diff options
Diffstat (limited to 'drivers/pci/hotplug/acpiphp_glue.c')
-rw-r--r-- | drivers/pci/hotplug/acpiphp_glue.c | 882 |
1 files changed, 512 insertions, 370 deletions
diff --git a/drivers/pci/hotplug/acpiphp_glue.c b/drivers/pci/hotplug/acpiphp_glue.c index e7f41294f811..424e7de181ae 100644 --- a/drivers/pci/hotplug/acpiphp_glue.c +++ b/drivers/pci/hotplug/acpiphp_glue.c | |||
@@ -4,6 +4,10 @@ | |||
4 | * Copyright (C) 2002,2003 Takayoshi Kochi (t-kochi@bq.jp.nec.com) | 4 | * Copyright (C) 2002,2003 Takayoshi Kochi (t-kochi@bq.jp.nec.com) |
5 | * Copyright (C) 2002 Hiroshi Aono (h-aono@ap.jp.nec.com) | 5 | * Copyright (C) 2002 Hiroshi Aono (h-aono@ap.jp.nec.com) |
6 | * Copyright (C) 2002,2003 NEC Corporation | 6 | * Copyright (C) 2002,2003 NEC Corporation |
7 | * Copyright (C) 2003-2005 Matthew Wilcox (matthew.wilcox@hp.com) | ||
8 | * Copyright (C) 2003-2005 Hewlett Packard | ||
9 | * Copyright (C) 2005 Rajesh Shah (rajesh.shah@intel.com) | ||
10 | * Copyright (C) 2005 Intel Corporation | ||
7 | * | 11 | * |
8 | * All rights reserved. | 12 | * All rights reserved. |
9 | * | 13 | * |
@@ -26,6 +30,16 @@ | |||
26 | * | 30 | * |
27 | */ | 31 | */ |
28 | 32 | ||
33 | /* | ||
34 | * Lifetime rules for pci_dev: | ||
35 | * - The one in acpiphp_func has its refcount elevated by pci_get_slot() | ||
36 | * when the driver is loaded or when an insertion event occurs. It loses | ||
37 | * a refcount when its ejected or the driver unloads. | ||
38 | * - The one in acpiphp_bridge has its refcount elevated by pci_get_slot() | ||
39 | * when the bridge is scanned and it loses a refcount when the bridge | ||
40 | * is removed. | ||
41 | */ | ||
42 | |||
29 | #include <linux/init.h> | 43 | #include <linux/init.h> |
30 | #include <linux/module.h> | 44 | #include <linux/module.h> |
31 | 45 | ||
@@ -178,21 +192,18 @@ register_slot(acpi_handle handle, u32 lvl, void *context, void **rv) | |||
178 | 192 | ||
179 | bridge->nr_slots++; | 193 | bridge->nr_slots++; |
180 | 194 | ||
181 | dbg("found ACPI PCI Hotplug slot at PCI %02x:%02x Slot:%d\n", | 195 | dbg("found ACPI PCI Hotplug slot %d at PCI %04x:%02x:%02x\n", |
182 | slot->bridge->bus, slot->device, slot->sun); | 196 | slot->sun, pci_domain_nr(bridge->pci_bus), |
197 | bridge->pci_bus->number, slot->device); | ||
183 | } | 198 | } |
184 | 199 | ||
185 | newfunc->slot = slot; | 200 | newfunc->slot = slot; |
186 | list_add_tail(&newfunc->sibling, &slot->funcs); | 201 | list_add_tail(&newfunc->sibling, &slot->funcs); |
187 | 202 | ||
188 | /* associate corresponding pci_dev */ | 203 | /* associate corresponding pci_dev */ |
189 | newfunc->pci_dev = pci_find_slot(bridge->bus, | 204 | newfunc->pci_dev = pci_get_slot(bridge->pci_bus, |
190 | PCI_DEVFN(device, function)); | 205 | PCI_DEVFN(device, function)); |
191 | if (newfunc->pci_dev) { | 206 | if (newfunc->pci_dev) { |
192 | if (acpiphp_init_func_resource(newfunc) < 0) { | ||
193 | kfree(newfunc); | ||
194 | return AE_ERROR; | ||
195 | } | ||
196 | slot->flags |= (SLOT_ENABLED | SLOT_POWEREDON); | 207 | slot->flags |= (SLOT_ENABLED | SLOT_POWEREDON); |
197 | } | 208 | } |
198 | 209 | ||
@@ -227,62 +238,6 @@ static int detect_ejectable_slots(acpi_handle *bridge_handle) | |||
227 | } | 238 | } |
228 | 239 | ||
229 | 240 | ||
230 | /* decode ACPI _CRS data and convert into our internal resource list | ||
231 | * TBD: _TRA, etc. | ||
232 | */ | ||
233 | static acpi_status | ||
234 | decode_acpi_resource(struct acpi_resource *resource, void *context) | ||
235 | { | ||
236 | struct acpiphp_bridge *bridge = (struct acpiphp_bridge *) context; | ||
237 | struct acpi_resource_address64 address; | ||
238 | struct pci_resource *res; | ||
239 | |||
240 | if (resource->id != ACPI_RSTYPE_ADDRESS16 && | ||
241 | resource->id != ACPI_RSTYPE_ADDRESS32 && | ||
242 | resource->id != ACPI_RSTYPE_ADDRESS64) | ||
243 | return AE_OK; | ||
244 | |||
245 | acpi_resource_to_address64(resource, &address); | ||
246 | |||
247 | if (address.producer_consumer == ACPI_PRODUCER && address.address_length > 0) { | ||
248 | dbg("resource type: %d: 0x%llx - 0x%llx\n", address.resource_type, | ||
249 | (unsigned long long)address.min_address_range, | ||
250 | (unsigned long long)address.max_address_range); | ||
251 | res = acpiphp_make_resource(address.min_address_range, | ||
252 | address.address_length); | ||
253 | if (!res) { | ||
254 | err("out of memory\n"); | ||
255 | return AE_OK; | ||
256 | } | ||
257 | |||
258 | switch (address.resource_type) { | ||
259 | case ACPI_MEMORY_RANGE: | ||
260 | if (address.attribute.memory.cache_attribute == ACPI_PREFETCHABLE_MEMORY) { | ||
261 | res->next = bridge->p_mem_head; | ||
262 | bridge->p_mem_head = res; | ||
263 | } else { | ||
264 | res->next = bridge->mem_head; | ||
265 | bridge->mem_head = res; | ||
266 | } | ||
267 | break; | ||
268 | case ACPI_IO_RANGE: | ||
269 | res->next = bridge->io_head; | ||
270 | bridge->io_head = res; | ||
271 | break; | ||
272 | case ACPI_BUS_NUMBER_RANGE: | ||
273 | res->next = bridge->bus_head; | ||
274 | bridge->bus_head = res; | ||
275 | break; | ||
276 | default: | ||
277 | /* invalid type */ | ||
278 | kfree(res); | ||
279 | break; | ||
280 | } | ||
281 | } | ||
282 | |||
283 | return AE_OK; | ||
284 | } | ||
285 | |||
286 | /* decode ACPI 2.0 _HPP hot plug parameters */ | 241 | /* decode ACPI 2.0 _HPP hot plug parameters */ |
287 | static void decode_hpp(struct acpiphp_bridge *bridge) | 242 | static void decode_hpp(struct acpiphp_bridge *bridge) |
288 | { | 243 | { |
@@ -346,34 +301,29 @@ static void init_bridge_misc(struct acpiphp_bridge *bridge) | |||
346 | /* decode ACPI 2.0 _HPP (hot plug parameters) */ | 301 | /* decode ACPI 2.0 _HPP (hot plug parameters) */ |
347 | decode_hpp(bridge); | 302 | decode_hpp(bridge); |
348 | 303 | ||
349 | /* subtract all resources already allocated */ | ||
350 | acpiphp_detect_pci_resource(bridge); | ||
351 | |||
352 | /* register all slot objects under this bridge */ | 304 | /* register all slot objects under this bridge */ |
353 | status = acpi_walk_namespace(ACPI_TYPE_DEVICE, bridge->handle, (u32)1, | 305 | status = acpi_walk_namespace(ACPI_TYPE_DEVICE, bridge->handle, (u32)1, |
354 | register_slot, bridge, NULL); | 306 | register_slot, bridge, NULL); |
355 | 307 | ||
356 | /* install notify handler */ | 308 | /* install notify handler */ |
357 | status = acpi_install_notify_handler(bridge->handle, | 309 | if (bridge->type != BRIDGE_TYPE_HOST) { |
310 | status = acpi_install_notify_handler(bridge->handle, | ||
358 | ACPI_SYSTEM_NOTIFY, | 311 | ACPI_SYSTEM_NOTIFY, |
359 | handle_hotplug_event_bridge, | 312 | handle_hotplug_event_bridge, |
360 | bridge); | 313 | bridge); |
361 | 314 | ||
362 | if (ACPI_FAILURE(status)) { | 315 | if (ACPI_FAILURE(status)) { |
363 | err("failed to register interrupt notify handler\n"); | 316 | err("failed to register interrupt notify handler\n"); |
317 | } | ||
364 | } | 318 | } |
365 | 319 | ||
366 | list_add(&bridge->list, &bridge_list); | 320 | list_add(&bridge->list, &bridge_list); |
367 | |||
368 | dbg("Bridge resource:\n"); | ||
369 | acpiphp_dump_resource(bridge); | ||
370 | } | 321 | } |
371 | 322 | ||
372 | 323 | ||
373 | /* allocate and initialize host bridge data structure */ | 324 | /* allocate and initialize host bridge data structure */ |
374 | static void add_host_bridge(acpi_handle *handle, int seg, int bus) | 325 | static void add_host_bridge(acpi_handle *handle, struct pci_bus *pci_bus) |
375 | { | 326 | { |
376 | acpi_status status; | ||
377 | struct acpiphp_bridge *bridge; | 327 | struct acpiphp_bridge *bridge; |
378 | 328 | ||
379 | bridge = kmalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL); | 329 | bridge = kmalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL); |
@@ -384,52 +334,19 @@ static void add_host_bridge(acpi_handle *handle, int seg, int bus) | |||
384 | 334 | ||
385 | bridge->type = BRIDGE_TYPE_HOST; | 335 | bridge->type = BRIDGE_TYPE_HOST; |
386 | bridge->handle = handle; | 336 | bridge->handle = handle; |
387 | bridge->seg = seg; | ||
388 | bridge->bus = bus; | ||
389 | 337 | ||
390 | bridge->pci_bus = pci_find_bus(seg, bus); | 338 | bridge->pci_bus = pci_bus; |
391 | 339 | ||
392 | spin_lock_init(&bridge->res_lock); | 340 | spin_lock_init(&bridge->res_lock); |
393 | 341 | ||
394 | /* to be overridden when we decode _CRS */ | ||
395 | bridge->sub = bridge->bus; | ||
396 | |||
397 | /* decode resources */ | ||
398 | |||
399 | status = acpi_walk_resources(handle, METHOD_NAME__CRS, | ||
400 | decode_acpi_resource, bridge); | ||
401 | |||
402 | if (ACPI_FAILURE(status)) { | ||
403 | err("failed to decode bridge resources\n"); | ||
404 | kfree(bridge); | ||
405 | return; | ||
406 | } | ||
407 | |||
408 | acpiphp_resource_sort_and_combine(&bridge->io_head); | ||
409 | acpiphp_resource_sort_and_combine(&bridge->mem_head); | ||
410 | acpiphp_resource_sort_and_combine(&bridge->p_mem_head); | ||
411 | acpiphp_resource_sort_and_combine(&bridge->bus_head); | ||
412 | |||
413 | dbg("ACPI _CRS resource:\n"); | ||
414 | acpiphp_dump_resource(bridge); | ||
415 | |||
416 | if (bridge->bus_head) { | ||
417 | bridge->bus = bridge->bus_head->base; | ||
418 | bridge->sub = bridge->bus_head->base + bridge->bus_head->length - 1; | ||
419 | } | ||
420 | |||
421 | init_bridge_misc(bridge); | 342 | init_bridge_misc(bridge); |
422 | } | 343 | } |
423 | 344 | ||
424 | 345 | ||
425 | /* allocate and initialize PCI-to-PCI bridge data structure */ | 346 | /* allocate and initialize PCI-to-PCI bridge data structure */ |
426 | static void add_p2p_bridge(acpi_handle *handle, int seg, int bus, int dev, int fn) | 347 | static void add_p2p_bridge(acpi_handle *handle, struct pci_dev *pci_dev) |
427 | { | 348 | { |
428 | struct acpiphp_bridge *bridge; | 349 | struct acpiphp_bridge *bridge; |
429 | u8 tmp8; | ||
430 | u16 tmp16; | ||
431 | u64 base64, limit64; | ||
432 | u32 base, limit, base32u, limit32u; | ||
433 | 350 | ||
434 | bridge = kmalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL); | 351 | bridge = kmalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL); |
435 | if (bridge == NULL) { | 352 | if (bridge == NULL) { |
@@ -441,133 +358,22 @@ static void add_p2p_bridge(acpi_handle *handle, int seg, int bus, int dev, int f | |||
441 | 358 | ||
442 | bridge->type = BRIDGE_TYPE_P2P; | 359 | bridge->type = BRIDGE_TYPE_P2P; |
443 | bridge->handle = handle; | 360 | bridge->handle = handle; |
444 | bridge->seg = seg; | ||
445 | |||
446 | bridge->pci_dev = pci_find_slot(bus, PCI_DEVFN(dev, fn)); | ||
447 | if (!bridge->pci_dev) { | ||
448 | err("Can't get pci_dev\n"); | ||
449 | kfree(bridge); | ||
450 | return; | ||
451 | } | ||
452 | 361 | ||
453 | bridge->pci_bus = bridge->pci_dev->subordinate; | 362 | bridge->pci_dev = pci_dev_get(pci_dev); |
363 | bridge->pci_bus = pci_dev->subordinate; | ||
454 | if (!bridge->pci_bus) { | 364 | if (!bridge->pci_bus) { |
455 | err("This is not a PCI-to-PCI bridge!\n"); | 365 | err("This is not a PCI-to-PCI bridge!\n"); |
456 | kfree(bridge); | 366 | goto err; |
457 | return; | ||
458 | } | 367 | } |
459 | 368 | ||
460 | spin_lock_init(&bridge->res_lock); | 369 | spin_lock_init(&bridge->res_lock); |
461 | 370 | ||
462 | bridge->bus = bridge->pci_bus->number; | ||
463 | bridge->sub = bridge->pci_bus->subordinate; | ||
464 | |||
465 | /* | ||
466 | * decode resources under this P2P bridge | ||
467 | */ | ||
468 | |||
469 | /* I/O resources */ | ||
470 | pci_read_config_byte(bridge->pci_dev, PCI_IO_BASE, &tmp8); | ||
471 | base = tmp8; | ||
472 | pci_read_config_byte(bridge->pci_dev, PCI_IO_LIMIT, &tmp8); | ||
473 | limit = tmp8; | ||
474 | |||
475 | switch (base & PCI_IO_RANGE_TYPE_MASK) { | ||
476 | case PCI_IO_RANGE_TYPE_16: | ||
477 | base = (base << 8) & 0xf000; | ||
478 | limit = ((limit << 8) & 0xf000) + 0xfff; | ||
479 | bridge->io_head = acpiphp_make_resource((u64)base, limit - base + 1); | ||
480 | if (!bridge->io_head) { | ||
481 | err("out of memory\n"); | ||
482 | kfree(bridge); | ||
483 | return; | ||
484 | } | ||
485 | dbg("16bit I/O range: %04x-%04x\n", | ||
486 | (u32)bridge->io_head->base, | ||
487 | (u32)(bridge->io_head->base + bridge->io_head->length - 1)); | ||
488 | break; | ||
489 | case PCI_IO_RANGE_TYPE_32: | ||
490 | pci_read_config_word(bridge->pci_dev, PCI_IO_BASE_UPPER16, &tmp16); | ||
491 | base = ((u32)tmp16 << 16) | ((base << 8) & 0xf000); | ||
492 | pci_read_config_word(bridge->pci_dev, PCI_IO_LIMIT_UPPER16, &tmp16); | ||
493 | limit = (((u32)tmp16 << 16) | ((limit << 8) & 0xf000)) + 0xfff; | ||
494 | bridge->io_head = acpiphp_make_resource((u64)base, limit - base + 1); | ||
495 | if (!bridge->io_head) { | ||
496 | err("out of memory\n"); | ||
497 | kfree(bridge); | ||
498 | return; | ||
499 | } | ||
500 | dbg("32bit I/O range: %08x-%08x\n", | ||
501 | (u32)bridge->io_head->base, | ||
502 | (u32)(bridge->io_head->base + bridge->io_head->length - 1)); | ||
503 | break; | ||
504 | case 0x0f: | ||
505 | dbg("I/O space unsupported\n"); | ||
506 | break; | ||
507 | default: | ||
508 | warn("Unknown I/O range type\n"); | ||
509 | } | ||
510 | |||
511 | /* Memory resources (mandatory for P2P bridge) */ | ||
512 | pci_read_config_word(bridge->pci_dev, PCI_MEMORY_BASE, &tmp16); | ||
513 | base = (tmp16 & 0xfff0) << 16; | ||
514 | pci_read_config_word(bridge->pci_dev, PCI_MEMORY_LIMIT, &tmp16); | ||
515 | limit = ((tmp16 & 0xfff0) << 16) | 0xfffff; | ||
516 | bridge->mem_head = acpiphp_make_resource((u64)base, limit - base + 1); | ||
517 | if (!bridge->mem_head) { | ||
518 | err("out of memory\n"); | ||
519 | kfree(bridge); | ||
520 | return; | ||
521 | } | ||
522 | dbg("32bit Memory range: %08x-%08x\n", | ||
523 | (u32)bridge->mem_head->base, | ||
524 | (u32)(bridge->mem_head->base + bridge->mem_head->length-1)); | ||
525 | |||
526 | /* Prefetchable Memory resources (optional) */ | ||
527 | pci_read_config_word(bridge->pci_dev, PCI_PREF_MEMORY_BASE, &tmp16); | ||
528 | base = tmp16; | ||
529 | pci_read_config_word(bridge->pci_dev, PCI_PREF_MEMORY_LIMIT, &tmp16); | ||
530 | limit = tmp16; | ||
531 | |||
532 | switch (base & PCI_MEMORY_RANGE_TYPE_MASK) { | ||
533 | case PCI_PREF_RANGE_TYPE_32: | ||
534 | base = (base & 0xfff0) << 16; | ||
535 | limit = ((limit & 0xfff0) << 16) | 0xfffff; | ||
536 | bridge->p_mem_head = acpiphp_make_resource((u64)base, limit - base + 1); | ||
537 | if (!bridge->p_mem_head) { | ||
538 | err("out of memory\n"); | ||
539 | kfree(bridge); | ||
540 | return; | ||
541 | } | ||
542 | dbg("32bit Prefetchable memory range: %08x-%08x\n", | ||
543 | (u32)bridge->p_mem_head->base, | ||
544 | (u32)(bridge->p_mem_head->base + bridge->p_mem_head->length - 1)); | ||
545 | break; | ||
546 | case PCI_PREF_RANGE_TYPE_64: | ||
547 | pci_read_config_dword(bridge->pci_dev, PCI_PREF_BASE_UPPER32, &base32u); | ||
548 | pci_read_config_dword(bridge->pci_dev, PCI_PREF_LIMIT_UPPER32, &limit32u); | ||
549 | base64 = ((u64)base32u << 32) | ((base & 0xfff0) << 16); | ||
550 | limit64 = (((u64)limit32u << 32) | ((limit & 0xfff0) << 16)) + 0xfffff; | ||
551 | |||
552 | bridge->p_mem_head = acpiphp_make_resource(base64, limit64 - base64 + 1); | ||
553 | if (!bridge->p_mem_head) { | ||
554 | err("out of memory\n"); | ||
555 | kfree(bridge); | ||
556 | return; | ||
557 | } | ||
558 | dbg("64bit Prefetchable memory range: %08x%08x-%08x%08x\n", | ||
559 | (u32)(bridge->p_mem_head->base >> 32), | ||
560 | (u32)(bridge->p_mem_head->base & 0xffffffff), | ||
561 | (u32)((bridge->p_mem_head->base + bridge->p_mem_head->length - 1) >> 32), | ||
562 | (u32)((bridge->p_mem_head->base + bridge->p_mem_head->length - 1) & 0xffffffff)); | ||
563 | break; | ||
564 | case 0x0f: | ||
565 | break; | ||
566 | default: | ||
567 | warn("Unknown prefetchale memory type\n"); | ||
568 | } | ||
569 | |||
570 | init_bridge_misc(bridge); | 371 | init_bridge_misc(bridge); |
372 | return; | ||
373 | err: | ||
374 | pci_dev_put(pci_dev); | ||
375 | kfree(bridge); | ||
376 | return; | ||
571 | } | 377 | } |
572 | 378 | ||
573 | 379 | ||
@@ -577,14 +383,10 @@ find_p2p_bridge(acpi_handle handle, u32 lvl, void *context, void **rv) | |||
577 | { | 383 | { |
578 | acpi_status status; | 384 | acpi_status status; |
579 | acpi_handle dummy_handle; | 385 | acpi_handle dummy_handle; |
580 | unsigned long *segbus = context; | ||
581 | unsigned long tmp; | 386 | unsigned long tmp; |
582 | int seg, bus, device, function; | 387 | int device, function; |
583 | struct pci_dev *dev; | 388 | struct pci_dev *dev; |
584 | 389 | struct pci_bus *pci_bus = context; | |
585 | /* get PCI address */ | ||
586 | seg = (*segbus >> 8) & 0xff; | ||
587 | bus = *segbus & 0xff; | ||
588 | 390 | ||
589 | status = acpi_get_handle(handle, "_ADR", &dummy_handle); | 391 | status = acpi_get_handle(handle, "_ADR", &dummy_handle); |
590 | if (ACPI_FAILURE(status)) | 392 | if (ACPI_FAILURE(status)) |
@@ -599,20 +401,19 @@ find_p2p_bridge(acpi_handle handle, u32 lvl, void *context, void **rv) | |||
599 | device = (tmp >> 16) & 0xffff; | 401 | device = (tmp >> 16) & 0xffff; |
600 | function = tmp & 0xffff; | 402 | function = tmp & 0xffff; |
601 | 403 | ||
602 | dev = pci_find_slot(bus, PCI_DEVFN(device, function)); | 404 | dev = pci_get_slot(pci_bus, PCI_DEVFN(device, function)); |
603 | 405 | ||
604 | if (!dev) | 406 | if (!dev || !dev->subordinate) |
605 | return AE_OK; | 407 | goto out; |
606 | |||
607 | if (!dev->subordinate) | ||
608 | return AE_OK; | ||
609 | 408 | ||
610 | /* check if this bridge has ejectable slots */ | 409 | /* check if this bridge has ejectable slots */ |
611 | if (detect_ejectable_slots(handle) > 0) { | 410 | if (detect_ejectable_slots(handle) > 0) { |
612 | dbg("found PCI-to-PCI bridge at PCI %s\n", pci_name(dev)); | 411 | dbg("found PCI-to-PCI bridge at PCI %s\n", pci_name(dev)); |
613 | add_p2p_bridge(handle, seg, bus, device, function); | 412 | add_p2p_bridge(handle, dev); |
614 | } | 413 | } |
615 | 414 | ||
415 | out: | ||
416 | pci_dev_put(dev); | ||
616 | return AE_OK; | 417 | return AE_OK; |
617 | } | 418 | } |
618 | 419 | ||
@@ -624,6 +425,7 @@ static int add_bridge(acpi_handle handle) | |||
624 | unsigned long tmp; | 425 | unsigned long tmp; |
625 | int seg, bus; | 426 | int seg, bus; |
626 | acpi_handle dummy_handle; | 427 | acpi_handle dummy_handle; |
428 | struct pci_bus *pci_bus; | ||
627 | 429 | ||
628 | /* if the bridge doesn't have _STA, we assume it is always there */ | 430 | /* if the bridge doesn't have _STA, we assume it is always there */ |
629 | status = acpi_get_handle(handle, "_STA", &dummy_handle); | 431 | status = acpi_get_handle(handle, "_STA", &dummy_handle); |
@@ -653,18 +455,22 @@ static int add_bridge(acpi_handle handle) | |||
653 | bus = 0; | 455 | bus = 0; |
654 | } | 456 | } |
655 | 457 | ||
458 | pci_bus = pci_find_bus(seg, bus); | ||
459 | if (!pci_bus) { | ||
460 | err("Can't find bus %04x:%02x\n", seg, bus); | ||
461 | return 0; | ||
462 | } | ||
463 | |||
656 | /* check if this bridge has ejectable slots */ | 464 | /* check if this bridge has ejectable slots */ |
657 | if (detect_ejectable_slots(handle) > 0) { | 465 | if (detect_ejectable_slots(handle) > 0) { |
658 | dbg("found PCI host-bus bridge with hot-pluggable slots\n"); | 466 | dbg("found PCI host-bus bridge with hot-pluggable slots\n"); |
659 | add_host_bridge(handle, seg, bus); | 467 | add_host_bridge(handle, pci_bus); |
660 | return 0; | 468 | return 0; |
661 | } | 469 | } |
662 | 470 | ||
663 | tmp = seg << 8 | bus; | ||
664 | |||
665 | /* search P2P bridges under this host bridge */ | 471 | /* search P2P bridges under this host bridge */ |
666 | status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1, | 472 | status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1, |
667 | find_p2p_bridge, &tmp, NULL); | 473 | find_p2p_bridge, pci_bus, NULL); |
668 | 474 | ||
669 | if (ACPI_FAILURE(status)) | 475 | if (ACPI_FAILURE(status)) |
670 | warn("find_p2p_bridge faied (error code = 0x%x)\n",status); | 476 | warn("find_p2p_bridge faied (error code = 0x%x)\n",status); |
@@ -672,12 +478,205 @@ static int add_bridge(acpi_handle handle) | |||
672 | return 0; | 478 | return 0; |
673 | } | 479 | } |
674 | 480 | ||
481 | static struct acpiphp_bridge *acpiphp_handle_to_bridge(acpi_handle handle) | ||
482 | { | ||
483 | struct list_head *head; | ||
484 | list_for_each(head, &bridge_list) { | ||
485 | struct acpiphp_bridge *bridge = list_entry(head, | ||
486 | struct acpiphp_bridge, list); | ||
487 | if (bridge->handle == handle) | ||
488 | return bridge; | ||
489 | } | ||
490 | |||
491 | return NULL; | ||
492 | } | ||
493 | |||
494 | static void cleanup_bridge(struct acpiphp_bridge *bridge) | ||
495 | { | ||
496 | struct list_head *list, *tmp; | ||
497 | struct acpiphp_slot *slot; | ||
498 | acpi_status status; | ||
499 | acpi_handle handle = bridge->handle; | ||
500 | |||
501 | status = acpi_remove_notify_handler(handle, ACPI_SYSTEM_NOTIFY, | ||
502 | handle_hotplug_event_bridge); | ||
503 | if (ACPI_FAILURE(status)) | ||
504 | err("failed to remove notify handler\n"); | ||
505 | |||
506 | slot = bridge->slots; | ||
507 | while (slot) { | ||
508 | struct acpiphp_slot *next = slot->next; | ||
509 | list_for_each_safe (list, tmp, &slot->funcs) { | ||
510 | struct acpiphp_func *func; | ||
511 | func = list_entry(list, struct acpiphp_func, sibling); | ||
512 | status = acpi_remove_notify_handler(func->handle, | ||
513 | ACPI_SYSTEM_NOTIFY, | ||
514 | handle_hotplug_event_func); | ||
515 | if (ACPI_FAILURE(status)) | ||
516 | err("failed to remove notify handler\n"); | ||
517 | pci_dev_put(func->pci_dev); | ||
518 | list_del(list); | ||
519 | kfree(func); | ||
520 | } | ||
521 | kfree(slot); | ||
522 | slot = next; | ||
523 | } | ||
524 | |||
525 | pci_dev_put(bridge->pci_dev); | ||
526 | list_del(&bridge->list); | ||
527 | kfree(bridge); | ||
528 | } | ||
529 | |||
530 | static acpi_status | ||
531 | cleanup_p2p_bridge(acpi_handle handle, u32 lvl, void *context, void **rv) | ||
532 | { | ||
533 | struct acpiphp_bridge *bridge; | ||
534 | |||
535 | if (!(bridge = acpiphp_handle_to_bridge(handle))) | ||
536 | return AE_OK; | ||
537 | cleanup_bridge(bridge); | ||
538 | return AE_OK; | ||
539 | } | ||
675 | 540 | ||
676 | static void remove_bridge(acpi_handle handle) | 541 | static void remove_bridge(acpi_handle handle) |
677 | { | 542 | { |
678 | /* No-op for now .. */ | 543 | struct acpiphp_bridge *bridge; |
544 | |||
545 | bridge = acpiphp_handle_to_bridge(handle); | ||
546 | if (bridge) { | ||
547 | cleanup_bridge(bridge); | ||
548 | } else { | ||
549 | /* clean-up p2p bridges under this host bridge */ | ||
550 | acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, | ||
551 | (u32)1, cleanup_p2p_bridge, NULL, NULL); | ||
552 | } | ||
553 | } | ||
554 | |||
555 | static struct pci_dev * get_apic_pci_info(acpi_handle handle) | ||
556 | { | ||
557 | struct acpi_pci_id id; | ||
558 | struct pci_bus *bus; | ||
559 | struct pci_dev *dev; | ||
560 | |||
561 | if (ACPI_FAILURE(acpi_get_pci_id(handle, &id))) | ||
562 | return NULL; | ||
563 | |||
564 | bus = pci_find_bus(id.segment, id.bus); | ||
565 | if (!bus) | ||
566 | return NULL; | ||
567 | |||
568 | dev = pci_get_slot(bus, PCI_DEVFN(id.device, id.function)); | ||
569 | if (!dev) | ||
570 | return NULL; | ||
571 | |||
572 | if ((dev->class != PCI_CLASS_SYSTEM_PIC_IOAPIC) && | ||
573 | (dev->class != PCI_CLASS_SYSTEM_PIC_IOXAPIC)) | ||
574 | { | ||
575 | pci_dev_put(dev); | ||
576 | return NULL; | ||
577 | } | ||
578 | |||
579 | return dev; | ||
580 | } | ||
581 | |||
582 | static int get_gsi_base(acpi_handle handle, u32 *gsi_base) | ||
583 | { | ||
584 | acpi_status status; | ||
585 | int result = -1; | ||
586 | unsigned long gsb; | ||
587 | struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL}; | ||
588 | union acpi_object *obj; | ||
589 | void *table; | ||
590 | |||
591 | status = acpi_evaluate_integer(handle, "_GSB", NULL, &gsb); | ||
592 | if (ACPI_SUCCESS(status)) { | ||
593 | *gsi_base = (u32)gsb; | ||
594 | return 0; | ||
595 | } | ||
596 | |||
597 | status = acpi_evaluate_object(handle, "_MAT", NULL, &buffer); | ||
598 | if (ACPI_FAILURE(status) || !buffer.length || !buffer.pointer) | ||
599 | return -1; | ||
600 | |||
601 | obj = buffer.pointer; | ||
602 | if (obj->type != ACPI_TYPE_BUFFER) | ||
603 | goto out; | ||
604 | |||
605 | table = obj->buffer.pointer; | ||
606 | switch (((acpi_table_entry_header *)table)->type) { | ||
607 | case ACPI_MADT_IOSAPIC: | ||
608 | *gsi_base = ((struct acpi_table_iosapic *)table)->global_irq_base; | ||
609 | result = 0; | ||
610 | break; | ||
611 | case ACPI_MADT_IOAPIC: | ||
612 | *gsi_base = ((struct acpi_table_ioapic *)table)->global_irq_base; | ||
613 | result = 0; | ||
614 | break; | ||
615 | default: | ||
616 | break; | ||
617 | } | ||
618 | out: | ||
619 | acpi_os_free(buffer.pointer); | ||
620 | return result; | ||
621 | } | ||
622 | |||
623 | static acpi_status | ||
624 | ioapic_add(acpi_handle handle, u32 lvl, void *context, void **rv) | ||
625 | { | ||
626 | acpi_status status; | ||
627 | unsigned long sta; | ||
628 | acpi_handle tmp; | ||
629 | struct pci_dev *pdev; | ||
630 | u32 gsi_base; | ||
631 | u64 phys_addr; | ||
632 | |||
633 | /* Evaluate _STA if present */ | ||
634 | status = acpi_evaluate_integer(handle, "_STA", NULL, &sta); | ||
635 | if (ACPI_SUCCESS(status) && sta != ACPI_STA_ALL) | ||
636 | return AE_CTRL_DEPTH; | ||
637 | |||
638 | /* Scan only PCI bus scope */ | ||
639 | status = acpi_get_handle(handle, "_HID", &tmp); | ||
640 | if (ACPI_SUCCESS(status)) | ||
641 | return AE_CTRL_DEPTH; | ||
642 | |||
643 | if (get_gsi_base(handle, &gsi_base)) | ||
644 | return AE_OK; | ||
645 | |||
646 | pdev = get_apic_pci_info(handle); | ||
647 | if (!pdev) | ||
648 | return AE_OK; | ||
649 | |||
650 | if (pci_enable_device(pdev)) { | ||
651 | pci_dev_put(pdev); | ||
652 | return AE_OK; | ||
653 | } | ||
654 | |||
655 | pci_set_master(pdev); | ||
656 | |||
657 | if (pci_request_region(pdev, 0, "I/O APIC(acpiphp)")) { | ||
658 | pci_disable_device(pdev); | ||
659 | pci_dev_put(pdev); | ||
660 | return AE_OK; | ||
661 | } | ||
662 | |||
663 | phys_addr = pci_resource_start(pdev, 0); | ||
664 | if (acpi_register_ioapic(handle, phys_addr, gsi_base)) { | ||
665 | pci_release_region(pdev, 0); | ||
666 | pci_disable_device(pdev); | ||
667 | pci_dev_put(pdev); | ||
668 | return AE_OK; | ||
669 | } | ||
670 | |||
671 | return AE_OK; | ||
679 | } | 672 | } |
680 | 673 | ||
674 | static int acpiphp_configure_ioapics(acpi_handle handle) | ||
675 | { | ||
676 | acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, | ||
677 | ACPI_UINT32_MAX, ioapic_add, NULL, NULL); | ||
678 | return 0; | ||
679 | } | ||
681 | 680 | ||
682 | static int power_on_slot(struct acpiphp_slot *slot) | 681 | static int power_on_slot(struct acpiphp_slot *slot) |
683 | { | 682 | { |
@@ -719,8 +718,6 @@ static int power_off_slot(struct acpiphp_slot *slot) | |||
719 | acpi_status status; | 718 | acpi_status status; |
720 | struct acpiphp_func *func; | 719 | struct acpiphp_func *func; |
721 | struct list_head *l; | 720 | struct list_head *l; |
722 | struct acpi_object_list arg_list; | ||
723 | union acpi_object arg; | ||
724 | 721 | ||
725 | int retval = 0; | 722 | int retval = 0; |
726 | 723 | ||
@@ -731,7 +728,7 @@ static int power_off_slot(struct acpiphp_slot *slot) | |||
731 | list_for_each (l, &slot->funcs) { | 728 | list_for_each (l, &slot->funcs) { |
732 | func = list_entry(l, struct acpiphp_func, sibling); | 729 | func = list_entry(l, struct acpiphp_func, sibling); |
733 | 730 | ||
734 | if (func->pci_dev && (func->flags & FUNC_HAS_PS3)) { | 731 | if (func->flags & FUNC_HAS_PS3) { |
735 | status = acpi_evaluate_object(func->handle, "_PS3", NULL, NULL); | 732 | status = acpi_evaluate_object(func->handle, "_PS3", NULL, NULL); |
736 | if (ACPI_FAILURE(status)) { | 733 | if (ACPI_FAILURE(status)) { |
737 | warn("%s: _PS3 failed\n", __FUNCTION__); | 734 | warn("%s: _PS3 failed\n", __FUNCTION__); |
@@ -742,27 +739,6 @@ static int power_off_slot(struct acpiphp_slot *slot) | |||
742 | } | 739 | } |
743 | } | 740 | } |
744 | 741 | ||
745 | list_for_each (l, &slot->funcs) { | ||
746 | func = list_entry(l, struct acpiphp_func, sibling); | ||
747 | |||
748 | /* We don't want to call _EJ0 on non-existing functions. */ | ||
749 | if (func->pci_dev && (func->flags & FUNC_HAS_EJ0)) { | ||
750 | /* _EJ0 method take one argument */ | ||
751 | arg_list.count = 1; | ||
752 | arg_list.pointer = &arg; | ||
753 | arg.type = ACPI_TYPE_INTEGER; | ||
754 | arg.integer.value = 1; | ||
755 | |||
756 | status = acpi_evaluate_object(func->handle, "_EJ0", &arg_list, NULL); | ||
757 | if (ACPI_FAILURE(status)) { | ||
758 | warn("%s: _EJ0 failed\n", __FUNCTION__); | ||
759 | retval = -1; | ||
760 | goto err_exit; | ||
761 | } else | ||
762 | break; | ||
763 | } | ||
764 | } | ||
765 | |||
766 | /* TBD: evaluate _STA to check if the slot is disabled */ | 742 | /* TBD: evaluate _STA to check if the slot is disabled */ |
767 | 743 | ||
768 | slot->flags &= (~SLOT_POWEREDON); | 744 | slot->flags &= (~SLOT_POWEREDON); |
@@ -782,70 +758,56 @@ static int power_off_slot(struct acpiphp_slot *slot) | |||
782 | */ | 758 | */ |
783 | static int enable_device(struct acpiphp_slot *slot) | 759 | static int enable_device(struct acpiphp_slot *slot) |
784 | { | 760 | { |
785 | u8 bus; | ||
786 | struct pci_dev *dev; | 761 | struct pci_dev *dev; |
787 | struct pci_bus *child; | 762 | struct pci_bus *bus = slot->bridge->pci_bus; |
788 | struct list_head *l; | 763 | struct list_head *l; |
789 | struct acpiphp_func *func; | 764 | struct acpiphp_func *func; |
790 | int retval = 0; | 765 | int retval = 0; |
791 | int num; | 766 | int num, max, pass; |
792 | 767 | ||
793 | if (slot->flags & SLOT_ENABLED) | 768 | if (slot->flags & SLOT_ENABLED) |
794 | goto err_exit; | 769 | goto err_exit; |
795 | 770 | ||
796 | /* sanity check: dev should be NULL when hot-plugged in */ | 771 | /* sanity check: dev should be NULL when hot-plugged in */ |
797 | dev = pci_find_slot(slot->bridge->bus, PCI_DEVFN(slot->device, 0)); | 772 | dev = pci_get_slot(bus, PCI_DEVFN(slot->device, 0)); |
798 | if (dev) { | 773 | if (dev) { |
799 | /* This case shouldn't happen */ | 774 | /* This case shouldn't happen */ |
800 | err("pci_dev structure already exists.\n"); | 775 | err("pci_dev structure already exists.\n"); |
776 | pci_dev_put(dev); | ||
801 | retval = -1; | 777 | retval = -1; |
802 | goto err_exit; | 778 | goto err_exit; |
803 | } | 779 | } |
804 | 780 | ||
805 | /* allocate resources to device */ | 781 | num = pci_scan_slot(bus, PCI_DEVFN(slot->device, 0)); |
806 | retval = acpiphp_configure_slot(slot); | 782 | if (num == 0) { |
807 | if (retval) | ||
808 | goto err_exit; | ||
809 | |||
810 | /* returned `dev' is the *first function* only! */ | ||
811 | num = pci_scan_slot(slot->bridge->pci_bus, PCI_DEVFN(slot->device, 0)); | ||
812 | if (num) | ||
813 | pci_bus_add_devices(slot->bridge->pci_bus); | ||
814 | dev = pci_find_slot(slot->bridge->bus, PCI_DEVFN(slot->device, 0)); | ||
815 | |||
816 | if (!dev) { | ||
817 | err("No new device found\n"); | 783 | err("No new device found\n"); |
818 | retval = -1; | 784 | retval = -1; |
819 | goto err_exit; | 785 | goto err_exit; |
820 | } | 786 | } |
821 | 787 | ||
822 | if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) { | 788 | max = bus->secondary; |
823 | pci_read_config_byte(dev, PCI_SECONDARY_BUS, &bus); | 789 | for (pass = 0; pass < 2; pass++) { |
824 | child = (struct pci_bus*) pci_add_new_bus(dev->bus, dev, bus); | 790 | list_for_each_entry(dev, &bus->devices, bus_list) { |
825 | pci_do_scan_bus(child); | 791 | if (PCI_SLOT(dev->devfn) != slot->device) |
792 | continue; | ||
793 | if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE || | ||
794 | dev->hdr_type == PCI_HEADER_TYPE_CARDBUS) | ||
795 | max = pci_scan_bridge(bus, dev, max, pass); | ||
796 | } | ||
826 | } | 797 | } |
827 | 798 | ||
799 | pci_bus_assign_resources(bus); | ||
800 | pci_bus_add_devices(bus); | ||
801 | |||
828 | /* associate pci_dev to our representation */ | 802 | /* associate pci_dev to our representation */ |
829 | list_for_each (l, &slot->funcs) { | 803 | list_for_each (l, &slot->funcs) { |
830 | func = list_entry(l, struct acpiphp_func, sibling); | 804 | func = list_entry(l, struct acpiphp_func, sibling); |
831 | 805 | func->pci_dev = pci_get_slot(bus, PCI_DEVFN(slot->device, | |
832 | func->pci_dev = pci_find_slot(slot->bridge->bus, | ||
833 | PCI_DEVFN(slot->device, | ||
834 | func->function)); | 806 | func->function)); |
835 | if (!func->pci_dev) | ||
836 | continue; | ||
837 | |||
838 | /* configure device */ | ||
839 | retval = acpiphp_configure_function(func); | ||
840 | if (retval) | ||
841 | goto err_exit; | ||
842 | } | 807 | } |
843 | 808 | ||
844 | slot->flags |= SLOT_ENABLED; | 809 | slot->flags |= SLOT_ENABLED; |
845 | 810 | ||
846 | dbg("Available resources:\n"); | ||
847 | acpiphp_dump_resource(slot->bridge); | ||
848 | |||
849 | err_exit: | 811 | err_exit: |
850 | return retval; | 812 | return retval; |
851 | } | 813 | } |
@@ -866,9 +828,12 @@ static int disable_device(struct acpiphp_slot *slot) | |||
866 | 828 | ||
867 | list_for_each (l, &slot->funcs) { | 829 | list_for_each (l, &slot->funcs) { |
868 | func = list_entry(l, struct acpiphp_func, sibling); | 830 | func = list_entry(l, struct acpiphp_func, sibling); |
831 | if (!func->pci_dev) | ||
832 | continue; | ||
869 | 833 | ||
870 | if (func->pci_dev) | 834 | pci_remove_bus_device(func->pci_dev); |
871 | acpiphp_unconfigure_function(func); | 835 | pci_dev_put(func->pci_dev); |
836 | func->pci_dev = NULL; | ||
872 | } | 837 | } |
873 | 838 | ||
874 | slot->flags &= (~SLOT_ENABLED); | 839 | slot->flags &= (~SLOT_ENABLED); |
@@ -920,6 +885,39 @@ static unsigned int get_slot_status(struct acpiphp_slot *slot) | |||
920 | } | 885 | } |
921 | 886 | ||
922 | /** | 887 | /** |
888 | * acpiphp_eject_slot - physically eject the slot | ||
889 | */ | ||
890 | static int acpiphp_eject_slot(struct acpiphp_slot *slot) | ||
891 | { | ||
892 | acpi_status status; | ||
893 | struct acpiphp_func *func; | ||
894 | struct list_head *l; | ||
895 | struct acpi_object_list arg_list; | ||
896 | union acpi_object arg; | ||
897 | |||
898 | list_for_each (l, &slot->funcs) { | ||
899 | func = list_entry(l, struct acpiphp_func, sibling); | ||
900 | |||
901 | /* We don't want to call _EJ0 on non-existing functions. */ | ||
902 | if ((func->flags & FUNC_HAS_EJ0)) { | ||
903 | /* _EJ0 method take one argument */ | ||
904 | arg_list.count = 1; | ||
905 | arg_list.pointer = &arg; | ||
906 | arg.type = ACPI_TYPE_INTEGER; | ||
907 | arg.integer.value = 1; | ||
908 | |||
909 | status = acpi_evaluate_object(func->handle, "_EJ0", &arg_list, NULL); | ||
910 | if (ACPI_FAILURE(status)) { | ||
911 | warn("%s: _EJ0 failed\n", __FUNCTION__); | ||
912 | return -1; | ||
913 | } else | ||
914 | break; | ||
915 | } | ||
916 | } | ||
917 | return 0; | ||
918 | } | ||
919 | |||
920 | /** | ||
923 | * acpiphp_check_bridge - re-enumerate devices | 921 | * acpiphp_check_bridge - re-enumerate devices |
924 | * | 922 | * |
925 | * Iterate over all slots under this bridge and make sure that if a | 923 | * Iterate over all slots under this bridge and make sure that if a |
@@ -942,6 +940,8 @@ static int acpiphp_check_bridge(struct acpiphp_bridge *bridge) | |||
942 | if (retval) { | 940 | if (retval) { |
943 | err("Error occurred in disabling\n"); | 941 | err("Error occurred in disabling\n"); |
944 | goto err_exit; | 942 | goto err_exit; |
943 | } else { | ||
944 | acpiphp_eject_slot(slot); | ||
945 | } | 945 | } |
946 | disabled++; | 946 | disabled++; |
947 | } else { | 947 | } else { |
@@ -962,6 +962,144 @@ static int acpiphp_check_bridge(struct acpiphp_bridge *bridge) | |||
962 | return retval; | 962 | return retval; |
963 | } | 963 | } |
964 | 964 | ||
965 | static void program_hpp(struct pci_dev *dev, struct acpiphp_bridge *bridge) | ||
966 | { | ||
967 | u16 pci_cmd, pci_bctl; | ||
968 | struct pci_dev *cdev; | ||
969 | |||
970 | /* Program hpp values for this device */ | ||
971 | if (!(dev->hdr_type == PCI_HEADER_TYPE_NORMAL || | ||
972 | (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE && | ||
973 | (dev->class >> 8) == PCI_CLASS_BRIDGE_PCI))) | ||
974 | return; | ||
975 | pci_write_config_byte(dev, PCI_CACHE_LINE_SIZE, | ||
976 | bridge->hpp.cache_line_size); | ||
977 | pci_write_config_byte(dev, PCI_LATENCY_TIMER, | ||
978 | bridge->hpp.latency_timer); | ||
979 | pci_read_config_word(dev, PCI_COMMAND, &pci_cmd); | ||
980 | if (bridge->hpp.enable_SERR) | ||
981 | pci_cmd |= PCI_COMMAND_SERR; | ||
982 | else | ||
983 | pci_cmd &= ~PCI_COMMAND_SERR; | ||
984 | if (bridge->hpp.enable_PERR) | ||
985 | pci_cmd |= PCI_COMMAND_PARITY; | ||
986 | else | ||
987 | pci_cmd &= ~PCI_COMMAND_PARITY; | ||
988 | pci_write_config_word(dev, PCI_COMMAND, pci_cmd); | ||
989 | |||
990 | /* Program bridge control value and child devices */ | ||
991 | if ((dev->class >> 8) == PCI_CLASS_BRIDGE_PCI) { | ||
992 | pci_write_config_byte(dev, PCI_SEC_LATENCY_TIMER, | ||
993 | bridge->hpp.latency_timer); | ||
994 | pci_read_config_word(dev, PCI_BRIDGE_CONTROL, &pci_bctl); | ||
995 | if (bridge->hpp.enable_SERR) | ||
996 | pci_bctl |= PCI_BRIDGE_CTL_SERR; | ||
997 | else | ||
998 | pci_bctl &= ~PCI_BRIDGE_CTL_SERR; | ||
999 | if (bridge->hpp.enable_PERR) | ||
1000 | pci_bctl |= PCI_BRIDGE_CTL_PARITY; | ||
1001 | else | ||
1002 | pci_bctl &= ~PCI_BRIDGE_CTL_PARITY; | ||
1003 | pci_write_config_word(dev, PCI_BRIDGE_CONTROL, pci_bctl); | ||
1004 | if (dev->subordinate) { | ||
1005 | list_for_each_entry(cdev, &dev->subordinate->devices, | ||
1006 | bus_list) | ||
1007 | program_hpp(cdev, bridge); | ||
1008 | } | ||
1009 | } | ||
1010 | } | ||
1011 | |||
1012 | static void acpiphp_set_hpp_values(acpi_handle handle, struct pci_bus *bus) | ||
1013 | { | ||
1014 | struct acpiphp_bridge bridge; | ||
1015 | struct pci_dev *dev; | ||
1016 | |||
1017 | memset(&bridge, 0, sizeof(bridge)); | ||
1018 | bridge.handle = handle; | ||
1019 | decode_hpp(&bridge); | ||
1020 | list_for_each_entry(dev, &bus->devices, bus_list) | ||
1021 | program_hpp(dev, &bridge); | ||
1022 | |||
1023 | } | ||
1024 | |||
1025 | /* | ||
1026 | * Remove devices for which we could not assign resources, call | ||
1027 | * arch specific code to fix-up the bus | ||
1028 | */ | ||
1029 | static void acpiphp_sanitize_bus(struct pci_bus *bus) | ||
1030 | { | ||
1031 | struct pci_dev *dev; | ||
1032 | int i; | ||
1033 | unsigned long type_mask = IORESOURCE_IO | IORESOURCE_MEM; | ||
1034 | |||
1035 | list_for_each_entry(dev, &bus->devices, bus_list) { | ||
1036 | for (i=0; i<PCI_BRIDGE_RESOURCES; i++) { | ||
1037 | struct resource *res = &dev->resource[i]; | ||
1038 | if ((res->flags & type_mask) && !res->start && | ||
1039 | res->end) { | ||
1040 | /* Could not assign a required resources | ||
1041 | * for this device, remove it */ | ||
1042 | pci_remove_bus_device(dev); | ||
1043 | break; | ||
1044 | } | ||
1045 | } | ||
1046 | } | ||
1047 | } | ||
1048 | |||
1049 | /* Program resources in newly inserted bridge */ | ||
1050 | static int acpiphp_configure_bridge (acpi_handle handle) | ||
1051 | { | ||
1052 | struct acpi_pci_id pci_id; | ||
1053 | struct pci_bus *bus; | ||
1054 | |||
1055 | if (ACPI_FAILURE(acpi_get_pci_id(handle, &pci_id))) { | ||
1056 | err("cannot get PCI domain and bus number for bridge\n"); | ||
1057 | return -EINVAL; | ||
1058 | } | ||
1059 | bus = pci_find_bus(pci_id.segment, pci_id.bus); | ||
1060 | if (!bus) { | ||
1061 | err("cannot find bus %d:%d\n", | ||
1062 | pci_id.segment, pci_id.bus); | ||
1063 | return -EINVAL; | ||
1064 | } | ||
1065 | |||
1066 | pci_bus_size_bridges(bus); | ||
1067 | pci_bus_assign_resources(bus); | ||
1068 | acpiphp_sanitize_bus(bus); | ||
1069 | acpiphp_set_hpp_values(handle, bus); | ||
1070 | pci_enable_bridges(bus); | ||
1071 | acpiphp_configure_ioapics(handle); | ||
1072 | return 0; | ||
1073 | } | ||
1074 | |||
1075 | static void handle_bridge_insertion(acpi_handle handle, u32 type) | ||
1076 | { | ||
1077 | struct acpi_device *device, *pdevice; | ||
1078 | acpi_handle phandle; | ||
1079 | |||
1080 | if ((type != ACPI_NOTIFY_BUS_CHECK) && | ||
1081 | (type != ACPI_NOTIFY_DEVICE_CHECK)) { | ||
1082 | err("unexpected notification type %d\n", type); | ||
1083 | return; | ||
1084 | } | ||
1085 | |||
1086 | acpi_get_parent(handle, &phandle); | ||
1087 | if (acpi_bus_get_device(phandle, &pdevice)) { | ||
1088 | dbg("no parent device, assuming NULL\n"); | ||
1089 | pdevice = NULL; | ||
1090 | } | ||
1091 | if (acpi_bus_add(&device, pdevice, handle, ACPI_BUS_TYPE_DEVICE)) { | ||
1092 | err("cannot add bridge to acpi list\n"); | ||
1093 | return; | ||
1094 | } | ||
1095 | if (!acpiphp_configure_bridge(handle) && | ||
1096 | !acpi_bus_start(device)) | ||
1097 | add_bridge(handle); | ||
1098 | else | ||
1099 | err("cannot configure and start bridge\n"); | ||
1100 | |||
1101 | } | ||
1102 | |||
965 | /* | 1103 | /* |
966 | * ACPI event handlers | 1104 | * ACPI event handlers |
967 | */ | 1105 | */ |
@@ -982,8 +1120,19 @@ static void handle_hotplug_event_bridge(acpi_handle handle, u32 type, void *cont | |||
982 | char objname[64]; | 1120 | char objname[64]; |
983 | struct acpi_buffer buffer = { .length = sizeof(objname), | 1121 | struct acpi_buffer buffer = { .length = sizeof(objname), |
984 | .pointer = objname }; | 1122 | .pointer = objname }; |
1123 | struct acpi_device *device; | ||
985 | 1124 | ||
986 | bridge = (struct acpiphp_bridge *)context; | 1125 | if (acpi_bus_get_device(handle, &device)) { |
1126 | /* This bridge must have just been physically inserted */ | ||
1127 | handle_bridge_insertion(handle, type); | ||
1128 | return; | ||
1129 | } | ||
1130 | |||
1131 | bridge = acpiphp_handle_to_bridge(handle); | ||
1132 | if (!bridge) { | ||
1133 | err("cannot get bridge info\n"); | ||
1134 | return; | ||
1135 | } | ||
987 | 1136 | ||
988 | acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer); | 1137 | acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer); |
989 | 1138 | ||
@@ -1031,7 +1180,6 @@ static void handle_hotplug_event_bridge(acpi_handle handle, u32 type, void *cont | |||
1031 | } | 1180 | } |
1032 | } | 1181 | } |
1033 | 1182 | ||
1034 | |||
1035 | /** | 1183 | /** |
1036 | * handle_hotplug_event_func - handle ACPI event on functions (i.e. slots) | 1184 | * handle_hotplug_event_func - handle ACPI event on functions (i.e. slots) |
1037 | * | 1185 | * |
@@ -1074,7 +1222,8 @@ static void handle_hotplug_event_func(acpi_handle handle, u32 type, void *contex | |||
1074 | case ACPI_NOTIFY_EJECT_REQUEST: | 1222 | case ACPI_NOTIFY_EJECT_REQUEST: |
1075 | /* request device eject */ | 1223 | /* request device eject */ |
1076 | dbg("%s: Device eject notify on %s\n", __FUNCTION__, objname); | 1224 | dbg("%s: Device eject notify on %s\n", __FUNCTION__, objname); |
1077 | acpiphp_disable_slot(func->slot); | 1225 | if (!(acpiphp_disable_slot(func->slot))) |
1226 | acpiphp_eject_slot(func->slot); | ||
1078 | break; | 1227 | break; |
1079 | 1228 | ||
1080 | default: | 1229 | default: |
@@ -1083,6 +1232,47 @@ static void handle_hotplug_event_func(acpi_handle handle, u32 type, void *contex | |||
1083 | } | 1232 | } |
1084 | } | 1233 | } |
1085 | 1234 | ||
1235 | static int is_root_bridge(acpi_handle handle) | ||
1236 | { | ||
1237 | acpi_status status; | ||
1238 | struct acpi_device_info *info; | ||
1239 | struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL}; | ||
1240 | int i; | ||
1241 | |||
1242 | status = acpi_get_object_info(handle, &buffer); | ||
1243 | if (ACPI_SUCCESS(status)) { | ||
1244 | info = buffer.pointer; | ||
1245 | if ((info->valid & ACPI_VALID_HID) && | ||
1246 | !strcmp(PCI_ROOT_HID_STRING, | ||
1247 | info->hardware_id.value)) { | ||
1248 | acpi_os_free(buffer.pointer); | ||
1249 | return 1; | ||
1250 | } | ||
1251 | if (info->valid & ACPI_VALID_CID) { | ||
1252 | for (i=0; i < info->compatibility_id.count; i++) { | ||
1253 | if (!strcmp(PCI_ROOT_HID_STRING, | ||
1254 | info->compatibility_id.id[i].value)) { | ||
1255 | acpi_os_free(buffer.pointer); | ||
1256 | return 1; | ||
1257 | } | ||
1258 | } | ||
1259 | } | ||
1260 | } | ||
1261 | return 0; | ||
1262 | } | ||
1263 | |||
1264 | static acpi_status | ||
1265 | find_root_bridges(acpi_handle handle, u32 lvl, void *context, void **rv) | ||
1266 | { | ||
1267 | int *count = (int *)context; | ||
1268 | |||
1269 | if (is_root_bridge(handle)) { | ||
1270 | acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY, | ||
1271 | handle_hotplug_event_bridge, NULL); | ||
1272 | (*count)++; | ||
1273 | } | ||
1274 | return AE_OK ; | ||
1275 | } | ||
1086 | 1276 | ||
1087 | static struct acpi_pci_driver acpi_pci_hp_driver = { | 1277 | static struct acpi_pci_driver acpi_pci_hp_driver = { |
1088 | .add = add_bridge, | 1278 | .add = add_bridge, |
@@ -1095,15 +1285,15 @@ static struct acpi_pci_driver acpi_pci_hp_driver = { | |||
1095 | */ | 1285 | */ |
1096 | int __init acpiphp_glue_init(void) | 1286 | int __init acpiphp_glue_init(void) |
1097 | { | 1287 | { |
1098 | int num; | 1288 | int num = 0; |
1099 | |||
1100 | if (list_empty(&pci_root_buses)) | ||
1101 | return -1; | ||
1102 | 1289 | ||
1103 | num = acpi_pci_register_driver(&acpi_pci_hp_driver); | 1290 | acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, |
1291 | ACPI_UINT32_MAX, find_root_bridges, &num, NULL); | ||
1104 | 1292 | ||
1105 | if (num <= 0) | 1293 | if (num <= 0) |
1106 | return -1; | 1294 | return -1; |
1295 | else | ||
1296 | acpi_pci_register_driver(&acpi_pci_hp_driver); | ||
1107 | 1297 | ||
1108 | return 0; | 1298 | return 0; |
1109 | } | 1299 | } |
@@ -1116,46 +1306,6 @@ int __init acpiphp_glue_init(void) | |||
1116 | */ | 1306 | */ |
1117 | void __exit acpiphp_glue_exit(void) | 1307 | void __exit acpiphp_glue_exit(void) |
1118 | { | 1308 | { |
1119 | struct list_head *l1, *l2, *n1, *n2; | ||
1120 | struct acpiphp_bridge *bridge; | ||
1121 | struct acpiphp_slot *slot, *next; | ||
1122 | struct acpiphp_func *func; | ||
1123 | acpi_status status; | ||
1124 | |||
1125 | list_for_each_safe (l1, n1, &bridge_list) { | ||
1126 | bridge = (struct acpiphp_bridge *)l1; | ||
1127 | slot = bridge->slots; | ||
1128 | while (slot) { | ||
1129 | next = slot->next; | ||
1130 | list_for_each_safe (l2, n2, &slot->funcs) { | ||
1131 | func = list_entry(l2, struct acpiphp_func, sibling); | ||
1132 | acpiphp_free_resource(&func->io_head); | ||
1133 | acpiphp_free_resource(&func->mem_head); | ||
1134 | acpiphp_free_resource(&func->p_mem_head); | ||
1135 | acpiphp_free_resource(&func->bus_head); | ||
1136 | status = acpi_remove_notify_handler(func->handle, | ||
1137 | ACPI_SYSTEM_NOTIFY, | ||
1138 | handle_hotplug_event_func); | ||
1139 | if (ACPI_FAILURE(status)) | ||
1140 | err("failed to remove notify handler\n"); | ||
1141 | kfree(func); | ||
1142 | } | ||
1143 | kfree(slot); | ||
1144 | slot = next; | ||
1145 | } | ||
1146 | status = acpi_remove_notify_handler(bridge->handle, ACPI_SYSTEM_NOTIFY, | ||
1147 | handle_hotplug_event_bridge); | ||
1148 | if (ACPI_FAILURE(status)) | ||
1149 | err("failed to remove notify handler\n"); | ||
1150 | |||
1151 | acpiphp_free_resource(&bridge->io_head); | ||
1152 | acpiphp_free_resource(&bridge->mem_head); | ||
1153 | acpiphp_free_resource(&bridge->p_mem_head); | ||
1154 | acpiphp_free_resource(&bridge->bus_head); | ||
1155 | |||
1156 | kfree(bridge); | ||
1157 | } | ||
1158 | |||
1159 | acpi_pci_unregister_driver(&acpi_pci_hp_driver); | 1309 | acpi_pci_unregister_driver(&acpi_pci_hp_driver); |
1160 | } | 1310 | } |
1161 | 1311 | ||
@@ -1173,11 +1323,14 @@ int __init acpiphp_get_num_slots(void) | |||
1173 | 1323 | ||
1174 | list_for_each (node, &bridge_list) { | 1324 | list_for_each (node, &bridge_list) { |
1175 | bridge = (struct acpiphp_bridge *)node; | 1325 | bridge = (struct acpiphp_bridge *)node; |
1176 | dbg("Bus%d %dslot(s)\n", bridge->bus, bridge->nr_slots); | 1326 | dbg("Bus %04x:%02x has %d slot%s\n", |
1327 | pci_domain_nr(bridge->pci_bus), | ||
1328 | bridge->pci_bus->number, bridge->nr_slots, | ||
1329 | bridge->nr_slots == 1 ? "" : "s"); | ||
1177 | num_slots += bridge->nr_slots; | 1330 | num_slots += bridge->nr_slots; |
1178 | } | 1331 | } |
1179 | 1332 | ||
1180 | dbg("Total %dslots\n", num_slots); | 1333 | dbg("Total %d slots\n", num_slots); |
1181 | return num_slots; | 1334 | return num_slots; |
1182 | } | 1335 | } |
1183 | 1336 | ||
@@ -1254,7 +1407,6 @@ int acpiphp_enable_slot(struct acpiphp_slot *slot) | |||
1254 | return retval; | 1407 | return retval; |
1255 | } | 1408 | } |
1256 | 1409 | ||
1257 | |||
1258 | /** | 1410 | /** |
1259 | * acpiphp_disable_slot - power off slot | 1411 | * acpiphp_disable_slot - power off slot |
1260 | */ | 1412 | */ |
@@ -1274,13 +1426,6 @@ int acpiphp_disable_slot(struct acpiphp_slot *slot) | |||
1274 | if (retval) | 1426 | if (retval) |
1275 | goto err_exit; | 1427 | goto err_exit; |
1276 | 1428 | ||
1277 | acpiphp_resource_sort_and_combine(&slot->bridge->io_head); | ||
1278 | acpiphp_resource_sort_and_combine(&slot->bridge->mem_head); | ||
1279 | acpiphp_resource_sort_and_combine(&slot->bridge->p_mem_head); | ||
1280 | acpiphp_resource_sort_and_combine(&slot->bridge->bus_head); | ||
1281 | dbg("Available resources:\n"); | ||
1282 | acpiphp_dump_resource(slot->bridge); | ||
1283 | |||
1284 | err_exit: | 1429 | err_exit: |
1285 | up(&slot->crit_sect); | 1430 | up(&slot->crit_sect); |
1286 | return retval; | 1431 | return retval; |
@@ -1293,11 +1438,7 @@ int acpiphp_disable_slot(struct acpiphp_slot *slot) | |||
1293 | */ | 1438 | */ |
1294 | u8 acpiphp_get_power_status(struct acpiphp_slot *slot) | 1439 | u8 acpiphp_get_power_status(struct acpiphp_slot *slot) |
1295 | { | 1440 | { |
1296 | unsigned int sta; | 1441 | return (slot->flags & SLOT_POWEREDON); |
1297 | |||
1298 | sta = get_slot_status(slot); | ||
1299 | |||
1300 | return (sta & ACPI_STA_ENABLED) ? 1 : 0; | ||
1301 | } | 1442 | } |
1302 | 1443 | ||
1303 | 1444 | ||
@@ -1335,9 +1476,10 @@ u8 acpiphp_get_adapter_status(struct acpiphp_slot *slot) | |||
1335 | u32 acpiphp_get_address(struct acpiphp_slot *slot) | 1476 | u32 acpiphp_get_address(struct acpiphp_slot *slot) |
1336 | { | 1477 | { |
1337 | u32 address; | 1478 | u32 address; |
1479 | struct pci_bus *pci_bus = slot->bridge->pci_bus; | ||
1338 | 1480 | ||
1339 | address = ((slot->bridge->seg) << 16) | | 1481 | address = (pci_domain_nr(pci_bus) << 16) | |
1340 | ((slot->bridge->bus) << 8) | | 1482 | (pci_bus->number << 8) | |
1341 | slot->device; | 1483 | slot->device; |
1342 | 1484 | ||
1343 | return address; | 1485 | return address; |