Kernel

Kernel Commit Details

Date:	2010-06-01 01:04:12 (13 years 6 months ago)
Author:	Lars C.
Commit:	9f94c8c94238e92ef58718c949084cf98cc13e8e
Message:	jz4740: Rename jzcodec to jz4740-codec. The other jz47xx SoCs seem to have a different internal codec.
Files:	sound/soc/codecs/Kconfig (2 diffs) sound/soc/codecs/Makefile (2 diffs) sound/soc/codecs/jz4740-codec.c (1 diff) sound/soc/codecs/jz4740-codec.h (1 diff) sound/soc/codecs/jzcodec.c (1 diff) sound/soc/codecs/jzcodec.h (1 diff) sound/soc/jz4740/Kconfig (3 diffs) sound/soc/jz4740/n516.c (3 diffs) sound/soc/jz4740/n526.c (3 diffs) sound/soc/jz4740/qi_lb60.c (3 diffs)

Change Details

sound/soc/codecs/Kconfig
22	22	select SND_SOC_AK4642 if I2C
23	23	select SND_SOC_AK4671 if I2C
24	24	select SND_SOC_CS4270 if I2C
	25	select SND_SOC_JZ4740 if SOC_JZ4740
25	26	select SND_SOC_MAX9877 if I2C
26	27	select SND_SOC_DA7210 if I2C
27	28	select SND_SOC_PCM3008
...	...
260	261	config SND_SOC_WM9713
261	262	tristate
262	263
263		config SND_SOC_JZCODEC
264		tristate "JZ4720/JZ4740 SoC internal codec"
265		depends on SND_SOC && SOC_JZ4740
266		help
267		Say Y if you want to use internal codec on Ingenic JZ4720/JZ4740 based
268		boards.
	264	config SND_SOC_JZ4740_CODEC
	265	tristate
269	266
270	267	# Amp
271	268	config SND_SOC_MAX9877

sound/soc/codecs/Makefile
54	54	snd-soc-wm9712-objs := wm9712.o
55	55	snd-soc-wm9713-objs := wm9713.o
56	56	snd-soc-wm-hubs-objs := wm_hubs.o
57		snd-soc-jzcodec-objs := jzcodec.o
	57	snd-soc-jz4740-codec-objs := jz4740-codec.o
58	58
59	59	# Amp
60	60	snd-soc-max9877-objs := max9877.o
...	...
117	117	obj-$(CONFIG_SND_SOC_WM9712) += snd-soc-wm9712.o
118	118	obj-$(CONFIG_SND_SOC_WM9713) += snd-soc-wm9713.o
119	119	obj-$(CONFIG_SND_SOC_WM_HUBS) += snd-soc-wm-hubs.o
120		obj-$(CONFIG_SND_SOC_JZCODEC) += snd-soc-jzcodec.o
	120	obj-$(CONFIG_SND_SOC_JZ4740_CODEC) += snd-soc-jz4740-codec.o
121	121
122	122	# Amp
123	123	obj-$(CONFIG_SND_SOC_MAX9877) += snd-soc-max9877.o

