Commit 57b1659f authored by Greg Kroah-Hartman's avatar Greg Kroah-Hartman
Browse files

Merge tag 'soundwire-5.18-rc1' of... 

Merge tag 'soundwire-5.18-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/vkoul/soundwire into char-misc-next

Vinod writes:

soundwire updates for 5.17-rc1

 - stream handling refactoring and renaming to make it consistent
   in the core
 - runtime pm suport for qcom driver
 - in band wake up interrupt support for qcom driver

* tag 'soundwire-5.18-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/vkoul/soundwire: (27 commits)
  soundwire: qcom: use __maybe_unused for swrm_runtime_resume()
  soundwire: qcom: constify static struct qcom_swrm_data global variables
  soundwire: qcom: add in-band wake up interrupt support
  dt-bindings: soundwire: qcom: document optional wake irq
  soundwire: qcom: add runtime pm support
  soundwire: stream: make enable/disable/deprepare idempotent
  soundwire: stream: sdw_stream_add_ functions can be called multiple times
  soundwire: stream: introduce sdw_slave_rt_find() helper
  soundwire: stream: separate alloc and config within sdw_stream_add_xxx()
  soundwire: stream: move list addition to sdw_slave_alloc_rt()
  soundwire: stream: rename and move master/slave_rt_free routines
  soundwire: stream: group sdw_stream_ functions
  soundwire: stream: split sdw_alloc_slave_rt() in alloc and config
  soundwire: stream: move sdw_alloc_slave_rt() before 'master' helpers
  soundwire: stream: split sdw_alloc_master_rt() in alloc and config
  soundwire: stream: simplify sdw_alloc_master_rt()
  soundwire: stream: group sdw_port and sdw_master/slave_port functions
  soundwire: stream: add 'slave' prefix for port range checks
  soundwire: stream: split alloc and config in two functions
  soundwire: stream: split port allocation and configuration loops
  ...
parents 4dee7a71 266fa946

Documentation/devicetree/bindings/soundwire/qcom,sdw.txt

+13 −1
Original line number Diff line number Diff line
@@ -22,7 +22,19 @@ board specific bus parameters. 
- interrupts:

	Usage: required

	Value type: <prop-encoded-array>

	Definition: should specify the SoundWire Controller IRQ

	Definition: should specify the SoundWire Controller core and optional

		    wake IRQ



- interrupt-names:

	Usage: Optional

	Value type: boolean

	Value type: <stringlist>

	Definition: should be "core" for core and "wakeup" for wake interrupt.



- wakeup-source:

	Usage: Optional

	Value type: boolean

	Definition: should specify if SoundWire Controller is wake up capable.



- clock-names:

	Usage: required

drivers/soundwire/bus.c

+7 −1
Original line number Diff line number Diff line
@@ -1749,9 +1749,12 @@ int sdw_handle_slave_status(struct sdw_bus *bus, 
			continue;



		if (status[i] == SDW_SLAVE_UNATTACHED &&

		    slave->status != SDW_SLAVE_UNATTACHED)

		    slave->status != SDW_SLAVE_UNATTACHED) {

			dev_warn(&slave->dev, "Slave %d state check1: UNATTACHED, status was %d\n",

				 i, slave->status);

			sdw_modify_slave_status(slave, SDW_SLAVE_UNATTACHED);

		}

	}



	if (status[0] == SDW_SLAVE_ATTACHED) {

		dev_dbg(bus->dev, "Slave attached, programming device number\n");
@@ -1785,6 +1788,9 @@ int sdw_handle_slave_status(struct sdw_bus *bus, 
			if (slave->status == SDW_SLAVE_UNATTACHED)

				break;



			dev_warn(&slave->dev, "Slave %d state check2: UNATTACHED, status was %d\n",

				 i, slave->status);



			sdw_modify_slave_status(slave, SDW_SLAVE_UNATTACHED);

			break;

drivers/soundwire/intel.c

+2 −2
Original line number Diff line number Diff line
@@ -448,8 +448,8 @@ static void intel_shim_wake(struct sdw_intel *sdw, bool wake_enable) 


		/* Clear wake status */

		wake_sts = intel_readw(shim, SDW_SHIM_WAKESTS);

		wake_sts |= (SDW_SHIM_WAKEEN_ENABLE << link_id);

		intel_writew(shim, SDW_SHIM_WAKESTS_STATUS, wake_sts);

		wake_sts |= (SDW_SHIM_WAKESTS_STATUS << link_id);

		intel_writew(shim, SDW_SHIM_WAKESTS, wake_sts);

	}

	mutex_unlock(sdw->link_res->shim_lock);

}

