?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] DVB: frontend conversion #3
[linux-2.6/history.git] / sound / oss / forte.c
bloba4cd8418cc529dcaaecd32aae0feb7063313f12e
1 /*
2 * forte.c - ForteMedia FM801 OSS Driver
3 *
4 * Written by Martin K. Petersen <mkp@mkp.net>
5 * Copyright (C) 2002 Hewlett-Packard Company
6 * Portions Copyright (C) 2003 Martin K. Petersen
7 *
8 * Latest version: http://mkp.net/forte/
9 *
10 * Based upon the ALSA FM801 driver by Jaroslav Kysela and OSS drivers
11 * by Thomas Sailer, Alan Cox, Zach Brown, and Jeff Garzik. Thanks
12 * guys!
13 *
14 * This program is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU General Public License version
16 * 2 as published by the Free Software Foundation.
17 *
18 * This program is distributed in the hope that it will be useful, but
19 * WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 * General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
26 * USA
27 *
28 */
29
30 #include <linux/config.h>
31 #include <linux/module.h>
32 #include <linux/kernel.h>
33
34 #include <linux/init.h>
35 #include <linux/spinlock.h>
36 #include <linux/pci.h>
37
38 #include <linux/delay.h>
39 #include <linux/poll.h>
40
41 #include <linux/sound.h>
42 #include <linux/ac97_codec.h>
43 #include <linux/interrupt.h>
44
45 #include <linux/proc_fs.h>
46
47 #include <asm/uaccess.h>
48 #include <asm/io.h>
49
50 #define DRIVER_NAME "forte"
51 #define DRIVER_VERSION "$Id: forte.c,v 1.63 2003/03/01 05:32:42 mkp Exp $"
52 #define PFX DRIVER_NAME ": "
53
54 #undef M_DEBUG
55
56 #ifdef M_DEBUG
57 #define DPRINTK(args...) printk(KERN_WARNING args)
58 #else
59 #define DPRINTK(args...)
60 #endif
61
62 /* Card capabilities */
63 #define FORTE_CAPS (DSP_CAP_MMAP | DSP_CAP_TRIGGER)
64
65 /* Supported audio formats */
66 #define FORTE_FMTS (AFMT_U8 | AFMT_S16_LE)
67
68 /* Buffers */
69 #define FORTE_MIN_FRAG_SIZE 256
70 #define FORTE_MAX_FRAG_SIZE PAGE_SIZE
71 #define FORTE_DEF_FRAG_SIZE 256
72 #define FORTE_MIN_FRAGMENTS 2
73 #define FORTE_MAX_FRAGMENTS 256
74 #define FORTE_DEF_FRAGMENTS 2
75 #define FORTE_MIN_BUF_MSECS 500
76 #define FORTE_MAX_BUF_MSECS 1000
77
78 /* PCI BARs */
79 #define FORTE_PCM_VOL 0x00 /* PCM Output Volume */
80 #define FORTE_FM_VOL 0x02 /* FM Output Volume */
81 #define FORTE_I2S_VOL 0x04 /* I2S Volume */
82 #define FORTE_REC_SRC 0x06 /* Record Source */
83 #define FORTE_PLY_CTRL 0x08 /* Playback Control */
84 #define FORTE_PLY_COUNT 0x0a /* Playback Count */
85 #define FORTE_PLY_BUF1 0x0c /* Playback Buffer I */
86 #define FORTE_PLY_BUF2 0x10 /* Playback Buffer II */
87 #define FORTE_CAP_CTRL 0x14 /* Capture Control */
88 #define FORTE_CAP_COUNT 0x16 /* Capture Count */
89 #define FORTE_CAP_BUF1 0x18 /* Capture Buffer I */
90 #define FORTE_CAP_BUF2 0x1c /* Capture Buffer II */
91 #define FORTE_CODEC_CTRL 0x22 /* Codec Control */
92 #define FORTE_I2S_MODE 0x24 /* I2S Mode Control */
93 #define FORTE_VOLUME 0x26 /* Volume Up/Down/Mute Status */
94 #define FORTE_I2C_CTRL 0x29 /* I2C Control */
95 #define FORTE_AC97_CMD 0x2a /* AC'97 Command */
96 #define FORTE_AC97_DATA 0x2c /* AC'97 Data */
97 #define FORTE_MPU401_DATA 0x30 /* MPU401 Data */
98 #define FORTE_MPU401_CMD 0x31 /* MPU401 Command */
99 #define FORTE_GPIO_CTRL 0x52 /* General Purpose I/O Control */
100 #define FORTE_GEN_CTRL 0x54 /* General Control */
101 #define FORTE_IRQ_MASK 0x56 /* Interrupt Mask */
102 #define FORTE_IRQ_STATUS 0x5a /* Interrupt Status */
103 #define FORTE_OPL3_BANK0 0x68 /* OPL3 Status Read / Bank 0 Write */
104 #define FORTE_OPL3_DATA0 0x69 /* OPL3 Data 0 Write */
105 #define FORTE_OPL3_BANK1 0x6a /* OPL3 Bank 1 Write */
106 #define FORTE_OPL3_DATA1 0x6b /* OPL3 Bank 1 Write */
107 #define FORTE_POWERDOWN 0x70 /* Blocks Power Down Control */
108
109 #define FORTE_CAP_OFFSET FORTE_CAP_CTRL - FORTE_PLY_CTRL
110
111 #define FORTE_AC97_ADDR_SHIFT 10
112
113 /* Playback and record control register bits */
114 #define FORTE_BUF1_LAST (1<<1)
115 #define FORTE_BUF2_LAST (1<<2)
116 #define FORTE_START (1<<5)
117 #define FORTE_PAUSE (1<<6)
118 #define FORTE_IMMED_STOP (1<<7)
119 #define FORTE_RATE_SHIFT 8
120 #define FORTE_RATE_MASK (15 << FORTE_RATE_SHIFT)
121 #define FORTE_CHANNELS_4 (1<<12) /* Playback only */
122 #define FORTE_CHANNELS_6 (2<<12) /* Playback only */
123 #define FORTE_CHANNELS_6MS (3<<12) /* Playback only */
124 #define FORTE_CHANNELS_MASK (3<<12)
125 #define FORTE_16BIT (1<<14)
126 #define FORTE_STEREO (1<<15)
127
128 /* IRQ status bits */
129 #define FORTE_IRQ_PLAYBACK (1<<8)
130 #define FORTE_IRQ_CAPTURE (1<<9)
131 #define FORTE_IRQ_VOLUME (1<<14)
132 #define FORTE_IRQ_MPU (1<<15)
133
134 /* CODEC control */
135 #define FORTE_CC_CODEC_RESET (1<<5)
136 #define FORTE_CC_AC97_RESET (1<<6)
137
138 /* AC97 cmd */
139 #define FORTE_AC97_WRITE (0<<7)
140 #define FORTE_AC97_READ (1<<7)
141 #define FORTE_AC97_DP_INVALID (0<<8)
142 #define FORTE_AC97_DP_VALID (1<<8)
143 #define FORTE_AC97_PORT_RDY (0<<9)
144 #define FORTE_AC97_PORT_BSY (1<<9)
145
146
147 struct forte_channel {
148 const char *name;
149
150 unsigned short ctrl; /* Ctrl BAR contents */
151 unsigned long iobase; /* Ctrl BAR address */
152
153 wait_queue_head_t wait;
154
155 void *buf; /* Buffer */
156 dma_addr_t buf_handle; /* Buffer handle */
157
158 unsigned int record;
159 unsigned int format;
160 unsigned int rate;
161 unsigned int stereo;
162
163 unsigned int frag_sz; /* Current fragment size */
164 unsigned int frag_num; /* Current # of fragments */
165 unsigned int frag_msecs; /* Milliseconds per frag */
166 unsigned int buf_sz; /* Current buffer size */
167
168 unsigned int hwptr; /* Tail */
169 unsigned int swptr; /* Head */
170 unsigned int filled_frags; /* Fragments currently full */
171 unsigned int next_buf; /* Index of next buffer */
172
173 unsigned int active; /* Channel currently in use */
174 unsigned int mapped; /* mmap */
175
176 unsigned int buf_pages; /* Real size of buffer */
177 unsigned int nr_irqs; /* Number of interrupts */
178 unsigned int bytes; /* Total bytes */
179 unsigned int residue; /* Partial fragment */
180 };
181
182
183 struct forte_chip {
184 struct pci_dev *pci_dev;
185 unsigned long iobase;
186 int irq;
187
188 struct semaphore open_sem; /* Device access */
189 spinlock_t lock; /* State */
190
191 spinlock_t ac97_lock;
192 struct ac97_codec *ac97;
193
194 int multichannel;
195 int dsp; /* OSS handle */
196 int trigger; /* mmap I/O trigger */
197
198 struct forte_channel play;
199 struct forte_channel rec;
200 };
201
202
203 static int channels[] = { 2, 4, 6, };
204 static int rates[] = { 5500, 8000, 9600, 11025, 16000, 19200,
205 22050, 32000, 38400, 44100, 48000, };
206
207 static struct forte_chip *forte;
208 static int found;
209
210
211 /* AC97 Codec -------------------------------------------------------------- */
212
213
214 /**
215 * forte_ac97_wait:
216 * @chip: fm801 instance whose AC97 codec to wait on
217 *
218 * FIXME:
219 * Stop busy-waiting
220 */
221
222 static inline int
223 forte_ac97_wait (struct forte_chip *chip)
224 {
225 int i = 10000;
226
227 while ( (inw (chip->iobase + FORTE_AC97_CMD) & FORTE_AC97_PORT_BSY)
228 && i-- )
229 cpu_relax();
230
231 return i == 0;
232 }
233
234
235 /**
236 * forte_ac97_read:
237 * @codec: AC97 codec to read from
238 * @reg: register to read
239 */
240
241 u16
242 forte_ac97_read (struct ac97_codec *codec, u8 reg)
243 {
244 u16 ret = 0;
245 struct forte_chip *chip = codec->private_data;
246
247 spin_lock (&chip->ac97_lock);
248
249 /* Knock, knock */
250 if (forte_ac97_wait (chip)) {
251 printk (KERN_ERR PFX "ac97_read: Serial bus busy\n");
252 goto out;
253 }
254
255 /* Send read command */
256 outw (reg | (1<<7), chip->iobase + FORTE_AC97_CMD);
257
258 if (forte_ac97_wait (chip)) {
259 printk (KERN_ERR PFX "ac97_read: Bus busy reading reg 0x%x\n",
260 reg);
261 goto out;
262 }
263
264 /* Sanity checking */
265 if (inw (chip->iobase + FORTE_AC97_CMD) & FORTE_AC97_DP_INVALID) {
266 printk (KERN_ERR PFX "ac97_read: Invalid data port");
267 goto out;
268 }
269
270 /* Fetch result */
271 ret = inw (chip->iobase + FORTE_AC97_DATA);
272
273 out:
274 spin_unlock (&chip->ac97_lock);
275 return ret;
276 }
277
278
279 /**
280 * forte_ac97_write:
281 * @codec: AC97 codec to send command to
282 * @reg: register to write
283 * @val: value to write
284 */
285
286 void
287 forte_ac97_write (struct ac97_codec *codec, u8 reg, u16 val)
288 {
289 struct forte_chip *chip = codec->private_data;
290
291 spin_lock (&chip->ac97_lock);
292
293 /* Knock, knock */
294 if (forte_ac97_wait (chip)) {
295 printk (KERN_ERR PFX "ac97_write: Serial bus busy\n");
296 goto out;
297 }
298
299 outw (val, chip->iobase + FORTE_AC97_DATA);
300 outb (reg | FORTE_AC97_WRITE, chip->iobase + FORTE_AC97_CMD);
301
302 /* Wait for completion */
303 if (forte_ac97_wait (chip)) {
304 printk (KERN_ERR PFX "ac97_write: Bus busy after write\n");
305 goto out;
306 }
307
308 out:
309 spin_unlock (&chip->ac97_lock);
310 }
311
312
313 /* Mixer ------------------------------------------------------------------- */
314
315
316 /**
317 * forte_mixer_open:
318 * @inode:
319 * @file:
320 */
321
322 static int
323 forte_mixer_open (struct inode *inode, struct file *file)
324 {
325 struct forte_chip *chip = forte;
326 file->private_data = chip->ac97;
327 return 0;
328 }
329
330
331 /**
332 * forte_mixer_release:
333 * @inode:
334 * @file:
335 */
336
337 static int
338 forte_mixer_release (struct inode *inode, struct file *file)
339 {
340 /* We will welease Wodewick */
341 return 0;
342 }
343
344
345 /**
346 * forte_mixer_ioctl:
347 * @inode:
348 * @file:
349 */
350
351 static int
352 forte_mixer_ioctl (struct inode *inode, struct file *file,
353 unsigned int cmd, unsigned long arg)
354 {
355 struct ac97_codec *codec = (struct ac97_codec *) file->private_data;
356
357 return codec->mixer_ioctl (codec, cmd, arg);
358 }
359
360
361 static struct file_operations forte_mixer_fops = {
362 .owner = THIS_MODULE,
363 .llseek = no_llseek,
364 .ioctl = forte_mixer_ioctl,
365 .open = forte_mixer_open,
366 .release = forte_mixer_release,
367 };
368
369
370 /* Channel ----------------------------------------------------------------- */
371
372 /**
373 * forte_channel_reset:
374 * @channel: Channel to reset
375 *
376 * Locking: Must be called with lock held.
377 */
378
379 static void
380 forte_channel_reset (struct forte_channel *channel)
381 {
382 if (!channel || !channel->iobase)
383 return;
384
385 DPRINTK ("%s: channel = %s\n", __FUNCTION__, channel->name);
386
387 channel->ctrl &= ~FORTE_START;
388 outw (channel->ctrl, channel->iobase + FORTE_PLY_CTRL);
389
390 /* We always play at least two fragments, hence these defaults */
391 channel->hwptr = channel->frag_sz;
392 channel->next_buf = 1;
393 channel->swptr = 0;
394 channel->filled_frags = 0;
395 channel->active = 0;
396 channel->bytes = 0;
397 channel->nr_irqs = 0;
398 channel->mapped = 0;
399 channel->residue = 0;
400 }
401
402
403 /**
404 * forte_channel_start:
405 * @channel: Channel to start (record/playback)
406 *
407 * Locking: Must be called with lock held.
408 */
409
410 static void inline
411 forte_channel_start (struct forte_channel *channel)
412 {
413 if (!channel || !channel->iobase || channel->active)
414 return;
415
416 channel->ctrl &= ~(FORTE_PAUSE | FORTE_BUF1_LAST | FORTE_BUF2_LAST
417 | FORTE_IMMED_STOP);
418 channel->ctrl |= FORTE_START;
419 channel->active = 1;
420 outw (channel->ctrl, channel->iobase + FORTE_PLY_CTRL);
421 }
422
423
424 /**
425 * forte_channel_stop:
426 * @channel: Channel to stop
427 *
428 * Locking: Must be called with lock held.
429 */
430
431 static void inline
432 forte_channel_stop (struct forte_channel *channel)
433 {
434 if (!channel || !channel->iobase)
435 return;
436
437 channel->ctrl &= ~(FORTE_START | FORTE_PAUSE);
438 channel->ctrl |= FORTE_IMMED_STOP;
439
440 channel->active = 0;
441 outw (channel->ctrl, channel->iobase + FORTE_PLY_CTRL);
442 }
443
444
445 /**
446 * forte_channel_pause:
447 * @channel: Channel to pause
448 *
449 * Locking: Must be called with lock held.
450 */
451
452 static void inline
453 forte_channel_pause (struct forte_channel *channel)
454 {
455 if (!channel || !channel->iobase)
456 return;
457
458 channel->ctrl |= FORTE_PAUSE;
459
460 channel->active = 0;
461 outw (channel->ctrl, channel->iobase + FORTE_PLY_CTRL);
462 }
463
464
465 /**
466 * forte_channel_rate:
467 * @channel: Channel whose rate to set. Playback and record are
468 * independent.
469 * @rate: Channel rate in Hz
470 *
471 * Locking: Must be called with lock held.
472 */
473
474 static int
475 forte_channel_rate (struct forte_channel *channel, unsigned int rate)
476 {
477 int new_rate;
478
479 if (!channel || !channel->iobase)
480 return -EINVAL;
481
482 /* The FM801 only supports a handful of fixed frequencies.
483 * We find the value closest to what userland requested.
484 */
485 if (rate <= 6250) { rate = 5500; new_rate = 0; }
486 else if (rate <= 8800) { rate = 8000; new_rate = 1; }
487 else if (rate <= 10312) { rate = 9600; new_rate = 2; }
488 else if (rate <= 13512) { rate = 11025; new_rate = 3; }
489 else if (rate <= 17600) { rate = 16000; new_rate = 4; }
490 else if (rate <= 20625) { rate = 19200; new_rate = 5; }
491 else if (rate <= 27025) { rate = 22050; new_rate = 6; }
492 else if (rate <= 35200) { rate = 32000; new_rate = 7; }
493 else if (rate <= 41250) { rate = 38400; new_rate = 8; }
494 else if (rate <= 46050) { rate = 44100; new_rate = 9; }
495 else { rate = 48000; new_rate = 10; }
496
497 channel->ctrl &= ~FORTE_RATE_MASK;
498 channel->ctrl |= new_rate << FORTE_RATE_SHIFT;
499 channel->rate = rate;
500
501 DPRINTK ("%s: %s rate = %d\n", __FUNCTION__, channel->name, rate);
502
503 return rate;
504 }
505
506
507 /**
508 * forte_channel_format:
509 * @channel: Channel whose audio format to set
510 * @format: OSS format ID
511 *
512 * Locking: Must be called with lock held.
513 */
514
515 static int
516 forte_channel_format (struct forte_channel *channel, int format)
517 {
518 if (!channel || !channel->iobase)
519 return -EINVAL;
520
521 switch (format) {
522
523 case AFMT_QUERY:
524 break;
525
526 case AFMT_U8:
527 channel->ctrl &= ~FORTE_16BIT;
528 channel->format = AFMT_U8;
529 break;
530
531 case AFMT_S16_LE:
532 default:
533 channel->ctrl |= FORTE_16BIT;
534 channel->format = AFMT_S16_LE;
535 break;
536 }
537
538 DPRINTK ("%s: %s want %d format, got %d\n", __FUNCTION__, channel->name,
539 format, channel->format);
540
541 return channel->format;
542 }
543
544
545 /**
546 * forte_channel_stereo:
547 * @channel: Channel to toggle
548 * @stereo: 0 for Mono, 1 for Stereo
549 *
550 * Locking: Must be called with lock held.
551 */
552
553 static int
554 forte_channel_stereo (struct forte_channel *channel, unsigned int stereo)
555 {
556 int ret;
557
558 if (!channel || !channel->iobase)
559 return -EINVAL;
560
561 DPRINTK ("%s: %s stereo = %d\n", __FUNCTION__, channel->name, stereo);
562
563 switch (stereo) {
564
565 case 0:
566 channel->ctrl &= ~(FORTE_STEREO | FORTE_CHANNELS_MASK);
567 channel-> stereo = stereo;
568 ret = stereo;
569 break;
570
571 case 1:
572 channel->ctrl &= ~FORTE_CHANNELS_MASK;
573 channel->ctrl |= FORTE_STEREO;
574 channel-> stereo = stereo;
575 ret = stereo;
576 break;
577
578 default:
579 DPRINTK ("Unsupported channel format");
580 ret = -EINVAL;
581 break;
582 }
583
584 return ret;
585 }
586
587
588 /**
589 * forte_channel_buffer:
590 * @channel: Channel whose buffer to set up
591 *
592 * Locking: Must be called with lock held.
593 */
594
595 static void
596 forte_channel_buffer (struct forte_channel *channel, int sz, int num)
597 {
598 unsigned int msecs, shift;
599
600 /* Go away, I'm busy */
601 if (channel->filled_frags || channel->bytes)
602 return;
603
604 /* Fragment size must be a power of 2 */
605 shift = 0; sz++;
606 while (sz >>= 1)
607 shift++;
608 channel->frag_sz = 1 << shift;
609
610 /* Round fragment size to something reasonable */
611 if (channel->frag_sz < FORTE_MIN_FRAG_SIZE)
612 channel->frag_sz = FORTE_MIN_FRAG_SIZE;
613
614 if (channel->frag_sz > FORTE_MAX_FRAG_SIZE)
615 channel->frag_sz = FORTE_MAX_FRAG_SIZE;
616
617 /* Find fragment length in milliseconds */
618 msecs = channel->frag_sz /
619 (channel->format == AFMT_S16_LE ? 2 : 1) /
620 (channel->stereo ? 2 : 1) /
621 (channel->rate / 1000);
622
623 channel->frag_msecs = msecs;
624
625 /* Pick a suitable number of fragments */
626 if (msecs * num < FORTE_MIN_BUF_MSECS)
627 num = FORTE_MIN_BUF_MSECS / msecs;
628
629 if (msecs * num > FORTE_MAX_BUF_MSECS)
630 num = FORTE_MAX_BUF_MSECS / msecs;
631
632 /* Fragment number must be a power of 2 */
633 shift = 0;
634 while (num >>= 1)
635 shift++;
636 channel->frag_num = 1 << (shift + 1);
637
638 /* Round fragment number to something reasonable */
639 if (channel->frag_num < FORTE_MIN_FRAGMENTS)
640 channel->frag_num = FORTE_MIN_FRAGMENTS;
641
642 if (channel->frag_num > FORTE_MAX_FRAGMENTS)
643 channel->frag_num = FORTE_MAX_FRAGMENTS;
644
645 channel->buf_sz = channel->frag_sz * channel->frag_num;
646
647 DPRINTK ("%s: %s frag_sz = %d, frag_num = %d, buf_sz = %d\n",
648 __FUNCTION__, channel->name, channel->frag_sz,
649 channel->frag_num, channel->buf_sz);
650 }
651
652
653 /**
654 * forte_channel_prep:
655 * @channel: Channel whose buffer to prepare
656 *
657 * Locking: Lock held.
658 */
659
660 static void
661 forte_channel_prep (struct forte_channel *channel)
662 {
663 struct page *page;
664 int i;
665
666 if (channel->buf)
667 return;
668
669 forte_channel_buffer (channel, channel->frag_sz, channel->frag_num);
670 channel->buf_pages = channel->buf_sz >> PAGE_SHIFT;
671
672 if (channel->buf_sz % PAGE_SIZE)
673 channel->buf_pages++;
674
675 DPRINTK ("%s: %s frag_sz = %d, frag_num = %d, buf_sz = %d, pg = %d\n",
676 __FUNCTION__, channel->name, channel->frag_sz,
677 channel->frag_num, channel->buf_sz, channel->buf_pages);
678
679 /* DMA buffer */
680 channel->buf = pci_alloc_consistent (forte->pci_dev,
681 channel->buf_pages * PAGE_SIZE,
682 &channel->buf_handle);
683
684 if (!channel->buf || !channel->buf_handle)
685 BUG();
686
687 page = virt_to_page (channel->buf);
688
689 /* FIXME: can this go away ? */
690 for (i = 0 ; i < channel->buf_pages ; i++)
691 SetPageReserved(page++);
692
693 /* Prep buffer registers */
694 outw (channel->frag_sz - 1, channel->iobase + FORTE_PLY_COUNT);
695 outl (channel->buf_handle, channel->iobase + FORTE_PLY_BUF1);
696 outl (channel->buf_handle + channel->frag_sz,
697 channel->iobase + FORTE_PLY_BUF2);
698
699 /* Reset hwptr */
700 channel->hwptr = channel->frag_sz;
701 channel->next_buf = 1;
702
703 DPRINTK ("%s: %s buffer @ %p (%p)\n", __FUNCTION__, channel->name,
704 channel->buf, channel->buf_handle);
705 }
706
707
708 /**
709 * forte_channel_drain:
710 * @chip:
711 * @channel:
712 *
713 * Locking: Don't hold the lock.
714 */
715
716 static inline int
717 forte_channel_drain (struct forte_channel *channel)
718 {
719 DECLARE_WAITQUEUE (wait, current);
720 unsigned long flags;
721
722 DPRINTK ("%s\n", __FUNCTION__);
723
724 if (channel->mapped) {
725 spin_lock_irqsave (&forte->lock, flags);
726 forte_channel_stop (channel);
727 spin_unlock_irqrestore (&forte->lock, flags);
728 return 0;
729 }
730
731 spin_lock_irqsave (&forte->lock, flags);
732 add_wait_queue (&channel->wait, &wait);
733
734 for (;;) {
735 if (channel->active == 0 || channel->filled_frags == 1)
736 break;
737
738 spin_unlock_irqrestore (&forte->lock, flags);
739
740 __set_current_state (TASK_INTERRUPTIBLE);
741 schedule();
742
743 spin_lock_irqsave (&forte->lock, flags);
744 }
745
746 forte_channel_stop (channel);
747 forte_channel_reset (channel);
748 set_current_state (TASK_RUNNING);
749 remove_wait_queue (&channel->wait, &wait);
750 spin_unlock_irqrestore (&forte->lock, flags);
751
752 return 0;
753 }
754
755
756 /**
757 * forte_channel_init:
758 * @chip: Forte chip instance the channel hangs off
759 * @channel: Channel to initialize
760 *
761 * Description:
762 * Initializes a channel, sets defaults, and allocates
763 * buffers.
764 *
765 * Locking: No lock held.
766 */
767
768 static int
769 forte_channel_init (struct forte_chip *chip, struct forte_channel *channel)
770 {
771 DPRINTK ("%s: chip iobase @ %p\n", __FUNCTION__, (void *)chip->iobase);
772
773 spin_lock_irq (&chip->lock);
774 memset (channel, 0x0, sizeof (*channel));
775
776 if (channel == &chip->play) {
777 channel->name = "PCM_OUT";
778 channel->iobase = chip->iobase;
779 DPRINTK ("%s: PCM-OUT iobase @ %p\n", __FUNCTION__,
780 (void *) channel->iobase);
781 }
782 else if (channel == &chip->rec) {
783 channel->name = "PCM_IN";
784 channel->iobase = chip->iobase + FORTE_CAP_OFFSET;
785 channel->record = 1;
786 DPRINTK ("%s: PCM-IN iobase @ %p\n", __FUNCTION__,
787 (void *) channel->iobase);
788 }
789 else
790 BUG();
791
792 init_waitqueue_head (&channel->wait);
793
794 /* Defaults: 48kHz, 16-bit, stereo */
795 channel->ctrl = inw (channel->iobase + FORTE_PLY_CTRL);
796 forte_channel_reset (channel);
797 forte_channel_stereo (channel, 1);
798 forte_channel_format (channel, AFMT_S16_LE);
799 forte_channel_rate (channel, 48000);
800 channel->frag_sz = FORTE_DEF_FRAG_SIZE;
801 channel->frag_num = FORTE_DEF_FRAGMENTS;
802
803 chip->trigger = 0;
804 spin_unlock_irq (&chip->lock);
805
806 return 0;
807 }
808
809
810 /**
811 * forte_channel_free:
812 * @chip: Chip this channel hangs off
813 * @channel: Channel to nuke
814 *
815 * Description:
816 * Resets channel and frees buffers.
817 *
818 * Locking: Hold your horses.
819 */
820
821 static void
822 forte_channel_free (struct forte_chip *chip, struct forte_channel *channel)
823 {
824 DPRINTK ("%s: %s\n", __FUNCTION__, channel->name);
825
826 if (!channel->buf_handle)
827 return;
828
829 pci_free_consistent (chip->pci_dev, channel->buf_pages * PAGE_SIZE,
830 channel->buf, channel->buf_handle);
831
832 memset (channel, 0x0, sizeof (*channel));
833 }
834
835
836 /* DSP --------------------------------------------------------------------- */
837
838
839 /**
840 * forte_dsp_ioctl:
841 */
842
843 static int
844 forte_dsp_ioctl (struct inode *inode, struct file *file, unsigned int cmd,
845 unsigned long arg)
846 {
847 int ival=0, ret, rval=0, rd, wr, count;
848 struct forte_chip *chip;
849 struct audio_buf_info abi;
850 struct count_info cinfo;
851 void __user *argp = (void __user *)arg;
852 int __user *p = argp;
853
854 chip = file->private_data;
855
856 if (file->f_mode & FMODE_WRITE)
857 wr = 1;
858 else
859 wr = 0;
860
861 if (file->f_mode & FMODE_READ)
862 rd = 1;
863 else
864 rd = 0;
865
866 switch (cmd) {
867
868 case OSS_GETVERSION:
869 return put_user (SOUND_VERSION, p);
870
871 case SNDCTL_DSP_GETCAPS:
872 DPRINTK ("%s: GETCAPS\n", __FUNCTION__);
873
874 ival = FORTE_CAPS; /* DUPLEX */
875 return put_user (ival, p);
876
877 case SNDCTL_DSP_GETFMTS:
878 DPRINTK ("%s: GETFMTS\n", __FUNCTION__);
879
880 ival = FORTE_FMTS; /* U8, 16LE */
881 return put_user (ival, p);
882
883 case SNDCTL_DSP_SETFMT: /* U8, 16LE */
884 DPRINTK ("%s: SETFMT\n", __FUNCTION__);
885
886 if (get_user (ival, p))
887 return -EFAULT;
888
889 spin_lock_irq (&chip->lock);
890
891 if (rd) {
892 forte_channel_stop (&chip->rec);
893 rval = forte_channel_format (&chip->rec, ival);
894 }
895
896 if (wr) {
897 forte_channel_stop (&chip->rec);
898 rval = forte_channel_format (&chip->play, ival);
899 }
900
901 spin_unlock_irq (&chip->lock);
902
903 return put_user (rval, p);
904
905 case SNDCTL_DSP_STEREO: /* 0 - mono, 1 - stereo */
906 DPRINTK ("%s: STEREO\n", __FUNCTION__);
907
908 if (get_user (ival, p))
909 return -EFAULT;
910
911 spin_lock_irq (&chip->lock);
912
913 if (rd) {
914 forte_channel_stop (&chip->rec);
915 rval = forte_channel_stereo (&chip->rec, ival);
916 }
917
918 if (wr) {
919 forte_channel_stop (&chip->rec);
920 rval = forte_channel_stereo (&chip->play, ival);
921 }
922
923 spin_unlock_irq (&chip->lock);
924
925 return put_user (rval, p);
926
927 case SNDCTL_DSP_CHANNELS: /* 1 - mono, 2 - stereo */
928 DPRINTK ("%s: CHANNELS\n", __FUNCTION__);
929
930 if (get_user (ival, p))
931 return -EFAULT;
932
933 spin_lock_irq (&chip->lock);
934
935 if (rd) {
936 forte_channel_stop (&chip->rec);
937 rval = forte_channel_stereo (&chip->rec, ival-1) + 1;
938 }
939
940 if (wr) {
941 forte_channel_stop (&chip->play);
942 rval = forte_channel_stereo (&chip->play, ival-1) + 1;
943 }
944
945 spin_unlock_irq (&chip->lock);
946
947 return put_user (rval, p);
948
949 case SNDCTL_DSP_SPEED:
950 DPRINTK ("%s: SPEED\n", __FUNCTION__);
951
952 if (get_user (ival, p))
953 return -EFAULT;
954
955 spin_lock_irq (&chip->lock);
956
957 if (rd) {
958 forte_channel_stop (&chip->rec);
959 rval = forte_channel_rate (&chip->rec, ival);
960 }
961
962 if (wr) {
963 forte_channel_stop (&chip->play);
964 rval = forte_channel_rate (&chip->play, ival);
965 }
966
967 spin_unlock_irq (&chip->lock);
968
969 return put_user(rval, p);
970
971 case SNDCTL_DSP_GETBLKSIZE:
972 DPRINTK ("%s: GETBLKSIZE\n", __FUNCTION__);
973
974 spin_lock_irq (&chip->lock);
975
976 if (rd)
977 ival = chip->rec.frag_sz;
978
979 if (wr)
980 ival = chip->play.frag_sz;
981
982 spin_unlock_irq (&chip->lock);
983
984 return put_user (ival, p);
985
986 case SNDCTL_DSP_RESET:
987 DPRINTK ("%s: RESET\n", __FUNCTION__);
988
989 spin_lock_irq (&chip->lock);
990
991 if (rd)
992 forte_channel_reset (&chip->rec);
993
994 if (wr)
995 forte_channel_reset (&chip->play);
996
997 spin_unlock_irq (&chip->lock);
998
999 return 0;
1000
1001 case SNDCTL_DSP_SYNC:
1002 DPRINTK ("%s: SYNC\n", __FUNCTION__);
1003
1004 if (wr)
1005 ret = forte_channel_drain (&chip->play);
1006
1007 return 0;
1008
1009 case SNDCTL_DSP_POST:
1010 DPRINTK ("%s: POST\n", __FUNCTION__);
1011
1012 if (wr) {
1013 spin_lock_irq (&chip->lock);
1014
1015 if (chip->play.filled_frags)
1016 forte_channel_start (&chip->play);
1017
1018 spin_unlock_irq (&chip->lock);
1019 }
1020
1021 return 0;
1022
1023 case SNDCTL_DSP_SETFRAGMENT:
1024 DPRINTK ("%s: SETFRAGMENT\n", __FUNCTION__);
1025
1026 if (get_user (ival, p))
1027 return -EFAULT;
1028
1029 spin_lock_irq (&chip->lock);
1030
1031 if (rd) {
1032 forte_channel_buffer (&chip->rec, ival & 0xffff,
1033 (ival >> 16) & 0xffff);
1034 ival = (chip->rec.frag_num << 16) + chip->rec.frag_sz;
1035 }
1036
1037 if (wr) {
1038 forte_channel_buffer (&chip->play, ival & 0xffff,
1039 (ival >> 16) & 0xffff);
1040 ival = (chip->play.frag_num << 16) +chip->play.frag_sz;
1041 }
1042
1043 spin_unlock_irq (&chip->lock);
1044
1045 return put_user (ival, p);
1046
1047 case SNDCTL_DSP_GETISPACE:
1048 DPRINTK ("%s: GETISPACE\n", __FUNCTION__);
1049
1050 if (!rd)
1051 return -EINVAL;
1052
1053 spin_lock_irq (&chip->lock);
1054
1055 abi.fragstotal = chip->rec.frag_num;
1056 abi.fragsize = chip->rec.frag_sz;
1057
1058 if (chip->rec.mapped) {
1059 abi.fragments = chip->rec.frag_num - 2;
1060 abi.bytes = abi.fragments * abi.fragsize;
1061 }
1062 else {
1063 abi.fragments = chip->rec.filled_frags;
1064 abi.bytes = abi.fragments * abi.fragsize;
1065 }
1066
1067 spin_unlock_irq (&chip->lock);
1068
1069 return copy_to_user (argp, &abi, sizeof (abi)) ? -EFAULT : 0;
1070
1071 case SNDCTL_DSP_GETIPTR:
1072 DPRINTK ("%s: GETIPTR\n", __FUNCTION__);
1073
1074 if (!rd)
1075 return -EINVAL;
1076
1077 spin_lock_irq (&chip->lock);
1078
1079 if (chip->rec.active)
1080 cinfo.ptr = chip->rec.hwptr;
1081 else
1082 cinfo.ptr = 0;
1083
1084 cinfo.bytes = chip->rec.bytes;
1085 cinfo.blocks = chip->rec.nr_irqs;
1086 chip->rec.nr_irqs = 0;
1087
1088 spin_unlock_irq (&chip->lock);
1089
1090 return copy_to_user (argp, &cinfo, sizeof (cinfo)) ? -EFAULT : 0;
1091
1092 case SNDCTL_DSP_GETOSPACE:
1093 if (!wr)
1094 return -EINVAL;
1095
1096 spin_lock_irq (&chip->lock);
1097
1098 abi.fragstotal = chip->play.frag_num;
1099 abi.fragsize = chip->play.frag_sz;
1100
1101 if (chip->play.mapped) {
1102 abi.fragments = chip->play.frag_num - 2;
1103 abi.bytes = chip->play.buf_sz;
1104 }
1105 else {
1106 abi.fragments = chip->play.frag_num -
1107 chip->play.filled_frags;
1108
1109 if (chip->play.residue)
1110 abi.fragments--;
1111
1112 abi.bytes = abi.fragments * abi.fragsize +
1113 chip->play.residue;
1114 }
1115
1116 spin_unlock_irq (&chip->lock);
1117
1118 return copy_to_user (argp, &abi, sizeof (abi)) ? -EFAULT : 0;
1119
1120 case SNDCTL_DSP_GETOPTR:
1121 if (!wr)
1122 return -EINVAL;
1123
1124 spin_lock_irq (&chip->lock);
1125
1126 if (chip->play.active)
1127 cinfo.ptr = chip->play.hwptr;
1128 else
1129 cinfo.ptr = 0;
1130
1131 cinfo.bytes = chip->play.bytes;
1132 cinfo.blocks = chip->play.nr_irqs;
1133 chip->play.nr_irqs = 0;
1134
1135 spin_unlock_irq (&chip->lock);
1136
1137 return copy_to_user (argp, &cinfo, sizeof (cinfo)) ? -EFAULT : 0;
1138
1139 case SNDCTL_DSP_GETODELAY:
1140 if (!wr)
1141 return -EINVAL;
1142
1143 spin_lock_irq (&chip->lock);
1144
1145 if (!chip->play.active) {
1146 ival = 0;
1147 }
1148 else if (chip->play.mapped) {
1149 count = inw (chip->play.iobase + FORTE_PLY_COUNT) + 1;
1150 ival = chip->play.frag_sz - count;
1151 }
1152 else {
1153 ival = chip->play.filled_frags * chip->play.frag_sz;
1154
1155 if (chip->play.residue)
1156 ival += chip->play.frag_sz - chip->play.residue;
1157 }
1158
1159 spin_unlock_irq (&chip->lock);
1160
1161 return put_user (ival, p);
1162
1163 case SNDCTL_DSP_SETDUPLEX:
1164 DPRINTK ("%s: SETDUPLEX\n", __FUNCTION__);
1165
1166 return -EINVAL;
1167
1168 case SNDCTL_DSP_GETTRIGGER:
1169 DPRINTK ("%s: GETTRIGGER\n", __FUNCTION__);
1170
1171 return put_user (chip->trigger, p);
1172
1173 case SNDCTL_DSP_SETTRIGGER:
1174
1175 if (get_user (ival, p))
1176 return -EFAULT;
1177
1178 DPRINTK ("%s: SETTRIGGER %d\n", __FUNCTION__, ival);
1179
1180 if (wr) {
1181 spin_lock_irq (&chip->lock);
1182
1183 if (ival & PCM_ENABLE_OUTPUT)
1184 forte_channel_start (&chip->play);
1185 else {
1186 chip->trigger = 1;
1187 forte_channel_prep (&chip->play);
1188 forte_channel_stop (&chip->play);
1189 }
1190
1191 spin_unlock_irq (&chip->lock);
1192 }
1193 else if (rd) {
1194 spin_lock_irq (&chip->lock);
1195
1196 if (ival & PCM_ENABLE_INPUT)
1197 forte_channel_start (&chip->rec);
1198 else {
1199 chip->trigger = 1;
1200 forte_channel_prep (&chip->rec);
1201 forte_channel_stop (&chip->rec);
1202 }
1203
1204 spin_unlock_irq (&chip->lock);
1205 }
1206
1207 return 0;
1208
1209 case SOUND_PCM_READ_RATE:
1210 DPRINTK ("%s: PCM_READ_RATE\n", __FUNCTION__);
1211 return put_user (chip->play.rate, p);
1212
1213 case SOUND_PCM_READ_CHANNELS:
1214 DPRINTK ("%s: PCM_READ_CHANNELS\n", __FUNCTION__);
1215 return put_user (chip->play.stereo, p);
1216
1217 case SOUND_PCM_READ_BITS:
1218 DPRINTK ("%s: PCM_READ_BITS\n", __FUNCTION__);
1219 return put_user (chip->play.format, p);
1220
1221 case SNDCTL_DSP_NONBLOCK:
1222 DPRINTK ("%s: DSP_NONBLOCK\n", __FUNCTION__);
1223 file->f_flags |= O_NONBLOCK;
1224 return 0;
1225
1226 default:
1227 DPRINTK ("Unsupported ioctl: %x (%p)\n", cmd, argp);
1228 break;
1229 }
1230
1231 return -EINVAL;
1232 }
1233
1234
1235 /**
1236 * forte_dsp_open:
1237 */
1238
1239 static int
1240 forte_dsp_open (struct inode *inode, struct file *file)
1241 {
1242 struct forte_chip *chip = forte; /* FIXME: HACK FROM HELL! */
1243
1244 if (file->f_flags & O_NONBLOCK) {
1245 if (down_trylock (&chip->open_sem)) {
1246 DPRINTK ("%s: returning -EAGAIN\n", __FUNCTION__);
1247 return -EAGAIN;
1248 }
1249 }
1250 else {
1251 if (down_interruptible (&chip->open_sem)) {
1252 DPRINTK ("%s: returning -ERESTARTSYS\n", __FUNCTION__);
1253 return -ERESTARTSYS;
1254 }
1255 }
1256
1257 file->private_data = forte;
1258
1259 DPRINTK ("%s: dsp opened by %d\n", __FUNCTION__, current->pid);
1260
1261 if (file->f_mode & FMODE_WRITE)
1262 forte_channel_init (forte, &forte->play);
1263
1264 if (file->f_mode & FMODE_READ)
1265 forte_channel_init (forte, &forte->rec);
1266
1267 return nonseekable_open(inode, file);
1268 }
1269
1270
1271 /**
1272 * forte_dsp_release:
1273 */
1274
1275 static int
1276 forte_dsp_release (struct inode *inode, struct file *file)
1277 {
1278 struct forte_chip *chip = file->private_data;
1279 int ret = 0;
1280
1281 DPRINTK ("%s: chip @ %p\n", __FUNCTION__, chip);
1282
1283 if (file->f_mode & FMODE_WRITE) {
1284 forte_channel_drain (&chip->play);
1285
1286 spin_lock_irq (&chip->lock);
1287
1288 forte_channel_free (chip, &chip->play);
1289
1290 spin_unlock_irq (&chip->lock);
1291 }
1292
1293 if (file->f_mode & FMODE_READ) {
1294 while (chip->rec.filled_frags > 0)
1295 interruptible_sleep_on (&chip->rec.wait);
1296
1297 spin_lock_irq (&chip->lock);
1298
1299 forte_channel_stop (&chip->rec);
1300 forte_channel_free (chip, &chip->rec);
1301
1302 spin_unlock_irq (&chip->lock);
1303 }
1304
1305 up (&chip->open_sem);
1306
1307 return ret;
1308 }
1309
1310
1311 /**
1312 * forte_dsp_poll:
1313 *
1314 */
1315
1316 static unsigned int
1317 forte_dsp_poll (struct file *file, struct poll_table_struct *wait)
1318 {
1319 struct forte_chip *chip;
1320 struct forte_channel *channel;
1321 unsigned int mask = 0;
1322
1323 chip = file->private_data;
1324
1325 if (file->f_mode & FMODE_WRITE) {
1326 channel = &chip->play;
1327
1328 if (channel->active)
1329 poll_wait (file, &channel->wait, wait);
1330
1331 spin_lock_irq (&chip->lock);
1332
1333 if (channel->frag_num - channel->filled_frags > 0)
1334 mask |= POLLOUT | POLLWRNORM;
1335
1336 spin_unlock_irq (&chip->lock);
1337 }
1338
1339 if (file->f_mode & FMODE_READ) {
1340 channel = &chip->rec;
1341
1342 if (channel->active)
1343 poll_wait (file, &channel->wait, wait);
1344
1345 spin_lock_irq (&chip->lock);
1346
1347 if (channel->filled_frags > 0)
1348 mask |= POLLIN | POLLRDNORM;
1349
1350 spin_unlock_irq (&chip->lock);
1351 }
1352
1353 return mask;
1354 }
1355
1356
1357 /**
1358 * forte_dsp_mmap:
1359 */
1360
1361 static int
1362 forte_dsp_mmap (struct file *file, struct vm_area_struct *vma)
1363 {
1364 struct forte_chip *chip;
1365 struct forte_channel *channel;
1366 unsigned long size;
1367 int ret;
1368
1369 chip = file->private_data;
1370
1371 DPRINTK ("%s: start %lXh, size %ld, pgoff %ld\n", __FUNCTION__,
1372 vma->vm_start, vma->vm_end - vma->vm_start, vma->vm_pgoff);
1373
1374 spin_lock_irq (&chip->lock);
1375
1376 if (vma->vm_flags & VM_WRITE && chip->play.active) {
1377 ret = -EBUSY;
1378 goto out;
1379 }
1380
1381 if (vma->vm_flags & VM_READ && chip->rec.active) {
1382 ret = -EBUSY;
1383 goto out;
1384 }
1385
1386 if (file->f_mode & FMODE_WRITE)
1387 channel = &chip->play;
1388 else if (file->f_mode & FMODE_READ)
1389 channel = &chip->rec;
1390 else {
1391 ret = -EINVAL;
1392 goto out;
1393 }
1394
1395 forte_channel_prep (channel);
1396 channel->mapped = 1;
1397
1398 if (vma->vm_pgoff != 0) {
1399 ret = -EINVAL;
1400 goto out;
1401 }
1402
1403 size = vma->vm_end - vma->vm_start;
1404
1405 if (size > channel->buf_pages * PAGE_SIZE) {
1406 DPRINTK ("%s: size (%ld) > buf_sz (%d) \n", __FUNCTION__,
1407 size, channel->buf_sz);
1408 ret = -EINVAL;
1409 goto out;
1410 }
1411
1412 if (remap_page_range (vma, vma->vm_start, virt_to_phys (channel->buf),
1413 size, vma->vm_page_prot)) {
1414 DPRINTK ("%s: remap el a no worko\n", __FUNCTION__);
1415 ret = -EAGAIN;
1416 goto out;
1417 }
1418
1419 ret = 0;
1420
1421 out:
1422 spin_unlock_irq (&chip->lock);
1423 return ret;
1424 }
1425
1426
1427 /**
1428 * forte_dsp_write:
1429 */
1430
1431 static ssize_t
1432 forte_dsp_write (struct file *file, const char __user *buffer, size_t bytes,
1433 loff_t *ppos)
1434 {
1435 struct forte_chip *chip;
1436 struct forte_channel *channel;
1437 unsigned int i = bytes, sz = 0;
1438 unsigned long flags;
1439
1440 if (!access_ok (VERIFY_READ, buffer, bytes))
1441 return -EFAULT;
1442
1443 chip = (struct forte_chip *) file->private_data;
1444
1445 if (!chip)
1446 BUG();
1447
1448 channel = &chip->play;
1449
1450 if (!channel)
1451 BUG();
1452
1453 spin_lock_irqsave (&chip->lock, flags);
1454
1455 /* Set up buffers with the right fragment size */
1456 forte_channel_prep (channel);
1457
1458 while (i) {
1459 /* All fragment buffers in use -> wait */
1460 if (channel->frag_num - channel->filled_frags == 0) {
1461 DECLARE_WAITQUEUE (wait, current);
1462
1463 /* For trigger or non-blocking operation, get out */
1464 if (chip->trigger || file->f_flags & O_NONBLOCK) {
1465 spin_unlock_irqrestore (&chip->lock, flags);
1466 return -EAGAIN;
1467 }
1468
1469 /* Otherwise wait for buffers */
1470 add_wait_queue (&channel->wait, &wait);
1471
1472 for (;;) {
1473 spin_unlock_irqrestore (&chip->lock, flags);
1474
1475 set_current_state (TASK_INTERRUPTIBLE);
1476 schedule();
1477
1478 spin_lock_irqsave (&chip->lock, flags);
1479
1480 if (channel->frag_num - channel->filled_frags)
1481 break;
1482 }
1483
1484 remove_wait_queue (&channel->wait, &wait);
1485 set_current_state (TASK_RUNNING);
1486
1487 if (signal_pending (current)) {
1488 spin_unlock_irqrestore (&chip->lock, flags);
1489 return -ERESTARTSYS;
1490 }
1491 }
1492
1493 if (channel->residue)
1494 sz = channel->residue;
1495 else if (i > channel->frag_sz)
1496 sz = channel->frag_sz;
1497 else
1498 sz = i;
1499
1500 spin_unlock_irqrestore (&chip->lock, flags);
1501
1502 if (copy_from_user ((void *) channel->buf + channel->swptr, buffer, sz))
1503 return -EFAULT;
1504
1505 spin_lock_irqsave (&chip->lock, flags);
1506
1507 /* Advance software pointer */
1508 buffer += sz;
1509 channel->swptr += sz;
1510 channel->swptr %= channel->buf_sz;
1511 i -= sz;
1512
1513 /* Only bump filled_frags if a full fragment has been written */
1514 if (channel->swptr % channel->frag_sz == 0) {
1515 channel->filled_frags++;
1516 channel->residue = 0;
1517 }
1518 else
1519 channel->residue = channel->frag_sz - sz;
1520
1521 /* If playback isn't active, start it */
1522 if (channel->active == 0 && chip->trigger == 0)
1523 forte_channel_start (channel);
1524 }
1525
1526 spin_unlock_irqrestore (&chip->lock, flags);
1527
1528 return bytes - i;
1529 }
1530
1531
1532 /**
1533 * forte_dsp_read:
1534 */
1535
1536 static ssize_t
1537 forte_dsp_read (struct file *file, char __user *buffer, size_t bytes,
1538 loff_t *ppos)
1539 {
1540 struct forte_chip *chip;
1541 struct forte_channel *channel;
1542 unsigned int i = bytes, sz;
1543 unsigned long flags;
1544
1545 if (!access_ok (VERIFY_WRITE, buffer, bytes))
1546 return -EFAULT;
1547
1548 chip = (struct forte_chip *) file->private_data;
1549
1550 if (!chip)
1551 BUG();
1552
1553 channel = &chip->rec;
1554
1555 if (!channel)
1556 BUG();
1557
1558 spin_lock_irqsave (&chip->lock, flags);
1559
1560 /* Set up buffers with the right fragment size */
1561 forte_channel_prep (channel);
1562
1563 /* Start recording */
1564 if (!chip->trigger)
1565 forte_channel_start (channel);
1566
1567 while (i) {
1568 /* No fragment buffers in use -> wait */
1569 if (channel->filled_frags == 0) {
1570 DECLARE_WAITQUEUE (wait, current);
1571
1572 /* For trigger mode operation, get out */
1573 if (chip->trigger) {
1574 spin_unlock_irqrestore (&chip->lock, flags);
1575 return -EAGAIN;
1576 }
1577
1578 add_wait_queue (&channel->wait, &wait);
1579
1580 for (;;) {
1581 if (channel->active == 0)
1582 break;
1583
1584 if (channel->filled_frags)
1585 break;
1586
1587 spin_unlock_irqrestore (&chip->lock, flags);
1588
1589 set_current_state (TASK_INTERRUPTIBLE);
1590 schedule();
1591
1592 spin_lock_irqsave (&chip->lock, flags);
1593 }
1594
1595 set_current_state (TASK_RUNNING);
1596 remove_wait_queue (&channel->wait, &wait);
1597 }
1598
1599 if (i > channel->frag_sz)
1600 sz = channel->frag_sz;
1601 else
1602 sz = i;
1603
1604 spin_unlock_irqrestore (&chip->lock, flags);
1605
1606 if (copy_to_user (buffer, (void *)channel->buf+channel->swptr, sz)) {
1607 DPRINTK ("%s: copy_to_user failed\n", __FUNCTION__);
1608 return -EFAULT;
1609 }
1610
1611 spin_lock_irqsave (&chip->lock, flags);
1612
1613 /* Advance software pointer */
1614 buffer += sz;
1615 if (channel->filled_frags > 0)
1616 channel->filled_frags--;
1617 channel->swptr += channel->frag_sz;
1618 channel->swptr %= channel->buf_sz;
1619 i -= sz;
1620 }
1621
1622 spin_unlock_irqrestore (&chip->lock, flags);
1623
1624 return bytes - i;
1625 }
1626
1627
1628 static struct file_operations forte_dsp_fops = {
1629 .owner = THIS_MODULE,
1630 .llseek = &no_llseek,
1631 .read = &forte_dsp_read,
1632 .write = &forte_dsp_write,
1633 .poll = &forte_dsp_poll,
1634 .ioctl = &forte_dsp_ioctl,
1635 .open = &forte_dsp_open,
1636 .release = &forte_dsp_release,
1637 .mmap = &forte_dsp_mmap,
1638 };
1639
1640
1641 /* Common ------------------------------------------------------------------ */
1642
1643
1644 /**
1645 * forte_interrupt:
1646 */
1647
1648 static irqreturn_t
1649 forte_interrupt (int irq, void *dev_id, struct pt_regs *regs)
1650 {
1651 struct forte_chip *chip = dev_id;
1652 struct forte_channel *channel = NULL;
1653 u16 status, count;
1654
1655 status = inw (chip->iobase + FORTE_IRQ_STATUS);
1656
1657 /* If this is not for us, get outta here ASAP */
1658 if ((status & (FORTE_IRQ_PLAYBACK | FORTE_IRQ_CAPTURE)) == 0)
1659 return IRQ_NONE;
1660
1661 if (status & FORTE_IRQ_PLAYBACK) {
1662 channel = &chip->play;
1663
1664 spin_lock (&chip->lock);
1665
1666 if (channel->frag_sz == 0)
1667 goto pack;
1668
1669 /* Declare a fragment done */
1670 if (channel->filled_frags > 0)
1671 channel->filled_frags--;
1672 channel->bytes += channel->frag_sz;
1673 channel->nr_irqs++;
1674
1675 /* Flip-flop between buffer I and II */
1676 channel->next_buf ^= 1;
1677
1678 /* Advance hardware pointer by fragment size and wrap around */
1679 channel->hwptr += channel->frag_sz;
1680 channel->hwptr %= channel->buf_sz;
1681
1682 /* Buffer I or buffer II BAR */
1683 outl (channel->buf_handle + channel->hwptr,
1684 channel->next_buf == 0 ?
1685 channel->iobase + FORTE_PLY_BUF1 :
1686 channel->iobase + FORTE_PLY_BUF2);
1687
1688 /* If the currently playing fragment is last, schedule pause */
1689 if (channel->filled_frags == 1)
1690 forte_channel_pause (channel);
1691
1692 pack:
1693 /* Acknowledge interrupt */
1694 outw (FORTE_IRQ_PLAYBACK, chip->iobase + FORTE_IRQ_STATUS);
1695
1696 if (waitqueue_active (&channel->wait))
1697 wake_up_all (&channel->wait);
1698
1699 spin_unlock (&chip->lock);
1700 }
1701
1702 if (status & FORTE_IRQ_CAPTURE) {
1703 channel = &chip->rec;
1704 spin_lock (&chip->lock);
1705
1706 /* One fragment filled */
1707 channel->filled_frags++;
1708
1709 /* Get # of completed bytes */
1710 count = inw (channel->iobase + FORTE_PLY_COUNT) + 1;
1711
1712 if (count == 0) {
1713 DPRINTK ("%s: last, filled_frags = %d\n", __FUNCTION__,
1714 channel->filled_frags);
1715 channel->filled_frags = 0;
1716 goto rack;
1717 }
1718
1719 /* Buffer I or buffer II BAR */
1720 outl (channel->buf_handle + channel->hwptr,
1721 channel->next_buf == 0 ?
1722 channel->iobase + FORTE_PLY_BUF1 :
1723 channel->iobase + FORTE_PLY_BUF2);
1724
1725 /* Flip-flop between buffer I and II */
1726 channel->next_buf ^= 1;
1727
1728 /* Advance hardware pointer by fragment size and wrap around */
1729 channel->hwptr += channel->frag_sz;
1730 channel->hwptr %= channel->buf_sz;
1731
1732 /* Out of buffers */
1733 if (channel->filled_frags == channel->frag_num - 1)
1734 forte_channel_stop (channel);
1735 rack:
1736 /* Acknowledge interrupt */
1737 outw (FORTE_IRQ_CAPTURE, chip->iobase + FORTE_IRQ_STATUS);
1738
1739 spin_unlock (&chip->lock);
1740
1741 if (waitqueue_active (&channel->wait))
1742 wake_up_all (&channel->wait);
1743 }
1744
1745 return IRQ_HANDLED;
1746 }
1747
1748
1749 /**
1750 * forte_proc_read:
1751 */
1752
1753 static int
1754 forte_proc_read (char *page, char **start, off_t off, int count,
1755 int *eof, void *data)
1756 {
1757 int i = 0, p_rate, p_chan, r_rate;
1758 unsigned short p_reg, r_reg;
1759
1760 i += sprintf (page, "ForteMedia FM801 OSS Lite driver\n%s\n \n",
1761 DRIVER_VERSION);
1762
1763 if (!forte->iobase)
1764 return i;
1765
1766 p_rate = p_chan = -1;
1767 p_reg = inw (forte->iobase + FORTE_PLY_CTRL);
1768 p_rate = (p_reg >> 8) & 15;
1769 p_chan = (p_reg >> 12) & 3;
1770
1771 if (p_rate >= 0 || p_rate <= 10)
1772 p_rate = rates[p_rate];
1773
1774 if (p_chan >= 0 || p_chan <= 2)
1775 p_chan = channels[p_chan];
1776
1777 r_rate = -1;
1778 r_reg = inw (forte->iobase + FORTE_CAP_CTRL);
1779 r_rate = (r_reg >> 8) & 15;
1780
1781 if (r_rate >= 0 || r_rate <= 10)
1782 r_rate = rates[r_rate];
1783
1784 i += sprintf (page + i,
1785 " Playback Capture\n"
1786 "FIFO empty : %-3s %-3s\n"
1787 "Buf1 Last : %-3s %-3s\n"
1788 "Buf2 Last : %-3s %-3s\n"
1789 "Started : %-3s %-3s\n"
1790 "Paused : %-3s %-3s\n"
1791 "Immed Stop : %-3s %-3s\n"
1792 "Rate : %-5d %-5d\n"
1793 "Channels : %-5d -\n"
1794 "16-bit : %-3s %-3s\n"
1795 "Stereo : %-3s %-3s\n"
1796 " \n"
1797 "Buffer Sz : %-6d %-6d\n"
1798 "Frag Sz : %-6d %-6d\n"
1799 "Frag Num : %-6d %-6d\n"
1800 "Frag msecs : %-6d %-6d\n"
1801 "Used Frags : %-6d %-6d\n"
1802 "Mapped : %-3s %-3s\n",
1803 p_reg & 1<<0 ? "yes" : "no",
1804 r_reg & 1<<0 ? "yes" : "no",
1805 p_reg & 1<<1 ? "yes" : "no",
1806 r_reg & 1<<1 ? "yes" : "no",
1807 p_reg & 1<<2 ? "yes" : "no",
1808 r_reg & 1<<2 ? "yes" : "no",
1809 p_reg & 1<<5 ? "yes" : "no",
1810 r_reg & 1<<5 ? "yes" : "no",
1811 p_reg & 1<<6 ? "yes" : "no",
1812 r_reg & 1<<6 ? "yes" : "no",
1813 p_reg & 1<<7 ? "yes" : "no",
1814 r_reg & 1<<7 ? "yes" : "no",
1815 p_rate, r_rate,
1816 p_chan,
1817 p_reg & 1<<14 ? "yes" : "no",
1818 r_reg & 1<<14 ? "yes" : "no",
1819 p_reg & 1<<15 ? "yes" : "no",
1820 r_reg & 1<<15 ? "yes" : "no",
1821 forte->play.buf_sz, forte->rec.buf_sz,
1822 forte->play.frag_sz, forte->rec.frag_sz,
1823 forte->play.frag_num, forte->rec.frag_num,
1824 forte->play.frag_msecs, forte->rec.frag_msecs,
1825 forte->play.filled_frags, forte->rec.filled_frags,
1826 forte->play.mapped ? "yes" : "no",
1827 forte->rec.mapped ? "yes" : "no"
1828 );
1829
1830 return i;
1831 }
1832
1833
1834 /**
1835 * forte_proc_init:
1836 *
1837 * Creates driver info entries in /proc
1838 */
1839
1840 static int __init
1841 forte_proc_init (void)
1842 {
1843 if (!proc_mkdir ("driver/forte", NULL))
1844 return -EIO;
1845
1846 if (!create_proc_read_entry ("driver/forte/chip", 0, NULL, forte_proc_read, forte)) {
1847 remove_proc_entry ("driver/forte", NULL);
1848 return -EIO;
1849 }
1850
1851 if (!create_proc_read_entry("driver/forte/ac97", 0, NULL, ac97_read_proc, forte->ac97)) {
1852 remove_proc_entry ("driver/forte/chip", NULL);
1853 remove_proc_entry ("driver/forte", NULL);
1854 return -EIO;
1855 }
1856
1857 return 0;
1858 }
1859
1860
1861 /**
1862 * forte_proc_remove:
1863 *
1864 * Removes driver info entries in /proc
1865 */
1866
1867 static void
1868 forte_proc_remove (void)
1869 {
1870 remove_proc_entry ("driver/forte/ac97", NULL);
1871 remove_proc_entry ("driver/forte/chip", NULL);
1872 remove_proc_entry ("driver/forte", NULL);
1873 }
1874
1875
1876 /**
1877 * forte_chip_init:
1878 * @chip: Chip instance to initialize
1879 *
1880 * Description:
1881 * Resets chip, configures codec and registers the driver with
1882 * the sound subsystem.
1883 *
1884 * Press and hold Start for 8 secs, then switch on Run
1885 * and hold for 4 seconds. Let go of Start. Numbers
1886 * assume a properly oiled TWG.
1887 */
1888
1889 static int __devinit
1890 forte_chip_init (struct forte_chip *chip)
1891 {
1892 u8 revision;
1893 u16 cmdw;
1894 struct ac97_codec *codec;
1895
1896 pci_read_config_byte (chip->pci_dev, PCI_REVISION_ID, &revision);
1897
1898 if (revision >= 0xB1) {
1899 chip->multichannel = 1;
1900 printk (KERN_INFO PFX "Multi-channel device detected.\n");
1901 }
1902
1903 /* Reset chip */
1904 outw (FORTE_CC_CODEC_RESET | FORTE_CC_AC97_RESET,
1905 chip->iobase + FORTE_CODEC_CTRL);
1906 udelay(100);
1907 outw (0, chip->iobase + FORTE_CODEC_CTRL);
1908
1909 /* Request read from AC97 */
1910 outw (FORTE_AC97_READ | (0 << FORTE_AC97_ADDR_SHIFT),
1911 chip->iobase + FORTE_AC97_CMD);
1912 mdelay(750);
1913
1914 if ((inw (chip->iobase + FORTE_AC97_CMD) & (3<<8)) != (1<<8)) {
1915 printk (KERN_INFO PFX "AC97 codec not responding");
1916 return -EIO;
1917 }
1918
1919 /* Init volume */
1920 outw (0x0808, chip->iobase + FORTE_PCM_VOL);
1921 outw (0x9f1f, chip->iobase + FORTE_FM_VOL);
1922 outw (0x8808, chip->iobase + FORTE_I2S_VOL);
1923
1924 /* I2S control - I2S mode */
1925 outw (0x0003, chip->iobase + FORTE_I2S_MODE);
1926
1927 /* Interrupt setup - unmask PLAYBACK & CAPTURE */
1928 cmdw = inw (chip->iobase + FORTE_IRQ_MASK);
1929 cmdw &= ~0x0003;
1930 outw (cmdw, chip->iobase + FORTE_IRQ_MASK);
1931
1932 /* Interrupt clear */
1933 outw (FORTE_IRQ_PLAYBACK|FORTE_IRQ_CAPTURE,
1934 chip->iobase + FORTE_IRQ_STATUS);
1935
1936 /* Set up the AC97 codec */
1937 if ((codec = ac97_alloc_codec()) == NULL)
1938 return -ENOMEM;
1939 codec->private_data = chip;
1940 codec->codec_read = forte_ac97_read;
1941 codec->codec_write = forte_ac97_write;
1942 codec->id = 0;
1943
1944 if (ac97_probe_codec (codec) == 0) {
1945 printk (KERN_ERR PFX "codec probe failed\n");
1946 ac97_release_codec(codec);
1947 return -1;
1948 }
1949
1950 /* Register mixer */
1951 if ((codec->dev_mixer =
1952 register_sound_mixer (&forte_mixer_fops, -1)) < 0) {
1953 printk (KERN_ERR PFX "couldn't register mixer!\n");
1954 ac97_release_codec(codec);
1955 return -1;
1956 }
1957
1958 chip->ac97 = codec;
1959
1960 /* Register DSP */
1961 if ((chip->dsp = register_sound_dsp (&forte_dsp_fops, -1) ) < 0) {
1962 printk (KERN_ERR PFX "couldn't register dsp!\n");
1963 return -1;
1964 }
1965
1966 /* Register with /proc */
1967 if (forte_proc_init()) {
1968 printk (KERN_ERR PFX "couldn't add entries to /proc!\n");
1969 return -1;
1970 }
1971
1972 return 0;
1973 }
1974
1975
1976 /**
1977 * forte_probe:
1978 * @pci_dev: PCI struct for probed device
1979 * @pci_id:
1980 *
1981 * Description:
1982 * Allocates chip instance, I/O region, and IRQ
1983 */
1984 static int __init
1985 forte_probe (struct pci_dev *pci_dev, const struct pci_device_id *pci_id)
1986 {
1987 struct forte_chip *chip;
1988 int ret = 0;
1989
1990 /* FIXME: Support more than one chip */
1991 if (found++)
1992 return -EIO;
1993
1994 /* Ignition */
1995 if (pci_enable_device (pci_dev))
1996 return -EIO;
1997
1998 pci_set_master (pci_dev);
1999
2000 /* Allocate chip instance and configure */
2001 forte = (struct forte_chip *)
2002 kmalloc (sizeof (struct forte_chip), GFP_KERNEL);
2003 chip = forte;
2004
2005 if (chip == NULL) {
2006 printk (KERN_WARNING PFX "Out of memory");
2007 return -ENOMEM;
2008 }
2009
2010 memset (chip, 0, sizeof (struct forte_chip));
2011 chip->pci_dev = pci_dev;
2012
2013 init_MUTEX(&chip->open_sem);
2014 spin_lock_init (&chip->lock);
2015 spin_lock_init (&chip->ac97_lock);
2016
2017 if (! request_region (pci_resource_start (pci_dev, 0),
2018 pci_resource_len (pci_dev, 0), DRIVER_NAME)) {
2019 printk (KERN_WARNING PFX "Unable to reserve I/O space");
2020 ret = -ENOMEM;
2021 goto error;
2022 }
2023
2024 chip->iobase = pci_resource_start (pci_dev, 0);
2025 chip->irq = pci_dev->irq;
2026
2027 if (request_irq (chip->irq, forte_interrupt, SA_SHIRQ, DRIVER_NAME,
2028 chip)) {
2029 printk (KERN_WARNING PFX "Unable to reserve IRQ");
2030 ret = -EIO;
2031 goto error;
2032 }
2033
2034 pci_set_drvdata (pci_dev, chip);
2035
2036 printk (KERN_INFO PFX "FM801 chip found at 0x%04lX-0x%04lX IRQ %u\n",
2037 chip->iobase, pci_resource_end (pci_dev, 0), chip->irq);
2038
2039 /* Power it up */
2040 if ((ret = forte_chip_init (chip)) == 0)
2041 return 0;
2042
2043 error:
2044 if (chip->irq)
2045 free_irq (chip->irq, chip);
2046
2047 if (chip->iobase)
2048 release_region (pci_resource_start (pci_dev, 0),
2049 pci_resource_len (pci_dev, 0));
2050
2051 kfree (chip);
2052
2053 return ret;
2054 }
2055
2056
2057 /**
2058 * forte_remove:
2059 * @pci_dev: PCI device to unclaim
2060 *
2061 */
2062
2063 static void
2064 forte_remove (struct pci_dev *pci_dev)
2065 {
2066 struct forte_chip *chip = pci_get_drvdata (pci_dev);
2067
2068 if (chip == NULL)
2069 return;
2070
2071 /* Turn volume down to avoid popping */
2072 outw (0x1f1f, chip->iobase + FORTE_PCM_VOL);
2073 outw (0x1f1f, chip->iobase + FORTE_FM_VOL);
2074 outw (0x1f1f, chip->iobase + FORTE_I2S_VOL);
2075
2076 forte_proc_remove();
2077 free_irq (chip->irq, chip);
2078 release_region (chip->iobase, pci_resource_len (pci_dev, 0));
2079
2080 unregister_sound_dsp (chip->dsp);
2081 unregister_sound_mixer (chip->ac97->dev_mixer);
2082 ac97_release_codec(chip->ac97);
2083 kfree (chip);
2084
2085 printk (KERN_INFO PFX "driver released\n");
2086 }
2087
2088
2089 static struct pci_device_id forte_pci_ids[] = {
2090 { 0x1319, 0x0801, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },
2091 { 0, }
2092 };
2093
2094
2095 static struct pci_driver forte_pci_driver = {
2096 .name = DRIVER_NAME,
2097 .id_table = forte_pci_ids,
2098 .probe = forte_probe,
2099 .remove = forte_remove,
2100
2101 };
2102
2103
2104 /**
2105 * forte_init_module:
2106 *
2107 */
2108
2109 static int __init
2110 forte_init_module (void)
2111 {
2112 printk (KERN_INFO PFX DRIVER_VERSION "\n");
2113
2114 return pci_register_driver (&forte_pci_driver);
2115 }
2116
2117
2118 /**
2119 * forte_cleanup_module:
2120 *
2121 */
2122
2123 static void __exit
2124 forte_cleanup_module (void)
2125 {
2126 pci_unregister_driver (&forte_pci_driver);
2127 }
2128
2129
2130 module_init(forte_init_module);
2131 module_exit(forte_cleanup_module);
2132
2133 MODULE_AUTHOR("Martin K. Petersen <mkp@mkp.net>");
2134 MODULE_DESCRIPTION("ForteMedia FM801 OSS Driver");
2135 MODULE_LICENSE("GPL");
2136 MODULE_DEVICE_TABLE (pci, forte_pci_ids);
Historical 2.5/2.6 development