[ALSA] Unregister device files at disconnection

Orignally proposed by Sam Revitch <sam.revitch@gmail.com>.
Unregister device files at disconnection to avoid the futher accesses.
Also, the dev_unregister callback is removed and replaced with the
combination of disconnect + free.
A new function snd_card_free_when_closed() is introduced, which is
used in USB disconnect callback.

Signed-off-by: Takashi Iwai <tiwai@suse.de>
Signed-off-by: Jaroslav Kysela <perex@suse.cz>

diff --git a/include/sound/core.h b/include/sound/core.h
index bab3ff457e40cfa00e21b40f2d9e14fee12f8e07..cf4001cf62484c9dcb5f3aa8f9511753f674dcb8 100644 (file)
--- a/include/sound/core.h
+++ b/include/sound/core.h
@@ -71,7 +71,6 @@ struct snd_device_ops {
        int (*dev_free)(struct snd_device *dev);
        int (*dev_register)(struct snd_device *dev);
        int (*dev_disconnect)(struct snd_device *dev);
-       int (*dev_unregister)(struct snd_device *dev);
 };
 
 struct snd_device {
@@ -131,6 +130,7 @@ struct snd_card {
                                                                state */
        spinlock_t files_lock;          /* lock the files for this card */
        int shutdown;                   /* this card is going down */
+       int free_on_last_close;         /* free in context of file_release */
        wait_queue_head_t shutdown_sleep;
        struct work_struct free_workq;  /* for free in workqueue */
        struct device *dev;
@@ -244,6 +244,7 @@ struct snd_card *snd_card_new(int idx, const char *id,
                         struct module *module, int extra_size);
 int snd_card_disconnect(struct snd_card *card);
 int snd_card_free(struct snd_card *card);
+int snd_card_free_when_closed(struct snd_card *card);
 int snd_card_free_in_thread(struct snd_card *card);
 int snd_card_register(struct snd_card *card);
 int snd_card_info_init(void);

diff --git a/include/sound/timer.h b/include/sound/timer.h
index 5ece2bf541dce81d9c289b10a81e23703369adab..d42c083db1dac0d9dbdfa599b2228675123a5526 100644 (file)
--- a/include/sound/timer.h
+++ b/include/sound/timer.h
@@ -129,7 +129,6 @@ void snd_timer_notify(struct snd_timer *timer, int event, struct timespec *tstam
 int snd_timer_global_new(char *id, int device, struct snd_timer **rtimer);
 int snd_timer_global_free(struct snd_timer *timer);
 int snd_timer_global_register(struct snd_timer *timer);
-int snd_timer_global_unregister(struct snd_timer *timer);
 
 int snd_timer_open(struct snd_timer_instance **ti, char *owner, struct snd_timer_id *tid, unsigned int slave_id);
 int snd_timer_close(struct snd_timer_instance *timeri);

diff --git a/sound/core/control.c b/sound/core/control.c
index e9c8854d2f7b47f6d4d781cb4f62090e15bb75df..f0c7272a2d48d0b798df2ad68d60f4de824873fe 100644 (file)
--- a/sound/core/control.c
+++ b/sound/core/control.c
@@ -1375,6 +1375,11 @@ static int snd_ctl_dev_disconnect(struct snd_device *device)
        struct snd_card *card = device->device_data;
        struct list_head *flist;
        struct snd_ctl_file *ctl;
+       int err, cardnum;
+
+       snd_assert(card != NULL, return -ENXIO);
+       cardnum = card->number;
+       snd_assert(cardnum >= 0 && cardnum < SNDRV_CARDS, return -ENXIO);
 
        down_read(&card->controls_rwsem);
        list_for_each(flist, &card->ctl_files) {
@@ -1383,6 +1388,10 @@ static int snd_ctl_dev_disconnect(struct snd_device *device)
                kill_fasync(&ctl->fasync, SIGIO, POLL_ERR);
        }
        up_read(&card->controls_rwsem);
+
+       if ((err = snd_unregister_device(SNDRV_DEVICE_TYPE_CONTROL,
+                                        card, -1)) < 0)
+               return err;
        return 0;
 }
 
@@ -1403,23 +1412,6 @@ static int snd_ctl_dev_free(struct snd_device *device)
        return 0;
 }
 
-/*
- * de-registration of the control device
- */
-static int snd_ctl_dev_unregister(struct snd_device *device)
-{
-       struct snd_card *card = device->device_data;
-       int err, cardnum;
-
-       snd_assert(card != NULL, return -ENXIO);
-       cardnum = card->number;
-       snd_assert(cardnum >= 0 && cardnum < SNDRV_CARDS, return -ENXIO);
-       if ((err = snd_unregister_device(SNDRV_DEVICE_TYPE_CONTROL,
-                                        card, -1)) < 0)
-               return err;
-       return snd_ctl_dev_free(device);
-}
-
 /*
  * create control core:
  * called from init.c
@@ -1430,7 +1422,6 @@ int snd_ctl_create(struct snd_card *card)
                .dev_free = snd_ctl_dev_free,
                .dev_register = snd_ctl_dev_register,
                .dev_disconnect = snd_ctl_dev_disconnect,
-               .dev_unregister = snd_ctl_dev_unregister
        };
 
        snd_assert(card != NULL, return -ENXIO);

diff --git a/sound/core/device.c b/sound/core/device.c
index 6ce4da4a1081995317c79523c22bfefd63786529..ccb25816ac9ececd151dad12fe042fe65ad97374 100644 (file)
--- a/sound/core/device.c
+++ b/sound/core/device.c
@@ -71,7 +71,7 @@ EXPORT_SYMBOL(snd_device_new);
  * @device_data: the data pointer to release
  *
  * Removes the device from the list on the card and invokes the
- * callback, dev_unregister or dev_free, corresponding to the state.
+ * callbacks, dev_disconnect and dev_free, corresponding to the state.
  * Then release the device.
  *
  * Returns zero if successful, or a negative error code on failure or if the
@@ -90,16 +90,14 @@ int snd_device_free(struct snd_card *card, void *device_data)
                        continue;
                /* unlink */
                list_del(&dev->list);
-               if ((dev->state == SNDRV_DEV_REGISTERED ||
-                    dev->state == SNDRV_DEV_DISCONNECTED) &&
-                   dev->ops->dev_unregister) {
-                       if (dev->ops->dev_unregister(dev))
-                               snd_printk(KERN_ERR "device unregister failure\n");
-               } else {
-                       if (dev->ops->dev_free) {
-                               if (dev->ops->dev_free(dev))
-                                       snd_printk(KERN_ERR "device free failure\n");
-                       }
+               if (dev->state == SNDRV_DEV_REGISTERED &&
+                   dev->ops->dev_disconnect)
+                       if (dev->ops->dev_disconnect(dev))
+                               snd_printk(KERN_ERR
+                                          "device disconnect failure\n");
+               if (dev->ops->dev_free) {
+                       if (dev->ops->dev_free(dev))
+                               snd_printk(KERN_ERR "device free failure\n");
                }
                kfree(dev);
                return 0;

diff --git a/sound/core/hwdep.c b/sound/core/hwdep.c
index cbd8a63282b69bda289068b5717714094d018e4e..9aa9d94891f0a8eb01b41faac8fcefe54e1aa2a1 100644 (file)
--- a/sound/core/hwdep.c
+++ b/sound/core/hwdep.c
@@ -42,7 +42,7 @@ static DEFINE_MUTEX(register_mutex);
 static int snd_hwdep_free(struct snd_hwdep *hwdep);
 static int snd_hwdep_dev_free(struct snd_device *device);
 static int snd_hwdep_dev_register(struct snd_device *device);
-static int snd_hwdep_dev_unregister(struct snd_device *device);
+static int snd_hwdep_dev_disconnect(struct snd_device *device);
 
 
 static struct snd_hwdep *snd_hwdep_search(struct snd_card *card, int device)
@@ -353,7 +353,7 @@ int snd_hwdep_new(struct snd_card *card, char *id, int device,
        static struct snd_device_ops ops = {
                .dev_free = snd_hwdep_dev_free,
                .dev_register = snd_hwdep_dev_register,
-               .dev_unregister = snd_hwdep_dev_unregister
+               .dev_disconnect = snd_hwdep_dev_disconnect,
        };
 
        snd_assert(rhwdep != NULL, return -EINVAL);
@@ -439,7 +439,7 @@ static int snd_hwdep_dev_register(struct snd_device *device)
        return 0;
 }
 
-static int snd_hwdep_dev_unregister(struct snd_device *device)
+static int snd_hwdep_dev_disconnect(struct snd_device *device)
 {
        struct snd_hwdep *hwdep = device->device_data;
 
@@ -454,9 +454,9 @@ static int snd_hwdep_dev_unregister(struct snd_device *device)
                snd_unregister_oss_device(hwdep->oss_type, hwdep->card, hwdep->device);
 #endif
        snd_unregister_device(SNDRV_DEVICE_TYPE_HWDEP, hwdep->card, hwdep->device);
-       list_del(&hwdep->list);
+       list_del_init(&hwdep->list);
        mutex_unlock(&register_mutex);
-       return snd_hwdep_free(hwdep);
+       return 0;
 }
 
 #ifdef CONFIG_PROC_FS

diff --git a/sound/core/init.c b/sound/core/init.c
index 1ecb029ff4c91b9e8bfda319ae45dbc78ec3f8e5..5850d99d21e32af63184db89794c54c2ee8a3bf9 100644 (file)
--- a/sound/core/init.c
+++ b/sound/core/init.c
@@ -327,22 +327,10 @@ EXPORT_SYMBOL(snd_card_disconnect);
  *  Returns zero. Frees all associated devices and frees the control
  *  interface associated to given soundcard.
  */
-int snd_card_free(struct snd_card *card)
+static int snd_card_do_free(struct snd_card *card)
 {
        struct snd_shutdown_f_ops *s_f_ops;
 
-       if (card == NULL)
-               return -EINVAL;
-       mutex_lock(&snd_card_mutex);
-       snd_cards[card->number] = NULL;
-       mutex_unlock(&snd_card_mutex);
-
-#ifdef CONFIG_PM
-       wake_up(&card->power_sleep);
-#endif
-       /* wait, until all devices are ready for the free operation */
-       wait_event(card->shutdown_sleep, card->files == NULL);
-
 #if defined(CONFIG_SND_MIXER_OSS) || defined(CONFIG_SND_MIXER_OSS_MODULE)
        if (snd_mixer_oss_notify_callback)
                snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_FREE);
@@ -371,10 +359,55 @@ int snd_card_free(struct snd_card *card)
                card->s_f_ops = s_f_ops->next;
                kfree(s_f_ops);
        }
+       kfree(card);
+       return 0;
+}
+
+static int snd_card_free_prepare(struct snd_card *card)
+{
+       if (card == NULL)
+               return -EINVAL;
+       (void) snd_card_disconnect(card);
        mutex_lock(&snd_card_mutex);
+       snd_cards[card->number] = NULL;
        snd_cards_lock &= ~(1 << card->number);
        mutex_unlock(&snd_card_mutex);
-       kfree(card);
+#ifdef CONFIG_PM
+       wake_up(&card->power_sleep);
+#endif
+       return 0;
+}
+
+int snd_card_free_when_closed(struct snd_card *card)
+{
+       int free_now = 0;
+       int ret = snd_card_free_prepare(card);
+       if (ret)
+               return ret;
+
+       spin_lock(&card->files_lock);
+       if (card->files == NULL)
+               free_now = 1;
+       else
+               card->free_on_last_close = 1;
+       spin_unlock(&card->files_lock);
+
+       if (free_now)
+               snd_card_do_free(card);
+       return 0;
+}
+
+EXPORT_SYMBOL(snd_card_free_when_closed);
+
+int snd_card_free(struct snd_card *card)
+{
+       int ret = snd_card_free_prepare(card);
+       if (ret)
+               return ret;
+
+       /* wait, until all devices are ready for the free operation */
+       wait_event(card->shutdown_sleep, card->files == NULL);
+       snd_card_do_free(card);
        return 0;
 }
 
