mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-10-29 23:53:32 +00:00
6794f709b7
We have all the information and dependencies we need to initialize and register the device available in snd_soc_new_ac97_codec(). So there is no need to delay the device registration until after the card itself as been registered. This makes the code significantly simpler and also makes it possible to use the AC'97 device in the CODECs probe function. The later will be required to be able to convert the AC'97 CODEC drivers to regmap. Signed-off-by: Lars-Peter Clausen <lars@metafoo.de> Signed-off-by: Mark Brown <broonie@kernel.org>
254 lines
6.1 KiB
C
254 lines
6.1 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_new_ac97_codec - initailise AC97 device
|
|
* @codec: audio codec
|
|
*
|
|
* Initialises AC97 codec resources for use by ad-hoc devices only.
|
|
*/
|
|
int snd_soc_new_ac97_codec(struct snd_soc_codec *codec)
|
|
{
|
|
int ret;
|
|
|
|
codec->ac97 = kzalloc(sizeof(struct snd_ac97), GFP_KERNEL);
|
|
if (codec->ac97 == NULL)
|
|
return -ENOMEM;
|
|
|
|
codec->ac97->bus = &soc_ac97_bus;
|
|
codec->ac97->num = 0;
|
|
|
|
codec->ac97->dev.bus = &ac97_bus_type;
|
|
codec->ac97->dev.parent = codec->component.card->dev;
|
|
codec->ac97->dev.release = soc_ac97_device_release;
|
|
|
|
dev_set_name(&codec->ac97->dev, "%d-%d:%s",
|
|
codec->component.card->snd_card->number, 0,
|
|
codec->component.name);
|
|
|
|
ret = device_register(&codec->ac97->dev);
|
|
if (ret)
|
|
put_device(&codec->ac97->dev);
|
|
|
|
return 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_soc_codec *codec)
|
|
{
|
|
device_del(&codec->ac97->dev);
|
|
codec->ac97->bus = NULL;
|
|
put_device(&codec->ac97->dev);
|
|
codec->ac97 = NULL;
|
|
}
|
|
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);
|