drivers/char/ipmi/ipmi_si_platform.c

   1 /*
   2  * ipmi_si_platform.c
   3  *
   4  * Handling for platform devices in IPMI (ACPI, OF, and things
   5  * coming from the platform.
   6  */
   7 #include <linux/types.h>
   8 #include <linux/module.h>
   9 #include <linux/of_device.h>
  10 #include <linux/of_platform.h>
  11 #include <linux/of_address.h>
  12 #include <linux/of_irq.h>
  13 #include <linux/acpi.h>
  14 #include "ipmi_si.h"
  15 #include "ipmi_dmi.h"
  16
  17 #define PFX "ipmi_platform: "
  18
  19 static bool si_tryplatform = true;
  20 #ifdef CONFIG_ACPI
  21 static bool          si_tryacpi = true;
  22 #endif
  23 #ifdef CONFIG_OF
  24 static bool          si_tryopenfirmware = true;
  25 #endif
  26 #ifdef CONFIG_DMI
  27 static bool          si_trydmi = true;
  28 #else
  29 static bool          si_trydmi = false;
  30 #endif
  31
  32 module_param_named(tryplatform, si_tryplatform, bool, 0);
  33 MODULE_PARM_DESC(tryplatform, "Setting this to zero will disable the"
  34                  " default scan of the interfaces identified via platform"
  35                  " interfaces besides ACPI, OpenFirmware, and DMI");
  36 #ifdef CONFIG_ACPI
  37 module_param_named(tryacpi, si_tryacpi, bool, 0);
  38 MODULE_PARM_DESC(tryacpi, "Setting this to zero will disable the"
  39                  " default scan of the interfaces identified via ACPI");
  40 #endif
  41 #ifdef CONFIG_OF
  42 module_param_named(tryopenfirmware, si_tryopenfirmware, bool, 0);
  43 MODULE_PARM_DESC(tryopenfirmware, "Setting this to zero will disable the"
  44                  " default scan of the interfaces identified via OpenFirmware");
  45 #endif
  46 #ifdef CONFIG_DMI
  47 module_param_named(trydmi, si_trydmi, bool, 0);
  48 MODULE_PARM_DESC(trydmi, "Setting this to zero will disable the"
  49                  " default scan of the interfaces identified via DMI");
  50 #endif
  51
  52 #ifdef CONFIG_ACPI
  53
  54 /*
  55  * Once we get an ACPI failure, we don't try any more, because we go
  56  * through the tables sequentially.  Once we don't find a table, there
  57  * are no more.
  58  */
  59 static int acpi_failure;
  60
  61 /* For GPE-type interrupts. */
  62 static u32 ipmi_acpi_gpe(acpi_handle gpe_device,
  63         u32 gpe_number, void *context)
  64 {
  65         struct si_sm_io *io = context;
  66
  67         ipmi_si_irq_handler(io->irq, io->irq_handler_data);
  68         return ACPI_INTERRUPT_HANDLED;
  69 }
  70
  71 static void acpi_gpe_irq_cleanup(struct si_sm_io *io)
  72 {
  73         if (!io->irq)
  74                 return;
  75
  76         ipmi_irq_start_cleanup(io);
  77         acpi_remove_gpe_handler(NULL, io->irq, &ipmi_acpi_gpe);
  78 }
  79
  80 static int acpi_gpe_irq_setup(struct si_sm_io *io)
  81 {
  82         acpi_status status;
  83
  84         if (!io->irq)
  85                 return 0;
  86
  87         status = acpi_install_gpe_handler(NULL,
  88                                           io->irq,
  89                                           ACPI_GPE_LEVEL_TRIGGERED,
  90                                           &ipmi_acpi_gpe,
  91                                           io);
  92         if (status != AE_OK) {
  93                 dev_warn(io->dev,
  94                          "Unable to claim ACPI GPE %d, running polled\n",
  95                          io->irq);
  96                 io->irq = 0;
  97                 return -EINVAL;
  98         } else {
  99                 io->irq_cleanup = acpi_gpe_irq_cleanup;
 100                 ipmi_irq_finish_setup(io);
 101                 dev_info(io->dev, "Using ACPI GPE %d\n", io->irq);
 102                 return 0;
 103         }
 104 }
 105
 106 /*
 107  * Defined at
 108  * http://h21007.www2.hp.com/portal/download/files/unprot/hpspmi.pdf
 109  */
 110 struct SPMITable {
 111         s8      Signature[4];
 112         u32     Length;
 113         u8      Revision;
 114         u8      Checksum;
 115         s8      OEMID[6];
 116         s8      OEMTableID[8];
 117         s8      OEMRevision[4];
 118         s8      CreatorID[4];
 119         s8      CreatorRevision[4];
 120         u8      InterfaceType;
 121         u8      IPMIlegacy;
 122         s16     SpecificationRevision;
 123
 124         /*
 125          * Bit 0 - SCI interrupt supported
 126          * Bit 1 - I/O APIC/SAPIC
 127          */
 128         u8      InterruptType;
 129
 130         /*
 131          * If bit 0 of InterruptType is set, then this is the SCI
 132          * interrupt in the GPEx_STS register.
 133          */
 134         u8      GPE;
 135
 136         s16     Reserved;
 137
 138         /*
 139          * If bit 1 of InterruptType is set, then this is the I/O
 140          * APIC/SAPIC interrupt.
 141          */
 142         u32     GlobalSystemInterrupt;
 143
 144         /* The actual register address. */
 145         struct acpi_generic_address addr;
 146
 147         u8      UID[4];
 148
 149         s8      spmi_id[1]; /* A '\0' terminated array starts here. */
 150 };
 151
 152 static int try_init_spmi(struct SPMITable *spmi)
 153 {
 154         struct si_sm_io io;
 155
 156         if (spmi->IPMIlegacy != 1) {
 157                 pr_info(PFX "Bad SPMI legacy %d\n", spmi->IPMIlegacy);
 158                 return -ENODEV;
 159         }
 160
 161         memset(&io, 0, sizeof(io));
 162         io.addr_source = SI_SPMI;
 163         pr_info(PFX "probing via SPMI\n");
 164
 165         /* Figure out the interface type. */
 166         switch (spmi->InterfaceType) {
 167         case 1: /* KCS */
 168                 io.si_type = SI_KCS;
 169                 break;
 170         case 2: /* SMIC */
 171                 io.si_type = SI_SMIC;
 172                 break;
 173         case 3: /* BT */
 174                 io.si_type = SI_BT;
 175                 break;
 176         case 4: /* SSIF, just ignore */
 177                 return -EIO;
 178         default:
 179                 pr_info(PFX "Unknown ACPI/SPMI SI type %d\n",
 180                         spmi->InterfaceType);
 181                 return -EIO;
 182         }
 183
 184         if (spmi->InterruptType & 1) {
 185                 /* We've got a GPE interrupt. */
 186                 io.irq = spmi->GPE;
 187                 io.irq_setup = acpi_gpe_irq_setup;
 188         } else if (spmi->InterruptType & 2) {
 189                 /* We've got an APIC/SAPIC interrupt. */
 190                 io.irq = spmi->GlobalSystemInterrupt;
 191                 io.irq_setup = ipmi_std_irq_setup;
 192         } else {
 193                 /* Use the default interrupt setting. */
 194                 io.irq = 0;
 195                 io.irq_setup = NULL;
 196         }
 197
 198         if (spmi->addr.bit_width) {
 199                 /* A (hopefully) properly formed register bit width. */
 200                 io.regspacing = spmi->addr.bit_width / 8;
 201         } else {
 202                 io.regspacing = DEFAULT_REGSPACING;
 203         }
 204         io.regsize = io.regspacing;
 205         io.regshift = spmi->addr.bit_offset;
 206
 207         if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) {
 208                 io.addr_type = IPMI_MEM_ADDR_SPACE;
 209         } else if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_IO) {
 210                 io.addr_type = IPMI_IO_ADDR_SPACE;
 211         } else {
 212                 pr_warn(PFX "Unknown ACPI I/O Address type\n");
 213                 return -EIO;
 214         }
 215         io.addr_data = spmi->addr.address;
 216
 217         pr_info("ipmi_si: SPMI: %s %#lx regsize %d spacing %d irq %d\n",
 218                 (io.addr_type == IPMI_IO_ADDR_SPACE) ? "io" : "mem",
 219                 io.addr_data, io.regsize, io.regspacing, io.irq);
 220
 221         return ipmi_si_add_smi(&io);
 222 }
 223
 224 static void spmi_find_bmc(void)
 225 {
 226         acpi_status      status;
 227         struct SPMITable *spmi;
 228         int              i;
 229
 230         if (acpi_disabled)
 231                 return;
 232
 233         if (acpi_failure)
 234                 return;
 235
 236         for (i = 0; ; i++) {
 237                 status = acpi_get_table(ACPI_SIG_SPMI, i+1,
 238                                         (struct acpi_table_header **)&spmi);
 239                 if (status != AE_OK)
 240                         return;
 241
 242                 try_init_spmi(spmi);
 243         }
 244 }
 245 #endif
 246
 247 static struct resource *
 248 ipmi_get_info_from_resources(struct platform_device *pdev,
 249                              struct si_sm_io *io)
 250 {
 251         struct resource *res, *res_second;
 252
 253         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
 254         if (res) {
 255                 io->addr_type = IPMI_IO_ADDR_SPACE;
 256         } else {
 257                 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 258                 if (res)
 259                         io->addr_type = IPMI_MEM_ADDR_SPACE;
 260         }
 261         if (!res) {
 262                 dev_err(&pdev->dev, "no I/O or memory address\n");
 263                 return NULL;
 264         }
 265         io->addr_data = res->start;
 266
 267         io->regspacing = DEFAULT_REGSPACING;
 268         res_second = platform_get_resource(pdev,
 269                                (io->addr_type == IPMI_IO_ADDR_SPACE) ?
 270                                         IORESOURCE_IO : IORESOURCE_MEM,
 271                                1);
 272         if (res_second) {
 273                 if (res_second->start > io->addr_data)
 274                         io->regspacing = res_second->start - io->addr_data;
 275         }
 276         io->regsize = DEFAULT_REGSIZE;
 277         io->regshift = 0;
 278
 279         return res;
 280 }
 281
 282 static int platform_ipmi_probe(struct platform_device *pdev)
 283 {
 284         struct si_sm_io io;
 285         u8 type, slave_addr, addr_source;
 286         int rv;
 287
 288         rv = device_property_read_u8(&pdev->dev, "addr-source", &addr_source);
 289         if (rv)
 290                 addr_source = SI_PLATFORM;
 291         if (addr_source >= SI_LAST)
 292                 return -EINVAL;
 293
 294         if (addr_source == SI_SMBIOS) {
 295                 if (!si_trydmi)
 296                         return -ENODEV;
 297         } else {
 298                 if (!si_tryplatform)
 299                         return -ENODEV;
 300         }
 301
 302         rv = device_property_read_u8(&pdev->dev, "ipmi-type", &type);
 303         if (rv)
 304                 return -ENODEV;
 305
 306         memset(&io, 0, sizeof(io));
 307         io.addr_source = addr_source;
 308         dev_info(&pdev->dev, PFX "probing via %s\n",
 309                  ipmi_addr_src_to_str(addr_source));
 310
 311         switch (type) {
 312         case SI_KCS:
 313         case SI_SMIC:
 314         case SI_BT:
 315                 io.si_type = type;
 316                 break;
 317         default:
 318                 dev_err(&pdev->dev, "ipmi-type property is invalid\n");
 319                 return -EINVAL;
 320         }
 321
 322         if (!ipmi_get_info_from_resources(pdev, &io))
 323                 return -EINVAL;
 324
 325         rv = device_property_read_u8(&pdev->dev, "slave-addr", &slave_addr);
 326         if (rv) {
 327                 dev_warn(&pdev->dev, "device has no slave-addr property\n");
 328                 io.slave_addr = 0x20;
 329         } else {
 330                 io.slave_addr = slave_addr;
 331         }
 332
 333         io.irq = platform_get_irq(pdev, 0);
 334         if (io.irq > 0)
 335                 io.irq_setup = ipmi_std_irq_setup;
 336         else
 337                 io.irq = 0;
 338
 339         io.dev = &pdev->dev;
 340
 341         pr_info("ipmi_si: SMBIOS: %s %#lx regsize %d spacing %d irq %d\n",
 342                 (io.addr_type == IPMI_IO_ADDR_SPACE) ? "io" : "mem",
 343                 io.addr_data, io.regsize, io.regspacing, io.irq);
 344
 345         ipmi_si_add_smi(&io);
 346
 347         return 0;
 348 }
 349
 350 #ifdef CONFIG_OF
 351 static const struct of_device_id of_ipmi_match[] = {
 352         { .type = "ipmi", .compatible = "ipmi-kcs",
 353           .data = (void *)(unsigned long) SI_KCS },
 354         { .type = "ipmi", .compatible = "ipmi-smic",
 355           .data = (void *)(unsigned long) SI_SMIC },
 356         { .type = "ipmi", .compatible = "ipmi-bt",
 357           .data = (void *)(unsigned long) SI_BT },
 358         {},
 359 };
 360 MODULE_DEVICE_TABLE(of, of_ipmi_match);
 361
 362 static int of_ipmi_probe(struct platform_device *pdev)
 363 {
 364         const struct of_device_id *match;
 365         struct si_sm_io io;
 366         struct resource resource;
 367         const __be32 *regsize, *regspacing, *regshift;
 368         struct device_node *np = pdev->dev.of_node;
 369         int ret;
 370         int proplen;
 371
 372         if (!si_tryopenfirmware)
 373                 return -ENODEV;
 374
 375         dev_info(&pdev->dev, "probing via device tree\n");
 376
 377         match = of_match_device(of_ipmi_match, &pdev->dev);
 378         if (!match)
 379                 return -ENODEV;
 380
 381         if (!of_device_is_available(np))
 382                 return -EINVAL;
 383
 384         ret = of_address_to_resource(np, 0, &resource);
 385         if (ret) {
 386                 dev_warn(&pdev->dev, PFX "invalid address from OF\n");
 387                 return ret;
 388         }
 389
 390         regsize = of_get_property(np, "reg-size", &proplen);
 391         if (regsize && proplen != 4) {
 392                 dev_warn(&pdev->dev, PFX "invalid regsize from OF\n");
 393                 return -EINVAL;
 394         }
 395
 396         regspacing = of_get_property(np, "reg-spacing", &proplen);
 397         if (regspacing && proplen != 4) {
 398                 dev_warn(&pdev->dev, PFX "invalid regspacing from OF\n");
 399                 return -EINVAL;
 400         }
 401
 402         regshift = of_get_property(np, "reg-shift", &proplen);
 403         if (regshift && proplen != 4) {
 404                 dev_warn(&pdev->dev, PFX "invalid regshift from OF\n");
 405                 return -EINVAL;
 406         }
 407
 408         memset(&io, 0, sizeof(io));
 409         io.si_type      = (enum si_type) match->data;
 410         io.addr_source  = SI_DEVICETREE;
 411         io.irq_setup    = ipmi_std_irq_setup;
 412
 413         if (resource.flags & IORESOURCE_IO)
 414                 io.addr_type = IPMI_IO_ADDR_SPACE;
 415         else
 416                 io.addr_type = IPMI_MEM_ADDR_SPACE;
 417
 418         io.addr_data    = resource.start;
 419
 420         io.regsize      = regsize ? be32_to_cpup(regsize) : DEFAULT_REGSIZE;
 421         io.regspacing   = regspacing ? be32_to_cpup(regspacing) : DEFAULT_REGSPACING;
 422         io.regshift     = regshift ? be32_to_cpup(regshift) : 0;
 423
 424         io.irq          = irq_of_parse_and_map(pdev->dev.of_node, 0);
 425         io.dev          = &pdev->dev;
 426
 427         dev_dbg(&pdev->dev, "addr 0x%lx regsize %d spacing %d irq %d\n",
 428                 io.addr_data, io.regsize, io.regspacing, io.irq);
 429
 430         return ipmi_si_add_smi(&io);
 431 }
 432 #else
 433 #define of_ipmi_match NULL
 434 static int of_ipmi_probe(struct platform_device *dev)
 435 {
 436         return -ENODEV;
 437 }
 438 #endif
 439
 440 #ifdef CONFIG_ACPI
 441 static int find_slave_address(struct si_sm_io *io, int slave_addr)
 442 {
 443 #ifdef CONFIG_IPMI_DMI_DECODE
 444         if (!slave_addr) {
 445                 u32 flags = IORESOURCE_IO;
 446
 447                 if (io->addr_type == IPMI_MEM_ADDR_SPACE)
 448                         flags = IORESOURCE_MEM;
 449
 450                 slave_addr = ipmi_dmi_get_slave_addr(io->si_type, flags,
 451                                                      io->addr_data);
 452         }
 453 #endif
 454
 455         return slave_addr;
 456 }
 457
 458 static int acpi_ipmi_probe(struct platform_device *pdev)
 459 {
 460         struct si_sm_io io;
 461         acpi_handle handle;
 462         acpi_status status;
 463         unsigned long long tmp;
 464         struct resource *res;
 465         int rv = -EINVAL;
 466
 467         if (!si_tryacpi)
 468                 return -ENODEV;
 469
 470         handle = ACPI_HANDLE(&pdev->dev);
 471         if (!handle)
 472                 return -ENODEV;
 473
 474         memset(&io, 0, sizeof(io));
 475         io.addr_source = SI_ACPI;
 476         dev_info(&pdev->dev, PFX "probing via ACPI\n");
 477
 478         io.addr_info.acpi_info.acpi_handle = handle;
 479
 480         /* _IFT tells us the interface type: KCS, BT, etc */
 481         status = acpi_evaluate_integer(handle, "_IFT", NULL, &tmp);
 482         if (ACPI_FAILURE(status)) {
 483                 dev_err(&pdev->dev,
 484                         "Could not find ACPI IPMI interface type\n");
 485                 goto err_free;
 486         }
 487
 488         switch (tmp) {
 489         case 1:
 490                 io.si_type = SI_KCS;
 491                 break;
 492         case 2:
 493                 io.si_type = SI_SMIC;
 494                 break;
 495         case 3:
 496                 io.si_type = SI_BT;
 497                 break;
 498         case 4: /* SSIF, just ignore */
 499                 rv = -ENODEV;
 500                 goto err_free;
 501         default:
 502                 dev_info(&pdev->dev, "unknown IPMI type %lld\n", tmp);
 503                 goto err_free;
 504         }
 505
 506         res = ipmi_get_info_from_resources(pdev, &io);
 507         if (!res) {
 508                 rv = -EINVAL;
 509                 goto err_free;
 510         }
 511
 512         /* If _GPE exists, use it; otherwise use standard interrupts */
 513         status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
 514         if (ACPI_SUCCESS(status)) {
 515                 io.irq = tmp;
 516                 io.irq_setup = acpi_gpe_irq_setup;
 517         } else {
 518                 int irq = platform_get_irq(pdev, 0);
 519
 520                 if (irq > 0) {
 521                         io.irq = irq;
 522                         io.irq_setup = ipmi_std_irq_setup;
 523                 }
 524         }
 525
 526         io.slave_addr = find_slave_address(&io, io.slave_addr);
 527
 528         io.dev = &pdev->dev;
 529
 530         dev_info(io.dev, "%pR regsize %d spacing %d irq %d\n",
 531                  res, io.regsize, io.regspacing, io.irq);
 532
 533         return ipmi_si_add_smi(&io);
 534
 535 err_free:
 536         return rv;
 537 }
 538
 539 static const struct acpi_device_id acpi_ipmi_match[] = {
 540         { "IPI0001", 0 },
 541         { },
 542 };
 543 MODULE_DEVICE_TABLE(acpi, acpi_ipmi_match);
 544 #else
 545 static int acpi_ipmi_probe(struct platform_device *dev)
 546 {
 547         return -ENODEV;
 548 }
 549 #endif
 550
 551 static int ipmi_probe(struct platform_device *pdev)
 552 {
 553         if (pdev->dev.of_node && of_ipmi_probe(pdev) == 0)
 554                 return 0;
 555
 556         if (acpi_ipmi_probe(pdev) == 0)
 557                 return 0;
 558
 559         return platform_ipmi_probe(pdev);
 560 }
 561
 562 static int ipmi_remove(struct platform_device *pdev)
 563 {
 564         return ipmi_si_remove_by_dev(&pdev->dev);
 565 }
 566
 567 struct platform_driver ipmi_platform_driver = {
 568         .driver = {
 569                 .name = DEVICE_NAME,
 570                 .of_match_table = of_ipmi_match,
 571                 .acpi_match_table = ACPI_PTR(acpi_ipmi_match),
 572         },
 573         .probe          = ipmi_probe,
 574         .remove         = ipmi_remove,
 575 };
 576
 577 void ipmi_si_platform_init(void)
 578 {
 579         int rv = platform_driver_register(&ipmi_platform_driver);
 580         if (rv)
 581                 pr_err(PFX "Unable to register driver: %d\n", rv);
 582
 583 #ifdef CONFIG_ACPI
 584         if (si_tryacpi)
 585                 spmi_find_bmc();
 586 #endif
 587
 588 }
 589
 590 void ipmi_si_platform_shutdown(void)
 591 {
 592         platform_driver_unregister(&ipmi_platform_driver);
 593 }