[mirror_ubuntu-jammy-kernel.git] / drivers / bus / hisi_lpc.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright (C) 2017 Hisilicon Limited, All Rights Reserved.
 * Author: Zhichang Yuan <yuanzhichang@hisilicon.com>
 * Author: Zou Rongrong <zourongrong@huawei.com>
 * Author: John Garry <john.garry@huawei.com>
 */

#include <linux/acpi.h>
#include <linux/console.h>
#include <linux/delay.h>
#include <linux/io.h>
#include <linux/logic_pio.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_platform.h>
#include <linux/pci.h>
#include <linux/serial_8250.h>
#include <linux/slab.h>

#define DRV_NAME "hisi-lpc"

/*
 * Setting this bit means each IO operation will target a different port
 * address; 0 means repeated IO operations will use the same port,
 * such as BT.
 */
#define FG_INCRADDR_LPC		0x02

struct lpc_cycle_para {
	unsigned int opflags;
	unsigned int csize; /* data length of each operation */
};

struct hisi_lpc_dev {
	spinlock_t cycle_lock;
	void __iomem  *membase;
	struct logic_pio_hwaddr *io_host;
};

/* The max IO cycle counts supported is four per operation at maximum */
#define LPC_MAX_DWIDTH	4

#define LPC_REG_STARTUP_SIGNAL		0x00
#define LPC_REG_STARTUP_SIGNAL_START	BIT(0)
#define LPC_REG_OP_STATUS		0x04
#define LPC_REG_OP_STATUS_IDLE		BIT(0)
#define LPC_REG_OP_STATUS_FINISHED	BIT(1)
#define LPC_REG_OP_LEN			0x10 /* LPC cycles count per start */
#define LPC_REG_CMD			0x14
#define LPC_REG_CMD_OP			BIT(0) /* 0: read, 1: write */
#define LPC_REG_CMD_SAMEADDR		BIT(3)
#define LPC_REG_ADDR			0x20 /* target address */
#define LPC_REG_WDATA			0x24 /* write FIFO */
#define LPC_REG_RDATA			0x28 /* read FIFO */

/* The minimal nanosecond interval for each query on LPC cycle status */
#define LPC_NSEC_PERWAIT	100

/*
 * The maximum waiting time is about 128us.  It is specific for stream I/O,
 * such as ins.
 *
 * The fastest IO cycle time is about 390ns, but the worst case will wait
 * for extra 256 lpc clocks, so (256 + 13) * 30ns = 8 us. The maximum burst
 * cycles is 16. So, the maximum waiting time is about 128us under worst
 * case.
 *
 * Choose 1300 as the maximum.
 */
#define LPC_MAX_WAITCNT		1300

/* About 10us. This is specific for single IO operations, such as inb */
#define LPC_PEROP_WAITCNT	100

static int wait_lpc_idle(void __iomem *mbase, unsigned int waitcnt)
{
	u32 status;

	do {
		status = readl(mbase + LPC_REG_OP_STATUS);
		if (status & LPC_REG_OP_STATUS_IDLE)
			return (status & LPC_REG_OP_STATUS_FINISHED) ? 0 : -EIO;
		ndelay(LPC_NSEC_PERWAIT);
	} while (--waitcnt);

	return -ETIME;
}

/*
 * hisi_lpc_target_in - trigger a series of LPC cycles for read operation
 * @lpcdev: pointer to hisi lpc device
 * @para: some parameters used to control the lpc I/O operations
 * @addr: the lpc I/O target port address
 * @buf: where the read back data is stored
 * @opcnt: how many I/O operations required, i.e. data width
 *
 * Returns 0 on success, non-zero on fail.
 */
static int hisi_lpc_target_in(struct hisi_lpc_dev *lpcdev,
			      struct lpc_cycle_para *para, unsigned long addr,
			      unsigned char *buf, unsigned long opcnt)
{
	unsigned int cmd_word;
	unsigned int waitcnt;
	unsigned long flags;
	int ret;

	if (!buf || !opcnt || !para || !para->csize || !lpcdev)
		return -EINVAL;

	cmd_word = 0; /* IO mode, Read */
	waitcnt = LPC_PEROP_WAITCNT;
	if (!(para->opflags & FG_INCRADDR_LPC)) {
		cmd_word |= LPC_REG_CMD_SAMEADDR;
		waitcnt = LPC_MAX_WAITCNT;
	}

	/* whole operation must be atomic */
	spin_lock_irqsave(&lpcdev->cycle_lock, flags);

	writel_relaxed(opcnt, lpcdev->membase + LPC_REG_OP_LEN);
	writel_relaxed(cmd_word, lpcdev->membase + LPC_REG_CMD);
	writel_relaxed(addr, lpcdev->membase + LPC_REG_ADDR);

	writel(LPC_REG_STARTUP_SIGNAL_START,
	       lpcdev->membase + LPC_REG_STARTUP_SIGNAL);

	/* whether the operation is finished */
	ret = wait_lpc_idle(lpcdev->membase, waitcnt);
	if (ret) {
		spin_unlock_irqrestore(&lpcdev->cycle_lock, flags);
		return ret;
	}

	readsb(lpcdev->membase + LPC_REG_RDATA, buf, opcnt);

	spin_unlock_irqrestore(&lpcdev->cycle_lock, flags);

	return 0;
}

