spi: spi-uclass: Add new spi_get_bus_and_cs() implementation

Move legacy spi_get_bus_and_cs() code to _spi_get_bus_and_cs().

Add new spi_get_bus_and_cs() implementation which rely on DT
for speed and mode and don't need any drv_name nor dev_name
parameters. This will prepare the ground for next patch.

Update all callers to use _spi_get_bus_and_cs() to keep the
same behavior.

Signed-off-by: Patrice Chotard <patrice.chotard@foss.st.com>
Cc: Marek Behun <marek.behun@nic.cz>
Cc: Jagan Teki <jagan@amarulasolutions.com>
Cc: Vignesh R <vigneshr@ti.com>
Cc: Joe Hershberger <joe.hershberger@ni.com>
Cc: Ramon Fried <rfried.dev@gmail.com>
Cc: Lukasz Majewski <lukma@denx.de>
Cc: Marek Vasut <marex@denx.de>
Cc: Wolfgang Denk <wd@denx.de>
Cc: Simon Glass <sjg@chromium.org>
Cc: Stefan Roese <sr@denx.de>
Cc: "Pali Rohár" <pali@kernel.org>
Cc: Konstantin Porotchkin <kostap@marvell.com>
Cc: Igal Liberman <igall@marvell.com>
Cc: Bin Meng <bmeng.cn@gmail.com>
Cc: Pratyush Yadav <p.yadav@ti.com>
Cc: Sean Anderson <seanga2@gmail.com>
Cc: Anji J <anji.jagarlmudi@nxp.com>
Cc: Biwen Li <biwen.li@nxp.com>
Cc: Priyanka Jain <priyanka.jain@nxp.com>
Cc: Chaitanya Sakinam <chaitanya.sakinam@nxp.com>

diff --git a/board/CZ.NIC/turris_mox/turris_mox.c b/board/CZ.NIC/turris_mox/turris_mox.c
index a4738b3..68bc315 100644 (file)
--- a/board/CZ.NIC/turris_mox/turris_mox.c
+++ b/board/CZ.NIC/turris_mox/turris_mox.c
@@ -149,9 +149,9 @@ static int mox_do_spi(u8 *in, u8 *out, size_t size)
        struct udevice *dev;
        int ret;
 
-       ret = spi_get_bus_and_cs(0, 1, 1000000, SPI_CPHA | SPI_CPOL,
-                                "spi_generic_drv", "moxtet@1", &dev,
-                                &slave);
+       ret = _spi_get_bus_and_cs(0, 1, 1000000, SPI_CPHA | SPI_CPOL,
+                                 "spi_generic_drv", "moxtet@1", &dev,
+                                 &slave);
        if (ret)
                goto fail;
 

diff --git a/cmd/spi.c b/cmd/spi.c
index 6dc3267..454ebe3 100644 (file)
--- a/cmd/spi.c
+++ b/cmd/spi.c
@@ -46,8 +46,8 @@ static int do_spi_xfer(int bus, int cs)
        str = strdup(name);
        if (!str)
                return -ENOMEM;
-       ret = spi_get_bus_and_cs(bus, cs, freq, mode, "spi_generic_drv",
-                                str, &dev, &slave);
+       ret = _spi_get_bus_and_cs(bus, cs, freq, mode, "spi_generic_drv",
+                                 str, &dev, &slave);
        if (ret)
                return ret;
 #else

