sys/dev/ipmi/ipmi_acpi.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/kernel.h>
  37 #include <sys/module.h>
  38 #include <sys/rman.h>
  39 #include <sys/selinfo.h>
  40
  41 #include <contrib/dev/acpica/include/acpi.h>
  42
  43 #include <dev/acpica/acpivar.h>
  44
  45 /* Hooks for the ACPI CA debugging infrastructure */
  46 #define _COMPONENT      ACPI_BUTTON
  47 ACPI_MODULE_NAME("IPMI")
  48
  49 #ifdef LOCAL_MODULE
  50 #include <ipmi.h>
  51 #include <ipmivars.h>
  52 #else
  53 #include <sys/ipmi.h>
  54 #include <dev/ipmi/ipmivars.h>
  55 #endif
  56
  57 static int ipmi_acpi_probe(device_t);
  58 static int ipmi_acpi_attach(device_t);
  59
  60 int
  61 ipmi_acpi_probe(device_t dev)
  62 {
  63         static char *ipmi_ids[] = {"IPI0001", NULL};
  64
  65         if (ipmi_attached)
  66                 return (EBUSY);
  67
  68         if (acpi_disabled("ipmi") ||
  69             ACPI_ID_PROBE(device_get_parent(dev), dev, ipmi_ids) == NULL)
  70                 return (ENXIO);
  71
  72         device_set_desc(dev, "IPMI System Interface");
  73
  74         return (0);
  75 }
  76
  77 static int
  78 ipmi_acpi_attach(device_t dev)
  79 {
  80         ACPI_HANDLE devh;
  81         const char *mode;
  82         struct ipmi_get_info info;
  83         struct ipmi_softc *sc = device_get_softc(dev);
  84         int count, error, flags, i, type;
  85         int interface_type = 0, interface_version = 0;
  86
  87         error = 0;
  88         devh = acpi_get_handle(dev);
  89         if (ACPI_FAILURE(acpi_GetInteger(devh, "_IFT", &interface_type)))
  90                 return (ENXIO);
  91
  92         if (ACPI_FAILURE(acpi_GetInteger(devh, "_SRV", &interface_version)))
  93                 return (ENXIO);
  94
  95         switch (interface_type) {
  96         case KCS_MODE:
  97                 count = 2;
  98                 mode = "KCS";
  99                 break;
 100         case SMIC_MODE:
 101                 count = 3;
 102                 mode = "SMIC";
 103                 break;
 104         case BT_MODE:
 105                 device_printf(dev, "BT interface not supported\n");
 106                 return (ENXIO);
 107         case SSIF_MODE:
 108                 if (ACPI_FAILURE(acpi_GetInteger(devh, "_ADR", &flags)))
 109                         return (ENXIO);
 110                 info.address = flags;
 111                 device_printf(dev, "SSIF interface not supported on ACPI\n");
 112                 return (0);
 113         default:
 114                 return (ENXIO);
 115         }
 116
 117         if (bus_get_resource(dev, SYS_RES_IOPORT, 0, NULL, NULL) == 0)
 118                 type = SYS_RES_IOPORT;
 119         else if (bus_get_resource(dev, SYS_RES_MEMORY, 0, NULL, NULL) == 0)
 120                 type = SYS_RES_MEMORY;
 121         else {
 122                 device_printf(dev, "unknown resource type\n");
 123                 return (ENXIO);
 124         }
 125
 126         sc->ipmi_io_rid = 0;
 127         sc->ipmi_io_res[0] = bus_alloc_resource_any(dev, type,
 128             &sc->ipmi_io_rid, RF_ACTIVE);
 129         sc->ipmi_io_type = type;
 130         sc->ipmi_io_spacing = 1;
 131         if (sc->ipmi_io_res[0] == NULL) {
 132                 device_printf(dev, "couldn't configure I/O resource\n");
 133                 return (ENXIO);
 134         }
 135
 136         /* If we have multiple resources, allocate up to MAX_RES. */
 137         for (i = 1; i < MAX_RES; i++) {
 138                 sc->ipmi_io_rid = i;
 139                 sc->ipmi_io_res[i] = bus_alloc_resource_any(dev, type,
 140                     &sc->ipmi_io_rid, RF_ACTIVE);
 141                 if (sc->ipmi_io_res[i] == NULL)
 142                         break;
 143         }
 144         sc->ipmi_io_rid = 0;
 145
 146         /* If we have multiple resources, make sure we have enough of them. */
 147         if (sc->ipmi_io_res[1] != NULL && sc->ipmi_io_res[count - 1] == NULL) {
 148                 device_printf(dev, "too few I/O resources\n");
 149                 error = ENXIO;
 150                 goto bad;
 151         }
 152
 153         device_printf(dev, "%s mode found at %s 0x%jx on %s\n",
 154             mode, type == SYS_RES_IOPORT ? "io" : "mem",
 155             (uintmax_t)rman_get_start(sc->ipmi_io_res[0]),
 156             device_get_name(device_get_parent(dev)));
 157
 158         sc->ipmi_dev = dev;
 159
 160         /*
 161          * Setup an interrupt if we have an interrupt resource.  We
 162          * don't support GPE interrupts via _GPE yet.
 163          */
 164         sc->ipmi_irq_rid = 0;
 165         sc->ipmi_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ,
 166             &sc->ipmi_irq_rid, RF_SHAREABLE | RF_ACTIVE);
 167
 168         /* Warn if _GPE exists. */
 169         if (ACPI_SUCCESS(AcpiEvaluateObject(devh, "_GPE", NULL, NULL)))
 170                 device_printf(dev, "_GPE support not implemented\n");
 171
 172         /*
 173          * We assume an alignment of 1 byte as currently the IPMI spec
 174          * doesn't provide any way to determine the alignment via ACPI.
 175          */
 176         switch (interface_type) {
 177         case KCS_MODE:
 178                 error = ipmi_kcs_attach(sc);
 179                 if (error)
 180                         goto bad;
 181                 break;
 182         case SMIC_MODE:
 183                 error = ipmi_smic_attach(sc);
 184                 if (error)
 185                         goto bad;
 186                 break;
 187         }
 188         error = ipmi_attach(dev);
 189         if (error)
 190                 goto bad;
 191
 192         return (0);
 193 bad:
 194         ipmi_release_resources(dev);
 195         return (error);
 196 }
 197
 198 static device_method_t ipmi_methods[] = {
 199         /* Device interface */
 200         DEVMETHOD(device_probe,         ipmi_acpi_probe),
 201         DEVMETHOD(device_attach,        ipmi_acpi_attach),
 202         DEVMETHOD(device_detach,        ipmi_detach),
 203         { 0, 0 }
 204 };
 205
 206 static driver_t ipmi_acpi_driver = {
 207         "ipmi",
 208         ipmi_methods,
 209         sizeof(struct ipmi_softc),
 210 };
 211
 212 DRIVER_MODULE(ipmi_acpi, acpi, ipmi_acpi_driver, ipmi_devclass, 0, 0);
 213 MODULE_DEPEND(ipmi_acpi, acpi, 1, 1, 1);