Unverified Commit 0d463d01 authored by James Schulman's avatar James Schulman Committed by Mark Brown
Browse files

ASoC: cs35l45: Add driver for Cirrus Logic CS35L45 Smart Amp 



The CS35L45 is a 15 V Boosted Mono Class D Amplifier with DSP
Speaker Protection and Adaptive Battery Management.

This initial driver provides standard non-boosted audio operation
without the DSP.

Signed-off-by: default avatarJames Schulman <james.schulman@cirrus.com>
Signed-off-by: default avatarRichard Fitzgerald <rf@opensource.cirrus.com>
Link: https://lore.kernel.org/r/20220405135419.1230088-6-rf@opensource.cirrus.com


Signed-off-by: default avatarMark Brown <broonie@kernel.org>
parent 72661ff7

sound/soc/codecs/Kconfig

+30 −0
Original line number Diff line number Diff line
@@ -65,6 +65,8 @@ config SND_SOC_ALL_CODECS 
	imply SND_SOC_CS35L36

	imply SND_SOC_CS35L41_SPI

	imply SND_SOC_CS35L41_I2C

	imply SND_SOC_CS35L45_I2C

	imply SND_SOC_CS35L45_SPI

	imply SND_SOC_CS42L42

	imply SND_SOC_CS42L51_I2C

	imply SND_SOC_CS42L52
@@ -656,6 +658,34 @@ config SND_SOC_CS35L41_I2C 
	select SND_SOC_CS35L41

	select REGMAP_I2C



config SND_SOC_CS35L45_TABLES

	tristate



config SND_SOC_CS35L45

	tristate



config SND_SOC_CS35L45_SPI

	tristate "Cirrus Logic CS35L45 CODEC (SPI)"

	depends on SPI_MASTER

	select REGMAP

	select REGMAP_SPI

	select SND_SOC_CS35L45_TABLES

	select SND_SOC_CS35L45

	help

	  Enable support for Cirrus Logic CS35L45 smart speaker amplifier

	  with SPI control.



config SND_SOC_CS35L45_I2C

	tristate "Cirrus Logic CS35L45 CODEC (I2C)"

	depends on I2C

	select REGMAP

	select REGMAP_I2C

	select SND_SOC_CS35L45_TABLES

	select SND_SOC_CS35L45

	help

	  Enable support for Cirrus Logic CS35L45 smart speaker amplifier

	  with I2C control.



config SND_SOC_CS42L42

	tristate "Cirrus Logic CS42L42 CODEC"

	depends on I2C

sound/soc/codecs/Makefile

+8 −0
Original line number Diff line number Diff line
@@ -60,6 +60,10 @@ 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-cs35l45-tables-objs := cs35l45-tables.o

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

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

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

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

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

snd-soc-cs42l51-i2c-objs := cs42l51-i2c.o
@@ -406,6 +410,10 @@ 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_CS35L45_TABLES)	+= snd-soc-cs35l45-tables.o

obj-$(CONFIG_SND_SOC_CS35L45)	+= snd-soc-cs35l45.o

obj-$(CONFIG_SND_SOC_CS35L45_SPI)	+= snd-soc-cs35l45-spi.o

obj-$(CONFIG_SND_SOC_CS35L45_I2C)	+= snd-soc-cs35l45-i2c.o

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

obj-$(CONFIG_SND_SOC_CS42L51)	+= snd-soc-cs42l51.o

obj-$(CONFIG_SND_SOC_CS42L51_I2C)	+= snd-soc-cs42l51-i2c.o

sound/soc/codecs/cs35l45-i2c.c

0 → 100644
+72 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause

//

// cs35l45-i2c.c -- CS35L45 I2C driver

//

// Copyright 2019-2022 Cirrus Logic, Inc.

//

// Author: James Schulman <james.schulman@cirrus.com>



#include <linux/device.h>

#include <linux/module.h>

#include <linux/i2c.h>

#include <linux/regmap.h>



#include "cs35l45.h"



static int cs35l45_i2c_probe(struct i2c_client *client)

