[deliverable/linux.git] / sound / soc / soc-ac97.c

/*
 * soc-ac97.c  --  ALSA SoC Audio Layer AC97 support
 *
 * Copyright 2005 Wolfson Microelectronics PLC.
 * Copyright 2005 Openedhand Ltd.
 * Copyright (C) 2010 Slimlogic Ltd.
 * Copyright (C) 2010 Texas Instruments Inc.
 *
 * Author: Liam Girdwood <lrg@slimlogic.co.uk>
 *         with code, comments and ideas from :-
 *         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/ctype.h>
#include <linux/delay.h>
#include <linux/export.h>
#include <linux/gpio.h>
#include <linux/gpio/driver.h>
#include <linux/init.h>
#include <linux/of_gpio.h>
#include <linux/of.h>
#include <linux/pinctrl/consumer.h>
#include <linux/slab.h>
#include <sound/ac97_codec.h>
#include <sound/soc.h>

struct snd_ac97_reset_cfg {
	struct pinctrl *pctl;
	struct pinctrl_state *pstate_reset;
	struct pinctrl_state *pstate_warm_reset;
	struct pinctrl_state *pstate_run;
	int gpio_sdata;
	int gpio_sync;
	int gpio_reset;
};

struct snd_ac97_gpio_priv {
#ifdef CONFIG_GPIOLIB
	struct gpio_chip gpio_chip;
#endif
	unsigned int gpios_set;
	struct snd_soc_codec *codec;
};

static struct snd_ac97_bus soc_ac97_bus = {
	.ops = NULL, /* Gets initialized in snd_soc_set_ac97_ops() */
};

static void soc_ac97_device_release(struct device *dev)
{
	kfree(to_ac97_t(dev));
}

#ifdef CONFIG_GPIOLIB
static inline struct snd_soc_codec *gpio_to_codec(struct gpio_chip *chip)
{
	struct snd_ac97_gpio_priv *gpio_priv =
		container_of(chip, struct snd_ac97_gpio_priv, gpio_chip);

	return gpio_priv->codec;
}

static int snd_soc_ac97_gpio_request(struct gpio_chip *chip, unsigned offset)
{
	if (offset >= AC97_NUM_GPIOS)
		return -EINVAL;

	return 0;
}

static int snd_soc_ac97_gpio_direction_in(struct gpio_chip *chip,
					  unsigned offset)
{
	struct snd_soc_codec *codec = gpio_to_codec(chip);

	dev_dbg(codec->dev, "set gpio %d to output\n", offset);
	return snd_soc_update_bits(codec, AC97_GPIO_CFG,
				   1 << offset, 1 << offset);
}

static int snd_soc_ac97_gpio_get(struct gpio_chip *chip, unsigned offset)
{
	struct snd_soc_codec *codec = gpio_to_codec(chip);
	int ret;

	ret = snd_soc_read(codec, AC97_GPIO_STATUS);
	dev_dbg(codec->dev, "get gpio %d : %d\n", offset,
		ret < 0 ? ret : ret & (1 << offset));

	return ret < 0 ? ret : !!(ret & (1 << offset));
}

static void snd_soc_ac97_gpio_set(struct gpio_chip *chip, unsigned offset,
				  int value)
{
	struct snd_ac97_gpio_priv *gpio_priv =
		container_of(chip, struct snd_ac97_gpio_priv, gpio_chip);
	struct snd_soc_codec *codec = gpio_to_codec(chip);

	gpio_priv->gpios_set &= ~(1 << offset);
	gpio_priv->gpios_set |= (!!value) << offset;
	snd_soc_write(codec, AC97_GPIO_STATUS, gpio_priv->gpios_set);
	dev_dbg(codec->dev, "set gpio %d to %d\n", offset, !!value);
}

static int snd_soc_ac97_gpio_direction_out(struct gpio_chip *chip,
				     unsigned offset, int value)
{
	struct snd_soc_codec *codec = gpio_to_codec(chip);

	dev_dbg(codec->dev, "set gpio %d to output\n", offset);
	snd_soc_ac97_gpio_set(chip, offset, value);
	return snd_soc_update_bits(codec, AC97_GPIO_CFG, 1 << offset, 0);
}