@@ -718,6 +751,7 @@ EXPORT_SYMBOL(snd_card_file_add);
 int snd_card_file_remove(struct snd_card *card, struct file *file)
 {
        struct snd_monitor_file *mfile, *pfile = NULL;
+       int last_close = 0;
 
        spin_lock(&card->files_lock);
        mfile = card->files;
@@ -732,9 +766,14 @@ int snd_card_file_remove(struct snd_card *card, struct file *file)
                pfile = mfile;
                mfile = mfile->next;
        }
-       spin_unlock(&card->files_lock);
        if (card->files == NULL)
+               last_close = 1;
+       spin_unlock(&card->files_lock);
+       if (last_close) {
                wake_up(&card->shutdown_sleep);
+               if (card->free_on_last_close)
+                       snd_card_do_free(card);
+       }
        if (!mfile) {
                snd_printk(KERN_ERR "ALSA card file remove problem (%p)\n", file);
                return -ENOENT;

diff --git a/sound/core/oss/mixer_oss.c b/sound/core/oss/mixer_oss.c
index 00c95def95aa574c07585da041571d4e751a6c94..f4c67042e3ac16ba72bb6effe6a2e93550fc7bf5 100644 (file)
--- a/sound/core/oss/mixer_oss.c
+++ b/sound/core/oss/mixer_oss.c
@@ -1310,21 +1310,19 @@ static int snd_mixer_oss_notify_handler(struct snd_card *card, int cmd)
                card->mixer_oss = mixer;
                snd_mixer_oss_build(mixer);
                snd_mixer_oss_proc_init(mixer);
-       } else if (cmd == SND_MIXER_OSS_NOTIFY_DISCONNECT) {
-               mixer = card->mixer_oss;
-               if (mixer == NULL || !mixer->oss_dev_alloc)
-                       return 0;
-               snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_MIXER, mixer->card, 0);
-               mixer->oss_dev_alloc = 0;
-       } else {                /* free */
+       } else {
                mixer = card->mixer_oss;
                if (mixer == NULL)
                        return 0;
+               if (mixer->oss_dev_alloc) {
 #ifdef SNDRV_OSS_INFO_DEV_MIXERS
-               snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_MIXERS, mixer->card->number);
+                       snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_MIXERS, mixer->card->number);
 #endif
