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