]>
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> | |
bd358132 IS |
16 | #include <linux/pci.h> |
17 | #include <linux/interrupt.h> | |
18 | #include <linux/delay.h> | |
19 | #include <linux/platform_device.h> | |
8102bad2 | 20 | #include <linux/slab.h> |
bd358132 IS |
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; | |
bafeafea | 35 | static char *modules[CMODIO_MAX_MODULES] = { |
bd358132 IS |
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 | ||
f791be49 | 65 | static int cmodio_setup_subdevice(struct cmodio_device *priv, |
bd358132 IS |
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; | |
3d2bdf75 SO |
88 | cell->platform_data = pdata; |
89 | cell->pdata_size = sizeof(*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 */ | |
f791be49 | 122 | static int cmodio_probe_submodules(struct cmodio_device *priv) |
bd358132 IS |
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, | |
0848c94f | 149 | num_probed, NULL, pdev->irq, NULL); |
bd358132 IS |
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 | ||
f791be49 | 179 | static int cmodio_pci_probe(struct pci_dev *dev, |
bd358132 IS |
180 | const struct pci_device_id *id) |
181 | { | |
182 | struct cmodio_device *priv; | |
183 | int ret; | |
184 | ||
fa75d4a6 | 185 | priv = devm_kzalloc(&dev->dev, sizeof(*priv), GFP_KERNEL); |
bd358132 IS |
186 | if (!priv) { |
187 | dev_err(&dev->dev, "unable to allocate private data\n"); | |
fa75d4a6 | 188 | return -ENOMEM; |
bd358132 IS |
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"); | |
fa75d4a6 | 198 | return ret; |
bd358132 IS |
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); | |
fa75d4a6 | 249 | |
bd358132 IS |
250 | return ret; |
251 | } | |
252 | ||
4740f73f | 253 | static void cmodio_pci_remove(struct pci_dev *dev) |
bd358132 IS |
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); | |
bd358132 IS |
262 | } |
263 | ||
264 | #define PCI_VENDOR_ID_JANZ 0x13c3 | |
265 | ||
266 | /* The list of devices that this module will support */ | |
36fcd06c | 267 | static const struct pci_device_id cmodio_pci_ids[] = { |
bd358132 IS |
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 }, | |
844e0edf AG |
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 }, | |
bd358132 IS |
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, | |
84449216 | 282 | .remove = cmodio_pci_remove, |
bd358132 IS |
283 | }; |
284 | ||
38a36f5a | 285 | module_pci_driver(cmodio_pci_driver); |
bd358132 IS |
286 | |
287 | MODULE_AUTHOR("Ira W. Snyder <iws@ovro.caltech.edu>"); | |
288 | MODULE_DESCRIPTION("Janz CMOD-IO PCI MODULbus Carrier Board Driver"); | |
289 | MODULE_LICENSE("GPL"); |