Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

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 */
 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");
286 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us