Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ipmi_kcs_sm.c
Go to the documentation of this file.
1 /*
2  * ipmi_kcs_sm.c
3  *
4  * State machine for handling IPMI KCS interfaces.
5  *
6  * Author: MontaVista Software, Inc.
7  * Corey Minyard <[email protected]>
8  * [email protected]
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 5000000
122 #define OBF_RETRY_TIMEOUT 5000000
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_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 
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 };
Generated on Thu Jan 10 2013 13:27:43 for Linux Kernel by   doxygen 1.8.2