{

	struct cs35l45_private *cs35l45;

	struct device *dev = &client->dev;

	int ret;



	cs35l45 = devm_kzalloc(dev, sizeof(struct cs35l45_private), GFP_KERNEL);

	if (!cs35l45)

		return -ENOMEM;



	i2c_set_clientdata(client, cs35l45);

	cs35l45->regmap = devm_regmap_init_i2c(client, &cs35l45_i2c_regmap);

	if (IS_ERR(cs35l45->regmap)) {

		ret = PTR_ERR(cs35l45->regmap);

		dev_err(dev, "Failed to allocate register map: %d\n", ret);

		return ret;

	}



	cs35l45->dev = dev;



	return cs35l45_probe(cs35l45);

}



static int cs35l45_i2c_remove(struct i2c_client *client)

{

	struct cs35l45_private *cs35l45 = i2c_get_clientdata(client);



	return cs35l45_remove(cs35l45);

}



static const struct of_device_id cs35l45_of_match[] = {

	{ .compatible = "cirrus,cs35l45" },

	{},

};

MODULE_DEVICE_TABLE(of, cs35l45_of_match);



static const struct i2c_device_id cs35l45_id_i2c[] = {

	{ "cs35l45", 0 },

	{}

};

MODULE_DEVICE_TABLE(i2c, cs35l45_id_i2c);



static struct i2c_driver cs35l45_i2c_driver = {

	.driver = {

		.name		= "cs35l45",

		.of_match_table = cs35l45_of_match,

		.pm		= &cs35l45_pm_ops,

	},

	.id_table	= cs35l45_id_i2c,

	.probe_new	= cs35l45_i2c_probe,

	.remove		= cs35l45_i2c_remove,

};

module_i2c_driver(cs35l45_i2c_driver);



MODULE_DESCRIPTION("I2C CS35L45 driver");

MODULE_AUTHOR("James Schulman, Cirrus Logic Inc, <james.schulman@cirrus.com>");

MODULE_LICENSE("Dual BSD/GPL");

sound/soc/codecs/cs35l45-spi.c

0 → 100644
+72 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause

//

// cs35l45-spi.c -- CS35L45 SPI driver

//

// Copyright 2019-2022 Cirrus Logic, Inc.

//

// Author: James Schulman <james.schulman@cirrus.com>



#include <linux/device.h>

#include <linux/module.h>

#include <linux/regmap.h>

#include <linux/spi/spi.h>



#include "cs35l45.h"



static int cs35l45_spi_probe(struct spi_device *spi)

{

	struct cs35l45_private *cs35l45;

	struct device *dev = &spi->dev;

	int ret;



	cs35l45 = devm_kzalloc(dev, sizeof(struct cs35l45_private), GFP_KERNEL);

	if (cs35l45 == NULL)

		return -ENOMEM;



	spi_set_drvdata(spi, cs35l45);

	cs35l45->regmap = devm_regmap_init_spi(spi, &cs35l45_spi_regmap);

	if (IS_ERR(cs35l45->regmap)) {

		ret = PTR_ERR(cs35l45->regmap);

		dev_err(dev, "Failed to allocate register map: %d\n", ret);

		return ret;

	}



	cs35l45->dev = dev;



	return cs35l45_probe(cs35l45);

}



static void cs35l45_spi_remove(struct spi_device *spi)

{

	struct cs35l45_private *cs35l45 = spi_get_drvdata(spi);



	cs35l45_remove(cs35l45);

}



static const struct of_device_id cs35l45_of_match[] = {

	{ .compatible = "cirrus,cs35l45" },

	{},

};

MODULE_DEVICE_TABLE(of, cs35l45_of_match);



static const struct spi_device_id cs35l45_id_spi[] = {

	{ "cs35l45", 0 },

	{}

};

MODULE_DEVICE_TABLE(spi, cs35l45_id_spi);



static struct spi_driver cs35l45_spi_driver = {

	.driver = {

		.name		= "cs35l45",

		.of_match_table = cs35l45_of_match,

		.pm		= &cs35l45_pm_ops,

	},

	.id_table	= cs35l45_id_spi,

	.probe		= cs35l45_spi_probe,

	.remove		= cs35l45_spi_remove,

};

module_spi_driver(cs35l45_spi_driver);



MODULE_DESCRIPTION("SPI CS35L45 driver");

MODULE_AUTHOR("James Schulman, Cirrus Logic Inc, <james.schulman@cirrus.com>");

MODULE_LICENSE("Dual BSD/GPL");

sound/soc/codecs/cs35l45-tables.c

0 → 100644
+202 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause

//

// cs35l45-tables.c -- CS35L45 ALSA SoC audio driver

//

// Copyright 2019-2022 Cirrus Logic, Inc.

