blob: e53fc24c6af3e1b97ea95052dd383efc26138eb3 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * ipmi_kcs_sm.c
3 *
4 * State machine for handling IPMI KCS interfaces.
5 *
6 * Author: MontaVista Software, Inc.
7 * Corey Minyard <minyard@mvista.com>
8 * source@mvista.com
9 *
10 * Copyright 2002 MontaVista Software Inc.
11 *
12 * This program is free software; you can redistribute it and/or modify it
13 * under the terms of the GNU General Public License as published by the
14 * Free Software Foundation; either version 2 of the License, or (at your
15 * option) any later version.
16 *
17 *
18 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
19 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
20 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
23 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
24 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
26 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
27 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 *
29 * You should have received a copy of the GNU General Public License along
30 * with this program; if not, write to the Free Software Foundation, Inc.,
31 * 675 Mass Ave, Cambridge, MA 02139, USA.
32 */
33
34/*
35 * This state machine is taken from the state machine in the IPMI spec,
36 * pretty much verbatim. If you have questions about the states, see
37 * that document.
38 */
39
40#include <linux/kernel.h> /* For printk. */
Corey Minyardc4edff12005-11-07 00:59:56 -080041#include <linux/module.h>
42#include <linux/moduleparam.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include <linux/string.h>
Corey Minyardc3e7e792005-11-07 01:00:02 -080044#include <linux/jiffies.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#include <linux/ipmi_msgdefs.h> /* for completion codes */
46#include "ipmi_si_sm.h"
47
Corey Minyardc4edff12005-11-07 00:59:56 -080048/* kcs_debug is a bit-field
49 * KCS_DEBUG_ENABLE - turned on for now
50 * KCS_DEBUG_MSG - commands and their responses
51 * KCS_DEBUG_STATES - state machine
52 */
53#define KCS_DEBUG_STATES 4
54#define KCS_DEBUG_MSG 2
55#define KCS_DEBUG_ENABLE 1
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
Corey Minyardc4edff12005-11-07 00:59:56 -080057static int kcs_debug;
58module_param(kcs_debug, int, 0644);
59MODULE_PARM_DESC(kcs_debug, "debug bitmask, 1=enable, 2=messages, 4=states");
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
61/* The states the KCS driver may be in. */
62enum kcs_states {
Corey Minyardc305e3d2008-04-29 01:01:10 -070063 /* The KCS interface is currently doing nothing. */
64 KCS_IDLE,
65
66 /*
67 * We are starting an operation. The data is in the output
68 * buffer, but nothing has been done to the interface yet. This
69 * was added to the state machine in the spec to wait for the
70 * initial IBF.
71 */
72 KCS_START_OP,
73
74 /* We have written a write cmd to the interface. */
75 KCS_WAIT_WRITE_START,
76
77 /* We are writing bytes to the interface. */
78 KCS_WAIT_WRITE,
79
80 /*
81 * We have written the write end cmd to the interface, and
82 * still need to write the last byte.
83 */
84 KCS_WAIT_WRITE_END,
85
86 /* We are waiting to read data from the interface. */
87 KCS_WAIT_READ,
88
89 /*
90 * State to transition to the error handler, this was added to
91 * the state machine in the spec to be sure IBF was there.
92 */
93 KCS_ERROR0,
94
95 /*
96 * First stage error handler, wait for the interface to
97 * respond.
98 */
99 KCS_ERROR1,
100
101 /*
102 * The abort cmd has been written, wait for the interface to
103 * respond.
104 */
105 KCS_ERROR2,
106
107 /*
108 * We wrote some data to the interface, wait for it to switch
109 * to read mode.
110 */
111 KCS_ERROR3,
112
113 /* The hardware failed to follow the state machine. */
114 KCS_HOSED
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115};
116
Corey Minyard5a1099b2006-12-06 20:41:16 -0800117#define MAX_KCS_READ_SIZE IPMI_MAX_MSG_LENGTH
118#define MAX_KCS_WRITE_SIZE IPMI_MAX_MSG_LENGTH
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119
120/* Timeouts in microseconds. */
Matthew Garrett828dc9d2012-03-28 14:42:48 -0700121#define IBF_RETRY_TIMEOUT 5000000
122#define OBF_RETRY_TIMEOUT 5000000
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123#define MAX_ERROR_RETRIES 10
Corey Minyardc3e7e792005-11-07 01:00:02 -0800124#define ERROR0_OBF_WAIT_JIFFIES (2*HZ)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125
Corey Minyardc305e3d2008-04-29 01:01:10 -0700126struct si_sm_data {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 enum kcs_states state;
128 struct si_sm_io *io;
129 unsigned char write_data[MAX_KCS_WRITE_SIZE];
130 int write_pos;
131 int write_count;
132 int orig_write_count;
133 unsigned char read_data[MAX_KCS_READ_SIZE];
134 int read_pos;
135 int truncated;
136
137 unsigned int error_retries;
138 long ibf_timeout;
139 long obf_timeout;
Corey Minyardc3e7e792005-11-07 01:00:02 -0800140 unsigned long error0_timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141};
142
143static unsigned int init_kcs_data(struct si_sm_data *kcs,
144 struct si_sm_io *io)
145{
146 kcs->state = KCS_IDLE;
147 kcs->io = io;
148 kcs->write_pos = 0;
149 kcs->write_count = 0;
150 kcs->orig_write_count = 0;
151 kcs->read_pos = 0;
152 kcs->error_retries = 0;
153 kcs->truncated = 0;
154 kcs->ibf_timeout = IBF_RETRY_TIMEOUT;
155 kcs->obf_timeout = OBF_RETRY_TIMEOUT;
156
157 /* Reserve 2 I/O bytes. */
158 return 2;
159}
160
161static inline unsigned char read_status(struct si_sm_data *kcs)
162{
163 return kcs->io->inputb(kcs->io, 1);
164}
165
166static inline unsigned char read_data(struct si_sm_data *kcs)
167{
168 return kcs->io->inputb(kcs->io, 0);
169}
170
171static inline void write_cmd(struct si_sm_data *kcs, unsigned char data)
172{
173 kcs->io->outputb(kcs->io, 1, data);
174}
175
176static inline void write_data(struct si_sm_data *kcs, unsigned char data)
177{
178 kcs->io->outputb(kcs->io, 0, data);
179}
180
181/* Control codes. */
182#define KCS_GET_STATUS_ABORT 0x60
183#define KCS_WRITE_START 0x61
184#define KCS_WRITE_END 0x62
185#define KCS_READ_BYTE 0x68
186
187/* Status bits. */
188#define GET_STATUS_STATE(status) (((status) >> 6) & 0x03)
189#define KCS_IDLE_STATE 0
190#define KCS_READ_STATE 1
191#define KCS_WRITE_STATE 2
192#define KCS_ERROR_STATE 3
193#define GET_STATUS_ATN(status) ((status) & 0x04)
194#define GET_STATUS_IBF(status) ((status) & 0x02)
195#define GET_STATUS_OBF(status) ((status) & 0x01)
196
197
198static inline void write_next_byte(struct si_sm_data *kcs)
199{
200 write_data(kcs, kcs->write_data[kcs->write_pos]);
201 (kcs->write_pos)++;
202 (kcs->write_count)--;
203}
204
205static inline void start_error_recovery(struct si_sm_data *kcs, char *reason)
206{
207 (kcs->error_retries)++;
208 if (kcs->error_retries > MAX_ERROR_RETRIES) {
Corey Minyardc4edff12005-11-07 00:59:56 -0800209 if (kcs_debug & KCS_DEBUG_ENABLE)
Corey Minyardc305e3d2008-04-29 01:01:10 -0700210 printk(KERN_DEBUG "ipmi_kcs_sm: kcs hosed: %s\n",
211 reason);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 kcs->state = KCS_HOSED;
213 } else {
Corey Minyardc3e7e792005-11-07 01:00:02 -0800214 kcs->error0_timeout = jiffies + ERROR0_OBF_WAIT_JIFFIES;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 kcs->state = KCS_ERROR0;
216 }
217}
218
219static inline void read_next_byte(struct si_sm_data *kcs)
220{
221 if (kcs->read_pos >= MAX_KCS_READ_SIZE) {
222 /* Throw the data away and mark it truncated. */
223 read_data(kcs);
224 kcs->truncated = 1;
225 } else {
226 kcs->read_data[kcs->read_pos] = read_data(kcs);
227 (kcs->read_pos)++;
228 }
229 write_data(kcs, KCS_READ_BYTE);
230}
231
232static inline int check_ibf(struct si_sm_data *kcs, unsigned char status,
233 long time)
234{
235 if (GET_STATUS_IBF(status)) {
236 kcs->ibf_timeout -= time;
237 if (kcs->ibf_timeout < 0) {
238 start_error_recovery(kcs, "IBF not ready in time");
239 kcs->ibf_timeout = IBF_RETRY_TIMEOUT;
240 return 1;
241 }
242 return 0;
243 }
244 kcs->ibf_timeout = IBF_RETRY_TIMEOUT;
245 return 1;
246}
247
248static inline int check_obf(struct si_sm_data *kcs, unsigned char status,
249 long time)
250{
Corey Minyard8a3628d2006-03-31 02:30:40 -0800251 if (!GET_STATUS_OBF(status)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 kcs->obf_timeout -= time;
253 if (kcs->obf_timeout < 0) {
254 start_error_recovery(kcs, "OBF not ready in time");
255 return 1;
256 }
257 return 0;
258 }
259 kcs->obf_timeout = OBF_RETRY_TIMEOUT;
260 return 1;
261}
262
263static void clear_obf(struct si_sm_data *kcs, unsigned char status)
264{
265 if (GET_STATUS_OBF(status))
266 read_data(kcs);
267}
268
269static void restart_kcs_transaction(struct si_sm_data *kcs)
270{
271 kcs->write_count = kcs->orig_write_count;
272 kcs->write_pos = 0;
273 kcs->read_pos = 0;
274 kcs->state = KCS_WAIT_WRITE_START;
275 kcs->ibf_timeout = IBF_RETRY_TIMEOUT;
276 kcs->obf_timeout = OBF_RETRY_TIMEOUT;
277 write_cmd(kcs, KCS_WRITE_START);
278}
279
280static int start_kcs_transaction(struct si_sm_data *kcs, unsigned char *data,
281 unsigned int size)
282{
Corey Minyardc4edff12005-11-07 00:59:56 -0800283 unsigned int i;
284
Corey Minyard4d7cbac2006-12-06 20:41:14 -0800285 if (size < 2)
286 return IPMI_REQ_LEN_INVALID_ERR;
287 if (size > MAX_KCS_WRITE_SIZE)
288 return IPMI_REQ_LEN_EXCEEDED_ERR;
289
290 if ((kcs->state != KCS_IDLE) && (kcs->state != KCS_HOSED))
291 return IPMI_NOT_IN_MY_STATE_ERR;
292
Corey Minyardc4edff12005-11-07 00:59:56 -0800293 if (kcs_debug & KCS_DEBUG_MSG) {
294 printk(KERN_DEBUG "start_kcs_transaction -");
Corey Minyardc305e3d2008-04-29 01:01:10 -0700295 for (i = 0; i < size; i++)
Corey Minyardc4edff12005-11-07 00:59:56 -0800296 printk(" %02x", (unsigned char) (data [i]));
Corey Minyardc305e3d2008-04-29 01:01:10 -0700297 printk("\n");
Corey Minyardc4edff12005-11-07 00:59:56 -0800298 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 kcs->error_retries = 0;
300 memcpy(kcs->write_data, data, size);
301 kcs->write_count = size;
302 kcs->orig_write_count = size;
303 kcs->write_pos = 0;
304 kcs->read_pos = 0;
305 kcs->state = KCS_START_OP;
306 kcs->ibf_timeout = IBF_RETRY_TIMEOUT;
307 kcs->obf_timeout = OBF_RETRY_TIMEOUT;
308 return 0;
309}
310
311static int get_kcs_result(struct si_sm_data *kcs, unsigned char *data,
312 unsigned int length)
313{
314 if (length < kcs->read_pos) {
315 kcs->read_pos = length;
316 kcs->truncated = 1;
317 }
318
319 memcpy(data, kcs->read_data, kcs->read_pos);
320
321 if ((length >= 3) && (kcs->read_pos < 3)) {
322 /* Guarantee that we return at least 3 bytes, with an
323 error in the third byte if it is too short. */
324 data[2] = IPMI_ERR_UNSPECIFIED;
325 kcs->read_pos = 3;
326 }
327 if (kcs->truncated) {
Corey Minyardc305e3d2008-04-29 01:01:10 -0700328 /*
329 * Report a truncated error. We might overwrite
330 * another error, but that's too bad, the user needs
331 * to know it was truncated.
332 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 data[2] = IPMI_ERR_MSG_TRUNCATED;
334 kcs->truncated = 0;
335 }
336
337 return kcs->read_pos;
338}
339
Corey Minyardc305e3d2008-04-29 01:01:10 -0700340/*
341 * This implements the state machine defined in the IPMI manual, see
342 * that for details on how this works. Divide that flowchart into
343 * sections delimited by "Wait for IBF" and this will become clear.
344 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time)
346{
347 unsigned char status;
348 unsigned char state;
349
350 status = read_status(kcs);
351
Corey Minyardc4edff12005-11-07 00:59:56 -0800352 if (kcs_debug & KCS_DEBUG_STATES)
353 printk(KERN_DEBUG "KCS: State = %d, %x\n", kcs->state, status);
354
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 /* All states wait for ibf, so just do it here. */
356 if (!check_ibf(kcs, status, time))
357 return SI_SM_CALL_WITH_DELAY;
358
359 /* Just about everything looks at the KCS state, so grab that, too. */
360 state = GET_STATUS_STATE(status);
361
362 switch (kcs->state) {
363 case KCS_IDLE:
364 /* If there's and interrupt source, turn it off. */
365 clear_obf(kcs, status);
366
367 if (GET_STATUS_ATN(status))
368 return SI_SM_ATTN;
369 else
370 return SI_SM_IDLE;
371
372 case KCS_START_OP:
Julia Lawalld1da96a2009-12-15 16:47:37 -0800373 if (state != KCS_IDLE_STATE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 start_error_recovery(kcs,
375 "State machine not idle at start");
376 break;
377 }
378
379 clear_obf(kcs, status);
380 write_cmd(kcs, KCS_WRITE_START);
381 kcs->state = KCS_WAIT_WRITE_START;
382 break;
383
384 case KCS_WAIT_WRITE_START:
385 if (state != KCS_WRITE_STATE) {
386 start_error_recovery(
387 kcs,
388 "Not in write state at write start");
389 break;
390 }
391 read_data(kcs);
392 if (kcs->write_count == 1) {
393 write_cmd(kcs, KCS_WRITE_END);
394 kcs->state = KCS_WAIT_WRITE_END;
395 } else {
396 write_next_byte(kcs);
397 kcs->state = KCS_WAIT_WRITE;
398 }
399 break;
400
401 case KCS_WAIT_WRITE:
402 if (state != KCS_WRITE_STATE) {
403 start_error_recovery(kcs,
404 "Not in write state for write");
405 break;
406 }
407 clear_obf(kcs, status);
408 if (kcs->write_count == 1) {
409 write_cmd(kcs, KCS_WRITE_END);
410 kcs->state = KCS_WAIT_WRITE_END;
411 } else {
412 write_next_byte(kcs);
413 }
414 break;
Corey Minyardc305e3d2008-04-29 01:01:10 -0700415
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 case KCS_WAIT_WRITE_END:
417 if (state != KCS_WRITE_STATE) {
418 start_error_recovery(kcs,
Corey Minyardc305e3d2008-04-29 01:01:10 -0700419 "Not in write state"
420 " for write end");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 break;
422 }
423 clear_obf(kcs, status);
424 write_next_byte(kcs);
425 kcs->state = KCS_WAIT_READ;
426 break;
427
428 case KCS_WAIT_READ:
429 if ((state != KCS_READ_STATE) && (state != KCS_IDLE_STATE)) {
430 start_error_recovery(
431 kcs,
432 "Not in read or idle in read state");
433 break;
434 }
435
436 if (state == KCS_READ_STATE) {
Corey Minyard8a3628d2006-03-31 02:30:40 -0800437 if (!check_obf(kcs, status, time))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 return SI_SM_CALL_WITH_DELAY;
439 read_next_byte(kcs);
440 } else {
Corey Minyardc305e3d2008-04-29 01:01:10 -0700441 /*
442 * We don't implement this exactly like the state
443 * machine in the spec. Some broken hardware
444 * does not write the final dummy byte to the
445 * read register. Thus obf will never go high
446 * here. We just go straight to idle, and we
447 * handle clearing out obf in idle state if it
448 * happens to come in.
449 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 clear_obf(kcs, status);
451 kcs->orig_write_count = 0;
452 kcs->state = KCS_IDLE;
453 return SI_SM_TRANSACTION_COMPLETE;
454 }
455 break;
456
457 case KCS_ERROR0:
458 clear_obf(kcs, status);
Corey Minyardc3e7e792005-11-07 01:00:02 -0800459 status = read_status(kcs);
Corey Minyardc305e3d2008-04-29 01:01:10 -0700460 if (GET_STATUS_OBF(status))
461 /* controller isn't responding */
Corey Minyardc3e7e792005-11-07 01:00:02 -0800462 if (time_before(jiffies, kcs->error0_timeout))
463 return SI_SM_CALL_WITH_TICK_DELAY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 write_cmd(kcs, KCS_GET_STATUS_ABORT);
465 kcs->state = KCS_ERROR1;
466 break;
467
468 case KCS_ERROR1:
469 clear_obf(kcs, status);
470 write_data(kcs, 0);
471 kcs->state = KCS_ERROR2;
472 break;
Corey Minyardc305e3d2008-04-29 01:01:10 -0700473
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 case KCS_ERROR2:
475 if (state != KCS_READ_STATE) {
476 start_error_recovery(kcs,
477 "Not in read state for error2");
478 break;
479 }
Corey Minyard8a3628d2006-03-31 02:30:40 -0800480 if (!check_obf(kcs, status, time))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 return SI_SM_CALL_WITH_DELAY;
482
483 clear_obf(kcs, status);
484 write_data(kcs, KCS_READ_BYTE);
485 kcs->state = KCS_ERROR3;
486 break;
Corey Minyardc305e3d2008-04-29 01:01:10 -0700487
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 case KCS_ERROR3:
489 if (state != KCS_IDLE_STATE) {
490 start_error_recovery(kcs,
491 "Not in idle state for error3");
492 break;
493 }
494
Corey Minyard8a3628d2006-03-31 02:30:40 -0800495 if (!check_obf(kcs, status, time))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 return SI_SM_CALL_WITH_DELAY;
497
498 clear_obf(kcs, status);
499 if (kcs->orig_write_count) {
500 restart_kcs_transaction(kcs);
501 } else {
502 kcs->state = KCS_IDLE;
503 return SI_SM_TRANSACTION_COMPLETE;
504 }
505 break;
Corey Minyardc305e3d2008-04-29 01:01:10 -0700506
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 case KCS_HOSED:
508 break;
509 }
510
511 if (kcs->state == KCS_HOSED) {
512 init_kcs_data(kcs, kcs->io);
513 return SI_SM_HOSED;
514 }
515
516 return SI_SM_CALL_WITHOUT_DELAY;
517}
518
519static int kcs_size(void)
520{
521 return sizeof(struct si_sm_data);
522}
523
524static int kcs_detect(struct si_sm_data *kcs)
525{
Corey Minyardc305e3d2008-04-29 01:01:10 -0700526 /*
527 * It's impossible for the KCS status register to be all 1's,
528 * (assuming a properly functioning, self-initialized BMC)
529 * but that's what you get from reading a bogus address, so we
530 * test that first.
531 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 if (read_status(kcs) == 0xff)
533 return 1;
534
535 return 0;
536}
537
538static void kcs_cleanup(struct si_sm_data *kcs)
539{
540}
541
Corey Minyardc305e3d2008-04-29 01:01:10 -0700542struct si_sm_handlers kcs_smi_handlers = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 .init_data = init_kcs_data,
544 .start_transaction = start_kcs_transaction,
545 .get_result = get_kcs_result,
546 .event = kcs_event,
547 .detect = kcs_detect,
548 .cleanup = kcs_cleanup,
549 .size = kcs_size,
550};