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 type,
 173                                                 int bus_master, int transfer)
 174 {
 175         int i = 0;
 176         static unsigned char warned;
 177
 178         while (i < PNP_MAX_DMA &&
 179                !(res->dma_resource[i].flags & IORESOURCE_UNSET))
 180                 i++;
 181         if (i < PNP_MAX_DMA) {
 182                 res->dma_resource[i].flags = IORESOURCE_DMA;    // Also clears _UNSET flag
 183                 res->dma_resource[i].flags |=
 184                     dma_flags(type, bus_master, transfer);
 185                 if (dma == -1) {
 186                         res->dma_resource[i].flags |= IORESOURCE_DISABLED;
 187                         return;
 188                 }
 189                 res->dma_resource[i].start = dma;
 190                 res->dma_resource[i].end = dma;
 191         } else if (!warned) {
 192                 printk(KERN_WARNING "pnpacpi: exceeded the max number of DMA "
 193                                 "resources: %d \n", PNP_MAX_DMA);
 194                 warned = 1;
 195         }
 196 }
 197
 198 static void pnpacpi_parse_allocated_ioresource(struct pnp_resource_table *res,
 199                                                u64 io, u64 len, int io_decode)
 200 {
 201         int i = 0;
 202         static unsigned char warned;
 203
 204         while (!(res->port_resource[i].flags & IORESOURCE_UNSET) &&
 205                i < PNP_MAX_PORT)
 206                 i++;
 207         if (i < PNP_MAX_PORT) {
 208                 res->port_resource[i].flags = IORESOURCE_IO;    // Also clears _UNSET flag
 209                 if (io_decode == ACPI_DECODE_16)
 210                         res->port_resource[i].flags |= PNP_PORT_FLAG_16BITADDR;
 211                 if (len <= 0 || (io + len - 1) >= 0x10003) {
 212                         res->port_resource[i].flags |= IORESOURCE_DISABLED;
 213                         return;
 214                 }
 215                 res->port_resource[i].start = io;
 216                 res->port_resource[i].end = io + len - 1;
 217         } else if (!warned) {
 218                 printk(KERN_WARNING "pnpacpi: exceeded the max number of IO "
 219                                 "resources: %d \n", PNP_MAX_PORT);
 220                 warned = 1;
 221         }
 222 }
 223
 224 static void pnpacpi_parse_allocated_memresource(struct pnp_resource_table *res,
 225                                                 u64 mem, u64 len,
 226                                                 int write_protect)
 227 {
 228         int i = 0;
 229         static unsigned char warned;
 230
 231         while (!(res->mem_resource[i].flags & IORESOURCE_UNSET) &&
 232                (i < PNP_MAX_MEM))
 233                 i++;
 234         if (i < PNP_MAX_MEM) {
 235                 res->mem_resource[i].flags = IORESOURCE_MEM;    // Also clears _UNSET flag
 236                 if (len <= 0) {
 237                         res->mem_resource[i].flags |= IORESOURCE_DISABLED;
 238                         return;
 239                 }
 240                 if (write_protect == ACPI_READ_WRITE_MEMORY)
 241                         res->mem_resource[i].flags |= IORESOURCE_MEM_WRITEABLE;
 242
 243                 res->mem_resource[i].start = mem;
 244                 res->mem_resource[i].end = mem + len - 1;
 245         } else if (!warned) {
 246                 printk(KERN_WARNING "pnpacpi: exceeded the max number of mem "
 247                                 "resources: %d\n", PNP_MAX_MEM);
 248                 warned = 1;
 249         }
 250 }
 251
 252 static void pnpacpi_parse_allocated_address_space(struct pnp_resource_table *res_table,
 253                                                   struct acpi_resource *res)
 254 {
 255         struct acpi_resource_address64 addr, *p = &addr;
 256         acpi_status status;
 257
 258         status = acpi_resource_to_address64(res, p);
 259         if (!ACPI_SUCCESS(status)) {
 260                 pnp_warn("PnPACPI: failed to convert resource type %d",
 261                          res->type);
 262                 return;
 263         }
 264
 265         if (p->producer_consumer == ACPI_PRODUCER)
 266                 return;
 267
 268         if (p->resource_type == ACPI_MEMORY_RANGE)
 269                 pnpacpi_parse_allocated_memresource(res_table,
 270                         p->minimum, p->address_length,
 271                         p->info.mem.write_protect);
 272         else if (p->resource_type == ACPI_IO_RANGE)
 273                 pnpacpi_parse_allocated_ioresource(res_table,
 274                         p->minimum, p->address_length,
 275                         p->granularity == 0xfff ? ACPI_DECODE_10 :
 276                                 ACPI_DECODE_16);
 277 }
 278
 279 static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res,
 280                                               void *data)
 281 {
 282         struct pnp_resource_table *res_table = data;
 283         struct acpi_resource_irq *irq;
 284         struct acpi_resource_dma *dma;
 285         struct acpi_resource_io *io;
 286         struct acpi_resource_fixed_io *fixed_io;
 287         struct acpi_resource_memory24 *memory24;
 288         struct acpi_resource_memory32 *memory32;
 289         struct acpi_resource_fixed_memory32 *fixed_memory32;
 290         struct acpi_resource_extended_irq *extended_irq;
 291         int i;
 292
 293         switch (res->type) {
 294         case ACPI_RESOURCE_TYPE_IRQ:
 295                 /*
 296                  * Per spec, only one interrupt per descriptor is allowed in
 297                  * _CRS, but some firmware violates this, so parse them all.
 298                  */
 299                 irq = &res->data.irq;
 300                 for (i = 0; i < irq->interrupt_count; i++) {
 301                         pnpacpi_parse_allocated_irqresource(res_table,
 302                                 irq->interrupts[i],
 303                                 irq->triggering,
 304                                 irq->polarity,
 305                                 irq->sharable);
 306                 }
 307                 break;
 308
 309         case ACPI_RESOURCE_TYPE_DMA:
 310                 dma = &res->data.dma;
 311                 if (dma->channel_count > 0)
 312                         pnpacpi_parse_allocated_dmaresource(res_table,
 313                                 dma->channels[0],
 314                                 dma->type,
 315                                 dma->bus_master,
 316                                 dma->transfer);
 317                 break;
 318
 319         case ACPI_RESOURCE_TYPE_IO:
 320                 io = &res->data.io;
 321                 pnpacpi_parse_allocated_ioresource(res_table,
 322                         io->minimum,
 323                         io->address_length,
 324                         io->io_decode);
 325                 break;
 326
 327         case ACPI_RESOURCE_TYPE_START_DEPENDENT:
 328         case ACPI_RESOURCE_TYPE_END_DEPENDENT:
 329                 break;
 330
 331         case ACPI_RESOURCE_TYPE_FIXED_IO:
 332                 fixed_io = &res->data.fixed_io;
 333                 pnpacpi_parse_allocated_ioresource(res_table,
 334                         fixed_io->address,
 335                         fixed_io->address_length,
 336                         ACPI_DECODE_10);
 337                 break;
 338
 339         case ACPI_RESOURCE_TYPE_VENDOR:
 340                 break;
 341
 342         case ACPI_RESOURCE_TYPE_END_TAG:
 343                 break;
 344
 345         case ACPI_RESOURCE_TYPE_MEMORY24:
 346                 memory24 = &res->data.memory24;
 347                 pnpacpi_parse_allocated_memresource(res_table,
 348                         memory24->minimum,
 349                         memory24->address_length,
 350                         memory24->write_protect);
 351                 break;
 352         case ACPI_RESOURCE_TYPE_MEMORY32:
 353                 memory32 = &res->data.memory32;
 354                 pnpacpi_parse_allocated_memresource(res_table,
 355                         memory32->minimum,
 356                         memory32->address_length,
 357                         memory32->write_protect);
 358                 break;
 359         case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
 360                 fixed_memory32 = &res->data.fixed_memory32;
 361                 pnpacpi_parse_allocated_memresource(res_table,
 362                         fixed_memory32->address,
 363                         fixed_memory32->address_length,
 364                         fixed_memory32->write_protect);
 365                 break;
 366         case ACPI_RESOURCE_TYPE_ADDRESS16:
 367         case ACPI_RESOURCE_TYPE_ADDRESS32:
 368         case ACPI_RESOURCE_TYPE_ADDRESS64:
 369                 pnpacpi_parse_allocated_address_space(res_table, res);
 370                 break;
 371
 372         case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
 373                 if (res->data.ext_address64.producer_consumer == ACPI_PRODUCER)
 374                         return AE_OK;
 375                 break;
 376
 377         case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
 378                 extended_irq = &res->data.extended_irq;
 379                 if (extended_irq->producer_consumer == ACPI_PRODUCER)
 380                         return AE_OK;
 381
 382                 for (i = 0; i < extended_irq->interrupt_count; i++) {
 383                         pnpacpi_parse_allocated_irqresource(res_table,
 384                                 extended_irq->interrupts[i],
 385                                 extended_irq->triggering,
 386                                 extended_irq->polarity,
 387                                 extended_irq->sharable);
 388                 }
 389                 break;
 390
 391         case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
 392                 break;
 393
 394         default:
 395                 pnp_warn("PnPACPI: unknown resource type %d", res->type);
 396                 return AE_ERROR;
 397         }
 398
 399         return AE_OK;
 400 }
 401
 402 acpi_status pnpacpi_parse_allocated_resource(acpi_handle handle,
 403                                              struct pnp_resource_table * res)
 404 {
 405         /* Blank the resource table values */
 406         pnp_init_resource_table(res);
 407
 408         return acpi_walk_resources(handle, METHOD_NAME__CRS,
 409                                    pnpacpi_allocated_resource, res);
 410 }
 411
 412 static __init void pnpacpi_parse_dma_option(struct pnp_option *option,
 413                                             struct acpi_resource_dma *p)
 414 {
 415         int i;
 416         struct pnp_dma *dma;
 417
 418         if (p->channel_count == 0)
 419                 return;
 420         dma = kzalloc(sizeof(struct pnp_dma), GFP_KERNEL);
 421         if (!dma)
 422                 return;
 423
 424         for (i = 0; i < p->channel_count; i++)
 425                 dma->map |= 1 << p->channels[i];
 426
 427         dma->flags = dma_flags(p->type, p->bus_master, p->transfer);
 428
 429         pnp_register_dma_resource(option, dma);
 430 }
 431
 432 static __init void pnpacpi_parse_irq_option(struct pnp_option *option,
 433                                             struct acpi_resource_irq *p)
 434 {
 435         int i;
 436         struct pnp_irq *irq;
 437
 438         if (p->interrupt_count == 0)
 439                 return;
 440         irq = kzalloc(sizeof(struct pnp_irq), GFP_KERNEL);
 441         if (!irq)
 442                 return;
 443
 444         for (i = 0; i < p->interrupt_count; i++)
 445                 if (p->interrupts[i])
 446                         __set_bit(p->interrupts[i], irq->map);
 447         irq->flags = irq_flags(p->triggering, p->polarity);
 448
 449         pnp_register_irq_resource(option, irq);
 450 }
 451
 452 static __init void pnpacpi_parse_ext_irq_option(struct pnp_option *option,
 453                                         struct acpi_resource_extended_irq *p)
 454 {
 455         int i;
 456         struct pnp_irq *irq;
 457
 458         if (p->interrupt_count == 0)
 459                 return;
 460         irq = kzalloc(sizeof(struct pnp_irq), GFP_KERNEL);
 461         if (!irq)
 462                 return;
 463
 464         for (i = 0; i < p->interrupt_count; i++)
 465                 if (p->interrupts[i])
 466                         __set_bit(p->interrupts[i], irq->map);
 467         irq->flags = irq_flags(p->triggering, p->polarity);
 468
 469         pnp_register_irq_resource(option, irq);
 470 }
 471
 472 static __init void pnpacpi_parse_port_option(struct pnp_option *option,
 473                                              struct acpi_resource_io *io)
 474 {
 475         struct pnp_port *port;
 476
 477         if (io->address_length == 0)
 478                 return;
 479         port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL);
 480         if (!port)
 481                 return;
 482         port->min = io->minimum;
 483         port->max = io->maximum;
 484         port->align = io->alignment;
 485         port->size = io->address_length;
 486         port->flags = ACPI_DECODE_16 == io->io_decode ?
 487             PNP_PORT_FLAG_16BITADDR : 0;
 488         pnp_register_port_resource(option, port);
 489 }
 490
 491 static __init void pnpacpi_parse_fixed_port_option(struct pnp_option *option,
 492                                         struct acpi_resource_fixed_io *io)
 493 {
 494         struct pnp_port *port;
 495
 496         if (io->address_length == 0)
 497                 return;
 498         port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL);
 499         if (!port)
 500                 return;
 501         port->min = port->max = io->address;
 502         port->size = io->address_length;
 503         port->align = 0;
 504         port->flags = PNP_PORT_FLAG_FIXED;
 505         pnp_register_port_resource(option, port);
 506 }
 507
 508 static __init void pnpacpi_parse_mem24_option(struct pnp_option *option,
 509                                               struct acpi_resource_memory24 *p)
 510 {
 511         struct pnp_mem *mem;
 512
 513         if (p->address_length == 0)
 514                 return;
 515         mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
 516         if (!mem)
 517                 return;
 518         mem->min = p->minimum;
 519         mem->max = p->maximum;
 520         mem->align = p->alignment;
 521         mem->size = p->address_length;
 522
 523         mem->flags = (ACPI_READ_WRITE_MEMORY == p->write_protect) ?
 524             IORESOURCE_MEM_WRITEABLE : 0;
 525
 526         pnp_register_mem_resource(option, mem);
 527 }
 528
 529 static __init void pnpacpi_parse_mem32_option(struct pnp_option *option,
 530                                               struct acpi_resource_memory32 *p)
 531 {
 532         struct pnp_mem *mem;
 533
 534         if (p->address_length == 0)
 535                 return;
 536         mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
 537         if (!mem)
 538                 return;
 539         mem->min = p->minimum;
 540         mem->max = p->maximum;
 541         mem->align = p->alignment;
 542         mem->size = p->address_length;
 543
 544         mem->flags = (ACPI_READ_WRITE_MEMORY == p->write_protect) ?
 545             IORESOURCE_MEM_WRITEABLE : 0;
 546
 547         pnp_register_mem_resource(option, mem);
 548 }
 549
 550 static __init void pnpacpi_parse_fixed_mem32_option(struct pnp_option *option,
 551                                         struct acpi_resource_fixed_memory32 *p)
 552 {
 553         struct pnp_mem *mem;
 554
 555         if (p->address_length == 0)
 556                 return;
 557         mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
 558         if (!mem)
 559                 return;
 560         mem->min = mem->max = p->address;
 561         mem->size = p->address_length;
 562         mem->align = 0;
 563
 564         mem->flags = (ACPI_READ_WRITE_MEMORY == p->write_protect) ?
 565             IORESOURCE_MEM_WRITEABLE : 0;
 566
 567         pnp_register_mem_resource(option, mem);
 568 }
 569
 570 static __init void pnpacpi_parse_address_option(struct pnp_option *option,
 571                                                 struct acpi_resource *r)
 572 {
 573         struct acpi_resource_address64 addr, *p = &addr;
 574         acpi_status status;
 575         struct pnp_mem *mem;
 576         struct pnp_port *port;
 577
 578         status = acpi_resource_to_address64(r, p);
 579         if (!ACPI_SUCCESS(status)) {
 580                 pnp_warn("PnPACPI: failed to convert resource type %d",
 581                          r->type);
 582                 return;
 583         }
 584
 585         if (p->address_length == 0)
 586                 return;
 587
 588         if (p->resource_type == ACPI_MEMORY_RANGE) {
 589                 mem = kzalloc(sizeof(struct pnp_mem), GFP_KERNEL);
 590                 if (!mem)
 591                         return;
 592                 mem->min = mem->max = p->minimum;
 593                 mem->size = p->address_length;
 594                 mem->align = 0;
 595                 mem->flags = (p->info.mem.write_protect ==
 596                               ACPI_READ_WRITE_MEMORY) ? IORESOURCE_MEM_WRITEABLE
 597                     : 0;
 598                 pnp_register_mem_resource(option, mem);
 599         } else if (p->resource_type == ACPI_IO_RANGE) {
 600                 port = kzalloc(sizeof(struct pnp_port), GFP_KERNEL);
 601                 if (!port)
 602                         return;
 603                 port->min = port->max = p->minimum;
 604                 port->size = p->address_length;
 605                 port->align = 0;
 606                 port->flags = PNP_PORT_FLAG_FIXED;
 607                 pnp_register_port_resource(option, port);
 608         }
 609 }
 610
 611 struct acpipnp_parse_option_s {
 612         struct pnp_option *option;
 613         struct pnp_option *option_independent;
 614         struct pnp_dev *dev;
 615 };
 616
 617 static __init acpi_status pnpacpi_option_resource(struct acpi_resource *res,
 618                                                   void *data)
 619 {
 620         int priority = 0;
 621         struct acpipnp_parse_option_s *parse_data = data;
 622         struct pnp_dev *dev = parse_data->dev;
 623         struct pnp_option *option = parse_data->option;
 624
 625         switch (res->type) {
 626         case ACPI_RESOURCE_TYPE_IRQ:
 627                 pnpacpi_parse_irq_option(option, &res->data.irq);
 628                 break;
 629
 630         case ACPI_RESOURCE_TYPE_DMA:
 631                 pnpacpi_parse_dma_option(option, &res->data.dma);
 632                 break;
 633
 634         case ACPI_RESOURCE_TYPE_START_DEPENDENT:
 635                 switch (res->data.start_dpf.compatibility_priority) {
 636                 case ACPI_GOOD_CONFIGURATION:
 637                         priority = PNP_RES_PRIORITY_PREFERRED;
 638                         break;
 639
 640                 case ACPI_ACCEPTABLE_CONFIGURATION:
 641                         priority = PNP_RES_PRIORITY_ACCEPTABLE;
 642                         break;
 643
 644                 case ACPI_SUB_OPTIMAL_CONFIGURATION:
 645                         priority = PNP_RES_PRIORITY_FUNCTIONAL;
 646                         break;
 647                 default:
 648                         priority = PNP_RES_PRIORITY_INVALID;
 649                         break;
 650                 }
 651                 /* TBD: Consider performance/robustness bits */
 652                 option = pnp_register_dependent_option(dev, priority);
 653                 if (!option)
 654                         return AE_ERROR;
 655                 parse_data->option = option;
 656                 break;
 657
 658         case ACPI_RESOURCE_TYPE_END_DEPENDENT:
 659                 /*only one EndDependentFn is allowed */
 660                 if (!parse_data->option_independent) {
 661                         pnp_warn("PnPACPI: more than one EndDependentFn");
 662                         return AE_ERROR;
 663                 }
 664                 parse_data->option = parse_data->option_independent;
 665                 parse_data->option_independent = NULL;
 666                 break;
 667
 668         case ACPI_RESOURCE_TYPE_IO:
 669                 pnpacpi_parse_port_option(option, &res->data.io);
 670                 break;
 671
 672         case ACPI_RESOURCE_TYPE_FIXED_IO:
 673                 pnpacpi_parse_fixed_port_option(option, &res->data.fixed_io);
 674                 break;
 675
 676         case ACPI_RESOURCE_TYPE_VENDOR:
 677         case ACPI_RESOURCE_TYPE_END_TAG:
 678                 break;
 679
 680         case ACPI_RESOURCE_TYPE_MEMORY24:
 681                 pnpacpi_parse_mem24_option(option, &res->data.memory24);
 682                 break;
 683
 684         case ACPI_RESOURCE_TYPE_MEMORY32:
 685                 pnpacpi_parse_mem32_option(option, &res->data.memory32);
 686                 break;
 687
 688         case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
 689                 pnpacpi_parse_fixed_mem32_option(option,
 690                                                  &res->data.fixed_memory32);
 691                 break;
 692
 693         case ACPI_RESOURCE_TYPE_ADDRESS16:
 694         case ACPI_RESOURCE_TYPE_ADDRESS32:
 695         case ACPI_RESOURCE_TYPE_ADDRESS64:
 696                 pnpacpi_parse_address_option(option, res);
 697                 break;
 698
 699         case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
 700                 break;
 701
 702         case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
 703                 pnpacpi_parse_ext_irq_option(option, &res->data.extended_irq);
 704                 break;
 705
 706         case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
 707                 break;
 708
 709         default:
 710                 pnp_warn("PnPACPI: unknown resource type %d", res->type);
 711                 return AE_ERROR;
 712         }
 713
 714         return AE_OK;
 715 }
 716
 717 acpi_status __init pnpacpi_parse_resource_option_data(acpi_handle handle,
 718                                                       struct pnp_dev *dev)
 719 {
 720         acpi_status status;
 721         struct acpipnp_parse_option_s parse_data;
 722
 723         parse_data.option = pnp_register_independent_option(dev);
 724         if (!parse_data.option)
 725                 return AE_ERROR;
 726         parse_data.option_independent = parse_data.option;
 727         parse_data.dev = dev;
 728         status = acpi_walk_resources(handle, METHOD_NAME__PRS,
 729                                      pnpacpi_option_resource, &parse_data);
 730
 731         return status;
 732 }
 733
 734 static int pnpacpi_supported_resource(struct acpi_resource *res)
 735 {
 736         switch (res->type) {
 737         case ACPI_RESOURCE_TYPE_IRQ:
 738         case ACPI_RESOURCE_TYPE_DMA:
 739         case ACPI_RESOURCE_TYPE_IO:
 740         case ACPI_RESOURCE_TYPE_FIXED_IO:
 741         case ACPI_RESOURCE_TYPE_MEMORY24:
 742         case ACPI_RESOURCE_TYPE_MEMORY32:
 743         case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
 744         case ACPI_RESOURCE_TYPE_ADDRESS16:
 745         case ACPI_RESOURCE_TYPE_ADDRESS32:
 746         case ACPI_RESOURCE_TYPE_ADDRESS64:
 747         case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
 748                 return 1;
 749         }
 750         return 0;
 751 }
 752
 753 /*
 754  * Set resource
 755  */
 756 static acpi_status pnpacpi_count_resources(struct acpi_resource *res,
 757                                            void *data)
 758 {
 759         int *res_cnt = data;
 760
 761         if (pnpacpi_supported_resource(res))
 762                 (*res_cnt)++;
 763         return AE_OK;
 764 }
 765
 766 static acpi_status pnpacpi_type_resources(struct acpi_resource *res, void *data)
 767 {
 768         struct acpi_resource **resource = data;
 769
 770         if (pnpacpi_supported_resource(res)) {
 771                 (*resource)->type = res->type;
 772                 (*resource)->length = sizeof(struct acpi_resource);
 773                 (*resource)++;
 774         }
 775
 776         return AE_OK;
 777 }
 778
 779 int pnpacpi_build_resource_template(acpi_handle handle,
 780                                     struct acpi_buffer *buffer)
 781 {
 782         struct acpi_resource *resource;
 783         int res_cnt = 0;
 784         acpi_status status;
 785
 786         status = acpi_walk_resources(handle, METHOD_NAME__CRS,
 787                                      pnpacpi_count_resources, &res_cnt);
 788         if (ACPI_FAILURE(status)) {
 789                 pnp_err("Evaluate _CRS failed");
 790                 return -EINVAL;
 791         }
 792         if (!res_cnt)
 793                 return -EINVAL;
 794         buffer->length = sizeof(struct acpi_resource) * (res_cnt + 1) + 1;
 795         buffer->pointer = kzalloc(buffer->length - 1, GFP_KERNEL);
 796         if (!buffer->pointer)
 797                 return -ENOMEM;
 798         pnp_dbg("Res cnt %d", res_cnt);
 799         resource = (struct acpi_resource *)buffer->pointer;
 800         status = acpi_walk_resources(handle, METHOD_NAME__CRS,
 801                                      pnpacpi_type_resources, &resource);
 802         if (ACPI_FAILURE(status)) {
 803                 kfree(buffer->pointer);
 804                 pnp_err("Evaluate _CRS failed");
 805                 return -EINVAL;
 806         }
 807         /* resource will pointer the end resource now */
 808         resource->type = ACPI_RESOURCE_TYPE_END_TAG;
 809
 810         return 0;
 811 }
 812
 813 static void pnpacpi_encode_irq(struct acpi_resource *resource,
 814                                struct resource *p)
 815 {
 816         struct acpi_resource_irq *irq = &resource->data.irq;
 817         int triggering, polarity;
 818
 819         decode_irq_flags(p->flags & IORESOURCE_BITS, &triggering, &polarity);
 820         irq->triggering = triggering;
 821         irq->polarity = polarity;
 822         if (triggering == ACPI_EDGE_SENSITIVE)
 823                 irq->sharable = ACPI_EXCLUSIVE;
 824         else
 825                 irq->sharable = ACPI_SHARED;
 826         irq->interrupt_count = 1;
 827         irq->interrupts[0] = p->start;
 828 }
 829
 830 static void pnpacpi_encode_ext_irq(struct acpi_resource *resource,
 831                                    struct resource *p)
 832 {
 833         struct acpi_resource_extended_irq *extended_irq = &resource->data.extended_irq;
 834         int triggering, polarity;
 835
 836         decode_irq_flags(p->flags & IORESOURCE_BITS, &triggering, &polarity);
 837         extended_irq->producer_consumer = ACPI_CONSUMER;
 838         extended_irq->triggering = triggering;
 839         extended_irq->polarity = polarity;
 840         if (triggering == ACPI_EDGE_SENSITIVE)
 841                 extended_irq->sharable = ACPI_EXCLUSIVE;
 842         else
 843                 extended_irq->sharable = ACPI_SHARED;
 844         extended_irq->interrupt_count = 1;
 845         extended_irq->interrupts[0] = p->start;
 846 }
 847
 848 static void pnpacpi_encode_dma(struct acpi_resource *resource,
 849                                struct resource *p)
 850 {
 851         struct acpi_resource_dma *dma = &resource->data.dma;
 852
 853         /* Note: pnp_assign_dma will copy pnp_dma->flags into p->flags */
 854         switch (p->flags & IORESOURCE_DMA_SPEED_MASK) {
 855         case IORESOURCE_DMA_TYPEA:
 856                 dma->type = ACPI_TYPE_A;
 857                 break;
 858         case IORESOURCE_DMA_TYPEB:
 859                 dma->type = ACPI_TYPE_B;
 860                 break;
 861         case IORESOURCE_DMA_TYPEF:
 862                 dma->type = ACPI_TYPE_F;
 863                 break;
 864         default:
 865                 dma->type = ACPI_COMPATIBILITY;
 866         }
 867
 868         switch (p->flags & IORESOURCE_DMA_TYPE_MASK) {
 869         case IORESOURCE_DMA_8BIT:
 870                 dma->transfer = ACPI_TRANSFER_8;
 871                 break;
 872         case IORESOURCE_DMA_8AND16BIT:
 873                 dma->transfer = ACPI_TRANSFER_8_16;
 874                 break;
 875         default:
 876                 dma->transfer = ACPI_TRANSFER_16;
 877         }
 878
 879         dma->bus_master = !!(p->flags & IORESOURCE_DMA_MASTER);
 880         dma->channel_count = 1;
 881         dma->channels[0] = p->start;
 882 }
 883
 884 static void pnpacpi_encode_io(struct acpi_resource *resource,
 885                               struct resource *p)
 886 {
 887         struct acpi_resource_io *io = &resource->data.io;
 888
 889         /* Note: pnp_assign_port will copy pnp_port->flags into p->flags */
 890         io->io_decode = (p->flags & PNP_PORT_FLAG_16BITADDR) ?
 891             ACPI_DECODE_16 : ACPI_DECODE_10;
 892         io->minimum = p->start;
 893         io->maximum = p->end;
 894         io->alignment = 0;      /* Correct? */
 895         io->address_length = p->end - p->start + 1;
 896 }
 897
 898 static void pnpacpi_encode_fixed_io(struct acpi_resource *resource,
 899                                     struct resource *p)
 900 {
 901         struct acpi_resource_fixed_io *fixed_io = &resource->data.fixed_io;
 902
 903         fixed_io->address = p->start;
 904         fixed_io->address_length = p->end - p->start + 1;
 905 }
 906
 907 static void pnpacpi_encode_mem24(struct acpi_resource *resource,
 908                                  struct resource *p)
 909 {
 910         struct acpi_resource_memory24 *memory24 = &resource->data.memory24;
 911
 912         /* Note: pnp_assign_mem will copy pnp_mem->flags into p->flags */
 913         memory24->write_protect =
 914             (p->flags & IORESOURCE_MEM_WRITEABLE) ?
 915             ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
 916         memory24->minimum = p->start;
 917         memory24->maximum = p->end;
 918         memory24->alignment = 0;
 919         memory24->address_length = p->end - p->start + 1;
 920 }
 921
 922 static void pnpacpi_encode_mem32(struct acpi_resource *resource,
 923                                  struct resource *p)
 924 {
 925         struct acpi_resource_memory32 *memory32 = &resource->data.memory32;
 926
 927         memory32->write_protect =
 928             (p->flags & IORESOURCE_MEM_WRITEABLE) ?
 929             ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
 930         memory32->minimum = p->start;
 931         memory32->maximum = p->end;
 932         memory32->alignment = 0;
 933         memory32->address_length = p->end - p->start + 1;
 934 }
 935
 936 static void pnpacpi_encode_fixed_mem32(struct acpi_resource *resource,
 937                                        struct resource *p)
 938 {
 939         struct acpi_resource_fixed_memory32 *fixed_memory32 = &resource->data.fixed_memory32;
 940
 941         fixed_memory32->write_protect =
 942             (p->flags & IORESOURCE_MEM_WRITEABLE) ?
 943             ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
 944         fixed_memory32->address = p->start;
 945         fixed_memory32->address_length = p->end - p->start + 1;
 946 }
 947
 948 int pnpacpi_encode_resources(struct pnp_resource_table *res_table,
 949                              struct acpi_buffer *buffer)
 950 {
 951         int i = 0;
 952         /* pnpacpi_build_resource_template allocates extra mem */
 953         int res_cnt = (buffer->length - 1) / sizeof(struct acpi_resource) - 1;
 954         struct acpi_resource *resource = buffer->pointer;
 955         int port = 0, irq = 0, dma = 0, mem = 0;
 956
 957         pnp_dbg("res cnt %d", res_cnt);
 958         while (i < res_cnt) {
 959                 switch (resource->type) {
 960                 case ACPI_RESOURCE_TYPE_IRQ:
 961                         pnp_dbg("Encode irq");
 962                         pnpacpi_encode_irq(resource,
 963                                            &res_table->irq_resource[irq]);
 964                         irq++;
 965                         break;
 966
 967                 case ACPI_RESOURCE_TYPE_DMA:
 968                         pnp_dbg("Encode dma");
 969                         pnpacpi_encode_dma(resource,
 970                                            &res_table->dma_resource[dma]);
 971                         dma++;
 972                         break;
 973                 case ACPI_RESOURCE_TYPE_IO:
 974                         pnp_dbg("Encode io");
 975                         pnpacpi_encode_io(resource,
 976                                           &res_table->port_resource[port]);
 977                         port++;
 978                         break;
 979                 case ACPI_RESOURCE_TYPE_FIXED_IO:
 980                         pnp_dbg("Encode fixed io");
 981                         pnpacpi_encode_fixed_io(resource,
 982                                                 &res_table->
 983                                                 port_resource[port]);
 984                         port++;
 985                         break;
 986                 case ACPI_RESOURCE_TYPE_MEMORY24:
 987                         pnp_dbg("Encode mem24");
 988                         pnpacpi_encode_mem24(resource,
 989                                              &res_table->mem_resource[mem]);
 990                         mem++;
 991                         break;
 992                 case ACPI_RESOURCE_TYPE_MEMORY32:
 993                         pnp_dbg("Encode mem32");
 994                         pnpacpi_encode_mem32(resource,
 995                                              &res_table->mem_resource[mem]);
 996                         mem++;
 997                         break;
 998                 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
 999                         pnp_dbg("Encode fixed mem32");
1000                         pnpacpi_encode_fixed_mem32(resource,
1001                                                    &res_table->
1002                                                    mem_resource[mem]);
1003                         mem++;
1004                         break;
1005                 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
1006                         pnp_dbg("Encode ext irq");
1007                         pnpacpi_encode_ext_irq(resource,
1008                                                &res_table->irq_resource[irq]);
1009                         irq++;
1010                         break;
1011                 case ACPI_RESOURCE_TYPE_START_DEPENDENT:
1012                 case ACPI_RESOURCE_TYPE_END_DEPENDENT:
1013                 case ACPI_RESOURCE_TYPE_VENDOR:
1014                 case ACPI_RESOURCE_TYPE_END_TAG:
1015                 case ACPI_RESOURCE_TYPE_ADDRESS16:
1016                 case ACPI_RESOURCE_TYPE_ADDRESS32:
1017                 case ACPI_RESOURCE_TYPE_ADDRESS64:
1018                 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
1019                 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
1020                 default:        /* other type */
1021                         pnp_warn("unknown resource type %d", resource->type);
1022                         return -EINVAL;
1023                 }
1024                 resource++;
1025                 i++;
1026         }
1027         return 0;
1028 }