drivers/bus/hisi_lpc.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2017 Hisilicon Limited, All Rights Reserved.
   4  * Author: Zhichang Yuan <yuanzhichang@hisilicon.com>
   5  * Author: Zou Rongrong <zourongrong@huawei.com>
   6  * Author: John Garry <john.garry@huawei.com>
   7  */
   8
   9 #include <linux/acpi.h>
  10 #include <linux/console.h>
  11 #include <linux/delay.h>
  12 #include <linux/io.h>
  13 #include <linux/logic_pio.h>
  14 #include <linux/module.h>
  15 #include <linux/of.h>
  16 #include <linux/of_address.h>
  17 #include <linux/of_platform.h>
  18 #include <linux/pci.h>
  19 #include <linux/serial_8250.h>
  20 #include <linux/slab.h>
  21
  22 #define DRV_NAME "hisi-lpc"
  23
  24 /*
  25  * Setting this bit means each IO operation will target a different port
  26  * address; 0 means repeated IO operations will use the same port,
  27  * such as BT.
  28  */
  29 #define FG_INCRADDR_LPC         0x02
  30
  31 struct lpc_cycle_para {
  32         unsigned int opflags;
  33         unsigned int csize; /* data length of each operation */
  34 };
  35
  36 struct hisi_lpc_dev {
  37         spinlock_t cycle_lock;
  38         void __iomem  *membase;
  39         struct logic_pio_hwaddr *io_host;
  40 };
  41
  42 /* The max IO cycle counts supported is four per operation at maximum */
  43 #define LPC_MAX_DWIDTH  4
  44
  45 #define LPC_REG_STARTUP_SIGNAL          0x00
  46 #define LPC_REG_STARTUP_SIGNAL_START    BIT(0)
  47 #define LPC_REG_OP_STATUS               0x04
  48 #define LPC_REG_OP_STATUS_IDLE          BIT(0)
  49 #define LPC_REG_OP_STATUS_FINISHED      BIT(1)
  50 #define LPC_REG_OP_LEN                  0x10 /* LPC cycles count per start */
  51 #define LPC_REG_CMD                     0x14
  52 #define LPC_REG_CMD_OP                  BIT(0) /* 0: read, 1: write */
  53 #define LPC_REG_CMD_SAMEADDR            BIT(3)
  54 #define LPC_REG_ADDR                    0x20 /* target address */
  55 #define LPC_REG_WDATA                   0x24 /* write FIFO */
  56 #define LPC_REG_RDATA                   0x28 /* read FIFO */
  57
  58 /* The minimal nanosecond interval for each query on LPC cycle status */
  59 #define LPC_NSEC_PERWAIT        100
  60
  61 /*
  62  * The maximum waiting time is about 128us.  It is specific for stream I/O,
  63  * such as ins.
  64  *
  65  * The fastest IO cycle time is about 390ns, but the worst case will wait
  66  * for extra 256 lpc clocks, so (256 + 13) * 30ns = 8 us. The maximum burst
  67  * cycles is 16. So, the maximum waiting time is about 128us under worst
  68  * case.
  69  *
  70  * Choose 1300 as the maximum.
  71  */
  72 #define LPC_MAX_WAITCNT         1300
  73
  74 /* About 10us. This is specific for single IO operations, such as inb */
  75 #define LPC_PEROP_WAITCNT       100
  76
  77 static int wait_lpc_idle(void __iomem *mbase, unsigned int waitcnt)
  78 {
  79         u32 status;
  80
  81         do {
  82                 status = readl(mbase + LPC_REG_OP_STATUS);
  83                 if (status & LPC_REG_OP_STATUS_IDLE)
  84                         return (status & LPC_REG_OP_STATUS_FINISHED) ? 0 : -EIO;
  85                 ndelay(LPC_NSEC_PERWAIT);
  86         } while (--waitcnt);
  87
  88         return -ETIME;
  89 }
  90
  91 /*
  92  * hisi_lpc_target_in - trigger a series of LPC cycles for read operation
  93  * @lpcdev: pointer to hisi lpc device
  94  * @para: some parameters used to control the lpc I/O operations
  95  * @addr: the lpc I/O target port address
  96  * @buf: where the read back data is stored
  97  * @opcnt: how many I/O operations required, i.e. data width
  98  *
  99  * Returns 0 on success, non-zero on fail.
 100  */
 101 static int hisi_lpc_target_in(struct hisi_lpc_dev *lpcdev,
 102                               struct lpc_cycle_para *para, unsigned long addr,
 103                               unsigned char *buf, unsigned long opcnt)
 104 {
 105         unsigned int cmd_word;
 106         unsigned int waitcnt;
 107         unsigned long flags;
 108         int ret;
 109
 110         if (!buf || !opcnt || !para || !para->csize || !lpcdev)
 111                 return -EINVAL;
 112
 113         cmd_word = 0; /* IO mode, Read */
 114         waitcnt = LPC_PEROP_WAITCNT;
 115         if (!(para->opflags & FG_INCRADDR_LPC)) {
 116                 cmd_word |= LPC_REG_CMD_SAMEADDR;
 117                 waitcnt = LPC_MAX_WAITCNT;
 118         }
 119
 120         /* whole operation must be atomic */
 121         spin_lock_irqsave(&lpcdev->cycle_lock, flags);
 122
 123         writel_relaxed(opcnt, lpcdev->membase + LPC_REG_OP_LEN);
 124         writel_relaxed(cmd_word, lpcdev->membase + LPC_REG_CMD);
 125         writel_relaxed(addr, lpcdev->membase + LPC_REG_ADDR);
 126
 127         writel(LPC_REG_STARTUP_SIGNAL_START,
 128                lpcdev->membase + LPC_REG_STARTUP_SIGNAL);
 129
 130         /* whether the operation is finished */
 131         ret = wait_lpc_idle(lpcdev->membase, waitcnt);
 132         if (ret) {
 133                 spin_unlock_irqrestore(&lpcdev->cycle_lock, flags);
 134                 return ret;
 135         }
 136
 137         readsb(lpcdev->membase + LPC_REG_RDATA, buf, opcnt);
 138
 139         spin_unlock_irqrestore(&lpcdev->cycle_lock, flags);
 140
 141         return 0;
 142 }
 143
 144 /*
 145  * hisi_lpc_target_out - trigger a series of LPC cycles for write operation
 146  * @lpcdev: pointer to hisi lpc device
 147  * @para: some parameters used to control the lpc I/O operations
 148  * @addr: the lpc I/O target port address
 149  * @buf: where the data to be written is stored
 150  * @opcnt: how many I/O operations required, i.e. data width
 151  *
 152  * Returns 0 on success, non-zero on fail.
 153  */
 154 static int hisi_lpc_target_out(struct hisi_lpc_dev *lpcdev,
 155                                struct lpc_cycle_para *para, unsigned long addr,
 156                                const unsigned char *buf, unsigned long opcnt)
 157 {
 158         unsigned int waitcnt;
 159         unsigned long flags;
 160         u32 cmd_word;
 161         int ret;
 162
 163         if (!buf || !opcnt || !para || !lpcdev)
 164                 return -EINVAL;
 165
 166         /* default is increasing address */
 167         cmd_word = LPC_REG_CMD_OP; /* IO mode, write */
 168         waitcnt = LPC_PEROP_WAITCNT;
 169         if (!(para->opflags & FG_INCRADDR_LPC)) {
 170                 cmd_word |= LPC_REG_CMD_SAMEADDR;
 171                 waitcnt = LPC_MAX_WAITCNT;
 172         }
 173
 174         spin_lock_irqsave(&lpcdev->cycle_lock, flags);
 175
 176         writel_relaxed(opcnt, lpcdev->membase + LPC_REG_OP_LEN);
 177         writel_relaxed(cmd_word, lpcdev->membase + LPC_REG_CMD);
 178         writel_relaxed(addr, lpcdev->membase + LPC_REG_ADDR);
 179
 180         writesb(lpcdev->membase + LPC_REG_WDATA, buf, opcnt);
 181
 182         writel(LPC_REG_STARTUP_SIGNAL_START,
 183                lpcdev->membase + LPC_REG_STARTUP_SIGNAL);
 184
 185         /* whether the operation is finished */
 186         ret = wait_lpc_idle(lpcdev->membase, waitcnt);
 187
 188         spin_unlock_irqrestore(&lpcdev->cycle_lock, flags);
 189
 190         return ret;
 191 }
 192
 193 static unsigned long hisi_lpc_pio_to_addr(struct hisi_lpc_dev *lpcdev,
 194                                           unsigned long pio)
 195 {
 196         return pio - lpcdev->io_host->io_start + lpcdev->io_host->hw_start;
 197 }
 198
 199 /*
 200  * hisi_lpc_comm_in - input the data in a single operation
 201  * @hostdata: pointer to the device information relevant to LPC controller
 202  * @pio: the target I/O port address
 203  * @dwidth: the data length required to read from the target I/O port
 204  *
 205  * When success, data is returned. Otherwise, ~0 is returned.
 206  */
 207 static u32 hisi_lpc_comm_in(void *hostdata, unsigned long pio, size_t dwidth)
 208 {
 209         struct hisi_lpc_dev *lpcdev = hostdata;
 210         struct lpc_cycle_para iopara;
 211         unsigned long addr;
 212         __le32 rd_data = 0;
 213         int ret;
 214
 215         if (!lpcdev || !dwidth || dwidth > LPC_MAX_DWIDTH)
 216                 return ~0;
 217
 218         addr = hisi_lpc_pio_to_addr(lpcdev, pio);
 219
 220         iopara.opflags = FG_INCRADDR_LPC;
 221         iopara.csize = dwidth;
 222
 223         ret = hisi_lpc_target_in(lpcdev, &iopara, addr,
 224                                  (unsigned char *)&rd_data, dwidth);
 225         if (ret)
 226                 return ~0;
 227
 228         return le32_to_cpu(rd_data);
 229 }
 230
 231 /*
 232  * hisi_lpc_comm_out - output the data in a single operation
 233  * @hostdata: pointer to the device information relevant to LPC controller
 234  * @pio: the target I/O port address
 235  * @val: a value to be output from caller, maximum is four bytes
 236  * @dwidth: the data width required writing to the target I/O port
 237  *
 238  * This function corresponds to out(b,w,l) only.
 239  */
 240 static void hisi_lpc_comm_out(void *hostdata, unsigned long pio,
 241                               u32 val, size_t dwidth)
 242 {
 243         struct hisi_lpc_dev *lpcdev = hostdata;
 244         struct lpc_cycle_para iopara;
 245         const unsigned char *buf;
 246         unsigned long addr;
 247         __le32 _val = cpu_to_le32(val);
 248
 249         if (!lpcdev || !dwidth || dwidth > LPC_MAX_DWIDTH)
 250                 return;
 251
 252         buf = (const unsigned char *)&_val;
 253         addr = hisi_lpc_pio_to_addr(lpcdev, pio);
 254
 255         iopara.opflags = FG_INCRADDR_LPC;
 256         iopara.csize = dwidth;
 257
 258         hisi_lpc_target_out(lpcdev, &iopara, addr, buf, dwidth);
 259 }
 260
 261 /*
 262  * hisi_lpc_comm_ins - input the data in the buffer in multiple operations
 263  * @hostdata: pointer to the device information relevant to LPC controller
 264  * @pio: the target I/O port address
 265  * @buffer: a buffer where read/input data bytes are stored
 266  * @dwidth: the data width required writing to the target I/O port
 267  * @count: how many data units whose length is dwidth will be read
 268  *
 269  * When success, the data read back is stored in buffer pointed by buffer.
 270  * Returns 0 on success, -errno otherwise.
 271  */
 272 static u32 hisi_lpc_comm_ins(void *hostdata, unsigned long pio, void *buffer,
 273                              size_t dwidth, unsigned int count)
 274 {
 275         struct hisi_lpc_dev *lpcdev = hostdata;
 276         unsigned char *buf = buffer;
 277         struct lpc_cycle_para iopara;
 278         unsigned long addr;
 279
 280         if (!lpcdev || !buf || !count || !dwidth || dwidth > LPC_MAX_DWIDTH)
 281                 return -EINVAL;
 282
 283         iopara.opflags = 0;
 284         if (dwidth > 1)
 285                 iopara.opflags |= FG_INCRADDR_LPC;
 286         iopara.csize = dwidth;
 287
 288         addr = hisi_lpc_pio_to_addr(lpcdev, pio);
 289
 290         do {
 291                 int ret;
 292
 293                 ret = hisi_lpc_target_in(lpcdev, &iopara, addr, buf, dwidth);
 294                 if (ret)
 295                         return ret;
 296                 buf += dwidth;
 297         } while (--count);
 298
 299         return 0;
 300 }
 301
 302 /*
 303  * hisi_lpc_comm_outs - output the data in the buffer in multiple operations
 304  * @hostdata: pointer to the device information relevant to LPC controller
 305  * @pio: the target I/O port address
 306  * @buffer: a buffer where write/output data bytes are stored
 307  * @dwidth: the data width required writing to the target I/O port
 308  * @count: how many data units whose length is dwidth will be written
 309  */
 310 static void hisi_lpc_comm_outs(void *hostdata, unsigned long pio,
 311                                const void *buffer, size_t dwidth,
 312                                unsigned int count)
 313 {
 314         struct hisi_lpc_dev *lpcdev = hostdata;
 315         struct lpc_cycle_para iopara;
 316         const unsigned char *buf = buffer;
 317         unsigned long addr;
 318
 319         if (!lpcdev || !buf || !count || !dwidth || dwidth > LPC_MAX_DWIDTH)
 320                 return;
 321
 322         iopara.opflags = 0;
 323         if (dwidth > 1)
 324                 iopara.opflags |= FG_INCRADDR_LPC;
 325         iopara.csize = dwidth;
 326
 327         addr = hisi_lpc_pio_to_addr(lpcdev, pio);
 328         do {
 329                 if (hisi_lpc_target_out(lpcdev, &iopara, addr, buf, dwidth))
 330                         break;
 331                 buf += dwidth;
 332         } while (--count);
 333 }
 334
 335 static const struct logic_pio_host_ops hisi_lpc_ops = {
 336         .in = hisi_lpc_comm_in,
 337         .out = hisi_lpc_comm_out,
 338         .ins = hisi_lpc_comm_ins,
 339         .outs = hisi_lpc_comm_outs,
 340 };
 341
 342 #ifdef CONFIG_ACPI
 343 static int hisi_lpc_acpi_xlat_io_res(struct acpi_device *adev,
 344                                      struct acpi_device *host,
 345                                      struct resource *res)
 346 {
 347         unsigned long sys_port;
 348         resource_size_t len = resource_size(res);
 349
 350         sys_port = logic_pio_trans_hwaddr(&host->fwnode, res->start, len);
 351         if (sys_port == ~0UL)
 352                 return -EFAULT;
 353
 354         res->start = sys_port;
 355         res->end = sys_port + len;
 356
 357         return 0;
 358 }
 359
 360 /*
 361  * hisi_lpc_acpi_set_io_res - set the resources for a child
 362  * @child: the device node to be updated the I/O resource
 363  * @hostdev: the device node associated with host controller
 364  * @res: double pointer to be set to the address of translated resources
 365  * @num_res: pointer to variable to hold the number of translated resources
 366  *
 367  * Returns 0 when successful, and a negative value for failure.
 368  *
 369  * For a given host controller, each child device will have an associated
 370  * host-relative address resource.  This function will return the translated
 371  * logical PIO addresses for each child devices resources.
 372  */
 373 static int hisi_lpc_acpi_set_io_res(struct device *child,
 374                                     struct device *hostdev,
 375                                     const struct resource **res, int *num_res)
 376 {
 377         struct acpi_device *adev;
 378         struct acpi_device *host;
 379         struct resource_entry *rentry;
 380         LIST_HEAD(resource_list);
 381         struct resource *resources;
 382         int count;
 383         int i;
 384
 385         if (!child || !hostdev)
 386                 return -EINVAL;
 387
 388         host = to_acpi_device(hostdev);
 389         adev = to_acpi_device(child);
 390
 391         if (!adev->status.present) {
 392                 dev_dbg(child, "device is not present\n");
 393                 return -EIO;
 394         }
 395
 396         if (acpi_device_enumerated(adev)) {
 397                 dev_dbg(child, "has been enumerated\n");
 398                 return -EIO;
 399         }
 400
 401         /*
 402          * The following code segment to retrieve the resources is common to
 403          * acpi_create_platform_device(), so consider a common helper function
 404          * in future.
 405          */
 406         count = acpi_dev_get_resources(adev, &resource_list, NULL, NULL);
 407         if (count <= 0) {
 408                 dev_dbg(child, "failed to get resources\n");
 409                 return count ? count : -EIO;
 410         }
 411
 412         resources = devm_kcalloc(hostdev, count, sizeof(*resources),
 413                                  GFP_KERNEL);
 414         if (!resources) {
 415                 dev_warn(hostdev, "could not allocate memory for %d resources\n",
 416                          count);
 417                 acpi_dev_free_resource_list(&resource_list);
 418                 return -ENOMEM;
 419         }
 420         count = 0;
 421         list_for_each_entry(rentry, &resource_list, node)
 422                 resources[count++] = *rentry->res;
 423
 424         acpi_dev_free_resource_list(&resource_list);
 425
 426         /* translate the I/O resources */
 427         for (i = 0; i < count; i++) {
 428                 int ret;
 429
 430                 if (!(resources[i].flags & IORESOURCE_IO))
 431                         continue;
 432                 ret = hisi_lpc_acpi_xlat_io_res(adev, host, &resources[i]);
 433                 if (ret) {
 434                         dev_err(child, "translate IO range %pR failed (%d)\n",
 435                                 &resources[i], ret);
 436                         return ret;
 437                 }
 438         }
 439         *res = resources;
 440         *num_res = count;
 441
 442         return 0;
 443 }
 444
 445 static int hisi_lpc_acpi_remove_subdev(struct device *dev, void *unused)
 446 {
 447         platform_device_unregister(to_platform_device(dev));
 448         return 0;
 449 }
 450
 451 struct hisi_lpc_acpi_cell {
 452         const char *hid;
 453         const char *name;
 454         void *pdata;
 455         size_t pdata_size;
 456 };
 457
 458 static void hisi_lpc_acpi_remove(struct device *hostdev)
 459 {
 460         struct acpi_device *adev = ACPI_COMPANION(hostdev);
 461         struct acpi_device *child;
 462
 463         device_for_each_child(hostdev, NULL, hisi_lpc_acpi_remove_subdev);
 464
 465         list_for_each_entry(child, &adev->children, node)
 466                 acpi_device_clear_enumerated(child);
 467 }
 468
 469 /*
 470  * hisi_lpc_acpi_probe - probe children for ACPI FW
 471  * @hostdev: LPC host device pointer
 472  *
 473  * Returns 0 when successful, and a negative value for failure.
 474  *
 475  * Create a platform device per child, fixing up the resources
 476  * from bus addresses to Logical PIO addresses.
 477  *
 478  */
 479 static int hisi_lpc_acpi_probe(struct device *hostdev)
 480 {
 481         struct acpi_device *adev = ACPI_COMPANION(hostdev);
 482         struct acpi_device *child;
 483         int ret;
 484
 485         /* Only consider the children of the host */
 486         list_for_each_entry(child, &adev->children, node) {
 487                 const char *hid = acpi_device_hid(child);
 488                 const struct hisi_lpc_acpi_cell *cell;
 489                 struct platform_device *pdev;
 490                 const struct resource *res;
 491                 bool found = false;
 492                 int num_res;
 493
 494                 ret = hisi_lpc_acpi_set_io_res(&child->dev, &adev->dev, &res,
 495                                                &num_res);
 496                 if (ret) {
 497                         dev_warn(hostdev, "set resource fail (%d)\n", ret);
 498                         goto fail;
 499                 }
 500
 501                 cell = (struct hisi_lpc_acpi_cell []){
 502                         /* ipmi */
 503                         {
 504                                 .hid = "IPI0001",
 505                                 .name = "hisi-lpc-ipmi",
 506                         },
 507                         /* 8250-compatible uart */
 508                         {
 509                                 .hid = "HISI1031",
 510                                 .name = "serial8250",
 511                                 .pdata = (struct plat_serial8250_port []) {
 512                                         {
 513                                                 .iobase = res->start,
 514                                                 .uartclk = 1843200,
 515                                                 .iotype = UPIO_PORT,
 516                                                 .flags = UPF_BOOT_AUTOCONF,
 517                                         },
 518                                         {}
 519                                 },
 520                                 .pdata_size = 2 *
 521                                         sizeof(struct plat_serial8250_port),
 522                         },
 523                         {}
 524                 };
 525
 526                 for (; cell && cell->name; cell++) {
 527                         if (!strcmp(cell->hid, hid)) {
 528                                 found = true;
 529                                 break;
 530                         }
 531                 }
 532
 533                 if (!found) {
 534                         dev_warn(hostdev,
 535                                  "could not find cell for child device (%s), discarding\n",
 536                                  hid);
 537                         continue;
 538                 }
 539
 540                 pdev = platform_device_alloc(cell->name, PLATFORM_DEVID_AUTO);
 541                 if (!pdev) {
 542                         ret = -ENOMEM;
 543                         goto fail;
 544                 }
 545
 546                 pdev->dev.parent = hostdev;
 547                 ACPI_COMPANION_SET(&pdev->dev, child);
 548
 549                 ret = platform_device_add_resources(pdev, res, num_res);
 550                 if (ret)
 551                         goto fail;
 552
 553                 ret = platform_device_add_data(pdev, cell->pdata,
 554                                                cell->pdata_size);
 555                 if (ret)
 556                         goto fail;
 557
 558                 ret = platform_device_add(pdev);
 559                 if (ret)
 560                         goto fail;
 561
 562                 acpi_device_set_enumerated(child);
 563         }
 564
 565         return 0;
 566
 567 fail:
 568         hisi_lpc_acpi_remove(hostdev);
 569         return ret;
 570 }
 571
 572 static const struct acpi_device_id hisi_lpc_acpi_match[] = {
 573         {"HISI0191"},
 574         {}
 575 };
 576 #else
 577 static int hisi_lpc_acpi_probe(struct device *dev)
 578 {
 579         return -ENODEV;
 580 }
 581
 582 static void hisi_lpc_acpi_remove(struct device *hostdev)
 583 {
 584 }
 585 #endif // CONFIG_ACPI
 586
 587 /*
 588  * hisi_lpc_probe - the probe callback function for hisi lpc host,
 589  *                 will finish all the initialization.
 590  * @pdev: the platform device corresponding to hisi lpc host
 591  *
 592  * Returns 0 on success, non-zero on fail.
 593  */
 594 static int hisi_lpc_probe(struct platform_device *pdev)
 595 {
 596         struct device *dev = &pdev->dev;
 597         struct acpi_device *acpi_device = ACPI_COMPANION(dev);
 598         struct logic_pio_hwaddr *range;
 599         struct hisi_lpc_dev *lpcdev;
 600         resource_size_t io_end;
 601         struct resource *res;
 602         int ret;
 603
 604         lpcdev = devm_kzalloc(dev, sizeof(*lpcdev), GFP_KERNEL);
 605         if (!lpcdev)
 606                 return -ENOMEM;
 607
 608         spin_lock_init(&lpcdev->cycle_lock);
 609
 610         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 611         lpcdev->membase = devm_ioremap_resource(dev, res);
 612         if (IS_ERR(lpcdev->membase))
 613                 return PTR_ERR(lpcdev->membase);
 614
 615         range = devm_kzalloc(dev, sizeof(*range), GFP_KERNEL);
 616         if (!range)
 617                 return -ENOMEM;
 618
 619         range->fwnode = dev->fwnode;
 620         range->flags = LOGIC_PIO_INDIRECT;
 621         range->size = PIO_INDIRECT_SIZE;
 622         range->hostdata = lpcdev;
 623         range->ops = &hisi_lpc_ops;
 624         lpcdev->io_host = range;
 625
 626         ret = logic_pio_register_range(range);
 627         if (ret) {
 628                 dev_err(dev, "register IO range failed (%d)!\n", ret);
 629                 return ret;
 630         }
 631
 632         /* register the LPC host PIO resources */
 633         if (acpi_device)
 634                 ret = hisi_lpc_acpi_probe(dev);
 635         else
 636                 ret = of_platform_populate(dev->of_node, NULL, NULL, dev);
 637         if (ret) {
 638                 logic_pio_unregister_range(range);
 639                 return ret;
 640         }
 641
 642         dev_set_drvdata(dev, lpcdev);
 643
 644         io_end = lpcdev->io_host->io_start + lpcdev->io_host->size;
 645         dev_info(dev, "registered range [%pa - %pa]\n",
 646                  &lpcdev->io_host->io_start, &io_end);
 647
 648         return ret;
 649 }
 650
 651 static int hisi_lpc_remove(struct platform_device *pdev)
 652 {
 653         struct device *dev = &pdev->dev;
 654         struct acpi_device *acpi_device = ACPI_COMPANION(dev);
 655         struct hisi_lpc_dev *lpcdev = dev_get_drvdata(dev);
 656         struct logic_pio_hwaddr *range = lpcdev->io_host;
 657
 658         if (acpi_device)
 659                 hisi_lpc_acpi_remove(dev);
 660         else
 661                 of_platform_depopulate(dev);
 662
 663         logic_pio_unregister_range(range);
 664
 665         return 0;
 666 }
 667
 668 static const struct of_device_id hisi_lpc_of_match[] = {
 669         { .compatible = "hisilicon,hip06-lpc", },
 670         { .compatible = "hisilicon,hip07-lpc", },
 671         {}
 672 };
 673
 674 static struct platform_driver hisi_lpc_driver = {
 675         .driver = {
 676                 .name           = DRV_NAME,
 677                 .of_match_table = hisi_lpc_of_match,
 678                 .acpi_match_table = ACPI_PTR(hisi_lpc_acpi_match),
 679         },
 680         .probe = hisi_lpc_probe,
 681         .remove = hisi_lpc_remove,
 682 };
 683 builtin_platform_driver(hisi_lpc_driver);