Root/
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 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 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 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 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 = 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 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9