sound/isa/msnd/msnd.c

   1 /*********************************************************************
   2  *
   3  * 2002/06/30 Karsten Wiese:
   4  *      removed kernel-version dependencies.
   5  *      ripped from linux kernel 2.4.18 (OSS Implementation) by me.
   6  *      In the OSS Version, this file is compiled to a separate MODULE,
   7  *      that is used by the pinnacle and the classic driver.
   8  *      since there is no classic driver for alsa yet (i dont have a classic
   9  *      & writing one blindfold is difficult) this file's object is statically
  10  *      linked into the pinnacle-driver-module for now. look for the string
  11  *              "uncomment this to make this a module again"
  12  *      to do guess what.
  13  *
  14  * the following is a copy of the 2.4.18 OSS FREE file-heading comment:
  15  *
  16  * msnd.c - Driver Base
  17  *
  18  * Turtle Beach MultiSound Sound Card Driver for Linux
  19  *
  20  * Copyright (C) 1998 Andrew Veliath
  21  *
  22  * This program is free software; you can redistribute it and/or modify
  23  * it under the terms of the GNU General Public License as published by
  24  * the Free Software Foundation; either version 2 of the License, or
  25  * (at your option) any later version.
  26  *
  27  * This program is distributed in the hope that it will be useful,
  28  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  29  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  30  * GNU General Public License for more details.
  31  *
  32  * You should have received a copy of the GNU General Public License
  33  * along with this program; if not, write to the Free Software
  34  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  35  *
  36  ********************************************************************/
  37
  38 #include <linux/kernel.h>
  39 #include <linux/types.h>
  40 #include <linux/interrupt.h>
  41 #include <linux/io.h>
  42 #include <linux/fs.h>
  43 #include <linux/delay.h>
  44
  45 #include <sound/core.h>
  46 #include <sound/initval.h>
  47 #include <sound/pcm.h>
  48 #include <sound/pcm_params.h>
  49
  50 #include "msnd.h"
  51
  52 #define LOGNAME                 "msnd"
  53
  54
  55 void snd_msnd_init_queue(void *base, int start, int size)
  56 {
  57         writew(PCTODSP_BASED(start), base + JQS_wStart);
  58         writew(PCTODSP_OFFSET(size) - 1, base + JQS_wSize);
  59         writew(0, base + JQS_wHead);
  60         writew(0, base + JQS_wTail);
  61 }
  62 EXPORT_SYMBOL(snd_msnd_init_queue);
  63
  64 static int snd_msnd_wait_TXDE(struct snd_msnd *dev)
  65 {
  66         unsigned int io = dev->io;
  67         int timeout = 1000;
  68
  69         while (timeout-- > 0)
  70                 if (inb(io + HP_ISR) & HPISR_TXDE)
  71                         return 0;
  72
  73         return -EIO;
  74 }
  75
  76 static int snd_msnd_wait_HC0(struct snd_msnd *dev)
  77 {
  78         unsigned int io = dev->io;
  79         int timeout = 1000;
  80
  81         while (timeout-- > 0)
  82                 if (!(inb(io + HP_CVR) & HPCVR_HC))
  83                         return 0;
  84
  85         return -EIO;
  86 }
  87
  88 int snd_msnd_send_dsp_cmd(struct snd_msnd *dev, u8 cmd)
  89 {
  90         unsigned long flags;
  91
  92         spin_lock_irqsave(&dev->lock, flags);
  93         if (snd_msnd_wait_HC0(dev) == 0) {
  94                 outb(cmd, dev->io + HP_CVR);
  95                 spin_unlock_irqrestore(&dev->lock, flags);
  96                 return 0;
  97         }
  98         spin_unlock_irqrestore(&dev->lock, flags);
  99
 100         snd_printd(KERN_ERR LOGNAME ": Send DSP command timeout\n");
 101
 102         return -EIO;
 103 }
 104 EXPORT_SYMBOL(snd_msnd_send_dsp_cmd);
 105
 106 int snd_msnd_send_word(struct snd_msnd *dev, unsigned char high,
 107                    unsigned char mid, unsigned char low)
 108 {
 109         unsigned int io = dev->io;
 110
 111         if (snd_msnd_wait_TXDE(dev) == 0) {
 112                 outb(high, io + HP_TXH);
 113                 outb(mid, io + HP_TXM);
 114                 outb(low, io + HP_TXL);
 115                 return 0;
 116         }
 117
 118         snd_printd(KERN_ERR LOGNAME ": Send host word timeout\n");
 119
 120         return -EIO;
 121 }
 122 EXPORT_SYMBOL(snd_msnd_send_word);
 123
 124 int snd_msnd_upload_host(struct snd_msnd *dev, const u8 *bin, int len)
 125 {
 126         int i;
 127
 128         if (len % 3 != 0) {
 129                 snd_printk(KERN_ERR LOGNAME
 130                            ": Upload host data not multiple of 3!\n");
 131                 return -EINVAL;
 132         }
 133
 134         for (i = 0; i < len; i += 3)
 135                 if (snd_msnd_send_word(dev, bin[i], bin[i + 1], bin[i + 2]))
 136                         return -EIO;
 137
 138         inb(dev->io + HP_RXL);
 139         inb(dev->io + HP_CVR);
 140
 141         return 0;
 142 }
 143 EXPORT_SYMBOL(snd_msnd_upload_host);
 144
 145 int snd_msnd_enable_irq(struct snd_msnd *dev)
 146 {
 147         unsigned long flags;
 148
 149         if (dev->irq_ref++)
 150                 return 0;
 151
 152         snd_printdd(LOGNAME ": Enabling IRQ\n");
 153
 154         spin_lock_irqsave(&dev->lock, flags);
 155         if (snd_msnd_wait_TXDE(dev) == 0) {
 156                 outb(inb(dev->io + HP_ICR) | HPICR_TREQ, dev->io + HP_ICR);
 157                 if (dev->type == msndClassic)
 158                         outb(dev->irqid, dev->io + HP_IRQM);
 159
 160                 outb(inb(dev->io + HP_ICR) & ~HPICR_TREQ, dev->io + HP_ICR);
 161                 outb(inb(dev->io + HP_ICR) | HPICR_RREQ, dev->io + HP_ICR);
 162                 enable_irq(dev->irq);
 163                 snd_msnd_init_queue(dev->DSPQ, dev->dspq_data_buff,
 164                                     dev->dspq_buff_size);
 165                 spin_unlock_irqrestore(&dev->lock, flags);
 166                 return 0;
 167         }
 168         spin_unlock_irqrestore(&dev->lock, flags);
 169
 170         snd_printd(KERN_ERR LOGNAME ": Enable IRQ failed\n");
 171
 172         return -EIO;
 173 }
 174 EXPORT_SYMBOL(snd_msnd_enable_irq);
 175
 176 int snd_msnd_disable_irq(struct snd_msnd *dev)
 177 {
 178         unsigned long flags;
 179
 180         if (--dev->irq_ref > 0)
 181                 return 0;
 182
 183         if (dev->irq_ref < 0)
 184                 snd_printd(KERN_WARNING LOGNAME ": IRQ ref count is %d\n",
 185                            dev->irq_ref);
 186
 187         snd_printdd(LOGNAME ": Disabling IRQ\n");
 188
 189         spin_lock_irqsave(&dev->lock, flags);
 190         if (snd_msnd_wait_TXDE(dev) == 0) {
 191                 outb(inb(dev->io + HP_ICR) & ~HPICR_RREQ, dev->io + HP_ICR);
 192                 if (dev->type == msndClassic)
 193                         outb(HPIRQ_NONE, dev->io + HP_IRQM);
 194                 disable_irq(dev->irq);
 195                 spin_unlock_irqrestore(&dev->lock, flags);
 196                 return 0;
 197         }
 198         spin_unlock_irqrestore(&dev->lock, flags);
 199
 200         snd_printd(KERN_ERR LOGNAME ": Disable IRQ failed\n");
 201
 202         return -EIO;
 203 }
 204 EXPORT_SYMBOL(snd_msnd_disable_irq);
 205
 206 static inline long get_play_delay_jiffies(struct snd_msnd *chip, long size)
 207 {
 208         long tmp = (size * HZ * chip->play_sample_size) / 8;
 209         return tmp / (chip->play_sample_rate * chip->play_channels);
 210 }
 211
 212 static void snd_msnd_dsp_write_flush(struct snd_msnd *chip)
 213 {
 214         if (!(chip->mode & FMODE_WRITE) || !test_bit(F_WRITING, &chip->flags))
 215                 return;
 216         set_bit(F_WRITEFLUSH, &chip->flags);
 217 /*      interruptible_sleep_on_timeout(
 218                 &chip->writeflush,
 219                 get_play_delay_jiffies(&chip, chip->DAPF.len));*/
 220         clear_bit(F_WRITEFLUSH, &chip->flags);
 221         if (!signal_pending(current))
 222                 schedule_timeout_interruptible(
 223                         get_play_delay_jiffies(chip, chip->play_period_bytes));
 224         clear_bit(F_WRITING, &chip->flags);
 225 }
 226
 227 void snd_msnd_dsp_halt(struct snd_msnd *chip, struct file *file)
 228 {
 229         if ((file ? file->f_mode : chip->mode) & FMODE_READ) {
 230                 clear_bit(F_READING, &chip->flags);
 231                 snd_msnd_send_dsp_cmd(chip, HDEX_RECORD_STOP);
 232                 snd_msnd_disable_irq(chip);
 233                 if (file) {
 234                         snd_printd(KERN_INFO LOGNAME
 235                                    ": Stopping read for %p\n", file);
 236                         chip->mode &= ~FMODE_READ;
 237                 }
 238                 clear_bit(F_AUDIO_READ_INUSE, &chip->flags);
 239         }
 240         if ((file ? file->f_mode : chip->mode) & FMODE_WRITE) {
 241                 if (test_bit(F_WRITING, &chip->flags)) {
 242                         snd_msnd_dsp_write_flush(chip);
 243                         snd_msnd_send_dsp_cmd(chip, HDEX_PLAY_STOP);
 244                 }
 245                 snd_msnd_disable_irq(chip);
 246                 if (file) {
 247                         snd_printd(KERN_INFO
 248                                    LOGNAME ": Stopping write for %p\n", file);
 249                         chip->mode &= ~FMODE_WRITE;
 250                 }
 251                 clear_bit(F_AUDIO_WRITE_INUSE, &chip->flags);
 252         }
 253 }
 254 EXPORT_SYMBOL(snd_msnd_dsp_halt);
 255
 256
 257 int snd_msnd_DARQ(struct snd_msnd *chip, int bank)
 258 {
 259         int /*size, n,*/ timeout = 3;
 260         u16 wTmp;
 261         /* void *DAQD; */
 262
 263         /* Increment the tail and check for queue wrap */
 264         wTmp = readw(chip->DARQ + JQS_wTail) + PCTODSP_OFFSET(DAQDS__size);
 265         if (wTmp > readw(chip->DARQ + JQS_wSize))
 266                 wTmp = 0;
 267         while (wTmp == readw(chip->DARQ + JQS_wHead) && timeout--)
 268                 udelay(1);
 269
 270         if (chip->capturePeriods == 2) {
 271                 void *pDAQ = chip->mappedbase + DARQ_DATA_BUFF +
 272                              bank * DAQDS__size + DAQDS_wStart;
 273                 unsigned short offset = 0x3000 + chip->capturePeriodBytes;
 274
 275                 if (readw(pDAQ) != PCTODSP_BASED(0x3000))
 276                         offset = 0x3000;
 277                 writew(PCTODSP_BASED(offset), pDAQ);
 278         }
 279
 280         writew(wTmp, chip->DARQ + JQS_wTail);
 281
 282 #if 0
 283         /* Get our digital audio queue struct */
 284         DAQD = bank * DAQDS__size + chip->mappedbase + DARQ_DATA_BUFF;
 285
 286         /* Get length of data */
 287         size = readw(DAQD + DAQDS_wSize);
 288
 289         /* Read data from the head (unprotected bank 1 access okay
 290            since this is only called inside an interrupt) */
 291         outb(HPBLKSEL_1, chip->io + HP_BLKS);
 292         n = msnd_fifo_write(&chip->DARF,
 293                             (char *)(chip->base + bank * DAR_BUFF_SIZE),
 294                             size, 0);
 295         if (n <= 0) {
 296                 outb(HPBLKSEL_0, chip->io + HP_BLKS);
 297                 return n;
 298         }
 299         outb(HPBLKSEL_0, chip->io + HP_BLKS);
 300 #endif
 301
 302         return 1;
 303 }
 304 EXPORT_SYMBOL(snd_msnd_DARQ);
 305
 306 int snd_msnd_DAPQ(struct snd_msnd *chip, int start)
 307 {
 308         u16     DAPQ_tail;
 309         int     protect = start, nbanks = 0;
 310         void    *DAQD;
 311         static int play_banks_submitted;
 312         /* unsigned long flags;
 313         spin_lock_irqsave(&chip->lock, flags); not necessary */
 314
 315         DAPQ_tail = readw(chip->DAPQ + JQS_wTail);
 316         while (DAPQ_tail != readw(chip->DAPQ + JQS_wHead) || start) {
 317                 int bank_num = DAPQ_tail / PCTODSP_OFFSET(DAQDS__size);
 318
 319                 if (start) {
 320                         start = 0;
 321                         play_banks_submitted = 0;
 322                 }
 323
 324                 /* Get our digital audio queue struct */
 325                 DAQD = bank_num * DAQDS__size + chip->mappedbase +
 326                         DAPQ_DATA_BUFF;
 327
 328                 /* Write size of this bank */
 329                 writew(chip->play_period_bytes, DAQD + DAQDS_wSize);
 330                 if (play_banks_submitted < 3)
 331                         ++play_banks_submitted;
 332                 else if (chip->playPeriods == 2) {
 333                         unsigned short offset = chip->play_period_bytes;
 334
 335                         if (readw(DAQD + DAQDS_wStart) != PCTODSP_BASED(0x0))
 336                                 offset = 0;
 337
 338                         writew(PCTODSP_BASED(offset), DAQD + DAQDS_wStart);
 339                 }
 340                 ++nbanks;
 341
 342                 /* Then advance the tail */
 343                 /*
 344                 if (protect)
 345                         snd_printd(KERN_INFO "B %X %lX\n",
 346                                    bank_num, xtime.tv_usec);
 347                 */
 348
 349                 DAPQ_tail = (++bank_num % 3) * PCTODSP_OFFSET(DAQDS__size);
 350                 writew(DAPQ_tail, chip->DAPQ + JQS_wTail);
 351                 /* Tell the DSP to play the bank */
 352                 snd_msnd_send_dsp_cmd(chip, HDEX_PLAY_START);
 353                 if (protect)
 354                         if (2 == bank_num)
 355                                 break;
 356         }
 357         /*
 358         if (protect)
 359                 snd_printd(KERN_INFO "%lX\n", xtime.tv_usec);
 360         */
 361         /* spin_unlock_irqrestore(&chip->lock, flags); not necessary */
 362         return nbanks;
 363 }
 364 EXPORT_SYMBOL(snd_msnd_DAPQ);
 365
 366 static void snd_msnd_play_reset_queue(struct snd_msnd *chip,
 367                                       unsigned int pcm_periods,
 368                                       unsigned int pcm_count)
 369 {
 370         int     n;
 371         void    *pDAQ = chip->mappedbase + DAPQ_DATA_BUFF;
 372
 373         chip->last_playbank = -1;
 374         chip->playLimit = pcm_count * (pcm_periods - 1);
 375         chip->playPeriods = pcm_periods;
 376         writew(PCTODSP_OFFSET(0 * DAQDS__size), chip->DAPQ + JQS_wHead);
 377         writew(PCTODSP_OFFSET(0 * DAQDS__size), chip->DAPQ + JQS_wTail);
 378
 379         chip->play_period_bytes = pcm_count;
 380
 381         for (n = 0; n < pcm_periods; ++n, pDAQ += DAQDS__size) {
 382                 writew(PCTODSP_BASED((u32)(pcm_count * n)),
 383                         pDAQ + DAQDS_wStart);
 384                 writew(0, pDAQ + DAQDS_wSize);
 385                 writew(1, pDAQ + DAQDS_wFormat);
 386                 writew(chip->play_sample_size, pDAQ + DAQDS_wSampleSize);
 387                 writew(chip->play_channels, pDAQ + DAQDS_wChannels);
 388                 writew(chip->play_sample_rate, pDAQ + DAQDS_wSampleRate);
 389                 writew(HIMT_PLAY_DONE * 0x100 + n, pDAQ + DAQDS_wIntMsg);
 390                 writew(n, pDAQ + DAQDS_wFlags);
 391         }
 392 }
 393
 394 static void snd_msnd_capture_reset_queue(struct snd_msnd *chip,
 395                                          unsigned int pcm_periods,
 396                                          unsigned int pcm_count)
 397 {
 398         int             n;
 399         void            *pDAQ;
 400         /* unsigned long        flags; */
 401
 402         /* snd_msnd_init_queue(chip->DARQ, DARQ_DATA_BUFF, DARQ_BUFF_SIZE); */
 403
 404         chip->last_recbank = 2;
 405         chip->captureLimit = pcm_count * (pcm_periods - 1);
 406         chip->capturePeriods = pcm_periods;
 407         writew(PCTODSP_OFFSET(0 * DAQDS__size), chip->DARQ + JQS_wHead);
 408         writew(PCTODSP_OFFSET(chip->last_recbank * DAQDS__size),
 409                 chip->DARQ + JQS_wTail);
 410
 411 #if 0 /* Critical section: bank 1 access. this is how the OSS driver does it:*/
 412         spin_lock_irqsave(&chip->lock, flags);
 413         outb(HPBLKSEL_1, chip->io + HP_BLKS);
 414         memset_io(chip->mappedbase, 0, DAR_BUFF_SIZE * 3);
 415         outb(HPBLKSEL_0, chip->io + HP_BLKS);
 416         spin_unlock_irqrestore(&chip->lock, flags);
 417 #endif
 418
 419         chip->capturePeriodBytes = pcm_count;
 420         snd_printdd("snd_msnd_capture_reset_queue() %i\n", pcm_count);
 421
 422         pDAQ = chip->mappedbase + DARQ_DATA_BUFF;
 423
 424         for (n = 0; n < pcm_periods; ++n, pDAQ += DAQDS__size) {
 425                 u32 tmp = pcm_count * n;
 426
 427                 writew(PCTODSP_BASED(tmp + 0x3000), pDAQ + DAQDS_wStart);
 428                 writew(pcm_count, pDAQ + DAQDS_wSize);
 429                 writew(1, pDAQ + DAQDS_wFormat);
 430                 writew(chip->capture_sample_size, pDAQ + DAQDS_wSampleSize);
 431                 writew(chip->capture_channels, pDAQ + DAQDS_wChannels);
 432                 writew(chip->capture_sample_rate, pDAQ + DAQDS_wSampleRate);
 433                 writew(HIMT_RECORD_DONE * 0x100 + n, pDAQ + DAQDS_wIntMsg);
 434                 writew(n, pDAQ + DAQDS_wFlags);
 435         }
 436 }
 437
 438 static struct snd_pcm_hardware snd_msnd_playback = {
 439         .info =                 SNDRV_PCM_INFO_MMAP |
 440                                 SNDRV_PCM_INFO_INTERLEAVED |
 441                                 SNDRV_PCM_INFO_MMAP_VALID |
 442                                 SNDRV_PCM_INFO_BATCH,
 443         .formats =              SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE,
 444         .rates =                SNDRV_PCM_RATE_8000_48000,
 445         .rate_min =             8000,
 446         .rate_max =             48000,
 447         .channels_min =         1,
 448         .channels_max =         2,
 449         .buffer_bytes_max =     0x3000,
 450         .period_bytes_min =     0x40,
 451         .period_bytes_max =     0x1800,
 452         .periods_min =          2,
 453         .periods_max =          3,
 454         .fifo_size =            0,
 455 };
 456
 457 static struct snd_pcm_hardware snd_msnd_capture = {
 458         .info =                 SNDRV_PCM_INFO_MMAP |
 459                                 SNDRV_PCM_INFO_INTERLEAVED |
 460                                 SNDRV_PCM_INFO_MMAP_VALID |
 461                                 SNDRV_PCM_INFO_BATCH,
 462         .formats =              SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE,
 463         .rates =                SNDRV_PCM_RATE_8000_48000,
 464         .rate_min =             8000,
 465         .rate_max =             48000,
 466         .channels_min =         1,
 467         .channels_max =         2,
 468         .buffer_bytes_max =     0x3000,
 469         .period_bytes_min =     0x40,
 470         .period_bytes_max =     0x1800,
 471         .periods_min =          2,
 472         .periods_max =          3,
 473         .fifo_size =            0,
 474 };
 475
 476
 477 static int snd_msnd_playback_open(struct snd_pcm_substream *substream)
 478 {
 479         struct snd_pcm_runtime *runtime = substream->runtime;
 480         struct snd_msnd *chip = snd_pcm_substream_chip(substream);
 481
 482         set_bit(F_AUDIO_WRITE_INUSE, &chip->flags);
 483         clear_bit(F_WRITING, &chip->flags);
 484         snd_msnd_enable_irq(chip);
 485
 486         runtime->dma_area = chip->mappedbase;
 487         runtime->dma_bytes = 0x3000;
 488
 489         chip->playback_substream = substream;
 490         runtime->hw = snd_msnd_playback;
 491         return 0;
 492 }
 493
 494 static int snd_msnd_playback_close(struct snd_pcm_substream *substream)
 495 {
 496         struct snd_msnd *chip = snd_pcm_substream_chip(substream);
 497
 498         snd_msnd_disable_irq(chip);
 499         clear_bit(F_AUDIO_WRITE_INUSE, &chip->flags);
 500         return 0;
 501 }
 502
 503
 504 static int snd_msnd_playback_hw_params(struct snd_pcm_substream *substream,
 505                                         struct snd_pcm_hw_params *params)
 506 {
 507         int     i;
 508         struct snd_msnd *chip = snd_pcm_substream_chip(substream);
 509         void    *pDAQ = chip->mappedbase + DAPQ_DATA_BUFF;
 510
 511         chip->play_sample_size = snd_pcm_format_width(params_format(params));
 512         chip->play_channels = params_channels(params);
 513         chip->play_sample_rate = params_rate(params);
 514
 515         for (i = 0; i < 3; ++i, pDAQ += DAQDS__size) {
 516                 writew(chip->play_sample_size, pDAQ + DAQDS_wSampleSize);
 517                 writew(chip->play_channels, pDAQ + DAQDS_wChannels);
 518                 writew(chip->play_sample_rate, pDAQ + DAQDS_wSampleRate);
 519         }
 520         /* dont do this here:
 521          * snd_msnd_calibrate_adc(chip->play_sample_rate);
 522          */
 523
 524         return 0;
 525 }
 526
 527 static int snd_msnd_playback_prepare(struct snd_pcm_substream *substream)
 528 {
 529         struct snd_msnd *chip = snd_pcm_substream_chip(substream);
 530         unsigned int pcm_size = snd_pcm_lib_buffer_bytes(substream);
 531         unsigned int pcm_count = snd_pcm_lib_period_bytes(substream);
 532         unsigned int pcm_periods = pcm_size / pcm_count;
 533
 534         snd_msnd_play_reset_queue(chip, pcm_periods, pcm_count);
 535         chip->playDMAPos = 0;
 536         return 0;
 537 }
 538
 539 static int snd_msnd_playback_trigger(struct snd_pcm_substream *substream,
 540                                      int cmd)
 541 {
 542         struct snd_msnd *chip = snd_pcm_substream_chip(substream);
 543         int     result = 0;
 544
 545         if (cmd == SNDRV_PCM_TRIGGER_START) {
 546                 snd_printdd("snd_msnd_playback_trigger(START)\n");
 547                 chip->banksPlayed = 0;
 548                 set_bit(F_WRITING, &chip->flags);
 549                 snd_msnd_DAPQ(chip, 1);
 550         } else if (cmd == SNDRV_PCM_TRIGGER_STOP) {
 551                 snd_printdd("snd_msnd_playback_trigger(STop)\n");
 552                 /* interrupt diagnostic, comment this out later */
 553                 clear_bit(F_WRITING, &chip->flags);
 554                 snd_msnd_send_dsp_cmd(chip, HDEX_PLAY_STOP);
 555         } else {
 556                 snd_printd(KERN_ERR "snd_msnd_playback_trigger(?????)\n");
 557                 result = -EINVAL;
 558         }
 559
 560         snd_printdd("snd_msnd_playback_trigger() ENDE\n");
 561         return result;
 562 }
 563
 564 static snd_pcm_uframes_t
 565 snd_msnd_playback_pointer(struct snd_pcm_substream *substream)
 566 {
 567         struct snd_msnd *chip = snd_pcm_substream_chip(substream);
 568
 569         return bytes_to_frames(substream->runtime, chip->playDMAPos);
 570 }
 571
 572
 573 static struct snd_pcm_ops snd_msnd_playback_ops = {
 574         .open =         snd_msnd_playback_open,
 575         .close =        snd_msnd_playback_close,
 576         .ioctl =        snd_pcm_lib_ioctl,
 577         .hw_params =    snd_msnd_playback_hw_params,
 578         .prepare =      snd_msnd_playback_prepare,
 579         .trigger =      snd_msnd_playback_trigger,
 580         .pointer =      snd_msnd_playback_pointer,
 581 };
 582
 583 static int snd_msnd_capture_open(struct snd_pcm_substream *substream)
 584 {
 585         struct snd_pcm_runtime *runtime = substream->runtime;
 586         struct snd_msnd *chip = snd_pcm_substream_chip(substream);
 587
 588         set_bit(F_AUDIO_READ_INUSE, &chip->flags);
 589         snd_msnd_enable_irq(chip);
 590         runtime->dma_area = chip->mappedbase + 0x3000;
 591         runtime->dma_bytes = 0x3000;
 592         memset(runtime->dma_area, 0, runtime->dma_bytes);
 593         chip->capture_substream = substream;
 594         runtime->hw = snd_msnd_capture;
 595         return 0;
 596 }
 597
 598 static int snd_msnd_capture_close(struct snd_pcm_substream *substream)
 599 {
 600         struct snd_msnd *chip = snd_pcm_substream_chip(substream);
 601
 602         snd_msnd_disable_irq(chip);
 603         clear_bit(F_AUDIO_READ_INUSE, &chip->flags);
 604         return 0;
 605 }
 606
 607 static int snd_msnd_capture_prepare(struct snd_pcm_substream *substream)
 608 {
 609         struct snd_msnd *chip = snd_pcm_substream_chip(substream);
 610         unsigned int pcm_size = snd_pcm_lib_buffer_bytes(substream);
 611         unsigned int pcm_count = snd_pcm_lib_period_bytes(substream);
 612         unsigned int pcm_periods = pcm_size / pcm_count;
 613
 614         snd_msnd_capture_reset_queue(chip, pcm_periods, pcm_count);
 615         chip->captureDMAPos = 0;
 616         return 0;
 617 }
 618
 619 static int snd_msnd_capture_trigger(struct snd_pcm_substream *substream,
 620                                     int cmd)
 621 {
 622         struct snd_msnd *chip = snd_pcm_substream_chip(substream);
 623
 624         if (cmd == SNDRV_PCM_TRIGGER_START) {
 625                 chip->last_recbank = -1;
 626                 set_bit(F_READING, &chip->flags);
 627                 if (snd_msnd_send_dsp_cmd(chip, HDEX_RECORD_START) == 0)
 628                         return 0;
 629
 630                 clear_bit(F_READING, &chip->flags);
 631         } else if (cmd == SNDRV_PCM_TRIGGER_STOP) {
 632                 clear_bit(F_READING, &chip->flags);
 633                 snd_msnd_send_dsp_cmd(chip, HDEX_RECORD_STOP);
 634                 return 0;
 635         }
 636         return -EINVAL;
 637 }
 638
 639
 640 static snd_pcm_uframes_t
 641 snd_msnd_capture_pointer(struct snd_pcm_substream *substream)
 642 {
 643         struct snd_pcm_runtime *runtime = substream->runtime;
 644         struct snd_msnd *chip = snd_pcm_substream_chip(substream);
 645
 646         return bytes_to_frames(runtime, chip->captureDMAPos);
 647 }
 648
 649
 650 static int snd_msnd_capture_hw_params(struct snd_pcm_substream *substream,
 651                                         struct snd_pcm_hw_params *params)
 652 {
 653         int             i;
 654         struct snd_msnd *chip = snd_pcm_substream_chip(substream);
 655         void            *pDAQ = chip->mappedbase + DARQ_DATA_BUFF;
 656
 657         chip->capture_sample_size = snd_pcm_format_width(params_format(params));
 658         chip->capture_channels = params_channels(params);
 659         chip->capture_sample_rate = params_rate(params);
 660
 661         for (i = 0; i < 3; ++i, pDAQ += DAQDS__size) {
 662                 writew(chip->capture_sample_size, pDAQ + DAQDS_wSampleSize);
 663                 writew(chip->capture_channels, pDAQ + DAQDS_wChannels);
 664                 writew(chip->capture_sample_rate, pDAQ + DAQDS_wSampleRate);
 665         }
 666         return 0;
 667 }
 668
 669
 670 static struct snd_pcm_ops snd_msnd_capture_ops = {
 671         .open =         snd_msnd_capture_open,
 672         .close =        snd_msnd_capture_close,
 673         .ioctl =        snd_pcm_lib_ioctl,
 674         .hw_params =    snd_msnd_capture_hw_params,
 675         .prepare =      snd_msnd_capture_prepare,
 676         .trigger =      snd_msnd_capture_trigger,
 677         .pointer =      snd_msnd_capture_pointer,
 678 };
 679
 680
 681 int snd_msnd_pcm(struct snd_card *card, int device,
 682                         struct snd_pcm **rpcm)
 683 {
 684         struct snd_msnd *chip = card->private_data;
 685         struct snd_pcm  *pcm;
 686         int err;
 687
 688         err = snd_pcm_new(card, "MSNDPINNACLE", device, 1, 1, &pcm);
 689         if (err < 0)
 690                 return err;
 691
 692         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_msnd_playback_ops);
 693         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_msnd_capture_ops);
 694
 695         pcm->private_data = chip;
 696         strcpy(pcm->name, "Hurricane");
 697
 698
 699         if (rpcm)
 700                 *rpcm = pcm;
 701         return 0;
 702 }
 703 EXPORT_SYMBOL(snd_msnd_pcm);
 704
 705 MODULE_DESCRIPTION("Common routines for Turtle Beach Multisound drivers");
 706 MODULE_LICENSE("GPL");
 707