[mirror_ubuntu-artful-kernel.git] / sound / soc / pxa / spitz.c

/*
 * spitz.c  --  SoC audio for Sharp SL-Cxx00 models Spitz, Borzoi and Akita
 *
 * Copyright 2005 Wolfson Microelectronics PLC.
 * Copyright 2005 Openedhand Ltd.
 *
 * Authors: Liam Girdwood <lrg@slimlogic.co.uk>
 *          Richard Purdie <richard@openedhand.com>
 *
 *  This program is free software; you can redistribute  it and/or modify it
 *  under  the terms of  the GNU General  Public License as published by the
 *  Free Software Foundation;  either version 2 of the  License, or (at your
 *  option) any later version.
 *
 */

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/timer.h>
#include <linux/interrupt.h>
#include <linux/platform_device.h>
#include <linux/gpio.h>
#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/soc.h>
#include <sound/soc-dapm.h>

#include <asm/mach-types.h>
#include <mach/spitz.h>
#include "../codecs/wm8750.h"
#include "pxa2xx-i2s.h"

#define SPITZ_HP        0
#define SPITZ_MIC       1
#define SPITZ_LINE      2
#define SPITZ_HEADSET   3
#define SPITZ_HP_OFF    4
#define SPITZ_SPK_ON    0
#define SPITZ_SPK_OFF   1

 /* audio clock in Hz - rounded from 12.235MHz */
#define SPITZ_AUDIO_CLOCK 12288000

static int spitz_jack_func;
static int spitz_spk_func;

static void spitz_ext_control(struct snd_soc_codec *codec)
{
	if (spitz_spk_func == SPITZ_SPK_ON)
		snd_soc_dapm_enable_pin(codec, "Ext Spk");
	else
		snd_soc_dapm_disable_pin(codec, "Ext Spk");

	/* set up jack connection */
	switch (spitz_jack_func) {
	case SPITZ_HP:
		/* enable and unmute hp jack, disable mic bias */
		snd_soc_dapm_disable_pin(codec, "Headset Jack");
		snd_soc_dapm_disable_pin(codec, "Mic Jack");
		snd_soc_dapm_disable_pin(codec, "Line Jack");
		snd_soc_dapm_enable_pin(codec, "Headphone Jack");
		gpio_set_value(SPITZ_GPIO_MUTE_L, 1);
		gpio_set_value(SPITZ_GPIO_MUTE_R, 1);
		break;
	case SPITZ_MIC:
		/* enable mic jack and bias, mute hp */
		snd_soc_dapm_disable_pin(codec, "Headphone Jack");
		snd_soc_dapm_disable_pin(codec, "Headset Jack");
		snd_soc_dapm_disable_pin(codec, "Line Jack");
		snd_soc_dapm_enable_pin(codec, "Mic Jack");
		gpio_set_value(SPITZ_GPIO_MUTE_L, 0);
		gpio_set_value(SPITZ_GPIO_MUTE_R, 0);
		break;
	case SPITZ_LINE:
		/* enable line jack, disable mic bias and mute hp */
		snd_soc_dapm_disable_pin(codec, "Headphone Jack");
		snd_soc_dapm_disable_pin(codec, "Headset Jack");
		snd_soc_dapm_disable_pin(codec, "Mic Jack");
		snd_soc_dapm_enable_pin(codec, "Line Jack");
		gpio_set_value(SPITZ_GPIO_MUTE_L, 0);
		gpio_set_value(SPITZ_GPIO_MUTE_R, 0);
		break;
	case SPITZ_HEADSET:
		/* enable and unmute headset jack enable mic bias, mute L hp */
		snd_soc_dapm_disable_pin(codec, "Headphone Jack");
		snd_soc_dapm_enable_pin(codec, "Mic Jack");
		snd_soc_dapm_disable_pin(codec, "Line Jack");
		snd_soc_dapm_enable_pin(codec, "Headset Jack");
		gpio_set_value(SPITZ_GPIO_MUTE_L, 0);
		gpio_set_value(SPITZ_GPIO_MUTE_R, 1);
		break;
	case SPITZ_HP_OFF:

		/* jack removed, everything off */
		snd_soc_dapm_disable_pin(codec, "Headphone Jack");
		snd_soc_dapm_disable_pin(codec, "Headset Jack");
		snd_soc_dapm_disable_pin(codec, "Mic Jack");
		snd_soc_dapm_disable_pin(codec, "Line Jack");
		gpio_set_value(SPITZ_GPIO_MUTE_L, 0);
		gpio_set_value(SPITZ_GPIO_MUTE_R, 0);
		break;
	}
	snd_soc_dapm_sync(codec);
}

