2 * Routines for control of the AK4114 via I2C and 4-wire serial interface
3 * IEC958 (S/PDIF) receiver by Asahi Kasei
4 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include <linux/slab.h>
24 #include <linux/delay.h>
25 #include <linux/module.h>
26 #include <sound/core.h>
27 #include <sound/control.h>
28 #include <sound/pcm.h>
29 #include <sound/ak4114.h>
30 #include <sound/asoundef.h>
31 #include <sound/info.h>
33 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
34 MODULE_DESCRIPTION("AK4114 IEC958 (S/PDIF) receiver by Asahi Kasei");
35 MODULE_LICENSE("GPL");
37 #define AK4114_ADDR 0x00 /* fixed address */
39 static void ak4114_stats(struct work_struct
*work
);
40 static void ak4114_init_regs(struct ak4114
*chip
);
42 static void reg_write(struct ak4114
*ak4114
, unsigned char reg
, unsigned char val
)
44 ak4114
->write(ak4114
->private_data
, reg
, val
);
45 if (reg
<= AK4114_REG_INT1_MASK
)
46 ak4114
->regmap
[reg
] = val
;
47 else if (reg
>= AK4114_REG_TXCSB0
&& reg
<= AK4114_REG_TXCSB4
)
48 ak4114
->txcsb
[reg
-AK4114_REG_TXCSB0
] = val
;
51 static inline unsigned char reg_read(struct ak4114
*ak4114
, unsigned char reg
)
53 return ak4114
->read(ak4114
->private_data
, reg
);
57 static void reg_dump(struct ak4114
*ak4114
)
61 printk(KERN_DEBUG
"AK4114 REG DUMP:\n");
62 for (i
= 0; i
< 0x20; i
++)
63 printk(KERN_DEBUG
"reg[%02x] = %02x (%02x)\n", i
, reg_read(ak4114
, i
), i
< ARRAY_SIZE(ak4114
->regmap
) ? ak4114
->regmap
[i
] : 0);
67 static void snd_ak4114_free(struct ak4114
*chip
)
69 atomic_inc(&chip
->wq_processing
); /* don't schedule new work */
70 cancel_delayed_work_sync(&chip
->work
);
74 static int snd_ak4114_dev_free(struct snd_device
*device
)
76 struct ak4114
*chip
= device
->device_data
;
77 snd_ak4114_free(chip
);
81 int snd_ak4114_create(struct snd_card
*card
,
82 ak4114_read_t
*read
, ak4114_write_t
*write
,
83 const unsigned char pgm
[6], const unsigned char txcsb
[5],
84 void *private_data
, struct ak4114
**r_ak4114
)
89 static struct snd_device_ops ops
= {
90 .dev_free
= snd_ak4114_dev_free
,
93 chip
= kzalloc(sizeof(*chip
), GFP_KERNEL
);
96 spin_lock_init(&chip
->lock
);
100 chip
->private_data
= private_data
;
101 INIT_DELAYED_WORK(&chip
->work
, ak4114_stats
);
102 atomic_set(&chip
->wq_processing
, 0);
103 mutex_init(&chip
->reinit_mutex
);
105 for (reg
= 0; reg
< 6; reg
++)
106 chip
->regmap
[reg
] = pgm
[reg
];
107 for (reg
= 0; reg
< 5; reg
++)
108 chip
->txcsb
[reg
] = txcsb
[reg
];
110 ak4114_init_regs(chip
);
112 chip
->rcs0
= reg_read(chip
, AK4114_REG_RCS0
) & ~(AK4114_QINT
| AK4114_CINT
);
113 chip
->rcs1
= reg_read(chip
, AK4114_REG_RCS1
);
115 if ((err
= snd_device_new(card
, SNDRV_DEV_CODEC
, chip
, &ops
)) < 0)
123 snd_ak4114_free(chip
);
126 EXPORT_SYMBOL(snd_ak4114_create
);
128 void snd_ak4114_reg_write(struct ak4114
*chip
, unsigned char reg
, unsigned char mask
, unsigned char val
)
130 if (reg
<= AK4114_REG_INT1_MASK
)
131 reg_write(chip
, reg
, (chip
->regmap
[reg
] & ~mask
) | val
);
132 else if (reg
>= AK4114_REG_TXCSB0
&& reg
<= AK4114_REG_TXCSB4
)
134 (chip
->txcsb
[reg
-AK4114_REG_TXCSB0
] & ~mask
) | val
);
136 EXPORT_SYMBOL(snd_ak4114_reg_write
);
138 static void ak4114_init_regs(struct ak4114
*chip
)
140 unsigned char old
= chip
->regmap
[AK4114_REG_PWRDN
], reg
;
142 /* bring the chip to reset state and powerdown state */
143 reg_write(chip
, AK4114_REG_PWRDN
, old
& ~(AK4114_RST
|AK4114_PWN
));
145 /* release reset, but leave powerdown */
146 reg_write(chip
, AK4114_REG_PWRDN
, (old
| AK4114_RST
) & ~AK4114_PWN
);
148 for (reg
= 1; reg
< 6; reg
++)
149 reg_write(chip
, reg
, chip
->regmap
[reg
]);
150 for (reg
= 0; reg
< 5; reg
++)
151 reg_write(chip
, reg
+ AK4114_REG_TXCSB0
, chip
->txcsb
[reg
]);
152 /* release powerdown, everything is initialized now */
153 reg_write(chip
, AK4114_REG_PWRDN
, old
| AK4114_RST
| AK4114_PWN
);
156 void snd_ak4114_reinit(struct ak4114
*chip
)
158 if (atomic_inc_return(&chip
->wq_processing
) == 1)
159 cancel_delayed_work_sync(&chip
->work
);
160 mutex_lock(&chip
->reinit_mutex
);
161 ak4114_init_regs(chip
);
162 mutex_unlock(&chip
->reinit_mutex
);
163 /* bring up statistics / event queing */
164 if (atomic_dec_and_test(&chip
->wq_processing
))
165 schedule_delayed_work(&chip
->work
, HZ
/ 10);
167 EXPORT_SYMBOL(snd_ak4114_reinit
);
169 static unsigned int external_rate(unsigned char rcs1
)
171 switch (rcs1
& (AK4114_FS0
|AK4114_FS1
|AK4114_FS2
|AK4114_FS3
)) {
172 case AK4114_FS_32000HZ
: return 32000;
173 case AK4114_FS_44100HZ
: return 44100;
174 case AK4114_FS_48000HZ
: return 48000;
175 case AK4114_FS_88200HZ
: return 88200;
176 case AK4114_FS_96000HZ
: return 96000;
177 case AK4114_FS_176400HZ
: return 176400;
178 case AK4114_FS_192000HZ
: return 192000;
183 static int snd_ak4114_in_error_info(struct snd_kcontrol
*kcontrol
,
184 struct snd_ctl_elem_info
*uinfo
)
186 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
188 uinfo
->value
.integer
.min
= 0;
189 uinfo
->value
.integer
.max
= LONG_MAX
;
193 static int snd_ak4114_in_error_get(struct snd_kcontrol
*kcontrol
,
194 struct snd_ctl_elem_value
*ucontrol
)
196 struct ak4114
*chip
= snd_kcontrol_chip(kcontrol
);
198 spin_lock_irq(&chip
->lock
);
199 ucontrol
->value
.integer
.value
[0] =
200 chip
->errors
[kcontrol
->private_value
];
201 chip
->errors
[kcontrol
->private_value
] = 0;
202 spin_unlock_irq(&chip
->lock
);
206 #define snd_ak4114_in_bit_info snd_ctl_boolean_mono_info
208 static int snd_ak4114_in_bit_get(struct snd_kcontrol
*kcontrol
,
209 struct snd_ctl_elem_value
*ucontrol
)
211 struct ak4114
*chip
= snd_kcontrol_chip(kcontrol
);
212 unsigned char reg
= kcontrol
->private_value
& 0xff;
213 unsigned char bit
= (kcontrol
->private_value
>> 8) & 0xff;
214 unsigned char inv
= (kcontrol
->private_value
>> 31) & 1;
216 ucontrol
->value
.integer
.value
[0] = ((reg_read(chip
, reg
) & (1 << bit
)) ? 1 : 0) ^ inv
;
220 static int snd_ak4114_rate_info(struct snd_kcontrol
*kcontrol
,
221 struct snd_ctl_elem_info
*uinfo
)
223 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
225 uinfo
->value
.integer
.min
= 0;
226 uinfo
->value
.integer
.max
= 192000;
230 static int snd_ak4114_rate_get(struct snd_kcontrol
*kcontrol
,
231 struct snd_ctl_elem_value
*ucontrol
)
233 struct ak4114
*chip
= snd_kcontrol_chip(kcontrol
);
235 ucontrol
->value
.integer
.value
[0] = external_rate(reg_read(chip
, AK4114_REG_RCS1
));
239 static int snd_ak4114_spdif_info(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
241 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_IEC958
;
246 static int snd_ak4114_spdif_get(struct snd_kcontrol
*kcontrol
,
247 struct snd_ctl_elem_value
*ucontrol
)
249 struct ak4114
*chip
= snd_kcontrol_chip(kcontrol
);
252 for (i
= 0; i
< AK4114_REG_RXCSB_SIZE
; i
++)
253 ucontrol
->value
.iec958
.status
[i
] = reg_read(chip
, AK4114_REG_RXCSB0
+ i
);
257 static int snd_ak4114_spdif_playback_get(struct snd_kcontrol
*kcontrol
,
258 struct snd_ctl_elem_value
*ucontrol
)
260 struct ak4114
*chip
= snd_kcontrol_chip(kcontrol
);
263 for (i
= 0; i
< AK4114_REG_TXCSB_SIZE
; i
++)
264 ucontrol
->value
.iec958
.status
[i
] = chip
->txcsb
[i
];
268 static int snd_ak4114_spdif_playback_put(struct snd_kcontrol
*kcontrol
,
269 struct snd_ctl_elem_value
*ucontrol
)
271 struct ak4114
*chip
= snd_kcontrol_chip(kcontrol
);
274 for (i
= 0; i
< AK4114_REG_TXCSB_SIZE
; i
++)
275 reg_write(chip
, AK4114_REG_TXCSB0
+ i
, ucontrol
->value
.iec958
.status
[i
]);
279 static int snd_ak4114_spdif_mask_info(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
281 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_IEC958
;
286 static int snd_ak4114_spdif_mask_get(struct snd_kcontrol
*kcontrol
,
287 struct snd_ctl_elem_value
*ucontrol
)
289 memset(ucontrol
->value
.iec958
.status
, 0xff, AK4114_REG_RXCSB_SIZE
);
293 static int snd_ak4114_spdif_pinfo(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
295 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
296 uinfo
->value
.integer
.min
= 0;
297 uinfo
->value
.integer
.max
= 0xffff;
302 static int snd_ak4114_spdif_pget(struct snd_kcontrol
*kcontrol
,
303 struct snd_ctl_elem_value
*ucontrol
)
305 struct ak4114
*chip
= snd_kcontrol_chip(kcontrol
);
308 ucontrol
->value
.integer
.value
[0] = 0xf8f2;
309 ucontrol
->value
.integer
.value
[1] = 0x4e1f;
310 tmp
= reg_read(chip
, AK4114_REG_Pc0
) | (reg_read(chip
, AK4114_REG_Pc1
) << 8);
311 ucontrol
->value
.integer
.value
[2] = tmp
;
312 tmp
= reg_read(chip
, AK4114_REG_Pd0
) | (reg_read(chip
, AK4114_REG_Pd1
) << 8);
313 ucontrol
->value
.integer
.value
[3] = tmp
;
317 static int snd_ak4114_spdif_qinfo(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
319 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BYTES
;
320 uinfo
->count
= AK4114_REG_QSUB_SIZE
;
324 static int snd_ak4114_spdif_qget(struct snd_kcontrol
*kcontrol
,
325 struct snd_ctl_elem_value
*ucontrol
)
327 struct ak4114
*chip
= snd_kcontrol_chip(kcontrol
);
330 for (i
= 0; i
< AK4114_REG_QSUB_SIZE
; i
++)
331 ucontrol
->value
.bytes
.data
[i
] = reg_read(chip
, AK4114_REG_QSUB_ADDR
+ i
);
335 /* Don't forget to change AK4114_CONTROLS define!!! */
336 static struct snd_kcontrol_new snd_ak4114_iec958_controls
[] = {
338 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
339 .name
= "IEC958 Parity Errors",
340 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
341 .info
= snd_ak4114_in_error_info
,
342 .get
= snd_ak4114_in_error_get
,
343 .private_value
= AK4114_PARITY_ERRORS
,
346 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
347 .name
= "IEC958 V-Bit Errors",
348 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
349 .info
= snd_ak4114_in_error_info
,
350 .get
= snd_ak4114_in_error_get
,
351 .private_value
= AK4114_V_BIT_ERRORS
,
354 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
355 .name
= "IEC958 C-CRC Errors",
356 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
357 .info
= snd_ak4114_in_error_info
,
358 .get
= snd_ak4114_in_error_get
,
359 .private_value
= AK4114_CCRC_ERRORS
,
362 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
363 .name
= "IEC958 Q-CRC Errors",
364 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
365 .info
= snd_ak4114_in_error_info
,
366 .get
= snd_ak4114_in_error_get
,
367 .private_value
= AK4114_QCRC_ERRORS
,
370 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
371 .name
= "IEC958 External Rate",
372 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
373 .info
= snd_ak4114_rate_info
,
374 .get
= snd_ak4114_rate_get
,
377 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
378 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,MASK
),
379 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
380 .info
= snd_ak4114_spdif_mask_info
,
381 .get
= snd_ak4114_spdif_mask_get
,
384 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
385 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,DEFAULT
),
386 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
387 .info
= snd_ak4114_spdif_info
,
388 .get
= snd_ak4114_spdif_playback_get
,
389 .put
= snd_ak4114_spdif_playback_put
,
392 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
393 .name
= SNDRV_CTL_NAME_IEC958("",CAPTURE
,MASK
),
394 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
395 .info
= snd_ak4114_spdif_mask_info
,
396 .get
= snd_ak4114_spdif_mask_get
,
399 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
400 .name
= SNDRV_CTL_NAME_IEC958("",CAPTURE
,DEFAULT
),
401 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
402 .info
= snd_ak4114_spdif_info
,
403 .get
= snd_ak4114_spdif_get
,
406 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
407 .name
= "IEC958 Preamble Capture Default",
408 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
409 .info
= snd_ak4114_spdif_pinfo
,
410 .get
= snd_ak4114_spdif_pget
,
413 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
414 .name
= "IEC958 Q-subcode Capture Default",
415 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
416 .info
= snd_ak4114_spdif_qinfo
,
417 .get
= snd_ak4114_spdif_qget
,
420 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
421 .name
= "IEC958 Audio",
422 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
423 .info
= snd_ak4114_in_bit_info
,
424 .get
= snd_ak4114_in_bit_get
,
425 .private_value
= (1<<31) | (1<<8) | AK4114_REG_RCS0
,
428 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
429 .name
= "IEC958 Non-PCM Bitstream",
430 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
431 .info
= snd_ak4114_in_bit_info
,
432 .get
= snd_ak4114_in_bit_get
,
433 .private_value
= (6<<8) | AK4114_REG_RCS0
,
436 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
437 .name
= "IEC958 DTS Bitstream",
438 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
439 .info
= snd_ak4114_in_bit_info
,
440 .get
= snd_ak4114_in_bit_get
,
441 .private_value
= (3<<8) | AK4114_REG_RCS0
,
444 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
445 .name
= "IEC958 PPL Lock Status",
446 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
447 .info
= snd_ak4114_in_bit_info
,
448 .get
= snd_ak4114_in_bit_get
,
449 .private_value
= (1<<31) | (4<<8) | AK4114_REG_RCS0
,
454 static void snd_ak4114_proc_regs_read(struct snd_info_entry
*entry
,
455 struct snd_info_buffer
*buffer
)
457 struct ak4114
*ak4114
= entry
->private_data
;
459 /* all ak4114 registers 0x00 - 0x1f */
460 for (reg
= 0; reg
< 0x20; reg
++) {
461 val
= reg_read(ak4114
, reg
);
462 snd_iprintf(buffer
, "0x%02x = 0x%02x\n", reg
, val
);
466 static void snd_ak4114_proc_init(struct ak4114
*ak4114
)
468 struct snd_info_entry
*entry
;
469 if (!snd_card_proc_new(ak4114
->card
, "ak4114", &entry
))
470 snd_info_set_text_ops(entry
, ak4114
, snd_ak4114_proc_regs_read
);
473 int snd_ak4114_build(struct ak4114
*ak4114
,
474 struct snd_pcm_substream
*ply_substream
,
475 struct snd_pcm_substream
*cap_substream
)
477 struct snd_kcontrol
*kctl
;
481 if (snd_BUG_ON(!cap_substream
))
483 ak4114
->playback_substream
= ply_substream
;
484 ak4114
->capture_substream
= cap_substream
;
485 for (idx
= 0; idx
< AK4114_CONTROLS
; idx
++) {
486 kctl
= snd_ctl_new1(&snd_ak4114_iec958_controls
[idx
], ak4114
);
489 if (strstr(kctl
->id
.name
, "Playback")) {
490 if (ply_substream
== NULL
) {
491 snd_ctl_free_one(kctl
);
492 ak4114
->kctls
[idx
] = NULL
;
495 kctl
->id
.device
= ply_substream
->pcm
->device
;
496 kctl
->id
.subdevice
= ply_substream
->number
;
498 kctl
->id
.device
= cap_substream
->pcm
->device
;
499 kctl
->id
.subdevice
= cap_substream
->number
;
501 err
= snd_ctl_add(ak4114
->card
, kctl
);
504 ak4114
->kctls
[idx
] = kctl
;
506 snd_ak4114_proc_init(ak4114
);
508 schedule_delayed_work(&ak4114
->work
, HZ
/ 10);
511 EXPORT_SYMBOL(snd_ak4114_build
);
513 /* notify kcontrols if any parameters are changed */
514 static void ak4114_notify(struct ak4114
*ak4114
,
515 unsigned char rcs0
, unsigned char rcs1
,
516 unsigned char c0
, unsigned char c1
)
518 if (!ak4114
->kctls
[0])
521 if (rcs0
& AK4114_PAR
)
522 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
,
523 &ak4114
->kctls
[0]->id
);
525 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
,
526 &ak4114
->kctls
[1]->id
);
527 if (rcs1
& AK4114_CCRC
)
528 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
,
529 &ak4114
->kctls
[2]->id
);
530 if (rcs1
& AK4114_QCRC
)
531 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
,
532 &ak4114
->kctls
[3]->id
);
536 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
,
537 &ak4114
->kctls
[4]->id
);
539 if ((c0
& AK4114_PEM
) | (c0
& AK4114_CINT
))
540 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
,
541 &ak4114
->kctls
[9]->id
);
542 if (c0
& AK4114_QINT
)
543 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
,
544 &ak4114
->kctls
[10]->id
);
546 if (c0
& AK4114_AUDION
)
547 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
,
548 &ak4114
->kctls
[11]->id
);
549 if (c0
& AK4114_AUTO
)
550 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
,
551 &ak4114
->kctls
[12]->id
);
552 if (c0
& AK4114_DTSCD
)
553 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
,
554 &ak4114
->kctls
[13]->id
);
555 if (c0
& AK4114_UNLCK
)
556 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
,
557 &ak4114
->kctls
[14]->id
);
560 int snd_ak4114_external_rate(struct ak4114
*ak4114
)
564 rcs1
= reg_read(ak4114
, AK4114_REG_RCS1
);
565 return external_rate(rcs1
);
567 EXPORT_SYMBOL(snd_ak4114_external_rate
);
569 int snd_ak4114_check_rate_and_errors(struct ak4114
*ak4114
, unsigned int flags
)
571 struct snd_pcm_runtime
*runtime
= ak4114
->capture_substream
? ak4114
->capture_substream
->runtime
: NULL
;
572 unsigned long _flags
;
574 unsigned char rcs0
, rcs1
;
575 unsigned char c0
, c1
;
577 rcs1
= reg_read(ak4114
, AK4114_REG_RCS1
);
578 if (flags
& AK4114_CHECK_NO_STAT
)
580 rcs0
= reg_read(ak4114
, AK4114_REG_RCS0
);
581 spin_lock_irqsave(&ak4114
->lock
, _flags
);
582 if (rcs0
& AK4114_PAR
)
583 ak4114
->errors
[AK4114_PARITY_ERRORS
]++;
585 ak4114
->errors
[AK4114_V_BIT_ERRORS
]++;
586 if (rcs1
& AK4114_CCRC
)
587 ak4114
->errors
[AK4114_CCRC_ERRORS
]++;
588 if (rcs1
& AK4114_QCRC
)
589 ak4114
->errors
[AK4114_QCRC_ERRORS
]++;
590 c0
= (ak4114
->rcs0
& (AK4114_QINT
| AK4114_CINT
| AK4114_PEM
| AK4114_AUDION
| AK4114_AUTO
| AK4114_UNLCK
)) ^
591 (rcs0
& (AK4114_QINT
| AK4114_CINT
| AK4114_PEM
| AK4114_AUDION
| AK4114_AUTO
| AK4114_UNLCK
));
592 c1
= (ak4114
->rcs1
& 0xf0) ^ (rcs1
& 0xf0);
593 ak4114
->rcs0
= rcs0
& ~(AK4114_QINT
| AK4114_CINT
);
595 spin_unlock_irqrestore(&ak4114
->lock
, _flags
);
597 ak4114_notify(ak4114
, rcs0
, rcs1
, c0
, c1
);
598 if (ak4114
->change_callback
&& (c0
| c1
) != 0)
599 ak4114
->change_callback(ak4114
, c0
, c1
);
603 res
= external_rate(rcs1
);
604 if (!(flags
& AK4114_CHECK_NO_RATE
) && runtime
&& runtime
->rate
!= res
) {
605 snd_pcm_stream_lock_irqsave(ak4114
->capture_substream
, _flags
);
606 if (snd_pcm_running(ak4114
->capture_substream
)) {
607 // printk(KERN_DEBUG "rate changed (%i <- %i)\n", runtime->rate, res);
608 snd_pcm_stop(ak4114
->capture_substream
, SNDRV_PCM_STATE_DRAINING
);
611 snd_pcm_stream_unlock_irqrestore(ak4114
->capture_substream
, _flags
);
615 EXPORT_SYMBOL(snd_ak4114_check_rate_and_errors
);
617 static void ak4114_stats(struct work_struct
*work
)
619 struct ak4114
*chip
= container_of(work
, struct ak4114
, work
.work
);
621 if (atomic_inc_return(&chip
->wq_processing
) == 1)
622 snd_ak4114_check_rate_and_errors(chip
, chip
->check_flags
);
623 if (atomic_dec_and_test(&chip
->wq_processing
))
624 schedule_delayed_work(&chip
->work
, HZ
/ 10);
628 void snd_ak4114_suspend(struct ak4114
*chip
)
630 atomic_inc(&chip
->wq_processing
); /* don't schedule new work */
631 cancel_delayed_work_sync(&chip
->work
);
633 EXPORT_SYMBOL(snd_ak4114_suspend
);
635 void snd_ak4114_resume(struct ak4114
*chip
)
637 atomic_dec(&chip
->wq_processing
);
638 snd_ak4114_reinit(chip
);
640 EXPORT_SYMBOL(snd_ak4114_resume
);