[linux-2.6-block.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(unsigned char *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;
	u32 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;

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

	val = cpu_to_le32(val);

	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;
}

/*
 * 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;

	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;
};

/*
 * 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)\n",
				 hid);
			ret = -ENODEV;
			goto fail;
		}

		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:
	device_for_each_child(hostdev, NULL,
			      hisi_lpc_acpi_remove_subdev);
	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;
}
#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;

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

	/* 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)
		return ret;

	lpcdev->io_host->hostdata = lpcdev;
	lpcdev->io_host->ops = &hisi_lpc_ops;

	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 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,
};
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
	77	static int wait_lpc_idle(unsigned char *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	u32 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
248	if (!lpcdev \|\| !dwidth \|\| dwidth > LPC_MAX_DWIDTH)
249	return;
250
251	val = cpu_to_le32(val);
252
253	buf = (const unsigned char *)&val;
254	addr = hisi_lpc_pio_to_addr(lpcdev, pio);
255
256	iopara.opflags = FG_INCRADDR_LPC;
257	iopara.csize = dwidth;
258
259	hisi_lpc_target_out(lpcdev, &iopara, addr, buf, dwidth);
260	}
261
262	/*
263	* hisi_lpc_comm_ins - input the data in the buffer in multiple operations
264	* @hostdata: pointer to the device information relevant to LPC controller
265	* @pio: the target I/O port address
266	* @buffer: a buffer where read/input data bytes are stored
267	* @dwidth: the data width required writing to the target I/O port
268	* @count: how many data units whose length is dwidth will be read
269	*
270	* When success, the data read back is stored in buffer pointed by buffer.
271	* Returns 0 on success, -errno otherwise.
272	*/
273	static u32 hisi_lpc_comm_ins(void hostdata, unsigned long pio, void buffer,
274	size_t dwidth, unsigned int count)
275	{
276	struct hisi_lpc_dev *lpcdev = hostdata;
277	unsigned char *buf = buffer;
278	struct lpc_cycle_para iopara;
279	unsigned long addr;
280
281	if (!lpcdev \|\| !buf \|\| !count \|\| !dwidth \|\| dwidth > LPC_MAX_DWIDTH)
282	return -EINVAL;
283
284	iopara.opflags = 0;
285	if (dwidth > 1)
286	iopara.opflags \|= FG_INCRADDR_LPC;
287	iopara.csize = dwidth;
288
289	addr = hisi_lpc_pio_to_addr(lpcdev, pio);
290
291	do {
292	int ret;
293
294	ret = hisi_lpc_target_in(lpcdev, &iopara, addr, buf, dwidth);
295	if (ret)
296	return ret;
297	buf += dwidth;
298	} while (--count);
299
300	return 0;
301	}
302
303	/*
304	* hisi_lpc_comm_outs - output the data in the buffer in multiple operations
305	* @hostdata: pointer to the device information relevant to LPC controller
306	* @pio: the target I/O port address
307	* @buffer: a buffer where write/output data bytes are stored
308	* @dwidth: the data width required writing to the target I/O port
309	* @count: how many data units whose length is dwidth will be written
310	*/
311	static void hisi_lpc_comm_outs(void *hostdata, unsigned long pio,
312	const void *buffer, size_t dwidth,
313	unsigned int count)
314	{
315	struct hisi_lpc_dev *lpcdev = hostdata;
316	struct lpc_cycle_para iopara;
317	const unsigned char *buf = buffer;
318	unsigned long addr;
319
320	if (!lpcdev \|\| !buf \|\| !count \|\| !dwidth \|\| dwidth > LPC_MAX_DWIDTH)
321	return;
322
323	iopara.opflags = 0;
324	if (dwidth > 1)
325	iopara.opflags \|= FG_INCRADDR_LPC;
326	iopara.csize = dwidth;
327
328	addr = hisi_lpc_pio_to_addr(lpcdev, pio);
329	do {
330	if (hisi_lpc_target_out(lpcdev, &iopara, addr, buf, dwidth))
331	break;
332	buf += dwidth;
333	} while (--count);
334	}
335
336	static const struct logic_pio_host_ops hisi_lpc_ops = {
337	.in = hisi_lpc_comm_in,
338	.out = hisi_lpc_comm_out,
339	.ins = hisi_lpc_comm_ins,
340	.outs = hisi_lpc_comm_outs,
341	};
342
e0aa1563	343	#ifdef CONFIG_ACPI
e0aa1563 JG	344	static int hisi_lpc_acpi_xlat_io_res(struct acpi_device *adev,
	345	struct acpi_device *host,
	346	struct resource *res)
	347	{
	348	unsigned long sys_port;
	349	resource_size_t len = resource_size(res);
	350
	351	sys_port = logic_pio_trans_hwaddr(&host->fwnode, res->start, len);
	352	if (sys_port == ~0UL)
	353	return -EFAULT;
	354
	355	res->start = sys_port;
	356	res->end = sys_port + len;
	357
	358	return 0;
	359	}
	360
	361	/*
332f632e	362	* hisi_lpc_acpi_set_io_res - set the resources for a child
e0aa1563 JG	363	* @child: the device node to be updated the I/O resource
	364	* @hostdev: the device node associated with host controller
	365	* @res: double pointer to be set to the address of translated resources
	366	* @num_res: pointer to variable to hold the number of translated resources
	367	*
	368	* Returns 0 when successful, and a negative value for failure.
	369	*
	370	* For a given host controller, each child device will have an associated
	371	* host-relative address resource. This function will return the translated
	372	* logical PIO addresses for each child devices resources.
	373	*/
	374	static int hisi_lpc_acpi_set_io_res(struct device *child,
	375	struct device *hostdev,
	376	const struct resource *res, int num_res)
	377	{
	378	struct acpi_device *adev;
	379	struct acpi_device *host;
	380	struct resource_entry *rentry;
	381	LIST_HEAD(resource_list);
	382	struct resource *resources;
	383	int count;
	384	int i;
	385
	386	if (!child \|\| !hostdev)
	387	return -EINVAL;
	388
	389	host = to_acpi_device(hostdev);
	390	adev = to_acpi_device(child);
	391
	392	if (!adev->status.present) {
	393	dev_dbg(child, "device is not present\n");
	394	return -EIO;
	395	}
	396
	397	if (acpi_device_enumerated(adev)) {
	398	dev_dbg(child, "has been enumerated\n");
	399	return -EIO;
	400	}
	401
	402	/*
	403	* The following code segment to retrieve the resources is common to
	404	* acpi_create_platform_device(), so consider a common helper function
	405	* in future.
	406	*/
	407	count = acpi_dev_get_resources(adev, &resource_list, NULL, NULL);
	408	if (count <= 0) {
	409	dev_dbg(child, "failed to get resources\n");
	410	return count ? count : -EIO;
	411	}
	412
	413	resources = devm_kcalloc(hostdev, count, sizeof(*resources),
	414	GFP_KERNEL);
	415	if (!resources) {
	416	dev_warn(hostdev, "could not allocate memory for %d resources\n",
	417	count);
	418	acpi_dev_free_resource_list(&resource_list);
	419	return -ENOMEM;
	420	}
	421	count = 0;
	422	list_for_each_entry(rentry, &resource_list, node)
	423	resources[count++] = *rentry->res;
	424
	425	acpi_dev_free_resource_list(&resource_list);
	426
427	/* translate the I/O resources */
428	for (i = 0; i < count; i++) {
429	int ret;
430
431	if (!(resources[i].flags & IORESOURCE_IO))
432	continue;
433	ret = hisi_lpc_acpi_xlat_io_res(adev, host, &resources[i]);
434	if (ret) {
435	dev_err(child, "translate IO range %pR failed (%d)\n",
436	&resources[i], ret);
437	return ret;
438	}
439	}
440	*res = resources;
441	*num_res = count;
442
443	return 0;
444	}
445
99c0228d JG	446	static int hisi_lpc_acpi_remove_subdev(struct device dev, void unused)
	447	{
	448	platform_device_unregister(to_platform_device(dev));
	449	return 0;
	450	}
	451
	452	struct hisi_lpc_acpi_cell {
	453	const char *hid;
	454	const char *name;
	455	void *pdata;
	456	size_t pdata_size;
	457	};
	458
e0aa1563 JG	459	/*
	460	* hisi_lpc_acpi_probe - probe children for ACPI FW
	461	* @hostdev: LPC host device pointer
	462	*
	463	* Returns 0 when successful, and a negative value for failure.
	464	*
99c0228d JG	465	* Create a platform device per child, fixing up the resources
	466	* from bus addresses to Logical PIO addresses.
	467	*
e0aa1563 JG	468	*/
	469	static int hisi_lpc_acpi_probe(struct device *hostdev)
	470	{
	471	struct acpi_device *adev = ACPI_COMPANION(hostdev);
e0aa1563	472	struct acpi_device *child;
332f632e	473	int ret;
e0aa1563	474
e0aa1563 JG	475	/* Only consider the children of the host */
e0aa1563 JG	476	list_for_each_entry(child, &adev->children, node) {
99c0228d JG	477	const char *hid = acpi_device_hid(child);
	478	const struct hisi_lpc_acpi_cell *cell;
	479	struct platform_device *pdev;
332f632e	480	const struct resource *res;
99c0228d	481	bool found = false;
332f632e JG	482	int num_res;
	483
	484	ret = hisi_lpc_acpi_set_io_res(&child->dev, &adev->dev, &res,
	485	&num_res);
e0aa1563	486	if (ret) {
332f632e	487	dev_warn(hostdev, "set resource fail (%d)\n", ret);
99c0228d JG	488	goto fail;
	489	}
	490
	491	cell = (struct hisi_lpc_acpi_cell []){
	492	/* ipmi */
	493	{
	494	.hid = "IPI0001",
	495	.name = "hisi-lpc-ipmi",
	496	},
adf3457b JG	497	/* 8250-compatible uart */
	498	{
	499	.hid = "HISI1031",
	500	.name = "serial8250",
	501	.pdata = (struct plat_serial8250_port []) {
	502	{
	503	.iobase = res->start,
	504	.uartclk = 1843200,
	505	.iotype = UPIO_PORT,
	506	.flags = UPF_BOOT_AUTOCONF,
	507	},
	508	{}
	509	},
	510	.pdata_size = 2 *
	511	sizeof(struct plat_serial8250_port),
	512	},
99c0228d JG	513	{}
	514	};
	515
	516	for (; cell && cell->name; cell++) {
	517	if (!strcmp(cell->hid, hid)) {
	518	found = true;
	519	break;
	520	}
e0aa1563	521	}
99c0228d JG	522
	523	if (!found) {
	524	dev_warn(hostdev,
	525	"could not find cell for child device (%s)\n",
	526	hid);
	527	ret = -ENODEV;
	528	goto fail;
	529	}
	530
	531	pdev = platform_device_alloc(cell->name, PLATFORM_DEVID_AUTO);
	532	if (!pdev) {
	533	ret = -ENOMEM;
	534	goto fail;
	535	}
	536
	537	pdev->dev.parent = hostdev;
	538	ACPI_COMPANION_SET(&pdev->dev, child);
	539
	540	ret = platform_device_add_resources(pdev, res, num_res);
	541	if (ret)
	542	goto fail;
	543
	544	ret = platform_device_add_data(pdev, cell->pdata,
	545	cell->pdata_size);
	546	if (ret)
	547	goto fail;
	548
	549	ret = platform_device_add(pdev);
	550	if (ret)
	551	goto fail;
	552
	553	acpi_device_set_enumerated(child);
e0aa1563 JG	554	}
	555
	556	return 0;
99c0228d JG	557
	558	fail:
	559	device_for_each_child(hostdev, NULL,
	560	hisi_lpc_acpi_remove_subdev);
	561	return ret;
e0aa1563 JG	562	}
	563
	564	static const struct acpi_device_id hisi_lpc_acpi_match[] = {
	565	{"HISI0191"},
	566	{}
	567	};
	568	#else
	569	static int hisi_lpc_acpi_probe(struct device *dev)
	570	{
	571	return -ENODEV;
	572	}
	573	#endif // CONFIG_ACPI
	574
adf38bb0 ZY	575	/*
	576	* hisi_lpc_probe - the probe callback function for hisi lpc host,
	577	* will finish all the initialization.
	578	* @pdev: the platform device corresponding to hisi lpc host
	579	*
	580	* Returns 0 on success, non-zero on fail.
	581	*/
	582	static int hisi_lpc_probe(struct platform_device *pdev)
	583	{
	584	struct device *dev = &pdev->dev;
	585	struct acpi_device *acpi_device = ACPI_COMPANION(dev);
	586	struct logic_pio_hwaddr *range;
	587	struct hisi_lpc_dev *lpcdev;
	588	resource_size_t io_end;
	589	struct resource *res;
	590	int ret;
	591
	592	lpcdev = devm_kzalloc(dev, sizeof(*lpcdev), GFP_KERNEL);
	593	if (!lpcdev)
	594	return -ENOMEM;
	595
	596	spin_lock_init(&lpcdev->cycle_lock);
	597
	598	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	599	lpcdev->membase = devm_ioremap_resource(dev, res);
	600	if (IS_ERR(lpcdev->membase))
	601	return PTR_ERR(lpcdev->membase);
	602
	603	range = devm_kzalloc(dev, sizeof(*range), GFP_KERNEL);
	604	if (!range)
	605	return -ENOMEM;
	606
	607	range->fwnode = dev->fwnode;
	608	range->flags = LOGIC_PIO_INDIRECT;
	609	range->size = PIO_INDIRECT_SIZE;
	610
	611	ret = logic_pio_register_range(range);
	612	if (ret) {
	613	dev_err(dev, "register IO range failed (%d)!\n", ret);
	614	return ret;
	615	}
	616	lpcdev->io_host = range;
	617
	618	/* register the LPC host PIO resources */
e0aa1563 JG	619	if (acpi_device)
	620	ret = hisi_lpc_acpi_probe(dev);
	621	else
adf38bb0	622	ret = of_platform_populate(dev->of_node, NULL, NULL, dev);
e0aa1563 JG	623	if (ret)
e0aa1563 JG	624	return ret;
adf38bb0 ZY	625
	626	lpcdev->io_host->hostdata = lpcdev;
	627	lpcdev->io_host->ops = &hisi_lpc_ops;
	628
	629	io_end = lpcdev->io_host->io_start + lpcdev->io_host->size;
	630	dev_info(dev, "registered range [%pa - %pa]\n",
	631	&lpcdev->io_host->io_start, &io_end);
	632
	633	return ret;
	634	}
	635
	636	static const struct of_device_id hisi_lpc_of_match[] = {
	637	{ .compatible = "hisilicon,hip06-lpc", },
	638	{ .compatible = "hisilicon,hip07-lpc", },
	639	{}
	640	};
	641
	642	static struct platform_driver hisi_lpc_driver = {
	643	.driver = {
	644	.name = DRV_NAME,
	645	.of_match_table = hisi_lpc_of_match,
e0aa1563	646	.acpi_match_table = ACPI_PTR(hisi_lpc_acpi_match),
adf38bb0 ZY	647	},
	648	.probe = hisi_lpc_probe,
	649	};
	650	builtin_platform_driver(hisi_lpc_driver);