[deliverable/linux.git] / drivers / gpio / gpio-bt8xx.c

/*

    bt8xx GPIO abuser

    Copyright (C) 2008 Michael Buesch <m@bues.ch>

    Please do _only_ contact the people listed _above_ with issues related to this driver.
    All the other people listed below are not related to this driver. Their names
    are only here, because this driver is derived from the bt848 driver.


    Derived from the bt848 driver:

    Copyright (C) 1996,97,98 Ralph  Metzler
			   & Marcus Metzler
    (c) 1999-2002 Gerd Knorr

    some v4l2 code lines are taken from Justin's bttv2 driver which is
    (c) 2000 Justin Schoeman

    V4L1 removal from:
    (c) 2005-2006 Nickolay V. Shmyrev

    Fixes to be fully V4L2 compliant by
    (c) 2006 Mauro Carvalho Chehab

    Cropping and overscan support
    Copyright (C) 2005, 2006 Michael H. Schimek
    Sponsored by OPQ Systems AB

    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.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include <linux/module.h>
#include <linux/pci.h>
#include <linux/spinlock.h>
#include <linux/gpio.h>
#include <linux/slab.h>

/* Steal the hardware definitions from the bttv driver. */
#include "../media/pci/bt8xx/bt848.h"


#define BT8XXGPIO_NR_GPIOS		24 /* We have 24 GPIO pins */


struct bt8xxgpio {
	spinlock_t lock;

	void __iomem *mmio;
	struct pci_dev *pdev;
	struct gpio_chip gpio;

#ifdef CONFIG_PM
	u32 saved_outen;
	u32 saved_data;
#endif
};

#define bgwrite(dat, adr)	writel((dat), bg->mmio+(adr))
#define bgread(adr)		readl(bg->mmio+(adr))


static int modparam_gpiobase = -1/* dynamic */;
module_param_named(gpiobase, modparam_gpiobase, int, 0444);
MODULE_PARM_DESC(gpiobase, "The GPIO number base. -1 means dynamic, which is the default.");


static int bt8xxgpio_gpio_direction_input(struct gpio_chip *gpio, unsigned nr)
{
	struct bt8xxgpio *bg = container_of(gpio, struct bt8xxgpio, gpio);
	unsigned long flags;
	u32 outen, data;

	spin_lock_irqsave(&bg->lock, flags);

	data = bgread(BT848_GPIO_DATA);
	data &= ~(1 << nr);
	bgwrite(data, BT848_GPIO_DATA);

	outen = bgread(BT848_GPIO_OUT_EN);
	outen &= ~(1 << nr);
	bgwrite(outen, BT848_GPIO_OUT_EN);

	spin_unlock_irqrestore(&bg->lock, flags);

	return 0;
}

static int bt8xxgpio_gpio_get(struct gpio_chip *gpio, unsigned nr)
{
	struct bt8xxgpio *bg = container_of(gpio, struct bt8xxgpio, gpio);
	unsigned long flags;
	u32 val;

	spin_lock_irqsave(&bg->lock, flags);
	val = bgread(BT848_GPIO_DATA);
	spin_unlock_irqrestore(&bg->lock, flags);

	return !!(val & (1 << nr));
}

static int bt8xxgpio_gpio_direction_output(struct gpio_chip *gpio,
					unsigned nr, int val)
{
	struct bt8xxgpio *bg = container_of(gpio, struct bt8xxgpio, gpio);
	unsigned long flags;
	u32 outen, data;

	spin_lock_irqsave(&bg->lock, flags);

	outen = bgread(BT848_GPIO_OUT_EN);
	outen |= (1 << nr);
	bgwrite(outen, BT848_GPIO_OUT_EN);

	data = bgread(BT848_GPIO_DATA);
	if (val)
		data |= (1 << nr);
	else
		data &= ~(1 << nr);
	bgwrite(data, BT848_GPIO_DATA);

	spin_unlock_irqrestore(&bg->lock, flags);

	return 0;
}

