开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
isapnp.c
资源名称：rtsp-1.0.1.tar.gz　[点击查看]
上传用户：sy_wanhua
上传日期：2013-07-25
资源大小：3048k
文件大小：52k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

C/C++

isapnp.c：源码内容
  1. /*
  2.  *  ISA Plug & Play support
  3.  *  Copyright (c) by Jaroslav Kysela <perex@suse.cz>
  4.  *
  5.  *  Modified by Ed Okerson <eokerson@quicknet.net> to work with the 2.2.x
  6.  *  series of Linux kernels. 11/17/99
  7.  *
  8.  *   This program is free software; you can redistribute it and/or modify
  9.  *   it under the terms of the GNU General Public License as published by
  10.  *   the Free Software Foundation; either version 2 of the License, or
  11.  *   (at your option) any later version.
  12.  *
  13.  *   This program is distributed in the hope that it will be useful,
  14.  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  *   GNU General Public License for more details.
  17.  *
  18.  *   You should have received a copy of the GNU General Public License
  19.  *   along with this program; if not, write to the Free Software
  20.  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  *
  22.  */
  24. #include <linux/config.h>
  25. #include <linux/version.h>
  26. #define EXPORT_SYMTAB
  27. #include <linux/module.h>
  28. #include <linux/kernel.h>
  29. #include <linux/errno.h>
  30. #include <linux/ioport.h>
  31. #include <linux/string.h>
  32. #include <linux/malloc.h>
  33. #include <linux/proc_fs.h>
  34. #include <linux/delay.h>
  35. #include <asm/io.h>
  36. #include <asm/dma.h>
  37. #include <asm/irq.h>
  38. #include <linux/pci.h>
  39. #include <linux/vmalloc.h>
  40. #include <linux/poll.h>
  41. #include <linux/init.h>
  42. #include <asm/uaccess.h>
  43. #include "pnpio.h"
  44. #include "isapnp.h"
  46. #ifdef CONFIG_PROC_FS
  47. #include "isapnp_proc.c"
  48. #endif
  50. #if 0
  51. #define ISAPNP_REGION_OK
  52. #endif
  53. #if 0
  54. #define ISAPNP_DEBUG
  55. #endif
  57. //struct resource *pidxr_res = NULL;
  58. //struct resource *pnpwrp_res = NULL;
  59. //struct resource *isapnp_rdp_res = NULL;
  61. int isapnp_disable = 0; /* Disable ISA PnP */
  62. int isapnp_rdp = 0; /* Read Data Port */
  63. int isapnp_reset = 0; /* reset all PnP cards (deactivate) */
  64. int isapnp_skip_pci_scan = 0; /* skip PCI resource scanning */
  65. int isapnp_verbose = 1; /* verbose mode */
  66. int isapnp_reserve_irq[16] = { [0 ... 15] = -1 }; /* reserve (don't use) some IRQ */
  67. int isapnp_reserve_dma[8] = { [0 ... 7] = -1 }; /* reserve (don't use) some DMA */
  68. int isapnp_reserve_io[16] = { [0 ... 15] = -1 }; /* reserve (don't use) some I/O region */
  69. int isapnp_reserve_mem[16] = { [0 ... 15] = -1 }; /* reserve (don't use) some memory region */
  70. int isapnp_debug = 0;
  72. MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
  73. MODULE_DESCRIPTION("Generic ISA Plug & Play support");
  74. MODULE_PARM(isapnp_disable, "i");
  75. MODULE_PARM_DESC(isapnp_disable, "ISA Plug & Play disable");
  76. MODULE_PARM(isapnp_rdp, "i");
  77. MODULE_PARM_DESC(isapnp_rdp, "ISA Plug & Play read data port");
  78. MODULE_PARM(isapnp_reset, "i");
  79. MODULE_PARM_DESC(isapnp_reset, "ISA Plug & Play reset all cards");
  80. MODULE_PARM(isapnp_skip_pci_scan, "i");
  81. MODULE_PARM_DESC(isapnp_skip_pci_scan, "ISA Plug & Play skip PCI resource scanning");
  82. MODULE_PARM(isapnp_verbose, "i");
  83. MODULE_PARM_DESC(isapnp_verbose, "ISA Plug & Play verbose mode");
  84. MODULE_PARM(isapnp_reserve_irq, "1-16i");
  85. MODULE_PARM_DESC(isapnp_reserve_irq, "ISA Plug & Play - reserve IRQ line(s)");
  86. MODULE_PARM(isapnp_reserve_dma, "1-8i");
  87. MODULE_PARM_DESC(isapnp_reserve_dma, "ISA Plug & Play - reserve DMA channel(s)");
  88. MODULE_PARM(isapnp_reserve_io, "1-16i");
  89. MODULE_PARM_DESC(isapnp_reserve_io, "ISA Plug & Play - reserve I/O region(s) - port,size");
  90. MODULE_PARM(isapnp_reserve_mem, "1-16i");
  91. MODULE_PARM_DESC(isapnp_reserve_mem, "ISA Plug & Play - reserve memory region(s) - address,size");
  92. MODULE_PARM(isapnp_debug, "i");
  93. MODULE_PARM_DESC(isapnp_debug, "ISA Plug & Play - Turn on some debugging messages");
  95. #define _PIDXR 0x279
  96. #define _PNPWRP 0xa79
  98. /* short tags */
  99. #define _STAG_PNPVERNO 0x01
  100. #define _STAG_LOGDEVID 0x02
  101. #define _STAG_COMPATDEVID 0x03
  102. #define _STAG_IRQ 0x04
  103. #define _STAG_DMA 0x05
  104. #define _STAG_STARTDEP 0x06
  105. #define _STAG_ENDDEP 0x07
  106. #define _STAG_IOPORT 0x08
  107. #define _STAG_FIXEDIO 0x09
  108. #define _STAG_VENDOR 0x0e
  109. #define _STAG_END 0x0f
  110. /* long tags */
  111. #define _LTAG_MEMRANGE 0x81
  112. #define _LTAG_ANSISTR 0x82
  113. #define _LTAG_UNICODESTR 0x83
  114. #define _LTAG_VENDOR 0x84
  115. #define _LTAG_MEM32RANGE 0x85
  116. #define _LTAG_FIXEDMEM32RANGE 0x86
  118. struct pnp_bus *isapnp_cards = NULL; /* ISA PnP cards */
  119. struct pnp_dev *isapnp_devices = NULL; /* ISA PnP devices */
  120. static struct pnp_dev *isapnp_last_device = NULL;
  121. static unsigned char isapnp_checksum_value;
  122. static struct semaphore isapnp_cfg_mutex = MUTEX;
  123. static int isapnp_detected = 0;
  125. /* some prototypes */
  127. static int isapnp_config_prepare(struct pnp_dev *dev);
  128. static int isapnp_config_activate(struct pnp_dev *dev);
  129. static int isapnp_config_deactivate(struct pnp_dev *dev);
  131. static inline void write_data(unsigned char x)
  132. {
  133. outb(x, _PNPWRP);
  134. }
  136. static inline void write_address(unsigned char x)
  137. {
  138. outb(x, _PIDXR);
  139. udelay(10);
  140. }
  142. static inline unsigned char read_data(void)
  143. {
  144. unsigned char val = inb(isapnp_rdp);
  145. return val;
  146. }
  148. unsigned char isapnp_read_byte(unsigned char idx)
  149. {
  150. write_address(idx);
  151. return read_data();
  152. }
  154. unsigned short isapnp_read_word(unsigned char idx)
  155. {
  156. unsigned short val;
  158. val = isapnp_read_byte(idx);
  159. val = (val << 8) + isapnp_read_byte(idx+1);
  160. return val;
  161. }
  163. unsigned int isapnp_read_dword(unsigned char idx)
  164. {
  165. unsigned int val;
  167. val = isapnp_read_byte(idx);
  168. val = (val << 8) + isapnp_read_byte(idx+1);
  169. val = (val << 8) + isapnp_read_byte(idx+2);
  170. val = (val << 8) + isapnp_read_byte(idx+3);
  171. return val;
  172. }
  174. void isapnp_write_byte(unsigned char idx, unsigned char val)
  175. {
  176. write_address(idx);
  177. write_data(val);
  178. }
  180. void isapnp_write_word(unsigned char idx, unsigned short val)
  181. {
  182. isapnp_write_byte(idx, val >> 8);
  183. isapnp_write_byte(idx+1, val);
  184. }
  186. void isapnp_write_dword(unsigned char idx, unsigned int val)
  187. {
  188. isapnp_write_byte(idx, val >> 24);
  189. isapnp_write_byte(idx+1, val >> 16);
  190. isapnp_write_byte(idx+2, val >> 8);
  191. isapnp_write_byte(idx+3, val);
  192. }
  194. static void *isapnp_alloc(long size)
  195. {
  196. void *result;
  198. result = kmalloc(size, GFP_KERNEL);
  199. if (!result)
  200. return NULL;
  201. memset(result, 0, size);
  202. return result;
  203. }
  205. static void isapnp_key(void)
  206. {
  207. unsigned char code = 0x6a, msb;
  208. int i;
  210. mdelay(1);
  211. write_address(0x00);
  212. write_address(0x00);
  214. write_address(code);
  216. for (i = 1; i < 32; i++) {
  217. msb = ((code & 0x01) ^ ((code & 0x02) >> 1)) << 7;
  218. code = (code >> 1) | msb;
  219. write_address(code);
  220. }
  221. }
  223. /* place all pnp cards in wait-for-key state */
  224. static void isapnp_wait(void)
  225. {
  226. isapnp_write_byte(0x02, 0x02);
  227. }
  229. void isapnp_wake(unsigned char csn)
  230. {
  231. isapnp_write_byte(0x03, csn);
  232. }
  234. void isapnp_device(unsigned char logdev)
  235. {
  236. isapnp_write_byte(0x07, logdev);
  237. }
  239. void isapnp_activate(unsigned char logdev)
  240. {
  241. isapnp_device(logdev);
  242. isapnp_write_byte(ISAPNP_CFG_ACTIVATE, 1);
  243. udelay(250);
  244. }
  246. void isapnp_deactivate(unsigned char logdev)
  247. {
  248. isapnp_device(logdev);
  249. isapnp_write_byte(ISAPNP_CFG_ACTIVATE, 0);
  250. }
  252. static void __init isapnp_peek(unsigned char *data, int bytes)
  253. {
  254. int i, j;
  255. unsigned char d;
  257. for (i = 1; i <= bytes; i++) {
  258. for (j = 0; j < 10; j++) {
  259. d = isapnp_read_byte(0x05);
  260. if (d & 1)
  261. break;
  262. udelay(10);
  263. }
  264. if (!(d & 1)) {
  265. *data++ = 0xff;
  266. continue;
  267. }
  268. d = isapnp_read_byte(0x04); /* PRESDI */
  269. isapnp_checksum_value += d;
  270. if (data != NULL)
  271. *data++ = d;
  272. }
  273. }
  275. #define RDP_STEP 32 /* minimum is 4 */
  277. static int isapnp_next_rdp(void)
  278. {
  279. int rdp = isapnp_rdp;
  280. while (rdp <= 0x3ff) {
  281. if (!check_region(rdp, 1)) {
  282. isapnp_rdp = rdp;
  283. return 0;
  284. }
  285. rdp += RDP_STEP;
  286. }
  287. return -1;
  288. }
  290. /* Set read port address */
  291. static inline void isapnp_set_rdp(void)
  292. {
  293. isapnp_write_byte(0x00, isapnp_rdp >> 2);
  294. udelay(100);
  295. }
  297. /*
  298.  * This code is badly broken. We cannot simply pick ports as the 
  299.  * ISAPnP specification implies. We should try 4 or 5 safe ports
  300.  * then bale by default.
  301.  *
  302.  * This code touches NE2K cards or other devices and your box is
  303.  * history.
  304.  */
  306. static int __init isapnp_isolate_rdp_select(void)
  307. {
  308. isapnp_wait();
  309. isapnp_key();
  311. /* Control: reset CSN and conditionally everything else too */
  312. isapnp_write_byte(0x02, isapnp_reset ? 0x05 : 0x04);
  313. mdelay(2);
  315. isapnp_wait();
  316. isapnp_key();
  317. isapnp_wake(0x00);
  319. if (isapnp_next_rdp() < 0) {
  320. isapnp_wait();
  321. return -1;
  322. }
  324. isapnp_set_rdp();
  325. udelay(1000);
  326. write_address(0x01);
  327. udelay(1000);
  328. return 0;
  329. }
  331. /*
  332.  *  Isolate (assign uniqued CSN) to all ISA PnP devices.
  333.  */
  335. static int __init isapnp_isolate(void)
  336. {
  337. unsigned char checksum = 0x6a;
  338. unsigned char chksum = 0x00;
  339. unsigned char bit = 0x00;
  340. int data;
  341. int csn = 0;
  342. int i;
  343. int iteration = 1;
  345. isapnp_rdp = 0x213;
  346. if (isapnp_isolate_rdp_select() < 0)
  347. return -1;
  349. while (1) {
  350. for (i = 1; i <= 64; i++) {
  351. data = read_data() << 8;
  352. udelay(250);
  353. data = data | read_data();
  354. udelay(250);
  355. if (data == 0x55aa)
  356. bit = 0x01;
  357. checksum = ((((checksum ^ (checksum >> 1)) & 0x01) ^ bit) << 7) | (checksum >> 1);
  358. bit = 0x00;
  359. }
  360. for (i = 65; i <= 72; i++) {
  361. data = read_data() << 8;
  362. udelay(250);
  363. data = data | read_data();
  364. udelay(250);
  365. if (data == 0x55aa)
  366. chksum |= (1 << (i - 65));
  367. }
  368. if (checksum != 0x00 && checksum == chksum) {
  369. csn++;
  371. isapnp_write_byte(0x06, csn);
  372. udelay(250);
  373. iteration++;
  374. isapnp_wake(0x00);
  375. write_address(0x01);
  376. goto __next;
  377. }
  378. if (iteration == 1) {
  379. isapnp_rdp += RDP_STEP;
  380. if (isapnp_isolate_rdp_select() < 0)
  381. return -1;
  382. } else if (iteration > 1) {
  383. break;
  384. }
  385.       __next:
  386. checksum = 0x6a;
  387. chksum = 0x00;
  388. bit = 0x00;
  389. }
  390. isapnp_wait();
  391. return csn;
  392. }
  394. /*
  395.  *  Read one tag from stream.
  396.  */
  398. static int __init isapnp_read_tag(unsigned char *type, unsigned short *size)
  399. {
  400. unsigned char tag, tmp[2];
  402. isapnp_peek(&tag, 1);
  403. if (tag == 0) /* invalid tag */
  404. return -1;
  405. if (tag & 0x80) { /* large item */
  406. *type = tag;
  407. isapnp_peek(tmp, 2);
  408. *size = (tmp[1] << 8) | tmp[0];
  409. } else {
  410. *type = (tag >> 3) & 0x0f;
  411. *size = tag & 0x07;
  412. }
  413.         if(isapnp_debug > 0)
  414.         {
  415.   printk("tag = 0x%x, type = 0x%x, size = %in", tag, *type, *size);
  416.         }
  417. if (type == 0) /* wrong type */
  418. return -1;
  419. if (*type == 0xff && *size == 0xffff) /* probably invalid data */
  420. return -1;
  421. return 0;
  422. }
  424. /*
  425.  *  Skip specified number of bytes from stream.
  426.  */
  427.  
  428. static void __init isapnp_skip_bytes(int count)
  429. {
  430. isapnp_peek(NULL, count);
  431. }
  433. /*
  434.  *  Parse logical device tag.
  435.  */
  437. static struct pnp_dev * __init isapnp_parse_device(struct pnp_bus *card,
  438. int size, int number)
  439. {
  440. unsigned char tmp[6];
  441. struct pnp_dev *dev;
  443. isapnp_peek(tmp, size);
  444. dev = isapnp_alloc(sizeof(struct pnp_dev));
  445. if (!dev)
  446. return NULL;
  447. dev->devfn = number;
  448. dev->vendor = (tmp[1] << 8) | tmp[0];
  449. dev->device = (tmp[3] << 8) | tmp[2];
  450. dev->regs = tmp[4];
  451. dev->bus = card;
  452. if (size > 5)
  453. dev->regs |= tmp[5] << 8;
  454. dev->prepare = isapnp_config_prepare;
  455. dev->activate = isapnp_config_activate;
  456. dev->deactivate = isapnp_config_deactivate;
  457. return dev;
  458. }
  460. /*
  461.  *  Build new resources structure
  462.  */
  464. static struct isapnp_resources * __init isapnp_build_resources(struct pnp_dev *dev, int dependent)
  465. {
  466. struct isapnp_resources *res, *ptr, *ptra;
  468. res = isapnp_alloc(sizeof(struct isapnp_resources));
  469. if (!res)
  470. return NULL;
  471. res->dev = dev;
  472. ptr = (struct isapnp_resources *)dev->sysdata;
  473. while (ptr && ptr->next)
  474. ptr = ptr->next;
  475. if (ptr && ptr->dependent && dependent) { /* add to another list */
  476. ptra = ptr->alt;
  477. while (ptra && ptra->alt)
  478. ptra = ptra->alt;
  479. if (!ptra)
  480. ptr->alt = res;
  481. else
  482. ptra->alt = res;
  483. } else {
  484. if (!ptr)
  485. dev->sysdata = res;
  486. else
  487. ptr->next = res;
  488. }
  489. if (dependent) {
  490. res->priority = dependent & 0xff;
  491. if (res->priority > ISAPNP_RES_PRIORITY_FUNCTIONAL)
  492. res->priority = ISAPNP_RES_PRIORITY_INVALID;
  493. res->dependent = 1;
  494. } else {
  495. res->priority = ISAPNP_RES_PRIORITY_PREFERRED;
  496. res->dependent = 0;
  497. }
  498. return res;
  499. }
  501. /*
  502.  *  Add IRQ resource to resources list.
  503.  */
  505. static void __init isapnp_add_irq_resource(struct pnp_dev *dev,
  506.                                             struct isapnp_resources **res,
  507.                                                int dependent, int size)
  508. {
  509. unsigned char tmp[3];
  510. struct isapnp_irq *irq, *ptr;
  512. isapnp_peek(tmp, size);
  513. irq = isapnp_alloc(sizeof(struct isapnp_irq));
  514. if (!irq)
  515. return;
  516. if (*res == NULL) {
  517. *res = isapnp_build_resources(dev, dependent);
  518. if (*res == NULL) {
  519. kfree(irq);
  520. return;
  521. }
  522. }
  523. irq->map = (tmp[1] << 8) | tmp[0];
  524. if (size > 2)
  525. irq->flags = tmp[2];
  526. else
  527. irq->flags = IORESOURCE_IRQ_HIGHEDGE;
  528. irq->res = *res;
  529. ptr = (*res)->irq;
  530. while (ptr && ptr->next)
  531. ptr = ptr->next;
  532. if (ptr)
  533. ptr->next = irq;
  534. else
  535. (*res)->irq = irq;
  536. }
  538. /*
  539.  *  Add DMA resource to resources list.
  540.  */
  542. static void __init isapnp_add_dma_resource(struct pnp_dev *dev,
  543.                                             struct isapnp_resources **res,
  544.                                             int dependent, int size)
  545. {
  546. unsigned char tmp[2];
  547. struct isapnp_dma *dma, *ptr;
  549. isapnp_peek(tmp, size);
  550. dma = isapnp_alloc(sizeof(struct isapnp_dma));
  551. if (!dma)
  552. return;
  553. if (*res == NULL) {
  554. *res = isapnp_build_resources(dev, dependent);
  555. if (*res == NULL) {
  556. kfree(dma);
  557. return;
  558. }
  559. }
  560. dma->map = tmp[0];
  561. dma->flags = tmp[1];
  562. dma->res = *res;
  563. ptr = (*res)->dma;
  564. while (ptr && ptr->next)
  565. ptr = ptr->next;
  566. if (ptr)
  567. ptr->next = dma;
  568. else
  569. (*res)->dma = dma;
  570. }
  572. /*
  573.  *  Add port resource to resources list.
  574.  */
  576. static void __init isapnp_add_port_resource(struct pnp_dev *dev,
  577. struct isapnp_resources **res,
  578. int dependent, int size)
  579. {
  580. unsigned char tmp[7];
  581. struct isapnp_port *port, *ptr;
  583. isapnp_peek(tmp, size);
  584. port = isapnp_alloc(sizeof(struct isapnp_port));
  585. if (!port)
  586. return;
  587. if (*res == NULL) {
  588. *res = isapnp_build_resources(dev, dependent);
  589. if (*res == NULL) {
  590. kfree(port);
  591. return;
  592. }
  593. }
  594. port->min = (tmp[2] << 8) | tmp[1];
  595. port->max = (tmp[4] << 8) | tmp[3];
  596. port->align = tmp[5];
  597. port->size = tmp[6];
  598. port->flags = tmp[0] ? ISAPNP_PORT_FLAG_16BITADDR : 0;
  599. port->res = *res;
  600. ptr = (*res)->port;
  601. while (ptr && ptr->next)
  602. ptr = ptr->next;
  603. if (ptr)
  604. ptr->next = port;
  605. else
  606. (*res)->port = port;
  607. }
  609. /*
  610.  *  Add fixed port resource to resources list.
  611.  */
  613. static void __init isapnp_add_fixed_port_resource(struct pnp_dev *dev,
  614.       struct isapnp_resources **res,
  615.       int dependent, int size)
  616. {
  617. unsigned char tmp[3];
  618. struct isapnp_port *port, *ptr;
  620. isapnp_peek(tmp, size);
  621. port = isapnp_alloc(sizeof(struct isapnp_port));
  622. if (!port)
  623. return;
  624. if (*res == NULL) {
  625. *res = isapnp_build_resources(dev, dependent);
  626. if (*res == NULL) {
  627. kfree(port);
  628. return;
  629. }
  630. }
  631. port->min = port->max = (tmp[1] << 8) | tmp[0];
  632. port->size = tmp[2];
  633. port->align = 0;
  634. port->flags = ISAPNP_PORT_FLAG_FIXED;
  635. port->res = *res;
  636. ptr = (*res)->port;
  637. while (ptr && ptr->next)
  638. ptr = ptr->next;
  639. if (ptr)
  640. ptr->next = port;
  641. else
  642. (*res)->port = port;
  643. }
  645. /*
  646.  *  Add memory resource to resources list.
  647.  */
  649. static void __init isapnp_add_mem_resource(struct pnp_dev *dev,
  650.        struct isapnp_resources **res,
  651.        int dependent, int size)
  652. {
  653. unsigned char tmp[9];
  654. struct isapnp_mem *mem, *ptr;
  656. isapnp_peek(tmp, size);
  657. mem = isapnp_alloc(sizeof(struct isapnp_mem));
  658. if (!mem)
  659. return;
  660. if (*res == NULL) {
  661. *res = isapnp_build_resources(dev, dependent);
  662. if (*res == NULL) {
  663. kfree(mem);
  664. return;
  665. }
  666. }
  667. mem->min = ((tmp[2] << 8) | tmp[1]) << 8;
  668. mem->max = ((tmp[4] << 8) | tmp[3]) << 8;
  669. mem->align = (tmp[6] << 8) | tmp[5];
  670. mem->size = ((tmp[8] << 8) | tmp[7]) << 8;
  671. mem->flags = tmp[0];
  672. mem->res = *res;
  673. ptr = (*res)->mem;
  674. while (ptr && ptr->next)
  675. ptr = ptr->next;
  676. if (ptr)
  677. ptr->next = mem;
  678. else
  679. (*res)->mem = mem;
  680. }
  682. /*
  683.  *  Add 32-bit memory resource to resources list.
  684.  */
  686. static void __init isapnp_add_mem32_resource(struct pnp_dev *dev,
  687.  struct isapnp_resources **res,
  688.  int dependent, int size)
  689. {
  690. unsigned char tmp[17];
  691. struct isapnp_mem32 *mem32, *ptr;
  693. isapnp_peek(tmp, size);
  694. mem32 = isapnp_alloc(sizeof(struct isapnp_mem32));
  695. if (!mem32)
  696. return;
  697. if (*res == NULL) {
  698. *res = isapnp_build_resources(dev, dependent);
  699. if (*res == NULL) {
  700. kfree(mem32);
  701. return;
  702. }
  703. }
  704. memcpy(mem32->data, tmp, 17);
  705. mem32->res = *res;
  706. ptr = (*res)->mem32;
  707. while (ptr && ptr->next)
  708. ptr = ptr->next;
  709. if (ptr)
  710. ptr->next = mem32;
  711. else
  712. (*res)->mem32 = mem32;
  713. }
  715. /*
  716.  *  Add 32-bit fixed memory resource to resources list.
  717.  */
  719. static void __init isapnp_add_fixed_mem32_resource(struct pnp_dev *dev,
  720.        struct isapnp_resources **res,
  721.        int dependent, int size)
  722. {
  723. unsigned char tmp[17];
  724. struct isapnp_mem32 *mem32, *ptr;
  726. isapnp_peek(tmp, size);
  727. mem32 = isapnp_alloc(sizeof(struct isapnp_mem32));
  728. if (!mem32)
  729. return;
  730. if (*res == NULL) {
  731. *res = isapnp_build_resources(dev, dependent);
  732. if (*res == NULL) {
  733. kfree(mem32);
  734. return;
  735. }
  736. }
  737. memcpy(mem32->data, tmp, 17);
  738. mem32->res = *res;
  739. ptr = (*res)->mem32;
  740. while (ptr && ptr->next)
  741. ptr = ptr->next;
  742. if (ptr)
  743. ptr->next = mem32;
  744. else
  745. (*res)->mem32 = mem32;
  746. }
  748. /*
  749.  *  Parse resource map for logical device.
  750.  */
  752. static int __init isapnp_create_device(struct pnp_bus *card,
  753.    unsigned short size)
  754. {
  755. int number = 0, skip = 0, dependent = 0, compat = 0;
  756. unsigned char type, tmp[17];
  757. struct pnp_dev *dev, *prev_dev;
  758. struct isapnp_resources *res = NULL;
  760. if ((dev = isapnp_parse_device(card, size, number++)) == NULL)
  761. return 1;
  762. card->devices = dev;
  763. if (isapnp_last_device) {
  764. isapnp_last_device->next = dev;
  765. isapnp_last_device = dev;
  766. } else {
  767. isapnp_devices = isapnp_last_device = dev;
  768. }
  769. while (1) {
  770. if (isapnp_read_tag(&type, &size)<0)
  771. return 1;
  772. if (skip && type != _STAG_LOGDEVID && type != _STAG_END)
  773. goto __skip;
  774. switch (type) {
  775. case _STAG_LOGDEVID:
  776. if (size >= 5 && size <= 6) {
  777. prev_dev = dev;
  778. isapnp_config_prepare(dev);
  779. if ((dev = isapnp_parse_device(card, size, number++)) == NULL)
  780. return 1;
  781. prev_dev->sibling = dev;
  782. isapnp_last_device->next = dev;
  783. isapnp_last_device = dev;
  784. size = 0;
  785. skip = 0;
  786. } else {
  787. skip = 1;
  788. }
  789. res = NULL;
  790. dependent = 0;
  791. compat = 0;
  792. break;
  793. case _STAG_COMPATDEVID:
  794. if (size == 4 && compat < DEVICE_COUNT_COMPATIBLE) {
  795. isapnp_peek(tmp, 4);
  796. dev->vendor_compatible[compat] = (tmp[1] << 8) | tmp[0];
  797. dev->device_compatible[compat] = (tmp[3] << 8) | tmp[2];
  798. compat++;
  799. size = 0;
  800. }
  801. break;
  802. case _STAG_IRQ:
  803. if (size < 2 || size > 3)
  804. goto __skip;
  805. isapnp_add_irq_resource(dev, &res, dependent, size);
  806. size = 0;
  807. break;
  808. case _STAG_DMA:
  809. if (size != 2)
  810. goto __skip;
  811. isapnp_add_dma_resource(dev, &res, dependent, size);
  812. size = 0;
  813. break;
  814. case _STAG_STARTDEP:
  815. if (size > 1)
  816. goto __skip;
  817. res = NULL;
  818. dependent = 0x100 | ISAPNP_RES_PRIORITY_ACCEPTABLE;
  819. if (size > 0) {
  820. isapnp_peek(tmp, size);
  821. dependent = 0x100 | tmp[0];
  822. size = 0;
  823. }
  824. break;
  825. case _STAG_ENDDEP:
  826. if (size != 0)
  827. goto __skip;
  828. res = NULL;
  829. dependent = 0;
  830. break;
  831. case _STAG_IOPORT:
  832. if (size != 7)
  833. goto __skip;
  834. isapnp_add_port_resource(dev, &res, dependent, size);
  835. size = 0;
  836. break;
  837. case _STAG_FIXEDIO:
  838. if (size != 3)
  839. goto __skip;
  840. isapnp_add_fixed_port_resource(dev, &res, dependent, size);
  841. size = 0;
  842. break;
  843. case _STAG_VENDOR:
  844. break;
  845. case _LTAG_MEMRANGE:
  846. if (size != 9)
  847. goto __skip;
  848. isapnp_add_mem_resource(dev, &res, dependent, size);
  849. size = 0;
  850. break;
  851. case _LTAG_ANSISTR:
  852. if (dev->name[0] == '') {
  853. unsigned short size1 = size > 47 ? 47 : size;
  854. isapnp_peek(dev->name, size1);
  855. dev->name[size1] = '';
  856. size -= size1;
  857. }
  858. break;
  859. case _LTAG_UNICODESTR:
  860. /* silently ignore */
  861. /* who use unicode for hardware identification? */
  862. break;
  863. case _LTAG_VENDOR:
  864. break;
  865. case _LTAG_MEM32RANGE:
  866. if (size != 17)
  867. goto __skip;
  868. isapnp_add_mem32_resource(dev, &res, dependent, size);
  869. size = 0;
  870. break;
  871. case _LTAG_FIXEDMEM32RANGE:
  872. if (size != 17)
  873. goto __skip;
  874. isapnp_add_fixed_mem32_resource(dev, &res, dependent, size);
  875. size = 0;
  876. break;
  877. case _STAG_END:
  878. if (size > 0)
  879. isapnp_skip_bytes(size);
  880. return 1;
  881. default:
  882. printk("isapnp: unexpected or unknown tag type 0x%x for logical device %i (device %i), ignoredn", type, dev->devfn, card->number);
  883. }
  884.       __skip:
  885.        if (size > 0)
  886.        isapnp_skip_bytes(size);
  887. }
  888. isapnp_config_prepare(dev);
  889. return 0;
  890. }
  892. /*
  893.  *  Parse resource map for ISA PnP card.
  894.  */
  895.  
  896. static void __init isapnp_parse_resource_map(struct pnp_bus *card)
  897. {
  898. unsigned char type, tmp[17];
  899. unsigned short size;
  901. while (1) {
  902. if (isapnp_read_tag(&type, &size)<0)
  903. return;
  904. switch (type) {
  905. case _STAG_PNPVERNO:
  906. if (size != 2)
  907. goto __skip;
  908. isapnp_peek(tmp, 2);
  909. card->pnpver = tmp[0];
  910. card->productver = tmp[1];
  911. size = 0;
  912. break;
  913. case _STAG_LOGDEVID:
  914. if (size >= 5 && size <= 6) {
  915. if (isapnp_create_device(card, size)==1)
  916. return;
  917. size = 0;
  918. }
  919. break;
  920. case _STAG_VENDOR:
  921. break;
  922. case _LTAG_ANSISTR:
  923. if (card->name[0] == '') {
  924. unsigned short size1 = size > 47 ? 47 : size;
  925. isapnp_peek(card->name, size1);
  926. card->name[size1] = '';
  927. size -= size1;
  928. }
  929. break;
  930. case _LTAG_UNICODESTR:
  931. /* silently ignore */
  932. /* who use unicode for hardware identification? */
  933. break;
  934. case _LTAG_VENDOR:
  935. break;
  936. case _STAG_END:
  937. if (size > 0)
  938. isapnp_skip_bytes(size);
  939. return;
  940. default:
  941. printk("isapnp: unexpected or unknown tag type 0x%x for device %i, ignoredn", type, card->number);
  942. }
  943.       __skip:
  944.        if (size > 0)
  945.        isapnp_skip_bytes(size);
  946. }
  947. }
  949. /*
  950.  *  Compute ISA PnP checksum for first eight bytes.
  951.  */
  953. static unsigned char __init isapnp_checksum(unsigned char *data)
  954. {
  955. int i, j;
  956. unsigned char checksum = 0x6a, bit, b;
  958. for (i = 0; i < 8; i++) {
  959. b = data[i];
  960. for (j = 0; j < 8; j++) {
  961. bit = 0;
  962. if (b & (1 << j))
  963. bit = 1;
  964. checksum = ((((checksum ^ (checksum >> 1)) & 0x01) ^ bit) << 7) | (checksum >> 1);
  965. }
  966. }
  967. return checksum;
  968. }
  970. /*
  971.  *  Build device list for all present ISA PnP devices.
  972.  */
  974. static int __init isapnp_build_device_list(void)
  975. {
  976. int csn;
  977. unsigned char header[9], checksum;
  978. struct pnp_bus *card, *prev = NULL;
  980. isapnp_wait();
  981. isapnp_key();
  982. for (csn = 1; csn <= 10; csn++) {
  983. isapnp_wake(csn);
  984. isapnp_peek(header, 9);
  985. checksum = isapnp_checksum(header);
  986.         if(isapnp_debug > 0)
  987.         {
  988. printk("vendor: %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02xn",
  989. header[0], header[1], header[2], header[3],
  990. header[4], header[5], header[6], header[7], header[8]);
  991. printk("checksum = 0x%xn", checksum);
  992.         }
  993. if (checksum == 0x00 || checksum != header[8]) /* not valid CSN */
  994. continue;
  995. if ((card = isapnp_alloc(sizeof(struct pnp_bus))) == NULL)
  996. continue;
  997. card->number = csn;
  998. card->vendor = (header[1] << 8) | header[0];
  999. card->device = (header[3] << 8) | header[2];
  1000. card->serial = (header[7] << 24) | (header[6] << 16) | (header[5] << 8) | header[4];
  1001. isapnp_checksum_value = 0x00;
  1002. isapnp_parse_resource_map(card);
  1003. if (isapnp_checksum_value != 0x00)
  1004. printk("isapnp: checksum for device %i is not valid (0x%x)n", csn, isapnp_checksum_value);
  1005. card->checksum = isapnp_checksum_value;
  1006. if (!isapnp_cards)
  1007. isapnp_cards = card;
  1008. else
  1009. prev->next = card;
  1010. prev = card;
  1011. }
  1012. return 0;
  1013. }
  1015. /*
  1016.  *  Basic configuration routines.
  1017.  */
  1019. int isapnp_present(void)
  1020. {
  1021. if (isapnp_devices)
  1022. return 1;
  1023. return 0;
  1024. }
  1026. int isapnp_cfg_begin(int csn, int logdev)
  1027. {
  1028. if (csn < 1 || csn > 10 || logdev > 10)
  1029. return -EINVAL;
  1030. MOD_INC_USE_COUNT;
  1031. down(&isapnp_cfg_mutex);
  1032. isapnp_wait();
  1033. isapnp_key();
  1034. isapnp_wake(csn);
  1035. #if 1 /* to avoid malfunction when the isapnptools package is used */
  1036. isapnp_set_rdp();
  1037. udelay(1000); /* delay 1000us */
  1038. write_address(0x01);
  1039. udelay(1000); /* delay 1000us */
  1040. #endif
  1041. if (logdev >= 0)
  1042. isapnp_device(logdev);
  1043. return 0;
  1044. }
  1046. int isapnp_cfg_end(void)
  1047. {
  1048. isapnp_wait();
  1049. up(&isapnp_cfg_mutex);
  1050. MOD_DEC_USE_COUNT;
  1051. return 0;
  1052. }
  1054. /*
  1055.  *  Resource manager.
  1056.  */
  1058. static struct isapnp_port *isapnp_find_port(struct pnp_dev *dev, int index)
  1059. {
  1060. struct isapnp_resources *res;
  1061. struct isapnp_port *port;
  1063. if (!dev || index < 0 || index > 7)
  1064. return NULL;
  1065. for (res = (struct isapnp_resources *)dev->sysdata; res; res = res->next) {
  1066. for (port = res->port; port; port = port->next) {
  1067. if (!index)
  1068. return port;
  1069. index--;
  1070. }
  1071. }
  1072. return NULL;
  1073. }
  1075. struct isapnp_irq *isapnp_find_irq(struct pnp_dev *dev, int index)
  1076. {
  1077. struct isapnp_resources *res, *resa;
  1078. struct isapnp_irq *irq;
  1079. int index1, index2, index3;
  1081. if (!dev || index < 0 || index > 7)
  1082. return NULL;
  1083. for (res = (struct isapnp_resources *)dev->sysdata; res; res = res->next) {
  1084. index3 = 0;
  1085. for (resa = res; resa; resa = resa->alt) {
  1086. index1 = index;
  1087. index2 = 0;
  1088. for (irq = resa->irq; irq; irq = irq->next) {
  1089. if (!index1)
  1090. return irq;
  1091. index1--;
  1092. index2++;
  1093. }
  1094. if (index3 < index2)
  1095. index3 = index2;
  1096. }
  1097. index -= index3;
  1098. }
  1099. return NULL;
  1100. }
  1102. struct isapnp_dma *isapnp_find_dma(struct pnp_dev *dev, int index)
  1103. {
  1104. struct isapnp_resources *res;
  1105. struct isapnp_dma *dma;
  1107. if (!dev || index < 0 || index > 7)
  1108. return NULL;
  1109. for (res = (struct isapnp_resources *)dev->sysdata; res; res = res->next) {
  1110. for (dma = res->dma; dma; dma = dma->next) {
  1111. if (!index)
  1112. return dma;
  1113. index--;
  1114. }
  1115. }
  1116. return NULL;
  1117. }
  1119. struct isapnp_mem *isapnp_find_mem(struct pnp_dev *dev, int index)
  1120. {
  1121. struct isapnp_resources *res;
  1122. struct isapnp_mem *mem;
  1124. if (!dev || index < 0 || index > 7)
  1125. return NULL;
  1126. for (res = (struct isapnp_resources *)dev->sysdata; res; res = res->next) {
  1127. for (mem = res->mem; mem; mem = mem->next) {
  1128. if (!index)
  1129. return mem;
  1130. index--;
  1131. }
  1132. }
  1133. return NULL;
  1134. }
  1136. struct isapnp_mem32 *isapnp_find_mem32(struct pnp_dev *dev, int index)
  1137. {
  1138. struct isapnp_resources *res;
  1139. struct isapnp_mem32 *mem32;
  1141. if (!dev || index < 0 || index > 7)
  1142. return NULL;
  1143. for (res = (struct isapnp_resources *)dev->sysdata; res; res = res->next) {
  1144. for (mem32 = res->mem32; mem32; mem32 = mem32->next) {
  1145. if (!index)
  1146. return mem32;
  1147. index--;
  1148. }
  1149. }
  1150. return NULL;
  1151. }
  1153. /*
  1154.  *  Device manager.
  1155.  */
  1157. struct pnp_bus *isapnp_find_card(unsigned short vendor,
  1158.  unsigned short device,
  1159.  struct pnp_bus *from)
  1160. {
  1161. struct pnp_bus *card;
  1163. if (from == NULL) {
  1164. from = isapnp_cards;
  1165. } else {
  1166. from = from->next;
  1167. }
  1168. for (card = from; card; card = card->next) {
  1169. if (card->vendor == vendor && card->device == device)
  1170. return card;
  1171. }
  1172. return NULL;
  1173. }
  1175. struct pnp_dev *isapnp_find_dev(struct pnp_bus *card,
  1176. unsigned short vendor,
  1177. unsigned short function,
  1178. struct pnp_dev *from)
  1179. {
  1180. struct pnp_dev *dev;
  1181. int idx;
  1183. if (card == NULL) { /* look for a logical device from all cards */
  1184. if (from == NULL) {
  1185. from = isapnp_devices;
  1186. } else {
  1187. from = from->next;
  1188. }
  1189. for (dev = from; dev; dev = dev->next) {
  1190. if (dev->vendor == vendor && dev->device == function)
  1191. return dev;
  1192. for (idx = 0; idx < DEVICE_COUNT_COMPATIBLE; idx++)
  1193. if (dev->vendor_compatible[idx] == vendor &&
  1194.     dev->device_compatible[idx] == function)
  1195. return dev;
  1196. }
  1197. } else {
  1198. if (from == NULL) {
  1199. from = card->devices;
  1200. } else {
  1201. from = from->next;
  1202. }
  1203. if (from->bus != card) /* something is wrong */
  1204. return NULL;
  1205. for (dev = from; dev; dev = dev->sibling) {
  1206. if (dev->vendor == vendor && dev->device == function)
  1207. return dev;
  1208. for (idx = 0; idx < DEVICE_COUNT_COMPATIBLE; idx++)
  1209. if (dev->vendor_compatible[idx] == vendor &&
  1210.     dev->device_compatible[idx] == function)
  1211. return dev;
  1212. }
  1213. }
  1214. return NULL;
  1215. }
  1217. static unsigned int isapnp_dma_resource_flags(struct isapnp_dma *dma)
  1218. {
  1219. return dma->flags | IORESOURCE_DMA | IORESOURCE_AUTO;
  1220. }
  1222. static unsigned int isapnp_mem_resource_flags(struct isapnp_mem *mem)
  1223. {
  1224. unsigned int result;
  1226. result = mem->flags | IORESOURCE_MEM | IORESOURCE_AUTO;
  1227. if (!(mem->flags & IORESOURCE_MEM_WRITEABLE))
  1228. result |= IORESOURCE_READONLY;
  1229. if (mem->flags & IORESOURCE_MEM_CACHEABLE)
  1230. result |= IORESOURCE_CACHEABLE;
  1231. if (mem->flags & IORESOURCE_MEM_RANGELENGTH)
  1232. result |= IORESOURCE_RANGELENGTH;
  1233. if (mem->flags & IORESOURCE_MEM_SHADOWABLE)
  1234. result |= IORESOURCE_SHADOWABLE;
  1235. return result;
  1236. }
  1238. static unsigned int isapnp_irq_resource_flags(struct isapnp_irq *irq)
  1239. {
  1240. return irq->flags | IORESOURCE_IRQ | IORESOURCE_AUTO;
  1241. }
  1243. static unsigned int isapnp_port_resource_flags(struct isapnp_port *port)
  1244. {
  1245. return port->flags | IORESOURCE_IO | IORESOURCE_AUTO;
  1246. }
  1248. static int isapnp_config_prepare(struct pnp_dev *dev)
  1249. {
  1250. struct isapnp_resources *res, *resa;
  1251. struct isapnp_port *port;
  1252. struct isapnp_irq *irq;
  1253. struct isapnp_dma *dma;
  1254. struct isapnp_mem *mem;
  1255. int port_count, port_count1;
  1256. int irq_count, irq_count1;
  1257. int dma_count, dma_count1;
  1258. int mem_count, mem_count1;
  1259. int idx;
  1261. if (dev == NULL)
  1262. return -EINVAL;
  1263. if (dev->active) // || dev->ro)
  1264. return -EBUSY;
  1265. for (idx = 0; idx < DEVICE_COUNT_IRQ; idx++) {
  1266. dev->irq_resource[idx].name = NULL;
  1267. dev->irq_resource[idx].start = 0;
  1268. dev->irq_resource[idx].end = 0;
  1269. dev->irq_resource[idx].flags = 0;
  1270. }
  1271. for (idx = 0; idx < DEVICE_COUNT_DMA; idx++) {
  1272. dev->dma_resource[idx].name = NULL;
  1273. dev->dma_resource[idx].start = 0;
  1274. dev->dma_resource[idx].end = 0;
  1275. dev->dma_resource[idx].flags = 0;
  1276. }
  1277. for (idx = 0; idx < DEVICE_COUNT_RESOURCE; idx++) {
  1278. dev->resource[idx].name = NULL;
  1279. dev->resource[idx].start = 0;
  1280. dev->resource[idx].end = 0;
  1281. dev->resource[idx].flags = 0;
  1282. }
  1283. port_count = irq_count = dma_count = mem_count = 0;
  1284. for (res = (struct isapnp_resources *)dev->sysdata; res; res = res->next) {
  1285. port_count1 = irq_count1 = dma_count1 = mem_count1 = 0;
  1286. for (resa = res; resa; resa = resa->alt) {
  1287. for (port = resa->port, idx = 0; port; port = port->next, idx++) {
  1288. if (dev->resource[port_count + idx].flags == 0) {
  1289. dev->resource[port_count + idx].flags = isapnp_port_resource_flags(port);
  1290. dev->resource[port_count + idx].end = port->size;
  1291. }
  1292. }
  1293. if (port_count1 < idx)
  1294. port_count1 = idx;
  1295. for (irq = resa->irq, idx = 0; irq; irq = irq->next, idx++) {
  1296. int count = irq_count + idx;
  1297. if (count < DEVICE_COUNT_IRQ) {
  1298. if (dev->irq_resource[count].flags == 0) {
  1299. dev->irq_resource[count].flags = isapnp_irq_resource_flags(irq);
  1300. }
  1301. }
  1303. }
  1304. if (irq_count1 < idx)
  1305. irq_count1 = idx;
  1306. for (dma = resa->dma, idx = 0; dma; dma = dma->next, idx++)
  1307. if (dev->dma_resource[idx].flags == 0) {
  1308. dev->dma_resource[idx].flags = isapnp_dma_resource_flags(dma);
  1309. }
  1310. if (dma_count1 < idx)
  1311. dma_count1 = idx;
  1312. for (mem = resa->mem, idx = 0; mem; mem = mem->next, idx++)
  1313. if (dev->resource[mem_count + idx + 8].flags == 0) {
  1314. dev->resource[mem_count + idx + 8].flags = isapnp_mem_resource_flags(mem);
  1315. }
  1316. if (mem_count1 < idx)
  1317. mem_count1 = idx;
  1318. }
  1319. port_count += port_count1;
  1320. irq_count += irq_count1;
  1321. dma_count += dma_count1;
  1322. mem_count += mem_count1;
  1323. }
  1324. return 0;
  1325. }
  1327. struct isapnp_cfgtmp {
  1328. struct isapnp_port *port[8];
  1329. struct isapnp_irq *irq[2];
  1330. struct isapnp_dma *dma[2];
  1331. struct isapnp_mem *mem[4];
  1332. struct pnp_dev *request;
  1333. struct pnp_dev result;
  1334. };
  1336. static int isapnp_alternative_switch(struct isapnp_cfgtmp *cfg,
  1337.      struct isapnp_resources *from,
  1338.      struct isapnp_resources *to)
  1339. {
  1340. int tmp, tmp1;
  1341. struct isapnp_port *port;
  1342. struct isapnp_irq *irq;
  1343. struct isapnp_dma *dma;
  1344. struct isapnp_mem *mem;
  1346. if (!cfg)
  1347. return -EINVAL;
  1348. /* process port settings */
  1349. for (tmp = 0; tmp < 8; tmp++) {
  1350. if (!(cfg->request->resource[tmp].flags & IORESOURCE_AUTO))
  1351. continue; /* don't touch */
  1352. port = cfg->port[tmp];
  1353. if (!port) {
  1354. cfg->port[tmp] = port = isapnp_find_port(cfg->request, tmp);
  1355. if (!port)
  1356. return -EINVAL;
  1357. }
  1358. if (from && port->res == from) {
  1359. while (port->res != to) {
  1360. if (!port->res->alt)
  1361. return -EINVAL;
  1362. port = port->res->alt->port;
  1363. for (tmp1 = tmp; tmp1 > 0 && port; tmp1--)
  1364. port = port->next;
  1365. cfg->port[tmp] = port;
  1366. if (!port)
  1367. return -ENOENT;
  1368. cfg->result.resource[tmp].flags = isapnp_port_resource_flags(port);
  1369. }
  1370. }
  1371. }
  1372. /* process irq settings */
  1373. for (tmp = 0; tmp < 2; tmp++) {
  1374. if (!(cfg->request->irq_resource[tmp].flags & IORESOURCE_AUTO))
  1375. continue; /* don't touch */
  1376. irq = cfg->irq[tmp];
  1377. if (!irq) {
  1378. cfg->irq[tmp] = irq = isapnp_find_irq(cfg->request, tmp);
  1379. if (!irq)
  1380. return -EINVAL;
  1381. }
  1382. if (from && irq->res == from) {
  1383. while (irq->res != to) {
  1384. if (!irq->res->alt)
  1385. return -EINVAL;
  1386. irq = irq->res->alt->irq;
  1387. for (tmp1 = tmp; tmp1 > 0 && irq; tmp1--)
  1388. irq = irq->next;
  1389. cfg->irq[tmp] = irq;
  1390. if (!irq)
  1391. return -ENOENT;
  1392. cfg->result.irq_resource[tmp].flags = isapnp_irq_resource_flags(irq);
  1393. }
  1394. }
  1395. }
  1396. /* process dma settings */
  1397. for (tmp = 0; tmp < 2; tmp++) {
  1398. if (!(cfg->request->dma_resource[tmp].flags & IORESOURCE_AUTO))
  1399. continue; /* don't touch */
  1400. dma = cfg->dma[tmp];
  1401. if (!dma) {
  1402. cfg->dma[tmp] = dma = isapnp_find_dma(cfg->request, tmp);
  1403. if (!dma)
  1404. return -EINVAL;
  1405. }
  1406. if (from && dma->res == from) {
  1407. while (dma->res != to) {
  1408. if (!dma->res->alt)
  1409. return -EINVAL;
  1410. dma = dma->res->alt->dma;
  1411. for (tmp1 = tmp; tmp1 > 0 && dma; tmp1--)
  1412. dma = dma->next;
  1413. cfg->dma[tmp] = dma;
  1414. if (!dma)
  1415. return -ENOENT;
  1416. cfg->result.dma_resource[tmp].flags = isapnp_dma_resource_flags(dma);
  1417. }
  1418. }
  1419. }
  1420. /* process memory settings */
  1421. for (tmp = 0; tmp < 4; tmp++) {
  1422. if (!(cfg->request->resource[tmp + 8].flags & IORESOURCE_AUTO))
  1423. continue; /* don't touch */
  1424. mem = cfg->mem[tmp];
  1425. if (!mem) {
  1426. cfg->mem[tmp] = mem = isapnp_find_mem(cfg->request, tmp);
  1427. if (!mem)
  1428. return -EINVAL;
  1429. }
  1430. if (from && mem->res == from) {
  1431. while (mem->res != to) {
  1432. if (!mem->res->alt)
  1433. return -EINVAL;
  1434. mem = mem->res->alt->mem;
  1435. for (tmp1 = tmp; tmp1 > 0 && mem; tmp1--)
  1436. mem = mem->next;
  1437. cfg->mem[tmp] = mem;
  1438. if (!mem)
  1439. return -ENOENT;
  1440. cfg->result.resource[tmp + 8].flags = isapnp_mem_resource_flags(mem);
  1441. }
  1442. }
  1443. }
  1444. return 0;
  1445. }
  1447. static int isapnp_check_port(struct isapnp_cfgtmp *cfg, int port, int size, int idx)
  1448. {
  1449. int i, tmp, rport, rsize;
  1450. struct isapnp_port *xport;
  1451. struct pnp_dev *dev;
  1453. if (check_region(port, size))
  1454. return 1;
  1455. for (i = 0; i < 8; i++) {
  1456. rport = isapnp_reserve_io[i << 1];
  1457. rsize = isapnp_reserve_io[(i << 1) + 1];
  1458. if (port >= rport && port < rport + rsize)
  1459. return 1;
  1460. if (port + size > rport && port + size < (rport + rsize) - 1)
  1461. return 1;
  1462. }
  1463. for (dev = isapnp_devices; dev; dev = dev->next) {
  1464. if (dev->active) {
  1465. for (tmp = 0; tmp < 8; tmp++) {
  1466. if (dev->resource[tmp].flags) {
  1467. rport = dev->resource[tmp].start;
  1468. rsize = (dev->resource[tmp].end - rport) + 1;
  1469. if (port >= rport && port < rport + rsize)
  1470. return 1;
  1471. if (port + size > rport && port + size < (rport + rsize) - 1)
  1472. return 1;
  1473. }
  1474. }
  1475. }
  1476. }
  1477. for (i = 0; i < 8; i++) {
  1478. unsigned int flags;
  1479. if (i == idx)
  1480. continue;
  1481. flags = cfg->request->resource[i].flags;
  1482. if (!flags)
  1483. continue;
  1484. tmp = cfg->request->resource[i].start;
  1485. if (flags & IORESOURCE_AUTO) { /* auto */
  1486. xport = cfg->port[i];
  1487. if (!xport)
  1488. return 1;
  1489. if (cfg->result.resource[i].flags & IORESOURCE_AUTO)
  1490. continue;
  1491. tmp = cfg->result.resource[i].start;
  1492. if (tmp + xport->size >= port && tmp <= port + xport->size)
  1493. return 1;
  1494. continue;
  1495. }
  1496. if (port == tmp)
  1497. return 1;
  1498. xport = isapnp_find_port(cfg->request, i);
  1499. if (!xport)
  1500. return 1;
  1501. if (tmp + xport->size >= port && tmp <= port + xport->size)
  1502. return 1;
  1503. }
  1504. return 0;
  1505. }
  1507. static int isapnp_valid_port(struct isapnp_cfgtmp *cfg, int idx)
  1508. {
  1509. int err;
  1510. unsigned long *value1, *value2;
  1511. struct isapnp_port *port;
  1513. if (!cfg || idx < 0 || idx > 7)
  1514. return -EINVAL;
  1515. if (!(cfg->result.resource[idx].flags & IORESOURCE_AUTO)) /* don't touch */
  1516. return 0;
  1517.       __again:
  1518.        port = cfg->port[idx];
  1519.        if (!port)
  1520.        return -EINVAL;
  1521.        value1 = &cfg->result.resource[idx].start;
  1522.        value2 = &cfg->result.resource[idx].end;
  1523. if (cfg->result.resource[idx].flags & IORESOURCE_AUTO) {
  1524. cfg->result.resource[idx].flags &= ~IORESOURCE_AUTO;
  1525. *value1 = port->min;
  1526. *value2 = port->min + port->size - 1;
  1527. if (!isapnp_check_port(cfg, *value1, port->size, idx))
  1528. return 0;
  1529. }
  1530. do {
  1531. *value1 += port->align;
  1532. *value2 = *value1 + port->size - 1;
  1533. if (*value1 > port->max || !port->align) {
  1534. if (port->res && port->res->alt) {
  1535. if ((err = isapnp_alternative_switch(cfg, port->res, port->res->alt))<0)
  1536. return err;
  1537. goto __again;
  1538. }
  1539. return -ENOENT;
  1540. }
  1541. } while (isapnp_check_port(cfg, *value1, port->size, idx));
  1542. return 0;
  1543. }
  1545. static void isapnp_test_handler(int irq, void *dev_id, struct pt_regs *regs)
  1546. {
  1547. }
  1549. static int isapnp_check_interrupt(struct isapnp_cfgtmp *cfg, int irq, int idx)
  1550. {
  1551. int i;
  1552. struct pnp_dev *dev;
  1554. if (irq < 0 || irq > 15)
  1555. return 1;
  1556. for (i = 0; i < 16; i++) {
  1557. if (isapnp_reserve_irq[i] == irq)
  1558. return 1;
  1559. }
  1560. for (dev = isapnp_devices; dev; dev = dev->next) {
  1561. if (dev->active) {
  1562. if (dev->irq_resource[0].start == irq ||
  1563.     dev->irq_resource[1].start == irq)
  1564. return 1;
  1565. }
  1566. }
  1567. if (request_irq(irq, isapnp_test_handler, SA_INTERRUPT, "isapnp", NULL))
  1568. return 1;
  1569. free_irq(irq, NULL);
  1570. for (i = 0; i < DEVICE_COUNT_IRQ; i++) {
  1571. if (i == idx)
  1572. continue;
  1573. if (!cfg->result.irq_resource[i].flags)
  1574. continue;
  1575. if (cfg->result.irq_resource[i].flags & IORESOURCE_AUTO)
  1576. continue;
  1577. if (cfg->result.irq_resource[i].start == irq)
  1578. return 1;
  1579. }
  1580. return 0;
  1581. }
  1583. static int isapnp_valid_irq(struct isapnp_cfgtmp *cfg, int idx)
  1584. {
  1585. /* IRQ priority: this table is good for i386 */
  1586. static unsigned short xtab[16] = {
  1587. 5, 10, 11, 12, 9, 14, 15, 7, 3, 4, 13, 0, 1, 6, 8, 2
  1588. };
  1589. int err, i;
  1590. unsigned long *value1, *value2;
  1591. struct isapnp_irq *irq;
  1593. if (!cfg || idx < 0 || idx > 1)
  1594. return -EINVAL;
  1595. if (!(cfg->result.irq_resource[idx].flags & IORESOURCE_AUTO))
  1596. return 0;
  1597.       __again:
  1598.        irq = cfg->irq[idx];
  1599.        if (!irq)
  1600.        return -EINVAL;
  1601.        value1 = &cfg->result.irq_resource[idx].start;
  1602.        value2 = &cfg->result.irq_resource[idx].end;
  1603. if (cfg->result.irq_resource[idx].flags & IORESOURCE_AUTO) {
  1604. for (i = 0; i < 16 && !(irq->map & (1<<xtab[i])); i++);
  1605. if (i >= 16)
  1606. return -ENOENT;
  1607. cfg->result.irq_resource[idx].flags &= ~IORESOURCE_AUTO;
  1608. if (!isapnp_check_interrupt(cfg, *value1 = *value2 = xtab[i], idx))
  1609. return 0;
  1610. }
  1611. do {
  1612. for (i = 0; i < 16 && xtab[i] != *value1; i++);
  1613. for (i++; i < 16 && !(irq->map & (1<<xtab[i])); i++);
  1614. if (i >= 16) {
  1615. if (irq->res && irq->res->alt) {
  1616. if ((err = isapnp_alternative_switch(cfg, irq->res, irq->res->alt))<0)
  1617. return err;
  1618. goto __again;
  1619. }
  1620. return -ENOENT;
  1621. } else {
  1622. *value1 = *value2 = xtab[i];
  1623. }
  1624. } while (isapnp_check_interrupt(cfg, *value1, idx));
  1625. return 0;
  1626. }
  1628. static int isapnp_check_dma(struct isapnp_cfgtmp *cfg, int dma, int idx)
  1629. {
  1630. int i;
  1631. struct pnp_dev *dev;
  1633. if (dma < 0 || dma == 4 || dma > 7)
  1634. return 1;
  1635. for (i = 0; i < 8; i++) {
  1636. if (isapnp_reserve_dma[i] == dma)
  1637. return 1;
  1638. }
  1639. for (dev = isapnp_devices; dev; dev = dev->next) {
  1640. if (dev->active) {
  1641. if (dev->dma_resource[0].start == dma || dev->dma_resource[1].start == dma)
  1642. return 1;
  1643. }
  1644. }
  1645. if (request_dma(dma, "isapnp"))
  1646. return 1;
  1647. free_dma(dma);
  1648. for (i = 0; i < 2; i++) {
  1649. if (i == idx)
  1650. continue;
  1651. if (!cfg->result.dma_resource[i].flags ||
  1652.     (cfg->result.dma_resource[i].flags & IORESOURCE_AUTO))
  1653. continue;
  1654. if (cfg->result.dma_resource[i].start == dma)
  1655. return 1;
  1656. }
  1657. return 0;
  1658. }
  1660. static int isapnp_valid_dma(struct isapnp_cfgtmp *cfg, int idx)
  1661. {
  1662. int err, i;
  1663. unsigned long *value1, *value2;
  1664. struct isapnp_dma *dma;
  1666. if (!cfg || idx < 0 || idx > 1)
  1667. return -EINVAL;
  1668. if (!(cfg->result.dma_resource[idx].flags & IORESOURCE_AUTO)) /* don't touch */
  1669. return 0;
  1670.       __again:
  1671.        dma = cfg->dma[idx];
  1672.        if (!dma)
  1673.        return -EINVAL;
  1674.        value1 = &cfg->result.dma_resource[idx].start;
  1675.        value2 = &cfg->result.dma_resource[idx].end;
  1676. if (cfg->result.dma_resource[idx].flags & IORESOURCE_AUTO) {
  1677. for (i = 0; i < 8 && !(dma->map & (1<<i)); i++);
  1678. if (i >= 8)
  1679. return -ENOENT;
  1680. cfg->result.dma_resource[idx].flags &= ~IORESOURCE_AUTO;
  1681. if (!isapnp_check_dma(cfg, *value1 = *value2 = i, idx))
  1682. return 0;
  1683. }
  1684. do {
  1685. for (i = *value1 + 1; i < 8 && !(dma->map & (1<<i)); i++);
  1686. if (i >= 8) {
  1687. if (dma->res && dma->res->alt) {
  1688. if ((err = isapnp_alternative_switch(cfg, dma->res, dma->res->alt))<0)
  1689. return err;
  1690. goto __again;
  1691. }
  1692. return -ENOENT;
  1693. } else {
  1694. *value1 = *value2 = i;
  1695. }
  1696. } while (isapnp_check_dma(cfg, *value1, idx));
  1697. return 0;
  1698. }
  1700. static int isapnp_check_mem(struct isapnp_cfgtmp *cfg, unsigned int addr, unsigned int size, int idx)
  1701. {
  1702. int i, tmp;
  1703. unsigned int raddr, rsize;
  1704. struct pnp_dev *dev;
  1705. struct isapnp_mem *xmem;
  1707. for (i = 0; i < 8; i++) {
  1708. raddr = (unsigned int)isapnp_reserve_mem[i << 1];
  1709. rsize = (unsigned int)isapnp_reserve_mem[(i << 1) + 1];
  1710. if (addr >= raddr && addr < raddr + rsize)
  1711. return 1;
  1712. if (addr + size > raddr && addr + size < (raddr + rsize) - 1)
  1713. return 1;
  1714. // if (__check_region(&iomem_resource, addr, size))
  1715. if (check_region(addr, size))
  1716. return 1;
  1717. }
  1718. for (dev = isapnp_devices; dev; dev = dev->next) {
  1719. if (dev->active) {
  1720. for (tmp = 0; tmp < 4; tmp++) {
  1721. if (dev->resource[tmp].flags) {
  1722. raddr = dev->resource[tmp + 8].start;
  1723. rsize = (dev->resource[tmp + 8].end - raddr) + 1;
  1724. if (addr >= raddr && addr < raddr + rsize)
  1725. return 1;
  1726. if (addr + size > raddr && addr + size < (raddr + rsize) - 1)
  1727. return 1;
  1728. }
  1729. }
  1730. }
  1731. }
  1732. for (i = 0; i < 4; i++) {
  1733. unsigned int flags = cfg->request->resource[i + 8].flags;
  1734. if (i == idx)
  1735. continue;
  1736. if (!flags)
  1737. continue;
  1738. tmp = cfg->result.resource[i + 8].start;
  1739. if (flags & IORESOURCE_AUTO) { /* auto */
  1740. xmem = cfg->mem[i];
  1741. if (!xmem)
  1742. return 1;
  1743. if (cfg->result.resource[i + 8].flags & IORESOURCE_AUTO)
  1744. continue;
  1745. if (tmp + xmem->size >= addr && tmp <= addr + xmem->size)
  1746. return 1;
  1747. continue;
  1748. }
  1749. if (addr == tmp)
  1750. return 1;
  1751. xmem = isapnp_find_mem(cfg->request, i);
  1752. if (!xmem)
  1753. return 1;
  1754. if (tmp + xmem->size >= addr && tmp <= addr + xmem->size)
  1755. return 1;
  1756. }
  1757. return 0;
  1758. }
  1760. static int isapnp_valid_mem(struct isapnp_cfgtmp *cfg, int idx)
  1761. {
  1762. int err;
  1763. unsigned long *value1, *value2;
  1764. struct isapnp_mem *mem;
  1766. if (!cfg || idx < 0 || idx > 3)
  1767. return -EINVAL;
  1768. if (!(cfg->result.resource[idx + 8].flags & IORESOURCE_AUTO)) /* don't touch */
  1769. return 0;
  1770.       __again:
  1771.        mem = cfg->mem[idx];
  1772.        if (!mem)
  1773.        return -EINVAL;
  1774.        value1 = &cfg->result.resource[idx].start;
  1775.        value2 = &cfg->result.resource[idx].end;
  1776. if (cfg->result.resource[idx + 8].flags & IORESOURCE_AUTO) {
  1777. cfg->result.resource[idx + 8].flags &= ~IORESOURCE_AUTO;
  1778. *value1 = mem->min;
  1779. *value2 = mem->min + mem->size - 1;
  1780. if (!isapnp_check_mem(cfg, *value1, mem->size, idx))
  1781. return 0;
  1782. }
  1783. do {
  1784. *value1 += mem->align;
  1785. *value2 = *value1 + mem->size - 1;
  1786. if (*value1 >= 8 || !mem->align) {
  1787. if (mem->res && mem->res->alt) {
  1788. if ((err = isapnp_alternative_switch(cfg, mem->res, mem->res->alt))<0)
  1789. return err;
  1790. goto __again;
  1791. }
  1792. return -ENOENT;
  1793. }
  1794. } while (isapnp_check_mem(cfg, *value1, mem->size, idx));
  1795. return 0;
  1796. }
  1798. static int isapnp_check_valid(struct isapnp_cfgtmp *cfg)
  1799. {
  1800. int tmp;
  1802. for (tmp = 0; tmp < 8; tmp++)
  1803. if (cfg->result.resource[tmp].flags & IORESOURCE_AUTO)
  1804. return -EAGAIN;
  1805. for (tmp = 0; tmp < 2; tmp++)
  1806. if (cfg->result.irq_resource[tmp].flags & IORESOURCE_AUTO)
  1807. return -EAGAIN;
  1808. for (tmp = 0; tmp < 2; tmp++)
  1809. if (cfg->result.dma_resource[tmp].flags & IORESOURCE_AUTO)
  1810. return -EAGAIN;
  1811. for (tmp = 0; tmp < 4; tmp++)
  1812. if (cfg->result.resource[tmp + 8].flags & IORESOURCE_AUTO)
  1813. return -EAGAIN;
  1814. return 0;
  1815. }
  1817. static int isapnp_config_activate(struct pnp_dev *dev)
  1818. {
  1819. struct isapnp_cfgtmp cfg;
  1820. int tmp, fauto, err;
  1822. if (!dev)
  1823. return -EINVAL;
  1824. if (dev->active)
  1825. return -EBUSY;
  1826. memset(&cfg, 0, sizeof(cfg));
  1827. cfg.request = dev;
  1828. memcpy(&cfg.result, dev, sizeof(struct pnp_dev));
  1829. /* check if all values are set, otherwise try auto-configuration */
  1830. for (tmp = fauto = 0; !fauto && tmp < 8; tmp++) {
  1831. if (dev->resource[tmp].flags & IORESOURCE_AUTO)
  1832. fauto++;
  1833. }
  1834. for (tmp = 0; !fauto && tmp < 2; tmp++) {
  1835. if (dev->irq_resource[tmp].flags & IORESOURCE_AUTO)
  1836. fauto++;
  1837. }
  1838. for (tmp = 0; !fauto && tmp < 2; tmp++) {
  1839. if (dev->dma_resource[tmp].flags & IORESOURCE_AUTO)
  1840. fauto++;
  1841. }
  1842. for (tmp = 0; !fauto && tmp < 4; tmp++) {
  1843. if (dev->resource[tmp + 8].flags & IORESOURCE_AUTO)
  1844. fauto++;
  1845. }
  1846. if (!fauto)
  1847. goto __skip_auto;
  1848. /* set variables to initial values */
  1849. if ((err = isapnp_alternative_switch(&cfg, NULL, NULL))<0)
  1850. return err;
  1851. /* find first valid configuration */
  1852. fauto = 0;
  1853. do {
  1854. for (tmp = 0; tmp < 8 && cfg.result.resource[tmp].flags; tmp++)
  1855. if ((err = isapnp_valid_port(&cfg, tmp))<0)
  1856. return err;
  1857. for (tmp = 0; tmp < 2 && cfg.result.irq_resource[tmp].flags; tmp++)
  1858. if ((err = isapnp_valid_irq(&cfg, tmp))<0)
  1859. return err;
  1860. for (tmp = 0; tmp < 2 && cfg.result.dma_resource[tmp].flags; tmp++)
  1861. if ((err = isapnp_valid_dma(&cfg, tmp))<0)
  1862. return err;
  1863. for (tmp = 0; tmp < 4 && cfg.result.resource[tmp + 8].flags; tmp++)
  1864. if ((err = isapnp_valid_mem(&cfg, tmp))<0)
  1865. return err;
  1866. } while (isapnp_check_valid(&cfg)<0 && fauto++ < 20);
  1867. if (fauto >= 20)
  1868. return -EAGAIN;
  1869.       __skip_auto:
  1870.        /* we have valid configuration, try configure hardware */
  1871.        isapnp_cfg_begin(dev->bus->number, dev->devfn);
  1872. dev->active = 1;
  1873. dev->irq_resource[0] = cfg.result.irq_resource[0];
  1874. dev->irq_resource[1] = cfg.result.irq_resource[1];
  1875. dev->dma_resource[0] = cfg.result.dma_resource[0];
  1876. dev->dma_resource[1] = cfg.result.dma_resource[1];
  1877. for (tmp = 0; tmp < 12; tmp++) {
  1878. dev->resource[tmp] = cfg.result.resource[tmp];
  1879. }
  1880. for (tmp = 0; tmp < 8 && dev->resource[tmp].flags; tmp++)
  1881. isapnp_write_word(ISAPNP_CFG_PORT+(tmp<<1), dev->resource[tmp].start);
  1882. for (tmp = 0; tmp < 2 && dev->irq_resource[tmp].flags; tmp++) {
  1883. int irq = dev->irq_resource[tmp].start;
  1884. if (irq == 2)
  1885. irq = 9;
  1886. isapnp_write_byte(ISAPNP_CFG_IRQ+(tmp<<1), irq);
  1887. }
  1888. for (tmp = 0; tmp < 2 && dev->dma_resource[tmp].flags; tmp++)
  1889. isapnp_write_byte(ISAPNP_CFG_DMA+tmp, dev->dma_resource[tmp].start);
  1890. for (tmp = 0; tmp < 4 && dev->resource[tmp+8].flags; tmp++)
  1891. isapnp_write_word(ISAPNP_CFG_MEM+(tmp<<2), (dev->resource[tmp + 8].start >> 8) & 0xffff);
  1892. isapnp_activate(dev->devfn);
  1893. isapnp_cfg_end();
  1894. return 0;
  1895. }
  1897. static int isapnp_config_deactivate(struct pnp_dev *dev)
  1898. {
  1899. if (!dev || !dev->active)
  1900. return -EINVAL;
  1901.        isapnp_cfg_begin(dev->bus->number, dev->devfn);
  1902. isapnp_deactivate(dev->devfn);
  1903. dev->active = 0;
  1904. isapnp_cfg_end();
  1905. return 0;
  1906. }
  1908. void isapnp_resource_change(struct resource *resource,
  1909.     unsigned long start,
  1910.     unsigned long size)
  1911. {
  1912. if (resource == NULL)
  1913. return;
  1914. resource->flags &= ~IORESOURCE_AUTO;
  1915. resource->start = start;
  1916. resource->end = start + size - 1;
  1917. }
  1919. /*
  1920.  *  Inititialization.
  1921.  */
  1923. #ifdef MODULE
  1925. static void isapnp_free_port(struct isapnp_port *port)
  1926. {
  1927. struct isapnp_port *next;
  1929. while (port) {
  1930. next = port->next;
  1931. kfree(port);
  1932. port = next;
  1933. }
  1934. }
  1936. static void isapnp_free_irq(struct isapnp_irq *irq)
  1937. {
  1938. struct isapnp_irq *next;
  1940. while (irq) {
  1941. next = irq->next;
  1942. kfree(irq);
  1943. irq = next;
  1944. }
  1945. }
  1947. static void isapnp_free_dma(struct isapnp_dma *dma)
  1948. {
  1949. struct isapnp_dma *next;
  1951. while (dma) {
  1952. next = dma->next;
  1953. kfree(dma);
  1954. dma = next;
  1955. }
  1956. }
  1958. static void isapnp_free_mem(struct isapnp_mem *mem)
  1959. {
  1960. struct isapnp_mem *next;
  1962. while (mem) {
  1963. next = mem->next;
  1964. kfree(mem);
  1965. mem = next;
  1966. }
  1967. }
  1969. static void isapnp_free_mem32(struct isapnp_mem32 *mem32)
  1970. {
  1971. struct isapnp_mem32 *next;
  1973. while (mem32) {
  1974. next = mem32->next;
  1975. kfree(mem32);
  1976. mem32 = next;
  1977. }
  1978. }
  1980. static void isapnp_free_resources(struct isapnp_resources *resources, int alt)
  1981. {
  1982. struct isapnp_resources *next;
  1984. while (resources) {
  1985. next = alt ? resources->alt : resources->next;
  1986. isapnp_free_port(resources->port);
  1987. isapnp_free_irq(resources->irq);
  1988. isapnp_free_dma(resources->dma);
  1989. isapnp_free_mem(resources->mem);
  1990. isapnp_free_mem32(resources->mem32);
  1991. if (!alt && resources->alt)
  1992. isapnp_free_resources(resources->alt, 1);
  1993. kfree(resources);
  1994. resources = next;
  1995. }
  1996. }
  1998. static void isapnp_free_device(struct pnp_dev *dev)
  1999. {
  2000. struct pnp_dev *next;
  2002. while (dev) {
  2003. next = dev->sibling;
  2004. isapnp_free_resources((struct isapnp_resources *)dev->sysdata, 0);
  2005. kfree(dev);
  2006. dev = next;
  2007. }
  2008. }
  2010. #endif /* MODULE */
  2012. static void isapnp_free_all_resources(void)
  2013. {
  2014. #ifdef MODULE
  2015. struct pnp_bus *card, *cardnext;
  2016. #endif
  2018. #ifdef ISAPNP_REGION_OK
  2019. // release_resource(pidxr_res);
  2020.         release_region(_PIDXR, 1);
  2021. #endif
  2022. // release_resource(pnpwrp_res);
  2023.         release_region(_PNPWRP, 1);
  2024. if (isapnp_rdp >= 0x203 && isapnp_rdp <= 0x3ff)
  2025. // release_resource(isapnp_rdp_res);
  2026. release_region(isapnp_rdp, 1);
  2027. #ifdef MODULE
  2028. for (card = isapnp_cards; card; card = cardnext) {
  2029. cardnext = card->next;
  2030. isapnp_free_device(card->devices);
  2031. kfree(card);
  2032. }
  2033. #ifdef CONFIG_PROC_FS
  2034. isapnp_proc_done();
  2035. #endif
  2036. #endif
  2037. }
  2039. static int __init isapnp_do_reserve_irq(int irq)
  2040. {
  2041. int i;
  2043. if (irq < 0 || irq > 15)
  2044. return -EINVAL;
  2045. for (i = 0; i < 16; i++) {
  2046. if (isapnp_reserve_irq[i] == irq)
  2047. return 0;
  2048. }
  2049. for (i = 0; i < 16; i++) {
  2050. if (isapnp_reserve_irq[i] < 0) {
  2051. isapnp_reserve_irq[i] = irq;
  2052. #ifdef ISAPNP_DEBUG
  2053. printk("IRQ %i is reserved now.n", irq);
  2054. #endif
  2055. return 0;
  2056. }
  2057. }
  2058. return -ENOMEM;
  2059. }
  2061. #ifdef CONFIG_PCI
  2063. struct pnp_dev *
  2064. pnp_find_slot(unsigned int bus, unsigned int devfn)
  2065. {
  2066.         struct pnp_dev *dev;
  2068.         for(dev=isapnp_devices; dev; dev=dev->next)
  2069.                 if (dev->bus->number == bus && dev->devfn == devfn)
  2070.                         break;
  2071.         return dev;
  2072. }
  2074. static void __init isapnp_pci_init(void)
  2075. {
  2076. int devfn;
  2077. struct pnp_dev *dev;
  2079. for (devfn = 0; devfn < 255; devfn++) {
  2080. dev = pnp_find_slot(0, devfn);
  2081. if (dev != NULL)
  2082. break;
  2083. }
  2084. if (dev == NULL)
  2085. return;
  2086. while (dev) {
  2087. #ifdef ISAPNP_DEBUG
  2088. printk("PCI: reserved IRQ: %in", dev->irq);
  2089. #endif
  2090. if (dev->irq > 0)
  2091. isapnp_do_reserve_irq(dev->irq);
  2092. dev = dev->next;
  2093. }
  2094. }
  2096. #endif /* CONFIG_PCI */
  2098. EXPORT_SYMBOL(isapnp_present);
  2099. EXPORT_SYMBOL(isapnp_cfg_begin);
  2100. EXPORT_SYMBOL(isapnp_cfg_end);
  2101. EXPORT_SYMBOL(isapnp_read_byte);
  2102. EXPORT_SYMBOL(isapnp_read_word);
  2103. EXPORT_SYMBOL(isapnp_read_dword);
  2104. EXPORT_SYMBOL(isapnp_write_byte);
  2105. EXPORT_SYMBOL(isapnp_write_word);
  2106. EXPORT_SYMBOL(isapnp_write_dword);
  2107. EXPORT_SYMBOL(isapnp_wake);
  2108. EXPORT_SYMBOL(isapnp_device);
  2109. EXPORT_SYMBOL(isapnp_activate);
  2110. EXPORT_SYMBOL(isapnp_deactivate);
  2111. EXPORT_SYMBOL(isapnp_find_card);
  2112. EXPORT_SYMBOL(isapnp_find_dev);
  2113. EXPORT_SYMBOL(isapnp_resource_change);
  2115. int __init isapnp_init(void)
  2116. {
  2117. int cards;
  2118. struct pnp_bus *card;
  2119. struct pnp_dev *dev;
  2121. if (isapnp_disable) {
  2122. isapnp_detected = 0;
  2123. printk("isapnp: ISA Plug & Play support disabledn");
  2124. return 0;
  2125. }
  2126. #ifdef ISAPNP_REGION_OK
  2127. request_region(_PIDXR, 1, "isapnp index");
  2128. // pidxr_res=request_region(_PIDXR, 1, "isapnp index");
  2129. // if(!pidxr_res) {
  2130. // printk("isapnp: Index Register 0x%x already usedn", _PIDXR);
  2131. // return -EBUSY;
  2132. // }
  2133. #endif
  2134. request_region(_PNPWRP, 1, "isapnp write");
  2135. // pnpwrp_res=request_region(_PNPWRP, 1, "isapnp write");
  2136. // if(!pnpwrp_res) {
  2137. // printk("isapnp: Write Data Register 0x%x already usedn", _PNPWRP);
  2138. // return -EBUSY;
  2139. // }
  2141. /*
  2142.  * Print a message. The existing ISAPnP code is hanging machines
  2143.  * so let the user know where.
  2144.  */
  2145.  
  2146. printk("isapnp: Scanning for Pnp cards...n");
  2147. if (isapnp_rdp >= 0x203 && isapnp_rdp <= 0x3ff) {
  2148. isapnp_rdp |= 3;
  2149. request_region(isapnp_rdp, 1, "isapnp read");
  2150. // isapnp_rdp_res=request_region(isapnp_rdp, 1, "isapnp read");
  2151. // if(!isapnp_rdp_res) {
  2152. // printk("isapnp: Read Data Register 0x%x already usedn", isapnp_rdp);
  2153. // return -EBUSY;
  2154. // }
  2155. isapnp_set_rdp();
  2156. }
  2157. isapnp_detected = 1;
  2158. if (isapnp_rdp < 0x203 || isapnp_rdp > 0x3ff) {
  2159. cards = isapnp_isolate();
  2160. if (cards < 0 || 
  2161.     (isapnp_rdp < 0x203 || isapnp_rdp > 0x3ff)) {
  2162. isapnp_free_all_resources();
  2163. isapnp_detected = 0;
  2164. printk("isapnp: No Plug & Play device foundn");
  2165. return 0;
  2166. }
  2167. request_region(isapnp_rdp, 1, "isapnp read");
  2168. // isapnp_rdp_res=request_region(isapnp_rdp, 1, "isapnp read");
  2169. }
  2170. isapnp_build_device_list();
  2171. cards = 0;
  2172. for (card = isapnp_cards; card; card = card->next)
  2173. cards++;
  2174. if (isapnp_verbose) {
  2175. for (card = isapnp_cards; card; card = card->next) {
  2176. printk( "isapnp: Card '%s'n", card->name[0]?card->name:"Unknown");
  2177. if (isapnp_verbose < 2)
  2178. continue;
  2179. for (dev = card->devices; dev; dev = dev->next)
  2180. printk("isapnp:   Device '%s'n", dev->name[0]?card->name:"Unknown");
  2181. }
  2182. }
  2183. if (cards) {
  2184. printk("isapnp: %i Plug & Play card%s detected totaln", cards, cards>1?"s":"");
  2185. } else {
  2186. printk("isapnp: No Plug & Play card foundn");
  2187. }
  2188. #ifdef CONFIG_PCI
  2189. if (!isapnp_skip_pci_scan)
  2190. isapnp_pci_init();
  2191. #endif
  2192. #ifdef CONFIG_PROC_FS
  2193. isapnp_proc_init();
  2194. #endif
  2195. return 0;
  2196. }
  2198. #ifdef MODULE
  2200. int init_module(void)
  2201. {
  2202. return isapnp_init();
  2203. }
  2205. void cleanup_module(void)
  2206. {
  2207. if (isapnp_detected)
  2208. isapnp_free_all_resources();
  2209. }
  2211. #endif