1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * EISA bus support functions for sysfs. |
4 | * |
5 | * (C) 2002, 2003 Marc Zyngier <maz@wild-wind.fr.eu.org> |
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; |
24 | char name[50]; |
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]; |
37 | static unsigned int enable_dev_count; |
38 | static int disable_dev[EISA_MAX_FORCED_DEV]; |
39 | static unsigned int disable_dev_count; |
40 | |
41 | static int is_forced_dev(int *forced_tab, |
42 | int forced_count, |
43 | struct eisa_root_device *root, |
44 | struct eisa_device *edev) |
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 | |
57 | static void __init eisa_name_device(struct eisa_device *edev) |
58 | { |
59 | #ifdef CONFIG_EISA_NAMES |
60 | int i; |
61 | for (i = 0; i < EISA_INFOS; i++) { |
62 | if (!strcmp(edev->id.sig, eisa_table[i].id.sig)) { |
63 | strscpy(p: edev->pretty_name, |
64 | q: eisa_table[i].name, |
65 | size: sizeof(edev->pretty_name)); |
66 | return; |
67 | } |
68 | } |
69 | |
70 | /* No name was found */ |
71 | sprintf(buf: edev->pretty_name, fmt: "EISA device %.7s" , edev->id.sig); |
72 | #endif |
73 | } |
74 | |
75 | static char __init *decode_eisa_sig(unsigned long addr) |
76 | { |
77 | static char sig_str[EISA_SIG_LEN]; |
78 | u8 sig[4]; |
79 | u16 rev; |
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(value: 0x80 + i, port: addr); |
92 | #endif |
93 | sig[i] = inb(port: addr + i); |
94 | |
95 | if (!i && (sig[0] & 0x80)) |
96 | return NULL; |
97 | } |
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(buf: sig_str + 3, fmt: "%04X" , rev); |
104 | |
105 | return sig_str; |
106 | } |
107 | |
108 | static int eisa_bus_match(struct device *dev, struct device_driver *drv) |
109 | { |
110 | struct eisa_device *edev = to_eisa_device(dev); |
111 | struct eisa_driver *edrv = to_eisa_driver(drv); |
112 | const struct eisa_device_id *eids = edrv->id_table; |
113 | |
114 | if (!eids) |
115 | return 0; |
116 | |
117 | while (strlen(eids->sig)) { |
118 | if (!strcmp(eids->sig, edev->id.sig) && |
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 | |
130 | static int eisa_bus_uevent(const struct device *dev, struct kobj_uevent_env *env) |
131 | { |
132 | const struct eisa_device *edev = to_eisa_device(dev); |
133 | |
134 | add_uevent_var(env, format: "MODALIAS=" EISA_DEVICE_MODALIAS_FMT, edev->id.sig); |
135 | return 0; |
136 | } |
137 | |
138 | struct bus_type eisa_bus_type = { |
139 | .name = "eisa" , |
140 | .match = eisa_bus_match, |
141 | .uevent = eisa_bus_uevent, |
142 | }; |
143 | EXPORT_SYMBOL(eisa_bus_type); |
144 | |
145 | int eisa_driver_register(struct eisa_driver *edrv) |
146 | { |
147 | edrv->driver.bus = &eisa_bus_type; |
148 | return driver_register(drv: &edrv->driver); |
149 | } |
150 | EXPORT_SYMBOL(eisa_driver_register); |
151 | |
152 | void eisa_driver_unregister(struct eisa_driver *edrv) |
153 | { |
154 | driver_unregister(drv: &edrv->driver); |
155 | } |
156 | EXPORT_SYMBOL(eisa_driver_unregister); |
157 | |
158 | static ssize_t signature_show(struct device *dev, |
159 | struct device_attribute *attr, char *buf) |
160 | { |
161 | struct eisa_device *edev = to_eisa_device(dev); |
162 | return sprintf(buf, fmt: "%s\n" , edev->id.sig); |
163 | } |
164 | static DEVICE_ATTR_RO(signature); |
165 | |
166 | static ssize_t enabled_show(struct device *dev, |
167 | struct device_attribute *attr, char *buf) |
168 | { |
169 | struct eisa_device *edev = to_eisa_device(dev); |
170 | return sprintf(buf, fmt: "%d\n" , edev->state & EISA_CONFIG_ENABLED); |
171 | } |
172 | static DEVICE_ATTR_RO(enabled); |
173 | |
174 | static ssize_t modalias_show(struct device *dev, |
175 | struct device_attribute *attr, char *buf) |
176 | { |
177 | struct eisa_device *edev = to_eisa_device(dev); |
178 | return sprintf(buf, EISA_DEVICE_MODALIAS_FMT "\n" , edev->id.sig); |
179 | } |
180 | static DEVICE_ATTR_RO(modalias); |
181 | |
182 | static int __init eisa_init_device(struct eisa_root_device *root, |
183 | struct eisa_device *edev, |
184 | int slot) |
185 | { |
186 | char *sig; |
187 | unsigned long sig_addr; |
188 | int i; |
189 | |
190 | sig_addr = SLOT_ADDRESS(root, slot) + EISA_VENDOR_ID_OFFSET; |
191 | |
192 | sig = decode_eisa_sig(addr: sig_addr); |
193 | if (!sig) |
194 | return -1; /* No EISA device here */ |
195 | |
196 | memcpy(edev->id.sig, sig, EISA_SIG_LEN); |
197 | edev->slot = slot; |
198 | edev->state = inb(SLOT_ADDRESS(root, slot) + EISA_CONFIG_OFFSET) |
199 | & EISA_CONFIG_ENABLED; |
200 | edev->base_addr = SLOT_ADDRESS(root, slot); |
201 | edev->dma_mask = root->dma_mask; /* Default DMA mask */ |
202 | eisa_name_device(edev); |
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; |
207 | dev_set_name(dev: &edev->dev, name: "%02X:%02X" , root->bus_nr, slot); |
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 | |
217 | if (is_forced_dev(forced_tab: enable_dev, forced_count: enable_dev_count, root, edev)) |
218 | edev->state = EISA_CONFIG_ENABLED | EISA_CONFIG_FORCED; |
219 | |
220 | if (is_forced_dev(forced_tab: disable_dev, forced_count: disable_dev_count, root, edev)) |
221 | edev->state = EISA_CONFIG_FORCED; |
222 | |
223 | return 0; |
224 | } |
225 | |
226 | static int __init eisa_register_device(struct eisa_device *edev) |
227 | { |
228 | int rc = device_register(dev: &edev->dev); |
229 | if (rc) { |
230 | put_device(dev: &edev->dev); |
231 | return rc; |
232 | } |
233 | |
234 | rc = device_create_file(device: &edev->dev, entry: &dev_attr_signature); |
235 | if (rc) |
236 | goto err_devreg; |
237 | rc = device_create_file(device: &edev->dev, entry: &dev_attr_enabled); |
238 | if (rc) |
239 | goto err_sig; |
240 | rc = device_create_file(device: &edev->dev, entry: &dev_attr_modalias); |
241 | if (rc) |
242 | goto err_enab; |
243 | |
244 | return 0; |
245 | |
246 | err_enab: |
247 | device_remove_file(dev: &edev->dev, attr: &dev_attr_enabled); |
248 | err_sig: |
249 | device_remove_file(dev: &edev->dev, attr: &dev_attr_signature); |
250 | err_devreg: |
251 | device_unregister(dev: &edev->dev); |
252 | return rc; |
253 | } |
254 | |
255 | static int __init eisa_request_resources(struct eisa_root_device *root, |
256 | struct eisa_device *edev, |
257 | int slot) |
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 | } |
272 | |
273 | if (slot) { |
274 | edev->res[i].name = NULL; |
275 | edev->res[i].start = SLOT_ADDRESS(root, slot) |
276 | + (i * 0x400); |
277 | edev->res[i].end = edev->res[i].start + 0xff; |
278 | edev->res[i].flags = IORESOURCE_IO; |
279 | } else { |
280 | edev->res[i].name = NULL; |
281 | edev->res[i].start = SLOT_ADDRESS(root, slot) |
282 | + EISA_VENDOR_ID_OFFSET; |
283 | edev->res[i].end = edev->res[i].start + 3; |
284 | edev->res[i].flags = IORESOURCE_IO | IORESOURCE_BUSY; |
285 | } |
286 | |
287 | if (request_resource(root: root->res, new: &edev->res[i])) |
288 | goto failed; |
289 | } |
290 | |
291 | return 0; |
292 | |
293 | failed: |
294 | while (--i >= 0) |
295 | release_resource(new: &edev->res[i]); |
296 | |
297 | return -1; |
298 | } |
299 | |
300 | static void __init eisa_release_resources(struct eisa_device *edev) |
301 | { |
302 | int i; |
303 | |
304 | for (i = 0; i < EISA_MAX_RESOURCES; i++) |
305 | if (edev->res[i].start || edev->res[i].end) |
306 | release_resource(new: &edev->res[i]); |
307 | } |
308 | |
309 | static int __init eisa_probe(struct eisa_root_device *root) |
310 | { |
311 | int i, c; |
312 | struct eisa_device *edev; |
313 | char *enabled_str; |
314 | |
315 | dev_info(root->dev, "Probing EISA bus %d\n" , root->bus_nr); |
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. */ |
319 | |
320 | edev = kzalloc(size: sizeof(*edev), GFP_KERNEL); |
321 | if (!edev) |
322 | return -ENOMEM; |
323 | |
324 | if (eisa_request_resources(root, edev, slot: 0)) { |
325 | dev_warn(root->dev, |
326 | "EISA: Cannot allocate resource for mainboard\n" ); |
327 | kfree(objp: edev); |
328 | if (!root->force_probe) |
329 | return -EBUSY; |
330 | goto force_probe; |
331 | } |
332 | |
333 | if (eisa_init_device(root, edev, slot: 0)) { |
334 | eisa_release_resources(edev); |
335 | kfree(objp: edev); |
336 | if (!root->force_probe) |
337 | return -ENODEV; |
338 | goto force_probe; |
339 | } |
340 | |
341 | dev_info(&edev->dev, "EISA: Mainboard %s detected\n" , edev->id.sig); |
342 | |
343 | if (eisa_register_device(edev)) { |
344 | dev_err(&edev->dev, "EISA: Failed to register %s\n" , |
345 | edev->id.sig); |
346 | eisa_release_resources(edev); |
347 | kfree(objp: edev); |
348 | } |
349 | |
350 | force_probe: |
351 | |
352 | for (c = 0, i = 1; i <= root->slots; i++) { |
353 | edev = kzalloc(size: sizeof(*edev), GFP_KERNEL); |
354 | if (!edev) { |
355 | dev_err(root->dev, "EISA: Out of memory for slot %d\n" , |
356 | i); |
357 | continue; |
358 | } |
359 | |
360 | if (eisa_request_resources(root, edev, slot: i)) { |
361 | dev_warn(root->dev, |
362 | "Cannot allocate resource for EISA slot %d\n" , |
363 | i); |
364 | kfree(objp: edev); |
365 | continue; |
366 | } |
367 | |
368 | if (eisa_init_device(root, edev, slot: i)) { |
369 | eisa_release_resources(edev); |
370 | kfree(objp: edev); |
371 | continue; |
372 | } |
373 | |
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); |
385 | |
386 | c++; |
387 | |
388 | if (eisa_register_device(edev)) { |
389 | dev_err(&edev->dev, "EISA: Failed to register %s\n" , |
390 | edev->id.sig); |
391 | eisa_release_resources(edev); |
392 | kfree(objp: edev); |
393 | } |
394 | } |
395 | |
396 | dev_info(root->dev, "EISA: Detected %d card%s\n" , c, c == 1 ? "" : "s" ); |
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 | |
409 | int __init eisa_root_register(struct eisa_root_device *root) |
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... */ |
417 | |
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 | |
423 | err = request_resource(root: &eisa_root_res, new: &root->eisa_root_res); |
424 | if (err) |
425 | return err; |
426 | |
427 | root->bus_nr = eisa_bus_count++; |
428 | |
429 | err = eisa_probe(root); |
430 | if (err) |
431 | release_resource(new: &root->eisa_root_res); |
432 | |
433 | return err; |
434 | } |
435 | |
436 | static int __init eisa_init(void) |
437 | { |
438 | int r; |
439 | |
440 | r = bus_register(bus: &eisa_bus_type); |
441 | if (r) |
442 | return r; |
443 | |
444 | printk(KERN_INFO "EISA bus registered\n" ); |
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 | |
451 | postcore_initcall(eisa_init); |
452 | |
453 | int EISA_bus; /* for legacy drivers */ |
454 | EXPORT_SYMBOL(EISA_bus); |
455 | |