2 * rsparser.c - parses and encodes pnpbios resource data streams
5 #include <linux/ctype.h>
7 #include <linux/pnpbios.h>
8 #include <linux/string.h>
9 #include <linux/slab.h>
12 #include <linux/pci.h>
14 inline void pcibios_penalize_isa_irq(int irq, int active)
17 #endif /* CONFIG_PCI */
22 /* standard resource tags */
23 #define SMALL_TAG_PNPVERNO 0x01
24 #define SMALL_TAG_LOGDEVID 0x02
25 #define SMALL_TAG_COMPATDEVID 0x03
26 #define SMALL_TAG_IRQ 0x04
27 #define SMALL_TAG_DMA 0x05
28 #define SMALL_TAG_STARTDEP 0x06
29 #define SMALL_TAG_ENDDEP 0x07
30 #define SMALL_TAG_PORT 0x08
31 #define SMALL_TAG_FIXEDPORT 0x09
32 #define SMALL_TAG_VENDOR 0x0e
33 #define SMALL_TAG_END 0x0f
34 #define LARGE_TAG 0x80
35 #define LARGE_TAG_MEM 0x81
36 #define LARGE_TAG_ANSISTR 0x82
37 #define LARGE_TAG_UNICODESTR 0x83
38 #define LARGE_TAG_VENDOR 0x84
39 #define LARGE_TAG_MEM32 0x85
40 #define LARGE_TAG_FIXEDMEM32 0x86
43 * Resource Data Stream Format:
45 * Allocated Resources (required)
47 * Resource Configuration Options (optional)
49 * Compitable Device IDs (optional)
57 static void pnpbios_parse_allocated_irqresource(struct pnp_dev *dev, int irq)
62 for (i = 0; i < PNP_MAX_IRQ; i++) {
63 res = pnp_get_resource(dev, IORESOURCE_IRQ, i);
64 if (!pnp_resource_valid(res))
68 if (i < PNP_MAX_IRQ) {
69 res->flags = IORESOURCE_IRQ; // Also clears _UNSET flag
71 res->flags |= IORESOURCE_DISABLED;
74 res->start = res->end = (unsigned long)irq;
75 pcibios_penalize_isa_irq(irq, 1);
79 static void pnpbios_parse_allocated_dmaresource(struct pnp_dev *dev, int dma)
84 for (i = 0; i < PNP_MAX_DMA; i++) {
85 res = pnp_get_resource(dev, IORESOURCE_DMA, i);
86 if (!pnp_resource_valid(res))
90 if (i < PNP_MAX_DMA) {
91 res->flags = IORESOURCE_DMA; // Also clears _UNSET flag
93 res->flags |= IORESOURCE_DISABLED;
96 res->start = res->end = (unsigned long)dma;
100 static void pnpbios_parse_allocated_ioresource(struct pnp_dev *dev,
103 struct resource *res;
106 for (i = 0; i < PNP_MAX_PORT; i++) {
107 res = pnp_get_resource(dev, IORESOURCE_IO, i);
108 if (!pnp_resource_valid(res))
112 if (i < PNP_MAX_PORT) {
113 res->flags = IORESOURCE_IO; // Also clears _UNSET flag
114 if (len <= 0 || (io + len - 1) >= 0x10003) {
115 res->flags |= IORESOURCE_DISABLED;
118 res->start = (unsigned long)io;
119 res->end = (unsigned long)(io + len - 1);
123 static void pnpbios_parse_allocated_memresource(struct pnp_dev *dev,
126 struct resource *res;
129 for (i = 0; i < PNP_MAX_MEM; i++) {
130 res = pnp_get_resource(dev, IORESOURCE_MEM, i);
131 if (!pnp_resource_valid(res))
135 if (i < PNP_MAX_MEM) {
136 res->flags = IORESOURCE_MEM; // Also clears _UNSET flag
138 res->flags |= IORESOURCE_DISABLED;
141 res->start = (unsigned long)mem;
142 res->end = (unsigned long)(mem + len - 1);
146 static unsigned char *pnpbios_parse_allocated_resource_data(struct pnp_dev *dev,
150 unsigned int len, tag;
151 int io, size, mask, i;
156 dev_dbg(&dev->dev, "parse allocated resources\n");
158 pnp_init_resources(dev);
160 while ((char *)p < (char *)end) {
162 /* determine the type of tag */
163 if (p[0] & LARGE_TAG) { /* large tag */
164 len = (p[2] << 8) | p[1];
166 } else { /* small tag */
168 tag = ((p[0] >> 3) & 0x0f);
176 io = *(short *)&p[4];
177 size = *(short *)&p[10];
178 pnpbios_parse_allocated_memresource(dev, io, size);
181 case LARGE_TAG_ANSISTR:
182 /* ignore this for now */
185 case LARGE_TAG_VENDOR:
189 case LARGE_TAG_MEM32:
193 size = *(int *)&p[16];
194 pnpbios_parse_allocated_memresource(dev, io, size);
197 case LARGE_TAG_FIXEDMEM32:
201 size = *(int *)&p[8];
202 pnpbios_parse_allocated_memresource(dev, io, size);
206 if (len < 2 || len > 3)
209 mask = p[1] + p[2] * 256;
210 for (i = 0; i < 16; i++, mask = mask >> 1)
213 pnpbios_parse_allocated_irqresource(dev, io);
221 for (i = 0; i < 8; i++, mask = mask >> 1)
224 pnpbios_parse_allocated_dmaresource(dev, io);
230 io = p[2] + p[3] * 256;
232 pnpbios_parse_allocated_ioresource(dev, io, size);
235 case SMALL_TAG_VENDOR:
239 case SMALL_TAG_FIXEDPORT:
242 io = p[1] + p[2] * 256;
244 pnpbios_parse_allocated_ioresource(dev, io, size);
249 return (unsigned char *)p;
252 default: /* an unkown tag */
254 dev_err(&dev->dev, "unknown tag %#x length %d\n",
259 /* continue to the next tag */
260 if (p[0] & LARGE_TAG)
266 dev_err(&dev->dev, "no end tag in resource structure\n");
272 * Resource Configuration Options
275 static __init void pnpbios_parse_mem_option(struct pnp_dev *dev,
276 unsigned char *p, int size,
277 struct pnp_option *option)
281 mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
284 mem->min = ((p[5] << 8) | p[4]) << 8;
285 mem->max = ((p[7] << 8) | p[6]) << 8;
286 mem->align = (p[9] << 8) | p[8];
287 mem->size = ((p[11] << 8) | p[10]) << 8;
289 pnp_register_mem_resource(dev, option, mem);
292 static __init void pnpbios_parse_mem32_option(struct pnp_dev *dev,
293 unsigned char *p, int size,
294 struct pnp_option *option)
298 mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
301 mem->min = (p[7] << 24) | (p[6] << 16) | (p[5] << 8) | p[4];
302 mem->max = (p[11] << 24) | (p[10] << 16) | (p[9] << 8) | p[8];
303 mem->align = (p[15] << 24) | (p[14] << 16) | (p[13] << 8) | p[12];
304 mem->size = (p[19] << 24) | (p[18] << 16) | (p[17] << 8) | p[16];
306 pnp_register_mem_resource(dev, option, mem);
309 static __init void pnpbios_parse_fixed_mem32_option(struct pnp_dev *dev,
310 unsigned char *p, int size,
311 struct pnp_option *option)
315 mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
318 mem->min = mem->max = (p[7] << 24) | (p[6] << 16) | (p[5] << 8) | p[4];
319 mem->size = (p[11] << 24) | (p[10] << 16) | (p[9] << 8) | p[8];
322 pnp_register_mem_resource(dev, option, mem);
325 static __init void pnpbios_parse_irq_option(struct pnp_dev *dev,
326 unsigned char *p, int size,
327 struct pnp_option *option)
332 irq = kzalloc(sizeof(struct pnp_irq), GFP_KERNEL);
335 bits = (p[2] << 8) | p[1];
336 bitmap_copy(irq->map, &bits, 16);
340 irq->flags = IORESOURCE_IRQ_HIGHEDGE;
341 pnp_register_irq_resource(dev, option, irq);
344 static __init void pnpbios_parse_dma_option(struct pnp_dev *dev,
345 unsigned char *p, int size,
346 struct pnp_option *option)
350 dma = kzalloc(sizeof(struct pnp_dma), GFP_KERNEL);
355 pnp_register_dma_resource(dev, option, dma);
358 static __init void pnpbios_parse_port_option(struct pnp_dev *dev,
359 unsigned char *p, int size,
360 struct pnp_option *option)
362 struct pnp_port *port;
364 port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL);
367 port->min = (p[3] << 8) | p[2];
368 port->max = (p[5] << 8) | p[4];
371 port->flags = p[1] ? PNP_PORT_FLAG_16BITADDR : 0;
372 pnp_register_port_resource(dev, option, port);
375 static __init void pnpbios_parse_fixed_port_option(struct pnp_dev *dev,
376 unsigned char *p, int size,
377 struct pnp_option *option)
379 struct pnp_port *port;
381 port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL);
384 port->min = port->max = (p[2] << 8) | p[1];
387 port->flags = PNP_PORT_FLAG_FIXED;
388 pnp_register_port_resource(dev, option, port);
391 static __init unsigned char *
392 pnpbios_parse_resource_option_data(unsigned char *p, unsigned char *end,
395 unsigned int len, tag;
397 struct pnp_option *option, *option_independent;
402 dev_dbg(&dev->dev, "parse resource options\n");
404 option_independent = option = pnp_register_independent_option(dev);
408 while ((char *)p < (char *)end) {
410 /* determine the type of tag */
411 if (p[0] & LARGE_TAG) { /* large tag */
412 len = (p[2] << 8) | p[1];
414 } else { /* small tag */
416 tag = ((p[0] >> 3) & 0x0f);
424 pnpbios_parse_mem_option(dev, p, len, option);
427 case LARGE_TAG_MEM32:
430 pnpbios_parse_mem32_option(dev, p, len, option);
433 case LARGE_TAG_FIXEDMEM32:
436 pnpbios_parse_fixed_mem32_option(dev, p, len, option);
440 if (len < 2 || len > 3)
442 pnpbios_parse_irq_option(dev, p, len, option);
448 pnpbios_parse_dma_option(dev, p, len, option);
454 pnpbios_parse_port_option(dev, p, len, option);
457 case SMALL_TAG_VENDOR:
461 case SMALL_TAG_FIXEDPORT:
464 pnpbios_parse_fixed_port_option(dev, p, len, option);
467 case SMALL_TAG_STARTDEP:
470 priority = 0x100 | PNP_RES_PRIORITY_ACCEPTABLE;
472 priority = 0x100 | p[1];
473 option = pnp_register_dependent_option(dev, priority);
478 case SMALL_TAG_ENDDEP:
481 if (option_independent == option)
482 dev_warn(&dev->dev, "missing "
483 "SMALL_TAG_STARTDEP tag\n");
484 option = option_independent;
485 dev_dbg(&dev->dev, "end dependent options\n");
491 default: /* an unkown tag */
493 dev_err(&dev->dev, "unknown tag %#x length %d\n",
498 /* continue to the next tag */
499 if (p[0] & LARGE_TAG)
505 dev_err(&dev->dev, "no end tag in resource structure\n");
511 * Compatible Device IDs
514 static unsigned char *pnpbios_parse_compatible_ids(unsigned char *p,
521 struct pnp_id *dev_id;
526 while ((char *)p < (char *)end) {
528 /* determine the type of tag */
529 if (p[0] & LARGE_TAG) { /* large tag */
530 len = (p[2] << 8) | p[1];
532 } else { /* small tag */
534 tag = ((p[0] >> 3) & 0x0f);
539 case LARGE_TAG_ANSISTR:
540 strncpy(dev->name, p + 3,
541 len >= PNP_NAME_LEN ? PNP_NAME_LEN - 2 : len);
543 PNP_NAME_LEN ? PNP_NAME_LEN - 1 : len] = '\0';
546 case SMALL_TAG_COMPATDEVID: /* compatible ID */
549 eisa_id = p[1] | p[2] << 8 | p[3] << 16 | p[4] << 24;
550 pnp_eisa_id_to_string(eisa_id & PNP_EISA_ID_MASK, id);
551 dev_id = pnp_add_id(dev, id);
558 return (unsigned char *)p;
561 default: /* an unkown tag */
563 dev_err(&dev->dev, "unknown tag %#x length %d\n",
568 /* continue to the next tag */
569 if (p[0] & LARGE_TAG)
575 dev_err(&dev->dev, "no end tag in resource structure\n");
581 * Allocated Resource Encoding
584 static void pnpbios_encode_mem(struct pnp_dev *dev, unsigned char *p,
585 struct resource *res)
587 unsigned long base = res->start;
588 unsigned long len = res->end - res->start + 1;
590 p[4] = (base >> 8) & 0xff;
591 p[5] = ((base >> 8) >> 8) & 0xff;
592 p[6] = (base >> 8) & 0xff;
593 p[7] = ((base >> 8) >> 8) & 0xff;
594 p[10] = (len >> 8) & 0xff;
595 p[11] = ((len >> 8) >> 8) & 0xff;
597 dev_dbg(&dev->dev, " encode mem %#llx-%#llx\n",
598 (unsigned long long) res->start, (unsigned long long) res->end);
601 static void pnpbios_encode_mem32(struct pnp_dev *dev, unsigned char *p,
602 struct resource *res)
604 unsigned long base = res->start;
605 unsigned long len = res->end - res->start + 1;
608 p[5] = (base >> 8) & 0xff;
609 p[6] = (base >> 16) & 0xff;
610 p[7] = (base >> 24) & 0xff;
612 p[9] = (base >> 8) & 0xff;
613 p[10] = (base >> 16) & 0xff;
614 p[11] = (base >> 24) & 0xff;
616 p[17] = (len >> 8) & 0xff;
617 p[18] = (len >> 16) & 0xff;
618 p[19] = (len >> 24) & 0xff;
620 dev_dbg(&dev->dev, " encode mem32 %#llx-%#llx\n",
621 (unsigned long long) res->start, (unsigned long long) res->end);
624 static void pnpbios_encode_fixed_mem32(struct pnp_dev *dev, unsigned char *p,
625 struct resource *res)
627 unsigned long base = res->start;
628 unsigned long len = res->end - res->start + 1;
631 p[5] = (base >> 8) & 0xff;
632 p[6] = (base >> 16) & 0xff;
633 p[7] = (base >> 24) & 0xff;
635 p[9] = (len >> 8) & 0xff;
636 p[10] = (len >> 16) & 0xff;
637 p[11] = (len >> 24) & 0xff;
639 dev_dbg(&dev->dev, " encode fixed_mem32 %#llx-%#llx\n",
640 (unsigned long long) res->start, (unsigned long long) res->end);
643 static void pnpbios_encode_irq(struct pnp_dev *dev, unsigned char *p,
644 struct resource *res)
646 unsigned long map = 0;
648 map = 1 << res->start;
650 p[2] = (map >> 8) & 0xff;
652 dev_dbg(&dev->dev, " encode irq %d\n", res->start);
655 static void pnpbios_encode_dma(struct pnp_dev *dev, unsigned char *p,
656 struct resource *res)
658 unsigned long map = 0;
660 map = 1 << res->start;
663 dev_dbg(&dev->dev, " encode dma %d\n", res->start);
666 static void pnpbios_encode_port(struct pnp_dev *dev, unsigned char *p,
667 struct resource *res)
669 unsigned long base = res->start;
670 unsigned long len = res->end - res->start + 1;
673 p[3] = (base >> 8) & 0xff;
675 p[5] = (base >> 8) & 0xff;
678 dev_dbg(&dev->dev, " encode io %#llx-%#llx\n",
679 (unsigned long long) res->start, (unsigned long long) res->end);
682 static void pnpbios_encode_fixed_port(struct pnp_dev *dev, unsigned char *p,
683 struct resource *res)
685 unsigned long base = res->start;
686 unsigned long len = res->end - res->start + 1;
689 p[2] = (base >> 8) & 0xff;
692 dev_dbg(&dev->dev, " encode fixed_io %#llx-%#llx\n",
693 (unsigned long long) res->start, (unsigned long long) res->end);
696 static unsigned char *pnpbios_encode_allocated_resource_data(struct pnp_dev
701 unsigned int len, tag;
702 int port = 0, irq = 0, dma = 0, mem = 0;
707 while ((char *)p < (char *)end) {
709 /* determine the type of tag */
710 if (p[0] & LARGE_TAG) { /* large tag */
711 len = (p[2] << 8) | p[1];
713 } else { /* small tag */
715 tag = ((p[0] >> 3) & 0x0f);
723 pnpbios_encode_mem(dev, p,
724 pnp_get_resource(dev, IORESOURCE_MEM, mem));
728 case LARGE_TAG_MEM32:
731 pnpbios_encode_mem32(dev, p,
732 pnp_get_resource(dev, IORESOURCE_MEM, mem));
736 case LARGE_TAG_FIXEDMEM32:
739 pnpbios_encode_fixed_mem32(dev, p,
740 pnp_get_resource(dev, IORESOURCE_MEM, mem));
745 if (len < 2 || len > 3)
747 pnpbios_encode_irq(dev, p,
748 pnp_get_resource(dev, IORESOURCE_IRQ, irq));
755 pnpbios_encode_dma(dev, p,
756 pnp_get_resource(dev, IORESOURCE_DMA, dma));
763 pnpbios_encode_port(dev, p,
764 pnp_get_resource(dev, IORESOURCE_IO, port));
768 case SMALL_TAG_VENDOR:
772 case SMALL_TAG_FIXEDPORT:
775 pnpbios_encode_fixed_port(dev, p,
776 pnp_get_resource(dev, IORESOURCE_IO, port));
782 return (unsigned char *)p;
785 default: /* an unkown tag */
787 dev_err(&dev->dev, "unknown tag %#x length %d\n",
792 /* continue to the next tag */
793 if (p[0] & LARGE_TAG)
799 dev_err(&dev->dev, "no end tag in resource structure\n");
805 * Core Parsing Functions
808 int __init pnpbios_parse_data_stream(struct pnp_dev *dev,
809 struct pnp_bios_node *node)
811 unsigned char *p = (char *)node->data;
812 unsigned char *end = (char *)(node->data + node->size);
814 p = pnpbios_parse_allocated_resource_data(dev, p, end);
817 p = pnpbios_parse_resource_option_data(p, end, dev);
820 p = pnpbios_parse_compatible_ids(p, end, dev);
826 int pnpbios_read_resources_from_node(struct pnp_dev *dev,
827 struct pnp_bios_node *node)
829 unsigned char *p = (char *)node->data;
830 unsigned char *end = (char *)(node->data + node->size);
832 p = pnpbios_parse_allocated_resource_data(dev, p, end);
838 int pnpbios_write_resources_to_node(struct pnp_dev *dev,
839 struct pnp_bios_node *node)
841 unsigned char *p = (char *)node->data;
842 unsigned char *end = (char *)(node->data + node->size);
844 p = pnpbios_encode_allocated_resource_data(dev, p, end);