Unverified Commit 85b57de3 authored by Mark Brown's avatar Mark Brown
Browse files

ASoC: Add support for CS35L41 in HDA systems 

Merge series from Lucas Tanure <tanureal@opensource.cirrus.com>:

Initial refactoring to support use of cs35l41 from the HDA driver stack.
parents 8b974c12 e8e4fcc0

include/sound/cs35l41.h

+739 −0

File changed.

Preview size limit exceeded, changes collapsed.

sound/soc/codecs/Kconfig

+7 −4
Original line number Diff line number Diff line
@@ -624,21 +624,24 @@ config SND_SOC_CS35L36 
	tristate "Cirrus Logic CS35L36 CODEC"

	depends on I2C



config SND_SOC_CS35L41_LIB

	tristate



config SND_SOC_CS35L41

	tristate

	default y if SND_SOC_CS35L41_SPI=y

	default y if SND_SOC_CS35L41_I2C=y

	default m if SND_SOC_CS35L41_SPI=m

	default m if SND_SOC_CS35L41_I2C=m



config SND_SOC_CS35L41_SPI

	tristate "Cirrus Logic CS35L41 CODEC (SPI)"

	depends on SPI_MASTER

	select SND_SOC_CS35L41_LIB

	select SND_SOC_CS35L41

	select REGMAP_SPI



config SND_SOC_CS35L41_I2C

	tristate "Cirrus Logic CS35L41 CODEC (I2C)"

	depends on I2C

	select SND_SOC_CS35L41_LIB

	select SND_SOC_CS35L41

	select REGMAP_I2C



config SND_SOC_CS42L42

sound/soc/codecs/Makefile

+3 −1
Original line number Diff line number Diff line
@@ -55,7 +55,8 @@ snd-soc-cs35l33-objs := cs35l33.o 
snd-soc-cs35l34-objs := cs35l34.o

snd-soc-cs35l35-objs := cs35l35.o

snd-soc-cs35l36-objs := cs35l36.o

snd-soc-cs35l41-objs := cs35l41.o cs35l41-tables.o

snd-soc-cs35l41-lib-objs := cs35l41-lib.o

snd-soc-cs35l41-objs := cs35l41.o

snd-soc-cs35l41-spi-objs := cs35l41-spi.o

snd-soc-cs35l41-i2c-objs := cs35l41-i2c.o

snd-soc-cs42l42-objs := cs42l42.o
@@ -396,6 +397,7 @@ obj-$(CONFIG_SND_SOC_CS35L34) += snd-soc-cs35l34.o 
obj-$(CONFIG_SND_SOC_CS35L35)	+= snd-soc-cs35l35.o

obj-$(CONFIG_SND_SOC_CS35L36)	+= snd-soc-cs35l36.o

obj-$(CONFIG_SND_SOC_CS35L41)	+= snd-soc-cs35l41.o

obj-$(CONFIG_SND_SOC_CS35L41_LIB)	+= snd-soc-cs35l41-lib.o

obj-$(CONFIG_SND_SOC_CS35L41_SPI)	+= snd-soc-cs35l41-spi.o

obj-$(CONFIG_SND_SOC_CS35L41_I2C)	+= snd-soc-cs35l41-i2c.o

obj-$(CONFIG_SND_SOC_CS42L42)	+= snd-soc-cs42l42.o

sound/soc/codecs/cs35l41-i2c.c

+0 −1
Original line number Diff line number Diff line
@@ -17,7 +17,6 @@ 
#include <linux/platform_device.h>

#include <linux/slab.h>



#include <sound/cs35l41.h>

#include "cs35l41.h"



