Changeset 644 for GPL


Ignore:
Timestamp:
Jan 16, 2021, 10:20:04 PM (5 years ago)
Author:
Paul Smedley
Message:

More code cleanups

Location:
GPL/branches/uniaud32-next
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • GPL/branches/uniaud32-next/alsa-kernel/core/control.c

    r637 r644  
    19891989#endif
    19901990
    1991 #ifndef CONFIG_SND_HAVE_NEW_IOCTL
    1992 /* need to unlock BKL to allow preemption */
    1993 static int snd_ctl_ioctl_old(struct inode *inode, struct file * file,
    1994                              unsigned int cmd, unsigned long arg)
    1995 {
    1996         int err;
    1997         err = snd_ctl_ioctl(file, cmd, arg);
    1998         return err;
    1999 }
    2000 #endif
    2001 
    20021991/*
    20031992 *  INIT PART
    … …  
    20122001        .llseek =       no_llseek,
    20132002        .poll =         snd_ctl_poll,
    2014 #ifdef CONFIG_SND_HAVE_NEW_IOCTL
    20152003        .unlocked_ioctl =       snd_ctl_ioctl,
    20162004        .compat_ioctl = snd_ctl_ioctl_compat,
    2017 #else
    2018         .ioctl =        snd_ctl_ioctl_old,
    2019 #endif
    20202005        .fasync =       snd_ctl_fasync,
    20212006};

  • GPL/branches/uniaud32-next/alsa-kernel/core/hwdep.c

    r629 r644  
    320320#endif
    321321
    322 #ifndef CONFIG_SND_HAVE_NEW_IOCTL
    323 /* need to unlock BKL to allow preemption */
    324 static int snd_hwdep_ioctl_old(struct inode *inode, struct file * file,
    325                                unsigned int cmd, unsigned long arg)
    326 {
    327         int err;
    328         err = snd_hwdep_ioctl(file, cmd, arg);
    329         return err;
    330 }
    331 #endif
    332 
    333322/*
    334323
    … …  
    344333        .release =      snd_hwdep_release,
    345334        .poll =         snd_hwdep_poll,
    346 #ifdef CONFIG_SND_HAVE_NEW_IOCTL
    347335        .unlocked_ioctl =       snd_hwdep_ioctl,
    348336        .compat_ioctl = snd_hwdep_ioctl_compat,
    349 #else
    350         .ioctl =        snd_hwdep_ioctl_old,
    351 #endif
    352337        .mmap =         snd_hwdep_mmap,
    353338};

  • GPL/branches/uniaud32-next/alsa-kernel/core/init.c

    r639 r644  
    341341}
    342342
    343 #ifdef CONFIG_SND_HAVE_NEW_IOCTL
    344343static long snd_disconnect_ioctl(struct file *file,
    345344                                 unsigned int cmd, unsigned long arg)
    … …  
    347346        return -ENODEV;
    348347}
    349 #else
    350 static int snd_disconnect_ioctl_old(struct inode *inode, struct file *file,
    351                                     unsigned int cmd, unsigned long arg)
    352 {
    353         return -ENODEV;
    354 }
    355 #endif
    356348
    357349static int snd_disconnect_mmap(struct file *file, struct vm_area_struct *vma)
    … …  
    373365        .release =      snd_disconnect_release,
    374366        .poll =         snd_disconnect_poll,
    375 #ifdef CONFIG_SND_HAVE_NEW_IOCTL
    376367        .unlocked_ioctl = snd_disconnect_ioctl,
    377368#ifdef CONFIG_COMPAT
    378369        .compat_ioctl = snd_disconnect_ioctl,
    379 #endif
    380 #else
    381         .ioctl =        snd_disconnect_ioctl_old,
    382370#endif
    383371        .mmap =         snd_disconnect_mmap,

  • GPL/branches/uniaud32-next/alsa-kernel/core/oss/mixer_oss.c

    r629 r644  
    395395#endif
    396396
    397 #ifndef CONFIG_SND_HAVE_NEW_IOCTL
    398 /* need to unlock BKL to allow preemption */
    399 static int snd_mixer_oss_ioctl_old(struct inode *inode, struct file * file,
    400                                    unsigned int cmd, unsigned long arg)
    401 {
    402         int err;
    403         err = snd_mixer_oss_ioctl(file, cmd, arg);
    404         return err;
    405 }
    406 #endif
    407 
    408397/*
    409398 *  REGISTRATION PART
    … …  
    416405        .release =      snd_mixer_oss_release,
    417406        .llseek =       no_llseek,
    418 #ifdef CONFIG_SND_HAVE_NEW_IOCTL
    419407        .unlocked_ioctl =       snd_mixer_oss_ioctl,
    420408        .compat_ioctl = snd_mixer_oss_ioctl_compat,
    421 #else
    422         .ioctl =        snd_mixer_oss_ioctl_old,
    423 #endif 
    424409};
    425410

  • GPL/branches/uniaud32-next/alsa-kernel/core/oss/pcm_oss.c

    r629 r644  
    27902790#endif
    27912791
    2792 #ifndef CONFIG_SND_HAVE_NEW_IOCTL
    2793 /* need to unlock BKL to allow preemption */
    2794 static int snd_pcm_oss_ioctl_old(struct inode *inode, struct file * file,
    2795                                  unsigned int cmd, unsigned long arg)
    2796 {
    2797         int err;
    2798         err = snd_pcm_oss_ioctl(file, cmd, arg);
    2799         return err;
    2800 }
    2801 #endif
    2802 
    28032792static ssize_t snd_pcm_oss_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
    28042793{
    … …  
    31513140        .llseek =       no_llseek,
    31523141        .poll =         snd_pcm_oss_poll,
    3153 #ifdef CONFIG_SND_HAVE_NEW_IOCTL
    31543142        .unlocked_ioctl =       snd_pcm_oss_ioctl,
    31553143        .compat_ioctl = snd_pcm_oss_ioctl_compat,
    3156 #else
    3157         .ioctl =        snd_pcm_oss_ioctl_old,
    3158 #endif
    31593144#ifndef TARGET_OS2
    31603145        .mmap =         snd_pcm_oss_mmap,

  • GPL/branches/uniaud32-next/alsa-kernel/core/pcm_native.c

    r642 r644  
    39143914#endif
    39153915
    3916 #ifndef CONFIG_SND_HAVE_NEW_IOCTL
    3917 /* need to unlock BKL to allow preemption */
    3918 static int snd_pcm_playback_ioctl_old(struct inode *inode, struct file * file,
    3919                                       unsigned int cmd, unsigned long arg)
    3920 {
    3921         int err;
    3922         err = snd_pcm_ioctl(file, cmd, arg);
    3923         return err;
    3924 }
    3925 static int snd_pcm_capture_ioctl_old(struct inode *inode, struct file * file,
    3926                                       unsigned int cmd, unsigned long arg)
    3927 {
    3928         int err;
    3929         err = snd_pcm_ioctl(file, cmd, arg);
    3930         return err;
    3931 }
    3932 #endif
    3933 
    39343916/*
    39353917 *  To be removed helpers to keep binary compatibility
    … …  
    40864068                .llseek =               no_llseek,
    40874069                .poll =                 snd_pcm_poll,
    4088 #ifndef TARGET_OS2
    40894070                .unlocked_ioctl =       snd_pcm_ioctl,
    40904071                .compat_ioctl =         snd_pcm_ioctl_compat,
    4091 #else
    4092                 .ioctl =                snd_pcm_playback_ioctl_old,
    4093 #endif
    40944072#ifndef TARGET_OS2
    40954073                .mmap =                 snd_pcm_mmap,
    … …  
    41084086                .llseek =               no_llseek,
    41094087                .poll =                 snd_pcm_poll,
    4110 #ifndef TARGET_OS2
    41114088                .unlocked_ioctl =       snd_pcm_ioctl,
    41124089                .compat_ioctl =         snd_pcm_ioctl_compat,
    4113 #else
    4114                 .ioctl =                snd_pcm_capture_ioctl_old,
    4115 #endif
    41164090#ifndef TARGET_OS2
    41174091                .mmap =                 snd_pcm_mmap,

  • GPL/branches/uniaud32-next/alsa-kernel/core/seq/oss/seq_oss.c

    r615 r644  
    194194#endif
    195195
    196 #ifndef CONFIG_SND_HAVE_NEW_IOCTL
    197 /* need to unlock BKL to allow preemption */
    198 static int odev_ioctl_old(struct inode *inode, struct file * file,
    199                           unsigned int cmd, unsigned long arg)
    200 {
    201         int err;
    202         err = odev_ioctl(file, cmd, arg);
    203         return err;
    204 }
    205 #endif
    206 
    207196static __poll_t
    208197odev_poll(struct file *file, poll_table * wait)
    … …  
    227216        .release =      odev_release,
    228217        .poll =         odev_poll,
    229 #ifdef CONFIG_SND_HAVE_NEW_IOCTL
    230218        .unlocked_ioctl =       odev_ioctl,
    231219        .compat_ioctl = odev_ioctl_compat,
    232 #else
    233         .ioctl =        odev_ioctl_old,
    234 #endif
    235220        .llseek =       noop_llseek,
    236221};

  • GPL/branches/uniaud32-next/alsa-kernel/core/seq/seq_clientmgr.c

    r639 r644  
    21752175#endif
    21762176
    2177 #ifndef CONFIG_SND_HAVE_NEW_IOCTL
    2178 /* need to unlock BKL to allow preemption */
    2179 static int snd_seq_ioctl_old(struct inode *inode, struct file * file,
    2180                              unsigned int cmd, unsigned long arg)
    2181 {
    2182         int err;
    2183         unlock_kernel();
    2184         err = snd_seq_ioctl(file, cmd, arg);
    2185         lock_kernel();
    2186         return err;
    2187 }
    2188 #endif
    2189 
    21902177/* -------------------------------------------------------- */
    21912178
    … …  
    25122499        .llseek =       no_llseek,
    25132500        .poll =         snd_seq_poll,
    2514 #ifdef CONFIG_SND_HAVE_NEW_IOCTL
    25152501        .unlocked_ioctl =       snd_seq_ioctl,
    25162502        .compat_ioctl = snd_seq_ioctl_compat,
    2517 #else
    2518         .ioctl =        snd_seq_ioctl_old,
    2519 #endif
    25202503};
    25212504

  • GPL/branches/uniaud32-next/alsa-kernel/core/timer.c

    r637 r644  
    22952295#endif
    22962296
    2297 #ifndef CONFIG_SND_HAVE_NEW_IOCTL
    2298 /* need to unlock BKL to allow preemption */
    2299 static int snd_timer_user_ioctl_old(struct inode *inode, struct file * file,
    2300                                     unsigned int cmd, unsigned long arg)
    2301 {
    2302         int err;
    2303         err = snd_timer_user_ioctl(file, cmd, arg);
    2304         return err;
    2305 }
    2306 #endif
    2307 
    23082297static const struct file_operations snd_timer_f_ops =
    23092298{
    … …  
    23142303        .llseek =       no_llseek,
    23152304        .poll =         snd_timer_user_poll,
    2316 #ifdef CONFIG_SND_HAVE_NEW_IOCTL
    23172305        .unlocked_ioctl =       snd_timer_user_ioctl,
    23182306        .compat_ioctl = snd_timer_user_ioctl_compat,
    2319 #else
    2320         .ioctl =        snd_timer_user_ioctl_old,
    2321 #endif
    23222307        .fasync =       snd_timer_user_fasync,
    23232308};

  • GPL/branches/uniaud32-next/include/linux/fs.h

    r625 r644  
    231231        int (*readdir) (struct file *, void *, filldir_t);
    232232        unsigned int (*poll) (struct file *, struct poll_table_struct *);
    233         int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
     233        long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
     234        long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
    234235        int (*mmap) (struct file *, struct vm_area_struct *);
    235236        int (*open) (struct inode *, struct file *);

  • GPL/branches/uniaud32-next/lib32/ioctl.c

    r625 r644  
    317317
    318318                        dprintf(("GetUniaudPcmCaps: cp1. pcm %i, phandle %x", i, pHandle));
    319                         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_INFO, (ULONG)pcminfo);
     319                        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_INFO, (ULONG)pcminfo);
    320320                        if(ret != 0) {
    321321                                rprintf(("GetUniaudPcmCaps: SNDRV_PCM_IOCTL_INFO error %i", ret));
    … …  
    337337                        //get all hardware parameters
    338338                        _snd_pcm_hw_params_any(params);
    339                         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)params);
     339                        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)params);
    340340                        if(ret != 0) {
    341341                                dprintf(("GetUniaudPcmCaps: SNDRV_PCM_IOCTL_HW_REFINE error %i", ret));
    … …  
    468468        }
    469469        //retrieve mixer information
    470         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
     470        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file,
    471471                                                                        SNDRV_CTL_IOCTL_POWER_STATE,
    472472                                                                        (ULONG)state);
    … …  
    522522        }
    523523        //retrieve mixer information
    524         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
     524        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file,
    525525                                                                        SNDRV_CTL_IOCTL_POWER,
    526526                                                                        (ULONG)state);
    … …  
    578578        }
    579579        //retrieve mixer information
    580         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
     580        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file,
    581581                                                                        SNDRV_CTL_IOCTL_CARD_INFO,
    582582                                                                        (ULONG)(struct snd_ctl_card_info *)info);
    … …  
    635635        }
    636636        //retrieve mixer information
    637         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
     637        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file,
    638638                                                                        SNDRV_CTL_IOCTL_CARD_INFO,
    639639                                                                        (ULONG)&pHandle->info);
    … …  
    645645        pHandle->list.offset = 0;
    646646        pHandle->list.space  = 0;
    647         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
     647        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file,
    648648                                                                        SNDRV_CTL_IOCTL_ELEM_LIST,
    649649                                                                        (ULONG)&pHandle->list);
    … …  
    703703        }
    704704        //retrieve mixer information
    705         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
     705        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file,
    706706                                                                        SNDRV_CTL_IOCTL_CARD_INFO,
    707707                                                                        (ULONG)&pHandle->info);
    … …  
    713713        pHandle->list.offset = 0;
    714714        pHandle->list.space  = 0;
    715         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
     715        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file,
    716716                                                                        SNDRV_CTL_IOCTL_ELEM_LIST,
    717717                                                                        (ULONG)&pHandle->list);
    … …  
    732732        pHandle->list.space  = pHandle->list.count;
    733733        pHandle->list.pids       = pHandle->pids;
    734         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
     734        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file,
    735735                                                                        SNDRV_CTL_IOCTL_ELEM_LIST,
    736736                                                                        (ULONG)&pHandle->list);
    … …  
    806806
    807807        pElemInfo->id.numid = id;
    808         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
     808        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
    809809        ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
    810810        if(pHandle) kfree(pHandle);
    … …  
    864864        pElem->id.numid = id;
    865865        pElem->indirect = 0;
    866         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_READ, (ULONG)pElem);
     866        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_READ, (ULONG)pElem);
    867867        ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
    868868        if(pHandle) kfree(pHandle);
    … …  
    924924        pElem->indirect = 0;
    925925
    926         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
     926        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
    927927        ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
    928928        if(pHandle) kfree(pHandle);
    … …  
    952952
    953953        pHandle->file.f_flags = O_NONBLOCK;
    954         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)params);
     954        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)params);
    955955        return ret;
    956956}
    … …  
    969969
    970970        pHandle->file.f_flags = O_NONBLOCK;
    971         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_PARAMS, (ULONG)params);
     971        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_PARAMS, (ULONG)params);
    972972        return ret;
    973973}
    … …  
    988988        pHandle->file.f_flags = O_NONBLOCK;
    989989
    990         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_SW_PARAMS, (ULONG)params);
     990        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_SW_PARAMS, (ULONG)params);
    991991        return ret;
    992992}
    … …  
    10051005        pHandle->file.f_flags = O_NONBLOCK;
    10061006
    1007         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)status);
     1007        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)status);
    10081008        return ret;
    10091009}
    … …  
    10541054        pHandle->file.f_flags = O_NONBLOCK;
    10551055
    1056         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
     1056        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
    10571057        return ret;
    10581058}
    … …  
    10691069        pHandle->file.f_flags = O_NONBLOCK;
    10701070
    1071         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PAUSE, pause);
     1071        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PAUSE, pause);
    10721072
    10731073        return ret;
    … …  
    10851085        pHandle->file.f_flags = O_NONBLOCK;
    10861086
    1087         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_START, 0);
     1087        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_START, 0);
    10881088
    10891089        return ret;
    … …  
    11011101        pHandle->file.f_flags = O_NONBLOCK;
    11021102
    1103         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_DROP, 0);
     1103        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_DROP, 0);
    11041104
    11051105        return ret;

  • GPL/branches/uniaud32-next/lib32/sound.c

    r621 r644  
    369369                pHandle->file.f_flags = O_NONBLOCK;
    370370
    371                 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_INFO, (ULONG)pcminfo);
     371                ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_INFO, (ULONG)pcminfo);
    372372                if(ret != 0) {
    373373                        rprintf(("OSS32_QueryDevCaps: SNDRV_PCM_IOCTL_INFO error %i\n", ret));
    … …  
    386386                //get all hardware parameters
    387387                _snd_pcm_hw_params_any(params);
    388                 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)params);
     388                ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)params);
    389389                if(ret != 0) {
    390390                        rprintf(("OSS32_QueryDevCaps: SNDRV_PCM_IOCTL_HW_REFINE error %i\n", ret));
    … …  
    630630                        {
    631631                                /* prepare for reuse */
    632                                 pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_RESET, 0);
    633                                 pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
     632                                pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_RESET, 0);
     633                                pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
    634634                        }
    635635                        break;
    … …  
    671671        pHandle->file.f_flags = O_NONBLOCK;
    672672
    673         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
     673        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
    674674        if (ret)
    675675                rprintf(("Wave prepare ret = %i, streamid %X\n",ret,(ULONG)pHandle));
    … …  
    690690        //set operation to non-blocking
    691691        pHandle->file.f_flags = O_NONBLOCK;
    692         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_START, 0);
     692        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_START, 0);
    693693        if (ret)
    694694                rprintf(("Wave start ret = %i, streamid %X\n",ret,(ULONG)pHandle));
    … …  
    710710        pHandle->file.f_flags = O_NONBLOCK;
    711711
    712         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_DROP, 0);
     712        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_DROP, 0);
    713713        if (ret)
    714714                rprintf(("Wave stop ret = %i. streamid %X\n",ret,(ULONG)pHandle));
    … …  
    730730        pHandle->file.f_flags = O_NONBLOCK;
    731731
    732         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PAUSE, 0);
     732        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PAUSE, 0);
    733733        if (ret)
    734734                rprintf(("Wave pause ret = %i, streamid %X\n",ret,(ULONG)pHandle));
    … …  
    750750        pHandle->file.f_flags = O_NONBLOCK;
    751751
    752         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PAUSE, 1);
     752        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PAUSE, 1);
    753753        if (ret)
    754754                rprintf(("Wave resume ret = %i, streamid %X\n",ret,(ULONG)pHandle));
    … …  
    818818                _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_CHANNELS,
    819819                                                          pHwParams->ulNumChannels, 0);
    820                 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
     820                ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
    821821                if (ret == 0) break;
    822822                pHwParams->ulNumChannels--;
    … …  
    831831        _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FORMAT,
    832832                                                   OSSToALSADataType[pHwParams->ulDataType], 0);
    833         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
     833        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
    834834        if(ret != 0) {
    835835                rprintf(("invalid format %lx\n", OSSToALSADataType[pHwParams->ulDataType]));
    … …  
    838838        _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_SAMPLE_BITS,
    839839                                                  pHwParams->ulBitsPerSample, 0);
    840         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
     840        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
    841841        if(ret != 0) {
    842842                rprintf(("invalid number of sample bits %d\n", pHwParams->ulBitsPerSample));
    … …  
    845845        _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_FRAME_BITS,
    846846                                                  pHwParams->ulBitsPerSample*pHwParams->ulNumChannels, 0);
    847         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
     847        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
    848848        if(ret != 0) {
    849849                rprintf(("invalid number of frame bits %d\n", pHwParams->ulBitsPerSample*pHwParams->ulNumChannels));
    … …  
    862862        _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_RATE,
    863863                                                  pHwParams->ulSampleRate, 0);
    864         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
     864        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
    865865        if(ret != 0) {
    866866                rprintf(("32_WSetHwPms (first pass) error %d bps:%d fmt: %d ch: %d sr: %d\n",
    … …  
    881881                                _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_RATE,
    882882                                                                          pHwParams->ulSampleRate, 0);
    883                                 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
     883                                ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
    884884                                if(ret == 0)
    885885                                {
    … …  
    895895                                        _snd_pcm_hw_param_set(&params, SNDRV_PCM_HW_PARAM_RATE,
    896896                                                                                  pHwParams->ulSampleRate, 0);
    897                                         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
     897                                        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_REFINE, (ULONG)__Stack32ToFlat(&params));
    898898                                        goto __next;
    899899                                }
    … …  
    10031003                         pHwParams->ulSampleRate, pHwParams->ulBitsPerSample, pHwParams->ulNumChannels, periodsize, nrperiods));
    10041004
    1005         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_HW_PARAMS, (ULONG)__Stack32ToFlat(&params));
     1005        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_HW_PARAMS, (ULONG)__Stack32ToFlat(&params));
    10061006        if (ret == -77 && fTryAgain == FALSE)
    10071007        {
    1008                 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
     1008                ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
    10091009                fTryAgain = TRUE;
    10101010                rprintf((" Error -77 from first IOCTL HW Parms"));
    … …  
    10481048                swparams.xfer_align        = periodsize;
    10491049
    1050                 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_SW_PARAMS, (ULONG)__Stack32ToFlat(&swparams));
     1050                ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_SW_PARAMS, (ULONG)__Stack32ToFlat(&swparams));
    10511051        }
    10521052
    10531053        total = 0;
    10541054        per_bytes = periodbytes;
    1055         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
     1055        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
    10561056        if ( ((status.state != SNDRV_PCM_STATE_PREPARED) &&
    10571057                   (status.state != SNDRV_PCM_STATE_SETUP) &&
    … …  
    10591059                   (status.state != SNDRV_PCM_STATE_DRAINING))) {
    10601060                rprintf(("Device is not in proper state: %lx. Calling prepare\n", status.state));
    1061                 ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
     1061                ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
    10621062        }
    10631063        return UNIXToOSSError(ret);
    … …  
    10971097
    10981098        /* get the status of the circular dma buffer */
    1099         iRet = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
     1099        iRet = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
    11001100
    11011101        if(iRet) {
    … …  
    11291129                if (status.state == SNDRV_PCM_STATE_XRUN) {
    11301130                        rprintf(("Internal Error: Xrun"));
    1131                         iRet = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
     1131                        iRet = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
    11321132                        if (iRet < 0) {
    11331133                                rprintf(("Prepare failed: state=%x avail=%x ReqSize=%x", status.state, status.avail, ulReqSize));
    11341134                                return UNIXToOSSError(iRet);
    11351135                        }
    1136                         iRet = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
     1136                        iRet = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
    11371137                        rprintf(("Xrun restarted: state=%x avail=%x ReqSize=%x", status.state, status.avail, ulReqSize));
    11381138                        if (iRet < 0) return UNIXToOSSError(iRet);
    … …  
    11681168                while (ulSize && ulJ && iRet) {
    11691169                        for (ulI=0; ulI < 1000; ulI++) {
    1170                                 iRet1 = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
     1170                                iRet1 = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
    11711171                                // If here any state and have free buffer to any byte
    11721172                                if ((status.state != SNDRV_PCM_STATE_XRUN ) && samples_to_bytes(status.avail) ) break;
    … …  
    11761176                                if (ulI > 998) {
    11771177                                        rprintf(("timeout state=%x avail=%d hw=%d app=%d",status.state,samples_to_bytes(status.avail),samples_to_bytes(status.hw_ptr), samples_to_bytes(status.appl_ptr)));
    1178                                         iRet1 = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
     1178                                        iRet1 = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
    11791179                                }
    11801180                        }
    … …  
    11931193                                if ( iRet != -11 ) {
    11941194                                        rprintf(("Doing prepare"));
    1195                                         iRet1 = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
     1195                                        iRet1 = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
    11961196                                }
    11971197                                continue;
    … …  
    12341234//        {
    12351235//                printk("warning: ulTransferred [%d] less than requested [%d]", *pulTransferred, ulSize);
    1236 //                iRet1 = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
     1236//                iRet1 = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_PREPARE, 0);
    12371237//        }
    12381238
    … …  
    12601260
    12611261        //Get the status of the stream
    1262         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
     1262        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
    12631263
    12641264        if(ret) {
    … …  
    12921292
    12931293        //Get the nr of bytes left in the audio buffer
    1294         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
     1294        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
    12951295
    12961296        if(ret) {
    … …  
    13241324
    13251325        //Get the status of the stream
    1326         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
     1326        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
    13271327
    13281328        if(ret) {
    … …  
    13551355
    13561356        //Get the status of the stream
    1357         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
     1357        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_STATUS, (ULONG)__Stack32ToFlat(&status));
    13581358        if(ret) return UNIXToOSSError(ret);
    13591359        *pStatus = status.state;
    … …  
    13871387
    13881388        dprintf(("OSS32_WaveSetVolume %x to (%d,%d)", streamid, leftvol, rightvol));
    1389         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_PCM_IOCTL_SETVOLUME, (ULONG)__Stack32ToFlat(&pcm_volume));
     1389        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_PCM_IOCTL_SETVOLUME, (ULONG)__Stack32ToFlat(&pcm_volume));
    13901390        return UNIXToOSSError(ret);
    13911391}

  • GPL/branches/uniaud32-next/lib32/soundmidi.c

    r598 r644  
    120120    {
    121121        //get the client id
    122         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_SEQ_IOCTL_CLIENT_ID, (ULONG)&pHandle->clientid);
     122        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_SEQ_IOCTL_CLIENT_ID, (ULONG)&pHandle->clientid);
    123123        if(ret) {
    124124            rprintf(("Get client id failed with error %d", ret));
    … …  
    133133            clientinfo.client = i;
    134134            clientinfo.type   = KERNEL_CLIENT;
    135             ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_SEQ_IOCTL_GET_CLIENT_INFO, (ULONG)__Stack32ToFlat(&clientinfo));
     135            ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_SEQ_IOCTL_GET_CLIENT_INFO, (ULONG)__Stack32ToFlat(&clientinfo));
    136136            if(ret) {
    137137                continue;
    … …  
    157157        portinfo.addr.client = pHandle->clientid;
    158158        portinfo.flags       = SNDRV_SEQ_PORT_TYPE_APPLICATION;
    159         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_SEQ_IOCTL_CREATE_PORT, (ULONG)__Stack32ToFlat(&portinfo));
     159        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_SEQ_IOCTL_CREATE_PORT, (ULONG)__Stack32ToFlat(&portinfo));
    160160        if(ret) {
    161161            rprintf(("subscribe error %d", ret));
    … …  
    172172        subs.sender.client = pHandle->clientid;
    173173        subs.sender.port   = pHandle->clientport;
    174         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT, (ULONG)__Stack32ToFlat(&subs));
     174        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT, (ULONG)__Stack32ToFlat(&subs));
    175175        if(ret) {
    176176            rprintf(("subscribe error %d", ret));
    … …  
    212212        subs.sender.client = pHandle->clientid;
    213213        subs.sender.port   = pHandle->clientport;
    214         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT, (ULONG)__Stack32ToFlat(&subs));
     214        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT, (ULONG)__Stack32ToFlat(&subs));
    215215        if(ret) {
    216216            rprintf(("unsubscribe error %d", ret));
    … …  
    227227        portinfo.addr.client = pHandle->clientid;
    228228        portinfo.addr.port   = pHandle->clientport;
    229         ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_SEQ_IOCTL_DELETE_PORT, (ULONG)__Stack32ToFlat(&portinfo));
     229        ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_SEQ_IOCTL_DELETE_PORT, (ULONG)__Stack32ToFlat(&portinfo));
    230230        if(ret) {
    231231            dprintf(("delete port error %d", ret));

  • GPL/branches/uniaud32-next/lib32/soundmixer.c

    r604 r644  
    148148  }
    149149  //retrieve mixer information
    150   ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
     150  ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file,
    151151                  SNDRV_CTL_IOCTL_CARD_INFO,
    152152                  (ULONG)&pHandle->info);
    … …  
    157157  pHandle->list.offset = 0;
    158158  pHandle->list.space  = 0;
    159   ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
     159  ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file,
    160160                  SNDRV_CTL_IOCTL_ELEM_LIST,
    161161                  (ULONG)&pHandle->list);
    … …  
    172172  pHandle->list.space  = pHandle->list.count;
    173173  pHandle->list.pids   = pHandle->pids;
    174   ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
     174  ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file,
    175175                  SNDRV_CTL_IOCTL_ELEM_LIST,
    176176                  (ULONG)&pHandle->list);
    … …  
    271271      pElemInfo->value.enumerated.item = i;
    272272      pElemInfo->id.numid = pHandle->pids[idx].numid;
    273       ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
     273      ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
    274274      if(ret) {
    275275        DebugInt3();
    … …  
    484484    pElem->value.integer.value[0] = TRUE;  //switch, not mute control (inversed)
    485485    pElem->value.integer.value[1] = TRUE;
    486     ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
     486    ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
    487487  }
    488488  //request information about mixer control
    489489  pElemInfo->id.numid = pHandle->pids[idx].numid;
    490   ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
     490  ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
    491491  if(ret) {
    492492    ret = UNIXToOSSError(ret);
    … …  
    515515
    516516#if 1
    517   ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
     517  ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
    518518#else
    519519  // looking for more, then one opened streams to prevent of muting active stream
    … …  
    528528  {
    529529    dprintf(("OSS32_MixSetVolume Ioctl"));
    530     ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
     530    ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
    531531
    532532    if(idxMute != -1 && volume == 0) {
    … …  
    538538      pElem->value.integer.value[1] = FALSE;
    539539      dprintf(("OSS32_MixSetVolume Ioctl mute"));
    540       ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
     540      ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
    541541    }
    542542  }
    … …  
    603603          //request information about mixer control
    604604          pElemInfo->id.numid       = pHandle->pids[idx].numid;
    605           ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
     605          ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
    606606          if(ret) {
    607607            ret = UNIXToOSSError(ret);
    … …  
    621621          }
    622622
    623           ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
     623          ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
    624624          if(ret) {
    625625            ret = UNIXToOSSError(ret);
    … …  
    631631      //request information about mixer control
    632632      pElemInfo->id.numid = pHandle->pids[idx].numid;
    633       ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
     633      ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
    634634      if(ret) {
    635635        ret = UNIXToOSSError(ret);
    … …  
    678678    //request information about mixer control
    679679    pElemInfo->id.numid = pHandle->pids[idx].numid;
    680     ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
     680    ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
    681681    if(ret) {
    682682      ret = UNIXToOSSError(ret);
    … …  
    707707
    708708  dprintf(("OSS32_MixSetProperty of %s to %x", pHandle->pids[idx].name, ulValue));
    709   ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
     709  ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
    710710
    711711  kfree(pElem);
    … …  
    849849  }
    850850  //retrieve mixer information
    851   ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
     851  ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file,
    852852                  SNDRV_CTL_IOCTL_CARD_INFO,
    853853                  (ULONG)&pHandle->info);
    … …  
    911911  }
    912912  //retrieve mixer information
    913   ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
     913  ret = pHandle->file.f_op->unlocked_ioctl(&pHandle->file,
    914914                  SNDRV_CTL_IOCTL_CARD_INFO,
    915915                  (ULONG)&pHandle->info);
Note: See TracChangeset for help on using the changeset viewer.