[PATCH v3 5/5] soundwire: stream: Fix bandwidth leak in multi-link aggregation failure
From: Bard Liao
Date: Thu Nov 12 2026 - 09:31:15 EST
From: David Lin <david.lin@xxxxxxxxx>
When preparing a multi-link aggregation stream, a failure on a subsequent
link during _sdw_prepare_stream() causes the stream preparation to fail.
However, the bandwidth allocated on the preceding successful links is never
released, causing a cumulative bandwidth leak.
Fix this by saving a snapshot of each bus's parameters before making any
modifications. In case of failure, we iterate through the stream's master
list and restore each bus to its original parameter state, ensuring an
atomic rollback and preventing any bandwidth leaks.
The lane assignments are stored in the port runtimes rather than in
bus->params, so they are not restored with the snapshot. Reset the lanes of
the stream to 0 during the rollback so that they match the restored
lane_used_bandwidth. Otherwise, the stale lanes would be used by the port
computation of other streams on the same bus. Skip this when the parameters
were not updated, as the lanes are still valid in that case.
A previous prepare can also leave a stale lane behind, because
_sdw_deprepare_stream() resets p_rt->lane only when the lane's used
bandwidth drops to zero. Reset the lanes of the stream being prepared in
sdw_compute_bus_params() when no multi-lane is selected.
Keep curr_bank and next_bank when restoring the snapshot. The failure may
happen after the register bank has already been switched, and restoring the
old values would make them differ from the hardware.
Fixes: 7a30292ffa2a ("soundwire: generic_bandwidth_allocation: select data lane")
Cc: stable@xxxxxxxxxxxxxxx
Signed-off-by: David Lin <david.lin@xxxxxxxxx>
Co-developed-by: Bard Liao <yung-chuan.liao@xxxxxxxxxxxxxxx>
Signed-off-by: Bard Liao <yung-chuan.liao@xxxxxxxxxxxxxxx>
Reviewed-by: Péter Ujfalusi <peter.ujfalusi@xxxxxxxxxxxxxxx>
---
drivers/soundwire/bus.h | 3 ++
.../soundwire/generic_bandwidth_allocation.c | 14 +++++++
drivers/soundwire/stream.c | 40 +++++++++++++++++--
3 files changed, 53 insertions(+), 4 deletions(-)
diff --git a/drivers/soundwire/bus.h b/drivers/soundwire/bus.h
index 44e4f5193917..476387b70472 100644
--- a/drivers/soundwire/bus.h
+++ b/drivers/soundwire/bus.h
@@ -155,6 +155,8 @@ struct sdw_slave_runtime {
*
* @bus: Bus handle
* @stream: Stream runtime handle
+ * @params_backup: Snapshot of original bus parameters saved before stream
+ * preparation, used for rollback recovery on failure.
* @direction: Data direction for Master
* @ch_count: Number of channels handled by the Master for
* this stream, can be zero.
@@ -166,6 +168,7 @@ struct sdw_slave_runtime {
struct sdw_master_runtime {
struct sdw_bus *bus;
struct sdw_stream_runtime *stream;
+ struct sdw_bus_params params_backup;
enum sdw_data_direction direction;
unsigned int ch_count;
struct list_head slave_rt_list;
diff --git a/drivers/soundwire/generic_bandwidth_allocation.c b/drivers/soundwire/generic_bandwidth_allocation.c
index 9bacde2c67a1..214a1be6c33e 100644
--- a/drivers/soundwire/generic_bandwidth_allocation.c
+++ b/drivers/soundwire/generic_bandwidth_allocation.c
@@ -656,6 +656,20 @@ static int sdw_compute_bus_params(struct sdw_bus *bus,
list_for_each_entry(m_p_rt, &m_rt->port_list, port_node) {
m_p_rt->lane = m_lane;
}
+ } else if (prepare) {
+ /* Clear stale lane assignments when preparing on lane 0. */
+ list_for_each_entry(m_rt, &bus->m_rt_list, bus_node) {
+ if (m_rt->stream != stream)
+ continue;
+
+ list_for_each_entry(m_p_rt, &m_rt->port_list, port_node)
+ m_p_rt->lane = 0;
+
+ list_for_each_entry(s_rt, &m_rt->slave_rt_list, m_rt_node)
+ list_for_each_entry(s_p_rt, &s_rt->port_list, port_node)
+ s_p_rt->lane = 0;
+ break;
+ }
}
if (!mstr_prop->default_frame_rate || !mstr_prop->default_row)
diff --git a/drivers/soundwire/stream.c b/drivers/soundwire/stream.c
index 06f051f03a21..bc0e2d5eaf0c 100644
--- a/drivers/soundwire/stream.c
+++ b/drivers/soundwire/stream.c
@@ -1477,21 +1477,26 @@ static int _sdw_prepare_stream(struct sdw_stream_runtime *stream,
bool update_params)
{
struct sdw_master_runtime *m_rt;
+ struct sdw_slave_runtime *s_rt;
+ struct sdw_port_runtime *p_rt;
struct sdw_bus *bus;
struct sdw_master_prop *prop;
- struct sdw_bus_params params;
int ret;
+ /* Pre-pass: snapshot original bus parameters for all masters */
+ list_for_each_entry(m_rt, &stream->master_list, stream_node)
+ m_rt->params_backup = m_rt->bus->params;
+
/* Prepare Master(s) and Slave(s) port(s) associated with stream */
list_for_each_entry(m_rt, &stream->master_list, stream_node) {
bus = m_rt->bus;
prop = &bus->prop;
- memcpy(¶ms, &bus->params, sizeof(params));
/* TODO: Support Asynchronous mode */
if ((prop->max_clk_freq % stream->params.rate) != 0) {
dev_err(bus->dev, "Async mode not supported\n");
- return -EINVAL;
+ ret = -EINVAL;
+ goto restore_params;
}
if (update_params) {
@@ -1542,7 +1547,34 @@ static int _sdw_prepare_stream(struct sdw_stream_runtime *stream,
return ret;
restore_params:
- memcpy(&bus->params, ¶ms, sizeof(params));
+ /*
+ * Revert all managers to their snapshotted original parameters.
+ * Any manager that was not modified will safely revert to its own original state.
+ */
+ list_for_each_entry(m_rt, &stream->master_list, stream_node) {
+ enum sdw_reg_bank curr_bank = m_rt->bus->params.curr_bank;
+ enum sdw_reg_bank next_bank = m_rt->bus->params.next_bank;
+
+ m_rt->bus->params = m_rt->params_backup;
+ /* The hardware bank may already have been switched */
+ m_rt->bus->params.curr_bank = curr_bank;
+ m_rt->bus->params.next_bank = next_bank;
+
+ /*
+ * The lane_used_bandwidth of this stream was reverted above, so clear its
+ * lanes too; a stale lane would be used by other streams' port computation.
+ */
+ if (!update_params)
+ continue;
+
+ list_for_each_entry(p_rt, &m_rt->port_list, port_node)
+ p_rt->lane = 0;
+
+ list_for_each_entry(s_rt, &m_rt->slave_rt_list, m_rt_node)
+ list_for_each_entry(p_rt, &s_rt->port_list, port_node)
+ p_rt->lane = 0;
+ }
+
return ret;
}
--
2.43.0