Skip to content

L
linux
Commit 6f76e791 authored by Krzysztof Kozlowski's avatar Krzysztof Kozlowski Committed by Vinod Koul
Browse files
Options

soundwire: qcom: use consistently 'ctrl' as state variable name 

The pointer to 'struct qcom_swrm_ctrl' was called sometimes 'swrm' and
sometimes 'ctrl' variable.  Choose one - 'ctrl' - so the code will be
consistent and easier to read.

No functional change.
Reviewed-by: default avatarSrinivas Kandagagatla <srinivas.kandagatla@linaro.org>
Tested-by: default avatarSrinivas Kandagagatla <srinivas.kandagatla@linaro.org>
Reviewed-by: default avatarKonrad Dybcio <konrad.dybcio@linaro.org>
Signed-off-by: default avatarKrzysztof Kozlowski <krzysztof.kozlowski@linaro.org>
Link: https://lore.kernel.org/r/20230418095447.577001-5-krzysztof.kozlowski@linaro.orgSigned-off-by: default avatarVinod Koul <vkoul@kernel.org>
parent a8dffaa0
Show whitespace changes
Inline Side-by-side
Showing with 84 additions and 84 deletions
drivers/soundwire/qcom.c
View file @ 6f76e791
...@@ -279,14 +279,14 @@ static u32 swrm_get_packed_reg_val(u8 *cmd_id, u8 cmd_data, ...@@ -279,14 +279,14 @@ static u32 swrm_get_packed_reg_val(u8 *cmd_id, u8 cmd_data,
return val; return val;
} }
static int swrm_wait_for_rd_fifo_avail(struct qcom_swrm_ctrl *swrm) static int swrm_wait_for_rd_fifo_avail(struct qcom_swrm_ctrl *ctrl)
{ {
u32 fifo_outstanding_data, value; u32 fifo_outstanding_data, value;
int fifo_retry_count = SWR_OVERFLOW_RETRY_COUNT; int fifo_retry_count = SWR_OVERFLOW_RETRY_COUNT;
do { do {
/* Check for fifo underflow during read */ /* Check for fifo underflow during read */
swrm->reg_read(swrm, SWRM_CMD_FIFO_STATUS, &value); ctrl->reg_read(ctrl, SWRM_CMD_FIFO_STATUS, &value);
fifo_outstanding_data = FIELD_GET(SWRM_RD_CMD_FIFO_CNT_MASK, value); fifo_outstanding_data = FIELD_GET(SWRM_RD_CMD_FIFO_CNT_MASK, value);
/* Check if read data is available in read fifo */ /* Check if read data is available in read fifo */
...@@ -297,39 +297,39 @@ static int swrm_wait_for_rd_fifo_avail(struct qcom_swrm_ctrl *swrm) ...@@ -297,39 +297,39 @@ static int swrm_wait_for_rd_fifo_avail(struct qcom_swrm_ctrl *swrm)
} while (fifo_retry_count--); } while (fifo_retry_count--);
if (fifo_outstanding_data == 0) { if (fifo_outstanding_data == 0) {
dev_err_ratelimited(swrm->dev, "%s err read underflow\n", __func__); dev_err_ratelimited(ctrl->dev, "%s err read underflow\n", __func__);
return -EIO; return -EIO;
} }
return 0; return 0;
} }
static int swrm_wait_for_wr_fifo_avail(struct qcom_swrm_ctrl *swrm) static int swrm_wait_for_wr_fifo_avail(struct qcom_swrm_ctrl *ctrl)
{ {
u32 fifo_outstanding_cmds, value; u32 fifo_outstanding_cmds, value;
int fifo_retry_count = SWR_OVERFLOW_RETRY_COUNT; int fifo_retry_count = SWR_OVERFLOW_RETRY_COUNT;
do { do {
/* Check for fifo overflow during write */ /* Check for fifo overflow during write */
swrm->reg_read(swrm, SWRM_CMD_FIFO_STATUS, &value); ctrl->reg_read(ctrl, SWRM_CMD_FIFO_STATUS, &value);
fifo_outstanding_cmds = FIELD_GET(SWRM_WR_CMD_FIFO_CNT_MASK, value); fifo_outstanding_cmds = FIELD_GET(SWRM_WR_CMD_FIFO_CNT_MASK, value);
/* Check for space in write fifo before writing */ /* Check for space in write fifo before writing */
if (fifo_outstanding_cmds < swrm->wr_fifo_depth) if (fifo_outstanding_cmds < ctrl->wr_fifo_depth)
return 0; return 0;
usleep_range(500, 510); usleep_range(500, 510);
} while (fifo_retry_count--); } while (fifo_retry_count--);
if (fifo_outstanding_cmds == swrm->wr_fifo_depth) { if (fifo_outstanding_cmds == ctrl->wr_fifo_depth) {
dev_err_ratelimited(swrm->dev, "%s err write overflow\n", __func__); dev_err_ratelimited(ctrl->dev, "%s err write overflow\n", __func__);
return -EIO; return -EIO;
} }
return 0; return 0;
} }
static int qcom_swrm_cmd_fifo_wr_cmd(struct qcom_swrm_ctrl *swrm, u8 cmd_data, static int qcom_swrm_cmd_fifo_wr_cmd(struct qcom_swrm_ctrl *ctrl, u8 cmd_data,
u8 dev_addr, u16 reg_addr) u8 dev_addr, u16 reg_addr)
{ {
...@@ -342,20 +342,20 @@ static int qcom_swrm_cmd_fifo_wr_cmd(struct qcom_swrm_ctrl *swrm, u8 cmd_data, ...@@ -342,20 +342,20 @@ static int qcom_swrm_cmd_fifo_wr_cmd(struct qcom_swrm_ctrl *swrm, u8 cmd_data,
val = swrm_get_packed_reg_val(&cmd_id, cmd_data, val = swrm_get_packed_reg_val(&cmd_id, cmd_data,
dev_addr, reg_addr); dev_addr, reg_addr);
} else { } else {
val = swrm_get_packed_reg_val(&swrm->wcmd_id, cmd_data, val = swrm_get_packed_reg_val(&ctrl->wcmd_id, cmd_data,
dev_addr, reg_addr); dev_addr, reg_addr);
} }
if (swrm_wait_for_wr_fifo_avail(swrm)) if (swrm_wait_for_wr_fifo_avail(ctrl))
return SDW_CMD_FAIL_OTHER; return SDW_CMD_FAIL_OTHER;
if (cmd_id == SWR_BROADCAST_CMD_ID) if (cmd_id == SWR_BROADCAST_CMD_ID)
reinit_completion(&swrm->broadcast); reinit_completion(&ctrl->broadcast);
/* Its assumed that write is okay as we do not get any status back */ /* Its assumed that write is okay as we do not get any status back */
swrm->reg_write(swrm, SWRM_CMD_FIFO_WR_CMD, val); ctrl->reg_write(ctrl, SWRM_CMD_FIFO_WR_CMD, val);
if (swrm->version <= SWRM_VERSION_1_3_0) if (ctrl->version <= SWRM_VERSION_1_3_0)
usleep_range(150, 155); usleep_range(150, 155);
if (cmd_id == SWR_BROADCAST_CMD_ID) { if (cmd_id == SWR_BROADCAST_CMD_ID) {
...@@ -363,7 +363,7 @@ static int qcom_swrm_cmd_fifo_wr_cmd(struct qcom_swrm_ctrl *swrm, u8 cmd_data, ...@@ -363,7 +363,7 @@ static int qcom_swrm_cmd_fifo_wr_cmd(struct qcom_swrm_ctrl *swrm, u8 cmd_data,
* sleep for 10ms for MSM soundwire variant to allow broadcast * sleep for 10ms for MSM soundwire variant to allow broadcast
* command to complete. * command to complete.
*/ */
ret = wait_for_completion_timeout(&swrm->broadcast, ret = wait_for_completion_timeout(&ctrl->broadcast,
msecs_to_jiffies(TIMEOUT_MS)); msecs_to_jiffies(TIMEOUT_MS));
if (!ret) if (!ret)
ret = SDW_CMD_IGNORED; ret = SDW_CMD_IGNORED;
...@@ -376,41 +376,41 @@ static int qcom_swrm_cmd_fifo_wr_cmd(struct qcom_swrm_ctrl *swrm, u8 cmd_data, ...@@ -376,41 +376,41 @@ static int qcom_swrm_cmd_fifo_wr_cmd(struct qcom_swrm_ctrl *swrm, u8 cmd_data,
return ret; return ret;
} }
static int qcom_swrm_cmd_fifo_rd_cmd(struct qcom_swrm_ctrl *swrm, static int qcom_swrm_cmd_fifo_rd_cmd(struct qcom_swrm_ctrl *ctrl,
u8 dev_addr, u16 reg_addr, u8 dev_addr, u16 reg_addr,
u32 len, u8 *rval) u32 len, u8 *rval)
{ {
u32 cmd_data, cmd_id, val, retry_attempt = 0; u32 cmd_data, cmd_id, val, retry_attempt = 0;
val = swrm_get_packed_reg_val(&swrm->rcmd_id, len, dev_addr, reg_addr); val = swrm_get_packed_reg_val(&ctrl->rcmd_id, len, dev_addr, reg_addr);
/* /*
* Check for outstanding cmd wrt. write fifo depth to avoid * Check for outstanding cmd wrt. write fifo depth to avoid
* overflow as read will also increase write fifo cnt. * overflow as read will also increase write fifo cnt.
*/ */
swrm_wait_for_wr_fifo_avail(swrm); swrm_wait_for_wr_fifo_avail(ctrl);
/* wait for FIFO RD to complete to avoid overflow */ /* wait for FIFO RD to complete to avoid overflow */
usleep_range(100, 105); usleep_range(100, 105);
swrm->reg_write(swrm, SWRM_CMD_FIFO_RD_CMD, val); ctrl->reg_write(ctrl, SWRM_CMD_FIFO_RD_CMD, val);
/* wait for FIFO RD CMD complete to avoid overflow */ /* wait for FIFO RD CMD complete to avoid overflow */
usleep_range(250, 255); usleep_range(250, 255);
if (swrm_wait_for_rd_fifo_avail(swrm)) if (swrm_wait_for_rd_fifo_avail(ctrl))
return SDW_CMD_FAIL_OTHER; return SDW_CMD_FAIL_OTHER;
do { do {
swrm->reg_read(swrm, SWRM_CMD_FIFO_RD_FIFO_ADDR, &cmd_data); ctrl->reg_read(ctrl, SWRM_CMD_FIFO_RD_FIFO_ADDR, &cmd_data);
rval[0] = cmd_data & 0xFF; rval[0] = cmd_data & 0xFF;
cmd_id = FIELD_GET(SWRM_RD_FIFO_CMD_ID_MASK, cmd_data); cmd_id = FIELD_GET(SWRM_RD_FIFO_CMD_ID_MASK, cmd_data);
if (cmd_id != swrm->rcmd_id) { if (cmd_id != ctrl->rcmd_id) {
if (retry_attempt < (MAX_FIFO_RD_RETRY - 1)) { if (retry_attempt < (MAX_FIFO_RD_RETRY - 1)) {
/* wait 500 us before retry on fifo read failure */ /* wait 500 us before retry on fifo read failure */
usleep_range(500, 505); usleep_range(500, 505);
swrm->reg_write(swrm, SWRM_CMD_FIFO_CMD, ctrl->reg_write(ctrl, SWRM_CMD_FIFO_CMD,
SWRM_CMD_FIFO_FLUSH); SWRM_CMD_FIFO_FLUSH);
swrm->reg_write(swrm, SWRM_CMD_FIFO_RD_CMD, val); ctrl->reg_write(ctrl, SWRM_CMD_FIFO_RD_CMD, val);
} }
retry_attempt++; retry_attempt++;
} else { } else {
...@@ -419,9 +419,9 @@ static int qcom_swrm_cmd_fifo_rd_cmd(struct qcom_swrm_ctrl *swrm, ...@@ -419,9 +419,9 @@ static int qcom_swrm_cmd_fifo_rd_cmd(struct qcom_swrm_ctrl *swrm,
} while (retry_attempt < MAX_FIFO_RD_RETRY); } while (retry_attempt < MAX_FIFO_RD_RETRY);
dev_err(swrm->dev, "failed to read fifo: reg: 0x%x, rcmd_id: 0x%x,\ dev_err(ctrl->dev, "failed to read fifo: reg: 0x%x, rcmd_id: 0x%x,\
dev_num: 0x%x, cmd_data: 0x%x\n", dev_num: 0x%x, cmd_data: 0x%x\n",
reg_addr, swrm->rcmd_id, dev_addr, cmd_data); reg_addr, ctrl->rcmd_id, dev_addr, cmd_data);
return SDW_CMD_IGNORED; return SDW_CMD_IGNORED;
} }
...@@ -533,39 +533,39 @@ static int qcom_swrm_enumerate(struct sdw_bus *bus) ...@@ -533,39 +533,39 @@ static int qcom_swrm_enumerate(struct sdw_bus *bus)
static irqreturn_t qcom_swrm_wake_irq_handler(int irq, void *dev_id) static irqreturn_t qcom_swrm_wake_irq_handler(int irq, void *dev_id)
{ {
struct qcom_swrm_ctrl *swrm = dev_id; struct qcom_swrm_ctrl *ctrl = dev_id;
int ret; int ret;
ret = pm_runtime_resume_and_get(swrm->dev); ret = pm_runtime_resume_and_get(ctrl->dev);
if (ret < 0 && ret != -EACCES) { if (ret < 0 && ret != -EACCES) {
dev_err_ratelimited(swrm->dev, dev_err_ratelimited(ctrl->dev,
"pm_runtime_resume_and_get failed in %s, ret %d\n", "pm_runtime_resume_and_get failed in %s, ret %d\n",
__func__, ret); __func__, ret);
return ret; return ret;
} }
if (swrm->wake_irq > 0) { if (ctrl->wake_irq > 0) {
if (!irqd_irq_disabled(irq_get_irq_data(swrm->wake_irq))) if (!irqd_irq_disabled(irq_get_irq_data(ctrl->wake_irq)))
disable_irq_nosync(swrm->wake_irq); disable_irq_nosync(ctrl->wake_irq);
} }
pm_runtime_mark_last_busy(swrm->dev); pm_runtime_mark_last_busy(ctrl->dev);
pm_runtime_put_autosuspend(swrm->dev); pm_runtime_put_autosuspend(ctrl->dev);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
static irqreturn_t qcom_swrm_irq_handler(int irq, void *dev_id) static irqreturn_t qcom_swrm_irq_handler(int irq, void *dev_id)
{ {
struct qcom_swrm_ctrl *swrm = dev_id; struct qcom_swrm_ctrl *ctrl = dev_id;
u32 value, intr_sts, intr_sts_masked, slave_status; u32 value, intr_sts, intr_sts_masked, slave_status;
u32 i; u32 i;
int devnum; int devnum;
int ret = IRQ_HANDLED; int ret = IRQ_HANDLED;
clk_prepare_enable(swrm->hclk); clk_prepare_enable(ctrl->hclk);
swrm->reg_read(swrm, SWRM_INTERRUPT_STATUS, &intr_sts); ctrl->reg_read(ctrl, SWRM_INTERRUPT_STATUS, &intr_sts);
intr_sts_masked = intr_sts & swrm->intr_mask; intr_sts_masked = intr_sts & ctrl->intr_mask;
do { do {
for (i = 0; i < SWRM_INTERRUPT_MAX; i++) { for (i = 0; i < SWRM_INTERRUPT_MAX; i++) {
...@@ -575,80 +575,80 @@ static irqreturn_t qcom_swrm_irq_handler(int irq, void *dev_id) ...@@ -575,80 +575,80 @@ static irqreturn_t qcom_swrm_irq_handler(int irq, void *dev_id)
switch (value) { switch (value) {
case SWRM_INTERRUPT_STATUS_SLAVE_PEND_IRQ: case SWRM_INTERRUPT_STATUS_SLAVE_PEND_IRQ:
devnum = qcom_swrm_get_alert_slave_dev_num(swrm); devnum = qcom_swrm_get_alert_slave_dev_num(ctrl);
if (devnum < 0) { if (devnum < 0) {
dev_err_ratelimited(swrm->dev, dev_err_ratelimited(ctrl->dev,
"no slave alert found.spurious interrupt\n"); "no slave alert found.spurious interrupt\n");
} else { } else {
sdw_handle_slave_status(&swrm->bus, swrm->status); sdw_handle_slave_status(&ctrl->bus, ctrl->status);
} }
break; break;
case SWRM_INTERRUPT_STATUS_NEW_SLAVE_ATTACHED: case SWRM_INTERRUPT_STATUS_NEW_SLAVE_ATTACHED:
case SWRM_INTERRUPT_STATUS_CHANGE_ENUM_SLAVE_STATUS: case SWRM_INTERRUPT_STATUS_CHANGE_ENUM_SLAVE_STATUS:
dev_dbg_ratelimited(swrm->dev, "SWR new slave attached\n"); dev_dbg_ratelimited(ctrl->dev, "SWR new slave attached\n");
swrm->reg_read(swrm, SWRM_MCP_SLV_STATUS, &slave_status); ctrl->reg_read(ctrl, SWRM_MCP_SLV_STATUS, &slave_status);
if (swrm->slave_status == slave_status) { if (ctrl->slave_status == slave_status) {
dev_dbg(swrm->dev, "Slave status not changed %x\n", dev_dbg(ctrl->dev, "Slave status not changed %x\n",
slave_status); slave_status);
} else { } else {
qcom_swrm_get_device_status(swrm); qcom_swrm_get_device_status(ctrl);
qcom_swrm_enumerate(&swrm->bus); qcom_swrm_enumerate(&ctrl->bus);
sdw_handle_slave_status(&swrm->bus, swrm->status); sdw_handle_slave_status(&ctrl->bus, ctrl->status);
} }
break; break;
case SWRM_INTERRUPT_STATUS_MASTER_CLASH_DET: case SWRM_INTERRUPT_STATUS_MASTER_CLASH_DET:
dev_err_ratelimited(swrm->dev, dev_err_ratelimited(ctrl->dev,
"%s: SWR bus clsh detected\n", "%s: SWR bus clsh detected\n",
__func__); __func__);
swrm->intr_mask &= ~SWRM_INTERRUPT_STATUS_MASTER_CLASH_DET; ctrl->intr_mask &= ~SWRM_INTERRUPT_STATUS_MASTER_CLASH_DET;
swrm->reg_write(swrm, SWRM_INTERRUPT_CPU_EN, swrm->intr_mask); ctrl->reg_write(ctrl, SWRM_INTERRUPT_CPU_EN, ctrl->intr_mask);
break; break;
case SWRM_INTERRUPT_STATUS_RD_FIFO_OVERFLOW: case SWRM_INTERRUPT_STATUS_RD_FIFO_OVERFLOW:
swrm->reg_read(swrm, SWRM_CMD_FIFO_STATUS, &value); ctrl->reg_read(ctrl, SWRM_CMD_FIFO_STATUS, &value);
dev_err_ratelimited(swrm->dev, dev_err_ratelimited(ctrl->dev,
"%s: SWR read FIFO overflow fifo status 0x%x\n", "%s: SWR read FIFO overflow fifo status 0x%x\n",
__func__, value); __func__, value);
break; break;
case SWRM_INTERRUPT_STATUS_RD_FIFO_UNDERFLOW: case SWRM_INTERRUPT_STATUS_RD_FIFO_UNDERFLOW:
swrm->reg_read(swrm, SWRM_CMD_FIFO_STATUS, &value); ctrl->reg_read(ctrl, SWRM_CMD_FIFO_STATUS, &value);
dev_err_ratelimited(swrm->dev, dev_err_ratelimited(ctrl->dev,
"%s: SWR read FIFO underflow fifo status 0x%x\n", "%s: SWR read FIFO underflow fifo status 0x%x\n",
__func__, value); __func__, value);
break; break;
case SWRM_INTERRUPT_STATUS_WR_CMD_FIFO_OVERFLOW: case SWRM_INTERRUPT_STATUS_WR_CMD_FIFO_OVERFLOW:
swrm->reg_read(swrm, SWRM_CMD_FIFO_STATUS, &value); ctrl->reg_read(ctrl, SWRM_CMD_FIFO_STATUS, &value);
dev_err(swrm->dev, dev_err(ctrl->dev,
"%s: SWR write FIFO overflow fifo status %x\n", "%s: SWR write FIFO overflow fifo status %x\n",
__func__, value); __func__, value);
swrm->reg_write(swrm, SWRM_CMD_FIFO_CMD, 0x1); ctrl->reg_write(ctrl, SWRM_CMD_FIFO_CMD, 0x1);
break; break;
case SWRM_INTERRUPT_STATUS_CMD_ERROR: case SWRM_INTERRUPT_STATUS_CMD_ERROR:
swrm->reg_read(swrm, SWRM_CMD_FIFO_STATUS, &value); ctrl->reg_read(ctrl, SWRM_CMD_FIFO_STATUS, &value);
dev_err_ratelimited(swrm->dev, dev_err_ratelimited(ctrl->dev,
"%s: SWR CMD error, fifo status 0x%x, flushing fifo\n", "%s: SWR CMD error, fifo status 0x%x, flushing fifo\n",
__func__, value); __func__, value);
swrm->reg_write(swrm, SWRM_CMD_FIFO_CMD, 0x1); ctrl->reg_write(ctrl, SWRM_CMD_FIFO_CMD, 0x1);
break; break;
case SWRM_INTERRUPT_STATUS_DOUT_PORT_COLLISION: case SWRM_INTERRUPT_STATUS_DOUT_PORT_COLLISION:
dev_err_ratelimited(swrm->dev, dev_err_ratelimited(ctrl->dev,
"%s: SWR Port collision detected\n", "%s: SWR Port collision detected\n",
__func__); __func__);
swrm->intr_mask &= ~SWRM_INTERRUPT_STATUS_DOUT_PORT_COLLISION; ctrl->intr_mask &= ~SWRM_INTERRUPT_STATUS_DOUT_PORT_COLLISION;
swrm->reg_write(swrm, ctrl->reg_write(ctrl,
SWRM_INTERRUPT_CPU_EN, swrm->intr_mask); SWRM_INTERRUPT_CPU_EN, ctrl->intr_mask);
break; break;
case SWRM_INTERRUPT_STATUS_READ_EN_RD_VALID_MISMATCH: case SWRM_INTERRUPT_STATUS_READ_EN_RD_VALID_MISMATCH:
dev_err_ratelimited(swrm->dev, dev_err_ratelimited(ctrl->dev,
"%s: SWR read enable valid mismatch\n", "%s: SWR read enable valid mismatch\n",
__func__); __func__);
swrm->intr_mask &= ctrl->intr_mask &=
~SWRM_INTERRUPT_STATUS_READ_EN_RD_VALID_MISMATCH; ~SWRM_INTERRUPT_STATUS_READ_EN_RD_VALID_MISMATCH;
swrm->reg_write(swrm, ctrl->reg_write(ctrl,
SWRM_INTERRUPT_CPU_EN, swrm->intr_mask); SWRM_INTERRUPT_CPU_EN, ctrl->intr_mask);
break; break;
case SWRM_INTERRUPT_STATUS_SPECIAL_CMD_ID_FINISHED: case SWRM_INTERRUPT_STATUS_SPECIAL_CMD_ID_FINISHED:
complete(&swrm->broadcast); complete(&ctrl->broadcast);
break; break;
case SWRM_INTERRUPT_STATUS_BUS_RESET_FINISHED_V2: case SWRM_INTERRUPT_STATUS_BUS_RESET_FINISHED_V2:
break; break;
...@@ -657,19 +657,19 @@ static irqreturn_t qcom_swrm_irq_handler(int irq, void *dev_id) ...@@ -657,19 +657,19 @@ static irqreturn_t qcom_swrm_irq_handler(int irq, void *dev_id)
case SWRM_INTERRUPT_STATUS_EXT_CLK_STOP_WAKEUP: case SWRM_INTERRUPT_STATUS_EXT_CLK_STOP_WAKEUP:
break; break;
default: default:
dev_err_ratelimited(swrm->dev, dev_err_ratelimited(ctrl->dev,
"%s: SWR unknown interrupt value: %d\n", "%s: SWR unknown interrupt value: %d\n",
__func__, value); __func__, value);
ret = IRQ_NONE; ret = IRQ_NONE;
break; break;
} }
} }
swrm->reg_write(swrm, SWRM_INTERRUPT_CLEAR, intr_sts); ctrl->reg_write(ctrl, SWRM_INTERRUPT_CLEAR, intr_sts);
swrm->reg_read(swrm, SWRM_INTERRUPT_STATUS, &intr_sts); ctrl->reg_read(ctrl, SWRM_INTERRUPT_STATUS, &intr_sts);
intr_sts_masked = intr_sts & swrm->intr_mask; intr_sts_masked = intr_sts & ctrl->intr_mask;
} while (intr_sts_masked); } while (intr_sts_masked);
clk_disable_unprepare(swrm->hclk); clk_disable_unprepare(ctrl->hclk);
return ret; return ret;
} }
...@@ -1301,23 +1301,23 @@ static int qcom_swrm_get_port_config(struct qcom_swrm_ctrl *ctrl) ...@@ -1301,23 +1301,23 @@ static int qcom_swrm_get_port_config(struct qcom_swrm_ctrl *ctrl)
#ifdef CONFIG_DEBUG_FS #ifdef CONFIG_DEBUG_FS
static int swrm_reg_show(struct seq_file *s_file, void *data) static int swrm_reg_show(struct seq_file *s_file, void *data)
{ {
struct qcom_swrm_ctrl *swrm = s_file->private; struct qcom_swrm_ctrl *ctrl = s_file->private;
int reg, reg_val, ret; int reg, reg_val, ret;
ret = pm_runtime_resume_and_get(swrm->dev); ret = pm_runtime_resume_and_get(ctrl->dev);
if (ret < 0 && ret != -EACCES) { if (ret < 0 && ret != -EACCES) {
dev_err_ratelimited(swrm->dev, dev_err_ratelimited(ctrl->dev,
"pm_runtime_resume_and_get failed in %s, ret %d\n", "pm_runtime_resume_and_get failed in %s, ret %d\n",
__func__, ret); __func__, ret);
return ret; return ret;
} }
for (reg = 0; reg <= SWR_MSTR_MAX_REG_ADDR; reg += 4) { for (reg = 0; reg <= SWR_MSTR_MAX_REG_ADDR; reg += 4) {
swrm->reg_read(swrm, reg, &reg_val); ctrl->reg_read(ctrl, reg, &reg_val);
seq_printf(s_file, "0x%.3x: 0x%.2x\n", reg, reg_val); seq_printf(s_file, "0x%.3x: 0x%.2x\n", reg, reg_val);
} }
pm_runtime_mark_last_busy(swrm->dev); pm_runtime_mark_last_busy(ctrl->dev);
pm_runtime_put_autosuspend(swrm->dev); pm_runtime_put_autosuspend(ctrl->dev);
return 0; return 0;
...@@ -1498,13 +1498,13 @@ static int qcom_swrm_remove(struct platform_device *pdev) ...@@ -1498,13 +1498,13 @@ static int qcom_swrm_remove(struct platform_device *pdev)
return 0; return 0;
} }
static bool swrm_wait_for_frame_gen_enabled(struct qcom_swrm_ctrl *swrm) static bool swrm_wait_for_frame_gen_enabled(struct qcom_swrm_ctrl *ctrl)
{ {
int retry = SWRM_LINK_STATUS_RETRY_CNT; int retry = SWRM_LINK_STATUS_RETRY_CNT;
int comp_sts; int comp_sts;
do { do {
swrm->reg_read(swrm, SWRM_COMP_STATUS, &comp_sts); ctrl->reg_read(ctrl, SWRM_COMP_STATUS, &comp_sts);
if (comp_sts & SWRM_FRM_GEN_ENABLED) if (comp_sts & SWRM_FRM_GEN_ENABLED)
return true; return true;
...@@ -1512,7 +1512,7 @@ static bool swrm_wait_for_frame_gen_enabled(struct qcom_swrm_ctrl *swrm) ...@@ -1512,7 +1512,7 @@ static bool swrm_wait_for_frame_gen_enabled(struct qcom_swrm_ctrl *swrm)
usleep_range(500, 510); usleep_range(500, 510);
} while (retry--); } while (retry--);
dev_err(swrm->dev, "%s: link status not %s\n", __func__, dev_err(ctrl->dev, "%s: link status not %s\n", __func__,
comp_sts & SWRM_FRM_GEN_ENABLED ? "connected" : "disconnected"); comp_sts & SWRM_FRM_GEN_ENABLED ? "connected" : "disconnected");
return false; return false;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7