1 /* 2 * CS4270 ALSA SoC (ASoC) codec driver 3 * 4 * Author: Timur Tabi <timur@freescale.com> 5 * 6 * Copyright 2007 Freescale Semiconductor, Inc. This file is licensed under 7 * the terms of the GNU General Public License version 2. This program 8 * is licensed "as is" without any warranty of any kind, whether express 9 * or implied. 10 * 11 * This is an ASoC device driver for the Cirrus Logic CS4270 codec. 12 * 13 * Current features/limitations: 14 * 15 * 1) Software mode is supported. Stand-alone mode is automatically 16 * selected if I2C is disabled or if a CS4270 is not found on the I2C 17 * bus. However, stand-alone mode is only partially implemented because 18 * there is no mechanism yet for this driver and the machine driver to 19 * communicate the values of the M0, M1, MCLK1, and MCLK2 pins. 20 * 2) Only I2C is supported, not SPI 21 * 3) Only Master mode is supported, not Slave. 22 * 4) The machine driver's 'startup' function must call 23 * cs4270_set_dai_sysclk() with the value of MCLK. 24 * 5) Only I2S and left-justified modes are supported 25 * 6) Power management is not supported 26 * 7) The only supported control is volume and hardware mute (if enabled) 27 */ 28 29 #include <linux/module.h> 30 #include <linux/platform_device.h> 31 #include <sound/core.h> 32 #include <sound/soc.h> 33 #include <sound/initval.h> 34 #include <linux/i2c.h> 35 36 #include "cs4270.h" 37 38 /* If I2C is defined, then we support software mode. However, if we're 39 not compiled as module but I2C is, then we can't use I2C calls. */ 40 #if defined(CONFIG_I2C) || (defined(CONFIG_I2C_MODULE) && defined(MODULE)) 41 #define USE_I2C 42 #endif 43 44 /* Private data for the CS4270 */ 45 struct cs4270_private { 46 unsigned int mclk; /* Input frequency of the MCLK pin */ 47 unsigned int mode; /* The mode (I2S or left-justified) */ 48 }; 49 50 /* 51 * The codec isn't really big-endian or little-endian, since the I2S 52 * interface requires data to be sent serially with the MSbit first. 53 * However, to support BE and LE I2S devices, we specify both here. That 54 * way, ALSA will always match the bit patterns. 55 */ 56 #define CS4270_FORMATS (SNDRV_PCM_FMTBIT_S8 | \ 57 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE | \ 58 SNDRV_PCM_FMTBIT_S18_3LE | SNDRV_PCM_FMTBIT_S18_3BE | \ 59 SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S20_3BE | \ 60 SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_S24_3BE | \ 61 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S24_BE) 62 63 #ifdef USE_I2C 64 65 /* CS4270 registers addresses */ 66 #define CS4270_CHIPID 0x01 /* Chip ID */ 67 #define CS4270_PWRCTL 0x02 /* Power Control */ 68 #define CS4270_MODE 0x03 /* Mode Control */ 69 #define CS4270_FORMAT 0x04 /* Serial Format, ADC/DAC Control */ 70 #define CS4270_TRANS 0x05 /* Transition Control */ 71 #define CS4270_MUTE 0x06 /* Mute Control */ 72 #define CS4270_VOLA 0x07 /* DAC Channel A Volume Control */ 73 #define CS4270_VOLB 0x08 /* DAC Channel B Volume Control */ 74 75 #define CS4270_FIRSTREG 0x01 76 #define CS4270_LASTREG 0x08 77 #define CS4270_NUMREGS (CS4270_LASTREG - CS4270_FIRSTREG + 1) 78 79 /* Bit masks for the CS4270 registers */ 80 #define CS4270_CHIPID_ID 0xF0 81 #define CS4270_CHIPID_REV 0x0F 82 #define CS4270_PWRCTL_FREEZE 0x80 83 #define CS4270_PWRCTL_PDN_ADC 0x20 84 #define CS4270_PWRCTL_PDN_DAC 0x02 85 #define CS4270_PWRCTL_PDN 0x01 86 #define CS4270_MODE_SPEED_MASK 0x30 87 #define CS4270_MODE_1X 0x00 88 #define CS4270_MODE_2X 0x10 89 #define CS4270_MODE_4X 0x20 90 #define CS4270_MODE_SLAVE 0x30 91 #define CS4270_MODE_DIV_MASK 0x0E 92 #define CS4270_MODE_DIV1 0x00 93 #define CS4270_MODE_DIV15 0x02 94 #define CS4270_MODE_DIV2 0x04 95 #define CS4270_MODE_DIV3 0x06 96 #define CS4270_MODE_DIV4 0x08 97 #define CS4270_MODE_POPGUARD 0x01 98 #define CS4270_FORMAT_FREEZE_A 0x80 99 #define CS4270_FORMAT_FREEZE_B 0x40 100 #define CS4270_FORMAT_LOOPBACK 0x20 101 #define CS4270_FORMAT_DAC_MASK 0x18 102 #define CS4270_FORMAT_DAC_LJ 0x00 103 #define CS4270_FORMAT_DAC_I2S 0x08 104 #define CS4270_FORMAT_DAC_RJ16 0x18 105 #define CS4270_FORMAT_DAC_RJ24 0x10 106 #define CS4270_FORMAT_ADC_MASK 0x01 107 #define CS4270_FORMAT_ADC_LJ 0x00 108 #define CS4270_FORMAT_ADC_I2S 0x01 109 #define CS4270_TRANS_ONE_VOL 0x80 110 #define CS4270_TRANS_SOFT 0x40 111 #define CS4270_TRANS_ZERO 0x20 112 #define CS4270_TRANS_INV_ADC_A 0x08 113 #define CS4270_TRANS_INV_ADC_B 0x10 114 #define CS4270_TRANS_INV_DAC_A 0x02 115 #define CS4270_TRANS_INV_DAC_B 0x04 116 #define CS4270_TRANS_DEEMPH 0x01 117 #define CS4270_MUTE_AUTO 0x20 118 #define CS4270_MUTE_ADC_A 0x08 119 #define CS4270_MUTE_ADC_B 0x10 120 #define CS4270_MUTE_POLARITY 0x04 121 #define CS4270_MUTE_DAC_A 0x01 122 #define CS4270_MUTE_DAC_B 0x02 123 124 /* 125 * Clock Ratio Selection for Master Mode with I2C enabled 126 * 127 * The data for this chart is taken from Table 5 of the CS4270 reference 128 * manual. 129 * 130 * This table is used to determine how to program the Mode Control register. 131 * It is also used by cs4270_set_dai_sysclk() to tell ALSA which sampling 132 * rates the CS4270 currently supports. 133 * 134 * Each element in this array corresponds to the ratios in mclk_ratios[]. 135 * These two arrays need to be in sync. 136 * 137 * 'speed_mode' is the corresponding bit pattern to be written to the 138 * MODE bits of the Mode Control Register 139 * 140 * 'mclk' is the corresponding bit pattern to be wirten to the MCLK bits of 141 * the Mode Control Register. 142 * 143 * In situations where a single ratio is represented by multiple speed 144 * modes, we favor the slowest speed. E.g, for a ratio of 128, we pick 145 * double-speed instead of quad-speed. However, the CS4270 errata states 146 * that Divide-By-1.5 can cause failures, so we avoid that mode where 147 * possible. 148 * 149 * ERRATA: There is an errata for the CS4270 where divide-by-1.5 does not 150 * work if VD = 3.3V. If this effects you, select the 151 * CONFIG_SND_SOC_CS4270_VD33_ERRATA Kconfig option, and the driver will 152 * never select any sample rates that require divide-by-1.5. 153 */ 154 static struct { 155 unsigned int ratio; 156 u8 speed_mode; 157 u8 mclk; 158 } cs4270_mode_ratios[] = { 159 {64, CS4270_MODE_4X, CS4270_MODE_DIV1}, 160 #ifndef CONFIG_SND_SOC_CS4270_VD33_ERRATA 161 {96, CS4270_MODE_4X, CS4270_MODE_DIV15}, 162 #endif 163 {128, CS4270_MODE_2X, CS4270_MODE_DIV1}, 164 {192, CS4270_MODE_4X, CS4270_MODE_DIV3}, 165 {256, CS4270_MODE_1X, CS4270_MODE_DIV1}, 166 {384, CS4270_MODE_2X, CS4270_MODE_DIV3}, 167 {512, CS4270_MODE_1X, CS4270_MODE_DIV2}, 168 {768, CS4270_MODE_1X, CS4270_MODE_DIV3}, 169 {1024, CS4270_MODE_1X, CS4270_MODE_DIV4} 170 }; 171 172 /* The number of MCLK/LRCK ratios supported by the CS4270 */ 173 #define NUM_MCLK_RATIOS ARRAY_SIZE(cs4270_mode_ratios) 174 175 /* 176 * Determine the CS4270 samples rates. 177 * 178 * 'freq' is the input frequency to MCLK. The other parameters are ignored. 179 * 180 * The value of MCLK is used to determine which sample rates are supported 181 * by the CS4270. The ratio of MCLK / Fs must be equal to one of nine 182 * support values: 64, 96, 128, 192, 256, 384, 512, 768, and 1024. 183 * 184 * This function calculates the nine ratios and determines which ones match 185 * a standard sample rate. If there's a match, then it is added to the list 186 * of support sample rates. 187 * 188 * This function must be called by the machine driver's 'startup' function, 189 * otherwise the list of supported sample rates will not be available in 190 * time for ALSA. 191 * 192 * Note that in stand-alone mode, the sample rate is determined by input 193 * pins M0, M1, MDIV1, and MDIV2. Also in stand-alone mode, divide-by-3 194 * is not a programmable option. However, divide-by-3 is not an available 195 * option in stand-alone mode. This cases two problems: a ratio of 768 is 196 * not available (it requires divide-by-3) and B) ratios 192 and 384 can 197 * only be selected with divide-by-1.5, but there is an errate that make 198 * this selection difficult. 199 * 200 * In addition, there is no mechanism for communicating with the machine 201 * driver what the input settings can be. This would need to be implemented 202 * for stand-alone mode to work. 203 */ 204 static int cs4270_set_dai_sysclk(struct snd_soc_dai *codec_dai, 205 int clk_id, unsigned int freq, int dir) 206 { 207 struct snd_soc_codec *codec = codec_dai->codec; 208 struct cs4270_private *cs4270 = codec->private_data; 209 unsigned int rates = 0; 210 unsigned int rate_min = -1; 211 unsigned int rate_max = 0; 212 unsigned int i; 213 214 cs4270->mclk = freq; 215 216 for (i = 0; i < NUM_MCLK_RATIOS; i++) { 217 unsigned int rate = freq / cs4270_mode_ratios[i].ratio; 218 rates |= snd_pcm_rate_to_rate_bit(rate); 219 if (rate < rate_min) 220 rate_min = rate; 221 if (rate > rate_max) 222 rate_max = rate; 223 } 224 /* FIXME: soc should support a rate list */ 225 rates &= ~SNDRV_PCM_RATE_KNOT; 226 227 if (!rates) { 228 printk(KERN_ERR "cs4270: could not find a valid sample rate\n"); 229 return -EINVAL; 230 } 231 232 codec_dai->playback.rates = rates; 233 codec_dai->playback.rate_min = rate_min; 234 codec_dai->playback.rate_max = rate_max; 235 236 codec_dai->capture.rates = rates; 237 codec_dai->capture.rate_min = rate_min; 238 codec_dai->capture.rate_max = rate_max; 239 240 return 0; 241 } 242 243 /* 244 * Configure the codec for the selected audio format 245 * 246 * This function takes a bitmask of SND_SOC_DAIFMT_x bits and programs the 247 * codec accordingly. 248 * 249 * Currently, this function only supports SND_SOC_DAIFMT_I2S and 250 * SND_SOC_DAIFMT_LEFT_J. The CS4270 codec also supports right-justified 251 * data for playback only, but ASoC currently does not support different 252 * formats for playback vs. record. 253 */ 254 static int cs4270_set_dai_fmt(struct snd_soc_dai *codec_dai, 255 unsigned int format) 256 { 257 struct snd_soc_codec *codec = codec_dai->codec; 258 struct cs4270_private *cs4270 = codec->private_data; 259 int ret = 0; 260 261 switch (format & SND_SOC_DAIFMT_FORMAT_MASK) { 262 case SND_SOC_DAIFMT_I2S: 263 case SND_SOC_DAIFMT_LEFT_J: 264 cs4270->mode = format & SND_SOC_DAIFMT_FORMAT_MASK; 265 break; 266 default: 267 printk(KERN_ERR "cs4270: invalid DAI format\n"); 268 ret = -EINVAL; 269 } 270 271 return ret; 272 } 273 274 /* 275 * A list of addresses on which this CS4270 could use. I2C addresses are 276 * 7 bits. For the CS4270, the upper four bits are always 1001, and the 277 * lower three bits are determined via the AD2, AD1, and AD0 pins 278 * (respectively). 279 */ 280 static const unsigned short normal_i2c[] = { 281 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, I2C_CLIENT_END 282 }; 283 I2C_CLIENT_INSMOD; 284 285 /* 286 * Pre-fill the CS4270 register cache. 287 * 288 * We use the auto-increment feature of the CS4270 to read all registers in 289 * one shot. 290 */ 291 static int cs4270_fill_cache(struct snd_soc_codec *codec) 292 { 293 u8 *cache = codec->reg_cache; 294 struct i2c_client *i2c_client = codec->control_data; 295 s32 length; 296 297 length = i2c_smbus_read_i2c_block_data(i2c_client, 298 CS4270_FIRSTREG | 0x80, CS4270_NUMREGS, cache); 299 300 if (length != CS4270_NUMREGS) { 301 printk(KERN_ERR "cs4270: I2C read failure, addr=0x%x\n", 302 i2c_client->addr); 303 return -EIO; 304 } 305 306 return 0; 307 } 308 309 /* 310 * Read from the CS4270 register cache. 311 * 312 * This CS4270 registers are cached to avoid excessive I2C I/O operations. 313 * After the initial read to pre-fill the cache, the CS4270 never updates 314 * the register values, so we won't have a cache coherncy problem. 315 */ 316 static unsigned int cs4270_read_reg_cache(struct snd_soc_codec *codec, 317 unsigned int reg) 318 { 319 u8 *cache = codec->reg_cache; 320 321 if ((reg < CS4270_FIRSTREG) || (reg > CS4270_LASTREG)) 322 return -EIO; 323 324 return cache[reg - CS4270_FIRSTREG]; 325 } 326 327 /* 328 * Write to a CS4270 register via the I2C bus. 329 * 330 * This function writes the given value to the given CS4270 register, and 331 * also updates the register cache. 332 * 333 * Note that we don't use the hw_write function pointer of snd_soc_codec. 334 * That's because it's too clunky: the hw_write_t prototype does not match 335 * i2c_smbus_write_byte_data(), and it's just another layer of overhead. 336 */ 337 static int cs4270_i2c_write(struct snd_soc_codec *codec, unsigned int reg, 338 unsigned int value) 339 { 340 u8 *cache = codec->reg_cache; 341 342 if ((reg < CS4270_FIRSTREG) || (reg > CS4270_LASTREG)) 343 return -EIO; 344 345 /* Only perform an I2C operation if the new value is different */ 346 if (cache[reg - CS4270_FIRSTREG] != value) { 347 struct i2c_client *client = codec->control_data; 348 if (i2c_smbus_write_byte_data(client, reg, value)) { 349 printk(KERN_ERR "cs4270: I2C write failed\n"); 350 return -EIO; 351 } 352 353 /* We've written to the hardware, so update the cache */ 354 cache[reg - CS4270_FIRSTREG] = value; 355 } 356 357 return 0; 358 } 359 360 /* 361 * Program the CS4270 with the given hardware parameters. 362 * 363 * The .dai_ops functions are used to provide board-specific data, like 364 * input frequencies, to this driver. This function takes that information, 365 * combines it with the hardware parameters provided, and programs the 366 * hardware accordingly. 367 */ 368 static int cs4270_hw_params(struct snd_pcm_substream *substream, 369 struct snd_pcm_hw_params *params) 370 { 371 struct snd_soc_pcm_runtime *rtd = substream->private_data; 372 struct snd_soc_device *socdev = rtd->socdev; 373 struct snd_soc_codec *codec = socdev->codec; 374 struct cs4270_private *cs4270 = codec->private_data; 375 int ret; 376 unsigned int i; 377 unsigned int rate; 378 unsigned int ratio; 379 int reg; 380 381 /* Figure out which MCLK/LRCK ratio to use */ 382 383 rate = params_rate(params); /* Sampling rate, in Hz */ 384 ratio = cs4270->mclk / rate; /* MCLK/LRCK ratio */ 385 386 for (i = 0; i < NUM_MCLK_RATIOS; i++) { 387 if (cs4270_mode_ratios[i].ratio == ratio) 388 break; 389 } 390 391 if (i == NUM_MCLK_RATIOS) { 392 /* We did not find a matching ratio */ 393 printk(KERN_ERR "cs4270: could not find matching ratio\n"); 394 return -EINVAL; 395 } 396 397 /* Freeze and power-down the codec */ 398 399 ret = snd_soc_write(codec, CS4270_PWRCTL, CS4270_PWRCTL_FREEZE | 400 CS4270_PWRCTL_PDN_ADC | CS4270_PWRCTL_PDN_DAC | 401 CS4270_PWRCTL_PDN); 402 if (ret < 0) { 403 printk(KERN_ERR "cs4270: I2C write failed\n"); 404 return ret; 405 } 406 407 /* Program the mode control register */ 408 409 reg = snd_soc_read(codec, CS4270_MODE); 410 reg &= ~(CS4270_MODE_SPEED_MASK | CS4270_MODE_DIV_MASK); 411 reg |= cs4270_mode_ratios[i].speed_mode | cs4270_mode_ratios[i].mclk; 412 413 ret = snd_soc_write(codec, CS4270_MODE, reg); 414 if (ret < 0) { 415 printk(KERN_ERR "cs4270: I2C write failed\n"); 416 return ret; 417 } 418 419 /* Program the format register */ 420 421 reg = snd_soc_read(codec, CS4270_FORMAT); 422 reg &= ~(CS4270_FORMAT_DAC_MASK | CS4270_FORMAT_ADC_MASK); 423 424 switch (cs4270->mode) { 425 case SND_SOC_DAIFMT_I2S: 426 reg |= CS4270_FORMAT_DAC_I2S | CS4270_FORMAT_ADC_I2S; 427 break; 428 case SND_SOC_DAIFMT_LEFT_J: 429 reg |= CS4270_FORMAT_DAC_LJ | CS4270_FORMAT_ADC_LJ; 430 break; 431 default: 432 printk(KERN_ERR "cs4270: unknown format\n"); 433 return -EINVAL; 434 } 435 436 ret = snd_soc_write(codec, CS4270_FORMAT, reg); 437 if (ret < 0) { 438 printk(KERN_ERR "cs4270: I2C write failed\n"); 439 return ret; 440 } 441 442 /* Disable auto-mute. This feature appears to be buggy, because in 443 some situations, auto-mute will not deactivate when it should. */ 444 445 reg = snd_soc_read(codec, CS4270_MUTE); 446 reg &= ~CS4270_MUTE_AUTO; 447 ret = snd_soc_write(codec, CS4270_MUTE, reg); 448 if (ret < 0) { 449 printk(KERN_ERR "cs4270: I2C write failed\n"); 450 return ret; 451 } 452 453 /* Thaw and power-up the codec */ 454 455 ret = snd_soc_write(codec, CS4270_PWRCTL, 0); 456 if (ret < 0) { 457 printk(KERN_ERR "cs4270: I2C write failed\n"); 458 return ret; 459 } 460 461 return ret; 462 } 463 464 #ifdef CONFIG_SND_SOC_CS4270_HWMUTE 465 466 /* 467 * Set the CS4270 external mute 468 * 469 * This function toggles the mute bits in the MUTE register. The CS4270's 470 * mute capability is intended for external muting circuitry, so if the 471 * board does not have the MUTEA or MUTEB pins connected to such circuitry, 472 * then this function will do nothing. 473 */ 474 static int cs4270_mute(struct snd_soc_dai *dai, int mute) 475 { 476 struct snd_soc_codec *codec = dai->codec; 477 int reg6; 478 479 reg6 = snd_soc_read(codec, CS4270_MUTE); 480 481 if (mute) 482 reg6 |= CS4270_MUTE_ADC_A | CS4270_MUTE_ADC_B | 483 CS4270_MUTE_DAC_A | CS4270_MUTE_DAC_B; 484 else 485 reg6 &= ~(CS4270_MUTE_ADC_A | CS4270_MUTE_ADC_B | 486 CS4270_MUTE_DAC_A | CS4270_MUTE_DAC_B); 487 488 return snd_soc_write(codec, CS4270_MUTE, reg6); 489 } 490 491 #endif 492 493 static int cs4270_i2c_probe(struct i2c_client *, const struct i2c_device_id *); 494 495 /* A list of non-DAPM controls that the CS4270 supports */ 496 static const struct snd_kcontrol_new cs4270_snd_controls[] = { 497 SOC_DOUBLE_R("Master Playback Volume", 498 CS4270_VOLA, CS4270_VOLB, 0, 0xFF, 1) 499 }; 500 501 static const struct i2c_device_id cs4270_id[] = { 502 {"cs4270", 0}, 503 {} 504 }; 505 MODULE_DEVICE_TABLE(i2c, cs4270_id); 506 507 static struct i2c_driver cs4270_i2c_driver = { 508 .driver = { 509 .name = "CS4270 I2C", 510 .owner = THIS_MODULE, 511 }, 512 .id_table = cs4270_id, 513 .probe = cs4270_i2c_probe, 514 }; 515 516 /* 517 * Global variable to store socdev for i2c probe function. 518 * 519 * If struct i2c_driver had a private_data field, we wouldn't need to use 520 * cs4270_socdec. This is the only way to pass the socdev structure to 521 * cs4270_i2c_probe(). 522 * 523 * The real solution to cs4270_socdev is to create a mechanism 524 * that maps I2C addresses to snd_soc_device structures. Perhaps the 525 * creation of the snd_soc_device object should be moved out of 526 * cs4270_probe() and into cs4270_i2c_probe(), but that would make this 527 * driver dependent on I2C. The CS4270 supports "stand-alone" mode, whereby 528 * the chip is *not* connected to the I2C bus, but is instead configured via 529 * input pins. 530 */ 531 static struct snd_soc_device *cs4270_socdev; 532 533 /* 534 * Initialize the I2C interface of the CS4270 535 * 536 * This function is called for whenever the I2C subsystem finds a device 537 * at a particular address. 538 * 539 * Note: snd_soc_new_pcms() must be called before this function can be called, 540 * because of snd_ctl_add(). 541 */ 542 static int cs4270_i2c_probe(struct i2c_client *i2c_client, 543 const struct i2c_device_id *id) 544 { 545 struct snd_soc_device *socdev = cs4270_socdev; 546 struct snd_soc_codec *codec = socdev->codec; 547 int i; 548 int ret = 0; 549 550 /* Probing all possible addresses has one drawback: if there are 551 multiple CS4270s on the bus, then you cannot specify which 552 socdev is matched with which CS4270. For now, we just reject 553 this I2C device if the socdev already has one attached. */ 554 if (codec->control_data) 555 return -ENODEV; 556 557 /* Note: codec_dai->codec is NULL here */ 558 559 codec->reg_cache = kzalloc(CS4270_NUMREGS, GFP_KERNEL); 560 if (!codec->reg_cache) { 561 printk(KERN_ERR "cs4270: could not allocate register cache\n"); 562 ret = -ENOMEM; 563 goto error; 564 } 565 566 /* Verify that we have a CS4270 */ 567 568 ret = i2c_smbus_read_byte_data(i2c_client, CS4270_CHIPID); 569 if (ret < 0) { 570 printk(KERN_ERR "cs4270: failed to read I2C\n"); 571 goto error; 572 } 573 /* The top four bits of the chip ID should be 1100. */ 574 if ((ret & 0xF0) != 0xC0) { 575 /* The device at this address is not a CS4270 codec */ 576 ret = -ENODEV; 577 goto error; 578 } 579 580 printk(KERN_INFO "cs4270: found device at I2C address %X\n", 581 i2c_client->addr); 582 printk(KERN_INFO "cs4270: hardware revision %X\n", ret & 0xF); 583 584 codec->control_data = i2c_client; 585 codec->read = cs4270_read_reg_cache; 586 codec->write = cs4270_i2c_write; 587 codec->reg_cache_size = CS4270_NUMREGS; 588 589 /* The I2C interface is set up, so pre-fill our register cache */ 590 591 ret = cs4270_fill_cache(codec); 592 if (ret < 0) { 593 printk(KERN_ERR "cs4270: failed to fill register cache\n"); 594 goto error; 595 } 596 597 /* Add the non-DAPM controls */ 598 599 for (i = 0; i < ARRAY_SIZE(cs4270_snd_controls); i++) { 600 struct snd_kcontrol *kctrl = 601 snd_soc_cnew(&cs4270_snd_controls[i], codec, NULL); 602 603 ret = snd_ctl_add(codec->card, kctrl); 604 if (ret < 0) 605 goto error; 606 } 607 608 i2c_set_clientdata(i2c_client, codec); 609 610 return 0; 611 612 error: 613 codec->control_data = NULL; 614 615 kfree(codec->reg_cache); 616 codec->reg_cache = NULL; 617 codec->reg_cache_size = 0; 618 619 return ret; 620 } 621 622 #endif /* USE_I2C*/ 623 624 struct snd_soc_dai cs4270_dai = { 625 .name = "CS4270", 626 .playback = { 627 .stream_name = "Playback", 628 .channels_min = 1, 629 .channels_max = 2, 630 .rates = 0, 631 .formats = CS4270_FORMATS, 632 }, 633 .capture = { 634 .stream_name = "Capture", 635 .channels_min = 1, 636 .channels_max = 2, 637 .rates = 0, 638 .formats = CS4270_FORMATS, 639 }, 640 }; 641 EXPORT_SYMBOL_GPL(cs4270_dai); 642 643 /* 644 * ASoC probe function 645 * 646 * This function is called when the machine driver calls 647 * platform_device_add(). 648 */ 649 static int cs4270_probe(struct platform_device *pdev) 650 { 651 struct snd_soc_device *socdev = platform_get_drvdata(pdev); 652 struct snd_soc_codec *codec; 653 int ret = 0; 654 655 printk(KERN_INFO "CS4270 ALSA SoC Codec\n"); 656 657 /* Allocate enough space for the snd_soc_codec structure 658 and our private data together. */ 659 codec = kzalloc(ALIGN(sizeof(struct snd_soc_codec), 4) + 660 sizeof(struct cs4270_private), GFP_KERNEL); 661 if (!codec) { 662 printk(KERN_ERR "cs4270: Could not allocate codec structure\n"); 663 return -ENOMEM; 664 } 665 666 mutex_init(&codec->mutex); 667 INIT_LIST_HEAD(&codec->dapm_widgets); 668 INIT_LIST_HEAD(&codec->dapm_paths); 669 670 codec->name = "CS4270"; 671 codec->owner = THIS_MODULE; 672 codec->dai = &cs4270_dai; 673 codec->num_dai = 1; 674 codec->private_data = (void *) codec + 675 ALIGN(sizeof(struct snd_soc_codec), 4); 676 677 socdev->codec = codec; 678 679 /* Register PCMs */ 680 681 ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1); 682 if (ret < 0) { 683 printk(KERN_ERR "cs4270: failed to create PCMs\n"); 684 goto error_free_codec; 685 } 686 687 #ifdef USE_I2C 688 cs4270_socdev = socdev; 689 690 ret = i2c_add_driver(&cs4270_i2c_driver); 691 if (ret) { 692 printk(KERN_ERR "cs4270: failed to attach driver"); 693 goto error_free_pcms; 694 } 695 696 /* Did we find a CS4270 on the I2C bus? */ 697 if (codec->control_data) { 698 /* Initialize codec ops */ 699 cs4270_dai.ops.hw_params = cs4270_hw_params; 700 cs4270_dai.dai_ops.set_sysclk = cs4270_set_dai_sysclk; 701 cs4270_dai.dai_ops.set_fmt = cs4270_set_dai_fmt; 702 #ifdef CONFIG_SND_SOC_CS4270_HWMUTE 703 cs4270_dai.dai_ops.digital_mute = cs4270_mute; 704 #endif 705 } else 706 printk(KERN_INFO "cs4270: no I2C device found, " 707 "using stand-alone mode\n"); 708 #else 709 printk(KERN_INFO "cs4270: I2C disabled, using stand-alone mode\n"); 710 #endif 711 712 ret = snd_soc_register_card(socdev); 713 if (ret < 0) { 714 printk(KERN_ERR "cs4270: failed to register card\n"); 715 goto error_del_driver; 716 } 717 718 return 0; 719 720 error_del_driver: 721 #ifdef USE_I2C 722 i2c_del_driver(&cs4270_i2c_driver); 723 724 error_free_pcms: 725 #endif 726 snd_soc_free_pcms(socdev); 727 728 error_free_codec: 729 kfree(socdev->codec); 730 socdev->codec = NULL; 731 732 return ret; 733 } 734 735 static int cs4270_remove(struct platform_device *pdev) 736 { 737 struct snd_soc_device *socdev = platform_get_drvdata(pdev); 738 739 snd_soc_free_pcms(socdev); 740 741 #ifdef USE_I2C 742 i2c_del_driver(&cs4270_i2c_driver); 743 #endif 744 745 kfree(socdev->codec); 746 socdev->codec = NULL; 747 748 return 0; 749 } 750 751 /* 752 * ASoC codec device structure 753 * 754 * Assign this variable to the codec_dev field of the machine driver's 755 * snd_soc_device structure. 756 */ 757 struct snd_soc_codec_device soc_codec_device_cs4270 = { 758 .probe = cs4270_probe, 759 .remove = cs4270_remove 760 }; 761 EXPORT_SYMBOL_GPL(soc_codec_device_cs4270); 762 763 MODULE_AUTHOR("Timur Tabi <timur@freescale.com>"); 764 MODULE_DESCRIPTION("Cirrus Logic CS4270 ALSA SoC Codec Driver"); 765 MODULE_LICENSE("GPL"); 766