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