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