diff options
author | Greg Kroah-Hartman <gregkh@suse.de> | 2006-03-14 10:49:04 -0800 |
---|---|---|
committer | Greg Kroah-Hartman <gregkh@suse.de> | 2006-03-14 10:49:04 -0800 |
commit | 1bce3d7a9fb6937d92c060656c0345a8de1f9015 (patch) | |
tree | f460d362a15f70e6d94f9370d8d67dcf906aeb3b /pci | |
parent | 85b9348e941df073c2c13d6668929e0477f043ee (diff) | |
download | patches-1bce3d7a9fb6937d92c060656c0345a8de1f9015.tar.gz |
pci and usb patches
Diffstat (limited to 'pci')
-rw-r--r-- | pci/acpiphp-scan-slots-under-the-nested-p2p-bridge.patch | 74 | ||||
-rw-r--r-- | pci/pci-kzalloc-conversion-in-drivers-pci.patch | 1020 |
2 files changed, 1094 insertions, 0 deletions
diff --git a/pci/acpiphp-scan-slots-under-the-nested-p2p-bridge.patch b/pci/acpiphp-scan-slots-under-the-nested-p2p-bridge.patch new file mode 100644 index 0000000000000..0a4559e00b827 --- /dev/null +++ b/pci/acpiphp-scan-slots-under-the-nested-p2p-bridge.patch @@ -0,0 +1,74 @@ +From kaneshige.kenji@jp.fujitsu.com Mon Feb 27 05:17:54 2006 +Message-ID: <4402FB85.2010608@jp.fujitsu.com> +Date: Mon, 27 Feb 2006 22:15:49 +0900 +From: Kenji Kaneshige <kaneshige.kenji@jp.fujitsu.com> +To: pcihpd-discuss@lists.sourceforge.net, Greg KH <greg@kroah.com> +Subject: acpiphp: Scan slots under the nested P2P bridge + + +Current ACPIPHP driver scans only slots under the top level PCI-to-PCI +bridge. So hotplug PCI slots under the nested PCI-to-PCI bridge would +not be detected. For example, if the system has the ACPI namespace +like below, hotplug slots woule not be detected. + +Device (PCI0) { /* Root bridge */ + Name (_HID, "PNP0A03") + Device (P2PA) { /* PCI-to-PCI bridge */ + Name (_ADR, ...) + Device (P2PB) { /* PCI-to-PCI bridge */ + Name (_ADR, ...) + Device (S0F0) { /* hotplug slot */ + Name (_ADR, ...) + Name (_SUN, ...) + Method (_EJ0, ...) { ... } + } + ... + Device (S0F7) { /* hotplug slot */ + Name (_ADR, ...) + Name (_SUN, ...) + Method (_EJ0, ...) { ... } + } + Device (S1F0) { /* hotplug slot */ + Name (_ADR, ...) + Name (_SUN, ...) + Method (_EJ0, ...) { ... } + } + ... + } + } +} + +This patch fixes this issue. + +Signed-off-by: Kenji Kaneshige <kaneshige.kenji@jp.fujitsu.com> +Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de> + +--- + drivers/pci/hotplug/acpiphp_glue.c | 9 ++++++++- + 1 file changed, 8 insertions(+), 1 deletion(-) + +--- gregkh-2.6.orig/drivers/pci/hotplug/acpiphp_glue.c ++++ gregkh-2.6/drivers/pci/hotplug/acpiphp_glue.c +@@ -463,6 +463,12 @@ find_p2p_bridge(acpi_handle handle, u32 + add_p2p_bridge(handle, dev); + } + ++ /* search P2P bridges under this p2p bridge */ ++ status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, (u32)1, ++ find_p2p_bridge, dev->subordinate, NULL); ++ if (ACPI_FAILURE(status)) ++ warn("find_p2p_bridge faied (error code = 0x%x)\n", status); ++ + out: + pci_dev_put(dev); + return AE_OK; +@@ -603,7 +609,8 @@ static void remove_bridge(acpi_handle ha + } else { + /* clean-up p2p bridges under this host bridge */ + acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, +- (u32)1, cleanup_p2p_bridge, NULL, NULL); ++ ACPI_UINT32_MAX, cleanup_p2p_bridge, ++ NULL, NULL); + } + } + diff --git a/pci/pci-kzalloc-conversion-in-drivers-pci.patch b/pci/pci-kzalloc-conversion-in-drivers-pci.patch new file mode 100644 index 0000000000000..620254c80a94b --- /dev/null +++ b/pci/pci-kzalloc-conversion-in-drivers-pci.patch @@ -0,0 +1,1020 @@ +From snakebyte@gmx.de Tue Feb 28 06:34:53 2006 +Subject: PCI: kzalloc() conversion in drivers/pci +From: Eric Sesterhenn <snakebyte@gmx.de> +Cc: gregkh@suse.de +Date: Tue, 28 Feb 2006 15:34:49 +0100 +Message-Id: <1141137289.17108.3.camel@alice> + +this patch converts drivers/pci to kzalloc usage. +Compile tested with allyes config. + +Signed-off-by: Eric Sesterhenn <snakebyte@gmx.de> +Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de> + +--- + drivers/pci/hotplug/acpiphp_glue.c | 14 ++----- + drivers/pci/hotplug/cpci_hotplug_core.c | 9 +--- + drivers/pci/hotplug/cpqphp_core.c | 13 ++---- + drivers/pci/hotplug/fakephp.c | 9 +--- + drivers/pci/hotplug/ibmphp_core.c | 6 +-- + drivers/pci/hotplug/ibmphp_ebda.c | 57 +++++++--------------------- + drivers/pci/hotplug/ibmphp_pci.c | 63 ++++++++++---------------------- + drivers/pci/hotplug/ibmphp_res.c | 33 +++++----------- + drivers/pci/hotplug/pciehp_core.c | 13 ++---- + drivers/pci/hotplug/rpaphp_slot.c | 9 +--- + drivers/pci/pci-driver.c | 3 - + drivers/pci/pci-sysfs.c | 3 - + drivers/pci/pcie/portdrv_core.c | 3 - + drivers/pci/probe.c | 9 +--- + 14 files changed, 75 insertions(+), 169 deletions(-) + +--- gregkh-2.6.orig/drivers/pci/hotplug/acpiphp_glue.c ++++ gregkh-2.6/drivers/pci/hotplug/acpiphp_glue.c +@@ -143,10 +143,9 @@ register_slot(acpi_handle handle, u32 lv + device = (adr >> 16) & 0xffff; + function = adr & 0xffff; + +- newfunc = kmalloc(sizeof(struct acpiphp_func), GFP_KERNEL); ++ newfunc = kzalloc(sizeof(struct acpiphp_func), GFP_KERNEL); + if (!newfunc) + return AE_NO_MEMORY; +- memset(newfunc, 0, sizeof(struct acpiphp_func)); + + INIT_LIST_HEAD(&newfunc->sibling); + newfunc->handle = handle; +@@ -189,13 +188,12 @@ register_slot(acpi_handle handle, u32 lv + } + + if (!slot) { +- slot = kmalloc(sizeof(struct acpiphp_slot), GFP_KERNEL); ++ slot = kzalloc(sizeof(struct acpiphp_slot), GFP_KERNEL); + if (!slot) { + kfree(newfunc); + return AE_NO_MEMORY; + } + +- memset(slot, 0, sizeof(struct acpiphp_slot)); + slot->bridge = bridge; + slot->device = device; + slot->sun = sun; +@@ -376,12 +374,10 @@ static void add_host_bridge(acpi_handle + { + struct acpiphp_bridge *bridge; + +- bridge = kmalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL); ++ bridge = kzalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL); + if (bridge == NULL) + return; + +- memset(bridge, 0, sizeof(struct acpiphp_bridge)); +- + bridge->type = BRIDGE_TYPE_HOST; + bridge->handle = handle; + +@@ -398,14 +394,12 @@ static void add_p2p_bridge(acpi_handle * + { + struct acpiphp_bridge *bridge; + +- bridge = kmalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL); ++ bridge = kzalloc(sizeof(struct acpiphp_bridge), GFP_KERNEL); + if (bridge == NULL) { + err("out of memory\n"); + return; + } + +- memset(bridge, 0, sizeof(struct acpiphp_bridge)); +- + bridge->type = BRIDGE_TYPE_P2P; + bridge->handle = handle; + +--- gregkh-2.6.orig/drivers/pci/hotplug/cpci_hotplug_core.c ++++ gregkh-2.6/drivers/pci/hotplug/cpci_hotplug_core.c +@@ -248,22 +248,19 @@ cpci_hp_register_bus(struct pci_bus *bus + * with the pci_hotplug subsystem. + */ + for (i = first; i <= last; ++i) { +- slot = kmalloc(sizeof (struct slot), GFP_KERNEL); ++ slot = kzalloc(sizeof (struct slot), GFP_KERNEL); + if (!slot) + goto error; +- memset(slot, 0, sizeof (struct slot)); + + hotplug_slot = +- kmalloc(sizeof (struct hotplug_slot), GFP_KERNEL); ++ kzalloc(sizeof (struct hotplug_slot), GFP_KERNEL); + if (!hotplug_slot) + goto error_slot; +- memset(hotplug_slot, 0, sizeof (struct hotplug_slot)); + slot->hotplug_slot = hotplug_slot; + +- info = kmalloc(sizeof (struct hotplug_slot_info), GFP_KERNEL); ++ info = kzalloc(sizeof (struct hotplug_slot_info), GFP_KERNEL); + if (!info) + goto error_hpslot; +- memset(info, 0, sizeof (struct hotplug_slot_info)); + hotplug_slot->info = info; + + name = kmalloc(SLOT_NAME_SIZE, GFP_KERNEL); +--- gregkh-2.6.orig/drivers/pci/hotplug/cpqphp_core.c ++++ gregkh-2.6/drivers/pci/hotplug/cpqphp_core.c +@@ -347,26 +347,22 @@ static int ctrl_slot_setup(struct contro + slot_number = ctrl->first_slot; + + while (number_of_slots) { +- slot = kmalloc(sizeof(*slot), GFP_KERNEL); ++ slot = kzalloc(sizeof(*slot), GFP_KERNEL); + if (!slot) + goto error; + +- memset(slot, 0, sizeof(struct slot)); +- slot->hotplug_slot = kmalloc(sizeof(*(slot->hotplug_slot)), ++ slot->hotplug_slot = kzalloc(sizeof(*(slot->hotplug_slot)), + GFP_KERNEL); + if (!slot->hotplug_slot) + goto error_slot; + hotplug_slot = slot->hotplug_slot; +- memset(hotplug_slot, 0, sizeof(struct hotplug_slot)); + + hotplug_slot->info = +- kmalloc(sizeof(*(hotplug_slot->info)), ++ kzalloc(sizeof(*(hotplug_slot->info)), + GFP_KERNEL); + if (!hotplug_slot->info) + goto error_hpslot; + hotplug_slot_info = hotplug_slot->info; +- memset(hotplug_slot_info, 0, +- sizeof(struct hotplug_slot_info)); + hotplug_slot->name = kmalloc(SLOT_NAME_SIZE, GFP_KERNEL); + + if (!hotplug_slot->name) +@@ -854,13 +850,12 @@ static int cpqhpc_probe(struct pci_dev * + goto err_disable_device; + } + +- ctrl = (struct controller *) kmalloc(sizeof(struct controller), GFP_KERNEL); ++ ctrl = kzalloc(sizeof(struct controller), GFP_KERNEL); + if (!ctrl) { + err("%s : out of memory\n", __FUNCTION__); + rc = -ENOMEM; + goto err_disable_device; + } +- memset(ctrl, 0, sizeof(struct controller)); + + rc = pci_read_config_word(pdev, PCI_SUBSYSTEM_ID, &subsystem_deviceid); + if (rc) { +--- gregkh-2.6.orig/drivers/pci/hotplug/fakephp.c ++++ gregkh-2.6/drivers/pci/hotplug/fakephp.c +@@ -95,15 +95,13 @@ static int add_slot(struct pci_dev *dev) + struct hotplug_slot *slot; + int retval = -ENOMEM; + +- slot = kmalloc(sizeof(struct hotplug_slot), GFP_KERNEL); ++ slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL); + if (!slot) + goto error; +- memset(slot, 0, sizeof(*slot)); + +- slot->info = kmalloc(sizeof(struct hotplug_slot_info), GFP_KERNEL); ++ slot->info = kzalloc(sizeof(struct hotplug_slot_info), GFP_KERNEL); + if (!slot->info) + goto error_slot; +- memset(slot->info, 0, sizeof(struct hotplug_slot_info)); + + slot->info->power_status = 1; + slot->info->max_bus_speed = PCI_SPEED_UNKNOWN; +@@ -227,11 +225,10 @@ static void pci_rescan_bus(const struct + { + unsigned int devfn; + struct pci_dev *dev; +- dev = kmalloc(sizeof(struct pci_dev), GFP_KERNEL); ++ dev = kzalloc(sizeof(struct pci_dev), GFP_KERNEL); + if (!dev) + return; + +- memset(dev, 0, sizeof(dev)); + dev->bus = (struct pci_bus*)bus; + dev->sysdata = bus->sysdata; + for (devfn = 0; devfn < 0x100; devfn += 8) { +--- gregkh-2.6.orig/drivers/pci/hotplug/ibmphp_core.c ++++ gregkh-2.6/drivers/pci/hotplug/ibmphp_core.c +@@ -1141,7 +1141,7 @@ static int enable_slot(struct hotplug_sl + goto error_power; + } + +- slot_cur->func = kmalloc(sizeof(struct pci_func), GFP_KERNEL); ++ slot_cur->func = kzalloc(sizeof(struct pci_func), GFP_KERNEL); + if (!slot_cur->func) { + /* We cannot do update_slot_info here, since no memory for + * kmalloc n.e.ways, and update_slot_info allocates some */ +@@ -1149,7 +1149,6 @@ static int enable_slot(struct hotplug_sl + rc = -ENOMEM; + goto error_power; + } +- memset(slot_cur->func, 0, sizeof(struct pci_func)); + slot_cur->func->busno = slot_cur->bus; + slot_cur->func->device = slot_cur->device; + for (i = 0; i < 4; i++) +@@ -1252,13 +1251,12 @@ int ibmphp_do_disable_slot(struct slot * + + if (slot_cur->func == NULL) { + /* We need this for fncs's that were there on bootup */ +- slot_cur->func = kmalloc(sizeof(struct pci_func), GFP_KERNEL); ++ slot_cur->func = kzalloc(sizeof(struct pci_func), GFP_KERNEL); + if (!slot_cur->func) { + err("out of system memory\n"); + rc = -ENOMEM; + goto error; + } +- memset(slot_cur->func, 0, sizeof(struct pci_func)); + slot_cur->func->busno = slot_cur->bus; + slot_cur->func->device = slot_cur->device; + } +--- gregkh-2.6.orig/drivers/pci/hotplug/ibmphp_ebda.c ++++ gregkh-2.6/drivers/pci/hotplug/ibmphp_ebda.c +@@ -72,13 +72,7 @@ static int ebda_rio_table (void); + + static struct ebda_hpc_list * __init alloc_ebda_hpc_list (void) + { +- struct ebda_hpc_list *list; +- +- list = kmalloc (sizeof (struct ebda_hpc_list), GFP_KERNEL); +- if (!list) +- return NULL; +- memset (list, 0, sizeof (*list)); +- return list; ++ return kzalloc(sizeof(struct ebda_hpc_list), GFP_KERNEL); + } + + static struct controller *alloc_ebda_hpc (u32 slot_count, u32 bus_count) +@@ -87,21 +81,18 @@ static struct controller *alloc_ebda_hpc + struct ebda_hpc_slot *slots; + struct ebda_hpc_bus *buses; + +- controller = kmalloc (sizeof (struct controller), GFP_KERNEL); ++ controller = kzalloc(sizeof(struct controller), GFP_KERNEL); + if (!controller) + goto error; +- memset (controller, 0, sizeof (*controller)); + +- slots = kmalloc (sizeof (struct ebda_hpc_slot) * slot_count, GFP_KERNEL); ++ slots = kcalloc(slot_count, sizeof(struct ebda_hpc_slot), GFP_KERNEL); + if (!slots) + goto error_contr; +- memset (slots, 0, sizeof (*slots) * slot_count); + controller->slots = slots; + +- buses = kmalloc (sizeof (struct ebda_hpc_bus) * bus_count, GFP_KERNEL); ++ buses = kcalloc(bus_count, sizeof(struct ebda_hpc_bus), GFP_KERNEL); + if (!buses) + goto error_slots; +- memset (buses, 0, sizeof (*buses) * bus_count); + controller->buses = buses; + + return controller; +@@ -122,24 +113,12 @@ static void free_ebda_hpc (struct contro + + static struct ebda_rsrc_list * __init alloc_ebda_rsrc_list (void) + { +- struct ebda_rsrc_list *list; +- +- list = kmalloc (sizeof (struct ebda_rsrc_list), GFP_KERNEL); +- if (!list) +- return NULL; +- memset (list, 0, sizeof (*list)); +- return list; ++ return kzalloc(sizeof(struct ebda_rsrc_list), GFP_KERNEL); + } + + static struct ebda_pci_rsrc *alloc_ebda_pci_rsrc (void) + { +- struct ebda_pci_rsrc *resource; +- +- resource = kmalloc (sizeof (struct ebda_pci_rsrc), GFP_KERNEL); +- if (!resource) +- return NULL; +- memset (resource, 0, sizeof (*resource)); +- return resource; ++ return kzalloc(sizeof(struct ebda_pci_rsrc), GFP_KERNEL); + } + + static void __init print_bus_info (void) +@@ -390,10 +369,9 @@ int __init ibmphp_access_ebda (void) + debug ("now enter io table ---\n"); + debug ("rio blk id: %x\n", blk_id); + +- rio_table_ptr = kmalloc (sizeof (struct rio_table_hdr), GFP_KERNEL); ++ rio_table_ptr = kzalloc(sizeof(struct rio_table_hdr), GFP_KERNEL); + if (!rio_table_ptr) + return -ENOMEM; +- memset (rio_table_ptr, 0, sizeof (struct rio_table_hdr) ); + rio_table_ptr->ver_num = readb (io_mem + offset); + rio_table_ptr->scal_count = readb (io_mem + offset + 1); + rio_table_ptr->riodev_count = readb (io_mem + offset + 2); +@@ -445,10 +423,9 @@ static int __init ebda_rio_table (void) + + // we do concern about rio details + for (i = 0; i < rio_table_ptr->riodev_count; i++) { +- rio_detail_ptr = kmalloc (sizeof (struct rio_detail), GFP_KERNEL); ++ rio_detail_ptr = kzalloc(sizeof(struct rio_detail), GFP_KERNEL); + if (!rio_detail_ptr) + return -ENOMEM; +- memset (rio_detail_ptr, 0, sizeof (struct rio_detail)); + rio_detail_ptr->rio_node_id = readb (io_mem + offset); + rio_detail_ptr->bbar = readl (io_mem + offset + 1); + rio_detail_ptr->rio_type = readb (io_mem + offset + 5); +@@ -503,10 +480,9 @@ static int __init combine_wpg_for_chassi + rio_detail_ptr = list_entry (list_head_ptr, struct rio_detail, rio_detail_list); + opt_rio_ptr = search_opt_vg (rio_detail_ptr->chassis_num); + if (!opt_rio_ptr) { +- opt_rio_ptr = (struct opt_rio *) kmalloc (sizeof (struct opt_rio), GFP_KERNEL); ++ opt_rio_ptr = kzalloc(sizeof(struct opt_rio), GFP_KERNEL); + if (!opt_rio_ptr) + return -ENOMEM; +- memset (opt_rio_ptr, 0, sizeof (struct opt_rio)); + opt_rio_ptr->rio_type = rio_detail_ptr->rio_type; + opt_rio_ptr->chassis_num = rio_detail_ptr->chassis_num; + opt_rio_ptr->first_slot_num = rio_detail_ptr->first_slot_num; +@@ -546,10 +522,9 @@ static int combine_wpg_for_expansion (vo + rio_detail_ptr = list_entry (list_head_ptr, struct rio_detail, rio_detail_list); + opt_rio_lo_ptr = search_opt_lo (rio_detail_ptr->chassis_num); + if (!opt_rio_lo_ptr) { +- opt_rio_lo_ptr = (struct opt_rio_lo *) kmalloc (sizeof (struct opt_rio_lo), GFP_KERNEL); ++ opt_rio_lo_ptr = kzalloc(sizeof(struct opt_rio_lo), GFP_KERNEL); + if (!opt_rio_lo_ptr) + return -ENOMEM; +- memset (opt_rio_lo_ptr, 0, sizeof (struct opt_rio_lo)); + opt_rio_lo_ptr->rio_type = rio_detail_ptr->rio_type; + opt_rio_lo_ptr->chassis_num = rio_detail_ptr->chassis_num; + opt_rio_lo_ptr->first_slot_num = rio_detail_ptr->first_slot_num; +@@ -842,12 +817,11 @@ static int __init ebda_rsrc_controller ( + + bus_info_ptr2 = ibmphp_find_same_bus_num (slot_ptr->slot_bus_num); + if (!bus_info_ptr2) { +- bus_info_ptr1 = (struct bus_info *) kmalloc (sizeof (struct bus_info), GFP_KERNEL); ++ bus_info_ptr1 = kzalloc(sizeof(struct bus_info), GFP_KERNEL); + if (!bus_info_ptr1) { + rc = -ENOMEM; + goto error_no_hp_slot; + } +- memset (bus_info_ptr1, 0, sizeof (struct bus_info)); + bus_info_ptr1->slot_min = slot_ptr->slot_num; + bus_info_ptr1->slot_max = slot_ptr->slot_num; + bus_info_ptr1->slot_count += 1; +@@ -946,19 +920,17 @@ static int __init ebda_rsrc_controller ( + // register slots with hpc core as well as create linked list of ibm slot + for (index = 0; index < hpc_ptr->slot_count; index++) { + +- hp_slot_ptr = kmalloc(sizeof(*hp_slot_ptr), GFP_KERNEL); ++ hp_slot_ptr = kzalloc(sizeof(*hp_slot_ptr), GFP_KERNEL); + if (!hp_slot_ptr) { + rc = -ENOMEM; + goto error_no_hp_slot; + } +- memset(hp_slot_ptr, 0, sizeof(*hp_slot_ptr)); + +- hp_slot_ptr->info = kmalloc (sizeof(struct hotplug_slot_info), GFP_KERNEL); ++ hp_slot_ptr->info = kzalloc(sizeof(struct hotplug_slot_info), GFP_KERNEL); + if (!hp_slot_ptr->info) { + rc = -ENOMEM; + goto error_no_hp_info; + } +- memset(hp_slot_ptr->info, 0, sizeof(struct hotplug_slot_info)); + + hp_slot_ptr->name = kmalloc(30, GFP_KERNEL); + if (!hp_slot_ptr->name) { +@@ -966,12 +938,11 @@ static int __init ebda_rsrc_controller ( + goto error_no_hp_name; + } + +- tmp_slot = kmalloc(sizeof(*tmp_slot), GFP_KERNEL); ++ tmp_slot = kzalloc(sizeof(*tmp_slot), GFP_KERNEL); + if (!tmp_slot) { + rc = -ENOMEM; + goto error_no_slot; + } +- memset(tmp_slot, 0, sizeof(*tmp_slot)); + + tmp_slot->flag = TRUE; + +--- gregkh-2.6.orig/drivers/pci/hotplug/ibmphp_pci.c ++++ gregkh-2.6/drivers/pci/hotplug/ibmphp_pci.c +@@ -164,12 +164,11 @@ int ibmphp_configure_card (struct pci_fu + cleanup_count = 6; + goto error; + } +- newfunc = kmalloc(sizeof(*newfunc), GFP_KERNEL); ++ newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL); + if (!newfunc) { + err ("out of system memory\n"); + return -ENOMEM; + } +- memset (newfunc, 0, sizeof (struct pci_func)); + newfunc->busno = cur_func->busno; + newfunc->device = device; + cur_func->next = newfunc; +@@ -203,12 +202,11 @@ int ibmphp_configure_card (struct pci_fu + flag = FALSE; + for (i = 0; i < 32; i++) { + if (func->devices[i]) { +- newfunc = kmalloc(sizeof(*newfunc), GFP_KERNEL); ++ newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL); + if (!newfunc) { + err ("out of system memory\n"); + return -ENOMEM; + } +- memset (newfunc, 0, sizeof (struct pci_func)); + newfunc->busno = sec_number; + newfunc->device = (u8) i; + for (j = 0; j < 4; j++) +@@ -232,12 +230,11 @@ int ibmphp_configure_card (struct pci_fu + } + } + +- newfunc = kmalloc(sizeof(*newfunc), GFP_KERNEL); ++ newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL); + if (!newfunc) { + err ("out of system memory\n"); + return -ENOMEM; + } +- memset (newfunc, 0, sizeof (struct pci_func)); + newfunc->busno = cur_func->busno; + newfunc->device = device; + for (j = 0; j < 4; j++) +@@ -279,12 +276,11 @@ int ibmphp_configure_card (struct pci_fu + for (i = 0; i < 32; i++) { + if (func->devices[i]) { + debug ("inside for loop, device is %x\n", i); +- newfunc = kmalloc(sizeof(*newfunc), GFP_KERNEL); ++ newfunc = kzalloc(sizeof(*newfunc), GFP_KERNEL); + if (!newfunc) { + err (" out of system memory\n"); + return -ENOMEM; + } +- memset (newfunc, 0, sizeof (struct pci_func)); + newfunc->busno = sec_number; + newfunc->device = (u8) i; + for (j = 0; j < 4; j++) +@@ -405,13 +401,12 @@ static int configure_device (struct pci_ + + debug ("len[count] in IO %x, count %d\n", len[count], count); + +- io[count] = kmalloc (sizeof (struct resource_node), GFP_KERNEL); ++ io[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL); + + if (!io[count]) { + err ("out of system memory\n"); + return -ENOMEM; + } +- memset (io[count], 0, sizeof (struct resource_node)); + io[count]->type = IO; + io[count]->busno = func->busno; + io[count]->devfunc = PCI_DEVFN(func->device, func->function); +@@ -444,12 +439,11 @@ static int configure_device (struct pci_ + + debug ("len[count] in PFMEM %x, count %d\n", len[count], count); + +- pfmem[count] = kmalloc (sizeof (struct resource_node), GFP_KERNEL); ++ pfmem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL); + if (!pfmem[count]) { + err ("out of system memory\n"); + return -ENOMEM; + } +- memset (pfmem[count], 0, sizeof (struct resource_node)); + pfmem[count]->type = PFMEM; + pfmem[count]->busno = func->busno; + pfmem[count]->devfunc = PCI_DEVFN(func->device, +@@ -460,13 +454,12 @@ static int configure_device (struct pci_ + ibmphp_add_resource (pfmem[count]); + func->pfmem[count] = pfmem[count]; + } else { +- mem_tmp = kmalloc(sizeof(*mem_tmp), GFP_KERNEL); ++ mem_tmp = kzalloc(sizeof(*mem_tmp), GFP_KERNEL); + if (!mem_tmp) { + err ("out of system memory\n"); + kfree (pfmem[count]); + return -ENOMEM; + } +- memset (mem_tmp, 0, sizeof (struct resource_node)); + mem_tmp->type = MEM; + mem_tmp->busno = pfmem[count]->busno; + mem_tmp->devfunc = pfmem[count]->devfunc; +@@ -512,12 +505,11 @@ static int configure_device (struct pci_ + + debug ("len[count] in Mem %x, count %d\n", len[count], count); + +- mem[count] = kmalloc (sizeof (struct resource_node), GFP_KERNEL); ++ mem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL); + if (!mem[count]) { + err ("out of system memory\n"); + return -ENOMEM; + } +- memset (mem[count], 0, sizeof (struct resource_node)); + mem[count]->type = MEM; + mem[count]->busno = func->busno; + mem[count]->devfunc = PCI_DEVFN(func->device, +@@ -677,14 +669,13 @@ static int configure_bridge (struct pci_ + + debug ("len[count] in IO = %x\n", len[count]); + +- bus_io[count] = kmalloc (sizeof (struct resource_node), GFP_KERNEL); ++ bus_io[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL); + + if (!bus_io[count]) { + err ("out of system memory\n"); + retval = -ENOMEM; + goto error; + } +- memset (bus_io[count], 0, sizeof (struct resource_node)); + bus_io[count]->type = IO; + bus_io[count]->busno = func->busno; + bus_io[count]->devfunc = PCI_DEVFN(func->device, +@@ -711,13 +702,12 @@ static int configure_bridge (struct pci_ + + debug ("len[count] in PFMEM = %x\n", len[count]); + +- bus_pfmem[count] = kmalloc (sizeof (struct resource_node), GFP_KERNEL); ++ bus_pfmem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL); + if (!bus_pfmem[count]) { + err ("out of system memory\n"); + retval = -ENOMEM; + goto error; + } +- memset (bus_pfmem[count], 0, sizeof (struct resource_node)); + bus_pfmem[count]->type = PFMEM; + bus_pfmem[count]->busno = func->busno; + bus_pfmem[count]->devfunc = PCI_DEVFN(func->device, +@@ -728,13 +718,12 @@ static int configure_bridge (struct pci_ + ibmphp_add_resource (bus_pfmem[count]); + func->pfmem[count] = bus_pfmem[count]; + } else { +- mem_tmp = kmalloc(sizeof(*mem_tmp), GFP_KERNEL); ++ mem_tmp = kzalloc(sizeof(*mem_tmp), GFP_KERNEL); + if (!mem_tmp) { + err ("out of system memory\n"); + retval = -ENOMEM; + goto error; + } +- memset (mem_tmp, 0, sizeof (struct resource_node)); + mem_tmp->type = MEM; + mem_tmp->busno = bus_pfmem[count]->busno; + mem_tmp->devfunc = bus_pfmem[count]->devfunc; +@@ -770,13 +759,12 @@ static int configure_bridge (struct pci_ + + debug ("len[count] in Memory is %x\n", len[count]); + +- bus_mem[count] = kmalloc (sizeof (struct resource_node), GFP_KERNEL); ++ bus_mem[count] = kzalloc(sizeof(struct resource_node), GFP_KERNEL); + if (!bus_mem[count]) { + err ("out of system memory\n"); + retval = -ENOMEM; + goto error; + } +- memset (bus_mem[count], 0, sizeof (struct resource_node)); + bus_mem[count]->type = MEM; + bus_mem[count]->busno = func->busno; + bus_mem[count]->devfunc = PCI_DEVFN(func->device, +@@ -841,14 +829,13 @@ static int configure_bridge (struct pci_ + flag_io = TRUE; + } else { + debug ("it wants %x IO behind the bridge\n", amount_needed->io); +- io = kmalloc(sizeof(*io), GFP_KERNEL); ++ io = kzalloc(sizeof(*io), GFP_KERNEL); + + if (!io) { + err ("out of system memory\n"); + retval = -ENOMEM; + goto error; + } +- memset (io, 0, sizeof (struct resource_node)); + io->type = IO; + io->busno = func->busno; + io->devfunc = PCI_DEVFN(func->device, func->function); +@@ -865,13 +852,12 @@ static int configure_bridge (struct pci_ + flag_mem = TRUE; + } else { + debug ("it wants %x memory behind the bridge\n", amount_needed->mem); +- mem = kmalloc(sizeof(*mem), GFP_KERNEL); ++ mem = kzalloc(sizeof(*mem), GFP_KERNEL); + if (!mem) { + err ("out of system memory\n"); + retval = -ENOMEM; + goto error; + } +- memset (mem, 0, sizeof (struct resource_node)); + mem->type = MEM; + mem->busno = func->busno; + mem->devfunc = PCI_DEVFN(func->device, func->function); +@@ -888,13 +874,12 @@ static int configure_bridge (struct pci_ + flag_pfmem = TRUE; + } else { + debug ("it wants %x pfmemory behind the bridge\n", amount_needed->pfmem); +- pfmem = kmalloc(sizeof(*pfmem), GFP_KERNEL); ++ pfmem = kzalloc(sizeof(*pfmem), GFP_KERNEL); + if (!pfmem) { + err ("out of system memory\n"); + retval = -ENOMEM; + goto error; + } +- memset (pfmem, 0, sizeof (struct resource_node)); + pfmem->type = PFMEM; + pfmem->busno = func->busno; + pfmem->devfunc = PCI_DEVFN(func->device, func->function); +@@ -904,13 +889,12 @@ static int configure_bridge (struct pci_ + ibmphp_add_resource (pfmem); + flag_pfmem = TRUE; + } else { +- mem_tmp = kmalloc(sizeof(*mem_tmp), GFP_KERNEL); ++ mem_tmp = kzalloc(sizeof(*mem_tmp), GFP_KERNEL); + if (!mem_tmp) { + err ("out of system memory\n"); + retval = -ENOMEM; + goto error; + } +- memset (mem_tmp, 0, sizeof (struct resource_node)); + mem_tmp->type = MEM; + mem_tmp->busno = pfmem->busno; + mem_tmp->devfunc = pfmem->devfunc; +@@ -936,13 +920,12 @@ static int configure_bridge (struct pci_ + */ + bus = ibmphp_find_res_bus (sec_number); + if (!bus) { +- bus = kmalloc(sizeof(*bus), GFP_KERNEL); ++ bus = kzalloc(sizeof(*bus), GFP_KERNEL); + if (!bus) { + err ("out of system memory\n"); + retval = -ENOMEM; + goto error; + } +- memset (bus, 0, sizeof (struct bus_node)); + bus->busno = sec_number; + debug ("b4 adding new bus\n"); + rc = add_new_bus (bus, io, mem, pfmem, func->busno); +@@ -1111,10 +1094,9 @@ static struct res_needed *scan_behind_br + }; + struct res_needed *amount; + +- amount = kmalloc(sizeof(*amount), GFP_KERNEL); ++ amount = kzalloc(sizeof(*amount), GFP_KERNEL); + if (amount == NULL) + return NULL; +- memset (amount, 0, sizeof (struct res_needed)); + + ibmphp_pci_bus->number = busno; + +@@ -1672,12 +1654,11 @@ static int add_new_bus (struct bus_node + list_add (&bus->bus_list, &cur_bus->bus_list); + } + if (io) { +- io_range = kmalloc(sizeof(*io_range), GFP_KERNEL); ++ io_range = kzalloc(sizeof(*io_range), GFP_KERNEL); + if (!io_range) { + err ("out of system memory\n"); + return -ENOMEM; + } +- memset (io_range, 0, sizeof (struct range_node)); + io_range->start = io->start; + io_range->end = io->end; + io_range->rangeno = 1; +@@ -1685,12 +1666,11 @@ static int add_new_bus (struct bus_node + bus->rangeIO = io_range; + } + if (mem) { +- mem_range = kmalloc(sizeof(*mem_range), GFP_KERNEL); ++ mem_range = kzalloc(sizeof(*mem_range), GFP_KERNEL); + if (!mem_range) { + err ("out of system memory\n"); + return -ENOMEM; + } +- memset (mem_range, 0, sizeof (struct range_node)); + mem_range->start = mem->start; + mem_range->end = mem->end; + mem_range->rangeno = 1; +@@ -1698,12 +1678,11 @@ static int add_new_bus (struct bus_node + bus->rangeMem = mem_range; + } + if (pfmem) { +- pfmem_range = kmalloc(sizeof(*pfmem_range), GFP_KERNEL); ++ pfmem_range = kzalloc(sizeof(*pfmem_range), GFP_KERNEL); + if (!pfmem_range) { + err ("out of system memory\n"); + return -ENOMEM; + } +- memset (pfmem_range, 0, sizeof (struct range_node)); + pfmem_range->start = pfmem->start; + pfmem_range->end = pfmem->end; + pfmem_range->rangeno = 1; +--- gregkh-2.6.orig/drivers/pci/hotplug/ibmphp_res.c ++++ gregkh-2.6/drivers/pci/hotplug/ibmphp_res.c +@@ -55,13 +55,12 @@ static struct bus_node * __init alloc_er + return NULL; + } + +- newbus = kmalloc (sizeof (struct bus_node), GFP_KERNEL); ++ newbus = kzalloc(sizeof(struct bus_node), GFP_KERNEL); + if (!newbus) { + err ("out of system memory\n"); + return NULL; + } + +- memset (newbus, 0, sizeof (struct bus_node)); + if (flag) + newbus->busno = busno; + else +@@ -79,12 +78,11 @@ static struct resource_node * __init all + return NULL; + } + +- rs = kmalloc (sizeof (struct resource_node), GFP_KERNEL); ++ rs = kzalloc(sizeof(struct resource_node), GFP_KERNEL); + if (!rs) { + err ("out of system memory\n"); + return NULL; + } +- memset (rs, 0, sizeof (struct resource_node)); + rs->busno = curr->bus_num; + rs->devfunc = curr->dev_fun; + rs->start = curr->start_addr; +@@ -100,12 +98,11 @@ static int __init alloc_bus_range (struc + u8 num_ranges = 0; + + if (first_bus) { +- newbus = kmalloc (sizeof (struct bus_node), GFP_KERNEL); ++ newbus = kzalloc(sizeof(struct bus_node), GFP_KERNEL); + if (!newbus) { + err ("out of system memory.\n"); + return -ENOMEM; + } +- memset (newbus, 0, sizeof (struct bus_node)); + newbus->busno = curr->bus_num; + } else { + newbus = *new_bus; +@@ -122,14 +119,13 @@ static int __init alloc_bus_range (struc + } + } + +- newrange = kmalloc (sizeof (struct range_node), GFP_KERNEL); ++ newrange = kzalloc(sizeof(struct range_node), GFP_KERNEL); + if (!newrange) { + if (first_bus) + kfree (newbus); + err ("out of system memory\n"); + return -ENOMEM; + } +- memset (newrange, 0, sizeof (struct range_node)); + newrange->start = curr->start_addr; + newrange->end = curr->end_addr; + +@@ -1705,12 +1701,11 @@ static int __init once_over (void) + + bus_cur->firstPFMemFromMem = pfmem_cur; + +- mem = kmalloc (sizeof (struct resource_node), GFP_KERNEL); ++ mem = kzalloc(sizeof(struct resource_node), GFP_KERNEL); + if (!mem) { + err ("out of system memory\n"); + return -ENOMEM; + } +- memset (mem, 0, sizeof (struct resource_node)); + mem->type = MEM; + mem->busno = pfmem_cur->busno; + mem->devfunc = pfmem_cur->devfunc; +@@ -1994,12 +1989,11 @@ static int __init update_bridge_ranges ( + end_address |= (upper_io_end << 16); + + if ((start_address) && (start_address <= end_address)) { +- range = kmalloc (sizeof (struct range_node), GFP_KERNEL); ++ range = kzalloc(sizeof(struct range_node), GFP_KERNEL); + if (!range) { + err ("out of system memory\n"); + return -ENOMEM; + } +- memset (range, 0, sizeof (struct range_node)); + range->start = start_address; + range->end = end_address + 0xfff; + +@@ -2020,13 +2014,12 @@ static int __init update_bridge_ranges ( + fix_resources (bus_sec); + + if (ibmphp_find_resource (bus_cur, start_address, &io, IO)) { +- io = kmalloc (sizeof (struct resource_node), GFP_KERNEL); ++ io = kzalloc(sizeof(struct resource_node), GFP_KERNEL); + if (!io) { + kfree (range); + err ("out of system memory\n"); + return -ENOMEM; + } +- memset (io, 0, sizeof (struct resource_node)); + io->type = IO; + io->busno = bus_cur->busno; + io->devfunc = ((device << 3) | (function & 0x7)); +@@ -2045,12 +2038,11 @@ static int __init update_bridge_ranges ( + + if ((start_address) && (start_address <= end_address)) { + +- range = kmalloc (sizeof (struct range_node), GFP_KERNEL); ++ range = kzalloc(sizeof(struct range_node), GFP_KERNEL); + if (!range) { + err ("out of system memory\n"); + return -ENOMEM; + } +- memset (range, 0, sizeof (struct range_node)); + range->start = start_address; + range->end = end_address + 0xfffff; + +@@ -2072,13 +2064,12 @@ static int __init update_bridge_ranges ( + fix_resources (bus_sec); + + if (ibmphp_find_resource (bus_cur, start_address, &mem, MEM)) { +- mem = kmalloc (sizeof (struct resource_node), GFP_KERNEL); ++ mem = kzalloc(sizeof(struct resource_node), GFP_KERNEL); + if (!mem) { + kfree (range); + err ("out of system memory\n"); + return -ENOMEM; + } +- memset (mem, 0, sizeof (struct resource_node)); + mem->type = MEM; + mem->busno = bus_cur->busno; + mem->devfunc = ((device << 3) | (function & 0x7)); +@@ -2101,12 +2092,11 @@ static int __init update_bridge_ranges ( + + if ((start_address) && (start_address <= end_address)) { + +- range = kmalloc (sizeof (struct range_node), GFP_KERNEL); ++ range = kzalloc(sizeof(struct range_node), GFP_KERNEL); + if (!range) { + err ("out of system memory\n"); + return -ENOMEM; + } +- memset (range, 0, sizeof (struct range_node)); + range->start = start_address; + range->end = end_address + 0xfffff; + +@@ -2127,13 +2117,12 @@ static int __init update_bridge_ranges ( + + fix_resources (bus_sec); + if (ibmphp_find_resource (bus_cur, start_address, &pfmem, PFMEM)) { +- pfmem = kmalloc (sizeof (struct resource_node), GFP_KERNEL); ++ pfmem = kzalloc(sizeof(struct resource_node), GFP_KERNEL); + if (!pfmem) { + kfree (range); + err ("out of system memory\n"); + return -ENOMEM; + } +- memset (pfmem, 0, sizeof (struct resource_node)); + pfmem->type = PFMEM; + pfmem->busno = bus_cur->busno; + pfmem->devfunc = ((device << 3) | (function & 0x7)); +--- gregkh-2.6.orig/drivers/pci/hotplug/pciehp_core.c ++++ gregkh-2.6/drivers/pci/hotplug/pciehp_core.c +@@ -117,27 +117,23 @@ static int init_slots(struct controller + slot_number = ctrl->first_slot; + + while (number_of_slots) { +- slot = kmalloc(sizeof(*slot), GFP_KERNEL); ++ slot = kzalloc(sizeof(*slot), GFP_KERNEL); + if (!slot) + goto error; + +- memset(slot, 0, sizeof(struct slot)); + slot->hotplug_slot = +- kmalloc(sizeof(*(slot->hotplug_slot)), ++ kzalloc(sizeof(*(slot->hotplug_slot)), + GFP_KERNEL); + if (!slot->hotplug_slot) + goto error_slot; + hotplug_slot = slot->hotplug_slot; +- memset(hotplug_slot, 0, sizeof(struct hotplug_slot)); + + hotplug_slot->info = +- kmalloc(sizeof(*(hotplug_slot->info)), ++ kzalloc(sizeof(*(hotplug_slot->info)), + GFP_KERNEL); + if (!hotplug_slot->info) + goto error_hpslot; + hotplug_slot_info = hotplug_slot->info; +- memset(hotplug_slot_info, 0, +- sizeof(struct hotplug_slot_info)); + hotplug_slot->name = kmalloc(SLOT_NAME_SIZE, GFP_KERNEL); + if (!hotplug_slot->name) + goto error_info; +@@ -373,12 +369,11 @@ static int pciehp_probe(struct pcie_devi + u8 value; + struct pci_dev *pdev; + +- ctrl = kmalloc(sizeof(*ctrl), GFP_KERNEL); ++ ctrl = kzalloc(sizeof(*ctrl), GFP_KERNEL); + if (!ctrl) { + err("%s : out of memory\n", __FUNCTION__); + goto err_out_none; + } +- memset(ctrl, 0, sizeof(struct controller)); + + pdev = dev->port; + ctrl->pci_dev = pdev; +--- gregkh-2.6.orig/drivers/pci/hotplug/rpaphp_slot.c ++++ gregkh-2.6/drivers/pci/hotplug/rpaphp_slot.c +@@ -84,19 +84,16 @@ struct slot *alloc_slot_struct(struct de + { + struct slot *slot; + +- slot = kmalloc(sizeof (struct slot), GFP_KERNEL); ++ slot = kzalloc(sizeof(struct slot), GFP_KERNEL); + if (!slot) + goto error_nomem; +- memset(slot, 0, sizeof (struct slot)); +- slot->hotplug_slot = kmalloc(sizeof (struct hotplug_slot), GFP_KERNEL); ++ slot->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL); + if (!slot->hotplug_slot) + goto error_slot; +- memset(slot->hotplug_slot, 0, sizeof (struct hotplug_slot)); +- slot->hotplug_slot->info = kmalloc(sizeof (struct hotplug_slot_info), ++ slot->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info), + GFP_KERNEL); + if (!slot->hotplug_slot->info) + goto error_hpslot; +- memset(slot->hotplug_slot->info, 0, sizeof (struct hotplug_slot_info)); + slot->hotplug_slot->name = kmalloc(BUS_ID_SIZE + 1, GFP_KERNEL); + if (!slot->hotplug_slot->name) + goto error_info; +--- gregkh-2.6.orig/drivers/pci/pci-driver.c ++++ gregkh-2.6/drivers/pci/pci-driver.c +@@ -53,11 +53,10 @@ store_new_id(struct device_driver *drive + if (fields < 0) + return -EINVAL; + +- dynid = kmalloc(sizeof(*dynid), GFP_KERNEL); ++ dynid = kzalloc(sizeof(*dynid), GFP_KERNEL); + if (!dynid) + return -ENOMEM; + +- memset(dynid, 0, sizeof(*dynid)); + INIT_LIST_HEAD(&dynid->node); + dynid->id.vendor = vendor; + dynid->id.device = device; +--- gregkh-2.6.orig/drivers/pci/pci-sysfs.c ++++ gregkh-2.6/drivers/pci/pci-sysfs.c +@@ -501,9 +501,8 @@ int pci_create_sysfs_dev_files (struct p + if (pci_resource_len(pdev, PCI_ROM_RESOURCE)) { + struct bin_attribute *rom_attr; + +- rom_attr = kmalloc(sizeof(*rom_attr), GFP_ATOMIC); ++ rom_attr = kzalloc(sizeof(*rom_attr), GFP_ATOMIC); + if (rom_attr) { +- memset(rom_attr, 0x00, sizeof(*rom_attr)); + pdev->rom_attr = rom_attr; + rom_attr->size = pci_resource_len(pdev, PCI_ROM_RESOURCE); + rom_attr->attr.name = "rom"; +--- gregkh-2.6.orig/drivers/pci/pcie/portdrv_core.c ++++ gregkh-2.6/drivers/pci/pcie/portdrv_core.c +@@ -248,11 +248,10 @@ static struct pcie_device* alloc_pcie_de + { + struct pcie_device *device; + +- device = kmalloc(sizeof(struct pcie_device), GFP_KERNEL); ++ device = kzalloc(sizeof(struct pcie_device), GFP_KERNEL); + if (!device) + return NULL; + +- memset(device, 0, sizeof(struct pcie_device)); + pcie_device_init(parent, device, port_type, service_type, irq,irq_mode); + printk(KERN_DEBUG "Allocate Port Service[%s]\n", device->device.bus_id); + return device; +--- gregkh-2.6.orig/drivers/pci/probe.c ++++ gregkh-2.6/drivers/pci/probe.c +@@ -33,10 +33,9 @@ LIST_HEAD(pci_devices); + */ + static void pci_create_legacy_files(struct pci_bus *b) + { +- b->legacy_io = kmalloc(sizeof(struct bin_attribute) * 2, ++ b->legacy_io = kzalloc(sizeof(struct bin_attribute) * 2, + GFP_ATOMIC); + if (b->legacy_io) { +- memset(b->legacy_io, 0, sizeof(struct bin_attribute) * 2); + b->legacy_io->attr.name = "legacy_io"; + b->legacy_io->size = 0xffff; + b->legacy_io->attr.mode = S_IRUSR | S_IWUSR; +@@ -320,9 +319,8 @@ static struct pci_bus * __devinit pci_al + { + struct pci_bus *b; + +- b = kmalloc(sizeof(*b), GFP_KERNEL); ++ b = kzalloc(sizeof(*b), GFP_KERNEL); + if (b) { +- memset(b, 0, sizeof(*b)); + INIT_LIST_HEAD(&b->node); + INIT_LIST_HEAD(&b->children); + INIT_LIST_HEAD(&b->devices); +@@ -797,11 +795,10 @@ pci_scan_device(struct pci_bus *bus, int + if (pci_bus_read_config_byte(bus, devfn, PCI_HEADER_TYPE, &hdr_type)) + return NULL; + +- dev = kmalloc(sizeof(struct pci_dev), GFP_KERNEL); ++ dev = kzalloc(sizeof(struct pci_dev), GFP_KERNEL); + if (!dev) + return NULL; + +- memset(dev, 0, sizeof(struct pci_dev)); + dev->bus = bus; + dev->sysdata = bus->sysdata; + dev->dev.parent = bus->bridge; |