static int spitz_startup(struct snd_pcm_substream *substream)
{
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	struct snd_soc_codec *codec = rtd->codec;

	/* check the jack status at stream startup */
	spitz_ext_control(codec);
	return 0;
}

static int spitz_hw_params(struct snd_pcm_substream *substream,
	struct snd_pcm_hw_params *params)
{
	struct snd_soc_pcm_runtime *rtd = substream->private_data;
	struct snd_soc_dai *codec_dai = rtd->codec_dai;
	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
	unsigned int clk = 0;
	int ret = 0;

	switch (params_rate(params)) {
	case 8000:
	case 16000:
	case 48000:
	case 96000:
		clk = 12288000;
		break;
	case 11025:
	case 22050:
	case 44100:
		clk = 11289600;
		break;
	}

	/* set codec DAI configuration */
	ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S |
		SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
	if (ret < 0)
		return ret;

	/* set cpu DAI configuration */
	ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S |
		SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
	if (ret < 0)
		return ret;

	/* set the codec system clock for DAC and ADC */
	ret = snd_soc_dai_set_sysclk(codec_dai, WM8750_SYSCLK, clk,
		SND_SOC_CLOCK_IN);
	if (ret < 0)
		return ret;

	/* set the I2S system clock as input (unused) */
	ret = snd_soc_dai_set_sysclk(cpu_dai, PXA2XX_I2S_SYSCLK, 0,
		SND_SOC_CLOCK_IN);
	if (ret < 0)
		return ret;

	return 0;
}

static struct snd_soc_ops spitz_ops = {
	.startup = spitz_startup,
	.hw_params = spitz_hw_params,
};

static int spitz_get_jack(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	ucontrol->value.integer.value[0] = spitz_jack_func;
	return 0;
}

static int spitz_set_jack(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);

	if (spitz_jack_func == ucontrol->value.integer.value[0])
		return 0;

	spitz_jack_func = ucontrol->value.integer.value[0];
	spitz_ext_control(codec);
	return 1;
}

static int spitz_get_spk(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	ucontrol->value.integer.value[0] = spitz_spk_func;
	return 0;
}

static int spitz_set_spk(struct snd_kcontrol *kcontrol,
	struct snd_ctl_elem_value *ucontrol)
{
	struct snd_soc_codec *codec =  snd_kcontrol_chip(kcontrol);

	if (spitz_spk_func == ucontrol->value.integer.value[0])
		return 0;

	spitz_spk_func = ucontrol->value.integer.value[0];
	spitz_ext_control(codec);
	return 1;
}

static int spitz_mic_bias(struct snd_soc_dapm_widget *w,
	struct snd_kcontrol *k, int event)
{
	if (machine_is_borzoi() || machine_is_spitz())
		gpio_set_value(SPITZ_GPIO_MIC_BIAS,
				SND_SOC_DAPM_EVENT_ON(event));

	if (machine_is_akita())
		gpio_set_value(AKITA_GPIO_MIC_BIAS,
				SND_SOC_DAPM_EVENT_ON(event));

	return 0;
}

/* spitz machine dapm widgets */
static const struct snd_soc_dapm_widget wm8750_dapm_widgets[] = {
	SND_SOC_DAPM_HP("Headphone Jack", NULL),
	SND_SOC_DAPM_MIC("Mic Jack", spitz_mic_bias),
	SND_SOC_DAPM_SPK("Ext Spk", NULL),
	SND_SOC_DAPM_LINE("Line Jack", NULL),

	/* headset is a mic and mono headphone */
	SND_SOC_DAPM_HP("Headset Jack", NULL),
};