static struct gpio_chip snd_soc_ac97_gpio_chip = {
	.label			= "snd_soc_ac97",
	.owner			= THIS_MODULE,
	.request		= snd_soc_ac97_gpio_request,
	.direction_input	= snd_soc_ac97_gpio_direction_in,
	.get			= snd_soc_ac97_gpio_get,
	.direction_output	= snd_soc_ac97_gpio_direction_out,
	.set			= snd_soc_ac97_gpio_set,
	.can_sleep		= 1,
};

static int snd_soc_ac97_init_gpio(struct snd_ac97 *ac97,
				  struct snd_soc_codec *codec)
{
	struct snd_ac97_gpio_priv *gpio_priv;
	int ret;

	gpio_priv = devm_kzalloc(codec->dev, sizeof(*gpio_priv), GFP_KERNEL);
	if (!gpio_priv)
		return -ENOMEM;
	ac97->gpio_priv = gpio_priv;
	gpio_priv->codec = codec;
	gpio_priv->gpio_chip = snd_soc_ac97_gpio_chip;
	gpio_priv->gpio_chip.ngpio = AC97_NUM_GPIOS;
	gpio_priv->gpio_chip.dev = codec->dev;
	gpio_priv->gpio_chip.base = -1;

	ret = gpiochip_add(&gpio_priv->gpio_chip);
	if (ret != 0)
		dev_err(codec->dev, "Failed to add GPIOs: %d\n", ret);
	return ret;
}

static void snd_soc_ac97_free_gpio(struct snd_ac97 *ac97)
{
	gpiochip_remove(&ac97->gpio_priv->gpio_chip);
}
#else
static int snd_soc_ac97_init_gpio(struct snd_ac97 *ac97,
				  struct snd_soc_codec *codec)
{
	return 0;
}

static void snd_soc_ac97_free_gpio(struct snd_ac97 *ac97)
{
}
#endif

/**
 * snd_soc_alloc_ac97_codec() - Allocate new a AC'97 device
 * @codec: The CODEC for which to create the AC'97 device
 *
 * Allocated a new snd_ac97 device and intializes it, but does not yet register
 * it. The caller is responsible to either call device_add(&ac97->dev) to
 * register the device, or to call put_device(&ac97->dev) to free the device.
 *
 * Returns: A snd_ac97 device or a PTR_ERR in case of an error.
 */
struct snd_ac97 *snd_soc_alloc_ac97_codec(struct snd_soc_codec *codec)
{
	struct snd_ac97 *ac97;

	ac97 = kzalloc(sizeof(struct snd_ac97), GFP_KERNEL);
	if (ac97 == NULL)
		return ERR_PTR(-ENOMEM);

	ac97->bus = &soc_ac97_bus;
	ac97->num = 0;

	ac97->dev.bus = &ac97_bus_type;
	ac97->dev.parent = codec->component.card->dev;
	ac97->dev.release = soc_ac97_device_release;

	dev_set_name(&ac97->dev, "%d-%d:%s",
		     codec->component.card->snd_card->number, 0,
		     codec->component.name);

	device_initialize(&ac97->dev);

	return ac97;
}
EXPORT_SYMBOL(snd_soc_alloc_ac97_codec);

/**
 * snd_soc_new_ac97_codec - initailise AC97 device
 * @codec: audio codec
 * @id: The expected device ID
 * @id_mask: Mask that is applied to the device ID before comparing with @id
 *
 * Initialises AC97 codec resources for use by ad-hoc devices only.
 *
 * If @id is not 0 this function will reset the device, then read the ID from
 * the device and check if it matches the expected ID. If it doesn't match an
 * error will be returned and device will not be registered.
 *
 * Returns: A PTR_ERR() on failure or a valid snd_ac97 struct on success.
 */
