[mirror_ubuntu-focal-kernel.git] / drivers / mfd / htc-pasic3.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Core driver for HTC PASIC3 LED/DS1WM chip.
 *
 * Copyright (C) 2006 Philipp Zabel <philipp.zabel@gmail.com>
 */

#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h>

#include <linux/gpio.h>
#include <linux/io.h>
#include <linux/irq.h>
#include <linux/interrupt.h>
#include <linux/mfd/core.h>
#include <linux/mfd/ds1wm.h>
#include <linux/mfd/htc-pasic3.h>
#include <linux/slab.h>

struct pasic3_data {
	void __iomem *mapping;
	unsigned int bus_shift;
};

#define REG_ADDR  5
#define REG_DATA  6

#define READ_MODE 0x80

/*
 * write to a secondary register on the PASIC3
 */
void pasic3_write_register(struct device *dev, u32 reg, u8 val)
{
	struct pasic3_data *asic = dev_get_drvdata(dev);
	int bus_shift = asic->bus_shift;
	void __iomem *addr = asic->mapping + (REG_ADDR << bus_shift);
	void __iomem *data = asic->mapping + (REG_DATA << bus_shift);

	__raw_writeb(~READ_MODE & reg, addr);
	__raw_writeb(val, data);
}
EXPORT_SYMBOL(pasic3_write_register); /* for leds-pasic3 */

/*
 * read from a secondary register on the PASIC3
 */
u8 pasic3_read_register(struct device *dev, u32 reg)
{
	struct pasic3_data *asic = dev_get_drvdata(dev);
	int bus_shift = asic->bus_shift;
	void __iomem *addr = asic->mapping + (REG_ADDR << bus_shift);
	void __iomem *data = asic->mapping + (REG_DATA << bus_shift);

	__raw_writeb(READ_MODE | reg, addr);
	return __raw_readb(data);
}
EXPORT_SYMBOL(pasic3_read_register); /* for leds-pasic3 */

/*
 * LEDs
 */

static struct mfd_cell led_cell __initdata = {
	.name = "leds-pasic3",
};

/*
 * DS1WM
 */

static int ds1wm_enable(struct platform_device *pdev)
{
	struct device *dev = pdev->dev.parent;
	int c;

	c = pasic3_read_register(dev, 0x28);
	pasic3_write_register(dev, 0x28, c & 0x7f);

	dev_dbg(dev, "DS1WM OWM_EN low (active) %02x\n", c & 0x7f);
	return 0;
}

static int ds1wm_disable(struct platform_device *pdev)
{
	struct device *dev = pdev->dev.parent;
	int c;

	c = pasic3_read_register(dev, 0x28);
	pasic3_write_register(dev, 0x28, c | 0x80);

	dev_dbg(dev, "DS1WM OWM_EN high (inactive) %02x\n", c | 0x80);
	return 0;
}

static struct ds1wm_driver_data ds1wm_pdata = {
	.active_high = 0,
	.reset_recover_delay = 1,
};

static struct resource ds1wm_resources[] __initdata = {
	[0] = {
		.start  = 0,
		.flags  = IORESOURCE_MEM,
	},
	[1] = {
		.start  = 0,
		.end    = 0,
		.flags  = IORESOURCE_IRQ,
	},
};

static const struct mfd_cell ds1wm_cell __initconst = {
	.name          = "ds1wm",
	.enable        = ds1wm_enable,
	.disable       = ds1wm_disable,
	.platform_data = &ds1wm_pdata,
	.pdata_size    = sizeof(ds1wm_pdata),
	.num_resources = 2,
	.resources     = ds1wm_resources,
};

