x86: minnowmax: Move USB and Ethernet to driver model

These should finish with a newline like the others.

Signed-off-by Simon Glass <[email protected]>

---

 drivers/core/device.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

Add a hyphen to correct the grammar.

Signed-off-by Simon Glass <[email protected]>

Quoted 3 lines · Simon Glass

Add a hyphen to correct the grammar.

Signed-off-by Simon Glass <[email protected]>

Acked by: Marek Vasut <[email protected]>

Best regards,
Marek Vasut

A few drivers still write out the license in full. Fix these.

Signed-off-by Simon Glass <[email protected]>

Quoted 3 lines · Simon Glass

A few drivers still write out the license in full. Fix these.

Signed-off-by Simon Glass <[email protected]>

Thanks!

Acked-by Marek Vasut <[email protected]>

Best regards,
Marek Vasut

When trying to figure out where an exception has occured, the relocated address is not a lot of help. Its value depends on various factors. Show the un-relocated IP as well. This can be looked up in System.map directly.

Signed-off-by Simon Glass <[email protected]>

---

At present all PCI devices must be present in the device tree in order to be used. Many or most PCI devices don't require any configuration other than that which is done automatically by U-Boot. It is inefficent to add a node with nothing but a compatible string in order to get a device working.

Add a mechanism whereby PCI drivers can be declared along with the device parameters they support (vendor/device/class). When no suitable driver is found in the device tree the list of such devices is consulted to determine the correct driver. If this also fails, then a generic driver is used as before.

The mechanism used is very similar to that provided by Linux and the header file defintions are copied from Linux 4.1.

Signed-off-by Simon Glass <[email protected]>

---

At present all PCI devices must be present in the device tree in order to be used. Many or most PCI devices don't require any configuration other than that which is done automatically by U-Boot. It is inefficent to add a node with nothing but a compatible string in order to get a device working.

Add a mechanism whereby PCI drivers can be declared along with the device parameters they support (vendor/device/class). When no suitable driver is found in the device tree the list of such devices is consulted to determine the correct driver. If this also fails, then a generic driver is used as before.

The mechanism used is very similar to that provided by Linux and the header file defintions are copied from Linux 4.1.

Signed-off-by Simon Glass <[email protected]>

---

 drivers/pci/pci-uclass.c | 129 ++++++++++++++++++++++++++++++++++++++++++-----
 include/pci.h            |  79 ++++++++++++++++++++++++++++-
 2 files changed, 193 insertions(+), 15 deletions(-)

drivers/pci/pci-uclass.c +116 -13

index 5b91fe3..41daa0d 100644
@@ -353,6 +353,101 @@ int dm_pci_hose_probe_bus(struct pci_controller *hose, pci_dev_t bdf)
        return sub_bus;
 }
 
+/**
+ * pci_match_one_device - Tell if a PCI device structure has a matching
+ *                        PCI device id structure
+ * @id: single PCI device id structure to match
+ * @dev: the PCI device structure to match against
+ *
+ * Returns the matching pci_device_id structure or %NULL if there is no match.
+ */
+static bool pci_match_one_id(const struct pci_device_id *id,
+                            const struct pci_device_id *find)
+{
+       if ((id->vendor == PCI_ANY_ID || id->vendor == find->vendor) &&
+           (id->device == PCI_ANY_ID || id->device == find->device) &&
+           (id->subvendor == PCI_ANY_ID || id->subvendor == find->subvendor) &&
+           (id->subdevice == PCI_ANY_ID || id->subdevice == find->subdevice) &&
+           !((id->class ^ find->class) & id->class_mask))
+               return true;
+
+       return false;
+}
+
+/**
+ * pci_find_and_bind_driver() - Find and bind the right PCI driver
+ *
+ * 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 udevice **devp)
+{
+       struct pci_driver_entry *start, *entry;
+       const char *drv;
+       int n_ents;
+       int ret;
+       char name[30], *str;
+
+       *devp = NULL;
+
+       debug("%s: Searching for driver: vendor=%x, device=%x\n", __func__,
+             find_id->vendor, find_id->device);
+       start = ll_entry_start(struct pci_driver_entry, pci_driver_entry);
+       n_ents = ll_entry_count(struct pci_driver_entry, pci_driver_entry);
+       for (entry = start; entry != start + n_ents; entry++) {
+               const struct pci_device_id *id;
+               struct udevice *dev;
+               const struct driver *drv;
+
+               for (id = entry->match;
+                    id->vendor || id->subvendor || id->class_mask;
+                    id++) {
+                       if (!pci_match_one_id(id, find_id))
+                               continue;
+
+                       drv = entry->driver;
+                       /*
+                        * We could pass the descriptor to the driver as
+                        * platdata (instead of NULL) and allow its bind()
+                        * method to return -ENOENT if it doesn't support this
+                        * device. That way we could continue the search to
+                        * find another driver. For now this doesn't seem
+                        * necesssary, so just bind the first match.
+                        */
+                       ret = device_bind(parent, drv, drv->name, NULL, -1,
+                                         &dev);
+                       if (ret)
+                               goto error;
+                       debug("%s: Match found: %s\n", __func__, drv->name);
+                       dev->driver_data = find_id->driver_data;
+                       *devp = dev;
+                       return 0;
+               }
+       }
+
+       /* 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));
+       str = strdup(name);
+       if (!str)
+               return -ENOMEM;
+       drv = (find_id->class >> 8) == PCI_CLASS_BRIDGE_PCI ? "pci_bridge_drv" :
+                       "pci_generic_drv";
+       ret = device_bind_driver(parent, drv, str, devp);
+       if (ret) {
+               debug("%s: Failed to bind generic driver: %d", __func__, ret);
+               return ret;
+       }
+       debug("%s: No match found: bound generic driver instead\n", __func__);
+
+       return 0;
+
+error:
+       debug("%s: No match found: error %d\n", __func__, ret);
+       return ret;
+}
+
 int pci_bind_bus_devices(struct udevice *bus)
 {
        ulong vendor, device;

@@ -387,25 +482,33 @@ int pci_bind_bus_devices(struct udevice *bus)
                      bus->seq, bus->name, PCI_DEV(devfn), PCI_FUNC(devfn));
                pci_bus_read_config(bus, devfn, PCI_DEVICE_ID, &device,
                                    PCI_SIZE_16);
-               pci_bus_read_config(bus, devfn, PCI_CLASS_DEVICE, &class,
-                                   PCI_SIZE_16);
+               pci_bus_read_config(bus, devfn, PCI_CLASS_REVISION, &class,
+                                   PCI_SIZE_32);
+               class >>= 8;
 
                /* Find this device in the device tree */
                ret = pci_bus_find_devfn(bus, devfn, &dev);
 
