?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
PNP: make generic pnp_add_dma_resource()
[linux-2.6/mini2440.git] / drivers / pnp / pnpbios / rsparser.c
blob7f8d657285992c7f132c1a1903104fea213ae590
1 /*
2 * rsparser.c - parses and encodes pnpbios resource data streams
3 */
4
5 #include <linux/ctype.h>
6 #include <linux/pnp.h>
7 #include <linux/pnpbios.h>
8 #include <linux/string.h>
9 #include <linux/slab.h>
10
11 #ifdef CONFIG_PCI
12 #include <linux/pci.h>
13 #else
14 inline void pcibios_penalize_isa_irq(int irq, int active)
15 {
16 }
17 #endif /* CONFIG_PCI */
18
19 #include "../base.h"
20 #include "pnpbios.h"
21
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
41
42 /*
43 * Resource Data Stream Format:
44 *
45 * Allocated Resources (required)
46 * end tag ->
47 * Resource Configuration Options (optional)
48 * end tag ->
49 * Compitable Device IDs (optional)
50 * final end tag ->
51 */
52
53 /*
54 * Allocated Resources
55 */
56
57 static void pnpbios_parse_allocated_ioresource(struct pnp_dev *dev,
58 int io, int len)
59 {
60 struct resource *res;
61 int i;
62
63 for (i = 0; i < PNP_MAX_PORT; i++) {
64 res = pnp_get_resource(dev, IORESOURCE_IO, i);
65 if (!pnp_resource_valid(res))
66 break;
67 }
68
69 if (i < PNP_MAX_PORT) {
70 res->flags = IORESOURCE_IO; // Also clears _UNSET flag
71 if (len <= 0 || (io + len - 1) >= 0x10003) {
72 res->flags |= IORESOURCE_DISABLED;
73 return;
74 }
75 res->start = (unsigned long)io;
76 res->end = (unsigned long)(io + len - 1);
77 }
78 }
79
80 static void pnpbios_parse_allocated_memresource(struct pnp_dev *dev,
81 int mem, int len)
82 {
83 struct resource *res;
84 int i;
85
86 for (i = 0; i < PNP_MAX_MEM; i++) {
87 res = pnp_get_resource(dev, IORESOURCE_MEM, i);
88 if (!pnp_resource_valid(res))
89 break;
90 }
91
92 if (i < PNP_MAX_MEM) {
93 res->flags = IORESOURCE_MEM; // Also clears _UNSET flag
94 if (len <= 0) {
95 res->flags |= IORESOURCE_DISABLED;
96 return;
97 }
98 res->start = (unsigned long)mem;
99 res->end = (unsigned long)(mem + len - 1);
100 }
101 }
102
103 static unsigned char *pnpbios_parse_allocated_resource_data(struct pnp_dev *dev,
104 unsigned char *p,
105 unsigned char *end)
106 {
107 unsigned int len, tag;
108 int io, size, mask, i, flags;
109
110 if (!p)
111 return NULL;
112
113 dev_dbg(&dev->dev, "parse allocated resources\n");
114
115 pnp_init_resources(dev);
116
117 while ((char *)p < (char *)end) {
118
119 /* determine the type of tag */
120 if (p[0] & LARGE_TAG) { /* large tag */
121 len = (p[2] << 8) | p[1];
122 tag = p[0];
123 } else { /* small tag */
124 len = p[0] & 0x07;
125 tag = ((p[0] >> 3) & 0x0f);
126 }
127
128 switch (tag) {
129
130 case LARGE_TAG_MEM:
131 if (len != 9)
132 goto len_err;
133 io = *(short *)&p[4];
134 size = *(short *)&p[10];
135 pnpbios_parse_allocated_memresource(dev, io, size);
136 break;
137
138 case LARGE_TAG_ANSISTR:
139 /* ignore this for now */
140 break;
141
142 case LARGE_TAG_VENDOR:
143 /* do nothing */
144 break;
145
146 case LARGE_TAG_MEM32:
147 if (len != 17)
148 goto len_err;
149 io = *(int *)&p[4];
150 size = *(int *)&p[16];
151 pnpbios_parse_allocated_memresource(dev, io, size);
152 break;
153
154 case LARGE_TAG_FIXEDMEM32:
155 if (len != 9)
156 goto len_err;
157 io = *(int *)&p[4];
158 size = *(int *)&p[8];
159 pnpbios_parse_allocated_memresource(dev, io, size);
160 break;
161
162 case SMALL_TAG_IRQ:
163 if (len < 2 || len > 3)
164 goto len_err;
165 flags = 0;
166 io = -1;
167 mask = p[1] + p[2] * 256;
168 for (i = 0; i < 16; i++, mask = mask >> 1)
169 if (mask & 0x01)
170 io = i;
171 if (io != -1)
172 pcibios_penalize_isa_irq(io, 1);
173 else
174 flags = IORESOURCE_DISABLED;
175 pnp_add_irq_resource(dev, io, flags);
176 break;
177
178 case SMALL_TAG_DMA:
179 if (len != 2)
180 goto len_err;
181 flags = 0;
182 io = -1;
183 mask = p[1];
184 for (i = 0; i < 8; i++, mask = mask >> 1)
185 if (mask & 0x01)
186 io = i;
187 if (io == -1)
188 flags = IORESOURCE_DISABLED;
189 pnp_add_dma_resource(dev, io, flags);
190 break;
191
192 case SMALL_TAG_PORT:
193 if (len != 7)
194 goto len_err;
195 io = p[2] + p[3] * 256;
196 size = p[7];
197 pnpbios_parse_allocated_ioresource(dev, io, size);
198 break;
199
200 case SMALL_TAG_VENDOR:
201 /* do nothing */
202 break;
203
204 case SMALL_TAG_FIXEDPORT:
205 if (len != 3)
206 goto len_err;
207 io = p[1] + p[2] * 256;
208 size = p[3];
209 pnpbios_parse_allocated_ioresource(dev, io, size);
210 break;
211
212 case SMALL_TAG_END:
213 p = p + 2;
214 return (unsigned char *)p;
215 break;
216
217 default: /* an unkown tag */
218 len_err:
219 dev_err(&dev->dev, "unknown tag %#x length %d\n",
220 tag, len);
221 break;
222 }
223
224 /* continue to the next tag */
225 if (p[0] & LARGE_TAG)
226 p += len + 3;
227 else
228 p += len + 1;
229 }
230
231 dev_err(&dev->dev, "no end tag in resource structure\n");
232
233 return NULL;
234 }
235
236 /*
237 * Resource Configuration Options
238 */
239
240 static __init void pnpbios_parse_mem_option(struct pnp_dev *dev,
241 unsigned char *p, int size,
242 struct pnp_option *option)
243 {
244 struct pnp_mem *mem;
245
246 mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
247 if (!mem)
248 return;
249 mem->min = ((p[5] << 8) | p[4]) << 8;
250 mem->max = ((p[7] << 8) | p[6]) << 8;
251 mem->align = (p[9] << 8) | p[8];
252 mem->size = ((p[11] << 8) | p[10]) << 8;
253 mem->flags = p[3];
254 pnp_register_mem_resource(dev, option, mem);
255 }
256
257 static __init void pnpbios_parse_mem32_option(struct pnp_dev *dev,
258 unsigned char *p, int size,
259 struct pnp_option *option)
260 {
261 struct pnp_mem *mem;
262
263 mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
264 if (!mem)
265 return;
266 mem->min = (p[7] << 24) | (p[6] << 16) | (p[5] << 8) | p[4];
267 mem->max = (p[11] << 24) | (p[10] << 16) | (p[9] << 8) | p[8];
268 mem->align = (p[15] << 24) | (p[14] << 16) | (p[13] << 8) | p[12];
269 mem->size = (p[19] << 24) | (p[18] << 16) | (p[17] << 8) | p[16];
270 mem->flags = p[3];
271 pnp_register_mem_resource(dev, option, mem);
272 }
273
274 static __init void pnpbios_parse_fixed_mem32_option(struct pnp_dev *dev,
275 unsigned char *p, int size,
276 struct pnp_option *option)
277 {
278 struct pnp_mem *mem;
279
280 mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
281 if (!mem)
282 return;
283 mem->min = mem->max = (p[7] << 24) | (p[6] << 16) | (p[5] << 8) | p[4];
284 mem->size = (p[11] << 24) | (p[10] << 16) | (p[9] << 8) | p[8];
285 mem->align = 0;
286 mem->flags = p[3];
287 pnp_register_mem_resource(dev, option, mem);
288 }
289
290 static __init void pnpbios_parse_irq_option(struct pnp_dev *dev,
291 unsigned char *p, int size,
292 struct pnp_option *option)
293 {
294 struct pnp_irq *irq;
295 unsigned long bits;
296
297 irq = kzalloc(sizeof(struct pnp_irq), GFP_KERNEL);
298 if (!irq)
299 return;
300 bits = (p[2] << 8) | p[1];
301 bitmap_copy(irq->map, &bits, 16);
302 if (size > 2)
303 irq->flags = p[3];
304 else
305 irq->flags = IORESOURCE_IRQ_HIGHEDGE;
306 pnp_register_irq_resource(dev, option, irq);
307 }
308
309 static __init void pnpbios_parse_dma_option(struct pnp_dev *dev,
310 unsigned char *p, int size,
311 struct pnp_option *option)
312 {
313 struct pnp_dma *dma;
314
315 dma = kzalloc(sizeof(struct pnp_dma), GFP_KERNEL);
316 if (!dma)
317 return;
318 dma->map = p[1];
319 dma->flags = p[2];
320 pnp_register_dma_resource(dev, option, dma);
321 }
322
323 static __init void pnpbios_parse_port_option(struct pnp_dev *dev,
324 unsigned char *p, int size,
325 struct pnp_option *option)
326 {
327 struct pnp_port *port;
328
329 port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL);
330 if (!port)
331 return;
332 port->min = (p[3] << 8) | p[2];
333 port->max = (p[5] << 8) | p[4];
334 port->align = p[6];
335 port->size = p[7];
336 port->flags = p[1] ? PNP_PORT_FLAG_16BITADDR : 0;
337 pnp_register_port_resource(dev, option, port);
338 }
339
340 static __init void pnpbios_parse_fixed_port_option(struct pnp_dev *dev,
341 unsigned char *p, int size,
342 struct pnp_option *option)
343 {
344 struct pnp_port *port;
345
346 port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL);
347 if (!port)
348 return;
349 port->min = port->max = (p[2] << 8) | p[1];
350 port->size = p[3];
351 port->align = 0;
352 port->flags = PNP_PORT_FLAG_FIXED;
353 pnp_register_port_resource(dev, option, port);
354 }
355
356 static __init unsigned char *
357 pnpbios_parse_resource_option_data(unsigned char *p, unsigned char *end,
358 struct pnp_dev *dev)
359 {
360 unsigned int len, tag;
361 int priority = 0;
362 struct pnp_option *option, *option_independent;
363
364 if (!p)
365 return NULL;
366
367 dev_dbg(&dev->dev, "parse resource options\n");
368
369 option_independent = option = pnp_register_independent_option(dev);
370 if (!option)
371 return NULL;
372
373 while ((char *)p < (char *)end) {
374
375 /* determine the type of tag */
376 if (p[0] & LARGE_TAG) { /* large tag */
377 len = (p[2] << 8) | p[1];
378 tag = p[0];
379 } else { /* small tag */
380 len = p[0] & 0x07;
381 tag = ((p[0] >> 3) & 0x0f);
382 }
383
384 switch (tag) {
385
386 case LARGE_TAG_MEM:
387 if (len != 9)
388 goto len_err;
389 pnpbios_parse_mem_option(dev, p, len, option);
390 break;
391
392 case LARGE_TAG_MEM32:
393 if (len != 17)
394 goto len_err;
395 pnpbios_parse_mem32_option(dev, p, len, option);
396 break;
397
398 case LARGE_TAG_FIXEDMEM32:
399 if (len != 9)
400 goto len_err;
401 pnpbios_parse_fixed_mem32_option(dev, p, len, option);
402 break;
403
404 case SMALL_TAG_IRQ:
405 if (len < 2 || len > 3)
406 goto len_err;
407 pnpbios_parse_irq_option(dev, p, len, option);
408 break;
409
410 case SMALL_TAG_DMA:
411 if (len != 2)
412 goto len_err;
413 pnpbios_parse_dma_option(dev, p, len, option);
414 break;
415
416 case SMALL_TAG_PORT:
417 if (len != 7)
418 goto len_err;
419 pnpbios_parse_port_option(dev, p, len, option);
420 break;
421
422 case SMALL_TAG_VENDOR:
423 /* do nothing */
424 break;
425
426 case SMALL_TAG_FIXEDPORT:
427 if (len != 3)
428 goto len_err;
429 pnpbios_parse_fixed_port_option(dev, p, len, option);
430 break;
431
432 case SMALL_TAG_STARTDEP:
433 if (len > 1)
434 goto len_err;
435 priority = 0x100 | PNP_RES_PRIORITY_ACCEPTABLE;
436 if (len > 0)
437 priority = 0x100 | p[1];
438 option = pnp_register_dependent_option(dev, priority);
439 if (!option)
440 return NULL;
441 break;
442
443 case SMALL_TAG_ENDDEP:
444 if (len != 0)
445 goto len_err;
446 if (option_independent == option)
447 dev_warn(&dev->dev, "missing "
448 "SMALL_TAG_STARTDEP tag\n");
449 option = option_independent;
450 dev_dbg(&dev->dev, "end dependent options\n");
451 break;
452
453 case SMALL_TAG_END:
454 return p + 2;
455
456 default: /* an unkown tag */
457 len_err:
458 dev_err(&dev->dev, "unknown tag %#x length %d\n",
459 tag, len);
460 break;
461 }
462
463 /* continue to the next tag */
464 if (p[0] & LARGE_TAG)
465 p += len + 3;
466 else
467 p += len + 1;
468 }
469
470 dev_err(&dev->dev, "no end tag in resource structure\n");
471
472 return NULL;
473 }
474
475 /*
476 * Compatible Device IDs
477 */
478
479 static unsigned char *pnpbios_parse_compatible_ids(unsigned char *p,
480 unsigned char *end,
481 struct pnp_dev *dev)
482 {
483 int len, tag;
484 u32 eisa_id;
485 char id[8];
486 struct pnp_id *dev_id;
487
488 if (!p)
489 return NULL;
490
491 while ((char *)p < (char *)end) {
492
493 /* determine the type of tag */
494 if (p[0] & LARGE_TAG) { /* large tag */
495 len = (p[2] << 8) | p[1];
496 tag = p[0];
497 } else { /* small tag */
498 len = p[0] & 0x07;
499 tag = ((p[0] >> 3) & 0x0f);
500 }
501
502 switch (tag) {
503
504 case LARGE_TAG_ANSISTR:
505 strncpy(dev->name, p + 3,
506 len >= PNP_NAME_LEN ? PNP_NAME_LEN - 2 : len);
507 dev->name[len >=
508 PNP_NAME_LEN ? PNP_NAME_LEN - 1 : len] = '\0';
509 break;
510
511 case SMALL_TAG_COMPATDEVID: /* compatible ID */
512 if (len != 4)
513 goto len_err;
514 eisa_id = p[1] | p[2] << 8 | p[3] << 16 | p[4] << 24;
515 pnp_eisa_id_to_string(eisa_id & PNP_EISA_ID_MASK, id);
516 dev_id = pnp_add_id(dev, id);
517 if (!dev_id)
518 return NULL;
519 break;
520
521 case SMALL_TAG_END:
522 p = p + 2;
523 return (unsigned char *)p;
524 break;
525
526 default: /* an unkown tag */
527 len_err:
528 dev_err(&dev->dev, "unknown tag %#x length %d\n",
529 tag, len);
530 break;
531 }
532
533 /* continue to the next tag */
534 if (p[0] & LARGE_TAG)
535 p += len + 3;
536 else
537 p += len + 1;
538 }
539
540 dev_err(&dev->dev, "no end tag in resource structure\n");
541
542 return NULL;
543 }
544
545 /*
546 * Allocated Resource Encoding
547 */
548
549 static void pnpbios_encode_mem(struct pnp_dev *dev, unsigned char *p,
550 struct resource *res)
551 {
552 unsigned long base = res->start;
553 unsigned long len = res->end - res->start + 1;
554
555 p[4] = (base >> 8) & 0xff;
556 p[5] = ((base >> 8) >> 8) & 0xff;
557 p[6] = (base >> 8) & 0xff;
558 p[7] = ((base >> 8) >> 8) & 0xff;
559 p[10] = (len >> 8) & 0xff;
560 p[11] = ((len >> 8) >> 8) & 0xff;
561
562 dev_dbg(&dev->dev, " encode mem %#llx-%#llx\n",
563 (unsigned long long) res->start, (unsigned long long) res->end);
564 }
565
566 static void pnpbios_encode_mem32(struct pnp_dev *dev, unsigned char *p,
567 struct resource *res)
568 {
569 unsigned long base = res->start;
570 unsigned long len = res->end - res->start + 1;
571
572 p[4] = base & 0xff;
573 p[5] = (base >> 8) & 0xff;
574 p[6] = (base >> 16) & 0xff;
575 p[7] = (base >> 24) & 0xff;
576 p[8] = base & 0xff;
577 p[9] = (base >> 8) & 0xff;
578 p[10] = (base >> 16) & 0xff;
579 p[11] = (base >> 24) & 0xff;
580 p[16] = len & 0xff;
581 p[17] = (len >> 8) & 0xff;
582 p[18] = (len >> 16) & 0xff;
583 p[19] = (len >> 24) & 0xff;
584
585 dev_dbg(&dev->dev, " encode mem32 %#llx-%#llx\n",
586 (unsigned long long) res->start, (unsigned long long) res->end);
587 }
588
589 static void pnpbios_encode_fixed_mem32(struct pnp_dev *dev, unsigned char *p,
590 struct resource *res)
591 {
592 unsigned long base = res->start;
593 unsigned long len = res->end - res->start + 1;
594
595 p[4] = base & 0xff;
596 p[5] = (base >> 8) & 0xff;
597 p[6] = (base >> 16) & 0xff;
598 p[7] = (base >> 24) & 0xff;
599 p[8] = len & 0xff;
600 p[9] = (len >> 8) & 0xff;
601 p[10] = (len >> 16) & 0xff;
602 p[11] = (len >> 24) & 0xff;
603
604 dev_dbg(&dev->dev, " encode fixed_mem32 %#llx-%#llx\n",
605 (unsigned long long) res->start, (unsigned long long) res->end);
606 }
607
608 static void pnpbios_encode_irq(struct pnp_dev *dev, unsigned char *p,
609 struct resource *res)
610 {
611 unsigned long map = 0;
612
613 map = 1 << res->start;
614 p[1] = map & 0xff;
615 p[2] = (map >> 8) & 0xff;
616
617 dev_dbg(&dev->dev, " encode irq %d\n", res->start);
618 }
619
620 static void pnpbios_encode_dma(struct pnp_dev *dev, unsigned char *p,
621 struct resource *res)
622 {
623 unsigned long map = 0;
624
625 map = 1 << res->start;
626 p[1] = map & 0xff;
627
628 dev_dbg(&dev->dev, " encode dma %d\n", res->start);
629 }
630
631 static void pnpbios_encode_port(struct pnp_dev *dev, unsigned char *p,
632 struct resource *res)
633 {
634 unsigned long base = res->start;
635 unsigned long len = res->end - res->start + 1;
636
637 p[2] = base & 0xff;
638 p[3] = (base >> 8) & 0xff;
639 p[4] = base & 0xff;
640 p[5] = (base >> 8) & 0xff;
641 p[7] = len & 0xff;
642
643 dev_dbg(&dev->dev, " encode io %#llx-%#llx\n",
644 (unsigned long long) res->start, (unsigned long long) res->end);
645 }
646
647 static void pnpbios_encode_fixed_port(struct pnp_dev *dev, unsigned char *p,
648 struct resource *res)
649 {
650 unsigned long base = res->start;
651 unsigned long len = res->end - res->start + 1;
652
653 p[1] = base & 0xff;
654 p[2] = (base >> 8) & 0xff;
655 p[3] = len & 0xff;
656
657 dev_dbg(&dev->dev, " encode fixed_io %#llx-%#llx\n",
658 (unsigned long long) res->start, (unsigned long long) res->end);
659 }
660
661 static unsigned char *pnpbios_encode_allocated_resource_data(struct pnp_dev
662 *dev,
663 unsigned char *p,
664 unsigned char *end)
665 {
666 unsigned int len, tag;
667 int port = 0, irq = 0, dma = 0, mem = 0;
668
669 if (!p)
670 return NULL;
671
672 while ((char *)p < (char *)end) {
673
674 /* determine the type of tag */
675 if (p[0] & LARGE_TAG) { /* large tag */
676 len = (p[2] << 8) | p[1];
677 tag = p[0];
678 } else { /* small tag */
679 len = p[0] & 0x07;
680 tag = ((p[0] >> 3) & 0x0f);
681 }
682
683 switch (tag) {
684
685 case LARGE_TAG_MEM:
686 if (len != 9)
687 goto len_err;
688 pnpbios_encode_mem(dev, p,
689 pnp_get_resource(dev, IORESOURCE_MEM, mem));
690 mem++;
691 break;
692
693 case LARGE_TAG_MEM32:
694 if (len != 17)
695 goto len_err;
696 pnpbios_encode_mem32(dev, p,
697 pnp_get_resource(dev, IORESOURCE_MEM, mem));
698 mem++;
699 break;
700
701 case LARGE_TAG_FIXEDMEM32:
702 if (len != 9)
703 goto len_err;
704 pnpbios_encode_fixed_mem32(dev, p,
705 pnp_get_resource(dev, IORESOURCE_MEM, mem));
706 mem++;
707 break;
708
709 case SMALL_TAG_IRQ:
710 if (len < 2 || len > 3)
711 goto len_err;
712 pnpbios_encode_irq(dev, p,
713 pnp_get_resource(dev, IORESOURCE_IRQ, irq));
714 irq++;
715 break;
716
717 case SMALL_TAG_DMA:
718 if (len != 2)
719 goto len_err;
720 pnpbios_encode_dma(dev, p,
721 pnp_get_resource(dev, IORESOURCE_DMA, dma));
722 dma++;
723 break;
724
725 case SMALL_TAG_PORT:
726 if (len != 7)
727 goto len_err;
728 pnpbios_encode_port(dev, p,
729 pnp_get_resource(dev, IORESOURCE_IO, port));
730 port++;
731 break;
732
733 case SMALL_TAG_VENDOR:
734 /* do nothing */
735 break;
736
737 case SMALL_TAG_FIXEDPORT:
738 if (len != 3)
739 goto len_err;
740 pnpbios_encode_fixed_port(dev, p,
741 pnp_get_resource(dev, IORESOURCE_IO, port));
742 port++;
743 break;
744
745 case SMALL_TAG_END:
746 p = p + 2;
747 return (unsigned char *)p;
748 break;
749
750 default: /* an unkown tag */
751 len_err:
752 dev_err(&dev->dev, "unknown tag %#x length %d\n",
753 tag, len);
754 break;
755 }
756
757 /* continue to the next tag */
758 if (p[0] & LARGE_TAG)
759 p += len + 3;
760 else
761 p += len + 1;
762 }
763
764 dev_err(&dev->dev, "no end tag in resource structure\n");
765
766 return NULL;
767 }
768
769 /*
770 * Core Parsing Functions
771 */
772
773 int __init pnpbios_parse_data_stream(struct pnp_dev *dev,
774 struct pnp_bios_node *node)
775 {
776 unsigned char *p = (char *)node->data;
777 unsigned char *end = (char *)(node->data + node->size);
778
779 p = pnpbios_parse_allocated_resource_data(dev, p, end);
780 if (!p)
781 return -EIO;
782 p = pnpbios_parse_resource_option_data(p, end, dev);
783 if (!p)
784 return -EIO;
785 p = pnpbios_parse_compatible_ids(p, end, dev);
786 if (!p)
787 return -EIO;
788 return 0;
789 }
790
791 int pnpbios_read_resources_from_node(struct pnp_dev *dev,
792 struct pnp_bios_node *node)
793 {
794 unsigned char *p = (char *)node->data;
795 unsigned char *end = (char *)(node->data + node->size);
796
797 p = pnpbios_parse_allocated_resource_data(dev, p, end);
798 if (!p)
799 return -EIO;
800 return 0;
801 }
802
803 int pnpbios_write_resources_to_node(struct pnp_dev *dev,
804 struct pnp_bios_node *node)
805 {
806 unsigned char *p = (char *)node->data;
807 unsigned char *end = (char *)(node->data + node->size);
808
809 p = pnpbios_encode_allocated_resource_data(dev, p, end);
810 if (!p)
811 return -EIO;
812 return 0;
813 }
Support for the Chinese Samsung S3C2440 based development boards