struct snd_ac97 *snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
	unsigned int id, unsigned int id_mask)
{
	struct snd_ac97 *ac97;
	int ret;

	ac97 = snd_soc_alloc_ac97_codec(codec);
	if (IS_ERR(ac97))
		return ac97;

	if (id) {
		ret = snd_ac97_reset(ac97, false, id, id_mask);
		if (ret < 0) {
			dev_err(codec->dev, "Failed to reset AC97 device: %d\n",
				ret);
			goto err_put_device;
		}
	}

	ret = device_add(&ac97->dev);
	if (ret)
		goto err_put_device;

	ret = snd_soc_ac97_init_gpio(ac97, codec);
	if (ret)
		goto err_put_device;

	return ac97;

err_put_device:
	put_device(&ac97->dev);
	return ERR_PTR(ret);
}
EXPORT_SYMBOL_GPL(snd_soc_new_ac97_codec);

/**
 * snd_soc_free_ac97_codec - free AC97 codec device
 * @codec: audio codec
 *
 * Frees AC97 codec device resources.
 */
void snd_soc_free_ac97_codec(struct snd_ac97 *ac97)
{
	snd_soc_ac97_free_gpio(ac97);
	device_del(&ac97->dev);
	ac97->bus = NULL;
	put_device(&ac97->dev);
}
EXPORT_SYMBOL_GPL(snd_soc_free_ac97_codec);

static struct snd_ac97_reset_cfg snd_ac97_rst_cfg;

static void snd_soc_ac97_warm_reset(struct snd_ac97 *ac97)
{
	struct pinctrl *pctl = snd_ac97_rst_cfg.pctl;

	pinctrl_select_state(pctl, snd_ac97_rst_cfg.pstate_warm_reset);

	gpio_direction_output(snd_ac97_rst_cfg.gpio_sync, 1);

	udelay(10);

	gpio_direction_output(snd_ac97_rst_cfg.gpio_sync, 0);

	pinctrl_select_state(pctl, snd_ac97_rst_cfg.pstate_run);
	msleep(2);
}

static void snd_soc_ac97_reset(struct snd_ac97 *ac97)
{
	struct pinctrl *pctl = snd_ac97_rst_cfg.pctl;

	pinctrl_select_state(pctl, snd_ac97_rst_cfg.pstate_reset);

	gpio_direction_output(snd_ac97_rst_cfg.gpio_sync, 0);
	gpio_direction_output(snd_ac97_rst_cfg.gpio_sdata, 0);
	gpio_direction_output(snd_ac97_rst_cfg.gpio_reset, 0);

	udelay(10);

	gpio_direction_output(snd_ac97_rst_cfg.gpio_reset, 1);

	pinctrl_select_state(pctl, snd_ac97_rst_cfg.pstate_run);
	msleep(2);
}

static int snd_soc_ac97_parse_pinctl(struct device *dev,
		struct snd_ac97_reset_cfg *cfg)
{
	struct pinctrl *p;
	struct pinctrl_state *state;
	int gpio;
	int ret;

	p = devm_pinctrl_get(dev);
	if (IS_ERR(p)) {
		dev_err(dev, "Failed to get pinctrl\n");
		return PTR_ERR(p);
	}
	cfg->pctl = p;

	state = pinctrl_lookup_state(p, "ac97-reset");
	if (IS_ERR(state)) {
		dev_err(dev, "Can't find pinctrl state ac97-reset\n");
		return PTR_ERR(state);
	}
	cfg->pstate_reset = state;

	state = pinctrl_lookup_state(p, "ac97-warm-reset");
	if (IS_ERR(state)) {
		dev_err(dev, "Can't find pinctrl state ac97-warm-reset\n");
		return PTR_ERR(state);
	}
	cfg->pstate_warm_reset = state;

	state = pinctrl_lookup_state(p, "ac97-running");
	if (IS_ERR(state)) {
		dev_err(dev, "Can't find pinctrl state ac97-running\n");
		return PTR_ERR(state);
	}
	cfg->pstate_run = state;

	gpio = of_get_named_gpio(dev->of_node, "ac97-gpios", 0);
	if (gpio < 0) {
		dev_err(dev, "Can't find ac97-sync gpio\n");
		return gpio;
	}
	ret = devm_gpio_request(dev, gpio, "AC97 link sync");
	if (ret) {
		dev_err(dev, "Failed requesting ac97-sync gpio\n");
		return ret;
	}
	cfg->gpio_sync = gpio;