/*
 * hisi_lpc_target_out - trigger a series of LPC cycles for write operation
 * @lpcdev: pointer to hisi lpc device
 * @para: some parameters used to control the lpc I/O operations
 * @addr: the lpc I/O target port address
 * @buf: where the data to be written is stored
 * @opcnt: how many I/O operations required, i.e. data width
 *
 * Returns 0 on success, non-zero on fail.
 */
static int hisi_lpc_target_out(struct hisi_lpc_dev *lpcdev,
			       struct lpc_cycle_para *para, unsigned long addr,
			       const unsigned char *buf, unsigned long opcnt)
{
	unsigned int waitcnt;
	unsigned long flags;
	u32 cmd_word;
	int ret;

	if (!buf || !opcnt || !para || !lpcdev)
		return -EINVAL;

	/* default is increasing address */
	cmd_word = LPC_REG_CMD_OP; /* IO mode, write */
	waitcnt = LPC_PEROP_WAITCNT;
	if (!(para->opflags & FG_INCRADDR_LPC)) {
		cmd_word |= LPC_REG_CMD_SAMEADDR;
		waitcnt = LPC_MAX_WAITCNT;
	}

	spin_lock_irqsave(&lpcdev->cycle_lock, flags);

	writel_relaxed(opcnt, lpcdev->membase + LPC_REG_OP_LEN);
	writel_relaxed(cmd_word, lpcdev->membase + LPC_REG_CMD);
	writel_relaxed(addr, lpcdev->membase + LPC_REG_ADDR);

	writesb(lpcdev->membase + LPC_REG_WDATA, buf, opcnt);

	writel(LPC_REG_STARTUP_SIGNAL_START,
	       lpcdev->membase + LPC_REG_STARTUP_SIGNAL);

	/* whether the operation is finished */
	ret = wait_lpc_idle(lpcdev->membase, waitcnt);

	spin_unlock_irqrestore(&lpcdev->cycle_lock, flags);

	return ret;
}

static unsigned long hisi_lpc_pio_to_addr(struct hisi_lpc_dev *lpcdev,
					  unsigned long pio)
{
	return pio - lpcdev->io_host->io_start + lpcdev->io_host->hw_start;
}

/*
 * hisi_lpc_comm_in - input the data in a single operation
 * @hostdata: pointer to the device information relevant to LPC controller
 * @pio: the target I/O port address
 * @dwidth: the data length required to read from the target I/O port
 *
 * When success, data is returned. Otherwise, ~0 is returned.
 */
static u32 hisi_lpc_comm_in(void *hostdata, unsigned long pio, size_t dwidth)
{
	struct hisi_lpc_dev *lpcdev = hostdata;
	struct lpc_cycle_para iopara;
	unsigned long addr;
	__le32 rd_data = 0;
	int ret;

	if (!lpcdev || !dwidth || dwidth > LPC_MAX_DWIDTH)
		return ~0;

	addr = hisi_lpc_pio_to_addr(lpcdev, pio);

	iopara.opflags = FG_INCRADDR_LPC;
	iopara.csize = dwidth;

	ret = hisi_lpc_target_in(lpcdev, &iopara, addr,
				 (unsigned char *)&rd_data, dwidth);
	if (ret)
		return ~0;

	return le32_to_cpu(rd_data);
}

/*
 * hisi_lpc_comm_out - output the data in a single operation
 * @hostdata: pointer to the device information relevant to LPC controller
 * @pio: the target I/O port address
 * @val: a value to be output from caller, maximum is four bytes
 * @dwidth: the data width required writing to the target I/O port
 *
 * This function corresponds to out(b,w,l) only.
 */
