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