455 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*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 22struct eisa_device_info {23 struct eisa_device_id id;24 char name[50];25};26 27#ifdef CONFIG_EISA_NAMES28static 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#endif33 34#define EISA_MAX_FORCED_DEV 1635 36static int enable_dev[EISA_MAX_FORCED_DEV];37static unsigned int enable_dev_count;38static int disable_dev[EISA_MAX_FORCED_DEV];39static unsigned int disable_dev_count;40 41static 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 57static void __init eisa_name_device(struct eisa_device *edev)58{59#ifdef CONFIG_EISA_NAMES60 int i;61 for (i = 0; i < EISA_INFOS; i++) {62 if (!strcmp(edev->id.sig, eisa_table[i].id.sig)) {63 strscpy(edev->pretty_name,64 eisa_table[i].name,65 sizeof(edev->pretty_name));66 return;67 }68 }69 70 /* No name was found */71 sprintf(edev->pretty_name, "EISA device %.7s", edev->id.sig);72#endif73}74 75static 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_PRIMING84 /*85 * This ugly stuff is used to wake up VL-bus cards86 * (AHA-284x is the only known example), so we can87 * read the EISA id.88 *89 * Thankfully, this only exists on x86...90 */91 outb(0x80 + i, addr);92#endif93 sig[i] = inb(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(sig_str + 3, "%04X", rev);104 105 return sig_str;106}107 108static int eisa_bus_match(struct device *dev, const struct device_driver *drv)109{110 struct eisa_device *edev = to_eisa_device(dev);111 const 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 130static 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, "MODALIAS=" EISA_DEVICE_MODALIAS_FMT, edev->id.sig);135 return 0;136}137 138struct bus_type eisa_bus_type = {139 .name = "eisa",140 .match = eisa_bus_match,141 .uevent = eisa_bus_uevent,142};143EXPORT_SYMBOL(eisa_bus_type);144 145int eisa_driver_register(struct eisa_driver *edrv)146{147 edrv->driver.bus = &eisa_bus_type;148 return driver_register(&edrv->driver);149}150EXPORT_SYMBOL(eisa_driver_register);151 152void eisa_driver_unregister(struct eisa_driver *edrv)153{154 driver_unregister(&edrv->driver);155}156EXPORT_SYMBOL(eisa_driver_unregister);157 158static 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, "%s\n", edev->id.sig);163}164static DEVICE_ATTR_RO(signature);165 166static 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, "%d\n", edev->state & EISA_CONFIG_ENABLED);171}172static DEVICE_ATTR_RO(enabled);173 174static 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}180static DEVICE_ATTR_RO(modalias);181 182static 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(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(&edev->dev, "%02X:%02X", root->bus_nr, slot);208 209 for (i = 0; i < EISA_MAX_RESOURCES; i++) {210#ifdef CONFIG_EISA_NAMES211 edev->res[i].name = edev->pretty_name;212#else213 edev->res[i].name = edev->id.sig;214#endif215 }216 217 if (is_forced_dev(enable_dev, enable_dev_count, root, edev))218 edev->state = EISA_CONFIG_ENABLED | EISA_CONFIG_FORCED;219 220 if (is_forced_dev(disable_dev, disable_dev_count, root, edev))221 edev->state = EISA_CONFIG_FORCED;222 223 return 0;224}225 226static int __init eisa_register_device(struct eisa_device *edev)227{228 int rc = device_register(&edev->dev);229 if (rc) {230 put_device(&edev->dev);231 return rc;232 }233 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;243 244 return 0;245 246err_enab:247 device_remove_file(&edev->dev, &dev_attr_enabled);248err_sig:249 device_remove_file(&edev->dev, &dev_attr_signature);250err_devreg:251 device_unregister(&edev->dev);252 return rc;253}254 255static 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 is263 * very likely to fail... :-( Instead, grab the EISA264 * 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->res, &edev->res[i]))288 goto failed;289 }290 291 return 0;292 293 failed:294 while (--i >= 0)295 release_resource(&edev->res[i]);296 297 return -1;298}299 300static 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(&edev->res[i]);307}308 309static 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 device318 * here, simply fail, unless root->force_probe is set. */319 320 edev = kzalloc(sizeof(*edev), GFP_KERNEL);321 if (!edev)322 return -ENOMEM;323 324 if (eisa_request_resources(root, edev, 0)) {325 dev_warn(root->dev,326 "EISA: Cannot allocate resource for mainboard\n");327 kfree(edev);328 if (!root->force_probe)329 return -EBUSY;330 goto force_probe;331 }332 333 if (eisa_init_device(root, edev, 0)) {334 eisa_release_resources(edev);335 kfree(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(edev);348 }349 350 force_probe:351 352 for (c = 0, i = 1; i <= root->slots; i++) {353 edev = kzalloc(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, i)) {361 dev_warn(root->dev,362 "Cannot allocate resource for EISA slot %d\n",363 i);364 kfree(edev);365 continue;366 }367 368 if (eisa_init_device(root, edev, i)) {369 eisa_release_resources(edev);370 kfree(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 else381 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(edev);393 }394 }395 396 dev_info(root->dev, "EISA: Detected %d card%s\n", c, c == 1 ? "" : "s");397 return 0;398}399 400static struct resource eisa_root_res = {401 .name = "EISA root resource",402 .start = 0,403 .end = 0xffffffff,404 .flags = IORESOURCE_IO,405};406 407static int eisa_bus_count;408 409int __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 has414 * been already registered. This prevents the virtual root415 * device from registering after the real one has, for416 * 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(&eisa_root_res, &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(&root->eisa_root_res);432 433 return err;434}435 436static int __init eisa_init(void)437{438 int r;439 440 r = bus_register(&eisa_bus_type);441 if (r)442 return r;443 444 printk(KERN_INFO "EISA bus registered\n");445 return 0;446}447 448module_param_array(enable_dev, int, &enable_dev_count, 0444);449module_param_array(disable_dev, int, &disable_dev_count, 0444);450 451postcore_initcall(eisa_init);452 453int EISA_bus; /* for legacy drivers */454EXPORT_SYMBOL(EISA_bus);455