janz-cmodio.c

Go to the documentation of this file.

/*
 * Janz CMOD-IO MODULbus Carrier Board PCI Driver
 *
 * Copyright (c) 2010 Ira W. Snyder <[email protected]>
 *
 * Lots of inspiration and code was copied from drivers/mfd/sm501.c
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/pci.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/slab.h>
#include <linux/mfd/core.h>

#include <linux/mfd/janz.h>

#define DRV_NAME "janz-cmodio"

/* Size of each MODULbus module in PCI BAR4 */
#define CMODIO_MODULBUS_SIZE    0x200

/* Maximum number of MODULbus modules on a CMOD-IO carrier board */
#define CMODIO_MAX_MODULES  4

/* Module Parameters */
static unsigned int num_modules = CMODIO_MAX_MODULES;
static char *modules[CMODIO_MAX_MODULES] = {
    "empty", "empty", "empty", "empty",
};

module_param_array(modules, charp, &num_modules, S_IRUGO);
MODULE_PARM_DESC(modules, "MODULbus modules attached to the carrier board");

/* Unique Device Id */
static unsigned int cmodio_id;

struct cmodio_device {
    /* Parent PCI device */
    struct pci_dev *pdev;

    /* PLX control registers */
    struct janz_cmodio_onboard_regs __iomem *ctrl;

    /* hex switch position */
    u8 hex;

    /* mfd-core API */
    struct mfd_cell cells[CMODIO_MAX_MODULES];
    struct resource resources[3 * CMODIO_MAX_MODULES];
    struct janz_platform_data pdata[CMODIO_MAX_MODULES];
};

/*
 * Subdevices using the mfd-core API
 */

static int __devinit cmodio_setup_subdevice(struct cmodio_device *priv,
                        char *name, unsigned int devno,
                        unsigned int modno)
{
    struct janz_platform_data *pdata;
    struct mfd_cell *cell;
    struct resource *res;
    struct pci_dev *pci;

    pci = priv->pdev;
    cell = &priv->cells[devno];
    res = &priv->resources[devno * 3];
    pdata = &priv->pdata[devno];

    cell->name = name;
    cell->resources = res;
    cell->num_resources = 3;

    /* Setup the subdevice ID -- must be unique */
    cell->id = cmodio_id++;

    /* Add platform data */
    pdata->modno = modno;
    cell->platform_data = pdata;
    cell->pdata_size = sizeof(*pdata);

    /* MODULbus registers -- PCI BAR3 is big-endian MODULbus access */
    res->flags = IORESOURCE_MEM;
    res->parent = &pci->resource[3];
    res->start = pci->resource[3].start + (CMODIO_MODULBUS_SIZE * modno);
    res->end = res->start + CMODIO_MODULBUS_SIZE - 1;
    res++;

    /* PLX Control Registers -- PCI BAR4 is interrupt and other registers */
    res->flags = IORESOURCE_MEM;
    res->parent = &pci->resource[4];
    res->start = pci->resource[4].start;
    res->end = pci->resource[4].end;
    res++;

    /*
     * IRQ
     *
     * The start and end fields are used as an offset to the irq_base
     * parameter passed into the mfd_add_devices() function call. All
     * devices share the same IRQ.
     */
    res->flags = IORESOURCE_IRQ;
    res->parent = NULL;
    res->start = 0;
    res->end = 0;
    res++;

    return 0;
}

/* Probe each submodule using kernel parameters */
static int __devinit cmodio_probe_submodules(struct cmodio_device *priv)
{
    struct pci_dev *pdev = priv->pdev;
    unsigned int num_probed = 0;
    char *name;
    int i;

    for (i = 0; i < num_modules; i++) {
        name = modules[i];
        if (!strcmp(name, "") || !strcmp(name, "empty"))
            continue;

        dev_dbg(&priv->pdev->dev, "MODULbus %d: name %s\n", i, name);
        cmodio_setup_subdevice(priv, name, num_probed, i);
        num_probed++;
    }

    /* print an error message if no modules were probed */
    if (num_probed == 0) {
        dev_err(&priv->pdev->dev, "no MODULbus modules specified, "
                      "please set the ``modules'' kernel "
                      "parameter according to your "
                      "hardware configuration\n");
        return -ENODEV;
    }

    return mfd_add_devices(&pdev->dev, 0, priv->cells,
                   num_probed, NULL, pdev->irq, NULL);
}

/*
 * SYSFS Attributes
 */

