[linux.git] / arch / arm / common / scoop.c

/*
 * Support code for the SCOOP interface found on various Sharp PDAs
 *
 * Copyright (c) 2004 Richard Purdie
 *
 *	Based on code written by Sharp/Lineo for 2.4 kernels
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 */

#include <linux/device.h>
#include <linux/gpio.h>
#include <linux/string.h>
#include <linux/slab.h>
#include <linux/platform_device.h>
#include <linux/export.h>
#include <linux/io.h>
#include <asm/hardware/scoop.h>

/* PCMCIA to Scoop linkage

   There is no easy way to link multiple scoop devices into one
   single entity for the pxa2xx_pcmcia device so this structure
   is used which is setup by the platform code.

   This file is never modular so this symbol is always
   accessile to the board support files.
*/
struct scoop_pcmcia_config *platform_scoop_config;
EXPORT_SYMBOL(platform_scoop_config);

struct  scoop_dev {
	void __iomem *base;
	struct gpio_chip gpio;
	spinlock_t scoop_lock;
	unsigned short suspend_clr;
	unsigned short suspend_set;
	u32 scoop_gpwr;
};

void reset_scoop(struct device *dev)
{
	struct scoop_dev *sdev = dev_get_drvdata(dev);

	iowrite16(0x0100, sdev->base + SCOOP_MCR);  /* 00 */
	iowrite16(0x0000, sdev->base + SCOOP_CDR);  /* 04 */
	iowrite16(0x0000, sdev->base + SCOOP_CCR);  /* 10 */
	iowrite16(0x0000, sdev->base + SCOOP_IMR);  /* 18 */
	iowrite16(0x00FF, sdev->base + SCOOP_IRM);  /* 14 */
	iowrite16(0x0000, sdev->base + SCOOP_ISR);  /* 1C */
	iowrite16(0x0000, sdev->base + SCOOP_IRM);
}

static void __scoop_gpio_set(struct scoop_dev *sdev,
			unsigned offset, int value)
{
	unsigned short gpwr;

	gpwr = ioread16(sdev->base + SCOOP_GPWR);
	if (value)
		gpwr |= 1 << (offset + 1);
	else
		gpwr &= ~(1 << (offset + 1));
	iowrite16(gpwr, sdev->base + SCOOP_GPWR);
}

static void scoop_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
{
	struct scoop_dev *sdev = gpiochip_get_data(chip);
	unsigned long flags;

	spin_lock_irqsave(&sdev->scoop_lock, flags);

	__scoop_gpio_set(sdev, offset, value);

	spin_unlock_irqrestore(&sdev->scoop_lock, flags);
}

static int scoop_gpio_get(struct gpio_chip *chip, unsigned offset)
{
	struct scoop_dev *sdev = gpiochip_get_data(chip);

	/* XXX: I'm unsure, but it seems so */
	return !!(ioread16(sdev->base + SCOOP_GPRR) & (1 << (offset + 1)));
}

static int scoop_gpio_direction_input(struct gpio_chip *chip,
			unsigned offset)
{
	struct scoop_dev *sdev = gpiochip_get_data(chip);
	unsigned long flags;
	unsigned short gpcr;

	spin_lock_irqsave(&sdev->scoop_lock, flags);

	gpcr = ioread16(sdev->base + SCOOP_GPCR);
	gpcr &= ~(1 << (offset + 1));
	iowrite16(gpcr, sdev->base + SCOOP_GPCR);

	spin_unlock_irqrestore(&sdev->scoop_lock, flags);

	return 0;
}

static int scoop_gpio_direction_output(struct gpio_chip *chip,
			unsigned offset, int value)
{
	struct scoop_dev *sdev = gpiochip_get_data(chip);
	unsigned long flags;
	unsigned short gpcr;

	spin_lock_irqsave(&sdev->scoop_lock, flags);

	__scoop_gpio_set(sdev, offset, value);

	gpcr = ioread16(sdev->base + SCOOP_GPCR);
	gpcr |= 1 << (offset + 1);
	iowrite16(gpcr, sdev->base + SCOOP_GPCR);

	spin_unlock_irqrestore(&sdev->scoop_lock, flags);

	return 0;
}

unsigned short read_scoop_reg(struct device *dev, unsigned short reg)
{
	struct scoop_dev *sdev = dev_get_drvdata(dev);
	return ioread16(sdev->base + reg);
}

