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