static ssize_t mbus_show(struct device *dev, struct device_attribute *attr,
             char *buf)
{
    struct cmodio_device *priv = dev_get_drvdata(dev);

    return snprintf(buf, PAGE_SIZE, "%x\n", priv->hex);
}

static DEVICE_ATTR(modulbus_number, S_IRUGO, mbus_show, NULL);

static struct attribute *cmodio_sysfs_attrs[] = {
    &dev_attr_modulbus_number.attr,
    NULL,
};

static const struct attribute_group cmodio_sysfs_attr_group = {
    .attrs = cmodio_sysfs_attrs,
};

/*
 * PCI Driver
 */

static int __devinit cmodio_pci_probe(struct pci_dev *dev,
                      const struct pci_device_id *id)
{
    struct cmodio_device *priv;
    int ret;

    priv = kzalloc(sizeof(*priv), GFP_KERNEL);
    if (!priv) {
        dev_err(&dev->dev, "unable to allocate private data\n");
        ret = -ENOMEM;
        goto out_return;
    }

    pci_set_drvdata(dev, priv);
    priv->pdev = dev;

    /* Hardware Initialization */
    ret = pci_enable_device(dev);
    if (ret) {
        dev_err(&dev->dev, "unable to enable device\n");
        goto out_free_priv;
    }

    pci_set_master(dev);
    ret = pci_request_regions(dev, DRV_NAME);
    if (ret) {
        dev_err(&dev->dev, "unable to request regions\n");
        goto out_pci_disable_device;
    }

    /* Onboard configuration registers */
    priv->ctrl = pci_ioremap_bar(dev, 4);
    if (!priv->ctrl) {
        dev_err(&dev->dev, "unable to remap onboard regs\n");
        ret = -ENOMEM;
        goto out_pci_release_regions;
    }

    /* Read the hex switch on the carrier board */
    priv->hex = ioread8(&priv->ctrl->int_enable);

    /* Add the MODULbus number (hex switch value) to the device's sysfs */
    ret = sysfs_create_group(&dev->dev.kobj, &cmodio_sysfs_attr_group);
    if (ret) {
        dev_err(&dev->dev, "unable to create sysfs attributes\n");
        goto out_unmap_ctrl;
    }

    /*
     * Disable all interrupt lines, each submodule will enable its
     * own interrupt line if needed
     */
    iowrite8(0xf, &priv->ctrl->int_disable);

    /* Register drivers for all submodules */
    ret = cmodio_probe_submodules(priv);
    if (ret) {
        dev_err(&dev->dev, "unable to probe submodules\n");
        goto out_sysfs_remove_group;
    }

    return 0;

out_sysfs_remove_group:
    sysfs_remove_group(&dev->dev.kobj, &cmodio_sysfs_attr_group);
out_unmap_ctrl:
    iounmap(priv->ctrl);
out_pci_release_regions:
    pci_release_regions(dev);
out_pci_disable_device:
    pci_disable_device(dev);
out_free_priv:
    kfree(priv);
out_return:
    return ret;
}

static void __devexit cmodio_pci_remove(struct pci_dev *dev)
{
    struct cmodio_device *priv = pci_get_drvdata(dev);

    mfd_remove_devices(&dev->dev);
    sysfs_remove_group(&dev->dev.kobj, &cmodio_sysfs_attr_group);
    iounmap(priv->ctrl);
    pci_release_regions(dev);
    pci_disable_device(dev);
    kfree(priv);
}

#define PCI_VENDOR_ID_JANZ      0x13c3

/* The list of devices that this module will support */
static DEFINE_PCI_DEVICE_TABLE(cmodio_pci_ids) = {
    { PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030, PCI_VENDOR_ID_JANZ, 0x0101 },
    { PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050, PCI_VENDOR_ID_JANZ, 0x0100 },
    { 0, }
};
MODULE_DEVICE_TABLE(pci, cmodio_pci_ids);

static struct pci_driver cmodio_pci_driver = {
    .name     = DRV_NAME,
    .id_table = cmodio_pci_ids,
    .probe    = cmodio_pci_probe,
    .remove   = __devexit_p(cmodio_pci_remove),
};

module_pci_driver(cmodio_pci_driver);

MODULE_AUTHOR("Ira W. Snyder <[email protected]>");
MODULE_DESCRIPTION("Janz CMOD-IO PCI MODULbus Carrier Board Driver");
MODULE_LICENSE("GPL");