drivers/soundwire/intel_init.c

+4 −3
Original line number Diff line number Diff line
@@ -180,7 +180,8 @@ static struct sdw_intel_ctx 
	if (!res)

		return NULL;



	if (acpi_bus_get_device(res->handle, &adev))

	adev = acpi_fetch_acpi_dev(res->handle);

	if (!adev)

		return NULL;



	if (!res->count)
@@ -294,13 +295,13 @@ static struct sdw_intel_ctx 
static int

sdw_intel_startup_controller(struct sdw_intel_ctx *ctx)

{

	struct acpi_device *adev;

	struct acpi_device *adev = acpi_fetch_acpi_dev(ctx->handle);

	struct sdw_intel_link_dev *ldev;

	u32 caps;

	u32 link_mask;

	int i;



	if (acpi_bus_get_device(ctx->handle, &adev))

	if (!adev)

		return -EINVAL;



	/* Check SNDWLCAP.LCOUNT */

drivers/soundwire/qcom.c

+205 −3
Original line number Diff line number Diff line
@@ -11,8 +11,10 @@ 
#include <linux/of.h>

#include <linux/of_irq.h>

#include <linux/of_device.h>

#include <linux/pm_runtime.h>

#include <linux/regmap.h>

#include <linux/slab.h>

#include <linux/pm_wakeirq.h>

#include <linux/slimbus.h>

#include <linux/soundwire/sdw.h>

#include <linux/soundwire/sdw_registers.h>
@@ -20,6 +22,9 @@ 
#include <sound/soc.h>

#include "bus.h"



#define SWRM_COMP_SW_RESET					0x008

#define SWRM_COMP_STATUS					0x014

#define SWRM_FRM_GEN_ENABLED					BIT(0)

#define SWRM_COMP_HW_VERSION					0x00

#define SWRM_COMP_CFG_ADDR					0x04

#define SWRM_COMP_CFG_IRQ_LEVEL_OR_PULSE_MSK			BIT(1)
@@ -29,6 +34,7 @@ 
#define SWRM_COMP_PARAMS_RD_FIFO_DEPTH				GENMASK(19, 15)

#define SWRM_COMP_PARAMS_DOUT_PORTS_MASK			GENMASK(4, 0)

#define SWRM_COMP_PARAMS_DIN_PORTS_MASK				GENMASK(9, 5)

#define SWRM_COMP_MASTER_ID					0x104

#define SWRM_INTERRUPT_STATUS					0x200

#define SWRM_INTERRUPT_STATUS_RMSK				GENMASK(16, 0)

#define SWRM_INTERRUPT_STATUS_SLAVE_PEND_IRQ			BIT(0)
@@ -111,6 +117,13 @@ 
#define SWR_MAX_CMD_ID	14

#define MAX_FIFO_RD_RETRY 3

#define SWR_OVERFLOW_RETRY_COUNT 30

#define SWRM_LINK_STATUS_RETRY_CNT 100



enum {

	MASTER_ID_WSA = 1,

	MASTER_ID_RX,

	MASTER_ID_TX

};



struct qcom_swrm_port_config {

	u8 si;
@@ -142,6 +155,7 @@ struct qcom_swrm_ctrl { 
	u8 rd_cmd_id;

	int irq;

	unsigned int version;

	int wake_irq;

	int num_din_ports;

	int num_dout_ports;

	int cols_index;
@@ -159,6 +173,7 @@ struct qcom_swrm_ctrl { 
	u32 slave_status;

	u32 wr_fifo_depth;

	u32 rd_fifo_depth;

	bool clock_stop_not_supported;

};



struct qcom_swrm_data {
@@ -166,12 +181,12 @@ struct qcom_swrm_data { 
	u32 default_rows;

};



static struct qcom_swrm_data swrm_v1_3_data = {

static const struct qcom_swrm_data swrm_v1_3_data = {

	.default_rows = 48,

	.default_cols = 16,

};



static struct qcom_swrm_data swrm_v1_5_data = {

static const struct qcom_swrm_data swrm_v1_5_data = {

	.default_rows = 50,

	.default_cols = 16,

};
@@ -490,6 +505,30 @@ static int qcom_swrm_enumerate(struct sdw_bus *bus) 
	return 0;

}



static irqreturn_t qcom_swrm_wake_irq_handler(int irq, void *dev_id)

{

	struct qcom_swrm_ctrl *swrm = dev_id;

	int ret;



	ret = pm_runtime_get_sync(swrm->dev);

	if (ret < 0 && ret != -EACCES) {

		dev_err_ratelimited(swrm->dev,

				    "pm_runtime_get_sync failed in %s, ret %d\n",

				    __func__, ret);

		pm_runtime_put_noidle(swrm->dev);

	}



	if (swrm->wake_irq > 0) {

		if (!irqd_irq_disabled(irq_get_irq_data(swrm->wake_irq)))

			disable_irq_nosync(swrm->wake_irq);

	}



	pm_runtime_mark_last_busy(swrm->dev);

	pm_runtime_put_autosuspend(swrm->dev);



	return IRQ_HANDLED;

}



static irqreturn_t qcom_swrm_irq_handler(int irq, void *dev_id)

{

	struct qcom_swrm_ctrl *swrm = dev_id;
@@ -497,6 +536,7 @@ static irqreturn_t qcom_swrm_irq_handler(int irq, void *dev_id) 
	u32 i;

	int devnum;

	int ret = IRQ_HANDLED;

	clk_prepare_enable(swrm->hclk);



	swrm->reg_read(swrm, SWRM_INTERRUPT_STATUS, &intr_sts);

	intr_sts_masked = intr_sts & swrm->intr_mask;
@@ -604,6 +644,7 @@ static irqreturn_t qcom_swrm_irq_handler(int irq, void *dev_id) 
		intr_sts_masked = intr_sts & swrm->intr_mask;

	} while (intr_sts_masked);



	clk_disable_unprepare(swrm->hclk);

	return ret;

}
@@ -1017,6 +1058,15 @@ static int qcom_swrm_startup(struct snd_pcm_substream *substream, 
	struct snd_soc_dai *codec_dai;

	int ret, i;



	ret = pm_runtime_get_sync(ctrl->dev);

	if (ret < 0 && ret != -EACCES) {

		dev_err_ratelimited(ctrl->dev,

				    "pm_runtime_get_sync failed in %s, ret %d\n",

				    __func__, ret);

		pm_runtime_put_noidle(ctrl->dev);

		return ret;

	}



	sruntime = sdw_alloc_stream(dai->name);

	if (!sruntime)

		return -ENOMEM;
@@ -1044,6 +1094,9 @@ static void qcom_swrm_shutdown(struct snd_pcm_substream *substream, 


	sdw_release_stream(ctrl->sruntime[dai->id]);

	ctrl->sruntime[dai->id] = NULL;

	pm_runtime_mark_last_busy(ctrl->dev);

	pm_runtime_put_autosuspend(ctrl->dev);



}



static const struct snd_soc_dai_ops qcom_swrm_pdm_dai_ops = {
@@ -1197,12 +1250,23 @@ static int qcom_swrm_get_port_config(struct qcom_swrm_ctrl *ctrl) 
static int swrm_reg_show(struct seq_file *s_file, void *data)

{

	struct qcom_swrm_ctrl *swrm = s_file->private;

	int reg, reg_val;

	int reg, reg_val, ret;



	ret = pm_runtime_get_sync(swrm->dev);

	if (ret < 0 && ret != -EACCES) {

		dev_err_ratelimited(swrm->dev,

				    "pm_runtime_get_sync failed in %s, ret %d\n",

				    __func__, ret);

		pm_runtime_put_noidle(swrm->dev);

	}



	for (reg = 0; reg <= SWR_MSTR_MAX_REG_ADDR; reg += 4) {

		swrm->reg_read(swrm, reg, &reg_val);

		seq_printf(s_file, "0x%.3x: 0x%.2x\n", reg, reg_val);

	}

	pm_runtime_mark_last_busy(swrm->dev);

	pm_runtime_put_autosuspend(swrm->dev);





	return 0;

}
@@ -1267,6 +1331,7 @@ static int qcom_swrm_probe(struct platform_device *pdev) 
	ctrl->bus.ops = &qcom_swrm_ops;

	ctrl->bus.port_ops = &qcom_swrm_port_ops;

	ctrl->bus.compute_params = &qcom_swrm_compute_params;

	ctrl->bus.clk_stop_timeout = 300;



	ret = qcom_swrm_get_port_config(ctrl);

	if (ret)
@@ -1301,6 +1366,18 @@ static int qcom_swrm_probe(struct platform_device *pdev) 
		goto err_clk;

	}



	ctrl->wake_irq = of_irq_get(dev->of_node, 1);

	if (ctrl->wake_irq > 0) {

		ret = devm_request_threaded_irq(dev, ctrl->wake_irq, NULL,

						qcom_swrm_wake_irq_handler,

						IRQF_TRIGGER_HIGH | IRQF_ONESHOT,

						"swr_wake_irq", ctrl);

		if (ret) {

			dev_err(dev, "Failed to request soundwire wake irq\n");

			goto err_init;

		}

	}



	ret = sdw_bus_master_add(&ctrl->bus, dev, dev->fwnode);

	if (ret) {

		dev_err(dev, "Failed to register Soundwire controller (%d)\n",
@@ -1319,6 +1396,21 @@ static int qcom_swrm_probe(struct platform_device *pdev) 
		 (ctrl->version >> 24) & 0xff, (ctrl->version >> 16) & 0xff,

		 ctrl->version & 0xffff);



	pm_runtime_set_autosuspend_delay(dev, 3000);

	pm_runtime_use_autosuspend(dev);

	pm_runtime_mark_last_busy(dev);

	pm_runtime_set_active(dev);

	pm_runtime_enable(dev);



	/* Clk stop is not supported on WSA Soundwire masters */

	if (ctrl->version <= 0x01030000) {

		ctrl->clock_stop_not_supported = true;

	} else {

		ctrl->reg_read(ctrl, SWRM_COMP_MASTER_ID, &val);

		if (val == MASTER_ID_WSA)

			ctrl->clock_stop_not_supported = true;

	}



#ifdef CONFIG_DEBUG_FS

	ctrl->debugfs = debugfs_create_dir("qualcomm-sdw", ctrl->bus.debugfs);

	debugfs_create_file("qualcomm-registers", 0400, ctrl->debugfs, ctrl,
@@ -1345,6 +1437,115 @@ static int qcom_swrm_remove(struct platform_device *pdev) 
	return 0;

}



static bool swrm_wait_for_frame_gen_enabled(struct qcom_swrm_ctrl *swrm)

{

	int retry = SWRM_LINK_STATUS_RETRY_CNT;

	int comp_sts;



	do {

		swrm->reg_read(swrm, SWRM_COMP_STATUS, &comp_sts);



		if (comp_sts & SWRM_FRM_GEN_ENABLED)

			return true;



		usleep_range(500, 510);

	} while (retry--);



	dev_err(swrm->dev, "%s: link status not %s\n", __func__,

		comp_sts && SWRM_FRM_GEN_ENABLED ? "connected" : "disconnected");



	return false;

}



static int __maybe_unused swrm_runtime_resume(struct device *dev)

{

	struct qcom_swrm_ctrl *ctrl = dev_get_drvdata(dev);

	int ret;



	if (ctrl->wake_irq > 0) {

		if (!irqd_irq_disabled(irq_get_irq_data(ctrl->wake_irq)))

			disable_irq_nosync(ctrl->wake_irq);

	}



	clk_prepare_enable(ctrl->hclk);



	if (ctrl->clock_stop_not_supported) {

		reinit_completion(&ctrl->enumeration);

		ctrl->reg_write(ctrl, SWRM_COMP_SW_RESET, 0x01);

		usleep_range(100, 105);



		qcom_swrm_init(ctrl);



		usleep_range(100, 105);

		if (!swrm_wait_for_frame_gen_enabled(ctrl))

			dev_err(ctrl->dev, "link failed to connect\n");



		/* wait for hw enumeration to complete */

		wait_for_completion_timeout(&ctrl->enumeration,

					    msecs_to_jiffies(TIMEOUT_MS));

		qcom_swrm_get_device_status(ctrl);

		sdw_handle_slave_status(&ctrl->bus, ctrl->status);

	} else {

		ctrl->reg_write(ctrl, SWRM_MCP_BUS_CTRL, SWRM_MCP_BUS_CLK_START);

		ctrl->reg_write(ctrl, SWRM_INTERRUPT_CLEAR,

			SWRM_INTERRUPT_STATUS_MASTER_CLASH_DET);



		ctrl->intr_mask |= SWRM_INTERRUPT_STATUS_MASTER_CLASH_DET;

		ctrl->reg_write(ctrl, SWRM_INTERRUPT_MASK_ADDR, ctrl->intr_mask);

		ctrl->reg_write(ctrl, SWRM_INTERRUPT_CPU_EN, ctrl->intr_mask);



		usleep_range(100, 105);

		if (!swrm_wait_for_frame_gen_enabled(ctrl))

			dev_err(ctrl->dev, "link failed to connect\n");



		ret = sdw_bus_exit_clk_stop(&ctrl->bus);

		if (ret < 0)

			dev_err(ctrl->dev, "bus failed to exit clock stop %d\n", ret);

	}



	return 0;

}



static int __maybe_unused swrm_runtime_suspend(struct device *dev)

{

	struct qcom_swrm_ctrl *ctrl = dev_get_drvdata(dev);

	int ret;



	if (!ctrl->clock_stop_not_supported) {

		/* Mask bus clash interrupt */

		ctrl->intr_mask &= ~SWRM_INTERRUPT_STATUS_MASTER_CLASH_DET;

		ctrl->reg_write(ctrl, SWRM_INTERRUPT_MASK_ADDR, ctrl->intr_mask);

		ctrl->reg_write(ctrl, SWRM_INTERRUPT_CPU_EN, ctrl->intr_mask);

		/* Prepare slaves for clock stop */

		ret = sdw_bus_prep_clk_stop(&ctrl->bus);

		if (ret < 0 && ret != -ENODATA) {

			dev_err(dev, "prepare clock stop failed %d", ret);

			return ret;

		}



		ret = sdw_bus_clk_stop(&ctrl->bus);

		if (ret < 0 && ret != -ENODATA) {

			dev_err(dev, "bus clock stop failed %d", ret);

			return ret;

		}

	}



	clk_disable_unprepare(ctrl->hclk);



	usleep_range(300, 305);



	if (ctrl->wake_irq > 0) {

		if (irqd_irq_disabled(irq_get_irq_data(ctrl->wake_irq)))

			enable_irq(ctrl->wake_irq);

	}



	return 0;

}



static const struct dev_pm_ops swrm_dev_pm_ops = {

	SET_RUNTIME_PM_OPS(swrm_runtime_suspend, swrm_runtime_resume, NULL)

};



static const struct of_device_id qcom_swrm_of_match[] = {

	{ .compatible = "qcom,soundwire-v1.3.0", .data = &swrm_v1_3_data },

	{ .compatible = "qcom,soundwire-v1.5.1", .data = &swrm_v1_5_data },
@@ -1359,6 +1560,7 @@ static struct platform_driver qcom_swrm_driver = { 
	.driver = {

		.name	= "qcom-soundwire",

		.of_match_table = qcom_swrm_of_match,

		.pm = &swrm_dev_pm_ops,

	}

};

module_platform_driver(qcom_swrm_driver);