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