X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=drivers%2Fpci%2Fhotplug%2Fshpchp_pci.c;h=2c9b23f4630ed7bc525c23b04664a48a8c071465;hb=5237fac468d9ad78bc9c09d26426b3425b876540;hp=42e7c3662f093dc6efacea0ecc17c263684728a7;hpb=86090fcac5e27b630656fe3d963a6b80e26dac44;p=linux-2.6.git diff --git a/drivers/pci/hotplug/shpchp_pci.c b/drivers/pci/hotplug/shpchp_pci.c index 42e7c3662..2c9b23f46 100644 --- a/drivers/pci/hotplug/shpchp_pci.c +++ b/drivers/pci/hotplug/shpchp_pci.c @@ -53,10 +53,11 @@ int shpchp_configure_device (struct controller* ctrl, struct pci_func* func) /* Still NULL ? Well then scan for it ! */ if (func->pci_dev == NULL) { num = pci_scan_slot(ctrl->pci_dev->subordinate, PCI_DEVFN(func->device, func->function)); - if (num) + if (num) { dbg("%s: subordiante %p number %x\n", __FUNCTION__, ctrl->pci_dev->subordinate, ctrl->pci_dev->subordinate->number); - pci_bus_add_devices(ctrl->pci_dev->subordinate); + pci_bus_add_devices(ctrl->pci_dev->subordinate); + } func->pci_dev = pci_find_slot(func->bus, PCI_DEVFN(func->device, func->function)); if (func->pci_dev == NULL) { @@ -67,7 +68,7 @@ int shpchp_configure_device (struct controller* ctrl, struct pci_func* func) if (func->pci_dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) { pci_read_config_byte(func->pci_dev, PCI_SECONDARY_BUS, &bus); - child = (struct pci_bus*) pci_add_new_bus(func->pci_dev->bus, (func->pci_dev), bus); + child = pci_add_new_bus(func->pci_dev->bus, (func->pci_dev), bus); pci_do_scan_bus(child); } @@ -81,10 +82,12 @@ int shpchp_unconfigure_device(struct pci_func* func) int rc = 0; int j; - dbg("%s: bus/dev/func = %x/%x/%x\n", __FUNCTION__, func->bus, func->device, func->function); + dbg("%s: bus/dev/func = %x/%x/%x\n", __FUNCTION__, func->bus, + func->device, func->function); for (j=0; j<8 ; j++) { - struct pci_dev* temp = pci_find_slot(func->bus, (func->device << 3) | j); + struct pci_dev* temp = pci_find_slot(func->bus, + (func->device << 3) | j); if (temp) { pci_remove_bus_device(temp); } @@ -163,12 +166,14 @@ int shpchp_save_config(struct controller *ctrl, int busnumber, int num_ctlr_slot int is_hot_plug = num_ctlr_slots || first_device_num; struct pci_bus lpci_bus, *pci_bus; - dbg("%s: num_ctlr_slots = %d, first_device_num = %d\n", __FUNCTION__, num_ctlr_slots, first_device_num); + dbg("%s: num_ctlr_slots = %d, first_device_num = %d\n", __FUNCTION__, + num_ctlr_slots, first_device_num); memcpy(&lpci_bus, ctrl->pci_dev->subordinate, sizeof(lpci_bus)); pci_bus = &lpci_bus; - dbg("%s: num_ctlr_slots = %d, first_device_num = %d\n", __FUNCTION__, num_ctlr_slots, first_device_num); + dbg("%s: num_ctlr_slots = %d, first_device_num = %d\n", __FUNCTION__, + num_ctlr_slots, first_device_num); /* Decide which slots are supported */ if (is_hot_plug) { @@ -182,20 +187,24 @@ int shpchp_save_config(struct controller *ctrl, int busnumber, int num_ctlr_slot LastSupported = 0x1F; } - dbg("FirstSupported = %d, LastSupported = %d\n", FirstSupported, LastSupported); + dbg("FirstSupported = %d, LastSupported = %d\n", FirstSupported, + LastSupported); /* Save PCI configuration space for all devices in supported slots */ pci_bus->number = busnumber; for (device = FirstSupported; device <= LastSupported; device++) { ID = 0xFFFFFFFF; - rc = pci_bus_read_config_dword(pci_bus, PCI_DEVFN(device, 0), PCI_VENDOR_ID, &ID); + rc = pci_bus_read_config_dword(pci_bus, PCI_DEVFN(device, 0), + PCI_VENDOR_ID, &ID); if (ID != 0xFFFFFFFF) { /* device in slot */ - rc = pci_bus_read_config_byte(pci_bus, PCI_DEVFN(device, 0), 0x0B, &class_code); + rc = pci_bus_read_config_byte(pci_bus, PCI_DEVFN(device, 0), + 0x0B, &class_code); if (rc) return rc; - rc = pci_bus_read_config_byte(pci_bus, PCI_DEVFN(device, 0), PCI_HEADER_TYPE, &header_type); + rc = pci_bus_read_config_byte(pci_bus, PCI_DEVFN(device, 0), + PCI_HEADER_TYPE, &header_type); if (rc) return rc; @@ -216,7 +225,8 @@ int shpchp_save_config(struct controller *ctrl, int busnumber, int num_ctlr_slot /* Recurse the subordinate bus * get the subordinate bus number */ - rc = pci_bus_read_config_byte(pci_bus, PCI_DEVFN(device, function), + rc = pci_bus_read_config_byte(pci_bus, + PCI_DEVFN(device, function), PCI_SECONDARY_BUS, &secondary_bus); if (rc) { return rc; @@ -255,13 +265,17 @@ int shpchp_save_config(struct controller *ctrl, int busnumber, int num_ctlr_slot new_slot->switch_save = 0x10; /* In case of unsupported board */ new_slot->status = DevError; - new_slot->pci_dev = pci_find_slot(new_slot->bus, (new_slot->device << 3) | new_slot->function); + new_slot->pci_dev = pci_find_slot(new_slot->bus, + (new_slot->device << 3) | new_slot->function); dbg("new_slot->pci_dev = %p\n", new_slot->pci_dev); for (cloop = 0; cloop < 0x20; cloop++) { - rc = pci_bus_read_config_dword(pci_bus, PCI_DEVFN(device, function), - cloop << 2, (u32 *) & (new_slot->config_space [cloop])); - /* dbg("new_slot->config_space[%x] = %x\n", cloop, new_slot->config_space[cloop]); */ + rc = pci_bus_read_config_dword(pci_bus, + PCI_DEVFN(device, function), + cloop << 2, + (u32 *) &(new_slot->config_space [cloop])); + /* dbg("new_slot->config_space[%x] = %x\n", + cloop, new_slot->config_space[cloop]); */ if (rc) return rc; } @@ -275,23 +289,28 @@ int shpchp_save_config(struct controller *ctrl, int busnumber, int num_ctlr_slot */ while ((function < max_functions)&&(!stop_it)) { - rc = pci_bus_read_config_dword(pci_bus, PCI_DEVFN(device, function), PCI_VENDOR_ID, &ID); + rc = pci_bus_read_config_dword(pci_bus, + PCI_DEVFN(device, function), + PCI_VENDOR_ID, &ID); if (ID == 0xFFFFFFFF) { /* nothing there. */ function++; dbg("Nothing there\n"); } else { /* Something there */ - rc = pci_bus_read_config_byte(pci_bus, PCI_DEVFN(device, function), + rc = pci_bus_read_config_byte(pci_bus, + PCI_DEVFN(device, function), 0x0B, &class_code); if (rc) return rc; - rc = pci_bus_read_config_byte(pci_bus, PCI_DEVFN(device, function), + rc = pci_bus_read_config_byte(pci_bus, + PCI_DEVFN(device, function), PCI_HEADER_TYPE, &header_type); if (rc) return rc; - dbg("class_code = %x, header_type = %x\n", class_code, header_type); + dbg("class_code = %x, header_type = %x\n", + class_code, header_type); stop_it++; } } @@ -328,7 +347,7 @@ int shpchp_save_config(struct controller *ctrl, int busnumber, int num_ctlr_slot * * returns 0 if success */ -int shpchp_save_slot_config (struct controller *ctrl, struct pci_func * new_slot) +int shpchp_save_slot_config(struct controller *ctrl, struct pci_func * new_slot) { int rc; u8 class_code; @@ -347,12 +366,15 @@ int shpchp_save_slot_config (struct controller *ctrl, struct pci_func * new_slot ID = 0xFFFFFFFF; - pci_bus_read_config_dword(pci_bus, PCI_DEVFN(new_slot->device, 0), PCI_VENDOR_ID, &ID); + pci_bus_read_config_dword(pci_bus, PCI_DEVFN(new_slot->device, 0), + PCI_VENDOR_ID, &ID); if (ID != 0xFFFFFFFF) { /* device in slot */ - pci_bus_read_config_byte(pci_bus, PCI_DEVFN(new_slot->device, 0), 0x0B, &class_code); + pci_bus_read_config_byte(pci_bus, PCI_DEVFN(new_slot->device, 0), + 0x0B, &class_code); - pci_bus_read_config_byte(pci_bus, PCI_DEVFN(new_slot->device, 0), PCI_HEADER_TYPE, &header_type); + pci_bus_read_config_byte(pci_bus, PCI_DEVFN(new_slot->device, 0), + PCI_HEADER_TYPE, &header_type); if (header_type & 0x80) /* Multi-function device */ max_functions = 8; @@ -364,7 +386,8 @@ int shpchp_save_slot_config (struct controller *ctrl, struct pci_func * new_slot do { if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE) { /* PCI-PCI Bridge */ /* Recurse the subordinate bus */ - pci_bus_read_config_byte(pci_bus, PCI_DEVFN(new_slot->device, function), + pci_bus_read_config_byte(pci_bus, + PCI_DEVFN(new_slot->device, function), PCI_SECONDARY_BUS, &secondary_bus); sub_bus = (int) secondary_bus; @@ -373,15 +396,17 @@ int shpchp_save_slot_config (struct controller *ctrl, struct pci_func * new_slot rc = shpchp_save_config(ctrl, sub_bus, 0, 0); if (rc) - return(rc); + return rc; } /* End of IF */ new_slot->status = 0; for (cloop = 0; cloop < 0x20; cloop++) { - pci_bus_read_config_dword(pci_bus, PCI_DEVFN(new_slot->device, function), - cloop << 2, (u32 *) & (new_slot->config_space [cloop])); + pci_bus_read_config_dword(pci_bus, + PCI_DEVFN(new_slot->device, function), + cloop << 2, + (u32 *) &(new_slot->config_space [cloop])); } function++; @@ -393,15 +418,20 @@ int shpchp_save_slot_config (struct controller *ctrl, struct pci_func * new_slot */ while ((function < max_functions) && (!stop_it)) { - pci_bus_read_config_dword(pci_bus, PCI_DEVFN(new_slot->device, function), PCI_VENDOR_ID, &ID); + pci_bus_read_config_dword(pci_bus, + PCI_DEVFN(new_slot->device, function), + PCI_VENDOR_ID, &ID); if (ID == 0xFFFFFFFF) { /* nothing there. */ function++; } else { /* Something there */ - pci_bus_read_config_byte(pci_bus, PCI_DEVFN(new_slot->device, function), 0x0B, &class_code); + pci_bus_read_config_byte(pci_bus, + PCI_DEVFN(new_slot->device, function), + 0x0B, &class_code); - pci_bus_read_config_byte(pci_bus, PCI_DEVFN(new_slot->device, function), PCI_HEADER_TYPE, - &header_type); + pci_bus_read_config_byte(pci_bus, + PCI_DEVFN(new_slot->device, function), + PCI_HEADER_TYPE, &header_type); stop_it++; } @@ -410,10 +440,10 @@ int shpchp_save_slot_config (struct controller *ctrl, struct pci_func * new_slot } while (function < max_functions); } /* End of IF (device in slot?) */ else { - return(2); + return 2; } - return(0); + return 0; } @@ -429,7 +459,7 @@ int shpchp_save_slot_config (struct controller *ctrl, struct pci_func * new_slot * it loops for all functions of the slot and disables them. * else, it just get resources of the function and return. */ -int shpchp_save_used_resources (struct controller *ctrl, struct pci_func *func, int disable) +int shpchp_save_used_resources(struct controller *ctrl, struct pci_func *func, int disable) { u8 cloop; u8 header_type; @@ -461,7 +491,7 @@ int shpchp_save_used_resources (struct controller *ctrl, struct pci_func *func, devfn = PCI_DEVFN(func->device, func->function); /* Save the command register */ - pci_bus_read_config_word (pci_bus, devfn, PCI_COMMAND, &save_command); + pci_bus_read_config_word(pci_bus, devfn, PCI_COMMAND, &save_command); if (disable) { /* disable card */ @@ -470,20 +500,22 @@ int shpchp_save_used_resources (struct controller *ctrl, struct pci_func *func, } /* Check for Bridge */ - pci_bus_read_config_byte (pci_bus, devfn, PCI_HEADER_TYPE, &header_type); + pci_bus_read_config_byte(pci_bus, devfn, PCI_HEADER_TYPE, &header_type); if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE) { /* PCI-PCI Bridge */ - dbg("Save_used_res of PCI bridge b:d=0x%x:%x, sc=0x%x\n", func->bus, func->device, save_command); + dbg("Save_used_res of PCI bridge b:d=0x%x:%x, sc=0x%x\n", + func->bus, func->device, save_command); if (disable) { /* Clear Bridge Control Register */ command = 0x00; pci_bus_write_config_word(pci_bus, devfn, PCI_BRIDGE_CONTROL, command); } - pci_bus_read_config_byte (pci_bus, devfn, PCI_SECONDARY_BUS, &secondary_bus); - pci_bus_read_config_byte (pci_bus, devfn, PCI_SUBORDINATE_BUS, &temp_byte); + pci_bus_read_config_byte(pci_bus, devfn, PCI_SECONDARY_BUS, &secondary_bus); + pci_bus_read_config_byte(pci_bus, devfn, PCI_SUBORDINATE_BUS, &temp_byte); - bus_node =(struct pci_resource *) kmalloc(sizeof(struct pci_resource), GFP_KERNEL); + bus_node = kmalloc(sizeof(struct pci_resource), + GFP_KERNEL); if (!bus_node) return -ENOMEM; @@ -494,13 +526,14 @@ int shpchp_save_used_resources (struct controller *ctrl, struct pci_func *func, func->bus_head = bus_node; /* Save IO base and Limit registers */ - pci_bus_read_config_byte (pci_bus, devfn, PCI_IO_BASE, &temp_byte); + pci_bus_read_config_byte(pci_bus, devfn, PCI_IO_BASE, &temp_byte); base = temp_byte; - pci_bus_read_config_byte (pci_bus, devfn, PCI_IO_LIMIT, &temp_byte); + pci_bus_read_config_byte(pci_bus, devfn, PCI_IO_LIMIT, &temp_byte); length = temp_byte; if ((base <= length) && (!disable || (save_command & PCI_COMMAND_IO))) { - io_node = (struct pci_resource *) kmalloc(sizeof(struct pci_resource), GFP_KERNEL); + io_node = kmalloc(sizeof(struct pci_resource), + GFP_KERNEL); if (!io_node) return -ENOMEM; @@ -512,11 +545,12 @@ int shpchp_save_used_resources (struct controller *ctrl, struct pci_func *func, } /* Save memory base and Limit registers */ - pci_bus_read_config_word (pci_bus, devfn, PCI_MEMORY_BASE, &w_base); - pci_bus_read_config_word (pci_bus, devfn, PCI_MEMORY_LIMIT, &w_length); + pci_bus_read_config_word(pci_bus, devfn, PCI_MEMORY_BASE, &w_base); + pci_bus_read_config_word(pci_bus, devfn, PCI_MEMORY_LIMIT, &w_length); if ((w_base <= w_length) && (!disable || (save_command & PCI_COMMAND_MEMORY))) { - mem_node = (struct pci_resource *) kmalloc(sizeof(struct pci_resource), GFP_KERNEL); + mem_node = kmalloc(sizeof(struct pci_resource), + GFP_KERNEL); if (!mem_node) return -ENOMEM; @@ -527,11 +561,12 @@ int shpchp_save_used_resources (struct controller *ctrl, struct pci_func *func, func->mem_head = mem_node; } /* Save prefetchable memory base and Limit registers */ - pci_bus_read_config_word (pci_bus, devfn, PCI_PREF_MEMORY_BASE, &w_base); - pci_bus_read_config_word (pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, &w_length); + pci_bus_read_config_word(pci_bus, devfn, PCI_PREF_MEMORY_BASE, &w_base); + pci_bus_read_config_word(pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, &w_length); if ((w_base <= w_length) && (!disable || (save_command & PCI_COMMAND_MEMORY))) { - p_mem_node = (struct pci_resource *) kmalloc(sizeof(struct pci_resource), GFP_KERNEL); + p_mem_node = kmalloc(sizeof(struct pci_resource), + GFP_KERNEL); if (!p_mem_node) return -ENOMEM; @@ -542,38 +577,41 @@ int shpchp_save_used_resources (struct controller *ctrl, struct pci_func *func, func->p_mem_head = p_mem_node; } } else if ((header_type & 0x7F) == PCI_HEADER_TYPE_NORMAL) { - dbg("Save_used_res of PCI adapter b:d=0x%x:%x, sc=0x%x\n", func->bus, func->device, save_command); + dbg("Save_used_res of PCI adapter b:d=0x%x:%x, sc=0x%x\n", + func->bus, func->device, save_command); /* Figure out IO and memory base lengths */ for (cloop = PCI_BASE_ADDRESS_0; cloop <= PCI_BASE_ADDRESS_5; cloop += 4) { - pci_bus_read_config_dword (pci_bus, devfn, cloop, &save_base); + pci_bus_read_config_dword(pci_bus, devfn, cloop, &save_base); temp_register = 0xFFFFFFFF; - pci_bus_write_config_dword (pci_bus, devfn, cloop, temp_register); - pci_bus_read_config_dword (pci_bus, devfn, cloop, &temp_register); + pci_bus_write_config_dword(pci_bus, devfn, cloop, temp_register); + pci_bus_read_config_dword(pci_bus, devfn, cloop, &temp_register); - if (!disable) { - pci_bus_write_config_dword (pci_bus, devfn, cloop, save_base); - } + if (!disable) + pci_bus_write_config_dword(pci_bus, devfn, cloop, save_base); if (!temp_register) continue; base = temp_register; - if ((base & PCI_BASE_ADDRESS_SPACE_IO) && (!disable || (save_command & PCI_COMMAND_IO))) { + if ((base & PCI_BASE_ADDRESS_SPACE_IO) && + (!disable || (save_command & PCI_COMMAND_IO))) { /* IO base */ /* set temp_register = amount of IO space requested */ base = base & 0xFFFFFFFCL; base = (~base) + 1; - io_node = (struct pci_resource *) kmalloc(sizeof (struct pci_resource), GFP_KERNEL); + io_node = kmalloc(sizeof (struct pci_resource), + GFP_KERNEL); if (!io_node) return -ENOMEM; io_node->base = (ulong)save_base & PCI_BASE_ADDRESS_IO_MASK; io_node->length = (ulong)base; - dbg("sur adapter: IO bar=0x%x(length=0x%x)\n", io_node->base, io_node->length); + dbg("sur adapter: IO bar=0x%x(length=0x%x)\n", + io_node->base, io_node->length); io_node->next = func->io_head; func->io_head = io_node; @@ -583,11 +621,13 @@ int shpchp_save_used_resources (struct controller *ctrl, struct pci_func *func, char *res_type_str = "PMEM"; u32 temp_register2; - t_mem_node = (struct pci_resource *) kmalloc(sizeof (struct pci_resource), GFP_KERNEL); + t_mem_node = kmalloc(sizeof (struct pci_resource), + GFP_KERNEL); if (!t_mem_node) return -ENOMEM; - if (!(base & PCI_BASE_ADDRESS_MEM_PREFETCH) && (!disable || (save_command & PCI_COMMAND_MEMORY))) { + if (!(base & PCI_BASE_ADDRESS_MEM_PREFETCH) && + (!disable || (save_command & PCI_COMMAND_MEMORY))) { prefetchable = 0; mem_node = t_mem_node; res_type_str++; @@ -602,16 +642,20 @@ int shpchp_save_used_resources (struct controller *ctrl, struct pci_func *func, if (prefetchable) { p_mem_node->base = (ulong)save_base & PCI_BASE_ADDRESS_MEM_MASK; p_mem_node->length = (ulong)base; - dbg("sur adapter: 32 %s bar=0x%x(length=0x%x)\n", res_type_str, - p_mem_node->base, p_mem_node->length); + dbg("sur adapter: 32 %s bar=0x%x(length=0x%x)\n", + res_type_str, + p_mem_node->base, + p_mem_node->length); p_mem_node->next = func->p_mem_head; func->p_mem_head = p_mem_node; } else { mem_node->base = (ulong)save_base & PCI_BASE_ADDRESS_MEM_MASK; mem_node->length = (ulong)base; - dbg("sur adapter: 32 %s bar=0x%x(length=0x%x)\n", res_type_str, - mem_node->base, mem_node->length); + dbg("sur adapter: 32 %s bar=0x%x(length=0x%x)\n", + res_type_str, + mem_node->base, + mem_node->length); mem_node->next = func->mem_head; func->mem_head = mem_node; @@ -631,16 +675,20 @@ int shpchp_save_used_resources (struct controller *ctrl, struct pci_func *func, if (prefetchable) { p_mem_node->base = base64 & PCI_BASE_ADDRESS_MEM_MASK; p_mem_node->length = base; - dbg("sur adapter: 64 %s base=0x%x(len=0x%x)\n", res_type_str, - p_mem_node->base, p_mem_node->length); + dbg("sur adapter: 64 %s base=0x%x(len=0x%x)\n", + res_type_str, + p_mem_node->base, + p_mem_node->length); p_mem_node->next = func->p_mem_head; func->p_mem_head = p_mem_node; } else { mem_node->base = base64 & PCI_BASE_ADDRESS_MEM_MASK; mem_node->length = base; - dbg("sur adapter: 64 %s base=0x%x(len=0x%x)\n", res_type_str, - mem_node->base, mem_node->length); + dbg("sur adapter: 64 %s base=0x%x(len=0x%x)\n", + res_type_str, + mem_node->base, + mem_node->length); mem_node->next = func->mem_head; func->mem_head = mem_node; @@ -648,13 +696,15 @@ int shpchp_save_used_resources (struct controller *ctrl, struct pci_func *func, cloop += 4; break; default: - dbg("asur: reserved BAR type=0x%x\n", temp_register); + dbg("asur: reserved BAR type=0x%x\n", + temp_register); break; } } } /* End of base register loop */ } else { /* Some other unknown header type */ - dbg("Save_used_res of PCI unknown type b:d=0x%x:%x. skip.\n", func->bus, func->device); + dbg("Save_used_res of PCI unknown type b:d=0x%x:%x. skip.\n", + func->bus, func->device); } /* find the next device in this slot */ @@ -663,9 +713,27 @@ int shpchp_save_used_resources (struct controller *ctrl, struct pci_func *func, func = shpchp_slot_find(func->bus, func->device, index++); } - return(0); + return 0; } +/** + * kfree_resource_list: release memory of all list members + * @res: resource list to free + */ +static inline void +return_resource_list(struct pci_resource **func, struct pci_resource **res) +{ + struct pci_resource *node; + struct pci_resource *t_node; + + node = *func; + *func = NULL; + while (node) { + t_node = node->next; + return_resource(res, node); + node = t_node; + } +} /* * shpchp_return_board_resources @@ -675,95 +743,39 @@ int shpchp_save_used_resources (struct controller *ctrl, struct pci_func *func, * * returns 0 if success */ -int shpchp_return_board_resources(struct pci_func * func, struct resource_lists * resources) +int shpchp_return_board_resources(struct pci_func * func, + struct resource_lists * resources) { - int rc = 0; - struct pci_resource *node; - struct pci_resource *t_node; + int rc; dbg("%s\n", __FUNCTION__); if (!func) - return(1); - - node = func->io_head; - func->io_head = NULL; - while (node) { - t_node = node->next; - return_resource(&(resources->io_head), node); - node = t_node; - } + return 1; - node = func->mem_head; - func->mem_head = NULL; - while (node) { - t_node = node->next; - return_resource(&(resources->mem_head), node); - node = t_node; - } + return_resource_list(&(func->io_head),&(resources->io_head)); + return_resource_list(&(func->mem_head),&(resources->mem_head)); + return_resource_list(&(func->p_mem_head),&(resources->p_mem_head)); + return_resource_list(&(func->bus_head),&(resources->bus_head)); - node = func->p_mem_head; - func->p_mem_head = NULL; - while (node) { - t_node = node->next; - return_resource(&(resources->p_mem_head), node); - node = t_node; - } - - node = func->bus_head; - func->bus_head = NULL; - while (node) { - t_node = node->next; - return_resource(&(resources->bus_head), node); - node = t_node; - } - - rc |= shpchp_resource_sort_and_combine(&(resources->mem_head)); + rc = shpchp_resource_sort_and_combine(&(resources->mem_head)); rc |= shpchp_resource_sort_and_combine(&(resources->p_mem_head)); rc |= shpchp_resource_sort_and_combine(&(resources->io_head)); rc |= shpchp_resource_sort_and_combine(&(resources->bus_head)); - return(rc); + return rc; } - -/* - * shpchp_destroy_resource_list - * - * Puts node back in the resource list pointed to by head +/** + * kfree_resource_list: release memory of all list members + * @res: resource list to free */ -void shpchp_destroy_resource_list (struct resource_lists * resources) +static inline void +kfree_resource_list(struct pci_resource **r) { struct pci_resource *res, *tres; - res = resources->io_head; - resources->io_head = NULL; - - while (res) { - tres = res; - res = res->next; - kfree(tres); - } - - res = resources->mem_head; - resources->mem_head = NULL; - - while (res) { - tres = res; - res = res->next; - kfree(tres); - } - - res = resources->p_mem_head; - resources->p_mem_head = NULL; - - while (res) { - tres = res; - res = res->next; - kfree(tres); - } - - res = resources->bus_head; - resources->bus_head = NULL; + res = *r; + *r = NULL; while (res) { tres = res; @@ -772,50 +784,26 @@ void shpchp_destroy_resource_list (struct resource_lists * resources) } } - -/* - * shpchp_destroy_board_resources - * - * Puts node back in the resource list pointed to by head +/** + * shpchp_destroy_resource_list: put node back in the resource list + * @resources: list to put nodes back */ -void shpchp_destroy_board_resources (struct pci_func * func) +void shpchp_destroy_resource_list(struct resource_lists *resources) { - struct pci_resource *res, *tres; - - res = func->io_head; - func->io_head = NULL; - - while (res) { - tres = res; - res = res->next; - kfree(tres); - } - - res = func->mem_head; - func->mem_head = NULL; - - while (res) { - tres = res; - res = res->next; - kfree(tres); - } - - res = func->p_mem_head; - func->p_mem_head = NULL; - - while (res) { - tres = res; - res = res->next; - kfree(tres); - } - - res = func->bus_head; - func->bus_head = NULL; - - while (res) { - tres = res; - res = res->next; - kfree(tres); - } + kfree_resource_list(&(resources->io_head)); + kfree_resource_list(&(resources->mem_head)); + kfree_resource_list(&(resources->p_mem_head)); + kfree_resource_list(&(resources->bus_head)); } +/** + * shpchp_destroy_board_resources: put node back in the resource list + * @resources: list to put nodes back + */ +void shpchp_destroy_board_resources(struct pci_func * func) +{ + kfree_resource_list(&(func->io_head)); + kfree_resource_list(&(func->mem_head)); + kfree_resource_list(&(func->p_mem_head)); + kfree_resource_list(&(func->bus_head)); +}