Commit | Line | Data |
---|---|---|
55c72036 VK |
1 | /* |
2 | * mfld_machine.c - ASoc Machine driver for Intel Medfield MID platform | |
3 | * | |
4 | * Copyright (C) 2010 Intel Corp | |
5 | * Author: Vinod Koul <vinod.koul@intel.com> | |
6 | * Author: Harsha Priya <priya.harsha@intel.com> | |
7 | * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
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 as published by | |
11 | * the Free Software Foundation; version 2 of the License. | |
12 | * | |
13 | * This program is distributed in the hope that it will be useful, but | |
14 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
16 | * General Public License for more details. | |
17 | * | |
18 | * You should have received a copy of the GNU General Public License along | |
19 | * with this program; if not, write to the Free Software Foundation, Inc., | |
20 | * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. | |
21 | * | |
22 | * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | |
23 | */ | |
24 | ||
25 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt | |
26 | ||
27 | #include <linux/init.h> | |
28 | #include <linux/device.h> | |
29 | #include <linux/slab.h> | |
42aee9b4 | 30 | #include <linux/io.h> |
da155d5b | 31 | #include <linux/module.h> |
55c72036 VK |
32 | #include <sound/pcm.h> |
33 | #include <sound/pcm_params.h> | |
34 | #include <sound/soc.h> | |
42aee9b4 | 35 | #include <sound/jack.h> |
55c72036 VK |
36 | #include "../codecs/sn95031.h" |
37 | ||
38 | #define MID_MONO 1 | |
39 | #define MID_STEREO 2 | |
40 | #define MID_MAX_CAP 5 | |
42aee9b4 VK |
41 | #define MFLD_JACK_INSERT 0x04 |
42 | ||
43 | enum soc_mic_bias_zones { | |
44 | MFLD_MV_START = 0, | |
45 | /* mic bias volutage range for Headphones*/ | |
46 | MFLD_MV_HP = 400, | |
47 | /* mic bias volutage range for American Headset*/ | |
48 | MFLD_MV_AM_HS = 650, | |
49 | /* mic bias volutage range for Headset*/ | |
50 | MFLD_MV_HS = 2000, | |
51 | MFLD_MV_UNDEFINED, | |
52 | }; | |
55c72036 VK |
53 | |
54 | static unsigned int hs_switch; | |
55 | static unsigned int lo_dac; | |
43b95634 | 56 | static struct snd_soc_codec *mfld_codec; |
55c72036 | 57 | |
42aee9b4 | 58 | struct mfld_mc_private { |
42aee9b4 | 59 | void __iomem *int_base; |
42aee9b4 VK |
60 | u8 interrupt_status; |
61 | }; | |
62 | ||
63 | struct snd_soc_jack mfld_jack; | |
64 | ||
65 | /*Headset jack detection DAPM pins */ | |
66 | static struct snd_soc_jack_pin mfld_jack_pins[] = { | |
67 | { | |
68 | .pin = "Headphones", | |
69 | .mask = SND_JACK_HEADPHONE, | |
70 | }, | |
71 | { | |
72 | .pin = "AMIC1", | |
73 | .mask = SND_JACK_MICROPHONE, | |
74 | }, | |
75 | }; | |
76 | ||
7ae74340 VK |
77 | /* jack detection voltage zones */ |
78 | static struct snd_soc_jack_zone mfld_zones[] = { | |
79 | {MFLD_MV_START, MFLD_MV_AM_HS, SND_JACK_HEADPHONE}, | |
80 | {MFLD_MV_AM_HS, MFLD_MV_HS, SND_JACK_HEADSET}, | |
81 | }; | |
82 | ||
55c72036 VK |
83 | /* sound card controls */ |
84 | static const char *headset_switch_text[] = {"Earpiece", "Headset"}; | |
85 | ||
86 | static const char *lo_text[] = {"Vibra", "Headset", "IHF", "None"}; | |
87 | ||
88 | static const struct soc_enum headset_enum = | |
89 | SOC_ENUM_SINGLE_EXT(2, headset_switch_text); | |
90 | ||
91 | static const struct soc_enum lo_enum = | |
92 | SOC_ENUM_SINGLE_EXT(4, lo_text); | |
93 | ||
94 | static int headset_get_switch(struct snd_kcontrol *kcontrol, | |
95 | struct snd_ctl_elem_value *ucontrol) | |
96 | { | |
97 | ucontrol->value.integer.value[0] = hs_switch; | |
98 | return 0; | |
99 | } | |
100 | ||
101 | static int headset_set_switch(struct snd_kcontrol *kcontrol, | |
102 | struct snd_ctl_elem_value *ucontrol) | |
103 | { | |
43b95634 LPC |
104 | struct snd_soc_card *card = snd_kcontrol_chip(kcontrol); |
105 | struct snd_soc_dapm_context *dapm = &card->dapm; | |
55c72036 VK |
106 | |
107 | if (ucontrol->value.integer.value[0] == hs_switch) | |
108 | return 0; | |
109 | ||
121df681 CK |
110 | snd_soc_dapm_mutex_lock(dapm); |
111 | ||
55c72036 VK |
112 | if (ucontrol->value.integer.value[0]) { |
113 | pr_debug("hs_set HS path\n"); | |
121df681 CK |
114 | snd_soc_dapm_enable_pin_unlocked(dapm, "Headphones"); |
115 | snd_soc_dapm_disable_pin_unlocked(dapm, "EPOUT"); | |
55c72036 VK |
116 | } else { |
117 | pr_debug("hs_set EP path\n"); | |
121df681 CK |
118 | snd_soc_dapm_disable_pin_unlocked(dapm, "Headphones"); |
119 | snd_soc_dapm_enable_pin_unlocked(dapm, "EPOUT"); | |
55c72036 | 120 | } |
121df681 CK |
121 | |
122 | snd_soc_dapm_sync_unlocked(dapm); | |
123 | ||
124 | snd_soc_dapm_mutex_unlock(dapm); | |
125 | ||
55c72036 VK |
126 | hs_switch = ucontrol->value.integer.value[0]; |
127 | ||
128 | return 0; | |
129 | } | |
130 | ||
43b95634 | 131 | static void lo_enable_out_pins(struct snd_soc_dapm_context *dapm) |
55c72036 | 132 | { |
121df681 CK |
133 | snd_soc_dapm_enable_pin_unlocked(dapm, "IHFOUTL"); |
134 | snd_soc_dapm_enable_pin_unlocked(dapm, "IHFOUTR"); | |
135 | snd_soc_dapm_enable_pin_unlocked(dapm, "LINEOUTL"); | |
136 | snd_soc_dapm_enable_pin_unlocked(dapm, "LINEOUTR"); | |
137 | snd_soc_dapm_enable_pin_unlocked(dapm, "VIB1OUT"); | |
138 | snd_soc_dapm_enable_pin_unlocked(dapm, "VIB2OUT"); | |
55c72036 | 139 | if (hs_switch) { |
121df681 CK |
140 | snd_soc_dapm_enable_pin_unlocked(dapm, "Headphones"); |
141 | snd_soc_dapm_disable_pin_unlocked(dapm, "EPOUT"); | |
55c72036 | 142 | } else { |
121df681 CK |
143 | snd_soc_dapm_disable_pin_unlocked(dapm, "Headphones"); |
144 | snd_soc_dapm_enable_pin_unlocked(dapm, "EPOUT"); | |
55c72036 VK |
145 | } |
146 | } | |
147 | ||
148 | static int lo_get_switch(struct snd_kcontrol *kcontrol, | |
149 | struct snd_ctl_elem_value *ucontrol) | |
150 | { | |
151 | ucontrol->value.integer.value[0] = lo_dac; | |
152 | return 0; | |
153 | } | |
154 | ||
155 | static int lo_set_switch(struct snd_kcontrol *kcontrol, | |
156 | struct snd_ctl_elem_value *ucontrol) | |
157 | { | |
43b95634 LPC |
158 | struct snd_soc_card *card = snd_kcontrol_chip(kcontrol); |
159 | struct snd_soc_dapm_context *dapm = &card->dapm; | |
55c72036 VK |
160 | |
161 | if (ucontrol->value.integer.value[0] == lo_dac) | |
162 | return 0; | |
163 | ||
121df681 CK |
164 | snd_soc_dapm_mutex_lock(dapm); |
165 | ||
55c72036 VK |
166 | /* we dont want to work with last state of lineout so just enable all |
167 | * pins and then disable pins not required | |
168 | */ | |
43b95634 | 169 | lo_enable_out_pins(dapm); |
121df681 | 170 | |
55c72036 VK |
171 | switch (ucontrol->value.integer.value[0]) { |
172 | case 0: | |
173 | pr_debug("set vibra path\n"); | |
121df681 CK |
174 | snd_soc_dapm_disable_pin_unlocked(dapm, "VIB1OUT"); |
175 | snd_soc_dapm_disable_pin_unlocked(dapm, "VIB2OUT"); | |
43b95634 | 176 | snd_soc_update_bits(mfld_codec, SN95031_LOCTL, 0x66, 0); |
55c72036 VK |
177 | break; |
178 | ||
179 | case 1: | |
180 | pr_debug("set hs path\n"); | |
121df681 CK |
181 | snd_soc_dapm_disable_pin_unlocked(dapm, "Headphones"); |
182 | snd_soc_dapm_disable_pin_unlocked(dapm, "EPOUT"); | |
43b95634 | 183 | snd_soc_update_bits(mfld_codec, SN95031_LOCTL, 0x66, 0x22); |
55c72036 VK |
184 | break; |
185 | ||
186 | case 2: | |
187 | pr_debug("set spkr path\n"); | |
121df681 CK |
188 | snd_soc_dapm_disable_pin_unlocked(dapm, "IHFOUTL"); |
189 | snd_soc_dapm_disable_pin_unlocked(dapm, "IHFOUTR"); | |
43b95634 | 190 | snd_soc_update_bits(mfld_codec, SN95031_LOCTL, 0x66, 0x44); |
55c72036 VK |
191 | break; |
192 | ||
193 | case 3: | |
194 | pr_debug("set null path\n"); | |
121df681 CK |
195 | snd_soc_dapm_disable_pin_unlocked(dapm, "LINEOUTL"); |
196 | snd_soc_dapm_disable_pin_unlocked(dapm, "LINEOUTR"); | |
43b95634 | 197 | snd_soc_update_bits(mfld_codec, SN95031_LOCTL, 0x66, 0x66); |
55c72036 VK |
198 | break; |
199 | } | |
121df681 CK |
200 | |
201 | snd_soc_dapm_sync_unlocked(dapm); | |
202 | ||
203 | snd_soc_dapm_mutex_unlock(dapm); | |
204 | ||
55c72036 VK |
205 | lo_dac = ucontrol->value.integer.value[0]; |
206 | return 0; | |
207 | } | |
208 | ||
209 | static const struct snd_kcontrol_new mfld_snd_controls[] = { | |
210 | SOC_ENUM_EXT("Playback Switch", headset_enum, | |
211 | headset_get_switch, headset_set_switch), | |
212 | SOC_ENUM_EXT("Lineout Mux", lo_enum, | |
213 | lo_get_switch, lo_set_switch), | |
214 | }; | |
215 | ||
42aee9b4 VK |
216 | static const struct snd_soc_dapm_widget mfld_widgets[] = { |
217 | SND_SOC_DAPM_HP("Headphones", NULL), | |
218 | SND_SOC_DAPM_MIC("Mic", NULL), | |
219 | }; | |
220 | ||
221 | static const struct snd_soc_dapm_route mfld_map[] = { | |
222 | {"Headphones", NULL, "HPOUTR"}, | |
223 | {"Headphones", NULL, "HPOUTL"}, | |
224 | {"Mic", NULL, "AMIC1"}, | |
225 | }; | |
226 | ||
227 | static void mfld_jack_check(unsigned int intr_status) | |
228 | { | |
229 | struct mfld_jack_data jack_data; | |
230 | ||
231 | jack_data.mfld_jack = &mfld_jack; | |
232 | jack_data.intr_id = intr_status; | |
233 | ||
234 | sn95031_jack_detection(&jack_data); | |
235 | /* TODO: add american headset detection post gpiolib support */ | |
236 | } | |
237 | ||
55c72036 VK |
238 | static int mfld_init(struct snd_soc_pcm_runtime *runtime) |
239 | { | |
43b95634 | 240 | struct snd_soc_dapm_context *dapm = &runtime->card->dapm; |
55c72036 VK |
241 | int ret_val; |
242 | ||
43b95634 | 243 | mfld_codec = runtime->codec; |
42aee9b4 | 244 | |
55c72036 | 245 | /* default is earpiece pin, userspace sets it explcitly */ |
42aee9b4 | 246 | snd_soc_dapm_disable_pin(dapm, "Headphones"); |
55c72036 VK |
247 | /* default is lineout NC, userspace sets it explcitly */ |
248 | snd_soc_dapm_disable_pin(dapm, "LINEOUTL"); | |
249 | snd_soc_dapm_disable_pin(dapm, "LINEOUTR"); | |
250 | lo_dac = 3; | |
251 | hs_switch = 0; | |
d316553a HP |
252 | /* we dont use linein in this so set to NC */ |
253 | snd_soc_dapm_disable_pin(dapm, "LINEINL"); | |
254 | snd_soc_dapm_disable_pin(dapm, "LINEINR"); | |
42aee9b4 VK |
255 | |
256 | /* Headset and button jack detection */ | |
546d4dd3 | 257 | ret_val = snd_soc_jack_new(mfld_codec, "Intel(R) MID Audio Jack", |
42aee9b4 VK |
258 | SND_JACK_HEADSET | SND_JACK_BTN_0 | |
259 | SND_JACK_BTN_1, &mfld_jack); | |
260 | if (ret_val) { | |
261 | pr_err("jack creation failed\n"); | |
262 | return ret_val; | |
263 | } | |
264 | ||
265 | ret_val = snd_soc_jack_add_pins(&mfld_jack, | |
266 | ARRAY_SIZE(mfld_jack_pins), mfld_jack_pins); | |
267 | if (ret_val) { | |
268 | pr_err("adding jack pins failed\n"); | |
269 | return ret_val; | |
270 | } | |
7ae74340 VK |
271 | ret_val = snd_soc_jack_add_zones(&mfld_jack, |
272 | ARRAY_SIZE(mfld_zones), mfld_zones); | |
273 | if (ret_val) { | |
274 | pr_err("adding jack zones failed\n"); | |
275 | return ret_val; | |
276 | } | |
42aee9b4 VK |
277 | |
278 | /* we want to check if anything is inserted at boot, | |
279 | * so send a fake event to codec and it will read adc | |
280 | * to find if anything is there or not */ | |
281 | mfld_jack_check(MFLD_JACK_INSERT); | |
282 | return ret_val; | |
55c72036 VK |
283 | } |
284 | ||
00c65161 | 285 | static struct snd_soc_dai_link mfld_msic_dailink[] = { |
55c72036 VK |
286 | { |
287 | .name = "Medfield Headset", | |
288 | .stream_name = "Headset", | |
289 | .cpu_dai_name = "Headset-cpu-dai", | |
290 | .codec_dai_name = "SN95031 Headset", | |
291 | .codec_name = "sn95031", | |
292 | .platform_name = "sst-platform", | |
293 | .init = mfld_init, | |
294 | }, | |
295 | { | |
296 | .name = "Medfield Speaker", | |
297 | .stream_name = "Speaker", | |
298 | .cpu_dai_name = "Speaker-cpu-dai", | |
299 | .codec_dai_name = "SN95031 Speaker", | |
300 | .codec_name = "sn95031", | |
301 | .platform_name = "sst-platform", | |
302 | .init = NULL, | |
303 | }, | |
304 | { | |
305 | .name = "Medfield Vibra", | |
306 | .stream_name = "Vibra1", | |
307 | .cpu_dai_name = "Vibra1-cpu-dai", | |
308 | .codec_dai_name = "SN95031 Vibra1", | |
309 | .codec_name = "sn95031", | |
310 | .platform_name = "sst-platform", | |
311 | .init = NULL, | |
312 | }, | |
313 | { | |
314 | .name = "Medfield Haptics", | |
315 | .stream_name = "Vibra2", | |
316 | .cpu_dai_name = "Vibra2-cpu-dai", | |
317 | .codec_dai_name = "SN95031 Vibra2", | |
318 | .codec_name = "sn95031", | |
319 | .platform_name = "sst-platform", | |
c514a911 VK |
320 | .init = NULL, |
321 | }, | |
322 | { | |
323 | .name = "Medfield Compress", | |
324 | .stream_name = "Speaker", | |
325 | .cpu_dai_name = "Compress-cpu-dai", | |
326 | .codec_dai_name = "SN95031 Speaker", | |
327 | .codec_name = "sn95031", | |
328 | .platform_name = "sst-platform", | |
55c72036 VK |
329 | .init = NULL, |
330 | }, | |
331 | }; | |
332 | ||
333 | /* SoC card */ | |
334 | static struct snd_soc_card snd_soc_card_mfld = { | |
335 | .name = "medfield_audio", | |
8270ba0c | 336 | .owner = THIS_MODULE, |
55c72036 VK |
337 | .dai_link = mfld_msic_dailink, |
338 | .num_links = ARRAY_SIZE(mfld_msic_dailink), | |
43b95634 LPC |
339 | |
340 | .controls = mfld_snd_controls, | |
341 | .num_controls = ARRAY_SIZE(mfld_snd_controls), | |
342 | .dapm_widgets = mfld_widgets, | |
343 | .num_dapm_widgets = ARRAY_SIZE(mfld_widgets), | |
344 | .dapm_routes = mfld_map, | |
345 | .num_dapm_routes = ARRAY_SIZE(mfld_map), | |
55c72036 VK |
346 | }; |
347 | ||
42aee9b4 VK |
348 | static irqreturn_t snd_mfld_jack_intr_handler(int irq, void *dev) |
349 | { | |
350 | struct mfld_mc_private *mc_private = (struct mfld_mc_private *) dev; | |
351 | ||
352 | memcpy_fromio(&mc_private->interrupt_status, | |
353 | ((void *)(mc_private->int_base)), | |
354 | sizeof(u8)); | |
355 | return IRQ_WAKE_THREAD; | |
356 | } | |
357 | ||
358 | static irqreturn_t snd_mfld_jack_detection(int irq, void *data) | |
359 | { | |
360 | struct mfld_mc_private *mc_drv_ctx = (struct mfld_mc_private *) data; | |
361 | ||
362 | if (mfld_jack.codec == NULL) | |
363 | return IRQ_HANDLED; | |
364 | mfld_jack_check(mc_drv_ctx->interrupt_status); | |
365 | ||
366 | return IRQ_HANDLED; | |
367 | } | |
368 | ||
7759f2ea | 369 | static int snd_mfld_mc_probe(struct platform_device *pdev) |
55c72036 | 370 | { |
42aee9b4 VK |
371 | int ret_val = 0, irq; |
372 | struct mfld_mc_private *mc_drv_ctx; | |
373 | struct resource *irq_mem; | |
55c72036 VK |
374 | |
375 | pr_debug("snd_mfld_mc_probe called\n"); | |
376 | ||
42aee9b4 VK |
377 | /* retrive the irq number */ |
378 | irq = platform_get_irq(pdev, 0); | |
379 | ||
380 | /* audio interrupt base of SRAM location where | |
381 | * interrupts are stored by System FW */ | |
de693006 | 382 | mc_drv_ctx = devm_kzalloc(&pdev->dev, sizeof(*mc_drv_ctx), GFP_ATOMIC); |
42aee9b4 VK |
383 | if (!mc_drv_ctx) { |
384 | pr_err("allocation failed\n"); | |
55c72036 VK |
385 | return -ENOMEM; |
386 | } | |
42aee9b4 VK |
387 | |
388 | irq_mem = platform_get_resource_byname( | |
389 | pdev, IORESOURCE_MEM, "IRQ_BASE"); | |
390 | if (!irq_mem) { | |
391 | pr_err("no mem resource given\n"); | |
de693006 | 392 | return -ENODEV; |
42aee9b4 | 393 | } |
de693006 WY |
394 | mc_drv_ctx->int_base = devm_ioremap_nocache(&pdev->dev, irq_mem->start, |
395 | resource_size(irq_mem)); | |
42aee9b4 VK |
396 | if (!mc_drv_ctx->int_base) { |
397 | pr_err("Mapping of cache failed\n"); | |
de693006 | 398 | return -ENOMEM; |
42aee9b4 VK |
399 | } |
400 | /* register for interrupt */ | |
de693006 WY |
401 | ret_val = devm_request_threaded_irq(&pdev->dev, irq, |
402 | snd_mfld_jack_intr_handler, | |
42aee9b4 VK |
403 | snd_mfld_jack_detection, |
404 | IRQF_SHARED, pdev->dev.driver->name, mc_drv_ctx); | |
405 | if (ret_val) { | |
406 | pr_err("cannot register IRQ\n"); | |
de693006 | 407 | return ret_val; |
42aee9b4 | 408 | } |
d58198b9 VK |
409 | /* register the soc card */ |
410 | snd_soc_card_mfld.dev = &pdev->dev; | |
33c89c30 | 411 | ret_val = devm_snd_soc_register_card(&pdev->dev, &snd_soc_card_mfld); |
55c72036 | 412 | if (ret_val) { |
d58198b9 | 413 | pr_debug("snd_soc_register_card failed %d\n", ret_val); |
de693006 | 414 | return ret_val; |
55c72036 | 415 | } |
42aee9b4 | 416 | platform_set_drvdata(pdev, mc_drv_ctx); |
55c72036 | 417 | pr_debug("successfully exited probe\n"); |
de693006 | 418 | return 0; |
55c72036 VK |
419 | } |
420 | ||
55c72036 VK |
421 | static struct platform_driver snd_mfld_mc_driver = { |
422 | .driver = { | |
423 | .owner = THIS_MODULE, | |
424 | .name = "msic_audio", | |
425 | }, | |
426 | .probe = snd_mfld_mc_probe, | |
55c72036 VK |
427 | }; |
428 | ||
29515d62 | 429 | module_platform_driver(snd_mfld_mc_driver); |
55c72036 VK |
430 | |
431 | MODULE_DESCRIPTION("ASoC Intel(R) MID Machine driver"); | |
432 | MODULE_AUTHOR("Vinod Koul <vinod.koul@intel.com>"); | |
433 | MODULE_AUTHOR("Harsha Priya <priya.harsha@intel.com>"); | |
434 | MODULE_LICENSE("GPL v2"); | |
435 | MODULE_ALIAS("platform:msic-audio"); |