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