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>
39 #include <linux/smp_lock.h>
49 static void calculate_ofrag(struct woinst *);
50 static void calculate_ifrag(struct wiinst *);
52 /* Audio file operations */
53 static ssize_t emu10k1_audio_read(struct file *file, char __user *buffer, size_t count, loff_t * ppos)
55 struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
56 struct wiinst *wiinst = wave_dev->wiinst;
60 DPD(3, "emu10k1_audio_read(), buffer=%p, count=%d\n", buffer, (u32) count);
62 if (!access_ok(VERIFY_WRITE, buffer, count))
65 spin_lock_irqsave(&wiinst->lock, flags);
67 if (wiinst->mmapped) {
68 spin_unlock_irqrestore(&wiinst->lock, flags);
72 if (wiinst->state == WAVE_STATE_CLOSED) {
73 calculate_ifrag(wiinst);
75 while (emu10k1_wavein_open(wave_dev) < 0) {
76 spin_unlock_irqrestore(&wiinst->lock, flags);
78 if (file->f_flags & O_NONBLOCK)
81 interruptible_sleep_on(&wave_dev->card->open_wait);
83 if (signal_pending(current))
86 spin_lock_irqsave(&wiinst->lock, flags);
90 spin_unlock_irqrestore(&wiinst->lock, flags);
95 spin_lock_irqsave(&wiinst->lock, flags);
97 if (!(wiinst->state & WAVE_STATE_STARTED)
98 && (wave_dev->enablebits & PCM_ENABLE_INPUT))
99 emu10k1_wavein_start(wave_dev);
101 emu10k1_wavein_update(wave_dev->card, wiinst);
102 emu10k1_wavein_getxfersize(wiinst, &bytestocopy);
104 spin_unlock_irqrestore(&wiinst->lock, flags);
106 DPD(3, "bytestocopy --> %d\n", bytestocopy);
108 if ((bytestocopy >= wiinst->buffer.fragment_size)
109 || (bytestocopy >= count)) {
110 bytestocopy = min_t(u32, bytestocopy, count);
112 emu10k1_wavein_xferdata(wiinst, (u8 __user *)buffer, &bytestocopy);
114 count -= bytestocopy;
115 buffer += bytestocopy;
120 if ((file->f_flags & O_NONBLOCK)
121 || (!(wave_dev->enablebits & PCM_ENABLE_INPUT)))
122 return (ret ? ret : -EAGAIN);
124 interruptible_sleep_on(&wiinst->wait_queue);
126 if (signal_pending(current))
127 return (ret ? ret : -ERESTARTSYS);
132 DPD(3, "bytes copied -> %d\n", (u32) ret);
137 static ssize_t emu10k1_audio_write(struct file *file, const char __user *buffer, size_t count, loff_t * ppos)
139 struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
140 struct woinst *woinst = wave_dev->woinst;
144 DPD(3, "emu10k1_audio_write(), buffer=%p, count=%d\n", buffer, (u32) count);
146 if (!access_ok(VERIFY_READ, buffer, count))
149 spin_lock_irqsave(&woinst->lock, flags);
151 if (woinst->mmapped) {
152 spin_unlock_irqrestore(&woinst->lock, flags);
155 // This is for emu10k1 revs less than 7, we need to go through tram
156 if (woinst->format.passthrough == 1) {
159 woinst->buffer.ossfragshift = PT_BLOCKSIZE_LOG2;
160 woinst->buffer.numfrags = PT_BLOCKCOUNT;
161 calculate_ofrag(woinst);
163 r = emu10k1_pt_write(file, buffer, count);
164 spin_unlock_irqrestore(&woinst->lock, flags);
168 if (woinst->state == WAVE_STATE_CLOSED) {
169 calculate_ofrag(woinst);
171 while (emu10k1_waveout_open(wave_dev) < 0) {
172 spin_unlock_irqrestore(&woinst->lock, flags);
174 if (file->f_flags & O_NONBLOCK)
177 interruptible_sleep_on(&wave_dev->card->open_wait);
179 if (signal_pending(current))
182 spin_lock_irqsave(&woinst->lock, flags);
186 spin_unlock_irqrestore(&woinst->lock, flags);
189 if (count % woinst->format.bytespersample)
192 count /= woinst->num_voices;
197 spin_lock_irqsave(&woinst->lock, flags);
198 emu10k1_waveout_update(woinst);
199 emu10k1_waveout_getxfersize(woinst, &bytestocopy);
200 spin_unlock_irqrestore(&woinst->lock, flags);
202 DPD(3, "bytestocopy --> %d\n", bytestocopy);
204 if ((bytestocopy >= woinst->buffer.fragment_size)
205 || (bytestocopy >= count)) {
207 bytestocopy = min_t(u32, bytestocopy, count);
209 emu10k1_waveout_xferdata(woinst, (u8 __user *) buffer, &bytestocopy);
211 count -= bytestocopy;
212 buffer += bytestocopy * woinst->num_voices;
213 ret += bytestocopy * woinst->num_voices;
215 spin_lock_irqsave(&woinst->lock, flags);
216 woinst->total_copied += bytestocopy;
218 if (!(woinst->state & WAVE_STATE_STARTED)
219 && (wave_dev->enablebits & PCM_ENABLE_OUTPUT)
220 && (woinst->total_copied >= woinst->buffer.fragment_size))
221 emu10k1_waveout_start(wave_dev);
223 spin_unlock_irqrestore(&woinst->lock, flags);
227 if ((file->f_flags & O_NONBLOCK)
228 || (!(wave_dev->enablebits & PCM_ENABLE_OUTPUT)))
229 return (ret ? ret : -EAGAIN);
231 interruptible_sleep_on(&woinst->wait_queue);
233 if (signal_pending(current))
234 return (ret ? ret : -ERESTARTSYS);
238 DPD(3, "bytes copied -> %d\n", (u32) ret);
243 static int emu10k1_audio_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
245 struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
246 struct woinst *woinst = NULL;
247 struct wiinst *wiinst = NULL;
251 int __user *p = (int __user *)arg;
253 DPF(4, "emu10k1_audio_ioctl()\n");
255 if (file->f_mode & FMODE_WRITE)
256 woinst = wave_dev->woinst;
258 if (file->f_mode & FMODE_READ)
259 wiinst = wave_dev->wiinst;
263 DPF(2, "OSS_GETVERSION:\n");
264 return put_user(SOUND_VERSION, p);
266 case SNDCTL_DSP_RESET:
267 DPF(2, "SNDCTL_DSP_RESET:\n");
268 wave_dev->enablebits = PCM_ENABLE_OUTPUT | PCM_ENABLE_INPUT;
270 if (file->f_mode & FMODE_WRITE) {
271 spin_lock_irqsave(&woinst->lock, flags);
273 if (woinst->state & WAVE_STATE_OPEN) {
274 emu10k1_waveout_close(wave_dev);
278 woinst->total_copied = 0;
279 woinst->total_played = 0;
282 spin_unlock_irqrestore(&woinst->lock, flags);
285 if (file->f_mode & FMODE_READ) {
286 spin_lock_irqsave(&wiinst->lock, flags);
288 if (wiinst->state & WAVE_STATE_OPEN) {
289 emu10k1_wavein_close(wave_dev);
293 wiinst->total_recorded = 0;
295 spin_unlock_irqrestore(&wiinst->lock, flags);
300 case SNDCTL_DSP_SYNC:
301 DPF(2, "SNDCTL_DSP_SYNC:\n");
303 if (file->f_mode & FMODE_WRITE) {
305 spin_lock_irqsave(&woinst->lock, flags);
307 if (woinst->state & WAVE_STATE_OPEN) {
309 if (woinst->state & WAVE_STATE_STARTED)
310 while ((woinst->total_played < woinst->total_copied)
311 && !signal_pending(current)) {
312 spin_unlock_irqrestore(&woinst->lock, flags);
313 interruptible_sleep_on(&woinst->wait_queue);
314 spin_lock_irqsave(&woinst->lock, flags);
316 emu10k1_waveout_close(wave_dev);
320 woinst->total_copied = 0;
321 woinst->total_played = 0;
324 spin_unlock_irqrestore(&woinst->lock, flags);
327 if (file->f_mode & FMODE_READ) {
328 spin_lock_irqsave(&wiinst->lock, flags);
330 if (wiinst->state & WAVE_STATE_OPEN) {
331 emu10k1_wavein_close(wave_dev);
335 wiinst->total_recorded = 0;
337 spin_unlock_irqrestore(&wiinst->lock, flags);
342 case SNDCTL_DSP_SETDUPLEX:
343 DPF(2, "SNDCTL_DSP_SETDUPLEX:\n");
346 case SNDCTL_DSP_GETCAPS:
347 DPF(2, "SNDCTL_DSP_GETCAPS:\n");
348 return put_user(DSP_CAP_DUPLEX | DSP_CAP_REALTIME |
349 DSP_CAP_TRIGGER | DSP_CAP_MMAP |
350 DSP_CAP_COPROC| DSP_CAP_MULTI, p);
351 case SNDCTL_DSP_SPEED:
352 DPF(2, "SNDCTL_DSP_SPEED:\n");
354 if (get_user(val, p))
357 DPD(2, "val is %d\n", val);
360 if (file->f_mode & FMODE_READ) {
361 struct wave_format format;
363 spin_lock_irqsave(&wiinst->lock, flags);
365 format = wiinst->format;
366 format.samplingrate = val;
368 if (emu10k1_wavein_setformat(wave_dev, &format) < 0) {
369 spin_unlock_irqrestore(&wiinst->lock, flags);
373 val = wiinst->format.samplingrate;
375 spin_unlock_irqrestore(&wiinst->lock, flags);
377 DPD(2, "set recording sampling rate -> %d\n", val);
380 if (file->f_mode & FMODE_WRITE) {
381 struct wave_format format;
383 spin_lock_irqsave(&woinst->lock, flags);
385 format = woinst->format;
386 format.samplingrate = val;
388 if (emu10k1_waveout_setformat(wave_dev, &format) < 0) {
389 spin_unlock_irqrestore(&woinst->lock, flags);
393 val = woinst->format.samplingrate;
395 spin_unlock_irqrestore(&woinst->lock, flags);
397 DPD(2, "set playback sampling rate -> %d\n", val);
400 return put_user(val, p);
402 if (file->f_mode & FMODE_READ)
403 val = wiinst->format.samplingrate;
404 else if (file->f_mode & FMODE_WRITE)
405 val = woinst->format.samplingrate;
407 return put_user(val, p);
411 case SNDCTL_DSP_STEREO:
412 DPF(2, "SNDCTL_DSP_STEREO:\n");
414 if (get_user(val, p))
417 DPD(2, " val is %d\n", val);
419 if (file->f_mode & FMODE_READ) {
420 struct wave_format format;
422 spin_lock_irqsave(&wiinst->lock, flags);
424 format = wiinst->format;
425 format.channels = val ? 2 : 1;
427 if (emu10k1_wavein_setformat(wave_dev, &format) < 0) {
428 spin_unlock_irqrestore(&wiinst->lock, flags);
432 val = wiinst->format.channels - 1;
434 spin_unlock_irqrestore(&wiinst->lock, flags);
435 DPD(2, "set recording stereo -> %d\n", val);
438 if (file->f_mode & FMODE_WRITE) {
439 struct wave_format format;
441 spin_lock_irqsave(&woinst->lock, flags);
443 format = woinst->format;
444 format.channels = val ? 2 : 1;
446 if (emu10k1_waveout_setformat(wave_dev, &format) < 0) {
447 spin_unlock_irqrestore(&woinst->lock, flags);
451 val = woinst->format.channels - 1;
453 spin_unlock_irqrestore(&woinst->lock, flags);
455 DPD(2, "set playback stereo -> %d\n", val);
458 return put_user(val, p);
462 case SNDCTL_DSP_CHANNELS:
463 DPF(2, "SNDCTL_DSP_CHANNELS:\n");
465 if (get_user(val, p))
468 DPD(2, " val is %d\n", val);
471 if (file->f_mode & FMODE_READ) {
472 struct wave_format format;
474 spin_lock_irqsave(&wiinst->lock, flags);
476 format = wiinst->format;
477 format.channels = val;
479 if (emu10k1_wavein_setformat(wave_dev, &format) < 0) {
480 spin_unlock_irqrestore(&wiinst->lock, flags);
483 val = wiinst->format.channels;
485 spin_unlock_irqrestore(&wiinst->lock, flags);
486 DPD(2, "set recording number of channels -> %d\n", val);
489 if (file->f_mode & FMODE_WRITE) {
490 struct wave_format format;
492 spin_lock_irqsave(&woinst->lock, flags);
494 format = woinst->format;
495 format.channels = val;
497 if (emu10k1_waveout_setformat(wave_dev, &format) < 0) {
498 spin_unlock_irqrestore(&woinst->lock, flags);
502 val = woinst->format.channels;
504 spin_unlock_irqrestore(&woinst->lock, flags);
505 DPD(2, "set playback number of channels -> %d\n", val);
508 return put_user(val, p);
510 if (file->f_mode & FMODE_READ)
511 val = wiinst->format.channels;
512 else if (file->f_mode & FMODE_WRITE)
513 val = woinst->format.channels;
515 return put_user(val, p);
519 case SNDCTL_DSP_GETFMTS:
520 DPF(2, "SNDCTL_DSP_GETFMTS:\n");
522 if (file->f_mode & FMODE_READ)
524 else if (file->f_mode & FMODE_WRITE) {
525 val = AFMT_S16_LE | AFMT_U8;
526 if (emu10k1_find_control_gpr(&wave_dev->card->mgr,
527 wave_dev->card->pt.patch_name,
528 wave_dev->card->pt.enable_gpr_name) >= 0)
531 return put_user(val, p);
533 case SNDCTL_DSP_SETFMT: /* Same as SNDCTL_DSP_SAMPLESIZE */
534 DPF(2, "SNDCTL_DSP_SETFMT:\n");
536 if (get_user(val, p))
539 DPD(2, " val is %d\n", val);
541 if (val != AFMT_QUERY) {
542 if (file->f_mode & FMODE_READ) {
543 struct wave_format format;
545 spin_lock_irqsave(&wiinst->lock, flags);
547 format = wiinst->format;
550 if (emu10k1_wavein_setformat(wave_dev, &format) < 0) {
551 spin_unlock_irqrestore(&wiinst->lock, flags);
555 val = wiinst->format.id;
557 spin_unlock_irqrestore(&wiinst->lock, flags);
558 DPD(2, "set recording format -> %d\n", val);
561 if (file->f_mode & FMODE_WRITE) {
562 struct wave_format format;
564 spin_lock_irqsave(&woinst->lock, flags);
566 format = woinst->format;
569 if (emu10k1_waveout_setformat(wave_dev, &format) < 0) {
570 spin_unlock_irqrestore(&woinst->lock, flags);
574 val = woinst->format.id;
576 spin_unlock_irqrestore(&woinst->lock, flags);
577 DPD(2, "set playback format -> %d\n", val);
580 return put_user(val, p);
582 if (file->f_mode & FMODE_READ)
583 val = wiinst->format.id;
584 else if (file->f_mode & FMODE_WRITE)
585 val = woinst->format.id;
587 return put_user(val, p);
591 case SOUND_PCM_READ_BITS:
593 if (file->f_mode & FMODE_READ)
594 val = wiinst->format.bitsperchannel;
595 else if (file->f_mode & FMODE_WRITE)
596 val = woinst->format.bitsperchannel;
598 return put_user(val, p);
600 case SOUND_PCM_READ_RATE:
602 if (file->f_mode & FMODE_READ)
603 val = wiinst->format.samplingrate;
604 else if (file->f_mode & FMODE_WRITE)
605 val = woinst->format.samplingrate;
607 return put_user(val, p);
609 case SOUND_PCM_READ_CHANNELS:
611 if (file->f_mode & FMODE_READ)
612 val = wiinst->format.channels;
613 else if (file->f_mode & FMODE_WRITE)
614 val = woinst->format.channels;
616 return put_user(val, p);
618 case SOUND_PCM_WRITE_FILTER:
619 DPF(2, "SOUND_PCM_WRITE_FILTER: not implemented\n");
622 case SOUND_PCM_READ_FILTER:
623 DPF(2, "SOUND_PCM_READ_FILTER: not implemented\n");
626 case SNDCTL_DSP_SETSYNCRO:
627 DPF(2, "SNDCTL_DSP_SETSYNCRO: not implemented\n");
630 case SNDCTL_DSP_GETTRIGGER:
631 DPF(2, "SNDCTL_DSP_GETTRIGGER:\n");
633 if (file->f_mode & FMODE_WRITE && (wave_dev->enablebits & PCM_ENABLE_OUTPUT))
634 val |= PCM_ENABLE_OUTPUT;
636 if (file->f_mode & FMODE_READ && (wave_dev->enablebits & PCM_ENABLE_INPUT))
637 val |= PCM_ENABLE_INPUT;
639 return put_user(val, p);
641 case SNDCTL_DSP_SETTRIGGER:
642 DPF(2, "SNDCTL_DSP_SETTRIGGER:\n");
644 if (get_user(val, p))
647 if (file->f_mode & FMODE_WRITE) {
648 spin_lock_irqsave(&woinst->lock, flags);
650 if (val & PCM_ENABLE_OUTPUT) {
651 wave_dev->enablebits |= PCM_ENABLE_OUTPUT;
652 if (woinst->state & WAVE_STATE_OPEN)
653 emu10k1_waveout_start(wave_dev);
655 wave_dev->enablebits &= ~PCM_ENABLE_OUTPUT;
656 if (woinst->state & WAVE_STATE_STARTED)
657 emu10k1_waveout_stop(wave_dev);
660 spin_unlock_irqrestore(&woinst->lock, flags);
663 if (file->f_mode & FMODE_READ) {
664 spin_lock_irqsave(&wiinst->lock, flags);
666 if (val & PCM_ENABLE_INPUT) {
667 wave_dev->enablebits |= PCM_ENABLE_INPUT;
668 if (wiinst->state & WAVE_STATE_OPEN)
669 emu10k1_wavein_start(wave_dev);
671 wave_dev->enablebits &= ~PCM_ENABLE_INPUT;
672 if (wiinst->state & WAVE_STATE_STARTED)
673 emu10k1_wavein_stop(wave_dev);
676 spin_unlock_irqrestore(&wiinst->lock, flags);
680 case SNDCTL_DSP_GETOSPACE:
684 DPF(4, "SNDCTL_DSP_GETOSPACE:\n");
686 if (!(file->f_mode & FMODE_WRITE))
689 spin_lock_irqsave(&woinst->lock, flags);
691 if (woinst->state & WAVE_STATE_OPEN) {
692 emu10k1_waveout_update(woinst);
693 emu10k1_waveout_getxfersize(woinst, &bytestocopy);
694 info.bytes = bytestocopy;
696 calculate_ofrag(woinst);
697 info.bytes = woinst->buffer.size;
699 spin_unlock_irqrestore(&woinst->lock, flags);
701 info.bytes *= woinst->num_voices;
702 info.fragsize = woinst->buffer.fragment_size * woinst->num_voices;
703 info.fragstotal = woinst->buffer.numfrags * woinst->num_voices;
704 info.fragments = info.bytes / info.fragsize;
706 if (copy_to_user(p, &info, sizeof(info)))
711 case SNDCTL_DSP_GETISPACE:
715 DPF(4, "SNDCTL_DSP_GETISPACE:\n");
717 if (!(file->f_mode & FMODE_READ))
720 spin_lock_irqsave(&wiinst->lock, flags);
721 if (wiinst->state & WAVE_STATE_OPEN) {
722 emu10k1_wavein_update(wave_dev->card, wiinst);
723 emu10k1_wavein_getxfersize(wiinst, &bytestocopy);
724 info.bytes = bytestocopy;
726 calculate_ifrag(wiinst);
729 spin_unlock_irqrestore(&wiinst->lock, flags);
731 info.fragstotal = wiinst->buffer.numfrags;
732 info.fragments = info.bytes / wiinst->buffer.fragment_size;
733 info.fragsize = wiinst->buffer.fragment_size;
735 if (copy_to_user(p, &info, sizeof(info)))
740 case SNDCTL_DSP_NONBLOCK:
741 DPF(2, "SNDCTL_DSP_NONBLOCK:\n");
743 file->f_flags |= O_NONBLOCK;
746 case SNDCTL_DSP_GETODELAY:
747 DPF(4, "SNDCTL_DSP_GETODELAY:\n");
749 if (!(file->f_mode & FMODE_WRITE))
752 spin_lock_irqsave(&woinst->lock, flags);
753 if (woinst->state & WAVE_STATE_OPEN) {
754 emu10k1_waveout_update(woinst);
755 emu10k1_waveout_getxfersize(woinst, &bytestocopy);
756 val = woinst->buffer.size - bytestocopy;
760 val *= woinst->num_voices;
761 spin_unlock_irqrestore(&woinst->lock, flags);
763 return put_user(val, p);
765 case SNDCTL_DSP_GETIPTR:
769 DPF(4, "SNDCTL_DSP_GETIPTR: \n");
771 if (!(file->f_mode & FMODE_READ))
774 spin_lock_irqsave(&wiinst->lock, flags);
776 if (wiinst->state & WAVE_STATE_OPEN) {
777 emu10k1_wavein_update(wave_dev->card, wiinst);
778 cinfo.ptr = wiinst->buffer.hw_pos;
779 cinfo.bytes = cinfo.ptr + wiinst->total_recorded - wiinst->total_recorded % wiinst->buffer.size;
780 cinfo.blocks = cinfo.bytes / wiinst->buffer.fragment_size - wiinst->blocks;
781 wiinst->blocks = cinfo.bytes / wiinst->buffer.fragment_size;
789 wiinst->buffer.bytestocopy %= wiinst->buffer.fragment_size;
791 spin_unlock_irqrestore(&wiinst->lock, flags);
793 if (copy_to_user(p, &cinfo, sizeof(cinfo)))
798 case SNDCTL_DSP_GETOPTR:
802 DPF(4, "SNDCTL_DSP_GETOPTR:\n");
804 if (!(file->f_mode & FMODE_WRITE))
807 spin_lock_irqsave(&woinst->lock, flags);
809 if (woinst->state & WAVE_STATE_OPEN ||
810 ((woinst->format.passthrough == 1) && wave_dev->card->pt.state)) {
813 if (woinst->format.passthrough == 1) {
814 emu10k1_pt_waveout_update(wave_dev);
815 cinfo.bytes = woinst->total_played;
817 emu10k1_waveout_update(woinst);
818 cinfo.bytes = woinst->total_played;
821 cinfo.ptr = woinst->buffer.hw_pos;
822 num_fragments = cinfo.bytes / woinst->buffer.fragment_size;
823 cinfo.blocks = num_fragments - woinst->blocks;
824 woinst->blocks = num_fragments;
826 cinfo.bytes *= woinst->num_voices;
827 cinfo.ptr *= woinst->num_voices;
835 woinst->buffer.free_bytes %= woinst->buffer.fragment_size;
837 spin_unlock_irqrestore(&woinst->lock, flags);
839 if (copy_to_user(p, &cinfo, sizeof(cinfo)))
844 case SNDCTL_DSP_GETBLKSIZE:
845 DPF(2, "SNDCTL_DSP_GETBLKSIZE:\n");
847 if (file->f_mode & FMODE_WRITE) {
848 spin_lock_irqsave(&woinst->lock, flags);
850 calculate_ofrag(woinst);
851 val = woinst->buffer.fragment_size * woinst->num_voices;
853 spin_unlock_irqrestore(&woinst->lock, flags);
856 if (file->f_mode & FMODE_READ) {
857 spin_lock_irqsave(&wiinst->lock, flags);
859 calculate_ifrag(wiinst);
860 val = wiinst->buffer.fragment_size;
862 spin_unlock_irqrestore(&wiinst->lock, flags);
865 return put_user(val, p);
869 case SNDCTL_DSP_POST:
870 if (file->f_mode & FMODE_WRITE) {
871 spin_lock_irqsave(&woinst->lock, flags);
873 if (!(woinst->state & WAVE_STATE_STARTED)
874 && (wave_dev->enablebits & PCM_ENABLE_OUTPUT)
875 && (woinst->total_copied > 0))
876 emu10k1_waveout_start(wave_dev);
878 spin_unlock_irqrestore(&woinst->lock, flags);
883 case SNDCTL_DSP_SUBDIVIDE:
884 DPF(2, "SNDCTL_DSP_SUBDIVIDE: not implemented\n");
887 case SNDCTL_DSP_SETFRAGMENT:
888 DPF(2, "SNDCTL_DSP_SETFRAGMENT:\n");
890 if (get_user(val, p))
893 DPD(2, "val is %#x\n", val);
898 if (file->f_mode & FMODE_WRITE) {
899 /* digital pass-through fragment count and size are fixed values */
900 if (woinst->state & WAVE_STATE_OPEN || (woinst->format.passthrough == 1))
901 return -EINVAL; /* too late to change */
903 woinst->buffer.ossfragshift = val & 0xffff;
904 woinst->buffer.numfrags = (val >> 16) & 0xffff;
907 if (file->f_mode & FMODE_READ) {
908 if (wiinst->state & WAVE_STATE_OPEN)
909 return -EINVAL; /* too late to change */
911 wiinst->buffer.ossfragshift = val & 0xffff;
912 wiinst->buffer.numfrags = (val >> 16) & 0xffff;
917 case SNDCTL_COPR_LOAD:
922 DPF(4, "SNDCTL_COPR_LOAD:\n");
924 buf = kmalloc(sizeof(copr_buffer), GFP_KERNEL);
928 if (copy_from_user(buf, p, sizeof(copr_buffer))) {
933 if ((buf->command != CMD_READ) && (buf->command != CMD_WRITE)) {
938 if (buf->command == CMD_WRITE) {
941 if ((buf->offs < 0) || (buf->offs + buf->len > 0xe00) || (buf->len > 1000)) {
943 if (((buf->offs < 0x100) || (buf->offs + buf->len > (wave_dev->card->is_audigy ? 0xe00 : 0x800)) || (buf->len > 1000)
945 //any register allowed raw access to users goes here:
948 && (buf->len == 1))) {
954 if ((buf->offs < 0) || (buf->offs + buf->len > 0xe00) || (buf->len > 1000)) {
960 if (((unsigned)buf->flags) > 0x3f)
963 if (buf->command == CMD_READ) {
964 for (i = 0; i < buf->len; i++)
965 ((u32 *) buf->data)[i] = sblive_readptr(wave_dev->card, buf->offs + i, buf->flags);
967 if (copy_to_user(p, buf, sizeof(copr_buffer))) {
972 for (i = 0; i < buf->len; i++)
973 sblive_writeptr(wave_dev->card, buf->offs + i, buf->flags, ((u32 *) buf->data)[i]);
980 default: /* Default is unrecognized command */
981 DPD(2, "default: %#x\n", cmd);
987 static struct page *emu10k1_mm_nopage (struct vm_area_struct * vma, unsigned long address, int *type)
989 struct emu10k1_wavedevice *wave_dev = vma->vm_private_data;
990 struct woinst *woinst = wave_dev->woinst;
991 struct wiinst *wiinst = wave_dev->wiinst;
992 struct page *dmapage;
996 DPF(3, "emu10k1_mm_nopage()\n");
997 DPD(3, "addr: %#lx\n", address);
999 if (address > vma->vm_end) {
1000 DPF(1, "EXIT, returning NOPAGE_SIGBUS\n");
1001 return NOPAGE_SIGBUS; /* Disallow mremap */
1004 pgoff = vma->vm_pgoff + ((address - vma->vm_start) >> PAGE_SHIFT);
1006 wr = woinst->mmapped;
1011 rd = wiinst->mmapped;
1015 /* if full-duplex (read+write) and we have two sets of bufs,
1016 * then the playback buffers come first, sez soundcard.c */
1018 if (pgoff >= woinst->buffer.pages) {
1019 pgoff -= woinst->buffer.pages;
1020 dmapage = virt_to_page ((u8 *) wiinst->buffer.addr + pgoff * PAGE_SIZE);
1022 dmapage = virt_to_page (woinst->voice[0].mem.addr[pgoff]);
1024 dmapage = virt_to_page ((u8 *) wiinst->buffer.addr + pgoff * PAGE_SIZE);
1029 DPD(3, "page: %#lx\n", (unsigned long) dmapage);
1031 *type = VM_FAULT_MINOR;
1035 struct vm_operations_struct emu10k1_mm_ops = {
1036 .nopage = emu10k1_mm_nopage,
1039 static int emu10k1_audio_mmap(struct file *file, struct vm_area_struct *vma)
1041 struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
1042 unsigned long max_pages, n_pages, pgoffset;
1043 struct woinst *woinst = NULL;
1044 struct wiinst *wiinst = NULL;
1045 unsigned long flags;
1047 DPF(2, "emu10k1_audio_mmap()\n");
1050 if (vma->vm_flags & VM_WRITE) {
1051 woinst = wave_dev->woinst;
1053 spin_lock_irqsave(&woinst->lock, flags);
1055 /* No m'mapping possible for multichannel */
1056 if (woinst->num_voices > 1) {
1057 spin_unlock_irqrestore(&woinst->lock, flags);
1061 if (woinst->state == WAVE_STATE_CLOSED) {
1062 calculate_ofrag(woinst);
1064 if (emu10k1_waveout_open(wave_dev) < 0) {
1065 spin_unlock_irqrestore(&woinst->lock, flags);
1071 woinst->mmapped = 1;
1072 max_pages += woinst->buffer.pages;
1073 spin_unlock_irqrestore(&woinst->lock, flags);
1076 if (vma->vm_flags & VM_READ) {
1077 wiinst = wave_dev->wiinst;
1079 spin_lock_irqsave(&wiinst->lock, flags);
1080 if (wiinst->state == WAVE_STATE_CLOSED) {
1081 calculate_ifrag(wiinst);
1083 if (emu10k1_wavein_open(wave_dev) < 0) {
1084 spin_unlock_irqrestore(&wiinst->lock, flags);
1090 wiinst->mmapped = 1;
1091 max_pages += wiinst->buffer.pages;
1092 spin_unlock_irqrestore(&wiinst->lock, flags);
1095 n_pages = ((vma->vm_end - vma->vm_start) + PAGE_SIZE - 1) >> PAGE_SHIFT;
1096 pgoffset = vma->vm_pgoff;
1098 DPD(2, "vma_start: %#lx, vma_end: %#lx, vma_offset: %ld\n", vma->vm_start, vma->vm_end, pgoffset);
1099 DPD(2, "n_pages: %ld, max_pages: %ld\n", n_pages, max_pages);
1101 if (pgoffset + n_pages > max_pages)
1104 vma->vm_flags |= VM_RESERVED;
1105 vma->vm_ops = &emu10k1_mm_ops;
1106 vma->vm_private_data = wave_dev;
1110 static int emu10k1_audio_open(struct inode *inode, struct file *file)
1112 int minor = iminor(inode);
1113 struct emu10k1_card *card = NULL;
1114 struct list_head *entry;
1115 struct emu10k1_wavedevice *wave_dev;
1117 DPF(2, "emu10k1_audio_open()\n");
1119 /* Check for correct device to open */
1121 list_for_each(entry, &emu10k1_devs) {
1122 card = list_entry(entry, struct emu10k1_card, list);
1124 if (!((card->audio_dev ^ minor) & ~0xf) || !((card->audio_dev1 ^ minor) & ~0xf))
1132 wave_dev = (struct emu10k1_wavedevice *) kmalloc(sizeof(struct emu10k1_wavedevice), GFP_KERNEL);
1134 if (wave_dev == NULL) {
1139 wave_dev->card = card;
1140 wave_dev->wiinst = NULL;
1141 wave_dev->woinst = NULL;
1142 wave_dev->enablebits = PCM_ENABLE_OUTPUT | PCM_ENABLE_INPUT; /* Default */
1144 if (file->f_mode & FMODE_READ) {
1146 struct wiinst *wiinst;
1148 if ((wiinst = (struct wiinst *) kmalloc(sizeof(struct wiinst), GFP_KERNEL)) == NULL) {
1154 wiinst->recsrc = card->wavein.recsrc;
1155 wiinst->fxwc = card->wavein.fxwc;
1157 switch (wiinst->recsrc) {
1158 case WAVERECORD_AC97:
1159 wiinst->format.id = AFMT_S16_LE;
1160 wiinst->format.samplingrate = 8000;
1161 wiinst->format.bitsperchannel = 16;
1162 wiinst->format.channels = 1;
1164 case WAVERECORD_MIC:
1165 wiinst->format.id = AFMT_S16_LE;
1166 wiinst->format.samplingrate = 8000;
1167 wiinst->format.bitsperchannel = 16;
1168 wiinst->format.channels = 1;
1171 wiinst->format.id = AFMT_S16_LE;
1172 wiinst->format.samplingrate = 48000;
1173 wiinst->format.bitsperchannel = 16;
1174 wiinst->format.channels = hweight32(wiinst->fxwc);
1183 wiinst->state = WAVE_STATE_CLOSED;
1185 wiinst->buffer.ossfragshift = 0;
1186 wiinst->buffer.fragment_size = 0;
1187 wiinst->buffer.numfrags = 0;
1189 init_waitqueue_head(&wiinst->wait_queue);
1191 wiinst->mmapped = 0;
1192 wiinst->total_recorded = 0;
1194 wiinst->lock = SPIN_LOCK_UNLOCKED;
1195 tasklet_init(&wiinst->timer.tasklet, emu10k1_wavein_bh, (unsigned long) wave_dev);
1196 wave_dev->wiinst = wiinst;
1197 emu10k1_wavein_setformat(wave_dev, &wiinst->format);
1200 if (file->f_mode & FMODE_WRITE) {
1201 struct woinst *woinst;
1204 if ((woinst = (struct woinst *) kmalloc(sizeof(struct woinst), GFP_KERNEL)) == NULL) {
1210 if (wave_dev->wiinst != NULL) {
1211 woinst->format = wave_dev->wiinst->format;
1213 woinst->format.id = AFMT_U8;
1214 woinst->format.samplingrate = 8000;
1215 woinst->format.bitsperchannel = 8;
1216 woinst->format.channels = 1;
1219 woinst->state = WAVE_STATE_CLOSED;
1221 woinst->buffer.fragment_size = 0;
1222 woinst->buffer.ossfragshift = 0;
1223 woinst->buffer.numfrags = 0;
1224 woinst->device = (card->audio_dev1 == minor);
1225 woinst->timer.state = TIMER_STATE_UNINSTALLED;
1226 woinst->num_voices = 1;
1227 for (i = 0; i < WAVEOUT_MAXVOICES; i++) {
1228 woinst->voice[i].usage = VOICE_USAGE_FREE;
1229 woinst->voice[i].mem.emupageindex = -1;
1232 init_waitqueue_head(&woinst->wait_queue);
1234 woinst->mmapped = 0;
1235 woinst->total_copied = 0;
1236 woinst->total_played = 0;
1238 woinst->lock = SPIN_LOCK_UNLOCKED;
1239 tasklet_init(&woinst->timer.tasklet, emu10k1_waveout_bh, (unsigned long) wave_dev);
1240 wave_dev->woinst = woinst;
1241 emu10k1_waveout_setformat(wave_dev, &woinst->format);
1244 file->private_data = (void *) wave_dev;
1246 return nonseekable_open(inode, file);
1249 static int emu10k1_audio_release(struct inode *inode, struct file *file)
1251 struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
1252 struct emu10k1_card *card;
1253 unsigned long flags;
1255 card = wave_dev->card;
1257 DPF(2, "emu10k1_audio_release()\n");
1259 if (file->f_mode & FMODE_WRITE) {
1260 struct woinst *woinst = wave_dev->woinst;
1262 spin_lock_irqsave(&woinst->lock, flags);
1263 if(woinst->format.passthrough==2)
1264 card->pt.state=PT_STATE_PLAYING;
1265 if (woinst->format.passthrough && card->pt.state != PT_STATE_INACTIVE){
1266 spin_lock(&card->pt.lock);
1267 emu10k1_pt_stop(card);
1268 spin_unlock(&card->pt.lock);
1270 if (woinst->state & WAVE_STATE_OPEN) {
1271 if (woinst->state & WAVE_STATE_STARTED) {
1272 if (!(file->f_flags & O_NONBLOCK)) {
1273 while (!signal_pending(current)
1274 && (woinst->total_played < woinst->total_copied)) {
1275 DPF(4, "Buffer hasn't been totally played, sleep....\n");
1276 spin_unlock_irqrestore(&woinst->lock, flags);
1277 interruptible_sleep_on(&woinst->wait_queue);
1278 spin_lock_irqsave(&woinst->lock, flags);
1282 emu10k1_waveout_close(wave_dev);
1285 spin_unlock_irqrestore(&woinst->lock, flags);
1286 /* remove the tasklet */
1287 tasklet_kill(&woinst->timer.tasklet);
1288 kfree(wave_dev->woinst);
1291 if (file->f_mode & FMODE_READ) {
1292 struct wiinst *wiinst = wave_dev->wiinst;
1294 spin_lock_irqsave(&wiinst->lock, flags);
1296 if (wiinst->state & WAVE_STATE_OPEN) {
1297 emu10k1_wavein_close(wave_dev);
1300 spin_unlock_irqrestore(&wiinst->lock, flags);
1301 tasklet_kill(&wiinst->timer.tasklet);
1302 kfree(wave_dev->wiinst);
1307 if (waitqueue_active(&card->open_wait))
1308 wake_up_interruptible(&card->open_wait);
1313 /* FIXME sort out poll() + mmap() */
1314 static unsigned int emu10k1_audio_poll(struct file *file, struct poll_table_struct *wait)
1316 struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
1317 struct woinst *woinst = wave_dev->woinst;
1318 struct wiinst *wiinst = wave_dev->wiinst;
1319 unsigned int mask = 0;
1321 unsigned long flags;
1323 DPF(4, "emu10k1_audio_poll()\n");
1325 if (file->f_mode & FMODE_WRITE)
1326 poll_wait(file, &woinst->wait_queue, wait);
1328 if (file->f_mode & FMODE_READ)
1329 poll_wait(file, &wiinst->wait_queue, wait);
1331 if (file->f_mode & FMODE_WRITE) {
1332 spin_lock_irqsave(&woinst->lock, flags);
1334 if (woinst->state & WAVE_STATE_OPEN) {
1335 emu10k1_waveout_update(woinst);
1336 emu10k1_waveout_getxfersize(woinst, &bytestocopy);
1338 if (bytestocopy >= woinst->buffer.fragment_size)
1339 mask |= POLLOUT | POLLWRNORM;
1341 mask |= POLLOUT | POLLWRNORM;
1343 spin_unlock_irqrestore(&woinst->lock, flags);
1346 if (file->f_mode & FMODE_READ) {
1347 spin_lock_irqsave(&wiinst->lock, flags);
1349 if (wiinst->state & WAVE_STATE_OPEN) {
1350 emu10k1_wavein_update(wave_dev->card, wiinst);
1351 emu10k1_wavein_getxfersize(wiinst, &bytestocopy);
1353 if (bytestocopy >= wiinst->buffer.fragment_size)
1354 mask |= POLLIN | POLLRDNORM;
1357 spin_unlock_irqrestore(&wiinst->lock, flags);
1363 static void calculate_ofrag(struct woinst *woinst)
1365 struct waveout_buffer *buffer = &woinst->buffer;
1368 if (buffer->fragment_size)
1371 if (!buffer->ossfragshift) {
1372 fragsize = (woinst->format.bytespervoicesample * woinst->format.samplingrate * WAVEOUT_DEFAULTFRAGLEN) / 1000 - 1;
1376 buffer->ossfragshift++;
1380 if (buffer->ossfragshift < WAVEOUT_MINFRAGSHIFT)
1381 buffer->ossfragshift = WAVEOUT_MINFRAGSHIFT;
1383 buffer->fragment_size = 1 << buffer->ossfragshift;
1385 while (buffer->fragment_size * WAVEOUT_MINFRAGS > WAVEOUT_MAXBUFSIZE)
1386 buffer->fragment_size >>= 1;
1388 /* now we are sure that:
1389 (2^WAVEOUT_MINFRAGSHIFT) <= (fragment_size = 2^n) <= (WAVEOUT_MAXBUFSIZE / WAVEOUT_MINFRAGS)
1392 if (!buffer->numfrags) {
1395 numfrags = (woinst->format.bytespervoicesample * woinst->format.samplingrate * WAVEOUT_DEFAULTBUFLEN) /
1396 (buffer->fragment_size * 1000) - 1;
1398 buffer->numfrags = 1;
1402 buffer->numfrags <<= 1;
1406 if (buffer->numfrags < WAVEOUT_MINFRAGS)
1407 buffer->numfrags = WAVEOUT_MINFRAGS;
1409 if (buffer->numfrags * buffer->fragment_size > WAVEOUT_MAXBUFSIZE)
1410 buffer->numfrags = WAVEOUT_MAXBUFSIZE / buffer->fragment_size;
1412 if (buffer->numfrags < WAVEOUT_MINFRAGS)
1415 buffer->size = buffer->fragment_size * buffer->numfrags;
1416 buffer->pages = buffer->size / PAGE_SIZE + ((buffer->size % PAGE_SIZE) ? 1 : 0);
1418 DPD(2, " calculated playback fragment_size -> %d\n", buffer->fragment_size);
1419 DPD(2, " calculated playback numfrags -> %d\n", buffer->numfrags);
1424 static void calculate_ifrag(struct wiinst *wiinst)
1426 struct wavein_buffer *buffer = &wiinst->buffer;
1427 u32 fragsize, bufsize, size[4];
1430 if (buffer->fragment_size)
1433 if (!buffer->ossfragshift) {
1434 fragsize = (wiinst->format.bytespersec * WAVEIN_DEFAULTFRAGLEN) / 1000 - 1;
1438 buffer->ossfragshift++;
1442 if (buffer->ossfragshift < WAVEIN_MINFRAGSHIFT)
1443 buffer->ossfragshift = WAVEIN_MINFRAGSHIFT;
1445 buffer->fragment_size = 1 << buffer->ossfragshift;
1447 while (buffer->fragment_size * WAVEIN_MINFRAGS > WAVEIN_MAXBUFSIZE)
1448 buffer->fragment_size >>= 1;
1450 /* now we are sure that:
1451 (2^WAVEIN_MINFRAGSHIFT) <= (fragment_size = 2^n) <= (WAVEIN_MAXBUFSIZE / WAVEIN_MINFRAGS)
1455 if (!buffer->numfrags)
1456 buffer->numfrags = (wiinst->format.bytespersec * WAVEIN_DEFAULTBUFLEN) / (buffer->fragment_size * 1000) - 1;
1458 if (buffer->numfrags < WAVEIN_MINFRAGS)
1459 buffer->numfrags = WAVEIN_MINFRAGS;
1461 if (buffer->numfrags * buffer->fragment_size > WAVEIN_MAXBUFSIZE)
1462 buffer->numfrags = WAVEIN_MAXBUFSIZE / buffer->fragment_size;
1464 if (buffer->numfrags < WAVEIN_MINFRAGS)
1467 bufsize = buffer->fragment_size * buffer->numfrags;
1469 /* the buffer size for recording is restricted to certain values, adjust it now */
1470 if (bufsize >= 0x10000) {
1471 buffer->size = 0x10000;
1472 buffer->sizeregval = 0x1f;
1480 for (i = 0; i < 8; i++)
1481 for (j = 0; j < 4; j++)
1482 if (bufsize >= size[j]) {
1483 buffer->size = size[j];
1485 buffer->sizeregval = i * 4 + j + 1;
1489 if (buffer->size == 0) {
1491 buffer->sizeregval = 0x01;
1495 /* adjust the fragment size so that buffer size is an integer multiple */
1496 while (buffer->size % buffer->fragment_size)
1497 buffer->fragment_size >>= 1;
1499 buffer->numfrags = buffer->size / buffer->fragment_size;
1500 buffer->pages = buffer->size / PAGE_SIZE + ((buffer->size % PAGE_SIZE) ? 1 : 0);
1502 DPD(2, " calculated recording fragment_size -> %d\n", buffer->fragment_size);
1503 DPD(2, " calculated recording numfrags -> %d\n", buffer->numfrags);
1504 DPD(2, " buffer size register -> %#04x\n", buffer->sizeregval);
1509 void emu10k1_wavein_bh(unsigned long refdata)
1511 struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) refdata;
1512 struct wiinst *wiinst = wave_dev->wiinst;
1514 unsigned long flags;
1519 spin_lock_irqsave(&wiinst->lock, flags);
1521 if (!(wiinst->state & WAVE_STATE_STARTED)) {
1522 spin_unlock_irqrestore(&wiinst->lock, flags);
1526 emu10k1_wavein_update(wave_dev->card, wiinst);
1527 emu10k1_wavein_getxfersize(wiinst, &bytestocopy);
1529 spin_unlock_irqrestore(&wiinst->lock, flags);
1531 if (bytestocopy >= wiinst->buffer.fragment_size) {
1532 if (waitqueue_active(&wiinst->wait_queue))
1533 wake_up_interruptible(&wiinst->wait_queue);
1535 DPD(3, "Not enough transfer size, %d\n", bytestocopy);
1540 void emu10k1_waveout_bh(unsigned long refdata)
1542 struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) refdata;
1543 struct woinst *woinst = wave_dev->woinst;
1545 unsigned long flags;
1550 spin_lock_irqsave(&woinst->lock, flags);
1552 if (!(woinst->state & WAVE_STATE_STARTED)) {
1553 spin_unlock_irqrestore(&woinst->lock, flags);
1557 emu10k1_waveout_update(woinst);
1558 emu10k1_waveout_getxfersize(woinst, &bytestocopy);
1560 if (woinst->buffer.fill_silence) {
1561 spin_unlock_irqrestore(&woinst->lock, flags);
1562 emu10k1_waveout_fillsilence(woinst);
1564 spin_unlock_irqrestore(&woinst->lock, flags);
1566 if (bytestocopy >= woinst->buffer.fragment_size) {
1567 if (waitqueue_active(&woinst->wait_queue))
1568 wake_up_interruptible(&woinst->wait_queue);
1570 DPD(3, "Not enough transfer size -> %d\n", bytestocopy);
1575 struct file_operations emu10k1_audio_fops = {
1576 .owner = THIS_MODULE,
1577 .llseek = no_llseek,
1578 .read = emu10k1_audio_read,
1579 .write = emu10k1_audio_write,
1580 .poll = emu10k1_audio_poll,
1581 .ioctl = emu10k1_audio_ioctl,
1582 .mmap = emu10k1_audio_mmap,
1583 .open = emu10k1_audio_open,
1584 .release = emu10k1_audio_release,