Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/x86/linux...
[linux-2.6] / drivers / char / ipmi / ipmi_kcs_sm.c
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
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
161 static inline unsigned char read_status(struct si_sm_data *kcs)
162 {
163         return kcs->io->inputb(kcs->io, 1);
164 }
165
166 static inline unsigned char read_data(struct si_sm_data *kcs)
167 {
168         return kcs->io->inputb(kcs->io, 0);
169 }
170
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
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
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
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
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
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
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
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
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
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
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  */
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) {
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
519 static int kcs_size(void)
520 {
521         return sizeof(struct si_sm_data);
522 }
523
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
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 };