sound/soc/codecs/jz4740-codec.c
	1	/*
	2	* Copyright (C) 2009-2010, Lars-Peter Clausen <lars@metafoo.de>
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License version 2 as
	6	* published by the Free Software Foundation.
	7	*
	8	* You should have received a copy of the GNU General Public License along
	9	* with this program; if not, write to the Free Software Foundation, Inc.,
	10	* 675 Mass Ave, Cambridge, MA 02139, USA.
	11	*
	12	*/
	13
	14	#include <linux/kernel.h>
	15	#include <linux/module.h>
	16	#include <linux/platform_device.h>
	17	#include <linux/slab.h>
	18
	19	#include <linux/delay.h>
	20
	21	#include <sound/core.h>
	22	#include <sound/pcm.h>
	23	#include <sound/pcm_params.h>
	24	#include <sound/initval.h>
	25	#include <sound/soc-dapm.h>
	26	#include <sound/soc.h>
	27
	28	#define JZ4740_REG_CODEC_1 0x0
	29	#define JZ4740_REG_CODEC_2 0x1
	30
	31	#define JZ4740_CODEC_1_LINE_ENABLE BIT(29)
	32	#define JZ4740_CODEC_1_MIC_ENABLE BIT(28)
	33	#define JZ4740_CODEC_1_SW1_ENABLE BIT(27)
	34	#define JZ4740_CODEC_1_ADC_ENABLE BIT(26)
	35	#define JZ4740_CODEC_1_SW2_ENABLE BIT(25)
	36	#define JZ4740_CODEC_1_DAC_ENABLE BIT(24)
	37	#define JZ4740_CODEC_1_VREF_DISABLE BIT(20)
	38	#define JZ4740_CODEC_1_VREF_AMP_DISABLE BIT(19)
	39	#define JZ4740_CODEC_1_VREF_PULL_DOWN BIT(18)
	40	#define JZ4740_CODEC_1_VREF_LOW_CURRENT BIT(17)
	41	#define JZ4740_CODEC_1_VREF_HIGH_CURRENT BIT(16)
	42	#define JZ4740_CODEC_1_HEADPHONE_DISABLE BIT(14)
	43	#define JZ4740_CODEC_1_HEADPHONE_AMP_CHANGE_ANY BIT(13)
	44	#define JZ4740_CODEC_1_HEADPHONE_CHANGE BIT(12)
	45	#define JZ4740_CODEC_1_HEADPHONE_PULL_DOWN_M BIT(11)
	46	#define JZ4740_CODEC_1_HEADPHONE_PULL_DOWN_R BIT(10)
	47	#define JZ4740_CODEC_1_HEADPHONE_POWER_DOWN_M BIT(9)
	48	#define JZ4740_CODEC_1_HEADPHONE_POWER_DOWN BIT(8)
	49	#define JZ4740_CODEC_1_SUSPEND BIT(1)
	50	#define JZ4740_CODEC_1_RESET BIT(0)
	51
	52	#define JZ4740_CODEC_1_LINE_ENABLE_OFFSET 29
	53	#define JZ4740_CODEC_1_MIC_ENABLE_OFFSET 28
	54	#define JZ4740_CODEC_1_SW1_ENABLE_OFFSET 27
	55	#define JZ4740_CODEC_1_ADC_ENABLE_OFFSET 26
	56	#define JZ4740_CODEC_1_SW2_ENABLE_OFFSET 25
	57	#define JZ4740_CODEC_1_DAC_ENABLE_OFFSET 24
	58	#define JZ4740_CODEC_1_HEADPHONE_DISABLE_OFFSET 14
	59	#define JZ4740_CODEC_1_HEADPHONE_POWER_DOWN_OFFSET 8
	60
	61	#define JZ4740_CODEC_2_INPUT_VOLUME_MASK 0x1f0000
	62	#define JZ4740_CODEC_2_SAMPLE_RATE_MASK 0x000f00
	63	#define JZ4740_CODEC_2_MIC_BOOST_GAIN_MASK 0x000030
	64	#define JZ4740_CODEC_2_HEADPHONE_VOLUME_MASK 0x000003
	65
	66	#define JZ4740_CODEC_2_INPUT_VOLUME_OFFSET 16
	67	#define JZ4740_CODEC_2_SAMPLE_RATE_OFFSET 8
	68	#define JZ4740_CODEC_2_MIC_BOOST_GAIN_OFFSET 4
	69	#define JZ4740_CODEC_2_HEADPHONE_VOLUME_OFFSET 0
	70
	71	struct jz4740_codec {
	72	void __iomem *base;
	73	struct resource *mem;
	74
	75	uint32_t reg_cache[2];
	76	struct snd_soc_codec codec;
	77	};
	78
	79	static inline struct jz4740_codec codec_to_jz4740(struct snd_soc_codec codec)
	80	{
	81	return container_of(codec, struct jz4740_codec, codec);
	82	}
	83
	84	static unsigned int jz4740_codec_read(struct snd_soc_codec *codec, unsigned int reg)
	85	{
	86	struct jz4740_codec *jz4740_codec = codec_to_jz4740(codec);
	87	return readl(jz4740_codec->base + (reg << 2));
	88	}
	89
	90	static int jz4740_codec_write(struct snd_soc_codec *codec, unsigned int reg,
	91	unsigned int val)
	92	{
	93	struct jz4740_codec *jz4740_codec = codec_to_jz4740(codec);
	94	jz4740_codec->reg_cache[reg] = val;
	95
	96	writel(val, jz4740_codec->base + (reg << 2));
	97	return 0;
	98	}
	99
	100	static const struct snd_kcontrol_new jz4740_codec_controls[] = {
	101	SOC_SINGLE("Master Playback Volume", JZ4740_REG_CODEC_2,
	102	JZ4740_CODEC_2_HEADPHONE_VOLUME_OFFSET, 3, 0),
	103	SOC_SINGLE("Capture Volume", JZ4740_REG_CODEC_2,
	104	JZ4740_CODEC_2_INPUT_VOLUME_OFFSET, 31, 0),
	105	SOC_SINGLE("Master Playback Switch", JZ4740_REG_CODEC_1,
	106	JZ4740_CODEC_1_HEADPHONE_DISABLE_OFFSET, 1, 1),
	107	SOC_SINGLE("Mic Capture Volume", JZ4740_REG_CODEC_2,
	108	JZ4740_CODEC_2_MIC_BOOST_GAIN_OFFSET, 3, 0),
	109	};
	110
	111	static const struct snd_kcontrol_new jz4740_codec_output_controls[] = {
	112	SOC_DAPM_SINGLE("Bypass Switch", JZ4740_REG_CODEC_1,
	113	JZ4740_CODEC_1_SW1_ENABLE_OFFSET, 1, 0),
	114	SOC_DAPM_SINGLE("DAC Switch", JZ4740_REG_CODEC_1,
	115	JZ4740_CODEC_1_SW2_ENABLE_OFFSET, 1, 0),
	116	};
	117
	118	static const struct snd_kcontrol_new jz4740_codec_input_controls[] = {
	119	SOC_DAPM_SINGLE("Line Capture Switch", JZ4740_REG_CODEC_1,
	120	JZ4740_CODEC_1_LINE_ENABLE_OFFSET, 1, 0),
	121	SOC_DAPM_SINGLE("Mic Capture Switch", JZ4740_REG_CODEC_1,
	122	JZ4740_CODEC_1_MIC_ENABLE_OFFSET, 1, 0),
	123	};
	124
	125	static const struct snd_soc_dapm_widget jz4740_codec_dapm_widgets[] = {
	126	SND_SOC_DAPM_ADC("ADC", "Capture", JZ4740_REG_CODEC_1,
	127	JZ4740_CODEC_1_ADC_ENABLE_OFFSET, 0),
	128	SND_SOC_DAPM_DAC("DAC", "Playback", JZ4740_REG_CODEC_1,
	129	JZ4740_CODEC_1_DAC_ENABLE_OFFSET, 0),
	130
	131	SND_SOC_DAPM_MIXER("Output Mixer", JZ4740_REG_CODEC_1,
	132	JZ4740_CODEC_1_HEADPHONE_POWER_DOWN_OFFSET, 1,
	133	jz4740_codec_output_controls,
	134	ARRAY_SIZE(jz4740_codec_output_controls)),
	135
	136	SND_SOC_DAPM_MIXER_NAMED_CTL("Input Mixer", SND_SOC_NOPM, 0, 0,
	137	jz4740_codec_input_controls,
	138	ARRAY_SIZE(jz4740_codec_input_controls)),
	139	SND_SOC_DAPM_MIXER("Line Input", SND_SOC_NOPM, 0, 0, NULL, 0),
	140
	141	SND_SOC_DAPM_OUTPUT("LOUT"),
	142	SND_SOC_DAPM_OUTPUT("ROUT"),
	143
	144	SND_SOC_DAPM_INPUT("MIC"),
	145	SND_SOC_DAPM_INPUT("LIN"),
	146	SND_SOC_DAPM_INPUT("RIN"),
	147	};
	148
	149	static const struct snd_soc_dapm_route jz4740_codec_dapm_routes[] = {
	150
	151	{"Line Input", NULL, "LIN"},
	152	{"Line Input", NULL, "RIN"},
	153
	154	{"Input Mixer", "Line Capture Switch", "Line Input"},
	155	{"Input Mixer", "Mic Capture Switch", "MIC"},
	156
	157	{"ADC", NULL, "Input Mixer"},
	158
	159	{"Output Mixer", "Bypass Switch", "Input Mixer"},
	160	{"Output Mixer", "DAC Switch", "DAC"},
	161
	162	{"LOUT", NULL, "Output Mixer"},
	163	{"ROUT", NULL, "Output Mixer"},
	164	};
	165
	166	static int jz4740_codec_hw_params(struct snd_pcm_substream *substream, struct
	167	snd_pcm_hw_params params, struct snd_soc_dai dai)
	168	{
	169	uint32_t val;
	170	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	171	struct snd_soc_device *socdev = rtd->socdev;
	172	struct snd_soc_codec *codec = socdev->card->codec;
	173
	174	switch (params_format(params)) {
	175	case SNDRV_PCM_FORMAT_S8:
	176	case SNDRV_PCM_FORMAT_S16_LE:
	177	case SNDRV_PCM_FORMAT_S18_3LE:
	178	break;
	179	default:
	180	return -EINVAL;
	181	break;
	182	}
	183
	184	switch (params_rate(params)) {
	185	case 8000:
	186	val = 0;
	187	break;
	188	case 11025:
	189	val = 1;
	190	break;
	191	case 12000:
	192	val = 2;
	193	break;
	194	case 16000:
	195	val = 3;
	196	break;
	197	case 22050:
	198	val = 4;
	199	break;
	200	case 24000:
	201	val = 5;
	202	break;
	203	case 32000:
	204	val = 6;
	205	break;
	206	case 44100:
	207	val = 7;
	208	break;
	209	case 48000:
	210	val = 8;
	211	break;
	212	default:
	213	return -EINVAL;
	214	}
	215
	216	val <<= JZ4740_CODEC_2_SAMPLE_RATE_OFFSET;
	217
	218	snd_soc_update_bits(codec, JZ4740_REG_CODEC_2,
	219	JZ4740_CODEC_2_SAMPLE_RATE_MASK, val);
	220
	221	return 0;
	222	}
	223
	224	static int jz4740_codec_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
	225	{
	226	switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
	227	case SND_SOC_DAIFMT_CBM_CFM:
	228	break;
	229	default:
	230	return -EINVAL;
	231	}
	232
	233	switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
	234	case SND_SOC_DAIFMT_I2S:
	235	break;
	236	default:
	237	return -EINVAL;
	238	}
	239
	240	switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
	241	case SND_SOC_DAIFMT_NB_NF:
	242	break;
	243	default:
	244	return -EINVAL;
	245	}
	246
	247	return 0;
	248	}
	249
	250	static struct snd_soc_dai_ops jz4740_codec_dai_ops = {
	251	.hw_params = jz4740_codec_hw_params,
	252	.set_fmt = jz4740_codec_set_fmt,
	253	};
	254
	255	struct snd_soc_dai jz4740_codec_dai = {
	256	.name = "jz-codec",
	257	.playback = {
	258	.stream_name = "Playback",
	259	.channels_min = 2,
	260	.channels_max = 2,
	261	.rates = SNDRV_PCM_RATE_8000_48000,
	262	.formats = SNDRV_PCM_FMTBIT_S16_LE \| SNDRV_PCM_FMTBIT_S8,
	263	},
	264	.capture = {
	265	.stream_name = "Capture",
	266	.channels_min = 2,
	267	.channels_max = 2,
	268	.rates = SNDRV_PCM_RATE_8000_48000,
	269	.formats = SNDRV_PCM_FMTBIT_S16_LE \| SNDRV_PCM_FMTBIT_S8,
	270	},
	271	.ops = &jz4740_codec_dai_ops,
	272	.symmetric_rates = 1,
	273	};
	274	EXPORT_SYMBOL_GPL(jz4740_codec_dai);
	275
	276	static int jz4740_codec_set_bias_level(struct snd_soc_codec *codec,
	277	enum snd_soc_bias_level level)
	278	{
	279
	280	if (codec->bias_level == SND_SOC_BIAS_OFF && level != SND_SOC_BIAS_OFF) {
	281	snd_soc_update_bits(codec, JZ4740_REG_CODEC_1,
	282	JZ4740_CODEC_1_RESET, JZ4740_CODEC_1_RESET);
	283	udelay(2);
	284
	285	snd_soc_update_bits(codec, JZ4740_REG_CODEC_1,
	286	JZ4740_CODEC_1_SUSPEND \| JZ4740_CODEC_1_RESET, 0);
	287	}
	288	switch (level) {
	289	case SND_SOC_BIAS_ON:
	290	snd_soc_update_bits(codec, JZ4740_REG_CODEC_1,
	291	JZ4740_CODEC_1_VREF_DISABLE \|
	292	JZ4740_CODEC_1_VREF_AMP_DISABLE \|
	293	JZ4740_CODEC_1_HEADPHONE_POWER_DOWN_M \|
	294	JZ4740_CODEC_1_VREF_LOW_CURRENT \|
	295	JZ4740_CODEC_1_VREF_HIGH_CURRENT,
	296	0);
	297	break;
	298	case SND_SOC_BIAS_PREPARE:
	299	snd_soc_update_bits(codec, JZ4740_REG_CODEC_1,
	300	JZ4740_CODEC_1_VREF_LOW_CURRENT \|
	301	JZ4740_CODEC_1_VREF_HIGH_CURRENT,
	302	JZ4740_CODEC_1_VREF_LOW_CURRENT \|
	303	JZ4740_CODEC_1_VREF_HIGH_CURRENT);
	304	break;
	305	case SND_SOC_BIAS_STANDBY:
	306	snd_soc_update_bits(codec, JZ4740_REG_CODEC_1,
	307	JZ4740_CODEC_1_VREF_DISABLE \| JZ4740_CODEC_1_VREF_AMP_DISABLE,
	308	JZ4740_CODEC_1_VREF_DISABLE \| JZ4740_CODEC_1_VREF_AMP_DISABLE);
	309	break;
	310	case SND_SOC_BIAS_OFF:
	311	snd_soc_update_bits(codec, JZ4740_REG_CODEC_1,
	312	JZ4740_CODEC_1_SUSPEND, JZ4740_CODEC_1_SUSPEND);
	313	break;
	314	}
	315	codec->bias_level = level;
	316
	317	return 0;
	318	}
	319
	320
	321	static struct snd_soc_codec *jz4740_codec_codec;
	322
	323	static int jz4740_codec_dev_probe(struct platform_device *pdev)
	324	{
	325	int ret;
	326	struct snd_soc_device *socdev = platform_get_drvdata(pdev);
	327	struct snd_soc_codec *codec = jz4740_codec_codec;
	328
	329	BUG_ON(!codec);
	330
	331	socdev->card->codec = codec;
	332
	333	ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
	334	if (ret) {
	335	dev_err(&pdev->dev, "Failed to create pcms: %d\n", ret);
	336	return ret;
	337	}
	338
	339	snd_soc_add_controls(codec, jz4740_codec_controls,
	340	ARRAY_SIZE(jz4740_codec_controls));
	341
	342	snd_soc_dapm_new_controls(codec, jz4740_codec_dapm_widgets,
	343	ARRAY_SIZE(jz4740_codec_dapm_widgets));
	344
	345	snd_soc_dapm_add_routes(codec, jz4740_codec_dapm_routes,
	346	ARRAY_SIZE(jz4740_codec_dapm_routes));
	347
	348	snd_soc_dapm_new_widgets(codec);
	349
	350	return 0;
	351	}
	352
	353	static int jz4740_codec_dev_remove(struct platform_device *pdev)
	354	{
	355	struct snd_soc_device *socdev = platform_get_drvdata(pdev);
	356	snd_soc_free_pcms(socdev);
	357	snd_soc_dapm_free(socdev);
	358
	359	return 0;
	360	}
	361
	362	struct snd_soc_codec_device soc_codec_dev_jz4740_codec = {
	363	.probe = jz4740_codec_dev_probe,
	364	.remove = jz4740_codec_dev_remove,
	365	};
	366	EXPORT_SYMBOL_GPL(soc_codec_dev_jz4740_codec);
	367
	368	static int __devinit jz4740_codec_probe(struct platform_device *pdev)
	369	{
	370	int ret;
	371	struct jz4740_codec *jz4740_codec;
	372	struct snd_soc_codec *codec;
	373
	374	jz4740_codec = kzalloc(sizeof(*jz4740_codec), GFP_KERNEL);
	375
	376	if (!jz4740_codec)
	377	return -ENOMEM;
	378
	379	jz4740_codec->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	380
	381	if (!jz4740_codec->mem) {
	382	dev_err(&pdev->dev, "Failed to get mmio memory resource\n");
	383	ret = -ENOENT;
	384	goto err_free_codec;
	385	}
	386
	387	jz4740_codec->mem = request_mem_region(jz4740_codec->mem->start,
	388	resource_size(jz4740_codec->mem), pdev->name);
	389
	390	if (!jz4740_codec->mem) {
	391	dev_err(&pdev->dev, "Failed to request mmio memory region\n");
	392	ret = -EBUSY;
	393	goto err_free_codec;
	394	}
	395
	396	jz4740_codec->base = ioremap(jz4740_codec->mem->start, resource_size(jz4740_codec->mem));
	397
	398	if (!jz4740_codec->base) {
	399	dev_err(&pdev->dev, "Failed to ioremap mmio memory\n");
	400	ret = -EBUSY;
	401	goto err_release_mem_region;
	402	}
	403
	404	jz4740_codec_dai.dev = &pdev->dev;
	405
	406	codec = &jz4740_codec->codec;
	407
	408	codec->dev = &pdev->dev;
	409	codec->name = "jz-codec";
	410	codec->owner = THIS_MODULE;
	411
	412	codec->read = jz4740_codec_read;
	413	codec->write = jz4740_codec_write;
	414	codec->set_bias_level = jz4740_codec_set_bias_level;
	415	codec->bias_level = SND_SOC_BIAS_OFF;
	416
	417	codec->dai = &jz4740_codec_dai;
	418	codec->num_dai = 1;
	419
	420	codec->reg_cache = jz4740_codec->reg_cache;
	421	codec->reg_cache_size = 2;
	422
	423	codec->private_data = jz4740_codec;
	424
	425	mutex_init(&codec->mutex);
	426	INIT_LIST_HEAD(&codec->dapm_widgets);
	427	INIT_LIST_HEAD(&codec->dapm_paths);
	428
	429	jz4740_codec_codec = codec;
	430
	431	snd_soc_update_bits(codec, JZ4740_REG_CODEC_1,
	432	JZ4740_CODEC_1_SW2_ENABLE, JZ4740_CODEC_1_SW2_ENABLE);
	433
	434
	435	platform_set_drvdata(pdev, jz4740_codec);
	436	ret = snd_soc_register_codec(codec);
	437
	438	if (ret) {
	439	dev_err(&pdev->dev, "Failed to register codec\n");
	440	goto err_iounmap;
	441	}
	442
	443	ret = snd_soc_register_dai(&jz4740_codec_dai);
	444	if (ret) {
	445	dev_err(&pdev->dev, "Failed to register codec dai\n");
	446	goto err_unregister_codec;
	447	}
	448
	449	jz4740_codec_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
	450
	451	return 0;
	452	err_unregister_codec:
	453	snd_soc_unregister_codec(codec);
	454	err_iounmap:
	455	iounmap(jz4740_codec->base);
	456	err_release_mem_region:
	457	release_mem_region(jz4740_codec->mem->start, resource_size(jz4740_codec->mem));
	458	err_free_codec:
	459	kfree(jz4740_codec);
	460
	461	return ret;
	462	}
	463
	464	static int __devexit jz4740_codec_remove(struct platform_device *pdev)
	465	{
	466	struct jz4740_codec *jz4740_codec = platform_get_drvdata(pdev);
	467
	468	snd_soc_unregister_dai(&jz4740_codec_dai);
	469	snd_soc_unregister_codec(&jz4740_codec->codec);
	470
	471	iounmap(jz4740_codec->base);
	472	release_mem_region(jz4740_codec->mem->start, resource_size(jz4740_codec->mem));
	473
	474	platform_set_drvdata(pdev, NULL);
	475	kfree(jz4740_codec);
	476
	477	return 0;
	478	}
	479
	480	static struct platform_driver jz4740_codec_driver = {
	481	.probe = jz4740_codec_probe,
	482	.remove = __devexit_p(jz4740_codec_remove),
	483	.driver = {
	484	.name = "jz4740-codec",
	485	.owner = THIS_MODULE,
	486	},
	487	};
	488
	489	static int __init jz4740_codec_init(void)
	490	{
	491	return platform_driver_register(&jz4740_codec_driver);
	492	}
	493	module_init(jz4740_codec_init);
	494
	495	static void __exit jz4740_codec_exit(void)
	496	{
	497	platform_driver_unregister(&jz4740_codec_driver);
	498	}
	499	module_exit(jz4740_codec_exit);
	500
	501	MODULE_DESCRIPTION("JZ4740 SoC internal codec driver");
	502	MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
	503	MODULE_LICENSE("GPL v2");
	504	MODULE_ALIAS("platform:jz-codec");

