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@suse.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 <sound/driver.h>
24 #include <linux/slab.h>
25 #include <linux/delay.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>
32 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
33 MODULE_DESCRIPTION("AK4114 IEC958 (S/PDIF) receiver by Asahi Kasei");
34 MODULE_LICENSE("GPL");
36 #define AK4114_ADDR 0x00 /* fixed address */
38 static void ak4114_stats(struct work_struct
*work
);
40 static void reg_write(struct ak4114
*ak4114
, unsigned char reg
, unsigned char val
)
42 ak4114
->write(ak4114
->private_data
, reg
, val
);
43 if (reg
<= AK4114_REG_INT1_MASK
)
44 ak4114
->regmap
[reg
] = val
;
45 else if (reg
>= AK4114_REG_RXCSB0
&& reg
<= AK4114_REG_TXCSB4
)
46 ak4114
->txcsb
[reg
-AK4114_REG_RXCSB0
] = val
;
49 static inline unsigned char reg_read(struct ak4114
*ak4114
, unsigned char reg
)
51 return ak4114
->read(ak4114
->private_data
, reg
);
55 static void reg_dump(struct ak4114
*ak4114
)
59 printk(KERN_DEBUG
"AK4114 REG DUMP:\n");
60 for (i
= 0; i
< 0x20; i
++)
61 printk(KERN_DEBUG
"reg[%02x] = %02x (%02x)\n", i
, reg_read(ak4114
, i
), i
< sizeof(ak4114
->regmap
) ? ak4114
->regmap
[i
] : 0);
65 static void snd_ak4114_free(struct ak4114
*chip
)
67 chip
->init
= 1; /* don't schedule new work */
69 cancel_delayed_work(&chip
->work
);
70 flush_scheduled_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
[7], 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
);
103 for (reg
= 0; reg
< 7; reg
++)
104 chip
->regmap
[reg
] = pgm
[reg
];
105 for (reg
= 0; reg
< 5; reg
++)
106 chip
->txcsb
[reg
] = txcsb
[reg
];
108 snd_ak4114_reinit(chip
);
110 chip
->rcs0
= reg_read(chip
, AK4114_REG_RCS0
) & ~(AK4114_QINT
| AK4114_CINT
);
111 chip
->rcs1
= reg_read(chip
, AK4114_REG_RCS1
);
113 if ((err
= snd_device_new(card
, SNDRV_DEV_LOWLEVEL
, chip
, &ops
)) < 0)
121 snd_ak4114_free(chip
);
122 return err
< 0 ? err
: -EIO
;
125 void snd_ak4114_reg_write(struct ak4114
*chip
, unsigned char reg
, unsigned char mask
, unsigned char val
)
127 if (reg
<= AK4114_REG_INT1_MASK
)
128 reg_write(chip
, reg
, (chip
->regmap
[reg
] & ~mask
) | val
);
129 else if (reg
>= AK4114_REG_TXCSB0
&& reg
<= AK4114_REG_TXCSB4
)
130 reg_write(chip
, reg
, (chip
->txcsb
[reg
] & ~mask
) | val
);
133 void snd_ak4114_reinit(struct ak4114
*chip
)
135 unsigned char old
= chip
->regmap
[AK4114_REG_PWRDN
], reg
;
139 flush_scheduled_work();
140 /* bring the chip to reset state and powerdown state */
141 reg_write(chip
, AK4114_REG_PWRDN
, old
& ~(AK4114_RST
|AK4114_PWN
));
143 /* release reset, but leave powerdown */
144 reg_write(chip
, AK4114_REG_PWRDN
, (old
| AK4114_RST
) & ~AK4114_PWN
);
146 for (reg
= 1; reg
< 7; reg
++)
147 reg_write(chip
, reg
, chip
->regmap
[reg
]);
148 for (reg
= 0; reg
< 5; reg
++)
149 reg_write(chip
, reg
+ AK4114_REG_TXCSB0
, chip
->txcsb
[reg
]);
150 /* release powerdown, everything is initialized now */
151 reg_write(chip
, AK4114_REG_PWRDN
, old
| AK4114_RST
| AK4114_PWN
);
152 /* bring up statistics / event queing */
154 schedule_delayed_work(&chip
->work
, HZ
/ 10);
157 static unsigned int external_rate(unsigned char rcs1
)
159 switch (rcs1
& (AK4114_FS0
|AK4114_FS1
|AK4114_FS2
|AK4114_FS3
)) {
160 case AK4114_FS_32000HZ
: return 32000;
161 case AK4114_FS_44100HZ
: return 44100;
162 case AK4114_FS_48000HZ
: return 48000;
163 case AK4114_FS_88200HZ
: return 88200;
164 case AK4114_FS_96000HZ
: return 96000;
165 case AK4114_FS_176400HZ
: return 176400;
166 case AK4114_FS_192000HZ
: return 192000;
171 static int snd_ak4114_in_error_info(struct snd_kcontrol
*kcontrol
,
172 struct snd_ctl_elem_info
*uinfo
)
174 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
176 uinfo
->value
.integer
.min
= 0;
177 uinfo
->value
.integer
.max
= LONG_MAX
;
181 static int snd_ak4114_in_error_get(struct snd_kcontrol
*kcontrol
,
182 struct snd_ctl_elem_value
*ucontrol
)
184 struct ak4114
*chip
= snd_kcontrol_chip(kcontrol
);
187 spin_lock_irq(&chip
->lock
);
188 ptr
= (long *)(((char *)chip
) + kcontrol
->private_value
);
189 ucontrol
->value
.integer
.value
[0] = *ptr
;
191 spin_unlock_irq(&chip
->lock
);
195 static int snd_ak4114_in_bit_info(struct snd_kcontrol
*kcontrol
,
196 struct snd_ctl_elem_info
*uinfo
)
198 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
200 uinfo
->value
.integer
.min
= 0;
201 uinfo
->value
.integer
.max
= 1;
205 static int snd_ak4114_in_bit_get(struct snd_kcontrol
*kcontrol
,
206 struct snd_ctl_elem_value
*ucontrol
)
208 struct ak4114
*chip
= snd_kcontrol_chip(kcontrol
);
209 unsigned char reg
= kcontrol
->private_value
& 0xff;
210 unsigned char bit
= (kcontrol
->private_value
>> 8) & 0xff;
211 unsigned char inv
= (kcontrol
->private_value
>> 31) & 1;
213 ucontrol
->value
.integer
.value
[0] = ((reg_read(chip
, reg
) & (1 << bit
)) ? 1 : 0) ^ inv
;
217 static int snd_ak4114_rate_info(struct snd_kcontrol
*kcontrol
,
218 struct snd_ctl_elem_info
*uinfo
)
220 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
222 uinfo
->value
.integer
.min
= 0;
223 uinfo
->value
.integer
.max
= 192000;
227 static int snd_ak4114_rate_get(struct snd_kcontrol
*kcontrol
,
228 struct snd_ctl_elem_value
*ucontrol
)
230 struct ak4114
*chip
= snd_kcontrol_chip(kcontrol
);
232 ucontrol
->value
.integer
.value
[0] = external_rate(reg_read(chip
, AK4114_REG_RCS1
));
236 static int snd_ak4114_spdif_info(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
238 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_IEC958
;
243 static int snd_ak4114_spdif_get(struct snd_kcontrol
*kcontrol
,
244 struct snd_ctl_elem_value
*ucontrol
)
246 struct ak4114
*chip
= snd_kcontrol_chip(kcontrol
);
249 for (i
= 0; i
< AK4114_REG_RXCSB_SIZE
; i
++)
250 ucontrol
->value
.iec958
.status
[i
] = reg_read(chip
, AK4114_REG_RXCSB0
+ i
);
254 static int snd_ak4114_spdif_playback_get(struct snd_kcontrol
*kcontrol
,
255 struct snd_ctl_elem_value
*ucontrol
)
257 struct ak4114
*chip
= snd_kcontrol_chip(kcontrol
);
260 for (i
= 0; i
< AK4114_REG_TXCSB_SIZE
; i
++)
261 ucontrol
->value
.iec958
.status
[i
] = chip
->txcsb
[i
];
265 static int snd_ak4114_spdif_playback_put(struct snd_kcontrol
*kcontrol
,
266 struct snd_ctl_elem_value
*ucontrol
)
268 struct ak4114
*chip
= snd_kcontrol_chip(kcontrol
);
271 for (i
= 0; i
< AK4114_REG_TXCSB_SIZE
; i
++)
272 reg_write(chip
, AK4114_REG_TXCSB0
+ i
, ucontrol
->value
.iec958
.status
[i
]);
276 static int snd_ak4114_spdif_mask_info(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
278 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_IEC958
;
283 static int snd_ak4114_spdif_mask_get(struct snd_kcontrol
*kcontrol
,
284 struct snd_ctl_elem_value
*ucontrol
)
286 memset(ucontrol
->value
.iec958
.status
, 0xff, AK4114_REG_RXCSB_SIZE
);
290 static int snd_ak4114_spdif_pinfo(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
292 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
293 uinfo
->value
.integer
.min
= 0;
294 uinfo
->value
.integer
.max
= 0xffff;
299 static int snd_ak4114_spdif_pget(struct snd_kcontrol
*kcontrol
,
300 struct snd_ctl_elem_value
*ucontrol
)
302 struct ak4114
*chip
= snd_kcontrol_chip(kcontrol
);
305 ucontrol
->value
.integer
.value
[0] = 0xf8f2;
306 ucontrol
->value
.integer
.value
[1] = 0x4e1f;
307 tmp
= reg_read(chip
, AK4114_REG_Pc0
) | (reg_read(chip
, AK4114_REG_Pc1
) << 8);
308 ucontrol
->value
.integer
.value
[2] = tmp
;
309 tmp
= reg_read(chip
, AK4114_REG_Pd0
) | (reg_read(chip
, AK4114_REG_Pd1
) << 8);
310 ucontrol
->value
.integer
.value
[3] = tmp
;
314 static int snd_ak4114_spdif_qinfo(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
316 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BYTES
;
317 uinfo
->count
= AK4114_REG_QSUB_SIZE
;
321 static int snd_ak4114_spdif_qget(struct snd_kcontrol
*kcontrol
,
322 struct snd_ctl_elem_value
*ucontrol
)
324 struct ak4114
*chip
= snd_kcontrol_chip(kcontrol
);
327 for (i
= 0; i
< AK4114_REG_QSUB_SIZE
; i
++)
328 ucontrol
->value
.bytes
.data
[i
] = reg_read(chip
, AK4114_REG_QSUB_ADDR
+ i
);
332 /* Don't forget to change AK4114_CONTROLS define!!! */
333 static struct snd_kcontrol_new snd_ak4114_iec958_controls
[] = {
335 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
336 .name
= "IEC958 Parity Errors",
337 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
338 .info
= snd_ak4114_in_error_info
,
339 .get
= snd_ak4114_in_error_get
,
340 .private_value
= offsetof(struct ak4114
, parity_errors
),
343 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
344 .name
= "IEC958 V-Bit Errors",
345 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
346 .info
= snd_ak4114_in_error_info
,
347 .get
= snd_ak4114_in_error_get
,
348 .private_value
= offsetof(struct ak4114
, v_bit_errors
),
351 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
352 .name
= "IEC958 C-CRC Errors",
353 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
354 .info
= snd_ak4114_in_error_info
,
355 .get
= snd_ak4114_in_error_get
,
356 .private_value
= offsetof(struct ak4114
, ccrc_errors
),
359 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
360 .name
= "IEC958 Q-CRC Errors",
361 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
362 .info
= snd_ak4114_in_error_info
,
363 .get
= snd_ak4114_in_error_get
,
364 .private_value
= offsetof(struct ak4114
, qcrc_errors
),
367 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
368 .name
= "IEC958 External Rate",
369 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
370 .info
= snd_ak4114_rate_info
,
371 .get
= snd_ak4114_rate_get
,
374 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
375 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,MASK
),
376 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
377 .info
= snd_ak4114_spdif_mask_info
,
378 .get
= snd_ak4114_spdif_mask_get
,
381 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
382 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,DEFAULT
),
383 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
384 .info
= snd_ak4114_spdif_info
,
385 .get
= snd_ak4114_spdif_playback_get
,
386 .put
= snd_ak4114_spdif_playback_put
,
389 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
390 .name
= SNDRV_CTL_NAME_IEC958("",CAPTURE
,MASK
),
391 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
392 .info
= snd_ak4114_spdif_mask_info
,
393 .get
= snd_ak4114_spdif_mask_get
,
396 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
397 .name
= SNDRV_CTL_NAME_IEC958("",CAPTURE
,DEFAULT
),
398 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
399 .info
= snd_ak4114_spdif_info
,
400 .get
= snd_ak4114_spdif_get
,
403 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
404 .name
= "IEC958 Preample Capture Default",
405 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
406 .info
= snd_ak4114_spdif_pinfo
,
407 .get
= snd_ak4114_spdif_pget
,
410 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
411 .name
= "IEC958 Q-subcode Capture Default",
412 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
413 .info
= snd_ak4114_spdif_qinfo
,
414 .get
= snd_ak4114_spdif_qget
,
417 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
418 .name
= "IEC958 Audio",
419 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
420 .info
= snd_ak4114_in_bit_info
,
421 .get
= snd_ak4114_in_bit_get
,
422 .private_value
= (1<<31) | (1<<8) | AK4114_REG_RCS0
,
425 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
426 .name
= "IEC958 Non-PCM Bitstream",
427 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
428 .info
= snd_ak4114_in_bit_info
,
429 .get
= snd_ak4114_in_bit_get
,
430 .private_value
= (6<<8) | AK4114_REG_RCS1
,
433 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
434 .name
= "IEC958 DTS Bitstream",
435 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
436 .info
= snd_ak4114_in_bit_info
,
437 .get
= snd_ak4114_in_bit_get
,
438 .private_value
= (3<<8) | AK4114_REG_RCS1
,
442 int snd_ak4114_build(struct ak4114
*ak4114
,
443 struct snd_pcm_substream
*ply_substream
,
444 struct snd_pcm_substream
*cap_substream
)
446 struct snd_kcontrol
*kctl
;
450 snd_assert(cap_substream
, return -EINVAL
);
451 ak4114
->playback_substream
= ply_substream
;
452 ak4114
->capture_substream
= cap_substream
;
453 for (idx
= 0; idx
< AK4114_CONTROLS
; idx
++) {
454 kctl
= snd_ctl_new1(&snd_ak4114_iec958_controls
[idx
], ak4114
);
457 if (!strstr(kctl
->id
.name
, "Playback")) {
458 if (ply_substream
== NULL
) {
459 snd_ctl_free_one(kctl
);
460 ak4114
->kctls
[idx
] = NULL
;
463 kctl
->id
.device
= ply_substream
->pcm
->device
;
464 kctl
->id
.subdevice
= ply_substream
->number
;
466 kctl
->id
.device
= cap_substream
->pcm
->device
;
467 kctl
->id
.subdevice
= cap_substream
->number
;
469 err
= snd_ctl_add(ak4114
->card
, kctl
);
472 ak4114
->kctls
[idx
] = kctl
;
477 int snd_ak4114_external_rate(struct ak4114
*ak4114
)
481 rcs1
= reg_read(ak4114
, AK4114_REG_RCS1
);
482 return external_rate(rcs1
);
485 int snd_ak4114_check_rate_and_errors(struct ak4114
*ak4114
, unsigned int flags
)
487 struct snd_pcm_runtime
*runtime
= ak4114
->capture_substream
? ak4114
->capture_substream
->runtime
: NULL
;
488 unsigned long _flags
;
490 unsigned char rcs0
, rcs1
;
491 unsigned char c0
, c1
;
493 rcs1
= reg_read(ak4114
, AK4114_REG_RCS1
);
494 if (flags
& AK4114_CHECK_NO_STAT
)
496 rcs0
= reg_read(ak4114
, AK4114_REG_RCS0
);
497 spin_lock_irqsave(&ak4114
->lock
, _flags
);
498 if (rcs0
& AK4114_PAR
)
499 ak4114
->parity_errors
++;
501 ak4114
->v_bit_errors
++;
502 if (rcs1
& AK4114_CCRC
)
503 ak4114
->ccrc_errors
++;
504 if (rcs1
& AK4114_QCRC
)
505 ak4114
->qcrc_errors
++;
506 c0
= (ak4114
->rcs0
& (AK4114_QINT
| AK4114_CINT
| AK4114_PEM
| AK4114_AUDION
| AK4114_AUTO
| AK4114_UNLCK
)) ^
507 (rcs0
& (AK4114_QINT
| AK4114_CINT
| AK4114_PEM
| AK4114_AUDION
| AK4114_AUTO
| AK4114_UNLCK
));
508 c1
= (ak4114
->rcs1
& 0xf0) ^ (rcs1
& 0xf0);
509 ak4114
->rcs0
= rcs0
& ~(AK4114_QINT
| AK4114_CINT
);
511 spin_unlock_irqrestore(&ak4114
->lock
, _flags
);
513 if (rcs0
& AK4114_PAR
)
514 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
, &ak4114
->kctls
[0]->id
);
516 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
, &ak4114
->kctls
[1]->id
);
517 if (rcs1
& AK4114_CCRC
)
518 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
, &ak4114
->kctls
[2]->id
);
519 if (rcs1
& AK4114_QCRC
)
520 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
, &ak4114
->kctls
[3]->id
);
524 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
, &ak4114
->kctls
[4]->id
);
526 if ((c0
& AK4114_PEM
) | (c0
& AK4114_CINT
))
527 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
, &ak4114
->kctls
[9]->id
);
528 if (c0
& AK4114_QINT
)
529 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
, &ak4114
->kctls
[10]->id
);
531 if (c0
& AK4114_AUDION
)
532 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
, &ak4114
->kctls
[11]->id
);
533 if (c0
& AK4114_AUTO
)
534 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
, &ak4114
->kctls
[12]->id
);
535 if (c0
& AK4114_DTSCD
)
536 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
, &ak4114
->kctls
[13]->id
);
538 if (ak4114
->change_callback
&& (c0
| c1
) != 0)
539 ak4114
->change_callback(ak4114
, c0
, c1
);
543 res
= external_rate(rcs1
);
544 if (!(flags
& AK4114_CHECK_NO_RATE
) && runtime
&& runtime
->rate
!= res
) {
545 snd_pcm_stream_lock_irqsave(ak4114
->capture_substream
, _flags
);
546 if (snd_pcm_running(ak4114
->capture_substream
)) {
547 // printk(KERN_DEBUG "rate changed (%i <- %i)\n", runtime->rate, res);
548 snd_pcm_stop(ak4114
->capture_substream
, SNDRV_PCM_STATE_DRAINING
);
551 snd_pcm_stream_unlock_irqrestore(ak4114
->capture_substream
, _flags
);
556 static void ak4114_stats(struct work_struct
*work
)
558 struct ak4114
*chip
= container_of(work
, struct ak4114
, work
.work
);
562 snd_ak4114_check_rate_and_errors(chip
, 0);
563 schedule_delayed_work(&chip
->work
, HZ
/ 10);
566 EXPORT_SYMBOL(snd_ak4114_create
);
567 EXPORT_SYMBOL(snd_ak4114_reg_write
);
568 EXPORT_SYMBOL(snd_ak4114_reinit
);
569 EXPORT_SYMBOL(snd_ak4114_build
);
570 EXPORT_SYMBOL(snd_ak4114_external_rate
);
571 EXPORT_SYMBOL(snd_ak4114_check_rate_and_errors
);