drivers/i2c/busses/i2c-pxa-pci.c

   1 /*
   2  * The CE4100's I2C device is more or less the same one as found on PXA.
   3  * It does not support slave mode, the register slightly moved. This PCI
   4  * device provides three bars, every contains a single I2C controller.
   5  */
   6 #include <linux/pci.h>
   7 #include <linux/platform_device.h>
   8 #include <linux/i2c/pxa-i2c.h>
   9 #include <linux/of.h>
  10 #include <linux/of_device.h>
  11 #include <linux/of_address.h>
  12
  13 #define CE4100_PCI_I2C_DEVS     3
  14
  15 struct ce4100_devices {
  16         struct platform_device *pdev[CE4100_PCI_I2C_DEVS];
  17 };
  18
  19 static struct platform_device *add_i2c_device(struct pci_dev *dev, int bar)
  20 {
  21         struct platform_device *pdev;
  22         struct i2c_pxa_platform_data pdata;
  23         struct resource res[2];
  24         struct device_node *child;
  25         static int devnum;
  26         int ret;
  27
  28         memset(&pdata, 0, sizeof(struct i2c_pxa_platform_data));
  29         memset(&res, 0, sizeof(res));
  30
  31         res[0].flags = IORESOURCE_MEM;
  32         res[0].start = pci_resource_start(dev, bar);
  33         res[0].end = pci_resource_end(dev, bar);
  34
  35         res[1].flags = IORESOURCE_IRQ;
  36         res[1].start = dev->irq;
  37         res[1].end = dev->irq;
  38
  39         for_each_child_of_node(dev->dev.of_node, child) {
  40                 const void *prop;
  41                 struct resource r;
  42                 int ret;
  43
  44                 ret = of_address_to_resource(child, 0, &r);
  45                 if (ret < 0)
  46                         continue;
  47                 if (r.start != res[0].start)
  48                         continue;
  49                 if (r.end != res[0].end)
  50                         continue;
  51                 if (r.flags != res[0].flags)
  52                         continue;
  53
  54                 prop = of_get_property(child, "fast-mode", NULL);
  55                 if (prop)
  56                         pdata.fast_mode = 1;
  57
  58                 break;
  59         }
  60
  61         if (!child) {
  62                 dev_err(&dev->dev, "failed to match a DT node for bar %d.\n",
  63                                 bar);
  64                 ret = -EINVAL;
  65                 goto out;
  66         }
  67
  68         pdev = platform_device_alloc("ce4100-i2c", devnum);
  69         if (!pdev) {
  70                 of_node_put(child);
  71                 ret = -ENOMEM;
  72                 goto out;
  73         }
  74         pdev->dev.parent = &dev->dev;
  75         pdev->dev.of_node = child;
  76
  77         ret = platform_device_add_resources(pdev, res, ARRAY_SIZE(res));
  78         if (ret)
  79                 goto err;
  80
  81         ret = platform_device_add_data(pdev, &pdata, sizeof(pdata));
  82         if (ret)
  83                 goto err;
  84
  85         ret = platform_device_add(pdev);
  86         if (ret)
  87                 goto err;
  88         devnum++;
  89         return pdev;
  90 err:
  91         platform_device_put(pdev);
  92 out:
  93         return ERR_PTR(ret);
  94 }
  95
  96 static int __devinit ce4100_i2c_probe(struct pci_dev *dev,
  97                 const struct pci_device_id *ent)
  98 {
  99         int ret;
 100         int i;
 101         struct ce4100_devices *sds;
 102
 103         ret = pci_enable_device_mem(dev);
 104         if (ret)
 105                 return ret;
 106
 107         if (!dev->dev.of_node) {
 108                 dev_err(&dev->dev, "Missing device tree node.\n");
 109                 return -EINVAL;
 110         }
 111         sds = kzalloc(sizeof(*sds), GFP_KERNEL);
 112         if (!sds)
 113                 goto err_mem;
 114
 115         for (i = 0; i < ARRAY_SIZE(sds->pdev); i++) {
 116                 sds->pdev[i] = add_i2c_device(dev, i);
 117                 if (IS_ERR(sds->pdev[i])) {
 118                         while (--i >= 0)
 119                                 platform_device_unregister(sds->pdev[i]);
 120                         goto err_dev_add;
 121                 }
 122         }
 123         pci_set_drvdata(dev, sds);
 124         return 0;
 125
 126 err_dev_add:
 127         pci_set_drvdata(dev, NULL);
 128         kfree(sds);
 129 err_mem:
 130         pci_disable_device(dev);
 131         return ret;
 132 }
 133
 134 static void __devexit ce4100_i2c_remove(struct pci_dev *dev)
 135 {
 136         struct ce4100_devices *sds;
 137         unsigned int i;
 138
 139         sds = pci_get_drvdata(dev);
 140         pci_set_drvdata(dev, NULL);
 141
 142         for (i = 0; i < ARRAY_SIZE(sds->pdev); i++)
 143                 platform_device_unregister(sds->pdev[i]);
 144
 145         pci_disable_device(dev);
 146         kfree(sds);
 147 }
 148
 149 static struct pci_device_id ce4100_i2c_devices[] __devinitdata = {
 150         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2e68)},
 151         { },
 152 };
 153 MODULE_DEVICE_TABLE(pci, ce4100_i2c_devices);
 154
 155 static struct pci_driver ce4100_i2c_driver = {
 156         .name           = "ce4100_i2c",
 157         .id_table       = ce4100_i2c_devices,
 158         .probe          = ce4100_i2c_probe,
 159         .remove         = __devexit_p(ce4100_i2c_remove),
 160 };
 161
 162 static int __init ce4100_i2c_init(void)
 163 {
 164         return pci_register_driver(&ce4100_i2c_driver);
 165 }
 166 module_init(ce4100_i2c_init);
 167
 168 static void __exit ce4100_i2c_exit(void)
 169 {
 170         pci_unregister_driver(&ce4100_i2c_driver);
 171 }
 172 module_exit(ce4100_i2c_exit);
 173
 174 MODULE_DESCRIPTION("CE4100 PCI-I2C glue code for PXA's driver");
 175 MODULE_LICENSE("GPL v2");
 176 MODULE_AUTHOR("Sebastian Andrzej Siewior <bigeasy@linutronix.de>");