[linux-2.6-block.git] / drivers / gpio / gpio-janz-ttl.c

/*
 * Janz MODULbus VMOD-TTL GPIO Driver
 *
 * Copyright (c) 2010 Ira W. Snyder <iws@ovro.caltech.edu>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/io.h>
#include <linux/gpio/driver.h>
#include <linux/slab.h>
#include <linux/bitops.h>

#include <linux/mfd/janz.h>

#define DRV_NAME "janz-ttl"

#define PORTA_DIRECTION		0x23
#define PORTB_DIRECTION		0x2B
#define PORTC_DIRECTION		0x06
#define PORTA_IOCTL		0x24
#define PORTB_IOCTL		0x2C
#define PORTC_IOCTL		0x07

#define MASTER_INT_CTL		0x00
#define MASTER_CONF_CTL		0x01

#define CONF_PAE		BIT(2)
#define CONF_PBE		BIT(7)
#define CONF_PCE		BIT(4)

struct ttl_control_regs {
	__be16 portc;
	__be16 portb;
	__be16 porta;
	__be16 control;
};

struct ttl_module {
	struct gpio_chip gpio;

	/* base address of registers */
	struct ttl_control_regs __iomem *regs;

	u8 portc_shadow;
	u8 portb_shadow;
	u8 porta_shadow;

	spinlock_t lock;
};

static int ttl_get_value(struct gpio_chip *gpio, unsigned offset)
{
	struct ttl_module *mod = dev_get_drvdata(gpio->parent);
	u8 *shadow;
	int ret;

	if (offset < 8) {
		shadow = &mod->porta_shadow;
	} else if (offset < 16) {
		shadow = &mod->portb_shadow;
		offset -= 8;
	} else {
		shadow = &mod->portc_shadow;
		offset -= 16;
	}

	spin_lock(&mod->lock);
	ret = *shadow & BIT(offset);
	spin_unlock(&mod->lock);
	return !!ret;
}

static void ttl_set_value(struct gpio_chip *gpio, unsigned offset, int value)
{
	struct ttl_module *mod = dev_get_drvdata(gpio->parent);
	void __iomem *port;
	u8 *shadow;

	if (offset < 8) {
		port = &mod->regs->porta;
		shadow = &mod->porta_shadow;
	} else if (offset < 16) {
		port = &mod->regs->portb;
		shadow = &mod->portb_shadow;
		offset -= 8;
	} else {
		port = &mod->regs->portc;
		shadow = &mod->portc_shadow;
		offset -= 16;
	}

	spin_lock(&mod->lock);
	if (value)
		*shadow |= BIT(offset);
	else
		*shadow &= ~BIT(offset);

	iowrite16be(*shadow, port);
	spin_unlock(&mod->lock);
}

static void ttl_write_reg(struct ttl_module *mod, u8 reg, u16 val)
{
	iowrite16be(reg, &mod->regs->control);
	iowrite16be(val, &mod->regs->control);
}

static void ttl_setup_device(struct ttl_module *mod)
{
	/* reset the device to a known state */
	iowrite16be(0x0000, &mod->regs->control);
	iowrite16be(0x0001, &mod->regs->control);
	iowrite16be(0x0000, &mod->regs->control);

	/* put all ports in open-drain mode */
	ttl_write_reg(mod, PORTA_IOCTL, 0x00ff);
	ttl_write_reg(mod, PORTB_IOCTL, 0x00ff);
	ttl_write_reg(mod, PORTC_IOCTL, 0x000f);

	/* set all ports as outputs */
	ttl_write_reg(mod, PORTA_DIRECTION, 0x0000);
	ttl_write_reg(mod, PORTB_DIRECTION, 0x0000);
	ttl_write_reg(mod, PORTC_DIRECTION, 0x0000);

	/* set all ports to drive zeroes */
	iowrite16be(0x0000, &mod->regs->porta);
	iowrite16be(0x0000, &mod->regs->portb);
	iowrite16be(0x0000, &mod->regs->portc);

	/* enable all ports */
	ttl_write_reg(mod, MASTER_CONF_CTL, CONF_PAE | CONF_PBE | CONF_PCE);
}

