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

/*

    bt8xx GPIO abuser

    Copyright (C) 2008 Michael Buesch <mb@bu3sch.de>

    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>

/* Steal the hardware definitions from the bttv driver. */
#include "../media/video/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 = 0;
}

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

	bg = kzalloc(sizeof(*bg), 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");
		goto err_freebg;
	}
	if (!request_mem_region(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 = ioremap(pci_resource_start(dev, 0), 0x1000);
	if (!bg->mmio) {
		printk(KERN_ERR "bt8xxgpio: ioremap() failed\n");
		err = -EIO;
		goto err_release_mem;
	}

	/* 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_release_mem;
	}

	printk(KERN_INFO "bt8xxgpio: Abusing BT8xx card for GPIOs %d to %d\n",
	       bg->gpio.base, bg->gpio.base + BT8XXGPIO_NR_GPIOS - 1);

	return 0;

err_release_mem:
	release_mem_region(pci_resource_start(dev, 0),
			   pci_resource_len(dev, 0));
	pci_set_drvdata(dev, NULL);
err_disable:
	pci_disable_device(dev);
err_freebg:
	kfree(bg);

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

	pci_set_drvdata(pdev, NULL);
	kfree(bg);
}

#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, 0);
	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 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,
};

static int __init bt8xxgpio_init(void)
{
	return pci_register_driver(&bt8xxgpio_pci_driver);
}
module_init(bt8xxgpio_init)

static void __exit bt8xxgpio_exit(void)
{
	pci_unregister_driver(&bt8xxgpio_pci_driver);
}
module_exit(bt8xxgpio_exit)

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
	5	Copyright (C) 2008 Michael Buesch <mb@bu3sch.de>
	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>
ff1d5c2f MB	50
	51	/* Steal the hardware definitions from the bttv driver. */
	52	#include "../media/video/bt8xx/bt848.h"
	53
	54
	55	#define BT8XXGPIO_NR_GPIOS 24 /* We have 24 GPIO pins */
	56
	57
	58	struct bt8xxgpio {
	59	spinlock_t lock;
	60
	61	void __iomem *mmio;
	62	struct pci_dev *pdev;
	63	struct gpio_chip gpio;
	64
	65	#ifdef CONFIG_PM
	66	u32 saved_outen;
	67	u32 saved_data;
	68	#endif
	69	};
	70
	71	#define bgwrite(dat, adr) writel((dat), bg->mmio+(adr))
	72	#define bgread(adr) readl(bg->mmio+(adr))
	73
	74
	75	static int modparam_gpiobase = -1/* dynamic */;
	76	module_param_named(gpiobase, modparam_gpiobase, int, 0444);
	77	MODULE_PARM_DESC(gpiobase, "The GPIO number base. -1 means dynamic, which is the default.");
	78
	79
	80	static int bt8xxgpio_gpio_direction_input(struct gpio_chip *gpio, unsigned nr)
	81	{
	82	struct bt8xxgpio *bg = container_of(gpio, struct bt8xxgpio, gpio);
	83	unsigned long flags;
	84	u32 outen, data;
	85
	86	spin_lock_irqsave(&bg->lock, flags);
	87
	88	data = bgread(BT848_GPIO_DATA);
	89	data &= ~(1 << nr);
	90	bgwrite(data, BT848_GPIO_DATA);
	91
	92	outen = bgread(BT848_GPIO_OUT_EN);
	93	outen &= ~(1 << nr);
	94	bgwrite(outen, BT848_GPIO_OUT_EN);
	95
	96	spin_unlock_irqrestore(&bg->lock, flags);
	97
	98	return 0;
	99	}
	100
	101	static int bt8xxgpio_gpio_get(struct gpio_chip *gpio, unsigned nr)
	102	{
	103	struct bt8xxgpio *bg = container_of(gpio, struct bt8xxgpio, gpio);
	104	unsigned long flags;
	105	u32 val;
	106
	107	spin_lock_irqsave(&bg->lock, flags);
	108	val = bgread(BT848_GPIO_DATA);
	109	spin_unlock_irqrestore(&bg->lock, flags);
	110
	111	return !!(val & (1 << nr));
	112	}
	113
114	static int bt8xxgpio_gpio_direction_output(struct gpio_chip *gpio,
115	unsigned nr, int val)
116	{
117	struct bt8xxgpio *bg = container_of(gpio, struct bt8xxgpio, gpio);
118	unsigned long flags;
119	u32 outen, data;
120
121	spin_lock_irqsave(&bg->lock, flags);
122
123	outen = bgread(BT848_GPIO_OUT_EN);
124	outen \|= (1 << nr);
125	bgwrite(outen, BT848_GPIO_OUT_EN);
126
127	data = bgread(BT848_GPIO_DATA);
128	if (val)
129	data \|= (1 << nr);
130	else
131	data &= ~(1 << nr);
132	bgwrite(data, BT848_GPIO_DATA);
133
134	spin_unlock_irqrestore(&bg->lock, flags);
135
136	return 0;
137	}
138
139	static void bt8xxgpio_gpio_set(struct gpio_chip *gpio,
140	unsigned nr, int val)
141	{
142	struct bt8xxgpio *bg = container_of(gpio, struct bt8xxgpio, gpio);
143	unsigned long flags;
144	u32 data;
145
146	spin_lock_irqsave(&bg->lock, flags);
147
148	data = bgread(BT848_GPIO_DATA);
149	if (val)
150	data \|= (1 << nr);
151	else
152	data &= ~(1 << nr);
153	bgwrite(data, BT848_GPIO_DATA);
154
155	spin_unlock_irqrestore(&bg->lock, flags);
156	}
157
158	static void bt8xxgpio_gpio_setup(struct bt8xxgpio *bg)
159	{
160	struct gpio_chip *c = &bg->gpio;
161
3e274bd0	162	c->label = dev_name(&bg->pdev->dev);
ff1d5c2f MB	163	c->owner = THIS_MODULE;
	164	c->direction_input = bt8xxgpio_gpio_direction_input;
	165	c->get = bt8xxgpio_gpio_get;
	166	c->direction_output = bt8xxgpio_gpio_direction_output;
	167	c->set = bt8xxgpio_gpio_set;
	168	c->dbg_show = NULL;
	169	c->base = modparam_gpiobase;
	170	c->ngpio = BT8XXGPIO_NR_GPIOS;
	171	c->can_sleep = 0;
	172	}
	173
	174	static int bt8xxgpio_probe(struct pci_dev *dev,
	175	const struct pci_device_id *pci_id)
	176	{
	177	struct bt8xxgpio *bg;
	178	int err;
	179
	180	bg = kzalloc(sizeof(*bg), GFP_KERNEL);
	181	if (!bg)
	182	return -ENOMEM;
	183
	184	bg->pdev = dev;
	185	spin_lock_init(&bg->lock);
	186
	187	err = pci_enable_device(dev);
	188	if (err) {
	189	printk(KERN_ERR "bt8xxgpio: Can't enable device.\n");
	190	goto err_freebg;
	191	}
	192	if (!request_mem_region(pci_resource_start(dev, 0),
	193	pci_resource_len(dev, 0),
	194	"bt8xxgpio")) {
	195	printk(KERN_WARNING "bt8xxgpio: Can't request iomem (0x%llx).\n",
	196	(unsigned long long)pci_resource_start(dev, 0));
	197	err = -EBUSY;
	198	goto err_disable;
	199	}
	200	pci_set_master(dev);
	201	pci_set_drvdata(dev, bg);
	202
	203	bg->mmio = ioremap(pci_resource_start(dev, 0), 0x1000);
	204	if (!bg->mmio) {
	205	printk(KERN_ERR "bt8xxgpio: ioremap() failed\n");
	206	err = -EIO;
	207	goto err_release_mem;
	208	}
	209
	210	/* Disable interrupts */
	211	bgwrite(0, BT848_INT_MASK);
	212
	213	/* gpio init */
	214	bgwrite(0, BT848_GPIO_DMA_CTL);
	215	bgwrite(0, BT848_GPIO_REG_INP);
	216	bgwrite(0, BT848_GPIO_OUT_EN);
	217
	218	bt8xxgpio_gpio_setup(bg);
	219	err = gpiochip_add(&bg->gpio);
	220	if (err) {
	221	printk(KERN_ERR "bt8xxgpio: Failed to register GPIOs\n");
	222	goto err_release_mem;
	223	}
	224
	225	printk(KERN_INFO "bt8xxgpio: Abusing BT8xx card for GPIOs %d to %d\n",
	226	bg->gpio.base, bg->gpio.base + BT8XXGPIO_NR_GPIOS - 1);
227
228	return 0;
229
230	err_release_mem:
231	release_mem_region(pci_resource_start(dev, 0),
232	pci_resource_len(dev, 0));
233	pci_set_drvdata(dev, NULL);
234	err_disable:
235	pci_disable_device(dev);
236	err_freebg:
237	kfree(bg);
238
239	return err;
240	}
241
242	static void bt8xxgpio_remove(struct pci_dev *pdev)
243	{
244	struct bt8xxgpio *bg = pci_get_drvdata(pdev);
245
246	gpiochip_remove(&bg->gpio);
247
248	bgwrite(0, BT848_INT_MASK);
249	bgwrite(~0x0, BT848_INT_STAT);
250	bgwrite(0x0, BT848_GPIO_OUT_EN);
251
252	iounmap(bg->mmio);
253	release_mem_region(pci_resource_start(pdev, 0),
254	pci_resource_len(pdev, 0));
255	pci_disable_device(pdev);
256
257	pci_set_drvdata(pdev, NULL);
258	kfree(bg);
259	}
260
261	#ifdef CONFIG_PM
262	static int bt8xxgpio_suspend(struct pci_dev *pdev, pm_message_t state)
263	{
264	struct bt8xxgpio *bg = pci_get_drvdata(pdev);
265	unsigned long flags;
266
267	spin_lock_irqsave(&bg->lock, flags);
268
269	bg->saved_outen = bgread(BT848_GPIO_OUT_EN);
270	bg->saved_data = bgread(BT848_GPIO_DATA);
271
272	bgwrite(0, BT848_INT_MASK);
273	bgwrite(~0x0, BT848_INT_STAT);
274	bgwrite(0x0, BT848_GPIO_OUT_EN);
275
276	spin_unlock_irqrestore(&bg->lock, flags);
277
278	pci_save_state(pdev);
279	pci_disable_device(pdev);
280	pci_set_power_state(pdev, pci_choose_state(pdev, state));
281
282	return 0;
283	}
284
285	static int bt8xxgpio_resume(struct pci_dev *pdev)
286	{
287	struct bt8xxgpio *bg = pci_get_drvdata(pdev);
288	unsigned long flags;
289	int err;
290
291	pci_set_power_state(pdev, 0);
292	err = pci_enable_device(pdev);
293	if (err)
294	return err;
295	pci_restore_state(pdev);
296
297	spin_lock_irqsave(&bg->lock, flags);
298
299	bgwrite(0, BT848_INT_MASK);
300	bgwrite(0, BT848_GPIO_DMA_CTL);
301	bgwrite(0, BT848_GPIO_REG_INP);
302	bgwrite(bg->saved_outen, BT848_GPIO_OUT_EN);
303	bgwrite(bg->saved_data & bg->saved_outen,
304	BT848_GPIO_DATA);
305
306	spin_unlock_irqrestore(&bg->lock, flags);
307
308	return 0;
309	}
310	#else
311	#define bt8xxgpio_suspend NULL
312	#define bt8xxgpio_resume NULL
313	#endif /* CONFIG_PM */
314
315	static struct pci_device_id bt8xxgpio_pci_tbl[] = {
316	{ PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT848) },
317	{ PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT849) },
318	{ PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT878) },
319	{ PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT879) },
320	{ 0, },
321	};
322	MODULE_DEVICE_TABLE(pci, bt8xxgpio_pci_tbl);
323
324	static struct pci_driver bt8xxgpio_pci_driver = {
325	.name = "bt8xxgpio",
326	.id_table = bt8xxgpio_pci_tbl,
327	.probe = bt8xxgpio_probe,
328	.remove = bt8xxgpio_remove,
329	.suspend = bt8xxgpio_suspend,
330	.resume = bt8xxgpio_resume,
331	};
332
59f6a6c6	333	static int __init bt8xxgpio_init(void)
ff1d5c2f MB	334	{
	335	return pci_register_driver(&bt8xxgpio_pci_driver);
	336	}
	337	module_init(bt8xxgpio_init)
	338
59f6a6c6	339	static void __exit bt8xxgpio_exit(void)
ff1d5c2f MB	340	{
	341	pci_unregister_driver(&bt8xxgpio_pci_driver);
	342	}
	343	module_exit(bt8xxgpio_exit)
	344
	345	MODULE_LICENSE("GPL");
	346	MODULE_AUTHOR("Michael Buesch");
	347	MODULE_DESCRIPTION("Abuse a BT8xx framegrabber card as generic GPIO card");