aboutsummaryrefslogtreecommitdiffstats
path: root/sound/soc/s3c24xx
diff options
context:
space:
mode:
Diffstat (limited to 'sound/soc/s3c24xx')
-rw-r--r--sound/soc/s3c24xx/Kconfig133
-rw-r--r--sound/soc/s3c24xx/Makefile45
-rw-r--r--sound/soc/s3c24xx/jive_wm8750.c196
-rw-r--r--sound/soc/s3c24xx/lm4857.h32
-rw-r--r--sound/soc/s3c24xx/ln2440sbc_alc650.c85
-rw-r--r--sound/soc/s3c24xx/neo1973_gta02_wm8753.c506
-rw-r--r--sound/soc/s3c24xx/neo1973_wm8753.c707
-rw-r--r--sound/soc/s3c24xx/regs-i2s-v2.h115
-rw-r--r--sound/soc/s3c24xx/s3c-ac97.c520
-rw-r--r--sound/soc/s3c24xx/s3c-ac97.h23
-rw-r--r--sound/soc/s3c24xx/s3c-dma.c482
-rw-r--r--sound/soc/s3c24xx/s3c-dma.h31
-rw-r--r--sound/soc/s3c24xx/s3c-i2s-v2.c777
-rw-r--r--sound/soc/s3c24xx/s3c-i2s-v2.h103
-rw-r--r--sound/soc/s3c24xx/s3c-pcm.c554
-rw-r--r--sound/soc/s3c24xx/s3c-pcm.h123
-rw-r--r--sound/soc/s3c24xx/s3c2412-i2s.c190
-rw-r--r--sound/soc/s3c24xx/s3c2412-i2s.h29
-rw-r--r--sound/soc/s3c24xx/s3c24xx-i2s.c503
-rw-r--r--sound/soc/s3c24xx/s3c24xx-i2s.h37
-rw-r--r--sound/soc/s3c24xx/s3c24xx_simtec.c394
-rw-r--r--sound/soc/s3c24xx/s3c24xx_simtec.h22
-rw-r--r--sound/soc/s3c24xx/s3c24xx_simtec_hermes.c153
-rw-r--r--sound/soc/s3c24xx/s3c24xx_simtec_tlv320aic23.c137
-rw-r--r--sound/soc/s3c24xx/s3c24xx_uda134x.c373
-rw-r--r--sound/soc/s3c24xx/s3c64xx-i2s-v4.c209
-rw-r--r--sound/soc/s3c24xx/s3c64xx-i2s.c190
-rw-r--r--sound/soc/s3c24xx/s3c64xx-i2s.h42
-rw-r--r--sound/soc/s3c24xx/smartq_wm8987.c295
-rw-r--r--sound/soc/s3c24xx/smdk2443_wm9710.c81
-rw-r--r--sound/soc/s3c24xx/smdk64xx_wm8580.c266
-rw-r--r--sound/soc/s3c24xx/smdk_wm9713.c97
32 files changed, 0 insertions, 7450 deletions
diff --git a/sound/soc/s3c24xx/Kconfig b/sound/soc/s3c24xx/Kconfig
deleted file mode 100644
index 213963ac3c28..000000000000
--- a/sound/soc/s3c24xx/Kconfig
+++ /dev/null
@@ -1,133 +0,0 @@
1config SND_S3C24XX_SOC
2 tristate "SoC Audio for the Samsung S3CXXXX chips"
3 depends on ARCH_S3C2410 || ARCH_S3C64XX || ARCH_S5PC100 || ARCH_S5PV210
4 select S3C64XX_DMA if ARCH_S3C64XX
5 help
6 Say Y or M if you want to add support for codecs attached to
7 the S3C24XX AC97 or I2S interfaces. You will also need to
8 select the audio interfaces to support below.
9
10config SND_S3C24XX_SOC_I2S
11 tristate
12 select S3C2410_DMA
13
14config SND_S3C_I2SV2_SOC
15 tristate
16
17config SND_S3C2412_SOC_I2S
18 tristate
19 select SND_S3C_I2SV2_SOC
20 select S3C2410_DMA
21
22config SND_S3C64XX_SOC_I2S
23 tristate
24 select SND_S3C_I2SV2_SOC
25 select S3C64XX_DMA
26
27config SND_S3C64XX_SOC_I2S_V4
28 tristate
29 select SND_S3C_I2SV2_SOC
30 select S3C64XX_DMA
31
32config SND_S3C_SOC_PCM
33 tristate
34
35config SND_S3C_SOC_AC97
36 tristate
37 select SND_SOC_AC97_BUS
38
39config SND_S3C24XX_SOC_NEO1973_WM8753
40 tristate "SoC I2S Audio support for NEO1973 - WM8753"
41 depends on SND_S3C24XX_SOC && MACH_NEO1973_GTA01
42 select SND_S3C24XX_SOC_I2S
43 select SND_SOC_WM8753
44 help
45 Say Y if you want to add support for SoC audio on smdk2440
46 with the WM8753.
47
48config SND_S3C24XX_SOC_NEO1973_GTA02_WM8753
49 tristate "Audio support for the Openmoko Neo FreeRunner (GTA02)"
50 depends on SND_S3C24XX_SOC && MACH_NEO1973_GTA02
51 select SND_S3C24XX_SOC_I2S
52 select SND_SOC_WM8753
53 help
54 This driver provides audio support for the Openmoko Neo FreeRunner
55 smartphone.
56
57config SND_S3C24XX_SOC_JIVE_WM8750
58 tristate "SoC I2S Audio support for Jive"
59 depends on SND_S3C24XX_SOC && MACH_JIVE
60 select SND_SOC_WM8750
61 select SND_S3C2412_SOC_I2S
62 help
63 Sat Y if you want to add support for SoC audio on the Jive.
64
65config SND_S3C64XX_SOC_WM8580
66 tristate "SoC I2S Audio support for WM8580 on SMDK64XX"
67 depends on SND_S3C24XX_SOC && MACH_SMDK6410
68 select SND_SOC_WM8580
69 select SND_S3C64XX_SOC_I2S_V4
70 help
71 Say Y if you want to add support for SoC audio on the SMDK6410.
72
73config SND_S3C24XX_SOC_SMDK2443_WM9710
74 tristate "SoC AC97 Audio support for SMDK2443 - WM9710"
75 depends on SND_S3C24XX_SOC && MACH_SMDK2443
76 select S3C2410_DMA
77 select AC97_BUS
78 select SND_SOC_AC97_CODEC
79 select SND_S3C_SOC_AC97
80 help
81 Say Y if you want to add support for SoC audio on smdk2443
82 with the WM9710.
83
84config SND_S3C24XX_SOC_LN2440SBC_ALC650
85 tristate "SoC AC97 Audio support for LN2440SBC - ALC650"
86 depends on SND_S3C24XX_SOC && ARCH_S3C2410
87 select S3C2410_DMA
88 select AC97_BUS
89 select SND_SOC_AC97_CODEC
90 select SND_S3C_SOC_AC97
91 help
92 Say Y if you want to add support for SoC audio on ln2440sbc
93 with the ALC650.
94
95config SND_S3C24XX_SOC_S3C24XX_UDA134X
96 tristate "SoC I2S Audio support UDA134X wired to a S3C24XX"
97 depends on SND_S3C24XX_SOC && ARCH_S3C2410
98 select SND_S3C24XX_SOC_I2S
99 select SND_SOC_L3
100 select SND_SOC_UDA134X
101
102config SND_S3C24XX_SOC_SIMTEC
103 tristate
104 help
105 Internal node for common S3C24XX/Simtec suppor
106
107config SND_S3C24XX_SOC_SIMTEC_TLV320AIC23
108 tristate "SoC I2S Audio support for TLV320AIC23 on Simtec boards"
109 depends on SND_S3C24XX_SOC && ARCH_S3C2410
110 select SND_S3C24XX_SOC_I2S
111 select SND_SOC_TLV320AIC23
112 select SND_S3C24XX_SOC_SIMTEC
113
114config SND_S3C24XX_SOC_SIMTEC_HERMES
115 tristate "SoC I2S Audio support for Simtec Hermes board"
116 depends on SND_S3C24XX_SOC && ARCH_S3C2410
117 select SND_S3C24XX_SOC_I2S
118 select SND_SOC_TLV320AIC3X
119 select SND_S3C24XX_SOC_SIMTEC
120
121config SND_SOC_SMDK_WM9713
122 tristate "SoC AC97 Audio support for SMDK with WM9713"
123 depends on SND_S3C24XX_SOC && (MACH_SMDK6410 || MACH_SMDKC100 || MACH_SMDKV210 || MACH_SMDKC110)
124 select SND_SOC_WM9713
125 select SND_S3C_SOC_AC97
126 help
127 Sat Y if you want to add support for SoC audio on the SMDK.
128
129config SND_S3C64XX_SOC_SMARTQ
130 tristate "SoC I2S Audio support for SmartQ board"
131 depends on SND_S3C24XX_SOC && MACH_SMARTQ
132 select SND_S3C64XX_SOC_I2S
133 select SND_SOC_WM8750
diff --git a/sound/soc/s3c24xx/Makefile b/sound/soc/s3c24xx/Makefile
deleted file mode 100644
index 50172c385d90..000000000000
--- a/sound/soc/s3c24xx/Makefile
+++ /dev/null
@@ -1,45 +0,0 @@
1# S3c24XX Platform Support
2snd-soc-s3c24xx-objs := s3c-dma.o
3snd-soc-s3c24xx-i2s-objs := s3c24xx-i2s.o
4snd-soc-s3c2412-i2s-objs := s3c2412-i2s.o
5snd-soc-s3c64xx-i2s-objs := s3c64xx-i2s.o
6snd-soc-s3c-ac97-objs := s3c-ac97.o
7snd-soc-s3c64xx-i2s-v4-objs := s3c64xx-i2s-v4.o
8snd-soc-s3c-i2s-v2-objs := s3c-i2s-v2.o
9snd-soc-s3c-pcm-objs := s3c-pcm.o
10
11obj-$(CONFIG_SND_S3C24XX_SOC) += snd-soc-s3c24xx.o
12obj-$(CONFIG_SND_S3C24XX_SOC_I2S) += snd-soc-s3c24xx-i2s.o
13obj-$(CONFIG_SND_S3C_SOC_AC97) += snd-soc-s3c-ac97.o
14obj-$(CONFIG_SND_S3C2412_SOC_I2S) += snd-soc-s3c2412-i2s.o
15obj-$(CONFIG_SND_S3C64XX_SOC_I2S) += snd-soc-s3c64xx-i2s.o
16obj-$(CONFIG_SND_S3C64XX_SOC_I2S_V4) += snd-soc-s3c64xx-i2s-v4.o
17obj-$(CONFIG_SND_S3C_I2SV2_SOC) += snd-soc-s3c-i2s-v2.o
18obj-$(CONFIG_SND_S3C_SOC_PCM) += snd-soc-s3c-pcm.o
19
20# S3C24XX Machine Support
21snd-soc-jive-wm8750-objs := jive_wm8750.o
22snd-soc-neo1973-wm8753-objs := neo1973_wm8753.o
23snd-soc-neo1973-gta02-wm8753-objs := neo1973_gta02_wm8753.o
24snd-soc-smdk2443-wm9710-objs := smdk2443_wm9710.o
25snd-soc-ln2440sbc-alc650-objs := ln2440sbc_alc650.o
26snd-soc-s3c24xx-uda134x-objs := s3c24xx_uda134x.o
27snd-soc-s3c24xx-simtec-objs := s3c24xx_simtec.o
28snd-soc-s3c24xx-simtec-hermes-objs := s3c24xx_simtec_hermes.o
29snd-soc-s3c24xx-simtec-tlv320aic23-objs := s3c24xx_simtec_tlv320aic23.o
30snd-soc-smdk64xx-wm8580-objs := smdk64xx_wm8580.o
31snd-soc-smdk-wm9713-objs := smdk_wm9713.o
32snd-soc-s3c64xx-smartq-wm8987-objs := smartq_wm8987.o
33
34obj-$(CONFIG_SND_S3C24XX_SOC_JIVE_WM8750) += snd-soc-jive-wm8750.o
35obj-$(CONFIG_SND_S3C24XX_SOC_NEO1973_WM8753) += snd-soc-neo1973-wm8753.o
36obj-$(CONFIG_SND_S3C24XX_SOC_NEO1973_GTA02_WM8753) += snd-soc-neo1973-gta02-wm8753.o
37obj-$(CONFIG_SND_S3C24XX_SOC_SMDK2443_WM9710) += snd-soc-smdk2443-wm9710.o
38obj-$(CONFIG_SND_S3C24XX_SOC_LN2440SBC_ALC650) += snd-soc-ln2440sbc-alc650.o
39obj-$(CONFIG_SND_S3C24XX_SOC_S3C24XX_UDA134X) += snd-soc-s3c24xx-uda134x.o
40obj-$(CONFIG_SND_S3C24XX_SOC_SIMTEC) += snd-soc-s3c24xx-simtec.o
41obj-$(CONFIG_SND_S3C24XX_SOC_SIMTEC_HERMES) += snd-soc-s3c24xx-simtec-hermes.o
42obj-$(CONFIG_SND_S3C24XX_SOC_SIMTEC_TLV320AIC23) += snd-soc-s3c24xx-simtec-tlv320aic23.o
43obj-$(CONFIG_SND_S3C64XX_SOC_WM8580) += snd-soc-smdk64xx-wm8580.o
44obj-$(CONFIG_SND_SOC_SMDK_WM9713) += snd-soc-smdk-wm9713.o
45obj-$(CONFIG_SND_S3C64XX_SOC_SMARTQ) += snd-soc-s3c64xx-smartq-wm8987.o
diff --git a/sound/soc/s3c24xx/jive_wm8750.c b/sound/soc/s3c24xx/jive_wm8750.c
deleted file mode 100644
index 8c108b121c10..000000000000
--- a/sound/soc/s3c24xx/jive_wm8750.c
+++ /dev/null
@@ -1,196 +0,0 @@
1/* sound/soc/s3c24xx/jive_wm8750.c
2 *
3 * Copyright 2007,2008 Simtec Electronics
4 *
5 * Based on sound/soc/pxa/spitz.c
6 * Copyright 2005 Wolfson Microelectronics PLC.
7 * Copyright 2005 Openedhand Ltd.
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12*/
13
14#include <linux/module.h>
15#include <linux/moduleparam.h>
16#include <linux/timer.h>
17#include <linux/interrupt.h>
18#include <linux/platform_device.h>
19#include <linux/clk.h>
20
21#include <sound/core.h>
22#include <sound/pcm.h>
23#include <sound/soc.h>
24#include <sound/soc-dapm.h>
25
26#include <asm/mach-types.h>
27
28#include "s3c-dma.h"
29#include "s3c2412-i2s.h"
30
31#include "../codecs/wm8750.h"
32
33static const struct snd_soc_dapm_route audio_map[] = {
34 { "Headphone Jack", NULL, "LOUT1" },
35 { "Headphone Jack", NULL, "ROUT1" },
36 { "Internal Speaker", NULL, "LOUT2" },
37 { "Internal Speaker", NULL, "ROUT2" },
38 { "LINPUT1", NULL, "Line Input" },
39 { "RINPUT1", NULL, "Line Input" },
40};
41
42static const struct snd_soc_dapm_widget wm8750_dapm_widgets[] = {
43 SND_SOC_DAPM_HP("Headphone Jack", NULL),
44 SND_SOC_DAPM_SPK("Internal Speaker", NULL),
45 SND_SOC_DAPM_LINE("Line In", NULL),
46};
47
48static int jive_hw_params(struct snd_pcm_substream *substream,
49 struct snd_pcm_hw_params *params)
50{
51 struct snd_soc_pcm_runtime *rtd = substream->private_data;
52 struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
53 struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
54 struct s3c_i2sv2_rate_calc div;
55 unsigned int clk = 0;
56 int ret = 0;
57
58 switch (params_rate(params)) {
59 case 8000:
60 case 16000:
61 case 48000:
62 case 96000:
63 clk = 12288000;
64 break;
65 case 11025:
66 case 22050:
67 case 44100:
68 clk = 11289600;
69 break;
70 }
71
72 s3c_i2sv2_iis_calc_rate(&div, NULL, params_rate(params),
73 s3c_i2sv2_get_clock(cpu_dai));
74
75 /* set codec DAI configuration */
76 ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S |
77 SND_SOC_DAIFMT_NB_NF |
78 SND_SOC_DAIFMT_CBS_CFS);
79 if (ret < 0)
80 return ret;
81
82 /* set cpu DAI configuration */
83 ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S |
84 SND_SOC_DAIFMT_NB_NF |
85 SND_SOC_DAIFMT_CBS_CFS);
86 if (ret < 0)
87 return ret;
88
89 /* set the codec system clock for DAC and ADC */
90 ret = snd_soc_dai_set_sysclk(codec_dai, WM8750_SYSCLK, clk,
91 SND_SOC_CLOCK_IN);
92 if (ret < 0)
93 return ret;
94
95 ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C2412_DIV_RCLK, div.fs_div);
96 if (ret < 0)
97 return ret;
98
99 ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C2412_DIV_PRESCALER,
100 div.clk_div - 1);
101 if (ret < 0)
102 return ret;
103
104 return 0;
105}
106
107static struct snd_soc_ops jive_ops = {
108 .hw_params = jive_hw_params,
109};
110
111static int jive_wm8750_init(struct snd_soc_codec *codec)
112{
113 int err;
114
115 /* These endpoints are not being used. */
116 snd_soc_dapm_nc_pin(codec, "LINPUT2");
117 snd_soc_dapm_nc_pin(codec, "RINPUT2");
118 snd_soc_dapm_nc_pin(codec, "LINPUT3");
119 snd_soc_dapm_nc_pin(codec, "RINPUT3");
120 snd_soc_dapm_nc_pin(codec, "OUT3");
121 snd_soc_dapm_nc_pin(codec, "MONO");
122
123 /* Add jive specific widgets */
124 err = snd_soc_dapm_new_controls(codec, wm8750_dapm_widgets,
125 ARRAY_SIZE(wm8750_dapm_widgets));
126 if (err) {
127 printk(KERN_ERR "%s: failed to add widgets (%d)\n",
128 __func__, err);
129 return err;
130 }
131
132 snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
133 snd_soc_dapm_sync(codec);
134
135 return 0;
136}
137
138static struct snd_soc_dai_link jive_dai = {
139 .name = "wm8750",
140 .stream_name = "WM8750",
141 .cpu_dai = &s3c2412_i2s_dai,
142 .codec_dai = &wm8750_dai,
143 .init = jive_wm8750_init,
144 .ops = &jive_ops,
145};
146
147/* jive audio machine driver */
148static struct snd_soc_card snd_soc_machine_jive = {
149 .name = "Jive",
150 .platform = &s3c24xx_soc_platform,
151 .dai_link = &jive_dai,
152 .num_links = 1,
153};
154
155/* jive audio subsystem */
156static struct snd_soc_device jive_snd_devdata = {
157 .card = &snd_soc_machine_jive,
158 .codec_dev = &soc_codec_dev_wm8750,
159};
160
161static struct platform_device *jive_snd_device;
162
163static int __init jive_init(void)
164{
165 int ret;
166
167 if (!machine_is_jive())
168 return 0;
169
170 printk("JIVE WM8750 Audio support\n");
171
172 jive_snd_device = platform_device_alloc("soc-audio", -1);
173 if (!jive_snd_device)
174 return -ENOMEM;
175
176 platform_set_drvdata(jive_snd_device, &jive_snd_devdata);
177 jive_snd_devdata.dev = &jive_snd_device->dev;
178 ret = platform_device_add(jive_snd_device);
179
180 if (ret)
181 platform_device_put(jive_snd_device);
182
183 return ret;
184}
185
186static void __exit jive_exit(void)
187{
188 platform_device_unregister(jive_snd_device);
189}
190
191module_init(jive_init);
192module_exit(jive_exit);
193
194MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
195MODULE_DESCRIPTION("ALSA SoC Jive Audio support");
196MODULE_LICENSE("GPL");
diff --git a/sound/soc/s3c24xx/lm4857.h b/sound/soc/s3c24xx/lm4857.h
deleted file mode 100644
index 0cf5b7011d6f..000000000000
--- a/sound/soc/s3c24xx/lm4857.h
+++ /dev/null
@@ -1,32 +0,0 @@
1/*
2 * lm4857.h -- ALSA Soc Audio Layer
3 *
4 * Copyright 2007 Wolfson Microelectronics PLC.
5 * Author: Graeme Gregory
6 * graeme.gregory@wolfsonmicro.com or linux@wolfsonmicro.com
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
12 *
13 * Revision history
14 * 18th Jun 2007 Initial version.
15 */
16
17#ifndef LM4857_H_
18#define LM4857_H_
19
20/* The register offsets in the cache array */
21#define LM4857_MVOL 0
22#define LM4857_LVOL 1
23#define LM4857_RVOL 2
24#define LM4857_CTRL 3
25
26/* the shifts required to set these bits */
27#define LM4857_3D 5
28#define LM4857_WAKEUP 5
29#define LM4857_EPGAIN 4
30
31#endif /*LM4857_H_*/
32
diff --git a/sound/soc/s3c24xx/ln2440sbc_alc650.c b/sound/soc/s3c24xx/ln2440sbc_alc650.c
deleted file mode 100644
index ffa954fe6931..000000000000
--- a/sound/soc/s3c24xx/ln2440sbc_alc650.c
+++ /dev/null
@@ -1,85 +0,0 @@
1/*
2 * SoC audio for ln2440sbc
3 *
4 * Copyright 2007 KonekTel, a.s.
5 * Author: Ivan Kuten
6 * ivan.kuten@promwad.com
7 *
8 * Heavily based on smdk2443_wm9710.c
9 * Copyright 2007 Wolfson Microelectronics PLC.
10 * Author: Graeme Gregory
11 * graeme.gregory@wolfsonmicro.com or linux@wolfsonmicro.com
12 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License version 2 as
15 * published by the Free Software Foundation.
16 *
17 */
18
19#include <linux/module.h>
20#include <linux/device.h>
21#include <sound/core.h>
22#include <sound/pcm.h>
23#include <sound/soc.h>
24#include <sound/soc-dapm.h>
25
26#include "../codecs/ac97.h"
27#include "s3c-dma.h"
28#include "s3c-ac97.h"
29
30static struct snd_soc_card ln2440sbc;
31
32static struct snd_soc_dai_link ln2440sbc_dai[] = {
33{
34 .name = "AC97",
35 .stream_name = "AC97 HiFi",
36 .cpu_dai = &s3c_ac97_dai[S3C_AC97_DAI_PCM],
37 .codec_dai = &ac97_dai,
38},
39};
40
41static struct snd_soc_card ln2440sbc = {
42 .name = "LN2440SBC",
43 .platform = &s3c24xx_soc_platform,
44 .dai_link = ln2440sbc_dai,
45 .num_links = ARRAY_SIZE(ln2440sbc_dai),
46};
47
48static struct snd_soc_device ln2440sbc_snd_ac97_devdata = {
49 .card = &ln2440sbc,
50 .codec_dev = &soc_codec_dev_ac97,
51};
52
53static struct platform_device *ln2440sbc_snd_ac97_device;
54
55static int __init ln2440sbc_init(void)
56{
57 int ret;
58
59 ln2440sbc_snd_ac97_device = platform_device_alloc("soc-audio", -1);
60 if (!ln2440sbc_snd_ac97_device)
61 return -ENOMEM;
62
63 platform_set_drvdata(ln2440sbc_snd_ac97_device,
64 &ln2440sbc_snd_ac97_devdata);
65 ln2440sbc_snd_ac97_devdata.dev = &ln2440sbc_snd_ac97_device->dev;
66 ret = platform_device_add(ln2440sbc_snd_ac97_device);
67
68 if (ret)
69 platform_device_put(ln2440sbc_snd_ac97_device);
70
71 return ret;
72}
73
74static void __exit ln2440sbc_exit(void)
75{
76 platform_device_unregister(ln2440sbc_snd_ac97_device);
77}
78
79module_init(ln2440sbc_init);
80module_exit(ln2440sbc_exit);
81
82/* Module information */
83MODULE_AUTHOR("Ivan Kuten");
84MODULE_DESCRIPTION("ALSA SoC ALC650 LN2440SBC");
85MODULE_LICENSE("GPL");
diff --git a/sound/soc/s3c24xx/neo1973_gta02_wm8753.c b/sound/soc/s3c24xx/neo1973_gta02_wm8753.c
deleted file mode 100644
index 209c25994c7e..000000000000
--- a/sound/soc/s3c24xx/neo1973_gta02_wm8753.c
+++ /dev/null
@@ -1,506 +0,0 @@
1/*
2 * neo1973_gta02_wm8753.c -- SoC audio for Openmoko Freerunner(GTA02)
3 *
4 * Copyright 2007 Openmoko Inc
5 * Author: Graeme Gregory <graeme@openmoko.org>
6 * Copyright 2007 Wolfson Microelectronics PLC.
7 * Author: Graeme Gregory <linux@wolfsonmicro.com>
8 * Copyright 2009 Wolfson Microelectronics
9 *
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the
12 * Free Software Foundation; either version 2 of the License, or (at your
13 * option) any later version.
14 */
15
16#include <linux/module.h>
17#include <linux/moduleparam.h>
18#include <linux/timer.h>
19#include <linux/interrupt.h>
20#include <linux/platform_device.h>
21#include <linux/gpio.h>
22#include <sound/core.h>
23#include <sound/pcm.h>
24#include <sound/soc.h>
25#include <sound/soc-dapm.h>
26
27#include <asm/mach-types.h>
28
29#include <plat/regs-iis.h>
30
31#include <mach/regs-clock.h>
32#include <asm/io.h>
33#include <mach/gta02.h>
34#include "../codecs/wm8753.h"
35#include "s3c-dma.h"
36#include "s3c24xx-i2s.h"
37
38static struct snd_soc_card neo1973_gta02;
39
40static int neo1973_gta02_hifi_hw_params(struct snd_pcm_substream *substream,
41 struct snd_pcm_hw_params *params)
42{
43 struct snd_soc_pcm_runtime *rtd = substream->private_data;
44 struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
45 struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
46 unsigned int pll_out = 0, bclk = 0;
47 int ret = 0;
48 unsigned long iis_clkrate;
49
50 iis_clkrate = s3c24xx_i2s_get_clockrate();
51
52 switch (params_rate(params)) {
53 case 8000:
54 case 16000:
55 pll_out = 12288000;
56 break;
57 case 48000:
58 bclk = WM8753_BCLK_DIV_4;
59 pll_out = 12288000;
60 break;
61 case 96000:
62 bclk = WM8753_BCLK_DIV_2;
63 pll_out = 12288000;
64 break;
65 case 11025:
66 bclk = WM8753_BCLK_DIV_16;
67 pll_out = 11289600;
68 break;
69 case 22050:
70 bclk = WM8753_BCLK_DIV_8;
71 pll_out = 11289600;
72 break;
73 case 44100:
74 bclk = WM8753_BCLK_DIV_4;
75 pll_out = 11289600;
76 break;
77 case 88200:
78 bclk = WM8753_BCLK_DIV_2;
79 pll_out = 11289600;
80 break;
81 }
82
83 /* set codec DAI configuration */
84 ret = snd_soc_dai_set_fmt(codec_dai,
85 SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
86 SND_SOC_DAIFMT_CBM_CFM);
87 if (ret < 0)
88 return ret;
89
90 /* set cpu DAI configuration */
91 ret = snd_soc_dai_set_fmt(cpu_dai,
92 SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
93 SND_SOC_DAIFMT_CBM_CFM);
94 if (ret < 0)
95 return ret;
96
97 /* set the codec system clock for DAC and ADC */
98 ret = snd_soc_dai_set_sysclk(codec_dai, WM8753_MCLK, pll_out,
99 SND_SOC_CLOCK_IN);
100 if (ret < 0)
101 return ret;
102
103 /* set MCLK division for sample rate */
104 ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C24XX_DIV_MCLK,
105 S3C2410_IISMOD_32FS);
106 if (ret < 0)
107 return ret;
108
109 /* set codec BCLK division for sample rate */
110 ret = snd_soc_dai_set_clkdiv(codec_dai,
111 WM8753_BCLKDIV, bclk);
112 if (ret < 0)
113 return ret;
114
115 /* set prescaler division for sample rate */
116 ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C24XX_DIV_PRESCALER,
117 S3C24XX_PRESCALE(4, 4));
118 if (ret < 0)
119 return ret;
120
121 /* codec PLL input is PCLK/4 */
122 ret = snd_soc_dai_set_pll(codec_dai, WM8753_PLL1, 0,
123 iis_clkrate / 4, pll_out);
124 if (ret < 0)
125 return ret;
126
127 return 0;
128}
129
130static int neo1973_gta02_hifi_hw_free(struct snd_pcm_substream *substream)
131{
132 struct snd_soc_pcm_runtime *rtd = substream->private_data;
133 struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
134
135 /* disable the PLL */
136 return snd_soc_dai_set_pll(codec_dai, WM8753_PLL1, 0, 0, 0);
137}
138
139/*
140 * Neo1973 WM8753 HiFi DAI opserations.
141 */
142static struct snd_soc_ops neo1973_gta02_hifi_ops = {
143 .hw_params = neo1973_gta02_hifi_hw_params,
144 .hw_free = neo1973_gta02_hifi_hw_free,
145};
146
147static int neo1973_gta02_voice_hw_params(
148 struct snd_pcm_substream *substream,
149 struct snd_pcm_hw_params *params)
150{
151 struct snd_soc_pcm_runtime *rtd = substream->private_data;
152 struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
153 unsigned int pcmdiv = 0;
154 int ret = 0;
155 unsigned long iis_clkrate;
156
157 iis_clkrate = s3c24xx_i2s_get_clockrate();
158
159 if (params_rate(params) != 8000)
160 return -EINVAL;
161 if (params_channels(params) != 1)
162 return -EINVAL;
163
164 pcmdiv = WM8753_PCM_DIV_6; /* 2.048 MHz */
165
166 /* todo: gg check mode (DSP_B) against CSR datasheet */
167 /* set codec DAI configuration */
168 ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_DSP_B |
169 SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
170 if (ret < 0)
171 return ret;
172
173 /* set the codec system clock for DAC and ADC */
174 ret = snd_soc_dai_set_sysclk(codec_dai, WM8753_PCMCLK,
175 12288000, SND_SOC_CLOCK_IN);
176 if (ret < 0)
177 return ret;
178
179 /* set codec PCM division for sample rate */
180 ret = snd_soc_dai_set_clkdiv(codec_dai, WM8753_PCMDIV,
181 pcmdiv);
182 if (ret < 0)
183 return ret;
184
185 /* configue and enable PLL for 12.288MHz output */
186 ret = snd_soc_dai_set_pll(codec_dai, WM8753_PLL2, 0,
187 iis_clkrate / 4, 12288000);
188 if (ret < 0)
189 return ret;
190
191 return 0;
192}
193
194static int neo1973_gta02_voice_hw_free(struct snd_pcm_substream *substream)
195{
196 struct snd_soc_pcm_runtime *rtd = substream->private_data;
197 struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
198
199 /* disable the PLL */
200 return snd_soc_dai_set_pll(codec_dai, WM8753_PLL2, 0, 0, 0);
201}
202
203static struct snd_soc_ops neo1973_gta02_voice_ops = {
204 .hw_params = neo1973_gta02_voice_hw_params,
205 .hw_free = neo1973_gta02_voice_hw_free,
206};
207
208#define LM4853_AMP 1
209#define LM4853_SPK 2
210
211static u8 lm4853_state;
212
213/* This has no effect, it exists only to maintain compatibility with
214 * existing ALSA state files.
215 */
216static int lm4853_set_state(struct snd_kcontrol *kcontrol,
217 struct snd_ctl_elem_value *ucontrol)
218{
219 int val = ucontrol->value.integer.value[0];
220
221 if (val)
222 lm4853_state |= LM4853_AMP;
223 else
224 lm4853_state &= ~LM4853_AMP;
225
226 return 0;
227}
228
229static int lm4853_get_state(struct snd_kcontrol *kcontrol,
230 struct snd_ctl_elem_value *ucontrol)
231{
232 ucontrol->value.integer.value[0] = lm4853_state & LM4853_AMP;
233
234 return 0;
235}
236
237static int lm4853_set_spk(struct snd_kcontrol *kcontrol,
238 struct snd_ctl_elem_value *ucontrol)
239{
240 int val = ucontrol->value.integer.value[0];
241
242 if (val) {
243 lm4853_state |= LM4853_SPK;
244 gpio_set_value(GTA02_GPIO_HP_IN, 0);
245 } else {
246 lm4853_state &= ~LM4853_SPK;
247 gpio_set_value(GTA02_GPIO_HP_IN, 1);
248 }
249
250 return 0;
251}
252
253static int lm4853_get_spk(struct snd_kcontrol *kcontrol,
254 struct snd_ctl_elem_value *ucontrol)
255{
256 ucontrol->value.integer.value[0] = (lm4853_state & LM4853_SPK) >> 1;
257
258 return 0;
259}
260
261static int lm4853_event(struct snd_soc_dapm_widget *w,
262 struct snd_kcontrol *k,
263 int event)
264{
265 gpio_set_value(GTA02_GPIO_AMP_SHUT, SND_SOC_DAPM_EVENT_OFF(value));
266
267 return 0;
268}
269
270static const struct snd_soc_dapm_widget wm8753_dapm_widgets[] = {
271 SND_SOC_DAPM_SPK("Stereo Out", lm4853_event),
272 SND_SOC_DAPM_LINE("GSM Line Out", NULL),
273 SND_SOC_DAPM_LINE("GSM Line In", NULL),
274 SND_SOC_DAPM_MIC("Headset Mic", NULL),
275 SND_SOC_DAPM_MIC("Handset Mic", NULL),
276 SND_SOC_DAPM_SPK("Handset Spk", NULL),
277};
278
279
280/* example machine audio_mapnections */
281static const struct snd_soc_dapm_route audio_map[] = {
282
283 /* Connections to the lm4853 amp */
284 {"Stereo Out", NULL, "LOUT1"},
285 {"Stereo Out", NULL, "ROUT1"},
286
287 /* Connections to the GSM Module */
288 {"GSM Line Out", NULL, "MONO1"},
289 {"GSM Line Out", NULL, "MONO2"},
290 {"RXP", NULL, "GSM Line In"},
291 {"RXN", NULL, "GSM Line In"},
292
293 /* Connections to Headset */
294 {"MIC1", NULL, "Mic Bias"},
295 {"Mic Bias", NULL, "Headset Mic"},
296
297 /* Call Mic */
298 {"MIC2", NULL, "Mic Bias"},
299 {"MIC2N", NULL, "Mic Bias"},
300 {"Mic Bias", NULL, "Handset Mic"},
301
302 /* Call Speaker */
303 {"Handset Spk", NULL, "LOUT2"},
304 {"Handset Spk", NULL, "ROUT2"},
305
306 /* Connect the ALC pins */
307 {"ACIN", NULL, "ACOP"},
308};
309
310static const struct snd_kcontrol_new wm8753_neo1973_gta02_controls[] = {
311 SOC_DAPM_PIN_SWITCH("Stereo Out"),
312 SOC_DAPM_PIN_SWITCH("GSM Line Out"),
313 SOC_DAPM_PIN_SWITCH("GSM Line In"),
314 SOC_DAPM_PIN_SWITCH("Headset Mic"),
315 SOC_DAPM_PIN_SWITCH("Handset Mic"),
316 SOC_DAPM_PIN_SWITCH("Handset Spk"),
317
318 /* This has no effect, it exists only to maintain compatibility with
319 * existing ALSA state files.
320 */
321 SOC_SINGLE_EXT("Amp State Switch", 6, 0, 1, 0,
322 lm4853_get_state,
323 lm4853_set_state),
324 SOC_SINGLE_EXT("Amp Spk Switch", 7, 0, 1, 0,
325 lm4853_get_spk,
326 lm4853_set_spk),
327};
328
329/*
330 * This is an example machine initialisation for a wm8753 connected to a
331 * neo1973 GTA02.
332 */
333static int neo1973_gta02_wm8753_init(struct snd_soc_codec *codec)
334{
335 int err;
336
337 /* set up NC codec pins */
338 snd_soc_dapm_nc_pin(codec, "OUT3");
339 snd_soc_dapm_nc_pin(codec, "OUT4");
340 snd_soc_dapm_nc_pin(codec, "LINE1");
341 snd_soc_dapm_nc_pin(codec, "LINE2");
342
343 /* Add neo1973 gta02 specific widgets */
344 snd_soc_dapm_new_controls(codec, wm8753_dapm_widgets,
345 ARRAY_SIZE(wm8753_dapm_widgets));
346
347 /* add neo1973 gta02 specific controls */
348 err = snd_soc_add_controls(codec, wm8753_neo1973_gta02_controls,
349 ARRAY_SIZE(wm8753_neo1973_gta02_controls));
350
351 if (err < 0)
352 return err;
353
354 /* set up neo1973 gta02 specific audio path audio_map */
355 snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
356
357 /* set endpoints to default off mode */
358 snd_soc_dapm_disable_pin(codec, "Stereo Out");
359 snd_soc_dapm_disable_pin(codec, "GSM Line Out");
360 snd_soc_dapm_disable_pin(codec, "GSM Line In");
361 snd_soc_dapm_disable_pin(codec, "Headset Mic");
362 snd_soc_dapm_disable_pin(codec, "Handset Mic");
363 snd_soc_dapm_disable_pin(codec, "Handset Spk");
364
365 /* allow audio paths from the GSM modem to run during suspend */
366 snd_soc_dapm_ignore_suspend(codec, "Stereo Out");
367 snd_soc_dapm_ignore_suspend(codec, "GSM Line Out");
368 snd_soc_dapm_ignore_suspend(codec, "GSM Line In");
369 snd_soc_dapm_ignore_suspend(codec, "Headset Mic");
370 snd_soc_dapm_ignore_suspend(codec, "Handset Mic");
371 snd_soc_dapm_ignore_suspend(codec, "Handset Spk");
372
373 snd_soc_dapm_sync(codec);
374
375 return 0;
376}
377
378/*
379 * BT Codec DAI
380 */
381static struct snd_soc_dai bt_dai = {
382 .name = "Bluetooth",
383 .id = 0,
384 .playback = {
385 .channels_min = 1,
386 .channels_max = 1,
387 .rates = SNDRV_PCM_RATE_8000,
388 .formats = SNDRV_PCM_FMTBIT_S16_LE,},
389 .capture = {
390 .channels_min = 1,
391 .channels_max = 1,
392 .rates = SNDRV_PCM_RATE_8000,
393 .formats = SNDRV_PCM_FMTBIT_S16_LE,},
394};
395
396static struct snd_soc_dai_link neo1973_gta02_dai[] = {
397{ /* Hifi Playback - for similatious use with voice below */
398 .name = "WM8753",
399 .stream_name = "WM8753 HiFi",
400 .cpu_dai = &s3c24xx_i2s_dai,
401 .codec_dai = &wm8753_dai[WM8753_DAI_HIFI],
402 .init = neo1973_gta02_wm8753_init,
403 .ops = &neo1973_gta02_hifi_ops,
404},
405{ /* Voice via BT */
406 .name = "Bluetooth",
407 .stream_name = "Voice",
408 .cpu_dai = &bt_dai,
409 .codec_dai = &wm8753_dai[WM8753_DAI_VOICE],
410 .ops = &neo1973_gta02_voice_ops,
411},
412};
413
414static struct snd_soc_card neo1973_gta02 = {
415 .name = "neo1973-gta02",
416 .platform = &s3c24xx_soc_platform,
417 .dai_link = neo1973_gta02_dai,
418 .num_links = ARRAY_SIZE(neo1973_gta02_dai),
419};
420
421static struct snd_soc_device neo1973_gta02_snd_devdata = {
422 .card = &neo1973_gta02,
423 .codec_dev = &soc_codec_dev_wm8753,
424};
425
426static struct platform_device *neo1973_gta02_snd_device;
427
428static int __init neo1973_gta02_init(void)
429{
430 int ret;
431
432 if (!machine_is_neo1973_gta02()) {
433 printk(KERN_INFO
434 "Only GTA02 is supported by this ASoC driver\n");
435 return -ENODEV;
436 }
437
438 /* register bluetooth DAI here */
439 ret = snd_soc_register_dai(&bt_dai);
440 if (ret)
441 return ret;
442
443 neo1973_gta02_snd_device = platform_device_alloc("soc-audio", -1);
444 if (!neo1973_gta02_snd_device)
445 return -ENOMEM;
446
447 platform_set_drvdata(neo1973_gta02_snd_device,
448 &neo1973_gta02_snd_devdata);
449 neo1973_gta02_snd_devdata.dev = &neo1973_gta02_snd_device->dev;
450 ret = platform_device_add(neo1973_gta02_snd_device);
451
452 if (ret) {
453 platform_device_put(neo1973_gta02_snd_device);
454 return ret;
455 }
456
457 /* Initialise GPIOs used by amp */
458 ret = gpio_request(GTA02_GPIO_HP_IN, "GTA02_HP_IN");
459 if (ret) {
460 pr_err("gta02_wm8753: Failed to register GPIO %d\n", GTA02_GPIO_HP_IN);
461 goto err_unregister_device;
462 }
463
464 ret = gpio_direction_output(GTA02_GPIO_AMP_HP_IN, 1);
465 if (ret) {
466 pr_err("gta02_wm8753: Failed to configure GPIO %d\n", GTA02_GPIO_HP_IN);
467 goto err_free_gpio_hp_in;
468 }
469
470 ret = gpio_request(GTA02_GPIO_AMP_SHUT, "GTA02_AMP_SHUT");
471 if (ret) {
472 pr_err("gta02_wm8753: Failed to register GPIO %d\n", GTA02_GPIO_AMP_SHUT);
473 goto err_free_gpio_hp_in;
474 }
475
476 ret = gpio_direction_output(GTA02_GPIO_AMP_SHUT, 1);
477 if (ret) {
478 pr_err("gta02_wm8753: Failed to configure GPIO %d\n", GTA02_GPIO_AMP_SHUT);
479 goto err_free_gpio_amp_shut;
480 }
481
482 return 0;
483
484err_free_gpio_amp_shut:
485 gpio_free(GTA02_GPIO_AMP_SHUT);
486err_free_gpio_hp_in:
487 gpio_free(GTA02_GPIO_HP_IN);
488err_unregister_device:
489 platform_device_unregister(neo1973_gta02_snd_device);
490 return ret;
491}
492module_init(neo1973_gta02_init);
493
494static void __exit neo1973_gta02_exit(void)
495{
496 snd_soc_unregister_dai(&bt_dai);
497 platform_device_unregister(neo1973_gta02_snd_device);
498 gpio_free(GTA02_GPIO_HP_IN);
499 gpio_free(GTA02_GPIO_AMP_SHUT);
500}
501module_exit(neo1973_gta02_exit);
502
503/* Module information */
504MODULE_AUTHOR("Graeme Gregory, graeme@openmoko.org");
505MODULE_DESCRIPTION("ALSA SoC WM8753 Neo1973 GTA02");
506MODULE_LICENSE("GPL");
diff --git a/sound/soc/s3c24xx/neo1973_wm8753.c b/sound/soc/s3c24xx/neo1973_wm8753.c
deleted file mode 100644
index 0cb4f86f6d1e..000000000000
--- a/sound/soc/s3c24xx/neo1973_wm8753.c
+++ /dev/null
@@ -1,707 +0,0 @@
1/*
2 * neo1973_wm8753.c -- SoC audio for Neo1973
3 *
4 * Copyright 2007 Wolfson Microelectronics PLC.
5 * Author: Graeme Gregory
6 * graeme.gregory@wolfsonmicro.com or linux@wolfsonmicro.com
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
12 *
13 */
14
15#include <linux/module.h>
16#include <linux/moduleparam.h>
17#include <linux/timer.h>
18#include <linux/interrupt.h>
19#include <linux/platform_device.h>
20#include <linux/i2c.h>
21#include <sound/core.h>
22#include <sound/pcm.h>
23#include <sound/soc.h>
24#include <sound/soc-dapm.h>
25#include <sound/tlv.h>
26
27#include <asm/mach-types.h>
28#include <asm/hardware/scoop.h>
29#include <mach/regs-clock.h>
30#include <mach/regs-gpio.h>
31#include <mach/hardware.h>
32#include <linux/io.h>
33#include <mach/spi-gpio.h>
34
35#include <plat/regs-iis.h>
36
37#include "../codecs/wm8753.h"
38#include "lm4857.h"
39#include "s3c-dma.h"
40#include "s3c24xx-i2s.h"
41
42/* define the scenarios */
43#define NEO_AUDIO_OFF 0
44#define NEO_GSM_CALL_AUDIO_HANDSET 1
45#define NEO_GSM_CALL_AUDIO_HEADSET 2
46#define NEO_GSM_CALL_AUDIO_BLUETOOTH 3
47#define NEO_STEREO_TO_SPEAKERS 4
48#define NEO_STEREO_TO_HEADPHONES 5
49#define NEO_CAPTURE_HANDSET 6
50#define NEO_CAPTURE_HEADSET 7
51#define NEO_CAPTURE_BLUETOOTH 8
52
53static struct snd_soc_card neo1973;
54static struct i2c_client *i2c;
55
56static int neo1973_hifi_hw_params(struct snd_pcm_substream *substream,
57 struct snd_pcm_hw_params *params)
58{
59 struct snd_soc_pcm_runtime *rtd = substream->private_data;
60 struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
61 struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
62 unsigned int pll_out = 0, bclk = 0;
63 int ret = 0;
64 unsigned long iis_clkrate;
65
66 pr_debug("Entered %s\n", __func__);
67
68 iis_clkrate = s3c24xx_i2s_get_clockrate();
69
70 switch (params_rate(params)) {
71 case 8000:
72 case 16000:
73 pll_out = 12288000;
74 break;
75 case 48000:
76 bclk = WM8753_BCLK_DIV_4;
77 pll_out = 12288000;
78 break;
79 case 96000:
80 bclk = WM8753_BCLK_DIV_2;
81 pll_out = 12288000;
82 break;
83 case 11025:
84 bclk = WM8753_BCLK_DIV_16;
85 pll_out = 11289600;
86 break;
87 case 22050:
88 bclk = WM8753_BCLK_DIV_8;
89 pll_out = 11289600;
90 break;
91 case 44100:
92 bclk = WM8753_BCLK_DIV_4;
93 pll_out = 11289600;
94 break;
95 case 88200:
96 bclk = WM8753_BCLK_DIV_2;
97 pll_out = 11289600;
98 break;
99 }
100
101 /* set codec DAI configuration */
102 ret = snd_soc_dai_set_fmt(codec_dai,
103 SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
104 SND_SOC_DAIFMT_CBM_CFM);
105 if (ret < 0)
106 return ret;
107
108 /* set cpu DAI configuration */
109 ret = snd_soc_dai_set_fmt(cpu_dai,
110 SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
111 SND_SOC_DAIFMT_CBM_CFM);
112 if (ret < 0)
113 return ret;
114
115 /* set the codec system clock for DAC and ADC */
116 ret = snd_soc_dai_set_sysclk(codec_dai, WM8753_MCLK, pll_out,
117 SND_SOC_CLOCK_IN);
118 if (ret < 0)
119 return ret;
120
121 /* set MCLK division for sample rate */
122 ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C24XX_DIV_MCLK,
123 S3C2410_IISMOD_32FS);
124 if (ret < 0)
125 return ret;
126
127 /* set codec BCLK division for sample rate */
128 ret = snd_soc_dai_set_clkdiv(codec_dai, WM8753_BCLKDIV, bclk);
129 if (ret < 0)
130 return ret;
131
132 /* set prescaler division for sample rate */
133 ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C24XX_DIV_PRESCALER,
134 S3C24XX_PRESCALE(4, 4));
135 if (ret < 0)
136 return ret;
137
138 /* codec PLL input is PCLK/4 */
139 ret = snd_soc_dai_set_pll(codec_dai, WM8753_PLL1, 0,
140 iis_clkrate / 4, pll_out);
141 if (ret < 0)
142 return ret;
143
144 return 0;
145}
146
147static int neo1973_hifi_hw_free(struct snd_pcm_substream *substream)
148{
149 struct snd_soc_pcm_runtime *rtd = substream->private_data;
150 struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
151
152 pr_debug("Entered %s\n", __func__);
153
154 /* disable the PLL */
155 return snd_soc_dai_set_pll(codec_dai, WM8753_PLL1, 0, 0, 0);
156}
157
158/*
159 * Neo1973 WM8753 HiFi DAI opserations.
160 */
161static struct snd_soc_ops neo1973_hifi_ops = {
162 .hw_params = neo1973_hifi_hw_params,
163 .hw_free = neo1973_hifi_hw_free,
164};
165
166static int neo1973_voice_hw_params(struct snd_pcm_substream *substream,
167 struct snd_pcm_hw_params *params)
168{
169 struct snd_soc_pcm_runtime *rtd = substream->private_data;
170 struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
171 unsigned int pcmdiv = 0;
172 int ret = 0;
173 unsigned long iis_clkrate;
174
175 pr_debug("Entered %s\n", __func__);
176
177 iis_clkrate = s3c24xx_i2s_get_clockrate();
178
179 if (params_rate(params) != 8000)
180 return -EINVAL;
181 if (params_channels(params) != 1)
182 return -EINVAL;
183
184 pcmdiv = WM8753_PCM_DIV_6; /* 2.048 MHz */
185
186 /* todo: gg check mode (DSP_B) against CSR datasheet */
187 /* set codec DAI configuration */
188 ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_DSP_B |
189 SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
190 if (ret < 0)
191 return ret;
192
193 /* set the codec system clock for DAC and ADC */
194 ret = snd_soc_dai_set_sysclk(codec_dai, WM8753_PCMCLK, 12288000,
195 SND_SOC_CLOCK_IN);
196 if (ret < 0)
197 return ret;
198
199 /* set codec PCM division for sample rate */
200 ret = snd_soc_dai_set_clkdiv(codec_dai, WM8753_PCMDIV, pcmdiv);
201 if (ret < 0)
202 return ret;
203
204 /* configue and enable PLL for 12.288MHz output */
205 ret = snd_soc_dai_set_pll(codec_dai, WM8753_PLL2, 0,
206 iis_clkrate / 4, 12288000);
207 if (ret < 0)
208 return ret;
209
210 return 0;
211}
212
213static int neo1973_voice_hw_free(struct snd_pcm_substream *substream)
214{
215 struct snd_soc_pcm_runtime *rtd = substream->private_data;
216 struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
217
218 pr_debug("Entered %s\n", __func__);
219
220 /* disable the PLL */
221 return snd_soc_dai_set_pll(codec_dai, WM8753_PLL2, 0, 0, 0);
222}
223
224static struct snd_soc_ops neo1973_voice_ops = {
225 .hw_params = neo1973_voice_hw_params,
226 .hw_free = neo1973_voice_hw_free,
227};
228
229static int neo1973_scenario;
230
231static int neo1973_get_scenario(struct snd_kcontrol *kcontrol,
232 struct snd_ctl_elem_value *ucontrol)
233{
234 ucontrol->value.integer.value[0] = neo1973_scenario;
235 return 0;
236}
237
238static int set_scenario_endpoints(struct snd_soc_codec *codec, int scenario)
239{
240 pr_debug("Entered %s\n", __func__);
241
242 switch (neo1973_scenario) {
243 case NEO_AUDIO_OFF:
244 snd_soc_dapm_disable_pin(codec, "Audio Out");
245 snd_soc_dapm_disable_pin(codec, "GSM Line Out");
246 snd_soc_dapm_disable_pin(codec, "GSM Line In");
247 snd_soc_dapm_disable_pin(codec, "Headset Mic");
248 snd_soc_dapm_disable_pin(codec, "Call Mic");
249 break;
250 case NEO_GSM_CALL_AUDIO_HANDSET:
251 snd_soc_dapm_enable_pin(codec, "Audio Out");
252 snd_soc_dapm_enable_pin(codec, "GSM Line Out");
253 snd_soc_dapm_enable_pin(codec, "GSM Line In");
254 snd_soc_dapm_disable_pin(codec, "Headset Mic");
255 snd_soc_dapm_enable_pin(codec, "Call Mic");
256 break;
257 case NEO_GSM_CALL_AUDIO_HEADSET:
258 snd_soc_dapm_enable_pin(codec, "Audio Out");
259 snd_soc_dapm_enable_pin(codec, "GSM Line Out");
260 snd_soc_dapm_enable_pin(codec, "GSM Line In");
261 snd_soc_dapm_enable_pin(codec, "Headset Mic");
262 snd_soc_dapm_disable_pin(codec, "Call Mic");
263 break;
264 case NEO_GSM_CALL_AUDIO_BLUETOOTH:
265 snd_soc_dapm_disable_pin(codec, "Audio Out");
266 snd_soc_dapm_enable_pin(codec, "GSM Line Out");
267 snd_soc_dapm_enable_pin(codec, "GSM Line In");
268 snd_soc_dapm_disable_pin(codec, "Headset Mic");
269 snd_soc_dapm_disable_pin(codec, "Call Mic");
270 break;
271 case NEO_STEREO_TO_SPEAKERS:
272 snd_soc_dapm_enable_pin(codec, "Audio Out");
273 snd_soc_dapm_disable_pin(codec, "GSM Line Out");
274 snd_soc_dapm_disable_pin(codec, "GSM Line In");
275 snd_soc_dapm_disable_pin(codec, "Headset Mic");
276 snd_soc_dapm_disable_pin(codec, "Call Mic");
277 break;
278 case NEO_STEREO_TO_HEADPHONES:
279 snd_soc_dapm_enable_pin(codec, "Audio Out");
280 snd_soc_dapm_disable_pin(codec, "GSM Line Out");
281 snd_soc_dapm_disable_pin(codec, "GSM Line In");
282 snd_soc_dapm_disable_pin(codec, "Headset Mic");
283 snd_soc_dapm_disable_pin(codec, "Call Mic");
284 break;
285 case NEO_CAPTURE_HANDSET:
286 snd_soc_dapm_disable_pin(codec, "Audio Out");
287 snd_soc_dapm_disable_pin(codec, "GSM Line Out");
288 snd_soc_dapm_disable_pin(codec, "GSM Line In");
289 snd_soc_dapm_disable_pin(codec, "Headset Mic");
290 snd_soc_dapm_enable_pin(codec, "Call Mic");
291 break;
292 case NEO_CAPTURE_HEADSET:
293 snd_soc_dapm_disable_pin(codec, "Audio Out");
294 snd_soc_dapm_disable_pin(codec, "GSM Line Out");
295 snd_soc_dapm_disable_pin(codec, "GSM Line In");
296 snd_soc_dapm_enable_pin(codec, "Headset Mic");
297 snd_soc_dapm_disable_pin(codec, "Call Mic");
298 break;
299 case NEO_CAPTURE_BLUETOOTH:
300 snd_soc_dapm_disable_pin(codec, "Audio Out");
301 snd_soc_dapm_disable_pin(codec, "GSM Line Out");
302 snd_soc_dapm_disable_pin(codec, "GSM Line In");
303 snd_soc_dapm_disable_pin(codec, "Headset Mic");
304 snd_soc_dapm_disable_pin(codec, "Call Mic");
305 break;
306 default:
307 snd_soc_dapm_disable_pin(codec, "Audio Out");
308 snd_soc_dapm_disable_pin(codec, "GSM Line Out");
309 snd_soc_dapm_disable_pin(codec, "GSM Line In");
310 snd_soc_dapm_disable_pin(codec, "Headset Mic");
311 snd_soc_dapm_disable_pin(codec, "Call Mic");
312 }
313
314 snd_soc_dapm_sync(codec);
315
316 return 0;
317}
318
319static int neo1973_set_scenario(struct snd_kcontrol *kcontrol,
320 struct snd_ctl_elem_value *ucontrol)
321{
322 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
323
324 pr_debug("Entered %s\n", __func__);
325
326 if (neo1973_scenario == ucontrol->value.integer.value[0])
327 return 0;
328
329 neo1973_scenario = ucontrol->value.integer.value[0];
330 set_scenario_endpoints(codec, neo1973_scenario);
331 return 1;
332}
333
334static u8 lm4857_regs[4] = {0x00, 0x40, 0x80, 0xC0};
335
336static void lm4857_write_regs(void)
337{
338 pr_debug("Entered %s\n", __func__);
339
340 if (i2c_master_send(i2c, lm4857_regs, 4) != 4)
341 printk(KERN_ERR "lm4857: i2c write failed\n");
342}
343
344static int lm4857_get_reg(struct snd_kcontrol *kcontrol,
345 struct snd_ctl_elem_value *ucontrol)
346{
347 struct soc_mixer_control *mc =
348 (struct soc_mixer_control *)kcontrol->private_value;
349 int reg = mc->reg;
350 int shift = mc->shift;
351 int mask = mc->max;
352
353 pr_debug("Entered %s\n", __func__);
354
355 ucontrol->value.integer.value[0] = (lm4857_regs[reg] >> shift) & mask;
356 return 0;
357}
358
359static int lm4857_set_reg(struct snd_kcontrol *kcontrol,
360 struct snd_ctl_elem_value *ucontrol)
361{
362 struct soc_mixer_control *mc =
363 (struct soc_mixer_control *)kcontrol->private_value;
364 int reg = mc->reg;
365 int shift = mc->shift;
366 int mask = mc->max;
367
368 if (((lm4857_regs[reg] >> shift) & mask) ==
369 ucontrol->value.integer.value[0])
370 return 0;
371
372 lm4857_regs[reg] &= ~(mask << shift);
373 lm4857_regs[reg] |= ucontrol->value.integer.value[0] << shift;
374 lm4857_write_regs();
375 return 1;
376}
377
378static int lm4857_get_mode(struct snd_kcontrol *kcontrol,
379 struct snd_ctl_elem_value *ucontrol)
380{
381 u8 value = lm4857_regs[LM4857_CTRL] & 0x0F;
382
383 pr_debug("Entered %s\n", __func__);
384
385 if (value)
386 value -= 5;
387
388 ucontrol->value.integer.value[0] = value;
389 return 0;
390}
391
392static int lm4857_set_mode(struct snd_kcontrol *kcontrol,
393 struct snd_ctl_elem_value *ucontrol)
394{
395 u8 value = ucontrol->value.integer.value[0];
396
397 pr_debug("Entered %s\n", __func__);
398
399 if (value)
400 value += 5;
401
402 if ((lm4857_regs[LM4857_CTRL] & 0x0F) == value)
403 return 0;
404
405 lm4857_regs[LM4857_CTRL] &= 0xF0;
406 lm4857_regs[LM4857_CTRL] |= value;
407 lm4857_write_regs();
408 return 1;
409}
410
411static const struct snd_soc_dapm_widget wm8753_dapm_widgets[] = {
412 SND_SOC_DAPM_LINE("Audio Out", NULL),
413 SND_SOC_DAPM_LINE("GSM Line Out", NULL),
414 SND_SOC_DAPM_LINE("GSM Line In", NULL),
415 SND_SOC_DAPM_MIC("Headset Mic", NULL),
416 SND_SOC_DAPM_MIC("Call Mic", NULL),
417};
418
419
420static const struct snd_soc_dapm_route dapm_routes[] = {
421
422 /* Connections to the lm4857 amp */
423 {"Audio Out", NULL, "LOUT1"},
424 {"Audio Out", NULL, "ROUT1"},
425
426 /* Connections to the GSM Module */
427 {"GSM Line Out", NULL, "MONO1"},
428 {"GSM Line Out", NULL, "MONO2"},
429 {"RXP", NULL, "GSM Line In"},
430 {"RXN", NULL, "GSM Line In"},
431
432 /* Connections to Headset */
433 {"MIC1", NULL, "Mic Bias"},
434 {"Mic Bias", NULL, "Headset Mic"},
435
436 /* Call Mic */
437 {"MIC2", NULL, "Mic Bias"},
438 {"MIC2N", NULL, "Mic Bias"},
439 {"Mic Bias", NULL, "Call Mic"},
440
441 /* Connect the ALC pins */
442 {"ACIN", NULL, "ACOP"},
443};
444
445static const char *lm4857_mode[] = {
446 "Off",
447 "Call Speaker",
448 "Stereo Speakers",
449 "Stereo Speakers + Headphones",
450 "Headphones"
451};
452
453static const struct soc_enum lm4857_mode_enum[] = {
454 SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(lm4857_mode), lm4857_mode),
455};
456
457static const char *neo_scenarios[] = {
458 "Off",
459 "GSM Handset",
460 "GSM Headset",
461 "GSM Bluetooth",
462 "Speakers",
463 "Headphones",
464 "Capture Handset",
465 "Capture Headset",
466 "Capture Bluetooth"
467};
468
469static const struct soc_enum neo_scenario_enum[] = {
470 SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(neo_scenarios), neo_scenarios),
471};
472
473static const DECLARE_TLV_DB_SCALE(stereo_tlv, -4050, 150, 0);
474static const DECLARE_TLV_DB_SCALE(mono_tlv, -3450, 150, 0);
475
476static const struct snd_kcontrol_new wm8753_neo1973_controls[] = {
477 SOC_SINGLE_EXT_TLV("Amp Left Playback Volume", LM4857_LVOL, 0, 31, 0,
478 lm4857_get_reg, lm4857_set_reg, stereo_tlv),
479 SOC_SINGLE_EXT_TLV("Amp Right Playback Volume", LM4857_RVOL, 0, 31, 0,
480 lm4857_get_reg, lm4857_set_reg, stereo_tlv),
481 SOC_SINGLE_EXT_TLV("Amp Mono Playback Volume", LM4857_MVOL, 0, 31, 0,
482 lm4857_get_reg, lm4857_set_reg, mono_tlv),
483 SOC_ENUM_EXT("Amp Mode", lm4857_mode_enum[0],
484 lm4857_get_mode, lm4857_set_mode),
485 SOC_ENUM_EXT("Neo Mode", neo_scenario_enum[0],
486 neo1973_get_scenario, neo1973_set_scenario),
487 SOC_SINGLE_EXT("Amp Spk 3D Playback Switch", LM4857_LVOL, 5, 1, 0,
488 lm4857_get_reg, lm4857_set_reg),
489 SOC_SINGLE_EXT("Amp HP 3d Playback Switch", LM4857_RVOL, 5, 1, 0,
490 lm4857_get_reg, lm4857_set_reg),
491 SOC_SINGLE_EXT("Amp Fast Wakeup Playback Switch", LM4857_CTRL, 5, 1, 0,
492 lm4857_get_reg, lm4857_set_reg),
493 SOC_SINGLE_EXT("Amp Earpiece 6dB Playback Switch", LM4857_CTRL, 4, 1, 0,
494 lm4857_get_reg, lm4857_set_reg),
495};
496
497/*
498 * This is an example machine initialisation for a wm8753 connected to a
499 * neo1973 II. It is missing logic to detect hp/mic insertions and logic
500 * to re-route the audio in such an event.
501 */
502static int neo1973_wm8753_init(struct snd_soc_codec *codec)
503{
504 int err;
505
506 pr_debug("Entered %s\n", __func__);
507
508 /* set up NC codec pins */
509 snd_soc_dapm_nc_pin(codec, "LOUT2");
510 snd_soc_dapm_nc_pin(codec, "ROUT2");
511 snd_soc_dapm_nc_pin(codec, "OUT3");
512 snd_soc_dapm_nc_pin(codec, "OUT4");
513 snd_soc_dapm_nc_pin(codec, "LINE1");
514 snd_soc_dapm_nc_pin(codec, "LINE2");
515
516 /* Add neo1973 specific widgets */
517 snd_soc_dapm_new_controls(codec, wm8753_dapm_widgets,
518 ARRAY_SIZE(wm8753_dapm_widgets));
519
520 /* set endpoints to default mode */
521 set_scenario_endpoints(codec, NEO_AUDIO_OFF);
522
523 /* add neo1973 specific controls */
524 err = snd_soc_add_controls(codec, wm8753_neo1973_controls,
525 ARRAY_SIZE(8753_neo1973_controls));
526 if (err < 0)
527 return err;
528
529 /* set up neo1973 specific audio routes */
530 err = snd_soc_dapm_add_routes(codec, dapm_routes,
531 ARRAY_SIZE(dapm_routes));
532
533 snd_soc_dapm_sync(codec);
534 return 0;
535}
536
537/*
538 * BT Codec DAI
539 */
540static struct snd_soc_dai bt_dai = {
541 .name = "Bluetooth",
542 .id = 0,
543 .playback = {
544 .channels_min = 1,
545 .channels_max = 1,
546 .rates = SNDRV_PCM_RATE_8000,
547 .formats = SNDRV_PCM_FMTBIT_S16_LE,},
548 .capture = {
549 .channels_min = 1,
550 .channels_max = 1,
551 .rates = SNDRV_PCM_RATE_8000,
552 .formats = SNDRV_PCM_FMTBIT_S16_LE,},
553};
554
555static struct snd_soc_dai_link neo1973_dai[] = {
556{ /* Hifi Playback - for similatious use with voice below */
557 .name = "WM8753",
558 .stream_name = "WM8753 HiFi",
559 .cpu_dai = &s3c24xx_i2s_dai,
560 .codec_dai = &wm8753_dai[WM8753_DAI_HIFI],
561 .init = neo1973_wm8753_init,
562 .ops = &neo1973_hifi_ops,
563},
564{ /* Voice via BT */
565 .name = "Bluetooth",
566 .stream_name = "Voice",
567 .cpu_dai = &bt_dai,
568 .codec_dai = &wm8753_dai[WM8753_DAI_VOICE],
569 .ops = &neo1973_voice_ops,
570},
571};
572
573static struct snd_soc_card neo1973 = {
574 .name = "neo1973",
575 .platform = &s3c24xx_soc_platform,
576 .dai_link = neo1973_dai,
577 .num_links = ARRAY_SIZE(neo1973_dai),
578};
579
580static struct snd_soc_device neo1973_snd_devdata = {
581 .card = &neo1973,
582 .codec_dev = &soc_codec_dev_wm8753,
583};
584
585static int lm4857_i2c_probe(struct i2c_client *client,
586 const struct i2c_device_id *id)
587{
588 pr_debug("Entered %s\n", __func__);
589
590 i2c = client;
591
592 lm4857_write_regs();
593 return 0;
594}
595
596static int lm4857_i2c_remove(struct i2c_client *client)
597{
598 pr_debug("Entered %s\n", __func__);
599
600 i2c = NULL;
601
602 return 0;
603}
604
605static u8 lm4857_state;
606
607static int lm4857_suspend(struct i2c_client *dev, pm_message_t state)
608{
609 pr_debug("Entered %s\n", __func__);
610
611 dev_dbg(&dev->dev, "lm4857_suspend\n");
612 lm4857_state = lm4857_regs[LM4857_CTRL] & 0xf;
613 if (lm4857_state) {
614 lm4857_regs[LM4857_CTRL] &= 0xf0;
615 lm4857_write_regs();
616 }
617 return 0;
618}
619
620static int lm4857_resume(struct i2c_client *dev)
621{
622 pr_debug("Entered %s\n", __func__);
623
624 if (lm4857_state) {
625 lm4857_regs[LM4857_CTRL] |= (lm4857_state & 0x0f);
626 lm4857_write_regs();
627 }
628 return 0;
629}
630
631static void lm4857_shutdown(struct i2c_client *dev)
632{
633 pr_debug("Entered %s\n", __func__);
634
635 dev_dbg(&dev->dev, "lm4857_shutdown\n");
636 lm4857_regs[LM4857_CTRL] &= 0xf0;
637 lm4857_write_regs();
638}
639
640static const struct i2c_device_id lm4857_i2c_id[] = {
641 { "neo1973_lm4857", 0 },
642 { }
643};
644
645static struct i2c_driver lm4857_i2c_driver = {
646 .driver = {
647 .name = "LM4857 I2C Amp",
648 .owner = THIS_MODULE,
649 },
650 .suspend = lm4857_suspend,
651 .resume = lm4857_resume,
652 .shutdown = lm4857_shutdown,
653 .probe = lm4857_i2c_probe,
654 .remove = lm4857_i2c_remove,
655 .id_table = lm4857_i2c_id,
656};
657
658static struct platform_device *neo1973_snd_device;
659
660static int __init neo1973_init(void)
661{
662 int ret;
663
664 pr_debug("Entered %s\n", __func__);
665
666 if (!machine_is_neo1973_gta01()) {
667 printk(KERN_INFO
668 "Only GTA01 hardware supported by ASoC driver\n");
669 return -ENODEV;
670 }
671
672 neo1973_snd_device = platform_device_alloc("soc-audio", -1);
673 if (!neo1973_snd_device)
674 return -ENOMEM;
675
676 platform_set_drvdata(neo1973_snd_device, &neo1973_snd_devdata);
677 neo1973_snd_devdata.dev = &neo1973_snd_device->dev;
678 ret = platform_device_add(neo1973_snd_device);
679
680 if (ret) {
681 platform_device_put(neo1973_snd_device);
682 return ret;
683 }
684
685 ret = i2c_add_driver(&lm4857_i2c_driver);
686
687 if (ret != 0)
688 platform_device_unregister(neo1973_snd_device);
689
690 return ret;
691}
692
693static void __exit neo1973_exit(void)
694{
695 pr_debug("Entered %s\n", __func__);
696
697 i2c_del_driver(&lm4857_i2c_driver);
698 platform_device_unregister(neo1973_snd_device);
699}
700
701module_init(neo1973_init);
702module_exit(neo1973_exit);
703
704/* Module information */
705MODULE_AUTHOR("Graeme Gregory, graeme@openmoko.org, www.openmoko.org");
706MODULE_DESCRIPTION("ALSA SoC WM8753 Neo1973");
707MODULE_LICENSE("GPL");
diff --git a/sound/soc/s3c24xx/regs-i2s-v2.h b/sound/soc/s3c24xx/regs-i2s-v2.h
deleted file mode 100644
index 5e5e5680580b..000000000000
--- a/sound/soc/s3c24xx/regs-i2s-v2.h
+++ /dev/null
@@ -1,115 +0,0 @@
1/* linux/include/asm-arm/plat-s3c24xx/regs-s3c2412-iis.h
2 *
3 * Copyright 2007 Simtec Electronics <linux@simtec.co.uk>
4 * http://armlinux.simtec.co.uk/
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 *
10 * S3C2412 IIS register definition
11*/
12
13#ifndef __ASM_ARCH_REGS_S3C2412_IIS_H
14#define __ASM_ARCH_REGS_S3C2412_IIS_H
15
16#define S3C2412_IISCON (0x00)
17#define S3C2412_IISMOD (0x04)
18#define S3C2412_IISFIC (0x08)
19#define S3C2412_IISPSR (0x0C)
20#define S3C2412_IISTXD (0x10)
21#define S3C2412_IISRXD (0x14)
22
23#define S5PC1XX_IISFICS 0x18
24#define S5PC1XX_IISTXDS 0x1C
25
26#define S5PC1XX_IISCON_SW_RST (1 << 31)
27#define S5PC1XX_IISCON_FRXOFSTATUS (1 << 26)
28#define S5PC1XX_IISCON_FRXORINTEN (1 << 25)
29#define S5PC1XX_IISCON_FTXSURSTAT (1 << 24)
30#define S5PC1XX_IISCON_FTXSURINTEN (1 << 23)
31#define S5PC1XX_IISCON_TXSDMAPAUSE (1 << 20)
32#define S5PC1XX_IISCON_TXSDMACTIVE (1 << 18)
33
34#define S3C64XX_IISCON_FTXURSTATUS (1 << 17)
35#define S3C64XX_IISCON_FTXURINTEN (1 << 16)
36#define S3C64XX_IISCON_TXFIFO2_EMPTY (1 << 15)
37#define S3C64XX_IISCON_TXFIFO1_EMPTY (1 << 14)
38#define S3C64XX_IISCON_TXFIFO2_FULL (1 << 13)
39#define S3C64XX_IISCON_TXFIFO1_FULL (1 << 12)
40
41#define S3C2412_IISCON_LRINDEX (1 << 11)
42#define S3C2412_IISCON_TXFIFO_EMPTY (1 << 10)
43#define S3C2412_IISCON_RXFIFO_EMPTY (1 << 9)
44#define S3C2412_IISCON_TXFIFO_FULL (1 << 8)
45#define S3C2412_IISCON_RXFIFO_FULL (1 << 7)
46#define S3C2412_IISCON_TXDMA_PAUSE (1 << 6)
47#define S3C2412_IISCON_RXDMA_PAUSE (1 << 5)
48#define S3C2412_IISCON_TXCH_PAUSE (1 << 4)
49#define S3C2412_IISCON_RXCH_PAUSE (1 << 3)
50#define S3C2412_IISCON_TXDMA_ACTIVE (1 << 2)
51#define S3C2412_IISCON_RXDMA_ACTIVE (1 << 1)
52#define S3C2412_IISCON_IIS_ACTIVE (1 << 0)
53
54#define S5PC1XX_IISMOD_OPCLK_CDCLK_OUT (0 << 30)
55#define S5PC1XX_IISMOD_OPCLK_CDCLK_IN (1 << 30)
56#define S5PC1XX_IISMOD_OPCLK_BCLK_OUT (2 << 30)
57#define S5PC1XX_IISMOD_OPCLK_PCLK (3 << 30)
58#define S5PC1XX_IISMOD_OPCLK_MASK (3 << 30)
59#define S5PC1XX_IISMOD_TXS_IDMA (1 << 28) /* Sec_TXFIFO use I-DMA */
60#define S5PC1XX_IISMOD_BLCS_MASK 0x3
61#define S5PC1XX_IISMOD_BLCS_SHIFT 26
62#define S5PC1XX_IISMOD_BLCP_MASK 0x3
63#define S5PC1XX_IISMOD_BLCP_SHIFT 24
64
65#define S3C64XX_IISMOD_C2DD_HHALF (1 << 21) /* Discard Higher-half */
66#define S3C64XX_IISMOD_C2DD_LHALF (1 << 20) /* Discard Lower-half */
67#define S3C64XX_IISMOD_C1DD_HHALF (1 << 19)
68#define S3C64XX_IISMOD_C1DD_LHALF (1 << 18)
69#define S3C64XX_IISMOD_DC2_EN (1 << 17)
70#define S3C64XX_IISMOD_DC1_EN (1 << 16)
71#define S3C64XX_IISMOD_BLC_16BIT (0 << 13)
72#define S3C64XX_IISMOD_BLC_8BIT (1 << 13)
73#define S3C64XX_IISMOD_BLC_24BIT (2 << 13)
74#define S3C64XX_IISMOD_BLC_MASK (3 << 13)
75
76#define S3C2412_IISMOD_IMS_SYSMUX (1 << 10)
77#define S3C2412_IISMOD_SLAVE (1 << 11)
78#define S3C2412_IISMOD_MODE_TXONLY (0 << 8)
79#define S3C2412_IISMOD_MODE_RXONLY (1 << 8)
80#define S3C2412_IISMOD_MODE_TXRX (2 << 8)
81#define S3C2412_IISMOD_MODE_MASK (3 << 8)
82#define S3C2412_IISMOD_LR_LLOW (0 << 7)
83#define S3C2412_IISMOD_LR_RLOW (1 << 7)
84#define S3C2412_IISMOD_SDF_IIS (0 << 5)
85#define S3C2412_IISMOD_SDF_MSB (1 << 5)
86#define S3C2412_IISMOD_SDF_LSB (2 << 5)
87#define S3C2412_IISMOD_SDF_MASK (3 << 5)
88#define S3C2412_IISMOD_RCLK_256FS (0 << 3)
89#define S3C2412_IISMOD_RCLK_512FS (1 << 3)
90#define S3C2412_IISMOD_RCLK_384FS (2 << 3)
91#define S3C2412_IISMOD_RCLK_768FS (3 << 3)
92#define S3C2412_IISMOD_RCLK_MASK (3 << 3)
93#define S3C2412_IISMOD_BCLK_32FS (0 << 1)
94#define S3C2412_IISMOD_BCLK_48FS (1 << 1)
95#define S3C2412_IISMOD_BCLK_16FS (2 << 1)
96#define S3C2412_IISMOD_BCLK_24FS (3 << 1)
97#define S3C2412_IISMOD_BCLK_MASK (3 << 1)
98#define S3C2412_IISMOD_8BIT (1 << 0)
99
100#define S3C64XX_IISMOD_CDCLKCON (1 << 12)
101
102#define S3C2412_IISPSR_PSREN (1 << 15)
103
104#define S3C64XX_IISFIC_TX2COUNT(x) (((x) >> 24) & 0xf)
105#define S3C64XX_IISFIC_TX1COUNT(x) (((x) >> 16) & 0xf)
106
107#define S3C2412_IISFIC_TXFLUSH (1 << 15)
108#define S3C2412_IISFIC_RXFLUSH (1 << 7)
109#define S3C2412_IISFIC_TXCOUNT(x) (((x) >> 8) & 0xf)
110#define S3C2412_IISFIC_RXCOUNT(x) (((x) >> 0) & 0xf)
111
112#define S5PC1XX_IISFICS_TXFLUSH (1 << 15)
113#define S5PC1XX_IISFICS_TXCOUNT(x) (((x) >> 8) & 0x7f)
114
115#endif /* __ASM_ARCH_REGS_S3C2412_IIS_H */
diff --git a/sound/soc/s3c24xx/s3c-ac97.c b/sound/soc/s3c24xx/s3c-ac97.c
deleted file mode 100644
index 31f6d45b6384..000000000000
--- a/sound/soc/s3c24xx/s3c-ac97.c
+++ /dev/null
@@ -1,520 +0,0 @@
1/* sound/soc/s3c24xx/s3c-ac97.c
2 *
3 * ALSA SoC Audio Layer - S3C AC97 Controller driver
4 * Evolved from s3c2443-ac97.c
5 *
6 * Copyright (c) 2010 Samsung Electronics Co. Ltd
7 * Author: Jaswinder Singh <jassi.brar@samsung.com>
8 * Credits: Graeme Gregory, Sean Choi
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
13 */
14
15#include <linux/init.h>
16#include <linux/module.h>
17#include <linux/io.h>
18#include <linux/delay.h>
19#include <linux/clk.h>
20
21#include <sound/soc.h>
22
23#include <plat/regs-ac97.h>
24#include <mach/dma.h>
25#include <plat/audio.h>
26
27#include "s3c-dma.h"
28#include "s3c-ac97.h"
29
30#define AC_CMD_ADDR(x) (x << 16)
31#define AC_CMD_DATA(x) (x & 0xffff)
32
33struct s3c_ac97_info {
34 struct clk *ac97_clk;
35 void __iomem *regs;
36 struct mutex lock;
37 struct completion done;
38};
39static struct s3c_ac97_info s3c_ac97;
40
41static struct s3c2410_dma_client s3c_dma_client_out = {
42 .name = "AC97 PCMOut"
43};
44
45static struct s3c2410_dma_client s3c_dma_client_in = {
46 .name = "AC97 PCMIn"
47};
48
49static struct s3c2410_dma_client s3c_dma_client_micin = {
50 .name = "AC97 MicIn"
51};
52
53static struct s3c_dma_params s3c_ac97_pcm_out = {
54 .client = &s3c_dma_client_out,
55 .dma_size = 4,
56};
57
58static struct s3c_dma_params s3c_ac97_pcm_in = {
59 .client = &s3c_dma_client_in,
60 .dma_size = 4,
61};
62
63static struct s3c_dma_params s3c_ac97_mic_in = {
64 .client = &s3c_dma_client_micin,
65 .dma_size = 4,
66};
67
68static void s3c_ac97_activate(struct snd_ac97 *ac97)
69{
70 u32 ac_glbctrl, stat;
71
72 stat = readl(s3c_ac97.regs + S3C_AC97_GLBSTAT) & 0x7;
73 if (stat == S3C_AC97_GLBSTAT_MAINSTATE_ACTIVE)
74 return; /* Return if already active */
75
76 INIT_COMPLETION(s3c_ac97.done);
77
78 ac_glbctrl = readl(s3c_ac97.regs + S3C_AC97_GLBCTRL);
79 ac_glbctrl = S3C_AC97_GLBCTRL_ACLINKON;
80 writel(ac_glbctrl, s3c_ac97.regs + S3C_AC97_GLBCTRL);
81 msleep(1);
82
83 ac_glbctrl |= S3C_AC97_GLBCTRL_TRANSFERDATAENABLE;
84 writel(ac_glbctrl, s3c_ac97.regs + S3C_AC97_GLBCTRL);
85 msleep(1);
86
87 ac_glbctrl = readl(s3c_ac97.regs + S3C_AC97_GLBCTRL);
88 ac_glbctrl |= S3C_AC97_GLBCTRL_CODECREADYIE;
89 writel(ac_glbctrl, s3c_ac97.regs + S3C_AC97_GLBCTRL);
90
91 if (!wait_for_completion_timeout(&s3c_ac97.done, HZ))
92 printk(KERN_ERR "AC97: Unable to activate!");
93}
94
95static unsigned short s3c_ac97_read(struct snd_ac97 *ac97,
96 unsigned short reg)
97{
98 u32 ac_glbctrl, ac_codec_cmd;
99 u32 stat, addr, data;
100
101 mutex_lock(&s3c_ac97.lock);
102
103 s3c_ac97_activate(ac97);
104
105 INIT_COMPLETION(s3c_ac97.done);
106
107 ac_codec_cmd = readl(s3c_ac97.regs + S3C_AC97_CODEC_CMD);
108 ac_codec_cmd = S3C_AC97_CODEC_CMD_READ | AC_CMD_ADDR(reg);
109 writel(ac_codec_cmd, s3c_ac97.regs + S3C_AC97_CODEC_CMD);
110
111 udelay(50);
112
113 ac_glbctrl = readl(s3c_ac97.regs + S3C_AC97_GLBCTRL);
114 ac_glbctrl |= S3C_AC97_GLBCTRL_CODECREADYIE;
115 writel(ac_glbctrl, s3c_ac97.regs + S3C_AC97_GLBCTRL);
116
117 if (!wait_for_completion_timeout(&s3c_ac97.done, HZ))
118 printk(KERN_ERR "AC97: Unable to read!");
119
120 stat = readl(s3c_ac97.regs + S3C_AC97_STAT);
121 addr = (stat >> 16) & 0x7f;
122 data = (stat & 0xffff);
123
124 if (addr != reg)
125 printk(KERN_ERR "s3c-ac97: req addr = %02x, rep addr = %02x\n", reg, addr);
126
127 mutex_unlock(&s3c_ac97.lock);
128
129 return (unsigned short)data;
130}
131
132static void s3c_ac97_write(struct snd_ac97 *ac97, unsigned short reg,
133 unsigned short val)
134{
135 u32 ac_glbctrl, ac_codec_cmd;
136
137 mutex_lock(&s3c_ac97.lock);
138
139 s3c_ac97_activate(ac97);
140
141 INIT_COMPLETION(s3c_ac97.done);
142
143 ac_codec_cmd = readl(s3c_ac97.regs + S3C_AC97_CODEC_CMD);
144 ac_codec_cmd = AC_CMD_ADDR(reg) | AC_CMD_DATA(val);
145 writel(ac_codec_cmd, s3c_ac97.regs + S3C_AC97_CODEC_CMD);
146
147 udelay(50);
148
149 ac_glbctrl = readl(s3c_ac97.regs + S3C_AC97_GLBCTRL);
150 ac_glbctrl |= S3C_AC97_GLBCTRL_CODECREADYIE;
151 writel(ac_glbctrl, s3c_ac97.regs + S3C_AC97_GLBCTRL);
152
153 if (!wait_for_completion_timeout(&s3c_ac97.done, HZ))
154 printk(KERN_ERR "AC97: Unable to write!");
155
156 ac_codec_cmd = readl(s3c_ac97.regs + S3C_AC97_CODEC_CMD);
157 ac_codec_cmd |= S3C_AC97_CODEC_CMD_READ;
158 writel(ac_codec_cmd, s3c_ac97.regs + S3C_AC97_CODEC_CMD);
159
160 mutex_unlock(&s3c_ac97.lock);
161}
162
163static void s3c_ac97_cold_reset(struct snd_ac97 *ac97)
164{
165 writel(S3C_AC97_GLBCTRL_COLDRESET,
166 s3c_ac97.regs + S3C_AC97_GLBCTRL);
167 msleep(1);
168
169 writel(0, s3c_ac97.regs + S3C_AC97_GLBCTRL);
170 msleep(1);
171}
172
173static void s3c_ac97_warm_reset(struct snd_ac97 *ac97)
174{
175 u32 stat;
176
177 stat = readl(s3c_ac97.regs + S3C_AC97_GLBSTAT) & 0x7;
178 if (stat == S3C_AC97_GLBSTAT_MAINSTATE_ACTIVE)
179 return; /* Return if already active */
180
181 writel(S3C_AC97_GLBCTRL_WARMRESET, s3c_ac97.regs + S3C_AC97_GLBCTRL);
182 msleep(1);
183
184 writel(0, s3c_ac97.regs + S3C_AC97_GLBCTRL);
185 msleep(1);
186
187 s3c_ac97_activate(ac97);
188}
189
190static irqreturn_t s3c_ac97_irq(int irq, void *dev_id)
191{
192 u32 ac_glbctrl, ac_glbstat;
193
194 ac_glbstat = readl(s3c_ac97.regs + S3C_AC97_GLBSTAT);
195
196 if (ac_glbstat & S3C_AC97_GLBSTAT_CODECREADY) {
197
198 ac_glbctrl = readl(s3c_ac97.regs + S3C_AC97_GLBCTRL);
199 ac_glbctrl &= ~S3C_AC97_GLBCTRL_CODECREADYIE;
200 writel(ac_glbctrl, s3c_ac97.regs + S3C_AC97_GLBCTRL);
201
202 complete(&s3c_ac97.done);
203 }
204
205 ac_glbctrl = readl(s3c_ac97.regs + S3C_AC97_GLBCTRL);
206 ac_glbctrl |= (1<<30); /* Clear interrupt */
207 writel(ac_glbctrl, s3c_ac97.regs + S3C_AC97_GLBCTRL);
208
209 return IRQ_HANDLED;
210}
211
212struct snd_ac97_bus_ops soc_ac97_ops = {
213 .read = s3c_ac97_read,
214 .write = s3c_ac97_write,
215 .warm_reset = s3c_ac97_warm_reset,
216 .reset = s3c_ac97_cold_reset,
217};
218EXPORT_SYMBOL_GPL(soc_ac97_ops);
219
220static int s3c_ac97_hw_params(struct snd_pcm_substream *substream,
221 struct snd_pcm_hw_params *params,
222 struct snd_soc_dai *dai)
223{
224 struct snd_soc_pcm_runtime *rtd = substream->private_data;
225 struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
226 struct s3c_dma_params *dma_data;
227
228 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
229 dma_data = &s3c_ac97_pcm_out;
230 else
231 dma_data = &s3c_ac97_pcm_in;
232
233 snd_soc_dai_set_dma_data(cpu_dai, substream, dma_data);
234
235 return 0;
236}
237
238static int s3c_ac97_trigger(struct snd_pcm_substream *substream, int cmd,
239 struct snd_soc_dai *dai)
240{
241 u32 ac_glbctrl;
242 struct snd_soc_pcm_runtime *rtd = substream->private_data;
243 struct s3c_dma_params *dma_data =
244 snd_soc_dai_get_dma_data(rtd->dai->cpu_dai, substream);
245
246 ac_glbctrl = readl(s3c_ac97.regs + S3C_AC97_GLBCTRL);
247 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
248 ac_glbctrl &= ~S3C_AC97_GLBCTRL_PCMINTM_MASK;
249 else
250 ac_glbctrl &= ~S3C_AC97_GLBCTRL_PCMOUTTM_MASK;
251
252 switch (cmd) {
253 case SNDRV_PCM_TRIGGER_START:
254 case SNDRV_PCM_TRIGGER_RESUME:
255 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
256 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
257 ac_glbctrl |= S3C_AC97_GLBCTRL_PCMINTM_DMA;
258 else
259 ac_glbctrl |= S3C_AC97_GLBCTRL_PCMOUTTM_DMA;
260 break;
261
262 case SNDRV_PCM_TRIGGER_STOP:
263 case SNDRV_PCM_TRIGGER_SUSPEND:
264 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
265 break;
266 }
267
268 writel(ac_glbctrl, s3c_ac97.regs + S3C_AC97_GLBCTRL);
269
270 s3c2410_dma_ctrl(dma_data->channel, S3C2410_DMAOP_STARTED);
271
272 return 0;
273}
274
275static int s3c_ac97_hw_mic_params(struct snd_pcm_substream *substream,
276 struct snd_pcm_hw_params *params,
277 struct snd_soc_dai *dai)
278{
279 struct snd_soc_pcm_runtime *rtd = substream->private_data;
280 struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
281
282 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
283 return -ENODEV;
284 else
285 snd_soc_dai_set_dma_data(cpu_dai, substream, &s3c_ac97_mic_in);
286
287 return 0;
288}
289
290static int s3c_ac97_mic_trigger(struct snd_pcm_substream *substream,
291 int cmd, struct snd_soc_dai *dai)
292{
293 u32 ac_glbctrl;
294 struct snd_soc_pcm_runtime *rtd = substream->private_data;
295 struct s3c_dma_params *dma_data =
296 snd_soc_dai_get_dma_data(rtd->dai->cpu_dai, substream);
297
298 ac_glbctrl = readl(s3c_ac97.regs + S3C_AC97_GLBCTRL);
299 ac_glbctrl &= ~S3C_AC97_GLBCTRL_MICINTM_MASK;
300
301 switch (cmd) {
302 case SNDRV_PCM_TRIGGER_START:
303 case SNDRV_PCM_TRIGGER_RESUME:
304 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
305 ac_glbctrl |= S3C_AC97_GLBCTRL_MICINTM_DMA;
306 break;
307
308 case SNDRV_PCM_TRIGGER_STOP:
309 case SNDRV_PCM_TRIGGER_SUSPEND:
310 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
311 break;
312 }
313
314 writel(ac_glbctrl, s3c_ac97.regs + S3C_AC97_GLBCTRL);
315
316 s3c2410_dma_ctrl(dma_data->channel, S3C2410_DMAOP_STARTED);
317
318 return 0;
319}
320
321static struct snd_soc_dai_ops s3c_ac97_dai_ops = {
322 .hw_params = s3c_ac97_hw_params,
323 .trigger = s3c_ac97_trigger,
324};
325
326static struct snd_soc_dai_ops s3c_ac97_mic_dai_ops = {
327 .hw_params = s3c_ac97_hw_mic_params,
328 .trigger = s3c_ac97_mic_trigger,
329};
330
331struct snd_soc_dai s3c_ac97_dai[] = {
332 [S3C_AC97_DAI_PCM] = {
333 .name = "s3c-ac97",
334 .id = S3C_AC97_DAI_PCM,
335 .ac97_control = 1,
336 .playback = {
337 .stream_name = "AC97 Playback",
338 .channels_min = 2,
339 .channels_max = 2,
340 .rates = SNDRV_PCM_RATE_8000_48000,
341 .formats = SNDRV_PCM_FMTBIT_S16_LE,},
342 .capture = {
343 .stream_name = "AC97 Capture",
344 .channels_min = 2,
345 .channels_max = 2,
346 .rates = SNDRV_PCM_RATE_8000_48000,
347 .formats = SNDRV_PCM_FMTBIT_S16_LE,},
348 .ops = &s3c_ac97_dai_ops,
349 },
350 [S3C_AC97_DAI_MIC] = {
351 .name = "s3c-ac97-mic",
352 .id = S3C_AC97_DAI_MIC,
353 .ac97_control = 1,
354 .capture = {
355 .stream_name = "AC97 Mic Capture",
356 .channels_min = 1,
357 .channels_max = 1,
358 .rates = SNDRV_PCM_RATE_8000_48000,
359 .formats = SNDRV_PCM_FMTBIT_S16_LE,},
360 .ops = &s3c_ac97_mic_dai_ops,
361 },
362};
363EXPORT_SYMBOL_GPL(s3c_ac97_dai);
364
365static __devinit int s3c_ac97_probe(struct platform_device *pdev)
366{
367 struct resource *mem_res, *dmatx_res, *dmarx_res, *dmamic_res, *irq_res;
368 struct s3c_audio_pdata *ac97_pdata;
369 int ret;
370
371 ac97_pdata = pdev->dev.platform_data;
372 if (!ac97_pdata || !ac97_pdata->cfg_gpio) {
373 dev_err(&pdev->dev, "cfg_gpio callback not provided!\n");
374 return -EINVAL;
375 }
376
377 /* Check for availability of necessary resource */
378 dmatx_res = platform_get_resource(pdev, IORESOURCE_DMA, 0);
379 if (!dmatx_res) {
380 dev_err(&pdev->dev, "Unable to get AC97-TX dma resource\n");
381 return -ENXIO;
382 }
383
384 dmarx_res = platform_get_resource(pdev, IORESOURCE_DMA, 1);
385 if (!dmarx_res) {
386 dev_err(&pdev->dev, "Unable to get AC97-RX dma resource\n");
387 return -ENXIO;
388 }
389
390 dmamic_res = platform_get_resource(pdev, IORESOURCE_DMA, 2);
391 if (!dmamic_res) {
392 dev_err(&pdev->dev, "Unable to get AC97-MIC dma resource\n");
393 return -ENXIO;
394 }
395
396 mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
397 if (!mem_res) {
398 dev_err(&pdev->dev, "Unable to get register resource\n");
399 return -ENXIO;
400 }
401
402 irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
403 if (!irq_res) {
404 dev_err(&pdev->dev, "AC97 IRQ not provided!\n");
405 return -ENXIO;
406 }
407
408 if (!request_mem_region(mem_res->start,
409 resource_size(mem_res), "s3c-ac97")) {
410 dev_err(&pdev->dev, "Unable to request register region\n");
411 return -EBUSY;
412 }
413
414 s3c_ac97_pcm_out.channel = dmatx_res->start;
415 s3c_ac97_pcm_out.dma_addr = mem_res->start + S3C_AC97_PCM_DATA;
416 s3c_ac97_pcm_in.channel = dmarx_res->start;
417 s3c_ac97_pcm_in.dma_addr = mem_res->start + S3C_AC97_PCM_DATA;
418 s3c_ac97_mic_in.channel = dmamic_res->start;
419 s3c_ac97_mic_in.dma_addr = mem_res->start + S3C_AC97_MIC_DATA;
420
421 init_completion(&s3c_ac97.done);
422 mutex_init(&s3c_ac97.lock);
423
424 s3c_ac97.regs = ioremap(mem_res->start, resource_size(mem_res));
425 if (s3c_ac97.regs == NULL) {
426 dev_err(&pdev->dev, "Unable to ioremap register region\n");
427 ret = -ENXIO;
428 goto err1;
429 }
430
431 s3c_ac97.ac97_clk = clk_get(&pdev->dev, "ac97");
432 if (IS_ERR(s3c_ac97.ac97_clk)) {
433 dev_err(&pdev->dev, "s3c-ac97 failed to get ac97_clock\n");
434 ret = -ENODEV;
435 goto err2;
436 }
437 clk_enable(s3c_ac97.ac97_clk);
438
439 if (ac97_pdata->cfg_gpio(pdev)) {
440 dev_err(&pdev->dev, "Unable to configure gpio\n");
441 ret = -EINVAL;
442 goto err3;
443 }
444
445 ret = request_irq(irq_res->start, s3c_ac97_irq,
446 IRQF_DISABLED, "AC97", NULL);
447 if (ret < 0) {
448 printk(KERN_ERR "s3c-ac97: interrupt request failed.\n");
449 goto err4;
450 }
451
452 s3c_ac97_dai[S3C_AC97_DAI_PCM].dev = &pdev->dev;
453 s3c_ac97_dai[S3C_AC97_DAI_MIC].dev = &pdev->dev;
454
455 ret = snd_soc_register_dais(s3c_ac97_dai, ARRAY_SIZE(s3c_ac97_dai));
456 if (ret)
457 goto err5;
458
459 return 0;
460
461err5:
462 free_irq(irq_res->start, NULL);
463err4:
464err3:
465 clk_disable(s3c_ac97.ac97_clk);
466 clk_put(s3c_ac97.ac97_clk);
467err2:
468 iounmap(s3c_ac97.regs);
469err1:
470 release_mem_region(mem_res->start, resource_size(mem_res));
471
472 return ret;
473}
474
475static __devexit int s3c_ac97_remove(struct platform_device *pdev)
476{
477 struct resource *mem_res, *irq_res;
478
479 snd_soc_unregister_dais(s3c_ac97_dai, ARRAY_SIZE(s3c_ac97_dai));
480
481 irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
482 if (irq_res)
483 free_irq(irq_res->start, NULL);
484
485 clk_disable(s3c_ac97.ac97_clk);
486 clk_put(s3c_ac97.ac97_clk);
487
488 iounmap(s3c_ac97.regs);
489
490 mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
491 if (mem_res)
492 release_mem_region(mem_res->start, resource_size(mem_res));
493
494 return 0;
495}
496
497static struct platform_driver s3c_ac97_driver = {
498 .probe = s3c_ac97_probe,
499 .remove = s3c_ac97_remove,
500 .driver = {
501 .name = "s3c-ac97",
502 .owner = THIS_MODULE,
503 },
504};
505
506static int __init s3c_ac97_init(void)
507{
508 return platform_driver_register(&s3c_ac97_driver);
509}
510module_init(s3c_ac97_init);
511
512static void __exit s3c_ac97_exit(void)
513{
514 platform_driver_unregister(&s3c_ac97_driver);
515}
516module_exit(s3c_ac97_exit);
517
518MODULE_AUTHOR("Jaswinder Singh, <jassi.brar@samsung.com>");
519MODULE_DESCRIPTION("AC97 driver for the Samsung SoC");
520MODULE_LICENSE("GPL");
diff --git a/sound/soc/s3c24xx/s3c-ac97.h b/sound/soc/s3c24xx/s3c-ac97.h
deleted file mode 100644
index 278198379def..000000000000
--- a/sound/soc/s3c24xx/s3c-ac97.h
+++ /dev/null
@@ -1,23 +0,0 @@
1/* sound/soc/s3c24xx/s3c-ac97.h
2 *
3 * ALSA SoC Audio Layer - S3C AC97 Controller driver
4 * Evolved from s3c2443-ac97.h
5 *
6 * Copyright (c) 2010 Samsung Electronics Co. Ltd
7 * Author: Jaswinder Singh <jassi.brar@samsung.com>
8 * Credits: Graeme Gregory, Sean Choi
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
13 */
14
15#ifndef __S3C_AC97_H_
16#define __S3C_AC97_H_
17
18#define S3C_AC97_DAI_PCM 0
19#define S3C_AC97_DAI_MIC 1
20
21extern struct snd_soc_dai s3c_ac97_dai[];
22
23#endif /* __S3C_AC97_H_ */
diff --git a/sound/soc/s3c24xx/s3c-dma.c b/sound/soc/s3c24xx/s3c-dma.c
deleted file mode 100644
index f1b1bc4bacfb..000000000000
--- a/sound/soc/s3c24xx/s3c-dma.c
+++ /dev/null
@@ -1,482 +0,0 @@
1/*
2 * s3c-dma.c -- ALSA Soc Audio Layer
3 *
4 * (c) 2006 Wolfson Microelectronics PLC.
5 * Graeme Gregory graeme.gregory@wolfsonmicro.com or linux@wolfsonmicro.com
6 *
7 * Copyright 2004-2005 Simtec Electronics
8 * http://armlinux.simtec.co.uk/
9 * Ben Dooks <ben@simtec.co.uk>
10 *
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by the
13 * Free Software Foundation; either version 2 of the License, or (at your
14 * option) any later version.
15 */
16
17#include <linux/module.h>
18#include <linux/init.h>
19#include <linux/io.h>
20#include <linux/platform_device.h>
21#include <linux/slab.h>
22#include <linux/dma-mapping.h>
23
24#include <sound/core.h>
25#include <sound/pcm.h>
26#include <sound/pcm_params.h>
27#include <sound/soc.h>
28
29#include <asm/dma.h>
30#include <mach/hardware.h>
31#include <mach/dma.h>
32
33#include "s3c-dma.h"
34
35static const struct snd_pcm_hardware s3c_dma_hardware = {
36 .info = SNDRV_PCM_INFO_INTERLEAVED |
37 SNDRV_PCM_INFO_BLOCK_TRANSFER |
38 SNDRV_PCM_INFO_MMAP |
39 SNDRV_PCM_INFO_MMAP_VALID |
40 SNDRV_PCM_INFO_PAUSE |
41 SNDRV_PCM_INFO_RESUME,
42 .formats = SNDRV_PCM_FMTBIT_S16_LE |
43 SNDRV_PCM_FMTBIT_U16_LE |
44 SNDRV_PCM_FMTBIT_U8 |
45 SNDRV_PCM_FMTBIT_S8,
46 .channels_min = 2,
47 .channels_max = 2,
48 .buffer_bytes_max = 128*1024,
49 .period_bytes_min = PAGE_SIZE,
50 .period_bytes_max = PAGE_SIZE*2,
51 .periods_min = 2,
52 .periods_max = 128,
53 .fifo_size = 32,
54};
55
56struct s3c24xx_runtime_data {
57 spinlock_t lock;
58 int state;
59 unsigned int dma_loaded;
60 unsigned int dma_limit;
61 unsigned int dma_period;
62 dma_addr_t dma_start;
63 dma_addr_t dma_pos;
64 dma_addr_t dma_end;
65 struct s3c_dma_params *params;
66};
67
68/* s3c_dma_enqueue
69 *
70 * place a dma buffer onto the queue for the dma system
71 * to handle.
72*/
73static void s3c_dma_enqueue(struct snd_pcm_substream *substream)
74{
75 struct s3c24xx_runtime_data *prtd = substream->runtime->private_data;
76 dma_addr_t pos = prtd->dma_pos;
77 unsigned int limit;
78 int ret;
79
80 pr_debug("Entered %s\n", __func__);
81
82 if (s3c_dma_has_circular())
83 limit = (prtd->dma_end - prtd->dma_start) / prtd->dma_period;
84 else
85 limit = prtd->dma_limit;
86
87 pr_debug("%s: loaded %d, limit %d\n",
88 __func__, prtd->dma_loaded, limit);
89
90 while (prtd->dma_loaded < limit) {
91 unsigned long len = prtd->dma_period;
92
93 pr_debug("dma_loaded: %d\n", prtd->dma_loaded);
94
95 if ((pos + len) > prtd->dma_end) {
96 len = prtd->dma_end - pos;
97 pr_debug("%s: corrected dma len %ld\n", __func__, len);
98 }
99
100 ret = s3c2410_dma_enqueue(prtd->params->channel,
101 substream, pos, len);
102
103 if (ret == 0) {
104 prtd->dma_loaded++;
105 pos += prtd->dma_period;
106 if (pos >= prtd->dma_end)
107 pos = prtd->dma_start;
108 } else
109 break;
110 }
111
112 prtd->dma_pos = pos;
113}
114
115static void s3c24xx_audio_buffdone(struct s3c2410_dma_chan *channel,
116 void *dev_id, int size,
117 enum s3c2410_dma_buffresult result)
118{
119 struct snd_pcm_substream *substream = dev_id;
120 struct s3c24xx_runtime_data *prtd;
121
122 pr_debug("Entered %s\n", __func__);
123
124 if (result == S3C2410_RES_ABORT || result == S3C2410_RES_ERR)
125 return;
126
127 prtd = substream->runtime->private_data;
128
129 if (substream)
130 snd_pcm_period_elapsed(substream);
131
132 spin_lock(&prtd->lock);
133 if (prtd->state & ST_RUNNING && !s3c_dma_has_circular()) {
134 prtd->dma_loaded--;
135 s3c_dma_enqueue(substream);
136 }
137
138 spin_unlock(&prtd->lock);
139}
140
141static int s3c_dma_hw_params(struct snd_pcm_substream *substream,
142 struct snd_pcm_hw_params *params)
143{
144 struct snd_pcm_runtime *runtime = substream->runtime;
145 struct s3c24xx_runtime_data *prtd = runtime->private_data;
146 struct snd_soc_pcm_runtime *rtd = substream->private_data;
147 unsigned long totbytes = params_buffer_bytes(params);
148 struct s3c_dma_params *dma =
149 snd_soc_dai_get_dma_data(rtd->dai->cpu_dai, substream);
150 int ret = 0;
151
152
153 pr_debug("Entered %s\n", __func__);
154
155 /* return if this is a bufferless transfer e.g.
156 * codec <--> BT codec or GSM modem -- lg FIXME */
157 if (!dma)
158 return 0;
159
160 /* this may get called several times by oss emulation
161 * with different params -HW */
162 if (prtd->params == NULL) {
163 /* prepare DMA */
164 prtd->params = dma;
165
166 pr_debug("params %p, client %p, channel %d\n", prtd->params,
167 prtd->params->client, prtd->params->channel);
168
169 ret = s3c2410_dma_request(prtd->params->channel,
170 prtd->params->client, NULL);
171
172 if (ret < 0) {
173 printk(KERN_ERR "failed to get dma channel\n");
174 return ret;
175 }
176
177 /* use the circular buffering if we have it available. */
178 if (s3c_dma_has_circular())
179 s3c2410_dma_setflags(prtd->params->channel,
180 S3C2410_DMAF_CIRCULAR);
181 }
182
183 s3c2410_dma_set_buffdone_fn(prtd->params->channel,
184 s3c24xx_audio_buffdone);
185
186 snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
187
188 runtime->dma_bytes = totbytes;
189
190 spin_lock_irq(&prtd->lock);
191 prtd->dma_loaded = 0;
192 prtd->dma_limit = runtime->hw.periods_min;
193 prtd->dma_period = params_period_bytes(params);
194 prtd->dma_start = runtime->dma_addr;
195 prtd->dma_pos = prtd->dma_start;
196 prtd->dma_end = prtd->dma_start + totbytes;
197 spin_unlock_irq(&prtd->lock);
198
199 return 0;
200}
201
202static int s3c_dma_hw_free(struct snd_pcm_substream *substream)
203{
204 struct s3c24xx_runtime_data *prtd = substream->runtime->private_data;
205
206 pr_debug("Entered %s\n", __func__);
207
208 /* TODO - do we need to ensure DMA flushed */
209 snd_pcm_set_runtime_buffer(substream, NULL);
210
211 if (prtd->params) {
212 s3c2410_dma_free(prtd->params->channel, prtd->params->client);
213 prtd->params = NULL;
214 }
215
216 return 0;
217}
218
219static int s3c_dma_prepare(struct snd_pcm_substream *substream)
220{
221 struct s3c24xx_runtime_data *prtd = substream->runtime->private_data;
222 int ret = 0;
223
224 pr_debug("Entered %s\n", __func__);
225
226 /* return if this is a bufferless transfer e.g.
227 * codec <--> BT codec or GSM modem -- lg FIXME */
228 if (!prtd->params)
229 return 0;
230
231 /* channel needs configuring for mem=>device, increment memory addr,
232 * sync to pclk, half-word transfers to the IIS-FIFO. */
233 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
234 s3c2410_dma_devconfig(prtd->params->channel,
235 S3C2410_DMASRC_MEM,
236 prtd->params->dma_addr);
237 } else {
238 s3c2410_dma_devconfig(prtd->params->channel,
239 S3C2410_DMASRC_HW,
240 prtd->params->dma_addr);
241 }
242
243 s3c2410_dma_config(prtd->params->channel,
244 prtd->params->dma_size);
245
246 /* flush the DMA channel */
247 s3c2410_dma_ctrl(prtd->params->channel, S3C2410_DMAOP_FLUSH);
248 prtd->dma_loaded = 0;
249 prtd->dma_pos = prtd->dma_start;
250
251 /* enqueue dma buffers */
252 s3c_dma_enqueue(substream);
253
254 return ret;
255}
256
257static int s3c_dma_trigger(struct snd_pcm_substream *substream, int cmd)
258{
259 struct s3c24xx_runtime_data *prtd = substream->runtime->private_data;
260 int ret = 0;
261
262 pr_debug("Entered %s\n", __func__);
263
264 spin_lock(&prtd->lock);
265
266 switch (cmd) {
267 case SNDRV_PCM_TRIGGER_START:
268 case SNDRV_PCM_TRIGGER_RESUME:
269 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
270 prtd->state |= ST_RUNNING;
271 s3c2410_dma_ctrl(prtd->params->channel, S3C2410_DMAOP_START);
272 break;
273
274 case SNDRV_PCM_TRIGGER_STOP:
275 case SNDRV_PCM_TRIGGER_SUSPEND:
276 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
277 prtd->state &= ~ST_RUNNING;
278 s3c2410_dma_ctrl(prtd->params->channel, S3C2410_DMAOP_STOP);
279 break;
280
281 default:
282 ret = -EINVAL;
283 break;
284 }
285
286 spin_unlock(&prtd->lock);
287
288 return ret;
289}
290
291static snd_pcm_uframes_t
292s3c_dma_pointer(struct snd_pcm_substream *substream)
293{
294 struct snd_pcm_runtime *runtime = substream->runtime;
295 struct s3c24xx_runtime_data *prtd = runtime->private_data;
296 unsigned long res;
297 dma_addr_t src, dst;
298
299 pr_debug("Entered %s\n", __func__);
300
301 spin_lock(&prtd->lock);
302 s3c2410_dma_getposition(prtd->params->channel, &src, &dst);
303
304 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
305 res = dst - prtd->dma_start;
306 else
307 res = src - prtd->dma_start;
308
309 spin_unlock(&prtd->lock);
310
311 pr_debug("Pointer %x %x\n", src, dst);
312
313 /* we seem to be getting the odd error from the pcm library due
314 * to out-of-bounds pointers. this is maybe due to the dma engine
315 * not having loaded the new values for the channel before being
316 * callled... (todo - fix )
317 */
318
319 if (res >= snd_pcm_lib_buffer_bytes(substream)) {
320 if (res == snd_pcm_lib_buffer_bytes(substream))
321 res = 0;
322 }
323
324 return bytes_to_frames(substream->runtime, res);
325}
326
327static int s3c_dma_open(struct snd_pcm_substream *substream)
328{
329 struct snd_pcm_runtime *runtime = substream->runtime;
330 struct s3c24xx_runtime_data *prtd;
331
332 pr_debug("Entered %s\n", __func__);
333
334 snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
335 snd_soc_set_runtime_hwparams(substream, &s3c_dma_hardware);
336
337 prtd = kzalloc(sizeof(struct s3c24xx_runtime_data), GFP_KERNEL);
338 if (prtd == NULL)
339 return -ENOMEM;
340
341 spin_lock_init(&prtd->lock);
342
343 runtime->private_data = prtd;
344 return 0;
345}
346
347static int s3c_dma_close(struct snd_pcm_substream *substream)
348{
349 struct snd_pcm_runtime *runtime = substream->runtime;
350 struct s3c24xx_runtime_data *prtd = runtime->private_data;
351
352 pr_debug("Entered %s\n", __func__);
353
354 if (!prtd)
355 pr_debug("s3c_dma_close called with prtd == NULL\n");
356
357 kfree(prtd);
358
359 return 0;
360}
361
362static int s3c_dma_mmap(struct snd_pcm_substream *substream,
363 struct vm_area_struct *vma)
364{
365 struct snd_pcm_runtime *runtime = substream->runtime;
366
367 pr_debug("Entered %s\n", __func__);
368
369 return dma_mmap_writecombine(substream->pcm->card->dev, vma,
370 runtime->dma_area,
371 runtime->dma_addr,
372 runtime->dma_bytes);
373}
374
375static struct snd_pcm_ops s3c_dma_ops = {
376 .open = s3c_dma_open,
377 .close = s3c_dma_close,
378 .ioctl = snd_pcm_lib_ioctl,
379 .hw_params = s3c_dma_hw_params,
380 .hw_free = s3c_dma_hw_free,
381 .prepare = s3c_dma_prepare,
382 .trigger = s3c_dma_trigger,
383 .pointer = s3c_dma_pointer,
384 .mmap = s3c_dma_mmap,
385};
386
387static int s3c_preallocate_dma_buffer(struct snd_pcm *pcm, int stream)
388{
389 struct snd_pcm_substream *substream = pcm->streams[stream].substream;
390 struct snd_dma_buffer *buf = &substream->dma_buffer;
391 size_t size = s3c_dma_hardware.buffer_bytes_max;
392
393 pr_debug("Entered %s\n", __func__);
394
395 buf->dev.type = SNDRV_DMA_TYPE_DEV;
396 buf->dev.dev = pcm->card->dev;
397 buf->private_data = NULL;
398 buf->area = dma_alloc_writecombine(pcm->card->dev, size,
399 &buf->addr, GFP_KERNEL);
400 if (!buf->area)
401 return -ENOMEM;
402 buf->bytes = size;
403 return 0;
404}
405
406static void s3c_dma_free_dma_buffers(struct snd_pcm *pcm)
407{
408 struct snd_pcm_substream *substream;
409 struct snd_dma_buffer *buf;
410 int stream;
411
412 pr_debug("Entered %s\n", __func__);
413
414 for (stream = 0; stream < 2; stream++) {
415 substream = pcm->streams[stream].substream;
416 if (!substream)
417 continue;
418
419 buf = &substream->dma_buffer;
420 if (!buf->area)
421 continue;
422
423 dma_free_writecombine(pcm->card->dev, buf->bytes,
424 buf->area, buf->addr);
425 buf->area = NULL;
426 }
427}
428
429static u64 s3c_dma_mask = DMA_BIT_MASK(32);
430
431static int s3c_dma_new(struct snd_card *card,
432 struct snd_soc_dai *dai, struct snd_pcm *pcm)
433{
434 int ret = 0;
435
436 pr_debug("Entered %s\n", __func__);
437
438 if (!card->dev->dma_mask)
439 card->dev->dma_mask = &s3c_dma_mask;
440 if (!card->dev->coherent_dma_mask)
441 card->dev->coherent_dma_mask = 0xffffffff;
442
443 if (dai->playback.channels_min) {
444 ret = s3c_preallocate_dma_buffer(pcm,
445 SNDRV_PCM_STREAM_PLAYBACK);
446 if (ret)
447 goto out;
448 }
449
450 if (dai->capture.channels_min) {
451 ret = s3c_preallocate_dma_buffer(pcm,
452 SNDRV_PCM_STREAM_CAPTURE);
453 if (ret)
454 goto out;
455 }
456 out:
457 return ret;
458}
459
460struct snd_soc_platform s3c24xx_soc_platform = {
461 .name = "s3c24xx-audio",
462 .pcm_ops = &s3c_dma_ops,
463 .pcm_new = s3c_dma_new,
464 .pcm_free = s3c_dma_free_dma_buffers,
465};
466EXPORT_SYMBOL_GPL(s3c24xx_soc_platform);
467
468static int __init s3c24xx_soc_platform_init(void)
469{
470 return snd_soc_register_platform(&s3c24xx_soc_platform);
471}
472module_init(s3c24xx_soc_platform_init);
473
474static void __exit s3c24xx_soc_platform_exit(void)
475{
476 snd_soc_unregister_platform(&s3c24xx_soc_platform);
477}
478module_exit(s3c24xx_soc_platform_exit);
479
480MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>");
481MODULE_DESCRIPTION("Samsung S3C Audio DMA module");
482MODULE_LICENSE("GPL");
diff --git a/sound/soc/s3c24xx/s3c-dma.h b/sound/soc/s3c24xx/s3c-dma.h
deleted file mode 100644
index 69bb6bf6fc1c..000000000000
--- a/sound/soc/s3c24xx/s3c-dma.h
+++ /dev/null
@@ -1,31 +0,0 @@
1/*
2 * s3c-dma.h --
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License as published by the
6 * Free Software Foundation; either version 2 of the License, or (at your
7 * option) any later version.
8 *
9 * ALSA PCM interface for the Samsung S3C24xx CPU
10 */
11
12#ifndef _S3C_AUDIO_H
13#define _S3C_AUDIO_H
14
15#define ST_RUNNING (1<<0)
16#define ST_OPENED (1<<1)
17
18struct s3c_dma_params {
19 struct s3c2410_dma_client *client; /* stream identifier */
20 int channel; /* Channel ID */
21 dma_addr_t dma_addr;
22 int dma_size; /* Size of the DMA transfer */
23};
24
25#define S3C24XX_DAI_I2S 0
26
27/* platform data */
28extern struct snd_soc_platform s3c24xx_soc_platform;
29extern struct snd_ac97_bus_ops s3c24xx_ac97_ops;
30
31#endif
diff --git a/sound/soc/s3c24xx/s3c-i2s-v2.c b/sound/soc/s3c24xx/s3c-i2s-v2.c
deleted file mode 100644
index 64376b2aac73..000000000000
--- a/sound/soc/s3c24xx/s3c-i2s-v2.c
+++ /dev/null
@@ -1,777 +0,0 @@
1/* sound/soc/s3c24xx/s3c-i2c-v2.c
2 *
3 * ALSA Soc Audio Layer - I2S core for newer Samsung SoCs.
4 *
5 * Copyright (c) 2006 Wolfson Microelectronics PLC.
6 * Graeme Gregory graeme.gregory@wolfsonmicro.com
7 * linux@wolfsonmicro.com
8 *
9 * Copyright (c) 2008, 2007, 2004-2005 Simtec Electronics
10 * http://armlinux.simtec.co.uk/
11 * Ben Dooks <ben@simtec.co.uk>
12 *
13 * This program is free software; you can redistribute it and/or modify it
14 * under the terms of the GNU General Public License as published by the
15 * Free Software Foundation; either version 2 of the License, or (at your
16 * option) any later version.
17 */
18
19#include <linux/delay.h>
20#include <linux/clk.h>
21#include <linux/io.h>
22
23#include <sound/pcm.h>
24#include <sound/pcm_params.h>
25#include <sound/soc.h>
26
27#include <mach/dma.h>
28
29#include "regs-i2s-v2.h"
30#include "s3c-i2s-v2.h"
31#include "s3c-dma.h"
32
33#undef S3C_IIS_V2_SUPPORTED
34
35#if defined(CONFIG_CPU_S3C2412) || defined(CONFIG_CPU_S3C2413) \
36 || defined(CONFIG_CPU_S5PV210)
37#define S3C_IIS_V2_SUPPORTED
38#endif
39
40#ifdef CONFIG_PLAT_S3C64XX
41#define S3C_IIS_V2_SUPPORTED
42#endif
43
44#ifndef S3C_IIS_V2_SUPPORTED
45#error Unsupported CPU model
46#endif
47
48#define S3C2412_I2S_DEBUG_CON 0
49
50static inline struct s3c_i2sv2_info *to_info(struct snd_soc_dai *cpu_dai)
51{
52 return cpu_dai->private_data;
53}
54
55#define bit_set(v, b) (((v) & (b)) ? 1 : 0)
56
57#if S3C2412_I2S_DEBUG_CON
58static void dbg_showcon(const char *fn, u32 con)
59{
60 printk(KERN_DEBUG "%s: LRI=%d, TXFEMPT=%d, RXFEMPT=%d, TXFFULL=%d, RXFFULL=%d\n", fn,
61 bit_set(con, S3C2412_IISCON_LRINDEX),
62 bit_set(con, S3C2412_IISCON_TXFIFO_EMPTY),
63 bit_set(con, S3C2412_IISCON_RXFIFO_EMPTY),
64 bit_set(con, S3C2412_IISCON_TXFIFO_FULL),
65 bit_set(con, S3C2412_IISCON_RXFIFO_FULL));
66
67 printk(KERN_DEBUG "%s: PAUSE: TXDMA=%d, RXDMA=%d, TXCH=%d, RXCH=%d\n",
68 fn,
69 bit_set(con, S3C2412_IISCON_TXDMA_PAUSE),
70 bit_set(con, S3C2412_IISCON_RXDMA_PAUSE),
71 bit_set(con, S3C2412_IISCON_TXCH_PAUSE),
72 bit_set(con, S3C2412_IISCON_RXCH_PAUSE));
73 printk(KERN_DEBUG "%s: ACTIVE: TXDMA=%d, RXDMA=%d, IIS=%d\n", fn,
74 bit_set(con, S3C2412_IISCON_TXDMA_ACTIVE),
75 bit_set(con, S3C2412_IISCON_RXDMA_ACTIVE),
76 bit_set(con, S3C2412_IISCON_IIS_ACTIVE));
77}
78#else
79static inline void dbg_showcon(const char *fn, u32 con)
80{
81}
82#endif
83
84
85/* Turn on or off the transmission path. */
86static void s3c2412_snd_txctrl(struct s3c_i2sv2_info *i2s, int on)
87{
88 void __iomem *regs = i2s->regs;
89 u32 fic, con, mod;
90
91 pr_debug("%s(%d)\n", __func__, on);
92
93 fic = readl(regs + S3C2412_IISFIC);
94 con = readl(regs + S3C2412_IISCON);
95 mod = readl(regs + S3C2412_IISMOD);
96
97 pr_debug("%s: IIS: CON=%x MOD=%x FIC=%x\n", __func__, con, mod, fic);
98
99 if (on) {
100 con |= S3C2412_IISCON_TXDMA_ACTIVE | S3C2412_IISCON_IIS_ACTIVE;
101 con &= ~S3C2412_IISCON_TXDMA_PAUSE;
102 con &= ~S3C2412_IISCON_TXCH_PAUSE;
103
104 switch (mod & S3C2412_IISMOD_MODE_MASK) {
105 case S3C2412_IISMOD_MODE_TXONLY:
106 case S3C2412_IISMOD_MODE_TXRX:
107 /* do nothing, we are in the right mode */
108 break;
109
110 case S3C2412_IISMOD_MODE_RXONLY:
111 mod &= ~S3C2412_IISMOD_MODE_MASK;
112 mod |= S3C2412_IISMOD_MODE_TXRX;
113 break;
114
115 default:
116 dev_err(i2s->dev, "TXEN: Invalid MODE %x in IISMOD\n",
117 mod & S3C2412_IISMOD_MODE_MASK);
118 break;
119 }
120
121 writel(con, regs + S3C2412_IISCON);
122 writel(mod, regs + S3C2412_IISMOD);
123 } else {
124 /* Note, we do not have any indication that the FIFO problems
125 * tha the S3C2410/2440 had apply here, so we should be able
126 * to disable the DMA and TX without resetting the FIFOS.
127 */
128
129 con |= S3C2412_IISCON_TXDMA_PAUSE;
130 con |= S3C2412_IISCON_TXCH_PAUSE;
131 con &= ~S3C2412_IISCON_TXDMA_ACTIVE;
132
133 switch (mod & S3C2412_IISMOD_MODE_MASK) {
134 case S3C2412_IISMOD_MODE_TXRX:
135 mod &= ~S3C2412_IISMOD_MODE_MASK;
136 mod |= S3C2412_IISMOD_MODE_RXONLY;
137 break;
138
139 case S3C2412_IISMOD_MODE_TXONLY:
140 mod &= ~S3C2412_IISMOD_MODE_MASK;
141 con &= ~S3C2412_IISCON_IIS_ACTIVE;
142 break;
143
144 default:
145 dev_err(i2s->dev, "TXDIS: Invalid MODE %x in IISMOD\n",
146 mod & S3C2412_IISMOD_MODE_MASK);
147 break;
148 }
149
150 writel(mod, regs + S3C2412_IISMOD);
151 writel(con, regs + S3C2412_IISCON);
152 }
153
154 fic = readl(regs + S3C2412_IISFIC);
155 dbg_showcon(__func__, con);
156 pr_debug("%s: IIS: CON=%x MOD=%x FIC=%x\n", __func__, con, mod, fic);
157}
158
159static void s3c2412_snd_rxctrl(struct s3c_i2sv2_info *i2s, int on)
160{
161 void __iomem *regs = i2s->regs;
162 u32 fic, con, mod;
163
164 pr_debug("%s(%d)\n", __func__, on);
165
166 fic = readl(regs + S3C2412_IISFIC);
167 con = readl(regs + S3C2412_IISCON);
168 mod = readl(regs + S3C2412_IISMOD);
169
170 pr_debug("%s: IIS: CON=%x MOD=%x FIC=%x\n", __func__, con, mod, fic);
171
172 if (on) {
173 con |= S3C2412_IISCON_RXDMA_ACTIVE | S3C2412_IISCON_IIS_ACTIVE;
174 con &= ~S3C2412_IISCON_RXDMA_PAUSE;
175 con &= ~S3C2412_IISCON_RXCH_PAUSE;
176
177 switch (mod & S3C2412_IISMOD_MODE_MASK) {
178 case S3C2412_IISMOD_MODE_TXRX:
179 case S3C2412_IISMOD_MODE_RXONLY:
180 /* do nothing, we are in the right mode */
181 break;
182
183 case S3C2412_IISMOD_MODE_TXONLY:
184 mod &= ~S3C2412_IISMOD_MODE_MASK;
185 mod |= S3C2412_IISMOD_MODE_TXRX;
186 break;
187
188 default:
189 dev_err(i2s->dev, "RXEN: Invalid MODE %x in IISMOD\n",
190 mod & S3C2412_IISMOD_MODE_MASK);
191 }
192
193 writel(mod, regs + S3C2412_IISMOD);
194 writel(con, regs + S3C2412_IISCON);
195 } else {
196 /* See txctrl notes on FIFOs. */
197
198 con &= ~S3C2412_IISCON_RXDMA_ACTIVE;
199 con |= S3C2412_IISCON_RXDMA_PAUSE;
200 con |= S3C2412_IISCON_RXCH_PAUSE;
201
202 switch (mod & S3C2412_IISMOD_MODE_MASK) {
203 case S3C2412_IISMOD_MODE_RXONLY:
204 con &= ~S3C2412_IISCON_IIS_ACTIVE;
205 mod &= ~S3C2412_IISMOD_MODE_MASK;
206 break;
207
208 case S3C2412_IISMOD_MODE_TXRX:
209 mod &= ~S3C2412_IISMOD_MODE_MASK;
210 mod |= S3C2412_IISMOD_MODE_TXONLY;
211 break;
212
213 default:
214 dev_err(i2s->dev, "RXDIS: Invalid MODE %x in IISMOD\n",
215 mod & S3C2412_IISMOD_MODE_MASK);
216 }
217
218 writel(con, regs + S3C2412_IISCON);
219 writel(mod, regs + S3C2412_IISMOD);
220 }
221
222 fic = readl(regs + S3C2412_IISFIC);
223 pr_debug("%s: IIS: CON=%x MOD=%x FIC=%x\n", __func__, con, mod, fic);
224}
225
226#define msecs_to_loops(t) (loops_per_jiffy / 1000 * HZ * t)
227
228/*
229 * Wait for the LR signal to allow synchronisation to the L/R clock
230 * from the codec. May only be needed for slave mode.
231 */
232static int s3c2412_snd_lrsync(struct s3c_i2sv2_info *i2s)
233{
234 u32 iiscon;
235 unsigned long loops = msecs_to_loops(5);
236
237 pr_debug("Entered %s\n", __func__);
238
239 while (--loops) {
240 iiscon = readl(i2s->regs + S3C2412_IISCON);
241 if (iiscon & S3C2412_IISCON_LRINDEX)
242 break;
243
244 cpu_relax();
245 }
246
247 if (!loops) {
248 printk(KERN_ERR "%s: timeout\n", __func__);
249 return -ETIMEDOUT;
250 }
251
252 return 0;
253}
254
255/*
256 * Set S3C2412 I2S DAI format
257 */
258static int s3c2412_i2s_set_fmt(struct snd_soc_dai *cpu_dai,
259 unsigned int fmt)
260{
261 struct s3c_i2sv2_info *i2s = to_info(cpu_dai);
262 u32 iismod;
263
264 pr_debug("Entered %s\n", __func__);
265
266 iismod = readl(i2s->regs + S3C2412_IISMOD);
267 pr_debug("hw_params r: IISMOD: %x \n", iismod);
268
269 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
270 case SND_SOC_DAIFMT_CBM_CFM:
271 i2s->master = 0;
272 iismod |= S3C2412_IISMOD_SLAVE;
273 break;
274 case SND_SOC_DAIFMT_CBS_CFS:
275 i2s->master = 1;
276 iismod &= ~S3C2412_IISMOD_SLAVE;
277 break;
278 default:
279 pr_err("unknwon master/slave format\n");
280 return -EINVAL;
281 }
282
283 iismod &= ~S3C2412_IISMOD_SDF_MASK;
284
285 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
286 case SND_SOC_DAIFMT_RIGHT_J:
287 iismod |= S3C2412_IISMOD_LR_RLOW;
288 iismod |= S3C2412_IISMOD_SDF_MSB;
289 break;
290 case SND_SOC_DAIFMT_LEFT_J:
291 iismod |= S3C2412_IISMOD_LR_RLOW;
292 iismod |= S3C2412_IISMOD_SDF_LSB;
293 break;
294 case SND_SOC_DAIFMT_I2S:
295 iismod &= ~S3C2412_IISMOD_LR_RLOW;
296 iismod |= S3C2412_IISMOD_SDF_IIS;
297 break;
298 default:
299 pr_err("Unknown data format\n");
300 return -EINVAL;
301 }
302
303 writel(iismod, i2s->regs + S3C2412_IISMOD);
304 pr_debug("hw_params w: IISMOD: %x \n", iismod);
305 return 0;
306}
307
308static int s3c_i2sv2_hw_params(struct snd_pcm_substream *substream,
309 struct snd_pcm_hw_params *params,
310 struct snd_soc_dai *socdai)
311{
312 struct snd_soc_pcm_runtime *rtd = substream->private_data;
313 struct snd_soc_dai_link *dai = rtd->dai;
314 struct s3c_i2sv2_info *i2s = to_info(dai->cpu_dai);
315 struct s3c_dma_params *dma_data;
316 u32 iismod;
317
318 pr_debug("Entered %s\n", __func__);
319
320 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
321 dma_data = i2s->dma_playback;
322 else
323 dma_data = i2s->dma_capture;
324
325 snd_soc_dai_set_dma_data(dai->cpu_dai, substream, dma_data);
326
327 /* Working copies of register */
328 iismod = readl(i2s->regs + S3C2412_IISMOD);
329 pr_debug("%s: r: IISMOD: %x\n", __func__, iismod);
330
331 iismod &= ~S3C64XX_IISMOD_BLC_MASK;
332 /* Sample size */
333 switch (params_format(params)) {
334 case SNDRV_PCM_FORMAT_S8:
335 iismod |= S3C64XX_IISMOD_BLC_8BIT;
336 break;
337 case SNDRV_PCM_FORMAT_S16_LE:
338 break;
339 case SNDRV_PCM_FORMAT_S24_LE:
340 iismod |= S3C64XX_IISMOD_BLC_24BIT;
341 break;
342 }
343
344 writel(iismod, i2s->regs + S3C2412_IISMOD);
345 pr_debug("%s: w: IISMOD: %x\n", __func__, iismod);
346
347 return 0;
348}
349
350static int s3c_i2sv2_set_sysclk(struct snd_soc_dai *cpu_dai,
351 int clk_id, unsigned int freq, int dir)
352{
353 struct s3c_i2sv2_info *i2s = to_info(cpu_dai);
354 u32 iismod = readl(i2s->regs + S3C2412_IISMOD);
355
356 pr_debug("Entered %s\n", __func__);
357 pr_debug("%s r: IISMOD: %x\n", __func__, iismod);
358
359 switch (clk_id) {
360 case S3C_I2SV2_CLKSRC_PCLK:
361 iismod &= ~S3C2412_IISMOD_IMS_SYSMUX;
362 break;
363
364 case S3C_I2SV2_CLKSRC_AUDIOBUS:
365 iismod |= S3C2412_IISMOD_IMS_SYSMUX;
366 break;
367
368 case S3C_I2SV2_CLKSRC_CDCLK:
369 /* Error if controller doesn't have the CDCLKCON bit */
370 if (!(i2s->feature & S3C_FEATURE_CDCLKCON))
371 return -EINVAL;
372
373 switch (dir) {
374 case SND_SOC_CLOCK_IN:
375 iismod |= S3C64XX_IISMOD_CDCLKCON;
376 break;
377 case SND_SOC_CLOCK_OUT:
378 iismod &= ~S3C64XX_IISMOD_CDCLKCON;
379 break;
380 default:
381 return -EINVAL;
382 }
383 break;
384
385 default:
386 return -EINVAL;
387 }
388
389 writel(iismod, i2s->regs + S3C2412_IISMOD);
390 pr_debug("%s w: IISMOD: %x\n", __func__, iismod);
391
392 return 0;
393}
394
395static int s3c2412_i2s_trigger(struct snd_pcm_substream *substream, int cmd,
396 struct snd_soc_dai *dai)
397{
398 struct snd_soc_pcm_runtime *rtd = substream->private_data;
399 struct s3c_i2sv2_info *i2s = to_info(rtd->dai->cpu_dai);
400 int capture = (substream->stream == SNDRV_PCM_STREAM_CAPTURE);
401 unsigned long irqs;
402 int ret = 0;
403 struct s3c_dma_params *dma_data =
404 snd_soc_dai_get_dma_data(rtd->dai->cpu_dai, substream);
405
406 pr_debug("Entered %s\n", __func__);
407
408 switch (cmd) {
409 case SNDRV_PCM_TRIGGER_START:
410 /* On start, ensure that the FIFOs are cleared and reset. */
411
412 writel(capture ? S3C2412_IISFIC_RXFLUSH : S3C2412_IISFIC_TXFLUSH,
413 i2s->regs + S3C2412_IISFIC);
414
415 /* clear again, just in case */
416 writel(0x0, i2s->regs + S3C2412_IISFIC);
417
418 case SNDRV_PCM_TRIGGER_RESUME:
419 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
420 if (!i2s->master) {
421 ret = s3c2412_snd_lrsync(i2s);
422 if (ret)
423 goto exit_err;
424 }
425
426 local_irq_save(irqs);
427
428 if (capture)
429 s3c2412_snd_rxctrl(i2s, 1);
430 else
431 s3c2412_snd_txctrl(i2s, 1);
432
433 local_irq_restore(irqs);
434
435 /*
436 * Load the next buffer to DMA to meet the reqirement
437 * of the auto reload mechanism of S3C24XX.
438 * This call won't bother S3C64XX.
439 */
440 s3c2410_dma_ctrl(dma_data->channel, S3C2410_DMAOP_STARTED);
441
442 break;
443
444 case SNDRV_PCM_TRIGGER_STOP:
445 case SNDRV_PCM_TRIGGER_SUSPEND:
446 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
447 local_irq_save(irqs);
448
449 if (capture)
450 s3c2412_snd_rxctrl(i2s, 0);
451 else
452 s3c2412_snd_txctrl(i2s, 0);
453
454 local_irq_restore(irqs);
455 break;
456 default:
457 ret = -EINVAL;
458 break;
459 }
460
461exit_err:
462 return ret;
463}
464
465/*
466 * Set S3C2412 Clock dividers
467 */
468static int s3c2412_i2s_set_clkdiv(struct snd_soc_dai *cpu_dai,
469 int div_id, int div)
470{
471 struct s3c_i2sv2_info *i2s = to_info(cpu_dai);
472 u32 reg;
473
474 pr_debug("%s(%p, %d, %d)\n", __func__, cpu_dai, div_id, div);
475
476 switch (div_id) {
477 case S3C_I2SV2_DIV_BCLK:
478 switch (div) {
479 case 16:
480 div = S3C2412_IISMOD_BCLK_16FS;
481 break;
482
483 case 32:
484 div = S3C2412_IISMOD_BCLK_32FS;
485 break;
486
487 case 24:
488 div = S3C2412_IISMOD_BCLK_24FS;
489 break;
490
491 case 48:
492 div = S3C2412_IISMOD_BCLK_48FS;
493 break;
494
495 default:
496 return -EINVAL;
497 }
498
499 reg = readl(i2s->regs + S3C2412_IISMOD);
500 reg &= ~S3C2412_IISMOD_BCLK_MASK;
501 writel(reg | div, i2s->regs + S3C2412_IISMOD);
502
503 pr_debug("%s: MOD=%08x\n", __func__, readl(i2s->regs + S3C2412_IISMOD));
504 break;
505
506 case S3C_I2SV2_DIV_RCLK:
507 switch (div) {
508 case 256:
509 div = S3C2412_IISMOD_RCLK_256FS;
510 break;
511
512 case 384:
513 div = S3C2412_IISMOD_RCLK_384FS;
514 break;
515
516 case 512:
517 div = S3C2412_IISMOD_RCLK_512FS;
518 break;
519
520 case 768:
521 div = S3C2412_IISMOD_RCLK_768FS;
522 break;
523
524 default:
525 return -EINVAL;
526 }
527
528 reg = readl(i2s->regs + S3C2412_IISMOD);
529 reg &= ~S3C2412_IISMOD_RCLK_MASK;
530 writel(reg | div, i2s->regs + S3C2412_IISMOD);
531 pr_debug("%s: MOD=%08x\n", __func__, readl(i2s->regs + S3C2412_IISMOD));
532 break;
533
534 case S3C_I2SV2_DIV_PRESCALER:
535 if (div >= 0) {
536 writel((div << 8) | S3C2412_IISPSR_PSREN,
537 i2s->regs + S3C2412_IISPSR);
538 } else {
539 writel(0x0, i2s->regs + S3C2412_IISPSR);
540 }
541 pr_debug("%s: PSR=%08x\n", __func__, readl(i2s->regs + S3C2412_IISPSR));
542 break;
543
544 default:
545 return -EINVAL;
546 }
547
548 return 0;
549}
550
551static snd_pcm_sframes_t s3c2412_i2s_delay(struct snd_pcm_substream *substream,
552 struct snd_soc_dai *dai)
553{
554 struct s3c_i2sv2_info *i2s = to_info(dai);
555 u32 reg = readl(i2s->regs + S3C2412_IISFIC);
556 snd_pcm_sframes_t delay;
557
558 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
559 delay = S3C2412_IISFIC_TXCOUNT(reg);
560 else
561 delay = S3C2412_IISFIC_RXCOUNT(reg);
562
563 return delay;
564}
565
566struct clk *s3c_i2sv2_get_clock(struct snd_soc_dai *cpu_dai)
567{
568 struct s3c_i2sv2_info *i2s = to_info(cpu_dai);
569 u32 iismod = readl(i2s->regs + S3C2412_IISMOD);
570
571 if (iismod & S3C2412_IISMOD_IMS_SYSMUX)
572 return i2s->iis_cclk;
573 else
574 return i2s->iis_pclk;
575}
576EXPORT_SYMBOL_GPL(s3c_i2sv2_get_clock);
577
578/* default table of all avaialable root fs divisors */
579static unsigned int iis_fs_tab[] = { 256, 512, 384, 768 };
580
581int s3c_i2sv2_iis_calc_rate(struct s3c_i2sv2_rate_calc *info,
582 unsigned int *fstab,
583 unsigned int rate, struct clk *clk)
584{
585 unsigned long clkrate = clk_get_rate(clk);
586 unsigned int div;
587 unsigned int fsclk;
588 unsigned int actual;
589 unsigned int fs;
590 unsigned int fsdiv;
591 signed int deviation = 0;
592 unsigned int best_fs = 0;
593 unsigned int best_div = 0;
594 unsigned int best_rate = 0;
595 unsigned int best_deviation = INT_MAX;
596
597 pr_debug("Input clock rate %ldHz\n", clkrate);
598
599 if (fstab == NULL)
600 fstab = iis_fs_tab;
601
602 for (fs = 0; fs < ARRAY_SIZE(iis_fs_tab); fs++) {
603 fsdiv = iis_fs_tab[fs];
604
605 fsclk = clkrate / fsdiv;
606 div = fsclk / rate;
607
608 if ((fsclk % rate) > (rate / 2))
609 div++;
610
611 if (div <= 1)
612 continue;
613
614 actual = clkrate / (fsdiv * div);
615 deviation = actual - rate;
616
617 printk(KERN_DEBUG "%ufs: div %u => result %u, deviation %d\n",
618 fsdiv, div, actual, deviation);
619
620 deviation = abs(deviation);
621
622 if (deviation < best_deviation) {
623 best_fs = fsdiv;
624 best_div = div;
625 best_rate = actual;
626 best_deviation = deviation;
627 }
628
629 if (deviation == 0)
630 break;
631 }
632
633 printk(KERN_DEBUG "best: fs=%u, div=%u, rate=%u\n",
634 best_fs, best_div, best_rate);
635
636 info->fs_div = best_fs;
637 info->clk_div = best_div;
638
639 return 0;
640}
641EXPORT_SYMBOL_GPL(s3c_i2sv2_iis_calc_rate);
642
643int s3c_i2sv2_probe(struct platform_device *pdev,
644 struct snd_soc_dai *dai,
645 struct s3c_i2sv2_info *i2s,
646 unsigned long base)
647{
648 struct device *dev = &pdev->dev;
649 unsigned int iismod;
650
651 i2s->dev = dev;
652
653 /* record our i2s structure for later use in the callbacks */
654 dai->private_data = i2s;
655
656 if (!base) {
657 struct resource *res = platform_get_resource(pdev,
658 IORESOURCE_MEM,
659 0);
660 if (!res) {
661 dev_err(dev, "Unable to get register resource\n");
662 return -ENXIO;
663 }
664
665 if (!request_mem_region(res->start, resource_size(res),
666 "s3c64xx-i2s-v4")) {
667 dev_err(dev, "Unable to request register region\n");
668 return -EBUSY;
669 }
670
671 base = res->start;
672 }
673
674 i2s->regs = ioremap(base, 0x100);
675 if (i2s->regs == NULL) {
676 dev_err(dev, "cannot ioremap registers\n");
677 return -ENXIO;
678 }
679
680 i2s->iis_pclk = clk_get(dev, "iis");
681 if (IS_ERR(i2s->iis_pclk)) {
682 dev_err(dev, "failed to get iis_clock\n");
683 iounmap(i2s->regs);
684 return -ENOENT;
685 }
686
687 clk_enable(i2s->iis_pclk);
688
689 /* Mark ourselves as in TXRX mode so we can run through our cleanup
690 * process without warnings. */
691 iismod = readl(i2s->regs + S3C2412_IISMOD);
692 iismod |= S3C2412_IISMOD_MODE_TXRX;
693 writel(iismod, i2s->regs + S3C2412_IISMOD);
694 s3c2412_snd_txctrl(i2s, 0);
695 s3c2412_snd_rxctrl(i2s, 0);
696
697 return 0;
698}
699EXPORT_SYMBOL_GPL(s3c_i2sv2_probe);
700
701#ifdef CONFIG_PM
702static int s3c2412_i2s_suspend(struct snd_soc_dai *dai)
703{
704 struct s3c_i2sv2_info *i2s = to_info(dai);
705 u32 iismod;
706
707 if (dai->active) {
708 i2s->suspend_iismod = readl(i2s->regs + S3C2412_IISMOD);
709 i2s->suspend_iiscon = readl(i2s->regs + S3C2412_IISCON);
710 i2s->suspend_iispsr = readl(i2s->regs + S3C2412_IISPSR);
711
712 /* some basic suspend checks */
713
714 iismod = readl(i2s->regs + S3C2412_IISMOD);
715
716 if (iismod & S3C2412_IISCON_RXDMA_ACTIVE)
717 pr_warning("%s: RXDMA active?\n", __func__);
718
719 if (iismod & S3C2412_IISCON_TXDMA_ACTIVE)
720 pr_warning("%s: TXDMA active?\n", __func__);
721
722 if (iismod & S3C2412_IISCON_IIS_ACTIVE)
723 pr_warning("%s: IIS active\n", __func__);
724 }
725
726 return 0;
727}
728
729static int s3c2412_i2s_resume(struct snd_soc_dai *dai)
730{
731 struct s3c_i2sv2_info *i2s = to_info(dai);
732
733 pr_info("dai_active %d, IISMOD %08x, IISCON %08x\n",
734 dai->active, i2s->suspend_iismod, i2s->suspend_iiscon);
735
736 if (dai->active) {
737 writel(i2s->suspend_iiscon, i2s->regs + S3C2412_IISCON);
738 writel(i2s->suspend_iismod, i2s->regs + S3C2412_IISMOD);
739 writel(i2s->suspend_iispsr, i2s->regs + S3C2412_IISPSR);
740
741 writel(S3C2412_IISFIC_RXFLUSH | S3C2412_IISFIC_TXFLUSH,
742 i2s->regs + S3C2412_IISFIC);
743
744 ndelay(250);
745 writel(0x0, i2s->regs + S3C2412_IISFIC);
746 }
747
748 return 0;
749}
750#else
751#define s3c2412_i2s_suspend NULL
752#define s3c2412_i2s_resume NULL
753#endif
754
755int s3c_i2sv2_register_dai(struct snd_soc_dai *dai)
756{
757 struct snd_soc_dai_ops *ops = dai->ops;
758
759 ops->trigger = s3c2412_i2s_trigger;
760 if (!ops->hw_params)
761 ops->hw_params = s3c_i2sv2_hw_params;
762 ops->set_fmt = s3c2412_i2s_set_fmt;
763 ops->set_clkdiv = s3c2412_i2s_set_clkdiv;
764 ops->set_sysclk = s3c_i2sv2_set_sysclk;
765
766 /* Allow overriding by (for example) IISv4 */
767 if (!ops->delay)
768 ops->delay = s3c2412_i2s_delay;
769
770 dai->suspend = s3c2412_i2s_suspend;
771 dai->resume = s3c2412_i2s_resume;
772
773 return snd_soc_register_dai(dai);
774}
775EXPORT_SYMBOL_GPL(s3c_i2sv2_register_dai);
776
777MODULE_LICENSE("GPL");
diff --git a/sound/soc/s3c24xx/s3c-i2s-v2.h b/sound/soc/s3c24xx/s3c-i2s-v2.h
deleted file mode 100644
index 766f43a13d8b..000000000000
--- a/sound/soc/s3c24xx/s3c-i2s-v2.h
+++ /dev/null
@@ -1,103 +0,0 @@
1/* sound/soc/s3c24xx/s3c-i2s-v2.h
2 *
3 * ALSA Soc Audio Layer - S3C_I2SV2 I2S driver
4 *
5 * Copyright (c) 2007 Simtec Electronics
6 * http://armlinux.simtec.co.uk/
7 * Ben Dooks <ben@simtec.co.uk>
8 *
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the
11 * Free Software Foundation; either version 2 of the License, or (at your
12 * option) any later version.
13*/
14
15/* This code is the core support for the I2S block found in a number of
16 * Samsung SoC devices which is unofficially named I2S-V2. Currently the
17 * S3C2412 and the S3C64XX series use this block to provide 1 or 2 I2S
18 * channels via configurable GPIO.
19 */
20
21#ifndef __SND_SOC_S3C24XX_S3C_I2SV2_I2S_H
22#define __SND_SOC_S3C24XX_S3C_I2SV2_I2S_H __FILE__
23
24#define S3C_I2SV2_DIV_BCLK (1)
25#define S3C_I2SV2_DIV_RCLK (2)
26#define S3C_I2SV2_DIV_PRESCALER (3)
27
28#define S3C_I2SV2_CLKSRC_PCLK 0
29#define S3C_I2SV2_CLKSRC_AUDIOBUS 1
30#define S3C_I2SV2_CLKSRC_CDCLK 2
31
32/* Set this flag for I2S controllers that have the bit IISMOD[12]
33 * bridge/break RCLK signal and external Xi2sCDCLK pin.
34 */
35#define S3C_FEATURE_CDCLKCON (1 << 0)
36
37/**
38 * struct s3c_i2sv2_info - S3C I2S-V2 information
39 * @dev: The parent device passed to use from the probe.
40 * @regs: The pointer to the device registe block.
41 * @feature: Set of bit-flags indicating features of the controller.
42 * @master: True if the I2S core is the I2S bit clock master.
43 * @dma_playback: DMA information for playback channel.
44 * @dma_capture: DMA information for capture channel.
45 * @suspend_iismod: PM save for the IISMOD register.
46 * @suspend_iiscon: PM save for the IISCON register.
47 * @suspend_iispsr: PM save for the IISPSR register.
48 *
49 * This is the private codec state for the hardware associated with an
50 * I2S channel such as the register mappings and clock sources.
51 */
52struct s3c_i2sv2_info {
53 struct device *dev;
54 void __iomem *regs;
55
56 u32 feature;
57
58 struct clk *iis_pclk;
59 struct clk *iis_cclk;
60
61 unsigned char master;
62
63 struct s3c_dma_params *dma_playback;
64 struct s3c_dma_params *dma_capture;
65
66 u32 suspend_iismod;
67 u32 suspend_iiscon;
68 u32 suspend_iispsr;
69};
70
71extern struct clk *s3c_i2sv2_get_clock(struct snd_soc_dai *cpu_dai);
72
73struct s3c_i2sv2_rate_calc {
74 unsigned int clk_div; /* for prescaler */
75 unsigned int fs_div; /* for root frame clock */
76};
77
78extern int s3c_i2sv2_iis_calc_rate(struct s3c_i2sv2_rate_calc *info,
79 unsigned int *fstab,
80 unsigned int rate, struct clk *clk);
81
82/**
83 * s3c_i2sv2_probe - probe for i2s device helper
84 * @pdev: The platform device supplied to the original probe.
85 * @dai: The ASoC DAI structure supplied to the original probe.
86 * @i2s: Our local i2s structure to fill in.
87 * @base: The base address for the registers.
88 */
89extern int s3c_i2sv2_probe(struct platform_device *pdev,
90 struct snd_soc_dai *dai,
91 struct s3c_i2sv2_info *i2s,
92 unsigned long base);
93
94/**
95 * s3c_i2sv2_register_dai - register dai with soc core
96 * @dai: The snd_soc_dai structure to register
97 *
98 * Fill in any missing fields and then register the given dai with the
99 * soc core.
100 */
101extern int s3c_i2sv2_register_dai(struct snd_soc_dai *dai);
102
103#endif /* __SND_SOC_S3C24XX_S3C_I2SV2_I2S_H */
diff --git a/sound/soc/s3c24xx/s3c-pcm.c b/sound/soc/s3c24xx/s3c-pcm.c
deleted file mode 100644
index 326f0a9e7e30..000000000000
--- a/sound/soc/s3c24xx/s3c-pcm.c
+++ /dev/null
@@ -1,554 +0,0 @@
1/* sound/soc/s3c24xx/s3c-pcm.c
2 *
3 * ALSA SoC Audio Layer - S3C PCM-Controller driver
4 *
5 * Copyright (c) 2009 Samsung Electronics Co. Ltd
6 * Author: Jaswinder Singh <jassi.brar@samsung.com>
7 * based upon I2S drivers by Ben Dooks.
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12 */
13
14#include <linux/init.h>
15#include <linux/module.h>
16#include <linux/device.h>
17#include <linux/delay.h>
18#include <linux/clk.h>
19#include <linux/kernel.h>
20#include <linux/gpio.h>
21#include <linux/io.h>
22
23#include <sound/core.h>
24#include <sound/pcm.h>
25#include <sound/pcm_params.h>
26#include <sound/initval.h>
27#include <sound/soc.h>
28
29#include <plat/audio.h>
30#include <plat/dma.h>
31
32#include "s3c-dma.h"
33#include "s3c-pcm.h"
34
35static struct s3c2410_dma_client s3c_pcm_dma_client_out = {
36 .name = "PCM Stereo out"
37};
38
39static struct s3c2410_dma_client s3c_pcm_dma_client_in = {
40 .name = "PCM Stereo in"
41};
42
43static struct s3c_dma_params s3c_pcm_stereo_out[] = {
44 [0] = {
45 .client = &s3c_pcm_dma_client_out,
46 .dma_size = 4,
47 },
48 [1] = {
49 .client = &s3c_pcm_dma_client_out,
50 .dma_size = 4,
51 },
52};
53
54static struct s3c_dma_params s3c_pcm_stereo_in[] = {
55 [0] = {
56 .client = &s3c_pcm_dma_client_in,
57 .dma_size = 4,
58 },
59 [1] = {
60 .client = &s3c_pcm_dma_client_in,
61 .dma_size = 4,
62 },
63};
64
65static struct s3c_pcm_info s3c_pcm[2];
66
67static inline struct s3c_pcm_info *to_info(struct snd_soc_dai *cpu_dai)
68{
69 return cpu_dai->private_data;
70}
71
72static void s3c_pcm_snd_txctrl(struct s3c_pcm_info *pcm, int on)
73{
74 void __iomem *regs = pcm->regs;
75 u32 ctl, clkctl;
76
77 clkctl = readl(regs + S3C_PCM_CLKCTL);
78 ctl = readl(regs + S3C_PCM_CTL);
79 ctl &= ~(S3C_PCM_CTL_TXDIPSTICK_MASK
80 << S3C_PCM_CTL_TXDIPSTICK_SHIFT);
81
82 if (on) {
83 ctl |= S3C_PCM_CTL_TXDMA_EN;
84 ctl |= S3C_PCM_CTL_TXFIFO_EN;
85 ctl |= S3C_PCM_CTL_ENABLE;
86 ctl |= (0x20<<S3C_PCM_CTL_TXDIPSTICK_SHIFT);
87 clkctl |= S3C_PCM_CLKCTL_SERCLK_EN;
88 } else {
89 ctl &= ~S3C_PCM_CTL_TXDMA_EN;
90 ctl &= ~S3C_PCM_CTL_TXFIFO_EN;
91
92 if (!(ctl & S3C_PCM_CTL_RXFIFO_EN)) {
93 ctl &= ~S3C_PCM_CTL_ENABLE;
94 if (!pcm->idleclk)
95 clkctl |= S3C_PCM_CLKCTL_SERCLK_EN;
96 }
97 }
98
99 writel(clkctl, regs + S3C_PCM_CLKCTL);
100 writel(ctl, regs + S3C_PCM_CTL);
101}
102
103static void s3c_pcm_snd_rxctrl(struct s3c_pcm_info *pcm, int on)
104{
105 void __iomem *regs = pcm->regs;
106 u32 ctl, clkctl;
107
108 ctl = readl(regs + S3C_PCM_CTL);
109 clkctl = readl(regs + S3C_PCM_CLKCTL);
110
111 if (on) {
112 ctl |= S3C_PCM_CTL_RXDMA_EN;
113 ctl |= S3C_PCM_CTL_RXFIFO_EN;
114 ctl |= S3C_PCM_CTL_ENABLE;
115 clkctl |= S3C_PCM_CLKCTL_SERCLK_EN;
116 } else {
117 ctl &= ~S3C_PCM_CTL_RXDMA_EN;
118 ctl &= ~S3C_PCM_CTL_RXFIFO_EN;
119
120 if (!(ctl & S3C_PCM_CTL_TXFIFO_EN)) {
121 ctl &= ~S3C_PCM_CTL_ENABLE;
122 if (!pcm->idleclk)
123 clkctl |= S3C_PCM_CLKCTL_SERCLK_EN;
124 }
125 }
126
127 writel(clkctl, regs + S3C_PCM_CLKCTL);
128 writel(ctl, regs + S3C_PCM_CTL);
129}
130
131static int s3c_pcm_trigger(struct snd_pcm_substream *substream, int cmd,
132 struct snd_soc_dai *dai)
133{
134 struct snd_soc_pcm_runtime *rtd = substream->private_data;
135 struct s3c_pcm_info *pcm = to_info(rtd->dai->cpu_dai);
136 unsigned long flags;
137
138 dev_dbg(pcm->dev, "Entered %s\n", __func__);
139
140 switch (cmd) {
141 case SNDRV_PCM_TRIGGER_START:
142 case SNDRV_PCM_TRIGGER_RESUME:
143 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
144 spin_lock_irqsave(&pcm->lock, flags);
145
146 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
147 s3c_pcm_snd_rxctrl(pcm, 1);
148 else
149 s3c_pcm_snd_txctrl(pcm, 1);
150
151 spin_unlock_irqrestore(&pcm->lock, flags);
152 break;
153
154 case SNDRV_PCM_TRIGGER_STOP:
155 case SNDRV_PCM_TRIGGER_SUSPEND:
156 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
157 spin_lock_irqsave(&pcm->lock, flags);
158
159 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
160 s3c_pcm_snd_rxctrl(pcm, 0);
161 else
162 s3c_pcm_snd_txctrl(pcm, 0);
163
164 spin_unlock_irqrestore(&pcm->lock, flags);
165 break;
166
167 default:
168 return -EINVAL;
169 }
170
171 return 0;
172}
173
174static int s3c_pcm_hw_params(struct snd_pcm_substream *substream,
175 struct snd_pcm_hw_params *params,
176 struct snd_soc_dai *socdai)
177{
178 struct snd_soc_pcm_runtime *rtd = substream->private_data;
179 struct snd_soc_dai_link *dai = rtd->dai;
180 struct s3c_pcm_info *pcm = to_info(dai->cpu_dai);
181 struct s3c_dma_params *dma_data;
182 void __iomem *regs = pcm->regs;
183 struct clk *clk;
184 int sclk_div, sync_div;
185 unsigned long flags;
186 u32 clkctl;
187
188 dev_dbg(pcm->dev, "Entered %s\n", __func__);
189
190 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
191 dma_data = pcm->dma_playback;
192 else
193 dma_data = pcm->dma_capture;
194
195 snd_soc_dai_set_dma_data(dai->cpu_dai, substream, dma_data);
196
197 /* Strictly check for sample size */
198 switch (params_format(params)) {
199 case SNDRV_PCM_FORMAT_S16_LE:
200 break;
201 default:
202 return -EINVAL;
203 }
204
205 spin_lock_irqsave(&pcm->lock, flags);
206
207 /* Get hold of the PCMSOURCE_CLK */
208 clkctl = readl(regs + S3C_PCM_CLKCTL);
209 if (clkctl & S3C_PCM_CLKCTL_SERCLKSEL_PCLK)
210 clk = pcm->pclk;
211 else
212 clk = pcm->cclk;
213
214 /* Set the SCLK divider */
215 sclk_div = clk_get_rate(clk) / pcm->sclk_per_fs /
216 params_rate(params) / 2 - 1;
217
218 clkctl &= ~(S3C_PCM_CLKCTL_SCLKDIV_MASK
219 << S3C_PCM_CLKCTL_SCLKDIV_SHIFT);
220 clkctl |= ((sclk_div & S3C_PCM_CLKCTL_SCLKDIV_MASK)
221 << S3C_PCM_CLKCTL_SCLKDIV_SHIFT);
222
223 /* Set the SYNC divider */
224 sync_div = pcm->sclk_per_fs - 1;
225
226 clkctl &= ~(S3C_PCM_CLKCTL_SYNCDIV_MASK
227 << S3C_PCM_CLKCTL_SYNCDIV_SHIFT);
228 clkctl |= ((sync_div & S3C_PCM_CLKCTL_SYNCDIV_MASK)
229 << S3C_PCM_CLKCTL_SYNCDIV_SHIFT);
230
231 writel(clkctl, regs + S3C_PCM_CLKCTL);
232
233 spin_unlock_irqrestore(&pcm->lock, flags);
234
235 dev_dbg(pcm->dev, "PCMSOURCE_CLK-%lu SCLK=%ufs SCLK_DIV=%d SYNC_DIV=%d\n",
236 clk_get_rate(clk), pcm->sclk_per_fs,
237 sclk_div, sync_div);
238
239 return 0;
240}
241
242static int s3c_pcm_set_fmt(struct snd_soc_dai *cpu_dai,
243 unsigned int fmt)
244{
245 struct s3c_pcm_info *pcm = to_info(cpu_dai);
246 void __iomem *regs = pcm->regs;
247 unsigned long flags;
248 int ret = 0;
249 u32 ctl;
250
251 dev_dbg(pcm->dev, "Entered %s\n", __func__);
252
253 spin_lock_irqsave(&pcm->lock, flags);
254
255 ctl = readl(regs + S3C_PCM_CTL);
256
257 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
258 case SND_SOC_DAIFMT_NB_NF:
259 /* Nothing to do, NB_NF by default */
260 break;
261 default:
262 dev_err(pcm->dev, "Unsupported clock inversion!\n");
263 ret = -EINVAL;
264 goto exit;
265 }
266
267 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
268 case SND_SOC_DAIFMT_CBS_CFS:
269 /* Nothing to do, Master by default */
270 break;
271 default:
272 dev_err(pcm->dev, "Unsupported master/slave format!\n");
273 ret = -EINVAL;
274 goto exit;
275 }
276
277 switch (fmt & SND_SOC_DAIFMT_CLOCK_MASK) {
278 case SND_SOC_DAIFMT_CONT:
279 pcm->idleclk = 1;
280 break;
281 case SND_SOC_DAIFMT_GATED:
282 pcm->idleclk = 0;
283 break;
284 default:
285 dev_err(pcm->dev, "Invalid Clock gating request!\n");
286 ret = -EINVAL;
287 goto exit;
288 }
289
290 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
291 case SND_SOC_DAIFMT_DSP_A:
292 ctl |= S3C_PCM_CTL_TXMSB_AFTER_FSYNC;
293 ctl |= S3C_PCM_CTL_RXMSB_AFTER_FSYNC;
294 break;
295 case SND_SOC_DAIFMT_DSP_B:
296 ctl &= ~S3C_PCM_CTL_TXMSB_AFTER_FSYNC;
297 ctl &= ~S3C_PCM_CTL_RXMSB_AFTER_FSYNC;
298 break;
299 default:
300 dev_err(pcm->dev, "Unsupported data format!\n");
301 ret = -EINVAL;
302 goto exit;
303 }
304
305 writel(ctl, regs + S3C_PCM_CTL);
306
307exit:
308 spin_unlock_irqrestore(&pcm->lock, flags);
309
310 return ret;
311}
312
313static int s3c_pcm_set_clkdiv(struct snd_soc_dai *cpu_dai,
314 int div_id, int div)
315{
316 struct s3c_pcm_info *pcm = to_info(cpu_dai);
317
318 switch (div_id) {
319 case S3C_PCM_SCLK_PER_FS:
320 pcm->sclk_per_fs = div;
321 break;
322
323 default:
324 return -EINVAL;
325 }
326
327 return 0;
328}
329
330static int s3c_pcm_set_sysclk(struct snd_soc_dai *cpu_dai,
331 int clk_id, unsigned int freq, int dir)
332{
333 struct s3c_pcm_info *pcm = to_info(cpu_dai);
334 void __iomem *regs = pcm->regs;
335 u32 clkctl = readl(regs + S3C_PCM_CLKCTL);
336
337 switch (clk_id) {
338 case S3C_PCM_CLKSRC_PCLK:
339 clkctl |= S3C_PCM_CLKCTL_SERCLKSEL_PCLK;
340 break;
341
342 case S3C_PCM_CLKSRC_MUX:
343 clkctl &= ~S3C_PCM_CLKCTL_SERCLKSEL_PCLK;
344
345 if (clk_get_rate(pcm->cclk) != freq)
346 clk_set_rate(pcm->cclk, freq);
347
348 break;
349
350 default:
351 return -EINVAL;
352 }
353
354 writel(clkctl, regs + S3C_PCM_CLKCTL);
355
356 return 0;
357}
358
359static struct snd_soc_dai_ops s3c_pcm_dai_ops = {
360 .set_sysclk = s3c_pcm_set_sysclk,
361 .set_clkdiv = s3c_pcm_set_clkdiv,
362 .trigger = s3c_pcm_trigger,
363 .hw_params = s3c_pcm_hw_params,
364 .set_fmt = s3c_pcm_set_fmt,
365};
366
367#define S3C_PCM_RATES SNDRV_PCM_RATE_8000_96000
368
369#define S3C_PCM_DECLARE(n) \
370{ \
371 .name = "samsung-pcm", \
372 .id = (n), \
373 .symmetric_rates = 1, \
374 .ops = &s3c_pcm_dai_ops, \
375 .playback = { \
376 .channels_min = 2, \
377 .channels_max = 2, \
378 .rates = S3C_PCM_RATES, \
379 .formats = SNDRV_PCM_FMTBIT_S16_LE, \
380 }, \
381 .capture = { \
382 .channels_min = 2, \
383 .channels_max = 2, \
384 .rates = S3C_PCM_RATES, \
385 .formats = SNDRV_PCM_FMTBIT_S16_LE, \
386 }, \
387}
388
389struct snd_soc_dai s3c_pcm_dai[] = {
390 S3C_PCM_DECLARE(0),
391 S3C_PCM_DECLARE(1),
392};
393EXPORT_SYMBOL_GPL(s3c_pcm_dai);
394
395static __devinit int s3c_pcm_dev_probe(struct platform_device *pdev)
396{
397 struct s3c_pcm_info *pcm;
398 struct snd_soc_dai *dai;
399 struct resource *mem_res, *dmatx_res, *dmarx_res;
400 struct s3c_audio_pdata *pcm_pdata;
401 int ret;
402
403 /* Check for valid device index */
404 if ((pdev->id < 0) || pdev->id >= ARRAY_SIZE(s3c_pcm)) {
405 dev_err(&pdev->dev, "id %d out of range\n", pdev->id);
406 return -EINVAL;
407 }
408
409 pcm_pdata = pdev->dev.platform_data;
410
411 /* Check for availability of necessary resource */
412 dmatx_res = platform_get_resource(pdev, IORESOURCE_DMA, 0);
413 if (!dmatx_res) {
414 dev_err(&pdev->dev, "Unable to get PCM-TX dma resource\n");
415 return -ENXIO;
416 }
417
418 dmarx_res = platform_get_resource(pdev, IORESOURCE_DMA, 1);
419 if (!dmarx_res) {
420 dev_err(&pdev->dev, "Unable to get PCM-RX dma resource\n");
421 return -ENXIO;
422 }
423
424 mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
425 if (!mem_res) {
426 dev_err(&pdev->dev, "Unable to get register resource\n");
427 return -ENXIO;
428 }
429
430 if (pcm_pdata && pcm_pdata->cfg_gpio && pcm_pdata->cfg_gpio(pdev)) {
431 dev_err(&pdev->dev, "Unable to configure gpio\n");
432 return -EINVAL;
433 }
434
435 pcm = &s3c_pcm[pdev->id];
436 pcm->dev = &pdev->dev;
437
438 spin_lock_init(&pcm->lock);
439
440 dai = &s3c_pcm_dai[pdev->id];
441 dai->dev = &pdev->dev;
442
443 /* Default is 128fs */
444 pcm->sclk_per_fs = 128;
445
446 pcm->cclk = clk_get(&pdev->dev, "audio-bus");
447 if (IS_ERR(pcm->cclk)) {
448 dev_err(&pdev->dev, "failed to get audio-bus\n");
449 ret = PTR_ERR(pcm->cclk);
450 goto err1;
451 }
452 clk_enable(pcm->cclk);
453
454 /* record our pcm structure for later use in the callbacks */
455 dai->private_data = pcm;
456
457 if (!request_mem_region(mem_res->start,
458 resource_size(mem_res), "samsung-pcm")) {
459 dev_err(&pdev->dev, "Unable to request register region\n");
460 ret = -EBUSY;
461 goto err2;
462 }
463
464 pcm->regs = ioremap(mem_res->start, 0x100);
465 if (pcm->regs == NULL) {
466 dev_err(&pdev->dev, "cannot ioremap registers\n");
467 ret = -ENXIO;
468 goto err3;
469 }
470
471 pcm->pclk = clk_get(&pdev->dev, "pcm");
472 if (IS_ERR(pcm->pclk)) {
473 dev_err(&pdev->dev, "failed to get pcm_clock\n");
474 ret = -ENOENT;
475 goto err4;
476 }
477 clk_enable(pcm->pclk);
478
479 ret = snd_soc_register_dai(dai);
480 if (ret != 0) {
481 dev_err(&pdev->dev, "failed to get pcm_clock\n");
482 goto err5;
483 }
484
485 s3c_pcm_stereo_in[pdev->id].dma_addr = mem_res->start
486 + S3C_PCM_RXFIFO;
487 s3c_pcm_stereo_out[pdev->id].dma_addr = mem_res->start
488 + S3C_PCM_TXFIFO;
489
490 s3c_pcm_stereo_in[pdev->id].channel = dmarx_res->start;
491 s3c_pcm_stereo_out[pdev->id].channel = dmatx_res->start;
492
493 pcm->dma_capture = &s3c_pcm_stereo_in[pdev->id];
494 pcm->dma_playback = &s3c_pcm_stereo_out[pdev->id];
495
496 return 0;
497
498err5:
499 clk_disable(pcm->pclk);
500 clk_put(pcm->pclk);
501err4:
502 iounmap(pcm->regs);
503err3:
504 release_mem_region(mem_res->start, resource_size(mem_res));
505err2:
506 clk_disable(pcm->cclk);
507 clk_put(pcm->cclk);
508err1:
509 return ret;
510}
511
512static __devexit int s3c_pcm_dev_remove(struct platform_device *pdev)
513{
514 struct s3c_pcm_info *pcm = &s3c_pcm[pdev->id];
515 struct resource *mem_res;
516
517 iounmap(pcm->regs);
518
519 mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
520 release_mem_region(mem_res->start, resource_size(mem_res));
521
522 clk_disable(pcm->cclk);
523 clk_disable(pcm->pclk);
524 clk_put(pcm->pclk);
525 clk_put(pcm->cclk);
526
527 return 0;
528}
529
530static struct platform_driver s3c_pcm_driver = {
531 .probe = s3c_pcm_dev_probe,
532 .remove = s3c_pcm_dev_remove,
533 .driver = {
534 .name = "samsung-pcm",
535 .owner = THIS_MODULE,
536 },
537};
538
539static int __init s3c_pcm_init(void)
540{
541 return platform_driver_register(&s3c_pcm_driver);
542}
543module_init(s3c_pcm_init);
544
545static void __exit s3c_pcm_exit(void)
546{
547 platform_driver_unregister(&s3c_pcm_driver);
548}
549module_exit(s3c_pcm_exit);
550
551/* Module information */
552MODULE_AUTHOR("Jaswinder Singh, <jassi.brar@samsung.com>");
553MODULE_DESCRIPTION("S3C PCM Controller Driver");
554MODULE_LICENSE("GPL");
diff --git a/sound/soc/s3c24xx/s3c-pcm.h b/sound/soc/s3c24xx/s3c-pcm.h
deleted file mode 100644
index 69ff9971692f..000000000000
--- a/sound/soc/s3c24xx/s3c-pcm.h
+++ /dev/null
@@ -1,123 +0,0 @@
1/* sound/soc/s3c24xx/s3c-pcm.h
2 *
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License version 2 as
5 * published by the Free Software Foundation.
6 *
7 */
8
9#ifndef __S3C_PCM_H
10#define __S3C_PCM_H __FILE__
11
12/*Register Offsets */
13#define S3C_PCM_CTL (0x00)
14#define S3C_PCM_CLKCTL (0x04)
15#define S3C_PCM_TXFIFO (0x08)
16#define S3C_PCM_RXFIFO (0x0C)
17#define S3C_PCM_IRQCTL (0x10)
18#define S3C_PCM_IRQSTAT (0x14)
19#define S3C_PCM_FIFOSTAT (0x18)
20#define S3C_PCM_CLRINT (0x20)
21
22/* PCM_CTL Bit-Fields */
23#define S3C_PCM_CTL_TXDIPSTICK_MASK (0x3f)
24#define S3C_PCM_CTL_TXDIPSTICK_SHIFT (13)
25#define S3C_PCM_CTL_RXDIPSTICK_MSK (0x3f<<7)
26#define S3C_PCM_CTL_TXDMA_EN (0x1<<6)
27#define S3C_PCM_CTL_RXDMA_EN (0x1<<5)
28#define S3C_PCM_CTL_TXMSB_AFTER_FSYNC (0x1<<4)
29#define S3C_PCM_CTL_RXMSB_AFTER_FSYNC (0x1<<3)
30#define S3C_PCM_CTL_TXFIFO_EN (0x1<<2)
31#define S3C_PCM_CTL_RXFIFO_EN (0x1<<1)
32#define S3C_PCM_CTL_ENABLE (0x1<<0)
33
34/* PCM_CLKCTL Bit-Fields */
35#define S3C_PCM_CLKCTL_SERCLK_EN (0x1<<19)
36#define S3C_PCM_CLKCTL_SERCLKSEL_PCLK (0x1<<18)
37#define S3C_PCM_CLKCTL_SCLKDIV_MASK (0x1ff)
38#define S3C_PCM_CLKCTL_SYNCDIV_MASK (0x1ff)
39#define S3C_PCM_CLKCTL_SCLKDIV_SHIFT (9)
40#define S3C_PCM_CLKCTL_SYNCDIV_SHIFT (0)
41
42/* PCM_TXFIFO Bit-Fields */
43#define S3C_PCM_TXFIFO_DVALID (0x1<<16)
44#define S3C_PCM_TXFIFO_DATA_MSK (0xffff<<0)
45
46/* PCM_RXFIFO Bit-Fields */
47#define S3C_PCM_RXFIFO_DVALID (0x1<<16)
48#define S3C_PCM_RXFIFO_DATA_MSK (0xffff<<0)
49
50/* PCM_IRQCTL Bit-Fields */
51#define S3C_PCM_IRQCTL_IRQEN (0x1<<14)
52#define S3C_PCM_IRQCTL_WRDEN (0x1<<12)
53#define S3C_PCM_IRQCTL_TXEMPTYEN (0x1<<11)
54#define S3C_PCM_IRQCTL_TXALMSTEMPTYEN (0x1<<10)
55#define S3C_PCM_IRQCTL_TXFULLEN (0x1<<9)
56#define S3C_PCM_IRQCTL_TXALMSTFULLEN (0x1<<8)
57#define S3C_PCM_IRQCTL_TXSTARVEN (0x1<<7)
58#define S3C_PCM_IRQCTL_TXERROVRFLEN (0x1<<6)
59#define S3C_PCM_IRQCTL_RXEMPTEN (0x1<<5)
60#define S3C_PCM_IRQCTL_RXALMSTEMPTEN (0x1<<4)
61#define S3C_PCM_IRQCTL_RXFULLEN (0x1<<3)
62#define S3C_PCM_IRQCTL_RXALMSTFULLEN (0x1<<2)
63#define S3C_PCM_IRQCTL_RXSTARVEN (0x1<<1)
64#define S3C_PCM_IRQCTL_RXERROVRFLEN (0x1<<0)
65
66/* PCM_IRQSTAT Bit-Fields */
67#define S3C_PCM_IRQSTAT_IRQPND (0x1<<13)
68#define S3C_PCM_IRQSTAT_WRD_XFER (0x1<<12)
69#define S3C_PCM_IRQSTAT_TXEMPTY (0x1<<11)
70#define S3C_PCM_IRQSTAT_TXALMSTEMPTY (0x1<<10)
71#define S3C_PCM_IRQSTAT_TXFULL (0x1<<9)
72#define S3C_PCM_IRQSTAT_TXALMSTFULL (0x1<<8)
73#define S3C_PCM_IRQSTAT_TXSTARV (0x1<<7)
74#define S3C_PCM_IRQSTAT_TXERROVRFL (0x1<<6)
75#define S3C_PCM_IRQSTAT_RXEMPT (0x1<<5)
76#define S3C_PCM_IRQSTAT_RXALMSTEMPT (0x1<<4)
77#define S3C_PCM_IRQSTAT_RXFULL (0x1<<3)
78#define S3C_PCM_IRQSTAT_RXALMSTFULL (0x1<<2)
79#define S3C_PCM_IRQSTAT_RXSTARV (0x1<<1)
80#define S3C_PCM_IRQSTAT_RXERROVRFL (0x1<<0)
81
82/* PCM_FIFOSTAT Bit-Fields */
83#define S3C_PCM_FIFOSTAT_TXCNT_MSK (0x3f<<14)
84#define S3C_PCM_FIFOSTAT_TXFIFOEMPTY (0x1<<13)
85#define S3C_PCM_FIFOSTAT_TXFIFOALMSTEMPTY (0x1<<12)
86#define S3C_PCM_FIFOSTAT_TXFIFOFULL (0x1<<11)
87#define S3C_PCM_FIFOSTAT_TXFIFOALMSTFULL (0x1<<10)
88#define S3C_PCM_FIFOSTAT_RXCNT_MSK (0x3f<<4)
89#define S3C_PCM_FIFOSTAT_RXFIFOEMPTY (0x1<<3)
90#define S3C_PCM_FIFOSTAT_RXFIFOALMSTEMPTY (0x1<<2)
91#define S3C_PCM_FIFOSTAT_RXFIFOFULL (0x1<<1)
92#define S3C_PCM_FIFOSTAT_RXFIFOALMSTFULL (0x1<<0)
93
94#define S3C_PCM_CLKSRC_PCLK 0
95#define S3C_PCM_CLKSRC_MUX 1
96
97#define S3C_PCM_SCLK_PER_FS 0
98
99/**
100 * struct s3c_pcm_info - S3C PCM Controller information
101 * @dev: The parent device passed to use from the probe.
102 * @regs: The pointer to the device register block.
103 * @dma_playback: DMA information for playback channel.
104 * @dma_capture: DMA information for capture channel.
105 */
106struct s3c_pcm_info {
107 spinlock_t lock;
108 struct device *dev;
109 void __iomem *regs;
110
111 unsigned int sclk_per_fs;
112
113 /* Whether to keep PCMSCLK enabled even when idle(no active xfer) */
114 unsigned int idleclk;
115
116 struct clk *pclk;
117 struct clk *cclk;
118
119 struct s3c_dma_params *dma_playback;
120 struct s3c_dma_params *dma_capture;
121};
122
123#endif /* __S3C_PCM_H */
diff --git a/sound/soc/s3c24xx/s3c2412-i2s.c b/sound/soc/s3c24xx/s3c2412-i2s.c
deleted file mode 100644
index 709adef9d043..000000000000
--- a/sound/soc/s3c24xx/s3c2412-i2s.c
+++ /dev/null
@@ -1,190 +0,0 @@
1/* sound/soc/s3c24xx/s3c2412-i2s.c
2 *
3 * ALSA Soc Audio Layer - S3C2412 I2S driver
4 *
5 * Copyright (c) 2006 Wolfson Microelectronics PLC.
6 * Graeme Gregory graeme.gregory@wolfsonmicro.com
7 * linux@wolfsonmicro.com
8 *
9 * Copyright (c) 2007, 2004-2005 Simtec Electronics
10 * http://armlinux.simtec.co.uk/
11 * Ben Dooks <ben@simtec.co.uk>
12 *
13 * This program is free software; you can redistribute it and/or modify it
14 * under the terms of the GNU General Public License as published by the
15 * Free Software Foundation; either version 2 of the License, or (at your
16 * option) any later version.
17 */
18
19#include <linux/init.h>
20#include <linux/module.h>
21#include <linux/device.h>
22#include <linux/delay.h>
23#include <linux/gpio.h>
24#include <linux/clk.h>
25#include <linux/kernel.h>
26#include <linux/io.h>
27
28#include <sound/core.h>
29#include <sound/pcm.h>
30#include <sound/pcm_params.h>
31#include <sound/initval.h>
32#include <sound/soc.h>
33#include <mach/hardware.h>
34
35#include <mach/regs-gpio.h>
36#include <mach/dma.h>
37
38#include "s3c-dma.h"
39#include "regs-i2s-v2.h"
40#include "s3c2412-i2s.h"
41
42#define S3C2412_I2S_DEBUG 0
43
44static struct s3c2410_dma_client s3c2412_dma_client_out = {
45 .name = "I2S PCM Stereo out"
46};
47
48static struct s3c2410_dma_client s3c2412_dma_client_in = {
49 .name = "I2S PCM Stereo in"
50};
51
52static struct s3c_dma_params s3c2412_i2s_pcm_stereo_out = {
53 .client = &s3c2412_dma_client_out,
54 .channel = DMACH_I2S_OUT,
55 .dma_addr = S3C2410_PA_IIS + S3C2412_IISTXD,
56 .dma_size = 4,
57};
58
59static struct s3c_dma_params s3c2412_i2s_pcm_stereo_in = {
60 .client = &s3c2412_dma_client_in,
61 .channel = DMACH_I2S_IN,
62 .dma_addr = S3C2410_PA_IIS + S3C2412_IISRXD,
63 .dma_size = 4,
64};
65
66static struct s3c_i2sv2_info s3c2412_i2s;
67
68static inline struct s3c_i2sv2_info *to_info(struct snd_soc_dai *cpu_dai)
69{
70 return cpu_dai->private_data;
71}
72
73static int s3c2412_i2s_probe(struct platform_device *pdev,
74 struct snd_soc_dai *dai)
75{
76 int ret;
77
78 pr_debug("Entered %s\n", __func__);
79
80 ret = s3c_i2sv2_probe(pdev, dai, &s3c2412_i2s, S3C2410_PA_IIS);
81 if (ret)
82 return ret;
83
84 s3c2412_i2s.dma_capture = &s3c2412_i2s_pcm_stereo_in;
85 s3c2412_i2s.dma_playback = &s3c2412_i2s_pcm_stereo_out;
86
87 s3c2412_i2s.iis_cclk = clk_get(&pdev->dev, "i2sclk");
88 if (s3c2412_i2s.iis_cclk == NULL) {
89 pr_err("failed to get i2sclk clock\n");
90 iounmap(s3c2412_i2s.regs);
91 return -ENODEV;
92 }
93
94 /* Set MPLL as the source for IIS CLK */
95
96 clk_set_parent(s3c2412_i2s.iis_cclk, clk_get(NULL, "mpll"));
97 clk_enable(s3c2412_i2s.iis_cclk);
98
99 s3c2412_i2s.iis_cclk = s3c2412_i2s.iis_pclk;
100
101 /* Configure the I2S pins in correct mode */
102 s3c2410_gpio_cfgpin(S3C2410_GPE0, S3C2410_GPE0_I2SLRCK);
103 s3c2410_gpio_cfgpin(S3C2410_GPE1, S3C2410_GPE1_I2SSCLK);
104 s3c2410_gpio_cfgpin(S3C2410_GPE2, S3C2410_GPE2_CDCLK);
105 s3c2410_gpio_cfgpin(S3C2410_GPE3, S3C2410_GPE3_I2SSDI);
106 s3c2410_gpio_cfgpin(S3C2410_GPE4, S3C2410_GPE4_I2SSDO);
107
108 return 0;
109}
110
111static int s3c2412_i2s_hw_params(struct snd_pcm_substream *substream,
112 struct snd_pcm_hw_params *params,
113 struct snd_soc_dai *cpu_dai)
114{
115 struct s3c_i2sv2_info *i2s = to_info(cpu_dai);
116 struct s3c_dma_params *dma_data;
117 u32 iismod;
118
119 pr_debug("Entered %s\n", __func__);
120
121 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
122 dma_data = i2s->dma_playback;
123 else
124 dma_data = i2s->dma_capture;
125
126 snd_soc_dai_set_dma_data(cpu_dai, substream, dma_data);
127
128 iismod = readl(i2s->regs + S3C2412_IISMOD);
129 pr_debug("%s: r: IISMOD: %x\n", __func__, iismod);
130
131 switch (params_format(params)) {
132 case SNDRV_PCM_FORMAT_S8:
133 iismod |= S3C2412_IISMOD_8BIT;
134 break;
135 case SNDRV_PCM_FORMAT_S16_LE:
136 iismod &= ~S3C2412_IISMOD_8BIT;
137 break;
138 }
139
140 writel(iismod, i2s->regs + S3C2412_IISMOD);
141 pr_debug("%s: w: IISMOD: %x\n", __func__, iismod);
142
143 return 0;
144}
145
146#define S3C2412_I2S_RATES \
147 (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 | SNDRV_PCM_RATE_16000 | \
148 SNDRV_PCM_RATE_22050 | SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | \
149 SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000)
150
151static struct snd_soc_dai_ops s3c2412_i2s_dai_ops = {
152 .hw_params = s3c2412_i2s_hw_params,
153};
154
155struct snd_soc_dai s3c2412_i2s_dai = {
156 .name = "s3c2412-i2s",
157 .id = 0,
158 .probe = s3c2412_i2s_probe,
159 .playback = {
160 .channels_min = 2,
161 .channels_max = 2,
162 .rates = S3C2412_I2S_RATES,
163 .formats = SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_LE,
164 },
165 .capture = {
166 .channels_min = 2,
167 .channels_max = 2,
168 .rates = S3C2412_I2S_RATES,
169 .formats = SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_LE,
170 },
171 .ops = &s3c2412_i2s_dai_ops,
172};
173EXPORT_SYMBOL_GPL(s3c2412_i2s_dai);
174
175static int __init s3c2412_i2s_init(void)
176{
177 return s3c_i2sv2_register_dai(&s3c2412_i2s_dai);
178}
179module_init(s3c2412_i2s_init);
180
181static void __exit s3c2412_i2s_exit(void)
182{
183 snd_soc_unregister_dai(&s3c2412_i2s_dai);
184}
185module_exit(s3c2412_i2s_exit);
186
187/* Module information */
188MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>");
189MODULE_DESCRIPTION("S3C2412 I2S SoC Interface");
190MODULE_LICENSE("GPL");
diff --git a/sound/soc/s3c24xx/s3c2412-i2s.h b/sound/soc/s3c24xx/s3c2412-i2s.h
deleted file mode 100644
index 0b5686b4d5c3..000000000000
--- a/sound/soc/s3c24xx/s3c2412-i2s.h
+++ /dev/null
@@ -1,29 +0,0 @@
1/* sound/soc/s3c24xx/s3c2412-i2s.c
2 *
3 * ALSA Soc Audio Layer - S3C2412 I2S driver
4 *
5 * Copyright (c) 2007 Simtec Electronics
6 * http://armlinux.simtec.co.uk/
7 * Ben Dooks <ben@simtec.co.uk>
8 *
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the
11 * Free Software Foundation; either version 2 of the License, or (at your
12 * option) any later version.
13*/
14
15#ifndef __SND_SOC_S3C24XX_S3C2412_I2S_H
16#define __SND_SOC_S3C24XX_S3C2412_I2S_H __FILE__
17
18#include "s3c-i2s-v2.h"
19
20#define S3C2412_DIV_BCLK S3C_I2SV2_DIV_BCLK
21#define S3C2412_DIV_RCLK S3C_I2SV2_DIV_RCLK
22#define S3C2412_DIV_PRESCALER S3C_I2SV2_DIV_PRESCALER
23
24#define S3C2412_CLKSRC_PCLK S3C_I2SV2_CLKSRC_PCLK
25#define S3C2412_CLKSRC_I2SCLK S3C_I2SV2_CLKSRC_AUDIOBUS
26
27extern struct snd_soc_dai s3c2412_i2s_dai;
28
29#endif /* __SND_SOC_S3C24XX_S3C2412_I2S_H */
diff --git a/sound/soc/s3c24xx/s3c24xx-i2s.c b/sound/soc/s3c24xx/s3c24xx-i2s.c
deleted file mode 100644
index c3ac890a3986..000000000000
--- a/sound/soc/s3c24xx/s3c24xx-i2s.c
+++ /dev/null
@@ -1,503 +0,0 @@
1/*
2 * s3c24xx-i2s.c -- ALSA Soc Audio Layer
3 *
4 * (c) 2006 Wolfson Microelectronics PLC.
5 * Graeme Gregory graeme.gregory@wolfsonmicro.com or linux@wolfsonmicro.com
6 *
7 * Copyright 2004-2005 Simtec Electronics
8 * http://armlinux.simtec.co.uk/
9 * Ben Dooks <ben@simtec.co.uk>
10 *
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by the
13 * Free Software Foundation; either version 2 of the License, or (at your
14 * option) any later version.
15 */
16
17#include <linux/init.h>
18#include <linux/module.h>
19#include <linux/device.h>
20#include <linux/delay.h>
21#include <linux/clk.h>
22#include <linux/jiffies.h>
23#include <linux/io.h>
24#include <linux/gpio.h>
25
26#include <sound/core.h>
27#include <sound/pcm.h>
28#include <sound/pcm_params.h>
29#include <sound/initval.h>
30#include <sound/soc.h>
31
32#include <mach/hardware.h>
33#include <mach/regs-gpio.h>
34#include <mach/regs-clock.h>
35
36#include <asm/dma.h>
37#include <mach/dma.h>
38
39#include <plat/regs-iis.h>
40
41#include "s3c-dma.h"
42#include "s3c24xx-i2s.h"
43
44static struct s3c2410_dma_client s3c24xx_dma_client_out = {
45 .name = "I2S PCM Stereo out"
46};
47
48static struct s3c2410_dma_client s3c24xx_dma_client_in = {
49 .name = "I2S PCM Stereo in"
50};
51
52static struct s3c_dma_params s3c24xx_i2s_pcm_stereo_out = {
53 .client = &s3c24xx_dma_client_out,
54 .channel = DMACH_I2S_OUT,
55 .dma_addr = S3C2410_PA_IIS + S3C2410_IISFIFO,
56 .dma_size = 2,
57};
58
59static struct s3c_dma_params s3c24xx_i2s_pcm_stereo_in = {
60 .client = &s3c24xx_dma_client_in,
61 .channel = DMACH_I2S_IN,
62 .dma_addr = S3C2410_PA_IIS + S3C2410_IISFIFO,
63 .dma_size = 2,
64};
65
66struct s3c24xx_i2s_info {
67 void __iomem *regs;
68 struct clk *iis_clk;
69 u32 iiscon;
70 u32 iismod;
71 u32 iisfcon;
72 u32 iispsr;
73};
74static struct s3c24xx_i2s_info s3c24xx_i2s;
75
76static void s3c24xx_snd_txctrl(int on)
77{
78 u32 iisfcon;
79 u32 iiscon;
80 u32 iismod;
81
82 pr_debug("Entered %s\n", __func__);
83
84 iisfcon = readl(s3c24xx_i2s.regs + S3C2410_IISFCON);
85 iiscon = readl(s3c24xx_i2s.regs + S3C2410_IISCON);
86 iismod = readl(s3c24xx_i2s.regs + S3C2410_IISMOD);
87
88 pr_debug("r: IISCON: %x IISMOD: %x IISFCON: %x\n", iiscon, iismod, iisfcon);
89
90 if (on) {
91 iisfcon |= S3C2410_IISFCON_TXDMA | S3C2410_IISFCON_TXENABLE;
92 iiscon |= S3C2410_IISCON_TXDMAEN | S3C2410_IISCON_IISEN;
93 iiscon &= ~S3C2410_IISCON_TXIDLE;
94 iismod |= S3C2410_IISMOD_TXMODE;
95
96 writel(iismod, s3c24xx_i2s.regs + S3C2410_IISMOD);
97 writel(iisfcon, s3c24xx_i2s.regs + S3C2410_IISFCON);
98 writel(iiscon, s3c24xx_i2s.regs + S3C2410_IISCON);
99 } else {
100 /* note, we have to disable the FIFOs otherwise bad things
101 * seem to happen when the DMA stops. According to the
102 * Samsung supplied kernel, this should allow the DMA
103 * engine and FIFOs to reset. If this isn't allowed, the
104 * DMA engine will simply freeze randomly.
105 */
106
107 iisfcon &= ~S3C2410_IISFCON_TXENABLE;
108 iisfcon &= ~S3C2410_IISFCON_TXDMA;
109 iiscon |= S3C2410_IISCON_TXIDLE;
110 iiscon &= ~S3C2410_IISCON_TXDMAEN;
111 iismod &= ~S3C2410_IISMOD_TXMODE;
112
113 writel(iiscon, s3c24xx_i2s.regs + S3C2410_IISCON);
114 writel(iisfcon, s3c24xx_i2s.regs + S3C2410_IISFCON);
115 writel(iismod, s3c24xx_i2s.regs + S3C2410_IISMOD);
116 }
117
118 pr_debug("w: IISCON: %x IISMOD: %x IISFCON: %x\n", iiscon, iismod, iisfcon);
119}
120
121static void s3c24xx_snd_rxctrl(int on)
122{
123 u32 iisfcon;
124 u32 iiscon;
125 u32 iismod;
126
127 pr_debug("Entered %s\n", __func__);
128
129 iisfcon = readl(s3c24xx_i2s.regs + S3C2410_IISFCON);
130 iiscon = readl(s3c24xx_i2s.regs + S3C2410_IISCON);
131 iismod = readl(s3c24xx_i2s.regs + S3C2410_IISMOD);
132
133 pr_debug("r: IISCON: %x IISMOD: %x IISFCON: %x\n", iiscon, iismod, iisfcon);
134
135 if (on) {
136 iisfcon |= S3C2410_IISFCON_RXDMA | S3C2410_IISFCON_RXENABLE;
137 iiscon |= S3C2410_IISCON_RXDMAEN | S3C2410_IISCON_IISEN;
138 iiscon &= ~S3C2410_IISCON_RXIDLE;
139 iismod |= S3C2410_IISMOD_RXMODE;
140
141 writel(iismod, s3c24xx_i2s.regs + S3C2410_IISMOD);
142 writel(iisfcon, s3c24xx_i2s.regs + S3C2410_IISFCON);
143 writel(iiscon, s3c24xx_i2s.regs + S3C2410_IISCON);
144 } else {
145 /* note, we have to disable the FIFOs otherwise bad things
146 * seem to happen when the DMA stops. According to the
147 * Samsung supplied kernel, this should allow the DMA
148 * engine and FIFOs to reset. If this isn't allowed, the
149 * DMA engine will simply freeze randomly.
150 */
151
152 iisfcon &= ~S3C2410_IISFCON_RXENABLE;
153 iisfcon &= ~S3C2410_IISFCON_RXDMA;
154 iiscon |= S3C2410_IISCON_RXIDLE;
155 iiscon &= ~S3C2410_IISCON_RXDMAEN;
156 iismod &= ~S3C2410_IISMOD_RXMODE;
157
158 writel(iisfcon, s3c24xx_i2s.regs + S3C2410_IISFCON);
159 writel(iiscon, s3c24xx_i2s.regs + S3C2410_IISCON);
160 writel(iismod, s3c24xx_i2s.regs + S3C2410_IISMOD);
161 }
162
163 pr_debug("w: IISCON: %x IISMOD: %x IISFCON: %x\n", iiscon, iismod, iisfcon);
164}
165
166/*
167 * Wait for the LR signal to allow synchronisation to the L/R clock
168 * from the codec. May only be needed for slave mode.
169 */
170static int s3c24xx_snd_lrsync(void)
171{
172 u32 iiscon;
173 int timeout = 50; /* 5ms */
174
175 pr_debug("Entered %s\n", __func__);
176
177 while (1) {
178 iiscon = readl(s3c24xx_i2s.regs + S3C2410_IISCON);
179 if (iiscon & S3C2410_IISCON_LRINDEX)
180 break;
181
182 if (!timeout--)
183 return -ETIMEDOUT;
184 udelay(100);
185 }
186
187 return 0;
188}
189
190/*
191 * Check whether CPU is the master or slave
192 */
193static inline int s3c24xx_snd_is_clkmaster(void)
194{
195 pr_debug("Entered %s\n", __func__);
196
197 return (readl(s3c24xx_i2s.regs + S3C2410_IISMOD) & S3C2410_IISMOD_SLAVE) ? 0:1;
198}
199
200/*
201 * Set S3C24xx I2S DAI format
202 */
203static int s3c24xx_i2s_set_fmt(struct snd_soc_dai *cpu_dai,
204 unsigned int fmt)
205{
206 u32 iismod;
207
208 pr_debug("Entered %s\n", __func__);
209
210 iismod = readl(s3c24xx_i2s.regs + S3C2410_IISMOD);
211 pr_debug("hw_params r: IISMOD: %x \n", iismod);
212
213 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
214 case SND_SOC_DAIFMT_CBM_CFM:
215 iismod |= S3C2410_IISMOD_SLAVE;
216 break;
217 case SND_SOC_DAIFMT_CBS_CFS:
218 iismod &= ~S3C2410_IISMOD_SLAVE;
219 break;
220 default:
221 return -EINVAL;
222 }
223
224 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
225 case SND_SOC_DAIFMT_LEFT_J:
226 iismod |= S3C2410_IISMOD_MSB;
227 break;
228 case SND_SOC_DAIFMT_I2S:
229 iismod &= ~S3C2410_IISMOD_MSB;
230 break;
231 default:
232 return -EINVAL;
233 }
234
235 writel(iismod, s3c24xx_i2s.regs + S3C2410_IISMOD);
236 pr_debug("hw_params w: IISMOD: %x \n", iismod);
237 return 0;
238}
239
240static int s3c24xx_i2s_hw_params(struct snd_pcm_substream *substream,
241 struct snd_pcm_hw_params *params,
242 struct snd_soc_dai *dai)
243{
244 struct snd_soc_pcm_runtime *rtd = substream->private_data;
245 struct s3c_dma_params *dma_data;
246 u32 iismod;
247
248 pr_debug("Entered %s\n", __func__);
249
250 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
251 dma_data = &s3c24xx_i2s_pcm_stereo_out;
252 else
253 dma_data = &s3c24xx_i2s_pcm_stereo_in;
254
255 snd_soc_dai_set_dma_data(rtd->dai->cpu_dai, substream, dma_data);
256
257 /* Working copies of register */
258 iismod = readl(s3c24xx_i2s.regs + S3C2410_IISMOD);
259 pr_debug("hw_params r: IISMOD: %x\n", iismod);
260
261 switch (params_format(params)) {
262 case SNDRV_PCM_FORMAT_S8:
263 iismod &= ~S3C2410_IISMOD_16BIT;
264 dma_data->dma_size = 1;
265 break;
266 case SNDRV_PCM_FORMAT_S16_LE:
267 iismod |= S3C2410_IISMOD_16BIT;
268 dma_data->dma_size = 2;
269 break;
270 default:
271 return -EINVAL;
272 }
273
274 writel(iismod, s3c24xx_i2s.regs + S3C2410_IISMOD);
275 pr_debug("hw_params w: IISMOD: %x\n", iismod);
276 return 0;
277}
278
279static int s3c24xx_i2s_trigger(struct snd_pcm_substream *substream, int cmd,
280 struct snd_soc_dai *dai)
281{
282 int ret = 0;
283 struct snd_soc_pcm_runtime *rtd = substream->private_data;
284 struct s3c_dma_params *dma_data =
285 snd_soc_dai_get_dma_data(rtd->dai->cpu_dai, substream);
286
287 pr_debug("Entered %s\n", __func__);
288
289 switch (cmd) {
290 case SNDRV_PCM_TRIGGER_START:
291 case SNDRV_PCM_TRIGGER_RESUME:
292 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
293 if (!s3c24xx_snd_is_clkmaster()) {
294 ret = s3c24xx_snd_lrsync();
295 if (ret)
296 goto exit_err;
297 }
298
299 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
300 s3c24xx_snd_rxctrl(1);
301 else
302 s3c24xx_snd_txctrl(1);
303
304 s3c2410_dma_ctrl(dma_data->channel, S3C2410_DMAOP_STARTED);
305 break;
306 case SNDRV_PCM_TRIGGER_STOP:
307 case SNDRV_PCM_TRIGGER_SUSPEND:
308 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
309 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
310 s3c24xx_snd_rxctrl(0);
311 else
312 s3c24xx_snd_txctrl(0);
313 break;
314 default:
315 ret = -EINVAL;
316 break;
317 }
318
319exit_err:
320 return ret;
321}
322
323/*
324 * Set S3C24xx Clock source
325 */
326static int s3c24xx_i2s_set_sysclk(struct snd_soc_dai *cpu_dai,
327 int clk_id, unsigned int freq, int dir)
328{
329 u32 iismod = readl(s3c24xx_i2s.regs + S3C2410_IISMOD);
330
331 pr_debug("Entered %s\n", __func__);
332
333 iismod &= ~S3C2440_IISMOD_MPLL;
334
335 switch (clk_id) {
336 case S3C24XX_CLKSRC_PCLK:
337 break;
338 case S3C24XX_CLKSRC_MPLL:
339 iismod |= S3C2440_IISMOD_MPLL;
340 break;
341 default:
342 return -EINVAL;
343 }
344
345 writel(iismod, s3c24xx_i2s.regs + S3C2410_IISMOD);
346 return 0;
347}
348
349/*
350 * Set S3C24xx Clock dividers
351 */
352static int s3c24xx_i2s_set_clkdiv(struct snd_soc_dai *cpu_dai,
353 int div_id, int div)
354{
355 u32 reg;
356
357 pr_debug("Entered %s\n", __func__);
358
359 switch (div_id) {
360 case S3C24XX_DIV_BCLK:
361 reg = readl(s3c24xx_i2s.regs + S3C2410_IISMOD) & ~S3C2410_IISMOD_FS_MASK;
362 writel(reg | div, s3c24xx_i2s.regs + S3C2410_IISMOD);
363 break;
364 case S3C24XX_DIV_MCLK:
365 reg = readl(s3c24xx_i2s.regs + S3C2410_IISMOD) & ~(S3C2410_IISMOD_384FS);
366 writel(reg | div, s3c24xx_i2s.regs + S3C2410_IISMOD);
367 break;
368 case S3C24XX_DIV_PRESCALER:
369 writel(div, s3c24xx_i2s.regs + S3C2410_IISPSR);
370 reg = readl(s3c24xx_i2s.regs + S3C2410_IISCON);
371 writel(reg | S3C2410_IISCON_PSCEN, s3c24xx_i2s.regs + S3C2410_IISCON);
372 break;
373 default:
374 return -EINVAL;
375 }
376
377 return 0;
378}
379
380/*
381 * To avoid duplicating clock code, allow machine driver to
382 * get the clockrate from here.
383 */
384u32 s3c24xx_i2s_get_clockrate(void)
385{
386 return clk_get_rate(s3c24xx_i2s.iis_clk);
387}
388EXPORT_SYMBOL_GPL(s3c24xx_i2s_get_clockrate);
389
390static int s3c24xx_i2s_probe(struct platform_device *pdev,
391 struct snd_soc_dai *dai)
392{
393 pr_debug("Entered %s\n", __func__);
394
395 s3c24xx_i2s.regs = ioremap(S3C2410_PA_IIS, 0x100);
396 if (s3c24xx_i2s.regs == NULL)
397 return -ENXIO;
398
399 s3c24xx_i2s.iis_clk = clk_get(&pdev->dev, "iis");
400 if (s3c24xx_i2s.iis_clk == NULL) {
401 pr_err("failed to get iis_clock\n");
402 iounmap(s3c24xx_i2s.regs);
403 return -ENODEV;
404 }
405 clk_enable(s3c24xx_i2s.iis_clk);
406
407 /* Configure the I2S pins in correct mode */
408 s3c2410_gpio_cfgpin(S3C2410_GPE0, S3C2410_GPE0_I2SLRCK);
409 s3c2410_gpio_cfgpin(S3C2410_GPE1, S3C2410_GPE1_I2SSCLK);
410 s3c2410_gpio_cfgpin(S3C2410_GPE2, S3C2410_GPE2_CDCLK);
411 s3c2410_gpio_cfgpin(S3C2410_GPE3, S3C2410_GPE3_I2SSDI);
412 s3c2410_gpio_cfgpin(S3C2410_GPE4, S3C2410_GPE4_I2SSDO);
413
414 writel(S3C2410_IISCON_IISEN, s3c24xx_i2s.regs + S3C2410_IISCON);
415
416 s3c24xx_snd_txctrl(0);
417 s3c24xx_snd_rxctrl(0);
418
419 return 0;
420}
421
422#ifdef CONFIG_PM
423static int s3c24xx_i2s_suspend(struct snd_soc_dai *cpu_dai)
424{
425 pr_debug("Entered %s\n", __func__);
426
427 s3c24xx_i2s.iiscon = readl(s3c24xx_i2s.regs + S3C2410_IISCON);
428 s3c24xx_i2s.iismod = readl(s3c24xx_i2s.regs + S3C2410_IISMOD);
429 s3c24xx_i2s.iisfcon = readl(s3c24xx_i2s.regs + S3C2410_IISFCON);
430 s3c24xx_i2s.iispsr = readl(s3c24xx_i2s.regs + S3C2410_IISPSR);
431
432 clk_disable(s3c24xx_i2s.iis_clk);
433
434 return 0;
435}
436
437static int s3c24xx_i2s_resume(struct snd_soc_dai *cpu_dai)
438{
439 pr_debug("Entered %s\n", __func__);
440 clk_enable(s3c24xx_i2s.iis_clk);
441
442 writel(s3c24xx_i2s.iiscon, s3c24xx_i2s.regs + S3C2410_IISCON);
443 writel(s3c24xx_i2s.iismod, s3c24xx_i2s.regs + S3C2410_IISMOD);
444 writel(s3c24xx_i2s.iisfcon, s3c24xx_i2s.regs + S3C2410_IISFCON);
445 writel(s3c24xx_i2s.iispsr, s3c24xx_i2s.regs + S3C2410_IISPSR);
446
447 return 0;
448}
449#else
450#define s3c24xx_i2s_suspend NULL
451#define s3c24xx_i2s_resume NULL
452#endif
453
454
455#define S3C24XX_I2S_RATES \
456 (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 | SNDRV_PCM_RATE_16000 | \
457 SNDRV_PCM_RATE_22050 | SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | \
458 SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000)
459
460static struct snd_soc_dai_ops s3c24xx_i2s_dai_ops = {
461 .trigger = s3c24xx_i2s_trigger,
462 .hw_params = s3c24xx_i2s_hw_params,
463 .set_fmt = s3c24xx_i2s_set_fmt,
464 .set_clkdiv = s3c24xx_i2s_set_clkdiv,
465 .set_sysclk = s3c24xx_i2s_set_sysclk,
466};
467
468struct snd_soc_dai s3c24xx_i2s_dai = {
469 .name = "s3c24xx-i2s",
470 .id = 0,
471 .probe = s3c24xx_i2s_probe,
472 .suspend = s3c24xx_i2s_suspend,
473 .resume = s3c24xx_i2s_resume,
474 .playback = {
475 .channels_min = 2,
476 .channels_max = 2,
477 .rates = S3C24XX_I2S_RATES,
478 .formats = SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_LE,},
479 .capture = {
480 .channels_min = 2,
481 .channels_max = 2,
482 .rates = S3C24XX_I2S_RATES,
483 .formats = SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_LE,},
484 .ops = &s3c24xx_i2s_dai_ops,
485};
486EXPORT_SYMBOL_GPL(s3c24xx_i2s_dai);
487
488static int __init s3c24xx_i2s_init(void)
489{
490 return snd_soc_register_dai(&s3c24xx_i2s_dai);
491}
492module_init(s3c24xx_i2s_init);
493
494static void __exit s3c24xx_i2s_exit(void)
495{
496 snd_soc_unregister_dai(&s3c24xx_i2s_dai);
497}
498module_exit(s3c24xx_i2s_exit);
499
500/* Module information */
501MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>");
502MODULE_DESCRIPTION("s3c24xx I2S SoC Interface");
503MODULE_LICENSE("GPL");
diff --git a/sound/soc/s3c24xx/s3c24xx-i2s.h b/sound/soc/s3c24xx/s3c24xx-i2s.h
deleted file mode 100644
index 726d91cf4e1c..000000000000
--- a/sound/soc/s3c24xx/s3c24xx-i2s.h
+++ /dev/null
@@ -1,37 +0,0 @@
1/*
2 * s3c24xx-i2s.c -- ALSA Soc Audio Layer
3 *
4 * Copyright 2005 Wolfson Microelectronics PLC.
5 * Author: Graeme Gregory
6 * graeme.gregory@wolfsonmicro.com or linux@wolfsonmicro.com
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
12 *
13 * Revision history
14 * 10th Nov 2006 Initial version.
15 */
16
17#ifndef S3C24XXI2S_H_
18#define S3C24XXI2S_H_
19
20/* clock sources */
21#define S3C24XX_CLKSRC_PCLK 0
22#define S3C24XX_CLKSRC_MPLL 1
23
24/* Clock dividers */
25#define S3C24XX_DIV_MCLK 0
26#define S3C24XX_DIV_BCLK 1
27#define S3C24XX_DIV_PRESCALER 2
28
29/* prescaler */
30#define S3C24XX_PRESCALE(a,b) \
31 (((a - 1) << S3C2410_IISPSR_INTSHIFT) | ((b - 1) << S3C2410_IISPSR_EXTSHFIT))
32
33u32 s3c24xx_i2s_get_clockrate(void);
34
35extern struct snd_soc_dai s3c24xx_i2s_dai;
36
37#endif /*S3C24XXI2S_H_*/
diff --git a/sound/soc/s3c24xx/s3c24xx_simtec.c b/sound/soc/s3c24xx/s3c24xx_simtec.c
deleted file mode 100644
index 4984754f3298..000000000000
--- a/sound/soc/s3c24xx/s3c24xx_simtec.c
+++ /dev/null
@@ -1,394 +0,0 @@
1/* sound/soc/s3c24xx/s3c24xx_simtec.c
2 *
3 * Copyright 2009 Simtec Electronics
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8*/
9
10#include <linux/module.h>
11#include <linux/moduleparam.h>
12#include <linux/platform_device.h>
13#include <linux/gpio.h>
14#include <linux/clk.h>
15#include <linux/i2c.h>
16
17#include <sound/core.h>
18#include <sound/pcm.h>
19#include <sound/soc.h>
20#include <sound/soc-dapm.h>
21
22#include <plat/audio-simtec.h>
23
24#include "s3c-dma.h"
25#include "s3c24xx-i2s.h"
26#include "s3c24xx_simtec.h"
27
28static struct s3c24xx_audio_simtec_pdata *pdata;
29static struct clk *xtal_clk;
30
31static int spk_gain;
32static int spk_unmute;
33
34/**
35 * speaker_gain_get - read the speaker gain setting.
36 * @kcontrol: The control for the speaker gain.
37 * @ucontrol: The value that needs to be updated.
38 *
39 * Read the value for the AMP gain control.
40 */
41static int speaker_gain_get(struct snd_kcontrol *kcontrol,
42 struct snd_ctl_elem_value *ucontrol)
43{
44 ucontrol->value.integer.value[0] = spk_gain;
45 return 0;
46}
47
48/**
49 * speaker_gain_set - set the value of the speaker amp gain
50 * @value: The value to write.
51 */
52static void speaker_gain_set(int value)
53{
54 gpio_set_value_cansleep(pdata->amp_gain[0], value & 1);
55 gpio_set_value_cansleep(pdata->amp_gain[1], value >> 1);
56}
57
58/**
59 * speaker_gain_put - set the speaker gain setting.
60 * @kcontrol: The control for the speaker gain.
61 * @ucontrol: The value that needs to be set.
62 *
63 * Set the value of the speaker gain from the specified
64 * @ucontrol setting.
65 *
66 * Note, if the speaker amp is muted, then we do not set a gain value
67 * as at-least one of the ICs that is fitted will try and power up even
68 * if the main control is set to off.
69 */
70static int speaker_gain_put(struct snd_kcontrol *kcontrol,
71 struct snd_ctl_elem_value *ucontrol)
72{
73 int value = ucontrol->value.integer.value[0];
74
75 spk_gain = value;
76
77 if (!spk_unmute)
78 speaker_gain_set(value);
79
80 return 0;
81}
82
83static const struct snd_kcontrol_new amp_gain_controls[] = {
84 SOC_SINGLE_EXT("Speaker Gain", 0, 0, 3, 0,
85 speaker_gain_get, speaker_gain_put),
86};
87
88/**
89 * spk_unmute_state - set the unmute state of the speaker
90 * @to: zero to unmute, non-zero to ununmute.
91 */
92static void spk_unmute_state(int to)
93{
94 pr_debug("%s: to=%d\n", __func__, to);
95
96 spk_unmute = to;
97 gpio_set_value(pdata->amp_gpio, to);
98
99 /* if we're umuting, also re-set the gain */
100 if (to && pdata->amp_gain[0] > 0)
101 speaker_gain_set(spk_gain);
102}
103
104/**
105 * speaker_unmute_get - read the speaker unmute setting.
106 * @kcontrol: The control for the speaker gain.
107 * @ucontrol: The value that needs to be updated.
108 *
109 * Read the value for the AMP gain control.
110 */
111static int speaker_unmute_get(struct snd_kcontrol *kcontrol,
112 struct snd_ctl_elem_value *ucontrol)
113{
114 ucontrol->value.integer.value[0] = spk_unmute;
115 return 0;
116}
117
118/**
119 * speaker_unmute_put - set the speaker unmute setting.
120 * @kcontrol: The control for the speaker gain.
121 * @ucontrol: The value that needs to be set.
122 *
123 * Set the value of the speaker gain from the specified
124 * @ucontrol setting.
125 */
126static int speaker_unmute_put(struct snd_kcontrol *kcontrol,
127 struct snd_ctl_elem_value *ucontrol)
128{
129 spk_unmute_state(ucontrol->value.integer.value[0]);
130 return 0;
131}
132
133/* This is added as a manual control as the speaker amps create clicks
134 * when their power state is changed, which are far more noticeable than
135 * anything produced by the CODEC itself.
136 */
137static const struct snd_kcontrol_new amp_unmute_controls[] = {
138 SOC_SINGLE_EXT("Speaker Switch", 0, 0, 1, 0,
139 speaker_unmute_get, speaker_unmute_put),
140};
141
142void simtec_audio_init(struct snd_soc_codec *codec)
143{
144 if (pdata->amp_gpio > 0) {
145 pr_debug("%s: adding amp routes\n", __func__);
146
147 snd_soc_add_controls(codec, amp_unmute_controls,
148 ARRAY_SIZE(amp_unmute_controls));
149 }
150
151 if (pdata->amp_gain[0] > 0) {
152 pr_debug("%s: adding amp controls\n", __func__);
153 snd_soc_add_controls(codec, amp_gain_controls,
154 ARRAY_SIZE(amp_gain_controls));
155 }
156}
157EXPORT_SYMBOL_GPL(simtec_audio_init);
158
159#define CODEC_CLOCK 12000000
160
161/**
162 * simtec_hw_params - update hardware parameters
163 * @substream: The audio substream instance.
164 * @params: The parameters requested.
165 *
166 * Update the codec data routing and configuration settings
167 * from the supplied data.
168 */
169static int simtec_hw_params(struct snd_pcm_substream *substream,
170 struct snd_pcm_hw_params *params)
171{
172 struct snd_soc_pcm_runtime *rtd = substream->private_data;
173 struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
174 struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
175 int ret;
176
177 /* Set the CODEC as the bus clock master, I2S */
178 ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S |
179 SND_SOC_DAIFMT_NB_NF |
180 SND_SOC_DAIFMT_CBM_CFM);
181 if (ret) {
182 pr_err("%s: failed set cpu dai format\n", __func__);
183 return ret;
184 }
185
186 /* Set the CODEC as the bus clock master */
187 ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S |
188 SND_SOC_DAIFMT_NB_NF |
189 SND_SOC_DAIFMT_CBM_CFM);
190 if (ret) {
191 pr_err("%s: failed set codec dai format\n", __func__);
192 return ret;
193 }
194
195 ret = snd_soc_dai_set_sysclk(codec_dai, 0,
196 CODEC_CLOCK, SND_SOC_CLOCK_IN);
197 if (ret) {
198 pr_err( "%s: failed setting codec sysclk\n", __func__);
199 return ret;
200 }
201
202 if (pdata->use_mpllin) {
203 ret = snd_soc_dai_set_sysclk(cpu_dai, S3C24XX_CLKSRC_MPLL,
204 0, SND_SOC_CLOCK_OUT);
205
206 if (ret) {
207 pr_err("%s: failed to set MPLLin as clksrc\n",
208 __func__);
209 return ret;
210 }
211 }
212
213 if (pdata->output_cdclk) {
214 int cdclk_scale;
215
216 cdclk_scale = clk_get_rate(xtal_clk) / CODEC_CLOCK;
217 cdclk_scale--;
218
219 ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C24XX_DIV_PRESCALER,
220 cdclk_scale);
221 }
222
223 return 0;
224}
225
226static int simtec_call_startup(struct s3c24xx_audio_simtec_pdata *pd)
227{
228 /* call any board supplied startup code, this currently only
229 * covers the bast/vr1000 which have a CPLD in the way of the
230 * LRCLK */
231 if (pd->startup)
232 pd->startup();
233
234 return 0;
235}
236
237static struct snd_soc_ops simtec_snd_ops = {
238 .hw_params = simtec_hw_params,
239};
240
241/**
242 * attach_gpio_amp - get and configure the necessary gpios
243 * @dev: The device we're probing.
244 * @pd: The platform data supplied by the board.
245 *
246 * If there is a GPIO based amplifier attached to the board, claim
247 * the necessary GPIO lines for it, and set default values.
248 */
249static int attach_gpio_amp(struct device *dev,
250 struct s3c24xx_audio_simtec_pdata *pd)
251{
252 int ret;
253
254 /* attach gpio amp gain (if any) */
255 if (pdata->amp_gain[0] > 0) {
256 ret = gpio_request(pd->amp_gain[0], "gpio-amp-gain0");
257 if (ret) {
258 dev_err(dev, "cannot get amp gpio gain0\n");
259 return ret;
260 }
261
262 ret = gpio_request(pd->amp_gain[1], "gpio-amp-gain1");
263 if (ret) {
264 dev_err(dev, "cannot get amp gpio gain1\n");
265 gpio_free(pdata->amp_gain[0]);
266 return ret;
267 }
268
269 gpio_direction_output(pd->amp_gain[0], 0);
270 gpio_direction_output(pd->amp_gain[1], 0);
271 }
272
273 /* note, currently we assume GPA0 isn't valid amp */
274 if (pdata->amp_gpio > 0) {
275 ret = gpio_request(pd->amp_gpio, "gpio-amp");
276 if (ret) {
277 dev_err(dev, "cannot get amp gpio %d (%d)\n",
278 pd->amp_gpio, ret);
279 goto err_amp;
280 }
281
282 /* set the amp off at startup */
283 spk_unmute_state(0);
284 }
285
286 return 0;
287
288err_amp:
289 if (pd->amp_gain[0] > 0) {
290 gpio_free(pd->amp_gain[0]);
291 gpio_free(pd->amp_gain[1]);
292 }
293
294 return ret;
295}
296
297static void detach_gpio_amp(struct s3c24xx_audio_simtec_pdata *pd)
298{
299 if (pd->amp_gain[0] > 0) {
300 gpio_free(pd->amp_gain[0]);
301 gpio_free(pd->amp_gain[1]);
302 }
303
304 if (pd->amp_gpio > 0)
305 gpio_free(pd->amp_gpio);
306}
307
308#ifdef CONFIG_PM
309int simtec_audio_resume(struct device *dev)
310{
311 simtec_call_startup(pdata);
312 return 0;
313}
314
315const struct dev_pm_ops simtec_audio_pmops = {
316 .resume = simtec_audio_resume,
317};
318EXPORT_SYMBOL_GPL(simtec_audio_pmops);
319#endif
320
321int __devinit simtec_audio_core_probe(struct platform_device *pdev,
322 struct snd_soc_device *socdev)
323{
324 struct platform_device *snd_dev;
325 int ret;
326
327 socdev->card->dai_link->ops = &simtec_snd_ops;
328
329 pdata = pdev->dev.platform_data;
330 if (!pdata) {
331 dev_err(&pdev->dev, "no platform data supplied\n");
332 return -EINVAL;
333 }
334
335 simtec_call_startup(pdata);
336
337 xtal_clk = clk_get(&pdev->dev, "xtal");
338 if (IS_ERR(xtal_clk)) {
339 dev_err(&pdev->dev, "could not get clkout0\n");
340 return -EINVAL;
341 }
342
343 dev_info(&pdev->dev, "xtal rate is %ld\n", clk_get_rate(xtal_clk));
344
345 ret = attach_gpio_amp(&pdev->dev, pdata);
346 if (ret)
347 goto err_clk;
348
349 snd_dev = platform_device_alloc("soc-audio", -1);
350 if (!snd_dev) {
351 dev_err(&pdev->dev, "failed to alloc soc-audio devicec\n");
352 ret = -ENOMEM;
353 goto err_gpio;
354 }
355
356 platform_set_drvdata(snd_dev, socdev);
357 socdev->dev = &snd_dev->dev;
358
359 ret = platform_device_add(snd_dev);
360 if (ret) {
361 dev_err(&pdev->dev, "failed to add soc-audio dev\n");
362 goto err_pdev;
363 }
364
365 platform_set_drvdata(pdev, snd_dev);
366 return 0;
367
368err_pdev:
369 platform_device_put(snd_dev);
370
371err_gpio:
372 detach_gpio_amp(pdata);
373
374err_clk:
375 clk_put(xtal_clk);
376 return ret;
377}
378EXPORT_SYMBOL_GPL(simtec_audio_core_probe);
379
380int __devexit simtec_audio_remove(struct platform_device *pdev)
381{
382 struct platform_device *snd_dev = platform_get_drvdata(pdev);
383
384 platform_device_unregister(snd_dev);
385
386 detach_gpio_amp(pdata);
387 clk_put(xtal_clk);
388 return 0;
389}
390EXPORT_SYMBOL_GPL(simtec_audio_remove);
391
392MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
393MODULE_DESCRIPTION("ALSA SoC Simtec Audio common support");
394MODULE_LICENSE("GPL");
diff --git a/sound/soc/s3c24xx/s3c24xx_simtec.h b/sound/soc/s3c24xx/s3c24xx_simtec.h
deleted file mode 100644
index e18faee30cce..000000000000
--- a/sound/soc/s3c24xx/s3c24xx_simtec.h
+++ /dev/null
@@ -1,22 +0,0 @@
1/* sound/soc/s3c24xx/s3c24xx_simtec.h
2 *
3 * Copyright 2009 Simtec Electronics
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8*/
9
10extern void simtec_audio_init(struct snd_soc_codec *codec);
11
12extern int simtec_audio_core_probe(struct platform_device *pdev,
13 struct snd_soc_device *socdev);
14
15extern int simtec_audio_remove(struct platform_device *pdev);
16
17#ifdef CONFIG_PM
18extern const struct dev_pm_ops simtec_audio_pmops;
19#define simtec_audio_pm &simtec_audio_pmops
20#else
21#define simtec_audio_pm NULL
22#endif
diff --git a/sound/soc/s3c24xx/s3c24xx_simtec_hermes.c b/sound/soc/s3c24xx/s3c24xx_simtec_hermes.c
deleted file mode 100644
index bdf8951af8e3..000000000000
--- a/sound/soc/s3c24xx/s3c24xx_simtec_hermes.c
+++ /dev/null
@@ -1,153 +0,0 @@
1/* sound/soc/s3c24xx/s3c24xx_simtec_hermes.c
2 *
3 * Copyright 2009 Simtec Electronics
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8*/
9
10#include <linux/module.h>
11#include <linux/clk.h>
12#include <linux/platform_device.h>
13
14#include <sound/core.h>
15#include <sound/pcm.h>
16#include <sound/soc.h>
17#include <sound/soc-dapm.h>
18
19#include <plat/audio-simtec.h>
20
21#include "s3c-dma.h"
22#include "s3c24xx-i2s.h"
23#include "s3c24xx_simtec.h"
24
25#include "../codecs/tlv320aic3x.h"
26
27static const struct snd_soc_dapm_widget dapm_widgets[] = {
28 SND_SOC_DAPM_LINE("GSM Out", NULL),
29 SND_SOC_DAPM_LINE("GSM In", NULL),
30 SND_SOC_DAPM_LINE("Line In", NULL),
31 SND_SOC_DAPM_LINE("Line Out", NULL),
32 SND_SOC_DAPM_LINE("ZV", NULL),
33 SND_SOC_DAPM_MIC("Mic Jack", NULL),
34 SND_SOC_DAPM_HP("Headphone Jack", NULL),
35};
36
37static const struct snd_soc_dapm_route base_map[] = {
38 /* Headphone connected to HP{L,R}OUT and HP{L,R}COM */
39
40 { "Headphone Jack", NULL, "HPLOUT" },
41 { "Headphone Jack", NULL, "HPLCOM" },
42 { "Headphone Jack", NULL, "HPROUT" },
43 { "Headphone Jack", NULL, "HPRCOM" },
44
45 /* ZV connected to Line1 */
46
47 { "LINE1L", NULL, "ZV" },
48 { "LINE1R", NULL, "ZV" },
49
50 /* Line In connected to Line2 */
51
52 { "LINE2L", NULL, "Line In" },
53 { "LINE2R", NULL, "Line In" },
54
55 /* Microphone connected to MIC3R and MIC_BIAS */
56
57 { "MIC3L", NULL, "Mic Jack" },
58
59 /* GSM connected to MONO_LOUT and MIC3L (in) */
60
61 { "GSM Out", NULL, "MONO_LOUT" },
62 { "MIC3L", NULL, "GSM In" },
63
64 /* Speaker is connected to LINEOUT{LN,LP,RN,RP}, however we are
65 * not using the DAPM to power it up and down as there it makes
66 * a click when powering up. */
67};
68
69/**
70 * simtec_hermes_init - initialise and add controls
71 * @codec; The codec instance to attach to.
72 *
73 * Attach our controls and configure the necessary codec
74 * mappings for our sound card instance.
75*/
76static int simtec_hermes_init(struct snd_soc_codec *codec)
77{
78 snd_soc_dapm_new_controls(codec, dapm_widgets,
79 ARRAY_SIZE(dapm_widgets));
80
81 snd_soc_dapm_add_routes(codec, base_map, ARRAY_SIZE(base_map));
82
83 snd_soc_dapm_enable_pin(codec, "Headphone Jack");
84 snd_soc_dapm_enable_pin(codec, "Line In");
85 snd_soc_dapm_enable_pin(codec, "Line Out");
86 snd_soc_dapm_enable_pin(codec, "Mic Jack");
87
88 simtec_audio_init(codec);
89 snd_soc_dapm_sync(codec);
90
91 return 0;
92}
93
94static struct aic3x_setup_data codec_setup = {
95};
96
97static struct snd_soc_dai_link simtec_dai_aic33 = {
98 .name = "tlv320aic33",
99 .stream_name = "TLV320AIC33",
100 .cpu_dai = &s3c24xx_i2s_dai,
101 .codec_dai = &aic3x_dai,
102 .init = simtec_hermes_init,
103};
104
105/* simtec audio machine driver */
106static struct snd_soc_card snd_soc_machine_simtec_aic33 = {
107 .name = "Simtec-Hermes",
108 .platform = &s3c24xx_soc_platform,
109 .dai_link = &simtec_dai_aic33,
110 .num_links = 1,
111};
112
113/* simtec audio subsystem */
114static struct snd_soc_device simtec_snd_devdata_aic33 = {
115 .card = &snd_soc_machine_simtec_aic33,
116 .codec_dev = &soc_codec_dev_aic3x,
117 .codec_data = &codec_setup,
118};
119
120static int __devinit simtec_audio_hermes_probe(struct platform_device *pd)
121{
122 dev_info(&pd->dev, "probing....\n");
123 return simtec_audio_core_probe(pd, &simtec_snd_devdata_aic33);
124}
125
126static struct platform_driver simtec_audio_hermes_platdrv = {
127 .driver = {
128 .owner = THIS_MODULE,
129 .name = "s3c24xx-simtec-hermes-snd",
130 .pm = simtec_audio_pm,
131 },
132 .probe = simtec_audio_hermes_probe,
133 .remove = __devexit_p(simtec_audio_remove),
134};
135
136MODULE_ALIAS("platform:s3c24xx-simtec-hermes-snd");
137
138static int __init simtec_hermes_modinit(void)
139{
140 return platform_driver_register(&simtec_audio_hermes_platdrv);
141}
142
143static void __exit simtec_hermes_modexit(void)
144{
145 platform_driver_unregister(&simtec_audio_hermes_platdrv);
146}
147
148module_init(simtec_hermes_modinit);
149module_exit(simtec_hermes_modexit);
150
151MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
152MODULE_DESCRIPTION("ALSA SoC Simtec Audio support");
153MODULE_LICENSE("GPL");
diff --git a/sound/soc/s3c24xx/s3c24xx_simtec_tlv320aic23.c b/sound/soc/s3c24xx/s3c24xx_simtec_tlv320aic23.c
deleted file mode 100644
index 185c0acb5ce6..000000000000
--- a/sound/soc/s3c24xx/s3c24xx_simtec_tlv320aic23.c
+++ /dev/null
@@ -1,137 +0,0 @@
1/* sound/soc/s3c24xx/s3c24xx_simtec_tlv320aic23.c
2 *
3 * Copyright 2009 Simtec Electronics
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8*/
9
10#include <linux/module.h>
11#include <linux/clk.h>
12#include <linux/platform_device.h>
13
14#include <sound/core.h>
15#include <sound/pcm.h>
16#include <sound/soc.h>
17#include <sound/soc-dapm.h>
18
19#include <plat/audio-simtec.h>
20
21#include "s3c-dma.h"
22#include "s3c24xx-i2s.h"
23#include "s3c24xx_simtec.h"
24
25#include "../codecs/tlv320aic23.h"
26
27/* supported machines:
28 *
29 * Machine Connections AMP
30 * ------- ----------- ---
31 * BAST MIC, HPOUT, LOUT, LIN TPA2001D1 (HPOUTL,R) (gain hardwired)
32 * VR1000 HPOUT, LIN None
33 * VR2000 LIN, LOUT, MIC, HP LM4871 (HPOUTL,R)
34 * DePicture LIN, LOUT, MIC, HP LM4871 (HPOUTL,R)
35 * Anubis LIN, LOUT, MIC, HP TPA2001D1 (HPOUTL,R)
36 */
37
38static const struct snd_soc_dapm_widget dapm_widgets[] = {
39 SND_SOC_DAPM_HP("Headphone Jack", NULL),
40 SND_SOC_DAPM_LINE("Line In", NULL),
41 SND_SOC_DAPM_LINE("Line Out", NULL),
42 SND_SOC_DAPM_MIC("Mic Jack", NULL),
43};
44
45static const struct snd_soc_dapm_route base_map[] = {
46 { "Headphone Jack", NULL, "LHPOUT"},
47 { "Headphone Jack", NULL, "RHPOUT"},
48
49 { "Line Out", NULL, "LOUT" },
50 { "Line Out", NULL, "ROUT" },
51
52 { "LLINEIN", NULL, "Line In"},
53 { "RLINEIN", NULL, "Line In"},
54
55 { "MICIN", NULL, "Mic Jack"},
56};
57
58/**
59 * simtec_tlv320aic23_init - initialise and add controls
60 * @codec; The codec instance to attach to.
61 *
62 * Attach our controls and configure the necessary codec
63 * mappings for our sound card instance.
64*/
65static int simtec_tlv320aic23_init(struct snd_soc_codec *codec)
66{
67 snd_soc_dapm_new_controls(codec, dapm_widgets,
68 ARRAY_SIZE(dapm_widgets));
69
70 snd_soc_dapm_add_routes(codec, base_map, ARRAY_SIZE(base_map));
71
72 snd_soc_dapm_enable_pin(codec, "Headphone Jack");
73 snd_soc_dapm_enable_pin(codec, "Line In");
74 snd_soc_dapm_enable_pin(codec, "Line Out");
75 snd_soc_dapm_enable_pin(codec, "Mic Jack");
76
77 simtec_audio_init(codec);
78 snd_soc_dapm_sync(codec);
79
80 return 0;
81}
82
83static struct snd_soc_dai_link simtec_dai_aic23 = {
84 .name = "tlv320aic23",
85 .stream_name = "TLV320AIC23",
86 .cpu_dai = &s3c24xx_i2s_dai,
87 .codec_dai = &tlv320aic23_dai,
88 .init = simtec_tlv320aic23_init,
89};
90
91/* simtec audio machine driver */
92static struct snd_soc_card snd_soc_machine_simtec_aic23 = {
93 .name = "Simtec",
94 .platform = &s3c24xx_soc_platform,
95 .dai_link = &simtec_dai_aic23,
96 .num_links = 1,
97};
98
99/* simtec audio subsystem */
100static struct snd_soc_device simtec_snd_devdata_aic23 = {
101 .card = &snd_soc_machine_simtec_aic23,
102 .codec_dev = &soc_codec_dev_tlv320aic23,
103};
104
105static int __devinit simtec_audio_tlv320aic23_probe(struct platform_device *pd)
106{
107 return simtec_audio_core_probe(pd, &simtec_snd_devdata_aic23);
108}
109
110static struct platform_driver simtec_audio_tlv320aic23_platdrv = {
111 .driver = {
112 .owner = THIS_MODULE,
113 .name = "s3c24xx-simtec-tlv320aic23",
114 .pm = simtec_audio_pm,
115 },
116 .probe = simtec_audio_tlv320aic23_probe,
117 .remove = __devexit_p(simtec_audio_remove),
118};
119
120MODULE_ALIAS("platform:s3c24xx-simtec-tlv320aic23");
121
122static int __init simtec_tlv320aic23_modinit(void)
123{
124 return platform_driver_register(&simtec_audio_tlv320aic23_platdrv);
125}
126
127static void __exit simtec_tlv320aic23_modexit(void)
128{
129 platform_driver_unregister(&simtec_audio_tlv320aic23_platdrv);
130}
131
132module_init(simtec_tlv320aic23_modinit);
133module_exit(simtec_tlv320aic23_modexit);
134
135MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
136MODULE_DESCRIPTION("ALSA SoC Simtec Audio support");
137MODULE_LICENSE("GPL");
diff --git a/sound/soc/s3c24xx/s3c24xx_uda134x.c b/sound/soc/s3c24xx/s3c24xx_uda134x.c
deleted file mode 100644
index 052d59659c29..000000000000
--- a/sound/soc/s3c24xx/s3c24xx_uda134x.c
+++ /dev/null
@@ -1,373 +0,0 @@
1/*
2 * Modifications by Christian Pellegrin <chripell@evolware.org>
3 *
4 * s3c24xx_uda134x.c -- S3C24XX_UDA134X ALSA SoC Audio board driver
5 *
6 * Copyright 2007 Dension Audio Systems Ltd.
7 * Author: Zoltan Devai
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12 */
13
14#include <linux/module.h>
15#include <linux/clk.h>
16#include <linux/mutex.h>
17#include <linux/gpio.h>
18#include <sound/pcm.h>
19#include <sound/pcm_params.h>
20#include <sound/soc.h>
21#include <sound/soc-dapm.h>
22#include <sound/s3c24xx_uda134x.h>
23#include <sound/uda134x.h>
24
25#include <plat/regs-iis.h>
26
27#include "s3c-dma.h"
28#include "s3c24xx-i2s.h"
29#include "../codecs/uda134x.h"
30
31
32/* #define ENFORCE_RATES 1 */
33/*
34 Unfortunately the S3C24XX in master mode has a limited capacity of
35 generating the clock for the codec. If you define this only rates
36 that are really available will be enforced. But be careful, most
37 user level application just want the usual sampling frequencies (8,
38 11.025, 22.050, 44.1 kHz) and anyway resampling is a costly
39 operation for embedded systems. So if you aren't very lucky or your
40 hardware engineer wasn't very forward-looking it's better to leave
41 this undefined. If you do so an approximate value for the requested
42 sampling rate in the range -/+ 5% will be chosen. If this in not
43 possible an error will be returned.
44*/
45
46static struct clk *xtal;
47static struct clk *pclk;
48/* this is need because we don't have a place where to keep the
49 * pointers to the clocks in each substream. We get the clocks only
50 * when we are actually using them so we don't block stuff like
51 * frequency change or oscillator power-off */
52static int clk_users;
53static DEFINE_MUTEX(clk_lock);
54
55static unsigned int rates[33 * 2];
56#ifdef ENFORCE_RATES
57static struct snd_pcm_hw_constraint_list hw_constraints_rates = {
58 .count = ARRAY_SIZE(rates),
59 .list = rates,
60 .mask = 0,
61};
62#endif
63
64static struct platform_device *s3c24xx_uda134x_snd_device;
65
66static int s3c24xx_uda134x_startup(struct snd_pcm_substream *substream)
67{
68 int ret = 0;
69#ifdef ENFORCE_RATES
70 struct snd_pcm_runtime *runtime = substream->runtime;
71#endif
72
73 mutex_lock(&clk_lock);
74 pr_debug("%s %d\n", __func__, clk_users);
75 if (clk_users == 0) {
76 xtal = clk_get(&s3c24xx_uda134x_snd_device->dev, "xtal");
77 if (!xtal) {
78 printk(KERN_ERR "%s cannot get xtal\n", __func__);
79 ret = -EBUSY;
80 } else {
81 pclk = clk_get(&s3c24xx_uda134x_snd_device->dev,
82 "pclk");
83 if (!pclk) {
84 printk(KERN_ERR "%s cannot get pclk\n",
85 __func__);
86 clk_put(xtal);
87 ret = -EBUSY;
88 }
89 }
90 if (!ret) {
91 int i, j;
92
93 for (i = 0; i < 2; i++) {
94 int fs = i ? 256 : 384;
95
96 rates[i*33] = clk_get_rate(xtal) / fs;
97 for (j = 1; j < 33; j++)
98 rates[i*33 + j] = clk_get_rate(pclk) /
99 (j * fs);
100 }
101 }
102 }
103 clk_users += 1;
104 mutex_unlock(&clk_lock);
105 if (!ret) {
106#ifdef ENFORCE_RATES
107 ret = snd_pcm_hw_constraint_list(runtime, 0,
108 SNDRV_PCM_HW_PARAM_RATE,
109 &hw_constraints_rates);
110 if (ret < 0)
111 printk(KERN_ERR "%s cannot set constraints\n",
112 __func__);
113#endif
114 }
115 return ret;
116}
117
118static void s3c24xx_uda134x_shutdown(struct snd_pcm_substream *substream)
119{
120 mutex_lock(&clk_lock);
121 pr_debug("%s %d\n", __func__, clk_users);
122 clk_users -= 1;
123 if (clk_users == 0) {
124 clk_put(xtal);
125 xtal = NULL;
126 clk_put(pclk);
127 pclk = NULL;
128 }
129 mutex_unlock(&clk_lock);
130}
131
132static int s3c24xx_uda134x_hw_params(struct snd_pcm_substream *substream,
133 struct snd_pcm_hw_params *params)
134{
135 struct snd_soc_pcm_runtime *rtd = substream->private_data;
136 struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
137 struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
138 unsigned int clk = 0;
139 int ret = 0;
140 int clk_source, fs_mode;
141 unsigned long rate = params_rate(params);
142 long err, cerr;
143 unsigned int div;
144 int i, bi;
145
146 err = 999999;
147 bi = 0;
148 for (i = 0; i < 2*33; i++) {
149 cerr = rates[i] - rate;
150 if (cerr < 0)
151 cerr = -cerr;
152 if (cerr < err) {
153 err = cerr;
154 bi = i;
155 }
156 }
157 if (bi / 33 == 1)
158 fs_mode = S3C2410_IISMOD_256FS;
159 else
160 fs_mode = S3C2410_IISMOD_384FS;
161 if (bi % 33 == 0) {
162 clk_source = S3C24XX_CLKSRC_MPLL;
163 div = 1;
164 } else {
165 clk_source = S3C24XX_CLKSRC_PCLK;
166 div = bi % 33;
167 }
168 pr_debug("%s desired rate %lu, %d\n", __func__, rate, bi);
169
170 clk = (fs_mode == S3C2410_IISMOD_384FS ? 384 : 256) * rate;
171 pr_debug("%s will use: %s %s %d sysclk %d err %ld\n", __func__,
172 fs_mode == S3C2410_IISMOD_384FS ? "384FS" : "256FS",
173 clk_source == S3C24XX_CLKSRC_MPLL ? "MPLLin" : "PCLK",
174 div, clk, err);
175
176 if ((err * 100 / rate) > 5) {
177 printk(KERN_ERR "S3C24XX_UDA134X: effective frequency "
178 "too different from desired (%ld%%)\n",
179 err * 100 / rate);
180 return -EINVAL;
181 }
182
183 ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S |
184 SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
185 if (ret < 0)
186 return ret;
187
188 ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S |
189 SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
190 if (ret < 0)
191 return ret;
192
193 ret = snd_soc_dai_set_sysclk(cpu_dai, clk_source , clk,
194 SND_SOC_CLOCK_IN);
195 if (ret < 0)
196 return ret;
197
198 ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C24XX_DIV_MCLK, fs_mode);
199 if (ret < 0)
200 return ret;
201
202 ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C24XX_DIV_BCLK,
203 S3C2410_IISMOD_32FS);
204 if (ret < 0)
205 return ret;
206
207 ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C24XX_DIV_PRESCALER,
208 S3C24XX_PRESCALE(div, div));
209 if (ret < 0)
210 return ret;
211
212 /* set the codec system clock for DAC and ADC */
213 ret = snd_soc_dai_set_sysclk(codec_dai, 0, clk,
214 SND_SOC_CLOCK_OUT);
215 if (ret < 0)
216 return ret;
217
218 return 0;
219}
220
221static struct snd_soc_ops s3c24xx_uda134x_ops = {
222 .startup = s3c24xx_uda134x_startup,
223 .shutdown = s3c24xx_uda134x_shutdown,
224 .hw_params = s3c24xx_uda134x_hw_params,
225};
226
227static struct snd_soc_dai_link s3c24xx_uda134x_dai_link = {
228 .name = "UDA134X",
229 .stream_name = "UDA134X",
230 .codec_dai = &uda134x_dai,
231 .cpu_dai = &s3c24xx_i2s_dai,
232 .ops = &s3c24xx_uda134x_ops,
233};
234
235static struct snd_soc_card snd_soc_s3c24xx_uda134x = {
236 .name = "S3C24XX_UDA134X",
237 .platform = &s3c24xx_soc_platform,
238 .dai_link = &s3c24xx_uda134x_dai_link,
239 .num_links = 1,
240};
241
242static struct s3c24xx_uda134x_platform_data *s3c24xx_uda134x_l3_pins;
243
244static void setdat(int v)
245{
246 gpio_set_value(s3c24xx_uda134x_l3_pins->l3_data, v > 0);
247}
248
249static void setclk(int v)
250{
251 gpio_set_value(s3c24xx_uda134x_l3_pins->l3_clk, v > 0);
252}
253
254static void setmode(int v)
255{
256 gpio_set_value(s3c24xx_uda134x_l3_pins->l3_mode, v > 0);
257}
258
259static struct uda134x_platform_data s3c24xx_uda134x = {
260 .l3 = {
261 .setdat = setdat,
262 .setclk = setclk,
263 .setmode = setmode,
264 .data_hold = 1,
265 .data_setup = 1,
266 .clock_high = 1,
267 .mode_hold = 1,
268 .mode = 1,
269 .mode_setup = 1,
270 },
271};
272
273static struct snd_soc_device s3c24xx_uda134x_snd_devdata = {
274 .card = &snd_soc_s3c24xx_uda134x,
275 .codec_dev = &soc_codec_dev_uda134x,
276 .codec_data = &s3c24xx_uda134x,
277};
278
279static int s3c24xx_uda134x_setup_pin(int pin, char *fun)
280{
281 if (gpio_request(pin, "s3c24xx_uda134x") < 0) {
282 printk(KERN_ERR "S3C24XX_UDA134X SoC Audio: "
283 "l3 %s pin already in use", fun);
284 return -EBUSY;
285 }
286 gpio_direction_output(pin, 0);
287 return 0;
288}
289
290static int s3c24xx_uda134x_probe(struct platform_device *pdev)
291{
292 int ret;
293
294 printk(KERN_INFO "S3C24XX_UDA134X SoC Audio driver\n");
295
296 s3c24xx_uda134x_l3_pins = pdev->dev.platform_data;
297 if (s3c24xx_uda134x_l3_pins == NULL) {
298 printk(KERN_ERR "S3C24XX_UDA134X SoC Audio: "
299 "unable to find platform data\n");
300 return -ENODEV;
301 }
302 s3c24xx_uda134x.power = s3c24xx_uda134x_l3_pins->power;
303 s3c24xx_uda134x.model = s3c24xx_uda134x_l3_pins->model;
304
305 if (s3c24xx_uda134x_setup_pin(s3c24xx_uda134x_l3_pins->l3_data,
306 "data") < 0)
307 return -EBUSY;
308 if (s3c24xx_uda134x_setup_pin(s3c24xx_uda134x_l3_pins->l3_clk,
309 "clk") < 0) {
310 gpio_free(s3c24xx_uda134x_l3_pins->l3_data);
311 return -EBUSY;
312 }
313 if (s3c24xx_uda134x_setup_pin(s3c24xx_uda134x_l3_pins->l3_mode,
314 "mode") < 0) {
315 gpio_free(s3c24xx_uda134x_l3_pins->l3_data);
316 gpio_free(s3c24xx_uda134x_l3_pins->l3_clk);
317 return -EBUSY;
318 }
319
320 s3c24xx_uda134x_snd_device = platform_device_alloc("soc-audio", -1);
321 if (!s3c24xx_uda134x_snd_device) {
322 printk(KERN_ERR "S3C24XX_UDA134X SoC Audio: "
323 "Unable to register\n");
324 return -ENOMEM;
325 }
326
327 platform_set_drvdata(s3c24xx_uda134x_snd_device,
328 &s3c24xx_uda134x_snd_devdata);
329 s3c24xx_uda134x_snd_devdata.dev = &s3c24xx_uda134x_snd_device->dev;
330 ret = platform_device_add(s3c24xx_uda134x_snd_device);
331 if (ret) {
332 printk(KERN_ERR "S3C24XX_UDA134X SoC Audio: Unable to add\n");
333 platform_device_put(s3c24xx_uda134x_snd_device);
334 }
335
336 return ret;
337}
338
339static int s3c24xx_uda134x_remove(struct platform_device *pdev)
340{
341 platform_device_unregister(s3c24xx_uda134x_snd_device);
342 gpio_free(s3c24xx_uda134x_l3_pins->l3_data);
343 gpio_free(s3c24xx_uda134x_l3_pins->l3_clk);
344 gpio_free(s3c24xx_uda134x_l3_pins->l3_mode);
345 return 0;
346}
347
348static struct platform_driver s3c24xx_uda134x_driver = {
349 .probe = s3c24xx_uda134x_probe,
350 .remove = s3c24xx_uda134x_remove,
351 .driver = {
352 .name = "s3c24xx_uda134x",
353 .owner = THIS_MODULE,
354 },
355};
356
357static int __init s3c24xx_uda134x_init(void)
358{
359 return platform_driver_register(&s3c24xx_uda134x_driver);
360}
361
362static void __exit s3c24xx_uda134x_exit(void)
363{
364 platform_driver_unregister(&s3c24xx_uda134x_driver);
365}
366
367
368module_init(s3c24xx_uda134x_init);
369module_exit(s3c24xx_uda134x_exit);
370
371MODULE_AUTHOR("Zoltan Devai, Christian Pellegrin <chripell@evolware.org>");
372MODULE_DESCRIPTION("S3C24XX_UDA134X ALSA SoC audio driver");
373MODULE_LICENSE("GPL");
diff --git a/sound/soc/s3c24xx/s3c64xx-i2s-v4.c b/sound/soc/s3c24xx/s3c64xx-i2s-v4.c
deleted file mode 100644
index 06db130030a1..000000000000
--- a/sound/soc/s3c24xx/s3c64xx-i2s-v4.c
+++ /dev/null
@@ -1,209 +0,0 @@
1/* sound/soc/s3c24xx/s3c64xx-i2s-v4.c
2 *
3 * ALSA SoC Audio Layer - S3C64XX I2Sv4 driver
4 * Copyright (c) 2010 Samsung Electronics Co. Ltd
5 * Author: Jaswinder Singh <jassi.brar@samsung.com>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11
12#include <linux/clk.h>
13#include <linux/gpio.h>
14#include <linux/io.h>
15
16#include <sound/soc.h>
17#include <sound/pcm_params.h>
18
19#include <mach/gpio-bank-c.h>
20#include <mach/gpio-bank-h.h>
21#include <plat/gpio-cfg.h>
22
23#include <mach/map.h>
24#include <mach/dma.h>
25
26#include "s3c-dma.h"
27#include "regs-i2s-v2.h"
28#include "s3c64xx-i2s.h"
29
30static struct s3c2410_dma_client s3c64xx_dma_client_out = {
31 .name = "I2Sv4 PCM Stereo out"
32};
33
34static struct s3c2410_dma_client s3c64xx_dma_client_in = {
35 .name = "I2Sv4 PCM Stereo in"
36};
37
38static struct s3c_dma_params s3c64xx_i2sv4_pcm_stereo_out;
39static struct s3c_dma_params s3c64xx_i2sv4_pcm_stereo_in;
40static struct s3c_i2sv2_info s3c64xx_i2sv4;
41
42struct snd_soc_dai s3c64xx_i2s_v4_dai;
43EXPORT_SYMBOL_GPL(s3c64xx_i2s_v4_dai);
44
45static inline struct s3c_i2sv2_info *to_info(struct snd_soc_dai *cpu_dai)
46{
47 return cpu_dai->private_data;
48}
49
50static int s3c64xx_i2sv4_probe(struct platform_device *pdev,
51 struct snd_soc_dai *dai)
52{
53 /* configure GPIO for i2s port */
54 s3c_gpio_cfgpin(S3C64XX_GPC(4), S3C64XX_GPC4_I2S_V40_DO0);
55 s3c_gpio_cfgpin(S3C64XX_GPC(5), S3C64XX_GPC5_I2S_V40_DO1);
56 s3c_gpio_cfgpin(S3C64XX_GPC(7), S3C64XX_GPC7_I2S_V40_DO2);
57 s3c_gpio_cfgpin(S3C64XX_GPH(6), S3C64XX_GPH6_I2S_V40_BCLK);
58 s3c_gpio_cfgpin(S3C64XX_GPH(7), S3C64XX_GPH7_I2S_V40_CDCLK);
59 s3c_gpio_cfgpin(S3C64XX_GPH(8), S3C64XX_GPH8_I2S_V40_LRCLK);
60 s3c_gpio_cfgpin(S3C64XX_GPH(9), S3C64XX_GPH9_I2S_V40_DI);
61
62 return 0;
63}
64
65static int s3c_i2sv4_hw_params(struct snd_pcm_substream *substream,
66 struct snd_pcm_hw_params *params,
67 struct snd_soc_dai *cpu_dai)
68{
69 struct s3c_i2sv2_info *i2s = to_info(cpu_dai);
70 struct s3c_dma_params *dma_data;
71 u32 iismod;
72
73 dev_dbg(cpu_dai->dev, "Entered %s\n", __func__);
74
75 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
76 dma_data = i2s->dma_playback;
77 else
78 dma_data = i2s->dma_capture;
79
80 snd_soc_dai_set_dma_data(cpu_dai, substream, dma_data);
81
82 iismod = readl(i2s->regs + S3C2412_IISMOD);
83 dev_dbg(cpu_dai->dev, "%s: r: IISMOD: %x\n", __func__, iismod);
84
85 iismod &= ~S3C64XX_IISMOD_BLC_MASK;
86 switch (params_format(params)) {
87 case SNDRV_PCM_FORMAT_S8:
88 iismod |= S3C64XX_IISMOD_BLC_8BIT;
89 break;
90 case SNDRV_PCM_FORMAT_S16_LE:
91 break;
92 case SNDRV_PCM_FORMAT_S24_LE:
93 iismod |= S3C64XX_IISMOD_BLC_24BIT;
94 break;
95 }
96
97 writel(iismod, i2s->regs + S3C2412_IISMOD);
98 dev_dbg(cpu_dai->dev, "%s: w: IISMOD: %x\n", __func__, iismod);
99
100 return 0;
101}
102
103static struct snd_soc_dai_ops s3c64xx_i2sv4_dai_ops = {
104 .hw_params = s3c_i2sv4_hw_params,
105};
106
107static __devinit int s3c64xx_i2sv4_dev_probe(struct platform_device *pdev)
108{
109 struct s3c_i2sv2_info *i2s;
110 struct snd_soc_dai *dai;
111 int ret;
112
113 i2s = &s3c64xx_i2sv4;
114 dai = &s3c64xx_i2s_v4_dai;
115
116 if (dai->dev) {
117 dev_dbg(dai->dev, "%s: \
118 I2Sv4 instance already registered!\n", __func__);
119 return -EBUSY;
120 }
121
122 dai->dev = &pdev->dev;
123 dai->name = "s3c64xx-i2s-v4";
124 dai->id = 0;
125 dai->symmetric_rates = 1;
126 dai->playback.channels_min = 2;
127 dai->playback.channels_max = 2;
128 dai->playback.rates = S3C64XX_I2S_RATES;
129 dai->playback.formats = S3C64XX_I2S_FMTS;
130 dai->capture.channels_min = 2;
131 dai->capture.channels_max = 2;
132 dai->capture.rates = S3C64XX_I2S_RATES;
133 dai->capture.formats = S3C64XX_I2S_FMTS;
134 dai->probe = s3c64xx_i2sv4_probe;
135 dai->ops = &s3c64xx_i2sv4_dai_ops;
136
137 i2s->feature |= S3C_FEATURE_CDCLKCON;
138
139 i2s->dma_capture = &s3c64xx_i2sv4_pcm_stereo_in;
140 i2s->dma_playback = &s3c64xx_i2sv4_pcm_stereo_out;
141
142 i2s->dma_capture->channel = DMACH_HSI_I2SV40_RX;
143 i2s->dma_capture->dma_addr = S3C64XX_PA_IISV4 + S3C2412_IISRXD;
144 i2s->dma_playback->channel = DMACH_HSI_I2SV40_TX;
145 i2s->dma_playback->dma_addr = S3C64XX_PA_IISV4 + S3C2412_IISTXD;
146
147 i2s->dma_capture->client = &s3c64xx_dma_client_in;
148 i2s->dma_capture->dma_size = 4;
149 i2s->dma_playback->client = &s3c64xx_dma_client_out;
150 i2s->dma_playback->dma_size = 4;
151
152 i2s->iis_cclk = clk_get(&pdev->dev, "audio-bus");
153 if (IS_ERR(i2s->iis_cclk)) {
154 dev_err(&pdev->dev, "failed to get audio-bus\n");
155 ret = PTR_ERR(i2s->iis_cclk);
156 goto err;
157 }
158
159 clk_enable(i2s->iis_cclk);
160
161 ret = s3c_i2sv2_probe(pdev, dai, i2s, 0);
162 if (ret)
163 goto err_clk;
164
165 ret = s3c_i2sv2_register_dai(dai);
166 if (ret != 0)
167 goto err_i2sv2;
168
169 return 0;
170
171err_i2sv2:
172 /* Not implemented for I2Sv2 core yet */
173err_clk:
174 clk_put(i2s->iis_cclk);
175err:
176 return ret;
177}
178
179static __devexit int s3c64xx_i2sv4_dev_remove(struct platform_device *pdev)
180{
181 dev_err(&pdev->dev, "Device removal not yet supported\n");
182 return 0;
183}
184
185static struct platform_driver s3c64xx_i2sv4_driver = {
186 .probe = s3c64xx_i2sv4_dev_probe,
187 .remove = s3c64xx_i2sv4_dev_remove,
188 .driver = {
189 .name = "s3c64xx-iis-v4",
190 .owner = THIS_MODULE,
191 },
192};
193
194static int __init s3c64xx_i2sv4_init(void)
195{
196 return platform_driver_register(&s3c64xx_i2sv4_driver);
197}
198module_init(s3c64xx_i2sv4_init);
199
200static void __exit s3c64xx_i2sv4_exit(void)
201{
202 platform_driver_unregister(&s3c64xx_i2sv4_driver);
203}
204module_exit(s3c64xx_i2sv4_exit);
205
206/* Module information */
207MODULE_AUTHOR("Jaswinder Singh, <jassi.brar@samsung.com>");
208MODULE_DESCRIPTION("S3C64XX I2Sv4 SoC Interface");
209MODULE_LICENSE("GPL");
diff --git a/sound/soc/s3c24xx/s3c64xx-i2s.c b/sound/soc/s3c24xx/s3c64xx-i2s.c
deleted file mode 100644
index 1d85cb85a7d2..000000000000
--- a/sound/soc/s3c24xx/s3c64xx-i2s.c
+++ /dev/null
@@ -1,190 +0,0 @@
1/* sound/soc/s3c24xx/s3c64xx-i2s.c
2 *
3 * ALSA SoC Audio Layer - S3C64XX I2S driver
4 *
5 * Copyright 2008 Openmoko, Inc.
6 * Copyright 2008 Simtec Electronics
7 * Ben Dooks <ben@simtec.co.uk>
8 * http://armlinux.simtec.co.uk/
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
13 */
14
15#include <linux/clk.h>
16#include <linux/gpio.h>
17#include <linux/io.h>
18
19#include <sound/soc.h>
20
21#include <mach/gpio-bank-d.h>
22#include <mach/gpio-bank-e.h>
23#include <plat/gpio-cfg.h>
24
25#include <mach/map.h>
26#include <mach/dma.h>
27
28#include "s3c-dma.h"
29#include "regs-i2s-v2.h"
30#include "s3c64xx-i2s.h"
31
32/* The value should be set to maximum of the total number
33 * of I2Sv3 controllers that any supported SoC has.
34 */
35#define MAX_I2SV3 2
36
37static struct s3c2410_dma_client s3c64xx_dma_client_out = {
38 .name = "I2S PCM Stereo out"
39};
40
41static struct s3c2410_dma_client s3c64xx_dma_client_in = {
42 .name = "I2S PCM Stereo in"
43};
44
45static struct s3c_dma_params s3c64xx_i2s_pcm_stereo_out[MAX_I2SV3];
46static struct s3c_dma_params s3c64xx_i2s_pcm_stereo_in[MAX_I2SV3];
47static struct s3c_i2sv2_info s3c64xx_i2s[MAX_I2SV3];
48
49struct snd_soc_dai s3c64xx_i2s_dai[MAX_I2SV3];
50EXPORT_SYMBOL_GPL(s3c64xx_i2s_dai);
51
52static inline struct s3c_i2sv2_info *to_info(struct snd_soc_dai *cpu_dai)
53{
54 return cpu_dai->private_data;
55}
56
57static int s3c64xx_i2s_probe(struct platform_device *pdev,
58 struct snd_soc_dai *dai)
59{
60 /* configure GPIO for i2s port */
61 switch (dai->id) {
62 case 0:
63 s3c_gpio_cfgpin(S3C64XX_GPD(0), S3C64XX_GPD0_I2S0_CLK);
64 s3c_gpio_cfgpin(S3C64XX_GPD(1), S3C64XX_GPD1_I2S0_CDCLK);
65 s3c_gpio_cfgpin(S3C64XX_GPD(2), S3C64XX_GPD2_I2S0_LRCLK);
66 s3c_gpio_cfgpin(S3C64XX_GPD(3), S3C64XX_GPD3_I2S0_DI);
67 s3c_gpio_cfgpin(S3C64XX_GPD(4), S3C64XX_GPD4_I2S0_D0);
68 break;
69 case 1:
70 s3c_gpio_cfgpin(S3C64XX_GPE(0), S3C64XX_GPE0_I2S1_CLK);
71 s3c_gpio_cfgpin(S3C64XX_GPE(1), S3C64XX_GPE1_I2S1_CDCLK);
72 s3c_gpio_cfgpin(S3C64XX_GPE(2), S3C64XX_GPE2_I2S1_LRCLK);
73 s3c_gpio_cfgpin(S3C64XX_GPE(3), S3C64XX_GPE3_I2S1_DI);
74 s3c_gpio_cfgpin(S3C64XX_GPE(4), S3C64XX_GPE4_I2S1_D0);
75 }
76
77 return 0;
78}
79
80
81static struct snd_soc_dai_ops s3c64xx_i2s_dai_ops;
82
83static __devinit int s3c64xx_iis_dev_probe(struct platform_device *pdev)
84{
85 struct s3c_i2sv2_info *i2s;
86 struct snd_soc_dai *dai;
87 int ret;
88
89 if (pdev->id >= MAX_I2SV3) {
90 dev_err(&pdev->dev, "id %d out of range\n", pdev->id);
91 return -EINVAL;
92 }
93
94 i2s = &s3c64xx_i2s[pdev->id];
95 dai = &s3c64xx_i2s_dai[pdev->id];
96 dai->dev = &pdev->dev;
97 dai->name = "s3c64xx-i2s";
98 dai->id = pdev->id;
99 dai->symmetric_rates = 1;
100 dai->playback.channels_min = 2;
101 dai->playback.channels_max = 2;
102 dai->playback.rates = S3C64XX_I2S_RATES;
103 dai->playback.formats = S3C64XX_I2S_FMTS;
104 dai->capture.channels_min = 2;
105 dai->capture.channels_max = 2;
106 dai->capture.rates = S3C64XX_I2S_RATES;
107 dai->capture.formats = S3C64XX_I2S_FMTS;
108 dai->probe = s3c64xx_i2s_probe;
109 dai->ops = &s3c64xx_i2s_dai_ops;
110
111 i2s->feature |= S3C_FEATURE_CDCLKCON;
112
113 i2s->dma_capture = &s3c64xx_i2s_pcm_stereo_in[pdev->id];
114 i2s->dma_playback = &s3c64xx_i2s_pcm_stereo_out[pdev->id];
115
116 if (pdev->id == 0) {
117 i2s->dma_capture->channel = DMACH_I2S0_IN;
118 i2s->dma_capture->dma_addr = S3C64XX_PA_IIS0 + S3C2412_IISRXD;
119 i2s->dma_playback->channel = DMACH_I2S0_OUT;
120 i2s->dma_playback->dma_addr = S3C64XX_PA_IIS0 + S3C2412_IISTXD;
121 } else {
122 i2s->dma_capture->channel = DMACH_I2S1_IN;
123 i2s->dma_capture->dma_addr = S3C64XX_PA_IIS1 + S3C2412_IISRXD;
124 i2s->dma_playback->channel = DMACH_I2S1_OUT;
125 i2s->dma_playback->dma_addr = S3C64XX_PA_IIS1 + S3C2412_IISTXD;
126 }
127
128 i2s->dma_capture->client = &s3c64xx_dma_client_in;
129 i2s->dma_capture->dma_size = 4;
130 i2s->dma_playback->client = &s3c64xx_dma_client_out;
131 i2s->dma_playback->dma_size = 4;
132
133 i2s->iis_cclk = clk_get(&pdev->dev, "audio-bus");
134 if (IS_ERR(i2s->iis_cclk)) {
135 dev_err(&pdev->dev, "failed to get audio-bus\n");
136 ret = PTR_ERR(i2s->iis_cclk);
137 goto err;
138 }
139
140 clk_enable(i2s->iis_cclk);
141
142 ret = s3c_i2sv2_probe(pdev, dai, i2s, 0);
143 if (ret)
144 goto err_clk;
145
146 ret = s3c_i2sv2_register_dai(dai);
147 if (ret != 0)
148 goto err_i2sv2;
149
150 return 0;
151
152err_i2sv2:
153 /* Not implemented for I2Sv2 core yet */
154err_clk:
155 clk_put(i2s->iis_cclk);
156err:
157 return ret;
158}
159
160static __devexit int s3c64xx_iis_dev_remove(struct platform_device *pdev)
161{
162 dev_err(&pdev->dev, "Device removal not yet supported\n");
163 return 0;
164}
165
166static struct platform_driver s3c64xx_iis_driver = {
167 .probe = s3c64xx_iis_dev_probe,
168 .remove = s3c64xx_iis_dev_remove,
169 .driver = {
170 .name = "s3c64xx-iis",
171 .owner = THIS_MODULE,
172 },
173};
174
175static int __init s3c64xx_i2s_init(void)
176{
177 return platform_driver_register(&s3c64xx_iis_driver);
178}
179module_init(s3c64xx_i2s_init);
180
181static void __exit s3c64xx_i2s_exit(void)
182{
183 platform_driver_unregister(&s3c64xx_iis_driver);
184}
185module_exit(s3c64xx_i2s_exit);
186
187/* Module information */
188MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>");
189MODULE_DESCRIPTION("S3C64XX I2S SoC Interface");
190MODULE_LICENSE("GPL");
diff --git a/sound/soc/s3c24xx/s3c64xx-i2s.h b/sound/soc/s3c24xx/s3c64xx-i2s.h
deleted file mode 100644
index 7a40f43d1d51..000000000000
--- a/sound/soc/s3c24xx/s3c64xx-i2s.h
+++ /dev/null
@@ -1,42 +0,0 @@
1/* sound/soc/s3c24xx/s3c64xx-i2s.h
2 *
3 * ALSA SoC Audio Layer - S3C64XX I2S driver
4 *
5 * Copyright 2008 Openmoko, Inc.
6 * Copyright 2008 Simtec Electronics
7 * Ben Dooks <ben@simtec.co.uk>
8 * http://armlinux.simtec.co.uk/
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
13 */
14
15#ifndef __SND_SOC_S3C24XX_S3C64XX_I2S_H
16#define __SND_SOC_S3C24XX_S3C64XX_I2S_H __FILE__
17
18struct clk;
19
20#include "s3c-i2s-v2.h"
21
22#define S3C64XX_DIV_BCLK S3C_I2SV2_DIV_BCLK
23#define S3C64XX_DIV_RCLK S3C_I2SV2_DIV_RCLK
24#define S3C64XX_DIV_PRESCALER S3C_I2SV2_DIV_PRESCALER
25
26#define S3C64XX_CLKSRC_PCLK S3C_I2SV2_CLKSRC_PCLK
27#define S3C64XX_CLKSRC_MUX S3C_I2SV2_CLKSRC_AUDIOBUS
28#define S3C64XX_CLKSRC_CDCLK S3C_I2SV2_CLKSRC_CDCLK
29
30#define S3C64XX_I2S_RATES \
31 (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 | SNDRV_PCM_RATE_16000 | \
32 SNDRV_PCM_RATE_22050 | SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | \
33 SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000)
34
35#define S3C64XX_I2S_FMTS \
36 (SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_LE |\
37 SNDRV_PCM_FMTBIT_S24_LE)
38
39extern struct snd_soc_dai s3c64xx_i2s_dai[];
40extern struct snd_soc_dai s3c64xx_i2s_v4_dai;
41
42#endif /* __SND_SOC_S3C24XX_S3C64XX_I2S_H */
diff --git a/sound/soc/s3c24xx/smartq_wm8987.c b/sound/soc/s3c24xx/smartq_wm8987.c
deleted file mode 100644
index b480348140b0..000000000000
--- a/sound/soc/s3c24xx/smartq_wm8987.c
+++ /dev/null
@@ -1,295 +0,0 @@
1/* sound/soc/s3c24xx/smartq_wm8987.c
2 *
3 * Copyright 2010 Maurus Cuelenaere <mcuelenaere@gmail.com>
4 *
5 * Based on smdk6410_wm8987.c
6 * Copyright 2007 Wolfson Microelectronics PLC. - linux@wolfsonmicro.com
7 * Graeme Gregory - graeme.gregory@wolfsonmicro.com
8 *
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the
11 * Free Software Foundation; either version 2 of the License, or (at your
12 * option) any later version.
13 *
14 */
15
16#include <linux/module.h>
17#include <linux/platform_device.h>
18#include <linux/gpio.h>
19
20#include <sound/pcm.h>
21#include <sound/pcm_params.h>
22#include <sound/soc-dapm.h>
23#include <sound/jack.h>
24
25#include <asm/mach-types.h>
26
27#include "s3c-dma.h"
28#include "s3c64xx-i2s.h"
29
30#include "../codecs/wm8750.h"
31
32/*
33 * WM8987 is register compatible with WM8750, so using that as base driver.
34 */
35
36static struct snd_soc_card snd_soc_smartq;
37
38static int smartq_hifi_hw_params(struct snd_pcm_substream *substream,
39 struct snd_pcm_hw_params *params)
40{
41 struct snd_soc_pcm_runtime *rtd = substream->private_data;
42 struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
43 struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
44 struct s3c_i2sv2_rate_calc div;
45 unsigned int clk = 0;
46 int ret;
47
48 s3c_i2sv2_iis_calc_rate(&div, NULL, params_rate(params),
49 s3c_i2sv2_get_clock(cpu_dai));
50
51 switch (params_rate(params)) {
52 case 8000:
53 case 16000:
54 case 32000:
55 case 48000:
56 case 96000:
57 clk = 12288000;
58 break;
59 case 11025:
60 case 22050:
61 case 44100:
62 case 88200:
63 clk = 11289600;
64 break;
65 }
66
67 /* set codec DAI configuration */
68 ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S |
69 SND_SOC_DAIFMT_NB_NF |
70 SND_SOC_DAIFMT_CBS_CFS);
71 if (ret < 0)
72 return ret;
73
74 /* set cpu DAI configuration */
75 ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S |
76 SND_SOC_DAIFMT_NB_NF |
77 SND_SOC_DAIFMT_CBS_CFS);
78 if (ret < 0)
79 return ret;
80
81 /* set the codec system clock for DAC and ADC */
82 ret = snd_soc_dai_set_sysclk(codec_dai, WM8750_SYSCLK, clk,
83 SND_SOC_CLOCK_IN);
84 if (ret < 0)
85 return ret;
86
87 /* set MCLK division for sample rate */
88 ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C_I2SV2_DIV_RCLK, div.fs_div);
89 if (ret < 0)
90 return ret;
91
92 /* set prescaler division for sample rate */
93 ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C_I2SV2_DIV_PRESCALER,
94 div.clk_div - 1);
95 if (ret < 0)
96 return ret;
97
98 return 0;
99}
100
101/*
102 * SmartQ WM8987 HiFi DAI operations.
103 */
104static struct snd_soc_ops smartq_hifi_ops = {
105 .hw_params = smartq_hifi_hw_params,
106};
107
108static struct snd_soc_jack smartq_jack;
109
110static struct snd_soc_jack_pin smartq_jack_pins[] = {
111 /* Disable speaker when headphone is plugged in */
112 {
113 .pin = "Internal Speaker",
114 .mask = SND_JACK_HEADPHONE,
115 },
116};
117
118static struct snd_soc_jack_gpio smartq_jack_gpios[] = {
119 {
120 .gpio = S3C64XX_GPL(12),
121 .name = "headphone detect",
122 .report = SND_JACK_HEADPHONE,
123 .debounce_time = 200,
124 },
125};
126
127static const struct snd_kcontrol_new wm8987_smartq_controls[] = {
128 SOC_DAPM_PIN_SWITCH("Internal Speaker"),
129 SOC_DAPM_PIN_SWITCH("Headphone Jack"),
130 SOC_DAPM_PIN_SWITCH("Internal Mic"),
131};
132
133static int smartq_speaker_event(struct snd_soc_dapm_widget *w,
134 struct snd_kcontrol *k,
135 int event)
136{
137 gpio_set_value(S3C64XX_GPK(12), SND_SOC_DAPM_EVENT_OFF(event));
138
139 return 0;
140}
141
142static const struct snd_soc_dapm_widget wm8987_dapm_widgets[] = {
143 SND_SOC_DAPM_SPK("Internal Speaker", smartq_speaker_event),
144 SND_SOC_DAPM_HP("Headphone Jack", NULL),
145 SND_SOC_DAPM_MIC("Internal Mic", NULL),
146};
147
148static const struct snd_soc_dapm_route audio_map[] = {
149 {"Headphone Jack", NULL, "LOUT2"},
150 {"Headphone Jack", NULL, "ROUT2"},
151
152 {"Internal Speaker", NULL, "LOUT2"},
153 {"Internal Speaker", NULL, "ROUT2"},
154
155 {"Mic Bias", NULL, "Internal Mic"},
156 {"LINPUT2", NULL, "Mic Bias"},
157};
158
159static int smartq_wm8987_init(struct snd_soc_codec *codec)
160{
161 int err = 0;
162
163 /* Add SmartQ specific widgets */
164 snd_soc_dapm_new_controls(codec, wm8987_dapm_widgets,
165 ARRAY_SIZE(wm8987_dapm_widgets));
166
167 /* add SmartQ specific controls */
168 err = snd_soc_add_controls(codec, wm8987_smartq_controls,
169 ARRAY_SIZE(wm8987_smartq_controls));
170
171 if (err < 0)
172 return err;
173
174 /* setup SmartQ specific audio path */
175 snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
176
177 /* set endpoints to not connected */
178 snd_soc_dapm_nc_pin(codec, "LINPUT1");
179 snd_soc_dapm_nc_pin(codec, "RINPUT1");
180 snd_soc_dapm_nc_pin(codec, "OUT3");
181 snd_soc_dapm_nc_pin(codec, "ROUT1");
182
183 /* set endpoints to default off mode */
184 snd_soc_dapm_enable_pin(codec, "Internal Speaker");
185 snd_soc_dapm_enable_pin(codec, "Internal Mic");
186 snd_soc_dapm_disable_pin(codec, "Headphone Jack");
187
188 err = snd_soc_dapm_sync(codec);
189 if (err)
190 return err;
191
192 /* Headphone jack detection */
193 err = snd_soc_jack_new(&snd_soc_smartq, "Headphone Jack",
194 SND_JACK_HEADPHONE, &smartq_jack);
195 if (err)
196 return err;
197
198 err = snd_soc_jack_add_pins(&smartq_jack, ARRAY_SIZE(smartq_jack_pins),
199 smartq_jack_pins);
200 if (err)
201 return err;
202
203 err = snd_soc_jack_add_gpios(&smartq_jack,
204 ARRAY_SIZE(smartq_jack_gpios),
205 smartq_jack_gpios);
206
207 return err;
208}
209
210static struct snd_soc_dai_link smartq_dai[] = {
211 {
212 .name = "wm8987",
213 .stream_name = "SmartQ Hi-Fi",
214 .cpu_dai = &s3c64xx_i2s_dai[0],
215 .codec_dai = &wm8750_dai,
216 .init = smartq_wm8987_init,
217 .ops = &smartq_hifi_ops,
218 },
219};
220
221static struct snd_soc_card snd_soc_smartq = {
222 .name = "SmartQ",
223 .platform = &s3c24xx_soc_platform,
224 .dai_link = smartq_dai,
225 .num_links = ARRAY_SIZE(smartq_dai),
226};
227
228static struct snd_soc_device smartq_snd_devdata = {
229 .card = &snd_soc_smartq,
230 .codec_dev = &soc_codec_dev_wm8750,
231};
232
233static struct platform_device *smartq_snd_device;
234
235static int __init smartq_init(void)
236{
237 int ret;
238
239 if (!machine_is_smartq7() && !machine_is_smartq5()) {
240 pr_info("Only SmartQ is supported by this ASoC driver\n");
241 return -ENODEV;
242 }
243
244 smartq_snd_device = platform_device_alloc("soc-audio", -1);
245 if (!smartq_snd_device)
246 return -ENOMEM;
247
248 platform_set_drvdata(smartq_snd_device, &smartq_snd_devdata);
249 smartq_snd_devdata.dev = &smartq_snd_device->dev;
250
251 ret = platform_device_add(smartq_snd_device);
252 if (ret) {
253 platform_device_put(smartq_snd_device);
254 return ret;
255 }
256
257 /* Initialise GPIOs used by amplifiers */
258 ret = gpio_request(S3C64XX_GPK(12), "amplifiers shutdown");
259 if (ret) {
260 dev_err(&smartq_snd_device->dev, "Failed to register GPK12\n");
261 goto err_unregister_device;
262 }
263
264 /* Disable amplifiers */
265 ret = gpio_direction_output(S3C64XX_GPK(12), 1);
266 if (ret) {
267 dev_err(&smartq_snd_device->dev, "Failed to configure GPK12\n");
268 goto err_free_gpio_amp_shut;
269 }
270
271 return 0;
272
273err_free_gpio_amp_shut:
274 gpio_free(S3C64XX_GPK(12));
275err_unregister_device:
276 platform_device_unregister(smartq_snd_device);
277
278 return ret;
279}
280
281static void __exit smartq_exit(void)
282{
283 snd_soc_jack_free_gpios(&smartq_jack, ARRAY_SIZE(smartq_jack_gpios),
284 smartq_jack_gpios);
285
286 platform_device_unregister(smartq_snd_device);
287}
288
289module_init(smartq_init);
290module_exit(smartq_exit);
291
292/* Module information */
293MODULE_AUTHOR("Maurus Cuelenaere <mcuelenaere@gmail.com>");
294MODULE_DESCRIPTION("ALSA SoC SmartQ WM8987");
295MODULE_LICENSE("GPL");
diff --git a/sound/soc/s3c24xx/smdk2443_wm9710.c b/sound/soc/s3c24xx/smdk2443_wm9710.c
deleted file mode 100644
index 362258835e8d..000000000000
--- a/sound/soc/s3c24xx/smdk2443_wm9710.c
+++ /dev/null
@@ -1,81 +0,0 @@
1/*
2 * smdk2443_wm9710.c -- SoC audio for smdk2443
3 *
4 * Copyright 2007 Wolfson Microelectronics PLC.
5 * Author: Graeme Gregory
6 * graeme.gregory@wolfsonmicro.com or linux@wolfsonmicro.com
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
12 *
13 */
14
15#include <linux/module.h>
16#include <linux/device.h>
17#include <sound/core.h>
18#include <sound/pcm.h>
19#include <sound/soc.h>
20#include <sound/soc-dapm.h>
21
22#include "../codecs/ac97.h"
23#include "s3c-dma.h"
24#include "s3c-ac97.h"
25
26static struct snd_soc_card smdk2443;
27
28static struct snd_soc_dai_link smdk2443_dai[] = {
29{
30 .name = "AC97",
31 .stream_name = "AC97 HiFi",
32 .cpu_dai = &s3c_ac97_dai[S3C_AC97_DAI_PCM],
33 .codec_dai = &ac97_dai,
34},
35};
36
37static struct snd_soc_card smdk2443 = {
38 .name = "SMDK2443",
39 .platform = &s3c24xx_soc_platform,
40 .dai_link = smdk2443_dai,
41 .num_links = ARRAY_SIZE(smdk2443_dai),
42};
43
44static struct snd_soc_device smdk2443_snd_ac97_devdata = {
45 .card = &smdk2443,
46 .codec_dev = &soc_codec_dev_ac97,
47};
48
49static struct platform_device *smdk2443_snd_ac97_device;
50
51static int __init smdk2443_init(void)
52{
53 int ret;
54
55 smdk2443_snd_ac97_device = platform_device_alloc("soc-audio", -1);
56 if (!smdk2443_snd_ac97_device)
57 return -ENOMEM;
58
59 platform_set_drvdata(smdk2443_snd_ac97_device,
60 &smdk2443_snd_ac97_devdata);
61 smdk2443_snd_ac97_devdata.dev = &smdk2443_snd_ac97_device->dev;
62 ret = platform_device_add(smdk2443_snd_ac97_device);
63
64 if (ret)
65 platform_device_put(smdk2443_snd_ac97_device);
66
67 return ret;
68}
69
70static void __exit smdk2443_exit(void)
71{
72 platform_device_unregister(smdk2443_snd_ac97_device);
73}
74
75module_init(smdk2443_init);
76module_exit(smdk2443_exit);
77
78/* Module information */
79MODULE_AUTHOR("Graeme Gregory, graeme.gregory@wolfsonmicro.com, www.wolfsonmicro.com");
80MODULE_DESCRIPTION("ALSA SoC WM9710 SMDK2443");
81MODULE_LICENSE("GPL");
diff --git a/sound/soc/s3c24xx/smdk64xx_wm8580.c b/sound/soc/s3c24xx/smdk64xx_wm8580.c
deleted file mode 100644
index 07e8e51d10d6..000000000000
--- a/sound/soc/s3c24xx/smdk64xx_wm8580.c
+++ /dev/null
@@ -1,266 +0,0 @@
1/*
2 * smdk64xx_wm8580.c
3 *
4 * Copyright (c) 2009 Samsung Electronics Co. Ltd
5 * Author: Jaswinder Singh <jassi.brar@samsung.com>
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2 of the License, or (at your
10 * option) any later version.
11 */
12
13#include <linux/platform_device.h>
14#include <linux/clk.h>
15#include <sound/core.h>
16#include <sound/pcm.h>
17#include <sound/pcm_params.h>
18#include <sound/soc.h>
19#include <sound/soc-dapm.h>
20
21#include "../codecs/wm8580.h"
22#include "s3c-dma.h"
23#include "s3c64xx-i2s.h"
24
25/* SMDK64XX has a 12MHZ crystal attached to WM8580 */
26#define SMDK64XX_WM8580_FREQ 12000000
27
28static int smdk64xx_hw_params(struct snd_pcm_substream *substream,
29 struct snd_pcm_hw_params *params)
30{
31 struct snd_soc_pcm_runtime *rtd = substream->private_data;
32 struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
33 struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
34 unsigned int pll_out;
35 int bfs, rfs, ret;
36
37 switch (params_format(params)) {
38 case SNDRV_PCM_FORMAT_U8:
39 case SNDRV_PCM_FORMAT_S8:
40 bfs = 16;
41 break;
42 case SNDRV_PCM_FORMAT_U16_LE:
43 case SNDRV_PCM_FORMAT_S16_LE:
44 bfs = 32;
45 break;
46 default:
47 return -EINVAL;
48 }
49
50 /* The Fvco for WM8580 PLLs must fall within [90,100]MHz.
51 * This criterion can't be met if we request PLL output
52 * as {8000x256, 64000x256, 11025x256}Hz.
53 * As a wayout, we rather change rfs to a minimum value that
54 * results in (params_rate(params) * rfs), and itself, acceptable
55 * to both - the CODEC and the CPU.
56 */
57 switch (params_rate(params)) {
58 case 16000:
59 case 22050:
60 case 32000:
61 case 44100:
62 case 48000:
63 case 88200:
64 case 96000:
65 rfs = 256;
66 break;
67 case 64000:
68 rfs = 384;
69 break;
70 case 8000:
71 case 11025:
72 rfs = 512;
73 break;
74 default:
75 return -EINVAL;
76 }
77 pll_out = params_rate(params) * rfs;
78
79 /* Set the Codec DAI configuration */
80 ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S
81 | SND_SOC_DAIFMT_NB_NF
82 | SND_SOC_DAIFMT_CBM_CFM);
83 if (ret < 0)
84 return ret;
85
86 /* Set the AP DAI configuration */
87 ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S
88 | SND_SOC_DAIFMT_NB_NF
89 | SND_SOC_DAIFMT_CBM_CFM);
90 if (ret < 0)
91 return ret;
92
93 ret = snd_soc_dai_set_sysclk(cpu_dai, S3C64XX_CLKSRC_CDCLK,
94 0, SND_SOC_CLOCK_IN);
95 if (ret < 0)
96 return ret;
97
98 /* We use PCLK for basic ops in SoC-Slave mode */
99 ret = snd_soc_dai_set_sysclk(cpu_dai, S3C64XX_CLKSRC_PCLK,
100 0, SND_SOC_CLOCK_IN);
101 if (ret < 0)
102 return ret;
103
104 /* Set WM8580 to drive MCLK from its PLLA */
105 ret = snd_soc_dai_set_clkdiv(codec_dai, WM8580_MCLK,
106 WM8580_CLKSRC_PLLA);
107 if (ret < 0)
108 return ret;
109
110 /* Explicitly set WM8580-DAC to source from MCLK */
111 ret = snd_soc_dai_set_clkdiv(codec_dai, WM8580_DAC_CLKSEL,
112 WM8580_CLKSRC_MCLK);
113 if (ret < 0)
114 return ret;
115
116 ret = snd_soc_dai_set_pll(codec_dai, WM8580_PLLA, 0,
117 SMDK64XX_WM8580_FREQ, pll_out);
118 if (ret < 0)
119 return ret;
120
121 ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C_I2SV2_DIV_BCLK, bfs);
122 if (ret < 0)
123 return ret;
124
125 ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C_I2SV2_DIV_RCLK, rfs);
126 if (ret < 0)
127 return ret;
128
129 return 0;
130}
131
132/*
133 * SMDK64XX WM8580 DAI operations.
134 */
135static struct snd_soc_ops smdk64xx_ops = {
136 .hw_params = smdk64xx_hw_params,
137};
138
139/* SMDK64xx Playback widgets */
140static const struct snd_soc_dapm_widget wm8580_dapm_widgets_pbk[] = {
141 SND_SOC_DAPM_HP("Front-L/R", NULL),
142 SND_SOC_DAPM_HP("Center/Sub", NULL),
143 SND_SOC_DAPM_HP("Rear-L/R", NULL),
144};
145
146/* SMDK64xx Capture widgets */
147static const struct snd_soc_dapm_widget wm8580_dapm_widgets_cpt[] = {
148 SND_SOC_DAPM_MIC("MicIn", NULL),
149 SND_SOC_DAPM_LINE("LineIn", NULL),
150};
151
152/* SMDK-PAIFTX connections */
153static const struct snd_soc_dapm_route audio_map_tx[] = {
154 /* MicIn feeds AINL */
155 {"AINL", NULL, "MicIn"},
156
157 /* LineIn feeds AINL/R */
158 {"AINL", NULL, "LineIn"},
159 {"AINR", NULL, "LineIn"},
160};
161
162/* SMDK-PAIFRX connections */
163static const struct snd_soc_dapm_route audio_map_rx[] = {
164 /* Front Left/Right are fed VOUT1L/R */
165 {"Front-L/R", NULL, "VOUT1L"},
166 {"Front-L/R", NULL, "VOUT1R"},
167
168 /* Center/Sub are fed VOUT2L/R */
169 {"Center/Sub", NULL, "VOUT2L"},
170 {"Center/Sub", NULL, "VOUT2R"},
171
172 /* Rear Left/Right are fed VOUT3L/R */
173 {"Rear-L/R", NULL, "VOUT3L"},
174 {"Rear-L/R", NULL, "VOUT3R"},
175};
176
177static int smdk64xx_wm8580_init_paiftx(struct snd_soc_codec *codec)
178{
179 /* Add smdk64xx specific Capture widgets */
180 snd_soc_dapm_new_controls(codec, wm8580_dapm_widgets_cpt,
181 ARRAY_SIZE(wm8580_dapm_widgets_cpt));
182
183 /* Set up PAIFTX audio path */
184 snd_soc_dapm_add_routes(codec, audio_map_tx, ARRAY_SIZE(audio_map_tx));
185
186 /* Enabling the microphone requires the fitting of a 0R
187 * resistor to connect the line from the microphone jack.
188 */
189 snd_soc_dapm_disable_pin(codec, "MicIn");
190
191 /* signal a DAPM event */
192 snd_soc_dapm_sync(codec);
193
194 return 0;
195}
196
197static int smdk64xx_wm8580_init_paifrx(struct snd_soc_codec *codec)
198{
199 /* Add smdk64xx specific Playback widgets */
200 snd_soc_dapm_new_controls(codec, wm8580_dapm_widgets_pbk,
201 ARRAY_SIZE(wm8580_dapm_widgets_pbk));
202
203 /* Set up PAIFRX audio path */
204 snd_soc_dapm_add_routes(codec, audio_map_rx, ARRAY_SIZE(audio_map_rx));
205
206 /* signal a DAPM event */
207 snd_soc_dapm_sync(codec);
208
209 return 0;
210}
211
212static struct snd_soc_dai_link smdk64xx_dai[] = {
213{ /* Primary Playback i/f */
214 .name = "WM8580 PAIF RX",
215 .stream_name = "Playback",
216 .cpu_dai = &s3c64xx_i2s_v4_dai,
217 .codec_dai = &wm8580_dai[WM8580_DAI_PAIFRX],
218 .init = smdk64xx_wm8580_init_paifrx,
219 .ops = &smdk64xx_ops,
220},
221{ /* Primary Capture i/f */
222 .name = "WM8580 PAIF TX",
223 .stream_name = "Capture",
224 .cpu_dai = &s3c64xx_i2s_v4_dai,
225 .codec_dai = &wm8580_dai[WM8580_DAI_PAIFTX],
226 .init = smdk64xx_wm8580_init_paiftx,
227 .ops = &smdk64xx_ops,
228},
229};
230
231static struct snd_soc_card smdk64xx = {
232 .name = "smdk64xx",
233 .platform = &s3c24xx_soc_platform,
234 .dai_link = smdk64xx_dai,
235 .num_links = ARRAY_SIZE(smdk64xx_dai),
236};
237
238static struct snd_soc_device smdk64xx_snd_devdata = {
239 .card = &smdk64xx,
240 .codec_dev = &soc_codec_dev_wm8580,
241};
242
243static struct platform_device *smdk64xx_snd_device;
244
245static int __init smdk64xx_audio_init(void)
246{
247 int ret;
248
249 smdk64xx_snd_device = platform_device_alloc("soc-audio", -1);
250 if (!smdk64xx_snd_device)
251 return -ENOMEM;
252
253 platform_set_drvdata(smdk64xx_snd_device, &smdk64xx_snd_devdata);
254 smdk64xx_snd_devdata.dev = &smdk64xx_snd_device->dev;
255 ret = platform_device_add(smdk64xx_snd_device);
256
257 if (ret)
258 platform_device_put(smdk64xx_snd_device);
259
260 return ret;
261}
262module_init(smdk64xx_audio_init);
263
264MODULE_AUTHOR("Jaswinder Singh, jassi.brar@samsung.com");
265MODULE_DESCRIPTION("ALSA SoC SMDK64XX WM8580");
266MODULE_LICENSE("GPL");
diff --git a/sound/soc/s3c24xx/smdk_wm9713.c b/sound/soc/s3c24xx/smdk_wm9713.c
deleted file mode 100644
index 5527b9e88c98..000000000000
--- a/sound/soc/s3c24xx/smdk_wm9713.c
+++ /dev/null
@@ -1,97 +0,0 @@
1/*
2 * smdk_wm9713.c -- SoC audio for SMDK
3 *
4 * Copyright 2010 Samsung Electronics Co. Ltd.
5 * Author: Jaswinder Singh Brar <jassi.brar@samsung.com>
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License as
9 * published by the Free Software Foundation; either version 2 of the
10 * License, or (at your option) any later version.
11 *
12 */
13
14#include <linux/module.h>
15#include <linux/device.h>
16#include <sound/soc.h>
17
18#include "../codecs/wm9713.h"
19#include "s3c-dma.h"
20#include "s3c-ac97.h"
21
22static struct snd_soc_card smdk;
23
24/*
25 * Default CFG switch settings to use this driver:
26 *
27 * SMDK6410: Set CFG1 1-3 On, CFG2 1-4 Off
28 * SMDKC100: Set CFG6 1-3 On, CFG7 1 On
29 * SMDKC110: Set CFGB10 1-2 Off, CFGB12 1-3 On
30 * SMDKV210: Set CFGB10 1-2 Off, CFGB12 1-3 On
31 */
32
33/*
34 Playback (HeadPhone):-
35 $ amixer sset 'Headphone' unmute
36 $ amixer sset 'Right Headphone Out Mux' 'Headphone'
37 $ amixer sset 'Left Headphone Out Mux' 'Headphone'
38 $ amixer sset 'Right HP Mixer PCM' unmute
39 $ amixer sset 'Left HP Mixer PCM' unmute
40
41 Capture (LineIn):-
42 $ amixer sset 'Right Capture Source' 'Line'
43 $ amixer sset 'Left Capture Source' 'Line'
44*/
45
46static struct snd_soc_dai_link smdk_dai = {
47 .name = "AC97",
48 .stream_name = "AC97 PCM",
49 .cpu_dai = &s3c_ac97_dai[S3C_AC97_DAI_PCM],
50 .codec_dai = &wm9713_dai[WM9713_DAI_AC97_HIFI],
51};
52
53static struct snd_soc_card smdk = {
54 .name = "SMDK",
55 .platform = &s3c24xx_soc_platform,
56 .dai_link = &smdk_dai,
57 .num_links = 1,
58};
59
60static struct snd_soc_device smdk_snd_ac97_devdata = {
61 .card = &smdk,
62 .codec_dev = &soc_codec_dev_wm9713,
63};
64
65static struct platform_device *smdk_snd_ac97_device;
66
67static int __init smdk_init(void)
68{
69 int ret;
70
71 smdk_snd_ac97_device = platform_device_alloc("soc-audio", -1);
72 if (!smdk_snd_ac97_device)
73 return -ENOMEM;
74
75 platform_set_drvdata(smdk_snd_ac97_device,
76 &smdk_snd_ac97_devdata);
77 smdk_snd_ac97_devdata.dev = &smdk_snd_ac97_device->dev;
78
79 ret = platform_device_add(smdk_snd_ac97_device);
80 if (ret)
81 platform_device_put(smdk_snd_ac97_device);
82
83 return ret;
84}
85
86static void __exit smdk_exit(void)
87{
88 platform_device_unregister(smdk_snd_ac97_device);
89}
90
91module_init(smdk_init);
92module_exit(smdk_exit);
93
94/* Module information */
95MODULE_AUTHOR("Jaswinder Singh Brar, jassi.brar@samsung.com");
96MODULE_DESCRIPTION("ALSA SoC SMDK+WM9713");
97MODULE_LICENSE("GPL");
generated by cgit v1.2.2 (git 2.25.0) at 2025-04-05 05:16:32 -0400