ChangeSet 1.1587.12.74, 2004/04/30 15:24:49-07:00, eike-hotplug@sf-tec.de [PATCH] SHPC PCI Hotplug: more coding style fixes A big bunch of coding style fixes for shpchp_ctrl.c and shpchp_pci.c Eike drivers/pci/hotplug/shpchp_ctrl.c | 25 ++--- drivers/pci/hotplug/shpchp_pci.c | 189 +++++++++++++++++++++++--------------- 2 files changed, 132 insertions(+), 82 deletions(-) diff -Nru a/drivers/pci/hotplug/shpchp_ctrl.c b/drivers/pci/hotplug/shpchp_ctrl.c --- a/drivers/pci/hotplug/shpchp_ctrl.c Mon May 17 16:58:13 2004 +++ b/drivers/pci/hotplug/shpchp_ctrl.c Mon May 17 16:58:13 2004 @@ -2516,7 +2516,7 @@ kfree(hold_mem_node); kfree(hold_p_mem_node); - return(1); + return 1; } memcpy(hold_bus_node, bus_node, sizeof(struct pci_resource)); @@ -2535,11 +2535,11 @@ /* set IO base and Limit registers */ RES_CHECK(io_node->base, 8); temp_byte = (u8)(io_node->base >> 8); - rc = pci_bus_write_config_byte (pci_bus, devfn, PCI_IO_BASE, temp_byte); + rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_IO_BASE, temp_byte); RES_CHECK(io_node->base + io_node->length - 1, 8); temp_byte = (u8)((io_node->base + io_node->length - 1) >> 8); - rc = pci_bus_write_config_byte (pci_bus, devfn, PCI_IO_LIMIT, temp_byte); + rc = pci_bus_write_config_byte(pci_bus, devfn, PCI_IO_LIMIT, temp_byte); } else { kfree(hold_IO_node); hold_IO_node = NULL; @@ -2556,17 +2556,17 @@ /* set Mem base and Limit registers */ RES_CHECK(mem_node->base, 16); temp_word = (u32)(mem_node->base >> 16); - rc = pci_bus_write_config_word (pci_bus, devfn, PCI_MEMORY_BASE, temp_word); + rc = pci_bus_write_config_word(pci_bus, devfn, PCI_MEMORY_BASE, temp_word); RES_CHECK(mem_node->base + mem_node->length - 1, 16); temp_word = (u32)((mem_node->base + mem_node->length - 1) >> 16); - rc = pci_bus_write_config_word (pci_bus, devfn, PCI_MEMORY_LIMIT, temp_word); + rc = pci_bus_write_config_word(pci_bus, devfn, PCI_MEMORY_LIMIT, temp_word); } else { temp_word = 0xFFFF; - rc = pci_bus_write_config_word (pci_bus, devfn, PCI_MEMORY_BASE, temp_word); + rc = pci_bus_write_config_word(pci_bus, devfn, PCI_MEMORY_BASE, temp_word); temp_word = 0x0000; - rc = pci_bus_write_config_word (pci_bus, devfn, PCI_MEMORY_LIMIT, temp_word); + rc = pci_bus_write_config_word(pci_bus, devfn, PCI_MEMORY_LIMIT, temp_word); kfree(hold_mem_node); hold_mem_node = NULL; @@ -2583,17 +2583,17 @@ /* set Pre Mem base and Limit registers */ RES_CHECK(p_mem_node->base, 16); temp_word = (u32)(p_mem_node->base >> 16); - rc = pci_bus_write_config_word (pci_bus, devfn, PCI_PREF_MEMORY_BASE, temp_word); + rc = pci_bus_write_config_word(pci_bus, devfn, PCI_PREF_MEMORY_BASE, temp_word); RES_CHECK(p_mem_node->base + p_mem_node->length - 1, 16); temp_word = (u32)((p_mem_node->base + p_mem_node->length - 1) >> 16); - rc = pci_bus_write_config_word (pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, temp_word); + rc = pci_bus_write_config_word(pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, temp_word); } else { temp_word = 0xFFFF; - rc = pci_bus_write_config_word (pci_bus, devfn, PCI_PREF_MEMORY_BASE, temp_word); + rc = pci_bus_write_config_word(pci_bus, devfn, PCI_PREF_MEMORY_BASE, temp_word); temp_word = 0x0000; - rc = pci_bus_write_config_word (pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, temp_word); + rc = pci_bus_write_config_word(pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, temp_word); kfree(hold_p_mem_node); hold_p_mem_node = NULL; @@ -2610,7 +2610,8 @@ ID = 0xFFFFFFFF; pci_bus->number = hold_bus_node->base; - pci_bus_read_config_dword (pci_bus, PCI_DEVFN(device, 0), PCI_VENDOR_ID, &ID); + pci_bus_read_config_dword(pci_bus, PCI_DEVFN(device, 0), + PCI_VENDOR_ID, &ID); pci_bus->number = func->bus; if (ID != 0xFFFFFFFF) { /* device Present */ diff -Nru a/drivers/pci/hotplug/shpchp_pci.c b/drivers/pci/hotplug/shpchp_pci.c --- a/drivers/pci/hotplug/shpchp_pci.c Mon May 17 16:58:13 2004 +++ b/drivers/pci/hotplug/shpchp_pci.c Mon May 17 16:58:13 2004 @@ -82,10 +82,12 @@ 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); } @@ -164,12 +166,14 @@ 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) { @@ -183,20 +187,24 @@ 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; @@ -217,7 +225,8 @@ /* 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; @@ -256,13 +265,17 @@ 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; } @@ -276,23 +289,28 @@ */ 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++; } } @@ -329,7 +347,7 @@ * * 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; @@ -348,12 +366,15 @@ 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; @@ -365,7 +386,8 @@ 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; @@ -374,15 +396,17 @@ 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++; @@ -394,15 +418,20 @@ */ 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), PCI_HEADER_TYPE, - &header_type); + 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); stop_it++; } @@ -411,10 +440,10 @@ } while (function < max_functions); } /* End of IF (device in slot?) */ else { - return(2); + return 2; } - return(0); + return 0; } @@ -430,7 +459,7 @@ * 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; @@ -462,7 +491,7 @@ 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 */ @@ -471,20 +500,22 @@ } /* 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; @@ -495,13 +526,14 @@ 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; @@ -513,11 +545,12 @@ } /* 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; @@ -528,11 +561,12 @@ 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; @@ -543,38 +577,41 @@ 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; @@ -584,11 +621,13 @@ 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++; @@ -603,16 +642,20 @@ 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; @@ -632,16 +675,20 @@ 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; @@ -649,13 +696,15 @@ 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 */