arch/i386/kernel/scx200.c

   1 /* linux/arch/i386/kernel/scx200.c
   2
   3    Copyright (c) 2001,2002 Christer Weinigel <wingel@nano-system.com>
   4
   5    National Semiconductor SCx200 support. */
   6
   7 #include <linux/config.h>
   8 #include <linux/module.h>
   9 #include <linux/errno.h>
  10 #include <linux/kernel.h>
  11 #include <linux/init.h>
  12 #include <linux/mutex.h>
  13 #include <linux/pci.h>
  14
  15 #include <linux/scx200.h>
  16 #include <linux/scx200_gpio.h>
  17
  18 /* Verify that the configuration block really is there */
  19 #define scx200_cb_probe(base) (inw((base) + SCx200_CBA) == (base))
  20
  21 #define NAME "scx200"
  22
  23 MODULE_AUTHOR("Christer Weinigel <wingel@nano-system.com>");
  24 MODULE_DESCRIPTION("NatSemi SCx200 Driver");
  25 MODULE_LICENSE("GPL");
  26
  27 unsigned scx200_gpio_base = 0;
  28 long scx200_gpio_shadow[2];
  29
  30 unsigned scx200_cb_base = 0;
  31
  32 static struct pci_device_id scx200_tbl[] = {
  33         { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SCx200_BRIDGE) },
  34         { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SC1100_BRIDGE) },
  35         { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SCx200_XBUS)   },
  36         { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SC1100_XBUS)   },
  37         { },
  38 };
  39 MODULE_DEVICE_TABLE(pci,scx200_tbl);
  40
  41 static int __devinit scx200_probe(struct pci_dev *, const struct pci_device_id *);
  42
  43 static struct pci_driver scx200_pci_driver = {
  44         .name = "scx200",
  45         .id_table = scx200_tbl,
  46         .probe = scx200_probe,
  47 };
  48
  49 static DEFINE_MUTEX(scx200_gpio_config_lock);
  50
  51 static void __devinit scx200_init_shadow(void)
  52 {
  53         int bank;
  54
  55         /* read the current values driven on the GPIO signals */
  56         for (bank = 0; bank < 2; ++bank)
  57                 scx200_gpio_shadow[bank] = inl(scx200_gpio_base + 0x10 * bank);
  58 }
  59
  60 static int __devinit scx200_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
  61 {
  62         unsigned base;
  63
  64         if (pdev->device == PCI_DEVICE_ID_NS_SCx200_BRIDGE ||
  65             pdev->device == PCI_DEVICE_ID_NS_SC1100_BRIDGE) {
  66                 base = pci_resource_start(pdev, 0);
  67                 printk(KERN_INFO NAME ": GPIO base 0x%x\n", base);
  68
  69                 if (request_region(base, SCx200_GPIO_SIZE, "NatSemi SCx200 GPIO") == 0) {
  70                         printk(KERN_ERR NAME ": can't allocate I/O for GPIOs\n");
  71                         return -EBUSY;
  72                 }
  73
  74                 scx200_gpio_base = base;
  75                 scx200_init_shadow();
  76
  77         } else {
  78                 /* find the base of the Configuration Block */
  79                 if (scx200_cb_probe(SCx200_CB_BASE_FIXED)) {
  80                         scx200_cb_base = SCx200_CB_BASE_FIXED;
  81                 } else {
  82                         pci_read_config_dword(pdev, SCx200_CBA_SCRATCH, &base);
  83                         if (scx200_cb_probe(base)) {
  84                                 scx200_cb_base = base;
  85                         } else {
  86                                 printk(KERN_WARNING NAME ": Configuration Block not found\n");
  87                                 return -ENODEV;
  88                         }
  89                 }
  90                 printk(KERN_INFO NAME ": Configuration Block base 0x%x\n", scx200_cb_base);
  91         }
  92
  93         return 0;
  94 }
  95
  96 u32 scx200_gpio_configure(unsigned index, u32 mask, u32 bits)
  97 {
  98         u32 config, new_config;
  99
 100         mutex_lock(&scx200_gpio_config_lock);
 101
 102         outl(index, scx200_gpio_base + 0x20);
 103         config = inl(scx200_gpio_base + 0x24);
 104
 105         new_config = (config & mask) | bits;
 106         outl(new_config, scx200_gpio_base + 0x24);
 107
 108         mutex_unlock(&scx200_gpio_config_lock);
 109
 110         return config;
 111 }
 112
 113 static int __init scx200_init(void)
 114 {
 115         printk(KERN_INFO NAME ": NatSemi SCx200 Driver\n");
 116
 117         return pci_register_driver(&scx200_pci_driver);
 118 }
 119
 120 static void __exit scx200_cleanup(void)
 121 {
 122         pci_unregister_driver(&scx200_pci_driver);
 123         release_region(scx200_gpio_base, SCx200_GPIO_SIZE);
 124 }
 125
 126 module_init(scx200_init);
 127 module_exit(scx200_cleanup);
 128
 129 EXPORT_SYMBOL(scx200_gpio_base);
 130 EXPORT_SYMBOL(scx200_gpio_shadow);
 131 EXPORT_SYMBOL(scx200_gpio_configure);
 132 EXPORT_SYMBOL(scx200_cb_base);