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 (5*USEC_PER_SEC) 122 #define OBF_RETRY_TIMEOUT (5*USEC_PER_SEC) 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 kcs->obf_timeout = OBF_RETRY_TIMEOUT; 255 start_error_recovery(kcs, "OBF not ready in time"); 256 return 1; 257 } 258 return 0; 259 } 260 kcs->obf_timeout = OBF_RETRY_TIMEOUT; 261 return 1; 262 } 263 264 static void clear_obf(struct si_sm_data *kcs, unsigned char status) 265 { 266 if (GET_STATUS_OBF(status)) 267 read_data(kcs); 268 } 269 270 static void restart_kcs_transaction(struct si_sm_data *kcs) 271 { 272 kcs->write_count = kcs->orig_write_count; 273 kcs->write_pos = 0; 274 kcs->read_pos = 0; 275 kcs->state = KCS_WAIT_WRITE_START; 276 kcs->ibf_timeout = IBF_RETRY_TIMEOUT; 277 kcs->obf_timeout = OBF_RETRY_TIMEOUT; 278 write_cmd(kcs, KCS_WRITE_START); 279 } 280 281 static int start_kcs_transaction(struct si_sm_data *kcs, unsigned char *data, 282 unsigned int size) 283 { 284 unsigned int i; 285 286 if (size < 2) 287 return IPMI_REQ_LEN_INVALID_ERR; 288 if (size > MAX_KCS_WRITE_SIZE) 289 return IPMI_REQ_LEN_EXCEEDED_ERR; 290 291 if ((kcs->state != KCS_IDLE) && (kcs->state != KCS_HOSED)) 292 return IPMI_NOT_IN_MY_STATE_ERR; 293 294 if (kcs_debug & KCS_DEBUG_MSG) { 295 printk(KERN_DEBUG "start_kcs_transaction -"); 296 for (i = 0; i < size; i++) 297 printk(" %02x", (unsigned char) (data [i])); 298 printk("\n"); 299 } 300 kcs->error_retries = 0; 301 memcpy(kcs->write_data, data, size); 302 kcs->write_count = size; 303 kcs->orig_write_count = size; 304 kcs->write_pos = 0; 305 kcs->read_pos = 0; 306 kcs->state = KCS_START_OP; 307 kcs->ibf_timeout = IBF_RETRY_TIMEOUT; 308 kcs->obf_timeout = OBF_RETRY_TIMEOUT; 309 return 0; 310 } 311 312 static int get_kcs_result(struct si_sm_data *kcs, unsigned char *data, 313 unsigned int length) 314 { 315 if (length < kcs->read_pos) { 316 kcs->read_pos = length; 317 kcs->truncated = 1; 318 } 319 320 memcpy(data, kcs->read_data, kcs->read_pos); 321 322 if ((length >= 3) && (kcs->read_pos < 3)) { 323 /* Guarantee that we return at least 3 bytes, with an 324 error in the third byte if it is too short. */ 325 data[2] = IPMI_ERR_UNSPECIFIED; 326 kcs->read_pos = 3; 327 } 328 if (kcs->truncated) { 329 /* 330 * Report a truncated error. We might overwrite 331 * another error, but that's too bad, the user needs 332 * to know it was truncated. 333 */ 334 data[2] = IPMI_ERR_MSG_TRUNCATED; 335 kcs->truncated = 0; 336 } 337 338 return kcs->read_pos; 339 } 340 341 /* 342 * This implements the state machine defined in the IPMI manual, see 343 * that for details on how this works. Divide that flowchart into 344 * sections delimited by "Wait for IBF" and this will become clear. 345 */ 346 static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time) 347 { 348 unsigned char status; 349 unsigned char state; 350 351 status = read_status(kcs); 352 353 if (kcs_debug & KCS_DEBUG_STATES) 354 printk(KERN_DEBUG "KCS: State = %d, %x\n", kcs->state, status); 355 356 /* All states wait for ibf, so just do it here. */ 357 if (!check_ibf(kcs, status, time)) 358 return SI_SM_CALL_WITH_DELAY; 359 360 /* Just about everything looks at the KCS state, so grab that, too. */ 361 state = GET_STATUS_STATE(status); 362 363 switch (kcs->state) { 364 case KCS_IDLE: 365 /* If there's and interrupt source, turn it off. */ 366 clear_obf(kcs, status); 367 368 if (GET_STATUS_ATN(status)) 369 return SI_SM_ATTN; 370 else 371 return SI_SM_IDLE; 372 373 case KCS_START_OP: 374 if (state != KCS_IDLE_STATE) { 375 start_error_recovery(kcs, 376 "State machine not idle at start"); 377 break; 378 } 379 380 clear_obf(kcs, status); 381 write_cmd(kcs, KCS_WRITE_START); 382 kcs->state = KCS_WAIT_WRITE_START; 383 break; 384 385 case KCS_WAIT_WRITE_START: 386 if (state != KCS_WRITE_STATE) { 387 start_error_recovery( 388 kcs, 389 "Not in write state at write start"); 390 break; 391 } 392 read_data(kcs); 393 if (kcs->write_count == 1) { 394 write_cmd(kcs, KCS_WRITE_END); 395 kcs->state = KCS_WAIT_WRITE_END; 396 } else { 397 write_next_byte(kcs); 398 kcs->state = KCS_WAIT_WRITE; 399 } 400 break; 401 402 case KCS_WAIT_WRITE: 403 if (state != KCS_WRITE_STATE) { 404 start_error_recovery(kcs, 405 "Not in write state for write"); 406 break; 407 } 408 clear_obf(kcs, status); 409 if (kcs->write_count == 1) { 410 write_cmd(kcs, KCS_WRITE_END); 411 kcs->state = KCS_WAIT_WRITE_END; 412 } else { 413 write_next_byte(kcs); 414 } 415 break; 416 417 case KCS_WAIT_WRITE_END: 418 if (state != KCS_WRITE_STATE) { 419 start_error_recovery(kcs, 420 "Not in write state" 421 " for write end"); 422 break; 423 } 424 clear_obf(kcs, status); 425 write_next_byte(kcs); 426 kcs->state = KCS_WAIT_READ; 427 break; 428 429 case KCS_WAIT_READ: 430 if ((state != KCS_READ_STATE) && (state != KCS_IDLE_STATE)) { 431 start_error_recovery( 432 kcs, 433 "Not in read or idle in read state"); 434 break; 435 } 436 437 if (state == KCS_READ_STATE) { 438 if (!check_obf(kcs, status, time)) 439 return SI_SM_CALL_WITH_DELAY; 440 read_next_byte(kcs); 441 } else { 442 /* 443 * We don't implement this exactly like the state 444 * machine in the spec. Some broken hardware 445 * does not write the final dummy byte to the 446 * read register. Thus obf will never go high 447 * here. We just go straight to idle, and we 448 * handle clearing out obf in idle state if it 449 * happens to come in. 450 */ 451 clear_obf(kcs, status); 452 kcs->orig_write_count = 0; 453 kcs->state = KCS_IDLE; 454 return SI_SM_TRANSACTION_COMPLETE; 455 } 456 break; 457 458 case KCS_ERROR0: 459 clear_obf(kcs, status); 460 status = read_status(kcs); 461 if (GET_STATUS_OBF(status)) 462 /* controller isn't responding */ 463 if (time_before(jiffies, kcs->error0_timeout)) 464 return SI_SM_CALL_WITH_TICK_DELAY; 465 write_cmd(kcs, KCS_GET_STATUS_ABORT); 466 kcs->state = KCS_ERROR1; 467 break; 468 469 case KCS_ERROR1: 470 clear_obf(kcs, status); 471 write_data(kcs, 0); 472 kcs->state = KCS_ERROR2; 473 break; 474 475 case KCS_ERROR2: 476 if (state != KCS_READ_STATE) { 477 start_error_recovery(kcs, 478 "Not in read state for error2"); 479 break; 480 } 481 if (!check_obf(kcs, status, time)) 482 return SI_SM_CALL_WITH_DELAY; 483 484 clear_obf(kcs, status); 485 write_data(kcs, KCS_READ_BYTE); 486 kcs->state = KCS_ERROR3; 487 break; 488 489 case KCS_ERROR3: 490 if (state != KCS_IDLE_STATE) { 491 start_error_recovery(kcs, 492 "Not in idle state for error3"); 493 break; 494 } 495 496 if (!check_obf(kcs, status, time)) 497 return SI_SM_CALL_WITH_DELAY; 498 499 clear_obf(kcs, status); 500 if (kcs->orig_write_count) { 501 restart_kcs_transaction(kcs); 502 } else { 503 kcs->state = KCS_IDLE; 504 return SI_SM_TRANSACTION_COMPLETE; 505 } 506 break; 507 508 case KCS_HOSED: 509 break; 510 } 511 512 if (kcs->state == KCS_HOSED) { 513 init_kcs_data(kcs, kcs->io); 514 return SI_SM_HOSED; 515 } 516 517 return SI_SM_CALL_WITHOUT_DELAY; 518 } 519 520 static int kcs_size(void) 521 { 522 return sizeof(struct si_sm_data); 523 } 524 525 static int kcs_detect(struct si_sm_data *kcs) 526 { 527 /* 528 * It's impossible for the KCS status register to be all 1's, 529 * (assuming a properly functioning, self-initialized BMC) 530 * but that's what you get from reading a bogus address, so we 531 * test that first. 532 */ 533 if (read_status(kcs) == 0xff) 534 return 1; 535 536 return 0; 537 } 538 539 static void kcs_cleanup(struct si_sm_data *kcs) 540 { 541 } 542 543 struct si_sm_handlers kcs_smi_handlers = { 544 .init_data = init_kcs_data, 545 .start_transaction = start_kcs_transaction, 546 .get_result = get_kcs_result, 547 .event = kcs_event, 548 .detect = kcs_detect, 549 .cleanup = kcs_cleanup, 550 .size = kcs_size, 551 }; 552