[thirdparty/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/string.h>
#include <linux/slab.h>
#include <linux/platform_device.h>
#include <linux/io.h>
#include <asm/gpio.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 usure,  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 set_scoop_gpio(struct device *dev, unsigned short bit)
{
	unsigned short gpio_bit;
	unsigned long flag;
	struct scoop_dev *sdev = dev_get_drvdata(dev);

	spin_lock_irqsave(&sdev->scoop_lock, flag);
	gpio_bit = ioread16(sdev->base + SCOOP_GPWR) | bit;
	iowrite16(gpio_bit, sdev->base + SCOOP_GPWR);
	spin_unlock_irqrestore(&sdev->scoop_lock, flag);

	return gpio_bit;
}

unsigned short reset_scoop_gpio(struct device *dev, unsigned short bit)
{
	unsigned short gpio_bit;
	unsigned long flag;
	struct scoop_dev *sdev = dev_get_drvdata(dev);

	spin_lock_irqsave(&sdev->scoop_lock, flag);
	gpio_bit = ioread16(sdev->base + SCOOP_GPWR) & ~bit;
	iowrite16(gpio_bit, sdev->base + SCOOP_GPWR);
	spin_unlock_irqrestore(&sdev->scoop_lock, flag);

	return gpio_bit;
}

EXPORT_SYMBOL(set_scoop_gpio);
EXPORT_SYMBOL(reset_scoop_gpio);

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

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

#ifdef CONFIG_PM
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 __devinit 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, mem->end - mem->start + 1);

	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 __devexit 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		= __devexit_p(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>
4e57b681	15	#include <linux/string.h>
de25968c	16	#include <linux/slab.h>
d052d1be	17	#include <linux/platform_device.h>
fced80c7	18	#include <linux/io.h>
b43a9e60	19	#include <asm/gpio.h>
1da177e4 LT	20	#include <asm/hardware/scoop.h>
1da177e4 LT	21
7ea3bbbc RP	22	/* PCMCIA to Scoop linkage
	23
	24	There is no easy way to link multiple scoop devices into one
	25	single entity for the pxa2xx_pcmcia device so this structure
	26	is used which is setup by the platform code.
	27
	28	This file is never modular so this symbol is always
	29	accessile to the board support files.
	30	*/
	31	struct scoop_pcmcia_config *platform_scoop_config;
	32	EXPORT_SYMBOL(platform_scoop_config);
	33
1da177e4	34	struct scoop_dev {
2f8c5149	35	void __iomem *base;
b43a9e60	36	struct gpio_chip gpio;
1da177e4	37	spinlock_t scoop_lock;
7c398988 RP	38	unsigned short suspend_clr;
7c398988 RP	39	unsigned short suspend_set;
1da177e4 LT	40	u32 scoop_gpwr;
	41	};
	42
	43	void reset_scoop(struct device *dev)
	44	{
	45	struct scoop_dev *sdev = dev_get_drvdata(dev);
	46
c353faa4 DB	47	iowrite16(0x0100, sdev->base + SCOOP_MCR); // 00
	48	iowrite16(0x0000, sdev->base + SCOOP_CDR); // 04
	49	iowrite16(0x0000, sdev->base + SCOOP_CCR); // 10
	50	iowrite16(0x0000, sdev->base + SCOOP_IMR); // 18
	51	iowrite16(0x00FF, sdev->base + SCOOP_IRM); // 14
	52	iowrite16(0x0000, sdev->base + SCOOP_ISR); // 1C
	53	iowrite16(0x0000, sdev->base + SCOOP_IRM);
1da177e4 LT	54	}
1da177e4 LT	55
b43a9e60 DB	56	static void __scoop_gpio_set(struct scoop_dev *sdev,
	57	unsigned offset, int value)
	58	{
	59	unsigned short gpwr;
	60
	61	gpwr = ioread16(sdev->base + SCOOP_GPWR);
	62	if (value)
	63	gpwr \|= 1 << (offset + 1);
	64	else
	65	gpwr &= ~(1 << (offset + 1));
	66	iowrite16(gpwr, sdev->base + SCOOP_GPWR);
	67	}
	68
	69	static void scoop_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
	70	{
	71	struct scoop_dev *sdev = container_of(chip, struct scoop_dev, gpio);
	72	unsigned long flags;
	73
	74	spin_lock_irqsave(&sdev->scoop_lock, flags);
	75
	76	__scoop_gpio_set(sdev, offset, value);
	77
	78	spin_unlock_irqrestore(&sdev->scoop_lock, flags);
	79	}
	80
	81	static int scoop_gpio_get(struct gpio_chip *chip, unsigned offset)
	82	{
	83	struct scoop_dev *sdev = container_of(chip, struct scoop_dev, gpio);
	84
	85	/* XXX: I'm usure, but it seems so */
	86	return ioread16(sdev->base + SCOOP_GPRR) & (1 << (offset + 1));
	87	}
	88
	89	static int scoop_gpio_direction_input(struct gpio_chip *chip,
	90	unsigned offset)
	91	{
	92	struct scoop_dev *sdev = container_of(chip, struct scoop_dev, gpio);
	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
	107	static int scoop_gpio_direction_output(struct gpio_chip *chip,
	108	unsigned offset, int value)
	109	{
	110	struct scoop_dev *sdev = container_of(chip, struct scoop_dev, gpio);
	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
1da177e4 LT	127	unsigned short set_scoop_gpio(struct device *dev, unsigned short bit)
	128	{
	129	unsigned short gpio_bit;
	130	unsigned long flag;
	131	struct scoop_dev *sdev = dev_get_drvdata(dev);
	132
	133	spin_lock_irqsave(&sdev->scoop_lock, flag);
c353faa4 DB	134	gpio_bit = ioread16(sdev->base + SCOOP_GPWR) \| bit;
c353faa4 DB	135	iowrite16(gpio_bit, sdev->base + SCOOP_GPWR);
1da177e4 LT	136	spin_unlock_irqrestore(&sdev->scoop_lock, flag);
	137
	138	return gpio_bit;
	139	}
	140
	141	unsigned short reset_scoop_gpio(struct device *dev, unsigned short bit)
	142	{
	143	unsigned short gpio_bit;
	144	unsigned long flag;
	145	struct scoop_dev *sdev = dev_get_drvdata(dev);
	146
	147	spin_lock_irqsave(&sdev->scoop_lock, flag);
c353faa4 DB	148	gpio_bit = ioread16(sdev->base + SCOOP_GPWR) & ~bit;
c353faa4 DB	149	iowrite16(gpio_bit, sdev->base + SCOOP_GPWR);
1da177e4 LT	150	spin_unlock_irqrestore(&sdev->scoop_lock, flag);
	151
	152	return gpio_bit;
	153	}
	154
	155	EXPORT_SYMBOL(set_scoop_gpio);
	156	EXPORT_SYMBOL(reset_scoop_gpio);
	157
	158	unsigned short read_scoop_reg(struct device *dev, unsigned short reg)
	159	{
	160	struct scoop_dev *sdev = dev_get_drvdata(dev);
c353faa4	161	return ioread16(sdev->base + reg);
1da177e4 LT	162	}
	163
	164	void write_scoop_reg(struct device *dev, unsigned short reg, unsigned short data)
	165	{
	166	struct scoop_dev *sdev = dev_get_drvdata(dev);
c353faa4	167	iowrite16(data, sdev->base + reg);
1da177e4 LT	168	}
	169
	170	EXPORT_SYMBOL(reset_scoop);
	171	EXPORT_SYMBOL(read_scoop_reg);
	172	EXPORT_SYMBOL(write_scoop_reg);
	173
7c398988 RP	174	static void check_scoop_reg(struct scoop_dev *sdev)
	175	{
	176	unsigned short mcr;
	177
c353faa4	178	mcr = ioread16(sdev->base + SCOOP_MCR);
7c398988	179	if ((mcr & 0x100) == 0)
c353faa4	180	iowrite16(0x0101, sdev->base + SCOOP_MCR);
7c398988 RP	181	}
7c398988 RP	182
1da177e4	183	#ifdef CONFIG_PM
3ae5eaec	184	static int scoop_suspend(struct platform_device *dev, pm_message_t state)
1da177e4	185	{
3ae5eaec	186	struct scoop_dev *sdev = platform_get_drvdata(dev);
9480e307 RK	187
9480e307 RK	188	check_scoop_reg(sdev);
c353faa4 DB	189	sdev->scoop_gpwr = ioread16(sdev->base + SCOOP_GPWR);
c353faa4 DB	190	iowrite16((sdev->scoop_gpwr & ~sdev->suspend_clr) \| sdev->suspend_set, sdev->base + SCOOP_GPWR);
1da177e4	191
1da177e4 LT	192	return 0;
	193	}
	194
3ae5eaec	195	static int scoop_resume(struct platform_device *dev)
1da177e4	196	{
3ae5eaec	197	struct scoop_dev *sdev = platform_get_drvdata(dev);
9480e307 RK	198
9480e307 RK	199	check_scoop_reg(sdev);
c353faa4	200	iowrite16(sdev->scoop_gpwr, sdev->base + SCOOP_GPWR);
1da177e4	201
1da177e4 LT	202	return 0;
	203	}
	204	#else
	205	#define scoop_suspend NULL
	206	#define scoop_resume NULL
	207	#endif
	208
2f8c5149	209	static int __devinit scoop_probe(struct platform_device *pdev)
1da177e4 LT	210	{
	211	struct scoop_dev *devptr;
	212	struct scoop_config *inf;
1da177e4	213	struct resource *mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
b43a9e60 DB	214	int ret;
b43a9e60 DB	215	int temp;
1da177e4 LT	216
	217	if (!mem)
	218	return -EINVAL;
	219
d2a02b93	220	devptr = kzalloc(sizeof(struct scoop_dev), GFP_KERNEL);
1da177e4	221	if (!devptr)
d2a02b93	222	return -ENOMEM;
1da177e4	223
1da177e4 LT	224	spin_lock_init(&devptr->scoop_lock);
1da177e4 LT	225
3ae5eaec	226	inf = pdev->dev.platform_data;
1da177e4 LT	227	devptr->base = ioremap(mem->start, mem->end - mem->start + 1);
	228
	229	if (!devptr->base) {
b43a9e60 DB	230	ret = -ENOMEM;
b43a9e60 DB	231	goto err_ioremap;
1da177e4 LT	232	}
1da177e4 LT	233
3ae5eaec	234	platform_set_drvdata(pdev, devptr);
1da177e4	235
2f8c5149	236	printk("Sharp Scoop Device found at 0x%08x -> 0x%8p\n",(unsigned int)mem->start, devptr->base);
1da177e4	237
c353faa4	238	iowrite16(0x0140, devptr->base + SCOOP_MCR);
c35bf4a5	239	reset_scoop(&pdev->dev);
c353faa4 DB	240	iowrite16(0x0000, devptr->base + SCOOP_CPR);
	241	iowrite16(inf->io_dir & 0xffff, devptr->base + SCOOP_GPCR);
	242	iowrite16(inf->io_out & 0xffff, devptr->base + SCOOP_GPWR);
1da177e4	243
7c398988 RP	244	devptr->suspend_clr = inf->suspend_clr;
	245	devptr->suspend_set = inf->suspend_set;
	246
b43a9e60 DB	247	devptr->gpio.base = -1;
	248
	249	if (inf->gpio_base != 0) {
3f978704	250	devptr->gpio.label = dev_name(&pdev->dev);
b43a9e60 DB	251	devptr->gpio.base = inf->gpio_base;
	252	devptr->gpio.ngpio = 12; /* PA11 = 0, PA12 = 1, etc. up to PA22 = 11 */
	253	devptr->gpio.set = scoop_gpio_set;
	254	devptr->gpio.get = scoop_gpio_get;
	255	devptr->gpio.direction_input = scoop_gpio_direction_input;
	256	devptr->gpio.direction_output = scoop_gpio_direction_output;
	257
	258	ret = gpiochip_add(&devptr->gpio);
	259	if (ret)
	260	goto err_gpio;
	261	}
	262
1da177e4	263	return 0;
b43a9e60 DB	264
	265	if (devptr->gpio.base != -1)
	266	temp = gpiochip_remove(&devptr->gpio);
	267	err_gpio:
	268	platform_set_drvdata(pdev, NULL);
	269	err_ioremap:
	270	iounmap(devptr->base);
	271	kfree(devptr);
	272
	273	return ret;
1da177e4 LT	274	}
1da177e4 LT	275
2f8c5149	276	static int __devexit scoop_remove(struct platform_device *pdev)
1da177e4	277	{
3ae5eaec	278	struct scoop_dev *sdev = platform_get_drvdata(pdev);
b43a9e60 DB	279	int ret;
	280
	281	if (!sdev)
	282	return -EINVAL;
	283
	284	if (sdev->gpio.base != -1) {
	285	ret = gpiochip_remove(&sdev->gpio);
	286	if (ret) {
	287	dev_err(&pdev->dev, "Can't remove gpio chip: %d\n", ret);
	288	return ret;
	289	}
1da177e4	290	}
b43a9e60 DB	291
	292	platform_set_drvdata(pdev, NULL);
	293	iounmap(sdev->base);
	294	kfree(sdev);
	295
1da177e4 LT	296	return 0;
	297	}
	298
3ae5eaec	299	static struct platform_driver scoop_driver = {
1da177e4	300	.probe = scoop_probe,
2f8c5149	301	.remove = __devexit_p(scoop_remove),
1da177e4 LT	302	.suspend = scoop_suspend,
1da177e4 LT	303	.resume = scoop_resume,
3ae5eaec RK	304	.driver = {
	305	.name = "sharp-scoop",
	306	},
1da177e4 LT	307	};
1da177e4 LT	308
2f8c5149	309	static int __init scoop_init(void)
1da177e4	310	{
3ae5eaec	311	return platform_driver_register(&scoop_driver);
1da177e4 LT	312	}
	313
	314	subsys_initcall(scoop_init);