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