summaryrefslogtreecommitdiffstats
path: root/kernel/sound/soc/au1x/db1200.c
blob: 5c73061d912ad55a2cf51e75f9779bad900f9f33 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
/*
 * DB1200/DB1300/DB1550 ASoC audio fabric support code.
 *
 * (c) 2008-2011 Manuel Lauss <manuel.lauss@googlemail.com>
 *
 */

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/timer.h>
#include <linux/interrupt.h>
#include <linux/platform_device.h>
#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/soc.h>
#include <asm/mach-au1x00/au1000.h>
#include <asm/mach-au1x00/au1xxx_psc.h>
#include <asm/mach-au1x00/au1xxx_dbdma.h>
#include <asm/mach-db1x00/bcsr.h>

#include "../codecs/wm8731.h"
#include "psc.h"

static const struct platform_device_id db1200_pids[] = {
	{
		.name		= "db1200-ac97",
		.driver_data	= 0,
	}, {
		.name		= "db1200-i2s",
		.driver_data	= 1,
	}, {
		.name		= "db1300-ac97",
		.driver_data	= 2,
	}, {
		.name		= "db1300-i2s",
		.driver_data	= 3,
	}, {
		.name		= "db1550-ac97",
		.driver_data	= 4,
	}, {
		.name		= "db1550-i2s",
		.driver_data	= 5,
	},
	{},
};

/*-------------------------  AC97 PART  ---------------------------*/

static struct snd_soc_dai_link db1200_ac97_dai = {
	.name		= "AC97",
	.stream_name	= "AC97 HiFi",
	.codec_dai_name	= "ac97-hifi",
	.cpu_dai_name	= "au1xpsc_ac97.1",
	.platform_name	= "au1xpsc-pcm.1",
	.codec_name	= "ac97-codec.1",
};

static struct snd_soc_card db1200_ac97_machine = {
	.name		= "DB1200_AC97",
	.owner		= THIS_MODULE,
	.dai_link	= &db1200_ac97_dai,
	.num_links	= 1,
};

static struct snd_soc_dai_link db1300_ac97_dai = {
	.name		= "AC97",
	.stream_name	= "AC97 HiFi",
	.codec_dai_name	= "wm9712-hifi",
	.cpu_dai_name	= "au1xpsc_ac97.1",
	.platform_name	= "au1xpsc-pcm.1",
	.codec_name	= "wm9712-codec.1",
};

static struct snd_soc_card db1300_ac97_machine = {
	.name		= "DB1300_AC97",
	.owner		= THIS_MODULE,
	.dai_link	= &db1300_ac97_dai,
	.num_links	= 1,
};

static struct snd_soc_card db1550_ac97_machine = {
	.name		= "DB1550_AC97",
	.owner		= THIS_MODULE,
	.dai_link	= &db1200_ac97_dai,
	.num_links	= 1,
};

/*-------------------------  I2S PART  ---------------------------*/

static int db1200_i2s_startup(struct snd_pcm_substream *substream)
{
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	struct snd_soc_dai *codec_dai = rtd->codec_dai;

	/* WM8731 has its own 12MHz crystal */
	snd_soc_dai_set_sysclk(codec_dai, WM8731_SYSCLK_XTAL,
				12000000, SND_SOC_CLOCK_IN);

	return 0;
}

static struct snd_soc_ops db1200_i2s_wm8731_ops = {
	.startup	= db1200_i2s_startup,
};

static struct snd_soc_dai_link db1200_i2s_dai = {
	.name		= "WM8731",
	.stream_name	= "WM8731 PCM",
	.codec_dai_name	= "wm8731-hifi",
	.cpu_dai_name	= "au1xpsc_i2s.1",
	.platform_name	= "au1xpsc-pcm.1",
	.codec_name	= "wm8731.0-001b",
	.dai_fmt	= SND_SOC_DAIFMT_LEFT_J | SND_SOC_DAIFMT_NB_NF |
			  SND_SOC_DAIFMT_CBM_CFM,
	.ops		= &db1200_i2s_wm8731_ops,
};

static struct snd_soc_card db1200_i2s_machine = {
	.name		= "DB1200_I2S",
	.owner		= THIS_MODULE,
	.dai_link	= &db1200_i2s_dai,
	.num_links	= 1,
};

static struct snd_soc_dai_link db1300_i2s_dai = {
	.name		= "WM8731",
	.stream_name	= "WM8731 PCM",
	.codec_dai_name	= "wm8731-hifi",
	.cpu_dai_name	= "au1xpsc_i2s.2",
	.platform_name	= "au1xpsc-pcm.2",
	.codec_name	= "wm8731.0-001b",
	.dai_fmt	= SND_SOC_DAIFMT_LEFT_J | SND_SOC_DAIFMT_NB_NF |
			  SND_SOC_DAIFMT_CBM_CFM,
	.ops		= &db1200_i2s_wm8731_ops,
};