//

// Author: James Schulman <james.schulman@cirrus.com>



#include <linux/module.h>

#include <linux/regmap.h>



#include "cs35l45.h"



static const struct reg_sequence cs35l45_patch[] = {

	{ 0x00000040,			0x00000055 },

	{ 0x00000040,			0x000000AA },

	{ 0x00000044,			0x00000055 },

	{ 0x00000044,			0x000000AA },

	{ 0x00006480,			0x0830500A },

	{ 0x00007C60,			0x1000850B },

	{ CS35L45_BOOST_OV_CFG,		0x007000D0 },

	{ CS35L45_LDPM_CONFIG,		0x0001B636 },

	{ 0x00002C08,			0x00000009 },

	{ 0x00006850,			0x0A30FFC4 },

	{ 0x00003820,			0x00040100 },

	{ 0x00003824,			0x00000000 },

	{ 0x00007CFC,			0x62870004 },

	{ 0x00007C60,			0x1001850B },

	{ 0x00000040,			0x00000000 },

	{ 0x00000044,			0x00000000 },

	{ CS35L45_BOOST_CCM_CFG,	0xF0000003 },

	{ CS35L45_BOOST_DCM_CFG,	0x08710220 },

	{ CS35L45_ERROR_RELEASE,	0x00200000 },

};



int cs35l45_apply_patch(struct cs35l45_private *cs35l45)

{

	return regmap_register_patch(cs35l45->regmap, cs35l45_patch,

				     ARRAY_SIZE(cs35l45_patch));

}

EXPORT_SYMBOL_GPL(cs35l45_apply_patch);



static const struct reg_default cs35l45_defaults[] = {

	{ CS35L45_BLOCK_ENABLES,		0x00003323 },

	{ CS35L45_BLOCK_ENABLES2,		0x00000010 },

	{ CS35L45_REFCLK_INPUT,			0x00000510 },

	{ CS35L45_GLOBAL_SAMPLE_RATE,		0x00000003 },

	{ CS35L45_ASP_ENABLES1,			0x00000000 },

	{ CS35L45_ASP_CONTROL1,			0x00000028 },

	{ CS35L45_ASP_CONTROL2,			0x18180200 },

	{ CS35L45_ASP_CONTROL3,			0x00000002 },

	{ CS35L45_ASP_FRAME_CONTROL1,		0x03020100 },

	{ CS35L45_ASP_FRAME_CONTROL2,		0x00000004 },

	{ CS35L45_ASP_FRAME_CONTROL5,		0x00000100 },

	{ CS35L45_ASP_DATA_CONTROL1,		0x00000018 },

	{ CS35L45_ASP_DATA_CONTROL5,		0x00000018 },

	{ CS35L45_DACPCM1_INPUT,		0x00000008 },

	{ CS35L45_ASPTX1_INPUT,			0x00000018 },

	{ CS35L45_ASPTX2_INPUT,			0x00000019 },

	{ CS35L45_ASPTX3_INPUT,			0x00000020 },

	{ CS35L45_ASPTX4_INPUT,			0x00000028 },

	{ CS35L45_ASPTX5_INPUT,			0x00000048 },

	{ CS35L45_AMP_PCM_CONTROL,		0x00100000 },

};



static bool cs35l45_readable_reg(struct device *dev, unsigned int reg)

{

	switch (reg) {

	case CS35L45_DEVID ... CS35L45_OTPID:

	case CS35L45_SFT_RESET:

	case CS35L45_GLOBAL_ENABLES:

	case CS35L45_BLOCK_ENABLES:

	case CS35L45_BLOCK_ENABLES2:

	case CS35L45_ERROR_RELEASE:

	case CS35L45_REFCLK_INPUT:

	case CS35L45_GLOBAL_SAMPLE_RATE:

	case CS35L45_ASP_ENABLES1:

	case CS35L45_ASP_CONTROL1:

	case CS35L45_ASP_CONTROL2:

	case CS35L45_ASP_CONTROL3:

	case CS35L45_ASP_FRAME_CONTROL1:

	case CS35L45_ASP_FRAME_CONTROL2:

	case CS35L45_ASP_FRAME_CONTROL5:

	case CS35L45_ASP_DATA_CONTROL1:

	case CS35L45_ASP_DATA_CONTROL5:

	case CS35L45_DACPCM1_INPUT:

	case CS35L45_ASPTX1_INPUT:

	case CS35L45_ASPTX2_INPUT:

	case CS35L45_ASPTX3_INPUT:

	case CS35L45_ASPTX4_INPUT:

	case CS35L45_ASPTX5_INPUT:

	case CS35L45_AMP_PCM_CONTROL:

	case CS35L45_AMP_PCM_HPF_TST:

	case CS35L45_IRQ1_EINT_4:

		return true;

	default:

		return false;

	}

}



