Pull altix-mmr into release branch
[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/string.h>
42 #include <linux/ipmi_msgdefs.h>         /* for completion codes */
43 #include "ipmi_si_sm.h"
44
45 /* Set this if you want a printout of why the state machine was hosed
46    when it gets hosed. */
47 #define DEBUG_HOSED_REASON
48
49 /* Print the state machine state on entry every time. */
50 #undef DEBUG_STATE
51
52 /* The states the KCS driver may be in. */
53 enum kcs_states {
54         KCS_IDLE,               /* The KCS interface is currently
55                                    doing nothing. */
56         KCS_START_OP,           /* We are starting an operation.  The
57                                    data is in the output buffer, but
58                                    nothing has been done to the
59                                    interface yet.  This was added to
60                                    the state machine in the spec to
61                                    wait for the initial IBF. */
62         KCS_WAIT_WRITE_START,   /* We have written a write cmd to the
63                                    interface. */
64         KCS_WAIT_WRITE,         /* We are writing bytes to the
65                                    interface. */
66         KCS_WAIT_WRITE_END,     /* We have written the write end cmd
67                                    to the interface, and still need to
68                                    write the last byte. */
69         KCS_WAIT_READ,          /* We are waiting to read data from
70                                    the interface. */
71         KCS_ERROR0,             /* State to transition to the error
72                                    handler, this was added to the
73                                    state machine in the spec to be
74                                    sure IBF was there. */
75         KCS_ERROR1,             /* First stage error handler, wait for
76                                    the interface to respond. */
77         KCS_ERROR2,             /* The abort cmd has been written,
78                                    wait for the interface to
79                                    respond. */
80         KCS_ERROR3,             /* We wrote some data to the
81                                    interface, wait for it to switch to
82                                    read mode. */
83         KCS_HOSED               /* The hardware failed to follow the
84                                    state machine. */
85 };
86
87 #define MAX_KCS_READ_SIZE 80
88 #define MAX_KCS_WRITE_SIZE 80
89
90 /* Timeouts in microseconds. */
91 #define IBF_RETRY_TIMEOUT 1000000
92 #define OBF_RETRY_TIMEOUT 1000000
93 #define MAX_ERROR_RETRIES 10
94
95 struct si_sm_data
96 {
97         enum kcs_states  state;
98         struct si_sm_io *io;
99         unsigned char    write_data[MAX_KCS_WRITE_SIZE];
100         int              write_pos;
101         int              write_count;
102         int              orig_write_count;
103         unsigned char    read_data[MAX_KCS_READ_SIZE];
104         int              read_pos;
105         int              truncated;
106
107         unsigned int  error_retries;
108         long          ibf_timeout;
109         long          obf_timeout;
110 };
111
112 static unsigned int init_kcs_data(struct si_sm_data *kcs,
113                                   struct si_sm_io *io)
114 {
115         kcs->state = KCS_IDLE;
116         kcs->io = io;
117         kcs->write_pos = 0;
118         kcs->write_count = 0;
119         kcs->orig_write_count = 0;
120         kcs->read_pos = 0;
121         kcs->error_retries = 0;
122         kcs->truncated = 0;
123         kcs->ibf_timeout = IBF_RETRY_TIMEOUT;
124         kcs->obf_timeout = OBF_RETRY_TIMEOUT;
125
126         /* Reserve 2 I/O bytes. */
127         return 2;
128 }
129
130 static inline unsigned char read_status(struct si_sm_data *kcs)
131 {
132         return kcs->io->inputb(kcs->io, 1);
133 }
134
135 static inline unsigned char read_data(struct si_sm_data *kcs)
136 {
137         return kcs->io->inputb(kcs->io, 0);
138 }
139
140 static inline void write_cmd(struct si_sm_data *kcs, unsigned char data)
141 {
142         kcs->io->outputb(kcs->io, 1, data);
143 }
144
145 static inline void write_data(struct si_sm_data *kcs, unsigned char data)
146 {
147         kcs->io->outputb(kcs->io, 0, data);
148 }
149
150 /* Control codes. */
151 #define KCS_GET_STATUS_ABORT    0x60
152 #define KCS_WRITE_START         0x61
153 #define KCS_WRITE_END           0x62
154 #define KCS_READ_BYTE           0x68
155
156 /* Status bits. */
157 #define GET_STATUS_STATE(status) (((status) >> 6) & 0x03)
158 #define KCS_IDLE_STATE  0
159 #define KCS_READ_STATE  1
160 #define KCS_WRITE_STATE 2
161 #define KCS_ERROR_STATE 3
162 #define GET_STATUS_ATN(status) ((status) & 0x04)
163 #define GET_STATUS_IBF(status) ((status) & 0x02)
164 #define GET_STATUS_OBF(status) ((status) & 0x01)
165
166
167 static inline void write_next_byte(struct si_sm_data *kcs)
168 {
169         write_data(kcs, kcs->write_data[kcs->write_pos]);
170         (kcs->write_pos)++;
171         (kcs->write_count)--;
172 }
173
174 static inline void start_error_recovery(struct si_sm_data *kcs, char *reason)
175 {
176         (kcs->error_retries)++;
177         if (kcs->error_retries > MAX_ERROR_RETRIES) {
178 #ifdef DEBUG_HOSED_REASON
179                 printk("ipmi_kcs_sm: kcs hosed: %s\n", reason);
180 #endif
181                 kcs->state = KCS_HOSED;
182         } else {
183                 kcs->state = KCS_ERROR0;
184         }
185 }
186
187 static inline void read_next_byte(struct si_sm_data *kcs)
188 {
189         if (kcs->read_pos >= MAX_KCS_READ_SIZE) {
190                 /* Throw the data away and mark it truncated. */
191                 read_data(kcs);
192                 kcs->truncated = 1;
193         } else {
194                 kcs->read_data[kcs->read_pos] = read_data(kcs);
195                 (kcs->read_pos)++;
196         }
197         write_data(kcs, KCS_READ_BYTE);
198 }
199
200 static inline int check_ibf(struct si_sm_data *kcs, unsigned char status,
201                             long time)
202 {
203         if (GET_STATUS_IBF(status)) {
204                 kcs->ibf_timeout -= time;
205                 if (kcs->ibf_timeout < 0) {
206                         start_error_recovery(kcs, "IBF not ready in time");
207                         kcs->ibf_timeout = IBF_RETRY_TIMEOUT;
208                         return 1;
209                 }
210                 return 0;
211         }
212         kcs->ibf_timeout = IBF_RETRY_TIMEOUT;
213         return 1;
214 }
215
216 static inline int check_obf(struct si_sm_data *kcs, unsigned char status,
217                             long time)
218 {
219         if (! GET_STATUS_OBF(status)) {
220                 kcs->obf_timeout -= time;
221                 if (kcs->obf_timeout < 0) {
222                     start_error_recovery(kcs, "OBF not ready in time");
223                     return 1;
224                 }
225                 return 0;
226         }
227         kcs->obf_timeout = OBF_RETRY_TIMEOUT;
228         return 1;
229 }
230
231 static void clear_obf(struct si_sm_data *kcs, unsigned char status)
232 {
233         if (GET_STATUS_OBF(status))
234                 read_data(kcs);
235 }
236
237 static void restart_kcs_transaction(struct si_sm_data *kcs)
238 {
239         kcs->write_count = kcs->orig_write_count;
240         kcs->write_pos = 0;
241         kcs->read_pos = 0;
242         kcs->state = KCS_WAIT_WRITE_START;
243         kcs->ibf_timeout = IBF_RETRY_TIMEOUT;
244         kcs->obf_timeout = OBF_RETRY_TIMEOUT;
245         write_cmd(kcs, KCS_WRITE_START);
246 }
247
248 static int start_kcs_transaction(struct si_sm_data *kcs, unsigned char *data,
249                                  unsigned int size)
250 {
251         if ((size < 2) || (size > MAX_KCS_WRITE_SIZE)) {
252                 return -1;
253         }
254
255         if ((kcs->state != KCS_IDLE) && (kcs->state != KCS_HOSED)) {
256                 return -2;
257         }
258
259         kcs->error_retries = 0;
260         memcpy(kcs->write_data, data, size);
261         kcs->write_count = size;
262         kcs->orig_write_count = size;
263         kcs->write_pos = 0;
264         kcs->read_pos = 0;
265         kcs->state = KCS_START_OP;
266         kcs->ibf_timeout = IBF_RETRY_TIMEOUT;
267         kcs->obf_timeout = OBF_RETRY_TIMEOUT;
268         return 0;
269 }
270
271 static int get_kcs_result(struct si_sm_data *kcs, unsigned char *data,
272                           unsigned int length)
273 {
274         if (length < kcs->read_pos) {
275                 kcs->read_pos = length;
276                 kcs->truncated = 1;
277         }
278
279         memcpy(data, kcs->read_data, kcs->read_pos);
280
281         if ((length >= 3) && (kcs->read_pos < 3)) {
282                 /* Guarantee that we return at least 3 bytes, with an
283                    error in the third byte if it is too short. */
284                 data[2] = IPMI_ERR_UNSPECIFIED;
285                 kcs->read_pos = 3;
286         }
287         if (kcs->truncated) {
288                 /* Report a truncated error.  We might overwrite
289                    another error, but that's too bad, the user needs
290                    to know it was truncated. */
291                 data[2] = IPMI_ERR_MSG_TRUNCATED;
292                 kcs->truncated = 0;
293         }
294
295         return kcs->read_pos;
296 }
297
298 /* This implements the state machine defined in the IPMI manual, see
299    that for details on how this works.  Divide that flowchart into
300    sections delimited by "Wait for IBF" and this will become clear. */
301 static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time)
302 {
303         unsigned char status;
304         unsigned char state;
305
306         status = read_status(kcs);
307
308 #ifdef DEBUG_STATE
309         printk("  State = %d, %x\n", kcs->state, status);
310 #endif
311         /* All states wait for ibf, so just do it here. */
312         if (!check_ibf(kcs, status, time))
313                 return SI_SM_CALL_WITH_DELAY;
314
315         /* Just about everything looks at the KCS state, so grab that, too. */
316         state = GET_STATUS_STATE(status);
317
318         switch (kcs->state) {
319         case KCS_IDLE:
320                 /* If there's and interrupt source, turn it off. */
321                 clear_obf(kcs, status);
322
323                 if (GET_STATUS_ATN(status))
324                         return SI_SM_ATTN;
325                 else
326                         return SI_SM_IDLE;
327
328         case KCS_START_OP:
329                 if (state != KCS_IDLE) {
330                         start_error_recovery(kcs,
331                                              "State machine not idle at start");
332                         break;
333                 }
334
335                 clear_obf(kcs, status);
336                 write_cmd(kcs, KCS_WRITE_START);
337                 kcs->state = KCS_WAIT_WRITE_START;
338                 break;
339
340         case KCS_WAIT_WRITE_START:
341                 if (state != KCS_WRITE_STATE) {
342                         start_error_recovery(
343                                 kcs,
344                                 "Not in write state at write start");
345                         break;
346                 }
347                 read_data(kcs);
348                 if (kcs->write_count == 1) {
349                         write_cmd(kcs, KCS_WRITE_END);
350                         kcs->state = KCS_WAIT_WRITE_END;
351                 } else {
352                         write_next_byte(kcs);
353                         kcs->state = KCS_WAIT_WRITE;
354                 }
355                 break;
356
357         case KCS_WAIT_WRITE:
358                 if (state != KCS_WRITE_STATE) {
359                         start_error_recovery(kcs,
360                                              "Not in write state for write");
361                         break;
362                 }
363                 clear_obf(kcs, status);
364                 if (kcs->write_count == 1) {
365                         write_cmd(kcs, KCS_WRITE_END);
366                         kcs->state = KCS_WAIT_WRITE_END;
367                 } else {
368                         write_next_byte(kcs);
369                 }
370                 break;
371                 
372         case KCS_WAIT_WRITE_END:
373                 if (state != KCS_WRITE_STATE) {
374                         start_error_recovery(kcs,
375                                              "Not in write state for write end");
376                         break;
377                 }
378                 clear_obf(kcs, status);
379                 write_next_byte(kcs);
380                 kcs->state = KCS_WAIT_READ;
381                 break;
382
383         case KCS_WAIT_READ:
384                 if ((state != KCS_READ_STATE) && (state != KCS_IDLE_STATE)) {
385                         start_error_recovery(
386                                 kcs,
387                                 "Not in read or idle in read state");
388                         break;
389                 }
390
391                 if (state == KCS_READ_STATE) {
392                         if (! check_obf(kcs, status, time))
393                                 return SI_SM_CALL_WITH_DELAY;
394                         read_next_byte(kcs);
395                 } else {
396                         /* We don't implement this exactly like the state
397                            machine in the spec.  Some broken hardware
398                            does not write the final dummy byte to the
399                            read register.  Thus obf will never go high
400                            here.  We just go straight to idle, and we
401                            handle clearing out obf in idle state if it
402                            happens to come in. */
403                         clear_obf(kcs, status);
404                         kcs->orig_write_count = 0;
405                         kcs->state = KCS_IDLE;
406                         return SI_SM_TRANSACTION_COMPLETE;
407                 }
408                 break;
409
410         case KCS_ERROR0:
411                 clear_obf(kcs, status);
412                 write_cmd(kcs, KCS_GET_STATUS_ABORT);
413                 kcs->state = KCS_ERROR1;
414                 break;
415
416         case KCS_ERROR1:
417                 clear_obf(kcs, status);
418                 write_data(kcs, 0);
419                 kcs->state = KCS_ERROR2;
420                 break;
421                 
422         case KCS_ERROR2:
423                 if (state != KCS_READ_STATE) {
424                         start_error_recovery(kcs,
425                                              "Not in read state for error2");
426                         break;
427                 }
428                 if (! check_obf(kcs, status, time))
429                         return SI_SM_CALL_WITH_DELAY;
430
431                 clear_obf(kcs, status);
432                 write_data(kcs, KCS_READ_BYTE);
433                 kcs->state = KCS_ERROR3;
434                 break;
435                 
436         case KCS_ERROR3:
437                 if (state != KCS_IDLE_STATE) {
438                         start_error_recovery(kcs,
439                                              "Not in idle state for error3");
440                         break;
441                 }
442
443                 if (! check_obf(kcs, status, time))
444                         return SI_SM_CALL_WITH_DELAY;
445
446                 clear_obf(kcs, status);
447                 if (kcs->orig_write_count) {
448                         restart_kcs_transaction(kcs);
449                 } else {
450                         kcs->state = KCS_IDLE;
451                         return SI_SM_TRANSACTION_COMPLETE;
452                 }
453                 break;
454                         
455         case KCS_HOSED:
456                 break;
457         }
458
459         if (kcs->state == KCS_HOSED) {
460                 init_kcs_data(kcs, kcs->io);
461                 return SI_SM_HOSED;
462         }
463
464         return SI_SM_CALL_WITHOUT_DELAY;
465 }
466
467 static int kcs_size(void)
468 {
469         return sizeof(struct si_sm_data);
470 }
471
472 static int kcs_detect(struct si_sm_data *kcs)
473 {
474         /* It's impossible for the KCS status register to be all 1's,
475            (assuming a properly functioning, self-initialized BMC)
476            but that's what you get from reading a bogus address, so we
477            test that first. */
478         if (read_status(kcs) == 0xff)
479                 return 1;
480
481         return 0;
482 }
483
484 static void kcs_cleanup(struct si_sm_data *kcs)
485 {
486 }
487
488 struct si_sm_handlers kcs_smi_handlers =
489 {
490         .init_data         = init_kcs_data,
491         .start_transaction = start_kcs_transaction,
492         .get_result        = get_kcs_result,
493         .event             = kcs_event,
494         .detect            = kcs_detect,
495         .cleanup           = kcs_cleanup,
496         .size              = kcs_size,
497 };