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