static void hisi_lpc_comm_out(void *hostdata, unsigned long pio,
			      u32 val, size_t dwidth)
{
	struct hisi_lpc_dev *lpcdev = hostdata;
	struct lpc_cycle_para iopara;
	const unsigned char *buf;
	unsigned long addr;
	__le32 _val = cpu_to_le32(val);

	if (!lpcdev || !dwidth || dwidth > LPC_MAX_DWIDTH)
		return;

	buf = (const unsigned char *)&_val;
	addr = hisi_lpc_pio_to_addr(lpcdev, pio);

	iopara.opflags = FG_INCRADDR_LPC;
	iopara.csize = dwidth;

	hisi_lpc_target_out(lpcdev, &iopara, addr, buf, dwidth);
}

/*
 * hisi_lpc_comm_ins - input the data in the buffer in multiple operations
 * @hostdata: pointer to the device information relevant to LPC controller
 * @pio: the target I/O port address
 * @buffer: a buffer where read/input data bytes are stored
 * @dwidth: the data width required writing to the target I/O port
 * @count: how many data units whose length is dwidth will be read
 *
 * When success, the data read back is stored in buffer pointed by buffer.
 * Returns 0 on success, -errno otherwise.
 */
static u32 hisi_lpc_comm_ins(void *hostdata, unsigned long pio, void *buffer,
			     size_t dwidth, unsigned int count)
{
	struct hisi_lpc_dev *lpcdev = hostdata;
	unsigned char *buf = buffer;
	struct lpc_cycle_para iopara;
	unsigned long addr;

	if (!lpcdev || !buf || !count || !dwidth || dwidth > LPC_MAX_DWIDTH)
		return -EINVAL;

	iopara.opflags = 0;
	if (dwidth > 1)
		iopara.opflags |= FG_INCRADDR_LPC;
	iopara.csize = dwidth;

	addr = hisi_lpc_pio_to_addr(lpcdev, pio);

	do {
		int ret;

		ret = hisi_lpc_target_in(lpcdev, &iopara, addr, buf, dwidth);
		if (ret)
			return ret;
		buf += dwidth;
	} while (--count);

	return 0;
}

/*
 * hisi_lpc_comm_outs - output the data in the buffer in multiple operations
 * @hostdata: pointer to the device information relevant to LPC controller
 * @pio: the target I/O port address
 * @buffer: a buffer where write/output data bytes are stored
 * @dwidth: the data width required writing to the target I/O port
 * @count: how many data units whose length is dwidth will be written
 */
static void hisi_lpc_comm_outs(void *hostdata, unsigned long pio,
			       const void *buffer, size_t dwidth,
			       unsigned int count)
{
	struct hisi_lpc_dev *lpcdev = hostdata;
	struct lpc_cycle_para iopara;
	const unsigned char *buf = buffer;
	unsigned long addr;

	if (!lpcdev || !buf || !count || !dwidth || dwidth > LPC_MAX_DWIDTH)
		return;

	iopara.opflags = 0;
	if (dwidth > 1)
		iopara.opflags |= FG_INCRADDR_LPC;
	iopara.csize = dwidth;

	addr = hisi_lpc_pio_to_addr(lpcdev, pio);
	do {
		if (hisi_lpc_target_out(lpcdev, &iopara, addr, buf, dwidth))
			break;
		buf += dwidth;
	} while (--count);
}

static const struct logic_pio_host_ops hisi_lpc_ops = {
	.in = hisi_lpc_comm_in,
	.out = hisi_lpc_comm_out,
	.ins = hisi_lpc_comm_ins,
	.outs = hisi_lpc_comm_outs,
};

#ifdef CONFIG_ACPI
static int hisi_lpc_acpi_xlat_io_res(struct acpi_device *adev,
				     struct acpi_device *host,
				     struct resource *res)
{
	unsigned long sys_port;
	resource_size_t len = resource_size(res);

	sys_port = logic_pio_trans_hwaddr(&host->fwnode, res->start, len);
	if (sys_port == ~0UL)
		return -EFAULT;

	res->start = sys_port;
	res->end = sys_port + len;

	return 0;
}

/*
 * Released firmware describes the IO port max address as 0x3fff, which is
 * the max host bus address. Fixup to a proper range. This will probably
 * never be fixed in firmware.
 */
static void hisi_lpc_acpi_fixup_child_resource(struct device *hostdev,
					       struct resource *r)
{
	if (r->end != 0x3fff)
		return;

	if (r->start == 0xe4)
		r->end = 0xe4 + 0x04 - 1;
	else if (r->start == 0x2f8)
		r->end = 0x2f8 + 0x08 - 1;
	else
		dev_warn(hostdev, "unrecognised resource %pR to fixup, ignoring\n",
			 r);
}