diff --git a/drivers/mtd/spi/sf-uclass.c b/drivers/mtd/spi/sf-uclass.c
index 63d1629..b45ba54 100644 (file)
--- a/drivers/mtd/spi/sf-uclass.c
+++ b/drivers/mtd/spi/sf-uclass.c
@@ -74,7 +74,7 @@ int spi_flash_probe_bus_cs(unsigned int busnum, unsigned int cs,
        snprintf(name, sizeof(name), "spi_flash@%d:%d", busnum, cs);
        str = strdup(name);
 #endif
-       ret = spi_get_bus_and_cs(busnum, cs, max_hz, spi_mode,
+       ret = _spi_get_bus_and_cs(busnum, cs, max_hz, spi_mode,
                                  "jedec_spi_nor", str, &bus, &slave);
        if (ret)
                return ret;

diff --git a/drivers/spi/spi-uclass.c b/drivers/spi/spi-uclass.c
index f8ec312..f2791c4 100644 (file)
--- a/drivers/spi/spi-uclass.c
+++ b/drivers/spi/spi-uclass.c
@@ -340,9 +340,65 @@ int spi_find_bus_and_cs(int busnum, int cs, struct udevice **busp,
        return ret;
 }
 
-int spi_get_bus_and_cs(int busnum, int cs, int speed, int mode,
-                      const char *drv_name, const char *dev_name,
-                      struct udevice **busp, struct spi_slave **devp)
+int spi_get_bus_and_cs(int busnum, int cs, struct udevice **busp,
+                      struct spi_slave **devp)
+{
+       struct udevice *bus, *dev;
+       struct dm_spi_bus *bus_data;
+       struct spi_slave *slave;
+       int ret;
+
+#if CONFIG_IS_ENABLED(OF_PLATDATA)
+       ret = uclass_first_device_err(UCLASS_SPI, &bus);
+#else
+       ret = uclass_get_device_by_seq(UCLASS_SPI, busnum, &bus);
+#endif
+       if (ret) {
+               log_err("Invalid bus %d (err=%d)\n", busnum, ret);
+               return ret;
+       }
+       ret = spi_find_chip_select(bus, cs, &dev);
+       if (ret) {
+               dev_err(bus, "Invalid chip select %d:%d (err=%d)\n", busnum, cs, ret);
+               return ret;
+       }
+
+       if (!device_active(dev)) {
+               struct spi_slave *slave;
+
+               ret = device_probe(dev);
+               if (ret)
+                       goto err;
+               slave = dev_get_parent_priv(dev);
+               slave->dev = dev;
+       }
+
+       slave = dev_get_parent_priv(dev);
+       bus_data = dev_get_uclass_priv(bus);
+
+       /*
+        * In case the operation speed is not yet established by
+        * dm_spi_claim_bus() ensure the bus is configured properly.
+        */
+       if (!bus_data->speed) {
+               ret = spi_claim_bus(slave);
+               if (ret)
+                       goto err;
+       }
+       *busp = bus;
+       *devp = slave;
+
+       return 0;
+
+err:
+       log_debug("%s: Error path, device '%s'\n", __func__, dev->name);
+
+       return ret;
+}
+
+int _spi_get_bus_and_cs(int busnum, int cs, int speed, int mode,
+                       const char *drv_name, const char *dev_name,
+                       struct udevice **busp, struct spi_slave **devp)
 {
        struct udevice *bus, *dev;
        struct dm_spi_slave_plat *plat;
@@ -453,8 +509,8 @@ struct spi_slave *spi_setup_slave(unsigned int busnum, unsigned int cs,
        struct udevice *dev;
        int ret;
 
-       ret = spi_get_bus_and_cs(busnum, cs, speed, mode, NULL, 0, &dev,
-                                &slave);
+       ret = _spi_get_bus_and_cs(busnum, cs, speed, mode, NULL, 0, &dev,
+                                 &slave);
        if (ret)
                return NULL;
 

diff --git a/drivers/usb/gadget/max3420_udc.c b/drivers/usb/gadget/max3420_udc.c
index a16095f..fa655c9 100644 (file)
--- a/drivers/usb/gadget/max3420_udc.c
+++ b/drivers/usb/gadget/max3420_udc.c
@@ -830,8 +830,8 @@ static int max3420_udc_probe(struct udevice *dev)
        cs = slave_pdata->cs;
        speed = slave_pdata->max_hz;
        mode = slave_pdata->mode;
-       spi_get_bus_and_cs(busnum, cs, speed, mode, "spi_generic_drv",
-                          NULL, &spid, &udc->slave);
+       _spi_get_bus_and_cs(busnum, cs, speed, mode, false, "spi_generic_drv",
+                           NULL, &spid, &udc->slave);
 
        udc->dev = dev;
        udc->gadget.ep0 = &udc->ep[0].ep_usb;

diff --git a/include/spi.h b/include/spi.h
index fa9ab12..9a8c1fb 100644 (file)
--- a/include/spi.h
+++ b/include/spi.h
@@ -572,6 +572,23 @@ int spi_find_bus_and_cs(int busnum, int cs, struct udevice **busp,
  * Given a bus number and chip select, this finds the corresponding bus
  * device and slave device.
  *
+ * @busnum:    SPI bus number
+ * @cs:                Chip select to look for
+ * @busp:      Returns bus device
+ * @devp:      Return slave device
+ * @return 0 if found, -ve on error
+ */
+int spi_get_bus_and_cs(int busnum, int cs,
+                      struct udevice **busp, struct spi_slave **devp);
+
+/**
+ * _spi_get_bus_and_cs() - Find and activate bus and slave devices by number
+ * As spi_flash_probe(), This is an old-style function. We should remove
+ * it when all SPI flash drivers use dm
+ *
+ * Given a bus number and chip select, this finds the corresponding bus
+ * device and slave device.
+ *
  * If no such slave exists, and drv_name is not NULL, then a new slave device
  * is automatically bound on this chip select with requested speed and mode.
  *
@@ -588,7 +605,7 @@ int spi_find_bus_and_cs(int busnum, int cs, struct udevice **busp,
  * @devp:      Return slave device
  * Return: 0 if found, -ve on error
  */
-int spi_get_bus_and_cs(int busnum, int cs, int speed, int mode,
+int _spi_get_bus_and_cs(int busnum, int cs, int speed, int mode,
                        const char *drv_name, const char *dev_name,
                        struct udevice **busp, struct spi_slave **devp);
 

diff --git a/test/dm/spi.c b/test/dm/spi.c
index ee4ad3a..7ab0820 100644 (file)
--- a/test/dm/spi.c
+++ b/test/dm/spi.c
@@ -46,19 +46,19 @@ static int dm_test_spi_find(struct unit_test_state *uts)
 
        /* This finds nothing because we removed the device */
        ut_asserteq(-ENODEV, spi_find_bus_and_cs(busnum, cs, &bus, &dev));
-       ut_asserteq(-ENODEV, spi_get_bus_and_cs(busnum, cs, speed, mode,
-                                               NULL, 0, &bus, &slave));
+       ut_asserteq(-ENODEV, _spi_get_bus_and_cs(busnum, cs, speed, mode,
+                                                NULL, 0, &bus, &slave));
 
        /*
         * This forces the device to be re-added, but there is no emulation
         * connected so the probe will fail. We require that bus is left
-        * alone on failure, and that the spi_get_bus_and_cs() does not add
+        * alone on failure, and that the _spi_get_bus_and_cs() does not add
         * a 'partially-inited' device.
         */
        ut_asserteq(-ENODEV, spi_find_bus_and_cs(busnum, cs, &bus, &dev));
-       ut_asserteq(-ENOENT, spi_get_bus_and_cs(busnum, cs, speed, mode,
-                                               "jedec_spi_nor", "name", &bus,
-                                               &slave));
+       ut_asserteq(-ENOENT, _spi_get_bus_and_cs(busnum, cs, speed, mode,
+                                                "jedec_spi_nor", "name", &bus,
+                                                &slave));
        sandbox_sf_unbind_emul(state_get_current(), busnum, cs);
        ut_assertok(spi_cs_info(bus, cs, &info));
        ut_asserteq_ptr(NULL, info.dev);
@@ -67,8 +67,8 @@ static int dm_test_spi_find(struct unit_test_state *uts)
        ut_assertok(sandbox_sf_bind_emul(state, busnum, cs, bus, node,
                                         "name"));
        ut_assertok(spi_find_bus_and_cs(busnum, cs, &bus, &dev));
-       ut_assertok(spi_get_bus_and_cs(busnum, cs, speed, mode,
-                                      "jedec_spi_nor", "name", &bus, &slave));
+       ut_assertok(_spi_get_bus_and_cs(busnum, cs, speed, mode,
+                                       "jedec_spi_nor", "name", &bus, &slave));
 
        ut_assertok(spi_cs_info(bus, cs, &info));
        ut_asserteq_ptr(info.dev, slave->dev);
@@ -76,8 +76,9 @@ static int dm_test_spi_find(struct unit_test_state *uts)
        /* We should be able to add something to another chip select */
        ut_assertok(sandbox_sf_bind_emul(state, busnum, cs_b, bus, node,
                                         "name"));
-       ut_asserteq(-EINVAL, spi_get_bus_and_cs(busnum, cs_b, speed, mode,
-                                      "jedec_spi_nor", "name", &bus, &slave));
+       ut_asserteq(-EINVAL, _spi_get_bus_and_cs(busnum, cs_b, speed, mode,
+                                                "jedec_spi_nor", "name", &bus,
+                                                &slave));
        ut_asserteq(-EINVAL, spi_cs_info(bus, cs_b, &info));
        ut_asserteq_ptr(NULL, info.dev);
 
@@ -145,11 +146,11 @@ static int dm_test_spi_claim_bus(struct unit_test_state *uts)
        const int busnum = 0, cs_a = 0, cs_b = 1, mode = 0;
 
        /* Get spi slave on CS0 */
-       ut_assertok(spi_get_bus_and_cs(busnum, cs_a, 1000000, mode, NULL, 0,
-                                      &bus, &slave_a));
+       ut_assertok(_spi_get_bus_and_cs(busnum, cs_a, 1000000, mode, NULL, 0,
+                                       &bus, &slave_a));
        /* Get spi slave on CS1 */
-       ut_assertok(spi_get_bus_and_cs(busnum, cs_b, 1000000, mode, NULL, 0,
-                                      &bus, &slave_b));
+       ut_assertok(_spi_get_bus_and_cs(busnum, cs_b, 1000000, mode, NULL, 0,
+                                       &bus, &slave_b));
 
        /* Different max_hz, different mode. */
        ut_assert(slave_a->max_hz != slave_b->max_hz);
@@ -182,8 +183,8 @@ static int dm_test_spi_xfer(struct unit_test_state *uts)
        const char dout[5] = {0x9f};
        unsigned char din[5];
 
-       ut_assertok(spi_get_bus_and_cs(busnum, cs, 1000000, mode, NULL, 0,
-                                      &bus, &slave));
+       ut_assertok(_spi_get_bus_and_cs(busnum, cs, 1000000, mode, NULL, 0,
+                                       &bus, &slave));
        ut_assertok(spi_claim_bus(slave));
        ut_assertok(spi_xfer(slave, 40, dout, din,
                             SPI_XFER_BEGIN | SPI_XFER_END));