Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ipmi_bt_sm.c
Go to the documentation of this file.
1 /*
2  * ipmi_bt_sm.c
3  *
4  * The state machine for an Open IPMI BT sub-driver under ipmi_si.c, part
5  * of the driver architecture at http://sourceforge.net/projects/openipmi
6  *
7  * Author: Rocky Craig <[email protected]>
8  *
9  * This program is free software; you can redistribute it and/or modify it
10  * under the terms of the GNU General Public License as published by the
11  * Free Software Foundation; either version 2 of the License, or (at your
12  * option) any later version.
13  *
14  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
15  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
16  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
19  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
20  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
21  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
22  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
23  * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  *
25  * You should have received a copy of the GNU General Public License along
26  * with this program; if not, write to the Free Software Foundation, Inc.,
27  * 675 Mass Ave, Cambridge, MA 02139, USA. */
28 
29 #include <linux/kernel.h> /* For printk. */
30 #include <linux/string.h>
31 #include <linux/module.h>
32 #include <linux/moduleparam.h>
33 #include <linux/ipmi_msgdefs.h> /* for completion codes */
34 #include "ipmi_si_sm.h"
35 
36 #define BT_DEBUG_OFF 0 /* Used in production */
37 #define BT_DEBUG_ENABLE 1 /* Generic messages */
38 #define BT_DEBUG_MSG 2 /* Prints all request/response buffers */
39 #define BT_DEBUG_STATES 4 /* Verbose look at state changes */
40 /*
41  * BT_DEBUG_OFF must be zero to correspond to the default uninitialized
42  * value
43  */
44 
45 static int bt_debug; /* 0 == BT_DEBUG_OFF */
46 
47 module_param(bt_debug, int, 0644);
48 MODULE_PARM_DESC(bt_debug, "debug bitmask, 1=enable, 2=messages, 4=states");
49 
50 /*
51  * Typical "Get BT Capabilities" values are 2-3 retries, 5-10 seconds,
52  * and 64 byte buffers. However, one HP implementation wants 255 bytes of
53  * buffer (with a documented message of 160 bytes) so go for the max.
54  * Since the Open IPMI architecture is single-message oriented at this
55  * stage, the queue depth of BT is of no concern.
56  */
57 
58 #define BT_NORMAL_TIMEOUT 5 /* seconds */
59 #define BT_NORMAL_RETRY_LIMIT 2
60 #define BT_RESET_DELAY 6 /* seconds after warm reset */
61 
62 /*
63  * States are written in chronological order and usually cover
64  * multiple rows of the state table discussion in the IPMI spec.
65  */
66 
67 enum bt_states {
68  BT_STATE_IDLE = 0, /* Order is critical in this list */
75  BT_STATE_RESET1, /* These must come last */
82  BT_STATE_LONG_BUSY /* BT doesn't get hosed :-) */
83 };
84 
85 /*
86  * Macros seen at the end of state "case" blocks. They help with legibility
87  * and debugging.
88  */
89 
90 #define BT_STATE_CHANGE(X, Y) { bt->state = X; return Y; }
91 
92 #define BT_SI_SM_RETURN(Y) { last_printed = BT_STATE_PRINTME; return Y; }
93 
94 struct si_sm_data {
96  unsigned char seq; /* BT sequence number */
97  struct si_sm_io *io;
103  long timeout; /* microseconds countdown */
104  int error_retries; /* end of "common" fields */
105  int nonzero_status; /* hung BMCs stay all 0 */
106  enum bt_states complete; /* to divert the state machine */
109  int BT_CAP_retries; /* Recommended retries */
110 };
111 
112 #define BT_CLR_WR_PTR 0x01 /* See IPMI 1.5 table 11.6.4 */
113 #define BT_CLR_RD_PTR 0x02
114 #define BT_H2B_ATN 0x04
115 #define BT_B2H_ATN 0x08
116 #define BT_SMS_ATN 0x10
117 #define BT_OEM0 0x20
118 #define BT_H_BUSY 0x40
119 #define BT_B_BUSY 0x80
120 
121 /*
122  * Some bits are toggled on each write: write once to set it, once
123  * more to clear it; writing a zero does nothing. To absolutely
124  * clear it, check its state and write if set. This avoids the "get
125  * current then use as mask" scheme to modify one bit. Note that the
126  * variable "bt" is hardcoded into these macros.
127  */
128 
129 #define BT_STATUS bt->io->inputb(bt->io, 0)
130 #define BT_CONTROL(x) bt->io->outputb(bt->io, 0, x)
131 
132 #define BMC2HOST bt->io->inputb(bt->io, 1)
133 #define HOST2BMC(x) bt->io->outputb(bt->io, 1, x)
134 
135 #define BT_INTMASK_R bt->io->inputb(bt->io, 2)
136 #define BT_INTMASK_W(x) bt->io->outputb(bt->io, 2, x)
137 
138 /*
139  * Convenience routines for debugging. These are not multi-open safe!
140  * Note the macros have hardcoded variables in them.
141  */
142 
143 static char *state2txt(unsigned char state)
144 {
145  switch (state) {
146  case BT_STATE_IDLE: return("IDLE");
147  case BT_STATE_XACTION_START: return("XACTION");
148  case BT_STATE_WRITE_BYTES: return("WR_BYTES");
149  case BT_STATE_WRITE_CONSUME: return("WR_CONSUME");
150  case BT_STATE_READ_WAIT: return("RD_WAIT");
151  case BT_STATE_CLEAR_B2H: return("CLEAR_B2H");
152  case BT_STATE_READ_BYTES: return("RD_BYTES");
153  case BT_STATE_RESET1: return("RESET1");
154  case BT_STATE_RESET2: return("RESET2");
155  case BT_STATE_RESET3: return("RESET3");
156  case BT_STATE_RESTART: return("RESTART");
157  case BT_STATE_LONG_BUSY: return("LONG_BUSY");
158  case BT_STATE_CAPABILITIES_BEGIN: return("CAP_BEGIN");
159  case BT_STATE_CAPABILITIES_END: return("CAP_END");
160  }
161  return("BAD STATE");
162 }
163 #define STATE2TXT state2txt(bt->state)
164 
165 static char *status2txt(unsigned char status)
166 {
167  /*
168  * This cannot be called by two threads at the same time and
169  * the buffer is always consumed immediately, so the static is
170  * safe to use.
171  */
172  static char buf[40];
173 
174  strcpy(buf, "[ ");
175  if (status & BT_B_BUSY)
176  strcat(buf, "B_BUSY ");
177  if (status & BT_H_BUSY)
178  strcat(buf, "H_BUSY ");
179  if (status & BT_OEM0)
180  strcat(buf, "OEM0 ");
181  if (status & BT_SMS_ATN)
182  strcat(buf, "SMS ");
183  if (status & BT_B2H_ATN)
184  strcat(buf, "B2H ");
185  if (status & BT_H2B_ATN)
186  strcat(buf, "H2B ");
187  strcat(buf, "]");
188  return buf;
189 }
190 #define STATUS2TXT status2txt(status)
191 
192 /* called externally at insmod time, and internally on cleanup */
193 
194 static unsigned int bt_init_data(struct si_sm_data *bt, struct si_sm_io *io)
195 {
196  memset(bt, 0, sizeof(struct si_sm_data));
197  if (bt->io != io) {
198  /* external: one-time only things */
199  bt->io = io;
200  bt->seq = 0;
201  }
202  bt->state = BT_STATE_IDLE; /* start here */
203  bt->complete = BT_STATE_IDLE; /* end here */
204  bt->BT_CAP_req2rsp = BT_NORMAL_TIMEOUT * 1000000;
206  /* BT_CAP_outreqs == zero is a flag to read BT Capabilities */
207  return 3; /* We claim 3 bytes of space; ought to check SPMI table */
208 }
209 
210 /* Jam a completion code (probably an error) into a response */
211 
212 static void force_result(struct si_sm_data *bt, unsigned char completion_code)
213 {
214  bt->read_data[0] = 4; /* # following bytes */
215  bt->read_data[1] = bt->write_data[1] | 4; /* Odd NetFn/LUN */
216  bt->read_data[2] = bt->write_data[2]; /* seq (ignored) */
217  bt->read_data[3] = bt->write_data[3]; /* Command */
218  bt->read_data[4] = completion_code;
219  bt->read_count = 5;
220 }
221 
222 /* The upper state machine starts here */
223 
224 static int bt_start_transaction(struct si_sm_data *bt,
225  unsigned char *data,
226  unsigned int size)
227 {
228  unsigned int i;
229 
230  if (size < 2)
232  if (size > IPMI_MAX_MSG_LENGTH)
234 
235  if (bt->state == BT_STATE_LONG_BUSY)
236  return IPMI_NODE_BUSY_ERR;
237 
238  if (bt->state != BT_STATE_IDLE)
240 
241  if (bt_debug & BT_DEBUG_MSG) {
242  printk(KERN_WARNING "BT: +++++++++++++++++ New command\n");
243  printk(KERN_WARNING "BT: NetFn/LUN CMD [%d data]:", size - 2);
244  for (i = 0; i < size; i ++)
245  printk(" %02x", data[i]);
246  printk("\n");
247  }
248  bt->write_data[0] = size + 1; /* all data plus seq byte */
249  bt->write_data[1] = *data; /* NetFn/LUN */
250  bt->write_data[2] = bt->seq++;
251  memcpy(bt->write_data + 3, data + 1, size - 1);
252  bt->write_count = size + 2;
253  bt->error_retries = 0;
254  bt->nonzero_status = 0;
255  bt->truncated = 0;
257  bt->timeout = bt->BT_CAP_req2rsp;
258  force_result(bt, IPMI_ERR_UNSPECIFIED);
259  return 0;
260 }
261 
262 /*
263  * After the upper state machine has been told SI_SM_TRANSACTION_COMPLETE
264  * it calls this. Strip out the length and seq bytes.
265  */
266 
267 static int bt_get_result(struct si_sm_data *bt,
268  unsigned char *data,
269  unsigned int length)
270 {
271  int i, msg_len;
272 
273  msg_len = bt->read_count - 2; /* account for length & seq */
274  if (msg_len < 3 || msg_len > IPMI_MAX_MSG_LENGTH) {
275  force_result(bt, IPMI_ERR_UNSPECIFIED);
276  msg_len = 3;
277  }
278  data[0] = bt->read_data[1];
279  data[1] = bt->read_data[3];
280  if (length < msg_len || bt->truncated) {
281  data[2] = IPMI_ERR_MSG_TRUNCATED;
282  msg_len = 3;
283  } else
284  memcpy(data + 2, bt->read_data + 4, msg_len - 2);
285 
286  if (bt_debug & BT_DEBUG_MSG) {
287  printk(KERN_WARNING "BT: result %d bytes:", msg_len);
288  for (i = 0; i < msg_len; i++)
289  printk(" %02x", data[i]);
290  printk("\n");
291  }
292  return msg_len;
293 }
294 
295 /* This bit's functionality is optional */
296 #define BT_BMC_HWRST 0x80
297 
298 static void reset_flags(struct si_sm_data *bt)
299 {
300  if (bt_debug)
301  printk(KERN_WARNING "IPMI BT: flag reset %s\n",
302  status2txt(BT_STATUS));
303  if (BT_STATUS & BT_H_BUSY)
304  BT_CONTROL(BT_H_BUSY); /* force clear */
305  BT_CONTROL(BT_CLR_WR_PTR); /* always reset */
306  BT_CONTROL(BT_SMS_ATN); /* always clear */
308 }
309 
310 /*
311  * Get rid of an unwanted/stale response. This should only be needed for
312  * BMCs that support multiple outstanding requests.
313  */
314 
315 static void drain_BMC2HOST(struct si_sm_data *bt)
316 {
317  int i, size;
318 
319  if (!(BT_STATUS & BT_B2H_ATN)) /* Not signalling a response */
320  return;
321 
322  BT_CONTROL(BT_H_BUSY); /* now set */
323  BT_CONTROL(BT_B2H_ATN); /* always clear */
324  BT_STATUS; /* pause */
325  BT_CONTROL(BT_B2H_ATN); /* some BMCs are stubborn */
326  BT_CONTROL(BT_CLR_RD_PTR); /* always reset */
327  if (bt_debug)
328  printk(KERN_WARNING "IPMI BT: stale response %s; ",
329  status2txt(BT_STATUS));
330  size = BMC2HOST;
331  for (i = 0; i < size ; i++)
332  BMC2HOST;
333  BT_CONTROL(BT_H_BUSY); /* now clear */
334  if (bt_debug)
335  printk("drained %d bytes\n", size + 1);
336 }
337 
338 static inline void write_all_bytes(struct si_sm_data *bt)
339 {
340  int i;
341 
342  if (bt_debug & BT_DEBUG_MSG) {
343  printk(KERN_WARNING "BT: write %d bytes seq=0x%02X",
344  bt->write_count, bt->seq);
345  for (i = 0; i < bt->write_count; i++)
346  printk(" %02x", bt->write_data[i]);
347  printk("\n");
348  }
349  for (i = 0; i < bt->write_count; i++)
350  HOST2BMC(bt->write_data[i]);
351 }
352 
353 static inline int read_all_bytes(struct si_sm_data *bt)
354 {
355  unsigned char i;
356 
357  /*
358  * length is "framing info", minimum = 4: NetFn, Seq, Cmd, cCode.
359  * Keep layout of first four bytes aligned with write_data[]
360  */
361 
362  bt->read_data[0] = BMC2HOST;
363  bt->read_count = bt->read_data[0];
364 
365  if (bt->read_count < 4 || bt->read_count >= IPMI_MAX_MSG_LENGTH) {
366  if (bt_debug & BT_DEBUG_MSG)
367  printk(KERN_WARNING "BT: bad raw rsp len=%d\n",
368  bt->read_count);
369  bt->truncated = 1;
370  return 1; /* let next XACTION START clean it up */
371  }
372  for (i = 1; i <= bt->read_count; i++)
373  bt->read_data[i] = BMC2HOST;
374  bt->read_count++; /* Account internally for length byte */
375 
376  if (bt_debug & BT_DEBUG_MSG) {
377  int max = bt->read_count;
378 
379  printk(KERN_WARNING "BT: got %d bytes seq=0x%02X",
380  max, bt->read_data[2]);
381  if (max > 16)
382  max = 16;
383  for (i = 0; i < max; i++)
384  printk(KERN_CONT " %02x", bt->read_data[i]);
385  printk(KERN_CONT "%s\n", bt->read_count == max ? "" : " ...");
386  }
387 
388  /* per the spec, the (NetFn[1], Seq[2], Cmd[3]) tuples must match */
389  if ((bt->read_data[3] == bt->write_data[3]) &&
390  (bt->read_data[2] == bt->write_data[2]) &&
391  ((bt->read_data[1] & 0xF8) == (bt->write_data[1] & 0xF8)))
392  return 1;
393 
394  if (bt_debug & BT_DEBUG_MSG)
395  printk(KERN_WARNING "IPMI BT: bad packet: "
396  "want 0x(%02X, %02X, %02X) got (%02X, %02X, %02X)\n",
397  bt->write_data[1] | 0x04, bt->write_data[2], bt->write_data[3],
398  bt->read_data[1], bt->read_data[2], bt->read_data[3]);
399  return 0;
400 }
401 
402 /* Restart if retries are left, or return an error completion code */
403 
404 static enum si_sm_result error_recovery(struct si_sm_data *bt,
405  unsigned char status,
406  unsigned char cCode)
407 {
408  char *reason;
409 
410  bt->timeout = bt->BT_CAP_req2rsp;
411 
412  switch (cCode) {
413  case IPMI_TIMEOUT_ERR:
414  reason = "timeout";
415  break;
416  default:
417  reason = "internal error";
418  break;
419  }
420 
421  printk(KERN_WARNING "IPMI BT: %s in %s %s ", /* open-ended line */
422  reason, STATE2TXT, STATUS2TXT);
423 
424  /*
425  * Per the IPMI spec, retries are based on the sequence number
426  * known only to this module, so manage a restart here.
427  */
428  (bt->error_retries)++;
429  if (bt->error_retries < bt->BT_CAP_retries) {
430  printk("%d retries left\n",
431  bt->BT_CAP_retries - bt->error_retries);
432  bt->state = BT_STATE_RESTART;
434  }
435 
436  printk(KERN_WARNING "failed %d retries, sending error response\n",
437  bt->BT_CAP_retries);
438  if (!bt->nonzero_status)
439  printk(KERN_ERR "IPMI BT: stuck, try power cycle\n");
440 
441  /* this is most likely during insmod */
442  else if (bt->seq <= (unsigned char)(bt->BT_CAP_retries & 0xFF)) {
443  printk(KERN_WARNING "IPMI: BT reset (takes 5 secs)\n");
444  bt->state = BT_STATE_RESET1;
446  }
447 
448  /*
449  * Concoct a useful error message, set up the next state, and
450  * be done with this sequence.
451  */
452 
453  bt->state = BT_STATE_IDLE;
454  switch (cCode) {
455  case IPMI_TIMEOUT_ERR:
456  if (status & BT_B_BUSY) {
457  cCode = IPMI_NODE_BUSY_ERR;
459  }
460  break;
461  default:
462  break;
463  }
464  force_result(bt, cCode);
466 }
467 
468 /* Check status and (usually) take action and change this state machine. */
469 
470 static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
471 {
472  unsigned char status, BT_CAP[8];
473  static enum bt_states last_printed = BT_STATE_PRINTME;
474  int i;
475 
476  status = BT_STATUS;
477  bt->nonzero_status |= status;
478  if ((bt_debug & BT_DEBUG_STATES) && (bt->state != last_printed)) {
479  printk(KERN_WARNING "BT: %s %s TO=%ld - %ld \n",
480  STATE2TXT,
481  STATUS2TXT,
482  bt->timeout,
483  time);
484  last_printed = bt->state;
485  }
486 
487  /*
488  * Commands that time out may still (eventually) provide a response.
489  * This stale response will get in the way of a new response so remove
490  * it if possible (hopefully during IDLE). Even if it comes up later
491  * it will be rejected by its (now-forgotten) seq number.
492  */
493 
494  if ((bt->state < BT_STATE_WRITE_BYTES) && (status & BT_B2H_ATN)) {
495  drain_BMC2HOST(bt);
497  }
498 
499  if ((bt->state != BT_STATE_IDLE) &&
500  (bt->state < BT_STATE_PRINTME)) {
501  /* check timeout */
502  bt->timeout -= time;
503  if ((bt->timeout < 0) && (bt->state < BT_STATE_RESET1))
504  return error_recovery(bt,
505  status,
507  }
508 
509  switch (bt->state) {
510 
511  /*
512  * Idle state first checks for asynchronous messages from another
513  * channel, then does some opportunistic housekeeping.
514  */
515 
516  case BT_STATE_IDLE:
517  if (status & BT_SMS_ATN) {
518  BT_CONTROL(BT_SMS_ATN); /* clear it */
519  return SI_SM_ATTN;
520  }
521 
522  if (status & BT_H_BUSY) /* clear a leftover H_BUSY */
523  BT_CONTROL(BT_H_BUSY);
524 
525  /* Read BT capabilities if it hasn't been done yet */
526  if (!bt->BT_CAP_outreqs)
529  bt->timeout = bt->BT_CAP_req2rsp;
531 
533  if (status & (BT_B_BUSY | BT_H2B_ATN))
535  if (BT_STATUS & BT_H_BUSY)
536  BT_CONTROL(BT_H_BUSY); /* force clear */
539 
541  if (status & BT_H_BUSY)
542  BT_CONTROL(BT_H_BUSY); /* clear */
544  write_all_bytes(bt);
545  BT_CONTROL(BT_H2B_ATN); /* can clear too fast to catch */
548 
550  if (status & (BT_B_BUSY | BT_H2B_ATN))
554 
555  /* Spinning hard can suppress B2H_ATN and force a timeout */
556 
557  case BT_STATE_READ_WAIT:
558  if (!(status & BT_B2H_ATN))
560  BT_CONTROL(BT_H_BUSY); /* set */
561 
562  /*
563  * Uncached, ordered writes should just proceed serially but
564  * some BMCs don't clear B2H_ATN with one hit. Fast-path a
565  * workaround without too much penalty to the general case.
566  */
567 
568  BT_CONTROL(BT_B2H_ATN); /* clear it to ACK the BMC */
571 
572  case BT_STATE_CLEAR_B2H:
573  if (status & BT_B2H_ATN) {
574  /* keep hitting it */
575  BT_CONTROL(BT_B2H_ATN);
577  }
580 
581  case BT_STATE_READ_BYTES:
582  if (!(status & BT_H_BUSY))
583  /* check in case of retry */
584  BT_CONTROL(BT_H_BUSY);
585  BT_CONTROL(BT_CLR_RD_PTR); /* start of BMC2HOST buffer */
586  i = read_all_bytes(bt); /* true == packet seq match */
587  BT_CONTROL(BT_H_BUSY); /* NOW clear */
588  if (!i) /* Not my message */
591  bt->state = bt->complete;
592  return bt->state == BT_STATE_IDLE ? /* where to next? */
593  SI_SM_TRANSACTION_COMPLETE : /* normal */
594  SI_SM_CALL_WITHOUT_DELAY; /* Startup magic */
595 
596  case BT_STATE_LONG_BUSY: /* For example: after FW update */
597  if (!(status & BT_B_BUSY)) {
598  reset_flags(bt); /* next state is now IDLE */
599  bt_init_data(bt, bt->io);
600  }
601  return SI_SM_CALL_WITH_DELAY; /* No repeat printing */
602 
603  case BT_STATE_RESET1:
604  reset_flags(bt);
605  drain_BMC2HOST(bt);
608 
609  case BT_STATE_RESET2: /* Send a soft reset */
611  HOST2BMC(3); /* number of bytes following */
612  HOST2BMC(0x18); /* NetFn/LUN == Application, LUN 0 */
613  HOST2BMC(42); /* Sequence number */
614  HOST2BMC(3); /* Cmd == Soft reset */
616  bt->timeout = BT_RESET_DELAY * 1000000;
619 
620  case BT_STATE_RESET3: /* Hold off everything for a bit */
621  if (bt->timeout > 0)
622  return SI_SM_CALL_WITH_DELAY;
623  drain_BMC2HOST(bt);
626 
627  case BT_STATE_RESTART: /* don't reset retries or seq! */
628  bt->read_count = 0;
629  bt->nonzero_status = 0;
630  bt->timeout = bt->BT_CAP_req2rsp;
633 
634  /*
635  * Get BT Capabilities, using timing of upper level state machine.
636  * Set outreqs to prevent infinite loop on timeout.
637  */
639  bt->BT_CAP_outreqs = 1;
640  {
641  unsigned char GetBT_CAP[] = { 0x18, 0x36 };
642  bt->state = BT_STATE_IDLE;
643  bt_start_transaction(bt, GetBT_CAP, sizeof(GetBT_CAP));
644  }
648 
650  i = bt_get_result(bt, BT_CAP, sizeof(BT_CAP));
651  bt_init_data(bt, bt->io);
652  if ((i == 8) && !BT_CAP[2]) {
653  bt->BT_CAP_outreqs = BT_CAP[3];
654  bt->BT_CAP_req2rsp = BT_CAP[6] * 1000000;
655  bt->BT_CAP_retries = BT_CAP[7];
656  } else
657  printk(KERN_WARNING "IPMI BT: using default values\n");
658  if (!bt->BT_CAP_outreqs)
659  bt->BT_CAP_outreqs = 1;
660  printk(KERN_WARNING "IPMI BT: req2rsp=%ld secs retries=%d\n",
661  bt->BT_CAP_req2rsp / 1000000L, bt->BT_CAP_retries);
662  bt->timeout = bt->BT_CAP_req2rsp;
664 
665  default: /* should never occur */
666  return error_recovery(bt,
667  status,
669  }
670  return SI_SM_CALL_WITH_DELAY;
671 }
672 
673 static int bt_detect(struct si_sm_data *bt)
674 {
675  /*
676  * It's impossible for the BT status and interrupt registers to be
677  * all 1's, (assuming a properly functioning, self-initialized BMC)
678  * but that's what you get from reading a bogus address, so we
679  * test that first. The calling routine uses negative logic.
680  */
681 
682  if ((BT_STATUS == 0xFF) && (BT_INTMASK_R == 0xFF))
683  return 1;
684  reset_flags(bt);
685  return 0;
686 }
687 
688 static void bt_cleanup(struct si_sm_data *bt)
689 {
690 }
691 
692 static int bt_size(void)
693 {
694  return sizeof(struct si_sm_data);
695 }
696 
698  .init_data = bt_init_data,
699  .start_transaction = bt_start_transaction,
700  .get_result = bt_get_result,
701  .event = bt_event,
702  .detect = bt_detect,
703  .cleanup = bt_cleanup,
704  .size = bt_size,
705 };