sound/core/jack.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  Jack abstraction layer
   4  *
   5  *  Copyright 2008 Wolfson Microelectronics
   6  */
   7
   8 #include <linux/input.h>
   9 #include <linux/slab.h>
  10 #include <linux/module.h>
  11 #include <sound/jack.h>
  12 #include <sound/core.h>
  13 #include <sound/control.h>
  14
  15 struct snd_jack_kctl {
  16         struct snd_kcontrol *kctl;
  17         struct list_head list;  /* list of controls belong to the same jack */
  18         unsigned int mask_bits; /* only masked status bits are reported via kctl */
  19 };
  20
  21 #ifdef CONFIG_SND_JACK_INPUT_DEV
  22 static const int jack_switch_types[SND_JACK_SWITCH_TYPES] = {
  23         SW_HEADPHONE_INSERT,
  24         SW_MICROPHONE_INSERT,
  25         SW_LINEOUT_INSERT,
  26         SW_JACK_PHYSICAL_INSERT,
  27         SW_VIDEOOUT_INSERT,
  28         SW_LINEIN_INSERT,
  29 };
  30 #endif /* CONFIG_SND_JACK_INPUT_DEV */
  31
  32 static int snd_jack_dev_disconnect(struct snd_device *device)
  33 {
  34 #ifdef CONFIG_SND_JACK_INPUT_DEV
  35         struct snd_jack *jack = device->device_data;
  36
  37         if (!jack->input_dev)
  38                 return 0;
  39
  40         /* If the input device is registered with the input subsystem
  41          * then we need to use a different deallocator. */
  42         if (jack->registered)
  43                 input_unregister_device(jack->input_dev);
  44         else
  45                 input_free_device(jack->input_dev);
  46         jack->input_dev = NULL;
  47 #endif /* CONFIG_SND_JACK_INPUT_DEV */
  48         return 0;
  49 }
  50
  51 static int snd_jack_dev_free(struct snd_device *device)
  52 {
  53         struct snd_jack *jack = device->device_data;
  54         struct snd_card *card = device->card;
  55         struct snd_jack_kctl *jack_kctl, *tmp_jack_kctl;
  56
  57         list_for_each_entry_safe(jack_kctl, tmp_jack_kctl, &jack->kctl_list, list) {
  58                 list_del_init(&jack_kctl->list);
  59                 snd_ctl_remove(card, jack_kctl->kctl);
  60         }
  61         if (jack->private_free)
  62                 jack->private_free(jack);
  63
  64         snd_jack_dev_disconnect(device);
  65
  66         kfree(jack->id);
  67         kfree(jack);
  68
  69         return 0;
  70 }
  71
  72 #ifdef CONFIG_SND_JACK_INPUT_DEV
  73 static int snd_jack_dev_register(struct snd_device *device)
  74 {
  75         struct snd_jack *jack = device->device_data;
  76         struct snd_card *card = device->card;
  77         int err, i;
  78
  79         snprintf(jack->name, sizeof(jack->name), "%s %s",
  80                  card->shortname, jack->id);
  81
  82         if (!jack->input_dev)
  83                 return 0;
  84
  85         jack->input_dev->name = jack->name;
  86
  87         /* Default to the sound card device. */
  88         if (!jack->input_dev->dev.parent)
  89                 jack->input_dev->dev.parent = snd_card_get_device_link(card);
  90
  91         /* Add capabilities for any keys that are enabled */
  92         for (i = 0; i < ARRAY_SIZE(jack->key); i++) {
  93                 int testbit = SND_JACK_BTN_0 >> i;
  94
  95                 if (!(jack->type & testbit))
  96                         continue;
  97
  98                 if (!jack->key[i])
  99                         jack->key[i] = BTN_0 + i;
 100
 101                 input_set_capability(jack->input_dev, EV_KEY, jack->key[i]);
 102         }
 103
 104         err = input_register_device(jack->input_dev);
 105         if (err == 0)
 106                 jack->registered = 1;
 107
 108         return err;
 109 }
 110 #endif /* CONFIG_SND_JACK_INPUT_DEV */
 111
 112 static void snd_jack_kctl_private_free(struct snd_kcontrol *kctl)
 113 {
 114         struct snd_jack_kctl *jack_kctl;
 115
 116         jack_kctl = kctl->private_data;
 117         if (jack_kctl) {
 118                 list_del(&jack_kctl->list);
 119                 kfree(jack_kctl);
 120         }
 121 }
 122
 123 static void snd_jack_kctl_add(struct snd_jack *jack, struct snd_jack_kctl *jack_kctl)
 124 {
 125         list_add_tail(&jack_kctl->list, &jack->kctl_list);
 126 }
 127
 128 static struct snd_jack_kctl * snd_jack_kctl_new(struct snd_card *card, const char *name, unsigned int mask)
 129 {
 130         struct snd_kcontrol *kctl;
 131         struct snd_jack_kctl *jack_kctl;
 132         int err;
 133
 134         kctl = snd_kctl_jack_new(name, card);
 135         if (!kctl)
 136                 return NULL;
 137
 138         err = snd_ctl_add(card, kctl);
 139         if (err < 0)
 140                 return NULL;
 141
 142         jack_kctl = kzalloc(sizeof(*jack_kctl), GFP_KERNEL);
 143
 144         if (!jack_kctl)
 145                 goto error;
 146
 147         jack_kctl->kctl = kctl;
 148         jack_kctl->mask_bits = mask;
 149
 150         kctl->private_data = jack_kctl;
 151         kctl->private_free = snd_jack_kctl_private_free;
 152
 153         return jack_kctl;
 154 error:
 155         snd_ctl_free_one(kctl);
 156         return NULL;
 157 }
 158
 159 /**
 160  * snd_jack_add_new_kctl - Create a new snd_jack_kctl and add it to jack
 161  * @jack:  the jack instance which the kctl will attaching to
 162  * @name:  the name for the snd_kcontrol object
 163  * @mask:  a bitmask of enum snd_jack_type values that can be detected
 164  *         by this snd_jack_kctl object.
 165  *
 166  * Creates a new snd_kcontrol object and adds it to the jack kctl_list.
 167  *
 168  * Return: Zero if successful, or a negative error code on failure.
 169  */
 170 int snd_jack_add_new_kctl(struct snd_jack *jack, const char * name, int mask)
 171 {
 172         struct snd_jack_kctl *jack_kctl;
 173
 174         jack_kctl = snd_jack_kctl_new(jack->card, name, mask);
 175         if (!jack_kctl)
 176                 return -ENOMEM;
 177
 178         snd_jack_kctl_add(jack, jack_kctl);
 179         return 0;
 180 }
 181 EXPORT_SYMBOL(snd_jack_add_new_kctl);
 182
 183 /**
 184  * snd_jack_new - Create a new jack
 185  * @card:  the card instance
 186  * @id:    an identifying string for this jack
 187  * @type:  a bitmask of enum snd_jack_type values that can be detected by
 188  *         this jack
 189  * @jjack: Used to provide the allocated jack object to the caller.
 190  * @initial_kctl: if true, create a kcontrol and add it to the jack list.
 191  * @phantom_jack: Don't create a input device for phantom jacks.
 192  *
 193  * Creates a new jack object.
 194  *
 195  * Return: Zero if successful, or a negative error code on failure.
 196  * On success @jjack will be initialised.
 197  */
 198 int snd_jack_new(struct snd_card *card, const char *id, int type,
 199                  struct snd_jack **jjack, bool initial_kctl, bool phantom_jack)
 200 {
 201         struct snd_jack *jack;
 202         struct snd_jack_kctl *jack_kctl = NULL;
 203         int err;
 204         static const struct snd_device_ops ops = {
 205                 .dev_free = snd_jack_dev_free,
 206 #ifdef CONFIG_SND_JACK_INPUT_DEV
 207                 .dev_register = snd_jack_dev_register,
 208                 .dev_disconnect = snd_jack_dev_disconnect,
 209 #endif /* CONFIG_SND_JACK_INPUT_DEV */
 210         };
 211
 212         if (initial_kctl) {
 213                 jack_kctl = snd_jack_kctl_new(card, id, type);
 214                 if (!jack_kctl)
 215                         return -ENOMEM;
 216         }
 217
 218         jack = kzalloc(sizeof(struct snd_jack), GFP_KERNEL);
 219         if (jack == NULL)
 220                 return -ENOMEM;
 221
 222         jack->id = kstrdup(id, GFP_KERNEL);
 223
 224         /* don't creat input device for phantom jack */
 225         if (!phantom_jack) {
 226 #ifdef CONFIG_SND_JACK_INPUT_DEV
 227                 int i;
 228
 229                 jack->input_dev = input_allocate_device();
 230                 if (jack->input_dev == NULL) {
 231                         err = -ENOMEM;
 232                         goto fail_input;
 233                 }
 234
 235                 jack->input_dev->phys = "ALSA";
 236
 237                 jack->type = type;
 238
 239                 for (i = 0; i < SND_JACK_SWITCH_TYPES; i++)
 240                         if (type & (1 << i))
 241                                 input_set_capability(jack->input_dev, EV_SW,
 242                                                      jack_switch_types[i]);
 243
 244 #endif /* CONFIG_SND_JACK_INPUT_DEV */
 245         }
 246
 247         err = snd_device_new(card, SNDRV_DEV_JACK, jack, &ops);
 248         if (err < 0)
 249                 goto fail_input;
 250
 251         jack->card = card;
 252         INIT_LIST_HEAD(&jack->kctl_list);
 253
 254         if (initial_kctl)
 255                 snd_jack_kctl_add(jack, jack_kctl);
 256
 257         *jjack = jack;
 258
 259         return 0;
 260
 261 fail_input:
 262 #ifdef CONFIG_SND_JACK_INPUT_DEV
 263         input_free_device(jack->input_dev);
 264 #endif
 265         kfree(jack->id);
 266         kfree(jack);
 267         return err;
 268 }
 269 EXPORT_SYMBOL(snd_jack_new);
 270
 271 #ifdef CONFIG_SND_JACK_INPUT_DEV
 272 /**
 273  * snd_jack_set_parent - Set the parent device for a jack
 274  *
 275  * @jack:   The jack to configure
 276  * @parent: The device to set as parent for the jack.
 277  *
 278  * Set the parent for the jack devices in the device tree.  This
 279  * function is only valid prior to registration of the jack.  If no
 280  * parent is configured then the parent device will be the sound card.
 281  */
 282 void snd_jack_set_parent(struct snd_jack *jack, struct device *parent)
 283 {
 284         WARN_ON(jack->registered);
 285         if (!jack->input_dev)
 286                 return;
 287
 288         jack->input_dev->dev.parent = parent;
 289 }
 290 EXPORT_SYMBOL(snd_jack_set_parent);
 291
 292 /**
 293  * snd_jack_set_key - Set a key mapping on a jack
 294  *
 295  * @jack:    The jack to configure
 296  * @type:    Jack report type for this key
 297  * @keytype: Input layer key type to be reported
 298  *
 299  * Map a SND_JACK_BTN_* button type to an input layer key, allowing
 300  * reporting of keys on accessories via the jack abstraction.  If no
 301  * mapping is provided but keys are enabled in the jack type then
 302  * BTN_n numeric buttons will be reported.
 303  *
 304  * If jacks are not reporting via the input API this call will have no
 305  * effect.
 306  *
 307  * Note that this is intended to be use by simple devices with small
 308  * numbers of keys that can be reported.  It is also possible to
 309  * access the input device directly - devices with complex input
 310  * capabilities on accessories should consider doing this rather than
 311  * using this abstraction.
 312  *
 313  * This function may only be called prior to registration of the jack.
 314  *
 315  * Return: Zero if successful, or a negative error code on failure.
 316  */
 317 int snd_jack_set_key(struct snd_jack *jack, enum snd_jack_types type,
 318                      int keytype)
 319 {
 320         int key = fls(SND_JACK_BTN_0) - fls(type);
 321
 322         WARN_ON(jack->registered);
 323
 324         if (!keytype || key >= ARRAY_SIZE(jack->key))
 325                 return -EINVAL;
 326
 327         jack->type |= type;
 328         jack->key[key] = keytype;
 329         return 0;
 330 }
 331 EXPORT_SYMBOL(snd_jack_set_key);
 332 #endif /* CONFIG_SND_JACK_INPUT_DEV */
 333
 334 /**
 335  * snd_jack_report - Report the current status of a jack
 336  *
 337  * @jack:   The jack to report status for
 338  * @status: The current status of the jack
 339  */
 340 void snd_jack_report(struct snd_jack *jack, int status)
 341 {
 342         struct snd_jack_kctl *jack_kctl;
 343 #ifdef CONFIG_SND_JACK_INPUT_DEV
 344         int i;
 345 #endif
 346
 347         if (!jack)
 348                 return;
 349
 350         list_for_each_entry(jack_kctl, &jack->kctl_list, list)
 351                 snd_kctl_jack_report(jack->card, jack_kctl->kctl,
 352                                             status & jack_kctl->mask_bits);
 353
 354 #ifdef CONFIG_SND_JACK_INPUT_DEV
 355         if (!jack->input_dev)
 356                 return;
 357
 358         for (i = 0; i < ARRAY_SIZE(jack->key); i++) {
 359                 int testbit = SND_JACK_BTN_0 >> i;
 360
 361                 if (jack->type & testbit)
 362                         input_report_key(jack->input_dev, jack->key[i],
 363                                          status & testbit);
 364         }
 365
 366         for (i = 0; i < ARRAY_SIZE(jack_switch_types); i++) {
 367                 int testbit = 1 << i;
 368                 if (jack->type & testbit)
 369                         input_report_switch(jack->input_dev,
 370                                             jack_switch_types[i],
 371                                             status & testbit);
 372         }
 373
 374         input_sync(jack->input_dev);
 375 #endif /* CONFIG_SND_JACK_INPUT_DEV */
 376 }
 377 EXPORT_SYMBOL(snd_jack_report);