static int __init pasic3_probe(struct platform_device *pdev)
{
	struct pasic3_platform_data *pdata = dev_get_platdata(&pdev->dev);
	struct device *dev = &pdev->dev;
	struct pasic3_data *asic;
	struct resource *r;
	int ret;
	int irq = 0;

	r = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	if (r) {
		ds1wm_resources[1].flags = IORESOURCE_IRQ | (r->flags &
			(IORESOURCE_IRQ_HIGHEDGE | IORESOURCE_IRQ_LOWEDGE));
		irq = r->start;
	}

	r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!r)
		return -ENXIO;

	if (!request_mem_region(r->start, resource_size(r), "pasic3"))
		return -EBUSY;

	asic = devm_kzalloc(dev, sizeof(struct pasic3_data), GFP_KERNEL);
	if (!asic)
		return -ENOMEM;

	platform_set_drvdata(pdev, asic);

	asic->mapping = ioremap(r->start, resource_size(r));
	if (!asic->mapping) {
		dev_err(dev, "couldn't ioremap PASIC3\n");
		return -ENOMEM;
	}

	/* calculate bus shift from mem resource */
	asic->bus_shift = (resource_size(r) - 5) >> 3;

	if (pdata && pdata->clock_rate) {
		ds1wm_pdata.clock_rate = pdata->clock_rate;
		/* the first 5 PASIC3 registers control the DS1WM */
		ds1wm_resources[0].end = (5 << asic->bus_shift) - 1;
		ret = mfd_add_devices(&pdev->dev, pdev->id,
				      &ds1wm_cell, 1, r, irq, NULL);
		if (ret < 0)
			dev_warn(dev, "failed to register DS1WM\n");
	}

	if (pdata && pdata->led_pdata) {
		led_cell.platform_data = pdata->led_pdata;
		led_cell.pdata_size = sizeof(struct pasic3_leds_machinfo);
		ret = mfd_add_devices(&pdev->dev, pdev->id, &led_cell, 1, r,
				      0, NULL);
		if (ret < 0)
			dev_warn(dev, "failed to register LED device\n");
	}

	return 0;
}

static int pasic3_remove(struct platform_device *pdev)
{
	struct pasic3_data *asic = platform_get_drvdata(pdev);
	struct resource *r;

	mfd_remove_devices(&pdev->dev);

	iounmap(asic->mapping);
	r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	release_mem_region(r->start, resource_size(r));
	return 0;
}

MODULE_ALIAS("platform:pasic3");

static struct platform_driver pasic3_driver = {
	.driver		= {
		.name	= "pasic3",
	},
	.remove		= pasic3_remove,
};

module_platform_driver_probe(pasic3_driver, pasic3_probe);

MODULE_AUTHOR("Philipp Zabel <philipp.zabel@gmail.com>");
MODULE_DESCRIPTION("Core driver for HTC PASIC3");
MODULE_LICENSE("GPL");
Commit	Line	Data
b886d83c	1	// SPDX-License-Identifier: GPL-2.0-only
5dc3339a PZ	2	/*
	3	* Core driver for HTC PASIC3 LED/DS1WM chip.
	4	*
	5	* Copyright (C) 2006 Philipp Zabel <philipp.zabel@gmail.com>
5dc3339a PZ	6	*/
	7
	8	#include <linux/init.h>
	9	#include <linux/module.h>
	10	#include <linux/platform_device.h>
	11
5dc3339a PZ	12	#include <linux/gpio.h>
	13	#include <linux/io.h>
	14	#include <linux/irq.h>
	15	#include <linux/interrupt.h>
0254a8f4 PZ	16	#include <linux/mfd/core.h>
0254a8f4 PZ	17	#include <linux/mfd/ds1wm.h>
5dc3339a	18	#include <linux/mfd/htc-pasic3.h>
5a0e3ad6	19	#include <linux/slab.h>
5dc3339a	20
5dc3339a PZ	21	struct pasic3_data {
	22	void __iomem *mapping;
	23	unsigned int bus_shift;
5dc3339a PZ	24	};
	25
	26	#define REG_ADDR 5
	27	#define REG_DATA 6