static struct snd_soc_card db1300_i2s_machine = {
	.name		= "DB1300_I2S",
	.owner		= THIS_MODULE,
	.dai_link	= &db1300_i2s_dai,
	.num_links	= 1,
};

static struct snd_soc_dai_link db1550_i2s_dai = {
	.name		= "WM8731",
	.stream_name	= "WM8731 PCM",
	.codec_dai_name	= "wm8731-hifi",
	.cpu_dai_name	= "au1xpsc_i2s.3",
	.platform_name	= "au1xpsc-pcm.3",
	.codec_name	= "wm8731.0-001b",
	.dai_fmt	= SND_SOC_DAIFMT_LEFT_J | SND_SOC_DAIFMT_NB_NF |
			  SND_SOC_DAIFMT_CBM_CFM,
	.ops		= &db1200_i2s_wm8731_ops,
};

static struct snd_soc_card db1550_i2s_machine = {
	.name		= "DB1550_I2S",
	.owner		= THIS_MODULE,
	.dai_link	= &db1550_i2s_dai,
	.num_links	= 1,
};

/*-------------------------  COMMON PART  ---------------------------*/

static struct snd_soc_card *db1200_cards[] = {
	&db1200_ac97_machine,
	&db1200_i2s_machine,
	&db1300_ac97_machine,
	&db1300_i2s_machine,
	&db1550_ac97_machine,
	&db1550_i2s_machine,
};

static int db1200_audio_probe(struct platform_device *pdev)
{
	const struct platform_device_id *pid = platform_get_device_id(pdev);
	struct snd_soc_card *card;

	card = db1200_cards[pid->driver_data];
	card->dev = &pdev->dev;
	return devm_snd_soc_register_card(&pdev->dev, card);
}

static struct platform_driver db1200_audio_driver = {
	.driver	= {
		.name	= "db1200-ac97",
		.pm	= &snd_soc_pm_ops,
	},
	.id_table	= db1200_pids,
	.probe		= db1200_audio_probe,
};

