sound/soc/soc-ac97.c

   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
  27 struct 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
  37 static struct snd_ac97_bus soc_ac97_bus = {
  38         .ops = NULL, /* Gets initialized in snd_soc_set_ac97_ops() */
  39 };
  40
  41 static void soc_ac97_device_release(struct device *dev)
  42 {
  43         kfree(to_ac97_t(dev));
  44 }
  45
  46 #ifdef CONFIG_GPIOLIB
  47 struct snd_ac97_gpio_priv {
  48         struct gpio_chip gpio_chip;
  49         unsigned int gpios_set;
  50         struct snd_soc_component *component;
  51 };
  52
  53 static 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
  60 static 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
  68 static 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
  78 static 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
  91 static 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
 104 static 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
 115 static 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
 126 static 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
 148 static void snd_soc_ac97_free_gpio(struct snd_ac97 *ac97)
 149 {
 150         gpiochip_remove(&ac97->gpio_priv->gpio_chip);
 151 }
 152 #else
 153 static int snd_soc_ac97_init_gpio(struct snd_ac97 *ac97,
 154                                   struct snd_soc_component *component)
 155 {
 156         return 0;
 157 }
 158
 159 static 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  */
 174 struct 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 }
 197 EXPORT_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  */
 213 struct 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
 242 err_put_device:
 243         put_device(&ac97->dev);
 244         return ERR_PTR(ret);
 245 }
 246 EXPORT_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  */
 254 void 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 }
 261 EXPORT_SYMBOL_GPL(snd_soc_free_ac97_component);
 262
 263 static struct snd_ac97_reset_cfg snd_ac97_rst_cfg;
 264
 265 static 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
 281 static 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
 299 static 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
 374 struct snd_ac97_bus_ops *soc_ac97_ops;
 375 EXPORT_SYMBOL_GPL(soc_ac97_ops);
 376
 377 int 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 }
 390 EXPORT_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  */
 400 int 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 }
 421 EXPORT_SYMBOL_GPL(snd_soc_set_ac97_ops_of_reset);