sound/soc/codecs/jz4740-codec.h
	1	/*
	2	* Copyright (C) 2009, Lars-Peter Clausen <lars@metafoo.de>
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License version 2 as
	6	* published by the Free Software Foundation.
	7	*
	8	* You should have received a copy of the GNU General Public License along
	9	* with this program; if not, write to the Free Software Foundation, Inc.,
	10	* 675 Mass Ave, Cambridge, MA 02139, USA.
	11	*
	12	*/
	13
	14	#ifndef __SND_SOC_CODECS_JZ4740_CODEC_H__
	15	#define __SND_SOC_CODECS_JZ4740_CODEC_H__
	16
	17	extern struct snd_soc_dai jz4740_codec_dai;
	18	extern struct snd_soc_codec_device soc_codec_dev_jz4740_codec;
	19
	20	#endif

sound/soc/codecs/jzcodec.c
1		/*
2		* Copyright (C) 2009-2010, Lars-Peter Clausen <lars@metafoo.de>
3		*
4		* This program is free software; you can redistribute it and/or modify
5		* it under the terms of the GNU General Public License version 2 as
6		* published by the Free Software Foundation.
7		*
8		* You should have received a copy of the GNU General Public License along
9		* with this program; if not, write to the Free Software Foundation, Inc.,
10		* 675 Mass Ave, Cambridge, MA 02139, USA.
11		*
12		*/
13
14		#include <linux/kernel.h>
15		#include <linux/module.h>
16		#include <linux/platform_device.h>
17		#include <linux/slab.h>
18
19		#include <linux/delay.h>
20
21		#include <sound/core.h>
22		#include <sound/pcm.h>
23		#include <sound/pcm_params.h>
24		#include <sound/initval.h>
25		#include <sound/soc-dapm.h>
26		#include <sound/soc.h>
27
28		#define JZ_REG_CODEC_1 0x0
29		#define JZ_REG_CODEC_2 0x1
30
31		#define JZ_CODEC_1_LINE_ENABLE BIT(29)
32		#define JZ_CODEC_1_MIC_ENABLE BIT(28)
33		#define JZ_CODEC_1_SW1_ENABLE BIT(27)
34		#define JZ_CODEC_1_ADC_ENABLE BIT(26)
35		#define JZ_CODEC_1_SW2_ENABLE BIT(25)
36		#define JZ_CODEC_1_DAC_ENABLE BIT(24)
37		#define JZ_CODEC_1_VREF_DISABLE BIT(20)
38		#define JZ_CODEC_1_VREF_AMP_DISABLE BIT(19)
39		#define JZ_CODEC_1_VREF_PULL_DOWN BIT(18)
40		#define JZ_CODEC_1_VREF_LOW_CURRENT BIT(17)
41		#define JZ_CODEC_1_VREF_HIGH_CURRENT BIT(16)
42		#define JZ_CODEC_1_HEADPHONE_DISABLE BIT(14)
43		#define JZ_CODEC_1_HEADPHONE_AMP_CHANGE_ANY BIT(13)
44		#define JZ_CODEC_1_HEADPHONE_CHANGE BIT(12)
45		#define JZ_CODEC_1_HEADPHONE_PULL_DOWN_M BIT(11)
46		#define JZ_CODEC_1_HEADPHONE_PULL_DOWN_R BIT(10)
47		#define JZ_CODEC_1_HEADPHONE_POWER_DOWN_M BIT(9)
48		#define JZ_CODEC_1_HEADPHONE_POWER_DOWN BIT(8)
49		#define JZ_CODEC_1_SUSPEND BIT(1)
50		#define JZ_CODEC_1_RESET BIT(0)
51
52		#define JZ_CODEC_1_LINE_ENABLE_OFFSET 29
53		#define JZ_CODEC_1_MIC_ENABLE_OFFSET 28
54		#define JZ_CODEC_1_SW1_ENABLE_OFFSET 27
55		#define JZ_CODEC_1_ADC_ENABLE_OFFSET 26
56		#define JZ_CODEC_1_SW2_ENABLE_OFFSET 25
57		#define JZ_CODEC_1_DAC_ENABLE_OFFSET 24
58		#define JZ_CODEC_1_HEADPHONE_DISABLE_OFFSET 14
59		#define JZ_CODEC_1_HEADPHONE_POWER_DOWN_OFFSET 8
60
61		#define JZ_CODEC_2_INPUT_VOLUME_MASK 0x1f0000
62		#define JZ_CODEC_2_SAMPLE_RATE_MASK 0x000f00
63		#define JZ_CODEC_2_MIC_BOOST_GAIN_MASK 0x000030
64		#define JZ_CODEC_2_HEADPHONE_VOLUME_MASK 0x000003
65
66		#define JZ_CODEC_2_INPUT_VOLUME_OFFSET 16
67		#define JZ_CODEC_2_SAMPLE_RATE_OFFSET 8
68		#define JZ_CODEC_2_MIC_BOOST_GAIN_OFFSET 4
69		#define JZ_CODEC_2_HEADPHONE_VOLUME_OFFSET 0
70
71		struct jz_codec {
72		void __iomem *base;
73		struct resource *mem;
74
75		uint32_t reg_cache[2];
76		struct snd_soc_codec codec;
77		};
78
79		static inline struct jz_codec codec_to_jz(struct snd_soc_codec codec)
80		{
81		return container_of(codec, struct jz_codec, codec);
82		}
83
84		static unsigned int jz_codec_read(struct snd_soc_codec *codec, unsigned int reg)
85		{
86		struct jz_codec *jz_codec = codec_to_jz(codec);
87		return readl(jz_codec->base + (reg << 2));
88		}
89
90		static int jz_codec_write(struct snd_soc_codec *codec, unsigned int reg,
91		unsigned int val)
92		{
93		struct jz_codec *jz_codec = codec_to_jz(codec);
94		jz_codec->reg_cache[reg] = val;
95
96		writel(val, jz_codec->base + (reg << 2));
97		return 0;
98		}
99
100		static const struct snd_kcontrol_new jz_codec_controls[] = {
101		SOC_SINGLE("Master Playback Volume", JZ_REG_CODEC_2,
102		JZ_CODEC_2_HEADPHONE_VOLUME_OFFSET, 3, 0),
103		SOC_SINGLE("Capture Volume", JZ_REG_CODEC_2,
104		JZ_CODEC_2_INPUT_VOLUME_OFFSET, 31, 0),
105		SOC_SINGLE("Master Playback Switch", JZ_REG_CODEC_1,
106		JZ_CODEC_1_HEADPHONE_DISABLE_OFFSET, 1, 1),
107		SOC_SINGLE("Mic Capture Volume", JZ_REG_CODEC_2,
108		JZ_CODEC_2_MIC_BOOST_GAIN_OFFSET, 3, 0),
109		};
110
111		static const struct snd_kcontrol_new jz_codec_output_controls[] = {
112		SOC_DAPM_SINGLE("Bypass Switch", JZ_REG_CODEC_1,
113		JZ_CODEC_1_SW1_ENABLE_OFFSET, 1, 0),
114		SOC_DAPM_SINGLE("DAC Switch", JZ_REG_CODEC_1,
115		JZ_CODEC_1_SW2_ENABLE_OFFSET, 1, 0),
116		};
117
118		static const struct snd_kcontrol_new jz_codec_input_controls[] = {
119		SOC_DAPM_SINGLE("Line Capture Switch", JZ_REG_CODEC_1,
120		JZ_CODEC_1_LINE_ENABLE_OFFSET, 1, 0),
121		SOC_DAPM_SINGLE("Mic Capture Switch", JZ_REG_CODEC_1,
122		JZ_CODEC_1_MIC_ENABLE_OFFSET, 1, 0),
123		};
124
125		static const struct snd_soc_dapm_widget jz_codec_dapm_widgets[] = {
126		SND_SOC_DAPM_ADC("ADC", "Capture", JZ_REG_CODEC_1,
127		JZ_CODEC_1_ADC_ENABLE_OFFSET, 0),
128		SND_SOC_DAPM_DAC("DAC", "Playback", JZ_REG_CODEC_1,
129		JZ_CODEC_1_DAC_ENABLE_OFFSET, 0),
130
131		SND_SOC_DAPM_MIXER("Output Mixer", JZ_REG_CODEC_1,
132		JZ_CODEC_1_HEADPHONE_POWER_DOWN_OFFSET, 1,
133		jz_codec_output_controls,
134		ARRAY_SIZE(jz_codec_output_controls)),
135
136		SND_SOC_DAPM_MIXER_NAMED_CTL("Input Mixer", SND_SOC_NOPM, 0, 0,
137		jz_codec_input_controls,
138		ARRAY_SIZE(jz_codec_input_controls)),
139		SND_SOC_DAPM_MIXER("Line Input", SND_SOC_NOPM, 0, 0, NULL, 0),
140
141		SND_SOC_DAPM_OUTPUT("LOUT"),
142		SND_SOC_DAPM_OUTPUT("ROUT"),
143
144		SND_SOC_DAPM_INPUT("MIC"),
145		SND_SOC_DAPM_INPUT("LIN"),
146		SND_SOC_DAPM_INPUT("RIN"),
147		};
148
149		static const struct snd_soc_dapm_route jz_codec_dapm_routes[] = {
150
151		{"Line Input", NULL, "LIN"},
152		{"Line Input", NULL, "RIN"},
153
154		{"Input Mixer", "Line Capture Switch", "Line Input"},
155		{"Input Mixer", "Mic Capture Switch", "MIC"},
156
157		{"ADC", NULL, "Input Mixer"},
158
159		{"Output Mixer", "Bypass Switch", "Input Mixer"},
160		{"Output Mixer", "DAC Switch", "DAC"},
161
162		{"LOUT", NULL, "Output Mixer"},
163		{"ROUT", NULL, "Output Mixer"},
164		};
165
166		static int jz_codec_hw_params(struct snd_pcm_substream *substream, struct
167		snd_pcm_hw_params params, struct snd_soc_dai dai)
168		{
169		uint32_t val;
170		struct snd_soc_pcm_runtime *rtd = substream->private_data;
171		struct snd_soc_device *socdev = rtd->socdev;
172		struct snd_soc_codec *codec = socdev->card->codec;
173
174		switch (params_format(params)) {
175		case SNDRV_PCM_FORMAT_S8:
176		case SNDRV_PCM_FORMAT_S16_LE:
177		case SNDRV_PCM_FORMAT_S18_3LE:
178		break;
179		default:
180		return -EINVAL;
181		break;
182		}
183
184		switch (params_rate(params)) {
185		case 8000:
186		val = 0;
187		break;
188		case 11025:
189		val = 1;
190		break;
191		case 12000:
192		val = 2;
193		break;
194		case 16000:
195		val = 3;
196		break;
197		case 22050:
198		val = 4;
199		break;
200		case 24000:
201		val = 5;
202		break;
203		case 32000:
204		val = 6;
205		break;
206		case 44100:
207		val = 7;
208		break;
209		case 48000:
210		val = 8;
211		break;
212		default:
213		return -EINVAL;
214		}
215
216		val <<= JZ_CODEC_2_SAMPLE_RATE_OFFSET;
217
218		snd_soc_update_bits(codec, JZ_REG_CODEC_2,
219		JZ_CODEC_2_SAMPLE_RATE_MASK, val);
220
221		return 0;
222		}
223
224		static int jz_codec_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
225		{
226		switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
227		case SND_SOC_DAIFMT_CBM_CFM:
228		break;
229		default:
230		return -EINVAL;
231		}
232
233		switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
234		case SND_SOC_DAIFMT_I2S:
235		break;
236		default:
237		return -EINVAL;
238		}
239
240		switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
241		case SND_SOC_DAIFMT_NB_NF:
242		break;
243		default:
244		return -EINVAL;
245		}
246
247		return 0;
248		}
249
250		static struct snd_soc_dai_ops jz_codec_dai_ops = {
251		.hw_params = jz_codec_hw_params,
252		.set_fmt = jz_codec_set_fmt,
253		};
254
255		struct snd_soc_dai jz_codec_dai = {
256		.name = "jz-codec",
257		.playback = {
258		.stream_name = "Playback",
259		.channels_min = 2,
260		.channels_max = 2,
261		.rates = SNDRV_PCM_RATE_8000_48000,
262		.formats = SNDRV_PCM_FMTBIT_S16_LE \| SNDRV_PCM_FMTBIT_S8,
263		},
264		.capture = {
265		.stream_name = "Capture",
266		.channels_min = 2,
267		.channels_max = 2,
268		.rates = SNDRV_PCM_RATE_8000_48000,
269		.formats = SNDRV_PCM_FMTBIT_S16_LE \| SNDRV_PCM_FMTBIT_S8,
270		},
271		.ops = &jz_codec_dai_ops,
272		.symmetric_rates = 1,
273		};
274		EXPORT_SYMBOL_GPL(jz_codec_dai);
275
276		static int jz_codec_set_bias_level(struct snd_soc_codec *codec,
277		enum snd_soc_bias_level level)
278		{
279
280		if (codec->bias_level == SND_SOC_BIAS_OFF && level != SND_SOC_BIAS_OFF) {
281		snd_soc_update_bits(codec, JZ_REG_CODEC_1,
282		JZ_CODEC_1_RESET, JZ_CODEC_1_RESET);
283		udelay(2);
284
285		snd_soc_update_bits(codec, JZ_REG_CODEC_1,
286		JZ_CODEC_1_SUSPEND \| JZ_CODEC_1_RESET, 0);
287		}
288		switch (level) {
289		case SND_SOC_BIAS_ON:
290		snd_soc_update_bits(codec, JZ_REG_CODEC_1,
291		JZ_CODEC_1_VREF_DISABLE \|
292		JZ_CODEC_1_VREF_AMP_DISABLE \|
293		JZ_CODEC_1_HEADPHONE_POWER_DOWN_M \|
294		JZ_CODEC_1_VREF_LOW_CURRENT \|
295		JZ_CODEC_1_VREF_HIGH_CURRENT,
296		0);
297		break;
298		case SND_SOC_BIAS_PREPARE:
299		snd_soc_update_bits(codec, JZ_REG_CODEC_1,
300		JZ_CODEC_1_VREF_LOW_CURRENT \|
301		JZ_CODEC_1_VREF_HIGH_CURRENT,
302		JZ_CODEC_1_VREF_LOW_CURRENT \|
303		JZ_CODEC_1_VREF_HIGH_CURRENT);
304		break;
305		case SND_SOC_BIAS_STANDBY:
306		snd_soc_update_bits(codec, JZ_REG_CODEC_1,
307		JZ_CODEC_1_VREF_DISABLE \| JZ_CODEC_1_VREF_AMP_DISABLE,
308		JZ_CODEC_1_VREF_DISABLE \| JZ_CODEC_1_VREF_AMP_DISABLE);
309		break;
310		case SND_SOC_BIAS_OFF:
311		snd_soc_update_bits(codec, JZ_REG_CODEC_1,
312		JZ_CODEC_1_SUSPEND, JZ_CODEC_1_SUSPEND);
313		break;
314		}
315		codec->bias_level = level;
316
317		return 0;
318		}
319
320
321		static struct snd_soc_codec *jz_codec_codec;
322
323		static int jz_codec_dev_probe(struct platform_device *pdev)
324		{
325		int ret;
326		struct snd_soc_device *socdev = platform_get_drvdata(pdev);
327		struct snd_soc_codec *codec = jz_codec_codec;
328
329		BUG_ON(!codec);
330
331		socdev->card->codec = codec;
332
333		ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
334		if (ret) {
335		dev_err(&pdev->dev, "Failed to create pcms: %d\n", ret);
336		return ret;
337		}
338
339		snd_soc_add_controls(codec, jz_codec_controls,
340		ARRAY_SIZE(jz_codec_controls));
341
342		snd_soc_dapm_new_controls(codec, jz_codec_dapm_widgets,
343		ARRAY_SIZE(jz_codec_dapm_widgets));
344
345		snd_soc_dapm_add_routes(codec, jz_codec_dapm_routes,
346		ARRAY_SIZE(jz_codec_dapm_routes));
347
348		snd_soc_dapm_new_widgets(codec);
349
350		return 0;
351		}
352
353		static int jz_codec_dev_remove(struct platform_device *pdev)
354		{
355		struct snd_soc_device *socdev = platform_get_drvdata(pdev);
356		snd_soc_free_pcms(socdev);
357		snd_soc_dapm_free(socdev);
358
359		return 0;
360		}
361
362		struct snd_soc_codec_device soc_codec_dev_jzcodec = {
363		.probe = jz_codec_dev_probe,
364		.remove = jz_codec_dev_remove,
365		};
366		EXPORT_SYMBOL_GPL(soc_codec_dev_jzcodec);
367
368		static int __devinit jz_codec_probe(struct platform_device *pdev)
369		{
370		int ret;
371		struct jz_codec *jz_codec;
372		struct snd_soc_codec *codec;
373
374		jz_codec = kzalloc(sizeof(*jz_codec), GFP_KERNEL);
375
376		if (!jz_codec)
377		return -ENOMEM;
378
379		jz_codec->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
380
381		if (!jz_codec->mem) {
382		dev_err(&pdev->dev, "Failed to get mmio memory resource\n");
383		ret = -ENOENT;
384		goto err_free_jz_codec;
385		}
386
387		jz_codec->mem = request_mem_region(jz_codec->mem->start,
388		resource_size(jz_codec->mem), pdev->name);
389
390		if (!jz_codec->mem) {
391		dev_err(&pdev->dev, "Failed to request mmio memory region\n");
392		ret = -EBUSY;
393		goto err_free_jz_codec;
394		}
395
396		jz_codec->base = ioremap(jz_codec->mem->start, resource_size(jz_codec->mem));
397
398		if (!jz_codec->base) {
399		dev_err(&pdev->dev, "Failed to ioremap mmio memory\n");
400		ret = -EBUSY;
401		goto err_release_mem_region;
402		}
403
404		jz_codec_dai.dev = &pdev->dev;
405
406		codec = &jz_codec->codec;
407
408		codec->dev = &pdev->dev;
409		codec->name = "jz-codec";
410		codec->owner = THIS_MODULE;
411
412		codec->read = jz_codec_read;
413		codec->write = jz_codec_write;
414		codec->set_bias_level = jz_codec_set_bias_level;
415		codec->bias_level = SND_SOC_BIAS_OFF;
416
417		codec->dai = &jz_codec_dai;
418		codec->num_dai = 1;
419
420		codec->reg_cache = jz_codec->reg_cache;
421		codec->reg_cache_size = 2;
422
423		codec->private_data = jz_codec;
424
425		mutex_init(&codec->mutex);
426		INIT_LIST_HEAD(&codec->dapm_widgets);
427		INIT_LIST_HEAD(&codec->dapm_paths);
428
429		jz_codec_codec = codec;
430
431		snd_soc_update_bits(codec, JZ_REG_CODEC_1,
432		JZ_CODEC_1_SW2_ENABLE, JZ_CODEC_1_SW2_ENABLE);
433
434
435		platform_set_drvdata(pdev, jz_codec);
436		ret = snd_soc_register_codec(codec);
437
438		if (ret) {
439		dev_err(&pdev->dev, "Failed to register codec\n");
440		goto err_iounmap;
441		}
442
443		ret = snd_soc_register_dai(&jz_codec_dai);
444		if (ret) {
445		dev_err(&pdev->dev, "Failed to register codec dai\n");
446		goto err_unregister_codec;
447		}
448
449		jz_codec_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
450
451		return 0;
452		err_unregister_codec:
453		snd_soc_unregister_codec(codec);
454		err_iounmap:
455		iounmap(jz_codec->base);
456		err_release_mem_region:
457		release_mem_region(jz_codec->mem->start, resource_size(jz_codec->mem));
458		err_free_jz_codec:
459		kfree(jz_codec);
460
461		return ret;
462		}
463
464		static int __devexit jz_codec_remove(struct platform_device *pdev)
465		{
466		struct jz_codec *jz_codec = platform_get_drvdata(pdev);
467
468		snd_soc_unregister_dai(&jz_codec_dai);
469		snd_soc_unregister_codec(&jz_codec->codec);
470
471		iounmap(jz_codec->base);
472		release_mem_region(jz_codec->mem->start, resource_size(jz_codec->mem));
473
474		platform_set_drvdata(pdev, NULL);
475		kfree(jz_codec);
476
477		return 0;
478		}
479
480		static struct platform_driver jz_codec_driver = {
481		.probe = jz_codec_probe,
482		.remove = __devexit_p(jz_codec_remove),
483		.driver = {
484		.name = "jz4740-codec",
485		.owner = THIS_MODULE,
486		},
487		};
488
489		static int __init jz_codec_init(void)
490		{
491		return platform_driver_register(&jz_codec_driver);
492		}
493		module_init(jz_codec_init);
494
495		static void __exit jz_codec_exit(void)
496		{
497		platform_driver_unregister(&jz_codec_driver);
498		}
499		module_exit(jz_codec_exit);
500
501		MODULE_DESCRIPTION("JZ4720/JZ4740 SoC internal codec driver");
502		MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
503		MODULE_LICENSE("GPL v2");
504		MODULE_ALIAS("platform:jz-codec");

