drivers/mfd/janz-cmodio.c

   1 /*
   2  * Janz CMOD-IO MODULbus Carrier Board PCI Driver
   3  *
   4  * Copyright (c) 2010 Ira W. Snyder <iws@ovro.caltech.edu>
   5  *
   6  * Lots of inspiration and code was copied from drivers/mfd/sm501.c
   7  *
   8  * This program is free software; you can redistribute it and/or modify it
   9  * under the terms of the GNU General Public License as published by the
  10  * Free Software Foundation; either version 2 of the License, or (at your
  11  * option) any later version.
  12  */
  13
  14 #include <linux/kernel.h>
  15 #include <linux/module.h>
  16 #include <linux/init.h>
  17 #include <linux/pci.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/delay.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/slab.h>
  22 #include <linux/mfd/core.h>
  23
  24 #include <linux/mfd/janz.h>
  25
  26 #define DRV_NAME "janz-cmodio"
  27
  28 /* Size of each MODULbus module in PCI BAR4 */
  29 #define CMODIO_MODULBUS_SIZE    0x200
  30
  31 /* Maximum number of MODULbus modules on a CMOD-IO carrier board */
  32 #define CMODIO_MAX_MODULES      4
  33
  34 /* Module Parameters */
  35 static unsigned int num_modules = CMODIO_MAX_MODULES;
  36 static unsigned char *modules[CMODIO_MAX_MODULES] = {
  37         "empty", "empty", "empty", "empty",
  38 };
  39
  40 module_param_array(modules, charp, &num_modules, S_IRUGO);
  41 MODULE_PARM_DESC(modules, "MODULbus modules attached to the carrier board");
  42
  43 /* Unique Device Id */
  44 static unsigned int cmodio_id;
  45
  46 struct cmodio_device {
  47         /* Parent PCI device */
  48         struct pci_dev *pdev;
  49
  50         /* PLX control registers */
  51         struct janz_cmodio_onboard_regs __iomem *ctrl;
  52
  53         /* hex switch position */
  54         u8 hex;
  55
  56         /* mfd-core API */
  57         struct mfd_cell cells[CMODIO_MAX_MODULES];
  58         struct resource resources[3 * CMODIO_MAX_MODULES];
  59         struct janz_platform_data pdata[CMODIO_MAX_MODULES];
  60 };
  61
  62 /*
  63  * Subdevices using the mfd-core API
  64  */
  65
  66 static int __devinit cmodio_setup_subdevice(struct cmodio_device *priv,
  67                                             char *name, unsigned int devno,
  68                                             unsigned int modno)
  69 {
  70         struct janz_platform_data *pdata;
  71         struct mfd_cell *cell;
  72         struct resource *res;
  73         struct pci_dev *pci;
  74
  75         pci = priv->pdev;
  76         cell = &priv->cells[devno];
  77         res = &priv->resources[devno * 3];
  78         pdata = &priv->pdata[devno];
  79
  80         cell->name = name;
  81         cell->resources = res;
  82         cell->num_resources = 3;
  83
  84         /* Setup the subdevice ID -- must be unique */
  85         cell->id = cmodio_id++;
  86
  87         /* Add platform data */
  88         pdata->modno = modno;
  89         cell->mfd_data = pdata;
  90
  91         /* MODULbus registers -- PCI BAR3 is big-endian MODULbus access */
  92         res->flags = IORESOURCE_MEM;
  93         res->parent = &pci->resource[3];
  94         res->start = pci->resource[3].start + (CMODIO_MODULBUS_SIZE * modno);
  95         res->end = res->start + CMODIO_MODULBUS_SIZE - 1;
  96         res++;
  97
  98         /* PLX Control Registers -- PCI BAR4 is interrupt and other registers */
  99         res->flags = IORESOURCE_MEM;
 100         res->parent = &pci->resource[4];
 101         res->start = pci->resource[4].start;
 102         res->end = pci->resource[4].end;
 103         res++;
 104
 105         /*
 106          * IRQ
 107          *
 108          * The start and end fields are used as an offset to the irq_base
 109          * parameter passed into the mfd_add_devices() function call. All
 110          * devices share the same IRQ.
 111          */
 112         res->flags = IORESOURCE_IRQ;
 113         res->parent = NULL;
 114         res->start = 0;
 115         res->end = 0;
 116         res++;
 117
 118         return 0;
 119 }
 120
 121 /* Probe each submodule using kernel parameters */
 122 static int __devinit cmodio_probe_submodules(struct cmodio_device *priv)
 123 {
 124         struct pci_dev *pdev = priv->pdev;
 125         unsigned int num_probed = 0;
 126         char *name;
 127         int i;
 128
 129         for (i = 0; i < num_modules; i++) {
 130                 name = modules[i];
 131                 if (!strcmp(name, "") || !strcmp(name, "empty"))
 132                         continue;
 133
 134                 dev_dbg(&priv->pdev->dev, "MODULbus %d: name %s\n", i, name);
 135                 cmodio_setup_subdevice(priv, name, num_probed, i);
 136                 num_probed++;
 137         }
 138
 139         /* print an error message if no modules were probed */
 140         if (num_probed == 0) {
 141                 dev_err(&priv->pdev->dev, "no MODULbus modules specified, "
 142                                           "please set the ``modules'' kernel "
 143                                           "parameter according to your "
 144                                           "hardware configuration\n");
 145                 return -ENODEV;
 146         }
 147
 148         return mfd_add_devices(&pdev->dev, 0, priv->cells,
 149                                num_probed, NULL, pdev->irq);
 150 }
 151
 152 /*
 153  * SYSFS Attributes
 154  */
 155
 156 static ssize_t mbus_show(struct device *dev, struct device_attribute *attr,
 157                          char *buf)
 158 {
 159         struct cmodio_device *priv = dev_get_drvdata(dev);
 160
 161         return snprintf(buf, PAGE_SIZE, "%x\n", priv->hex);
 162 }
 163
 164 static DEVICE_ATTR(modulbus_number, S_IRUGO, mbus_show, NULL);
 165
 166 static struct attribute *cmodio_sysfs_attrs[] = {
 167         &dev_attr_modulbus_number.attr,
 168         NULL,
 169 };
 170
 171 static const struct attribute_group cmodio_sysfs_attr_group = {
 172         .attrs = cmodio_sysfs_attrs,
 173 };
 174
 175 /*
 176  * PCI Driver
 177  */
 178
 179 static int __devinit cmodio_pci_probe(struct pci_dev *dev,
 180                                       const struct pci_device_id *id)
 181 {
 182         struct cmodio_device *priv;
 183         int ret;
 184
 185         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
 186         if (!priv) {
 187                 dev_err(&dev->dev, "unable to allocate private data\n");
 188                 ret = -ENOMEM;
 189                 goto out_return;
 190         }
 191
 192         pci_set_drvdata(dev, priv);
 193         priv->pdev = dev;
 194
 195         /* Hardware Initialization */
 196         ret = pci_enable_device(dev);
 197         if (ret) {
 198                 dev_err(&dev->dev, "unable to enable device\n");
 199                 goto out_free_priv;
 200         }
 201
 202         pci_set_master(dev);
 203         ret = pci_request_regions(dev, DRV_NAME);
 204         if (ret) {
 205                 dev_err(&dev->dev, "unable to request regions\n");
 206                 goto out_pci_disable_device;
 207         }
 208
 209         /* Onboard configuration registers */
 210         priv->ctrl = pci_ioremap_bar(dev, 4);
 211         if (!priv->ctrl) {
 212                 dev_err(&dev->dev, "unable to remap onboard regs\n");
 213                 ret = -ENOMEM;
 214                 goto out_pci_release_regions;
 215         }
 216
 217         /* Read the hex switch on the carrier board */
 218         priv->hex = ioread8(&priv->ctrl->int_enable);
 219
 220         /* Add the MODULbus number (hex switch value) to the device's sysfs */
 221         ret = sysfs_create_group(&dev->dev.kobj, &cmodio_sysfs_attr_group);
 222         if (ret) {
 223                 dev_err(&dev->dev, "unable to create sysfs attributes\n");
 224                 goto out_unmap_ctrl;
 225         }
 226
 227         /*
 228          * Disable all interrupt lines, each submodule will enable its
 229          * own interrupt line if needed
 230          */
 231         iowrite8(0xf, &priv->ctrl->int_disable);
 232
 233         /* Register drivers for all submodules */
 234         ret = cmodio_probe_submodules(priv);
 235         if (ret) {
 236                 dev_err(&dev->dev, "unable to probe submodules\n");
 237                 goto out_sysfs_remove_group;
 238         }
 239
 240         return 0;
 241
 242 out_sysfs_remove_group:
 243         sysfs_remove_group(&dev->dev.kobj, &cmodio_sysfs_attr_group);
 244 out_unmap_ctrl:
 245         iounmap(priv->ctrl);
 246 out_pci_release_regions:
 247         pci_release_regions(dev);
 248 out_pci_disable_device:
 249         pci_disable_device(dev);
 250 out_free_priv:
 251         kfree(priv);
 252 out_return:
 253         return ret;
 254 }
 255
 256 static void __devexit cmodio_pci_remove(struct pci_dev *dev)
 257 {
 258         struct cmodio_device *priv = pci_get_drvdata(dev);
 259
 260         mfd_remove_devices(&dev->dev);
 261         sysfs_remove_group(&dev->dev.kobj, &cmodio_sysfs_attr_group);
 262         iounmap(priv->ctrl);
 263         pci_release_regions(dev);
 264         pci_disable_device(dev);
 265         kfree(priv);
 266 }
 267
 268 #define PCI_VENDOR_ID_JANZ              0x13c3
 269
 270 /* The list of devices that this module will support */
 271 static DEFINE_PCI_DEVICE_TABLE(cmodio_pci_ids) = {
 272         { PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030, PCI_VENDOR_ID_JANZ, 0x0101 },
 273         { PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050, PCI_VENDOR_ID_JANZ, 0x0100 },
 274         { 0, }
 275 };
 276 MODULE_DEVICE_TABLE(pci, cmodio_pci_ids);
 277
 278 static struct pci_driver cmodio_pci_driver = {
 279         .name     = DRV_NAME,
 280         .id_table = cmodio_pci_ids,
 281         .probe    = cmodio_pci_probe,
 282         .remove   = __devexit_p(cmodio_pci_remove),
 283 };
 284
 285 /*
 286  * Module Init / Exit
 287  */
 288
 289 static int __init cmodio_init(void)
 290 {
 291         return pci_register_driver(&cmodio_pci_driver);
 292 }
 293
 294 static void __exit cmodio_exit(void)
 295 {
 296         pci_unregister_driver(&cmodio_pci_driver);
 297 }
 298
 299 MODULE_AUTHOR("Ira W. Snyder <iws@ovro.caltech.edu>");
 300 MODULE_DESCRIPTION("Janz CMOD-IO PCI MODULbus Carrier Board Driver");
 301 MODULE_LICENSE("GPL");
 302
 303 module_init(cmodio_init);
 304 module_exit(cmodio_exit);