-               if (mixer->oss_dev_alloc)
                        snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_MIXER, mixer->card, 0);
+                       mixer->oss_dev_alloc = 0;
+               }
+               if (cmd == SND_MIXER_OSS_NOTIFY_DISCONNECT)
+                       return 0;
                snd_mixer_oss_proc_done(mixer);
                return snd_mixer_oss_free1(mixer);
        }

diff --git a/sound/core/oss/pcm_oss.c b/sound/core/oss/pcm_oss.c
index a92b93e5ebd58215ca648736d4e510f2c4ca09a3..505b23ec4058c29a4407d8cd29c78e0c3509bdb1 100644 (file)
--- a/sound/core/oss/pcm_oss.c
+++ b/sound/core/oss/pcm_oss.c
@@ -2929,25 +2929,23 @@ static int snd_pcm_oss_disconnect_minor(struct snd_pcm *pcm)
                        snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_PCM,
                                                  pcm->card, 1);
                }
-       }
-       return 0;
-}
-
-static int snd_pcm_oss_unregister_minor(struct snd_pcm *pcm)
-{
-       snd_pcm_oss_disconnect_minor(pcm);
-       if (pcm->oss.reg) {
                if (dsp_map[pcm->card->number] == (int)pcm->device) {
 #ifdef SNDRV_OSS_INFO_DEV_AUDIO
                        snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_AUDIO, pcm->card->number);
 #endif
                }
                pcm->oss.reg = 0;
-               snd_pcm_oss_proc_done(pcm);
        }
        return 0;
 }
 
