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>
32 #include <linux/config.h>
33 #include <linux/module.h>
34 #include <linux/moduleparam.h>
35 #include <linux/kernel.h>
36 #include <linux/types.h>
37 #include <linux/proc_fs.h>
38 #include <linux/slab.h>
39 #include <linux/workqueue.h>
40 #include <linux/pci.h>
41 #include <linux/init.h>
42 #include <linux/interrupt.h>
44 #include <asm/uaccess.h>
47 #include "cpqphp_nvram.h"
48 #include "../../../arch/i386/pci/pci.h" /* horrible hack showing how processor dependent we are... */
51 /* Global variables */
53 int cpqhp_legacy_mode
;
54 struct controller
*cpqhp_ctrl_list
; /* = NULL */
55 struct pci_func
*cpqhp_slot_list
[256];
58 static void *smbios_table
;
59 static void *smbios_start
;
60 static void *cpqhp_rom_start
;
61 static int power_mode
;
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 int one_time_init (void);
81 static int set_attention_status (struct hotplug_slot
*slot
, u8 value
);
82 static int process_SI (struct hotplug_slot
*slot
);
83 static int process_SS (struct hotplug_slot
*slot
);
84 static int hardware_test (struct hotplug_slot
*slot
, u32 value
);
85 static int get_power_status (struct hotplug_slot
*slot
, u8
*value
);
86 static int get_attention_status (struct hotplug_slot
*slot
, u8
*value
);
87 static int get_latch_status (struct hotplug_slot
*slot
, u8
*value
);
88 static int get_adapter_status (struct hotplug_slot
*slot
, u8
*value
);
89 static int get_max_bus_speed (struct hotplug_slot
*slot
, enum pci_bus_speed
*value
);
90 static int get_cur_bus_speed (struct hotplug_slot
*slot
, enum pci_bus_speed
*value
);
92 static struct hotplug_slot_ops cpqphp_hotplug_slot_ops
= {
94 .set_attention_status
= set_attention_status
,
95 .enable_slot
= process_SI
,
96 .disable_slot
= process_SS
,
97 .hardware_test
= hardware_test
,
98 .get_power_status
= get_power_status
,
99 .get_attention_status
= get_attention_status
,
100 .get_latch_status
= get_latch_status
,
101 .get_adapter_status
= get_adapter_status
,
102 .get_max_bus_speed
= get_max_bus_speed
,
103 .get_cur_bus_speed
= get_cur_bus_speed
,
107 static inline int is_slot64bit(struct slot
*slot
)
109 return (readb(slot
->p_sm_slot
+ SMBIOS_SLOT_WIDTH
) == 0x06) ? 1 : 0;
112 static inline int is_slot66mhz(struct slot
*slot
)
114 return (readb(slot
->p_sm_slot
+ SMBIOS_SLOT_TYPE
) == 0x0E) ? 1 : 0;
118 * detect_SMBIOS_pointer - find the System Management BIOS Table in mem region.
120 * @begin: begin pointer for region to be scanned.
121 * @end: end pointer for region to be scanned.
123 * Returns pointer to the head of the SMBIOS tables (or NULL)
126 static void * detect_SMBIOS_pointer(void *begin
, void *end
)
130 u8 temp1
, temp2
, temp3
, temp4
;
133 endp
= (end
- sizeof(u32
) + 1);
135 for (fp
= begin
; fp
<= endp
; fp
+= 16) {
152 dbg("Discovered SMBIOS Entry point at %p\n", fp
);
158 * init_SERR - Initializes the per slot SERR generation.
160 * For unexpected switch opens
163 static int init_SERR(struct controller
* ctrl
)
172 tempdword
= ctrl
->first_slot
;
174 number_of_slots
= readb(ctrl
->hpc_reg
+ SLOT_MASK
) & 0x0F;
175 // Loop through slots
176 while (number_of_slots
) {
177 physical_slot
= tempdword
;
178 writeb(0, ctrl
->hpc_reg
+ SLOT_SERR
);
187 /* nice debugging output */
188 static int pci_print_IRQ_route (void)
190 struct irq_routing_table
*routing_table
;
194 u8 tbus
, tdevice
, tslot
;
196 routing_table
= pcibios_get_irq_routing_table();
197 if (routing_table
== NULL
) {
198 err("No BIOS Routing Table??? Not good\n");
202 len
= (routing_table
->size
- sizeof(struct irq_routing_table
)) /
203 sizeof(struct irq_info
);
204 // Make sure I got at least one entry
206 kfree(routing_table
);
210 dbg("bus dev func slot\n");
212 for (loop
= 0; loop
< len
; ++loop
) {
213 tbus
= routing_table
->slots
[loop
].bus
;
214 tdevice
= routing_table
->slots
[loop
].devfn
;
215 tslot
= routing_table
->slots
[loop
].slot
;
216 dbg("%d %d %d %d\n", tbus
, tdevice
>> 3, tdevice
& 0x7, tslot
);
219 kfree(routing_table
);
225 * get_subsequent_smbios_entry: get the next entry from bios table.
227 * Gets the first entry if previous == NULL
228 * Otherwise, returns the next entry
229 * Uses global SMBIOS Table pointer
231 * @curr: %NULL or pointer to previously returned structure
233 * returns a pointer to an SMBIOS structure or NULL if none found
235 static void *get_subsequent_smbios_entry(void *smbios_start
,
236 void *smbios_table
, void *curr
)
239 u8 previous_byte
= 1;
243 if (!smbios_table
|| !curr
)
246 // set p_max to the end of the table
247 p_max
= smbios_start
+ readw(smbios_table
+ ST_LENGTH
);
250 p_temp
+= readb(curr
+ SMBIOS_GENERIC_LENGTH
);
252 while ((p_temp
< p_max
) && !bail
) {
253 /* Look for the double NULL terminator
254 * The first condition is the previous byte
255 * and the second is the curr */
256 if (!previous_byte
&& !(readb(p_temp
))) {
260 previous_byte
= readb(p_temp
);
264 if (p_temp
< p_max
) {
275 * @type:SMBIOS structure type to be returned
276 * @previous: %NULL or pointer to previously returned structure
278 * Gets the first entry of the specified type if previous == NULL
279 * Otherwise, returns the next entry of the given type.
280 * Uses global SMBIOS Table pointer
281 * Uses get_subsequent_smbios_entry
283 * returns a pointer to an SMBIOS structure or %NULL if none found
285 static void *get_SMBIOS_entry(void *smbios_start
, void *smbios_table
, u8 type
,
292 previous
= smbios_start
;
294 previous
= get_subsequent_smbios_entry(smbios_start
,
295 smbios_table
, previous
);
299 if (readb(previous
+ SMBIOS_GENERIC_TYPE
) != type
) {
300 previous
= get_subsequent_smbios_entry(smbios_start
,
301 smbios_table
, previous
);
310 static void release_slot(struct hotplug_slot
*hotplug_slot
)
312 struct slot
*slot
= hotplug_slot
->private;
314 dbg("%s - physical_slot = %s\n", __FUNCTION__
, hotplug_slot
->name
);
316 kfree(slot
->hotplug_slot
->info
);
317 kfree(slot
->hotplug_slot
->name
);
318 kfree(slot
->hotplug_slot
);
322 static int ctrl_slot_setup(struct controller
* ctrl
, void *smbios_start
,
325 struct slot
*new_slot
;
331 void *slot_entry
= NULL
;
332 int result
= -ENOMEM
;
334 dbg("%s\n", __FUNCTION__
);
336 tempdword
= readl(ctrl
->hpc_reg
+ INT_INPUT_CLEAR
);
338 number_of_slots
= readb(ctrl
->hpc_reg
+ SLOT_MASK
) & 0x0F;
339 slot_device
= readb(ctrl
->hpc_reg
+ SLOT_MASK
) >> 4;
340 slot_number
= ctrl
->first_slot
;
342 while (number_of_slots
) {
343 new_slot
= kmalloc(sizeof(*new_slot
), GFP_KERNEL
);
347 memset(new_slot
, 0, sizeof(struct slot
));
348 new_slot
->hotplug_slot
= kmalloc(sizeof(*(new_slot
->hotplug_slot
)),
350 if (!new_slot
->hotplug_slot
)
352 memset(new_slot
->hotplug_slot
, 0, sizeof(struct hotplug_slot
));
354 new_slot
->hotplug_slot
->info
=
355 kmalloc(sizeof(*(new_slot
->hotplug_slot
->info
)),
357 if (!new_slot
->hotplug_slot
->info
)
359 memset(new_slot
->hotplug_slot
->info
, 0,
360 sizeof(struct hotplug_slot_info
));
361 new_slot
->hotplug_slot
->name
= kmalloc(SLOT_NAME_SIZE
, GFP_KERNEL
);
362 if (!new_slot
->hotplug_slot
->name
)
365 new_slot
->ctrl
= ctrl
;
366 new_slot
->bus
= ctrl
->bus
;
367 new_slot
->device
= slot_device
;
368 new_slot
->number
= slot_number
;
369 dbg("slot->number = %d\n",new_slot
->number
);
371 slot_entry
= get_SMBIOS_entry(smbios_start
, smbios_table
, 9,
374 while (slot_entry
&& (readw(slot_entry
+ SMBIOS_SLOT_NUMBER
) != new_slot
->number
)) {
375 slot_entry
= get_SMBIOS_entry(smbios_start
,
376 smbios_table
, 9, slot_entry
);
379 new_slot
->p_sm_slot
= slot_entry
;
381 init_timer(&new_slot
->task_event
);
382 new_slot
->task_event
.expires
= jiffies
+ 5 * HZ
;
383 new_slot
->task_event
.function
= cpqhp_pushbutton_thread
;
385 //FIXME: these capabilities aren't used but if they are
386 // they need to be correctly implemented
387 new_slot
->capabilities
|= PCISLOT_REPLACE_SUPPORTED
;
388 new_slot
->capabilities
|= PCISLOT_INTERLOCK_SUPPORTED
;
390 if (is_slot64bit(new_slot
))
391 new_slot
->capabilities
|= PCISLOT_64_BIT_SUPPORTED
;
392 if (is_slot66mhz(new_slot
))
393 new_slot
->capabilities
|= PCISLOT_66_MHZ_SUPPORTED
;
394 if (ctrl
->speed
== PCI_SPEED_66MHz
)
395 new_slot
->capabilities
|= PCISLOT_66_MHZ_OPERATION
;
397 ctrl_slot
= slot_device
- (readb(ctrl
->hpc_reg
+ SLOT_MASK
) >> 4);
400 new_slot
->capabilities
|= ((((~tempdword
) >> 23) | ((~tempdword
) >> 15)) >> ctrl_slot
) & 0x02;
401 // Check the switch state
402 new_slot
->capabilities
|= ((~tempdword
& 0xFF) >> ctrl_slot
) & 0x01;
403 // Check the slot enable
404 new_slot
->capabilities
|= ((read_slot_enable(ctrl
) << 2) >> ctrl_slot
) & 0x04;
406 /* register this slot with the hotplug pci core */
407 new_slot
->hotplug_slot
->release
= &release_slot
;
408 new_slot
->hotplug_slot
->private = new_slot
;
409 make_slot_name(new_slot
->hotplug_slot
->name
, SLOT_NAME_SIZE
, new_slot
);
410 new_slot
->hotplug_slot
->ops
= &cpqphp_hotplug_slot_ops
;
412 new_slot
->hotplug_slot
->info
->power_status
= get_slot_enabled(ctrl
, new_slot
);
413 new_slot
->hotplug_slot
->info
->attention_status
= cpq_get_attention_status(ctrl
, new_slot
);
414 new_slot
->hotplug_slot
->info
->latch_status
= cpq_get_latch_status(ctrl
, new_slot
);
415 new_slot
->hotplug_slot
->info
->adapter_status
= get_presence_status(ctrl
, new_slot
);
417 dbg ("registering bus %d, dev %d, number %d, "
418 "ctrl->slot_device_offset %d, slot %d\n",
419 new_slot
->bus
, new_slot
->device
,
420 new_slot
->number
, ctrl
->slot_device_offset
,
422 result
= pci_hp_register (new_slot
->hotplug_slot
);
424 err ("pci_hp_register failed with error %d\n", result
);
428 new_slot
->next
= ctrl
->slot
;
429 ctrl
->slot
= new_slot
;
439 kfree(new_slot
->hotplug_slot
->name
);
441 kfree(new_slot
->hotplug_slot
->info
);
443 kfree(new_slot
->hotplug_slot
);
450 static int ctrl_slot_cleanup (struct controller
* ctrl
)
452 struct slot
*old_slot
, *next_slot
;
454 old_slot
= ctrl
->slot
;
458 /* memory will be freed by the release_slot callback */
459 next_slot
= old_slot
->next
;
460 pci_hp_deregister (old_slot
->hotplug_slot
);
461 old_slot
= next_slot
;
464 //Free IRQ associated with hot plug device
465 free_irq(ctrl
->interrupt
, ctrl
);
467 iounmap(ctrl
->hpc_reg
);
468 //Finally reclaim PCI mem
469 release_mem_region(pci_resource_start(ctrl
->pci_dev
, 0),
470 pci_resource_len(ctrl
->pci_dev
, 0));
476 //============================================================================
477 // function: get_slot_mapping
479 // Description: Attempts to determine a logical slot mapping for a PCI
480 // device. Won't work for more than one PCI-PCI bridge
483 // Input: u8 bus_num - bus number of PCI device
484 // u8 dev_num - device number of PCI device
485 // u8 *slot - Pointer to u8 where slot number will
488 // Output: SUCCESS or FAILURE
489 //=============================================================================
491 get_slot_mapping(struct pci_bus
*bus
, u8 bus_num
, u8 dev_num
, u8
*slot
)
493 struct irq_routing_table
*PCIIRQRoutingInfoLength
;
498 u8 tbus
, tdevice
, tslot
, bridgeSlot
;
500 dbg("%s: %p, %d, %d, %p\n", __FUNCTION__
, bus
, bus_num
, dev_num
, slot
);
504 PCIIRQRoutingInfoLength
= pcibios_get_irq_routing_table();
505 if (!PCIIRQRoutingInfoLength
)
508 len
= (PCIIRQRoutingInfoLength
->size
-
509 sizeof(struct irq_routing_table
)) / sizeof(struct irq_info
);
510 // Make sure I got at least one entry
512 kfree(PCIIRQRoutingInfoLength
);
516 for (loop
= 0; loop
< len
; ++loop
) {
517 tbus
= PCIIRQRoutingInfoLength
->slots
[loop
].bus
;
518 tdevice
= PCIIRQRoutingInfoLength
->slots
[loop
].devfn
>> 3;
519 tslot
= PCIIRQRoutingInfoLength
->slots
[loop
].slot
;
521 if ((tbus
== bus_num
) && (tdevice
== dev_num
)) {
523 kfree(PCIIRQRoutingInfoLength
);
526 /* Did not get a match on the target PCI device. Check
527 * if the current IRQ table entry is a PCI-to-PCI bridge
528 * device. If so, and it's secondary bus matches the
529 * bus number for the target device, I need to save the
530 * bridge's slot number. If I can not find an entry for
531 * the target device, I will have to assume it's on the
532 * other side of the bridge, and assign it the bridge's
535 pci_bus_read_config_dword(bus
, PCI_DEVFN(tdevice
, 0),
536 PCI_REVISION_ID
, &work
);
538 if ((work
>> 8) == PCI_TO_PCI_BRIDGE_CLASS
) {
539 pci_bus_read_config_dword(bus
,
540 PCI_DEVFN(tdevice
, 0),
541 PCI_PRIMARY_BUS
, &work
);
542 // See if bridge's secondary bus matches target bus.
543 if (((work
>> 8) & 0x000000FF) == (long) bus_num
) {
551 // If we got here, we didn't find an entry in the IRQ mapping table
552 // for the target PCI device. If we did determine that the target
553 // device is on the other side of a PCI-to-PCI bridge, return the
554 // slot number for the bridge.
555 if (bridgeSlot
!= 0xFF) {
557 kfree(PCIIRQRoutingInfoLength
);
560 kfree(PCIIRQRoutingInfoLength
);
561 // Couldn't find an entry in the routing table for this PCI device
567 * cpqhp_set_attention_status - Turns the Amber LED for a slot on or off
571 cpqhp_set_attention_status(struct controller
*ctrl
, struct pci_func
*func
,
576 hp_slot
= func
->device
- ctrl
->slot_device_offset
;
581 // Wait for exclusive access to hardware
582 down(&ctrl
->crit_sect
);
585 amber_LED_on (ctrl
, hp_slot
);
586 } else if (status
== 0) {
587 amber_LED_off (ctrl
, hp_slot
);
589 // Done with exclusive hardware access
590 up(&ctrl
->crit_sect
);
596 // Wait for SOBS to be unset
597 wait_for_ctrl_irq (ctrl
);
599 // Done with exclusive hardware access
600 up(&ctrl
->crit_sect
);
607 * set_attention_status - Turns the Amber LED for a slot on or off
610 static int set_attention_status (struct hotplug_slot
*hotplug_slot
, u8 status
)
612 struct pci_func
*slot_func
;
613 struct slot
*slot
= hotplug_slot
->private;
614 struct controller
*ctrl
= slot
->ctrl
;
620 dbg("%s - physical_slot = %s\n", __FUNCTION__
, hotplug_slot
->name
);
622 if (cpqhp_get_bus_dev(ctrl
, &bus
, &devfn
, slot
->number
) == -1)
626 function
= devfn
& 0x7;
627 dbg("bus, dev, fn = %d, %d, %d\n", bus
, device
, function
);
629 slot_func
= cpqhp_slot_find(bus
, device
, function
);
633 return cpqhp_set_attention_status(ctrl
, slot_func
, status
);
637 static int process_SI(struct hotplug_slot
*hotplug_slot
)
639 struct pci_func
*slot_func
;
640 struct slot
*slot
= hotplug_slot
->private;
641 struct controller
*ctrl
= slot
->ctrl
;
647 dbg("%s - physical_slot = %s\n", __FUNCTION__
, hotplug_slot
->name
);
649 if (cpqhp_get_bus_dev(ctrl
, &bus
, &devfn
, slot
->number
) == -1)
653 function
= devfn
& 0x7;
654 dbg("bus, dev, fn = %d, %d, %d\n", bus
, device
, function
);
656 slot_func
= cpqhp_slot_find(bus
, device
, function
);
660 slot_func
->bus
= bus
;
661 slot_func
->device
= device
;
662 slot_func
->function
= function
;
663 slot_func
->configured
= 0;
664 dbg("board_added(%p, %p)\n", slot_func
, ctrl
);
665 return cpqhp_process_SI(ctrl
, slot_func
);
669 static int process_SS(struct hotplug_slot
*hotplug_slot
)
671 struct pci_func
*slot_func
;
672 struct slot
*slot
= hotplug_slot
->private;
673 struct controller
*ctrl
= slot
->ctrl
;
679 dbg("%s - physical_slot = %s\n", __FUNCTION__
, hotplug_slot
->name
);
681 if (cpqhp_get_bus_dev(ctrl
, &bus
, &devfn
, slot
->number
) == -1)
685 function
= devfn
& 0x7;
686 dbg("bus, dev, fn = %d, %d, %d\n", bus
, device
, function
);
688 slot_func
= cpqhp_slot_find(bus
, device
, function
);
692 dbg("In %s, slot_func = %p, ctrl = %p\n", __FUNCTION__
, slot_func
, ctrl
);
693 return cpqhp_process_SS(ctrl
, slot_func
);
697 static int hardware_test(struct hotplug_slot
*hotplug_slot
, u32 value
)
699 struct slot
*slot
= hotplug_slot
->private;
700 struct controller
*ctrl
= slot
->ctrl
;
702 dbg("%s - physical_slot = %s\n", __FUNCTION__
, hotplug_slot
->name
);
704 return cpqhp_hardware_test(ctrl
, value
);
708 static int get_power_status(struct hotplug_slot
*hotplug_slot
, u8
*value
)
710 struct slot
*slot
= hotplug_slot
->private;
711 struct controller
*ctrl
= slot
->ctrl
;
713 dbg("%s - physical_slot = %s\n", __FUNCTION__
, hotplug_slot
->name
);
715 *value
= get_slot_enabled(ctrl
, slot
);
719 static int get_attention_status(struct hotplug_slot
*hotplug_slot
, u8
*value
)
721 struct slot
*slot
= hotplug_slot
->private;
722 struct controller
*ctrl
= slot
->ctrl
;
724 dbg("%s - physical_slot = %s\n", __FUNCTION__
, hotplug_slot
->name
);
726 *value
= cpq_get_attention_status(ctrl
, slot
);
730 static int get_latch_status(struct hotplug_slot
*hotplug_slot
, u8
*value
)
732 struct slot
*slot
= hotplug_slot
->private;
733 struct controller
*ctrl
= slot
->ctrl
;
735 dbg("%s - physical_slot = %s\n", __FUNCTION__
, hotplug_slot
->name
);
737 *value
= cpq_get_latch_status(ctrl
, slot
);
742 static int get_adapter_status(struct hotplug_slot
*hotplug_slot
, u8
*value
)
744 struct slot
*slot
= hotplug_slot
->private;
745 struct controller
*ctrl
= slot
->ctrl
;
747 dbg("%s - physical_slot = %s\n", __FUNCTION__
, hotplug_slot
->name
);
749 *value
= get_presence_status(ctrl
, slot
);
754 static int get_max_bus_speed (struct hotplug_slot
*hotplug_slot
, enum pci_bus_speed
*value
)
756 struct slot
*slot
= hotplug_slot
->private;
757 struct controller
*ctrl
= slot
->ctrl
;
759 dbg("%s - physical_slot = %s\n", __FUNCTION__
, hotplug_slot
->name
);
761 *value
= ctrl
->speed_capability
;
766 static int get_cur_bus_speed (struct hotplug_slot
*hotplug_slot
, enum pci_bus_speed
*value
)
768 struct slot
*slot
= hotplug_slot
->private;
769 struct controller
*ctrl
= slot
->ctrl
;
771 dbg("%s - physical_slot = %s\n", __FUNCTION__
, hotplug_slot
->name
);
773 *value
= ctrl
->speed
;
778 static int cpqhpc_probe(struct pci_dev
*pdev
, const struct pci_device_id
*ent
)
788 u16 subsystem_deviceid
;
790 struct controller
*ctrl
;
791 struct pci_func
*func
;
793 // Need to read VID early b/c it's used to differentiate CPQ and INTC discovery
794 rc
= pci_read_config_word(pdev
, PCI_VENDOR_ID
, &vendor_id
);
795 if (rc
|| ((vendor_id
!= PCI_VENDOR_ID_COMPAQ
) && (vendor_id
!= PCI_VENDOR_ID_INTEL
))) {
796 err(msg_HPC_non_compaq_or_intel
);
799 dbg("Vendor ID: %x\n", vendor_id
);
801 rc
= pci_read_config_byte(pdev
, PCI_REVISION_ID
, &rev
);
802 dbg("revision: %d\n", rev
);
803 if (rc
|| ((vendor_id
== PCI_VENDOR_ID_COMPAQ
) && (!rev
))) {
804 err(msg_HPC_rev_error
);
808 /* Check for the proper subsytem ID's
809 * Intel uses a different SSID programming model than Compaq.
810 * For Intel, each SSID bit identifies a PHP capability.
811 * Also Intel HPC's may have RID=0.
813 if ((rev
> 2) || (vendor_id
== PCI_VENDOR_ID_INTEL
)) {
814 // TODO: This code can be made to support non-Compaq or Intel subsystem IDs
815 rc
= pci_read_config_word(pdev
, PCI_SUBSYSTEM_VENDOR_ID
, &subsystem_vid
);
817 err("%s : pci_read_config_word failed\n", __FUNCTION__
);
820 dbg("Subsystem Vendor ID: %x\n", subsystem_vid
);
821 if ((subsystem_vid
!= PCI_VENDOR_ID_COMPAQ
) && (subsystem_vid
!= PCI_VENDOR_ID_INTEL
)) {
822 err(msg_HPC_non_compaq_or_intel
);
826 ctrl
= (struct controller
*) kmalloc(sizeof(struct controller
), GFP_KERNEL
);
828 err("%s : out of memory\n", __FUNCTION__
);
831 memset(ctrl
, 0, sizeof(struct controller
));
833 rc
= pci_read_config_word(pdev
, PCI_SUBSYSTEM_ID
, &subsystem_deviceid
);
835 err("%s : pci_read_config_word failed\n", __FUNCTION__
);
839 info("Hot Plug Subsystem Device ID: %x\n", subsystem_deviceid
);
841 /* Set Vendor ID, so it can be accessed later from other functions */
842 ctrl
->vendor_id
= vendor_id
;
844 switch (subsystem_vid
) {
845 case PCI_VENDOR_ID_COMPAQ
:
846 if (rev
>= 0x13) { /* CIOBX */
848 ctrl
->slot_switch_type
= 1;
849 ctrl
->push_button
= 1;
850 ctrl
->pci_config_space
= 1;
851 ctrl
->defeature_PHP
= 1;
852 ctrl
->pcix_support
= 1;
853 ctrl
->pcix_speed_capability
= 1;
854 pci_read_config_byte(pdev
, 0x41, &bus_cap
);
855 if (bus_cap
& 0x80) {
856 dbg("bus max supports 133MHz PCI-X\n");
857 ctrl
->speed_capability
= PCI_SPEED_133MHz_PCIX
;
860 if (bus_cap
& 0x40) {
861 dbg("bus max supports 100MHz PCI-X\n");
862 ctrl
->speed_capability
= PCI_SPEED_100MHz_PCIX
;
866 dbg("bus max supports 66MHz PCI-X\n");
867 ctrl
->speed_capability
= PCI_SPEED_66MHz_PCIX
;
871 dbg("bus max supports 66MHz PCI\n");
872 ctrl
->speed_capability
= PCI_SPEED_66MHz
;
879 switch (subsystem_deviceid
) {
881 /* Original 6500/7000 implementation */
882 ctrl
->slot_switch_type
= 1;
883 ctrl
->speed_capability
= PCI_SPEED_33MHz
;
884 ctrl
->push_button
= 0;
885 ctrl
->pci_config_space
= 1;
886 ctrl
->defeature_PHP
= 1;
887 ctrl
->pcix_support
= 0;
888 ctrl
->pcix_speed_capability
= 0;
890 case PCI_SUB_HPC_ID2
:
891 /* First Pushbutton implementation */
893 ctrl
->slot_switch_type
= 1;
894 ctrl
->speed_capability
= PCI_SPEED_33MHz
;
895 ctrl
->push_button
= 1;
896 ctrl
->pci_config_space
= 1;
897 ctrl
->defeature_PHP
= 1;
898 ctrl
->pcix_support
= 0;
899 ctrl
->pcix_speed_capability
= 0;
901 case PCI_SUB_HPC_ID_INTC
:
902 /* Third party (6500/7000) */
903 ctrl
->slot_switch_type
= 1;
904 ctrl
->speed_capability
= PCI_SPEED_33MHz
;
905 ctrl
->push_button
= 0;
906 ctrl
->pci_config_space
= 1;
907 ctrl
->defeature_PHP
= 1;
908 ctrl
->pcix_support
= 0;
909 ctrl
->pcix_speed_capability
= 0;
911 case PCI_SUB_HPC_ID3
:
912 /* First 66 Mhz implementation */
914 ctrl
->slot_switch_type
= 1;
915 ctrl
->speed_capability
= PCI_SPEED_66MHz
;
916 ctrl
->push_button
= 1;
917 ctrl
->pci_config_space
= 1;
918 ctrl
->defeature_PHP
= 1;
919 ctrl
->pcix_support
= 0;
920 ctrl
->pcix_speed_capability
= 0;
922 case PCI_SUB_HPC_ID4
:
923 /* First PCI-X implementation, 100MHz */
925 ctrl
->slot_switch_type
= 1;
926 ctrl
->speed_capability
= PCI_SPEED_100MHz_PCIX
;
927 ctrl
->push_button
= 1;
928 ctrl
->pci_config_space
= 1;
929 ctrl
->defeature_PHP
= 1;
930 ctrl
->pcix_support
= 1;
931 ctrl
->pcix_speed_capability
= 0;
934 err(msg_HPC_not_supported
);
940 case PCI_VENDOR_ID_INTEL
:
941 /* Check for speed capability (0=33, 1=66) */
942 if (subsystem_deviceid
& 0x0001) {
943 ctrl
->speed_capability
= PCI_SPEED_66MHz
;
945 ctrl
->speed_capability
= PCI_SPEED_33MHz
;
948 /* Check for push button */
949 if (subsystem_deviceid
& 0x0002) {
951 ctrl
->push_button
= 0;
953 /* push button supported */
954 ctrl
->push_button
= 1;
957 /* Check for slot switch type (0=mechanical, 1=not mechanical) */
958 if (subsystem_deviceid
& 0x0004) {
960 ctrl
->slot_switch_type
= 0;
963 ctrl
->slot_switch_type
= 1;
966 /* PHP Status (0=De-feature PHP, 1=Normal operation) */
967 if (subsystem_deviceid
& 0x0008) {
968 ctrl
->defeature_PHP
= 1; // PHP supported
970 ctrl
->defeature_PHP
= 0; // PHP not supported
973 /* Alternate Base Address Register Interface (0=not supported, 1=supported) */
974 if (subsystem_deviceid
& 0x0010) {
975 ctrl
->alternate_base_address
= 1; // supported
977 ctrl
->alternate_base_address
= 0; // not supported
980 /* PCI Config Space Index (0=not supported, 1=supported) */
981 if (subsystem_deviceid
& 0x0020) {
982 ctrl
->pci_config_space
= 1; // supported
984 ctrl
->pci_config_space
= 0; // not supported
988 if (subsystem_deviceid
& 0x0080) {
990 ctrl
->pcix_support
= 1;
991 /* Frequency of operation in PCI-X mode */
992 if (subsystem_deviceid
& 0x0040) {
993 /* 133MHz PCI-X if bit 7 is 1 */
994 ctrl
->pcix_speed_capability
= 1;
996 /* 100MHz PCI-X if bit 7 is 1 and bit 0 is 0, */
997 /* 66MHz PCI-X if bit 7 is 1 and bit 0 is 1 */
998 ctrl
->pcix_speed_capability
= 0;
1001 /* Conventional PCI */
1002 ctrl
->pcix_support
= 0;
1003 ctrl
->pcix_speed_capability
= 0;
1008 err(msg_HPC_not_supported
);
1014 err(msg_HPC_not_supported
);
1018 // Tell the user that we found one.
1019 info("Initializing the PCI hot plug controller residing on PCI bus %d\n",
1022 dbg("Hotplug controller capabilities:\n");
1023 dbg(" speed_capability %d\n", ctrl
->speed_capability
);
1024 dbg(" slot_switch_type %s\n", ctrl
->slot_switch_type
?
1025 "switch present" : "no switch");
1026 dbg(" defeature_PHP %s\n", ctrl
->defeature_PHP
?
1027 "PHP supported" : "PHP not supported");
1028 dbg(" alternate_base_address %s\n", ctrl
->alternate_base_address
?
1029 "supported" : "not supported");
1030 dbg(" pci_config_space %s\n", ctrl
->pci_config_space
?
1031 "supported" : "not supported");
1032 dbg(" pcix_speed_capability %s\n", ctrl
->pcix_speed_capability
?
1033 "supported" : "not supported");
1034 dbg(" pcix_support %s\n", ctrl
->pcix_support
?
1035 "supported" : "not supported");
1037 ctrl
->pci_dev
= pdev
;
1038 pci_set_drvdata(pdev
, ctrl
);
1040 /* make our own copy of the pci bus structure,
1041 * as we like tweaking it a lot */
1042 ctrl
->pci_bus
= kmalloc(sizeof(*ctrl
->pci_bus
), GFP_KERNEL
);
1043 if (!ctrl
->pci_bus
) {
1044 err("out of memory\n");
1048 memcpy(ctrl
->pci_bus
, pdev
->bus
, sizeof(*ctrl
->pci_bus
));
1050 ctrl
->bus
= pdev
->bus
->number
;
1052 dbg("bus device function rev: %d %d %d %d\n", ctrl
->bus
,
1053 PCI_SLOT(pdev
->devfn
), PCI_FUNC(pdev
->devfn
), ctrl
->rev
);
1055 init_MUTEX(&ctrl
->crit_sect
);
1056 init_waitqueue_head(&ctrl
->queue
);
1058 /* initialize our threads if they haven't already been started up */
1059 rc
= one_time_init();
1064 dbg("pdev = %p\n", pdev
);
1065 dbg("pci resource start %lx\n", pci_resource_start(pdev
, 0));
1066 dbg("pci resource len %lx\n", pci_resource_len(pdev
, 0));
1068 if (!request_mem_region(pci_resource_start(pdev
, 0),
1069 pci_resource_len(pdev
, 0), MY_NAME
)) {
1070 err("cannot reserve MMIO region\n");
1075 ctrl
->hpc_reg
= ioremap(pci_resource_start(pdev
, 0),
1076 pci_resource_len(pdev
, 0));
1077 if (!ctrl
->hpc_reg
) {
1078 err("cannot remap MMIO region %lx @ %lx\n",
1079 pci_resource_len(pdev
, 0),
1080 pci_resource_start(pdev
, 0));
1082 goto err_free_mem_region
;
1085 // Check for 66Mhz operation
1086 ctrl
->speed
= get_controller_speed(ctrl
);
1089 /********************************************************
1091 * Save configuration headers for this and
1092 * subordinate PCI buses
1094 ********************************************************/
1096 // find the physical slot number of the first hot plug slot
1098 /* Get slot won't work for devices behind bridges, but
1099 * in this case it will always be called for the "base"
1100 * bus/dev/func of a slot.
1101 * CS: this is leveraging the PCIIRQ routing code from the kernel
1102 * (pci-pc.c: get_irq_routing_table) */
1103 rc
= get_slot_mapping(ctrl
->pci_bus
, pdev
->bus
->number
,
1104 (readb(ctrl
->hpc_reg
+ SLOT_MASK
) >> 4),
1105 &(ctrl
->first_slot
));
1106 dbg("get_slot_mapping: first_slot = %d, returned = %d\n",
1107 ctrl
->first_slot
, rc
);
1109 err(msg_initialization_err
, rc
);
1113 // Store PCI Config Space for all devices on this bus
1114 rc
= cpqhp_save_config(ctrl
, ctrl
->bus
, readb(ctrl
->hpc_reg
+ SLOT_MASK
));
1116 err("%s: unable to save PCI configuration data, error %d\n",
1122 * Get IO, memory, and IRQ resources for new devices
1124 // The next line is required for cpqhp_find_available_resources
1125 ctrl
->interrupt
= pdev
->irq
;
1126 if (ctrl
->interrupt
< 0x10) {
1127 cpqhp_legacy_mode
= 1;
1128 dbg("System seems to be configured for Full Table Mapped MPS mode\n");
1131 ctrl
->cfgspc_irq
= 0;
1132 pci_read_config_byte(pdev
, PCI_INTERRUPT_LINE
, &ctrl
->cfgspc_irq
);
1134 rc
= cpqhp_find_available_resources(ctrl
, cpqhp_rom_start
);
1135 ctrl
->add_support
= !rc
;
1137 dbg("cpqhp_find_available_resources = 0x%x\n", rc
);
1138 err("unable to locate PCI configuration resources for hot plug add.\n");
1143 * Finish setting up the hot plug ctrl device
1145 ctrl
->slot_device_offset
= readb(ctrl
->hpc_reg
+ SLOT_MASK
) >> 4;
1146 dbg("NumSlots %d \n", ctrl
->slot_device_offset
);
1148 ctrl
->next_event
= 0;
1150 /* Setup the slot information structures */
1151 rc
= ctrl_slot_setup(ctrl
, smbios_start
, smbios_table
);
1153 err(msg_initialization_err
, 6);
1154 err("%s: unable to save PCI configuration data, error %d\n",
1159 /* Mask all general input interrupts */
1160 writel(0xFFFFFFFFL
, ctrl
->hpc_reg
+ INT_MASK
);
1162 /* set up the interrupt */
1163 dbg("HPC interrupt = %d \n", ctrl
->interrupt
);
1164 if (request_irq(ctrl
->interrupt
, cpqhp_ctrl_intr
,
1165 SA_SHIRQ
, MY_NAME
, ctrl
)) {
1166 err("Can't get irq %d for the hotplug pci controller\n",
1172 /* Enable Shift Out interrupt and clear it, also enable SERR on power fault */
1173 temp_word
= readw(ctrl
->hpc_reg
+ MISC
);
1174 temp_word
|= 0x4006;
1175 writew(temp_word
, ctrl
->hpc_reg
+ MISC
);
1177 // Changed 05/05/97 to clear all interrupts at start
1178 writel(0xFFFFFFFFL
, ctrl
->hpc_reg
+ INT_INPUT_CLEAR
);
1180 ctrl
->ctrl_int_comp
= readl(ctrl
->hpc_reg
+ INT_INPUT_CLEAR
);
1182 writel(0x0L
, ctrl
->hpc_reg
+ INT_MASK
);
1184 if (!cpqhp_ctrl_list
) {
1185 cpqhp_ctrl_list
= ctrl
;
1188 ctrl
->next
= cpqhp_ctrl_list
;
1189 cpqhp_ctrl_list
= ctrl
;
1192 // turn off empty slots here unless command line option "ON" set
1193 // Wait for exclusive access to hardware
1194 down(&ctrl
->crit_sect
);
1196 num_of_slots
= readb(ctrl
->hpc_reg
+ SLOT_MASK
) & 0x0F;
1198 // find first device number for the ctrl
1199 device
= readb(ctrl
->hpc_reg
+ SLOT_MASK
) >> 4;
1201 while (num_of_slots
) {
1202 dbg("num_of_slots: %d\n", num_of_slots
);
1203 func
= cpqhp_slot_find(ctrl
->bus
, device
, 0);
1207 hp_slot
= func
->device
- ctrl
->slot_device_offset
;
1208 dbg("hp_slot: %d\n", hp_slot
);
1210 // We have to save the presence info for these slots
1211 temp_word
= ctrl
->ctrl_int_comp
>> 16;
1212 func
->presence_save
= (temp_word
>> hp_slot
) & 0x01;
1213 func
->presence_save
|= (temp_word
>> (hp_slot
+ 7)) & 0x02;
1215 if (ctrl
->ctrl_int_comp
& (0x1L
<< hp_slot
)) {
1216 func
->switch_save
= 0;
1218 func
->switch_save
= 0x10;
1222 if (!func
->is_a_board
) {
1223 green_LED_off(ctrl
, hp_slot
);
1224 slot_disable(ctrl
, hp_slot
);
1234 // Wait for SOBS to be unset
1235 wait_for_ctrl_irq(ctrl
);
1238 rc
= init_SERR(ctrl
);
1240 err("init_SERR failed\n");
1241 up(&ctrl
->crit_sect
);
1245 // Done with exclusive hardware access
1246 up(&ctrl
->crit_sect
);
1248 cpqhp_create_ctrl_files(ctrl
);
1253 free_irq(ctrl
->interrupt
, ctrl
);
1255 iounmap(ctrl
->hpc_reg
);
1256 err_free_mem_region
:
1257 release_mem_region(pci_resource_start(pdev
, 0), pci_resource_len(pdev
, 0));
1259 kfree(ctrl
->pci_bus
);
1266 static int one_time_init(void)
1270 static int initialized
= 0;
1277 retval
= pci_print_IRQ_route();
1281 dbg("Initialize + Start the notification mechanism \n");
1283 retval
= cpqhp_event_start_thread();
1287 dbg("Initialize slot lists\n");
1288 for (loop
= 0; loop
< 256; loop
++) {
1289 cpqhp_slot_list
[loop
] = NULL
;
1292 // FIXME: We also need to hook the NMI handler eventually.
1293 // this also needs to be worked with Christoph
1294 // register_NMI_handler();
1297 cpqhp_rom_start
= ioremap(ROM_PHY_ADDR
, ROM_PHY_LEN
);
1298 if (!cpqhp_rom_start
) {
1299 err ("Could not ioremap memory region for ROM\n");
1304 /* Now, map the int15 entry point if we are on compaq specific hardware */
1305 compaq_nvram_init(cpqhp_rom_start
);
1307 /* Map smbios table entry point structure */
1308 smbios_table
= detect_SMBIOS_pointer(cpqhp_rom_start
,
1309 cpqhp_rom_start
+ ROM_PHY_LEN
);
1310 if (!smbios_table
) {
1311 err ("Could not find the SMBIOS pointer in memory\n");
1313 goto error_rom_start
;
1316 smbios_start
= ioremap(readl(smbios_table
+ ST_ADDRESS
),
1317 readw(smbios_table
+ ST_LENGTH
));
1318 if (!smbios_start
) {
1319 err ("Could not ioremap memory region taken from SMBIOS values\n");
1321 goto error_smbios_start
;
1329 iounmap(smbios_start
);
1331 iounmap(cpqhp_rom_start
);
1337 static void __exit
unload_cpqphpd(void)
1339 struct pci_func
*next
;
1340 struct pci_func
*TempSlot
;
1343 struct controller
*ctrl
;
1344 struct controller
*tctrl
;
1345 struct pci_resource
*res
;
1346 struct pci_resource
*tres
;
1348 rc
= compaq_nvram_store(cpqhp_rom_start
);
1350 ctrl
= cpqhp_ctrl_list
;
1353 if (ctrl
->hpc_reg
) {
1355 rc
= read_slot_enable (ctrl
);
1357 writeb(0, ctrl
->hpc_reg
+ SLOT_SERR
);
1358 writel(0xFFFFFFC0L
| ~rc
, ctrl
->hpc_reg
+ INT_MASK
);
1360 misc
= readw(ctrl
->hpc_reg
+ MISC
);
1362 writew(misc
, ctrl
->hpc_reg
+ MISC
);
1365 ctrl_slot_cleanup(ctrl
);
1367 res
= ctrl
->io_head
;
1374 res
= ctrl
->mem_head
;
1381 res
= ctrl
->p_mem_head
;
1388 res
= ctrl
->bus_head
;
1395 kfree (ctrl
->pci_bus
);
1402 for (loop
= 0; loop
< 256; loop
++) {
1403 next
= cpqhp_slot_list
[loop
];
1404 while (next
!= NULL
) {
1405 res
= next
->io_head
;
1412 res
= next
->mem_head
;
1419 res
= next
->p_mem_head
;
1426 res
= next
->bus_head
;
1439 // Stop the notification mechanism
1440 cpqhp_event_stop_thread();
1442 //unmap the rom address
1443 if (cpqhp_rom_start
)
1444 iounmap(cpqhp_rom_start
);
1446 iounmap(smbios_start
);
1451 static struct pci_device_id hpcd_pci_tbl
[] = {
1453 /* handle any PCI Hotplug controller */
1454 .class = ((PCI_CLASS_SYSTEM_PCI_HOTPLUG
<< 8) | 0x00),
1457 /* no matter who makes it */
1458 .vendor
= PCI_ANY_ID
,
1459 .device
= PCI_ANY_ID
,
1460 .subvendor
= PCI_ANY_ID
,
1461 .subdevice
= PCI_ANY_ID
,
1463 }, { /* end: all zeroes */ }
1466 MODULE_DEVICE_TABLE(pci
, hpcd_pci_tbl
);
1470 static struct pci_driver cpqhpc_driver
= {
1471 .name
= "compaq_pci_hotplug",
1472 .id_table
= hpcd_pci_tbl
,
1473 .probe
= cpqhpc_probe
,
1474 /* remove: cpqhpc_remove_one, */
1479 static int __init
cpqhpc_init(void)
1483 cpqhp_debug
= debug
;
1485 info (DRIVER_DESC
" version: " DRIVER_VERSION
"\n");
1486 result
= pci_module_init(&cpqhpc_driver
);
1487 dbg("pci_module_init = %d\n", result
);
1492 static void __exit
cpqhpc_cleanup(void)
1494 dbg("unload_cpqphpd()\n");
1497 dbg("pci_unregister_driver\n");
1498 pci_unregister_driver(&cpqhpc_driver
);
1502 module_init(cpqhpc_init
);
1503 module_exit(cpqhpc_cleanup
);