lib/fdtdec: Fix compiling warning caused by changing fdt_addr_t type

[oweals/u-boot.git] / drivers / pci / pci-uclass.c

diff --git a/drivers/pci/pci-uclass.c b/drivers/pci/pci-uclass.c
index 3be76c99ee471646dc5307164c6817d69563f793..6262f352c999206cdf8681560e48b60a67718f6a 100644 (file)
--- a/drivers/pci/pci-uclass.c
+++ b/drivers/pci/pci-uclass.c
@@ -207,8 +207,7 @@ int pci_write_config(pci_dev_t bdf, int offset, unsigned long value,
        if (ret)
                return ret;
 
-       return pci_bus_write_config(bus, PCI_MASK_BUS(bdf), offset, value,
-                                   size);
+       return pci_bus_write_config(bus, bdf, offset, value, size);
 }
 
 int pci_write_config32(pci_dev_t bdf, int offset, u32 value)
@@ -247,8 +246,7 @@ int pci_read_config(pci_dev_t bdf, int offset, unsigned long *valuep,
        if (ret)
                return ret;
 
-       return pci_bus_read_config(bus, PCI_MASK_BUS(bdf), offset, valuep,
-                                  size);
+       return pci_bus_read_config(bus, bdf, offset, valuep, size);
 }
 
 int pci_read_config32(pci_dev_t bdf, int offset, u32 *valuep)
@@ -303,14 +301,10 @@ int pci_auto_config_devices(struct udevice *bus)
        for (ret = device_find_first_child(bus, &dev);
             !ret && dev;
             ret = device_find_next_child(&dev)) {
-               struct pci_controller *ctlr_hose;
                unsigned int max_bus;
 
                debug("%s: device %s\n", __func__, dev->name);
-
-               /* The root controller has the region information */
-               ctlr_hose = hose->ctlr->uclass_priv;
-               max_bus = pciauto_config_device(ctlr_hose, pci_get_bdf(dev));
+               max_bus = pciauto_config_device(hose, pci_get_bdf(dev));
                sub_bus = max(sub_bus, max_bus);
        }
        debug("%s: done\n", __func__);
@@ -328,7 +322,7 @@ int dm_pci_hose_probe_bus(struct pci_controller *hose, pci_dev_t bdf)
        parent = hose->bus;
 
        /* Find the bus within the parent */
