[linux-2.6-block.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 = gpiochip_get_data(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 = gpiochip_get_data(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.parent = codec->dev;
	gpio_priv->gpio_chip.base = -1;

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