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