}
 EXPORT_SYMBOL_GPL(comedi_buf_write_free);
 
-unsigned int comedi_buf_read_n_available(struct comedi_async *async)
+unsigned int comedi_buf_read_n_available(struct comedi_subdevice *s)
 {
+       struct comedi_async *async = s->async;
        unsigned num_bytes;
 
        if (!async)
 int comedi_buf_get(struct comedi_subdevice *s, unsigned short *x)
 {
        struct comedi_async *async = s->async;
-       unsigned int n = comedi_buf_read_n_available(async);
+       unsigned int n = comedi_buf_read_n_available(s);
 
        if (n < sizeof(short))
                return 0;
 
        if (s && s->async) {
                poll_wait(file, &s->async->wait_head, wait);
                if (!s->busy || !comedi_is_subdevice_running(s) ||
-                   comedi_buf_read_n_available(s->async) > 0)
+                   comedi_buf_read_n_available(s) > 0)
                        mask |= POLLIN | POLLRDNORM;
        }
 
 
                n = nbytes;
 
-               m = comedi_buf_read_n_available(async);
+               m = comedi_buf_read_n_available(s);
                /* printk("%d available\n",m); */
                if (async->buf_read_ptr + m > async->prealloc_bufsz)
                        m = async->prealloc_bufsz - async->buf_read_ptr;
 
 unsigned int comedi_buf_write_alloc(struct comedi_subdevice *s, unsigned int n);
 unsigned int comedi_buf_write_free(struct comedi_subdevice *s, unsigned int n);
 
-unsigned int comedi_buf_read_n_available(struct comedi_async *);
+unsigned int comedi_buf_read_n_available(struct comedi_subdevice *s);
 unsigned int comedi_buf_read_alloc(struct comedi_subdevice *s, unsigned int n);
 unsigned int comedi_buf_read_free(struct comedi_subdevice *s, unsigned int n);
 
 
                bytes_per_scan = sizeof(short);
        }
        /* Determine number of scans available in buffer. */
-       num_scans = comedi_buf_read_n_available(s->async) / bytes_per_scan;
+       num_scans = comedi_buf_read_n_available(s) / bytes_per_scan;
        if (cmd->stop_src == TRIG_COUNT) {
                /* Fixed number of scans. */
                if (num_scans > devpriv->ao_stop_count)
 
        dacstat = inw(dev->iobase + PCI230_DACCON);
        /* Determine number of scans available in buffer. */
        bytes_per_scan = cmd->chanlist_len * sizeof(short);
-       num_scans = comedi_buf_read_n_available(async) / bytes_per_scan;
+       num_scans = comedi_buf_read_n_available(s) / bytes_per_scan;
        if (cmd->stop_src == TRIG_COUNT) {
                /* Fixed number of scans. */
                if (num_scans > devpriv->ao_scan_count)
 
        buffer_index = devpriv->ao_dma_index;
        prev_buffer_index = prev_ao_dma_index(dev);
 
-       num_bytes = comedi_buf_read_n_available(dev->write_subdev->async);
+       num_bytes = comedi_buf_read_n_available(dev->write_subdev);
        if (num_bytes > DMA_BUFFER_SIZE)
                num_bytes = DMA_BUFFER_SIZE;
        if (cmd->stop_src == TRIG_COUNT && num_bytes > devpriv->ao_count)
 
        spin_lock_irqsave(&devpriv->interrupt_lock, flags);
        mite_sync_input_dma(counter->mite_chan, s->async);
        spin_unlock_irqrestore(&devpriv->interrupt_lock, flags);
-       return comedi_buf_read_n_available(s->async);
+       return comedi_buf_read_n_available(s);
 }
 
 static int ni_660x_buf_change(struct comedi_device *dev,
 
        const struct ni_board_struct *board = comedi_board(dev);
        int n;
 
-       n = comedi_buf_read_n_available(s->async);
+       n = comedi_buf_read_n_available(s);
        if (n == 0) {
                s->async->events |= COMEDI_CB_OVERFLOW;
                return 0;
                ni_ao_win_outl(dev, 0x6, AO_FIFO_Offset_Load_611x);
 
        /* load some data */
-       n = comedi_buf_read_n_available(s->async);
+       n = comedi_buf_read_n_available(s);
        if (n == 0)
                return 0;