Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * EISA bus support functions for sysfs. | |
3 | * | |
4 | * (C) 2002, 2003 Marc Zyngier <maz@wild-wind.fr.eu.org> | |
5 | * | |
6 | * This code is released under the GPL version 2. | |
7 | */ | |
8 | ||
9 | #include <linux/kernel.h> | |
10 | #include <linux/device.h> | |
11 | #include <linux/eisa.h> | |
12 | #include <linux/module.h> | |
13 | #include <linux/moduleparam.h> | |
14 | #include <linux/init.h> | |
15 | #include <linux/slab.h> | |
16 | #include <linux/ioport.h> | |
17 | #include <asm/io.h> | |
18 | ||
19 | #define SLOT_ADDRESS(r,n) (r->bus_base_addr + (0x1000 * n)) | |
20 | ||
21 | #define EISA_DEVINFO(i,s) { .id = { .sig = i }, .name = s } | |
22 | ||
23 | struct eisa_device_info { | |
24 | struct eisa_device_id id; | |
ca52a498 | 25 | char name[50]; |
1da177e4 LT |
26 | }; |
27 | ||
28 | #ifdef CONFIG_EISA_NAMES | |
29 | static struct eisa_device_info __initdata eisa_table[] = { | |
30 | #include "devlist.h" | |
31 | }; | |
32 | #define EISA_INFOS (sizeof (eisa_table) / (sizeof (struct eisa_device_info))) | |
33 | #endif | |
34 | ||
35 | #define EISA_MAX_FORCED_DEV 16 | |
36 | ||
37 | static int enable_dev[EISA_MAX_FORCED_DEV]; | |
64a6f950 | 38 | static unsigned int enable_dev_count; |
1da177e4 | 39 | static int disable_dev[EISA_MAX_FORCED_DEV]; |
64a6f950 | 40 | static unsigned int disable_dev_count; |
1da177e4 | 41 | |
33fd797b TLSC |
42 | static int is_forced_dev(int *forced_tab, |
43 | int forced_count, | |
44 | struct eisa_root_device *root, | |
45 | struct eisa_device *edev) | |
1da177e4 LT |
46 | { |
47 | int i, x; | |
48 | ||
49 | for (i = 0; i < forced_count; i++) { | |
50 | x = (root->bus_nr << 8) | edev->slot; | |
51 | if (forced_tab[i] == x) | |
52 | return 1; | |
53 | } | |
54 | ||
55 | return 0; | |
56 | } | |
57 | ||
33fd797b | 58 | static void __init eisa_name_device(struct eisa_device *edev) |
1da177e4 LT |
59 | { |
60 | #ifdef CONFIG_EISA_NAMES | |
61 | int i; | |
62 | for (i = 0; i < EISA_INFOS; i++) { | |
33fd797b TLSC |
63 | if (!strcmp(edev->id.sig, eisa_table[i].id.sig)) { |
64 | strlcpy(edev->pretty_name, | |
65 | eisa_table[i].name, | |
66 | sizeof(edev->pretty_name)); | |
1da177e4 LT |
67 | return; |
68 | } | |
69 | } | |
70 | ||
71 | /* No name was found */ | |
33fd797b | 72 | sprintf(edev->pretty_name, "EISA device %.7s", edev->id.sig); |
1da177e4 LT |
73 | #endif |
74 | } | |
75 | ||
76 | static char __init *decode_eisa_sig(unsigned long addr) | |
77 | { | |
78 | static char sig_str[EISA_SIG_LEN]; | |
79 | u8 sig[4]; | |
80 | u16 rev; | |
81 | int i; | |
82 | ||
83 | for (i = 0; i < 4; i++) { | |
84 | #ifdef CONFIG_EISA_VLB_PRIMING | |
85 | /* | |
86 | * This ugly stuff is used to wake up VL-bus cards | |
87 | * (AHA-284x is the only known example), so we can | |
88 | * read the EISA id. | |
89 | * | |
90 | * Thankfully, this only exists on x86... | |
91 | */ | |
92 | outb(0x80 + i, addr); | |
93 | #endif | |
33fd797b | 94 | sig[i] = inb(addr + i); |
1da177e4 LT |
95 | |
96 | if (!i && (sig[0] & 0x80)) | |
97 | return NULL; | |
98 | } | |
99 | ||
100 | sig_str[0] = ((sig[0] >> 2) & 0x1f) + ('A' - 1); | |
101 | sig_str[1] = (((sig[0] & 3) << 3) | (sig[1] >> 5)) + ('A' - 1); | |
102 | sig_str[2] = (sig[1] & 0x1f) + ('A' - 1); | |
103 | rev = (sig[2] << 8) | sig[3]; | |
104 | sprintf(sig_str + 3, "%04X", rev); | |
105 | ||
106 | return sig_str; | |
107 | } | |
108 | ||
33fd797b | 109 | static int eisa_bus_match(struct device *dev, struct device_driver *drv) |
1da177e4 | 110 | { |
33fd797b TLSC |
111 | struct eisa_device *edev = to_eisa_device(dev); |
112 | struct eisa_driver *edrv = to_eisa_driver(drv); | |
1da177e4 LT |
113 | const struct eisa_device_id *eids = edrv->id_table; |
114 | ||
115 | if (!eids) | |
116 | return 0; | |
117 | ||
33fd797b TLSC |
118 | while (strlen(eids->sig)) { |
119 | if (!strcmp(eids->sig, edev->id.sig) && | |
1da177e4 LT |
120 | edev->state & EISA_CONFIG_ENABLED) { |
121 | edev->id.driver_data = eids->driver_data; | |
122 | return 1; | |
123 | } | |
124 | ||
125 | eids++; | |
126 | } | |
127 | ||
128 | return 0; | |
129 | } | |
130 | ||
7eff2e7a | 131 | static int eisa_bus_uevent(struct device *dev, struct kobj_uevent_env *env) |
07563c71 MT |
132 | { |
133 | struct eisa_device *edev = to_eisa_device(dev); | |
07563c71 | 134 | |
7eff2e7a | 135 | add_uevent_var(env, "MODALIAS=" EISA_DEVICE_MODALIAS_FMT, edev->id.sig); |
07563c71 MT |
136 | return 0; |
137 | } | |
138 | ||
1da177e4 LT |
139 | struct bus_type eisa_bus_type = { |
140 | .name = "eisa", | |
141 | .match = eisa_bus_match, | |
07563c71 | 142 | .uevent = eisa_bus_uevent, |
1da177e4 | 143 | }; |
33fd797b | 144 | EXPORT_SYMBOL(eisa_bus_type); |
1da177e4 | 145 | |
33fd797b | 146 | int eisa_driver_register(struct eisa_driver *edrv) |
1da177e4 | 147 | { |
1da177e4 | 148 | edrv->driver.bus = &eisa_bus_type; |
33fd797b | 149 | return driver_register(&edrv->driver); |
1da177e4 | 150 | } |
33fd797b | 151 | EXPORT_SYMBOL(eisa_driver_register); |
1da177e4 | 152 | |
33fd797b | 153 | void eisa_driver_unregister(struct eisa_driver *edrv) |
1da177e4 | 154 | { |
33fd797b | 155 | driver_unregister(&edrv->driver); |
1da177e4 | 156 | } |
33fd797b | 157 | EXPORT_SYMBOL(eisa_driver_unregister); |
1da177e4 | 158 | |
33fd797b TLSC |
159 | static ssize_t eisa_show_sig(struct device *dev, struct device_attribute *attr, |
160 | char *buf) | |
1da177e4 | 161 | { |
33fd797b TLSC |
162 | struct eisa_device *edev = to_eisa_device(dev); |
163 | return sprintf(buf, "%s\n", edev->id.sig); | |
1da177e4 LT |
164 | } |
165 | ||
166 | static DEVICE_ATTR(signature, S_IRUGO, eisa_show_sig, NULL); | |
167 | ||
33fd797b TLSC |
168 | static ssize_t eisa_show_state(struct device *dev, |
169 | struct device_attribute *attr, | |
170 | char *buf) | |
1da177e4 | 171 | { |
33fd797b TLSC |
172 | struct eisa_device *edev = to_eisa_device(dev); |
173 | return sprintf(buf, "%d\n", edev->state & EISA_CONFIG_ENABLED); | |
1da177e4 LT |
174 | } |
175 | ||
176 | static DEVICE_ATTR(enabled, S_IRUGO, eisa_show_state, NULL); | |
177 | ||
33fd797b TLSC |
178 | static ssize_t eisa_show_modalias(struct device *dev, |
179 | struct device_attribute *attr, | |
180 | char *buf) | |
07563c71 | 181 | { |
33fd797b TLSC |
182 | struct eisa_device *edev = to_eisa_device(dev); |
183 | return sprintf(buf, EISA_DEVICE_MODALIAS_FMT "\n", edev->id.sig); | |
07563c71 MT |
184 | } |
185 | ||
186 | static DEVICE_ATTR(modalias, S_IRUGO, eisa_show_modalias, NULL); | |
187 | ||
33fd797b TLSC |
188 | static int __init eisa_init_device(struct eisa_root_device *root, |
189 | struct eisa_device *edev, | |
190 | int slot) | |
1da177e4 LT |
191 | { |
192 | char *sig; | |
33fd797b | 193 | unsigned long sig_addr; |
1da177e4 LT |
194 | int i; |
195 | ||
33fd797b | 196 | sig_addr = SLOT_ADDRESS(root, slot) + EISA_VENDOR_ID_OFFSET; |
1da177e4 | 197 | |
33fd797b TLSC |
198 | sig = decode_eisa_sig(sig_addr); |
199 | if (!sig) | |
1da177e4 LT |
200 | return -1; /* No EISA device here */ |
201 | ||
33fd797b | 202 | memcpy(edev->id.sig, sig, EISA_SIG_LEN); |
1da177e4 | 203 | edev->slot = slot; |
33fd797b TLSC |
204 | edev->state = inb(SLOT_ADDRESS(root, slot) + EISA_CONFIG_OFFSET) |
205 | & EISA_CONFIG_ENABLED; | |
206 | edev->base_addr = SLOT_ADDRESS(root, slot); | |
1da177e4 | 207 | edev->dma_mask = root->dma_mask; /* Default DMA mask */ |
33fd797b | 208 | eisa_name_device(edev); |
1da177e4 LT |
209 | edev->dev.parent = root->dev; |
210 | edev->dev.bus = &eisa_bus_type; | |
211 | edev->dev.dma_mask = &edev->dma_mask; | |
212 | edev->dev.coherent_dma_mask = edev->dma_mask; | |
e537b245 | 213 | dev_set_name(&edev->dev, "%02X:%02X", root->bus_nr, slot); |
1da177e4 LT |
214 | |
215 | for (i = 0; i < EISA_MAX_RESOURCES; i++) { | |
216 | #ifdef CONFIG_EISA_NAMES | |
217 | edev->res[i].name = edev->pretty_name; | |
218 | #else | |
219 | edev->res[i].name = edev->id.sig; | |
220 | #endif | |
221 | } | |
222 | ||
33fd797b | 223 | if (is_forced_dev(enable_dev, enable_dev_count, root, edev)) |
1da177e4 LT |
224 | edev->state = EISA_CONFIG_ENABLED | EISA_CONFIG_FORCED; |
225 | ||
33fd797b | 226 | if (is_forced_dev(disable_dev, disable_dev_count, root, edev)) |
1da177e4 LT |
227 | edev->state = EISA_CONFIG_FORCED; |
228 | ||
229 | return 0; | |
230 | } | |
231 | ||
33fd797b | 232 | static int __init eisa_register_device(struct eisa_device *edev) |
1da177e4 | 233 | { |
33fd797b | 234 | int rc = device_register(&edev->dev); |
42ddfd68 JG |
235 | if (rc) |
236 | return rc; | |
1da177e4 | 237 | |
33fd797b TLSC |
238 | rc = device_create_file(&edev->dev, &dev_attr_signature); |
239 | if (rc) | |
240 | goto err_devreg; | |
241 | rc = device_create_file(&edev->dev, &dev_attr_enabled); | |
242 | if (rc) | |
243 | goto err_sig; | |
244 | rc = device_create_file(&edev->dev, &dev_attr_modalias); | |
245 | if (rc) | |
246 | goto err_enab; | |
1da177e4 LT |
247 | |
248 | return 0; | |
42ddfd68 JG |
249 | |
250 | err_enab: | |
33fd797b | 251 | device_remove_file(&edev->dev, &dev_attr_enabled); |
42ddfd68 | 252 | err_sig: |
33fd797b | 253 | device_remove_file(&edev->dev, &dev_attr_signature); |
42ddfd68 JG |
254 | err_devreg: |
255 | device_unregister(&edev->dev); | |
256 | return rc; | |
1da177e4 LT |
257 | } |
258 | ||
33fd797b TLSC |
259 | static int __init eisa_request_resources(struct eisa_root_device *root, |
260 | struct eisa_device *edev, | |
261 | int slot) | |
1da177e4 LT |
262 | { |
263 | int i; | |
264 | ||
265 | for (i = 0; i < EISA_MAX_RESOURCES; i++) { | |
266 | /* Don't register resource for slot 0, since this is | |
267 | * very likely to fail... :-( Instead, grab the EISA | |
268 | * id, now we can display something in /proc/ioports. | |
269 | */ | |
270 | ||
271 | /* Only one region for mainboard */ | |
272 | if (!slot && i > 0) { | |
273 | edev->res[i].start = edev->res[i].end = 0; | |
274 | continue; | |
275 | } | |
276 | ||
277 | if (slot) { | |
278 | edev->res[i].name = NULL; | |
33fd797b TLSC |
279 | edev->res[i].start = SLOT_ADDRESS(root, slot) |
280 | + (i * 0x400); | |
1da177e4 LT |
281 | edev->res[i].end = edev->res[i].start + 0xff; |
282 | edev->res[i].flags = IORESOURCE_IO; | |
283 | } else { | |
284 | edev->res[i].name = NULL; | |
33fd797b TLSC |
285 | edev->res[i].start = SLOT_ADDRESS(root, slot) |
286 | + EISA_VENDOR_ID_OFFSET; | |
1da177e4 LT |
287 | edev->res[i].end = edev->res[i].start + 3; |
288 | edev->res[i].flags = IORESOURCE_BUSY; | |
289 | } | |
290 | ||
33fd797b | 291 | if (request_resource(root->res, &edev->res[i])) |
1da177e4 LT |
292 | goto failed; |
293 | } | |
294 | ||
295 | return 0; | |
296 | ||
297 | failed: | |
298 | while (--i >= 0) | |
33fd797b | 299 | release_resource(&edev->res[i]); |
1da177e4 LT |
300 | |
301 | return -1; | |
302 | } | |
303 | ||
33fd797b | 304 | static void __init eisa_release_resources(struct eisa_device *edev) |
1da177e4 LT |
305 | { |
306 | int i; | |
307 | ||
308 | for (i = 0; i < EISA_MAX_RESOURCES; i++) | |
309 | if (edev->res[i].start || edev->res[i].end) | |
33fd797b | 310 | release_resource(&edev->res[i]); |
1da177e4 LT |
311 | } |
312 | ||
33fd797b | 313 | static int __init eisa_probe(struct eisa_root_device *root) |
1da177e4 LT |
314 | { |
315 | int i, c; | |
316 | struct eisa_device *edev; | |
317 | ||
33fd797b TLSC |
318 | printk(KERN_INFO "EISA: Probing bus %d at %s\n", |
319 | root->bus_nr, dev_name(root->dev)); | |
1da177e4 LT |
320 | |
321 | /* First try to get hold of slot 0. If there is no device | |
322 | * here, simply fail, unless root->force_probe is set. */ | |
323 | ||
33fd797b TLSC |
324 | edev = kzalloc(sizeof(*edev), GFP_KERNEL); |
325 | if (!edev) { | |
326 | printk(KERN_ERR "EISA: Couldn't allocate mainboard slot\n"); | |
1da177e4 LT |
327 | return -ENOMEM; |
328 | } | |
329 | ||
33fd797b TLSC |
330 | if (eisa_request_resources(root, edev, 0)) { |
331 | printk(KERN_WARNING \ | |
332 | "EISA: Cannot allocate resource for mainboard\n"); | |
333 | kfree(edev); | |
1da177e4 LT |
334 | if (!root->force_probe) |
335 | return -EBUSY; | |
336 | goto force_probe; | |
337 | } | |
338 | ||
33fd797b TLSC |
339 | if (eisa_init_device(root, edev, 0)) { |
340 | eisa_release_resources(edev); | |
341 | kfree(edev); | |
1da177e4 LT |
342 | if (!root->force_probe) |
343 | return -ENODEV; | |
344 | goto force_probe; | |
345 | } | |
346 | ||
33fd797b | 347 | printk(KERN_INFO "EISA: Mainboard %s detected.\n", edev->id.sig); |
1da177e4 | 348 | |
33fd797b TLSC |
349 | if (eisa_register_device(edev)) { |
350 | printk(KERN_ERR "EISA: Failed to register %s\n", | |
351 | edev->id.sig); | |
352 | eisa_release_resources(edev); | |
353 | kfree(edev); | |
1da177e4 LT |
354 | } |
355 | ||
356 | force_probe: | |
357 | ||
358 | for (c = 0, i = 1; i <= root->slots; i++) { | |
33fd797b TLSC |
359 | edev = kzalloc(sizeof(*edev), GFP_KERNEL); |
360 | if (!edev) { | |
361 | printk(KERN_ERR "EISA: Out of memory for slot %d\n", i); | |
1da177e4 LT |
362 | continue; |
363 | } | |
1da177e4 | 364 | |
33fd797b TLSC |
365 | if (eisa_request_resources(root, edev, i)) { |
366 | printk(KERN_WARNING \ | |
367 | "Cannot allocate resource for EISA slot %d\n", | |
368 | i); | |
369 | kfree(edev); | |
1da177e4 LT |
370 | continue; |
371 | } | |
372 | ||
33fd797b TLSC |
373 | if (eisa_init_device(root, edev, i)) { |
374 | eisa_release_resources(edev); | |
375 | kfree(edev); | |
1da177e4 LT |
376 | continue; |
377 | } | |
378 | ||
33fd797b TLSC |
379 | printk(KERN_INFO "EISA: slot %d : %s detected", |
380 | i, edev->id.sig); | |
1da177e4 LT |
381 | |
382 | switch (edev->state) { | |
383 | case EISA_CONFIG_ENABLED | EISA_CONFIG_FORCED: | |
33fd797b | 384 | printk(" (forced enabled)"); |
1da177e4 LT |
385 | break; |
386 | ||
387 | case EISA_CONFIG_FORCED: | |
33fd797b | 388 | printk(" (forced disabled)"); |
1da177e4 LT |
389 | break; |
390 | ||
391 | case 0: | |
33fd797b | 392 | printk(" (disabled)"); |
1da177e4 LT |
393 | break; |
394 | } | |
395 | ||
396 | printk (".\n"); | |
397 | ||
398 | c++; | |
399 | ||
33fd797b TLSC |
400 | if (eisa_register_device(edev)) { |
401 | printk(KERN_ERR "EISA: Failed to register %s\n", | |
402 | edev->id.sig); | |
403 | eisa_release_resources(edev); | |
404 | kfree(edev); | |
1da177e4 LT |
405 | } |
406 | } | |
407 | ||
33fd797b | 408 | printk(KERN_INFO "EISA: Detected %d card%s.\n", c, c == 1 ? "" : "s"); |
1da177e4 LT |
409 | |
410 | return 0; | |
411 | } | |
412 | ||
413 | static struct resource eisa_root_res = { | |
414 | .name = "EISA root resource", | |
415 | .start = 0, | |
416 | .end = 0xffffffff, | |
417 | .flags = IORESOURCE_IO, | |
418 | }; | |
419 | ||
420 | static int eisa_bus_count; | |
421 | ||
33fd797b | 422 | int __init eisa_root_register(struct eisa_root_device *root) |
1da177e4 LT |
423 | { |
424 | int err; | |
425 | ||
426 | /* Use our own resources to check if this bus base address has | |
427 | * been already registered. This prevents the virtual root | |
428 | * device from registering after the real one has, for | |
429 | * example... */ | |
430 | ||
431 | root->eisa_root_res.name = eisa_root_res.name; | |
432 | root->eisa_root_res.start = root->res->start; | |
433 | root->eisa_root_res.end = root->res->end; | |
434 | root->eisa_root_res.flags = IORESOURCE_BUSY; | |
435 | ||
33fd797b TLSC |
436 | err = request_resource(&eisa_root_res, &root->eisa_root_res); |
437 | if (err) | |
1da177e4 LT |
438 | return err; |
439 | ||
440 | root->bus_nr = eisa_bus_count++; | |
441 | ||
33fd797b TLSC |
442 | err = eisa_probe(root); |
443 | if (err) | |
444 | release_resource(&root->eisa_root_res); | |
1da177e4 LT |
445 | |
446 | return err; | |
447 | } | |
448 | ||
33fd797b | 449 | static int __init eisa_init(void) |
1da177e4 LT |
450 | { |
451 | int r; | |
452 | ||
33fd797b TLSC |
453 | r = bus_register(&eisa_bus_type); |
454 | if (r) | |
1da177e4 LT |
455 | return r; |
456 | ||
33fd797b | 457 | printk(KERN_INFO "EISA bus registered\n"); |
1da177e4 LT |
458 | return 0; |
459 | } | |
460 | ||
461 | module_param_array(enable_dev, int, &enable_dev_count, 0444); | |
462 | module_param_array(disable_dev, int, &disable_dev_count, 0444); | |
463 | ||
33fd797b | 464 | postcore_initcall(eisa_init); |
1da177e4 LT |
465 | |
466 | int EISA_bus; /* for legacy drivers */ | |
33fd797b | 467 | EXPORT_SYMBOL(EISA_bus); |