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