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