+static int snd_pcm_oss_unregister_minor(struct snd_pcm *pcm)
+{
+       snd_pcm_oss_disconnect_minor(pcm);
+       snd_pcm_oss_proc_done(pcm);
+       return 0;
+}
+
 static struct snd_pcm_notify snd_pcm_oss_notify =
 {
        .n_register =   snd_pcm_oss_register_minor,

diff --git a/sound/core/pcm.c b/sound/core/pcm.c
index b8602471f7e52d326e5a919eb900ef2d03303ea7..f52178abf1209cbd141bad0c1f55838ca22ea2ee 100644 (file)
--- a/sound/core/pcm.c
+++ b/sound/core/pcm.c
@@ -42,7 +42,6 @@ static int snd_pcm_free(struct snd_pcm *pcm);
 static int snd_pcm_dev_free(struct snd_device *device);
 static int snd_pcm_dev_register(struct snd_device *device);
 static int snd_pcm_dev_disconnect(struct snd_device *device);
-static int snd_pcm_dev_unregister(struct snd_device *device);
 
 static struct snd_pcm *snd_pcm_search(struct snd_card *card, int device)
 {
@@ -680,7 +679,6 @@ int snd_pcm_new(struct snd_card *card, char *id, int device,
                .dev_free = snd_pcm_dev_free,
                .dev_register = snd_pcm_dev_register,
                .dev_disconnect = snd_pcm_dev_disconnect,
-               .dev_unregister = snd_pcm_dev_unregister
        };
 
        snd_assert(rpcm != NULL, return -EINVAL);
@@ -724,6 +722,7 @@ static void snd_pcm_free_stream(struct snd_pcm_str * pstr)
        substream = pstr->substream;
        while (substream) {
                substream_next = substream->next;
+               snd_pcm_timer_done(substream);
                snd_pcm_substream_proc_done(substream);
                kfree(substream);
                substream = substream_next;
@@ -740,7 +739,12 @@ static void snd_pcm_free_stream(struct snd_pcm_str * pstr)
 
 static int snd_pcm_free(struct snd_pcm *pcm)
 {
+       struct snd_pcm_notify *notify;
+
        snd_assert(pcm != NULL, return -ENXIO);
+       list_for_each_entry(notify, &snd_pcm_notify_list, list) {
+               notify->n_unregister(pcm);
+       }
        if (pcm->private_free)
                pcm->private_free(pcm);
        snd_pcm_lib_preallocate_free_for_all(pcm);
@@ -955,35 +959,22 @@ static int snd_pcm_dev_register(struct snd_device *device)
 static int snd_pcm_dev_disconnect(struct snd_device *device)
 {
        struct snd_pcm *pcm = device->device_data;
-       struct list_head *list;
+       struct snd_pcm_notify *notify;
        struct snd_pcm_substream *substream;
-       int cidx;
+       int cidx, devtype;
 
        mutex_lock(&register_mutex);
+       if (list_empty(&pcm->list))
+               goto unlock;
+
        list_del_init(&pcm->list);
        for (cidx = 0; cidx < 2; cidx++)
                for (substream = pcm->streams[cidx].substream; substream; substream = substream->next)
                        if (substream->runtime)
                                substream->runtime->status->state = SNDRV_PCM_STATE_DISCONNECTED;
-       list_for_each(list, &snd_pcm_notify_list) {
-               struct snd_pcm_notify *notify;
-               notify = list_entry(list, struct snd_pcm_notify, list);
+       list_for_each_entry(notify, &snd_pcm_notify_list, list) {
                notify->n_disconnect(pcm);
        }
-       mutex_unlock(&register_mutex);
-       return 0;
-}
-
-static int snd_pcm_dev_unregister(struct snd_device *device)
-{
-       int cidx, devtype;
-       struct snd_pcm_substream *substream;
-       struct list_head *list;
-       struct snd_pcm *pcm = device->device_data;
-
-       snd_assert(pcm != NULL, return -ENXIO);
-       mutex_lock(&register_mutex);
-       list_del(&pcm->list);
        for (cidx = 0; cidx < 2; cidx++) {
                devtype = -1;
                switch (cidx) {
@@ -995,23 +986,20 @@ static int snd_pcm_dev_unregister(struct snd_device *device)
                        break;
                }
                snd_unregister_device(devtype, pcm->card, pcm->device);
-               for (substream = pcm->streams[cidx].substream; substream; substream = substream->next)
-                       snd_pcm_timer_done(substream);
-       }
-       list_for_each(list, &snd_pcm_notify_list) {
-               struct snd_pcm_notify *notify;
-               notify = list_entry(list, struct snd_pcm_notify, list);
-               notify->n_unregister(pcm);
        }
+ unlock:
        mutex_unlock(&register_mutex);
-       return snd_pcm_free(pcm);
+       return 0;
 }
 
 int snd_pcm_notify(struct snd_pcm_notify *notify, int nfree)
 {
        struct list_head *p;
 
-       snd_assert(notify != NULL && notify->n_register != NULL && notify->n_unregister != NULL, return -EINVAL);
+       snd_assert(notify != NULL &&
+                  notify->n_register != NULL &&
+                  notify->n_unregister != NULL &&
+                  notify->n_disconnect, return -EINVAL);
        mutex_lock(&register_mutex);
        if (nfree) {
                list_del(&notify->list);

diff --git a/sound/core/rawmidi.c b/sound/core/rawmidi.c
index 51577c22f8ceb8561f3d7a2397d5854eb20c9ea7..8a2bdfae63e39968fde086198f0e84243e2aaf62 100644 (file)
--- a/sound/core/rawmidi.c
+++ b/sound/core/rawmidi.c
@@ -55,7 +55,6 @@ static int snd_rawmidi_free(struct snd_rawmidi *rawmidi);
 static int snd_rawmidi_dev_free(struct snd_device *device);
 static int snd_rawmidi_dev_register(struct snd_device *device);
 static int snd_rawmidi_dev_disconnect(struct snd_device *device);
-static int snd_rawmidi_dev_unregister(struct snd_device *device);
 
 static LIST_HEAD(snd_rawmidi_devices);
 static DEFINE_MUTEX(register_mutex);
@@ -1426,7 +1425,6 @@ int snd_rawmidi_new(struct snd_card *card, char *id, int device,
                .dev_free = snd_rawmidi_dev_free,
                .dev_register = snd_rawmidi_dev_register,
                .dev_disconnect = snd_rawmidi_dev_disconnect,
-               .dev_unregister = snd_rawmidi_dev_unregister
        };
 
        snd_assert(rrawmidi != NULL, return -EINVAL);
@@ -1479,6 +1477,14 @@ static void snd_rawmidi_free_substreams(struct snd_rawmidi_str *stream)
 static int snd_rawmidi_free(struct snd_rawmidi *rmidi)
 {
        snd_assert(rmidi != NULL, return -ENXIO);       
+
+       snd_info_free_entry(rmidi->proc_entry);
+       rmidi->proc_entry = NULL;
+       mutex_lock(&register_mutex);
+       if (rmidi->ops && rmidi->ops->dev_unregister)
+               rmidi->ops->dev_unregister(rmidi);
+       mutex_unlock(&register_mutex);
+
        snd_rawmidi_free_substreams(&rmidi->streams[SNDRV_RAWMIDI_STREAM_INPUT]);
        snd_rawmidi_free_substreams(&rmidi->streams[SNDRV_RAWMIDI_STREAM_OUTPUT]);
        if (rmidi->private_free)
@@ -1587,21 +1593,6 @@ static int snd_rawmidi_dev_disconnect(struct snd_device *device)
 
        mutex_lock(&register_mutex);
        list_del_init(&rmidi->list);
-       mutex_unlock(&register_mutex);
-       return 0;
-}
-
-static int snd_rawmidi_dev_unregister(struct snd_device *device)
-{
-       struct snd_rawmidi *rmidi = device->device_data;
-
-       snd_assert(rmidi != NULL, return -ENXIO);
-       mutex_lock(&register_mutex);
-       list_del(&rmidi->list);
-       if (rmidi->proc_entry) {
-               snd_info_free_entry(rmidi->proc_entry);
-               rmidi->proc_entry = NULL;
-       }
 #ifdef CONFIG_SND_OSSEMUL
        if (rmidi->ossreg) {
                if ((int)rmidi->device == midi_map[rmidi->card->number]) {
@@ -1615,17 +1606,9 @@ static int snd_rawmidi_dev_unregister(struct snd_device *device)
                rmidi->ossreg = 0;
        }
 #endif /* CONFIG_SND_OSSEMUL */
-       if (rmidi->ops && rmidi->ops->dev_unregister)
-               rmidi->ops->dev_unregister(rmidi);
        snd_unregister_device(SNDRV_DEVICE_TYPE_RAWMIDI, rmidi->card, rmidi->device);
        mutex_unlock(&register_mutex);
-#if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE))
-       if (rmidi->seq_dev) {
-               snd_device_free(rmidi->card, rmidi->seq_dev);
-               rmidi->seq_dev = NULL;
-       }
-#endif
-       return snd_rawmidi_free(rmidi);
+       return 0;
 }
 
 /**

diff --git a/sound/core/rtctimer.c b/sound/core/rtctimer.c
index 84704ccb1829385416f28d7dbcc0a3ad2a5d5e9e..412dd62b654ec2907b3108df5415b0697032e29c 100644 (file)
--- a/sound/core/rtctimer.c
+++ b/sound/core/rtctimer.c
@@ -156,7 +156,7 @@ static int __init rtctimer_init(void)
 static void __exit rtctimer_exit(void)
 {
        if (rtctimer) {
-               snd_timer_global_unregister(rtctimer);
+               snd_timer_global_free(rtctimer);
                rtctimer = NULL;
        }
 }

diff --git a/sound/core/seq/seq_device.c b/sound/core/seq/seq_device.c
index b85954e956d476b6241a0a4f0c0393ae2dcbc496..b79d011813c026436b9b8c311daec32962d48ac6 100644 (file)
--- a/sound/core/seq/seq_device.c
+++ b/sound/core/seq/seq_device.c
@@ -90,7 +90,6 @@ static int snd_seq_device_free(struct snd_seq_device *dev);
 static int snd_seq_device_dev_free(struct snd_device *device);
 static int snd_seq_device_dev_register(struct snd_device *device);
 static int snd_seq_device_dev_disconnect(struct snd_device *device);
-static int snd_seq_device_dev_unregister(struct snd_device *device);
 
 static int init_device(struct snd_seq_device *dev, struct ops_list *ops);
 static int free_device(struct snd_seq_device *dev, struct ops_list *ops);
@@ -189,7 +188,6 @@ int snd_seq_device_new(struct snd_card *card, int device, char *id, int argsize,
                .dev_free = snd_seq_device_dev_free,
                .dev_register = snd_seq_device_dev_register,
                .dev_disconnect = snd_seq_device_dev_disconnect,
-               .dev_unregister = snd_seq_device_dev_unregister
        };
 
        if (result)
@@ -308,15 +306,6 @@ static int snd_seq_device_dev_disconnect(struct snd_device *device)
        return 0;
 }
 
-/*
- * unregister the existing device
- */
-static int snd_seq_device_dev_unregister(struct snd_device *device)
-{
-       struct snd_seq_device *dev = device->device_data;
-       return snd_seq_device_free(dev);
-}
-
 /*
  * register device driver
  * id = driver id

diff --git a/sound/core/timer.c b/sound/core/timer.c
index 52ecbe1e9abb10e19deaf829de3661e32b37ab10..7e5e562fe356e3b52181b7ac0b575c0e4b548682 100644 (file)
--- a/sound/core/timer.c
+++ b/sound/core/timer.c
@@ -88,7 +88,7 @@ static DEFINE_MUTEX(register_mutex);
 static int snd_timer_free(struct snd_timer *timer);
 static int snd_timer_dev_free(struct snd_device *device);
 static int snd_timer_dev_register(struct snd_device *device);
-static int snd_timer_dev_unregister(struct snd_device *device);
+static int snd_timer_dev_disconnect(struct snd_device *device);
 
 static void snd_timer_reschedule(struct snd_timer * timer, unsigned long ticks_left);
 
@@ -773,7 +773,7 @@ int snd_timer_new(struct snd_card *card, char *id, struct snd_timer_id *tid,
        static struct snd_device_ops ops = {
                .dev_free = snd_timer_dev_free,
                .dev_register = snd_timer_dev_register,
-               .dev_unregister = snd_timer_dev_unregister
+               .dev_disconnect = snd_timer_dev_disconnect,
        };
 
        snd_assert(tid != NULL, return -EINVAL);
@@ -813,6 +813,21 @@ int snd_timer_new(struct snd_card *card, char *id, struct snd_timer_id *tid,
 static int snd_timer_free(struct snd_timer *timer)
 {
        snd_assert(timer != NULL, return -ENXIO);
+
+       mutex_lock(&register_mutex);
+       if (! list_empty(&timer->open_list_head)) {
+               struct list_head *p, *n;
+               struct snd_timer_instance *ti;
+               snd_printk(KERN_WARNING "timer %p is busy?\n", timer);
+               list_for_each_safe(p, n, &timer->open_list_head) {
+                       list_del_init(p);
+                       ti = list_entry(p, struct snd_timer_instance, open_list);
+                       ti->timer = NULL;
+               }
+       }
+       list_del(&timer->device_list);
+       mutex_unlock(&register_mutex);
+
        if (timer->private_free)
                timer->private_free(timer);
        kfree(timer);
@@ -867,30 +882,13 @@ static int snd_timer_dev_register(struct snd_device *dev)
        return 0;
 }
 
-static int snd_timer_unregister(struct snd_timer *timer)
+static int snd_timer_dev_disconnect(struct snd_device *device)
 {
-       struct list_head *p, *n;
-       struct snd_timer_instance *ti;
-
-       snd_assert(timer != NULL, return -ENXIO);
+       struct snd_timer *timer = device->device_data;
        mutex_lock(&register_mutex);
-       if (! list_empty(&timer->open_list_head)) {
-               snd_printk(KERN_WARNING "timer 0x%lx is busy?\n", (long)timer);
-               list_for_each_safe(p, n, &timer->open_list_head) {
-                       list_del_init(p);
-                       ti = list_entry(p, struct snd_timer_instance, open_list);
-                       ti->timer = NULL;
-               }
-       }
-       list_del(&timer->device_list);
+       list_del_init(&timer->device_list);
        mutex_unlock(&register_mutex);
-       return snd_timer_free(timer);
-}
-
-static int snd_timer_dev_unregister(struct snd_device *device)
-{
-       struct snd_timer *timer = device->device_data;
-       return snd_timer_unregister(timer);
+       return 0;
 }
 
 void snd_timer_notify(struct snd_timer *timer, int event, struct timespec *tstamp)
@@ -955,11 +953,6 @@ int snd_timer_global_register(struct snd_timer *timer)
        return snd_timer_dev_register(&dev);
 }
 
-int snd_timer_global_unregister(struct snd_timer *timer)
-{
-       return snd_timer_unregister(timer);
-}
-
 /*
  *  System timer
  */
@@ -1982,7 +1975,7 @@ static void __exit alsa_timer_exit(void)
        /* unregister the system timer */
        list_for_each_safe(p, n, &snd_timer_list) {
                struct snd_timer *timer = list_entry(p, struct snd_timer, device_list);
-               snd_timer_unregister(timer);
+               snd_timer_free(timer);
        }
        snd_timer_proc_done();
 #ifdef SNDRV_OSS_INFO_DEV_TIMERS
@@ -2005,5 +1998,4 @@ EXPORT_SYMBOL(snd_timer_notify);
 EXPORT_SYMBOL(snd_timer_global_new);
 EXPORT_SYMBOL(snd_timer_global_free);
 EXPORT_SYMBOL(snd_timer_global_register);
-EXPORT_SYMBOL(snd_timer_global_unregister);
 EXPORT_SYMBOL(snd_timer_interrupt);

diff --git a/sound/pci/ac97/ac97_codec.c b/sound/pci/ac97/ac97_codec.c
index 51e83d7a839a3ccf09d6d2134eaed858ef638922..b35280ca2465d678a3865fc202ab3c5d7e9382ce 100644 (file)
--- a/sound/pci/ac97/ac97_codec.c
+++ b/sound/pci/ac97/ac97_codec.c
@@ -1817,13 +1817,13 @@ static int snd_ac97_dev_register(struct snd_device *device)
        return 0;
 }
 
-/* unregister ac97 codec */
-static int snd_ac97_dev_unregister(struct snd_device *device)
+/* disconnect ac97 codec */
+static int snd_ac97_dev_disconnect(struct snd_device *device)
 {
        struct snd_ac97 *ac97 = device->device_data;
        if (ac97->dev.bus)
                device_unregister(&ac97->dev);
-       return snd_ac97_free(ac97);
+       return 0;
 }
 
 /* build_ops to do nothing */
@@ -1860,7 +1860,7 @@ int snd_ac97_mixer(struct snd_ac97_bus *bus, struct snd_ac97_template *template,
        static struct snd_device_ops ops = {
                .dev_free =     snd_ac97_dev_free,
                .dev_register = snd_ac97_dev_register,
-               .dev_unregister =       snd_ac97_dev_unregister,
+               .dev_disconnect =       snd_ac97_dev_disconnect,
        };
 
        snd_assert(rac97 != NULL, return -EINVAL);

diff --git a/sound/usb/usbaudio.c b/sound/usb/usbaudio.c
index 1b7f499c549da7f2457bbff3f7c3e1ab63cf7e40..31443138591370d05b4be47489dfdf147c48b876 100644 (file)
--- a/sound/usb/usbaudio.c
+++ b/sound/usb/usbaudio.c
@@ -3499,7 +3499,7 @@ static void snd_usb_audio_disconnect(struct usb_device *dev, void *ptr)
                }
                usb_chip[chip->index] = NULL;
                mutex_unlock(&register_mutex);
-               snd_card_free(card);
+               snd_card_free_when_closed(card);
        } else {
                mutex_unlock(&register_mutex);
        }