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