scoop.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Support code for the SCOOP interface found on various Sharp PDAs
  4 *
  5 * Copyright (c) 2004 Richard Purdie
  6 *
  7 *	Based on code written by Sharp/Lineo for 2.4 kernels
  8 */
  9
 10#include <linux/device.h>
 11#include <linux/gpio/driver.h>
 12#include <linux/string.h>
 13#include <linux/slab.h>
 14#include <linux/platform_device.h>
 15#include <linux/export.h>
 16#include <linux/io.h>
 17#include <asm/hardware/scoop.h>
 18
 19/* PCMCIA to Scoop linkage
 20
 21   There is no easy way to link multiple scoop devices into one
 22   single entity for the pxa2xx_pcmcia device so this structure
 23   is used which is setup by the platform code.
 24
 25   This file is never modular so this symbol is always
 26   accessile to the board support files.
 27*/
 28struct scoop_pcmcia_config *platform_scoop_config;
 29EXPORT_SYMBOL(platform_scoop_config);
 30
 31struct  scoop_dev {
 32	void __iomem *base;
 33	struct gpio_chip gpio;
 34	spinlock_t scoop_lock;
 35	unsigned short suspend_clr;
 36	unsigned short suspend_set;
 37	u32 scoop_gpwr;
 38};
 39
 40void reset_scoop(struct device *dev)
 41{
 42	struct scoop_dev *sdev = dev_get_drvdata(dev);
 43
 44	iowrite16(0x0100, sdev->base + SCOOP_MCR);  /* 00 */
 45	iowrite16(0x0000, sdev->base + SCOOP_CDR);  /* 04 */
 46	iowrite16(0x0000, sdev->base + SCOOP_CCR);  /* 10 */
 47	iowrite16(0x0000, sdev->base + SCOOP_IMR);  /* 18 */
 48	iowrite16(0x00FF, sdev->base + SCOOP_IRM);  /* 14 */
 49	iowrite16(0x0000, sdev->base + SCOOP_ISR);  /* 1C */
 50	iowrite16(0x0000, sdev->base + SCOOP_IRM);
 51}
 52
 53static void __scoop_gpio_set(struct scoop_dev *sdev,
 54			unsigned offset, int value)
 55{
 56	unsigned short gpwr;
 57
 58	gpwr = ioread16(sdev->base + SCOOP_GPWR);
 59	if (value)
 60		gpwr |= 1 << (offset + 1);
 61	else
 62		gpwr &= ~(1 << (offset + 1));
 63	iowrite16(gpwr, sdev->base + SCOOP_GPWR);
 64}
 65
 66static int scoop_gpio_set(struct gpio_chip *chip, unsigned int offset,
 67			  int value)
 68{
 69	struct scoop_dev *sdev = gpiochip_get_data(chip);
 70	unsigned long flags;
 71
 72	spin_lock_irqsave(&sdev->scoop_lock, flags);
 73
 74	__scoop_gpio_set(sdev, offset, value);
 75
 76	spin_unlock_irqrestore(&sdev->scoop_lock, flags);
 77
 78	return 0;
 79}
 80
 81static int scoop_gpio_get(struct gpio_chip *chip, unsigned offset)
 82{
 83	struct scoop_dev *sdev = gpiochip_get_data(chip);
 84
 85	/* XXX: I'm unsure, but it seems so */
 86	return !!(ioread16(sdev->base + SCOOP_GPRR) & (1 << (offset + 1)));
 87}
 88
 89static int scoop_gpio_direction_input(struct gpio_chip *chip,
 90			unsigned offset)
 91{
 92	struct scoop_dev *sdev = gpiochip_get_data(chip);
 93	unsigned long flags;
 94	unsigned short gpcr;
 95
 96	spin_lock_irqsave(&sdev->scoop_lock, flags);
 97
 98	gpcr = ioread16(sdev->base + SCOOP_GPCR);
 99	gpcr &= ~(1 << (offset + 1));
100	iowrite16(gpcr, sdev->base + SCOOP_GPCR);
101
102	spin_unlock_irqrestore(&sdev->scoop_lock, flags);
103
104	return 0;
105}
106
107static int scoop_gpio_direction_output(struct gpio_chip *chip,
108			unsigned offset, int value)
109{
110	struct scoop_dev *sdev = gpiochip_get_data(chip);
111	unsigned long flags;
112	unsigned short gpcr;
113
114	spin_lock_irqsave(&sdev->scoop_lock, flags);
115
116	__scoop_gpio_set(sdev, offset, value);
117
118	gpcr = ioread16(sdev->base + SCOOP_GPCR);
119	gpcr |= 1 << (offset + 1);
120	iowrite16(gpcr, sdev->base + SCOOP_GPCR);
121
122	spin_unlock_irqrestore(&sdev->scoop_lock, flags);
123
124	return 0;
125}
126
127unsigned short read_scoop_reg(struct device *dev, unsigned short reg)
128{
129	struct scoop_dev *sdev = dev_get_drvdata(dev);
130	return ioread16(sdev->base + reg);
131}
132
133void write_scoop_reg(struct device *dev, unsigned short reg, unsigned short data)
134{
135	struct scoop_dev *sdev = dev_get_drvdata(dev);
136	iowrite16(data, sdev->base + reg);
137}
138
139EXPORT_SYMBOL(reset_scoop);
140EXPORT_SYMBOL(read_scoop_reg);
141EXPORT_SYMBOL(write_scoop_reg);
142
143#ifdef CONFIG_PM
144static void check_scoop_reg(struct scoop_dev *sdev)
145{
146	unsigned short mcr;
147
148	mcr = ioread16(sdev->base + SCOOP_MCR);
149	if ((mcr & 0x100) == 0)
150		iowrite16(0x0101, sdev->base + SCOOP_MCR);
151}
152
153static int scoop_suspend(struct platform_device *dev, pm_message_t state)
154{
155	struct scoop_dev *sdev = platform_get_drvdata(dev);
156
157	check_scoop_reg(sdev);
158	sdev->scoop_gpwr = ioread16(sdev->base + SCOOP_GPWR);
159	iowrite16((sdev->scoop_gpwr & ~sdev->suspend_clr) | sdev->suspend_set, sdev->base + SCOOP_GPWR);
160
161	return 0;
162}
163
164static int scoop_resume(struct platform_device *dev)
165{
166	struct scoop_dev *sdev = platform_get_drvdata(dev);
167
168	check_scoop_reg(sdev);
169	iowrite16(sdev->scoop_gpwr, sdev->base + SCOOP_GPWR);
170
171	return 0;
172}
173#else
174#define scoop_suspend	NULL
175#define scoop_resume	NULL
176#endif
177
178static int scoop_probe(struct platform_device *pdev)
179{
180	struct scoop_dev *devptr;
181	struct scoop_config *inf;
182	struct resource *mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
183	int ret;
184
185	if (!mem)
186		return -EINVAL;
187
188	devptr = kzalloc(sizeof(struct scoop_dev), GFP_KERNEL);
189	if (!devptr)
190		return -ENOMEM;
191
192	spin_lock_init(&devptr->scoop_lock);
193
194	inf = pdev->dev.platform_data;
195	devptr->base = ioremap(mem->start, resource_size(mem));
196
197	if (!devptr->base) {
198		ret = -ENOMEM;
199		goto err_ioremap;
200	}
201
202	platform_set_drvdata(pdev, devptr);
203
204	printk("Sharp Scoop Device found at 0x%08x -> 0x%8p\n",(unsigned int)mem->start, devptr->base);
205
206	iowrite16(0x0140, devptr->base + SCOOP_MCR);
207	reset_scoop(&pdev->dev);
208	iowrite16(0x0000, devptr->base + SCOOP_CPR);
209	iowrite16(inf->io_dir & 0xffff, devptr->base + SCOOP_GPCR);
210	iowrite16(inf->io_out & 0xffff, devptr->base + SCOOP_GPWR);
211
212	devptr->suspend_clr = inf->suspend_clr;
213	devptr->suspend_set = inf->suspend_set;
214
215	devptr->gpio.base = -1;
216
217	if (inf->gpio_base != 0) {
218		devptr->gpio.label = dev_name(&pdev->dev);
219		devptr->gpio.base = inf->gpio_base;
220		devptr->gpio.ngpio = 12; /* PA11 = 0, PA12 = 1, etc. up to PA22 = 11 */
221		devptr->gpio.set = scoop_gpio_set;
222		devptr->gpio.get = scoop_gpio_get;
223		devptr->gpio.direction_input = scoop_gpio_direction_input;
224		devptr->gpio.direction_output = scoop_gpio_direction_output;
225
226		ret = gpiochip_add_data(&devptr->gpio, devptr);
227		if (ret)
228			goto err_gpio;
229	}
230
231	return 0;
232
233err_gpio:
234	platform_set_drvdata(pdev, NULL);
235err_ioremap:
236	iounmap(devptr->base);
237	kfree(devptr);
238
239	return ret;
240}
241
242static void scoop_remove(struct platform_device *pdev)
243{
244	struct scoop_dev *sdev = platform_get_drvdata(pdev);
245
246	if (sdev->gpio.base != -1)
247		gpiochip_remove(&sdev->gpio);
248
249	platform_set_drvdata(pdev, NULL);
250	iounmap(sdev->base);
251	kfree(sdev);
252}
253
254static struct platform_driver scoop_driver = {
255	.probe		= scoop_probe,
256	.remove		= scoop_remove,
257	.suspend	= scoop_suspend,
258	.resume		= scoop_resume,
259	.driver		= {
260		.name	= "sharp-scoop",
261	},
262};
263
264static int __init scoop_init(void)
265{
266	return platform_driver_register(&scoop_driver);
267}
268
269subsys_initcall(scoop_init);