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/project/openipmi 6 * 7 * Author: Rocky Craig <first.last@hp.com> 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 /* BT_DEBUG_OFF must be zero to correspond to the default uninitialized 41 value */ 42 43 static int bt_debug; /* 0 == BT_DEBUG_OFF */ 44 45 module_param(bt_debug, int, 0644); 46 MODULE_PARM_DESC(bt_debug, "debug bitmask, 1=enable, 2=messages, 4=states"); 47 48 /* Typical "Get BT Capabilities" values are 2-3 retries, 5-10 seconds, 49 and 64 byte buffers. However, one HP implementation wants 255 bytes of 50 buffer (with a documented message of 160 bytes) so go for the max. 51 Since the Open IPMI architecture is single-message oriented at this 52 stage, the queue depth of BT is of no concern. */ 53 54 #define BT_NORMAL_TIMEOUT 5 /* seconds */ 55 #define BT_NORMAL_RETRY_LIMIT 2 56 #define BT_RESET_DELAY 6 /* seconds after warm reset */ 57 58 /* States are written in chronological order and usually cover 59 multiple rows of the state table discussion in the IPMI spec. */ 60 61 enum bt_states { 62 BT_STATE_IDLE = 0, /* Order is critical in this list */ 63 BT_STATE_XACTION_START, 64 BT_STATE_WRITE_BYTES, 65 BT_STATE_WRITE_CONSUME, 66 BT_STATE_READ_WAIT, 67 BT_STATE_CLEAR_B2H, 68 BT_STATE_READ_BYTES, 69 BT_STATE_RESET1, /* These must come last */ 70 BT_STATE_RESET2, 71 BT_STATE_RESET3, 72 BT_STATE_RESTART, 73 BT_STATE_PRINTME, 74 BT_STATE_CAPABILITIES_BEGIN, 75 BT_STATE_CAPABILITIES_END, 76 BT_STATE_LONG_BUSY /* BT doesn't get hosed :-) */ 77 }; 78 79 /* Macros seen at the end of state "case" blocks. They help with legibility 80 and debugging. */ 81 82 #define BT_STATE_CHANGE(X,Y) { bt->state = X; return Y; } 83 84 #define BT_SI_SM_RETURN(Y) { last_printed = BT_STATE_PRINTME; return Y; } 85 86 struct si_sm_data { 87 enum bt_states state; 88 unsigned char seq; /* BT sequence number */ 89 struct si_sm_io *io; 90 unsigned char write_data[IPMI_MAX_MSG_LENGTH]; 91 int write_count; 92 unsigned char read_data[IPMI_MAX_MSG_LENGTH]; 93 int read_count; 94 int truncated; 95 long timeout; /* microseconds countdown */ 96 int error_retries; /* end of "common" fields */ 97 int nonzero_status; /* hung BMCs stay all 0 */ 98 enum bt_states complete; /* to divert the state machine */ 99 int BT_CAP_outreqs; 100 long BT_CAP_req2rsp; 101 int BT_CAP_retries; /* Recommended retries */ 102 }; 103 104 #define BT_CLR_WR_PTR 0x01 /* See IPMI 1.5 table 11.6.4 */ 105 #define BT_CLR_RD_PTR 0x02 106 #define BT_H2B_ATN 0x04 107 #define BT_B2H_ATN 0x08 108 #define BT_SMS_ATN 0x10 109 #define BT_OEM0 0x20 110 #define BT_H_BUSY 0x40 111 #define BT_B_BUSY 0x80 112 113 /* Some bits are toggled on each write: write once to set it, once 114 more to clear it; writing a zero does nothing. To absolutely 115 clear it, check its state and write if set. This avoids the "get 116 current then use as mask" scheme to modify one bit. Note that the 117 variable "bt" is hardcoded into these macros. */ 118 119 #define BT_STATUS bt->io->inputb(bt->io, 0) 120 #define BT_CONTROL(x) bt->io->outputb(bt->io, 0, x) 121 122 #define BMC2HOST bt->io->inputb(bt->io, 1) 123 #define HOST2BMC(x) bt->io->outputb(bt->io, 1, x) 124 125 #define BT_INTMASK_R bt->io->inputb(bt->io, 2) 126 #define BT_INTMASK_W(x) bt->io->outputb(bt->io, 2, x) 127 128 /* Convenience routines for debugging. These are not multi-open safe! 129 Note the macros have hardcoded variables in them. */ 130 131 static char *state2txt(unsigned char state) 132 { 133 switch (state) { 134 case BT_STATE_IDLE: return("IDLE"); 135 case BT_STATE_XACTION_START: return("XACTION"); 136 case BT_STATE_WRITE_BYTES: return("WR_BYTES"); 137 case BT_STATE_WRITE_CONSUME: return("WR_CONSUME"); 138 case BT_STATE_READ_WAIT: return("RD_WAIT"); 139 case BT_STATE_CLEAR_B2H: return("CLEAR_B2H"); 140 case BT_STATE_READ_BYTES: return("RD_BYTES"); 141 case BT_STATE_RESET1: return("RESET1"); 142 case BT_STATE_RESET2: return("RESET2"); 143 case BT_STATE_RESET3: return("RESET3"); 144 case BT_STATE_RESTART: return("RESTART"); 145 case BT_STATE_LONG_BUSY: return("LONG_BUSY"); 146 case BT_STATE_CAPABILITIES_BEGIN: return("CAP_BEGIN"); 147 case BT_STATE_CAPABILITIES_END: return("CAP_END"); 148 } 149 return("BAD STATE"); 150 } 151 #define STATE2TXT state2txt(bt->state) 152 153 static char *status2txt(unsigned char status) 154 { 155 /* 156 * This cannot be called by two threads at the same time and 157 * the buffer is always consumed immediately, so the static is 158 * safe to use. 159 */ 160 static char buf[40]; 161 162 strcpy(buf, "[ "); 163 if (status & BT_B_BUSY) 164 strcat(buf, "B_BUSY "); 165 if (status & BT_H_BUSY) 166 strcat(buf, "H_BUSY "); 167 if (status & BT_OEM0) 168 strcat(buf, "OEM0 "); 169 if (status & BT_SMS_ATN) 170 strcat(buf, "SMS "); 171 if (status & BT_B2H_ATN) 172 strcat(buf, "B2H "); 173 if (status & BT_H2B_ATN) 174 strcat(buf, "H2B "); 175 strcat(buf, "]"); 176 return buf; 177 } 178 #define STATUS2TXT status2txt(status) 179 180 /* called externally at insmod time, and internally on cleanup */ 181 182 static unsigned int bt_init_data(struct si_sm_data *bt, struct si_sm_io *io) 183 { 184 memset(bt, 0, sizeof(struct si_sm_data)); 185 if (bt->io != io) { /* external: one-time only things */ 186 bt->io = io; 187 bt->seq = 0; 188 } 189 bt->state = BT_STATE_IDLE; /* start here */ 190 bt->complete = BT_STATE_IDLE; /* end here */ 191 bt->BT_CAP_req2rsp = BT_NORMAL_TIMEOUT * 1000000; 192 bt->BT_CAP_retries = BT_NORMAL_RETRY_LIMIT; 193 /* BT_CAP_outreqs == zero is a flag to read BT Capabilities */ 194 return 3; /* We claim 3 bytes of space; ought to check SPMI table */ 195 } 196 197 /* Jam a completion code (probably an error) into a response */ 198 199 static void force_result(struct si_sm_data *bt, unsigned char completion_code) 200 { 201 bt->read_data[0] = 4; /* # following bytes */ 202 bt->read_data[1] = bt->write_data[1] | 4; /* Odd NetFn/LUN */ 203 bt->read_data[2] = bt->write_data[2]; /* seq (ignored) */ 204 bt->read_data[3] = bt->write_data[3]; /* Command */ 205 bt->read_data[4] = completion_code; 206 bt->read_count = 5; 207 } 208 209 /* The upper state machine starts here */ 210 211 static int bt_start_transaction(struct si_sm_data *bt, 212 unsigned char *data, 213 unsigned int size) 214 { 215 unsigned int i; 216 217 if (size < 2) 218 return IPMI_REQ_LEN_INVALID_ERR; 219 if (size > IPMI_MAX_MSG_LENGTH) 220 return IPMI_REQ_LEN_EXCEEDED_ERR; 221 222 if (bt->state == BT_STATE_LONG_BUSY) 223 return IPMI_NODE_BUSY_ERR; 224 225 if (bt->state != BT_STATE_IDLE) 226 return IPMI_NOT_IN_MY_STATE_ERR; 227 228 if (bt_debug & BT_DEBUG_MSG) { 229 printk(KERN_WARNING "BT: +++++++++++++++++ New command\n"); 230 printk(KERN_WARNING "BT: NetFn/LUN CMD [%d data]:", size - 2); 231 for (i = 0; i < size; i ++) 232 printk (" %02x", data[i]); 233 printk("\n"); 234 } 235 bt->write_data[0] = size + 1; /* all data plus seq byte */ 236 bt->write_data[1] = *data; /* NetFn/LUN */ 237 bt->write_data[2] = bt->seq++; 238 memcpy(bt->write_data + 3, data + 1, size - 1); 239 bt->write_count = size + 2; 240 bt->error_retries = 0; 241 bt->nonzero_status = 0; 242 bt->truncated = 0; 243 bt->state = BT_STATE_XACTION_START; 244 bt->timeout = bt->BT_CAP_req2rsp; 245 force_result(bt, IPMI_ERR_UNSPECIFIED); 246 return 0; 247 } 248 249 /* After the upper state machine has been told SI_SM_TRANSACTION_COMPLETE 250 it calls this. Strip out the length and seq bytes. */ 251 252 static int bt_get_result(struct si_sm_data *bt, 253 unsigned char *data, 254 unsigned int length) 255 { 256 int i, msg_len; 257 258 msg_len = bt->read_count - 2; /* account for length & seq */ 259 if (msg_len < 3 || msg_len > IPMI_MAX_MSG_LENGTH) { 260 force_result(bt, IPMI_ERR_UNSPECIFIED); 261 msg_len = 3; 262 } 263 data[0] = bt->read_data[1]; 264 data[1] = bt->read_data[3]; 265 if (length < msg_len || bt->truncated) { 266 data[2] = IPMI_ERR_MSG_TRUNCATED; 267 msg_len = 3; 268 } else 269 memcpy(data + 2, bt->read_data + 4, msg_len - 2); 270 271 if (bt_debug & BT_DEBUG_MSG) { 272 printk (KERN_WARNING "BT: result %d bytes:", msg_len); 273 for (i = 0; i < msg_len; i++) 274 printk(" %02x", data[i]); 275 printk ("\n"); 276 } 277 return msg_len; 278 } 279 280 /* This bit's functionality is optional */ 281 #define BT_BMC_HWRST 0x80 282 283 static void reset_flags(struct si_sm_data *bt) 284 { 285 if (bt_debug) 286 printk(KERN_WARNING "IPMI BT: flag reset %s\n", 287 status2txt(BT_STATUS)); 288 if (BT_STATUS & BT_H_BUSY) 289 BT_CONTROL(BT_H_BUSY); /* force clear */ 290 BT_CONTROL(BT_CLR_WR_PTR); /* always reset */ 291 BT_CONTROL(BT_SMS_ATN); /* always clear */ 292 BT_INTMASK_W(BT_BMC_HWRST); 293 } 294 295 /* Get rid of an unwanted/stale response. This should only be needed for 296 BMCs that support multiple outstanding requests. */ 297 298 static void drain_BMC2HOST(struct si_sm_data *bt) 299 { 300 int i, size; 301 302 if (!(BT_STATUS & BT_B2H_ATN)) /* Not signalling a response */ 303 return; 304 305 BT_CONTROL(BT_H_BUSY); /* now set */ 306 BT_CONTROL(BT_B2H_ATN); /* always clear */ 307 BT_STATUS; /* pause */ 308 BT_CONTROL(BT_B2H_ATN); /* some BMCs are stubborn */ 309 BT_CONTROL(BT_CLR_RD_PTR); /* always reset */ 310 if (bt_debug) 311 printk(KERN_WARNING "IPMI BT: stale response %s; ", 312 status2txt(BT_STATUS)); 313 size = BMC2HOST; 314 for (i = 0; i < size ; i++) 315 BMC2HOST; 316 BT_CONTROL(BT_H_BUSY); /* now clear */ 317 if (bt_debug) 318 printk("drained %d bytes\n", size + 1); 319 } 320 321 static inline void write_all_bytes(struct si_sm_data *bt) 322 { 323 int i; 324 325 if (bt_debug & BT_DEBUG_MSG) { 326 printk(KERN_WARNING "BT: write %d bytes seq=0x%02X", 327 bt->write_count, bt->seq); 328 for (i = 0; i < bt->write_count; i++) 329 printk (" %02x", bt->write_data[i]); 330 printk ("\n"); 331 } 332 for (i = 0; i < bt->write_count; i++) 333 HOST2BMC(bt->write_data[i]); 334 } 335 336 static inline int read_all_bytes(struct si_sm_data *bt) 337 { 338 unsigned char i; 339 340 /* length is "framing info", minimum = 4: NetFn, Seq, Cmd, cCode. 341 Keep layout of first four bytes aligned with write_data[] */ 342 343 bt->read_data[0] = BMC2HOST; 344 bt->read_count = bt->read_data[0]; 345 346 if (bt->read_count < 4 || bt->read_count >= IPMI_MAX_MSG_LENGTH) { 347 if (bt_debug & BT_DEBUG_MSG) 348 printk(KERN_WARNING "BT: bad raw rsp len=%d\n", 349 bt->read_count); 350 bt->truncated = 1; 351 return 1; /* let next XACTION START clean it up */ 352 } 353 for (i = 1; i <= bt->read_count; i++) 354 bt->read_data[i] = BMC2HOST; 355 bt->read_count++; /* Account internally for length byte */ 356 357 if (bt_debug & BT_DEBUG_MSG) { 358 int max = bt->read_count; 359 360 printk(KERN_WARNING "BT: got %d bytes seq=0x%02X", 361 max, bt->read_data[2]); 362 if (max > 16) 363 max = 16; 364 for (i = 0; i < max; i++) 365 printk (" %02x", bt->read_data[i]); 366 printk ("%s\n", bt->read_count == max ? "" : " ..."); 367 } 368 369 /* per the spec, the (NetFn[1], Seq[2], Cmd[3]) tuples must match */ 370 if ((bt->read_data[3] == bt->write_data[3]) && 371 (bt->read_data[2] == bt->write_data[2]) && 372 ((bt->read_data[1] & 0xF8) == (bt->write_data[1] & 0xF8))) 373 return 1; 374 375 if (bt_debug & BT_DEBUG_MSG) 376 printk(KERN_WARNING "IPMI BT: bad packet: " 377 "want 0x(%02X, %02X, %02X) got (%02X, %02X, %02X)\n", 378 bt->write_data[1] | 0x04, bt->write_data[2], bt->write_data[3], 379 bt->read_data[1], bt->read_data[2], bt->read_data[3]); 380 return 0; 381 } 382 383 /* Restart if retries are left, or return an error completion code */ 384 385 static enum si_sm_result error_recovery(struct si_sm_data *bt, 386 unsigned char status, 387 unsigned char cCode) 388 { 389 char *reason; 390 391 bt->timeout = bt->BT_CAP_req2rsp; 392 393 switch (cCode) { 394 case IPMI_TIMEOUT_ERR: 395 reason = "timeout"; 396 break; 397 default: 398 reason = "internal error"; 399 break; 400 } 401 402 printk(KERN_WARNING "IPMI BT: %s in %s %s ", /* open-ended line */ 403 reason, STATE2TXT, STATUS2TXT); 404 405 /* Per the IPMI spec, retries are based on the sequence number 406 known only to this module, so manage a restart here. */ 407 (bt->error_retries)++; 408 if (bt->error_retries < bt->BT_CAP_retries) { 409 printk("%d retries left\n", 410 bt->BT_CAP_retries - bt->error_retries); 411 bt->state = BT_STATE_RESTART; 412 return SI_SM_CALL_WITHOUT_DELAY; 413 } 414 415 printk("failed %d retries, sending error response\n", 416 bt->BT_CAP_retries); 417 if (!bt->nonzero_status) 418 printk(KERN_ERR "IPMI BT: stuck, try power cycle\n"); 419 420 /* this is most likely during insmod */ 421 else if (bt->seq <= (unsigned char)(bt->BT_CAP_retries & 0xFF)) { 422 printk(KERN_WARNING "IPMI: BT reset (takes 5 secs)\n"); 423 bt->state = BT_STATE_RESET1; 424 return SI_SM_CALL_WITHOUT_DELAY; 425 } 426 427 /* Concoct a useful error message, set up the next state, and 428 be done with this sequence. */ 429 430 bt->state = BT_STATE_IDLE; 431 switch (cCode) { 432 case IPMI_TIMEOUT_ERR: 433 if (status & BT_B_BUSY) { 434 cCode = IPMI_NODE_BUSY_ERR; 435 bt->state = BT_STATE_LONG_BUSY; 436 } 437 break; 438 default: 439 break; 440 } 441 force_result(bt, cCode); 442 return SI_SM_TRANSACTION_COMPLETE; 443 } 444 445 /* Check status and (usually) take action and change this state machine. */ 446 447 static enum si_sm_result bt_event(struct si_sm_data *bt, long time) 448 { 449 unsigned char status, BT_CAP[8]; 450 static enum bt_states last_printed = BT_STATE_PRINTME; 451 int i; 452 453 status = BT_STATUS; 454 bt->nonzero_status |= status; 455 if ((bt_debug & BT_DEBUG_STATES) && (bt->state != last_printed)) { 456 printk(KERN_WARNING "BT: %s %s TO=%ld - %ld \n", 457 STATE2TXT, 458 STATUS2TXT, 459 bt->timeout, 460 time); 461 last_printed = bt->state; 462 } 463 464 /* Commands that time out may still (eventually) provide a response. 465 This stale response will get in the way of a new response so remove 466 it if possible (hopefully during IDLE). Even if it comes up later 467 it will be rejected by its (now-forgotten) seq number. */ 468 469 if ((bt->state < BT_STATE_WRITE_BYTES) && (status & BT_B2H_ATN)) { 470 drain_BMC2HOST(bt); 471 BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY); 472 } 473 474 if ((bt->state != BT_STATE_IDLE) && 475 (bt->state < BT_STATE_PRINTME)) { /* check timeout */ 476 bt->timeout -= time; 477 if ((bt->timeout < 0) && (bt->state < BT_STATE_RESET1)) 478 return error_recovery(bt, 479 status, 480 IPMI_TIMEOUT_ERR); 481 } 482 483 switch (bt->state) { 484 485 /* Idle state first checks for asynchronous messages from another 486 channel, then does some opportunistic housekeeping. */ 487 488 case BT_STATE_IDLE: 489 if (status & BT_SMS_ATN) { 490 BT_CONTROL(BT_SMS_ATN); /* clear it */ 491 return SI_SM_ATTN; 492 } 493 494 if (status & BT_H_BUSY) /* clear a leftover H_BUSY */ 495 BT_CONTROL(BT_H_BUSY); 496 497 /* Read BT capabilities if it hasn't been done yet */ 498 if (!bt->BT_CAP_outreqs) 499 BT_STATE_CHANGE(BT_STATE_CAPABILITIES_BEGIN, 500 SI_SM_CALL_WITHOUT_DELAY); 501 bt->timeout = bt->BT_CAP_req2rsp; 502 BT_SI_SM_RETURN(SI_SM_IDLE); 503 504 case BT_STATE_XACTION_START: 505 if (status & (BT_B_BUSY | BT_H2B_ATN)) 506 BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY); 507 if (BT_STATUS & BT_H_BUSY) 508 BT_CONTROL(BT_H_BUSY); /* force clear */ 509 BT_STATE_CHANGE(BT_STATE_WRITE_BYTES, 510 SI_SM_CALL_WITHOUT_DELAY); 511 512 case BT_STATE_WRITE_BYTES: 513 if (status & BT_H_BUSY) 514 BT_CONTROL(BT_H_BUSY); /* clear */ 515 BT_CONTROL(BT_CLR_WR_PTR); 516 write_all_bytes(bt); 517 BT_CONTROL(BT_H2B_ATN); /* can clear too fast to catch */ 518 BT_STATE_CHANGE(BT_STATE_WRITE_CONSUME, 519 SI_SM_CALL_WITHOUT_DELAY); 520 521 case BT_STATE_WRITE_CONSUME: 522 if (status & (BT_B_BUSY | BT_H2B_ATN)) 523 BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY); 524 BT_STATE_CHANGE(BT_STATE_READ_WAIT, 525 SI_SM_CALL_WITHOUT_DELAY); 526 527 /* Spinning hard can suppress B2H_ATN and force a timeout */ 528 529 case BT_STATE_READ_WAIT: 530 if (!(status & BT_B2H_ATN)) 531 BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY); 532 BT_CONTROL(BT_H_BUSY); /* set */ 533 534 /* Uncached, ordered writes should just proceeed serially but 535 some BMCs don't clear B2H_ATN with one hit. Fast-path a 536 workaround without too much penalty to the general case. */ 537 538 BT_CONTROL(BT_B2H_ATN); /* clear it to ACK the BMC */ 539 BT_STATE_CHANGE(BT_STATE_CLEAR_B2H, 540 SI_SM_CALL_WITHOUT_DELAY); 541 542 case BT_STATE_CLEAR_B2H: 543 if (status & BT_B2H_ATN) { /* keep hitting it */ 544 BT_CONTROL(BT_B2H_ATN); 545 BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY); 546 } 547 BT_STATE_CHANGE(BT_STATE_READ_BYTES, 548 SI_SM_CALL_WITHOUT_DELAY); 549 550 case BT_STATE_READ_BYTES: 551 if (!(status & BT_H_BUSY)) /* check in case of retry */ 552 BT_CONTROL(BT_H_BUSY); 553 BT_CONTROL(BT_CLR_RD_PTR); /* start of BMC2HOST buffer */ 554 i = read_all_bytes(bt); /* true == packet seq match */ 555 BT_CONTROL(BT_H_BUSY); /* NOW clear */ 556 if (!i) /* Not my message */ 557 BT_STATE_CHANGE(BT_STATE_READ_WAIT, 558 SI_SM_CALL_WITHOUT_DELAY); 559 bt->state = bt->complete; 560 return bt->state == BT_STATE_IDLE ? /* where to next? */ 561 SI_SM_TRANSACTION_COMPLETE : /* normal */ 562 SI_SM_CALL_WITHOUT_DELAY; /* Startup magic */ 563 564 case BT_STATE_LONG_BUSY: /* For example: after FW update */ 565 if (!(status & BT_B_BUSY)) { 566 reset_flags(bt); /* next state is now IDLE */ 567 bt_init_data(bt, bt->io); 568 } 569 return SI_SM_CALL_WITH_DELAY; /* No repeat printing */ 570 571 case BT_STATE_RESET1: 572 reset_flags(bt); 573 drain_BMC2HOST(bt); 574 BT_STATE_CHANGE(BT_STATE_RESET2, 575 SI_SM_CALL_WITH_DELAY); 576 577 case BT_STATE_RESET2: /* Send a soft reset */ 578 BT_CONTROL(BT_CLR_WR_PTR); 579 HOST2BMC(3); /* number of bytes following */ 580 HOST2BMC(0x18); /* NetFn/LUN == Application, LUN 0 */ 581 HOST2BMC(42); /* Sequence number */ 582 HOST2BMC(3); /* Cmd == Soft reset */ 583 BT_CONTROL(BT_H2B_ATN); 584 bt->timeout = BT_RESET_DELAY * 1000000; 585 BT_STATE_CHANGE(BT_STATE_RESET3, 586 SI_SM_CALL_WITH_DELAY); 587 588 case BT_STATE_RESET3: /* Hold off everything for a bit */ 589 if (bt->timeout > 0) 590 return SI_SM_CALL_WITH_DELAY; 591 drain_BMC2HOST(bt); 592 BT_STATE_CHANGE(BT_STATE_RESTART, 593 SI_SM_CALL_WITH_DELAY); 594 595 case BT_STATE_RESTART: /* don't reset retries or seq! */ 596 bt->read_count = 0; 597 bt->nonzero_status = 0; 598 bt->timeout = bt->BT_CAP_req2rsp; 599 BT_STATE_CHANGE(BT_STATE_XACTION_START, 600 SI_SM_CALL_WITH_DELAY); 601 602 /* Get BT Capabilities, using timing of upper level state machine. 603 Set outreqs to prevent infinite loop on timeout. */ 604 case BT_STATE_CAPABILITIES_BEGIN: 605 bt->BT_CAP_outreqs = 1; 606 { 607 unsigned char GetBT_CAP[] = { 0x18, 0x36 }; 608 bt->state = BT_STATE_IDLE; 609 bt_start_transaction(bt, GetBT_CAP, sizeof(GetBT_CAP)); 610 } 611 bt->complete = BT_STATE_CAPABILITIES_END; 612 BT_STATE_CHANGE(BT_STATE_XACTION_START, 613 SI_SM_CALL_WITH_DELAY); 614 615 case BT_STATE_CAPABILITIES_END: 616 i = bt_get_result(bt, BT_CAP, sizeof(BT_CAP)); 617 bt_init_data(bt, bt->io); 618 if ((i == 8) && !BT_CAP[2]) { 619 bt->BT_CAP_outreqs = BT_CAP[3]; 620 bt->BT_CAP_req2rsp = BT_CAP[6] * 1000000; 621 bt->BT_CAP_retries = BT_CAP[7]; 622 } else 623 printk(KERN_WARNING "IPMI BT: using default values\n"); 624 if (!bt->BT_CAP_outreqs) 625 bt->BT_CAP_outreqs = 1; 626 printk(KERN_WARNING "IPMI BT: req2rsp=%ld secs retries=%d\n", 627 bt->BT_CAP_req2rsp / 1000000L, bt->BT_CAP_retries); 628 bt->timeout = bt->BT_CAP_req2rsp; 629 return SI_SM_CALL_WITHOUT_DELAY; 630 631 default: /* should never occur */ 632 return error_recovery(bt, 633 status, 634 IPMI_ERR_UNSPECIFIED); 635 } 636 return SI_SM_CALL_WITH_DELAY; 637 } 638 639 static int bt_detect(struct si_sm_data *bt) 640 { 641 /* It's impossible for the BT status and interrupt registers to be 642 all 1's, (assuming a properly functioning, self-initialized BMC) 643 but that's what you get from reading a bogus address, so we 644 test that first. The calling routine uses negative logic. */ 645 646 if ((BT_STATUS == 0xFF) && (BT_INTMASK_R == 0xFF)) 647 return 1; 648 reset_flags(bt); 649 return 0; 650 } 651 652 static void bt_cleanup(struct si_sm_data *bt) 653 { 654 } 655 656 static int bt_size(void) 657 { 658 return sizeof(struct si_sm_data); 659 } 660 661 struct si_sm_handlers bt_smi_handlers = 662 { 663 .init_data = bt_init_data, 664 .start_transaction = bt_start_transaction, 665 .get_result = bt_get_result, 666 .event = bt_event, 667 .detect = bt_detect, 668 .cleanup = bt_cleanup, 669 .size = bt_size, 670 }; 671