ak4114.c

  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 *  Routines for control of the AK4114 via I2C and 4-wire serial interface
  4 *  IEC958 (S/PDIF) receiver by Asahi Kasei
  5 *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
  6 */
  7
  8#include <linux/slab.h>
  9#include <linux/delay.h>
 10#include <linux/module.h>
 11#include <sound/core.h>
 12#include <sound/control.h>
 13#include <sound/pcm.h>
 14#include <sound/ak4114.h>
 15#include <sound/asoundef.h>
 16#include <sound/info.h>
 17
 18MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
 19MODULE_DESCRIPTION("AK4114 IEC958 (S/PDIF) receiver by Asahi Kasei");
 20MODULE_LICENSE("GPL");
 21
 22#define AK4114_ADDR			0x00 /* fixed address */
 23
 24static void ak4114_stats(struct work_struct *work);
 25static void ak4114_init_regs(struct ak4114 *chip);
 26
 27static void reg_write(struct ak4114 *ak4114, unsigned char reg, unsigned char val)
 28{
 29	ak4114->write(ak4114->private_data, reg, val);
 30	if (reg <= AK4114_REG_INT1_MASK)
 31		ak4114->regmap[reg] = val;
 32	else if (reg >= AK4114_REG_TXCSB0 && reg <= AK4114_REG_TXCSB4)
 33		ak4114->txcsb[reg-AK4114_REG_TXCSB0] = val;
 34}
 35
 36static inline unsigned char reg_read(struct ak4114 *ak4114, unsigned char reg)
 37{
 38	return ak4114->read(ak4114->private_data, reg);
 39}
 40
 41static void snd_ak4114_free(struct ak4114 *chip)
 42{
 43	atomic_inc(&chip->wq_processing);	/* don't schedule new work */
 44	cancel_delayed_work_sync(&chip->work);
 45	kfree(chip);
 46}
 47
 48static int snd_ak4114_dev_free(struct snd_device *device)
 49{
 50	struct ak4114 *chip = device->device_data;
 51	snd_ak4114_free(chip);
 52	return 0;
 53}
 54
 55int snd_ak4114_create(struct snd_card *card,
 56		      ak4114_read_t *read, ak4114_write_t *write,
 57		      const unsigned char pgm[6], const unsigned char txcsb[5],
 58		      void *private_data, struct ak4114 **r_ak4114)
 59{
 60	struct ak4114 *chip;
 61	int err = 0;
 62	unsigned char reg;
 63	static const struct snd_device_ops ops = {
 64		.dev_free =     snd_ak4114_dev_free,
 65	};
 66
 67	chip = kzalloc(sizeof(*chip), GFP_KERNEL);
 68	if (chip == NULL)
 69		return -ENOMEM;
 70	spin_lock_init(&chip->lock);
 71	chip->card = card;
 72	chip->read = read;
 73	chip->write = write;
 74	chip->private_data = private_data;
 75	INIT_DELAYED_WORK(&chip->work, ak4114_stats);
 76	atomic_set(&chip->wq_processing, 0);
 77	mutex_init(&chip->reinit_mutex);
 78
 79	for (reg = 0; reg < 6; reg++)
 80		chip->regmap[reg] = pgm[reg];
 81	for (reg = 0; reg < 5; reg++)
 82		chip->txcsb[reg] = txcsb[reg];
 83
 84	ak4114_init_regs(chip);
 85
 86	chip->rcs0 = reg_read(chip, AK4114_REG_RCS0) & ~(AK4114_QINT | AK4114_CINT);
 87	chip->rcs1 = reg_read(chip, AK4114_REG_RCS1);
 88
 89	err = snd_device_new(card, SNDRV_DEV_CODEC, chip, &ops);
 90	if (err < 0)
 91		goto __fail;
 92
 93	if (r_ak4114)
 94		*r_ak4114 = chip;
 95	return 0;
 96
 97      __fail:
 98	snd_ak4114_free(chip);
 99	return err;
100}
101EXPORT_SYMBOL(snd_ak4114_create);
102
103void snd_ak4114_reg_write(struct ak4114 *chip, unsigned char reg, unsigned char mask, unsigned char val)
104{
105	if (reg <= AK4114_REG_INT1_MASK)
106		reg_write(chip, reg, (chip->regmap[reg] & ~mask) | val);
107	else if (reg >= AK4114_REG_TXCSB0 && reg <= AK4114_REG_TXCSB4)
108		reg_write(chip, reg,
109			  (chip->txcsb[reg-AK4114_REG_TXCSB0] & ~mask) | val);
110}
111EXPORT_SYMBOL(snd_ak4114_reg_write);
112
113static void ak4114_init_regs(struct ak4114 *chip)
114{
115	unsigned char old = chip->regmap[AK4114_REG_PWRDN], reg;
116
117	/* bring the chip to reset state and powerdown state */
118	reg_write(chip, AK4114_REG_PWRDN, old & ~(AK4114_RST|AK4114_PWN));
119	udelay(200);
120	/* release reset, but leave powerdown */
121	reg_write(chip, AK4114_REG_PWRDN, (old | AK4114_RST) & ~AK4114_PWN);
122	udelay(200);
123	for (reg = 1; reg < 6; reg++)
124		reg_write(chip, reg, chip->regmap[reg]);
125	for (reg = 0; reg < 5; reg++)
126		reg_write(chip, reg + AK4114_REG_TXCSB0, chip->txcsb[reg]);
127	/* release powerdown, everything is initialized now */
128	reg_write(chip, AK4114_REG_PWRDN, old | AK4114_RST | AK4114_PWN);
129}
130
131void snd_ak4114_reinit(struct ak4114 *chip)
132{
133	if (atomic_inc_return(&chip->wq_processing) == 1)
134		cancel_delayed_work_sync(&chip->work);
135	scoped_guard(mutex, &chip->reinit_mutex) {
136		ak4114_init_regs(chip);
137	}
138	/* bring up statistics / event queing */
139	if (atomic_dec_and_test(&chip->wq_processing))
140		schedule_delayed_work(&chip->work, HZ / 10);
141}
142EXPORT_SYMBOL(snd_ak4114_reinit);
143
144static unsigned int external_rate(unsigned char rcs1)
145{
146	switch (rcs1 & (AK4114_FS0|AK4114_FS1|AK4114_FS2|AK4114_FS3)) {
147	case AK4114_FS_32000HZ: return 32000;
148	case AK4114_FS_44100HZ: return 44100;
149	case AK4114_FS_48000HZ: return 48000;
150	case AK4114_FS_88200HZ: return 88200;
151	case AK4114_FS_96000HZ: return 96000;
152	case AK4114_FS_176400HZ: return 176400;
153	case AK4114_FS_192000HZ: return 192000;
154	default:		return 0;
155	}
156}
157
158static int snd_ak4114_in_error_info(struct snd_kcontrol *kcontrol,
159				    struct snd_ctl_elem_info *uinfo)
160{
161	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
162	uinfo->count = 1;
163	uinfo->value.integer.min = 0;
164	uinfo->value.integer.max = LONG_MAX;
165	return 0;
166}
167
168static int snd_ak4114_in_error_get(struct snd_kcontrol *kcontrol,
169				   struct snd_ctl_elem_value *ucontrol)
170{
171	struct ak4114 *chip = snd_kcontrol_chip(kcontrol);
172
173	guard(spinlock_irq)(&chip->lock);
174	ucontrol->value.integer.value[0] =
175		chip->errors[kcontrol->private_value];
176	chip->errors[kcontrol->private_value] = 0;
177	return 0;
178}
179
180#define snd_ak4114_in_bit_info		snd_ctl_boolean_mono_info
181
182static int snd_ak4114_in_bit_get(struct snd_kcontrol *kcontrol,
183				 struct snd_ctl_elem_value *ucontrol)
184{
185	struct ak4114 *chip = snd_kcontrol_chip(kcontrol);
186	unsigned char reg = kcontrol->private_value & 0xff;
187	unsigned char bit = (kcontrol->private_value >> 8) & 0xff;
188	unsigned char inv = (kcontrol->private_value >> 31) & 1;
189
190	ucontrol->value.integer.value[0] = ((reg_read(chip, reg) & (1 << bit)) ? 1 : 0) ^ inv;
191	return 0;
192}
193
194static int snd_ak4114_rate_info(struct snd_kcontrol *kcontrol,
195				struct snd_ctl_elem_info *uinfo)
196{
197	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
198	uinfo->count = 1;
199	uinfo->value.integer.min = 0;
200	uinfo->value.integer.max = 192000;
201	return 0;
202}
203
204static int snd_ak4114_rate_get(struct snd_kcontrol *kcontrol,
205			       struct snd_ctl_elem_value *ucontrol)
206{
207	struct ak4114 *chip = snd_kcontrol_chip(kcontrol);
208
209	ucontrol->value.integer.value[0] = external_rate(reg_read(chip, AK4114_REG_RCS1));
210	return 0;
211}
212
213static int snd_ak4114_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
214{
215	uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
216	uinfo->count = 1;
217	return 0;
218}
219
220static int snd_ak4114_spdif_get(struct snd_kcontrol *kcontrol,
221				struct snd_ctl_elem_value *ucontrol)
222{
223	struct ak4114 *chip = snd_kcontrol_chip(kcontrol);
224	unsigned i;
225
226	for (i = 0; i < AK4114_REG_RXCSB_SIZE; i++)
227		ucontrol->value.iec958.status[i] = reg_read(chip, AK4114_REG_RXCSB0 + i);
228	return 0;
229}
230
231static int snd_ak4114_spdif_playback_get(struct snd_kcontrol *kcontrol,
232					 struct snd_ctl_elem_value *ucontrol)
233{
234	struct ak4114 *chip = snd_kcontrol_chip(kcontrol);
235	unsigned i;
236
237	for (i = 0; i < AK4114_REG_TXCSB_SIZE; i++)
238		ucontrol->value.iec958.status[i] = chip->txcsb[i];
239	return 0;
240}
241
242static int snd_ak4114_spdif_playback_put(struct snd_kcontrol *kcontrol,
243					 struct snd_ctl_elem_value *ucontrol)
244{
245	struct ak4114 *chip = snd_kcontrol_chip(kcontrol);
246	unsigned i;
247
248	for (i = 0; i < AK4114_REG_TXCSB_SIZE; i++)
249		reg_write(chip, AK4114_REG_TXCSB0 + i, ucontrol->value.iec958.status[i]);
250	return 0;
251}
252
253static int snd_ak4114_spdif_mask_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
254{
255	uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
256	uinfo->count = 1;
257	return 0;
258}
259
260static int snd_ak4114_spdif_mask_get(struct snd_kcontrol *kcontrol,
261				      struct snd_ctl_elem_value *ucontrol)
262{
263	memset(ucontrol->value.iec958.status, 0xff, AK4114_REG_RXCSB_SIZE);
264	return 0;
265}
266
267static int snd_ak4114_spdif_pinfo(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
268{
269	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
270	uinfo->value.integer.min = 0;
271	uinfo->value.integer.max = 0xffff;
272	uinfo->count = 4;
273	return 0;
274}
275
276static int snd_ak4114_spdif_pget(struct snd_kcontrol *kcontrol,
277				 struct snd_ctl_elem_value *ucontrol)
278{
279	struct ak4114 *chip = snd_kcontrol_chip(kcontrol);
280	unsigned short tmp;
281
282	ucontrol->value.integer.value[0] = 0xf8f2;
283	ucontrol->value.integer.value[1] = 0x4e1f;
284	tmp = reg_read(chip, AK4114_REG_Pc0) | (reg_read(chip, AK4114_REG_Pc1) << 8);
285	ucontrol->value.integer.value[2] = tmp;
286	tmp = reg_read(chip, AK4114_REG_Pd0) | (reg_read(chip, AK4114_REG_Pd1) << 8);
287	ucontrol->value.integer.value[3] = tmp;
288	return 0;
289}
290
291static int snd_ak4114_spdif_qinfo(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
292{
293	uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;
294	uinfo->count = AK4114_REG_QSUB_SIZE;
295	return 0;
296}
297
298static int snd_ak4114_spdif_qget(struct snd_kcontrol *kcontrol,
299				 struct snd_ctl_elem_value *ucontrol)
300{
301	struct ak4114 *chip = snd_kcontrol_chip(kcontrol);
302	unsigned i;
303
304	for (i = 0; i < AK4114_REG_QSUB_SIZE; i++)
305		ucontrol->value.bytes.data[i] = reg_read(chip, AK4114_REG_QSUB_ADDR + i);
306	return 0;
307}
308
309/* Don't forget to change AK4114_CONTROLS define!!! */
310static const struct snd_kcontrol_new snd_ak4114_iec958_controls[] = {
311{
312	.iface =	SNDRV_CTL_ELEM_IFACE_PCM,
313	.name =		"IEC958 Parity Errors",
314	.access =	SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
315	.info =		snd_ak4114_in_error_info,
316	.get =		snd_ak4114_in_error_get,
317	.private_value = AK4114_PARITY_ERRORS,
318},
319{
320	.iface =	SNDRV_CTL_ELEM_IFACE_PCM,
321	.name =		"IEC958 V-Bit Errors",
322	.access =	SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
323	.info =		snd_ak4114_in_error_info,
324	.get =		snd_ak4114_in_error_get,
325	.private_value = AK4114_V_BIT_ERRORS,
326},
327{
328	.iface =	SNDRV_CTL_ELEM_IFACE_PCM,
329	.name =		"IEC958 C-CRC Errors",
330	.access =	SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
331	.info =		snd_ak4114_in_error_info,
332	.get =		snd_ak4114_in_error_get,
333	.private_value = AK4114_CCRC_ERRORS,
334},
335{
336	.iface =	SNDRV_CTL_ELEM_IFACE_PCM,
337	.name =		"IEC958 Q-CRC Errors",
338	.access =	SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
339	.info =		snd_ak4114_in_error_info,
340	.get =		snd_ak4114_in_error_get,
341	.private_value = AK4114_QCRC_ERRORS,
342},
343{
344	.iface =	SNDRV_CTL_ELEM_IFACE_PCM,
345	.name =		"IEC958 External Rate",
346	.access =	SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
347	.info =		snd_ak4114_rate_info,
348	.get =		snd_ak4114_rate_get,
349},
350{
351	.iface =	SNDRV_CTL_ELEM_IFACE_PCM,
352	.name =		SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),
353	.access =	SNDRV_CTL_ELEM_ACCESS_READ,
354	.info =		snd_ak4114_spdif_mask_info,
355	.get =		snd_ak4114_spdif_mask_get,
356},
357{
358	.iface =	SNDRV_CTL_ELEM_IFACE_PCM,
359	.name =		SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
360	.access =	SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
361	.info =		snd_ak4114_spdif_info,
362	.get =		snd_ak4114_spdif_playback_get,
363	.put =		snd_ak4114_spdif_playback_put,
364},
365{
366	.iface =	SNDRV_CTL_ELEM_IFACE_PCM,
367	.name =		SNDRV_CTL_NAME_IEC958("",CAPTURE,MASK),
368	.access =	SNDRV_CTL_ELEM_ACCESS_READ,
369	.info =		snd_ak4114_spdif_mask_info,
370	.get =		snd_ak4114_spdif_mask_get,
371},
372{
373	.iface =	SNDRV_CTL_ELEM_IFACE_PCM,
374	.name =		SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT),
375	.access =	SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
376	.info =		snd_ak4114_spdif_info,
377	.get =		snd_ak4114_spdif_get,
378},
379{
380	.iface =	SNDRV_CTL_ELEM_IFACE_PCM,
381	.name =		"IEC958 Preamble Capture Default",
382	.access =	SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
383	.info =		snd_ak4114_spdif_pinfo,
384	.get =		snd_ak4114_spdif_pget,
385},
386{
387	.iface =	SNDRV_CTL_ELEM_IFACE_PCM,
388	.name =		"IEC958 Q-subcode Capture Default",
389	.access =	SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
390	.info =		snd_ak4114_spdif_qinfo,
391	.get =		snd_ak4114_spdif_qget,
392},
393{
394	.iface =	SNDRV_CTL_ELEM_IFACE_PCM,
395	.name =		"IEC958 Audio",
396	.access =	SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
397	.info =		snd_ak4114_in_bit_info,
398	.get =		snd_ak4114_in_bit_get,
399	.private_value = (1<<31) | (1<<8) | AK4114_REG_RCS0,
400},
401{
402	.iface =	SNDRV_CTL_ELEM_IFACE_PCM,
403	.name =		"IEC958 Non-PCM Bitstream",
404	.access =	SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
405	.info =		snd_ak4114_in_bit_info,
406	.get =		snd_ak4114_in_bit_get,
407	.private_value = (6<<8) | AK4114_REG_RCS0,
408},
409{
410	.iface =	SNDRV_CTL_ELEM_IFACE_PCM,
411	.name =		"IEC958 DTS Bitstream",
412	.access =	SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
413	.info =		snd_ak4114_in_bit_info,
414	.get =		snd_ak4114_in_bit_get,
415	.private_value = (3<<8) | AK4114_REG_RCS0,
416},
417{
418	.iface =	SNDRV_CTL_ELEM_IFACE_PCM,
419	.name =		"IEC958 PPL Lock Status",
420	.access =	SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE,
421	.info =		snd_ak4114_in_bit_info,
422	.get =		snd_ak4114_in_bit_get,
423	.private_value = (1<<31) | (4<<8) | AK4114_REG_RCS0,
424}
425};
426
427
428static void snd_ak4114_proc_regs_read(struct snd_info_entry *entry,
429		struct snd_info_buffer *buffer)
430{
431	struct ak4114 *ak4114 = entry->private_data;
432	int reg, val;
433	/* all ak4114 registers 0x00 - 0x1f */
434	for (reg = 0; reg < 0x20; reg++) {
435		val = reg_read(ak4114, reg);
436		snd_iprintf(buffer, "0x%02x = 0x%02x\n", reg, val);
437	}
438}
439
440static void snd_ak4114_proc_init(struct ak4114 *ak4114)
441{
442	snd_card_ro_proc_new(ak4114->card, "ak4114", ak4114,
443			     snd_ak4114_proc_regs_read);
444}
445
446int snd_ak4114_build(struct ak4114 *ak4114,
447		     struct snd_pcm_substream *ply_substream,
448		     struct snd_pcm_substream *cap_substream)
449{
450	struct snd_kcontrol *kctl;
451	unsigned int idx;
452	int err;
453
454	if (snd_BUG_ON(!cap_substream))
455		return -EINVAL;
456	ak4114->playback_substream = ply_substream;
457	ak4114->capture_substream = cap_substream;
458	for (idx = 0; idx < AK4114_CONTROLS; idx++) {
459		kctl = snd_ctl_new1(&snd_ak4114_iec958_controls[idx], ak4114);
460		if (kctl == NULL)
461			return -ENOMEM;
462		if (strstr(kctl->id.name, "Playback")) {
463			if (ply_substream == NULL) {
464				snd_ctl_free_one(kctl);
465				ak4114->kctls[idx] = NULL;
466				continue;
467			}
468			kctl->id.device = ply_substream->pcm->device;
469			kctl->id.subdevice = ply_substream->number;
470		} else {
471			kctl->id.device = cap_substream->pcm->device;
472			kctl->id.subdevice = cap_substream->number;
473		}
474		err = snd_ctl_add(ak4114->card, kctl);
475		if (err < 0)
476			return err;
477		ak4114->kctls[idx] = kctl;
478	}
479	snd_ak4114_proc_init(ak4114);
480	/* trigger workq */
481	schedule_delayed_work(&ak4114->work, HZ / 10);
482	return 0;
483}
484EXPORT_SYMBOL(snd_ak4114_build);
485
486/* notify kcontrols if any parameters are changed */
487static void ak4114_notify(struct ak4114 *ak4114,
488			  unsigned char rcs0, unsigned char rcs1,
489			  unsigned char c0, unsigned char c1)
490{
491	if (!ak4114->kctls[0])
492		return;
493
494	if (rcs0 & AK4114_PAR)
495		snd_ctl_notify(ak4114->card, SNDRV_CTL_EVENT_MASK_VALUE,
496			       &ak4114->kctls[0]->id);
497	if (rcs0 & AK4114_V)
498		snd_ctl_notify(ak4114->card, SNDRV_CTL_EVENT_MASK_VALUE,
499			       &ak4114->kctls[1]->id);
500	if (rcs1 & AK4114_CCRC)
501		snd_ctl_notify(ak4114->card, SNDRV_CTL_EVENT_MASK_VALUE,
502			       &ak4114->kctls[2]->id);
503	if (rcs1 & AK4114_QCRC)
504		snd_ctl_notify(ak4114->card, SNDRV_CTL_EVENT_MASK_VALUE,
505			       &ak4114->kctls[3]->id);
506
507	/* rate change */
508	if (c1 & 0xf0)
509		snd_ctl_notify(ak4114->card, SNDRV_CTL_EVENT_MASK_VALUE,
510			       &ak4114->kctls[4]->id);
511
512	if ((c0 & AK4114_PEM) | (c0 & AK4114_CINT))
513		snd_ctl_notify(ak4114->card, SNDRV_CTL_EVENT_MASK_VALUE,
514			       &ak4114->kctls[9]->id);
515	if (c0 & AK4114_QINT)
516		snd_ctl_notify(ak4114->card, SNDRV_CTL_EVENT_MASK_VALUE,
517			       &ak4114->kctls[10]->id);
518
519	if (c0 & AK4114_AUDION)
520		snd_ctl_notify(ak4114->card, SNDRV_CTL_EVENT_MASK_VALUE,
521			       &ak4114->kctls[11]->id);
522	if (c0 & AK4114_AUTO)
523		snd_ctl_notify(ak4114->card, SNDRV_CTL_EVENT_MASK_VALUE,
524			       &ak4114->kctls[12]->id);
525	if (c0 & AK4114_DTSCD)
526		snd_ctl_notify(ak4114->card, SNDRV_CTL_EVENT_MASK_VALUE,
527			       &ak4114->kctls[13]->id);
528	if (c0 & AK4114_UNLCK)
529		snd_ctl_notify(ak4114->card, SNDRV_CTL_EVENT_MASK_VALUE,
530			       &ak4114->kctls[14]->id);
531}
532
533int snd_ak4114_external_rate(struct ak4114 *ak4114)
534{
535	unsigned char rcs1;
536
537	rcs1 = reg_read(ak4114, AK4114_REG_RCS1);
538	return external_rate(rcs1);
539}
540EXPORT_SYMBOL(snd_ak4114_external_rate);
541
542int snd_ak4114_check_rate_and_errors(struct ak4114 *ak4114, unsigned int flags)
543{
544	struct snd_pcm_runtime *runtime = ak4114->capture_substream ? ak4114->capture_substream->runtime : NULL;
545	unsigned long _flags;
546	int res = 0;
547	unsigned char rcs0, rcs1;
548	unsigned char c0, c1;
549
550	rcs1 = reg_read(ak4114, AK4114_REG_RCS1);
551	if (flags & AK4114_CHECK_NO_STAT)
552		goto __rate;
553	rcs0 = reg_read(ak4114, AK4114_REG_RCS0);
554	scoped_guard(spinlock_irqsave, &ak4114->lock) {
555		if (rcs0 & AK4114_PAR)
556			ak4114->errors[AK4114_PARITY_ERRORS]++;
557		if (rcs1 & AK4114_V)
558			ak4114->errors[AK4114_V_BIT_ERRORS]++;
559		if (rcs1 & AK4114_CCRC)
560			ak4114->errors[AK4114_CCRC_ERRORS]++;
561		if (rcs1 & AK4114_QCRC)
562			ak4114->errors[AK4114_QCRC_ERRORS]++;
563		c0 = (ak4114->rcs0 & (AK4114_QINT | AK4114_CINT | AK4114_PEM | AK4114_AUDION | AK4114_AUTO | AK4114_UNLCK)) ^
564			(rcs0 & (AK4114_QINT | AK4114_CINT | AK4114_PEM | AK4114_AUDION | AK4114_AUTO | AK4114_UNLCK));
565		c1 = (ak4114->rcs1 & 0xf0) ^ (rcs1 & 0xf0);
566		ak4114->rcs0 = rcs0 & ~(AK4114_QINT | AK4114_CINT);
567		ak4114->rcs1 = rcs1;
568	}
569
570	ak4114_notify(ak4114, rcs0, rcs1, c0, c1);
571	if (ak4114->change_callback && (c0 | c1) != 0)
572		ak4114->change_callback(ak4114, c0, c1);
573
574      __rate:
575	/* compare rate */
576	res = external_rate(rcs1);
577	if (!(flags & AK4114_CHECK_NO_RATE) && runtime && runtime->rate != res) {
578		snd_pcm_stream_lock_irqsave(ak4114->capture_substream, _flags);
579		if (snd_pcm_running(ak4114->capture_substream)) {
580			snd_pcm_stop(ak4114->capture_substream, SNDRV_PCM_STATE_DRAINING);
581			res = 1;
582		}
583		snd_pcm_stream_unlock_irqrestore(ak4114->capture_substream, _flags);
584	}
585	return res;
586}
587EXPORT_SYMBOL(snd_ak4114_check_rate_and_errors);
588
589static void ak4114_stats(struct work_struct *work)
590{
591	struct ak4114 *chip = container_of(work, struct ak4114, work.work);
592
593	if (atomic_inc_return(&chip->wq_processing) == 1)
594		snd_ak4114_check_rate_and_errors(chip, chip->check_flags);
595	if (atomic_dec_and_test(&chip->wq_processing))
596		schedule_delayed_work(&chip->work, HZ / 10);
597}
598
599#ifdef CONFIG_PM
600void snd_ak4114_suspend(struct ak4114 *chip)
601{
602	atomic_inc(&chip->wq_processing); /* don't schedule new work */
603	cancel_delayed_work_sync(&chip->work);
604}
605EXPORT_SYMBOL(snd_ak4114_suspend);
606
607void snd_ak4114_resume(struct ak4114 *chip)
608{
609	atomic_dec(&chip->wq_processing);
610	snd_ak4114_reinit(chip);
611}
612EXPORT_SYMBOL(snd_ak4114_resume);
613#endif