forked from Minki/linux
47e039413c
In some cases it is necessary to before additional operations after the
device has been initialized and before the device is registered. This can
for example be resetting the device.
This patch introduces a new function snd_soc_alloc_ac97_codec() which is
similar to snd_soc_new_ac97_codec() except that it does not register the
device. Any users of snd_soc_alloc_ac97_codec() are responsible for calling
device_add() manually.
Fixes: 6794f709b7 ("ASoC: ac97: Drop delayed device registration")
Reported-by: Manuel Lauss <manuel.lauss@gmail.com>
Signed-off-by: Lars-Peter Clausen <lars@metafoo.de>
Tested-by: Manuel Lauss <manuel.lauss@gmail.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
Cc: stable@vger.kernel.org
281 lines
6.7 KiB
C
281 lines
6.7 KiB
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/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;
|
|
};
|
|
|
|
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));
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
*
|
|
* Initialises AC97 codec resources for use by ad-hoc devices only.
|
|
*/
|
|
struct snd_ac97 *snd_soc_new_ac97_codec(struct snd_soc_codec *codec)
|
|
{
|
|
struct snd_ac97 *ac97;
|
|
int ret;
|
|
|
|
ac97 = snd_soc_alloc_ac97_codec(codec);
|
|
if (IS_ERR(ac97))
|
|
return ac97;
|
|
|
|
ret = device_add(&ac97->dev);
|
|
if (ret) {
|
|
put_device(&ac97->dev);
|
|
return ERR_PTR(ret);
|
|
}
|
|
|
|
return ac97;
|
|
}
|
|
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)
|
|
{
|
|
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);
|