2 * ISA Plug & Play support
3 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 * 2000-01-01 Added quirks handling for buggy hardware
22 * Peter Denison <peterd@pnd-pc.demon.co.uk>
23 * 2000-06-14 Added isapnp_probe_devs() and isapnp_activate_dev()
24 * Christoph Hellwig <hch@infradead.org>
25 * 2001-06-03 Added release_region calls to correspond with
26 * request_region calls when a failure occurs. Also
27 * added KERN_* constants to printk() calls.
28 * 2001-11-07 Added isapnp_{,un}register_driver calls along the lines
29 * of the pci driver interface
30 * Kai Germaschewski <kai.germaschewski@gmx.de>
31 * 2002-06-06 Made the use of dma channel 0 configurable
32 * Gerald Teschl <gerald.teschl@univie.ac.at>
33 * 2002-10-06 Ported to PnP Layer - Adam Belay <ambx1@neo.rr.com>
34 * 2003-08-11 Resource Management Updates - Adam Belay <ambx1@neo.rr.com>
37 #include <linux/module.h>
38 #include <linux/kernel.h>
39 #include <linux/errno.h>
40 #include <linux/slab.h>
41 #include <linux/delay.h>
42 #include <linux/init.h>
43 #include <linux/isapnp.h>
44 #include <linux/mutex.h>
50 #define ISAPNP_REGION_OK
53 int isapnp_disable
; /* Disable ISA PnP */
54 static int isapnp_rdp
; /* Read Data Port */
55 static int isapnp_reset
= 1; /* reset all PnP cards (deactivate) */
56 static int isapnp_verbose
= 1; /* verbose mode */
58 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
59 MODULE_DESCRIPTION("Generic ISA Plug & Play support");
60 module_param(isapnp_disable
, int, 0);
61 MODULE_PARM_DESC(isapnp_disable
, "ISA Plug & Play disable");
62 module_param(isapnp_rdp
, int, 0);
63 MODULE_PARM_DESC(isapnp_rdp
, "ISA Plug & Play read data port");
64 module_param(isapnp_reset
, int, 0);
65 MODULE_PARM_DESC(isapnp_reset
, "ISA Plug & Play reset all cards");
66 module_param(isapnp_verbose
, int, 0);
67 MODULE_PARM_DESC(isapnp_verbose
, "ISA Plug & Play verbose mode");
68 MODULE_LICENSE("GPL");
74 #define _STAG_PNPVERNO 0x01
75 #define _STAG_LOGDEVID 0x02
76 #define _STAG_COMPATDEVID 0x03
77 #define _STAG_IRQ 0x04
78 #define _STAG_DMA 0x05
79 #define _STAG_STARTDEP 0x06
80 #define _STAG_ENDDEP 0x07
81 #define _STAG_IOPORT 0x08
82 #define _STAG_FIXEDIO 0x09
83 #define _STAG_VENDOR 0x0e
84 #define _STAG_END 0x0f
86 #define _LTAG_MEMRANGE 0x81
87 #define _LTAG_ANSISTR 0x82
88 #define _LTAG_UNICODESTR 0x83
89 #define _LTAG_VENDOR 0x84
90 #define _LTAG_MEM32RANGE 0x85
91 #define _LTAG_FIXEDMEM32RANGE 0x86
93 /* Logical device control and configuration registers */
95 #define ISAPNP_CFG_ACTIVATE 0x30 /* byte */
96 #define ISAPNP_CFG_MEM 0x40 /* 4 * dword */
97 #define ISAPNP_CFG_PORT 0x60 /* 8 * word */
98 #define ISAPNP_CFG_IRQ 0x70 /* 2 * word */
99 #define ISAPNP_CFG_DMA 0x74 /* 2 * byte */
102 * Sizes of ISAPNP logical device configuration register sets.
103 * See PNP-ISA-v1.0a.pdf, Appendix A.
105 #define ISAPNP_MAX_MEM 4
106 #define ISAPNP_MAX_PORT 8
107 #define ISAPNP_MAX_IRQ 2
108 #define ISAPNP_MAX_DMA 2
110 static unsigned char isapnp_checksum_value
;
111 static DEFINE_MUTEX(isapnp_cfg_mutex
);
112 static int isapnp_csn_count
;
114 /* some prototypes */
116 static inline void write_data(unsigned char x
)
121 static inline void write_address(unsigned char x
)
127 static inline unsigned char read_data(void)
129 unsigned char val
= inb(isapnp_rdp
);
133 unsigned char isapnp_read_byte(unsigned char idx
)
139 static unsigned short isapnp_read_word(unsigned char idx
)
143 val
= isapnp_read_byte(idx
);
144 val
= (val
<< 8) + isapnp_read_byte(idx
+ 1);
148 void isapnp_write_byte(unsigned char idx
, unsigned char val
)
154 static void isapnp_write_word(unsigned char idx
, unsigned short val
)
156 isapnp_write_byte(idx
, val
>> 8);
157 isapnp_write_byte(idx
+ 1, val
);
160 static void isapnp_key(void)
162 unsigned char code
= 0x6a, msb
;
171 for (i
= 1; i
< 32; i
++) {
172 msb
= ((code
& 0x01) ^ ((code
& 0x02) >> 1)) << 7;
173 code
= (code
>> 1) | msb
;
178 /* place all pnp cards in wait-for-key state */
179 static void isapnp_wait(void)
181 isapnp_write_byte(0x02, 0x02);
184 static void isapnp_wake(unsigned char csn
)
186 isapnp_write_byte(0x03, csn
);
189 static void isapnp_device(unsigned char logdev
)
191 isapnp_write_byte(0x07, logdev
);
194 static void isapnp_activate(unsigned char logdev
)
196 isapnp_device(logdev
);
197 isapnp_write_byte(ISAPNP_CFG_ACTIVATE
, 1);
201 static void isapnp_deactivate(unsigned char logdev
)
203 isapnp_device(logdev
);
204 isapnp_write_byte(ISAPNP_CFG_ACTIVATE
, 0);
208 static void __init
isapnp_peek(unsigned char *data
, int bytes
)
213 for (i
= 1; i
<= bytes
; i
++) {
214 for (j
= 0; j
< 20; j
++) {
215 d
= isapnp_read_byte(0x05);
225 d
= isapnp_read_byte(0x04); /* PRESDI */
226 isapnp_checksum_value
+= d
;
232 #define RDP_STEP 32 /* minimum is 4 */
234 static int isapnp_next_rdp(void)
236 int rdp
= isapnp_rdp
;
237 static int old_rdp
= 0;
240 release_region(old_rdp
, 1);
243 while (rdp
<= 0x3ff) {
245 * We cannot use NE2000 probe spaces for ISAPnP or we
246 * will lock up machines.
248 if ((rdp
< 0x280 || rdp
> 0x380)
249 && request_region(rdp
, 1, "ISAPnP")) {
259 /* Set read port address */
260 static inline void isapnp_set_rdp(void)
262 isapnp_write_byte(0x00, isapnp_rdp
>> 2);
267 * Perform an isolation. The port selection code now tries to avoid
268 * "dangerous to read" ports.
270 static int __init
isapnp_isolate_rdp_select(void)
275 /* Control: reset CSN and conditionally everything else too */
276 isapnp_write_byte(0x02, isapnp_reset
? 0x05 : 0x04);
283 if (isapnp_next_rdp() < 0) {
296 * Isolate (assign uniqued CSN) to all ISA PnP devices.
298 static int __init
isapnp_isolate(void)
300 unsigned char checksum
= 0x6a;
301 unsigned char chksum
= 0x00;
302 unsigned char bit
= 0x00;
309 if (isapnp_isolate_rdp_select() < 0)
313 for (i
= 1; i
<= 64; i
++) {
314 data
= read_data() << 8;
316 data
= data
| read_data();
321 ((((checksum
^ (checksum
>> 1)) & 0x01) ^ bit
) << 7)
325 for (i
= 65; i
<= 72; i
++) {
326 data
= read_data() << 8;
328 data
= data
| read_data();
331 chksum
|= (1 << (i
- 65));
333 if (checksum
!= 0x00 && checksum
== chksum
) {
336 isapnp_write_byte(0x06, csn
);
346 if (iteration
== 1) {
347 isapnp_rdp
+= RDP_STEP
;
348 if (isapnp_isolate_rdp_select() < 0)
350 } else if (iteration
> 1) {
361 isapnp_csn_count
= csn
;
366 * Read one tag from stream.
368 static int __init
isapnp_read_tag(unsigned char *type
, unsigned short *size
)
370 unsigned char tag
, tmp
[2];
372 isapnp_peek(&tag
, 1);
373 if (tag
== 0) /* invalid tag */
375 if (tag
& 0x80) { /* large item */
378 *size
= (tmp
[1] << 8) | tmp
[0];
380 *type
= (tag
>> 3) & 0x0f;
384 printk(KERN_DEBUG
"tag = 0x%x, type = 0x%x, size = %i\n", tag
, *type
,
387 if (*type
== 0xff && *size
== 0xffff) /* probably invalid data */
393 * Skip specified number of bytes from stream.
395 static void __init
isapnp_skip_bytes(int count
)
397 isapnp_peek(NULL
, count
);
401 * Parse logical device tag.
403 static struct pnp_dev
*__init
isapnp_parse_device(struct pnp_card
*card
,
404 int size
, int number
)
406 unsigned char tmp
[6];
411 isapnp_peek(tmp
, size
);
412 eisa_id
= tmp
[0] | tmp
[1] << 8 | tmp
[2] << 16 | tmp
[3] << 24;
413 pnp_eisa_id_to_string(eisa_id
, id
);
415 dev
= pnp_alloc_dev(&isapnp_protocol
, number
, id
);
422 dev
->regs
|= tmp
[5] << 8;
423 dev
->capabilities
|= PNP_CONFIGURABLE
;
424 dev
->capabilities
|= PNP_READ
;
425 dev
->capabilities
|= PNP_WRITE
;
426 dev
->capabilities
|= PNP_DISABLE
;
427 pnp_init_resource_table(&dev
->res
);
432 * Add IRQ resource to resources list.
434 static void __init
isapnp_parse_irq_resource(struct pnp_option
*option
,
437 unsigned char tmp
[3];
441 isapnp_peek(tmp
, size
);
442 irq
= kzalloc(sizeof(struct pnp_irq
), GFP_KERNEL
);
445 bits
= (tmp
[1] << 8) | tmp
[0];
446 bitmap_copy(irq
->map
, &bits
, 16);
450 irq
->flags
= IORESOURCE_IRQ_HIGHEDGE
;
451 pnp_register_irq_resource(option
, irq
);
455 * Add DMA resource to resources list.
457 static void __init
isapnp_parse_dma_resource(struct pnp_option
*option
,
460 unsigned char tmp
[2];
463 isapnp_peek(tmp
, size
);
464 dma
= kzalloc(sizeof(struct pnp_dma
), GFP_KERNEL
);
469 pnp_register_dma_resource(option
, dma
);
473 * Add port resource to resources list.
475 static void __init
isapnp_parse_port_resource(struct pnp_option
*option
,
478 unsigned char tmp
[7];
479 struct pnp_port
*port
;
481 isapnp_peek(tmp
, size
);
482 port
= kzalloc(sizeof(struct pnp_port
), GFP_KERNEL
);
485 port
->min
= (tmp
[2] << 8) | tmp
[1];
486 port
->max
= (tmp
[4] << 8) | tmp
[3];
487 port
->align
= tmp
[5];
489 port
->flags
= tmp
[0] ? PNP_PORT_FLAG_16BITADDR
: 0;
490 pnp_register_port_resource(option
, port
);
494 * Add fixed port resource to resources list.
496 static void __init
isapnp_parse_fixed_port_resource(struct pnp_option
*option
,
499 unsigned char tmp
[3];
500 struct pnp_port
*port
;
502 isapnp_peek(tmp
, size
);
503 port
= kzalloc(sizeof(struct pnp_port
), GFP_KERNEL
);
506 port
->min
= port
->max
= (tmp
[1] << 8) | tmp
[0];
509 port
->flags
= PNP_PORT_FLAG_FIXED
;
510 pnp_register_port_resource(option
, port
);
514 * Add memory resource to resources list.
516 static void __init
isapnp_parse_mem_resource(struct pnp_option
*option
,
519 unsigned char tmp
[9];
522 isapnp_peek(tmp
, size
);
523 mem
= kzalloc(sizeof(struct pnp_mem
), GFP_KERNEL
);
526 mem
->min
= ((tmp
[2] << 8) | tmp
[1]) << 8;
527 mem
->max
= ((tmp
[4] << 8) | tmp
[3]) << 8;
528 mem
->align
= (tmp
[6] << 8) | tmp
[5];
529 mem
->size
= ((tmp
[8] << 8) | tmp
[7]) << 8;
531 pnp_register_mem_resource(option
, mem
);
535 * Add 32-bit memory resource to resources list.
537 static void __init
isapnp_parse_mem32_resource(struct pnp_option
*option
,
540 unsigned char tmp
[17];
543 isapnp_peek(tmp
, size
);
544 mem
= kzalloc(sizeof(struct pnp_mem
), GFP_KERNEL
);
547 mem
->min
= (tmp
[4] << 24) | (tmp
[3] << 16) | (tmp
[2] << 8) | tmp
[1];
548 mem
->max
= (tmp
[8] << 24) | (tmp
[7] << 16) | (tmp
[6] << 8) | tmp
[5];
550 (tmp
[12] << 24) | (tmp
[11] << 16) | (tmp
[10] << 8) | tmp
[9];
552 (tmp
[16] << 24) | (tmp
[15] << 16) | (tmp
[14] << 8) | tmp
[13];
554 pnp_register_mem_resource(option
, mem
);
558 * Add 32-bit fixed memory resource to resources list.
560 static void __init
isapnp_parse_fixed_mem32_resource(struct pnp_option
*option
,
563 unsigned char tmp
[9];
566 isapnp_peek(tmp
, size
);
567 mem
= kzalloc(sizeof(struct pnp_mem
), GFP_KERNEL
);
570 mem
->min
= mem
->max
=
571 (tmp
[4] << 24) | (tmp
[3] << 16) | (tmp
[2] << 8) | tmp
[1];
572 mem
->size
= (tmp
[8] << 24) | (tmp
[7] << 16) | (tmp
[6] << 8) | tmp
[5];
575 pnp_register_mem_resource(option
, mem
);
579 * Parse card name for ISA PnP device.
582 isapnp_parse_name(char *name
, unsigned int name_max
, unsigned short *size
)
584 if (name
[0] == '\0') {
585 unsigned short size1
=
586 *size
>= name_max
? (name_max
- 1) : *size
;
587 isapnp_peek(name
, size1
);
591 /* clean whitespace from end of string */
592 while (size1
> 0 && name
[--size1
] == ' ')
598 * Parse resource map for logical device.
600 static int __init
isapnp_create_device(struct pnp_card
*card
,
603 int number
= 0, skip
= 0, priority
= 0, compat
= 0;
604 unsigned char type
, tmp
[17];
605 struct pnp_option
*option
;
610 if ((dev
= isapnp_parse_device(card
, size
, number
++)) == NULL
)
612 option
= pnp_register_independent_option(dev
);
617 pnp_add_card_device(card
, dev
);
620 if (isapnp_read_tag(&type
, &size
) < 0)
622 if (skip
&& type
!= _STAG_LOGDEVID
&& type
!= _STAG_END
)
626 if (size
>= 5 && size
<= 6) {
628 isapnp_parse_device(card
, size
,
633 option
= pnp_register_independent_option(dev
);
638 pnp_add_card_device(card
, dev
);
645 case _STAG_COMPATDEVID
:
646 if (size
== 4 && compat
< DEVICE_COUNT_COMPATIBLE
) {
648 eisa_id
= tmp
[0] | tmp
[1] << 8 |
649 tmp
[2] << 16 | tmp
[3] << 24;
650 pnp_eisa_id_to_string(eisa_id
, id
);
657 if (size
< 2 || size
> 3)
659 isapnp_parse_irq_resource(option
, size
);
665 isapnp_parse_dma_resource(option
, size
);
671 priority
= 0x100 | PNP_RES_PRIORITY_ACCEPTABLE
;
673 isapnp_peek(tmp
, size
);
674 priority
= 0x100 | tmp
[0];
677 option
= pnp_register_dependent_option(dev
, priority
);
689 isapnp_parse_port_resource(option
, size
);
695 isapnp_parse_fixed_port_resource(option
, size
);
703 isapnp_parse_mem_resource(option
, size
);
707 isapnp_parse_name(dev
->name
, sizeof(dev
->name
), &size
);
709 case _LTAG_UNICODESTR
:
710 /* silently ignore */
711 /* who use unicode for hardware identification? */
715 case _LTAG_MEM32RANGE
:
718 isapnp_parse_mem32_resource(option
, size
);
721 case _LTAG_FIXEDMEM32RANGE
:
724 isapnp_parse_fixed_mem32_resource(option
, size
);
729 isapnp_skip_bytes(size
);
733 "isapnp: unexpected or unknown tag type 0x%x for logical device %i (device %i), ignored\n",
734 type
, dev
->number
, card
->number
);
738 isapnp_skip_bytes(size
);
744 * Parse resource map for ISA PnP card.
746 static void __init
isapnp_parse_resource_map(struct pnp_card
*card
)
748 unsigned char type
, tmp
[17];
752 if (isapnp_read_tag(&type
, &size
) < 0)
759 card
->pnpver
= tmp
[0];
760 card
->productver
= tmp
[1];
764 if (size
>= 5 && size
<= 6) {
765 if (isapnp_create_device(card
, size
) == 1)
773 isapnp_parse_name(card
->name
, sizeof(card
->name
),
776 case _LTAG_UNICODESTR
:
777 /* silently ignore */
778 /* who use unicode for hardware identification? */
784 isapnp_skip_bytes(size
);
788 "isapnp: unexpected or unknown tag type 0x%x for device %i, ignored\n",
793 isapnp_skip_bytes(size
);
798 * Compute ISA PnP checksum for first eight bytes.
800 static unsigned char __init
isapnp_checksum(unsigned char *data
)
803 unsigned char checksum
= 0x6a, bit
, b
;
805 for (i
= 0; i
< 8; i
++) {
807 for (j
= 0; j
< 8; j
++) {
812 ((((checksum
^ (checksum
>> 1)) & 0x01) ^ bit
) << 7)
820 * Build device list for all present ISA PnP devices.
822 static int __init
isapnp_build_device_list(void)
825 unsigned char header
[9], checksum
;
826 struct pnp_card
*card
;
832 for (csn
= 1; csn
<= isapnp_csn_count
; csn
++) {
834 isapnp_peek(header
, 9);
835 checksum
= isapnp_checksum(header
);
838 "vendor: %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
839 header
[0], header
[1], header
[2], header
[3], header
[4],
840 header
[5], header
[6], header
[7], header
[8]);
841 printk(KERN_DEBUG
"checksum = 0x%x\n", checksum
);
843 eisa_id
= header
[0] | header
[1] << 8 |
844 header
[2] << 16 | header
[3] << 24;
845 pnp_eisa_id_to_string(eisa_id
, id
);
846 card
= pnp_alloc_card(&isapnp_protocol
, csn
, id
);
850 INIT_LIST_HEAD(&card
->devices
);
852 (header
[7] << 24) | (header
[6] << 16) | (header
[5] << 8) |
854 isapnp_checksum_value
= 0x00;
855 isapnp_parse_resource_map(card
);
856 if (isapnp_checksum_value
!= 0x00)
858 "isapnp: checksum for device %i is not valid (0x%x)\n",
859 csn
, isapnp_checksum_value
);
860 card
->checksum
= isapnp_checksum_value
;
869 * Basic configuration routines.
872 int isapnp_present(void)
874 struct pnp_card
*card
;
876 pnp_for_each_card(card
) {
877 if (card
->protocol
== &isapnp_protocol
)
883 int isapnp_cfg_begin(int csn
, int logdev
)
885 if (csn
< 1 || csn
> isapnp_csn_count
|| logdev
> 10)
887 mutex_lock(&isapnp_cfg_mutex
);
892 /* to avoid malfunction when the isapnptools package is used */
893 /* we must set RDP to our value again */
894 /* it is possible to set RDP only in the isolation phase */
895 /* Jens Thoms Toerring <Jens.Toerring@physik.fu-berlin.de> */
896 isapnp_write_byte(0x02, 0x04); /* clear CSN of card */
897 mdelay(2); /* is this necessary? */
898 isapnp_wake(csn
); /* bring card into sleep state */
899 isapnp_wake(0); /* bring card into isolation state */
900 isapnp_set_rdp(); /* reset the RDP port */
901 udelay(1000); /* delay 1000us */
902 isapnp_write_byte(0x06, csn
); /* reset CSN to previous value */
903 udelay(250); /* is this necessary? */
906 isapnp_device(logdev
);
910 int isapnp_cfg_end(void)
913 mutex_unlock(&isapnp_cfg_mutex
);
921 EXPORT_SYMBOL(isapnp_protocol
);
922 EXPORT_SYMBOL(isapnp_present
);
923 EXPORT_SYMBOL(isapnp_cfg_begin
);
924 EXPORT_SYMBOL(isapnp_cfg_end
);
925 EXPORT_SYMBOL(isapnp_write_byte
);
927 static int isapnp_read_resources(struct pnp_dev
*dev
,
928 struct pnp_resource_table
*res
)
932 dev
->active
= isapnp_read_byte(ISAPNP_CFG_ACTIVATE
);
934 for (tmp
= 0; tmp
< ISAPNP_MAX_PORT
; tmp
++) {
935 ret
= isapnp_read_word(ISAPNP_CFG_PORT
+ (tmp
<< 1));
938 res
->port_resource
[tmp
].start
= ret
;
939 res
->port_resource
[tmp
].flags
= IORESOURCE_IO
;
941 for (tmp
= 0; tmp
< ISAPNP_MAX_MEM
; tmp
++) {
943 isapnp_read_word(ISAPNP_CFG_MEM
+ (tmp
<< 3)) << 8;
946 res
->mem_resource
[tmp
].start
= ret
;
947 res
->mem_resource
[tmp
].flags
= IORESOURCE_MEM
;
949 for (tmp
= 0; tmp
< ISAPNP_MAX_IRQ
; tmp
++) {
951 (isapnp_read_word(ISAPNP_CFG_IRQ
+ (tmp
<< 1)) >>
955 res
->irq_resource
[tmp
].start
=
956 res
->irq_resource
[tmp
].end
= ret
;
957 res
->irq_resource
[tmp
].flags
= IORESOURCE_IRQ
;
959 for (tmp
= 0; tmp
< ISAPNP_MAX_DMA
; tmp
++) {
960 ret
= isapnp_read_byte(ISAPNP_CFG_DMA
+ tmp
);
963 res
->dma_resource
[tmp
].start
=
964 res
->dma_resource
[tmp
].end
= ret
;
965 res
->dma_resource
[tmp
].flags
= IORESOURCE_DMA
;
971 static int isapnp_get_resources(struct pnp_dev
*dev
,
972 struct pnp_resource_table
*res
)
976 pnp_init_resource_table(res
);
977 isapnp_cfg_begin(dev
->card
->number
, dev
->number
);
978 ret
= isapnp_read_resources(dev
, res
);
983 static int isapnp_set_resources(struct pnp_dev
*dev
,
984 struct pnp_resource_table
*res
)
988 isapnp_cfg_begin(dev
->card
->number
, dev
->number
);
991 tmp
< ISAPNP_MAX_PORT
992 && (res
->port_resource
[tmp
].
993 flags
& (IORESOURCE_IO
| IORESOURCE_UNSET
)) == IORESOURCE_IO
;
995 isapnp_write_word(ISAPNP_CFG_PORT
+ (tmp
<< 1),
996 res
->port_resource
[tmp
].start
);
999 && (res
->irq_resource
[tmp
].
1000 flags
& (IORESOURCE_IRQ
| IORESOURCE_UNSET
)) == IORESOURCE_IRQ
;
1002 int irq
= res
->irq_resource
[tmp
].start
;
1005 isapnp_write_byte(ISAPNP_CFG_IRQ
+ (tmp
<< 1), irq
);
1008 tmp
< ISAPNP_MAX_DMA
1009 && (res
->dma_resource
[tmp
].
1010 flags
& (IORESOURCE_DMA
| IORESOURCE_UNSET
)) == IORESOURCE_DMA
;
1012 isapnp_write_byte(ISAPNP_CFG_DMA
+ tmp
,
1013 res
->dma_resource
[tmp
].start
);
1015 tmp
< ISAPNP_MAX_MEM
1016 && (res
->mem_resource
[tmp
].
1017 flags
& (IORESOURCE_MEM
| IORESOURCE_UNSET
)) == IORESOURCE_MEM
;
1019 isapnp_write_word(ISAPNP_CFG_MEM
+ (tmp
<< 3),
1020 (res
->mem_resource
[tmp
].start
>> 8) & 0xffff);
1021 /* FIXME: We aren't handling 32bit mems properly here */
1022 isapnp_activate(dev
->number
);
1027 static int isapnp_disable_resources(struct pnp_dev
*dev
)
1031 isapnp_cfg_begin(dev
->card
->number
, dev
->number
);
1032 isapnp_deactivate(dev
->number
);
1038 struct pnp_protocol isapnp_protocol
= {
1039 .name
= "ISA Plug and Play",
1040 .get
= isapnp_get_resources
,
1041 .set
= isapnp_set_resources
,
1042 .disable
= isapnp_disable_resources
,
1045 static int __init
isapnp_init(void)
1048 struct pnp_card
*card
;
1049 struct pnp_dev
*dev
;
1051 if (isapnp_disable
) {
1052 printk(KERN_INFO
"isapnp: ISA Plug & Play support disabled\n");
1055 #ifdef CONFIG_PPC_MERGE
1056 if (check_legacy_ioport(_PIDXR
) || check_legacy_ioport(_PNPWRP
))
1059 #ifdef ISAPNP_REGION_OK
1060 if (!request_region(_PIDXR
, 1, "isapnp index")) {
1061 printk(KERN_ERR
"isapnp: Index Register 0x%x already used\n",
1066 if (!request_region(_PNPWRP
, 1, "isapnp write")) {
1068 "isapnp: Write Data Register 0x%x already used\n",
1070 #ifdef ISAPNP_REGION_OK
1071 release_region(_PIDXR
, 1);
1076 if (pnp_register_protocol(&isapnp_protocol
) < 0)
1080 * Print a message. The existing ISAPnP code is hanging machines
1081 * so let the user know where.
1084 printk(KERN_INFO
"isapnp: Scanning for PnP cards...\n");
1085 if (isapnp_rdp
>= 0x203 && isapnp_rdp
<= 0x3ff) {
1087 if (!request_region(isapnp_rdp
, 1, "isapnp read")) {
1089 "isapnp: Read Data Register 0x%x already used\n",
1091 #ifdef ISAPNP_REGION_OK
1092 release_region(_PIDXR
, 1);
1094 release_region(_PNPWRP
, 1);
1099 if (isapnp_rdp
< 0x203 || isapnp_rdp
> 0x3ff) {
1100 cards
= isapnp_isolate();
1101 if (cards
< 0 || (isapnp_rdp
< 0x203 || isapnp_rdp
> 0x3ff)) {
1102 #ifdef ISAPNP_REGION_OK
1103 release_region(_PIDXR
, 1);
1105 release_region(_PNPWRP
, 1);
1107 "isapnp: No Plug & Play device found\n");
1110 request_region(isapnp_rdp
, 1, "isapnp read");
1112 isapnp_build_device_list();
1115 protocol_for_each_card(&isapnp_protocol
, card
) {
1117 if (isapnp_verbose
) {
1118 printk(KERN_INFO
"isapnp: Card '%s'\n",
1119 card
->name
[0] ? card
->name
: "Unknown");
1120 if (isapnp_verbose
< 2)
1122 card_for_each_dev(card
, dev
) {
1123 printk(KERN_INFO
"isapnp: Device '%s'\n",
1124 dev
->name
[0] ? dev
->name
: "Unknown");
1130 "isapnp: %i Plug & Play card%s detected total\n", cards
,
1131 cards
> 1 ? "s" : "");
1133 printk(KERN_INFO
"isapnp: No Plug & Play card found\n");
1139 device_initcall(isapnp_init
);
1141 /* format is: noisapnp */
1143 static int __init
isapnp_setup_disable(char *str
)
1149 __setup("noisapnp", isapnp_setup_disable
);
1151 /* format is: isapnp=rdp,reset,skip_pci_scan,verbose */
1153 static int __init
isapnp_setup_isapnp(char *str
)
1155 (void)((get_option(&str
, &isapnp_rdp
) == 2) &&
1156 (get_option(&str
, &isapnp_reset
) == 2) &&
1157 (get_option(&str
, &isapnp_verbose
) == 2));
1161 __setup("isapnp=", isapnp_setup_isapnp
);