xref: /openbmc/linux/sound/soc/codecs/cs4270.c (revision 22246614)
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_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  */
254 static 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  */
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_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 
493 static 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  */
503 static int cs4270_i2c_attach(struct i2c_adapter *adapter)
504 {
505 	return i2c_probe(adapter, &addr_data, cs4270_i2c_probe);
506 }
507 
508 static 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 */
523 static 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 
528 static 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  */
553 static 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  */
564 static 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 
653 error:
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 
670 struct 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 };
687 EXPORT_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  */
695 static 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 
769 static 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  */
792 struct snd_soc_codec_device soc_codec_device_cs4270 = {
793 	.probe = 	cs4270_probe,
794 	.remove = 	cs4270_remove
795 };
796 EXPORT_SYMBOL_GPL(soc_codec_device_cs4270);
797 
798 MODULE_AUTHOR("Timur Tabi <timur@freescale.com>");
799 MODULE_DESCRIPTION("Cirrus Logic CS4270 ALSA SoC Codec Driver");
800 MODULE_LICENSE("GPL");
801