1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * ISA Plug & Play support
4 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
7 * 2000-01-01 Added quirks handling for buggy hardware
8 * Peter Denison <peterd@pnd-pc.demon.co.uk>
9 * 2000-06-14 Added isapnp_probe_devs() and isapnp_activate_dev()
10 * Christoph Hellwig <hch@infradead.org>
11 * 2001-06-03 Added release_region calls to correspond with
12 * request_region calls when a failure occurs. Also
13 * added KERN_* constants to printk() calls.
14 * 2001-11-07 Added isapnp_{,un}register_driver calls along the lines
15 * of the pci driver interface
16 * Kai Germaschewski <kai.germaschewski@gmx.de>
17 * 2002-06-06 Made the use of dma channel 0 configurable
18 * Gerald Teschl <gerald.teschl@univie.ac.at>
19 * 2002-10-06 Ported to PnP Layer - Adam Belay <ambx1@neo.rr.com>
20 * 2003-08-11 Resource Management Updates - Adam Belay <ambx1@neo.rr.com>
23 #include <linux/moduleparam.h>
24 #include <linux/kernel.h>
25 #include <linux/errno.h>
26 #include <linux/delay.h>
27 #include <linux/init.h>
28 #include <linux/isapnp.h>
29 #include <linux/mutex.h>
35 #define ISAPNP_REGION_OK
38 int isapnp_disable
; /* Disable ISA PnP */
39 static int isapnp_rdp
; /* Read Data Port */
40 static int isapnp_reset
= 1; /* reset all PnP cards (deactivate) */
41 static int isapnp_verbose
= 1; /* verbose mode */
43 module_param(isapnp_disable
, int, 0);
44 MODULE_PARM_DESC(isapnp_disable
, "ISA Plug & Play disable");
45 module_param(isapnp_rdp
, int, 0);
46 MODULE_PARM_DESC(isapnp_rdp
, "ISA Plug & Play read data port");
47 module_param(isapnp_reset
, int, 0);
48 MODULE_PARM_DESC(isapnp_reset
, "ISA Plug & Play reset all cards");
49 module_param(isapnp_verbose
, int, 0);
50 MODULE_PARM_DESC(isapnp_verbose
, "ISA Plug & Play verbose mode");
56 #define _STAG_PNPVERNO 0x01
57 #define _STAG_LOGDEVID 0x02
58 #define _STAG_COMPATDEVID 0x03
59 #define _STAG_IRQ 0x04
60 #define _STAG_DMA 0x05
61 #define _STAG_STARTDEP 0x06
62 #define _STAG_ENDDEP 0x07
63 #define _STAG_IOPORT 0x08
64 #define _STAG_FIXEDIO 0x09
65 #define _STAG_VENDOR 0x0e
66 #define _STAG_END 0x0f
68 #define _LTAG_MEMRANGE 0x81
69 #define _LTAG_ANSISTR 0x82
70 #define _LTAG_UNICODESTR 0x83
71 #define _LTAG_VENDOR 0x84
72 #define _LTAG_MEM32RANGE 0x85
73 #define _LTAG_FIXEDMEM32RANGE 0x86
75 /* Logical device control and configuration registers */
77 #define ISAPNP_CFG_ACTIVATE 0x30 /* byte */
78 #define ISAPNP_CFG_MEM 0x40 /* 4 * dword */
79 #define ISAPNP_CFG_PORT 0x60 /* 8 * word */
80 #define ISAPNP_CFG_IRQ 0x70 /* 2 * word */
81 #define ISAPNP_CFG_DMA 0x74 /* 2 * byte */
84 * Sizes of ISAPNP logical device configuration register sets.
85 * See PNP-ISA-v1.0a.pdf, Appendix A.
87 #define ISAPNP_MAX_MEM 4
88 #define ISAPNP_MAX_PORT 8
89 #define ISAPNP_MAX_IRQ 2
90 #define ISAPNP_MAX_DMA 2
92 static unsigned char isapnp_checksum_value
;
93 static DEFINE_MUTEX(isapnp_cfg_mutex
);
94 static int isapnp_csn_count
;
98 static inline void write_data(unsigned char x
)
103 static inline void write_address(unsigned char x
)
109 static inline unsigned char read_data(void)
111 unsigned char val
= inb(isapnp_rdp
);
115 unsigned char isapnp_read_byte(unsigned char idx
)
121 static unsigned short isapnp_read_word(unsigned char idx
)
125 val
= isapnp_read_byte(idx
);
126 val
= (val
<< 8) + isapnp_read_byte(idx
+ 1);
130 void isapnp_write_byte(unsigned char idx
, unsigned char val
)
136 static void isapnp_write_word(unsigned char idx
, unsigned short val
)
138 isapnp_write_byte(idx
, val
>> 8);
139 isapnp_write_byte(idx
+ 1, val
);
142 static void isapnp_key(void)
144 unsigned char code
= 0x6a, msb
;
153 for (i
= 1; i
< 32; i
++) {
154 msb
= ((code
& 0x01) ^ ((code
& 0x02) >> 1)) << 7;
155 code
= (code
>> 1) | msb
;
160 /* place all pnp cards in wait-for-key state */
161 static void isapnp_wait(void)
163 isapnp_write_byte(0x02, 0x02);
166 static void isapnp_wake(unsigned char csn
)
168 isapnp_write_byte(0x03, csn
);
171 static void isapnp_device(unsigned char logdev
)
173 isapnp_write_byte(0x07, logdev
);
176 static void isapnp_activate(unsigned char logdev
)
178 isapnp_device(logdev
);
179 isapnp_write_byte(ISAPNP_CFG_ACTIVATE
, 1);
183 static void isapnp_deactivate(unsigned char logdev
)
185 isapnp_device(logdev
);
186 isapnp_write_byte(ISAPNP_CFG_ACTIVATE
, 0);
190 static void __init
isapnp_peek(unsigned char *data
, int bytes
)
195 for (i
= 1; i
<= bytes
; i
++) {
196 for (j
= 0; j
< 20; j
++) {
197 d
= isapnp_read_byte(0x05);
207 d
= isapnp_read_byte(0x04); /* PRESDI */
208 isapnp_checksum_value
+= d
;
214 #define RDP_STEP 32 /* minimum is 4 */
216 static int isapnp_next_rdp(void)
218 int rdp
= isapnp_rdp
;
219 static int old_rdp
= 0;
222 release_region(old_rdp
, 1);
225 while (rdp
<= 0x3ff) {
227 * We cannot use NE2000 probe spaces for ISAPnP or we
228 * will lock up machines.
230 if ((rdp
< 0x280 || rdp
> 0x380)
231 && request_region(rdp
, 1, "ISAPnP")) {
241 /* Set read port address */
242 static inline void isapnp_set_rdp(void)
244 isapnp_write_byte(0x00, isapnp_rdp
>> 2);
249 * Perform an isolation. The port selection code now tries to avoid
250 * "dangerous to read" ports.
252 static int __init
isapnp_isolate_rdp_select(void)
257 /* Control: reset CSN and conditionally everything else too */
258 isapnp_write_byte(0x02, isapnp_reset
? 0x05 : 0x04);
265 if (isapnp_next_rdp() < 0) {
278 * Isolate (assign uniqued CSN) to all ISA PnP devices.
280 static int __init
isapnp_isolate(void)
282 unsigned char checksum
= 0x6a;
283 unsigned char chksum
= 0x00;
284 unsigned char bit
= 0x00;
291 if (isapnp_isolate_rdp_select() < 0)
295 for (i
= 1; i
<= 64; i
++) {
296 data
= read_data() << 8;
298 data
= data
| read_data();
303 ((((checksum
^ (checksum
>> 1)) & 0x01) ^ bit
) << 7)
307 for (i
= 65; i
<= 72; i
++) {
308 data
= read_data() << 8;
310 data
= data
| read_data();
313 chksum
|= (1 << (i
- 65));
315 if (checksum
!= 0x00 && checksum
== chksum
) {
318 isapnp_write_byte(0x06, csn
);
328 if (iteration
== 1) {
329 isapnp_rdp
+= RDP_STEP
;
330 if (isapnp_isolate_rdp_select() < 0)
332 } else if (iteration
> 1) {
343 isapnp_csn_count
= csn
;
348 * Read one tag from stream.
350 static int __init
isapnp_read_tag(unsigned char *type
, unsigned short *size
)
352 unsigned char tag
, tmp
[2];
354 isapnp_peek(&tag
, 1);
355 if (tag
== 0) /* invalid tag */
357 if (tag
& 0x80) { /* large item */
360 *size
= (tmp
[1] << 8) | tmp
[0];
362 *type
= (tag
>> 3) & 0x0f;
365 if (*type
== 0xff && *size
== 0xffff) /* probably invalid data */
371 * Skip specified number of bytes from stream.
373 static void __init
isapnp_skip_bytes(int count
)
375 isapnp_peek(NULL
, count
);
379 * Parse logical device tag.
381 static struct pnp_dev
*__init
isapnp_parse_device(struct pnp_card
*card
,
382 int size
, int number
)
384 unsigned char tmp
[6];
389 isapnp_peek(tmp
, size
);
390 eisa_id
= tmp
[0] | tmp
[1] << 8 | tmp
[2] << 16 | tmp
[3] << 24;
391 pnp_eisa_id_to_string(eisa_id
, id
);
393 dev
= pnp_alloc_dev(&isapnp_protocol
, number
, id
);
398 dev
->capabilities
|= PNP_CONFIGURABLE
;
399 dev
->capabilities
|= PNP_READ
;
400 dev
->capabilities
|= PNP_WRITE
;
401 dev
->capabilities
|= PNP_DISABLE
;
402 pnp_init_resources(dev
);
407 * Add IRQ resource to resources list.
409 static void __init
isapnp_parse_irq_resource(struct pnp_dev
*dev
,
410 unsigned int option_flags
,
413 unsigned char tmp
[3];
416 unsigned char flags
= IORESOURCE_IRQ_HIGHEDGE
;
418 isapnp_peek(tmp
, size
);
419 bits
= (tmp
[1] << 8) | tmp
[0];
421 bitmap_zero(map
.bits
, PNP_IRQ_NR
);
422 bitmap_copy(map
.bits
, &bits
, 16);
427 pnp_register_irq_resource(dev
, option_flags
, &map
, flags
);
431 * Add DMA resource to resources list.
433 static void __init
isapnp_parse_dma_resource(struct pnp_dev
*dev
,
434 unsigned int option_flags
,
437 unsigned char tmp
[2];
439 isapnp_peek(tmp
, size
);
440 pnp_register_dma_resource(dev
, option_flags
, tmp
[0], tmp
[1]);
444 * Add port resource to resources list.
446 static void __init
isapnp_parse_port_resource(struct pnp_dev
*dev
,
447 unsigned int option_flags
,
450 unsigned char tmp
[7];
451 resource_size_t min
, max
, align
, len
;
454 isapnp_peek(tmp
, size
);
455 min
= (tmp
[2] << 8) | tmp
[1];
456 max
= (tmp
[4] << 8) | tmp
[3];
459 flags
= tmp
[0] ? IORESOURCE_IO_16BIT_ADDR
: 0;
460 pnp_register_port_resource(dev
, option_flags
,
461 min
, max
, align
, len
, flags
);
465 * Add fixed port resource to resources list.
467 static void __init
isapnp_parse_fixed_port_resource(struct pnp_dev
*dev
,
468 unsigned int option_flags
,
471 unsigned char tmp
[3];
472 resource_size_t base
, len
;
474 isapnp_peek(tmp
, size
);
475 base
= (tmp
[1] << 8) | tmp
[0];
477 pnp_register_port_resource(dev
, option_flags
, base
, base
, 0, len
,
478 IORESOURCE_IO_FIXED
);
482 * Add memory resource to resources list.
484 static void __init
isapnp_parse_mem_resource(struct pnp_dev
*dev
,
485 unsigned int option_flags
,
488 unsigned char tmp
[9];
489 resource_size_t min
, max
, align
, len
;
492 isapnp_peek(tmp
, size
);
493 min
= ((tmp
[2] << 8) | tmp
[1]) << 8;
494 max
= ((tmp
[4] << 8) | tmp
[3]) << 8;
495 align
= (tmp
[6] << 8) | tmp
[5];
496 len
= ((tmp
[8] << 8) | tmp
[7]) << 8;
498 pnp_register_mem_resource(dev
, option_flags
,
499 min
, max
, align
, len
, flags
);
503 * Add 32-bit memory resource to resources list.
505 static void __init
isapnp_parse_mem32_resource(struct pnp_dev
*dev
,
506 unsigned int option_flags
,
509 unsigned char tmp
[17];
510 resource_size_t min
, max
, align
, len
;
513 isapnp_peek(tmp
, size
);
514 min
= (tmp
[4] << 24) | (tmp
[3] << 16) | (tmp
[2] << 8) | tmp
[1];
515 max
= (tmp
[8] << 24) | (tmp
[7] << 16) | (tmp
[6] << 8) | tmp
[5];
516 align
= (tmp
[12] << 24) | (tmp
[11] << 16) | (tmp
[10] << 8) | tmp
[9];
517 len
= (tmp
[16] << 24) | (tmp
[15] << 16) | (tmp
[14] << 8) | tmp
[13];
519 pnp_register_mem_resource(dev
, option_flags
,
520 min
, max
, align
, len
, flags
);
524 * Add 32-bit fixed memory resource to resources list.
526 static void __init
isapnp_parse_fixed_mem32_resource(struct pnp_dev
*dev
,
527 unsigned int option_flags
,
530 unsigned char tmp
[9];
531 resource_size_t base
, len
;
534 isapnp_peek(tmp
, size
);
535 base
= (tmp
[4] << 24) | (tmp
[3] << 16) | (tmp
[2] << 8) | tmp
[1];
536 len
= (tmp
[8] << 24) | (tmp
[7] << 16) | (tmp
[6] << 8) | tmp
[5];
538 pnp_register_mem_resource(dev
, option_flags
, base
, base
, 0, len
, flags
);
542 * Parse card name for ISA PnP device.
545 isapnp_parse_name(char *name
, unsigned int name_max
, unsigned short *size
)
547 if (name
[0] == '\0') {
548 unsigned short size1
=
549 *size
>= name_max
? (name_max
- 1) : *size
;
550 isapnp_peek(name
, size1
);
554 /* clean whitespace from end of string */
555 while (size1
> 0 && name
[--size1
] == ' ')
561 * Parse resource map for logical device.
563 static int __init
isapnp_create_device(struct pnp_card
*card
,
566 int number
= 0, skip
= 0, priority
, compat
= 0;
567 unsigned char type
, tmp
[17];
568 unsigned int option_flags
;
573 if ((dev
= isapnp_parse_device(card
, size
, number
++)) == NULL
)
576 pnp_add_card_device(card
, dev
);
579 if (isapnp_read_tag(&type
, &size
) < 0)
581 if (skip
&& type
!= _STAG_LOGDEVID
&& type
!= _STAG_END
)
585 if (size
>= 5 && size
<= 6) {
587 isapnp_parse_device(card
, size
,
593 pnp_add_card_device(card
, dev
);
599 case _STAG_COMPATDEVID
:
600 if (size
== 4 && compat
< DEVICE_COUNT_COMPATIBLE
) {
602 eisa_id
= tmp
[0] | tmp
[1] << 8 |
603 tmp
[2] << 16 | tmp
[3] << 24;
604 pnp_eisa_id_to_string(eisa_id
, id
);
611 if (size
< 2 || size
> 3)
613 isapnp_parse_irq_resource(dev
, option_flags
, size
);
619 isapnp_parse_dma_resource(dev
, option_flags
, size
);
625 priority
= PNP_RES_PRIORITY_ACCEPTABLE
;
627 isapnp_peek(tmp
, size
);
631 option_flags
= pnp_new_dependent_set(dev
, priority
);
641 isapnp_parse_port_resource(dev
, option_flags
, size
);
647 isapnp_parse_fixed_port_resource(dev
, option_flags
,
656 isapnp_parse_mem_resource(dev
, option_flags
, size
);
660 isapnp_parse_name(dev
->name
, sizeof(dev
->name
), &size
);
662 case _LTAG_UNICODESTR
:
663 /* silently ignore */
664 /* who use unicode for hardware identification? */
668 case _LTAG_MEM32RANGE
:
671 isapnp_parse_mem32_resource(dev
, option_flags
, size
);
674 case _LTAG_FIXEDMEM32RANGE
:
677 isapnp_parse_fixed_mem32_resource(dev
, option_flags
,
683 isapnp_skip_bytes(size
);
686 dev_err(&dev
->dev
, "unknown tag %#x (card %i), "
687 "ignored\n", type
, card
->number
);
691 isapnp_skip_bytes(size
);
697 * Parse resource map for ISA PnP card.
699 static void __init
isapnp_parse_resource_map(struct pnp_card
*card
)
701 unsigned char type
, tmp
[17];
705 if (isapnp_read_tag(&type
, &size
) < 0)
712 card
->pnpver
= tmp
[0];
713 card
->productver
= tmp
[1];
717 if (size
>= 5 && size
<= 6) {
718 if (isapnp_create_device(card
, size
) == 1)
726 isapnp_parse_name(card
->name
, sizeof(card
->name
),
729 case _LTAG_UNICODESTR
:
730 /* silently ignore */
731 /* who use unicode for hardware identification? */
737 isapnp_skip_bytes(size
);
740 dev_err(&card
->dev
, "unknown tag %#x, ignored\n",
745 isapnp_skip_bytes(size
);
750 * Build device list for all present ISA PnP devices.
752 static int __init
isapnp_build_device_list(void)
755 unsigned char header
[9];
756 struct pnp_card
*card
;
762 for (csn
= 1; csn
<= isapnp_csn_count
; csn
++) {
764 isapnp_peek(header
, 9);
765 eisa_id
= header
[0] | header
[1] << 8 |
766 header
[2] << 16 | header
[3] << 24;
767 pnp_eisa_id_to_string(eisa_id
, id
);
768 card
= pnp_alloc_card(&isapnp_protocol
, csn
, id
);
772 INIT_LIST_HEAD(&card
->devices
);
774 (header
[7] << 24) | (header
[6] << 16) | (header
[5] << 8) |
776 isapnp_checksum_value
= 0x00;
777 isapnp_parse_resource_map(card
);
778 if (isapnp_checksum_value
!= 0x00)
779 dev_err(&card
->dev
, "invalid checksum %#x\n",
780 isapnp_checksum_value
);
781 card
->checksum
= isapnp_checksum_value
;
790 * Basic configuration routines.
793 int isapnp_present(void)
795 struct pnp_card
*card
;
797 pnp_for_each_card(card
) {
798 if (card
->protocol
== &isapnp_protocol
)
804 int isapnp_cfg_begin(int csn
, int logdev
)
806 if (csn
< 1 || csn
> isapnp_csn_count
|| logdev
> 10)
808 mutex_lock(&isapnp_cfg_mutex
);
813 /* to avoid malfunction when the isapnptools package is used */
814 /* we must set RDP to our value again */
815 /* it is possible to set RDP only in the isolation phase */
816 /* Jens Thoms Toerring <Jens.Toerring@physik.fu-berlin.de> */
817 isapnp_write_byte(0x02, 0x04); /* clear CSN of card */
818 mdelay(2); /* is this necessary? */
819 isapnp_wake(csn
); /* bring card into sleep state */
820 isapnp_wake(0); /* bring card into isolation state */
821 isapnp_set_rdp(); /* reset the RDP port */
822 udelay(1000); /* delay 1000us */
823 isapnp_write_byte(0x06, csn
); /* reset CSN to previous value */
824 udelay(250); /* is this necessary? */
827 isapnp_device(logdev
);
831 int isapnp_cfg_end(void)
834 mutex_unlock(&isapnp_cfg_mutex
);
842 EXPORT_SYMBOL(isapnp_protocol
);
843 EXPORT_SYMBOL(isapnp_present
);
844 EXPORT_SYMBOL(isapnp_cfg_begin
);
845 EXPORT_SYMBOL(isapnp_cfg_end
);
846 EXPORT_SYMBOL(isapnp_write_byte
);
848 static int isapnp_get_resources(struct pnp_dev
*dev
)
852 pnp_dbg(&dev
->dev
, "get resources\n");
853 pnp_init_resources(dev
);
854 isapnp_cfg_begin(dev
->card
->number
, dev
->number
);
855 dev
->active
= isapnp_read_byte(ISAPNP_CFG_ACTIVATE
);
859 for (i
= 0; i
< ISAPNP_MAX_PORT
; i
++) {
860 ret
= isapnp_read_word(ISAPNP_CFG_PORT
+ (i
<< 1));
861 pnp_add_io_resource(dev
, ret
, ret
,
862 ret
== 0 ? IORESOURCE_DISABLED
: 0);
864 for (i
= 0; i
< ISAPNP_MAX_MEM
; i
++) {
865 ret
= isapnp_read_word(ISAPNP_CFG_MEM
+ (i
<< 3)) << 8;
866 pnp_add_mem_resource(dev
, ret
, ret
,
867 ret
== 0 ? IORESOURCE_DISABLED
: 0);
869 for (i
= 0; i
< ISAPNP_MAX_IRQ
; i
++) {
870 ret
= isapnp_read_word(ISAPNP_CFG_IRQ
+ (i
<< 1)) >> 8;
871 pnp_add_irq_resource(dev
, ret
,
872 ret
== 0 ? IORESOURCE_DISABLED
: 0);
874 for (i
= 0; i
< ISAPNP_MAX_DMA
; i
++) {
875 ret
= isapnp_read_byte(ISAPNP_CFG_DMA
+ i
);
876 pnp_add_dma_resource(dev
, ret
,
877 ret
== 4 ? IORESOURCE_DISABLED
: 0);
885 static int isapnp_set_resources(struct pnp_dev
*dev
)
887 struct resource
*res
;
890 pnp_dbg(&dev
->dev
, "set resources\n");
891 isapnp_cfg_begin(dev
->card
->number
, dev
->number
);
893 for (tmp
= 0; tmp
< ISAPNP_MAX_PORT
; tmp
++) {
894 res
= pnp_get_resource(dev
, IORESOURCE_IO
, tmp
);
895 if (pnp_resource_enabled(res
)) {
896 pnp_dbg(&dev
->dev
, " set io %d to %#llx\n",
897 tmp
, (unsigned long long) res
->start
);
898 isapnp_write_word(ISAPNP_CFG_PORT
+ (tmp
<< 1),
902 for (tmp
= 0; tmp
< ISAPNP_MAX_IRQ
; tmp
++) {
903 res
= pnp_get_resource(dev
, IORESOURCE_IRQ
, tmp
);
904 if (pnp_resource_enabled(res
)) {
905 int irq
= res
->start
;
908 pnp_dbg(&dev
->dev
, " set irq %d to %d\n", tmp
, irq
);
909 isapnp_write_byte(ISAPNP_CFG_IRQ
+ (tmp
<< 1), irq
);
912 for (tmp
= 0; tmp
< ISAPNP_MAX_DMA
; tmp
++) {
913 res
= pnp_get_resource(dev
, IORESOURCE_DMA
, tmp
);
914 if (pnp_resource_enabled(res
)) {
915 pnp_dbg(&dev
->dev
, " set dma %d to %lld\n",
916 tmp
, (unsigned long long) res
->start
);
917 isapnp_write_byte(ISAPNP_CFG_DMA
+ tmp
, res
->start
);
920 for (tmp
= 0; tmp
< ISAPNP_MAX_MEM
; tmp
++) {
921 res
= pnp_get_resource(dev
, IORESOURCE_MEM
, tmp
);
922 if (pnp_resource_enabled(res
)) {
923 pnp_dbg(&dev
->dev
, " set mem %d to %#llx\n",
924 tmp
, (unsigned long long) res
->start
);
925 isapnp_write_word(ISAPNP_CFG_MEM
+ (tmp
<< 3),
926 (res
->start
>> 8) & 0xffff);
929 /* FIXME: We aren't handling 32bit mems properly here */
930 isapnp_activate(dev
->number
);
935 static int isapnp_disable_resources(struct pnp_dev
*dev
)
939 isapnp_cfg_begin(dev
->card
->number
, dev
->number
);
940 isapnp_deactivate(dev
->number
);
946 struct pnp_protocol isapnp_protocol
= {
947 .name
= "ISA Plug and Play",
948 .get
= isapnp_get_resources
,
949 .set
= isapnp_set_resources
,
950 .disable
= isapnp_disable_resources
,
953 static int __init
isapnp_init(void)
956 struct pnp_card
*card
;
959 if (isapnp_disable
) {
960 printk(KERN_INFO
"isapnp: ISA Plug & Play support disabled\n");
964 if (check_legacy_ioport(_PIDXR
) || check_legacy_ioport(_PNPWRP
))
967 #ifdef ISAPNP_REGION_OK
968 if (!request_region(_PIDXR
, 1, "isapnp index")) {
969 printk(KERN_ERR
"isapnp: Index Register 0x%x already used\n",
974 if (!request_region(_PNPWRP
, 1, "isapnp write")) {
976 "isapnp: Write Data Register 0x%x already used\n",
978 #ifdef ISAPNP_REGION_OK
979 release_region(_PIDXR
, 1);
984 if (pnp_register_protocol(&isapnp_protocol
) < 0)
988 * Print a message. The existing ISAPnP code is hanging machines
989 * so let the user know where.
992 printk(KERN_INFO
"isapnp: Scanning for PnP cards...\n");
993 if (isapnp_rdp
>= 0x203 && isapnp_rdp
<= 0x3ff) {
995 if (!request_region(isapnp_rdp
, 1, "isapnp read")) {
997 "isapnp: Read Data Register 0x%x already used\n",
999 #ifdef ISAPNP_REGION_OK
1000 release_region(_PIDXR
, 1);
1002 release_region(_PNPWRP
, 1);
1007 if (isapnp_rdp
< 0x203 || isapnp_rdp
> 0x3ff) {
1008 cards
= isapnp_isolate();
1009 if (cards
< 0 || (isapnp_rdp
< 0x203 || isapnp_rdp
> 0x3ff)) {
1010 #ifdef ISAPNP_REGION_OK
1011 release_region(_PIDXR
, 1);
1013 release_region(_PNPWRP
, 1);
1015 "isapnp: No Plug & Play device found\n");
1018 request_region(isapnp_rdp
, 1, "isapnp read");
1020 isapnp_build_device_list();
1023 protocol_for_each_card(&isapnp_protocol
, card
) {
1025 if (isapnp_verbose
) {
1026 dev_info(&card
->dev
, "card '%s'\n",
1027 card
->name
[0] ? card
->name
: "unknown");
1028 if (isapnp_verbose
< 2)
1030 card_for_each_dev(card
, dev
) {
1031 dev_info(&card
->dev
, "device '%s'\n",
1032 dev
->name
[0] ? dev
->name
: "unknown");
1038 "isapnp: %i Plug & Play card%s detected total\n", cards
,
1039 cards
> 1 ? "s" : "");
1041 printk(KERN_INFO
"isapnp: No Plug & Play card found\n");
1047 device_initcall(isapnp_init
);
1049 /* format is: noisapnp */
1051 static int __init
isapnp_setup_disable(char *str
)
1057 __setup("noisapnp", isapnp_setup_disable
);
1059 /* format is: isapnp=rdp,reset,skip_pci_scan,verbose */
1061 static int __init
isapnp_setup_isapnp(char *str
)
1063 (void)((get_option(&str
, &isapnp_rdp
) == 2) &&
1064 (get_option(&str
, &isapnp_reset
) == 2) &&
1065 (get_option(&str
, &isapnp_verbose
) == 2));
1069 __setup("isapnp=", isapnp_setup_isapnp
);