[net-next-2.6.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 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);

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 DES	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 DES	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
af901ca1	85	/* XXX: I'm unsure, but it seems so */
b43a9e60 DES	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 read_scoop_reg(struct device *dev, unsigned short reg)
	128	{
	129	struct scoop_dev *sdev = dev_get_drvdata(dev);
c353faa4	130	return ioread16(sdev->base + reg);
1da177e4 LT	131	}
	132
	133	void write_scoop_reg(struct device *dev, unsigned short reg, unsigned short data)
	134	{
	135	struct scoop_dev *sdev = dev_get_drvdata(dev);
c353faa4	136	iowrite16(data, sdev->base + reg);
1da177e4 LT	137	}
	138
	139	EXPORT_SYMBOL(reset_scoop);
	140	EXPORT_SYMBOL(read_scoop_reg);
	141	EXPORT_SYMBOL(write_scoop_reg);
	142
7c398988 RP	143	static void check_scoop_reg(struct scoop_dev *sdev)
	144	{
	145	unsigned short mcr;
	146
c353faa4	147	mcr = ioread16(sdev->base + SCOOP_MCR);
7c398988	148	if ((mcr & 0x100) == 0)
c353faa4	149	iowrite16(0x0101, sdev->base + SCOOP_MCR);
7c398988 RP	150	}
7c398988 RP	151
1da177e4	152	#ifdef CONFIG_PM
3ae5eaec	153	static int scoop_suspend(struct platform_device *dev, pm_message_t state)
1da177e4	154	{
3ae5eaec	155	struct scoop_dev *sdev = platform_get_drvdata(dev);
9480e307 RK	156
9480e307 RK	157	check_scoop_reg(sdev);
c353faa4 DES	158	sdev->scoop_gpwr = ioread16(sdev->base + SCOOP_GPWR);
c353faa4 DES	159	iowrite16((sdev->scoop_gpwr & ~sdev->suspend_clr) \| sdev->suspend_set, sdev->base + SCOOP_GPWR);
1da177e4	160
1da177e4 LT	161	return 0;
	162	}
	163
3ae5eaec	164	static int scoop_resume(struct platform_device *dev)
1da177e4	165	{
3ae5eaec	166	struct scoop_dev *sdev = platform_get_drvdata(dev);
9480e307 RK	167
9480e307 RK	168	check_scoop_reg(sdev);
c353faa4	169	iowrite16(sdev->scoop_gpwr, sdev->base + SCOOP_GPWR);
1da177e4	170
1da177e4 LT	171	return 0;
	172	}
	173	#else
	174	#define scoop_suspend NULL
	175	#define scoop_resume NULL
	176	#endif
	177
2f8c5149	178	static int __devinit scoop_probe(struct platform_device *pdev)
1da177e4 LT	179	{
	180	struct scoop_dev *devptr;
	181	struct scoop_config *inf;
1da177e4	182	struct resource *mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
b43a9e60 DES	183	int ret;
b43a9e60 DES	184	int temp;
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;
1da177e4 LT	196	devptr->base = ioremap(mem->start, mem->end - mem->start + 1);
	197
	198	if (!devptr->base) {
b43a9e60 DES	199	ret = -ENOMEM;
b43a9e60 DES	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 DES	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 DES	216	devptr->gpio.base = -1;
	217
	218	if (inf->gpio_base != 0) {
3f978704	219	devptr->gpio.label = dev_name(&pdev->dev);
b43a9e60 DES	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
	227	ret = gpiochip_add(&devptr->gpio);
	228	if (ret)
	229	goto err_gpio;
	230	}
	231
1da177e4	232	return 0;
b43a9e60 DES	233
	234	if (devptr->gpio.base != -1)
	235	temp = gpiochip_remove(&devptr->gpio);
	236	err_gpio:
	237	platform_set_drvdata(pdev, NULL);
	238	err_ioremap:
	239	iounmap(devptr->base);
	240	kfree(devptr);
	241
	242	return ret;
1da177e4 LT	243	}
1da177e4 LT	244
2f8c5149	245	static int __devexit scoop_remove(struct platform_device *pdev)
1da177e4	246	{
3ae5eaec	247	struct scoop_dev *sdev = platform_get_drvdata(pdev);
b43a9e60 DES	248	int ret;
	249
	250	if (!sdev)
	251	return -EINVAL;
	252
	253	if (sdev->gpio.base != -1) {
	254	ret = gpiochip_remove(&sdev->gpio);
	255	if (ret) {
	256	dev_err(&pdev->dev, "Can't remove gpio chip: %d\n", ret);
	257	return ret;
	258	}
1da177e4	259	}
b43a9e60 DES	260
	261	platform_set_drvdata(pdev, NULL);
	262	iounmap(sdev->base);
	263	kfree(sdev);
	264
1da177e4 LT	265	return 0;
	266	}
	267
3ae5eaec	268	static struct platform_driver scoop_driver = {
1da177e4	269	.probe = scoop_probe,
2f8c5149	270	.remove = __devexit_p(scoop_remove),
1da177e4 LT	271	.suspend = scoop_suspend,
1da177e4 LT	272	.resume = scoop_resume,
3ae5eaec RK	273	.driver = {
	274	.name = "sharp-scoop",
	275	},
1da177e4 LT	276	};
1da177e4 LT	277
2f8c5149	278	static int __init scoop_init(void)
1da177e4	279	{
3ae5eaec	280	return platform_driver_register(&scoop_driver);
1da177e4 LT	281	}
	282
	283	subsys_initcall(scoop_init);