sound/soc/codecs/jzcodec.h
1		/*
2		* Copyright (C) 2009, Lars-Peter Clausen <lars@metafoo.de>
3		*
4		* This program is free software; you can redistribute it and/or modify
5		* it under the terms of the GNU General Public License version 2 as
6		* published by the Free Software Foundation.
7		*
8		* You should have received a copy of the GNU General Public License along
9		* with this program; if not, write to the Free Software Foundation, Inc.,
10		* 675 Mass Ave, Cambridge, MA 02139, USA.
11		*
12		*/
13
14		#ifndef _ICODEC_H
15		#define _ICODEC_H
16
17		extern struct snd_soc_dai jz_codec_dai;
18		extern struct snd_soc_codec_device soc_codec_dev_jzcodec;
19
20		#endif

sound/soc/jz4740/Kconfig
16	16	tristate "SoC Audio support for Qi Hardware Ben Nanonote"
17	17	depends on SND_JZ4740_SOC && JZ4740_QI_LB60
18	18	select SND_JZ4740_SOC_I2S
19		select SND_SOC_JZCODEC
	19	select SND_SOC_JZ4740_CODEC
20	20	help
21	21	Say Y if you want to add support for SoC audio of internal codec on Ingenic Jz4740 QI_LB60 board.
22	22
...	...
24	24	tristate "SoC Audio support for Hanvon N516 eBook reader"
25	25	depends on SND_JZ4740_SOC && JZ4740_N516
26	26	select SND_JZ4740_SOC_I2S
27		select SND_SOC_JZCODEC
	27	select SND_SOC_JZ4740_CODEC
