Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/dev/acpica/acpi_resource.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /*- 2 * Copyright (c) 2000 Michael Smith 3 * Copyright (c) 2000 BSDi 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 */ 27 28 #include <sys/cdefs.h> 29 __FBSDID("$FreeBSD$"); 30 31 #include "opt_acpi.h" 32 #include <sys/param.h> 33 #include <sys/kernel.h> 34 #include <sys/bus.h> 35 #include <sys/malloc.h> 36 #include <sys/module.h> 37 38 #include <machine/bus.h> 39 #include <machine/resource.h> 40 #include <sys/rman.h> 41 42 #include <contrib/dev/acpica/include/acpi.h> 43 #include <contrib/dev/acpica/include/accommon.h> 44 45 #include <dev/acpica/acpivar.h> 46 47 /* Hooks for the ACPI CA debugging infrastructure */ 48 #define _COMPONENT ACPI_BUS 49 ACPI_MODULE_NAME("RESOURCE") 50 51 struct lookup_irq_request { 52 ACPI_RESOURCE *acpi_res; 53 struct resource *res; 54 int counter; 55 int rid; 56 int found; 57 }; 58 59 static ACPI_STATUS 60 acpi_lookup_irq_handler(ACPI_RESOURCE *res, void *context) 61 { 62 struct lookup_irq_request *req; 63 size_t len; 64 u_int irqnum, irq; 65 66 switch (res->Type) { 67 case ACPI_RESOURCE_TYPE_IRQ: 68 irqnum = res->Data.Irq.InterruptCount; 69 irq = res->Data.Irq.Interrupts[0]; 70 len = ACPI_RS_SIZE(ACPI_RESOURCE_IRQ); 71 break; 72 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: 73 irqnum = res->Data.ExtendedIrq.InterruptCount; 74 irq = res->Data.ExtendedIrq.Interrupts[0]; 75 len = ACPI_RS_SIZE(ACPI_RESOURCE_EXTENDED_IRQ); 76 break; 77 default: 78 return (AE_OK); 79 } 80 if (irqnum != 1) 81 return (AE_OK); 82 req = (struct lookup_irq_request *)context; 83 if (req->counter != req->rid) { 84 req->counter++; 85 return (AE_OK); 86 } 87 req->found = 1; 88 KASSERT(irq == rman_get_start(req->res), 89 ("IRQ resources do not match")); 90 bcopy(res, req->acpi_res, len); 91 return (AE_CTRL_TERMINATE); 92 } 93 94 ACPI_STATUS 95 acpi_lookup_irq_resource(device_t dev, int rid, struct resource *res, 96 ACPI_RESOURCE *acpi_res) 97 { 98 struct lookup_irq_request req; 99 ACPI_STATUS status; 100 101 req.acpi_res = acpi_res; 102 req.res = res; 103 req.counter = 0; 104 req.rid = rid; 105 req.found = 0; 106 status = AcpiWalkResources(acpi_get_handle(dev), "_CRS", 107 acpi_lookup_irq_handler, &req); 108 if (ACPI_SUCCESS(status) && req.found == 0) 109 status = AE_NOT_FOUND; 110 return (status); 111 } 112 113 void 114 acpi_config_intr(device_t dev, ACPI_RESOURCE *res) 115 { 116 u_int irq; 117 int pol, trig; 118 119 switch (res->Type) { 120 case ACPI_RESOURCE_TYPE_IRQ: 121 KASSERT(res->Data.Irq.InterruptCount == 1, 122 ("%s: multiple interrupts", __func__)); 123 irq = res->Data.Irq.Interrupts[0]; 124 trig = res->Data.Irq.Triggering; 125 pol = res->Data.Irq.Polarity; 126 break; 127 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: 128 KASSERT(res->Data.ExtendedIrq.InterruptCount == 1, 129 ("%s: multiple interrupts", __func__)); 130 irq = res->Data.ExtendedIrq.Interrupts[0]; 131 trig = res->Data.ExtendedIrq.Triggering; 132 pol = res->Data.ExtendedIrq.Polarity; 133 break; 134 default: 135 panic("%s: bad resource type %u", __func__, res->Type); 136 } 137 138 #if defined(__amd64__) || defined(__i386__) 139 /* 140 * XXX: Certain BIOSes have buggy AML that specify an IRQ that is 141 * edge-sensitive and active-lo. However, edge-sensitive IRQs 142 * should be active-hi. Force IRQs with an ISA IRQ value to be 143 * active-hi instead. 144 */ 145 if (irq < 16 && trig == ACPI_EDGE_SENSITIVE && pol == ACPI_ACTIVE_LOW) 146 pol = ACPI_ACTIVE_HIGH; 147 #endif 148 BUS_CONFIG_INTR(dev, irq, (trig == ACPI_EDGE_SENSITIVE) ? 149 INTR_TRIGGER_EDGE : INTR_TRIGGER_LEVEL, (pol == ACPI_ACTIVE_HIGH) ? 150 INTR_POLARITY_HIGH : INTR_POLARITY_LOW); 151 } 152 153 /* 154 * Fetch a device's resources and associate them with the device. 155 * 156 * Note that it might be nice to also locate ACPI-specific resource items, such 157 * as GPE bits. 158 * 159 * We really need to split the resource-fetching code out from the 160 * resource-parsing code, since we may want to use the parsing 161 * code for _PRS someday. 162 */ 163 ACPI_STATUS 164 acpi_parse_resources(device_t dev, ACPI_HANDLE handle, 165 struct acpi_parse_resource_set *set, void *arg) 166 { 167 ACPI_BUFFER buf; 168 ACPI_RESOURCE *res; 169 char *curr, *last; 170 ACPI_STATUS status; 171 void *context; 172 173 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 174 175 /* 176 * Special-case some devices that abuse _PRS/_CRS to mean 177 * something other than "I consume this resource". 178 * 179 * XXX do we really need this? It's only relevant once 180 * we start always-allocating these resources, and even 181 * then, the only special-cased device is likely to be 182 * the PCI interrupt link. 183 */ 184 185 /* Fetch the device's current resources. */ 186 buf.Length = ACPI_ALLOCATE_BUFFER; 187 if (ACPI_FAILURE((status = AcpiGetCurrentResources(handle, &buf)))) { 188 if (status != AE_NOT_FOUND && status != AE_TYPE) 189 printf("can't fetch resources for %s - %s\n", 190 acpi_name(handle), AcpiFormatException(status)); 191 return_ACPI_STATUS (status); 192 } 193 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "%s - got %ld bytes of resources\n", 194 acpi_name(handle), (long)buf.Length)); 195 set->set_init(dev, arg, &context); 196 197 /* Iterate through the resources */ 198 curr = buf.Pointer; 199 last = (char *)buf.Pointer + buf.Length; 200 while (curr < last) { 201 res = (ACPI_RESOURCE *)curr; 202 curr += res->Length; 203 204 /* Handle the individual resource types */ 205 switch(res->Type) { 206 case ACPI_RESOURCE_TYPE_END_TAG: 207 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "EndTag\n")); 208 curr = last; 209 break; 210 case ACPI_RESOURCE_TYPE_FIXED_IO: 211 if (res->Data.FixedIo.AddressLength <= 0) 212 break; 213 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "FixedIo 0x%x/%d\n", 214 res->Data.FixedIo.Address, 215 res->Data.FixedIo.AddressLength)); 216 set->set_ioport(dev, context, 217 res->Data.FixedIo.Address, 218 res->Data.FixedIo.AddressLength); 219 break; 220 case ACPI_RESOURCE_TYPE_IO: 221 if (res->Data.Io.AddressLength <= 0) 222 break; 223 if (res->Data.Io.Minimum == res->Data.Io.Maximum) { 224 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "Io 0x%x/%d\n", 225 res->Data.Io.Minimum, 226 res->Data.Io.AddressLength)); 227 set->set_ioport(dev, context, 228 res->Data.Io.Minimum, 229 res->Data.Io.AddressLength); 230 } else { 231 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "Io 0x%x-0x%x/%d\n", 232 res->Data.Io.Minimum, 233 res->Data.Io.Maximum, 234 res->Data.Io.AddressLength)); 235 set->set_iorange(dev, context, 236 res->Data.Io.Minimum, 237 res->Data.Io.Maximum, 238 res->Data.Io.AddressLength, 239 res->Data.Io.Alignment); 240 } 241 break; 242 case ACPI_RESOURCE_TYPE_FIXED_MEMORY32: 243 if (res->Data.FixedMemory32.AddressLength <= 0) 244 break; 245 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "FixedMemory32 0x%x/%d\n", 246 res->Data.FixedMemory32.Address, 247 res->Data.FixedMemory32.AddressLength)); 248 set->set_memory(dev, context, 249 res->Data.FixedMemory32.Address, 250 res->Data.FixedMemory32.AddressLength); 251 break; 252 case ACPI_RESOURCE_TYPE_MEMORY32: 253 if (res->Data.Memory32.AddressLength <= 0) 254 break; 255 if (res->Data.Memory32.Minimum == 256 res->Data.Memory32.Maximum) { 257 258 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "Memory32 0x%x/%d\n", 259 res->Data.Memory32.Minimum, 260 res->Data.Memory32.AddressLength)); 261 set->set_memory(dev, context, 262 res->Data.Memory32.Minimum, 263 res->Data.Memory32.AddressLength); 264 } else { 265 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "Memory32 0x%x-0x%x/%d\n", 266 res->Data.Memory32.Minimum, 267 res->Data.Memory32.Maximum, 268 res->Data.Memory32.AddressLength)); 269 set->set_memoryrange(dev, context, 270 res->Data.Memory32.Minimum, 271 res->Data.Memory32.Maximum, 272 res->Data.Memory32.AddressLength, 273 res->Data.Memory32.Alignment); 274 } 275 break; 276 case ACPI_RESOURCE_TYPE_MEMORY24: 277 if (res->Data.Memory24.AddressLength <= 0) 278 break; 279 if (res->Data.Memory24.Minimum == 280 res->Data.Memory24.Maximum) { 281 282 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "Memory24 0x%x/%d\n", 283 res->Data.Memory24.Minimum, 284 res->Data.Memory24.AddressLength)); 285 set->set_memory(dev, context, res->Data.Memory24.Minimum, 286 res->Data.Memory24.AddressLength); 287 } else { 288 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "Memory24 0x%x-0x%x/%d\n", 289 res->Data.Memory24.Minimum, 290 res->Data.Memory24.Maximum, 291 res->Data.Memory24.AddressLength)); 292 set->set_memoryrange(dev, context, 293 res->Data.Memory24.Minimum, 294 res->Data.Memory24.Maximum, 295 res->Data.Memory24.AddressLength, 296 res->Data.Memory24.Alignment); 297 } 298 break; 299 case ACPI_RESOURCE_TYPE_IRQ: 300 /* 301 * from 1.0b 6.4.2 302 * "This structure is repeated for each separate interrupt 303 * required" 304 */ 305 set->set_irq(dev, context, res->Data.Irq.Interrupts, 306 res->Data.Irq.InterruptCount, res->Data.Irq.Triggering, 307 res->Data.Irq.Polarity); 308 break; 309 case ACPI_RESOURCE_TYPE_DMA: 310 /* 311 * from 1.0b 6.4.3 312 * "This structure is repeated for each separate dma channel 313 * required" 314 */ 315 set->set_drq(dev, context, res->Data.Dma.Channels, 316 res->Data.Dma.ChannelCount); 317 break; 318 case ACPI_RESOURCE_TYPE_START_DEPENDENT: 319 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "start dependent functions\n")); 320 set->set_start_dependent(dev, context, 321 res->Data.StartDpf.CompatibilityPriority); 322 break; 323 case ACPI_RESOURCE_TYPE_END_DEPENDENT: 324 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "end dependent functions\n")); 325 set->set_end_dependent(dev, context); 326 break; 327 case ACPI_RESOURCE_TYPE_ADDRESS32: 328 if (res->Data.Address32.AddressLength <= 0) 329 break; 330 if (res->Data.Address32.ProducerConsumer != ACPI_CONSUMER) { 331 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, 332 "ignored Address32 %s producer\n", 333 res->Data.Address32.ResourceType == ACPI_IO_RANGE ? 334 "IO" : "Memory")); 335 break; 336 } 337 if (res->Data.Address32.ResourceType != ACPI_MEMORY_RANGE && 338 res->Data.Address32.ResourceType != ACPI_IO_RANGE) { 339 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, 340 "ignored Address32 for non-memory, non-I/O\n")); 341 break; 342 } 343 344 if (res->Data.Address32.MinAddressFixed == ACPI_ADDRESS_FIXED && 345 res->Data.Address32.MaxAddressFixed == ACPI_ADDRESS_FIXED) { 346 347 if (res->Data.Address32.ResourceType == ACPI_MEMORY_RANGE) { 348 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, 349 "Address32/Memory 0x%x/%d\n", 350 res->Data.Address32.Minimum, 351 res->Data.Address32.AddressLength)); 352 set->set_memory(dev, context, 353 res->Data.Address32.Minimum, 354 res->Data.Address32.AddressLength); 355 } else { 356 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, 357 "Address32/IO 0x%x/%d\n", 358 res->Data.Address32.Minimum, 359 res->Data.Address32.AddressLength)); 360 set->set_ioport(dev, context, 361 res->Data.Address32.Minimum, 362 res->Data.Address32.AddressLength); 363 } 364 } else { 365 if (res->Data.Address32.ResourceType == ACPI_MEMORY_RANGE) { 366 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, 367 "Address32/Memory 0x%x-0x%x/%d\n", 368 res->Data.Address32.Minimum, 369 res->Data.Address32.Maximum, 370 res->Data.Address32.AddressLength)); 371 set->set_memoryrange(dev, context, 372 res->Data.Address32.Minimum, 373 res->Data.Address32.Maximum, 374 res->Data.Address32.AddressLength, 375 res->Data.Address32.Granularity); 376 } else { 377 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, 378 "Address32/IO 0x%x-0x%x/%d\n", 379 res->Data.Address32.Minimum, 380 res->Data.Address32.Maximum, 381 res->Data.Address32.AddressLength)); 382 set->set_iorange(dev, context, 383 res->Data.Address32.Minimum, 384 res->Data.Address32.Maximum, 385 res->Data.Address32.AddressLength, 386 res->Data.Address32.Granularity); 387 } 388 } 389 break; 390 case ACPI_RESOURCE_TYPE_ADDRESS16: 391 if (res->Data.Address16.AddressLength <= 0) 392 break; 393 if (res->Data.Address16.ProducerConsumer != ACPI_CONSUMER) { 394 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, 395 "ignored Address16 %s producer\n", 396 res->Data.Address16.ResourceType == ACPI_IO_RANGE ? 397 "IO" : "Memory")); 398 break; 399 } 400 if (res->Data.Address16.ResourceType != ACPI_MEMORY_RANGE && 401 res->Data.Address16.ResourceType != ACPI_IO_RANGE) { 402 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, 403 "ignored Address16 for non-memory, non-I/O\n")); 404 break; 405 } 406 407 if (res->Data.Address16.MinAddressFixed == ACPI_ADDRESS_FIXED && 408 res->Data.Address16.MaxAddressFixed == ACPI_ADDRESS_FIXED) { 409 410 if (res->Data.Address16.ResourceType == ACPI_MEMORY_RANGE) { 411 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, 412 "Address16/Memory 0x%x/%d\n", 413 res->Data.Address16.Minimum, 414 res->Data.Address16.AddressLength)); 415 set->set_memory(dev, context, 416 res->Data.Address16.Minimum, 417 res->Data.Address16.AddressLength); 418 } else { 419 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, 420 "Address16/IO 0x%x/%d\n", 421 res->Data.Address16.Minimum, 422 res->Data.Address16.AddressLength)); 423 set->set_ioport(dev, context, 424 res->Data.Address16.Minimum, 425 res->Data.Address16.AddressLength); 426 } 427 } else { 428 if (res->Data.Address16.ResourceType == ACPI_MEMORY_RANGE) { 429 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, 430 "Address16/Memory 0x%x-0x%x/%d\n", 431 res->Data.Address16.Minimum, 432 res->Data.Address16.Maximum, 433 res->Data.Address16.AddressLength)); 434 set->set_memoryrange(dev, context, 435 res->Data.Address16.Minimum, 436 res->Data.Address16.Maximum, 437 res->Data.Address16.AddressLength, 438 res->Data.Address16.Granularity); 439 } else { 440 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, 441 "Address16/IO 0x%x-0x%x/%d\n", 442 res->Data.Address16.Minimum, 443 res->Data.Address16.Maximum, 444 res->Data.Address16.AddressLength)); 445 set->set_iorange(dev, context, 446 res->Data.Address16.Minimum, 447 res->Data.Address16.Maximum, 448 res->Data.Address16.AddressLength, 449 res->Data.Address16.Granularity); 450 } 451 } 452 break; 453 case ACPI_RESOURCE_TYPE_ADDRESS64: 454 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, 455 "unimplemented Address64 resource\n")); 456 break; 457 case ACPI_RESOURCE_TYPE_EXTENDED_IRQ: 458 if (res->Data.ExtendedIrq.ProducerConsumer != ACPI_CONSUMER) { 459 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, 460 "ignored ExtIRQ producer\n")); 461 break; 462 } 463 set->set_ext_irq(dev, context, res->Data.ExtendedIrq.Interrupts, 464 res->Data.ExtendedIrq.InterruptCount, 465 res->Data.ExtendedIrq.Triggering, 466 res->Data.ExtendedIrq.Polarity); 467 break; 468 case ACPI_RESOURCE_TYPE_VENDOR: 469 ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, 470 "unimplemented VendorSpecific resource\n")); 471 break; 472 default: 473 break; 474 } 475 } 476 477 AcpiOsFree(buf.Pointer); 478 set->set_done(dev, context); 479 return_ACPI_STATUS (AE_OK); 480 } 481 482 /* 483 * Resource-set vectors used to attach _CRS-derived resources 484 * to an ACPI device. 485 */ 486 static void acpi_res_set_init(device_t dev, void *arg, void **context); 487 static void acpi_res_set_done(device_t dev, void *context); 488 static void acpi_res_set_ioport(device_t dev, void *context, 489 u_int32_t base, u_int32_t length); 490 static void acpi_res_set_iorange(device_t dev, void *context, 491 u_int32_t low, u_int32_t high, 492 u_int32_t length, u_int32_t align); 493 static void acpi_res_set_memory(device_t dev, void *context, 494 u_int32_t base, u_int32_t length); 495 static void acpi_res_set_memoryrange(device_t dev, void *context, 496 u_int32_t low, u_int32_t high, 497 u_int32_t length, u_int32_t align); 498 static void acpi_res_set_irq(device_t dev, void *context, u_int8_t *irq, 499 int count, int trig, int pol); 500 static void acpi_res_set_ext_irq(device_t dev, void *context, 501 u_int32_t *irq, int count, int trig, int pol); 502 static void acpi_res_set_drq(device_t dev, void *context, u_int8_t *drq, 503 int count); 504 static void acpi_res_set_start_dependent(device_t dev, void *context, 505 int preference); 506 static void acpi_res_set_end_dependent(device_t dev, void *context); 507 508 struct acpi_parse_resource_set acpi_res_parse_set = { 509 acpi_res_set_init, 510 acpi_res_set_done, 511 acpi_res_set_ioport, 512 acpi_res_set_iorange, 513 acpi_res_set_memory, 514 acpi_res_set_memoryrange, 515 acpi_res_set_irq, 516 acpi_res_set_ext_irq, 517 acpi_res_set_drq, 518 acpi_res_set_start_dependent, 519 acpi_res_set_end_dependent 520 }; 521 522 struct acpi_res_context { 523 int ar_nio; 524 int ar_nmem; 525 int ar_nirq; 526 int ar_ndrq; 527 void *ar_parent; 528 }; 529 530 static void 531 acpi_res_set_init(device_t dev, void *arg, void **context) 532 { 533 struct acpi_res_context *cp; 534 535 if ((cp = AcpiOsAllocate(sizeof(*cp))) != NULL) { 536 bzero(cp, sizeof(*cp)); 537 cp->ar_parent = arg; 538 *context = cp; 539 } 540 } 541 542 static void 543 acpi_res_set_done(device_t dev, void *context) 544 { 545 struct acpi_res_context *cp = (struct acpi_res_context *)context; 546 547 if (cp == NULL) 548 return; 549 AcpiOsFree(cp); 550 } 551 552 static void 553 acpi_res_set_ioport(device_t dev, void *context, u_int32_t base, 554 u_int32_t length) 555 { 556 struct acpi_res_context *cp = (struct acpi_res_context *)context; 557 558 if (cp == NULL) 559 return; 560 bus_set_resource(dev, SYS_RES_IOPORT, cp->ar_nio++, base, length); 561 } 562 563 static void 564 acpi_res_set_iorange(device_t dev, void *context, u_int32_t low, 565 u_int32_t high, u_int32_t length, u_int32_t align) 566 { 567 struct acpi_res_context *cp = (struct acpi_res_context *)context; 568 569 if (cp == NULL) 570 return; 571 device_printf(dev, "I/O range not supported\n"); 572 } 573 574 static void 575 acpi_res_set_memory(device_t dev, void *context, u_int32_t base, 576 u_int32_t length) 577 { 578 struct acpi_res_context *cp = (struct acpi_res_context *)context; 579 580 if (cp == NULL) 581 return; 582 583 bus_set_resource(dev, SYS_RES_MEMORY, cp->ar_nmem++, base, length); 584 } 585 586 static void 587 acpi_res_set_memoryrange(device_t dev, void *context, u_int32_t low, 588 u_int32_t high, u_int32_t length, u_int32_t align) 589 { 590 struct acpi_res_context *cp = (struct acpi_res_context *)context; 591 592 if (cp == NULL) 593 return; 594 device_printf(dev, "memory range not supported\n"); 595 } 596 597 static void 598 acpi_res_set_irq(device_t dev, void *context, u_int8_t *irq, int count, 599 int trig, int pol) 600 { 601 struct acpi_res_context *cp = (struct acpi_res_context *)context; 602 603 if (cp == NULL || irq == NULL) 604 return; 605 606 /* This implements no resource relocation. */ 607 if (count != 1) 608 return; 609 610 bus_set_resource(dev, SYS_RES_IRQ, cp->ar_nirq++, *irq, 1); 611 } 612 613 static void 614 acpi_res_set_ext_irq(device_t dev, void *context, u_int32_t *irq, int count, 615 int trig, int pol) 616 { 617 struct acpi_res_context *cp = (struct acpi_res_context *)context; 618 619 if (cp == NULL || irq == NULL) 620 return; 621 622 /* This implements no resource relocation. */ 623 if (count != 1) 624 return; 625 626 bus_set_resource(dev, SYS_RES_IRQ, cp->ar_nirq++, *irq, 1); 627 } 628 629 static void 630 acpi_res_set_drq(device_t dev, void *context, u_int8_t *drq, int count) 631 { 632 struct acpi_res_context *cp = (struct acpi_res_context *)context; 633 634 if (cp == NULL || drq == NULL) 635 return; 636 637 /* This implements no resource relocation. */ 638 if (count != 1) 639 return; 640 641 bus_set_resource(dev, SYS_RES_DRQ, cp->ar_ndrq++, *drq, 1); 642 } 643 644 static void 645 acpi_res_set_start_dependent(device_t dev, void *context, int preference) 646 { 647 struct acpi_res_context *cp = (struct acpi_res_context *)context; 648 649 if (cp == NULL) 650 return; 651 device_printf(dev, "dependent functions not supported\n"); 652 } 653 654 static void 655 acpi_res_set_end_dependent(device_t dev, void *context) 656 { 657 struct acpi_res_context *cp = (struct acpi_res_context *)context; 658 659 if (cp == NULL) 660 return; 661 device_printf(dev, "dependent functions not supported\n"); 662 } 663 664 /* 665 * Resource-owning placeholders for IO and memory pseudo-devices. 666 * 667 * This code allocates system resources that will be used by ACPI 668 * child devices. The acpi parent manages these resources through a 669 * private rman. 670 */ 671 672 static int acpi_sysres_rid = 100; 673 674 static int acpi_sysres_probe(device_t dev); 675 static int acpi_sysres_attach(device_t dev); 676 677 static device_method_t acpi_sysres_methods[] = { 678 /* Device interface */ 679 DEVMETHOD(device_probe, acpi_sysres_probe), 680 DEVMETHOD(device_attach, acpi_sysres_attach), 681 682 {0, 0} 683 }; 684 685 static driver_t acpi_sysres_driver = { 686 "acpi_sysresource", 687 acpi_sysres_methods, 688 0, 689 }; 690 691 static devclass_t acpi_sysres_devclass; 692 DRIVER_MODULE(acpi_sysresource, acpi, acpi_sysres_driver, acpi_sysres_devclass, 693 0, 0); 694 MODULE_DEPEND(acpi_sysresource, acpi, 1, 1, 1); 695 696 static int 697 acpi_sysres_probe(device_t dev) 698 { 699 static char *sysres_ids[] = { "PNP0C01", "PNP0C02", NULL }; 700 701 if (acpi_disabled("sysresource") || 702 ACPI_ID_PROBE(device_get_parent(dev), dev, sysres_ids) == NULL) 703 return (ENXIO); 704 705 device_set_desc(dev, "System Resource"); 706 device_quiet(dev); 707 return (BUS_PROBE_DEFAULT); 708 } 709 710 static int 711 acpi_sysres_attach(device_t dev) 712 { 713 device_t bus; 714 struct resource_list_entry *bus_rle, *dev_rle; 715 struct resource_list *bus_rl, *dev_rl; 716 int done, type; 717 u_long start, end, count; 718 719 /* 720 * Loop through all current resources to see if the new one overlaps 721 * any existing ones. If so, grow the old one up and/or down 722 * accordingly. Discard any that are wholly contained in the old. If 723 * the resource is unique, add it to the parent. It will later go into 724 * the rman pool. 725 */ 726 bus = device_get_parent(dev); 727 dev_rl = BUS_GET_RESOURCE_LIST(bus, dev); 728 bus_rl = BUS_GET_RESOURCE_LIST(device_get_parent(bus), bus); 729 STAILQ_FOREACH(dev_rle, dev_rl, link) { 730 if (dev_rle->type != SYS_RES_IOPORT && dev_rle->type != SYS_RES_MEMORY) 731 continue; 732 733 start = dev_rle->start; 734 end = dev_rle->end; 735 count = dev_rle->count; 736 type = dev_rle->type; 737 done = FALSE; 738 739 STAILQ_FOREACH(bus_rle, bus_rl, link) { 740 if (bus_rle->type != type) 741 continue; 742 743 /* New resource wholly contained in old, discard. */ 744 if (start >= bus_rle->start && end <= bus_rle->end) 745 break; 746 747 /* New tail overlaps old head, grow existing resource downward. */ 748 if (start < bus_rle->start && end >= bus_rle->start) { 749 bus_rle->count += bus_rle->start - start; 750 bus_rle->start = start; 751 done = TRUE; 752 } 753 754 /* New head overlaps old tail, grow existing resource upward. */ 755 if (start <= bus_rle->end && end > bus_rle->end) { 756 bus_rle->count += end - bus_rle->end; 757 bus_rle->end = end; 758 done = TRUE; 759 } 760 761 /* If we adjusted the old resource, we're finished. */ 762 if (done) 763 break; 764 } 765 766 /* If we didn't merge with anything, add this resource. */ 767 if (bus_rle == NULL) 768 bus_set_resource(bus, type, acpi_sysres_rid++, start, count); 769 } 770 771 /* After merging/moving resources to the parent, free the list. */ 772 resource_list_free(dev_rl); 773 774 return (0); 775 }
Cache object: 0cf49c6150dc6176ceeacc2cf5a6e17a
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]