/*
 * hisi_lpc_acpi_set_io_res - set the resources for a child
 * @child: the device node to be updated the I/O resource
 * @hostdev: the device node associated with host controller
 * @res: double pointer to be set to the address of translated resources
 * @num_res: pointer to variable to hold the number of translated resources
 *
 * Returns 0 when successful, and a negative value for failure.
 *
 * For a given host controller, each child device will have an associated
 * host-relative address resource.  This function will return the translated
 * logical PIO addresses for each child devices resources.
 */
static int hisi_lpc_acpi_set_io_res(struct device *child,
				    struct device *hostdev,
				    const struct resource **res, int *num_res)
{
	struct acpi_device *adev;
	struct acpi_device *host;
	struct resource_entry *rentry;
	LIST_HEAD(resource_list);
	struct resource *resources;
	int count;
	int i;

	if (!child || !hostdev)
		return -EINVAL;

	host = to_acpi_device(hostdev);
	adev = to_acpi_device(child);

	if (!adev->status.present) {
		dev_dbg(child, "device is not present\n");
		return -EIO;
	}

	if (acpi_device_enumerated(adev)) {
		dev_dbg(child, "has been enumerated\n");
		return -EIO;
	}

	/*
	 * The following code segment to retrieve the resources is common to
	 * acpi_create_platform_device(), so consider a common helper function
	 * in future.
	 */
	count = acpi_dev_get_resources(adev, &resource_list, NULL, NULL);
	if (count <= 0) {
		dev_dbg(child, "failed to get resources\n");
		return count ? count : -EIO;
	}

	resources = devm_kcalloc(hostdev, count, sizeof(*resources),
				 GFP_KERNEL);
	if (!resources) {
		dev_warn(hostdev, "could not allocate memory for %d resources\n",
			 count);
		acpi_dev_free_resource_list(&resource_list);
		return -ENOMEM;
	}
	count = 0;
	list_for_each_entry(rentry, &resource_list, node) {
		resources[count] = *rentry->res;
		hisi_lpc_acpi_fixup_child_resource(hostdev, &resources[count]);
		count++;
	}

	acpi_dev_free_resource_list(&resource_list);

	/* translate the I/O resources */
	for (i = 0; i < count; i++) {
		int ret;

		if (!(resources[i].flags & IORESOURCE_IO))
			continue;
		ret = hisi_lpc_acpi_xlat_io_res(adev, host, &resources[i]);
		if (ret) {
			dev_err(child, "translate IO range %pR failed (%d)\n",
				&resources[i], ret);
			return ret;
		}
	}
	*res = resources;
	*num_res = count;

	return 0;
}

static int hisi_lpc_acpi_remove_subdev(struct device *dev, void *unused)
{
	platform_device_unregister(to_platform_device(dev));
	return 0;
}

struct hisi_lpc_acpi_cell {
	const char *hid;
	const char *name;
	void *pdata;
	size_t pdata_size;
};

static void hisi_lpc_acpi_remove(struct device *hostdev)
{
	struct acpi_device *adev = ACPI_COMPANION(hostdev);
	struct acpi_device *child;

	device_for_each_child(hostdev, NULL, hisi_lpc_acpi_remove_subdev);

	list_for_each_entry(child, &adev->children, node)
		acpi_device_clear_enumerated(child);
}

/*
 * hisi_lpc_acpi_probe - probe children for ACPI FW
 * @hostdev: LPC host device pointer
 *
 * Returns 0 when successful, and a negative value for failure.
 *
 * Create a platform device per child, fixing up the resources
 * from bus addresses to Logical PIO addresses.
 *
 */
static int hisi_lpc_acpi_probe(struct device *hostdev)
{
	struct acpi_device *adev = ACPI_COMPANION(hostdev);
	struct acpi_device *child;
	int ret;

	/* Only consider the children of the host */
	list_for_each_entry(child, &adev->children, node) {
		const char *hid = acpi_device_hid(child);
		const struct hisi_lpc_acpi_cell *cell;
		struct platform_device *pdev;
		const struct resource *res;
		bool found = false;
		int num_res;

		ret = hisi_lpc_acpi_set_io_res(&child->dev, &adev->dev, &res,
					       &num_res);
		if (ret) {
			dev_warn(hostdev, "set resource fail (%d)\n", ret);
			goto fail;
		}

		cell = (struct hisi_lpc_acpi_cell []){
			/* ipmi */
			{
				.hid = "IPI0001",
				.name = "hisi-lpc-ipmi",
			},
			/* 8250-compatible uart */
			{
				.hid = "HISI1031",
				.name = "serial8250",
				.pdata = (struct plat_serial8250_port []) {
					{
						.iobase = res->start,
						.uartclk = 1843200,
						.iotype = UPIO_PORT,
						.flags = UPF_BOOT_AUTOCONF,
					},
					{}
				},
				.pdata_size = 2 *
					sizeof(struct plat_serial8250_port),
			},
			{}
		};

		for (; cell && cell->name; cell++) {
			if (!strcmp(cell->hid, hid)) {
				found = true;
				break;
			}
		}

		if (!found) {
			dev_warn(hostdev,
				 "could not find cell for child device (%s), discarding\n",
				 hid);
			continue;
		}

		pdev = platform_device_alloc(cell->name, PLATFORM_DEVID_AUTO);
		if (!pdev) {
			ret = -ENOMEM;
			goto fail;
		}

		pdev->dev.parent = hostdev;
		ACPI_COMPANION_SET(&pdev->dev, child);

		ret = platform_device_add_resources(pdev, res, num_res);
		if (ret)
			goto fail;

		ret = platform_device_add_data(pdev, cell->pdata,
					       cell->pdata_size);
		if (ret)
			goto fail;

		ret = platform_device_add(pdev);
		if (ret)
			goto fail;

		acpi_device_set_enumerated(child);
	}

	return 0;

fail:
	hisi_lpc_acpi_remove(hostdev);
	return ret;
}