static void bt8xxgpio_gpio_set(struct gpio_chip *gpio,
			    unsigned nr, int val)
{
	struct bt8xxgpio *bg = container_of(gpio, struct bt8xxgpio, gpio);
	unsigned long flags;
	u32 data;

	spin_lock_irqsave(&bg->lock, flags);

	data = bgread(BT848_GPIO_DATA);
	if (val)
		data |= (1 << nr);
	else
		data &= ~(1 << nr);
	bgwrite(data, BT848_GPIO_DATA);

	spin_unlock_irqrestore(&bg->lock, flags);
}

static void bt8xxgpio_gpio_setup(struct bt8xxgpio *bg)
{
	struct gpio_chip *c = &bg->gpio;

	c->label = dev_name(&bg->pdev->dev);
	c->owner = THIS_MODULE;
	c->direction_input = bt8xxgpio_gpio_direction_input;
	c->get = bt8xxgpio_gpio_get;
	c->direction_output = bt8xxgpio_gpio_direction_output;
	c->set = bt8xxgpio_gpio_set;
	c->dbg_show = NULL;
	c->base = modparam_gpiobase;
	c->ngpio = BT8XXGPIO_NR_GPIOS;
	c->can_sleep = false;
}

static int bt8xxgpio_probe(struct pci_dev *dev,
			const struct pci_device_id *pci_id)
{
	struct bt8xxgpio *bg;
	int err;

	bg = devm_kzalloc(&dev->dev, sizeof(struct bt8xxgpio), GFP_KERNEL);
	if (!bg)
		return -ENOMEM;

	bg->pdev = dev;
	spin_lock_init(&bg->lock);

	err = pci_enable_device(dev);
	if (err) {
		printk(KERN_ERR "bt8xxgpio: Can't enable device.\n");
		return err;
	}
	if (!devm_request_mem_region(&dev->dev, pci_resource_start(dev, 0),
				pci_resource_len(dev, 0),
				"bt8xxgpio")) {
		printk(KERN_WARNING "bt8xxgpio: Can't request iomem (0x%llx).\n",
		       (unsigned long long)pci_resource_start(dev, 0));
		err = -EBUSY;
		goto err_disable;
	}
	pci_set_master(dev);
	pci_set_drvdata(dev, bg);

	bg->mmio = devm_ioremap(&dev->dev, pci_resource_start(dev, 0), 0x1000);
	if (!bg->mmio) {
		printk(KERN_ERR "bt8xxgpio: ioremap() failed\n");
		err = -EIO;
		goto err_disable;
	}

	/* Disable interrupts */
	bgwrite(0, BT848_INT_MASK);

	/* gpio init */
	bgwrite(0, BT848_GPIO_DMA_CTL);
	bgwrite(0, BT848_GPIO_REG_INP);
	bgwrite(0, BT848_GPIO_OUT_EN);

	bt8xxgpio_gpio_setup(bg);
	err = gpiochip_add(&bg->gpio);
	if (err) {
		printk(KERN_ERR "bt8xxgpio: Failed to register GPIOs\n");
		goto err_disable;
	}

	return 0;

err_disable:
	pci_disable_device(dev);

	return err;
}

static void bt8xxgpio_remove(struct pci_dev *pdev)
{
	struct bt8xxgpio *bg = pci_get_drvdata(pdev);

	gpiochip_remove(&bg->gpio);

	bgwrite(0, BT848_INT_MASK);
	bgwrite(~0x0, BT848_INT_STAT);
	bgwrite(0x0, BT848_GPIO_OUT_EN);

	iounmap(bg->mmio);
	release_mem_region(pci_resource_start(pdev, 0),
			   pci_resource_len(pdev, 0));
	pci_disable_device(pdev);
}

