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 <[email protected]>
   6  * Copyright (c) 2004 Li Shaohua <[email protected]>
   7  * Copyright (C) 2008 Hewlett-Packard Development Company, L.P.
   8  *      Bjorn Helgaas <[email protected]>
   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                                                    gpio->wake_capable);
 211                 } else {
 212                         flags = IORESOURCE_DISABLED;
 213                 }
 214                 pnp_add_irq_resource(dev, i, flags);
 215                 return AE_OK;
 216         } else if (r->flags & IORESOURCE_DISABLED) {
 217                 pnp_add_irq_resource(dev, 0, IORESOURCE_DISABLED);
 218                 return AE_OK;
 219         }
 220
 221         switch (res->type) {
 222         case ACPI_RESOURCE_TYPE_MEMORY24:
 223         case ACPI_RESOURCE_TYPE_MEMORY32:
 224         case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
 225                 if (acpi_dev_resource_memory(res, r))
 226                         pnp_add_resource(dev, r);
 227                 break;
 228         case ACPI_RESOURCE_TYPE_IO:
 229         case ACPI_RESOURCE_TYPE_FIXED_IO:
 230                 if (acpi_dev_resource_io(res, r))
 231                         pnp_add_resource(dev, r);
 232                 break;
 233         case ACPI_RESOURCE_TYPE_DMA:
 234                 dma = &res->data.dma;
 235                 if (dma->channel_count > 0 && dma->channels[0] != (u8) -1)
 236                         flags = dma_flags(dev, dma->type, dma->bus_master,
 237                                           dma->transfer);
 238                 else
 239                         flags = IORESOURCE_DISABLED;
 240                 pnp_add_dma_resource(dev, dma->channels[0], flags);
 241                 break;
 242
 243         case ACPI_RESOURCE_TYPE_START_DEPENDENT:
 244         case ACPI_RESOURCE_TYPE_END_DEPENDENT:
 245                 break;
 246
 247         case ACPI_RESOURCE_TYPE_VENDOR:
 248                 vendor_typed = &res->data.vendor_typed;
 249                 pnpacpi_parse_allocated_vendor(dev, vendor_typed);
 250                 break;
 251
 252         case ACPI_RESOURCE_TYPE_END_TAG:
 253                 break;
 254
 255         case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
 256                 break;
 257
 258         case ACPI_RESOURCE_TYPE_SERIAL_BUS:
 259                 /* serial bus connections (I2C/SPI/UART) are not pnp */
 260                 break;
 261
 262         default:
 263                 dev_warn(&dev->dev, "unknown resource type %d in _CRS\n",
 264                          res->type);
 265                 return AE_ERROR;
 266         }
 267
 268         return AE_OK;
 269 }
 270
 271 int pnpacpi_parse_allocated_resource(struct pnp_dev *dev)
 272 {
 273         struct acpi_device *acpi_dev = dev->data;
 274         acpi_handle handle = acpi_dev->handle;
 275         acpi_status status;
 276
 277         pnp_dbg(&dev->dev, "parse allocated resources\n");
 278
 279         pnp_init_resources(dev);
 280
 281         status = acpi_walk_resources(handle, METHOD_NAME__CRS,
 282                                      pnpacpi_allocated_resource, dev);
 283
 284         if (ACPI_FAILURE(status)) {
 285                 if (status != AE_NOT_FOUND)
 286                         dev_err(&dev->dev, "can't evaluate _CRS: %d", status);
 287                 return -EPERM;
 288         }
 289         return 0;
 290 }
 291
 292 static __init void pnpacpi_parse_dma_option(struct pnp_dev *dev,
 293                                             unsigned int option_flags,
 294                                             struct acpi_resource_dma *p)
 295 {
 296         int i;
 297         unsigned char map = 0, flags;
 298
 299         for (i = 0; i < p->channel_count; i++)
 300                 map |= 1 << p->channels[i];
 301
 302         flags = dma_flags(dev, p->type, p->bus_master, p->transfer);
 303         pnp_register_dma_resource(dev, option_flags, map, flags);
 304 }
 305
 306 static __init void pnpacpi_parse_irq_option(struct pnp_dev *dev,
 307                                             unsigned int option_flags,
 308                                             struct acpi_resource_irq *p)
 309 {
 310         int i;
 311         pnp_irq_mask_t map;
 312         unsigned char flags;
 313
 314         bitmap_zero(map.bits, PNP_IRQ_NR);
 315         for (i = 0; i < p->interrupt_count; i++)
 316                 if (p->interrupts[i])
 317                         __set_bit(p->interrupts[i], map.bits);
 318
 319         flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->shareable, p->wake_capable);
 320         pnp_register_irq_resource(dev, option_flags, &map, flags);
 321 }
 322
 323 static __init void pnpacpi_parse_ext_irq_option(struct pnp_dev *dev,
 324                                         unsigned int option_flags,
 325                                         struct acpi_resource_extended_irq *p)
 326 {
 327         int i;
 328         pnp_irq_mask_t map;
 329         unsigned char flags;
 330
 331         bitmap_zero(map.bits, PNP_IRQ_NR);
 332         for (i = 0; i < p->interrupt_count; i++) {
 333                 if (p->interrupts[i]) {
 334                         if (p->interrupts[i] < PNP_IRQ_NR)
 335                                 __set_bit(p->interrupts[i], map.bits);
 336                         else
 337                                 dev_err(&dev->dev,
 338                                         "ignoring IRQ %d option (too large for %d entry bitmap)\n",
 339                                         p->interrupts[i], PNP_IRQ_NR);
 340                 }
 341         }
 342
 343         flags = acpi_dev_irq_flags(p->triggering, p->polarity, p->shareable, p->wake_capable);
 344         pnp_register_irq_resource(dev, option_flags, &map, flags);
 345 }
 346
 347 static __init void pnpacpi_parse_port_option(struct pnp_dev *dev,
 348                                              unsigned int option_flags,
 349                                              struct acpi_resource_io *io)
 350 {
 351         unsigned char flags = 0;
 352
 353         if (io->io_decode == ACPI_DECODE_16)
 354                 flags = IORESOURCE_IO_16BIT_ADDR;
 355         pnp_register_port_resource(dev, option_flags, io->minimum, io->maximum,
 356                                    io->alignment, io->address_length, flags);
 357 }
 358
 359 static __init void pnpacpi_parse_fixed_port_option(struct pnp_dev *dev,
 360                                         unsigned int option_flags,
 361                                         struct acpi_resource_fixed_io *io)
 362 {
 363         pnp_register_port_resource(dev, option_flags, io->address, io->address,
 364                                    0, io->address_length, IORESOURCE_IO_FIXED);
 365 }
 366
 367 static __init void pnpacpi_parse_mem24_option(struct pnp_dev *dev,
 368                                               unsigned int option_flags,
 369                                               struct acpi_resource_memory24 *p)
 370 {
 371         unsigned char flags = 0;
 372
 373         if (p->write_protect == ACPI_READ_WRITE_MEMORY)
 374                 flags = IORESOURCE_MEM_WRITEABLE;
 375         pnp_register_mem_resource(dev, option_flags, p->minimum, p->maximum,
 376                                   p->alignment, p->address_length, flags);
 377 }
 378
 379 static __init void pnpacpi_parse_mem32_option(struct pnp_dev *dev,
 380                                               unsigned int option_flags,
 381                                               struct acpi_resource_memory32 *p)
 382 {
 383         unsigned char flags = 0;
 384
 385         if (p->write_protect == ACPI_READ_WRITE_MEMORY)
 386                 flags = IORESOURCE_MEM_WRITEABLE;
 387         pnp_register_mem_resource(dev, option_flags, p->minimum, p->maximum,
 388                                   p->alignment, p->address_length, flags);
 389 }
 390
 391 static __init void pnpacpi_parse_fixed_mem32_option(struct pnp_dev *dev,
 392                                         unsigned int option_flags,
 393                                         struct acpi_resource_fixed_memory32 *p)
 394 {
 395         unsigned char flags = 0;
 396
 397         if (p->write_protect == ACPI_READ_WRITE_MEMORY)
 398                 flags = IORESOURCE_MEM_WRITEABLE;
 399         pnp_register_mem_resource(dev, option_flags, p->address, p->address,
 400                                   0, p->address_length, flags);
 401 }
 402
 403 static __init void pnpacpi_parse_address_option(struct pnp_dev *dev,
 404                                                 unsigned int option_flags,
 405                                                 struct acpi_resource *r)
 406 {
 407         struct acpi_resource_address64 addr, *p = &addr;
 408         acpi_status status;
 409         unsigned char flags = 0;
 410
 411         status = acpi_resource_to_address64(r, p);
 412         if (ACPI_FAILURE(status)) {
 413                 dev_warn(&dev->dev, "can't convert resource type %d\n",
 414                          r->type);
 415                 return;
 416         }
 417
 418         if (p->resource_type == ACPI_MEMORY_RANGE) {
 419                 if (p->info.mem.write_protect == ACPI_READ_WRITE_MEMORY)
 420                         flags = IORESOURCE_MEM_WRITEABLE;
 421                 pnp_register_mem_resource(dev, option_flags, p->address.minimum,
 422                                           p->address.minimum, 0, p->address.address_length,
 423                                           flags);
 424         } else if (p->resource_type == ACPI_IO_RANGE)
 425                 pnp_register_port_resource(dev, option_flags, p->address.minimum,
 426                                            p->address.minimum, 0, p->address.address_length,
 427                                            IORESOURCE_IO_FIXED);
 428 }
 429
 430 static __init void pnpacpi_parse_ext_address_option(struct pnp_dev *dev,
 431                                                     unsigned int option_flags,
 432                                                     struct acpi_resource *r)
 433 {
 434         struct acpi_resource_extended_address64 *p = &r->data.ext_address64;
 435         unsigned char flags = 0;
 436
 437         if (p->resource_type == ACPI_MEMORY_RANGE) {
 438                 if (p->info.mem.write_protect == ACPI_READ_WRITE_MEMORY)
 439                         flags = IORESOURCE_MEM_WRITEABLE;
 440                 pnp_register_mem_resource(dev, option_flags, p->address.minimum,
 441                                           p->address.minimum, 0, p->address.address_length,
 442                                           flags);
 443         } else if (p->resource_type == ACPI_IO_RANGE)
 444                 pnp_register_port_resource(dev, option_flags, p->address.minimum,
 445                                            p->address.minimum, 0, p->address.address_length,
 446                                            IORESOURCE_IO_FIXED);
 447 }
 448
 449 struct acpipnp_parse_option_s {
 450         struct pnp_dev *dev;
 451         unsigned int option_flags;
 452 };
 453
 454 static __init acpi_status pnpacpi_option_resource(struct acpi_resource *res,
 455                                                   void *data)
 456 {
 457         int priority;
 458         struct acpipnp_parse_option_s *parse_data = data;
 459         struct pnp_dev *dev = parse_data->dev;
 460         unsigned int option_flags = parse_data->option_flags;
 461
 462         switch (res->type) {
 463         case ACPI_RESOURCE_TYPE_IRQ:
 464                 pnpacpi_parse_irq_option(dev, option_flags, &res->data.irq);
 465                 break;
 466
 467         case ACPI_RESOURCE_TYPE_DMA:
 468                 pnpacpi_parse_dma_option(dev, option_flags, &res->data.dma);
 469                 break;
 470
 471         case ACPI_RESOURCE_TYPE_START_DEPENDENT:
 472                 switch (res->data.start_dpf.compatibility_priority) {
 473                 case ACPI_GOOD_CONFIGURATION:
 474                         priority = PNP_RES_PRIORITY_PREFERRED;
 475                         break;
 476
 477                 case ACPI_ACCEPTABLE_CONFIGURATION:
 478                         priority = PNP_RES_PRIORITY_ACCEPTABLE;
 479                         break;
 480
 481                 case ACPI_SUB_OPTIMAL_CONFIGURATION:
 482                         priority = PNP_RES_PRIORITY_FUNCTIONAL;
 483                         break;
 484                 default:
 485                         priority = PNP_RES_PRIORITY_INVALID;
 486                         break;
 487                 }
 488                 parse_data->option_flags = pnp_new_dependent_set(dev, priority);
 489                 break;
 490
 491         case ACPI_RESOURCE_TYPE_END_DEPENDENT:
 492                 parse_data->option_flags = 0;
 493                 break;
 494
 495         case ACPI_RESOURCE_TYPE_IO:
 496                 pnpacpi_parse_port_option(dev, option_flags, &res->data.io);
 497                 break;
 498
 499         case ACPI_RESOURCE_TYPE_FIXED_IO:
 500                 pnpacpi_parse_fixed_port_option(dev, option_flags,
 501                                                 &res->data.fixed_io);
 502                 break;
 503
 504         case ACPI_RESOURCE_TYPE_VENDOR:
 505         case ACPI_RESOURCE_TYPE_END_TAG:
 506                 break;
 507
 508         case ACPI_RESOURCE_TYPE_MEMORY24:
 509                 pnpacpi_parse_mem24_option(dev, option_flags,
 510                                            &res->data.memory24);
 511                 break;
 512
 513         case ACPI_RESOURCE_TYPE_MEMORY32:
 514                 pnpacpi_parse_mem32_option(dev, option_flags,
 515                                            &res->data.memory32);
 516                 break;
 517
 518         case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
 519                 pnpacpi_parse_fixed_mem32_option(dev, option_flags,
 520                                                  &res->data.fixed_memory32);
 521                 break;
 522
 523         case ACPI_RESOURCE_TYPE_ADDRESS16:
 524         case ACPI_RESOURCE_TYPE_ADDRESS32:
 525         case ACPI_RESOURCE_TYPE_ADDRESS64:
 526                 pnpacpi_parse_address_option(dev, option_flags, res);
 527                 break;
 528
 529         case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
 530                 pnpacpi_parse_ext_address_option(dev, option_flags, res);
 531                 break;
 532
 533         case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
 534                 pnpacpi_parse_ext_irq_option(dev, option_flags,
 535                                              &res->data.extended_irq);
 536                 break;
 537
 538         case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
 539                 break;
 540
 541         default:
 542                 dev_warn(&dev->dev, "unknown resource type %d in _PRS\n",
 543                          res->type);
 544                 return AE_ERROR;
 545         }
 546
 547         return AE_OK;
 548 }
 549
 550 int __init pnpacpi_parse_resource_option_data(struct pnp_dev *dev)
 551 {
 552         struct acpi_device *acpi_dev = dev->data;
 553         acpi_handle handle = acpi_dev->handle;
 554         acpi_status status;
 555         struct acpipnp_parse_option_s parse_data;
 556
 557         pnp_dbg(&dev->dev, "parse resource options\n");
 558
 559         parse_data.dev = dev;
 560         parse_data.option_flags = 0;
 561
 562         status = acpi_walk_resources(handle, METHOD_NAME__PRS,
 563                                      pnpacpi_option_resource, &parse_data);
 564
 565         if (ACPI_FAILURE(status)) {
 566                 if (status != AE_NOT_FOUND)
 567                         dev_err(&dev->dev, "can't evaluate _PRS: %d", status);
 568                 return -EPERM;
 569         }
 570         return 0;
 571 }
 572
 573 static int pnpacpi_supported_resource(struct acpi_resource *res)
 574 {
 575         switch (res->type) {
 576         case ACPI_RESOURCE_TYPE_IRQ:
 577         case ACPI_RESOURCE_TYPE_DMA:
 578         case ACPI_RESOURCE_TYPE_IO:
 579         case ACPI_RESOURCE_TYPE_FIXED_IO:
 580         case ACPI_RESOURCE_TYPE_MEMORY24:
 581         case ACPI_RESOURCE_TYPE_MEMORY32:
 582         case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
 583         case ACPI_RESOURCE_TYPE_ADDRESS16:
 584         case ACPI_RESOURCE_TYPE_ADDRESS32:
 585         case ACPI_RESOURCE_TYPE_ADDRESS64:
 586         case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
 587         case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
 588                 return 1;
 589         }
 590         return 0;
 591 }
 592
 593 /*
 594  * Set resource
 595  */
 596 static acpi_status pnpacpi_count_resources(struct acpi_resource *res,
 597                                            void *data)
 598 {
 599         int *res_cnt = data;
 600
 601         if (pnpacpi_supported_resource(res))
 602                 (*res_cnt)++;
 603         return AE_OK;
 604 }
 605
 606 static acpi_status pnpacpi_type_resources(struct acpi_resource *res, void *data)
 607 {
 608         struct acpi_resource **resource = data;
 609
 610         if (pnpacpi_supported_resource(res)) {
 611                 (*resource)->type = res->type;
 612                 (*resource)->length = sizeof(struct acpi_resource);
 613                 if (res->type == ACPI_RESOURCE_TYPE_IRQ)
 614                         (*resource)->data.irq.descriptor_length =
 615                                         res->data.irq.descriptor_length;
 616                 (*resource)++;
 617         }
 618
 619         return AE_OK;
 620 }
 621
 622 int pnpacpi_build_resource_template(struct pnp_dev *dev,
 623                                     struct acpi_buffer *buffer)
 624 {
 625         struct acpi_device *acpi_dev = dev->data;
 626         acpi_handle handle = acpi_dev->handle;
 627         struct acpi_resource *resource;
 628         int res_cnt = 0;
 629         acpi_status status;
 630
 631         status = acpi_walk_resources(handle, METHOD_NAME__CRS,
 632                                      pnpacpi_count_resources, &res_cnt);
 633         if (ACPI_FAILURE(status)) {
 634                 dev_err(&dev->dev, "can't evaluate _CRS: %d\n", status);
 635                 return -EINVAL;
 636         }
 637         if (!res_cnt)
 638                 return -EINVAL;
 639         buffer->length = sizeof(struct acpi_resource) * (res_cnt + 1) + 1;
 640         buffer->pointer = kzalloc(buffer->length - 1, GFP_KERNEL);
 641         if (!buffer->pointer)
 642                 return -ENOMEM;
 643
 644         resource = (struct acpi_resource *)buffer->pointer;
 645         status = acpi_walk_resources(handle, METHOD_NAME__CRS,
 646                                      pnpacpi_type_resources, &resource);
 647         if (ACPI_FAILURE(status)) {
 648                 kfree(buffer->pointer);
 649                 dev_err(&dev->dev, "can't evaluate _CRS: %d\n", status);
 650                 return -EINVAL;
 651         }
 652         /* resource will pointer the end resource now */
 653         resource->type = ACPI_RESOURCE_TYPE_END_TAG;
 654         resource->length = sizeof(struct acpi_resource);
 655
 656         return 0;
 657 }
 658
 659 static void pnpacpi_encode_irq(struct pnp_dev *dev,
 660                                struct acpi_resource *resource,
 661                                struct resource *p)
 662 {
 663         struct acpi_resource_irq *irq = &resource->data.irq;
 664         u8 triggering, polarity, shareable;
 665
 666         if (!pnp_resource_enabled(p)) {
 667                 irq->interrupt_count = 0;
 668                 pnp_dbg(&dev->dev, "  encode irq (%s)\n",
 669                         p ? "disabled" : "missing");
 670                 return;
 671         }
 672
 673         decode_irq_flags(dev, p->flags, &triggering, &polarity, &shareable);
 674         irq->triggering = triggering;
 675         irq->polarity = polarity;
 676         irq->shareable = shareable;
 677         irq->interrupt_count = 1;
 678         irq->interrupts[0] = p->start;
 679
 680         pnp_dbg(&dev->dev, "  encode irq %d %s %s %s (%d-byte descriptor)\n",
 681                 (int) p->start,
 682                 triggering == ACPI_LEVEL_SENSITIVE ? "level" : "edge",
 683                 polarity == ACPI_ACTIVE_LOW ? "low" : "high",
 684                 irq->shareable == ACPI_SHARED ? "shared" : "exclusive",
 685                 irq->descriptor_length);
 686 }
 687
 688 static void pnpacpi_encode_ext_irq(struct pnp_dev *dev,
 689                                    struct acpi_resource *resource,
 690                                    struct resource *p)
 691 {
 692         struct acpi_resource_extended_irq *extended_irq = &resource->data.extended_irq;
 693         u8 triggering, polarity, shareable;
 694
 695         if (!pnp_resource_enabled(p)) {
 696                 extended_irq->interrupt_count = 0;
 697                 pnp_dbg(&dev->dev, "  encode extended irq (%s)\n",
 698                         p ? "disabled" : "missing");
 699                 return;
 700         }
 701
 702         decode_irq_flags(dev, p->flags, &triggering, &polarity, &shareable);
 703         extended_irq->producer_consumer = ACPI_CONSUMER;
 704         extended_irq->triggering = triggering;
 705         extended_irq->polarity = polarity;
 706         extended_irq->shareable = shareable;
 707         extended_irq->interrupt_count = 1;
 708         extended_irq->interrupts[0] = p->start;
 709
 710         pnp_dbg(&dev->dev, "  encode irq %d %s %s %s\n", (int) p->start,
 711                 triggering == ACPI_LEVEL_SENSITIVE ? "level" : "edge",
 712                 polarity == ACPI_ACTIVE_LOW ? "low" : "high",
 713                 extended_irq->shareable == ACPI_SHARED ? "shared" : "exclusive");
 714 }
 715
 716 static void pnpacpi_encode_dma(struct pnp_dev *dev,
 717                                struct acpi_resource *resource,
 718                                struct resource *p)
 719 {
 720         struct acpi_resource_dma *dma = &resource->data.dma;
 721
 722         if (!pnp_resource_enabled(p)) {
 723                 dma->channel_count = 0;
 724                 pnp_dbg(&dev->dev, "  encode dma (%s)\n",
 725                         p ? "disabled" : "missing");
 726                 return;
 727         }
 728
 729         /* Note: pnp_assign_dma will copy pnp_dma->flags into p->flags */
 730         switch (p->flags & IORESOURCE_DMA_SPEED_MASK) {
 731         case IORESOURCE_DMA_TYPEA:
 732                 dma->type = ACPI_TYPE_A;
 733                 break;
 734         case IORESOURCE_DMA_TYPEB:
 735                 dma->type = ACPI_TYPE_B;
 736                 break;
 737         case IORESOURCE_DMA_TYPEF:
 738                 dma->type = ACPI_TYPE_F;
 739                 break;
 740         default:
 741                 dma->type = ACPI_COMPATIBILITY;
 742         }
 743
 744         switch (p->flags & IORESOURCE_DMA_TYPE_MASK) {
 745         case IORESOURCE_DMA_8BIT:
 746                 dma->transfer = ACPI_TRANSFER_8;
 747                 break;
 748         case IORESOURCE_DMA_8AND16BIT:
 749                 dma->transfer = ACPI_TRANSFER_8_16;
 750                 break;
 751         default:
 752                 dma->transfer = ACPI_TRANSFER_16;
 753         }
 754
 755         dma->bus_master = !!(p->flags & IORESOURCE_DMA_MASTER);
 756         dma->channel_count = 1;
 757         dma->channels[0] = p->start;
 758
 759         pnp_dbg(&dev->dev, "  encode dma %d "
 760                 "type %#x transfer %#x master %d\n",
 761                 (int) p->start, dma->type, dma->transfer, dma->bus_master);
 762 }
 763
 764 static void pnpacpi_encode_io(struct pnp_dev *dev,
 765                               struct acpi_resource *resource,
 766                               struct resource *p)
 767 {
 768         struct acpi_resource_io *io = &resource->data.io;
 769
 770         if (pnp_resource_enabled(p)) {
 771                 /* Note: pnp_assign_port copies pnp_port->flags into p->flags */
 772                 io->io_decode = (p->flags & IORESOURCE_IO_16BIT_ADDR) ?
 773                     ACPI_DECODE_16 : ACPI_DECODE_10;
 774                 io->minimum = p->start;
 775                 io->maximum = p->end;
 776                 io->alignment = 0;      /* Correct? */
 777                 io->address_length = resource_size(p);
 778         } else {
 779                 io->minimum = 0;
 780                 io->address_length = 0;
 781         }
 782
 783         pnp_dbg(&dev->dev, "  encode io %#x-%#x decode %#x\n", io->minimum,
 784                 io->minimum + io->address_length - 1, io->io_decode);
 785 }
 786
 787 static void pnpacpi_encode_fixed_io(struct pnp_dev *dev,
 788                                     struct acpi_resource *resource,
 789                                     struct resource *p)
 790 {
 791         struct acpi_resource_fixed_io *fixed_io = &resource->data.fixed_io;
 792
 793         if (pnp_resource_enabled(p)) {
 794                 fixed_io->address = p->start;
 795                 fixed_io->address_length = resource_size(p);
 796         } else {
 797                 fixed_io->address = 0;
 798                 fixed_io->address_length = 0;
 799         }
 800
 801         pnp_dbg(&dev->dev, "  encode fixed_io %#x-%#x\n", fixed_io->address,
 802                 fixed_io->address + fixed_io->address_length - 1);
 803 }
 804
 805 static void pnpacpi_encode_mem24(struct pnp_dev *dev,
 806                                  struct acpi_resource *resource,
 807                                  struct resource *p)
 808 {
 809         struct acpi_resource_memory24 *memory24 = &resource->data.memory24;
 810
 811         if (pnp_resource_enabled(p)) {
 812                 /* Note: pnp_assign_mem copies pnp_mem->flags into p->flags */
 813                 memory24->write_protect = p->flags & IORESOURCE_MEM_WRITEABLE ?
 814                     ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
 815                 memory24->minimum = p->start;
 816                 memory24->maximum = p->end;
 817                 memory24->alignment = 0;
 818                 memory24->address_length = resource_size(p);
 819         } else {
 820                 memory24->minimum = 0;
 821                 memory24->address_length = 0;
 822         }
 823
 824         pnp_dbg(&dev->dev, "  encode mem24 %#x-%#x write_protect %#x\n",
 825                 memory24->minimum,
 826                 memory24->minimum + memory24->address_length - 1,
 827                 memory24->write_protect);
 828 }
 829
 830 static void pnpacpi_encode_mem32(struct pnp_dev *dev,
 831                                  struct acpi_resource *resource,
 832                                  struct resource *p)
 833 {
 834         struct acpi_resource_memory32 *memory32 = &resource->data.memory32;
 835
 836         if (pnp_resource_enabled(p)) {
 837                 memory32->write_protect = p->flags & IORESOURCE_MEM_WRITEABLE ?
 838                     ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
 839                 memory32->minimum = p->start;
 840                 memory32->maximum = p->end;
 841                 memory32->alignment = 0;
 842                 memory32->address_length = resource_size(p);
 843         } else {
 844                 memory32->minimum = 0;
 845                 memory32->alignment = 0;
 846         }
 847
 848         pnp_dbg(&dev->dev, "  encode mem32 %#x-%#x write_protect %#x\n",
 849                 memory32->minimum,
 850                 memory32->minimum + memory32->address_length - 1,
 851                 memory32->write_protect);
 852 }
 853
 854 static void pnpacpi_encode_fixed_mem32(struct pnp_dev *dev,
 855                                        struct acpi_resource *resource,
 856                                        struct resource *p)
 857 {
 858         struct acpi_resource_fixed_memory32 *fixed_memory32 = &resource->data.fixed_memory32;
 859
 860         if (pnp_resource_enabled(p)) {
 861                 fixed_memory32->write_protect =
 862                     p->flags & IORESOURCE_MEM_WRITEABLE ?
 863                     ACPI_READ_WRITE_MEMORY : ACPI_READ_ONLY_MEMORY;
 864                 fixed_memory32->address = p->start;
 865                 fixed_memory32->address_length = resource_size(p);
 866         } else {
 867                 fixed_memory32->address = 0;
 868                 fixed_memory32->address_length = 0;
 869         }
 870
 871         pnp_dbg(&dev->dev, "  encode fixed_mem32 %#x-%#x write_protect %#x\n",
 872                 fixed_memory32->address,
 873                 fixed_memory32->address + fixed_memory32->address_length - 1,
 874                 fixed_memory32->write_protect);
 875 }
 876
 877 int pnpacpi_encode_resources(struct pnp_dev *dev, struct acpi_buffer *buffer)
 878 {
 879         int i = 0;
 880         /* pnpacpi_build_resource_template allocates extra mem */
 881         int res_cnt = (buffer->length - 1) / sizeof(struct acpi_resource) - 1;
 882         struct acpi_resource *resource = buffer->pointer;
 883         unsigned int port = 0, irq = 0, dma = 0, mem = 0;
 884
 885         pnp_dbg(&dev->dev, "encode %d resources\n", res_cnt);
 886         while (i < res_cnt) {
 887                 switch (resource->type) {
 888                 case ACPI_RESOURCE_TYPE_IRQ:
 889                         pnpacpi_encode_irq(dev, resource,
 890                                pnp_get_resource(dev, IORESOURCE_IRQ, irq));
 891                         irq++;
 892                         break;
 893
 894                 case ACPI_RESOURCE_TYPE_DMA:
 895                         pnpacpi_encode_dma(dev, resource,
 896                                 pnp_get_resource(dev, IORESOURCE_DMA, dma));
 897                         dma++;
 898                         break;
 899                 case ACPI_RESOURCE_TYPE_IO:
 900                         pnpacpi_encode_io(dev, resource,
 901                                 pnp_get_resource(dev, IORESOURCE_IO, port));
 902                         port++;
 903                         break;
 904                 case ACPI_RESOURCE_TYPE_FIXED_IO:
 905                         pnpacpi_encode_fixed_io(dev, resource,
 906                                 pnp_get_resource(dev, IORESOURCE_IO, port));
 907                         port++;
 908                         break;
 909                 case ACPI_RESOURCE_TYPE_MEMORY24:
 910                         pnpacpi_encode_mem24(dev, resource,
 911                                 pnp_get_resource(dev, IORESOURCE_MEM, mem));
 912                         mem++;
 913                         break;
 914                 case ACPI_RESOURCE_TYPE_MEMORY32:
 915                         pnpacpi_encode_mem32(dev, resource,
 916                                 pnp_get_resource(dev, IORESOURCE_MEM, mem));
 917                         mem++;
 918                         break;
 919                 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
 920                         pnpacpi_encode_fixed_mem32(dev, resource,
 921                                 pnp_get_resource(dev, IORESOURCE_MEM, mem));
 922                         mem++;
 923                         break;
 924                 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
 925                         pnpacpi_encode_ext_irq(dev, resource,
 926                                 pnp_get_resource(dev, IORESOURCE_IRQ, irq));
 927                         irq++;
 928                         break;
 929                 case ACPI_RESOURCE_TYPE_START_DEPENDENT:
 930                 case ACPI_RESOURCE_TYPE_END_DEPENDENT:
 931                 case ACPI_RESOURCE_TYPE_VENDOR:
 932                 case ACPI_RESOURCE_TYPE_END_TAG:
 933                 case ACPI_RESOURCE_TYPE_ADDRESS16:
 934                 case ACPI_RESOURCE_TYPE_ADDRESS32:
 935                 case ACPI_RESOURCE_TYPE_ADDRESS64:
 936                 case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
 937                 case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
 938                 default:        /* other type */
 939                         dev_warn(&dev->dev,
 940                                  "can't encode unknown resource type %d\n",
 941                                  resource->type);
 942                         return -EINVAL;
 943                 }
 944                 resource++;
 945                 i++;
 946         }
 947         return 0;
 948 }