static const struct acpi_device_id hisi_lpc_acpi_match[] = {
	{"HISI0191"},
	{}
};
#else
static int hisi_lpc_acpi_probe(struct device *dev)
{
	return -ENODEV;
}

static void hisi_lpc_acpi_remove(struct device *hostdev)
{
}
#endif // CONFIG_ACPI

/*
 * hisi_lpc_probe - the probe callback function for hisi lpc host,
 *		   will finish all the initialization.
 * @pdev: the platform device corresponding to hisi lpc host
 *
 * Returns 0 on success, non-zero on fail.
 */
static int hisi_lpc_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct acpi_device *acpi_device = ACPI_COMPANION(dev);
	struct logic_pio_hwaddr *range;
	struct hisi_lpc_dev *lpcdev;
	resource_size_t io_end;
	struct resource *res;
	int ret;

	lpcdev = devm_kzalloc(dev, sizeof(*lpcdev), GFP_KERNEL);
	if (!lpcdev)
		return -ENOMEM;

	spin_lock_init(&lpcdev->cycle_lock);

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	lpcdev->membase = devm_ioremap_resource(dev, res);
	if (IS_ERR(lpcdev->membase))
		return PTR_ERR(lpcdev->membase);

	range = devm_kzalloc(dev, sizeof(*range), GFP_KERNEL);
	if (!range)
		return -ENOMEM;

	range->fwnode = dev->fwnode;
	range->flags = LOGIC_PIO_INDIRECT;
	range->size = PIO_INDIRECT_SIZE;
	range->hostdata = lpcdev;
	range->ops = &hisi_lpc_ops;
	lpcdev->io_host = range;

	ret = logic_pio_register_range(range);
	if (ret) {
		dev_err(dev, "register IO range failed (%d)!\n", ret);
		return ret;
	}

	/* register the LPC host PIO resources */
	if (acpi_device)
		ret = hisi_lpc_acpi_probe(dev);
	else
		ret = of_platform_populate(dev->of_node, NULL, NULL, dev);
	if (ret) {
		logic_pio_unregister_range(range);
		return ret;
	}

	dev_set_drvdata(dev, lpcdev);

	io_end = lpcdev->io_host->io_start + lpcdev->io_host->size;
	dev_info(dev, "registered range [%pa - %pa]\n",
		 &lpcdev->io_host->io_start, &io_end);

	return ret;
}

static int hisi_lpc_remove(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct acpi_device *acpi_device = ACPI_COMPANION(dev);
	struct hisi_lpc_dev *lpcdev = dev_get_drvdata(dev);
	struct logic_pio_hwaddr *range = lpcdev->io_host;

	if (acpi_device)
		hisi_lpc_acpi_remove(dev);
	else
		of_platform_depopulate(dev);

	logic_pio_unregister_range(range);

	return 0;
}

static const struct of_device_id hisi_lpc_of_match[] = {
	{ .compatible = "hisilicon,hip06-lpc", },
	{ .compatible = "hisilicon,hip07-lpc", },
	{}
};

static struct platform_driver hisi_lpc_driver = {
	.driver = {
		.name           = DRV_NAME,
		.of_match_table = hisi_lpc_of_match,
		.acpi_match_table = ACPI_PTR(hisi_lpc_acpi_match),
	},
	.probe = hisi_lpc_probe,
	.remove = hisi_lpc_remove,
};
builtin_platform_driver(hisi_lpc_driver);
Commit	Line	Data
adf38bb0 ZY	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>
adf3457b	19	#include <linux/serial_8250.h>
adf38bb0 ZY	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
663accf1	77	static int wait_lpc_idle(void __iomem *mbase, unsigned int waitcnt)
adf38bb0 ZY	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;
663accf1	212	__le32 rd_data = 0;
adf38bb0 ZY	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;
663accf1	247	__le32 _val = cpu_to_le32(val);
adf38bb0 ZY	248
	249	if (!lpcdev \|\| !dwidth \|\| dwidth > LPC_MAX_DWIDTH)
	250	return;
	251
