2 * Compaq Hot Plug Controller Driver
4 * Copyright (C) 1995,2001 Compaq Computer Corporation
5 * Copyright (C) 2001 Greg Kroah-Hartman <greg@kroah.com>
6 * Copyright (C) 2001 IBM Corp.
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or (at
13 * your option) any later version.
15 * This program is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
18 * NON INFRINGEMENT. See the GNU General Public License for more
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 * Send feedback to <greg@kroah.com>
27 * Jan 12, 2003 - Added 66/100/133MHz PCI-X support,
28 * Torben Mathiasen <torben.mathiasen@hp.com>
31 #include <linux/module.h>
32 #include <linux/moduleparam.h>
33 #include <linux/kernel.h>
34 #include <linux/types.h>
35 #include <linux/proc_fs.h>
36 #include <linux/slab.h>
37 #include <linux/workqueue.h>
38 #include <linux/pci.h>
39 #include <linux/pci_hotplug.h>
40 #include <linux/init.h>
41 #include <linux/interrupt.h>
43 #include <asm/uaccess.h>
46 #include "cpqphp_nvram.h"
49 /* Global variables */
51 int cpqhp_legacy_mode
;
52 struct controller
*cpqhp_ctrl_list
; /* = NULL */
53 struct pci_func
*cpqhp_slot_list
[256];
54 struct irq_routing_table
*cpqhp_routing_table
;
57 static void __iomem
*smbios_table
;
58 static void __iomem
*smbios_start
;
59 static void __iomem
*cpqhp_rom_start
;
60 static bool power_mode
;
62 static int initialized
;
64 #define DRIVER_VERSION "0.9.8"
65 #define DRIVER_AUTHOR "Dan Zink <dan.zink@compaq.com>, Greg Kroah-Hartman <greg@kroah.com>"
66 #define DRIVER_DESC "Compaq Hot Plug PCI Controller Driver"
68 MODULE_AUTHOR(DRIVER_AUTHOR
);
69 MODULE_DESCRIPTION(DRIVER_DESC
);
70 MODULE_LICENSE("GPL");
72 module_param(power_mode
, bool, 0644);
73 MODULE_PARM_DESC(power_mode
, "Power mode enabled or not");
75 module_param(debug
, bool, 0644);
76 MODULE_PARM_DESC(debug
, "Debugging mode enabled or not");
78 #define CPQHPC_MODULE_MINOR 208
80 static inline int is_slot64bit(struct slot
*slot
)
82 return (readb(slot
->p_sm_slot
+ SMBIOS_SLOT_WIDTH
) == 0x06) ? 1 : 0;
85 static inline int is_slot66mhz(struct slot
*slot
)
87 return (readb(slot
->p_sm_slot
+ SMBIOS_SLOT_TYPE
) == 0x0E) ? 1 : 0;
91 * detect_SMBIOS_pointer - find the System Management BIOS Table in mem region.
92 * @begin: begin pointer for region to be scanned.
93 * @end: end pointer for region to be scanned.
95 * Returns pointer to the head of the SMBIOS tables (or %NULL).
97 static void __iomem
* detect_SMBIOS_pointer(void __iomem
*begin
, void __iomem
*end
)
101 u8 temp1
, temp2
, temp3
, temp4
;
104 endp
= (end
- sizeof(u32
) + 1);
106 for (fp
= begin
; fp
<= endp
; fp
+= 16) {
123 dbg("Discovered SMBIOS Entry point at %p\n", fp
);
129 * init_SERR - Initializes the per slot SERR generation.
130 * @ctrl: controller to use
132 * For unexpected switch opens
134 static int init_SERR(struct controller
* ctrl
)
143 tempdword
= ctrl
->first_slot
;
145 number_of_slots
= readb(ctrl
->hpc_reg
+ SLOT_MASK
) & 0x0F;
146 /* Loop through slots */
147 while (number_of_slots
) {
148 physical_slot
= tempdword
;
149 writeb(0, ctrl
->hpc_reg
+ SLOT_SERR
);
157 static int init_cpqhp_routing_table(void)
161 cpqhp_routing_table
= pcibios_get_irq_routing_table();
162 if (cpqhp_routing_table
== NULL
)
165 len
= cpqhp_routing_table_length();
167 kfree(cpqhp_routing_table
);
168 cpqhp_routing_table
= NULL
;
175 /* nice debugging output */
176 static void pci_print_IRQ_route(void)
180 u8 tbus
, tdevice
, tslot
;
182 len
= cpqhp_routing_table_length();
184 dbg("bus dev func slot\n");
185 for (loop
= 0; loop
< len
; ++loop
) {
186 tbus
= cpqhp_routing_table
->slots
[loop
].bus
;
187 tdevice
= cpqhp_routing_table
->slots
[loop
].devfn
;
188 tslot
= cpqhp_routing_table
->slots
[loop
].slot
;
189 dbg("%d %d %d %d\n", tbus
, tdevice
>> 3, tdevice
& 0x7, tslot
);
197 * get_subsequent_smbios_entry: get the next entry from bios table.
198 * @smbios_start: where to start in the SMBIOS table
199 * @smbios_table: location of the SMBIOS table
200 * @curr: %NULL or pointer to previously returned structure
202 * Gets the first entry if previous == NULL;
203 * otherwise, returns the next entry.
204 * Uses global SMBIOS Table pointer.
206 * Returns a pointer to an SMBIOS structure or NULL if none found.
208 static void __iomem
*get_subsequent_smbios_entry(void __iomem
*smbios_start
,
209 void __iomem
*smbios_table
,
213 u8 previous_byte
= 1;
214 void __iomem
*p_temp
;
217 if (!smbios_table
|| !curr
)
220 /* set p_max to the end of the table */
221 p_max
= smbios_start
+ readw(smbios_table
+ ST_LENGTH
);
224 p_temp
+= readb(curr
+ SMBIOS_GENERIC_LENGTH
);
226 while ((p_temp
< p_max
) && !bail
) {
227 /* Look for the double NULL terminator
228 * The first condition is the previous byte
229 * and the second is the curr
231 if (!previous_byte
&& !(readb(p_temp
)))
234 previous_byte
= readb(p_temp
);
246 * get_SMBIOS_entry - return the requested SMBIOS entry or %NULL
247 * @smbios_start: where to start in the SMBIOS table
248 * @smbios_table: location of the SMBIOS table
249 * @type: SMBIOS structure type to be returned
250 * @previous: %NULL or pointer to previously returned structure
252 * Gets the first entry of the specified type if previous == %NULL;
253 * Otherwise, returns the next entry of the given type.
254 * Uses global SMBIOS Table pointer.
255 * Uses get_subsequent_smbios_entry.
257 * Returns a pointer to an SMBIOS structure or %NULL if none found.
259 static void __iomem
*get_SMBIOS_entry(void __iomem
*smbios_start
,
260 void __iomem
*smbios_table
,
262 void __iomem
*previous
)
268 previous
= smbios_start
;
270 previous
= get_subsequent_smbios_entry(smbios_start
,
271 smbios_table
, previous
);
274 if (readb(previous
+ SMBIOS_GENERIC_TYPE
) != type
)
275 previous
= get_subsequent_smbios_entry(smbios_start
,
276 smbios_table
, previous
);
283 static void release_slot(struct hotplug_slot
*hotplug_slot
)
285 struct slot
*slot
= hotplug_slot
->private;
287 dbg("%s - physical_slot = %s\n", __func__
, slot_name(slot
));
289 kfree(slot
->hotplug_slot
->info
);
290 kfree(slot
->hotplug_slot
);
294 static int ctrl_slot_cleanup (struct controller
* ctrl
)
296 struct slot
*old_slot
, *next_slot
;
298 old_slot
= ctrl
->slot
;
302 /* memory will be freed by the release_slot callback */
303 next_slot
= old_slot
->next
;
304 pci_hp_deregister (old_slot
->hotplug_slot
);
305 old_slot
= next_slot
;
308 cpqhp_remove_debugfs_files(ctrl
);
310 /* Free IRQ associated with hot plug device */
311 free_irq(ctrl
->interrupt
, ctrl
);
312 /* Unmap the memory */
313 iounmap(ctrl
->hpc_reg
);
314 /* Finally reclaim PCI mem */
315 release_mem_region(pci_resource_start(ctrl
->pci_dev
, 0),
316 pci_resource_len(ctrl
->pci_dev
, 0));
323 * get_slot_mapping - determine logical slot mapping for PCI device
325 * Won't work for more than one PCI-PCI bridge in a slot.
327 * @bus_num - bus number of PCI device
328 * @dev_num - device number of PCI device
329 * @slot - Pointer to u8 where slot number will be returned
331 * Output: SUCCESS or FAILURE
334 get_slot_mapping(struct pci_bus
*bus
, u8 bus_num
, u8 dev_num
, u8
*slot
)
340 u8 tbus
, tdevice
, tslot
, bridgeSlot
;
342 dbg("%s: %p, %d, %d, %p\n", __func__
, bus
, bus_num
, dev_num
, slot
);
346 len
= cpqhp_routing_table_length();
347 for (loop
= 0; loop
< len
; ++loop
) {
348 tbus
= cpqhp_routing_table
->slots
[loop
].bus
;
349 tdevice
= cpqhp_routing_table
->slots
[loop
].devfn
>> 3;
350 tslot
= cpqhp_routing_table
->slots
[loop
].slot
;
352 if ((tbus
== bus_num
) && (tdevice
== dev_num
)) {
356 /* Did not get a match on the target PCI device. Check
357 * if the current IRQ table entry is a PCI-to-PCI
358 * bridge device. If so, and it's secondary bus
359 * matches the bus number for the target device, I need
360 * to save the bridge's slot number. If I can not find
361 * an entry for the target device, I will have to
362 * assume it's on the other side of the bridge, and
363 * assign it the bridge's slot.
366 pci_bus_read_config_dword(bus
, PCI_DEVFN(tdevice
, 0),
367 PCI_CLASS_REVISION
, &work
);
369 if ((work
>> 8) == PCI_TO_PCI_BRIDGE_CLASS
) {
370 pci_bus_read_config_dword(bus
,
371 PCI_DEVFN(tdevice
, 0),
372 PCI_PRIMARY_BUS
, &work
);
373 // See if bridge's secondary bus matches target bus.
374 if (((work
>> 8) & 0x000000FF) == (long) bus_num
)
381 /* If we got here, we didn't find an entry in the IRQ mapping table for
382 * the target PCI device. If we did determine that the target device
383 * is on the other side of a PCI-to-PCI bridge, return the slot number
386 if (bridgeSlot
!= 0xFF) {
390 /* Couldn't find an entry in the routing table for this PCI device */
396 * cpqhp_set_attention_status - Turns the Amber LED for a slot on or off
397 * @ctrl: struct controller to use
398 * @func: PCI device/function info
399 * @status: LED control flag: 1 = LED on, 0 = LED off
402 cpqhp_set_attention_status(struct controller
*ctrl
, struct pci_func
*func
,
410 hp_slot
= func
->device
- ctrl
->slot_device_offset
;
412 /* Wait for exclusive access to hardware */
413 mutex_lock(&ctrl
->crit_sect
);
416 amber_LED_on (ctrl
, hp_slot
);
417 else if (status
== 0)
418 amber_LED_off (ctrl
, hp_slot
);
420 /* Done with exclusive hardware access */
421 mutex_unlock(&ctrl
->crit_sect
);
427 /* Wait for SOBS to be unset */
428 wait_for_ctrl_irq (ctrl
);
430 /* Done with exclusive hardware access */
431 mutex_unlock(&ctrl
->crit_sect
);
438 * set_attention_status - Turns the Amber LED for a slot on or off
439 * @hotplug_slot: slot to change LED on
440 * @status: LED control flag
442 static int set_attention_status (struct hotplug_slot
*hotplug_slot
, u8 status
)
444 struct pci_func
*slot_func
;
445 struct slot
*slot
= hotplug_slot
->private;
446 struct controller
*ctrl
= slot
->ctrl
;
452 dbg("%s - physical_slot = %s\n", __func__
, slot_name(slot
));
454 if (cpqhp_get_bus_dev(ctrl
, &bus
, &devfn
, slot
->number
) == -1)
458 function
= devfn
& 0x7;
459 dbg("bus, dev, fn = %d, %d, %d\n", bus
, device
, function
);
461 slot_func
= cpqhp_slot_find(bus
, device
, function
);
465 return cpqhp_set_attention_status(ctrl
, slot_func
, status
);
469 static int process_SI(struct hotplug_slot
*hotplug_slot
)
471 struct pci_func
*slot_func
;
472 struct slot
*slot
= hotplug_slot
->private;
473 struct controller
*ctrl
= slot
->ctrl
;
479 dbg("%s - physical_slot = %s\n", __func__
, slot_name(slot
));
481 if (cpqhp_get_bus_dev(ctrl
, &bus
, &devfn
, slot
->number
) == -1)
485 function
= devfn
& 0x7;
486 dbg("bus, dev, fn = %d, %d, %d\n", bus
, device
, function
);
488 slot_func
= cpqhp_slot_find(bus
, device
, function
);
492 slot_func
->bus
= bus
;
493 slot_func
->device
= device
;
494 slot_func
->function
= function
;
495 slot_func
->configured
= 0;
496 dbg("board_added(%p, %p)\n", slot_func
, ctrl
);
497 return cpqhp_process_SI(ctrl
, slot_func
);
501 static int process_SS(struct hotplug_slot
*hotplug_slot
)
503 struct pci_func
*slot_func
;
504 struct slot
*slot
= hotplug_slot
->private;
505 struct controller
*ctrl
= slot
->ctrl
;
511 dbg("%s - physical_slot = %s\n", __func__
, slot_name(slot
));
513 if (cpqhp_get_bus_dev(ctrl
, &bus
, &devfn
, slot
->number
) == -1)
517 function
= devfn
& 0x7;
518 dbg("bus, dev, fn = %d, %d, %d\n", bus
, device
, function
);
520 slot_func
= cpqhp_slot_find(bus
, device
, function
);
524 dbg("In %s, slot_func = %p, ctrl = %p\n", __func__
, slot_func
, ctrl
);
525 return cpqhp_process_SS(ctrl
, slot_func
);
529 static int hardware_test(struct hotplug_slot
*hotplug_slot
, u32 value
)
531 struct slot
*slot
= hotplug_slot
->private;
532 struct controller
*ctrl
= slot
->ctrl
;
534 dbg("%s - physical_slot = %s\n", __func__
, slot_name(slot
));
536 return cpqhp_hardware_test(ctrl
, value
);
540 static int get_power_status(struct hotplug_slot
*hotplug_slot
, u8
*value
)
542 struct slot
*slot
= hotplug_slot
->private;
543 struct controller
*ctrl
= slot
->ctrl
;
545 dbg("%s - physical_slot = %s\n", __func__
, slot_name(slot
));
547 *value
= get_slot_enabled(ctrl
, slot
);
551 static int get_attention_status(struct hotplug_slot
*hotplug_slot
, u8
*value
)
553 struct slot
*slot
= hotplug_slot
->private;
554 struct controller
*ctrl
= slot
->ctrl
;
556 dbg("%s - physical_slot = %s\n", __func__
, slot_name(slot
));
558 *value
= cpq_get_attention_status(ctrl
, slot
);
562 static int get_latch_status(struct hotplug_slot
*hotplug_slot
, u8
*value
)
564 struct slot
*slot
= hotplug_slot
->private;
565 struct controller
*ctrl
= slot
->ctrl
;
567 dbg("%s - physical_slot = %s\n", __func__
, slot_name(slot
));
569 *value
= cpq_get_latch_status(ctrl
, slot
);
574 static int get_adapter_status(struct hotplug_slot
*hotplug_slot
, u8
*value
)
576 struct slot
*slot
= hotplug_slot
->private;
577 struct controller
*ctrl
= slot
->ctrl
;
579 dbg("%s - physical_slot = %s\n", __func__
, slot_name(slot
));
581 *value
= get_presence_status(ctrl
, slot
);
586 static struct hotplug_slot_ops cpqphp_hotplug_slot_ops
= {
587 .set_attention_status
= set_attention_status
,
588 .enable_slot
= process_SI
,
589 .disable_slot
= process_SS
,
590 .hardware_test
= hardware_test
,
591 .get_power_status
= get_power_status
,
592 .get_attention_status
= get_attention_status
,
593 .get_latch_status
= get_latch_status
,
594 .get_adapter_status
= get_adapter_status
,
597 #define SLOT_NAME_SIZE 10
599 static int ctrl_slot_setup(struct controller
*ctrl
,
600 void __iomem
*smbios_start
,
601 void __iomem
*smbios_table
)
604 struct hotplug_slot
*hotplug_slot
;
605 struct hotplug_slot_info
*hotplug_slot_info
;
606 struct pci_bus
*bus
= ctrl
->pci_bus
;
612 char name
[SLOT_NAME_SIZE
];
613 void __iomem
*slot_entry
= NULL
;
616 dbg("%s\n", __func__
);
618 tempdword
= readl(ctrl
->hpc_reg
+ INT_INPUT_CLEAR
);
620 number_of_slots
= readb(ctrl
->hpc_reg
+ SLOT_MASK
) & 0x0F;
621 slot_device
= readb(ctrl
->hpc_reg
+ SLOT_MASK
) >> 4;
622 slot_number
= ctrl
->first_slot
;
624 while (number_of_slots
) {
625 slot
= kzalloc(sizeof(*slot
), GFP_KERNEL
);
631 slot
->hotplug_slot
= kzalloc(sizeof(*(slot
->hotplug_slot
)),
633 if (!slot
->hotplug_slot
) {
637 hotplug_slot
= slot
->hotplug_slot
;
639 hotplug_slot
->info
= kzalloc(sizeof(*(hotplug_slot
->info
)),
641 if (!hotplug_slot
->info
) {
645 hotplug_slot_info
= hotplug_slot
->info
;
648 slot
->bus
= ctrl
->bus
;
649 slot
->device
= slot_device
;
650 slot
->number
= slot_number
;
651 dbg("slot->number = %u\n", slot
->number
);
653 slot_entry
= get_SMBIOS_entry(smbios_start
, smbios_table
, 9,
656 while (slot_entry
&& (readw(slot_entry
+ SMBIOS_SLOT_NUMBER
) !=
658 slot_entry
= get_SMBIOS_entry(smbios_start
,
659 smbios_table
, 9, slot_entry
);
662 slot
->p_sm_slot
= slot_entry
;
664 init_timer(&slot
->task_event
);
665 slot
->task_event
.expires
= jiffies
+ 5 * HZ
;
666 slot
->task_event
.function
= cpqhp_pushbutton_thread
;
668 /*FIXME: these capabilities aren't used but if they are
669 * they need to be correctly implemented
671 slot
->capabilities
|= PCISLOT_REPLACE_SUPPORTED
;
672 slot
->capabilities
|= PCISLOT_INTERLOCK_SUPPORTED
;
674 if (is_slot64bit(slot
))
675 slot
->capabilities
|= PCISLOT_64_BIT_SUPPORTED
;
676 if (is_slot66mhz(slot
))
677 slot
->capabilities
|= PCISLOT_66_MHZ_SUPPORTED
;
678 if (bus
->cur_bus_speed
== PCI_SPEED_66MHz
)
679 slot
->capabilities
|= PCISLOT_66_MHZ_OPERATION
;
682 slot_device
- (readb(ctrl
->hpc_reg
+ SLOT_MASK
) >> 4);
685 slot
->capabilities
|=
686 ((((~tempdword
) >> 23) |
687 ((~tempdword
) >> 15)) >> ctrl_slot
) & 0x02;
688 /* Check the switch state */
689 slot
->capabilities
|=
690 ((~tempdword
& 0xFF) >> ctrl_slot
) & 0x01;
691 /* Check the slot enable */
692 slot
->capabilities
|=
693 ((read_slot_enable(ctrl
) << 2) >> ctrl_slot
) & 0x04;
695 /* register this slot with the hotplug pci core */
696 hotplug_slot
->release
= &release_slot
;
697 hotplug_slot
->private = slot
;
698 snprintf(name
, SLOT_NAME_SIZE
, "%u", slot
->number
);
699 hotplug_slot
->ops
= &cpqphp_hotplug_slot_ops
;
701 hotplug_slot_info
->power_status
= get_slot_enabled(ctrl
, slot
);
702 hotplug_slot_info
->attention_status
=
703 cpq_get_attention_status(ctrl
, slot
);
704 hotplug_slot_info
->latch_status
=
705 cpq_get_latch_status(ctrl
, slot
);
706 hotplug_slot_info
->adapter_status
=
707 get_presence_status(ctrl
, slot
);
709 dbg("registering bus %d, dev %d, number %d, "
710 "ctrl->slot_device_offset %d, slot %d\n",
711 slot
->bus
, slot
->device
,
712 slot
->number
, ctrl
->slot_device_offset
,
714 result
= pci_hp_register(hotplug_slot
,
719 err("pci_hp_register failed with error %d\n", result
);
723 slot
->next
= ctrl
->slot
;
733 kfree(hotplug_slot_info
);
742 static int one_time_init(void)
752 retval
= init_cpqhp_routing_table();
757 pci_print_IRQ_route();
759 dbg("Initialize + Start the notification mechanism \n");
761 retval
= cpqhp_event_start_thread();
765 dbg("Initialize slot lists\n");
766 for (loop
= 0; loop
< 256; loop
++)
767 cpqhp_slot_list
[loop
] = NULL
;
769 /* FIXME: We also need to hook the NMI handler eventually.
770 * this also needs to be worked with Christoph
771 * register_NMI_handler();
773 /* Map rom address */
774 cpqhp_rom_start
= ioremap(ROM_PHY_ADDR
, ROM_PHY_LEN
);
775 if (!cpqhp_rom_start
) {
776 err ("Could not ioremap memory region for ROM\n");
781 /* Now, map the int15 entry point if we are on compaq specific
784 compaq_nvram_init(cpqhp_rom_start
);
786 /* Map smbios table entry point structure */
787 smbios_table
= detect_SMBIOS_pointer(cpqhp_rom_start
,
788 cpqhp_rom_start
+ ROM_PHY_LEN
);
790 err ("Could not find the SMBIOS pointer in memory\n");
792 goto error_rom_start
;
795 smbios_start
= ioremap(readl(smbios_table
+ ST_ADDRESS
),
796 readw(smbios_table
+ ST_LENGTH
));
798 err ("Could not ioremap memory region taken from SMBIOS values\n");
800 goto error_smbios_start
;
808 iounmap(smbios_start
);
810 iounmap(cpqhp_rom_start
);
815 static int cpqhpc_probe(struct pci_dev
*pdev
, const struct pci_device_id
*ent
)
824 u16 subsystem_deviceid
;
826 struct controller
*ctrl
;
827 struct pci_func
*func
;
831 err
= pci_enable_device(pdev
);
833 printk(KERN_ERR MY_NAME
": cannot enable PCI device %s (%d)\n",
834 pci_name(pdev
), err
);
838 bus
= pdev
->subordinate
;
840 dev_notice(&pdev
->dev
, "the device is not a bridge, "
843 goto err_disable_device
;
846 /* Need to read VID early b/c it's used to differentiate CPQ and INTC
849 vendor_id
= pdev
->vendor
;
850 if ((vendor_id
!= PCI_VENDOR_ID_COMPAQ
) &&
851 (vendor_id
!= PCI_VENDOR_ID_INTEL
)) {
852 err(msg_HPC_non_compaq_or_intel
);
854 goto err_disable_device
;
856 dbg("Vendor ID: %x\n", vendor_id
);
858 dbg("revision: %d\n", pdev
->revision
);
859 if ((vendor_id
== PCI_VENDOR_ID_COMPAQ
) && (!pdev
->revision
)) {
860 err(msg_HPC_rev_error
);
862 goto err_disable_device
;
865 /* Check for the proper subsystem IDs
866 * Intel uses a different SSID programming model than Compaq.
867 * For Intel, each SSID bit identifies a PHP capability.
868 * Also Intel HPCs may have RID=0.
870 if ((pdev
->revision
<= 2) && (vendor_id
!= PCI_VENDOR_ID_INTEL
)) {
871 err(msg_HPC_not_supported
);
875 /* TODO: This code can be made to support non-Compaq or Intel
878 subsystem_vid
= pdev
->subsystem_vendor
;
879 dbg("Subsystem Vendor ID: %x\n", subsystem_vid
);
880 if ((subsystem_vid
!= PCI_VENDOR_ID_COMPAQ
) && (subsystem_vid
!= PCI_VENDOR_ID_INTEL
)) {
881 err(msg_HPC_non_compaq_or_intel
);
883 goto err_disable_device
;
886 ctrl
= kzalloc(sizeof(struct controller
), GFP_KERNEL
);
888 err("%s : out of memory\n", __func__
);
890 goto err_disable_device
;
893 subsystem_deviceid
= pdev
->subsystem_device
;
895 info("Hot Plug Subsystem Device ID: %x\n", subsystem_deviceid
);
897 /* Set Vendor ID, so it can be accessed later from other
900 ctrl
->vendor_id
= vendor_id
;
902 switch (subsystem_vid
) {
903 case PCI_VENDOR_ID_COMPAQ
:
904 if (pdev
->revision
>= 0x13) { /* CIOBX */
906 ctrl
->slot_switch_type
= 1;
907 ctrl
->push_button
= 1;
908 ctrl
->pci_config_space
= 1;
909 ctrl
->defeature_PHP
= 1;
910 ctrl
->pcix_support
= 1;
911 ctrl
->pcix_speed_capability
= 1;
912 pci_read_config_byte(pdev
, 0x41, &bus_cap
);
913 if (bus_cap
& 0x80) {
914 dbg("bus max supports 133MHz PCI-X\n");
915 bus
->max_bus_speed
= PCI_SPEED_133MHz_PCIX
;
918 if (bus_cap
& 0x40) {
919 dbg("bus max supports 100MHz PCI-X\n");
920 bus
->max_bus_speed
= PCI_SPEED_100MHz_PCIX
;
924 dbg("bus max supports 66MHz PCI-X\n");
925 bus
->max_bus_speed
= PCI_SPEED_66MHz_PCIX
;
929 dbg("bus max supports 66MHz PCI\n");
930 bus
->max_bus_speed
= PCI_SPEED_66MHz
;
937 switch (subsystem_deviceid
) {
939 /* Original 6500/7000 implementation */
940 ctrl
->slot_switch_type
= 1;
941 bus
->max_bus_speed
= PCI_SPEED_33MHz
;
942 ctrl
->push_button
= 0;
943 ctrl
->pci_config_space
= 1;
944 ctrl
->defeature_PHP
= 1;
945 ctrl
->pcix_support
= 0;
946 ctrl
->pcix_speed_capability
= 0;
948 case PCI_SUB_HPC_ID2
:
949 /* First Pushbutton implementation */
951 ctrl
->slot_switch_type
= 1;
952 bus
->max_bus_speed
= PCI_SPEED_33MHz
;
953 ctrl
->push_button
= 1;
954 ctrl
->pci_config_space
= 1;
955 ctrl
->defeature_PHP
= 1;
956 ctrl
->pcix_support
= 0;
957 ctrl
->pcix_speed_capability
= 0;
959 case PCI_SUB_HPC_ID_INTC
:
960 /* Third party (6500/7000) */
961 ctrl
->slot_switch_type
= 1;
962 bus
->max_bus_speed
= PCI_SPEED_33MHz
;
963 ctrl
->push_button
= 0;
964 ctrl
->pci_config_space
= 1;
965 ctrl
->defeature_PHP
= 1;
966 ctrl
->pcix_support
= 0;
967 ctrl
->pcix_speed_capability
= 0;
969 case PCI_SUB_HPC_ID3
:
970 /* First 66 Mhz implementation */
972 ctrl
->slot_switch_type
= 1;
973 bus
->max_bus_speed
= PCI_SPEED_66MHz
;
974 ctrl
->push_button
= 1;
975 ctrl
->pci_config_space
= 1;
976 ctrl
->defeature_PHP
= 1;
977 ctrl
->pcix_support
= 0;
978 ctrl
->pcix_speed_capability
= 0;
980 case PCI_SUB_HPC_ID4
:
981 /* First PCI-X implementation, 100MHz */
983 ctrl
->slot_switch_type
= 1;
984 bus
->max_bus_speed
= PCI_SPEED_100MHz_PCIX
;
985 ctrl
->push_button
= 1;
986 ctrl
->pci_config_space
= 1;
987 ctrl
->defeature_PHP
= 1;
988 ctrl
->pcix_support
= 1;
989 ctrl
->pcix_speed_capability
= 0;
992 err(msg_HPC_not_supported
);
998 case PCI_VENDOR_ID_INTEL
:
999 /* Check for speed capability (0=33, 1=66) */
1000 if (subsystem_deviceid
& 0x0001)
1001 bus
->max_bus_speed
= PCI_SPEED_66MHz
;
1003 bus
->max_bus_speed
= PCI_SPEED_33MHz
;
1005 /* Check for push button */
1006 if (subsystem_deviceid
& 0x0002)
1007 ctrl
->push_button
= 0;
1009 ctrl
->push_button
= 1;
1011 /* Check for slot switch type (0=mechanical, 1=not mechanical) */
1012 if (subsystem_deviceid
& 0x0004)
1013 ctrl
->slot_switch_type
= 0;
1015 ctrl
->slot_switch_type
= 1;
1017 /* PHP Status (0=De-feature PHP, 1=Normal operation) */
1018 if (subsystem_deviceid
& 0x0008)
1019 ctrl
->defeature_PHP
= 1; /* PHP supported */
1021 ctrl
->defeature_PHP
= 0; /* PHP not supported */
1023 /* Alternate Base Address Register Interface
1024 * (0=not supported, 1=supported)
1026 if (subsystem_deviceid
& 0x0010)
1027 ctrl
->alternate_base_address
= 1;
1029 ctrl
->alternate_base_address
= 0;
1031 /* PCI Config Space Index (0=not supported, 1=supported) */
1032 if (subsystem_deviceid
& 0x0020)
1033 ctrl
->pci_config_space
= 1;
1035 ctrl
->pci_config_space
= 0;
1038 if (subsystem_deviceid
& 0x0080) {
1039 ctrl
->pcix_support
= 1;
1040 if (subsystem_deviceid
& 0x0040)
1041 /* 133MHz PCI-X if bit 7 is 1 */
1042 ctrl
->pcix_speed_capability
= 1;
1044 /* 100MHz PCI-X if bit 7 is 1 and bit 0 is 0, */
1045 /* 66MHz PCI-X if bit 7 is 1 and bit 0 is 1 */
1046 ctrl
->pcix_speed_capability
= 0;
1048 /* Conventional PCI */
1049 ctrl
->pcix_support
= 0;
1050 ctrl
->pcix_speed_capability
= 0;
1055 err(msg_HPC_not_supported
);
1060 /* Tell the user that we found one. */
1061 info("Initializing the PCI hot plug controller residing on PCI bus %d\n",
1064 dbg("Hotplug controller capabilities:\n");
1065 dbg(" speed_capability %d\n", bus
->max_bus_speed
);
1066 dbg(" slot_switch_type %s\n", ctrl
->slot_switch_type
?
1067 "switch present" : "no switch");
1068 dbg(" defeature_PHP %s\n", ctrl
->defeature_PHP
?
1069 "PHP supported" : "PHP not supported");
1070 dbg(" alternate_base_address %s\n", ctrl
->alternate_base_address
?
1071 "supported" : "not supported");
1072 dbg(" pci_config_space %s\n", ctrl
->pci_config_space
?
1073 "supported" : "not supported");
1074 dbg(" pcix_speed_capability %s\n", ctrl
->pcix_speed_capability
?
1075 "supported" : "not supported");
1076 dbg(" pcix_support %s\n", ctrl
->pcix_support
?
1077 "supported" : "not supported");
1079 ctrl
->pci_dev
= pdev
;
1080 pci_set_drvdata(pdev
, ctrl
);
1082 /* make our own copy of the pci bus structure,
1083 * as we like tweaking it a lot */
1084 ctrl
->pci_bus
= kmemdup(pdev
->bus
, sizeof(*ctrl
->pci_bus
), GFP_KERNEL
);
1085 if (!ctrl
->pci_bus
) {
1086 err("out of memory\n");
1091 ctrl
->bus
= pdev
->bus
->number
;
1092 ctrl
->rev
= pdev
->revision
;
1093 dbg("bus device function rev: %d %d %d %d\n", ctrl
->bus
,
1094 PCI_SLOT(pdev
->devfn
), PCI_FUNC(pdev
->devfn
), ctrl
->rev
);
1096 mutex_init(&ctrl
->crit_sect
);
1097 init_waitqueue_head(&ctrl
->queue
);
1099 /* initialize our threads if they haven't already been started up */
1100 rc
= one_time_init();
1105 dbg("pdev = %p\n", pdev
);
1106 dbg("pci resource start %llx\n", (unsigned long long)pci_resource_start(pdev
, 0));
1107 dbg("pci resource len %llx\n", (unsigned long long)pci_resource_len(pdev
, 0));
1109 if (!request_mem_region(pci_resource_start(pdev
, 0),
1110 pci_resource_len(pdev
, 0), MY_NAME
)) {
1111 err("cannot reserve MMIO region\n");
1116 ctrl
->hpc_reg
= ioremap(pci_resource_start(pdev
, 0),
1117 pci_resource_len(pdev
, 0));
1118 if (!ctrl
->hpc_reg
) {
1119 err("cannot remap MMIO region %llx @ %llx\n",
1120 (unsigned long long)pci_resource_len(pdev
, 0),
1121 (unsigned long long)pci_resource_start(pdev
, 0));
1123 goto err_free_mem_region
;
1126 /* Check for 66Mhz operation */
1127 bus
->cur_bus_speed
= get_controller_speed(ctrl
);
1130 /********************************************************
1132 * Save configuration headers for this and
1133 * subordinate PCI buses
1135 ********************************************************/
1137 /* find the physical slot number of the first hot plug slot */
1139 /* Get slot won't work for devices behind bridges, but
1140 * in this case it will always be called for the "base"
1141 * bus/dev/func of a slot.
1142 * CS: this is leveraging the PCIIRQ routing code from the kernel
1143 * (pci-pc.c: get_irq_routing_table) */
1144 rc
= get_slot_mapping(ctrl
->pci_bus
, pdev
->bus
->number
,
1145 (readb(ctrl
->hpc_reg
+ SLOT_MASK
) >> 4),
1146 &(ctrl
->first_slot
));
1147 dbg("get_slot_mapping: first_slot = %d, returned = %d\n",
1148 ctrl
->first_slot
, rc
);
1150 err(msg_initialization_err
, rc
);
1154 /* Store PCI Config Space for all devices on this bus */
1155 rc
= cpqhp_save_config(ctrl
, ctrl
->bus
, readb(ctrl
->hpc_reg
+ SLOT_MASK
));
1157 err("%s: unable to save PCI configuration data, error %d\n",
1163 * Get IO, memory, and IRQ resources for new devices
1165 /* The next line is required for cpqhp_find_available_resources */
1166 ctrl
->interrupt
= pdev
->irq
;
1167 if (ctrl
->interrupt
< 0x10) {
1168 cpqhp_legacy_mode
= 1;
1169 dbg("System seems to be configured for Full Table Mapped MPS mode\n");
1172 ctrl
->cfgspc_irq
= 0;
1173 pci_read_config_byte(pdev
, PCI_INTERRUPT_LINE
, &ctrl
->cfgspc_irq
);
1175 rc
= cpqhp_find_available_resources(ctrl
, cpqhp_rom_start
);
1176 ctrl
->add_support
= !rc
;
1178 dbg("cpqhp_find_available_resources = 0x%x\n", rc
);
1179 err("unable to locate PCI configuration resources for hot plug add.\n");
1184 * Finish setting up the hot plug ctrl device
1186 ctrl
->slot_device_offset
= readb(ctrl
->hpc_reg
+ SLOT_MASK
) >> 4;
1187 dbg("NumSlots %d \n", ctrl
->slot_device_offset
);
1189 ctrl
->next_event
= 0;
1191 /* Setup the slot information structures */
1192 rc
= ctrl_slot_setup(ctrl
, smbios_start
, smbios_table
);
1194 err(msg_initialization_err
, 6);
1195 err("%s: unable to save PCI configuration data, error %d\n",
1200 /* Mask all general input interrupts */
1201 writel(0xFFFFFFFFL
, ctrl
->hpc_reg
+ INT_MASK
);
1203 /* set up the interrupt */
1204 dbg("HPC interrupt = %d \n", ctrl
->interrupt
);
1205 if (request_irq(ctrl
->interrupt
, cpqhp_ctrl_intr
,
1206 IRQF_SHARED
, MY_NAME
, ctrl
)) {
1207 err("Can't get irq %d for the hotplug pci controller\n",
1213 /* Enable Shift Out interrupt and clear it, also enable SERR on power
1216 temp_word
= readw(ctrl
->hpc_reg
+ MISC
);
1217 temp_word
|= 0x4006;
1218 writew(temp_word
, ctrl
->hpc_reg
+ MISC
);
1220 /* Changed 05/05/97 to clear all interrupts at start */
1221 writel(0xFFFFFFFFL
, ctrl
->hpc_reg
+ INT_INPUT_CLEAR
);
1223 ctrl
->ctrl_int_comp
= readl(ctrl
->hpc_reg
+ INT_INPUT_CLEAR
);
1225 writel(0x0L
, ctrl
->hpc_reg
+ INT_MASK
);
1227 if (!cpqhp_ctrl_list
) {
1228 cpqhp_ctrl_list
= ctrl
;
1231 ctrl
->next
= cpqhp_ctrl_list
;
1232 cpqhp_ctrl_list
= ctrl
;
1235 /* turn off empty slots here unless command line option "ON" set
1236 * Wait for exclusive access to hardware
1238 mutex_lock(&ctrl
->crit_sect
);
1240 num_of_slots
= readb(ctrl
->hpc_reg
+ SLOT_MASK
) & 0x0F;
1242 /* find first device number for the ctrl */
1243 device
= readb(ctrl
->hpc_reg
+ SLOT_MASK
) >> 4;
1245 while (num_of_slots
) {
1246 dbg("num_of_slots: %d\n", num_of_slots
);
1247 func
= cpqhp_slot_find(ctrl
->bus
, device
, 0);
1251 hp_slot
= func
->device
- ctrl
->slot_device_offset
;
1252 dbg("hp_slot: %d\n", hp_slot
);
1254 /* We have to save the presence info for these slots */
1255 temp_word
= ctrl
->ctrl_int_comp
>> 16;
1256 func
->presence_save
= (temp_word
>> hp_slot
) & 0x01;
1257 func
->presence_save
|= (temp_word
>> (hp_slot
+ 7)) & 0x02;
1259 if (ctrl
->ctrl_int_comp
& (0x1L
<< hp_slot
))
1260 func
->switch_save
= 0;
1262 func
->switch_save
= 0x10;
1265 if (!func
->is_a_board
) {
1266 green_LED_off(ctrl
, hp_slot
);
1267 slot_disable(ctrl
, hp_slot
);
1276 /* Wait for SOBS to be unset */
1277 wait_for_ctrl_irq(ctrl
);
1280 rc
= init_SERR(ctrl
);
1282 err("init_SERR failed\n");
1283 mutex_unlock(&ctrl
->crit_sect
);
1287 /* Done with exclusive hardware access */
1288 mutex_unlock(&ctrl
->crit_sect
);
1290 cpqhp_create_debugfs_files(ctrl
);
1295 free_irq(ctrl
->interrupt
, ctrl
);
1297 iounmap(ctrl
->hpc_reg
);
1298 err_free_mem_region
:
1299 release_mem_region(pci_resource_start(pdev
, 0), pci_resource_len(pdev
, 0));
1301 kfree(ctrl
->pci_bus
);
1305 pci_disable_device(pdev
);
1309 static void __exit
unload_cpqphpd(void)
1311 struct pci_func
*next
;
1312 struct pci_func
*TempSlot
;
1315 struct controller
*ctrl
;
1316 struct controller
*tctrl
;
1317 struct pci_resource
*res
;
1318 struct pci_resource
*tres
;
1320 rc
= compaq_nvram_store(cpqhp_rom_start
);
1322 ctrl
= cpqhp_ctrl_list
;
1325 if (ctrl
->hpc_reg
) {
1327 rc
= read_slot_enable (ctrl
);
1329 writeb(0, ctrl
->hpc_reg
+ SLOT_SERR
);
1330 writel(0xFFFFFFC0L
| ~rc
, ctrl
->hpc_reg
+ INT_MASK
);
1332 misc
= readw(ctrl
->hpc_reg
+ MISC
);
1334 writew(misc
, ctrl
->hpc_reg
+ MISC
);
1337 ctrl_slot_cleanup(ctrl
);
1339 res
= ctrl
->io_head
;
1346 res
= ctrl
->mem_head
;
1353 res
= ctrl
->p_mem_head
;
1360 res
= ctrl
->bus_head
;
1367 kfree (ctrl
->pci_bus
);
1374 for (loop
= 0; loop
< 256; loop
++) {
1375 next
= cpqhp_slot_list
[loop
];
1376 while (next
!= NULL
) {
1377 res
= next
->io_head
;
1384 res
= next
->mem_head
;
1391 res
= next
->p_mem_head
;
1398 res
= next
->bus_head
;
1411 /* Stop the notification mechanism */
1413 cpqhp_event_stop_thread();
1415 /* unmap the rom address */
1416 if (cpqhp_rom_start
)
1417 iounmap(cpqhp_rom_start
);
1419 iounmap(smbios_start
);
1422 static struct pci_device_id hpcd_pci_tbl
[] = {
1424 /* handle any PCI Hotplug controller */
1425 .class = ((PCI_CLASS_SYSTEM_PCI_HOTPLUG
<< 8) | 0x00),
1428 /* no matter who makes it */
1429 .vendor
= PCI_ANY_ID
,
1430 .device
= PCI_ANY_ID
,
1431 .subvendor
= PCI_ANY_ID
,
1432 .subdevice
= PCI_ANY_ID
,
1434 }, { /* end: all zeroes */ }
1437 MODULE_DEVICE_TABLE(pci
, hpcd_pci_tbl
);
1439 static struct pci_driver cpqhpc_driver
= {
1440 .name
= "compaq_pci_hotplug",
1441 .id_table
= hpcd_pci_tbl
,
1442 .probe
= cpqhpc_probe
,
1443 /* remove: cpqhpc_remove_one, */
1446 static int __init
cpqhpc_init(void)
1450 cpqhp_debug
= debug
;
1452 info (DRIVER_DESC
" version: " DRIVER_VERSION
"\n");
1453 cpqhp_initialize_debugfs();
1454 result
= pci_register_driver(&cpqhpc_driver
);
1455 dbg("pci_register_driver = %d\n", result
);
1459 static void __exit
cpqhpc_cleanup(void)
1461 dbg("unload_cpqphpd()\n");
1464 dbg("pci_unregister_driver\n");
1465 pci_unregister_driver(&cpqhpc_driver
);
1466 cpqhp_shutdown_debugfs();
1469 module_init(cpqhpc_init
);
1470 module_exit(cpqhpc_cleanup
);