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