5dc3339a PZ	28
	29	#define READ_MODE 0x80
	30
	31	/*
	32	* write to a secondary register on the PASIC3
	33	*/
	34	void pasic3_write_register(struct device *dev, u32 reg, u8 val)
	35	{
1902a9e6	36	struct pasic3_data *asic = dev_get_drvdata(dev);
5dc3339a PZ	37	int bus_shift = asic->bus_shift;
	38	void __iomem *addr = asic->mapping + (REG_ADDR << bus_shift);
	39	void __iomem *data = asic->mapping + (REG_DATA << bus_shift);
	40
	41	__raw_writeb(~READ_MODE & reg, addr);
	42	__raw_writeb(val, data);
	43	}
	44	EXPORT_SYMBOL(pasic3_write_register); /* for leds-pasic3 */
	45
	46	/*
	47	* read from a secondary register on the PASIC3
	48	*/
	49	u8 pasic3_read_register(struct device *dev, u32 reg)
	50	{
1902a9e6	51	struct pasic3_data *asic = dev_get_drvdata(dev);
5dc3339a PZ	52	int bus_shift = asic->bus_shift;
	53	void __iomem *addr = asic->mapping + (REG_ADDR << bus_shift);
	54	void __iomem *data = asic->mapping + (REG_DATA << bus_shift);
	55
	56	__raw_writeb(READ_MODE \| reg, addr);
	57	return __raw_readb(data);
	58	}
	59	EXPORT_SYMBOL(pasic3_read_register); /* for leds-pasic3 */
	60
	61	/*
	62	* LEDs
	63	*/
	64
0254a8f4 PZ	65	static struct mfd_cell led_cell __initdata = {
	66	.name = "leds-pasic3",
	67	};
5dc3339a PZ	68
	69	/*
	70	* DS1WM
	71	*/
	72
0254a8f4	73	static int ds1wm_enable(struct platform_device *pdev)
5dc3339a PZ	74	{
	75	struct device *dev = pdev->dev.parent;
	76	int c;
	77
	78	c = pasic3_read_register(dev, 0x28);
	79	pasic3_write_register(dev, 0x28, c & 0x7f);
	80
	81	dev_dbg(dev, "DS1WM OWM_EN low (active) %02x\n", c & 0x7f);
0254a8f4	82	return 0;
5dc3339a PZ	83	}
5dc3339a PZ	84
0254a8f4	85	static int ds1wm_disable(struct platform_device *pdev)
5dc3339a PZ	86	{
	87	struct device *dev = pdev->dev.parent;
	88	int c;
	89
	90	c = pasic3_read_register(dev, 0x28);
	91	pasic3_write_register(dev, 0x28, c \| 0x80);
	92
	93	dev_dbg(dev, "DS1WM OWM_EN high (inactive) %02x\n", c \| 0x80);
0254a8f4	94	return 0;
5dc3339a PZ	95	}
5dc3339a PZ	96
0254a8f4 PZ	97	static struct ds1wm_driver_data ds1wm_pdata = {
0254a8f4 PZ	98	.active_high = 0,
f607e7fc	99	.reset_recover_delay = 1,
5dc3339a PZ	100	};
5dc3339a PZ	101
0254a8f4 PZ	102	static struct resource ds1wm_resources[] __initdata = {
	103	[0] = {
	104	.start = 0,
	105	.flags = IORESOURCE_MEM,
	106	},
	107	[1] = {
	108	.start = 0,
	109	.end = 0,
	110	.flags = IORESOURCE_IRQ,
	111	},
	112	};
5dc3339a	113
5ac98553	114	static const struct mfd_cell ds1wm_cell __initconst = {
0254a8f4 PZ	115	.name = "ds1wm",
	116	.enable = ds1wm_enable,
	117	.disable = ds1wm_disable,
121ea573 SO	118	.platform_data = &ds1wm_pdata,
121ea573 SO	119	.pdata_size = sizeof(ds1wm_pdata),
0254a8f4 PZ	120	.num_resources = 2,
	121	.resources = ds1wm_resources,
	122	};
