Pull context-bitmap into release branch
[linux-2.6] / sound / oss / forte.c
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 static 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 static 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_pfn_range(vma, vma->vm_start,
1413                               virt_to_phys(channel->buf) >> PAGE_SHIFT,
1414                               size, vma->vm_page_prot)) {
1415                 DPRINTK ("%s: remap el a no worko\n", __FUNCTION__);
1416                 ret = -EAGAIN;
1417                 goto out;
1418         }
1419
1420         ret = 0;
1421
1422  out:
1423         spin_unlock_irq (&chip->lock);
1424         return ret;
1425 }
1426
1427
1428 /**
1429  * forte_dsp_write:
1430  */
1431
1432 static ssize_t 
1433 forte_dsp_write (struct file *file, const char __user *buffer, size_t bytes, 
1434                  loff_t *ppos)
1435 {
1436         struct forte_chip *chip;
1437         struct forte_channel *channel;
1438         unsigned int i = bytes, sz = 0;
1439         unsigned long flags;
1440
1441         if (!access_ok (VERIFY_READ, buffer, bytes))
1442                 return -EFAULT;
1443
1444         chip = (struct forte_chip *) file->private_data;
1445
1446         if (!chip)
1447                 BUG();
1448
1449         channel = &chip->play;
1450
1451         if (!channel)
1452                 BUG();
1453
1454         spin_lock_irqsave (&chip->lock, flags);
1455
1456         /* Set up buffers with the right fragment size */
1457         forte_channel_prep (channel);
1458
1459         while (i) {
1460                 /* All fragment buffers in use -> wait */
1461                 if (channel->frag_num - channel->filled_frags == 0) {
1462                         DECLARE_WAITQUEUE (wait, current);
1463
1464                         /* For trigger or non-blocking operation, get out */
1465                         if (chip->trigger || file->f_flags & O_NONBLOCK) {
1466                                 spin_unlock_irqrestore (&chip->lock, flags);
1467                                 return -EAGAIN;
1468                         }
1469
1470                         /* Otherwise wait for buffers */
1471                         add_wait_queue (&channel->wait, &wait);
1472
1473                         for (;;) {
1474                                 spin_unlock_irqrestore (&chip->lock, flags);
1475
1476                                 set_current_state (TASK_INTERRUPTIBLE);
1477                                 schedule();
1478
1479                                 spin_lock_irqsave (&chip->lock, flags);
1480
1481                                 if (channel->frag_num - channel->filled_frags)
1482                                         break;
1483                         }
1484
1485                         remove_wait_queue (&channel->wait, &wait);
1486                         set_current_state (TASK_RUNNING);
1487
1488                         if (signal_pending (current)) {
1489                                 spin_unlock_irqrestore (&chip->lock, flags);
1490                                 return -ERESTARTSYS;
1491                         }
1492                 }
1493
1494                 if (channel->residue)
1495                         sz = channel->residue;
1496                 else if (i > channel->frag_sz)
1497                         sz = channel->frag_sz;
1498                 else
1499                         sz = i;
1500
1501                 spin_unlock_irqrestore (&chip->lock, flags);
1502
1503                 if (copy_from_user ((void *) channel->buf + channel->swptr, buffer, sz))
1504                         return -EFAULT;
1505
1506                 spin_lock_irqsave (&chip->lock, flags);
1507
1508                 /* Advance software pointer */
1509                 buffer += sz;
1510                 channel->swptr += sz;
1511                 channel->swptr %= channel->buf_sz;
1512                 i -= sz;
1513
1514                 /* Only bump filled_frags if a full fragment has been written */
1515                 if (channel->swptr % channel->frag_sz == 0) {
1516                         channel->filled_frags++;
1517                         channel->residue = 0;
1518                 }
1519                 else
1520                         channel->residue = channel->frag_sz - sz;
1521
1522                 /* If playback isn't active, start it */
1523                 if (channel->active == 0 && chip->trigger == 0)
1524                         forte_channel_start (channel);
1525         }
1526
1527         spin_unlock_irqrestore (&chip->lock, flags);
1528
1529         return bytes - i;
1530 }
1531
1532
1533 /**
1534  * forte_dsp_read:
1535  */
1536
1537 static ssize_t 
1538 forte_dsp_read (struct file *file, char __user *buffer, size_t bytes, 
1539                 loff_t *ppos)
1540 {
1541         struct forte_chip *chip;
1542         struct forte_channel *channel;
1543         unsigned int i = bytes, sz;
1544         unsigned long flags;
1545
1546         if (!access_ok (VERIFY_WRITE, buffer, bytes))
1547                 return -EFAULT;
1548
1549         chip = (struct forte_chip *) file->private_data;
1550
1551         if (!chip)
1552                 BUG();
1553
1554         channel = &chip->rec;
1555
1556         if (!channel)
1557                 BUG();
1558
1559         spin_lock_irqsave (&chip->lock, flags);
1560
1561         /* Set up buffers with the right fragment size */
1562         forte_channel_prep (channel);
1563
1564         /* Start recording */
1565         if (!chip->trigger)
1566                 forte_channel_start (channel);
1567
1568         while (i) {
1569                 /* No fragment buffers in use -> wait */
1570                 if (channel->filled_frags == 0) {
1571                         DECLARE_WAITQUEUE (wait, current);
1572
1573                         /* For trigger mode operation, get out */
1574                         if (chip->trigger) {
1575                                 spin_unlock_irqrestore (&chip->lock, flags);
1576                                 return -EAGAIN;
1577                         }
1578
1579                         add_wait_queue (&channel->wait, &wait);
1580
1581                         for (;;) {
1582                                 if (channel->active == 0)
1583                                         break;
1584
1585                                 if (channel->filled_frags)
1586                                         break;
1587                                                 
1588                                 spin_unlock_irqrestore (&chip->lock, flags);
1589
1590                                 set_current_state (TASK_INTERRUPTIBLE);
1591                                 schedule();
1592
1593                                 spin_lock_irqsave (&chip->lock, flags);
1594                         }
1595
1596                         set_current_state (TASK_RUNNING);
1597                         remove_wait_queue (&channel->wait, &wait);
1598                 }
1599
1600                 if (i > channel->frag_sz)
1601                         sz = channel->frag_sz;
1602                 else
1603                         sz = i;
1604
1605                 spin_unlock_irqrestore (&chip->lock, flags);
1606
1607                 if (copy_to_user (buffer, (void *)channel->buf+channel->swptr, sz)) {
1608                         DPRINTK ("%s: copy_to_user failed\n", __FUNCTION__);
1609                         return -EFAULT;
1610                 }
1611
1612                 spin_lock_irqsave (&chip->lock, flags);
1613
1614                 /* Advance software pointer */
1615                 buffer += sz;
1616                 if (channel->filled_frags > 0)
1617                         channel->filled_frags--;
1618                 channel->swptr += channel->frag_sz;
1619                 channel->swptr %= channel->buf_sz;
1620                 i -= sz;
1621         }
1622
1623         spin_unlock_irqrestore (&chip->lock, flags);
1624
1625         return bytes - i;
1626 }
1627
1628
1629 static struct file_operations forte_dsp_fops = {
1630         .owner                  = THIS_MODULE,
1631         .llseek                 = &no_llseek,
1632         .read                   = &forte_dsp_read,
1633         .write                  = &forte_dsp_write,
1634         .poll                   = &forte_dsp_poll,
1635         .ioctl                  = &forte_dsp_ioctl,
1636         .open                   = &forte_dsp_open,
1637         .release                = &forte_dsp_release,
1638         .mmap                   = &forte_dsp_mmap,
1639 };
1640
1641
1642 /* Common ------------------------------------------------------------------ */
1643
1644
1645 /**
1646  * forte_interrupt:
1647  */
1648
1649 static irqreturn_t
1650 forte_interrupt (int irq, void *dev_id, struct pt_regs *regs)
1651 {
1652         struct forte_chip *chip = dev_id;
1653         struct forte_channel *channel = NULL;
1654         u16 status, count; 
1655
1656         status = inw (chip->iobase + FORTE_IRQ_STATUS);
1657
1658         /* If this is not for us, get outta here ASAP */
1659         if ((status & (FORTE_IRQ_PLAYBACK | FORTE_IRQ_CAPTURE)) == 0)
1660                 return IRQ_NONE;
1661         
1662         if (status & FORTE_IRQ_PLAYBACK) {
1663                 channel = &chip->play;
1664
1665                 spin_lock (&chip->lock);
1666
1667                 if (channel->frag_sz == 0)
1668                         goto pack;
1669
1670                 /* Declare a fragment done */
1671                 if (channel->filled_frags > 0)
1672                         channel->filled_frags--;
1673                 channel->bytes += channel->frag_sz;
1674                 channel->nr_irqs++;
1675                 
1676                 /* Flip-flop between buffer I and II */
1677                 channel->next_buf ^= 1;
1678
1679                 /* Advance hardware pointer by fragment size and wrap around */
1680                 channel->hwptr += channel->frag_sz;
1681                 channel->hwptr %= channel->buf_sz;
1682
1683                 /* Buffer I or buffer II BAR */
1684                 outl (channel->buf_handle + channel->hwptr, 
1685                       channel->next_buf == 0 ?
1686                       channel->iobase + FORTE_PLY_BUF1 :
1687                       channel->iobase + FORTE_PLY_BUF2);
1688
1689                 /* If the currently playing fragment is last, schedule pause */
1690                 if (channel->filled_frags == 1) 
1691                         forte_channel_pause (channel);
1692
1693         pack:
1694                 /* Acknowledge interrupt */
1695                 outw (FORTE_IRQ_PLAYBACK, chip->iobase + FORTE_IRQ_STATUS);
1696
1697                 if (waitqueue_active (&channel->wait)) 
1698                         wake_up_all (&channel->wait);
1699
1700                 spin_unlock (&chip->lock);
1701         }
1702
1703         if (status & FORTE_IRQ_CAPTURE) {
1704                 channel = &chip->rec;
1705                 spin_lock (&chip->lock);
1706
1707                 /* One fragment filled */
1708                 channel->filled_frags++;
1709
1710                 /* Get # of completed bytes */
1711                 count = inw (channel->iobase + FORTE_PLY_COUNT) + 1;
1712
1713                 if (count == 0) {
1714                         DPRINTK ("%s: last, filled_frags = %d\n", __FUNCTION__,
1715                                  channel->filled_frags);
1716                         channel->filled_frags = 0;
1717                         goto rack;
1718                 }
1719
1720                 /* Buffer I or buffer II BAR */
1721                 outl (channel->buf_handle + channel->hwptr, 
1722                       channel->next_buf == 0 ?
1723                       channel->iobase + FORTE_PLY_BUF1 :
1724                       channel->iobase + FORTE_PLY_BUF2);
1725
1726                 /* Flip-flop between buffer I and II */
1727                 channel->next_buf ^= 1;
1728
1729                 /* Advance hardware pointer by fragment size and wrap around */
1730                 channel->hwptr += channel->frag_sz;
1731                 channel->hwptr %= channel->buf_sz;
1732
1733                 /* Out of buffers */
1734                 if (channel->filled_frags == channel->frag_num - 1)
1735                         forte_channel_stop (channel);
1736         rack:
1737                 /* Acknowledge interrupt */
1738                 outw (FORTE_IRQ_CAPTURE, chip->iobase + FORTE_IRQ_STATUS);
1739
1740                 spin_unlock (&chip->lock);
1741
1742                 if (waitqueue_active (&channel->wait))
1743                         wake_up_all (&channel->wait);           
1744         }
1745
1746         return IRQ_HANDLED;
1747 }
1748
1749
1750 /**
1751  * forte_proc_read:
1752  */
1753
1754 static int
1755 forte_proc_read (char *page, char **start, off_t off, int count, 
1756                  int *eof, void *data)
1757 {
1758         int i = 0, p_rate, p_chan, r_rate;
1759         unsigned short p_reg, r_reg;
1760
1761         i += sprintf (page, "ForteMedia FM801 OSS Lite driver\n%s\n \n", 
1762                       DRIVER_VERSION);
1763
1764         if (!forte->iobase)
1765                 return i;
1766
1767         p_rate = p_chan = -1;
1768         p_reg  = inw (forte->iobase + FORTE_PLY_CTRL);
1769         p_rate = (p_reg >> 8) & 15;
1770         p_chan = (p_reg >> 12) & 3;
1771
1772         if (p_rate >= 0 || p_rate <= 10)
1773                 p_rate = rates[p_rate];
1774
1775         if (p_chan >= 0 || p_chan <= 2)
1776                 p_chan = channels[p_chan];
1777
1778         r_rate = -1;
1779         r_reg  = inw (forte->iobase + FORTE_CAP_CTRL);
1780         r_rate = (r_reg >> 8) & 15;
1781
1782         if (r_rate >= 0 || r_rate <= 10)
1783                 r_rate = rates[r_rate]; 
1784
1785         i += sprintf (page + i,
1786                       "             Playback  Capture\n"
1787                       "FIFO empty : %-3s       %-3s\n"
1788                       "Buf1 Last  : %-3s       %-3s\n"
1789                       "Buf2 Last  : %-3s       %-3s\n"
1790                       "Started    : %-3s       %-3s\n"
1791                       "Paused     : %-3s       %-3s\n"
1792                       "Immed Stop : %-3s       %-3s\n"
1793                       "Rate       : %-5d     %-5d\n"
1794                       "Channels   : %-5d     -\n"
1795                       "16-bit     : %-3s       %-3s\n"
1796                       "Stereo     : %-3s       %-3s\n"
1797                       " \n"
1798                       "Buffer Sz  : %-6d    %-6d\n"
1799                       "Frag Sz    : %-6d    %-6d\n"
1800                       "Frag Num   : %-6d    %-6d\n"
1801                       "Frag msecs : %-6d    %-6d\n"
1802                       "Used Frags : %-6d    %-6d\n"
1803                       "Mapped     : %-3s       %-3s\n",
1804                       p_reg & 1<<0  ? "yes" : "no",
1805                       r_reg & 1<<0  ? "yes" : "no",
1806                       p_reg & 1<<1  ? "yes" : "no",
1807                       r_reg & 1<<1  ? "yes" : "no",
1808                       p_reg & 1<<2  ? "yes" : "no",
1809                       r_reg & 1<<2  ? "yes" : "no",
1810                       p_reg & 1<<5  ? "yes" : "no",
1811                       r_reg & 1<<5  ? "yes" : "no",
1812                       p_reg & 1<<6  ? "yes" : "no",
1813                       r_reg & 1<<6  ? "yes" : "no",
1814                       p_reg & 1<<7  ? "yes" : "no",
1815                       r_reg & 1<<7  ? "yes" : "no",
1816                       p_rate, r_rate,
1817                       p_chan,
1818                       p_reg & 1<<14 ? "yes" : "no",
1819                       r_reg & 1<<14 ? "yes" : "no",
1820                       p_reg & 1<<15 ? "yes" : "no",
1821                       r_reg & 1<<15 ? "yes" : "no",
1822                       forte->play.buf_sz,       forte->rec.buf_sz,
1823                       forte->play.frag_sz,      forte->rec.frag_sz,
1824                       forte->play.frag_num,     forte->rec.frag_num,
1825                       forte->play.frag_msecs,   forte->rec.frag_msecs,
1826                       forte->play.filled_frags, forte->rec.filled_frags,
1827                       forte->play.mapped ? "yes" : "no",
1828                       forte->rec.mapped ? "yes" : "no"
1829                 );
1830
1831         return i;
1832 }
1833
1834
1835 /**
1836  * forte_proc_init:
1837  *
1838  * Creates driver info entries in /proc
1839  */
1840
1841 static int __init 
1842 forte_proc_init (void)
1843 {
1844         if (!proc_mkdir ("driver/forte", NULL))
1845                 return -EIO;
1846
1847         if (!create_proc_read_entry ("driver/forte/chip", 0, NULL, forte_proc_read, forte)) {
1848                 remove_proc_entry ("driver/forte", NULL);
1849                 return -EIO;
1850         }
1851
1852         if (!create_proc_read_entry("driver/forte/ac97", 0, NULL, ac97_read_proc, forte->ac97)) {
1853                 remove_proc_entry ("driver/forte/chip", NULL);
1854                 remove_proc_entry ("driver/forte", NULL);
1855                 return -EIO;
1856         }
1857
1858         return 0;
1859 }
1860
1861
1862 /**
1863  * forte_proc_remove:
1864  *
1865  * Removes driver info entries in /proc
1866  */
1867
1868 static void
1869 forte_proc_remove (void)
1870 {
1871         remove_proc_entry ("driver/forte/ac97", NULL);
1872         remove_proc_entry ("driver/forte/chip", NULL);
1873         remove_proc_entry ("driver/forte", NULL);       
1874 }
1875
1876
1877 /**
1878  * forte_chip_init:
1879  * @chip:       Chip instance to initialize
1880  *
1881  * Description:
1882  *              Resets chip, configures codec and registers the driver with
1883  *              the sound subsystem.
1884  *
1885  *              Press and hold Start for 8 secs, then switch on Run
1886  *              and hold for 4 seconds.  Let go of Start.  Numbers
1887  *              assume a properly oiled TWG.
1888  */
1889
1890 static int __devinit
1891 forte_chip_init (struct forte_chip *chip)
1892 {
1893         u8 revision;
1894         u16 cmdw;
1895         struct ac97_codec *codec;
1896
1897         pci_read_config_byte (chip->pci_dev, PCI_REVISION_ID, &revision);
1898
1899         if (revision >= 0xB1) {
1900                 chip->multichannel = 1;
1901                 printk (KERN_INFO PFX "Multi-channel device detected.\n");
1902         }
1903
1904         /* Reset chip */
1905         outw (FORTE_CC_CODEC_RESET | FORTE_CC_AC97_RESET, 
1906               chip->iobase + FORTE_CODEC_CTRL);
1907         udelay(100);
1908         outw (0, chip->iobase + FORTE_CODEC_CTRL);
1909
1910         /* Request read from AC97 */
1911         outw (FORTE_AC97_READ | (0 << FORTE_AC97_ADDR_SHIFT), 
1912               chip->iobase + FORTE_AC97_CMD);
1913         mdelay(750);
1914
1915         if ((inw (chip->iobase + FORTE_AC97_CMD) & (3<<8)) != (1<<8)) {
1916                 printk (KERN_INFO PFX "AC97 codec not responding");
1917                 return -EIO;
1918         }
1919
1920         /* Init volume */
1921         outw (0x0808, chip->iobase + FORTE_PCM_VOL);
1922         outw (0x9f1f, chip->iobase + FORTE_FM_VOL);
1923         outw (0x8808, chip->iobase + FORTE_I2S_VOL);
1924
1925         /* I2S control - I2S mode */
1926         outw (0x0003, chip->iobase + FORTE_I2S_MODE);
1927
1928         /* Interrupt setup - unmask PLAYBACK & CAPTURE */
1929         cmdw = inw (chip->iobase + FORTE_IRQ_MASK);
1930         cmdw &= ~0x0003;
1931         outw (cmdw, chip->iobase + FORTE_IRQ_MASK);
1932
1933         /* Interrupt clear */
1934         outw (FORTE_IRQ_PLAYBACK|FORTE_IRQ_CAPTURE, 
1935               chip->iobase + FORTE_IRQ_STATUS);
1936
1937         /* Set up the AC97 codec */
1938         if ((codec = ac97_alloc_codec()) == NULL)
1939                 return -ENOMEM;
1940         codec->private_data = chip;
1941         codec->codec_read = forte_ac97_read;
1942         codec->codec_write = forte_ac97_write;
1943         codec->id = 0;
1944
1945         if (ac97_probe_codec (codec) == 0) {
1946                 printk (KERN_ERR PFX "codec probe failed\n");
1947                 ac97_release_codec(codec);
1948                 return -1;
1949         }
1950
1951         /* Register mixer */
1952         if ((codec->dev_mixer = 
1953              register_sound_mixer (&forte_mixer_fops, -1)) < 0) {
1954                 printk (KERN_ERR PFX "couldn't register mixer!\n");
1955                 ac97_release_codec(codec);
1956                 return -1;
1957         }
1958
1959         chip->ac97 = codec;
1960
1961         /* Register DSP */
1962         if ((chip->dsp = register_sound_dsp (&forte_dsp_fops, -1) ) < 0) {
1963                 printk (KERN_ERR PFX "couldn't register dsp!\n");
1964                 return -1;
1965         }
1966
1967         /* Register with /proc */
1968         if (forte_proc_init()) {
1969                 printk (KERN_ERR PFX "couldn't add entries to /proc!\n");
1970                 return -1;
1971         }
1972
1973         return 0;
1974 }
1975
1976
1977 /**
1978  * forte_probe:
1979  * @pci_dev:    PCI struct for probed device
1980  * @pci_id:     
1981  *
1982  * Description:
1983  *              Allocates chip instance, I/O region, and IRQ
1984  */
1985 static int __init 
1986 forte_probe (struct pci_dev *pci_dev, const struct pci_device_id *pci_id)
1987 {
1988         struct forte_chip *chip;
1989         int ret = 0;
1990
1991         /* FIXME: Support more than one chip */
1992         if (found++)
1993                 return -EIO;
1994
1995         /* Ignition */
1996         if (pci_enable_device (pci_dev))
1997                 return -EIO;
1998
1999         pci_set_master (pci_dev);
2000
2001         /* Allocate chip instance and configure */
2002         forte = (struct forte_chip *) 
2003                 kmalloc (sizeof (struct forte_chip), GFP_KERNEL);
2004         chip = forte;
2005
2006         if (chip == NULL) {
2007                 printk (KERN_WARNING PFX "Out of memory");
2008                 return -ENOMEM;
2009         }
2010
2011         memset (chip, 0, sizeof (struct forte_chip));
2012         chip->pci_dev = pci_dev;
2013
2014         init_MUTEX(&chip->open_sem);
2015         spin_lock_init (&chip->lock);
2016         spin_lock_init (&chip->ac97_lock);
2017
2018         if (! request_region (pci_resource_start (pci_dev, 0),
2019                               pci_resource_len (pci_dev, 0), DRIVER_NAME)) {
2020                 printk (KERN_WARNING PFX "Unable to reserve I/O space");
2021                 ret = -ENOMEM;
2022                 goto error;
2023         }
2024
2025         chip->iobase = pci_resource_start (pci_dev, 0);
2026         chip->irq = pci_dev->irq;
2027
2028         if (request_irq (chip->irq, forte_interrupt, SA_SHIRQ, DRIVER_NAME,
2029                          chip)) {
2030                 printk (KERN_WARNING PFX "Unable to reserve IRQ");
2031                 ret = -EIO;
2032                 goto error;
2033         }               
2034         
2035         pci_set_drvdata (pci_dev, chip);
2036
2037         printk (KERN_INFO PFX "FM801 chip found at 0x%04lX-0x%04lX IRQ %u\n", 
2038                 chip->iobase, pci_resource_end (pci_dev, 0), chip->irq);
2039
2040         /* Power it up */
2041         if ((ret = forte_chip_init (chip)) == 0)
2042                 return 0;
2043
2044  error:
2045         if (chip->irq)
2046                 free_irq (chip->irq, chip);
2047
2048         if (chip->iobase) 
2049                 release_region (pci_resource_start (pci_dev, 0),
2050                                 pci_resource_len (pci_dev, 0));
2051                 
2052         kfree (chip);
2053
2054         return ret;
2055 }
2056
2057
2058 /**
2059  * forte_remove:
2060  * @pci_dev:    PCI device to unclaim
2061  *
2062  */
2063
2064 static void 
2065 forte_remove (struct pci_dev *pci_dev)
2066 {
2067         struct forte_chip *chip = pci_get_drvdata (pci_dev);
2068
2069         if (chip == NULL)
2070                 return;
2071
2072         /* Turn volume down to avoid popping */
2073         outw (0x1f1f, chip->iobase + FORTE_PCM_VOL);
2074         outw (0x1f1f, chip->iobase + FORTE_FM_VOL);
2075         outw (0x1f1f, chip->iobase + FORTE_I2S_VOL);
2076
2077         forte_proc_remove();
2078         free_irq (chip->irq, chip);
2079         release_region (chip->iobase, pci_resource_len (pci_dev, 0));
2080
2081         unregister_sound_dsp (chip->dsp);
2082         unregister_sound_mixer (chip->ac97->dev_mixer);
2083         ac97_release_codec(chip->ac97);
2084         kfree (chip);
2085
2086         printk (KERN_INFO PFX "driver released\n");
2087 }
2088
2089
2090 static struct pci_device_id forte_pci_ids[] = {
2091         { 0x1319, 0x0801, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, },
2092         { 0, }
2093 };
2094
2095
2096 static struct pci_driver forte_pci_driver = {
2097         .name                   = DRIVER_NAME,
2098         .id_table               = forte_pci_ids,
2099         .probe                  = forte_probe,
2100         .remove                 = forte_remove,
2101
2102 };
2103
2104
2105 /**
2106  * forte_init_module:
2107  *
2108  */
2109
2110 static int __init
2111 forte_init_module (void)
2112 {
2113         printk (KERN_INFO PFX DRIVER_VERSION "\n");
2114
2115         return pci_register_driver (&forte_pci_driver);
2116 }
2117
2118
2119 /**
2120  * forte_cleanup_module:
2121  *
2122  */
2123
2124 static void __exit 
2125 forte_cleanup_module (void)
2126 {
2127         pci_unregister_driver (&forte_pci_driver);
2128 }
2129
2130
2131 module_init(forte_init_module);
2132 module_exit(forte_cleanup_module);
2133
2134 MODULE_AUTHOR("Martin K. Petersen <mkp@mkp.net>");
2135 MODULE_DESCRIPTION("ForteMedia FM801 OSS Driver");
2136 MODULE_LICENSE("GPL");
2137 MODULE_DEVICE_TABLE (pci, forte_pci_ids);