#define SND_JACK_SWITCH_TYPES 6
 
 struct snd_jack {
-       struct input_dev *input_dev;
        struct list_head kctl_list;
        struct snd_card *card;
+       const char *id;
+#ifdef CONFIG_SND_JACK_INPUT_DEV
+       struct input_dev *input_dev;
        int registered;
        int type;
-       const char *id;
        char name[100];
        unsigned int key[6];   /* Keep in sync with definitions above */
+#endif /* CONFIG_SND_JACK_INPUT_DEV */
        void *private_data;
        void (*private_free)(struct snd_jack *);
 };
 int snd_jack_new(struct snd_card *card, const char *id, int type,
                 struct snd_jack **jack, bool initial_kctl, bool phantom_jack);
 int snd_jack_add_new_kctl(struct snd_jack *jack, const char * name, int mask);
+#ifdef CONFIG_SND_JACK_INPUT_DEV
 void snd_jack_set_parent(struct snd_jack *jack, struct device *parent);
 int snd_jack_set_key(struct snd_jack *jack, enum snd_jack_types type,
                     int keytype);
-
+#endif
 void snd_jack_report(struct snd_jack *jack, int status);
 
 #else
        return 0;
 }
 
+static inline void snd_jack_report(struct snd_jack *jack, int status)
+{
+}
+
+#endif
+
+#if !defined(CONFIG_SND_JACK) || !defined(CONFIG_SND_JACK_INPUT_DEV)
 static inline void snd_jack_set_parent(struct snd_jack *jack,
                                       struct device *parent)
 {
 {
        return 0;
 }
-
-static inline void snd_jack_report(struct snd_jack *jack, int status)
-{
-}
-
-#endif
+#endif /* !CONFIG_SND_JACK || !CONFIG_SND_JACK_INPUT_DEV */
 
 #endif
 
        unsigned int mask_bits; /* only masked status bits are reported via kctl */
 };
 
+#ifdef CONFIG_SND_JACK_INPUT_DEV
 static int jack_switch_types[SND_JACK_SWITCH_TYPES] = {
        SW_HEADPHONE_INSERT,
        SW_MICROPHONE_INSERT,
        SW_VIDEOOUT_INSERT,
        SW_LINEIN_INSERT,
 };
+#endif /* CONFIG_SND_JACK_INPUT_DEV */
 
 static int snd_jack_dev_disconnect(struct snd_device *device)
 {
+#ifdef CONFIG_SND_JACK_INPUT_DEV
        struct snd_jack *jack = device->device_data;
 
        if (!jack->input_dev)
        else
                input_free_device(jack->input_dev);
        jack->input_dev = NULL;
+#endif /* CONFIG_SND_JACK_INPUT_DEV */
        return 0;
 }
 
        return 0;
 }
 
+#ifdef CONFIG_SND_JACK_INPUT_DEV
 static int snd_jack_dev_register(struct snd_device *device)
 {
        struct snd_jack *jack = device->device_data;
 
        return err;
 }
+#endif /* CONFIG_SND_JACK_INPUT_DEV */
 
 static void snd_jack_kctl_private_free(struct snd_kcontrol *kctl)
 {
        struct snd_jack *jack;
        struct snd_jack_kctl *jack_kctl = NULL;
        int err;
-       int i;
        static struct snd_device_ops ops = {
                .dev_free = snd_jack_dev_free,
+#ifdef CONFIG_SND_JACK_INPUT_DEV
                .dev_register = snd_jack_dev_register,
                .dev_disconnect = snd_jack_dev_disconnect,
+#endif /* CONFIG_SND_JACK_INPUT_DEV */
        };
 
        if (initial_kctl) {
 
        /* don't creat input device for phantom jack */
        if (!phantom_jack) {
+#ifdef CONFIG_SND_JACK_INPUT_DEV
+               int i;
+
                jack->input_dev = input_allocate_device();
                if (jack->input_dev == NULL) {
                        err = -ENOMEM;
                                input_set_capability(jack->input_dev, EV_SW,
                                                     jack_switch_types[i]);
 
+#endif /* CONFIG_SND_JACK_INPUT_DEV */
        }
 
        err = snd_device_new(card, SNDRV_DEV_JACK, jack, &ops);
        return 0;
 
 fail_input:
+#ifdef CONFIG_SND_JACK_INPUT_DEV
        input_free_device(jack->input_dev);
+#endif
        kfree(jack->id);
        kfree(jack);
        return err;
 }
 EXPORT_SYMBOL(snd_jack_new);
 
+#ifdef CONFIG_SND_JACK_INPUT_DEV
 /**
  * snd_jack_set_parent - Set the parent device for a jack
  *
 
        jack->type |= type;
        jack->key[key] = keytype;
-
        return 0;
 }
 EXPORT_SYMBOL(snd_jack_set_key);
+#endif /* CONFIG_SND_JACK_INPUT_DEV */
 
 /**
  * snd_jack_report - Report the current status of a jack
 void snd_jack_report(struct snd_jack *jack, int status)
 {
        struct snd_jack_kctl *jack_kctl;
+#ifdef CONFIG_SND_JACK_INPUT_DEV
        int i;
+#endif
 
        if (!jack)
                return;
                snd_kctl_jack_report(jack->card, jack_kctl->kctl,
                                            status & jack_kctl->mask_bits);
 
+#ifdef CONFIG_SND_JACK_INPUT_DEV
        if (!jack->input_dev)
                return;
 
        }
 
        input_sync(jack->input_dev);
-
+#endif /* CONFIG_SND_JACK_INPUT_DEV */
 }
 EXPORT_SYMBOL(snd_jack_report);