asoc: codec: Add initial driver for swr-haptics

The haptics module in some PMICs has SWR slave data port which connects
to Bolero SWR RX port and it can receive PCM data from that port and use
it as the pattern source to play the vibration. Add the driver to
support it.

Change-Id: I5e6811ac8d81a60c3cd226029ef22ee12ed46f1d
Signed-off-by: Fenglin Wu <[email protected]>

asoc/codecs/Kbuild

@@ -187,6 +187,10 @@ ifdef CONFIG_SND_SOC_WCD_IRQ
 	CORE_OBJS += wcd-irq.o
 endif
 
+ifdef CONFIG_SND_SWR_HAPTICS
+	SWR_HAP_OBJS += swr-haptics.o
+endif
+
 LINUX_INC +=	-Iinclude/linux
 
 INCS +=		$(COMMON_INC) \
@@ -271,5 +275,8 @@ obj-$(CONFIG_SND_SOC_MSM_HDMI_CODEC_RX) += hdmi_dlkm.o
 hdmi_dlkm-y := $(HDMICODEC_OBJS)
 endif
 
+obj-$(CONFIG_SND_SWR_HAPTICS) += swr_haptics_dlkm.o
+swr_haptics_dlkm-y := $(SWR_HAP_OBJS)
+
 # inject some build related information
 DEFINES += -DBUILD_TIMESTAMP=\"$(shell date -u +'%Y-%m-%dT%H:%M:%SZ')\"

asoc/codecs/swr-haptics.c

