2 * SHPCHPRM ACPI: PHP Resource Manager for ACPI platform
4 * Copyright (C) 2003-2004 Intel Corporation
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or (at
11 * your option) any later version.
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
16 * NON INFRINGEMENT. See the GNU General Public License for more
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., 675 Mass Ave, Cambridge, MA 02139, USA.
23 * Send feedback to <dely.l.sy@intel.com>
27 #include <linux/config.h>
28 #include <linux/module.h>
29 #include <linux/kernel.h>
30 #include <linux/types.h>
31 #include <linux/pci.h>
32 #include <linux/init.h>
33 #include <linux/acpi.h>
34 #include <linux/efi.h>
35 #include <asm/uaccess.h>
36 #include <asm/system.h>
38 #include <asm/iosapic.h>
40 #include <acpi/acpi.h>
41 #include <acpi/acpi_bus.h>
42 #include <acpi/actypes.h>
46 #define PCI_MAX_BUS 0x100
47 #define ACPI_STA_DEVICE_PRESENT 0x01
49 #define METHOD_NAME__SUN "_SUN"
50 #define METHOD_NAME__HPP "_HPP"
51 #define METHOD_NAME_OSHP "OSHP"
53 #define PHP_RES_BUS 0xA0
54 #define PHP_RES_IO 0xA1
55 #define PHP_RES_MEM 0xA2
56 #define PHP_RES_PMEM 0xA3
58 #define BRIDGE_TYPE_P2P 0x00
59 #define BRIDGE_TYPE_HOST 0x01
61 /* this should go to drivers/acpi/include/ */
69 struct acpi_php_slot {
70 struct acpi_php_slot *next;
71 struct acpi_bridge *bridge;
78 struct pci_resource *mem_head;
79 struct pci_resource *p_mem_head;
80 struct pci_resource *io_head;
81 struct pci_resource *bus_head;
82 void *slot_ops; /* _STA, _EJx, etc */
87 struct acpi_bridge *parent;
88 struct acpi_bridge *next;
89 struct acpi_bridge *child;
92 int pbus; /* pdev->bus->number */
93 int pdevice; /* PCI_SLOT(pdev->devfn) */
94 int pfunction; /* PCI_DEVFN(pdev->devfn) */
95 int bus; /* pdev->subordinate->number */
96 struct acpi__hpp *_hpp;
97 struct acpi_php_slot *slots;
98 struct pci_resource *tmem_head; /* total from crs */
99 struct pci_resource *tp_mem_head; /* total from crs */
100 struct pci_resource *tio_head; /* total from crs */
101 struct pci_resource *tbus_head; /* total from crs */
102 struct pci_resource *mem_head; /* available */
103 struct pci_resource *p_mem_head; /* available */
104 struct pci_resource *io_head; /* available */
105 struct pci_resource *bus_head; /* available */
110 static struct acpi_bridge *acpi_bridges_head;
112 static u8 * acpi_path_name( acpi_handle handle)
115 static u8 path_name[ACPI_PATHNAME_MAX];
116 struct acpi_buffer ret_buf = { ACPI_PATHNAME_MAX, path_name };
118 memset(path_name, 0, sizeof (path_name));
119 status = acpi_get_name(handle, ACPI_FULL_PATHNAME, &ret_buf);
121 if (ACPI_FAILURE(status))
127 static void acpi_get__hpp ( struct acpi_bridge *ab);
128 static void acpi_run_oshp ( struct acpi_bridge *ab);
130 static int acpi_add_slot_to_php_slots(
131 struct acpi_bridge *ab,
138 struct acpi_php_slot *aps;
139 static long samesun = -1;
141 aps = (struct acpi_php_slot *) kmalloc (sizeof(struct acpi_php_slot), GFP_KERNEL);
143 err ("acpi_shpchprm: alloc for aps fail\n");
146 memset(aps, 0, sizeof(struct acpi_php_slot));
148 aps->handle = handle;
150 aps->dev = (adr >> 16) & 0xffff;
151 aps->fun = adr & 0xffff;
154 aps->next = ab->slots; /* cling to the bridge */
164 if (sun != samesun) {
165 info("acpi_shpchprm: Slot sun(%x) at s:b:d:f=0x%02x:%02x:%02x:%02x\n", aps->sun, ab->seg,
166 aps->bus, aps->dev, aps->fun);
172 static void acpi_get__hpp ( struct acpi_bridge *ab)
176 struct acpi_buffer ret_buf = { 0, NULL};
177 union acpi_object *ext_obj, *package;
178 u8 *path_name = acpi_path_name(ab->handle);
182 status = acpi_evaluate_object(ab->handle, METHOD_NAME__HPP, NULL, &ret_buf);
184 case AE_BUFFER_OVERFLOW:
185 ret_buf.pointer = kmalloc (ret_buf.length, GFP_KERNEL);
186 if (!ret_buf.pointer) {
187 err ("acpi_shpchprm:%s alloc for _HPP fail\n", path_name);
190 status = acpi_evaluate_object(ab->handle, METHOD_NAME__HPP, NULL, &ret_buf);
191 if (ACPI_SUCCESS(status))
194 if (ACPI_FAILURE(status)) {
195 err("acpi_shpchprm:%s _HPP fail=0x%x\n", path_name, status);
200 ext_obj = (union acpi_object *) ret_buf.pointer;
201 if (ext_obj->type != ACPI_TYPE_PACKAGE) {
202 err ("acpi_shpchprm:%s _HPP obj not a package\n", path_name);
203 goto free_and_return;
206 len = ext_obj->package.count;
207 package = (union acpi_object *) ret_buf.pointer;
208 for ( i = 0; (i < len) || (i < 4); i++) {
209 ext_obj = (union acpi_object *) &package->package.elements[i];
210 switch (ext_obj->type) {
211 case ACPI_TYPE_INTEGER:
212 nui[i] = (u8)ext_obj->integer.value;
215 err ("acpi_shpchprm:%s _HPP obj type incorrect\n", path_name);
216 goto free_and_return;
220 ab->_hpp = kmalloc (sizeof (struct acpi__hpp), GFP_KERNEL);
221 memset(ab->_hpp, 0, sizeof(struct acpi__hpp));
223 ab->_hpp->cache_line_size = nui[0];
224 ab->_hpp->latency_timer = nui[1];
225 ab->_hpp->enable_serr = nui[2];
226 ab->_hpp->enable_perr = nui[3];
228 dbg(" _HPP: cache_line_size=0x%x\n", ab->_hpp->cache_line_size);
229 dbg(" _HPP: latency timer =0x%x\n", ab->_hpp->latency_timer);
230 dbg(" _HPP: enable SERR =0x%x\n", ab->_hpp->enable_serr);
231 dbg(" _HPP: enable PERR =0x%x\n", ab->_hpp->enable_perr);
234 kfree(ret_buf.pointer);
237 static void acpi_run_oshp ( struct acpi_bridge *ab)
240 u8 *path_name = acpi_path_name(ab->handle);
241 struct acpi_buffer ret_buf = { 0, NULL};
244 status = acpi_evaluate_object(ab->handle, METHOD_NAME_OSHP, NULL, &ret_buf);
245 if (ACPI_FAILURE(status)) {
246 err("acpi_pciehprm:%s OSHP fails=0x%x\n", path_name, status);
248 dbg("acpi_pciehprm:%s OSHP passes =0x%x\n", path_name, status);
252 static acpi_status acpi_evaluate_crs(
254 struct acpi_resource **retbuf
258 struct acpi_buffer crsbuf;
259 u8 *path_name = acpi_path_name(handle);
262 crsbuf.pointer = NULL;
264 status = acpi_get_current_resources (handle, &crsbuf);
267 case AE_BUFFER_OVERFLOW:
270 dbg("acpi_shpchprm:%s _CRS not found\n", path_name);
273 err ("acpi_shpchprm:%s _CRS fail=0x%x\n", path_name, status);
277 crsbuf.pointer = kmalloc (crsbuf.length, GFP_KERNEL);
278 if (!crsbuf.pointer) {
279 err ("acpi_shpchprm: alloc %ld bytes for %s _CRS fail\n", (ulong)crsbuf.length, path_name);
283 status = acpi_get_current_resources (handle, &crsbuf);
284 if (ACPI_FAILURE(status)) {
285 err("acpi_shpchprm: %s _CRS fail=0x%x.\n", path_name, status);
286 kfree(crsbuf.pointer);
290 *retbuf = crsbuf.pointer;
295 static void free_pci_resource ( struct pci_resource *aprh)
297 struct pci_resource *res, *next;
299 for (res = aprh; res; res = next) {
305 static void print_pci_resource ( struct pci_resource *aprh)
307 struct pci_resource *res;
309 for (res = aprh; res; res = res->next)
310 dbg(" base= 0x%x length= 0x%x\n", res->base, res->length);
313 static void print_slot_resources( struct acpi_php_slot *aps)
316 dbg(" BUS Resources:\n");
317 print_pci_resource (aps->bus_head);
321 dbg(" IO Resources:\n");
322 print_pci_resource (aps->io_head);
326 dbg(" MEM Resources:\n");
327 print_pci_resource (aps->mem_head);
330 if (aps->p_mem_head) {
331 dbg(" PMEM Resources:\n");
332 print_pci_resource (aps->p_mem_head);
336 static void print_pci_resources( struct acpi_bridge *ab)
339 dbg(" Total BUS Resources:\n");
340 print_pci_resource (ab->tbus_head);
343 dbg(" BUS Resources:\n");
344 print_pci_resource (ab->bus_head);
348 dbg(" Total IO Resources:\n");
349 print_pci_resource (ab->tio_head);
352 dbg(" IO Resources:\n");
353 print_pci_resource (ab->io_head);
357 dbg(" Total MEM Resources:\n");
358 print_pci_resource (ab->tmem_head);
361 dbg(" MEM Resources:\n");
362 print_pci_resource (ab->mem_head);
365 if (ab->tp_mem_head) {
366 dbg(" Total PMEM Resources:\n");
367 print_pci_resource (ab->tp_mem_head);
369 if (ab->p_mem_head) {
370 dbg(" PMEM Resources:\n");
371 print_pci_resource (ab->p_mem_head);
374 dbg(" _HPP: cache_line_size=0x%x\n", ab->_hpp->cache_line_size);
375 dbg(" _HPP: latency timer =0x%x\n", ab->_hpp->latency_timer);
376 dbg(" _HPP: enable SERR =0x%x\n", ab->_hpp->enable_serr);
377 dbg(" _HPP: enable PERR =0x%x\n", ab->_hpp->enable_perr);
381 static int shpchprm_delete_resource(
382 struct pci_resource **aprh,
386 struct pci_resource *res;
387 struct pci_resource *prevnode;
388 struct pci_resource *split_node;
391 shpchp_resource_sort_and_combine(aprh);
393 for (res = *aprh; res; res = res->next) {
394 if (res->base > base)
397 if ((res->base + res->length) < (base + size))
400 if (res->base < base) {
403 if ((res->length - (tbase - res->base)) < size)
406 split_node = (struct pci_resource *) kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
410 split_node->base = res->base;
411 split_node->length = tbase - res->base;
413 res->length -= split_node->length;
415 split_node->next = res->next;
416 res->next = split_node;
419 if (res->length >= size) {
420 split_node = (struct pci_resource*) kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
424 split_node->base = res->base + size;
425 split_node->length = res->length - size;
428 split_node->next = res->next;
429 res->next = split_node;
436 while (prevnode->next != res)
437 prevnode = prevnode->next;
439 prevnode->next = res->next;
449 static int shpchprm_delete_resources(
450 struct pci_resource **aprh,
451 struct pci_resource *this
454 struct pci_resource *res;
456 for (res = this; res; res = res->next)
457 shpchprm_delete_resource(aprh, res->base, res->length);
462 static int shpchprm_add_resource(
463 struct pci_resource **aprh,
467 struct pci_resource *res;
469 for (res = *aprh; res; res = res->next) {
470 if ((res->base + res->length) == base) {
475 if (res->next == *aprh)
480 res = kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
482 err ("acpi_shpchprm: alloc for res fail\n");
485 memset(res, 0, sizeof (struct pci_resource));
496 static int shpchprm_add_resources(
497 struct pci_resource **aprh,
498 struct pci_resource *this
501 struct pci_resource *res;
504 for (res = this; res && !rc; res = res->next)
505 rc = shpchprm_add_resource(aprh, res->base, res->length);
510 static void acpi_parse_io (
511 struct acpi_bridge *ab,
512 union acpi_resource_data *data
515 struct acpi_resource_io *dataio;
516 dataio = (struct acpi_resource_io *) data;
518 dbg("Io Resource\n");
519 dbg(" %d bit decode\n", ACPI_DECODE_16 == dataio->io_decode ? 16:10);
520 dbg(" Range minimum base: %08X\n", dataio->min_base_address);
521 dbg(" Range maximum base: %08X\n", dataio->max_base_address);
522 dbg(" Alignment: %08X\n", dataio->alignment);
523 dbg(" Range Length: %08X\n", dataio->range_length);
526 static void acpi_parse_fixed_io (
527 struct acpi_bridge *ab,
528 union acpi_resource_data *data
531 struct acpi_resource_fixed_io *datafio;
532 datafio = (struct acpi_resource_fixed_io *) data;
534 dbg("Fixed Io Resource\n");
535 dbg(" Range base address: %08X", datafio->base_address);
536 dbg(" Range length: %08X", datafio->range_length);
539 static void acpi_parse_address16_32 (
540 struct acpi_bridge *ab,
541 union acpi_resource_data *data,
542 acpi_resource_type id
546 * acpi_resource_address16 == acpi_resource_address32
547 * acpi_resource_address16 *data16 = (acpi_resource_address16 *) data;
549 struct acpi_resource_address32 *data32 = (struct acpi_resource_address32 *) data;
550 struct pci_resource **aprh, **tprh;
552 if (id == ACPI_RSTYPE_ADDRESS16)
553 dbg("acpi_shpchprm:16-Bit Address Space Resource\n");
555 dbg("acpi_shpchprm:32-Bit Address Space Resource\n");
557 switch (data32->resource_type) {
558 case ACPI_MEMORY_RANGE:
559 dbg(" Resource Type: Memory Range\n");
560 aprh = &ab->mem_head;
561 tprh = &ab->tmem_head;
563 switch (data32->attribute.memory.cache_attribute) {
564 case ACPI_NON_CACHEABLE_MEMORY:
565 dbg(" Type Specific: Noncacheable memory\n");
567 case ACPI_CACHABLE_MEMORY:
568 dbg(" Type Specific: Cacheable memory\n");
570 case ACPI_WRITE_COMBINING_MEMORY:
571 dbg(" Type Specific: Write-combining memory\n");
573 case ACPI_PREFETCHABLE_MEMORY:
574 aprh = &ab->p_mem_head;
575 dbg(" Type Specific: Prefetchable memory\n");
578 dbg(" Type Specific: Invalid cache attribute\n");
582 dbg(" Type Specific: Read%s\n", ACPI_READ_WRITE_MEMORY == data32->attribute.memory.read_write_attribute ? "/Write":" Only");
586 dbg(" Resource Type: I/O Range\n");
588 tprh = &ab->tio_head;
590 switch (data32->attribute.io.range_attribute) {
591 case ACPI_NON_ISA_ONLY_RANGES:
592 dbg(" Type Specific: Non-ISA Io Addresses\n");
594 case ACPI_ISA_ONLY_RANGES:
595 dbg(" Type Specific: ISA Io Addresses\n");
597 case ACPI_ENTIRE_RANGE:
598 dbg(" Type Specific: ISA and non-ISA Io Addresses\n");
601 dbg(" Type Specific: Invalid range attribute\n");
606 case ACPI_BUS_NUMBER_RANGE:
607 dbg(" Resource Type: Bus Number Range(fixed)\n");
608 /* fixup to be compatible with the rest of php driver */
609 data32->min_address_range++;
610 data32->address_length--;
611 aprh = &ab->bus_head;
612 tprh = &ab->tbus_head;
615 dbg(" Resource Type: Invalid resource type. Exiting.\n");
619 dbg(" Resource %s\n", ACPI_CONSUMER == data32->producer_consumer ? "Consumer":"Producer");
620 dbg(" %s decode\n", ACPI_SUB_DECODE == data32->decode ? "Subtractive":"Positive");
621 dbg(" Min address is %s fixed\n", ACPI_ADDRESS_FIXED == data32->min_address_fixed ? "":"not");
622 dbg(" Max address is %s fixed\n", ACPI_ADDRESS_FIXED == data32->max_address_fixed ? "":"not");
623 dbg(" Granularity: %08X\n", data32->granularity);
624 dbg(" Address range min: %08X\n", data32->min_address_range);
625 dbg(" Address range max: %08X\n", data32->max_address_range);
626 dbg(" Address translation offset: %08X\n", data32->address_translation_offset);
627 dbg(" Address Length: %08X\n", data32->address_length);
629 if (0xFF != data32->resource_source.index) {
630 dbg(" Resource Source Index: %X\n", data32->resource_source.index);
631 /* dbg(" Resource Source: %s\n", data32->resource_source.string_ptr); */
634 shpchprm_add_resource(aprh, data32->min_address_range, data32->address_length);
637 static acpi_status acpi_parse_crs(
638 struct acpi_bridge *ab,
639 struct acpi_resource *crsbuf
642 acpi_status status = AE_OK;
643 struct acpi_resource *resource = crsbuf;
648 dbg("acpi_shpchprm: PCI bus 0x%x Resource structure %x.\n", ab->bus, count++);
649 switch (resource->id) {
650 case ACPI_RSTYPE_IRQ:
651 dbg("Irq -------- Resource\n");
653 case ACPI_RSTYPE_DMA:
654 dbg("DMA -------- Resource\n");
656 case ACPI_RSTYPE_START_DPF:
657 dbg("Start DPF -------- Resource\n");
659 case ACPI_RSTYPE_END_DPF:
660 dbg("End DPF -------- Resource\n");
663 acpi_parse_io (ab, &resource->data);
665 case ACPI_RSTYPE_FIXED_IO:
666 acpi_parse_fixed_io (ab, &resource->data);
668 case ACPI_RSTYPE_VENDOR:
669 dbg("Vendor -------- Resource\n");
671 case ACPI_RSTYPE_END_TAG:
672 dbg("End_tag -------- Resource\n");
675 case ACPI_RSTYPE_MEM24:
676 dbg("Mem24 -------- Resource\n");
678 case ACPI_RSTYPE_MEM32:
679 dbg("Mem32 -------- Resource\n");
681 case ACPI_RSTYPE_FIXED_MEM32:
682 dbg("Fixed Mem32 -------- Resource\n");
684 case ACPI_RSTYPE_ADDRESS16:
685 acpi_parse_address16_32(ab, &resource->data, ACPI_RSTYPE_ADDRESS16);
687 case ACPI_RSTYPE_ADDRESS32:
688 acpi_parse_address16_32(ab, &resource->data, ACPI_RSTYPE_ADDRESS32);
690 case ACPI_RSTYPE_ADDRESS64:
691 info("Address64 -------- Resource unparsed\n");
693 case ACPI_RSTYPE_EXT_IRQ:
694 dbg("Ext Irq -------- Resource\n");
697 dbg("Invalid -------- resource type 0x%x\n", resource->id);
701 resource = (struct acpi_resource *) ((char *)resource + resource->length);
707 static acpi_status acpi_get_crs( struct acpi_bridge *ab)
710 struct acpi_resource *crsbuf;
712 status = acpi_evaluate_crs(ab->handle, &crsbuf);
713 if (ACPI_SUCCESS(status)) {
714 status = acpi_parse_crs(ab, crsbuf);
717 shpchp_resource_sort_and_combine(&ab->bus_head);
718 shpchp_resource_sort_and_combine(&ab->io_head);
719 shpchp_resource_sort_and_combine(&ab->mem_head);
720 shpchp_resource_sort_and_combine(&ab->p_mem_head);
722 shpchprm_add_resources (&ab->tbus_head, ab->bus_head);
723 shpchprm_add_resources (&ab->tio_head, ab->io_head);
724 shpchprm_add_resources (&ab->tmem_head, ab->mem_head);
725 shpchprm_add_resources (&ab->tp_mem_head, ab->p_mem_head);
731 /* find acpi_bridge downword from ab. */
732 static struct acpi_bridge *
733 find_acpi_bridge_by_bus(
734 struct acpi_bridge *ab,
736 int bus /* pdev->subordinate->number */
739 struct acpi_bridge *lab = NULL;
744 if ((ab->bus == bus) && (ab->seg == seg))
748 lab = find_acpi_bridge_by_bus(ab->child, seg, bus);
752 lab = find_acpi_bridge_by_bus(ab->next, seg, bus);
758 * Build a device tree of ACPI PCI Bridges
760 static void shpchprm_acpi_register_a_bridge (
761 struct acpi_bridge **head,
762 struct acpi_bridge *pab, /* parent bridge to which child bridge is added */
763 struct acpi_bridge *cab /* child bridge to add */
766 struct acpi_bridge *lpab;
767 struct acpi_bridge *lcab;
769 lpab = find_acpi_bridge_by_bus(*head, pab->seg, pab->bus);
771 if (!(pab->type & BRIDGE_TYPE_HOST))
772 warn("PCI parent bridge s:b(%x:%x) not in list.\n", pab->seg, pab->bus);
778 if ((cab->type & BRIDGE_TYPE_HOST) && (pab == cab))
781 lcab = find_acpi_bridge_by_bus(*head, cab->seg, cab->bus);
783 if ((pab->bus != lcab->parent->bus) || (lcab->bus != cab->bus))
784 err("PCI child bridge s:b(%x:%x) in list with diff parent.\n", cab->seg, cab->bus);
790 lcab->next = lpab->child;
794 static acpi_status shpchprm_acpi_build_php_slots_callback(
805 acpi_handle phandle = NULL;
806 struct acpi_bridge *pab = (struct acpi_bridge *)context;
807 struct acpi_bridge *lab;
809 u8 *path_name = acpi_path_name(handle);
812 status = acpi_evaluate_integer(handle, METHOD_NAME__SUN, NULL, &sun);
817 if (ACPI_FAILURE(status)) {
818 err("acpi_shpchprm:%s _SUN fail=0x%x\n", path_name, status);
823 /* get _ADR. _ADR must exist if _SUN exists */
824 status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL, &adr);
825 if (ACPI_FAILURE(status)) {
826 err("acpi_shpchprm:%s _ADR fail=0x%x\n", path_name, status);
830 dbg("acpi_shpchprm:%s sun=0x%08x adr=0x%08x\n", path_name, (u32)sun, (u32)adr);
832 status = acpi_get_parent(handle, &phandle);
833 if (ACPI_FAILURE(status)) {
834 err("acpi_shpchprm:%s get_parent fail=0x%x\n", path_name, status);
841 if (pab->bus == bus_num) {
844 dbg("WARN: pab is not parent\n");
845 lab = find_acpi_bridge_by_bus(pab, seg_num, bus_num);
847 dbg("acpi_shpchprm: alloc new P2P bridge(%x) for sun(%08x)\n", (u32)bus_num, (u32)sun);
848 lab = (struct acpi_bridge *)kmalloc(sizeof(struct acpi_bridge), GFP_KERNEL);
850 err("acpi_shpchprm: alloc for ab fail\n");
853 memset(lab, 0, sizeof(struct acpi_bridge));
855 lab->handle = phandle;
856 lab->pbus = pab->bus;
857 lab->pdevice = (int)(padr >> 16) & 0xffff;
858 lab->pfunction = (int)(padr & 0xffff);
859 lab->bus = (int)bus_num;
861 lab->type = BRIDGE_TYPE_P2P;
863 shpchprm_acpi_register_a_bridge (&acpi_bridges_head, pab, lab);
865 dbg("acpi_shpchprm: found P2P bridge(%x) for sun(%08x)\n", (u32)bus_num, (u32)sun);
868 acpi_add_slot_to_php_slots(lab, (int)bus_num, handle, (u32)adr, (u32)sun);
872 static int shpchprm_acpi_build_php_slots(
873 struct acpi_bridge *ab,
878 u8 *path_name = acpi_path_name(ab->handle);
880 /* Walk down this pci bridge to get _SUNs if any behind P2P */
881 status = acpi_walk_namespace ( ACPI_TYPE_DEVICE,
884 shpchprm_acpi_build_php_slots_callback,
887 if (ACPI_FAILURE(status)) {
888 dbg("acpi_shpchprm:%s walk for _SUN on pci bridge seg:bus(%x:%x) fail=0x%x\n", path_name, ab->seg, ab->bus, status);
895 static void build_a_bridge(
896 struct acpi_bridge *pab,
897 struct acpi_bridge *ab
900 u8 *path_name = acpi_path_name(ab->handle);
902 shpchprm_acpi_register_a_bridge (&acpi_bridges_head, pab, ab);
905 case BRIDGE_TYPE_HOST:
906 dbg("acpi_shpchprm: Registered PCI HOST Bridge(%02x) on s:b:d:f(%02x:%02x:%02x:%02x) [%s]\n",
907 ab->bus, ab->seg, ab->pbus, ab->pdevice, ab->pfunction, path_name);
909 case BRIDGE_TYPE_P2P:
910 dbg("acpi_shpchprm: Registered PCI P2P Bridge(%02x-%02x) on s:b:d:f(%02x:%02x:%02x:%02x) [%s]\n",
911 ab->pbus, ab->bus, ab->seg, ab->pbus, ab->pdevice, ab->pfunction, path_name);
915 /* build any immediate PHP slots under this pci bridge */
916 shpchprm_acpi_build_php_slots(ab, 1);
919 static struct acpi_bridge * add_p2p_bridge(
921 struct acpi_bridge *pab, /* parent */
925 struct acpi_bridge *ab;
926 struct pci_dev *pdev;
927 ulong devnum, funcnum;
928 u8 *path_name = acpi_path_name(handle);
930 ab = (struct acpi_bridge *) kmalloc (sizeof(struct acpi_bridge), GFP_KERNEL);
932 err("acpi_shpchprm: alloc for ab fail\n");
935 memset(ab, 0, sizeof(struct acpi_bridge));
937 devnum = (adr >> 16) & 0xffff;
938 funcnum = adr & 0xffff;
940 pdev = pci_find_slot(pab->bus, PCI_DEVFN(devnum, funcnum));
941 if (!pdev || !pdev->subordinate) {
942 err("acpi_shpchprm:%s is not a P2P Bridge\n", path_name);
949 ab->pbus = pab->bus; /* or pdev->bus->number */
950 ab->pdevice = devnum; /* or PCI_SLOT(pdev->devfn) */
951 ab->pfunction = funcnum; /* or PCI_FUNC(pdev->devfn) */
952 ab->bus = pdev->subordinate->number;
954 ab->type = BRIDGE_TYPE_P2P;
956 dbg("acpi_shpchprm: P2P(%x-%x) on pci=b:d:f(%x:%x:%x) acpi=b:d:f(%x:%x:%x) [%s]\n",
957 pab->bus, ab->bus, pdev->bus->number, PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn),
958 pab->bus, (u32)devnum, (u32)funcnum, path_name);
960 build_a_bridge(pab, ab);
965 static acpi_status scan_p2p_bridge(
972 struct acpi_bridge *pab = (struct acpi_bridge *)context;
973 struct acpi_bridge *ab;
976 u8 *path_name = acpi_path_name(handle);
977 ulong devnum, funcnum;
978 struct pci_dev *pdev;
980 /* get device, function */
981 status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL, &adr);
982 if (ACPI_FAILURE(status)) {
983 if (status != AE_NOT_FOUND)
984 err("acpi_shpchprm:%s _ADR fail=0x%x\n", path_name, status);
988 devnum = (adr >> 16) & 0xffff;
989 funcnum = adr & 0xffff;
991 pdev = pci_find_slot(pab->bus, PCI_DEVFN(devnum, funcnum));
994 if (!pdev->subordinate)
997 ab = add_p2p_bridge(handle, pab, adr);
999 status = acpi_walk_namespace ( ACPI_TYPE_DEVICE,
1005 if (ACPI_FAILURE(status))
1006 dbg("acpi_shpchprm:%s find_p2p fail=0x%x\n", path_name, status);
1012 static struct acpi_bridge * add_host_bridge(
1020 struct acpi_bridge *ab;
1021 u8 *path_name = acpi_path_name(handle);
1023 /* get device, function: host br adr is always 0000 though. */
1024 status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL, &adr);
1025 if (ACPI_FAILURE(status)) {
1026 err("acpi_shpchprm:%s _ADR fail=0x%x\n", path_name, status);
1029 dbg("acpi_shpchprm: ROOT PCI seg(0x%x)bus(0x%x)dev(0x%x)func(0x%x) [%s]\n", (u32)segnum, (u32)busnum,
1030 (u32)(adr >> 16) & 0xffff, (u32)adr & 0xffff, path_name);
1032 ab = (struct acpi_bridge *) kmalloc (sizeof(struct acpi_bridge), GFP_KERNEL);
1034 err("acpi_shpchprm: alloc for ab fail\n");
1037 memset(ab, 0, sizeof(struct acpi_bridge));
1039 ab->handle = handle;
1040 ab->seg = (int)segnum;
1041 ab->bus = ab->pbus = (int)busnum;
1042 ab->pdevice = (int)(adr >> 16) & 0xffff;
1043 ab->pfunction = (int)(adr & 0xffff);
1045 ab->type = BRIDGE_TYPE_HOST;
1047 /* get root pci bridge's current resources */
1048 status = acpi_get_crs(ab);
1049 if (ACPI_FAILURE(status)) {
1050 err("acpi_shpchprm:%s evaluate _CRS fail=0x%x\n", path_name, status);
1054 build_a_bridge(ab, ab);
1059 static acpi_status acpi_scan_from_root_pci_callback (
1069 struct acpi_bridge *ab;
1070 u8 *path_name = acpi_path_name(handle);
1072 /* get bus number of this pci root bridge */
1073 status = acpi_evaluate_integer(handle, METHOD_NAME__SEG, NULL, &segnum);
1074 if (ACPI_FAILURE(status)) {
1075 if (status != AE_NOT_FOUND) {
1076 err("acpi_shpchprm:%s evaluate _SEG fail=0x%x\n", path_name, status);
1082 /* get bus number of this pci root bridge */
1083 status = acpi_evaluate_integer(handle, METHOD_NAME__BBN, NULL, &busnum);
1084 if (ACPI_FAILURE(status)) {
1085 err("acpi_shpchprm:%s evaluate _BBN fail=0x%x\n", path_name, status);
1089 ab = add_host_bridge(handle, segnum, busnum);
1091 status = acpi_walk_namespace ( ACPI_TYPE_DEVICE,
1097 if (ACPI_FAILURE(status))
1098 dbg("acpi_shpchprm:%s find_p2p fail=0x%x\n", path_name, status);
1104 static int shpchprm_acpi_scan_pci (void)
1109 * TBD: traverse LDM device tree with the help of
1110 * unified ACPI augmented for php device population.
1112 status = acpi_get_devices ( PCI_ROOT_HID_STRING,
1113 acpi_scan_from_root_pci_callback,
1116 if (ACPI_FAILURE(status)) {
1117 err("acpi_shpchprm:get_device PCI ROOT HID fail=0x%x\n", status);
1124 int shpchprm_init(enum php_ctlr_type ctlr_type)
1128 if (ctlr_type != PCI)
1131 dbg("shpchprm ACPI init <enter>\n");
1132 acpi_bridges_head = NULL;
1134 /* construct PCI bus:device tree of acpi_handles */
1135 rc = shpchprm_acpi_scan_pci();
1139 dbg("shpchprm ACPI init %s\n", (rc)?"fail":"success");
1143 static void free_a_slot(struct acpi_php_slot *aps)
1145 dbg(" free a php func of slot(0x%02x) on PCI b:d:f=0x%02x:%02x:%02x\n", aps->sun, aps->bus, aps->dev, aps->fun);
1147 free_pci_resource (aps->io_head);
1148 free_pci_resource (aps->bus_head);
1149 free_pci_resource (aps->mem_head);
1150 free_pci_resource (aps->p_mem_head);
1155 static void free_a_bridge( struct acpi_bridge *ab)
1157 struct acpi_php_slot *aps, *next;
1160 case BRIDGE_TYPE_HOST:
1161 dbg("Free ACPI PCI HOST Bridge(%x) [%s] on s:b:d:f(%x:%x:%x:%x)\n",
1162 ab->bus, acpi_path_name(ab->handle), ab->seg, ab->pbus, ab->pdevice, ab->pfunction);
1164 case BRIDGE_TYPE_P2P:
1165 dbg("Free ACPI PCI P2P Bridge(%x-%x) [%s] on s:b:d:f(%x:%x:%x:%x)\n",
1166 ab->pbus, ab->bus, acpi_path_name(ab->handle), ab->seg, ab->pbus, ab->pdevice, ab->pfunction);
1170 /* free slots first */
1171 for (aps = ab->slots; aps; aps = next) {
1176 free_pci_resource (ab->io_head);
1177 free_pci_resource (ab->tio_head);
1178 free_pci_resource (ab->bus_head);
1179 free_pci_resource (ab->tbus_head);
1180 free_pci_resource (ab->mem_head);
1181 free_pci_resource (ab->tmem_head);
1182 free_pci_resource (ab->p_mem_head);
1183 free_pci_resource (ab->tp_mem_head);
1188 static void shpchprm_free_bridges ( struct acpi_bridge *ab)
1194 shpchprm_free_bridges (ab->child);
1197 shpchprm_free_bridges (ab->next);
1202 void shpchprm_cleanup(void)
1204 shpchprm_free_bridges (acpi_bridges_head);
1207 static int get_number_of_slots (
1208 struct acpi_bridge *ab,
1212 struct acpi_php_slot *aps;
1216 for ( aps = ab->slots; aps; aps = aps->next)
1217 if (aps->dev != prev_slot) {
1218 prev_slot = aps->dev;
1223 slot_num += get_number_of_slots (ab->child, 0);
1229 slot_num += get_number_of_slots (ab->next, 0);
1234 static int print_acpi_resources (struct acpi_bridge *ab)
1236 struct acpi_php_slot *aps;
1240 case BRIDGE_TYPE_HOST:
1241 dbg("PCI HOST Bridge (%x) [%s]\n", ab->bus, acpi_path_name(ab->handle));
1243 case BRIDGE_TYPE_P2P:
1244 dbg("PCI P2P Bridge (%x-%x) [%s]\n", ab->pbus, ab->bus, acpi_path_name(ab->handle));
1248 print_pci_resources (ab);
1250 for ( i = -1, aps = ab->slots; aps; aps = aps->next) {
1253 dbg(" Slot sun(%x) s:b:d:f(%02x:%02x:%02x:%02x)\n", aps->sun, aps->seg, aps->bus, aps->dev, aps->fun);
1254 print_slot_resources(aps);
1259 print_acpi_resources (ab->child);
1262 print_acpi_resources (ab->next);
1267 int shpchprm_print_pirt(void)
1269 dbg("SHPCHPRM ACPI Slots\n");
1270 if (acpi_bridges_head)
1271 print_acpi_resources (acpi_bridges_head);
1275 static struct acpi_php_slot * get_acpi_slot (
1276 struct acpi_bridge *ab,
1280 struct acpi_php_slot *aps = NULL;
1282 for ( aps = ab->slots; aps; aps = aps->next)
1283 if (aps->sun == sun)
1286 if (!aps && ab->child) {
1287 aps = (struct acpi_php_slot *)get_acpi_slot (ab->child, sun);
1292 if (!aps && ab->next) {
1293 aps = (struct acpi_php_slot *)get_acpi_slot (ab->next, sun);
1302 void * shpchprm_get_slot(struct slot *slot)
1304 struct acpi_bridge *ab = acpi_bridges_head;
1305 struct acpi_php_slot *aps = get_acpi_slot (ab, slot->number);
1309 dbg("Got acpi slot sun(%x): s:b:d:f(%x:%x:%x:%x)\n", aps->sun, aps->seg, aps->bus, aps->dev, aps->fun);
1314 static void shpchprm_dump_func_res( struct pci_func *fun)
1316 struct pci_func *func = fun;
1318 if (func->bus_head) {
1319 dbg(": BUS Resources:\n");
1320 print_pci_resource (func->bus_head);
1322 if (func->io_head) {
1323 dbg(": IO Resources:\n");
1324 print_pci_resource (func->io_head);
1326 if (func->mem_head) {
1327 dbg(": MEM Resources:\n");
1328 print_pci_resource (func->mem_head);
1330 if (func->p_mem_head) {
1331 dbg(": PMEM Resources:\n");
1332 print_pci_resource (func->p_mem_head);
1336 static void shpchprm_dump_ctrl_res( struct controller *ctlr)
1338 struct controller *ctrl = ctlr;
1340 if (ctrl->bus_head) {
1341 dbg(": BUS Resources:\n");
1342 print_pci_resource (ctrl->bus_head);
1344 if (ctrl->io_head) {
1345 dbg(": IO Resources:\n");
1346 print_pci_resource (ctrl->io_head);
1348 if (ctrl->mem_head) {
1349 dbg(": MEM Resources:\n");
1350 print_pci_resource (ctrl->mem_head);
1352 if (ctrl->p_mem_head) {
1353 dbg(": PMEM Resources:\n");
1354 print_pci_resource (ctrl->p_mem_head);
1358 static int shpchprm_get_used_resources (
1359 struct controller *ctrl,
1360 struct pci_func *func
1363 return shpchp_save_used_resources (ctrl, func, !DISABLE_CARD);
1366 static int configure_existing_function(
1367 struct controller *ctrl,
1368 struct pci_func *func
1373 /* see how much resources the func has used. */
1374 rc = shpchprm_get_used_resources (ctrl, func);
1377 /* subtract the resources used by the func from ctrl resources */
1378 rc = shpchprm_delete_resources (&ctrl->bus_head, func->bus_head);
1379 rc |= shpchprm_delete_resources (&ctrl->io_head, func->io_head);
1380 rc |= shpchprm_delete_resources (&ctrl->mem_head, func->mem_head);
1381 rc |= shpchprm_delete_resources (&ctrl->p_mem_head, func->p_mem_head);
1383 warn("aCEF: cannot del used resources\n");
1385 err("aCEF: cannot get used resources\n");
1390 static int bind_pci_resources_to_slots ( struct controller *ctrl)
1392 struct pci_func *func;
1393 int busn = ctrl->bus;
1397 for (devn = 0; devn < 32; devn++) {
1398 for (funn = 0; funn < 8; funn++) {
1399 if (devn == ctrl->device && funn == ctrl->function)
1401 /* find out if this entry is for an occupied slot */
1403 pci_bus_read_config_dword(ctrl->pci_bus, PCI_DEVFN(devn, funn), PCI_VENDOR_ID, &vid);
1405 if (vid != 0xFFFFFFFF) {
1406 func = shpchp_slot_find(busn, devn, funn);
1409 configure_existing_function(ctrl, func);
1410 dbg("aCCF:existing PCI 0x%x Func ResourceDump\n", ctrl->bus);
1411 shpchprm_dump_func_res(func);
1419 static int bind_pci_resources(
1420 struct controller *ctrl,
1421 struct acpi_bridge *ab
1427 dbg("bapr: BUS Resources add on PCI 0x%x\n", ab->bus);
1428 status = shpchprm_add_resources (&ctrl->bus_head, ab->bus_head);
1429 if (shpchprm_delete_resources (&ab->bus_head, ctrl->bus_head))
1430 warn("bapr: cannot sub BUS Resource on PCI 0x%x\n", ab->bus);
1432 err("bapr: BUS Resource add on PCI 0x%x: fail=0x%x\n", ab->bus, status);
1436 info("bapr: No BUS Resource on PCI 0x%x.\n", ab->bus);
1439 dbg("bapr: IO Resources add on PCI 0x%x\n", ab->bus);
1440 status = shpchprm_add_resources (&ctrl->io_head, ab->io_head);
1441 if (shpchprm_delete_resources (&ab->io_head, ctrl->io_head))
1442 warn("bapr: cannot sub IO Resource on PCI 0x%x\n", ab->bus);
1444 err("bapr: IO Resource add on PCI 0x%x: fail=0x%x\n", ab->bus, status);
1448 info("bapr: No IO Resource on PCI 0x%x.\n", ab->bus);
1451 dbg("bapr: MEM Resources add on PCI 0x%x\n", ab->bus);
1452 status = shpchprm_add_resources (&ctrl->mem_head, ab->mem_head);
1453 if (shpchprm_delete_resources (&ab->mem_head, ctrl->mem_head))
1454 warn("bapr: cannot sub MEM Resource on PCI 0x%x\n", ab->bus);
1456 err("bapr: MEM Resource add on PCI 0x%x: fail=0x%x\n", ab->bus, status);
1460 info("bapr: No MEM Resource on PCI 0x%x.\n", ab->bus);
1462 if (ab->p_mem_head) {
1463 dbg("bapr: PMEM Resources add on PCI 0x%x\n", ab->bus);
1464 status = shpchprm_add_resources (&ctrl->p_mem_head, ab->p_mem_head);
1465 if (shpchprm_delete_resources (&ab->p_mem_head, ctrl->p_mem_head))
1466 warn("bapr: cannot sub PMEM Resource on PCI 0x%x\n", ab->bus);
1468 err("bapr: PMEM Resource add on PCI 0x%x: fail=0x%x\n", ab->bus, status);
1472 info("bapr: No PMEM Resource on PCI 0x%x.\n", ab->bus);
1477 static int no_pci_resources( struct acpi_bridge *ab)
1479 return !(ab->p_mem_head || ab->mem_head || ab->io_head || ab->bus_head);
1482 static int find_pci_bridge_resources (
1483 struct controller *ctrl,
1484 struct acpi_bridge *ab
1488 struct pci_func func;
1490 memset(&func, 0, sizeof(struct pci_func));
1492 func.bus = ab->pbus;
1493 func.device = ab->pdevice;
1494 func.function = ab->pfunction;
1495 func.is_a_board = 1;
1497 /* Get used resources for this PCI bridge */
1498 rc = shpchp_save_used_resources (ctrl, &func, !DISABLE_CARD);
1500 ab->io_head = func.io_head;
1501 ab->mem_head = func.mem_head;
1502 ab->p_mem_head = func.p_mem_head;
1503 ab->bus_head = func.bus_head;
1505 shpchprm_delete_resource(&ab->bus_head, ctrl->bus, 1);
1510 static int get_pci_resources_from_bridge(
1511 struct controller *ctrl,
1512 struct acpi_bridge *ab
1517 dbg("grfb: Get Resources for PCI 0x%x from actual PCI bridge 0x%x.\n", ctrl->bus, ab->bus);
1519 rc = find_pci_bridge_resources (ctrl, ab);
1521 shpchp_resource_sort_and_combine(&ab->bus_head);
1522 shpchp_resource_sort_and_combine(&ab->io_head);
1523 shpchp_resource_sort_and_combine(&ab->mem_head);
1524 shpchp_resource_sort_and_combine(&ab->p_mem_head);
1526 shpchprm_add_resources (&ab->tbus_head, ab->bus_head);
1527 shpchprm_add_resources (&ab->tio_head, ab->io_head);
1528 shpchprm_add_resources (&ab->tmem_head, ab->mem_head);
1529 shpchprm_add_resources (&ab->tp_mem_head, ab->p_mem_head);
1534 static int get_pci_resources(
1535 struct controller *ctrl,
1536 struct acpi_bridge *ab
1541 if (no_pci_resources(ab)) {
1542 dbg("spbr:PCI 0x%x has no resources. Get parent resources.\n", ab->bus);
1543 rc = get_pci_resources_from_bridge(ctrl, ab);
1549 int shpchprm_get_physical_slot_number(struct controller *ctrl, u32 *sun, u8 busnum, u8 devnum)
1551 int offset = devnum - ctrl->slot_device_offset;
1553 dbg("%s: ctrl->slot_num_inc %d, offset %d\n", __FUNCTION__, ctrl->slot_num_inc, offset);
1554 *sun = (u8) (ctrl->first_slot + ctrl->slot_num_inc *offset);
1559 * Get resources for this ctrl.
1560 * 1. get total resources from ACPI _CRS or bridge (this ctrl)
1561 * 2. find used resources of existing adapters
1562 * 3. subtract used resources from total resources
1564 int shpchprm_find_available_resources( struct controller *ctrl)
1567 struct acpi_bridge *ab;
1569 ab = find_acpi_bridge_by_bus(acpi_bridges_head, ctrl->seg, ctrl->pci_dev->subordinate->number);
1571 err("pfar:cannot locate acpi bridge of PCI 0x%x.\n", ctrl->pci_dev->subordinate->number);
1574 if (no_pci_resources(ab)) {
1575 rc = get_pci_resources(ctrl, ab);
1577 err("pfar:cannot get pci resources of PCI 0x%x.\n",ctrl->pci_dev->subordinate->number);
1582 rc = bind_pci_resources(ctrl, ab);
1583 dbg("pfar:pre-Bind PCI 0x%x Ctrl Resource Dump\n", ctrl->pci_dev->subordinate->number);
1584 shpchprm_dump_ctrl_res(ctrl);
1586 bind_pci_resources_to_slots (ctrl);
1588 dbg("pfar:post-Bind PCI 0x%x Ctrl Resource Dump\n", ctrl->pci_dev->subordinate->number);
1589 shpchprm_dump_ctrl_res(ctrl);
1594 int shpchprm_set_hpp(
1595 struct controller *ctrl,
1596 struct pci_func *func,
1600 struct acpi_bridge *ab;
1601 struct pci_bus lpci_bus, *pci_bus;
1604 u8 cls= 0x08; /* default cache line size */
1605 u8 lt = 0x40; /* default latency timer */
1609 memcpy(&lpci_bus, ctrl->pci_bus, sizeof(lpci_bus));
1610 pci_bus = &lpci_bus;
1611 pci_bus->number = func->bus;
1612 devfn = PCI_DEVFN(func->device, func->function);
1614 ab = find_acpi_bridge_by_bus(acpi_bridges_head, ctrl->seg, ctrl->bus);
1618 lt = (u8)ab->_hpp->latency_timer;
1619 cls = (u8)ab->_hpp->cache_line_size;
1620 ep = (u8)ab->_hpp->enable_perr;
1621 es = (u8)ab->_hpp->enable_serr;
1623 dbg("_hpp: no _hpp for B/D/F=%#x/%#x/%#x. use default value\n", func->bus, func->device, func->function);
1625 dbg("_hpp: no acpi bridge for B/D/F = %#x/%#x/%#x. use default value\n", func->bus, func->device, func->function);
1628 if (card_type == PCI_HEADER_TYPE_BRIDGE) {
1629 /* set subordinate Latency Timer */
1630 rc |= pci_bus_write_config_byte(pci_bus, devfn, PCI_SEC_LATENCY_TIMER, lt);
1633 /* set base Latency Timer */
1634 rc |= pci_bus_write_config_byte(pci_bus, devfn, PCI_LATENCY_TIMER, lt);
1635 dbg(" set latency timer =0x%02x: %x\n", lt, rc);
1637 rc |= pci_bus_write_config_byte(pci_bus, devfn, PCI_CACHE_LINE_SIZE, cls);
1638 dbg(" set cache_line_size=0x%02x: %x\n", cls, rc);
1643 void shpchprm_enable_card(
1644 struct controller *ctrl,
1645 struct pci_func *func,
1648 u16 command, cmd, bcommand, bcmd;
1649 struct pci_bus lpci_bus, *pci_bus;
1650 struct acpi_bridge *ab;
1654 memcpy(&lpci_bus, ctrl->pci_bus, sizeof(lpci_bus));
1655 pci_bus = &lpci_bus;
1656 pci_bus->number = func->bus;
1657 devfn = PCI_DEVFN(func->device, func->function);
1659 rc = pci_bus_read_config_word(pci_bus, devfn, PCI_COMMAND, &command);
1661 if (card_type == PCI_HEADER_TYPE_BRIDGE) {
1662 rc = pci_bus_read_config_word(pci_bus, devfn, PCI_BRIDGE_CONTROL, &bcommand);
1665 cmd = command = command | PCI_COMMAND_MASTER | PCI_COMMAND_INVALIDATE
1666 | PCI_COMMAND_IO | PCI_COMMAND_MEMORY;
1667 bcmd = bcommand = bcommand | PCI_BRIDGE_CTL_NO_ISA;
1669 ab = find_acpi_bridge_by_bus(acpi_bridges_head, ctrl->seg, ctrl->bus);
1672 if (ab->_hpp->enable_perr) {
1673 command |= PCI_COMMAND_PARITY;
1674 bcommand |= PCI_BRIDGE_CTL_PARITY;
1676 command &= ~PCI_COMMAND_PARITY;
1677 bcommand &= ~PCI_BRIDGE_CTL_PARITY;
1679 if (ab->_hpp->enable_serr) {
1680 command |= PCI_COMMAND_SERR;
1681 bcommand |= PCI_BRIDGE_CTL_SERR;
1683 command &= ~PCI_COMMAND_SERR;
1684 bcommand &= ~PCI_BRIDGE_CTL_SERR;
1687 dbg("no _hpp for B/D/F = %#x/%#x/%#x.\n", func->bus, func->device, func->function);
1689 dbg("no acpi bridge for B/D/F = %#x/%#x/%#x.\n", func->bus, func->device, func->function);
1691 if (command != cmd) {
1692 rc = pci_bus_write_config_word(pci_bus, devfn, PCI_COMMAND, command);
1694 if ((card_type == PCI_HEADER_TYPE_BRIDGE) && (bcommand != bcmd)) {
1695 rc = pci_bus_write_config_word(pci_bus, devfn, PCI_BRIDGE_CONTROL, bcommand);