/* * 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 * with code, comments and ideas from :- * Richard Purdie * * 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 #include #include #include #include #include #include #include #include #include #include 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);