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 } 825