[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
	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>
	15	#include <linux/string.h>
	16	#include <linux/slab.h>
	17	#include <linux/platform_device.h>
	18	#include <linux/io.h>
	19	#include <asm/gpio.h>
	20	#include <asm/hardware/scoop.h>
	21
	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
	34	struct scoop_dev {
	35	void __iomem *base;
	36	struct gpio_chip gpio;
	37	spinlock_t scoop_lock;
	38	unsigned short suspend_clr;
	39	unsigned short suspend_set;
	40	u32 scoop_gpwr;
	41	};
	42
	43	void reset_scoop(struct device *dev)
	44	{
	45	struct scoop_dev *sdev = dev_get_drvdata(dev);
	46
	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);
	54	}
	55
	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 unsure, 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
	127	unsigned 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
	133	void 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
	139	EXPORT_SYMBOL(reset_scoop);
	140	EXPORT_SYMBOL(read_scoop_reg);
	141	EXPORT_SYMBOL(write_scoop_reg);
	142
	143	static void check_scoop_reg(struct scoop_dev *sdev)
	144	{
	145	unsigned short mcr;
	146
	147	mcr = ioread16(sdev->base + SCOOP_MCR);
	148	if ((mcr & 0x100) == 0)
	149	iowrite16(0x0101, sdev->base + SCOOP_MCR);
	150	}
	151
	152	#ifdef CONFIG_PM
	153	static 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
	164	static 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
	178	static int __devinit 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	int temp;
	185
	186	if (!mem)
	187	return -EINVAL;
	188
	189	devptr = kzalloc(sizeof(struct scoop_dev), GFP_KERNEL);
	190	if (!devptr)
	191	return -ENOMEM;
	192
	193	spin_lock_init(&devptr->scoop_lock);
	194
	195	inf = pdev->dev.platform_data;
	196	devptr->base = ioremap(mem->start, mem->end - mem->start + 1);
	197
	198	if (!devptr->base) {
	199	ret = -ENOMEM;
	200	goto err_ioremap;
	201	}
	202
	203	platform_set_drvdata(pdev, devptr);
	204
	205	printk("Sharp Scoop Device found at 0x%08x -> 0x%8p\n",(unsigned int)mem->start, devptr->base);
	206
	207	iowrite16(0x0140, devptr->base + SCOOP_MCR);
	208	reset_scoop(&pdev->dev);
	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);
	212
	213	devptr->suspend_clr = inf->suspend_clr;
	214	devptr->suspend_set = inf->suspend_set;
	215
	216	devptr->gpio.base = -1;
	217
	218	if (inf->gpio_base != 0) {
	219	devptr->gpio.label = dev_name(&pdev->dev);
	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
	232	return 0;
	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;
	243	}
	244
	245	static int __devexit scoop_remove(struct platform_device *pdev)
	246	{
	247	struct scoop_dev *sdev = platform_get_drvdata(pdev);
	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	}
	259	}
	260
	261	platform_set_drvdata(pdev, NULL);
	262	iounmap(sdev->base);
	263	kfree(sdev);
	264
	265	return 0;
	266	}
	267
	268	static struct platform_driver scoop_driver = {
	269	.probe = scoop_probe,
	270	.remove = __devexit_p(scoop_remove),
	271	.suspend = scoop_suspend,
	272	.resume = scoop_resume,
	273	.driver = {
	274	.name = "sharp-scoop",
	275	},
	276	};
	277
	278	static int __init scoop_init(void)
	279	{
	280	return platform_driver_register(&scoop_driver);
	281	}
	282
	283	subsys_initcall(scoop_init);