#ifdef CONFIG_PM
static int bt8xxgpio_suspend(struct pci_dev *pdev, pm_message_t state)
{
	struct bt8xxgpio *bg = pci_get_drvdata(pdev);
	unsigned long flags;

	spin_lock_irqsave(&bg->lock, flags);

	bg->saved_outen = bgread(BT848_GPIO_OUT_EN);
	bg->saved_data = bgread(BT848_GPIO_DATA);

	bgwrite(0, BT848_INT_MASK);
	bgwrite(~0x0, BT848_INT_STAT);
	bgwrite(0x0, BT848_GPIO_OUT_EN);

	spin_unlock_irqrestore(&bg->lock, flags);

	pci_save_state(pdev);
	pci_disable_device(pdev);
	pci_set_power_state(pdev, pci_choose_state(pdev, state));

	return 0;
}

static int bt8xxgpio_resume(struct pci_dev *pdev)
{
	struct bt8xxgpio *bg = pci_get_drvdata(pdev);
	unsigned long flags;
	int err;

	pci_set_power_state(pdev, PCI_D0);
	err = pci_enable_device(pdev);
	if (err)
		return err;
	pci_restore_state(pdev);

	spin_lock_irqsave(&bg->lock, flags);

	bgwrite(0, BT848_INT_MASK);
	bgwrite(0, BT848_GPIO_DMA_CTL);
	bgwrite(0, BT848_GPIO_REG_INP);
	bgwrite(bg->saved_outen, BT848_GPIO_OUT_EN);
	bgwrite(bg->saved_data & bg->saved_outen,
		BT848_GPIO_DATA);

	spin_unlock_irqrestore(&bg->lock, flags);

	return 0;
}
#else
#define bt8xxgpio_suspend NULL
#define bt8xxgpio_resume NULL
#endif /* CONFIG_PM */

static const struct pci_device_id bt8xxgpio_pci_tbl[] = {
	{ PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT848) },
	{ PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT849) },
	{ PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT878) },
	{ PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT879) },
	{ 0, },
};
MODULE_DEVICE_TABLE(pci, bt8xxgpio_pci_tbl);

static struct pci_driver bt8xxgpio_pci_driver = {
	.name		= "bt8xxgpio",
	.id_table	= bt8xxgpio_pci_tbl,
	.probe		= bt8xxgpio_probe,
	.remove		= bt8xxgpio_remove,
	.suspend	= bt8xxgpio_suspend,
	.resume		= bt8xxgpio_resume,
};