/* Spitz machine audio_map */
static const struct snd_soc_dapm_route audio_map[] = {

	/* headphone connected to LOUT1, ROUT1 */
	{"Headphone Jack", NULL, "LOUT1"},
	{"Headphone Jack", NULL, "ROUT1"},

	/* headset connected to ROUT1 and LINPUT1 with bias (def below) */
	{"Headset Jack", NULL, "ROUT1"},

	/* ext speaker connected to LOUT2, ROUT2  */
	{"Ext Spk", NULL , "ROUT2"},
	{"Ext Spk", NULL , "LOUT2"},

	/* mic is connected to input 1 - with bias */
	{"LINPUT1", NULL, "Mic Bias"},
	{"Mic Bias", NULL, "Mic Jack"},

	/* line is connected to input 1 - no bias */
	{"LINPUT1", NULL, "Line Jack"},
};

static const char *jack_function[] = {"Headphone", "Mic", "Line", "Headset",
	"Off"};
static const char *spk_function[] = {"On", "Off"};
static const struct soc_enum spitz_enum[] = {
	SOC_ENUM_SINGLE_EXT(5, jack_function),
	SOC_ENUM_SINGLE_EXT(2, spk_function),
};

static const struct snd_kcontrol_new wm8750_spitz_controls[] = {
	SOC_ENUM_EXT("Jack Function", spitz_enum[0], spitz_get_jack,
		spitz_set_jack),
	SOC_ENUM_EXT("Speaker Function", spitz_enum[1], spitz_get_spk,
		spitz_set_spk),
};

/*
 * Logic for a wm8750 as connected on a Sharp SL-Cxx00 Device
 */
static int spitz_wm8750_init(struct snd_soc_pcm_runtime *rtd)
{
	struct snd_soc_codec *codec = rtd->codec;
	int err;

	/* NC codec pins */
	snd_soc_dapm_nc_pin(codec, "RINPUT1");
	snd_soc_dapm_nc_pin(codec, "LINPUT2");
	snd_soc_dapm_nc_pin(codec, "RINPUT2");
	snd_soc_dapm_nc_pin(codec, "LINPUT3");
	snd_soc_dapm_nc_pin(codec, "RINPUT3");
	snd_soc_dapm_nc_pin(codec, "OUT3");
	snd_soc_dapm_nc_pin(codec, "MONO1");

	/* Add spitz specific controls */
	err = snd_soc_add_controls(codec, wm8750_spitz_controls,
				ARRAY_SIZE(wm8750_spitz_controls));
	if (err < 0)
		return err;

	/* Add spitz specific widgets */
	snd_soc_dapm_new_controls(codec, wm8750_dapm_widgets,
				  ARRAY_SIZE(wm8750_dapm_widgets));

	/* Set up spitz specific audio paths */
	snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));

	snd_soc_dapm_sync(codec);
	return 0;
}

/* spitz digital audio interface glue - connects codec <--> CPU */
static struct snd_soc_dai_link spitz_dai = {
	.name = "wm8750",
	.stream_name = "WM8750",
	.cpu_dai_name = "pxa-is2",
	.codec_dai_name = "wm8750-hifi",
	.platform_name = "pxa-pcm-audio",
	.codec_name = "wm8750-codec.0-001a",
	.init = spitz_wm8750_init,
	.ops = &spitz_ops,
};

/* spitz audio machine driver */
static struct snd_soc_card snd_soc_spitz = {
	.name = "Spitz",
	.dai_link = &spitz_dai,
	.num_links = 1,
};

static struct platform_device *spitz_snd_device;

static int __init spitz_init(void)
{
	int ret;

	if (!(machine_is_spitz() || machine_is_borzoi() || machine_is_akita()))
		return -ENODEV;

	spitz_snd_device = platform_device_alloc("soc-audio", -1);
	if (!spitz_snd_device)
		return -ENOMEM;

	platform_set_drvdata(spitz_snd_device, &snd_soc_spitz);
	ret = platform_device_add(spitz_snd_device);

	if (ret)
		platform_device_put(spitz_snd_device);

	return ret;
}

static void __exit spitz_exit(void)
{
	platform_device_unregister(spitz_snd_device);
}

module_init(spitz_init);
module_exit(spitz_exit);

