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