static const struct i2c_device_id cs35l41_id_i2c[] = {

sound/soc/codecs/cs35l41-tables.c→sound/soc/codecs/cs35l41-lib.c

+351 −4
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

//

// cs35l41-tables.c -- CS35L41 ALSA SoC audio driver

// cs35l41-lib.c -- CS35L41 Common functions for HDA and ASoC Audio drivers

//

// Copyright 2017-2021 Cirrus Logic, Inc.

//

// Author: David Rhodes <david.rhodes@cirrus.com>

// Author: Lucas Tanure <lucas.tanure@cirrus.com>



#include "cs35l41.h"

#include <linux/dev_printk.h>

#include <linux/module.h>

#include <linux/regmap.h>

#include <linux/regulator/consumer.h>

#include <linux/slab.h>



#include <sound/cs35l41.h>



static const struct reg_default cs35l41_reg[] = {

	{ CS35L41_PWR_CTRL1,			0x00000000 },

	{ CS35L41_PWR_CTRL2,			0x00000000 },

	{ CS35L41_PWR_CTRL3,			0x01000010 },

	{ CS35L41_GPIO_PAD_CONTROL,		0x00000000 },

	{ CS35L41_SP_ENABLES,			0x00000000 },
@@ -39,7 +47,7 @@ static const struct reg_default cs35l41_reg[] = { 
	{ CS35L41_CLASSH_CFG,			0x000B0405 },

	{ CS35L41_WKFET_CFG,			0x00000111 },

	{ CS35L41_NG_CFG,			0x00000033 },

	{ CS35L41_AMP_GAIN_CTRL,		0x00000273 },

	{ CS35L41_AMP_GAIN_CTRL,		0x00000000 },

	{ CS35L41_GPIO1_CTRL1,			0xE1000001 },

	{ CS35L41_GPIO2_CTRL1,			0xE1000001 },

	{ CS35L41_MIXER_NGATE_CFG,		0x00000000 },
@@ -651,7 +659,58 @@ static const struct cs35l41_otp_packed_element_t otp_map_2[CS35L41_NUM_OTP_ELEM] 
	{ 0x00017044,	0,	24 }, /*LOT_NUMBER*/

};



const struct cs35l41_otp_map_element_t cs35l41_otp_map_map[CS35L41_NUM_OTP_MAPS] = {

static const struct reg_sequence cs35l41_reva0_errata_patch[] = {

	{ 0x00000040,			 0x00005555 },

	{ 0x00000040,			 0x0000AAAA },

	{ 0x00003854,			 0x05180240 },

	{ CS35L41_VIMON_SPKMON_RESYNC,	 0x00000000 },

	{ 0x00004310,			 0x00000000 },

	{ CS35L41_VPVBST_FS_SEL,	 0x00000000 },

	{ CS35L41_OTP_TRIM_30,		 0x9091A1C8 },

	{ 0x00003014,			 0x0200EE0E },

	{ CS35L41_BSTCVRT_DCM_CTRL,	 0x00000051 },

	{ 0x00000054,			 0x00000004 },

	{ CS35L41_IRQ1_DB3,		 0x00000000 },

	{ CS35L41_IRQ2_DB3,		 0x00000000 },

	{ CS35L41_DSP1_YM_ACCEL_PL0_PRI, 0x00000000 },

	{ CS35L41_DSP1_XM_ACCEL_PL0_PRI, 0x00000000 },

	{ 0x00000040,			 0x0000CCCC },

	{ 0x00000040,			 0x00003333 },

	{ CS35L41_PWR_CTRL2,		 0x00000000 },

	{ CS35L41_AMP_GAIN_CTRL,	 0x00000000 },

};



static const struct reg_sequence cs35l41_revb0_errata_patch[] = {

	{ 0x00000040,			 0x00005555 },

	{ 0x00000040,			 0x0000AAAA },

	{ CS35L41_VIMON_SPKMON_RESYNC,	 0x00000000 },

	{ 0x00004310,			 0x00000000 },

	{ CS35L41_VPVBST_FS_SEL,	 0x00000000 },

	{ CS35L41_BSTCVRT_DCM_CTRL,	 0x00000051 },

	{ CS35L41_DSP1_YM_ACCEL_PL0_PRI, 0x00000000 },

	{ CS35L41_DSP1_XM_ACCEL_PL0_PRI, 0x00000000 },

	{ 0x00000040,			 0x0000CCCC },

	{ 0x00000040,			 0x00003333 },

	{ CS35L41_PWR_CTRL2,		 0x00000000 },

	{ CS35L41_AMP_GAIN_CTRL,	 0x00000000 },

};



static const struct reg_sequence cs35l41_revb2_errata_patch[] = {

	{ 0x00000040,			 0x00005555 },

	{ 0x00000040,			 0x0000AAAA },

	{ CS35L41_VIMON_SPKMON_RESYNC,	 0x00000000 },

	{ 0x00004310,			 0x00000000 },

	{ CS35L41_VPVBST_FS_SEL,	 0x00000000 },

	{ CS35L41_BSTCVRT_DCM_CTRL,	 0x00000051 },

	{ CS35L41_DSP1_YM_ACCEL_PL0_PRI, 0x00000000 },

	{ CS35L41_DSP1_XM_ACCEL_PL0_PRI, 0x00000000 },

	{ 0x00000040,			 0x0000CCCC },

	{ 0x00000040,			 0x00003333 },

	{ CS35L41_PWR_CTRL2,		 0x00000000 },

	{ CS35L41_AMP_GAIN_CTRL,	 0x00000000 },

};



static const struct cs35l41_otp_map_element_t cs35l41_otp_map_map[] = {

	{

		.id = 0x01,

		.map = otp_map_1,
@@ -721,3 +780,291 @@ struct regmap_config cs35l41_regmap_spi = { 
	.cache_type = REGCACHE_RBTREE,

};

EXPORT_SYMBOL_GPL(cs35l41_regmap_spi);



static const struct cs35l41_otp_map_element_t *cs35l41_find_otp_map(u32 otp_id)

{

	int i;



	for (i = 0; i < ARRAY_SIZE(cs35l41_otp_map_map); i++) {

		if (cs35l41_otp_map_map[i].id == otp_id)

			return &cs35l41_otp_map_map[i];

	}



	return NULL;

}



int cs35l41_otp_unpack(struct device *dev, struct regmap *regmap)

{

	const struct cs35l41_otp_map_element_t *otp_map_match;

	const struct cs35l41_otp_packed_element_t *otp_map;

	int bit_offset, word_offset, ret, i;

	unsigned int bit_sum = 8;

	u32 otp_val, otp_id_reg;

	u32 *otp_mem;



	otp_mem = kmalloc_array(CS35L41_OTP_SIZE_WORDS, sizeof(*otp_mem), GFP_KERNEL);

	if (!otp_mem)

		return -ENOMEM;



	ret = regmap_read(regmap, CS35L41_OTPID, &otp_id_reg);

	if (ret) {

		dev_err(dev, "Read OTP ID failed: %d\n", ret);

		goto err_otp_unpack;

	}



	otp_map_match = cs35l41_find_otp_map(otp_id_reg);



	if (!otp_map_match) {

		dev_err(dev, "OTP Map matching ID %d not found\n", otp_id_reg);

		ret = -EINVAL;

		goto err_otp_unpack;

	}



	ret = regmap_bulk_read(regmap, CS35L41_OTP_MEM0, otp_mem, CS35L41_OTP_SIZE_WORDS);

	if (ret) {

		dev_err(dev, "Read OTP Mem failed: %d\n", ret);

		goto err_otp_unpack;

	}



	otp_map = otp_map_match->map;



	bit_offset = otp_map_match->bit_offset;

	word_offset = otp_map_match->word_offset;



	ret = regmap_write(regmap, CS35L41_TEST_KEY_CTL, 0x00000055);

	if (ret) {

		dev_err(dev, "Write Unlock key failed 1/2: %d\n", ret);

		goto err_otp_unpack;

	}

	ret = regmap_write(regmap, CS35L41_TEST_KEY_CTL, 0x000000AA);

	if (ret) {

		dev_err(dev, "Write Unlock key failed 2/2: %d\n", ret);

		goto err_otp_unpack;

	}



	for (i = 0; i < otp_map_match->num_elements; i++) {

		dev_dbg(dev, "bitoffset= %d, word_offset=%d, bit_sum mod 32=%d\n",

			bit_offset, word_offset, bit_sum % 32);

		if (bit_offset + otp_map[i].size - 1 >= 32) {

			otp_val = (otp_mem[word_offset] &

					GENMASK(31, bit_offset)) >> bit_offset;

			otp_val |= (otp_mem[++word_offset] &

					GENMASK(bit_offset + otp_map[i].size - 33, 0)) <<

					(32 - bit_offset);

			bit_offset += otp_map[i].size - 32;

		} else {

			otp_val = (otp_mem[word_offset] &

				   GENMASK(bit_offset + otp_map[i].size - 1, bit_offset)

				  ) >> bit_offset;

			bit_offset += otp_map[i].size;

		}

		bit_sum += otp_map[i].size;



		if (bit_offset == 32) {

			bit_offset = 0;

			word_offset++;

		}



		if (otp_map[i].reg != 0) {

			ret = regmap_update_bits(regmap, otp_map[i].reg,

						 GENMASK(otp_map[i].shift + otp_map[i].size - 1,

							 otp_map[i].shift),

						 otp_val << otp_map[i].shift);

			if (ret < 0) {

				dev_err(dev, "Write OTP val failed: %d\n", ret);

				goto err_otp_unpack;

			}

		}

	}



	ret = regmap_write(regmap, CS35L41_TEST_KEY_CTL, 0x000000CC);

	if (ret) {

		dev_err(dev, "Write Lock key failed 1/2: %d\n", ret);

		goto err_otp_unpack;

	}

	ret = regmap_write(regmap, CS35L41_TEST_KEY_CTL, 0x00000033);

	if (ret) {

		dev_err(dev, "Write Lock key failed 2/2: %d\n", ret);

		goto err_otp_unpack;

	}

	ret = 0;



err_otp_unpack:

	kfree(otp_mem);



	return ret;

}

EXPORT_SYMBOL_GPL(cs35l41_otp_unpack);



int cs35l41_register_errata_patch(struct device *dev, struct regmap *reg, unsigned int reg_revid)

{

	char *rev;

	int ret;



	switch (reg_revid) {

	case CS35L41_REVID_A0:

		ret = regmap_register_patch(reg, cs35l41_reva0_errata_patch,

					    ARRAY_SIZE(cs35l41_reva0_errata_patch));

		rev = "A0";

		break;

	case CS35L41_REVID_B0:

		ret = regmap_register_patch(reg, cs35l41_revb0_errata_patch,

					    ARRAY_SIZE(cs35l41_revb0_errata_patch));

		rev = "B0";

		break;

	case CS35L41_REVID_B2:

		ret = regmap_register_patch(reg, cs35l41_revb2_errata_patch,

					    ARRAY_SIZE(cs35l41_revb2_errata_patch));

		rev = "B2";

		break;

	default:

		ret = -EINVAL;

		rev = "XX";

		break;

	}



	if (ret)

		dev_err(dev, "Failed to apply %s errata patch: %d\n", rev, ret);



	ret = regmap_write(reg, CS35L41_DSP1_CCM_CORE_CTRL, 0);

	if (ret < 0)

		dev_err(dev, "Write CCM_CORE_CTRL failed: %d\n", ret);



	return ret;

}

EXPORT_SYMBOL_GPL(cs35l41_register_errata_patch);



int cs35l41_set_channels(struct device *dev, struct regmap *reg,

			 unsigned int tx_num, unsigned int *tx_slot,

			 unsigned int rx_num, unsigned int *rx_slot)

{

	unsigned int val, mask;

	int i;



	if (tx_num > 4 || rx_num > 2)

		return -EINVAL;



	val = 0;

	mask = 0;

	for (i = 0; i < rx_num; i++) {

		dev_dbg(dev, "rx slot %d position = %d\n", i, rx_slot[i]);

		val |= rx_slot[i] << (i * 8);

		mask |= 0x3F << (i * 8);

	}

	regmap_update_bits(reg, CS35L41_SP_FRAME_RX_SLOT, mask, val);



	val = 0;

	mask = 0;

	for (i = 0; i < tx_num; i++) {

		dev_dbg(dev, "tx slot %d position = %d\n", i, tx_slot[i]);

		val |= tx_slot[i] << (i * 8);

		mask |= 0x3F << (i * 8);

	}

	regmap_update_bits(reg, CS35L41_SP_FRAME_TX_SLOT, mask, val);



	return 0;

}

EXPORT_SYMBOL_GPL(cs35l41_set_channels);



static const unsigned char cs35l41_bst_k1_table[4][5] = {

	{ 0x24, 0x32, 0x32, 0x4F, 0x57 },

	{ 0x24, 0x32, 0x32, 0x4F, 0x57 },

	{ 0x40, 0x32, 0x32, 0x4F, 0x57 },

	{ 0x40, 0x32, 0x32, 0x4F, 0x57 }

};



static const unsigned char cs35l41_bst_k2_table[4][5] = {

	{ 0x24, 0x49, 0x66, 0xA3, 0xEA },

	{ 0x24, 0x49, 0x66, 0xA3, 0xEA },

	{ 0x48, 0x49, 0x66, 0xA3, 0xEA },

	{ 0x48, 0x49, 0x66, 0xA3, 0xEA }

};



static const unsigned char cs35l41_bst_slope_table[4] = {

	0x75, 0x6B, 0x3B, 0x28

};





int cs35l41_boost_config(struct device *dev, struct regmap *regmap, int boost_ind, int boost_cap,

			 int boost_ipk)

{

	unsigned char bst_lbst_val, bst_cbst_range, bst_ipk_scaled;

	int ret;



	switch (boost_ind) {

	case 1000:	/* 1.0 uH */

		bst_lbst_val = 0;

		break;

	case 1200:	/* 1.2 uH */

		bst_lbst_val = 1;

		break;

	case 1500:	/* 1.5 uH */

		bst_lbst_val = 2;

		break;

	case 2200:	/* 2.2 uH */

		bst_lbst_val = 3;

		break;

	default:

		dev_err(dev, "Invalid boost inductor value: %d nH\n", boost_ind);

		return -EINVAL;

	}



	switch (boost_cap) {

	case 0 ... 19:

		bst_cbst_range = 0;

		break;

	case 20 ... 50:

		bst_cbst_range = 1;

		break;

	case 51 ... 100:

		bst_cbst_range = 2;

		break;

	case 101 ... 200:

		bst_cbst_range = 3;

		break;

	default:	/* 201 uF and greater */

		bst_cbst_range = 4;

	}



	ret = regmap_update_bits(regmap, CS35L41_BSTCVRT_COEFF,

				 CS35L41_BST_K1_MASK | CS35L41_BST_K2_MASK,

				 cs35l41_bst_k1_table[bst_lbst_val][bst_cbst_range]

					<< CS35L41_BST_K1_SHIFT |

				 cs35l41_bst_k2_table[bst_lbst_val][bst_cbst_range]

					<< CS35L41_BST_K2_SHIFT);

	if (ret) {

		dev_err(dev, "Failed to write boost coefficients: %d\n", ret);

		return ret;

	}



	ret = regmap_update_bits(regmap, CS35L41_BSTCVRT_SLOPE_LBST,

				 CS35L41_BST_SLOPE_MASK | CS35L41_BST_LBST_VAL_MASK,

				 cs35l41_bst_slope_table[bst_lbst_val]

					<< CS35L41_BST_SLOPE_SHIFT |

				 bst_lbst_val << CS35L41_BST_LBST_VAL_SHIFT);

	if (ret) {

		dev_err(dev, "Failed to write boost slope/inductor value: %d\n", ret);

		return ret;

	}



	if (boost_ipk < 1600 || boost_ipk > 4500) {

		dev_err(dev, "Invalid boost inductor peak current: %d mA\n", boost_ipk);

		return -EINVAL;

	}

	bst_ipk_scaled = ((boost_ipk - 1600) / 50) + 0x10;



	ret = regmap_update_bits(regmap, CS35L41_BSTCVRT_PEAK_CUR, CS35L41_BST_IPK_MASK,

				 bst_ipk_scaled << CS35L41_BST_IPK_SHIFT);

	if (ret) {

		dev_err(dev, "Failed to write boost inductor peak current: %d\n", ret);

		return ret;

	}



	return 0;

}

EXPORT_SYMBOL_GPL(cs35l41_boost_config);



MODULE_DESCRIPTION("CS35L41 library");

MODULE_AUTHOR("David Rhodes, Cirrus Logic Inc, <david.rhodes@cirrus.com>");

MODULE_AUTHOR("Lucas Tanure, Cirrus Logic Inc, <tanureal@opensource.cirrus.com>");

MODULE_LICENSE("GPL");