src/superio/common/ssdt.c

   1 /* SPDX-License-Identifier: GPL-2.0-or-later */
   2
   3 #include <superio/common/ssdt.h>
   4
   5 #include <device/device.h>
   6 #include <device/pnp.h>
   7 #include <acpi/acpigen.h>
   8 #include <acpi/acpi.h>
   9 #include <console/console.h>
  10 #include <types.h>
  11 #include <string.h>
  12
  13 struct superio_dev {
  14         const char *acpi_hid;
  15         u16 io_base[4];
  16         u8 irq[2];
  17 };
  18
  19 static const struct superio_dev superio_devs[] = {
  20         {ACPI_HID_FDC, {0x3f0, 0x3f2, 0x3f7}, {6, } },
  21         {ACPI_HID_KEYBOARD, {60, 64, }, {1, } },
  22         {ACPI_HID_MOUSE, {60, 64, }, {12, } },
  23         {ACPI_HID_COM, {0x3f8, 0x2f8, 0x3e8, 0x2e8}, {4, 3} },
  24         {ACPI_HID_LPT, {0x378, }, {7, } },
  25 };
  26
  27 static const u8 io_idx[] = {PNP_IDX_IO0, PNP_IDX_IO1, PNP_IDX_IO2, PNP_IDX_IO3};
  28 static const u8 irq_idx[] = {PNP_IDX_IRQ0, PNP_IDX_IRQ1};
  29
  30 static const struct superio_dev *superio_guess_function(const struct device *dev)
  31 {
  32         for (size_t i = 0; i < ARRAY_SIZE(io_idx); i++) {
  33                 struct resource *res = probe_resource(dev, io_idx[i]);
  34                 if (!res || !res->base)
  35                         continue;
  36
  37                 for (size_t j = 0; j < ARRAY_SIZE(superio_devs); j++) {
  38                         for (size_t k = 0; k < 4; k++) {
  39                                 if (!superio_devs[j].io_base[k])
  40                                         continue;
  41                                 if (superio_devs[j].io_base[k] == res->base)
  42                                         return &superio_devs[j];
  43                         }
  44                 }
  45         }
  46         for (size_t i = 0; i < ARRAY_SIZE(irq_idx); i++) {
  47                 struct resource *res = probe_resource(dev, irq_idx[i]);
  48                 if (!res || !res->size)
  49                         continue;
  50                 for (size_t j = 0; j < ARRAY_SIZE(superio_devs); j++) {
  51                         for (size_t k = 0; k < 2; k++) {
  52                                 if (!superio_devs[j].irq[k])
  53                                         continue;
  54                                 if (superio_devs[j].irq[k] == res->base)
  55                                         return &superio_devs[j];
  56                         }
  57                 }
  58         }
  59         return NULL;
  60 }
  61
  62 /* Return true if there are resources to report */
  63 static bool has_resources(const struct device *dev)
  64 {
  65         for (size_t i = 0; i < ARRAY_SIZE(io_idx); i++) {
  66                 struct resource *res = probe_resource(dev, io_idx[i]);
  67                 if (!res || !res->base || !res->size)
  68                         continue;
  69                 return 1;
  70         }
  71         for (size_t i = 0; i < ARRAY_SIZE(irq_idx); i++) {
  72                 struct resource *res = probe_resource(dev, irq_idx[i]);
  73                 if (!res || !res->size || res->base > 16)
  74                         continue;
  75                 return 1;
  76         }
  77         return 0;
  78 }
  79
  80 /* Add IO and IRQ resources for _CRS or _PRS */
  81 static void ldn_gen_resources(const struct device *dev)
  82 {
  83         uint16_t irq = 0;
  84         for (size_t i = 0; i < ARRAY_SIZE(io_idx); i++) {
  85                 struct resource *res = probe_resource(dev, io_idx[i]);
  86                 if (!res || !res->base)
  87                         continue;
  88                 resource_t base = res->base;
  89                 resource_t size = res->size;
  90                 while (size > 0) {
  91                         resource_t sz = size > 255 ? 255 : size;
  92                         /* TODO: Needs test with regions >= 256 bytes */
  93                         acpigen_write_io16(base, base, 1, sz, 1);
  94                         size -= sz;
  95                         base += sz;
  96                 }
  97         }
  98         for (size_t i = 0; i < ARRAY_SIZE(irq_idx); i++) {
  99                 struct resource *res = probe_resource(dev, irq_idx[i]);
 100                 if (!res || !res->size || res->base >= 16)
 101                         continue;
 102                 irq |= 1 << res->base;
 103         }
 104         if (irq)
 105                 acpigen_write_irq(irq);
 106
 107 }
 108
 109 /* Add resource base and size for additional SuperIO code */
 110 static void ldn_gen_resources_use(const struct device *dev)
 111 {
 112         char name[5];
 113         for (size_t i = 0; i < ARRAY_SIZE(io_idx); i++) {
 114                 struct resource *res = probe_resource(dev, io_idx[i]);
 115                 if (!res || !res->base || !res->size)
 116                         continue;
 117
 118                 snprintf(name, sizeof(name), "IO%zXB", i);
 119                 name[4] = '\0';
 120                 acpigen_write_name_integer(name, res->base);
 121
 122                 snprintf(name, sizeof(name), "IO%zXS", i);
 123                 name[4] = '\0';
 124                 acpigen_write_name_integer(name, res->size);
 125         }
 126 }
 127
 128 const char *superio_common_ldn_acpi_name(const struct device *dev)
 129 {
 130         u8 ldn = dev->path.pnp.device & 0xff;
 131         u8 vldn = (dev->path.pnp.device >> 8) & 0x7;
 132         static char name[5];
 133
 134         snprintf(name, sizeof(name), "L%02X%01X", ldn, vldn);
 135
 136         name[4] = '\0';
 137
 138         return name;
 139 }
 140
 141 static const char *name_from_hid(const char *hid)
 142 {
 143         static const struct {
 144                 const char *hid;
 145                 const char *name;
 146         } lookup[] = {
 147                 {ACPI_HID_FDC, "FDC" },
 148                 {ACPI_HID_KEYBOARD, "PS2 Keyboard" },
 149                 {ACPI_HID_MOUSE, "PS2 Mouse"},
 150                 {ACPI_HID_COM, "COM port" },
 151                 {ACPI_HID_LPT, "LPT" },
 152                 {ACPI_HID_PNP, "Generic PNP device" },
 153         };
 154
 155         for (size_t i = 0; hid && i < ARRAY_SIZE(lookup); i++) {
 156                 if (strcmp(hid, lookup[i].hid) == 0)
 157                         return lookup[i].name;
 158         }
 159         return "Generic device";
 160 }
 161
 162 void superio_common_fill_ssdt_generator(const struct device *dev)
 163 {
 164         if (!dev || !dev->upstream || !dev->upstream->dev) {
 165                 printk(BIOS_CRIT, "BUG: Invalid argument in %s!\n", __func__);
 166                 return;
 167         }
 168
 169         const char *scope = acpi_device_scope(dev);
 170         const char *name = acpi_device_name(dev);
 171         const u8 ldn = dev->path.pnp.device & 0xff;
 172         const u8 vldn = (dev->path.pnp.device >> 8) & 0x7;
 173         const char *hid;
 174
 175         /* Validate devicetree settings */
 176         bool bug = false;
 177         if (dev->upstream->dev->path.type != DEVICE_PATH_PNP) {
 178                 bug = true;
 179                 printk(BIOS_CRIT, "BUG: Parent of device %s is not a PNP device\n",
 180                         dev_path(dev));
 181         } else if (dev->upstream->dev->path.pnp.port != dev->path.pnp.port) {
 182                 bug = true;
 183                 printk(BIOS_CRIT, "BUG: Parent of device %s has wrong I/O port\n",
 184                         dev_path(dev));
 185         }
 186         if (bug) {
 187                 printk(BIOS_CRIT, "BUG: Check your devicetree!\n");
 188                 return;
 189         }
 190
 191         if (!scope || !name) {
 192                 printk(BIOS_ERR, "%s: Missing ACPI path/scope\n", dev_path(dev));
 193                 return;
 194         }
 195         if (vldn) {
 196                 printk(BIOS_DEBUG, "%s: Ignoring virtual LDN\n", dev_path(dev));
 197                 return;
 198         }
 199
 200         printk(BIOS_DEBUG, "%s.%s: %s\n", scope, name, dev_path(dev));
 201
 202         /* Scope */
 203         acpigen_write_scope(scope);
 204
 205         /* Device */
 206         acpigen_write_device(name);
 207
 208         acpi_device_write_uid(dev);
 209
 210         acpigen_write_name_byte("LDN", ldn);
 211         acpigen_write_name_byte("VLDN", vldn);
 212
 213         acpigen_write_method("_STA", 0);
 214         {
 215                 acpigen_write_store();
 216                 acpigen_emit_namestring("^^QLDN");
 217                 acpigen_write_integer(ldn);
 218                 acpigen_emit_byte(LOCAL0_OP);
 219
 220                 /* Multiply (Local0, 0xf, Local0) */
 221                 acpigen_emit_byte(MULTIPLY_OP);
 222                 acpigen_emit_byte(LOCAL0_OP);
 223                 acpigen_write_integer(0xf);
 224                 acpigen_emit_byte(LOCAL0_OP);
 225
 226                 acpigen_emit_byte(RETURN_OP);
 227                 acpigen_emit_byte(LOCAL0_OP);
 228
 229         }
 230         acpigen_pop_len(); /* Method */
 231
 232         /*
 233          * The ACPI6.2 spec Chapter 6.1.5 requires to set a  _HID if no _ADR
 234          * is present. Tests on Windows 10 showed that this is also true for
 235          * disabled (_STA = 0) devices, otherwise it BSODs.
 236          */
 237
 238         hid = acpi_device_hid(dev);
 239         if (!hid) {
 240                 printk(BIOS_ERR, "%s: SuperIO driver doesn't provide a _HID\n", dev_path(dev));
 241                 /* Try to guess it... */
 242                 const struct superio_dev *sdev = superio_guess_function(dev);
 243                 if (sdev && sdev->acpi_hid) {
 244                         hid = sdev->acpi_hid;
 245                         printk(BIOS_WARNING, "%s: Guessed _HID is '%s'\n", dev_path(dev), hid);
 246                 } else {
 247                         hid = ACPI_HID_PNP;
 248                         printk(BIOS_ERR, "%s: Failed to guessed _HID\n", dev_path(dev));
 249                 }
 250         }
 251
 252         acpigen_write_name_string("_HID", hid);
 253         acpigen_write_name_string("_DDN", name_from_hid(hid));
 254
 255         acpigen_write_method("_DIS", 0);
 256         {
 257                 acpigen_emit_namestring("^^DLDN");
 258                 acpigen_write_integer(ldn);
 259         }
 260         acpigen_pop_len(); /* Method */
 261
 262         if (dev->enabled && has_resources(dev)) {
 263                 /* Resources - _CRS */
 264                 acpigen_write_name("_CRS");
 265                 acpigen_write_resourcetemplate_header();
 266                 ldn_gen_resources(dev);
 267                 acpigen_write_resourcetemplate_footer();
 268
 269                 /* Resources - _PRS */
 270                 acpigen_write_name("_PRS");
 271                 acpigen_write_resourcetemplate_header();
 272                 ldn_gen_resources(dev);
 273                 acpigen_write_resourcetemplate_footer();
 274
 275                 /* Resources base and size for 3rd party ACPI code */
 276                 ldn_gen_resources_use(dev);
 277         }
 278
 279         acpigen_pop_len(); /* Device */
 280         acpigen_pop_len(); /* Scope */
 281 }