	gpio = of_get_named_gpio(dev->of_node, "ac97-gpios", 1);
	if (gpio < 0) {
		dev_err(dev, "Can't find ac97-sdata gpio %d\n", gpio);
		return gpio;
	}
	ret = devm_gpio_request(dev, gpio, "AC97 link sdata");
	if (ret) {
		dev_err(dev, "Failed requesting ac97-sdata gpio\n");
		return ret;
	}
	cfg->gpio_sdata = gpio;

	gpio = of_get_named_gpio(dev->of_node, "ac97-gpios", 2);
	if (gpio < 0) {
		dev_err(dev, "Can't find ac97-reset gpio\n");
		return gpio;
	}
	ret = devm_gpio_request(dev, gpio, "AC97 link reset");
	if (ret) {
		dev_err(dev, "Failed requesting ac97-reset gpio\n");
		return ret;
	}
	cfg->gpio_reset = gpio;

	return 0;
}

struct snd_ac97_bus_ops *soc_ac97_ops;
EXPORT_SYMBOL_GPL(soc_ac97_ops);

int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops)
{
	if (ops == soc_ac97_ops)
		return 0;

	if (soc_ac97_ops && ops)
		return -EBUSY;

	soc_ac97_ops = ops;
	soc_ac97_bus.ops = ops;

	return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_set_ac97_ops);

/**
 * snd_soc_set_ac97_ops_of_reset - Set ac97 ops with generic ac97 reset functions
 *
 * This function sets the reset and warm_reset properties of ops and parses
 * the device node of pdev to get pinctrl states and gpio numbers to use.
 */
int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
		struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct snd_ac97_reset_cfg cfg;
	int ret;

	ret = snd_soc_ac97_parse_pinctl(dev, &cfg);
	if (ret)
		return ret;

	ret = snd_soc_set_ac97_ops(ops);
	if (ret)
		return ret;

	ops->warm_reset = snd_soc_ac97_warm_reset;
	ops->reset = snd_soc_ac97_reset;

	snd_ac97_rst_cfg = cfg;
	return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_set_ac97_ops_of_reset);
Commit	Line	Data
336b8423 LPC	1	/*
	2	* soc-ac97.c -- ALSA SoC Audio Layer AC97 support
	3	*
	4	* Copyright 2005 Wolfson Microelectronics PLC.
	5	* Copyright 2005 Openedhand Ltd.
	6	* Copyright (C) 2010 Slimlogic Ltd.
	7	* Copyright (C) 2010 Texas Instruments Inc.
	8	*
	9	* Author: Liam Girdwood <lrg@slimlogic.co.uk>
	10	* with code, comments and ideas from :-
	11	* Richard Purdie <richard@openedhand.com>
	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/ctype.h>
	20	#include <linux/delay.h>
	21	#include <linux/export.h>
	22	#include <linux/gpio.h>
9bf5c3d1	23	#include <linux/gpio/driver.h>
336b8423 LPC	24	#include <linux/init.h>
	25	#include <linux/of_gpio.h>
	26	#include <linux/of.h>
	27	#include <linux/pinctrl/consumer.h>
	28	#include <linux/slab.h>
	29	#include <sound/ac97_codec.h>
	30	#include <sound/soc.h>
	31
	32	struct snd_ac97_reset_cfg {
	33	struct pinctrl *pctl;
	34	struct pinctrl_state *pstate_reset;
	35	struct pinctrl_state *pstate_warm_reset;
	36	struct pinctrl_state *pstate_run;
	37	int gpio_sdata;
	38	int gpio_sync;
	39	int gpio_reset;
	40	};
	41
9bf5c3d1 RJ	42	struct snd_ac97_gpio_priv {
	43	#ifdef CONFIG_GPIOLIB
	44	struct gpio_chip gpio_chip;
	45	#endif
	46	unsigned int gpios_set;
	47	struct snd_soc_codec *codec;
	48	};
	49
eda1a701 LPC	50	static struct snd_ac97_bus soc_ac97_bus = {
	51	.ops = NULL, /* Gets initialized in snd_soc_set_ac97_ops() */
	52	};
	53