static int ttl_probe(struct platform_device *pdev)
{
	struct janz_platform_data *pdata;
	struct device *dev = &pdev->dev;
	struct ttl_module *mod;
	struct gpio_chip *gpio;
	int ret;

	pdata = dev_get_platdata(&pdev->dev);
	if (!pdata) {
		dev_err(dev, "no platform data\n");
		return -ENXIO;
	}

	mod = devm_kzalloc(dev, sizeof(*mod), GFP_KERNEL);
	if (!mod)
		return -ENOMEM;

	platform_set_drvdata(pdev, mod);
	spin_lock_init(&mod->lock);

	/* get access to the MODULbus registers for this module */
	mod->regs = devm_platform_ioremap_resource(pdev, 0);
	if (IS_ERR(mod->regs))
		return PTR_ERR(mod->regs);

	ttl_setup_device(mod);

	/* Initialize the GPIO data structures */
	gpio = &mod->gpio;
	gpio->parent = &pdev->dev;
	gpio->label = pdev->name;
	gpio->get = ttl_get_value;
	gpio->set = ttl_set_value;
	gpio->owner = THIS_MODULE;

	/* request dynamic allocation */
	gpio->base = -1;
	gpio->ngpio = 20;

	ret = devm_gpiochip_add_data(dev, gpio, NULL);
	if (ret) {
		dev_err(dev, "unable to add GPIO chip\n");
		return ret;
	}

	return 0;
}

static struct platform_driver ttl_driver = {
	.driver		= {
		.name	= DRV_NAME,
	},
	.probe		= ttl_probe,
};

module_platform_driver(ttl_driver);

MODULE_AUTHOR("Ira W. Snyder <iws@ovro.caltech.edu>");
MODULE_DESCRIPTION("Janz MODULbus VMOD-TTL Driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:janz-ttl");
Commit	Line	Data
800e69fb IS	1	/*
	2	* Janz MODULbus VMOD-TTL GPIO Driver
	3	*
	4	* Copyright (c) 2010 Ira W. Snyder <iws@ovro.caltech.edu>
	5	*
	6	* This program is free software; you can redistribute it and/or modify it
	7	* under the terms of the GNU General Public License as published by the
	8	* Free Software Foundation; either version 2 of the License, or (at your
	9	* option) any later version.
	10	*/
	11
	12	#include <linux/kernel.h>
	13	#include <linux/module.h>
	14	#include <linux/init.h>
	15	#include <linux/interrupt.h>
	16	#include <linux/delay.h>
	17	#include <linux/platform_device.h>
	18	#include <linux/io.h>
1c947b7f	19	#include <linux/gpio/driver.h>
800e69fb	20	#include <linux/slab.h>
96d0d03d	21	#include <linux/bitops.h>
800e69fb IS	22
	23	#include <linux/mfd/janz.h>
	24
	25	#define DRV_NAME "janz-ttl"
	26
	27	#define PORTA_DIRECTION 0x23
	28	#define PORTB_DIRECTION 0x2B
	29	#define PORTC_DIRECTION 0x06
	30	#define PORTA_IOCTL 0x24
	31	#define PORTB_IOCTL 0x2C
	32	#define PORTC_IOCTL 0x07
	33
	34	#define MASTER_INT_CTL 0x00
	35	#define MASTER_CONF_CTL 0x01
	36
96d0d03d LW	37	#define CONF_PAE BIT(2)
	38	#define CONF_PBE BIT(7)
	39	#define CONF_PCE BIT(4)
800e69fb IS	40
	41	struct ttl_control_regs {
	42	__be16 portc;
	43	__be16 portb;
	44	__be16 porta;
	45	__be16 control;
	46	};
	47
	48	struct ttl_module {
	49	struct gpio_chip gpio;
	50
	51	/* base address of registers */
	52	struct ttl_control_regs __iomem *regs;
	53
	54	u8 portc_shadow;
	55	u8 portb_shadow;
	56	u8 porta_shadow;
	57
	58	spinlock_t lock;
	59	};
	60
	61	static int ttl_get_value(struct gpio_chip *gpio, unsigned offset)
	62	{
58383c78	63	struct ttl_module *mod = dev_get_drvdata(gpio->parent);
800e69fb IS	64	u8 *shadow;
	65	int ret;
	66
	67	if (offset < 8) {
	68	shadow = &mod->porta_shadow;
	69	} else if (offset < 16) {
	70	shadow = &mod->portb_shadow;
	71	offset -= 8;
	72	} else {
	73	shadow = &mod->portc_shadow;
	74	offset -= 16;
	75	}
	76
	77	spin_lock(&mod->lock);
96d0d03d	78	ret = *shadow & BIT(offset);
800e69fb	79	spin_unlock(&mod->lock);
828240c2	80	return !!ret;
800e69fb IS	81	}
	82
	83	static void ttl_set_value(struct gpio_chip *gpio, unsigned offset, int value)
	84	{
58383c78	85	struct ttl_module *mod = dev_get_drvdata(gpio->parent);
800e69fb IS	86	void __iomem *port;
	87	u8 *shadow;
	88
	89	if (offset < 8) {
	90	port = &mod->regs->porta;
	91	shadow = &mod->porta_shadow;
	92	} else if (offset < 16) {
	93	port = &mod->regs->portb;
	94	shadow = &mod->portb_shadow;
	95	offset -= 8;
	96	} else {
	97	port = &mod->regs->portc;
	98	shadow = &mod->portc_shadow;
	99	offset -= 16;
	100	}
	101
	102	spin_lock(&mod->lock);
	103	if (value)
96d0d03d	104	*shadow \|= BIT(offset);
800e69fb	105	else
96d0d03d	106	*shadow &= ~BIT(offset);
800e69fb IS	107
	108	iowrite16be(*shadow, port);
	109	spin_unlock(&mod->lock);
	110	}
	111
