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