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