663accf1	252	buf = (const unsigned char *)&_val;
adf38bb0 ZY	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
e0aa1563	342	#ifdef CONFIG_ACPI
e0aa1563 JG	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
a6dd255b JG	360	/*
	361	* Released firmware describes the IO port max address as 0x3fff, which is
	362	* the max host bus address. Fixup to a proper range. This will probably
	363	* never be fixed in firmware.
	364	*/
	365	static void hisi_lpc_acpi_fixup_child_resource(struct device *hostdev,
	366	struct resource *r)
	367	{
	368	if (r->end != 0x3fff)
	369	return;
	370
	371	if (r->start == 0xe4)
	372	r->end = 0xe4 + 0x04 - 1;
	373	else if (r->start == 0x2f8)
	374	r->end = 0x2f8 + 0x08 - 1;
	375	else
	376	dev_warn(hostdev, "unrecognised resource %pR to fixup, ignoring\n",
	377	r);
	378	}
	379
e0aa1563	380	/*
332f632e	381	* hisi_lpc_acpi_set_io_res - set the resources for a child
e0aa1563 JG	382	* @child: the device node to be updated the I/O resource
	383	* @hostdev: the device node associated with host controller
	384	* @res: double pointer to be set to the address of translated resources
	385	* @num_res: pointer to variable to hold the number of translated resources
	386	*
	387	* Returns 0 when successful, and a negative value for failure.
	388	*
	389	* For a given host controller, each child device will have an associated
	390	* host-relative address resource. This function will return the translated
	391	* logical PIO addresses for each child devices resources.
	392	*/
	393	static int hisi_lpc_acpi_set_io_res(struct device *child,
	394	struct device *hostdev,
	395	const struct resource *res, int num_res)
	396	{
	397	struct acpi_device *adev;
	398	struct acpi_device *host;
	399	struct resource_entry *rentry;
	400	LIST_HEAD(resource_list);
	401	struct resource *resources;
	402	int count;
	403	int i;
	404
	405	if (!child \|\| !hostdev)
	406	return -EINVAL;
	407
	408	host = to_acpi_device(hostdev);
	409	adev = to_acpi_device(child);
	410
	411	if (!adev->status.present) {
	412	dev_dbg(child, "device is not present\n");
	413	return -EIO;
	414	}
	415
	416	if (acpi_device_enumerated(adev)) {
	417	dev_dbg(child, "has been enumerated\n");
	418	return -EIO;
	419	}
	420
	421	/*
	422	* The following code segment to retrieve the resources is common to
	423	* acpi_create_platform_device(), so consider a common helper function
	424	* in future.
	425	*/
	426	count = acpi_dev_get_resources(adev, &resource_list, NULL, NULL);
	427	if (count <= 0) {
	428	dev_dbg(child, "failed to get resources\n");
	429	return count ? count : -EIO;
	430	}
	431
	432	resources = devm_kcalloc(hostdev, count, sizeof(*resources),
	433	GFP_KERNEL);
	434	if (!resources) {
	435	dev_warn(hostdev, "could not allocate memory for %d resources\n",
	436	count);
	437	acpi_dev_free_resource_list(&resource_list);
	438	return -ENOMEM;
	439	}
	440	count = 0;
a6dd255b JG	441	list_for_each_entry(rentry, &resource_list, node) {
	442	resources[count] = *rentry->res;
	443	hisi_lpc_acpi_fixup_child_resource(hostdev, &resources[count]);
	444	count++;
	445	}
e0aa1563 JG	446
	447	acpi_dev_free_resource_list(&resource_list);
	448
	449	/* translate the I/O resources */
	450	for (i = 0; i < count; i++) {
	451	int ret;
	452
	453	if (!(resources[i].flags & IORESOURCE_IO))
	454	continue;
	455	ret = hisi_lpc_acpi_xlat_io_res(adev, host, &resources[i]);
	456	if (ret) {
	457	dev_err(child, "translate IO range %pR failed (%d)\n",
	458	&resources[i], ret);
	459	return ret;
	460	}
	461	}
	462	*res = resources;
	463	*num_res = count;
	464
	465	return 0;
	466	}
	467
