2 * Standard 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.
7 * Copyright (C) 2003-2004 Intel Corporation
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 <greg@kroah.com>, <dely.l.sy@intel.com>
30 #include <linux/config.h>
31 #include <linux/module.h>
32 #include <linux/kernel.h>
33 #include <linux/types.h>
34 #include <linux/slab.h>
35 #include <linux/workqueue.h>
36 #include <linux/proc_fs.h>
37 #include <linux/pci.h>
41 #include "../../../arch/i386/pci/pci.h" /* horrible hack showing how processor dependant we are... */
44 int shpchp_configure_device (struct controller* ctrl, struct pci_func* func)
47 struct pci_bus *child;
50 if (func->pci_dev == NULL)
51 func->pci_dev = pci_find_slot(func->bus, PCI_DEVFN(func->device, func->function));
53 /* Still NULL ? Well then scan for it ! */
54 if (func->pci_dev == NULL) {
55 num = pci_scan_slot(ctrl->pci_dev->subordinate, PCI_DEVFN(func->device, func->function));
57 dbg("%s: subordiante %p number %x\n", __FUNCTION__, ctrl->pci_dev->subordinate,
58 ctrl->pci_dev->subordinate->number);
59 pci_bus_add_devices(ctrl->pci_dev->subordinate);
62 func->pci_dev = pci_find_slot(func->bus, PCI_DEVFN(func->device, func->function));
63 if (func->pci_dev == NULL) {
64 dbg("ERROR: pci_dev still null\n");
69 if (func->pci_dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
70 pci_read_config_byte(func->pci_dev, PCI_SECONDARY_BUS, &bus);
71 child = pci_add_new_bus(func->pci_dev->bus, (func->pci_dev), bus);
72 pci_do_scan_bus(child);
80 int shpchp_unconfigure_device(struct pci_func* func)
85 dbg("%s: bus/dev/func = %x/%x/%x\n", __FUNCTION__, func->bus,
86 func->device, func->function);
88 for (j=0; j<8 ; j++) {
89 struct pci_dev* temp = pci_find_slot(func->bus,
90 (func->device << 3) | j);
92 pci_remove_bus_device(temp);
101 * @bus_num: bus number of PCI device
102 * @dev_num: device number of PCI device
103 * @slot: pointer to u8 where slot number will be returned
105 int shpchp_set_irq (u8 bus_num, u8 dev_num, u8 int_pin, u8 irq_num)
107 #if defined(CONFIG_X86) && !defined(CONFIG_X86_IO_APIC) && !defined(CONFIG_X86_64)
110 struct pci_dev fakedev;
111 struct pci_bus fakebus;
113 fakedev.devfn = dev_num << 3;
114 fakedev.bus = &fakebus;
115 fakebus.number = bus_num;
116 dbg("%s: dev %d, bus %d, pin %d, num %d\n",
117 __FUNCTION__, dev_num, bus_num, int_pin, irq_num);
118 rc = pcibios_set_irq_routing(&fakedev, int_pin - 0x0a, irq_num);
119 dbg("%s: rc %d\n", __FUNCTION__, rc);
123 /* set the Edge Level Control Register (ELCR) */
124 temp_word = inb(0x4d0);
125 temp_word |= inb(0x4d1) << 8;
127 temp_word |= 0x01 << irq_num;
129 /* This should only be for x86 as it sets the Edge Level Control Register */
130 outb((u8) (temp_word & 0xFF), 0x4d0);
131 outb((u8) ((temp_word & 0xFF00) >> 8), 0x4d1);
136 /* More PCI configuration routines; this time centered around hotplug controller */
142 * Reads configuration for all slots in a PCI bus and saves info.
144 * Note: For non-hot plug busses, the slot # saved is the device #
146 * returns 0 if success
148 int shpchp_save_config(struct controller *ctrl, int busnumber, int num_ctlr_slots, int first_device_num)
155 struct pci_func *new_slot;
166 int is_hot_plug = num_ctlr_slots || first_device_num;
167 struct pci_bus lpci_bus, *pci_bus;
169 dbg("%s: num_ctlr_slots = %d, first_device_num = %d\n", __FUNCTION__,
170 num_ctlr_slots, first_device_num);
172 memcpy(&lpci_bus, ctrl->pci_dev->subordinate, sizeof(lpci_bus));
175 dbg("%s: num_ctlr_slots = %d, first_device_num = %d\n", __FUNCTION__,
176 num_ctlr_slots, first_device_num);
178 /* Decide which slots are supported */
180 /*********************************
181 * is_hot_plug is the slot mask
182 *********************************/
183 FirstSupported = first_device_num;
184 LastSupported = FirstSupported + num_ctlr_slots - 1;
187 LastSupported = 0x1F;
190 dbg("FirstSupported = %d, LastSupported = %d\n", FirstSupported,
193 /* Save PCI configuration space for all devices in supported slots */
194 pci_bus->number = busnumber;
195 for (device = FirstSupported; device <= LastSupported; device++) {
197 rc = pci_bus_read_config_dword(pci_bus, PCI_DEVFN(device, 0),
200 if (ID != 0xFFFFFFFF) { /* device in slot */
201 rc = pci_bus_read_config_byte(pci_bus, PCI_DEVFN(device, 0),
206 rc = pci_bus_read_config_byte(pci_bus, PCI_DEVFN(device, 0),
207 PCI_HEADER_TYPE, &header_type);
211 dbg("class_code = %x, header_type = %x\n", class_code, header_type);
213 /* If multi-function device, set max_functions to 8 */
214 if (header_type & 0x80)
224 if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE) { /* P-P Bridge */
225 /* Recurse the subordinate bus
226 * get the subordinate bus number
228 rc = pci_bus_read_config_byte(pci_bus,
229 PCI_DEVFN(device, function),
230 PCI_SECONDARY_BUS, &secondary_bus);
234 sub_bus = (int) secondary_bus;
236 /* Save secondary bus cfg spc with this recursive call. */
237 rc = shpchp_save_config(ctrl, sub_bus, 0, 0);
244 new_slot = shpchp_slot_find(busnumber, device, index++);
246 dbg("new_slot = %p\n", new_slot);
248 while (new_slot && (new_slot->function != (u8) function)) {
249 new_slot = shpchp_slot_find(busnumber, device, index++);
250 dbg("new_slot = %p\n", new_slot);
253 /* Setup slot structure. */
254 new_slot = shpchp_slot_create(busnumber);
255 dbg("new_slot = %p\n", new_slot);
257 if (new_slot == NULL)
261 new_slot->bus = (u8) busnumber;
262 new_slot->device = (u8) device;
263 new_slot->function = (u8) function;
264 new_slot->is_a_board = 1;
265 new_slot->switch_save = 0x10;
266 /* In case of unsupported board */
267 new_slot->status = DevError;
268 new_slot->pci_dev = pci_find_slot(new_slot->bus,
269 (new_slot->device << 3) | new_slot->function);
270 dbg("new_slot->pci_dev = %p\n", new_slot->pci_dev);
272 for (cloop = 0; cloop < 0x20; cloop++) {
273 rc = pci_bus_read_config_dword(pci_bus,
274 PCI_DEVFN(device, function),
276 (u32 *) &(new_slot->config_space [cloop]));
277 /* dbg("new_slot->config_space[%x] = %x\n",
278 cloop, new_slot->config_space[cloop]); */
287 /* this loop skips to the next present function
288 * reading in Class Code and Header type.
291 while ((function < max_functions)&&(!stop_it)) {
292 rc = pci_bus_read_config_dword(pci_bus,
293 PCI_DEVFN(device, function),
296 if (ID == 0xFFFFFFFF) { /* nothing there. */
298 dbg("Nothing there\n");
299 } else { /* Something there */
300 rc = pci_bus_read_config_byte(pci_bus,
301 PCI_DEVFN(device, function),
306 rc = pci_bus_read_config_byte(pci_bus,
307 PCI_DEVFN(device, function),
308 PCI_HEADER_TYPE, &header_type);
312 dbg("class_code = %x, header_type = %x\n",
313 class_code, header_type);
318 } while (function < max_functions);
319 /* End of IF (device in slot?) */
320 } else if (is_hot_plug) {
321 /* Setup slot structure with entry for empty slot */
322 new_slot = shpchp_slot_create(busnumber);
324 if (new_slot == NULL) {
327 dbg("new_slot = %p\n", new_slot);
329 new_slot->bus = (u8) busnumber;
330 new_slot->device = (u8) device;
331 new_slot->function = 0;
332 new_slot->is_a_board = 0;
333 new_slot->presence_save = 0;
334 new_slot->switch_save = 0;
336 } /* End of FOR loop */
343 * shpchp_save_slot_config
345 * Saves configuration info for all PCI devices in a given slot
346 * including subordinate busses.
348 * returns 0 if success
350 int shpchp_save_slot_config(struct controller *ctrl, struct pci_func * new_slot)
362 struct pci_bus lpci_bus, *pci_bus;
363 memcpy(&lpci_bus, ctrl->pci_dev->subordinate, sizeof(lpci_bus));
365 pci_bus->number = new_slot->bus;
369 pci_bus_read_config_dword(pci_bus, PCI_DEVFN(new_slot->device, 0),
372 if (ID != 0xFFFFFFFF) { /* device in slot */
373 pci_bus_read_config_byte(pci_bus, PCI_DEVFN(new_slot->device, 0),
376 pci_bus_read_config_byte(pci_bus, PCI_DEVFN(new_slot->device, 0),
377 PCI_HEADER_TYPE, &header_type);
379 if (header_type & 0x80) /* Multi-function device */
387 if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE) { /* PCI-PCI Bridge */
388 /* Recurse the subordinate bus */
389 pci_bus_read_config_byte(pci_bus,
390 PCI_DEVFN(new_slot->device, function),
391 PCI_SECONDARY_BUS, &secondary_bus);
393 sub_bus = (int) secondary_bus;
395 /* Save the config headers for the secondary bus. */
396 rc = shpchp_save_config(ctrl, sub_bus, 0, 0);
403 new_slot->status = 0;
405 for (cloop = 0; cloop < 0x20; cloop++) {
406 pci_bus_read_config_dword(pci_bus,
407 PCI_DEVFN(new_slot->device, function),
409 (u32 *) &(new_slot->config_space [cloop]));
416 /* this loop skips to the next present function
417 * reading in the Class Code and the Header type.
420 while ((function < max_functions) && (!stop_it)) {
421 pci_bus_read_config_dword(pci_bus,
422 PCI_DEVFN(new_slot->device, function),
425 if (ID == 0xFFFFFFFF) { /* nothing there. */
427 } else { /* Something there */
428 pci_bus_read_config_byte(pci_bus,
429 PCI_DEVFN(new_slot->device, function),
432 pci_bus_read_config_byte(pci_bus,
433 PCI_DEVFN(new_slot->device, function),
434 PCI_HEADER_TYPE, &header_type);
440 } while (function < max_functions);
441 } /* End of IF (device in slot?) */
451 * shpchp_save_used_resources
453 * Stores used resource information for existing boards. this is
454 * for boards that were in the system when this driver was loaded.
455 * this function is for hot plug ADD
457 * returns 0 if success
458 * if disable == 1(DISABLE_CARD),
459 * it loops for all functions of the slot and disables them.
460 * else, it just get resources of the function and return.
462 int shpchp_save_used_resources(struct controller *ctrl, struct pci_func *func, int disable)
470 u16 w_base, w_length;
477 struct pci_resource *mem_node = NULL;
478 struct pci_resource *p_mem_node = NULL;
479 struct pci_resource *t_mem_node;
480 struct pci_resource *io_node;
481 struct pci_resource *bus_node;
482 struct pci_bus lpci_bus, *pci_bus;
483 memcpy(&lpci_bus, ctrl->pci_dev->subordinate, sizeof(lpci_bus));
487 func = shpchp_slot_find(func->bus, func->device, index++);
489 while ((func != NULL) && func->is_a_board) {
490 pci_bus->number = func->bus;
491 devfn = PCI_DEVFN(func->device, func->function);
493 /* Save the command register */
494 pci_bus_read_config_word(pci_bus, devfn, PCI_COMMAND, &save_command);
499 pci_bus_write_config_word(pci_bus, devfn, PCI_COMMAND, command);
502 /* Check for Bridge */
503 pci_bus_read_config_byte(pci_bus, devfn, PCI_HEADER_TYPE, &header_type);
505 if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE) { /* PCI-PCI Bridge */
506 dbg("Save_used_res of PCI bridge b:d=0x%x:%x, sc=0x%x\n",
507 func->bus, func->device, save_command);
509 /* Clear Bridge Control Register */
511 pci_bus_write_config_word(pci_bus, devfn, PCI_BRIDGE_CONTROL, command);
514 pci_bus_read_config_byte(pci_bus, devfn, PCI_SECONDARY_BUS, &secondary_bus);
515 pci_bus_read_config_byte(pci_bus, devfn, PCI_SUBORDINATE_BUS, &temp_byte);
517 bus_node = kmalloc(sizeof(struct pci_resource),
522 bus_node->base = (ulong)secondary_bus;
523 bus_node->length = (ulong)(temp_byte - secondary_bus + 1);
525 bus_node->next = func->bus_head;
526 func->bus_head = bus_node;
528 /* Save IO base and Limit registers */
529 pci_bus_read_config_byte(pci_bus, devfn, PCI_IO_BASE, &temp_byte);
531 pci_bus_read_config_byte(pci_bus, devfn, PCI_IO_LIMIT, &temp_byte);
534 if ((base <= length) && (!disable || (save_command & PCI_COMMAND_IO))) {
535 io_node = kmalloc(sizeof(struct pci_resource),
540 io_node->base = (ulong)(base & PCI_IO_RANGE_MASK) << 8;
541 io_node->length = (ulong)(length - base + 0x10) << 8;
543 io_node->next = func->io_head;
544 func->io_head = io_node;
547 /* Save memory base and Limit registers */
548 pci_bus_read_config_word(pci_bus, devfn, PCI_MEMORY_BASE, &w_base);
549 pci_bus_read_config_word(pci_bus, devfn, PCI_MEMORY_LIMIT, &w_length);
551 if ((w_base <= w_length) && (!disable || (save_command & PCI_COMMAND_MEMORY))) {
552 mem_node = kmalloc(sizeof(struct pci_resource),
557 mem_node->base = (ulong)w_base << 16;
558 mem_node->length = (ulong)(w_length - w_base + 0x10) << 16;
560 mem_node->next = func->mem_head;
561 func->mem_head = mem_node;
563 /* Save prefetchable memory base and Limit registers */
564 pci_bus_read_config_word(pci_bus, devfn, PCI_PREF_MEMORY_BASE, &w_base);
565 pci_bus_read_config_word(pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, &w_length);
567 if ((w_base <= w_length) && (!disable || (save_command & PCI_COMMAND_MEMORY))) {
568 p_mem_node = kmalloc(sizeof(struct pci_resource),
573 p_mem_node->base = (ulong)w_base << 16;
574 p_mem_node->length = (ulong)(w_length - w_base + 0x10) << 16;
576 p_mem_node->next = func->p_mem_head;
577 func->p_mem_head = p_mem_node;
579 } else if ((header_type & 0x7F) == PCI_HEADER_TYPE_NORMAL) {
580 dbg("Save_used_res of PCI adapter b:d=0x%x:%x, sc=0x%x\n",
581 func->bus, func->device, save_command);
583 /* Figure out IO and memory base lengths */
584 for (cloop = PCI_BASE_ADDRESS_0; cloop <= PCI_BASE_ADDRESS_5; cloop += 4) {
585 pci_bus_read_config_dword(pci_bus, devfn, cloop, &save_base);
587 temp_register = 0xFFFFFFFF;
588 pci_bus_write_config_dword(pci_bus, devfn, cloop, temp_register);
589 pci_bus_read_config_dword(pci_bus, devfn, cloop, &temp_register);
592 pci_bus_write_config_dword(pci_bus, devfn, cloop, save_base);
597 base = temp_register;
599 if ((base & PCI_BASE_ADDRESS_SPACE_IO) &&
600 (!disable || (save_command & PCI_COMMAND_IO))) {
602 /* set temp_register = amount of IO space requested */
603 base = base & 0xFFFFFFFCL;
606 io_node = kmalloc(sizeof (struct pci_resource),
611 io_node->base = (ulong)save_base & PCI_BASE_ADDRESS_IO_MASK;
612 io_node->length = (ulong)base;
613 dbg("sur adapter: IO bar=0x%x(length=0x%x)\n",
614 io_node->base, io_node->length);
616 io_node->next = func->io_head;
617 func->io_head = io_node;
618 } else { /* map Memory */
619 int prefetchable = 1;
620 /* struct pci_resources **res_node; */
621 char *res_type_str = "PMEM";
624 t_mem_node = kmalloc(sizeof (struct pci_resource),
629 if (!(base & PCI_BASE_ADDRESS_MEM_PREFETCH) &&
630 (!disable || (save_command & PCI_COMMAND_MEMORY))) {
632 mem_node = t_mem_node;
635 p_mem_node = t_mem_node;
637 base = base & 0xFFFFFFF0L;
640 switch (temp_register & PCI_BASE_ADDRESS_MEM_TYPE_MASK) {
641 case PCI_BASE_ADDRESS_MEM_TYPE_32:
643 p_mem_node->base = (ulong)save_base & PCI_BASE_ADDRESS_MEM_MASK;
644 p_mem_node->length = (ulong)base;
645 dbg("sur adapter: 32 %s bar=0x%x(length=0x%x)\n",
650 p_mem_node->next = func->p_mem_head;
651 func->p_mem_head = p_mem_node;
653 mem_node->base = (ulong)save_base & PCI_BASE_ADDRESS_MEM_MASK;
654 mem_node->length = (ulong)base;
655 dbg("sur adapter: 32 %s bar=0x%x(length=0x%x)\n",
660 mem_node->next = func->mem_head;
661 func->mem_head = mem_node;
664 case PCI_BASE_ADDRESS_MEM_TYPE_64:
665 pci_bus_read_config_dword(pci_bus, devfn, cloop+4, &temp_register2);
666 base64 = temp_register2;
667 base64 = (base64 << 32) | save_base;
669 if (temp_register2) {
670 dbg("sur adapter: 64 %s high dword of base64(0x%x:%x) masked to 0\n",
671 res_type_str, temp_register2, (u32)base64);
672 base64 &= 0x00000000FFFFFFFFL;
676 p_mem_node->base = base64 & PCI_BASE_ADDRESS_MEM_MASK;
677 p_mem_node->length = base;
678 dbg("sur adapter: 64 %s base=0x%x(len=0x%x)\n",
683 p_mem_node->next = func->p_mem_head;
684 func->p_mem_head = p_mem_node;
686 mem_node->base = base64 & PCI_BASE_ADDRESS_MEM_MASK;
687 mem_node->length = base;
688 dbg("sur adapter: 64 %s base=0x%x(len=0x%x)\n",
693 mem_node->next = func->mem_head;
694 func->mem_head = mem_node;
699 dbg("asur: reserved BAR type=0x%x\n",
704 } /* End of base register loop */
705 } else { /* Some other unknown header type */
706 dbg("Save_used_res of PCI unknown type b:d=0x%x:%x. skip.\n",
707 func->bus, func->device);
710 /* find the next device in this slot */
713 func = shpchp_slot_find(func->bus, func->device, index++);
720 * kfree_resource_list: release memory of all list members
721 * @res: resource list to free
724 return_resource_list(struct pci_resource **func, struct pci_resource **res)
726 struct pci_resource *node;
727 struct pci_resource *t_node;
733 return_resource(res, node);
739 * shpchp_return_board_resources
741 * this routine returns all resources allocated to a board to
742 * the available pool.
744 * returns 0 if success
746 int shpchp_return_board_resources(struct pci_func * func,
747 struct resource_lists * resources)
750 dbg("%s\n", __FUNCTION__);
755 return_resource_list(&(func->io_head),&(resources->io_head));
756 return_resource_list(&(func->mem_head),&(resources->mem_head));
757 return_resource_list(&(func->p_mem_head),&(resources->p_mem_head));
758 return_resource_list(&(func->bus_head),&(resources->bus_head));
760 rc = shpchp_resource_sort_and_combine(&(resources->mem_head));
761 rc |= shpchp_resource_sort_and_combine(&(resources->p_mem_head));
762 rc |= shpchp_resource_sort_and_combine(&(resources->io_head));
763 rc |= shpchp_resource_sort_and_combine(&(resources->bus_head));
769 * kfree_resource_list: release memory of all list members
770 * @res: resource list to free
773 kfree_resource_list(struct pci_resource **r)
775 struct pci_resource *res, *tres;
788 * shpchp_destroy_resource_list: put node back in the resource list
789 * @resources: list to put nodes back
791 void shpchp_destroy_resource_list(struct resource_lists *resources)
793 kfree_resource_list(&(resources->io_head));
794 kfree_resource_list(&(resources->mem_head));
795 kfree_resource_list(&(resources->p_mem_head));
796 kfree_resource_list(&(resources->bus_head));
800 * shpchp_destroy_board_resources: put node back in the resource list
801 * @resources: list to put nodes back
803 void shpchp_destroy_board_resources(struct pci_func * func)
805 kfree_resource_list(&(func->io_head));
806 kfree_resource_list(&(func->mem_head));
807 kfree_resource_list(&(func->p_mem_head));
808 kfree_resource_list(&(func->bus_head));