@@ -0,0 +1,498 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2020, The Linux Foundation. All rights reserved.
+ */
+
+#include <linux/device.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/regmap.h>
+#include <linux/regulator/consumer.h>
+#include <linux/slab.h>
+#include <soc/soundwire.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+
+/* SWR register definition */
+#define SWR_HAP_ACCESS_BASE		0x3000
+#define FIFO_WR_READY_REG		(SWR_HAP_ACCESS_BASE + 0x8)
+#define NUM_PAT_SMPL_REG		(SWR_HAP_ACCESS_BASE + 0x9)
+#define SWR_WR_ACCESS_REG		(SWR_HAP_ACCESS_BASE + 0xa)
+#define CAL_TLRA_STATUS_MSB_REG		(SWR_HAP_ACCESS_BASE + 0xb)
+#define CAL_TLRA_STATUS_LSB_REG		(SWR_HAP_ACCESS_BASE + 0xc)
+#define AUTO_RES_CAL_DONE_REG		(SWR_HAP_ACCESS_BASE + 0xd)
+#define SWR_READ_DATA_REG		(SWR_HAP_ACCESS_BASE + 0x80)
+#define SWR_PLAY_REG			(SWR_HAP_ACCESS_BASE + 0x81)
+#define SWR_VMAX_REG			(SWR_HAP_ACCESS_BASE + 0x82)
+#define SWR_PLAY_BIT			BIT(7)
+#define SWR_BRAKE_EN_BIT		BIT(3)
+#define SWR_PLAY_SRC_MASK		GENMASK(2, 0)
+#define SWR_PLAY_SRC_VAL_SWR		4
+
+#define SWR_HAP_REG_MAX			(SWR_HAP_ACCESS_BASE + 0xff)
+
+static struct reg_default swr_hap_reg_defaults[] = {
+	{FIFO_WR_READY_REG, 1},
+	{NUM_PAT_SMPL_REG, 8},
+	{SWR_WR_ACCESS_REG, 1},
+	{CAL_TLRA_STATUS_MSB_REG, 0},
+	{CAL_TLRA_STATUS_LSB_REG, 0},
+	{AUTO_RES_CAL_DONE_REG, 0},
+	{SWR_READ_DATA_REG, 0},
+	{SWR_PLAY_REG, 4},
+	{SWR_VMAX_REG, 0},
+};
+
+enum {
+	PORT_ID_DT_IDX,
+	CH_MASK_DT_IDX,
+	CH_RATE_DT_IDX,
+	NUM_CH_DT_IDX,
+	PORT_TYPE_DT_IDX,
+	NUM_SWR_PORT_DT_PARAMS,
+};
+
+struct swr_port {
+	u8 port_id;
+	u8 ch_mask;
+	u32 ch_rate;
+	u8 num_ch;
+	u8 port_type;
+};
+
+struct swr_haptics_dev {
+	struct device			*dev;
+	struct swr_device		*swr_slave;
+	struct snd_soc_component	*component;
+	struct regmap			*regmap;
+	struct swr_port			port;
+	struct regulator		*vdd;
+};
+
+static bool swr_hap_volatile_register(struct device *dev, unsigned int reg)
+{
+	switch (reg) {
+	case SWR_READ_DATA_REG:
+	case SWR_PLAY_REG:
+	case SWR_VMAX_REG:
+		return 1;
+	default:
+		return 0;
+	}
+}
+
+static bool swr_hap_readable_register(struct device *dev, unsigned int reg)
+{
+	if (reg <= SWR_HAP_ACCESS_BASE)
+		return 0;
+
+	return 1;
+}
+
+static bool swr_hap_writeable_register(struct device *dev, unsigned int reg)
+{
+	if (reg <= SWR_HAP_ACCESS_BASE)
+		return 0;
+
+	switch (reg) {
+	case FIFO_WR_READY_REG:
+	case NUM_PAT_SMPL_REG:
+	case SWR_WR_ACCESS_REG:
+	case CAL_TLRA_STATUS_MSB_REG:
+	case CAL_TLRA_STATUS_LSB_REG:
+	case AUTO_RES_CAL_DONE_REG:
+	case SWR_READ_DATA_REG:
+		return 0;
+	}
+
+	return 1;
+}
+
+struct regmap_config swr_hap_regmap_config = {
+	.reg_bits		= 16,
+	.val_bits		= 8,
+	.cache_type		= REGCACHE_RBTREE,
+	.reg_defaults		= swr_hap_reg_defaults,
+	.num_reg_defaults	= ARRAY_SIZE(swr_hap_reg_defaults),
+	.max_register		= SWR_HAP_REG_MAX,
+	.volatile_reg		= swr_hap_volatile_register,
+	.readable_reg		= swr_hap_readable_register,
+	.writeable_reg		= swr_hap_writeable_register,
+	.reg_format_endian	= REGMAP_ENDIAN_NATIVE,
+	.val_format_endian	= REGMAP_ENDIAN_NATIVE,
+	.can_multi_write	= true,
+};
+
+static const struct snd_kcontrol_new hap_swr_dac_port[] = {
+	SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0)
+};
+
+static int hap_enable_swr_dac_port(struct snd_soc_dapm_widget *w,
+		struct snd_kcontrol *kcontrol, int event)
+{
+	struct snd_soc_component *swr_hap_comp =
+		snd_soc_dapm_to_component(w->dapm);
+	struct swr_haptics_dev *swr_hap =
+		snd_soc_component_get_drvdata(swr_hap_comp);
+	u8 port_id, ch_mask, num_ch, port_type, num_port;
+	u32 ch_rate;
+	unsigned int val;
+	int rc;
+
+	dev_dbg(swr_hap->dev, "%s: %s event %d\n", __func__, w->name, event);
+	if (!swr_hap)
+		return -ENODEV;
+
+	num_port = 1;
+	port_id = swr_hap->port.port_id;
+	ch_mask = swr_hap->port.ch_mask;
+	ch_rate = swr_hap->port.ch_rate;
+	num_ch = swr_hap->port.num_ch;
+	port_type = swr_hap->port.port_type;
+
+	switch (event) {
+	case SND_SOC_DAPM_PRE_PMU:
+		swr_connect_port(swr_hap->swr_slave, &port_id, num_port,
+				&ch_mask, &ch_rate, &num_ch, &port_type);
+		/* trigger SWR play */
+		val = SWR_PLAY_BIT | SWR_BRAKE_EN_BIT | SWR_PLAY_SRC_VAL_SWR;
+		rc = regmap_write(swr_hap->regmap, SWR_PLAY_REG, val);
+		if (rc) {
+			dev_err(swr_hap->dev, "%s: Enable SWR_PLAY failed, rc=%d\n",
+					__func__, rc);
+			return rc;
+		}
+
+		swr_slvdev_datapath_control(swr_hap->swr_slave,
+				swr_hap->swr_slave->dev_num, true);
+		break;
+	case SND_SOC_DAPM_POST_PMD:
+		swr_slvdev_datapath_control(swr_hap->swr_slave,
+				swr_hap->swr_slave->dev_num, false);
+		/* stop SWR play */
+		val = 0;
+		rc = regmap_write(swr_hap->regmap, SWR_PLAY_REG, val);
+		if (rc) {
+			dev_err(swr_hap->dev, "%s: Enable SWR_PLAY failed, rc=%d\n",
+					__func__, rc);
+			return rc;
+		}
+
+		swr_disconnect_port(swr_hap->swr_slave, &port_id, num_port,
+				&ch_mask, &port_type);
+		break;
+	default:
+		break;
+	}
+
+	return 0;
+}
+
+static const struct snd_soc_dapm_widget haptics_comp_dapm_widgets[] = {
+	SND_SOC_DAPM_INPUT("HAP_IN"),
+	SND_SOC_DAPM_MIXER_E("SWR DAC_Port", SND_SOC_NOPM, 0, 0,
+			hap_swr_dac_port, ARRAY_SIZE(hap_swr_dac_port),
+			hap_enable_swr_dac_port,
+			SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
+			SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD),
+	SND_SOC_DAPM_SPK("HAP_OUT", NULL),
+};
+
+static const struct snd_soc_dapm_route haptics_comp_dapm_route[] = {
+	{"SWR DAC_Port", "Switch", "HAP_IN"},
+	{"HAP_OUT", NULL, "SWR DAC_Port"},
+};
+
+static int haptics_comp_probe(struct snd_soc_component *component)
+{
+	struct snd_soc_dapm_context *dapm;
+
+	struct swr_haptics_dev *swr_hap =
+		snd_soc_component_get_drvdata(component);
+
+	if (!swr_hap)
+		return -EINVAL;
+
+	snd_soc_component_init_regmap(component, swr_hap->regmap);
+
+	dapm = snd_soc_component_get_dapm(component);
+	if (dapm && dapm->component) {
+		snd_soc_dapm_ignore_suspend(dapm, "HAP_IN");
+		snd_soc_dapm_ignore_suspend(dapm, "HAP_OUT");
+	}
+
+	return 0;
+}
+
+static void haptics_comp_remove(struct snd_soc_component *component)
+{
+}
+
+static const struct snd_soc_component_driver swr_haptics_component = {
+	.name = "swr-haptics",
+	.probe = haptics_comp_probe,
+	.remove = haptics_comp_remove,
+	.dapm_widgets = haptics_comp_dapm_widgets,
+	.num_dapm_widgets = ARRAY_SIZE(haptics_comp_dapm_widgets),
+	.dapm_routes = haptics_comp_dapm_route,
+	.num_dapm_routes = ARRAY_SIZE(haptics_comp_dapm_route),
+};
+
+static int swr_haptics_parse_port_mapping(struct swr_device *sdev)
+{
+	struct swr_haptics_dev *swr_hap = swr_get_dev_data(sdev);
+	u32 port_cfg[NUM_SWR_PORT_DT_PARAMS];
+	int rc;
+
+	rc = of_property_read_u32_array(sdev->dev.of_node, "qcom,rx_swr_ch_map",
+			port_cfg, NUM_SWR_PORT_DT_PARAMS);
+	if (rc < 0) {
+		dev_err(swr_hap->dev, "%s: Get qcom,rx_swr_ch_map failed, rc=%d\n",
+				__func__, rc);
+		return -EINVAL;
+	}
+
+	swr_hap->port.port_id = (u8) port_cfg[PORT_ID_DT_IDX];
+	swr_hap->port.ch_mask = (u8) port_cfg[CH_MASK_DT_IDX];
+	swr_hap->port.ch_rate = port_cfg[CH_RATE_DT_IDX];
+	swr_hap->port.num_ch = (u8) port_cfg[NUM_CH_DT_IDX];
+	swr_hap->port.port_type = (u8) port_cfg[PORT_TYPE_DT_IDX];
+
+	dev_dbg(swr_hap->dev, "%s: port_id = %d, ch_mask = %d, ch_rate = %d, num_ch = %d, port_type = %d\n",
+			__func__, swr_hap->port.port_id,
+			swr_hap->port.ch_mask, swr_hap->port.ch_rate,
+			swr_hap->port.num_ch, swr_hap->port.port_type);
+	return 0;
+}
+
+static int swr_haptics_probe(struct swr_device *sdev)
+{
+	struct swr_haptics_dev *swr_hap;
+	int rc;
+	u8 devnum;
+
+	swr_hap = devm_kzalloc(&sdev->dev,
+			sizeof(struct swr_haptics_dev), GFP_KERNEL);
+	if (!swr_hap)
+		return -ENOMEM;
+
+	swr_hap->swr_slave = sdev;
+	swr_hap->dev = &sdev->dev;
+	swr_set_dev_data(sdev, swr_hap);
+
+	rc = swr_haptics_parse_port_mapping(sdev);
+	if (rc < 0) {
+		dev_err(swr_hap->dev, "%s: failed to parse swr port mapping, rc=%d\n",
+				__func__, rc);
+		goto clean;
+	}
+
+	swr_hap->vdd = devm_regulator_get(swr_hap->dev, "swr-slave");
+	if (IS_ERR(swr_hap->vdd)) {
+		rc = PTR_ERR(swr_hap->vdd);
+		if (rc != -EPROBE_DEFER)
+			dev_err(swr_hap->dev, "%s: get swr-slave-supply failed, rc=%d\n",
+					__func__, rc);
+		goto clean;
+	}
+
+	rc = regulator_enable(swr_hap->vdd);
+	if (rc < 0) {
+		dev_err(swr_hap->dev, "%s: enable swr-slave-vdd failed, rc=%d\n",
+				__func__, rc);
+		goto clean;
+	}
+
+	rc = swr_get_logical_dev_num(sdev, sdev->addr, &devnum);
+	if (rc) {
+		dev_err(swr_hap->dev, "%s: failed to get devnum for swr-haptics, rc=%d\n",
+				__func__, rc);
+		goto dev_err;
+	}
+
+	sdev->dev_num = devnum;
+	swr_hap->regmap = devm_regmap_init_swr(sdev, &swr_hap_regmap_config);
+	if (IS_ERR(swr_hap->regmap)) {
+		rc = PTR_ERR(swr_hap->regmap);
+		dev_err(swr_hap->dev, "%s: init regmap failed, rc=%d\n",
+				__func__, rc);
+		goto dev_err;
+	}
+
+	rc = snd_soc_register_component(&sdev->dev,
+			&swr_haptics_component, NULL, 0);
+	if (rc) {
+		dev_err(swr_hap->dev, "%s: register swr_haptics component failed, rc=%d\n",
+				__func__, rc);
+		goto dev_err;
+	}
+
+	return 0;
+dev_err:
+	regulator_disable(swr_hap->vdd);
+	swr_remove_device(sdev);
+clean:
+	swr_set_dev_data(sdev, NULL);
+	return rc;
+}
+
+static int swr_haptics_remove(struct swr_device *sdev)
+{
+	struct swr_haptics_dev *swr_hap;
+	int rc = 0;
+
+	swr_hap = swr_get_dev_data(sdev);
+	if (!swr_hap) {
+		dev_err(swr_hap->dev, "%s: no data for swr_hap\n", __func__);
+		goto clean;
+	}
+
+	rc = regulator_disable(swr_hap->vdd);
+	if (rc < 0) {
+		dev_err(swr_hap->dev, "%s: disable swr-slave failed, rc=%d\n",
+				__func__, rc);
+		goto clean;
+	}
+clean:
+	snd_soc_unregister_component(&sdev->dev);
+	swr_set_dev_data(sdev, NULL);
+	return rc;
+}
+
+static int swr_haptics_device_up(struct swr_device *sdev)
+{
+	struct swr_haptics_dev *swr_hap;
+	int rc;
+
+	swr_hap = swr_get_dev_data(sdev);
+	if (!swr_hap) {
+		dev_err(swr_hap->dev, "%s: no data for swr_hap\n", __func__);
+		return -ENODEV;
+	}
+
+	/* Take SWR slave out of reset */
+	rc = regulator_enable(swr_hap->vdd);
+	if (rc < 0) {
+		dev_err(swr_hap->dev, "%s: enable swr-slave failed, rc=%d\n",
+				__func__, rc);
+		return rc;
+	}
+
+	return 0;
+}
+
+static int swr_haptics_device_down(struct swr_device *sdev)
+{
+	struct swr_haptics_dev *swr_hap = swr_get_dev_data(sdev);
+	int rc;
+	unsigned int val;
+
+	if (!swr_hap) {
+		dev_err(swr_hap->dev, "%s: no data for swr_hap\n", __func__);
+		return -ENODEV;
+	}
+
+	/* Stop SWR play in SSR */
+	val = 0;
+	rc = regmap_write(swr_hap->regmap, SWR_PLAY_REG, val);
+	if (rc) {
+		dev_err(swr_hap->dev, "%s: disable SWR_PLAY failed, rc=%d\n",
+				__func__, rc);
+		return rc;
+	}
+
+	/* Put SWR slave into reset */
+	rc = regulator_disable(swr_hap->vdd);
+	if (rc < 0) {
+		dev_err(swr_hap->dev, "%s: disable swr-slave failed, rc=%d\n",
+				__func__, rc);
+		return rc;
+	}
+
+	return 0;
+}
+
+static int swr_haptics_suspend(struct device *dev)
+{
+	struct swr_haptics_dev *swr_hap;
+	int rc;
+
+	swr_hap = swr_get_dev_data(to_swr_device(dev));
+
+	/* Put SWR slave into reset */
+	rc = regulator_disable(swr_hap->vdd);
+	if (rc < 0) {
+		dev_err(swr_hap->dev, "%s: disable swr-slave failed, rc=%d\n",
+				__func__, rc);
+		return rc;
+	}
+
+	return 0;
+}
+
+static int swr_haptics_resume(struct device *dev)
+{
+	struct swr_haptics_dev *swr_hap;
+	int rc;
+
+	swr_hap = swr_get_dev_data(to_swr_device(dev));
+
+	/* Take SWR slave out of reset */
+	rc = regulator_enable(swr_hap->vdd);
+	if (rc < 0) {
+		dev_err(swr_hap->dev, "%s: enable swr-slave failed, rc=%d\n",
+				__func__, rc);
+		return rc;
+	}
+
+	return 0;
+}
+
+
+static const struct of_device_id swr_haptics_match_table[] = {
+	{ .compatible = "qcom,swr-haptics", },
+	{ .compatible = "qcom,pm8350b-swr-haptics", },
+	{ },
+};
+
+static const struct swr_device_id swr_haptics_id[] = {
+	{"swr-haptics", 0},
+	{"pm8350b-swr-haptics", 0},
+	{},
+};
+
+static const struct dev_pm_ops swr_haptics_pm_ops = {
+	.suspend = swr_haptics_suspend,
+	.resume = swr_haptics_resume,
+};
+
+static struct swr_driver swr_haptics_driver = {
+	.driver = {
+		.name = "swr-haptics",
+		.owner = THIS_MODULE,
+		.pm = &swr_haptics_pm_ops,
+		.of_match_table = swr_haptics_match_table,
+	},
+	.probe = swr_haptics_probe,
+	.remove = swr_haptics_remove,
+	.id_table = swr_haptics_id,
+	.device_up = swr_haptics_device_up,
+	.device_down = swr_haptics_device_down,
+};
+
+static int __init swr_haptics_init(void)
+{
+	return swr_driver_register(&swr_haptics_driver);
+}
+
+static void __exit swr_haptics_exit(void)
+{
+	swr_driver_unregister(&swr_haptics_driver);
+}
+
+module_init(swr_haptics_init);
+module_exit(swr_haptics_exit);
+
+MODULE_DESCRIPTION("SWR haptics driver");
+MODULE_LICENSE("GPL v2");