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
  28 static int jack_switch_types[SND_JACK_SWITCH_TYPES] = {
  29         SW_HEADPHONE_INSERT,
  30         SW_MICROPHONE_INSERT,
  31         SW_LINEOUT_INSERT,
  32         SW_JACK_PHYSICAL_INSERT,
  33         SW_VIDEOOUT_INSERT,
  34         SW_LINEIN_INSERT,
  35 };
  36
  37 static int snd_jack_dev_free(struct snd_device *device)
  38 {
  39         struct snd_jack *jack = device->device_data;
  40
  41         if (jack->private_free)
  42                 jack->private_free(jack);
  43
  44         /* If the input device is registered with the input subsystem
  45          * then we need to use a different deallocator. */
  46         if (jack->registered)
  47                 input_unregister_device(jack->input_dev);
  48         else
  49                 input_free_device(jack->input_dev);
  50
  51         kfree(jack->id);
  52         kfree(jack);
  53
  54         return 0;
  55 }
  56
  57 static int snd_jack_dev_register(struct snd_device *device)
  58 {
  59         struct snd_jack *jack = device->device_data;
  60         struct snd_card *card = device->card;
  61         int err, i;
  62
  63         snprintf(jack->name, sizeof(jack->name), "%s %s",
  64                  card->shortname, jack->id);
  65         jack->input_dev->name = jack->name;
  66
  67         /* Default to the sound card device. */
  68         if (!jack->input_dev->dev.parent)
  69                 jack->input_dev->dev.parent = snd_card_get_device_link(card);
  70
  71         /* Add capabilities for any keys that are enabled */
  72         for (i = 0; i < ARRAY_SIZE(jack->key); i++) {
  73                 int testbit = SND_JACK_BTN_0 >> i;
  74
  75                 if (!(jack->type & testbit))
  76                         continue;
  77
  78                 if (!jack->key[i])
  79                         jack->key[i] = BTN_0 + i;
  80
  81                 input_set_capability(jack->input_dev, EV_KEY, jack->key[i]);
  82         }
  83
  84         err = input_register_device(jack->input_dev);
  85         if (err == 0)
  86                 jack->registered = 1;
  87
  88         return err;
  89 }
  90
  91 /**
  92  * snd_jack_new - Create a new jack
  93  * @card:  the card instance
  94  * @id:    an identifying string for this jack
  95  * @type:  a bitmask of enum snd_jack_type values that can be detected by
  96  *         this jack
  97  * @jjack: Used to provide the allocated jack object to the caller.
  98  *
  99  * Creates a new jack object.
 100  *
 101  * Return: Zero if successful, or a negative error code on failure.
 102  * On success @jjack will be initialised.
 103  */
 104 int snd_jack_new(struct snd_card *card, const char *id, int type,
 105                  struct snd_jack **jjack)
 106 {
 107         struct snd_jack *jack;
 108         int err;
 109         int i;
 110         static struct snd_device_ops ops = {
 111                 .dev_free = snd_jack_dev_free,
 112                 .dev_register = snd_jack_dev_register,
 113         };
 114
 115         jack = kzalloc(sizeof(struct snd_jack), GFP_KERNEL);
 116         if (jack == NULL)
 117                 return -ENOMEM;
 118
 119         jack->id = kstrdup(id, GFP_KERNEL);
 120
 121         jack->input_dev = input_allocate_device();
 122         if (jack->input_dev == NULL) {
 123                 err = -ENOMEM;
 124                 goto fail_input;
 125         }
 126
 127         jack->input_dev->phys = "ALSA";
 128
 129         jack->type = type;
 130
 131         for (i = 0; i < SND_JACK_SWITCH_TYPES; i++)
 132                 if (type & (1 << i))
 133                         input_set_capability(jack->input_dev, EV_SW,
 134                                              jack_switch_types[i]);
 135
 136         err = snd_device_new(card, SNDRV_DEV_JACK, jack, &ops);
 137         if (err < 0)
 138                 goto fail_input;
 139
 140         *jjack = jack;
 141
 142         return 0;
 143
 144 fail_input:
 145         input_free_device(jack->input_dev);
 146         kfree(jack->id);
 147         kfree(jack);
 148         return err;
 149 }
 150 EXPORT_SYMBOL(snd_jack_new);
 151
 152 /**
 153  * snd_jack_set_parent - Set the parent device for a jack
 154  *
 155  * @jack:   The jack to configure
 156  * @parent: The device to set as parent for the jack.
 157  *
 158  * Set the parent for the jack devices in the device tree.  This
 159  * function is only valid prior to registration of the jack.  If no
 160  * parent is configured then the parent device will be the sound card.
 161  */
 162 void snd_jack_set_parent(struct snd_jack *jack, struct device *parent)
 163 {
 164         WARN_ON(jack->registered);
 165
 166         jack->input_dev->dev.parent = parent;
 167 }
 168 EXPORT_SYMBOL(snd_jack_set_parent);
 169
 170 /**
 171  * snd_jack_set_key - Set a key mapping on a jack
 172  *
 173  * @jack:    The jack to configure
 174  * @type:    Jack report type for this key
 175  * @keytype: Input layer key type to be reported
 176  *
 177  * Map a SND_JACK_BTN_ button type to an input layer key, allowing
 178  * reporting of keys on accessories via the jack abstraction.  If no
 179  * mapping is provided but keys are enabled in the jack type then
 180  * BTN_n numeric buttons will be reported.
 181  *
 182  * If jacks are not reporting via the input API this call will have no
 183  * effect.
 184  *
 185  * Note that this is intended to be use by simple devices with small
 186  * numbers of keys that can be reported.  It is also possible to
 187  * access the input device directly - devices with complex input
 188  * capabilities on accessories should consider doing this rather than
 189  * using this abstraction.
 190  *
 191  * This function may only be called prior to registration of the jack.
 192  *
 193  * Return: Zero if successful, or a negative error code on failure.
 194  */
 195 int snd_jack_set_key(struct snd_jack *jack, enum snd_jack_types type,
 196                      int keytype)
 197 {
 198         int key = fls(SND_JACK_BTN_0) - fls(type);
 199
 200         WARN_ON(jack->registered);
 201
 202         if (!keytype || key >= ARRAY_SIZE(jack->key))
 203                 return -EINVAL;
 204
 205         jack->type |= type;
 206         jack->key[key] = keytype;
 207
 208         return 0;
 209 }
 210 EXPORT_SYMBOL(snd_jack_set_key);
 211
 212 /**
 213  * snd_jack_report - Report the current status of a jack
 214  *
 215  * @jack:   The jack to report status for
 216  * @status: The current status of the jack
 217  */
 218 void snd_jack_report(struct snd_jack *jack, int status)
 219 {
 220         int i;
 221
 222         if (!jack)
 223                 return;
 224
 225         for (i = 0; i < ARRAY_SIZE(jack->key); i++) {
 226                 int testbit = SND_JACK_BTN_0 >> i;
 227
 228                 if (jack->type & testbit)
 229                         input_report_key(jack->input_dev, jack->key[i],
 230                                          status & testbit);
 231         }
 232
 233         for (i = 0; i < ARRAY_SIZE(jack_switch_types); i++) {
 234                 int testbit = 1 << i;
 235                 if (jack->type & testbit)
 236                         input_report_switch(jack->input_dev,
 237                                             jack_switch_types[i],
 238                                             status & testbit);
 239         }
 240
 241         input_sync(jack->input_dev);
 242 }
 243 EXPORT_SYMBOL(snd_jack_report);
 244
 245 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
 246 MODULE_DESCRIPTION("Jack detection support for ALSA");
 247 MODULE_LICENSE("GPL");