+               /* Search for a driver */
+
                /* If nothing in the device tree, bind a generic device */
                if (ret == -ENODEV) {
-                       char name[30], *str;
-                       const char *drv;
-
-                       sprintf(name, "pci_%x:%x.%x", bus->seq,
-                               PCI_DEV(devfn), PCI_FUNC(devfn));
-                       str = strdup(name);
-                       if (!str)
-                               return -ENOMEM;
-                       drv = class == PCI_CLASS_BRIDGE_PCI ?
-                               "pci_bridge_drv" : "pci_generic_drv";
-                       ret = device_bind_driver(bus, drv, str, &dev);
+                       struct pci_device_id find_id;
+                       ulong val;
+
+                       memset(&find_id, '\0', sizeof(find_id));
+                       find_id.vendor = vendor;
+                       find_id.device = device;
+                       find_id.class = class;
+                       if ((header_type & 0x7f) == PCI_HEADER_TYPE_NORMAL) {
+                               pci_bus_read_config(bus, devfn,
+                                                   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,
+                                                      &dev);
                }
                if (ret)
                        return ret;

include/pci.h +0 -0

index 3af511b..d21fa8b 100644

include/pci.h +67 -1

 struct pci_controller;

@@ -1110,7 +1113,79 @@ struct dm_pci_emul_ops {
 int sandbox_pci_get_emul(struct udevice *bus, pci_dev_t find_devfn,
                         struct udevice **emulp);
 
-#endif
+/**
+ * PCI_DEVICE - macro used to describe a specific pci device
+ * @vend: the 16 bit PCI Vendor ID
+ * @dev: the 16 bit PCI Device ID
+ *
+ * This macro is used to create a struct pci_device_id that matches a
+ * specific device.  The subvendor and subdevice fields will be set to
+ * PCI_ANY_ID.
+ */
+#define PCI_DEVICE(vend, dev) \
+       .vendor = (vend), .device = (dev), \
+       .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
+
+/**
+ * PCI_DEVICE_SUB - macro used to describe a specific pci device with subsystem
+ * @vend: the 16 bit PCI Vendor ID
+ * @dev: the 16 bit PCI Device ID
+ * @subvend: the 16 bit PCI Subvendor ID
+ * @subdev: the 16 bit PCI Subdevice ID
+ *
+ * This macro is used to create a struct pci_device_id that matches a
+ * specific device with subsystem information.
+ */
+#define PCI_DEVICE_SUB(vend, dev, subvend, subdev) \
+       .vendor = (vend), .device = (dev), \
+       .subvendor = (subvend), .subdevice = (subdev)
+
+/**
+ * PCI_DEVICE_CLASS - macro used to describe a specific pci device class
+ * @dev_class: the class, subclass, prog-if triple for this device
+ * @dev_class_mask: the class mask for this device
+ *
+ * This macro is used to create a struct pci_device_id that matches a
+ * specific PCI class.  The vendor, device, subvendor, and subdevice
+ * fields will be set to PCI_ANY_ID.
+ */
+#define PCI_DEVICE_CLASS(dev_class, dev_class_mask) \
+       .class = (dev_class), .class_mask = (dev_class_mask), \
+       .vendor = PCI_ANY_ID, .device = PCI_ANY_ID, \
+       .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
+
+/**
+ * PCI_VDEVICE - macro used to describe a specific pci device in short form
+ * @vend: the vendor name
+ * @dev: the 16 bit PCI Device ID
+ *
+ * This macro is used to create a struct pci_device_id that matches a
+ * specific PCI device.  The subvendor, and subdevice fields will be set
+ * to PCI_ANY_ID. The macro allows the next field to follow as the device
+ * private data.
+ */
+
+#define PCI_VDEVICE(vend, dev) \
+       .vendor = PCI_VENDOR_ID_##vend, .device = (dev), \
+       .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID, 0, 0
+
+/**
+ * struct pci_driver_entry - Matches a driver to its pci_device_id list
+ * @driver: Driver to use
+ * @match: List of match records for this driver, terminated by {}
+ */
+struct pci_driver_entry {
+       struct driver *driver;
+       const struct pci_device_id *match;
+};
+
+#define U_BOOT_PCI_DEVICE(__name, __match)                             \

Hi Simon,

Quoted 179 lines · Simon Glass

At present all PCI devices must be present in the device tree in order to be used. Many or most PCI devices don't require any configuration other than that which is done automatically by U-Boot. It is inefficent to add a node with nothing but a compatible string in order to get a device working.

Add a mechanism whereby PCI drivers can be declared along with the device parameters they support (vendor/device/class). When no suitable driver is found in the device tree the list of such devices is consulted to determine the correct driver. If this also fails, then a generic driver is used as before.

The mechanism used is very similar to that provided by Linux and the header file defintions are copied from Linux 4.1.

Signed-off-by Simon Glass <[email protected]>

---

 drivers/pci/pci-uclass.c | 129 ++++++++++++++++++++++++++++++++++++++++++-----
 include/pci.h            |  79 ++++++++++++++++++++++++++++-
 2 files changed, 193 insertions(+), 15 deletions(-)

drivers/pci/pci-uclass.c +116 -13

index 5b91fe3..41daa0d 100644
@@ -353,6 +353,101 @@ int dm_pci_hose_probe_bus(struct pci_controller *hose, pci_dev_t bdf)
        return sub_bus;
 }
 
+/**
+ * pci_match_one_device - Tell if a PCI device structure has a matching
+ *                        PCI device id structure
+ * @id: single PCI device id structure to match
+ * @dev: the PCI device structure to match against
+ *
+ * Returns the matching pci_device_id structure or %NULL if there is no match.
+ */
+static bool pci_match_one_id(const struct pci_device_id *id,
+                            const struct pci_device_id *find)
+{
+       if ((id->vendor == PCI_ANY_ID || id->vendor == find->vendor) &&
+           (id->device == PCI_ANY_ID || id->device == find->device) &&
+           (id->subvendor == PCI_ANY_ID || id->subvendor == find->subvendor) &&
+           (id->subdevice == PCI_ANY_ID || id->subdevice == find->subdevice) &&
+           !((id->class ^ find->class) & id->class_mask))
+               return true;
+
+       return false;
+}
+
+/**
+ * pci_find_and_bind_driver() - Find and bind the right PCI driver
+ *
+ * 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 udevice **devp)
+{
+       struct pci_driver_entry *start, *entry;
+       const char *drv;
+       int n_ents;
+       int ret;
+       char name[30], *str;
+
+       *devp = NULL;
+
+       debug("%s: Searching for driver: vendor=%x, device=%x\n", __func__,
+             find_id->vendor, find_id->device);
+       start = ll_entry_start(struct pci_driver_entry, pci_driver_entry);
+       n_ents = ll_entry_count(struct pci_driver_entry, pci_driver_entry);
+       for (entry = start; entry != start + n_ents; entry++) {
+               const struct pci_device_id *id;
+               struct udevice *dev;
+               const struct driver *drv;
+
+               for (id = entry->match;
+                    id->vendor || id->subvendor || id->class_mask;
+                    id++) {
+                       if (!pci_match_one_id(id, find_id))
+                               continue;
+
+                       drv = entry->driver;
+                       /*
+                        * We could pass the descriptor to the driver as
+                        * platdata (instead of NULL) and allow its bind()
+                        * method to return -ENOENT if it doesn't support this
+                        * device. That way we could continue the search to
+                        * find another driver. For now this doesn't seem
+                        * necesssary, so just bind the first match.
+                        */
+                       ret = device_bind(parent, drv, drv->name, NULL, -1,
+                                         &dev);
+                       if (ret)
+                               goto error;
+                       debug("%s: Match found: %s\n", __func__, drv->name);
+                       dev->driver_data = find_id->driver_data;
+                       *devp = dev;
+                       return 0;
+               }
+       }
+
+       /* 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));
+       str = strdup(name);
+       if (!str)
+               return -ENOMEM;
+       drv = (find_id->class >> 8) == PCI_CLASS_BRIDGE_PCI ? "pci_bridge_drv" :
+                       "pci_generic_drv";
+       ret = device_bind_driver(parent, drv, str, devp);
+       if (ret) {
+               debug("%s: Failed to bind generic driver: %d", __func__, ret);
+               return ret;
+       }
+       debug("%s: No match found: bound generic driver instead\n", __func__);
+
+       return 0;
+
+error:
+       debug("%s: No match found: error %d\n", __func__, ret);
+       return ret;
+}
+
 int pci_bind_bus_devices(struct udevice *bus)
 {
        ulong vendor, device;

@@ -387,25 +482,33 @@ int pci_bind_bus_devices(struct udevice *bus)
                      bus->seq, bus->name, PCI_DEV(devfn), PCI_FUNC(devfn));
                pci_bus_read_config(bus, devfn, PCI_DEVICE_ID, &device,
                                    PCI_SIZE_16);
-               pci_bus_read_config(bus, devfn, PCI_CLASS_DEVICE, &class,
-                                   PCI_SIZE_16);
+               pci_bus_read_config(bus, devfn, PCI_CLASS_REVISION, &class,
+                                   PCI_SIZE_32);
+               class >>= 8;
 
                /* Find this device in the device tree */
                ret = pci_bus_find_devfn(bus, devfn, &dev);
 
