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/pci.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/delay.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/slab.h>
  21 #include <linux/mfd/core.h>
  22
  23 #include <linux/mfd/janz.h>
  24
  25 #define DRV_NAME "janz-cmodio"
  26
  27 /* Size of each MODULbus module in PCI BAR4 */
  28 #define CMODIO_MODULBUS_SIZE    0x200
  29
  30 /* Maximum number of MODULbus modules on a CMOD-IO carrier board */
  31 #define CMODIO_MAX_MODULES      4
  32
  33 /* Module Parameters */
  34 static unsigned int num_modules = CMODIO_MAX_MODULES;
  35 static char *modules[CMODIO_MAX_MODULES] = {
  36         "empty", "empty", "empty", "empty",
  37 };
  38
  39 module_param_array(modules, charp, &num_modules, S_IRUGO);
  40 MODULE_PARM_DESC(modules, "MODULbus modules attached to the carrier board");
  41
  42 /* Unique Device Id */
  43 static unsigned int cmodio_id;
  44
  45 struct cmodio_device {
  46         /* Parent PCI device */
  47         struct pci_dev *pdev;
  48
  49         /* PLX control registers */
  50         struct janz_cmodio_onboard_regs __iomem *ctrl;
  51
  52         /* hex switch position */
  53         u8 hex;
  54
  55         /* mfd-core API */
  56         struct mfd_cell cells[CMODIO_MAX_MODULES];
  57         struct resource resources[3 * CMODIO_MAX_MODULES];
  58         struct janz_platform_data pdata[CMODIO_MAX_MODULES];
  59 };
  60
  61 /*
  62  * Subdevices using the mfd-core API
  63  */
  64
  65 static int cmodio_setup_subdevice(struct cmodio_device *priv,
  66                                             char *name, unsigned int devno,
  67                                             unsigned int modno)
  68 {
  69         struct janz_platform_data *pdata;
  70         struct mfd_cell *cell;
  71         struct resource *res;
  72         struct pci_dev *pci;
  73
  74         pci = priv->pdev;
  75         cell = &priv->cells[devno];
  76         res = &priv->resources[devno * 3];
  77         pdata = &priv->pdata[devno];
  78
  79         cell->name = name;
  80         cell->resources = res;
  81         cell->num_resources = 3;
  82
  83         /* Setup the subdevice ID -- must be unique */
  84         cell->id = cmodio_id++;
  85
  86         /* Add platform data */
  87         pdata->modno = modno;
  88         cell->platform_data = pdata;
  89         cell->pdata_size = sizeof(*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 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, NULL);
 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 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 = devm_kzalloc(&dev->dev, sizeof(*priv), GFP_KERNEL);
 186         if (!priv) {
 187                 dev_err(&dev->dev, "unable to allocate private data\n");
 188                 return -ENOMEM;
 189         }
 190
 191         pci_set_drvdata(dev, priv);
 192         priv->pdev = dev;
 193
 194         /* Hardware Initialization */
 195         ret = pci_enable_device(dev);
 196         if (ret) {
 197                 dev_err(&dev->dev, "unable to enable device\n");
 198                 return ret;
 199         }
 200
 201         pci_set_master(dev);
 202         ret = pci_request_regions(dev, DRV_NAME);
 203         if (ret) {
 204                 dev_err(&dev->dev, "unable to request regions\n");
 205                 goto out_pci_disable_device;
 206         }
 207
 208         /* Onboard configuration registers */
 209         priv->ctrl = pci_ioremap_bar(dev, 4);
 210         if (!priv->ctrl) {
 211                 dev_err(&dev->dev, "unable to remap onboard regs\n");
 212                 ret = -ENOMEM;
 213                 goto out_pci_release_regions;
 214         }
 215
 216         /* Read the hex switch on the carrier board */
 217         priv->hex = ioread8(&priv->ctrl->int_enable);
 218
 219         /* Add the MODULbus number (hex switch value) to the device's sysfs */
 220         ret = sysfs_create_group(&dev->dev.kobj, &cmodio_sysfs_attr_group);
 221         if (ret) {
 222                 dev_err(&dev->dev, "unable to create sysfs attributes\n");
 223                 goto out_unmap_ctrl;
 224         }
 225
 226         /*
 227          * Disable all interrupt lines, each submodule will enable its
 228          * own interrupt line if needed
 229          */
 230         iowrite8(0xf, &priv->ctrl->int_disable);
 231
 232         /* Register drivers for all submodules */
 233         ret = cmodio_probe_submodules(priv);
 234         if (ret) {
 235                 dev_err(&dev->dev, "unable to probe submodules\n");
 236                 goto out_sysfs_remove_group;
 237         }
 238
 239         return 0;
 240
 241 out_sysfs_remove_group:
 242         sysfs_remove_group(&dev->dev.kobj, &cmodio_sysfs_attr_group);
 243 out_unmap_ctrl:
 244         iounmap(priv->ctrl);
 245 out_pci_release_regions:
 246         pci_release_regions(dev);
 247 out_pci_disable_device:
 248         pci_disable_device(dev);
 249
 250         return ret;
 251 }
 252
 253 static void cmodio_pci_remove(struct pci_dev *dev)
 254 {
 255         struct cmodio_device *priv = pci_get_drvdata(dev);
 256
 257         mfd_remove_devices(&dev->dev);
 258         sysfs_remove_group(&dev->dev.kobj, &cmodio_sysfs_attr_group);
 259         iounmap(priv->ctrl);
 260         pci_release_regions(dev);
 261         pci_disable_device(dev);
 262 }
 263
 264 #define PCI_VENDOR_ID_JANZ              0x13c3
 265
 266 /* The list of devices that this module will support */
 267 static const struct pci_device_id cmodio_pci_ids[] = {
 268         { PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030, PCI_VENDOR_ID_JANZ, 0x0101 },
 269         { PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050, PCI_VENDOR_ID_JANZ, 0x0100 },
 270         { 0, }
 271 };
 272 MODULE_DEVICE_TABLE(pci, cmodio_pci_ids);
 273
 274 static struct pci_driver cmodio_pci_driver = {
 275         .name     = DRV_NAME,
 276         .id_table = cmodio_pci_ids,
 277         .probe    = cmodio_pci_probe,
 278         .remove   = cmodio_pci_remove,
 279 };
 280
 281 module_pci_driver(cmodio_pci_driver);
 282
 283 MODULE_AUTHOR("Ira W. Snyder <iws@ovro.caltech.edu>");
 284 MODULE_DESCRIPTION("Janz CMOD-IO PCI MODULbus Carrier Board Driver");
 285 MODULE_LICENSE("GPL");