5bd69206ba65943bfff05221d8b9f66e9abc245e
[linux-2.6.git] / sound / pcmcia / pdaudiocf / pdaudiocf_irq.c
1 /*
2  * Driver for Sound Core PDAudioCF soundcard
3  *
4  * Copyright (c) 2003 by Jaroslav Kysela <perex@suse.cz>
5  *
6  *   This program is free software; you can redistribute it and/or modify
7  *   it under the terms of the GNU General Public License as published by
8  *   the Free Software Foundation; either version 2 of the License, or
9  *   (at your option) any later version.
10  *
11  *   This program is distributed in the hope that it will be useful,
12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *   GNU General Public License for more details.
15  *
16  *   You should have received a copy of the GNU General Public License
17  *   along with this program; if not, write to the Free Software
18  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
19  */
20
21 #include <sound/driver.h>
22 #include <sound/core.h>
23 #include "pdaudiocf.h"
24 #include <sound/initval.h>
25 #include <asm/irq_regs.h>
26
27 /*
28  *
29  */
30 irqreturn_t pdacf_interrupt(int irq, void *dev)
31 {
32         struct snd_pdacf *chip = dev;
33         unsigned short stat;
34
35         if ((chip->chip_status & (PDAUDIOCF_STAT_IS_STALE|
36                                   PDAUDIOCF_STAT_IS_CONFIGURED|
37                                   PDAUDIOCF_STAT_IS_SUSPENDED)) != PDAUDIOCF_STAT_IS_CONFIGURED)
38                 return IRQ_HANDLED;     /* IRQ_NONE here? */
39
40         stat = inw(chip->port + PDAUDIOCF_REG_ISR);
41         if (stat & (PDAUDIOCF_IRQLVL|PDAUDIOCF_IRQOVR)) {
42                 if (stat & PDAUDIOCF_IRQOVR)    /* should never happen */
43                         snd_printk(KERN_ERR "PDAUDIOCF SRAM buffer overrun detected!\n");
44                 if (chip->pcm_substream)
45                         tasklet_hi_schedule(&chip->tq);
46                 if (!(stat & PDAUDIOCF_IRQAKM))
47                         stat |= PDAUDIOCF_IRQAKM;       /* check rate */
48         }
49         if (get_irq_regs() != NULL)
50                 snd_ak4117_check_rate_and_errors(chip->ak4117, 0);
51         return IRQ_HANDLED;
52 }
53
54 static inline void pdacf_transfer_mono16(u16 *dst, u16 xor, unsigned int size, unsigned long rdp_port)
55 {
56         while (size-- > 0) {
57                 *dst++ = inw(rdp_port) ^ xor;
58                 inw(rdp_port);
59         }
60 }
61
62 static inline void pdacf_transfer_mono32(u32 *dst, u32 xor, unsigned int size, unsigned long rdp_port)
63 {
64         register u16 val1, val2;
65
66         while (size-- > 0) {
67                 val1 = inw(rdp_port);
68                 val2 = inw(rdp_port);
69                 inw(rdp_port);
70                 *dst++ = ((((u32)val2 & 0xff) << 24) | ((u32)val1 << 8)) ^ xor;
71         }
72 }
73
74 static inline void pdacf_transfer_stereo16(u16 *dst, u16 xor, unsigned int size, unsigned long rdp_port)
75 {
76         while (size-- > 0) {
77                 *dst++ = inw(rdp_port) ^ xor;
78                 *dst++ = inw(rdp_port) ^ xor;
79         }
80 }
81
82 static inline void pdacf_transfer_stereo32(u32 *dst, u32 xor, unsigned int size, unsigned long rdp_port)
83 {
84         register u16 val1, val2, val3;
85
86         while (size-- > 0) {
87                 val1 = inw(rdp_port);
88                 val2 = inw(rdp_port);
89                 val3 = inw(rdp_port);
90                 *dst++ = ((((u32)val2 & 0xff) << 24) | ((u32)val1 << 8)) ^ xor;
91                 *dst++ = (((u32)val3 << 16) | (val2 & 0xff00)) ^ xor;
92         }
93 }
94
95 static inline void pdacf_transfer_mono16sw(u16 *dst, u16 xor, unsigned int size, unsigned long rdp_port)
96 {
97         while (size-- > 0) {
98                 *dst++ = swab16(inw(rdp_port) ^ xor);
99                 inw(rdp_port);
100         }
101 }
102
103 static inline void pdacf_transfer_mono32sw(u32 *dst, u32 xor, unsigned int size, unsigned long rdp_port)
104 {
105         register u16 val1, val2;
106
107         while (size-- > 0) {
108                 val1 = inw(rdp_port);
109                 val2 = inw(rdp_port);
110                 inw(rdp_port);
111                 *dst++ = swab32((((val2 & 0xff) << 24) | ((u32)val1 << 8)) ^ xor);
112         }
113 }
114
115 static inline void pdacf_transfer_stereo16sw(u16 *dst, u16 xor, unsigned int size, unsigned long rdp_port)
116 {
117         while (size-- > 0) {
118                 *dst++ = swab16(inw(rdp_port) ^ xor);
119                 *dst++ = swab16(inw(rdp_port) ^ xor);
120         }
121 }
122
123 static inline void pdacf_transfer_stereo32sw(u32 *dst, u32 xor, unsigned int size, unsigned long rdp_port)
124 {
125         register u16 val1, val2, val3;
126
127         while (size-- > 0) {
128                 val1 = inw(rdp_port);
129                 val2 = inw(rdp_port);
130                 val3 = inw(rdp_port);
131                 *dst++ = swab32((((val2 & 0xff) << 24) | ((u32)val1 << 8)) ^ xor);
132                 *dst++ = swab32((((u32)val3 << 16) | (val2 & 0xff00)) ^ xor);
133         }
134 }
135
136 static inline void pdacf_transfer_mono24le(u8 *dst, u16 xor, unsigned int size, unsigned long rdp_port)
137 {
138         register u16 val1, val2;
139         register u32 xval1;
140
141         while (size-- > 0) {
142                 val1 = inw(rdp_port);
143                 val2 = inw(rdp_port);
144                 inw(rdp_port);
145                 xval1 = (((val2 & 0xff) << 8) | (val1 << 16)) ^ xor;
146                 *dst++ = (u8)(xval1 >> 8);
147                 *dst++ = (u8)(xval1 >> 16);
148                 *dst++ = (u8)(xval1 >> 24);
149         }
150 }
151
152 static inline void pdacf_transfer_mono24be(u8 *dst, u16 xor, unsigned int size, unsigned long rdp_port)
153 {
154         register u16 val1, val2;
155         register u32 xval1;
156
157         while (size-- > 0) {
158                 val1 = inw(rdp_port);
159                 val2 = inw(rdp_port);
160                 inw(rdp_port);
161                 xval1 = (((val2 & 0xff) << 8) | (val1 << 16)) ^ xor;
162                 *dst++ = (u8)(xval1 >> 24);
163                 *dst++ = (u8)(xval1 >> 16);
164                 *dst++ = (u8)(xval1 >> 8);
165         }
166 }
167
168 static inline void pdacf_transfer_stereo24le(u8 *dst, u32 xor, unsigned int size, unsigned long rdp_port)
169 {
170         register u16 val1, val2, val3;
171         register u32 xval1, xval2;
172
173         while (size-- > 0) {
174                 val1 = inw(rdp_port);
175                 val2 = inw(rdp_port);
176                 val3 = inw(rdp_port);
177                 xval1 = ((((u32)val2 & 0xff) << 24) | ((u32)val1 << 8)) ^ xor;
178                 xval2 = (((u32)val3 << 16) | (val2 & 0xff00)) ^ xor;
179                 *dst++ = (u8)(xval1 >> 8);
180                 *dst++ = (u8)(xval1 >> 16);
181                 *dst++ = (u8)(xval1 >> 24);
182                 *dst++ = (u8)(xval2 >> 8);
183                 *dst++ = (u8)(xval2 >> 16);
184                 *dst++ = (u8)(xval2 >> 24);
185         }
186 }
187
188 static inline void pdacf_transfer_stereo24be(u8 *dst, u32 xor, unsigned int size, unsigned long rdp_port)
189 {
190         register u16 val1, val2, val3;
191         register u32 xval1, xval2;
192
193         while (size-- > 0) {
194                 val1 = inw(rdp_port);
195                 val2 = inw(rdp_port);
196                 val3 = inw(rdp_port);
197                 xval1 = ((((u32)val2 & 0xff) << 24) | ((u32)val1 << 8)) ^ xor;
198                 xval2 = (((u32)val3 << 16) | (val2 & 0xff00)) ^ xor;
199                 *dst++ = (u8)(xval1 >> 24);
200                 *dst++ = (u8)(xval1 >> 16);
201                 *dst++ = (u8)(xval1 >> 8);
202                 *dst++ = (u8)(xval2 >> 24);
203                 *dst++ = (u8)(xval2 >> 16);
204                 *dst++ = (u8)(xval2 >> 8);
205         }
206 }
207
208 static void pdacf_transfer(struct snd_pdacf *chip, unsigned int size, unsigned int off)
209 {
210         unsigned long rdp_port = chip->port + PDAUDIOCF_REG_MD;
211         unsigned int xor = chip->pcm_xor;
212
213         if (chip->pcm_sample == 3) {
214                 if (chip->pcm_little) {
215                         if (chip->pcm_channels == 1) {
216                                 pdacf_transfer_mono24le((char *)chip->pcm_area + (off * 3), xor, size, rdp_port);
217                         } else {
218                                 pdacf_transfer_stereo24le((char *)chip->pcm_area + (off * 6), xor, size, rdp_port);
219                         }
220                 } else {
221                         if (chip->pcm_channels == 1) {
222                                 pdacf_transfer_mono24be((char *)chip->pcm_area + (off * 3), xor, size, rdp_port);
223                         } else {
224                                 pdacf_transfer_stereo24be((char *)chip->pcm_area + (off * 6), xor, size, rdp_port);
225                         }                       
226                 }
227                 return;
228         }
229         if (chip->pcm_swab == 0) {
230                 if (chip->pcm_channels == 1) {
231                         if (chip->pcm_frame == 2) {
232                                 pdacf_transfer_mono16((u16 *)chip->pcm_area + off, xor, size, rdp_port);
233                         } else {
234                                 pdacf_transfer_mono32((u32 *)chip->pcm_area + off, xor, size, rdp_port);
235                         }
236                 } else {
237                         if (chip->pcm_frame == 2) {
238                                 pdacf_transfer_stereo16((u16 *)chip->pcm_area + (off * 2), xor, size, rdp_port);
239                         } else {
240                                 pdacf_transfer_stereo32((u32 *)chip->pcm_area + (off * 2), xor, size, rdp_port);
241                         }
242                 }
243         } else {
244                 if (chip->pcm_channels == 1) {
245                         if (chip->pcm_frame == 2) {
246                                 pdacf_transfer_mono16sw((u16 *)chip->pcm_area + off, xor, size, rdp_port);
247                         } else {
248                                 pdacf_transfer_mono32sw((u32 *)chip->pcm_area + off, xor, size, rdp_port);
249                         }
250                 } else {
251                         if (chip->pcm_frame == 2) {
252                                 pdacf_transfer_stereo16sw((u16 *)chip->pcm_area + (off * 2), xor, size, rdp_port);
253                         } else {
254                                 pdacf_transfer_stereo32sw((u32 *)chip->pcm_area + (off * 2), xor, size, rdp_port);
255                         }
256                 }
257         }
258 }
259
260 void pdacf_tasklet(unsigned long private_data)
261 {
262         struct snd_pdacf *chip = (struct snd_pdacf *) private_data;
263         int size, off, cont, rdp, wdp;
264
265         if ((chip->chip_status & (PDAUDIOCF_STAT_IS_STALE|PDAUDIOCF_STAT_IS_CONFIGURED)) != PDAUDIOCF_STAT_IS_CONFIGURED)
266                 return;
267         
268         if (chip->pcm_substream == NULL || chip->pcm_substream->runtime == NULL || !snd_pcm_running(chip->pcm_substream))
269                 return;
270
271         rdp = inw(chip->port + PDAUDIOCF_REG_RDP);
272         wdp = inw(chip->port + PDAUDIOCF_REG_WDP);
273         // printk("TASKLET: rdp = %x, wdp = %x\n", rdp, wdp);
274         size = wdp - rdp;
275         if (size < 0)
276                 size += 0x10000;
277         if (size == 0)
278                 size = 0x10000;
279         size /= chip->pcm_frame;
280         if (size > 64)
281                 size -= 32;
282
283 #if 0
284         chip->pcm_hwptr += size;
285         chip->pcm_hwptr %= chip->pcm_size;
286         chip->pcm_tdone += size;
287         if (chip->pcm_frame == 2) {
288                 unsigned long rdp_port = chip->port + PDAUDIOCF_REG_MD;
289                 while (size-- > 0) {
290                         inw(rdp_port);
291                         inw(rdp_port);
292                 }
293         } else {
294                 unsigned long rdp_port = chip->port + PDAUDIOCF_REG_MD;
295                 while (size-- > 0) {
296                         inw(rdp_port);
297                         inw(rdp_port);
298                         inw(rdp_port);
299                 }
300         }
301 #else
302         off = chip->pcm_hwptr + chip->pcm_tdone;
303         off %= chip->pcm_size;
304         chip->pcm_tdone += size;
305         while (size > 0) {
306                 cont = chip->pcm_size - off;
307                 if (cont > size)
308                         cont = size;
309                 pdacf_transfer(chip, cont, off);
310                 off += cont;
311                 off %= chip->pcm_size;
312                 size -= cont;
313         }
314 #endif
315         spin_lock(&chip->reg_lock);
316         while (chip->pcm_tdone >= chip->pcm_period) {
317                 chip->pcm_hwptr += chip->pcm_period;
318                 chip->pcm_hwptr %= chip->pcm_size;
319                 chip->pcm_tdone -= chip->pcm_period;
320                 spin_unlock(&chip->reg_lock);
321                 snd_pcm_period_elapsed(chip->pcm_substream);
322                 spin_lock(&chip->reg_lock);
323         }
324         spin_unlock(&chip->reg_lock);
325         // printk("TASKLET: end\n");
326 }