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 1000000 122 #define OBF_RETRY_TIMEOUT 1000000 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 }; 551