LXR linux/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 */
  34static unsigned int num_modules = CMODIO_MAX_MODULES;
  35static char *modules[CMODIO_MAX_MODULES] = {
  36        "empty", "empty", "empty", "empty",
  37};
  38
  39module_param_array(modules, charp, &num_modules, S_IRUGO);
  40MODULE_PARM_DESC(modules, "MODULbus modules attached to the carrier board");
  41
  42/* Unique Device Id */
  43static unsigned int cmodio_id;
  44
  45struct 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
  65static 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 */
 122static 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
 156static 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
 164static DEVICE_ATTR(modulbus_number, S_IRUGO, mbus_show, NULL);
 165
 166static struct attribute *cmodio_sysfs_attrs[] = {
 167        &dev_attr_modulbus_number.attr,
 168        NULL,
 169};
 170
 171static const struct attribute_group cmodio_sysfs_attr_group = {
 172        .attrs = cmodio_sysfs_attrs,
 173};
 174
 175/*
 176 * PCI Driver
 177 */
 178
 179static 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
 241out_sysfs_remove_group:
 242        sysfs_remove_group(&dev->dev.kobj, &cmodio_sysfs_attr_group);
 243out_unmap_ctrl:
 244        iounmap(priv->ctrl);
 245out_pci_release_regions:
 246        pci_release_regions(dev);
 247out_pci_disable_device:
 248        pci_disable_device(dev);
 249
 250        return ret;
 251}
 252
 253static 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 */
 267static 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        { PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030, PCI_VENDOR_ID_JANZ, 0x0201 },
 271        { PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030, PCI_VENDOR_ID_JANZ, 0x0202 },
 272        { PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050, PCI_VENDOR_ID_JANZ, 0x0201 },
 273        { PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050, PCI_VENDOR_ID_JANZ, 0x0202 },
 274        { 0, }
 275};
 276MODULE_DEVICE_TABLE(pci, cmodio_pci_ids);
 277
 278static struct pci_driver cmodio_pci_driver = {
 279        .name     = DRV_NAME,
 280        .id_table = cmodio_pci_ids,
 281        .probe    = cmodio_pci_probe,
 282        .remove   = cmodio_pci_remove,
 283};
 284
 285module_pci_driver(cmodio_pci_driver);
 286
 287MODULE_AUTHOR("Ira W. Snyder <iws@ovro.caltech.edu>");
 288MODULE_DESCRIPTION("Janz CMOD-IO PCI MODULbus Carrier Board Driver");
 289MODULE_LICENSE("GPL");
 290