sys/dev/misc/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  * $FreeBSD: head/sys/dev/ipmi/ipmi_kcs.c 248705 2013-03-25 14:30:34Z melifaro $
  27  */
  28
  29 #include <sys/param.h>
  30 #include <sys/systm.h>
  31 #include <sys/bus.h>
  32 #include <sys/condvar.h>
  33 #include <sys/eventhandler.h>
  34 #include <sys/kernel.h>
  35 #include <sys/kthread.h>
  36 #include <sys/rman.h>
  37 #include <sys/conf.h>
  38
  39 #ifdef LOCAL_MODULE
  40 #include <ipmi.h>
  41 #include <ipmivars.h>
  42 #else
  43 #include <sys/ipmi.h>
  44 #include <dev/misc/ipmi/ipmivars.h>
  45 #endif
  46
  47 static void     kcs_clear_obf(struct ipmi_softc *, int);
  48 static void     kcs_error(struct ipmi_softc *);
  49 static int      kcs_wait_for_ibf(struct ipmi_softc *, int);
  50 static int      kcs_wait_for_obf(struct ipmi_softc *, int);
  51
  52 static int
  53 kcs_wait_for_ibf(struct ipmi_softc *sc, int state)
  54 {
  55         int status, start = ticks;
  56
  57         status = INB(sc, KCS_CTL_STS);
  58         if (state == 0) {
  59                 /* WAIT FOR IBF = 0 */
  60                 while (ticks - start < MAX_TIMEOUT && status & KCS_STATUS_IBF) {
  61                         DELAY(100);
  62                         status = INB(sc, KCS_CTL_STS);
  63                 }
  64         } else {
  65                 /* WAIT FOR IBF = 1 */
  66                 while (ticks - start < MAX_TIMEOUT &&
  67                     !(status & KCS_STATUS_IBF)) {
  68                         DELAY(100);
  69                         status = INB(sc, KCS_CTL_STS);
  70                 }
  71         }
  72         return (status);
  73 }
  74
  75 static int
  76 kcs_wait_for_obf(struct ipmi_softc *sc, int state)
  77 {
  78         int status, start = ticks;
  79
  80         status = INB(sc, KCS_CTL_STS);
  81         if (state == 0) {
  82                 /* WAIT FOR OBF = 0 */
  83                 while (ticks - start < MAX_TIMEOUT && status & KCS_STATUS_OBF) {
  84                         DELAY(100);
  85                         status = INB(sc, KCS_CTL_STS);
  86                 }
  87         } else {
  88                 /* WAIT FOR OBF = 1 */
  89                 while (ticks - start < MAX_TIMEOUT &&
  90                     !(status & KCS_STATUS_OBF)) {
  91                         DELAY(100);
  92                         status = INB(sc, KCS_CTL_STS);
  93                 }
  94         }
  95         return (status);
  96 }
  97
  98 static void
  99 kcs_clear_obf(struct ipmi_softc *sc, int status)
 100 {
 101         int data;
 102
 103         /* Clear OBF */
 104         if (status & KCS_STATUS_OBF) {
 105                 data = INB(sc, KCS_DATA);
 106         }
 107 }
 108
 109 static void
 110 kcs_error(struct ipmi_softc *sc)
 111 {
 112         int retry, status;
 113         u_char data;
 114
 115         for (retry = 0; retry < 2; retry++) {
 116
 117                 /* Wait for IBF = 0 */
 118                 status = kcs_wait_for_ibf(sc, 0);
 119
 120                 /* ABORT */
 121                 OUTB(sc, KCS_CTL_STS, KCS_CONTROL_GET_STATUS_ABORT);
 122
 123                 /* Wait for IBF = 0 */
 124                 status = kcs_wait_for_ibf(sc, 0);
 125
 126                 /* Clear OBF */
 127                 kcs_clear_obf(sc, status);
 128
 129                 if (status & KCS_STATUS_OBF) {
 130                         data = INB(sc, KCS_DATA);
 131                         if (data != 0)
 132                                 device_printf(sc->ipmi_dev,
 133                                     "KCS Error Data %02x\n", data);
 134                 }
 135
 136                 /* 0x00 to DATA_IN */
 137                 OUTB(sc, KCS_DATA, 0x00);
 138
 139                 /* Wait for IBF = 0 */
 140                 status = kcs_wait_for_ibf(sc, 0);
 141
 142                 if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_READ) {
 143
 144                         /* Wait for OBF = 1 */
 145                         status = kcs_wait_for_obf(sc, 1);
 146
 147                         /* Read error status */
 148                         data = INB(sc, KCS_DATA);
 149                         if (data != 0)
 150                                 device_printf(sc->ipmi_dev, "KCS error: %02x\n",
 151                                     data);
 152
 153                         /* Write READ into Data_in */
 154                         OUTB(sc, KCS_DATA, KCS_DATA_IN_READ);
 155
 156                         /* Wait for IBF = 0 */
 157                         status = kcs_wait_for_ibf(sc, 0);
 158                 }
 159
 160                 /* IDLE STATE */
 161                 if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_IDLE) {
 162                         /* Wait for OBF = 1 */
 163                         status = kcs_wait_for_obf(sc, 1);
 164
 165                         /* Clear OBF */
 166                         kcs_clear_obf(sc, status);
 167                         return;
 168                 }
 169         }
 170         device_printf(sc->ipmi_dev, "KCS: Error retry exhausted\n");
 171 }
 172
 173 /*
 174  * Start to write a request.  Waits for IBF to clear and then sends the
 175  * WR_START command.
 176  */
 177 static int
 178 kcs_start_write(struct ipmi_softc *sc)
 179 {
 180         int retry, status;
 181
 182         for (retry = 0; retry < 10; retry++) {
 183                 /* Wait for IBF = 0 */
 184                 status = kcs_wait_for_ibf(sc, 0);
 185
 186                 /* Clear OBF */
 187                 kcs_clear_obf(sc, status);
 188
 189                 /* Write start to command */
 190                 OUTB(sc, KCS_CTL_STS, KCS_CONTROL_WRITE_START);
 191
 192                 /* Wait for IBF = 0 */
 193                 status = kcs_wait_for_ibf(sc, 0);
 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
 224         if (KCS_STATUS_STATE(status) != KCS_STATUS_STATE_WRITE)
 225                 return (0);
 226
 227         /* Clear OBF */
 228         kcs_clear_obf(sc, status);
 229         return (1);
 230 }
 231
 232 /*
 233  * Write the last byte of a request message.
 234  */
 235 static int
 236 kcs_write_last_byte(struct ipmi_softc *sc, u_char data)
 237 {
 238         int status;
 239
 240         /* Write end to command */
 241         OUTB(sc, KCS_CTL_STS, KCS_CONTROL_WRITE_END);
 242
 243         /* Wait for IBF = 0 */
 244         status = kcs_wait_for_ibf(sc, 0);
 245
 246         if (KCS_STATUS_STATE(status) != KCS_STATUS_STATE_WRITE)
 247                 /* error state */
 248                 return (0);
 249
 250         /* Clear OBF */
 251         kcs_clear_obf(sc, status);
 252
 253         /* Send data byte to DATA. */
 254         OUTB(sc, KCS_DATA, data);
 255         return (1);
 256 }
 257
 258 /*
 259  * Read one byte of the reply message.
 260  */
 261 static int
 262 kcs_read_byte(struct ipmi_softc *sc, u_char *data)
 263 {
 264         int status;
 265         u_char dummy;
 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
 276                 /* Read Data_out */
 277                 *data = INB(sc, KCS_DATA);
 278
 279                 /* Write READ into Data_in */
 280                 OUTB(sc, KCS_DATA, KCS_DATA_IN_READ);
 281                 return (1);
 282         }
 283
 284         /* Idle State */
 285         if (KCS_STATUS_STATE(status) == KCS_STATUS_STATE_IDLE) {
 286
 287                 /* Wait for OBF = 1*/
 288                 status = kcs_wait_for_obf(sc, 1);
 289
 290                 /* Read Dummy */
 291                 dummy = INB(sc, KCS_DATA);
 292                 return (2);
 293         }
 294
 295         /* Error State */
 296         return (0);
 297 }
 298
 299 /*
 300  * Send a request message and collect the reply.  Returns true if we
 301  * succeed.
 302  */
 303 static int
 304 kcs_polled_request(struct ipmi_softc *sc, struct ipmi_request *req)
 305 {
 306         u_char *cp, data;
 307         int i, state;
 308
 309         /* Send the request. */
 310         if (!kcs_start_write(sc)) {
 311                 device_printf(sc->ipmi_dev, "KCS: Failed to start write\n");
 312                 goto fail;
 313         }
 314 #ifdef KCS_DEBUG
 315         device_printf(sc->ipmi_dev, "KCS: WRITE_START... ok\n");
 316 #endif
 317
 318         if (!kcs_write_byte(sc, req->ir_addr)) {
 319                 device_printf(sc->ipmi_dev, "KCS: Failed to write address\n");
 320                 goto fail;
 321         }
 322 #ifdef KCS_DEBUG
 323         device_printf(sc->ipmi_dev, "KCS: Wrote address: %02x\n", req->ir_addr);
 324 #endif
 325
 326         if (req->ir_requestlen == 0) {
 327                 if (!kcs_write_last_byte(sc, req->ir_command)) {
 328                         device_printf(sc->ipmi_dev,
 329                             "KCS: Failed to write command\n");
 330                         goto fail;
 331                 }
 332 #ifdef KCS_DEBUG
 333                 device_printf(sc->ipmi_dev, "KCS: Wrote command: %02x\n",
 334                     req->ir_command);
 335 #endif
 336         } else {
 337                 if (!kcs_write_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
 347                 cp = req->ir_request;
 348                 for (i = 0; i < req->ir_requestlen - 1; i++) {
 349                         if (!kcs_write_byte(sc, *cp++)) {
 350                                 device_printf(sc->ipmi_dev,
 351                                     "KCS: Failed to write data byte %d\n",
 352                                     i + 1);
 353                                 goto fail;
 354                         }
 355 #ifdef KCS_DEBUG
 356                         device_printf(sc->ipmi_dev, "KCS: Wrote data: %02x\n",
 357                             cp[-1]);
 358 #endif
 359                 }
 360
 361                 if (!kcs_write_last_byte(sc, *cp)) {
 362                         device_printf(sc->ipmi_dev,
 363                             "KCS: Failed to write last dta byte\n");
 364                         goto fail;
 365                 }
 366 #ifdef KCS_DEBUG
 367                 device_printf(sc->ipmi_dev, "KCS: Wrote last data: %02x\n",
 368                     *cp);
 369 #endif
 370         }
 371
 372         /* Read the reply.  First, read the NetFn/LUN. */
 373         if (kcs_read_byte(sc, &data) != 1) {
 374                 device_printf(sc->ipmi_dev, "KCS: Failed to read address\n");
 375                 goto fail;
 376         }
 377 #ifdef KCS_DEBUG
 378         device_printf(sc->ipmi_dev, "KCS: Read address: %02x\n", data);
 379 #endif
 380         if (data != IPMI_REPLY_ADDR(req->ir_addr)) {
 381                 device_printf(sc->ipmi_dev, "KCS: Reply address mismatch\n");
 382                 goto fail;
 383         }
 384
 385         /* Next we read the command. */
 386         if (kcs_read_byte(sc, &data) != 1) {
 387                 device_printf(sc->ipmi_dev, "KCS: Failed to read command\n");
 388                 goto fail;
 389         }
 390 #ifdef KCS_DEBUG
 391         device_printf(sc->ipmi_dev, "KCS: Read command: %02x\n", data);
 392 #endif
 393         if (data != req->ir_command) {
 394                 device_printf(sc->ipmi_dev, "KCS: Command mismatch\n");
 395                 goto fail;
 396         }
 397
 398         /* Next we read the completion code. */
 399         if (kcs_read_byte(sc, &req->ir_compcode) != 1) {
 400                 device_printf(sc->ipmi_dev,
 401                     "KCS: Failed to read completion code\n");
 402                 goto fail;
 403         }
 404 #ifdef KCS_DEBUG
 405         device_printf(sc->ipmi_dev, "KCS: Read completion code: %02x\n",
 406             req->ir_compcode);
 407 #endif
 408
 409         /* Finally, read the reply from the BMC. */
 410         i = 0;
 411         for (;;) {
 412                 state = kcs_read_byte(sc, &data);
 413                 if (state == 0) {
 414                         device_printf(sc->ipmi_dev,
 415                             "KCS: Read failed on byte %d\n", i + 1);
 416                         goto fail;
 417                 }
 418                 if (state == 2)
 419                         break;
 420                 if (i < req->ir_replybuflen) {
 421                         req->ir_reply[i] = data;
 422 #ifdef KCS_DEBUG
 423                         device_printf(sc->ipmi_dev, "KCS: Read data %02x\n",
 424                             data);
 425                 } else {
 426                         device_printf(sc->ipmi_dev,
 427                             "KCS: Read short %02x byte %d\n", data, i + 1);
 428 #endif
 429                 }
 430                 i++;
 431         }
 432         req->ir_replylen = i;
 433 #ifdef KCS_DEBUG
 434         device_printf(sc->ipmi_dev, "KCS: READ finished (%d bytes)\n", i);
 435         if (req->ir_replybuflen < i)
 436 #else
 437         if (req->ir_replybuflen < i && req->ir_replybuflen != 0)
 438 #endif
 439                 device_printf(sc->ipmi_dev,
 440                     "KCS: Read short: %zd buffer, %d actual\n",
 441                     req->ir_replybuflen, i);
 442         return (1);
 443 fail:
 444         kcs_error(sc);
 445         return (0);
 446 }
 447
 448 static void
 449 kcs_loop(void *arg)
 450 {
 451         struct ipmi_softc *sc = arg;
 452         struct ipmi_request *req;
 453         int i, ok;
 454
 455         IPMI_LOCK(sc);
 456         while ((req = ipmi_dequeue_request(sc)) != NULL) {
 457                 IPMI_UNLOCK(sc);
 458                 ok = 0;
 459                 for (i = 0; i < 3 && !ok; i++)
 460                         ok = kcs_polled_request(sc, req);
 461                 if (ok)
 462                         req->ir_error = 0;
 463                 else
 464                         req->ir_error = EIO;
 465                 IPMI_LOCK(sc);
 466                 ipmi_complete_request(sc, req);
 467         }
 468         IPMI_UNLOCK(sc);
 469         kthread_exit();
 470 }
 471
 472 static int
 473 kcs_startup(struct ipmi_softc *sc)
 474 {
 475
 476         return (kthread_create(kcs_loop, sc, &sc->ipmi_kthread, "%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                 kprintf("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         kprintf("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 }