]>
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 LT |
41 | |
42 | static int is_forced_dev (int *forced_tab, | |
43 | int forced_count, | |
44 | struct eisa_root_device *root, | |
45 | struct eisa_device *edev) | |
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 | ||
58 | static void __init eisa_name_device (struct eisa_device *edev) | |
59 | { | |
60 | #ifdef CONFIG_EISA_NAMES | |
61 | int i; | |
62 | for (i = 0; i < EISA_INFOS; i++) { | |
63 | if (!strcmp (edev->id.sig, eisa_table[i].id.sig)) { | |
64 | strlcpy (edev->pretty_name, | |
65 | eisa_table[i].name, | |
ca52a498 | 66 | sizeof(edev->pretty_name)); |
1da177e4 LT |
67 | return; |
68 | } | |
69 | } | |
70 | ||
71 | /* No name was found */ | |
72 | sprintf (edev->pretty_name, "EISA device %.7s", edev->id.sig); | |
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 | |
94 | sig[i] = inb (addr + i); | |
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 | ||
109 | static int eisa_bus_match (struct device *dev, struct device_driver *drv) | |
110 | { | |
111 | struct eisa_device *edev = to_eisa_device (dev); | |
112 | struct eisa_driver *edrv = to_eisa_driver (drv); | |
113 | const struct eisa_device_id *eids = edrv->id_table; | |
114 | ||
115 | if (!eids) | |
116 | return 0; | |
117 | ||
118 | while (strlen (eids->sig)) { | |
119 | if (!strcmp (eids->sig, edev->id.sig) && | |
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 LT |
143 | }; |
144 | ||
145 | int eisa_driver_register (struct eisa_driver *edrv) | |
146 | { | |
1da177e4 | 147 | edrv->driver.bus = &eisa_bus_type; |
c2f6fabb | 148 | return driver_register (&edrv->driver); |
1da177e4 LT |
149 | } |
150 | ||
151 | void eisa_driver_unregister (struct eisa_driver *edrv) | |
152 | { | |
153 | driver_unregister (&edrv->driver); | |
154 | } | |
155 | ||
74880c06 | 156 | static ssize_t eisa_show_sig (struct device *dev, struct device_attribute *attr, char *buf) |
1da177e4 LT |
157 | { |
158 | struct eisa_device *edev = to_eisa_device (dev); | |
159 | return sprintf (buf,"%s\n", edev->id.sig); | |
160 | } | |
161 | ||
162 | static DEVICE_ATTR(signature, S_IRUGO, eisa_show_sig, NULL); | |
163 | ||
74880c06 | 164 | static ssize_t eisa_show_state (struct device *dev, struct device_attribute *attr, char *buf) |
1da177e4 LT |
165 | { |
166 | struct eisa_device *edev = to_eisa_device (dev); | |
167 | return sprintf (buf,"%d\n", edev->state & EISA_CONFIG_ENABLED); | |
168 | } | |
169 | ||
170 | static DEVICE_ATTR(enabled, S_IRUGO, eisa_show_state, NULL); | |
171 | ||
07563c71 MT |
172 | static ssize_t eisa_show_modalias (struct device *dev, struct device_attribute *attr, char *buf) |
173 | { | |
174 | struct eisa_device *edev = to_eisa_device (dev); | |
175 | return sprintf (buf, EISA_DEVICE_MODALIAS_FMT "\n", edev->id.sig); | |
176 | } | |
177 | ||
178 | static DEVICE_ATTR(modalias, S_IRUGO, eisa_show_modalias, NULL); | |
179 | ||
1da177e4 LT |
180 | static int __init eisa_init_device (struct eisa_root_device *root, |
181 | struct eisa_device *edev, | |
182 | int slot) | |
183 | { | |
184 | char *sig; | |
185 | unsigned long sig_addr; | |
186 | int i; | |
187 | ||
188 | sig_addr = SLOT_ADDRESS (root, slot) + EISA_VENDOR_ID_OFFSET; | |
189 | ||
190 | if (!(sig = decode_eisa_sig (sig_addr))) | |
191 | return -1; /* No EISA device here */ | |
192 | ||
193 | memcpy (edev->id.sig, sig, EISA_SIG_LEN); | |
194 | edev->slot = slot; | |
195 | edev->state = inb (SLOT_ADDRESS (root, slot) + EISA_CONFIG_OFFSET) & EISA_CONFIG_ENABLED; | |
196 | edev->base_addr = SLOT_ADDRESS (root, slot); | |
197 | edev->dma_mask = root->dma_mask; /* Default DMA mask */ | |
198 | eisa_name_device (edev); | |
199 | edev->dev.parent = root->dev; | |
200 | edev->dev.bus = &eisa_bus_type; | |
201 | edev->dev.dma_mask = &edev->dma_mask; | |
202 | edev->dev.coherent_dma_mask = edev->dma_mask; | |
203 | sprintf (edev->dev.bus_id, "%02X:%02X", root->bus_nr, slot); | |
204 | ||
205 | for (i = 0; i < EISA_MAX_RESOURCES; i++) { | |
206 | #ifdef CONFIG_EISA_NAMES | |
207 | edev->res[i].name = edev->pretty_name; | |
208 | #else | |
209 | edev->res[i].name = edev->id.sig; | |
210 | #endif | |
211 | } | |
212 | ||
213 | if (is_forced_dev (enable_dev, enable_dev_count, root, edev)) | |
214 | edev->state = EISA_CONFIG_ENABLED | EISA_CONFIG_FORCED; | |
215 | ||
216 | if (is_forced_dev (disable_dev, disable_dev_count, root, edev)) | |
217 | edev->state = EISA_CONFIG_FORCED; | |
218 | ||
219 | return 0; | |
220 | } | |
221 | ||
222 | static int __init eisa_register_device (struct eisa_device *edev) | |
223 | { | |
42ddfd68 JG |
224 | int rc = device_register (&edev->dev); |
225 | if (rc) | |
226 | return rc; | |
1da177e4 | 227 | |
42ddfd68 JG |
228 | rc = device_create_file (&edev->dev, &dev_attr_signature); |
229 | if (rc) goto err_devreg; | |
230 | rc = device_create_file (&edev->dev, &dev_attr_enabled); | |
231 | if (rc) goto err_sig; | |
232 | rc = device_create_file (&edev->dev, &dev_attr_modalias); | |
233 | if (rc) goto err_enab; | |
1da177e4 LT |
234 | |
235 | return 0; | |
42ddfd68 JG |
236 | |
237 | err_enab: | |
238 | device_remove_file (&edev->dev, &dev_attr_enabled); | |
239 | err_sig: | |
240 | device_remove_file (&edev->dev, &dev_attr_signature); | |
241 | err_devreg: | |
242 | device_unregister(&edev->dev); | |
243 | return rc; | |
1da177e4 LT |
244 | } |
245 | ||
246 | static int __init eisa_request_resources (struct eisa_root_device *root, | |
247 | struct eisa_device *edev, | |
248 | int slot) | |
249 | { | |
250 | int i; | |
251 | ||
252 | for (i = 0; i < EISA_MAX_RESOURCES; i++) { | |
253 | /* Don't register resource for slot 0, since this is | |
254 | * very likely to fail... :-( Instead, grab the EISA | |
255 | * id, now we can display something in /proc/ioports. | |
256 | */ | |
257 | ||
258 | /* Only one region for mainboard */ | |
259 | if (!slot && i > 0) { | |
260 | edev->res[i].start = edev->res[i].end = 0; | |
261 | continue; | |
262 | } | |
263 | ||
264 | if (slot) { | |
265 | edev->res[i].name = NULL; | |
266 | edev->res[i].start = SLOT_ADDRESS (root, slot) + (i * 0x400); | |
267 | edev->res[i].end = edev->res[i].start + 0xff; | |
268 | edev->res[i].flags = IORESOURCE_IO; | |
269 | } else { | |
270 | edev->res[i].name = NULL; | |
271 | edev->res[i].start = SLOT_ADDRESS (root, slot) + EISA_VENDOR_ID_OFFSET; | |
272 | edev->res[i].end = edev->res[i].start + 3; | |
273 | edev->res[i].flags = IORESOURCE_BUSY; | |
274 | } | |
275 | ||
276 | if (request_resource (root->res, &edev->res[i])) | |
277 | goto failed; | |
278 | } | |
279 | ||
280 | return 0; | |
281 | ||
282 | failed: | |
283 | while (--i >= 0) | |
284 | release_resource (&edev->res[i]); | |
285 | ||
286 | return -1; | |
287 | } | |
288 | ||
289 | static void __init eisa_release_resources (struct eisa_device *edev) | |
290 | { | |
291 | int i; | |
292 | ||
293 | for (i = 0; i < EISA_MAX_RESOURCES; i++) | |
294 | if (edev->res[i].start || edev->res[i].end) | |
295 | release_resource (&edev->res[i]); | |
296 | } | |
297 | ||
298 | static int __init eisa_probe (struct eisa_root_device *root) | |
299 | { | |
300 | int i, c; | |
301 | struct eisa_device *edev; | |
302 | ||
303 | printk (KERN_INFO "EISA: Probing bus %d at %s\n", | |
304 | root->bus_nr, root->dev->bus_id); | |
305 | ||
306 | /* First try to get hold of slot 0. If there is no device | |
307 | * here, simply fail, unless root->force_probe is set. */ | |
308 | ||
8ac5436c | 309 | if (!(edev = kzalloc (sizeof (*edev), GFP_KERNEL))) { |
1da177e4 LT |
310 | printk (KERN_ERR "EISA: Couldn't allocate mainboard slot\n"); |
311 | return -ENOMEM; | |
312 | } | |
313 | ||
1da177e4 LT |
314 | if (eisa_request_resources (root, edev, 0)) { |
315 | printk (KERN_WARNING \ | |
316 | "EISA: Cannot allocate resource for mainboard\n"); | |
317 | kfree (edev); | |
318 | if (!root->force_probe) | |
319 | return -EBUSY; | |
320 | goto force_probe; | |
321 | } | |
322 | ||
323 | if (eisa_init_device (root, edev, 0)) { | |
324 | eisa_release_resources (edev); | |
325 | kfree (edev); | |
326 | if (!root->force_probe) | |
327 | return -ENODEV; | |
328 | goto force_probe; | |
329 | } | |
330 | ||
331 | printk (KERN_INFO "EISA: Mainboard %s detected.\n", edev->id.sig); | |
332 | ||
333 | if (eisa_register_device (edev)) { | |
334 | printk (KERN_ERR "EISA: Failed to register %s\n", | |
335 | edev->id.sig); | |
336 | eisa_release_resources (edev); | |
337 | kfree (edev); | |
338 | } | |
339 | ||
340 | force_probe: | |
341 | ||
342 | for (c = 0, i = 1; i <= root->slots; i++) { | |
8ac5436c | 343 | if (!(edev = kzalloc (sizeof (*edev), GFP_KERNEL))) { |
1da177e4 LT |
344 | printk (KERN_ERR "EISA: Out of memory for slot %d\n", |
345 | i); | |
346 | continue; | |
347 | } | |
1da177e4 LT |
348 | |
349 | if (eisa_request_resources (root, edev, i)) { | |
350 | printk (KERN_WARNING \ | |
351 | "Cannot allocate resource for EISA slot %d\n", | |
352 | i); | |
353 | kfree (edev); | |
354 | continue; | |
355 | } | |
356 | ||
357 | if (eisa_init_device (root, edev, i)) { | |
358 | eisa_release_resources (edev); | |
359 | kfree (edev); | |
360 | continue; | |
361 | } | |
362 | ||
363 | printk (KERN_INFO "EISA: slot %d : %s detected", | |
364 | i, edev->id.sig); | |
365 | ||
366 | switch (edev->state) { | |
367 | case EISA_CONFIG_ENABLED | EISA_CONFIG_FORCED: | |
368 | printk (" (forced enabled)"); | |
369 | break; | |
370 | ||
371 | case EISA_CONFIG_FORCED: | |
372 | printk (" (forced disabled)"); | |
373 | break; | |
374 | ||
375 | case 0: | |
376 | printk (" (disabled)"); | |
377 | break; | |
378 | } | |
379 | ||
380 | printk (".\n"); | |
381 | ||
382 | c++; | |
383 | ||
384 | if (eisa_register_device (edev)) { | |
385 | printk (KERN_ERR "EISA: Failed to register %s\n", | |
386 | edev->id.sig); | |
387 | eisa_release_resources (edev); | |
388 | kfree (edev); | |
389 | } | |
390 | } | |
391 | ||
392 | printk (KERN_INFO "EISA: Detected %d card%s.\n", c, c == 1 ? "" : "s"); | |
393 | ||
394 | return 0; | |
395 | } | |
396 | ||
397 | static struct resource eisa_root_res = { | |
398 | .name = "EISA root resource", | |
399 | .start = 0, | |
400 | .end = 0xffffffff, | |
401 | .flags = IORESOURCE_IO, | |
402 | }; | |
403 | ||
404 | static int eisa_bus_count; | |
405 | ||
406 | int __init eisa_root_register (struct eisa_root_device *root) | |
407 | { | |
408 | int err; | |
409 | ||
410 | /* Use our own resources to check if this bus base address has | |
411 | * been already registered. This prevents the virtual root | |
412 | * device from registering after the real one has, for | |
413 | * example... */ | |
414 | ||
415 | root->eisa_root_res.name = eisa_root_res.name; | |
416 | root->eisa_root_res.start = root->res->start; | |
417 | root->eisa_root_res.end = root->res->end; | |
418 | root->eisa_root_res.flags = IORESOURCE_BUSY; | |
419 | ||
420 | if ((err = request_resource (&eisa_root_res, &root->eisa_root_res))) | |
421 | return err; | |
422 | ||
423 | root->bus_nr = eisa_bus_count++; | |
424 | ||
425 | if ((err = eisa_probe (root))) | |
426 | release_resource (&root->eisa_root_res); | |
427 | ||
428 | return err; | |
429 | } | |
430 | ||
431 | static int __init eisa_init (void) | |
432 | { | |
433 | int r; | |
434 | ||
435 | if ((r = bus_register (&eisa_bus_type))) | |
436 | return r; | |
437 | ||
438 | printk (KERN_INFO "EISA bus registered\n"); | |
439 | return 0; | |
440 | } | |
441 | ||
442 | module_param_array(enable_dev, int, &enable_dev_count, 0444); | |
443 | module_param_array(disable_dev, int, &disable_dev_count, 0444); | |
444 | ||
445 | postcore_initcall (eisa_init); | |
446 | ||
447 | int EISA_bus; /* for legacy drivers */ | |
448 | EXPORT_SYMBOL (EISA_bus); | |
449 | EXPORT_SYMBOL (eisa_bus_type); | |
450 | EXPORT_SYMBOL (eisa_driver_register); | |
451 | EXPORT_SYMBOL (eisa_driver_unregister); |