drivers/pnp/pnpacpi/rsparser.c

   1 /*
   2  * pnpacpi -- PnP ACPI driver
   3  *
   4  * Copyright (c) 2004 Matthieu Castet <castet.matthieu@free.fr>
   5  * Copyright (c) 2004 Li Shaohua <shaohua.li@intel.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the
   9  * Free Software Foundation; either version 2, or (at your option) any
  10  * later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21 #include <linux/kernel.h>
  22 #include <linux/acpi.h>
  23 #include <linux/pci.h>
  24 #include "pnpacpi.h"
  25
  26 #ifdef CONFIG_IA64
  27 #define valid_IRQ(i) (1)
  28 #else
  29 #define valid_IRQ(i) (((i) != 0) && ((i) != 2))
  30 #endif
  31
  32 /*
  33  * Allocated Resources
  34  */
  35 static int irq_flags(int triggering, int polarity)
  36 {
  37         if (triggering == ACPI_LEVEL_SENSITIVE) {
  38                 if (polarity == ACPI_ACTIVE_LOW)
  39                         return IORESOURCE_IRQ_LOWLEVEL;
  40                 else
  41                         return IORESOURCE_IRQ_HIGHLEVEL;
  42         } else {
  43                 if (polarity == ACPI_ACTIVE_LOW)
  44                         return IORESOURCE_IRQ_LOWEDGE;
  45                 else
  46                         return IORESOURCE_IRQ_HIGHEDGE;
  47         }
  48 }
  49
  50 static void decode_irq_flags(int flag, int *triggering, int *polarity)
  51 {
  52         switch (flag) {
  53         case IORESOURCE_IRQ_LOWLEVEL:
  54                 *triggering = ACPI_LEVEL_SENSITIVE;
  55                 *polarity = ACPI_ACTIVE_LOW;
  56                 break;
  57         case IORESOURCE_IRQ_HIGHLEVEL:
  58                 *triggering = ACPI_LEVEL_SENSITIVE;
  59                 *polarity = ACPI_ACTIVE_HIGH;
  60                 break;
  61         case IORESOURCE_IRQ_LOWEDGE:
  62                 *triggering = ACPI_EDGE_SENSITIVE;
  63                 *polarity = ACPI_ACTIVE_LOW;
  64                 break;
  65         case IORESOURCE_IRQ_HIGHEDGE:
  66                 *triggering = ACPI_EDGE_SENSITIVE;
  67                 *polarity = ACPI_ACTIVE_HIGH;
  68                 break;
  69         }
  70 }
  71
  72 static void pnpacpi_parse_allocated_irqresource(struct pnp_resource_table *res,
  73                                                 u32 gsi, int triggering,
  74                                                 int polarity, int shareable)
  75 {
  76         int i = 0;
  77         int irq;
  78         int p, t;
  79         static unsigned char warned;
  80
  81         if (!valid_IRQ(gsi))
  82                 return;
  83
  84         while (!(res->irq_resource[i].flags & IORESOURCE_UNSET) &&
  85                i < PNP_MAX_IRQ)
  86                 i++;
  87         if (i >= PNP_MAX_IRQ) {
  88                 if (!warned) {
  89                         printk(KERN_WARNING "pnpacpi: exceeded the max number"
  90                                 " of IRQ resources: %d\n", PNP_MAX_IRQ);
  91                         warned = 1;
  92                 }
  93                 return;
  94         }
  95         /*
  96          * in IO-APIC mode, use overrided attribute. Two reasons:
  97          * 1. BIOS bug in DSDT
  98          * 2. BIOS uses IO-APIC mode Interrupt Source Override
  99          */
 100         if (!acpi_get_override_irq(gsi, &t, &p)) {
 101                 t = t ? ACPI_LEVEL_SENSITIVE : ACPI_EDGE_SENSITIVE;
 102                 p = p ? ACPI_ACTIVE_LOW : ACPI_ACTIVE_HIGH;
 103
 104                 if (triggering != t || polarity != p) {
 105                         pnp_warn("IRQ %d override to %s, %s",
 106                                 gsi, t ? "edge":"level", p ? "low":"high");
 107                         triggering = t;
 108                         polarity = p;
 109                 }
 110         }
 111
 112         res->irq_resource[i].flags = IORESOURCE_IRQ;    // Also clears _UNSET flag
 113         res->irq_resource[i].flags |= irq_flags(triggering, polarity);
 114         irq = acpi_register_gsi(gsi, triggering, polarity);
 115         if (irq < 0) {
 116                 res->irq_resource[i].flags |= IORESOURCE_DISABLED;
 117                 return;
 118         }
 119
 120         if (shareable)
 121                 res->irq_resource[i].flags |= IORESOURCE_IRQ_SHAREABLE;
 122
 123         res->irq_resource[i].start = irq;
 124         res->irq_resource[i].end = irq;
 125         pcibios_penalize_isa_irq(irq, 1);
 126 }
 127
 128 static int dma_flags(int type, int bus_master, int transfer)
 129 {
 130         int flags = 0;
 131
 132         if (bus_master)
 133                 flags |= IORESOURCE_DMA_MASTER;
 134         switch (type) {
 135         case ACPI_COMPATIBILITY:
 136                 flags |= IORESOURCE_DMA_COMPATIBLE;
 137                 break;
 138         case ACPI_TYPE_A:
 139                 flags |= IORESOURCE_DMA_TYPEA;
 140                 break;
 141         case ACPI_TYPE_B:
 142                 flags |= IORESOURCE_DMA_TYPEB;
 143                 break;
 144         case ACPI_TYPE_F:
 145                 flags |= IORESOURCE_DMA_TYPEF;
 146                 break;
 147         default:
 148                 /* Set a default value ? */
 149                 flags |= IORESOURCE_DMA_COMPATIBLE;
 150                 pnp_err("Invalid DMA type");
 151         }
 152         switch (transfer) {
 153         case ACPI_TRANSFER_8:
 154                 flags |= IORESOURCE_DMA_8BIT;
 155                 break;
 156         case ACPI_TRANSFER_8_16:
 157                 flags |= IORESOURCE_DMA_8AND16BIT;
 158                 break;
 159         case ACPI_TRANSFER_16:
 160                 flags |= IORESOURCE_DMA_16BIT;
 161                 break;
 162         default:
 163                 /* Set a default value ? */
 164                 flags |= IORESOURCE_DMA_8AND16BIT;
 165                 pnp_err("Invalid DMA transfer type");
 166         }
 167
 168         return flags;
 169 }
 170
 171 static void pnpacpi_parse_allocated_dmaresource(struct pnp_resource_table *res,
 172                                                 u32 dma, int flags)
 173 {
 174         int i = 0;
 175         static unsigned char warned;
 176
 177         while (i < PNP_MAX_DMA &&
 178                !(res->dma_resource[i].flags & IORESOURCE_UNSET))
 179                 i++;
 180         if (i < PNP_MAX_DMA) {
 181                 res->dma_resource[i].flags = IORESOURCE_DMA;    // Also clears _UNSET flag
 182                 res->dma_resource[i].flags |= flags;
 183                 if (dma == -1) {
 184                         res->dma_resource[i].flags |= IORESOURCE_DISABLED;
 185                         return;
 186                 }
 187                 res->dma_resource[i].start = dma;
 188                 res->dma_resource[i].end = dma;
 189         } else if (!warned) {
 190                 printk(KERN_WARNING "pnpacpi: exceeded the max number of DMA "
 191                                 "resources: %d \n", PNP_MAX_DMA);
 192                 warned = 1;
 193         }
 194 }
 195
 196 static void pnpacpi_parse_allocated_ioresource(struct pnp_resource_table *res,
 197                                                u64 io, u64 len, int io_decode)
 198 {
 199         int i = 0;
 200         static unsigned char warned;
 201
 202         while (!(res->port_resource[i].flags & IORESOURCE_UNSET) &&
 203                i < PNP_MAX_PORT)
 204                 i++;
 205         if (i < PNP_MAX_PORT) {
 206                 res->port_resource[i].flags = IORESOURCE_IO;    // Also clears _UNSET flag
 207                 if (io_decode == ACPI_DECODE_16)
 208                         res->port_resource[i].flags |= PNP_PORT_FLAG_16BITADDR;
 209                 if (len <= 0 || (io + len - 1) >= 0x10003) {
 210                         res->port_resource[i].flags |= IORESOURCE_DISABLED;
 211                         return;
 212                 }
 213                 res->port_resource[i].start = io;
 214                 res->port_resource[i].end = io + len - 1;
 215         } else if (!warned) {
 216                 printk(KERN_WARNING "pnpacpi: exceeded the max number of IO "
 217                                 "resources: %d \n", PNP_MAX_PORT);
 218                 warned = 1;
 219         }
 220 }
 221
 222 static void pnpacpi_parse_allocated_memresource(struct pnp_resource_table *res,
 223                                                 u64 mem, u64 len,
 224                                                 int write_protect)
 225 {
 226         int i = 0;
 227         static unsigned char warned;
 228
 229         while (!(res->mem_resource[i].flags & IORESOURCE_UNSET) &&
 230                (i < PNP_MAX_MEM))
 231                 i++;
 232         if (i < PNP_MAX_MEM) {
 233                 res->mem_resource[i].flags = IORESOURCE_MEM;    // Also clears _UNSET flag
 234                 if (len <= 0) {
 235                         res->mem_resource[i].flags |= IORESOURCE_DISABLED;
 236                         return;
 237                 }
 238                 if (write_protect == ACPI_READ_WRITE_MEMORY)
 239                         res->mem_resource[i].flags |= IORESOURCE_MEM_WRITEABLE;
 240
 241                 res->mem_resource[i].start = mem;
 242                 res->mem_resource[i].end = mem + len - 1;
 243         } else if (!warned) {
 244                 printk(KERN_WARNING "pnpacpi: exceeded the max number of mem "
 245                                 "resources: %d\n", PNP_MAX_MEM);
 246                 warned = 1;
 247         }
 248 }
 249
 250 static void pnpacpi_parse_allocated_address_space(struct pnp_resource_table *res_table,
 251                                                   struct acpi_resource *res)
 252 {
 253         struct acpi_resource_address64 addr, *p = &addr;
 254         acpi_status status;
 255
 256         status = acpi_resource_to_address64(res, p);
 257         if (!ACPI_SUCCESS(status)) {
 258                 pnp_warn("PnPACPI: failed to convert resource type %d",
 259                          res->type);
 260                 return;
 261         }
 262
 263         if (p->producer_consumer == ACPI_PRODUCER)
 264                 return;
 265
 266         if (p->resource_type == ACPI_MEMORY_RANGE)
 267                 pnpacpi_parse_allocated_memresource(res_table,
 268                         p->minimum, p->address_length,
 269                         p->info.mem.write_protect);
 270         else if (p->resource_type == ACPI_IO_RANGE)
 271                 pnpacpi_parse_allocated_ioresource(res_table,
 272                         p->minimum, p->address_length,
 273                         p->granularity == 0xfff ? ACPI_DECODE_10 :
 274                                 ACPI_DECODE_16);
 275 }
 276
 277 static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res,
 278                                               void *data)
 279 {
 280         struct pnp_resource_table *res_table = data;
 281         struct acpi_resource_irq *irq;
 282         struct acpi_resource_dma *dma;
 283         struct acpi_resource_io *io;
 284         struct acpi_resource_fixed_io *fixed_io;
 285         struct acpi_resource_memory24 *memory24;
 286         struct acpi_resource_memory32 *memory32;
 287         struct acpi_resource_fixed_memory32 *fixed_memory32;
 288         struct acpi_resource_extended_irq *extended_irq;
 289         int i;
 290
 291         switch (res->type) {
 292         case ACPI_RESOURCE_TYPE_IRQ:
 293                 /*
 294                  * Per spec, only one interrupt per descriptor is allowed in
 295                  * _CRS, but some firmware violates this, so parse them all.
 296                  */
 297                 irq = &res->data.irq;
 298                 for (i = 0; i < irq->interrupt_count; i++) {
 299                         pnpacpi_parse_allocated_irqresource(res_table,
 300                                 irq->interrupts[i],
 301                                 irq->triggering,
 302                                 irq->polarity,
 303                                 irq->sharable);
 304                 }
 305                 break;
 306
 307         case ACPI_RESOURCE_TYPE_DMA:
 308                 dma = &res->data.dma;
 309                 if (dma->channel_count > 0)
 310                         pnpacpi_parse_allocated_dmaresource(res_table,
 311                                 dma->channels[0],
 312                                 dma_flags(dma->type, dma->bus_master,
 313                                           dma->transfer));
 314                 break;
 315
 316         case ACPI_RESOURCE_TYPE_IO:
 317                 io = &res->data.io;
 318                 pnpacpi_parse_allocated_ioresource(res_table,
 319                         io->minimum,
 320                         io->address_length,
 321                         io->io_decode);
 322                 break;
 323
 324         case ACPI_RESOURCE_TYPE_START_DEPENDENT:
 325         case ACPI_RESOURCE_TYPE_END_DEPENDENT:
 326                 break;
 327
 328         case ACPI_RESOURCE_TYPE_FIXED_IO:
 329                 fixed_io = &res->data.fixed_io;
 330                 pnpacpi_parse_allocated_ioresource(res_table,
 331                         fixed_io->address,
 332                         fixed_io->address_length,
 333                         ACPI_DECODE_10);
 334                 break;
 335
 336         case ACPI_RESOURCE_TYPE_VENDOR:
 337                 break;
 338
 339         case ACPI_RESOURCE_TYPE_END_TAG:
 340                 break;
 341
 342         case ACPI_RESOURCE_TYPE_MEMORY24:
 343                 memory24 = &res->data.memory24;
 344                 pnpacpi_parse_allocated_memresource(res_table,
 345                         memory24->minimum,
 346                         memory24->address_length,
 347                         memory24->write_protect);
 348                 break;
 349         case ACPI_RESOURCE_TYPE_MEMORY32:
 350                 memory32 = &res->data.memory32;
 351                 pnpacpi_parse_allocated_memresource(res_table,
 352                         memory32->minimum,
 353                         memory32->address_length,
 354                         memory32->write_protect);
 355                 break;
 356         case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
 357                 fixed_memory32 = &res->data.fixed_memory32;
 358                 pnpacpi_parse_allocated_memresource(res_table,
 359                         fixed_memory32->address,
 360                         fixed_memory32->address_length,
 361                         fixed_memory32->write_protect);
 362                 break;
 363         case ACPI_RESOURCE_TYPE_ADDRESS16:
 364         case ACPI_RESOURCE_TYPE_ADDRESS32:
 365         case ACPI_RESOURCE_TYPE_ADDRESS64:
 366                 pnpacpi_parse_allocated_address_space(res_table, res);
 367                 break;
 368
 369         case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
 370                 if (res->data.ext_address64.producer_consumer == ACPI_PRODUCER)
 371                         return AE_OK;
 372                 break;
 373
 374         case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
 375                 extended_irq = &res->data.extended_irq;
 376                 if (extended_irq->producer_consumer == ACPI_PRODUCER)
 377                         return AE_OK;
 378
 379                 for (i = 0; i < extended_irq->interrupt_count; i++) {
 380                         pnpacpi_parse_allocated_irqresource(res_table,
 381                                 extended_irq->interrupts[i],
 382                                 extended_irq->triggering,
 383                                 extended_irq->polarity,
 384                                 extended_irq->sharable);
 385                 }
 386                 break;
 387
 388         case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
 389                 break;
 390
 391         default:
 392                 pnp_warn("PnPACPI: unknown resource type %d", res->type);
 393                 return AE_ERROR;
 394         }
 395
 396         return AE_OK;
 397 }
 398
 399 acpi_status pnpacpi_parse_allocated_resource(acpi_handle handle,
 400                                              struct pnp_resource_table * res)
 401 {
 402         /* Blank the resource table values */
 403         pnp_init_resource_table(res);
 404
 405         return acpi_walk_resources(handle, METHOD_NAME__CRS,
 406                                    pnpacpi_allocated_resource, res);
 407 }
 408
 409 static __init void pnpacpi_parse_dma_option(struct pnp_option *option,
 410                                             struct acpi_resource_dma *p)
 411 {
 412         int i;
 413         struct pnp_dma *dma;
 414
 415         if (p->channel_count == 0)
 416                 return;
 417         dma = kzalloc(sizeof(struct pnp_dma), GFP_KERNEL);
 418         if (!dma)
 419                 return;
 420
 421         for (i = 0; i < p->channel_count; i++)
 422                 dma->map |= 1 << p->channels[i];
 423
 424         dma->flags = dma_flags(p->type, p->bus_master, p->transfer);
 425
 426         pnp_register_dma_resource(option, dma);
 427 }
 428
 429 static __init void pnpacpi_parse_irq_option(struct pnp_option *option,
 430                                             struct acpi_resource_irq *p)
 431 {
 432         int i;
 433         struct pnp_irq *irq;
 434
 435         if (p->interrupt_count == 0)
 436                 return;
 437         irq = kzalloc(sizeof(struct pnp_irq), GFP_KERNEL);
 438         if (!irq)
 439                 return;
 440
 441         for (i = 0; i < p->interrupt_count; i++)
 442                 if (p->interrupts[i])
 443                         __set_bit(p->interrupts[i], irq->map);
 444         irq->flags = irq_flags(p->triggering, p->polarity);
 445
 446         pnp_register_irq_resource(option, irq);
 447 }
 448
 449 static __init void pnpacpi_parse_ext_irq_option(struct pnp_option *option,
 450                                         struct acpi_resource_extended_irq *p)
 451 {
 452         int i;
 453         struct pnp_irq *irq;
 454
 455         if (p->interrupt_count == 0)
 456                 return;
 457         irq = kzalloc(sizeof(struct pnp_irq), GFP_KERNEL);
 458         if (!irq)
 459                 return;
 460
 461         for (i = 0; i < p->interrupt_count; i++)
 462                 if (p->interrupts[i])
 463                         __set_bit(p->interrupts[i], irq->map);
 464         irq->flags = irq_flags(p->triggering, p->polarity);
 465
 466         pnp_register_irq_resource(option, irq);
 467 }
 468
 469 static __init void pnpacpi_parse_port_option(struct pnp_option *option,
 470                                              struct acpi_resource_io *io)
 471 {
 472         struct pnp_port *port;
 473
 474         if (io->address_length == 0)
 475                 return;
 476         port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL);
 477         if (!port)
 478                 return;
 479         port->min = io->minimum;
 480         port->max = io->maximum;
 481         port->align = io->alignment;
 482         port->size = io->address_length;
 483         port->flags = ACPI_DECODE_16 == io->io_decode ?
 484             PNP_PORT_FLAG_16BITADDR : 0;
 485         pnp_register_port_resource(option, port);
 486 }
 487
 488 static __init void pnpacpi_parse_fixed_port_option(struct pnp_option *option,
 489                                         struct acpi_resource_fixed_io *io)
 490 {
 491         struct pnp_port *port;
 492
 493         if (io->address_length == 0)
 494                 return;
 495         port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL);
 496         if (!port)
 497                 return;
 498         port->min = port->max = io->address;
 499         port->size = io->address_length;
 500         port->align = 0;
 501         port->flags = PNP_PORT_FLAG_FIXED;
 502         pnp_register_port_resource(option, port);
 503 }
 504
 505 static __init void pnpacpi_parse_mem24_option(struct pnp_option *option,
 506                                               struct acpi_resource_memory24 *p)
 507 {
 508         struct pnp_mem *mem;
 509
 510         if (p->address_length == 0)
 511                 return;
 512         mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
 513         if (!mem)
 514                 return;
 515         mem->min = p->minimum;
 516         mem->max = p->maximum;
 517         mem->align = p->alignment;
 518         mem->size = p->address_length;
 519
 520         mem->flags = (ACPI_READ_WRITE_MEMORY == p->write_protect) ?
 521             IORESOURCE_MEM_WRITEABLE : 0;
 522
 523         pnp_register_mem_resource(option, mem);
 524 }
 525
 526 static __init void pnpacpi_parse_mem32_option(struct pnp_option *option,
 527                                               struct acpi_resource_memory32 *p)
 528 {
 529         struct pnp_mem *mem;
 530
 531         if (p->address_length == 0)
 532                 return;
 533         mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
 534         if (!mem)
 535                 return;
 536         mem->min = p->minimum;
 537         mem->max = p->maximum;
 538         mem->align = p->alignment;
 539         mem->size = p->address_length;
 540
 541         mem->flags = (ACPI_READ_WRITE_MEMORY == p->write_protect) ?
 542             IORESOURCE_MEM_WRITEABLE : 0;
 543
 544         pnp_register_mem_resource(option, mem);
 545 }
 546
 547 static __init void pnpacpi_parse_fixed_mem32_option(struct pnp_option *option,
 548                                         struct acpi_resource_fixed_memory32 *p)
 549 {
 550         struct pnp_mem *mem;
 551
 552         if (p->address_length == 0)
 553                 return;
 554         mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
 555         if (!mem)
 556                 return;
 557         mem->min = mem->max = p->address;
 558         mem->size = p->address_length;
 559         mem->align = 0;
 560
 561         mem->flags = (ACPI_READ_WRITE_MEMORY == p->write_protect) ?
 562             IORESOURCE_MEM_WRITEABLE : 0;
 563
 564         pnp_register_mem_resource(option, mem);
 565 }
 566
 567 static __init void pnpacpi_parse_address_option(struct pnp_option *option,
 568                                                 struct acpi_resource *r)
 569 {
 570         struct acpi_resource_address64 addr, *p = &addr;
 571         acpi_status status;
 572         struct pnp_mem *mem;
 573         struct pnp_port *port;
 574
 575         status = acpi_resource_to_address64(r, p);
 576         if (!ACPI_SUCCESS(status)) {
 577                 pnp_warn("PnPACPI: failed to convert resource type %d",
 578                          r->type);
 579                 return;
 580         }
 581
 582         if (p->address_length == 0)
 583                 return;
 584
 585         if (p->resource_type == ACPI_MEMORY_RANGE) {
 586                 mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
 587                 if (!mem)
 588                         return;
 589                 mem->min = mem->max = p->minimum;
 590                 mem->size = p->address_length;
 591                 mem->align = 0;
 592                 mem->flags = (p->info.mem.write_protect ==
 593                               ACPI_READ_WRITE_MEMORY) ? IORESOURCE_MEM_WRITEABLE
 594                     : 0;
 595                 pnp_register_mem_resource(option, mem);
 596         } else if (p->resource_type == ACPI_IO_RANGE) {
 597                 port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL);
 598                 if (!port)
 599                         return;
 600                 port->min = port->max = p->minimum;
 601                 port->size = p->address_length;
 602                 port->align = 0;
 603                 port->flags = PNP_PORT_FLAG_FIXED;
 604                 pnp_register_port_resource(option, port);
 605         }
 606 }
 607
 608 struct acpipnp_parse_option_s {
 609         struct pnp_option *option;
 610         struct pnp_option *option_independent;
 611         struct pnp_dev *dev;
 612 };
 613
 614 static __init acpi_status pnpacpi_option_resource(struct acpi_resource *res,
 615                                                   void *data)
 616 {
 617         int priority = 0;
 618         struct acpipnp_parse_option_s *parse_data = data;
 619         struct pnp_dev *dev = parse_data->dev;
 620         struct pnp_option *option = parse_data->option;
 621
 622         switch (res->type) {
 623         case ACPI_RESOURCE_TYPE_IRQ:
 624                 pnpacpi_parse_irq_option(option, &res->data.irq);
 625                 break;
 626
 627         case ACPI_RESOURCE_TYPE_DMA:
 628                 pnpacpi_parse_dma_option(option, &res->data.dma);
 629                 break;
 630
 631         case ACPI_RESOURCE_TYPE_START_DEPENDENT:
 632                 switch (res->data.start_dpf.compatibility_priority) {
 633                 case ACPI_GOOD_CONFIGURATION:
 634                         priority = PNP_RES_PRIORITY_PREFERRED;
 635                         break;
 636
 637                 case ACPI_ACCEPTABLE_CONFIGURATION:
 638                         priority = PNP_RES_PRIORITY_ACCEPTABLE;
 639                         break;
 640
 641                 case ACPI_SUB_OPTIMAL_CONFIGURATION:
 642                         priority = PNP_RES_PRIORITY_FUNCTIONAL;
 643                         break;
 644                 default:
 645                         priority = PNP_RES_PRIORITY_INVALID;
 646                         break;
 647                 }
 648                 /* TBD: Consider performance/robustness bits */
 649                 option = pnp_register_dependent_option(dev, priority);
 650                 if (!option)
 651                         return AE_ERROR;
 652                 parse_data->option = option;
 653                 break;
 654
 655         case ACPI_RESOURCE_TYPE_END_DEPENDENT:
 656                 /*only one EndDependentFn is allowed */
 657                 if (!parse_data->option_independent) {
 658                         pnp_warn("PnPACPI: more than one EndDependentFn");
 659                         return AE_ERROR;
 660                 }
 661                 parse_data->option = parse_data->option_independent;
 662                 parse_data->option_independent = NULL;
 663                 break;
 664
 665         case ACPI_RESOURCE_TYPE_IO:
 666                 pnpacpi_parse_port_option(option, &res->data.io);
 667                 break;
 668
 669         case ACPI_RESOURCE_TYPE_FIXED_IO:
 670                 pnpacpi_parse_fixed_port_option(option, &res->data.fixed_io);
 671                 break;
 672
 673         case ACPI_RESOURCE_TYPE_VENDOR:
 674         case ACPI_RESOURCE_TYPE_END_TAG:
 675                 break;
 676
 677         case ACPI_RESOURCE_TYPE_MEMORY24:
 678                 pnpacpi_parse_mem24_option(option, &res->data.memory24);
 679                 break;
 680
 681         case ACPI_RESOURCE_TYPE_MEMORY32:
 682                 pnpacpi_parse_mem32_option(option, &res->data.memory32);
 683                 break;
 684
 685         case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
 686                 pnpacpi_parse_fixed_mem32_option(option,
 687                                                  &res->data.fixed_memory32);
 688                 break;
 689
 690         case ACPI_RESOURCE_TYPE_ADDRESS16:
 691         case ACPI_RESOURCE_TYPE_ADDRESS32:
 692         case ACPI_RESOURCE_TYPE_ADDRESS64:
 693                 pnpacpi_parse_address_option(option, res);
 694                 break;
 695
 696         case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
 697                 break;
 698
 699         case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
 700                 pnpacpi_parse_ext_irq_option(option, &res->data.extended_irq);
 701                 break;
 702
 703         case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
 704                 break;
 705
 706         default:
 707                 pnp_warn("PnPACPI: unknown resource type %d", res->type);
 708                 return AE_ERROR;
 709         }
 710
 711         return AE_OK;
 712 }
 713
 714 acpi_status __init pnpacpi_parse_resource_option_data(acpi_handle handle,
 715                                                       struct pnp_dev *dev)
 716 {
 717         acpi_status status;
 718         struct acpipnp_parse_option_s parse_data;
 719
 720         parse_data.option = pnp_register_independent_option(dev);
 721         if (!parse_data.option)
 722                 return AE_ERROR;
 723         parse_data.option_independent = parse_data.option;
 724         parse_data.dev = dev;
 725         status = acpi_walk_resources(handle, METHOD_NAME__PRS,
 726                                      pnpacpi_option_resource, &parse_data);
 727
 728         return status;
 729 }
 730
 731 static int pnpacpi_supported_resource(struct acpi_resource *res)
 732 {
 733         switch (res->type) {
 734         case ACPI_RESOURCE_TYPE_IRQ:
 735         case ACPI_RESOURCE_TYPE_DMA:
 736         case ACPI_RESOURCE_TYPE_IO:
 737         case ACPI_RESOURCE_TYPE_FIXED_IO:
 738         case ACPI_RESOURCE_TYPE_MEMORY24:
 739         case ACPI_RESOURCE_TYPE_MEMORY32:
 740         case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
 741         case ACPI_RESOURCE_TYPE_ADDRESS16:
 742         case ACPI_RESOURCE_TYPE_ADDRESS32:
 743         case ACPI_RESOURCE_TYPE_ADDRESS64:
 744         case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
 745                 return 1;
 746         }
 747         return 0;
 748 }
 749
 750 /*
 751  * Set resource
 752  */
 753 static acpi_status pnpacpi_count_resources(struct acpi_resource *res,
 754                                            void *data)
 755 {
 756         int *res_cnt = data;
 757
 758         if (pnpacpi_supported_resource(res))
 759                 (*res_cnt)++;
 760         return AE_OK;
 761 }
 762
 763 static acpi_status pnpacpi_type_resources(struct acpi_resource *res, void *data)
 764 {
 765         struct acpi_resource **resource = data;
 766
 767         if (pnpacpi_supported_resource(res)) {
 768                 (*resource)->type = res->type;
 769                 (*resource)->length = sizeof(struct acpi_resource);
 770                 (*resource)++;
 771         }
 772
 773         return AE_OK;
 774 }
 775
 776 int pnpacpi_build_resource_template(acpi_handle handle,
 777                                     struct acpi_buffer *buffer)
 778 {
 779         struct acpi_resource *resource;
 780         int res_cnt = 0;
 781         acpi_status status;
 782
 783         status = acpi_walk_resources(handle, METHOD_NAME__CRS,
 784                                      pnpacpi_count_resources, &res_cnt);
 785         if (ACPI_FAILURE(status)) {
 786                 pnp_err("Evaluate _CRS failed");
 787                 return -EINVAL;
 788         }
 789         if (!res_cnt)
 790                 return -EINVAL;
 791         buffer->length = sizeof(struct acpi_resource) * (res_cnt + 1) + 1;
 792         buffer->pointer = kzalloc(buffer->length - 1, GFP_KERNEL);
 793         if (!buffer->pointer)
 794                 return -ENOMEM;
 795         pnp_dbg("Res cnt %d", res_cnt);
 796         resource = (struct acpi_resource *)buffer->pointer;
 797         status = acpi_walk_resources(handle, METHOD_NAME__CRS,
 798                                      pnpacpi_type_resources, &resource);
 799         if (ACPI_FAILURE(status)) {
 800                 kfree(buffer->pointer);
 801                 pnp_err("Evaluate _CRS failed");
 802                 return -EINVAL;
 803         }
 804         /* resource will pointer the end resource now */
 805         resource->type = ACPI_RESOURCE_TYPE_END_TAG;
 806
 807         return 0;
 808 }
 809
 810 static void pnpacpi_encode_irq(struct acpi_resource *resource,
 811                                struct resource *p)
 812 {
 813         struct acpi_resource_irq *irq = &resource->data.irq;
 814         int triggering, polarity;
 815
 816         decode_irq_flags(p->flags & IORESOURCE_BITS, &triggering, &polarity);
 817         irq->triggering = triggering;
 818         irq->polarity = polarity;
 819         if (triggering == ACPI_EDGE_SENSITIVE)
 820                 irq->sharable = ACPI_EXCLUSIVE;
 821         else
 822                 irq->sharable = ACPI_SHARED;
 823         irq->interrupt_count = 1;
 824         irq->interrupts[0] = p->start;
 825 }
 826
 827 static void pnpacpi_encode_ext_irq(struct acpi_resource *resource,
 828                                    struct resource *p)
 829 {
 830         struct acpi_resource_extended_irq *extended_irq = &resource->data.extended_irq;
 831         int triggering, polarity;
 832
 833         decode_irq_flags(p->flags & IORESOURCE_BITS, &triggering, &polarity);
 834         extended_irq->producer_consumer = ACPI_CONSUMER;
 835         extended_irq->triggering = triggering;
 836         extended_irq->polarity = polarity;
 837         if (triggering == ACPI_EDGE_SENSITIVE)
 838                 extended_irq->sharable = ACPI_EXCLUSIVE;
 839         else
 840                 extended_irq->sharable = ACPI_SHARED;
 841         extended_irq->interrupt_count = 1;
 842         extended_irq->interrupts[0] = p->start;
 843 }
 844
 845 static void pnpacpi_encode_dma(struct acpi_resource *resource,
 846                                struct resource *p)
 847 {
 848         struct acpi_resource_dma *dma = &resource->data.dma;
 849
 850         /* Note: pnp_assign_dma will copy pnp_dma->flags into p->flags */
 851         switch (p->flags & IORESOURCE_DMA_SPEED_MASK) {
 852         case IORESOURCE_DMA_TYPEA:
 853                 dma->type = ACPI_TYPE_A;
 854                 break;
 855         case IORESOURCE_DMA_TYPEB:
 856                 dma->type = ACPI_TYPE_B;
 857                 break;
 858         case IORESOURCE_DMA_TYPEF:
 859                 dma->type = ACPI_TYPE_F;
 860                 break;
 861         default:
 862                 dma->type = ACPI_COMPATIBILITY;
 863         }
 864
 865         switch (p->flags & IORESOURCE_DMA_TYPE_MASK) {
 866         case IORESOURCE_DMA_8BIT:
 867                 dma->transfer = ACPI_TRANSFER_8;
 868                 break;
 869         case IORESOURCE_DMA_8AND16BIT:
 870                 dma->transfer = ACPI_TRANSFER_8_16;
 871                 break;
 872         default:
 873                 dma->transfer = ACPI_TRANSFER_16;
 874         }
 875
 876         dma->bus_master = !!(p->flags & IORESOURCE_DMA_MASTER);
 877         dma->channel_count = 1;
 878         dma->channels[0] = p->start;
 879 }
 880
 881 static void pnpacpi_encode_io(struct acpi_resource *resource,
 882                               struct resource *p)
 883 {
 884         struct acpi_resource_io *io = &resource->data.io;
 885
 886         /* Note: pnp_assign_port will copy pnp_port->flags into p->flags */
 887         io->io_decode = (p->flags & PNP_PORT_FLAG_16BITADDR) ?
 888             ACPI_DECODE_16 : ACPI_DECODE_10;
 889         io->minimum = p->start;
 890         io->maximum = p->end;
 891         io->alignment = 0;      /* Correct? */
 892         io->address_length = p->end - p->start + 1;
 893 }
 894
 895 static void pnpacpi_encode_fixed_io(struct acpi_resource *resource,
 896                                     struct resource *p)
 897 {
 898         struct acpi_resource_fixed_io *fixed_io = &resource->data.fixed_io;
 899
 900         fixed_io->address = p->start;
 901         fixed_io->address_length = p->end - p->start + 1;
 902 }
 903
 904 static void pnpacpi_encode_mem24(struct acpi_resource *resource,
 905                                  struct resource *p)
 906 {
 907         struct acpi_resource_memory24 *memory24 = &resource->data.memory24;
 908
 909         /* Note: pnp_assign_mem will copy pnp_mem->flags into p->flags */
 910         memory24->write_protect =
 911             (p->flags & IORESOURCE_MEM_WRITEABLE) ?
 912             ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
 913         memory24->minimum = p->start;
 914         memory24->maximum = p->end;
 915         memory24->alignment = 0;
 916         memory24->address_length = p->end - p->start + 1;
 917 }
 918
 919 static void pnpacpi_encode_mem32(struct acpi_resource *resource,
 920                                  struct resource *p)
 921 {
 922         struct acpi_resource_memory32 *memory32 = &resource->data.memory32;
 923
 924         memory32->write_protect =
 925             (p->flags & IORESOURCE_MEM_WRITEABLE) ?
 926             ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
 927         memory32->minimum = p->start;
 928         memory32->maximum = p->end;
 929         memory32->alignment = 0;
 930         memory32->address_length = p->end - p->start + 1;
 931 }
 932
 933 static void pnpacpi_encode_fixed_mem32(struct acpi_resource *resource,
 934                                        struct resource *p)
 935 {
 936         struct acpi_resource_fixed_memory32 *fixed_memory32 = &resource->data.fixed_memory32;
 937
 938         fixed_memory32->write_protect =
 939             (p->flags & IORESOURCE_MEM_WRITEABLE) ?
 940             ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
 941         fixed_memory32->address = p->start;
 942         fixed_memory32->address_length = p->end - p->start + 1;
 943 }
 944
 945 int pnpacpi_encode_resources(struct pnp_resource_table *res_table,
 946                              struct acpi_buffer *buffer)
 947 {
 948         int i = 0;
 949         /* pnpacpi_build_resource_template allocates extra mem */
 950         int res_cnt = (buffer->length - 1) / sizeof(struct acpi_resource) - 1;
 951         struct acpi_resource *resource = buffer->pointer;
 952         int port = 0, irq = 0, dma = 0, mem = 0;
 953
 954         pnp_dbg("res cnt %d", res_cnt);
 955         while (i < res_cnt) {
 956                 switch (resource->type) {
 957                 case ACPI_RESOURCE_TYPE_IRQ:
 958                         pnp_dbg("Encode irq");
 959                         pnpacpi_encode_irq(resource,
 960                                            &res_table->irq_resource[irq]);
 961                         irq++;
 962                         break;
 963
 964                 case ACPI_RESOURCE_TYPE_DMA:
 965                         pnp_dbg("Encode dma");
 966                         pnpacpi_encode_dma(resource,
 967                                            &res_table->dma_resource[dma]);
 968                         dma++;
 969                         break;
 970                 case ACPI_RESOURCE_TYPE_IO:
 971                         pnp_dbg("Encode io");
 972                         pnpacpi_encode_io(resource,
 973                                           &res_table->port_resource[port]);
 974                         port++;
 975                         break;
 976                 case ACPI_RESOURCE_TYPE_FIXED_IO:
 977                         pnp_dbg("Encode fixed io");
 978                         pnpacpi_encode_fixed_io(resource,
 979                                                 &res_table->
 980                                                 port_resource[port]);
 981                         port++;
 982                         break;
 983                 case ACPI_RESOURCE_TYPE_MEMORY24:
 984                         pnp_dbg("Encode mem24");
 985                         pnpacpi_encode_mem24(resource,
 986                                              &res_table->mem_resource[mem]);
 987                         mem++;
 988                         break;
 989                 case ACPI_RESOURCE_TYPE_MEMORY32:
 990                         pnp_dbg("Encode mem32");
 991                         pnpacpi_encode_mem32(resource,
 992                                              &res_table->mem_resource[mem]);
 993                         mem++;
 994                         break;
 995                 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
 996                         pnp_dbg("Encode fixed mem32");
 997                         pnpacpi_encode_fixed_mem32(resource,
 998                                                    &res_table->
 999                                                    mem_resource[mem]);
1000                         mem++;
1001                         break;
1002                 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
1003                         pnp_dbg("Encode ext irq");
1004                         pnpacpi_encode_ext_irq(resource,
1005                                                &res_table->irq_resource[irq]);
1006                         irq++;
1007                         break;
1008                 case ACPI_RESOURCE_TYPE_START_DEPENDENT:
1009                 case ACPI_RESOURCE_TYPE_END_DEPENDENT:
1010                 case ACPI_RESOURCE_TYPE_VENDOR:
1011                 case ACPI_RESOURCE_TYPE_END_TAG:
1012                 case ACPI_RESOURCE_TYPE_ADDRESS16:
1013                 case ACPI_RESOURCE_TYPE_ADDRESS32:
1014                 case ACPI_RESOURCE_TYPE_ADDRESS64:
1015                 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
1016                 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
1017                 default:        /* other type */
1018                         pnp_warn("unknown resource type %d", resource->type);
1019                         return -EINVAL;
1020                 }
1021                 resource++;
1022                 i++;
1023         }
1024         return 0;
1025 }