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