linux/sound/soc/codecs/cs4270.c
<<
>>
Prefs
   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 */
  45struct 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 */
 154static 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 */
 204static int cs4270_set_dai_sysclk(struct snd_soc_codec_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 */
 254static int cs4270_set_dai_fmt(struct snd_soc_codec_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 */
 280static const unsigned short normal_i2c[] = {
 281        0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, I2C_CLIENT_END
 282};
 283I2C_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 */
 291static 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 */
 316static 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 */
 337static 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 */
 368static 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        unsigned int ret = 0;
 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 */
 474static int cs4270_mute(struct snd_soc_codec_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
 493static int cs4270_i2c_probe(struct i2c_adapter *adap, int addr, int kind);
 494
 495/*
 496 * Notify the driver that a new I2C bus has been found.
 497 *
 498 * This function is called for each I2C bus in the system.  The function
 499 * then asks the I2C subsystem to probe that bus at the addresses on which
 500 * our device (the CS4270) could exist.  If a device is found at one of
 501 * those addresses, then our probe function (cs4270_i2c_probe) is called.
 502 */
 503static int cs4270_i2c_attach(struct i2c_adapter *adapter)
 504{
 505        return i2c_probe(adapter, &addr_data, cs4270_i2c_probe);
 506}
 507
 508static int cs4270_i2c_detach(struct i2c_client *client)
 509{
 510        struct snd_soc_codec *codec = i2c_get_clientdata(client);
 511
 512        i2c_detach_client(client);
 513        codec->control_data = NULL;
 514
 515        kfree(codec->reg_cache);
 516        codec->reg_cache = NULL;
 517
 518        kfree(client);
 519        return 0;
 520}
 521
 522/* A list of non-DAPM controls that the CS4270 supports */
 523static const struct snd_kcontrol_new cs4270_snd_controls[] = {
 524        SOC_DOUBLE_R("Master Playback Volume",
 525                CS4270_VOLA, CS4270_VOLB, 0, 0xFF, 1)
 526};
 527
 528static struct i2c_driver cs4270_i2c_driver = {
 529        .driver = {
 530                .name = "CS4270 I2C",
 531                .owner = THIS_MODULE,
 532        },
 533        .id =             I2C_DRIVERID_CS4270,
 534        .attach_adapter = cs4270_i2c_attach,
 535        .detach_client =  cs4270_i2c_detach,
 536};
 537
 538/*
 539 * Global variable to store socdev for i2c probe function.
 540 *
 541 * If struct i2c_driver had a private_data field, we wouldn't need to use
 542 * cs4270_socdec.  This is the only way to pass the socdev structure to
 543 * cs4270_i2c_probe().
 544 *
 545 * The real solution to cs4270_socdev is to create a mechanism
 546 * that maps I2C addresses to snd_soc_device structures.  Perhaps the
 547 * creation of the snd_soc_device object should be moved out of
 548 * cs4270_probe() and into cs4270_i2c_probe(), but that would make this
 549 * driver dependent on I2C.  The CS4270 supports "stand-alone" mode, whereby
 550 * the chip is *not* connected to the I2C bus, but is instead configured via
 551 * input pins.
 552 */
 553static struct snd_soc_device *cs4270_socdev;
 554
 555/*
 556 * Initialize the I2C interface of the CS4270
 557 *
 558 * This function is called for whenever the I2C subsystem finds a device
 559 * at a particular address.
 560 *
 561 * Note: snd_soc_new_pcms() must be called before this function can be called,
 562 * because of snd_ctl_add().
 563 */
 564static int cs4270_i2c_probe(struct i2c_adapter *adapter, int addr, int kind)
 565{
 566        struct snd_soc_device *socdev = cs4270_socdev;
 567        struct snd_soc_codec *codec = socdev->codec;
 568        struct i2c_client *i2c_client = NULL;
 569        int i;
 570        int ret = 0;
 571
 572        /* Probing all possible addresses has one drawback: if there are
 573           multiple CS4270s on the bus, then you cannot specify which
 574           socdev is matched with which CS4270.  For now, we just reject
 575           this I2C device if the socdev already has one attached. */
 576        if (codec->control_data)
 577                return -ENODEV;
 578
 579        /* Note: codec_dai->codec is NULL here */
 580
 581        i2c_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
 582        if (!i2c_client) {
 583                printk(KERN_ERR "cs4270: could not allocate I2C client\n");
 584                return -ENOMEM;
 585        }
 586
 587        codec->reg_cache = kzalloc(CS4270_NUMREGS, GFP_KERNEL);
 588        if (!codec->reg_cache) {
 589                printk(KERN_ERR "cs4270: could not allocate register cache\n");
 590                ret = -ENOMEM;
 591                goto error;
 592        }
 593
 594        i2c_set_clientdata(i2c_client, codec);
 595        strcpy(i2c_client->name, "CS4270");
 596
 597        i2c_client->driver = &cs4270_i2c_driver;
 598        i2c_client->adapter = adapter;
 599        i2c_client->addr = addr;
 600
 601        /* Verify that we have a CS4270 */
 602
 603        ret = i2c_smbus_read_byte_data(i2c_client, CS4270_CHIPID);
 604        if (ret < 0) {
 605                printk(KERN_ERR "cs4270: failed to read I2C\n");
 606                goto error;
 607        }
 608        /* The top four bits of the chip ID should be 1100. */
 609        if ((ret & 0xF0) != 0xC0) {
 610                /* The device at this address is not a CS4270 codec */
 611                ret = -ENODEV;
 612                goto error;
 613        }
 614
 615        printk(KERN_INFO "cs4270: found device at I2C address %X\n", addr);
 616        printk(KERN_INFO "cs4270: hardware revision %X\n", ret & 0xF);
 617
 618        /* Tell the I2C layer a new client has arrived */
 619
 620        ret = i2c_attach_client(i2c_client);
 621        if (ret) {
 622                printk(KERN_ERR "cs4270: could not attach codec, "
 623                        "I2C address %x, error code %i\n", addr, ret);
 624                goto error;
 625        }
 626
 627        codec->control_data = i2c_client;
 628        codec->read = cs4270_read_reg_cache;
 629        codec->write = cs4270_i2c_write;
 630        codec->reg_cache_size = CS4270_NUMREGS;
 631
 632        /* The I2C interface is set up, so pre-fill our register cache */
 633
 634        ret = cs4270_fill_cache(codec);
 635        if (ret < 0) {
 636                printk(KERN_ERR "cs4270: failed to fill register cache\n");
 637                goto error;
 638        }
 639
 640        /* Add the non-DAPM controls */
 641
 642        for (i = 0; i < ARRAY_SIZE(cs4270_snd_controls); i++) {
 643                struct snd_kcontrol *kctrl =
 644                snd_soc_cnew(&cs4270_snd_controls[i], codec, NULL);
 645
 646                ret = snd_ctl_add(codec->card, kctrl);
 647                if (ret < 0)
 648                        goto error;
 649        }
 650
 651        return 0;
 652
 653error:
 654        if (codec->control_data) {
 655                i2c_detach_client(i2c_client);
 656                codec->control_data = NULL;
 657        }
 658
 659        kfree(codec->reg_cache);
 660        codec->reg_cache = NULL;
 661        codec->reg_cache_size = 0;
 662
 663        kfree(i2c_client);
 664
 665        return ret;
 666}
 667
 668#endif /* USE_I2C*/
 669
 670struct snd_soc_codec_dai cs4270_dai = {
 671        .name = "CS4270",
 672        .playback = {
 673                .stream_name = "Playback",
 674                .channels_min = 1,
 675                .channels_max = 2,
 676                .rates = 0,
 677                .formats = CS4270_FORMATS,
 678        },
 679        .capture = {
 680                .stream_name = "Capture",
 681                .channels_min = 1,
 682                .channels_max = 2,
 683                .rates = 0,
 684                .formats = CS4270_FORMATS,
 685        },
 686};
 687EXPORT_SYMBOL_GPL(cs4270_dai);
 688
 689/*
 690 * ASoC probe function
 691 *
 692 * This function is called when the machine driver calls
 693 * platform_device_add().
 694 */
 695static int cs4270_probe(struct platform_device *pdev)
 696{
 697        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
 698        struct snd_soc_codec *codec;
 699        int ret = 0;
 700
 701        printk(KERN_INFO "CS4270 ALSA SoC Codec\n");
 702
 703        /* Allocate enough space for the snd_soc_codec structure
 704           and our private data together. */
 705        codec = kzalloc(ALIGN(sizeof(struct snd_soc_codec), 4) +
 706                        sizeof(struct cs4270_private), GFP_KERNEL);
 707        if (!codec) {
 708                printk(KERN_ERR "cs4270: Could not allocate codec structure\n");
 709                return -ENOMEM;
 710        }
 711
 712        mutex_init(&codec->mutex);
 713        INIT_LIST_HEAD(&codec->dapm_widgets);
 714        INIT_LIST_HEAD(&codec->dapm_paths);
 715
 716        codec->name = "CS4270";
 717        codec->owner = THIS_MODULE;
 718        codec->dai = &cs4270_dai;
 719        codec->num_dai = 1;
 720        codec->private_data = (void *) codec +
 721                ALIGN(sizeof(struct snd_soc_codec), 4);
 722
 723        socdev->codec = codec;
 724
 725        /* Register PCMs */
 726
 727        ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
 728        if (ret < 0) {
 729                printk(KERN_ERR "cs4270: failed to create PCMs\n");
 730                return ret;
 731        }
 732
 733#ifdef USE_I2C
 734        cs4270_socdev = socdev;
 735
 736        ret = i2c_add_driver(&cs4270_i2c_driver);
 737        if (ret) {
 738                printk(KERN_ERR "cs4270: failed to attach driver");
 739                snd_soc_free_pcms(socdev);
 740                return ret;
 741        }
 742
 743        /* Did we find a CS4270 on the I2C bus? */
 744        if (codec->control_data) {
 745                /* Initialize codec ops */
 746                cs4270_dai.ops.hw_params = cs4270_hw_params;
 747                cs4270_dai.dai_ops.set_sysclk = cs4270_set_dai_sysclk;
 748                cs4270_dai.dai_ops.set_fmt = cs4270_set_dai_fmt;
 749#ifdef CONFIG_SND_SOC_CS4270_HWMUTE
 750                cs4270_dai.dai_ops.digital_mute = cs4270_mute;
 751#endif
 752        } else
 753                printk(KERN_INFO "cs4270: no I2C device found, "
 754                        "using stand-alone mode\n");
 755#else
 756        printk(KERN_INFO "cs4270: I2C disabled, using stand-alone mode\n");
 757#endif
 758
 759        ret = snd_soc_register_card(socdev);
 760        if (ret < 0) {
 761                printk(KERN_ERR "cs4270: failed to register card\n");
 762                snd_soc_free_pcms(socdev);
 763                return ret;
 764        }
 765
 766        return ret;
 767}
 768
 769static int cs4270_remove(struct platform_device *pdev)
 770{
 771        struct snd_soc_device *socdev = platform_get_drvdata(pdev);
 772
 773        snd_soc_free_pcms(socdev);
 774
 775#ifdef USE_I2C
 776        if (socdev->codec->control_data)
 777                i2c_del_driver(&cs4270_i2c_driver);
 778#endif
 779
 780        kfree(socdev->codec);
 781        socdev->codec = NULL;
 782
 783        return 0;
 784}
 785
 786/*
 787 * ASoC codec device structure
 788 *
 789 * Assign this variable to the codec_dev field of the machine driver's
 790 * snd_soc_device structure.
 791 */
 792struct snd_soc_codec_device soc_codec_device_cs4270 = {
 793        .probe =        cs4270_probe,
 794        .remove =       cs4270_remove
 795};
 796EXPORT_SYMBOL_GPL(soc_codec_device_cs4270);
 797
 798MODULE_AUTHOR("Timur Tabi <timur@freescale.com>");
 799MODULE_DESCRIPTION("Cirrus Logic CS4270 ALSA SoC Codec Driver");
 800MODULE_LICENSE("GPL");
 801
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.