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_TXCSB0
&& reg
<= AK4114_REG_TXCSB4
)
46 ak4114
->txcsb
[reg
-AK4114_REG_TXCSB0
] = 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
)
131 (chip
->txcsb
[reg
-AK4114_REG_TXCSB0
] & ~mask
) | val
);
134 void snd_ak4114_reinit(struct ak4114
*chip
)
136 unsigned char old
= chip
->regmap
[AK4114_REG_PWRDN
], reg
;
140 flush_scheduled_work();
141 /* bring the chip to reset state and powerdown state */
142 reg_write(chip
, AK4114_REG_PWRDN
, old
& ~(AK4114_RST
|AK4114_PWN
));
144 /* release reset, but leave powerdown */
145 reg_write(chip
, AK4114_REG_PWRDN
, (old
| AK4114_RST
) & ~AK4114_PWN
);
147 for (reg
= 1; reg
< 7; reg
++)
148 reg_write(chip
, reg
, chip
->regmap
[reg
]);
149 for (reg
= 0; reg
< 5; reg
++)
150 reg_write(chip
, reg
+ AK4114_REG_TXCSB0
, chip
->txcsb
[reg
]);
151 /* release powerdown, everything is initialized now */
152 reg_write(chip
, AK4114_REG_PWRDN
, old
| AK4114_RST
| AK4114_PWN
);
153 /* bring up statistics / event queing */
155 schedule_delayed_work(&chip
->work
, HZ
/ 10);
158 static unsigned int external_rate(unsigned char rcs1
)
160 switch (rcs1
& (AK4114_FS0
|AK4114_FS1
|AK4114_FS2
|AK4114_FS3
)) {
161 case AK4114_FS_32000HZ
: return 32000;
162 case AK4114_FS_44100HZ
: return 44100;
163 case AK4114_FS_48000HZ
: return 48000;
164 case AK4114_FS_88200HZ
: return 88200;
165 case AK4114_FS_96000HZ
: return 96000;
166 case AK4114_FS_176400HZ
: return 176400;
167 case AK4114_FS_192000HZ
: return 192000;
172 static int snd_ak4114_in_error_info(struct snd_kcontrol
*kcontrol
,
173 struct snd_ctl_elem_info
*uinfo
)
175 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
177 uinfo
->value
.integer
.min
= 0;
178 uinfo
->value
.integer
.max
= LONG_MAX
;
182 static int snd_ak4114_in_error_get(struct snd_kcontrol
*kcontrol
,
183 struct snd_ctl_elem_value
*ucontrol
)
185 struct ak4114
*chip
= snd_kcontrol_chip(kcontrol
);
188 spin_lock_irq(&chip
->lock
);
189 ptr
= (long *)(((char *)chip
) + kcontrol
->private_value
);
190 ucontrol
->value
.integer
.value
[0] = *ptr
;
192 spin_unlock_irq(&chip
->lock
);
196 static int snd_ak4114_in_bit_info(struct snd_kcontrol
*kcontrol
,
197 struct snd_ctl_elem_info
*uinfo
)
199 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
201 uinfo
->value
.integer
.min
= 0;
202 uinfo
->value
.integer
.max
= 1;
206 static int snd_ak4114_in_bit_get(struct snd_kcontrol
*kcontrol
,
207 struct snd_ctl_elem_value
*ucontrol
)
209 struct ak4114
*chip
= snd_kcontrol_chip(kcontrol
);
210 unsigned char reg
= kcontrol
->private_value
& 0xff;
211 unsigned char bit
= (kcontrol
->private_value
>> 8) & 0xff;
212 unsigned char inv
= (kcontrol
->private_value
>> 31) & 1;
214 ucontrol
->value
.integer
.value
[0] = ((reg_read(chip
, reg
) & (1 << bit
)) ? 1 : 0) ^ inv
;
218 static int snd_ak4114_rate_info(struct snd_kcontrol
*kcontrol
,
219 struct snd_ctl_elem_info
*uinfo
)
221 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
223 uinfo
->value
.integer
.min
= 0;
224 uinfo
->value
.integer
.max
= 192000;
228 static int snd_ak4114_rate_get(struct snd_kcontrol
*kcontrol
,
229 struct snd_ctl_elem_value
*ucontrol
)
231 struct ak4114
*chip
= snd_kcontrol_chip(kcontrol
);
233 ucontrol
->value
.integer
.value
[0] = external_rate(reg_read(chip
, AK4114_REG_RCS1
));
237 static int snd_ak4114_spdif_info(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
239 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_IEC958
;
244 static int snd_ak4114_spdif_get(struct snd_kcontrol
*kcontrol
,
245 struct snd_ctl_elem_value
*ucontrol
)
247 struct ak4114
*chip
= snd_kcontrol_chip(kcontrol
);
250 for (i
= 0; i
< AK4114_REG_RXCSB_SIZE
; i
++)
251 ucontrol
->value
.iec958
.status
[i
] = reg_read(chip
, AK4114_REG_RXCSB0
+ i
);
255 static int snd_ak4114_spdif_playback_get(struct snd_kcontrol
*kcontrol
,
256 struct snd_ctl_elem_value
*ucontrol
)
258 struct ak4114
*chip
= snd_kcontrol_chip(kcontrol
);
261 for (i
= 0; i
< AK4114_REG_TXCSB_SIZE
; i
++)
262 ucontrol
->value
.iec958
.status
[i
] = chip
->txcsb
[i
];
266 static int snd_ak4114_spdif_playback_put(struct snd_kcontrol
*kcontrol
,
267 struct snd_ctl_elem_value
*ucontrol
)
269 struct ak4114
*chip
= snd_kcontrol_chip(kcontrol
);
272 for (i
= 0; i
< AK4114_REG_TXCSB_SIZE
; i
++)
273 reg_write(chip
, AK4114_REG_TXCSB0
+ i
, ucontrol
->value
.iec958
.status
[i
]);
277 static int snd_ak4114_spdif_mask_info(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
279 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_IEC958
;
284 static int snd_ak4114_spdif_mask_get(struct snd_kcontrol
*kcontrol
,
285 struct snd_ctl_elem_value
*ucontrol
)
287 memset(ucontrol
->value
.iec958
.status
, 0xff, AK4114_REG_RXCSB_SIZE
);
291 static int snd_ak4114_spdif_pinfo(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
293 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_INTEGER
;
294 uinfo
->value
.integer
.min
= 0;
295 uinfo
->value
.integer
.max
= 0xffff;
300 static int snd_ak4114_spdif_pget(struct snd_kcontrol
*kcontrol
,
301 struct snd_ctl_elem_value
*ucontrol
)
303 struct ak4114
*chip
= snd_kcontrol_chip(kcontrol
);
306 ucontrol
->value
.integer
.value
[0] = 0xf8f2;
307 ucontrol
->value
.integer
.value
[1] = 0x4e1f;
308 tmp
= reg_read(chip
, AK4114_REG_Pc0
) | (reg_read(chip
, AK4114_REG_Pc1
) << 8);
309 ucontrol
->value
.integer
.value
[2] = tmp
;
310 tmp
= reg_read(chip
, AK4114_REG_Pd0
) | (reg_read(chip
, AK4114_REG_Pd1
) << 8);
311 ucontrol
->value
.integer
.value
[3] = tmp
;
315 static int snd_ak4114_spdif_qinfo(struct snd_kcontrol
*kcontrol
, struct snd_ctl_elem_info
*uinfo
)
317 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BYTES
;
318 uinfo
->count
= AK4114_REG_QSUB_SIZE
;
322 static int snd_ak4114_spdif_qget(struct snd_kcontrol
*kcontrol
,
323 struct snd_ctl_elem_value
*ucontrol
)
325 struct ak4114
*chip
= snd_kcontrol_chip(kcontrol
);
328 for (i
= 0; i
< AK4114_REG_QSUB_SIZE
; i
++)
329 ucontrol
->value
.bytes
.data
[i
] = reg_read(chip
, AK4114_REG_QSUB_ADDR
+ i
);
333 /* Don't forget to change AK4114_CONTROLS define!!! */
334 static struct snd_kcontrol_new snd_ak4114_iec958_controls
[] = {
336 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
337 .name
= "IEC958 Parity 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
= offsetof(struct ak4114
, parity_errors
),
344 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
345 .name
= "IEC958 V-Bit Errors",
346 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
347 .info
= snd_ak4114_in_error_info
,
348 .get
= snd_ak4114_in_error_get
,
349 .private_value
= offsetof(struct ak4114
, v_bit_errors
),
352 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
353 .name
= "IEC958 C-CRC Errors",
354 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
355 .info
= snd_ak4114_in_error_info
,
356 .get
= snd_ak4114_in_error_get
,
357 .private_value
= offsetof(struct ak4114
, ccrc_errors
),
360 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
361 .name
= "IEC958 Q-CRC Errors",
362 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
363 .info
= snd_ak4114_in_error_info
,
364 .get
= snd_ak4114_in_error_get
,
365 .private_value
= offsetof(struct ak4114
, qcrc_errors
),
368 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
369 .name
= "IEC958 External Rate",
370 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
371 .info
= snd_ak4114_rate_info
,
372 .get
= snd_ak4114_rate_get
,
375 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
376 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,MASK
),
377 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
378 .info
= snd_ak4114_spdif_mask_info
,
379 .get
= snd_ak4114_spdif_mask_get
,
382 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
383 .name
= SNDRV_CTL_NAME_IEC958("",PLAYBACK
,DEFAULT
),
384 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
385 .info
= snd_ak4114_spdif_info
,
386 .get
= snd_ak4114_spdif_playback_get
,
387 .put
= snd_ak4114_spdif_playback_put
,
390 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
391 .name
= SNDRV_CTL_NAME_IEC958("",CAPTURE
,MASK
),
392 .access
= SNDRV_CTL_ELEM_ACCESS_READ
,
393 .info
= snd_ak4114_spdif_mask_info
,
394 .get
= snd_ak4114_spdif_mask_get
,
397 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
398 .name
= SNDRV_CTL_NAME_IEC958("",CAPTURE
,DEFAULT
),
399 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
400 .info
= snd_ak4114_spdif_info
,
401 .get
= snd_ak4114_spdif_get
,
404 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
405 .name
= "IEC958 Preample Capture Default",
406 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
407 .info
= snd_ak4114_spdif_pinfo
,
408 .get
= snd_ak4114_spdif_pget
,
411 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
412 .name
= "IEC958 Q-subcode Capture Default",
413 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
414 .info
= snd_ak4114_spdif_qinfo
,
415 .get
= snd_ak4114_spdif_qget
,
418 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
419 .name
= "IEC958 Audio",
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) | (1<<8) | AK4114_REG_RCS0
,
426 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
427 .name
= "IEC958 Non-PCM Bitstream",
428 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
429 .info
= snd_ak4114_in_bit_info
,
430 .get
= snd_ak4114_in_bit_get
,
431 .private_value
= (6<<8) | AK4114_REG_RCS1
,
434 .iface
= SNDRV_CTL_ELEM_IFACE_PCM
,
435 .name
= "IEC958 DTS Bitstream",
436 .access
= SNDRV_CTL_ELEM_ACCESS_READ
| SNDRV_CTL_ELEM_ACCESS_VOLATILE
,
437 .info
= snd_ak4114_in_bit_info
,
438 .get
= snd_ak4114_in_bit_get
,
439 .private_value
= (3<<8) | AK4114_REG_RCS1
,
443 int snd_ak4114_build(struct ak4114
*ak4114
,
444 struct snd_pcm_substream
*ply_substream
,
445 struct snd_pcm_substream
*cap_substream
)
447 struct snd_kcontrol
*kctl
;
451 snd_assert(cap_substream
, return -EINVAL
);
452 ak4114
->playback_substream
= ply_substream
;
453 ak4114
->capture_substream
= cap_substream
;
454 for (idx
= 0; idx
< AK4114_CONTROLS
; idx
++) {
455 kctl
= snd_ctl_new1(&snd_ak4114_iec958_controls
[idx
], ak4114
);
458 if (!strstr(kctl
->id
.name
, "Playback")) {
459 if (ply_substream
== NULL
) {
460 snd_ctl_free_one(kctl
);
461 ak4114
->kctls
[idx
] = NULL
;
464 kctl
->id
.device
= ply_substream
->pcm
->device
;
465 kctl
->id
.subdevice
= ply_substream
->number
;
467 kctl
->id
.device
= cap_substream
->pcm
->device
;
468 kctl
->id
.subdevice
= cap_substream
->number
;
470 err
= snd_ctl_add(ak4114
->card
, kctl
);
473 ak4114
->kctls
[idx
] = kctl
;
478 int snd_ak4114_external_rate(struct ak4114
*ak4114
)
482 rcs1
= reg_read(ak4114
, AK4114_REG_RCS1
);
483 return external_rate(rcs1
);
486 int snd_ak4114_check_rate_and_errors(struct ak4114
*ak4114
, unsigned int flags
)
488 struct snd_pcm_runtime
*runtime
= ak4114
->capture_substream
? ak4114
->capture_substream
->runtime
: NULL
;
489 unsigned long _flags
;
491 unsigned char rcs0
, rcs1
;
492 unsigned char c0
, c1
;
494 rcs1
= reg_read(ak4114
, AK4114_REG_RCS1
);
495 if (flags
& AK4114_CHECK_NO_STAT
)
497 rcs0
= reg_read(ak4114
, AK4114_REG_RCS0
);
498 spin_lock_irqsave(&ak4114
->lock
, _flags
);
499 if (rcs0
& AK4114_PAR
)
500 ak4114
->parity_errors
++;
502 ak4114
->v_bit_errors
++;
503 if (rcs1
& AK4114_CCRC
)
504 ak4114
->ccrc_errors
++;
505 if (rcs1
& AK4114_QCRC
)
506 ak4114
->qcrc_errors
++;
507 c0
= (ak4114
->rcs0
& (AK4114_QINT
| AK4114_CINT
| AK4114_PEM
| AK4114_AUDION
| AK4114_AUTO
| AK4114_UNLCK
)) ^
508 (rcs0
& (AK4114_QINT
| AK4114_CINT
| AK4114_PEM
| AK4114_AUDION
| AK4114_AUTO
| AK4114_UNLCK
));
509 c1
= (ak4114
->rcs1
& 0xf0) ^ (rcs1
& 0xf0);
510 ak4114
->rcs0
= rcs0
& ~(AK4114_QINT
| AK4114_CINT
);
512 spin_unlock_irqrestore(&ak4114
->lock
, _flags
);
514 if (rcs0
& AK4114_PAR
)
515 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
, &ak4114
->kctls
[0]->id
);
517 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
, &ak4114
->kctls
[1]->id
);
518 if (rcs1
& AK4114_CCRC
)
519 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
, &ak4114
->kctls
[2]->id
);
520 if (rcs1
& AK4114_QCRC
)
521 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
, &ak4114
->kctls
[3]->id
);
525 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
, &ak4114
->kctls
[4]->id
);
527 if ((c0
& AK4114_PEM
) | (c0
& AK4114_CINT
))
528 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
, &ak4114
->kctls
[9]->id
);
529 if (c0
& AK4114_QINT
)
530 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
, &ak4114
->kctls
[10]->id
);
532 if (c0
& AK4114_AUDION
)
533 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
, &ak4114
->kctls
[11]->id
);
534 if (c0
& AK4114_AUTO
)
535 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
, &ak4114
->kctls
[12]->id
);
536 if (c0
& AK4114_DTSCD
)
537 snd_ctl_notify(ak4114
->card
, SNDRV_CTL_EVENT_MASK_VALUE
, &ak4114
->kctls
[13]->id
);
539 if (ak4114
->change_callback
&& (c0
| c1
) != 0)
540 ak4114
->change_callback(ak4114
, c0
, c1
);
544 res
= external_rate(rcs1
);
545 if (!(flags
& AK4114_CHECK_NO_RATE
) && runtime
&& runtime
->rate
!= res
) {
546 snd_pcm_stream_lock_irqsave(ak4114
->capture_substream
, _flags
);
547 if (snd_pcm_running(ak4114
->capture_substream
)) {
548 // printk(KERN_DEBUG "rate changed (%i <- %i)\n", runtime->rate, res);
549 snd_pcm_stop(ak4114
->capture_substream
, SNDRV_PCM_STATE_DRAINING
);
552 snd_pcm_stream_unlock_irqrestore(ak4114
->capture_substream
, _flags
);
557 static void ak4114_stats(struct work_struct
*work
)
559 struct ak4114
*chip
= container_of(work
, struct ak4114
, work
.work
);
563 snd_ak4114_check_rate_and_errors(chip
, 0);
564 schedule_delayed_work(&chip
->work
, HZ
/ 10);
567 EXPORT_SYMBOL(snd_ak4114_create
);
568 EXPORT_SYMBOL(snd_ak4114_reg_write
);
569 EXPORT_SYMBOL(snd_ak4114_reinit
);
570 EXPORT_SYMBOL(snd_ak4114_build
);
571 EXPORT_SYMBOL(snd_ak4114_external_rate
);
572 EXPORT_SYMBOL(snd_ak4114_check_rate_and_errors
);