MODULE_AUTHOR("Richard Purdie");
MODULE_DESCRIPTION("ALSA SoC Spitz");
MODULE_LICENSE("GPL");
Commit	Line	Data
7fb290d0 LG	1	/*
	2	* spitz.c -- SoC audio for Sharp SL-Cxx00 models Spitz, Borzoi and Akita
	3	*
	4	* Copyright 2005 Wolfson Microelectronics PLC.
	5	* Copyright 2005 Openedhand Ltd.
	6	*
d331124d	7	* Authors: Liam Girdwood <lrg@slimlogic.co.uk>
7fb290d0 LG	8	* Richard Purdie <richard@openedhand.com>
	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	*
7fb290d0 LG	15	*/
	16
	17	#include <linux/module.h>
	18	#include <linux/moduleparam.h>
	19	#include <linux/timer.h>
	20	#include <linux/interrupt.h>
	21	#include <linux/platform_device.h>
fff14720	22	#include <linux/gpio.h>
7fb290d0 LG	23	#include <sound/core.h>
	24	#include <sound/pcm.h>
	25	#include <sound/soc.h>
	26	#include <sound/soc-dapm.h>
	27
	28	#include <asm/mach-types.h>
a09e64fb	29	#include <mach/spitz.h>
7fb290d0	30	#include "../codecs/wm8750.h"
97952f60	31	#include "pxa2xx-i2s.h"
7fb290d0 LG	32
	33	#define SPITZ_HP 0
	34	#define SPITZ_MIC 1
	35	#define SPITZ_LINE 2
	36	#define SPITZ_HEADSET 3
	37	#define SPITZ_HP_OFF 4
	38	#define SPITZ_SPK_ON 0
	39	#define SPITZ_SPK_OFF 1
	40
	41	/* audio clock in Hz - rounded from 12.235MHz */
	42	#define SPITZ_AUDIO_CLOCK 12288000
	43
	44	static int spitz_jack_func;
	45	static int spitz_spk_func;
	46
	47	static void spitz_ext_control(struct snd_soc_codec *codec)
	48	{
	49	if (spitz_spk_func == SPITZ_SPK_ON)
a5302181	50	snd_soc_dapm_enable_pin(codec, "Ext Spk");
7fb290d0	51	else
a5302181	52	snd_soc_dapm_disable_pin(codec, "Ext Spk");
7fb290d0 LG	53
	54	/* set up jack connection */
	55	switch (spitz_jack_func) {
	56	case SPITZ_HP:
	57	/* enable and unmute hp jack, disable mic bias */
a5302181 LG	58	snd_soc_dapm_disable_pin(codec, "Headset Jack");
	59	snd_soc_dapm_disable_pin(codec, "Mic Jack");
	60	snd_soc_dapm_disable_pin(codec, "Line Jack");
	61	snd_soc_dapm_enable_pin(codec, "Headphone Jack");
fff14720 EM	62	gpio_set_value(SPITZ_GPIO_MUTE_L, 1);
fff14720 EM	63	gpio_set_value(SPITZ_GPIO_MUTE_R, 1);
7fb290d0 LG	64	break;
	65	case SPITZ_MIC:
	66	/* enable mic jack and bias, mute hp */
a5302181 LG	67	snd_soc_dapm_disable_pin(codec, "Headphone Jack");
	68	snd_soc_dapm_disable_pin(codec, "Headset Jack");
	69	snd_soc_dapm_disable_pin(codec, "Line Jack");
	70	snd_soc_dapm_enable_pin(codec, "Mic Jack");
fff14720 EM	71	gpio_set_value(SPITZ_GPIO_MUTE_L, 0);
fff14720 EM	72	gpio_set_value(SPITZ_GPIO_MUTE_R, 0);
7fb290d0 LG	73	break;
	74	case SPITZ_LINE:
	75	/* enable line jack, disable mic bias and mute hp */
a5302181 LG	76	snd_soc_dapm_disable_pin(codec, "Headphone Jack");
	77	snd_soc_dapm_disable_pin(codec, "Headset Jack");
	78	snd_soc_dapm_disable_pin(codec, "Mic Jack");
	79	snd_soc_dapm_enable_pin(codec, "Line Jack");
fff14720 EM	80	gpio_set_value(SPITZ_GPIO_MUTE_L, 0);
fff14720 EM	81	gpio_set_value(SPITZ_GPIO_MUTE_R, 0);
7fb290d0 LG	82	break;
	83	case SPITZ_HEADSET:
	84	/* enable and unmute headset jack enable mic bias, mute L hp */
a5302181 LG	85	snd_soc_dapm_disable_pin(codec, "Headphone Jack");
	86	snd_soc_dapm_enable_pin(codec, "Mic Jack");
	87	snd_soc_dapm_disable_pin(codec, "Line Jack");
	88	snd_soc_dapm_enable_pin(codec, "Headset Jack");
fff14720 EM	89	gpio_set_value(SPITZ_GPIO_MUTE_L, 0);
fff14720 EM	90	gpio_set_value(SPITZ_GPIO_MUTE_R, 1);
7fb290d0 LG	91	break;
	92	case SPITZ_HP_OFF:
	93
	94	/* jack removed, everything off */
a5302181 LG	95	snd_soc_dapm_disable_pin(codec, "Headphone Jack");
	96	snd_soc_dapm_disable_pin(codec, "Headset Jack");
	97	snd_soc_dapm_disable_pin(codec, "Mic Jack");
	98	snd_soc_dapm_disable_pin(codec, "Line Jack");
fff14720 EM	99	gpio_set_value(SPITZ_GPIO_MUTE_L, 0);
fff14720 EM	100	gpio_set_value(SPITZ_GPIO_MUTE_R, 0);
7fb290d0 LG	101	break;
7fb290d0 LG	102	}
a5302181	103	snd_soc_dapm_sync(codec);
7fb290d0 LG	104	}
	105
	106	static int spitz_startup(struct snd_pcm_substream *substream)
	107	{
	108	struct snd_soc_pcm_runtime *rtd = substream->private_data;
f0fba2ad	109	struct snd_soc_codec *codec = rtd->codec;
7fb290d0 LG	110
	111	/* check the jack status at stream startup */
	112	spitz_ext_control(codec);
	113	return 0;
	114	}
	115
