1/* 2 * Routines for control of the CS8427 via i2c bus 3 * IEC958 (S/PDIF) receiver & transmitter by Cirrus Logic 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/init.h> 26#include <linux/bitrev.h> 27#include <asm/unaligned.h> 28#include <sound/core.h> 29#include <sound/control.h> 30#include <sound/pcm.h> 31#include <sound/cs8427.h> 32#include <sound/asoundef.h> 33 34static void snd_cs8427_reset(struct snd_i2c_device *cs8427); 35 36MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>"); 37MODULE_DESCRIPTION("IEC958 (S/PDIF) receiver & transmitter by Cirrus Logic"); 38MODULE_LICENSE("GPL"); 39 40#define CS8427_ADDR (0x20>>1) /* fixed address */ 41 42struct cs8427_stream { 43 struct snd_pcm_substream *substream; 44 char hw_status[24]; /* hardware status */ 45 char def_status[24]; /* default status */ 46 char pcm_status[24]; /* PCM private status */ 47 char hw_udata[32]; 48 struct snd_kcontrol *pcm_ctl; 49}; 50 51struct cs8427 { 52 unsigned char regmap[0x14]; /* map of first 1 + 13 registers */ 53 unsigned int rate; 54 unsigned int reset_timeout; 55 struct cs8427_stream playback; 56 struct cs8427_stream capture; 57}; 58 59int snd_cs8427_reg_write(struct snd_i2c_device *device, unsigned char reg, 60 unsigned char val) 61{ 62 int err; 63 unsigned char buf[2]; 64 65 buf[0] = reg & 0x7f; 66 buf[1] = val; 67 if ((err = snd_i2c_sendbytes(device, buf, 2)) != 2) { 68 snd_printk(KERN_ERR "unable to send bytes 0x%02x:0x%02x " 69 "to CS8427 (%i)\n", buf[0], buf[1], err); 70 return err < 0 ? err : -EIO; 71 } 72 return 0; 73} 74 75EXPORT_SYMBOL(snd_cs8427_reg_write); 76 77static int snd_cs8427_reg_read(struct snd_i2c_device *device, unsigned char reg) 78{ 79 int err; 80 unsigned char buf; 81 82 if ((err = snd_i2c_sendbytes(device, ®, 1)) != 1) { 83 snd_printk(KERN_ERR "unable to send register 0x%x byte " 84 "to CS8427\n", reg); 85 return err < 0 ? err : -EIO; 86 } 87 if ((err = snd_i2c_readbytes(device, &buf, 1)) != 1) { 88 snd_printk(KERN_ERR "unable to read register 0x%x byte " 89 "from CS8427\n", reg); 90 return err < 0 ? err : -EIO; 91 } 92 return buf; 93} 94 95static int snd_cs8427_select_corudata(struct snd_i2c_device *device, int udata) 96{ 97 struct cs8427 *chip = device->private_data; 98 int err; 99 100 udata = udata ? CS8427_BSEL : 0; 101 if (udata != (chip->regmap[CS8427_REG_CSDATABUF] & udata)) { 102 chip->regmap[CS8427_REG_CSDATABUF] &= ~CS8427_BSEL; 103 chip->regmap[CS8427_REG_CSDATABUF] |= udata; 104 err = snd_cs8427_reg_write(device, CS8427_REG_CSDATABUF, 105 chip->regmap[CS8427_REG_CSDATABUF]); 106 if (err < 0) 107 return err; 108 } 109 return 0; 110} 111 112static int snd_cs8427_send_corudata(struct snd_i2c_device *device, 113 int udata, 114 unsigned char *ndata, 115 int count) 116{ 117 struct cs8427 *chip = device->private_data; 118 char *hw_data = udata ? 119 chip->playback.hw_udata : chip->playback.hw_status; 120 char data[32]; 121 int err, idx; 122 123 if (!memcmp(hw_data, ndata, count)) 124 return 0; 125 if ((err = snd_cs8427_select_corudata(device, udata)) < 0) 126 return err; 127 memcpy(hw_data, ndata, count); 128 if (udata) { 129 memset(data, 0, sizeof(data)); 130 if (memcmp(hw_data, data, count) == 0) { 131 chip->regmap[CS8427_REG_UDATABUF] &= ~CS8427_UBMMASK; 132 chip->regmap[CS8427_REG_UDATABUF] |= CS8427_UBMZEROS | 133 CS8427_EFTUI; 134 err = snd_cs8427_reg_write(device, CS8427_REG_UDATABUF, 135 chip->regmap[CS8427_REG_UDATABUF]); 136 return err < 0 ? err : 0; 137 } 138 } 139 data[0] = CS8427_REG_AUTOINC | CS8427_REG_CORU_DATABUF; 140 for (idx = 0; idx < count; idx++) 141 data[idx + 1] = bitrev8(ndata[idx]); 142 if (snd_i2c_sendbytes(device, data, count + 1) != count + 1) 143 return -EIO; 144 return 1; 145} 146 147static void snd_cs8427_free(struct snd_i2c_device *device) 148{ 149 kfree(device->private_data); 150} 151 152int snd_cs8427_create(struct snd_i2c_bus *bus, 153 unsigned char addr, 154 unsigned int reset_timeout, 155 struct snd_i2c_device **r_cs8427) 156{ 157 static unsigned char initvals1[] = { 158 CS8427_REG_CONTROL1 | CS8427_REG_AUTOINC, 159 /* CS8427_REG_CONTROL1: RMCK to OMCK, valid PCM audio, disable mutes, 160 TCBL=output */ 161 CS8427_SWCLK | CS8427_TCBLDIR, 162 /* CS8427_REG_CONTROL2: hold last valid audio sample, RMCK=256*Fs, 163 normal stereo operation */ 164 0x00, 165 /* CS8427_REG_DATAFLOW: output drivers normal operation, Tx<=serial, 166 Rx=>serial */ 167 CS8427_TXDSERIAL | CS8427_SPDAES3RECEIVER, 168 CS8427_RXDILRCK, 169 /* CS8427_REG_SERIALINPUT: Serial audio input port data format = I2S, 170 24-bit, 64*Fsi */ 171 CS8427_SIDEL | CS8427_SILRPOL, 172 /* CS8427_REG_SERIALOUTPUT: Serial audio output port data format 173 = I2S, 24-bit, 64*Fsi */ 174 CS8427_SODEL | CS8427_SOLRPOL, 175 }; 176 static unsigned char initvals2[] = { 177 CS8427_REG_RECVERRMASK | CS8427_REG_AUTOINC, 178 /* CS8427_REG_RECVERRMASK: unmask the input PLL clock, V, confidence, 179 biphase, parity status bits */ 180 /* CS8427_UNLOCK | CS8427_V | CS8427_CONF | CS8427_BIP | CS8427_PAR,*/ 181 0xff, /* set everything */ 182 /* CS8427_REG_CSDATABUF: 183 Registers 32-55 window to CS buffer 184 Inhibit D->E transfers from overwriting first 5 bytes of CS data. 185 Inhibit D->E transfers (all) of CS data. 186 Allow E->F transfer of CS data. 187 One byte mode; both A/B channels get same written CB data. 188 A channel info is output to chip's EMPH* pin. */ 189 CS8427_CBMR | CS8427_DETCI, 190 /* CS8427_REG_UDATABUF: 191 Use internal buffer to transmit User (U) data. 192 Chip's U pin is an output. 193 Transmit all O's for user data. 194 Inhibit D->E transfers. 195 Inhibit E->F transfers. */ 196 CS8427_UD | CS8427_EFTUI | CS8427_DETUI, 197 }; 198 int err; 199 struct cs8427 *chip; 200 struct snd_i2c_device *device; 201 unsigned char buf[24]; 202 203 if ((err = snd_i2c_device_create(bus, "CS8427", 204 CS8427_ADDR | (addr & 7), 205 &device)) < 0) 206 return err; 207 chip = device->private_data = kzalloc(sizeof(*chip), GFP_KERNEL); 208 if (chip == NULL) { 209 snd_i2c_device_free(device); 210 return -ENOMEM; 211 } 212 device->private_free = snd_cs8427_free; 213 214 snd_i2c_lock(bus); 215 err = snd_cs8427_reg_read(device, CS8427_REG_ID_AND_VER); 216 if (err != CS8427_VER8427A) { 217 /* give second chance */ 218 snd_printk(KERN_WARNING "invalid CS8427 signature 0x%x: " 219 "let me try again...\n", err); 220 err = snd_cs8427_reg_read(device, CS8427_REG_ID_AND_VER); 221 } 222 if (err != CS8427_VER8427A) { 223 snd_i2c_unlock(bus); 224 snd_printk(KERN_ERR "unable to find CS8427 signature " 225 "(expected 0x%x, read 0x%x),\n", 226 CS8427_VER8427A, err); 227 snd_printk(KERN_ERR " initialization is not completed\n"); 228 return -EFAULT; 229 } 230 /* turn off run bit while making changes to configuration */ 231 err = snd_cs8427_reg_write(device, CS8427_REG_CLOCKSOURCE, 0x00); 232 if (err < 0) 233 goto __fail; 234 /* send initial values */ 235 memcpy(chip->regmap + (initvals1[0] & 0x7f), initvals1 + 1, 6); 236 if ((err = snd_i2c_sendbytes(device, initvals1, 7)) != 7) { 237 err = err < 0 ? err : -EIO; 238 goto __fail; 239 } 240 /* Turn off CS8427 interrupt stuff that is not used in hardware */ 241 memset(buf, 0, 7); 242 /* from address 9 to 15 */ 243 buf[0] = 9; /* register */ 244 if ((err = snd_i2c_sendbytes(device, buf, 7)) != 7) 245 goto __fail; 246 /* send transfer initialization sequence */ 247 memcpy(chip->regmap + (initvals2[0] & 0x7f), initvals2 + 1, 3); 248 if ((err = snd_i2c_sendbytes(device, initvals2, 4)) != 4) { 249 err = err < 0 ? err : -EIO; 250 goto __fail; 251 } 252 /* write default channel status bytes */ 253 put_unaligned_le32(SNDRV_PCM_DEFAULT_CON_SPDIF, buf); 254 memset(buf + 4, 0, 24 - 4); 255 if (snd_cs8427_send_corudata(device, 0, buf, 24) < 0) 256 goto __fail; 257 memcpy(chip->playback.def_status, buf, 24); 258 memcpy(chip->playback.pcm_status, buf, 24); 259 snd_i2c_unlock(bus); 260 261 /* turn on run bit and rock'n'roll */ 262 if (reset_timeout < 1) 263 reset_timeout = 1; 264 chip->reset_timeout = reset_timeout; 265 snd_cs8427_reset(device); 266 267 268 if (r_cs8427) 269 *r_cs8427 = device; 270 return 0; 271 272 __fail: 273 snd_i2c_unlock(bus); 274 snd_i2c_device_free(device); 275 return err < 0 ? err : -EIO; 276} 277 278EXPORT_SYMBOL(snd_cs8427_create); 279 280static void snd_cs8427_reset(struct snd_i2c_device *cs8427) 281{ 282 struct cs8427 *chip; 283 unsigned long end_time; 284 int data, aes3input = 0; 285 286 if (snd_BUG_ON(!cs8427)) 287 return; 288 chip = cs8427->private_data; 289 snd_i2c_lock(cs8427->bus); 290 if ((chip->regmap[CS8427_REG_CLOCKSOURCE] & CS8427_RXDAES3INPUT) == 291 CS8427_RXDAES3INPUT) /* AES3 bit is set */ 292 aes3input = 1; 293 chip->regmap[CS8427_REG_CLOCKSOURCE] &= ~(CS8427_RUN | CS8427_RXDMASK); 294 snd_cs8427_reg_write(cs8427, CS8427_REG_CLOCKSOURCE, 295 chip->regmap[CS8427_REG_CLOCKSOURCE]); 296 udelay(200); 297 chip->regmap[CS8427_REG_CLOCKSOURCE] |= CS8427_RUN | CS8427_RXDILRCK; 298 snd_cs8427_reg_write(cs8427, CS8427_REG_CLOCKSOURCE, 299 chip->regmap[CS8427_REG_CLOCKSOURCE]); 300 udelay(200); 301 snd_i2c_unlock(cs8427->bus); 302 end_time = jiffies + chip->reset_timeout; 303 while (time_after_eq(end_time, jiffies)) { 304 snd_i2c_lock(cs8427->bus); 305 data = snd_cs8427_reg_read(cs8427, CS8427_REG_RECVERRORS); 306 snd_i2c_unlock(cs8427->bus); 307 if (!(data & CS8427_UNLOCK)) 308 break; 309 schedule_timeout_uninterruptible(1); 310 } 311 snd_i2c_lock(cs8427->bus); 312 chip->regmap[CS8427_REG_CLOCKSOURCE] &= ~CS8427_RXDMASK; 313 if (aes3input) 314 chip->regmap[CS8427_REG_CLOCKSOURCE] |= CS8427_RXDAES3INPUT; 315 snd_cs8427_reg_write(cs8427, CS8427_REG_CLOCKSOURCE, 316 chip->regmap[CS8427_REG_CLOCKSOURCE]); 317 snd_i2c_unlock(cs8427->bus); 318} 319 320static int snd_cs8427_in_status_info(struct snd_kcontrol *kcontrol, 321 struct snd_ctl_elem_info *uinfo) 322{ 323 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 324 uinfo->count = 1; 325 uinfo->value.integer.min = 0; 326 uinfo->value.integer.max = 255; 327 return 0; 328} 329 330static int snd_cs8427_in_status_get(struct snd_kcontrol *kcontrol, 331 struct snd_ctl_elem_value *ucontrol) 332{ 333 struct snd_i2c_device *device = snd_kcontrol_chip(kcontrol); 334 int data; 335 336 snd_i2c_lock(device->bus); 337 data = snd_cs8427_reg_read(device, kcontrol->private_value); 338 snd_i2c_unlock(device->bus); 339 if (data < 0) 340 return data; 341 ucontrol->value.integer.value[0] = data; 342 return 0; 343} 344 345static int snd_cs8427_qsubcode_info(struct snd_kcontrol *kcontrol, 346 struct snd_ctl_elem_info *uinfo) 347{ 348 uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES; 349 uinfo->count = 10; 350 return 0; 351} 352 353static int snd_cs8427_qsubcode_get(struct snd_kcontrol *kcontrol, 354 struct snd_ctl_elem_value *ucontrol) 355{ 356 struct snd_i2c_device *device = snd_kcontrol_chip(kcontrol); 357 unsigned char reg = CS8427_REG_QSUBCODE; 358 int err; 359 360 snd_i2c_lock(device->bus); 361 if ((err = snd_i2c_sendbytes(device, ®, 1)) != 1) { 362 snd_printk(KERN_ERR "unable to send register 0x%x byte " 363 "to CS8427\n", reg); 364 snd_i2c_unlock(device->bus); 365 return err < 0 ? err : -EIO; 366 } 367 err = snd_i2c_readbytes(device, ucontrol->value.bytes.data, 10); 368 if (err != 10) { 369 snd_printk(KERN_ERR "unable to read Q-subcode bytes " 370 "from CS8427\n"); 371 snd_i2c_unlock(device->bus); 372 return err < 0 ? err : -EIO; 373 } 374 snd_i2c_unlock(device->bus); 375 return 0; 376} 377 378static int snd_cs8427_spdif_info(struct snd_kcontrol *kcontrol, 379 struct snd_ctl_elem_info *uinfo) 380{ 381 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; 382 uinfo->count = 1; 383 return 0; 384} 385 386static int snd_cs8427_spdif_get(struct snd_kcontrol *kcontrol, 387 struct snd_ctl_elem_value *ucontrol) 388{ 389 struct snd_i2c_device *device = snd_kcontrol_chip(kcontrol); 390 struct cs8427 *chip = device->private_data; 391 392 snd_i2c_lock(device->bus); 393 memcpy(ucontrol->value.iec958.status, chip->playback.def_status, 24); 394 snd_i2c_unlock(device->bus); 395 return 0; 396} 397 398static int snd_cs8427_spdif_put(struct snd_kcontrol *kcontrol, 399 struct snd_ctl_elem_value *ucontrol) 400{ 401 struct snd_i2c_device *device = snd_kcontrol_chip(kcontrol); 402 struct cs8427 *chip = device->private_data; 403 unsigned char *status = kcontrol->private_value ? 404 chip->playback.pcm_status : chip->playback.def_status; 405 struct snd_pcm_runtime *runtime = chip->playback.substream ? 406 chip->playback.substream->runtime : NULL; 407 int err, change; 408 409 snd_i2c_lock(device->bus); 410 change = memcmp(ucontrol->value.iec958.status, status, 24) != 0; 411 memcpy(status, ucontrol->value.iec958.status, 24); 412 if (change && (kcontrol->private_value ? 413 runtime != NULL : runtime == NULL)) { 414 err = snd_cs8427_send_corudata(device, 0, status, 24); 415 if (err < 0) 416 change = err; 417 } 418 snd_i2c_unlock(device->bus); 419 return change; 420} 421 422static int snd_cs8427_spdif_mask_info(struct snd_kcontrol *kcontrol, 423 struct snd_ctl_elem_info *uinfo) 424{ 425 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958; 426 uinfo->count = 1; 427 return 0; 428} 429 430static int snd_cs8427_spdif_mask_get(struct snd_kcontrol *kcontrol, 431 struct snd_ctl_elem_value *ucontrol) 432{ 433 memset(ucontrol->value.iec958.status, 0xff, 24); 434 return 0; 435} 436 437static struct snd_kcontrol_new snd_cs8427_iec958_controls[] = { 438{ 439 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 440 .info = snd_cs8427_in_status_info, 441 .name = "IEC958 CS8427 Input Status", 442 .access = (SNDRV_CTL_ELEM_ACCESS_READ | 443 SNDRV_CTL_ELEM_ACCESS_VOLATILE), 444 .get = snd_cs8427_in_status_get, 445 .private_value = 15, 446}, 447{ 448 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 449 .info = snd_cs8427_in_status_info, 450 .name = "IEC958 CS8427 Error Status", 451 .access = (SNDRV_CTL_ELEM_ACCESS_READ | 452 SNDRV_CTL_ELEM_ACCESS_VOLATILE), 453 .get = snd_cs8427_in_status_get, 454 .private_value = 16, 455}, 456{ 457 .access = SNDRV_CTL_ELEM_ACCESS_READ, 458 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 459 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK), 460 .info = snd_cs8427_spdif_mask_info, 461 .get = snd_cs8427_spdif_mask_get, 462}, 463{ 464 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 465 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT), 466 .info = snd_cs8427_spdif_info, 467 .get = snd_cs8427_spdif_get, 468 .put = snd_cs8427_spdif_put, 469 .private_value = 0 470}, 471{ 472 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | 473 SNDRV_CTL_ELEM_ACCESS_INACTIVE), 474 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 475 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM), 476 .info = snd_cs8427_spdif_info, 477 .get = snd_cs8427_spdif_get, 478 .put = snd_cs8427_spdif_put, 479 .private_value = 1 480}, 481{ 482 .iface = SNDRV_CTL_ELEM_IFACE_PCM, 483 .info = snd_cs8427_qsubcode_info, 484 .name = "IEC958 Q-subcode Capture Default", 485 .access = (SNDRV_CTL_ELEM_ACCESS_READ | 486 SNDRV_CTL_ELEM_ACCESS_VOLATILE), 487 .get = snd_cs8427_qsubcode_get 488}}; 489 490int snd_cs8427_iec958_build(struct snd_i2c_device *cs8427, 491 struct snd_pcm_substream *play_substream, 492 struct snd_pcm_substream *cap_substream) 493{ 494 struct cs8427 *chip = cs8427->private_data; 495 struct snd_kcontrol *kctl; 496 unsigned int idx; 497 int err; 498 499 if (snd_BUG_ON(!play_substream || !cap_substream)) 500 return -EINVAL; 501 for (idx = 0; idx < ARRAY_SIZE(snd_cs8427_iec958_controls); idx++) { 502 kctl = snd_ctl_new1(&snd_cs8427_iec958_controls[idx], cs8427); 503 if (kctl == NULL) 504 return -ENOMEM; 505 kctl->id.device = play_substream->pcm->device; 506 kctl->id.subdevice = play_substream->number; 507 err = snd_ctl_add(cs8427->bus->card, kctl); 508 if (err < 0) 509 return err; 510 if (! strcmp(kctl->id.name, 511 SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM))) 512 chip->playback.pcm_ctl = kctl; 513 } 514 515 chip->playback.substream = play_substream; 516 chip->capture.substream = cap_substream; 517 if (snd_BUG_ON(!chip->playback.pcm_ctl)) 518 return -EIO; 519 return 0; 520} 521 522EXPORT_SYMBOL(snd_cs8427_iec958_build); 523 524int snd_cs8427_iec958_active(struct snd_i2c_device *cs8427, int active) 525{ 526 struct cs8427 *chip; 527 528 if (snd_BUG_ON(!cs8427)) 529 return -ENXIO; 530 chip = cs8427->private_data; 531 if (active) 532 memcpy(chip->playback.pcm_status, 533 chip->playback.def_status, 24); 534 chip->playback.pcm_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE; 535 snd_ctl_notify(cs8427->bus->card, 536 SNDRV_CTL_EVENT_MASK_VALUE | SNDRV_CTL_EVENT_MASK_INFO, 537 &chip->playback.pcm_ctl->id); 538 return 0; 539} 540 541EXPORT_SYMBOL(snd_cs8427_iec958_active); 542 543int snd_cs8427_iec958_pcm(struct snd_i2c_device *cs8427, unsigned int rate) 544{ 545 struct cs8427 *chip; 546 char *status; 547 int err, reset; 548 549 if (snd_BUG_ON(!cs8427)) 550 return -ENXIO; 551 chip = cs8427->private_data; 552 status = chip->playback.pcm_status; 553 snd_i2c_lock(cs8427->bus); 554 if (status[0] & IEC958_AES0_PROFESSIONAL) { 555 status[0] &= ~IEC958_AES0_PRO_FS; 556 switch (rate) { 557 case 32000: status[0] |= IEC958_AES0_PRO_FS_32000; break; 558 case 44100: status[0] |= IEC958_AES0_PRO_FS_44100; break; 559 case 48000: status[0] |= IEC958_AES0_PRO_FS_48000; break; 560 default: status[0] |= IEC958_AES0_PRO_FS_NOTID; break; 561 } 562 } else { 563 status[3] &= ~IEC958_AES3_CON_FS; 564 switch (rate) { 565 case 32000: status[3] |= IEC958_AES3_CON_FS_32000; break; 566 case 44100: status[3] |= IEC958_AES3_CON_FS_44100; break; 567 case 48000: status[3] |= IEC958_AES3_CON_FS_48000; break; 568 } 569 } 570 err = snd_cs8427_send_corudata(cs8427, 0, status, 24); 571 if (err > 0) 572 snd_ctl_notify(cs8427->bus->card, 573 SNDRV_CTL_EVENT_MASK_VALUE, 574 &chip->playback.pcm_ctl->id); 575 reset = chip->rate != rate; 576 chip->rate = rate; 577 snd_i2c_unlock(cs8427->bus); 578 if (reset) 579 snd_cs8427_reset(cs8427); 580 return err < 0 ? err : 0; 581} 582 583EXPORT_SYMBOL(snd_cs8427_iec958_pcm); 584 585static int __init alsa_cs8427_module_init(void) 586{ 587 return 0; 588} 589 590static void __exit alsa_cs8427_module_exit(void) 591{ 592} 593 594module_init(alsa_cs8427_module_init) 595module_exit(alsa_cs8427_module_exit) 596