cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

soc-ac97.c (10831B)


      1// SPDX-License-Identifier: GPL-2.0+
      2//
      3// soc-ac97.c  --  ALSA SoC Audio Layer AC97 support
      4//
      5// Copyright 2005 Wolfson Microelectronics PLC.
      6// Copyright 2005 Openedhand Ltd.
      7// Copyright (C) 2010 Slimlogic Ltd.
      8// Copyright (C) 2010 Texas Instruments Inc.
      9//
     10// Author: Liam Girdwood <lrg@slimlogic.co.uk>
     11//         with code, comments and ideas from :-
     12//         Richard Purdie <richard@openedhand.com>
     13
     14#include <linux/ctype.h>
     15#include <linux/delay.h>
     16#include <linux/export.h>
     17#include <linux/gpio.h>
     18#include <linux/gpio/driver.h>
     19#include <linux/init.h>
     20#include <linux/of_gpio.h>
     21#include <linux/of.h>
     22#include <linux/pinctrl/consumer.h>
     23#include <linux/slab.h>
     24#include <sound/ac97_codec.h>
     25#include <sound/soc.h>
     26
     27struct snd_ac97_reset_cfg {
     28	struct pinctrl *pctl;
     29	struct pinctrl_state *pstate_reset;
     30	struct pinctrl_state *pstate_warm_reset;
     31	struct pinctrl_state *pstate_run;
     32	int gpio_sdata;
     33	int gpio_sync;
     34	int gpio_reset;
     35};
     36
     37static struct snd_ac97_bus soc_ac97_bus = {
     38	.ops = NULL, /* Gets initialized in snd_soc_set_ac97_ops() */
     39};
     40
     41static void soc_ac97_device_release(struct device *dev)
     42{
     43	kfree(to_ac97_t(dev));
     44}
     45
     46#ifdef CONFIG_GPIOLIB
     47struct snd_ac97_gpio_priv {
     48	struct gpio_chip gpio_chip;
     49	unsigned int gpios_set;
     50	struct snd_soc_component *component;
     51};
     52
     53static inline struct snd_soc_component *gpio_to_component(struct gpio_chip *chip)
     54{
     55	struct snd_ac97_gpio_priv *gpio_priv = gpiochip_get_data(chip);
     56
     57	return gpio_priv->component;
     58}
     59
     60static int snd_soc_ac97_gpio_request(struct gpio_chip *chip, unsigned offset)
     61{
     62	if (offset >= AC97_NUM_GPIOS)
     63		return -EINVAL;
     64
     65	return 0;
     66}
     67
     68static int snd_soc_ac97_gpio_direction_in(struct gpio_chip *chip,
     69					  unsigned offset)
     70{
     71	struct snd_soc_component *component = gpio_to_component(chip);
     72
     73	dev_dbg(component->dev, "set gpio %d to output\n", offset);
     74	return snd_soc_component_update_bits(component, AC97_GPIO_CFG,
     75				   1 << offset, 1 << offset);
     76}
     77
     78static int snd_soc_ac97_gpio_get(struct gpio_chip *chip, unsigned offset)
     79{
     80	struct snd_soc_component *component = gpio_to_component(chip);
     81	int ret;
     82
     83	ret = snd_soc_component_read(component, AC97_GPIO_STATUS);
     84
     85	dev_dbg(component->dev, "get gpio %d : %d\n", offset,
     86		ret & (1 << offset));
     87
     88	return !!(ret & (1 << offset));
     89}
     90
     91static void snd_soc_ac97_gpio_set(struct gpio_chip *chip, unsigned offset,
     92				  int value)
     93{
     94	struct snd_ac97_gpio_priv *gpio_priv = gpiochip_get_data(chip);
     95	struct snd_soc_component *component = gpio_to_component(chip);
     96
     97	gpio_priv->gpios_set &= ~(1 << offset);
     98	gpio_priv->gpios_set |= (!!value) << offset;
     99	snd_soc_component_write(component, AC97_GPIO_STATUS,
    100				gpio_priv->gpios_set);
    101	dev_dbg(component->dev, "set gpio %d to %d\n", offset, !!value);
    102}
    103
    104static int snd_soc_ac97_gpio_direction_out(struct gpio_chip *chip,
    105				     unsigned offset, int value)
    106{
    107	struct snd_soc_component *component = gpio_to_component(chip);
    108
    109	dev_dbg(component->dev, "set gpio %d to output\n", offset);
    110	snd_soc_ac97_gpio_set(chip, offset, value);
    111	return snd_soc_component_update_bits(component, AC97_GPIO_CFG,
    112					     1 << offset, 0);
    113}
    114
    115static const struct gpio_chip snd_soc_ac97_gpio_chip = {
    116	.label			= "snd_soc_ac97",
    117	.owner			= THIS_MODULE,
    118	.request		= snd_soc_ac97_gpio_request,
    119	.direction_input	= snd_soc_ac97_gpio_direction_in,
    120	.get			= snd_soc_ac97_gpio_get,
    121	.direction_output	= snd_soc_ac97_gpio_direction_out,
    122	.set			= snd_soc_ac97_gpio_set,
    123	.can_sleep		= 1,
    124};
    125
    126static int snd_soc_ac97_init_gpio(struct snd_ac97 *ac97,
    127				  struct snd_soc_component *component)
    128{
    129	struct snd_ac97_gpio_priv *gpio_priv;
    130	int ret;
    131
    132	gpio_priv = devm_kzalloc(component->dev, sizeof(*gpio_priv), GFP_KERNEL);
    133	if (!gpio_priv)
    134		return -ENOMEM;
    135	ac97->gpio_priv = gpio_priv;
    136	gpio_priv->component = component;
    137	gpio_priv->gpio_chip = snd_soc_ac97_gpio_chip;
    138	gpio_priv->gpio_chip.ngpio = AC97_NUM_GPIOS;
    139	gpio_priv->gpio_chip.parent = component->dev;
    140	gpio_priv->gpio_chip.base = -1;
    141
    142	ret = gpiochip_add_data(&gpio_priv->gpio_chip, gpio_priv);
    143	if (ret != 0)
    144		dev_err(component->dev, "Failed to add GPIOs: %d\n", ret);
    145	return ret;
    146}
    147
    148static void snd_soc_ac97_free_gpio(struct snd_ac97 *ac97)
    149{
    150	gpiochip_remove(&ac97->gpio_priv->gpio_chip);
    151}
    152#else
    153static int snd_soc_ac97_init_gpio(struct snd_ac97 *ac97,
    154				  struct snd_soc_component *component)
    155{
    156	return 0;
    157}
    158
    159static void snd_soc_ac97_free_gpio(struct snd_ac97 *ac97)
    160{
    161}
    162#endif
    163
    164/**
    165 * snd_soc_alloc_ac97_component() - Allocate new a AC'97 device
    166 * @component: The COMPONENT for which to create the AC'97 device
    167 *
    168 * Allocated a new snd_ac97 device and intializes it, but does not yet register
    169 * it. The caller is responsible to either call device_add(&ac97->dev) to
    170 * register the device, or to call put_device(&ac97->dev) to free the device.
    171 *
    172 * Returns: A snd_ac97 device or a PTR_ERR in case of an error.
    173 */
    174struct snd_ac97 *snd_soc_alloc_ac97_component(struct snd_soc_component *component)
    175{
    176	struct snd_ac97 *ac97;
    177
    178	ac97 = kzalloc(sizeof(struct snd_ac97), GFP_KERNEL);
    179	if (ac97 == NULL)
    180		return ERR_PTR(-ENOMEM);
    181
    182	ac97->bus = &soc_ac97_bus;
    183	ac97->num = 0;
    184
    185	ac97->dev.bus = &ac97_bus_type;
    186	ac97->dev.parent = component->card->dev;
    187	ac97->dev.release = soc_ac97_device_release;
    188
    189	dev_set_name(&ac97->dev, "%d-%d:%s",
    190		     component->card->snd_card->number, 0,
    191		     component->name);
    192
    193	device_initialize(&ac97->dev);
    194
    195	return ac97;
    196}
    197EXPORT_SYMBOL(snd_soc_alloc_ac97_component);
    198
    199/**
    200 * snd_soc_new_ac97_component - initailise AC97 device
    201 * @component: audio component
    202 * @id: The expected device ID
    203 * @id_mask: Mask that is applied to the device ID before comparing with @id
    204 *
    205 * Initialises AC97 component resources for use by ad-hoc devices only.
    206 *
    207 * If @id is not 0 this function will reset the device, then read the ID from
    208 * the device and check if it matches the expected ID. If it doesn't match an
    209 * error will be returned and device will not be registered.
    210 *
    211 * Returns: A PTR_ERR() on failure or a valid snd_ac97 struct on success.
    212 */
    213struct snd_ac97 *snd_soc_new_ac97_component(struct snd_soc_component *component,
    214	unsigned int id, unsigned int id_mask)
    215{
    216	struct snd_ac97 *ac97;
    217	int ret;
    218
    219	ac97 = snd_soc_alloc_ac97_component(component);
    220	if (IS_ERR(ac97))
    221		return ac97;
    222
    223	if (id) {
    224		ret = snd_ac97_reset(ac97, false, id, id_mask);
    225		if (ret < 0) {
    226			dev_err(component->dev, "Failed to reset AC97 device: %d\n",
    227				ret);
    228			goto err_put_device;
    229		}
    230	}
    231
    232	ret = device_add(&ac97->dev);
    233	if (ret)
    234		goto err_put_device;
    235
    236	ret = snd_soc_ac97_init_gpio(ac97, component);
    237	if (ret)
    238		goto err_put_device;
    239
    240	return ac97;
    241
    242err_put_device:
    243	put_device(&ac97->dev);
    244	return ERR_PTR(ret);
    245}
    246EXPORT_SYMBOL_GPL(snd_soc_new_ac97_component);
    247
    248/**
    249 * snd_soc_free_ac97_component - free AC97 component device
    250 * @ac97: snd_ac97 device to be freed
    251 *
    252 * Frees AC97 component device resources.
    253 */
    254void snd_soc_free_ac97_component(struct snd_ac97 *ac97)
    255{
    256	snd_soc_ac97_free_gpio(ac97);
    257	device_del(&ac97->dev);
    258	ac97->bus = NULL;
    259	put_device(&ac97->dev);
    260}
    261EXPORT_SYMBOL_GPL(snd_soc_free_ac97_component);
    262
    263static struct snd_ac97_reset_cfg snd_ac97_rst_cfg;
    264
    265static void snd_soc_ac97_warm_reset(struct snd_ac97 *ac97)
    266{
    267	struct pinctrl *pctl = snd_ac97_rst_cfg.pctl;
    268
    269	pinctrl_select_state(pctl, snd_ac97_rst_cfg.pstate_warm_reset);
    270
    271	gpio_direction_output(snd_ac97_rst_cfg.gpio_sync, 1);
    272
    273	udelay(10);
    274
    275	gpio_direction_output(snd_ac97_rst_cfg.gpio_sync, 0);
    276
    277	pinctrl_select_state(pctl, snd_ac97_rst_cfg.pstate_run);
    278	msleep(2);
    279}
    280
    281static void snd_soc_ac97_reset(struct snd_ac97 *ac97)
    282{
    283	struct pinctrl *pctl = snd_ac97_rst_cfg.pctl;
    284
    285	pinctrl_select_state(pctl, snd_ac97_rst_cfg.pstate_reset);
    286
    287	gpio_direction_output(snd_ac97_rst_cfg.gpio_sync, 0);
    288	gpio_direction_output(snd_ac97_rst_cfg.gpio_sdata, 0);
    289	gpio_direction_output(snd_ac97_rst_cfg.gpio_reset, 0);
    290
    291	udelay(10);
    292
    293	gpio_direction_output(snd_ac97_rst_cfg.gpio_reset, 1);
    294
    295	pinctrl_select_state(pctl, snd_ac97_rst_cfg.pstate_run);
    296	msleep(2);
    297}
    298
    299static int snd_soc_ac97_parse_pinctl(struct device *dev,
    300		struct snd_ac97_reset_cfg *cfg)
    301{
    302	struct pinctrl *p;
    303	struct pinctrl_state *state;
    304	int gpio;
    305	int ret;
    306
    307	p = devm_pinctrl_get(dev);
    308	if (IS_ERR(p)) {
    309		dev_err(dev, "Failed to get pinctrl\n");
    310		return PTR_ERR(p);
    311	}
    312	cfg->pctl = p;
    313
    314	state = pinctrl_lookup_state(p, "ac97-reset");
    315	if (IS_ERR(state)) {
    316		dev_err(dev, "Can't find pinctrl state ac97-reset\n");
    317		return PTR_ERR(state);
    318	}
    319	cfg->pstate_reset = state;
    320
    321	state = pinctrl_lookup_state(p, "ac97-warm-reset");
    322	if (IS_ERR(state)) {
    323		dev_err(dev, "Can't find pinctrl state ac97-warm-reset\n");
    324		return PTR_ERR(state);
    325	}
    326	cfg->pstate_warm_reset = state;
    327
    328	state = pinctrl_lookup_state(p, "ac97-running");
    329	if (IS_ERR(state)) {
    330		dev_err(dev, "Can't find pinctrl state ac97-running\n");
    331		return PTR_ERR(state);
    332	}
    333	cfg->pstate_run = state;
    334
    335	gpio = of_get_named_gpio(dev->of_node, "ac97-gpios", 0);
    336	if (gpio < 0) {
    337		dev_err(dev, "Can't find ac97-sync gpio\n");
    338		return gpio;
    339	}
    340	ret = devm_gpio_request(dev, gpio, "AC97 link sync");
    341	if (ret) {
    342		dev_err(dev, "Failed requesting ac97-sync gpio\n");
    343		return ret;
    344	}
    345	cfg->gpio_sync = gpio;
    346
    347	gpio = of_get_named_gpio(dev->of_node, "ac97-gpios", 1);
    348	if (gpio < 0) {
    349		dev_err(dev, "Can't find ac97-sdata gpio %d\n", gpio);
    350		return gpio;
    351	}
    352	ret = devm_gpio_request(dev, gpio, "AC97 link sdata");
    353	if (ret) {
    354		dev_err(dev, "Failed requesting ac97-sdata gpio\n");
    355		return ret;
    356	}
    357	cfg->gpio_sdata = gpio;
    358
    359	gpio = of_get_named_gpio(dev->of_node, "ac97-gpios", 2);
    360	if (gpio < 0) {
    361		dev_err(dev, "Can't find ac97-reset gpio\n");
    362		return gpio;
    363	}
    364	ret = devm_gpio_request(dev, gpio, "AC97 link reset");
    365	if (ret) {
    366		dev_err(dev, "Failed requesting ac97-reset gpio\n");
    367		return ret;
    368	}
    369	cfg->gpio_reset = gpio;
    370
    371	return 0;
    372}
    373
    374struct snd_ac97_bus_ops *soc_ac97_ops;
    375EXPORT_SYMBOL_GPL(soc_ac97_ops);
    376
    377int snd_soc_set_ac97_ops(struct snd_ac97_bus_ops *ops)
    378{
    379	if (ops == soc_ac97_ops)
    380		return 0;
    381
    382	if (soc_ac97_ops && ops)
    383		return -EBUSY;
    384
    385	soc_ac97_ops = ops;
    386	soc_ac97_bus.ops = ops;
    387
    388	return 0;
    389}
    390EXPORT_SYMBOL_GPL(snd_soc_set_ac97_ops);
    391
    392/**
    393 * snd_soc_set_ac97_ops_of_reset - Set ac97 ops with generic ac97 reset functions
    394 * @ops: bus ops
    395 * @pdev: platform device
    396 *
    397 * This function sets the reset and warm_reset properties of ops and parses
    398 * the device node of pdev to get pinctrl states and gpio numbers to use.
    399 */
    400int snd_soc_set_ac97_ops_of_reset(struct snd_ac97_bus_ops *ops,
    401		struct platform_device *pdev)
    402{
    403	struct device *dev = &pdev->dev;
    404	struct snd_ac97_reset_cfg cfg;
    405	int ret;
    406
    407	ret = snd_soc_ac97_parse_pinctl(dev, &cfg);
    408	if (ret)
    409		return ret;
    410
    411	ret = snd_soc_set_ac97_ops(ops);
    412	if (ret)
    413		return ret;
    414
    415	ops->warm_reset = snd_soc_ac97_warm_reset;
    416	ops->reset = snd_soc_ac97_reset;
    417
    418	snd_ac97_rst_cfg = cfg;
    419	return 0;
    420}
    421EXPORT_SYMBOL_GPL(snd_soc_set_ac97_ops_of_reset);