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
18 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
19 MODULE_DESCRIPTION("AK4114 IEC958 (S/PDIF) receiver by Asahi Kasei");
20 MODULE_LICENSE("GPL");
21
22 #define AK4114_ADDR 0x00 /* fixed address */
23
24 static void ak4114_stats(struct work_struct *work);
25 static void ak4114_init_regs(struct ak4114 *chip);
26
reg_write(struct ak4114 * ak4114,unsigned char reg,unsigned char val)27 static 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
reg_read(struct ak4114 * ak4114,unsigned char reg)36 static inline unsigned char reg_read(struct ak4114 *ak4114, unsigned char reg)
37 {
38 return ak4114->read(ak4114->private_data, reg);
39 }
40
snd_ak4114_free(struct ak4114 * chip)41 static 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
snd_ak4114_dev_free(struct snd_device * device)48 static 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
snd_ak4114_create(struct snd_card * card,ak4114_read_t * read,ak4114_write_t * write,const unsigned char pgm[6],const unsigned char txcsb[5],void * private_data,struct ak4114 ** r_ak4114)55 int 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_obj(*chip);
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 }
101 EXPORT_SYMBOL(snd_ak4114_create);
102
snd_ak4114_reg_write(struct ak4114 * chip,unsigned char reg,unsigned char mask,unsigned char val)103 void 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 }
111 EXPORT_SYMBOL(snd_ak4114_reg_write);
112
ak4114_init_regs(struct ak4114 * chip)113 static 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
snd_ak4114_reinit(struct ak4114 * chip)131 void 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 }
142 EXPORT_SYMBOL(snd_ak4114_reinit);
143
external_rate(unsigned char rcs1)144 static 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
snd_ak4114_in_error_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)158 static 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
snd_ak4114_in_error_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)168 static 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
snd_ak4114_in_bit_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)182 static 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
snd_ak4114_rate_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)194 static 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
snd_ak4114_rate_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)204 static 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
snd_ak4114_spdif_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)213 static 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
snd_ak4114_spdif_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)220 static 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
snd_ak4114_spdif_playback_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)231 static 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
snd_ak4114_spdif_playback_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)242 static 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
snd_ak4114_spdif_mask_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)253 static 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
snd_ak4114_spdif_mask_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)260 static 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
snd_ak4114_spdif_pinfo(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)267 static 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
snd_ak4114_spdif_pget(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)276 static 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
snd_ak4114_spdif_qinfo(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)291 static 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
snd_ak4114_spdif_qget(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)298 static 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!!! */
310 static 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
snd_ak4114_proc_regs_read(struct snd_info_entry * entry,struct snd_info_buffer * buffer)428 static 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
snd_ak4114_proc_init(struct ak4114 * ak4114)440 static 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
snd_ak4114_build(struct ak4114 * ak4114,struct snd_pcm_substream * ply_substream,struct snd_pcm_substream * cap_substream)446 int 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 }
484 EXPORT_SYMBOL(snd_ak4114_build);
485
486 /* notify kcontrols if any parameters are changed */
ak4114_notify(struct ak4114 * ak4114,unsigned char rcs0,unsigned char rcs1,unsigned char c0,unsigned char c1)487 static 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
snd_ak4114_external_rate(struct ak4114 * ak4114)533 int 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 }
540 EXPORT_SYMBOL(snd_ak4114_external_rate);
541
snd_ak4114_check_rate_and_errors(struct ak4114 * ak4114,unsigned int flags)542 int 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 }
587 EXPORT_SYMBOL(snd_ak4114_check_rate_and_errors);
588
ak4114_stats(struct work_struct * work)589 static 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
snd_ak4114_suspend(struct ak4114 * chip)600 void 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 }
605 EXPORT_SYMBOL(snd_ak4114_suspend);
606
snd_ak4114_resume(struct ak4114 * chip)607 void snd_ak4114_resume(struct ak4114 *chip)
608 {
609 atomic_dec(&chip->wq_processing);
610 snd_ak4114_reinit(chip);
611 }
612 EXPORT_SYMBOL(snd_ak4114_resume);
613 #endif
614