1 /*- 2 * Copyright (c) 2006 IronPort Systems Inc. <ambrisko@ironport.com> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 __FBSDID("$FreeBSD$"); 29 30 #include <sys/param.h> 31 #include <sys/systm.h> 32 #include <sys/bus.h> 33 #include <sys/condvar.h> 34 #include <sys/eventhandler.h> 35 #include <sys/kernel.h> 36 #include <sys/kthread.h> 37 #include <sys/rman.h> 38 #include <sys/selinfo.h> 39 #include <machine/bus.h> 40 41 #ifdef LOCAL_MODULE 42 #include <ipmi.h> 43 #include <ipmivars.h> 44 #else 45 #include <sys/ipmi.h> 46 #include <dev/ipmi/ipmivars.h> 47 #endif 48 49 static void kcs_clear_obf(struct ipmi_softc *, int); 50 static void kcs_error(struct ipmi_softc *); 51 static int kcs_wait_for_ibf(struct ipmi_softc *, int); 52 static int kcs_wait_for_obf(struct ipmi_softc *, int); 53 54 static int 55 kcs_wait_for_ibf(struct ipmi_softc *sc, int state) 56 { 57 int status, start = ticks; 58 59 status = INB(sc, KCS_CTL_STS); 60 if (state == 0) { 61 /* WAIT FOR IBF = 0 */ 62 while (ticks - start < MAX_TIMEOUT && status & KCS_STATUS_IBF) { 63 DELAY(100); 64 status = INB(sc, KCS_CTL_STS); 65 } 66 } else { 67 /* WAIT FOR IBF = 1 */ 68 while (ticks - start < MAX_TIMEOUT && 69 !(status & KCS_STATUS_IBF)) { 70 DELAY(100); 71 status = INB(sc, KCS_CTL_STS); 72 } 73 } 74 return (status); 75 } 76 77 static int 78 kcs_wait_for_obf(struct ipmi_softc *sc, int state) 79 { 80 int status, start = ticks; 81 82 status = INB(sc, KCS_CTL_STS); 83 if (state == 0) { 84 /* WAIT FOR OBF = 0 */ 85 while (ticks - start < MAX_TIMEOUT && status & KCS_STATUS_OBF) { 86 DELAY(100); 87 status = INB(sc, KCS_CTL_STS); 88 } 89 } else { 90 /* WAIT FOR OBF = 1 */ 91 while (ticks - start < MAX_TIMEOUT && 92 !(status & KCS_STATUS_OBF)) { 93 DELAY(100); 94 status = INB(sc, KCS_CTL_STS); 95 } 96 } 97 return (status); 98 } 99 100 static void 101 kcs_clear_obf(struct ipmi_softc *sc, int status) 102 { 103 int data; 104 105 /* Clear OBF */ 106 if (status & KCS_STATUS_OBF) { 107 data = INB(sc, KCS_DATA); 108 } 109 } 110 111 static void 112 kcs_error(struct ipmi_softc *sc) 113 { 114 int retry, status; 115 u_char data; 116 117 for (retry = 0; retry < 2; retry++) { 118 119 /* Wait for IBF = 0 */ 120 status = kcs_wait_for_ibf(sc, 0); 121 122 /* ABORT */ 123 OUTB(sc, KCS_CTL_STS, KCS_CONTROL_GET_STATUS_ABORT); 124 125 /* Wait for IBF = 0 */ 126 status = kcs_wait_for_ibf(sc, 0); 127 128 /* Clear OBF */ 129 kcs_clear_obf(sc, status); 130 131 if (status & KCS_STATUS_OBF) { 132 data = INB(sc, KCS_DATA); 133 if (data != 0) 134 device_printf(sc->ipmi_dev, 135 "KCS Error Data %02x\n", data); 136 } 137 138 /* 0x00 to DATA_IN */ 139 OUTB(sc, KCS_DATA, 0x00); 140 141 /* Wait for IBF = 0 */ 142 status = kcs_wait_for_ibf(sc, 0); 143 144 if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_READ) { 145 146 /* Wait for OBF = 1 */ 147 status = kcs_wait_for_obf(sc, 1); 148 149 /* Read error status */ 150 data = INB(sc, KCS_DATA); 151 if (data != 0) 152 device_printf(sc->ipmi_dev, "KCS error: %02x\n", 153 data); 154 155 /* Write READ into Data_in */ 156 OUTB(sc, KCS_DATA, KCS_DATA_IN_READ); 157 158 /* Wait for IBF = 0 */ 159 status = kcs_wait_for_ibf(sc, 0); 160 } 161 162 /* IDLE STATE */ 163 if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_IDLE) { 164 /* Wait for OBF = 1 */ 165 status = kcs_wait_for_obf(sc, 1); 166 167 /* Clear OBF */ 168 kcs_clear_obf(sc, status); 169 return; 170 } 171 } 172 device_printf(sc->ipmi_dev, "KCS Error retry exhausted\n"); 173 } 174 175 /* 176 * Start to write a request. Waits for IBF to clear and then sends the 177 * WR_START command. 178 */ 179 static int 180 kcs_start_write(struct ipmi_softc *sc) 181 { 182 int retry, status; 183 184 for (retry = 0; retry < 10; retry++) { 185 /* Wait for IBF = 0 */ 186 status = kcs_wait_for_ibf(sc, 0); 187 188 /* Clear OBF */ 189 kcs_clear_obf(sc, status); 190 191 /* Write start to command */ 192 OUTB(sc, KCS_CTL_STS, KCS_CONTROL_WRITE_START); 193 194 /* Wait for IBF = 0 */ 195 status = kcs_wait_for_ibf(sc, 0); 196 if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_WRITE) 197 break; 198 DELAY(1000000); 199 } 200 201 if (KCS_STATUS_STATE(status) != KCS_STATUS_STATE_WRITE) 202 /* error state */ 203 return (0); 204 205 /* Clear OBF */ 206 kcs_clear_obf(sc, status); 207 208 return (1); 209 } 210 211 /* 212 * Write a byte of the request message, excluding the last byte of the 213 * message which requires special handling. 214 */ 215 static int 216 kcs_write_byte(struct ipmi_softc *sc, u_char data) 217 { 218 int status; 219 220 /* Data to Data */ 221 OUTB(sc, KCS_DATA, data); 222 223 /* Wait for IBF = 0 */ 224 status = kcs_wait_for_ibf(sc, 0); 225 226 if (KCS_STATUS_STATE(status) != KCS_STATUS_STATE_WRITE) 227 return (0); 228 229 /* Clear OBF */ 230 kcs_clear_obf(sc, status); 231 return (1); 232 } 233 234 /* 235 * Write the last byte of a request message. 236 */ 237 static int 238 kcs_write_last_byte(struct ipmi_softc *sc, u_char data) 239 { 240 int status; 241 242 /* Write end to command */ 243 OUTB(sc, KCS_CTL_STS, KCS_CONTROL_WRITE_END); 244 245 /* Wait for IBF = 0 */ 246 status = kcs_wait_for_ibf(sc, 0); 247 248 if (KCS_STATUS_STATE(status) != KCS_STATUS_STATE_WRITE) 249 /* error state */ 250 return (0); 251 252 /* Clear OBF */ 253 kcs_clear_obf(sc, status); 254 255 /* Send data byte to DATA. */ 256 OUTB(sc, KCS_DATA, data); 257 return (1); 258 } 259 260 /* 261 * Read one byte of the reply message. 262 */ 263 static int 264 kcs_read_byte(struct ipmi_softc *sc, u_char *data) 265 { 266 int status; 267 u_char dummy; 268 269 /* Wait for IBF = 0 */ 270 status = kcs_wait_for_ibf(sc, 0); 271 272 /* Read State */ 273 if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_READ) { 274 275 /* Wait for OBF = 1 */ 276 status = kcs_wait_for_obf(sc, 1); 277 278 /* Read Data_out */ 279 *data = INB(sc, KCS_DATA); 280 281 /* Write READ into Data_in */ 282 OUTB(sc, KCS_DATA, KCS_DATA_IN_READ); 283 return (1); 284 } 285 286 /* Idle State */ 287 if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_IDLE) { 288 289 /* Wait for OBF = 1*/ 290 status = kcs_wait_for_obf(sc, 1); 291 292 /* Read Dummy */ 293 dummy = INB(sc, KCS_DATA); 294 return (2); 295 } 296 297 /* Error State */ 298 return (0); 299 } 300 301 /* 302 * Send a request message and collect the reply. Returns true if we 303 * succeed. 304 */ 305 static int 306 kcs_polled_request(struct ipmi_softc *sc, struct ipmi_request *req) 307 { 308 u_char *cp, data; 309 int i, state; 310 311 /* Send the request. */ 312 if (!kcs_start_write(sc)) { 313 device_printf(sc->ipmi_dev, "KCS: Failed to start write\n"); 314 goto fail; 315 } 316 #ifdef KCS_DEBUG 317 device_printf(sc->ipmi_dev, "KCS: WRITE_START... ok\n"); 318 #endif 319 320 if (!kcs_write_byte(sc, req->ir_addr)) { 321 device_printf(sc->ipmi_dev, "KCS: Failed to write address\n"); 322 goto fail; 323 } 324 #ifdef KCS_DEBUG 325 device_printf(sc->ipmi_dev, "KCS: Wrote address: %02x\n", req->ir_addr); 326 #endif 327 328 if (req->ir_requestlen == 0) { 329 if (!kcs_write_last_byte(sc, req->ir_command)) { 330 device_printf(sc->ipmi_dev, 331 "KCS: Failed to write command\n"); 332 goto fail; 333 } 334 #ifdef KCS_DEBUG 335 device_printf(sc->ipmi_dev, "KCS: Wrote command: %02x\n", 336 req->ir_command); 337 #endif 338 } else { 339 if (!kcs_write_byte(sc, req->ir_command)) { 340 device_printf(sc->ipmi_dev, 341 "KCS: Failed to write command\n"); 342 goto fail; 343 } 344 #ifdef KCS_DEBUG 345 device_printf(sc->ipmi_dev, "KCS: Wrote command: %02x\n", 346 req->ir_command); 347 #endif 348 349 cp = req->ir_request; 350 for (i = 0; i < req->ir_requestlen - 1; i++) { 351 if (!kcs_write_byte(sc, *cp++)) { 352 device_printf(sc->ipmi_dev, 353 "KCS: Failed to write data byte %d\n", 354 i + 1); 355 goto fail; 356 } 357 #ifdef KCS_DEBUG 358 device_printf(sc->ipmi_dev, "KCS: Wrote data: %02x\n", 359 cp[-1]); 360 #endif 361 } 362 363 if (!kcs_write_last_byte(sc, *cp)) { 364 device_printf(sc->ipmi_dev, 365 "KCS: Failed to write last dta byte\n"); 366 goto fail; 367 } 368 #ifdef KCS_DEBUG 369 device_printf(sc->ipmi_dev, "KCS: Wrote last data: %02x\n", 370 *cp); 371 #endif 372 } 373 374 /* Read the reply. First, read the NetFn/LUN. */ 375 if (kcs_read_byte(sc, &data) != 1) { 376 device_printf(sc->ipmi_dev, "KCS: Failed to read address\n"); 377 goto fail; 378 } 379 #ifdef KCS_DEBUG 380 device_printf(sc->ipmi_dev, "KCS: Read address: %02x\n", data); 381 #endif 382 if (data != IPMI_REPLY_ADDR(req->ir_addr)) { 383 device_printf(sc->ipmi_dev, "KCS: Reply address mismatch\n"); 384 goto fail; 385 } 386 387 /* Next we read the command. */ 388 if (kcs_read_byte(sc, &data) != 1) { 389 device_printf(sc->ipmi_dev, "KCS: Failed to read command\n"); 390 goto fail; 391 } 392 #ifdef KCS_DEBUG 393 device_printf(sc->ipmi_dev, "KCS: Read command: %02x\n", data); 394 #endif 395 if (data != req->ir_command) { 396 device_printf(sc->ipmi_dev, "KCS: Command mismatch\n"); 397 goto fail; 398 } 399 400 /* Next we read the completion code. */ 401 if (kcs_read_byte(sc, &req->ir_compcode) != 1) { 402 device_printf(sc->ipmi_dev, 403 "KCS: Failed to read completion code\n"); 404 goto fail; 405 } 406 #ifdef KCS_DEBUG 407 device_printf(sc->ipmi_dev, "KCS: Read completion code: %02x\n", 408 req->ir_compcode); 409 #endif 410 411 /* Finally, read the reply from the BMC. */ 412 i = 0; 413 for (;;) { 414 state = kcs_read_byte(sc, &data); 415 if (state == 0) { 416 device_printf(sc->ipmi_dev, 417 "KCS: Read failed on byte %d\n", i + 1); 418 goto fail; 419 } 420 if (state == 2) 421 break; 422 if (i < req->ir_replybuflen) { 423 req->ir_reply[i] = data; 424 #ifdef KCS_DEBUG 425 device_printf(sc->ipmi_dev, "KCS: Read data %02x\n", 426 data); 427 } else { 428 device_printf(sc->ipmi_dev, 429 "KCS: Read short %02x byte %d\n", data, i + 1); 430 #endif 431 } 432 i++; 433 } 434 req->ir_replylen = i; 435 #ifdef KCS_DEBUG 436 device_printf(sc->ipmi_dev, "KCS: READ finished (%d bytes)\n", i); 437 if (req->ir_replybuflen < i) 438 #else 439 if (req->ir_replybuflen < i && req->ir_replybuflen != 0) 440 #endif 441 device_printf(sc->ipmi_dev, 442 "KCS: Read short: %zd buffer, %d actual\n", 443 req->ir_replybuflen, i); 444 return (1); 445 fail: 446 kcs_error(sc); 447 return (0); 448 } 449 450 static void 451 kcs_loop(void *arg) 452 { 453 struct ipmi_softc *sc = arg; 454 struct ipmi_request *req; 455 int i, ok; 456 457 IPMI_LOCK(sc); 458 while ((req = ipmi_dequeue_request(sc)) != NULL) { 459 ok = 0; 460 for (i = 0; i < 3 && !ok; i++) 461 ok = kcs_polled_request(sc, req); 462 if (ok) 463 req->ir_error = 0; 464 else 465 req->ir_error = EIO; 466 ipmi_complete_request(sc, req); 467 } 468 IPMI_UNLOCK(sc); 469 kproc_exit(0); 470 } 471 472 static int 473 kcs_startup(struct ipmi_softc *sc) 474 { 475 476 return (kproc_create(kcs_loop, sc, &sc->ipmi_kthread, 0, 0, "%s: kcs", 477 device_get_nameunit(sc->ipmi_dev))); 478 } 479 480 int 481 ipmi_kcs_attach(struct ipmi_softc *sc) 482 { 483 int status; 484 485 /* Setup function pointers. */ 486 sc->ipmi_startup = kcs_startup; 487 sc->ipmi_enqueue_request = ipmi_polled_enqueue_request; 488 489 /* See if we can talk to the controller. */ 490 status = INB(sc, KCS_CTL_STS); 491 if (status == 0xff) { 492 device_printf(sc->ipmi_dev, "couldn't find it\n"); 493 return (ENXIO); 494 } 495 496 #ifdef KCS_DEBUG 497 device_printf(sc->ipmi_dev, "KCS: initial state: %02x\n", status); 498 #endif 499 if (status & KCS_STATUS_OBF || 500 KCS_STATUS_STATE(status) != KCS_STATUS_STATE_IDLE) 501 kcs_error(sc); 502 503 return (0); 504 } 505 506 /* 507 * Determine the alignment automatically for a PCI attachment. In this case, 508 * any unused bytes will return 0x00 when read. We make use of the C/D bit 509 * in the CTL_STS register to try to start a GET_STATUS transaction. When 510 * we write the command, that bit should be set, so we should get a non-zero 511 * value back when we read CTL_STS if the offset we are testing is the CTL_STS 512 * register. 513 */ 514 int 515 ipmi_kcs_probe_align(struct ipmi_softc *sc) 516 { 517 int data, status; 518 519 sc->ipmi_io_spacing = 1; 520 retry: 521 #ifdef KCS_DEBUG 522 device_printf(sc->ipmi_dev, "Trying KCS align %d... ", sc->ipmi_io_spacing); 523 #endif 524 525 /* Wait for IBF = 0 */ 526 status = INB(sc, KCS_CTL_STS); 527 while (status & KCS_STATUS_IBF) { 528 DELAY(100); 529 status = INB(sc, KCS_CTL_STS); 530 } 531 532 OUTB(sc, KCS_CTL_STS, KCS_CONTROL_GET_STATUS_ABORT); 533 534 /* Wait for IBF = 0 */ 535 status = INB(sc, KCS_CTL_STS); 536 while (status & KCS_STATUS_IBF) { 537 DELAY(100); 538 status = INB(sc, KCS_CTL_STS); 539 } 540 541 /* If we got 0x00 back, then this must not be the CTL_STS register. */ 542 if (status == 0) { 543 #ifdef KCS_DEBUG 544 printf("failed\n"); 545 #endif 546 sc->ipmi_io_spacing <<= 1; 547 if (sc->ipmi_io_spacing > 4) 548 return (0); 549 goto retry; 550 } 551 #ifdef KCS_DEBUG 552 printf("ok\n"); 553 #endif 554 555 /* Finish out the transaction. */ 556 557 /* Clear OBF */ 558 if (status && KCS_STATUS_OBF) 559 data = INB(sc, KCS_DATA); 560 561 /* 0x00 to DATA_IN */ 562 OUTB(sc, KCS_DATA, 0); 563 564 /* Wait for IBF = 0 */ 565 status = INB(sc, KCS_CTL_STS); 566 while (status & KCS_STATUS_IBF) { 567 DELAY(100); 568 status = INB(sc, KCS_CTL_STS); 569 } 570 571 if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_READ) { 572 /* Wait for IBF = 1 */ 573 while (!(status & KCS_STATUS_OBF)) { 574 DELAY(100); 575 status = INB(sc, KCS_CTL_STS); 576 } 577 578 /* Read error status. */ 579 data = INB(sc, KCS_DATA); 580 581 /* Write dummy READ to DATA_IN. */ 582 OUTB(sc, KCS_DATA, KCS_DATA_IN_READ); 583 584 /* Wait for IBF = 0 */ 585 status = INB(sc, KCS_CTL_STS); 586 while (status & KCS_STATUS_IBF) { 587 DELAY(100); 588 status = INB(sc, KCS_CTL_STS); 589 } 590 } 591 592 if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_IDLE) { 593 /* Wait for IBF = 1 */ 594 while (!(status & KCS_STATUS_OBF)) { 595 DELAY(100); 596 status = INB(sc, KCS_CTL_STS); 597 } 598 599 /* Clear OBF */ 600 if (status && KCS_STATUS_OBF) 601 data = INB(sc, KCS_DATA); 602 } else 603 device_printf(sc->ipmi_dev, "KCS probe: end state %x\n", 604 KCS_STATUS_STATE(status)); 605 606 return (1); 607 } 608