linux/sound/oss/dmabuf.c
<<
>>
Prefs
   1/*
   2 * sound/oss/dmabuf.c
   3 *
   4 * The DMA buffer manager for digitized voice applications
   5 */
   6/*
   7 * Copyright (C) by Hannu Savolainen 1993-1997
   8 *
   9 * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
  10 * Version 2 (June 1991). See the "COPYING" file distributed with this software
  11 * for more info.
  12 *
  13 * Thomas Sailer   : moved several static variables into struct audio_operations
  14 *                   (which is grossly misnamed btw.) because they have the same
  15 *                   lifetime as the rest in there and dynamic allocation saves
  16 *                   12k or so
  17 * Thomas Sailer   : remove {in,out}_sleep_flag. It was used for the sleeper to
  18 *                   determine if it was woken up by the expiring timeout or by
  19 *                   an explicit wake_up. The return value from schedule_timeout
  20 *                   can be used instead; if 0, the wakeup was due to the timeout.
  21 *
  22 * Rob Riggs            Added persistent DMA buffers (1998/10/17)
  23 */
  24
  25#define BE_CONSERVATIVE
  26#define SAMPLE_ROUNDUP 0
  27
  28#include <linux/mm.h>
  29#include <linux/gfp.h>
  30#include "sound_config.h"
  31
  32#define DMAP_FREE_ON_CLOSE      0
  33#define DMAP_KEEP_ON_CLOSE      1
  34extern int sound_dmap_flag;
  35
  36static void dma_reset_output(int dev);
  37static void dma_reset_input(int dev);
  38static int local_start_dma(struct audio_operations *adev, unsigned long physaddr, int count, int dma_mode);
  39
  40
  41
  42static int debugmem;            /* switched off by default */
  43static int dma_buffsize = DSP_BUFFSIZE;
  44
  45static long dmabuf_timeout(struct dma_buffparms *dmap)
  46{
  47        long tmout;
  48
  49        tmout = (dmap->fragment_size * HZ) / dmap->data_rate;
  50        tmout += HZ / 5;        /* Some safety distance */
  51        if (tmout < (HZ / 2))
  52                tmout = HZ / 2;
  53        if (tmout > 20 * HZ)
  54                tmout = 20 * HZ;
  55        return tmout;
  56}
  57
  58static int sound_alloc_dmap(struct dma_buffparms *dmap)
  59{
  60        char *start_addr, *end_addr;
  61        int dma_pagesize;
  62        int sz, size;
  63        struct page *page;
  64
  65        dmap->mapping_flags &= ~DMA_MAP_MAPPED;
  66
  67        if (dmap->raw_buf != NULL)
  68                return 0;       /* Already done */
  69        if (dma_buffsize < 4096)
  70                dma_buffsize = 4096;
  71        dma_pagesize = (dmap->dma < 4) ? (64 * 1024) : (128 * 1024);
  72        
  73        /*
  74         *      Now check for the Cyrix problem.
  75         */
  76         
  77        if(isa_dma_bridge_buggy==2)
  78                dma_pagesize=32768;
  79         
  80        dmap->raw_buf = NULL;
  81        dmap->buffsize = dma_buffsize;
  82        if (dmap->buffsize > dma_pagesize)
  83                dmap->buffsize = dma_pagesize;
  84        start_addr = NULL;
  85        /*
  86         * Now loop until we get a free buffer. Try to get smaller buffer if
  87         * it fails. Don't accept smaller than 8k buffer for performance
  88         * reasons.
  89         */
  90        while (start_addr == NULL && dmap->buffsize > PAGE_SIZE) {
  91                for (sz = 0, size = PAGE_SIZE; size < dmap->buffsize; sz++, size <<= 1);
  92                dmap->buffsize = PAGE_SIZE * (1 << sz);
  93                start_addr = (char *) __get_free_pages(GFP_ATOMIC|GFP_DMA|__GFP_NOWARN, sz);
  94                if (start_addr == NULL)
  95                        dmap->buffsize /= 2;
  96        }
  97
  98        if (start_addr == NULL) {
  99                printk(KERN_WARNING "Sound error: Couldn't allocate DMA buffer\n");
 100                return -ENOMEM;
 101        } else {
 102                /* make some checks */
 103                end_addr = start_addr + dmap->buffsize - 1;
 104
 105                if (debugmem)
 106                        printk(KERN_DEBUG "sound: start 0x%lx, end 0x%lx\n", (long) start_addr, (long) end_addr);
 107                
 108                /* now check if it fits into the same dma-pagesize */
 109
 110                if (((long) start_addr & ~(dma_pagesize - 1)) != ((long) end_addr & ~(dma_pagesize - 1))
 111                    || end_addr >= (char *) (MAX_DMA_ADDRESS)) {
 112                        printk(KERN_ERR "sound: Got invalid address 0x%lx for %db DMA-buffer\n", (long) start_addr, dmap->buffsize);
 113                        return -EFAULT;
 114                }
 115        }
 116        dmap->raw_buf = start_addr;
 117        dmap->raw_buf_phys = dma_map_single(NULL, start_addr, dmap->buffsize, DMA_BIDIRECTIONAL);
 118
 119        for (page = virt_to_page(start_addr); page <= virt_to_page(end_addr); page++)
 120                SetPageReserved(page);
 121        return 0;
 122}
 123
 124static void sound_free_dmap(struct dma_buffparms *dmap)
 125{
 126        int sz, size;
 127        struct page *page;
 128        unsigned long start_addr, end_addr;
 129
 130        if (dmap->raw_buf == NULL)
 131                return;
 132        if (dmap->mapping_flags & DMA_MAP_MAPPED)
 133                return;         /* Don't free mmapped buffer. Will use it next time */
 134        for (sz = 0, size = PAGE_SIZE; size < dmap->buffsize; sz++, size <<= 1);
 135
 136        start_addr = (unsigned long) dmap->raw_buf;
 137        end_addr = start_addr + dmap->buffsize;
 138
 139        for (page = virt_to_page(start_addr); page <= virt_to_page(end_addr); page++)
 140                ClearPageReserved(page);
 141
 142        dma_unmap_single(NULL, dmap->raw_buf_phys, dmap->buffsize, DMA_BIDIRECTIONAL);
 143        free_pages((unsigned long) dmap->raw_buf, sz);
 144        dmap->raw_buf = NULL;
 145}
 146
 147
 148/* Intel version !!!!!!!!! */
 149
 150static int sound_start_dma(struct dma_buffparms *dmap, unsigned long physaddr, int count, int dma_mode)
 151{
 152        unsigned long flags;
 153        int chan = dmap->dma;
 154
 155        /* printk( "Start DMA%d %d, %d\n",  chan,  (int)(physaddr-dmap->raw_buf_phys),  count); */
 156
 157        flags = claim_dma_lock();
 158        disable_dma(chan);
 159        clear_dma_ff(chan);
 160        set_dma_mode(chan, dma_mode);
 161        set_dma_addr(chan, physaddr);
 162        set_dma_count(chan, count);
 163        enable_dma(chan);
 164        release_dma_lock(flags);
 165
 166        return 0;
 167}
 168
 169static void dma_init_buffers(struct dma_buffparms *dmap)
 170{
 171        dmap->qlen = dmap->qhead = dmap->qtail = dmap->user_counter = 0;
 172        dmap->byte_counter = 0;
 173        dmap->max_byte_counter = 8000 * 60 * 60;
 174        dmap->bytes_in_use = dmap->buffsize;
 175
 176        dmap->dma_mode = DMODE_NONE;
 177        dmap->mapping_flags = 0;
 178        dmap->neutral_byte = 0x80;
 179        dmap->data_rate = 8000;
 180        dmap->cfrag = -1;
 181        dmap->closing = 0;
 182        dmap->nbufs = 1;
 183        dmap->flags = DMA_BUSY; /* Other flags off */
 184}
 185
 186static int open_dmap(struct audio_operations *adev, int mode, struct dma_buffparms *dmap)
 187{
 188        int err;
 189        
 190        if (dmap->flags & DMA_BUSY)
 191                return -EBUSY;
 192        if ((err = sound_alloc_dmap(dmap)) < 0)
 193                return err;
 194
 195        if (dmap->raw_buf == NULL) {
 196                printk(KERN_WARNING "Sound: DMA buffers not available\n");
 197                return -ENOSPC; /* Memory allocation failed during boot */
 198        }
 199        if (dmap->dma >= 0 && sound_open_dma(dmap->dma, adev->name)) {
 200                printk(KERN_WARNING "Unable to grab(2) DMA%d for the audio driver\n", dmap->dma);
 201                return -EBUSY;
 202        }
 203        dma_init_buffers(dmap);
 204        spin_lock_init(&dmap->lock);
 205        dmap->open_mode = mode;
 206        dmap->subdivision = dmap->underrun_count = 0;
 207        dmap->fragment_size = 0;
 208        dmap->max_fragments = 65536;    /* Just a large value */
 209        dmap->byte_counter = 0;
 210        dmap->max_byte_counter = 8000 * 60 * 60;
 211        dmap->applic_profile = APF_NORMAL;
 212        dmap->needs_reorg = 1;
 213        dmap->audio_callback = NULL;
 214        dmap->callback_parm = 0;
 215        return 0;
 216}
 217
 218static void close_dmap(struct audio_operations *adev, struct dma_buffparms *dmap)
 219{
 220        unsigned long flags;
 221        
 222        if (dmap->dma >= 0) {
 223                sound_close_dma(dmap->dma);
 224                flags=claim_dma_lock();
 225                disable_dma(dmap->dma);
 226                release_dma_lock(flags);
 227        }
 228        if (dmap->flags & DMA_BUSY)
 229                dmap->dma_mode = DMODE_NONE;
 230        dmap->flags &= ~DMA_BUSY;
 231        
 232        if (sound_dmap_flag == DMAP_FREE_ON_CLOSE)
 233                sound_free_dmap(dmap);
 234}
 235
 236
 237static unsigned int default_set_bits(int dev, unsigned int bits)
 238{
 239        mm_segment_t fs = get_fs();
 240
 241        set_fs(get_ds());
 242        audio_devs[dev]->d->ioctl(dev, SNDCTL_DSP_SETFMT, (void __user *)&bits);
 243        set_fs(fs);
 244        return bits;
 245}
 246
 247static int default_set_speed(int dev, int speed)
 248{
 249        mm_segment_t fs = get_fs();
 250
 251        set_fs(get_ds());
 252        audio_devs[dev]->d->ioctl(dev, SNDCTL_DSP_SPEED, (void __user *)&speed);
 253        set_fs(fs);
 254        return speed;
 255}
 256
 257static short default_set_channels(int dev, short channels)
 258{
 259        int c = channels;
 260        mm_segment_t fs = get_fs();
 261
 262        set_fs(get_ds());
 263        audio_devs[dev]->d->ioctl(dev, SNDCTL_DSP_CHANNELS, (void __user *)&c);
 264        set_fs(fs);
 265        return c;
 266}
 267
 268static void check_driver(struct audio_driver *d)
 269{
 270        if (d->set_speed == NULL)
 271                d->set_speed = default_set_speed;
 272        if (d->set_bits == NULL)
 273                d->set_bits = default_set_bits;
 274        if (d->set_channels == NULL)
 275                d->set_channels = default_set_channels;
 276}
 277
 278int DMAbuf_open(int dev, int mode)
 279{
 280        struct audio_operations *adev = audio_devs[dev];
 281        int retval;
 282        struct dma_buffparms *dmap_in = NULL;
 283        struct dma_buffparms *dmap_out = NULL;
 284
 285        if (!adev)
 286                  return -ENXIO;
 287        if (!(adev->flags & DMA_DUPLEX))
 288                adev->dmap_in = adev->dmap_out;
 289        check_driver(adev->d);
 290
 291        if ((retval = adev->d->open(dev, mode)) < 0)
 292                return retval;
 293        dmap_out = adev->dmap_out;
 294        dmap_in = adev->dmap_in;
 295        if (dmap_in == dmap_out)
 296                adev->flags &= ~DMA_DUPLEX;
 297
 298        if (mode & OPEN_WRITE) {
 299                if ((retval = open_dmap(adev, mode, dmap_out)) < 0) {
 300                        adev->d->close(dev);
 301                        return retval;
 302                }
 303        }
 304        adev->enable_bits = mode;
 305
 306        if (mode == OPEN_READ || (mode != OPEN_WRITE && (adev->flags & DMA_DUPLEX))) {
 307                if ((retval = open_dmap(adev, mode, dmap_in)) < 0) {
 308                        adev->d->close(dev);
 309                        if (mode & OPEN_WRITE)
 310                                close_dmap(adev, dmap_out);
 311                        return retval;
 312                }
 313        }
 314        adev->open_mode = mode;
 315        adev->go = 1;
 316
 317        adev->d->set_bits(dev, 8);
 318        adev->d->set_channels(dev, 1);
 319        adev->d->set_speed(dev, DSP_DEFAULT_SPEED);
 320        if (adev->dmap_out->dma_mode == DMODE_OUTPUT) 
 321                memset(adev->dmap_out->raw_buf, adev->dmap_out->neutral_byte,
 322                       adev->dmap_out->bytes_in_use);
 323        return 0;
 324}
 325/* MUST not hold the spinlock */
 326void DMAbuf_reset(int dev)
 327{
 328        if (audio_devs[dev]->open_mode & OPEN_WRITE)
 329                dma_reset_output(dev);
 330
 331        if (audio_devs[dev]->open_mode & OPEN_READ)
 332                dma_reset_input(dev);
 333}
 334
 335static void dma_reset_output(int dev)
 336{
 337        struct audio_operations *adev = audio_devs[dev];
 338        unsigned long flags,f ;
 339        struct dma_buffparms *dmap = adev->dmap_out;
 340
 341        if (!(dmap->flags & DMA_STARTED))       /* DMA is not active */
 342                return;
 343
 344        /*
 345         *      First wait until the current fragment has been played completely
 346         */
 347        spin_lock_irqsave(&dmap->lock,flags);
 348        adev->dmap_out->flags |= DMA_SYNCING;
 349
 350        adev->dmap_out->underrun_count = 0;
 351        if (!signal_pending(current) && adev->dmap_out->qlen && 
 352            adev->dmap_out->underrun_count == 0){
 353                spin_unlock_irqrestore(&dmap->lock,flags);
 354                interruptible_sleep_on_timeout(&adev->out_sleeper,
 355                                               dmabuf_timeout(dmap));
 356                spin_lock_irqsave(&dmap->lock,flags);
 357        }
 358        adev->dmap_out->flags &= ~(DMA_SYNCING | DMA_ACTIVE);
 359
 360        /*
 361         *      Finally shut the device off
 362         */
 363        if (!(adev->flags & DMA_DUPLEX) || !adev->d->halt_output)
 364                adev->d->halt_io(dev);
 365        else
 366                adev->d->halt_output(dev);
 367        adev->dmap_out->flags &= ~DMA_STARTED;
 368        
 369        f=claim_dma_lock();
 370        clear_dma_ff(dmap->dma);
 371        disable_dma(dmap->dma);
 372        release_dma_lock(f);
 373        
 374        dmap->byte_counter = 0;
 375        reorganize_buffers(dev, adev->dmap_out, 0);
 376        dmap->qlen = dmap->qhead = dmap->qtail = dmap->user_counter = 0;
 377        spin_unlock_irqrestore(&dmap->lock,flags);
 378}
 379
 380static void dma_reset_input(int dev)
 381{
 382        struct audio_operations *adev = audio_devs[dev];
 383        unsigned long flags;
 384        struct dma_buffparms *dmap = adev->dmap_in;
 385
 386        spin_lock_irqsave(&dmap->lock,flags);
 387        if (!(adev->flags & DMA_DUPLEX) || !adev->d->halt_input)
 388                adev->d->halt_io(dev);
 389        else
 390                adev->d->halt_input(dev);
 391        adev->dmap_in->flags &= ~DMA_STARTED;
 392
 393        dmap->qlen = dmap->qhead = dmap->qtail = dmap->user_counter = 0;
 394        dmap->byte_counter = 0;
 395        reorganize_buffers(dev, adev->dmap_in, 1);
 396        spin_unlock_irqrestore(&dmap->lock,flags);
 397}
 398/* MUST be called with holding the dmap->lock */
 399void DMAbuf_launch_output(int dev, struct dma_buffparms *dmap)
 400{
 401        struct audio_operations *adev = audio_devs[dev];
 402
 403        if (!((adev->enable_bits * adev->go) & PCM_ENABLE_OUTPUT))
 404                return;         /* Don't start DMA yet */
 405        dmap->dma_mode = DMODE_OUTPUT;
 406
 407        if (!(dmap->flags & DMA_ACTIVE) || !(adev->flags & DMA_AUTOMODE) || (dmap->flags & DMA_NODMA)) {
 408                if (!(dmap->flags & DMA_STARTED)) {
 409                        reorganize_buffers(dev, dmap, 0);
 410                        if (adev->d->prepare_for_output(dev, dmap->fragment_size, dmap->nbufs))
 411                                return;
 412                        if (!(dmap->flags & DMA_NODMA))
 413                                local_start_dma(adev, dmap->raw_buf_phys, dmap->bytes_in_use,DMA_MODE_WRITE);
 414                        dmap->flags |= DMA_STARTED;
 415                }
 416                if (dmap->counts[dmap->qhead] == 0)
 417                        dmap->counts[dmap->qhead] = dmap->fragment_size;
 418                dmap->dma_mode = DMODE_OUTPUT;
 419                adev->d->output_block(dev, dmap->raw_buf_phys + dmap->qhead * dmap->fragment_size,
 420                                      dmap->counts[dmap->qhead], 1);
 421                if (adev->d->trigger)
 422                        adev->d->trigger(dev,adev->enable_bits * adev->go);
 423        }
 424        dmap->flags |= DMA_ACTIVE;
 425}
 426
 427int DMAbuf_sync(int dev)
 428{
 429        struct audio_operations *adev = audio_devs[dev];
 430        unsigned long flags;
 431        int n = 0;
 432        struct dma_buffparms *dmap;
 433
 434        if (!adev->go && !(adev->enable_bits & PCM_ENABLE_OUTPUT))
 435                return 0;
 436
 437        if (adev->dmap_out->dma_mode == DMODE_OUTPUT) {
 438                dmap = adev->dmap_out;
 439                spin_lock_irqsave(&dmap->lock,flags);
 440                if (dmap->qlen > 0 && !(dmap->flags & DMA_ACTIVE))
 441                        DMAbuf_launch_output(dev, dmap);
 442                adev->dmap_out->flags |= DMA_SYNCING;
 443                adev->dmap_out->underrun_count = 0;
 444                while (!signal_pending(current) && n++ < adev->dmap_out->nbufs &&
 445                       adev->dmap_out->qlen && adev->dmap_out->underrun_count == 0) {
 446                        long t = dmabuf_timeout(dmap);
 447                        spin_unlock_irqrestore(&dmap->lock,flags);
 448                        /* FIXME: not safe may miss events */
 449                        t = interruptible_sleep_on_timeout(&adev->out_sleeper, t);
 450                        spin_lock_irqsave(&dmap->lock,flags);
 451                        if (!t) {
 452                                adev->dmap_out->flags &= ~DMA_SYNCING;
 453                                spin_unlock_irqrestore(&dmap->lock,flags);
 454                                return adev->dmap_out->qlen;
 455                        }
 456                }
 457                adev->dmap_out->flags &= ~(DMA_SYNCING | DMA_ACTIVE);
 458                
 459                /*
 460                 * Some devices such as GUS have huge amount of on board RAM for the
 461                 * audio data. We have to wait until the device has finished playing.
 462                 */
 463
 464                /* still holding the lock */
 465                if (adev->d->local_qlen) {   /* Device has hidden buffers */
 466                        while (!signal_pending(current) &&
 467                               adev->d->local_qlen(dev)){
 468                                spin_unlock_irqrestore(&dmap->lock,flags);
 469                                interruptible_sleep_on_timeout(&adev->out_sleeper,
 470                                                               dmabuf_timeout(dmap));
 471                                spin_lock_irqsave(&dmap->lock,flags);
 472                        }
 473                }
 474                spin_unlock_irqrestore(&dmap->lock,flags);
 475        }
 476        adev->dmap_out->dma_mode = DMODE_NONE;
 477        return adev->dmap_out->qlen;
 478}
 479
 480int DMAbuf_release(int dev, int mode)
 481{
 482        struct audio_operations *adev = audio_devs[dev];
 483        struct dma_buffparms *dmap;
 484        unsigned long flags;
 485
 486        dmap = adev->dmap_out;
 487        if (adev->open_mode & OPEN_WRITE)
 488                adev->dmap_out->closing = 1;
 489
 490        if (adev->open_mode & OPEN_READ){
 491                adev->dmap_in->closing = 1;
 492                dmap = adev->dmap_in;
 493        }
 494        if (adev->open_mode & OPEN_WRITE)
 495                if (!(adev->dmap_out->mapping_flags & DMA_MAP_MAPPED))
 496                        if (!signal_pending(current) && (adev->dmap_out->dma_mode == DMODE_OUTPUT))
 497                                DMAbuf_sync(dev);
 498        if (adev->dmap_out->dma_mode == DMODE_OUTPUT)
 499                memset(adev->dmap_out->raw_buf, adev->dmap_out->neutral_byte, adev->dmap_out->bytes_in_use);
 500
 501        DMAbuf_reset(dev);
 502        spin_lock_irqsave(&dmap->lock,flags);
 503        adev->d->close(dev);
 504
 505        if (adev->open_mode & OPEN_WRITE)
 506                close_dmap(adev, adev->dmap_out);
 507
 508        if (adev->open_mode == OPEN_READ ||
 509            (adev->open_mode != OPEN_WRITE &&
 510             (adev->flags & DMA_DUPLEX)))
 511                close_dmap(adev, adev->dmap_in);
 512        adev->open_mode = 0;
 513        spin_unlock_irqrestore(&dmap->lock,flags);
 514        return 0;
 515}
 516/* called with dmap->lock dold */
 517int DMAbuf_activate_recording(int dev, struct dma_buffparms *dmap)
 518{
 519        struct audio_operations *adev = audio_devs[dev];
 520        int  err;
 521
 522        if (!(adev->open_mode & OPEN_READ))
 523                return 0;
 524        if (!(adev->enable_bits & PCM_ENABLE_INPUT))
 525                return 0;
 526        if (dmap->dma_mode == DMODE_OUTPUT) {   /* Direction change */
 527                /* release lock - it's not recursive */
 528                spin_unlock_irq(&dmap->lock);
 529                DMAbuf_sync(dev);
 530                DMAbuf_reset(dev);
 531                spin_lock_irq(&dmap->lock);
 532                dmap->dma_mode = DMODE_NONE;
 533        }
 534        if (!dmap->dma_mode) {
 535                reorganize_buffers(dev, dmap, 1);
 536                if ((err = adev->d->prepare_for_input(dev,
 537                                dmap->fragment_size, dmap->nbufs)) < 0)
 538                        return err;
 539                dmap->dma_mode = DMODE_INPUT;
 540        }
 541        if (!(dmap->flags & DMA_ACTIVE)) {
 542                if (dmap->needs_reorg)
 543                        reorganize_buffers(dev, dmap, 0);
 544                local_start_dma(adev, dmap->raw_buf_phys, dmap->bytes_in_use, DMA_MODE_READ);
 545                adev->d->start_input(dev, dmap->raw_buf_phys + dmap->qtail * dmap->fragment_size,
 546                                     dmap->fragment_size, 0);
 547                dmap->flags |= DMA_ACTIVE;
 548                if (adev->d->trigger)
 549                        adev->d->trigger(dev, adev->enable_bits * adev->go);
 550        }
 551        return 0;
 552}
 553/* acquires lock */
 554int DMAbuf_getrdbuffer(int dev, char **buf, int *len, int dontblock)
 555{
 556        struct audio_operations *adev = audio_devs[dev];
 557        unsigned long flags;
 558        int err = 0, n = 0;
 559        struct dma_buffparms *dmap = adev->dmap_in;
 560        int go;
 561
 562        if (!(adev->open_mode & OPEN_READ))
 563                return -EIO;
 564        spin_lock_irqsave(&dmap->lock,flags);
 565        if (dmap->needs_reorg)
 566                reorganize_buffers(dev, dmap, 0);
 567        if (adev->dmap_in->mapping_flags & DMA_MAP_MAPPED) {
 568/*                printk(KERN_WARNING "Sound: Can't read from mmapped device (1)\n");*/
 569                  spin_unlock_irqrestore(&dmap->lock,flags);
 570                  return -EINVAL;
 571        } else while (dmap->qlen <= 0 && n++ < 10) {
 572                long timeout = MAX_SCHEDULE_TIMEOUT;
 573                if (!(adev->enable_bits & PCM_ENABLE_INPUT) || !adev->go) {
 574                        spin_unlock_irqrestore(&dmap->lock,flags);
 575                        return -EAGAIN;
 576                }
 577                if ((err = DMAbuf_activate_recording(dev, dmap)) < 0) {
 578                        spin_unlock_irqrestore(&dmap->lock,flags);
 579                        return err;
 580                }
 581                /* Wait for the next block */
 582
 583                if (dontblock) {
 584                        spin_unlock_irqrestore(&dmap->lock,flags);
 585                        return -EAGAIN;
 586                }
 587                if ((go = adev->go))
 588                        timeout = dmabuf_timeout(dmap);
 589
 590                spin_unlock_irqrestore(&dmap->lock,flags);
 591                timeout = interruptible_sleep_on_timeout(&adev->in_sleeper,
 592                                                         timeout);
 593                if (!timeout) {
 594                        /* FIXME: include device name */
 595                        err = -EIO;
 596                        printk(KERN_WARNING "Sound: DMA (input) timed out - IRQ/DRQ config error?\n");
 597                        dma_reset_input(dev);
 598                } else
 599                        err = -EINTR;
 600                spin_lock_irqsave(&dmap->lock,flags);
 601        }
 602        spin_unlock_irqrestore(&dmap->lock,flags);
 603
 604        if (dmap->qlen <= 0)
 605                return err ? err : -EINTR;
 606        *buf = &dmap->raw_buf[dmap->qhead * dmap->fragment_size + dmap->counts[dmap->qhead]];
 607        *len = dmap->fragment_size - dmap->counts[dmap->qhead];
 608
 609        return dmap->qhead;
 610}
 611
 612int DMAbuf_rmchars(int dev, int buff_no, int c)
 613{
 614        struct audio_operations *adev = audio_devs[dev];
 615        struct dma_buffparms *dmap = adev->dmap_in;
 616        int p = dmap->counts[dmap->qhead] + c;
 617
 618        if (dmap->mapping_flags & DMA_MAP_MAPPED)
 619        {
 620/*                printk("Sound: Can't read from mmapped device (2)\n");*/
 621                return -EINVAL;
 622        }
 623        else if (dmap->qlen <= 0)
 624                return -EIO;
 625        else if (p >= dmap->fragment_size) {  /* This buffer is completely empty */
 626                dmap->counts[dmap->qhead] = 0;
 627                dmap->qlen--;
 628                dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
 629        }
 630        else dmap->counts[dmap->qhead] = p;
 631
 632        return 0;
 633}
 634/* MUST be called with dmap->lock hold */
 635int DMAbuf_get_buffer_pointer(int dev, struct dma_buffparms *dmap, int direction)
 636{
 637        /*
 638         *      Try to approximate the active byte position of the DMA pointer within the
 639         *      buffer area as well as possible.
 640         */
 641
 642        int pos;
 643        unsigned long f;
 644
 645        if (!(dmap->flags & DMA_ACTIVE))
 646                pos = 0;
 647        else {
 648                int chan = dmap->dma;
 649                
 650                f=claim_dma_lock();
 651                clear_dma_ff(chan);
 652                
 653                if(!isa_dma_bridge_buggy)
 654                        disable_dma(dmap->dma);
 655                
 656                pos = get_dma_residue(chan);
 657                
 658                pos = dmap->bytes_in_use - pos;
 659
 660                if (!(dmap->mapping_flags & DMA_MAP_MAPPED)) {
 661                        if (direction == DMODE_OUTPUT) {
 662                                if (dmap->qhead == 0)
 663                                        if (pos > dmap->fragment_size)
 664                                                pos = 0;
 665                        } else {
 666                                if (dmap->qtail == 0)
 667                                        if (pos > dmap->fragment_size)
 668                                                pos = 0;
 669                        }
 670                }
 671                if (pos < 0)
 672                        pos = 0;
 673                if (pos >= dmap->bytes_in_use)
 674                        pos = 0;
 675                
 676                if(!isa_dma_bridge_buggy)
 677                        enable_dma(dmap->dma);
 678                        
 679                release_dma_lock(f);
 680        }
 681        /* printk( "%04x ",  pos); */
 682
 683        return pos;
 684}
 685
 686/*
 687 *      DMAbuf_start_devices() is called by the /dev/music driver to start
 688 *      one or more audio devices at desired moment.
 689 */
 690
 691void DMAbuf_start_devices(unsigned int devmask)
 692{
 693        struct audio_operations *adev;
 694        int dev;
 695
 696        for (dev = 0; dev < num_audiodevs; dev++) {
 697                if (!(devmask & (1 << dev)))
 698                        continue;
 699                if (!(adev = audio_devs[dev]))
 700                        continue;
 701                if (adev->open_mode == 0)
 702                        continue;
 703                if (adev->go)
 704                        continue;
 705                /* OK to start the device */
 706                adev->go = 1;
 707                if (adev->d->trigger)
 708                        adev->d->trigger(dev,adev->enable_bits * adev->go);
 709        }
 710}
 711/* via poll called without a lock ?*/
 712int DMAbuf_space_in_queue(int dev)
 713{
 714        struct audio_operations *adev = audio_devs[dev];
 715        int len, max, tmp;
 716        struct dma_buffparms *dmap = adev->dmap_out;
 717        int lim = dmap->nbufs;
 718
 719        if (lim < 2)
 720                lim = 2;
 721
 722        if (dmap->qlen >= lim)  /* No space at all */
 723                return 0;
 724
 725        /*
 726         *      Verify that there are no more pending buffers than the limit
 727         *      defined by the process.
 728         */
 729
 730        max = dmap->max_fragments;
 731        if (max > lim)
 732                max = lim;
 733        len = dmap->qlen;
 734
 735        if (adev->d->local_qlen) {
 736                tmp = adev->d->local_qlen(dev);
 737                if (tmp && len)
 738                        tmp--;  /* This buffer has been counted twice */
 739                len += tmp;
 740        }
 741        if (dmap->byte_counter % dmap->fragment_size)   /* There is a partial fragment */
 742                len = len + 1;
 743
 744        if (len >= max)
 745                return 0;
 746        return max - len;
 747}
 748/* MUST not hold the spinlock  - this function may sleep */
 749static int output_sleep(int dev, int dontblock)
 750{
 751        struct audio_operations *adev = audio_devs[dev];
 752        int err = 0;
 753        struct dma_buffparms *dmap = adev->dmap_out;
 754        long timeout;
 755        long timeout_value;
 756
 757        if (dontblock)
 758                return -EAGAIN;
 759        if (!(adev->enable_bits & PCM_ENABLE_OUTPUT))
 760                return -EAGAIN;
 761
 762        /*
 763         * Wait for free space
 764         */
 765        if (signal_pending(current))
 766                return -EINTR;
 767        timeout = (adev->go && !(dmap->flags & DMA_NOTIMEOUT));
 768        if (timeout) 
 769                timeout_value = dmabuf_timeout(dmap);
 770        else
 771                timeout_value = MAX_SCHEDULE_TIMEOUT;
 772        timeout_value = interruptible_sleep_on_timeout(&adev->out_sleeper,
 773                                                       timeout_value);
 774        if (timeout != MAX_SCHEDULE_TIMEOUT && !timeout_value) {
 775                printk(KERN_WARNING "Sound: DMA (output) timed out - IRQ/DRQ config error?\n");
 776                dma_reset_output(dev);
 777        } else {
 778                if (signal_pending(current))
 779                        err = -EINTR;
 780        }
 781        return err;
 782}
 783/* called with the lock held */
 784static int find_output_space(int dev, char **buf, int *size)
 785{
 786        struct audio_operations *adev = audio_devs[dev];
 787        struct dma_buffparms *dmap = adev->dmap_out;
 788        unsigned long active_offs;
 789        long len, offs;
 790        int maxfrags;
 791        int occupied_bytes = (dmap->user_counter % dmap->fragment_size);
 792
 793        *buf = dmap->raw_buf;
 794        if (!(maxfrags = DMAbuf_space_in_queue(dev)) && !occupied_bytes)
 795                return 0;
 796
 797#ifdef BE_CONSERVATIVE
 798        active_offs = dmap->byte_counter + dmap->qhead * dmap->fragment_size;
 799#else
 800        active_offs = max(DMAbuf_get_buffer_pointer(dev, dmap, DMODE_OUTPUT), 0);
 801        /* Check for pointer wrapping situation */
 802        if (active_offs >= dmap->bytes_in_use)
 803                active_offs = 0;
 804        active_offs += dmap->byte_counter;
 805#endif
 806
 807        offs = (dmap->user_counter % dmap->bytes_in_use) & ~SAMPLE_ROUNDUP;
 808        if (offs < 0 || offs >= dmap->bytes_in_use) {
 809                printk(KERN_ERR "Sound: Got unexpected offs %ld. Giving up.\n", offs);
 810                printk("Counter = %ld, bytes=%d\n", dmap->user_counter, dmap->bytes_in_use);
 811                return 0;
 812        }
 813        *buf = dmap->raw_buf + offs;
 814
 815        len = active_offs + dmap->bytes_in_use - dmap->user_counter;    /* Number of unused bytes in buffer */
 816
 817        if ((offs + len) > dmap->bytes_in_use)
 818                len = dmap->bytes_in_use - offs;
 819        if (len < 0) {
 820                return 0;
 821        }
 822        if (len > ((maxfrags * dmap->fragment_size) - occupied_bytes))
 823                len = (maxfrags * dmap->fragment_size) - occupied_bytes;
 824        *size = len & ~SAMPLE_ROUNDUP;
 825        return (*size > 0);
 826}
 827/* acquires lock  */
 828int DMAbuf_getwrbuffer(int dev, char **buf, int *size, int dontblock)
 829{
 830        struct audio_operations *adev = audio_devs[dev];
 831        unsigned long flags;
 832        int err = -EIO;
 833        struct dma_buffparms *dmap = adev->dmap_out;
 834
 835        if (dmap->mapping_flags & DMA_MAP_MAPPED) {
 836/*              printk(KERN_DEBUG "Sound: Can't write to mmapped device (3)\n");*/
 837                return -EINVAL;
 838        }
 839        spin_lock_irqsave(&dmap->lock,flags);
 840        if (dmap->needs_reorg)
 841                reorganize_buffers(dev, dmap, 0);
 842
 843        if (dmap->dma_mode == DMODE_INPUT) {    /* Direction change */
 844                spin_unlock_irqrestore(&dmap->lock,flags);
 845                DMAbuf_reset(dev);
 846                spin_lock_irqsave(&dmap->lock,flags);
 847        }
 848        dmap->dma_mode = DMODE_OUTPUT;
 849
 850        while (find_output_space(dev, buf, size) <= 0) {
 851                spin_unlock_irqrestore(&dmap->lock,flags);
 852                if ((err = output_sleep(dev, dontblock)) < 0) {
 853                        return err;
 854                }
 855                spin_lock_irqsave(&dmap->lock,flags);
 856        }
 857
 858        spin_unlock_irqrestore(&dmap->lock,flags);
 859        return 0;
 860}
 861/* has to acquire dmap->lock */
 862int DMAbuf_move_wrpointer(int dev, int l)
 863{
 864        struct audio_operations *adev = audio_devs[dev];
 865        struct dma_buffparms *dmap = adev->dmap_out;
 866        unsigned long ptr;
 867        unsigned long end_ptr, p;
 868        int post;
 869        unsigned long flags;
 870
 871        spin_lock_irqsave(&dmap->lock,flags);
 872        post= (dmap->flags & DMA_POST);
 873        ptr = (dmap->user_counter / dmap->fragment_size) * dmap->fragment_size;
 874
 875        dmap->flags &= ~DMA_POST;
 876        dmap->cfrag = -1;
 877        dmap->user_counter += l;
 878        dmap->flags |= DMA_DIRTY;
 879
 880        if (dmap->byte_counter >= dmap->max_byte_counter) {
 881                /* Wrap the byte counters */
 882                long decr = dmap->byte_counter;
 883                dmap->byte_counter = (dmap->byte_counter % dmap->bytes_in_use);
 884                decr -= dmap->byte_counter;
 885                dmap->user_counter -= decr;
 886        }
 887        end_ptr = (dmap->user_counter / dmap->fragment_size) * dmap->fragment_size;
 888
 889        p = (dmap->user_counter - 1) % dmap->bytes_in_use;
 890        dmap->neutral_byte = dmap->raw_buf[p];
 891
 892        /* Update the fragment based bookkeeping too */
 893        while (ptr < end_ptr) {
 894                dmap->counts[dmap->qtail] = dmap->fragment_size;
 895                dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
 896                dmap->qlen++;
 897                ptr += dmap->fragment_size;
 898        }
 899
 900        dmap->counts[dmap->qtail] = dmap->user_counter - ptr;
 901
 902        /*
 903         *      Let the low level driver perform some postprocessing to
 904         *      the written data.
 905         */
 906        if (adev->d->postprocess_write)
 907                adev->d->postprocess_write(dev);
 908
 909        if (!(dmap->flags & DMA_ACTIVE))
 910                if (dmap->qlen > 1 || (dmap->qlen > 0 && (post || dmap->qlen >= dmap->nbufs - 1)))
 911                        DMAbuf_launch_output(dev, dmap);
 912
 913        spin_unlock_irqrestore(&dmap->lock,flags);
 914        return 0;
 915}
 916
 917int DMAbuf_start_dma(int dev, unsigned long physaddr, int count, int dma_mode)
 918{
 919        struct audio_operations *adev = audio_devs[dev];
 920        struct dma_buffparms *dmap = (dma_mode == DMA_MODE_WRITE) ? adev->dmap_out : adev->dmap_in;
 921
 922        if (dmap->raw_buf == NULL) {
 923                printk(KERN_ERR "sound: DMA buffer(1) == NULL\n");
 924                printk("Device %d, chn=%s\n", dev, (dmap == adev->dmap_out) ? "out" : "in");
 925                return 0;
 926        }
 927        if (dmap->dma < 0)
 928                return 0;
 929        sound_start_dma(dmap, physaddr, count, dma_mode);
 930        return count;
 931}
 932EXPORT_SYMBOL(DMAbuf_start_dma);
 933
 934static int local_start_dma(struct audio_operations *adev, unsigned long physaddr, int count, int dma_mode)
 935{
 936        struct dma_buffparms *dmap = (dma_mode == DMA_MODE_WRITE) ? adev->dmap_out : adev->dmap_in;
 937
 938        if (dmap->raw_buf == NULL) {
 939                printk(KERN_ERR "sound: DMA buffer(2) == NULL\n");
 940                printk(KERN_ERR "Device %s, chn=%s\n", adev->name, (dmap == adev->dmap_out) ? "out" : "in");
 941                return 0;
 942        }
 943        if (dmap->flags & DMA_NODMA)
 944                return 1;
 945        if (dmap->dma < 0)
 946                return 0;
 947        sound_start_dma(dmap, dmap->raw_buf_phys, dmap->bytes_in_use, dma_mode | DMA_AUTOINIT);
 948        dmap->flags |= DMA_STARTED;
 949        return count;
 950}
 951
 952static void finish_output_interrupt(int dev, struct dma_buffparms *dmap)
 953{
 954        struct audio_operations *adev = audio_devs[dev];
 955
 956        if (dmap->audio_callback != NULL)
 957                dmap->audio_callback(dev, dmap->callback_parm);
 958        wake_up(&adev->out_sleeper);
 959        wake_up(&adev->poll_sleeper);
 960}
 961/* called with dmap->lock held in irq context*/
 962static void do_outputintr(int dev, int dummy)
 963{
 964        struct audio_operations *adev = audio_devs[dev];
 965        struct dma_buffparms *dmap = adev->dmap_out;
 966        int this_fragment;
 967
 968        if (dmap->raw_buf == NULL) {
 969                printk(KERN_ERR "Sound: Error. Audio interrupt (%d) after freeing buffers.\n", dev);
 970                return;
 971        }
 972        if (dmap->mapping_flags & DMA_MAP_MAPPED) {     /* Virtual memory mapped access */
 973                /* mmapped access */
 974                dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
 975                if (dmap->qhead == 0) {     /* Wrapped */
 976                        dmap->byte_counter += dmap->bytes_in_use;
 977                        if (dmap->byte_counter >= dmap->max_byte_counter) {     /* Overflow */
 978                                long decr = dmap->byte_counter;
 979                                dmap->byte_counter = (dmap->byte_counter % dmap->bytes_in_use);
 980                                decr -= dmap->byte_counter;
 981                                dmap->user_counter -= decr;
 982                        }
 983                }
 984                dmap->qlen++;   /* Yes increment it (don't decrement) */
 985                if (!(adev->flags & DMA_AUTOMODE))
 986                        dmap->flags &= ~DMA_ACTIVE;
 987                dmap->counts[dmap->qhead] = dmap->fragment_size;
 988                DMAbuf_launch_output(dev, dmap);
 989                finish_output_interrupt(dev, dmap);
 990                return;
 991        }
 992
 993        dmap->qlen--;
 994        this_fragment = dmap->qhead;
 995        dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
 996
 997        if (dmap->qhead == 0) { /* Wrapped */
 998                dmap->byte_counter += dmap->bytes_in_use;
 999                if (dmap->byte_counter >= dmap->max_byte_counter) {     /* Overflow */
1000                        long decr = dmap->byte_counter;
1001                        dmap->byte_counter = (dmap->byte_counter % dmap->bytes_in_use);
1002                        decr -= dmap->byte_counter;
1003                        dmap->user_counter -= decr;
1004                }
1005        }
1006        if (!(adev->flags & DMA_AUTOMODE))
1007                dmap->flags &= ~DMA_ACTIVE;
1008                
1009        /*
1010         *      This is  dmap->qlen <= 0 except when closing when
1011         *      dmap->qlen < 0
1012         */
1013         
1014        while (dmap->qlen <= -dmap->closing) {
1015                dmap->underrun_count++;
1016                dmap->qlen++;
1017                if ((dmap->flags & DMA_DIRTY) && dmap->applic_profile != APF_CPUINTENS) {
1018                        dmap->flags &= ~DMA_DIRTY;
1019                        memset(adev->dmap_out->raw_buf, adev->dmap_out->neutral_byte,
1020                               adev->dmap_out->buffsize);
1021                }
1022                dmap->user_counter += dmap->fragment_size;
1023                dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
1024        }
1025        if (dmap->qlen > 0)
1026                DMAbuf_launch_output(dev, dmap);
1027        finish_output_interrupt(dev, dmap);
1028}
1029/* called in irq context */
1030void DMAbuf_outputintr(int dev, int notify_only)
1031{
1032        struct audio_operations *adev = audio_devs[dev];
1033        unsigned long flags;
1034        struct dma_buffparms *dmap = adev->dmap_out;
1035
1036        spin_lock_irqsave(&dmap->lock,flags);
1037        if (!(dmap->flags & DMA_NODMA)) {
1038                int chan = dmap->dma, pos, n;
1039                unsigned long f;
1040                
1041                f=claim_dma_lock();
1042                
1043                if(!isa_dma_bridge_buggy)
1044                        disable_dma(dmap->dma);
1045                clear_dma_ff(chan);
1046                pos = dmap->bytes_in_use - get_dma_residue(chan);
1047                if(!isa_dma_bridge_buggy)
1048                        enable_dma(dmap->dma);
1049                release_dma_lock(f);
1050                
1051                pos = pos / dmap->fragment_size;        /* Actual qhead */
1052                if (pos < 0 || pos >= dmap->nbufs)
1053                        pos = 0;
1054                n = 0;
1055                while (dmap->qhead != pos && n++ < dmap->nbufs)
1056                        do_outputintr(dev, notify_only);
1057        }
1058        else
1059                do_outputintr(dev, notify_only);
1060        spin_unlock_irqrestore(&dmap->lock,flags);
1061}
1062EXPORT_SYMBOL(DMAbuf_outputintr);
1063
1064/* called with dmap->lock held in irq context */
1065static void do_inputintr(int dev)
1066{
1067        struct audio_operations *adev = audio_devs[dev];
1068        struct dma_buffparms *dmap = adev->dmap_in;
1069
1070        if (dmap->raw_buf == NULL) {
1071                printk(KERN_ERR "Sound: Fatal error. Audio interrupt after freeing buffers.\n");
1072                return;
1073        }
1074        if (dmap->mapping_flags & DMA_MAP_MAPPED) {
1075                dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
1076                if (dmap->qtail == 0) {         /* Wrapped */
1077                        dmap->byte_counter += dmap->bytes_in_use;
1078                        if (dmap->byte_counter >= dmap->max_byte_counter) {     /* Overflow */
1079                                long decr = dmap->byte_counter;
1080                                dmap->byte_counter = (dmap->byte_counter % dmap->bytes_in_use) + dmap->bytes_in_use;
1081                                decr -= dmap->byte_counter;
1082                                dmap->user_counter -= decr;
1083                        }
1084                }
1085                dmap->qlen++;
1086
1087                if (!(adev->flags & DMA_AUTOMODE)) {
1088                        if (dmap->needs_reorg)
1089                                reorganize_buffers(dev, dmap, 0);
1090                        local_start_dma(adev, dmap->raw_buf_phys, dmap->bytes_in_use,DMA_MODE_READ);
1091                        adev->d->start_input(dev, dmap->raw_buf_phys + dmap->qtail * dmap->fragment_size,
1092                                             dmap->fragment_size, 1);
1093                        if (adev->d->trigger)
1094                                adev->d->trigger(dev, adev->enable_bits * adev->go);
1095                }
1096                dmap->flags |= DMA_ACTIVE;
1097        } else if (dmap->qlen >= (dmap->nbufs - 1)) {
1098                printk(KERN_WARNING "Sound: Recording overrun\n");
1099                dmap->underrun_count++;
1100
1101                /* Just throw away the oldest fragment but keep the engine running */
1102                dmap->qhead = (dmap->qhead + 1) % dmap->nbufs;
1103                dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
1104        } else if (dmap->qlen >= 0 && dmap->qlen < dmap->nbufs) {
1105                dmap->qlen++;
1106                dmap->qtail = (dmap->qtail + 1) % dmap->nbufs;
1107                if (dmap->qtail == 0) {         /* Wrapped */
1108                        dmap->byte_counter += dmap->bytes_in_use;
1109                        if (dmap->byte_counter >= dmap->max_byte_counter) {     /* Overflow */
1110                                long decr = dmap->byte_counter;
1111                                dmap->byte_counter = (dmap->byte_counter % dmap->bytes_in_use) + dmap->bytes_in_use;
1112                                decr -= dmap->byte_counter;
1113                                dmap->user_counter -= decr;
1114                        }
1115                }
1116        }
1117        if (!(adev->flags & DMA_AUTOMODE) || (dmap->flags & DMA_NODMA)) {
1118                local_start_dma(adev, dmap->raw_buf_phys, dmap->bytes_in_use, DMA_MODE_READ);
1119                adev->d->start_input(dev, dmap->raw_buf_phys + dmap->qtail * dmap->fragment_size, dmap->fragment_size, 1);
1120                if (adev->d->trigger)
1121                        adev->d->trigger(dev,adev->enable_bits * adev->go);
1122        }
1123        dmap->flags |= DMA_ACTIVE;
1124        if (dmap->qlen > 0)
1125        {
1126                wake_up(&adev->in_sleeper);
1127                wake_up(&adev->poll_sleeper);
1128        }
1129}
1130/* called in irq context */
1131void DMAbuf_inputintr(int dev)
1132{
1133        struct audio_operations *adev = audio_devs[dev];
1134        struct dma_buffparms *dmap = adev->dmap_in;
1135        unsigned long flags;
1136
1137        spin_lock_irqsave(&dmap->lock,flags);
1138
1139        if (!(dmap->flags & DMA_NODMA)) {
1140                int chan = dmap->dma, pos, n;
1141                unsigned long f;
1142                
1143                f=claim_dma_lock();
1144                if(!isa_dma_bridge_buggy)
1145                        disable_dma(dmap->dma);
1146                clear_dma_ff(chan);
1147                pos = dmap->bytes_in_use - get_dma_residue(chan);
1148                if(!isa_dma_bridge_buggy)
1149                        enable_dma(dmap->dma);
1150                release_dma_lock(f);
1151
1152                pos = pos / dmap->fragment_size;        /* Actual qhead */
1153                if (pos < 0 || pos >= dmap->nbufs)
1154                        pos = 0;
1155
1156                n = 0;
1157                while (dmap->qtail != pos && ++n < dmap->nbufs)
1158                        do_inputintr(dev);
1159        } else
1160                do_inputintr(dev);
1161        spin_unlock_irqrestore(&dmap->lock,flags);
1162}
1163EXPORT_SYMBOL(DMAbuf_inputintr);
1164
1165void DMAbuf_init(int dev, int dma1, int dma2)
1166{
1167        struct audio_operations *adev = audio_devs[dev];
1168        /*
1169         * NOTE! This routine could be called several times.
1170         */
1171
1172        if (adev && adev->dmap_out == NULL) {
1173                if (adev->d == NULL)
1174                        panic("OSS: audio_devs[%d]->d == NULL\n", dev);
1175
1176                if (adev->parent_dev) {  /* Use DMA map of the parent dev */
1177                        int parent = adev->parent_dev - 1;
1178                        adev->dmap_out = audio_devs[parent]->dmap_out;
1179                        adev->dmap_in = audio_devs[parent]->dmap_in;
1180                } else {
1181                        adev->dmap_out = adev->dmap_in = &adev->dmaps[0];
1182                        adev->dmap_out->dma = dma1;
1183                        if (adev->flags & DMA_DUPLEX) {
1184                                adev->dmap_in = &adev->dmaps[1];
1185                                adev->dmap_in->dma = dma2;
1186                        }
1187                }
1188                /* Persistent DMA buffers allocated here */
1189                if (sound_dmap_flag == DMAP_KEEP_ON_CLOSE) {
1190                        if (adev->dmap_in->raw_buf == NULL)
1191                                sound_alloc_dmap(adev->dmap_in);
1192                        if (adev->dmap_out->raw_buf == NULL)
1193                                sound_alloc_dmap(adev->dmap_out);
1194                }
1195        }
1196}
1197
1198/* No kernel lock - DMAbuf_activate_recording protected by global cli/sti */
1199static unsigned int poll_input(struct file * file, int dev, poll_table *wait)
1200{
1201        struct audio_operations *adev = audio_devs[dev];
1202        struct dma_buffparms *dmap = adev->dmap_in;
1203
1204        if (!(adev->open_mode & OPEN_READ))
1205                return 0;
1206        if (dmap->mapping_flags & DMA_MAP_MAPPED) {
1207                if (dmap->qlen)
1208                        return POLLIN | POLLRDNORM;
1209                return 0;
1210        }
1211        if (dmap->dma_mode != DMODE_INPUT) {
1212                if (dmap->dma_mode == DMODE_NONE &&
1213                    adev->enable_bits & PCM_ENABLE_INPUT &&
1214                    !dmap->qlen && adev->go) {
1215                        unsigned long flags;
1216                        
1217                        spin_lock_irqsave(&dmap->lock,flags);
1218                        DMAbuf_activate_recording(dev, dmap);
1219                        spin_unlock_irqrestore(&dmap->lock,flags);
1220                }
1221                return 0;
1222        }
1223        if (!dmap->qlen)
1224                return 0;
1225        return POLLIN | POLLRDNORM;
1226}
1227
1228static unsigned int poll_output(struct file * file, int dev, poll_table *wait)
1229{
1230        struct audio_operations *adev = audio_devs[dev];
1231        struct dma_buffparms *dmap = adev->dmap_out;
1232        
1233        if (!(adev->open_mode & OPEN_WRITE))
1234                return 0;
1235        if (dmap->mapping_flags & DMA_MAP_MAPPED) {
1236                if (dmap->qlen)
1237                        return POLLOUT | POLLWRNORM;
1238                return 0;
1239        }
1240        if (dmap->dma_mode == DMODE_INPUT)
1241                return 0;
1242        if (dmap->dma_mode == DMODE_NONE)
1243                return POLLOUT | POLLWRNORM;
1244        if (!DMAbuf_space_in_queue(dev))
1245                return 0;
1246        return POLLOUT | POLLWRNORM;
1247}
1248
1249unsigned int DMAbuf_poll(struct file * file, int dev, poll_table *wait)
1250{
1251        struct audio_operations *adev = audio_devs[dev];
1252        poll_wait(file, &adev->poll_sleeper, wait);
1253        return poll_input(file, dev, wait) | poll_output(file, dev, wait);
1254}
1255
1256void DMAbuf_deinit(int dev)
1257{
1258        struct audio_operations *adev = audio_devs[dev];
1259        /* This routine is called when driver is being unloaded */
1260        if (!adev)
1261                return;
1262
1263        /* Persistent DMA buffers deallocated here */
1264        if (sound_dmap_flag == DMAP_KEEP_ON_CLOSE) {
1265                sound_free_dmap(adev->dmap_out);
1266                if (adev->flags & DMA_DUPLEX)
1267                        sound_free_dmap(adev->dmap_in);
1268        }
1269}
1270
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.