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