[deliverable/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 = container_of(chip, struct scoop_dev, gpio);
	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 = container_of(chip, struct scoop_dev, gpio);

	/* 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 = container_of(chip, struct scoop_dev, gpio);
	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 = container_of(chip, struct scoop_dev, gpio);
	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;
	int temp;

	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(&devptr->gpio);
		if (ret)
			goto err_gpio;
	}

	return 0;

	if (devptr->gpio.base != -1)
		temp = gpiochip_remove(&devptr->gpio);
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);
	int ret;

	if (!sdev)
		return -EINVAL;

	if (sdev->gpio.base != -1) {
		ret = gpiochip_remove(&sdev->gpio);
		if (ret) {
			dev_err(&pdev->dev, "Can't remove gpio chip: %d\n", ret);
			return ret;
		}
	}

	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	{
	72	struct scoop_dev *sdev = container_of(chip, struct scoop_dev, gpio);
	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	{
	84	struct scoop_dev *sdev = container_of(chip, struct scoop_dev, gpio);
	85
af901ca1	86	/* XXX: I'm unsure, but it seems so */
b43a9e60 DB	87	return ioread16(sdev->base + SCOOP_GPRR) & (1 << (offset + 1));
	88	}
	89
	90	static int scoop_gpio_direction_input(struct gpio_chip *chip,
	91	unsigned offset)
	92	{
	93	struct scoop_dev *sdev = container_of(chip, struct scoop_dev, gpio);
	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	{
	111	struct scoop_dev *sdev = container_of(chip, struct scoop_dev, gpio);
	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 DB	184	int ret;
b43a9e60 DB	185	int temp;
1da177e4 LT	186
	187	if (!mem)
	188	return -EINVAL;
	189
d2a02b93	190	devptr = kzalloc(sizeof(struct scoop_dev), GFP_KERNEL);
1da177e4	191	if (!devptr)
d2a02b93	192	return -ENOMEM;
1da177e4	193
1da177e4 LT	194	spin_lock_init(&devptr->scoop_lock);
1da177e4 LT	195
3ae5eaec	196	inf = pdev->dev.platform_data;
28f65c11	197	devptr->base = ioremap(mem->start, resource_size(mem));
1da177e4 LT	198
1da177e4 LT	199	if (!devptr->base) {
b43a9e60 DB	200	ret = -ENOMEM;
b43a9e60 DB	201	goto err_ioremap;
1da177e4 LT	202	}
1da177e4 LT	203
3ae5eaec	204	platform_set_drvdata(pdev, devptr);
1da177e4	205
2f8c5149	206	printk("Sharp Scoop Device found at 0x%08x -> 0x%8p\n",(unsigned int)mem->start, devptr->base);
1da177e4	207
c353faa4	208	iowrite16(0x0140, devptr->base + SCOOP_MCR);
c35bf4a5	209	reset_scoop(&pdev->dev);
c353faa4 DB	210	iowrite16(0x0000, devptr->base + SCOOP_CPR);
	211	iowrite16(inf->io_dir & 0xffff, devptr->base + SCOOP_GPCR);
	212	iowrite16(inf->io_out & 0xffff, devptr->base + SCOOP_GPWR);
1da177e4	213
7c398988 RP	214	devptr->suspend_clr = inf->suspend_clr;
	215	devptr->suspend_set = inf->suspend_set;
	216
b43a9e60 DB	217	devptr->gpio.base = -1;
	218
	219	if (inf->gpio_base != 0) {
3f978704	220	devptr->gpio.label = dev_name(&pdev->dev);
b43a9e60 DB	221	devptr->gpio.base = inf->gpio_base;
	222	devptr->gpio.ngpio = 12; /* PA11 = 0, PA12 = 1, etc. up to PA22 = 11 */
	223	devptr->gpio.set = scoop_gpio_set;
	224	devptr->gpio.get = scoop_gpio_get;
	225	devptr->gpio.direction_input = scoop_gpio_direction_input;
	226	devptr->gpio.direction_output = scoop_gpio_direction_output;
	227
	228	ret = gpiochip_add(&devptr->gpio);
	229	if (ret)
	230	goto err_gpio;
	231	}
	232
1da177e4	233	return 0;
b43a9e60 DB	234
	235	if (devptr->gpio.base != -1)
	236	temp = gpiochip_remove(&devptr->gpio);
	237	err_gpio:
	238	platform_set_drvdata(pdev, NULL);
	239	err_ioremap:
	240	iounmap(devptr->base);
	241	kfree(devptr);
	242
	243	return ret;
1da177e4 LT	244	}
1da177e4 LT	245
351a102d	246	static int scoop_remove(struct platform_device *pdev)
1da177e4	247	{
3ae5eaec	248	struct scoop_dev *sdev = platform_get_drvdata(pdev);
b43a9e60 DB	249	int ret;
	250
	251	if (!sdev)
	252	return -EINVAL;
	253
	254	if (sdev->gpio.base != -1) {
	255	ret = gpiochip_remove(&sdev->gpio);
	256	if (ret) {
	257	dev_err(&pdev->dev, "Can't remove gpio chip: %d\n", ret);
	258	return ret;
	259	}
1da177e4	260	}
b43a9e60 DB	261
	262	platform_set_drvdata(pdev, NULL);
	263	iounmap(sdev->base);
	264	kfree(sdev);
	265
1da177e4 LT	266	return 0;
	267	}
	268
3ae5eaec	269	static struct platform_driver scoop_driver = {
1da177e4	270	.probe = scoop_probe,
351a102d	271	.remove = scoop_remove,
1da177e4 LT	272	.suspend = scoop_suspend,
1da177e4 LT	273	.resume = scoop_resume,
3ae5eaec RK	274	.driver = {
	275	.name = "sharp-scoop",
	276	},
1da177e4 LT	277	};
1da177e4 LT	278
2f8c5149	279	static int __init scoop_init(void)
1da177e4	280	{
3ae5eaec	281	return platform_driver_register(&scoop_driver);
1da177e4 LT	282	}
	283
	284	subsys_initcall(scoop_init);