module_platform_driver(db1200_audio_driver);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("DB1200/DB1300/DB1550 ASoC audio support");
MODULE_AUTHOR("Manuel Lauss");
span class="p">: case SSM4567_REG_STATUS_1 ... SSM4567_REG_STATUS_2: case SSM4567_REG_SOFT_RESET: return true; default: return false; } } static const DECLARE_TLV_DB_MINMAX_MUTE(ssm4567_vol_tlv, -7125, 2400); static const struct snd_kcontrol_new ssm4567_snd_controls[] = { SOC_SINGLE_TLV("Master Playback Volume", SSM4567_REG_DAC_VOLUME, 0, 0xff, 1, ssm4567_vol_tlv), SOC_SINGLE("DAC Low Power Mode Switch", SSM4567_REG_DAC_CTRL, 4, 1, 0), SOC_SINGLE("DAC High Pass Filter Switch", SSM4567_REG_DAC_CTRL, 5, 1, 0), }; static const struct snd_kcontrol_new ssm4567_amplifier_boost_control = SOC_DAPM_SINGLE("Switch", SSM4567_REG_POWER_CTRL, 1, 1, 1); static const struct snd_soc_dapm_widget ssm4567_dapm_widgets[] = { SND_SOC_DAPM_DAC("DAC", "HiFi Playback", SSM4567_REG_POWER_CTRL, 2, 1), SND_SOC_DAPM_SWITCH("Amplifier Boost", SSM4567_REG_POWER_CTRL, 3, 1, &ssm4567_amplifier_boost_control), SND_SOC_DAPM_SIGGEN("Sense"), SND_SOC_DAPM_PGA("Current Sense", SSM4567_REG_POWER_CTRL, 4, 1, NULL, 0), SND_SOC_DAPM_PGA("Voltage Sense", SSM4567_REG_POWER_CTRL, 5, 1, NULL, 0), SND_SOC_DAPM_PGA("VBAT Sense", SSM4567_REG_POWER_CTRL, 6, 1, NULL, 0), SND_SOC_DAPM_OUTPUT("OUT"), }; static const struct snd_soc_dapm_route ssm4567_routes[] = { { "OUT", NULL, "Amplifier Boost" }, { "Amplifier Boost", "Switch", "DAC" }, { "OUT", NULL, "DAC" }, { "Current Sense", NULL, "Sense" }, { "Voltage Sense", NULL, "Sense" }, { "VBAT Sense", NULL, "Sense" }, { "Capture Sense", NULL, "Current Sense" }, { "Capture Sense", NULL, "Voltage Sense" }, { "Capture Sense", NULL, "VBAT Sense" }, }; static int ssm4567_hw_params(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) { struct snd_soc_codec *codec = dai->codec; struct ssm4567 *ssm4567 = snd_soc_codec_get_drvdata(codec); unsigned int rate = params_rate(params); unsigned int dacfs; if (rate >= 8000 && rate <= 12000) dacfs = SSM4567_DAC_FS_8000_12000; else if (rate >= 16000 && rate <= 24000) dacfs = SSM4567_DAC_FS_16000_24000; else if (rate >= 32000 && rate <= 48000) dacfs = SSM4567_DAC_FS_32000_48000; else if (rate >= 64000 && rate <= 96000) dacfs = SSM4567_DAC_FS_64000_96000; else if (rate >= 128000 && rate <= 192000) dacfs = SSM4567_DAC_FS_128000_192000; else return -EINVAL; return regmap_update_bits(ssm4567->regmap, SSM4567_REG_DAC_CTRL, SSM4567_DAC_FS_MASK, dacfs); } static int ssm4567_mute(struct snd_soc_dai *dai, int mute) { struct ssm4567 *ssm4567 = snd_soc_codec_get_drvdata(dai->codec); unsigned int val; val = mute ? SSM4567_DAC_MUTE : 0; return regmap_update_bits(ssm4567->regmap, SSM4567_REG_DAC_CTRL, SSM4567_DAC_MUTE, val); } static int ssm4567_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask, unsigned int rx_mask, int slots, int width) { struct ssm4567 *ssm4567 = snd_soc_dai_get_drvdata(dai); unsigned int blcks; int slot; int ret; if (tx_mask == 0) return -EINVAL; if (rx_mask && rx_mask != tx_mask) return -EINVAL; slot = __ffs(tx_mask); if (tx_mask != BIT(slot)) return -EINVAL; switch (width) { case 32: blcks = SSM4567_SAI_CTRL_1_TDM_BLCKS_32; break; case 48: blcks = SSM4567_SAI_CTRL_1_TDM_BLCKS_48; break; case 64: blcks = SSM4567_SAI_CTRL_1_TDM_BLCKS_64; break; default: return -EINVAL; } ret = regmap_update_bits(ssm4567->regmap, SSM4567_REG_SAI_CTRL_2, SSM4567_SAI_CTRL_2_AUTO_SLOT | SSM4567_SAI_CTRL_2_TDM_SLOT_MASK, SSM4567_SAI_CTRL_2_TDM_SLOT(slot)); if (ret) return ret; return regmap_update_bits(ssm4567->regmap, SSM4567_REG_SAI_CTRL_1, SSM4567_SAI_CTRL_1_TDM_BLCKS_MASK, blcks); } static int ssm4567_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt) { struct ssm4567 *ssm4567 = snd_soc_dai_get_drvdata(dai); unsigned int ctrl1 = 0; bool invert_fclk; switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { case SND_SOC_DAIFMT_CBS_CFS: break; default: return -EINVAL; } switch (fmt & SND_SOC_DAIFMT_INV_MASK) { case SND_SOC_DAIFMT_NB_NF: invert_fclk = false; break; case SND_SOC_DAIFMT_IB_NF: ctrl1 |= SSM4567_SAI_CTRL_1_BCLK; invert_fclk = false; break; case SND_SOC_DAIFMT_NB_IF: ctrl1 |= SSM4567_SAI_CTRL_1_FSYNC; invert_fclk = true; break; case SND_SOC_DAIFMT_IB_IF: ctrl1 |= SSM4567_SAI_CTRL_1_BCLK; invert_fclk = true; break; default: return -EINVAL; } switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { case SND_SOC_DAIFMT_I2S: break; case SND_SOC_DAIFMT_LEFT_J: ctrl1 |= SSM4567_SAI_CTRL_1_LJ; invert_fclk = !invert_fclk; break; case SND_SOC_DAIFMT_DSP_A: ctrl1 |= SSM4567_SAI_CTRL_1_TDM; break; case SND_SOC_DAIFMT_DSP_B: ctrl1 |= SSM4567_SAI_CTRL_1_TDM | SSM4567_SAI_CTRL_1_LJ; break; case SND_SOC_DAIFMT_PDM: ctrl1 |= SSM4567_SAI_CTRL_1_PDM; break; default: return -EINVAL; } if (invert_fclk) ctrl1 |= SSM4567_SAI_CTRL_1_FSYNC; return regmap_update_bits(ssm4567->regmap, SSM4567_REG_SAI_CTRL_1, SSM4567_SAI_CTRL_1_BCLK | SSM4567_SAI_CTRL_1_FSYNC | SSM4567_SAI_CTRL_1_LJ | SSM4567_SAI_CTRL_1_TDM | SSM4567_SAI_CTRL_1_PDM, ctrl1); } static int ssm4567_set_power(struct ssm4567 *ssm4567, bool enable) { int ret = 0; if (!enable) { ret = regmap_update_bits(ssm4567->regmap, SSM4567_REG_POWER_CTRL, SSM4567_POWER_SPWDN, SSM4567_POWER_SPWDN); regcache_mark_dirty(ssm4567->regmap); } regcache_cache_only(ssm4567->regmap, !enable); if (enable) { ret = regmap_update_bits(ssm4567->regmap, SSM4567_REG_POWER_CTRL, SSM4567_POWER_SPWDN, 0x00); regcache_sync(ssm4567->regmap); } return ret; } static int ssm4567_set_bias_level(struct snd_soc_codec *codec, enum snd_soc_bias_level level) { struct ssm4567 *ssm4567 = snd_soc_codec_get_drvdata(codec); int ret = 0; switch (level) { case SND_SOC_BIAS_ON: break; case SND_SOC_BIAS_PREPARE: break; case SND_SOC_BIAS_STANDBY: if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) ret = ssm4567_set_power(ssm4567, true); break; case SND_SOC_BIAS_OFF: ret = ssm4567_set_power(ssm4567, false); break; } return ret; } static const struct snd_soc_dai_ops ssm4567_dai_ops = { .hw_params = ssm4567_hw_params, .digital_mute = ssm4567_mute, .set_fmt = ssm4567_set_dai_fmt, .set_tdm_slot = ssm4567_set_tdm_slot, }; static struct snd_soc_dai_driver ssm4567_dai = { .name = "ssm4567-hifi", .playback = { .stream_name = "Playback", .channels_min = 1, .channels_max = 1, .rates = SNDRV_PCM_RATE_8000_192000, .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32, }, .capture = { .stream_name = "Capture Sense", .channels_min = 1, .channels_max = 1, .rates = SNDRV_PCM_RATE_8000_192000, .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32, }, .ops = &ssm4567_dai_ops, }; static struct snd_soc_codec_driver ssm4567_codec_driver = { .set_bias_level = ssm4567_set_bias_level, .idle_bias_off = true, .controls = ssm4567_snd_controls, .num_controls = ARRAY_SIZE(ssm4567_snd_controls), .dapm_widgets = ssm4567_dapm_widgets, .num_dapm_widgets = ARRAY_SIZE(ssm4567_dapm_widgets), .dapm_routes = ssm4567_routes, .num_dapm_routes = ARRAY_SIZE(ssm4567_routes), }; static const struct regmap_config ssm4567_regmap_config = { .val_bits = 8, .reg_bits = 8, .max_register = SSM4567_REG_SOFT_RESET, .readable_reg = ssm4567_readable_reg, .writeable_reg = ssm4567_writeable_reg, .volatile_reg = ssm4567_volatile_reg, .cache_type = REGCACHE_RBTREE, .reg_defaults = ssm4567_reg_defaults, .num_reg_defaults = ARRAY_SIZE(ssm4567_reg_defaults), }; static int ssm4567_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) { struct ssm4567 *ssm4567; int ret; ssm4567 = devm_kzalloc(&i2c->dev, sizeof(*ssm4567), GFP_KERNEL); if (ssm4567 == NULL) return -ENOMEM; i2c_set_clientdata(i2c, ssm4567); ssm4567->regmap = devm_regmap_init_i2c(i2c, &ssm4567_regmap_config); if (IS_ERR(ssm4567->regmap)) return PTR_ERR(ssm4567->regmap); ret = regmap_write(ssm4567->regmap, SSM4567_REG_SOFT_RESET, 0x00); if (ret) return ret; ret = ssm4567_set_power(ssm4567, false); if (ret) return ret; return snd_soc_register_codec(&i2c->dev, &ssm4567_codec_driver, &ssm4567_dai, 1); } static int ssm4567_i2c_remove(struct i2c_client *client) { snd_soc_unregister_codec(&client->dev); return 0; } static const struct i2c_device_id ssm4567_i2c_ids[] = { { "ssm4567", 0 }, { } }; MODULE_DEVICE_TABLE(i2c, ssm4567_i2c_ids); #ifdef CONFIG_ACPI static const struct acpi_device_id ssm4567_acpi_match[] = { { "INT343B", 0 }, {}, }; MODULE_DEVICE_TABLE(acpi, ssm4567_acpi_match); #endif static struct i2c_driver ssm4567_driver = { .driver = { .name = "ssm4567", .acpi_match_table = ACPI_PTR(ssm4567_acpi_match), }, .probe = ssm4567_i2c_probe, .remove = ssm4567_i2c_remove, .id_table = ssm4567_i2c_ids, }; module_i2c_driver(ssm4567_driver); MODULE_DESCRIPTION("ASoC SSM4567 driver"); MODULE_AUTHOR("Anatol Pomozov <anatol@chromium.org>"); MODULE_LICENSE("GPL");