drivers/gpio/bt8xxgpio.c

   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>
  49 #include <linux/gpio.h>
  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
 162         c->label = dev_name(&bg->pdev->dev);
 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
 333 static int __init bt8xxgpio_init(void)
 334 {
 335         return pci_register_driver(&bt8xxgpio_pci_driver);
 336 }
 337 module_init(bt8xxgpio_init)
 338
 339 static void __exit bt8xxgpio_exit(void)
 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");