Merge branch 'upstream-fixes' of master.kernel.org:/pub/scm/linux/kernel/git/jgarzik...
[linux-2.6] / sound / oss / ite8172.c
1 /*
2  *      ite8172.c  --  ITE IT8172G Sound Driver.
3  *
4  * Copyright 2001 MontaVista Software Inc.
5  * Author: MontaVista Software, Inc.
6  *              stevel@mvista.com or source@mvista.com
7  *
8  *  This program is free software; you can redistribute  it and/or modify it
9  *  under  the terms of  the GNU General  Public License as published by the
10  *  Free Software Foundation;  either version 2 of the  License, or (at your
11  *  option) any later version.
12  *
13  *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
14  *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
15  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
16  *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,
17  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
18  *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
19  *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
20  *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
21  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
22  *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23  *
24  *  You should have received a copy of the  GNU General Public License along
25  *  with this program; if not, write  to the Free Software Foundation, Inc.,
26  *  675 Mass Ave, Cambridge, MA 02139, USA.
27  *
28  *
29  * Module command line parameters:
30  *
31  *  Supported devices:
32  *  /dev/dsp    standard OSS /dev/dsp device
33  *  /dev/mixer  standard OSS /dev/mixer device
34  *
35  * Notes:
36  *
37  *  1. Much of the OSS buffer allocation, ioctl's, and mmap'ing are
38  *     taken, slightly modified or not at all, from the ES1371 driver,
39  *     so refer to the credits in es1371.c for those. The rest of the
40  *     code (probe, open, read, write, the ISR, etc.) is new.
41  *  2. The following support is untested:
42  *      * Memory mapping the audio buffers, and the ioctl controls that go
43  *        with it.
44  *      * S/PDIF output.
45  *      * I2S support.
46  *  3. The following is not supported:
47  *      * legacy audio mode.
48  *  4. Support for volume button interrupts is implemented but doesn't
49  *     work yet.
50  *
51  *  Revision history
52  *    02.08.2001  Initial release
53  *    06.22.2001  Added I2S support
54  *    07.30.2003  Removed initialisation to zero for static variables
55  *                 (spdif[NR_DEVICE], i2s_fmt[NR_DEVICE], and devindex)
56  */
57 #include <linux/module.h>
58 #include <linux/string.h>
59 #include <linux/ioport.h>
60 #include <linux/sched.h>
61 #include <linux/delay.h>
62 #include <linux/sound.h>
63 #include <linux/slab.h>
64 #include <linux/soundcard.h>
65 #include <linux/pci.h>
66 #include <linux/init.h>
67 #include <linux/poll.h>
68 #include <linux/bitops.h>
69 #include <linux/proc_fs.h>
70 #include <linux/spinlock.h>
71 #include <linux/smp_lock.h>
72 #include <linux/ac97_codec.h>
73 #include <linux/interrupt.h>
74 #include <asm/io.h>
75 #include <asm/dma.h>
76 #include <asm/uaccess.h>
77 #include <asm/it8172/it8172.h>
78
79 /* --------------------------------------------------------------------- */
80
81 #undef OSS_DOCUMENTED_MIXER_SEMANTICS
82 #define IT8172_DEBUG
83 #undef IT8172_VERBOSE_DEBUG
84 #define DBG(x) {}
85
86 #define IT8172_MODULE_NAME "IT8172 audio"
87 #define PFX IT8172_MODULE_NAME
88
89 #ifdef IT8172_DEBUG
90 #define dbg(format, arg...) printk(KERN_DEBUG PFX ": " format "\n" , ## arg)
91 #else
92 #define dbg(format, arg...) do {} while (0)
93 #endif
94 #define err(format, arg...) printk(KERN_ERR PFX ": " format "\n" , ## arg)
95 #define info(format, arg...) printk(KERN_INFO PFX ": " format "\n" , ## arg)
96 #define warn(format, arg...) printk(KERN_WARNING PFX ": " format "\n" , ## arg)
97
98
99 #define IT8172_MODULE_NAME "IT8172 audio"
100 #define PFX IT8172_MODULE_NAME
101
102 #ifdef IT8172_DEBUG
103 #define dbg(format, arg...) printk(KERN_DEBUG PFX ": " format "\n" , ## arg)
104 #else
105 #define dbg(format, arg...) do {} while (0)
106 #endif
107 #define err(format, arg...) printk(KERN_ERR PFX ": " format "\n" , ## arg)
108 #define info(format, arg...) printk(KERN_INFO PFX ": " format "\n" , ## arg)
109 #define warn(format, arg...) printk(KERN_WARNING PFX ": " format "\n" , ## arg)
110
111
112 static const unsigned sample_shift[] = { 0, 1, 1, 2 };
113
114
115 /*
116  * Audio Controller register bit definitions follow. See
117  * include/asm/it8172/it8172.h for register offsets.
118  */
119
120 /* PCM Out Volume Reg */
121 #define PCMOV_PCMOM     (1<<15) /* PCM Out Mute default 1: mute */
122 #define PCMOV_PCMRCG_BIT 8      /* PCM Right channel Gain */
123 #define PCMOV_PCMRCG_MASK (0x1f<<PCMOV_PCMRCG_BIT)
124 #define PCMOV_PCMLCG_BIT 0      /* PCM Left channel gain  */
125 #define PCMOV_PCMLCG_MASK 0x1f
126
127 /* FM Out Volume Reg */
128 #define FMOV_FMOM       (1<<15) /* FM Out Mute default 1: mute */
129 #define FMOV_FMRCG_BIT  8       /* FM Right channel Gain */
130 #define FMOV_FMRCG_MASK (0x1f<<FMOV_FMRCG_BIT)
131 #define FMOV_FMLCG_BIT  0       /* FM Left channel gain  */
132 #define FMOV_FMLCG_MASK 0x1f
133
134 /* I2S Out Volume Reg */
135 #define I2SV_I2SOM       (1<<15) /* I2S Out Mute default 1: mute */
136 #define I2SV_I2SRCG_BIT  8       /* I2S Right channel Gain */
137 #define I2SV_I2SRCG_MASK (0x1f<<I2SV_I2SRCG_BIT)
138 #define I2SV_I2SLCG_BIT  0       /* I2S Left channel gain  */
139 #define I2SV_I2SLCG_MASK 0x1f
140
141 /* Digital Recording Source Select Reg */
142 #define DRSS_BIT   0
143 #define DRSS_MASK  0x07
144 #define   DRSS_AC97_PRIM 0
145 #define   DRSS_FM        1
146 #define   DRSS_I2S       2
147 #define   DRSS_PCM       3
148 #define   DRSS_AC97_SEC  4
149
150 /* Playback/Capture Channel Control Registers */
151 #define CC_SM           (1<<15) /* Stereo, Mone 0: mono 1: stereo */
152 #define CC_DF           (1<<14) /* Data Format 0: 8 bit 1: 16 bit */
153 #define CC_FMT_BIT      14
154 #define CC_FMT_MASK     (0x03<<CC_FMT_BIT)
155 #define CC_CF_BIT       12      /* Channel format (Playback only) */
156 #define CC_CF_MASK      (0x03<<CC_CF_BIT)
157 #define   CC_CF_2       0
158 #define   CC_CF_4       (1<<CC_CF_BIT)
159 #define   CC_CF_6       (2<<CC_CF_BIT)
160 #define CC_SR_BIT       8       /* sample Rate */
161 #define CC_SR_MASK      (0x0f<<CC_SR_BIT)
162 #define   CC_SR_5500    0
163 #define   CC_SR_8000    (1<<CC_SR_BIT)
164 #define   CC_SR_9600    (2<<CC_SR_BIT)
165 #define   CC_SR_11025   (3<<CC_SR_BIT)
166 #define   CC_SR_16000   (4<<CC_SR_BIT)
167 #define   CC_SR_19200   (5<<CC_SR_BIT)
168 #define   CC_SR_22050   (6<<CC_SR_BIT)
169 #define   CC_SR_32000   (7<<CC_SR_BIT)
170 #define   CC_SR_38400   (8<<CC_SR_BIT)
171 #define   CC_SR_44100   (9<<CC_SR_BIT)
172 #define   CC_SR_48000   (10<<CC_SR_BIT)
173 #define CC_CSP          (1<<7)  /* Channel stop 
174                                  * 0: End of Current buffer
175                                  * 1: Immediately stop when rec stop */
176 #define CC_CP           (1<<6)  /* Channel pause 0: normal, 1: pause */
177 #define CC_CA           (1<<5)  /* Channel Action 0: Stop , 1: start */
178 #define CC_CB2L         (1<<2)  /* Cur. buf. 2 xfr is last 0: No, 1: Yes */
179 #define CC_CB1L         (1<<1)  /* Cur. buf. 1 xfr is last 0: No, 1: Yes */
180 #define CC_DE           1       /* DFC/DFIFO Data Empty 1: empty, 0: not empty
181                                  * (Playback only)
182                                  */
183
184 /* Codec Control Reg */
185 #define CODECC_GME      (1<<9)  /* AC97 GPIO Mode enable */
186 #define CODECC_ATM      (1<<8)  /* AC97 ATE test mode 0: test 1: normal */
187 #define CODECC_WR       (1<<6)  /* AC97 Warn reset 1: warm reset , 0: Normal */
188 #define CODECC_CR       (1<<5)  /* AC97 Cold reset 1: Cold reset , 0: Normal */
189
190
191 /* I2S Control Reg      */
192 #define I2SMC_SR_BIT     6      /* I2S Sampling rate 
193                                  * 00: 48KHz, 01: 44.1 KHz, 10: 32 32 KHz */
194 #define I2SMC_SR_MASK    (0x03<<I2SMC_SR_BIT)
195 #define   I2SMC_SR_48000 0
196 #define   I2SMC_SR_44100 (1<<I2SMC_SR_BIT)
197 #define   I2SMC_SR_32000 (2<<I2SMC_SR_BIT)
198 #define I2SMC_SRSS       (1<<5) /* Sample Rate Source Select 1:S/W, 0: H/W */
199 #define I2SMC_I2SF_BIT   0      /* I2S Format */
200 #define I2SMC_I2SF_MASK  0x03
201 #define   I2SMC_I2SF_DAC 0
202 #define   I2SMC_I2SF_ADC 2
203 #define   I2SMC_I2SF_I2S 3
204
205
206 /* Volume up, Down, Mute */
207 #define VS_VMP  (1<<2)  /* Volume mute 1: pushed, 0: not */
208 #define VS_VDP  (1<<1)  /* Volume Down 1: pushed, 0: not */
209 #define VS_VUP  1       /* Volime Up 1: pushed, 0: not */
210
211 /* SRC, Mixer test control/DFC status reg */
212 #define SRCS_DPUSC      (1<<5)  /* DFC Playback underrun Status/clear */
213 #define SRCS_DCOSC      (1<<4)  /* DFC Capture Overrun Status/clear */
214 #define SRCS_SIS        (1<<3)  /* SRC input select 1: Mixer, 0: Codec I/F */
215 #define SRCS_CDIS_BIT   0       /* Codec Data Input Select */
216 #define SRCS_CDIS_MASK  0x07
217 #define   SRCS_CDIS_MIXER 0
218 #define   SRCS_CDIS_PCM   1
219 #define   SRCS_CDIS_I2S   2
220 #define   SRCS_CDIS_FM    3
221 #define   SRCS_CDIS_DFC   4
222
223
224 /* Codec Index Reg command Port */
225 #define CIRCP_CID_BIT   10
226 #define CIRCP_CID_MASK  (0x03<<CIRCP_CID_BIT)
227 #define CIRCP_CPS       (1<<9)  /* Command Port Status 0: ready, 1: busy */
228 #define CIRCP_DPVF      (1<<8)  /* Data Port Valid Flag 0: invalis, 1: valid */
229 #define CIRCP_RWC       (1<<7)  /* Read/write command */
230 #define CIRCP_CIA_BIT   0
231 #define CIRCP_CIA_MASK  0x007F  /* Codec Index Address */
232
233 /* Test Mode Control/Test group Select Control */
234
235 /* General Control Reg */
236 #define GC_VDC_BIT      6       /* Volume Division Control */
237 #define GC_VDC_MASK     (0x03<<GC_VDC_BIT)
238 #define   GC_VDC_NONE   0
239 #define   GC_VDC_DIV2   (1<<GC_VDC_BIT)
240 #define   GC_VDC_DIV4   (2<<GC_VDC_BIT)
241 #define GC_SOE          (1<<2)  /* S/PDIF Output enable */
242 #define GC_SWR          1       /* Software warn reset */
243
244 /* Interrupt mask Control Reg */
245 #define IMC_VCIM        (1<<6)  /* Volume CNTL interrupt mask */
246 #define IMC_CCIM        (1<<1)  /* Capture Chan. iterrupt mask */
247 #define IMC_PCIM        1       /* Playback Chan. interrupt mask */
248
249 /* Interrupt status/clear reg */
250 #define ISC_VCI         (1<<6)  /* Volume CNTL interrupt 1: clears */
251 #define ISC_CCI         (1<<1)  /* Capture Chan. interrupt 1: clears  */
252 #define ISC_PCI         1       /* Playback Chan. interrupt 1: clears */
253
254 /* misc stuff */
255 #define POLL_COUNT   0x5000
256
257
258 /* --------------------------------------------------------------------- */
259
260 /*
261  * Define DIGITAL1 as the I2S channel, since it is not listed in
262  * soundcard.h.
263  */
264 #define SOUND_MIXER_I2S        SOUND_MIXER_DIGITAL1
265 #define SOUND_MASK_I2S         SOUND_MASK_DIGITAL1
266 #define SOUND_MIXER_READ_I2S   MIXER_READ(SOUND_MIXER_I2S)
267 #define SOUND_MIXER_WRITE_I2S  MIXER_WRITE(SOUND_MIXER_I2S)
268
269 /* --------------------------------------------------------------------- */
270
271 struct it8172_state {
272         /* list of it8172 devices */
273         struct list_head devs;
274
275         /* the corresponding pci_dev structure */
276         struct pci_dev *dev;
277
278         /* soundcore stuff */
279         int dev_audio;
280
281         /* hardware resources */
282         unsigned long io;
283         unsigned int irq;
284
285         /* PCI ID's */
286         u16 vendor;
287         u16 device;
288         u8 rev; /* the chip revision */
289
290         /* options */
291         int spdif_volume; /* S/PDIF output is enabled if != -1 */
292         int i2s_volume;   /* current I2S out volume, in OSS format */
293         int i2s_recording;/* 1 = recording from I2S, 0 = not */
294     
295 #ifdef IT8172_DEBUG
296         /* debug /proc entry */
297         struct proc_dir_entry *ps;
298         struct proc_dir_entry *ac97_ps;
299 #endif /* IT8172_DEBUG */
300
301         struct ac97_codec codec;
302
303         unsigned short pcc, capcc;
304         unsigned dacrate, adcrate;
305
306         spinlock_t lock;
307         struct semaphore open_sem;
308         mode_t open_mode;
309         wait_queue_head_t open_wait;
310
311         struct dmabuf {
312                 void *rawbuf;
313                 dma_addr_t dmaaddr;
314                 unsigned buforder;
315                 unsigned numfrag;
316                 unsigned fragshift;
317                 void* nextIn;
318                 void* nextOut;
319                 int count;
320                 int curBufPtr;
321                 unsigned total_bytes;
322                 unsigned error; /* over/underrun */
323                 wait_queue_head_t wait;
324                 /* redundant, but makes calculations easier */
325                 unsigned fragsize;
326                 unsigned dmasize;
327                 unsigned fragsamples;
328                 /* OSS stuff */
329                 unsigned mapped:1;
330                 unsigned ready:1;
331                 unsigned stopped:1;
332                 unsigned ossfragshift;
333                 int ossmaxfrags;
334                 unsigned subdivision;
335         } dma_dac, dma_adc;
336 };
337
338 /* --------------------------------------------------------------------- */
339
340 static LIST_HEAD(devs);
341
342 /* --------------------------------------------------------------------- */
343
344 static inline unsigned ld2(unsigned int x)
345 {
346         unsigned r = 0;
347         
348         if (x >= 0x10000) {
349                 x >>= 16;
350                 r += 16;
351         }
352         if (x >= 0x100) {
353                 x >>= 8;
354                 r += 8;
355         }
356         if (x >= 0x10) {
357                 x >>= 4;
358                 r += 4;
359         }
360         if (x >= 4) {
361                 x >>= 2;
362                 r += 2;
363         }
364         if (x >= 2)
365                 r++;
366         return r;
367 }
368
369 /* --------------------------------------------------------------------- */
370
371 static void it8172_delay(int msec)
372 {
373         unsigned long tmo;
374         signed long tmo2;
375
376         if (in_interrupt())
377                 return;
378     
379         tmo = jiffies + (msec*HZ)/1000;
380         for (;;) {
381                 tmo2 = tmo - jiffies;
382                 if (tmo2 <= 0)
383                         break;
384                 schedule_timeout(tmo2);
385         }
386 }
387
388
389 static unsigned short
390 get_compat_rate(unsigned* rate)
391 {
392         unsigned rate_out = *rate;
393         unsigned short sr;
394     
395         if (rate_out >= 46050) {
396                 sr = CC_SR_48000; rate_out = 48000;
397         } else if (rate_out >= 41250) {
398                 sr = CC_SR_44100; rate_out = 44100;
399         } else if (rate_out >= 35200) {
400                 sr = CC_SR_38400; rate_out = 38400;
401         } else if (rate_out >= 27025) {
402                 sr = CC_SR_32000; rate_out = 32000;
403         } else if (rate_out >= 20625) {
404                 sr = CC_SR_22050; rate_out = 22050;
405         } else if (rate_out >= 17600) {
406                 sr = CC_SR_19200; rate_out = 19200;
407         } else if (rate_out >= 13513) {
408                 sr = CC_SR_16000; rate_out = 16000;
409         } else if (rate_out >= 10313) {
410                 sr = CC_SR_11025; rate_out = 11025;
411         } else if (rate_out >= 8800) {
412                 sr = CC_SR_9600; rate_out = 9600;
413         } else if (rate_out >= 6750) {
414                 sr = CC_SR_8000; rate_out = 8000;
415         } else {
416                 sr = CC_SR_5500; rate_out = 5500;
417         }
418
419         *rate = rate_out;
420         return sr;
421 }
422
423 static void set_adc_rate(struct it8172_state *s, unsigned rate)
424 {
425         unsigned long flags;
426         unsigned short sr;
427     
428         sr = get_compat_rate(&rate);
429
430         spin_lock_irqsave(&s->lock, flags);
431         s->capcc &= ~CC_SR_MASK;
432         s->capcc |= sr;
433         outw(s->capcc, s->io+IT_AC_CAPCC);
434         spin_unlock_irqrestore(&s->lock, flags);
435
436         s->adcrate = rate;
437 }
438
439
440 static void set_dac_rate(struct it8172_state *s, unsigned rate)
441 {
442         unsigned long flags;
443         unsigned short sr;
444     
445         sr = get_compat_rate(&rate);
446
447         spin_lock_irqsave(&s->lock, flags);
448         s->pcc &= ~CC_SR_MASK;
449         s->pcc |= sr;
450         outw(s->pcc, s->io+IT_AC_PCC);
451         spin_unlock_irqrestore(&s->lock, flags);
452
453         s->dacrate = rate;
454 }
455
456
457 /* --------------------------------------------------------------------- */
458
459 static u16 rdcodec(struct ac97_codec *codec, u8 addr)
460 {
461         struct it8172_state *s = (struct it8172_state *)codec->private_data;
462         unsigned long flags;
463         unsigned short circp, data;
464         int i;
465     
466         spin_lock_irqsave(&s->lock, flags);
467
468         for (i = 0; i < POLL_COUNT; i++)
469                 if (!(inw(s->io+IT_AC_CIRCP) & CIRCP_CPS))
470                         break;
471         if (i == POLL_COUNT)
472                 err("rdcodec: codec ready poll expired!");
473
474         circp = addr & CIRCP_CIA_MASK;
475         circp |= (codec->id << CIRCP_CID_BIT);
476         circp |= CIRCP_RWC; // read command
477         outw(circp, s->io+IT_AC_CIRCP);
478
479         /* now wait for the data */
480         for (i = 0; i < POLL_COUNT; i++)
481                 if (inw(s->io+IT_AC_CIRCP) & CIRCP_DPVF)
482                         break;
483         if (i == POLL_COUNT)
484                 err("rdcodec: read poll expired!");
485
486         data = inw(s->io+IT_AC_CIRDP);
487         spin_unlock_irqrestore(&s->lock, flags);
488
489         return data;
490 }
491
492
493 static void wrcodec(struct ac97_codec *codec, u8 addr, u16 data)
494 {
495         struct it8172_state *s = (struct it8172_state *)codec->private_data;
496         unsigned long flags;
497         unsigned short circp;
498         int i;
499     
500         spin_lock_irqsave(&s->lock, flags);
501
502         for (i = 0; i < POLL_COUNT; i++)
503                 if (!(inw(s->io+IT_AC_CIRCP) & CIRCP_CPS))
504                         break;
505         if (i == POLL_COUNT)
506                 err("wrcodec: codec ready poll expired!");
507
508         circp = addr & CIRCP_CIA_MASK;
509         circp |= (codec->id << CIRCP_CID_BIT);
510         circp &= ~CIRCP_RWC; // write command
511
512         outw(data,  s->io+IT_AC_CIRDP);  // send data first
513         outw(circp, s->io+IT_AC_CIRCP);
514
515         spin_unlock_irqrestore(&s->lock, flags);
516 }
517
518
519 static void waitcodec(struct ac97_codec *codec)
520 {
521         unsigned short temp;
522
523         /* codec_wait is used to wait for a ready state after
524            an AC97_RESET. */
525         it8172_delay(10);
526
527         temp = rdcodec(codec, 0x26);
528
529         // If power down, power up
530         if (temp & 0x3f00) {
531                 // Power on
532                 wrcodec(codec, 0x26, 0);
533                 it8172_delay(100);
534                 // Reread
535                 temp = rdcodec(codec, 0x26);
536         }
537     
538         // Check if Codec REF,ANL,DAC,ADC ready***/
539         if ((temp & 0x3f0f) != 0x000f) {
540                 err("codec reg 26 status (0x%x) not ready!!", temp);
541                 return;
542         }
543 }
544
545
546 /* --------------------------------------------------------------------- */
547
548 static inline void stop_adc(struct it8172_state *s)
549 {
550         struct dmabuf* db = &s->dma_adc;
551         unsigned long flags;
552         unsigned char imc;
553     
554         if (db->stopped)
555                 return;
556
557         spin_lock_irqsave(&s->lock, flags);
558
559         s->capcc &= ~(CC_CA | CC_CP | CC_CB2L | CC_CB1L);
560         s->capcc |= CC_CSP;
561         outw(s->capcc, s->io+IT_AC_CAPCC);
562     
563         // disable capture interrupt
564         imc = inb(s->io+IT_AC_IMC);
565         outb(imc | IMC_CCIM, s->io+IT_AC_IMC);
566
567         db->stopped = 1;
568
569         spin_unlock_irqrestore(&s->lock, flags);
570 }       
571
572 static inline void stop_dac(struct it8172_state *s)
573 {
574         struct dmabuf* db = &s->dma_dac;
575         unsigned long flags;
576         unsigned char imc;
577     
578         if (db->stopped)
579                 return;
580
581         spin_lock_irqsave(&s->lock, flags);
582
583         s->pcc &= ~(CC_CA | CC_CP | CC_CB2L | CC_CB1L);
584         s->pcc |= CC_CSP;
585         outw(s->pcc, s->io+IT_AC_PCC);
586     
587         // disable playback interrupt
588         imc = inb(s->io+IT_AC_IMC);
589         outb(imc | IMC_PCIM, s->io+IT_AC_IMC);
590
591         db->stopped = 1;
592     
593         spin_unlock_irqrestore(&s->lock, flags);
594 }       
595
596 static void start_dac(struct it8172_state *s)
597 {
598         struct dmabuf* db = &s->dma_dac;
599         unsigned long flags;
600         unsigned char imc;
601         unsigned long buf1, buf2;
602     
603         if (!db->stopped)
604                 return;
605     
606         spin_lock_irqsave(&s->lock, flags);
607
608         // reset Buffer 1 and 2 pointers to nextOut and nextOut+fragsize
609         buf1 = virt_to_bus(db->nextOut);
610         buf2 = buf1 + db->fragsize;
611         if (buf2 >= db->dmaaddr + db->dmasize)
612                 buf2 -= db->dmasize;
613     
614         outl(buf1, s->io+IT_AC_PCB1STA);
615         outl(buf2, s->io+IT_AC_PCB2STA);
616         db->curBufPtr = IT_AC_PCB1STA;
617     
618         // enable playback interrupt
619         imc = inb(s->io+IT_AC_IMC);
620         outb(imc & ~IMC_PCIM, s->io+IT_AC_IMC);
621
622         s->pcc &= ~(CC_CSP | CC_CP | CC_CB2L | CC_CB1L);
623         s->pcc |= CC_CA;
624         outw(s->pcc, s->io+IT_AC_PCC);
625     
626         db->stopped = 0;
627
628         spin_unlock_irqrestore(&s->lock, flags);
629 }       
630
631 static void start_adc(struct it8172_state *s)
632 {
633         struct dmabuf* db = &s->dma_adc;
634         unsigned long flags;
635         unsigned char imc;
636         unsigned long buf1, buf2;
637     
638         if (!db->stopped)
639                 return;
640
641         spin_lock_irqsave(&s->lock, flags);
642
643         // reset Buffer 1 and 2 pointers to nextIn and nextIn+fragsize
644         buf1 = virt_to_bus(db->nextIn);
645         buf2 = buf1 + db->fragsize;
646         if (buf2 >= db->dmaaddr + db->dmasize)
647                 buf2 -= db->dmasize;
648     
649         outl(buf1, s->io+IT_AC_CAPB1STA);
650         outl(buf2, s->io+IT_AC_CAPB2STA);
651         db->curBufPtr = IT_AC_CAPB1STA;
652
653         // enable capture interrupt
654         imc = inb(s->io+IT_AC_IMC);
655         outb(imc & ~IMC_CCIM, s->io+IT_AC_IMC);
656
657         s->capcc &= ~(CC_CSP | CC_CP | CC_CB2L | CC_CB1L);
658         s->capcc |= CC_CA;
659         outw(s->capcc, s->io+IT_AC_CAPCC);
660     
661         db->stopped = 0;
662
663         spin_unlock_irqrestore(&s->lock, flags);
664 }       
665
666 /* --------------------------------------------------------------------- */
667
668 #define DMABUF_DEFAULTORDER (17-PAGE_SHIFT)
669 #define DMABUF_MINORDER 1
670
671 static inline void dealloc_dmabuf(struct it8172_state *s, struct dmabuf *db)
672 {
673         struct page *page, *pend;
674
675         if (db->rawbuf) {
676                 /* undo marking the pages as reserved */
677                 pend = virt_to_page(db->rawbuf +
678                                     (PAGE_SIZE << db->buforder) - 1);
679                 for (page = virt_to_page(db->rawbuf); page <= pend; page++)
680                         ClearPageReserved(page);
681                 pci_free_consistent(s->dev, PAGE_SIZE << db->buforder,
682                                     db->rawbuf, db->dmaaddr);
683         }
684         db->rawbuf = db->nextIn = db->nextOut = NULL;
685         db->mapped = db->ready = 0;
686 }
687
688 static int prog_dmabuf(struct it8172_state *s, struct dmabuf *db,
689                        unsigned rate, unsigned fmt, unsigned reg)
690 {
691         int order;
692         unsigned bytepersec;
693         unsigned bufs;
694         struct page *page, *pend;
695
696         if (!db->rawbuf) {
697                 db->ready = db->mapped = 0;
698                 for (order = DMABUF_DEFAULTORDER;
699                      order >= DMABUF_MINORDER; order--)
700                         if ((db->rawbuf =
701                              pci_alloc_consistent(s->dev,
702                                                   PAGE_SIZE << order,
703                                                   &db->dmaaddr)))
704                                 break;
705                 if (!db->rawbuf)
706                         return -ENOMEM;
707                 db->buforder = order;
708                 /* now mark the pages as reserved;
709                    otherwise remap_pfn_range doesn't do what we want */
710                 pend = virt_to_page(db->rawbuf +
711                                     (PAGE_SIZE << db->buforder) - 1);
712                 for (page = virt_to_page(db->rawbuf); page <= pend; page++)
713                         SetPageReserved(page);
714         }
715
716         db->count = 0;
717         db->nextIn = db->nextOut = db->rawbuf;
718     
719         bytepersec = rate << sample_shift[fmt];
720         bufs = PAGE_SIZE << db->buforder;
721         if (db->ossfragshift) {
722                 if ((1000 << db->ossfragshift) < bytepersec)
723                         db->fragshift = ld2(bytepersec/1000);
724                 else
725                         db->fragshift = db->ossfragshift;
726         } else {
727                 db->fragshift = ld2(bytepersec/100/(db->subdivision ?
728                                                     db->subdivision : 1));
729                 if (db->fragshift < 3)
730                         db->fragshift = 3;
731         }
732         db->numfrag = bufs >> db->fragshift;
733         while (db->numfrag < 4 && db->fragshift > 3) {
734                 db->fragshift--;
735                 db->numfrag = bufs >> db->fragshift;
736         }
737         db->fragsize = 1 << db->fragshift;
738         if (db->ossmaxfrags >= 4 && db->ossmaxfrags < db->numfrag)
739                 db->numfrag = db->ossmaxfrags;
740         db->fragsamples = db->fragsize >> sample_shift[fmt];
741         db->dmasize = db->numfrag << db->fragshift;
742         memset(db->rawbuf, (fmt & (CC_DF>>CC_FMT_BIT)) ? 0 : 0x80, bufs);
743     
744 #ifdef IT8172_VERBOSE_DEBUG
745         dbg("rate=%d, fragsize=%d, numfrag=%d, dmasize=%d",
746             rate, db->fragsize, db->numfrag, db->dmasize);
747 #endif
748
749         // set data length register
750         outw(db->fragsize, s->io+reg+2);
751         db->ready = 1;
752
753         return 0;
754 }
755
756 static inline int prog_dmabuf_adc(struct it8172_state *s)
757 {
758         stop_adc(s);
759         return prog_dmabuf(s, &s->dma_adc, s->adcrate,
760                            (s->capcc & CC_FMT_MASK) >> CC_FMT_BIT,
761                            IT_AC_CAPCC);
762 }
763
764 static inline int prog_dmabuf_dac(struct it8172_state *s)
765 {
766         stop_dac(s);
767         return prog_dmabuf(s, &s->dma_dac, s->dacrate,
768                            (s->pcc & CC_FMT_MASK) >> CC_FMT_BIT,
769                            IT_AC_PCC);
770 }
771
772
773 /* hold spinlock for the following! */
774
775 static irqreturn_t it8172_interrupt(int irq, void *dev_id, struct pt_regs *regs)
776 {
777         struct it8172_state *s = (struct it8172_state *)dev_id;
778         struct dmabuf* dac = &s->dma_dac;
779         struct dmabuf* adc = &s->dma_adc;
780         unsigned char isc, vs;
781         unsigned short vol, mute;
782         unsigned long newptr;
783     
784         spin_lock(&s->lock);
785
786         isc = inb(s->io+IT_AC_ISC);
787
788         /* fastpath out, to ease interrupt sharing */
789         if (!(isc & (ISC_VCI | ISC_CCI | ISC_PCI))) {
790                 spin_unlock(&s->lock);
791                 return IRQ_NONE;
792         }
793     
794         /* clear audio interrupts first */
795         outb(isc | ISC_VCI | ISC_CCI | ISC_PCI, s->io+IT_AC_ISC);
796     
797         /* handle volume button events (ignore if S/PDIF enabled) */
798         if ((isc & ISC_VCI) && s->spdif_volume == -1) {
799                 vs = inb(s->io+IT_AC_VS);
800                 outb(0, s->io+IT_AC_VS);
801                 vol = inw(s->io+IT_AC_PCMOV);
802                 mute = vol & PCMOV_PCMOM;
803                 vol &= PCMOV_PCMLCG_MASK;
804                 if ((vs & VS_VUP) && vol > 0)
805                         vol--;
806                 if ((vs & VS_VDP) && vol < 0x1f)
807                         vol++;
808                 vol |= (vol << PCMOV_PCMRCG_BIT);
809                 if (vs & VS_VMP)
810                         vol |= (mute ^ PCMOV_PCMOM);
811                 outw(vol, s->io+IT_AC_PCMOV);
812         }
813     
814         /* update capture pointers */
815         if (isc & ISC_CCI) {
816                 if (adc->count > adc->dmasize - adc->fragsize) {
817                         // Overrun. Stop ADC and log the error
818                         stop_adc(s);
819                         adc->error++;
820                         dbg("adc overrun");
821                 } else {
822                         newptr = virt_to_bus(adc->nextIn) + 2*adc->fragsize;
823                         if (newptr >= adc->dmaaddr + adc->dmasize)
824                                 newptr -= adc->dmasize;
825             
826                         outl(newptr, s->io+adc->curBufPtr);
827                         adc->curBufPtr = (adc->curBufPtr == IT_AC_CAPB1STA) ?
828                                 IT_AC_CAPB2STA : IT_AC_CAPB1STA;
829             
830                         adc->nextIn += adc->fragsize;
831                         if (adc->nextIn >= adc->rawbuf + adc->dmasize)
832                                 adc->nextIn -= adc->dmasize;
833             
834                         adc->count += adc->fragsize;
835                         adc->total_bytes += adc->fragsize;
836
837                         /* wake up anybody listening */
838                         if (waitqueue_active(&adc->wait))
839                                 wake_up_interruptible(&adc->wait);
840                 }
841         }
842     
843         /* update playback pointers */
844         if (isc & ISC_PCI) {
845                 newptr = virt_to_bus(dac->nextOut) + 2*dac->fragsize;
846                 if (newptr >= dac->dmaaddr + dac->dmasize)
847                         newptr -= dac->dmasize;
848         
849                 outl(newptr, s->io+dac->curBufPtr);
850                 dac->curBufPtr = (dac->curBufPtr == IT_AC_PCB1STA) ?
851                         IT_AC_PCB2STA : IT_AC_PCB1STA;
852         
853                 dac->nextOut += dac->fragsize;
854                 if (dac->nextOut >= dac->rawbuf + dac->dmasize)
855                         dac->nextOut -= dac->dmasize;
856         
857                 dac->count -= dac->fragsize;
858                 dac->total_bytes += dac->fragsize;
859
860                 /* wake up anybody listening */
861                 if (waitqueue_active(&dac->wait))
862                         wake_up_interruptible(&dac->wait);
863         
864                 if (dac->count <= 0)
865                         stop_dac(s);
866         }
867     
868         spin_unlock(&s->lock);
869         return IRQ_HANDLED;
870 }
871
872 /* --------------------------------------------------------------------- */
873
874 static int it8172_open_mixdev(struct inode *inode, struct file *file)
875 {
876         int minor = iminor(inode);
877         struct list_head *list;
878         struct it8172_state *s;
879
880         for (list = devs.next; ; list = list->next) {
881                 if (list == &devs)
882                         return -ENODEV;
883                 s = list_entry(list, struct it8172_state, devs);
884                 if (s->codec.dev_mixer == minor)
885                         break;
886         }
887         file->private_data = s;
888         return nonseekable_open(inode, file);
889 }
890
891 static int it8172_release_mixdev(struct inode *inode, struct file *file)
892 {
893         return 0;
894 }
895
896
897 static u16
898 cvt_ossvol(unsigned int gain)
899 {
900         u16 ret;
901     
902         if (gain == 0)
903                 return 0;
904     
905         if (gain > 100)
906                 gain = 100;
907     
908         ret = (100 - gain + 32) / 4;
909         ret = ret > 31 ? 31 : ret;
910         return ret;
911 }
912
913
914 static int mixdev_ioctl(struct ac97_codec *codec, unsigned int cmd,
915                         unsigned long arg)
916 {
917         struct it8172_state *s = (struct it8172_state *)codec->private_data;
918         unsigned int left, right;
919         unsigned long flags;
920         int val;
921         u16 vol;
922     
923         /*
924          * When we are in S/PDIF mode, we want to disable any analog output so
925          * we filter the master/PCM channel volume ioctls.
926          *
927          * Also filter I2S channel, which AC'97 knows nothing about.
928          */
929
930         switch (cmd) {
931         case SOUND_MIXER_WRITE_VOLUME:
932                 // if not in S/PDIF mode, pass to AC'97
933                 if (s->spdif_volume == -1)
934                         break;
935                 return 0;
936         case SOUND_MIXER_WRITE_PCM:
937                 // if not in S/PDIF mode, pass to AC'97
938                 if (s->spdif_volume == -1)
939                         break;
940                 if (get_user(val, (int *)arg))
941                         return -EFAULT;
942                 right = ((val >> 8)  & 0xff);
943                 left = (val  & 0xff);
944                 if (right > 100)
945                         right = 100;
946                 if (left > 100)
947                         left = 100;
948                 s->spdif_volume = (right << 8) | left;
949                 vol = cvt_ossvol(left);
950                 vol |= (cvt_ossvol(right) << PCMOV_PCMRCG_BIT);
951                 if (vol == 0)
952                         vol = PCMOV_PCMOM; // mute
953                 spin_lock_irqsave(&s->lock, flags);
954                 outw(vol, s->io+IT_AC_PCMOV);
955                 spin_unlock_irqrestore(&s->lock, flags);
956                 return put_user(s->spdif_volume, (int *)arg);
957         case SOUND_MIXER_READ_PCM:
958                 // if not in S/PDIF mode, pass to AC'97
959                 if (s->spdif_volume == -1)
960                         break;
961                 return put_user(s->spdif_volume, (int *)arg);
962         case SOUND_MIXER_WRITE_I2S:
963                 if (get_user(val, (int *)arg))
964                         return -EFAULT;
965                 right = ((val >> 8)  & 0xff);
966                 left = (val  & 0xff);
967                 if (right > 100)
968                         right = 100;
969                 if (left > 100)
970                         left = 100;
971                 s->i2s_volume = (right << 8) | left;
972                 vol = cvt_ossvol(left);
973                 vol |= (cvt_ossvol(right) << I2SV_I2SRCG_BIT);
974                 if (vol == 0)
975                         vol = I2SV_I2SOM; // mute
976                 outw(vol, s->io+IT_AC_I2SV);
977                 return put_user(s->i2s_volume, (int *)arg);
978         case SOUND_MIXER_READ_I2S:
979                 return put_user(s->i2s_volume, (int *)arg);
980         case SOUND_MIXER_WRITE_RECSRC:
981                 if (get_user(val, (int *)arg))
982                         return -EFAULT;
983                 if (val & SOUND_MASK_I2S) {
984                         s->i2s_recording = 1;
985                         outb(DRSS_I2S, s->io+IT_AC_DRSS);
986                         return 0;
987                 } else {
988                         s->i2s_recording = 0;
989                         outb(DRSS_AC97_PRIM, s->io+IT_AC_DRSS);
990                         // now let AC'97 select record source
991                         break;
992                 }
993         case SOUND_MIXER_READ_RECSRC:
994                 if (s->i2s_recording)
995                         return put_user(SOUND_MASK_I2S, (int *)arg);
996                 else
997                         // let AC'97 report recording source
998                         break;
999         }
1000
1001         return codec->mixer_ioctl(codec, cmd, arg);
1002 }
1003
1004 static int it8172_ioctl_mixdev(struct inode *inode, struct file *file,
1005                                unsigned int cmd, unsigned long arg)
1006 {
1007         struct it8172_state *s = (struct it8172_state *)file->private_data;
1008         struct ac97_codec *codec = &s->codec;
1009
1010         return mixdev_ioctl(codec, cmd, arg);
1011 }
1012
1013 static /*const*/ struct file_operations it8172_mixer_fops = {
1014         .owner          = THIS_MODULE,
1015         .llseek         = no_llseek,
1016         .ioctl          = it8172_ioctl_mixdev,
1017         .open           = it8172_open_mixdev,
1018         .release        = it8172_release_mixdev,
1019 };
1020
1021 /* --------------------------------------------------------------------- */
1022
1023 static int drain_dac(struct it8172_state *s, int nonblock)
1024 {
1025         unsigned long flags;
1026         int count, tmo;
1027         
1028         if (s->dma_dac.mapped || !s->dma_dac.ready || s->dma_dac.stopped)
1029                 return 0;
1030
1031         for (;;) {
1032                 spin_lock_irqsave(&s->lock, flags);
1033                 count = s->dma_dac.count;
1034                 spin_unlock_irqrestore(&s->lock, flags);
1035                 if (count <= 0)
1036                         break;
1037                 if (signal_pending(current))
1038                         break;
1039                 //if (nonblock)
1040                 //return -EBUSY;
1041                 tmo = 1000 * count / s->dacrate;
1042                 tmo >>= sample_shift[(s->pcc & CC_FMT_MASK) >> CC_FMT_BIT];
1043                 it8172_delay(tmo);
1044         }
1045         if (signal_pending(current))
1046                 return -ERESTARTSYS;
1047         return 0;
1048 }
1049
1050 /* --------------------------------------------------------------------- */
1051
1052
1053 /*
1054  * Copy audio data to/from user buffer from/to dma buffer, taking care
1055  * that we wrap when reading/writing the dma buffer. Returns actual byte
1056  * count written to or read from the dma buffer.
1057  */
1058 static int copy_dmabuf_user(struct dmabuf *db, char* userbuf,
1059                             int count, int to_user)
1060 {
1061         char* bufptr = to_user ? db->nextOut : db->nextIn;
1062         char* bufend = db->rawbuf + db->dmasize;
1063         
1064         if (bufptr + count > bufend) {
1065                 int partial = (int)(bufend - bufptr);
1066                 if (to_user) {
1067                         if (copy_to_user(userbuf, bufptr, partial))
1068                                 return -EFAULT;
1069                         if (copy_to_user(userbuf + partial, db->rawbuf,
1070                                          count - partial))
1071                                 return -EFAULT;
1072                 } else {
1073                         if (copy_from_user(bufptr, userbuf, partial))
1074                                 return -EFAULT;
1075                         if (copy_from_user(db->rawbuf,
1076                                            userbuf + partial,
1077                                            count - partial))
1078                                 return -EFAULT;
1079                 }
1080         } else {
1081                 if (to_user) {
1082                         if (copy_to_user(userbuf, bufptr, count))
1083                                 return -EFAULT;
1084                 } else {
1085                         if (copy_from_user(bufptr, userbuf, count))
1086                                 return -EFAULT;
1087                 }
1088         }
1089         
1090         return count;
1091 }
1092
1093
1094 static ssize_t it8172_read(struct file *file, char *buffer,
1095                            size_t count, loff_t *ppos)
1096 {
1097         struct it8172_state *s = (struct it8172_state *)file->private_data;
1098         struct dmabuf *db = &s->dma_adc;
1099         ssize_t ret;
1100         unsigned long flags;
1101         int cnt, remainder, avail;
1102
1103         if (db->mapped)
1104                 return -ENXIO;
1105         if (!access_ok(VERIFY_WRITE, buffer, count))
1106                 return -EFAULT;
1107         ret = 0;
1108
1109         while (count > 0) {
1110                 // wait for samples in capture buffer
1111                 do {
1112                         spin_lock_irqsave(&s->lock, flags);
1113                         if (db->stopped)
1114                                 start_adc(s);
1115                         avail = db->count;
1116                         spin_unlock_irqrestore(&s->lock, flags);
1117                         if (avail <= 0) {
1118                                 if (file->f_flags & O_NONBLOCK) {
1119                                         if (!ret)
1120                                                 ret = -EAGAIN;
1121                                         return ret;
1122                                 }
1123                                 interruptible_sleep_on(&db->wait);
1124                                 if (signal_pending(current)) {
1125                                         if (!ret)
1126                                                 ret = -ERESTARTSYS;
1127                                         return ret;
1128                                 }
1129                         }
1130                 } while (avail <= 0);
1131
1132                 // copy from nextOut to user
1133                 if ((cnt = copy_dmabuf_user(db, buffer, count > avail ?
1134                                             avail : count, 1)) < 0) {
1135                         if (!ret)
1136                                 ret = -EFAULT;
1137                         return ret;
1138                 }
1139
1140                 spin_lock_irqsave(&s->lock, flags);
1141                 db->count -= cnt;
1142                 spin_unlock_irqrestore(&s->lock, flags);
1143
1144                 db->nextOut += cnt;
1145                 if (db->nextOut >= db->rawbuf + db->dmasize)
1146                         db->nextOut -= db->dmasize;     
1147
1148                 count -= cnt;
1149                 buffer += cnt;
1150                 ret += cnt;
1151         } // while (count > 0)
1152
1153         /*
1154          * See if the dma buffer count after this read call is
1155          * aligned on a fragsize boundary. If not, read from
1156          * buffer until we reach a boundary, and let's hope this
1157          * is just the last remainder of an audio record. If not
1158          * it means the user is not reading in fragsize chunks, in
1159          * which case it's his/her fault that there are audio gaps
1160          * in their record.
1161          */
1162         spin_lock_irqsave(&s->lock, flags);
1163         remainder = db->count % db->fragsize;
1164         if (remainder) {
1165                 db->nextOut += remainder;
1166                 if (db->nextOut >= db->rawbuf + db->dmasize)
1167                         db->nextOut -= db->dmasize;
1168                 db->count -= remainder;
1169         }
1170         spin_unlock_irqrestore(&s->lock, flags);
1171
1172         return ret;
1173 }
1174
1175 static ssize_t it8172_write(struct file *file, const char *buffer,
1176                             size_t count, loff_t *ppos)
1177 {
1178         struct it8172_state *s = (struct it8172_state *)file->private_data;
1179         struct dmabuf *db = &s->dma_dac;
1180         ssize_t ret;
1181         unsigned long flags;
1182         int cnt, remainder, avail;
1183
1184         if (db->mapped)
1185                 return -ENXIO;
1186         if (!access_ok(VERIFY_READ, buffer, count))
1187                 return -EFAULT;
1188         ret = 0;
1189     
1190         while (count > 0) {
1191                 // wait for space in playback buffer
1192                 do {
1193                         spin_lock_irqsave(&s->lock, flags);
1194                         avail = db->dmasize - db->count;
1195                         spin_unlock_irqrestore(&s->lock, flags);
1196                         if (avail <= 0) {
1197                                 if (file->f_flags & O_NONBLOCK) {
1198                                         if (!ret)
1199                                                 ret = -EAGAIN;
1200                                         return ret;
1201                                 }
1202                                 interruptible_sleep_on(&db->wait);
1203                                 if (signal_pending(current)) {
1204                                         if (!ret)
1205                                                 ret = -ERESTARTSYS;
1206                                         return ret;
1207                                 }
1208                         }
1209                 } while (avail <= 0);
1210         
1211                 // copy to nextIn
1212                 if ((cnt = copy_dmabuf_user(db, (char*)buffer,
1213                                             count > avail ?
1214                                             avail : count, 0)) < 0) {
1215                         if (!ret)
1216                                 ret = -EFAULT;
1217                         return ret;
1218                 }
1219
1220                 spin_lock_irqsave(&s->lock, flags);
1221                 db->count += cnt;
1222                 if (db->stopped)
1223                         start_dac(s);
1224                 spin_unlock_irqrestore(&s->lock, flags);
1225         
1226                 db->nextIn += cnt;
1227                 if (db->nextIn >= db->rawbuf + db->dmasize)
1228                         db->nextIn -= db->dmasize;
1229         
1230                 count -= cnt;
1231                 buffer += cnt;
1232                 ret += cnt;
1233         } // while (count > 0)
1234         
1235         /*
1236          * See if the dma buffer count after this write call is
1237          * aligned on a fragsize boundary. If not, fill buffer
1238          * with silence to the next boundary, and let's hope this
1239          * is just the last remainder of an audio playback. If not
1240          * it means the user is not sending us fragsize chunks, in
1241          * which case it's his/her fault that there are audio gaps
1242          * in their playback.
1243          */
1244         spin_lock_irqsave(&s->lock, flags);
1245         remainder = db->count % db->fragsize;
1246         if (remainder) {
1247                 int fill_cnt = db->fragsize - remainder;
1248                 memset(db->nextIn, 0, fill_cnt);
1249                 db->nextIn += fill_cnt;
1250                 if (db->nextIn >= db->rawbuf + db->dmasize)
1251                         db->nextIn -= db->dmasize;
1252                 db->count += fill_cnt;
1253         }
1254         spin_unlock_irqrestore(&s->lock, flags);
1255
1256         return ret;
1257 }
1258
1259 /* No kernel lock - we have our own spinlock */
1260 static unsigned int it8172_poll(struct file *file,
1261                                 struct poll_table_struct *wait)
1262 {
1263         struct it8172_state *s = (struct it8172_state *)file->private_data;
1264         unsigned long flags;
1265         unsigned int mask = 0;
1266
1267         if (file->f_mode & FMODE_WRITE) {
1268                 if (!s->dma_dac.ready)
1269                         return 0;
1270                 poll_wait(file, &s->dma_dac.wait, wait);
1271         }
1272         if (file->f_mode & FMODE_READ) {
1273                 if (!s->dma_adc.ready)
1274                         return 0;
1275                 poll_wait(file, &s->dma_adc.wait, wait);
1276         }
1277         
1278         spin_lock_irqsave(&s->lock, flags);
1279         if (file->f_mode & FMODE_READ) {
1280                 if (s->dma_adc.count >= (signed)s->dma_adc.fragsize)
1281                         mask |= POLLIN | POLLRDNORM;
1282         }
1283         if (file->f_mode & FMODE_WRITE) {
1284                 if (s->dma_dac.mapped) {
1285                         if (s->dma_dac.count >= (signed)s->dma_dac.fragsize) 
1286                                 mask |= POLLOUT | POLLWRNORM;
1287                 } else {
1288                         if ((signed)s->dma_dac.dmasize >=
1289                             s->dma_dac.count + (signed)s->dma_dac.fragsize)
1290                                 mask |= POLLOUT | POLLWRNORM;
1291                 }
1292         }
1293         spin_unlock_irqrestore(&s->lock, flags);
1294         return mask;
1295 }
1296
1297 static int it8172_mmap(struct file *file, struct vm_area_struct *vma)
1298 {
1299         struct it8172_state *s = (struct it8172_state *)file->private_data;
1300         struct dmabuf *db;
1301         unsigned long size;
1302
1303         lock_kernel();
1304         if (vma->vm_flags & VM_WRITE)
1305                 db = &s->dma_dac;
1306         else if (vma->vm_flags & VM_READ)
1307                 db = &s->dma_adc;
1308         else {
1309                 unlock_kernel();
1310                 return -EINVAL;
1311         }
1312         if (vma->vm_pgoff != 0) {
1313                 unlock_kernel();
1314                 return -EINVAL;
1315         }
1316         size = vma->vm_end - vma->vm_start;
1317         if (size > (PAGE_SIZE << db->buforder)) {
1318                 unlock_kernel();
1319                 return -EINVAL;
1320         }
1321         if (remap_pfn_range(vma, vma->vm_start,
1322                              virt_to_phys(db->rawbuf) >> PAGE_SHIFT,
1323                              size, vma->vm_page_prot)) {
1324                 unlock_kernel();
1325                 return -EAGAIN;
1326         }
1327         db->mapped = 1;
1328         unlock_kernel();
1329         return 0;
1330 }
1331
1332
1333 #ifdef IT8172_VERBOSE_DEBUG
1334 static struct ioctl_str_t {
1335         unsigned int cmd;
1336         const char* str;
1337 } ioctl_str[] = {
1338         {SNDCTL_DSP_RESET, "SNDCTL_DSP_RESET"},
1339         {SNDCTL_DSP_SYNC, "SNDCTL_DSP_SYNC"},
1340         {SNDCTL_DSP_SPEED, "SNDCTL_DSP_SPEED"},
1341         {SNDCTL_DSP_STEREO, "SNDCTL_DSP_STEREO"},
1342         {SNDCTL_DSP_GETBLKSIZE, "SNDCTL_DSP_GETBLKSIZE"},
1343         {SNDCTL_DSP_SAMPLESIZE, "SNDCTL_DSP_SAMPLESIZE"},
1344         {SNDCTL_DSP_CHANNELS, "SNDCTL_DSP_CHANNELS"},
1345         {SOUND_PCM_WRITE_CHANNELS, "SOUND_PCM_WRITE_CHANNELS"},
1346         {SOUND_PCM_WRITE_FILTER, "SOUND_PCM_WRITE_FILTER"},
1347         {SNDCTL_DSP_POST, "SNDCTL_DSP_POST"},
1348         {SNDCTL_DSP_SUBDIVIDE, "SNDCTL_DSP_SUBDIVIDE"},
1349         {SNDCTL_DSP_SETFRAGMENT, "SNDCTL_DSP_SETFRAGMENT"},
1350         {SNDCTL_DSP_GETFMTS, "SNDCTL_DSP_GETFMTS"},
1351         {SNDCTL_DSP_SETFMT, "SNDCTL_DSP_SETFMT"},
1352         {SNDCTL_DSP_GETOSPACE, "SNDCTL_DSP_GETOSPACE"},
1353         {SNDCTL_DSP_GETISPACE, "SNDCTL_DSP_GETISPACE"},
1354         {SNDCTL_DSP_NONBLOCK, "SNDCTL_DSP_NONBLOCK"},
1355         {SNDCTL_DSP_GETCAPS, "SNDCTL_DSP_GETCAPS"},
1356         {SNDCTL_DSP_GETTRIGGER, "SNDCTL_DSP_GETTRIGGER"},
1357         {SNDCTL_DSP_SETTRIGGER, "SNDCTL_DSP_SETTRIGGER"},
1358         {SNDCTL_DSP_GETIPTR, "SNDCTL_DSP_GETIPTR"},
1359         {SNDCTL_DSP_GETOPTR, "SNDCTL_DSP_GETOPTR"},
1360         {SNDCTL_DSP_MAPINBUF, "SNDCTL_DSP_MAPINBUF"},
1361         {SNDCTL_DSP_MAPOUTBUF, "SNDCTL_DSP_MAPOUTBUF"},
1362         {SNDCTL_DSP_SETSYNCRO, "SNDCTL_DSP_SETSYNCRO"},
1363         {SNDCTL_DSP_SETDUPLEX, "SNDCTL_DSP_SETDUPLEX"},
1364         {SNDCTL_DSP_GETODELAY, "SNDCTL_DSP_GETODELAY"},
1365         {SNDCTL_DSP_GETCHANNELMASK, "SNDCTL_DSP_GETCHANNELMASK"},
1366         {SNDCTL_DSP_BIND_CHANNEL, "SNDCTL_DSP_BIND_CHANNEL"},
1367         {OSS_GETVERSION, "OSS_GETVERSION"},
1368         {SOUND_PCM_READ_RATE, "SOUND_PCM_READ_RATE"},
1369         {SOUND_PCM_READ_CHANNELS, "SOUND_PCM_READ_CHANNELS"},
1370         {SOUND_PCM_READ_BITS, "SOUND_PCM_READ_BITS"},
1371         {SOUND_PCM_READ_FILTER, "SOUND_PCM_READ_FILTER"}
1372 };
1373 #endif    
1374
1375 static int it8172_ioctl(struct inode *inode, struct file *file,
1376                         unsigned int cmd, unsigned long arg)
1377 {
1378         struct it8172_state *s = (struct it8172_state *)file->private_data;
1379         unsigned long flags;
1380         audio_buf_info abinfo;
1381         count_info cinfo;
1382         int count;
1383         int val, mapped, ret, diff;
1384
1385         mapped = ((file->f_mode & FMODE_WRITE) && s->dma_dac.mapped) ||
1386                 ((file->f_mode & FMODE_READ) && s->dma_adc.mapped);
1387
1388 #ifdef IT8172_VERBOSE_DEBUG
1389         for (count=0; count<sizeof(ioctl_str)/sizeof(ioctl_str[0]); count++) {
1390                 if (ioctl_str[count].cmd == cmd)
1391                         break;
1392         }
1393         if (count < sizeof(ioctl_str)/sizeof(ioctl_str[0]))
1394                 dbg("ioctl %s, arg=0x%08x",
1395                     ioctl_str[count].str, (unsigned int)arg);
1396         else
1397                 dbg("ioctl unknown, 0x%x", cmd);
1398 #endif
1399     
1400         switch (cmd) {
1401         case OSS_GETVERSION:
1402                 return put_user(SOUND_VERSION, (int *)arg);
1403
1404         case SNDCTL_DSP_SYNC:
1405                 if (file->f_mode & FMODE_WRITE)
1406                         return drain_dac(s, file->f_flags & O_NONBLOCK);
1407                 return 0;
1408                 
1409         case SNDCTL_DSP_SETDUPLEX:
1410                 return 0;
1411
1412         case SNDCTL_DSP_GETCAPS:
1413                 return put_user(DSP_CAP_DUPLEX | DSP_CAP_REALTIME |
1414                                 DSP_CAP_TRIGGER | DSP_CAP_MMAP, (int *)arg);
1415                 
1416         case SNDCTL_DSP_RESET:
1417                 if (file->f_mode & FMODE_WRITE) {
1418                         stop_dac(s);
1419                         synchronize_irq(s->irq);
1420                         s->dma_dac.count = s->dma_dac.total_bytes = 0;
1421                         s->dma_dac.nextIn = s->dma_dac.nextOut =
1422                                 s->dma_dac.rawbuf;
1423                 }
1424                 if (file->f_mode & FMODE_READ) {
1425                         stop_adc(s);
1426                         synchronize_irq(s->irq);
1427                         s->dma_adc.count = s->dma_adc.total_bytes = 0;
1428                         s->dma_adc.nextIn = s->dma_adc.nextOut =
1429                                 s->dma_adc.rawbuf;
1430                 }
1431                 return 0;
1432
1433         case SNDCTL_DSP_SPEED:
1434                 if (get_user(val, (int *)arg))
1435                         return -EFAULT;
1436                 if (val >= 0) {
1437                         if (file->f_mode & FMODE_READ) {
1438                                 stop_adc(s);
1439                                 set_adc_rate(s, val);
1440                                 if ((ret = prog_dmabuf_adc(s)))
1441                                         return ret;
1442                         }
1443                         if (file->f_mode & FMODE_WRITE) {
1444                                 stop_dac(s);
1445                                 set_dac_rate(s, val);
1446                                 if ((ret = prog_dmabuf_dac(s)))
1447                                         return ret;
1448                         }
1449                 }
1450                 return put_user((file->f_mode & FMODE_READ) ?
1451                                 s->adcrate : s->dacrate, (int *)arg);
1452
1453         case SNDCTL_DSP_STEREO:
1454                 if (get_user(val, (int *)arg))
1455                         return -EFAULT;
1456                 if (file->f_mode & FMODE_READ) {
1457                         stop_adc(s);
1458                         if (val)
1459                                 s->capcc |= CC_SM;
1460                         else
1461                                 s->capcc &= ~CC_SM;
1462                         outw(s->capcc, s->io+IT_AC_CAPCC);
1463                         if ((ret = prog_dmabuf_adc(s)))
1464                                 return ret;
1465                 }
1466                 if (file->f_mode & FMODE_WRITE) {
1467                         stop_dac(s);
1468                         if (val)
1469                                 s->pcc |= CC_SM;
1470                         else
1471                                 s->pcc &= ~CC_SM;
1472                         outw(s->pcc, s->io+IT_AC_PCC);
1473                         if ((ret = prog_dmabuf_dac(s)))
1474                                 return ret;
1475                 }
1476                 return 0;
1477
1478         case SNDCTL_DSP_CHANNELS:
1479                 if (get_user(val, (int *)arg))
1480                         return -EFAULT;
1481                 if (val != 0) {
1482                         if (file->f_mode & FMODE_READ) {
1483                                 stop_adc(s);
1484                                 if (val >= 2) {
1485                                         val = 2;
1486                                         s->capcc |= CC_SM;
1487                                 }
1488                                 else
1489                                         s->capcc &= ~CC_SM;
1490                                 outw(s->capcc, s->io+IT_AC_CAPCC);
1491                                 if ((ret = prog_dmabuf_adc(s)))
1492                                         return ret;
1493                         }
1494                         if (file->f_mode & FMODE_WRITE) {
1495                                 stop_dac(s);
1496                                 switch (val) {
1497                                 case 1:
1498                                         s->pcc &= ~CC_SM;
1499                                         break;
1500                                 case 2:
1501                                         s->pcc |= CC_SM;
1502                                         break;
1503                                 default:
1504                                         // FIX! support multichannel???
1505                                         val = 2;
1506                                         s->pcc |= CC_SM;
1507                                         break;
1508                                 }
1509                                 outw(s->pcc, s->io+IT_AC_PCC);
1510                                 if ((ret = prog_dmabuf_dac(s)))
1511                                         return ret;
1512                         }
1513                 }
1514                 return put_user(val, (int *)arg);
1515                 
1516         case SNDCTL_DSP_GETFMTS: /* Returns a mask */
1517                 return put_user(AFMT_S16_LE|AFMT_U8, (int *)arg);
1518                 
1519         case SNDCTL_DSP_SETFMT: /* Selects ONE fmt*/
1520                 if (get_user(val, (int *)arg))
1521                         return -EFAULT;
1522                 if (val != AFMT_QUERY) {
1523                         if (file->f_mode & FMODE_READ) {
1524                                 stop_adc(s);
1525                                 if (val == AFMT_S16_LE)
1526                                         s->capcc |= CC_DF;
1527                                 else {
1528                                         val = AFMT_U8;
1529                                         s->capcc &= ~CC_DF;
1530                                 }
1531                                 outw(s->capcc, s->io+IT_AC_CAPCC);
1532                                 if ((ret = prog_dmabuf_adc(s)))
1533                                         return ret;
1534                         }
1535                         if (file->f_mode & FMODE_WRITE) {
1536                                 stop_dac(s);
1537                                 if (val == AFMT_S16_LE)
1538                                         s->pcc |= CC_DF;
1539                                 else {
1540                                         val = AFMT_U8;
1541                                         s->pcc &= ~CC_DF;
1542                                 }
1543                                 outw(s->pcc, s->io+IT_AC_PCC);
1544                                 if ((ret = prog_dmabuf_dac(s)))
1545                                         return ret;
1546                         }
1547                 } else {
1548                         if (file->f_mode & FMODE_READ)
1549                                 val = (s->capcc & CC_DF) ?
1550                                         AFMT_S16_LE : AFMT_U8;
1551                         else
1552                                 val = (s->pcc & CC_DF) ?
1553                                         AFMT_S16_LE : AFMT_U8;
1554                 }
1555                 return put_user(val, (int *)arg);
1556                 
1557         case SNDCTL_DSP_POST:
1558                 return 0;
1559
1560         case SNDCTL_DSP_GETTRIGGER:
1561                 val = 0;
1562                 spin_lock_irqsave(&s->lock, flags);
1563                 if (file->f_mode & FMODE_READ && !s->dma_adc.stopped)
1564                         val |= PCM_ENABLE_INPUT;
1565                 if (file->f_mode & FMODE_WRITE && !s->dma_dac.stopped)
1566                         val |= PCM_ENABLE_OUTPUT;
1567                 spin_unlock_irqrestore(&s->lock, flags);
1568                 return put_user(val, (int *)arg);
1569                 
1570         case SNDCTL_DSP_SETTRIGGER:
1571                 if (get_user(val, (int *)arg))
1572                         return -EFAULT;
1573                 if (file->f_mode & FMODE_READ) {
1574                         if (val & PCM_ENABLE_INPUT)
1575                                 start_adc(s);
1576                         else
1577                                 stop_adc(s);
1578                 }
1579                 if (file->f_mode & FMODE_WRITE) {
1580                         if (val & PCM_ENABLE_OUTPUT)
1581                                 start_dac(s);
1582                         else
1583                                 stop_dac(s);
1584                 }
1585                 return 0;
1586
1587         case SNDCTL_DSP_GETOSPACE:
1588                 if (!(file->f_mode & FMODE_WRITE))
1589                         return -EINVAL;
1590                 abinfo.fragsize = s->dma_dac.fragsize;
1591                 spin_lock_irqsave(&s->lock, flags);
1592                 count = s->dma_dac.count;
1593                 if (!s->dma_dac.stopped)
1594                         count -= (s->dma_dac.fragsize -
1595                                   inw(s->io+IT_AC_PCDL));
1596                 spin_unlock_irqrestore(&s->lock, flags);
1597                 if (count < 0)
1598                         count = 0;
1599                 abinfo.bytes = s->dma_dac.dmasize - count;
1600                 abinfo.fragstotal = s->dma_dac.numfrag;
1601                 abinfo.fragments = abinfo.bytes >> s->dma_dac.fragshift;      
1602                 return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ?
1603                         -EFAULT : 0;
1604
1605         case SNDCTL_DSP_GETISPACE:
1606                 if (!(file->f_mode & FMODE_READ))
1607                         return -EINVAL;
1608                 abinfo.fragsize = s->dma_adc.fragsize;
1609                 spin_lock_irqsave(&s->lock, flags);
1610                 count = s->dma_adc.count;
1611                 if (!s->dma_adc.stopped)
1612                         count += (s->dma_adc.fragsize -
1613                                   inw(s->io+IT_AC_CAPCDL));
1614                 spin_unlock_irqrestore(&s->lock, flags);
1615                 if (count < 0)
1616                         count = 0;
1617                 abinfo.bytes = count;
1618                 abinfo.fragstotal = s->dma_adc.numfrag;
1619                 abinfo.fragments = abinfo.bytes >> s->dma_adc.fragshift;      
1620                 return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ?
1621                         -EFAULT : 0;
1622                 
1623         case SNDCTL_DSP_NONBLOCK:
1624                 file->f_flags |= O_NONBLOCK;
1625                 return 0;
1626
1627         case SNDCTL_DSP_GETODELAY:
1628                 if (!(file->f_mode & FMODE_WRITE))
1629                         return -EINVAL;
1630                 spin_lock_irqsave(&s->lock, flags);
1631                 count = s->dma_dac.count;
1632                 if (!s->dma_dac.stopped)
1633                         count -= (s->dma_dac.fragsize -
1634                                   inw(s->io+IT_AC_PCDL));
1635                 spin_unlock_irqrestore(&s->lock, flags);
1636                 if (count < 0)
1637                         count = 0;
1638                 return put_user(count, (int *)arg);
1639
1640         case SNDCTL_DSP_GETIPTR:
1641                 if (!(file->f_mode & FMODE_READ))
1642                         return -EINVAL;
1643                 spin_lock_irqsave(&s->lock, flags);
1644                 cinfo.bytes = s->dma_adc.total_bytes;
1645                 count = s->dma_adc.count;
1646                 if (!s->dma_adc.stopped) {
1647                         diff = s->dma_adc.fragsize - inw(s->io+IT_AC_CAPCDL);
1648                         count += diff;
1649                         cinfo.bytes += diff;
1650                         cinfo.ptr = inl(s->io+s->dma_adc.curBufPtr) -
1651                                 s->dma_adc.dmaaddr;
1652                 } else
1653                         cinfo.ptr = virt_to_bus(s->dma_adc.nextIn) -
1654                                 s->dma_adc.dmaaddr;
1655                 if (s->dma_adc.mapped)
1656                         s->dma_adc.count &= s->dma_adc.fragsize-1;
1657                 spin_unlock_irqrestore(&s->lock, flags);
1658                 if (count < 0)
1659                         count = 0;
1660                 cinfo.blocks = count >> s->dma_adc.fragshift;
1661                 if (copy_to_user((void *)arg, &cinfo, sizeof(cinfo)))
1662                         return -EFAULT;
1663                 return 0;
1664
1665         case SNDCTL_DSP_GETOPTR:
1666                 if (!(file->f_mode & FMODE_READ))
1667                         return -EINVAL;
1668                 spin_lock_irqsave(&s->lock, flags);
1669                 cinfo.bytes = s->dma_dac.total_bytes;
1670                 count = s->dma_dac.count;
1671                 if (!s->dma_dac.stopped) {
1672                         diff = s->dma_dac.fragsize - inw(s->io+IT_AC_CAPCDL);
1673                         count -= diff;
1674                         cinfo.bytes += diff;
1675                         cinfo.ptr = inl(s->io+s->dma_dac.curBufPtr) -
1676                                 s->dma_dac.dmaaddr;
1677                 } else
1678                         cinfo.ptr = virt_to_bus(s->dma_dac.nextOut) -
1679                                 s->dma_dac.dmaaddr;
1680                 if (s->dma_dac.mapped)
1681                         s->dma_dac.count &= s->dma_dac.fragsize-1;
1682                 spin_unlock_irqrestore(&s->lock, flags);
1683                 if (count < 0)
1684                         count = 0;
1685                 cinfo.blocks = count >> s->dma_dac.fragshift;
1686                 if (copy_to_user((void *)arg, &cinfo, sizeof(cinfo)))
1687                         return -EFAULT;
1688                 return 0;
1689
1690         case SNDCTL_DSP_GETBLKSIZE:
1691                 if (file->f_mode & FMODE_WRITE)
1692                         return put_user(s->dma_dac.fragsize, (int *)arg);
1693                 else
1694                         return put_user(s->dma_adc.fragsize, (int *)arg);
1695
1696         case SNDCTL_DSP_SETFRAGMENT:
1697                 if (get_user(val, (int *)arg))
1698                         return -EFAULT;
1699                 if (file->f_mode & FMODE_READ) {
1700                         stop_adc(s);
1701                         s->dma_adc.ossfragshift = val & 0xffff;
1702                         s->dma_adc.ossmaxfrags = (val >> 16) & 0xffff;
1703                         if (s->dma_adc.ossfragshift < 4)
1704                                 s->dma_adc.ossfragshift = 4;
1705                         if (s->dma_adc.ossfragshift > 15)
1706                                 s->dma_adc.ossfragshift = 15;
1707                         if (s->dma_adc.ossmaxfrags < 4)
1708                                 s->dma_adc.ossmaxfrags = 4;
1709                         if ((ret = prog_dmabuf_adc(s)))
1710                                 return ret;
1711                 }
1712                 if (file->f_mode & FMODE_WRITE) {
1713                         stop_dac(s);
1714                         s->dma_dac.ossfragshift = val & 0xffff;
1715                         s->dma_dac.ossmaxfrags = (val >> 16) & 0xffff;
1716                         if (s->dma_dac.ossfragshift < 4)
1717                                 s->dma_dac.ossfragshift = 4;
1718                         if (s->dma_dac.ossfragshift > 15)
1719                                 s->dma_dac.ossfragshift = 15;
1720                         if (s->dma_dac.ossmaxfrags < 4)
1721                                 s->dma_dac.ossmaxfrags = 4;
1722                         if ((ret = prog_dmabuf_dac(s)))
1723                                 return ret;
1724                 }
1725                 return 0;
1726
1727         case SNDCTL_DSP_SUBDIVIDE:
1728                 if ((file->f_mode & FMODE_READ && s->dma_adc.subdivision) ||
1729                     (file->f_mode & FMODE_WRITE && s->dma_dac.subdivision))
1730                         return -EINVAL;
1731                 if (get_user(val, (int *)arg))
1732                         return -EFAULT;
1733                 if (val != 1 && val != 2 && val != 4)
1734                         return -EINVAL;
1735                 if (file->f_mode & FMODE_READ) {
1736                         stop_adc(s);
1737                         s->dma_adc.subdivision = val;
1738                         if ((ret = prog_dmabuf_adc(s)))
1739                                 return ret;
1740                 }
1741                 if (file->f_mode & FMODE_WRITE) {
1742                         stop_dac(s);
1743                         s->dma_dac.subdivision = val;
1744                         if ((ret = prog_dmabuf_dac(s)))
1745                                 return ret;
1746                 }
1747                 return 0;
1748
1749         case SOUND_PCM_READ_RATE:
1750                 return put_user((file->f_mode & FMODE_READ) ?
1751                                 s->adcrate : s->dacrate, (int *)arg);
1752
1753         case SOUND_PCM_READ_CHANNELS:
1754                 if (file->f_mode & FMODE_READ)
1755                         return put_user((s->capcc & CC_SM) ? 2 : 1,
1756                                         (int *)arg);
1757                 else
1758                         return put_user((s->pcc & CC_SM) ? 2 : 1,
1759                                         (int *)arg);
1760             
1761         case SOUND_PCM_READ_BITS:
1762                 if (file->f_mode & FMODE_READ)
1763                         return put_user((s->capcc & CC_DF) ? 16 : 8,
1764                                         (int *)arg);
1765                 else
1766                         return put_user((s->pcc & CC_DF) ? 16 : 8,
1767                                         (int *)arg);
1768
1769         case SOUND_PCM_WRITE_FILTER:
1770         case SNDCTL_DSP_SETSYNCRO:
1771         case SOUND_PCM_READ_FILTER:
1772                 return -EINVAL;
1773         }
1774
1775         return mixdev_ioctl(&s->codec, cmd, arg);
1776 }
1777
1778
1779 static int it8172_open(struct inode *inode, struct file *file)
1780 {
1781         int minor = iminor(inode);
1782         DECLARE_WAITQUEUE(wait, current);
1783         unsigned long flags;
1784         struct list_head *list;
1785         struct it8172_state *s;
1786         int ret;
1787     
1788 #ifdef IT8172_VERBOSE_DEBUG
1789         if (file->f_flags & O_NONBLOCK)
1790                 dbg("%s: non-blocking", __FUNCTION__);
1791         else
1792                 dbg("%s: blocking", __FUNCTION__);
1793 #endif
1794         
1795         for (list = devs.next; ; list = list->next) {
1796                 if (list == &devs)
1797                         return -ENODEV;
1798                 s = list_entry(list, struct it8172_state, devs);
1799                 if (!((s->dev_audio ^ minor) & ~0xf))
1800                         break;
1801         }
1802         file->private_data = s;
1803         /* wait for device to become free */
1804         down(&s->open_sem);
1805         while (s->open_mode & file->f_mode) {
1806                 if (file->f_flags & O_NONBLOCK) {
1807                         up(&s->open_sem);
1808                         return -EBUSY;
1809                 }
1810                 add_wait_queue(&s->open_wait, &wait);
1811                 __set_current_state(TASK_INTERRUPTIBLE);
1812                 up(&s->open_sem);
1813                 schedule();
1814                 remove_wait_queue(&s->open_wait, &wait);
1815                 set_current_state(TASK_RUNNING);
1816                 if (signal_pending(current))
1817                         return -ERESTARTSYS;
1818                 down(&s->open_sem);
1819         }
1820
1821         spin_lock_irqsave(&s->lock, flags);
1822
1823         if (file->f_mode & FMODE_READ) {
1824                 s->dma_adc.ossfragshift = s->dma_adc.ossmaxfrags =
1825                         s->dma_adc.subdivision = s->dma_adc.total_bytes = 0;
1826                 s->capcc &= ~(CC_SM | CC_DF);
1827                 set_adc_rate(s, 8000);
1828                 if ((minor & 0xf) == SND_DEV_DSP16)
1829                         s->capcc |= CC_DF;
1830                 outw(s->capcc, s->io+IT_AC_CAPCC);
1831                 if ((ret = prog_dmabuf_adc(s))) {
1832                         spin_unlock_irqrestore(&s->lock, flags);
1833                         return ret;
1834                 }
1835         }
1836         if (file->f_mode & FMODE_WRITE) {
1837                 s->dma_dac.ossfragshift = s->dma_dac.ossmaxfrags =
1838                         s->dma_dac.subdivision = s->dma_dac.total_bytes = 0;
1839                 s->pcc &= ~(CC_SM | CC_DF);
1840                 set_dac_rate(s, 8000);
1841                 if ((minor & 0xf) == SND_DEV_DSP16)
1842                         s->pcc |= CC_DF;
1843                 outw(s->pcc, s->io+IT_AC_PCC);
1844                 if ((ret = prog_dmabuf_dac(s))) {
1845                         spin_unlock_irqrestore(&s->lock, flags);
1846                         return ret;
1847                 }
1848         }
1849     
1850         spin_unlock_irqrestore(&s->lock, flags);
1851
1852         s->open_mode |= (file->f_mode & (FMODE_READ | FMODE_WRITE));
1853         up(&s->open_sem);
1854         return nonseekable_open(inode, file);
1855 }
1856
1857 static int it8172_release(struct inode *inode, struct file *file)
1858 {
1859         struct it8172_state *s = (struct it8172_state *)file->private_data;
1860
1861 #ifdef IT8172_VERBOSE_DEBUG
1862         dbg("%s", __FUNCTION__);
1863 #endif
1864         lock_kernel();
1865         if (file->f_mode & FMODE_WRITE)
1866                 drain_dac(s, file->f_flags & O_NONBLOCK);
1867         down(&s->open_sem);
1868         if (file->f_mode & FMODE_WRITE) {
1869                 stop_dac(s);
1870                 dealloc_dmabuf(s, &s->dma_dac);
1871         }
1872         if (file->f_mode & FMODE_READ) {
1873                 stop_adc(s);
1874                 dealloc_dmabuf(s, &s->dma_adc);
1875         }
1876         s->open_mode &= ((~file->f_mode) & (FMODE_READ|FMODE_WRITE));
1877         up(&s->open_sem);
1878         wake_up(&s->open_wait);
1879         unlock_kernel();
1880         return 0;
1881 }
1882
1883 static /*const*/ struct file_operations it8172_audio_fops = {
1884         .owner          = THIS_MODULE,
1885         .llseek         = no_llseek,
1886         .read           = it8172_read,
1887         .write          = it8172_write,
1888         .poll           = it8172_poll,
1889         .ioctl          = it8172_ioctl,
1890         .mmap           = it8172_mmap,
1891         .open           = it8172_open,
1892         .release        = it8172_release,
1893 };
1894
1895
1896 /* --------------------------------------------------------------------- */
1897
1898
1899 /* --------------------------------------------------------------------- */
1900
1901 /*
1902  * for debugging purposes, we'll create a proc device that dumps the
1903  * CODEC chipstate
1904  */
1905
1906 #ifdef IT8172_DEBUG
1907 static int proc_it8172_dump (char *buf, char **start, off_t fpos,
1908                              int length, int *eof, void *data)
1909 {
1910         struct it8172_state *s;
1911         int cnt, len = 0;
1912
1913         if (list_empty(&devs))
1914                 return 0;
1915         s = list_entry(devs.next, struct it8172_state, devs);
1916
1917         /* print out header */
1918         len += sprintf(buf + len, "\n\t\tIT8172 Audio Debug\n\n");
1919
1920         // print out digital controller state
1921         len += sprintf (buf + len, "IT8172 Audio Controller registers\n");
1922         len += sprintf (buf + len, "---------------------------------\n");
1923         cnt=0;
1924         while (cnt < 0x72) {
1925                 if (cnt == IT_AC_PCB1STA || cnt == IT_AC_PCB2STA ||
1926                     cnt == IT_AC_CAPB1STA || cnt == IT_AC_CAPB2STA ||
1927                     cnt == IT_AC_PFDP) {
1928                         len+= sprintf (buf + len, "reg %02x = %08x\n",
1929                                        cnt, inl(s->io+cnt));
1930                         cnt += 4;
1931                 } else {
1932                         len+= sprintf (buf + len, "reg %02x = %04x\n",
1933                                        cnt, inw(s->io+cnt));
1934                         cnt += 2;
1935                 }
1936         }
1937     
1938         /* print out CODEC state */
1939         len += sprintf (buf + len, "\nAC97 CODEC registers\n");
1940         len += sprintf (buf + len, "----------------------\n");
1941         for (cnt=0; cnt <= 0x7e; cnt = cnt +2)
1942                 len+= sprintf (buf + len, "reg %02x = %04x\n",
1943                                cnt, rdcodec(&s->codec, cnt));
1944
1945         if (fpos >=len){
1946                 *start = buf;
1947                 *eof =1;
1948                 return 0;
1949         }
1950         *start = buf + fpos;
1951         if ((len -= fpos) > length)
1952                 return length;
1953         *eof =1;
1954         return len;
1955
1956 }
1957 #endif /* IT8172_DEBUG */
1958
1959 /* --------------------------------------------------------------------- */
1960
1961 /* maximum number of devices; only used for command line params */
1962 #define NR_DEVICE 5
1963
1964 static int spdif[NR_DEVICE];
1965 static int i2s_fmt[NR_DEVICE];
1966
1967 static unsigned int devindex;
1968
1969 MODULE_PARM(spdif, "1-" __MODULE_STRING(NR_DEVICE) "i");
1970 MODULE_PARM_DESC(spdif, "if 1 the S/PDIF digital output is enabled");
1971 MODULE_PARM(i2s_fmt, "1-" __MODULE_STRING(NR_DEVICE) "i");
1972 MODULE_PARM_DESC(i2s_fmt, "the format of I2S");
1973
1974 MODULE_AUTHOR("Monta Vista Software, stevel@mvista.com");
1975 MODULE_DESCRIPTION("IT8172 Audio Driver");
1976
1977 /* --------------------------------------------------------------------- */
1978
1979 static int __devinit it8172_probe(struct pci_dev *pcidev,
1980                                   const struct pci_device_id *pciid)
1981 {
1982         struct it8172_state *s;
1983         int i, val;
1984         unsigned short pcisr, vol;
1985         unsigned char legacy, imc;
1986         char proc_str[80];
1987     
1988         if (pcidev->irq == 0) 
1989                 return -1;
1990
1991         if (!(s = kmalloc(sizeof(struct it8172_state), GFP_KERNEL))) {
1992                 err("alloc of device struct failed");
1993                 return -1;
1994         }
1995         
1996         memset(s, 0, sizeof(struct it8172_state));
1997         init_waitqueue_head(&s->dma_adc.wait);
1998         init_waitqueue_head(&s->dma_dac.wait);
1999         init_waitqueue_head(&s->open_wait);
2000         init_MUTEX(&s->open_sem);
2001         spin_lock_init(&s->lock);
2002         s->dev = pcidev;
2003         s->io = pci_resource_start(pcidev, 0);
2004         s->irq = pcidev->irq;
2005         s->vendor = pcidev->vendor;
2006         s->device = pcidev->device;
2007         pci_read_config_byte(pcidev, PCI_REVISION_ID, &s->rev);
2008         s->codec.private_data = s;
2009         s->codec.id = 0;
2010         s->codec.codec_read = rdcodec;
2011         s->codec.codec_write = wrcodec;
2012         s->codec.codec_wait = waitcodec;
2013
2014         if (!request_region(s->io, pci_resource_len(pcidev,0),
2015                             IT8172_MODULE_NAME)) {
2016                 err("io ports %#lx->%#lx in use",
2017                     s->io, s->io + pci_resource_len(pcidev,0)-1);
2018                 goto err_region;
2019         }
2020         if (request_irq(s->irq, it8172_interrupt, SA_INTERRUPT,
2021                         IT8172_MODULE_NAME, s)) {
2022                 err("irq %u in use", s->irq);
2023                 goto err_irq;
2024         }
2025
2026         info("IO at %#lx, IRQ %d", s->io, s->irq);
2027
2028         /* register devices */
2029         if ((s->dev_audio = register_sound_dsp(&it8172_audio_fops, -1)) < 0)
2030                 goto err_dev1;
2031         if ((s->codec.dev_mixer =
2032              register_sound_mixer(&it8172_mixer_fops, -1)) < 0)
2033                 goto err_dev2;
2034
2035 #ifdef IT8172_DEBUG
2036         /* initialize the debug proc device */
2037         s->ps = create_proc_read_entry(IT8172_MODULE_NAME, 0, NULL,
2038                                        proc_it8172_dump, NULL);
2039 #endif /* IT8172_DEBUG */
2040         
2041         /*
2042          * Reset the Audio device using the IT8172 PCI Reset register. This
2043          * creates an audible double click on a speaker connected to Line-out.
2044          */
2045         IT_IO_READ16(IT_PM_PCISR, pcisr);
2046         pcisr |= IT_PM_PCISR_ACSR;
2047         IT_IO_WRITE16(IT_PM_PCISR, pcisr);
2048         /* wait up to 100msec for reset to complete */
2049         for (i=0; pcisr & IT_PM_PCISR_ACSR; i++) {
2050                 it8172_delay(10);
2051                 if (i == 10)
2052                         break;
2053                 IT_IO_READ16(IT_PM_PCISR, pcisr);
2054         }
2055         if (i == 10) {
2056                 err("chip reset timeout!");
2057                 goto err_dev3;
2058         }
2059     
2060         /* enable pci io and bus mastering */
2061         if (pci_enable_device(pcidev))
2062                 goto err_dev3;
2063         pci_set_master(pcidev);
2064
2065         /* get out of legacy mode */
2066         pci_read_config_byte (pcidev, 0x40, &legacy);
2067         pci_write_config_byte (pcidev, 0x40, legacy & ~1);
2068     
2069         s->spdif_volume = -1;
2070         /* check to see if s/pdif mode is being requested */
2071         if (spdif[devindex]) {
2072                 info("enabling S/PDIF output");
2073                 s->spdif_volume = 0;
2074                 outb(GC_SOE, s->io+IT_AC_GC);
2075         } else {
2076                 info("disabling S/PDIF output");
2077                 outb(0, s->io+IT_AC_GC);
2078         }
2079     
2080         /* check to see if I2S format requested */
2081         if (i2s_fmt[devindex]) {
2082                 info("setting I2S format to 0x%02x", i2s_fmt[devindex]);
2083                 outb(i2s_fmt[devindex], s->io+IT_AC_I2SMC);
2084         } else {
2085                 outb(I2SMC_I2SF_I2S, s->io+IT_AC_I2SMC);
2086         }
2087
2088         /* cold reset the AC97 */
2089         outw(CODECC_CR, s->io+IT_AC_CODECC);
2090         udelay(1000);
2091         outw(0, s->io+IT_AC_CODECC);
2092         /* need to delay around 500msec(bleech) to give
2093            some CODECs enough time to wakeup */
2094         it8172_delay(500);
2095     
2096         /* AC97 warm reset to start the bitclk */
2097         outw(CODECC_WR, s->io+IT_AC_CODECC);
2098         udelay(1000);
2099         outw(0, s->io+IT_AC_CODECC);
2100     
2101         /* codec init */
2102         if (!ac97_probe_codec(&s->codec))
2103                 goto err_dev3;
2104
2105         /* add I2S as allowable recording source */
2106         s->codec.record_sources |= SOUND_MASK_I2S;
2107         
2108         /* Enable Volume button interrupts */
2109         imc = inb(s->io+IT_AC_IMC);
2110         outb(imc & ~IMC_VCIM, s->io+IT_AC_IMC);
2111
2112         /* Un-mute PCM and FM out on the controller */
2113         vol = inw(s->io+IT_AC_PCMOV);
2114         outw(vol & ~PCMOV_PCMOM, s->io+IT_AC_PCMOV);
2115         vol = inw(s->io+IT_AC_FMOV);
2116         outw(vol & ~FMOV_FMOM, s->io+IT_AC_FMOV);
2117     
2118         /* set channel defaults to 8-bit, mono, 8 Khz */
2119         s->pcc = 0;
2120         s->capcc = 0;
2121         set_dac_rate(s, 8000);
2122         set_adc_rate(s, 8000);
2123
2124         /* set mic to be the recording source */
2125         val = SOUND_MASK_MIC;
2126         mixdev_ioctl(&s->codec, SOUND_MIXER_WRITE_RECSRC,
2127                      (unsigned long)&val);
2128
2129         /* mute AC'97 master and PCM when in S/PDIF mode */
2130         if (s->spdif_volume != -1) {
2131                 val = 0x0000;
2132                 s->codec.mixer_ioctl(&s->codec, SOUND_MIXER_WRITE_VOLUME,
2133                                      (unsigned long)&val);
2134                 s->codec.mixer_ioctl(&s->codec, SOUND_MIXER_WRITE_PCM,
2135                                      (unsigned long)&val);
2136         }
2137     
2138 #ifdef IT8172_DEBUG
2139         sprintf(proc_str, "driver/%s/%d/ac97", IT8172_MODULE_NAME,
2140                 s->codec.id);
2141         s->ac97_ps = create_proc_read_entry (proc_str, 0, NULL,
2142                                              ac97_read_proc, &s->codec);
2143 #endif
2144     
2145         /* store it in the driver field */
2146         pci_set_drvdata(pcidev, s);
2147         pcidev->dma_mask = 0xffffffff;
2148         /* put it into driver list */
2149         list_add_tail(&s->devs, &devs);
2150         /* increment devindex */
2151         if (devindex < NR_DEVICE-1)
2152                 devindex++;
2153         return 0;
2154
2155  err_dev3:
2156         unregister_sound_mixer(s->codec.dev_mixer);
2157  err_dev2:
2158         unregister_sound_dsp(s->dev_audio);
2159  err_dev1:
2160         err("cannot register misc device");
2161         free_irq(s->irq, s);
2162  err_irq:
2163         release_region(s->io, pci_resource_len(pcidev,0));
2164  err_region:
2165         kfree(s);
2166         return -1;
2167 }
2168
2169 static void __devexit it8172_remove(struct pci_dev *dev)
2170 {
2171         struct it8172_state *s = pci_get_drvdata(dev);
2172
2173         if (!s)
2174                 return;
2175         list_del(&s->devs);
2176 #ifdef IT8172_DEBUG
2177         if (s->ps)
2178                 remove_proc_entry(IT8172_MODULE_NAME, NULL);
2179 #endif /* IT8172_DEBUG */
2180         synchronize_irq(s->irq);
2181         free_irq(s->irq, s);
2182         release_region(s->io, pci_resource_len(dev,0));
2183         unregister_sound_dsp(s->dev_audio);
2184         unregister_sound_mixer(s->codec.dev_mixer);
2185         kfree(s);
2186         pci_set_drvdata(dev, NULL);
2187 }
2188
2189
2190
2191 static struct pci_device_id id_table[] = {
2192         { PCI_VENDOR_ID_ITE, PCI_DEVICE_ID_ITE_IT8172G_AUDIO, PCI_ANY_ID,
2193           PCI_ANY_ID, 0, 0 },
2194         { 0, }
2195 };
2196
2197 MODULE_DEVICE_TABLE(pci, id_table);
2198
2199 static struct pci_driver it8172_driver = {
2200         .name = IT8172_MODULE_NAME,
2201         .id_table = id_table,
2202         .probe = it8172_probe,
2203         .remove = __devexit_p(it8172_remove)
2204 };
2205
2206 static int __init init_it8172(void)
2207 {
2208         info("version v0.5 time " __TIME__ " " __DATE__);
2209         return pci_module_init(&it8172_driver);
2210 }
2211
2212 static void __exit cleanup_it8172(void)
2213 {
2214         info("unloading");
2215         pci_unregister_driver(&it8172_driver);
2216 }
2217
2218 module_init(init_it8172);
2219 module_exit(cleanup_it8172);
2220
2221 /* --------------------------------------------------------------------- */
2222
2223 #ifndef MODULE
2224
2225 /* format is: it8172=[spdif],[i2s:<I2S format>] */
2226
2227 static int __init it8172_setup(char *options)
2228 {
2229         char* this_opt;
2230         static unsigned __initdata nr_dev = 0;
2231
2232         if (nr_dev >= NR_DEVICE)
2233                 return 0;
2234
2235         if (!options || !*options)
2236                 return 0;
2237
2238         while (this_opt = strsep(&options, ",")) {
2239                 if (!*this_opt)
2240                         continue;
2241                 if (!strncmp(this_opt, "spdif", 5)) {
2242                         spdif[nr_dev] = 1;
2243                 } else if (!strncmp(this_opt, "i2s:", 4)) {
2244                         if (!strncmp(this_opt+4, "dac", 3))
2245                                 i2s_fmt[nr_dev] = I2SMC_I2SF_DAC;
2246                         else if (!strncmp(this_opt+4, "adc", 3))
2247                                 i2s_fmt[nr_dev] = I2SMC_I2SF_ADC;
2248                         else if (!strncmp(this_opt+4, "i2s", 3))
2249                                 i2s_fmt[nr_dev] = I2SMC_I2SF_I2S;
2250                 }
2251         }
2252
2253         nr_dev++;
2254         return 1;
2255 }
2256
2257 __setup("it8172=", it8172_setup);
2258
2259 #endif /* MODULE */