drivers/gpio/gpio-bt8xx.c

   1 /*
   2
   3     bt8xx GPIO abuser
   4
   5     Copyright (C) 2008 Michael Buesch <m@bues.ch>
   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 #include <linux/slab.h>
  51
  52 /* Steal the hardware definitions from the bttv driver. */
  53 #include "../media/pci/bt8xx/bt848.h"
  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
 163         c->label = dev_name(&bg->pdev->dev);
 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;
 172         c->can_sleep = false;
 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
 181         bg = kzalloc(sizeof(*bg), GFP_KERNEL);
 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");
 191                 goto err_freebg;
 192         }
 193         if (!request_mem_region(pci_resource_start(dev, 0),
 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
 204         bg->mmio = ioremap(pci_resource_start(dev, 0), 0x1000);
 205         if (!bg->mmio) {
 206                 printk(KERN_ERR "bt8xxgpio: ioremap() failed\n");
 207                 err = -EIO;
 208                 goto err_release_mem;
 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");
 223                 goto err_release_mem;
 224         }
 225
 226         return 0;
 227
 228 err_release_mem:
 229         release_mem_region(pci_resource_start(dev, 0),
 230                            pci_resource_len(dev, 0));
 231 err_disable:
 232         pci_disable_device(dev);
 233 err_freebg:
 234         kfree(bg);
 235
 236         return err;
 237 }
 238
 239 static void bt8xxgpio_remove(struct pci_dev *pdev)
 240 {
 241         struct bt8xxgpio *bg = pci_get_drvdata(pdev);
 242
 243         gpiochip_remove(&bg->gpio);
 244
 245         bgwrite(0, BT848_INT_MASK);
 246         bgwrite(~0x0, BT848_INT_STAT);
 247         bgwrite(0x0, BT848_GPIO_OUT_EN);
 248
 249         iounmap(bg->mmio);
 250         release_mem_region(pci_resource_start(pdev, 0),
 251                            pci_resource_len(pdev, 0));
 252         pci_disable_device(pdev);
 253
 254         kfree(bg);
 255 }
 256
 257 #ifdef CONFIG_PM
 258 static int bt8xxgpio_suspend(struct pci_dev *pdev, pm_message_t state)
 259 {
 260         struct bt8xxgpio *bg = pci_get_drvdata(pdev);
 261         unsigned long flags;
 262
 263         spin_lock_irqsave(&bg->lock, flags);
 264
 265         bg->saved_outen = bgread(BT848_GPIO_OUT_EN);
 266         bg->saved_data = bgread(BT848_GPIO_DATA);
 267
 268         bgwrite(0, BT848_INT_MASK);
 269         bgwrite(~0x0, BT848_INT_STAT);
 270         bgwrite(0x0, BT848_GPIO_OUT_EN);
 271
 272         spin_unlock_irqrestore(&bg->lock, flags);
 273
 274         pci_save_state(pdev);
 275         pci_disable_device(pdev);
 276         pci_set_power_state(pdev, pci_choose_state(pdev, state));
 277
 278         return 0;
 279 }
 280
 281 static int bt8xxgpio_resume(struct pci_dev *pdev)
 282 {
 283         struct bt8xxgpio *bg = pci_get_drvdata(pdev);
 284         unsigned long flags;
 285         int err;
 286
 287         pci_set_power_state(pdev, PCI_D0);
 288         err = pci_enable_device(pdev);
 289         if (err)
 290                 return err;
 291         pci_restore_state(pdev);
 292
 293         spin_lock_irqsave(&bg->lock, flags);
 294
 295         bgwrite(0, BT848_INT_MASK);
 296         bgwrite(0, BT848_GPIO_DMA_CTL);
 297         bgwrite(0, BT848_GPIO_REG_INP);
 298         bgwrite(bg->saved_outen, BT848_GPIO_OUT_EN);
 299         bgwrite(bg->saved_data & bg->saved_outen,
 300                 BT848_GPIO_DATA);
 301
 302         spin_unlock_irqrestore(&bg->lock, flags);
 303
 304         return 0;
 305 }
 306 #else
 307 #define bt8xxgpio_suspend NULL
 308 #define bt8xxgpio_resume NULL
 309 #endif /* CONFIG_PM */
 310
 311 static const struct pci_device_id bt8xxgpio_pci_tbl[] = {
 312         { PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT848) },
 313         { PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT849) },
 314         { PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT878) },
 315         { PCI_DEVICE(PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT879) },
 316         { 0, },
 317 };
 318 MODULE_DEVICE_TABLE(pci, bt8xxgpio_pci_tbl);
 319
 320 static struct pci_driver bt8xxgpio_pci_driver = {
 321         .name           = "bt8xxgpio",
 322         .id_table       = bt8xxgpio_pci_tbl,
 323         .probe          = bt8xxgpio_probe,
 324         .remove         = bt8xxgpio_remove,
 325         .suspend        = bt8xxgpio_suspend,
 326         .resume         = bt8xxgpio_resume,
 327 };
 328
 329 module_pci_driver(bt8xxgpio_pci_driver);
 330
 331 MODULE_LICENSE("GPL");
 332 MODULE_AUTHOR("Michael Buesch");
 333 MODULE_DESCRIPTION("Abuse a BT8xx framegrabber card as generic GPIO card");