1 /* 2 * soc-jack.c -- ALSA SoC jack handling 3 * 4 * Copyright 2008 Wolfson Microelectronics PLC. 5 * 6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com> 7 * 8 * This program is free software; you can redistribute it and/or modify it 9 * under the terms of the GNU General Public License as published by the 10 * Free Software Foundation; either version 2 of the License, or (at your 11 * option) any later version. 12 */ 13 14 #include <sound/jack.h> 15 #include <sound/soc.h> 16 #include <linux/gpio.h> 17 #include <linux/gpio/consumer.h> 18 #include <linux/interrupt.h> 19 #include <linux/workqueue.h> 20 #include <linux/delay.h> 21 #include <linux/export.h> 22 #include <trace/events/asoc.h> 23 24 /** 25 * snd_soc_jack_new - Create a new jack 26 * @codec: ASoC codec 27 * @id: an identifying string for this jack 28 * @type: a bitmask of enum snd_jack_type values that can be detected by 29 * this jack 30 * @jack: structure to use for the jack 31 * 32 * Creates a new jack object. 33 * 34 * Returns zero if successful, or a negative error code on failure. 35 * On success jack will be initialised. 36 */ 37 int snd_soc_jack_new(struct snd_soc_codec *codec, const char *id, int type, 38 struct snd_soc_jack *jack) 39 { 40 mutex_init(&jack->mutex); 41 jack->codec = codec; 42 INIT_LIST_HEAD(&jack->pins); 43 INIT_LIST_HEAD(&jack->jack_zones); 44 BLOCKING_INIT_NOTIFIER_HEAD(&jack->notifier); 45 46 return snd_jack_new(codec->card->snd_card, id, type, &jack->jack); 47 } 48 EXPORT_SYMBOL_GPL(snd_soc_jack_new); 49 50 /** 51 * snd_soc_jack_report - Report the current status for a jack 52 * 53 * @jack: the jack 54 * @status: a bitmask of enum snd_jack_type values that are currently detected. 55 * @mask: a bitmask of enum snd_jack_type values that being reported. 56 * 57 * If configured using snd_soc_jack_add_pins() then the associated 58 * DAPM pins will be enabled or disabled as appropriate and DAPM 59 * synchronised. 60 * 61 * Note: This function uses mutexes and should be called from a 62 * context which can sleep (such as a workqueue). 63 */ 64 void snd_soc_jack_report(struct snd_soc_jack *jack, int status, int mask) 65 { 66 struct snd_soc_codec *codec; 67 struct snd_soc_dapm_context *dapm; 68 struct snd_soc_jack_pin *pin; 69 unsigned int sync = 0; 70 int enable; 71 72 trace_snd_soc_jack_report(jack, mask, status); 73 74 if (!jack) 75 return; 76 77 codec = jack->codec; 78 dapm = &codec->dapm; 79 80 mutex_lock(&jack->mutex); 81 82 jack->status &= ~mask; 83 jack->status |= status & mask; 84 85 trace_snd_soc_jack_notify(jack, status); 86 87 list_for_each_entry(pin, &jack->pins, list) { 88 enable = pin->mask & jack->status; 89 90 if (pin->invert) 91 enable = !enable; 92 93 if (enable) 94 snd_soc_dapm_enable_pin(dapm, pin->pin); 95 else 96 snd_soc_dapm_disable_pin(dapm, pin->pin); 97 98 /* we need to sync for this case only */ 99 sync = 1; 100 } 101 102 /* Report before the DAPM sync to help users updating micbias status */ 103 blocking_notifier_call_chain(&jack->notifier, jack->status, jack); 104 105 if (sync) 106 snd_soc_dapm_sync(dapm); 107 108 snd_jack_report(jack->jack, jack->status); 109 110 mutex_unlock(&jack->mutex); 111 } 112 EXPORT_SYMBOL_GPL(snd_soc_jack_report); 113 114 /** 115 * snd_soc_jack_add_zones - Associate voltage zones with jack 116 * 117 * @jack: ASoC jack 118 * @count: Number of zones 119 * @zone: Array of zones 120 * 121 * After this function has been called the zones specified in the 122 * array will be associated with the jack. 123 */ 124 int snd_soc_jack_add_zones(struct snd_soc_jack *jack, int count, 125 struct snd_soc_jack_zone *zones) 126 { 127 int i; 128 129 for (i = 0; i < count; i++) { 130 INIT_LIST_HEAD(&zones[i].list); 131 list_add(&(zones[i].list), &jack->jack_zones); 132 } 133 return 0; 134 } 135 EXPORT_SYMBOL_GPL(snd_soc_jack_add_zones); 136 137 /** 138 * snd_soc_jack_get_type - Based on the mic bias value, this function returns 139 * the type of jack from the zones declared in the jack type 140 * 141 * @jack: ASoC jack 142 * @micbias_voltage: mic bias voltage at adc channel when jack is plugged in 143 * 144 * Based on the mic bias value passed, this function helps identify 145 * the type of jack from the already declared jack zones 146 */ 147 int snd_soc_jack_get_type(struct snd_soc_jack *jack, int micbias_voltage) 148 { 149 struct snd_soc_jack_zone *zone; 150 151 list_for_each_entry(zone, &jack->jack_zones, list) { 152 if (micbias_voltage >= zone->min_mv && 153 micbias_voltage < zone->max_mv) 154 return zone->jack_type; 155 } 156 return 0; 157 } 158 EXPORT_SYMBOL_GPL(snd_soc_jack_get_type); 159 160 /** 161 * snd_soc_jack_add_pins - Associate DAPM pins with an ASoC jack 162 * 163 * @jack: ASoC jack 164 * @count: Number of pins 165 * @pins: Array of pins 166 * 167 * After this function has been called the DAPM pins specified in the 168 * pins array will have their status updated to reflect the current 169 * state of the jack whenever the jack status is updated. 170 */ 171 int snd_soc_jack_add_pins(struct snd_soc_jack *jack, int count, 172 struct snd_soc_jack_pin *pins) 173 { 174 int i; 175 176 for (i = 0; i < count; i++) { 177 if (!pins[i].pin) { 178 dev_err(jack->codec->dev, "ASoC: No name for pin %d\n", 179 i); 180 return -EINVAL; 181 } 182 if (!pins[i].mask) { 183 dev_err(jack->codec->dev, "ASoC: No mask for pin %d" 184 " (%s)\n", i, pins[i].pin); 185 return -EINVAL; 186 } 187 188 INIT_LIST_HEAD(&pins[i].list); 189 list_add(&(pins[i].list), &jack->pins); 190 } 191 192 /* Update to reflect the last reported status; canned jack 193 * implementations are likely to set their state before the 194 * card has an opportunity to associate pins. 195 */ 196 snd_soc_jack_report(jack, 0, 0); 197 198 return 0; 199 } 200 EXPORT_SYMBOL_GPL(snd_soc_jack_add_pins); 201 202 /** 203 * snd_soc_jack_notifier_register - Register a notifier for jack status 204 * 205 * @jack: ASoC jack 206 * @nb: Notifier block to register 207 * 208 * Register for notification of the current status of the jack. Note 209 * that it is not possible to report additional jack events in the 210 * callback from the notifier, this is intended to support 211 * applications such as enabling electrical detection only when a 212 * mechanical detection event has occurred. 213 */ 214 void snd_soc_jack_notifier_register(struct snd_soc_jack *jack, 215 struct notifier_block *nb) 216 { 217 blocking_notifier_chain_register(&jack->notifier, nb); 218 } 219 EXPORT_SYMBOL_GPL(snd_soc_jack_notifier_register); 220 221 /** 222 * snd_soc_jack_notifier_unregister - Unregister a notifier for jack status 223 * 224 * @jack: ASoC jack 225 * @nb: Notifier block to unregister 226 * 227 * Stop notifying for status changes. 228 */ 229 void snd_soc_jack_notifier_unregister(struct snd_soc_jack *jack, 230 struct notifier_block *nb) 231 { 232 blocking_notifier_chain_unregister(&jack->notifier, nb); 233 } 234 EXPORT_SYMBOL_GPL(snd_soc_jack_notifier_unregister); 235 236 #ifdef CONFIG_GPIOLIB 237 /* gpio detect */ 238 static void snd_soc_jack_gpio_detect(struct snd_soc_jack_gpio *gpio) 239 { 240 struct snd_soc_jack *jack = gpio->jack; 241 int enable; 242 int report; 243 244 enable = gpiod_get_value_cansleep(gpio->desc); 245 if (gpio->invert) 246 enable = !enable; 247 248 if (enable) 249 report = gpio->report; 250 else 251 report = 0; 252 253 if (gpio->jack_status_check) 254 report = gpio->jack_status_check(gpio->data); 255 256 snd_soc_jack_report(jack, report, gpio->report); 257 } 258 259 /* irq handler for gpio pin */ 260 static irqreturn_t gpio_handler(int irq, void *data) 261 { 262 struct snd_soc_jack_gpio *gpio = data; 263 struct device *dev = gpio->jack->codec->card->dev; 264 265 trace_snd_soc_jack_irq(gpio->name); 266 267 if (device_may_wakeup(dev)) 268 pm_wakeup_event(dev, gpio->debounce_time + 50); 269 270 queue_delayed_work(system_power_efficient_wq, &gpio->work, 271 msecs_to_jiffies(gpio->debounce_time)); 272 273 return IRQ_HANDLED; 274 } 275 276 /* gpio work */ 277 static void gpio_work(struct work_struct *work) 278 { 279 struct snd_soc_jack_gpio *gpio; 280 281 gpio = container_of(work, struct snd_soc_jack_gpio, work.work); 282 snd_soc_jack_gpio_detect(gpio); 283 } 284 285 /** 286 * snd_soc_jack_add_gpios - Associate GPIO pins with an ASoC jack 287 * 288 * @jack: ASoC jack 289 * @count: number of pins 290 * @gpios: array of gpio pins 291 * 292 * This function will request gpio, set data direction and request irq 293 * for each gpio in the array. 294 */ 295 int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count, 296 struct snd_soc_jack_gpio *gpios) 297 { 298 int i, ret; 299 300 for (i = 0; i < count; i++) { 301 if (!gpios[i].name) { 302 dev_err(jack->codec->dev, 303 "ASoC: No name for gpio at index %d\n", i); 304 ret = -EINVAL; 305 goto undo; 306 } 307 308 if (gpios[i].gpiod_dev) { 309 /* GPIO descriptor */ 310 gpios[i].desc = gpiod_get_index(gpios[i].gpiod_dev, 311 gpios[i].name, 312 gpios[i].idx); 313 if (IS_ERR(gpios[i].desc)) { 314 ret = PTR_ERR(gpios[i].desc); 315 dev_err(gpios[i].gpiod_dev, 316 "ASoC: Cannot get gpio at index %d: %d", 317 i, ret); 318 goto undo; 319 } 320 } else { 321 /* legacy GPIO number */ 322 if (!gpio_is_valid(gpios[i].gpio)) { 323 dev_err(jack->codec->dev, 324 "ASoC: Invalid gpio %d\n", 325 gpios[i].gpio); 326 ret = -EINVAL; 327 goto undo; 328 } 329 330 ret = gpio_request(gpios[i].gpio, gpios[i].name); 331 if (ret) 332 goto undo; 333 334 gpios[i].desc = gpio_to_desc(gpios[i].gpio); 335 } 336 337 ret = gpiod_direction_input(gpios[i].desc); 338 if (ret) 339 goto err; 340 341 INIT_DELAYED_WORK(&gpios[i].work, gpio_work); 342 gpios[i].jack = jack; 343 344 ret = request_any_context_irq(gpiod_to_irq(gpios[i].desc), 345 gpio_handler, 346 IRQF_TRIGGER_RISING | 347 IRQF_TRIGGER_FALLING, 348 gpios[i].name, 349 &gpios[i]); 350 if (ret < 0) 351 goto err; 352 353 if (gpios[i].wake) { 354 ret = irq_set_irq_wake(gpiod_to_irq(gpios[i].desc), 1); 355 if (ret != 0) 356 dev_err(jack->codec->dev, 357 "ASoC: Failed to mark GPIO at index %d as wake source: %d\n", 358 i, ret); 359 } 360 361 /* Expose GPIO value over sysfs for diagnostic purposes */ 362 gpiod_export(gpios[i].desc, false); 363 364 /* Update initial jack status */ 365 schedule_delayed_work(&gpios[i].work, 366 msecs_to_jiffies(gpios[i].debounce_time)); 367 } 368 369 return 0; 370 371 err: 372 gpio_free(gpios[i].gpio); 373 undo: 374 snd_soc_jack_free_gpios(jack, i, gpios); 375 376 return ret; 377 } 378 EXPORT_SYMBOL_GPL(snd_soc_jack_add_gpios); 379 380 /** 381 * snd_soc_jack_add_gpiods - Associate GPIO descriptor pins with an ASoC jack 382 * 383 * @gpiod_dev: GPIO consumer device 384 * @jack: ASoC jack 385 * @count: number of pins 386 * @gpios: array of gpio pins 387 * 388 * This function will request gpio, set data direction and request irq 389 * for each gpio in the array. 390 */ 391 int snd_soc_jack_add_gpiods(struct device *gpiod_dev, 392 struct snd_soc_jack *jack, 393 int count, struct snd_soc_jack_gpio *gpios) 394 { 395 int i; 396 397 for (i = 0; i < count; i++) 398 gpios[i].gpiod_dev = gpiod_dev; 399 400 return snd_soc_jack_add_gpios(jack, count, gpios); 401 } 402 EXPORT_SYMBOL_GPL(snd_soc_jack_add_gpiods); 403 404 /** 405 * snd_soc_jack_free_gpios - Release GPIO pins' resources of an ASoC jack 406 * 407 * @jack: ASoC jack 408 * @count: number of pins 409 * @gpios: array of gpio pins 410 * 411 * Release gpio and irq resources for gpio pins associated with an ASoC jack. 412 */ 413 void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count, 414 struct snd_soc_jack_gpio *gpios) 415 { 416 int i; 417 418 for (i = 0; i < count; i++) { 419 gpiod_unexport(gpios[i].desc); 420 free_irq(gpiod_to_irq(gpios[i].desc), &gpios[i]); 421 cancel_delayed_work_sync(&gpios[i].work); 422 gpiod_put(gpios[i].desc); 423 gpios[i].jack = NULL; 424 } 425 } 426 EXPORT_SYMBOL_GPL(snd_soc_jack_free_gpios); 427 #endif /* CONFIG_GPIOLIB */ 428