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 KCS_IDLE, /* The KCS interface is currently 64 doing nothing. */ 65 KCS_START_OP, /* We are starting an operation. The 66 data is in the output buffer, but 67 nothing has been done to the 68 interface yet. This was added to 69 the state machine in the spec to 70 wait for the initial IBF. */ 71 KCS_WAIT_WRITE_START, /* We have written a write cmd to the 72 interface. */ 73 KCS_WAIT_WRITE, /* We are writing bytes to the 74 interface. */ 75 KCS_WAIT_WRITE_END, /* We have written the write end cmd 76 to the interface, and still need to 77 write the last byte. */ 78 KCS_WAIT_READ, /* We are waiting to read data from 79 the interface. */ 80 KCS_ERROR0, /* State to transition to the error 81 handler, this was added to the 82 state machine in the spec to be 83 sure IBF was there. */ 84 KCS_ERROR1, /* First stage error handler, wait for 85 the interface to respond. */ 86 KCS_ERROR2, /* The abort cmd has been written, 87 wait for the interface to 88 respond. */ 89 KCS_ERROR3, /* We wrote some data to the 90 interface, wait for it to switch to 91 read mode. */ 92 KCS_HOSED /* The hardware failed to follow the 93 state machine. */ 94 }; 95 96 #define MAX_KCS_READ_SIZE IPMI_MAX_MSG_LENGTH 97 #define MAX_KCS_WRITE_SIZE IPMI_MAX_MSG_LENGTH 98 99 /* Timeouts in microseconds. */ 100 #define IBF_RETRY_TIMEOUT 1000000 101 #define OBF_RETRY_TIMEOUT 1000000 102 #define MAX_ERROR_RETRIES 10 103 #define ERROR0_OBF_WAIT_JIFFIES (2*HZ) 104 105 struct si_sm_data 106 { 107 enum kcs_states state; 108 struct si_sm_io *io; 109 unsigned char write_data[MAX_KCS_WRITE_SIZE]; 110 int write_pos; 111 int write_count; 112 int orig_write_count; 113 unsigned char read_data[MAX_KCS_READ_SIZE]; 114 int read_pos; 115 int truncated; 116 117 unsigned int error_retries; 118 long ibf_timeout; 119 long obf_timeout; 120 unsigned long error0_timeout; 121 }; 122 123 static unsigned int init_kcs_data(struct si_sm_data *kcs, 124 struct si_sm_io *io) 125 { 126 kcs->state = KCS_IDLE; 127 kcs->io = io; 128 kcs->write_pos = 0; 129 kcs->write_count = 0; 130 kcs->orig_write_count = 0; 131 kcs->read_pos = 0; 132 kcs->error_retries = 0; 133 kcs->truncated = 0; 134 kcs->ibf_timeout = IBF_RETRY_TIMEOUT; 135 kcs->obf_timeout = OBF_RETRY_TIMEOUT; 136 137 /* Reserve 2 I/O bytes. */ 138 return 2; 139 } 140 141 static inline unsigned char read_status(struct si_sm_data *kcs) 142 { 143 return kcs->io->inputb(kcs->io, 1); 144 } 145 146 static inline unsigned char read_data(struct si_sm_data *kcs) 147 { 148 return kcs->io->inputb(kcs->io, 0); 149 } 150 151 static inline void write_cmd(struct si_sm_data *kcs, unsigned char data) 152 { 153 kcs->io->outputb(kcs->io, 1, data); 154 } 155 156 static inline void write_data(struct si_sm_data *kcs, unsigned char data) 157 { 158 kcs->io->outputb(kcs->io, 0, data); 159 } 160 161 /* Control codes. */ 162 #define KCS_GET_STATUS_ABORT 0x60 163 #define KCS_WRITE_START 0x61 164 #define KCS_WRITE_END 0x62 165 #define KCS_READ_BYTE 0x68 166 167 /* Status bits. */ 168 #define GET_STATUS_STATE(status) (((status) >> 6) & 0x03) 169 #define KCS_IDLE_STATE 0 170 #define KCS_READ_STATE 1 171 #define KCS_WRITE_STATE 2 172 #define KCS_ERROR_STATE 3 173 #define GET_STATUS_ATN(status) ((status) & 0x04) 174 #define GET_STATUS_IBF(status) ((status) & 0x02) 175 #define GET_STATUS_OBF(status) ((status) & 0x01) 176 177 178 static inline void write_next_byte(struct si_sm_data *kcs) 179 { 180 write_data(kcs, kcs->write_data[kcs->write_pos]); 181 (kcs->write_pos)++; 182 (kcs->write_count)--; 183 } 184 185 static inline void start_error_recovery(struct si_sm_data *kcs, char *reason) 186 { 187 (kcs->error_retries)++; 188 if (kcs->error_retries > MAX_ERROR_RETRIES) { 189 if (kcs_debug & KCS_DEBUG_ENABLE) 190 printk(KERN_DEBUG "ipmi_kcs_sm: kcs hosed: %s\n", reason); 191 kcs->state = KCS_HOSED; 192 } else { 193 kcs->error0_timeout = jiffies + ERROR0_OBF_WAIT_JIFFIES; 194 kcs->state = KCS_ERROR0; 195 } 196 } 197 198 static inline void read_next_byte(struct si_sm_data *kcs) 199 { 200 if (kcs->read_pos >= MAX_KCS_READ_SIZE) { 201 /* Throw the data away and mark it truncated. */ 202 read_data(kcs); 203 kcs->truncated = 1; 204 } else { 205 kcs->read_data[kcs->read_pos] = read_data(kcs); 206 (kcs->read_pos)++; 207 } 208 write_data(kcs, KCS_READ_BYTE); 209 } 210 211 static inline int check_ibf(struct si_sm_data *kcs, unsigned char status, 212 long time) 213 { 214 if (GET_STATUS_IBF(status)) { 215 kcs->ibf_timeout -= time; 216 if (kcs->ibf_timeout < 0) { 217 start_error_recovery(kcs, "IBF not ready in time"); 218 kcs->ibf_timeout = IBF_RETRY_TIMEOUT; 219 return 1; 220 } 221 return 0; 222 } 223 kcs->ibf_timeout = IBF_RETRY_TIMEOUT; 224 return 1; 225 } 226 227 static inline int check_obf(struct si_sm_data *kcs, unsigned char status, 228 long time) 229 { 230 if (!GET_STATUS_OBF(status)) { 231 kcs->obf_timeout -= time; 232 if (kcs->obf_timeout < 0) { 233 start_error_recovery(kcs, "OBF not ready in time"); 234 return 1; 235 } 236 return 0; 237 } 238 kcs->obf_timeout = OBF_RETRY_TIMEOUT; 239 return 1; 240 } 241 242 static void clear_obf(struct si_sm_data *kcs, unsigned char status) 243 { 244 if (GET_STATUS_OBF(status)) 245 read_data(kcs); 246 } 247 248 static void restart_kcs_transaction(struct si_sm_data *kcs) 249 { 250 kcs->write_count = kcs->orig_write_count; 251 kcs->write_pos = 0; 252 kcs->read_pos = 0; 253 kcs->state = KCS_WAIT_WRITE_START; 254 kcs->ibf_timeout = IBF_RETRY_TIMEOUT; 255 kcs->obf_timeout = OBF_RETRY_TIMEOUT; 256 write_cmd(kcs, KCS_WRITE_START); 257 } 258 259 static int start_kcs_transaction(struct si_sm_data *kcs, unsigned char *data, 260 unsigned int size) 261 { 262 unsigned int i; 263 264 if (size < 2) 265 return IPMI_REQ_LEN_INVALID_ERR; 266 if (size > MAX_KCS_WRITE_SIZE) 267 return IPMI_REQ_LEN_EXCEEDED_ERR; 268 269 if ((kcs->state != KCS_IDLE) && (kcs->state != KCS_HOSED)) 270 return IPMI_NOT_IN_MY_STATE_ERR; 271 272 if (kcs_debug & KCS_DEBUG_MSG) { 273 printk(KERN_DEBUG "start_kcs_transaction -"); 274 for (i = 0; i < size; i ++) { 275 printk(" %02x", (unsigned char) (data [i])); 276 } 277 printk ("\n"); 278 } 279 kcs->error_retries = 0; 280 memcpy(kcs->write_data, data, size); 281 kcs->write_count = size; 282 kcs->orig_write_count = size; 283 kcs->write_pos = 0; 284 kcs->read_pos = 0; 285 kcs->state = KCS_START_OP; 286 kcs->ibf_timeout = IBF_RETRY_TIMEOUT; 287 kcs->obf_timeout = OBF_RETRY_TIMEOUT; 288 return 0; 289 } 290 291 static int get_kcs_result(struct si_sm_data *kcs, unsigned char *data, 292 unsigned int length) 293 { 294 if (length < kcs->read_pos) { 295 kcs->read_pos = length; 296 kcs->truncated = 1; 297 } 298 299 memcpy(data, kcs->read_data, kcs->read_pos); 300 301 if ((length >= 3) && (kcs->read_pos < 3)) { 302 /* Guarantee that we return at least 3 bytes, with an 303 error in the third byte if it is too short. */ 304 data[2] = IPMI_ERR_UNSPECIFIED; 305 kcs->read_pos = 3; 306 } 307 if (kcs->truncated) { 308 /* Report a truncated error. We might overwrite 309 another error, but that's too bad, the user needs 310 to know it was truncated. */ 311 data[2] = IPMI_ERR_MSG_TRUNCATED; 312 kcs->truncated = 0; 313 } 314 315 return kcs->read_pos; 316 } 317 318 /* This implements the state machine defined in the IPMI manual, see 319 that for details on how this works. Divide that flowchart into 320 sections delimited by "Wait for IBF" and this will become clear. */ 321 static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time) 322 { 323 unsigned char status; 324 unsigned char state; 325 326 status = read_status(kcs); 327 328 if (kcs_debug & KCS_DEBUG_STATES) 329 printk(KERN_DEBUG "KCS: State = %d, %x\n", kcs->state, status); 330 331 /* All states wait for ibf, so just do it here. */ 332 if (!check_ibf(kcs, status, time)) 333 return SI_SM_CALL_WITH_DELAY; 334 335 /* Just about everything looks at the KCS state, so grab that, too. */ 336 state = GET_STATUS_STATE(status); 337 338 switch (kcs->state) { 339 case KCS_IDLE: 340 /* If there's and interrupt source, turn it off. */ 341 clear_obf(kcs, status); 342 343 if (GET_STATUS_ATN(status)) 344 return SI_SM_ATTN; 345 else 346 return SI_SM_IDLE; 347 348 case KCS_START_OP: 349 if (state != KCS_IDLE) { 350 start_error_recovery(kcs, 351 "State machine not idle at start"); 352 break; 353 } 354 355 clear_obf(kcs, status); 356 write_cmd(kcs, KCS_WRITE_START); 357 kcs->state = KCS_WAIT_WRITE_START; 358 break; 359 360 case KCS_WAIT_WRITE_START: 361 if (state != KCS_WRITE_STATE) { 362 start_error_recovery( 363 kcs, 364 "Not in write state at write start"); 365 break; 366 } 367 read_data(kcs); 368 if (kcs->write_count == 1) { 369 write_cmd(kcs, KCS_WRITE_END); 370 kcs->state = KCS_WAIT_WRITE_END; 371 } else { 372 write_next_byte(kcs); 373 kcs->state = KCS_WAIT_WRITE; 374 } 375 break; 376 377 case KCS_WAIT_WRITE: 378 if (state != KCS_WRITE_STATE) { 379 start_error_recovery(kcs, 380 "Not in write state for write"); 381 break; 382 } 383 clear_obf(kcs, status); 384 if (kcs->write_count == 1) { 385 write_cmd(kcs, KCS_WRITE_END); 386 kcs->state = KCS_WAIT_WRITE_END; 387 } else { 388 write_next_byte(kcs); 389 } 390 break; 391 392 case KCS_WAIT_WRITE_END: 393 if (state != KCS_WRITE_STATE) { 394 start_error_recovery(kcs, 395 "Not in write state for write end"); 396 break; 397 } 398 clear_obf(kcs, status); 399 write_next_byte(kcs); 400 kcs->state = KCS_WAIT_READ; 401 break; 402 403 case KCS_WAIT_READ: 404 if ((state != KCS_READ_STATE) && (state != KCS_IDLE_STATE)) { 405 start_error_recovery( 406 kcs, 407 "Not in read or idle in read state"); 408 break; 409 } 410 411 if (state == KCS_READ_STATE) { 412 if (!check_obf(kcs, status, time)) 413 return SI_SM_CALL_WITH_DELAY; 414 read_next_byte(kcs); 415 } else { 416 /* We don't implement this exactly like the state 417 machine in the spec. Some broken hardware 418 does not write the final dummy byte to the 419 read register. Thus obf will never go high 420 here. We just go straight to idle, and we 421 handle clearing out obf in idle state if it 422 happens to come in. */ 423 clear_obf(kcs, status); 424 kcs->orig_write_count = 0; 425 kcs->state = KCS_IDLE; 426 return SI_SM_TRANSACTION_COMPLETE; 427 } 428 break; 429 430 case KCS_ERROR0: 431 clear_obf(kcs, status); 432 status = read_status(kcs); 433 if (GET_STATUS_OBF(status)) /* controller isn't responding */ 434 if (time_before(jiffies, kcs->error0_timeout)) 435 return SI_SM_CALL_WITH_TICK_DELAY; 436 write_cmd(kcs, KCS_GET_STATUS_ABORT); 437 kcs->state = KCS_ERROR1; 438 break; 439 440 case KCS_ERROR1: 441 clear_obf(kcs, status); 442 write_data(kcs, 0); 443 kcs->state = KCS_ERROR2; 444 break; 445 446 case KCS_ERROR2: 447 if (state != KCS_READ_STATE) { 448 start_error_recovery(kcs, 449 "Not in read state for error2"); 450 break; 451 } 452 if (!check_obf(kcs, status, time)) 453 return SI_SM_CALL_WITH_DELAY; 454 455 clear_obf(kcs, status); 456 write_data(kcs, KCS_READ_BYTE); 457 kcs->state = KCS_ERROR3; 458 break; 459 460 case KCS_ERROR3: 461 if (state != KCS_IDLE_STATE) { 462 start_error_recovery(kcs, 463 "Not in idle state for error3"); 464 break; 465 } 466 467 if (!check_obf(kcs, status, time)) 468 return SI_SM_CALL_WITH_DELAY; 469 470 clear_obf(kcs, status); 471 if (kcs->orig_write_count) { 472 restart_kcs_transaction(kcs); 473 } else { 474 kcs->state = KCS_IDLE; 475 return SI_SM_TRANSACTION_COMPLETE; 476 } 477 break; 478 479 case KCS_HOSED: 480 break; 481 } 482 483 if (kcs->state == KCS_HOSED) { 484 init_kcs_data(kcs, kcs->io); 485 return SI_SM_HOSED; 486 } 487 488 return SI_SM_CALL_WITHOUT_DELAY; 489 } 490 491 static int kcs_size(void) 492 { 493 return sizeof(struct si_sm_data); 494 } 495 496 static int kcs_detect(struct si_sm_data *kcs) 497 { 498 /* It's impossible for the KCS status register to be all 1's, 499 (assuming a properly functioning, self-initialized BMC) 500 but that's what you get from reading a bogus address, so we 501 test that first. */ 502 if (read_status(kcs) == 0xff) 503 return 1; 504 505 return 0; 506 } 507 508 static void kcs_cleanup(struct si_sm_data *kcs) 509 { 510 } 511 512 struct si_sm_handlers kcs_smi_handlers = 513 { 514 .init_data = init_kcs_data, 515 .start_transaction = start_kcs_transaction, 516 .get_result = get_kcs_result, 517 .event = kcs_event, 518 .detect = kcs_detect, 519 .cleanup = kcs_cleanup, 520 .size = kcs_size, 521 }; 522