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

/*

    bt8xx GPIO abuser

    Copyright (C) 2008 Michael Buesch <[email protected]>

    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 = gpiochip_get_data(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 = gpiochip_get_data(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 = gpiochip_get_data(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 = gpiochip_get_data(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_data(&bg->gpio, bg);
	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);

	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 <[email protected]>
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	{
e51b5523	83	struct bt8xxgpio *bg = gpiochip_get_data(gpio);
ff1d5c2f MB	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	{
e51b5523	104	struct bt8xxgpio *bg = gpiochip_get_data(gpio);
ff1d5c2f MB	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	{
e51b5523	118	struct bt8xxgpio *bg = gpiochip_get_data(gpio);
ff1d5c2f MB	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	{
e51b5523	143	struct bt8xxgpio *bg = gpiochip_get_data(gpio);
ff1d5c2f MB	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);
e51b5523	220	err = gpiochip_add_data(&bg->gpio, bg);
ff1d5c2f MB	221	if (err) {
ff1d5c2f MB	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
ff1d5c2f	244	pci_disable_device(pdev);
ff1d5c2f MB	245	}
	246
	247	#ifdef CONFIG_PM
	248	static int bt8xxgpio_suspend(struct pci_dev *pdev, pm_message_t state)
	249	{
	250	struct bt8xxgpio *bg = pci_get_drvdata(pdev);
	251	unsigned long flags;
	252
	253	spin_lock_irqsave(&bg->lock, flags);
	254
	255	bg->saved_outen = bgread(BT848_GPIO_OUT_EN);
	256	bg->saved_data = bgread(BT848_GPIO_DATA);
	257
	258	bgwrite(0, BT848_INT_MASK);
	259	bgwrite(~0x0, BT848_INT_STAT);
	260	bgwrite(0x0, BT848_GPIO_OUT_EN);
	261
	262	spin_unlock_irqrestore(&bg->lock, flags);
	263
	264	pci_save_state(pdev);
	265	pci_disable_device(pdev);
	266	pci_set_power_state(pdev, pci_choose_state(pdev, state));
	267
	268	return 0;
	269	}
	270
	271	static int bt8xxgpio_resume(struct pci_dev *pdev)
	272	{
	273	struct bt8xxgpio *bg = pci_get_drvdata(pdev);
	274	unsigned long flags;
	275	int err;
	276
038f0bab	277	pci_set_power_state(pdev, PCI_D0);
ff1d5c2f MB	278	err = pci_enable_device(pdev);
	279	if (err)
	280	return err;
	281	pci_restore_state(pdev);
	282
	283	spin_lock_irqsave(&bg->lock, flags);
	284
	285	bgwrite(0, BT848_INT_MASK);
	286	bgwrite(0, BT848_GPIO_DMA_CTL);
	287	bgwrite(0, BT848_GPIO_REG_INP);
	288	bgwrite(bg->saved_outen, BT848_GPIO_OUT_EN);
	289	bgwrite(bg->saved_data & bg->saved_outen,
	290	BT848_GPIO_DATA);
	291
	292	spin_unlock_irqrestore(&bg->lock, flags);
	293
	294	return 0;
	295	}
	296	#else
	297	#define bt8xxgpio_suspend NULL
	298	#define bt8xxgpio_resume NULL
	299	#endif /* CONFIG_PM */
	300
14f4a883	301	static const struct pci_device_id bt8xxgpio_pci_tbl[] = {
ff1d5c2f MB	302	{ PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT848) },
	303	{ PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT849) },
	304	{ PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT878) },
	305	{ PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT879) },
	306	{ 0, },
	307	};
	308	MODULE_DEVICE_TABLE(pci, bt8xxgpio_pci_tbl);
	309
	310	static struct pci_driver bt8xxgpio_pci_driver = {
	311	.name = "bt8xxgpio",
	312	.id_table = bt8xxgpio_pci_tbl,
	313	.probe = bt8xxgpio_probe,
	314	.remove = bt8xxgpio_remove,
	315	.suspend = bt8xxgpio_suspend,
	316	.resume = bt8xxgpio_resume,
	317	};
	318
93baa65f	319	module_pci_driver(bt8xxgpio_pci_driver);
ff1d5c2f MB	320
	321	MODULE_LICENSE("GPL");
	322	MODULE_AUTHOR("Michael Buesch");
	323	MODULE_DESCRIPTION("Abuse a BT8xx framegrabber card as generic GPIO card");