2 * IBM Hot Plug Controller Driver
4 * Written By: Chuck Cole, Jyoti Shah, Tong Yu, Irene Zubarev, IBM Corporation
6 * Copyright (C) 2001,2003 Greg Kroah-Hartman (greg@kroah.com)
7 * Copyright (C) 2001-2003 IBM Corp.
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.
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
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.
26 * Send feedback to <gregkh@us.ibm.com>
30 #include <linux/init.h>
31 #include <linux/module.h>
32 #include <linux/slab.h>
33 #include <linux/pci.h>
34 #include <linux/interrupt.h>
35 #include <linux/delay.h>
36 #include <linux/wait.h>
37 #include <linux/smp_lock.h>
39 #include "../../../arch/i386/pci/pci.h" /* for struct irq_routing_table */
42 #define attn_on(sl) ibmphp_hpc_writeslot (sl, HPC_SLOT_ATTNON)
43 #define attn_off(sl) ibmphp_hpc_writeslot (sl, HPC_SLOT_ATTNOFF)
44 #define attn_LED_blink(sl) ibmphp_hpc_writeslot (sl, HPC_SLOT_BLINKLED)
45 #define get_ctrl_revision(sl, rev) ibmphp_hpc_readslot (sl, READ_REVLEVEL, rev)
46 #define get_hpc_options(sl, opt) ibmphp_hpc_readslot (sl, READ_HPCOPTIONS, opt)
48 #define DRIVER_VERSION "0.6"
49 #define DRIVER_DESC "IBM Hot Plug PCI Controller Driver"
54 module_param(debug, bool, S_IRUGO | S_IWUSR);
55 MODULE_PARM_DESC (debug, "Debugging mode enabled or not");
56 MODULE_LICENSE ("GPL");
57 MODULE_DESCRIPTION (DRIVER_DESC);
59 struct pci_bus *ibmphp_pci_bus;
62 static int irqs[16]; /* PIC mode IRQ's we're using so far (in case MPS tables don't provide default info for empty slots */
67 static int get_max_adapter_speed_1 (struct hotplug_slot *, u8 *, u8);
69 static inline int get_max_adapter_speed (struct hotplug_slot *hs, u8 *value)
71 return get_max_adapter_speed_1 (hs, value, 1);
74 static inline int get_cur_bus_info (struct slot **sl)
77 struct slot * slot_cur = *sl;
79 debug ("options = %x\n", slot_cur->ctrl->options);
80 debug ("revision = %x\n", slot_cur->ctrl->revision);
82 if (READ_BUS_STATUS (slot_cur->ctrl))
83 rc = ibmphp_hpc_readslot (slot_cur, READ_BUSSTATUS, NULL);
88 slot_cur->bus_on->current_speed = CURRENT_BUS_SPEED (slot_cur->busstatus);
89 if (READ_BUS_MODE (slot_cur->ctrl))
90 slot_cur->bus_on->current_bus_mode = CURRENT_BUS_MODE (slot_cur->busstatus);
92 slot_cur->bus_on->current_bus_mode = 0xFF;
94 debug ("busstatus = %x, bus_speed = %x, bus_mode = %x\n", slot_cur->busstatus, slot_cur->bus_on->current_speed, slot_cur->bus_on->current_bus_mode);
100 static inline int slot_update (struct slot **sl)
103 rc = ibmphp_hpc_readslot (*sl, READ_ALLSTAT, NULL);
107 rc = get_cur_bus_info(sl);
111 static int __init get_max_slots (void)
113 struct slot * slot_cur;
114 struct list_head * tmp;
117 list_for_each (tmp, &ibmphp_slot_head) {
118 slot_cur = list_entry (tmp, struct slot, ibm_slot_list);
119 /* sometimes the hot-pluggable slots start with 4 (not always from 1) */
120 slot_count = max (slot_count, slot_cur->number);
125 /* This routine will put the correct slot->device information per slot. It's
126 * called from initialization of the slot structures. It will also assign
127 * interrupt numbers per each slot.
128 * Parameters: struct slot
129 * Returns 0 or errors
131 int ibmphp_init_devno (struct slot **cur_slot)
133 struct irq_routing_table *rtable;
138 rtable = pcibios_get_irq_routing_table ();
140 err ("no BIOS routing table...\n");
144 len = (rtable->size - sizeof (struct irq_routing_table)) / sizeof (struct irq_info);
148 for (loop = 0; loop < len; loop++) {
149 if ((*cur_slot)->number == rtable->slots[loop].slot) {
150 if ((*cur_slot)->bus == rtable->slots[loop].bus) {
151 (*cur_slot)->device = PCI_SLOT (rtable->slots[loop].devfn);
152 for (i = 0; i < 4; i++)
153 (*cur_slot)->irq[i] = IO_APIC_get_PCI_irq_vector ((int) (*cur_slot)->bus, (int) (*cur_slot)->device, i);
155 debug ("(*cur_slot)->irq[0] = %x\n", (*cur_slot)->irq[0]);
156 debug ("(*cur_slot)->irq[1] = %x\n", (*cur_slot)->irq[1]);
157 debug ("(*cur_slot)->irq[2] = %x\n", (*cur_slot)->irq[2]);
158 debug ("(*cur_slot)->irq[3] = %x\n", (*cur_slot)->irq[3]);
160 debug ("rtable->exlusive_irqs = %x\n", rtable->exclusive_irqs);
161 debug ("rtable->slots[loop].irq[0].bitmap = %x\n", rtable->slots[loop].irq[0].bitmap);
162 debug ("rtable->slots[loop].irq[1].bitmap = %x\n", rtable->slots[loop].irq[1].bitmap);
163 debug ("rtable->slots[loop].irq[2].bitmap = %x\n", rtable->slots[loop].irq[2].bitmap);
164 debug ("rtable->slots[loop].irq[3].bitmap = %x\n", rtable->slots[loop].irq[3].bitmap);
166 debug ("rtable->slots[loop].irq[0].link= %x\n", rtable->slots[loop].irq[0].link);
167 debug ("rtable->slots[loop].irq[1].link = %x\n", rtable->slots[loop].irq[1].link);
168 debug ("rtable->slots[loop].irq[2].link = %x\n", rtable->slots[loop].irq[2].link);
169 debug ("rtable->slots[loop].irq[3].link = %x\n", rtable->slots[loop].irq[3].link);
170 debug ("end of init_devno\n");
179 static inline int power_on (struct slot *slot_cur)
181 u8 cmd = HPC_SLOT_ON;
184 retval = ibmphp_hpc_writeslot (slot_cur, cmd);
186 err ("power on failed\n");
189 if (CTLR_RESULT (slot_cur->ctrl->status)) {
190 err ("command not completed successfully in power_on\n");
193 msleep(3000); /* For ServeRAID cards, and some 66 PCI */
197 static inline int power_off (struct slot *slot_cur)
199 u8 cmd = HPC_SLOT_OFF;
202 retval = ibmphp_hpc_writeslot (slot_cur, cmd);
204 err ("power off failed\n");
207 if (CTLR_RESULT (slot_cur->ctrl->status)) {
208 err ("command not completed successfully in power_off\n");
214 static int set_attention_status (struct hotplug_slot *hotplug_slot, u8 value)
220 debug ("set_attention_status - Entry hotplug_slot[%lx] value[%x]\n", (ulong) hotplug_slot, value);
221 ibmphp_lock_operations ();
222 cmd = 0x00; // avoid compiler warning
226 case HPC_SLOT_ATTN_OFF:
227 cmd = HPC_SLOT_ATTNOFF;
229 case HPC_SLOT_ATTN_ON:
230 cmd = HPC_SLOT_ATTNON;
232 case HPC_SLOT_ATTN_BLINK:
233 cmd = HPC_SLOT_BLINKLED;
237 err ("set_attention_status - Error : invalid input [%x]\n", value);
241 pslot = (struct slot *) hotplug_slot->private;
243 rc = ibmphp_hpc_writeslot(pslot, cmd);
250 ibmphp_unlock_operations ();
252 debug ("set_attention_status - Exit rc[%d]\n", rc);
256 static int get_attention_status (struct hotplug_slot *hotplug_slot, u8 * value)
262 debug ("get_attention_status - Entry hotplug_slot[%lx] pvalue[%lx]\n", (ulong) hotplug_slot, (ulong) value);
264 ibmphp_lock_operations ();
265 if (hotplug_slot && value) {
266 pslot = (struct slot *) hotplug_slot->private;
268 memcpy ((void *) &myslot, (void *) pslot, sizeof (struct slot));
269 rc = ibmphp_hpc_readslot(pslot, READ_SLOTSTATUS, &(myslot.status));
271 rc = ibmphp_hpc_readslot(pslot, READ_EXTSLOTSTATUS, &(myslot.ext_status));
273 *value = SLOT_ATTN (myslot.status, myslot.ext_status);
277 ibmphp_unlock_operations ();
278 debug("get_attention_status - Exit rc[%d] value[%x]\n", rc, *value);
282 static int get_latch_status (struct hotplug_slot *hotplug_slot, u8 * value)
288 debug ("get_latch_status - Entry hotplug_slot[%lx] pvalue[%lx]\n", (ulong) hotplug_slot, (ulong) value);
289 ibmphp_lock_operations ();
290 if (hotplug_slot && value) {
291 pslot = (struct slot *) hotplug_slot->private;
293 memcpy ((void *) &myslot, (void *) pslot, sizeof (struct slot));
294 rc = ibmphp_hpc_readslot(pslot, READ_SLOTSTATUS, &(myslot.status));
296 *value = SLOT_LATCH (myslot.status);
300 ibmphp_unlock_operations ();
301 debug("get_latch_status - Exit rc[%d] rc[%x] value[%x]\n", rc, rc, *value);
306 static int get_power_status (struct hotplug_slot *hotplug_slot, u8 * value)
312 debug ("get_power_status - Entry hotplug_slot[%lx] pvalue[%lx]\n", (ulong) hotplug_slot, (ulong) value);
313 ibmphp_lock_operations ();
314 if (hotplug_slot && value) {
315 pslot = (struct slot *) hotplug_slot->private;
317 memcpy ((void *) &myslot, (void *) pslot, sizeof (struct slot));
318 rc = ibmphp_hpc_readslot(pslot, READ_SLOTSTATUS, &(myslot.status));
320 *value = SLOT_PWRGD (myslot.status);
324 ibmphp_unlock_operations ();
325 debug("get_power_status - Exit rc[%d] rc[%x] value[%x]\n", rc, rc, *value);
329 static int get_adapter_present (struct hotplug_slot *hotplug_slot, u8 * value)
336 debug ("get_adapter_status - Entry hotplug_slot[%lx] pvalue[%lx]\n", (ulong) hotplug_slot, (ulong) value);
337 ibmphp_lock_operations ();
338 if (hotplug_slot && value) {
339 pslot = (struct slot *) hotplug_slot->private;
341 memcpy ((void *) &myslot, (void *) pslot, sizeof (struct slot));
342 rc = ibmphp_hpc_readslot(pslot, READ_SLOTSTATUS, &(myslot.status));
344 present = SLOT_PRESENT (myslot.status);
345 if (present == HPC_SLOT_EMPTY)
353 ibmphp_unlock_operations ();
354 debug("get_adapter_present - Exit rc[%d] value[%x]\n", rc, *value);
358 static int get_max_bus_speed (struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value)
364 debug ("%s - Entry hotplug_slot[%p] pvalue[%p]\n", __FUNCTION__,
365 hotplug_slot, value);
367 ibmphp_lock_operations ();
369 if (hotplug_slot && value) {
370 pslot = (struct slot *) hotplug_slot->private;
373 mode = pslot->supported_bus_mode;
374 *value = pslot->supported_speed;
379 if (mode == BUS_MODE_PCIX)
384 *value = pslot->supported_speed + 0x01;
387 /* Note (will need to change): there would be soon 256, 512 also */
393 ibmphp_unlock_operations ();
394 debug ("%s - Exit rc[%d] value[%x]\n", __FUNCTION__, rc, *value);
398 static int get_cur_bus_speed (struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value)
404 debug ("%s - Entry hotplug_slot[%p] pvalue[%p]\n", __FUNCTION__,
405 hotplug_slot, value);
407 ibmphp_lock_operations ();
409 if (hotplug_slot && value) {
410 pslot = (struct slot *) hotplug_slot->private;
412 rc = get_cur_bus_info (&pslot);
414 mode = pslot->bus_on->current_bus_mode;
415 *value = pslot->bus_on->current_speed;
420 if (mode == BUS_MODE_PCIX)
422 else if (mode == BUS_MODE_PCI)
425 *value = PCI_SPEED_UNKNOWN;
432 /* Note of change: there would also be 256, 512 soon */
439 ibmphp_unlock_operations ();
440 debug ("%s - Exit rc[%d] value[%x]\n", __FUNCTION__, rc, *value);
444 static int get_max_adapter_speed_1 (struct hotplug_slot *hotplug_slot, u8 * value, u8 flag)
450 debug ("get_max_adapter_speed_1 - Entry hotplug_slot[%lx] pvalue[%lx]\n", (ulong)hotplug_slot, (ulong) value);
453 ibmphp_lock_operations ();
455 if (hotplug_slot && value) {
456 pslot = (struct slot *) hotplug_slot->private;
458 memcpy ((void *) &myslot, (void *) pslot, sizeof (struct slot));
459 rc = ibmphp_hpc_readslot(pslot, READ_SLOTSTATUS, &(myslot.status));
461 if (!(SLOT_LATCH (myslot.status)) && (SLOT_PRESENT (myslot.status))) {
462 rc = ibmphp_hpc_readslot(pslot, READ_EXTSLOTSTATUS, &(myslot.ext_status));
464 *value = SLOT_SPEED (myslot.ext_status);
466 *value = MAX_ADAPTER_NONE;
471 ibmphp_unlock_operations ();
473 debug("get_max_adapter_speed_1 - Exit rc[%d] value[%x]\n", rc, *value);
477 static int get_bus_name (struct hotplug_slot *hotplug_slot, char * value)
480 struct slot *pslot = NULL;
482 debug ("get_bus_name - Entry hotplug_slot[%lx]\n", (ulong)hotplug_slot);
484 ibmphp_lock_operations ();
487 pslot = (struct slot *) hotplug_slot->private;
490 snprintf (value, 100, "Bus %x", pslot->bus);
495 ibmphp_unlock_operations ();
496 debug ("get_bus_name - Exit rc[%d] value[%x]\n", rc, *value);
501 /*******************************************************************************
502 * This routine will initialize the ops data structure used in the validate
503 * function. It will also power off empty slots that are powered on since BIOS
504 * leaves those on, albeit disconnected
505 ******************************************************************************/
506 static int __init init_ops (void)
508 struct slot *slot_cur;
509 struct list_head *tmp;
513 list_for_each (tmp, &ibmphp_slot_head) {
514 slot_cur = list_entry (tmp, struct slot, ibm_slot_list);
519 debug ("BEFORE GETTING SLOT STATUS, slot # %x\n", slot_cur->number);
520 if (slot_cur->ctrl->revision == 0xFF)
521 if (get_ctrl_revision (slot_cur, &slot_cur->ctrl->revision))
524 if (slot_cur->bus_on->current_speed == 0xFF)
525 if (get_cur_bus_info (&slot_cur))
528 if (slot_cur->ctrl->options == 0xFF)
529 if (get_hpc_options (slot_cur, &slot_cur->ctrl->options))
532 retval = slot_update (&slot_cur);
536 debug ("status = %x\n", slot_cur->status);
537 debug ("ext_status = %x\n", slot_cur->ext_status);
538 debug ("SLOT_POWER = %x\n", SLOT_POWER (slot_cur->status));
539 debug ("SLOT_PRESENT = %x\n", SLOT_PRESENT (slot_cur->status));
540 debug ("SLOT_LATCH = %x\n", SLOT_LATCH (slot_cur->status));
542 if ((SLOT_PWRGD (slot_cur->status)) &&
543 !(SLOT_PRESENT (slot_cur->status)) &&
544 !(SLOT_LATCH (slot_cur->status))) {
545 debug ("BEFORE POWER OFF COMMAND\n");
546 rc = power_off (slot_cur);
550 /* retval = slot_update (&slot_cur);
553 * ibmphp_update_slot_info (slot_cur);
561 /* This operation will check whether the slot is within the bounds and
562 * the operation is valid to perform on that slot
563 * Parameters: slot, operation
564 * Returns: 0 or error codes
566 static int validate (struct slot *slot_cur, int opn)
573 number = slot_cur->number;
574 if ((number > max_slots) || (number < 0))
576 debug ("slot_number in validate is %d\n", slot_cur->number);
578 retval = slot_update (&slot_cur);
584 if (!(SLOT_PWRGD (slot_cur->status)) &&
585 (SLOT_PRESENT (slot_cur->status)) &&
586 !(SLOT_LATCH (slot_cur->status)))
590 if ((SLOT_PWRGD (slot_cur->status)) &&
591 (SLOT_PRESENT (slot_cur->status)) &&
592 !(SLOT_LATCH (slot_cur->status)))
598 err ("validate failed....\n");
602 /********************************************************************************
603 * This routine is for updating the data structures in the hotplug core
604 * Parameters: struct slot
605 * Returns: 0 or error
606 *******************************************************************************/
607 int ibmphp_update_slot_info (struct slot *slot_cur)
609 struct hotplug_slot_info *info;
614 info = kmalloc (sizeof (struct hotplug_slot_info), GFP_KERNEL);
616 err ("out of system memory\n");
620 info->power_status = SLOT_PWRGD (slot_cur->status);
621 info->attention_status = SLOT_ATTN (slot_cur->status, slot_cur->ext_status);
622 info->latch_status = SLOT_LATCH (slot_cur->status);
623 if (!SLOT_PRESENT (slot_cur->status)) {
624 info->adapter_status = 0;
625 // info->max_adapter_speed_status = MAX_ADAPTER_NONE;
627 info->adapter_status = 1;
628 // get_max_adapter_speed_1 (slot_cur->hotplug_slot, &info->max_adapter_speed_status, 0);
631 bus_speed = slot_cur->bus_on->current_speed;
632 mode = slot_cur->bus_on->current_bus_mode;
638 if (mode == BUS_MODE_PCIX)
640 else if (mode == BUS_MODE_PCI)
643 bus_speed = PCI_SPEED_UNKNOWN;
650 bus_speed = PCI_SPEED_UNKNOWN;
653 info->cur_bus_speed = bus_speed;
654 info->max_bus_speed = slot_cur->hotplug_slot->info->max_bus_speed;
657 rc = pci_hp_change_slot_info (slot_cur->hotplug_slot, info);
663 /******************************************************************************
664 * This function will return the pci_func, given bus and devfunc, or NULL. It
665 * is called from visit routines
666 ******************************************************************************/
668 static struct pci_func *ibm_slot_find (u8 busno, u8 device, u8 function)
670 struct pci_func *func_cur;
671 struct slot *slot_cur;
672 struct list_head * tmp;
673 list_for_each (tmp, &ibmphp_slot_head) {
674 slot_cur = list_entry (tmp, struct slot, ibm_slot_list);
675 if (slot_cur->func) {
676 func_cur = slot_cur->func;
678 if ((func_cur->busno == busno) && (func_cur->device == device) && (func_cur->function == function))
680 func_cur = func_cur->next;
687 /*************************************************************
688 * This routine frees up memory used by struct slot, including
689 * the pointers to pci_func, bus, hotplug_slot, controller,
690 * and deregistering from the hotplug core
691 *************************************************************/
692 static void free_slots (void)
694 struct slot *slot_cur;
695 struct list_head * tmp;
696 struct list_head * next;
698 debug ("%s -- enter\n", __FUNCTION__);
700 list_for_each_safe (tmp, next, &ibmphp_slot_head) {
701 slot_cur = list_entry (tmp, struct slot, ibm_slot_list);
702 pci_hp_deregister (slot_cur->hotplug_slot);
704 debug ("%s -- exit\n", __FUNCTION__);
707 static void ibm_unconfigure_device(struct pci_func *func)
709 struct pci_dev *temp;
712 debug("inside %s\n", __FUNCTION__);
713 debug("func->device = %x, func->function = %x\n", func->device, func->function);
714 debug("func->device << 3 | 0x0 = %x\n", func->device << 3 | 0x0);
716 for (j = 0; j < 0x08; j++) {
717 temp = pci_find_slot(func->busno, (func->device << 3) | j);
719 pci_remove_bus_device(temp);
724 * The following function is to fix kernel bug regarding
725 * getting bus entries, here we manually add those primary
726 * bus entries to kernel bus structure whenever apply
729 static u8 bus_structure_fixup (u8 busno)
735 if (pci_find_bus(0, busno) || !(ibmphp_find_same_bus_num (busno)))
738 bus = kmalloc (sizeof (*bus), GFP_KERNEL);
740 err ("%s - out of memory\n", __FUNCTION__);
743 dev = kmalloc (sizeof (*dev), GFP_KERNEL);
746 err ("%s - out of memory\n", __FUNCTION__);
751 bus->ops = ibmphp_pci_bus->ops;
753 for (dev->devfn = 0; dev->devfn < 256; dev->devfn += 8) {
754 if (!pci_read_config_word (dev, PCI_VENDOR_ID, &l) && l != 0x0000 && l != 0xffff) {
755 debug ("%s - Inside bus_struture_fixup()\n", __FUNCTION__);
756 pci_scan_bus (busno, ibmphp_pci_bus->ops, NULL);
767 static int ibm_configure_device (struct pci_func *func)
770 struct pci_bus *child;
772 int flag = 0; /* this is to make sure we don't double scan the bus, for bridged devices primarily */
774 if (!(bus_structure_fixup (func->busno)))
776 if (func->dev == NULL)
777 func->dev = pci_find_slot (func->busno, PCI_DEVFN(func->device, func->function));
779 if (func->dev == NULL) {
780 struct pci_bus *bus = pci_find_bus(0, func->busno);
784 num = pci_scan_slot(bus, PCI_DEVFN(func->device, func->function));
786 pci_bus_add_devices(bus);
788 func->dev = pci_find_slot(func->busno, PCI_DEVFN(func->device, func->function));
789 if (func->dev == NULL) {
790 err ("ERROR... : pci_dev still NULL\n");
794 if (!(flag) && (func->dev->hdr_type == PCI_HEADER_TYPE_BRIDGE)) {
795 pci_read_config_byte (func->dev, PCI_SECONDARY_BUS, &bus);
796 child = (struct pci_bus *) pci_add_new_bus (func->dev->bus, (func->dev), bus);
797 pci_do_scan_bus (child);
803 /*******************************************************
804 * Returns whether the bus is empty or not
805 *******************************************************/
806 static int is_bus_empty (struct slot * slot_cur)
809 struct slot * tmp_slot;
810 u8 i = slot_cur->bus_on->slot_min;
812 while (i <= slot_cur->bus_on->slot_max) {
813 if (i == slot_cur->number) {
817 tmp_slot = ibmphp_get_slot_from_physical_num (i);
820 rc = slot_update (&tmp_slot);
823 if (SLOT_PRESENT (tmp_slot->status) && SLOT_PWRGD (tmp_slot->status))
830 /***********************************************************
831 * If the HPC permits and the bus currently empty, tries to set the
832 * bus speed and mode at the maximum card and bus capability
834 * Returns: bus is set (0) or error code
835 ***********************************************************/
836 static int set_bus (struct slot * slot_cur)
842 static struct pci_device_id ciobx[] = {
843 { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS, 0x0101) },
847 debug ("%s - entry slot # %d\n", __FUNCTION__, slot_cur->number);
848 if (SET_BUS_STATUS (slot_cur->ctrl) && is_bus_empty (slot_cur)) {
849 rc = slot_update (&slot_cur);
852 speed = SLOT_SPEED (slot_cur->ext_status);
853 debug ("ext_status = %x, speed = %x\n", slot_cur->ext_status, speed);
855 case HPC_SLOT_SPEED_33:
856 cmd = HPC_BUS_33CONVMODE;
858 case HPC_SLOT_SPEED_66:
859 if (SLOT_PCIX (slot_cur->ext_status)) {
860 if ((slot_cur->supported_speed >= BUS_SPEED_66) && (slot_cur->supported_bus_mode == BUS_MODE_PCIX))
861 cmd = HPC_BUS_66PCIXMODE;
862 else if (!SLOT_BUS_MODE (slot_cur->ext_status))
863 /* if max slot/bus capability is 66 pci
864 and there's no bus mode mismatch, then
865 the adapter supports 66 pci */
866 cmd = HPC_BUS_66CONVMODE;
868 cmd = HPC_BUS_33CONVMODE;
870 if (slot_cur->supported_speed >= BUS_SPEED_66)
871 cmd = HPC_BUS_66CONVMODE;
873 cmd = HPC_BUS_33CONVMODE;
876 case HPC_SLOT_SPEED_133:
877 switch (slot_cur->supported_speed) {
879 cmd = HPC_BUS_33CONVMODE;
882 if (slot_cur->supported_bus_mode == BUS_MODE_PCIX)
883 cmd = HPC_BUS_66PCIXMODE;
885 cmd = HPC_BUS_66CONVMODE;
888 cmd = HPC_BUS_100PCIXMODE;
891 /* This is to take care of the bug in CIOBX chip */
892 if (pci_dev_present(ciobx))
893 ibmphp_hpc_writeslot (slot_cur, HPC_BUS_100PCIXMODE);
894 cmd = HPC_BUS_133PCIXMODE;
897 err ("Wrong bus speed\n");
902 err ("wrong slot speed\n");
905 debug ("setting bus speed for slot %d, cmd %x\n", slot_cur->number, cmd);
906 retval = ibmphp_hpc_writeslot (slot_cur, cmd);
908 err ("setting bus speed failed\n");
911 if (CTLR_RESULT (slot_cur->ctrl->status)) {
912 err ("command not completed successfully in set_bus\n");
916 /* This is for x440, once Brandon fixes the firmware,
917 will not need this delay */
919 debug ("%s -Exit\n", __FUNCTION__);
923 /* This routine checks the bus limitations that the slot is on from the BIOS.
924 * This is used in deciding whether or not to power up the slot.
925 * (electrical/spec limitations. For example, >1 133 MHz or >2 66 PCI cards on
928 * Returns: 0 = no limitations, -EINVAL = exceeded limitations on the bus
930 static int check_limitations (struct slot *slot_cur)
933 struct slot * tmp_slot;
937 for (i = slot_cur->bus_on->slot_min; i <= slot_cur->bus_on->slot_max; i++) {
938 tmp_slot = ibmphp_get_slot_from_physical_num (i);
941 if ((SLOT_PWRGD (tmp_slot->status)) && !(SLOT_CONNECT (tmp_slot->status)))
944 get_cur_bus_info (&slot_cur);
945 switch (slot_cur->bus_on->current_speed) {
947 limitation = slot_cur->bus_on->slots_at_33_conv;
950 if (slot_cur->bus_on->current_bus_mode == BUS_MODE_PCIX)
951 limitation = slot_cur->bus_on->slots_at_66_pcix;
953 limitation = slot_cur->bus_on->slots_at_66_conv;
956 limitation = slot_cur->bus_on->slots_at_100_pcix;
959 limitation = slot_cur->bus_on->slots_at_133_pcix;
963 if ((count + 1) > limitation)
968 static inline void print_card_capability (struct slot *slot_cur)
970 info ("capability of the card is ");
971 if ((slot_cur->ext_status & CARD_INFO) == PCIX133)
972 info (" 133 MHz PCI-X\n");
973 else if ((slot_cur->ext_status & CARD_INFO) == PCIX66)
974 info (" 66 MHz PCI-X\n");
975 else if ((slot_cur->ext_status & CARD_INFO) == PCI66)
976 info (" 66 MHz PCI\n");
978 info (" 33 MHz PCI\n");
982 /* This routine will power on the slot, configure the device(s) and find the
984 * Parameters: hotplug_slot
985 * Returns: 0 or failure codes
987 static int enable_slot (struct hotplug_slot *hs)
990 struct slot *slot_cur;
992 struct pci_func *tmp_func;
994 ibmphp_lock_operations ();
996 debug ("ENABLING SLOT........\n");
997 slot_cur = (struct slot *) hs->private;
999 if ((rc = validate (slot_cur, ENABLE))) {
1000 err ("validate function failed\n");
1004 attn_LED_blink (slot_cur);
1006 rc = set_bus (slot_cur);
1008 err ("was not able to set the bus\n");
1012 /*-----------------debugging------------------------------*/
1013 get_cur_bus_info (&slot_cur);
1014 debug ("the current bus speed right after set_bus = %x\n", slot_cur->bus_on->current_speed);
1015 /*----------------------------------------------------------*/
1017 rc = check_limitations (slot_cur);
1019 err ("Adding this card exceeds the limitations of this bus.\n");
1020 err ("(i.e., >1 133MHz cards running on same bus, or "
1021 ">2 66 PCI cards running on same bus\n.");
1022 err ("Try hot-adding into another bus\n");
1027 rc = power_on (slot_cur);
1030 err ("something wrong when powering up... please see below for details\n");
1031 /* need to turn off before on, otherwise, blinking overwrites */
1034 if (slot_update (&slot_cur)) {
1035 attn_off (slot_cur);
1040 /* Check to see the error of why it failed */
1041 if ((SLOT_POWER (slot_cur->status)) && !(SLOT_PWRGD (slot_cur->status)))
1042 err ("power fault occurred trying to power up\n");
1043 else if (SLOT_BUS_SPEED (slot_cur->status)) {
1044 err ("bus speed mismatch occurred. please check current bus speed and card capability\n");
1045 print_card_capability (slot_cur);
1046 } else if (SLOT_BUS_MODE (slot_cur->ext_status)) {
1047 err ("bus mode mismatch occurred. please check current bus mode and card capability\n");
1048 print_card_capability (slot_cur);
1050 ibmphp_update_slot_info (slot_cur);
1053 debug ("after power_on\n");
1054 /*-----------------------debugging---------------------------*/
1055 get_cur_bus_info (&slot_cur);
1056 debug ("the current bus speed right after power_on = %x\n", slot_cur->bus_on->current_speed);
1057 /*----------------------------------------------------------*/
1059 rc = slot_update (&slot_cur);
1064 if (SLOT_POWER (slot_cur->status) && !(SLOT_PWRGD (slot_cur->status))) {
1065 err ("power fault occurred trying to power up...\n");
1068 if (SLOT_POWER (slot_cur->status) && (SLOT_BUS_SPEED (slot_cur->status))) {
1069 err ("bus speed mismatch occurred. please check current bus speed and card capability\n");
1070 print_card_capability (slot_cur);
1073 /* Don't think this case will happen after above checks... but just in case, for paranoia sake */
1074 if (!(SLOT_POWER (slot_cur->status))) {
1075 err ("power on failed...\n");
1079 slot_cur->func = (struct pci_func *) kmalloc (sizeof (struct pci_func), GFP_KERNEL);
1080 if (!slot_cur->func) {
1081 /* We cannot do update_slot_info here, since no memory for
1082 * kmalloc n.e.ways, and update_slot_info allocates some */
1083 err ("out of system memory\n");
1087 memset (slot_cur->func, 0, sizeof (struct pci_func));
1088 slot_cur->func->busno = slot_cur->bus;
1089 slot_cur->func->device = slot_cur->device;
1090 for (i = 0; i < 4; i++)
1091 slot_cur->func->irq[i] = slot_cur->irq[i];
1093 debug ("b4 configure_card, slot_cur->bus = %x, slot_cur->device = %x\n", slot_cur->bus, slot_cur->device);
1095 if (ibmphp_configure_card (slot_cur->func, slot_cur->number)) {
1096 err ("configure_card was unsuccessful...\n");
1097 ibmphp_unconfigure_card (&slot_cur, 1); /* true because don't need to actually deallocate resources, just remove references */
1098 debug ("after unconfigure_card\n");
1099 slot_cur->func = NULL;
1106 tmp_func = ibm_slot_find (slot_cur->bus, slot_cur->func->device, function++);
1107 if (tmp_func && !(tmp_func->dev))
1108 ibm_configure_device (tmp_func);
1111 attn_off (slot_cur);
1112 if (slot_update (&slot_cur)) {
1116 ibmphp_print_test ();
1117 rc = ibmphp_update_slot_info (slot_cur);
1119 ibmphp_unlock_operations();
1123 attn_off (slot_cur); /* need to turn off if was blinking b4 */
1126 rcpr = slot_update (&slot_cur);
1131 ibmphp_update_slot_info (slot_cur);
1135 attn_off (slot_cur); /* need to turn off if was blinking b4 */
1137 rcpr = power_off (slot_cur);
1145 /**************************************************************
1146 * HOT REMOVING ADAPTER CARD *
1147 * INPUT: POINTER TO THE HOTPLUG SLOT STRUCTURE *
1148 * OUTPUT: SUCCESS 0 ; FAILURE: UNCONFIGURE , VALIDATE *
1150 **************************************************************/
1151 static int ibmphp_disable_slot (struct hotplug_slot *hotplug_slot)
1153 struct slot *slot = hotplug_slot->private;
1156 ibmphp_lock_operations();
1157 rc = ibmphp_do_disable_slot(slot);
1158 ibmphp_unlock_operations();
1162 int ibmphp_do_disable_slot (struct slot *slot_cur)
1167 debug ("DISABLING SLOT...\n");
1169 if ((slot_cur == NULL) || (slot_cur->ctrl == NULL)) {
1173 flag = slot_cur->flag;
1174 slot_cur->flag = TRUE;
1177 rc = validate (slot_cur, DISABLE); /* checking if powered off already & valid slot # */
1181 attn_LED_blink (slot_cur);
1183 if (slot_cur->func == NULL) {
1184 /* We need this for fncs's that were there on bootup */
1185 slot_cur->func = (struct pci_func *) kmalloc (sizeof (struct pci_func), GFP_KERNEL);
1186 if (!slot_cur->func) {
1187 err ("out of system memory\n");
1191 memset (slot_cur->func, 0, sizeof (struct pci_func));
1192 slot_cur->func->busno = slot_cur->bus;
1193 slot_cur->func->device = slot_cur->device;
1196 ibm_unconfigure_device(slot_cur->func);
1198 /* If we got here from latch suddenly opening on operating card or
1199 a power fault, there's no power to the card, so cannot
1200 read from it to determine what resources it occupied. This operation
1201 is forbidden anyhow. The best we can do is remove it from kernel
1205 attn_off (slot_cur);
1209 rc = ibmphp_unconfigure_card (&slot_cur, 0);
1210 slot_cur->func = NULL;
1211 debug ("in disable_slot. after unconfigure_card\n");
1213 err ("could not unconfigure card.\n");
1217 rc = ibmphp_hpc_writeslot (slot_cur, HPC_SLOT_OFF);
1221 attn_off (slot_cur);
1222 rc = slot_update (&slot_cur);
1226 rc = ibmphp_update_slot_info (slot_cur);
1227 ibmphp_print_test ();
1232 /* Need to turn off if was blinking b4 */
1233 attn_off (slot_cur);
1235 if (slot_update (&slot_cur)) {
1240 ibmphp_update_slot_info (slot_cur);
1244 struct hotplug_slot_ops ibmphp_hotplug_slot_ops = {
1245 .owner = THIS_MODULE,
1246 .set_attention_status = set_attention_status,
1247 .enable_slot = enable_slot,
1248 .disable_slot = ibmphp_disable_slot,
1249 .hardware_test = NULL,
1250 .get_power_status = get_power_status,
1251 .get_attention_status = get_attention_status,
1252 .get_latch_status = get_latch_status,
1253 .get_adapter_status = get_adapter_present,
1254 .get_max_bus_speed = get_max_bus_speed,
1255 .get_cur_bus_speed = get_cur_bus_speed,
1256 /* .get_max_adapter_speed = get_max_adapter_speed,
1257 .get_bus_name_status = get_bus_name,
1261 static void ibmphp_unload (void)
1264 debug ("after slots\n");
1265 ibmphp_free_resources ();
1266 debug ("after resources\n");
1267 ibmphp_free_bus_info_queue ();
1268 debug ("after bus info\n");
1269 ibmphp_free_ebda_hpc_queue ();
1270 debug ("after ebda hpc\n");
1271 ibmphp_free_ebda_pci_rsrc_queue ();
1272 debug ("after ebda pci rsrc\n");
1273 kfree (ibmphp_pci_bus);
1276 static int __init ibmphp_init (void)
1278 struct pci_bus *bus;
1284 info (DRIVER_DESC " version: " DRIVER_VERSION "\n");
1286 ibmphp_pci_bus = kmalloc (sizeof (*ibmphp_pci_bus), GFP_KERNEL);
1287 if (!ibmphp_pci_bus) {
1288 err ("out of memory\n");
1293 bus = pci_find_bus(0, 0);
1295 err ("Can't find the root pci bus, can not continue\n");
1299 memcpy (ibmphp_pci_bus, bus, sizeof (*ibmphp_pci_bus));
1301 ibmphp_debug = debug;
1303 ibmphp_hpc_initvars ();
1305 for (i = 0; i < 16; i++)
1308 if ((rc = ibmphp_access_ebda ()))
1310 debug ("after ibmphp_access_ebda ()\n");
1312 if ((rc = ibmphp_rsrc_init ()))
1314 debug ("AFTER Resource & EBDA INITIALIZATIONS\n");
1316 max_slots = get_max_slots ();
1318 if ((rc = ibmphp_register_pci ()))
1326 ibmphp_print_test ();
1327 if ((rc = ibmphp_hpc_start_poll_thread ())) {
1331 /* lock ourselves into memory with a module
1332 * count of -1 so that no one can unload us. */
1333 module_put(THIS_MODULE);
1343 static void __exit ibmphp_exit (void)
1345 ibmphp_hpc_stop_poll_thread ();
1346 debug ("after polling\n");
1351 module_init (ibmphp_init);
1352 module_exit (ibmphp_exit);