static bool cs35l45_volatile_reg(struct device *dev, unsigned int reg)

{

	switch (reg) {

	case CS35L45_DEVID ... CS35L45_OTPID:

	case CS35L45_SFT_RESET:

	case CS35L45_GLOBAL_ENABLES:

	case CS35L45_ERROR_RELEASE:

	case CS35L45_AMP_PCM_HPF_TST:	/* not cachable */

	case CS35L45_IRQ1_EINT_4:

		return true;

	default:

		return false;

	}

}



const struct regmap_config cs35l45_i2c_regmap = {

	.reg_bits = 32,

	.val_bits = 32,

	.reg_stride = 4,

	.reg_format_endian = REGMAP_ENDIAN_BIG,

	.val_format_endian = REGMAP_ENDIAN_BIG,

	.max_register = CS35L45_LASTREG,

	.reg_defaults = cs35l45_defaults,

	.num_reg_defaults = ARRAY_SIZE(cs35l45_defaults),

	.volatile_reg = cs35l45_volatile_reg,

	.readable_reg = cs35l45_readable_reg,

	.cache_type = REGCACHE_RBTREE,

};

EXPORT_SYMBOL_GPL(cs35l45_i2c_regmap);



const struct regmap_config cs35l45_spi_regmap = {

	.reg_bits = 32,

	.val_bits = 32,

	.pad_bits = 16,

	.reg_stride = 4,

	.reg_format_endian = REGMAP_ENDIAN_BIG,

	.val_format_endian = REGMAP_ENDIAN_BIG,

	.max_register = CS35L45_LASTREG,

	.reg_defaults = cs35l45_defaults,

	.num_reg_defaults = ARRAY_SIZE(cs35l45_defaults),

	.volatile_reg = cs35l45_volatile_reg,

	.readable_reg = cs35l45_readable_reg,

	.cache_type = REGCACHE_RBTREE,

};

EXPORT_SYMBOL_GPL(cs35l45_spi_regmap);



static const struct {

	u8 cfg_id;

	u32 freq;

} cs35l45_pll_refclk_freq[] = {

	{ 0x0C,   128000 },

	{ 0x0F,   256000 },

	{ 0x11,   384000 },

	{ 0x12,   512000 },

	{ 0x15,   768000 },

	{ 0x17,  1024000 },

	{ 0x19,  1411200 },

	{ 0x1B,  1536000 },

	{ 0x1C,  2116800 },

	{ 0x1D,  2048000 },

	{ 0x1E,  2304000 },

	{ 0x1F,  2822400 },

	{ 0x21,  3072000 },

	{ 0x23,  4233600 },

	{ 0x24,  4096000 },

	{ 0x25,  4608000 },

	{ 0x26,  5644800 },

	{ 0x27,  6000000 },

	{ 0x28,  6144000 },

	{ 0x29,  6350400 },

	{ 0x2A,  6912000 },

	{ 0x2D,  7526400 },

	{ 0x2E,  8467200 },

	{ 0x2F,  8192000 },

	{ 0x30,  9216000 },

	{ 0x31, 11289600 },

	{ 0x33, 12288000 },

	{ 0x37, 16934400 },

	{ 0x38, 18432000 },

	{ 0x39, 22579200 },

	{ 0x3B, 24576000 },

};



unsigned int cs35l45_get_clk_freq_id(unsigned int freq)

{

	int i;



	if (freq == 0)

		return -EINVAL;



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

		if (cs35l45_pll_refclk_freq[i].freq == freq)

			return cs35l45_pll_refclk_freq[i].cfg_id;

	}



	return -EINVAL;

}

EXPORT_SYMBOL_GPL(cs35l45_get_clk_freq_id);



MODULE_DESCRIPTION("ASoC CS35L45 driver tables");

MODULE_AUTHOR("James Schulman, Cirrus Logic Inc, <james.schulman@cirrus.com>");

MODULE_LICENSE("Dual BSD/GPL");