Commit | Line | Data |
---|---|---|
bd358132 IS |
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> | |
8102bad2 | 21 | #include <linux/slab.h> |
bd358132 IS |
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 unsigned 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; | |
65e52359 | 89 | cell->mfd_data = pdata; |
bd358132 IS |
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 __devinit 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); | |
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 __devinit 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 = kzalloc(sizeof(*priv), GFP_KERNEL); | |
186 | if (!priv) { | |
187 | dev_err(&dev->dev, "unable to allocate private data\n"); | |
188 | ret = -ENOMEM; | |
189 | goto out_return; | |
190 | } | |
191 | ||
192 | pci_set_drvdata(dev, priv); | |
193 | priv->pdev = dev; | |
194 | ||
195 | /* Hardware Initialization */ | |
196 | ret = pci_enable_device(dev); | |
197 | if (ret) { | |
198 | dev_err(&dev->dev, "unable to enable device\n"); | |
199 | goto out_free_priv; | |
200 | } | |
201 | ||
202 | pci_set_master(dev); | |
203 | ret = pci_request_regions(dev, DRV_NAME); | |
204 | if (ret) { | |
205 | dev_err(&dev->dev, "unable to request regions\n"); | |
206 | goto out_pci_disable_device; | |
207 | } | |
208 | ||
209 | /* Onboard configuration registers */ | |
210 | priv->ctrl = pci_ioremap_bar(dev, 4); | |
211 | if (!priv->ctrl) { | |
212 | dev_err(&dev->dev, "unable to remap onboard regs\n"); | |
213 | ret = -ENOMEM; | |
214 | goto out_pci_release_regions; | |
215 | } | |
216 | ||
217 | /* Read the hex switch on the carrier board */ | |
218 | priv->hex = ioread8(&priv->ctrl->int_enable); | |
219 | ||
220 | /* Add the MODULbus number (hex switch value) to the device's sysfs */ | |
221 | ret = sysfs_create_group(&dev->dev.kobj, &cmodio_sysfs_attr_group); | |
222 | if (ret) { | |
223 | dev_err(&dev->dev, "unable to create sysfs attributes\n"); | |
224 | goto out_unmap_ctrl; | |
225 | } | |
226 | ||
227 | /* | |
228 | * Disable all interrupt lines, each submodule will enable its | |
229 | * own interrupt line if needed | |
230 | */ | |
231 | iowrite8(0xf, &priv->ctrl->int_disable); | |
232 | ||
233 | /* Register drivers for all submodules */ | |
234 | ret = cmodio_probe_submodules(priv); | |
235 | if (ret) { | |
236 | dev_err(&dev->dev, "unable to probe submodules\n"); | |
237 | goto out_sysfs_remove_group; | |
238 | } | |
239 | ||
240 | return 0; | |
241 | ||
242 | out_sysfs_remove_group: | |
243 | sysfs_remove_group(&dev->dev.kobj, &cmodio_sysfs_attr_group); | |
244 | out_unmap_ctrl: | |
245 | iounmap(priv->ctrl); | |
246 | out_pci_release_regions: | |
247 | pci_release_regions(dev); | |
248 | out_pci_disable_device: | |
249 | pci_disable_device(dev); | |
250 | out_free_priv: | |
251 | kfree(priv); | |
252 | out_return: | |
253 | return ret; | |
254 | } | |
255 | ||
256 | static void __devexit cmodio_pci_remove(struct pci_dev *dev) | |
257 | { | |
258 | struct cmodio_device *priv = pci_get_drvdata(dev); | |
259 | ||
260 | mfd_remove_devices(&dev->dev); | |
261 | sysfs_remove_group(&dev->dev.kobj, &cmodio_sysfs_attr_group); | |
262 | iounmap(priv->ctrl); | |
263 | pci_release_regions(dev); | |
264 | pci_disable_device(dev); | |
265 | kfree(priv); | |
266 | } | |
267 | ||
268 | #define PCI_VENDOR_ID_JANZ 0x13c3 | |
269 | ||
270 | /* The list of devices that this module will support */ | |
271 | static DEFINE_PCI_DEVICE_TABLE(cmodio_pci_ids) = { | |
272 | { PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030, PCI_VENDOR_ID_JANZ, 0x0101 }, | |
273 | { PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050, PCI_VENDOR_ID_JANZ, 0x0100 }, | |
274 | { 0, } | |
275 | }; | |
276 | MODULE_DEVICE_TABLE(pci, cmodio_pci_ids); | |
277 | ||
278 | static struct pci_driver cmodio_pci_driver = { | |
279 | .name = DRV_NAME, | |
280 | .id_table = cmodio_pci_ids, | |
281 | .probe = cmodio_pci_probe, | |
282 | .remove = __devexit_p(cmodio_pci_remove), | |
283 | }; | |
284 | ||
285 | /* | |
286 | * Module Init / Exit | |
287 | */ | |
288 | ||
289 | static int __init cmodio_init(void) | |
290 | { | |
291 | return pci_register_driver(&cmodio_pci_driver); | |
292 | } | |
293 | ||
294 | static void __exit cmodio_exit(void) | |
295 | { | |
296 | pci_unregister_driver(&cmodio_pci_driver); | |
297 | } | |
298 | ||
299 | MODULE_AUTHOR("Ira W. Snyder <iws@ovro.caltech.edu>"); | |
300 | MODULE_DESCRIPTION("Janz CMOD-IO PCI MODULbus Carrier Board Driver"); | |
301 | MODULE_LICENSE("GPL"); | |
302 | ||
303 | module_init(cmodio_init); | |
304 | module_exit(cmodio_exit); |