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