Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 1 | /* |
| 2 | * n810.c -- SoC audio for Nokia N810 |
| 3 | * |
| 4 | * Copyright (C) 2008 Nokia Corporation |
| 5 | * |
Jarkko Nikula | 7ec41ee | 2011-08-11 15:44:57 +0300 | [diff] [blame] | 6 | * Contact: Jarkko Nikula <jarkko.nikula@bitmer.com> |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 7 | * |
| 8 | * This program is free software; you can redistribute it and/or |
| 9 | * modify it under the terms of the GNU General Public License |
| 10 | * version 2 as published by the Free Software Foundation. |
| 11 | * |
| 12 | * This program is distributed in the hope that it will be useful, but |
| 13 | * WITHOUT ANY WARRANTY; without even the implied warranty of |
| 14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 15 | * General Public License for more details. |
| 16 | * |
| 17 | * You should have received a copy of the GNU General Public License |
| 18 | * along with this program; if not, write to the Free Software |
| 19 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA |
| 20 | * 02110-1301 USA |
| 21 | * |
| 22 | */ |
| 23 | |
| 24 | #include <linux/clk.h> |
Ben Dooks | aa6b904 | 2009-08-20 22:50:42 +0100 | [diff] [blame] | 25 | #include <linux/i2c.h> |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 26 | #include <linux/platform_device.h> |
| 27 | #include <sound/core.h> |
| 28 | #include <sound/pcm.h> |
| 29 | #include <sound/soc.h> |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 30 | |
| 31 | #include <asm/mach-types.h> |
Jarkko Nikula | f99a633 | 2008-05-15 11:01:36 +0200 | [diff] [blame] | 32 | #include <linux/gpio.h> |
Paul Gortmaker | da155d5 | 2011-07-15 12:38:28 -0400 | [diff] [blame] | 33 | #include <linux/module.h> |
Arnd Bergmann | 2203747 | 2012-08-24 15:21:06 +0200 | [diff] [blame] | 34 | #include <linux/platform_data/asoc-ti-mcbsp.h> |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 35 | |
| 36 | #include "omap-mcbsp.h" |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 37 | |
Jarkko Nikula | f99a633 | 2008-05-15 11:01:36 +0200 | [diff] [blame] | 38 | #define N810_HEADSET_AMP_GPIO 10 |
| 39 | #define N810_SPEAKER_AMP_GPIO 101 |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 40 | |
Jarkko Nikula | f8d5fc9 | 2009-03-18 16:46:54 +0200 | [diff] [blame] | 41 | enum { |
| 42 | N810_JACK_DISABLED, |
| 43 | N810_JACK_HP, |
| 44 | N810_JACK_HS, |
| 45 | N810_JACK_MIC, |
| 46 | }; |
| 47 | |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 48 | static struct clk *sys_clkout2; |
| 49 | static struct clk *sys_clkout2_src; |
| 50 | static struct clk *func96m_clk; |
| 51 | |
| 52 | static int n810_spk_func; |
| 53 | static int n810_jack_func; |
Jarkko Nikula | 90b9e47 | 2008-06-25 14:58:47 +0300 | [diff] [blame] | 54 | static int n810_dmic_func; |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 55 | |
Liam Girdwood | 022658b | 2012-02-03 17:43:09 +0000 | [diff] [blame] | 56 | static void n810_ext_control(struct snd_soc_dapm_context *dapm) |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 57 | { |
Jarkko Nikula | f8d5fc9 | 2009-03-18 16:46:54 +0200 | [diff] [blame] | 58 | int hp = 0, line1l = 0; |
| 59 | |
| 60 | switch (n810_jack_func) { |
| 61 | case N810_JACK_HS: |
| 62 | line1l = 1; |
| 63 | case N810_JACK_HP: |
| 64 | hp = 1; |
| 65 | break; |
| 66 | case N810_JACK_MIC: |
| 67 | line1l = 1; |
| 68 | break; |
| 69 | } |
| 70 | |
Charles Keepax | 43cbbc3 | 2014-02-18 15:22:23 +0000 | [diff] [blame] | 71 | snd_soc_dapm_mutex_lock(dapm); |
| 72 | |
Liam Girdwood | a530218 | 2008-07-07 13:35:17 +0100 | [diff] [blame] | 73 | if (n810_spk_func) |
Charles Keepax | 43cbbc3 | 2014-02-18 15:22:23 +0000 | [diff] [blame] | 74 | snd_soc_dapm_enable_pin_unlocked(dapm, "Ext Spk"); |
Liam Girdwood | a530218 | 2008-07-07 13:35:17 +0100 | [diff] [blame] | 75 | else |
Charles Keepax | 43cbbc3 | 2014-02-18 15:22:23 +0000 | [diff] [blame] | 76 | snd_soc_dapm_disable_pin_unlocked(dapm, "Ext Spk"); |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 77 | |
Jarkko Nikula | f8d5fc9 | 2009-03-18 16:46:54 +0200 | [diff] [blame] | 78 | if (hp) |
Charles Keepax | 43cbbc3 | 2014-02-18 15:22:23 +0000 | [diff] [blame] | 79 | snd_soc_dapm_enable_pin_unlocked(dapm, "Headphone Jack"); |
Liam Girdwood | a530218 | 2008-07-07 13:35:17 +0100 | [diff] [blame] | 80 | else |
Charles Keepax | 43cbbc3 | 2014-02-18 15:22:23 +0000 | [diff] [blame] | 81 | snd_soc_dapm_disable_pin_unlocked(dapm, "Headphone Jack"); |
Jarkko Nikula | f8d5fc9 | 2009-03-18 16:46:54 +0200 | [diff] [blame] | 82 | if (line1l) |
Charles Keepax | 43cbbc3 | 2014-02-18 15:22:23 +0000 | [diff] [blame] | 83 | snd_soc_dapm_enable_pin_unlocked(dapm, "LINE1L"); |
Jarkko Nikula | f8d5fc9 | 2009-03-18 16:46:54 +0200 | [diff] [blame] | 84 | else |
Charles Keepax | 43cbbc3 | 2014-02-18 15:22:23 +0000 | [diff] [blame] | 85 | snd_soc_dapm_disable_pin_unlocked(dapm, "LINE1L"); |
Liam Girdwood | a530218 | 2008-07-07 13:35:17 +0100 | [diff] [blame] | 86 | |
| 87 | if (n810_dmic_func) |
Charles Keepax | 43cbbc3 | 2014-02-18 15:22:23 +0000 | [diff] [blame] | 88 | snd_soc_dapm_enable_pin_unlocked(dapm, "DMic"); |
Liam Girdwood | a530218 | 2008-07-07 13:35:17 +0100 | [diff] [blame] | 89 | else |
Charles Keepax | 43cbbc3 | 2014-02-18 15:22:23 +0000 | [diff] [blame] | 90 | snd_soc_dapm_disable_pin_unlocked(dapm, "DMic"); |
Liam Girdwood | a530218 | 2008-07-07 13:35:17 +0100 | [diff] [blame] | 91 | |
Charles Keepax | 43cbbc3 | 2014-02-18 15:22:23 +0000 | [diff] [blame] | 92 | snd_soc_dapm_sync_unlocked(dapm); |
| 93 | |
| 94 | snd_soc_dapm_mutex_unlock(dapm); |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 95 | } |
| 96 | |
| 97 | static int n810_startup(struct snd_pcm_substream *substream) |
| 98 | { |
Jarkko Nikula | 0be4305 | 2008-11-25 12:45:08 +0200 | [diff] [blame] | 99 | struct snd_pcm_runtime *runtime = substream->runtime; |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 100 | struct snd_soc_pcm_runtime *rtd = substream->private_data; |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 101 | |
Lars-Peter Clausen | 8dfabe7 | 2015-10-18 15:39:26 +0200 | [diff] [blame] | 102 | snd_pcm_hw_constraint_single(runtime, SNDRV_PCM_HW_PARAM_CHANNELS, 2); |
Jarkko Nikula | 0be4305 | 2008-11-25 12:45:08 +0200 | [diff] [blame] | 103 | |
Lars-Peter Clausen | d4bdace | 2015-04-11 10:47:57 +0200 | [diff] [blame] | 104 | n810_ext_control(&rtd->card->dapm); |
Jarkko Nikula | fb28a75 | 2013-11-30 18:05:28 +0200 | [diff] [blame] | 105 | return clk_prepare_enable(sys_clkout2); |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 106 | } |
| 107 | |
| 108 | static void n810_shutdown(struct snd_pcm_substream *substream) |
| 109 | { |
Jarkko Nikula | fb28a75 | 2013-11-30 18:05:28 +0200 | [diff] [blame] | 110 | clk_disable_unprepare(sys_clkout2); |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 111 | } |
| 112 | |
| 113 | static int n810_hw_params(struct snd_pcm_substream *substream, |
| 114 | struct snd_pcm_hw_params *params) |
| 115 | { |
| 116 | struct snd_soc_pcm_runtime *rtd = substream->private_data; |
Liam Girdwood | f0fba2a | 2010-03-17 20:15:21 +0000 | [diff] [blame] | 117 | struct snd_soc_dai *codec_dai = rtd->codec_dai; |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 118 | int err; |
| 119 | |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 120 | /* Set the codec system clock for DAC and ADC */ |
Liam Girdwood | 64105cf | 2008-07-08 13:19:18 +0100 | [diff] [blame] | 121 | err = snd_soc_dai_set_sysclk(codec_dai, 0, 12000000, |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 122 | SND_SOC_CLOCK_IN); |
| 123 | |
| 124 | return err; |
| 125 | } |
| 126 | |
Bhumika Goyal | 2261cf1 | 2017-03-18 19:34:11 +0530 | [diff] [blame] | 127 | static const struct snd_soc_ops n810_ops = { |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 128 | .startup = n810_startup, |
| 129 | .hw_params = n810_hw_params, |
| 130 | .shutdown = n810_shutdown, |
| 131 | }; |
| 132 | |
| 133 | static int n810_get_spk(struct snd_kcontrol *kcontrol, |
| 134 | struct snd_ctl_elem_value *ucontrol) |
| 135 | { |
Takashi Iwai | dd90533 | 2016-02-29 17:26:21 +0100 | [diff] [blame] | 136 | ucontrol->value.enumerated.item[0] = n810_spk_func; |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 137 | |
| 138 | return 0; |
| 139 | } |
| 140 | |
| 141 | static int n810_set_spk(struct snd_kcontrol *kcontrol, |
| 142 | struct snd_ctl_elem_value *ucontrol) |
| 143 | { |
Liam Girdwood | 022658b | 2012-02-03 17:43:09 +0000 | [diff] [blame] | 144 | struct snd_soc_card *card = snd_kcontrol_chip(kcontrol); |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 145 | |
Takashi Iwai | dd90533 | 2016-02-29 17:26:21 +0100 | [diff] [blame] | 146 | if (n810_spk_func == ucontrol->value.enumerated.item[0]) |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 147 | return 0; |
| 148 | |
Takashi Iwai | dd90533 | 2016-02-29 17:26:21 +0100 | [diff] [blame] | 149 | n810_spk_func = ucontrol->value.enumerated.item[0]; |
Liam Girdwood | 022658b | 2012-02-03 17:43:09 +0000 | [diff] [blame] | 150 | n810_ext_control(&card->dapm); |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 151 | |
| 152 | return 1; |
| 153 | } |
| 154 | |
| 155 | static int n810_get_jack(struct snd_kcontrol *kcontrol, |
| 156 | struct snd_ctl_elem_value *ucontrol) |
| 157 | { |
Takashi Iwai | dd90533 | 2016-02-29 17:26:21 +0100 | [diff] [blame] | 158 | ucontrol->value.enumerated.item[0] = n810_jack_func; |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 159 | |
| 160 | return 0; |
| 161 | } |
| 162 | |
| 163 | static int n810_set_jack(struct snd_kcontrol *kcontrol, |
| 164 | struct snd_ctl_elem_value *ucontrol) |
| 165 | { |
Liam Girdwood | 022658b | 2012-02-03 17:43:09 +0000 | [diff] [blame] | 166 | struct snd_soc_card *card = snd_kcontrol_chip(kcontrol); |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 167 | |
Takashi Iwai | dd90533 | 2016-02-29 17:26:21 +0100 | [diff] [blame] | 168 | if (n810_jack_func == ucontrol->value.enumerated.item[0]) |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 169 | return 0; |
| 170 | |
Takashi Iwai | dd90533 | 2016-02-29 17:26:21 +0100 | [diff] [blame] | 171 | n810_jack_func = ucontrol->value.enumerated.item[0]; |
Liam Girdwood | 022658b | 2012-02-03 17:43:09 +0000 | [diff] [blame] | 172 | n810_ext_control(&card->dapm); |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 173 | |
| 174 | return 1; |
| 175 | } |
| 176 | |
Jarkko Nikula | 90b9e47 | 2008-06-25 14:58:47 +0300 | [diff] [blame] | 177 | static int n810_get_input(struct snd_kcontrol *kcontrol, |
| 178 | struct snd_ctl_elem_value *ucontrol) |
| 179 | { |
Takashi Iwai | dd90533 | 2016-02-29 17:26:21 +0100 | [diff] [blame] | 180 | ucontrol->value.enumerated.item[0] = n810_dmic_func; |
Jarkko Nikula | 90b9e47 | 2008-06-25 14:58:47 +0300 | [diff] [blame] | 181 | |
| 182 | return 0; |
| 183 | } |
| 184 | |
| 185 | static int n810_set_input(struct snd_kcontrol *kcontrol, |
| 186 | struct snd_ctl_elem_value *ucontrol) |
| 187 | { |
Liam Girdwood | 022658b | 2012-02-03 17:43:09 +0000 | [diff] [blame] | 188 | struct snd_soc_card *card = snd_kcontrol_chip(kcontrol); |
Jarkko Nikula | 90b9e47 | 2008-06-25 14:58:47 +0300 | [diff] [blame] | 189 | |
Takashi Iwai | dd90533 | 2016-02-29 17:26:21 +0100 | [diff] [blame] | 190 | if (n810_dmic_func == ucontrol->value.enumerated.item[0]) |
Jarkko Nikula | 90b9e47 | 2008-06-25 14:58:47 +0300 | [diff] [blame] | 191 | return 0; |
| 192 | |
Takashi Iwai | dd90533 | 2016-02-29 17:26:21 +0100 | [diff] [blame] | 193 | n810_dmic_func = ucontrol->value.enumerated.item[0]; |
Axel Lin | 625136e | 2012-02-10 14:54:37 +0800 | [diff] [blame] | 194 | n810_ext_control(&card->dapm); |
Jarkko Nikula | 90b9e47 | 2008-06-25 14:58:47 +0300 | [diff] [blame] | 195 | |
| 196 | return 1; |
| 197 | } |
| 198 | |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 199 | static int n810_spk_event(struct snd_soc_dapm_widget *w, |
| 200 | struct snd_kcontrol *k, int event) |
| 201 | { |
| 202 | if (SND_SOC_DAPM_EVENT_ON(event)) |
Jarkko Nikula | f99a633 | 2008-05-15 11:01:36 +0200 | [diff] [blame] | 203 | gpio_set_value(N810_SPEAKER_AMP_GPIO, 1); |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 204 | else |
Jarkko Nikula | f99a633 | 2008-05-15 11:01:36 +0200 | [diff] [blame] | 205 | gpio_set_value(N810_SPEAKER_AMP_GPIO, 0); |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 206 | |
| 207 | return 0; |
| 208 | } |
| 209 | |
| 210 | static int n810_jack_event(struct snd_soc_dapm_widget *w, |
| 211 | struct snd_kcontrol *k, int event) |
| 212 | { |
| 213 | if (SND_SOC_DAPM_EVENT_ON(event)) |
Jarkko Nikula | f99a633 | 2008-05-15 11:01:36 +0200 | [diff] [blame] | 214 | gpio_set_value(N810_HEADSET_AMP_GPIO, 1); |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 215 | else |
Jarkko Nikula | f99a633 | 2008-05-15 11:01:36 +0200 | [diff] [blame] | 216 | gpio_set_value(N810_HEADSET_AMP_GPIO, 0); |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 217 | |
| 218 | return 0; |
| 219 | } |
| 220 | |
| 221 | static const struct snd_soc_dapm_widget aic33_dapm_widgets[] = { |
| 222 | SND_SOC_DAPM_SPK("Ext Spk", n810_spk_event), |
| 223 | SND_SOC_DAPM_HP("Headphone Jack", n810_jack_event), |
Jarkko Nikula | 90b9e47 | 2008-06-25 14:58:47 +0300 | [diff] [blame] | 224 | SND_SOC_DAPM_MIC("DMic", NULL), |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 225 | }; |
| 226 | |
Mark Brown | 1a25059 | 2008-05-13 14:58:57 +0200 | [diff] [blame] | 227 | static const struct snd_soc_dapm_route audio_map[] = { |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 228 | {"Headphone Jack", NULL, "HPLOUT"}, |
| 229 | {"Headphone Jack", NULL, "HPROUT"}, |
| 230 | |
| 231 | {"Ext Spk", NULL, "LLOUT"}, |
| 232 | {"Ext Spk", NULL, "RLOUT"}, |
Jarkko Nikula | 90b9e47 | 2008-06-25 14:58:47 +0300 | [diff] [blame] | 233 | |
Hebbar Gururaja | e2e8bfd | 2013-01-31 18:23:04 +0530 | [diff] [blame] | 234 | {"DMic Rate 64", NULL, "Mic Bias"}, |
| 235 | {"Mic Bias", NULL, "DMic"}, |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 236 | }; |
| 237 | |
| 238 | static const char *spk_function[] = {"Off", "On"}; |
Jarkko Nikula | f8d5fc9 | 2009-03-18 16:46:54 +0200 | [diff] [blame] | 239 | static const char *jack_function[] = {"Off", "Headphone", "Headset", "Mic"}; |
Jarkko Nikula | 90b9e47 | 2008-06-25 14:58:47 +0300 | [diff] [blame] | 240 | static const char *input_function[] = {"ADC", "Digital Mic"}; |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 241 | static const struct soc_enum n810_enum[] = { |
Jarkko Nikula | 3c17279 | 2008-05-13 16:02:04 +0200 | [diff] [blame] | 242 | SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(spk_function), spk_function), |
| 243 | SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(jack_function), jack_function), |
Jarkko Nikula | 90b9e47 | 2008-06-25 14:58:47 +0300 | [diff] [blame] | 244 | SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(input_function), input_function), |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 245 | }; |
| 246 | |
| 247 | static const struct snd_kcontrol_new aic33_n810_controls[] = { |
| 248 | SOC_ENUM_EXT("Speaker Function", n810_enum[0], |
| 249 | n810_get_spk, n810_set_spk), |
| 250 | SOC_ENUM_EXT("Jack Function", n810_enum[1], |
| 251 | n810_get_jack, n810_set_jack), |
Jarkko Nikula | 90b9e47 | 2008-06-25 14:58:47 +0300 | [diff] [blame] | 252 | SOC_ENUM_EXT("Input Select", n810_enum[2], |
| 253 | n810_get_input, n810_set_input), |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 254 | }; |
| 255 | |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 256 | /* Digital audio interface glue - connects codec <--> CPU */ |
| 257 | static struct snd_soc_dai_link n810_dai = { |
| 258 | .name = "TLV320AIC33", |
| 259 | .stream_name = "AIC33", |
Peter Ujfalusi | 45656b4 | 2012-02-14 18:20:58 +0200 | [diff] [blame] | 260 | .cpu_dai_name = "omap-mcbsp.2", |
Peter Ujfalusi | 7f46b0b | 2014-04-16 15:46:25 +0300 | [diff] [blame] | 261 | .platform_name = "omap-mcbsp.2", |
Liam Girdwood | f0fba2a | 2010-03-17 20:15:21 +0000 | [diff] [blame] | 262 | .codec_name = "tlv320aic3x-codec.2-0018", |
| 263 | .codec_dai_name = "tlv320aic3x-hifi", |
Jarkko Nikula | cf9feff | 2011-09-30 16:07:45 +0300 | [diff] [blame] | 264 | .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF | |
| 265 | SND_SOC_DAIFMT_CBM_CFM, |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 266 | .ops = &n810_ops, |
| 267 | }; |
| 268 | |
| 269 | /* Audio machine driver */ |
Mark Brown | 8750654 | 2008-11-18 20:50:34 +0000 | [diff] [blame] | 270 | static struct snd_soc_card snd_soc_n810 = { |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 271 | .name = "N810", |
Axel Lin | b425b88 | 2011-12-22 11:08:59 +0800 | [diff] [blame] | 272 | .owner = THIS_MODULE, |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 273 | .dai_link = &n810_dai, |
| 274 | .num_links = 1, |
Peter Ujfalusi | 8966c2d | 2011-10-10 15:34:10 +0300 | [diff] [blame] | 275 | |
| 276 | .controls = aic33_n810_controls, |
| 277 | .num_controls = ARRAY_SIZE(aic33_n810_controls), |
| 278 | .dapm_widgets = aic33_dapm_widgets, |
| 279 | .num_dapm_widgets = ARRAY_SIZE(aic33_dapm_widgets), |
| 280 | .dapm_routes = audio_map, |
| 281 | .num_dapm_routes = ARRAY_SIZE(audio_map), |
Lars-Peter Clausen | 59c41d1 | 2015-04-11 10:47:58 +0200 | [diff] [blame] | 282 | .fully_routed = true, |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 283 | }; |
| 284 | |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 285 | static struct platform_device *n810_snd_device; |
| 286 | |
| 287 | static int __init n810_soc_init(void) |
| 288 | { |
| 289 | int err; |
| 290 | struct device *dev; |
| 291 | |
Aaro Koskinen | ea2787f | 2014-03-04 00:45:18 +0200 | [diff] [blame] | 292 | if (!of_have_populated_dt() || |
| 293 | (!of_machine_is_compatible("nokia,n810") && |
| 294 | !of_machine_is_compatible("nokia,n810-wimax"))) |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 295 | return -ENODEV; |
| 296 | |
| 297 | n810_snd_device = platform_device_alloc("soc-audio", -1); |
| 298 | if (!n810_snd_device) |
| 299 | return -ENOMEM; |
| 300 | |
Liam Girdwood | f0fba2a | 2010-03-17 20:15:21 +0000 | [diff] [blame] | 301 | platform_set_drvdata(n810_snd_device, &snd_soc_n810); |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 302 | err = platform_device_add(n810_snd_device); |
| 303 | if (err) |
| 304 | goto err1; |
| 305 | |
| 306 | dev = &n810_snd_device->dev; |
| 307 | |
| 308 | sys_clkout2_src = clk_get(dev, "sys_clkout2_src"); |
| 309 | if (IS_ERR(sys_clkout2_src)) { |
| 310 | dev_err(dev, "Could not get sys_clkout2_src clock\n"); |
Jarkko Nikula | e784539 | 2008-08-26 13:32:57 +0300 | [diff] [blame] | 311 | err = PTR_ERR(sys_clkout2_src); |
| 312 | goto err2; |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 313 | } |
| 314 | sys_clkout2 = clk_get(dev, "sys_clkout2"); |
| 315 | if (IS_ERR(sys_clkout2)) { |
| 316 | dev_err(dev, "Could not get sys_clkout2\n"); |
Jarkko Nikula | e784539 | 2008-08-26 13:32:57 +0300 | [diff] [blame] | 317 | err = PTR_ERR(sys_clkout2); |
| 318 | goto err3; |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 319 | } |
| 320 | /* |
| 321 | * Configure 12 MHz output on SYS_CLKOUT2. Therefore we must use |
| 322 | * 96 MHz as its parent in order to get 12 MHz |
| 323 | */ |
| 324 | func96m_clk = clk_get(dev, "func_96m_ck"); |
| 325 | if (IS_ERR(func96m_clk)) { |
| 326 | dev_err(dev, "Could not get func 96M clock\n"); |
Jarkko Nikula | e784539 | 2008-08-26 13:32:57 +0300 | [diff] [blame] | 327 | err = PTR_ERR(func96m_clk); |
| 328 | goto err4; |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 329 | } |
| 330 | clk_set_parent(sys_clkout2_src, func96m_clk); |
| 331 | clk_set_rate(sys_clkout2, 12000000); |
| 332 | |
Takashi Iwai | 96b61bc | 2013-11-05 18:40:02 +0100 | [diff] [blame] | 333 | if (WARN_ON((gpio_request(N810_HEADSET_AMP_GPIO, "hs_amp") < 0) || |
| 334 | (gpio_request(N810_SPEAKER_AMP_GPIO, "spk_amp") < 0))) { |
| 335 | err = -EINVAL; |
| 336 | goto err4; |
| 337 | } |
Alexander Beregalov | f4c1724 | 2009-04-12 05:04:43 +0400 | [diff] [blame] | 338 | |
Jarkko Nikula | f99a633 | 2008-05-15 11:01:36 +0200 | [diff] [blame] | 339 | gpio_direction_output(N810_HEADSET_AMP_GPIO, 0); |
| 340 | gpio_direction_output(N810_SPEAKER_AMP_GPIO, 0); |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 341 | |
| 342 | return 0; |
Jarkko Nikula | e784539 | 2008-08-26 13:32:57 +0300 | [diff] [blame] | 343 | err4: |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 344 | clk_put(sys_clkout2); |
Jarkko Nikula | e784539 | 2008-08-26 13:32:57 +0300 | [diff] [blame] | 345 | err3: |
| 346 | clk_put(sys_clkout2_src); |
| 347 | err2: |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 348 | platform_device_del(n810_snd_device); |
| 349 | err1: |
| 350 | platform_device_put(n810_snd_device); |
| 351 | |
| 352 | return err; |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 353 | } |
| 354 | |
| 355 | static void __exit n810_soc_exit(void) |
| 356 | { |
Jarkko Nikula | f99a633 | 2008-05-15 11:01:36 +0200 | [diff] [blame] | 357 | gpio_free(N810_SPEAKER_AMP_GPIO); |
| 358 | gpio_free(N810_HEADSET_AMP_GPIO); |
Jarkko Nikula | e784539 | 2008-08-26 13:32:57 +0300 | [diff] [blame] | 359 | clk_put(sys_clkout2_src); |
| 360 | clk_put(sys_clkout2); |
| 361 | clk_put(func96m_clk); |
Jarkko Nikula | f99a633 | 2008-05-15 11:01:36 +0200 | [diff] [blame] | 362 | |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 363 | platform_device_unregister(n810_snd_device); |
| 364 | } |
| 365 | |
| 366 | module_init(n810_soc_init); |
| 367 | module_exit(n810_soc_exit); |
| 368 | |
Jarkko Nikula | 7ec41ee | 2011-08-11 15:44:57 +0300 | [diff] [blame] | 369 | MODULE_AUTHOR("Jarkko Nikula <jarkko.nikula@bitmer.com>"); |
Jarkko Nikula | 2e74796 | 2008-04-25 13:55:19 +0200 | [diff] [blame] | 370 | MODULE_DESCRIPTION("ALSA SoC Nokia N810"); |
| 371 | MODULE_LICENSE("GPL"); |