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 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->platform_data = pdata; 90 cell->pdata_size = sizeof(*pdata); 91 92 /* MODULbus registers -- PCI BAR3 is big-endian MODULbus access */ 93 res->flags = IORESOURCE_MEM; 94 res->parent = &pci->resource[3]; 95 res->start = pci->resource[3].start + (CMODIO_MODULBUS_SIZE * modno); 96 res->end = res->start + CMODIO_MODULBUS_SIZE - 1; 97 res++; 98 99 /* PLX Control Registers -- PCI BAR4 is interrupt and other registers */ 100 res->flags = IORESOURCE_MEM; 101 res->parent = &pci->resource[4]; 102 res->start = pci->resource[4].start; 103 res->end = pci->resource[4].end; 104 res++; 105 106 /* 107 * IRQ 108 * 109 * The start and end fields are used as an offset to the irq_base 110 * parameter passed into the mfd_add_devices() function call. All 111 * devices share the same IRQ. 112 */ 113 res->flags = IORESOURCE_IRQ; 114 res->parent = NULL; 115 res->start = 0; 116 res->end = 0; 117 res++; 118 119 return 0; 120 } 121 122 /* Probe each submodule using kernel parameters */ 123 static int __devinit cmodio_probe_submodules(struct cmodio_device *priv) 124 { 125 struct pci_dev *pdev = priv->pdev; 126 unsigned int num_probed = 0; 127 char *name; 128 int i; 129 130 for (i = 0; i < num_modules; i++) { 131 name = modules[i]; 132 if (!strcmp(name, "") || !strcmp(name, "empty")) 133 continue; 134 135 dev_dbg(&priv->pdev->dev, "MODULbus %d: name %s\n", i, name); 136 cmodio_setup_subdevice(priv, name, num_probed, i); 137 num_probed++; 138 } 139 140 /* print an error message if no modules were probed */ 141 if (num_probed == 0) { 142 dev_err(&priv->pdev->dev, "no MODULbus modules specified, " 143 "please set the ``modules'' kernel " 144 "parameter according to your " 145 "hardware configuration\n"); 146 return -ENODEV; 147 } 148 149 return mfd_add_devices(&pdev->dev, 0, priv->cells, 150 num_probed, NULL, pdev->irq, NULL); 151 } 152 153 /* 154 * SYSFS Attributes 155 */ 156 157 static ssize_t mbus_show(struct device *dev, struct device_attribute *attr, 158 char *buf) 159 { 160 struct cmodio_device *priv = dev_get_drvdata(dev); 161 162 return snprintf(buf, PAGE_SIZE, "%x\n", priv->hex); 163 } 164 165 static DEVICE_ATTR(modulbus_number, S_IRUGO, mbus_show, NULL); 166 167 static struct attribute *cmodio_sysfs_attrs[] = { 168 &dev_attr_modulbus_number.attr, 169 NULL, 170 }; 171 172 static const struct attribute_group cmodio_sysfs_attr_group = { 173 .attrs = cmodio_sysfs_attrs, 174 }; 175 176 /* 177 * PCI Driver 178 */ 179 180 static int __devinit cmodio_pci_probe(struct pci_dev *dev, 181 const struct pci_device_id *id) 182 { 183 struct cmodio_device *priv; 184 int ret; 185 186 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 187 if (!priv) { 188 dev_err(&dev->dev, "unable to allocate private data\n"); 189 ret = -ENOMEM; 190 goto out_return; 191 } 192 193 pci_set_drvdata(dev, priv); 194 priv->pdev = dev; 195 196 /* Hardware Initialization */ 197 ret = pci_enable_device(dev); 198 if (ret) { 199 dev_err(&dev->dev, "unable to enable device\n"); 200 goto out_free_priv; 201 } 202 203 pci_set_master(dev); 204 ret = pci_request_regions(dev, DRV_NAME); 205 if (ret) { 206 dev_err(&dev->dev, "unable to request regions\n"); 207 goto out_pci_disable_device; 208 } 209 210 /* Onboard configuration registers */ 211 priv->ctrl = pci_ioremap_bar(dev, 4); 212 if (!priv->ctrl) { 213 dev_err(&dev->dev, "unable to remap onboard regs\n"); 214 ret = -ENOMEM; 215 goto out_pci_release_regions; 216 } 217 218 /* Read the hex switch on the carrier board */ 219 priv->hex = ioread8(&priv->ctrl->int_enable); 220 221 /* Add the MODULbus number (hex switch value) to the device's sysfs */ 222 ret = sysfs_create_group(&dev->dev.kobj, &cmodio_sysfs_attr_group); 223 if (ret) { 224 dev_err(&dev->dev, "unable to create sysfs attributes\n"); 225 goto out_unmap_ctrl; 226 } 227 228 /* 229 * Disable all interrupt lines, each submodule will enable its 230 * own interrupt line if needed 231 */ 232 iowrite8(0xf, &priv->ctrl->int_disable); 233 234 /* Register drivers for all submodules */ 235 ret = cmodio_probe_submodules(priv); 236 if (ret) { 237 dev_err(&dev->dev, "unable to probe submodules\n"); 238 goto out_sysfs_remove_group; 239 } 240 241 return 0; 242 243 out_sysfs_remove_group: 244 sysfs_remove_group(&dev->dev.kobj, &cmodio_sysfs_attr_group); 245 out_unmap_ctrl: 246 iounmap(priv->ctrl); 247 out_pci_release_regions: 248 pci_release_regions(dev); 249 out_pci_disable_device: 250 pci_disable_device(dev); 251 out_free_priv: 252 kfree(priv); 253 out_return: 254 return ret; 255 } 256 257 static void __devexit cmodio_pci_remove(struct pci_dev *dev) 258 { 259 struct cmodio_device *priv = pci_get_drvdata(dev); 260 261 mfd_remove_devices(&dev->dev); 262 sysfs_remove_group(&dev->dev.kobj, &cmodio_sysfs_attr_group); 263 iounmap(priv->ctrl); 264 pci_release_regions(dev); 265 pci_disable_device(dev); 266 kfree(priv); 267 } 268 269 #define PCI_VENDOR_ID_JANZ 0x13c3 270 271 /* The list of devices that this module will support */ 272 static DEFINE_PCI_DEVICE_TABLE(cmodio_pci_ids) = { 273 { PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030, PCI_VENDOR_ID_JANZ, 0x0101 }, 274 { PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050, PCI_VENDOR_ID_JANZ, 0x0100 }, 275 { 0, } 276 }; 277 MODULE_DEVICE_TABLE(pci, cmodio_pci_ids); 278 279 static struct pci_driver cmodio_pci_driver = { 280 .name = DRV_NAME, 281 .id_table = cmodio_pci_ids, 282 .probe = cmodio_pci_probe, 283 .remove = __devexit_p(cmodio_pci_remove), 284 }; 285 286 module_pci_driver(cmodio_pci_driver); 287 288 MODULE_AUTHOR("Ira W. Snyder <iws@ovro.caltech.edu>"); 289 MODULE_DESCRIPTION("Janz CMOD-IO PCI MODULbus Carrier Board Driver"); 290 MODULE_LICENSE("GPL"); 291