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