sys/dev/ipmi/ipmi_kcs.c

   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                 if (status & KCS_STATUS_IBF)
 188                         return (0);
 189
 190                 /* Clear OBF */
 191                 kcs_clear_obf(sc, status);
 192
 193                 /* Write start to command */
 194                 OUTB(sc, KCS_CTL_STS, KCS_CONTROL_WRITE_START);
 195
 196                 /* Wait for IBF = 0 */
 197                 status = kcs_wait_for_ibf(sc, 0);
 198                 if (status & KCS_STATUS_IBF)
 199                         return (0);
 200
 201                 if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_WRITE)
 202                         break;
 203                 DELAY(1000000);
 204         }
 205
 206         if (KCS_STATUS_STATE(status) != KCS_STATUS_STATE_WRITE)
 207                 /* error state */
 208                 return (0);
 209
 210         /* Clear OBF */
 211         kcs_clear_obf(sc, status);
 212
 213         return (1);
 214 }
 215
 216 /*
 217  * Write a byte of the request message, excluding the last byte of the
 218  * message which requires special handling.
 219  */
 220 static int
 221 kcs_write_byte(struct ipmi_softc *sc, u_char data)
 222 {
 223         int status;
 224
 225         /* Data to Data */
 226         OUTB(sc, KCS_DATA, data);
 227
 228         /* Wait for IBF = 0 */
 229         status = kcs_wait_for_ibf(sc, 0);
 230         if (status & KCS_STATUS_IBF)
 231                 return (0);
 232
 233         if (KCS_STATUS_STATE(status) != KCS_STATUS_STATE_WRITE)
 234                 return (0);
 235
 236         /* Clear OBF */
 237         kcs_clear_obf(sc, status);
 238         return (1);
 239 }
 240
 241 /*
 242  * Write the last byte of a request message.
 243  */
 244 static int
 245 kcs_write_last_byte(struct ipmi_softc *sc, u_char data)
 246 {
 247         int status;
 248
 249         /* Write end to command */
 250         OUTB(sc, KCS_CTL_STS, KCS_CONTROL_WRITE_END);
 251
 252         /* Wait for IBF = 0 */
 253         status = kcs_wait_for_ibf(sc, 0);
 254         if (status & KCS_STATUS_IBF)
 255                 return (0);
 256
 257         if (KCS_STATUS_STATE(status) != KCS_STATUS_STATE_WRITE)
 258                 /* error state */
 259                 return (0);
 260
 261         /* Clear OBF */
 262         kcs_clear_obf(sc, status);
 263
 264         /* Send data byte to DATA. */
 265         OUTB(sc, KCS_DATA, data);
 266         return (1);
 267 }
 268
 269 /*
 270  * Read one byte of the reply message.
 271  */
 272 static int
 273 kcs_read_byte(struct ipmi_softc *sc, u_char *data)
 274 {
 275         int status;
 276         u_char dummy;
 277
 278         /* Wait for IBF = 0 */
 279         status = kcs_wait_for_ibf(sc, 0);
 280
 281         /* Read State */
 282         if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_READ) {
 283
 284                 /* Wait for OBF = 1 */
 285                 status = kcs_wait_for_obf(sc, 1);
 286                 if ((status & KCS_STATUS_OBF) == 0)
 287                         return (0);
 288
 289                 /* Read Data_out */
 290                 *data = INB(sc, KCS_DATA);
 291
 292                 /* Write READ into Data_in */
 293                 OUTB(sc, KCS_DATA, KCS_DATA_IN_READ);
 294                 return (1);
 295         }
 296
 297         /* Idle State */
 298         if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_IDLE) {
 299
 300                 /* Wait for OBF = 1*/
 301                 status = kcs_wait_for_obf(sc, 1);
 302                 if ((status & KCS_STATUS_OBF) == 0)
 303                         return (0);
 304
 305                 /* Read Dummy */
 306                 dummy = INB(sc, KCS_DATA);
 307                 return (2);
 308         }
 309
 310         /* Error State */
 311         return (0);
 312 }
 313
 314 /*
 315  * Send a request message and collect the reply.  Returns true if we
 316  * succeed.
 317  */
 318 static int
 319 kcs_polled_request(struct ipmi_softc *sc, struct ipmi_request *req)
 320 {
 321         u_char *cp, data;
 322         int i, state;
 323
 324         /* Send the request. */
 325         if (!kcs_start_write(sc)) {
 326                 device_printf(sc->ipmi_dev, "KCS: Failed to start write\n");
 327                 goto fail;
 328         }
 329 #ifdef KCS_DEBUG
 330         device_printf(sc->ipmi_dev, "KCS: WRITE_START... ok\n");
 331 #endif
 332
 333         if (!kcs_write_byte(sc, req->ir_addr)) {
 334                 device_printf(sc->ipmi_dev, "KCS: Failed to write address\n");
 335                 goto fail;
 336         }
 337 #ifdef KCS_DEBUG
 338         device_printf(sc->ipmi_dev, "KCS: Wrote address: %02x\n", req->ir_addr);
 339 #endif
 340
 341         if (req->ir_requestlen == 0) {
 342                 if (!kcs_write_last_byte(sc, req->ir_command)) {
 343                         device_printf(sc->ipmi_dev,
 344                             "KCS: Failed to write command\n");
 345                         goto fail;
 346                 }
 347 #ifdef KCS_DEBUG
 348                 device_printf(sc->ipmi_dev, "KCS: Wrote command: %02x\n",
 349                     req->ir_command);
 350 #endif
 351         } else {
 352                 if (!kcs_write_byte(sc, req->ir_command)) {
 353                         device_printf(sc->ipmi_dev,
 354                             "KCS: Failed to write command\n");
 355                         goto fail;
 356                 }
 357 #ifdef KCS_DEBUG
 358                 device_printf(sc->ipmi_dev, "KCS: Wrote command: %02x\n",
 359                     req->ir_command);
 360 #endif
 361
 362                 cp = req->ir_request;
 363                 for (i = 0; i < req->ir_requestlen - 1; i++) {
 364                         if (!kcs_write_byte(sc, *cp++)) {
 365                                 device_printf(sc->ipmi_dev,
 366                                     "KCS: Failed to write data byte %d\n",
 367                                     i + 1);
 368                                 goto fail;
 369                         }
 370 #ifdef KCS_DEBUG
 371                         device_printf(sc->ipmi_dev, "KCS: Wrote data: %02x\n",
 372                             cp[-1]);
 373 #endif
 374                 }
 375
 376                 if (!kcs_write_last_byte(sc, *cp)) {
 377                         device_printf(sc->ipmi_dev,
 378                             "KCS: Failed to write last dta byte\n");
 379                         goto fail;
 380                 }
 381 #ifdef KCS_DEBUG
 382                 device_printf(sc->ipmi_dev, "KCS: Wrote last data: %02x\n",
 383                     *cp);
 384 #endif
 385         }
 386
 387         /* Read the reply.  First, read the NetFn/LUN. */
 388         if (kcs_read_byte(sc, &data) != 1) {
 389                 device_printf(sc->ipmi_dev, "KCS: Failed to read address\n");
 390                 goto fail;
 391         }
 392 #ifdef KCS_DEBUG
 393         device_printf(sc->ipmi_dev, "KCS: Read address: %02x\n", data);
 394 #endif
 395         if (data != IPMI_REPLY_ADDR(req->ir_addr)) {
 396                 device_printf(sc->ipmi_dev, "KCS: Reply address mismatch\n");
 397                 goto fail;
 398         }
 399
 400         /* Next we read the command. */
 401         if (kcs_read_byte(sc, &data) != 1) {
 402                 device_printf(sc->ipmi_dev, "KCS: Failed to read command\n");
 403                 goto fail;
 404         }
 405 #ifdef KCS_DEBUG
 406         device_printf(sc->ipmi_dev, "KCS: Read command: %02x\n", data);
 407 #endif
 408         if (data != req->ir_command) {
 409                 device_printf(sc->ipmi_dev, "KCS: Command mismatch\n");
 410                 goto fail;
 411         }
 412
 413         /* Next we read the completion code. */
 414         if (kcs_read_byte(sc, &req->ir_compcode) != 1) {
 415                 device_printf(sc->ipmi_dev,
 416                     "KCS: Failed to read completion code\n");
 417                 goto fail;
 418         }
 419 #ifdef KCS_DEBUG
 420         device_printf(sc->ipmi_dev, "KCS: Read completion code: %02x\n",
 421             req->ir_compcode);
 422 #endif
 423
 424         /* Finally, read the reply from the BMC. */
 425         i = 0;
 426         for (;;) {
 427                 state = kcs_read_byte(sc, &data);
 428                 if (state == 0) {
 429                         device_printf(sc->ipmi_dev,
 430                             "KCS: Read failed on byte %d\n", i + 1);
 431                         goto fail;
 432                 }
 433                 if (state == 2)
 434                         break;
 435                 if (i < req->ir_replybuflen) {
 436                         req->ir_reply[i] = data;
 437 #ifdef KCS_DEBUG
 438                         device_printf(sc->ipmi_dev, "KCS: Read data %02x\n",
 439                             data);
 440                 } else {
 441                         device_printf(sc->ipmi_dev,
 442                             "KCS: Read short %02x byte %d\n", data, i + 1);
 443 #endif
 444                 }
 445                 i++;
 446         }
 447         req->ir_replylen = i;
 448 #ifdef KCS_DEBUG
 449         device_printf(sc->ipmi_dev, "KCS: READ finished (%d bytes)\n", i);
 450         if (req->ir_replybuflen < i)
 451 #else
 452         if (req->ir_replybuflen < i && req->ir_replybuflen != 0)
 453 #endif
 454                 device_printf(sc->ipmi_dev,
 455                     "KCS: Read short: %zd buffer, %d actual\n",
 456                     req->ir_replybuflen, i);
 457         return (1);
 458 fail:
 459         kcs_error(sc);
 460         return (0);
 461 }
 462
 463 static void
 464 kcs_loop(void *arg)
 465 {
 466         struct ipmi_softc *sc = arg;
 467         struct ipmi_request *req;
 468         int i, ok;
 469
 470         IPMI_LOCK(sc);
 471         while ((req = ipmi_dequeue_request(sc)) != NULL) {
 472                 IPMI_UNLOCK(sc);
 473                 ok = 0;
 474                 for (i = 0; i < 3 && !ok; i++)
 475                         ok = kcs_polled_request(sc, req);
 476                 if (ok)
 477                         req->ir_error = 0;
 478                 else
 479                         req->ir_error = EIO;
 480                 IPMI_LOCK(sc);
 481                 ipmi_complete_request(sc, req);
 482         }
 483         IPMI_UNLOCK(sc);
 484         kproc_exit(0);
 485 }
 486
 487 static int
 488 kcs_startup(struct ipmi_softc *sc)
 489 {
 490
 491         return (kproc_create(kcs_loop, sc, &sc->ipmi_kthread, 0, 0, "%s: kcs",
 492             device_get_nameunit(sc->ipmi_dev)));
 493 }
 494
 495 int
 496 ipmi_kcs_attach(struct ipmi_softc *sc)
 497 {
 498         int status;
 499
 500         /* Setup function pointers. */
 501         sc->ipmi_startup = kcs_startup;
 502         sc->ipmi_enqueue_request = ipmi_polled_enqueue_request;
 503
 504         /* See if we can talk to the controller. */
 505         status = INB(sc, KCS_CTL_STS);
 506         if (status == 0xff) {
 507                 device_printf(sc->ipmi_dev, "couldn't find it\n");
 508                 return (ENXIO);
 509         }
 510
 511 #ifdef KCS_DEBUG
 512         device_printf(sc->ipmi_dev, "KCS: initial state: %02x\n", status);
 513 #endif
 514         if (status & KCS_STATUS_OBF ||
 515             KCS_STATUS_STATE(status) != KCS_STATUS_STATE_IDLE)
 516                 kcs_error(sc);
 517
 518         return (0);
 519 }
 520
 521 /*
 522  * Determine the alignment automatically for a PCI attachment.  In this case,
 523  * any unused bytes will return 0x00 when read.  We make use of the C/D bit
 524  * in the CTL_STS register to try to start a GET_STATUS transaction.  When
 525  * we write the command, that bit should be set, so we should get a non-zero
 526  * value back when we read CTL_STS if the offset we are testing is the CTL_STS
 527  * register.
 528  */
 529 int
 530 ipmi_kcs_probe_align(struct ipmi_softc *sc)
 531 {
 532         int data, status;
 533
 534         sc->ipmi_io_spacing = 1;
 535 retry:
 536 #ifdef KCS_DEBUG
 537         device_printf(sc->ipmi_dev, "Trying KCS align %d... ", sc->ipmi_io_spacing);
 538 #endif
 539
 540         /* Wait for IBF = 0 */
 541         status = INB(sc, KCS_CTL_STS);
 542         while (status & KCS_STATUS_IBF) {
 543                 DELAY(100);
 544                 status = INB(sc, KCS_CTL_STS);
 545         }
 546
 547         OUTB(sc, KCS_CTL_STS, KCS_CONTROL_GET_STATUS_ABORT);
 548
 549         /* Wait for IBF = 0 */
 550         status = INB(sc, KCS_CTL_STS);
 551         while (status & KCS_STATUS_IBF) {
 552                 DELAY(100);
 553                 status = INB(sc, KCS_CTL_STS);
 554         }
 555
 556         /* If we got 0x00 back, then this must not be the CTL_STS register. */
 557         if (status == 0) {
 558 #ifdef KCS_DEBUG
 559                 printf("failed\n");
 560 #endif
 561                 sc->ipmi_io_spacing <<= 1;
 562                 if (sc->ipmi_io_spacing > 4)
 563                         return (0);
 564                 goto retry;
 565         }
 566 #ifdef KCS_DEBUG
 567         printf("ok\n");
 568 #endif
 569
 570         /* Finish out the transaction. */
 571
 572         /* Clear OBF */
 573         if (status & KCS_STATUS_OBF)
 574                 data = INB(sc, KCS_DATA);
 575
 576         /* 0x00 to DATA_IN */
 577         OUTB(sc, KCS_DATA, 0);
 578
 579         /* Wait for IBF = 0 */
 580         status = INB(sc, KCS_CTL_STS);
 581         while (status & KCS_STATUS_IBF) {
 582                 DELAY(100);
 583                 status = INB(sc, KCS_CTL_STS);
 584         }
 585
 586         if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_READ) {
 587                 /* Wait for IBF = 1 */
 588                 while (!(status & KCS_STATUS_OBF)) {
 589                         DELAY(100);
 590                         status = INB(sc, KCS_CTL_STS);
 591                 }
 592
 593                 /* Read error status. */
 594                 data = INB(sc, KCS_DATA);
 595
 596                 /* Write dummy READ to DATA_IN. */
 597                 OUTB(sc, KCS_DATA, KCS_DATA_IN_READ);
 598
 599                 /* Wait for IBF = 0 */
 600                 status = INB(sc, KCS_CTL_STS);
 601                 while (status & KCS_STATUS_IBF) {
 602                         DELAY(100);
 603                         status = INB(sc, KCS_CTL_STS);
 604                 }
 605         }
 606
 607         if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_IDLE) {
 608                 /* Wait for IBF = 1 */
 609                 while (!(status & KCS_STATUS_OBF)) {
 610                         DELAY(100);
 611                         status = INB(sc, KCS_CTL_STS);
 612                 }
 613
 614                 /* Clear OBF */
 615                 if (status & KCS_STATUS_OBF)
 616                         data = INB(sc, KCS_DATA);
 617         } else
 618                 device_printf(sc->ipmi_dev, "KCS probe: end state %x\n",
 619                     KCS_STATUS_STATE(status));
 620
 621         return (1);
 622 }