projects / deliverable / linux.git / blob
? search:


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