cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

tas6424.c (24160B)


      1// SPDX-License-Identifier: GPL-2.0
      2/*
      3 * ALSA SoC Texas Instruments TAS6424 Quad-Channel Audio Amplifier
      4 *
      5 * Copyright (C) 2016-2017 Texas Instruments Incorporated - https://www.ti.com/
      6 *	Author: Andreas Dannenberg <dannenberg@ti.com>
      7 *	Andrew F. Davis <afd@ti.com>
      8 */
      9
     10#include <linux/module.h>
     11#include <linux/errno.h>
     12#include <linux/device.h>
     13#include <linux/i2c.h>
     14#include <linux/pm_runtime.h>
     15#include <linux/regmap.h>
     16#include <linux/slab.h>
     17#include <linux/regulator/consumer.h>
     18#include <linux/delay.h>
     19#include <linux/gpio/consumer.h>
     20
     21#include <sound/pcm.h>
     22#include <sound/pcm_params.h>
     23#include <sound/soc.h>
     24#include <sound/soc-dapm.h>
     25#include <sound/tlv.h>
     26
     27#include "tas6424.h"
     28
     29/* Define how often to check (and clear) the fault status register (in ms) */
     30#define TAS6424_FAULT_CHECK_INTERVAL 200
     31
     32static const char * const tas6424_supply_names[] = {
     33	"dvdd", /* Digital power supply. Connect to 3.3-V supply. */
     34	"vbat", /* Supply used for higher voltage analog circuits. */
     35	"pvdd", /* Class-D amp output FETs supply. */
     36};
     37#define TAS6424_NUM_SUPPLIES ARRAY_SIZE(tas6424_supply_names)
     38
     39struct tas6424_data {
     40	struct device *dev;
     41	struct regmap *regmap;
     42	struct regulator_bulk_data supplies[TAS6424_NUM_SUPPLIES];
     43	struct delayed_work fault_check_work;
     44	unsigned int last_cfault;
     45	unsigned int last_fault1;
     46	unsigned int last_fault2;
     47	unsigned int last_warn;
     48	struct gpio_desc *standby_gpio;
     49	struct gpio_desc *mute_gpio;
     50};
     51
     52/*
     53 * DAC digital volumes. From -103.5 to 24 dB in 0.5 dB steps. Note that
     54 * setting the gain below -100 dB (register value <0x7) is effectively a MUTE
     55 * as per device datasheet.
     56 */
     57static DECLARE_TLV_DB_SCALE(dac_tlv, -10350, 50, 0);
     58
     59static const struct snd_kcontrol_new tas6424_snd_controls[] = {
     60	SOC_SINGLE_TLV("Speaker Driver CH1 Playback Volume",
     61		       TAS6424_CH1_VOL_CTRL, 0, 0xff, 0, dac_tlv),
     62	SOC_SINGLE_TLV("Speaker Driver CH2 Playback Volume",
     63		       TAS6424_CH2_VOL_CTRL, 0, 0xff, 0, dac_tlv),
     64	SOC_SINGLE_TLV("Speaker Driver CH3 Playback Volume",
     65		       TAS6424_CH3_VOL_CTRL, 0, 0xff, 0, dac_tlv),
     66	SOC_SINGLE_TLV("Speaker Driver CH4 Playback Volume",
     67		       TAS6424_CH4_VOL_CTRL, 0, 0xff, 0, dac_tlv),
     68	SOC_SINGLE_STROBE("Auto Diagnostics Switch", TAS6424_DC_DIAG_CTRL1,
     69			  TAS6424_LDGBYPASS_SHIFT, 1),
     70};
     71
     72static int tas6424_dac_event(struct snd_soc_dapm_widget *w,
     73			     struct snd_kcontrol *kcontrol, int event)
     74{
     75	struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
     76	struct tas6424_data *tas6424 = snd_soc_component_get_drvdata(component);
     77
     78	dev_dbg(component->dev, "%s() event=0x%0x\n", __func__, event);
     79
     80	if (event & SND_SOC_DAPM_POST_PMU) {
     81		/* Observe codec shutdown-to-active time */
     82		msleep(12);
     83
     84		/* Turn on TAS6424 periodic fault checking/handling */
     85		tas6424->last_fault1 = 0;
     86		tas6424->last_fault2 = 0;
     87		tas6424->last_warn = 0;
     88		schedule_delayed_work(&tas6424->fault_check_work,
     89				      msecs_to_jiffies(TAS6424_FAULT_CHECK_INTERVAL));
     90	} else if (event & SND_SOC_DAPM_PRE_PMD) {
     91		/* Disable TAS6424 periodic fault checking/handling */
     92		cancel_delayed_work_sync(&tas6424->fault_check_work);
     93	}
     94
     95	return 0;
     96}
     97
     98static const struct snd_soc_dapm_widget tas6424_dapm_widgets[] = {
     99	SND_SOC_DAPM_AIF_IN("DAC IN", "Playback", 0, SND_SOC_NOPM, 0, 0),
    100	SND_SOC_DAPM_DAC_E("DAC", NULL, SND_SOC_NOPM, 0, 0, tas6424_dac_event,
    101			   SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
    102	SND_SOC_DAPM_OUTPUT("OUT")
    103};
    104
    105static const struct snd_soc_dapm_route tas6424_audio_map[] = {
    106	{ "DAC", NULL, "DAC IN" },
    107	{ "OUT", NULL, "DAC" },
    108};
    109
    110static int tas6424_hw_params(struct snd_pcm_substream *substream,
    111			     struct snd_pcm_hw_params *params,
    112			     struct snd_soc_dai *dai)
    113{
    114	struct snd_soc_component *component = dai->component;
    115	unsigned int rate = params_rate(params);
    116	unsigned int width = params_width(params);
    117	u8 sap_ctrl = 0;
    118
    119	dev_dbg(component->dev, "%s() rate=%u width=%u\n", __func__, rate, width);
    120
    121	switch (rate) {
    122	case 44100:
    123		sap_ctrl |= TAS6424_SAP_RATE_44100;
    124		break;
    125	case 48000:
    126		sap_ctrl |= TAS6424_SAP_RATE_48000;
    127		break;
    128	case 96000:
    129		sap_ctrl |= TAS6424_SAP_RATE_96000;
    130		break;
    131	default:
    132		dev_err(component->dev, "unsupported sample rate: %u\n", rate);
    133		return -EINVAL;
    134	}
    135
    136	switch (width) {
    137	case 16:
    138		sap_ctrl |= TAS6424_SAP_TDM_SLOT_SZ_16;
    139		break;
    140	case 24:
    141		break;
    142	default:
    143		dev_err(component->dev, "unsupported sample width: %u\n", width);
    144		return -EINVAL;
    145	}
    146
    147	snd_soc_component_update_bits(component, TAS6424_SAP_CTRL,
    148			    TAS6424_SAP_RATE_MASK |
    149			    TAS6424_SAP_TDM_SLOT_SZ_16,
    150			    sap_ctrl);
    151
    152	return 0;
    153}
    154
    155static int tas6424_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt)
    156{
    157	struct snd_soc_component *component = dai->component;
    158	u8 serial_format = 0;
    159
    160	dev_dbg(component->dev, "%s() fmt=0x%0x\n", __func__, fmt);
    161
    162	/* clock masters */
    163	switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
    164	case SND_SOC_DAIFMT_CBS_CFS:
    165		break;
    166	default:
    167		dev_err(component->dev, "Invalid DAI master/slave interface\n");
    168		return -EINVAL;
    169	}
    170
    171	/* signal polarity */
    172	switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
    173	case SND_SOC_DAIFMT_NB_NF:
    174		break;
    175	default:
    176		dev_err(component->dev, "Invalid DAI clock signal polarity\n");
    177		return -EINVAL;
    178	}
    179
    180	/* interface format */
    181	switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
    182	case SND_SOC_DAIFMT_I2S:
    183		serial_format |= TAS6424_SAP_I2S;
    184		break;
    185	case SND_SOC_DAIFMT_DSP_A:
    186		serial_format |= TAS6424_SAP_DSP;
    187		break;
    188	case SND_SOC_DAIFMT_DSP_B:
    189		/*
    190		 * We can use the fact that the TAS6424 does not care about the
    191		 * LRCLK duty cycle during TDM to receive DSP_B formatted data
    192		 * in LEFTJ mode (no delaying of the 1st data bit).
    193		 */
    194		serial_format |= TAS6424_SAP_LEFTJ;
    195		break;
    196	case SND_SOC_DAIFMT_LEFT_J:
    197		serial_format |= TAS6424_SAP_LEFTJ;
    198		break;
    199	default:
    200		dev_err(component->dev, "Invalid DAI interface format\n");
    201		return -EINVAL;
    202	}
    203
    204	snd_soc_component_update_bits(component, TAS6424_SAP_CTRL,
    205			    TAS6424_SAP_FMT_MASK, serial_format);
    206
    207	return 0;
    208}
    209
    210static int tas6424_set_dai_tdm_slot(struct snd_soc_dai *dai,
    211				    unsigned int tx_mask, unsigned int rx_mask,
    212				    int slots, int slot_width)
    213{
    214	struct snd_soc_component *component = dai->component;
    215	unsigned int first_slot, last_slot;
    216	bool sap_tdm_slot_last;
    217
    218	dev_dbg(component->dev, "%s() tx_mask=%d rx_mask=%d\n", __func__,
    219		tx_mask, rx_mask);
    220
    221	if (!tx_mask || !rx_mask)
    222		return 0; /* nothing needed to disable TDM mode */
    223
    224	/*
    225	 * Determine the first slot and last slot that is being requested so
    226	 * we'll be able to more easily enforce certain constraints as the
    227	 * TAS6424's TDM interface is not fully configurable.
    228	 */
    229	first_slot = __ffs(tx_mask);
    230	last_slot = __fls(rx_mask);
    231
    232	if (last_slot - first_slot != 4) {
    233		dev_err(component->dev, "tdm mask must cover 4 contiguous slots\n");
    234		return -EINVAL;
    235	}
    236
    237	switch (first_slot) {
    238	case 0:
    239		sap_tdm_slot_last = false;
    240		break;
    241	case 4:
    242		sap_tdm_slot_last = true;
    243		break;
    244	default:
    245		dev_err(component->dev, "tdm mask must start at slot 0 or 4\n");
    246		return -EINVAL;
    247	}
    248
    249	snd_soc_component_update_bits(component, TAS6424_SAP_CTRL, TAS6424_SAP_TDM_SLOT_LAST,
    250			    sap_tdm_slot_last ? TAS6424_SAP_TDM_SLOT_LAST : 0);
    251
    252	return 0;
    253}
    254
    255static int tas6424_mute(struct snd_soc_dai *dai, int mute, int direction)
    256{
    257	struct snd_soc_component *component = dai->component;
    258	struct tas6424_data *tas6424 = snd_soc_component_get_drvdata(component);
    259	unsigned int val;
    260
    261	dev_dbg(component->dev, "%s() mute=%d\n", __func__, mute);
    262
    263	if (tas6424->mute_gpio) {
    264		gpiod_set_value_cansleep(tas6424->mute_gpio, mute);
    265		return 0;
    266	}
    267
    268	if (mute)
    269		val = TAS6424_ALL_STATE_MUTE;
    270	else
    271		val = TAS6424_ALL_STATE_PLAY;
    272
    273	snd_soc_component_write(component, TAS6424_CH_STATE_CTRL, val);
    274
    275	return 0;
    276}
    277
    278static int tas6424_power_off(struct snd_soc_component *component)
    279{
    280	struct tas6424_data *tas6424 = snd_soc_component_get_drvdata(component);
    281	int ret;
    282
    283	snd_soc_component_write(component, TAS6424_CH_STATE_CTRL, TAS6424_ALL_STATE_HIZ);
    284
    285	regcache_cache_only(tas6424->regmap, true);
    286	regcache_mark_dirty(tas6424->regmap);
    287
    288	ret = regulator_bulk_disable(ARRAY_SIZE(tas6424->supplies),
    289				     tas6424->supplies);
    290	if (ret < 0) {
    291		dev_err(component->dev, "failed to disable supplies: %d\n", ret);
    292		return ret;
    293	}
    294
    295	return 0;
    296}
    297
    298static int tas6424_power_on(struct snd_soc_component *component)
    299{
    300	struct tas6424_data *tas6424 = snd_soc_component_get_drvdata(component);
    301	int ret;
    302	u8 chan_states;
    303	int no_auto_diags = 0;
    304	unsigned int reg_val;
    305
    306	if (!regmap_read(tas6424->regmap, TAS6424_DC_DIAG_CTRL1, &reg_val))
    307		no_auto_diags = reg_val & TAS6424_LDGBYPASS_MASK;
    308
    309	ret = regulator_bulk_enable(ARRAY_SIZE(tas6424->supplies),
    310				    tas6424->supplies);
    311	if (ret < 0) {
    312		dev_err(component->dev, "failed to enable supplies: %d\n", ret);
    313		return ret;
    314	}
    315
    316	regcache_cache_only(tas6424->regmap, false);
    317
    318	ret = regcache_sync(tas6424->regmap);
    319	if (ret < 0) {
    320		dev_err(component->dev, "failed to sync regcache: %d\n", ret);
    321		return ret;
    322	}
    323
    324	if (tas6424->mute_gpio) {
    325		gpiod_set_value_cansleep(tas6424->mute_gpio, 0);
    326		/*
    327		 * channels are muted via the mute pin.  Don't also mute
    328		 * them via the registers so that subsequent register
    329		 * access is not necessary to un-mute the channels
    330		 */
    331		chan_states = TAS6424_ALL_STATE_PLAY;
    332	} else {
    333		chan_states = TAS6424_ALL_STATE_MUTE;
    334	}
    335	snd_soc_component_write(component, TAS6424_CH_STATE_CTRL, chan_states);
    336
    337	/* any time we come out of HIZ, the output channels automatically run DC
    338	 * load diagnostics if autodiagnotics are enabled. wait here until this
    339	 * completes.
    340	 */
    341	if (!no_auto_diags)
    342		msleep(230);
    343
    344	return 0;
    345}
    346
    347static int tas6424_set_bias_level(struct snd_soc_component *component,
    348				  enum snd_soc_bias_level level)
    349{
    350	dev_dbg(component->dev, "%s() level=%d\n", __func__, level);
    351
    352	switch (level) {
    353	case SND_SOC_BIAS_ON:
    354	case SND_SOC_BIAS_PREPARE:
    355		break;
    356	case SND_SOC_BIAS_STANDBY:
    357		if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF)
    358			tas6424_power_on(component);
    359		break;
    360	case SND_SOC_BIAS_OFF:
    361		tas6424_power_off(component);
    362		break;
    363	}
    364
    365	return 0;
    366}
    367
    368static struct snd_soc_component_driver soc_codec_dev_tas6424 = {
    369	.set_bias_level		= tas6424_set_bias_level,
    370	.controls		= tas6424_snd_controls,
    371	.num_controls		= ARRAY_SIZE(tas6424_snd_controls),
    372	.dapm_widgets		= tas6424_dapm_widgets,
    373	.num_dapm_widgets	= ARRAY_SIZE(tas6424_dapm_widgets),
    374	.dapm_routes		= tas6424_audio_map,
    375	.num_dapm_routes	= ARRAY_SIZE(tas6424_audio_map),
    376	.use_pmdown_time	= 1,
    377	.endianness		= 1,
    378	.non_legacy_dai_naming	= 1,
    379};
    380
    381static const struct snd_soc_dai_ops tas6424_speaker_dai_ops = {
    382	.hw_params	= tas6424_hw_params,
    383	.set_fmt	= tas6424_set_dai_fmt,
    384	.set_tdm_slot	= tas6424_set_dai_tdm_slot,
    385	.mute_stream	= tas6424_mute,
    386	.no_capture_mute = 1,
    387};
    388
    389static struct snd_soc_dai_driver tas6424_dai[] = {
    390	{
    391		.name = "tas6424-amplifier",
    392		.playback = {
    393			.stream_name = "Playback",
    394			.channels_min = 1,
    395			.channels_max = 4,
    396			.rates = TAS6424_RATES,
    397			.formats = TAS6424_FORMATS,
    398		},
    399		.ops = &tas6424_speaker_dai_ops,
    400	},
    401};
    402
    403static void tas6424_fault_check_work(struct work_struct *work)
    404{
    405	struct tas6424_data *tas6424 = container_of(work, struct tas6424_data,
    406						    fault_check_work.work);
    407	struct device *dev = tas6424->dev;
    408	unsigned int reg;
    409	int ret;
    410
    411	ret = regmap_read(tas6424->regmap, TAS6424_CHANNEL_FAULT, &reg);
    412	if (ret < 0) {
    413		dev_err(dev, "failed to read CHANNEL_FAULT register: %d\n", ret);
    414		goto out;
    415	}
    416
    417	if (!reg) {
    418		tas6424->last_cfault = reg;
    419		goto check_global_fault1_reg;
    420	}
    421
    422	/*
    423	 * Only flag errors once for a given occurrence. This is needed as
    424	 * the TAS6424 will take time clearing the fault condition internally
    425	 * during which we don't want to bombard the system with the same
    426	 * error message over and over.
    427	 */
    428	if ((reg & TAS6424_FAULT_OC_CH1) && !(tas6424->last_cfault & TAS6424_FAULT_OC_CH1))
    429		dev_crit(dev, "experienced a channel 1 overcurrent fault\n");
    430
    431	if ((reg & TAS6424_FAULT_OC_CH2) && !(tas6424->last_cfault & TAS6424_FAULT_OC_CH2))
    432		dev_crit(dev, "experienced a channel 2 overcurrent fault\n");
    433
    434	if ((reg & TAS6424_FAULT_OC_CH3) && !(tas6424->last_cfault & TAS6424_FAULT_OC_CH3))
    435		dev_crit(dev, "experienced a channel 3 overcurrent fault\n");
    436
    437	if ((reg & TAS6424_FAULT_OC_CH4) && !(tas6424->last_cfault & TAS6424_FAULT_OC_CH4))
    438		dev_crit(dev, "experienced a channel 4 overcurrent fault\n");
    439
    440	if ((reg & TAS6424_FAULT_DC_CH1) && !(tas6424->last_cfault & TAS6424_FAULT_DC_CH1))
    441		dev_crit(dev, "experienced a channel 1 DC fault\n");
    442
    443	if ((reg & TAS6424_FAULT_DC_CH2) && !(tas6424->last_cfault & TAS6424_FAULT_DC_CH2))
    444		dev_crit(dev, "experienced a channel 2 DC fault\n");
    445
    446	if ((reg & TAS6424_FAULT_DC_CH3) && !(tas6424->last_cfault & TAS6424_FAULT_DC_CH3))
    447		dev_crit(dev, "experienced a channel 3 DC fault\n");
    448
    449	if ((reg & TAS6424_FAULT_DC_CH4) && !(tas6424->last_cfault & TAS6424_FAULT_DC_CH4))
    450		dev_crit(dev, "experienced a channel 4 DC fault\n");
    451
    452	/* Store current fault1 value so we can detect any changes next time */
    453	tas6424->last_cfault = reg;
    454
    455check_global_fault1_reg:
    456	ret = regmap_read(tas6424->regmap, TAS6424_GLOB_FAULT1, &reg);
    457	if (ret < 0) {
    458		dev_err(dev, "failed to read GLOB_FAULT1 register: %d\n", ret);
    459		goto out;
    460	}
    461
    462	/*
    463	 * Ignore any clock faults as there is no clean way to check for them.
    464	 * We would need to start checking for those faults *after* the SAIF
    465	 * stream has been setup, and stop checking *before* the stream is
    466	 * stopped to avoid any false-positives. However there are no
    467	 * appropriate hooks to monitor these events.
    468	 */
    469	reg &= TAS6424_FAULT_PVDD_OV |
    470	       TAS6424_FAULT_VBAT_OV |
    471	       TAS6424_FAULT_PVDD_UV |
    472	       TAS6424_FAULT_VBAT_UV;
    473
    474	if (!reg) {
    475		tas6424->last_fault1 = reg;
    476		goto check_global_fault2_reg;
    477	}
    478
    479	if ((reg & TAS6424_FAULT_PVDD_OV) && !(tas6424->last_fault1 & TAS6424_FAULT_PVDD_OV))
    480		dev_crit(dev, "experienced a PVDD overvoltage fault\n");
    481
    482	if ((reg & TAS6424_FAULT_VBAT_OV) && !(tas6424->last_fault1 & TAS6424_FAULT_VBAT_OV))
    483		dev_crit(dev, "experienced a VBAT overvoltage fault\n");
    484
    485	if ((reg & TAS6424_FAULT_PVDD_UV) && !(tas6424->last_fault1 & TAS6424_FAULT_PVDD_UV))
    486		dev_crit(dev, "experienced a PVDD undervoltage fault\n");
    487
    488	if ((reg & TAS6424_FAULT_VBAT_UV) && !(tas6424->last_fault1 & TAS6424_FAULT_VBAT_UV))
    489		dev_crit(dev, "experienced a VBAT undervoltage fault\n");
    490
    491	/* Store current fault1 value so we can detect any changes next time */
    492	tas6424->last_fault1 = reg;
    493
    494check_global_fault2_reg:
    495	ret = regmap_read(tas6424->regmap, TAS6424_GLOB_FAULT2, &reg);
    496	if (ret < 0) {
    497		dev_err(dev, "failed to read GLOB_FAULT2 register: %d\n", ret);
    498		goto out;
    499	}
    500
    501	reg &= TAS6424_FAULT_OTSD |
    502	       TAS6424_FAULT_OTSD_CH1 |
    503	       TAS6424_FAULT_OTSD_CH2 |
    504	       TAS6424_FAULT_OTSD_CH3 |
    505	       TAS6424_FAULT_OTSD_CH4;
    506
    507	if (!reg) {
    508		tas6424->last_fault2 = reg;
    509		goto check_warn_reg;
    510	}
    511
    512	if ((reg & TAS6424_FAULT_OTSD) && !(tas6424->last_fault2 & TAS6424_FAULT_OTSD))
    513		dev_crit(dev, "experienced a global overtemp shutdown\n");
    514
    515	if ((reg & TAS6424_FAULT_OTSD_CH1) && !(tas6424->last_fault2 & TAS6424_FAULT_OTSD_CH1))
    516		dev_crit(dev, "experienced an overtemp shutdown on CH1\n");
    517
    518	if ((reg & TAS6424_FAULT_OTSD_CH2) && !(tas6424->last_fault2 & TAS6424_FAULT_OTSD_CH2))
    519		dev_crit(dev, "experienced an overtemp shutdown on CH2\n");
    520
    521	if ((reg & TAS6424_FAULT_OTSD_CH3) && !(tas6424->last_fault2 & TAS6424_FAULT_OTSD_CH3))
    522		dev_crit(dev, "experienced an overtemp shutdown on CH3\n");
    523
    524	if ((reg & TAS6424_FAULT_OTSD_CH4) && !(tas6424->last_fault2 & TAS6424_FAULT_OTSD_CH4))
    525		dev_crit(dev, "experienced an overtemp shutdown on CH4\n");
    526
    527	/* Store current fault2 value so we can detect any changes next time */
    528	tas6424->last_fault2 = reg;
    529
    530check_warn_reg:
    531	ret = regmap_read(tas6424->regmap, TAS6424_WARN, &reg);
    532	if (ret < 0) {
    533		dev_err(dev, "failed to read WARN register: %d\n", ret);
    534		goto out;
    535	}
    536
    537	reg &= TAS6424_WARN_VDD_UV |
    538	       TAS6424_WARN_VDD_POR |
    539	       TAS6424_WARN_VDD_OTW |
    540	       TAS6424_WARN_VDD_OTW_CH1 |
    541	       TAS6424_WARN_VDD_OTW_CH2 |
    542	       TAS6424_WARN_VDD_OTW_CH3 |
    543	       TAS6424_WARN_VDD_OTW_CH4;
    544
    545	if (!reg) {
    546		tas6424->last_warn = reg;
    547		goto out;
    548	}
    549
    550	if ((reg & TAS6424_WARN_VDD_UV) && !(tas6424->last_warn & TAS6424_WARN_VDD_UV))
    551		dev_warn(dev, "experienced a VDD under voltage condition\n");
    552
    553	if ((reg & TAS6424_WARN_VDD_POR) && !(tas6424->last_warn & TAS6424_WARN_VDD_POR))
    554		dev_warn(dev, "experienced a VDD POR condition\n");
    555
    556	if ((reg & TAS6424_WARN_VDD_OTW) && !(tas6424->last_warn & TAS6424_WARN_VDD_OTW))
    557		dev_warn(dev, "experienced a global overtemp warning\n");
    558
    559	if ((reg & TAS6424_WARN_VDD_OTW_CH1) && !(tas6424->last_warn & TAS6424_WARN_VDD_OTW_CH1))
    560		dev_warn(dev, "experienced an overtemp warning on CH1\n");
    561
    562	if ((reg & TAS6424_WARN_VDD_OTW_CH2) && !(tas6424->last_warn & TAS6424_WARN_VDD_OTW_CH2))
    563		dev_warn(dev, "experienced an overtemp warning on CH2\n");
    564
    565	if ((reg & TAS6424_WARN_VDD_OTW_CH3) && !(tas6424->last_warn & TAS6424_WARN_VDD_OTW_CH3))
    566		dev_warn(dev, "experienced an overtemp warning on CH3\n");
    567
    568	if ((reg & TAS6424_WARN_VDD_OTW_CH4) && !(tas6424->last_warn & TAS6424_WARN_VDD_OTW_CH4))
    569		dev_warn(dev, "experienced an overtemp warning on CH4\n");
    570
    571	/* Store current warn value so we can detect any changes next time */
    572	tas6424->last_warn = reg;
    573
    574	/* Clear any warnings by toggling the CLEAR_FAULT control bit */
    575	ret = regmap_write_bits(tas6424->regmap, TAS6424_MISC_CTRL3,
    576				TAS6424_CLEAR_FAULT, TAS6424_CLEAR_FAULT);
    577	if (ret < 0)
    578		dev_err(dev, "failed to write MISC_CTRL3 register: %d\n", ret);
    579
    580	ret = regmap_write_bits(tas6424->regmap, TAS6424_MISC_CTRL3,
    581				TAS6424_CLEAR_FAULT, 0);
    582	if (ret < 0)
    583		dev_err(dev, "failed to write MISC_CTRL3 register: %d\n", ret);
    584
    585out:
    586	/* Schedule the next fault check at the specified interval */
    587	schedule_delayed_work(&tas6424->fault_check_work,
    588			      msecs_to_jiffies(TAS6424_FAULT_CHECK_INTERVAL));
    589}
    590
    591static const struct reg_default tas6424_reg_defaults[] = {
    592	{ TAS6424_MODE_CTRL,		0x00 },
    593	{ TAS6424_MISC_CTRL1,		0x32 },
    594	{ TAS6424_MISC_CTRL2,		0x62 },
    595	{ TAS6424_SAP_CTRL,		0x04 },
    596	{ TAS6424_CH_STATE_CTRL,	0x55 },
    597	{ TAS6424_CH1_VOL_CTRL,		0xcf },
    598	{ TAS6424_CH2_VOL_CTRL,		0xcf },
    599	{ TAS6424_CH3_VOL_CTRL,		0xcf },
    600	{ TAS6424_CH4_VOL_CTRL,		0xcf },
    601	{ TAS6424_DC_DIAG_CTRL1,	0x00 },
    602	{ TAS6424_DC_DIAG_CTRL2,	0x11 },
    603	{ TAS6424_DC_DIAG_CTRL3,	0x11 },
    604	{ TAS6424_PIN_CTRL,		0xff },
    605	{ TAS6424_AC_DIAG_CTRL1,	0x00 },
    606	{ TAS6424_MISC_CTRL3,		0x00 },
    607	{ TAS6424_CLIP_CTRL,		0x01 },
    608	{ TAS6424_CLIP_WINDOW,		0x14 },
    609	{ TAS6424_CLIP_WARN,		0x00 },
    610	{ TAS6424_CBC_STAT,		0x00 },
    611	{ TAS6424_MISC_CTRL4,		0x40 },
    612};
    613
    614static bool tas6424_is_writable_reg(struct device *dev, unsigned int reg)
    615{
    616	switch (reg) {
    617	case TAS6424_MODE_CTRL:
    618	case TAS6424_MISC_CTRL1:
    619	case TAS6424_MISC_CTRL2:
    620	case TAS6424_SAP_CTRL:
    621	case TAS6424_CH_STATE_CTRL:
    622	case TAS6424_CH1_VOL_CTRL:
    623	case TAS6424_CH2_VOL_CTRL:
    624	case TAS6424_CH3_VOL_CTRL:
    625	case TAS6424_CH4_VOL_CTRL:
    626	case TAS6424_DC_DIAG_CTRL1:
    627	case TAS6424_DC_DIAG_CTRL2:
    628	case TAS6424_DC_DIAG_CTRL3:
    629	case TAS6424_PIN_CTRL:
    630	case TAS6424_AC_DIAG_CTRL1:
    631	case TAS6424_MISC_CTRL3:
    632	case TAS6424_CLIP_CTRL:
    633	case TAS6424_CLIP_WINDOW:
    634	case TAS6424_CLIP_WARN:
    635	case TAS6424_CBC_STAT:
    636	case TAS6424_MISC_CTRL4:
    637		return true;
    638	default:
    639		return false;
    640	}
    641}
    642
    643static bool tas6424_is_volatile_reg(struct device *dev, unsigned int reg)
    644{
    645	switch (reg) {
    646	case TAS6424_DC_LOAD_DIAG_REP12:
    647	case TAS6424_DC_LOAD_DIAG_REP34:
    648	case TAS6424_DC_LOAD_DIAG_REPLO:
    649	case TAS6424_CHANNEL_STATE:
    650	case TAS6424_CHANNEL_FAULT:
    651	case TAS6424_GLOB_FAULT1:
    652	case TAS6424_GLOB_FAULT2:
    653	case TAS6424_WARN:
    654	case TAS6424_AC_LOAD_DIAG_REP1:
    655	case TAS6424_AC_LOAD_DIAG_REP2:
    656	case TAS6424_AC_LOAD_DIAG_REP3:
    657	case TAS6424_AC_LOAD_DIAG_REP4:
    658		return true;
    659	default:
    660		return false;
    661	}
    662}
    663
    664static const struct regmap_config tas6424_regmap_config = {
    665	.reg_bits = 8,
    666	.val_bits = 8,
    667
    668	.writeable_reg = tas6424_is_writable_reg,
    669	.volatile_reg = tas6424_is_volatile_reg,
    670
    671	.max_register = TAS6424_MAX,
    672	.reg_defaults = tas6424_reg_defaults,
    673	.num_reg_defaults = ARRAY_SIZE(tas6424_reg_defaults),
    674	.cache_type = REGCACHE_RBTREE,
    675};
    676
    677#if IS_ENABLED(CONFIG_OF)
    678static const struct of_device_id tas6424_of_ids[] = {
    679	{ .compatible = "ti,tas6424", },
    680	{ },
    681};
    682MODULE_DEVICE_TABLE(of, tas6424_of_ids);
    683#endif
    684
    685static int tas6424_i2c_probe(struct i2c_client *client)
    686{
    687	struct device *dev = &client->dev;
    688	struct tas6424_data *tas6424;
    689	int ret;
    690	int i;
    691
    692	tas6424 = devm_kzalloc(dev, sizeof(*tas6424), GFP_KERNEL);
    693	if (!tas6424)
    694		return -ENOMEM;
    695	dev_set_drvdata(dev, tas6424);
    696
    697	tas6424->dev = dev;
    698
    699	tas6424->regmap = devm_regmap_init_i2c(client, &tas6424_regmap_config);
    700	if (IS_ERR(tas6424->regmap)) {
    701		ret = PTR_ERR(tas6424->regmap);
    702		dev_err(dev, "unable to allocate register map: %d\n", ret);
    703		return ret;
    704	}
    705
    706	/*
    707	 * Get control of the standby pin and set it LOW to take the codec
    708	 * out of the stand-by mode.
    709	 * Note: The actual pin polarity is taken care of in the GPIO lib
    710	 * according the polarity specified in the DTS.
    711	 */
    712	tas6424->standby_gpio = devm_gpiod_get_optional(dev, "standby",
    713						      GPIOD_OUT_LOW);
    714	if (IS_ERR(tas6424->standby_gpio)) {
    715		if (PTR_ERR(tas6424->standby_gpio) == -EPROBE_DEFER)
    716			return -EPROBE_DEFER;
    717		dev_info(dev, "failed to get standby GPIO: %ld\n",
    718			PTR_ERR(tas6424->standby_gpio));
    719		tas6424->standby_gpio = NULL;
    720	}
    721
    722	/*
    723	 * Get control of the mute pin and set it HIGH in order to start with
    724	 * all the output muted.
    725	 * Note: The actual pin polarity is taken care of in the GPIO lib
    726	 * according the polarity specified in the DTS.
    727	 */
    728	tas6424->mute_gpio = devm_gpiod_get_optional(dev, "mute",
    729						      GPIOD_OUT_HIGH);
    730	if (IS_ERR(tas6424->mute_gpio)) {
    731		if (PTR_ERR(tas6424->mute_gpio) == -EPROBE_DEFER)
    732			return -EPROBE_DEFER;
    733		dev_info(dev, "failed to get nmute GPIO: %ld\n",
    734			PTR_ERR(tas6424->mute_gpio));
    735		tas6424->mute_gpio = NULL;
    736	}
    737
    738	for (i = 0; i < ARRAY_SIZE(tas6424->supplies); i++)
    739		tas6424->supplies[i].supply = tas6424_supply_names[i];
    740	ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(tas6424->supplies),
    741				      tas6424->supplies);
    742	if (ret) {
    743		dev_err(dev, "unable to request supplies: %d\n", ret);
    744		return ret;
    745	}
    746
    747	ret = regulator_bulk_enable(ARRAY_SIZE(tas6424->supplies),
    748				    tas6424->supplies);
    749	if (ret) {
    750		dev_err(dev, "unable to enable supplies: %d\n", ret);
    751		return ret;
    752	}
    753
    754	/* Reset device to establish well-defined startup state */
    755	ret = regmap_update_bits(tas6424->regmap, TAS6424_MODE_CTRL,
    756				 TAS6424_RESET, TAS6424_RESET);
    757	if (ret) {
    758		dev_err(dev, "unable to reset device: %d\n", ret);
    759		goto disable_regs;
    760	}
    761
    762	INIT_DELAYED_WORK(&tas6424->fault_check_work, tas6424_fault_check_work);
    763
    764	ret = devm_snd_soc_register_component(dev, &soc_codec_dev_tas6424,
    765				     tas6424_dai, ARRAY_SIZE(tas6424_dai));
    766	if (ret < 0) {
    767		dev_err(dev, "unable to register codec: %d\n", ret);
    768		goto disable_regs;
    769	}
    770
    771	return 0;
    772
    773disable_regs:
    774	regulator_bulk_disable(ARRAY_SIZE(tas6424->supplies), tas6424->supplies);
    775	return ret;
    776}
    777
    778static int tas6424_i2c_remove(struct i2c_client *client)
    779{
    780	struct device *dev = &client->dev;
    781	struct tas6424_data *tas6424 = dev_get_drvdata(dev);
    782	int ret;
    783
    784	cancel_delayed_work_sync(&tas6424->fault_check_work);
    785
    786	/* put the codec in stand-by */
    787	if (tas6424->standby_gpio)
    788		gpiod_set_value_cansleep(tas6424->standby_gpio, 1);
    789
    790	ret = regulator_bulk_disable(ARRAY_SIZE(tas6424->supplies),
    791				     tas6424->supplies);
    792	if (ret < 0)
    793		dev_err(dev, "unable to disable supplies: %d\n", ret);
    794
    795	return 0;
    796}
    797
    798static const struct i2c_device_id tas6424_i2c_ids[] = {
    799	{ "tas6424", 0 },
    800	{ }
    801};
    802MODULE_DEVICE_TABLE(i2c, tas6424_i2c_ids);
    803
    804static struct i2c_driver tas6424_i2c_driver = {
    805	.driver = {
    806		.name = "tas6424",
    807		.of_match_table = of_match_ptr(tas6424_of_ids),
    808	},
    809	.probe_new = tas6424_i2c_probe,
    810	.remove = tas6424_i2c_remove,
    811	.id_table = tas6424_i2c_ids,
    812};
    813module_i2c_driver(tas6424_i2c_driver);
    814
    815MODULE_AUTHOR("Andreas Dannenberg <dannenberg@ti.com>");
    816MODULE_AUTHOR("Andrew F. Davis <afd@ti.com>");
    817MODULE_DESCRIPTION("TAS6424 Audio amplifier driver");
    818MODULE_LICENSE("GPL v2");