drivers/char/ipmi/ipmi_dmi.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * A hack to create a platform device from a DMI entry.  This will
   4  * allow autoloading of the IPMI drive based on SMBIOS entries.
   5  */
   6
   7 #define pr_fmt(fmt) "%s" fmt, "ipmi:dmi: "
   8 #define dev_fmt pr_fmt
   9
  10 #include <linux/ipmi.h>
  11 #include <linux/init.h>
  12 #include <linux/dmi.h>
  13 #include <linux/platform_device.h>
  14 #include <linux/property.h>
  15 #include "ipmi_si_sm.h"
  16 #include "ipmi_dmi.h"
  17 #include "ipmi_plat_data.h"
  18
  19 #define IPMI_DMI_TYPE_KCS       0x01
  20 #define IPMI_DMI_TYPE_SMIC      0x02
  21 #define IPMI_DMI_TYPE_BT        0x03
  22 #define IPMI_DMI_TYPE_SSIF      0x04
  23
  24 struct ipmi_dmi_info {
  25         enum si_type si_type;
  26         unsigned int space; /* addr space for si, intf# for ssif */
  27         unsigned long addr;
  28         u8 slave_addr;
  29         struct ipmi_dmi_info *next;
  30 };
  31
  32 static struct ipmi_dmi_info *ipmi_dmi_infos;
  33
  34 static int ipmi_dmi_nr __initdata;
  35
  36 static void __init dmi_add_platform_ipmi(unsigned long base_addr,
  37                                          unsigned int space,
  38                                          u8 slave_addr,
  39                                          int irq,
  40                                          int offset,
  41                                          int type)
  42 {
  43         const char *name;
  44         struct ipmi_dmi_info *info;
  45         struct ipmi_plat_data p;
  46
  47         memset(&p, 0, sizeof(p));
  48
  49         name = "dmi-ipmi-si";
  50         p.iftype = IPMI_PLAT_IF_SI;
  51         switch (type) {
  52         case IPMI_DMI_TYPE_SSIF:
  53                 name = "dmi-ipmi-ssif";
  54                 p.iftype = IPMI_PLAT_IF_SSIF;
  55                 p.type = SI_TYPE_INVALID;
  56                 break;
  57         case IPMI_DMI_TYPE_BT:
  58                 p.type = SI_BT;
  59                 break;
  60         case IPMI_DMI_TYPE_KCS:
  61                 p.type = SI_KCS;
  62                 break;
  63         case IPMI_DMI_TYPE_SMIC:
  64                 p.type = SI_SMIC;
  65                 break;
  66         default:
  67                 pr_err("Invalid IPMI type: %d\n", type);
  68                 return;
  69         }
  70
  71         p.addr = base_addr;
  72         p.space = space;
  73         p.regspacing = offset;
  74         p.irq = irq;
  75         p.slave_addr = slave_addr;
  76         p.addr_source = SI_SMBIOS;
  77
  78         info = kmalloc(sizeof(*info), GFP_KERNEL);
  79         if (!info) {
  80                 pr_warn("Could not allocate dmi info\n");
  81         } else {
  82                 info->si_type = p.type;
  83                 info->space = space;
  84                 info->addr = base_addr;
  85                 info->slave_addr = slave_addr;
  86                 info->next = ipmi_dmi_infos;
  87                 ipmi_dmi_infos = info;
  88         }
  89
  90         if (ipmi_platform_add(name, ipmi_dmi_nr, &p))
  91                 ipmi_dmi_nr++;
  92 }
  93
  94 /*
  95  * Look up the slave address for a given interface.  This is here
  96  * because ACPI doesn't have a slave address while SMBIOS does, but we
  97  * prefer using ACPI so the ACPI code can use the IPMI namespace.
  98  * This function allows an ACPI-specified IPMI device to look up the
  99  * slave address from the DMI table.
 100  */
 101 int ipmi_dmi_get_slave_addr(enum si_type si_type, unsigned int space,
 102                             unsigned long base_addr)
 103 {
 104         struct ipmi_dmi_info *info = ipmi_dmi_infos;
 105
 106         while (info) {
 107                 if (info->si_type == si_type &&
 108                     info->space == space &&
 109                     info->addr == base_addr)
 110                         return info->slave_addr;
 111                 info = info->next;
 112         }
 113
 114         return 0;
 115 }
 116 EXPORT_SYMBOL(ipmi_dmi_get_slave_addr);
 117
 118 #define DMI_IPMI_MIN_LENGTH     0x10
 119 #define DMI_IPMI_VER2_LENGTH    0x12
 120 #define DMI_IPMI_TYPE           4
 121 #define DMI_IPMI_SLAVEADDR      6
 122 #define DMI_IPMI_ADDR           8
 123 #define DMI_IPMI_ACCESS         0x10
 124 #define DMI_IPMI_IRQ            0x11
 125 #define DMI_IPMI_IO_MASK        0xfffe
 126
 127 static void __init dmi_decode_ipmi(const struct dmi_header *dm)
 128 {
 129         const u8 *data = (const u8 *) dm;
 130         int space = IPMI_IO_ADDR_SPACE;
 131         unsigned long base_addr;
 132         u8 len = dm->length;
 133         u8 slave_addr;
 134         int irq = 0, offset = 0;
 135         int type;
 136
 137         if (len < DMI_IPMI_MIN_LENGTH)
 138                 return;
 139
 140         type = data[DMI_IPMI_TYPE];
 141         slave_addr = data[DMI_IPMI_SLAVEADDR];
 142
 143         memcpy(&base_addr, data + DMI_IPMI_ADDR, sizeof(unsigned long));
 144         if (!base_addr) {
 145                 pr_err("Base address is zero, assuming no IPMI interface\n");
 146                 return;
 147         }
 148         if (len >= DMI_IPMI_VER2_LENGTH) {
 149                 if (type == IPMI_DMI_TYPE_SSIF) {
 150                         space = 0; /* Match I2C interface 0. */
 151                         base_addr = data[DMI_IPMI_ADDR] >> 1;
 152                         if (base_addr == 0) {
 153                                 /*
 154                                  * Some broken systems put the I2C address in
 155                                  * the slave address field.  We try to
 156                                  * accommodate them here.
 157                                  */
 158                                 base_addr = data[DMI_IPMI_SLAVEADDR] >> 1;
 159                                 slave_addr = 0;
 160                         }
 161                 } else {
 162                         if (base_addr & 1) {
 163                                 /* I/O */
 164                                 base_addr &= DMI_IPMI_IO_MASK;
 165                         } else {
 166                                 /* Memory */
 167                                 space = IPMI_MEM_ADDR_SPACE;
 168                         }
 169
 170                         /*
 171                          * If bit 4 of byte 0x10 is set, then the lsb
 172                          * for the address is odd.
 173                          */
 174                         base_addr |= (data[DMI_IPMI_ACCESS] >> 4) & 1;
 175
 176                         irq = data[DMI_IPMI_IRQ];
 177
 178                         /*
 179                          * The top two bits of byte 0x10 hold the
 180                          * register spacing.
 181                          */
 182                         switch ((data[DMI_IPMI_ACCESS] >> 6) & 3) {
 183                         case 0: /* Byte boundaries */
 184                                 offset = 1;
 185                                 break;
 186                         case 1: /* 32-bit boundaries */
 187                                 offset = 4;
 188                                 break;
 189                         case 2: /* 16-byte boundaries */
 190                                 offset = 16;
 191                                 break;
 192                         default:
 193                                 pr_err("Invalid offset: 0\n");
 194                                 return;
 195                         }
 196                 }
 197         } else {
 198                 /* Old DMI spec. */
 199                 /*
 200                  * Note that technically, the lower bit of the base
 201                  * address should be 1 if the address is I/O and 0 if
 202                  * the address is in memory.  So many systems get that
 203                  * wrong (and all that I have seen are I/O) so we just
 204                  * ignore that bit and assume I/O.  Systems that use
 205                  * memory should use the newer spec, anyway.
 206                  */
 207                 base_addr = base_addr & DMI_IPMI_IO_MASK;
 208                 offset = 1;
 209         }
 210
 211         dmi_add_platform_ipmi(base_addr, space, slave_addr, irq,
 212                               offset, type);
 213 }
 214
 215 static int __init scan_for_dmi_ipmi(void)
 216 {
 217         const struct dmi_device *dev = NULL;
 218
 219         while ((dev = dmi_find_device(DMI_DEV_TYPE_IPMI, NULL, dev)))
 220                 dmi_decode_ipmi((const struct dmi_header *) dev->device_data);
 221
 222         return 0;
 223 }
 224 subsys_initcall(scan_for_dmi_ipmi);