97952f60 LG	116	static int spitz_hw_params(struct snd_pcm_substream *substream,
	117	struct snd_pcm_hw_params *params)
	118	{
	119	struct snd_soc_pcm_runtime *rtd = substream->private_data;
f0fba2ad LG	120	struct snd_soc_dai *codec_dai = rtd->codec_dai;
f0fba2ad LG	121	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
97952f60 LG	122	unsigned int clk = 0;
	123	int ret = 0;
	124
	125	switch (params_rate(params)) {
	126	case 8000:
	127	case 16000:
	128	case 48000:
	129	case 96000:
	130	clk = 12288000;
	131	break;
	132	case 11025:
	133	case 22050:
	134	case 44100:
	135	clk = 11289600;
	136	break;
	137	}
	138
	139	/* set codec DAI configuration */
64105cfd	140	ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_I2S \|
97952f60 LG	141	SND_SOC_DAIFMT_NB_NF \| SND_SOC_DAIFMT_CBS_CFS);
	142	if (ret < 0)
	143	return ret;
	144
	145	/* set cpu DAI configuration */
64105cfd	146	ret = snd_soc_dai_set_fmt(cpu_dai, SND_SOC_DAIFMT_I2S \|
97952f60 LG	147	SND_SOC_DAIFMT_NB_NF \| SND_SOC_DAIFMT_CBS_CFS);
	148	if (ret < 0)
	149	return ret;
	150
	151	/* set the codec system clock for DAC and ADC */
64105cfd	152	ret = snd_soc_dai_set_sysclk(codec_dai, WM8750_SYSCLK, clk,
97952f60 LG	153	SND_SOC_CLOCK_IN);
	154	if (ret < 0)
	155	return ret;
	156
	157	/* set the I2S system clock as input (unused) */
64105cfd	158	ret = snd_soc_dai_set_sysclk(cpu_dai, PXA2XX_I2S_SYSCLK, 0,
97952f60 LG	159	SND_SOC_CLOCK_IN);
	160	if (ret < 0)
	161	return ret;
	162
	163	return 0;
	164	}
	165