99c0228d JG	468	static int hisi_lpc_acpi_remove_subdev(struct device dev, void unused)
	469	{
	470	platform_device_unregister(to_platform_device(dev));
	471	return 0;
	472	}
	473
	474	struct hisi_lpc_acpi_cell {
	475	const char *hid;
	476	const char *name;
	477	void *pdata;
	478	size_t pdata_size;
	479	};
	480
10e62b47 JG	481	static void hisi_lpc_acpi_remove(struct device *hostdev)
	482	{
	483	struct acpi_device *adev = ACPI_COMPANION(hostdev);
	484	struct acpi_device *child;
	485
	486	device_for_each_child(hostdev, NULL, hisi_lpc_acpi_remove_subdev);
	487
	488	list_for_each_entry(child, &adev->children, node)
	489	acpi_device_clear_enumerated(child);
	490	}
	491
e0aa1563 JG	492	/*
	493	* hisi_lpc_acpi_probe - probe children for ACPI FW
	494	* @hostdev: LPC host device pointer
	495	*
	496	* Returns 0 when successful, and a negative value for failure.
	497	*
99c0228d JG	498	* Create a platform device per child, fixing up the resources
	499	* from bus addresses to Logical PIO addresses.
	500	*
e0aa1563 JG	501	*/
	502	static int hisi_lpc_acpi_probe(struct device *hostdev)
	503	{
	504	struct acpi_device *adev = ACPI_COMPANION(hostdev);
e0aa1563	505	struct acpi_device *child;
332f632e	506	int ret;
e0aa1563	507
e0aa1563 JG	508	/* Only consider the children of the host */
e0aa1563 JG	509	list_for_each_entry(child, &adev->children, node) {
99c0228d JG	510	const char *hid = acpi_device_hid(child);
	511	const struct hisi_lpc_acpi_cell *cell;
	512	struct platform_device *pdev;
332f632e	513	const struct resource *res;
99c0228d	514	bool found = false;
332f632e JG	515	int num_res;
	516
	517	ret = hisi_lpc_acpi_set_io_res(&child->dev, &adev->dev, &res,
	518	&num_res);
e0aa1563	519	if (ret) {
332f632e	520	dev_warn(hostdev, "set resource fail (%d)\n", ret);
99c0228d JG	521	goto fail;
	522	}
	523
	524	cell = (struct hisi_lpc_acpi_cell []){
	525	/* ipmi */
	526	{
	527	.hid = "IPI0001",
	528	.name = "hisi-lpc-ipmi",
	529	},
adf3457b JG	530	/* 8250-compatible uart */
	531	{
	532	.hid = "HISI1031",
	533	.name = "serial8250",
	534	.pdata = (struct plat_serial8250_port []) {
	535	{
	536	.iobase = res->start,
	537	.uartclk = 1843200,
	538	.iotype = UPIO_PORT,
	539	.flags = UPF_BOOT_AUTOCONF,
	540	},
	541	{}
	542	},
	543	.pdata_size = 2 *
	544	sizeof(struct plat_serial8250_port),
	545	},
99c0228d JG	546	{}
	547	};
	548
	549	for (; cell && cell->name; cell++) {
	550	if (!strcmp(cell->hid, hid)) {
	551	found = true;
	552	break;
	553	}
e0aa1563	554	}
99c0228d JG	555
	556	if (!found) {
	557	dev_warn(hostdev,
705c0ee8	558	"could not find cell for child device (%s), discarding\n",
99c0228d	559	hid);
705c0ee8	560	continue;
99c0228d JG	561	}
	562
	563	pdev = platform_device_alloc(cell->name, PLATFORM_DEVID_AUTO);
	564	if (!pdev) {
	565	ret = -ENOMEM;
	566	goto fail;
	567	}
	568
	569	pdev->dev.parent = hostdev;
	570	ACPI_COMPANION_SET(&pdev->dev, child);
	571
	572	ret = platform_device_add_resources(pdev, res, num_res);
	573	if (ret)
	574	goto fail;
	575
	576	ret = platform_device_add_data(pdev, cell->pdata,
	577	cell->pdata_size);
	578	if (ret)
	579	goto fail;
	580
	581	ret = platform_device_add(pdev);
	582	if (ret)
	583	goto fail;
	584
	585	acpi_device_set_enumerated(child);
e0aa1563 JG	586	}
	587
	588	return 0;
99c0228d JG	589
99c0228d JG	590	fail:
10e62b47	591	hisi_lpc_acpi_remove(hostdev);
99c0228d	592	return ret;
e0aa1563 JG	593	}
	594
	595	static const struct acpi_device_id hisi_lpc_acpi_match[] = {
	596	{"HISI0191"},
	597	{}
	598	};
	599	#else
	600	static int hisi_lpc_acpi_probe(struct device *dev)
	601	{
	602	return -ENODEV;
	603	}