+               /* Search for a driver */
+
                /* If nothing in the device tree, bind a generic device */
                if (ret == -ENODEV) {
-                       char name[30], *str;
-                       const char *drv;
-
-                       sprintf(name, "pci_%x:%x.%x", bus->seq,
-                               PCI_DEV(devfn), PCI_FUNC(devfn));
-                       str = strdup(name);
-                       if (!str)
-                               return -ENOMEM;
-                       drv = class == PCI_CLASS_BRIDGE_PCI ?
-                               "pci_bridge_drv" : "pci_generic_drv";
-                       ret = device_bind_driver(bus, drv, str, &dev);
+                       struct pci_device_id find_id;
+                       ulong val;
+
+                       memset(&find_id, '\0', sizeof(find_id));
+                       find_id.vendor = vendor;
+                       find_id.device = device;
+                       find_id.class = class;
+                       if ((header_type & 0x7f) == PCI_HEADER_TYPE_NORMAL) {
+                               pci_bus_read_config(bus, devfn,
+                                                   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,
+                                                      &dev);
                }
                if (ret)
                        return ret;

include/pci.h +0 -0

index 3af511b..d21fa8b 100644

include/pci.h typedef int pci_dev_t; · line 475

Quoted 9 lines

include/pci.h +4 -1

@@ -468,7 +468,10 @@ typedef int pci_dev_t;
 #define PCI_ANY_ID             (~0)
 
 struct pci_device_id {
-       unsigned int vendor, device;            /* Vendor and device ID or PCI_ANY_ID */
+       unsigned int vendor, device;    /* Vendor and device ID or PCI_ANY_ID */
+       unsigned int subvendor, subdevice; /* Subsystem ID's or PCI_ANY_ID */
+       unsigned int class, class_mask; /* (class,subclass,prog-if) triplet */
+       unsigned long driver_data;      /* Data private to the driver */
 };

Can we create another structure for dm? There are lots of codes which only defines vendor id and device id like below:

static struct pci_device_id mmc_supported[] = {
{ PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_TCF_SDIO_0 }, { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_TCF_SDIO_1 },
};

Although compiler does not generate any error or warning, it is confusing.

Quoted 82 lines

include/pci.h +73 -1

 struct pci_controller;

@@ -1110,7 +1113,79 @@ struct dm_pci_emul_ops {
 int sandbox_pci_get_emul(struct udevice *bus, pci_dev_t find_devfn,
                         struct udevice **emulp);
 
-#endif
+/**
+ * PCI_DEVICE - macro used to describe a specific pci device
+ * @vend: the 16 bit PCI Vendor ID
+ * @dev: the 16 bit PCI Device ID
+ *
+ * This macro is used to create a struct pci_device_id that matches a
+ * specific device.  The subvendor and subdevice fields will be set to
+ * PCI_ANY_ID.
+ */
+#define PCI_DEVICE(vend, dev) \
+       .vendor = (vend), .device = (dev), \
+       .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
+
+/**
+ * PCI_DEVICE_SUB - macro used to describe a specific pci device with subsystem
+ * @vend: the 16 bit PCI Vendor ID
+ * @dev: the 16 bit PCI Device ID
+ * @subvend: the 16 bit PCI Subvendor ID
+ * @subdev: the 16 bit PCI Subdevice ID
+ *
+ * This macro is used to create a struct pci_device_id that matches a
+ * specific device with subsystem information.
+ */
+#define PCI_DEVICE_SUB(vend, dev, subvend, subdev) \
+       .vendor = (vend), .device = (dev), \
+       .subvendor = (subvend), .subdevice = (subdev)
+
+/**
+ * PCI_DEVICE_CLASS - macro used to describe a specific pci device class
+ * @dev_class: the class, subclass, prog-if triple for this device
+ * @dev_class_mask: the class mask for this device
+ *
+ * This macro is used to create a struct pci_device_id that matches a
+ * specific PCI class.  The vendor, device, subvendor, and subdevice
+ * fields will be set to PCI_ANY_ID.
+ */
+#define PCI_DEVICE_CLASS(dev_class, dev_class_mask) \
+       .class = (dev_class), .class_mask = (dev_class_mask), \
+       .vendor = PCI_ANY_ID, .device = PCI_ANY_ID, \
+       .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
+
+/**
+ * PCI_VDEVICE - macro used to describe a specific pci device in short form
+ * @vend: the vendor name
+ * @dev: the 16 bit PCI Device ID
+ *
+ * This macro is used to create a struct pci_device_id that matches a
+ * specific PCI device.  The subvendor, and subdevice fields will be set
+ * to PCI_ANY_ID. The macro allows the next field to follow as the device
+ * private data.
+ */
+
+#define PCI_VDEVICE(vend, dev) \
+       .vendor = PCI_VENDOR_ID_##vend, .device = (dev), \
+       .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID, 0, 0
+
+/**
+ * struct pci_driver_entry - Matches a driver to its pci_device_id list
+ * @driver: Driver to use
+ * @match: List of match records for this driver, terminated by {}
+ */
+struct pci_driver_entry {
+       struct driver *driver;
+       const struct pci_device_id *match;
+};
+
+#define U_BOOT_PCI_DEVICE(__name, __match)                             \
+       ll_entry_declare(struct pci_driver_entry, __name, pci_driver_entry) = {\
+               .driver = llsym(struct driver, __name, driver), \
+               .match = __match, \
+               }
+
+#endif /* CONFIG_DM_PCI */
 

include/pci.h struct dm_pci_emul_ops {

Quoted 3 lines

include/pci.h +0 -1

 #endif /* __ASSEMBLY__ */
 #endif /* _PCI_H */
--

Do you have plan to address the issue that dm pci cannot be used in the pre-reloc phase? Like we need pci uart as the U-Boot console.

Hi Bin,

Quoted 200 lines · Bin Meng

Hi Simon,

Quoted 179 lines · Simon Glass

At present all PCI devices must be present in the device tree in order to be used. Many or most PCI devices don't require any configuration other than that which is done automatically by U-Boot. It is inefficent to add a node with nothing but a compatible string in order to get a device working.

Add a mechanism whereby PCI drivers can be declared along with the device parameters they support (vendor/device/class). When no suitable driver is found in the device tree the list of such devices is consulted to determine the correct driver. If this also fails, then a generic driver is used as before.

The mechanism used is very similar to that provided by Linux and the header file defintions are copied from Linux 4.1.

Signed-off-by Simon Glass <[email protected]>

---

 drivers/pci/pci-uclass.c | 129 ++++++++++++++++++++++++++++++++++++++++++-----
 include/pci.h            |  79 ++++++++++++++++++++++++++++-
 2 files changed, 193 insertions(+), 15 deletions(-)

drivers/pci/pci-uclass.c +116 -13

index 5b91fe3..41daa0d 100644
@@ -353,6 +353,101 @@ int dm_pci_hose_probe_bus(struct pci_controller *hose, pci_dev_t bdf)
        return sub_bus;
 }
 
+/**
+ * pci_match_one_device - Tell if a PCI device structure has a matching
+ *                        PCI device id structure
+ * @id: single PCI device id structure to match
+ * @dev: the PCI device structure to match against
+ *
+ * Returns the matching pci_device_id structure or %NULL if there is no match.
+ */
+static bool pci_match_one_id(const struct pci_device_id *id,
+                            const struct pci_device_id *find)
+{
+       if ((id->vendor == PCI_ANY_ID || id->vendor == find->vendor) &&
+           (id->device == PCI_ANY_ID || id->device == find->device) &&
+           (id->subvendor == PCI_ANY_ID || id->subvendor == find->subvendor) &&
+           (id->subdevice == PCI_ANY_ID || id->subdevice == find->subdevice) &&
+           !((id->class ^ find->class) & id->class_mask))
+               return true;
+
+       return false;
+}
+
+/**
+ * pci_find_and_bind_driver() - Find and bind the right PCI driver
+ *
+ * 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 udevice **devp)
+{
+       struct pci_driver_entry *start, *entry;
+       const char *drv;
+       int n_ents;
+       int ret;
+       char name[30], *str;
+
+       *devp = NULL;
+
+       debug("%s: Searching for driver: vendor=%x, device=%x\n", __func__,
+             find_id->vendor, find_id->device);
+       start = ll_entry_start(struct pci_driver_entry, pci_driver_entry);
+       n_ents = ll_entry_count(struct pci_driver_entry, pci_driver_entry);
+       for (entry = start; entry != start + n_ents; entry++) {
+               const struct pci_device_id *id;
+               struct udevice *dev;
+               const struct driver *drv;
+
+               for (id = entry->match;
+                    id->vendor || id->subvendor || id->class_mask;
+                    id++) {
+                       if (!pci_match_one_id(id, find_id))
+                               continue;
+
+                       drv = entry->driver;
+                       /*
+                        * We could pass the descriptor to the driver as
+                        * platdata (instead of NULL) and allow its bind()
+                        * method to return -ENOENT if it doesn't support this
+                        * device. That way we could continue the search to
+                        * find another driver. For now this doesn't seem
+                        * necesssary, so just bind the first match.
+                        */
+                       ret = device_bind(parent, drv, drv->name, NULL, -1,
+                                         &dev);
+                       if (ret)
+                               goto error;
+                       debug("%s: Match found: %s\n", __func__, drv->name);
+                       dev->driver_data = find_id->driver_data;
+                       *devp = dev;
+                       return 0;
+               }
+       }
+
+       /* 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));
+       str = strdup(name);
+       if (!str)
+               return -ENOMEM;
+       drv = (find_id->class >> 8) == PCI_CLASS_BRIDGE_PCI ? "pci_bridge_drv" :
+                       "pci_generic_drv";
+       ret = device_bind_driver(parent, drv, str, devp);
+       if (ret) {
+               debug("%s: Failed to bind generic driver: %d", __func__, ret);
+               return ret;
+       }
+       debug("%s: No match found: bound generic driver instead\n", __func__);
+
+       return 0;
+
+error:
+       debug("%s: No match found: error %d\n", __func__, ret);
+       return ret;
+}
+
 int pci_bind_bus_devices(struct udevice *bus)
 {
        ulong vendor, device;

@@ -387,25 +482,33 @@ int pci_bind_bus_devices(struct udevice *bus)
                      bus->seq, bus->name, PCI_DEV(devfn), PCI_FUNC(devfn));
                pci_bus_read_config(bus, devfn, PCI_DEVICE_ID, &device,
                                    PCI_SIZE_16);
-               pci_bus_read_config(bus, devfn, PCI_CLASS_DEVICE, &class,
-                                   PCI_SIZE_16);
+               pci_bus_read_config(bus, devfn, PCI_CLASS_REVISION, &class,
+                                   PCI_SIZE_32);
+               class >>= 8;
 
                /* Find this device in the device tree */
                ret = pci_bus_find_devfn(bus, devfn, &dev);
 
