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>
38 #include "../../../arch/x86/pci/pci.h" /* for struct irq_routing_table */
41 #define attn_on(sl) ibmphp_hpc_writeslot (sl, HPC_SLOT_ATTNON)
42 #define attn_off(sl) ibmphp_hpc_writeslot (sl, HPC_SLOT_ATTNOFF)
43 #define attn_LED_blink(sl) ibmphp_hpc_writeslot (sl, HPC_SLOT_BLINKLED)
44 #define get_ctrl_revision(sl, rev) ibmphp_hpc_readslot (sl, READ_REVLEVEL, rev)
45 #define get_hpc_options(sl, opt) ibmphp_hpc_readslot (sl, READ_HPCOPTIONS, opt)
47 #define DRIVER_VERSION "0.6"
48 #define DRIVER_DESC "IBM Hot Plug PCI Controller Driver"
53 module_param(debug, bool, S_IRUGO | S_IWUSR);
54 MODULE_PARM_DESC (debug, "Debugging mode enabled or not");
55 MODULE_LICENSE ("GPL");
56 MODULE_DESCRIPTION (DRIVER_DESC);
58 struct pci_bus *ibmphp_pci_bus;
61 static int irqs[16]; /* PIC mode IRQ's we're using so far (in case MPS
62 * 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 =
91 CURRENT_BUS_MODE(slot_cur->busstatus);
93 slot_cur->bus_on->current_bus_mode = 0xFF;
95 debug("busstatus = %x, bus_speed = %x, bus_mode = %x\n",
97 slot_cur->bus_on->current_speed,
98 slot_cur->bus_on->current_bus_mode);
104 static inline int slot_update(struct slot **sl)
107 rc = ibmphp_hpc_readslot(*sl, READ_ALLSTAT, NULL);
111 rc = get_cur_bus_info(sl);
115 static int __init get_max_slots (void)
117 struct slot * slot_cur;
118 struct list_head * tmp;
121 list_for_each(tmp, &ibmphp_slot_head) {
122 slot_cur = list_entry(tmp, struct slot, ibm_slot_list);
123 /* sometimes the hot-pluggable slots start with 4 (not always from 1) */
124 slot_count = max(slot_count, slot_cur->number);
129 /* This routine will put the correct slot->device information per slot. It's
130 * called from initialization of the slot structures. It will also assign
131 * interrupt numbers per each slot.
132 * Parameters: struct slot
133 * Returns 0 or errors
135 int ibmphp_init_devno(struct slot **cur_slot)
137 struct irq_routing_table *rtable;
142 rtable = pcibios_get_irq_routing_table();
144 err("no BIOS routing table...\n");
148 len = (rtable->size - sizeof(struct irq_routing_table)) /
149 sizeof(struct irq_info);
153 for (loop = 0; loop < len; loop++) {
154 if ((*cur_slot)->number == rtable->slots[loop].slot) {
155 if ((*cur_slot)->bus == rtable->slots[loop].bus) {
156 (*cur_slot)->device = PCI_SLOT(rtable->slots[loop].devfn);
157 for (i = 0; i < 4; i++)
158 (*cur_slot)->irq[i] = IO_APIC_get_PCI_irq_vector((int) (*cur_slot)->bus,
159 (int) (*cur_slot)->device, i);
161 debug("(*cur_slot)->irq[0] = %x\n",
162 (*cur_slot)->irq[0]);
163 debug("(*cur_slot)->irq[1] = %x\n",
164 (*cur_slot)->irq[1]);
165 debug("(*cur_slot)->irq[2] = %x\n",
166 (*cur_slot)->irq[2]);
167 debug("(*cur_slot)->irq[3] = %x\n",
168 (*cur_slot)->irq[3]);
170 debug("rtable->exlusive_irqs = %x\n",
171 rtable->exclusive_irqs);
172 debug("rtable->slots[loop].irq[0].bitmap = %x\n",
173 rtable->slots[loop].irq[0].bitmap);
174 debug("rtable->slots[loop].irq[1].bitmap = %x\n",
175 rtable->slots[loop].irq[1].bitmap);
176 debug("rtable->slots[loop].irq[2].bitmap = %x\n",
177 rtable->slots[loop].irq[2].bitmap);
178 debug("rtable->slots[loop].irq[3].bitmap = %x\n",
179 rtable->slots[loop].irq[3].bitmap);
181 debug("rtable->slots[loop].irq[0].link = %x\n",
182 rtable->slots[loop].irq[0].link);
183 debug("rtable->slots[loop].irq[1].link = %x\n",
184 rtable->slots[loop].irq[1].link);
185 debug("rtable->slots[loop].irq[2].link = %x\n",
186 rtable->slots[loop].irq[2].link);
187 debug("rtable->slots[loop].irq[3].link = %x\n",
188 rtable->slots[loop].irq[3].link);
189 debug("end of init_devno\n");
198 static inline int power_on(struct slot *slot_cur)
200 u8 cmd = HPC_SLOT_ON;
203 retval = ibmphp_hpc_writeslot(slot_cur, cmd);
205 err("power on failed\n");
208 if (CTLR_RESULT(slot_cur->ctrl->status)) {
209 err("command not completed successfully in power_on\n");
212 msleep(3000); /* For ServeRAID cards, and some 66 PCI */
216 static inline int power_off(struct slot *slot_cur)
218 u8 cmd = HPC_SLOT_OFF;
221 retval = ibmphp_hpc_writeslot(slot_cur, cmd);
223 err("power off failed\n");
226 if (CTLR_RESULT(slot_cur->ctrl->status)) {
227 err("command not completed successfully in power_off\n");
233 static int set_attention_status(struct hotplug_slot *hotplug_slot, u8 value)
237 u8 cmd = 0x00; /* avoid compiler warning */
239 debug("set_attention_status - Entry hotplug_slot[%lx] value[%x]\n",
240 (ulong) hotplug_slot, value);
241 ibmphp_lock_operations();
246 case HPC_SLOT_ATTN_OFF:
247 cmd = HPC_SLOT_ATTNOFF;
249 case HPC_SLOT_ATTN_ON:
250 cmd = HPC_SLOT_ATTNON;
252 case HPC_SLOT_ATTN_BLINK:
253 cmd = HPC_SLOT_BLINKLED;
257 err("set_attention_status - Error : invalid input [%x]\n",
262 pslot = hotplug_slot->private;
264 rc = ibmphp_hpc_writeslot(pslot, cmd);
271 ibmphp_unlock_operations();
273 debug("set_attention_status - Exit rc[%d]\n", rc);
277 static int get_attention_status(struct hotplug_slot *hotplug_slot, u8 * value)
283 debug("get_attention_status - Entry hotplug_slot[%lx] pvalue[%lx]\n",
284 (ulong) hotplug_slot, (ulong) value);
286 ibmphp_lock_operations();
288 pslot = hotplug_slot->private;
290 memcpy(&myslot, pslot, sizeof(struct slot));
291 rc = ibmphp_hpc_readslot(pslot, READ_SLOTSTATUS,
294 rc = ibmphp_hpc_readslot(pslot,
296 &(myslot.ext_status));
298 *value = SLOT_ATTN(myslot.status,
303 ibmphp_unlock_operations();
304 debug("get_attention_status - Exit rc[%d] value[%x]\n", rc, *value);
308 static int get_latch_status(struct hotplug_slot *hotplug_slot, u8 * value)
314 debug("get_latch_status - Entry hotplug_slot[%lx] pvalue[%lx]\n",
315 (ulong) hotplug_slot, (ulong) value);
316 ibmphp_lock_operations();
318 pslot = hotplug_slot->private;
320 memcpy(&myslot, pslot, sizeof(struct slot));
321 rc = ibmphp_hpc_readslot(pslot, READ_SLOTSTATUS,
324 *value = SLOT_LATCH(myslot.status);
328 ibmphp_unlock_operations();
329 debug("get_latch_status - Exit rc[%d] rc[%x] value[%x]\n",
335 static int get_power_status(struct hotplug_slot *hotplug_slot, u8 * value)
341 debug("get_power_status - Entry hotplug_slot[%lx] pvalue[%lx]\n",
342 (ulong) hotplug_slot, (ulong) value);
343 ibmphp_lock_operations();
345 pslot = hotplug_slot->private;
347 memcpy(&myslot, pslot, sizeof(struct slot));
348 rc = ibmphp_hpc_readslot(pslot, READ_SLOTSTATUS,
351 *value = SLOT_PWRGD(myslot.status);
355 ibmphp_unlock_operations();
356 debug("get_power_status - Exit rc[%d] rc[%x] value[%x]\n",
361 static int get_adapter_present(struct hotplug_slot *hotplug_slot, u8 * value)
368 debug("get_adapter_status - Entry hotplug_slot[%lx] pvalue[%lx]\n",
369 (ulong) hotplug_slot, (ulong) value);
370 ibmphp_lock_operations();
372 pslot = hotplug_slot->private;
374 memcpy(&myslot, pslot, sizeof(struct slot));
375 rc = ibmphp_hpc_readslot(pslot, READ_SLOTSTATUS,
378 present = SLOT_PRESENT(myslot.status);
379 if (present == HPC_SLOT_EMPTY)
387 ibmphp_unlock_operations();
388 debug("get_adapter_present - Exit rc[%d] value[%x]\n", rc, *value);
392 static int get_max_bus_speed(struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value)
398 debug("%s - Entry hotplug_slot[%p] pvalue[%p]\n", __FUNCTION__,
399 hotplug_slot, value);
401 ibmphp_lock_operations();
404 pslot = hotplug_slot->private;
407 mode = pslot->supported_bus_mode;
408 *value = pslot->supported_speed;
413 if (mode == BUS_MODE_PCIX)
418 *value = pslot->supported_speed + 0x01;
421 /* Note (will need to change): there would be soon 256, 512 also */
427 ibmphp_unlock_operations();
428 debug("%s - Exit rc[%d] value[%x]\n", __FUNCTION__, rc, *value);
432 static int get_cur_bus_speed(struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value)
438 debug("%s - Entry hotplug_slot[%p] pvalue[%p]\n", __FUNCTION__,
439 hotplug_slot, value);
441 ibmphp_lock_operations();
444 pslot = hotplug_slot->private;
446 rc = get_cur_bus_info(&pslot);
448 mode = pslot->bus_on->current_bus_mode;
449 *value = pslot->bus_on->current_speed;
454 if (mode == BUS_MODE_PCIX)
456 else if (mode == BUS_MODE_PCI)
459 *value = PCI_SPEED_UNKNOWN;
466 /* Note of change: there would also be 256, 512 soon */
473 ibmphp_unlock_operations();
474 debug("%s - Exit rc[%d] value[%x]\n", __FUNCTION__, rc, *value);
479 static int get_max_adapter_speed_1(struct hotplug_slot *hotplug_slot, u8 * value, u8 flag)
485 debug("get_max_adapter_speed_1 - Entry hotplug_slot[%lx] pvalue[%lx]\n",
486 (ulong)hotplug_slot, (ulong) value);
489 ibmphp_lock_operations();
491 if (hotplug_slot && value) {
492 pslot = hotplug_slot->private;
494 memcpy(&myslot, pslot, sizeof(struct slot));
495 rc = ibmphp_hpc_readslot(pslot, READ_SLOTSTATUS,
498 if (!(SLOT_LATCH (myslot.status)) &&
499 (SLOT_PRESENT (myslot.status))) {
500 rc = ibmphp_hpc_readslot(pslot,
502 &(myslot.ext_status));
504 *value = SLOT_SPEED(myslot.ext_status);
506 *value = MAX_ADAPTER_NONE;
511 ibmphp_unlock_operations();
513 debug("get_max_adapter_speed_1 - Exit rc[%d] value[%x]\n", rc, *value);
517 static int get_bus_name(struct hotplug_slot *hotplug_slot, char * value)
520 struct slot *pslot = NULL;
522 debug("get_bus_name - Entry hotplug_slot[%lx]\n", (ulong)hotplug_slot);
524 ibmphp_lock_operations();
527 pslot = hotplug_slot->private;
530 snprintf(value, 100, "Bus %x", pslot->bus);
535 ibmphp_unlock_operations();
536 debug("get_bus_name - Exit rc[%d] value[%x]\n", rc, *value);
541 /****************************************************************************
542 * This routine will initialize the ops data structure used in the validate
543 * function. It will also power off empty slots that are powered on since BIOS
544 * leaves those on, albeit disconnected
545 ****************************************************************************/
546 static int __init init_ops(void)
548 struct slot *slot_cur;
549 struct list_head *tmp;
553 list_for_each(tmp, &ibmphp_slot_head) {
554 slot_cur = list_entry(tmp, struct slot, ibm_slot_list);
559 debug("BEFORE GETTING SLOT STATUS, slot # %x\n",
561 if (slot_cur->ctrl->revision == 0xFF)
562 if (get_ctrl_revision(slot_cur,
563 &slot_cur->ctrl->revision))
566 if (slot_cur->bus_on->current_speed == 0xFF)
567 if (get_cur_bus_info(&slot_cur))
570 if (slot_cur->ctrl->options == 0xFF)
571 if (get_hpc_options(slot_cur, &slot_cur->ctrl->options))
574 retval = slot_update(&slot_cur);
578 debug("status = %x\n", slot_cur->status);
579 debug("ext_status = %x\n", slot_cur->ext_status);
580 debug("SLOT_POWER = %x\n", SLOT_POWER(slot_cur->status));
581 debug("SLOT_PRESENT = %x\n", SLOT_PRESENT(slot_cur->status));
582 debug("SLOT_LATCH = %x\n", SLOT_LATCH(slot_cur->status));
584 if ((SLOT_PWRGD(slot_cur->status)) &&
585 !(SLOT_PRESENT(slot_cur->status)) &&
586 !(SLOT_LATCH(slot_cur->status))) {
587 debug("BEFORE POWER OFF COMMAND\n");
588 rc = power_off(slot_cur);
592 /* retval = slot_update(&slot_cur);
595 * ibmphp_update_slot_info(slot_cur);
603 /* This operation will check whether the slot is within the bounds and
604 * the operation is valid to perform on that slot
605 * Parameters: slot, operation
606 * Returns: 0 or error codes
608 static int validate(struct slot *slot_cur, int opn)
615 number = slot_cur->number;
616 if ((number > max_slots) || (number < 0))
618 debug("slot_number in validate is %d\n", slot_cur->number);
620 retval = slot_update(&slot_cur);
626 if (!(SLOT_PWRGD(slot_cur->status)) &&
627 (SLOT_PRESENT(slot_cur->status)) &&
628 !(SLOT_LATCH(slot_cur->status)))
632 if ((SLOT_PWRGD(slot_cur->status)) &&
633 (SLOT_PRESENT(slot_cur->status)) &&
634 !(SLOT_LATCH(slot_cur->status)))
640 err("validate failed....\n");
644 /****************************************************************************
645 * This routine is for updating the data structures in the hotplug core
646 * Parameters: struct slot
647 * Returns: 0 or error
648 ****************************************************************************/
649 int ibmphp_update_slot_info(struct slot *slot_cur)
651 struct hotplug_slot_info *info;
656 info = kmalloc(sizeof(struct hotplug_slot_info), GFP_KERNEL);
658 err("out of system memory\n");
662 info->power_status = SLOT_PWRGD(slot_cur->status);
663 info->attention_status = SLOT_ATTN(slot_cur->status,
664 slot_cur->ext_status);
665 info->latch_status = SLOT_LATCH(slot_cur->status);
666 if (!SLOT_PRESENT(slot_cur->status)) {
667 info->adapter_status = 0;
668 /* info->max_adapter_speed_status = MAX_ADAPTER_NONE; */
670 info->adapter_status = 1;
671 /* get_max_adapter_speed_1(slot_cur->hotplug_slot,
672 &info->max_adapter_speed_status, 0); */
675 bus_speed = slot_cur->bus_on->current_speed;
676 mode = slot_cur->bus_on->current_bus_mode;
682 if (mode == BUS_MODE_PCIX)
684 else if (mode == BUS_MODE_PCI)
687 bus_speed = PCI_SPEED_UNKNOWN;
694 bus_speed = PCI_SPEED_UNKNOWN;
697 info->cur_bus_speed = bus_speed;
698 info->max_bus_speed = slot_cur->hotplug_slot->info->max_bus_speed;
701 rc = pci_hp_change_slot_info(slot_cur->hotplug_slot, info);
707 /******************************************************************************
708 * This function will return the pci_func, given bus and devfunc, or NULL. It
709 * is called from visit routines
710 ******************************************************************************/
712 static struct pci_func *ibm_slot_find(u8 busno, u8 device, u8 function)
714 struct pci_func *func_cur;
715 struct slot *slot_cur;
716 struct list_head * tmp;
717 list_for_each(tmp, &ibmphp_slot_head) {
718 slot_cur = list_entry(tmp, struct slot, ibm_slot_list);
719 if (slot_cur->func) {
720 func_cur = slot_cur->func;
722 if ((func_cur->busno == busno) &&
723 (func_cur->device == device) &&
724 (func_cur->function == function))
726 func_cur = func_cur->next;
733 /*************************************************************
734 * This routine frees up memory used by struct slot, including
735 * the pointers to pci_func, bus, hotplug_slot, controller,
736 * and deregistering from the hotplug core
737 *************************************************************/
738 static void free_slots(void)
740 struct slot *slot_cur;
741 struct list_head * tmp;
742 struct list_head * next;
744 debug("%s -- enter\n", __FUNCTION__);
746 list_for_each_safe(tmp, next, &ibmphp_slot_head) {
747 slot_cur = list_entry(tmp, struct slot, ibm_slot_list);
748 pci_hp_deregister(slot_cur->hotplug_slot);
750 debug("%s -- exit\n", __FUNCTION__);
753 static void ibm_unconfigure_device(struct pci_func *func)
755 struct pci_dev *temp;
758 debug("inside %s\n", __FUNCTION__);
759 debug("func->device = %x, func->function = %x\n",
760 func->device, func->function);
761 debug("func->device << 3 | 0x0 = %x\n", func->device << 3 | 0x0);
763 for (j = 0; j < 0x08; j++) {
764 temp = pci_find_slot(func->busno, (func->device << 3) | j);
766 pci_remove_bus_device(temp);
771 * The following function is to fix kernel bug regarding
772 * getting bus entries, here we manually add those primary
773 * bus entries to kernel bus structure whenever apply
775 static u8 bus_structure_fixup(u8 busno)
781 if (pci_find_bus(0, busno) || !(ibmphp_find_same_bus_num(busno)))
784 bus = kmalloc(sizeof(*bus), GFP_KERNEL);
786 err("%s - out of memory\n", __FUNCTION__);
789 dev = kmalloc(sizeof(*dev), GFP_KERNEL);
792 err("%s - out of memory\n", __FUNCTION__);
797 bus->ops = ibmphp_pci_bus->ops;
799 for (dev->devfn = 0; dev->devfn < 256; dev->devfn += 8) {
800 if (!pci_read_config_word(dev, PCI_VENDOR_ID, &l) &&
801 (l != 0x0000) && (l != 0xffff)) {
802 debug("%s - Inside bus_struture_fixup()\n",
804 pci_scan_bus(busno, ibmphp_pci_bus->ops, NULL);
815 static int ibm_configure_device(struct pci_func *func)
818 struct pci_bus *child;
820 int flag = 0; /* this is to make sure we don't double scan the bus,
821 for bridged devices primarily */
823 if (!(bus_structure_fixup(func->busno)))
825 if (func->dev == NULL)
826 func->dev = pci_find_slot(func->busno,
827 PCI_DEVFN(func->device, func->function));
829 if (func->dev == NULL) {
830 struct pci_bus *bus = pci_find_bus(0, func->busno);
834 num = pci_scan_slot(bus,
835 PCI_DEVFN(func->device, func->function));
837 pci_bus_add_devices(bus);
839 func->dev = pci_find_slot(func->busno,
840 PCI_DEVFN(func->device, func->function));
841 if (func->dev == NULL) {
842 err("ERROR... : pci_dev still NULL\n");
846 if (!(flag) && (func->dev->hdr_type == PCI_HEADER_TYPE_BRIDGE)) {
847 pci_read_config_byte(func->dev, PCI_SECONDARY_BUS, &bus);
848 child = pci_add_new_bus(func->dev->bus, func->dev, bus);
849 pci_do_scan_bus(child);
855 /*******************************************************
856 * Returns whether the bus is empty or not
857 *******************************************************/
858 static int is_bus_empty(struct slot * slot_cur)
861 struct slot * tmp_slot;
862 u8 i = slot_cur->bus_on->slot_min;
864 while (i <= slot_cur->bus_on->slot_max) {
865 if (i == slot_cur->number) {
869 tmp_slot = ibmphp_get_slot_from_physical_num(i);
872 rc = slot_update(&tmp_slot);
875 if (SLOT_PRESENT(tmp_slot->status) &&
876 SLOT_PWRGD(tmp_slot->status))
883 /***********************************************************
884 * If the HPC permits and the bus currently empty, tries to set the
885 * bus speed and mode at the maximum card and bus capability
887 * Returns: bus is set (0) or error code
888 ***********************************************************/
889 static int set_bus(struct slot * slot_cur)
895 static struct pci_device_id ciobx[] = {
896 { PCI_DEVICE(PCI_VENDOR_ID_SERVERWORKS, 0x0101) },
900 debug("%s - entry slot # %d\n", __FUNCTION__, slot_cur->number);
901 if (SET_BUS_STATUS(slot_cur->ctrl) && is_bus_empty(slot_cur)) {
902 rc = slot_update(&slot_cur);
905 speed = SLOT_SPEED(slot_cur->ext_status);
906 debug("ext_status = %x, speed = %x\n", slot_cur->ext_status, speed);
908 case HPC_SLOT_SPEED_33:
909 cmd = HPC_BUS_33CONVMODE;
911 case HPC_SLOT_SPEED_66:
912 if (SLOT_PCIX(slot_cur->ext_status)) {
913 if ((slot_cur->supported_speed >= BUS_SPEED_66) &&
914 (slot_cur->supported_bus_mode == BUS_MODE_PCIX))
915 cmd = HPC_BUS_66PCIXMODE;
916 else if (!SLOT_BUS_MODE(slot_cur->ext_status))
917 /* if max slot/bus capability is 66 pci
918 and there's no bus mode mismatch, then
919 the adapter supports 66 pci */
920 cmd = HPC_BUS_66CONVMODE;
922 cmd = HPC_BUS_33CONVMODE;
924 if (slot_cur->supported_speed >= BUS_SPEED_66)
925 cmd = HPC_BUS_66CONVMODE;
927 cmd = HPC_BUS_33CONVMODE;
930 case HPC_SLOT_SPEED_133:
931 switch (slot_cur->supported_speed) {
933 cmd = HPC_BUS_33CONVMODE;
936 if (slot_cur->supported_bus_mode == BUS_MODE_PCIX)
937 cmd = HPC_BUS_66PCIXMODE;
939 cmd = HPC_BUS_66CONVMODE;
942 cmd = HPC_BUS_100PCIXMODE;
945 /* This is to take care of the bug in CIOBX chip */
946 if (pci_dev_present(ciobx))
947 ibmphp_hpc_writeslot(slot_cur,
948 HPC_BUS_100PCIXMODE);
949 cmd = HPC_BUS_133PCIXMODE;
952 err("Wrong bus speed\n");
957 err("wrong slot speed\n");
960 debug("setting bus speed for slot %d, cmd %x\n",
961 slot_cur->number, cmd);
962 retval = ibmphp_hpc_writeslot(slot_cur, cmd);
964 err("setting bus speed failed\n");
967 if (CTLR_RESULT(slot_cur->ctrl->status)) {
968 err("command not completed successfully in set_bus\n");
972 /* This is for x440, once Brandon fixes the firmware,
973 will not need this delay */
975 debug("%s -Exit\n", __FUNCTION__);
979 /* This routine checks the bus limitations that the slot is on from the BIOS.
980 * This is used in deciding whether or not to power up the slot.
981 * (electrical/spec limitations. For example, >1 133 MHz or >2 66 PCI cards on
984 * Returns: 0 = no limitations, -EINVAL = exceeded limitations on the bus
986 static int check_limitations(struct slot *slot_cur)
989 struct slot * tmp_slot;
993 for (i = slot_cur->bus_on->slot_min; i <= slot_cur->bus_on->slot_max; i++) {
994 tmp_slot = ibmphp_get_slot_from_physical_num(i);
997 if ((SLOT_PWRGD(tmp_slot->status)) &&
998 !(SLOT_CONNECT(tmp_slot->status)))
1001 get_cur_bus_info(&slot_cur);
1002 switch (slot_cur->bus_on->current_speed) {
1004 limitation = slot_cur->bus_on->slots_at_33_conv;
1007 if (slot_cur->bus_on->current_bus_mode == BUS_MODE_PCIX)
1008 limitation = slot_cur->bus_on->slots_at_66_pcix;
1010 limitation = slot_cur->bus_on->slots_at_66_conv;
1013 limitation = slot_cur->bus_on->slots_at_100_pcix;
1016 limitation = slot_cur->bus_on->slots_at_133_pcix;
1020 if ((count + 1) > limitation)
1025 static inline void print_card_capability(struct slot *slot_cur)
1027 info("capability of the card is ");
1028 if ((slot_cur->ext_status & CARD_INFO) == PCIX133)
1029 info(" 133 MHz PCI-X\n");
1030 else if ((slot_cur->ext_status & CARD_INFO) == PCIX66)
1031 info(" 66 MHz PCI-X\n");
1032 else if ((slot_cur->ext_status & CARD_INFO) == PCI66)
1033 info(" 66 MHz PCI\n");
1035 info(" 33 MHz PCI\n");
1039 /* This routine will power on the slot, configure the device(s) and find the
1041 * Parameters: hotplug_slot
1042 * Returns: 0 or failure codes
1044 static int enable_slot(struct hotplug_slot *hs)
1047 struct slot *slot_cur;
1049 struct pci_func *tmp_func;
1051 ibmphp_lock_operations();
1053 debug("ENABLING SLOT........\n");
1054 slot_cur = hs->private;
1056 if ((rc = validate(slot_cur, ENABLE))) {
1057 err("validate function failed\n");
1061 attn_LED_blink(slot_cur);
1063 rc = set_bus(slot_cur);
1065 err("was not able to set the bus\n");
1069 /*-----------------debugging------------------------------*/
1070 get_cur_bus_info(&slot_cur);
1071 debug("the current bus speed right after set_bus = %x\n",
1072 slot_cur->bus_on->current_speed);
1073 /*----------------------------------------------------------*/
1075 rc = check_limitations(slot_cur);
1077 err("Adding this card exceeds the limitations of this bus.\n");
1078 err("(i.e., >1 133MHz cards running on same bus, or "
1079 ">2 66 PCI cards running on same bus.\n");
1080 err("Try hot-adding into another bus\n");
1085 rc = power_on(slot_cur);
1088 err("something wrong when powering up... please see below for details\n");
1089 /* need to turn off before on, otherwise, blinking overwrites */
1092 if (slot_update(&slot_cur)) {
1098 /* Check to see the error of why it failed */
1099 if ((SLOT_POWER(slot_cur->status)) &&
1100 !(SLOT_PWRGD(slot_cur->status)))
1101 err("power fault occurred trying to power up\n");
1102 else if (SLOT_BUS_SPEED(slot_cur->status)) {
1103 err("bus speed mismatch occurred. please check "
1104 "current bus speed and card capability\n");
1105 print_card_capability(slot_cur);
1106 } else if (SLOT_BUS_MODE(slot_cur->ext_status)) {
1107 err("bus mode mismatch occurred. please check "
1108 "current bus mode and card capability\n");
1109 print_card_capability(slot_cur);
1111 ibmphp_update_slot_info(slot_cur);
1114 debug("after power_on\n");
1115 /*-----------------------debugging---------------------------*/
1116 get_cur_bus_info(&slot_cur);
1117 debug("the current bus speed right after power_on = %x\n",
1118 slot_cur->bus_on->current_speed);
1119 /*----------------------------------------------------------*/
1121 rc = slot_update(&slot_cur);
1126 if (SLOT_POWER(slot_cur->status) && !(SLOT_PWRGD(slot_cur->status))) {
1127 err("power fault occurred trying to power up...\n");
1130 if (SLOT_POWER(slot_cur->status) && (SLOT_BUS_SPEED(slot_cur->status))) {
1131 err("bus speed mismatch occurred. please check current bus "
1132 "speed and card capability\n");
1133 print_card_capability(slot_cur);
1136 /* Don't think this case will happen after above checks...
1137 * but just in case, for paranoia sake */
1138 if (!(SLOT_POWER(slot_cur->status))) {
1139 err("power on failed...\n");
1143 slot_cur->func = kzalloc(sizeof(struct pci_func), GFP_KERNEL);
1144 if (!slot_cur->func) {
1145 /* We cannot do update_slot_info here, since no memory for
1146 * kmalloc n.e.ways, and update_slot_info allocates some */
1147 err("out of system memory\n");
1151 slot_cur->func->busno = slot_cur->bus;
1152 slot_cur->func->device = slot_cur->device;
1153 for (i = 0; i < 4; i++)
1154 slot_cur->func->irq[i] = slot_cur->irq[i];
1156 debug("b4 configure_card, slot_cur->bus = %x, slot_cur->device = %x\n",
1157 slot_cur->bus, slot_cur->device);
1159 if (ibmphp_configure_card(slot_cur->func, slot_cur->number)) {
1160 err("configure_card was unsuccessful...\n");
1161 /* true because don't need to actually deallocate resources,
1162 * just remove references */
1163 ibmphp_unconfigure_card(&slot_cur, 1);
1164 debug("after unconfigure_card\n");
1165 slot_cur->func = NULL;
1172 tmp_func = ibm_slot_find(slot_cur->bus, slot_cur->func->device,
1174 if (tmp_func && !(tmp_func->dev))
1175 ibm_configure_device(tmp_func);
1179 if (slot_update(&slot_cur)) {
1183 ibmphp_print_test();
1184 rc = ibmphp_update_slot_info(slot_cur);
1186 ibmphp_unlock_operations();
1190 attn_off(slot_cur); /* need to turn off if was blinking b4 */
1193 rcpr = slot_update(&slot_cur);
1198 ibmphp_update_slot_info(slot_cur);
1202 attn_off(slot_cur); /* need to turn off if was blinking b4 */
1204 rcpr = power_off(slot_cur);
1212 /**************************************************************
1213 * HOT REMOVING ADAPTER CARD *
1214 * INPUT: POINTER TO THE HOTPLUG SLOT STRUCTURE *
1215 * OUTPUT: SUCCESS 0 ; FAILURE: UNCONFIGURE , VALIDATE *
1217 **************************************************************/
1218 static int ibmphp_disable_slot(struct hotplug_slot *hotplug_slot)
1220 struct slot *slot = hotplug_slot->private;
1223 ibmphp_lock_operations();
1224 rc = ibmphp_do_disable_slot(slot);
1225 ibmphp_unlock_operations();
1229 int ibmphp_do_disable_slot(struct slot *slot_cur)
1234 debug("DISABLING SLOT...\n");
1236 if ((slot_cur == NULL) || (slot_cur->ctrl == NULL)) {
1240 flag = slot_cur->flag;
1244 rc = validate(slot_cur, DISABLE);
1245 /* checking if powered off already & valid slot # */
1249 attn_LED_blink(slot_cur);
1251 if (slot_cur->func == NULL) {
1252 /* We need this for fncs's that were there on bootup */
1253 slot_cur->func = kzalloc(sizeof(struct pci_func), GFP_KERNEL);
1254 if (!slot_cur->func) {
1255 err("out of system memory\n");
1259 slot_cur->func->busno = slot_cur->bus;
1260 slot_cur->func->device = slot_cur->device;
1263 ibm_unconfigure_device(slot_cur->func);
1265 /* If we got here from latch suddenly opening on operating card or
1266 a power fault, there's no power to the card, so cannot
1267 read from it to determine what resources it occupied. This operation
1268 is forbidden anyhow. The best we can do is remove it from kernel
1276 rc = ibmphp_unconfigure_card(&slot_cur, 0);
1277 slot_cur->func = NULL;
1278 debug("in disable_slot. after unconfigure_card\n");
1280 err("could not unconfigure card.\n");
1284 rc = ibmphp_hpc_writeslot(slot_cur, HPC_SLOT_OFF);
1289 rc = slot_update(&slot_cur);
1293 rc = ibmphp_update_slot_info(slot_cur);
1294 ibmphp_print_test();
1299 /* Need to turn off if was blinking b4 */
1302 if (slot_update(&slot_cur)) {
1307 ibmphp_update_slot_info(slot_cur);
1311 struct hotplug_slot_ops ibmphp_hotplug_slot_ops = {
1312 .owner = THIS_MODULE,
1313 .set_attention_status = set_attention_status,
1314 .enable_slot = enable_slot,
1315 .disable_slot = ibmphp_disable_slot,
1316 .hardware_test = NULL,
1317 .get_power_status = get_power_status,
1318 .get_attention_status = get_attention_status,
1319 .get_latch_status = get_latch_status,
1320 .get_adapter_status = get_adapter_present,
1321 .get_max_bus_speed = get_max_bus_speed,
1322 .get_cur_bus_speed = get_cur_bus_speed,
1323 /* .get_max_adapter_speed = get_max_adapter_speed,
1324 .get_bus_name_status = get_bus_name,
1328 static void ibmphp_unload(void)
1331 debug("after slots\n");
1332 ibmphp_free_resources();
1333 debug("after resources\n");
1334 ibmphp_free_bus_info_queue();
1335 debug("after bus info\n");
1336 ibmphp_free_ebda_hpc_queue();
1337 debug("after ebda hpc\n");
1338 ibmphp_free_ebda_pci_rsrc_queue();
1339 debug("after ebda pci rsrc\n");
1340 kfree(ibmphp_pci_bus);
1343 static int __init ibmphp_init(void)
1345 struct pci_bus *bus;
1351 info(DRIVER_DESC " version: " DRIVER_VERSION "\n");
1353 ibmphp_pci_bus = kmalloc(sizeof(*ibmphp_pci_bus), GFP_KERNEL);
1354 if (!ibmphp_pci_bus) {
1355 err("out of memory\n");
1360 bus = pci_find_bus(0, 0);
1362 err("Can't find the root pci bus, can not continue\n");
1366 memcpy(ibmphp_pci_bus, bus, sizeof(*ibmphp_pci_bus));
1368 ibmphp_debug = debug;
1370 ibmphp_hpc_initvars();
1372 for (i = 0; i < 16; i++)
1375 if ((rc = ibmphp_access_ebda()))
1377 debug("after ibmphp_access_ebda()\n");
1379 if ((rc = ibmphp_rsrc_init()))
1381 debug("AFTER Resource & EBDA INITIALIZATIONS\n");
1383 max_slots = get_max_slots();
1385 if ((rc = ibmphp_register_pci()))
1393 ibmphp_print_test();
1394 if ((rc = ibmphp_hpc_start_poll_thread())) {
1398 /* lock ourselves into memory with a module
1399 * count of -1 so that no one can unload us. */
1400 module_put(THIS_MODULE);
1410 static void __exit ibmphp_exit(void)
1412 ibmphp_hpc_stop_poll_thread();
1413 debug("after polling\n");
1418 module_init(ibmphp_init);
1419 module_exit(ibmphp_exit);