7fb290d0 LG	166	static struct snd_soc_ops spitz_ops = {
7fb290d0 LG	167	.startup = spitz_startup,
97952f60	168	.hw_params = spitz_hw_params,
7fb290d0 LG	169	};
	170
	171	static int spitz_get_jack(struct snd_kcontrol *kcontrol,
	172	struct snd_ctl_elem_value *ucontrol)
	173	{
	174	ucontrol->value.integer.value[0] = spitz_jack_func;
	175	return 0;
	176	}
	177
	178	static int spitz_set_jack(struct snd_kcontrol *kcontrol,
	179	struct snd_ctl_elem_value *ucontrol)
	180	{
	181	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
	182
	183	if (spitz_jack_func == ucontrol->value.integer.value[0])
	184	return 0;
	185
	186	spitz_jack_func = ucontrol->value.integer.value[0];
	187	spitz_ext_control(codec);
	188	return 1;
	189	}
	190
	191	static int spitz_get_spk(struct snd_kcontrol *kcontrol,
	192	struct snd_ctl_elem_value *ucontrol)
	193	{
	194	ucontrol->value.integer.value[0] = spitz_spk_func;
	195	return 0;
	196	}
	197
	198	static int spitz_set_spk(struct snd_kcontrol *kcontrol,
	199	struct snd_ctl_elem_value *ucontrol)
	200	{
	201	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
	202
	203	if (spitz_spk_func == ucontrol->value.integer.value[0])
	204	return 0;
	205
	206	spitz_spk_func = ucontrol->value.integer.value[0];
	207	spitz_ext_control(codec);
	208	return 1;
	209	}
	210
338c7ed0 JN	211	static int spitz_mic_bias(struct snd_soc_dapm_widget *w,
338c7ed0 JN	212	struct snd_kcontrol *k, int event)
7fb290d0	213	{
fff14720 EM	214	if (machine_is_borzoi() \|\| machine_is_spitz())
	215	gpio_set_value(SPITZ_GPIO_MIC_BIAS,
	216	SND_SOC_DAPM_EVENT_ON(event));
7fb290d0	217
f72de663 EM	218	if (machine_is_akita())
	219	gpio_set_value(AKITA_GPIO_MIC_BIAS,
	220	SND_SOC_DAPM_EVENT_ON(event));
7fb290d0	221
7fb290d0 LG	222	return 0;
	223	}
	224
	225	/* spitz machine dapm widgets */
	226	static const struct snd_soc_dapm_widget wm8750_dapm_widgets[] = {
	227	SND_SOC_DAPM_HP("Headphone Jack", NULL),
	228	SND_SOC_DAPM_MIC("Mic Jack", spitz_mic_bias),
	229	SND_SOC_DAPM_SPK("Ext Spk", NULL),
	230	SND_SOC_DAPM_LINE("Line Jack", NULL),
	231
	232	/* headset is a mic and mono headphone */
	233	SND_SOC_DAPM_HP("Headset Jack", NULL),
	234	};
	235
	236	/* Spitz machine audio_map */
25191c45	237	static const struct snd_soc_dapm_route audio_map[] = {
7fb290d0 LG	238
	239	/* headphone connected to LOUT1, ROUT1 */
	240	{"Headphone Jack", NULL, "LOUT1"},
	241	{"Headphone Jack", NULL, "ROUT1"},
	242
	243	/* headset connected to ROUT1 and LINPUT1 with bias (def below) */
	244	{"Headset Jack", NULL, "ROUT1"},
	245
	246	/* ext speaker connected to LOUT2, ROUT2 */
	247	{"Ext Spk", NULL , "ROUT2"},
	248	{"Ext Spk", NULL , "LOUT2"},
	249
	250	/* mic is connected to input 1 - with bias */
	251	{"LINPUT1", NULL, "Mic Bias"},
	252	{"Mic Bias", NULL, "Mic Jack"},
	253
	254	/* line is connected to input 1 - no bias */
	255	{"LINPUT1", NULL, "Line Jack"},
7fb290d0 LG	256	};
	257
	258	static const char *jack_function[] = {"Headphone", "Mic", "Line", "Headset",
	259	"Off"};
	260	static const char *spk_function[] = {"On", "Off"};
	261	static const struct soc_enum spitz_enum[] = {
	262	SOC_ENUM_SINGLE_EXT(5, jack_function),
	263	SOC_ENUM_SINGLE_EXT(2, spk_function),
	264	};
	265
	266	static const struct snd_kcontrol_new wm8750_spitz_controls[] = {
	267	SOC_ENUM_EXT("Jack Function", spitz_enum[0], spitz_get_jack,
	268	spitz_set_jack),
	269	SOC_ENUM_EXT("Speaker Function", spitz_enum[1], spitz_get_spk,
	270	spitz_set_spk),
	271	};
	272
	273	/*
	274	* Logic for a wm8750 as connected on a Sharp SL-Cxx00 Device
	275	*/
