1 /* 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> 5 * 6 * 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. 11 * 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. 16 * 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 20 * 21 */ 22 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> 31 32 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>"); 33 MODULE_DESCRIPTION("AK4114 IEC958 (S/PDIF) receiver by Asahi Kasei"); 34 MODULE_LICENSE("GPL"); 35 36 #define AK4114_ADDR 0x00 /* fixed address */ 37 38 static void ak4114_stats(struct work_struct *work); 39 40 static void reg_write(struct ak4114 *ak4114, unsigned char reg, unsigned char val) 41 { 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; 47 } 48 49 static inline unsigned char reg_read(struct ak4114 *ak4114, unsigned char reg) 50 { 51 return ak4114->read(ak4114->private_data, reg); 52 } 53 54 #if 0 55 static void reg_dump(struct ak4114 *ak4114) 56 { 57 int i; 58 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); 62 } 63 #endif 64 65 static void snd_ak4114_free(struct ak4114 *chip) 66 { 67 chip->init = 1; /* don't schedule new work */ 68 mb(); 69 cancel_delayed_work(&chip->work); 70 flush_scheduled_work(); 71 kfree(chip); 72 } 73 74 static int snd_ak4114_dev_free(struct snd_device *device) 75 { 76 struct ak4114 *chip = device->device_data; 77 snd_ak4114_free(chip); 78 return 0; 79 } 80 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) 85 { 86 struct ak4114 *chip; 87 int err = 0; 88 unsigned char reg; 89 static struct snd_device_ops ops = { 90 .dev_free = snd_ak4114_dev_free, 91 }; 92 93 chip = kzalloc(sizeof(*chip), GFP_KERNEL); 94 if (chip == NULL) 95 return -ENOMEM; 96 spin_lock_init(&chip->lock); 97 chip->card = card; 98 chip->read = read; 99 chip->write = write; 100 chip->private_data = private_data; 101 INIT_DELAYED_WORK(&chip->work, ak4114_stats); 102 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]; 107 108 snd_ak4114_reinit(chip); 109 110 chip->rcs0 = reg_read(chip, AK4114_REG_RCS0) & ~(AK4114_QINT | AK4114_CINT); 111 chip->rcs1 = reg_read(chip, AK4114_REG_RCS1); 112 113 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) 114 goto __fail; 115 116 if (r_ak4114) 117 *r_ak4114 = chip; 118 return 0; 119 120 __fail: 121 snd_ak4114_free(chip); 122 return err < 0 ? err : -EIO; 123 } 124 125 void snd_ak4114_reg_write(struct ak4114 *chip, unsigned char reg, unsigned char mask, unsigned char val) 126 { 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, 131 (chip->txcsb[reg-AK4114_REG_TXCSB0] & ~mask) | val); 132 } 133 134 void snd_ak4114_reinit(struct ak4114 *chip) 135 { 136 unsigned char old = chip->regmap[AK4114_REG_PWRDN], reg; 137 138 chip->init = 1; 139 mb(); 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)); 143 udelay(200); 144 /* release reset, but leave powerdown */ 145 reg_write(chip, AK4114_REG_PWRDN, (old | AK4114_RST) & ~AK4114_PWN); 146 udelay(200); 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 */ 154 chip->init = 0; 155 schedule_delayed_work(&chip->work, HZ / 10); 156 } 157 158 static unsigned int external_rate(unsigned char rcs1) 159 { 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; 168 default: return 0; 169 } 170 } 171 172 static int snd_ak4114_in_error_info(struct snd_kcontrol *kcontrol, 173 struct snd_ctl_elem_info *uinfo) 174 { 175 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 176 uinfo->count = 1; 177 uinfo->value.integer.min = 0; 178 uinfo->value.integer.max = LONG_MAX; 179 return 0; 180 } 181 182 static int snd_ak4114_in_error_get(struct snd_kcontrol *kcontrol, 183 struct snd_ctl_elem_value *ucontrol) 184 { 185 struct ak4114 *chip = snd_kcontrol_chip(kcontrol); 186 long *ptr; 187 188 spin_lock_irq(&chip->lock); 189 ptr = (long *)(((char *)chip) + kcontrol->private_value); 190 ucontrol->value.integer.value[0] = *ptr; 191 *ptr = 0; 192 spin_unlock_irq(&chip->lock); 193 return 0; 194 } 195 196 static int snd_ak4114_in_bit_info(struct snd_kcontrol *kcontrol, 197 struct snd_ctl_elem_info *uinfo) 198 { 199 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 200 uinfo->count = 1; 201 uinfo->value.integer.min = 0; 202 uinfo->value.integer.max = 1; 203 return 0; 204 } 205 206 static int snd_ak4114_in_bit_get(struct snd_kcontrol *kcontrol, 207 struct snd_ctl_elem_value *ucontrol) 208 { 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; 213 214 ucontrol->value.integer.value[0] = ((reg_read(chip, reg) & (1 << bit)) ? 1 : 0) ^ inv; 215 return 0; 216 } 217 218 static int snd_ak4114_rate_info(struct snd_kcontrol *kcontrol, 219 struct snd_ctl_elem_info *uinfo) 220 { 221 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 222 uinfo->count = 1; 223 uinfo->value.integer.min = 0; 224 uinfo->value.integer.max = 192000; 225 return 0; 226 } 227 228 static int snd_ak4114_rate_get(struct snd_kcontrol *kcontrol, 229 struct snd_ctl_elem_value *ucontrol) 230 { 231 struct ak4114 *chip = snd_kcontrol_chip(kcontrol); 232 233 ucontrol->value.integer.value[0] = external_rate(reg_read(chip, AK4114_REG_RCS1)); 234 return 0; 235 } 236 237 static int snd_ak4114_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 238 { 239 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; 240 uinfo->count = 1; 241 return 0; 242 } 243 244 static int snd_ak4114_spdif_get(struct snd_kcontrol *kcontrol, 245 struct snd_ctl_elem_value *ucontrol) 246 { 247 struct ak4114 *chip = snd_kcontrol_chip(kcontrol); 248 unsigned i; 249 250 for (i = 0; i < AK4114_REG_RXCSB_SIZE; i++) 251 ucontrol->value.iec958.status[i] = reg_read(chip, AK4114_REG_RXCSB0 + i); 252 return 0; 253 } 254 255 static int snd_ak4114_spdif_playback_get(struct snd_kcontrol *kcontrol, 256 struct snd_ctl_elem_value *ucontrol) 257 { 258 struct ak4114 *chip = snd_kcontrol_chip(kcontrol); 259 unsigned i; 260 261 for (i = 0; i < AK4114_REG_TXCSB_SIZE; i++) 262 ucontrol->value.iec958.status[i] = chip->txcsb[i]; 263 return 0; 264 } 265 266 static int snd_ak4114_spdif_playback_put(struct snd_kcontrol *kcontrol, 267 struct snd_ctl_elem_value *ucontrol) 268 { 269 struct ak4114 *chip = snd_kcontrol_chip(kcontrol); 270 unsigned i; 271 272 for (i = 0; i < AK4114_REG_TXCSB_SIZE; i++) 273 reg_write(chip, AK4114_REG_TXCSB0 + i, ucontrol->value.iec958.status[i]); 274 return 0; 275 } 276 277 static int snd_ak4114_spdif_mask_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 278 { 279 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; 280 uinfo->count = 1; 281 return 0; 282 } 283 284 static int snd_ak4114_spdif_mask_get(struct snd_kcontrol *kcontrol, 285 struct snd_ctl_elem_value *ucontrol) 286 { 287 memset(ucontrol->value.iec958.status, 0xff, AK4114_REG_RXCSB_SIZE); 288 return 0; 289 } 290 291 static int snd_ak4114_spdif_pinfo(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 292 { 293 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 294 uinfo->value.integer.min = 0; 295 uinfo->value.integer.max = 0xffff; 296 uinfo->count = 4; 297 return 0; 298 } 299 300 static int snd_ak4114_spdif_pget(struct snd_kcontrol *kcontrol, 301 struct snd_ctl_elem_value *ucontrol) 302 { 303 struct ak4114 *chip = snd_kcontrol_chip(kcontrol); 304 unsigned short tmp; 305 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; 312 return 0; 313 } 314 315 static int snd_ak4114_spdif_qinfo(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 316 { 317 uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES; 318 uinfo->count = AK4114_REG_QSUB_SIZE; 319 return 0; 320 } 321 322 static int snd_ak4114_spdif_qget(struct snd_kcontrol *kcontrol, 323 struct snd_ctl_elem_value *ucontrol) 324 { 325 struct ak4114 *chip = snd_kcontrol_chip(kcontrol); 326 unsigned i; 327 328 for (i = 0; i < AK4114_REG_QSUB_SIZE; i++) 329 ucontrol->value.bytes.data[i] = reg_read(chip, AK4114_REG_QSUB_ADDR + i); 330 return 0; 331 } 332 333 /* Don't forget to change AK4114_CONTROLS define!!! */ 334 static struct snd_kcontrol_new snd_ak4114_iec958_controls[] = { 335 { 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), 342 }, 343 { 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), 350 }, 351 { 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), 358 }, 359 { 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), 366 }, 367 { 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, 373 }, 374 { 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, 380 }, 381 { 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, 388 }, 389 { 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, 395 }, 396 { 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, 402 }, 403 { 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, 409 }, 410 { 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, 416 }, 417 { 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, 424 }, 425 { 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, 432 }, 433 { 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, 440 } 441 }; 442 443 int snd_ak4114_build(struct ak4114 *ak4114, 444 struct snd_pcm_substream *ply_substream, 445 struct snd_pcm_substream *cap_substream) 446 { 447 struct snd_kcontrol *kctl; 448 unsigned int idx; 449 int err; 450 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); 456 if (kctl == NULL) 457 return -ENOMEM; 458 if (!strstr(kctl->id.name, "Playback")) { 459 if (ply_substream == NULL) { 460 snd_ctl_free_one(kctl); 461 ak4114->kctls[idx] = NULL; 462 continue; 463 } 464 kctl->id.device = ply_substream->pcm->device; 465 kctl->id.subdevice = ply_substream->number; 466 } else { 467 kctl->id.device = cap_substream->pcm->device; 468 kctl->id.subdevice = cap_substream->number; 469 } 470 err = snd_ctl_add(ak4114->card, kctl); 471 if (err < 0) 472 return err; 473 ak4114->kctls[idx] = kctl; 474 } 475 return 0; 476 } 477 478 int snd_ak4114_external_rate(struct ak4114 *ak4114) 479 { 480 unsigned char rcs1; 481 482 rcs1 = reg_read(ak4114, AK4114_REG_RCS1); 483 return external_rate(rcs1); 484 } 485 486 int snd_ak4114_check_rate_and_errors(struct ak4114 *ak4114, unsigned int flags) 487 { 488 struct snd_pcm_runtime *runtime = ak4114->capture_substream ? ak4114->capture_substream->runtime : NULL; 489 unsigned long _flags; 490 int res = 0; 491 unsigned char rcs0, rcs1; 492 unsigned char c0, c1; 493 494 rcs1 = reg_read(ak4114, AK4114_REG_RCS1); 495 if (flags & AK4114_CHECK_NO_STAT) 496 goto __rate; 497 rcs0 = reg_read(ak4114, AK4114_REG_RCS0); 498 spin_lock_irqsave(&ak4114->lock, _flags); 499 if (rcs0 & AK4114_PAR) 500 ak4114->parity_errors++; 501 if (rcs1 & AK4114_V) 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); 511 ak4114->rcs1 = rcs1; 512 spin_unlock_irqrestore(&ak4114->lock, _flags); 513 514 if (rcs0 & AK4114_PAR) 515 snd_ctl_notify(ak4114->card, SNDRV_CTL_EVENT_MASK_VALUE, &ak4114->kctls[0]->id); 516 if (rcs0 & AK4114_V) 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); 522 523 /* rate change */ 524 if (c1 & 0xf0) 525 snd_ctl_notify(ak4114->card, SNDRV_CTL_EVENT_MASK_VALUE, &ak4114->kctls[4]->id); 526 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); 531 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); 538 539 if (ak4114->change_callback && (c0 | c1) != 0) 540 ak4114->change_callback(ak4114, c0, c1); 541 542 __rate: 543 /* compare rate */ 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); 550 res = 1; 551 } 552 snd_pcm_stream_unlock_irqrestore(ak4114->capture_substream, _flags); 553 } 554 return res; 555 } 556 557 static void ak4114_stats(struct work_struct *work) 558 { 559 struct ak4114 *chip = container_of(work, struct ak4114, work.work); 560 561 if (chip->init) 562 return; 563 snd_ak4114_check_rate_and_errors(chip, 0); 564 schedule_delayed_work(&chip->work, HZ / 10); 565 } 566 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); 573