drivers/pnp/pnpbios/rsparser.c

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