sys/dev/ipmi/ipmi_kcs.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   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/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/systm.h>
  34 #include <sys/bus.h>
  35 #include <sys/condvar.h>
  36 #include <sys/eventhandler.h>
  37 #include <sys/kernel.h>
  38 #include <sys/kthread.h>
  39 #include <sys/rman.h>
  40 #include <sys/selinfo.h>
  41 #include <machine/bus.h>
  42
  43 #ifdef LOCAL_MODULE
  44 #include <ipmi.h>
  45 #include <ipmivars.h>
  46 #else
  47 #include <sys/ipmi.h>
  48 #include <dev/ipmi/ipmivars.h>
  49 #endif
  50
  51 #define POLLING_DELAY_MIN 4     /* Waits are 2-3 usecs on typical systems */
  52 #define POLLING_DELAY_MAX 256
  53
  54 static void     kcs_clear_obf(struct ipmi_softc *, int);
  55 static void     kcs_error(struct ipmi_softc *);
  56 static int      kcs_wait_for_ibf(struct ipmi_softc *, bool);
  57 static int      kcs_wait_for_obf(struct ipmi_softc *, bool);
  58
  59 static int
  60 kcs_wait(struct ipmi_softc *sc, int value, int mask)
  61 {
  62         int status, start = ticks;
  63         int delay_usec = POLLING_DELAY_MIN;
  64
  65         status = INB(sc, KCS_CTL_STS);
  66         while (ticks - start < MAX_TIMEOUT && (status & mask) != value) {
  67                 /*
  68                  * The wait delay is increased exponentially to avoid putting
  69                  * significant load on I/O bus.
  70                  */
  71                 DELAY(delay_usec);
  72                 status = INB(sc, KCS_CTL_STS);
  73                 if (delay_usec < POLLING_DELAY_MAX)
  74                         delay_usec *= 2;
  75         }
  76         return (status);
  77 }
  78
  79 static int
  80 kcs_wait_for_ibf(struct ipmi_softc *sc, bool level)
  81 {
  82
  83         return (kcs_wait(sc, level ? KCS_STATUS_IBF : 0, KCS_STATUS_IBF));
  84 }
  85
  86 static int
  87 kcs_wait_for_obf(struct ipmi_softc *sc, bool level)
  88 {
  89
  90         return (kcs_wait(sc, level ? KCS_STATUS_OBF : 0, KCS_STATUS_OBF));
  91 }
  92
  93 static void
  94 kcs_clear_obf(struct ipmi_softc *sc, int status)
  95 {
  96         int data;
  97
  98         /* Clear OBF */
  99         if (status & KCS_STATUS_OBF) {
 100                 data = INB(sc, KCS_DATA);
 101         }
 102 }
 103
 104 static void
 105 kcs_error(struct ipmi_softc *sc)
 106 {
 107         int retry, status;
 108         u_char data;
 109
 110         for (retry = 0; retry < 2; retry++) {
 111
 112                 /* Wait for IBF = 0 */
 113                 status = kcs_wait_for_ibf(sc, 0);
 114
 115                 /* ABORT */
 116                 OUTB(sc, KCS_CTL_STS, KCS_CONTROL_GET_STATUS_ABORT);
 117
 118                 /* Wait for IBF = 0 */
 119                 status = kcs_wait_for_ibf(sc, 0);
 120
 121                 /* Clear OBF */
 122                 kcs_clear_obf(sc, status);
 123
 124                 if (status & KCS_STATUS_OBF) {
 125                         data = INB(sc, KCS_DATA);
 126                         if (data != 0)
 127                                 device_printf(sc->ipmi_dev,
 128                                     "KCS Error Data %02x\n", data);
 129                 }
 130
 131                 /* 0x00 to DATA_IN */
 132                 OUTB(sc, KCS_DATA, 0x00);
 133
 134                 /* Wait for IBF = 0 */
 135                 status = kcs_wait_for_ibf(sc, 0);
 136
 137                 if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_READ) {
 138
 139                         /* Wait for OBF = 1 */
 140                         status = kcs_wait_for_obf(sc, 1);
 141
 142                         /* Read error status */
 143                         data = INB(sc, KCS_DATA);
 144                         if (data != 0 && (data != 0xff || bootverbose))
 145                                 device_printf(sc->ipmi_dev, "KCS error: %02x\n",
 146                                     data);
 147
 148                         /* Write READ into Data_in */
 149                         OUTB(sc, KCS_DATA, KCS_DATA_IN_READ);
 150
 151                         /* Wait for IBF = 0 */
 152                         status = kcs_wait_for_ibf(sc, 0);
 153                 }
 154
 155                 /* IDLE STATE */
 156                 if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_IDLE) {
 157                         /* Wait for OBF = 1 */
 158                         status = kcs_wait_for_obf(sc, 1);
 159
 160                         /* Clear OBF */
 161                         kcs_clear_obf(sc, status);
 162                         return;
 163                 }
 164         }
 165         device_printf(sc->ipmi_dev, "KCS: Error retry exhausted\n");
 166 }
 167
 168 /*
 169  * Start to write a request.  Waits for IBF to clear and then sends the
 170  * WR_START command.
 171  */
 172 static int
 173 kcs_start_write(struct ipmi_softc *sc)
 174 {
 175         int retry, status;
 176
 177         for (retry = 0; retry < 10; retry++) {
 178                 /* Wait for IBF = 0 */
 179                 status = kcs_wait_for_ibf(sc, 0);
 180                 if (status & KCS_STATUS_IBF)
 181                         return (0);
 182
 183                 /* Clear OBF */
 184                 kcs_clear_obf(sc, status);
 185
 186                 /* Write start to command */
 187                 OUTB(sc, KCS_CTL_STS, KCS_CONTROL_WRITE_START);
 188
 189                 /* Wait for IBF = 0 */
 190                 status = kcs_wait_for_ibf(sc, 0);
 191                 if (status & KCS_STATUS_IBF)
 192                         return (0);
 193
 194                 if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_WRITE)
 195                         break;
 196                 DELAY(1000000);
 197         }
 198
 199         if (KCS_STATUS_STATE(status) != KCS_STATUS_STATE_WRITE)
 200                 /* error state */
 201                 return (0);
 202
 203         /* Clear OBF */
 204         kcs_clear_obf(sc, status);
 205
 206         return (1);
 207 }
 208
 209 /*
 210  * Write a byte of the request message, excluding the last byte of the
 211  * message which requires special handling.
 212  */
 213 static int
 214 kcs_write_byte(struct ipmi_softc *sc, u_char data)
 215 {
 216         int status;
 217
 218         /* Data to Data */
 219         OUTB(sc, KCS_DATA, data);
 220
 221         /* Wait for IBF = 0 */
 222         status = kcs_wait_for_ibf(sc, 0);
 223         if (status & KCS_STATUS_IBF)
 224                 return (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         if (status & KCS_STATUS_IBF)
 248                 return (0);
 249
 250         if (KCS_STATUS_STATE(status) != KCS_STATUS_STATE_WRITE)
 251                 /* error state */
 252                 return (0);
 253
 254         /* Clear OBF */
 255         kcs_clear_obf(sc, status);
 256
 257         /* Send data byte to DATA. */
 258         OUTB(sc, KCS_DATA, data);
 259         return (1);
 260 }
 261
 262 /*
 263  * Read one byte of the reply message.
 264  */
 265 static int
 266 kcs_read_byte(struct ipmi_softc *sc, u_char *data)
 267 {
 268         int status;
 269         u_char dummy;
 270
 271         /* Wait for IBF = 0 */
 272         status = kcs_wait_for_ibf(sc, 0);
 273
 274         /* Read State */
 275         if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_READ) {
 276
 277                 /* Wait for OBF = 1 */
 278                 status = kcs_wait_for_obf(sc, 1);
 279                 if ((status & KCS_STATUS_OBF) == 0)
 280                         return (0);
 281
 282                 /* Read Data_out */
 283                 *data = INB(sc, KCS_DATA);
 284
 285                 /* Write READ into Data_in */
 286                 OUTB(sc, KCS_DATA, KCS_DATA_IN_READ);
 287                 return (1);
 288         }
 289
 290         /* Idle State */
 291         if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_IDLE) {
 292
 293                 /* Wait for OBF = 1*/
 294                 status = kcs_wait_for_obf(sc, 1);
 295                 if ((status & KCS_STATUS_OBF) == 0)
 296                         return (0);
 297
 298                 /* Read Dummy */
 299                 dummy = INB(sc, KCS_DATA);
 300                 return (2);
 301         }
 302
 303         /* Error State */
 304         return (0);
 305 }
 306
 307 /*
 308  * Send a request message and collect the reply.  Returns true if we
 309  * succeed.
 310  */
 311 static int
 312 kcs_polled_request(struct ipmi_softc *sc, struct ipmi_request *req)
 313 {
 314         u_char *cp, data;
 315         int i, state;
 316
 317         IPMI_IO_LOCK(sc);
 318
 319         /* Send the request. */
 320         if (!kcs_start_write(sc)) {
 321                 device_printf(sc->ipmi_dev, "KCS: Failed to start write\n");
 322                 goto fail;
 323         }
 324 #ifdef KCS_DEBUG
 325         device_printf(sc->ipmi_dev, "KCS: WRITE_START... ok\n");
 326 #endif
 327
 328         if (!kcs_write_byte(sc, req->ir_addr)) {
 329                 device_printf(sc->ipmi_dev, "KCS: Failed to write address\n");
 330                 goto fail;
 331         }
 332 #ifdef KCS_DEBUG
 333         device_printf(sc->ipmi_dev, "KCS: Wrote address: %02x\n", req->ir_addr);
 334 #endif
 335
 336         if (req->ir_requestlen == 0) {
 337                 if (!kcs_write_last_byte(sc, req->ir_command)) {
 338                         device_printf(sc->ipmi_dev,
 339                             "KCS: Failed to write command\n");
 340                         goto fail;
 341                 }
 342 #ifdef KCS_DEBUG
 343                 device_printf(sc->ipmi_dev, "KCS: Wrote command: %02x\n",
 344                     req->ir_command);
 345 #endif
 346         } else {
 347                 if (!kcs_write_byte(sc, req->ir_command)) {
 348                         device_printf(sc->ipmi_dev,
 349                             "KCS: Failed to write command\n");
 350                         goto fail;
 351                 }
 352 #ifdef KCS_DEBUG
 353                 device_printf(sc->ipmi_dev, "KCS: Wrote command: %02x\n",
 354                     req->ir_command);
 355 #endif
 356
 357                 cp = req->ir_request;
 358                 for (i = 0; i < req->ir_requestlen - 1; i++) {
 359                         if (!kcs_write_byte(sc, *cp++)) {
 360                                 device_printf(sc->ipmi_dev,
 361                                     "KCS: Failed to write data byte %d\n",
 362                                     i + 1);
 363                                 goto fail;
 364                         }
 365 #ifdef KCS_DEBUG
 366                         device_printf(sc->ipmi_dev, "KCS: Wrote data: %02x\n",
 367                             cp[-1]);
 368 #endif
 369                 }
 370
 371                 if (!kcs_write_last_byte(sc, *cp)) {
 372                         device_printf(sc->ipmi_dev,
 373                             "KCS: Failed to write last dta byte\n");
 374                         goto fail;
 375                 }
 376 #ifdef KCS_DEBUG
 377                 device_printf(sc->ipmi_dev, "KCS: Wrote last data: %02x\n",
 378                     *cp);
 379 #endif
 380         }
 381
 382         /* Read the reply.  First, read the NetFn/LUN. */
 383         if (kcs_read_byte(sc, &data) != 1) {
 384                 device_printf(sc->ipmi_dev, "KCS: Failed to read address\n");
 385                 goto fail;
 386         }
 387 #ifdef KCS_DEBUG
 388         device_printf(sc->ipmi_dev, "KCS: Read address: %02x\n", data);
 389 #endif
 390         if (data != IPMI_REPLY_ADDR(req->ir_addr)) {
 391                 device_printf(sc->ipmi_dev, "KCS: Reply address mismatch\n");
 392                 goto fail;
 393         }
 394
 395         /* Next we read the command. */
 396         if (kcs_read_byte(sc, &data) != 1) {
 397                 device_printf(sc->ipmi_dev, "KCS: Failed to read command\n");
 398                 goto fail;
 399         }
 400 #ifdef KCS_DEBUG
 401         device_printf(sc->ipmi_dev, "KCS: Read command: %02x\n", data);
 402 #endif
 403         if (data != req->ir_command) {
 404                 device_printf(sc->ipmi_dev, "KCS: Command mismatch\n");
 405                 goto fail;
 406         }
 407
 408         /* Next we read the completion code. */
 409         if (kcs_read_byte(sc, &req->ir_compcode) != 1) {
 410                 if (bootverbose) {
 411                         device_printf(sc->ipmi_dev,
 412                             "KCS: Failed to read completion code\n");
 413                 }
 414                 goto fail;
 415         }
 416 #ifdef KCS_DEBUG
 417         device_printf(sc->ipmi_dev, "KCS: Read completion code: %02x\n",
 418             req->ir_compcode);
 419 #endif
 420
 421         /* Finally, read the reply from the BMC. */
 422         i = 0;
 423         for (;;) {
 424                 state = kcs_read_byte(sc, &data);
 425                 if (state == 0) {
 426                         device_printf(sc->ipmi_dev,
 427                             "KCS: Read failed on byte %d\n", i + 1);
 428                         goto fail;
 429                 }
 430                 if (state == 2)
 431                         break;
 432                 if (i < req->ir_replybuflen) {
 433                         req->ir_reply[i] = data;
 434 #ifdef KCS_DEBUG
 435                         device_printf(sc->ipmi_dev, "KCS: Read data %02x\n",
 436                             data);
 437                 } else {
 438                         device_printf(sc->ipmi_dev,
 439                             "KCS: Read short %02x byte %d\n", data, i + 1);
 440 #endif
 441                 }
 442                 i++;
 443         }
 444         IPMI_IO_UNLOCK(sc);
 445         req->ir_replylen = i;
 446 #ifdef KCS_DEBUG
 447         device_printf(sc->ipmi_dev, "KCS: READ finished (%d bytes)\n", i);
 448         if (req->ir_replybuflen < i)
 449 #else
 450         if (req->ir_replybuflen < i && req->ir_replybuflen != 0)
 451 #endif
 452                 device_printf(sc->ipmi_dev,
 453                     "KCS: Read short: %zd buffer, %d actual\n",
 454                     req->ir_replybuflen, i);
 455         return (1);
 456 fail:
 457         kcs_error(sc);
 458         IPMI_IO_UNLOCK(sc);
 459         return (0);
 460 }
 461
 462 static void
 463 kcs_loop(void *arg)
 464 {
 465         struct ipmi_softc *sc = arg;
 466         struct ipmi_request *req;
 467         int i, ok;
 468
 469         IPMI_LOCK(sc);
 470         while ((req = ipmi_dequeue_request(sc)) != NULL) {
 471                 IPMI_UNLOCK(sc);
 472                 ok = 0;
 473                 for (i = 0; i < 3 && !ok; i++)
 474                         ok = kcs_polled_request(sc, req);
 475                 if (ok)
 476                         req->ir_error = 0;
 477                 else
 478                         req->ir_error = EIO;
 479                 IPMI_LOCK(sc);
 480                 ipmi_complete_request(sc, req);
 481         }
 482         IPMI_UNLOCK(sc);
 483         kproc_exit(0);
 484 }
 485
 486 static int
 487 kcs_startup(struct ipmi_softc *sc)
 488 {
 489
 490         return (kproc_create(kcs_loop, sc, &sc->ipmi_kthread, 0, 0, "%s: kcs",
 491             device_get_nameunit(sc->ipmi_dev)));
 492 }
 493
 494 static int
 495 kcs_driver_request(struct ipmi_softc *sc, struct ipmi_request *req, int timo)
 496 {
 497         int i, ok;
 498
 499         ok = 0;
 500         for (i = 0; i < 3 && !ok; i++)
 501                 ok = kcs_polled_request(sc, req);
 502         if (ok)
 503                 req->ir_error = 0;
 504         else
 505                 req->ir_error = EIO;
 506         return (req->ir_error);
 507 }
 508
 509 int
 510 ipmi_kcs_attach(struct ipmi_softc *sc)
 511 {
 512         int status;
 513
 514         /* Setup function pointers. */
 515         sc->ipmi_startup = kcs_startup;
 516         sc->ipmi_enqueue_request = ipmi_polled_enqueue_request;
 517         sc->ipmi_driver_request = kcs_driver_request;
 518         sc->ipmi_driver_requests_polled = 1;
 519
 520         /* See if we can talk to the controller. */
 521         status = INB(sc, KCS_CTL_STS);
 522         if (status == 0xff) {
 523                 device_printf(sc->ipmi_dev, "couldn't find it\n");
 524                 return (ENXIO);
 525         }
 526
 527 #ifdef KCS_DEBUG
 528         device_printf(sc->ipmi_dev, "KCS: initial state: %02x\n", status);
 529 #endif
 530         if (status & KCS_STATUS_OBF ||
 531             KCS_STATUS_STATE(status) != KCS_STATUS_STATE_IDLE)
 532                 kcs_error(sc);
 533
 534         return (0);
 535 }
 536
 537 /*
 538  * Determine the alignment automatically for a PCI attachment.  In this case,
 539  * any unused bytes will return 0x00 when read.  We make use of the C/D bit
 540  * in the CTL_STS register to try to start a GET_STATUS transaction.  When
 541  * we write the command, that bit should be set, so we should get a non-zero
 542  * value back when we read CTL_STS if the offset we are testing is the CTL_STS
 543  * register.
 544  */
 545 int
 546 ipmi_kcs_probe_align(struct ipmi_softc *sc)
 547 {
 548         int data, status;
 549
 550         sc->ipmi_io_spacing = 1;
 551 retry:
 552 #ifdef KCS_DEBUG
 553         device_printf(sc->ipmi_dev, "Trying KCS align %d... ", sc->ipmi_io_spacing);
 554 #endif
 555
 556         /* Wait for IBF = 0 */
 557         status = INB(sc, KCS_CTL_STS);
 558         while (status & KCS_STATUS_IBF) {
 559                 DELAY(100);
 560                 status = INB(sc, KCS_CTL_STS);
 561         }
 562
 563         OUTB(sc, KCS_CTL_STS, KCS_CONTROL_GET_STATUS_ABORT);
 564
 565         /* Wait for IBF = 0 */
 566         status = INB(sc, KCS_CTL_STS);
 567         while (status & KCS_STATUS_IBF) {
 568                 DELAY(100);
 569                 status = INB(sc, KCS_CTL_STS);
 570         }
 571
 572         /* If we got 0x00 back, then this must not be the CTL_STS register. */
 573         if (status == 0) {
 574 #ifdef KCS_DEBUG
 575                 printf("failed\n");
 576 #endif
 577                 sc->ipmi_io_spacing <<= 1;
 578                 if (sc->ipmi_io_spacing > 4)
 579                         return (0);
 580                 goto retry;
 581         }
 582 #ifdef KCS_DEBUG
 583         printf("ok\n");
 584 #endif
 585
 586         /* Finish out the transaction. */
 587
 588         /* Clear OBF */
 589         if (status & KCS_STATUS_OBF)
 590                 data = INB(sc, KCS_DATA);
 591
 592         /* 0x00 to DATA_IN */
 593         OUTB(sc, KCS_DATA, 0);
 594
 595         /* Wait for IBF = 0 */
 596         status = INB(sc, KCS_CTL_STS);
 597         while (status & KCS_STATUS_IBF) {
 598                 DELAY(100);
 599                 status = INB(sc, KCS_CTL_STS);
 600         }
 601
 602         if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_READ) {
 603                 /* Wait for IBF = 1 */
 604                 while (!(status & KCS_STATUS_OBF)) {
 605                         DELAY(100);
 606                         status = INB(sc, KCS_CTL_STS);
 607                 }
 608
 609                 /* Read error status. */
 610                 data = INB(sc, KCS_DATA);
 611
 612                 /* Write dummy READ to DATA_IN. */
 613                 OUTB(sc, KCS_DATA, KCS_DATA_IN_READ);
 614
 615                 /* Wait for IBF = 0 */
 616                 status = INB(sc, KCS_CTL_STS);
 617                 while (status & KCS_STATUS_IBF) {
 618                         DELAY(100);
 619                         status = INB(sc, KCS_CTL_STS);
 620                 }
 621         }
 622
 623         if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_IDLE) {
 624                 /* Wait for IBF = 1 */
 625                 while (!(status & KCS_STATUS_OBF)) {
 626                         DELAY(100);
 627                         status = INB(sc, KCS_CTL_STS);
 628                 }
 629
 630                 /* Clear OBF */
 631                 if (status & KCS_STATUS_OBF)
 632                         data = INB(sc, KCS_DATA);
 633         } else
 634                 device_printf(sc->ipmi_dev, "KCS probe: end state %x\n",
 635                     KCS_STATUS_STATE(status));
 636
 637         return (1);
 638 }