?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
PNP: add pnp_eisa_id_to_string()
[linux-2.6.git] / drivers / pnp / isapnp / core.c
blobccb04190044ba631967c46a828deaa8a67caff38
1 /*
2 * ISA Plug & Play support
3 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
4 *
5 *
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.
10 *
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.
15 *
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.
19 *
20 * Changelog:
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>
35 */
36
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>
45 #include <asm/io.h>
46
47 #include "../base.h"
48
49 #if 0
50 #define ISAPNP_REGION_OK
51 #endif
52
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 */
57
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");
69
70 #define _PIDXR 0x279
71 #define _PNPWRP 0xa79
72
73 /* short tags */
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
85 /* long tags */
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
92
93 /* Logical device control and configuration registers */
94
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 */
100
101 /*
102 * Sizes of ISAPNP logical device configuration register sets.
103 * See PNP-ISA-v1.0a.pdf, Appendix A.
104 */
105 #define ISAPNP_MAX_MEM 4
106 #define ISAPNP_MAX_PORT 8
107 #define ISAPNP_MAX_IRQ 2
108 #define ISAPNP_MAX_DMA 2
109
110 static unsigned char isapnp_checksum_value;
111 static DEFINE_MUTEX(isapnp_cfg_mutex);
112 static int isapnp_csn_count;
113
114 /* some prototypes */
115
116 static inline void write_data(unsigned char x)
117 {
118 outb(x, _PNPWRP);
119 }
120
121 static inline void write_address(unsigned char x)
122 {
123 outb(x, _PIDXR);
124 udelay(20);
125 }
126
127 static inline unsigned char read_data(void)
128 {
129 unsigned char val = inb(isapnp_rdp);
130 return val;
131 }
132
133 unsigned char isapnp_read_byte(unsigned char idx)
134 {
135 write_address(idx);
136 return read_data();
137 }
138
139 static unsigned short isapnp_read_word(unsigned char idx)
140 {
141 unsigned short val;
142
143 val = isapnp_read_byte(idx);
144 val = (val << 8) + isapnp_read_byte(idx + 1);
145 return val;
146 }
147
148 void isapnp_write_byte(unsigned char idx, unsigned char val)
149 {
150 write_address(idx);
151 write_data(val);
152 }
153
154 static void isapnp_write_word(unsigned char idx, unsigned short val)
155 {
156 isapnp_write_byte(idx, val >> 8);
157 isapnp_write_byte(idx + 1, val);
158 }
159
160 static void isapnp_key(void)
161 {
162 unsigned char code = 0x6a, msb;
163 int i;
164
165 mdelay(1);
166 write_address(0x00);
167 write_address(0x00);
168
169 write_address(code);
170
171 for (i = 1; i < 32; i++) {
172 msb = ((code & 0x01) ^ ((code & 0x02) >> 1)) << 7;
173 code = (code >> 1) | msb;
174 write_address(code);
175 }
176 }
177
178 /* place all pnp cards in wait-for-key state */
179 static void isapnp_wait(void)
180 {
181 isapnp_write_byte(0x02, 0x02);
182 }
183
184 static void isapnp_wake(unsigned char csn)
185 {
186 isapnp_write_byte(0x03, csn);
187 }
188
189 static void isapnp_device(unsigned char logdev)
190 {
191 isapnp_write_byte(0x07, logdev);
192 }
193
194 static void isapnp_activate(unsigned char logdev)
195 {
196 isapnp_device(logdev);
197 isapnp_write_byte(ISAPNP_CFG_ACTIVATE, 1);
198 udelay(250);
199 }
200
201 static void isapnp_deactivate(unsigned char logdev)
202 {
203 isapnp_device(logdev);
204 isapnp_write_byte(ISAPNP_CFG_ACTIVATE, 0);
205 udelay(500);
206 }
207
208 static void __init isapnp_peek(unsigned char *data, int bytes)
209 {
210 int i, j;
211 unsigned char d = 0;
212
213 for (i = 1; i <= bytes; i++) {
214 for (j = 0; j < 20; j++) {
215 d = isapnp_read_byte(0x05);
216 if (d & 1)
217 break;
218 udelay(100);
219 }
220 if (!(d & 1)) {
221 if (data != NULL)
222 *data++ = 0xff;
223 continue;
224 }
225 d = isapnp_read_byte(0x04); /* PRESDI */
226 isapnp_checksum_value += d;
227 if (data != NULL)
228 *data++ = d;
229 }
230 }
231
232 #define RDP_STEP 32 /* minimum is 4 */
233
234 static int isapnp_next_rdp(void)
235 {
236 int rdp = isapnp_rdp;
237 static int old_rdp = 0;
238
239 if (old_rdp) {
240 release_region(old_rdp, 1);
241 old_rdp = 0;
242 }
243 while (rdp <= 0x3ff) {
244 /*
245 * We cannot use NE2000 probe spaces for ISAPnP or we
246 * will lock up machines.
247 */
248 if ((rdp < 0x280 || rdp > 0x380)
249 && request_region(rdp, 1, "ISAPnP")) {
250 isapnp_rdp = rdp;
251 old_rdp = rdp;
252 return 0;
253 }
254 rdp += RDP_STEP;
255 }
256 return -1;
257 }
258
259 /* Set read port address */
260 static inline void isapnp_set_rdp(void)
261 {
262 isapnp_write_byte(0x00, isapnp_rdp >> 2);
263 udelay(100);
264 }
265
266 /*
267 * Perform an isolation. The port selection code now tries to avoid
268 * "dangerous to read" ports.
269 */
270 static int __init isapnp_isolate_rdp_select(void)
271 {
272 isapnp_wait();
273 isapnp_key();
274
275 /* Control: reset CSN and conditionally everything else too */
276 isapnp_write_byte(0x02, isapnp_reset ? 0x05 : 0x04);
277 mdelay(2);
278
279 isapnp_wait();
280 isapnp_key();
281 isapnp_wake(0x00);
282
283 if (isapnp_next_rdp() < 0) {
284 isapnp_wait();
285 return -1;
286 }
287
288 isapnp_set_rdp();
289 udelay(1000);
290 write_address(0x01);
291 udelay(1000);
292 return 0;
293 }
294
295 /*
296 * Isolate (assign uniqued CSN) to all ISA PnP devices.
297 */
298 static int __init isapnp_isolate(void)
299 {
300 unsigned char checksum = 0x6a;
301 unsigned char chksum = 0x00;
302 unsigned char bit = 0x00;
303 int data;
304 int csn = 0;
305 int i;
306 int iteration = 1;
307
308 isapnp_rdp = 0x213;
309 if (isapnp_isolate_rdp_select() < 0)
310 return -1;
311
312 while (1) {
313 for (i = 1; i <= 64; i++) {
314 data = read_data() << 8;
315 udelay(250);
316 data = data | read_data();
317 udelay(250);
318 if (data == 0x55aa)
319 bit = 0x01;
320 checksum =
321 ((((checksum ^ (checksum >> 1)) & 0x01) ^ bit) << 7)
322 | (checksum >> 1);
323 bit = 0x00;
324 }
325 for (i = 65; i <= 72; i++) {
326 data = read_data() << 8;
327 udelay(250);
328 data = data | read_data();
329 udelay(250);
330 if (data == 0x55aa)
331 chksum |= (1 << (i - 65));
332 }
333 if (checksum != 0x00 && checksum == chksum) {
334 csn++;
335
336 isapnp_write_byte(0x06, csn);
337 udelay(250);
338 iteration++;
339 isapnp_wake(0x00);
340 isapnp_set_rdp();
341 udelay(1000);
342 write_address(0x01);
343 udelay(1000);
344 goto __next;
345 }
346 if (iteration == 1) {
347 isapnp_rdp += RDP_STEP;
348 if (isapnp_isolate_rdp_select() < 0)
349 return -1;
350 } else if (iteration > 1) {
351 break;
352 }
353 __next:
354 if (csn == 255)
355 break;
356 checksum = 0x6a;
357 chksum = 0x00;
358 bit = 0x00;
359 }
360 isapnp_wait();
361 isapnp_csn_count = csn;
362 return csn;
363 }
364
365 /*
366 * Read one tag from stream.
367 */
368 static int __init isapnp_read_tag(unsigned char *type, unsigned short *size)
369 {
370 unsigned char tag, tmp[2];
371
372 isapnp_peek(&tag, 1);
373 if (tag == 0) /* invalid tag */
374 return -1;
375 if (tag & 0x80) { /* large item */
376 *type = tag;
377 isapnp_peek(tmp, 2);
378 *size = (tmp[1] << 8) | tmp[0];
379 } else {
380 *type = (tag >> 3) & 0x0f;
381 *size = tag & 0x07;
382 }
383 #if 0
384 printk(KERN_DEBUG "tag = 0x%x, type = 0x%x, size = %i\n", tag, *type,
385 *size);
386 #endif
387 if (*type == 0xff && *size == 0xffff) /* probably invalid data */
388 return -1;
389 return 0;
390 }
391
392 /*
393 * Skip specified number of bytes from stream.
394 */
395 static void __init isapnp_skip_bytes(int count)
396 {
397 isapnp_peek(NULL, count);
398 }
399
400 /*
401 * Parse logical device tag.
402 */
403 static struct pnp_dev *__init isapnp_parse_device(struct pnp_card *card,
404 int size, int number)
405 {
406 unsigned char tmp[6];
407 struct pnp_dev *dev;
408 u32 eisa_id;
409 char id[8];
410
411 isapnp_peek(tmp, size);
412 dev = kzalloc(sizeof(struct pnp_dev), GFP_KERNEL);
413 if (!dev)
414 return NULL;
415 dev->number = number;
416 eisa_id = tmp[0] | tmp[1] << 8 | tmp[2] << 16 | tmp[3] << 24;
417 pnp_eisa_id_to_string(eisa_id, id);
418 pnp_add_id(dev, id);
419 dev->regs = tmp[4];
420 dev->card = card;
421 if (size > 5)
422 dev->regs |= tmp[5] << 8;
423 dev->protocol = &isapnp_protocol;
424 dev->capabilities |= PNP_CONFIGURABLE;
425 dev->capabilities |= PNP_READ;
426 dev->capabilities |= PNP_WRITE;
427 dev->capabilities |= PNP_DISABLE;
428 pnp_init_resource_table(&dev->res);
429 return dev;
430 }
431
432 /*
433 * Add IRQ resource to resources list.
434 */
435 static void __init isapnp_parse_irq_resource(struct pnp_option *option,
436 int size)
437 {
438 unsigned char tmp[3];
439 struct pnp_irq *irq;
440 unsigned long bits;
441
442 isapnp_peek(tmp, size);
443 irq = kzalloc(sizeof(struct pnp_irq), GFP_KERNEL);
444 if (!irq)
445 return;
446 bits = (tmp[1] << 8) | tmp[0];
447 bitmap_copy(irq->map, &bits, 16);
448 if (size > 2)
449 irq->flags = tmp[2];
450 else
451 irq->flags = IORESOURCE_IRQ_HIGHEDGE;
452 pnp_register_irq_resource(option, irq);
453 }
454
455 /*
456 * Add DMA resource to resources list.
457 */
458 static void __init isapnp_parse_dma_resource(struct pnp_option *option,
459 int size)
460 {
461 unsigned char tmp[2];
462 struct pnp_dma *dma;
463
464 isapnp_peek(tmp, size);
465 dma = kzalloc(sizeof(struct pnp_dma), GFP_KERNEL);
466 if (!dma)
467 return;
468 dma->map = tmp[0];
469 dma->flags = tmp[1];
470 pnp_register_dma_resource(option, dma);
471 }
472
473 /*
474 * Add port resource to resources list.
475 */
476 static void __init isapnp_parse_port_resource(struct pnp_option *option,
477 int size)
478 {
479 unsigned char tmp[7];
480 struct pnp_port *port;
481
482 isapnp_peek(tmp, size);
483 port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL);
484 if (!port)
485 return;
486 port->min = (tmp[2] << 8) | tmp[1];
487 port->max = (tmp[4] << 8) | tmp[3];
488 port->align = tmp[5];
489 port->size = tmp[6];
490 port->flags = tmp[0] ? PNP_PORT_FLAG_16BITADDR : 0;
491 pnp_register_port_resource(option, port);
492 }
493
494 /*
495 * Add fixed port resource to resources list.
496 */
497 static void __init isapnp_parse_fixed_port_resource(struct pnp_option *option,
498 int size)
499 {
500 unsigned char tmp[3];
501 struct pnp_port *port;
502
503 isapnp_peek(tmp, size);
504 port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL);
505 if (!port)
506 return;
507 port->min = port->max = (tmp[1] << 8) | tmp[0];
508 port->size = tmp[2];
509 port->align = 0;
510 port->flags = PNP_PORT_FLAG_FIXED;
511 pnp_register_port_resource(option, port);
512 }
513
514 /*
515 * Add memory resource to resources list.
516 */
517 static void __init isapnp_parse_mem_resource(struct pnp_option *option,
518 int size)
519 {
520 unsigned char tmp[9];
521 struct pnp_mem *mem;
522
523 isapnp_peek(tmp, size);
524 mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
525 if (!mem)
526 return;
527 mem->min = ((tmp[2] << 8) | tmp[1]) << 8;
528 mem->max = ((tmp[4] << 8) | tmp[3]) << 8;
529 mem->align = (tmp[6] << 8) | tmp[5];
530 mem->size = ((tmp[8] << 8) | tmp[7]) << 8;
531 mem->flags = tmp[0];
532 pnp_register_mem_resource(option, mem);
533 }
534
535 /*
536 * Add 32-bit memory resource to resources list.
537 */
538 static void __init isapnp_parse_mem32_resource(struct pnp_option *option,
539 int size)
540 {
541 unsigned char tmp[17];
542 struct pnp_mem *mem;
543
544 isapnp_peek(tmp, size);
545 mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
546 if (!mem)
547 return;
548 mem->min = (tmp[4] << 24) | (tmp[3] << 16) | (tmp[2] << 8) | tmp[1];
549 mem->max = (tmp[8] << 24) | (tmp[7] << 16) | (tmp[6] << 8) | tmp[5];
550 mem->align =
551 (tmp[12] << 24) | (tmp[11] << 16) | (tmp[10] << 8) | tmp[9];
552 mem->size =
553 (tmp[16] << 24) | (tmp[15] << 16) | (tmp[14] << 8) | tmp[13];
554 mem->flags = tmp[0];
555 pnp_register_mem_resource(option, mem);
556 }
557
558 /*
559 * Add 32-bit fixed memory resource to resources list.
560 */
561 static void __init isapnp_parse_fixed_mem32_resource(struct pnp_option *option,
562 int size)
563 {
564 unsigned char tmp[9];
565 struct pnp_mem *mem;
566
567 isapnp_peek(tmp, size);
568 mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
569 if (!mem)
570 return;
571 mem->min = mem->max =
572 (tmp[4] << 24) | (tmp[3] << 16) | (tmp[2] << 8) | tmp[1];
573 mem->size = (tmp[8] << 24) | (tmp[7] << 16) | (tmp[6] << 8) | tmp[5];
574 mem->align = 0;
575 mem->flags = tmp[0];
576 pnp_register_mem_resource(option, mem);
577 }
578
579 /*
580 * Parse card name for ISA PnP device.
581 */
582 static void __init
583 isapnp_parse_name(char *name, unsigned int name_max, unsigned short *size)
584 {
585 if (name[0] == '\0') {
586 unsigned short size1 =
587 *size >= name_max ? (name_max - 1) : *size;
588 isapnp_peek(name, size1);
589 name[size1] = '\0';
590 *size -= size1;
591
592 /* clean whitespace from end of string */
593 while (size1 > 0 && name[--size1] == ' ')
594 name[size1] = '\0';
595 }
596 }
597
598 /*
599 * Parse resource map for logical device.
600 */
601 static int __init isapnp_create_device(struct pnp_card *card,
602 unsigned short size)
603 {
604 int number = 0, skip = 0, priority = 0, compat = 0;
605 unsigned char type, tmp[17];
606 struct pnp_option *option;
607 struct pnp_dev *dev;
608 u32 eisa_id;
609 char id[8];
610
611 if ((dev = isapnp_parse_device(card, size, number++)) == NULL)
612 return 1;
613 option = pnp_register_independent_option(dev);
614 if (!option) {
615 kfree(dev);
616 return 1;
617 }
618 pnp_add_card_device(card, dev);
619
620 while (1) {
621 if (isapnp_read_tag(&type, &size) < 0)
622 return 1;
623 if (skip && type != _STAG_LOGDEVID && type != _STAG_END)
624 goto __skip;
625 switch (type) {
626 case _STAG_LOGDEVID:
627 if (size >= 5 && size <= 6) {
628 if ((dev =
629 isapnp_parse_device(card, size,
630 number++)) == NULL)
631 return 1;
632 size = 0;
633 skip = 0;
634 option = pnp_register_independent_option(dev);
635 if (!option) {
636 kfree(dev);
637 return 1;
638 }
639 pnp_add_card_device(card, dev);
640 } else {
641 skip = 1;
642 }
643 priority = 0;
644 compat = 0;
645 break;
646 case _STAG_COMPATDEVID:
647 if (size == 4 && compat < DEVICE_COUNT_COMPATIBLE) {
648 isapnp_peek(tmp, 4);
649 eisa_id = tmp[0] | tmp[1] << 8 |
650 tmp[2] << 16 | tmp[3] << 24;
651 pnp_eisa_id_to_string(eisa_id, id);
652 pnp_add_id(dev, id);
653 compat++;
654 size = 0;
655 }
656 break;
657 case _STAG_IRQ:
658 if (size < 2 || size > 3)
659 goto __skip;
660 isapnp_parse_irq_resource(option, size);
661 size = 0;
662 break;
663 case _STAG_DMA:
664 if (size != 2)
665 goto __skip;
666 isapnp_parse_dma_resource(option, size);
667 size = 0;
668 break;
669 case _STAG_STARTDEP:
670 if (size > 1)
671 goto __skip;
672 priority = 0x100 | PNP_RES_PRIORITY_ACCEPTABLE;
673 if (size > 0) {
674 isapnp_peek(tmp, size);
675 priority = 0x100 | tmp[0];
676 size = 0;
677 }
678 option = pnp_register_dependent_option(dev, priority);
679 if (!option)
680 return 1;
681 break;
682 case _STAG_ENDDEP:
683 if (size != 0)
684 goto __skip;
685 priority = 0;
686 break;
687 case _STAG_IOPORT:
688 if (size != 7)
689 goto __skip;
690 isapnp_parse_port_resource(option, size);
691 size = 0;
692 break;
693 case _STAG_FIXEDIO:
694 if (size != 3)
695 goto __skip;
696 isapnp_parse_fixed_port_resource(option, size);
697 size = 0;
698 break;
699 case _STAG_VENDOR:
700 break;
701 case _LTAG_MEMRANGE:
702 if (size != 9)
703 goto __skip;
704 isapnp_parse_mem_resource(option, size);
705 size = 0;
706 break;
707 case _LTAG_ANSISTR:
708 isapnp_parse_name(dev->name, sizeof(dev->name), &size);
709 break;
710 case _LTAG_UNICODESTR:
711 /* silently ignore */
712 /* who use unicode for hardware identification? */
713 break;
714 case _LTAG_VENDOR:
715 break;
716 case _LTAG_MEM32RANGE:
717 if (size != 17)
718 goto __skip;
719 isapnp_parse_mem32_resource(option, size);
720 size = 0;
721 break;
722 case _LTAG_FIXEDMEM32RANGE:
723 if (size != 9)
724 goto __skip;
725 isapnp_parse_fixed_mem32_resource(option, size);
726 size = 0;
727 break;
728 case _STAG_END:
729 if (size > 0)
730 isapnp_skip_bytes(size);
731 return 1;
732 default:
733 printk(KERN_ERR
734 "isapnp: unexpected or unknown tag type 0x%x for logical device %i (device %i), ignored\n",
735 type, dev->number, card->number);
736 }
737 __skip:
738 if (size > 0)
739 isapnp_skip_bytes(size);
740 }
741 return 0;
742 }
743
744 /*
745 * Parse resource map for ISA PnP card.
746 */
747 static void __init isapnp_parse_resource_map(struct pnp_card *card)
748 {
749 unsigned char type, tmp[17];
750 unsigned short size;
751
752 while (1) {
753 if (isapnp_read_tag(&type, &size) < 0)
754 return;
755 switch (type) {
756 case _STAG_PNPVERNO:
757 if (size != 2)
758 goto __skip;
759 isapnp_peek(tmp, 2);
760 card->pnpver = tmp[0];
761 card->productver = tmp[1];
762 size = 0;
763 break;
764 case _STAG_LOGDEVID:
765 if (size >= 5 && size <= 6) {
766 if (isapnp_create_device(card, size) == 1)
767 return;
768 size = 0;
769 }
770 break;
771 case _STAG_VENDOR:
772 break;
773 case _LTAG_ANSISTR:
774 isapnp_parse_name(card->name, sizeof(card->name),
775 &size);
776 break;
777 case _LTAG_UNICODESTR:
778 /* silently ignore */
779 /* who use unicode for hardware identification? */
780 break;
781 case _LTAG_VENDOR:
782 break;
783 case _STAG_END:
784 if (size > 0)
785 isapnp_skip_bytes(size);
786 return;
787 default:
788 printk(KERN_ERR
789 "isapnp: unexpected or unknown tag type 0x%x for device %i, ignored\n",
790 type, card->number);
791 }
792 __skip:
793 if (size > 0)
794 isapnp_skip_bytes(size);
795 }
796 }
797
798 /*
799 * Compute ISA PnP checksum for first eight bytes.
800 */
801 static unsigned char __init isapnp_checksum(unsigned char *data)
802 {
803 int i, j;
804 unsigned char checksum = 0x6a, bit, b;
805
806 for (i = 0; i < 8; i++) {
807 b = data[i];
808 for (j = 0; j < 8; j++) {
809 bit = 0;
810 if (b & (1 << j))
811 bit = 1;
812 checksum =
813 ((((checksum ^ (checksum >> 1)) & 0x01) ^ bit) << 7)
814 | (checksum >> 1);
815 }
816 }
817 return checksum;
818 }
819
820 /*
821 * Parse EISA id for ISA PnP card.
822 */
823 static void isapnp_parse_card_id(struct pnp_card *card, unsigned short vendor,
824 unsigned short device)
825 {
826 struct pnp_id *id = kzalloc(sizeof(struct pnp_id), GFP_KERNEL);
827
828 if (!id)
829 return;
830 sprintf(id->id, "%c%c%c%x%x%x%x",
831 'A' + ((vendor >> 2) & 0x3f) - 1,
832 'A' + (((vendor & 3) << 3) | ((vendor >> 13) & 7)) - 1,
833 'A' + ((vendor >> 8) & 0x1f) - 1,
834 (device >> 4) & 0x0f,
835 device & 0x0f, (device >> 12) & 0x0f, (device >> 8) & 0x0f);
836 pnp_add_card_id(id, card);
837 }
838
839 /*
840 * Build device list for all present ISA PnP devices.
841 */
842 static int __init isapnp_build_device_list(void)
843 {
844 int csn;
845 unsigned char header[9], checksum;
846 struct pnp_card *card;
847
848 isapnp_wait();
849 isapnp_key();
850 for (csn = 1; csn <= isapnp_csn_count; csn++) {
851 isapnp_wake(csn);
852 isapnp_peek(header, 9);
853 checksum = isapnp_checksum(header);
854 #if 0
855 printk(KERN_DEBUG
856 "vendor: %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
857 header[0], header[1], header[2], header[3], header[4],
858 header[5], header[6], header[7], header[8]);
859 printk(KERN_DEBUG "checksum = 0x%x\n", checksum);
860 #endif
861 if ((card =
862 kzalloc(sizeof(struct pnp_card), GFP_KERNEL)) == NULL)
863 continue;
864
865 card->number = csn;
866 INIT_LIST_HEAD(&card->devices);
867 isapnp_parse_card_id(card, (header[1] << 8) | header[0],
868 (header[3] << 8) | header[2]);
869 card->serial =
870 (header[7] << 24) | (header[6] << 16) | (header[5] << 8) |
871 header[4];
872 isapnp_checksum_value = 0x00;
873 isapnp_parse_resource_map(card);
874 if (isapnp_checksum_value != 0x00)
875 printk(KERN_ERR
876 "isapnp: checksum for device %i is not valid (0x%x)\n",
877 csn, isapnp_checksum_value);
878 card->checksum = isapnp_checksum_value;
879 card->protocol = &isapnp_protocol;
880
881 pnp_add_card(card);
882 }
883 isapnp_wait();
884 return 0;
885 }
886
887 /*
888 * Basic configuration routines.
889 */
890
891 int isapnp_present(void)
892 {
893 struct pnp_card *card;
894
895 pnp_for_each_card(card) {
896 if (card->protocol == &isapnp_protocol)
897 return 1;
898 }
899 return 0;
900 }
901
902 int isapnp_cfg_begin(int csn, int logdev)
903 {
904 if (csn < 1 || csn > isapnp_csn_count || logdev > 10)
905 return -EINVAL;
906 mutex_lock(&isapnp_cfg_mutex);
907 isapnp_wait();
908 isapnp_key();
909 isapnp_wake(csn);
910 #if 0
911 /* to avoid malfunction when the isapnptools package is used */
912 /* we must set RDP to our value again */
913 /* it is possible to set RDP only in the isolation phase */
914 /* Jens Thoms Toerring <Jens.Toerring@physik.fu-berlin.de> */
915 isapnp_write_byte(0x02, 0x04); /* clear CSN of card */
916 mdelay(2); /* is this necessary? */
917 isapnp_wake(csn); /* bring card into sleep state */
918 isapnp_wake(0); /* bring card into isolation state */
919 isapnp_set_rdp(); /* reset the RDP port */
920 udelay(1000); /* delay 1000us */
921 isapnp_write_byte(0x06, csn); /* reset CSN to previous value */
922 udelay(250); /* is this necessary? */
923 #endif
924 if (logdev >= 0)
925 isapnp_device(logdev);
926 return 0;
927 }
928
929 int isapnp_cfg_end(void)
930 {
931 isapnp_wait();
932 mutex_unlock(&isapnp_cfg_mutex);
933 return 0;
934 }
935
936 /*
937 * Initialization.
938 */
939
940 EXPORT_SYMBOL(isapnp_protocol);
941 EXPORT_SYMBOL(isapnp_present);
942 EXPORT_SYMBOL(isapnp_cfg_begin);
943 EXPORT_SYMBOL(isapnp_cfg_end);
944 EXPORT_SYMBOL(isapnp_write_byte);
945
946 static int isapnp_read_resources(struct pnp_dev *dev,
947 struct pnp_resource_table *res)
948 {
949 int tmp, ret;
950
951 dev->active = isapnp_read_byte(ISAPNP_CFG_ACTIVATE);
952 if (dev->active) {
953 for (tmp = 0; tmp < ISAPNP_MAX_PORT; tmp++) {
954 ret = isapnp_read_word(ISAPNP_CFG_PORT + (tmp << 1));
955 if (!ret)
956 continue;
957 res->port_resource[tmp].start = ret;
958 res->port_resource[tmp].flags = IORESOURCE_IO;
959 }
960 for (tmp = 0; tmp < ISAPNP_MAX_MEM; tmp++) {
961 ret =
962 isapnp_read_word(ISAPNP_CFG_MEM + (tmp << 3)) << 8;
963 if (!ret)
964 continue;
965 res->mem_resource[tmp].start = ret;
966 res->mem_resource[tmp].flags = IORESOURCE_MEM;
967 }
968 for (tmp = 0; tmp < ISAPNP_MAX_IRQ; tmp++) {
969 ret =
970 (isapnp_read_word(ISAPNP_CFG_IRQ + (tmp << 1)) >>
971 8);
972 if (!ret)
973 continue;
974 res->irq_resource[tmp].start =
975 res->irq_resource[tmp].end = ret;
976 res->irq_resource[tmp].flags = IORESOURCE_IRQ;
977 }
978 for (tmp = 0; tmp < ISAPNP_MAX_DMA; tmp++) {
979 ret = isapnp_read_byte(ISAPNP_CFG_DMA + tmp);
980 if (ret == 4)
981 continue;
982 res->dma_resource[tmp].start =
983 res->dma_resource[tmp].end = ret;
984 res->dma_resource[tmp].flags = IORESOURCE_DMA;
985 }
986 }
987 return 0;
988 }
989
990 static int isapnp_get_resources(struct pnp_dev *dev,
991 struct pnp_resource_table *res)
992 {
993 int ret;
994
995 pnp_init_resource_table(res);
996 isapnp_cfg_begin(dev->card->number, dev->number);
997 ret = isapnp_read_resources(dev, res);
998 isapnp_cfg_end();
999 return ret;
1000 }
1001
1002 static int isapnp_set_resources(struct pnp_dev *dev,
1003 struct pnp_resource_table *res)
1004 {
1005 int tmp;
1006
1007 isapnp_cfg_begin(dev->card->number, dev->number);
1008 dev->active = 1;
1009 for (tmp = 0;
1010 tmp < ISAPNP_MAX_PORT
1011 && (res->port_resource[tmp].
1012 flags & (IORESOURCE_IO | IORESOURCE_UNSET)) == IORESOURCE_IO;
1013 tmp++)
1014 isapnp_write_word(ISAPNP_CFG_PORT + (tmp << 1),
1015 res->port_resource[tmp].start);
1016 for (tmp = 0;
1017 tmp < ISAPNP_MAX_IRQ
1018 && (res->irq_resource[tmp].
1019 flags & (IORESOURCE_IRQ | IORESOURCE_UNSET)) == IORESOURCE_IRQ;
1020 tmp++) {
1021 int irq = res->irq_resource[tmp].start;
1022 if (irq == 2)
1023 irq = 9;
1024 isapnp_write_byte(ISAPNP_CFG_IRQ + (tmp << 1), irq);
1025 }
1026 for (tmp = 0;
1027 tmp < ISAPNP_MAX_DMA
1028 && (res->dma_resource[tmp].
1029 flags & (IORESOURCE_DMA | IORESOURCE_UNSET)) == IORESOURCE_DMA;
1030 tmp++)
1031 isapnp_write_byte(ISAPNP_CFG_DMA + tmp,
1032 res->dma_resource[tmp].start);
1033 for (tmp = 0;
1034 tmp < ISAPNP_MAX_MEM
1035 && (res->mem_resource[tmp].
1036 flags & (IORESOURCE_MEM | IORESOURCE_UNSET)) == IORESOURCE_MEM;
1037 tmp++)
1038 isapnp_write_word(ISAPNP_CFG_MEM + (tmp << 3),
1039 (res->mem_resource[tmp].start >> 8) & 0xffff);
1040 /* FIXME: We aren't handling 32bit mems properly here */
1041 isapnp_activate(dev->number);
1042 isapnp_cfg_end();
1043 return 0;
1044 }
1045
1046 static int isapnp_disable_resources(struct pnp_dev *dev)
1047 {
1048 if (!dev->active)
1049 return -EINVAL;
1050 isapnp_cfg_begin(dev->card->number, dev->number);
1051 isapnp_deactivate(dev->number);
1052 dev->active = 0;
1053 isapnp_cfg_end();
1054 return 0;
1055 }
1056
1057 struct pnp_protocol isapnp_protocol = {
1058 .name = "ISA Plug and Play",
1059 .get = isapnp_get_resources,
1060 .set = isapnp_set_resources,
1061 .disable = isapnp_disable_resources,
1062 };
1063
1064 static int __init isapnp_init(void)
1065 {
1066 int cards;
1067 struct pnp_card *card;
1068 struct pnp_dev *dev;
1069
1070 if (isapnp_disable) {
1071 printk(KERN_INFO "isapnp: ISA Plug & Play support disabled\n");
1072 return 0;
1073 }
1074 #ifdef CONFIG_PPC_MERGE
1075 if (check_legacy_ioport(_PIDXR) || check_legacy_ioport(_PNPWRP))
1076 return -EINVAL;
1077 #endif
1078 #ifdef ISAPNP_REGION_OK
1079 if (!request_region(_PIDXR, 1, "isapnp index")) {
1080 printk(KERN_ERR "isapnp: Index Register 0x%x already used\n",
1081 _PIDXR);
1082 return -EBUSY;
1083 }
1084 #endif
1085 if (!request_region(_PNPWRP, 1, "isapnp write")) {
1086 printk(KERN_ERR
1087 "isapnp: Write Data Register 0x%x already used\n",
1088 _PNPWRP);
1089 #ifdef ISAPNP_REGION_OK
1090 release_region(_PIDXR, 1);
1091 #endif
1092 return -EBUSY;
1093 }
1094
1095 if (pnp_register_protocol(&isapnp_protocol) < 0)
1096 return -EBUSY;
1097
1098 /*
1099 * Print a message. The existing ISAPnP code is hanging machines
1100 * so let the user know where.
1101 */
1102
1103 printk(KERN_INFO "isapnp: Scanning for PnP cards...\n");
1104 if (isapnp_rdp >= 0x203 && isapnp_rdp <= 0x3ff) {
1105 isapnp_rdp |= 3;
1106 if (!request_region(isapnp_rdp, 1, "isapnp read")) {
1107 printk(KERN_ERR
1108 "isapnp: Read Data Register 0x%x already used\n",
1109 isapnp_rdp);
1110 #ifdef ISAPNP_REGION_OK
1111 release_region(_PIDXR, 1);
1112 #endif
1113 release_region(_PNPWRP, 1);
1114 return -EBUSY;
1115 }
1116 isapnp_set_rdp();
1117 }
1118 if (isapnp_rdp < 0x203 || isapnp_rdp > 0x3ff) {
1119 cards = isapnp_isolate();
1120 if (cards < 0 || (isapnp_rdp < 0x203 || isapnp_rdp > 0x3ff)) {
1121 #ifdef ISAPNP_REGION_OK
1122 release_region(_PIDXR, 1);
1123 #endif
1124 release_region(_PNPWRP, 1);
1125 printk(KERN_INFO
1126 "isapnp: No Plug & Play device found\n");
1127 return 0;
1128 }
1129 request_region(isapnp_rdp, 1, "isapnp read");
1130 }
1131 isapnp_build_device_list();
1132 cards = 0;
1133
1134 protocol_for_each_card(&isapnp_protocol, card) {
1135 cards++;
1136 if (isapnp_verbose) {
1137 printk(KERN_INFO "isapnp: Card '%s'\n",
1138 card->name[0] ? card->name : "Unknown");
1139 if (isapnp_verbose < 2)
1140 continue;
1141 card_for_each_dev(card, dev) {
1142 printk(KERN_INFO "isapnp: Device '%s'\n",
1143 dev->name[0] ? dev->name : "Unknown");
1144 }
1145 }
1146 }
1147 if (cards)
1148 printk(KERN_INFO
1149 "isapnp: %i Plug & Play card%s detected total\n", cards,
1150 cards > 1 ? "s" : "");
1151 else
1152 printk(KERN_INFO "isapnp: No Plug & Play card found\n");
1153
1154 isapnp_proc_init();
1155 return 0;
1156 }
1157
1158 device_initcall(isapnp_init);
1159
1160 /* format is: noisapnp */
1161
1162 static int __init isapnp_setup_disable(char *str)
1163 {
1164 isapnp_disable = 1;
1165 return 1;
1166 }
1167
1168 __setup("noisapnp", isapnp_setup_disable);
1169
1170 /* format is: isapnp=rdp,reset,skip_pci_scan,verbose */
1171
1172 static int __init isapnp_setup_isapnp(char *str)
1173 {
1174 (void)((get_option(&str, &isapnp_rdp) == 2) &&
1175 (get_option(&str, &isapnp_reset) == 2) &&
1176 (get_option(&str, &isapnp_verbose) == 2));
1177 return 1;
1178 }
1179
1180 __setup("isapnp=", isapnp_setup_isapnp);
Linus' kernel tree