-       ret = pci_bus_find_devfn(parent, bdf, &bus);
+       ret = pci_bus_find_devfn(parent, PCI_MASK_BUS(bdf), &bus);
        if (ret) {
                debug("%s: Cannot find device %x on bus %s: %d\n", __func__,
                      bdf, parent->name, ret);
@@ -383,7 +377,7 @@ static bool pci_match_one_id(const struct pci_device_id *id,
  * This only looks at certain fields in the descriptor.
  */
 static int pci_find_and_bind_driver(struct udevice *parent,
-                                   struct pci_device_id *find_id, int devfn,
+                                   struct pci_device_id *find_id, pci_dev_t bdf,
                                    struct udevice **devp)
 {
        struct pci_driver_entry *start, *entry;
@@ -430,8 +424,8 @@ static int pci_find_and_bind_driver(struct udevice *parent,
        }
 
        /* Bind a generic driver so that the device can be used */
-       sprintf(name, "pci_%x:%x.%x", parent->seq, PCI_DEV(devfn),
-               PCI_FUNC(devfn));
+       sprintf(name, "pci_%x:%x.%x", parent->seq, PCI_DEV(bdf),
+               PCI_FUNC(bdf));
        str = strdup(name);
        if (!str)
                return -ENOMEM;
@@ -455,42 +449,44 @@ int pci_bind_bus_devices(struct udevice *bus)
 {
        ulong vendor, device;
        ulong header_type;
-       pci_dev_t devfn, end;
+       pci_dev_t bdf, end;
        bool found_multi;
        int ret;
 
        found_multi = false;
-       end = PCI_DEVFN(PCI_MAX_PCI_DEVICES - 1, PCI_MAX_PCI_FUNCTIONS - 1);
-       for (devfn = PCI_DEVFN(0, 0); devfn < end; devfn += PCI_DEVFN(0, 1)) {
+       end = PCI_BDF(bus->seq, PCI_MAX_PCI_DEVICES - 1,
+                     PCI_MAX_PCI_FUNCTIONS - 1);
+       for (bdf = PCI_BDF(bus->seq, 0, 0); bdf < end;
+            bdf += PCI_BDF(0, 0, 1)) {
                struct pci_child_platdata *pplat;
                struct udevice *dev;
                ulong class;
 
-               if (PCI_FUNC(devfn) && !found_multi)
+               if (PCI_FUNC(bdf) && !found_multi)
                        continue;
                /* Check only the first access, we don't expect problems */
-               ret = pci_bus_read_config(bus, devfn, PCI_HEADER_TYPE,
+               ret = pci_bus_read_config(bus, bdf, PCI_HEADER_TYPE,
                                          &header_type, PCI_SIZE_8);
                if (ret)
                        goto error;
-               pci_bus_read_config(bus, devfn, PCI_VENDOR_ID, &vendor,
+               pci_bus_read_config(bus, bdf, PCI_VENDOR_ID, &vendor,
                                    PCI_SIZE_16);
                if (vendor == 0xffff || vendor == 0x0000)
                        continue;
 
-               if (!PCI_FUNC(devfn))
+               if (!PCI_FUNC(bdf))
                        found_multi = header_type & 0x80;
 
                debug("%s: bus %d/%s: found device %x, function %d\n", __func__,
-                     bus->seq, bus->name, PCI_DEV(devfn), PCI_FUNC(devfn));
-               pci_bus_read_config(bus, devfn, PCI_DEVICE_ID, &device,
+                     bus->seq, bus->name, PCI_DEV(bdf), PCI_FUNC(bdf));
+               pci_bus_read_config(bus, bdf, PCI_DEVICE_ID, &device,
                                    PCI_SIZE_16);
-               pci_bus_read_config(bus, devfn, PCI_CLASS_REVISION, &class,
+               pci_bus_read_config(bus, bdf, PCI_CLASS_REVISION, &class,
                                    PCI_SIZE_32);
                class >>= 8;
 
                /* Find this device in the device tree */
-               ret = pci_bus_find_devfn(bus, devfn, &dev);
+               ret = pci_bus_find_devfn(bus, PCI_MASK_BUS(bdf), &dev);
 
                /* Search for a driver */
 
@@ -504,13 +500,13 @@ int pci_bind_bus_devices(struct udevice *bus)
                        find_id.device = device;
                        find_id.class = class;
                        if ((header_type & 0x7f) == PCI_HEADER_TYPE_NORMAL) {
-                               pci_bus_read_config(bus, devfn,
+                               pci_bus_read_config(bus, bdf,
                                                    PCI_SUBSYSTEM_VENDOR_ID,
                                                    &val, PCI_SIZE_32);
                                find_id.subvendor = val & 0xffff;
                                find_id.subdevice = val >> 16;
                        }
-                       ret = pci_find_and_bind_driver(bus, &find_id, devfn,
+                       ret = pci_find_and_bind_driver(bus, &find_id, bdf,
                                                       &dev);
                }
                if (ret)
@@ -518,7 +514,7 @@ int pci_bind_bus_devices(struct udevice *bus)
 
                /* Update the platform data */
                pplat = dev_get_parent_platdata(dev);
-               pplat->devfn = devfn;
+               pplat->devfn = PCI_MASK_BUS(bdf);
                pplat->vendor = vendor;
                pplat->device = device;
                pplat->class = class;
@@ -645,10 +641,6 @@ static int pci_uclass_post_probe(struct udevice *bus)
 {
        int ret;
 
-       /* Don't scan buses before relocation */
-       if (!(gd->flags & GD_FLG_RELOC))
-               return 0;
-
        debug("%s: probing bus %d\n", __func__, bus->seq);
        ret = pci_bind_bus_devices(bus);
        if (ret)
@@ -689,20 +681,20 @@ static int pci_uclass_child_post_bind(struct udevice *dev)
        return 0;
 }
 
-int pci_bridge_read_config(struct udevice *bus, pci_dev_t devfn, uint offset,
-                          ulong *valuep, enum pci_size_t size)
+static int pci_bridge_read_config(struct udevice *bus, pci_dev_t bdf,
+                                 uint offset, ulong *valuep,
+                                 enum pci_size_t size)
 {
        struct pci_controller *hose = bus->uclass_priv;
-       pci_dev_t bdf = PCI_ADD_BUS(bus->seq, devfn);
 
        return pci_bus_read_config(hose->ctlr, bdf, offset, valuep, size);
 }
 
-int pci_bridge_write_config(struct udevice *bus, pci_dev_t devfn, uint offset,
-                           ulong value, enum pci_size_t size)
+static int pci_bridge_write_config(struct udevice *bus, pci_dev_t bdf,
+                                  uint offset, ulong value,
+                                  enum pci_size_t size)
 {
        struct pci_controller *hose = bus->uclass_priv;
-       pci_dev_t bdf = PCI_ADD_BUS(bus->seq, devfn);
 
        return pci_bus_write_config(hose->ctlr, bdf, offset, value, size);
 }