sound/core/jack.c

   1 /*
   2  *  Jack abstraction layer
   3  *
   4  *  Copyright 2008 Wolfson Microelectronics
   5  *
   6  *   This program is free software; you can redistribute it and/or modify
   7  *   it under the terms of the GNU General Public License as published by
   8  *   the Free Software Foundation; either version 2 of the License, or
   9  *   (at your option) any later version.
  10  *
  11  *   This program is distributed in the hope that it will be useful,
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *   GNU General Public License for more details.
  15  *
  16  *   You should have received a copy of the GNU General Public License
  17  *   along with this program; if not, write to the Free Software
  18  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19  *
  20  */
  21
  22 #include <linux/input.h>
  23 #include <linux/slab.h>
  24 #include <linux/module.h>
  25 #include <sound/jack.h>
  26 #include <sound/core.h>
  27 #include <sound/control.h>
  28
  29 struct snd_jack_kctl {
  30         struct snd_kcontrol *kctl;
  31         struct list_head list;  /* list of controls belong to the same jack */
  32         unsigned int mask_bits; /* only masked status bits are reported via kctl */
  33 };
  34
  35 static int jack_switch_types[SND_JACK_SWITCH_TYPES] = {
  36         SW_HEADPHONE_INSERT,
  37         SW_MICROPHONE_INSERT,
  38         SW_LINEOUT_INSERT,
  39         SW_JACK_PHYSICAL_INSERT,
  40         SW_VIDEOOUT_INSERT,
  41         SW_LINEIN_INSERT,
  42 };
  43
  44 static int snd_jack_dev_disconnect(struct snd_device *device)
  45 {
  46         struct snd_jack *jack = device->device_data;
  47
  48         if (!jack->input_dev)
  49                 return 0;
  50
  51         /* If the input device is registered with the input subsystem
  52          * then we need to use a different deallocator. */
  53         if (jack->registered)
  54                 input_unregister_device(jack->input_dev);
  55         else
  56                 input_free_device(jack->input_dev);
  57         jack->input_dev = NULL;
  58         return 0;
  59 }
  60
  61 static int snd_jack_dev_free(struct snd_device *device)
  62 {
  63         struct snd_jack *jack = device->device_data;
  64         struct snd_card *card = device->card;
  65         struct snd_jack_kctl *jack_kctl, *tmp_jack_kctl;
  66
  67         list_for_each_entry_safe(jack_kctl, tmp_jack_kctl, &jack->kctl_list, list) {
  68                 list_del_init(&jack_kctl->list);
  69                 snd_ctl_remove(card, jack_kctl->kctl);
  70         }
  71         if (jack->private_free)
  72                 jack->private_free(jack);
  73
  74         snd_jack_dev_disconnect(device);
  75
  76         kfree(jack->id);
  77         kfree(jack);
  78
  79         return 0;
  80 }
  81
  82 static int snd_jack_dev_register(struct snd_device *device)
  83 {
  84         struct snd_jack *jack = device->device_data;
  85         struct snd_card *card = device->card;
  86         int err, i;
  87
  88         snprintf(jack->name, sizeof(jack->name), "%s %s",
  89                  card->shortname, jack->id);
  90
  91         if (!jack->input_dev)
  92                 return 0;
  93
  94         jack->input_dev->name = jack->name;
  95
  96         /* Default to the sound card device. */
  97         if (!jack->input_dev->dev.parent)
  98                 jack->input_dev->dev.parent = snd_card_get_device_link(card);
  99
 100         /* Add capabilities for any keys that are enabled */
 101         for (i = 0; i < ARRAY_SIZE(jack->key); i++) {
 102                 int testbit = SND_JACK_BTN_0 >> i;
 103
 104                 if (!(jack->type & testbit))
 105                         continue;
 106
 107                 if (!jack->key[i])
 108                         jack->key[i] = BTN_0 + i;
 109
 110                 input_set_capability(jack->input_dev, EV_KEY, jack->key[i]);
 111         }
 112
 113         err = input_register_device(jack->input_dev);
 114         if (err == 0)
 115                 jack->registered = 1;
 116
 117         return err;
 118 }
 119
 120 static void snd_jack_kctl_private_free(struct snd_kcontrol *kctl)
 121 {
 122         struct snd_jack_kctl *jack_kctl;
 123
 124         jack_kctl = kctl->private_data;
 125         if (jack_kctl) {
 126                 list_del(&jack_kctl->list);
 127                 kfree(jack_kctl);
 128         }
 129 }
 130
 131 static void snd_jack_kctl_add(struct snd_jack *jack, struct snd_jack_kctl *jack_kctl)
 132 {
 133         list_add_tail(&jack_kctl->list, &jack->kctl_list);
 134 }
 135
 136 static struct snd_jack_kctl * snd_jack_kctl_new(struct snd_card *card, const char *name, unsigned int mask)
 137 {
 138         struct snd_kcontrol *kctl;
 139         struct snd_jack_kctl *jack_kctl;
 140         int err;
 141
 142         kctl = snd_kctl_jack_new(name, card);
 143         if (!kctl)
 144                 return NULL;
 145
 146         err = snd_ctl_add(card, kctl);
 147         if (err < 0)
 148                 return NULL;
 149
 150         jack_kctl = kzalloc(sizeof(*jack_kctl), GFP_KERNEL);
 151
 152         if (!jack_kctl)
 153                 goto error;
 154
 155         jack_kctl->kctl = kctl;
 156         jack_kctl->mask_bits = mask;
 157
 158         kctl->private_data = jack_kctl;
 159         kctl->private_free = snd_jack_kctl_private_free;
 160
 161         return jack_kctl;
 162 error:
 163         snd_ctl_free_one(kctl);
 164         return NULL;
 165 }
 166
 167 /**
 168  * snd_jack_add_new_kctl - Create a new snd_jack_kctl and add it to jack
 169  * @jack:  the jack instance which the kctl will attaching to
 170  * @name:  the name for the snd_kcontrol object
 171  * @mask:  a bitmask of enum snd_jack_type values that can be detected
 172  *         by this snd_jack_kctl object.
 173  *
 174  * Creates a new snd_kcontrol object and adds it to the jack kctl_list.
 175  *
 176  * Return: Zero if successful, or a negative error code on failure.
 177  */
 178 int snd_jack_add_new_kctl(struct snd_jack *jack, const char * name, int mask)
 179 {
 180         struct snd_jack_kctl *jack_kctl;
 181
 182         jack_kctl = snd_jack_kctl_new(jack->card, name, mask);
 183         if (!jack_kctl)
 184                 return -ENOMEM;
 185
 186         snd_jack_kctl_add(jack, jack_kctl);
 187         return 0;
 188 }
 189 EXPORT_SYMBOL(snd_jack_add_new_kctl);
 190
 191 /**
 192  * snd_jack_new - Create a new jack
 193  * @card:  the card instance
 194  * @id:    an identifying string for this jack
 195  * @type:  a bitmask of enum snd_jack_type values that can be detected by
 196  *         this jack
 197  * @jjack: Used to provide the allocated jack object to the caller.
 198  * @initial_kctl: if true, create a kcontrol and add it to the jack list.
 199  * @phantom_jack: Don't create a input device for phantom jacks.
 200  *
 201  * Creates a new jack object.
 202  *
 203  * Return: Zero if successful, or a negative error code on failure.
 204  * On success @jjack will be initialised.
 205  */
 206 int snd_jack_new(struct snd_card *card, const char *id, int type,
 207                  struct snd_jack **jjack, bool initial_kctl, bool phantom_jack)
 208 {
 209         struct snd_jack *jack;
 210         struct snd_jack_kctl *jack_kctl = NULL;
 211         int err;
 212         int i;
 213         static struct snd_device_ops ops = {
 214                 .dev_free = snd_jack_dev_free,
 215                 .dev_register = snd_jack_dev_register,
 216                 .dev_disconnect = snd_jack_dev_disconnect,
 217         };
 218
 219         if (initial_kctl) {
 220                 jack_kctl = snd_jack_kctl_new(card, id, type);
 221                 if (!jack_kctl)
 222                         return -ENOMEM;
 223         }
 224
 225         jack = kzalloc(sizeof(struct snd_jack), GFP_KERNEL);
 226         if (jack == NULL)
 227                 return -ENOMEM;
 228
 229         jack->id = kstrdup(id, GFP_KERNEL);
 230
 231         /* don't creat input device for phantom jack */
 232         if (!phantom_jack) {
 233                 jack->input_dev = input_allocate_device();
 234                 if (jack->input_dev == NULL) {
 235                         err = -ENOMEM;
 236                         goto fail_input;
 237                 }
 238
 239                 jack->input_dev->phys = "ALSA";
 240
 241                 jack->type = type;
 242
 243                 for (i = 0; i < SND_JACK_SWITCH_TYPES; i++)
 244                         if (type & (1 << i))
 245                                 input_set_capability(jack->input_dev, EV_SW,
 246                                                      jack_switch_types[i]);
 247
 248         }
 249
 250         err = snd_device_new(card, SNDRV_DEV_JACK, jack, &ops);
 251         if (err < 0)
 252                 goto fail_input;
 253
 254         jack->card = card;
 255         INIT_LIST_HEAD(&jack->kctl_list);
 256
 257         if (initial_kctl)
 258                 snd_jack_kctl_add(jack, jack_kctl);
 259
 260         *jjack = jack;
 261
 262         return 0;
 263
 264 fail_input:
 265         input_free_device(jack->input_dev);
 266         kfree(jack->id);
 267         kfree(jack);
 268         return err;
 269 }
 270 EXPORT_SYMBOL(snd_jack_new);
 271
 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
 330         return 0;
 331 }
 332 EXPORT_SYMBOL(snd_jack_set_key);
 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         int i;
 344
 345         if (!jack)
 346                 return;
 347
 348         list_for_each_entry(jack_kctl, &jack->kctl_list, list)
 349                 snd_kctl_jack_report(jack->card, jack_kctl->kctl,
 350                                             status & jack_kctl->mask_bits);
 351
 352         if (!jack->input_dev)
 353                 return;
 354
 355         for (i = 0; i < ARRAY_SIZE(jack->key); i++) {
 356                 int testbit = SND_JACK_BTN_0 >> i;
 357
 358                 if (jack->type & testbit)
 359                         input_report_key(jack->input_dev, jack->key[i],
 360                                          status & testbit);
 361         }
 362
 363         for (i = 0; i < ARRAY_SIZE(jack_switch_types); i++) {
 364                 int testbit = 1 << i;
 365                 if (jack->type & testbit)
 366                         input_report_switch(jack->input_dev,
 367                                             jack_switch_types[i],
 368                                             status & testbit);
 369         }
 370
 371         input_sync(jack->input_dev);
 372
 373 }
 374 EXPORT_SYMBOL(snd_jack_report);