?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
MOXA linux-2.6.x / linux-2.6.9-uc0 from sdlinux-moxaart.tgz
[linux-2.6.9-moxart.git] / drivers / pci / hotplug / pciehprm_acpi.c
blobb127575ec98516029298fbc817acc7421f6d6fde
1 /*
2 * PCIEHPRM ACPI: PHP Resource Manager for ACPI platform
3 *
4 * Copyright (C) 2003-2004 Intel Corporation
5 *
6 * All rights reserved.
7 *
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.
12 *
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
17 * details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 *
23 * Send feedback to <dely.l.sy@intel.com>
24 *
25 */
26
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>
37 #ifdef CONFIG_IA64
38 #include <asm/iosapic.h>
39 #endif
40 #include <acpi/acpi.h>
41 #include <acpi/acpi_bus.h>
42 #include <acpi/actypes.h>
43 #include "pciehp.h"
44 #include "pciehprm.h"
45
46 #define PCI_MAX_BUS 0x100
47 #define ACPI_STA_DEVICE_PRESENT 0x01
48
49 #define METHOD_NAME__SUN "_SUN"
50 #define METHOD_NAME__HPP "_HPP"
51 #define METHOD_NAME_OSHP "OSHP"
52
53 #define PHP_RES_BUS 0xA0
54 #define PHP_RES_IO 0xA1
55 #define PHP_RES_MEM 0xA2
56 #define PHP_RES_PMEM 0xA3
57
58 #define BRIDGE_TYPE_P2P 0x00
59 #define BRIDGE_TYPE_HOST 0x01
60
61 /* this should go to drivers/acpi/include/ */
62 struct acpi__hpp {
63 u8 cache_line_size;
64 u8 latency_timer;
65 u8 enable_serr;
66 u8 enable_perr;
67 };
68
69 struct acpi_php_slot {
70 struct acpi_php_slot *next;
71 struct acpi_bridge *bridge;
72 acpi_handle handle;
73 int seg;
74 int bus;
75 int dev;
76 int fun;
77 u32 sun;
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 */
83 struct slot *slot;
84 }; /* per func */
85
86 struct acpi_bridge {
87 struct acpi_bridge *parent;
88 struct acpi_bridge *next;
89 struct acpi_bridge *child;
90 acpi_handle handle;
91 int seg;
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 */
106 int scanned;
107 int type;
108 };
109
110 static struct acpi_bridge *acpi_bridges_head;
111
112 static u8 * acpi_path_name( acpi_handle handle)
113 {
114 acpi_status status;
115 static u8 path_name[ACPI_PATHNAME_MAX];
116 struct acpi_buffer ret_buf = { ACPI_PATHNAME_MAX, path_name };
117
118 memset(path_name, 0, sizeof (path_name));
119 status = acpi_get_name(handle, ACPI_FULL_PATHNAME, &ret_buf);
120
121 if (ACPI_FAILURE(status))
122 return NULL;
123 else
124 return path_name;
125 }
126
127 static void acpi_get__hpp ( struct acpi_bridge *ab);
128 static void acpi_run_oshp ( struct acpi_bridge *ab);
129
130 static int acpi_add_slot_to_php_slots(
131 struct acpi_bridge *ab,
132 int bus_num,
133 acpi_handle handle,
134 u32 adr,
135 u32 sun
136 )
137 {
138 struct acpi_php_slot *aps;
139 static long samesun = -1;
140
141 aps = (struct acpi_php_slot *) kmalloc (sizeof(struct acpi_php_slot), GFP_KERNEL);
142 if (!aps) {
143 err ("acpi_pciehprm: alloc for aps fail\n");
144 return -1;
145 }
146 memset(aps, 0, sizeof(struct acpi_php_slot));
147
148 aps->handle = handle;
149 aps->bus = bus_num;
150 aps->dev = (adr >> 16) & 0xffff;
151 aps->fun = adr & 0xffff;
152 aps->sun = sun;
153
154 aps->next = ab->slots; /* cling to the bridge */
155 aps->bridge = ab;
156 ab->slots = aps;
157
158 ab->scanned += 1;
159 if (!ab->_hpp)
160 acpi_get__hpp(ab);
161
162 acpi_run_oshp(ab);
163
164 if (sun != samesun) {
165 info("acpi_pciehprm: Slot sun(%x) at s:b:d:f=0x%02x:%02x:%02x:%02x\n",
166 aps->sun, ab->seg, aps->bus, aps->dev, aps->fun);
167 samesun = sun;
168 }
169 return 0;
170 }
171
172 static void acpi_get__hpp ( struct acpi_bridge *ab)
173 {
174 acpi_status status;
175 u8 nui[4];
176 struct acpi_buffer ret_buf = { 0, NULL};
177 union acpi_object *ext_obj, *package;
178 u8 *path_name = acpi_path_name(ab->handle);
179 int i, len = 0;
180
181 /* get _hpp */
182 status = acpi_evaluate_object(ab->handle, METHOD_NAME__HPP, NULL, &ret_buf);
183 switch (status) {
184 case AE_BUFFER_OVERFLOW:
185 ret_buf.pointer = kmalloc (ret_buf.length, GFP_KERNEL);
186 if (!ret_buf.pointer) {
187 err ("acpi_pciehprm:%s alloc for _HPP fail\n", path_name);
188 return;
189 }
190 status = acpi_evaluate_object(ab->handle, METHOD_NAME__HPP, NULL, &ret_buf);
191 if (ACPI_SUCCESS(status))
192 break;
193 default:
194 if (ACPI_FAILURE(status)) {
195 err("acpi_pciehprm:%s _HPP fail=0x%x\n", path_name, status);
196 return;
197 }
198 }
199
200 ext_obj = (union acpi_object *) ret_buf.pointer;
201 if (ext_obj->type != ACPI_TYPE_PACKAGE) {
202 err ("acpi_pciehprm:%s _HPP obj not a package\n", path_name);
203 goto free_and_return;
204 }
205
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;
213 break;
214 default:
215 err ("acpi_pciehprm:%s _HPP obj type incorrect\n", path_name);
216 goto free_and_return;
217 }
218 }
219
220 ab->_hpp = kmalloc (sizeof (struct acpi__hpp), GFP_KERNEL);
221 if (!ab->_hpp) {
222 err ("acpi_pciehprm:%s alloc for _HPP failed\n", path_name);
223 goto free_and_return;
224 }
225 memset(ab->_hpp, 0, sizeof(struct acpi__hpp));
226
227 ab->_hpp->cache_line_size = nui[0];
228 ab->_hpp->latency_timer = nui[1];
229 ab->_hpp->enable_serr = nui[2];
230 ab->_hpp->enable_perr = nui[3];
231
232 dbg(" _HPP: cache_line_size=0x%x\n", ab->_hpp->cache_line_size);
233 dbg(" _HPP: latency timer =0x%x\n", ab->_hpp->latency_timer);
234 dbg(" _HPP: enable SERR =0x%x\n", ab->_hpp->enable_serr);
235 dbg(" _HPP: enable PERR =0x%x\n", ab->_hpp->enable_perr);
236
237 free_and_return:
238 kfree(ret_buf.pointer);
239 }
240
241 static void acpi_run_oshp ( struct acpi_bridge *ab)
242 {
243 acpi_status status;
244 u8 *path_name = acpi_path_name(ab->handle);
245 struct acpi_buffer ret_buf = { 0, NULL};
246
247 /* run OSHP */
248 status = acpi_evaluate_object(ab->handle, METHOD_NAME_OSHP, NULL, &ret_buf);
249 if (ACPI_FAILURE(status)) {
250 err("acpi_pciehprm:%s OSHP fails=0x%x\n", path_name, status);
251 } else
252 dbg("acpi_pciehprm:%s OSHP passes =0x%x\n", path_name, status);
253 return;
254 }
255
256 static acpi_status acpi_evaluate_crs(
257 acpi_handle handle,
258 struct acpi_resource **retbuf
259 )
260 {
261 acpi_status status;
262 struct acpi_buffer crsbuf;
263 u8 *path_name = acpi_path_name(handle);
264
265 crsbuf.length = 0;
266 crsbuf.pointer = NULL;
267
268 status = acpi_get_current_resources (handle, &crsbuf);
269
270 switch (status) {
271 case AE_BUFFER_OVERFLOW:
272 break; /* found */
273 case AE_NOT_FOUND:
274 dbg("acpi_pciehprm:%s _CRS not found\n", path_name);
275 return status;
276 default:
277 err ("acpi_pciehprm:%s _CRS fail=0x%x\n", path_name, status);
278 return status;
279 }
280
281 crsbuf.pointer = kmalloc (crsbuf.length, GFP_KERNEL);
282 if (!crsbuf.pointer) {
283 err ("acpi_pciehprm: alloc %ld bytes for %s _CRS fail\n", (ulong)crsbuf.length, path_name);
284 return AE_NO_MEMORY;
285 }
286
287 status = acpi_get_current_resources (handle, &crsbuf);
288 if (ACPI_FAILURE(status)) {
289 err("acpi_pciehprm: %s _CRS fail=0x%x.\n", path_name, status);
290 kfree(crsbuf.pointer);
291 return status;
292 }
293
294 *retbuf = crsbuf.pointer;
295
296 return status;
297 }
298
299 static void free_pci_resource ( struct pci_resource *aprh)
300 {
301 struct pci_resource *res, *next;
302
303 for (res = aprh; res; res = next) {
304 next = res->next;
305 kfree(res);
306 }
307 }
308
309 static void print_pci_resource ( struct pci_resource *aprh)
310 {
311 struct pci_resource *res;
312
313 for (res = aprh; res; res = res->next)
314 dbg(" base= 0x%x length= 0x%x\n", res->base, res->length);
315 }
316
317 static void print_slot_resources( struct acpi_php_slot *aps)
318 {
319 if (aps->bus_head) {
320 dbg(" BUS Resources:\n");
321 print_pci_resource (aps->bus_head);
322 }
323
324 if (aps->io_head) {
325 dbg(" IO Resources:\n");
326 print_pci_resource (aps->io_head);
327 }
328
329 if (aps->mem_head) {
330 dbg(" MEM Resources:\n");
331 print_pci_resource (aps->mem_head);
332 }
333
334 if (aps->p_mem_head) {
335 dbg(" PMEM Resources:\n");
336 print_pci_resource (aps->p_mem_head);
337 }
338 }
339
340 static void print_pci_resources( struct acpi_bridge *ab)
341 {
342 if (ab->tbus_head) {
343 dbg(" Total BUS Resources:\n");
344 print_pci_resource (ab->tbus_head);
345 }
346 if (ab->bus_head) {
347 dbg(" BUS Resources:\n");
348 print_pci_resource (ab->bus_head);
349 }
350
351 if (ab->tio_head) {
352 dbg(" Total IO Resources:\n");
353 print_pci_resource (ab->tio_head);
354 }
355 if (ab->io_head) {
356 dbg(" IO Resources:\n");
357 print_pci_resource (ab->io_head);
358 }
359
360 if (ab->tmem_head) {
361 dbg(" Total MEM Resources:\n");
362 print_pci_resource (ab->tmem_head);
363 }
364 if (ab->mem_head) {
365 dbg(" MEM Resources:\n");
366 print_pci_resource (ab->mem_head);
367 }
368
369 if (ab->tp_mem_head) {
370 dbg(" Total PMEM Resources:\n");
371 print_pci_resource (ab->tp_mem_head);
372 }
373 if (ab->p_mem_head) {
374 dbg(" PMEM Resources:\n");
375 print_pci_resource (ab->p_mem_head);
376 }
377 if (ab->_hpp) {
378 dbg(" _HPP: cache_line_size=0x%x\n", ab->_hpp->cache_line_size);
379 dbg(" _HPP: latency timer =0x%x\n", ab->_hpp->latency_timer);
380 dbg(" _HPP: enable SERR =0x%x\n", ab->_hpp->enable_serr);
381 dbg(" _HPP: enable PERR =0x%x\n", ab->_hpp->enable_perr);
382 }
383 }
384
385 static int pciehprm_delete_resource(
386 struct pci_resource **aprh,
387 ulong base,
388 ulong size)
389 {
390 struct pci_resource *res;
391 struct pci_resource *prevnode;
392 struct pci_resource *split_node;
393 ulong tbase;
394
395 pciehp_resource_sort_and_combine(aprh);
396
397 for (res = *aprh; res; res = res->next) {
398 if (res->base > base)
399 continue;
400
401 if ((res->base + res->length) < (base + size))
402 continue;
403
404 if (res->base < base) {
405 tbase = base;
406
407 if ((res->length - (tbase - res->base)) < size)
408 continue;
409
410 split_node = (struct pci_resource *) kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
411 if (!split_node)
412 return -ENOMEM;
413
414 split_node->base = res->base;
415 split_node->length = tbase - res->base;
416 res->base = tbase;
417 res->length -= split_node->length;
418
419 split_node->next = res->next;
420 res->next = split_node;
421 }
422
423 if (res->length >= size) {
424 split_node = (struct pci_resource*) kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
425 if (!split_node)
426 return -ENOMEM;
427
428 split_node->base = res->base + size;
429 split_node->length = res->length - size;
430 res->length = size;
431
432 split_node->next = res->next;
433 res->next = split_node;
434 }
435
436 if (*aprh == res) {
437 *aprh = res->next;
438 } else {
439 prevnode = *aprh;
440 while (prevnode->next != res)
441 prevnode = prevnode->next;
442
443 prevnode->next = res->next;
444 }
445 res->next = NULL;
446 kfree(res);
447 break;
448 }
449
450 return 0;
451 }
452
453 static int pciehprm_delete_resources(
454 struct pci_resource **aprh,
455 struct pci_resource *this
456 )
457 {
458 struct pci_resource *res;
459
460 for (res = this; res; res = res->next)
461 pciehprm_delete_resource(aprh, res->base, res->length);
462
463 return 0;
464 }
465
466 static int pciehprm_add_resource(
467 struct pci_resource **aprh,
468 ulong base,
469 ulong size)
470 {
471 struct pci_resource *res;
472
473 for (res = *aprh; res; res = res->next) {
474 if ((res->base + res->length) == base) {
475 res->length += size;
476 size = 0L;
477 break;
478 }
479 if (res->next == *aprh)
480 break;
481 }
482
483 if (size) {
484 res = kmalloc(sizeof(struct pci_resource), GFP_KERNEL);
485 if (!res) {
486 err ("acpi_pciehprm: alloc for res fail\n");
487 return -ENOMEM;
488 }
489 memset(res, 0, sizeof (struct pci_resource));
490
491 res->base = base;
492 res->length = size;
493 res->next = *aprh;
494 *aprh = res;
495 }
496
497 return 0;
498 }
499
500 static int pciehprm_add_resources(
501 struct pci_resource **aprh,
502 struct pci_resource *this
503 )
504 {
505 struct pci_resource *res;
506 int rc = 0;
507
508 for (res = this; res && !rc; res = res->next)
509 rc = pciehprm_add_resource(aprh, res->base, res->length);
510
511 return rc;
512 }
513
514 static void acpi_parse_io (
515 struct acpi_bridge *ab,
516 union acpi_resource_data *data
517 )
518 {
519 struct acpi_resource_io *dataio;
520 dataio = (struct acpi_resource_io *) data;
521
522 dbg("Io Resource\n");
523 dbg(" %d bit decode\n", ACPI_DECODE_16 == dataio->io_decode ? 16:10);
524 dbg(" Range minimum base: %08X\n", dataio->min_base_address);
525 dbg(" Range maximum base: %08X\n", dataio->max_base_address);
526 dbg(" Alignment: %08X\n", dataio->alignment);
527 dbg(" Range Length: %08X\n", dataio->range_length);
528 }
529
530 static void acpi_parse_fixed_io (
531 struct acpi_bridge *ab,
532 union acpi_resource_data *data
533 )
534 {
535 struct acpi_resource_fixed_io *datafio;
536 datafio = (struct acpi_resource_fixed_io *) data;
537
538 dbg("Fixed Io Resource\n");
539 dbg(" Range base address: %08X", datafio->base_address);
540 dbg(" Range length: %08X", datafio->range_length);
541 }
542
543 static void acpi_parse_address16_32 (
544 struct acpi_bridge *ab,
545 union acpi_resource_data *data,
546 acpi_resource_type id
547 )
548 {
549 /*
550 * acpi_resource_address16 == acpi_resource_address32
551 * acpi_resource_address16 *data16 = (acpi_resource_address16 *) data;
552 */
553 struct acpi_resource_address32 *data32 = (struct acpi_resource_address32 *) data;
554 struct pci_resource **aprh, **tprh;
555
556 if (id == ACPI_RSTYPE_ADDRESS16)
557 dbg("acpi_pciehprm:16-Bit Address Space Resource\n");
558 else
559 dbg("acpi_pciehprm:32-Bit Address Space Resource\n");
560
561 switch (data32->resource_type) {
562 case ACPI_MEMORY_RANGE:
563 dbg(" Resource Type: Memory Range\n");
564 aprh = &ab->mem_head;
565 tprh = &ab->tmem_head;
566
567 switch (data32->attribute.memory.cache_attribute) {
568 case ACPI_NON_CACHEABLE_MEMORY:
569 dbg(" Type Specific: Noncacheable memory\n");
570 break;
571 case ACPI_CACHABLE_MEMORY:
572 dbg(" Type Specific: Cacheable memory\n");
573 break;
574 case ACPI_WRITE_COMBINING_MEMORY:
575 dbg(" Type Specific: Write-combining memory\n");
576 break;
577 case ACPI_PREFETCHABLE_MEMORY:
578 aprh = &ab->p_mem_head;
579 dbg(" Type Specific: Prefetchable memory\n");
580 break;
581 default:
582 dbg(" Type Specific: Invalid cache attribute\n");
583 break;
584 }
585
586 dbg(" Type Specific: Read%s\n", ACPI_READ_WRITE_MEMORY == data32->attribute.memory.read_write_attribute ? "/Write":" Only");
587 break;
588
589 case ACPI_IO_RANGE:
590 dbg(" Resource Type: I/O Range\n");
591 aprh = &ab->io_head;
592 tprh = &ab->tio_head;
593
594 switch (data32->attribute.io.range_attribute) {
595 case ACPI_NON_ISA_ONLY_RANGES:
596 dbg(" Type Specific: Non-ISA Io Addresses\n");
597 break;
598 case ACPI_ISA_ONLY_RANGES:
599 dbg(" Type Specific: ISA Io Addresses\n");
600 break;
601 case ACPI_ENTIRE_RANGE:
602 dbg(" Type Specific: ISA and non-ISA Io Addresses\n");
603 break;
604 default:
605 dbg(" Type Specific: Invalid range attribute\n");
606 break;
607 }
608 break;
609
610 case ACPI_BUS_NUMBER_RANGE:
611 dbg(" Resource Type: Bus Number Range(fixed)\n");
612 /* fixup to be compatible with the rest of php driver */
613 data32->min_address_range++;
614 data32->address_length--;
615 aprh = &ab->bus_head;
616 tprh = &ab->tbus_head;
617 break;
618 default:
619 dbg(" Resource Type: Invalid resource type. Exiting.\n");
620 return;
621 }
622
623 dbg(" Resource %s\n", ACPI_CONSUMER == data32->producer_consumer ? "Consumer":"Producer");
624 dbg(" %s decode\n", ACPI_SUB_DECODE == data32->decode ? "Subtractive":"Positive");
625 dbg(" Min address is %s fixed\n", ACPI_ADDRESS_FIXED == data32->min_address_fixed ? "":"not");
626 dbg(" Max address is %s fixed\n", ACPI_ADDRESS_FIXED == data32->max_address_fixed ? "":"not");
627 dbg(" Granularity: %08X\n", data32->granularity);
628 dbg(" Address range min: %08X\n", data32->min_address_range);
629 dbg(" Address range max: %08X\n", data32->max_address_range);
630 dbg(" Address translation offset: %08X\n", data32->address_translation_offset);
631 dbg(" Address Length: %08X\n", data32->address_length);
632
633 if (0xFF != data32->resource_source.index) {
634 dbg(" Resource Source Index: %X\n", data32->resource_source.index);
635 /* dbg(" Resource Source: %s\n", data32->resource_source.string_ptr); */
636 }
637
638 pciehprm_add_resource(aprh, data32->min_address_range, data32->address_length);
639 }
640
641 static acpi_status acpi_parse_crs(
642 struct acpi_bridge *ab,
643 struct acpi_resource *crsbuf
644 )
645 {
646 acpi_status status = AE_OK;
647 struct acpi_resource *resource = crsbuf;
648 u8 count = 0;
649 u8 done = 0;
650
651 while (!done) {
652 dbg("acpi_pciehprm: PCI bus 0x%x Resource structure %x.\n", ab->bus, count++);
653 switch (resource->id) {
654 case ACPI_RSTYPE_IRQ:
655 dbg("Irq -------- Resource\n");
656 break;
657 case ACPI_RSTYPE_DMA:
658 dbg("DMA -------- Resource\n");
659 break;
660 case ACPI_RSTYPE_START_DPF:
661 dbg("Start DPF -------- Resource\n");
662 break;
663 case ACPI_RSTYPE_END_DPF:
664 dbg("End DPF -------- Resource\n");
665 break;
666 case ACPI_RSTYPE_IO:
667 acpi_parse_io (ab, &resource->data);
668 break;
669 case ACPI_RSTYPE_FIXED_IO:
670 acpi_parse_fixed_io (ab, &resource->data);
671 break;
672 case ACPI_RSTYPE_VENDOR:
673 dbg("Vendor -------- Resource\n");
674 break;
675 case ACPI_RSTYPE_END_TAG:
676 dbg("End_tag -------- Resource\n");
677 done = 1;
678 break;
679 case ACPI_RSTYPE_MEM24:
680 dbg("Mem24 -------- Resource\n");
681 break;
682 case ACPI_RSTYPE_MEM32:
683 dbg("Mem32 -------- Resource\n");
684 break;
685 case ACPI_RSTYPE_FIXED_MEM32:
686 dbg("Fixed Mem32 -------- Resource\n");
687 break;
688 case ACPI_RSTYPE_ADDRESS16:
689 acpi_parse_address16_32(ab, &resource->data, ACPI_RSTYPE_ADDRESS16);
690 break;
691 case ACPI_RSTYPE_ADDRESS32:
692 acpi_parse_address16_32(ab, &resource->data, ACPI_RSTYPE_ADDRESS32);
693 break;
694 case ACPI_RSTYPE_ADDRESS64:
695 info("Address64 -------- Resource unparsed\n");
696 break;
697 case ACPI_RSTYPE_EXT_IRQ:
698 dbg("Ext Irq -------- Resource\n");
699 break;
700 default:
701 dbg("Invalid -------- resource type 0x%x\n", resource->id);
702 break;
703 }
704
705 resource = (struct acpi_resource *) ((char *)resource + resource->length);
706 }
707
708 return status;
709 }
710
711 static acpi_status acpi_get_crs( struct acpi_bridge *ab)
712 {
713 acpi_status status;
714 struct acpi_resource *crsbuf;
715
716 status = acpi_evaluate_crs(ab->handle, &crsbuf);
717 if (ACPI_SUCCESS(status)) {
718 status = acpi_parse_crs(ab, crsbuf);
719 kfree(crsbuf);
720
721 pciehp_resource_sort_and_combine(&ab->bus_head);
722 pciehp_resource_sort_and_combine(&ab->io_head);
723 pciehp_resource_sort_and_combine(&ab->mem_head);
724 pciehp_resource_sort_and_combine(&ab->p_mem_head);
725
726 pciehprm_add_resources (&ab->tbus_head, ab->bus_head);
727 pciehprm_add_resources (&ab->tio_head, ab->io_head);
728 pciehprm_add_resources (&ab->tmem_head, ab->mem_head);
729 pciehprm_add_resources (&ab->tp_mem_head, ab->p_mem_head);
730 }
731
732 return status;
733 }
734
735 /* find acpi_bridge downword from ab. */
736 static struct acpi_bridge *
737 find_acpi_bridge_by_bus(
738 struct acpi_bridge *ab,
739 int seg,
740 int bus /* pdev->subordinate->number */
741 )
742 {
743 struct acpi_bridge *lab = NULL;
744
745 if (!ab)
746 return NULL;
747
748 if ((ab->bus == bus) && (ab->seg == seg))
749 return ab;
750
751 if (ab->child)
752 lab = find_acpi_bridge_by_bus(ab->child, seg, bus);
753
754 if (!lab)
755 if (ab->next)
756 lab = find_acpi_bridge_by_bus(ab->next, seg, bus);
757
758 return lab;
759 }
760
761 /*
762 * Build a device tree of ACPI PCI Bridges
763 */
764 static void pciehprm_acpi_register_a_bridge (
765 struct acpi_bridge **head,
766 struct acpi_bridge *pab, /* parent bridge to which child bridge is added */
767 struct acpi_bridge *cab /* child bridge to add */
768 )
769 {
770 struct acpi_bridge *lpab;
771 struct acpi_bridge *lcab;
772
773 lpab = find_acpi_bridge_by_bus(*head, pab->seg, pab->bus);
774 if (!lpab) {
775 if (!(pab->type & BRIDGE_TYPE_HOST))
776 warn("PCI parent bridge s:b(%x:%x) not in list.\n", pab->seg, pab->bus);
777 pab->next = *head;
778 *head = pab;
779 lpab = pab;
780 }
781
782 if ((cab->type & BRIDGE_TYPE_HOST) && (pab == cab))
783 return;
784
785 lcab = find_acpi_bridge_by_bus(*head, cab->seg, cab->bus);
786 if (lcab) {
787 if ((pab->bus != lcab->parent->bus) || (lcab->bus != cab->bus))
788 err("PCI child bridge s:b(%x:%x) in list with diff parent.\n", cab->seg, cab->bus);
789 return;
790 } else
791 lcab = cab;
792
793 lcab->parent = lpab;
794 lcab->next = lpab->child;
795 lpab->child = lcab;
796 }
797
798 static acpi_status pciehprm_acpi_build_php_slots_callback(
799 acpi_handle handle,
800 u32 Level,
801 void *context,
802 void **retval
803 )
804 {
805 ulong bus_num;
806 ulong seg_num;
807 ulong sun, adr;
808 ulong padr = 0;
809 acpi_handle phandle = NULL;
810 struct acpi_bridge *pab = (struct acpi_bridge *)context;
811 struct acpi_bridge *lab;
812 acpi_status status;
813 u8 *path_name = acpi_path_name(handle);
814
815 /* get _SUN */
816 status = acpi_evaluate_integer(handle, METHOD_NAME__SUN, NULL, &sun);
817 switch(status) {
818 case AE_NOT_FOUND:
819 return AE_OK;
820 default:
821 if (ACPI_FAILURE(status)) {
822 err("acpi_pciehprm:%s _SUN fail=0x%x\n", path_name, status);
823 return status;
824 }
825 }
826
827 /* get _ADR. _ADR must exist if _SUN exists */
828 status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL, &adr);
829 if (ACPI_FAILURE(status)) {
830 err("acpi_pciehprm:%s _ADR fail=0x%x\n", path_name, status);
831 return status;
832 }
833
834 dbg("acpi_pciehprm:%s sun=0x%08x adr=0x%08x\n", path_name, (u32)sun, (u32)adr);
835
836 status = acpi_get_parent(handle, &phandle);
837 if (ACPI_FAILURE(status)) {
838 err("acpi_pciehprm:%s get_parent fail=0x%x\n", path_name, status);
839 return (status);
840 }
841
842 bus_num = pab->bus;
843 seg_num = pab->seg;
844
845 if (pab->bus == bus_num) {
846 lab = pab;
847 } else {
848 dbg("WARN: pab is not parent\n");
849 lab = find_acpi_bridge_by_bus(pab, seg_num, bus_num);
850 if (!lab) {
851 dbg("acpi_pciehprm: alloc new P2P bridge(%x) for sun(%08x)\n", (u32)bus_num, (u32)sun);
852 lab = (struct acpi_bridge *)kmalloc(sizeof(struct acpi_bridge), GFP_KERNEL);
853 if (!lab) {
854 err("acpi_pciehprm: alloc for ab fail\n");
855 return AE_NO_MEMORY;
856 }
857 memset(lab, 0, sizeof(struct acpi_bridge));
858
859 lab->handle = phandle;
860 lab->pbus = pab->bus;
861 lab->pdevice = (int)(padr >> 16) & 0xffff;
862 lab->pfunction = (int)(padr & 0xffff);
863 lab->bus = (int)bus_num;
864 lab->scanned = 0;
865 lab->type = BRIDGE_TYPE_P2P;
866
867 pciehprm_acpi_register_a_bridge (&acpi_bridges_head, pab, lab);
868 } else
869 dbg("acpi_pciehprm: found P2P bridge(%x) for sun(%08x)\n", (u32)bus_num, (u32)sun);
870 }
871
872 acpi_add_slot_to_php_slots(lab, (int)bus_num, handle, (u32)adr, (u32)sun);
873
874 return (status);
875 }
876
877 static int pciehprm_acpi_build_php_slots(
878 struct acpi_bridge *ab,
879 u32 depth
880 )
881 {
882 acpi_status status;
883 u8 *path_name = acpi_path_name(ab->handle);
884
885 /* Walk down this pci bridge to get _SUNs if any behind P2P */
886 status = acpi_walk_namespace ( ACPI_TYPE_DEVICE,
887 ab->handle,
888 depth,
889 pciehprm_acpi_build_php_slots_callback,
890 ab,
891 NULL );
892 if (ACPI_FAILURE(status)) {
893 dbg("acpi_pciehprm:%s walk for _SUN on pci bridge seg:bus(%x:%x) fail=0x%x\n", path_name, ab->seg, ab->bus, status);
894 return -1;
895 }
896
897 return 0;
898 }
899
900 static void build_a_bridge(
901 struct acpi_bridge *pab,
902 struct acpi_bridge *ab
903 )
904 {
905 u8 *path_name = acpi_path_name(ab->handle);
906
907 pciehprm_acpi_register_a_bridge (&acpi_bridges_head, pab, ab);
908
909 switch (ab->type) {
910 case BRIDGE_TYPE_HOST:
911 dbg("acpi_pciehprm: Registered PCI HOST Bridge(%02x) on s:b:d:f(%02x:%02x:%02x:%02x) [%s]\n",
912 ab->bus, ab->seg, ab->pbus, ab->pdevice, ab->pfunction, path_name);
913 break;
914 case BRIDGE_TYPE_P2P:
915 dbg("acpi_pciehprm: Registered PCI P2P Bridge(%02x-%02x) on s:b:d:f(%02x:%02x:%02x:%02x) [%s]\n",
916 ab->pbus, ab->bus, ab->seg, ab->pbus, ab->pdevice, ab->pfunction, path_name);
917 break;
918 };
919
920 /* build any immediate PHP slots under this pci bridge */
921 pciehprm_acpi_build_php_slots(ab, 1);
922 }
923
924 static struct acpi_bridge * add_p2p_bridge(
925 acpi_handle handle,
926 struct acpi_bridge *pab, /* parent */
927 ulong adr
928 )
929 {
930 struct acpi_bridge *ab;
931 struct pci_dev *pdev;
932 ulong devnum, funcnum;
933 u8 *path_name = acpi_path_name(handle);
934
935 ab = (struct acpi_bridge *) kmalloc (sizeof(struct acpi_bridge), GFP_KERNEL);
936 if (!ab) {
937 err("acpi_pciehprm: alloc for ab fail\n");
938 return NULL;
939 }
940 memset(ab, 0, sizeof(struct acpi_bridge));
941
942 devnum = (adr >> 16) & 0xffff;
943 funcnum = adr & 0xffff;
944
945 pdev = pci_find_slot(pab->bus, PCI_DEVFN(devnum, funcnum));
946 if (!pdev || !pdev->subordinate) {
947 err("acpi_pciehprm:%s is not a P2P Bridge\n", path_name);
948 kfree(ab);
949 return NULL;
950 }
951
952 ab->handle = handle;
953 ab->seg = pab->seg;
954 ab->pbus = pab->bus; /* or pdev->bus->number */
955 ab->pdevice = devnum; /* or PCI_SLOT(pdev->devfn) */
956 ab->pfunction = funcnum; /* or PCI_FUNC(pdev->devfn) */
957 ab->bus = pdev->subordinate->number;
958 ab->scanned = 0;
959 ab->type = BRIDGE_TYPE_P2P;
960
961 dbg("acpi_pciehprm: P2P(%x-%x) on pci=b:d:f(%x:%x:%x) acpi=b:d:f(%x:%x:%x) [%s]\n",
962 pab->bus, ab->bus, pdev->bus->number, PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn),
963 pab->bus, (u32)devnum, (u32)funcnum, path_name);
964
965 build_a_bridge(pab, ab);
966
967 return ab;
968 }
969
970 static acpi_status scan_p2p_bridge(
971 acpi_handle handle,
972 u32 Level,
973 void *context,
974 void **retval
975 )
976 {
977 struct acpi_bridge *pab = (struct acpi_bridge *)context;
978 struct acpi_bridge *ab;
979 acpi_status status;
980 ulong adr = 0;
981 u8 *path_name = acpi_path_name(handle);
982 ulong devnum, funcnum;
983 struct pci_dev *pdev;
984
985 /* get device, function */
986 status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL, &adr);
987 if (ACPI_FAILURE(status)) {
988 if (status != AE_NOT_FOUND)
989 err("acpi_pciehprm:%s _ADR fail=0x%x\n", path_name, status);
990 return AE_OK;
991 }
992
993 devnum = (adr >> 16) & 0xffff;
994 funcnum = adr & 0xffff;
995
996 pdev = pci_find_slot(pab->bus, PCI_DEVFN(devnum, funcnum));
997 if (!pdev)
998 return AE_OK;
999 if (!pdev->subordinate)
1000 return AE_OK;
1001
1002 ab = add_p2p_bridge(handle, pab, adr);
1003 if (ab) {
1004 status = acpi_walk_namespace ( ACPI_TYPE_DEVICE,
1005 handle,
1006 (u32)1,
1007 scan_p2p_bridge,
1008 ab,
1009 NULL);
1010 if (ACPI_FAILURE(status))
1011 dbg("acpi_pciehprm:%s find_p2p fail=0x%x\n", path_name, status);
1012 }
1013
1014 return AE_OK;
1015 }
1016
1017 static struct acpi_bridge * add_host_bridge(
1018 acpi_handle handle,
1019 ulong segnum,
1020 ulong busnum
1021 )
1022 {
1023 ulong adr = 0;
1024 acpi_status status;
1025 struct acpi_bridge *ab;
1026 u8 *path_name = acpi_path_name(handle);
1027
1028 /* get device, function: host br adr is always 0000 though. */
1029 status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL, &adr);
1030 if (ACPI_FAILURE(status)) {
1031 err("acpi_pciehprm:%s _ADR fail=0x%x\n", path_name, status);
1032 return NULL;
1033 }
1034 dbg("acpi_pciehprm: ROOT PCI seg(0x%x)bus(0x%x)dev(0x%x)func(0x%x) [%s]\n", (u32)segnum,
1035 (u32)busnum, (u32)(adr >> 16) & 0xffff, (u32)adr & 0xffff, path_name);
1036
1037 ab = (struct acpi_bridge *) kmalloc (sizeof(struct acpi_bridge), GFP_KERNEL);
1038 if (!ab) {
1039 err("acpi_pciehprm: alloc for ab fail\n");
1040 return NULL;
1041 }
1042 memset(ab, 0, sizeof(struct acpi_bridge));
1043
1044 ab->handle = handle;
1045 ab->seg = (int)segnum;
1046 ab->bus = ab->pbus = (int)busnum;
1047 ab->pdevice = (int)(adr >> 16) & 0xffff;
1048 ab->pfunction = (int)(adr & 0xffff);
1049 ab->scanned = 0;
1050 ab->type = BRIDGE_TYPE_HOST;
1051
1052 /* get root pci bridge's current resources */
1053 status = acpi_get_crs(ab);
1054 if (ACPI_FAILURE(status)) {
1055 err("acpi_pciehprm:%s evaluate _CRS fail=0x%x\n", path_name, status);
1056 kfree(ab);
1057 return NULL;
1058 }
1059 build_a_bridge(ab, ab);
1060
1061 return ab;
1062 }
1063
1064 static acpi_status acpi_scan_from_root_pci_callback (
1065 acpi_handle handle,
1066 u32 Level,
1067 void *context,
1068 void **retval
1069 )
1070 {
1071 ulong segnum = 0;
1072 ulong busnum = 0;
1073 acpi_status status;
1074 struct acpi_bridge *ab;
1075 u8 *path_name = acpi_path_name(handle);
1076
1077 /* get bus number of this pci root bridge */
1078 status = acpi_evaluate_integer(handle, METHOD_NAME__SEG, NULL, &segnum);
1079 if (ACPI_FAILURE(status)) {
1080 if (status != AE_NOT_FOUND) {
1081 err("acpi_pciehprm:%s evaluate _SEG fail=0x%x\n", path_name, status);
1082 return status;
1083 }
1084 segnum = 0;
1085 }
1086
1087 /* get bus number of this pci root bridge */
1088 status = acpi_evaluate_integer(handle, METHOD_NAME__BBN, NULL, &busnum);
1089 if (ACPI_FAILURE(status)) {
1090 err("acpi_pciehprm:%s evaluate _BBN fail=0x%x\n", path_name, status);
1091 return (status);
1092 }
1093
1094 ab = add_host_bridge(handle, segnum, busnum);
1095 if (ab) {
1096 status = acpi_walk_namespace ( ACPI_TYPE_DEVICE,
1097 handle,
1098 1,
1099 scan_p2p_bridge,
1100 ab,
1101 NULL);
1102 if (ACPI_FAILURE(status))
1103 dbg("acpi_pciehprm:%s find_p2p fail=0x%x\n", path_name, status);
1104 }
1105
1106 return AE_OK;
1107 }
1108
1109 static int pciehprm_acpi_scan_pci (void)
1110 {
1111 acpi_status status;
1112
1113 /*
1114 * TBD: traverse LDM device tree with the help of
1115 * unified ACPI augmented for php device population.
1116 */
1117 status = acpi_get_devices ( PCI_ROOT_HID_STRING,
1118 acpi_scan_from_root_pci_callback,
1119 NULL,
1120 NULL );
1121 if (ACPI_FAILURE(status)) {
1122 err("acpi_pciehprm:get_device PCI ROOT HID fail=0x%x\n", status);
1123 return -1;
1124 }
1125
1126 return 0;
1127 }
1128
1129 int pciehprm_init(enum php_ctlr_type ctlr_type)
1130 {
1131 int rc;
1132
1133 if (ctlr_type != PCI)
1134 return -ENODEV;
1135
1136 dbg("pciehprm ACPI init <enter>\n");
1137 acpi_bridges_head = NULL;
1138
1139 /* construct PCI bus:device tree of acpi_handles */
1140 rc = pciehprm_acpi_scan_pci();
1141 if (rc)
1142 return rc;
1143
1144 dbg("pciehprm ACPI init %s\n", (rc)?"fail":"success");
1145 return rc;
1146 }
1147
1148 static void free_a_slot(struct acpi_php_slot *aps)
1149 {
1150 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);
1151
1152 free_pci_resource (aps->io_head);
1153 free_pci_resource (aps->bus_head);
1154 free_pci_resource (aps->mem_head);
1155 free_pci_resource (aps->p_mem_head);
1156
1157 kfree(aps);
1158 }
1159
1160 static void free_a_bridge( struct acpi_bridge *ab)
1161 {
1162 struct acpi_php_slot *aps, *next;
1163
1164 switch (ab->type) {
1165 case BRIDGE_TYPE_HOST:
1166 dbg("Free ACPI PCI HOST Bridge(%x) [%s] on s:b:d:f(%x:%x:%x:%x)\n",
1167 ab->bus, acpi_path_name(ab->handle), ab->seg, ab->pbus, ab->pdevice, ab->pfunction);
1168 break;
1169 case BRIDGE_TYPE_P2P:
1170 dbg("Free ACPI PCI P2P Bridge(%x-%x) [%s] on s:b:d:f(%x:%x:%x:%x)\n",
1171 ab->pbus, ab->bus, acpi_path_name(ab->handle), ab->seg, ab->pbus, ab->pdevice, ab->pfunction);
1172 break;
1173 };
1174
1175 /* free slots first */
1176 for (aps = ab->slots; aps; aps = next) {
1177 next = aps->next;
1178 free_a_slot(aps);
1179 }
1180
1181 free_pci_resource (ab->io_head);
1182 free_pci_resource (ab->tio_head);
1183 free_pci_resource (ab->bus_head);
1184 free_pci_resource (ab->tbus_head);
1185 free_pci_resource (ab->mem_head);
1186 free_pci_resource (ab->tmem_head);
1187 free_pci_resource (ab->p_mem_head);
1188 free_pci_resource (ab->tp_mem_head);
1189
1190 kfree(ab);
1191 }
1192
1193 static void pciehprm_free_bridges ( struct acpi_bridge *ab)
1194 {
1195 if (!ab)
1196 return;
1197
1198 if (ab->child)
1199 pciehprm_free_bridges (ab->child);
1200
1201 if (ab->next)
1202 pciehprm_free_bridges (ab->next);
1203
1204 free_a_bridge(ab);
1205 }
1206
1207 void pciehprm_cleanup(void)
1208 {
1209 pciehprm_free_bridges (acpi_bridges_head);
1210 }
1211
1212 static int get_number_of_slots (
1213 struct acpi_bridge *ab,
1214 int selfonly
1215 )
1216 {
1217 struct acpi_php_slot *aps;
1218 int prev_slot = -1;
1219 int slot_num = 0;
1220
1221 for ( aps = ab->slots; aps; aps = aps->next)
1222 if (aps->dev != prev_slot) {
1223 prev_slot = aps->dev;
1224 slot_num++;
1225 }
1226
1227 if (ab->child)
1228 slot_num += get_number_of_slots (ab->child, 0);
1229
1230 if (selfonly)
1231 return slot_num;
1232
1233 if (ab->next)
1234 slot_num += get_number_of_slots (ab->next, 0);
1235
1236 return slot_num;
1237 }
1238
1239 static int print_acpi_resources (struct acpi_bridge *ab)
1240 {
1241 struct acpi_php_slot *aps;
1242 int i;
1243
1244 switch (ab->type) {
1245 case BRIDGE_TYPE_HOST:
1246 dbg("PCI HOST Bridge (%x) [%s]\n", ab->bus, acpi_path_name(ab->handle));
1247 break;
1248 case BRIDGE_TYPE_P2P:
1249 dbg("PCI P2P Bridge (%x-%x) [%s]\n", ab->pbus, ab->bus, acpi_path_name(ab->handle));
1250 break;
1251 };
1252
1253 print_pci_resources (ab);
1254
1255 for ( i = -1, aps = ab->slots; aps; aps = aps->next) {
1256 if (aps->dev == i)
1257 continue;
1258 dbg(" Slot sun(%x) s:b:d:f(%02x:%02x:%02x:%02x)\n", aps->sun, aps->seg, aps->bus, aps->dev, aps->fun);
1259 print_slot_resources(aps);
1260 i = aps->dev;
1261 }
1262
1263 if (ab->child)
1264 print_acpi_resources (ab->child);
1265
1266 if (ab->next)
1267 print_acpi_resources (ab->next);
1268
1269 return 0;
1270 }
1271
1272 int pciehprm_print_pirt(void)
1273 {
1274 dbg("PCIEHPRM ACPI Slots\n");
1275 if (acpi_bridges_head)
1276 print_acpi_resources (acpi_bridges_head);
1277
1278 return 0;
1279 }
1280
1281 static struct acpi_php_slot * get_acpi_slot (
1282 struct acpi_bridge *ab,
1283 u32 sun
1284 )
1285 {
1286 struct acpi_php_slot *aps = NULL;
1287
1288 for ( aps = ab->slots; aps; aps = aps->next)
1289 if (aps->sun == sun)
1290 return aps;
1291
1292 if (!aps && ab->child) {
1293 aps = (struct acpi_php_slot *)get_acpi_slot (ab->child, sun);
1294 if (aps)
1295 return aps;
1296 }
1297
1298 if (!aps && ab->next) {
1299 aps = (struct acpi_php_slot *)get_acpi_slot (ab->next, sun);
1300 if (aps)
1301 return aps;
1302 }
1303
1304 return aps;
1305
1306 }
1307
1308 #if 0
1309 void * pciehprm_get_slot(struct slot *slot)
1310 {
1311 struct acpi_bridge *ab = acpi_bridges_head;
1312 struct acpi_php_slot *aps = get_acpi_slot (ab, slot->number);
1313
1314 aps->slot = slot;
1315
1316 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);
1317
1318 return (void *)aps;
1319 }
1320 #endif
1321
1322 static void pciehprm_dump_func_res( struct pci_func *fun)
1323 {
1324 struct pci_func *func = fun;
1325
1326 if (func->bus_head) {
1327 dbg(": BUS Resources:\n");
1328 print_pci_resource (func->bus_head);
1329 }
1330 if (func->io_head) {
1331 dbg(": IO Resources:\n");
1332 print_pci_resource (func->io_head);
1333 }
1334 if (func->mem_head) {
1335 dbg(": MEM Resources:\n");
1336 print_pci_resource (func->mem_head);
1337 }
1338 if (func->p_mem_head) {
1339 dbg(": PMEM Resources:\n");
1340 print_pci_resource (func->p_mem_head);
1341 }
1342 }
1343
1344 static void pciehprm_dump_ctrl_res( struct controller *ctlr)
1345 {
1346 struct controller *ctrl = ctlr;
1347
1348 if (ctrl->bus_head) {
1349 dbg(": BUS Resources:\n");
1350 print_pci_resource (ctrl->bus_head);
1351 }
1352 if (ctrl->io_head) {
1353 dbg(": IO Resources:\n");
1354 print_pci_resource (ctrl->io_head);
1355 }
1356 if (ctrl->mem_head) {
1357 dbg(": MEM Resources:\n");
1358 print_pci_resource (ctrl->mem_head);
1359 }
1360 if (ctrl->p_mem_head) {
1361 dbg(": PMEM Resources:\n");
1362 print_pci_resource (ctrl->p_mem_head);
1363 }
1364 }
1365
1366 static int pciehprm_get_used_resources (
1367 struct controller *ctrl,
1368 struct pci_func *func
1369 )
1370 {
1371 return pciehp_save_used_resources (ctrl, func, !DISABLE_CARD);
1372 }
1373
1374 static int configure_existing_function(
1375 struct controller *ctrl,
1376 struct pci_func *func
1377 )
1378 {
1379 int rc;
1380
1381 /* see how much resources the func has used. */
1382 rc = pciehprm_get_used_resources (ctrl, func);
1383
1384 if (!rc) {
1385 /* subtract the resources used by the func from ctrl resources */
1386 rc = pciehprm_delete_resources (&ctrl->bus_head, func->bus_head);
1387 rc |= pciehprm_delete_resources (&ctrl->io_head, func->io_head);
1388 rc |= pciehprm_delete_resources (&ctrl->mem_head, func->mem_head);
1389 rc |= pciehprm_delete_resources (&ctrl->p_mem_head, func->p_mem_head);
1390 if (rc)
1391 warn("aCEF: cannot del used resources\n");
1392 } else
1393 err("aCEF: cannot get used resources\n");
1394
1395 return rc;
1396 }
1397
1398 static int bind_pci_resources_to_slots ( struct controller *ctrl)
1399 {
1400 struct pci_func *func, new_func;
1401 int busn = ctrl->slot_bus;
1402 int devn, funn;
1403 u32 vid;
1404
1405 for (devn = 0; devn < 32; devn++) {
1406 for (funn = 0; funn < 8; funn++) {
1407 /*
1408 if (devn == ctrl->device && funn == ctrl->function)
1409 continue;
1410 */
1411 /* find out if this entry is for an occupied slot */
1412 vid = 0xFFFFFFFF;
1413 pci_bus_read_config_dword(ctrl->pci_dev->subordinate, PCI_DEVFN(devn, funn), PCI_VENDOR_ID, &vid);
1414
1415 if (vid != 0xFFFFFFFF) {
1416 dbg("%s: vid = %x\n", __FUNCTION__, vid);
1417 func = pciehp_slot_find(busn, devn, funn);
1418 if (!func) {
1419 memset(&new_func, 0, sizeof(struct pci_func));
1420 new_func.bus = busn;
1421 new_func.device = devn;
1422 new_func.function = funn;
1423 new_func.is_a_board = 1;
1424 configure_existing_function(ctrl, &new_func);
1425 pciehprm_dump_func_res(&new_func);
1426 } else {
1427 configure_existing_function(ctrl, func);
1428 pciehprm_dump_func_res(func);
1429 }
1430 dbg("aCCF:existing PCI 0x%x Func ResourceDump\n", ctrl->bus);
1431 }
1432 }
1433 }
1434
1435 return 0;
1436 }
1437
1438 static int bind_pci_resources(
1439 struct controller *ctrl,
1440 struct acpi_bridge *ab
1441 )
1442 {
1443 int status = 0;
1444
1445 if (ab->bus_head) {
1446 dbg("bapr: BUS Resources add on PCI 0x%x\n", ab->bus);
1447 status = pciehprm_add_resources (&ctrl->bus_head, ab->bus_head);
1448 if (pciehprm_delete_resources (&ab->bus_head, ctrl->bus_head))
1449 warn("bapr: cannot sub BUS Resource on PCI 0x%x\n", ab->bus);
1450 if (status) {
1451 err("bapr: BUS Resource add on PCI 0x%x: fail=0x%x\n", ab->bus, status);
1452 return status;
1453 }
1454 } else
1455 info("bapr: No BUS Resource on PCI 0x%x.\n", ab->bus);
1456
1457 if (ab->io_head) {
1458 dbg("bapr: IO Resources add on PCI 0x%x\n", ab->bus);
1459 status = pciehprm_add_resources (&ctrl->io_head, ab->io_head);
1460 if (pciehprm_delete_resources (&ab->io_head, ctrl->io_head))
1461 warn("bapr: cannot sub IO Resource on PCI 0x%x\n", ab->bus);
1462 if (status) {
1463 err("bapr: IO Resource add on PCI 0x%x: fail=0x%x\n", ab->bus, status);
1464 return status;
1465 }
1466 } else
1467 info("bapr: No IO Resource on PCI 0x%x.\n", ab->bus);
1468
1469 if (ab->mem_head) {
1470 dbg("bapr: MEM Resources add on PCI 0x%x\n", ab->bus);
1471 status = pciehprm_add_resources (&ctrl->mem_head, ab->mem_head);
1472 if (pciehprm_delete_resources (&ab->mem_head, ctrl->mem_head))
1473 warn("bapr: cannot sub MEM Resource on PCI 0x%x\n", ab->bus);
1474 if (status) {
1475 err("bapr: MEM Resource add on PCI 0x%x: fail=0x%x\n", ab->bus, status);
1476 return status;
1477 }
1478 } else
1479 info("bapr: No MEM Resource on PCI 0x%x.\n", ab->bus);
1480
1481 if (ab->p_mem_head) {
1482 dbg("bapr: PMEM Resources add on PCI 0x%x\n", ab->bus);
1483 status = pciehprm_add_resources (&ctrl->p_mem_head, ab->p_mem_head);
1484 if (pciehprm_delete_resources (&ab->p_mem_head, ctrl->p_mem_head))
1485 warn("bapr: cannot sub PMEM Resource on PCI 0x%x\n", ab->bus);
1486 if (status) {
1487 err("bapr: PMEM Resource add on PCI 0x%x: fail=0x%x\n", ab->bus, status);
1488 return status;
1489 }
1490 } else
1491 info("bapr: No PMEM Resource on PCI 0x%x.\n", ab->bus);
1492
1493 return status;
1494 }
1495
1496 static int no_pci_resources( struct acpi_bridge *ab)
1497 {
1498 return !(ab->p_mem_head || ab->mem_head || ab->io_head || ab->bus_head);
1499 }
1500
1501 static int find_pci_bridge_resources (
1502 struct controller *ctrl,
1503 struct acpi_bridge *ab
1504 )
1505 {
1506 int rc = 0;
1507 struct pci_func func;
1508
1509 memset(&func, 0, sizeof(struct pci_func));
1510
1511 func.bus = ab->pbus;
1512 func.device = ab->pdevice;
1513 func.function = ab->pfunction;
1514 func.is_a_board = 1;
1515
1516 /* Get used resources for this PCI bridge */
1517 rc = pciehp_save_used_resources (ctrl, &func, !DISABLE_CARD);
1518
1519 ab->io_head = func.io_head;
1520 ab->mem_head = func.mem_head;
1521 ab->p_mem_head = func.p_mem_head;
1522 ab->bus_head = func.bus_head;
1523 if (ab->bus_head)
1524 pciehprm_delete_resource(&ab->bus_head, ctrl->pci_dev->subordinate->number, 1);
1525
1526 return rc;
1527 }
1528
1529 static int get_pci_resources_from_bridge(
1530 struct controller *ctrl,
1531 struct acpi_bridge *ab
1532 )
1533 {
1534 int rc = 0;
1535
1536 dbg("grfb: Get Resources for PCI 0x%x from actual PCI bridge 0x%x.\n", ctrl->bus, ab->bus);
1537
1538 rc = find_pci_bridge_resources (ctrl, ab);
1539
1540 pciehp_resource_sort_and_combine(&ab->bus_head);
1541 pciehp_resource_sort_and_combine(&ab->io_head);
1542 pciehp_resource_sort_and_combine(&ab->mem_head);
1543 pciehp_resource_sort_and_combine(&ab->p_mem_head);
1544
1545 pciehprm_add_resources (&ab->tbus_head, ab->bus_head);
1546 pciehprm_add_resources (&ab->tio_head, ab->io_head);
1547 pciehprm_add_resources (&ab->tmem_head, ab->mem_head);
1548 pciehprm_add_resources (&ab->tp_mem_head, ab->p_mem_head);
1549
1550 return rc;
1551 }
1552
1553 static int get_pci_resources(
1554 struct controller *ctrl,
1555 struct acpi_bridge *ab
1556 )
1557 {
1558 int rc = 0;
1559
1560 if (no_pci_resources(ab)) {
1561 dbg("spbr:PCI 0x%x has no resources. Get parent resources.\n", ab->bus);
1562 rc = get_pci_resources_from_bridge(ctrl, ab);
1563 }
1564
1565 return rc;
1566 }
1567
1568 /*
1569 * Get resources for this ctrl.
1570 * 1. get total resources from ACPI _CRS or bridge (this ctrl)
1571 * 2. find used resources of existing adapters
1572 * 3. subtract used resources from total resources
1573 */
1574 int pciehprm_find_available_resources( struct controller *ctrl)
1575 {
1576 int rc = 0;
1577 struct acpi_bridge *ab;
1578
1579 ab = find_acpi_bridge_by_bus(acpi_bridges_head, ctrl->seg, ctrl->pci_dev->subordinate->number);
1580 if (!ab) {
1581 err("pfar:cannot locate acpi bridge of PCI 0x%x.\n", ctrl->pci_dev->subordinate->number);
1582 return -1;
1583 }
1584 if (no_pci_resources(ab)) {
1585 rc = get_pci_resources(ctrl, ab);
1586 if (rc) {
1587 err("pfar:cannot get pci resources of PCI 0x%x.\n", ctrl->pci_dev->subordinate->number);
1588 return -1;
1589 }
1590 }
1591
1592 rc = bind_pci_resources(ctrl, ab);
1593 dbg("pfar:pre-Bind PCI 0x%x Ctrl Resource Dump\n", ctrl->pci_dev->subordinate->number);
1594 pciehprm_dump_ctrl_res(ctrl);
1595
1596 bind_pci_resources_to_slots (ctrl);
1597
1598 dbg("pfar:post-Bind PCI 0x%x Ctrl Resource Dump\n", ctrl->pci_dev->subordinate->number);
1599 pciehprm_dump_ctrl_res(ctrl);
1600
1601 return rc;
1602 }
1603
1604 int pciehprm_set_hpp(
1605 struct controller *ctrl,
1606 struct pci_func *func,
1607 u8 card_type
1608 )
1609 {
1610 struct acpi_bridge *ab;
1611 struct pci_bus lpci_bus, *pci_bus;
1612 int rc = 0;
1613 unsigned int devfn;
1614 u8 cls= 0x08; /* default cache line size */
1615 u8 lt = 0x40; /* default latency timer */
1616 u8 ep = 0;
1617 u8 es = 0;
1618
1619 memcpy(&lpci_bus, ctrl->pci_bus, sizeof(lpci_bus));
1620 pci_bus = &lpci_bus;
1621 pci_bus->number = func->bus;
1622 devfn = PCI_DEVFN(func->device, func->function);
1623
1624 ab = find_acpi_bridge_by_bus(acpi_bridges_head, ctrl->seg, ctrl->bus);
1625
1626 if (ab) {
1627 if (ab->_hpp) {
1628 lt = (u8)ab->_hpp->latency_timer;
1629 cls = (u8)ab->_hpp->cache_line_size;
1630 ep = (u8)ab->_hpp->enable_perr;
1631 es = (u8)ab->_hpp->enable_serr;
1632 } else
1633 dbg("_hpp: no _hpp for B/D/F=%#x/%#x/%#x. use default value\n", func->bus, func->device, func->function);
1634 } else
1635 dbg("_hpp: no acpi bridge for B/D/F = %#x/%#x/%#x. use default value\n", func->bus, func->device, func->function);
1636
1637
1638 if (card_type == PCI_HEADER_TYPE_BRIDGE) {
1639 /* set subordinate Latency Timer */
1640 rc |= pci_bus_write_config_byte(pci_bus, devfn, PCI_SEC_LATENCY_TIMER, lt);
1641 }
1642
1643 /* set base Latency Timer */
1644 rc |= pci_bus_write_config_byte(pci_bus, devfn, PCI_LATENCY_TIMER, lt);
1645 dbg(" set latency timer =0x%02x: %x\n", lt, rc);
1646
1647 rc |= pci_bus_write_config_byte(pci_bus, devfn, PCI_CACHE_LINE_SIZE, cls);
1648 dbg(" set cache_line_size=0x%02x: %x\n", cls, rc);
1649
1650 return rc;
1651 }
1652
1653 void pciehprm_enable_card(
1654 struct controller *ctrl,
1655 struct pci_func *func,
1656 u8 card_type)
1657 {
1658 u16 command, cmd, bcommand, bcmd;
1659 struct pci_bus lpci_bus, *pci_bus;
1660 struct acpi_bridge *ab;
1661 unsigned int devfn;
1662 int rc;
1663
1664 memcpy(&lpci_bus, ctrl->pci_bus, sizeof(lpci_bus));
1665 pci_bus = &lpci_bus;
1666 pci_bus->number = func->bus;
1667 devfn = PCI_DEVFN(func->device, func->function);
1668
1669 rc = pci_bus_read_config_word(pci_bus, devfn, PCI_COMMAND, &command);
1670
1671 if (card_type == PCI_HEADER_TYPE_BRIDGE) {
1672 rc = pci_bus_read_config_word(pci_bus, devfn, PCI_BRIDGE_CONTROL, &bcommand);
1673 }
1674
1675 cmd = command = command | PCI_COMMAND_MASTER | PCI_COMMAND_INVALIDATE
1676 | PCI_COMMAND_IO | PCI_COMMAND_MEMORY;
1677 bcmd = bcommand = bcommand | PCI_BRIDGE_CTL_NO_ISA;
1678
1679 ab = find_acpi_bridge_by_bus(acpi_bridges_head, ctrl->seg, ctrl->bus);
1680 if (ab) {
1681 if (ab->_hpp) {
1682 if (ab->_hpp->enable_perr) {
1683 command |= PCI_COMMAND_PARITY;
1684 bcommand |= PCI_BRIDGE_CTL_PARITY;
1685 } else {
1686 command &= ~PCI_COMMAND_PARITY;
1687 bcommand &= ~PCI_BRIDGE_CTL_PARITY;
1688 }
1689 if (ab->_hpp->enable_serr) {
1690 command |= PCI_COMMAND_SERR;
1691 bcommand |= PCI_BRIDGE_CTL_SERR;
1692 } else {
1693 command &= ~PCI_COMMAND_SERR;
1694 bcommand &= ~PCI_BRIDGE_CTL_SERR;
1695 }
1696 } else
1697 dbg("no _hpp for B/D/F = %#x/%#x/%#x.\n", func->bus, func->device, func->function);
1698 } else
1699 dbg("no acpi bridge for B/D/F = %#x/%#x/%#x.\n", func->bus, func->device, func->function);
1700
1701 if (command != cmd) {
1702 rc = pci_bus_write_config_word(pci_bus, devfn, PCI_COMMAND, command);
1703 }
1704 if ((card_type == PCI_HEADER_TYPE_BRIDGE) && (bcommand != bcmd)) {
1705 rc = pci_bus_write_config_word(pci_bus, devfn, PCI_BRIDGE_CONTROL, bcommand);
1706 }
1707 }
MOXA 2.6.9 from sdlinux-moxaart.tgz