sys/dev/ipmi/ipmi_opal.c

   1 /*-
   2  * Copyright (C) 2018 Justin Hibbits
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  14  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  15  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  16  * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  17  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  18  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  19  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  20  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  21  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  22  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  23  */
  24
  25 #include <sys/cdefs.h>
  26 __FBSDID("$FreeBSD$");
  27
  28 #include <sys/param.h>
  29 #include <sys/kernel.h>
  30 #include <sys/systm.h>
  31 #include <sys/lock.h>
  32 #include <sys/module.h>
  33 #include <sys/mutex.h>
  34 #include <sys/bus.h>
  35 #include <sys/kthread.h>
  36 #include <sys/proc.h>
  37 #include <sys/selinfo.h>
  38 #include <sys/sysctl.h>
  39
  40 #include <vm/vm.h>
  41 #include <vm/pmap.h>
  42
  43 #include <machine/bus.h>
  44
  45 #include <dev/ofw/openfirm.h>
  46 #include <dev/ofw/ofw_bus.h>
  47 #include <dev/ofw/ofw_bus_subr.h>
  48
  49 #include <sys/ipmi.h>
  50 #include <dev/ipmi/ipmivars.h>
  51
  52 #include <powerpc/powernv/opal.h>
  53
  54 /*
  55  * OPAL_IPMI_DEBUG
  56  *
  57  * 0 - disabled
  58  * 1 - enable error messages (EPRINTF)
  59  * 2 - enable error and debug messages (DPRINTF)
  60  */
  61 #define OPAL_IPMI_DEBUG         0
  62 #if OPAL_IPMI_DEBUG >= 2
  63 /* debug printf */
  64 #define DPRINTF(fmt, ...)       printf("ipmi: " fmt "\n", ## __VA_ARGS__)
  65 #else
  66 #define DPRINTF(fmt, ...)       ((void)0)
  67 #endif
  68 #if OPAL_IPMI_DEBUG >= 1
  69 /* error printf: to print messages only when something fails */
  70 #define EPRINTF(fmt, ...)       printf("ipmi: " fmt "\n", ## __VA_ARGS__)
  71 #else
  72 #define EPRINTF(fmt, ...)       ((void)0)
  73 #endif
  74
  75 struct opal_ipmi_softc {
  76         struct ipmi_softc ipmi;
  77         uint64_t sc_interface;
  78         int sc_timedout;
  79         struct opal_ipmi_msg *sc_msg; /* Protected by IPMI lock */
  80 };
  81
  82 static MALLOC_DEFINE(M_IPMI, "ipmi", "OPAL IPMI");
  83
  84 static int
  85 opal_ipmi_recv(struct opal_ipmi_softc *sc, uint64_t *msg_len, int timo)
  86 {
  87         int err;
  88
  89         if (timo == 0)
  90                 timo = MAX_TIMEOUT;
  91         timo *= 10; /* Timeout is in milliseconds, we delay in 100us */
  92
  93         for (;;) {
  94                 *msg_len = sizeof(struct opal_ipmi_msg) + IPMI_MAX_RX;
  95                 /* Crank the OPAL state machine while we poll for a reply. */
  96                 opal_call(OPAL_POLL_EVENTS, NULL);
  97                 err = opal_call(OPAL_IPMI_RECV, sc->sc_interface,
  98                     vtophys(sc->sc_msg), vtophys(msg_len));
  99                 if (err != OPAL_EMPTY)
 100                         break;
 101
 102                 DELAY(100);
 103                 if (timo-- <= 0) {
 104                         sc->sc_timedout = 1;
 105                         break;
 106                 }
 107         }
 108
 109         if (err != OPAL_SUCCESS)
 110                 EPRINTF("RECV: error: %d", err);
 111
 112         switch (err) {
 113         case OPAL_SUCCESS:
 114                 DPRINTF("RECV: rv=%02x len=%ld",
 115                     sc->sc_msg->data[0], *msg_len);
 116                 return (0);
 117         case OPAL_RESOURCE:
 118                 return (ENOMEM);
 119         case OPAL_EMPTY:
 120                 return (EAGAIN);
 121         default:
 122                 return (EIO);
 123         }
 124 }
 125
 126 static void
 127 opal_ipmi_discard_msgs(struct opal_ipmi_softc *sc)
 128 {
 129         uint64_t msg_len;
 130         int err, i = 0;
 131
 132         /* OPAL_IPMI_RECV fails when msg version is not set. */
 133         sc->sc_msg->version = OPAL_IPMI_MSG_FORMAT_VERSION_1;
 134
 135         /* Wait up to 100ms for the 1st timedout message. */
 136         err = opal_ipmi_recv(sc, &msg_len, 100);
 137         while (err == 0) {
 138                 i++;
 139                 /* Wait only 10ms for the remaining messages. */
 140                 err = opal_ipmi_recv(sc, &msg_len, 10);
 141         }
 142         if (i > 0)
 143                 EPRINTF("Discarded %d message(s)", i);
 144         sc->sc_timedout = 0;
 145 }
 146
 147 static int
 148 opal_ipmi_polled_request(struct opal_ipmi_softc *sc, struct ipmi_request *req,
 149     int timo)
 150 {
 151         uint64_t msg_len;
 152         int err;
 153
 154         /*
 155          * Discard timed out messages before sending a new one, to avoid
 156          * them being confused with the reply of the new message.
 157          */
 158         if (sc->sc_timedout)
 159                 opal_ipmi_discard_msgs(sc);
 160
 161         /* Construct and send the message. */
 162         sc->sc_msg->version = OPAL_IPMI_MSG_FORMAT_VERSION_1;
 163         sc->sc_msg->netfn = req->ir_addr;
 164         sc->sc_msg->cmd = req->ir_command;
 165
 166         if (req->ir_requestlen > IPMI_MAX_RX) {
 167                 err = ENOMEM;
 168                 goto out;
 169         }
 170         memcpy(sc->sc_msg->data, req->ir_request, req->ir_requestlen);
 171
 172         msg_len = sizeof(*sc->sc_msg) + req->ir_requestlen;
 173         err = opal_call(OPAL_IPMI_SEND, sc->sc_interface, vtophys(sc->sc_msg),
 174             msg_len);
 175
 176         DPRINTF("SEND: cmd=%02x netfn=%02x len=%ld -> %d",
 177             sc->sc_msg->cmd, sc->sc_msg->netfn, msg_len, err);
 178
 179         if (err != OPAL_SUCCESS)
 180                 EPRINTF("SEND: error: %d", err);
 181
 182         switch (err) {
 183         case OPAL_SUCCESS:
 184                 break;
 185         case OPAL_PARAMETER:
 186         case OPAL_UNSUPPORTED:
 187                 err = EINVAL;
 188                 goto out;
 189         case OPAL_RESOURCE:
 190                 err = ENOMEM;
 191                 goto out;
 192         case OPAL_HARDWARE:
 193         default:
 194                 err = EIO;
 195                 goto out;
 196         }
 197
 198         if ((err = opal_ipmi_recv(sc, &msg_len, timo)) == 0) {
 199                 /* Subtract one extra for the completion code. */
 200                 req->ir_replylen = msg_len - sizeof(struct opal_ipmi_msg) - 1;
 201                 req->ir_replylen = min(req->ir_replylen, req->ir_replybuflen);
 202                 memcpy(req->ir_reply, &sc->sc_msg->data[1], req->ir_replylen);
 203                 req->ir_compcode = sc->sc_msg->data[0];
 204         }
 205
 206 out:
 207         return (err);
 208 }
 209
 210 static int
 211 opal_ipmi_probe(device_t dev)
 212 {
 213         if (!ofw_bus_is_compatible(dev, "ibm,opal-ipmi"))
 214                 return (ENXIO);
 215
 216         device_set_desc(dev, "OPAL IPMI System Interface");
 217
 218         return (BUS_PROBE_DEFAULT);
 219 }
 220
 221 static void
 222 opal_ipmi_loop(void *arg)
 223 {
 224         struct opal_ipmi_softc *sc = arg;
 225         struct ipmi_request *req;
 226         int i, err;
 227
 228         IPMI_LOCK(&sc->ipmi);
 229         while ((req = ipmi_dequeue_request(&sc->ipmi)) != NULL) {
 230                 IPMI_UNLOCK(&sc->ipmi);
 231                 err = EIO;
 232                 for (i = 0; i < 3 && err != 0; i++) {
 233                         IPMI_IO_LOCK(&sc->ipmi);
 234                         err = opal_ipmi_polled_request(sc, req, MAX_TIMEOUT);
 235                         IPMI_IO_UNLOCK(&sc->ipmi);
 236                 }
 237                 req->ir_error = err == 0 ? 0 : EIO;
 238                 IPMI_LOCK(&sc->ipmi);
 239                 ipmi_complete_request(&sc->ipmi, req);
 240         }
 241         IPMI_UNLOCK(&sc->ipmi);
 242         kproc_exit(0);
 243 }
 244
 245 static int
 246 opal_ipmi_startup(struct ipmi_softc *sc)
 247 {
 248
 249         return (kproc_create(opal_ipmi_loop, sc, &sc->ipmi_kthread, 0, 0,
 250             "%s: opal", device_get_nameunit(sc->ipmi_dev)));
 251 }
 252
 253 static int
 254 opal_ipmi_driver_request(struct ipmi_softc *isc, struct ipmi_request *req,
 255     int timo)
 256 {
 257         struct opal_ipmi_softc *sc = (struct opal_ipmi_softc *)isc;
 258         int i, err;
 259
 260         for (i = 0; i < 3; i++) {
 261                 IPMI_LOCK(&sc->ipmi);
 262                 err = opal_ipmi_polled_request(sc, req, timo);
 263                 IPMI_UNLOCK(&sc->ipmi);
 264                 if (err == 0)
 265                         break;
 266         }
 267
 268         req->ir_error = err;
 269
 270         return (err);
 271 }
 272
 273 static int
 274 opal_ipmi_attach(device_t dev)
 275 {
 276         struct opal_ipmi_softc *sc;
 277         pcell_t ifid;
 278
 279         sc = device_get_softc(dev);
 280
 281         if (OF_getencprop(ofw_bus_get_node(dev), "ibm,ipmi-interface-id",
 282             &ifid, sizeof(ifid)) < 0) {
 283                 device_printf(dev, "Missing interface id\n");
 284                 return (ENXIO);
 285         }
 286         sc->sc_interface = ifid;
 287         sc->ipmi.ipmi_startup = opal_ipmi_startup;
 288         sc->ipmi.ipmi_driver_request = opal_ipmi_driver_request;
 289         sc->ipmi.ipmi_enqueue_request = ipmi_polled_enqueue_request;
 290         sc->ipmi.ipmi_driver_requests_polled = 1;
 291         sc->ipmi.ipmi_dev = dev;
 292
 293         sc->sc_msg = malloc(sizeof(struct opal_ipmi_msg) + IPMI_MAX_RX, M_IPMI,
 294             M_WAITOK | M_ZERO);
 295
 296         /* Discard old messages that may have remained in receive queue. */
 297         opal_ipmi_discard_msgs(sc);
 298
 299         return (ipmi_attach(dev));
 300 }
 301
 302 static int
 303 opal_ipmi_detach(device_t dev)
 304 {
 305         struct opal_ipmi_softc *sc;
 306         int err;
 307
 308         sc = device_get_softc(dev);
 309         err = ipmi_detach(dev);
 310         if (err == 0)
 311                 free(sc->sc_msg, M_IPMI);
 312
 313         return (err);
 314 }
 315
 316 static device_method_t  opal_ipmi_methods[] = {
 317         /* Device interface */
 318         DEVMETHOD(device_probe,         opal_ipmi_probe),
 319         DEVMETHOD(device_attach,        opal_ipmi_attach),
 320         DEVMETHOD(device_detach,        opal_ipmi_detach),
 321         DEVMETHOD_END
 322 };
 323
 324 static driver_t opal_ipmi_driver = {
 325         "ipmi",
 326         opal_ipmi_methods,
 327         sizeof(struct opal_ipmi_softc)
 328 };
 329
 330 DRIVER_MODULE(opal_ipmi, opal, opal_ipmi_driver, ipmi_devclass, NULL, NULL);