eisa-bus.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456
  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. #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. #define SLOT_ADDRESS(r,n) (r->bus_base_addr + (0x1000 * n))
  18. #define EISA_DEVINFO(i,s) { .id = { .sig = i }, .name = s }
  19. struct eisa_device_info {
  20. struct eisa_device_id id;
  21. char name[DEVICE_NAME_SIZE];
  22. };
  23. #ifdef CONFIG_EISA_NAMES
  24. static struct eisa_device_info __initdata eisa_table[] = {
  25. #include "devlist.h"
  26. };
  27. #define EISA_INFOS (sizeof (eisa_table) / (sizeof (struct eisa_device_info)))
  28. #endif
  29. #define EISA_MAX_FORCED_DEV 16
  30. static int enable_dev[EISA_MAX_FORCED_DEV];
  31. static int enable_dev_count;
  32. static int disable_dev[EISA_MAX_FORCED_DEV];
  33. static int disable_dev_count;
  34. static int is_forced_dev (int *forced_tab,
  35. int forced_count,
  36. struct eisa_root_device *root,
  37. struct eisa_device *edev)
  38. {
  39. int i, x;
  40. for (i = 0; i < forced_count; i++) {
  41. x = (root->bus_nr << 8) | edev->slot;
  42. if (forced_tab[i] == x)
  43. return 1;
  44. }
  45. return 0;
  46. }
  47. static void __init eisa_name_device (struct eisa_device *edev)
  48. {
  49. #ifdef CONFIG_EISA_NAMES
  50. int i;
  51. for (i = 0; i < EISA_INFOS; i++) {
  52. if (!strcmp (edev->id.sig, eisa_table[i].id.sig)) {
  53. strlcpy (edev->pretty_name,
  54. eisa_table[i].name,
  55. DEVICE_NAME_SIZE);
  56. return;
  57. }
  58. }
  59. /* No name was found */
  60. sprintf (edev->pretty_name, "EISA device %.7s", edev->id.sig);
  61. #endif
  62. }
  63. static char __init *decode_eisa_sig(unsigned long addr)
  64. {
  65. static char sig_str[EISA_SIG_LEN];
  66. u8 sig[4];
  67. u16 rev;
  68. int i;
  69. for (i = 0; i < 4; i++) {
  70. #ifdef CONFIG_EISA_VLB_PRIMING
  71. /*
  72. * This ugly stuff is used to wake up VL-bus cards
  73. * (AHA-284x is the only known example), so we can
  74. * read the EISA id.
  75. *
  76. * Thankfully, this only exists on x86...
  77. */
  78. outb(0x80 + i, addr);
  79. #endif
  80. sig[i] = inb (addr + i);
  81. if (!i && (sig[0] & 0x80))
  82. return NULL;
  83. }
  84. sig_str[0] = ((sig[0] >> 2) & 0x1f) + ('A' - 1);
  85. sig_str[1] = (((sig[0] & 3) << 3) | (sig[1] >> 5)) + ('A' - 1);
  86. sig_str[2] = (sig[1] & 0x1f) + ('A' - 1);
  87. rev = (sig[2] << 8) | sig[3];
  88. sprintf(sig_str + 3, "%04X", rev);
  89. return sig_str;
  90. }
  91. static int eisa_bus_match (struct device *dev, struct device_driver *drv)
  92. {
  93. struct eisa_device *edev = to_eisa_device (dev);
  94. struct eisa_driver *edrv = to_eisa_driver (drv);
  95. const struct eisa_device_id *eids = edrv->id_table;
  96. if (!eids)
  97. return 0;
  98. while (strlen (eids->sig)) {
  99. if (!strcmp (eids->sig, edev->id.sig) &&
  100. edev->state & EISA_CONFIG_ENABLED) {
  101. edev->id.driver_data = eids->driver_data;
  102. return 1;
  103. }
  104. eids++;
  105. }
  106. return 0;
  107. }
  108. static int eisa_bus_uevent(struct device *dev, char **envp, int num_envp,
  109. char *buffer, int buffer_size)
  110. {
  111. struct eisa_device *edev = to_eisa_device(dev);
  112. int i = 0;
  113. int length = 0;
  114. add_uevent_var(envp, num_envp, &i, buffer, buffer_size, &length,
  115. "MODALIAS=" EISA_DEVICE_MODALIAS_FMT, edev->id.sig);
  116. envp[i] = NULL;
  117. return 0;
  118. }
  119. struct bus_type eisa_bus_type = {
  120. .name = "eisa",
  121. .match = eisa_bus_match,
  122. .uevent = eisa_bus_uevent,
  123. };
  124. int eisa_driver_register (struct eisa_driver *edrv)
  125. {
  126. edrv->driver.bus = &eisa_bus_type;
  127. return driver_register (&edrv->driver);
  128. }
  129. void eisa_driver_unregister (struct eisa_driver *edrv)
  130. {
  131. driver_unregister (&edrv->driver);
  132. }
  133. static ssize_t eisa_show_sig (struct device *dev, struct device_attribute *attr, char *buf)
  134. {
  135. struct eisa_device *edev = to_eisa_device (dev);
  136. return sprintf (buf,"%s\n", edev->id.sig);
  137. }
  138. static DEVICE_ATTR(signature, S_IRUGO, eisa_show_sig, NULL);
  139. static ssize_t eisa_show_state (struct device *dev, struct device_attribute *attr, char *buf)
  140. {
  141. struct eisa_device *edev = to_eisa_device (dev);
  142. return sprintf (buf,"%d\n", edev->state & EISA_CONFIG_ENABLED);
  143. }
  144. static DEVICE_ATTR(enabled, S_IRUGO, eisa_show_state, NULL);
  145. static ssize_t eisa_show_modalias (struct device *dev, struct device_attribute *attr, char *buf)
  146. {
  147. struct eisa_device *edev = to_eisa_device (dev);
  148. return sprintf (buf, EISA_DEVICE_MODALIAS_FMT "\n", edev->id.sig);
  149. }
  150. static DEVICE_ATTR(modalias, S_IRUGO, eisa_show_modalias, NULL);
  151. static int __init eisa_init_device (struct eisa_root_device *root,
  152. struct eisa_device *edev,
  153. int slot)
  154. {
  155. char *sig;
  156. unsigned long sig_addr;
  157. int i;
  158. sig_addr = SLOT_ADDRESS (root, slot) + EISA_VENDOR_ID_OFFSET;
  159. if (!(sig = decode_eisa_sig (sig_addr)))
  160. return -1; /* No EISA device here */
  161. memcpy (edev->id.sig, sig, EISA_SIG_LEN);
  162. edev->slot = slot;
  163. edev->state = inb (SLOT_ADDRESS (root, slot) + EISA_CONFIG_OFFSET) & EISA_CONFIG_ENABLED;
  164. edev->base_addr = SLOT_ADDRESS (root, slot);
  165. edev->dma_mask = root->dma_mask; /* Default DMA mask */
  166. eisa_name_device (edev);
  167. edev->dev.parent = root->dev;
  168. edev->dev.bus = &eisa_bus_type;
  169. edev->dev.dma_mask = &edev->dma_mask;
  170. edev->dev.coherent_dma_mask = edev->dma_mask;
  171. sprintf (edev->dev.bus_id, "%02X:%02X", root->bus_nr, slot);
  172. for (i = 0; i < EISA_MAX_RESOURCES; i++) {
  173. #ifdef CONFIG_EISA_NAMES
  174. edev->res[i].name = edev->pretty_name;
  175. #else
  176. edev->res[i].name = edev->id.sig;
  177. #endif
  178. }
  179. if (is_forced_dev (enable_dev, enable_dev_count, root, edev))
  180. edev->state = EISA_CONFIG_ENABLED | EISA_CONFIG_FORCED;
  181. if (is_forced_dev (disable_dev, disable_dev_count, root, edev))
  182. edev->state = EISA_CONFIG_FORCED;
  183. return 0;
  184. }
  185. static int __init eisa_register_device (struct eisa_device *edev)
  186. {
  187. int rc = device_register (&edev->dev);
  188. if (rc)
  189. return rc;
  190. rc = device_create_file (&edev->dev, &dev_attr_signature);
  191. if (rc) goto err_devreg;
  192. rc = device_create_file (&edev->dev, &dev_attr_enabled);
  193. if (rc) goto err_sig;
  194. rc = device_create_file (&edev->dev, &dev_attr_modalias);
  195. if (rc) goto err_enab;
  196. return 0;
  197. err_enab:
  198. device_remove_file (&edev->dev, &dev_attr_enabled);
  199. err_sig:
  200. device_remove_file (&edev->dev, &dev_attr_signature);
  201. err_devreg:
  202. device_unregister(&edev->dev);
  203. return rc;
  204. }
  205. static int __init eisa_request_resources (struct eisa_root_device *root,
  206. struct eisa_device *edev,
  207. int slot)
  208. {
  209. int i;
  210. for (i = 0; i < EISA_MAX_RESOURCES; i++) {
  211. /* Don't register resource for slot 0, since this is
  212. * very likely to fail... :-( Instead, grab the EISA
  213. * id, now we can display something in /proc/ioports.
  214. */
  215. /* Only one region for mainboard */
  216. if (!slot && i > 0) {
  217. edev->res[i].start = edev->res[i].end = 0;
  218. continue;
  219. }
  220. if (slot) {
  221. edev->res[i].name = NULL;
  222. edev->res[i].start = SLOT_ADDRESS (root, slot) + (i * 0x400);
  223. edev->res[i].end = edev->res[i].start + 0xff;
  224. edev->res[i].flags = IORESOURCE_IO;
  225. } else {
  226. edev->res[i].name = NULL;
  227. edev->res[i].start = SLOT_ADDRESS (root, slot) + EISA_VENDOR_ID_OFFSET;
  228. edev->res[i].end = edev->res[i].start + 3;
  229. edev->res[i].flags = IORESOURCE_BUSY;
  230. }
  231. if (request_resource (root->res, &edev->res[i]))
  232. goto failed;
  233. }
  234. return 0;
  235. failed:
  236. while (--i >= 0)
  237. release_resource (&edev->res[i]);
  238. return -1;
  239. }
  240. static void __init eisa_release_resources (struct eisa_device *edev)
  241. {
  242. int i;
  243. for (i = 0; i < EISA_MAX_RESOURCES; i++)
  244. if (edev->res[i].start || edev->res[i].end)
  245. release_resource (&edev->res[i]);
  246. }
  247. static int __init eisa_probe (struct eisa_root_device *root)
  248. {
  249. int i, c;
  250. struct eisa_device *edev;
  251. printk (KERN_INFO "EISA: Probing bus %d at %s\n",
  252. root->bus_nr, root->dev->bus_id);
  253. /* First try to get hold of slot 0. If there is no device
  254. * here, simply fail, unless root->force_probe is set. */
  255. if (!(edev = kzalloc (sizeof (*edev), GFP_KERNEL))) {
  256. printk (KERN_ERR "EISA: Couldn't allocate mainboard slot\n");
  257. return -ENOMEM;
  258. }
  259. if (eisa_request_resources (root, edev, 0)) {
  260. printk (KERN_WARNING \
  261. "EISA: Cannot allocate resource for mainboard\n");
  262. kfree (edev);
  263. if (!root->force_probe)
  264. return -EBUSY;
  265. goto force_probe;
  266. }
  267. if (eisa_init_device (root, edev, 0)) {
  268. eisa_release_resources (edev);
  269. kfree (edev);
  270. if (!root->force_probe)
  271. return -ENODEV;
  272. goto force_probe;
  273. }
  274. printk (KERN_INFO "EISA: Mainboard %s detected.\n", edev->id.sig);
  275. if (eisa_register_device (edev)) {
  276. printk (KERN_ERR "EISA: Failed to register %s\n",
  277. edev->id.sig);
  278. eisa_release_resources (edev);
  279. kfree (edev);
  280. }
  281. force_probe:
  282. for (c = 0, i = 1; i <= root->slots; i++) {
  283. if (!(edev = kzalloc (sizeof (*edev), GFP_KERNEL))) {
  284. printk (KERN_ERR "EISA: Out of memory for slot %d\n",
  285. i);
  286. continue;
  287. }
  288. if (eisa_request_resources (root, edev, i)) {
  289. printk (KERN_WARNING \
  290. "Cannot allocate resource for EISA slot %d\n",
  291. i);
  292. kfree (edev);
  293. continue;
  294. }
  295. if (eisa_init_device (root, edev, i)) {
  296. eisa_release_resources (edev);
  297. kfree (edev);
  298. continue;
  299. }
  300. printk (KERN_INFO "EISA: slot %d : %s detected",
  301. i, edev->id.sig);
  302. switch (edev->state) {
  303. case EISA_CONFIG_ENABLED | EISA_CONFIG_FORCED:
  304. printk (" (forced enabled)");
  305. break;
  306. case EISA_CONFIG_FORCED:
  307. printk (" (forced disabled)");
  308. break;
  309. case 0:
  310. printk (" (disabled)");
  311. break;
  312. }
  313. printk (".\n");
  314. c++;
  315. if (eisa_register_device (edev)) {
  316. printk (KERN_ERR "EISA: Failed to register %s\n",
  317. edev->id.sig);
  318. eisa_release_resources (edev);
  319. kfree (edev);
  320. }
  321. }
  322. printk (KERN_INFO "EISA: Detected %d card%s.\n", c, c == 1 ? "" : "s");
  323. return 0;
  324. }
  325. static struct resource eisa_root_res = {
  326. .name = "EISA root resource",
  327. .start = 0,
  328. .end = 0xffffffff,
  329. .flags = IORESOURCE_IO,
  330. };
  331. static int eisa_bus_count;
  332. int __init eisa_root_register (struct eisa_root_device *root)
  333. {
  334. int err;
  335. /* Use our own resources to check if this bus base address has
  336. * been already registered. This prevents the virtual root
  337. * device from registering after the real one has, for
  338. * example... */
  339. root->eisa_root_res.name = eisa_root_res.name;
  340. root->eisa_root_res.start = root->res->start;
  341. root->eisa_root_res.end = root->res->end;
  342. root->eisa_root_res.flags = IORESOURCE_BUSY;
  343. if ((err = request_resource (&eisa_root_res, &root->eisa_root_res)))
  344. return err;
  345. root->bus_nr = eisa_bus_count++;
  346. if ((err = eisa_probe (root)))
  347. release_resource (&root->eisa_root_res);
  348. return err;
  349. }
  350. static int __init eisa_init (void)
  351. {
  352. int r;
  353. if ((r = bus_register (&eisa_bus_type)))
  354. return r;
  355. printk (KERN_INFO "EISA bus registered\n");
  356. return 0;
  357. }
  358. module_param_array(enable_dev, int, &enable_dev_count, 0444);
  359. module_param_array(disable_dev, int, &disable_dev_count, 0444);
  360. postcore_initcall (eisa_init);
  361. int EISA_bus; /* for legacy drivers */
  362. EXPORT_SYMBOL (EISA_bus);
  363. EXPORT_SYMBOL (eisa_bus_type);
  364. EXPORT_SYMBOL (eisa_driver_register);
  365. EXPORT_SYMBOL (eisa_driver_unregister);