2 * IBM Hot Plug Controller Driver
4 * Written By: Chuck Cole, Jyoti Shah, Tong Yu, Irene Zubarev, IBM Corporation
6 * Copyright (c) 2001 Greg Kroah-Hartman (greg@kroah.com)
7 * Copyright (c) 2001,2002 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>
38 #include "../../arch/i386/kernel/pci-i386.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_PARM (debug, "i");
54 MODULE_PARM_DESC (debug, "Debugging mode enabled or not");
55 MODULE_LICENSE ("GPL");
56 MODULE_DESCRIPTION (DRIVER_DESC);
58 static int *ops[MAX_OPS + 1];
59 struct pci_ops *ibmphp_pci_root_ops;
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 return 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)
221 debug ("set_attention_status - Entry hotplug_slot[%lx] value[%x]\n", (ulong) hotplug_slot, value);
222 ibmphp_lock_operations ();
223 cmd = 0x00; // avoid compiler warning
227 case HPC_SLOT_ATTN_OFF:
228 cmd = HPC_SLOT_ATTNOFF;
230 case HPC_SLOT_ATTN_ON:
231 cmd = HPC_SLOT_ATTNON;
233 case HPC_SLOT_ATTN_BLINK:
234 cmd = HPC_SLOT_BLINKLED;
238 err ("set_attention_status - Error : invalid input [%x]\n", value);
242 pslot = (struct slot *) hotplug_slot->private;
244 hpcrc = ibmphp_hpc_writeslot (pslot, cmd);
254 ibmphp_unlock_operations ();
256 debug ("set_attention_status - Exit rc[%d]\n", rc);
260 static int get_attention_status (struct hotplug_slot *hotplug_slot, u8 * value)
267 debug ("get_attention_status - Entry hotplug_slot[%lx] pvalue[%lx]\n", (ulong) hotplug_slot, (ulong) value);
269 ibmphp_lock_operations ();
270 if (hotplug_slot && value) {
271 pslot = (struct slot *) hotplug_slot->private;
273 memcpy ((void *) &myslot, (void *) pslot, sizeof (struct slot));
274 hpcrc = ibmphp_hpc_readslot (pslot, READ_SLOTSTATUS, &(myslot.status));
276 hpcrc = ibmphp_hpc_readslot (pslot, READ_EXTSLOTSTATUS, &(myslot.ext_status));
278 *value = SLOT_ATTN (myslot.status, myslot.ext_status);
288 ibmphp_unlock_operations ();
289 debug ("get_attention_status - Exit rc[%d] hpcrc[%x] value[%x]\n", rc, hpcrc, *value);
293 static int get_latch_status (struct hotplug_slot *hotplug_slot, u8 * value)
300 debug ("get_latch_status - Entry hotplug_slot[%lx] pvalue[%lx]\n", (ulong) hotplug_slot, (ulong) value);
301 ibmphp_lock_operations ();
302 if (hotplug_slot && value) {
303 pslot = (struct slot *) hotplug_slot->private;
305 memcpy ((void *) &myslot, (void *) pslot, sizeof (struct slot));
306 hpcrc = ibmphp_hpc_readslot (pslot, READ_SLOTSTATUS, &(myslot.status));
308 *value = SLOT_LATCH (myslot.status);
318 ibmphp_unlock_operations ();
319 debug ("get_latch_status - Exit rc[%d] hpcrc[%x] value[%x]\n", rc, hpcrc, *value);
324 static int get_power_status (struct hotplug_slot *hotplug_slot, u8 * value)
331 debug ("get_power_status - Entry hotplug_slot[%lx] pvalue[%lx]\n", (ulong) hotplug_slot, (ulong) value);
332 ibmphp_lock_operations ();
333 if (hotplug_slot && value) {
334 pslot = (struct slot *) hotplug_slot->private;
336 memcpy ((void *) &myslot, (void *) pslot, sizeof (struct slot));
337 hpcrc = ibmphp_hpc_readslot (pslot, READ_SLOTSTATUS, &(myslot.status));
339 *value = SLOT_PWRGD (myslot.status);
349 ibmphp_unlock_operations ();
350 debug ("get_power_status - Exit rc[%d] hpcrc[%x] value[%x]\n", rc, hpcrc, *value);
354 static int get_adapter_present (struct hotplug_slot *hotplug_slot, u8 * value)
362 debug ("get_adapter_status - Entry hotplug_slot[%lx] pvalue[%lx]\n", (ulong) hotplug_slot, (ulong) value);
363 ibmphp_lock_operations ();
364 if (hotplug_slot && value) {
365 pslot = (struct slot *) hotplug_slot->private;
367 memcpy ((void *) &myslot, (void *) pslot, sizeof (struct slot));
368 hpcrc = ibmphp_hpc_readslot (pslot, READ_SLOTSTATUS, &(myslot.status));
370 present = SLOT_PRESENT (myslot.status);
371 if (present == HPC_SLOT_EMPTY)
383 ibmphp_unlock_operations ();
384 debug ("get_adapter_present - Exit rc[%d] hpcrc[%x] value[%x]\n", rc, hpcrc, *value);
388 static int get_max_bus_speed (struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value)
394 debug ("%s - Entry hotplug_slot[%p] pvalue[%p]\n", __FUNCTION__,
395 hotplug_slot, value);
397 ibmphp_lock_operations ();
399 if (hotplug_slot && value) {
400 pslot = (struct slot *) hotplug_slot->private;
403 mode = pslot->supported_bus_mode;
404 *value = pslot->supported_speed;
409 if (mode == BUS_MODE_PCIX)
414 *value = pslot->supported_speed + 0x01;
417 /* Note (will need to change): there would be soon 256, 512 also */
424 ibmphp_unlock_operations ();
425 debug ("%s - Exit rc[%d] value[%x]\n", __FUNCTION__, rc, *value);
429 static int get_cur_bus_speed (struct hotplug_slot *hotplug_slot, enum pci_bus_speed *value)
435 debug ("%s - Entry hotplug_slot[%p] pvalue[%p]\n", __FUNCTION__,
436 hotplug_slot, value);
438 ibmphp_lock_operations ();
440 if (hotplug_slot && value) {
441 pslot = (struct slot *) hotplug_slot->private;
443 rc = get_cur_bus_info (&pslot);
445 mode = pslot->bus_on->current_bus_mode;
446 *value = pslot->bus_on->current_speed;
451 if (mode == BUS_MODE_PCIX)
453 else if (mode == BUS_MODE_PCI)
456 *value = PCI_SPEED_UNKNOWN;
463 /* Note of change: there would also be 256, 512 soon */
471 ibmphp_unlock_operations ();
472 debug ("%s - Exit rc[%d] value[%x]\n", __FUNCTION__, rc, *value);
476 static int get_max_adapter_speed_1 (struct hotplug_slot *hotplug_slot, u8 * value, u8 flag)
483 debug ("get_max_adapter_speed_1 - Entry hotplug_slot[%lx] pvalue[%lx]\n", (ulong)hotplug_slot, (ulong) value);
486 ibmphp_lock_operations ();
488 if (hotplug_slot && value) {
489 pslot = (struct slot *) hotplug_slot->private;
491 memcpy ((void *) &myslot, (void *) pslot, sizeof (struct slot));
492 hpcrc = ibmphp_hpc_readslot (pslot, READ_SLOTSTATUS, &(myslot.status));
494 if (!(SLOT_LATCH (myslot.status)) && (SLOT_PRESENT (myslot.status))) {
495 hpcrc = ibmphp_hpc_readslot (pslot, READ_EXTSLOTSTATUS, &(myslot.ext_status));
497 *value = SLOT_SPEED (myslot.ext_status);
501 *value = MAX_ADAPTER_NONE;
512 ibmphp_unlock_operations ();
514 debug ("get_max_adapter_speed_1 - Exit rc[%d] hpcrc[%x] value[%x]\n", rc, hpcrc, *value);
518 static int get_bus_name (struct hotplug_slot *hotplug_slot, char * value)
521 struct slot *pslot = NULL;
523 debug ("get_bus_name - Entry hotplug_slot[%lx] \n", (ulong)hotplug_slot);
525 ibmphp_lock_operations ();
528 pslot = (struct slot *) hotplug_slot->private;
531 snprintf (value, 100, "Bus %x", pslot->bus);
536 ibmphp_unlock_operations ();
537 debug ("get_bus_name - Exit rc[%d] value[%x]\n", rc, *value);
542 /*******************************************************************************
543 * This routine will initialize the ops data structure used in the validate
544 * function. It will also power off empty slots that are powered on since BIOS
545 * leaves those on, albeit disconnected
546 ******************************************************************************/
547 static int __init init_ops (void)
549 struct slot *slot_cur;
550 struct list_head *tmp;
555 for (j = 0; j < MAX_OPS; j++) {
556 ops[j] = (int *) kmalloc ((max_slots + 1) * sizeof (int), GFP_KERNEL);
557 memset (ops[j], 0, (max_slots + 1) * sizeof (int));
559 err ("out of system memory \n");
568 list_for_each (tmp, &ibmphp_slot_head) {
569 slot_cur = list_entry (tmp, struct slot, ibm_slot_list);
574 debug ("BEFORE GETTING SLOT STATUS, slot # %x\n", slot_cur->number);
575 if (slot_cur->ctrl->revision == 0xFF)
576 if (get_ctrl_revision (slot_cur, &slot_cur->ctrl->revision))
579 if (slot_cur->bus_on->current_speed == 0xFF)
580 if (get_cur_bus_info (&slot_cur))
583 if (slot_cur->ctrl->options == 0xFF)
584 if (get_hpc_options (slot_cur, &slot_cur->ctrl->options))
587 retval = slot_update (&slot_cur);
591 debug ("status = %x, ext_status = %x\n", slot_cur->status, slot_cur->ext_status);
592 debug ("SLOT_POWER = %x, SLOT_PRESENT = %x, SLOT_LATCH = %x\n", SLOT_POWER (slot_cur->status), SLOT_PRESENT (slot_cur->status), SLOT_LATCH (slot_cur->status));
594 if (!(SLOT_PWRGD (slot_cur->status)) && (SLOT_PRESENT (slot_cur->status)) && !(SLOT_LATCH (slot_cur->status)))
595 /* No power, adapter, and latch closed */
596 ops[ADD][slot_cur->number] = 1;
598 ops[ADD][slot_cur->number] = 0;
600 ops[DETAIL][slot_cur->number] = 1;
602 if ((SLOT_PWRGD (slot_cur->status)) && (SLOT_PRESENT (slot_cur->status)) && !(SLOT_LATCH (slot_cur->status)))
603 /*Power,adapter,latch closed */
604 ops[REMOVE][slot_cur->number] = 1;
606 ops[REMOVE][slot_cur->number] = 0;
608 if ((SLOT_PWRGD (slot_cur->status)) && !(SLOT_PRESENT (slot_cur->status)) && !(SLOT_LATCH (slot_cur->status))) {
609 debug ("BEFORE POWER OFF COMMAND\n");
610 rc = power_off (slot_cur);
614 /* retval = slot_update (&slot_cur);
617 * ibmphp_update_slot_info (slot_cur);
625 /* This operation will check whether the slot is within the bounds and
626 * the operation is valid to perform on that slot
627 * Parameters: slot, operation
628 * Returns: 0 or error codes
630 static int validate (struct slot *slot_cur, int opn)
637 number = slot_cur->number;
638 if ((number > max_slots) || (number < 0))
640 debug ("slot_number in validate is %d\n", slot_cur->number);
642 retval = slot_update (&slot_cur);
646 if (!(SLOT_PWRGD (slot_cur->status)) && (SLOT_PRESENT (slot_cur->status))
647 && !(SLOT_LATCH (slot_cur->status)))
648 ops[ADD][number] = 1;
650 ops[ADD][number] = 0;
652 ops[DETAIL][number] = 1;
654 if ((SLOT_PWRGD (slot_cur->status)) && (SLOT_PRESENT (slot_cur->status))
655 && !(SLOT_LATCH (slot_cur->status)))
656 ops[REMOVE][number] = 1;
658 ops[REMOVE][number] = 0;
662 if (ops[ADD][number])
666 if (ops[REMOVE][number])
670 if (ops[DETAIL][number])
677 err ("validate failed....\n");
681 /********************************************************************************
682 * This routine is for updating the data structures in the hotplug core
683 * Parameters: struct slot
684 * Returns: 0 or error
685 *******************************************************************************/
686 int ibmphp_update_slot_info (struct slot *slot_cur)
688 struct hotplug_slot_info *info;
694 info = kmalloc (sizeof (struct hotplug_slot_info), GFP_KERNEL);
696 err ("out of system memory \n");
700 strncpy (buffer, slot_cur->hotplug_slot->name, 30);
701 info->power_status = SLOT_PWRGD (slot_cur->status);
702 info->attention_status = SLOT_ATTN (slot_cur->status, slot_cur->ext_status);
703 info->latch_status = SLOT_LATCH (slot_cur->status);
704 if (!SLOT_PRESENT (slot_cur->status)) {
705 info->adapter_status = 0;
706 // info->max_adapter_speed_status = MAX_ADAPTER_NONE;
708 info->adapter_status = 1;
709 // get_max_adapter_speed_1 (slot_cur->hotplug_slot, &info->max_adapter_speed_status, 0);
712 bus_speed = slot_cur->bus_on->current_speed;
713 mode = slot_cur->bus_on->current_bus_mode;
719 if (mode == BUS_MODE_PCIX)
721 else if (mode == BUS_MODE_PCI)
724 bus_speed = PCI_SPEED_UNKNOWN;
731 bus_speed = PCI_SPEED_UNKNOWN;
734 info->cur_bus_speed = bus_speed;
735 info->max_bus_speed = slot_cur->hotplug_slot->info->max_bus_speed;
738 rc = pci_hp_change_slot_info (buffer, info);
744 /******************************************************************************
745 * This function will return the pci_func, given bus and devfunc, or NULL. It
746 * is called from visit routines
747 ******************************************************************************/
749 static struct pci_func *ibm_slot_find (u8 busno, u8 device, u8 function)
751 struct pci_func *func_cur;
752 struct slot *slot_cur;
753 struct list_head * tmp;
754 list_for_each (tmp, &ibmphp_slot_head) {
755 slot_cur = list_entry (tmp, struct slot, ibm_slot_list);
756 if (slot_cur->func) {
757 func_cur = slot_cur->func;
759 if ((func_cur->busno == busno) && (func_cur->device == device) && (func_cur->function == function))
761 func_cur = func_cur->next;
768 /* This routine is to find the pci_bus from kernel structures.
769 * Parameters: bus number
770 * Returns : pci_bus * or NULL if not found
772 static struct pci_bus *find_bus (u8 busno)
774 const struct list_head *tmp;
776 debug ("inside find_bus, busno = %x \n", busno);
778 list_for_each (tmp, &pci_root_buses) {
779 bus = (struct pci_bus *) pci_bus_b (tmp);
781 if (bus->number == busno)
787 /******************************************************************
788 * This function is here because we can no longer use pci_root_ops
789 ******************************************************************/
790 static struct pci_ops *get_root_pci_ops (void)
792 struct pci_bus * bus;
794 if ((bus = find_bus (0)))
799 /*************************************************************
800 * This routine frees up memory used by struct slot, including
801 * the pointers to pci_func, bus, hotplug_slot, controller,
802 * and deregistering from the hotplug core
803 *************************************************************/
804 static void free_slots (void)
806 struct slot *slot_cur;
807 struct list_head * tmp;
808 struct list_head * next;
810 debug ("%s -- enter\n", __FUNCTION__);
812 list_for_each_safe (tmp, next, &ibmphp_slot_head) {
814 slot_cur = list_entry (tmp, struct slot, ibm_slot_list);
816 pci_hp_deregister (slot_cur->hotplug_slot);
818 if (slot_cur->hotplug_slot) {
819 kfree (slot_cur->hotplug_slot);
820 slot_cur->hotplug_slot = NULL;
824 slot_cur->ctrl = NULL;
826 if (slot_cur->bus_on)
827 slot_cur->bus_on = NULL;
829 ibmphp_unconfigure_card (&slot_cur, -1); /* we don't want to actually remove the resources, since free_resources will do just that */
834 debug ("%s -- exit\n", __FUNCTION__);
837 static int ibm_is_pci_dev_in_use (struct pci_dev *dev)
845 for (i = 0; !dev->driver && !inuse && (i < 6); i++) {
847 if (!pci_resource_start (dev, i))
850 if (pci_resource_flags (dev, i) & IORESOURCE_IO)
851 inuse = check_region (pci_resource_start (dev, i), pci_resource_len (dev, i));
853 else if (pci_resource_flags (dev, i) & IORESOURCE_MEM)
854 inuse = check_mem_region (pci_resource_start (dev, i), pci_resource_len (dev, i));
860 static int ibm_pci_hp_remove_device (struct pci_dev *dev)
862 if (ibm_is_pci_dev_in_use (dev)) {
863 err ("***Cannot safely power down device -- it appears to be in use***\n");
866 pci_remove_device (dev);
870 static int ibm_unconfigure_visit_pci_dev_phase2 (struct pci_dev_wrapped *wrapped_dev, struct pci_bus_wrapped *wrapped_bus)
872 struct pci_dev *dev = wrapped_dev->dev;
873 struct pci_func *temp_func;
877 temp_func = ibm_slot_find (dev->bus->number, dev->devfn >> 3, i++);
878 } while (temp_func && (temp_func->function != (dev->devfn & 0x07)));
881 if (ibm_pci_hp_remove_device (dev) == 0)
882 kfree (dev); /* Now, remove */
888 temp_func->dev = NULL;
890 debug ("No pci_func representation for bus, devfn = %d, %x\n", dev->bus->number, dev->devfn);
895 static int ibm_unconfigure_visit_pci_bus_phase2 (struct pci_bus_wrapped *wrapped_bus, struct pci_dev_wrapped *wrapped_dev)
897 struct pci_bus *bus = wrapped_bus->bus;
899 pci_proc_detach_bus (bus);
900 /* The cleanup code should live in the kernel... */
901 bus->self->subordinate = NULL;
902 /* unlink from parent bus */
903 list_del (&bus->node);
912 static int ibm_unconfigure_visit_pci_dev_phase1 (struct pci_dev_wrapped *wrapped_dev, struct pci_bus_wrapped *wrapped_bus)
914 struct pci_dev *dev = wrapped_dev->dev;
916 debug ("attempting removal of driver for device (%x, %x, %x)\n", dev->bus->number, PCI_SLOT (dev->devfn), PCI_FUNC (dev->devfn));
918 /* Now, remove the Linux Driver Representation */
920 debug ("is there a driver?\n");
921 if (dev->driver->remove) {
922 dev->driver->remove (dev);
923 debug ("driver was properly removed\n");
928 return ibm_is_pci_dev_in_use (dev);
931 static struct pci_visit ibm_unconfigure_functions_phase1 = {
932 .post_visit_pci_dev = ibm_unconfigure_visit_pci_dev_phase1,
935 static struct pci_visit ibm_unconfigure_functions_phase2 = {
936 .post_visit_pci_bus = ibm_unconfigure_visit_pci_bus_phase2,
937 .post_visit_pci_dev = ibm_unconfigure_visit_pci_dev_phase2,
940 static int ibm_unconfigure_device (struct pci_func *func)
943 struct pci_dev_wrapped wrapped_dev;
944 struct pci_bus_wrapped wrapped_bus;
945 struct pci_dev *temp;
948 memset (&wrapped_dev, 0, sizeof (struct pci_dev_wrapped));
949 memset (&wrapped_bus, 0, sizeof (struct pci_bus_wrapped));
951 debug ("inside ibm_unconfigure_device\n");
952 debug ("func->device = %x, func->function = %x\n", func->device, func->function);
953 debug ("func->device << 3 | 0x0 = %x\n", func->device << 3 | 0x0);
955 for (j = 0; j < 0x08; j++) {
956 temp = pci_find_slot (func->busno, (func->device << 3) | j);
958 wrapped_dev.dev = temp;
959 wrapped_bus.bus = temp->bus;
960 rc = pci_visit_dev (&ibm_unconfigure_functions_phase1, &wrapped_dev, &wrapped_bus);
964 rc = pci_visit_dev (&ibm_unconfigure_functions_phase2, &wrapped_dev, &wrapped_bus);
969 debug ("rc in ibm_unconfigure_device b4 returning is %d \n", rc);
973 static int configure_visit_pci_dev (struct pci_dev_wrapped *wrapped_dev, struct pci_bus_wrapped *wrapped_bus)
975 // struct pci_bus *bus = wrapped_bus->bus; /* We don't need this, since we don't create in the else statement */
976 struct pci_dev *dev = wrapped_dev->dev;
977 struct pci_func *temp_func;
981 temp_func = ibm_slot_find (dev->bus->number, dev->devfn >> 3, i++);
982 } while (temp_func && (temp_func->function != (dev->devfn & 0x07)));
985 temp_func->dev = dev;
987 /* This should not really happen, since we create functions
988 first and then call to configure */
989 debug (" We shouldn't come here \n");
992 if (temp_func->dev) {
993 pci_proc_attach_device (temp_func->dev);
994 pci_announce_device_to_drivers (temp_func->dev);
1000 static struct pci_visit configure_functions = {
1001 .visit_pci_dev =configure_visit_pci_dev,
1006 * The following function is to fix kernel bug regarding
1007 * getting bus entries, here we manually add those primary
1008 * bus entries to kernel bus structure whenever apply
1011 static u8 bus_structure_fixup (u8 busno)
1013 struct pci_bus bus_t;
1014 struct pci_dev dev_t;
1017 if (find_bus (busno) || !(ibmphp_find_same_bus_num (busno)))
1019 bus_t.number = busno;
1020 bus_t.ops = ibmphp_pci_root_ops;
1022 for (dev_t.devfn=0; dev_t.devfn<256; dev_t.devfn += 8) {
1023 if (!pci_read_config_word (&dev_t, PCI_VENDOR_ID, &l) && l != 0x0000 && l != 0xffff) {
1024 debug ("%s - Inside bus_struture_fixup() \n", __FUNCTION__);
1025 pci_scan_bus (busno, ibmphp_pci_root_ops, NULL);
1032 static int ibm_configure_device (struct pci_func *func)
1035 struct pci_dev dev0;
1036 struct pci_bus *child;
1037 struct pci_dev *temp;
1039 int flag = 0; /* this is to make sure we don't double scan the bus, for bridged devices primarily */
1041 struct pci_dev_wrapped wrapped_dev;
1042 struct pci_bus_wrapped wrapped_bus;
1044 memset (&wrapped_dev, 0, sizeof (struct pci_dev_wrapped));
1045 memset (&wrapped_bus, 0, sizeof (struct pci_bus_wrapped));
1046 memset (&dev0, 0, sizeof (struct pci_dev));
1048 if (!(bus_structure_fixup (func->busno)))
1050 if (func->dev == NULL)
1051 func->dev = pci_find_slot (func->busno, (func->device << 3) | (func->function & 0x7));
1053 if (func->dev == NULL) {
1054 dev0.bus = find_bus (func->busno);
1055 dev0.devfn = ((func->device << 3) + (func->function & 0x7));
1056 dev0.sysdata = dev0.bus->sysdata;
1058 func->dev = pci_scan_slot (&dev0);
1060 if (func->dev == NULL) {
1061 err ("ERROR... : pci_dev still NULL \n");
1065 if (!(flag) && (func->dev->hdr_type == PCI_HEADER_TYPE_BRIDGE)) {
1066 pci_read_config_byte (func->dev, PCI_SECONDARY_BUS, &bus);
1067 child = (struct pci_bus *) pci_add_new_bus (func->dev->bus, (func->dev), bus);
1068 pci_do_scan_bus (child);
1073 wrapped_dev.dev = temp;
1074 wrapped_bus.bus = temp->bus;
1075 rc = pci_visit_dev (&configure_functions, &wrapped_dev, &wrapped_bus);
1080 /*******************************************************
1081 * Returns whether the bus is empty or not
1082 *******************************************************/
1083 static int is_bus_empty (struct slot * slot_cur)
1086 struct slot * tmp_slot;
1087 u8 i = slot_cur->bus_on->slot_min;
1089 while (i <= slot_cur->bus_on->slot_max) {
1090 if (i == slot_cur->number) {
1094 tmp_slot = ibmphp_get_slot_from_physical_num (i);
1095 rc = slot_update (&tmp_slot);
1098 if (SLOT_PRESENT (tmp_slot->status) && SLOT_PWRGD (tmp_slot->status))
1105 /***********************************************************
1106 * If the HPC permits and the bus currently empty, tries to set the
1107 * bus speed and mode at the maximum card and bus capability
1109 * Returns: bus is set (0) or error code
1110 ***********************************************************/
1111 static int set_bus (struct slot * slot_cur)
1116 const struct list_head *tmp;
1117 struct pci_dev * dev;
1120 debug ("%s - entry slot # %d \n", __FUNCTION__, slot_cur->number);
1121 if (SET_BUS_STATUS (slot_cur->ctrl) && is_bus_empty (slot_cur)) {
1122 rc = slot_update (&slot_cur);
1125 speed = SLOT_SPEED (slot_cur->ext_status);
1126 debug ("ext_status = %x, speed = %x\n", slot_cur->ext_status, speed);
1128 case HPC_SLOT_SPEED_33:
1129 cmd = HPC_BUS_33CONVMODE;
1131 case HPC_SLOT_SPEED_66:
1132 if (SLOT_PCIX (slot_cur->ext_status)) {
1133 if ((slot_cur->supported_speed >= BUS_SPEED_66) && (slot_cur->supported_bus_mode == BUS_MODE_PCIX))
1134 cmd = HPC_BUS_66PCIXMODE;
1135 else if (!SLOT_BUS_MODE (slot_cur->ext_status))
1136 /* if max slot/bus capability is 66 pci
1137 and there's no bus mode mismatch, then
1138 the adapter supports 66 pci */
1139 cmd = HPC_BUS_66CONVMODE;
1141 cmd = HPC_BUS_33CONVMODE;
1143 if (slot_cur->supported_speed >= BUS_SPEED_66)
1144 cmd = HPC_BUS_66CONVMODE;
1146 cmd = HPC_BUS_33CONVMODE;
1149 case HPC_SLOT_SPEED_133:
1150 switch (slot_cur->supported_speed) {
1152 cmd = HPC_BUS_33CONVMODE;
1155 if (slot_cur->supported_bus_mode == BUS_MODE_PCIX)
1156 cmd = HPC_BUS_66PCIXMODE;
1158 cmd = HPC_BUS_66CONVMODE;
1161 cmd = HPC_BUS_100PCIXMODE;
1164 /* This is to take care of the bug in CIOBX chip*/
1165 list_for_each (tmp, &pci_devices) {
1166 dev = (struct pci_dev *) pci_dev_g (tmp);
1168 if ((dev->vendor == 0x1166) && (dev->device == 0x0101))
1169 ibmphp_hpc_writeslot (slot_cur, HPC_BUS_100PCIXMODE);
1172 cmd = HPC_BUS_133PCIXMODE;
1175 err ("Wrong bus speed \n");
1180 err ("wrong slot speed \n");
1183 debug ("setting bus speed for slot %d, cmd %x\n", slot_cur->number, cmd);
1184 retval = ibmphp_hpc_writeslot (slot_cur, cmd);
1186 err ("setting bus speed failed\n");
1189 if (CTLR_RESULT (slot_cur->ctrl->status)) {
1190 err ("command not completed successfully in set_bus \n");
1194 /* This is for x440, once Brandon fixes the firmware,
1195 will not need this delay */
1196 long_delay (1 * HZ);
1197 debug ("%s -Exit \n", __FUNCTION__);
1201 /* This routine checks the bus limitations that the slot is on from the BIOS.
1202 * This is used in deciding whether or not to power up the slot.
1203 * (electrical/spec limitations. For example, >1 133 MHz or >2 66 PCI cards on
1206 * Returns: 0 = no limitations, -EINVAL = exceeded limitations on the bus
1208 static int check_limitations (struct slot *slot_cur)
1211 struct slot * tmp_slot;
1215 for (i = slot_cur->bus_on->slot_min; i <= slot_cur->bus_on->slot_max; i++) {
1216 tmp_slot = ibmphp_get_slot_from_physical_num (i);
1217 if ((SLOT_PWRGD (tmp_slot->status)) && !(SLOT_CONNECT (tmp_slot->status)))
1220 get_cur_bus_info (&slot_cur);
1221 switch (slot_cur->bus_on->current_speed) {
1223 limitation = slot_cur->bus_on->slots_at_33_conv;
1226 if (slot_cur->bus_on->current_bus_mode == BUS_MODE_PCIX)
1227 limitation = slot_cur->bus_on->slots_at_66_pcix;
1229 limitation = slot_cur->bus_on->slots_at_66_conv;
1232 limitation = slot_cur->bus_on->slots_at_100_pcix;
1235 limitation = slot_cur->bus_on->slots_at_133_pcix;
1239 if ((count + 1) > limitation)
1244 static inline void print_card_capability (struct slot *slot_cur)
1246 info ("capability of the card is ");
1247 if ((slot_cur->ext_status & CARD_INFO) == PCIX133)
1248 info (" 133 MHz PCI-X \n");
1249 else if ((slot_cur->ext_status & CARD_INFO) == PCIX66)
1250 info (" 66 MHz PCI-X \n");
1251 else if ((slot_cur->ext_status & CARD_INFO) == PCI66)
1252 info (" 66 MHz PCI \n");
1254 info (" 33 MHz PCI \n");
1258 /* This routine will power on the slot, configure the device(s) and find the
1260 * Parameters: hotplug_slot
1261 * Returns: 0 or failure codes
1263 static int enable_slot (struct hotplug_slot *hs)
1266 struct slot *slot_cur;
1269 struct pci_func *tmp_func;
1271 ibmphp_lock_operations ();
1273 debug ("ENABLING SLOT........ \n");
1274 slot_cur = (struct slot *) hs->private;
1276 if ((rc = validate (slot_cur, ENABLE))) {
1277 err ("validate function failed \n");
1278 attn_off (slot_cur); /* need to turn off if was blinking b4 */
1280 rc = slot_update (&slot_cur);
1282 ibmphp_unlock_operations();
1285 ibmphp_update_slot_info (slot_cur);
1286 ibmphp_unlock_operations ();
1290 attn_LED_blink (slot_cur);
1292 rc = set_bus (slot_cur);
1294 err ("was not able to set the bus \n");
1295 attn_off (slot_cur);
1297 ibmphp_unlock_operations ();
1301 /*-----------------debugging------------------------------*/
1302 get_cur_bus_info (&slot_cur);
1303 debug ("the current bus speed right after set_bus = %x \n", slot_cur->bus_on->current_speed);
1304 /*----------------------------------------------------------*/
1306 rc = check_limitations (slot_cur);
1308 err ("Adding this card exceeds the limitations of this bus. \n");
1309 err ("(i.e., >1 133MHz cards running on same bus, or >2 66 PCI cards running on same bus \n. Try hot-adding into another bus \n");
1310 attn_off (slot_cur);
1313 if (slot_update (&slot_cur)) {
1314 ibmphp_unlock_operations ();
1317 ibmphp_update_slot_info (slot_cur);
1318 ibmphp_unlock_operations ();
1322 rc = power_on (slot_cur);
1325 err ("something wrong when powering up... please see below for details\n");
1326 /* need to turn off before on, otherwise, blinking overwrites */
1329 if (slot_update (&slot_cur)) {
1330 attn_off (slot_cur);
1332 ibmphp_unlock_operations ();
1335 /* Check to see the error of why it failed */
1336 if ((SLOT_POWER (slot_cur->status)) && !(SLOT_PWRGD (slot_cur->status)))
1337 err ("power fault occured trying to power up \n");
1338 else if (SLOT_BUS_SPEED (slot_cur->status)) {
1339 err ("bus speed mismatch occured. please check current bus speed and card capability \n");
1340 print_card_capability (slot_cur);
1341 } else if (SLOT_BUS_MODE (slot_cur->ext_status)) {
1342 err ("bus mode mismatch occured. please check current bus mode and card capability \n");
1343 print_card_capability (slot_cur);
1345 ibmphp_update_slot_info (slot_cur);
1346 ibmphp_unlock_operations ();
1349 debug ("after power_on\n");
1350 /*-----------------------debugging---------------------------*/
1351 get_cur_bus_info (&slot_cur);
1352 debug ("the current bus speed right after power_on = %x \n", slot_cur->bus_on->current_speed);
1353 /*----------------------------------------------------------*/
1355 rc = slot_update (&slot_cur);
1357 attn_off (slot_cur);
1359 rcpr = power_off (slot_cur);
1361 ibmphp_unlock_operations ();
1364 ibmphp_unlock_operations ();
1368 if (SLOT_POWER (slot_cur->status) && !(SLOT_PWRGD (slot_cur->status))) {
1370 err ("power fault occured trying to power up... \n");
1371 } else if (SLOT_POWER (slot_cur->status) && (SLOT_BUS_SPEED (slot_cur->status))) {
1373 err ("bus speed mismatch occured. please check current bus speed and card capability \n");
1374 print_card_capability (slot_cur);
1376 /* Don't think this case will happen after above checks... but just in case, for paranoia sake */
1377 else if (!(SLOT_POWER (slot_cur->status))) {
1378 err ("power on failed... \n");
1382 attn_off (slot_cur); /* need to turn off b4 on */
1384 rcpr = power_off (slot_cur);
1386 ibmphp_unlock_operations ();
1390 if (slot_update (&slot_cur)) {
1391 ibmphp_unlock_operations ();
1394 ibmphp_update_slot_info (slot_cur);
1395 ibmphp_unlock_operations ();
1399 slot_cur->func = (struct pci_func *) kmalloc (sizeof (struct pci_func), GFP_KERNEL);
1400 if (!slot_cur->func) { /* We cannot do update_slot_info here, since no memory for kmalloc n.e.ways, and update_slot_info allocates some */
1401 err ("out of system memory \n");
1402 attn_off (slot_cur);
1404 rcpr = power_off (slot_cur);
1406 ibmphp_unlock_operations ();
1409 ibmphp_unlock_operations ();
1412 memset (slot_cur->func, 0, sizeof (struct pci_func));
1413 slot_cur->func->busno = slot_cur->bus;
1414 slot_cur->func->device = slot_cur->device;
1415 for (i = 0; i < 4; i++)
1416 slot_cur->func->irq[i] = slot_cur->irq[i];
1418 debug ("b4 configure_card, slot_cur->bus = %x, slot_cur->device = %x\n", slot_cur->bus, slot_cur->device);
1420 if (ibmphp_configure_card (slot_cur->func, slot_cur->number)) {
1421 err ("configure_card was unsuccessful... \n");
1422 ibmphp_unconfigure_card (&slot_cur, 1); /* true because don't need to actually deallocate resources, just remove references */
1423 debug ("after unconfigure_card\n");
1424 slot_cur->func = NULL;
1425 attn_off (slot_cur); /* need to turn off in case was blinking */
1427 rcpr = power_off (slot_cur);
1429 ibmphp_unlock_operations ();
1432 if (slot_update (&slot_cur)) {
1433 ibmphp_unlock_operations();
1436 ibmphp_update_slot_info (slot_cur);
1437 ibmphp_unlock_operations ();
1442 tmp_func = ibm_slot_find (slot_cur->bus, slot_cur->func->device, function++);
1443 if (tmp_func && !(tmp_func->dev))
1444 ibm_configure_device (tmp_func);
1447 attn_off (slot_cur);
1448 if (slot_update (&slot_cur)) {
1449 ibmphp_unlock_operations ();
1452 ibmphp_print_test ();
1453 rc = ibmphp_update_slot_info (slot_cur);
1454 ibmphp_unlock_operations();
1458 /**************************************************************
1459 * HOT REMOVING ADAPTER CARD *
1460 * INPUT: POINTER TO THE HOTPLUG SLOT STRUCTURE *
1461 * OUTPUT: SUCCESS 0 ; FAILURE: UNCONFIGURE , VALIDATE *
1463 **************************************************************/
1464 int ibmphp_disable_slot (struct hotplug_slot *hotplug_slot)
1467 struct slot *slot_cur = (struct slot *) hotplug_slot->private;
1471 debug ("DISABLING SLOT... \n");
1473 if (slot_cur == NULL) {
1474 ibmphp_unlock_operations ();
1478 if (slot_cur->ctrl == NULL) {
1479 ibmphp_unlock_operations ();
1483 flag = slot_cur->flag; /* to see if got here from polling */
1486 ibmphp_lock_operations ();
1488 slot_cur->flag = TRUE;
1491 rc = validate (slot_cur, DISABLE); /* checking if powered off already & valid slot # */
1493 /* Need to turn off if was blinking b4 */
1494 attn_off (slot_cur);
1496 if (slot_update (&slot_cur)) {
1497 ibmphp_unlock_operations ();
1501 ibmphp_update_slot_info (slot_cur);
1502 ibmphp_unlock_operations ();
1506 attn_LED_blink (slot_cur);
1508 if (slot_cur->func == NULL) {
1509 /* We need this for fncs's that were there on bootup */
1510 slot_cur->func = (struct pci_func *) kmalloc (sizeof (struct pci_func), GFP_KERNEL);
1511 if (!slot_cur->func) {
1512 err ("out of system memory \n");
1513 attn_off (slot_cur);
1515 ibmphp_unlock_operations ();
1518 memset (slot_cur->func, 0, sizeof (struct pci_func));
1519 slot_cur->func->busno = slot_cur->bus;
1520 slot_cur->func->device = slot_cur->device;
1523 if ((rc = ibm_unconfigure_device (slot_cur->func))) {
1524 err ("removing from kernel failed... \n");
1525 err ("Please check to see if it was statically linked or is in use otherwise. (perhaps the driver is not 'hot-removable')\n");
1526 attn_off (slot_cur);
1528 ibmphp_unlock_operations ();
1532 /* If we got here from latch suddenly opening on operating card or
1533 a power fault, there's no power to the card, so cannot
1534 read from it to determine what resources it occupied. This operation
1535 is forbidden anyhow. The best we can do is remove it from kernel
1539 attn_off (slot_cur);
1543 rc = ibmphp_unconfigure_card (&slot_cur, parm);
1544 slot_cur->func = NULL;
1545 debug ("in disable_slot. after unconfigure_card\n");
1547 err ("could not unconfigure card.\n");
1548 attn_off (slot_cur); /* need to turn off if was blinking b4 */
1551 if (slot_update (&slot_cur)) {
1552 ibmphp_unlock_operations ();
1557 ibmphp_update_slot_info (slot_cur);
1558 ibmphp_unlock_operations ();
1562 rc = ibmphp_hpc_writeslot (hotplug_slot->private, HPC_SLOT_OFF);
1564 attn_off (slot_cur);
1566 if (slot_update (&slot_cur)) {
1567 ibmphp_unlock_operations ();
1571 ibmphp_update_slot_info (slot_cur);
1572 ibmphp_unlock_operations ();
1576 attn_off (slot_cur);
1577 if (slot_update (&slot_cur)) {
1578 ibmphp_unlock_operations ();
1581 rc = ibmphp_update_slot_info (slot_cur);
1582 ibmphp_print_test ();
1583 ibmphp_unlock_operations();
1587 struct hotplug_slot_ops ibmphp_hotplug_slot_ops = {
1588 .owner = THIS_MODULE,
1589 .set_attention_status = set_attention_status,
1590 .enable_slot = enable_slot,
1591 .disable_slot = ibmphp_disable_slot,
1592 .hardware_test = NULL,
1593 .get_power_status = get_power_status,
1594 .get_attention_status = get_attention_status,
1595 .get_latch_status = get_latch_status,
1596 .get_adapter_status = get_adapter_present,
1597 .get_max_bus_speed = get_max_bus_speed,
1598 .get_cur_bus_speed = get_cur_bus_speed,
1599 /* .get_max_adapter_speed = get_max_adapter_speed,
1600 .get_bus_name_status = get_bus_name,
1604 static void ibmphp_unload (void)
1607 debug ("after slots \n");
1608 ibmphp_free_resources ();
1609 debug ("after resources \n");
1610 ibmphp_free_bus_info_queue ();
1611 debug ("after bus info \n");
1612 ibmphp_free_ebda_hpc_queue ();
1613 debug ("after ebda hpc \n");
1614 ibmphp_free_ebda_pci_rsrc_queue ();
1615 debug ("after ebda pci rsrc \n");
1618 static int __init ibmphp_init (void)
1625 info (DRIVER_DESC " version: " DRIVER_VERSION "\n");
1627 ibmphp_pci_root_ops = get_root_pci_ops ();
1628 if (ibmphp_pci_root_ops == NULL) {
1629 err ("cannot read bus operations... will not be able to read the cards. Please check your system\n");
1633 ibmphp_debug = debug;
1635 ibmphp_hpc_initvars ();
1637 for (i = 0; i < 16; i++)
1640 if ((rc = ibmphp_access_ebda ())) {
1644 debug ("after ibmphp_access_ebda ()\n");
1646 if ((rc = ibmphp_rsrc_init ())) {
1650 debug ("AFTER Resource & EBDA INITIALIZATIONS\n");
1652 max_slots = get_max_slots ();
1654 if ((rc = ibmphp_register_pci ())) {
1663 ibmphp_print_test ();
1664 if ((rc = ibmphp_hpc_start_poll_thread ())) {
1669 /* if no NVRAM module selected, lock ourselves into memory with a
1670 * module count of -1 so that no one can unload us. */
1675 static void __exit ibmphp_exit (void)
1677 ibmphp_hpc_stop_poll_thread ();
1678 debug ("after polling\n");
1683 module_init (ibmphp_init);
1684 module_exit (ibmphp_exit);