soundwire: add multi-lane support
Bard Liao
maintainercover soundwire: add multi-lane support
This series adds multi-lane support for SoundWire. We will get the lane connection information from ACPI and use multiple lanes if the bandwidth is not enough.
Bard Liao (10):
soundwire: add lane field in sdw_port_runtime
soundwire: mipi_disco: read lane mapping properties from ACPI
soundwire: add lane_used_bandwidth in struct sdw_bus
Soundwire: add sdw_slave_get_scale_index helper
Soundwire: stream: program BUSCLOCK_SCALE
Soundwire: generic_bandwidth_allocation: set frame shape on fly
soundwire: generic_bandwidth_allocation: correct clk_freq check in
sdw_select_row_col
soundwire: generic_bandwidth_allocation: check required freq
accurately
soundwire: generic_bandwidth_allocation: select data lane
soundwire: generic_bandwidth_allocation: add lane in sdw_group_params
Pierre-Louis Bossart (2):
soundwire: stream: set DEPREPARED state earlier
soundwire: generic_bandwidth_allocation: skip DEPREPARED streams
drivers/soundwire/amd_manager.c | 2 +- drivers/soundwire/bus.c | 65 ++-- drivers/soundwire/bus.h | 3 + .../soundwire/generic_bandwidth_allocation.c | 294 +++++++++++++++--- drivers/soundwire/mipi_disco.c | 40 ++- drivers/soundwire/stream.c | 63 +++- include/linux/soundwire/sdw.h | 10 + 7 files changed, 405 insertions(+), 72 deletions(-)
Signature · 1 line
2.34.1
Bard Liao
maintainerPATCH 1/12 soundwire: add lane field in sdw_port_runtime
Currently, lane_ctrl is always 0. Add a lane field in sdw_port_runtime to indicate the data lane of the data port.
They are 0 by default.
--- drivers/soundwire/amd_manager.c | 2 +- drivers/soundwire/bus.h | 2 ++ drivers/soundwire/generic_bandwidth_allocation.c | 4 ++-- 3 files changed, 5 insertions(+), 3 deletions(-)
drivers/soundwire/amd_manager.c +1 -1
@@ -410,7 +410,7 @@ static int amd_sdw_compute_params(struct sdw_bus *bus)sdw_fill_xport_params (&p_rt->transport_params, p_rt->num, false,SDW_BLK_GRP_CNT_1 , sample_int, port_bo, port_bo >>8 , hstart, hstop, -SDW_BLK_PKG_PER_PORT ,0x0 ); +SDW_BLK_PKG_PER_PORT , p_rt->lane); sdw_fill_port_params(&p_rt->port_params, p_rt->num, bps,
drivers/soundwire/bus.h +2 -0
@@ -90,6 +90,7 @@ int sdw_find_col_index(int col);* @transport_params: Transport parameters * @port_params: Port parameters * @port_node: List node for Master or Slave port_list +* @lane: Which lane is used * * SoundWire spec has no mention of ports for Master interface but the * concept is logically extended.
@@ -100,6 +101,7 @@ struct sdw_port_runtime {struct sdw_transport_params transport_params;struct sdw_port_params port_params;struct list_head port_node; +unsigned int lane; };/**
drivers/soundwire/generic_bandwidth_allocation.c +2 -2
@@ -56,7 +56,7 @@ void sdw_compute_slave_ports(struct sdw_master_runtime *m_rt, sample_int, port_bo, port_bo >>8 , t_data->hstart, t_data->hstop, - SDW_BLK_PKG_PER_PORT, 0x0); + SDW_BLK_PKG_PER_PORT, p_rt->lane); sdw_fill_port_params(&p_rt->port_params, p_rt->num, bps,
@@ -109,7 +109,7 @@ static void sdw_compute_master_ports(struct sdw_master_runtime *m_rt,sdw_fill_xport_params (&p_rt->transport_params, p_rt->num, false,SDW_BLK_GRP_CNT_1 , sample_int, *port_bo, (*port_bo) >>8 , hstart, hstop, -SDW_BLK_PKG_PER_PORT ,0x0 ); +SDW_BLK_PKG_PER_PORT , p_rt->lane); sdw_fill_port_params(&p_rt->port_params, p_rt->num, bps,
Signature · 1 line
2.34.1
Bard Liao
maintainerPATCH 2/12 soundwire: mipi_disco: read lane mapping properties from ACPI
In reply to Bard LiaoThe DisCo for SoundWire 2.0 added support for the
'mipi-sdw-lane-<n>-mapping' property.
--- drivers/soundwire/mipi_disco.c | 40 +++++++++++++++++++++++++++++++++- include/linux/soundwire/sdw.h | 5 +++++ 2 files changed, 44 insertions(+), 1 deletion(-)
drivers/soundwire/mipi_disco.c +39 -1
@@ -366,6 +366,44 @@ static int sdw_slave_read_dpn(struct sdw_slave *slave,return 0 ; } +/* +* In MIPI DisCo spec for SoundWire, lane mapping for a slave device is done with +* mipi-sdw-lane-x-mapping properties, where x is 1..7, and the values for those +* properties are mipi-sdw-manager-lane-x or mipi-sdw-peripheral-link-y, where x +* is an integer between 1 to 7 if the lane is connected to a manager lane, y is a +* character between A to E if the lane is connected to another peripheral lane. +*/ +int sdw_slave_read_lane_mapping (struct sdw_slave *slave) +{ +struct sdw_slave_prop *prop = &slave->prop; +struct device *dev = &slave->dev; +char prop_name[30 ]; +const char *prop_val; +size_t len; +int ret, i; +u8 lane; + +for (i =0 ; i <SDW_MAX_LANES ; i++) { +snprintf (prop_name,sizeof (prop_name),"mipi-sdw-lane-%d-mapping" , i); + ret =device_property_read_string (dev, prop_name, &prop_val); +if (ret) +continue ; + + len =strlen (prop_val); +if (len <1 ) +return -EINVAL ; + +/* The last character is enough to identify the connection */ + ret =kstrtou8 (&prop_val[len -1 ],10 , &lane); +if (ret) +return ret; +if (in_range (lane,1 ,SDW_MAX_LANES -1 )) + prop->lane_maps[i] = lane; + } +return 0 ; +} +EXPORT_SYMBOL (sdw_slave_read_lane_mapping); +/** * sdw_slave_read_prop() - Read Slave properties * @slave: SDW Slave
@@ -486,6 +524,6 @@ int sdw_slave_read_prop(struct sdw_slave *slave)sdw_slave_read_dpn (slave, prop->sink_dpn_prop, nval, prop->sink_ports,"sink" ); -return 0 ; +return sdw_slave_read_lane_mapping (slave); }EXPORT_SYMBOL (sdw_slave_read_prop);
include/linux/soundwire/sdw.h +5 -0
@@ -46,6 +46,8 @@ struct sdw_slave;#define SDW_MAX_PORTS 15#define SDW_VALID_PORT_RANGE (n) ((n) < SDW_MAX_PORTS && (n) >= 1) +#define SDW_MAX_LANES 8 +enum {SDW_PORT_DIRN_SINK =0 ,SDW_PORT_DIRN_SOURCE ,
@@ -348,6 +350,7 @@ struct sdw_dpn_prop {* and masks are supported * @commit_register_supported: is PCP_Commit register supported * @scp_int1_mask: SCP_INT1_MASK desired settings +* @lane_maps: Lane mapping for the slave, only valid if lane_control_support is set * @clock_reg_supported: the Peripheral implements the clock base and scale * registers introduced with the SoundWire 1.2 specification. SDCA devices * do not need to set this boolean property as the registers are required.
@@ -377,6 +380,7 @@ struct sdw_slave_prop {u32 sdca_interrupt_register_list;u8 commit_register_supported;u8 scp_int1_mask; +u8 lane_maps[SDW_MAX_LANES ];bool clock_reg_supported;bool use_domain_irq; };
@@ -442,6 +446,7 @@ struct sdw_master_prop {int sdw_master_read_prop (struct sdw_bus *bus);int sdw_slave_read_prop (struct sdw_slave *slave); +int sdw_slave_read_lane_mapping (struct sdw_slave *slave);/* * SDW Slave Structures and APIs
Signature · 1 line
2.34.1
Bard Liao
maintainerPATCH 3/12 soundwire: add lane_used_bandwidth in struct sdw_bus
In reply to Bard LiaoTo support multi-lane, we need to know how much bandwidth is used on each lane. And to use the lane that has enough bandwidth.
--- include/linux/soundwire/sdw.h | 2 ++ 1 file changed, 2 insertions(+)
include/linux/soundwire/sdw.h +2 -0
@@ -889,6 +889,7 @@ struct sdw_master_ops {* @multi_link: Store bus property that indicates if multi links * are supported. This flag is populated by drivers after reading * appropriate firmware (ACPI/DT). +* @lane_used_bandwidth: how much bandwidth in bits per second is used by each lane */ struct sdw_bus {struct device *dev;
@@ -920,6 +921,7 @@ struct sdw_bus {struct dentry *debugfs;#endif bool multi_link; +unsigned int lane_used_bandwidth[SDW_MAX_LANES ]; }; int sdw_bus_master_add(struct sdw_bus *bus, struct device *parent,
Signature · 1 line
2.34.1
Bard Liao
maintainerPATCH 4/12 soundwire: stream: set DEPREPARED state earlier
In reply to Bard LiaoFrom: Pierre-Louis Bossart <[email protected]>
The existing logic is problematic in that we deprepare all the ports, but still take into account the stream for bit allocation by just walking through the bus->m_rt list.
This patch sets the state earlier, so that such DEPREPARED streams can be skipped in the bandwidth allocation (to be implemented in a follow-up patch).
--- drivers/soundwire/stream.c | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-)
drivers/soundwire/stream.c +10 -1
@@ -1643,8 +1643,15 @@ static int _sdw_deprepare_stream(struct sdw_stream_runtime *stream) {struct sdw_master_runtime *m_rt;struct sdw_bus *bus; +int state = stream->state;int ret =0 ; +/* +* first mark the state as DEPREPARED so that it is not taken into account +* for bit allocation +*/ + stream->state =SDW_STREAM_DEPREPARED ; +list_for_each_entry (m_rt, &stream->master_list, stream_node) { bus = m_rt->bus;/* De-prepare port(s) */
@@ -1652,6 +1659,7 @@ static int _sdw_deprepare_stream(struct sdw_stream_runtime *stream)if (ret <0 ) {dev_err (bus->dev,"De-prepare port(s) failed: %d\n" , ret); + stream->state = state;return ret; }
@@ -1665,6 +1673,7 @@ static int _sdw_deprepare_stream(struct sdw_stream_runtime *stream)if (ret <0 ) {dev_err (bus->dev,"Compute params failed: %d\n" , ret); + stream->state = state;return ret; } }
@@ -1673,11 +1682,11 @@ static int _sdw_deprepare_stream(struct sdw_stream_runtime *stream) ret =sdw_program_params (bus, false);if (ret <0 ) {dev_err (bus->dev,"%s: Program params failed: %d\n" , __func__, ret); + stream->state = state;return ret; } } - stream->state =SDW_STREAM_DEPREPARED ;return do_bank_switch (stream); }
Signature · 1 line
2.34.1
Bard Liao
maintainerPATCH 5/12 soundwire: generic_bandwidth_allocation: skip DEPREPARED streams
In reply to Bard LiaoFrom: Pierre-Louis Bossart <[email protected]>
We should not blindly walk through all the m_rt list, since it will have the side effect of accounting for deprepared streams.
This behavior is the result of the split implementation where the dailink hw_free() handles the stream state change and the bit allocation, and the dai hw_free() modifies the m_rt list. The bit allocation ends-up using m_rt entries in zombie state, no longer relevant but still used.
--- drivers/soundwire/generic_bandwidth_allocation.c | 3 +++ 1 file changed, 3 insertions(+)
drivers/soundwire/generic_bandwidth_allocation.c +3 -0
@@ -238,6 +238,9 @@ static int sdw_get_group_count(struct sdw_bus *bus,return -ENOMEM ; list_for_each_entry(m_rt, &bus->m_rt_list, bus_node) { + if (m_rt->stream->state == SDW_STREAM_DEPREPARED) + continue; + rate = m_rt->stream->params.rate; if (m_rt == list_first_entry(&bus->m_rt_list, struct sdw_master_runtime,
Signature · 1 line
2.34.1
Bard Liao
maintainerPATCH 6/12 Soundwire: add sdw_slave_get_scale_index helper
In reply to Bard LiaoCurrently, we only set peripheral frequency when the peripheral is initialized. However, curr_dr_freq may change to get required bandwidth. For example, curr_dr_freq may increase from 4.8MHz to 9.6MHz when the 4th stream is opened. Add a helper to get the scale index so that we can get the scale index and program it.
--- drivers/soundwire/bus.c | 55 ++++++++++++++++++++++------------- include/linux/soundwire/sdw.h | 2 ++ 2 files changed, 36 insertions(+), 21 deletions(-)
drivers/soundwire/bus.c +34 -21
@@ -1276,23 +1276,12 @@ int sdw_configure_dpn_intr(struct sdw_slave *slave,return ret; } -static int sdw_slave_set_frequency (struct sdw_slave *slave) +int sdw_slave_get_scale_index (struct sdw_slave *slave,u8 *base) {u32 mclk_freq = slave->bus->prop.mclk_freq;u32 curr_freq = slave->bus->params.curr_dr_freq >>1 ;unsigned int scale;u8 scale_index; -u8 base; -int ret; - -/* -* frequency base and scale registers are required for SDCA -* devices. They may also be used for 1.2+/non-SDCA devices. -* Driver can set the property, we will need a DisCo property -* to discover this case from platform firmware. -*/ -if (!slave->id.class_id && !slave->prop.clock_reg_supported) -return 0 ;if (!mclk_freq) { dev_err(&slave->dev,
@@ -1311,19 +1300,19 @@ static int sdw_slave_set_frequency(struct sdw_slave *slave)*/ if (!(19200000 % mclk_freq)) { mclk_freq =19200000 ; - base =SDW_SCP_BASE_CLOCK_19200000_HZ ; + *base =SDW_SCP_BASE_CLOCK_19200000_HZ ; }else if (!(22579200 % mclk_freq)) { mclk_freq =22579200 ; - base =SDW_SCP_BASE_CLOCK_22579200_HZ ; + *base =SDW_SCP_BASE_CLOCK_22579200_HZ ; }else if (!(24576000 % mclk_freq)) { mclk_freq =24576000 ; - base =SDW_SCP_BASE_CLOCK_24576000_HZ ; + *base =SDW_SCP_BASE_CLOCK_24576000_HZ ; }else if (!(32000000 % mclk_freq)) { mclk_freq =32000000 ; - base =SDW_SCP_BASE_CLOCK_32000000_HZ ; + *base =SDW_SCP_BASE_CLOCK_32000000_HZ ; }else if (!(96000000 % mclk_freq)) { mclk_freq =24000000 ; - base =SDW_SCP_BASE_CLOCK_24000000_HZ ; + *base =SDW_SCP_BASE_CLOCK_24000000_HZ ; }else { dev_err(&slave->dev, "Unsupported clock base, mclk %d\n",
@@ -1354,6 +1343,34 @@ static int sdw_slave_set_frequency(struct sdw_slave *slave) } scale_index++; +dev_dbg (&slave->dev, +"Configured bus base %d, scale %d, mclk %d, curr_freq %d\n" , + *base, scale_index, mclk_freq, curr_freq); + +return scale_index; +} +EXPORT_SYMBOL (sdw_slave_get_scale_index); + +static int sdw_slave_set_frequency (struct sdw_slave *slave) +{ +int scale_index; +u8 base; +int ret; + +/* +* frequency base and scale registers are required for SDCA +* devices. They may also be used for 1.2+/non-SDCA devices. +* Driver can set the property directly, for now there's no +* DisCo property to discover support for the scaling registers +* from platform firmware. +*/ +if (!slave->id.class_id && !slave->prop.clock_reg_supported) +return 0 ; + + scale_index =sdw_slave_get_scale_index (slave, &base); +if (scale_index <0 ) +return scale_index; + ret =sdw_write_no_pm (slave,SDW_SCP_BUS_CLOCK_BASE , base);if (ret <0 ) { dev_err(&slave->dev,
@@ -1373,10 +1390,6 @@ static int sdw_slave_set_frequency(struct sdw_slave *slave)dev_err (&slave->dev,"SDW_SCP_BUSCLOCK_SCALE_B1 write failed:%d\n" , ret); -dev_dbg (&slave->dev, -"Configured bus base %d, scale %d, mclk %d, curr_freq %d\n" , - base, scale_index, mclk_freq, curr_freq); -return ret; }
include/linux/soundwire/sdw.h +2 -0
@@ -1048,6 +1048,8 @@ int sdw_stream_add_slave(struct sdw_slave *slave,int sdw_stream_remove_slave (struct sdw_slave *slave,struct sdw_stream_runtime *stream); +int sdw_slave_get_scale_index (struct sdw_slave *slave,u8 *base); +/* messaging and data APIs */ int sdw_read (struct sdw_slave *slave,u32 addr);int sdw_write (struct sdw_slave *slave,u32 addr,u8 value);
Signature · 1 line
2.34.1
Bard Liao
maintainerPATCH 7/12 Soundwire: stream: program BUSCLOCK_SCALE
In reply to Bard LiaoWe need to program bus clock scale to adjust the bus clock if current bus clock doesn't fit the bandwidth.
--- drivers/soundwire/bus.c | 10 ++++++++++ drivers/soundwire/stream.c | 32 ++++++++++++++++++++++++++++++++ include/linux/soundwire/sdw.h | 1 + 3 files changed, 43 insertions(+)
drivers/soundwire/bus.c +10 -0
@@ -813,6 +813,16 @@ void sdw_extract_slave_id(struct sdw_bus *bus, }EXPORT_SYMBOL (sdw_extract_slave_id); +bool is_clock_scaling_supported_by_slave (struct sdw_slave *slave) +{ +/* +* Dynamic scaling is a defined by SDCA. However, some devices expose the class ID but +* can't support dynamic scaling. We might need a quirk to handle such devices. +*/ +return slave->id.class_id; +} +EXPORT_SYMBOL (is_clock_scaling_supported_by_slave); +static int sdw_program_device_num (struct sdw_bus *bus,bool *programmed) {u8 buf[SDW_NUM_DEV_ID_REGISTERS ] = {0 };
drivers/soundwire/stream.c +32 -0
@@ -629,8 +629,40 @@ static int sdw_notify_config(struct sdw_master_runtime *m_rt)static int sdw_program_params (struct sdw_bus *bus,bool prepare) {struct sdw_master_runtime *m_rt; +struct sdw_slave *slave;int ret =0 ; +u32 addr1; +/* Check if all Peripherals comply with SDCA */ +list_for_each_entry (slave, &bus->slaves, node) { +if (!is_clock_scaling_supported_by_slave (slave)) { +dev_dbg (&slave->dev,"The Peripheral doesn't comply with SDCA\n" ); + goto manager_runtime; + } + } + +if (bus->params.next_bank) + addr1 =SDW_SCP_BUSCLOCK_SCALE_B1 ; +else + addr1 =SDW_SCP_BUSCLOCK_SCALE_B0 ; + +/* Program SDW_SCP_BUSCLOCK_SCALE if all Peripherals comply with SDCA */ +list_for_each_entry (slave, &bus->slaves, node) { +int scale_index; +u8 base; + + scale_index =sdw_slave_get_scale_index (slave, &base); +if (scale_index <0 ) +return scale_index; + + ret =sdw_write_no_pm (slave, addr1, scale_index); +if (ret <0 ) { +dev_err (&slave->dev,"SDW_SCP_BUSCLOCK_SCALE register write failed\n" ); +return ret; + } + } + +manager_runtime:list_for_each_entry (m_rt, &bus->m_rt_list, bus_node) {/*
include/linux/soundwire/sdw.h +1 -0
@@ -1037,6 +1037,7 @@ int sdw_bus_exit_clk_stop(struct sdw_bus *bus);int sdw_compare_devid (struct sdw_slave *slave,struct sdw_slave_id id);void sdw_extract_slave_id (struct sdw_bus *bus,u64 addr,struct sdw_slave_id *id); +bool is_clock_scaling_supported_by_slave (struct sdw_slave *slave);#if IS_ENABLED (CONFIG_SOUNDWIRE )
Signature · 1 line
2.34.1
Bard Liao
maintainerPATCH 8/12 Soundwire: generic_bandwidth_allocation: set frame shape on fly
In reply to Bard LiaoWe need to recalculate frame shape when sdw bus clock is changed. And need to make sure all Peripherals connected to the Manager support dynamic clock change.
--- .../soundwire/generic_bandwidth_allocation.c | 23 +++++++++++++++++++ 1 file changed, 23 insertions(+)
drivers/soundwire/generic_bandwidth_allocation.c +23 -0
@@ -327,6 +327,19 @@ static int sdw_select_row_col(struct sdw_bus *bus, int clk_freq)return -EINVAL ; } +static bool is_clock_scaling_supported (struct sdw_bus *bus) +{ +struct sdw_master_runtime *m_rt; +struct sdw_slave_runtime *s_rt; + +list_for_each_entry (m_rt, &bus->m_rt_list, bus_node) +list_for_each_entry (s_rt, &m_rt->slave_rt_list, m_rt_node) +if (!is_clock_scaling_supported_by_slave (s_rt->slave)) +return false; + +return true; +} +/** * sdw_compute_bus_params: Compute bus parameters *
@@ -352,6 +365,10 @@ static int sdw_compute_bus_params(struct sdw_bus *bus) clk_buf =NULL ; } +/* If dynamic scaling is not supported, don't try higher freq */ +if (!is_clock_scaling_supported (bus)) + clk_values =1 ; +for (i =0 ; i < clk_values; i++) {if (!clk_buf) curr_dr_freq = bus->params.max_dr_freq;
@@ -378,6 +395,12 @@ static int sdw_compute_bus_params(struct sdw_bus *bus)return -EINVAL ; } +if (!mstr_prop->default_frame_rate || !mstr_prop->default_row) +return -EINVAL ; + + mstr_prop->default_col = curr_dr_freq / mstr_prop->default_frame_rate / + mstr_prop->default_row; + ret =sdw_select_row_col (bus, curr_dr_freq);if (ret <0 ) { dev_err(bus->dev, "%s: could not find frame configuration for bus dr_freq %d\n",
Signature · 1 line
2.34.1
Bard Liao
maintainerPATCH 9/12 soundwire: generic_bandwidth_allocation: correct clk_freq check in sdw_select_row_col
In reply to Bard LiaoThe bits in Column 0 of Rows 0 to 47 are for control word and cannot be used for audio. In practice, entire Column 0 is skipped.
--- drivers/soundwire/generic_bandwidth_allocation.c | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-)
drivers/soundwire/generic_bandwidth_allocation.c +2 -6
@@ -302,7 +302,6 @@ static int sdw_compute_port_params(struct sdw_bus *bus)static int sdw_select_row_col (struct sdw_bus *bus,int clk_freq) {struct sdw_master_prop *prop = &bus->prop; -int frame_int, frame_freq;int r, c;for (c =0 ; c <SDW_FRAME_COLS ; c++) {
@@ -311,11 +310,8 @@ static int sdw_select_row_col(struct sdw_bus *bus, int clk_freq) sdw_cols[c] != prop->default_col)continue ; - frame_int = sdw_rows[r] * sdw_cols[c]; - frame_freq = clk_freq / frame_int; - -if ((clk_freq - (frame_freq *SDW_FRAME_CTRL_BITS )) < - bus->params.bandwidth) +if (clk_freq * (sdw_cols[c] -1 ) < + bus->params.bandwidth * sdw_cols[c])continue ; bus->params.row = sdw_rows[r];
Signature · 1 line
2.34.1
Bard Liao
maintainerPATCH 10/12 soundwire: generic_bandwidth_allocation: check required freq accurately
In reply to Bard LiaoCurrently, we check curr_dr_freq roughly by "if (curr_dr_freq <= bus->params.bandwidth)" in sdw_compute_bus_params() and check it accurately in sdw_select_row_col(). It works if we only support one freq. But, we need to check it accurately in sdw_select_row_col() to give it a chance to use a higher freq or use multi-lane.
--- drivers/soundwire/generic_bandwidth_allocation.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/soundwire/generic_bandwidth_allocation.c +2 -1
@@ -373,7 +373,8 @@ static int sdw_compute_bus_params(struct sdw_bus *bus) (bus->params.max_dr_freq >> clk_buf[i]) : clk_buf[i] *SDW_DOUBLE_RATE_FACTOR ; -if (curr_dr_freq <= bus->params.bandwidth) +if (curr_dr_freq * (mstr_prop->default_col -1 ) < + bus->params.bandwidth * mstr_prop->default_col)continue ;break ;
Signature · 1 line
2.34.1
Bard Liao
maintainerPATCH 11/12 soundwire: generic_bandwidth_allocation: select data lane
In reply to Bard LiaoIf a peripheral supports multi-lane, we can use data lane x to extend the bandwidth. The patch suggests to select data lane x where x > 0 when bandwidth is not enough on data lane 0.
--- .../soundwire/generic_bandwidth_allocation.c | 133 +++++++++++++++++- drivers/soundwire/stream.c | 20 ++- 2 files changed, 146 insertions(+), 7 deletions(-)
drivers/soundwire/generic_bandwidth_allocation.c +128 -5
@@ -336,6 +336,82 @@ static bool is_clock_scaling_supported(struct sdw_bus *bus)return true; } +/** +* is_lane_connected_to_all_peripherals: Check if the given manager lane connects to all peripherals +* So that all peripherals can use the manager lane. +* +* @m_rt: Manager runtime +* @lane: Lane number +*/ +static bool is_lane_connected_to_all_peripherals (struct sdw_master_runtime *m_rt,unsigned int lane) +{ +struct sdw_slave_prop *slave_prop; +struct sdw_slave_runtime *s_rt; +int i; + +list_for_each_entry (s_rt, &m_rt->slave_rt_list, m_rt_node) { + slave_prop = &s_rt->slave->prop; +for (i =1 ; i <SDW_MAX_LANES ; i++) { +if (slave_prop->lane_maps[i] == lane) { +dev_dbg (&s_rt->slave->dev, +"M lane %d is connected to P lane %d\n" , + lane, i); +break ; + } + } +if (i ==SDW_MAX_LANES ) { +dev_dbg (&s_rt->slave->dev,"M lane %d is not connected\n" , lane); +return false; + } + } +return true; +} + +static int get_manager_lane (struct sdw_bus *bus,struct sdw_master_runtime *m_rt, +struct sdw_slave_runtime *s_rt,unsigned int curr_dr_freq) +{ +struct sdw_slave_prop *slave_prop = &s_rt->slave->prop; +struct sdw_port_runtime *m_p_rt; +unsigned int required_bandwidth; +int m_lane; +int l; + +for (l =1 ; l <SDW_MAX_LANES ; l++) { +if (!slave_prop->lane_maps[l]) +continue ; + + required_bandwidth =0 ; +list_for_each_entry (m_p_rt, &m_rt->port_list, port_node) { + required_bandwidth += m_rt->stream->params.rate * +hweight32 (m_p_rt->ch_mask) * + m_rt->stream->params.bps; + } +if (required_bandwidth <= + curr_dr_freq - bus->lane_used_bandwidth[l]) { +/* Check if m_lane is connected to all Peripherals */ +if (!is_lane_connected_to_all_peripherals (m_rt, + slave_prop->lane_maps[l])) { +dev_dbg (bus->dev, +"Not all Peripherals are connected to M lane %d\n" , + slave_prop->lane_maps[l]); +continue ; + } + m_lane = slave_prop->lane_maps[l]; +dev_dbg (&s_rt->slave->dev,"M lane %d is used\n" , m_lane); + bus->lane_used_bandwidth[l] += required_bandwidth; +/* +* Use non-zero manager lane, subtract the lane 0 +* bandwidth that is already calculated +*/ + bus->params.bandwidth -= required_bandwidth; +return m_lane; + } + } + +/* No available multi lane found, only lane 0 can be used */ +return 0 ; +} +/** * sdw_compute_bus_params: Compute bus parameters *
@@ -343,10 +419,16 @@ static bool is_clock_scaling_supported(struct sdw_bus *bus)*/ static int sdw_compute_bus_params (struct sdw_bus *bus) { -unsigned int curr_dr_freq =0 ;struct sdw_master_prop *mstr_prop = &bus->prop; -int i, clk_values, ret; +struct sdw_slave_prop *slave_prop; +struct sdw_port_runtime *m_p_rt; +struct sdw_port_runtime *s_p_rt; +struct sdw_master_runtime *m_rt; +struct sdw_slave_runtime *s_rt; +unsigned int curr_dr_freq =0 ; +int i, l, clk_values, ret;bool is_gear = false; +int m_lane =0 ;u32 *clk_buf;if (mstr_prop->num_clk_gears) {
@@ -373,11 +455,26 @@ static int sdw_compute_bus_params(struct sdw_bus *bus) (bus->params.max_dr_freq >> clk_buf[i]) : clk_buf[i] *SDW_DOUBLE_RATE_FACTOR ; -if (curr_dr_freq * (mstr_prop->default_col -1 ) < +if (curr_dr_freq * (mstr_prop->default_col -1 ) >= bus->params.bandwidth * mstr_prop->default_col) -continue ; +break ; -break ; +list_for_each_entry (m_rt, &bus->m_rt_list, bus_node) { +/* +* Get the first s_rt that will be used to find the available lane that +* can be used. No need to check all Peripherals because we can't use +* multi-lane if we can't find any available lane for the first Peripheral. +*/ + s_rt =list_first_entry (&m_rt->slave_rt_list, + struct sdw_slave_runtime, m_rt_node); + +/* +* Find the available Manager lane that connected to the first Peripheral. +*/ + m_lane =get_manager_lane (bus, m_rt, s_rt, curr_dr_freq); +if (m_lane >0 ) + goto out; + }/* * TODO: Check all the Slave(s) port(s) audio modes and find
@@ -391,6 +488,32 @@ static int sdw_compute_bus_params(struct sdw_bus *bus) __func__, bus->params.bandwidth);return -EINVAL ; } +out: +/* multilane can be used */ +if (m_lane >0 ) { +/* Set Peripheral lanes */ +list_for_each_entry (s_rt, &m_rt->slave_rt_list, m_rt_node) { + slave_prop = &s_rt->slave->prop; +for (l =1 ; l <SDW_MAX_LANES ; l++) { +if (slave_prop->lane_maps[l] == m_lane) { +list_for_each_entry (s_p_rt, &s_rt->port_list, port_node) { + s_p_rt->lane = l; +dev_dbg (&s_rt->slave->dev, +"Set P lane %d for port %d\n" , + l, s_p_rt->num); + } +break ; + } + } + } +/* +* Set Manager lanes. Configure the last m_rt in bus->m_rt_list only since +* we don't want to touch other m_rts that are already working. +*/ +list_for_each_entry (m_p_rt, &m_rt->port_list, port_node) { + m_p_rt->lane = m_lane; + } + }if (!mstr_prop->default_frame_rate || !mstr_prop->default_row)return -EINVAL ;
drivers/soundwire/stream.c +18 -2
@@ -1674,6 +1674,9 @@ EXPORT_SYMBOL(sdw_disable_stream);static int _sdw_deprepare_stream (struct sdw_stream_runtime *stream) {struct sdw_master_runtime *m_rt; +struct sdw_port_runtime *p_rt; +unsigned int multi_lane_bandwidth; +unsigned int bandwidth;struct sdw_bus *bus;int state = stream->state;int ret =0 ;
@@ -1695,9 +1698,22 @@ static int _sdw_deprepare_stream(struct sdw_stream_runtime *stream)return ret; } + multi_lane_bandwidth =0 ; + +list_for_each_entry (p_rt, &m_rt->port_list, port_node) { +if (!p_rt->lane) +continue ; + + bandwidth = m_rt->stream->params.rate *hweight32 (p_rt->ch_mask) * + m_rt->stream->params.bps; + multi_lane_bandwidth += bandwidth; + bus->lane_used_bandwidth[p_rt->lane] -= bandwidth; +if (!bus->lane_used_bandwidth[p_rt->lane]) + p_rt->lane =0 ; + }/* TODO: Update this during Device-Device support */ - bus->params.bandwidth -= m_rt->stream->params.rate * - m_rt->ch_count * m_rt->stream->params.bps; + bandwidth = m_rt->stream->params.rate * m_rt->ch_count * m_rt->stream->params.bps; + bus->params.bandwidth -= bandwidth - multi_lane_bandwidth;/* Compute params */ if (bus->compute_params) {
Signature · 1 line
2.34.1
Bard Liao
maintainerPATCH 12/12 soundwire: generic_bandwidth_allocation: add lane in sdw_group_params
In reply to Bard LiaoAll active streams with the same parameters are grouped together and the params are stored in the sdw_group struct. We compute the required bandwidth for each group. However, each lane has individual bandwidth. Therefore, we should separate different lanes in different params groups. Add lane variable to separate params groups.
--- drivers/soundwire/bus.h | 1 + .../soundwire/generic_bandwidth_allocation.c | 122 +++++++++++++----- 2 files changed, 90 insertions(+), 33 deletions(-)
drivers/soundwire/bus.h +1 -0
@@ -151,6 +151,7 @@ struct sdw_transport_data {int hstop;int block_offset;int sub_block_offset; +unsigned int lane; }; struct sdw_dpn_prop *sdw_get_slave_dpn_prop(struct sdw_slave *slave,
drivers/soundwire/generic_bandwidth_allocation.c +89 -33
241 lines not on this page · raw message
Signature · 1 line
2.34.1