2 **********************************************************************
3 * audio.c -- /dev/dsp interface for emu10k1 driver
4 * Copyright 1999, 2000 Creative Labs, Inc.
6 **********************************************************************
8 * Date Author Summary of changes
9 * ---- ------ ------------------
10 * October 20, 1999 Bertrand Lee base code release
11 * November 2, 1999 Alan Cox cleaned up types/leaks
13 **********************************************************************
15 * This program is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU General Public License as
17 * published by the Free Software Foundation; either version 2 of
18 * the License, or (at your option) any later version.
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
25 * You should have received a copy of the GNU General Public
26 * License along with this program; if not, write to the Free
27 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
30 **********************************************************************
33 #include <linux/module.h>
34 #include <linux/poll.h>
35 #include <linux/slab.h>
36 #include <linux/bitops.h>
38 #include <linux/sched.h>
40 #include <linux/smp_lock.h>
50 static void calculate_ofrag(struct woinst *);
51 static void calculate_ifrag(struct wiinst *);
53 static void emu10k1_waveout_bh(unsigned long refdata);
54 static void emu10k1_wavein_bh(unsigned long refdata);
56 /* Audio file operations */
57 static ssize_t emu10k1_audio_read(struct file *file, char __user *buffer, size_t count, loff_t * ppos)
59 struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
60 struct wiinst *wiinst = wave_dev->wiinst;
64 DPD(3, "emu10k1_audio_read(), buffer=%p, count=%d\n", buffer, (u32) count);
66 if (!access_ok(VERIFY_WRITE, buffer, count))
69 spin_lock_irqsave(&wiinst->lock, flags);
71 if (wiinst->mmapped) {
72 spin_unlock_irqrestore(&wiinst->lock, flags);
76 if (wiinst->state == WAVE_STATE_CLOSED) {
77 calculate_ifrag(wiinst);
79 while (emu10k1_wavein_open(wave_dev) < 0) {
80 spin_unlock_irqrestore(&wiinst->lock, flags);
82 if (file->f_flags & O_NONBLOCK)
85 interruptible_sleep_on(&wave_dev->card->open_wait);
87 if (signal_pending(current))
90 spin_lock_irqsave(&wiinst->lock, flags);
94 spin_unlock_irqrestore(&wiinst->lock, flags);
99 spin_lock_irqsave(&wiinst->lock, flags);
101 if (!(wiinst->state & WAVE_STATE_STARTED)
102 && (wave_dev->enablebits & PCM_ENABLE_INPUT))
103 emu10k1_wavein_start(wave_dev);
105 emu10k1_wavein_update(wave_dev->card, wiinst);
106 emu10k1_wavein_getxfersize(wiinst, &bytestocopy);
108 spin_unlock_irqrestore(&wiinst->lock, flags);
110 DPD(3, "bytestocopy --> %d\n", bytestocopy);
112 if ((bytestocopy >= wiinst->buffer.fragment_size)
113 || (bytestocopy >= count)) {
114 bytestocopy = min_t(u32, bytestocopy, count);
116 emu10k1_wavein_xferdata(wiinst, (u8 __user *)buffer, &bytestocopy);
118 count -= bytestocopy;
119 buffer += bytestocopy;
124 if ((file->f_flags & O_NONBLOCK)
125 || (!(wave_dev->enablebits & PCM_ENABLE_INPUT)))
126 return (ret ? ret : -EAGAIN);
128 interruptible_sleep_on(&wiinst->wait_queue);
130 if (signal_pending(current))
131 return (ret ? ret : -ERESTARTSYS);
136 DPD(3, "bytes copied -> %d\n", (u32) ret);
141 static ssize_t emu10k1_audio_write(struct file *file, const char __user *buffer, size_t count, loff_t * ppos)
143 struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
144 struct woinst *woinst = wave_dev->woinst;
148 DPD(3, "emu10k1_audio_write(), buffer=%p, count=%d\n", buffer, (u32) count);
150 if (!access_ok(VERIFY_READ, buffer, count))
153 spin_lock_irqsave(&woinst->lock, flags);
155 if (woinst->mmapped) {
156 spin_unlock_irqrestore(&woinst->lock, flags);
159 // This is for emu10k1 revs less than 7, we need to go through tram
160 if (woinst->format.passthrough == 1) {
163 woinst->buffer.ossfragshift = PT_BLOCKSIZE_LOG2;
164 woinst->buffer.numfrags = PT_BLOCKCOUNT;
165 calculate_ofrag(woinst);
167 r = emu10k1_pt_write(file, buffer, count);
168 spin_unlock_irqrestore(&woinst->lock, flags);
172 if (woinst->state == WAVE_STATE_CLOSED) {
173 calculate_ofrag(woinst);
175 while (emu10k1_waveout_open(wave_dev) < 0) {
176 spin_unlock_irqrestore(&woinst->lock, flags);
178 if (file->f_flags & O_NONBLOCK)
181 interruptible_sleep_on(&wave_dev->card->open_wait);
183 if (signal_pending(current))
186 spin_lock_irqsave(&woinst->lock, flags);
190 spin_unlock_irqrestore(&woinst->lock, flags);
193 if (count % woinst->format.bytespersample)
196 count /= woinst->num_voices;
201 spin_lock_irqsave(&woinst->lock, flags);
202 emu10k1_waveout_update(woinst);
203 emu10k1_waveout_getxfersize(woinst, &bytestocopy);
204 spin_unlock_irqrestore(&woinst->lock, flags);
206 DPD(3, "bytestocopy --> %d\n", bytestocopy);
208 if ((bytestocopy >= woinst->buffer.fragment_size)
209 || (bytestocopy >= count)) {
211 bytestocopy = min_t(u32, bytestocopy, count);
213 emu10k1_waveout_xferdata(woinst, (u8 __user *) buffer, &bytestocopy);
215 count -= bytestocopy;
216 buffer += bytestocopy * woinst->num_voices;
217 ret += bytestocopy * woinst->num_voices;
219 spin_lock_irqsave(&woinst->lock, flags);
220 woinst->total_copied += bytestocopy;
222 if (!(woinst->state & WAVE_STATE_STARTED)
223 && (wave_dev->enablebits & PCM_ENABLE_OUTPUT)
224 && (woinst->total_copied >= woinst->buffer.fragment_size))
225 emu10k1_waveout_start(wave_dev);
227 spin_unlock_irqrestore(&woinst->lock, flags);
231 if ((file->f_flags & O_NONBLOCK)
232 || (!(wave_dev->enablebits & PCM_ENABLE_OUTPUT)))
233 return (ret ? ret : -EAGAIN);
235 interruptible_sleep_on(&woinst->wait_queue);
237 if (signal_pending(current))
238 return (ret ? ret : -ERESTARTSYS);
242 DPD(3, "bytes copied -> %d\n", (u32) ret);
247 static int emu10k1_audio_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
249 struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
250 struct woinst *woinst = NULL;
251 struct wiinst *wiinst = NULL;
255 int __user *p = (int __user *)arg;
257 DPF(4, "emu10k1_audio_ioctl()\n");
259 if (file->f_mode & FMODE_WRITE)
260 woinst = wave_dev->woinst;
262 if (file->f_mode & FMODE_READ)
263 wiinst = wave_dev->wiinst;
267 DPF(2, "OSS_GETVERSION:\n");
268 return put_user(SOUND_VERSION, p);
270 case SNDCTL_DSP_RESET:
271 DPF(2, "SNDCTL_DSP_RESET:\n");
272 wave_dev->enablebits = PCM_ENABLE_OUTPUT | PCM_ENABLE_INPUT;
274 if (file->f_mode & FMODE_WRITE) {
275 spin_lock_irqsave(&woinst->lock, flags);
277 if (woinst->state & WAVE_STATE_OPEN) {
278 emu10k1_waveout_close(wave_dev);
282 woinst->total_copied = 0;
283 woinst->total_played = 0;
286 spin_unlock_irqrestore(&woinst->lock, flags);
289 if (file->f_mode & FMODE_READ) {
290 spin_lock_irqsave(&wiinst->lock, flags);
292 if (wiinst->state & WAVE_STATE_OPEN) {
293 emu10k1_wavein_close(wave_dev);
297 wiinst->total_recorded = 0;
299 spin_unlock_irqrestore(&wiinst->lock, flags);
304 case SNDCTL_DSP_SYNC:
305 DPF(2, "SNDCTL_DSP_SYNC:\n");
307 if (file->f_mode & FMODE_WRITE) {
309 spin_lock_irqsave(&woinst->lock, flags);
311 if (woinst->state & WAVE_STATE_OPEN) {
313 if (woinst->state & WAVE_STATE_STARTED)
314 while ((woinst->total_played < woinst->total_copied)
315 && !signal_pending(current)) {
316 spin_unlock_irqrestore(&woinst->lock, flags);
317 interruptible_sleep_on(&woinst->wait_queue);
318 spin_lock_irqsave(&woinst->lock, flags);
320 emu10k1_waveout_close(wave_dev);
324 woinst->total_copied = 0;
325 woinst->total_played = 0;
328 spin_unlock_irqrestore(&woinst->lock, flags);
331 if (file->f_mode & FMODE_READ) {
332 spin_lock_irqsave(&wiinst->lock, flags);
334 if (wiinst->state & WAVE_STATE_OPEN) {
335 emu10k1_wavein_close(wave_dev);
339 wiinst->total_recorded = 0;
341 spin_unlock_irqrestore(&wiinst->lock, flags);
346 case SNDCTL_DSP_SETDUPLEX:
347 DPF(2, "SNDCTL_DSP_SETDUPLEX:\n");
350 case SNDCTL_DSP_GETCAPS:
351 DPF(2, "SNDCTL_DSP_GETCAPS:\n");
352 return put_user(DSP_CAP_DUPLEX | DSP_CAP_REALTIME |
353 DSP_CAP_TRIGGER | DSP_CAP_MMAP |
354 DSP_CAP_COPROC| DSP_CAP_MULTI, p);
355 case SNDCTL_DSP_SPEED:
356 DPF(2, "SNDCTL_DSP_SPEED:\n");
358 if (get_user(val, p))
361 DPD(2, "val is %d\n", val);
364 if (file->f_mode & FMODE_READ) {
365 struct wave_format format;
367 spin_lock_irqsave(&wiinst->lock, flags);
369 format = wiinst->format;
370 format.samplingrate = val;
372 if (emu10k1_wavein_setformat(wave_dev, &format) < 0) {
373 spin_unlock_irqrestore(&wiinst->lock, flags);
377 val = wiinst->format.samplingrate;
379 spin_unlock_irqrestore(&wiinst->lock, flags);
381 DPD(2, "set recording sampling rate -> %d\n", val);
384 if (file->f_mode & FMODE_WRITE) {
385 struct wave_format format;
387 spin_lock_irqsave(&woinst->lock, flags);
389 format = woinst->format;
390 format.samplingrate = val;
392 if (emu10k1_waveout_setformat(wave_dev, &format) < 0) {
393 spin_unlock_irqrestore(&woinst->lock, flags);
397 val = woinst->format.samplingrate;
399 spin_unlock_irqrestore(&woinst->lock, flags);
401 DPD(2, "set playback sampling rate -> %d\n", val);
404 return put_user(val, p);
406 if (file->f_mode & FMODE_READ)
407 val = wiinst->format.samplingrate;
408 else if (file->f_mode & FMODE_WRITE)
409 val = woinst->format.samplingrate;
411 return put_user(val, p);
415 case SNDCTL_DSP_STEREO:
416 DPF(2, "SNDCTL_DSP_STEREO:\n");
418 if (get_user(val, p))
421 DPD(2, " val is %d\n", val);
423 if (file->f_mode & FMODE_READ) {
424 struct wave_format format;
426 spin_lock_irqsave(&wiinst->lock, flags);
428 format = wiinst->format;
429 format.channels = val ? 2 : 1;
431 if (emu10k1_wavein_setformat(wave_dev, &format) < 0) {
432 spin_unlock_irqrestore(&wiinst->lock, flags);
436 val = wiinst->format.channels - 1;
438 spin_unlock_irqrestore(&wiinst->lock, flags);
439 DPD(2, "set recording stereo -> %d\n", val);
442 if (file->f_mode & FMODE_WRITE) {
443 struct wave_format format;
445 spin_lock_irqsave(&woinst->lock, flags);
447 format = woinst->format;
448 format.channels = val ? 2 : 1;
450 if (emu10k1_waveout_setformat(wave_dev, &format) < 0) {
451 spin_unlock_irqrestore(&woinst->lock, flags);
455 val = woinst->format.channels - 1;
457 spin_unlock_irqrestore(&woinst->lock, flags);
459 DPD(2, "set playback stereo -> %d\n", val);
462 return put_user(val, p);
466 case SNDCTL_DSP_CHANNELS:
467 DPF(2, "SNDCTL_DSP_CHANNELS:\n");
469 if (get_user(val, p))
472 DPD(2, " val is %d\n", val);
475 if (file->f_mode & FMODE_READ) {
476 struct wave_format format;
478 spin_lock_irqsave(&wiinst->lock, flags);
480 format = wiinst->format;
481 format.channels = val;
483 if (emu10k1_wavein_setformat(wave_dev, &format) < 0) {
484 spin_unlock_irqrestore(&wiinst->lock, flags);
487 val = wiinst->format.channels;
489 spin_unlock_irqrestore(&wiinst->lock, flags);
490 DPD(2, "set recording number of channels -> %d\n", val);
493 if (file->f_mode & FMODE_WRITE) {
494 struct wave_format format;
496 spin_lock_irqsave(&woinst->lock, flags);
498 format = woinst->format;
499 format.channels = val;
501 if (emu10k1_waveout_setformat(wave_dev, &format) < 0) {
502 spin_unlock_irqrestore(&woinst->lock, flags);
506 val = woinst->format.channels;
508 spin_unlock_irqrestore(&woinst->lock, flags);
509 DPD(2, "set playback number of channels -> %d\n", val);
512 return put_user(val, p);
514 if (file->f_mode & FMODE_READ)
515 val = wiinst->format.channels;
516 else if (file->f_mode & FMODE_WRITE)
517 val = woinst->format.channels;
519 return put_user(val, p);
523 case SNDCTL_DSP_GETFMTS:
524 DPF(2, "SNDCTL_DSP_GETFMTS:\n");
526 if (file->f_mode & FMODE_READ)
528 else if (file->f_mode & FMODE_WRITE) {
529 val = AFMT_S16_LE | AFMT_U8;
530 if (emu10k1_find_control_gpr(&wave_dev->card->mgr,
531 wave_dev->card->pt.patch_name,
532 wave_dev->card->pt.enable_gpr_name) >= 0)
535 return put_user(val, p);
537 case SNDCTL_DSP_SETFMT: /* Same as SNDCTL_DSP_SAMPLESIZE */
538 DPF(2, "SNDCTL_DSP_SETFMT:\n");
540 if (get_user(val, p))
543 DPD(2, " val is %d\n", val);
545 if (val != AFMT_QUERY) {
546 if (file->f_mode & FMODE_READ) {
547 struct wave_format format;
549 spin_lock_irqsave(&wiinst->lock, flags);
551 format = wiinst->format;
554 if (emu10k1_wavein_setformat(wave_dev, &format) < 0) {
555 spin_unlock_irqrestore(&wiinst->lock, flags);
559 val = wiinst->format.id;
561 spin_unlock_irqrestore(&wiinst->lock, flags);
562 DPD(2, "set recording format -> %d\n", val);
565 if (file->f_mode & FMODE_WRITE) {
566 struct wave_format format;
568 spin_lock_irqsave(&woinst->lock, flags);
570 format = woinst->format;
573 if (emu10k1_waveout_setformat(wave_dev, &format) < 0) {
574 spin_unlock_irqrestore(&woinst->lock, flags);
578 val = woinst->format.id;
580 spin_unlock_irqrestore(&woinst->lock, flags);
581 DPD(2, "set playback format -> %d\n", val);
584 return put_user(val, p);
586 if (file->f_mode & FMODE_READ)
587 val = wiinst->format.id;
588 else if (file->f_mode & FMODE_WRITE)
589 val = woinst->format.id;
591 return put_user(val, p);
595 case SOUND_PCM_READ_BITS:
597 if (file->f_mode & FMODE_READ)
598 val = wiinst->format.bitsperchannel;
599 else if (file->f_mode & FMODE_WRITE)
600 val = woinst->format.bitsperchannel;
602 return put_user(val, p);
604 case SOUND_PCM_READ_RATE:
606 if (file->f_mode & FMODE_READ)
607 val = wiinst->format.samplingrate;
608 else if (file->f_mode & FMODE_WRITE)
609 val = woinst->format.samplingrate;
611 return put_user(val, p);
613 case SOUND_PCM_READ_CHANNELS:
615 if (file->f_mode & FMODE_READ)
616 val = wiinst->format.channels;
617 else if (file->f_mode & FMODE_WRITE)
618 val = woinst->format.channels;
620 return put_user(val, p);
622 case SOUND_PCM_WRITE_FILTER:
623 DPF(2, "SOUND_PCM_WRITE_FILTER: not implemented\n");
626 case SOUND_PCM_READ_FILTER:
627 DPF(2, "SOUND_PCM_READ_FILTER: not implemented\n");
630 case SNDCTL_DSP_SETSYNCRO:
631 DPF(2, "SNDCTL_DSP_SETSYNCRO: not implemented\n");
634 case SNDCTL_DSP_GETTRIGGER:
635 DPF(2, "SNDCTL_DSP_GETTRIGGER:\n");
637 if (file->f_mode & FMODE_WRITE && (wave_dev->enablebits & PCM_ENABLE_OUTPUT))
638 val |= PCM_ENABLE_OUTPUT;
640 if (file->f_mode & FMODE_READ && (wave_dev->enablebits & PCM_ENABLE_INPUT))
641 val |= PCM_ENABLE_INPUT;
643 return put_user(val, p);
645 case SNDCTL_DSP_SETTRIGGER:
646 DPF(2, "SNDCTL_DSP_SETTRIGGER:\n");
648 if (get_user(val, p))
651 if (file->f_mode & FMODE_WRITE) {
652 spin_lock_irqsave(&woinst->lock, flags);
654 if (val & PCM_ENABLE_OUTPUT) {
655 wave_dev->enablebits |= PCM_ENABLE_OUTPUT;
656 if (woinst->state & WAVE_STATE_OPEN)
657 emu10k1_waveout_start(wave_dev);
659 wave_dev->enablebits &= ~PCM_ENABLE_OUTPUT;
660 if (woinst->state & WAVE_STATE_STARTED)
661 emu10k1_waveout_stop(wave_dev);
664 spin_unlock_irqrestore(&woinst->lock, flags);
667 if (file->f_mode & FMODE_READ) {
668 spin_lock_irqsave(&wiinst->lock, flags);
670 if (val & PCM_ENABLE_INPUT) {
671 wave_dev->enablebits |= PCM_ENABLE_INPUT;
672 if (wiinst->state & WAVE_STATE_OPEN)
673 emu10k1_wavein_start(wave_dev);
675 wave_dev->enablebits &= ~PCM_ENABLE_INPUT;
676 if (wiinst->state & WAVE_STATE_STARTED)
677 emu10k1_wavein_stop(wave_dev);
680 spin_unlock_irqrestore(&wiinst->lock, flags);
684 case SNDCTL_DSP_GETOSPACE:
688 DPF(4, "SNDCTL_DSP_GETOSPACE:\n");
690 if (!(file->f_mode & FMODE_WRITE))
693 spin_lock_irqsave(&woinst->lock, flags);
695 if (woinst->state & WAVE_STATE_OPEN) {
696 emu10k1_waveout_update(woinst);
697 emu10k1_waveout_getxfersize(woinst, &bytestocopy);
698 info.bytes = bytestocopy;
700 calculate_ofrag(woinst);
701 info.bytes = woinst->buffer.size;
703 spin_unlock_irqrestore(&woinst->lock, flags);
705 info.bytes *= woinst->num_voices;
706 info.fragsize = woinst->buffer.fragment_size * woinst->num_voices;
707 info.fragstotal = woinst->buffer.numfrags * woinst->num_voices;
708 info.fragments = info.bytes / info.fragsize;
710 if (copy_to_user(p, &info, sizeof(info)))
715 case SNDCTL_DSP_GETISPACE:
719 DPF(4, "SNDCTL_DSP_GETISPACE:\n");
721 if (!(file->f_mode & FMODE_READ))
724 spin_lock_irqsave(&wiinst->lock, flags);
725 if (wiinst->state & WAVE_STATE_OPEN) {
726 emu10k1_wavein_update(wave_dev->card, wiinst);
727 emu10k1_wavein_getxfersize(wiinst, &bytestocopy);
728 info.bytes = bytestocopy;
730 calculate_ifrag(wiinst);
733 spin_unlock_irqrestore(&wiinst->lock, flags);
735 info.fragstotal = wiinst->buffer.numfrags;
736 info.fragments = info.bytes / wiinst->buffer.fragment_size;
737 info.fragsize = wiinst->buffer.fragment_size;
739 if (copy_to_user(p, &info, sizeof(info)))
744 case SNDCTL_DSP_NONBLOCK:
745 DPF(2, "SNDCTL_DSP_NONBLOCK:\n");
747 file->f_flags |= O_NONBLOCK;
750 case SNDCTL_DSP_GETODELAY:
751 DPF(4, "SNDCTL_DSP_GETODELAY:\n");
753 if (!(file->f_mode & FMODE_WRITE))
756 spin_lock_irqsave(&woinst->lock, flags);
757 if (woinst->state & WAVE_STATE_OPEN) {
758 emu10k1_waveout_update(woinst);
759 emu10k1_waveout_getxfersize(woinst, &bytestocopy);
760 val = woinst->buffer.size - bytestocopy;
764 val *= woinst->num_voices;
765 spin_unlock_irqrestore(&woinst->lock, flags);
767 return put_user(val, p);
769 case SNDCTL_DSP_GETIPTR:
773 DPF(4, "SNDCTL_DSP_GETIPTR: \n");
775 if (!(file->f_mode & FMODE_READ))
778 spin_lock_irqsave(&wiinst->lock, flags);
780 if (wiinst->state & WAVE_STATE_OPEN) {
781 emu10k1_wavein_update(wave_dev->card, wiinst);
782 cinfo.ptr = wiinst->buffer.hw_pos;
783 cinfo.bytes = cinfo.ptr + wiinst->total_recorded - wiinst->total_recorded % wiinst->buffer.size;
784 cinfo.blocks = cinfo.bytes / wiinst->buffer.fragment_size - wiinst->blocks;
785 wiinst->blocks = cinfo.bytes / wiinst->buffer.fragment_size;
793 wiinst->buffer.bytestocopy %= wiinst->buffer.fragment_size;
795 spin_unlock_irqrestore(&wiinst->lock, flags);
797 if (copy_to_user(p, &cinfo, sizeof(cinfo)))
802 case SNDCTL_DSP_GETOPTR:
806 DPF(4, "SNDCTL_DSP_GETOPTR:\n");
808 if (!(file->f_mode & FMODE_WRITE))
811 spin_lock_irqsave(&woinst->lock, flags);
813 if (woinst->state & WAVE_STATE_OPEN ||
814 ((woinst->format.passthrough == 1) && wave_dev->card->pt.state)) {
817 if (woinst->format.passthrough == 1) {
818 emu10k1_pt_waveout_update(wave_dev);
819 cinfo.bytes = woinst->total_played;
821 emu10k1_waveout_update(woinst);
822 cinfo.bytes = woinst->total_played;
825 cinfo.ptr = woinst->buffer.hw_pos;
826 num_fragments = cinfo.bytes / woinst->buffer.fragment_size;
827 cinfo.blocks = num_fragments - woinst->blocks;
828 woinst->blocks = num_fragments;
830 cinfo.bytes *= woinst->num_voices;
831 cinfo.ptr *= woinst->num_voices;
839 woinst->buffer.free_bytes %= woinst->buffer.fragment_size;
841 spin_unlock_irqrestore(&woinst->lock, flags);
843 if (copy_to_user(p, &cinfo, sizeof(cinfo)))
848 case SNDCTL_DSP_GETBLKSIZE:
849 DPF(2, "SNDCTL_DSP_GETBLKSIZE:\n");
851 if (file->f_mode & FMODE_WRITE) {
852 spin_lock_irqsave(&woinst->lock, flags);
854 calculate_ofrag(woinst);
855 val = woinst->buffer.fragment_size * woinst->num_voices;
857 spin_unlock_irqrestore(&woinst->lock, flags);
860 if (file->f_mode & FMODE_READ) {
861 spin_lock_irqsave(&wiinst->lock, flags);
863 calculate_ifrag(wiinst);
864 val = wiinst->buffer.fragment_size;
866 spin_unlock_irqrestore(&wiinst->lock, flags);
869 return put_user(val, p);
873 case SNDCTL_DSP_POST:
874 if (file->f_mode & FMODE_WRITE) {
875 spin_lock_irqsave(&woinst->lock, flags);
877 if (!(woinst->state & WAVE_STATE_STARTED)
878 && (wave_dev->enablebits & PCM_ENABLE_OUTPUT)
879 && (woinst->total_copied > 0))
880 emu10k1_waveout_start(wave_dev);
882 spin_unlock_irqrestore(&woinst->lock, flags);
887 case SNDCTL_DSP_SUBDIVIDE:
888 DPF(2, "SNDCTL_DSP_SUBDIVIDE: not implemented\n");
891 case SNDCTL_DSP_SETFRAGMENT:
892 DPF(2, "SNDCTL_DSP_SETFRAGMENT:\n");
894 if (get_user(val, p))
897 DPD(2, "val is %#x\n", val);
902 if (file->f_mode & FMODE_WRITE) {
903 /* digital pass-through fragment count and size are fixed values */
904 if (woinst->state & WAVE_STATE_OPEN || (woinst->format.passthrough == 1))
905 return -EINVAL; /* too late to change */
907 woinst->buffer.ossfragshift = val & 0xffff;
908 woinst->buffer.numfrags = (val >> 16) & 0xffff;
911 if (file->f_mode & FMODE_READ) {
912 if (wiinst->state & WAVE_STATE_OPEN)
913 return -EINVAL; /* too late to change */
915 wiinst->buffer.ossfragshift = val & 0xffff;
916 wiinst->buffer.numfrags = (val >> 16) & 0xffff;
921 case SNDCTL_COPR_LOAD:
926 DPF(4, "SNDCTL_COPR_LOAD:\n");
928 buf = kmalloc(sizeof(copr_buffer), GFP_KERNEL);
932 if (copy_from_user(buf, p, sizeof(copr_buffer))) {
937 if ((buf->command != CMD_READ) && (buf->command != CMD_WRITE)) {
942 if (buf->command == CMD_WRITE) {
945 if ((buf->offs < 0) || (buf->offs + buf->len > 0xe00) || (buf->len > 1000)) {
947 if (((buf->offs < 0x100) || (buf->offs + buf->len > (wave_dev->card->is_audigy ? 0xe00 : 0x800)) || (buf->len > 1000)
949 //any register allowed raw access to users goes here:
952 && (buf->len == 1))) {
958 if ((buf->offs < 0) || (buf->offs + buf->len > 0xe00) || (buf->len > 1000)) {
964 if (((unsigned)buf->flags) > 0x3f)
967 if (buf->command == CMD_READ) {
968 for (i = 0; i < buf->len; i++)
969 ((u32 *) buf->data)[i] = sblive_readptr(wave_dev->card, buf->offs + i, buf->flags);
971 if (copy_to_user(p, buf, sizeof(copr_buffer))) {
976 for (i = 0; i < buf->len; i++)
977 sblive_writeptr(wave_dev->card, buf->offs + i, buf->flags, ((u32 *) buf->data)[i]);
984 default: /* Default is unrecognized command */
985 DPD(2, "default: %#x\n", cmd);
991 static struct page *emu10k1_mm_nopage (struct vm_area_struct * vma, unsigned long address, int *type)
993 struct emu10k1_wavedevice *wave_dev = vma->vm_private_data;
994 struct woinst *woinst = wave_dev->woinst;
995 struct wiinst *wiinst = wave_dev->wiinst;
996 struct page *dmapage;
1000 DPF(3, "emu10k1_mm_nopage()\n");
1001 DPD(3, "addr: %#lx\n", address);
1003 if (address > vma->vm_end) {
1004 DPF(1, "EXIT, returning NOPAGE_SIGBUS\n");
1005 return NOPAGE_SIGBUS; /* Disallow mremap */
1008 pgoff = vma->vm_pgoff + ((address - vma->vm_start) >> PAGE_SHIFT);
1010 wr = woinst->mmapped;
1015 rd = wiinst->mmapped;
1019 /* if full-duplex (read+write) and we have two sets of bufs,
1020 * then the playback buffers come first, sez soundcard.c */
1022 if (pgoff >= woinst->buffer.pages) {
1023 pgoff -= woinst->buffer.pages;
1024 dmapage = virt_to_page ((u8 *) wiinst->buffer.addr + pgoff * PAGE_SIZE);
1026 dmapage = virt_to_page (woinst->voice[0].mem.addr[pgoff]);
1028 dmapage = virt_to_page ((u8 *) wiinst->buffer.addr + pgoff * PAGE_SIZE);
1033 DPD(3, "page: %#lx\n", (unsigned long) dmapage);
1035 *type = VM_FAULT_MINOR;
1039 static struct vm_operations_struct emu10k1_mm_ops = {
1040 .nopage = emu10k1_mm_nopage,
1043 static int emu10k1_audio_mmap(struct file *file, struct vm_area_struct *vma)
1045 struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
1046 unsigned long max_pages, n_pages, pgoffset;
1047 struct woinst *woinst = NULL;
1048 struct wiinst *wiinst = NULL;
1049 unsigned long flags;
1051 DPF(2, "emu10k1_audio_mmap()\n");
1054 if (vma->vm_flags & VM_WRITE) {
1055 woinst = wave_dev->woinst;
1057 spin_lock_irqsave(&woinst->lock, flags);
1059 /* No m'mapping possible for multichannel */
1060 if (woinst->num_voices > 1) {
1061 spin_unlock_irqrestore(&woinst->lock, flags);
1065 if (woinst->state == WAVE_STATE_CLOSED) {
1066 calculate_ofrag(woinst);
1068 if (emu10k1_waveout_open(wave_dev) < 0) {
1069 spin_unlock_irqrestore(&woinst->lock, flags);
1075 woinst->mmapped = 1;
1076 max_pages += woinst->buffer.pages;
1077 spin_unlock_irqrestore(&woinst->lock, flags);
1080 if (vma->vm_flags & VM_READ) {
1081 wiinst = wave_dev->wiinst;
1083 spin_lock_irqsave(&wiinst->lock, flags);
1084 if (wiinst->state == WAVE_STATE_CLOSED) {
1085 calculate_ifrag(wiinst);
1087 if (emu10k1_wavein_open(wave_dev) < 0) {
1088 spin_unlock_irqrestore(&wiinst->lock, flags);
1094 wiinst->mmapped = 1;
1095 max_pages += wiinst->buffer.pages;
1096 spin_unlock_irqrestore(&wiinst->lock, flags);
1099 n_pages = ((vma->vm_end - vma->vm_start) + PAGE_SIZE - 1) >> PAGE_SHIFT;
1100 pgoffset = vma->vm_pgoff;
1102 DPD(2, "vma_start: %#lx, vma_end: %#lx, vma_offset: %ld\n", vma->vm_start, vma->vm_end, pgoffset);
1103 DPD(2, "n_pages: %ld, max_pages: %ld\n", n_pages, max_pages);
1105 if (pgoffset + n_pages > max_pages)
1108 vma->vm_flags |= VM_RESERVED;
1109 vma->vm_ops = &emu10k1_mm_ops;
1110 vma->vm_private_data = wave_dev;
1114 static int emu10k1_audio_open(struct inode *inode, struct file *file)
1116 int minor = iminor(inode);
1117 struct emu10k1_card *card = NULL;
1118 struct list_head *entry;
1119 struct emu10k1_wavedevice *wave_dev;
1121 DPF(2, "emu10k1_audio_open()\n");
1123 /* Check for correct device to open */
1125 list_for_each(entry, &emu10k1_devs) {
1126 card = list_entry(entry, struct emu10k1_card, list);
1128 if (!((card->audio_dev ^ minor) & ~0xf) || !((card->audio_dev1 ^ minor) & ~0xf))
1136 wave_dev = (struct emu10k1_wavedevice *) kmalloc(sizeof(struct emu10k1_wavedevice), GFP_KERNEL);
1138 if (wave_dev == NULL) {
1143 wave_dev->card = card;
1144 wave_dev->wiinst = NULL;
1145 wave_dev->woinst = NULL;
1146 wave_dev->enablebits = PCM_ENABLE_OUTPUT | PCM_ENABLE_INPUT; /* Default */
1148 if (file->f_mode & FMODE_READ) {
1150 struct wiinst *wiinst;
1152 if ((wiinst = (struct wiinst *) kmalloc(sizeof(struct wiinst), GFP_KERNEL)) == NULL) {
1158 wiinst->recsrc = card->wavein.recsrc;
1159 wiinst->fxwc = card->wavein.fxwc;
1161 switch (wiinst->recsrc) {
1162 case WAVERECORD_AC97:
1163 wiinst->format.id = AFMT_S16_LE;
1164 wiinst->format.samplingrate = 8000;
1165 wiinst->format.bitsperchannel = 16;
1166 wiinst->format.channels = 1;
1168 case WAVERECORD_MIC:
1169 wiinst->format.id = AFMT_S16_LE;
1170 wiinst->format.samplingrate = 8000;
1171 wiinst->format.bitsperchannel = 16;
1172 wiinst->format.channels = 1;
1175 wiinst->format.id = AFMT_S16_LE;
1176 wiinst->format.samplingrate = 48000;
1177 wiinst->format.bitsperchannel = 16;
1178 wiinst->format.channels = hweight32(wiinst->fxwc);
1187 wiinst->state = WAVE_STATE_CLOSED;
1189 wiinst->buffer.ossfragshift = 0;
1190 wiinst->buffer.fragment_size = 0;
1191 wiinst->buffer.numfrags = 0;
1193 init_waitqueue_head(&wiinst->wait_queue);
1195 wiinst->mmapped = 0;
1196 wiinst->total_recorded = 0;
1198 spin_lock_init(&wiinst->lock);
1199 tasklet_init(&wiinst->timer.tasklet, emu10k1_wavein_bh, (unsigned long) wave_dev);
1200 wave_dev->wiinst = wiinst;
1201 emu10k1_wavein_setformat(wave_dev, &wiinst->format);
1204 if (file->f_mode & FMODE_WRITE) {
1205 struct woinst *woinst;
1208 if ((woinst = (struct woinst *) kmalloc(sizeof(struct woinst), GFP_KERNEL)) == NULL) {
1214 if (wave_dev->wiinst != NULL) {
1215 woinst->format = wave_dev->wiinst->format;
1217 woinst->format.id = AFMT_U8;
1218 woinst->format.samplingrate = 8000;
1219 woinst->format.bitsperchannel = 8;
1220 woinst->format.channels = 1;
1223 woinst->state = WAVE_STATE_CLOSED;
1225 woinst->buffer.fragment_size = 0;
1226 woinst->buffer.ossfragshift = 0;
1227 woinst->buffer.numfrags = 0;
1228 woinst->device = (card->audio_dev1 == minor);
1229 woinst->timer.state = TIMER_STATE_UNINSTALLED;
1230 woinst->num_voices = 1;
1231 for (i = 0; i < WAVEOUT_MAXVOICES; i++) {
1232 woinst->voice[i].usage = VOICE_USAGE_FREE;
1233 woinst->voice[i].mem.emupageindex = -1;
1236 init_waitqueue_head(&woinst->wait_queue);
1238 woinst->mmapped = 0;
1239 woinst->total_copied = 0;
1240 woinst->total_played = 0;
1242 spin_lock_init(&woinst->lock);
1243 tasklet_init(&woinst->timer.tasklet, emu10k1_waveout_bh, (unsigned long) wave_dev);
1244 wave_dev->woinst = woinst;
1245 emu10k1_waveout_setformat(wave_dev, &woinst->format);
1248 file->private_data = (void *) wave_dev;
1250 return nonseekable_open(inode, file);
1253 static int emu10k1_audio_release(struct inode *inode, struct file *file)
1255 struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
1256 struct emu10k1_card *card;
1257 unsigned long flags;
1259 card = wave_dev->card;
1261 DPF(2, "emu10k1_audio_release()\n");
1263 if (file->f_mode & FMODE_WRITE) {
1264 struct woinst *woinst = wave_dev->woinst;
1266 spin_lock_irqsave(&woinst->lock, flags);
1267 if(woinst->format.passthrough==2)
1268 card->pt.state=PT_STATE_PLAYING;
1269 if (woinst->format.passthrough && card->pt.state != PT_STATE_INACTIVE){
1270 spin_lock(&card->pt.lock);
1271 emu10k1_pt_stop(card);
1272 spin_unlock(&card->pt.lock);
1274 if (woinst->state & WAVE_STATE_OPEN) {
1275 if (woinst->state & WAVE_STATE_STARTED) {
1276 if (!(file->f_flags & O_NONBLOCK)) {
1277 while (!signal_pending(current)
1278 && (woinst->total_played < woinst->total_copied)) {
1279 DPF(4, "Buffer hasn't been totally played, sleep....\n");
1280 spin_unlock_irqrestore(&woinst->lock, flags);
1281 interruptible_sleep_on(&woinst->wait_queue);
1282 spin_lock_irqsave(&woinst->lock, flags);
1286 emu10k1_waveout_close(wave_dev);
1289 spin_unlock_irqrestore(&woinst->lock, flags);
1290 /* remove the tasklet */
1291 tasklet_kill(&woinst->timer.tasklet);
1292 kfree(wave_dev->woinst);
1295 if (file->f_mode & FMODE_READ) {
1296 struct wiinst *wiinst = wave_dev->wiinst;
1298 spin_lock_irqsave(&wiinst->lock, flags);
1300 if (wiinst->state & WAVE_STATE_OPEN) {
1301 emu10k1_wavein_close(wave_dev);
1304 spin_unlock_irqrestore(&wiinst->lock, flags);
1305 tasklet_kill(&wiinst->timer.tasklet);
1306 kfree(wave_dev->wiinst);
1311 if (waitqueue_active(&card->open_wait))
1312 wake_up_interruptible(&card->open_wait);
1317 /* FIXME sort out poll() + mmap() */
1318 static unsigned int emu10k1_audio_poll(struct file *file, struct poll_table_struct *wait)
1320 struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
1321 struct woinst *woinst = wave_dev->woinst;
1322 struct wiinst *wiinst = wave_dev->wiinst;
1323 unsigned int mask = 0;
1325 unsigned long flags;
1327 DPF(4, "emu10k1_audio_poll()\n");
1329 if (file->f_mode & FMODE_WRITE)
1330 poll_wait(file, &woinst->wait_queue, wait);
1332 if (file->f_mode & FMODE_READ)
1333 poll_wait(file, &wiinst->wait_queue, wait);
1335 if (file->f_mode & FMODE_WRITE) {
1336 spin_lock_irqsave(&woinst->lock, flags);
1338 if (woinst->state & WAVE_STATE_OPEN) {
1339 emu10k1_waveout_update(woinst);
1340 emu10k1_waveout_getxfersize(woinst, &bytestocopy);
1342 if (bytestocopy >= woinst->buffer.fragment_size)
1343 mask |= POLLOUT | POLLWRNORM;
1345 mask |= POLLOUT | POLLWRNORM;
1347 spin_unlock_irqrestore(&woinst->lock, flags);
1350 if (file->f_mode & FMODE_READ) {
1351 spin_lock_irqsave(&wiinst->lock, flags);
1353 if (wiinst->state & WAVE_STATE_OPEN) {
1354 emu10k1_wavein_update(wave_dev->card, wiinst);
1355 emu10k1_wavein_getxfersize(wiinst, &bytestocopy);
1357 if (bytestocopy >= wiinst->buffer.fragment_size)
1358 mask |= POLLIN | POLLRDNORM;
1361 spin_unlock_irqrestore(&wiinst->lock, flags);
1367 static void calculate_ofrag(struct woinst *woinst)
1369 struct waveout_buffer *buffer = &woinst->buffer;
1372 if (buffer->fragment_size)
1375 if (!buffer->ossfragshift) {
1376 fragsize = (woinst->format.bytespervoicesample * woinst->format.samplingrate * WAVEOUT_DEFAULTFRAGLEN) / 1000 - 1;
1380 buffer->ossfragshift++;
1384 if (buffer->ossfragshift < WAVEOUT_MINFRAGSHIFT)
1385 buffer->ossfragshift = WAVEOUT_MINFRAGSHIFT;
1387 buffer->fragment_size = 1 << buffer->ossfragshift;
1389 while (buffer->fragment_size * WAVEOUT_MINFRAGS > WAVEOUT_MAXBUFSIZE)
1390 buffer->fragment_size >>= 1;
1392 /* now we are sure that:
1393 (2^WAVEOUT_MINFRAGSHIFT) <= (fragment_size = 2^n) <= (WAVEOUT_MAXBUFSIZE / WAVEOUT_MINFRAGS)
1396 if (!buffer->numfrags) {
1399 numfrags = (woinst->format.bytespervoicesample * woinst->format.samplingrate * WAVEOUT_DEFAULTBUFLEN) /
1400 (buffer->fragment_size * 1000) - 1;
1402 buffer->numfrags = 1;
1406 buffer->numfrags <<= 1;
1410 if (buffer->numfrags < WAVEOUT_MINFRAGS)
1411 buffer->numfrags = WAVEOUT_MINFRAGS;
1413 if (buffer->numfrags * buffer->fragment_size > WAVEOUT_MAXBUFSIZE)
1414 buffer->numfrags = WAVEOUT_MAXBUFSIZE / buffer->fragment_size;
1416 if (buffer->numfrags < WAVEOUT_MINFRAGS)
1419 buffer->size = buffer->fragment_size * buffer->numfrags;
1420 buffer->pages = buffer->size / PAGE_SIZE + ((buffer->size % PAGE_SIZE) ? 1 : 0);
1422 DPD(2, " calculated playback fragment_size -> %d\n", buffer->fragment_size);
1423 DPD(2, " calculated playback numfrags -> %d\n", buffer->numfrags);
1428 static void calculate_ifrag(struct wiinst *wiinst)
1430 struct wavein_buffer *buffer = &wiinst->buffer;
1431 u32 fragsize, bufsize, size[4];
1434 if (buffer->fragment_size)
1437 if (!buffer->ossfragshift) {
1438 fragsize = (wiinst->format.bytespersec * WAVEIN_DEFAULTFRAGLEN) / 1000 - 1;
1442 buffer->ossfragshift++;
1446 if (buffer->ossfragshift < WAVEIN_MINFRAGSHIFT)
1447 buffer->ossfragshift = WAVEIN_MINFRAGSHIFT;
1449 buffer->fragment_size = 1 << buffer->ossfragshift;
1451 while (buffer->fragment_size * WAVEIN_MINFRAGS > WAVEIN_MAXBUFSIZE)
1452 buffer->fragment_size >>= 1;
1454 /* now we are sure that:
1455 (2^WAVEIN_MINFRAGSHIFT) <= (fragment_size = 2^n) <= (WAVEIN_MAXBUFSIZE / WAVEIN_MINFRAGS)
1459 if (!buffer->numfrags)
1460 buffer->numfrags = (wiinst->format.bytespersec * WAVEIN_DEFAULTBUFLEN) / (buffer->fragment_size * 1000) - 1;
1462 if (buffer->numfrags < WAVEIN_MINFRAGS)
1463 buffer->numfrags = WAVEIN_MINFRAGS;
1465 if (buffer->numfrags * buffer->fragment_size > WAVEIN_MAXBUFSIZE)
1466 buffer->numfrags = WAVEIN_MAXBUFSIZE / buffer->fragment_size;
1468 if (buffer->numfrags < WAVEIN_MINFRAGS)
1471 bufsize = buffer->fragment_size * buffer->numfrags;
1473 /* the buffer size for recording is restricted to certain values, adjust it now */
1474 if (bufsize >= 0x10000) {
1475 buffer->size = 0x10000;
1476 buffer->sizeregval = 0x1f;
1484 for (i = 0; i < 8; i++)
1485 for (j = 0; j < 4; j++)
1486 if (bufsize >= size[j]) {
1487 buffer->size = size[j];
1489 buffer->sizeregval = i * 4 + j + 1;
1493 if (buffer->size == 0) {
1495 buffer->sizeregval = 0x01;
1499 /* adjust the fragment size so that buffer size is an integer multiple */
1500 while (buffer->size % buffer->fragment_size)
1501 buffer->fragment_size >>= 1;
1503 buffer->numfrags = buffer->size / buffer->fragment_size;
1504 buffer->pages = buffer->size / PAGE_SIZE + ((buffer->size % PAGE_SIZE) ? 1 : 0);
1506 DPD(2, " calculated recording fragment_size -> %d\n", buffer->fragment_size);
1507 DPD(2, " calculated recording numfrags -> %d\n", buffer->numfrags);
1508 DPD(2, " buffer size register -> %#04x\n", buffer->sizeregval);
1513 static void emu10k1_wavein_bh(unsigned long refdata)
1515 struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) refdata;
1516 struct wiinst *wiinst = wave_dev->wiinst;
1518 unsigned long flags;
1523 spin_lock_irqsave(&wiinst->lock, flags);
1525 if (!(wiinst->state & WAVE_STATE_STARTED)) {
1526 spin_unlock_irqrestore(&wiinst->lock, flags);
1530 emu10k1_wavein_update(wave_dev->card, wiinst);
1531 emu10k1_wavein_getxfersize(wiinst, &bytestocopy);
1533 spin_unlock_irqrestore(&wiinst->lock, flags);
1535 if (bytestocopy >= wiinst->buffer.fragment_size) {
1536 if (waitqueue_active(&wiinst->wait_queue))
1537 wake_up_interruptible(&wiinst->wait_queue);
1539 DPD(3, "Not enough transfer size, %d\n", bytestocopy);
1544 static void emu10k1_waveout_bh(unsigned long refdata)
1546 struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) refdata;
1547 struct woinst *woinst = wave_dev->woinst;
1549 unsigned long flags;
1554 spin_lock_irqsave(&woinst->lock, flags);
1556 if (!(woinst->state & WAVE_STATE_STARTED)) {
1557 spin_unlock_irqrestore(&woinst->lock, flags);
1561 emu10k1_waveout_update(woinst);
1562 emu10k1_waveout_getxfersize(woinst, &bytestocopy);
1564 if (woinst->buffer.fill_silence) {
1565 spin_unlock_irqrestore(&woinst->lock, flags);
1566 emu10k1_waveout_fillsilence(woinst);
1568 spin_unlock_irqrestore(&woinst->lock, flags);
1570 if (bytestocopy >= woinst->buffer.fragment_size) {
1571 if (waitqueue_active(&woinst->wait_queue))
1572 wake_up_interruptible(&woinst->wait_queue);
1574 DPD(3, "Not enough transfer size -> %d\n", bytestocopy);
1579 struct file_operations emu10k1_audio_fops = {
1580 .owner = THIS_MODULE,
1581 .llseek = no_llseek,
1582 .read = emu10k1_audio_read,
1583 .write = emu10k1_audio_write,
1584 .poll = emu10k1_audio_poll,
1585 .ioctl = emu10k1_audio_ioctl,
1586 .mmap = emu10k1_audio_mmap,
1587 .open = emu10k1_audio_open,
1588 .release = emu10k1_audio_release,