void write_scoop_reg(struct device *dev, unsigned short reg, unsigned short data)
{
	struct scoop_dev *sdev = dev_get_drvdata(dev);
	iowrite16(data, sdev->base + reg);
}

EXPORT_SYMBOL(reset_scoop);
EXPORT_SYMBOL(read_scoop_reg);
EXPORT_SYMBOL(write_scoop_reg);

#ifdef CONFIG_PM
static void check_scoop_reg(struct scoop_dev *sdev)
{
	unsigned short mcr;

	mcr = ioread16(sdev->base + SCOOP_MCR);
	if ((mcr & 0x100) == 0)
		iowrite16(0x0101, sdev->base + SCOOP_MCR);
}

static int scoop_suspend(struct platform_device *dev, pm_message_t state)
{
	struct scoop_dev *sdev = platform_get_drvdata(dev);

	check_scoop_reg(sdev);
	sdev->scoop_gpwr = ioread16(sdev->base + SCOOP_GPWR);
	iowrite16((sdev->scoop_gpwr & ~sdev->suspend_clr) | sdev->suspend_set, sdev->base + SCOOP_GPWR);

	return 0;
}

static int scoop_resume(struct platform_device *dev)
{
	struct scoop_dev *sdev = platform_get_drvdata(dev);

	check_scoop_reg(sdev);
	iowrite16(sdev->scoop_gpwr, sdev->base + SCOOP_GPWR);

	return 0;
}
#else
#define scoop_suspend	NULL
#define scoop_resume	NULL
#endif

static int scoop_probe(struct platform_device *pdev)
{
	struct scoop_dev *devptr;
	struct scoop_config *inf;
	struct resource *mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	int ret;

	if (!mem)
		return -EINVAL;

	devptr = kzalloc(sizeof(struct scoop_dev), GFP_KERNEL);
	if (!devptr)
		return -ENOMEM;

	spin_lock_init(&devptr->scoop_lock);

	inf = pdev->dev.platform_data;
	devptr->base = ioremap(mem->start, resource_size(mem));

	if (!devptr->base) {
		ret = -ENOMEM;
		goto err_ioremap;
	}

	platform_set_drvdata(pdev, devptr);

	printk("Sharp Scoop Device found at 0x%08x -> 0x%8p\n",(unsigned int)mem->start, devptr->base);

	iowrite16(0x0140, devptr->base + SCOOP_MCR);
	reset_scoop(&pdev->dev);
	iowrite16(0x0000, devptr->base + SCOOP_CPR);
	iowrite16(inf->io_dir & 0xffff, devptr->base + SCOOP_GPCR);
	iowrite16(inf->io_out & 0xffff, devptr->base + SCOOP_GPWR);

	devptr->suspend_clr = inf->suspend_clr;
	devptr->suspend_set = inf->suspend_set;

	devptr->gpio.base = -1;

	if (inf->gpio_base != 0) {
		devptr->gpio.label = dev_name(&pdev->dev);
		devptr->gpio.base = inf->gpio_base;
		devptr->gpio.ngpio = 12; /* PA11 = 0, PA12 = 1, etc. up to PA22 = 11 */
		devptr->gpio.set = scoop_gpio_set;
		devptr->gpio.get = scoop_gpio_get;
		devptr->gpio.direction_input = scoop_gpio_direction_input;
		devptr->gpio.direction_output = scoop_gpio_direction_output;

		ret = gpiochip_add_data(&devptr->gpio, devptr);
		if (ret)
			goto err_gpio;
	}

	return 0;

err_gpio:
	platform_set_drvdata(pdev, NULL);
err_ioremap:
	iounmap(devptr->base);
	kfree(devptr);

	return ret;
}

static int scoop_remove(struct platform_device *pdev)
{
	struct scoop_dev *sdev = platform_get_drvdata(pdev);

	if (!sdev)
		return -EINVAL;

	if (sdev->gpio.base != -1)
		gpiochip_remove(&sdev->gpio);

	platform_set_drvdata(pdev, NULL);
	iounmap(sdev->base);
	kfree(sdev);

	return 0;
}

static struct platform_driver scoop_driver = {
	.probe		= scoop_probe,
	.remove		= scoop_remove,
	.suspend	= scoop_suspend,
	.resume		= scoop_resume,
	.driver		= {
		.name	= "sharp-scoop",
	},
};

static int __init scoop_init(void)
{
	return platform_driver_register(&scoop_driver);
}

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