drivers/pnp/pnpacpi/rsparser.c

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