10e62b47 JG	604
	605	static void hisi_lpc_acpi_remove(struct device *hostdev)
	606	{
	607	}
e0aa1563 JG	608	#endif // CONFIG_ACPI
e0aa1563 JG	609
adf38bb0 ZY	610	/*
	611	* hisi_lpc_probe - the probe callback function for hisi lpc host,
	612	* will finish all the initialization.
	613	* @pdev: the platform device corresponding to hisi lpc host
	614	*
	615	* Returns 0 on success, non-zero on fail.
	616	*/
	617	static int hisi_lpc_probe(struct platform_device *pdev)
	618	{
	619	struct device *dev = &pdev->dev;
	620	struct acpi_device *acpi_device = ACPI_COMPANION(dev);
	621	struct logic_pio_hwaddr *range;
	622	struct hisi_lpc_dev *lpcdev;
	623	resource_size_t io_end;
	624	struct resource *res;
	625	int ret;
	626
	627	lpcdev = devm_kzalloc(dev, sizeof(*lpcdev), GFP_KERNEL);
	628	if (!lpcdev)
	629	return -ENOMEM;
	630
	631	spin_lock_init(&lpcdev->cycle_lock);
	632
	633	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	634	lpcdev->membase = devm_ioremap_resource(dev, res);
	635	if (IS_ERR(lpcdev->membase))
	636	return PTR_ERR(lpcdev->membase);
	637
	638	range = devm_kzalloc(dev, sizeof(*range), GFP_KERNEL);
	639	if (!range)
	640	return -ENOMEM;
	641
	642	range->fwnode = dev->fwnode;
	643	range->flags = LOGIC_PIO_INDIRECT;
	644	range->size = PIO_INDIRECT_SIZE;
1b15a563 JG	645	range->hostdata = lpcdev;
	646	range->ops = &hisi_lpc_ops;
	647	lpcdev->io_host = range;
adf38bb0 ZY	648
	649	ret = logic_pio_register_range(range);
	650	if (ret) {
	651	dev_err(dev, "register IO range failed (%d)!\n", ret);
	652	return ret;
	653	}
adf38bb0 ZY	654
adf38bb0 ZY	655	/* register the LPC host PIO resources */
e0aa1563 JG	656	if (acpi_device)
	657	ret = hisi_lpc_acpi_probe(dev);
	658	else
adf38bb0	659	ret = of_platform_populate(dev->of_node, NULL, NULL, dev);
1b15a563 JG	660	if (ret) {
1b15a563 JG	661	logic_pio_unregister_range(range);
e0aa1563	662	return ret;
1b15a563	663	}
adf38bb0	664
10e62b47 JG	665	dev_set_drvdata(dev, lpcdev);
10e62b47 JG	666
adf38bb0 ZY	667	io_end = lpcdev->io_host->io_start + lpcdev->io_host->size;
	668	dev_info(dev, "registered range [%pa - %pa]\n",
	669	&lpcdev->io_host->io_start, &io_end);
	670
	671	return ret;
	672	}
	673
10e62b47 JG	674	static int hisi_lpc_remove(struct platform_device *pdev)
	675	{
	676	struct device *dev = &pdev->dev;
	677	struct acpi_device *acpi_device = ACPI_COMPANION(dev);
	678	struct hisi_lpc_dev *lpcdev = dev_get_drvdata(dev);
	679	struct logic_pio_hwaddr *range = lpcdev->io_host;
	680
	681	if (acpi_device)
	682	hisi_lpc_acpi_remove(dev);
	683	else
	684	of_platform_depopulate(dev);
	685
	686	logic_pio_unregister_range(range);
	687
	688	return 0;
	689	}
	690
adf38bb0 ZY	691	static const struct of_device_id hisi_lpc_of_match[] = {
	692	{ .compatible = "hisilicon,hip06-lpc", },
	693	{ .compatible = "hisilicon,hip07-lpc", },
	694	{}
	695	};
	696
	697	static struct platform_driver hisi_lpc_driver = {
	698	.driver = {
	699	.name = DRV_NAME,
	700	.of_match_table = hisi_lpc_of_match,
e0aa1563	701	.acpi_match_table = ACPI_PTR(hisi_lpc_acpi_match),
adf38bb0 ZY	702	},
adf38bb0 ZY	703	.probe = hisi_lpc_probe,
10e62b47	704	.remove = hisi_lpc_remove,
adf38bb0 ZY	705	};
adf38bb0 ZY	706	builtin_platform_driver(hisi_lpc_driver);