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@perex.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 <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> 32 33 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>"); 34 MODULE_DESCRIPTION("AK4114 IEC958 (S/PDIF) receiver by Asahi Kasei"); 35 MODULE_LICENSE("GPL"); 36 37 #define AK4114_ADDR 0x00 /* fixed address */ 38 39 static void ak4114_stats(struct work_struct *work); 40 static void ak4114_init_regs(struct ak4114 *chip); 41 42 static void reg_write(struct ak4114 *ak4114, unsigned char reg, unsigned char val) 43 { 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; 49 } 50 51 static inline unsigned char reg_read(struct ak4114 *ak4114, unsigned char reg) 52 { 53 return ak4114->read(ak4114->private_data, reg); 54 } 55 56 #if 0 57 static void reg_dump(struct ak4114 *ak4114) 58 { 59 int i; 60 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); 64 } 65 #endif 66 67 static void snd_ak4114_free(struct ak4114 *chip) 68 { 69 atomic_inc(&chip->wq_processing); /* don't schedule new work */ 70 cancel_delayed_work_sync(&chip->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[6], 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 atomic_set(&chip->wq_processing, 0); 103 mutex_init(&chip->reinit_mutex); 104 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]; 109 110 ak4114_init_regs(chip); 111 112 chip->rcs0 = reg_read(chip, AK4114_REG_RCS0) & ~(AK4114_QINT | AK4114_CINT); 113 chip->rcs1 = reg_read(chip, AK4114_REG_RCS1); 114 115 if ((err = snd_device_new(card, SNDRV_DEV_CODEC, chip, &ops)) < 0) 116 goto __fail; 117 118 if (r_ak4114) 119 *r_ak4114 = chip; 120 return 0; 121 122 __fail: 123 snd_ak4114_free(chip); 124 return err < 0 ? err : -EIO; 125 } 126 EXPORT_SYMBOL(snd_ak4114_create); 127 128 void snd_ak4114_reg_write(struct ak4114 *chip, unsigned char reg, unsigned char mask, unsigned char val) 129 { 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) 133 reg_write(chip, reg, 134 (chip->txcsb[reg-AK4114_REG_TXCSB0] & ~mask) | val); 135 } 136 EXPORT_SYMBOL(snd_ak4114_reg_write); 137 138 static void ak4114_init_regs(struct ak4114 *chip) 139 { 140 unsigned char old = chip->regmap[AK4114_REG_PWRDN], reg; 141 142 /* bring the chip to reset state and powerdown state */ 143 reg_write(chip, AK4114_REG_PWRDN, old & ~(AK4114_RST|AK4114_PWN)); 144 udelay(200); 145 /* release reset, but leave powerdown */ 146 reg_write(chip, AK4114_REG_PWRDN, (old | AK4114_RST) & ~AK4114_PWN); 147 udelay(200); 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); 154 } 155 156 void snd_ak4114_reinit(struct ak4114 *chip) 157 { 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); 166 } 167 EXPORT_SYMBOL(snd_ak4114_reinit); 168 169 static unsigned int external_rate(unsigned char rcs1) 170 { 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; 179 default: return 0; 180 } 181 } 182 183 static int snd_ak4114_in_error_info(struct snd_kcontrol *kcontrol, 184 struct snd_ctl_elem_info *uinfo) 185 { 186 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 187 uinfo->count = 1; 188 uinfo->value.integer.min = 0; 189 uinfo->value.integer.max = LONG_MAX; 190 return 0; 191 } 192 193 static int snd_ak4114_in_error_get(struct snd_kcontrol *kcontrol, 194 struct snd_ctl_elem_value *ucontrol) 195 { 196 struct ak4114 *chip = snd_kcontrol_chip(kcontrol); 197 long *ptr; 198 199 spin_lock_irq(&chip->lock); 200 ptr = (long *)(((char *)chip) + kcontrol->private_value); 201 ucontrol->value.integer.value[0] = *ptr; 202 *ptr = 0; 203 spin_unlock_irq(&chip->lock); 204 return 0; 205 } 206 207 #define snd_ak4114_in_bit_info snd_ctl_boolean_mono_info 208 209 static int snd_ak4114_in_bit_get(struct snd_kcontrol *kcontrol, 210 struct snd_ctl_elem_value *ucontrol) 211 { 212 struct ak4114 *chip = snd_kcontrol_chip(kcontrol); 213 unsigned char reg = kcontrol->private_value & 0xff; 214 unsigned char bit = (kcontrol->private_value >> 8) & 0xff; 215 unsigned char inv = (kcontrol->private_value >> 31) & 1; 216 217 ucontrol->value.integer.value[0] = ((reg_read(chip, reg) & (1 << bit)) ? 1 : 0) ^ inv; 218 return 0; 219 } 220 221 static int snd_ak4114_rate_info(struct snd_kcontrol *kcontrol, 222 struct snd_ctl_elem_info *uinfo) 223 { 224 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 225 uinfo->count = 1; 226 uinfo->value.integer.min = 0; 227 uinfo->value.integer.max = 192000; 228 return 0; 229 } 230 231 static int snd_ak4114_rate_get(struct snd_kcontrol *kcontrol, 232 struct snd_ctl_elem_value *ucontrol) 233 { 234 struct ak4114 *chip = snd_kcontrol_chip(kcontrol); 235 236 ucontrol->value.integer.value[0] = external_rate(reg_read(chip, AK4114_REG_RCS1)); 237 return 0; 238 } 239 240 static int snd_ak4114_spdif_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 241 { 242 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; 243 uinfo->count = 1; 244 return 0; 245 } 246 247 static int snd_ak4114_spdif_get(struct snd_kcontrol *kcontrol, 248 struct snd_ctl_elem_value *ucontrol) 249 { 250 struct ak4114 *chip = snd_kcontrol_chip(kcontrol); 251 unsigned i; 252 253 for (i = 0; i < AK4114_REG_RXCSB_SIZE; i++) 254 ucontrol->value.iec958.status[i] = reg_read(chip, AK4114_REG_RXCSB0 + i); 255 return 0; 256 } 257 258 static int snd_ak4114_spdif_playback_get(struct snd_kcontrol *kcontrol, 259 struct snd_ctl_elem_value *ucontrol) 260 { 261 struct ak4114 *chip = snd_kcontrol_chip(kcontrol); 262 unsigned i; 263 264 for (i = 0; i < AK4114_REG_TXCSB_SIZE; i++) 265 ucontrol->value.iec958.status[i] = chip->txcsb[i]; 266 return 0; 267 } 268 269 static int snd_ak4114_spdif_playback_put(struct snd_kcontrol *kcontrol, 270 struct snd_ctl_elem_value *ucontrol) 271 { 272 struct ak4114 *chip = snd_kcontrol_chip(kcontrol); 273 unsigned i; 274 275 for (i = 0; i < AK4114_REG_TXCSB_SIZE; i++) 276 reg_write(chip, AK4114_REG_TXCSB0 + i, ucontrol->value.iec958.status[i]); 277 return 0; 278 } 279 280 static int snd_ak4114_spdif_mask_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 281 { 282 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; 283 uinfo->count = 1; 284 return 0; 285 } 286 287 static int snd_ak4114_spdif_mask_get(struct snd_kcontrol *kcontrol, 288 struct snd_ctl_elem_value *ucontrol) 289 { 290 memset(ucontrol->value.iec958.status, 0xff, AK4114_REG_RXCSB_SIZE); 291 return 0; 292 } 293 294 static int snd_ak4114_spdif_pinfo(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 295 { 296 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 297 uinfo->value.integer.min = 0; 298 uinfo->value.integer.max = 0xffff; 299 uinfo->count = 4; 300 return 0; 301 } 302 303 static int snd_ak4114_spdif_pget(struct snd_kcontrol *kcontrol, 304 struct snd_ctl_elem_value *ucontrol) 305 { 306 struct ak4114 *chip = snd_kcontrol_chip(kcontrol); 307 unsigned short tmp; 308 309 ucontrol->value.integer.value[0] = 0xf8f2; 310 ucontrol->value.integer.value[1] = 0x4e1f; 311 tmp = reg_read(chip, AK4114_REG_Pc0) | (reg_read(chip, AK4114_REG_Pc1) << 8); 312 ucontrol->value.integer.value[2] = tmp; 313 tmp = reg_read(chip, AK4114_REG_Pd0) | (reg_read(chip, AK4114_REG_Pd1) << 8); 314 ucontrol->value.integer.value[3] = tmp; 315 return 0; 316 } 317 318 static int snd_ak4114_spdif_qinfo(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 319 { 320 uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES; 321 uinfo->count = AK4114_REG_QSUB_SIZE; 322 return 0; 323 } 324 325 static int snd_ak4114_spdif_qget(struct snd_kcontrol *kcontrol, 326 struct snd_ctl_elem_value *ucontrol) 327 { 328 struct ak4114 *chip = snd_kcontrol_chip(kcontrol); 329 unsigned i; 330 331 for (i = 0; i < AK4114_REG_QSUB_SIZE; i++) 332 ucontrol->value.bytes.data[i] = reg_read(chip, AK4114_REG_QSUB_ADDR + i); 333 return 0; 334 } 335 336 /* Don't forget to change AK4114_CONTROLS define!!! */ 337 static struct snd_kcontrol_new snd_ak4114_iec958_controls[] = { 338 { 339 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 340 .name = "IEC958 Parity Errors", 341 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 342 .info = snd_ak4114_in_error_info, 343 .get = snd_ak4114_in_error_get, 344 .private_value = offsetof(struct ak4114, parity_errors), 345 }, 346 { 347 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 348 .name = "IEC958 V-Bit Errors", 349 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 350 .info = snd_ak4114_in_error_info, 351 .get = snd_ak4114_in_error_get, 352 .private_value = offsetof(struct ak4114, v_bit_errors), 353 }, 354 { 355 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 356 .name = "IEC958 C-CRC Errors", 357 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 358 .info = snd_ak4114_in_error_info, 359 .get = snd_ak4114_in_error_get, 360 .private_value = offsetof(struct ak4114, ccrc_errors), 361 }, 362 { 363 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 364 .name = "IEC958 Q-CRC Errors", 365 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 366 .info = snd_ak4114_in_error_info, 367 .get = snd_ak4114_in_error_get, 368 .private_value = offsetof(struct ak4114, qcrc_errors), 369 }, 370 { 371 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 372 .name = "IEC958 External Rate", 373 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 374 .info = snd_ak4114_rate_info, 375 .get = snd_ak4114_rate_get, 376 }, 377 { 378 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 379 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK), 380 .access = SNDRV_CTL_ELEM_ACCESS_READ, 381 .info = snd_ak4114_spdif_mask_info, 382 .get = snd_ak4114_spdif_mask_get, 383 }, 384 { 385 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 386 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), 387 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 388 .info = snd_ak4114_spdif_info, 389 .get = snd_ak4114_spdif_playback_get, 390 .put = snd_ak4114_spdif_playback_put, 391 }, 392 { 393 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 394 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,MASK), 395 .access = SNDRV_CTL_ELEM_ACCESS_READ, 396 .info = snd_ak4114_spdif_mask_info, 397 .get = snd_ak4114_spdif_mask_get, 398 }, 399 { 400 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 401 .name = SNDRV_CTL_NAME_IEC958("",CAPTURE,DEFAULT), 402 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 403 .info = snd_ak4114_spdif_info, 404 .get = snd_ak4114_spdif_get, 405 }, 406 { 407 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 408 .name = "IEC958 Preamble Capture Default", 409 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 410 .info = snd_ak4114_spdif_pinfo, 411 .get = snd_ak4114_spdif_pget, 412 }, 413 { 414 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 415 .name = "IEC958 Q-subcode Capture Default", 416 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 417 .info = snd_ak4114_spdif_qinfo, 418 .get = snd_ak4114_spdif_qget, 419 }, 420 { 421 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 422 .name = "IEC958 Audio", 423 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 424 .info = snd_ak4114_in_bit_info, 425 .get = snd_ak4114_in_bit_get, 426 .private_value = (1<<31) | (1<<8) | AK4114_REG_RCS0, 427 }, 428 { 429 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 430 .name = "IEC958 Non-PCM Bitstream", 431 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 432 .info = snd_ak4114_in_bit_info, 433 .get = snd_ak4114_in_bit_get, 434 .private_value = (6<<8) | AK4114_REG_RCS0, 435 }, 436 { 437 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 438 .name = "IEC958 DTS Bitstream", 439 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 440 .info = snd_ak4114_in_bit_info, 441 .get = snd_ak4114_in_bit_get, 442 .private_value = (3<<8) | AK4114_REG_RCS0, 443 }, 444 { 445 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 446 .name = "IEC958 PPL Lock Status", 447 .access = SNDRV_CTL_ELEM_ACCESS_READ | SNDRV_CTL_ELEM_ACCESS_VOLATILE, 448 .info = snd_ak4114_in_bit_info, 449 .get = snd_ak4114_in_bit_get, 450 .private_value = (1<<31) | (4<<8) | AK4114_REG_RCS0, 451 } 452 }; 453 454 455 static void snd_ak4114_proc_regs_read(struct snd_info_entry *entry, 456 struct snd_info_buffer *buffer) 457 { 458 struct ak4114 *ak4114 = entry->private_data; 459 int reg, val; 460 /* all ak4114 registers 0x00 - 0x1f */ 461 for (reg = 0; reg < 0x20; reg++) { 462 val = reg_read(ak4114, reg); 463 snd_iprintf(buffer, "0x%02x = 0x%02x\n", reg, val); 464 } 465 } 466 467 static void snd_ak4114_proc_init(struct ak4114 *ak4114) 468 { 469 struct snd_info_entry *entry; 470 if (!snd_card_proc_new(ak4114->card, "ak4114", &entry)) 471 snd_info_set_text_ops(entry, ak4114, snd_ak4114_proc_regs_read); 472 } 473 474 int snd_ak4114_build(struct ak4114 *ak4114, 475 struct snd_pcm_substream *ply_substream, 476 struct snd_pcm_substream *cap_substream) 477 { 478 struct snd_kcontrol *kctl; 479 unsigned int idx; 480 int err; 481 482 if (snd_BUG_ON(!cap_substream)) 483 return -EINVAL; 484 ak4114->playback_substream = ply_substream; 485 ak4114->capture_substream = cap_substream; 486 for (idx = 0; idx < AK4114_CONTROLS; idx++) { 487 kctl = snd_ctl_new1(&snd_ak4114_iec958_controls[idx], ak4114); 488 if (kctl == NULL) 489 return -ENOMEM; 490 if (strstr(kctl->id.name, "Playback")) { 491 if (ply_substream == NULL) { 492 snd_ctl_free_one(kctl); 493 ak4114->kctls[idx] = NULL; 494 continue; 495 } 496 kctl->id.device = ply_substream->pcm->device; 497 kctl->id.subdevice = ply_substream->number; 498 } else { 499 kctl->id.device = cap_substream->pcm->device; 500 kctl->id.subdevice = cap_substream->number; 501 } 502 err = snd_ctl_add(ak4114->card, kctl); 503 if (err < 0) 504 return err; 505 ak4114->kctls[idx] = kctl; 506 } 507 snd_ak4114_proc_init(ak4114); 508 /* trigger workq */ 509 schedule_delayed_work(&ak4114->work, HZ / 10); 510 return 0; 511 } 512 EXPORT_SYMBOL(snd_ak4114_build); 513 514 /* notify kcontrols if any parameters are changed */ 515 static void ak4114_notify(struct ak4114 *ak4114, 516 unsigned char rcs0, unsigned char rcs1, 517 unsigned char c0, unsigned char c1) 518 { 519 if (!ak4114->kctls[0]) 520 return; 521 522 if (rcs0 & AK4114_PAR) 523 snd_ctl_notify(ak4114->card, SNDRV_CTL_EVENT_MASK_VALUE, 524 &ak4114->kctls[0]->id); 525 if (rcs0 & AK4114_V) 526 snd_ctl_notify(ak4114->card, SNDRV_CTL_EVENT_MASK_VALUE, 527 &ak4114->kctls[1]->id); 528 if (rcs1 & AK4114_CCRC) 529 snd_ctl_notify(ak4114->card, SNDRV_CTL_EVENT_MASK_VALUE, 530 &ak4114->kctls[2]->id); 531 if (rcs1 & AK4114_QCRC) 532 snd_ctl_notify(ak4114->card, SNDRV_CTL_EVENT_MASK_VALUE, 533 &ak4114->kctls[3]->id); 534 535 /* rate change */ 536 if (c1 & 0xf0) 537 snd_ctl_notify(ak4114->card, SNDRV_CTL_EVENT_MASK_VALUE, 538 &ak4114->kctls[4]->id); 539 540 if ((c0 & AK4114_PEM) | (c0 & AK4114_CINT)) 541 snd_ctl_notify(ak4114->card, SNDRV_CTL_EVENT_MASK_VALUE, 542 &ak4114->kctls[9]->id); 543 if (c0 & AK4114_QINT) 544 snd_ctl_notify(ak4114->card, SNDRV_CTL_EVENT_MASK_VALUE, 545 &ak4114->kctls[10]->id); 546 547 if (c0 & AK4114_AUDION) 548 snd_ctl_notify(ak4114->card, SNDRV_CTL_EVENT_MASK_VALUE, 549 &ak4114->kctls[11]->id); 550 if (c0 & AK4114_AUTO) 551 snd_ctl_notify(ak4114->card, SNDRV_CTL_EVENT_MASK_VALUE, 552 &ak4114->kctls[12]->id); 553 if (c0 & AK4114_DTSCD) 554 snd_ctl_notify(ak4114->card, SNDRV_CTL_EVENT_MASK_VALUE, 555 &ak4114->kctls[13]->id); 556 if (c0 & AK4114_UNLCK) 557 snd_ctl_notify(ak4114->card, SNDRV_CTL_EVENT_MASK_VALUE, 558 &ak4114->kctls[14]->id); 559 } 560 561 int snd_ak4114_external_rate(struct ak4114 *ak4114) 562 { 563 unsigned char rcs1; 564 565 rcs1 = reg_read(ak4114, AK4114_REG_RCS1); 566 return external_rate(rcs1); 567 } 568 EXPORT_SYMBOL(snd_ak4114_external_rate); 569 570 int snd_ak4114_check_rate_and_errors(struct ak4114 *ak4114, unsigned int flags) 571 { 572 struct snd_pcm_runtime *runtime = ak4114->capture_substream ? ak4114->capture_substream->runtime : NULL; 573 unsigned long _flags; 574 int res = 0; 575 unsigned char rcs0, rcs1; 576 unsigned char c0, c1; 577 578 rcs1 = reg_read(ak4114, AK4114_REG_RCS1); 579 if (flags & AK4114_CHECK_NO_STAT) 580 goto __rate; 581 rcs0 = reg_read(ak4114, AK4114_REG_RCS0); 582 spin_lock_irqsave(&ak4114->lock, _flags); 583 if (rcs0 & AK4114_PAR) 584 ak4114->parity_errors++; 585 if (rcs1 & AK4114_V) 586 ak4114->v_bit_errors++; 587 if (rcs1 & AK4114_CCRC) 588 ak4114->ccrc_errors++; 589 if (rcs1 & AK4114_QCRC) 590 ak4114->qcrc_errors++; 591 c0 = (ak4114->rcs0 & (AK4114_QINT | AK4114_CINT | AK4114_PEM | AK4114_AUDION | AK4114_AUTO | AK4114_UNLCK)) ^ 592 (rcs0 & (AK4114_QINT | AK4114_CINT | AK4114_PEM | AK4114_AUDION | AK4114_AUTO | AK4114_UNLCK)); 593 c1 = (ak4114->rcs1 & 0xf0) ^ (rcs1 & 0xf0); 594 ak4114->rcs0 = rcs0 & ~(AK4114_QINT | AK4114_CINT); 595 ak4114->rcs1 = rcs1; 596 spin_unlock_irqrestore(&ak4114->lock, _flags); 597 598 ak4114_notify(ak4114, rcs0, rcs1, c0, c1); 599 if (ak4114->change_callback && (c0 | c1) != 0) 600 ak4114->change_callback(ak4114, c0, c1); 601 602 __rate: 603 /* compare rate */ 604 res = external_rate(rcs1); 605 if (!(flags & AK4114_CHECK_NO_RATE) && runtime && runtime->rate != res) { 606 snd_pcm_stream_lock_irqsave(ak4114->capture_substream, _flags); 607 if (snd_pcm_running(ak4114->capture_substream)) { 608 // printk(KERN_DEBUG "rate changed (%i <- %i)\n", runtime->rate, res); 609 snd_pcm_stop(ak4114->capture_substream, SNDRV_PCM_STATE_DRAINING); 610 res = 1; 611 } 612 snd_pcm_stream_unlock_irqrestore(ak4114->capture_substream, _flags); 613 } 614 return res; 615 } 616 EXPORT_SYMBOL(snd_ak4114_check_rate_and_errors); 617 618 static void ak4114_stats(struct work_struct *work) 619 { 620 struct ak4114 *chip = container_of(work, struct ak4114, work.work); 621 622 if (atomic_inc_return(&chip->wq_processing) == 1) 623 snd_ak4114_check_rate_and_errors(chip, chip->check_flags); 624 if (atomic_dec_and_test(&chip->wq_processing)) 625 schedule_delayed_work(&chip->work, HZ / 10); 626 } 627 628 #ifdef CONFIG_PM 629 void snd_ak4114_suspend(struct ak4114 *chip) 630 { 631 atomic_inc(&chip->wq_processing); /* don't schedule new work */ 632 cancel_delayed_work_sync(&chip->work); 633 } 634 EXPORT_SYMBOL(snd_ak4114_suspend); 635 636 void snd_ak4114_resume(struct ak4114 *chip) 637 { 638 atomic_dec(&chip->wq_processing); 639 snd_ak4114_reinit(chip); 640 } 641 EXPORT_SYMBOL(snd_ak4114_resume); 642 #endif 643