[PATCH] use device_for_each_child() to properly access child devices.

On Friday, March 25, 2005 8:47 PM Greg KH wrote:
>Here's a fix for pci express.  For some reason I don't think they are
>using the driver model properly here, but I could be wrong...

Thanks for making the changes. However, changes in functions:
void pcie_port_device_remove(struct pci_dev *dev) and
static int remove_iter(struct device *dev, void *data)
are not correct. Please use the patch, which is based on kernel
2.6.12-rc1, below for a fix for these.

Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

diff --git a/drivers/pci/pcie/portdrv_core.c b/drivers/pci/pcie/portdrv_core.c
index 576285765e98cab75dab2fcc2d0ffbc1d9ff7897..f5c5f10a3d2f8da02de92b45f18eba599014e244 100644 (file)
--- a/drivers/pci/pcie/portdrv_core.c
+++ b/drivers/pci/pcie/portdrv_core.c
@@ -232,19 +232,16 @@ static void pcie_device_init(struct pci_dev *parent, struct pcie_device *dev,
        /* Initialize generic device interface */
        device = &dev->device;
        memset(device, 0, sizeof(struct device));
-       INIT_LIST_HEAD(&device->node);
-       INIT_LIST_HEAD(&device->children);
-       INIT_LIST_HEAD(&device->bus_list);
        device->bus = &pcie_port_bus_type;
        device->driver = NULL;
-       device->driver_data = NULL; 
+       device->driver_data = NULL;
        device->release = release_pcie_device;  /* callback to free pcie dev */
-       sprintf(&device->bus_id[0], "pcie%02x", 
+       sprintf(&device->bus_id[0], "pcie%02x",
                get_descriptor_id(port_type, service_type));
        device->parent = &parent->dev;
 }
 
-static struct pcie_device* alloc_pcie_device(struct pci_dev *parent, 
+static struct pcie_device* alloc_pcie_device(struct pci_dev *parent,
        int port_type, int service_type, int irq, int irq_mode)
 {
        struct pcie_device *device;
@@ -270,9 +267,9 @@ int pcie_port_device_probe(struct pci_dev *dev)
        pci_read_config_word(dev, pos + PCIE_CAPABILITIES_REG, &reg);
        type = (reg >> 4) & PORT_TYPE_MASK;
        if (    type == PCIE_RC_PORT || type == PCIE_SW_UPSTREAM_PORT ||
-               type == PCIE_SW_DOWNSTREAM_PORT )  
+               type == PCIE_SW_DOWNSTREAM_PORT )
                return 0;
- 
+
        return -ENODEV;
 }
 
@@ -283,8 +280,8 @@ int pcie_port_device_register(struct pci_dev *dev)
        u16 reg16;
 
        /* Get port type */
-       pci_read_config_word(dev, 
-               pci_find_capability(dev, PCI_CAP_ID_EXP) + 
+       pci_read_config_word(dev,
+               pci_find_capability(dev, PCI_CAP_ID_EXP) +
                PCIE_CAPABILITIES_REG, &reg16);
        type = (reg16 >> 4) & PORT_TYPE_MASK;
 
@@ -299,11 +296,11 @@ int pcie_port_device_register(struct pci_dev *dev)
                if (capabilities & (1 << i)) {
                        child = alloc_pcie_device(
                                dev,            /* parent */
-                               type,           /* port type */ 
+                               type,           /* port type */
                                i,              /* service type */
                                vectors[i],     /* irq */
                                irq_mode        /* interrupt mode */);
-                       if (child) { 
+                       if (child) {
                                status = device_register(&child->device);
                                if (status) {
                                        kfree(child);
@@ -317,84 +314,78 @@ int pcie_port_device_register(struct pci_dev *dev)
 }
 
 #ifdef CONFIG_PM
-int pcie_port_device_suspend(struct pci_dev *dev, pm_message_t state)
+static int suspend_iter(struct device *dev, void *data)
 {
-       struct list_head                *head, *tmp;
-       struct device                   *parent, *child;
-       struct device_driver            *driver;
        struct pcie_port_service_driver *service_driver;
+       u32 state = (u32)data;
+
+       if ((dev->bus == &pcie_port_bus_type) &&
+           (dev->driver)) {
+               service_driver = to_service_driver(dev->driver);
+               if (service_driver->suspend)
+                       service_driver->suspend(to_pcie_device(dev), state);
+       }
+       return 0;
+}
 
-       parent = &dev->dev;
-       head = &parent->children;
-       tmp = head->next;
-       while (head != tmp) {
-               child = container_of(tmp, struct device, node);
-               tmp = tmp->next;
-               if (child->bus != &pcie_port_bus_type)
-                       continue;
-               driver = child->driver;
-               if (!driver)
-                       continue;
-               service_driver = to_service_driver(driver);
-               if (service_driver->suspend)  
-                       service_driver->suspend(to_pcie_device(child), state);
-       }
-       return 0; 
+int pcie_port_device_suspend(struct pci_dev *dev, u32 state)
+{
+       device_for_each_child(&dev->dev, (void *)state, suspend_iter);
+       return 0;
 }
 
-int pcie_port_device_resume(struct pci_dev *dev) 
-{ 
-       struct list_head                *head, *tmp;
-       struct device                   *parent, *child;
-       struct device_driver            *driver;
+static int resume_iter(struct device *dev, void *data)
+{
        struct pcie_port_service_driver *service_driver;
 
-       parent = &dev->dev;
-       head = &parent->children;
-       tmp = head->next;
-       while (head != tmp) {
-               child = container_of(tmp, struct device, node);
-               tmp = tmp->next;
-               if (child->bus != &pcie_port_bus_type)
-                       continue;
-               driver = child->driver;
-               if (!driver)
-                       continue;
-               service_driver = to_service_driver(driver);
-               if (service_driver->resume)  
-                       service_driver->resume(to_pcie_device(child));
+       if ((dev->bus == &pcie_port_bus_type) &&
+           (dev->driver)) {
+               service_driver = to_service_driver(dev->driver);
+               if (service_driver->resume)
+                       service_driver->resume(to_pcie_device(dev));
        }
-       return 0; 
+       return 0;
+}
 
+int pcie_port_device_resume(struct pci_dev *dev)
+{
+       device_for_each_child(&dev->dev, NULL, resume_iter);
+       return 0;
 }
 #endif
 
-void pcie_port_device_remove(struct pci_dev *dev)
+static int remove_iter(struct device *dev, void *data)
 {
-       struct list_head                *head, *tmp;
-       struct device                   *parent, *child;
-       struct device_driver            *driver;
        struct pcie_port_service_driver *service_driver;
-       int interrupt_mode = PCIE_PORT_INTx_MODE;
 
-       parent = &dev->dev;
-       head = &parent->children;
-       tmp = head->next;
-       while (head != tmp) {
-               child = container_of(tmp, struct device, node);
-               tmp = tmp->next;
-               if (child->bus != &pcie_port_bus_type)
-                       continue;
-               driver = child->driver;
-               if (driver) { 
-                       service_driver = to_service_driver(driver);
-                       if (service_driver->remove)  
-                               service_driver->remove(to_pcie_device(child));
+       if (dev->bus == &pcie_port_bus_type) {
+               if (dev->driver) {
+                       service_driver = to_service_driver(dev->driver);
+                       if (service_driver->remove)
+                               service_driver->remove(to_pcie_device(dev));
                }
-               interrupt_mode = (to_pcie_device(child))->interrupt_mode;
-               put_device(child);
-               device_unregister(child);
+               *(unsigned long*)data = (unsigned long)dev;
+               return 1;
        }
+       return 0;
+}
+
+void pcie_port_device_remove(struct pci_dev *dev)
+{
+       struct device *device;
+       unsigned long device_addr;
+       int interrupt_mode = PCIE_PORT_INTx_MODE;
+       int status;
+
+       do {
+               status = device_for_each_child(&dev->dev, &device_addr, remove_iter);
+               if (status) {
+                       device = (struct device*)device_addr;
+                       interrupt_mode = (to_pcie_device(device))->interrupt_mode;
+                       put_device(device);
+                       device_unregister(device);
+               }
+       } while (status);
        /* Switch to INTx by default if MSI enabled */
        if (interrupt_mode == PCIE_PORT_MSIX_MODE)
                pci_disable_msix(dev);
@@ -423,7 +414,7 @@ int pcie_port_service_register(struct pcie_port_service_driver *new)
        new->driver.resume = pcie_port_resume_service;
 
        return driver_register(&new->driver);
-} 
+}
 
 void pcie_port_service_unregister(struct pcie_port_service_driver *new)
 {