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