f0fba2ad	276	static int spitz_wm8750_init(struct snd_soc_pcm_runtime *rtd)
7fb290d0	277	{
f0fba2ad	278	struct snd_soc_codec *codec = rtd->codec;
eb5f6d75	279	int err;
7fb290d0 LG	280
7fb290d0 LG	281	/* NC codec pins */
35f5e54d MB	282	snd_soc_dapm_nc_pin(codec, "RINPUT1");
	283	snd_soc_dapm_nc_pin(codec, "LINPUT2");
	284	snd_soc_dapm_nc_pin(codec, "RINPUT2");
	285	snd_soc_dapm_nc_pin(codec, "LINPUT3");
	286	snd_soc_dapm_nc_pin(codec, "RINPUT3");
	287	snd_soc_dapm_nc_pin(codec, "OUT3");
	288	snd_soc_dapm_nc_pin(codec, "MONO1");
7fb290d0 LG	289
7fb290d0 LG	290	/* Add spitz specific controls */
eb5f6d75 PZ	291	err = snd_soc_add_controls(codec, wm8750_spitz_controls,
	292	ARRAY_SIZE(wm8750_spitz_controls));
	293	if (err < 0)
	294	return err;
7fb290d0 LG	295
7fb290d0 LG	296	/* Add spitz specific widgets */
25191c45 MB	297	snd_soc_dapm_new_controls(codec, wm8750_dapm_widgets,
25191c45 MB	298	ARRAY_SIZE(wm8750_dapm_widgets));
7fb290d0	299
25191c45 MB	300	/* Set up spitz specific audio paths */
25191c45 MB	301	snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
7fb290d0	302
a5302181	303	snd_soc_dapm_sync(codec);
7fb290d0 LG	304	return 0;
	305	}
	306
7fb290d0 LG	307	/* spitz digital audio interface glue - connects codec <--> CPU */
	308	static struct snd_soc_dai_link spitz_dai = {
	309	.name = "wm8750",
	310	.stream_name = "WM8750",
f0fba2ad LG	311	.cpu_dai_name = "pxa-is2",
	312	.codec_dai_name = "wm8750-hifi",
	313	.platform_name = "pxa-pcm-audio",
	314	.codec_name = "wm8750-codec.0-001a",
7fb290d0	315	.init = spitz_wm8750_init,
97952f60	316	.ops = &spitz_ops,
7fb290d0 LG	317	};
	318
	319	/* spitz audio machine driver */
87506549	320	static struct snd_soc_card snd_soc_spitz = {
7fb290d0 LG	321	.name = "Spitz",
	322	.dai_link = &spitz_dai,
	323	.num_links = 1,
7fb290d0 LG	324	};
7fb290d0 LG	325
7fb290d0 LG	326	static struct platform_device *spitz_snd_device;
	327
	328	static int __init spitz_init(void)
	329	{
	330	int ret;
	331
	332	if (!(machine_is_spitz() \|\| machine_is_borzoi() \|\| machine_is_akita()))
	333	return -ENODEV;
	334
	335	spitz_snd_device = platform_device_alloc("soc-audio", -1);
	336	if (!spitz_snd_device)
	337	return -ENOMEM;
	338
f0fba2ad	339	platform_set_drvdata(spitz_snd_device, &snd_soc_spitz);
7fb290d0 LG	340	ret = platform_device_add(spitz_snd_device);
	341
	342	if (ret)
	343	platform_device_put(spitz_snd_device);
	344
	345	return ret;
	346	}
	347
	348	static void __exit spitz_exit(void)
	349	{
	350	platform_device_unregister(spitz_snd_device);
	351	}
	352
	353	module_init(spitz_init);
	354	module_exit(spitz_exit);
	355
	356	MODULE_AUTHOR("Richard Purdie");
	357	MODULE_DESCRIPTION("ALSA SoC Spitz");
	358	MODULE_LICENSE("GPL");