Pull hp-machvec into release branch
[linux-2.6] / drivers / pci / hotplug / shpchp_ctrl.c
1 /*
2  * Standard Hot Plug Controller Driver
3  *
4  * Copyright (C) 1995,2001 Compaq Computer Corporation
5  * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
6  * Copyright (C) 2001 IBM Corp.
7  * Copyright (C) 2003-2004 Intel Corporation
8  *
9  * All rights reserved.
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or (at
14  * your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful, but
17  * WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
19  * NON INFRINGEMENT.  See the GNU General Public License for more
20  * details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25  *
26  * Send feedback to <greg@kroah.com>, <kristen.c.accardi@intel.com>
27  *
28  */
29
30 #include <linux/config.h>
31 #include <linux/module.h>
32 #include <linux/kernel.h>
33 #include <linux/types.h>
34 #include <linux/slab.h>
35 #include <linux/workqueue.h>
36 #include <linux/interrupt.h>
37 #include <linux/delay.h>
38 #include <linux/wait.h>
39 #include <linux/smp_lock.h>
40 #include <linux/pci.h>
41 #include "shpchp.h"
42 #include "shpchprm.h"
43
44 static u32 configure_new_device(struct controller *ctrl, struct pci_func *func,
45         u8 behind_bridge, struct resource_lists *resources, u8 bridge_bus, u8 bridge_dev);
46 static int configure_new_function( struct controller *ctrl, struct pci_func *func,
47         u8 behind_bridge, struct resource_lists *resources, u8 bridge_bus, u8 bridge_dev);
48 static void interrupt_event_handler(struct controller *ctrl);
49
50 static struct semaphore event_semaphore;        /* mutex for process loop (up if something to process) */
51 static struct semaphore event_exit;             /* guard ensure thread has exited before calling it quits */
52 static int event_finished;
53 static unsigned long pushbutton_pending;        /* = 0 */
54
55 u8 shpchp_disk_irq;
56 u8 shpchp_nic_irq;
57
58 u8 shpchp_handle_attention_button(u8 hp_slot, void *inst_id)
59 {
60         struct controller *ctrl = (struct controller *) inst_id;
61         struct slot *p_slot;
62         u8 rc = 0;
63         u8 getstatus;
64         struct pci_func *func;
65         struct event_info *taskInfo;
66
67         /* Attention Button Change */
68         dbg("shpchp:  Attention button interrupt received.\n");
69         
70         func = shpchp_slot_find(ctrl->slot_bus, (hp_slot + ctrl->slot_device_offset), 0);
71
72         /* This is the structure that tells the worker thread what to do */
73         taskInfo = &(ctrl->event_queue[ctrl->next_event]);
74         p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);
75
76         p_slot->hpc_ops->get_adapter_status(p_slot, &(func->presence_save));
77         p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
78         
79         ctrl->next_event = (ctrl->next_event + 1) % 10;
80         taskInfo->hp_slot = hp_slot;
81
82         rc++;
83
84         /*
85          *  Button pressed - See if need to TAKE ACTION!!!
86          */
87         info("Button pressed on Slot(%d)\n", ctrl->first_slot + hp_slot);
88         taskInfo->event_type = INT_BUTTON_PRESS;
89
90         if ((p_slot->state == BLINKINGON_STATE)
91             || (p_slot->state == BLINKINGOFF_STATE)) {
92                 /* Cancel if we are still blinking; this means that we press the
93                  * attention again before the 5 sec. limit expires to cancel hot-add
94                  * or hot-remove
95                  */
96                 taskInfo->event_type = INT_BUTTON_CANCEL;
97                 info("Button cancel on Slot(%d)\n", ctrl->first_slot + hp_slot);
98         } else if ((p_slot->state == POWERON_STATE)
99                    || (p_slot->state == POWEROFF_STATE)) {
100                 /* Ignore if the slot is on power-on or power-off state; this 
101                  * means that the previous attention button action to hot-add or
102                  * hot-remove is undergoing
103                  */
104                 taskInfo->event_type = INT_BUTTON_IGNORE;
105                 info("Button ignore on Slot(%d)\n", ctrl->first_slot + hp_slot);
106         }
107
108         if (rc)
109                 up(&event_semaphore);   /* signal event thread that new event is posted */
110
111         return 0;
112
113 }
114
115 u8 shpchp_handle_switch_change(u8 hp_slot, void *inst_id)
116 {
117         struct controller *ctrl = (struct controller *) inst_id;
118         struct slot *p_slot;
119         u8 rc = 0;
120         u8 getstatus;
121         struct pci_func *func;
122         struct event_info *taskInfo;
123
124         /* Switch Change */
125         dbg("shpchp:  Switch interrupt received.\n");
126
127         func = shpchp_slot_find(ctrl->slot_bus, (hp_slot + ctrl->slot_device_offset), 0);
128
129         /* This is the structure that tells the worker thread
130          * what to do
131          */
132         taskInfo = &(ctrl->event_queue[ctrl->next_event]);
133         ctrl->next_event = (ctrl->next_event + 1) % 10;
134         taskInfo->hp_slot = hp_slot;
135
136         rc++;
137         p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);
138         p_slot->hpc_ops->get_adapter_status(p_slot, &(func->presence_save));
139         p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
140         dbg("%s: Card present %x Power status %x\n", __FUNCTION__,
141                 func->presence_save, func->pwr_save);
142
143         if (getstatus) {
144                 /*
145                  * Switch opened
146                  */
147                 info("Latch open on Slot(%d)\n", ctrl->first_slot + hp_slot);
148                 func->switch_save = 0;
149                 taskInfo->event_type = INT_SWITCH_OPEN;
150                 if (func->pwr_save && func->presence_save) {
151                         taskInfo->event_type = INT_POWER_FAULT;
152                         err("Surprise Removal of card\n");
153                 }
154         } else {
155                 /*
156                  *  Switch closed
157                  */
158                 info("Latch close on Slot(%d)\n", ctrl->first_slot + hp_slot);
159                 func->switch_save = 0x10;
160                 taskInfo->event_type = INT_SWITCH_CLOSE;
161         }
162
163         if (rc)
164                 up(&event_semaphore);   /* signal event thread that new event is posted */
165
166         return rc;
167 }
168
169 u8 shpchp_handle_presence_change(u8 hp_slot, void *inst_id)
170 {
171         struct controller *ctrl = (struct controller *) inst_id;
172         struct slot *p_slot;
173         u8 rc = 0;
174         /*u8 temp_byte;*/
175         struct pci_func *func;
176         struct event_info *taskInfo;
177
178         /* Presence Change */
179         dbg("shpchp:  Presence/Notify input change.\n");
180
181         func = shpchp_slot_find(ctrl->slot_bus, (hp_slot + ctrl->slot_device_offset), 0);
182
183         /* This is the structure that tells the worker thread
184          * what to do
185          */
186         taskInfo = &(ctrl->event_queue[ctrl->next_event]);
187         ctrl->next_event = (ctrl->next_event + 1) % 10;
188         taskInfo->hp_slot = hp_slot;
189
190         rc++;
191         p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);
192
193         /* 
194          * Save the presence state
195          */
196         p_slot->hpc_ops->get_adapter_status(p_slot, &(func->presence_save));
197         if (func->presence_save) {
198                 /*
199                  * Card Present
200                  */
201                 info("Card present on Slot(%d)\n", ctrl->first_slot + hp_slot);
202                 taskInfo->event_type = INT_PRESENCE_ON;
203         } else {
204                 /*
205                  * Not Present
206                  */
207                 info("Card not present on Slot(%d)\n", ctrl->first_slot + hp_slot);
208                 taskInfo->event_type = INT_PRESENCE_OFF;
209         }
210
211         if (rc)
212                 up(&event_semaphore);   /* signal event thread that new event is posted */
213
214         return rc;
215 }
216
217 u8 shpchp_handle_power_fault(u8 hp_slot, void *inst_id)
218 {
219         struct controller *ctrl = (struct controller *) inst_id;
220         struct slot *p_slot;
221         u8 rc = 0;
222         struct pci_func *func;
223         struct event_info *taskInfo;
224
225         /* Power fault */
226         dbg("shpchp:  Power fault interrupt received.\n");
227
228         func = shpchp_slot_find(ctrl->slot_bus, (hp_slot + ctrl->slot_device_offset), 0);
229
230         /* This is the structure that tells the worker thread
231          * what to do
232          */
233         taskInfo = &(ctrl->event_queue[ctrl->next_event]);
234         ctrl->next_event = (ctrl->next_event + 1) % 10;
235         taskInfo->hp_slot = hp_slot;
236
237         rc++;
238         p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);
239
240         if ( !(p_slot->hpc_ops->query_power_fault(p_slot))) {
241                 /*
242                  * Power fault Cleared
243                  */
244                 info("Power fault cleared on Slot(%d)\n", ctrl->first_slot + hp_slot);
245                 func->status = 0x00;
246                 taskInfo->event_type = INT_POWER_FAULT_CLEAR;
247         } else {
248                 /*
249                  *   Power fault
250                  */
251                 info("Power fault on Slot(%d)\n", ctrl->first_slot + hp_slot);
252                 taskInfo->event_type = INT_POWER_FAULT;
253                 /* set power fault status for this board */
254                 func->status = 0xFF;
255                 info("power fault bit %x set\n", hp_slot);
256         }
257         if (rc)
258                 up(&event_semaphore);   /* signal event thread that new event is posted */
259
260         return rc;
261 }
262
263
264 /*
265  * sort_by_size
266  *
267  * Sorts nodes on the list by their length.
268  * Smallest first.
269  *
270  */
271 static int sort_by_size(struct pci_resource **head)
272 {
273         struct pci_resource *current_res;
274         struct pci_resource *next_res;
275         int out_of_order = 1;
276
277         if (!(*head))
278                 return(1);
279
280         if (!((*head)->next))
281                 return(0);
282
283         while (out_of_order) {
284                 out_of_order = 0;
285
286                 /* Special case for swapping list head */
287                 if (((*head)->next) &&
288                     ((*head)->length > (*head)->next->length)) {
289                         out_of_order++;
290                         current_res = *head;
291                         *head = (*head)->next;
292                         current_res->next = (*head)->next;
293                         (*head)->next = current_res;
294                 }
295
296                 current_res = *head;
297
298                 while (current_res->next && current_res->next->next) {
299                         if (current_res->next->length > current_res->next->next->length) {
300                                 out_of_order++;
301                                 next_res = current_res->next;
302                                 current_res->next = current_res->next->next;
303                                 current_res = current_res->next;
304                                 next_res->next = current_res->next;
305                                 current_res->next = next_res;
306                         } else
307                                 current_res = current_res->next;
308                 }
309         }  /* End of out_of_order loop */
310
311         return(0);
312 }
313
314
315 /*
316  * sort_by_max_size
317  *
318  * Sorts nodes on the list by their length.
319  * Largest first.
320  *
321  */
322 static int sort_by_max_size(struct pci_resource **head)
323 {
324         struct pci_resource *current_res;
325         struct pci_resource *next_res;
326         int out_of_order = 1;
327
328         if (!(*head))
329                 return(1);
330
331         if (!((*head)->next))
332                 return(0);
333
334         while (out_of_order) {
335                 out_of_order = 0;
336
337                 /* Special case for swapping list head */
338                 if (((*head)->next) &&
339                     ((*head)->length < (*head)->next->length)) {
340                         out_of_order++;
341                         current_res = *head;
342                         *head = (*head)->next;
343                         current_res->next = (*head)->next;
344                         (*head)->next = current_res;
345                 }
346
347                 current_res = *head;
348
349                 while (current_res->next && current_res->next->next) {
350                         if (current_res->next->length < current_res->next->next->length) {
351                                 out_of_order++;
352                                 next_res = current_res->next;
353                                 current_res->next = current_res->next->next;
354                                 current_res = current_res->next;
355                                 next_res->next = current_res->next;
356                                 current_res->next = next_res;
357                         } else
358                                 current_res = current_res->next;
359                 }
360         }  /* End of out_of_order loop */
361
362         return(0);
363 }
364
365
366 /*
367  * do_pre_bridge_resource_split
368  *
369  *      Returns zero or one node of resources that aren't in use
370  *
371  */
372 static struct pci_resource *do_pre_bridge_resource_split (struct pci_resource **head, struct pci_resource **orig_head, u32 alignment)
373 {
374         struct pci_resource *prevnode = NULL;
375         struct pci_resource *node;
376         struct pci_resource *split_node;
377         u32 rc;
378         u32 temp_dword;
379         dbg("do_pre_bridge_resource_split\n");
380
381         if (!(*head) || !(*orig_head))
382                 return(NULL);
383
384         rc = shpchp_resource_sort_and_combine(head);
385
386         if (rc)
387                 return(NULL);
388
389         if ((*head)->base != (*orig_head)->base)
390                 return(NULL);
391
392         if ((*head)->length == (*orig_head)->length)
393                 return(NULL);
394
395
396         /* If we got here, there the bridge requires some of the resource, but
397          *  we may be able to split some off of the front
398          */     
399         node = *head;
400
401         if (node->length & (alignment -1)) {
402                 /* This one isn't an aligned length, so we'll make a new entry
403                  * and split it up.
404                  */
405                 split_node = kmalloc(sizeof(*split_node), GFP_KERNEL);
406
407                 if (!split_node)
408                         return(NULL);
409
410                 temp_dword = (node->length | (alignment-1)) + 1 - alignment;
411
412                 split_node->base = node->base;
413                 split_node->length = temp_dword;
414
415                 node->length -= temp_dword;
416                 node->base += split_node->length;
417
418                 /* Put it in the list */
419                 *head = split_node;
420                 split_node->next = node;
421         }
422
423         if (node->length < alignment) {
424                 return(NULL);
425         }
426
427         /* Now unlink it */
428         if (*head == node) {
429                 *head = node->next;
430                 node->next = NULL;
431         } else {
432                 prevnode = *head;
433                 while (prevnode->next != node)
434                         prevnode = prevnode->next;
435
436                 prevnode->next = node->next;
437                 node->next = NULL;
438         }
439
440         return(node);
441 }
442
443
444 /*
445  * do_bridge_resource_split
446  *
447  *      Returns zero or one node of resources that aren't in use
448  *
449  */
450 static struct pci_resource *do_bridge_resource_split (struct pci_resource **head, u32 alignment)
451 {
452         struct pci_resource *prevnode = NULL;
453         struct pci_resource *node;
454         u32 rc;
455         u32 temp_dword;
456
457         if (!(*head))
458                 return(NULL);
459
460         rc = shpchp_resource_sort_and_combine(head);
461
462         if (rc)
463                 return(NULL);
464
465         node = *head;
466
467         while (node->next) {
468                 prevnode = node;
469                 node = node->next;
470                 kfree(prevnode);
471         }
472
473         if (node->length < alignment) {
474                 kfree(node);
475                 return(NULL);
476         }
477
478         if (node->base & (alignment - 1)) {
479                 /* Short circuit if adjusted size is too small */
480                 temp_dword = (node->base | (alignment-1)) + 1;
481                 if ((node->length - (temp_dword - node->base)) < alignment) {
482                         kfree(node);
483                         return(NULL);
484                 }
485
486                 node->length -= (temp_dword - node->base);
487                 node->base = temp_dword;
488         }
489
490         if (node->length & (alignment - 1)) {
491                 /* There's stuff in use after this node */
492                 kfree(node);
493                 return(NULL);
494         }
495
496         return(node);
497 }
498
499
500 /*
501  * get_io_resource
502  *
503  * this function sorts the resource list by size and then
504  * returns the first node of "size" length that is not in the
505  * ISA aliasing window.  If it finds a node larger than "size"
506  * it will split it up.
507  *
508  * size must be a power of two.
509  */
510 static struct pci_resource *get_io_resource (struct pci_resource **head, u32 size)
511 {
512         struct pci_resource *prevnode;
513         struct pci_resource *node;
514         struct pci_resource *split_node = NULL;
515         u32 temp_dword;
516
517         if (!(*head))
518                 return(NULL);
519
520         if ( shpchp_resource_sort_and_combine(head) )
521                 return(NULL);
522
523         if ( sort_by_size(head) )
524                 return(NULL);
525
526         for (node = *head; node; node = node->next) {
527                 if (node->length < size)
528                         continue;
529
530                 if (node->base & (size - 1)) {
531                         /* This one isn't base aligned properly
532                            so we'll make a new entry and split it up */
533                         temp_dword = (node->base | (size-1)) + 1;
534
535                         /*/ Short circuit if adjusted size is too small */
536                         if ((node->length - (temp_dword - node->base)) < size)
537                                 continue;
538
539                         split_node = kmalloc(sizeof(*split_node), GFP_KERNEL);
540
541                         if (!split_node)
542                                 return(NULL);
543
544                         split_node->base = node->base;
545                         split_node->length = temp_dword - node->base;
546                         node->base = temp_dword;
547                         node->length -= split_node->length;
548
549                         /* Put it in the list */
550                         split_node->next = node->next;
551                         node->next = split_node;
552                 } /* End of non-aligned base */
553
554                 /* Don't need to check if too small since we already did */
555                 if (node->length > size) {
556                         /* This one is longer than we need
557                            so we'll make a new entry and split it up */
558                         split_node = kmalloc(sizeof(*split_node), GFP_KERNEL);
559
560                         if (!split_node)
561                                 return(NULL);
562
563                         split_node->base = node->base + size;
564                         split_node->length = node->length - size;
565                         node->length = size;
566
567                         /* Put it in the list */
568                         split_node->next = node->next;
569                         node->next = split_node;
570                 }  /* End of too big on top end */
571
572                 /* For IO make sure it's not in the ISA aliasing space */
573                 if (node->base & 0x300L)
574                         continue;
575
576                 /* If we got here, then it is the right size 
577                    Now take it out of the list */
578                 if (*head == node) {
579                         *head = node->next;
580                 } else {
581                         prevnode = *head;
582                         while (prevnode->next != node)
583                                 prevnode = prevnode->next;
584
585                         prevnode->next = node->next;
586                 }
587                 node->next = NULL;
588                 /* Stop looping */
589                 break;
590         }
591
592         return(node);
593 }
594
595
596 /*
597  * get_max_resource
598  *
599  * Gets the largest node that is at least "size" big from the
600  * list pointed to by head.  It aligns the node on top and bottom
601  * to "size" alignment before returning it.
602  * J.I. modified to put max size limits of; 64M->32M->16M->8M->4M->1M
603  *  This is needed to avoid allocating entire ACPI _CRS res to one child bridge/slot.
604  */
605 static struct pci_resource *get_max_resource (struct pci_resource **head, u32 size)
606 {
607         struct pci_resource *max;
608         struct pci_resource *temp;
609         struct pci_resource *split_node;
610         u32 temp_dword;
611         u32 max_size[] = { 0x4000000, 0x2000000, 0x1000000, 0x0800000, 0x0400000, 0x0200000, 0x0100000, 0x00 };
612         int i;
613
614         if (!(*head))
615                 return(NULL);
616
617         if (shpchp_resource_sort_and_combine(head))
618                 return(NULL);
619
620         if (sort_by_max_size(head))
621                 return(NULL);
622
623         for (max = *head;max; max = max->next) {
624
625                 /* If not big enough we could probably just bail, 
626                    instead we'll continue to the next. */
627                 if (max->length < size)
628                         continue;
629
630                 if (max->base & (size - 1)) {
631                         /* This one isn't base aligned properly
632                            so we'll make a new entry and split it up */
633                         temp_dword = (max->base | (size-1)) + 1;
634
635                         /* Short circuit if adjusted size is too small */
636                         if ((max->length - (temp_dword - max->base)) < size)
637                                 continue;
638
639                         split_node = kmalloc(sizeof(*split_node), GFP_KERNEL);
640
641                         if (!split_node)
642                                 return(NULL);
643
644                         split_node->base = max->base;
645                         split_node->length = temp_dword - max->base;
646                         max->base = temp_dword;
647                         max->length -= split_node->length;
648
649                         /* Put it next in the list */
650                         split_node->next = max->next;
651                         max->next = split_node;
652                 }
653
654                 if ((max->base + max->length) & (size - 1)) {
655                         /* This one isn't end aligned properly at the top
656                            so we'll make a new entry and split it up */
657                         split_node = kmalloc(sizeof(*split_node), GFP_KERNEL);
658
659                         if (!split_node)
660                                 return(NULL);
661                         temp_dword = ((max->base + max->length) & ~(size - 1));
662                         split_node->base = temp_dword;
663                         split_node->length = max->length + max->base
664                                              - split_node->base;
665                         max->length -= split_node->length;
666
667                         /* Put it in the list */
668                         split_node->next = max->next;
669                         max->next = split_node;
670                 }
671
672                 /* Make sure it didn't shrink too much when we aligned it */
673                 if (max->length < size)
674                         continue;
675
676                 for ( i = 0; max_size[i] > size; i++) {
677                         if (max->length > max_size[i]) {
678                                 split_node = kmalloc(sizeof(*split_node),
679                                                         GFP_KERNEL);
680                                 if (!split_node)
681                                         break;  /* return (NULL); */
682                                 split_node->base = max->base + max_size[i];
683                                 split_node->length = max->length - max_size[i];
684                                 max->length = max_size[i];
685                                 /* Put it next in the list */
686                                 split_node->next = max->next;
687                                 max->next = split_node;
688                                 break;
689                         }
690                 }
691
692                 /* Now take it out of the list */
693                 temp = (struct pci_resource*) *head;
694                 if (temp == max) {
695                         *head = max->next;
696                 } else {
697                         while (temp && temp->next != max) {
698                                 temp = temp->next;
699                         }
700
701                         temp->next = max->next;
702                 }
703
704                 max->next = NULL;
705                 return(max);
706         }
707
708         /* If we get here, we couldn't find one */
709         return(NULL);
710 }
711
712
713 /*
714  * get_resource
715  *
716  * this function sorts the resource list by size and then
717  * returns the first node of "size" length.  If it finds a node
718  * larger than "size" it will split it up.
719  *
720  * size must be a power of two.
721  */
722 static struct pci_resource *get_resource (struct pci_resource **head, u32 size)
723 {
724         struct pci_resource *prevnode;
725         struct pci_resource *node;
726         struct pci_resource *split_node;
727         u32 temp_dword;
728
729         if (!(*head))
730                 return(NULL);
731
732         if ( shpchp_resource_sort_and_combine(head) )
733                 return(NULL);
734
735         if ( sort_by_size(head) )
736                 return(NULL);
737
738         for (node = *head; node; node = node->next) {
739                 dbg("%s: req_size =0x%x node=%p, base=0x%x, length=0x%x\n",
740                     __FUNCTION__, size, node, node->base, node->length);
741                 if (node->length < size)
742                         continue;
743
744                 if (node->base & (size - 1)) {
745                         dbg("%s: not aligned\n", __FUNCTION__);
746                         /* this one isn't base aligned properly
747                            so we'll make a new entry and split it up */
748                         temp_dword = (node->base | (size-1)) + 1;
749
750                         /* Short circuit if adjusted size is too small */
751                         if ((node->length - (temp_dword - node->base)) < size)
752                                 continue;
753
754                         split_node = kmalloc(sizeof(*split_node), GFP_KERNEL);
755
756                         if (!split_node)
757                                 return(NULL);
758
759                         split_node->base = node->base;
760                         split_node->length = temp_dword - node->base;
761                         node->base = temp_dword;
762                         node->length -= split_node->length;
763
764                         /* Put it in the list */
765                         split_node->next = node->next;
766                         node->next = split_node;
767                 } /* End of non-aligned base */
768
769                 /* Don't need to check if too small since we already did */
770                 if (node->length > size) {
771                         dbg("%s: too big\n", __FUNCTION__);
772                         /* this one is longer than we need
773                            so we'll make a new entry and split it up */
774                         split_node = kmalloc(sizeof(*split_node), GFP_KERNEL);
775
776                         if (!split_node)
777                                 return(NULL);
778
779                         split_node->base = node->base + size;
780                         split_node->length = node->length - size;
781                         node->length = size;
782
783                         /* Put it in the list */
784                         split_node->next = node->next;
785                         node->next = split_node;
786                 }  /* End of too big on top end */
787
788                 dbg("%s: got one!!!\n", __FUNCTION__);
789                 /* If we got here, then it is the right size
790                    Now take it out of the list */
791                 if (*head == node) {
792                         *head = node->next;
793                 } else {
794                         prevnode = *head;
795                         while (prevnode->next != node)
796                                 prevnode = prevnode->next;
797
798                         prevnode->next = node->next;
799                 }
800                 node->next = NULL;
801                 /* Stop looping */
802                 break;
803         }
804         return(node);
805 }
806
807
808 /*
809  * shpchp_resource_sort_and_combine
810  *
811  * Sorts all of the nodes in the list in ascending order by
812  * their base addresses.  Also does garbage collection by
813  * combining adjacent nodes.
814  *
815  * returns 0 if success
816  */
817 int shpchp_resource_sort_and_combine(struct pci_resource **head)
818 {
819         struct pci_resource *node1;
820         struct pci_resource *node2;
821         int out_of_order = 1;
822
823         dbg("%s: head = %p, *head = %p\n", __FUNCTION__, head, *head);
824
825         if (!(*head))
826                 return(1);
827
828         dbg("*head->next = %p\n",(*head)->next);
829
830         if (!(*head)->next)
831                 return(0);      /* only one item on the list, already sorted! */
832
833         dbg("*head->base = 0x%x\n",(*head)->base);
834         dbg("*head->next->base = 0x%x\n",(*head)->next->base);
835         while (out_of_order) {
836                 out_of_order = 0;
837
838                 /* Special case for swapping list head */
839                 if (((*head)->next) &&
840                     ((*head)->base > (*head)->next->base)) {
841                         node1 = *head;
842                         (*head) = (*head)->next;
843                         node1->next = (*head)->next;
844                         (*head)->next = node1;
845                         out_of_order++;
846                 }
847
848                 node1 = (*head);
849
850                 while (node1->next && node1->next->next) {
851                         if (node1->next->base > node1->next->next->base) {
852                                 out_of_order++;
853                                 node2 = node1->next;
854                                 node1->next = node1->next->next;
855                                 node1 = node1->next;
856                                 node2->next = node1->next;
857                                 node1->next = node2;
858                         } else
859                                 node1 = node1->next;
860                 }
861         }  /* End of out_of_order loop */
862
863         node1 = *head;
864
865         while (node1 && node1->next) {
866                 if ((node1->base + node1->length) == node1->next->base) {
867                         /* Combine */
868                         dbg("8..\n");
869                         node1->length += node1->next->length;
870                         node2 = node1->next;
871                         node1->next = node1->next->next;
872                         kfree(node2);
873                 } else
874                         node1 = node1->next;
875         }
876
877         return(0);
878 }
879
880
881 /**
882  * shpchp_slot_create - Creates a node and adds it to the proper bus.
883  * @busnumber - bus where new node is to be located
884  *
885  * Returns pointer to the new node or NULL if unsuccessful
886  */
887 struct pci_func *shpchp_slot_create(u8 busnumber)
888 {
889         struct pci_func *new_slot;
890         struct pci_func *next;
891
892         new_slot = kmalloc(sizeof(*new_slot), GFP_KERNEL);
893
894         if (new_slot == NULL) {
895                 return(new_slot);
896         }
897
898         memset(new_slot, 0, sizeof(struct pci_func));
899
900         new_slot->next = NULL;
901         new_slot->configured = 1;
902
903         if (shpchp_slot_list[busnumber] == NULL) {
904                 shpchp_slot_list[busnumber] = new_slot;
905         } else {
906                 next = shpchp_slot_list[busnumber];
907                 while (next->next != NULL)
908                         next = next->next;
909                 next->next = new_slot;
910         }
911         return(new_slot);
912 }
913
914
915 /*
916  * slot_remove - Removes a node from the linked list of slots.
917  * @old_slot: slot to remove
918  *
919  * Returns 0 if successful, !0 otherwise.
920  */
921 static int slot_remove(struct pci_func * old_slot)
922 {
923         struct pci_func *next;
924
925         if (old_slot == NULL)
926                 return(1);
927
928         next = shpchp_slot_list[old_slot->bus];
929
930         if (next == NULL) {
931                 return(1);
932         }
933
934         if (next == old_slot) {
935                 shpchp_slot_list[old_slot->bus] = old_slot->next;
936                 shpchp_destroy_board_resources(old_slot);
937                 kfree(old_slot);
938                 return(0);
939         }
940
941         while ((next->next != old_slot) && (next->next != NULL)) {
942                 next = next->next;
943         }
944
945         if (next->next == old_slot) {
946                 next->next = old_slot->next;
947                 shpchp_destroy_board_resources(old_slot);
948                 kfree(old_slot);
949                 return(0);
950         } else
951                 return(2);
952 }
953
954
955 /**
956  * bridge_slot_remove - Removes a node from the linked list of slots.
957  * @bridge: bridge to remove
958  *
959  * Returns 0 if successful, !0 otherwise.
960  */
961 static int bridge_slot_remove(struct pci_func *bridge)
962 {
963         u8 subordinateBus, secondaryBus;
964         u8 tempBus;
965         struct pci_func *next;
966
967         if (bridge == NULL)
968                 return(1);
969
970         secondaryBus = (bridge->config_space[0x06] >> 8) & 0xFF;
971         subordinateBus = (bridge->config_space[0x06] >> 16) & 0xFF;
972
973         for (tempBus = secondaryBus; tempBus <= subordinateBus; tempBus++) {
974                 next = shpchp_slot_list[tempBus];
975
976                 while (!slot_remove(next)) {
977                         next = shpchp_slot_list[tempBus];
978                 }
979         }
980
981         next = shpchp_slot_list[bridge->bus];
982
983         if (next == NULL) {
984                 return(1);
985         }
986
987         if (next == bridge) {
988                 shpchp_slot_list[bridge->bus] = bridge->next;
989                 kfree(bridge);
990                 return(0);
991         }
992
993         while ((next->next != bridge) && (next->next != NULL)) {
994                 next = next->next;
995         }
996
997         if (next->next == bridge) {
998                 next->next = bridge->next;
999                 kfree(bridge);
1000                 return(0);
1001         } else
1002                 return(2);
1003 }
1004
1005
1006 /**
1007  * shpchp_slot_find - Looks for a node by bus, and device, multiple functions accessed
1008  * @bus: bus to find
1009  * @device: device to find
1010  * @index: is 0 for first function found, 1 for the second...
1011  *
1012  * Returns pointer to the node if successful, %NULL otherwise.
1013  */
1014 struct pci_func *shpchp_slot_find(u8 bus, u8 device, u8 index)
1015 {
1016         int found = -1;
1017         struct pci_func *func;
1018
1019         func = shpchp_slot_list[bus];
1020
1021         if ((func == NULL) || ((func->device == device) && (index == 0)))
1022                 return(func);
1023
1024         if (func->device == device)
1025                 found++;
1026
1027         while (func->next != NULL) {
1028                 func = func->next;
1029
1030                 if (func->device == device)
1031                         found++;
1032
1033                 if (found == index)
1034                         return(func);
1035         }
1036
1037         return(NULL);
1038 }
1039
1040 static int is_bridge(struct pci_func * func)
1041 {
1042         /* Check the header type */
1043         if (((func->config_space[0x03] >> 16) & 0xFF) == 0x01)
1044                 return 1;
1045         else
1046                 return 0;
1047 }
1048
1049
1050 /* The following routines constitute the bulk of the 
1051    hotplug controller logic
1052  */
1053 static u32 change_bus_speed(struct controller *ctrl, struct slot *p_slot, enum pci_bus_speed speed)
1054
1055         u32 rc = 0;
1056
1057         dbg("%s: change to speed %d\n", __FUNCTION__, speed);
1058         down(&ctrl->crit_sect);
1059         if ((rc = p_slot->hpc_ops->set_bus_speed_mode(p_slot, speed))) {
1060                 err("%s: Issue of set bus speed mode command failed\n", __FUNCTION__);
1061                 up(&ctrl->crit_sect);
1062                 return WRONG_BUS_FREQUENCY;
1063         }
1064         wait_for_ctrl_irq (ctrl);
1065                 
1066         if ((rc = p_slot->hpc_ops->check_cmd_status(ctrl))) {
1067                 err("%s: Can't set bus speed/mode in the case of adapter & bus mismatch\n",
1068                           __FUNCTION__);
1069                 err("%s: Error code (%d)\n", __FUNCTION__, rc);
1070                 up(&ctrl->crit_sect);
1071                 return WRONG_BUS_FREQUENCY;
1072         }
1073         up(&ctrl->crit_sect);
1074         return rc;
1075 }
1076
1077 static u32 fix_bus_speed(struct controller *ctrl, struct slot *pslot, u8 flag, 
1078 enum pci_bus_speed asp, enum pci_bus_speed bsp, enum pci_bus_speed msp)
1079
1080         u32 rc = 0;
1081         
1082         if (flag != 0) { /* Other slots on the same bus are occupied */
1083                 if ( asp < bsp ) {
1084                         err("%s: speed of bus %x and adapter %x mismatch\n", __FUNCTION__, bsp, asp);
1085                         return WRONG_BUS_FREQUENCY;
1086                 }
1087         } else {
1088                 /* Other slots on the same bus are empty */
1089                 if (msp == bsp) {
1090                 /* if adapter_speed >= bus_speed, do nothing */
1091                         if (asp < bsp) {
1092                                 /* 
1093                                 * Try to lower bus speed to accommodate the adapter if other slots 
1094                                 * on the same controller are empty
1095                                 */
1096                                 if ((rc = change_bus_speed(ctrl, pslot, asp)))
1097                                         return rc;
1098                         } 
1099                 } else {
1100                         if (asp < msp) {
1101                                 if ((rc = change_bus_speed(ctrl, pslot, asp)))
1102                                         return rc;
1103                         } else {
1104                                 if ((rc = change_bus_speed(ctrl, pslot, msp)))
1105                                         return rc;
1106                         }
1107                 }
1108         }
1109         return rc;
1110 }
1111
1112 /**
1113  * board_added - Called after a board has been added to the system.
1114  *
1115  * Turns power on for the board
1116  * Configures board
1117  *
1118  */
1119 static u32 board_added(struct pci_func * func, struct controller * ctrl)
1120 {
1121         u8 hp_slot;
1122         u8 slots_not_empty = 0;
1123         int index;
1124         u32 temp_register = 0xFFFFFFFF;
1125         u32 retval, rc = 0;
1126         struct pci_func *new_func = NULL;
1127         struct slot *p_slot;
1128         struct resource_lists res_lists;
1129         enum pci_bus_speed adapter_speed, bus_speed, max_bus_speed;
1130         u8 pi, mode;
1131
1132         p_slot = shpchp_find_slot(ctrl, func->device);
1133         hp_slot = func->device - ctrl->slot_device_offset;
1134
1135         dbg("%s: func->device, slot_offset, hp_slot = %d, %d ,%d\n", __FUNCTION__, func->device, ctrl->slot_device_offset, hp_slot);
1136
1137         /* Wait for exclusive access to hardware */
1138         down(&ctrl->crit_sect);
1139
1140         /* Power on slot without connecting to bus */
1141         rc = p_slot->hpc_ops->power_on_slot(p_slot);
1142         if (rc) {
1143                 err("%s: Failed to power on slot\n", __FUNCTION__);
1144                 /* Done with exclusive hardware access */
1145                 up(&ctrl->crit_sect);
1146                 return -1;
1147         }
1148                         
1149         /* Wait for the command to complete */
1150         wait_for_ctrl_irq (ctrl);
1151         
1152         rc = p_slot->hpc_ops->check_cmd_status(ctrl);
1153         if (rc) {
1154                 err("%s: Failed to power on slot, error code(%d)\n", __FUNCTION__, rc);
1155                 /* Done with exclusive hardware access */
1156                 up(&ctrl->crit_sect);
1157                 return -1;
1158         }
1159
1160         
1161         if ((ctrl->pci_dev->vendor == 0x8086) && (ctrl->pci_dev->device == 0x0332)) {
1162                 if (slots_not_empty)
1163                         return WRONG_BUS_FREQUENCY;
1164                 
1165                 if ((rc = p_slot->hpc_ops->set_bus_speed_mode(p_slot, PCI_SPEED_33MHz))) {
1166                         err("%s: Issue of set bus speed mode command failed\n", __FUNCTION__);
1167                         up(&ctrl->crit_sect);
1168                         return WRONG_BUS_FREQUENCY;
1169                 }
1170                 wait_for_ctrl_irq (ctrl);
1171                 
1172                 if ((rc = p_slot->hpc_ops->check_cmd_status(ctrl))) {
1173                         err("%s: Can't set bus speed/mode in the case of adapter & bus mismatch\n",
1174                                   __FUNCTION__);
1175                         err("%s: Error code (%d)\n", __FUNCTION__, rc);
1176                         up(&ctrl->crit_sect);
1177                         return WRONG_BUS_FREQUENCY;
1178                 }
1179                 /* turn on board, blink green LED, turn off Amber LED */
1180                 if ((rc = p_slot->hpc_ops->slot_enable(p_slot))) {
1181                         err("%s: Issue of Slot Enable command failed\n", __FUNCTION__);
1182                         up(&ctrl->crit_sect);
1183                         return rc;
1184                 }
1185                 wait_for_ctrl_irq (ctrl);
1186
1187                 if ((rc = p_slot->hpc_ops->check_cmd_status(ctrl))) {
1188                         err("%s: Failed to enable slot, error code(%d)\n", __FUNCTION__, rc);
1189                         up(&ctrl->crit_sect);
1190                         return rc;  
1191                 }
1192         }
1193  
1194         rc = p_slot->hpc_ops->get_adapter_speed(p_slot, &adapter_speed);
1195         /* 0 = PCI 33Mhz, 1 = PCI 66 Mhz, 2 = PCI-X 66 PA, 4 = PCI-X 66 ECC, */
1196         /* 5 = PCI-X 133 PA, 7 = PCI-X 133 ECC,  0xa = PCI-X 133 Mhz 266, */
1197         /* 0xd = PCI-X 133 Mhz 533 */
1198         /* This encoding is different from the one used in cur_bus_speed & */
1199         /* max_bus_speed */
1200
1201         if (rc  || adapter_speed == PCI_SPEED_UNKNOWN) {
1202                 err("%s: Can't get adapter speed or bus mode mismatch\n", __FUNCTION__);
1203                 /* Done with exclusive hardware access */
1204                 up(&ctrl->crit_sect);
1205                 return WRONG_BUS_FREQUENCY;
1206         }
1207
1208         rc = p_slot->hpc_ops->get_cur_bus_speed(p_slot, &bus_speed);
1209         if (rc || bus_speed == PCI_SPEED_UNKNOWN) {
1210                 err("%s: Can't get bus operation speed\n", __FUNCTION__);
1211                 /* Done with exclusive hardware access */
1212                 up(&ctrl->crit_sect);
1213                 return WRONG_BUS_FREQUENCY;
1214         }
1215
1216         rc = p_slot->hpc_ops->get_max_bus_speed(p_slot, &max_bus_speed);
1217         if (rc || max_bus_speed == PCI_SPEED_UNKNOWN) {
1218                 err("%s: Can't get max bus operation speed\n", __FUNCTION__);
1219                 max_bus_speed = bus_speed;
1220         }
1221
1222         /* Done with exclusive hardware access */
1223         up(&ctrl->crit_sect);
1224
1225         if ((rc  = p_slot->hpc_ops->get_prog_int(p_slot, &pi))) {
1226                 err("%s: Can't get controller programming interface, set it to 1\n", __FUNCTION__);
1227                 pi = 1;
1228         }
1229
1230         /* Check if there are other slots or devices on the same bus */
1231         if (!list_empty(&ctrl->pci_dev->subordinate->devices))
1232                 slots_not_empty = 1;
1233
1234         dbg("%s: slots_not_empty %d, pi %d\n", __FUNCTION__, 
1235                 slots_not_empty, pi);
1236         dbg("adapter_speed %d, bus_speed %d, max_bus_speed %d\n", 
1237                 adapter_speed, bus_speed, max_bus_speed);
1238
1239         if (pi == 2) {
1240                 dbg("%s: In PI = %d\n", __FUNCTION__, pi);
1241                 if ((rc = p_slot->hpc_ops->get_mode1_ECC_cap(p_slot, &mode))) {
1242                         err("%s: Can't get Mode1_ECC, set mode to 0\n", __FUNCTION__);
1243                         mode = 0;
1244                 }
1245
1246                 switch (adapter_speed) {
1247                 case PCI_SPEED_133MHz_PCIX_533:
1248                 case PCI_SPEED_133MHz_PCIX_266:
1249                         if ((bus_speed != adapter_speed) &&
1250                            ((rc = fix_bus_speed(ctrl, p_slot, slots_not_empty, adapter_speed, bus_speed, max_bus_speed)))) 
1251                                 return rc;
1252                         break;  
1253                 case PCI_SPEED_133MHz_PCIX_ECC:
1254                 case PCI_SPEED_133MHz_PCIX:
1255                         if (mode) { /* Bus - Mode 1 ECC */
1256                                 if ((bus_speed != 0x7) &&
1257                                    ((rc = fix_bus_speed(ctrl, p_slot, slots_not_empty, adapter_speed, bus_speed, max_bus_speed)))) 
1258                                         return rc;
1259                         } else {
1260                                 if ((bus_speed != 0x4) &&
1261                                    ((rc = fix_bus_speed(ctrl, p_slot, slots_not_empty, adapter_speed, bus_speed, max_bus_speed)))) 
1262                                         return rc;
1263                         }
1264                         break;
1265                 case PCI_SPEED_66MHz_PCIX_ECC:
1266                 case PCI_SPEED_66MHz_PCIX:
1267                         if (mode) { /* Bus - Mode 1 ECC */
1268                                 if ((bus_speed != 0x5) &&
1269                                    ((rc = fix_bus_speed(ctrl, p_slot, slots_not_empty, adapter_speed, bus_speed, max_bus_speed)))) 
1270                                         return rc;
1271                         } else {
1272                                 if ((bus_speed != 0x2) &&
1273                                    ((rc = fix_bus_speed(ctrl, p_slot, slots_not_empty, adapter_speed, bus_speed, max_bus_speed)))) 
1274                                         return rc;
1275                         }
1276                         break;
1277                 case PCI_SPEED_66MHz:
1278                         if ((bus_speed != 0x1) &&
1279                            ((rc = fix_bus_speed(ctrl, p_slot, slots_not_empty, adapter_speed, bus_speed, max_bus_speed)))) 
1280                                 return rc;
1281                         break;  
1282                 case PCI_SPEED_33MHz:
1283                         if (bus_speed > 0x0) {
1284                                 if (slots_not_empty == 0) {
1285                                         if ((rc = change_bus_speed(ctrl, p_slot, adapter_speed)))
1286                                                 return rc;
1287                                 } else {
1288                                         err("%s: speed of bus %x and adapter %x mismatch\n", __FUNCTION__, bus_speed, adapter_speed);
1289                                         return WRONG_BUS_FREQUENCY;
1290                                 }
1291                         }
1292                         break;
1293                 default:
1294                         err("%s: speed of bus %x and adapter %x mismatch\n", __FUNCTION__, bus_speed, adapter_speed);
1295                         return WRONG_BUS_FREQUENCY;
1296                 }
1297         } else {
1298                 /* If adpater_speed == bus_speed, nothing to do here */
1299                 dbg("%s: In PI = %d\n", __FUNCTION__, pi);
1300                 if ((adapter_speed != bus_speed) &&
1301                    ((rc = fix_bus_speed(ctrl, p_slot, slots_not_empty, adapter_speed, bus_speed, max_bus_speed))))
1302                                 return rc;
1303         }
1304
1305         down(&ctrl->crit_sect);
1306         /* turn on board, blink green LED, turn off Amber LED */
1307         if ((rc = p_slot->hpc_ops->slot_enable(p_slot))) {
1308                 err("%s: Issue of Slot Enable command failed\n", __FUNCTION__);
1309                 up(&ctrl->crit_sect);
1310                 return rc;
1311         }
1312         wait_for_ctrl_irq (ctrl);
1313
1314         if ((rc = p_slot->hpc_ops->check_cmd_status(ctrl))) {
1315                 err("%s: Failed to enable slot, error code(%d)\n", __FUNCTION__, rc);
1316                 up(&ctrl->crit_sect);
1317                 return rc;  
1318         }
1319
1320         up(&ctrl->crit_sect);
1321
1322         /* Wait for ~1 second */
1323         dbg("%s: before long_delay\n", __FUNCTION__);
1324         wait_for_ctrl_irq (ctrl);
1325         dbg("%s: after long_delay\n", __FUNCTION__);
1326
1327         dbg("%s: func status = %x\n", __FUNCTION__, func->status);
1328         /* Check for a power fault */
1329         if (func->status == 0xFF) {
1330                 /* power fault occurred, but it was benign */
1331                 temp_register = 0xFFFFFFFF;
1332                 dbg("%s: temp register set to %x by power fault\n", __FUNCTION__, temp_register);
1333                 rc = POWER_FAILURE;
1334                 func->status = 0;
1335         } else {
1336                 /* Get vendor/device ID u32 */
1337                 rc = pci_bus_read_config_dword (ctrl->pci_dev->subordinate, PCI_DEVFN(func->device, func->function), 
1338                         PCI_VENDOR_ID, &temp_register);
1339                 dbg("%s: pci_bus_read_config_dword returns %d\n", __FUNCTION__, rc);
1340                 dbg("%s: temp_register is %x\n", __FUNCTION__, temp_register);
1341
1342                 if (rc != 0) {
1343                         /* Something's wrong here */
1344                         temp_register = 0xFFFFFFFF;
1345                         dbg("%s: temp register set to %x by error\n", __FUNCTION__, temp_register);
1346                 }
1347                 /* Preset return code.  It will be changed later if things go okay. */
1348                 rc = NO_ADAPTER_PRESENT;
1349         }
1350
1351         /* All F's is an empty slot or an invalid board */
1352         if (temp_register != 0xFFFFFFFF) {        /* Check for a board in the slot */
1353                 res_lists.io_head = ctrl->io_head;
1354                 res_lists.mem_head = ctrl->mem_head;
1355                 res_lists.p_mem_head = ctrl->p_mem_head;
1356                 res_lists.bus_head = ctrl->bus_head;
1357                 res_lists.irqs = NULL;
1358
1359                 rc = configure_new_device(ctrl, func, 0, &res_lists, 0, 0);
1360                 dbg("%s: back from configure_new_device\n", __FUNCTION__);
1361
1362                 ctrl->io_head = res_lists.io_head;
1363                 ctrl->mem_head = res_lists.mem_head;
1364                 ctrl->p_mem_head = res_lists.p_mem_head;
1365                 ctrl->bus_head = res_lists.bus_head;
1366
1367                 shpchp_resource_sort_and_combine(&(ctrl->mem_head));
1368                 shpchp_resource_sort_and_combine(&(ctrl->p_mem_head));
1369                 shpchp_resource_sort_and_combine(&(ctrl->io_head));
1370                 shpchp_resource_sort_and_combine(&(ctrl->bus_head));
1371
1372                 if (rc) {
1373                         /* Wait for exclusive access to hardware */
1374                         down(&ctrl->crit_sect);
1375
1376                         /* turn off slot, turn on Amber LED, turn off Green LED */
1377                         retval = p_slot->hpc_ops->slot_disable(p_slot);
1378                         if (retval) {
1379                                 err("%s: Issue of Slot Enable command failed\n", __FUNCTION__);
1380                                 /* Done with exclusive hardware access */
1381                                 up(&ctrl->crit_sect);
1382                                 return retval;
1383                         }
1384                         /* Wait for the command to complete */
1385                         wait_for_ctrl_irq (ctrl);
1386
1387                         retval = p_slot->hpc_ops->check_cmd_status(ctrl);
1388                         if (retval) {
1389                                 err("%s: Failed to disable slot, error code(%d)\n", __FUNCTION__, retval);
1390                                 /* Done with exclusive hardware access */
1391                                 up(&ctrl->crit_sect);
1392                                 return retval;  
1393                         }
1394
1395                         /* Done with exclusive hardware access */
1396                         up(&ctrl->crit_sect);
1397
1398                         return(rc);
1399                 }
1400                 shpchp_save_slot_config(ctrl, func);
1401
1402                 func->status = 0;
1403                 func->switch_save = 0x10;
1404                 func->is_a_board = 0x01;
1405                 func->pwr_save = 1;
1406
1407                 /* Next, we will instantiate the linux pci_dev structures 
1408                  * (with appropriate driver notification, if already present) 
1409                  */
1410                 index = 0;
1411                 do {
1412                         new_func = shpchp_slot_find(ctrl->slot_bus, func->device, index++);
1413                         if (new_func && !new_func->pci_dev) {
1414                                 dbg("%s:call pci_hp_configure_dev\n", __FUNCTION__);
1415                                 shpchp_configure_device(ctrl, new_func);
1416                         }
1417                 } while (new_func);
1418
1419                 /* Wait for exclusive access to hardware */
1420                 down(&ctrl->crit_sect);
1421
1422                 p_slot->hpc_ops->green_led_on(p_slot);
1423
1424                 /* Wait for the command to complete */
1425                 wait_for_ctrl_irq (ctrl);
1426
1427
1428                 /* Done with exclusive hardware access */
1429                 up(&ctrl->crit_sect);
1430
1431         } else {
1432                 /* Wait for exclusive access to hardware */
1433                 down(&ctrl->crit_sect);
1434
1435                 /* turn off slot, turn on Amber LED, turn off Green LED */
1436                 rc = p_slot->hpc_ops->slot_disable(p_slot);
1437                 if (rc) {
1438                         err("%s: Issue of Slot Disable command failed\n", __FUNCTION__);
1439                         /* Done with exclusive hardware access */
1440                         up(&ctrl->crit_sect);
1441                         return rc;
1442                 }
1443                 /* Wait for the command to complete */
1444                 wait_for_ctrl_irq (ctrl);
1445
1446                 rc = p_slot->hpc_ops->check_cmd_status(ctrl);
1447                 if (rc) {
1448                         err("%s: Failed to disable slot, error code(%d)\n", __FUNCTION__, rc);
1449                         /* Done with exclusive hardware access */
1450                         up(&ctrl->crit_sect);
1451                         return rc;  
1452                 }
1453
1454                 /* Done with exclusive hardware access */
1455                 up(&ctrl->crit_sect);
1456
1457                 return(rc);
1458         }
1459         return 0;
1460 }
1461
1462
1463 /**
1464  * remove_board - Turns off slot and LED's
1465  *
1466  */
1467 static u32 remove_board(struct pci_func *func, struct controller *ctrl)
1468 {
1469         int index;
1470         u8 skip = 0;
1471         u8 device;
1472         u8 hp_slot;
1473         u32 rc;
1474         struct resource_lists res_lists;
1475         struct pci_func *temp_func;
1476         struct slot *p_slot;
1477
1478         if (func == NULL)
1479                 return(1);
1480
1481         if (shpchp_unconfigure_device(func))
1482                 return(1);
1483
1484         device = func->device;
1485
1486         hp_slot = func->device - ctrl->slot_device_offset;
1487         p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);
1488
1489         dbg("In %s, hp_slot = %d\n", __FUNCTION__, hp_slot);
1490
1491         if ((ctrl->add_support) &&
1492                 !(func->bus_head || func->mem_head || func->p_mem_head || func->io_head)) {
1493                 /* Here we check to see if we've saved any of the board's
1494                  * resources already.  If so, we'll skip the attempt to
1495                  * determine what's being used.
1496                  */
1497                 index = 0;
1498
1499                 temp_func = func;
1500
1501                 while ((temp_func = shpchp_slot_find(temp_func->bus, temp_func->device, index++))) {
1502                         if (temp_func->bus_head || temp_func->mem_head
1503                             || temp_func->p_mem_head || temp_func->io_head) {
1504                                 skip = 1;
1505                                 break;
1506                         }
1507                 }
1508
1509                 if (!skip)
1510                         rc = shpchp_save_used_resources(ctrl, func, DISABLE_CARD);
1511         }
1512         /* Change status to shutdown */
1513         if (func->is_a_board)
1514                 func->status = 0x01;
1515         func->configured = 0;
1516
1517         /* Wait for exclusive access to hardware */
1518         down(&ctrl->crit_sect);
1519
1520         /* turn off slot, turn on Amber LED, turn off Green LED */
1521         rc = p_slot->hpc_ops->slot_disable(p_slot);
1522         if (rc) {
1523                 err("%s: Issue of Slot Disable command failed\n", __FUNCTION__);
1524                 /* Done with exclusive hardware access */
1525                 up(&ctrl->crit_sect);
1526                 return rc;
1527         }
1528         /* Wait for the command to complete */
1529         wait_for_ctrl_irq (ctrl);
1530
1531         rc = p_slot->hpc_ops->check_cmd_status(ctrl);
1532         if (rc) {
1533                 err("%s: Failed to disable slot, error code(%d)\n", __FUNCTION__, rc);
1534                 /* Done with exclusive hardware access */
1535                 up(&ctrl->crit_sect);
1536                 return rc;  
1537         }
1538         
1539         rc = p_slot->hpc_ops->set_attention_status(p_slot, 0);
1540         if (rc) {
1541                 err("%s: Issue of Set Attention command failed\n", __FUNCTION__);
1542                 /* Done with exclusive hardware access */
1543                 up(&ctrl->crit_sect);
1544                 return rc;
1545         }
1546         /* Wait for the command to complete */
1547         wait_for_ctrl_irq (ctrl);
1548
1549         /* Done with exclusive hardware access */
1550         up(&ctrl->crit_sect);
1551
1552         if (ctrl->add_support) {
1553                 while (func) {
1554                         res_lists.io_head = ctrl->io_head;
1555                         res_lists.mem_head = ctrl->mem_head;
1556                         res_lists.p_mem_head = ctrl->p_mem_head;
1557                         res_lists.bus_head = ctrl->bus_head;
1558
1559                         dbg("Returning resources to ctlr lists for (B/D/F) = (%#x/%#x/%#x)\n", func->bus, 
1560                                 func->device, func->function);
1561
1562                         shpchp_return_board_resources(func, &res_lists);
1563
1564                         ctrl->io_head = res_lists.io_head;
1565                         ctrl->mem_head = res_lists.mem_head;
1566                         ctrl->p_mem_head = res_lists.p_mem_head;
1567                         ctrl->bus_head = res_lists.bus_head;
1568
1569                         shpchp_resource_sort_and_combine(&(ctrl->mem_head));
1570                         shpchp_resource_sort_and_combine(&(ctrl->p_mem_head));
1571                         shpchp_resource_sort_and_combine(&(ctrl->io_head));
1572                         shpchp_resource_sort_and_combine(&(ctrl->bus_head));
1573
1574                         if (is_bridge(func)) {
1575                                 dbg("PCI Bridge Hot-Remove s:b:d:f(%02x:%02x:%02x:%02x)\n", ctrl->seg, func->bus, 
1576                                         func->device, func->function);
1577                                 bridge_slot_remove(func);
1578                         } else
1579                                 dbg("PCI Function Hot-Remove s:b:d:f(%02x:%02x:%02x:%02x)\n", ctrl->seg, func->bus, 
1580                                         func->device, func->function);
1581                                 slot_remove(func);
1582
1583                         func = shpchp_slot_find(ctrl->slot_bus, device, 0);
1584                 }
1585
1586                 /* Setup slot structure with entry for empty slot */
1587                 func = shpchp_slot_create(ctrl->slot_bus);
1588
1589                 if (func == NULL) {
1590                         return(1);
1591                 }
1592
1593                 func->bus = ctrl->slot_bus;
1594                 func->device = device;
1595                 func->function = 0;
1596                 func->configured = 0;
1597                 func->switch_save = 0x10;
1598                 func->pwr_save = 0;
1599                 func->is_a_board = 0;
1600         }
1601
1602         return 0;
1603 }
1604
1605
1606 static void pushbutton_helper_thread (unsigned long data)
1607 {
1608         pushbutton_pending = data;
1609
1610         up(&event_semaphore);
1611 }
1612
1613
1614 /**
1615  * shpchp_pushbutton_thread
1616  *
1617  * Scheduled procedure to handle blocking stuff for the pushbuttons
1618  * Handles all pending events and exits.
1619  *
1620  */
1621 static void shpchp_pushbutton_thread (unsigned long slot)
1622 {
1623         struct slot *p_slot = (struct slot *) slot;
1624         u8 getstatus;
1625         
1626         pushbutton_pending = 0;
1627
1628         if (!p_slot) {
1629                 dbg("%s: Error! slot NULL\n", __FUNCTION__);
1630                 return;
1631         }
1632
1633         p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
1634         if (getstatus) {
1635                 p_slot->state = POWEROFF_STATE;
1636                 dbg("In power_down_board, b:d(%x:%x)\n", p_slot->bus, p_slot->device);
1637
1638                 shpchp_disable_slot(p_slot);
1639                 p_slot->state = STATIC_STATE;
1640         } else {
1641                 p_slot->state = POWERON_STATE;
1642                 dbg("In add_board, b:d(%x:%x)\n", p_slot->bus, p_slot->device);
1643
1644                 if (shpchp_enable_slot(p_slot)) {
1645                         /* Wait for exclusive access to hardware */
1646                         down(&p_slot->ctrl->crit_sect);
1647
1648                         p_slot->hpc_ops->green_led_off(p_slot);
1649
1650                         /* Wait for the command to complete */
1651                         wait_for_ctrl_irq (p_slot->ctrl);
1652
1653                         /* Done with exclusive hardware access */
1654                         up(&p_slot->ctrl->crit_sect);
1655                 }
1656                 p_slot->state = STATIC_STATE;
1657         }
1658
1659         return;
1660 }
1661
1662
1663 /* this is the main worker thread */
1664 static int event_thread(void* data)
1665 {
1666         struct controller *ctrl;
1667         lock_kernel();
1668         daemonize("shpchpd_event");
1669         unlock_kernel();
1670
1671         while (1) {
1672                 dbg("!!!!event_thread sleeping\n");
1673                 down_interruptible (&event_semaphore);
1674                 dbg("event_thread woken finished = %d\n", event_finished);
1675                 if (event_finished || signal_pending(current))
1676                         break;
1677                 /* Do stuff here */
1678                 if (pushbutton_pending)
1679                         shpchp_pushbutton_thread(pushbutton_pending);
1680                 else
1681                         for (ctrl = shpchp_ctrl_list; ctrl; ctrl=ctrl->next)
1682                                 interrupt_event_handler(ctrl);
1683         }
1684         dbg("event_thread signals exit\n");
1685         up(&event_exit);
1686         return 0;
1687 }
1688
1689 int shpchp_event_start_thread (void)
1690 {
1691         int pid;
1692
1693         /* initialize our semaphores */
1694         init_MUTEX_LOCKED(&event_exit);
1695         event_finished=0;
1696
1697         init_MUTEX_LOCKED(&event_semaphore);
1698         pid = kernel_thread(event_thread, NULL, 0);
1699
1700         if (pid < 0) {
1701                 err ("Can't start up our event thread\n");
1702                 return -1;
1703         }
1704         dbg("Our event thread pid = %d\n", pid);
1705         return 0;
1706 }
1707
1708
1709 void shpchp_event_stop_thread (void)
1710 {
1711         event_finished = 1;
1712         dbg("event_thread finish command given\n");
1713         up(&event_semaphore);
1714         dbg("wait for event_thread to exit\n");
1715         down(&event_exit);
1716 }
1717
1718
1719 static int update_slot_info (struct slot *slot)
1720 {
1721         struct hotplug_slot_info *info;
1722         int result;
1723
1724         info = kmalloc(sizeof(*info), GFP_KERNEL);
1725         if (!info)
1726                 return -ENOMEM;
1727
1728         slot->hpc_ops->get_power_status(slot, &(info->power_status));
1729         slot->hpc_ops->get_attention_status(slot, &(info->attention_status));
1730         slot->hpc_ops->get_latch_status(slot, &(info->latch_status));
1731         slot->hpc_ops->get_adapter_status(slot, &(info->adapter_status));
1732
1733         result = pci_hp_change_slot_info(slot->hotplug_slot, info);
1734         kfree (info);
1735         return result;
1736 }
1737
1738 static void interrupt_event_handler(struct controller *ctrl)
1739 {
1740         int loop = 0;
1741         int change = 1;
1742         struct pci_func *func;
1743         u8 hp_slot;
1744         u8 getstatus;
1745         struct slot *p_slot;
1746
1747         dbg("%s:\n", __FUNCTION__);
1748         while (change) {
1749                 change = 0;
1750
1751                 for (loop = 0; loop < 10; loop++) {
1752                         if (ctrl->event_queue[loop].event_type != 0) {
1753                                 dbg("%s:loop %x event_type %x\n", __FUNCTION__, loop, 
1754                                         ctrl->event_queue[loop].event_type);
1755                                 hp_slot = ctrl->event_queue[loop].hp_slot;
1756
1757                                 func = shpchp_slot_find(ctrl->slot_bus, (hp_slot + ctrl->slot_device_offset), 0);
1758
1759                                 p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);
1760
1761                                 dbg("%s: hp_slot %d, func %p, p_slot %p\n", __FUNCTION__, hp_slot, func, p_slot);
1762
1763                                 if (ctrl->event_queue[loop].event_type == INT_BUTTON_CANCEL) {
1764                                         dbg("%s: button cancel\n", __FUNCTION__);
1765                                         del_timer(&p_slot->task_event);
1766
1767                                         switch (p_slot->state) {
1768                                         case BLINKINGOFF_STATE:
1769                                                 /* Wait for exclusive access to hardware */
1770                                                 down(&ctrl->crit_sect);
1771
1772                                                 p_slot->hpc_ops->green_led_on(p_slot);
1773                                                 /* Wait for the command to complete */
1774                                                 wait_for_ctrl_irq (ctrl);
1775
1776                                                 p_slot->hpc_ops->set_attention_status(p_slot, 0);
1777
1778                                                 /* Wait for the command to complete */
1779                                                 wait_for_ctrl_irq (ctrl);
1780
1781                                                 /* Done with exclusive hardware access */
1782                                                 up(&ctrl->crit_sect);
1783                                                 break;
1784                                         case BLINKINGON_STATE:
1785                                                 /* Wait for exclusive access to hardware */
1786                                                 down(&ctrl->crit_sect);
1787
1788                                                 p_slot->hpc_ops->green_led_off(p_slot);
1789                                                 /* Wait for the command to complete */
1790                                                 wait_for_ctrl_irq (ctrl);
1791
1792                                                 p_slot->hpc_ops->set_attention_status(p_slot, 0);
1793                                                 /* Wait for the command to complete */
1794                                                 wait_for_ctrl_irq (ctrl);
1795
1796                                                 /* Done with exclusive hardware access */
1797                                                 up(&ctrl->crit_sect);
1798
1799                                                 break;
1800                                         default:
1801                                                 warn("Not a valid state\n");
1802                                                 return;
1803                                         }
1804                                         info(msg_button_cancel, p_slot->number);
1805                                         p_slot->state = STATIC_STATE;
1806                                 } else if (ctrl->event_queue[loop].event_type == INT_BUTTON_PRESS) {
1807                                         /* Button Pressed (No action on 1st press...) */
1808                                         dbg("%s: Button pressed\n", __FUNCTION__);
1809
1810                                         p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
1811                                         if (getstatus) {
1812                                                 /* slot is on */
1813                                                 dbg("%s: slot is on\n", __FUNCTION__);
1814                                                 p_slot->state = BLINKINGOFF_STATE;
1815                                                 info(msg_button_off, p_slot->number);
1816                                         } else {
1817                                                 /* slot is off */
1818                                                 dbg("%s: slot is off\n", __FUNCTION__);
1819                                                 p_slot->state = BLINKINGON_STATE;
1820                                                 info(msg_button_on, p_slot->number);
1821                                         }
1822
1823                                         /* Wait for exclusive access to hardware */
1824                                         down(&ctrl->crit_sect);
1825
1826                                         /* blink green LED and turn off amber */
1827                                         p_slot->hpc_ops->green_led_blink(p_slot);
1828                                         /* Wait for the command to complete */
1829                                         wait_for_ctrl_irq (ctrl);
1830                                         
1831                                         p_slot->hpc_ops->set_attention_status(p_slot, 0);
1832
1833                                         /* Wait for the command to complete */
1834                                         wait_for_ctrl_irq (ctrl);
1835
1836                                         /* Done with exclusive hardware access */
1837                                         up(&ctrl->crit_sect);
1838
1839                                         init_timer(&p_slot->task_event);
1840                                         p_slot->task_event.expires = jiffies + 5 * HZ;   /* 5 second delay */
1841                                         p_slot->task_event.function = (void (*)(unsigned long)) pushbutton_helper_thread;
1842                                         p_slot->task_event.data = (unsigned long) p_slot;
1843
1844                                         dbg("%s: add_timer p_slot = %p\n", __FUNCTION__,(void *) p_slot);
1845                                         add_timer(&p_slot->task_event);
1846                                 } else if (ctrl->event_queue[loop].event_type == INT_POWER_FAULT) {
1847                                         /***********POWER FAULT********************/
1848                                         dbg("%s: power fault\n", __FUNCTION__);
1849                                         /* Wait for exclusive access to hardware */
1850                                         down(&ctrl->crit_sect);
1851
1852                                         p_slot->hpc_ops->set_attention_status(p_slot, 1);
1853                                         /* Wait for the command to complete */
1854                                         wait_for_ctrl_irq (ctrl);
1855                                         
1856                                         p_slot->hpc_ops->green_led_off(p_slot);
1857                                         /* Wait for the command to complete */
1858                                         wait_for_ctrl_irq (ctrl);
1859
1860                                         /* Done with exclusive hardware access */
1861                                         up(&ctrl->crit_sect);
1862                                 } else {
1863                                         /* refresh notification */
1864                                         if (p_slot)
1865                                                 update_slot_info(p_slot);
1866                                 }
1867
1868                                 ctrl->event_queue[loop].event_type = 0;
1869
1870                                 change = 1;
1871                         }
1872                 }               /* End of FOR loop */
1873         }
1874
1875         return;
1876 }
1877
1878
1879 int shpchp_enable_slot (struct slot *p_slot)
1880 {
1881         u8 getstatus = 0;
1882         int rc;
1883         struct pci_func *func;
1884
1885         func = shpchp_slot_find(p_slot->bus, p_slot->device, 0);
1886         if (!func) {
1887                 dbg("%s: Error! slot NULL\n", __FUNCTION__);
1888                 return -ENODEV;
1889         }
1890
1891         /* Check to see if (latch closed, card present, power off) */
1892         down(&p_slot->ctrl->crit_sect);
1893         rc = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus);
1894         if (rc || !getstatus) {
1895                 info("%s: no adapter on slot(%x)\n", __FUNCTION__, p_slot->number);
1896                 up(&p_slot->ctrl->crit_sect);
1897                 return -ENODEV;
1898         }
1899         rc = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
1900         if (rc || getstatus) {
1901                 info("%s: latch open on slot(%x)\n", __FUNCTION__, p_slot->number);
1902                 up(&p_slot->ctrl->crit_sect);
1903                 return -ENODEV;
1904         }
1905         rc = p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
1906         if (rc || getstatus) {
1907                 info("%s: already enabled on slot(%x)\n", __FUNCTION__, p_slot->number);
1908                 up(&p_slot->ctrl->crit_sect);
1909                 return -ENODEV;
1910         }
1911         up(&p_slot->ctrl->crit_sect);
1912
1913         slot_remove(func);
1914
1915         func = shpchp_slot_create(p_slot->bus);
1916         if (func == NULL)
1917                 return -ENOMEM;
1918
1919         func->bus = p_slot->bus;
1920         func->device = p_slot->device;
1921         func->function = 0;
1922         func->configured = 0;
1923         func->is_a_board = 1;
1924
1925         /* We have to save the presence info for these slots */
1926         p_slot->hpc_ops->get_adapter_status(p_slot, &(func->presence_save));
1927         p_slot->hpc_ops->get_power_status(p_slot, &(func->pwr_save));
1928         dbg("%s: func->pwr_save %x\n", __FUNCTION__, func->pwr_save);
1929         p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
1930         func->switch_save = !getstatus? 0x10:0;
1931
1932         rc = board_added(func, p_slot->ctrl);
1933         if (rc) {
1934                 if (is_bridge(func))
1935                         bridge_slot_remove(func);
1936                 else
1937                         slot_remove(func);
1938
1939                 /* Setup slot structure with entry for empty slot */
1940                 func = shpchp_slot_create(p_slot->bus);
1941                 if (func == NULL)
1942                         return -ENOMEM; /* Out of memory */
1943
1944                 func->bus = p_slot->bus;
1945                 func->device = p_slot->device;
1946                 func->function = 0;
1947                 func->configured = 0;
1948                 func->is_a_board = 1;
1949
1950                 /* We have to save the presence info for these slots */
1951                 p_slot->hpc_ops->get_adapter_status(p_slot, &(func->presence_save));
1952                 p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
1953                 func->switch_save = !getstatus? 0x10:0;
1954         }
1955
1956         if (p_slot)
1957                 update_slot_info(p_slot);
1958
1959         return rc;
1960 }
1961
1962
1963 int shpchp_disable_slot (struct slot *p_slot)
1964 {
1965         u8 class_code, header_type, BCR;
1966         u8 index = 0;
1967         u8 getstatus = 0;
1968         u32 rc = 0;
1969         int ret = 0;
1970         unsigned int devfn;
1971         struct pci_bus *pci_bus;
1972         struct pci_func *func;
1973
1974         if (!p_slot->ctrl)
1975                 return -ENODEV;
1976
1977         pci_bus = p_slot->ctrl->pci_dev->subordinate;
1978
1979         /* Check to see if (latch closed, card present, power on) */
1980         down(&p_slot->ctrl->crit_sect);
1981
1982         ret = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus);
1983         if (ret || !getstatus) {
1984                 info("%s: no adapter on slot(%x)\n", __FUNCTION__, p_slot->number);
1985                 up(&p_slot->ctrl->crit_sect);
1986                 return -ENODEV;
1987         }
1988         ret = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
1989         if (ret || getstatus) {
1990                 info("%s: latch open on slot(%x)\n", __FUNCTION__, p_slot->number);
1991                 up(&p_slot->ctrl->crit_sect);
1992                 return -ENODEV;
1993         }
1994         ret = p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
1995         if (ret || !getstatus) {
1996                 info("%s: already disabled slot(%x)\n", __FUNCTION__, p_slot->number);
1997                 up(&p_slot->ctrl->crit_sect);
1998                 return -ENODEV;
1999         }
2000         up(&p_slot->ctrl->crit_sect);
2001
2002         func = shpchp_slot_find(p_slot->bus, p_slot->device, index++);
2003
2004         /* Make sure there are no video controllers here
2005          * for all func of p_slot
2006          */
2007         while (func && !rc) {
2008                 pci_bus->number = func->bus;
2009                 devfn = PCI_DEVFN(func->device, func->function);
2010
2011                 /* Check the Class Code */
2012                 rc = pci_bus_read_config_byte (pci_bus, devfn, 0x0B, &class_code);
2013                 if (rc)
2014                         return -ENODEV;
2015
2016                 if (class_code == PCI_BASE_CLASS_DISPLAY) {
2017                         /* Display/Video adapter (not supported) */
2018                         rc = REMOVE_NOT_SUPPORTED;
2019                 } else {
2020                         /* See if it's a bridge */
2021                         rc = pci_bus_read_config_byte (pci_bus, devfn, PCI_HEADER_TYPE, &header_type);
2022                         if (rc)
2023                                 return -ENODEV;
2024
2025                         /* If it's a bridge, check the VGA Enable bit */
2026                         if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE) {
2027                                 rc = pci_bus_read_config_byte (pci_bus, devfn, PCI_BRIDGE_CONTROL, &BCR);
2028                                 if (rc)
2029                                         return -ENODEV;
2030
2031                                 /* If the VGA Enable bit is set, remove isn't supported */
2032                                 if (BCR & PCI_BRIDGE_CTL_VGA) {
2033                                         rc = REMOVE_NOT_SUPPORTED;
2034                                 }
2035                         }
2036                 }
2037
2038                 func = shpchp_slot_find(p_slot->bus, p_slot->device, index++);
2039         }
2040
2041         func = shpchp_slot_find(p_slot->bus, p_slot->device, 0);
2042         if ((func != NULL) && !rc) {
2043                 rc = remove_board(func, p_slot->ctrl);
2044         } else if (!rc)
2045                 rc = -ENODEV;
2046
2047         if (p_slot)
2048                 update_slot_info(p_slot);
2049
2050         return rc;
2051 }
2052
2053
2054 /**
2055  * configure_new_device - Configures the PCI header information of one board.
2056  *
2057  * @ctrl: pointer to controller structure
2058  * @func: pointer to function structure
2059  * @behind_bridge: 1 if this is a recursive call, 0 if not
2060  * @resources: pointer to set of resource lists
2061  *
2062  * Returns 0 if success
2063  *
2064  */
2065 static u32 configure_new_device (struct controller * ctrl, struct pci_func * func,
2066         u8 behind_bridge, struct resource_lists * resources, u8 bridge_bus, u8 bridge_dev)
2067 {
2068         u8 temp_byte, function, max_functions, stop_it;
2069         int rc;
2070         u32 ID;
2071         struct pci_func *new_slot;
2072         struct pci_bus lpci_bus, *pci_bus;
2073         int index;
2074
2075         new_slot = func;
2076
2077         dbg("%s\n", __FUNCTION__);
2078         memcpy(&lpci_bus, ctrl->pci_dev->subordinate, sizeof(lpci_bus));
2079         pci_bus = &lpci_bus;
2080         pci_bus->number = func->bus;
2081
2082         /* Check for Multi-function device */
2083         rc = pci_bus_read_config_byte(pci_bus, PCI_DEVFN(func->device, func->function), 0x0E, &temp_byte);
2084         if (rc) {
2085                 dbg("%s: rc = %d\n", __FUNCTION__, rc);
2086                 return rc;
2087         }
2088
2089         if (temp_byte & 0x80)   /* Multi-function device */
2090                 max_functions = 8;
2091         else
2092                 max_functions = 1;
2093
2094         function = 0;
2095
2096         do {
2097                 rc = configure_new_function(ctrl, new_slot, behind_bridge, resources, bridge_bus, bridge_dev);
2098
2099                 if (rc) {
2100                         dbg("configure_new_function failed %d\n",rc);
2101                         index = 0;
2102
2103                         while (new_slot) {
2104                                 new_slot = shpchp_slot_find(new_slot->bus, new_slot->device, index++);
2105
2106                                 if (new_slot)
2107                                         shpchp_return_board_resources(new_slot, resources);
2108                         }
2109
2110                         return(rc);
2111                 }
2112
2113                 function++;
2114
2115                 stop_it = 0;
2116
2117                 /*  The following loop skips to the next present function
2118                  *  and creates a board structure
2119                  */
2120
2121                 while ((function < max_functions) && (!stop_it)) {
2122                         pci_bus_read_config_dword(pci_bus, PCI_DEVFN(func->device, function), 0x00, &ID);
2123
2124                         if (ID == 0xFFFFFFFF) {   /* There's nothing there. */
2125                                 function++;
2126                         } else {  /* There's something there */
2127                                 /* Setup slot structure. */
2128                                 new_slot = shpchp_slot_create(func->bus);
2129
2130                                 if (new_slot == NULL) {
2131                                         /* Out of memory */
2132                                         return(1);
2133                                 }
2134
2135                                 new_slot->bus = func->bus;
2136                                 new_slot->device = func->device;
2137                                 new_slot->function = function;
2138                                 new_slot->is_a_board = 1;
2139                                 new_slot->status = 0;
2140
2141                                 stop_it++;
2142                         }
2143                 }
2144
2145         } while (function < max_functions);
2146         dbg("returning from configure_new_device\n");
2147
2148         return 0;
2149 }
2150
2151
2152 /*
2153  * Configuration logic that involves the hotplug data structures and 
2154  * their bookkeeping
2155  */
2156
2157
2158 /**
2159  * configure_new_function - Configures the PCI header information of one device
2160  *
2161  * @ctrl: pointer to controller structure
2162  * @func: pointer to function structure
2163  * @behind_bridge: 1 if this is a recursive call, 0 if not
2164  * @resources: pointer to set of resource lists
2165  *
2166  * Calls itself recursively for bridged devices.
2167  * Returns 0 if success
2168  *
2169  */
2170 static int configure_new_function (struct controller * ctrl, struct pci_func * func,
2171         u8 behind_bridge, struct resource_lists *resources, u8 bridge_bus, u8 bridge_dev)
2172 {
2173         int cloop;
2174         u8 temp_byte;
2175         u8 device;
2176         u8 class_code;
2177         u16 temp_word;
2178         u32 rc;
2179         u32 temp_register;
2180         u32 base;
2181         u32 ID;
2182         unsigned int devfn;
2183         struct pci_resource *mem_node;
2184         struct pci_resource *p_mem_node;
2185         struct pci_resource *io_node;
2186         struct pci_resource *bus_node;
2187         struct pci_resource *hold_mem_node;
2188         struct pci_resource *hold_p_mem_node;
2189         struct pci_resource *hold_IO_node;
2190         struct pci_resource *hold_bus_node;
2191         struct irq_mapping irqs;
2192         struct pci_func *new_slot;
2193         struct pci_bus lpci_bus, *pci_bus;
2194         struct resource_lists temp_resources;
2195 #if defined(CONFIG_X86_64)
2196         u8 IRQ=0;
2197 #endif
2198
2199         memcpy(&lpci_bus, ctrl->pci_dev->subordinate, sizeof(lpci_bus));
2200         pci_bus = &lpci_bus;
2201         pci_bus->number = func->bus;
2202         devfn = PCI_DEVFN(func->device, func->function);
2203
2204         /* Check for Bridge */
2205         rc = pci_bus_read_config_byte (pci_bus, devfn, PCI_HEADER_TYPE, &temp_byte);
2206         if (rc)
2207                 return rc;
2208
2209         if ((temp_byte & 0x7F) == PCI_HEADER_TYPE_BRIDGE) { /* PCI-PCI Bridge */
2210                 /* set Primary bus */
2211                 dbg("set Primary bus = 0x%x\n", func->bus);
2212                 rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_PRIMARY_BUS, func->bus);
2213                 if (rc)
2214                         return rc;
2215
2216                 /* find range of busses to use */
2217                 bus_node = get_max_resource(&resources->bus_head, 1L);
2218
2219                 /* If we don't have any busses to allocate, we can't continue */
2220                 if (!bus_node) {
2221                         err("Got NO bus resource to use\n");
2222                         return -ENOMEM;
2223                 }
2224                 dbg("Got ranges of buses to use: base:len=0x%x:%x\n", bus_node->base, bus_node->length);
2225
2226                 /* set Secondary bus */
2227                 temp_byte = (u8)bus_node->base;
2228                 dbg("set Secondary bus = 0x%x\n", temp_byte);
2229                 rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_SECONDARY_BUS, temp_byte);
2230                 if (rc)
2231                         return rc;
2232
2233                 /* set subordinate bus */
2234                 temp_byte = (u8)(bus_node->base + bus_node->length - 1);
2235                 dbg("set subordinate bus = 0x%x\n", temp_byte);
2236                 rc = pci_bus_write_config_byte (pci_bus, devfn, PCI_SUBORDINATE_BUS, temp_byte);
2237                 if (rc)
2238                         return rc;
2239
2240                 /* Set HP parameters (Cache Line Size, Latency Timer) */
2241                 rc = shpchprm_set_hpp(ctrl, func, PCI_HEADER_TYPE_BRIDGE);
2242                 if (rc)
2243                         return rc;
2244
2245                 /* Setup the IO, memory, and prefetchable windows */
2246
2247                 io_node = get_max_resource(&(resources->io_head), 0x1000L);
2248                 if (io_node) {
2249                         dbg("io_node(base, len, next) (%x, %x, %p)\n", io_node->base, io_node->length, io_node->next);
2250                 }
2251
2252                 mem_node = get_max_resource(&(resources->mem_head), 0x100000L);
2253                 if (mem_node) {
2254                         dbg("mem_node(base, len, next) (%x, %x, %p)\n", mem_node->base, mem_node->length, mem_node->next);
2255                 }
2256
2257                 if (resources->p_mem_head)
2258                         p_mem_node = get_max_resource(&(resources->p_mem_head), 0x100000L);
2259                 else {
2260                         /*
2261                          * In some platform implementation, MEM and PMEM are not
2262                          *  distinguished, and hence ACPI _CRS has only MEM entries
2263                          *  for both MEM and PMEM.
2264                          */
2265                         dbg("using MEM for PMEM\n");
2266                         p_mem_node = get_max_resource(&(resources->mem_head), 0x100000L);
2267                 }
2268                 if (p_mem_node) {
2269                         dbg("p_mem_node(base, len, next) (%x, %x, %p)\n", p_mem_node->base, p_mem_node->length, p_mem_node->next);
2270                 }
2271
2272                 /* set up the IRQ info */
2273                 if (!resources->irqs) {
2274                         irqs.barber_pole = 0;
2275                         irqs.interrupt[0] = 0;
2276                         irqs.interrupt[1] = 0;
2277                         irqs.interrupt[2] = 0;
2278                         irqs.interrupt[3] = 0;
2279                         irqs.valid_INT = 0;
2280                 } else {
2281                         irqs.barber_pole = resources->irqs->barber_pole;
2282                         irqs.interrupt[0] = resources->irqs->interrupt[0];
2283                         irqs.interrupt[1] = resources->irqs->interrupt[1];
2284                         irqs.interrupt[2] = resources->irqs->interrupt[2];
2285                         irqs.interrupt[3] = resources->irqs->interrupt[3];
2286                         irqs.valid_INT = resources->irqs->valid_INT;
2287                 }
2288
2289                 /* set up resource lists that are now aligned on top and bottom
2290                  * for anything behind the bridge.
2291                  */
2292                 temp_resources.bus_head = bus_node;
2293                 temp_resources.io_head = io_node;
2294                 temp_resources.mem_head = mem_node;
2295                 temp_resources.p_mem_head = p_mem_node;
2296                 temp_resources.irqs = &irqs;
2297
2298                 /* Make copies of the nodes we are going to pass down so that
2299                  * if there is a problem,we can just use these to free resources
2300                  */
2301                 hold_bus_node = kmalloc(sizeof(*hold_bus_node), GFP_KERNEL);
2302                 hold_IO_node = kmalloc(sizeof(*hold_IO_node), GFP_KERNEL);
2303                 hold_mem_node = kmalloc(sizeof(*hold_mem_node), GFP_KERNEL);
2304                 hold_p_mem_node = kmalloc(sizeof(*hold_p_mem_node), GFP_KERNEL);
2305
2306                 if (!hold_bus_node || !hold_IO_node || !hold_mem_node || !hold_p_mem_node) {
2307                         kfree(hold_bus_node);
2308                         kfree(hold_IO_node);
2309                         kfree(hold_mem_node);
2310                         kfree(hold_p_mem_node);
2311
2312                         return 1;
2313                 }
2314
2315                 memcpy(hold_bus_node, bus_node, sizeof(struct pci_resource));
2316
2317                 bus_node->base += 1;
2318                 bus_node->length -= 1;
2319                 bus_node->next = NULL;
2320
2321                 /* If we have IO resources copy them and fill in the bridge's
2322                  * IO range registers
2323                  */
2324                 if (io_node) {
2325                         memcpy(hold_IO_node, io_node, sizeof(struct pci_resource));
2326                         io_node->next = NULL;
2327
2328                         /* set IO base and Limit registers */
2329                         RES_CHECK(io_node->base, 8);
2330                         temp_byte = (u8)(io_node->base >> 8);
2331                         rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_IO_BASE, temp_byte);
2332
2333                         RES_CHECK(io_node->base + io_node->length - 1, 8);
2334                         temp_byte = (u8)((io_node->base + io_node->length - 1) >> 8);
2335                         rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_IO_LIMIT, temp_byte);
2336                 } else {
2337                         kfree(hold_IO_node);
2338                         hold_IO_node = NULL;
2339                 }
2340
2341                 /* If we have memory resources copy them and fill in the bridge's
2342                  * memory range registers.  Otherwise, fill in the range
2343                  * registers with values that disable them.
2344                  */
2345                 if (mem_node) {
2346                         memcpy(hold_mem_node, mem_node, sizeof(struct pci_resource));
2347                         mem_node->next = NULL;
2348
2349                         /* set Mem base and Limit registers */
2350                         RES_CHECK(mem_node->base, 16);
2351                         temp_word = (u32)(mem_node->base >> 16);
2352                         rc = pci_bus_write_config_word(pci_bus, devfn, PCI_MEMORY_BASE, temp_word);
2353
2354                         RES_CHECK(mem_node->base + mem_node->length - 1, 16);
2355                         temp_word = (u32)((mem_node->base + mem_node->length - 1) >> 16);
2356                         rc = pci_bus_write_config_word(pci_bus, devfn, PCI_MEMORY_LIMIT, temp_word);
2357                 } else {
2358                         temp_word = 0xFFFF;
2359                         rc = pci_bus_write_config_word(pci_bus, devfn, PCI_MEMORY_BASE, temp_word);
2360
2361                         temp_word = 0x0000;
2362                         rc = pci_bus_write_config_word(pci_bus, devfn, PCI_MEMORY_LIMIT, temp_word);
2363
2364                         kfree(hold_mem_node);
2365                         hold_mem_node = NULL;
2366                 }
2367
2368                 /* If we have prefetchable memory resources copy them and 
2369                  * fill in the bridge's memory range registers.  Otherwise,
2370                  * fill in the range registers with values that disable them.
2371                  */
2372                 if (p_mem_node) {
2373                         memcpy(hold_p_mem_node, p_mem_node, sizeof(struct pci_resource));
2374                         p_mem_node->next = NULL;
2375
2376                         /* set Pre Mem base and Limit registers */
2377                         RES_CHECK(p_mem_node->base, 16);
2378                         temp_word = (u32)(p_mem_node->base >> 16);
2379                         rc = pci_bus_write_config_word(pci_bus, devfn, PCI_PREF_MEMORY_BASE, temp_word);
2380
2381                         RES_CHECK(p_mem_node->base + p_mem_node->length - 1, 16);
2382                         temp_word = (u32)((p_mem_node->base + p_mem_node->length - 1) >> 16);
2383                         rc = pci_bus_write_config_word(pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, temp_word);
2384                 } else {
2385                         temp_word = 0xFFFF;
2386                         rc = pci_bus_write_config_word(pci_bus, devfn, PCI_PREF_MEMORY_BASE, temp_word);
2387
2388                         temp_word = 0x0000;
2389                         rc = pci_bus_write_config_word(pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, temp_word);
2390
2391                         kfree(hold_p_mem_node);
2392                         hold_p_mem_node = NULL;
2393                 }
2394
2395                 /* Adjust this to compensate for extra adjustment in first loop */
2396                 irqs.barber_pole--;
2397
2398                 rc = 0;
2399
2400                 /* Here we actually find the devices and configure them */
2401                 for (device = 0; (device <= 0x1F) && !rc; device++) {
2402                         irqs.barber_pole = (irqs.barber_pole + 1) & 0x03;
2403
2404                         ID = 0xFFFFFFFF;
2405                         pci_bus->number = hold_bus_node->base;
2406                         pci_bus_read_config_dword(pci_bus, PCI_DEVFN(device, 0),
2407                                         PCI_VENDOR_ID, &ID);
2408                         pci_bus->number = func->bus;
2409
2410                         if (ID != 0xFFFFFFFF) {   /*  device Present */
2411                                 /* Setup slot structure. */
2412                                 new_slot = shpchp_slot_create(hold_bus_node->base);
2413
2414                                 if (new_slot == NULL) {
2415                                         /* Out of memory */
2416                                         rc = -ENOMEM;
2417                                         continue;
2418                                 }
2419
2420                                 new_slot->bus = hold_bus_node->base;
2421                                 new_slot->device = device;
2422                                 new_slot->function = 0;
2423                                 new_slot->is_a_board = 1;
2424                                 new_slot->status = 0;
2425
2426                                 rc = configure_new_device(ctrl, new_slot, 1, &temp_resources, func->bus, func->device);
2427                                 dbg("configure_new_device rc=0x%x\n",rc);
2428                         }       /* End of IF (device in slot?) */
2429                 }               /* End of FOR loop */
2430
2431                 if (rc) {
2432                         shpchp_destroy_resource_list(&temp_resources);
2433
2434                         return_resource(&(resources->bus_head), hold_bus_node);
2435                         return_resource(&(resources->io_head), hold_IO_node);
2436                         return_resource(&(resources->mem_head), hold_mem_node);
2437                         return_resource(&(resources->p_mem_head), hold_p_mem_node);
2438                         return(rc);
2439                 }
2440
2441                 /* save the interrupt routing information */
2442                 if (resources->irqs) {
2443                         resources->irqs->interrupt[0] = irqs.interrupt[0];
2444                         resources->irqs->interrupt[1] = irqs.interrupt[1];
2445                         resources->irqs->interrupt[2] = irqs.interrupt[2];
2446                         resources->irqs->interrupt[3] = irqs.interrupt[3];
2447                         resources->irqs->valid_INT = irqs.valid_INT;
2448                 } else if (!behind_bridge) {
2449                         /* We need to hook up the interrupts here */
2450                         for (cloop = 0; cloop < 4; cloop++) {
2451                                 if (irqs.valid_INT & (0x01 << cloop)) {
2452                                         rc = shpchp_set_irq(func->bus, func->device,
2453                                                            0x0A + cloop, irqs.interrupt[cloop]);
2454                                         if (rc) {
2455                                                 shpchp_destroy_resource_list (&temp_resources);
2456                                                 return_resource(&(resources->bus_head), hold_bus_node);
2457                                                 return_resource(&(resources->io_head), hold_IO_node);
2458                                                 return_resource(&(resources->mem_head), hold_mem_node);
2459                                                 return_resource(&(resources->p_mem_head), hold_p_mem_node);
2460                                                 return rc;
2461                                         }
2462                                 }
2463                         }       /* end of for loop */
2464                 }
2465
2466                 /* Return unused bus resources
2467                  * First use the temporary node to store information for the board
2468                  */
2469                 if (hold_bus_node && bus_node && temp_resources.bus_head) {
2470                         hold_bus_node->length = bus_node->base - hold_bus_node->base;
2471
2472                         hold_bus_node->next = func->bus_head;
2473                         func->bus_head = hold_bus_node;
2474
2475                         temp_byte = (u8)(temp_resources.bus_head->base - 1);
2476
2477                         /* set subordinate bus */
2478                         dbg("re-set subordinate bus = 0x%x\n", temp_byte);
2479                         rc = pci_bus_write_config_byte (pci_bus, devfn, PCI_SUBORDINATE_BUS, temp_byte);
2480
2481                         if (temp_resources.bus_head->length == 0) {
2482                                 kfree(temp_resources.bus_head);
2483                                 temp_resources.bus_head = NULL;
2484                         } else {
2485                                 dbg("return bus res of b:d(0x%x:%x) base:len(0x%x:%x)\n",
2486                                         func->bus, func->device, temp_resources.bus_head->base, temp_resources.bus_head->length);
2487                                 return_resource(&(resources->bus_head), temp_resources.bus_head);
2488                         }
2489                 }
2490
2491                 /* If we have IO space available and there is some left,
2492                  * return the unused portion
2493                  */
2494                 if (hold_IO_node && temp_resources.io_head) {
2495                         io_node = do_pre_bridge_resource_split(&(temp_resources.io_head),
2496                                                                &hold_IO_node, 0x1000);
2497
2498                         /* Check if we were able to split something off */
2499                         if (io_node) {
2500                                 hold_IO_node->base = io_node->base + io_node->length;
2501
2502                                 RES_CHECK(hold_IO_node->base, 8);
2503                                 temp_byte = (u8)((hold_IO_node->base) >> 8);
2504                                 rc = pci_bus_write_config_byte (pci_bus, devfn, PCI_IO_BASE, temp_byte);
2505
2506                                 return_resource(&(resources->io_head), io_node);
2507                         }
2508
2509                         io_node = do_bridge_resource_split(&(temp_resources.io_head), 0x1000);
2510
2511                         /*  Check if we were able to split something off */
2512                         if (io_node) {
2513                                 /* First use the temporary node to store information for the board */
2514                                 hold_IO_node->length = io_node->base - hold_IO_node->base;
2515
2516                                 /* If we used any, add it to the board's list */
2517                                 if (hold_IO_node->length) {
2518                                         hold_IO_node->next = func->io_head;
2519                                         func->io_head = hold_IO_node;
2520
2521                                         RES_CHECK(io_node->base - 1, 8);
2522                                         temp_byte = (u8)((io_node->base - 1) >> 8);
2523                                         rc = pci_bus_write_config_byte (pci_bus, devfn, PCI_IO_LIMIT, temp_byte);
2524
2525                                         return_resource(&(resources->io_head), io_node);
2526                                 } else {
2527                                         /* it doesn't need any IO */
2528                                         temp_byte = 0x00;
2529                                         rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_IO_LIMIT, temp_byte);
2530
2531                                         return_resource(&(resources->io_head), io_node);
2532                                         kfree(hold_IO_node);
2533                                 }
2534                         } else {
2535                                 /* it used most of the range */
2536                                 hold_IO_node->next = func->io_head;
2537                                 func->io_head = hold_IO_node;
2538                         }
2539                 } else if (hold_IO_node) {
2540                         /* it used the whole range */
2541                         hold_IO_node->next = func->io_head;
2542                         func->io_head = hold_IO_node;
2543                 }
2544
2545                 /* If we have memory space available and there is some left,
2546                  * return the unused portion
2547                  */
2548                 if (hold_mem_node && temp_resources.mem_head) {
2549                         mem_node = do_pre_bridge_resource_split(&(temp_resources.mem_head), &hold_mem_node, 0x100000L);
2550
2551                         /* Check if we were able to split something off */
2552                         if (mem_node) {
2553                                 hold_mem_node->base = mem_node->base + mem_node->length;
2554
2555                                 RES_CHECK(hold_mem_node->base, 16);
2556                                 temp_word = (u32)((hold_mem_node->base) >> 16);
2557                                 rc = pci_bus_write_config_word (pci_bus, devfn, PCI_MEMORY_BASE, temp_word);
2558
2559                                 return_resource(&(resources->mem_head), mem_node);
2560                         }
2561
2562                         mem_node = do_bridge_resource_split(&(temp_resources.mem_head), 0x100000L);
2563
2564                         /* Check if we were able to split something off */
2565                         if (mem_node) {
2566                                 /* First use the temporary node to store information for the board */
2567                                 hold_mem_node->length = mem_node->base - hold_mem_node->base;
2568
2569                                 if (hold_mem_node->length) {
2570                                         hold_mem_node->next = func->mem_head;
2571                                         func->mem_head = hold_mem_node;
2572
2573                                         /* configure end address */
2574                                         RES_CHECK(mem_node->base - 1, 16);
2575                                         temp_word = (u32)((mem_node->base - 1) >> 16);
2576                                         rc = pci_bus_write_config_word (pci_bus, devfn, PCI_MEMORY_LIMIT, temp_word);
2577
2578                                         /* Return unused resources to the pool */
2579                                         return_resource(&(resources->mem_head), mem_node);
2580                                 } else {
2581                                         /* it doesn't need any Mem */
2582                                         temp_word = 0x0000;
2583                                         rc = pci_bus_write_config_word (pci_bus, devfn, PCI_MEMORY_LIMIT, temp_word);
2584
2585                                         return_resource(&(resources->mem_head), mem_node);
2586                                         kfree(hold_mem_node);
2587                                 }
2588                         } else {
2589                                 /* it used most of the range */
2590                                 hold_mem_node->next = func->mem_head;
2591                                 func->mem_head = hold_mem_node;
2592                         }
2593                 } else if (hold_mem_node) {
2594                         /* it used the whole range */
2595                         hold_mem_node->next = func->mem_head;
2596                         func->mem_head = hold_mem_node;
2597                 }
2598
2599                 /* If we have prefetchable memory space available and there is some 
2600                  * left at the end, return the unused portion
2601                  */
2602                 if (hold_p_mem_node && temp_resources.p_mem_head) {
2603                         p_mem_node = do_pre_bridge_resource_split(&(temp_resources.p_mem_head),
2604                                                                   &hold_p_mem_node, 0x100000L);
2605
2606                         /* Check if we were able to split something off */
2607                         if (p_mem_node) {
2608                                 hold_p_mem_node->base = p_mem_node->base + p_mem_node->length;
2609
2610                                 RES_CHECK(hold_p_mem_node->base, 16);
2611                                 temp_word = (u32)((hold_p_mem_node->base) >> 16);
2612                                 rc = pci_bus_write_config_word (pci_bus, devfn, PCI_PREF_MEMORY_BASE, temp_word);
2613
2614                                 return_resource(&(resources->p_mem_head), p_mem_node);
2615                         }
2616
2617                         p_mem_node = do_bridge_resource_split(&(temp_resources.p_mem_head), 0x100000L);
2618
2619                         /* Check if we were able to split something off */
2620                         if (p_mem_node) {
2621                                 /* First use the temporary node to store information for the board */
2622                                 hold_p_mem_node->length = p_mem_node->base - hold_p_mem_node->base;
2623
2624                                 /* If we used any, add it to the board's list */
2625                                 if (hold_p_mem_node->length) {
2626                                         hold_p_mem_node->next = func->p_mem_head;
2627                                         func->p_mem_head = hold_p_mem_node;
2628
2629                                         RES_CHECK(p_mem_node->base - 1, 16);
2630                                         temp_word = (u32)((p_mem_node->base - 1) >> 16);
2631                                         rc = pci_bus_write_config_word (pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, temp_word);
2632
2633                                         return_resource(&(resources->p_mem_head), p_mem_node);
2634                                 } else {
2635                                         /* it doesn't need any PMem */
2636                                         temp_word = 0x0000;
2637                                         rc = pci_bus_write_config_word (pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, temp_word);
2638
2639                                         return_resource(&(resources->p_mem_head), p_mem_node);
2640                                         kfree(hold_p_mem_node);
2641                                 }
2642                         } else {
2643                                 /* it used the most of the range */
2644                                 hold_p_mem_node->next = func->p_mem_head;
2645                                 func->p_mem_head = hold_p_mem_node;
2646                         }
2647                 } else if (hold_p_mem_node) {
2648                         /* it used the whole range */
2649                         hold_p_mem_node->next = func->p_mem_head;
2650                         func->p_mem_head = hold_p_mem_node;
2651                 }
2652
2653                 /* We should be configuring an IRQ and the bridge's base address
2654                  * registers if it needs them.  Although we have never seen such
2655                  * a device
2656                  */
2657
2658                 shpchprm_enable_card(ctrl, func, PCI_HEADER_TYPE_BRIDGE);
2659
2660                 dbg("PCI Bridge Hot-Added s:b:d:f(%02x:%02x:%02x:%02x)\n", ctrl->seg, func->bus, func->device, func->function);
2661         } else if ((temp_byte & 0x7F) == PCI_HEADER_TYPE_NORMAL) {
2662                 /* Standard device */
2663                 u64     base64;
2664                 rc = pci_bus_read_config_byte (pci_bus, devfn, 0x0B, &class_code);
2665
2666                 if (class_code == PCI_BASE_CLASS_DISPLAY)
2667                         return (DEVICE_TYPE_NOT_SUPPORTED);
2668
2669                 /* Figure out IO and memory needs */
2670                 for (cloop = PCI_BASE_ADDRESS_0; cloop <= PCI_BASE_ADDRESS_5; cloop += 4) {
2671                         temp_register = 0xFFFFFFFF;
2672
2673                         rc = pci_bus_write_config_dword (pci_bus, devfn, cloop, temp_register);
2674                         rc = pci_bus_read_config_dword(pci_bus, devfn, cloop, &temp_register);
2675                         dbg("Bar[%x]=0x%x on bus:dev:func(0x%x:%x:%x)\n", cloop, temp_register, func->bus, func->device, 
2676                                 func->function);
2677
2678                         if (!temp_register)
2679                                 continue;
2680
2681                         base64 = 0L;
2682                         if (temp_register & PCI_BASE_ADDRESS_SPACE_IO) {
2683                                 /* Map IO */
2684
2685                                 /* set base = amount of IO space */
2686                                 base = temp_register & 0xFFFFFFFC;
2687                                 base = ~base + 1;
2688
2689                                 dbg("NEED IO length(0x%x)\n", base);
2690                                 io_node = get_io_resource(&(resources->io_head),(ulong)base);
2691
2692                                 /* allocate the resource to the board */
2693                                 if (io_node) {
2694                                         dbg("Got IO base=0x%x(length=0x%x)\n", io_node->base, io_node->length);
2695                                         base = (u32)io_node->base;
2696                                         io_node->next = func->io_head;
2697                                         func->io_head = io_node;
2698                                 } else {
2699                                         err("Got NO IO resource(length=0x%x)\n", base);
2700                                         return -ENOMEM;
2701                                 }
2702                         } else {        /* map MEM */
2703                                 int prefetchable = 1;
2704                                 struct pci_resource **res_node = &func->p_mem_head;
2705                                 char *res_type_str = "PMEM";
2706                                 u32     temp_register2;
2707
2708                                 if (!(temp_register & PCI_BASE_ADDRESS_MEM_PREFETCH)) {
2709                                         prefetchable = 0;
2710                                         res_node = &func->mem_head;
2711                                         res_type_str++;
2712                                 }
2713
2714                                 base = temp_register & 0xFFFFFFF0;
2715                                 base = ~base + 1;
2716
2717                                 switch (temp_register & PCI_BASE_ADDRESS_MEM_TYPE_MASK) {
2718                                 case PCI_BASE_ADDRESS_MEM_TYPE_32:
2719                                         dbg("NEED 32 %s bar=0x%x(length=0x%x)\n", res_type_str, temp_register, base);
2720
2721                                         if (prefetchable && resources->p_mem_head)
2722                                                 mem_node=get_resource(&(resources->p_mem_head), (ulong)base);
2723                                         else {
2724                                                 if (prefetchable)
2725                                                         dbg("using MEM for PMEM\n");
2726                                                 mem_node=get_resource(&(resources->mem_head), (ulong)base);
2727                                         }
2728
2729                                         /* allocate the resource to the board */
2730                                         if (mem_node) {
2731                                                 base = (u32)mem_node->base; 
2732                                                 mem_node->next = *res_node;
2733                                                 *res_node = mem_node;
2734                                                 dbg("Got 32 %s base=0x%x(length=0x%x)\n", res_type_str, mem_node->base, 
2735                                                         mem_node->length);
2736                                         } else {
2737                                                 err("Got NO 32 %s resource(length=0x%x)\n", res_type_str, base);
2738                                                 return -ENOMEM;
2739                                         }
2740                                         break;
2741                                 case PCI_BASE_ADDRESS_MEM_TYPE_64:
2742                                         rc = pci_bus_read_config_dword(pci_bus, devfn, cloop+4, &temp_register2);
2743                                         dbg("NEED 64 %s bar=0x%x:%x(length=0x%x)\n", res_type_str, temp_register2, 
2744                                                 temp_register, base);
2745
2746                                         if (prefetchable && resources->p_mem_head)
2747                                                 mem_node = get_resource(&(resources->p_mem_head), (ulong)base);
2748                                         else {
2749                                                 if (prefetchable)
2750                                                         dbg("using MEM for PMEM\n");
2751                                                 mem_node = get_resource(&(resources->mem_head), (ulong)base);
2752                                         }
2753
2754                                         /* allocate the resource to the board */
2755                                         if (mem_node) {
2756                                                 base64 = mem_node->base; 
2757                                                 mem_node->next = *res_node;
2758                                                 *res_node = mem_node;
2759                                                 dbg("Got 64 %s base=0x%x:%x(length=%x)\n", res_type_str, (u32)(base64 >> 32), 
2760                                                         (u32)base64, mem_node->length);
2761                                         } else {
2762                                                 err("Got NO 64 %s resource(length=0x%x)\n", res_type_str, base);
2763                                                 return -ENOMEM;
2764                                         }
2765                                         break;
2766                                 default:
2767                                         dbg("reserved BAR type=0x%x\n", temp_register);
2768                                         break;
2769                                 }
2770
2771                         }
2772
2773                         if (base64) {
2774                                 rc = pci_bus_write_config_dword(pci_bus, devfn, cloop, (u32)base64);
2775                                 cloop += 4;
2776                                 base64 >>= 32;
2777
2778                                 if (base64) {
2779                                         dbg("%s: high dword of base64(0x%x) set to 0\n", __FUNCTION__, (u32)base64);
2780                                         base64 = 0x0L;
2781                                 }
2782
2783                                 rc = pci_bus_write_config_dword(pci_bus, devfn, cloop, (u32)base64);
2784                         } else {
2785                                 rc = pci_bus_write_config_dword(pci_bus, devfn, cloop, base);
2786                         }
2787                 }               /* End of base register loop */
2788
2789 #if defined(CONFIG_X86_64)
2790                 /* Figure out which interrupt pin this function uses */
2791                 rc = pci_bus_read_config_byte (pci_bus, devfn, PCI_INTERRUPT_PIN, &temp_byte);
2792
2793                 /* If this function needs an interrupt and we are behind a bridge
2794                    and the pin is tied to something that's alread mapped,
2795                    set this one the same
2796                  */
2797                 if (temp_byte && resources->irqs && 
2798                     (resources->irqs->valid_INT & 
2799                      (0x01 << ((temp_byte + resources->irqs->barber_pole - 1) & 0x03)))) {
2800                         /* We have to share with something already set up */
2801                         IRQ = resources->irqs->interrupt[(temp_byte + resources->irqs->barber_pole - 1) & 0x03];
2802                 } else {
2803                         /* Program IRQ based on card type */
2804                         rc = pci_bus_read_config_byte (pci_bus, devfn, 0x0B, &class_code);
2805
2806                         if (class_code == PCI_BASE_CLASS_STORAGE) {
2807                                 IRQ = shpchp_disk_irq;
2808                         } else {
2809                                 IRQ = shpchp_nic_irq;
2810                         }
2811                 }
2812
2813                 /* IRQ Line */
2814                 rc = pci_bus_write_config_byte (pci_bus, devfn, PCI_INTERRUPT_LINE, IRQ);
2815
2816                 if (!behind_bridge) {
2817                         rc = shpchp_set_irq(func->bus, func->device, temp_byte + 0x09, IRQ);
2818                         if (rc)
2819                                 return(1);
2820                 } else {
2821                         /* TBD - this code may also belong in the other clause of this If statement */
2822                         resources->irqs->interrupt[(temp_byte + resources->irqs->barber_pole - 1) & 0x03] = IRQ;
2823                         resources->irqs->valid_INT |= 0x01 << (temp_byte + resources->irqs->barber_pole - 1) & 0x03;
2824                 }
2825 #endif
2826                 /* Disable ROM base Address */
2827                 rc = pci_bus_write_config_dword (pci_bus, devfn, PCI_ROM_ADDRESS, 0x00);
2828
2829                 /* Set HP parameters (Cache Line Size, Latency Timer) */
2830                 rc = shpchprm_set_hpp(ctrl, func, PCI_HEADER_TYPE_NORMAL);
2831                 if (rc)
2832                         return rc;
2833
2834                 shpchprm_enable_card(ctrl, func, PCI_HEADER_TYPE_NORMAL);
2835
2836                 dbg("PCI function Hot-Added s:b:d:f(%02x:%02x:%02x:%02x)\n", ctrl->seg, func->bus, func->device, func->function);
2837         }                       /* End of Not-A-Bridge else */
2838         else {
2839                 /* It's some strange type of PCI adapter (Cardbus?) */
2840                 return(DEVICE_TYPE_NOT_SUPPORTED);
2841         }
2842
2843         func->configured = 1;
2844
2845         return 0;
2846 }
2847