28	28	help
29	29	Say Y if you want to enable support for SoC audio on the Hanvon N516.
30	30
...	...
32	32	tristate "SoC Audio support for Hanvon N526 eBook reader"
33	33	depends on SND_JZ4740_SOC && JZ4740_N526
34	34	select SND_JZ4740_SOC_I2S
35		select SND_SOC_JZCODEC
	35	select SND_SOC_JZ4740_CODEC
36	36	help
37	37	Say Y if you want to enable support for SoC audio on the Hanvon N526.

sound/soc/jz4740/n516.c
24	24	#include <linux/gpio.h>
25	25	#include <linux/workqueue.h>
26	26
27		#include "../codecs/jzcodec.h"
	27	#include "../codecs/jz4740-codec.h"
28	28	#include "jz4740-pcm.h"
29	29	#include "jz4740-i2s.h"
30	30
...	...
185	185	}
186	186
187	187	static struct snd_soc_dai_link n516_dai = {
188		.name = "jz-codec",
189		.stream_name = "JZCODEC",
	188	.name = "jz4740-codec",
	189	.stream_name = "jz4740-codec",
190	190	.cpu_dai = &jz4740_i2s_dai,
191		.codec_dai = &jz_codec_dai,
	191	.codec_dai = &jz4740_codec_dai,
192	192	.init = n516_codec_init,
193	193	};
194	194
...	...
201	201
202	202	static struct snd_soc_device n516_snd_devdata = {
203	203	.card = &n516_card,
204		.codec_dev = &soc_codec_dev_jzcodec,
	204	.codec_dev = &soc_codec_dev_jz4740_codec,
205	205	};
206	206
207	207	static struct platform_device *n516_snd_device;