+               /* Search for a driver */
+
                /* If nothing in the device tree, bind a generic device */
                if (ret == -ENODEV) {
-                       char name[30], *str;
-                       const char *drv;
-
-                       sprintf(name, "pci_%x:%x.%x", bus->seq,
-                               PCI_DEV(devfn), PCI_FUNC(devfn));
-                       str = strdup(name);
-                       if (!str)
-                               return -ENOMEM;
-                       drv = class == PCI_CLASS_BRIDGE_PCI ?
-                               "pci_bridge_drv" : "pci_generic_drv";
-                       ret = device_bind_driver(bus, drv, str, &dev);
+                       struct pci_device_id find_id;
+                       ulong val;
+
+                       memset(&find_id, '\0', sizeof(find_id));
+                       find_id.vendor = vendor;
+                       find_id.device = device;
+                       find_id.class = class;
+                       if ((header_type & 0x7f) == PCI_HEADER_TYPE_NORMAL) {
+                               pci_bus_read_config(bus, devfn,
+                                                   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,
+                                                      &dev);
                }
                if (ret)
                        return ret;

include/pci.h +0 -0

index 3af511b..d21fa8b 100644

include/pci.h typedef int pci_dev_t; · line 475

Quoted 9 lines

include/pci.h +4 -1

@@ -468,7 +468,10 @@ typedef int pci_dev_t;
 #define PCI_ANY_ID             (~0)
 
 struct pci_device_id {
-       unsigned int vendor, device;            /* Vendor and device ID or PCI_ANY_ID */
+       unsigned int vendor, device;    /* Vendor and device ID or PCI_ANY_ID */
+       unsigned int subvendor, subdevice; /* Subsystem ID's or PCI_ANY_ID */
+       unsigned int class, class_mask; /* (class,subclass,prog-if) triplet */
+       unsigned long driver_data;      /* Data private to the driver */
 };

Can we create another structure for dm? There are lots of codes which only defines vendor id and device id like below:

static struct pci_device_id mmc_supported[] = {
{ PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_TCF_SDIO_0 }, { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_TCF_SDIO_1 },
};

Quoted 1 line

Although compiler does not generate any error or warning, it is confusing.

I think the existing structure is for exactly this purpose, - I have just added a few new fields. Why do we want to change it? I also really want to use this name as it matches Linux.

Quoted 82 lines

Quoted 82 lines

include/pci.h +73 -1

 struct pci_controller;

@@ -1110,7 +1113,79 @@ struct dm_pci_emul_ops {
 int sandbox_pci_get_emul(struct udevice *bus, pci_dev_t find_devfn,
                         struct udevice **emulp);
 
-#endif
+/**
+ * PCI_DEVICE - macro used to describe a specific pci device
+ * @vend: the 16 bit PCI Vendor ID
+ * @dev: the 16 bit PCI Device ID
+ *
+ * This macro is used to create a struct pci_device_id that matches a
+ * specific device.  The subvendor and subdevice fields will be set to
+ * PCI_ANY_ID.
+ */
+#define PCI_DEVICE(vend, dev) \
+       .vendor = (vend), .device = (dev), \
+       .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
+
+/**
+ * PCI_DEVICE_SUB - macro used to describe a specific pci device with subsystem
+ * @vend: the 16 bit PCI Vendor ID
+ * @dev: the 16 bit PCI Device ID
+ * @subvend: the 16 bit PCI Subvendor ID
+ * @subdev: the 16 bit PCI Subdevice ID
+ *
+ * This macro is used to create a struct pci_device_id that matches a
+ * specific device with subsystem information.
+ */
+#define PCI_DEVICE_SUB(vend, dev, subvend, subdev) \
+       .vendor = (vend), .device = (dev), \
+       .subvendor = (subvend), .subdevice = (subdev)
+
+/**
+ * PCI_DEVICE_CLASS - macro used to describe a specific pci device class
+ * @dev_class: the class, subclass, prog-if triple for this device
+ * @dev_class_mask: the class mask for this device
+ *
+ * This macro is used to create a struct pci_device_id that matches a
+ * specific PCI class.  The vendor, device, subvendor, and subdevice
+ * fields will be set to PCI_ANY_ID.
+ */
+#define PCI_DEVICE_CLASS(dev_class, dev_class_mask) \
+       .class = (dev_class), .class_mask = (dev_class_mask), \
+       .vendor = PCI_ANY_ID, .device = PCI_ANY_ID, \
+       .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
+
+/**
+ * PCI_VDEVICE - macro used to describe a specific pci device in short form
+ * @vend: the vendor name
+ * @dev: the 16 bit PCI Device ID
+ *
+ * This macro is used to create a struct pci_device_id that matches a
+ * specific PCI device.  The subvendor, and subdevice fields will be set
+ * to PCI_ANY_ID. The macro allows the next field to follow as the device
+ * private data.
+ */
+
+#define PCI_VDEVICE(vend, dev) \
+       .vendor = PCI_VENDOR_ID_##vend, .device = (dev), \
+       .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID, 0, 0
+
+/**
+ * struct pci_driver_entry - Matches a driver to its pci_device_id list
+ * @driver: Driver to use
+ * @match: List of match records for this driver, terminated by {}
+ */
+struct pci_driver_entry {
+       struct driver *driver;
+       const struct pci_device_id *match;
+};
+
+#define U_BOOT_PCI_DEVICE(__name, __match)                             \
+       ll_entry_declare(struct pci_driver_entry, __name, pci_driver_entry) = {\
+               .driver = llsym(struct driver, __name, driver), \
+               .match = __match, \
+               }
+
+#endif /* CONFIG_DM_PCI */
 

Quoted 6 lines

include/pci.h struct dm_pci_emul_ops {

Quoted 3 lines

include/pci.h +0 -1

 #endif /* __ASSEMBLY__ */
 #endif /* _PCI_H */
--

Do you have plan to address the issue that dm pci cannot be used in the pre-reloc phase? Like we need pci uart as the U-Boot console.

Hi Simon,

Quoted 203 lines · Simon Glass

Hi Bin,

Quoted 200 lines · Bin Meng

Hi Simon,

Quoted 179 lines · Simon Glass

At present all PCI devices must be present in the device tree in order to be used. Many or most PCI devices don't require any configuration other than that which is done automatically by U-Boot. It is inefficent to add a node with nothing but a compatible string in order to get a device working.

Add a mechanism whereby PCI drivers can be declared along with the device parameters they support (vendor/device/class). When no suitable driver is found in the device tree the list of such devices is consulted to determine the correct driver. If this also fails, then a generic driver is used as before.

The mechanism used is very similar to that provided by Linux and the header file defintions are copied from Linux 4.1.

Signed-off-by Simon Glass <[email protected]>

---

 drivers/pci/pci-uclass.c | 129 ++++++++++++++++++++++++++++++++++++++++++-----
 include/pci.h            |  79 ++++++++++++++++++++++++++++-
 2 files changed, 193 insertions(+), 15 deletions(-)

drivers/pci/pci-uclass.c +116 -13

index 5b91fe3..41daa0d 100644
@@ -353,6 +353,101 @@ int dm_pci_hose_probe_bus(struct pci_controller *hose, pci_dev_t bdf)
        return sub_bus;
 }
 
+/**
+ * pci_match_one_device - Tell if a PCI device structure has a matching
+ *                        PCI device id structure
+ * @id: single PCI device id structure to match
+ * @dev: the PCI device structure to match against
+ *
+ * Returns the matching pci_device_id structure or %NULL if there is no match.
+ */
+static bool pci_match_one_id(const struct pci_device_id *id,
+                            const struct pci_device_id *find)
+{
+       if ((id->vendor == PCI_ANY_ID || id->vendor == find->vendor) &&
+           (id->device == PCI_ANY_ID || id->device == find->device) &&
+           (id->subvendor == PCI_ANY_ID || id->subvendor == find->subvendor) &&
+           (id->subdevice == PCI_ANY_ID || id->subdevice == find->subdevice) &&
+           !((id->class ^ find->class) & id->class_mask))
+               return true;
+
+       return false;
+}
+
+/**
+ * pci_find_and_bind_driver() - Find and bind the right PCI driver
+ *
+ * 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 udevice **devp)
+{
+       struct pci_driver_entry *start, *entry;
+       const char *drv;
+       int n_ents;
+       int ret;
+       char name[30], *str;
+
+       *devp = NULL;
+
+       debug("%s: Searching for driver: vendor=%x, device=%x\n", __func__,
+             find_id->vendor, find_id->device);
+       start = ll_entry_start(struct pci_driver_entry, pci_driver_entry);
+       n_ents = ll_entry_count(struct pci_driver_entry, pci_driver_entry);
+       for (entry = start; entry != start + n_ents; entry++) {
+               const struct pci_device_id *id;
+               struct udevice *dev;
+               const struct driver *drv;
+
+               for (id = entry->match;
+                    id->vendor || id->subvendor || id->class_mask;
+                    id++) {
+                       if (!pci_match_one_id(id, find_id))
+                               continue;
+
+                       drv = entry->driver;
+                       /*
+                        * We could pass the descriptor to the driver as
+                        * platdata (instead of NULL) and allow its bind()
+                        * method to return -ENOENT if it doesn't support this
+                        * device. That way we could continue the search to
+                        * find another driver. For now this doesn't seem
+                        * necesssary, so just bind the first match.
+                        */
+                       ret = device_bind(parent, drv, drv->name, NULL, -1,
+                                         &dev);
+                       if (ret)
+                               goto error;
+                       debug("%s: Match found: %s\n", __func__, drv->name);
+                       dev->driver_data = find_id->driver_data;
+                       *devp = dev;
+                       return 0;
+               }
+       }
+
+       /* 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));
+       str = strdup(name);
+       if (!str)
+               return -ENOMEM;
+       drv = (find_id->class >> 8) == PCI_CLASS_BRIDGE_PCI ? "pci_bridge_drv" :
+                       "pci_generic_drv";
+       ret = device_bind_driver(parent, drv, str, devp);
+       if (ret) {
+               debug("%s: Failed to bind generic driver: %d", __func__, ret);
+               return ret;
+       }
+       debug("%s: No match found: bound generic driver instead\n", __func__);
+
+       return 0;
+
+error:
+       debug("%s: No match found: error %d\n", __func__, ret);
+       return ret;
+}
+
 int pci_bind_bus_devices(struct udevice *bus)
 {
        ulong vendor, device;

@@ -387,25 +482,33 @@ int pci_bind_bus_devices(struct udevice *bus)
                      bus->seq, bus->name, PCI_DEV(devfn), PCI_FUNC(devfn));
                pci_bus_read_config(bus, devfn, PCI_DEVICE_ID, &device,
                                    PCI_SIZE_16);
-               pci_bus_read_config(bus, devfn, PCI_CLASS_DEVICE, &class,
-                                   PCI_SIZE_16);
+               pci_bus_read_config(bus, devfn, PCI_CLASS_REVISION, &class,
+                                   PCI_SIZE_32);
+               class >>= 8;
 
                /* Find this device in the device tree */
                ret = pci_bus_find_devfn(bus, devfn, &dev);
 
