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 <linux/ctype.h>
  12 #include <linux/mm.h>
  13 #include <linux/debugfs.h>
  14 #include <sound/jack.h>
  15 #include <sound/core.h>
  16 #include <sound/control.h>
  17
  18 struct snd_jack_kctl {
  19         struct snd_kcontrol *kctl;
  20         struct list_head list;  /* list of controls belong to the same jack */
  21         unsigned int mask_bits; /* only masked status bits are reported via kctl */
  22         struct snd_jack *jack;  /* pointer to struct snd_jack */
  23         bool sw_inject_enable;  /* allow to inject plug event via debugfs */
  24 #ifdef CONFIG_SND_JACK_INJECTION_DEBUG
  25         struct dentry *jack_debugfs_root; /* jack_kctl debugfs root */
  26 #endif
  27 };
  28
  29 #ifdef CONFIG_SND_JACK_INPUT_DEV
  30 static const int jack_switch_types[SND_JACK_SWITCH_TYPES] = {
  31         SW_HEADPHONE_INSERT,
  32         SW_MICROPHONE_INSERT,
  33         SW_LINEOUT_INSERT,
  34         SW_JACK_PHYSICAL_INSERT,
  35         SW_VIDEOOUT_INSERT,
  36         SW_LINEIN_INSERT,
  37 };
  38 #endif /* CONFIG_SND_JACK_INPUT_DEV */
  39
  40 static void snd_jack_remove_debugfs(struct snd_jack *jack);
  41
  42 static int snd_jack_dev_disconnect(struct snd_device *device)
  43 {
  44         struct snd_jack *jack = device->device_data;
  45
  46         snd_jack_remove_debugfs(jack);
  47
  48 #ifdef CONFIG_SND_JACK_INPUT_DEV
  49         guard(mutex)(&jack->input_dev_lock);
  50         if (!jack->input_dev)
  51                 return 0;
  52
  53         /* If the input device is registered with the input subsystem
  54          * then we need to use a different deallocator. */
  55         if (jack->registered)
  56                 input_unregister_device(jack->input_dev);
  57         else
  58                 input_free_device(jack->input_dev);
  59         jack->input_dev = NULL;
  60 #endif /* CONFIG_SND_JACK_INPUT_DEV */
  61         return 0;
  62 }
  63
  64 static int snd_jack_dev_free(struct snd_device *device)
  65 {
  66         struct snd_jack *jack = device->device_data;
  67         struct snd_card *card = device->card;
  68         struct snd_jack_kctl *jack_kctl, *tmp_jack_kctl;
  69
  70         list_for_each_entry_safe(jack_kctl, tmp_jack_kctl, &jack->kctl_list, list) {
  71                 list_del_init(&jack_kctl->list);
  72                 snd_ctl_remove(card, jack_kctl->kctl);
  73         }
  74
  75         if (jack->private_free)
  76                 jack->private_free(jack);
  77
  78         snd_jack_dev_disconnect(device);
  79
  80         kfree(jack->id);
  81         kfree(jack);
  82
  83         return 0;
  84 }
  85
  86 #ifdef CONFIG_SND_JACK_INPUT_DEV
  87 static int snd_jack_dev_register(struct snd_device *device)
  88 {
  89         struct snd_jack *jack = device->device_data;
  90         struct snd_card *card = device->card;
  91         int err, i;
  92
  93         snprintf(jack->name, sizeof(jack->name), "%s %s",
  94                  card->shortname, jack->id);
  95
  96         guard(mutex)(&jack->input_dev_lock);
  97         if (!jack->input_dev)
  98                 return 0;
  99
 100         jack->input_dev->name = jack->name;
 101
 102         /* Default to the sound card device. */
 103         if (!jack->input_dev->dev.parent)
 104                 jack->input_dev->dev.parent = snd_card_get_device_link(card);
 105
 106         /* Add capabilities for any keys that are enabled */
 107         for (i = 0; i < ARRAY_SIZE(jack->key); i++) {
 108                 int testbit = SND_JACK_BTN_0 >> i;
 109
 110                 if (!(jack->type & testbit))
 111                         continue;
 112
 113                 if (!jack->key[i])
 114                         jack->key[i] = BTN_0 + i;
 115
 116                 input_set_capability(jack->input_dev, EV_KEY, jack->key[i]);
 117         }
 118
 119         err = input_register_device(jack->input_dev);
 120         if (err == 0)
 121                 jack->registered = 1;
 122
 123         return err;
 124 }
 125 #endif /* CONFIG_SND_JACK_INPUT_DEV */
 126
 127 #ifdef CONFIG_SND_JACK_INJECTION_DEBUG
 128 static void snd_jack_inject_report(struct snd_jack_kctl *jack_kctl, int status)
 129 {
 130         struct snd_jack *jack;
 131 #ifdef CONFIG_SND_JACK_INPUT_DEV
 132         int i;
 133 #endif
 134         if (!jack_kctl)
 135                 return;
 136
 137         jack = jack_kctl->jack;
 138
 139         if (jack_kctl->sw_inject_enable)
 140                 snd_kctl_jack_report(jack->card, jack_kctl->kctl,
 141                                      status & jack_kctl->mask_bits);
 142
 143 #ifdef CONFIG_SND_JACK_INPUT_DEV
 144         if (!jack->input_dev)
 145                 return;
 146
 147         for (i = 0; i < ARRAY_SIZE(jack->key); i++) {
 148                 int testbit = ((SND_JACK_BTN_0 >> i) & jack_kctl->mask_bits);
 149
 150                 if (jack->type & testbit)
 151                         input_report_key(jack->input_dev, jack->key[i],
 152                                          status & testbit);
 153         }
 154
 155         for (i = 0; i < ARRAY_SIZE(jack_switch_types); i++) {
 156                 int testbit = ((1 << i) & jack_kctl->mask_bits);
 157
 158                 if (jack->type & testbit)
 159                         input_report_switch(jack->input_dev,
 160                                             jack_switch_types[i],
 161                                             status & testbit);
 162         }
 163
 164         input_sync(jack->input_dev);
 165 #endif /* CONFIG_SND_JACK_INPUT_DEV */
 166 }
 167
 168 static ssize_t sw_inject_enable_read(struct file *file,
 169                                      char __user *to, size_t count, loff_t *ppos)
 170 {
 171         struct snd_jack_kctl *jack_kctl = file->private_data;
 172         int len, ret;
 173         char buf[128];
 174
 175         len = scnprintf(buf, sizeof(buf), "%s: %s\t\t%s: %i\n", "Jack", jack_kctl->kctl->id.name,
 176                         "Inject Enabled", jack_kctl->sw_inject_enable);
 177         ret = simple_read_from_buffer(to, count, ppos, buf, len);
 178
 179         return ret;
 180 }
 181
 182 static ssize_t sw_inject_enable_write(struct file *file,
 183                                       const char __user *from, size_t count, loff_t *ppos)
 184 {
 185         struct snd_jack_kctl *jack_kctl = file->private_data;
 186         int ret, err;
 187         unsigned long enable;
 188         char buf[8] = { 0 };
 189
 190         ret = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, from, count);
 191         err = kstrtoul(buf, 0, &enable);
 192         if (err)
 193                 return err;
 194
 195         if (jack_kctl->sw_inject_enable == (!!enable))
 196                 return ret;
 197
 198         jack_kctl->sw_inject_enable = !!enable;
 199
 200         if (!jack_kctl->sw_inject_enable)
 201                 snd_jack_report(jack_kctl->jack, jack_kctl->jack->hw_status_cache);
 202
 203         return ret;
 204 }
 205
 206 static ssize_t jackin_inject_write(struct file *file,
 207                                    const char __user *from, size_t count, loff_t *ppos)
 208 {
 209         struct snd_jack_kctl *jack_kctl = file->private_data;
 210         int ret, err;
 211         unsigned long enable;
 212         char buf[8] = { 0 };
 213
 214         if (!jack_kctl->sw_inject_enable)
 215                 return -EINVAL;
 216
 217         ret = simple_write_to_buffer(buf, sizeof(buf) - 1, ppos, from, count);
 218         err = kstrtoul(buf, 0, &enable);
 219         if (err)
 220                 return err;
 221
 222         snd_jack_inject_report(jack_kctl, !!enable ? jack_kctl->mask_bits : 0);
 223
 224         return ret;
 225 }
 226
 227 static ssize_t jack_kctl_id_read(struct file *file,
 228                                  char __user *to, size_t count, loff_t *ppos)
 229 {
 230         struct snd_jack_kctl *jack_kctl = file->private_data;
 231         char buf[64];
 232         int len, ret;
 233
 234         len = scnprintf(buf, sizeof(buf), "%s\n", jack_kctl->kctl->id.name);
 235         ret = simple_read_from_buffer(to, count, ppos, buf, len);
 236
 237         return ret;
 238 }
 239
 240 /* the bit definition is aligned with snd_jack_types in jack.h */
 241 static const char * const jack_events_name[] = {
 242         "HEADPHONE(0x0001)", "MICROPHONE(0x0002)", "LINEOUT(0x0004)",
 243         "MECHANICAL(0x0008)", "VIDEOOUT(0x0010)", "LINEIN(0x0020)",
 244         "", "", "", "BTN_5(0x0200)", "BTN_4(0x0400)", "BTN_3(0x0800)",
 245         "BTN_2(0x1000)", "BTN_1(0x2000)", "BTN_0(0x4000)", "",
 246 };
 247
 248 /* the recommended buffer size is 256 */
 249 static int parse_mask_bits(unsigned int mask_bits, char *buf, size_t buf_size)
 250 {
 251         int i;
 252
 253         scnprintf(buf, buf_size, "0x%04x", mask_bits);
 254
 255         for (i = 0; i < ARRAY_SIZE(jack_events_name); i++)
 256                 if (mask_bits & (1 << i)) {
 257                         strlcat(buf, " ", buf_size);
 258                         strlcat(buf, jack_events_name[i], buf_size);
 259                 }
 260         strlcat(buf, "\n", buf_size);
 261
 262         return strlen(buf);
 263 }
 264
 265 static ssize_t jack_kctl_mask_bits_read(struct file *file,
 266                                         char __user *to, size_t count, loff_t *ppos)
 267 {
 268         struct snd_jack_kctl *jack_kctl = file->private_data;
 269         char buf[256];
 270         int len, ret;
 271
 272         len = parse_mask_bits(jack_kctl->mask_bits, buf, sizeof(buf));
 273         ret = simple_read_from_buffer(to, count, ppos, buf, len);
 274
 275         return ret;
 276 }
 277
 278 static ssize_t jack_kctl_status_read(struct file *file,
 279                                      char __user *to, size_t count, loff_t *ppos)
 280 {
 281         struct snd_jack_kctl *jack_kctl = file->private_data;
 282         char buf[16];
 283         int len, ret;
 284
 285         len = scnprintf(buf, sizeof(buf), "%s\n", jack_kctl->kctl->private_value ?
 286                         "Plugged" : "Unplugged");
 287         ret = simple_read_from_buffer(to, count, ppos, buf, len);
 288
 289         return ret;
 290 }
 291
 292 #ifdef CONFIG_SND_JACK_INPUT_DEV
 293 static ssize_t jack_type_read(struct file *file,
 294                               char __user *to, size_t count, loff_t *ppos)
 295 {
 296         struct snd_jack_kctl *jack_kctl = file->private_data;
 297         char buf[256];
 298         int len, ret;
 299
 300         len = parse_mask_bits(jack_kctl->jack->type, buf, sizeof(buf));
 301         ret = simple_read_from_buffer(to, count, ppos, buf, len);
 302
 303         return ret;
 304 }
 305
 306 static const struct file_operations jack_type_fops = {
 307         .open = simple_open,
 308         .read = jack_type_read,
 309         .llseek = default_llseek,
 310 };
 311 #endif
 312
 313 static const struct file_operations sw_inject_enable_fops = {
 314         .open = simple_open,
 315         .read = sw_inject_enable_read,
 316         .write = sw_inject_enable_write,
 317         .llseek = default_llseek,
 318 };
 319
 320 static const struct file_operations jackin_inject_fops = {
 321         .open = simple_open,
 322         .write = jackin_inject_write,
 323         .llseek = default_llseek,
 324 };
 325
 326 static const struct file_operations jack_kctl_id_fops = {
 327         .open = simple_open,
 328         .read = jack_kctl_id_read,
 329         .llseek = default_llseek,
 330 };
 331
 332 static const struct file_operations jack_kctl_mask_bits_fops = {
 333         .open = simple_open,
 334         .read = jack_kctl_mask_bits_read,
 335         .llseek = default_llseek,
 336 };
 337
 338 static const struct file_operations jack_kctl_status_fops = {
 339         .open = simple_open,
 340         .read = jack_kctl_status_read,
 341         .llseek = default_llseek,
 342 };
 343
 344 static int snd_jack_debugfs_add_inject_node(struct snd_jack *jack,
 345                                             struct snd_jack_kctl *jack_kctl)
 346 {
 347         char *tname;
 348         int i;
 349
 350         /* Don't create injection interface for Phantom jacks */
 351         if (strstr(jack_kctl->kctl->id.name, "Phantom"))
 352                 return 0;
 353
 354         tname = kstrdup(jack_kctl->kctl->id.name, GFP_KERNEL);
 355         if (!tname)
 356                 return -ENOMEM;
 357
 358         /* replace the chars which are not suitable for folder's name with _ */
 359         for (i = 0; tname[i]; i++)
 360                 if (!isalnum(tname[i]))
 361                         tname[i] = '_';
 362
 363         jack_kctl->jack_debugfs_root = debugfs_create_dir(tname, jack->card->debugfs_root);
 364         kfree(tname);
 365
 366         debugfs_create_file("sw_inject_enable", 0644, jack_kctl->jack_debugfs_root, jack_kctl,
 367                             &sw_inject_enable_fops);
 368
 369         debugfs_create_file("jackin_inject", 0200, jack_kctl->jack_debugfs_root, jack_kctl,
 370                             &jackin_inject_fops);
 371
 372         debugfs_create_file("kctl_id", 0444, jack_kctl->jack_debugfs_root, jack_kctl,
 373                             &jack_kctl_id_fops);
 374
 375         debugfs_create_file("mask_bits", 0444, jack_kctl->jack_debugfs_root, jack_kctl,
 376                             &jack_kctl_mask_bits_fops);
 377
 378         debugfs_create_file("status", 0444, jack_kctl->jack_debugfs_root, jack_kctl,
 379                             &jack_kctl_status_fops);
 380
 381 #ifdef CONFIG_SND_JACK_INPUT_DEV
 382         debugfs_create_file("type", 0444, jack_kctl->jack_debugfs_root, jack_kctl,
 383                             &jack_type_fops);
 384 #endif
 385         return 0;
 386 }
 387
 388 static void snd_jack_remove_debugfs(struct snd_jack *jack)
 389 {
 390         struct snd_jack_kctl *jack_kctl;
 391
 392         list_for_each_entry(jack_kctl, &jack->kctl_list, list) {
 393                 debugfs_remove(jack_kctl->jack_debugfs_root);
 394                 jack_kctl->jack_debugfs_root = NULL;
 395         }
 396 }
 397 #else /* CONFIG_SND_JACK_INJECTION_DEBUG */
 398 static int snd_jack_debugfs_add_inject_node(struct snd_jack *jack,
 399                                             struct snd_jack_kctl *jack_kctl)
 400 {
 401         return 0;
 402 }
 403
 404 static void snd_jack_remove_debugfs(struct snd_jack *jack)
 405 {
 406 }
 407 #endif /* CONFIG_SND_JACK_INJECTION_DEBUG */
 408
 409 static void snd_jack_kctl_private_free(struct snd_kcontrol *kctl)
 410 {
 411         struct snd_jack_kctl *jack_kctl;
 412
 413         jack_kctl = kctl->private_data;
 414         if (jack_kctl) {
 415                 list_del(&jack_kctl->list);
 416                 kfree(jack_kctl);
 417         }
 418 }
 419
 420 static void snd_jack_kctl_add(struct snd_jack *jack, struct snd_jack_kctl *jack_kctl)
 421 {
 422         jack_kctl->jack = jack;
 423         list_add_tail(&jack_kctl->list, &jack->kctl_list);
 424         snd_jack_debugfs_add_inject_node(jack, jack_kctl);
 425 }
 426
 427 static struct snd_jack_kctl * snd_jack_kctl_new(struct snd_card *card, const char *name, unsigned int mask)
 428 {
 429         struct snd_kcontrol *kctl;
 430         struct snd_jack_kctl *jack_kctl;
 431         int err;
 432
 433         kctl = snd_kctl_jack_new(name, card);
 434         if (!kctl)
 435                 return NULL;
 436
 437         err = snd_ctl_add(card, kctl);
 438         if (err < 0)
 439                 return NULL;
 440
 441         jack_kctl = kzalloc(sizeof(*jack_kctl), GFP_KERNEL);
 442
 443         if (!jack_kctl)
 444                 goto error;
 445
 446         jack_kctl->kctl = kctl;
 447         jack_kctl->mask_bits = mask;
 448
 449         kctl->private_data = jack_kctl;
 450         kctl->private_free = snd_jack_kctl_private_free;
 451
 452         return jack_kctl;
 453 error:
 454         snd_ctl_free_one(kctl);
 455         return NULL;
 456 }
 457
 458 /**
 459  * snd_jack_add_new_kctl - Create a new snd_jack_kctl and add it to jack
 460  * @jack:  the jack instance which the kctl will attaching to
 461  * @name:  the name for the snd_kcontrol object
 462  * @mask:  a bitmask of enum snd_jack_type values that can be detected
 463  *         by this snd_jack_kctl object.
 464  *
 465  * Creates a new snd_kcontrol object and adds it to the jack kctl_list.
 466  *
 467  * Return: Zero if successful, or a negative error code on failure.
 468  */
 469 int snd_jack_add_new_kctl(struct snd_jack *jack, const char * name, int mask)
 470 {
 471         struct snd_jack_kctl *jack_kctl;
 472
 473         jack_kctl = snd_jack_kctl_new(jack->card, name, mask);
 474         if (!jack_kctl)
 475                 return -ENOMEM;
 476
 477         snd_jack_kctl_add(jack, jack_kctl);
 478         return 0;
 479 }
 480 EXPORT_SYMBOL(snd_jack_add_new_kctl);
 481
 482 /**
 483  * snd_jack_new - Create a new jack
 484  * @card:  the card instance
 485  * @id:    an identifying string for this jack
 486  * @type:  a bitmask of enum snd_jack_type values that can be detected by
 487  *         this jack
 488  * @jjack: Used to provide the allocated jack object to the caller.
 489  * @initial_kctl: if true, create a kcontrol and add it to the jack list.
 490  * @phantom_jack: Don't create a input device for phantom jacks.
 491  *
 492  * Creates a new jack object.
 493  *
 494  * Return: Zero if successful, or a negative error code on failure.
 495  * On success @jjack will be initialised.
 496  */
 497 int snd_jack_new(struct snd_card *card, const char *id, int type,
 498                  struct snd_jack **jjack, bool initial_kctl, bool phantom_jack)
 499 {
 500         struct snd_jack *jack;
 501         struct snd_jack_kctl *jack_kctl = NULL;
 502         int err;
 503         static const struct snd_device_ops ops = {
 504                 .dev_free = snd_jack_dev_free,
 505 #ifdef CONFIG_SND_JACK_INPUT_DEV
 506                 .dev_register = snd_jack_dev_register,
 507 #endif /* CONFIG_SND_JACK_INPUT_DEV */
 508                 .dev_disconnect = snd_jack_dev_disconnect,
 509         };
 510
 511         if (initial_kctl) {
 512                 jack_kctl = snd_jack_kctl_new(card, id, type);
 513                 if (!jack_kctl)
 514                         return -ENOMEM;
 515         }
 516
 517         jack = kzalloc(sizeof(struct snd_jack), GFP_KERNEL);
 518         if (jack == NULL)
 519                 return -ENOMEM;
 520
 521         jack->id = kstrdup(id, GFP_KERNEL);
 522         if (jack->id == NULL) {
 523                 kfree(jack);
 524                 return -ENOMEM;
 525         }
 526
 527 #ifdef CONFIG_SND_JACK_INPUT_DEV
 528         mutex_init(&jack->input_dev_lock);
 529
 530         /* don't create input device for phantom jack */
 531         if (!phantom_jack) {
 532                 int i;
 533
 534                 jack->input_dev = input_allocate_device();
 535                 if (jack->input_dev == NULL) {
 536                         err = -ENOMEM;
 537                         goto fail_input;
 538                 }
 539
 540                 jack->input_dev->phys = "ALSA";
 541
 542                 jack->type = type;
 543
 544                 for (i = 0; i < SND_JACK_SWITCH_TYPES; i++)
 545                         if (type & (1 << i))
 546                                 input_set_capability(jack->input_dev, EV_SW,
 547                                                      jack_switch_types[i]);
 548
 549         }
 550 #endif /* CONFIG_SND_JACK_INPUT_DEV */
 551
 552         err = snd_device_new(card, SNDRV_DEV_JACK, jack, &ops);
 553         if (err < 0)
 554                 goto fail_input;
 555
 556         jack->card = card;
 557         INIT_LIST_HEAD(&jack->kctl_list);
 558
 559         if (initial_kctl)
 560                 snd_jack_kctl_add(jack, jack_kctl);
 561
 562         *jjack = jack;
 563
 564         return 0;
 565
 566 fail_input:
 567 #ifdef CONFIG_SND_JACK_INPUT_DEV
 568         input_free_device(jack->input_dev);
 569 #endif
 570         kfree(jack->id);
 571         kfree(jack);
 572         return err;
 573 }
 574 EXPORT_SYMBOL(snd_jack_new);
 575
 576 #ifdef CONFIG_SND_JACK_INPUT_DEV
 577 /**
 578  * snd_jack_set_parent - Set the parent device for a jack
 579  *
 580  * @jack:   The jack to configure
 581  * @parent: The device to set as parent for the jack.
 582  *
 583  * Set the parent for the jack devices in the device tree.  This
 584  * function is only valid prior to registration of the jack.  If no
 585  * parent is configured then the parent device will be the sound card.
 586  */
 587 void snd_jack_set_parent(struct snd_jack *jack, struct device *parent)
 588 {
 589         WARN_ON(jack->registered);
 590         guard(mutex)(&jack->input_dev_lock);
 591         if (jack->input_dev)
 592                 jack->input_dev->dev.parent = parent;
 593 }
 594 EXPORT_SYMBOL(snd_jack_set_parent);
 595
 596 /**
 597  * snd_jack_set_key - Set a key mapping on a jack
 598  *
 599  * @jack:    The jack to configure
 600  * @type:    Jack report type for this key
 601  * @keytype: Input layer key type to be reported
 602  *
 603  * Map a SND_JACK_BTN_* button type to an input layer key, allowing
 604  * reporting of keys on accessories via the jack abstraction.  If no
 605  * mapping is provided but keys are enabled in the jack type then
 606  * BTN_n numeric buttons will be reported.
 607  *
 608  * If jacks are not reporting via the input API this call will have no
 609  * effect.
 610  *
 611  * Note that this is intended to be use by simple devices with small
 612  * numbers of keys that can be reported.  It is also possible to
 613  * access the input device directly - devices with complex input
 614  * capabilities on accessories should consider doing this rather than
 615  * using this abstraction.
 616  *
 617  * This function may only be called prior to registration of the jack.
 618  *
 619  * Return: Zero if successful, or a negative error code on failure.
 620  */
 621 int snd_jack_set_key(struct snd_jack *jack, enum snd_jack_types type,
 622                      int keytype)
 623 {
 624         int key = fls(SND_JACK_BTN_0) - fls(type);
 625
 626         WARN_ON(jack->registered);
 627
 628         if (!keytype || key >= ARRAY_SIZE(jack->key))
 629                 return -EINVAL;
 630
 631         jack->type |= type;
 632         jack->key[key] = keytype;
 633         return 0;
 634 }
 635 EXPORT_SYMBOL(snd_jack_set_key);
 636 #endif /* CONFIG_SND_JACK_INPUT_DEV */
 637
 638 /**
 639  * snd_jack_report - Report the current status of a jack
 640  * Note: This function uses mutexes and should be called from a
 641  * context which can sleep (such as a workqueue).
 642  *
 643  * @jack:   The jack to report status for
 644  * @status: The current status of the jack
 645  */
 646 void snd_jack_report(struct snd_jack *jack, int status)
 647 {
 648         struct snd_jack_kctl *jack_kctl;
 649         unsigned int mask_bits = 0;
 650 #ifdef CONFIG_SND_JACK_INPUT_DEV
 651         struct input_dev *idev;
 652         int i;
 653 #endif
 654
 655         if (!jack)
 656                 return;
 657
 658         jack->hw_status_cache = status;
 659
 660         list_for_each_entry(jack_kctl, &jack->kctl_list, list)
 661                 if (jack_kctl->sw_inject_enable)
 662                         mask_bits |= jack_kctl->mask_bits;
 663                 else
 664                         snd_kctl_jack_report(jack->card, jack_kctl->kctl,
 665                                              status & jack_kctl->mask_bits);
 666
 667 #ifdef CONFIG_SND_JACK_INPUT_DEV
 668         idev = input_get_device(jack->input_dev);
 669         if (!idev)
 670                 return;
 671
 672         for (i = 0; i < ARRAY_SIZE(jack->key); i++) {
 673                 int testbit = ((SND_JACK_BTN_0 >> i) & ~mask_bits);
 674
 675                 if (jack->type & testbit)
 676                         input_report_key(idev, jack->key[i],
 677                                          status & testbit);
 678         }
 679
 680         for (i = 0; i < ARRAY_SIZE(jack_switch_types); i++) {
 681                 int testbit = ((1 << i) & ~mask_bits);
 682
 683                 if (jack->type & testbit)
 684                         input_report_switch(idev,
 685                                             jack_switch_types[i],
 686                                             status & testbit);
 687         }
 688
 689         input_sync(idev);
 690         input_put_device(idev);
 691 #endif /* CONFIG_SND_JACK_INPUT_DEV */
 692 }
 693 EXPORT_SYMBOL(snd_jack_report);