1 /*
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. */
41 #include <linux/module.h>
42 #include <linux/moduleparam.h>
43 #include <linux/string.h>
44 #include <linux/jiffies.h>
45 #include <linux/ipmi_msgdefs.h> /* for completion codes */
46 #include "ipmi_si_sm.h"
47
48 /* 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
56
57 static int kcs_debug;
58 module_param(kcs_debug, int, 0644);
59 MODULE_PARM_DESC(kcs_debug, "debug bitmask, 1=enable, 2=messages, 4=states");
60
61 /* The states the KCS driver may be in. */
62 enum kcs_states {
63 /* 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
115 };
116
117 #define MAX_KCS_READ_SIZE IPMI_MAX_MSG_LENGTH
118 #define MAX_KCS_WRITE_SIZE IPMI_MAX_MSG_LENGTH
119
120 /* Timeouts in microseconds. */
121 #define IBF_RETRY_TIMEOUT 1000000
122 #define OBF_RETRY_TIMEOUT 1000000
123 #define MAX_ERROR_RETRIES 10
124 #define ERROR0_OBF_WAIT_JIFFIES (2*HZ)
125
126 struct si_sm_data {
127 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;
140 unsigned long error0_timeout;
141 };
142
init_kcs_data(struct si_sm_data * kcs,struct si_sm_io * io)143 static 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
read_status(struct si_sm_data * kcs)161 static inline unsigned char read_status(struct si_sm_data *kcs)
162 {
163 return kcs->io->inputb(kcs->io, 1);
164 }
165
read_data(struct si_sm_data * kcs)166 static inline unsigned char read_data(struct si_sm_data *kcs)
167 {
168 return kcs->io->inputb(kcs->io, 0);
169 }
170
write_cmd(struct si_sm_data * kcs,unsigned char data)171 static inline void write_cmd(struct si_sm_data *kcs, unsigned char data)
172 {
173 kcs->io->outputb(kcs->io, 1, data);
174 }
175
write_data(struct si_sm_data * kcs,unsigned char data)176 static 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
write_next_byte(struct si_sm_data * kcs)198 static 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
start_error_recovery(struct si_sm_data * kcs,char * reason)205 static 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) {
209 if (kcs_debug & KCS_DEBUG_ENABLE)
210 printk(KERN_DEBUG "ipmi_kcs_sm: kcs hosed: %s\n",
211 reason);
212 kcs->state = KCS_HOSED;
213 } else {
214 kcs->error0_timeout = jiffies + ERROR0_OBF_WAIT_JIFFIES;
215 kcs->state = KCS_ERROR0;
216 }
217 }
218
read_next_byte(struct si_sm_data * kcs)219 static 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
check_ibf(struct si_sm_data * kcs,unsigned char status,long time)232 static 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
check_obf(struct si_sm_data * kcs,unsigned char status,long time)248 static inline int check_obf(struct si_sm_data *kcs, unsigned char status,
249 long time)
250 {
251 if (!GET_STATUS_OBF(status)) {
252 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
clear_obf(struct si_sm_data * kcs,unsigned char status)263 static void clear_obf(struct si_sm_data *kcs, unsigned char status)
264 {
265 if (GET_STATUS_OBF(status))
266 read_data(kcs);
267 }
268
restart_kcs_transaction(struct si_sm_data * kcs)269 static 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
start_kcs_transaction(struct si_sm_data * kcs,unsigned char * data,unsigned int size)280 static int start_kcs_transaction(struct si_sm_data *kcs, unsigned char *data,
281 unsigned int size)
282 {
283 unsigned int i;
284
285 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
293 if (kcs_debug & KCS_DEBUG_MSG) {
294 printk(KERN_DEBUG "start_kcs_transaction -");
295 for (i = 0; i < size; i++)
296 printk(" %02x", (unsigned char) (data [i]));
297 printk("\n");
298 }
299 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
get_kcs_result(struct si_sm_data * kcs,unsigned char * data,unsigned int length)311 static 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) {
328 /*
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 */
333 data[2] = IPMI_ERR_MSG_TRUNCATED;
334 kcs->truncated = 0;
335 }
336
337 return kcs->read_pos;
338 }
339
340 /*
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 */
kcs_event(struct si_sm_data * kcs,long time)345 static 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
352 if (kcs_debug & KCS_DEBUG_STATES)
353 printk(KERN_DEBUG "KCS: State = %d, %x\n", kcs->state, status);
354
355 /* 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:
373 if (state != KCS_IDLE_STATE) {
374 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;
415
416 case KCS_WAIT_WRITE_END:
417 if (state != KCS_WRITE_STATE) {
418 start_error_recovery(kcs,
419 "Not in write state"
420 " for write end");
421 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) {
437 if (!check_obf(kcs, status, time))
438 return SI_SM_CALL_WITH_DELAY;
439 read_next_byte(kcs);
440 } else {
441 /*
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 */
450 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);
459 status = read_status(kcs);
460 if (GET_STATUS_OBF(status))
461 /* controller isn't responding */
462 if (time_before(jiffies, kcs->error0_timeout))
463 return SI_SM_CALL_WITH_TICK_DELAY;
464 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;
473
474 case KCS_ERROR2:
475 if (state != KCS_READ_STATE) {
476 start_error_recovery(kcs,
477 "Not in read state for error2");
478 break;
479 }
480 if (!check_obf(kcs, status, time))
481 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;
487
488 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
495 if (!check_obf(kcs, status, time))
496 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;
506
507 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
kcs_size(void)519 static int kcs_size(void)
520 {
521 return sizeof(struct si_sm_data);
522 }
523
kcs_detect(struct si_sm_data * kcs)524 static int kcs_detect(struct si_sm_data *kcs)
525 {
526 /*
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 */
532 if (read_status(kcs) == 0xff)
533 return 1;
534
535 return 0;
536 }
537
kcs_cleanup(struct si_sm_data * kcs)538 static void kcs_cleanup(struct si_sm_data *kcs)
539 {
540 }
541
542 struct si_sm_handlers kcs_smi_handlers = {
543 .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 };
551