soundwire: mipi-disco: add support for DP0/DPn 'lane-list' property

The SoundWire specification did not clearly require that ports could
use all Lanes. Some SoundWire/SDCA peripheral adopters added
restrictions on which lanes can be used by what port, and the DisCo
for SoundWire 2.1 specification added a 'lane-list' property to model
this hardware limitation.

When not specified, the ports can use all Lanes. Otherwise, the
'lane-list' indicates which Lanes can be used, sorted by order of
preference (most-preferred-first).

This patch only reads the properties, the use of this property will
come at a later time with multi-lane support.

Signed-off-by: Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>
Signed-off-by: Bard Liao <yung-chuan.liao@linux.intel.com>
Link: https://lore.kernel.org/r/20241003070650.62787-15-yung-chuan.liao@linux.intel.com
Signed-off-by: Vinod Koul <vkoul@kernel.org>

diff --git a/drivers/soundwire/mipi_disco.c b/drivers/soundwire/mipi_disco.c
index 36e734751225c91a55b11162b7c72f81576452aa..9d59f486edbe0a158c1b21745fba3d980dcfad25 100644 (file)
--- a/drivers/soundwire/mipi_disco.c
+++ b/drivers/soundwire/mipi_disco.c
@@ -197,6 +197,22 @@ static int sdw_slave_read_dp0(struct sdw_slave *slave,
        dp0->imp_def_interrupts = mipi_fwnode_property_read_bool(port,
                                "mipi-sdw-imp-def-dp0-interrupts-supported");
 
+       nval = fwnode_property_count_u32(port, "mipi-sdw-lane-list");
+       if (nval > 0) {
+               dp0->num_lanes = nval;
+               dp0->lane_list = devm_kcalloc(&slave->dev,
+                                             dp0->num_lanes, sizeof(*dp0->lane_list),
+                                             GFP_KERNEL);
+               if (!dp0->lane_list)
+                       return -ENOMEM;
+
+               ret = fwnode_property_read_u32_array(port,
+                                              "mipi-sdw-lane-list",
+                                              dp0->lane_list, dp0->num_lanes);
+               if (ret < 0)
+                       return ret;
+       }
+
        return 0;
 }
 
@@ -326,6 +342,22 @@ static int sdw_slave_read_dpn(struct sdw_slave *slave,
                fwnode_property_read_u32(node, "mipi-sdw-port-encoding-type",
                                         &dpn[i].port_encoding);
 
+               nval = fwnode_property_count_u32(node, "mipi-sdw-lane-list");
+               if (nval > 0) {
+                       dpn[i].num_lanes = nval;
+                       dpn[i].lane_list = devm_kcalloc(&slave->dev,
+                                                       dpn[i].num_lanes, sizeof(*dpn[i].lane_list),
+                                                       GFP_KERNEL);
+                       if (!dpn[i].lane_list)
+                               return -ENOMEM;
+
+                       ret = fwnode_property_read_u32_array(node,
+                                                      "mipi-sdw-lane-list",
+                                                      dpn[i].lane_list, dpn[i].num_lanes);
+                       if (ret < 0)
+                               return ret;
+               }
+
                fwnode_handle_put(node);
 
                i++;

diff --git a/include/linux/soundwire/sdw.h b/include/linux/soundwire/sdw.h
index 952514f044f0d6be22c900ed62c3b65d2ecaa3e8..73f655334fe9c71c15c4ccd1f2b5ee31ad1eb518 100644 (file)
--- a/include/linux/soundwire/sdw.h
+++ b/include/linux/soundwire/sdw.h
@@ -238,6 +238,8 @@ enum sdw_clk_stop_mode {
  * @simple_ch_prep_sm: If channel prepare sequence is required
  * @imp_def_interrupts: If set, each bit corresponds to support for
  * implementation-defined interrupts
+ * @num_lanes: array size of @lane_list
+ * @lane_list: indicates which Lanes can be used by DP0
  *
  * The wordlengths are specified by Spec as max, min AND number of
  * discrete values, implementation can define based on the wordlengths they
@@ -252,6 +254,8 @@ struct sdw_dp0_prop {
        bool BRA_flow_controlled;
        bool simple_ch_prep_sm;
        bool imp_def_interrupts;
+       int num_lanes;
+       u32 *lane_list;
 };
 
 /**
@@ -275,6 +279,8 @@ struct sdw_dp0_prop {
  * @num_ch_combinations: Number of channel combinations supported
  * @channels: Discrete channels supported
  * @ch_combinations: Channel combinations supported
+ * @lane_list: indicates which Lanes can be used by DPn
+ * @num_lanes: array size of @lane_list
  * @modes: SDW mode supported
  * @max_async_buffer: Number of samples that this port can buffer in
  * asynchronous modes
@@ -300,6 +306,8 @@ struct sdw_dpn_prop {
        u32 num_ch_combinations;
        u32 *channels;
        u32 *ch_combinations;
+       u32 *lane_list;
+       int num_lanes;
        u32 modes;
        u32 max_async_buffer;
        u32 port_encoding;