336b8423 LPC	54	static void soc_ac97_device_release(struct device *dev)
	55	{
	56	kfree(to_ac97_t(dev));
	57	}
	58
9bf5c3d1 RJ	59	#ifdef CONFIG_GPIOLIB
	60	static inline struct snd_soc_codec gpio_to_codec(struct gpio_chip chip)
	61	{
	62	struct snd_ac97_gpio_priv *gpio_priv =
	63	container_of(chip, struct snd_ac97_gpio_priv, gpio_chip);
	64
	65	return gpio_priv->codec;
	66	}
	67
	68	static int snd_soc_ac97_gpio_request(struct gpio_chip *chip, unsigned offset)
	69	{
	70	if (offset >= AC97_NUM_GPIOS)
	71	return -EINVAL;
	72
	73	return 0;
	74	}
	75
	76	static int snd_soc_ac97_gpio_direction_in(struct gpio_chip *chip,
	77	unsigned offset)
	78	{
	79	struct snd_soc_codec *codec = gpio_to_codec(chip);
	80
	81	dev_dbg(codec->dev, "set gpio %d to output\n", offset);
	82	return snd_soc_update_bits(codec, AC97_GPIO_CFG,
	83	1 << offset, 1 << offset);
	84	}
	85
	86	static int snd_soc_ac97_gpio_get(struct gpio_chip *chip, unsigned offset)
	87	{
	88	struct snd_soc_codec *codec = gpio_to_codec(chip);
	89	int ret;
	90
	91	ret = snd_soc_read(codec, AC97_GPIO_STATUS);
	92	dev_dbg(codec->dev, "get gpio %d : %d\n", offset,
	93	ret < 0 ? ret : ret & (1 << offset));
	94
34015f5e	95	return ret < 0 ? ret : !!(ret & (1 << offset));
9bf5c3d1 RJ	96	}
	97
	98	static void snd_soc_ac97_gpio_set(struct gpio_chip *chip, unsigned offset,
	99	int value)
	100	{
	101	struct snd_ac97_gpio_priv *gpio_priv =
	102	container_of(chip, struct snd_ac97_gpio_priv, gpio_chip);
	103	struct snd_soc_codec *codec = gpio_to_codec(chip);
	104
	105	gpio_priv->gpios_set &= ~(1 << offset);
	106	gpio_priv->gpios_set \|= (!!value) << offset;
	107	snd_soc_write(codec, AC97_GPIO_STATUS, gpio_priv->gpios_set);
	108	dev_dbg(codec->dev, "set gpio %d to %d\n", offset, !!value);
	109	}
	110
	111	static int snd_soc_ac97_gpio_direction_out(struct gpio_chip *chip,
	112	unsigned offset, int value)
	113	{
	114	struct snd_soc_codec *codec = gpio_to_codec(chip);
	115
	116	dev_dbg(codec->dev, "set gpio %d to output\n", offset);
	117	snd_soc_ac97_gpio_set(chip, offset, value);
	118	return snd_soc_update_bits(codec, AC97_GPIO_CFG, 1 << offset, 0);
	119	}
	120
	121	static struct gpio_chip snd_soc_ac97_gpio_chip = {
	122	.label = "snd_soc_ac97",
	123	.owner = THIS_MODULE,
	124	.request = snd_soc_ac97_gpio_request,
	125	.direction_input = snd_soc_ac97_gpio_direction_in,
	126	.get = snd_soc_ac97_gpio_get,
	127	.direction_output = snd_soc_ac97_gpio_direction_out,
	128	.set = snd_soc_ac97_gpio_set,
	129	.can_sleep = 1,
	130	};
	131
	132	static int snd_soc_ac97_init_gpio(struct snd_ac97 *ac97,
	133	struct snd_soc_codec *codec)
	134	{
	135	struct snd_ac97_gpio_priv *gpio_priv;
	136	int ret;
	137
	138	gpio_priv = devm_kzalloc(codec->dev, sizeof(*gpio_priv), GFP_KERNEL);
	139	if (!gpio_priv)
	140	return -ENOMEM;
	141	ac97->gpio_priv = gpio_priv;
	142	gpio_priv->codec = codec;
	143	gpio_priv->gpio_chip = snd_soc_ac97_gpio_chip;
	144	gpio_priv->gpio_chip.ngpio = AC97_NUM_GPIOS;
	145	gpio_priv->gpio_chip.dev = codec->dev;
	146	gpio_priv->gpio_chip.base = -1;
	147
	148	ret = gpiochip_add(&gpio_priv->gpio_chip);
	149	if (ret != 0)
	150	dev_err(codec->dev, "Failed to add GPIOs: %d\n", ret);
	151	return ret;
	152	}
	153
	154	static void snd_soc_ac97_free_gpio(struct snd_ac97 *ac97)
	155	{
	156	gpiochip_remove(&ac97->gpio_priv->gpio_chip);
	157	}
	158	#else
	159	static int snd_soc_ac97_init_gpio(struct snd_ac97 *ac97,
160	struct snd_soc_codec *codec)
161	{
162	return 0;
163	}
164
165	static void snd_soc_ac97_free_gpio(struct snd_ac97 *ac97)
166	{
167	}
168	#endif
169
336b8423	170	/**
47e03941 LPC	171	* snd_soc_alloc_ac97_codec() - Allocate new a AC'97 device
47e03941 LPC	172	* @codec: The CODEC for which to create the AC'97 device
336b8423	173	*
47e03941 LPC	174	* Allocated a new snd_ac97 device and intializes it, but does not yet register
	175	* it. The caller is responsible to either call device_add(&ac97->dev) to
	176	* register the device, or to call put_device(&ac97->dev) to free the device.
	177	*
	178	* Returns: A snd_ac97 device or a PTR_ERR in case of an error.
336b8423	179	*/
47e03941	180	struct snd_ac97 snd_soc_alloc_ac97_codec(struct snd_soc_codec codec)
336b8423	181	{
358a8bb5	182	struct snd_ac97 *ac97;
6794f709	183
358a8bb5 LPC	184	ac97 = kzalloc(sizeof(struct snd_ac97), GFP_KERNEL);
	185	if (ac97 == NULL)
	186	return ERR_PTR(-ENOMEM);
336b8423	187
358a8bb5 LPC	188	ac97->bus = &soc_ac97_bus;
358a8bb5 LPC	189	ac97->num = 0;
6794f709	190
358a8bb5 LPC	191	ac97->dev.bus = &ac97_bus_type;
	192	ac97->dev.parent = codec->component.card->dev;
	193	ac97->dev.release = soc_ac97_device_release;
336b8423	194
358a8bb5	195	dev_set_name(&ac97->dev, "%d-%d:%s",
6794f709 LPC	196	codec->component.card->snd_card->number, 0,
	197	codec->component.name);
	198
47e03941 LPC	199	device_initialize(&ac97->dev);
	200
	201	return ac97;
	202	}
	203	EXPORT_SYMBOL(snd_soc_alloc_ac97_codec);
	204
	205	/**
	206	* snd_soc_new_ac97_codec - initailise AC97 device
	207	* @codec: audio codec
7361fbea LPC	208	* @id: The expected device ID
7361fbea LPC	209	* @id_mask: Mask that is applied to the device ID before comparing with @id
47e03941 LPC	210	*
47e03941 LPC	211	* Initialises AC97 codec resources for use by ad-hoc devices only.
7361fbea LPC	212	*
	213	* If @id is not 0 this function will reset the device, then read the ID from
	214	* the device and check if it matches the expected ID. If it doesn't match an
	215	* error will be returned and device will not be registered.
	216	*
	217	* Returns: A PTR_ERR() on failure or a valid snd_ac97 struct on success.
47e03941	218	*/
7361fbea LPC	219	struct snd_ac97 snd_soc_new_ac97_codec(struct snd_soc_codec codec,
7361fbea LPC	220	unsigned int id, unsigned int id_mask)
47e03941 LPC	221	{
	222	struct snd_ac97 *ac97;
	223	int ret;
	224
	225	ac97 = snd_soc_alloc_ac97_codec(codec);
	226	if (IS_ERR(ac97))
	227	return ac97;
	228
7361fbea LPC	229	if (id) {
	230	ret = snd_ac97_reset(ac97, false, id, id_mask);
	231	if (ret < 0) {
	232	dev_err(codec->dev, "Failed to reset AC97 device: %d\n",
	233	ret);
	234	goto err_put_device;
	235	}
358a8bb5	236	}
336b8423	237
7361fbea LPC	238	ret = device_add(&ac97->dev);
	239	if (ret)
	240	goto err_put_device;
	241
9bf5c3d1 RJ	242	ret = snd_soc_ac97_init_gpio(ac97, codec);
	243	if (ret)
	244	goto err_put_device;
	245
358a8bb5	246	return ac97;
7361fbea LPC	247
	248	err_put_device:
	249	put_device(&ac97->dev);
	250	return ERR_PTR(ret);
336b8423 LPC	251	}
	252	EXPORT_SYMBOL_GPL(snd_soc_new_ac97_codec);
	253
	254	/**
	255	* snd_soc_free_ac97_codec - free AC97 codec device
	256	* @codec: audio codec
	257	*
	258	* Frees AC97 codec device resources.
	259	*/
