drivers/mfd/lpc_sch.c

   1 /*
   2  *  lpc_sch.c - LPC interface for Intel Poulsbo SCH
   3  *
   4  *  LPC bridge function of the Intel SCH contains many other
   5  *  functional units, such as Interrupt controllers, Timers,
   6  *  Power Management, System Management, GPIO, RTC, and LPC
   7  *  Configuration Registers.
   8  *
   9  *  Copyright (c) 2010 CompuLab Ltd
  10  *  Author: Denis Turischev <denis@compulab.co.il>
  11  *
  12  *  This program is free software; you can redistribute it and/or modify
  13  *  it under the terms of the GNU General Public License 2 as published
  14  *  by the Free Software Foundation.
  15  *
  16  *  This program is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; see the file COPYING.  If not, write to
  23  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  24  */
  25
  26 #include <linux/init.h>
  27 #include <linux/kernel.h>
  28 #include <linux/module.h>
  29 #include <linux/errno.h>
  30 #include <linux/acpi.h>
  31 #include <linux/pci.h>
  32 #include <linux/mfd/core.h>
  33
  34 #define SMBASE          0x40
  35 #define SMBUS_IO_SIZE   64
  36
  37 #define GPIOBASE        0x44
  38 #define GPIO_IO_SIZE    64
  39
  40 #define WDTBASE         0x84
  41 #define WDT_IO_SIZE     64
  42
  43 static struct resource smbus_sch_resource = {
  44                 .flags = IORESOURCE_IO,
  45 };
  46
  47
  48 static struct resource gpio_sch_resource = {
  49                 .flags = IORESOURCE_IO,
  50 };
  51
  52 static struct mfd_cell lpc_sch_cells[] = {
  53         {
  54                 .name = "isch_smbus",
  55                 .num_resources = 1,
  56                 .resources = &smbus_sch_resource,
  57         },
  58         {
  59                 .name = "sch_gpio",
  60                 .num_resources = 1,
  61                 .resources = &gpio_sch_resource,
  62         },
  63 };
  64
  65 static struct resource wdt_sch_resource = {
  66                 .flags = IORESOURCE_IO,
  67 };
  68
  69 static struct mfd_cell tunnelcreek_cells[] = {
  70         {
  71                 .name = "tunnelcreek_wdt",
  72                 .num_resources = 1,
  73                 .resources = &wdt_sch_resource,
  74         },
  75 };
  76
  77 static struct pci_device_id lpc_sch_ids[] = {
  78         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_SCH_LPC) },
  79         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_ITC_LPC) },
  80         { 0, }
  81 };
  82 MODULE_DEVICE_TABLE(pci, lpc_sch_ids);
  83
  84 static int __devinit lpc_sch_probe(struct pci_dev *dev,
  85                                 const struct pci_device_id *id)
  86 {
  87         unsigned int base_addr_cfg;
  88         unsigned short base_addr;
  89         int i;
  90         int ret;
  91
  92         pci_read_config_dword(dev, SMBASE, &base_addr_cfg);
  93         if (!(base_addr_cfg & (1 << 31))) {
  94                 dev_err(&dev->dev, "Decode of the SMBus I/O range disabled\n");
  95                 return -ENODEV;
  96         }
  97         base_addr = (unsigned short)base_addr_cfg;
  98         if (base_addr == 0) {
  99                 dev_err(&dev->dev, "I/O space for SMBus uninitialized\n");
 100                 return -ENODEV;
 101         }
 102
 103         smbus_sch_resource.start = base_addr;
 104         smbus_sch_resource.end = base_addr + SMBUS_IO_SIZE - 1;
 105
 106         pci_read_config_dword(dev, GPIOBASE, &base_addr_cfg);
 107         if (!(base_addr_cfg & (1 << 31))) {
 108                 dev_err(&dev->dev, "Decode of the GPIO I/O range disabled\n");
 109                 return -ENODEV;
 110         }
 111         base_addr = (unsigned short)base_addr_cfg;
 112         if (base_addr == 0) {
 113                 dev_err(&dev->dev, "I/O space for GPIO uninitialized\n");
 114                 return -ENODEV;
 115         }
 116
 117         gpio_sch_resource.start = base_addr;
 118         gpio_sch_resource.end = base_addr + GPIO_IO_SIZE - 1;
 119
 120         for (i=0; i < ARRAY_SIZE(lpc_sch_cells); i++)
 121                 lpc_sch_cells[i].id = id->device;
 122
 123         ret = mfd_add_devices(&dev->dev, 0,
 124                         lpc_sch_cells, ARRAY_SIZE(lpc_sch_cells), NULL, 0);
 125         if (ret)
 126                 goto out_dev;
 127
 128         if (id->device == PCI_DEVICE_ID_INTEL_ITC_LPC) {
 129                 pci_read_config_dword(dev, WDTBASE, &base_addr_cfg);
 130                 if (!(base_addr_cfg & (1 << 31))) {
 131                         dev_err(&dev->dev, "Decode of the WDT I/O range disabled\n");
 132                         ret = -ENODEV;
 133                         goto out_dev;
 134                 }
 135                 base_addr = (unsigned short)base_addr_cfg;
 136                 if (base_addr == 0) {
 137                         dev_err(&dev->dev, "I/O space for WDT uninitialized\n");
 138                         ret = -ENODEV;
 139                         goto out_dev;
 140                 }
 141
 142                 wdt_sch_resource.start = base_addr;
 143                 wdt_sch_resource.end = base_addr + WDT_IO_SIZE - 1;
 144
 145                 for (i = 0; i < ARRAY_SIZE(tunnelcreek_cells); i++)
 146                         tunnelcreek_cells[i].id = id->device;
 147
 148                 ret = mfd_add_devices(&dev->dev, 0, tunnelcreek_cells,
 149                         ARRAY_SIZE(tunnelcreek_cells), NULL, 0);
 150         }
 151
 152         return ret;
 153 out_dev:
 154         mfd_remove_devices(&dev->dev);
 155         return ret;
 156 }
 157
 158 static void __devexit lpc_sch_remove(struct pci_dev *dev)
 159 {
 160         mfd_remove_devices(&dev->dev);
 161 }
 162
 163 static struct pci_driver lpc_sch_driver = {
 164         .name           = "lpc_sch",
 165         .id_table       = lpc_sch_ids,
 166         .probe          = lpc_sch_probe,
 167         .remove         = __devexit_p(lpc_sch_remove),
 168 };
 169
 170 static int __init lpc_sch_init(void)
 171 {
 172         return pci_register_driver(&lpc_sch_driver);
 173 }
 174
 175 static void __exit lpc_sch_exit(void)
 176 {
 177         pci_unregister_driver(&lpc_sch_driver);
 178 }
 179
 180 module_init(lpc_sch_init);
 181 module_exit(lpc_sch_exit);
 182
 183 MODULE_AUTHOR("Denis Turischev <denis@compulab.co.il>");
 184 MODULE_DESCRIPTION("LPC interface for Intel Poulsbo SCH");
 185 MODULE_LICENSE("GPL");