static int snd_pcm_oss_register_minor(struct snd_pcm *pcm)
 {
        pcm->oss.reg = 0;
-       if (dsp_map[pcm->card->number] == pcm->device) {
+       if (dsp_map[pcm->card->number] == (int)pcm->device) {
                char name[128];
                int duplex;
                register_oss_dsp(pcm, 0);
                pcm->oss.reg++;
                pcm->oss.reg_mask |= 1;
        }
-       if (adsp_map[pcm->card->number] == pcm->device) {
+       if (adsp_map[pcm->card->number] == (int)pcm->device) {
                register_oss_dsp(pcm, 1);
                pcm->oss.reg++;
                pcm->oss.reg_mask |= 2;
                        snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_PCM,
                                                  pcm->card, 1);
                }
-               if (dsp_map[pcm->card->number] == pcm->device) {
+               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
 
        /* check device map table */
        for (i = 0; i < SNDRV_CARDS; i++) {
-               if (dsp_map[i] < 0 || dsp_map[i] >= SNDRV_OS_MINORS) {
+               if (dsp_map[i] < 0 || dsp_map[i] >= SNDRV_PCM_DEVICES) {
                        snd_printk(KERN_ERR "invalid dsp_map[%d] = %d\n",
                                   i, dsp_map[i]);
                        dsp_map[i] = 0;
                }
-               if (adsp_map[i] < 0 || adsp_map[i] >= SNDRV_OS_MINORS) {
+               if (adsp_map[i] < 0 || adsp_map[i] >= SNDRV_PCM_DEVICES) {
                        snd_printk(KERN_ERR "invalid adsp_map[%d] = %d\n",
                                   i, adsp_map[i]);
                        adsp_map[i] = 1;
 
 static int snd_pcm_dev_register(struct snd_device *device);
 static int snd_pcm_dev_disconnect(struct snd_device *device);
 
-static inline struct snd_pcm *snd_pcm_get(struct snd_card *card, int device)
+static struct snd_pcm *snd_pcm_search(struct snd_card *card, int device)
 {
        struct snd_pcm *pcm;
 
        return NULL;
 }
 
-static inline int snd_pcm_next(struct snd_card *card, int device)
-{
-       struct snd_pcm *pcm;
-
-       list_for_each_entry(pcm, &snd_pcm_devices, list) {
-               if (pcm->card == card && pcm->device > device)
-                       return pcm->device;
-               else if (pcm->card->number > card->number)
-                       return -1;
-       }
-       return -1;
-}
-
-static inline int snd_pcm_add(struct snd_pcm *newpcm)
-{
-       struct snd_pcm *pcm;
-
-       list_for_each_entry(pcm, &snd_pcm_devices, list) {
-               if (pcm->card == newpcm->card && pcm->device == newpcm->device)
-                       return -EBUSY;
-               if (pcm->card->number > newpcm->card->number ||
-                               (pcm->card == newpcm->card &&
-                               pcm->device > newpcm->device)) {
-                       list_add(&newpcm->list, pcm->list.prev);
-                       return 0;
-               }
-       }
-       list_add_tail(&newpcm->list, &snd_pcm_devices);
-       return 0;
-}
-
 static int snd_pcm_control_ioctl(struct snd_card *card,
                                 struct snd_ctl_file *control,
                                 unsigned int cmd, unsigned long arg)
                        if (get_user(device, (int __user *)arg))
                                return -EFAULT;
                        mutex_lock(®ister_mutex);
-                       device = snd_pcm_next(card, device);
+                       device = device < 0 ? 0 : device + 1;
+                       while (device < SNDRV_PCM_DEVICES) {
+                               if (snd_pcm_search(card, device))
+                                       break;
+                               device++;
+                       }
+                       if (device == SNDRV_PCM_DEVICES)
+                               device = -1;
                        mutex_unlock(®ister_mutex);
                        if (put_user(device, (int __user *)arg))
                                return -EFAULT;
                        if (get_user(subdevice, &info->subdevice))
                                return -EFAULT;
                        mutex_lock(®ister_mutex);
-                       pcm = snd_pcm_get(card, device);
+                       pcm = snd_pcm_search(card, device);
                        if (pcm == NULL) {
                                err = -ENXIO;
                                goto _error;
 
        snd_assert(pcm != NULL && device != NULL, return -ENXIO);
        mutex_lock(®ister_mutex);
-       err = snd_pcm_add(pcm);
-       if (err) {
+       if (snd_pcm_search(pcm->card, pcm->device)) {
                mutex_unlock(®ister_mutex);
-               return err;
+               return -EBUSY;
        }
+       list_add_tail(&pcm->list, &snd_pcm_devices);
        for (cidx = 0; cidx < 2; cidx++) {
                int devtype = -1;
                if (pcm->streams[cidx].substream == NULL)