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