module_pci_driver(bt8xxgpio_pci_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Michael Buesch");
MODULE_DESCRIPTION("Abuse a BT8xx framegrabber card as generic GPIO card");
Commit	Line	Data
ff1d5c2f MB	1	/*
	2
	3	bt8xx GPIO abuser
	4
eb032b98	5	Copyright (C) 2008 Michael Buesch <m@bues.ch>
ff1d5c2f MB	6
	7	Please do _only_ contact the people listed _above_ with issues related to this driver.
	8	All the other people listed below are not related to this driver. Their names
	9	are only here, because this driver is derived from the bt848 driver.
	10
	11
	12	Derived from the bt848 driver:
	13
	14	Copyright (C) 1996,97,98 Ralph Metzler
	15	& Marcus Metzler
	16	(c) 1999-2002 Gerd Knorr
	17
	18	some v4l2 code lines are taken from Justin's bttv2 driver which is
	19	(c) 2000 Justin Schoeman
	20
	21	V4L1 removal from:
	22	(c) 2005-2006 Nickolay V. Shmyrev
	23
	24	Fixes to be fully V4L2 compliant by
	25	(c) 2006 Mauro Carvalho Chehab
	26
	27	Cropping and overscan support
	28	Copyright (C) 2005, 2006 Michael H. Schimek
	29	Sponsored by OPQ Systems AB
	30
	31	This program is free software; you can redistribute it and/or modify
	32	it under the terms of the GNU General Public License as published by
	33	the Free Software Foundation; either version 2 of the License, or
	34	(at your option) any later version.
	35
	36	This program is distributed in the hope that it will be useful,
	37	but WITHOUT ANY WARRANTY; without even the implied warranty of
	38	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	39	GNU General Public License for more details.
	40
	41	You should have received a copy of the GNU General Public License
	42	along with this program; if not, write to the Free Software
	43	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	44	*/
	45
	46	#include <linux/module.h>
	47	#include <linux/pci.h>
	48	#include <linux/spinlock.h>
d120c17f	49	#include <linux/gpio.h>
5a0e3ad6	50	#include <linux/slab.h>
ff1d5c2f MB	51
ff1d5c2f MB	52	/* Steal the hardware definitions from the bttv driver. */
52d32258	53	#include "../media/pci/bt8xx/bt848.h"
ff1d5c2f MB	54
	55
	56	#define BT8XXGPIO_NR_GPIOS 24 /* We have 24 GPIO pins */
	57
	58
	59	struct bt8xxgpio {
	60	spinlock_t lock;
	61
	62	void __iomem *mmio;
	63	struct pci_dev *pdev;
	64	struct gpio_chip gpio;
	65
	66	#ifdef CONFIG_PM
	67	u32 saved_outen;
	68	u32 saved_data;
	69	#endif
	70	};
	71
	72	#define bgwrite(dat, adr) writel((dat), bg->mmio+(adr))
	73	#define bgread(adr) readl(bg->mmio+(adr))
	74
	75
	76	static int modparam_gpiobase = -1/* dynamic */;
	77	module_param_named(gpiobase, modparam_gpiobase, int, 0444);
	78	MODULE_PARM_DESC(gpiobase, "The GPIO number base. -1 means dynamic, which is the default.");
	79
	80
	81	static int bt8xxgpio_gpio_direction_input(struct gpio_chip *gpio, unsigned nr)
	82	{
	83	struct bt8xxgpio *bg = container_of(gpio, struct bt8xxgpio, gpio);
	84	unsigned long flags;
	85	u32 outen, data;
	86
	87	spin_lock_irqsave(&bg->lock, flags);
	88
	89	data = bgread(BT848_GPIO_DATA);
	90	data &= ~(1 << nr);
	91	bgwrite(data, BT848_GPIO_DATA);
	92
	93	outen = bgread(BT848_GPIO_OUT_EN);
	94	outen &= ~(1 << nr);
	95	bgwrite(outen, BT848_GPIO_OUT_EN);
	96
	97	spin_unlock_irqrestore(&bg->lock, flags);
	98
	99	return 0;
	100	}
	101
	102	static int bt8xxgpio_gpio_get(struct gpio_chip *gpio, unsigned nr)
	103	{
	104	struct bt8xxgpio *bg = container_of(gpio, struct bt8xxgpio, gpio);
	105	unsigned long flags;
	106	u32 val;
	107
	108	spin_lock_irqsave(&bg->lock, flags);
	109	val = bgread(BT848_GPIO_DATA);
	110	spin_unlock_irqrestore(&bg->lock, flags);
	111
	112	return !!(val & (1 << nr));
	113	}
	114
	115	static int bt8xxgpio_gpio_direction_output(struct gpio_chip *gpio,
	116	unsigned nr, int val)
	117	{
118	struct bt8xxgpio *bg = container_of(gpio, struct bt8xxgpio, gpio);
119	unsigned long flags;
120	u32 outen, data;
121
122	spin_lock_irqsave(&bg->lock, flags);
123
124	outen = bgread(BT848_GPIO_OUT_EN);
125	outen \|= (1 << nr);
126	bgwrite(outen, BT848_GPIO_OUT_EN);
127
128	data = bgread(BT848_GPIO_DATA);
129	if (val)
130	data \|= (1 << nr);
131	else
132	data &= ~(1 << nr);
133	bgwrite(data, BT848_GPIO_DATA);
134
135	spin_unlock_irqrestore(&bg->lock, flags);
136
137	return 0;
138	}
139
140	static void bt8xxgpio_gpio_set(struct gpio_chip *gpio,
141	unsigned nr, int val)
142	{
143	struct bt8xxgpio *bg = container_of(gpio, struct bt8xxgpio, gpio);
144	unsigned long flags;
145	u32 data;
146
147	spin_lock_irqsave(&bg->lock, flags);
148
149	data = bgread(BT848_GPIO_DATA);
150	if (val)
151	data \|= (1 << nr);
152	else
153	data &= ~(1 << nr);
154	bgwrite(data, BT848_GPIO_DATA);
155
156	spin_unlock_irqrestore(&bg->lock, flags);
157	}
158
159	static void bt8xxgpio_gpio_setup(struct bt8xxgpio *bg)
160	{
161	struct gpio_chip *c = &bg->gpio;
162
3e274bd0	163	c->label = dev_name(&bg->pdev->dev);
ff1d5c2f MB	164	c->owner = THIS_MODULE;
	165	c->direction_input = bt8xxgpio_gpio_direction_input;
	166	c->get = bt8xxgpio_gpio_get;
	167	c->direction_output = bt8xxgpio_gpio_direction_output;
	168	c->set = bt8xxgpio_gpio_set;
	169	c->dbg_show = NULL;
	170	c->base = modparam_gpiobase;
	171	c->ngpio = BT8XXGPIO_NR_GPIOS;
9fb1f39e	172	c->can_sleep = false;
ff1d5c2f MB	173	}
	174
	175	static int bt8xxgpio_probe(struct pci_dev *dev,
	176	const struct pci_device_id *pci_id)
	177	{
	178	struct bt8xxgpio *bg;
	179	int err;
	180
a435e180	181	bg = devm_kzalloc(&dev->dev, sizeof(struct bt8xxgpio), GFP_KERNEL);
ff1d5c2f MB	182	if (!bg)
	183	return -ENOMEM;
	184
	185	bg->pdev = dev;
	186	spin_lock_init(&bg->lock);
	187
	188	err = pci_enable_device(dev);
	189	if (err) {
	190	printk(KERN_ERR "bt8xxgpio: Can't enable device.\n");
a435e180	191	return err;
ff1d5c2f	192	}
a435e180	193	if (!devm_request_mem_region(&dev->dev, pci_resource_start(dev, 0),
ff1d5c2f MB	194	pci_resource_len(dev, 0),
	195	"bt8xxgpio")) {
	196	printk(KERN_WARNING "bt8xxgpio: Can't request iomem (0x%llx).\n",
	197	(unsigned long long)pci_resource_start(dev, 0));
	198	err = -EBUSY;
	199	goto err_disable;
	200	}
	201	pci_set_master(dev);
	202	pci_set_drvdata(dev, bg);
	203
a435e180	204	bg->mmio = devm_ioremap(&dev->dev, pci_resource_start(dev, 0), 0x1000);
ff1d5c2f MB	205	if (!bg->mmio) {
	206	printk(KERN_ERR "bt8xxgpio: ioremap() failed\n");
	207	err = -EIO;
a435e180	208	goto err_disable;
ff1d5c2f MB	209	}
	210
	211	/* Disable interrupts */
	212	bgwrite(0, BT848_INT_MASK);
	213
	214	/* gpio init */
	215	bgwrite(0, BT848_GPIO_DMA_CTL);
	216	bgwrite(0, BT848_GPIO_REG_INP);
	217	bgwrite(0, BT848_GPIO_OUT_EN);
	218
	219	bt8xxgpio_gpio_setup(bg);
	220	err = gpiochip_add(&bg->gpio);
	221	if (err) {
	222	printk(KERN_ERR "bt8xxgpio: Failed to register GPIOs\n");
a435e180	223	goto err_disable;
ff1d5c2f MB	224	}
ff1d5c2f MB	225
ff1d5c2f MB	226	return 0;
ff1d5c2f MB	227
ff1d5c2f MB	228	err_disable:
ff1d5c2f MB	229	pci_disable_device(dev);
ff1d5c2f MB	230
	231	return err;
	232	}
	233
	234	static void bt8xxgpio_remove(struct pci_dev *pdev)
	235	{
	236	struct bt8xxgpio *bg = pci_get_drvdata(pdev);
	237
	238	gpiochip_remove(&bg->gpio);
	239
	240	bgwrite(0, BT848_INT_MASK);
	241	bgwrite(~0x0, BT848_INT_STAT);
	242	bgwrite(0x0, BT848_GPIO_OUT_EN);
	243
	244	iounmap(bg->mmio);
	245	release_mem_region(pci_resource_start(pdev, 0),
	246	pci_resource_len(pdev, 0));
	247	pci_disable_device(pdev);
ff1d5c2f MB	248	}
	249
	250	#ifdef CONFIG_PM
	251	static int bt8xxgpio_suspend(struct pci_dev *pdev, pm_message_t state)
	252	{
	253	struct bt8xxgpio *bg = pci_get_drvdata(pdev);
	254	unsigned long flags;
	255
	256	spin_lock_irqsave(&bg->lock, flags);
	257
	258	bg->saved_outen = bgread(BT848_GPIO_OUT_EN);
	259	bg->saved_data = bgread(BT848_GPIO_DATA);
	260
	261	bgwrite(0, BT848_INT_MASK);
	262	bgwrite(~0x0, BT848_INT_STAT);
	263	bgwrite(0x0, BT848_GPIO_OUT_EN);
	264
	265	spin_unlock_irqrestore(&bg->lock, flags);
	266
	267	pci_save_state(pdev);
	268	pci_disable_device(pdev);
	269	pci_set_power_state(pdev, pci_choose_state(pdev, state));
	270
	271	return 0;
	272	}
	273
	274	static int bt8xxgpio_resume(struct pci_dev *pdev)
	275	{
	276	struct bt8xxgpio *bg = pci_get_drvdata(pdev);
	277	unsigned long flags;
	278	int err;
	279
038f0bab	280	pci_set_power_state(pdev, PCI_D0);
ff1d5c2f MB	281	err = pci_enable_device(pdev);
	282	if (err)
	283	return err;
	284	pci_restore_state(pdev);
	285
	286	spin_lock_irqsave(&bg->lock, flags);
	287
	288	bgwrite(0, BT848_INT_MASK);
	289	bgwrite(0, BT848_GPIO_DMA_CTL);
	290	bgwrite(0, BT848_GPIO_REG_INP);
	291	bgwrite(bg->saved_outen, BT848_GPIO_OUT_EN);
	292	bgwrite(bg->saved_data & bg->saved_outen,
	293	BT848_GPIO_DATA);
	294
	295	spin_unlock_irqrestore(&bg->lock, flags);
	296
	297	return 0;
	298	}
	299	#else
	300	#define bt8xxgpio_suspend NULL
	301	#define bt8xxgpio_resume NULL
	302	#endif /* CONFIG_PM */
	303
14f4a883	304	static const struct pci_device_id bt8xxgpio_pci_tbl[] = {
ff1d5c2f MB	305	{ PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT848) },
	306	{ PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT849) },
	307	{ PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT878) },
	308	{ PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT879) },
	309	{ 0, },
	310	};
	311	MODULE_DEVICE_TABLE(pci, bt8xxgpio_pci_tbl);
	312
	313	static struct pci_driver bt8xxgpio_pci_driver = {
	314	.name = "bt8xxgpio",
	315	.id_table = bt8xxgpio_pci_tbl,
	316	.probe = bt8xxgpio_probe,
	317	.remove = bt8xxgpio_remove,
	318	.suspend = bt8xxgpio_suspend,
	319	.resume = bt8xxgpio_resume,
	320	};
	321
93baa65f	322	module_pci_driver(bt8xxgpio_pci_driver);
ff1d5c2f MB	323
	324	MODULE_LICENSE("GPL");
	325	MODULE_AUTHOR("Michael Buesch");
	326	MODULE_DESCRIPTION("Abuse a BT8xx framegrabber card as generic GPIO card");