sys/dev/ipmi/ipmi_ssif.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/module.h>
  40 #include <sys/selinfo.h>
  41
  42 #include <dev/smbus/smbconf.h>
  43 #include <dev/smbus/smb.h>
  44
  45 #include "smbus_if.h"
  46
  47 #ifdef LOCAL_MODULE
  48 #include <ipmivars.h>
  49 #else
  50 #include <dev/ipmi/ipmivars.h>
  51 #endif
  52
  53 #define SMBUS_WRITE_SINGLE      0x02
  54 #define SMBUS_WRITE_START       0x06
  55 #define SMBUS_WRITE_CONT        0x07
  56 #define SMBUS_READ_START        0x03
  57 #define SMBUS_READ_CONT         0x09
  58 #define SMBUS_DATA_SIZE         32
  59
  60 #ifdef SSIF_DEBUG
  61 static void
  62 dump_buffer(device_t dev, const char *msg, u_char *bytes, int len)
  63 {
  64         int i;
  65
  66         device_printf(dev, "%s:", msg);
  67         for (i = 0; i < len; i++)
  68                 printf(" %02x", bytes[i]);
  69         printf("\n");
  70 }
  71 #endif
  72
  73 static int
  74 ssif_polled_request(struct ipmi_softc *sc, struct ipmi_request *req)
  75 {
  76         u_char ssif_buf[SMBUS_DATA_SIZE];
  77         device_t dev = sc->ipmi_dev;
  78         device_t smbus = sc->ipmi_ssif_smbus;
  79         u_char *cp, block, count, offset;
  80         size_t len;
  81         int error;
  82
  83         /* Acquire the bus while we send the request. */
  84         if (smbus_request_bus(smbus, dev, SMB_WAIT) != 0)
  85                 return (0);
  86
  87         /*
  88          * First, send out the request.  Begin by filling out the first
  89          * packet which includes the NetFn/LUN and command.
  90          */
  91         ssif_buf[0] = req->ir_addr;
  92         ssif_buf[1] = req->ir_command;
  93         if (req->ir_requestlen > 0)
  94                 bcopy(req->ir_request, &ssif_buf[2],
  95                     min(req->ir_requestlen, SMBUS_DATA_SIZE - 2));
  96
  97         /* Small requests are sent with a single command. */
  98         if (req->ir_requestlen <= 30) {
  99 #ifdef SSIF_DEBUG
 100                 dump_buffer(dev, "WRITE_SINGLE", ssif_buf,
 101                     req->ir_requestlen + 2);
 102 #endif
 103                 error = smbus_error(smbus_bwrite(smbus,
 104                         sc->ipmi_ssif_smbus_address, SMBUS_WRITE_SINGLE,
 105                         req->ir_requestlen + 2, ssif_buf));
 106                 if (error) {
 107 #ifdef SSIF_ERROR_DEBUG
 108                         device_printf(dev, "SSIF: WRITE_SINGLE error %d\n",
 109                             error);
 110 #endif
 111                         goto fail;
 112                 }
 113         } else {
 114                 /* Longer requests are sent out in 32-byte messages. */
 115 #ifdef SSIF_DEBUG
 116                 dump_buffer(dev, "WRITE_START", ssif_buf, SMBUS_DATA_SIZE);
 117 #endif
 118                 error = smbus_error(smbus_bwrite(smbus,
 119                         sc->ipmi_ssif_smbus_address, SMBUS_WRITE_START,
 120                         SMBUS_DATA_SIZE, ssif_buf));
 121                 if (error) {
 122 #ifdef SSIF_ERROR_DEBUG
 123                         device_printf(dev, "SSIF: WRITE_START error %d\n",
 124                             error);
 125 #endif
 126                         goto fail;
 127                 }
 128
 129                 len = req->ir_requestlen - (SMBUS_DATA_SIZE - 2);
 130                 cp = req->ir_request + (SMBUS_DATA_SIZE - 2);
 131                 while (len > 0) {
 132 #ifdef SSIF_DEBUG
 133                         dump_buffer(dev, "WRITE_CONT", cp,
 134                             min(len, SMBUS_DATA_SIZE));
 135 #endif
 136                         error = smbus_error(smbus_bwrite(smbus,
 137                             sc->ipmi_ssif_smbus_address, SMBUS_WRITE_CONT,
 138                             min(len, SMBUS_DATA_SIZE), cp));
 139                         if (error) {
 140 #ifdef SSIF_ERROR_DEBUG
 141                                 device_printf(dev, "SSIF: WRITE_CONT error %d\n",
 142                                     error);
 143 #endif
 144                                 goto fail;
 145                         }
 146                         cp += SMBUS_DATA_SIZE;
 147                         len -= SMBUS_DATA_SIZE;
 148                 }
 149
 150                 /*
 151                  * The final WRITE_CONT transaction has to have a non-zero
 152                  * length that is also not SMBUS_DATA_SIZE.  If our last
 153                  * WRITE_CONT transaction in the loop sent SMBUS_DATA_SIZE
 154                  * bytes, then len will be 0, and we send an extra 0x00 byte
 155                  * to terminate the transaction.
 156                  */
 157                 if (len == 0) {
 158                         char c = 0;
 159
 160 #ifdef SSIF_DEBUG
 161                         dump_buffer(dev, "WRITE_CONT", &c, 1);
 162 #endif
 163                         error = smbus_error(smbus_bwrite(smbus,
 164                                 sc->ipmi_ssif_smbus_address, SMBUS_WRITE_CONT,
 165                                 1, &c));
 166                         if (error) {
 167 #ifdef SSIF_ERROR_DEBUG
 168                                 device_printf(dev, "SSIF: WRITE_CONT error %d\n",
 169                                     error);
 170 #endif
 171                                 goto fail;
 172                         }
 173                 }
 174         }
 175
 176         /* Release the bus. */
 177         smbus_release_bus(smbus, dev);
 178
 179         /* Give the BMC 100ms to chew on the request. */
 180         pause("ssifwt", hz / 10);
 181
 182         /* Try to read the first packet. */
 183 read_start:
 184         if (smbus_request_bus(smbus, dev, SMB_WAIT) != 0)
 185                 return (0);
 186         count = SMBUS_DATA_SIZE;
 187         error = smbus_error(smbus_bread(smbus,
 188             sc->ipmi_ssif_smbus_address, SMBUS_READ_START, &count, ssif_buf));
 189         if (error == ENXIO || error == EBUSY) {
 190                 smbus_release_bus(smbus, dev);
 191 #ifdef SSIF_DEBUG
 192                 device_printf(dev, "SSIF: READ_START retry\n");
 193 #endif
 194                 /* Give the BMC another 10ms. */
 195                 pause("ssifwt", hz / 100);
 196                 goto read_start;
 197         }
 198         if (error) {
 199 #ifdef SSIF_ERROR_DEBUG
 200                 device_printf(dev, "SSIF: READ_START failed: %d\n", error);
 201 #endif
 202                 goto fail;
 203         }
 204 #ifdef SSIF_DEBUG
 205         device_printf("SSIF: READ_START: ok\n");
 206 #endif
 207
 208         /*
 209          * If this is the first part of a multi-part read, then we need to
 210          * skip the first two bytes.
 211          */
 212         if (count == SMBUS_DATA_SIZE && ssif_buf[0] == 0 && ssif_buf[1] == 1)
 213                 offset = 2;
 214         else
 215                 offset = 0;
 216
 217         /* We had better get the reply header. */
 218         if (count < 3) {
 219                 device_printf(dev, "SSIF: Short reply packet\n");
 220                 goto fail;
 221         }
 222
 223         /* Verify the NetFn/LUN. */
 224         if (ssif_buf[offset] != IPMI_REPLY_ADDR(req->ir_addr)) {
 225                 device_printf(dev, "SSIF: Reply address mismatch\n");
 226                 goto fail;
 227         }
 228
 229         /* Verify the command. */
 230         if (ssif_buf[offset + 1] != req->ir_command) {
 231                 device_printf(dev, "SMIC: Command mismatch\n");
 232                 goto fail;
 233         }
 234
 235         /* Read the completion code. */
 236         req->ir_compcode = ssif_buf[offset + 2];
 237
 238         /* If this is a single read, just copy the data and return. */
 239         if (offset == 0) {
 240 #ifdef SSIF_DEBUG
 241                 dump_buffer(dev, "READ_SINGLE", ssif_buf, count);
 242 #endif
 243                 len = count - 3;
 244                 bcopy(&ssif_buf[3], req->ir_reply,
 245                     min(req->ir_replybuflen, len));
 246                 goto done;
 247         }
 248
 249         /*
 250          * This is the first part of a multi-read transaction, so copy
 251          * out the payload and start looping.
 252          */
 253 #ifdef SSIF_DEBUG
 254         dump_buffer(dev, "READ_START", ssif_buf + 2, count - 2);
 255 #endif
 256         bcopy(&ssif_buf[5], req->ir_reply, min(req->ir_replybuflen, count - 5));
 257         len = count - 5;
 258         block = 1;
 259
 260         for (;;) {
 261                 /* Read another packet via READ_CONT. */
 262                 count = SMBUS_DATA_SIZE;
 263                 error = smbus_error(smbus_bread(smbus,
 264                     sc->ipmi_ssif_smbus_address, SMBUS_READ_CONT, &count,
 265                     ssif_buf));
 266                 if (error) {
 267 #ifdef SSIF_ERROR_DEBUG
 268                         printf("SSIF: READ_CONT failed: %d\n", error);
 269 #endif
 270                         goto fail;
 271                 }
 272 #ifdef SSIF_DEBUG
 273                 device_printf(dev, "SSIF: READ_CONT... ok\n");
 274 #endif
 275
 276                 /* Verify the block number.  0xff marks the last block. */
 277                 if (ssif_buf[0] != 0xff && ssif_buf[0] != block) {
 278                         device_printf(dev, "SSIF: Read wrong block %d %d\n",
 279                             ssif_buf[0], block);
 280                         goto fail;
 281                 }
 282                 if (ssif_buf[0] != 0xff && count < SMBUS_DATA_SIZE) {
 283                         device_printf(dev,
 284                             "SSIF: Read short middle block, length %d\n",
 285                             count);
 286                         goto fail;
 287                 }
 288 #ifdef SSIF_DEBUG
 289                 if (ssif_buf[0] == 0xff)
 290                         dump_buffer(dev, "READ_END", ssif_buf + 1, count - 1);
 291                 else
 292                         dump_buffer(dev, "READ_CONT", ssif_buf + 1, count - 1);
 293 #endif
 294                 if (len < req->ir_replybuflen)
 295                         bcopy(&ssif_buf[1], &req->ir_reply[len],
 296                             min(req->ir_replybuflen - len, count - 1));
 297                 len += count - 1;
 298
 299                 /* If this was the last block we are done. */
 300                 if (ssif_buf[0] != 0xff)
 301                         break;
 302                 block++;
 303         }
 304
 305 done:
 306         /* Save the total length and return success. */
 307         req->ir_replylen = len;
 308         smbus_release_bus(smbus, dev);
 309         return (1);
 310
 311 fail:
 312         smbus_release_bus(smbus, dev);
 313         return (0);
 314 }
 315
 316 static void
 317 ssif_loop(void *arg)
 318 {
 319         struct ipmi_softc *sc = arg;
 320         struct ipmi_request *req;
 321         int i, ok;
 322
 323         IPMI_LOCK(sc);
 324         while ((req = ipmi_dequeue_request(sc)) != NULL) {
 325                 IPMI_UNLOCK(sc);
 326                 ok = 0;
 327                 for (i = 0; i < 5; i++) {
 328                         ok = ssif_polled_request(sc, req);
 329                         if (ok)
 330                                 break;
 331
 332                         /* Wait 60 ms between retries. */
 333                         pause("retry", 60 * hz / 1000);
 334 #ifdef SSIF_RETRY_DEBUG
 335                         device_printf(sc->ipmi_dev,
 336                             "SSIF: Retrying request (%d)\n", i + 1);
 337 #endif
 338                 }
 339                 if (ok)
 340                         req->ir_error = 0;
 341                 else
 342                         req->ir_error = EIO;
 343                 IPMI_LOCK(sc);
 344                 ipmi_complete_request(sc, req);
 345                 IPMI_UNLOCK(sc);
 346
 347                 /* Enforce 10ms between requests. */
 348                 pause("delay", hz / 100);
 349
 350                 IPMI_LOCK(sc);
 351         }
 352         IPMI_UNLOCK(sc);
 353         kproc_exit(0);
 354 }
 355
 356 static int
 357 ssif_startup(struct ipmi_softc *sc)
 358 {
 359
 360         return (kproc_create(ssif_loop, sc, &sc->ipmi_kthread, 0, 0,
 361             "%s: ssif", device_get_nameunit(sc->ipmi_dev)));
 362 }
 363
 364 static int
 365 ssif_driver_request(struct ipmi_softc *sc, struct ipmi_request *req, int timo)
 366 {
 367         int error;
 368
 369         IPMI_LOCK(sc);
 370         error = ipmi_polled_enqueue_request(sc, req);
 371         if (error == 0)
 372                 error = msleep(req, &sc->ipmi_requests_lock, 0, "ipmireq",
 373                     timo);
 374         if (error == 0)
 375                 error = req->ir_error;
 376         IPMI_UNLOCK(sc);
 377         return (error);
 378 }
 379
 380 int
 381 ipmi_ssif_attach(struct ipmi_softc *sc, device_t smbus, int smbus_address)
 382 {
 383
 384         /* Setup smbus address. */
 385         sc->ipmi_ssif_smbus = smbus;
 386         sc->ipmi_ssif_smbus_address = smbus_address;
 387
 388         /* Setup function pointers. */
 389         sc->ipmi_startup = ssif_startup;
 390         sc->ipmi_enqueue_request = ipmi_polled_enqueue_request;
 391         sc->ipmi_driver_request = ssif_driver_request;
 392
 393         return (0);
 394 }