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