?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
PNP: make generic pnp_add_irq_resource()
[linux-2.6/sactl.git] / drivers / pnp / isapnp / core.c
blob2cf750f077a41aef4caf3b19975eb860d7587e0d
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 eisa_id = tmp[0] | tmp[1] << 8 | tmp[2] << 16 | tmp[3] << 24;
413 pnp_eisa_id_to_string(eisa_id, id);
414
415 dev = pnp_alloc_dev(&isapnp_protocol, number, id);
416 if (!dev)
417 return NULL;
418
419 dev->regs = tmp[4];
420 dev->card = card;
421 if (size > 5)
422 dev->regs |= tmp[5] << 8;
423 dev->capabilities |= PNP_CONFIGURABLE;
424 dev->capabilities |= PNP_READ;
425 dev->capabilities |= PNP_WRITE;
426 dev->capabilities |= PNP_DISABLE;
427 pnp_init_resources(dev);
428 return dev;
429 }
430
431 /*
432 * Add IRQ resource to resources list.
433 */
434 static void __init isapnp_parse_irq_resource(struct pnp_dev *dev,
435 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(dev, option, irq);
453 }
454
455 /*
456 * Add DMA resource to resources list.
457 */
458 static void __init isapnp_parse_dma_resource(struct pnp_dev *dev,
459 struct pnp_option *option,
460 int size)
461 {
462 unsigned char tmp[2];
463 struct pnp_dma *dma;
464
465 isapnp_peek(tmp, size);
466 dma = kzalloc(sizeof(struct pnp_dma), GFP_KERNEL);
467 if (!dma)
468 return;
469 dma->map = tmp[0];
470 dma->flags = tmp[1];
471 pnp_register_dma_resource(dev, option, dma);
472 }
473
474 /*
475 * Add port resource to resources list.
476 */
477 static void __init isapnp_parse_port_resource(struct pnp_dev *dev,
478 struct pnp_option *option,
479 int size)
480 {
481 unsigned char tmp[7];
482 struct pnp_port *port;
483
484 isapnp_peek(tmp, size);
485 port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL);
486 if (!port)
487 return;
488 port->min = (tmp[2] << 8) | tmp[1];
489 port->max = (tmp[4] << 8) | tmp[3];
490 port->align = tmp[5];
491 port->size = tmp[6];
492 port->flags = tmp[0] ? PNP_PORT_FLAG_16BITADDR : 0;
493 pnp_register_port_resource(dev, option, port);
494 }
495
496 /*
497 * Add fixed port resource to resources list.
498 */
499 static void __init isapnp_parse_fixed_port_resource(struct pnp_dev *dev,
500 struct pnp_option *option,
501 int size)
502 {
503 unsigned char tmp[3];
504 struct pnp_port *port;
505
506 isapnp_peek(tmp, size);
507 port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL);
508 if (!port)
509 return;
510 port->min = port->max = (tmp[1] << 8) | tmp[0];
511 port->size = tmp[2];
512 port->align = 0;
513 port->flags = PNP_PORT_FLAG_FIXED;
514 pnp_register_port_resource(dev, option, port);
515 }
516
517 /*
518 * Add memory resource to resources list.
519 */
520 static void __init isapnp_parse_mem_resource(struct pnp_dev *dev,
521 struct pnp_option *option,
522 int size)
523 {
524 unsigned char tmp[9];
525 struct pnp_mem *mem;
526
527 isapnp_peek(tmp, size);
528 mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
529 if (!mem)
530 return;
531 mem->min = ((tmp[2] << 8) | tmp[1]) << 8;
532 mem->max = ((tmp[4] << 8) | tmp[3]) << 8;
533 mem->align = (tmp[6] << 8) | tmp[5];
534 mem->size = ((tmp[8] << 8) | tmp[7]) << 8;
535 mem->flags = tmp[0];
536 pnp_register_mem_resource(dev, option, mem);
537 }
538
539 /*
540 * Add 32-bit memory resource to resources list.
541 */
542 static void __init isapnp_parse_mem32_resource(struct pnp_dev *dev,
543 struct pnp_option *option,
544 int size)
545 {
546 unsigned char tmp[17];
547 struct pnp_mem *mem;
548
549 isapnp_peek(tmp, size);
550 mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
551 if (!mem)
552 return;
553 mem->min = (tmp[4] << 24) | (tmp[3] << 16) | (tmp[2] << 8) | tmp[1];
554 mem->max = (tmp[8] << 24) | (tmp[7] << 16) | (tmp[6] << 8) | tmp[5];
555 mem->align =
556 (tmp[12] << 24) | (tmp[11] << 16) | (tmp[10] << 8) | tmp[9];
557 mem->size =
558 (tmp[16] << 24) | (tmp[15] << 16) | (tmp[14] << 8) | tmp[13];
559 mem->flags = tmp[0];
560 pnp_register_mem_resource(dev, option, mem);
561 }
562
563 /*
564 * Add 32-bit fixed memory resource to resources list.
565 */
566 static void __init isapnp_parse_fixed_mem32_resource(struct pnp_dev *dev,
567 struct pnp_option *option,
568 int size)
569 {
570 unsigned char tmp[9];
571 struct pnp_mem *mem;
572
573 isapnp_peek(tmp, size);
574 mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
575 if (!mem)
576 return;
577 mem->min = mem->max =
578 (tmp[4] << 24) | (tmp[3] << 16) | (tmp[2] << 8) | tmp[1];
579 mem->size = (tmp[8] << 24) | (tmp[7] << 16) | (tmp[6] << 8) | tmp[5];
580 mem->align = 0;
581 mem->flags = tmp[0];
582 pnp_register_mem_resource(dev, option, mem);
583 }
584
585 /*
586 * Parse card name for ISA PnP device.
587 */
588 static void __init
589 isapnp_parse_name(char *name, unsigned int name_max, unsigned short *size)
590 {
591 if (name[0] == '\0') {
592 unsigned short size1 =
593 *size >= name_max ? (name_max - 1) : *size;
594 isapnp_peek(name, size1);
595 name[size1] = '\0';
596 *size -= size1;
597
598 /* clean whitespace from end of string */
599 while (size1 > 0 && name[--size1] == ' ')
600 name[size1] = '\0';
601 }
602 }
603
604 /*
605 * Parse resource map for logical device.
606 */
607 static int __init isapnp_create_device(struct pnp_card *card,
608 unsigned short size)
609 {
610 int number = 0, skip = 0, priority = 0, compat = 0;
611 unsigned char type, tmp[17];
612 struct pnp_option *option;
613 struct pnp_dev *dev;
614 u32 eisa_id;
615 char id[8];
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 eisa_id = tmp[0] | tmp[1] << 8 |
656 tmp[2] << 16 | tmp[3] << 24;
657 pnp_eisa_id_to_string(eisa_id, id);
658 pnp_add_id(dev, id);
659 compat++;
660 size = 0;
661 }
662 break;
663 case _STAG_IRQ:
664 if (size < 2 || size > 3)
665 goto __skip;
666 isapnp_parse_irq_resource(dev, option, size);
667 size = 0;
668 break;
669 case _STAG_DMA:
670 if (size != 2)
671 goto __skip;
672 isapnp_parse_dma_resource(dev, option, size);
673 size = 0;
674 break;
675 case _STAG_STARTDEP:
676 if (size > 1)
677 goto __skip;
678 priority = 0x100 | PNP_RES_PRIORITY_ACCEPTABLE;
679 if (size > 0) {
680 isapnp_peek(tmp, size);
681 priority = 0x100 | tmp[0];
682 size = 0;
683 }
684 option = pnp_register_dependent_option(dev, priority);
685 if (!option)
686 return 1;
687 break;
688 case _STAG_ENDDEP:
689 if (size != 0)
690 goto __skip;
691 priority = 0;
692 dev_dbg(&dev->dev, "end dependent options\n");
693 break;
694 case _STAG_IOPORT:
695 if (size != 7)
696 goto __skip;
697 isapnp_parse_port_resource(dev, option, size);
698 size = 0;
699 break;
700 case _STAG_FIXEDIO:
701 if (size != 3)
702 goto __skip;
703 isapnp_parse_fixed_port_resource(dev, option, size);
704 size = 0;
705 break;
706 case _STAG_VENDOR:
707 break;
708 case _LTAG_MEMRANGE:
709 if (size != 9)
710 goto __skip;
711 isapnp_parse_mem_resource(dev, option, size);
712 size = 0;
713 break;
714 case _LTAG_ANSISTR:
715 isapnp_parse_name(dev->name, sizeof(dev->name), &size);
716 break;
717 case _LTAG_UNICODESTR:
718 /* silently ignore */
719 /* who use unicode for hardware identification? */
720 break;
721 case _LTAG_VENDOR:
722 break;
723 case _LTAG_MEM32RANGE:
724 if (size != 17)
725 goto __skip;
726 isapnp_parse_mem32_resource(dev, option, size);
727 size = 0;
728 break;
729 case _LTAG_FIXEDMEM32RANGE:
730 if (size != 9)
731 goto __skip;
732 isapnp_parse_fixed_mem32_resource(dev, option, size);
733 size = 0;
734 break;
735 case _STAG_END:
736 if (size > 0)
737 isapnp_skip_bytes(size);
738 return 1;
739 default:
740 dev_err(&dev->dev, "unknown tag %#x (card %i), "
741 "ignored\n", type, card->number);
742 }
743 __skip:
744 if (size > 0)
745 isapnp_skip_bytes(size);
746 }
747 return 0;
748 }
749
750 /*
751 * Parse resource map for ISA PnP card.
752 */
753 static void __init isapnp_parse_resource_map(struct pnp_card *card)
754 {
755 unsigned char type, tmp[17];
756 unsigned short size;
757
758 while (1) {
759 if (isapnp_read_tag(&type, &size) < 0)
760 return;
761 switch (type) {
762 case _STAG_PNPVERNO:
763 if (size != 2)
764 goto __skip;
765 isapnp_peek(tmp, 2);
766 card->pnpver = tmp[0];
767 card->productver = tmp[1];
768 size = 0;
769 break;
770 case _STAG_LOGDEVID:
771 if (size >= 5 && size <= 6) {
772 if (isapnp_create_device(card, size) == 1)
773 return;
774 size = 0;
775 }
776 break;
777 case _STAG_VENDOR:
778 break;
779 case _LTAG_ANSISTR:
780 isapnp_parse_name(card->name, sizeof(card->name),
781 &size);
782 break;
783 case _LTAG_UNICODESTR:
784 /* silently ignore */
785 /* who use unicode for hardware identification? */
786 break;
787 case _LTAG_VENDOR:
788 break;
789 case _STAG_END:
790 if (size > 0)
791 isapnp_skip_bytes(size);
792 return;
793 default:
794 dev_err(&card->dev, "unknown tag %#x, ignored\n",
795 type);
796 }
797 __skip:
798 if (size > 0)
799 isapnp_skip_bytes(size);
800 }
801 }
802
803 /*
804 * Compute ISA PnP checksum for first eight bytes.
805 */
806 static unsigned char __init isapnp_checksum(unsigned char *data)
807 {
808 int i, j;
809 unsigned char checksum = 0x6a, bit, b;
810
811 for (i = 0; i < 8; i++) {
812 b = data[i];
813 for (j = 0; j < 8; j++) {
814 bit = 0;
815 if (b & (1 << j))
816 bit = 1;
817 checksum =
818 ((((checksum ^ (checksum >> 1)) & 0x01) ^ bit) << 7)
819 | (checksum >> 1);
820 }
821 }
822 return checksum;
823 }
824
825 /*
826 * Build device list for all present ISA PnP devices.
827 */
828 static int __init isapnp_build_device_list(void)
829 {
830 int csn;
831 unsigned char header[9], checksum;
832 struct pnp_card *card;
833 u32 eisa_id;
834 char id[8];
835
836 isapnp_wait();
837 isapnp_key();
838 for (csn = 1; csn <= isapnp_csn_count; csn++) {
839 isapnp_wake(csn);
840 isapnp_peek(header, 9);
841 checksum = isapnp_checksum(header);
842 eisa_id = header[0] | header[1] << 8 |
843 header[2] << 16 | header[3] << 24;
844 pnp_eisa_id_to_string(eisa_id, id);
845 card = pnp_alloc_card(&isapnp_protocol, csn, id);
846 if (!card)
847 continue;
848
849 #if 0
850 dev_info(&card->dev,
851 "vendor: %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n",
852 header[0], header[1], header[2], header[3], header[4],
853 header[5], header[6], header[7], header[8]);
854 dev_info(&card->dev, "checksum = %#x\n", checksum);
855 #endif
856 INIT_LIST_HEAD(&card->devices);
857 card->serial =
858 (header[7] << 24) | (header[6] << 16) | (header[5] << 8) |
859 header[4];
860 isapnp_checksum_value = 0x00;
861 isapnp_parse_resource_map(card);
862 if (isapnp_checksum_value != 0x00)
863 dev_err(&card->dev, "invalid checksum %#x\n",
864 isapnp_checksum_value);
865 card->checksum = isapnp_checksum_value;
866
867 pnp_add_card(card);
868 }
869 isapnp_wait();
870 return 0;
871 }
872
873 /*
874 * Basic configuration routines.
875 */
876
877 int isapnp_present(void)
878 {
879 struct pnp_card *card;
880
881 pnp_for_each_card(card) {
882 if (card->protocol == &isapnp_protocol)
883 return 1;
884 }
885 return 0;
886 }
887
888 int isapnp_cfg_begin(int csn, int logdev)
889 {
890 if (csn < 1 || csn > isapnp_csn_count || logdev > 10)
891 return -EINVAL;
892 mutex_lock(&isapnp_cfg_mutex);
893 isapnp_wait();
894 isapnp_key();
895 isapnp_wake(csn);
896 #if 0
897 /* to avoid malfunction when the isapnptools package is used */
898 /* we must set RDP to our value again */
899 /* it is possible to set RDP only in the isolation phase */
900 /* Jens Thoms Toerring <Jens.Toerring@physik.fu-berlin.de> */
901 isapnp_write_byte(0x02, 0x04); /* clear CSN of card */
902 mdelay(2); /* is this necessary? */
903 isapnp_wake(csn); /* bring card into sleep state */
904 isapnp_wake(0); /* bring card into isolation state */
905 isapnp_set_rdp(); /* reset the RDP port */
906 udelay(1000); /* delay 1000us */
907 isapnp_write_byte(0x06, csn); /* reset CSN to previous value */
908 udelay(250); /* is this necessary? */
909 #endif
910 if (logdev >= 0)
911 isapnp_device(logdev);
912 return 0;
913 }
914
915 int isapnp_cfg_end(void)
916 {
917 isapnp_wait();
918 mutex_unlock(&isapnp_cfg_mutex);
919 return 0;
920 }
921
922 /*
923 * Initialization.
924 */
925
926 EXPORT_SYMBOL(isapnp_protocol);
927 EXPORT_SYMBOL(isapnp_present);
928 EXPORT_SYMBOL(isapnp_cfg_begin);
929 EXPORT_SYMBOL(isapnp_cfg_end);
930 EXPORT_SYMBOL(isapnp_write_byte);
931
932 static int isapnp_read_resources(struct pnp_dev *dev)
933 {
934 struct pnp_resource *pnp_res;
935 struct resource *res;
936 int tmp, ret;
937
938 dev->active = isapnp_read_byte(ISAPNP_CFG_ACTIVATE);
939 if (dev->active) {
940 for (tmp = 0; tmp < ISAPNP_MAX_PORT; tmp++) {
941 ret = isapnp_read_word(ISAPNP_CFG_PORT + (tmp << 1));
942 if (!ret)
943 continue;
944 pnp_res = pnp_get_pnp_resource(dev, IORESOURCE_IO, tmp);
945 pnp_res->index = tmp;
946 res = &pnp_res->res;
947 res->start = ret;
948 res->flags = IORESOURCE_IO;
949 }
950 for (tmp = 0; tmp < ISAPNP_MAX_MEM; tmp++) {
951 ret =
952 isapnp_read_word(ISAPNP_CFG_MEM + (tmp << 3)) << 8;
953 if (!ret)
954 continue;
955 pnp_res = pnp_get_pnp_resource(dev, IORESOURCE_MEM,
956 tmp);
957 pnp_res->index = tmp;
958 res = &pnp_res->res;
959 res->start = ret;
960 res->flags = IORESOURCE_MEM;
961 }
962 for (tmp = 0; tmp < ISAPNP_MAX_IRQ; tmp++) {
963 ret =
964 (isapnp_read_word(ISAPNP_CFG_IRQ + (tmp << 1)) >>
965 8);
966 if (!ret)
967 continue;
968 pnp_res = pnp_add_irq_resource(dev, ret, 0);
969 if (pnp_res)
970 pnp_res->index = tmp;
971 }
972 for (tmp = 0; tmp < ISAPNP_MAX_DMA; tmp++) {
973 ret = isapnp_read_byte(ISAPNP_CFG_DMA + tmp);
974 if (ret == 4)
975 continue;
976 pnp_res = pnp_get_pnp_resource(dev, IORESOURCE_DMA,
977 tmp);
978 pnp_res->index = tmp;
979 res = &pnp_res->res;
980 res->start = res->end = ret;
981 res->flags = IORESOURCE_DMA;
982 }
983 }
984 return 0;
985 }
986
987 static int isapnp_get_resources(struct pnp_dev *dev)
988 {
989 int ret;
990
991 dev_dbg(&dev->dev, "get resources\n");
992 pnp_init_resources(dev);
993 isapnp_cfg_begin(dev->card->number, dev->number);
994 ret = isapnp_read_resources(dev);
995 isapnp_cfg_end();
996 return ret;
997 }
998
999 static int isapnp_set_resources(struct pnp_dev *dev)
1000 {
1001 struct pnp_resource *pnp_res;
1002 struct resource *res;
1003 int tmp, index;
1004
1005 dev_dbg(&dev->dev, "set resources\n");
1006 isapnp_cfg_begin(dev->card->number, dev->number);
1007 dev->active = 1;
1008 for (tmp = 0; tmp < ISAPNP_MAX_PORT; tmp++) {
1009 pnp_res = pnp_get_pnp_resource(dev, IORESOURCE_IO, tmp);
1010 if (!pnp_res)
1011 continue;
1012 res = &pnp_res->res;
1013 if (pnp_resource_valid(res)) {
1014 index = pnp_res->index;
1015 dev_dbg(&dev->dev, " set io %d to %#llx\n",
1016 index, (unsigned long long) res->start);
1017 isapnp_write_word(ISAPNP_CFG_PORT + (index << 1),
1018 res->start);
1019 }
1020 }
1021 for (tmp = 0; tmp < ISAPNP_MAX_IRQ; tmp++) {
1022 pnp_res = pnp_get_pnp_resource(dev, IORESOURCE_IRQ, tmp);
1023 if (!pnp_res)
1024 continue;
1025 res = &pnp_res->res;
1026 if (pnp_resource_valid(res)) {
1027 int irq = res->start;
1028 if (irq == 2)
1029 irq = 9;
1030 index = pnp_res->index;
1031 dev_dbg(&dev->dev, " set irq %d to %d\n", index, irq);
1032 isapnp_write_byte(ISAPNP_CFG_IRQ + (index << 1), irq);
1033 }
1034 }
1035 for (tmp = 0; tmp < ISAPNP_MAX_DMA; tmp++) {
1036 pnp_res = pnp_get_pnp_resource(dev, IORESOURCE_DMA, tmp);
1037 if (!pnp_res)
1038 continue;
1039 res = &pnp_res->res;
1040 if (pnp_resource_valid(res)) {
1041 index = pnp_res->index;
1042 dev_dbg(&dev->dev, " set dma %d to %lld\n",
1043 index, (unsigned long long) res->start);
1044 isapnp_write_byte(ISAPNP_CFG_DMA + index, res->start);
1045 }
1046 }
1047 for (tmp = 0; tmp < ISAPNP_MAX_MEM; tmp++) {
1048 pnp_res = pnp_get_pnp_resource(dev, IORESOURCE_MEM, tmp);
1049 if (!pnp_res)
1050 continue;
1051 res = &pnp_res->res;
1052 if (pnp_resource_valid(res)) {
1053 index = pnp_res->index;
1054 dev_dbg(&dev->dev, " set mem %d to %#llx\n",
1055 index, (unsigned long long) res->start);
1056 isapnp_write_word(ISAPNP_CFG_MEM + (index << 3),
1057 (res->start >> 8) & 0xffff);
1058 }
1059 }
1060 /* FIXME: We aren't handling 32bit mems properly here */
1061 isapnp_activate(dev->number);
1062 isapnp_cfg_end();
1063 return 0;
1064 }
1065
1066 static int isapnp_disable_resources(struct pnp_dev *dev)
1067 {
1068 if (!dev->active)
1069 return -EINVAL;
1070 isapnp_cfg_begin(dev->card->number, dev->number);
1071 isapnp_deactivate(dev->number);
1072 dev->active = 0;
1073 isapnp_cfg_end();
1074 return 0;
1075 }
1076
1077 struct pnp_protocol isapnp_protocol = {
1078 .name = "ISA Plug and Play",
1079 .get = isapnp_get_resources,
1080 .set = isapnp_set_resources,
1081 .disable = isapnp_disable_resources,
1082 };
1083
1084 static int __init isapnp_init(void)
1085 {
1086 int cards;
1087 struct pnp_card *card;
1088 struct pnp_dev *dev;
1089
1090 if (isapnp_disable) {
1091 printk(KERN_INFO "isapnp: ISA Plug & Play support disabled\n");
1092 return 0;
1093 }
1094 #ifdef CONFIG_PPC_MERGE
1095 if (check_legacy_ioport(_PIDXR) || check_legacy_ioport(_PNPWRP))
1096 return -EINVAL;
1097 #endif
1098 #ifdef ISAPNP_REGION_OK
1099 if (!request_region(_PIDXR, 1, "isapnp index")) {
1100 printk(KERN_ERR "isapnp: Index Register 0x%x already used\n",
1101 _PIDXR);
1102 return -EBUSY;
1103 }
1104 #endif
1105 if (!request_region(_PNPWRP, 1, "isapnp write")) {
1106 printk(KERN_ERR
1107 "isapnp: Write Data Register 0x%x already used\n",
1108 _PNPWRP);
1109 #ifdef ISAPNP_REGION_OK
1110 release_region(_PIDXR, 1);
1111 #endif
1112 return -EBUSY;
1113 }
1114
1115 if (pnp_register_protocol(&isapnp_protocol) < 0)
1116 return -EBUSY;
1117
1118 /*
1119 * Print a message. The existing ISAPnP code is hanging machines
1120 * so let the user know where.
1121 */
1122
1123 printk(KERN_INFO "isapnp: Scanning for PnP cards...\n");
1124 if (isapnp_rdp >= 0x203 && isapnp_rdp <= 0x3ff) {
1125 isapnp_rdp |= 3;
1126 if (!request_region(isapnp_rdp, 1, "isapnp read")) {
1127 printk(KERN_ERR
1128 "isapnp: Read Data Register 0x%x already used\n",
1129 isapnp_rdp);
1130 #ifdef ISAPNP_REGION_OK
1131 release_region(_PIDXR, 1);
1132 #endif
1133 release_region(_PNPWRP, 1);
1134 return -EBUSY;
1135 }
1136 isapnp_set_rdp();
1137 }
1138 if (isapnp_rdp < 0x203 || isapnp_rdp > 0x3ff) {
1139 cards = isapnp_isolate();
1140 if (cards < 0 || (isapnp_rdp < 0x203 || isapnp_rdp > 0x3ff)) {
1141 #ifdef ISAPNP_REGION_OK
1142 release_region(_PIDXR, 1);
1143 #endif
1144 release_region(_PNPWRP, 1);
1145 printk(KERN_INFO
1146 "isapnp: No Plug & Play device found\n");
1147 return 0;
1148 }
1149 request_region(isapnp_rdp, 1, "isapnp read");
1150 }
1151 isapnp_build_device_list();
1152 cards = 0;
1153
1154 protocol_for_each_card(&isapnp_protocol, card) {
1155 cards++;
1156 if (isapnp_verbose) {
1157 dev_info(&card->dev, "card '%s'\n",
1158 card->name[0] ? card->name : "unknown");
1159 if (isapnp_verbose < 2)
1160 continue;
1161 card_for_each_dev(card, dev) {
1162 dev_info(&card->dev, "device '%s'\n",
1163 dev->name[0] ? dev->name : "unknown");
1164 }
1165 }
1166 }
1167 if (cards)
1168 printk(KERN_INFO
1169 "isapnp: %i Plug & Play card%s detected total\n", cards,
1170 cards > 1 ? "s" : "");
1171 else
1172 printk(KERN_INFO "isapnp: No Plug & Play card found\n");
1173
1174 isapnp_proc_init();
1175 return 0;
1176 }
1177
1178 device_initcall(isapnp_init);
1179
1180 /* format is: noisapnp */
1181
1182 static int __init isapnp_setup_disable(char *str)
1183 {
1184 isapnp_disable = 1;
1185 return 1;
1186 }
1187
1188 __setup("noisapnp", isapnp_setup_disable);
1189
1190 /* format is: isapnp=rdp,reset,skip_pci_scan,verbose */
1191
1192 static int __init isapnp_setup_isapnp(char *str)
1193 {
1194 (void)((get_option(&str, &isapnp_rdp) == 2) &&
1195 (get_option(&str, &isapnp_reset) == 2) &&
1196 (get_option(&str, &isapnp_verbose) == 2));
1197 return 1;
1198 }
1199
1200 __setup("isapnp=", isapnp_setup_isapnp);
SocketAccessConTroL development