sound/soc/jz4740/n526.c
22	22	#include <sound/soc-dapm.h>
23	23	#include <linux/gpio.h>
24	24
25		#include "../codecs/jzcodec.h"
	25	#include "../codecs/jz4740-codec.h"
26	26	#include "jz4740-pcm.h"
27	27	#include "jz4740-i2s.h"
28	28
...	...
91	91	}
92	92
93	93	static struct snd_soc_dai_link n526_dai = {
94		.name = "jz-codec",
95		.stream_name = "JZCODEC",
	94	.name = "jz4740-codec",
	95	.stream_name = "jz4740-codec",
96	96	.cpu_dai = &jz4740_i2s_dai,
97		.codec_dai = &jz_codec_dai,
	97	.codec_dai = &jz4740_codec_dai,
98	98	.init = n526_codec_init,
99	99	};
100	100
...	...
107	107
108	108	static struct snd_soc_device n526_snd_devdata = {
109	109	.card = &n526,
110		.codec_dev = &soc_codec_dev_jzcodec,
	110	.codec_dev = &soc_codec_dev_jz4740_codec,
111	111	};
112	112
113	113	static struct platform_device *n526_snd_device;

sound/soc/jz4740/qi_lb60.c
22	22	#include <sound/soc-dapm.h>
23	23	#include <linux/gpio.h>
24	24
25		#include "../codecs/jzcodec.h"
	25	#include "../codecs/jz4740-codec.h"
26	26	#include "jz4740-pcm.h"
27	27	#include "jz4740-i2s.h"
28	28
...	...
91	91	}
92	92
93	93	static struct snd_soc_dai_link qi_lb60_dai = {
94		.name = "jz-codec",
95		.stream_name = "JZCODEC",
	94	.name = "jz4740-codec",
	95	.stream_name = "jz4740-codec",
96	96	.cpu_dai = &jz4740_i2s_dai,
97		.codec_dai = &jz_codec_dai,
	97	.codec_dai = &jz4740_codec_dai,
98	98	.init = qi_lb60_codec_init,
99	99	};
100	100
...	...
107	107
108	108	static struct snd_soc_device qi_lb60_snd_devdata = {
109	109	.card = &qi_lb60,
110		.codec_dev = &soc_codec_dev_jzcodec,
	110	.codec_dev = &soc_codec_dev_jz4740_codec,
111	111	};
112	112
113	113	static struct platform_device *qi_lb60_snd_device;

Download the corresponding diff file

Branches:
ben-wpan
ben-wpan-stefan
5396a9238205f20f811ea57898980d3ca82df0b6
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Commit Details

Change Details

interactive