Merge branch 'linus' into sched/core
[linux-3.10.git] / drivers / i2c / busses / scx200_acb.c
index 8e646bd..684395b 100644 (file)
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/i2c.h>
-#include <linux/smp_lock.h>
 #include <linux/pci.h>
 #include <linux/delay.h>
+#include <linux/mutex.h>
+#include <linux/slab.h>
 #include <asm/io.h>
-#include <asm/msr.h>
 
 #include <linux/scx200.h>
 
@@ -74,7 +74,7 @@ struct scx200_acb_iface {
        struct scx200_acb_iface *next;
        struct i2c_adapter adapter;
        unsigned base;
-       struct semaphore sem;
+       struct mutex mutex;
 
        /* State machine data */
        enum scx200_acb_state state;
@@ -84,6 +84,10 @@ struct scx200_acb_iface {
        u8 *ptr;
        char needs_reset;
        unsigned len;
+
+       /* PCI device info */
+       struct pci_dev *pdev;
+       int bar;
 };
 
 /* Register Definitions */
@@ -132,6 +136,9 @@ static void scx200_acb_machine(struct scx200_acb_iface *iface, u8 status)
 
                outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1);
                outb(ACBST_STASTR | ACBST_NEGACK, ACBST);
+
+               /* Reset the status register */
+               outb(0, ACBST);
                return;
        }
 
@@ -177,21 +184,21 @@ static void scx200_acb_machine(struct scx200_acb_iface *iface, u8 status)
                break;
 
        case state_read:
-               /* Set ACK if receiving the last byte */
-               if (iface->len == 1)
+               /* Set ACK if _next_ byte will be the last one */
+               if (iface->len == 2)
                        outb(inb(ACBCTL1) | ACBCTL1_ACK, ACBCTL1);
                else
                        outb(inb(ACBCTL1) & ~ACBCTL1_ACK, ACBCTL1);
 
