mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-05 17:16:41 +07:00
358a8bb562
Now that the ASoC core no longer needs a handle to the AC'97 device that is associated with a CODEC we can remove it from the snd_soc_codec struct and push it into the individual driver state structs like we do for other communication buses. Doing so creates a clean separation between the AC'97 bus support and the ASoC core. Signed-off-by: Lars-Peter Clausen <lars@metafoo.de> Acked-by: Charles Keepax <ckeepax@opensource.wolfsonmicro.com> Signed-off-by: Mark Brown <broonie@kernel.org>
257 lines
6.0 KiB
C
257 lines
6.0 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.
|
|
*/
|
|
struct snd_ac97 *snd_soc_new_ac97_codec(struct snd_soc_codec *codec)
|
|
{
|
|
struct snd_ac97 *ac97;
|
|
int ret;
|
|
|
|
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);
|
|
|
|
ret = device_register(&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);
|