drivers/char/ipmi/ipmi_si_platform.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * ipmi_si_platform.c
   4  *
   5  * Handling for platform devices in IPMI (ACPI, OF, and things
   6  * coming from the platform.
   7  */
   8
   9 #define pr_fmt(fmt) "ipmi_platform: " fmt
  10 #define dev_fmt pr_fmt
  11
  12 #include <linux/types.h>
  13 #include <linux/module.h>
  14 #include <linux/of.h>
  15 #include <linux/of_address.h>
  16 #include <linux/of_irq.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/property.h>
  19 #include <linux/acpi.h>
  20 #include "ipmi_si.h"
  21 #include "ipmi_dmi.h"
  22
  23 static bool platform_registered;
  24 static bool si_tryplatform = true;
  25 #ifdef CONFIG_ACPI
  26 static bool          si_tryacpi = true;
  27 #endif
  28 #ifdef CONFIG_OF
  29 static bool          si_tryopenfirmware = true;
  30 #endif
  31 #ifdef CONFIG_DMI
  32 static bool          si_trydmi = true;
  33 #else
  34 static bool          si_trydmi = false;
  35 #endif
  36
  37 module_param_named(tryplatform, si_tryplatform, bool, 0);
  38 MODULE_PARM_DESC(tryplatform,
  39                  "Setting this to zero will disable the default scan of the interfaces identified via platform interfaces besides ACPI, OpenFirmware, and DMI");
  40 #ifdef CONFIG_ACPI
  41 module_param_named(tryacpi, si_tryacpi, bool, 0);
  42 MODULE_PARM_DESC(tryacpi,
  43                  "Setting this to zero will disable the default scan of the interfaces identified via ACPI");
  44 #endif
  45 #ifdef CONFIG_OF
  46 module_param_named(tryopenfirmware, si_tryopenfirmware, bool, 0);
  47 MODULE_PARM_DESC(tryopenfirmware,
  48                  "Setting this to zero will disable the default scan of the interfaces identified via OpenFirmware");
  49 #endif
  50 #ifdef CONFIG_DMI
  51 module_param_named(trydmi, si_trydmi, bool, 0);
  52 MODULE_PARM_DESC(trydmi,
  53                  "Setting this to zero will disable the default scan of the interfaces identified via DMI");
  54 #endif
  55
  56 #ifdef CONFIG_ACPI
  57 /* For GPE-type interrupts. */
  58 static u32 ipmi_acpi_gpe(acpi_handle gpe_device,
  59         u32 gpe_number, void *context)
  60 {
  61         struct si_sm_io *io = context;
  62
  63         ipmi_si_irq_handler(io->irq, io->irq_handler_data);
  64         return ACPI_INTERRUPT_HANDLED;
  65 }
  66
  67 static void acpi_gpe_irq_cleanup(struct si_sm_io *io)
  68 {
  69         if (!io->irq)
  70                 return;
  71
  72         ipmi_irq_start_cleanup(io);
  73         acpi_remove_gpe_handler(NULL, io->irq, &ipmi_acpi_gpe);
  74 }
  75
  76 static int acpi_gpe_irq_setup(struct si_sm_io *io)
  77 {
  78         acpi_status status;
  79
  80         if (!io->irq)
  81                 return 0;
  82
  83         status = acpi_install_gpe_handler(NULL,
  84                                           io->irq,
  85                                           ACPI_GPE_LEVEL_TRIGGERED,
  86                                           &ipmi_acpi_gpe,
  87                                           io);
  88         if (ACPI_FAILURE(status)) {
  89                 dev_warn(io->dev,
  90                          "Unable to claim ACPI GPE %d, running polled\n",
  91                          io->irq);
  92                 io->irq = 0;
  93                 return -EINVAL;
  94         }
  95
  96         io->irq_cleanup = acpi_gpe_irq_cleanup;
  97         ipmi_irq_finish_setup(io);
  98         dev_info(io->dev, "Using ACPI GPE %d\n", io->irq);
  99         return 0;
 100 }
 101 #endif
 102
 103 static void ipmi_set_addr_data_and_space(struct resource *r, struct si_sm_io *io)
 104 {
 105         if (resource_type(r) == IORESOURCE_IO)
 106                 io->addr_space = IPMI_IO_ADDR_SPACE;
 107         else
 108                 io->addr_space = IPMI_MEM_ADDR_SPACE;
 109         io->addr_data = r->start;
 110 }
 111
 112 static struct resource *
 113 ipmi_get_info_from_resources(struct platform_device *pdev,
 114                              struct si_sm_io *io)
 115 {
 116         struct resource *res, *res_second;
 117
 118         res = platform_get_mem_or_io(pdev, 0);
 119         if (!res) {
 120                 dev_err(&pdev->dev, "no I/O or memory address\n");
 121                 return NULL;
 122         }
 123         ipmi_set_addr_data_and_space(res, io);
 124
 125         io->regspacing = DEFAULT_REGSPACING;
 126         res_second = platform_get_mem_or_io(pdev, 1);
 127         if (res_second && resource_type(res_second) == resource_type(res)) {
 128                 if (res_second->start > io->addr_data)
 129                         io->regspacing = res_second->start - io->addr_data;
 130         }
 131
 132         return res;
 133 }
 134
 135 static int platform_ipmi_probe(struct platform_device *pdev)
 136 {
 137         struct si_sm_io io;
 138         u8 type, slave_addr, addr_source, regsize, regshift;
 139         int rv;
 140
 141         rv = device_property_read_u8(&pdev->dev, "addr-source", &addr_source);
 142         if (rv)
 143                 addr_source = SI_PLATFORM;
 144         if (addr_source >= SI_LAST)
 145                 return -EINVAL;
 146
 147         if (addr_source == SI_SMBIOS) {
 148                 if (!si_trydmi)
 149                         return -ENODEV;
 150         } else if (addr_source != SI_HARDCODED) {
 151                 if (!si_tryplatform)
 152                         return -ENODEV;
 153         }
 154
 155         rv = device_property_read_u8(&pdev->dev, "ipmi-type", &type);
 156         if (rv)
 157                 return -ENODEV;
 158
 159         memset(&io, 0, sizeof(io));
 160         io.addr_source = addr_source;
 161         dev_info(&pdev->dev, "probing via %s\n",
 162                  ipmi_addr_src_to_str(addr_source));
 163
 164         switch (type) {
 165         case SI_KCS:
 166         case SI_SMIC:
 167         case SI_BT:
 168                 io.si_type = type;
 169                 break;
 170         case SI_TYPE_INVALID: /* User disabled this in hardcode. */
 171                 return -ENODEV;
 172         default:
 173                 dev_err(&pdev->dev, "ipmi-type property is invalid\n");
 174                 return -EINVAL;
 175         }
 176
 177         io.regsize = DEFAULT_REGSIZE;
 178         rv = device_property_read_u8(&pdev->dev, "reg-size", &regsize);
 179         if (!rv)
 180                 io.regsize = regsize;
 181
 182         io.regshift = 0;
 183         rv = device_property_read_u8(&pdev->dev, "reg-shift", &regshift);
 184         if (!rv)
 185                 io.regshift = regshift;
 186
 187         if (!ipmi_get_info_from_resources(pdev, &io))
 188                 return -EINVAL;
 189
 190         rv = device_property_read_u8(&pdev->dev, "slave-addr", &slave_addr);
 191         if (rv)
 192                 io.slave_addr = 0x20;
 193         else
 194                 io.slave_addr = slave_addr;
 195
 196         io.irq = platform_get_irq_optional(pdev, 0);
 197         if (io.irq > 0)
 198                 io.irq_setup = ipmi_std_irq_setup;
 199         else
 200                 io.irq = 0;
 201
 202         io.dev = &pdev->dev;
 203
 204         pr_info("ipmi_si: %s: %s %#lx regsize %d spacing %d irq %d\n",
 205                 ipmi_addr_src_to_str(addr_source),
 206                 (io.addr_space == IPMI_IO_ADDR_SPACE) ? "io" : "mem",
 207                 io.addr_data, io.regsize, io.regspacing, io.irq);
 208
 209         ipmi_si_add_smi(&io);
 210
 211         return 0;
 212 }
 213
 214 #ifdef CONFIG_OF
 215 static const struct of_device_id of_ipmi_match[] = {
 216         { .type = "ipmi", .compatible = "ipmi-kcs",
 217           .data = (void *)(unsigned long) SI_KCS },
 218         { .type = "ipmi", .compatible = "ipmi-smic",
 219           .data = (void *)(unsigned long) SI_SMIC },
 220         { .type = "ipmi", .compatible = "ipmi-bt",
 221           .data = (void *)(unsigned long) SI_BT },
 222         {},
 223 };
 224 MODULE_DEVICE_TABLE(of, of_ipmi_match);
 225
 226 static int of_ipmi_probe(struct platform_device *pdev)
 227 {
 228         struct si_sm_io io;
 229         struct resource resource;
 230         const __be32 *regsize, *regspacing, *regshift;
 231         struct device_node *np = pdev->dev.of_node;
 232         int ret;
 233         int proplen;
 234
 235         if (!si_tryopenfirmware)
 236                 return -ENODEV;
 237
 238         dev_info(&pdev->dev, "probing via device tree\n");
 239
 240         if (!of_device_is_available(np))
 241                 return -EINVAL;
 242
 243         ret = of_address_to_resource(np, 0, &resource);
 244         if (ret) {
 245                 dev_warn(&pdev->dev, "invalid address from OF\n");
 246                 return ret;
 247         }
 248
 249         regsize = of_get_property(np, "reg-size", &proplen);
 250         if (regsize && proplen != 4) {
 251                 dev_warn(&pdev->dev, "invalid regsize from OF\n");
 252                 return -EINVAL;
 253         }
 254
 255         regspacing = of_get_property(np, "reg-spacing", &proplen);
 256         if (regspacing && proplen != 4) {
 257                 dev_warn(&pdev->dev, "invalid regspacing from OF\n");
 258                 return -EINVAL;
 259         }
 260
 261         regshift = of_get_property(np, "reg-shift", &proplen);
 262         if (regshift && proplen != 4) {
 263                 dev_warn(&pdev->dev, "invalid regshift from OF\n");
 264                 return -EINVAL;
 265         }
 266
 267         memset(&io, 0, sizeof(io));
 268         io.si_type      = (enum si_type)device_get_match_data(&pdev->dev);
 269         io.addr_source  = SI_DEVICETREE;
 270         io.irq_setup    = ipmi_std_irq_setup;
 271
 272         ipmi_set_addr_data_and_space(&resource, &io);
 273
 274         io.regsize      = regsize ? be32_to_cpup(regsize) : DEFAULT_REGSIZE;
 275         io.regspacing   = regspacing ? be32_to_cpup(regspacing) : DEFAULT_REGSPACING;
 276         io.regshift     = regshift ? be32_to_cpup(regshift) : 0;
 277
 278         io.irq          = irq_of_parse_and_map(pdev->dev.of_node, 0);
 279         io.dev          = &pdev->dev;
 280
 281         dev_dbg(&pdev->dev, "addr 0x%lx regsize %d spacing %d irq %d\n",
 282                 io.addr_data, io.regsize, io.regspacing, io.irq);
 283
 284         return ipmi_si_add_smi(&io);
 285 }
 286 #else
 287 #define of_ipmi_match NULL
 288 static int of_ipmi_probe(struct platform_device *dev)
 289 {
 290         return -ENODEV;
 291 }
 292 #endif
 293
 294 #ifdef CONFIG_ACPI
 295 static int find_slave_address(struct si_sm_io *io, int slave_addr)
 296 {
 297 #ifdef CONFIG_IPMI_DMI_DECODE
 298         if (!slave_addr)
 299                 slave_addr = ipmi_dmi_get_slave_addr(io->si_type,
 300                                                      io->addr_space,
 301                                                      io->addr_data);
 302 #endif
 303
 304         return slave_addr;
 305 }
 306
 307 static int acpi_ipmi_probe(struct platform_device *pdev)
 308 {
 309         struct device *dev = &pdev->dev;
 310         struct si_sm_io io;
 311         acpi_handle handle;
 312         acpi_status status;
 313         unsigned long long tmp;
 314         struct resource *res;
 315
 316         if (!si_tryacpi)
 317                 return -ENODEV;
 318
 319         handle = ACPI_HANDLE(dev);
 320         if (!handle)
 321                 return -ENODEV;
 322
 323         memset(&io, 0, sizeof(io));
 324         io.addr_source = SI_ACPI;
 325         dev_info(dev, "probing via ACPI\n");
 326
 327         io.addr_info.acpi_info.acpi_handle = handle;
 328
 329         /* _IFT tells us the interface type: KCS, BT, etc */
 330         status = acpi_evaluate_integer(handle, "_IFT", NULL, &tmp);
 331         if (ACPI_FAILURE(status)) {
 332                 dev_err(dev, "Could not find ACPI IPMI interface type\n");
 333                 return -EINVAL;
 334         }
 335
 336         switch (tmp) {
 337         case 1:
 338                 io.si_type = SI_KCS;
 339                 break;
 340         case 2:
 341                 io.si_type = SI_SMIC;
 342                 break;
 343         case 3:
 344                 io.si_type = SI_BT;
 345                 break;
 346         case 4: /* SSIF, just ignore */
 347                 return -ENODEV;
 348         default:
 349                 dev_info(dev, "unknown IPMI type %lld\n", tmp);
 350                 return -EINVAL;
 351         }
 352
 353         io.dev = dev;
 354         io.regsize = DEFAULT_REGSIZE;
 355         io.regshift = 0;
 356
 357         res = ipmi_get_info_from_resources(pdev, &io);
 358         if (!res)
 359                 return -EINVAL;
 360
 361         /* If _GPE exists, use it; otherwise use standard interrupts */
 362         status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
 363         if (ACPI_SUCCESS(status)) {
 364                 io.irq = tmp;
 365                 io.irq_setup = acpi_gpe_irq_setup;
 366         } else {
 367                 int irq = platform_get_irq_optional(pdev, 0);
 368
 369                 if (irq > 0) {
 370                         io.irq = irq;
 371                         io.irq_setup = ipmi_std_irq_setup;
 372                 }
 373         }
 374
 375         io.slave_addr = find_slave_address(&io, io.slave_addr);
 376
 377         dev_info(dev, "%pR regsize %d spacing %d irq %d\n",
 378                  res, io.regsize, io.regspacing, io.irq);
 379
 380         request_module_nowait("acpi_ipmi");
 381
 382         return ipmi_si_add_smi(&io);
 383 }
 384
 385 static const struct acpi_device_id acpi_ipmi_match[] = {
 386         { "IPI0001", 0 },
 387         { },
 388 };
 389 MODULE_DEVICE_TABLE(acpi, acpi_ipmi_match);
 390 #else
 391 static int acpi_ipmi_probe(struct platform_device *dev)
 392 {
 393         return -ENODEV;
 394 }
 395 #endif
 396
 397 static int ipmi_probe(struct platform_device *pdev)
 398 {
 399         if (pdev->dev.of_node && of_ipmi_probe(pdev) == 0)
 400                 return 0;
 401
 402         if (acpi_ipmi_probe(pdev) == 0)
 403                 return 0;
 404
 405         return platform_ipmi_probe(pdev);
 406 }
 407
 408 static void ipmi_remove(struct platform_device *pdev)
 409 {
 410         ipmi_si_remove_by_dev(&pdev->dev);
 411 }
 412
 413 static int pdev_match_name(struct device *dev, const void *data)
 414 {
 415         struct platform_device *pdev = to_platform_device(dev);
 416         const char *name = data;
 417
 418         return strcmp(pdev->name, name) == 0;
 419 }
 420
 421 void ipmi_remove_platform_device_by_name(char *name)
 422 {
 423         struct device *dev;
 424
 425         while ((dev = bus_find_device(&platform_bus_type, NULL, name,
 426                                       pdev_match_name))) {
 427                 struct platform_device *pdev = to_platform_device(dev);
 428
 429                 platform_device_unregister(pdev);
 430                 put_device(dev);
 431         }
 432 }
 433
 434 static const struct platform_device_id si_plat_ids[] = {
 435         { "dmi-ipmi-si", 0 },
 436         { "hardcode-ipmi-si", 0 },
 437         { "hotmod-ipmi-si", 0 },
 438         { }
 439 };
 440
 441 struct platform_driver ipmi_platform_driver = {
 442         .driver = {
 443                 .name = SI_DEVICE_NAME,
 444                 .of_match_table = of_ipmi_match,
 445                 .acpi_match_table = ACPI_PTR(acpi_ipmi_match),
 446         },
 447         .probe          = ipmi_probe,
 448         .remove         = ipmi_remove,
 449         .id_table       = si_plat_ids
 450 };
 451
 452 void ipmi_si_platform_init(void)
 453 {
 454         int rv = platform_driver_register(&ipmi_platform_driver);
 455         if (rv)
 456                 pr_err("Unable to register driver: %d\n", rv);
 457         else
 458                 platform_registered = true;
 459 }
 460
 461 void ipmi_si_platform_shutdown(void)
 462 {
 463         if (platform_registered)
 464                 platform_driver_unregister(&ipmi_platform_driver);
 465 }