-               *iface->ptr++ = inb(ACBSDA);
-               --iface->len;
-
-               if (iface->len == 0) {
+               if (iface->len == 1) {
                        iface->result = 0;
                        iface->state = state_idle;
                        outb(inb(ACBCTL1) | ACBCTL1_STOP, ACBCTL1);
                }
 
+               *iface->ptr++ = inb(ACBSDA);
+               --iface->len;
+
                break;
 
        case state_write:
@@ -211,8 +218,10 @@ static void scx200_acb_machine(struct scx200_acb_iface *iface, u8 status)
        return;
 
  error:
-       dev_err(&iface->adapter.dev, "%s in state %s\n", errmsg,
-               scx200_acb_state_name[iface->state]);
+       dev_err(&iface->adapter.dev,
+               "%s in state %s (addr=0x%02x, len=%d, status=0x%02x)\n", errmsg,
+               scx200_acb_state_name[iface->state], iface->address_byte,
+               iface->len, status);
 
        iface->state = state_idle;
        iface->result = -EIO;
@@ -225,13 +234,20 @@ static void scx200_acb_poll(struct scx200_acb_iface *iface)
        unsigned long timeout;
 
        timeout = jiffies + POLL_TIMEOUT;
-       while (time_before(jiffies, timeout)) {
+       while (1) {
                status = inb(ACBST);
+
+               /* Reset the status register to avoid the hang */
+               outb(0, ACBST);
+
                if ((status & (ACBST_SDAST|ACBST_BER|ACBST_NEGACK)) != 0) {
                        scx200_acb_machine(iface, status);
                        return;
                }
-               yield();
+               if (time_after(jiffies, timeout))
+                       break;
+               cpu_relax();
+               cond_resched();
        }
 
        dev_err(&iface->adapter.dev, "timeout in state %s\n",
@@ -296,8 +312,10 @@ static s32 scx200_acb_smbus_xfer(struct i2c_adapter *adapter,
                buffer = (u8 *)&cur_word;
                break;
 
-       case I2C_SMBUS_BLOCK_DATA:
+       case I2C_SMBUS_I2C_BLOCK_DATA:
                len = data->block[0];
+               if (len == 0 || len > I2C_SMBUS_BLOCK_MAX)
+                       return -EINVAL;
                buffer = &data->block[1];
                break;
 
@@ -314,7 +332,7 @@ static s32 scx200_acb_smbus_xfer(struct i2c_adapter *adapter,
                return -EINVAL;
        }
 
-       down(&iface->sem);
+       mutex_lock(&iface->mutex);
 
        iface->address_byte = (address << 1) | rw;
        iface->command = command;
@@ -338,7 +356,7 @@ static s32 scx200_acb_smbus_xfer(struct i2c_adapter *adapter,
 
        rc = iface->result;
 
-       up(&iface->sem);
+       mutex_unlock(&iface->mutex);
 
        if (rc == 0 && size == I2C_SMBUS_WORD_DATA && rw == I2C_SMBUS_READ)
                data->word = le16_to_cpu(cur_word);
@@ -361,19 +379,19 @@ static u32 scx200_acb_func(struct i2c_adapter *adapter)
 {
        return I2C_FUNC_SMBUS_QUICK | I2C_FUNC_SMBUS_BYTE |
               I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA |
-              I2C_FUNC_SMBUS_BLOCK_DATA;
+              I2C_FUNC_SMBUS_I2C_BLOCK;
 }
 
 /* For now, we only handle combined mode (smbus) */
-static struct i2c_algorithm scx200_acb_algorithm = {
+static const struct i2c_algorithm scx200_acb_algorithm = {
        .smbus_xfer     = scx200_acb_smbus_xfer,
        .functionality  = scx200_acb_func,
 };
 
 static struct scx200_acb_iface *scx200_acb_list;
-static DECLARE_MUTEX(scx200_acb_list_mutex);
+static DEFINE_MUTEX(scx200_acb_list_mutex);
 
-static int scx200_acb_probe(struct scx200_acb_iface *iface)
+static __init int scx200_acb_probe(struct scx200_acb_iface *iface)
 {
        u8 val;
 
@@ -409,120 +427,205 @@ static int scx200_acb_probe(struct scx200_acb_iface *iface)
        return 0;
 }
 
-static int  __init scx200_acb_create(const char *text, int base, int index)
+static __init struct scx200_acb_iface *scx200_create_iface(const char *text,
+               struct device *dev, int index)
 {
        struct scx200_acb_iface *iface;
        struct i2c_adapter *adapter;
-       int rc;
-       char description[64];
 
        iface = kzalloc(sizeof(*iface), GFP_KERNEL);
        if (!iface) {
                printk(KERN_ERR NAME ": can't allocate memory\n");
-               rc = -ENOMEM;
-               goto errout;
+               return NULL;
        }
 
        adapter = &iface->adapter;
        i2c_set_adapdata(adapter, iface);
-       snprintf(adapter->name, I2C_NAME_SIZE, "%s ACB%d", text, index);
+       snprintf(adapter->name, sizeof(adapter->name), "%s ACB%d", text, index);
        adapter->owner = THIS_MODULE;
-       adapter->id = I2C_HW_SMBUS_SCX200;
        adapter->algo = &scx200_acb_algorithm;
-       adapter->class = I2C_CLASS_HWMON;
+       adapter->class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
+       adapter->dev.parent = dev;
 
-       init_MUTEX(&iface->sem);
+       mutex_init(&iface->mutex);
 
-       snprintf(description, sizeof(description), "%s ACCESS.bus [%s]",
-                text, adapter->name);
+       return iface;
+}
 
-       if (request_region(base, 8, description) == 0) {
-               printk(KERN_ERR NAME ": can't allocate io 0x%x-0x%x\n",
-                       base, base + 8-1);
-               rc = -EBUSY;
-               goto errout_free;
-       }
-       iface->base = base;
+static int __init scx200_acb_create(struct scx200_acb_iface *iface)
+{
+       struct i2c_adapter *adapter;
+       int rc;
+
+       adapter = &iface->adapter;
 
        rc = scx200_acb_probe(iface);
        if (rc) {
                printk(KERN_WARNING NAME ": probe failed\n");
-               goto errout_release;
+               return rc;
        }
 
        scx200_acb_reset(iface);
 
        if (i2c_add_adapter(adapter) < 0) {
                printk(KERN_ERR NAME ": failed to register\n");
-               rc = -ENODEV;
-               goto errout_release;
+               return -ENODEV;
        }
 
-       down(&scx200_acb_list_mutex);
+       mutex_lock(&scx200_acb_list_mutex);
        iface->next = scx200_acb_list;
        scx200_acb_list = iface;
-       up(&scx200_acb_list_mutex);
+       mutex_unlock(&scx200_acb_list_mutex);
 
        return 0;
+}
+
+static __init int scx200_create_pci(const char *text, struct pci_dev *pdev,
+               int bar)
+{
+       struct scx200_acb_iface *iface;
+       int rc;
+
+       iface = scx200_create_iface(text, &pdev->dev, 0);
+
+       if (iface == NULL)
+               return -ENOMEM;
+
+       iface->pdev = pdev;
+       iface->bar = bar;
+
+       rc = pci_enable_device_io(iface->pdev);
+       if (rc)
+               goto errout_free;
+
+       rc = pci_request_region(iface->pdev, iface->bar, iface->adapter.name);
+       if (rc) {
+               printk(KERN_ERR NAME ": can't allocate PCI BAR %d\n",
+                               iface->bar);
+               goto errout_free;
+       }
+
+       iface->base = pci_resource_start(iface->pdev, iface->bar);
+       rc = scx200_acb_create(iface);
+
+       if (rc == 0)
+               return 0;
 
- errout_release:
-       release_region(iface->base, 8);
+       pci_release_region(iface->pdev, iface->bar);
+       pci_dev_put(iface->pdev);
  errout_free:
        kfree(iface);
- errout:
        return rc;
 }
 
-static struct pci_device_id scx200[] = {
-       { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SCx200_BRIDGE) },
-       { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SC1100_BRIDGE) },
-       { },
-};
+static int __init scx200_create_isa(const char *text, unsigned long base,
+               int index)
+{
+       struct scx200_acb_iface *iface;
+       int rc;
+
+       iface = scx200_create_iface(text, NULL, index);
+
+       if (iface == NULL)
+               return -ENOMEM;
+
+       if (!request_region(base, 8, iface->adapter.name)) {
+               printk(KERN_ERR NAME ": can't allocate io 0x%lx-0x%lx\n",
+                      base, base + 8 - 1);
+               rc = -EBUSY;
+               goto errout_free;
+       }
+
+       iface->base = base;
+       rc = scx200_acb_create(iface);
+
+       if (rc == 0)
+               return 0;
 
-static struct pci_device_id divil_pci[] = {
-       { PCI_DEVICE(PCI_VENDOR_ID_NS,  PCI_DEVICE_ID_NS_CS5535_ISA) },
-       { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_ISA) },
-       { } /* NULL entry */
+       release_region(base, 8);
+ errout_free:
+       kfree(iface);
+       return rc;
+}
+
+/* Driver data is an index into the scx200_data array that indicates
+ * the name and the BAR where the I/O address resource is located.  ISA
+ * devices are flagged with a bar value of -1 */
+
+static struct pci_device_id scx200_pci[] = {
+       { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SCx200_BRIDGE),
+         .driver_data = 0 },
+       { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_SC1100_BRIDGE),
+         .driver_data = 0 },
+       { PCI_DEVICE(PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_CS5535_ISA),
+         .driver_data = 1 },
+       { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_CS5536_ISA),
+         .driver_data = 2 }
 };
 
-#define MSR_LBAR_SMB           0x5140000B
+static struct {
+       const char *name;
+       int bar;
+} scx200_data[] = {
+       { "SCx200", -1 },
+       { "CS5535",  0 },
+       { "CS5536",  0 }
+};
 
-static int scx200_add_cs553x(void)
+static __init int scx200_scan_pci(void)
 {
-       u32     low, hi;
-       u32     smb_base;
-
-       /* Grab & reserve the SMB I/O range */
-       rdmsr(MSR_LBAR_SMB, low, hi);
+       int data, dev;
+       int rc = -ENODEV;
+       struct pci_dev *pdev;
+
+       for(dev = 0; dev < ARRAY_SIZE(scx200_pci); dev++) {
+               pdev = pci_get_device(scx200_pci[dev].vendor,
+                               scx200_pci[dev].device, NULL);
+
+               if (pdev == NULL)
+                       continue;
+
+               data = scx200_pci[dev].driver_data;
+
+               /* if .bar is greater or equal to zero, this is a
+                * PCI device - otherwise, we assume
+                  that the ports are ISA based
+               */
+
+               if (scx200_data[data].bar >= 0)
+                       rc = scx200_create_pci(scx200_data[data].name, pdev,
+                                       scx200_data[data].bar);
+               else {
+                       int i;
+
+                       pci_dev_put(pdev);
+                       for (i = 0; i < MAX_DEVICES; ++i) {
+                               if (base[i] == 0)
+                                       continue;
+
+                               rc = scx200_create_isa(scx200_data[data].name,
+                                               base[i],
+                                               i);
+                       }
+               }
 
-       /* Check the IO mask and whether SMB is enabled */
-       if (hi != 0x0000F001) {
-               printk(KERN_WARNING NAME ": SMBus not enabled\n");
-               return -ENODEV;
+               break;
        }
 
-       /* SMBus IO size is 8 bytes */
-       smb_base = low & 0x0000FFF8;
-
-       return scx200_acb_create("CS5535", smb_base, 0);
+       return rc;
 }
 
 static int __init scx200_acb_init(void)
 {
-       int i;
-       int     rc = -ENODEV;
+       int rc;
 
        pr_debug(NAME ": NatSemi SCx200 ACCESS.bus Driver\n");
 
-       /* Verify that this really is a SCx200 processor */
-       if (pci_dev_present(scx200)) {
-               for (i = 0; i < MAX_DEVICES; ++i) {
-                       if (base[i] > 0)
-                               rc = scx200_acb_create("SCx200", base[i], i);
-               }
-       } else if (pci_dev_present(divil_pci))
-               rc = scx200_add_cs553x();
+       rc = scx200_scan_pci();
 
+       /* If at least one bus was created, init must succeed */
+       if (scx200_acb_list)
+               return 0;
        return rc;
 }
 
@@ -530,17 +633,24 @@ static void __exit scx200_acb_cleanup(void)
 {
        struct scx200_acb_iface *iface;
 
-       down(&scx200_acb_list_mutex);
+       mutex_lock(&scx200_acb_list_mutex);
        while ((iface = scx200_acb_list) != NULL) {
                scx200_acb_list = iface->next;
-               up(&scx200_acb_list_mutex);
+               mutex_unlock(&scx200_acb_list_mutex);
 
                i2c_del_adapter(&iface->adapter);
-               release_region(iface->base, 8);
+
+               if (iface->pdev) {
+                       pci_release_region(iface->pdev, iface->bar);
+                       pci_dev_put(iface->pdev);
+               }
+               else
+                       release_region(iface->base, 8);
+
                kfree(iface);
-               down(&scx200_acb_list_mutex);
+               mutex_lock(&scx200_acb_list_mutex);
        }
-       up(&scx200_acb_list_mutex);
+       mutex_unlock(&scx200_acb_list_mutex);
 }
 
 module_init(scx200_acb_init);