5dc3339a PZ	123
	124	static int __init pasic3_probe(struct platform_device *pdev)
	125	{
334a41ce	126	struct pasic3_platform_data *pdata = dev_get_platdata(&pdev->dev);
5dc3339a PZ	127	struct device *dev = &pdev->dev;
	128	struct pasic3_data *asic;
	129	struct resource *r;
	130	int ret;
0254a8f4 PZ	131	int irq = 0;
	132
	133	r = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	134	if (r) {
	135	ds1wm_resources[1].flags = IORESOURCE_IRQ \| (r->flags &
	136	(IORESOURCE_IRQ_HIGHEDGE \| IORESOURCE_IRQ_LOWEDGE));
	137	irq = r->start;
	138	}
	139
5dc3339a PZ	140	r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	141	if (!r)
	142	return -ENXIO;
	143
0254a8f4	144	if (!request_mem_region(r->start, resource_size(r), "pasic3"))
5dc3339a PZ	145	return -EBUSY;
5dc3339a PZ	146
8692881e	147	asic = devm_kzalloc(dev, sizeof(struct pasic3_data), GFP_KERNEL);
5dc3339a PZ	148	if (!asic)
	149	return -ENOMEM;
	150
	151	platform_set_drvdata(pdev, asic);
	152
0254a8f4	153	asic->mapping = ioremap(r->start, resource_size(r));
5dc3339a PZ	154	if (!asic->mapping) {
5dc3339a PZ	155	dev_err(dev, "couldn't ioremap PASIC3\n");
5dc3339a PZ	156	return -ENOMEM;
	157	}
	158
0254a8f4 PZ	159	/* calculate bus shift from mem resource */
	160	asic->bus_shift = (resource_size(r) - 5) >> 3;
	161
47c10edd PZ	162	if (pdata && pdata->clock_rate) {
	163	ds1wm_pdata.clock_rate = pdata->clock_rate;
	164	/* the first 5 PASIC3 registers control the DS1WM */
	165	ds1wm_resources[0].end = (5 << asic->bus_shift) - 1;
47c10edd	166	ret = mfd_add_devices(&pdev->dev, pdev->id,
0848c94f	167	&ds1wm_cell, 1, r, irq, NULL);
47c10edd PZ	168	if (ret < 0)
	169	dev_warn(dev, "failed to register DS1WM\n");
	170	}
	171
	172	if (pdata && pdata->led_pdata) {
8ac93bea SO	173	led_cell.platform_data = pdata->led_pdata;
8ac93bea SO	174	led_cell.pdata_size = sizeof(struct pasic3_leds_machinfo);
0848c94f MB	175	ret = mfd_add_devices(&pdev->dev, pdev->id, &led_cell, 1, r,
0848c94f MB	176	0, NULL);
5dc3339a PZ	177	if (ret < 0)
	178	dev_warn(dev, "failed to register LED device\n");
	179	}
	180
	181	return 0;
	182	}
	183
	184	static int pasic3_remove(struct platform_device *pdev)
	185	{
	186	struct pasic3_data *asic = platform_get_drvdata(pdev);
	187	struct resource *r;
	188
0254a8f4	189	mfd_remove_devices(&pdev->dev);
5dc3339a PZ	190
	191	iounmap(asic->mapping);
	192	r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
0254a8f4	193	release_mem_region(r->start, resource_size(r));
5dc3339a PZ	194	return 0;
	195	}
	196
4f46d6e7 KS	197	MODULE_ALIAS("platform:pasic3");
4f46d6e7 KS	198
5dc3339a PZ	199	static struct platform_driver pasic3_driver = {
	200	.driver = {
	201	.name = "pasic3",
	202	},
	203	.remove = pasic3_remove,
	204	};
	205
e8fe6a82	206	module_platform_driver_probe(pasic3_driver, pasic3_probe);
5dc3339a PZ	207
	208	MODULE_AUTHOR("Philipp Zabel <philipp.zabel@gmail.com>");
	209	MODULE_DESCRIPTION("Core driver for HTC PASIC3");
	210	MODULE_LICENSE("GPL");