File: /usr/src/linux/drivers/sound/emu10k1/audio.c
1 /*
2 **********************************************************************
3 * audio.c -- /dev/dsp interface for emu10k1 driver
4 * Copyright 1999, 2000 Creative Labs, Inc.
5 *
6 **********************************************************************
7 *
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
12 *
13 **********************************************************************
14 *
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.
19 *
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.
24 *
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,
28 * USA.
29 *
30 **********************************************************************
31 */
32
33 #define __NO_VERSION__
34 #include <linux/module.h>
35 #include <linux/poll.h>
36 #include <linux/slab.h>
37 #include <linux/version.h>
38 #include <linux/bitops.h>
39 #include <asm/io.h>
40 #include <linux/sched.h>
41 #include <linux/smp_lock.h>
42 #include <linux/wrapper.h>
43
44
45 #include "hwaccess.h"
46 #include "cardwo.h"
47 #include "cardwi.h"
48 #include "recmgr.h"
49 #include "irqmgr.h"
50 #include "audio.h"
51 #include "8010.h"
52 #include "passthrough.h"
53
54 static void calculate_ofrag(struct woinst *);
55 static void calculate_ifrag(struct wiinst *);
56
57 /* Audio file operations */
58 static ssize_t emu10k1_audio_read(struct file *file, char *buffer, size_t count, loff_t * ppos)
59 {
60 struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
61 struct wiinst *wiinst = wave_dev->wiinst;
62 ssize_t ret = 0;
63 unsigned long flags;
64
65 DPD(3, "emu10k1_audio_read(), buffer=%p, count=%d\n", buffer, (u32) count);
66
67 if (ppos != &file->f_pos)
68 return -ESPIPE;
69
70 if (!access_ok(VERIFY_WRITE, buffer, count))
71 return -EFAULT;
72
73 spin_lock_irqsave(&wiinst->lock, flags);
74
75 if (wiinst->mmapped) {
76 spin_unlock_irqrestore(&wiinst->lock, flags);
77 return -ENXIO;
78 }
79
80 if (wiinst->state == WAVE_STATE_CLOSED) {
81 calculate_ifrag(wiinst);
82
83 while (emu10k1_wavein_open(wave_dev) < 0) {
84 spin_unlock_irqrestore(&wiinst->lock, flags);
85
86 if (file->f_flags & O_NONBLOCK)
87 return -EAGAIN;
88
89 interruptible_sleep_on(&wave_dev->card->open_wait);
90
91 if (signal_pending(current))
92 return -ERESTARTSYS;
93
94 spin_lock_irqsave(&wiinst->lock, flags);
95 }
96 }
97
98 spin_unlock_irqrestore(&wiinst->lock, flags);
99
100 while (count > 0) {
101 u32 bytestocopy;
102
103 spin_lock_irqsave(&wiinst->lock, flags);
104
105 if (!(wiinst->state & WAVE_STATE_STARTED)
106 && (wave_dev->enablebits & PCM_ENABLE_INPUT))
107 emu10k1_wavein_start(wave_dev);
108
109 emu10k1_wavein_update(wave_dev->card, wiinst);
110 emu10k1_wavein_getxfersize(wiinst, &bytestocopy);
111
112 spin_unlock_irqrestore(&wiinst->lock, flags);
113
114 DPD(3, "bytestocopy --> %d\n", bytestocopy);
115
116 if ((bytestocopy >= wiinst->buffer.fragment_size)
117 || (bytestocopy >= count)) {
118 bytestocopy = min_t(u32, bytestocopy, count);
119
120 emu10k1_wavein_xferdata(wiinst, (u8 *) buffer, &bytestocopy);
121
122 count -= bytestocopy;
123 buffer += bytestocopy;
124 ret += bytestocopy;
125 }
126
127 if (count > 0) {
128 if ((file->f_flags & O_NONBLOCK)
129 || (!(wave_dev->enablebits & PCM_ENABLE_INPUT)))
130 return (ret ? ret : -EAGAIN);
131
132 interruptible_sleep_on(&wiinst->wait_queue);
133
134 if (signal_pending(current))
135 return (ret ? ret : -ERESTARTSYS);
136
137 }
138 }
139
140 DPD(3, "bytes copied -> %d\n", (u32) ret);
141
142 return ret;
143 }
144
145 static ssize_t emu10k1_audio_write(struct file *file, const char *buffer, size_t count, loff_t * ppos)
146 {
147 struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
148 struct woinst *woinst = wave_dev->woinst;
149 ssize_t ret;
150 unsigned long flags;
151
152 DPD(3, "emu10k1_audio_write(), buffer=%p, count=%d\n", buffer, (u32) count);
153
154 if (ppos != &file->f_pos)
155 return -ESPIPE;
156
157 if (!access_ok(VERIFY_READ, buffer, count))
158 return -EFAULT;
159
160 spin_lock_irqsave(&woinst->lock, flags);
161
162 if (woinst->mmapped) {
163 spin_unlock_irqrestore(&woinst->lock, flags);
164 return -ENXIO;
165 }
166
167 if (woinst->format.passthrough) {
168 int r;
169
170 woinst->buffer.ossfragshift = PT_BLOCKSIZE_LOG2;
171 woinst->buffer.numfrags = PT_BLOCKCOUNT;
172 calculate_ofrag(woinst);
173
174 r = emu10k1_pt_write(file, buffer, count);
175 spin_unlock_irqrestore(&woinst->lock, flags);
176 return r;
177 }
178
179 if (woinst->state == WAVE_STATE_CLOSED) {
180 calculate_ofrag(woinst);
181
182 while (emu10k1_waveout_open(wave_dev) < 0) {
183 spin_unlock_irqrestore(&woinst->lock, flags);
184
185 if (file->f_flags & O_NONBLOCK)
186 return -EAGAIN;
187
188 interruptible_sleep_on(&wave_dev->card->open_wait);
189
190 if (signal_pending(current))
191 return -ERESTARTSYS;
192
193 spin_lock_irqsave(&woinst->lock, flags);
194 }
195 }
196
197 spin_unlock_irqrestore(&woinst->lock, flags);
198
199 ret = 0;
200 if (count % woinst->format.bytespersample)
201 return -EINVAL;
202
203 count /= woinst->num_voices;
204
205 while (count > 0) {
206 u32 bytestocopy;
207
208 spin_lock_irqsave(&woinst->lock, flags);
209 emu10k1_waveout_update(woinst);
210 emu10k1_waveout_getxfersize(woinst, &bytestocopy);
211 spin_unlock_irqrestore(&woinst->lock, flags);
212
213 DPD(3, "bytestocopy --> %d\n", bytestocopy);
214
215 if ((bytestocopy >= woinst->buffer.fragment_size)
216 || (bytestocopy >= count)) {
217
218 bytestocopy = min_t(u32, bytestocopy, count);
219
220 emu10k1_waveout_xferdata(woinst, (u8 *) buffer, &bytestocopy);
221
222 count -= bytestocopy;
223 buffer += bytestocopy * woinst->num_voices;
224 ret += bytestocopy * woinst->num_voices;
225
226 spin_lock_irqsave(&woinst->lock, flags);
227 woinst->total_copied += bytestocopy;
228
229 if (!(woinst->state & WAVE_STATE_STARTED)
230 && (wave_dev->enablebits & PCM_ENABLE_OUTPUT)
231 && (woinst->total_copied >= woinst->buffer.fragment_size))
232 emu10k1_waveout_start(wave_dev);
233
234 spin_unlock_irqrestore(&woinst->lock, flags);
235 }
236
237 if (count > 0) {
238 if ((file->f_flags & O_NONBLOCK)
239 || (!(wave_dev->enablebits & PCM_ENABLE_OUTPUT)))
240 return (ret ? ret : -EAGAIN);
241
242 interruptible_sleep_on(&woinst->wait_queue);
243
244 if (signal_pending(current))
245 return (ret ? ret : -ERESTARTSYS);
246 }
247 }
248
249 DPD(3, "bytes copied -> %d\n", (u32) ret);
250
251 return ret;
252 }
253
254 static int emu10k1_audio_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
255 {
256 struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
257 struct woinst *woinst = NULL;
258 struct wiinst *wiinst = NULL;
259 int val = 0;
260 u32 bytestocopy;
261 unsigned long flags;
262
263 DPF(4, "emu10k1_audio_ioctl()\n");
264
265 if (file->f_mode & FMODE_WRITE)
266 woinst = wave_dev->woinst;
267
268 if (file->f_mode & FMODE_READ)
269 wiinst = wave_dev->wiinst;
270
271 switch (cmd) {
272 case OSS_GETVERSION:
273 DPF(2, "OSS_GETVERSION:\n");
274 return put_user(SOUND_VERSION, (int *) arg);
275
276 case SNDCTL_DSP_RESET:
277 DPF(2, "SNDCTL_DSP_RESET:\n");
278 wave_dev->enablebits = PCM_ENABLE_OUTPUT | PCM_ENABLE_INPUT;
279
280 if (file->f_mode & FMODE_WRITE) {
281 spin_lock_irqsave(&woinst->lock, flags);
282
283 if (woinst->state & WAVE_STATE_OPEN) {
284 emu10k1_waveout_close(wave_dev);
285 }
286
287 woinst->mmapped = 0;
288 woinst->total_copied = 0;
289 woinst->total_played = 0;
290 woinst->blocks = 0;
291
292 spin_unlock_irqrestore(&woinst->lock, flags);
293 }
294
295 if (file->f_mode & FMODE_READ) {
296 spin_lock_irqsave(&wiinst->lock, flags);
297
298 if (wiinst->state & WAVE_STATE_OPEN) {
299 emu10k1_wavein_close(wave_dev);
300 }
301
302 wiinst->mmapped = 0;
303 wiinst->total_recorded = 0;
304 wiinst->blocks = 0;
305 spin_unlock_irqrestore(&wiinst->lock, flags);
306 }
307
308 break;
309
310 case SNDCTL_DSP_SYNC:
311 DPF(2, "SNDCTL_DSP_SYNC:\n");
312
313 if (file->f_mode & FMODE_WRITE) {
314
315 spin_lock_irqsave(&woinst->lock, flags);
316
317 if (woinst->state & WAVE_STATE_OPEN) {
318
319 if (woinst->state & WAVE_STATE_STARTED)
320 while ((woinst->total_played < woinst->total_copied)
321 && !signal_pending(current)) {
322 spin_unlock_irqrestore(&woinst->lock, flags);
323 interruptible_sleep_on(&woinst->wait_queue);
324 spin_lock_irqsave(&woinst->lock, flags);
325 }
326 emu10k1_waveout_close(wave_dev);
327 }
328
329 woinst->mmapped = 0;
330 woinst->total_copied = 0;
331 woinst->total_played = 0;
332 woinst->blocks = 0;
333
334 spin_unlock_irqrestore(&woinst->lock, flags);
335 }
336
337 if (file->f_mode & FMODE_READ) {
338 spin_lock_irqsave(&wiinst->lock, flags);
339
340 if (wiinst->state & WAVE_STATE_OPEN) {
341 emu10k1_wavein_close(wave_dev);
342 }
343
344 wiinst->mmapped = 0;
345 wiinst->total_recorded = 0;
346 wiinst->blocks = 0;
347 spin_unlock_irqrestore(&wiinst->lock, flags);
348 }
349
350 break;
351
352 case SNDCTL_DSP_SETDUPLEX:
353 DPF(2, "SNDCTL_DSP_SETDUPLEX:\n");
354 break;
355
356 case SNDCTL_DSP_GETCAPS:
357 DPF(2, "SNDCTL_DSP_GETCAPS:\n");
358 return put_user(DSP_CAP_DUPLEX | DSP_CAP_REALTIME | DSP_CAP_TRIGGER | DSP_CAP_MMAP | DSP_CAP_COPROC, (int *) arg);
359
360 case SNDCTL_DSP_SPEED:
361 DPF(2, "SNDCTL_DSP_SPEED:\n");
362
363 if (get_user(val, (int *) arg))
364 return -EFAULT;
365
366 DPD(2, "val is %d\n", val);
367
368 if (val > 0) {
369 if (file->f_mode & FMODE_READ) {
370 struct wave_format format;
371
372 spin_lock_irqsave(&wiinst->lock, flags);
373
374 format = wiinst->format;
375 format.samplingrate = val;
376
377 if (emu10k1_wavein_setformat(wave_dev, &format) < 0) {
378 spin_unlock_irqrestore(&wiinst->lock, flags);
379 return -EINVAL;
380 }
381
382 val = wiinst->format.samplingrate;
383
384 spin_unlock_irqrestore(&wiinst->lock, flags);
385
386 DPD(2, "set recording sampling rate -> %d\n", val);
387 }
388
389 if (file->f_mode & FMODE_WRITE) {
390 struct wave_format format;
391
392 spin_lock_irqsave(&woinst->lock, flags);
393
394 format = woinst->format;
395 format.samplingrate = val;
396
397 if (emu10k1_waveout_setformat(wave_dev, &format) < 0) {
398 spin_unlock_irqrestore(&woinst->lock, flags);
399 return -EINVAL;
400 }
401
402 val = woinst->format.samplingrate;
403
404 spin_unlock_irqrestore(&woinst->lock, flags);
405
406 DPD(2, "set playback sampling rate -> %d\n", val);
407 }
408
409 return put_user(val, (int *) arg);
410 } else {
411 if (file->f_mode & FMODE_READ)
412 val = wiinst->format.samplingrate;
413 else if (file->f_mode & FMODE_WRITE)
414 val = woinst->format.samplingrate;
415
416 return put_user(val, (int *) arg);
417 }
418 break;
419
420 case SNDCTL_DSP_STEREO:
421 DPF(2, "SNDCTL_DSP_STEREO:\n");
422
423 if (get_user(val, (int *) arg))
424 return -EFAULT;
425
426 DPD(2, " val is %d\n", val);
427
428 if (file->f_mode & FMODE_READ) {
429 struct wave_format format;
430
431 spin_lock_irqsave(&wiinst->lock, flags);
432
433 format = wiinst->format;
434 format.channels = val ? 2 : 1;
435
436 if (emu10k1_wavein_setformat(wave_dev, &format) < 0) {
437 spin_unlock_irqrestore(&wiinst->lock, flags);
438 return -EINVAL;
439 }
440
441 val = wiinst->format.channels - 1;
442
443 spin_unlock_irqrestore(&wiinst->lock, flags);
444 DPD(2, "set recording stereo -> %d\n", val);
445 }
446
447 if (file->f_mode & FMODE_WRITE) {
448 struct wave_format format;
449
450 spin_lock_irqsave(&woinst->lock, flags);
451
452 format = woinst->format;
453 format.channels = val ? 2 : 1;
454
455 if (emu10k1_waveout_setformat(wave_dev, &format) < 0) {
456 spin_unlock_irqrestore(&woinst->lock, flags);
457 return -EINVAL;
458 }
459
460 val = woinst->format.channels - 1;
461
462 spin_unlock_irqrestore(&woinst->lock, flags);
463
464 DPD(2, "set playback stereo -> %d\n", val);
465 }
466
467 return put_user(val, (int *) arg);
468
469 break;
470
471 case SNDCTL_DSP_CHANNELS:
472 DPF(2, "SNDCTL_DSP_CHANNELS:\n");
473
474 if (get_user(val, (int *) arg))
475 return -EFAULT;
476
477 DPD(2, " val is %d\n", val);
478
479 if (val > 0) {
480 if (file->f_mode & FMODE_READ) {
481 struct wave_format format;
482
483 spin_lock_irqsave(&wiinst->lock, flags);
484
485 format = wiinst->format;
486 format.channels = val;
487
488 if (emu10k1_wavein_setformat(wave_dev, &format) < 0) {
489 spin_unlock_irqrestore(&wiinst->lock, flags);
490 return -EINVAL;
491 }
492 val = wiinst->format.channels;
493
494 spin_unlock_irqrestore(&wiinst->lock, flags);
495 DPD(2, "set recording number of channels -> %d\n", val);
496 }
497
498 if (file->f_mode & FMODE_WRITE) {
499 struct wave_format format;
500
501 spin_lock_irqsave(&woinst->lock, flags);
502
503 format = woinst->format;
504 format.channels = val;
505
506 if (emu10k1_waveout_setformat(wave_dev, &format) < 0) {
507 spin_unlock_irqrestore(&woinst->lock, flags);
508 return -EINVAL;
509 }
510
511 val = woinst->format.channels;
512
513 spin_unlock_irqrestore(&woinst->lock, flags);
514 DPD(2, "set playback number of channels -> %d\n", val);
515 }
516
517 return put_user(val, (int *) arg);
518 } else {
519 if (file->f_mode & FMODE_READ)
520 val = wiinst->format.channels;
521 else if (file->f_mode & FMODE_WRITE)
522 val = woinst->format.channels;
523
524 return put_user(val, (int *) arg);
525 }
526 break;
527
528 case SNDCTL_DSP_GETFMTS:
529 DPF(2, "SNDCTL_DSP_GETFMTS:\n");
530
531 if (file->f_mode & FMODE_READ)
532 val = AFMT_S16_LE;
533 else if (file->f_mode & FMODE_WRITE) {
534 val = AFMT_S16_LE | AFMT_U8;
535 if (emu10k1_find_control_gpr(&wave_dev->card->mgr,
536 wave_dev->card->pt.patch_name,
537 wave_dev->card->pt.enable_gpr_name) >= 0)
538 val |= AFMT_AC3;
539 }
540 return put_user(val, (int *) arg);
541
542 case SNDCTL_DSP_SETFMT: /* Same as SNDCTL_DSP_SAMPLESIZE */
543 DPF(2, "SNDCTL_DSP_SETFMT:\n");
544
545 if (get_user(val, (int *) arg))
546 return -EFAULT;
547
548 DPD(2, " val is %d\n", val);
549
550 if (val != AFMT_QUERY) {
551 if (file->f_mode & FMODE_READ) {
552 struct wave_format format;
553
554 spin_lock_irqsave(&wiinst->lock, flags);
555
556 format = wiinst->format;
557 format.id = val;
558
559 if (emu10k1_wavein_setformat(wave_dev, &format) < 0) {
560 spin_unlock_irqrestore(&wiinst->lock, flags);
561 return -EINVAL;
562 }
563
564 val = wiinst->format.id;
565
566 spin_unlock_irqrestore(&wiinst->lock, flags);
567 DPD(2, "set recording format -> %d\n", val);
568 }
569
570 if (file->f_mode & FMODE_WRITE) {
571 struct wave_format format;
572
573 spin_lock_irqsave(&woinst->lock, flags);
574
575 format = woinst->format;
576 format.id = val;
577
578 if (emu10k1_waveout_setformat(wave_dev, &format) < 0) {
579 spin_unlock_irqrestore(&woinst->lock, flags);
580 return -EINVAL;
581 }
582
583 val = woinst->format.id;
584
585 spin_unlock_irqrestore(&woinst->lock, flags);
586 DPD(2, "set playback format -> %d\n", val);
587 }
588
589 return put_user(val, (int *) arg);
590 } else {
591 if (file->f_mode & FMODE_READ)
592 val = wiinst->format.id;
593 else if (file->f_mode & FMODE_WRITE)
594 val = woinst->format.id;
595
596 return put_user(val, (int *) arg);
597 }
598 break;
599
600 case SOUND_PCM_READ_BITS:
601
602 if (file->f_mode & FMODE_READ)
603 val = wiinst->format.bitsperchannel;
604 else if (file->f_mode & FMODE_WRITE)
605 val = woinst->format.bitsperchannel;
606
607 return put_user(val, (int *) arg);
608
609 case SOUND_PCM_READ_RATE:
610
611 if (file->f_mode & FMODE_READ)
612 val = wiinst->format.samplingrate;
613 else if (file->f_mode & FMODE_WRITE)
614 val = woinst->format.samplingrate;
615
616 return put_user(val, (int *) arg);
617
618 case SOUND_PCM_READ_CHANNELS:
619
620 if (file->f_mode & FMODE_READ)
621 val = wiinst->format.channels;
622 else if (file->f_mode & FMODE_WRITE)
623 val = woinst->format.channels;
624
625 return put_user(val, (int *) arg);
626
627 case SOUND_PCM_WRITE_FILTER:
628 DPF(2, "SOUND_PCM_WRITE_FILTER: not implemented\n");
629 break;
630
631 case SOUND_PCM_READ_FILTER:
632 DPF(2, "SOUND_PCM_READ_FILTER: not implemented\n");
633 break;
634
635 case SNDCTL_DSP_SETSYNCRO:
636 DPF(2, "SNDCTL_DSP_SETSYNCRO: not implemented\n");
637 break;
638
639 case SNDCTL_DSP_GETTRIGGER:
640 DPF(2, "SNDCTL_DSP_GETTRIGGER:\n");
641
642 if (file->f_mode & FMODE_WRITE && (wave_dev->enablebits & PCM_ENABLE_OUTPUT))
643 val |= PCM_ENABLE_OUTPUT;
644
645 if (file->f_mode & FMODE_READ && (wave_dev->enablebits & PCM_ENABLE_INPUT))
646 val |= PCM_ENABLE_INPUT;
647
648 return put_user(val, (int *) arg);
649
650 case SNDCTL_DSP_SETTRIGGER:
651 DPF(2, "SNDCTL_DSP_SETTRIGGER:\n");
652
653 if (get_user(val, (int *) arg))
654 return -EFAULT;
655
656 if (file->f_mode & FMODE_WRITE) {
657 spin_lock_irqsave(&woinst->lock, flags);
658
659 if (val & PCM_ENABLE_OUTPUT) {
660 wave_dev->enablebits |= PCM_ENABLE_OUTPUT;
661 if (woinst->state & WAVE_STATE_OPEN)
662 emu10k1_waveout_start(wave_dev);
663 } else {
664 wave_dev->enablebits &= ~PCM_ENABLE_OUTPUT;
665 if (woinst->state & WAVE_STATE_STARTED)
666 emu10k1_waveout_stop(wave_dev);
667 }
668
669 spin_unlock_irqrestore(&woinst->lock, flags);
670 }
671
672 if (file->f_mode & FMODE_READ) {
673 spin_lock_irqsave(&wiinst->lock, flags);
674
675 if (val & PCM_ENABLE_INPUT) {
676 wave_dev->enablebits |= PCM_ENABLE_INPUT;
677 if (wiinst->state & WAVE_STATE_OPEN)
678 emu10k1_wavein_start(wave_dev);
679 } else {
680 wave_dev->enablebits &= ~PCM_ENABLE_INPUT;
681 if (wiinst->state & WAVE_STATE_STARTED)
682 emu10k1_wavein_stop(wave_dev);
683 }
684
685 spin_unlock_irqrestore(&wiinst->lock, flags);
686 }
687 break;
688
689 case SNDCTL_DSP_GETOSPACE:
690 {
691 audio_buf_info info;
692
693 DPF(4, "SNDCTL_DSP_GETOSPACE:\n");
694
695 if (!(file->f_mode & FMODE_WRITE))
696 return -EINVAL;
697
698 spin_lock_irqsave(&woinst->lock, flags);
699
700 if (woinst->state & WAVE_STATE_OPEN) {
701 emu10k1_waveout_update(woinst);
702 emu10k1_waveout_getxfersize(woinst, &bytestocopy);
703 info.bytes = bytestocopy;
704 } else {
705 calculate_ofrag(woinst);
706 info.bytes = woinst->buffer.size;
707 }
708 spin_unlock_irqrestore(&woinst->lock, flags);
709
710 info.bytes *= woinst->num_voices;
711 info.fragsize = woinst->buffer.fragment_size * woinst->num_voices;
712 info.fragstotal = woinst->buffer.numfrags * woinst->num_voices;
713 info.fragments = info.bytes / info.fragsize;
714
715 if (copy_to_user((int *) arg, &info, sizeof(info)))
716 return -EFAULT;
717 }
718 break;
719
720 case SNDCTL_DSP_GETISPACE:
721 {
722 audio_buf_info info;
723
724 DPF(4, "SNDCTL_DSP_GETISPACE:\n");
725
726 if (!(file->f_mode & FMODE_READ))
727 return -EINVAL;
728
729 spin_lock_irqsave(&wiinst->lock, flags);
730 if (wiinst->state & WAVE_STATE_OPEN) {
731 emu10k1_wavein_update(wave_dev->card, wiinst);
732 emu10k1_wavein_getxfersize(wiinst, &bytestocopy);
733 info.bytes = bytestocopy;
734 } else {
735 calculate_ifrag(wiinst);
736 info.bytes = 0;
737 }
738 spin_unlock_irqrestore(&wiinst->lock, flags);
739
740 info.fragstotal = wiinst->buffer.numfrags;
741 info.fragments = info.bytes / wiinst->buffer.fragment_size;
742 info.fragsize = wiinst->buffer.fragment_size;
743
744 if (copy_to_user((int *) arg, &info, sizeof(info)))
745 return -EFAULT;
746 }
747 break;
748
749 case SNDCTL_DSP_NONBLOCK:
750 DPF(2, "SNDCTL_DSP_NONBLOCK:\n");
751
752 file->f_flags |= O_NONBLOCK;
753 break;
754
755 case SNDCTL_DSP_GETODELAY:
756 DPF(4, "SNDCTL_DSP_GETODELAY:\n");
757
758 if (!(file->f_mode & FMODE_WRITE))
759 return -EINVAL;
760
761 spin_lock_irqsave(&woinst->lock, flags);
762 if (woinst->state & WAVE_STATE_OPEN) {
763 emu10k1_waveout_update(woinst);
764 emu10k1_waveout_getxfersize(woinst, &bytestocopy);
765 val = woinst->buffer.size - bytestocopy;
766 } else
767 val = 0;
768
769 val *= woinst->num_voices;
770 spin_unlock_irqrestore(&woinst->lock, flags);
771
772 return put_user(val, (int *) arg);
773
774 case SNDCTL_DSP_GETIPTR:
775 {
776 count_info cinfo;
777
778 DPF(4, "SNDCTL_DSP_GETIPTR: \n");
779
780 if (!(file->f_mode & FMODE_READ))
781 return -EINVAL;
782
783 spin_lock_irqsave(&wiinst->lock, flags);
784
785 if (wiinst->state & WAVE_STATE_OPEN) {
786 emu10k1_wavein_update(wave_dev->card, wiinst);
787 cinfo.ptr = wiinst->buffer.hw_pos;
788 cinfo.bytes = cinfo.ptr + wiinst->total_recorded - wiinst->total_recorded % wiinst->buffer.size;
789 cinfo.blocks = cinfo.bytes / wiinst->buffer.fragment_size - wiinst->blocks;
790 wiinst->blocks = cinfo.bytes / wiinst->buffer.fragment_size;
791 } else {
792 cinfo.ptr = 0;
793 cinfo.bytes = 0;
794 cinfo.blocks = 0;
795 }
796
797 if(wiinst->mmapped)
798 wiinst->buffer.bytestocopy %= wiinst->buffer.fragment_size;
799
800 spin_unlock_irqrestore(&wiinst->lock, flags);
801
802 if (copy_to_user((void *) arg, &cinfo, sizeof(cinfo)))
803 return -EFAULT;
804 }
805 break;
806
807 case SNDCTL_DSP_GETOPTR:
808 {
809 count_info cinfo;
810
811 DPF(4, "SNDCTL_DSP_GETOPTR:\n");
812
813 if (!(file->f_mode & FMODE_WRITE))
814 return -EINVAL;
815
816 spin_lock_irqsave(&woinst->lock, flags);
817
818 if (woinst->state & WAVE_STATE_OPEN ||
819 (woinst->format.passthrough && wave_dev->card->pt.state)) {
820 int num_fragments;
821 if (woinst->format.passthrough) {
822 emu10k1_pt_waveout_update(wave_dev);
823 cinfo.bytes = woinst->total_played;
824 } else {
825 emu10k1_waveout_update(woinst);
826 cinfo.bytes = woinst->total_played;
827 }
828 cinfo.ptr = woinst->buffer.hw_pos;
829 num_fragments = cinfo.bytes / woinst->buffer.fragment_size;
830 cinfo.blocks = num_fragments - woinst->blocks;
831 woinst->blocks = num_fragments;
832
833 cinfo.bytes *= woinst->num_voices;
834 cinfo.ptr *= woinst->num_voices;
835 } else {
836 cinfo.ptr = 0;
837 cinfo.bytes = 0;
838 cinfo.blocks = 0;
839 }
840
841 if (woinst->mmapped)
842 woinst->buffer.free_bytes %= woinst->buffer.fragment_size;
843
844 spin_unlock_irqrestore(&woinst->lock, flags);
845
846 if (copy_to_user((void *) arg, &cinfo, sizeof(cinfo)))
847 return -EFAULT;
848 }
849 break;
850
851 case SNDCTL_DSP_GETBLKSIZE:
852 DPF(2, "SNDCTL_DSP_GETBLKSIZE:\n");
853
854 if (file->f_mode & FMODE_WRITE) {
855 spin_lock_irqsave(&woinst->lock, flags);
856
857 calculate_ofrag(woinst);
858 val = woinst->buffer.fragment_size * woinst->num_voices;
859
860 spin_unlock_irqrestore(&woinst->lock, flags);
861 }
862
863 if (file->f_mode & FMODE_READ) {
864 spin_lock_irqsave(&wiinst->lock, flags);
865
866 calculate_ifrag(wiinst);
867 val = wiinst->buffer.fragment_size;
868
869 spin_unlock_irqrestore(&wiinst->lock, flags);
870 }
871
872 return put_user(val, (int *) arg);
873
874 break;
875
876 case SNDCTL_DSP_POST:
877 if (file->f_mode & FMODE_WRITE) {
878 spin_lock_irqsave(&woinst->lock, flags);
879
880 if (!(woinst->state & WAVE_STATE_STARTED)
881 && (wave_dev->enablebits & PCM_ENABLE_OUTPUT)
882 && (woinst->total_copied > 0))
883 emu10k1_waveout_start(wave_dev);
884
885 spin_unlock_irqrestore(&woinst->lock, flags);
886 }
887
888 break;
889
890 case SNDCTL_DSP_SUBDIVIDE:
891 DPF(2, "SNDCTL_DSP_SUBDIVIDE: not implemented\n");
892 break;
893
894 case SNDCTL_DSP_SETFRAGMENT:
895 DPF(2, "SNDCTL_DSP_SETFRAGMENT:\n");
896
897 if (get_user(val, (int *) arg))
898 return -EFAULT;
899
900 DPD(2, "val is %#x\n", val);
901
902 if (val == 0)
903 return -EIO;
904
905 if (file->f_mode & FMODE_WRITE) {
906 /* digital pass-through fragment count and size are fixed values */
907 if (woinst->state & WAVE_STATE_OPEN || woinst->format.passthrough)
908 return -EINVAL; /* too late to change */
909
910 woinst->buffer.ossfragshift = val & 0xffff;
911 woinst->buffer.numfrags = (val >> 16) & 0xffff;
912 }
913
914 if (file->f_mode & FMODE_READ) {
915 if (wiinst->state & WAVE_STATE_OPEN)
916 return -EINVAL; /* too late to change */
917
918 wiinst->buffer.ossfragshift = val & 0xffff;
919 wiinst->buffer.numfrags = (val >> 16) & 0xffff;
920 }
921
922 break;
923
924 case SNDCTL_COPR_LOAD:
925 {
926 copr_buffer *buf;
927 u32 i;
928
929 DPF(4, "SNDCTL_COPR_LOAD:\n");
930
931 buf = kmalloc(sizeof(copr_buffer), GFP_KERNEL);
932 if (!buf)
933 return -ENOMEM;
934
935 if (copy_from_user(buf, (copr_buffer *) arg, sizeof(copr_buffer))) {
936 kfree (buf);
937 return -EFAULT;
938 }
939
940 if ((buf->command != CMD_READ) && (buf->command != CMD_WRITE)) {
941 kfree (buf);
942 return -EINVAL;
943 }
944 #ifdef DBGEMU
945 if ( (buf->offs < 0) || (buf->offs + buf->len > 0x800) || (buf->len > 1000)) {
946 #else
947 if ( ((buf->offs < 0x100 ) || (buf->offs + buf->len > 0x800) || (buf->len > 1000))
948 && !( ( buf->offs == DBG) && (buf->len ==1) )){
949 #endif
950 kfree(buf);
951 return -EINVAL;
952 }
953
954 if (buf->command == CMD_READ) {
955 for (i = 0; i < buf->len; i++)
956 ((u32 *) buf->data)[i] = sblive_readptr(wave_dev->card, buf->offs + i, 0);
957
958 if (copy_to_user((copr_buffer *) arg, buf, sizeof(copr_buffer))) {
959 kfree(buf);
960 return -EFAULT;
961 }
962 } else {
963 for (i = 0; i < buf->len; i++)
964 sblive_writeptr(wave_dev->card, buf->offs + i, 0, ((u32 *) buf->data)[i]);
965 }
966
967 kfree (buf);
968 break;
969 }
970
971 default: /* Default is unrecognized command */
972 DPD(2, "default: %#x\n", cmd);
973 return -EINVAL;
974 }
975 return 0;
976 }
977
978 static struct page *emu10k1_mm_nopage (struct vm_area_struct * vma, unsigned long address, int write_access)
979 {
980 struct emu10k1_wavedevice *wave_dev = vma->vm_private_data;
981 struct woinst *woinst = wave_dev->woinst;
982 struct wiinst *wiinst = wave_dev->wiinst;
983 struct page *dmapage;
984 unsigned long pgoff;
985 int rd, wr;
986
987 if (address > vma->vm_end) {
988 DPF(2, "EXIT, returning NOPAGE_SIGBUS\n");
989 return NOPAGE_SIGBUS; /* Disallow mremap */
990 }
991
992 pgoff = vma->vm_pgoff + ((address - vma->vm_start) >> PAGE_SHIFT);
993 if (woinst != NULL)
994 wr = woinst->mmapped;
995 else
996 wr = 0;
997
998 if (wiinst != NULL)
999 rd = wiinst->mmapped;
1000 else
1001 rd = 0;
1002
1003 /* if full-duplex (read+write) and we have two sets of bufs,
1004 * then the playback buffers come first, sez soundcard.c */
1005 if (wr) {
1006 if (pgoff >= woinst->buffer.pages) {
1007 pgoff -= woinst->buffer.pages;
1008 dmapage = virt_to_page ((u8 *) wiinst->buffer.addr + pgoff * PAGE_SIZE);
1009 } else
1010 dmapage = virt_to_page (woinst->buffer.mem[0].addr[pgoff]);
1011 } else {
1012 dmapage = virt_to_page ((u8 *) wiinst->buffer.addr + pgoff * PAGE_SIZE);
1013 }
1014
1015 get_page (dmapage);
1016 return dmapage;
1017 }
1018
1019 struct vm_operations_struct emu10k1_mm_ops = {
1020 nopage: emu10k1_mm_nopage,
1021 };
1022
1023 static int emu10k1_audio_mmap(struct file *file, struct vm_area_struct *vma)
1024 {
1025 struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
1026 unsigned long maxsize, size, offset, pgoffset;
1027 struct woinst *woinst = NULL;
1028 struct wiinst *wiinst = NULL;
1029 unsigned long flags;
1030
1031 DPF(2, "emu10k1_audio_mmap()\n");
1032
1033 maxsize = 0;
1034 if (vma->vm_flags & VM_WRITE) {
1035 woinst = wave_dev->woinst;
1036
1037 spin_lock_irqsave(&woinst->lock, flags);
1038
1039 /* No m'mapping possible for multichannel */
1040 if (woinst->num_voices > 1) {
1041 spin_unlock_irqrestore(&woinst->lock, flags);
1042 return -EINVAL;
1043 }
1044
1045 if (woinst->state == WAVE_STATE_CLOSED) {
1046 calculate_ofrag(woinst);
1047
1048 if (emu10k1_waveout_open(wave_dev) < 0) {
1049 spin_unlock_irqrestore(&woinst->lock, flags);
1050 ERROR();
1051 return -EINVAL;
1052 }
1053 }
1054
1055 woinst->mmapped = 1;
1056 maxsize += woinst->buffer.pages * PAGE_SIZE;
1057 spin_unlock_irqrestore(&woinst->lock, flags);
1058 }
1059
1060 if (vma->vm_flags & VM_READ) {
1061 wiinst = wave_dev->wiinst;
1062
1063 spin_lock_irqsave(&wiinst->lock, flags);
1064 if (wiinst->state == WAVE_STATE_CLOSED) {
1065 calculate_ifrag(wiinst);
1066
1067 if (emu10k1_wavein_open(wave_dev) < 0) {
1068 spin_unlock_irqrestore(&wiinst->lock, flags);
1069 ERROR();
1070 return -EINVAL;
1071 }
1072 }
1073
1074 wiinst->mmapped = 1;
1075 maxsize += wiinst->buffer.pages * PAGE_SIZE;
1076 spin_unlock_irqrestore(&wiinst->lock, flags);
1077 }
1078
1079 size = vma->vm_end - vma->vm_start;
1080 pgoffset = vma->vm_pgoff;
1081 offset = pgoffset << PAGE_SHIFT;
1082
1083 if (offset + size > maxsize)
1084 return -EINVAL;
1085
1086 vma->vm_flags |= VM_RESERVED;
1087 vma->vm_ops = &emu10k1_mm_ops;
1088 vma->vm_private_data = wave_dev;
1089
1090 return 0;
1091 }
1092
1093 static int emu10k1_audio_open(struct inode *inode, struct file *file)
1094 {
1095 int minor = MINOR(inode->i_rdev);
1096 struct emu10k1_card *card = NULL;
1097 struct list_head *entry;
1098 struct emu10k1_wavedevice *wave_dev;
1099
1100 DPF(2, "emu10k1_audio_open()\n");
1101
1102 /* Check for correct device to open */
1103
1104 list_for_each(entry, &emu10k1_devs) {
1105 card = list_entry(entry, struct emu10k1_card, list);
1106
1107 if (!((card->audio_dev ^ minor) & ~0xf) || !((card->audio_dev1 ^ minor) & ~0xf))
1108 goto match;
1109 }
1110
1111 return -ENODEV;
1112
1113 match:
1114
1115 wave_dev = (struct emu10k1_wavedevice *) kmalloc(sizeof(struct emu10k1_wavedevice), GFP_KERNEL);
1116
1117 if (wave_dev == NULL) {
1118 ERROR();
1119 return -ENOMEM;
1120 }
1121
1122 wave_dev->card = card;
1123 wave_dev->wiinst = NULL;
1124 wave_dev->woinst = NULL;
1125 wave_dev->enablebits = PCM_ENABLE_OUTPUT | PCM_ENABLE_INPUT; /* Default */
1126
1127 if (file->f_mode & FMODE_READ) {
1128 /* Recording */
1129 struct wiinst *wiinst;
1130
1131 if ((wiinst = (struct wiinst *) kmalloc(sizeof(struct wiinst), GFP_KERNEL)) == NULL) {
1132 ERROR();
1133 return -ENODEV;
1134 }
1135
1136 wiinst->recsrc = card->wavein.recsrc;
1137 wiinst->fxwc = card->wavein.fxwc;
1138
1139 switch (wiinst->recsrc) {
1140 case WAVERECORD_AC97:
1141 wiinst->format.id = AFMT_S16_LE;
1142 wiinst->format.samplingrate = 8000;
1143 wiinst->format.bitsperchannel = 16;
1144 wiinst->format.channels = 1;
1145 break;
1146 case WAVERECORD_MIC:
1147 wiinst->format.id = AFMT_S16_LE;
1148 wiinst->format.samplingrate = 8000;
1149 wiinst->format.bitsperchannel = 16;
1150 wiinst->format.channels = 1;
1151 break;
1152 case WAVERECORD_FX:
1153 wiinst->format.id = AFMT_S16_LE;
1154 wiinst->format.samplingrate = 48000;
1155 wiinst->format.bitsperchannel = 16;
1156 wiinst->format.channels = hweight32(wiinst->fxwc);
1157 break;
1158 default:
1159 BUG();
1160 break;
1161 }
1162
1163 wiinst->state = WAVE_STATE_CLOSED;
1164
1165 wiinst->buffer.ossfragshift = 0;
1166 wiinst->buffer.fragment_size = 0;
1167 wiinst->buffer.numfrags = 0;
1168
1169 init_waitqueue_head(&wiinst->wait_queue);
1170
1171 wiinst->mmapped = 0;
1172 wiinst->total_recorded = 0;
1173 wiinst->blocks = 0;
1174 wiinst->lock = SPIN_LOCK_UNLOCKED;
1175 tasklet_init(&wiinst->timer.tasklet, emu10k1_wavein_bh, (unsigned long) wave_dev);
1176 wave_dev->wiinst = wiinst;
1177 emu10k1_wavein_setformat(wave_dev, &wiinst->format);
1178 }
1179
1180 if (file->f_mode & FMODE_WRITE) {
1181 struct woinst *woinst;
1182 int i;
1183
1184 if ((woinst = (struct woinst *) kmalloc(sizeof(struct woinst), GFP_KERNEL)) == NULL) {
1185 ERROR();
1186 return -ENODEV;
1187 }
1188
1189 if (wave_dev->wiinst != NULL) {
1190 woinst->format = wave_dev->wiinst->format;
1191 } else {
1192 woinst->format.id = AFMT_U8;
1193 woinst->format.samplingrate = 8000;
1194 woinst->format.bitsperchannel = 8;
1195 woinst->format.channels = 1;
1196 }
1197
1198 woinst->state = WAVE_STATE_CLOSED;
1199
1200 woinst->buffer.fragment_size = 0;
1201 woinst->buffer.ossfragshift = 0;
1202 woinst->buffer.numfrags = 0;
1203 woinst->device = (card->audio_dev1 == minor);
1204 woinst->timer.state = TIMER_STATE_UNINSTALLED;
1205 woinst->num_voices = 1;
1206 for (i = 0; i < WAVEOUT_MAXVOICES; i++) {
1207 woinst->voice[i].usage = VOICE_USAGE_FREE;
1208 woinst->buffer.mem[i].emupageindex = -1;
1209 }
1210
1211 init_waitqueue_head(&woinst->wait_queue);
1212
1213 woinst->mmapped = 0;
1214 woinst->total_copied = 0;
1215 woinst->total_played = 0;
1216 woinst->blocks = 0;
1217 woinst->lock = SPIN_LOCK_UNLOCKED;
1218 tasklet_init(&woinst->timer.tasklet, emu10k1_waveout_bh, (unsigned long) wave_dev);
1219 wave_dev->woinst = woinst;
1220 emu10k1_waveout_setformat(wave_dev, &woinst->format);
1221 }
1222
1223 file->private_data = (void *) wave_dev;
1224
1225 return 0;
1226 }
1227
1228 static int emu10k1_audio_release(struct inode *inode, struct file *file)
1229 {
1230 struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
1231 struct emu10k1_card *card;
1232 unsigned long flags;
1233
1234 card = wave_dev->card;
1235
1236 DPF(2, "emu10k1_audio_release()\n");
1237
1238 if (file->f_mode & FMODE_WRITE) {
1239 struct woinst *woinst = wave_dev->woinst;
1240
1241 spin_lock_irqsave(&woinst->lock, flags);
1242
1243 if (woinst->format.passthrough && card->pt.state != PT_STATE_INACTIVE)
1244 emu10k1_pt_stop(card);
1245
1246 if (woinst->state & WAVE_STATE_OPEN) {
1247 if (woinst->state & WAVE_STATE_STARTED) {
1248 if (!(file->f_flags & O_NONBLOCK)) {
1249 while (!signal_pending(current)
1250 && (woinst->total_played < woinst->total_copied)) {
1251 DPF(4, "Buffer hasn't been totally played, sleep....\n");
1252 spin_unlock_irqrestore(&woinst->lock, flags);
1253 interruptible_sleep_on(&woinst->wait_queue);
1254 spin_lock_irqsave(&woinst->lock, flags);
1255 }
1256 }
1257 }
1258 emu10k1_waveout_close(wave_dev);
1259 }
1260
1261 spin_unlock_irqrestore(&woinst->lock, flags);
1262 /* wait for the tasklet (bottom-half) to finish */
1263 tasklet_kill(&woinst->timer.tasklet);
1264 kfree(wave_dev->woinst);
1265 }
1266
1267 if (file->f_mode & FMODE_READ) {
1268 struct wiinst *wiinst = wave_dev->wiinst;
1269
1270 spin_lock_irqsave(&wiinst->lock, flags);
1271
1272 if (wiinst->state & WAVE_STATE_OPEN) {
1273 emu10k1_wavein_close(wave_dev);
1274 }
1275
1276 spin_unlock_irqrestore(&wiinst->lock, flags);
1277 tasklet_kill(&wiinst->timer.tasklet);
1278 kfree(wave_dev->wiinst);
1279 }
1280
1281 kfree(wave_dev);
1282
1283 if (waitqueue_active(&card->open_wait))
1284 wake_up_interruptible(&card->open_wait);
1285
1286 return 0;
1287 }
1288
1289 /* FIXME sort out poll() + mmap() */
1290 static unsigned int emu10k1_audio_poll(struct file *file, struct poll_table_struct *wait)
1291 {
1292 struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) file->private_data;
1293 struct woinst *woinst = wave_dev->woinst;
1294 struct wiinst *wiinst = wave_dev->wiinst;
1295 unsigned int mask = 0;
1296 u32 bytestocopy;
1297 unsigned long flags;
1298
1299 DPF(4, "emu10k1_audio_poll()\n");
1300
1301 if (file->f_mode & FMODE_WRITE)
1302 poll_wait(file, &woinst->wait_queue, wait);
1303
1304 if (file->f_mode & FMODE_READ)
1305 poll_wait(file, &wiinst->wait_queue, wait);
1306
1307 if (file->f_mode & FMODE_WRITE) {
1308 spin_lock_irqsave(&woinst->lock, flags);
1309
1310 if (woinst->state & WAVE_STATE_OPEN) {
1311 emu10k1_waveout_update(woinst);
1312 emu10k1_waveout_getxfersize(woinst, &bytestocopy);
1313
1314 if (bytestocopy >= woinst->buffer.fragment_size)
1315 mask |= POLLOUT | POLLWRNORM;
1316 } else
1317 mask |= POLLOUT | POLLWRNORM;
1318
1319 spin_unlock_irqrestore(&woinst->lock, flags);
1320 }
1321
1322 if (file->f_mode & FMODE_READ) {
1323 spin_lock_irqsave(&wiinst->lock, flags);
1324
1325 if (wiinst->state == WAVE_STATE_CLOSED) {
1326 calculate_ifrag(wiinst);
1327 if (emu10k1_wavein_open(wave_dev) < 0) {
1328 spin_unlock_irqrestore(&wiinst->lock, flags);
1329 return (mask |= POLLERR);
1330 }
1331 }
1332
1333 if (!(wiinst->state & WAVE_STATE_STARTED)) {
1334 wave_dev->enablebits |= PCM_ENABLE_INPUT;
1335 emu10k1_wavein_start(wave_dev);
1336 }
1337 emu10k1_wavein_update(wave_dev->card, wiinst);
1338 emu10k1_wavein_getxfersize(wiinst, &bytestocopy);
1339
1340 if (bytestocopy >= wiinst->buffer.fragment_size)
1341 mask |= POLLIN | POLLRDNORM;
1342
1343 spin_unlock_irqrestore(&wiinst->lock, flags);
1344 }
1345
1346 return mask;
1347 }
1348
1349 static void calculate_ofrag(struct woinst *woinst)
1350 {
1351 struct waveout_buffer *buffer = &woinst->buffer;
1352 u32 fragsize;
1353
1354 if (buffer->fragment_size)
1355 return;
1356
1357 if (!buffer->ossfragshift) {
1358 fragsize = (woinst->format.bytespervoicesample * woinst->format.samplingrate * WAVEOUT_DEFAULTFRAGLEN) / 1000 - 1;
1359
1360 while (fragsize) {
1361 fragsize >>= 1;
1362 buffer->ossfragshift++;
1363 }
1364 }
1365
1366 if (buffer->ossfragshift < WAVEOUT_MINFRAGSHIFT)
1367 buffer->ossfragshift = WAVEOUT_MINFRAGSHIFT;
1368
1369 buffer->fragment_size = 1 << buffer->ossfragshift;
1370
1371 if (!buffer->numfrags) {
1372 u32 numfrags;
1373
1374 numfrags = (woinst->format.bytespervoicesample * woinst->format.samplingrate * WAVEOUT_DEFAULTBUFLEN) /
1375 (buffer->fragment_size * 1000) - 1;
1376
1377 buffer->numfrags = 1;
1378
1379 while (numfrags) {
1380 numfrags >>= 1;
1381 buffer->numfrags <<= 1;
1382 }
1383 }
1384
1385 if (buffer->numfrags < MINFRAGS)
1386 buffer->numfrags = MINFRAGS;
1387
1388 if (buffer->numfrags * buffer->fragment_size > WAVEOUT_MAXBUFSIZE) {
1389 buffer->numfrags = WAVEOUT_MAXBUFSIZE / buffer->fragment_size;
1390
1391 if (buffer->numfrags < MINFRAGS) {
1392 buffer->numfrags = MINFRAGS;
1393 buffer->fragment_size = WAVEOUT_MAXBUFSIZE / MINFRAGS;
1394 }
1395
1396 } else if (buffer->numfrags * buffer->fragment_size < WAVEOUT_MINBUFSIZE)
1397 buffer->numfrags = WAVEOUT_MINBUFSIZE / buffer->fragment_size;
1398
1399 buffer->size = buffer->fragment_size * buffer->numfrags;
1400 buffer->pages = buffer->size / PAGE_SIZE + ((buffer->size % PAGE_SIZE) ? 1 : 0);
1401
1402 DPD(2, " calculated playback fragment_size -> %d\n", buffer->fragment_size);
1403 DPD(2, " calculated playback numfrags -> %d\n", buffer->numfrags);
1404
1405 return;
1406 }
1407
1408 static void calculate_ifrag(struct wiinst *wiinst)
1409 {
1410 struct wavein_buffer *buffer = &wiinst->buffer;
1411 u32 fragsize, bufsize, size[4];
1412 int i, j;
1413
1414 if (buffer->fragment_size)
1415 return;
1416
1417 if (!buffer->ossfragshift) {
1418 fragsize = (wiinst->format.bytespersec * WAVEIN_DEFAULTFRAGLEN) / 1000 - 1;
1419
1420 while (fragsize) {
1421 fragsize >>= 1;
1422 buffer->ossfragshift++;
1423 }
1424 }
1425
1426 if (buffer->ossfragshift < WAVEIN_MINFRAGSHIFT)
1427 buffer->ossfragshift = WAVEIN_MINFRAGSHIFT;
1428
1429 buffer->fragment_size = 1 << buffer->ossfragshift;
1430
1431 if (!buffer->numfrags)
1432 buffer->numfrags = (wiinst->format.bytespersec * WAVEIN_DEFAULTBUFLEN) / (buffer->fragment_size * 1000) - 1;
1433
1434 if (buffer->numfrags < MINFRAGS)
1435 buffer->numfrags = MINFRAGS;
1436
1437 if (buffer->numfrags * buffer->fragment_size > WAVEIN_MAXBUFSIZE) {
1438 buffer->numfrags = WAVEIN_MAXBUFSIZE / buffer->fragment_size;
1439
1440 if (buffer->numfrags < MINFRAGS) {
1441 buffer->numfrags = MINFRAGS;
1442 buffer->fragment_size = WAVEIN_MAXBUFSIZE / MINFRAGS;
1443 }
1444 } else if (buffer->numfrags * buffer->fragment_size < WAVEIN_MINBUFSIZE)
1445 buffer->numfrags = WAVEIN_MINBUFSIZE / buffer->fragment_size;
1446
1447 bufsize = buffer->fragment_size * buffer->numfrags;
1448
1449 if (bufsize >= 0x10000) {
1450 buffer->size = 0x10000;
1451 buffer->sizeregval = 0x1f;
1452 } else {
1453 buffer->size = 0;
1454 size[0] = 384;
1455 size[1] = 448;
1456 size[2] = 512;
1457 size[3] = 640;
1458
1459 for (i = 0; i < 8; i++)
1460 for (j = 0; j < 4; j++)
1461 if (bufsize >= size[j]) {
1462 buffer->size = size[j];
1463 size[j] *= 2;
1464 buffer->sizeregval = i * 4 + j + 1;
1465 } else
1466 goto exitloop;
1467 exitloop:
1468 if (buffer->size == 0) {
1469 buffer->size = 384;
1470 buffer->sizeregval = 0x01;
1471 }
1472 }
1473
1474 buffer->numfrags = buffer->size / buffer->fragment_size;
1475 buffer->pages = buffer->size / PAGE_SIZE + ((buffer->size % PAGE_SIZE) ? 1 : 0);
1476 if (buffer->size % buffer->fragment_size)
1477 BUG();
1478
1479 DPD(2, " calculated recording fragment_size -> %d\n", buffer->fragment_size);
1480 DPD(2, " calculated recording numfrags -> %d\n", buffer->numfrags);
1481 DPD(2, " buffer size register -> %#04x\n", buffer->sizeregval);
1482
1483 return;
1484 }
1485
1486 void emu10k1_wavein_bh(unsigned long refdata)
1487 {
1488 struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) refdata;
1489 struct wiinst *wiinst = wave_dev->wiinst;
1490 u32 bytestocopy;
1491 unsigned long flags;
1492
1493 if (!wiinst)
1494 return;
1495
1496 spin_lock_irqsave(&wiinst->lock, flags);
1497
1498 if (!(wiinst->state & WAVE_STATE_STARTED)) {
1499 spin_unlock_irqrestore(&wiinst->lock, flags);
1500 return;
1501 }
1502
1503 emu10k1_wavein_update(wave_dev->card, wiinst);
1504 emu10k1_wavein_getxfersize(wiinst, &bytestocopy);
1505
1506 spin_unlock_irqrestore(&wiinst->lock, flags);
1507
1508 if (bytestocopy >= wiinst->buffer.fragment_size && waitqueue_active(&wiinst->wait_queue))
1509 wake_up_interruptible(&wiinst->wait_queue);
1510 else
1511 DPD(3, "Not enough transfer size, %d\n", bytestocopy);
1512
1513 return;
1514 }
1515
1516 void emu10k1_waveout_bh(unsigned long refdata)
1517 {
1518 struct emu10k1_wavedevice *wave_dev = (struct emu10k1_wavedevice *) refdata;
1519 struct woinst *woinst = wave_dev->woinst;
1520 u32 bytestocopy;
1521 unsigned long flags;
1522
1523 if (!woinst)
1524 return;
1525
1526 spin_lock_irqsave(&woinst->lock, flags);
1527
1528 if (!(woinst->state & WAVE_STATE_STARTED)) {
1529 spin_unlock_irqrestore(&woinst->lock, flags);
1530 return;
1531 }
1532
1533 emu10k1_waveout_update(woinst);
1534 emu10k1_waveout_getxfersize(woinst, &bytestocopy);
1535
1536 if (woinst->buffer.fill_silence) {
1537 spin_unlock_irqrestore(&woinst->lock, flags);
1538 emu10k1_waveout_fillsilence(woinst);
1539 } else
1540 spin_unlock_irqrestore(&woinst->lock, flags);
1541
1542 if (bytestocopy >= woinst->buffer.fragment_size && waitqueue_active(&woinst->wait_queue))
1543 wake_up_interruptible(&woinst->wait_queue);
1544 else
1545 DPD(3, "Not enough transfer size -> %d\n", bytestocopy);
1546
1547 return;
1548 }
1549
1550 struct file_operations emu10k1_audio_fops = {
1551 owner: THIS_MODULE,
1552 llseek: no_llseek,
1553 read: emu10k1_audio_read,
1554 write: emu10k1_audio_write,
1555 poll: emu10k1_audio_poll,
1556 ioctl: emu10k1_audio_ioctl,
1557 mmap: emu10k1_audio_mmap,
1558 open: emu10k1_audio_open,
1559 release: emu10k1_audio_release,
1560 };
1561