?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update libata drive blacklist to the latest from 2.6.21
[linux/fpc-iii.git] / sound / pci / emu10k1 / io.c
blob029e7856c43beaa7d171a22696d95410119b7b43
1 /*
2 * Copyright (c) by Jaroslav Kysela <perex@suse.cz>
3 * Creative Labs, Inc.
4 * Routines for control of EMU10K1 chips
5 *
6 * BUGS:
7 * --
8 *
9 * TODO:
10 * --
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 *
26 */
27
28 #include <sound/driver.h>
29 #include <linux/time.h>
30 #include <sound/core.h>
31 #include <sound/emu10k1.h>
32 #include <linux/delay.h>
33
34 unsigned int snd_emu10k1_ptr_read(struct snd_emu10k1 * emu, unsigned int reg, unsigned int chn)
35 {
36 unsigned long flags;
37 unsigned int regptr, val;
38 unsigned int mask;
39
40 mask = emu->audigy ? A_PTR_ADDRESS_MASK : PTR_ADDRESS_MASK;
41 regptr = ((reg << 16) & mask) | (chn & PTR_CHANNELNUM_MASK);
42
43 if (reg & 0xff000000) {
44 unsigned char size, offset;
45
46 size = (reg >> 24) & 0x3f;
47 offset = (reg >> 16) & 0x1f;
48 mask = ((1 << size) - 1) << offset;
49
50 spin_lock_irqsave(&emu->emu_lock, flags);
51 outl(regptr, emu->port + PTR);
52 val = inl(emu->port + DATA);
53 spin_unlock_irqrestore(&emu->emu_lock, flags);
54
55 return (val & mask) >> offset;
56 } else {
57 spin_lock_irqsave(&emu->emu_lock, flags);
58 outl(regptr, emu->port + PTR);
59 val = inl(emu->port + DATA);
60 spin_unlock_irqrestore(&emu->emu_lock, flags);
61 return val;
62 }
63 }
64
65 EXPORT_SYMBOL(snd_emu10k1_ptr_read);
66
67 void snd_emu10k1_ptr_write(struct snd_emu10k1 *emu, unsigned int reg, unsigned int chn, unsigned int data)
68 {
69 unsigned int regptr;
70 unsigned long flags;
71 unsigned int mask;
72
73 mask = emu->audigy ? A_PTR_ADDRESS_MASK : PTR_ADDRESS_MASK;
74 regptr = ((reg << 16) & mask) | (chn & PTR_CHANNELNUM_MASK);
75
76 if (reg & 0xff000000) {
77 unsigned char size, offset;
78
79 size = (reg >> 24) & 0x3f;
80 offset = (reg >> 16) & 0x1f;
81 mask = ((1 << size) - 1) << offset;
82 data = (data << offset) & mask;
83
84 spin_lock_irqsave(&emu->emu_lock, flags);
85 outl(regptr, emu->port + PTR);
86 data |= inl(emu->port + DATA) & ~mask;
87 outl(data, emu->port + DATA);
88 spin_unlock_irqrestore(&emu->emu_lock, flags);
89 } else {
90 spin_lock_irqsave(&emu->emu_lock, flags);
91 outl(regptr, emu->port + PTR);
92 outl(data, emu->port + DATA);
93 spin_unlock_irqrestore(&emu->emu_lock, flags);
94 }
95 }
96
97 EXPORT_SYMBOL(snd_emu10k1_ptr_write);
98
99 unsigned int snd_emu10k1_ptr20_read(struct snd_emu10k1 * emu,
100 unsigned int reg,
101 unsigned int chn)
102 {
103 unsigned long flags;
104 unsigned int regptr, val;
105
106 regptr = (reg << 16) | chn;
107
108 spin_lock_irqsave(&emu->emu_lock, flags);
109 outl(regptr, emu->port + 0x20 + PTR);
110 val = inl(emu->port + 0x20 + DATA);
111 spin_unlock_irqrestore(&emu->emu_lock, flags);
112 return val;
113 }
114
115 void snd_emu10k1_ptr20_write(struct snd_emu10k1 *emu,
116 unsigned int reg,
117 unsigned int chn,
118 unsigned int data)
119 {
120 unsigned int regptr;
121 unsigned long flags;
122
123 regptr = (reg << 16) | chn;
124
125 spin_lock_irqsave(&emu->emu_lock, flags);
126 outl(regptr, emu->port + 0x20 + PTR);
127 outl(data, emu->port + 0x20 + DATA);
128 spin_unlock_irqrestore(&emu->emu_lock, flags);
129 }
130
131 int snd_emu10k1_spi_write(struct snd_emu10k1 * emu,
132 unsigned int data)
133 {
134 unsigned int reset, set;
135 unsigned int reg, tmp;
136 int n, result;
137 if (emu->card_capabilities->ca0108_chip)
138 reg = 0x3c; /* PTR20, reg 0x3c */
139 else {
140 /* For other chip types the SPI register
141 * is currently unknown. */
142 return 1;
143 }
144 if (data > 0xffff) /* Only 16bit values allowed */
145 return 1;
146
147 tmp = snd_emu10k1_ptr20_read(emu, reg, 0);
148 reset = (tmp & ~0x3ffff) | 0x20000; /* Set xxx20000 */
149 set = reset | 0x10000; /* Set xxx1xxxx */
150 snd_emu10k1_ptr20_write(emu, reg, 0, reset | data);
151 tmp = snd_emu10k1_ptr20_read(emu, reg, 0); /* write post */
152 snd_emu10k1_ptr20_write(emu, reg, 0, set | data);
153 result = 1;
154 /* Wait for status bit to return to 0 */
155 for (n = 0; n < 100; n++) {
156 udelay(10);
157 tmp = snd_emu10k1_ptr20_read(emu, reg, 0);
158 if (!(tmp & 0x10000)) {
159 result = 0;
160 break;
161 }
162 }
163 if (result) /* Timed out */
164 return 1;
165 snd_emu10k1_ptr20_write(emu, reg, 0, reset | data);
166 tmp = snd_emu10k1_ptr20_read(emu, reg, 0); /* Write post */
167 return 0;
168 }
169
170 void snd_emu10k1_intr_enable(struct snd_emu10k1 *emu, unsigned int intrenb)
171 {
172 unsigned long flags;
173 unsigned int enable;
174
175 spin_lock_irqsave(&emu->emu_lock, flags);
176 enable = inl(emu->port + INTE) | intrenb;
177 outl(enable, emu->port + INTE);
178 spin_unlock_irqrestore(&emu->emu_lock, flags);
179 }
180
181 void snd_emu10k1_intr_disable(struct snd_emu10k1 *emu, unsigned int intrenb)
182 {
183 unsigned long flags;
184 unsigned int enable;
185
186 spin_lock_irqsave(&emu->emu_lock, flags);
187 enable = inl(emu->port + INTE) & ~intrenb;
188 outl(enable, emu->port + INTE);
189 spin_unlock_irqrestore(&emu->emu_lock, flags);
190 }
191
192 void snd_emu10k1_voice_intr_enable(struct snd_emu10k1 *emu, unsigned int voicenum)
193 {
194 unsigned long flags;
195 unsigned int val;
196
197 spin_lock_irqsave(&emu->emu_lock, flags);
198 /* voice interrupt */
199 if (voicenum >= 32) {
200 outl(CLIEH << 16, emu->port + PTR);
201 val = inl(emu->port + DATA);
202 val |= 1 << (voicenum - 32);
203 } else {
204 outl(CLIEL << 16, emu->port + PTR);
205 val = inl(emu->port + DATA);
206 val |= 1 << voicenum;
207 }
208 outl(val, emu->port + DATA);
209 spin_unlock_irqrestore(&emu->emu_lock, flags);
210 }
211
212 void snd_emu10k1_voice_intr_disable(struct snd_emu10k1 *emu, unsigned int voicenum)
213 {
214 unsigned long flags;
215 unsigned int val;
216
217 spin_lock_irqsave(&emu->emu_lock, flags);
218 /* voice interrupt */
219 if (voicenum >= 32) {
220 outl(CLIEH << 16, emu->port + PTR);
221 val = inl(emu->port + DATA);
222 val &= ~(1 << (voicenum - 32));
223 } else {
224 outl(CLIEL << 16, emu->port + PTR);
225 val = inl(emu->port + DATA);
226 val &= ~(1 << voicenum);
227 }
228 outl(val, emu->port + DATA);
229 spin_unlock_irqrestore(&emu->emu_lock, flags);
230 }
231
232 void snd_emu10k1_voice_intr_ack(struct snd_emu10k1 *emu, unsigned int voicenum)
233 {
234 unsigned long flags;
235
236 spin_lock_irqsave(&emu->emu_lock, flags);
237 /* voice interrupt */
238 if (voicenum >= 32) {
239 outl(CLIPH << 16, emu->port + PTR);
240 voicenum = 1 << (voicenum - 32);
241 } else {
242 outl(CLIPL << 16, emu->port + PTR);
243 voicenum = 1 << voicenum;
244 }
245 outl(voicenum, emu->port + DATA);
246 spin_unlock_irqrestore(&emu->emu_lock, flags);
247 }
248
249 void snd_emu10k1_voice_half_loop_intr_enable(struct snd_emu10k1 *emu, unsigned int voicenum)
250 {
251 unsigned long flags;
252 unsigned int val;
253
254 spin_lock_irqsave(&emu->emu_lock, flags);
255 /* voice interrupt */
256 if (voicenum >= 32) {
257 outl(HLIEH << 16, emu->port + PTR);
258 val = inl(emu->port + DATA);
259 val |= 1 << (voicenum - 32);
260 } else {
261 outl(HLIEL << 16, emu->port + PTR);
262 val = inl(emu->port + DATA);
263 val |= 1 << voicenum;
264 }
265 outl(val, emu->port + DATA);
266 spin_unlock_irqrestore(&emu->emu_lock, flags);
267 }
268
269 void snd_emu10k1_voice_half_loop_intr_disable(struct snd_emu10k1 *emu, unsigned int voicenum)
270 {
271 unsigned long flags;
272 unsigned int val;
273
274 spin_lock_irqsave(&emu->emu_lock, flags);
275 /* voice interrupt */
276 if (voicenum >= 32) {
277 outl(HLIEH << 16, emu->port + PTR);
278 val = inl(emu->port + DATA);
279 val &= ~(1 << (voicenum - 32));
280 } else {
281 outl(HLIEL << 16, emu->port + PTR);
282 val = inl(emu->port + DATA);
283 val &= ~(1 << voicenum);
284 }
285 outl(val, emu->port + DATA);
286 spin_unlock_irqrestore(&emu->emu_lock, flags);
287 }
288
289 void snd_emu10k1_voice_half_loop_intr_ack(struct snd_emu10k1 *emu, unsigned int voicenum)
290 {
291 unsigned long flags;
292
293 spin_lock_irqsave(&emu->emu_lock, flags);
294 /* voice interrupt */
295 if (voicenum >= 32) {
296 outl(HLIPH << 16, emu->port + PTR);
297 voicenum = 1 << (voicenum - 32);
298 } else {
299 outl(HLIPL << 16, emu->port + PTR);
300 voicenum = 1 << voicenum;
301 }
302 outl(voicenum, emu->port + DATA);
303 spin_unlock_irqrestore(&emu->emu_lock, flags);
304 }
305
306 void snd_emu10k1_voice_set_loop_stop(struct snd_emu10k1 *emu, unsigned int voicenum)
307 {
308 unsigned long flags;
309 unsigned int sol;
310
311 spin_lock_irqsave(&emu->emu_lock, flags);
312 /* voice interrupt */
313 if (voicenum >= 32) {
314 outl(SOLEH << 16, emu->port + PTR);
315 sol = inl(emu->port + DATA);
316 sol |= 1 << (voicenum - 32);
317 } else {
318 outl(SOLEL << 16, emu->port + PTR);
319 sol = inl(emu->port + DATA);
320 sol |= 1 << voicenum;
321 }
322 outl(sol, emu->port + DATA);
323 spin_unlock_irqrestore(&emu->emu_lock, flags);
324 }
325
326 void snd_emu10k1_voice_clear_loop_stop(struct snd_emu10k1 *emu, unsigned int voicenum)
327 {
328 unsigned long flags;
329 unsigned int sol;
330
331 spin_lock_irqsave(&emu->emu_lock, flags);
332 /* voice interrupt */
333 if (voicenum >= 32) {
334 outl(SOLEH << 16, emu->port + PTR);
335 sol = inl(emu->port + DATA);
336 sol &= ~(1 << (voicenum - 32));
337 } else {
338 outl(SOLEL << 16, emu->port + PTR);
339 sol = inl(emu->port + DATA);
340 sol &= ~(1 << voicenum);
341 }
342 outl(sol, emu->port + DATA);
343 spin_unlock_irqrestore(&emu->emu_lock, flags);
344 }
345
346 void snd_emu10k1_wait(struct snd_emu10k1 *emu, unsigned int wait)
347 {
348 volatile unsigned count;
349 unsigned int newtime = 0, curtime;
350
351 curtime = inl(emu->port + WC) >> 6;
352 while (wait-- > 0) {
353 count = 0;
354 while (count++ < 16384) {
355 newtime = inl(emu->port + WC) >> 6;
356 if (newtime != curtime)
357 break;
358 }
359 if (count >= 16384)
360 break;
361 curtime = newtime;
362 }
363 }
364
365 unsigned short snd_emu10k1_ac97_read(struct snd_ac97 *ac97, unsigned short reg)
366 {
367 struct snd_emu10k1 *emu = ac97->private_data;
368 unsigned long flags;
369 unsigned short val;
370
371 spin_lock_irqsave(&emu->emu_lock, flags);
372 outb(reg, emu->port + AC97ADDRESS);
373 val = inw(emu->port + AC97DATA);
374 spin_unlock_irqrestore(&emu->emu_lock, flags);
375 return val;
376 }
377
378 void snd_emu10k1_ac97_write(struct snd_ac97 *ac97, unsigned short reg, unsigned short data)
379 {
380 struct snd_emu10k1 *emu = ac97->private_data;
381 unsigned long flags;
382
383 spin_lock_irqsave(&emu->emu_lock, flags);
384 outb(reg, emu->port + AC97ADDRESS);
385 outw(data, emu->port + AC97DATA);
386 spin_unlock_irqrestore(&emu->emu_lock, flags);
387 }
388
389 /*
390 * convert rate to pitch
391 */
392
393 unsigned int snd_emu10k1_rate_to_pitch(unsigned int rate)
394 {
395 static u32 logMagTable[128] = {
396 0x00000, 0x02dfc, 0x05b9e, 0x088e6, 0x0b5d6, 0x0e26f, 0x10eb3, 0x13aa2,
397 0x1663f, 0x1918a, 0x1bc84, 0x1e72e, 0x2118b, 0x23b9a, 0x2655d, 0x28ed5,
398 0x2b803, 0x2e0e8, 0x30985, 0x331db, 0x359eb, 0x381b6, 0x3a93d, 0x3d081,
399 0x3f782, 0x41e42, 0x444c1, 0x46b01, 0x49101, 0x4b6c4, 0x4dc49, 0x50191,
400 0x5269e, 0x54b6f, 0x57006, 0x59463, 0x5b888, 0x5dc74, 0x60029, 0x623a7,
401 0x646ee, 0x66a00, 0x68cdd, 0x6af86, 0x6d1fa, 0x6f43c, 0x7164b, 0x73829,
402 0x759d4, 0x77b4f, 0x79c9a, 0x7bdb5, 0x7dea1, 0x7ff5e, 0x81fed, 0x8404e,
403 0x86082, 0x88089, 0x8a064, 0x8c014, 0x8df98, 0x8fef1, 0x91e20, 0x93d26,
404 0x95c01, 0x97ab4, 0x9993e, 0x9b79f, 0x9d5d9, 0x9f3ec, 0xa11d8, 0xa2f9d,
405 0xa4d3c, 0xa6ab5, 0xa8808, 0xaa537, 0xac241, 0xadf26, 0xafbe7, 0xb1885,
406 0xb3500, 0xb5157, 0xb6d8c, 0xb899f, 0xba58f, 0xbc15e, 0xbdd0c, 0xbf899,
407 0xc1404, 0xc2f50, 0xc4a7b, 0xc6587, 0xc8073, 0xc9b3f, 0xcb5ed, 0xcd07c,
408 0xceaec, 0xd053f, 0xd1f73, 0xd398a, 0xd5384, 0xd6d60, 0xd8720, 0xda0c3,
409 0xdba4a, 0xdd3b4, 0xded03, 0xe0636, 0xe1f4e, 0xe384a, 0xe512c, 0xe69f3,
410 0xe829f, 0xe9b31, 0xeb3a9, 0xecc08, 0xee44c, 0xefc78, 0xf148a, 0xf2c83,
411 0xf4463, 0xf5c2a, 0xf73da, 0xf8b71, 0xfa2f0, 0xfba57, 0xfd1a7, 0xfe8df
412 };
413 static char logSlopeTable[128] = {
414 0x5c, 0x5c, 0x5b, 0x5a, 0x5a, 0x59, 0x58, 0x58,
415 0x57, 0x56, 0x56, 0x55, 0x55, 0x54, 0x53, 0x53,
416 0x52, 0x52, 0x51, 0x51, 0x50, 0x50, 0x4f, 0x4f,
417 0x4e, 0x4d, 0x4d, 0x4d, 0x4c, 0x4c, 0x4b, 0x4b,
418 0x4a, 0x4a, 0x49, 0x49, 0x48, 0x48, 0x47, 0x47,
419 0x47, 0x46, 0x46, 0x45, 0x45, 0x45, 0x44, 0x44,
420 0x43, 0x43, 0x43, 0x42, 0x42, 0x42, 0x41, 0x41,
421 0x41, 0x40, 0x40, 0x40, 0x3f, 0x3f, 0x3f, 0x3e,
422 0x3e, 0x3e, 0x3d, 0x3d, 0x3d, 0x3c, 0x3c, 0x3c,
423 0x3b, 0x3b, 0x3b, 0x3b, 0x3a, 0x3a, 0x3a, 0x39,
424 0x39, 0x39, 0x39, 0x38, 0x38, 0x38, 0x38, 0x37,
425 0x37, 0x37, 0x37, 0x36, 0x36, 0x36, 0x36, 0x35,
426 0x35, 0x35, 0x35, 0x34, 0x34, 0x34, 0x34, 0x34,
427 0x33, 0x33, 0x33, 0x33, 0x32, 0x32, 0x32, 0x32,
428 0x32, 0x31, 0x31, 0x31, 0x31, 0x31, 0x30, 0x30,
429 0x30, 0x30, 0x30, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f
430 };
431 int i;
432
433 if (rate == 0)
434 return 0; /* Bail out if no leading "1" */
435 rate *= 11185; /* Scale 48000 to 0x20002380 */
436 for (i = 31; i > 0; i--) {
437 if (rate & 0x80000000) { /* Detect leading "1" */
438 return (((unsigned int) (i - 15) << 20) +
439 logMagTable[0x7f & (rate >> 24)] +
440 (0x7f & (rate >> 17)) *
441 logSlopeTable[0x7f & (rate >> 24)]);
442 }
443 rate <<= 1;
444 }
445
446 return 0; /* Should never reach this point */
447 }
448
Linux with added FPC-III support