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); 422