+               /* Search for a driver */
+
                /* If nothing in the device tree, bind a generic device */
                if (ret == -ENODEV) {
-                       char name[30], *str;
-                       const char *drv;
-
-                       sprintf(name, "pci_%x:%x.%x", bus->seq,
-                               PCI_DEV(devfn), PCI_FUNC(devfn));
-                       str = strdup(name);
-                       if (!str)
-                               return -ENOMEM;
-                       drv = class == PCI_CLASS_BRIDGE_PCI ?
-                               "pci_bridge_drv" : "pci_generic_drv";
-                       ret = device_bind_driver(bus, drv, str, &dev);
+                       struct pci_device_id find_id;
+                       ulong val;
+
+                       memset(&find_id, '\0', sizeof(find_id));
+                       find_id.vendor = vendor;
+                       find_id.device = device;
+                       find_id.class = class;
+                       if ((header_type & 0x7f) == PCI_HEADER_TYPE_NORMAL) {
+                               pci_bus_read_config(bus, devfn,
+                                                   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,
+                                                      &dev);
                }
                if (ret)
                        return ret;

include/pci.h +0 -0

index 3af511b..d21fa8b 100644

include/pci.h typedef int pci_dev_t; · line 475

Quoted 9 lines

include/pci.h +4 -1

@@ -468,7 +468,10 @@ typedef int pci_dev_t;
 #define PCI_ANY_ID             (~0)
 
 struct pci_device_id {
-       unsigned int vendor, device;            /* Vendor and device ID or PCI_ANY_ID */
+       unsigned int vendor, device;    /* Vendor and device ID or PCI_ANY_ID */
+       unsigned int subvendor, subdevice; /* Subsystem ID's or PCI_ANY_ID */
+       unsigned int class, class_mask; /* (class,subclass,prog-if) triplet */
+       unsigned long driver_data;      /* Data private to the driver */
 };

Can we create another structure for dm? There are lots of codes which only defines vendor id and device id like below:

static struct pci_device_id mmc_supported[] = {
{ PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_TCF_SDIO_0 }, { PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_TCF_SDIO_1 },
};

Quoted 6 lines

Quoted 1 line

Although compiler does not generate any error or warning, it is confusing.

I think the existing structure is for exactly this purpose, - I have just added a few new fields. Why do we want to change it? I also really want to use this name as it matches Linux.

I mean it creates confusion if existing codes are unchanged, which makes me think it contains only a vendor id and a device id for each structure, but actually it has more members which are omitted. I would do:

static struct pci_device_id mmc_supported[] = {
{ .vendor = PCI_VENDOR_ID_INTEL, .device =
PCI_DEVICE_ID_INTEL_TCF_SDIO_0 },
{ .vendor = PCI_VENDOR_ID_INTEL, .device =
PCI_DEVICE_ID_INTEL_TCF_SDIO_1 },

And one more comment at the end.

Quoted 83 lines

Quoted 83 lines

Quoted 83 lines

include/pci.h +73 -1

 struct pci_controller;

@@ -1110,7 +1113,79 @@ struct dm_pci_emul_ops {
 int sandbox_pci_get_emul(struct udevice *bus, pci_dev_t find_devfn,
                         struct udevice **emulp);
 
-#endif
+/**
+ * PCI_DEVICE - macro used to describe a specific pci device
+ * @vend: the 16 bit PCI Vendor ID
+ * @dev: the 16 bit PCI Device ID
+ *
+ * This macro is used to create a struct pci_device_id that matches a
+ * specific device.  The subvendor and subdevice fields will be set to
+ * PCI_ANY_ID.
+ */
+#define PCI_DEVICE(vend, dev) \
+       .vendor = (vend), .device = (dev), \
+       .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
+
+/**
+ * PCI_DEVICE_SUB - macro used to describe a specific pci device with subsystem
+ * @vend: the 16 bit PCI Vendor ID
+ * @dev: the 16 bit PCI Device ID
+ * @subvend: the 16 bit PCI Subvendor ID
+ * @subdev: the 16 bit PCI Subdevice ID
+ *
+ * This macro is used to create a struct pci_device_id that matches a
+ * specific device with subsystem information.
+ */
+#define PCI_DEVICE_SUB(vend, dev, subvend, subdev) \
+       .vendor = (vend), .device = (dev), \
+       .subvendor = (subvend), .subdevice = (subdev)
+
+/**
+ * PCI_DEVICE_CLASS - macro used to describe a specific pci device class
+ * @dev_class: the class, subclass, prog-if triple for this device
+ * @dev_class_mask: the class mask for this device
+ *
+ * This macro is used to create a struct pci_device_id that matches a
+ * specific PCI class.  The vendor, device, subvendor, and subdevice
+ * fields will be set to PCI_ANY_ID.
+ */
+#define PCI_DEVICE_CLASS(dev_class, dev_class_mask) \
+       .class = (dev_class), .class_mask = (dev_class_mask), \
+       .vendor = PCI_ANY_ID, .device = PCI_ANY_ID, \
+       .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID
+
+/**
+ * PCI_VDEVICE - macro used to describe a specific pci device in short form
+ * @vend: the vendor name
+ * @dev: the 16 bit PCI Device ID
+ *
+ * This macro is used to create a struct pci_device_id that matches a
+ * specific PCI device.  The subvendor, and subdevice fields will be set
+ * to PCI_ANY_ID. The macro allows the next field to follow as the device
+ * private data.
+ */
+
+#define PCI_VDEVICE(vend, dev) \
+       .vendor = PCI_VENDOR_ID_##vend, .device = (dev), \
+       .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID, 0, 0
+
+/**
+ * struct pci_driver_entry - Matches a driver to its pci_device_id list
+ * @driver: Driver to use
+ * @match: List of match records for this driver, terminated by {}
+ */
+struct pci_driver_entry {
+       struct driver *driver;
+       const struct pci_device_id *match;
+};
+
+#define U_BOOT_PCI_DEVICE(__name, __match)                             \
+       ll_entry_declare(struct pci_driver_entry, __name, pci_driver_entry) = {\
+               .driver = llsym(struct driver, __name, driver), \
+               .match = __match, \
+               }
+
+#endif /* CONFIG_DM_PCI */
 

Quoted 7 lines

Quoted 6 lines

include/pci.h struct dm_pci_emul_ops {

Quoted 3 lines

include/pci.h +0 -1

 #endif /* __ASSEMBLY__ */
 #endif /* _PCI_H */
--

Do you have plan to address the issue that dm pci cannot be used in the pre-reloc phase? Like we need pci uart as the U-Boot console.

Do you have plan to address the issue that dm pci cannot be used in the pre-reloc phase? Like we need pci uart as the U-Boot console.

This driver is used by the Intel Minnowmax board. Convert it to driver model so it can use the new Ethernet implementation.

Signed-off-by Simon Glass <[email protected]>

---

 drivers/net/rtl8169.c | 236 +++++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 187 insertions(+), 49 deletions(-)

It is useful to be able to find the full PCI address (bus, device and function) for a PCI device. Add a function to provide this.

Adjust the existing code to use this.

Signed-off-by Simon Glass <[email protected]>

---

 drivers/pci/pci-uclass.c | 15 +++++++++------
 drivers/pci/pci_compat.c |  8 ++------
 include/pci.h            |  8 ++++++++
 3 files changed, 19 insertions(+), 12 deletions(-)

The function documentation is incorrect. Fix it.

Signed-off-by Simon Glass <[email protected]>

Quoted 3 lines · Simon Glass

The function documentation is incorrect. Fix it.

Signed-off-by Simon Glass <[email protected]>

Acked-by Marek Vasut <[email protected]>

Best regards,
Marek Vasut

If driver model is used for Ethernet then USB Ethernet does not build. This can be made to work with driver model is used for USB also. Add #ifdef logic to make this clear when building.

Signed-off-by Simon Glass <[email protected]>

Quoted 4 lines · Simon Glass

If driver model is used for Ethernet then USB Ethernet does not build. This can be made to work with driver model is used for USB also. Add #ifdef logic to make this clear when building.

Quoted 1 line

Signed-off-by Simon Glass <[email protected]>

Well ew, but OK.

Reviewed-by Marek Vasut <[email protected]>

Best regards,
Marek Vasut

Some devices can take a long time to work out whether they have a new packet or now. For example the ASIX USB Ethernet dongle can take 5 seconds to do this, since it waits until it gets a new packet on the wire before allowing the USB bulk read packet to be submitted.

At present with driver mode the Ethernet receive code reads 32 packets. This can take a very long time if we must wait for all 32 packets. The old code (before driver model) worked by reading a single set of packets from the USB device, then processing all the packets with in. It would be nice to use the same behaviour with driver model.

Add a flag to the receive method which indicates that the driver should try to find a packet if available, by consulting the hardware. When the flag is not set, it should just return any packet data it has already received. If there is none, it should return -EAGAIN so that the loop will terminate.

Signed-off-by Simon Glass <[email protected]>

---

 drivers/net/designware.c  |  2 +-
 drivers/net/sandbox-raw.c |  2 +-
 drivers/net/sandbox.c     |  2 +-
 drivers/net/sunxi_emac.c  |  2 +-
 include/net.h             | 10 +++++++++-
 net/eth.c                 |  5 ++++-
 6 files changed, 17 insertions(+), 6 deletions(-)

Some devices can take a long time to work out whether they have a new packet or now. For example the ASIX USB Ethernet dongle can take 5 seconds to do this, since it waits until it gets a new packet on the wire before allowing the USB bulk read packet to be submitted.

At present with driver mode the Ethernet receive code reads 32 packets. This can take a very long time if we must wait for all 32 packets. The old code (before driver model) worked by reading a single set of packets from the USB device, then processing all the packets with in. It would be nice to use the same behaviour with driver model.

Add a flag to the receive method which indicates that the driver should try to find a packet if available, by consulting the hardware. When the flag is not set, it should just return any packet data it has already received. If there is none, it should return -EAGAIN so that the loop will terminate.

Signed-off-by Simon Glass <[email protected]>

---

At present USB Ethernet does not work with CONFIG_DM_ETH. Add driver model support to this feature, so that it can work alongside other Ethernet devices with driver model.

It was found that quite a bit of code is common in most of the USB Ethernet drivers. Add this code to the common layer to reduce the amount of duplicate code needed in USB Ethernet drivers when CONFIG_DM_ETH is used.

Signed-off-by Simon Glass <[email protected]>

Quoted 8 lines · Simon Glass

At present USB Ethernet does not work with CONFIG_DM_ETH. Add driver model support to this feature, so that it can work alongside other Ethernet devices with driver model.

It was found that quite a bit of code is common in most of the USB Ethernet drivers. Add this code to the common layer to reduce the amount of duplicate code needed in USB Ethernet drivers when CONFIG_DM_ETH is used.

Quoted 1 line

Signed-off-by Simon Glass <[email protected]>

Reviewed-by Marek Vasut <[email protected]>

Best regards,
Marek Vasut

In Linux USB_DEVICE() is used to declare a USB device by vendor/device ID. We should follow the same convention in U-Boot. Rename the existing USB_DEVICE() macro to U_BOOT_USB_DEVICE() and bring in the USB_DEVICE() macro from Linux for use in U-Boot.

Signed-off-by Simon Glass <[email protected]>

Quoted 5 lines · Simon Glass

In Linux USB_DEVICE() is used to declare a USB device by vendor/device ID. We should follow the same convention in U-Boot. Rename the existing USB_DEVICE() macro to U_BOOT_USB_DEVICE() and bring in the USB_DEVICE() macro from Linux for use in U-Boot.

Quoted 1 line

Signed-off-by Simon Glass <[email protected]>

Acked-by Marek Vasut <[email protected]>

Best regards,
Marek Vasut

Now that the RTL8169 driver warning is fixed we can drop this. The incorrect value is causing problems with USB EHCI.

Signed-off-by Simon Glass <[email protected]>

---

 include/configs/minnowmax.h | 3 ---
 1 file changed, 3 deletions(-)

include/configs/minnowmax.h +0 -0

index 41653ba..105b05d 100644

Quoted 23 lines · Simon Glass

Now that the RTL8169 driver warning is fixed we can drop this. The incorrect value is causing problems with USB EHCI.

Signed-off-by Simon Glass <[email protected]>

---

 include/configs/minnowmax.h | 3 ---
 1 file changed, 3 deletions(-)

include/configs/minnowmax.h +0 -3

index 41653ba..105b05d 100644
@@ -63,9 +63,6 @@
 #define CONFIG_FIT_SIGNATURE
 #define CONFIG_RSA
 
-/* Avoid a warning in the Realtek Ethernet driver */
-#define CONFIG_SYS_CACHELINE_SIZE 16
-
 #define CONFIG_ENV_SECT_SIZE           0x1000
 #define CONFIG_ENV_OFFSET              0x007fe000
 

Quoted 1 line

--

Reviewed-by Bin Meng <[email protected]>

Support driver model in this driver. This uses the normal USB driver search mechanism. Any EHCI controllers will be set up as they are found during usb_init().

Signed-off-by Simon Glass <[email protected]>

Quoted 5 lines · Simon Glass

Support driver model in this driver. This uses the normal USB driver search mechanism. Any EHCI controllers will be set up as they are found during usb_init().

Signed-off-by Simon Glass <[email protected]>

Reviewed-by Marek Vasut <[email protected]>

Best regards,
Marek Vasut

This USB Ethernet driver is quite widely use. Allow it to work with CONFIG_DM_ETH enabled. Most of the code remains common but there is a new packet receive flow which is handled specially.

Signed-off-by Simon Glass <[email protected]>

---

 drivers/usb/eth/asix.c | 237 ++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 216 insertions(+), 21 deletions(-)

Some drivers may want to implement this method for some of their devices but not for others. So it is not possible to just leave the operation out of the table. Drivers could get around this by masquerading as two separate drivers but that seems unpleasant.

Allow the driver to return an error when it does not want to process the write_hwaddr() method.

Signed-off-by Simon Glass <[email protected]>

---

 include/net.h | 4 +++-
 net/eth.c     | 6 ++++++
 2 files changed, 9 insertions(+), 1 deletion(-)