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

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