358a8bb5	260	void snd_soc_free_ac97_codec(struct snd_ac97 *ac97)
336b8423	261	{
9bf5c3d1	262	snd_soc_ac97_free_gpio(ac97);
358a8bb5 LPC	263	device_del(&ac97->dev);
	264	ac97->bus = NULL;
	265	put_device(&ac97->dev);
336b8423 LPC	266	}
	267	EXPORT_SYMBOL_GPL(snd_soc_free_ac97_codec);
	268
	269	static struct snd_ac97_reset_cfg snd_ac97_rst_cfg;
	270
	271	static void snd_soc_ac97_warm_reset(struct snd_ac97 *ac97)
	272	{
	273	struct pinctrl *pctl = snd_ac97_rst_cfg.pctl;
	274
	275	pinctrl_select_state(pctl, snd_ac97_rst_cfg.pstate_warm_reset);
	276
	277	gpio_direction_output(snd_ac97_rst_cfg.gpio_sync, 1);
	278
	279	udelay(10);
	280
	281	gpio_direction_output(snd_ac97_rst_cfg.gpio_sync, 0);
	282
	283	pinctrl_select_state(pctl, snd_ac97_rst_cfg.pstate_run);
	284	msleep(2);
	285	}
	286
	287	static void snd_soc_ac97_reset(struct snd_ac97 *ac97)
	288	{
	289	struct pinctrl *pctl = snd_ac97_rst_cfg.pctl;
	290
	291	pinctrl_select_state(pctl, snd_ac97_rst_cfg.pstate_reset);
	292
	293	gpio_direction_output(snd_ac97_rst_cfg.gpio_sync, 0);
	294	gpio_direction_output(snd_ac97_rst_cfg.gpio_sdata, 0);
	295	gpio_direction_output(snd_ac97_rst_cfg.gpio_reset, 0);
	296
	297	udelay(10);
	298
	299	gpio_direction_output(snd_ac97_rst_cfg.gpio_reset, 1);
	300
	301	pinctrl_select_state(pctl, snd_ac97_rst_cfg.pstate_run);
	302	msleep(2);
	303	}
	304
	305	static int snd_soc_ac97_parse_pinctl(struct device *dev,
	306	struct snd_ac97_reset_cfg *cfg)
	307	{
	308	struct pinctrl *p;
	309	struct pinctrl_state *state;
	310	int gpio;
	311	int ret;
	312
	313	p = devm_pinctrl_get(dev);
	314	if (IS_ERR(p)) {
	315	dev_err(dev, "Failed to get pinctrl\n");
	316	return PTR_ERR(p);
	317	}
	318	cfg->pctl = p;
	319
	320	state = pinctrl_lookup_state(p, "ac97-reset");
	321	if (IS_ERR(state)) {
	322	dev_err(dev, "Can't find pinctrl state ac97-reset\n");
	323	return PTR_ERR(state);
	324	}
	325	cfg->pstate_reset = state;
	326
	327	state = pinctrl_lookup_state(p, "ac97-warm-reset");
	328	if (IS_ERR(state)) {
	329	dev_err(dev, "Can't find pinctrl state ac97-warm-reset\n");
330	return PTR_ERR(state);
331	}
332	cfg->pstate_warm_reset = state;
333
334	state = pinctrl_lookup_state(p, "ac97-running");
335	if (IS_ERR(state)) {
336	dev_err(dev, "Can't find pinctrl state ac97-running\n");
337	return PTR_ERR(state);
338	}
339	cfg->pstate_run = state;
340
341	gpio = of_get_named_gpio(dev->of_node, "ac97-gpios", 0);
342	if (gpio < 0) {
343	dev_err(dev, "Can't find ac97-sync gpio\n");
344	return gpio;
345	}
346	ret = devm_gpio_request(dev, gpio, "AC97 link sync");
347	if (ret) {
348	dev_err(dev, "Failed requesting ac97-sync gpio\n");
349	return ret;
350	}
351	cfg->gpio_sync = gpio;
352
353	gpio = of_get_named_gpio(dev->of_node, "ac97-gpios", 1);
354	if (gpio < 0) {
355	dev_err(dev, "Can't find ac97-sdata gpio %d\n", gpio);
356	return gpio;
357	}
358	ret = devm_gpio_request(dev, gpio, "AC97 link sdata");
359	if (ret) {
360	dev_err(dev, "Failed requesting ac97-sdata gpio\n");
361	return ret;
362	}
363	cfg->gpio_sdata = gpio;
364
365	gpio = of_get_named_gpio(dev->of_node, "ac97-gpios", 2);
366	if (gpio < 0) {
367	dev_err(dev, "Can't find ac97-reset gpio\n");
368	return gpio;
369	}
370	ret = devm_gpio_request(dev, gpio, "AC97 link reset");
371	if (ret) {
372	dev_err(dev, "Failed requesting ac97-reset gpio\n");
373	return ret;
374	}
375	cfg->gpio_reset = gpio;
376
377	return 0;
378	}
379
380	struct snd_ac97_bus_ops *soc_ac97_ops;
381	EXPORT_SYMBOL_GPL(soc_ac97_ops);
382
383	int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops)
384	{
385	if (ops == soc_ac97_ops)
386	return 0;
387
388	if (soc_ac97_ops && ops)
389	return -EBUSY;
390
391	soc_ac97_ops = ops;
eda1a701	392	soc_ac97_bus.ops = ops;
336b8423 LPC	393
	394	return 0;
	395	}
	396	EXPORT_SYMBOL_GPL(snd_soc_set_ac97_ops);
	397
	398	/**
	399	* snd_soc_set_ac97_ops_of_reset - Set ac97 ops with generic ac97 reset functions
	400	*
	401	* This function sets the reset and warm_reset properties of ops and parses
	402	* the device node of pdev to get pinctrl states and gpio numbers to use.
	403	*/
	404	int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
	405	struct platform_device *pdev)
	406	{
	407	struct device *dev = &pdev->dev;
	408	struct snd_ac97_reset_cfg cfg;
	409	int ret;
	410
	411	ret = snd_soc_ac97_parse_pinctl(dev, &cfg);
	412	if (ret)
	413	return ret;
	414
	415	ret = snd_soc_set_ac97_ops(ops);
	416	if (ret)
	417	return ret;
	418
	419	ops->warm_reset = snd_soc_ac97_warm_reset;
	420	ops->reset = snd_soc_ac97_reset;
	421
	422	snd_ac97_rst_cfg = cfg;
	423	return 0;
	424	}
	425	EXPORT_SYMBOL_GPL(snd_soc_set_ac97_ops_of_reset);