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_PARM (debug, "i");
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 long_delay (3 * HZ); /* 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)
841 struct pci_dev *dev = NULL;
844 debug ("%s - entry slot # %d\n", __FUNCTION__, slot_cur->number);
845 if (SET_BUS_STATUS (slot_cur->ctrl) && is_bus_empty (slot_cur)) {
846 rc = slot_update (&slot_cur);
849 speed = SLOT_SPEED (slot_cur->ext_status);
850 debug ("ext_status = %x, speed = %x\n", slot_cur->ext_status, speed);
852 case HPC_SLOT_SPEED_33:
853 cmd = HPC_BUS_33CONVMODE;
855 case HPC_SLOT_SPEED_66:
856 if (SLOT_PCIX (slot_cur->ext_status)) {
857 if ((slot_cur->supported_speed >= BUS_SPEED_66) && (slot_cur->supported_bus_mode == BUS_MODE_PCIX))
858 cmd = HPC_BUS_66PCIXMODE;
859 else if (!SLOT_BUS_MODE (slot_cur->ext_status))
860 /* if max slot/bus capability is 66 pci
861 and there's no bus mode mismatch, then
862 the adapter supports 66 pci */
863 cmd = HPC_BUS_66CONVMODE;
865 cmd = HPC_BUS_33CONVMODE;
867 if (slot_cur->supported_speed >= BUS_SPEED_66)
868 cmd = HPC_BUS_66CONVMODE;
870 cmd = HPC_BUS_33CONVMODE;
873 case HPC_SLOT_SPEED_133:
874 switch (slot_cur->supported_speed) {
876 cmd = HPC_BUS_33CONVMODE;
879 if (slot_cur->supported_bus_mode == BUS_MODE_PCIX)
880 cmd = HPC_BUS_66PCIXMODE;
882 cmd = HPC_BUS_66CONVMODE;
885 cmd = HPC_BUS_100PCIXMODE;
888 /* This is to take care of the bug in CIOBX chip */
889 while ((dev = pci_find_device(PCI_VENDOR_ID_SERVERWORKS,
890 0x0101, dev)) != NULL)
891 ibmphp_hpc_writeslot (slot_cur, HPC_BUS_100PCIXMODE);
892 cmd = HPC_BUS_133PCIXMODE;
895 err ("Wrong bus speed\n");
900 err ("wrong slot speed\n");
903 debug ("setting bus speed for slot %d, cmd %x\n", slot_cur->number, cmd);
904 retval = ibmphp_hpc_writeslot (slot_cur, cmd);
906 err ("setting bus speed failed\n");
909 if (CTLR_RESULT (slot_cur->ctrl->status)) {
910 err ("command not completed successfully in set_bus\n");
914 /* This is for x440, once Brandon fixes the firmware,
915 will not need this delay */
917 debug ("%s -Exit\n", __FUNCTION__);
921 /* This routine checks the bus limitations that the slot is on from the BIOS.
922 * This is used in deciding whether or not to power up the slot.
923 * (electrical/spec limitations. For example, >1 133 MHz or >2 66 PCI cards on
926 * Returns: 0 = no limitations, -EINVAL = exceeded limitations on the bus
928 static int check_limitations (struct slot *slot_cur)
931 struct slot * tmp_slot;
935 for (i = slot_cur->bus_on->slot_min; i <= slot_cur->bus_on->slot_max; i++) {
936 tmp_slot = ibmphp_get_slot_from_physical_num (i);
939 if ((SLOT_PWRGD (tmp_slot->status)) && !(SLOT_CONNECT (tmp_slot->status)))
942 get_cur_bus_info (&slot_cur);
943 switch (slot_cur->bus_on->current_speed) {
945 limitation = slot_cur->bus_on->slots_at_33_conv;
948 if (slot_cur->bus_on->current_bus_mode == BUS_MODE_PCIX)
949 limitation = slot_cur->bus_on->slots_at_66_pcix;
951 limitation = slot_cur->bus_on->slots_at_66_conv;
954 limitation = slot_cur->bus_on->slots_at_100_pcix;
957 limitation = slot_cur->bus_on->slots_at_133_pcix;
961 if ((count + 1) > limitation)
966 static inline void print_card_capability (struct slot *slot_cur)
968 info ("capability of the card is ");
969 if ((slot_cur->ext_status & CARD_INFO) == PCIX133)
970 info (" 133 MHz PCI-X\n");
971 else if ((slot_cur->ext_status & CARD_INFO) == PCIX66)
972 info (" 66 MHz PCI-X\n");
973 else if ((slot_cur->ext_status & CARD_INFO) == PCI66)
974 info (" 66 MHz PCI\n");
976 info (" 33 MHz PCI\n");
980 /* This routine will power on the slot, configure the device(s) and find the
982 * Parameters: hotplug_slot
983 * Returns: 0 or failure codes
985 static int enable_slot (struct hotplug_slot *hs)
988 struct slot *slot_cur;
990 struct pci_func *tmp_func;
992 ibmphp_lock_operations ();
994 debug ("ENABLING SLOT........\n");
995 slot_cur = (struct slot *) hs->private;
997 if ((rc = validate (slot_cur, ENABLE))) {
998 err ("validate function failed\n");
1002 attn_LED_blink (slot_cur);
1004 rc = set_bus (slot_cur);
1006 err ("was not able to set the bus\n");
1010 /*-----------------debugging------------------------------*/
1011 get_cur_bus_info (&slot_cur);
1012 debug ("the current bus speed right after set_bus = %x\n", slot_cur->bus_on->current_speed);
1013 /*----------------------------------------------------------*/
1015 rc = check_limitations (slot_cur);
1017 err ("Adding this card exceeds the limitations of this bus.\n");
1018 err ("(i.e., >1 133MHz cards running on same bus, or "
1019 ">2 66 PCI cards running on same bus\n.");
1020 err ("Try hot-adding into another bus\n");
1025 rc = power_on (slot_cur);
1028 err ("something wrong when powering up... please see below for details\n");
1029 /* need to turn off before on, otherwise, blinking overwrites */
1032 if (slot_update (&slot_cur)) {
1033 attn_off (slot_cur);
1038 /* Check to see the error of why it failed */
1039 if ((SLOT_POWER (slot_cur->status)) && !(SLOT_PWRGD (slot_cur->status)))
1040 err ("power fault occurred trying to power up\n");
1041 else if (SLOT_BUS_SPEED (slot_cur->status)) {
1042 err ("bus speed mismatch occurred. please check current bus speed and card capability\n");
1043 print_card_capability (slot_cur);
1044 } else if (SLOT_BUS_MODE (slot_cur->ext_status)) {
1045 err ("bus mode mismatch occurred. please check current bus mode and card capability\n");
1046 print_card_capability (slot_cur);
1048 ibmphp_update_slot_info (slot_cur);
1051 debug ("after power_on\n");
1052 /*-----------------------debugging---------------------------*/
1053 get_cur_bus_info (&slot_cur);
1054 debug ("the current bus speed right after power_on = %x\n", slot_cur->bus_on->current_speed);
1055 /*----------------------------------------------------------*/
1057 rc = slot_update (&slot_cur);
1062 if (SLOT_POWER (slot_cur->status) && !(SLOT_PWRGD (slot_cur->status))) {
1063 err ("power fault occurred trying to power up...\n");
1066 if (SLOT_POWER (slot_cur->status) && (SLOT_BUS_SPEED (slot_cur->status))) {
1067 err ("bus speed mismatch occurred. please check current bus speed and card capability\n");
1068 print_card_capability (slot_cur);
1071 /* Don't think this case will happen after above checks... but just in case, for paranoia sake */
1072 if (!(SLOT_POWER (slot_cur->status))) {
1073 err ("power on failed...\n");
1077 slot_cur->func = (struct pci_func *) kmalloc (sizeof (struct pci_func), GFP_KERNEL);
1078 if (!slot_cur->func) {
1079 /* We cannot do update_slot_info here, since no memory for
1080 * kmalloc n.e.ways, and update_slot_info allocates some */
1081 err ("out of system memory\n");
1085 memset (slot_cur->func, 0, sizeof (struct pci_func));
1086 slot_cur->func->busno = slot_cur->bus;
1087 slot_cur->func->device = slot_cur->device;
1088 for (i = 0; i < 4; i++)
1089 slot_cur->func->irq[i] = slot_cur->irq[i];
1091 debug ("b4 configure_card, slot_cur->bus = %x, slot_cur->device = %x\n", slot_cur->bus, slot_cur->device);
1093 if (ibmphp_configure_card (slot_cur->func, slot_cur->number)) {
1094 err ("configure_card was unsuccessful...\n");
1095 ibmphp_unconfigure_card (&slot_cur, 1); /* true because don't need to actually deallocate resources, just remove references */
1096 debug ("after unconfigure_card\n");
1097 slot_cur->func = NULL;
1104 tmp_func = ibm_slot_find (slot_cur->bus, slot_cur->func->device, function++);
1105 if (tmp_func && !(tmp_func->dev))
1106 ibm_configure_device (tmp_func);
1109 attn_off (slot_cur);
1110 if (slot_update (&slot_cur)) {
1114 ibmphp_print_test ();
1115 rc = ibmphp_update_slot_info (slot_cur);
1117 ibmphp_unlock_operations();
1121 attn_off (slot_cur); /* need to turn off if was blinking b4 */
1124 rcpr = slot_update (&slot_cur);
1129 ibmphp_update_slot_info (slot_cur);
1133 attn_off (slot_cur); /* need to turn off if was blinking b4 */
1135 rcpr = power_off (slot_cur);
1143 /**************************************************************
1144 * HOT REMOVING ADAPTER CARD *
1145 * INPUT: POINTER TO THE HOTPLUG SLOT STRUCTURE *
1146 * OUTPUT: SUCCESS 0 ; FAILURE: UNCONFIGURE , VALIDATE *
1148 **************************************************************/
1149 static int ibmphp_disable_slot (struct hotplug_slot *hotplug_slot)
1151 struct slot *slot = hotplug_slot->private;
1154 ibmphp_lock_operations();
1155 rc = ibmphp_do_disable_slot(slot);
1156 ibmphp_unlock_operations();
1160 int ibmphp_do_disable_slot (struct slot *slot_cur)
1165 debug ("DISABLING SLOT...\n");
1167 if ((slot_cur == NULL) || (slot_cur->ctrl == NULL)) {
1171 flag = slot_cur->flag;
1172 slot_cur->flag = TRUE;
1175 rc = validate (slot_cur, DISABLE); /* checking if powered off already & valid slot # */
1179 attn_LED_blink (slot_cur);
1181 if (slot_cur->func == NULL) {
1182 /* We need this for fncs's that were there on bootup */
1183 slot_cur->func = (struct pci_func *) kmalloc (sizeof (struct pci_func), GFP_KERNEL);
1184 if (!slot_cur->func) {
1185 err ("out of system memory\n");
1189 memset (slot_cur->func, 0, sizeof (struct pci_func));
1190 slot_cur->func->busno = slot_cur->bus;
1191 slot_cur->func->device = slot_cur->device;
1194 ibm_unconfigure_device(slot_cur->func);
1196 /* If we got here from latch suddenly opening on operating card or
1197 a power fault, there's no power to the card, so cannot
1198 read from it to determine what resources it occupied. This operation
1199 is forbidden anyhow. The best we can do is remove it from kernel
1203 attn_off (slot_cur);
1207 rc = ibmphp_unconfigure_card (&slot_cur, 0);
1208 slot_cur->func = NULL;
1209 debug ("in disable_slot. after unconfigure_card\n");
1211 err ("could not unconfigure card.\n");
1215 rc = ibmphp_hpc_writeslot (slot_cur, HPC_SLOT_OFF);
1219 attn_off (slot_cur);
1220 rc = slot_update (&slot_cur);
1224 rc = ibmphp_update_slot_info (slot_cur);
1225 ibmphp_print_test ();
1230 /* Need to turn off if was blinking b4 */
1231 attn_off (slot_cur);
1233 if (slot_update (&slot_cur)) {
1238 ibmphp_update_slot_info (slot_cur);
1242 struct hotplug_slot_ops ibmphp_hotplug_slot_ops = {
1243 .owner = THIS_MODULE,
1244 .set_attention_status = set_attention_status,
1245 .enable_slot = enable_slot,
1246 .disable_slot = ibmphp_disable_slot,
1247 .hardware_test = NULL,
1248 .get_power_status = get_power_status,
1249 .get_attention_status = get_attention_status,
1250 .get_latch_status = get_latch_status,
1251 .get_adapter_status = get_adapter_present,
1252 .get_max_bus_speed = get_max_bus_speed,
1253 .get_cur_bus_speed = get_cur_bus_speed,
1254 /* .get_max_adapter_speed = get_max_adapter_speed,
1255 .get_bus_name_status = get_bus_name,
1259 static void ibmphp_unload (void)
1262 debug ("after slots\n");
1263 ibmphp_free_resources ();
1264 debug ("after resources\n");
1265 ibmphp_free_bus_info_queue ();
1266 debug ("after bus info\n");
1267 ibmphp_free_ebda_hpc_queue ();
1268 debug ("after ebda hpc\n");
1269 ibmphp_free_ebda_pci_rsrc_queue ();
1270 debug ("after ebda pci rsrc\n");
1271 kfree (ibmphp_pci_bus);
1274 static int __init ibmphp_init (void)
1276 struct pci_bus *bus;
1282 info (DRIVER_DESC " version: " DRIVER_VERSION "\n");
1284 ibmphp_pci_bus = kmalloc (sizeof (*ibmphp_pci_bus), GFP_KERNEL);
1285 if (!ibmphp_pci_bus) {
1286 err ("out of memory\n");
1291 bus = pci_find_bus(0, 0);
1293 err ("Can't find the root pci bus, can not continue\n");
1297 memcpy (ibmphp_pci_bus, bus, sizeof (*ibmphp_pci_bus));
1299 ibmphp_debug = debug;
1301 ibmphp_hpc_initvars ();
1303 for (i = 0; i < 16; i++)
1306 if ((rc = ibmphp_access_ebda ()))
1308 debug ("after ibmphp_access_ebda ()\n");
1310 if ((rc = ibmphp_rsrc_init ()))
1312 debug ("AFTER Resource & EBDA INITIALIZATIONS\n");
1314 max_slots = get_max_slots ();
1316 if ((rc = ibmphp_register_pci ()))
1324 ibmphp_print_test ();
1325 if ((rc = ibmphp_hpc_start_poll_thread ())) {
1329 /* lock ourselves into memory with a module
1330 * count of -1 so that no one can unload us. */
1331 module_put(THIS_MODULE);
1341 static void __exit ibmphp_exit (void)
1343 ibmphp_hpc_stop_poll_thread ();
1344 debug ("after polling\n");
1349 module_init (ibmphp_init);
1350 module_exit (ibmphp_exit);