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 */
cs4270_set_dai_sysclk(struct snd_soc_dai * codec_dai,int clk_id,unsigned int freq,int dir)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 */
cs4270_set_dai_fmt(struct snd_soc_dai * codec_dai,unsigned int format)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 */
cs4270_fill_cache(struct snd_soc_codec * codec)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 */
cs4270_read_reg_cache(struct snd_soc_codec * codec,unsigned int reg)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 */
cs4270_i2c_write(struct snd_soc_codec * codec,unsigned int reg,unsigned int value)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 .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 */
cs4270_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params,struct snd_soc_dai * dai)368 static int cs4270_hw_params(struct snd_pcm_substream *substream,
369 struct snd_pcm_hw_params *params,
370 struct snd_soc_dai *dai)
371 {
372 struct snd_soc_pcm_runtime *rtd = substream->private_data;
373 struct snd_soc_device *socdev = rtd->socdev;
374 struct snd_soc_codec *codec = socdev->codec;
375 struct cs4270_private *cs4270 = codec->private_data;
376 int ret;
377 unsigned int i;
378 unsigned int rate;
379 unsigned int ratio;
380 int reg;
381
382 /* Figure out which MCLK/LRCK ratio to use */
383
384 rate = params_rate(params); /* Sampling rate, in Hz */
385 ratio = cs4270->mclk / rate; /* MCLK/LRCK ratio */
386
387 for (i = 0; i < NUM_MCLK_RATIOS; i++) {
388 if (cs4270_mode_ratios[i].ratio == ratio)
389 break;
390 }
391
392 if (i == NUM_MCLK_RATIOS) {
393 /* We did not find a matching ratio */
394 printk(KERN_ERR "cs4270: could not find matching ratio\n");
395 return -EINVAL;
396 }
397
398 /* Freeze and power-down the codec */
399
400 ret = snd_soc_write(codec, CS4270_PWRCTL, CS4270_PWRCTL_FREEZE |
401 CS4270_PWRCTL_PDN_ADC | CS4270_PWRCTL_PDN_DAC |
402 CS4270_PWRCTL_PDN);
403 if (ret < 0) {
404 printk(KERN_ERR "cs4270: I2C write failed\n");
405 return ret;
406 }
407
408 /* Program the mode control register */
409
410 reg = snd_soc_read(codec, CS4270_MODE);
411 reg &= ~(CS4270_MODE_SPEED_MASK | CS4270_MODE_DIV_MASK);
412 reg |= cs4270_mode_ratios[i].speed_mode | cs4270_mode_ratios[i].mclk;
413
414 ret = snd_soc_write(codec, CS4270_MODE, reg);
415 if (ret < 0) {
416 printk(KERN_ERR "cs4270: I2C write failed\n");
417 return ret;
418 }
419
420 /* Program the format register */
421
422 reg = snd_soc_read(codec, CS4270_FORMAT);
423 reg &= ~(CS4270_FORMAT_DAC_MASK | CS4270_FORMAT_ADC_MASK);
424
425 switch (cs4270->mode) {
426 case SND_SOC_DAIFMT_I2S:
427 reg |= CS4270_FORMAT_DAC_I2S | CS4270_FORMAT_ADC_I2S;
428 break;
429 case SND_SOC_DAIFMT_LEFT_J:
430 reg |= CS4270_FORMAT_DAC_LJ | CS4270_FORMAT_ADC_LJ;
431 break;
432 default:
433 printk(KERN_ERR "cs4270: unknown format\n");
434 return -EINVAL;
435 }
436
437 ret = snd_soc_write(codec, CS4270_FORMAT, reg);
438 if (ret < 0) {
439 printk(KERN_ERR "cs4270: I2C write failed\n");
440 return ret;
441 }
442
443 /* Disable auto-mute. This feature appears to be buggy, because in
444 some situations, auto-mute will not deactivate when it should. */
445
446 reg = snd_soc_read(codec, CS4270_MUTE);
447 reg &= ~CS4270_MUTE_AUTO;
448 ret = snd_soc_write(codec, CS4270_MUTE, reg);
449 if (ret < 0) {
450 printk(KERN_ERR "cs4270: I2C write failed\n");
451 return ret;
452 }
453
454 /* Disable automatic volume control. It's enabled by default, and
455 * it causes volume change commands to be delayed, sometimes until
456 * after playback has started.
457 */
458
459 reg = cs4270_read_reg_cache(codec, CS4270_TRANS);
460 reg &= ~(CS4270_TRANS_SOFT | CS4270_TRANS_ZERO);
461 ret = cs4270_i2c_write(codec, CS4270_TRANS, reg);
462 if (ret < 0) {
463 printk(KERN_ERR "I2C write failed\n");
464 return ret;
465 }
466
467 /* Thaw and power-up the codec */
468
469 ret = snd_soc_write(codec, CS4270_PWRCTL, 0);
470 if (ret < 0) {
471 printk(KERN_ERR "cs4270: I2C write failed\n");
472 return ret;
473 }
474
475 return ret;
476 }
477
478 #ifdef CONFIG_SND_SOC_CS4270_HWMUTE
479
480 /*
481 * Set the CS4270 external mute
482 *
483 * This function toggles the mute bits in the MUTE register. The CS4270's
484 * mute capability is intended for external muting circuitry, so if the
485 * board does not have the MUTEA or MUTEB pins connected to such circuitry,
486 * then this function will do nothing.
487 */
cs4270_mute(struct snd_soc_dai * dai,int mute)488 static int cs4270_mute(struct snd_soc_dai *dai, int mute)
489 {
490 struct snd_soc_codec *codec = dai->codec;
491 int reg6;
492
493 reg6 = snd_soc_read(codec, CS4270_MUTE);
494
495 if (mute)
496 reg6 |= CS4270_MUTE_ADC_A | CS4270_MUTE_ADC_B |
497 CS4270_MUTE_DAC_A | CS4270_MUTE_DAC_B;
498 else
499 reg6 &= ~(CS4270_MUTE_ADC_A | CS4270_MUTE_ADC_B |
500 CS4270_MUTE_DAC_A | CS4270_MUTE_DAC_B);
501
502 return snd_soc_write(codec, CS4270_MUTE, reg6);
503 }
504
505 #endif
506
507 static int cs4270_i2c_probe(struct i2c_client *, const struct i2c_device_id *);
508
509 /* A list of non-DAPM controls that the CS4270 supports */
510 static const struct snd_kcontrol_new cs4270_snd_controls[] = {
511 SOC_DOUBLE_R("Master Playback Volume",
512 CS4270_VOLA, CS4270_VOLB, 0, 0xFF, 1)
513 };
514
515 static const struct i2c_device_id cs4270_id[] = {
516 {"cs4270", 0},
517 {}
518 };
519 MODULE_DEVICE_TABLE(i2c, cs4270_id);
520
521 static struct i2c_driver cs4270_i2c_driver = {
522 .driver = {
523 .name = "CS4270 I2C",
524 .owner = THIS_MODULE,
525 },
526 .id_table = cs4270_id,
527 .probe = cs4270_i2c_probe,
528 };
529
530 /*
531 * Global variable to store socdev for i2c probe function.
532 *
533 * If struct i2c_driver had a private_data field, we wouldn't need to use
534 * cs4270_socdec. This is the only way to pass the socdev structure to
535 * cs4270_i2c_probe().
536 *
537 * The real solution to cs4270_socdev is to create a mechanism
538 * that maps I2C addresses to snd_soc_device structures. Perhaps the
539 * creation of the snd_soc_device object should be moved out of
540 * cs4270_probe() and into cs4270_i2c_probe(), but that would make this
541 * driver dependent on I2C. The CS4270 supports "stand-alone" mode, whereby
542 * the chip is *not* connected to the I2C bus, but is instead configured via
543 * input pins.
544 */
545 static struct snd_soc_device *cs4270_socdev;
546
547 /*
548 * Initialize the I2C interface of the CS4270
549 *
550 * This function is called for whenever the I2C subsystem finds a device
551 * at a particular address.
552 *
553 * Note: snd_soc_new_pcms() must be called before this function can be called,
554 * because of snd_ctl_add().
555 */
cs4270_i2c_probe(struct i2c_client * i2c_client,const struct i2c_device_id * id)556 static int cs4270_i2c_probe(struct i2c_client *i2c_client,
557 const struct i2c_device_id *id)
558 {
559 struct snd_soc_device *socdev = cs4270_socdev;
560 struct snd_soc_codec *codec = socdev->codec;
561 int i;
562 int ret = 0;
563
564 /* Probing all possible addresses has one drawback: if there are
565 multiple CS4270s on the bus, then you cannot specify which
566 socdev is matched with which CS4270. For now, we just reject
567 this I2C device if the socdev already has one attached. */
568 if (codec->control_data)
569 return -ENODEV;
570
571 /* Note: codec_dai->codec is NULL here */
572
573 codec->reg_cache = kzalloc(CS4270_NUMREGS, GFP_KERNEL);
574 if (!codec->reg_cache) {
575 printk(KERN_ERR "cs4270: could not allocate register cache\n");
576 ret = -ENOMEM;
577 goto error;
578 }
579
580 /* Verify that we have a CS4270 */
581
582 ret = i2c_smbus_read_byte_data(i2c_client, CS4270_CHIPID);
583 if (ret < 0) {
584 printk(KERN_ERR "cs4270: failed to read I2C\n");
585 goto error;
586 }
587 /* The top four bits of the chip ID should be 1100. */
588 if ((ret & 0xF0) != 0xC0) {
589 /* The device at this address is not a CS4270 codec */
590 ret = -ENODEV;
591 goto error;
592 }
593
594 printk(KERN_INFO "cs4270: found device at I2C address %X\n",
595 i2c_client->addr);
596 printk(KERN_INFO "cs4270: hardware revision %X\n", ret & 0xF);
597
598 codec->control_data = i2c_client;
599 codec->read = cs4270_read_reg_cache;
600 codec->write = cs4270_i2c_write;
601 codec->reg_cache_size = CS4270_NUMREGS;
602
603 /* The I2C interface is set up, so pre-fill our register cache */
604
605 ret = cs4270_fill_cache(codec);
606 if (ret < 0) {
607 printk(KERN_ERR "cs4270: failed to fill register cache\n");
608 goto error;
609 }
610
611 /* Add the non-DAPM controls */
612
613 for (i = 0; i < ARRAY_SIZE(cs4270_snd_controls); i++) {
614 struct snd_kcontrol *kctrl =
615 snd_soc_cnew(&cs4270_snd_controls[i], codec, NULL);
616
617 ret = snd_ctl_add(codec->card, kctrl);
618 if (ret < 0)
619 goto error;
620 }
621
622 i2c_set_clientdata(i2c_client, codec);
623
624 return 0;
625
626 error:
627 codec->control_data = NULL;
628
629 kfree(codec->reg_cache);
630 codec->reg_cache = NULL;
631 codec->reg_cache_size = 0;
632
633 return ret;
634 }
635
636 #endif /* USE_I2C*/
637
638 struct snd_soc_dai cs4270_dai = {
639 .name = "CS4270",
640 .playback = {
641 .stream_name = "Playback",
642 .channels_min = 1,
643 .channels_max = 2,
644 .rates = 0,
645 .formats = CS4270_FORMATS,
646 },
647 .capture = {
648 .stream_name = "Capture",
649 .channels_min = 1,
650 .channels_max = 2,
651 .rates = 0,
652 .formats = CS4270_FORMATS,
653 },
654 };
655 EXPORT_SYMBOL_GPL(cs4270_dai);
656
657 /*
658 * ASoC probe function
659 *
660 * This function is called when the machine driver calls
661 * platform_device_add().
662 */
cs4270_probe(struct platform_device * pdev)663 static int cs4270_probe(struct platform_device *pdev)
664 {
665 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
666 struct snd_soc_codec *codec;
667 int ret = 0;
668
669 printk(KERN_INFO "CS4270 ALSA SoC Codec\n");
670
671 /* Allocate enough space for the snd_soc_codec structure
672 and our private data together. */
673 codec = kzalloc(ALIGN(sizeof(struct snd_soc_codec), 4) +
674 sizeof(struct cs4270_private), GFP_KERNEL);
675 if (!codec) {
676 printk(KERN_ERR "cs4270: Could not allocate codec structure\n");
677 return -ENOMEM;
678 }
679
680 mutex_init(&codec->mutex);
681 INIT_LIST_HEAD(&codec->dapm_widgets);
682 INIT_LIST_HEAD(&codec->dapm_paths);
683
684 codec->name = "CS4270";
685 codec->owner = THIS_MODULE;
686 codec->dai = &cs4270_dai;
687 codec->num_dai = 1;
688 codec->private_data = (void *) codec +
689 ALIGN(sizeof(struct snd_soc_codec), 4);
690
691 socdev->codec = codec;
692
693 /* Register PCMs */
694
695 ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
696 if (ret < 0) {
697 printk(KERN_ERR "cs4270: failed to create PCMs\n");
698 goto error_free_codec;
699 }
700
701 #ifdef USE_I2C
702 cs4270_socdev = socdev;
703
704 ret = i2c_add_driver(&cs4270_i2c_driver);
705 if (ret) {
706 printk(KERN_ERR "cs4270: failed to attach driver");
707 goto error_free_pcms;
708 }
709
710 /* Did we find a CS4270 on the I2C bus? */
711 if (codec->control_data) {
712 /* Initialize codec ops */
713 cs4270_dai.ops.hw_params = cs4270_hw_params;
714 cs4270_dai.ops.set_sysclk = cs4270_set_dai_sysclk;
715 cs4270_dai.ops.set_fmt = cs4270_set_dai_fmt;
716 #ifdef CONFIG_SND_SOC_CS4270_HWMUTE
717 cs4270_dai.ops.digital_mute = cs4270_mute;
718 #endif
719 } else
720 printk(KERN_INFO "cs4270: no I2C device found, "
721 "using stand-alone mode\n");
722 #else
723 printk(KERN_INFO "cs4270: I2C disabled, using stand-alone mode\n");
724 #endif
725
726 ret = snd_soc_init_card(socdev);
727 if (ret < 0) {
728 printk(KERN_ERR "cs4270: failed to register card\n");
729 goto error_del_driver;
730 }
731
732 return 0;
733
734 error_del_driver:
735 #ifdef USE_I2C
736 i2c_del_driver(&cs4270_i2c_driver);
737
738 error_free_pcms:
739 #endif
740 snd_soc_free_pcms(socdev);
741
742 error_free_codec:
743 kfree(socdev->codec);
744 socdev->codec = NULL;
745
746 return ret;
747 }
748
cs4270_remove(struct platform_device * pdev)749 static int cs4270_remove(struct platform_device *pdev)
750 {
751 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
752
753 snd_soc_free_pcms(socdev);
754
755 #ifdef USE_I2C
756 i2c_del_driver(&cs4270_i2c_driver);
757 #endif
758
759 kfree(socdev->codec);
760 socdev->codec = NULL;
761
762 return 0;
763 }
764
765 /*
766 * ASoC codec device structure
767 *
768 * Assign this variable to the codec_dev field of the machine driver's
769 * snd_soc_device structure.
770 */
771 struct snd_soc_codec_device soc_codec_device_cs4270 = {
772 .probe = cs4270_probe,
773 .remove = cs4270_remove
774 };
775 EXPORT_SYMBOL_GPL(soc_codec_device_cs4270);
776
cs4270_init(void)777 static int __init cs4270_init(void)
778 {
779 return snd_soc_register_dai(&cs4270_dai);
780 }
781 module_init(cs4270_init);
782
cs4270_exit(void)783 static void __exit cs4270_exit(void)
784 {
785 snd_soc_unregister_dai(&cs4270_dai);
786 }
787 module_exit(cs4270_exit);
788
789 MODULE_AUTHOR("Timur Tabi <timur@freescale.com>");
790 MODULE_DESCRIPTION("Cirrus Logic CS4270 ALSA SoC Codec Driver");
791 MODULE_LICENSE("GPL");
792