3836309d	112	static void ttl_write_reg(struct ttl_module *mod, u8 reg, u16 val)
800e69fb IS	113	{
	114	iowrite16be(reg, &mod->regs->control);
	115	iowrite16be(val, &mod->regs->control);
	116	}
	117
3836309d	118	static void ttl_setup_device(struct ttl_module *mod)
800e69fb IS	119	{
	120	/* reset the device to a known state */
	121	iowrite16be(0x0000, &mod->regs->control);
	122	iowrite16be(0x0001, &mod->regs->control);
	123	iowrite16be(0x0000, &mod->regs->control);
	124
	125	/* put all ports in open-drain mode */
	126	ttl_write_reg(mod, PORTA_IOCTL, 0x00ff);
	127	ttl_write_reg(mod, PORTB_IOCTL, 0x00ff);
	128	ttl_write_reg(mod, PORTC_IOCTL, 0x000f);
	129
	130	/* set all ports as outputs */
	131	ttl_write_reg(mod, PORTA_DIRECTION, 0x0000);
	132	ttl_write_reg(mod, PORTB_DIRECTION, 0x0000);
	133	ttl_write_reg(mod, PORTC_DIRECTION, 0x0000);
	134
	135	/* set all ports to drive zeroes */
	136	iowrite16be(0x0000, &mod->regs->porta);
	137	iowrite16be(0x0000, &mod->regs->portb);
	138	iowrite16be(0x0000, &mod->regs->portc);
	139
	140	/* enable all ports */
	141	ttl_write_reg(mod, MASTER_CONF_CTL, CONF_PAE \| CONF_PBE \| CONF_PCE);
	142	}
	143
3836309d	144	static int ttl_probe(struct platform_device *pdev)
800e69fb IS	145	{
	146	struct janz_platform_data *pdata;
	147	struct device *dev = &pdev->dev;
	148	struct ttl_module *mod;
	149	struct gpio_chip *gpio;
800e69fb IS	150	int ret;
800e69fb IS	151
e56aee18	152	pdata = dev_get_platdata(&pdev->dev);
800e69fb IS	153	if (!pdata) {
800e69fb IS	154	dev_err(dev, "no platform data\n");
ae28193e	155	return -ENXIO;
800e69fb IS	156	}
800e69fb IS	157
ae28193e	158	mod = devm_kzalloc(dev, sizeof(*mod), GFP_KERNEL);
	159	if (!mod)
	160	return -ENOMEM;
800e69fb IS	161
	162	platform_set_drvdata(pdev, mod);
	163	spin_lock_init(&mod->lock);
	164
	165	/* get access to the MODULbus registers for this module */
38b1e680	166	mod->regs = devm_platform_ioremap_resource(pdev, 0);
ae28193e	167	if (IS_ERR(mod->regs))
ae28193e	168	return PTR_ERR(mod->regs);
800e69fb IS	169
	170	ttl_setup_device(mod);
	171
	172	/* Initialize the GPIO data structures */
	173	gpio = &mod->gpio;
58383c78	174	gpio->parent = &pdev->dev;
800e69fb IS	175	gpio->label = pdev->name;
	176	gpio->get = ttl_get_value;
	177	gpio->set = ttl_set_value;
	178	gpio->owner = THIS_MODULE;
	179
	180	/* request dynamic allocation */
	181	gpio->base = -1;
	182	gpio->ngpio = 20;
	183
abeb3f40	184	ret = devm_gpiochip_add_data(dev, gpio, NULL);
800e69fb IS	185	if (ret) {
800e69fb IS	186	dev_err(dev, "unable to add GPIO chip\n");
ae28193e	187	return ret;
800e69fb IS	188	}
800e69fb IS	189
800e69fb	190	return 0;
800e69fb IS	191	}
800e69fb IS	192
800e69fb IS	193	static struct platform_driver ttl_driver = {
	194	.driver = {
	195	.name = DRV_NAME,
800e69fb IS	196	},
800e69fb IS	197	.probe = ttl_probe,
800e69fb IS	198	};
800e69fb IS	199
6f61415e	200	module_platform_driver(ttl_driver);
800e69fb IS	201
	202	MODULE_AUTHOR("Ira W. Snyder <iws@ovro.caltech.edu>");
	203	MODULE_DESCRIPTION("Janz MODULbus VMOD-TTL Driver");
	204	MODULE_LICENSE("GPL");
	205	MODULE_ALIAS("platform:janz-ttl");