1 /*
2 * Crystal SoundFusion CS46xx driver
3 *
4 * Copyright 1998-2000 Cirrus Logic Corporation <audio@crystal.cirrus.com>
5 * Copyright 1999-2000 Jaroslav Kysela <perex@suse.cz>
6 * Copyright 2000 Alan Cox <alan@redhat.com>
7 *
8 * The core of this code is taken from the ALSA project driver by
9 * Jaroslav. Please send Jaroslav the credit for the driver and
10 * report bugs in this port to <alan@redhat.com>
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., 675 Mass Ave, Cambridge, MA 02139, USA.
25 *
26 * Current maintainers:
27 * Cirrus Logic Corporation, Thomas Woller (tw)
28 * <twoller@crystal.cirrus.com>
29 * Nils Faerber (nf)
30 * <nils@kernelconcepts.de>
31 * Thanks to David Pollard for testing.
32 *
33 * Changes:
34 * 20000909-nf Changed cs_read, cs_write and drain_dac
35 * 20001025-tw Separate Playback/Capture structs and buffers.
36 * Added Scatter/Gather support for Playback.
37 * Added Capture.
38 * 20001027-nf Port to kernel 2.4.0-test9, some clean-ups
39 * Start of powermanagement support (CS46XX_PM).
40 * 20001128-tw Add module parm for default buffer order.
41 * added DMA_GFP flag to kmalloc dma buffer allocs.
42 * backfill silence to eliminate stuttering on
43 * underruns.
44 * 20001201-tw add resyncing of swptr on underruns.
45 * 20001205-tw-nf fixed GETOSPACE ioctl() after open()
46 *
47 *
48 * Status:
49 * Playback/Capture supported from 8k-48k.
50 * 16Bit Signed LE & 8Bit Unsigned, with Mono or Stereo supported.
51 */
52
53 #include <linux/module.h>
54 #include <linux/version.h>
55 #include <linux/string.h>
56 #include <linux/ctype.h>
57 #include <linux/ioport.h>
58 #include <linux/sched.h>
59 #include <linux/delay.h>
60 #include <linux/sound.h>
61 #include <linux/malloc.h>
62 #include <linux/soundcard.h>
63 #include <linux/pci.h>
64 #ifdef CS46XX_PM
65 #include <linux/pm.h>
66 #endif
67 #include <asm/io.h>
68 #include <asm/dma.h>
69 #include <linux/init.h>
70 #include <linux/poll.h>
71 #include <linux/spinlock.h>
72 #include <linux/ac97_codec.h>
73 #include <linux/wrapper.h>
74 #include <asm/uaccess.h>
75 #include <asm/hardirq.h>
76
77 #include "cs461x.h"
78
79
80 /* MIDI buffer sizes */
81 #define CS_MIDIINBUF 500
82 #define CS_MIDIOUTBUF 500
83
84 #define ADC_RUNNING 1
85 #define DAC_RUNNING 2
86
87 #define CS_FMT_16BIT 1 /* These are fixed in fact */
88 #define CS_FMT_STEREO 2
89 #define CS_FMT_MASK 3
90
91 #define CS_TYPE_ADC 1
92 #define CS_TYPE_DAC 2
93 /*
94 * CS461x definitions
95 */
96
97 #define CS461X_BA0_SIZE 0x2000
98 #define CS461X_BA1_DATA0_SIZE 0x3000
99 #define CS461X_BA1_DATA1_SIZE 0x3800
100 #define CS461X_BA1_PRG_SIZE 0x7000
101 #define CS461X_BA1_REG_SIZE 0x0100
102
103 #define GOF_PER_SEC 200
104
105 #define CSDEBUG_INTERFACE 1
106 #define CSDEBUG 1
107 /*
108 * Turn on/off debugging compilation by using 1/0 respectively for CSDEBUG
109 *
110 *
111 * CSDEBUG is usual mode is set to 1, then use the
112 * cs_debuglevel and cs_debugmask to turn on or off debugging.
113 * Debug level of 1 has been defined to be kernel errors and info
114 * that should be printed on any released driver.
115 */
116 #if CSDEBUG
117 #define CS_DBGOUT(mask,level,x) if((cs_debuglevel >= (level)) && ((mask) & cs_debugmask)) {x;}
118 #else
119 #define CS_DBGOUT(mask,level,x)
120 #endif
121 /*
122 * cs_debugmask areas
123 */
124 #define CS_INIT 0x00000001 /* initialization and probe functions */
125 #define CS_ERROR 0x00000002 /* tmp debugging bit placeholder */
126 #define CS_INTERRUPT 0x00000004 /* interrupt handler (separate from all other) */
127 #define CS_FUNCTION 0x00000008 /* enter/leave functions */
128 #define CS_WAVE_WRITE 0x00000010 /* write information for wave */
129 #define CS_WAVE_READ 0x00000020 /* read information for wave */
130 #define CS_MIDI_WRITE 0x00000040 /* write information for midi */
131 #define CS_MIDI_READ 0x00000080 /* read information for midi */
132 #define CS_MPU401_WRITE 0x00000100 /* write information for mpu401 */
133 #define CS_MPU401_READ 0x00000200 /* read information for mpu401 */
134 #define CS_OPEN 0x00000400 /* all open functions in the driver */
135 #define CS_RELEASE 0x00000800 /* all release functions in the driver */
136 #define CS_PARMS 0x00001000 /* functional and operational parameters */
137 #define CS_IOCTL 0x00002000 /* ioctl (non-mixer) */
138 #define CS_TMP 0x10000000 /* tmp debug mask bit */
139
140 #if CSDEBUG
141 static unsigned long cs_debuglevel=1; /* levels range from 1-9 */
142 static unsigned long cs_debugmask=CS_INIT | CS_ERROR; /* use CS_DBGOUT with various mask values */
143 #endif
144 #define DMABUF_DEFAULTORDER 3
145 static unsigned long defaultorder=DMABUF_DEFAULTORDER;
146 #if MODULE
147 MODULE_PARM(defaultorder, "i");
148 MODULE_PARM(cs_debuglevel, "i");
149 MODULE_PARM(cs_debugmask, "i");
150 #endif
151
152 static int external_amp = 0;
153 static int thinkpad = 0;
154
155
156 /* An instance of the 4610 channel */
157
158 struct cs_channel
159 {
160 int used;
161 int num;
162 void *state;
163 };
164
165 #define DRIVER_VERSION "1.10"
166
167 /* magic numbers to protect our data structures */
168 #define CS_CARD_MAGIC 0x43525553 /* "CRUS" */
169 #define CS_STATE_MAGIC 0x4c4f4749 /* "LOGI" */
170 #define NR_HW_CH 3
171
172 /* maxinum number of AC97 codecs connected, AC97 2.0 defined 4 */
173 #define NR_AC97 2
174
175 static const unsigned sample_size[] = { 1, 2, 2, 4 };
176 static const unsigned sample_shift[] = { 0, 1, 1, 2 };
177
178 /* "software" or virtual channel, an instance of opened /dev/dsp */
179 struct cs_state {
180 unsigned int magic;
181 struct cs_card *card; /* Card info */
182
183 /* single open lock mechanism, only used for recording */
184 struct semaphore open_sem;
185 wait_queue_head_t open_wait;
186
187 /* file mode */
188 mode_t open_mode;
189
190 /* virtual channel number */
191 int virt;
192
193 struct dmabuf {
194 /* wave sample stuff */
195 unsigned int rate;
196 unsigned char fmt, enable;
197
198 /* hardware channel */
199 struct cs_channel *channel;
200 int pringbuf; /* Software ring slot */
201 void *pbuf; /* 4K hardware DMA buffer */
202
203 /* OSS buffer management stuff */
204 void *rawbuf;
205 dma_addr_t dma_handle;
206 unsigned buforder;
207 unsigned numfrag;
208 unsigned fragshift;
209 unsigned divisor;
210 unsigned type;
211 void *tmpbuff; /* tmp buffer for sample conversions */
212 dma_addr_t dma_handle_tmpbuff;
213 unsigned buforder_tmpbuff; /* Log base 2 of size in bytes.. */
214
215 /* our buffer acts like a circular ring */
216 unsigned hwptr; /* where dma last started, updated by update_ptr */
217 unsigned swptr; /* where driver last clear/filled, updated by read/write */
218 int count; /* bytes to be comsumed or been generated by dma machine */
219 unsigned total_bytes; /* total bytes dmaed by hardware */
220 unsigned blocks; /* total blocks */
221
222 unsigned error; /* number of over/underruns */
223 unsigned underrun; /* underrun pending before next write has occurred */
224 wait_queue_head_t wait; /* put process on wait queue when no more space in buffer */
225
226 /* redundant, but makes calculations easier */
227 unsigned fragsize;
228 unsigned dmasize;
229 unsigned fragsamples;
230
231 /* OSS stuff */
232 unsigned mapped:1;
233 unsigned ready:1;
234 unsigned endcleared:1;
235 unsigned SGok:1;
236 unsigned update_flag;
237 unsigned ossfragshift;
238 int ossmaxfrags;
239 unsigned subdivision;
240 } dmabuf;
241 };
242
243
244 struct cs_card {
245 struct cs_channel channel[2];
246 unsigned int magic;
247
248 /* We keep cs461x cards in a linked list */
249 struct cs_card *next;
250
251 /* The cs461x has a certain amount of cross channel interaction
252 so we use a single per card lock */
253 spinlock_t lock;
254
255 /* PCI device stuff */
256 struct pci_dev * pci_dev;
257
258 unsigned int pctl, cctl; /* Hardware DMA flag sets */
259
260 /* soundcore stuff */
261 int dev_audio;
262 int dev_midi;
263
264 /* structures for abstraction of hardware facilities, codecs, banks and channels*/
265 struct ac97_codec *ac97_codec[NR_AC97];
266 struct cs_state *states[2];
267
268 u16 ac97_features;
269
270 int amplifier; /* Amplifier control */
271 void (*amplifier_ctrl)(struct cs_card *, int);
272
273 int active; /* Active clocking */
274 void (*active_ctrl)(struct cs_card *, int);
275
276 /* hardware resources */
277 unsigned long ba0_addr;
278 unsigned long ba1_addr;
279 u32 irq;
280
281 /* mappings */
282 void *ba0;
283 union
284 {
285 struct
286 {
287 u8 *data0;
288 u8 *data1;
289 u8 *pmem;
290 u8 *reg;
291 } name;
292 u8 *idx[4];
293 } ba1;
294
295 /* Function support */
296 struct cs_channel *(*alloc_pcm_channel)(struct cs_card *);
297 struct cs_channel *(*alloc_rec_pcm_channel)(struct cs_card *);
298 void (*free_pcm_channel)(struct cs_card *, int chan);
299
300 /* /dev/midi stuff */
301 struct {
302 unsigned ird, iwr, icnt;
303 unsigned ord, owr, ocnt;
304 wait_queue_head_t open_wait;
305 wait_queue_head_t iwait;
306 wait_queue_head_t owait;
307 spinlock_t lock;
308 unsigned char ibuf[CS_MIDIINBUF];
309 unsigned char obuf[CS_MIDIOUTBUF];
310 mode_t open_mode;
311 struct semaphore open_sem;
312 } midi;
313 };
314
315 static struct cs_card *devs = NULL;
316
317 static int cs_open_mixdev(struct inode *inode, struct file *file);
318 static int cs_release_mixdev(struct inode *inode, struct file *file);
319 static int cs_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd,
320 unsigned long arg);
321 static loff_t cs_llseek(struct file *file, loff_t offset, int origin);
322
323 extern __inline__ unsigned ld2(unsigned int x)
324 {
325 unsigned r = 0;
326
327 if (x >= 0x10000) {
328 x >>= 16;
329 r += 16;
330 }
331 if (x >= 0x100) {
332 x >>= 8;
333 r += 8;
334 }
335 if (x >= 0x10) {
336 x >>= 4;
337 r += 4;
338 }
339 if (x >= 4) {
340 x >>= 2;
341 r += 2;
342 }
343 if (x >= 2)
344 r++;
345 return r;
346 }
347
348 #if CSDEBUG
349
350 /* DEBUG ROUTINES */
351
352 #define SOUND_MIXER_CS_GETDBGLEVEL _SIOWR('M',120, int)
353 #define SOUND_MIXER_CS_SETDBGLEVEL _SIOWR('M',121, int)
354 #define SOUND_MIXER_CS_GETDBGMASK _SIOWR('M',122, int)
355 #define SOUND_MIXER_CS_SETDBGMASK _SIOWR('M',123, int)
356
357 #define SNDCTL_DSP_CS_GETDBGLEVEL _SIOWR('P', 50, int)
358 #define SNDCTL_DSP_CS_SETDBGLEVEL _SIOWR('P', 51, int)
359 #define SNDCTL_DSP_CS_GETDBGMASK _SIOWR('P', 52, int)
360 #define SNDCTL_DSP_CS_SETDBGMASK _SIOWR('P', 53, int)
361
362 static void printioctl(unsigned int x)
363 {
364 unsigned int i;
365 unsigned char vidx;
366 /* these values are incorrect for the ac97 driver, fix.
367 * Index of mixtable1[] member is Device ID
368 * and must be <= SOUND_MIXER_NRDEVICES.
369 * Value of array member is index into s->mix.vol[]
370 */
371 static const unsigned char mixtable1[SOUND_MIXER_NRDEVICES] = {
372 [SOUND_MIXER_PCM] = 1, /* voice */
373 [SOUND_MIXER_LINE1] = 2, /* AUX */
374 [SOUND_MIXER_CD] = 3, /* CD */
375 [SOUND_MIXER_LINE] = 4, /* Line */
376 [SOUND_MIXER_SYNTH] = 5, /* FM */
377 [SOUND_MIXER_MIC] = 6, /* Mic */
378 [SOUND_MIXER_SPEAKER] = 7, /* Speaker */
379 [SOUND_MIXER_RECLEV] = 8, /* Recording level */
380 [SOUND_MIXER_VOLUME] = 9 /* Master Volume */
381 };
382
383 switch(x)
384 {
385 case SOUND_MIXER_CS_GETDBGMASK:
386 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_GETDBGMASK: ") );
387 break;
388 case SOUND_MIXER_CS_GETDBGLEVEL:
389 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_GETDBGLEVEL: ") );
390 break;
391 case SOUND_MIXER_CS_SETDBGMASK:
392 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_SETDBGMASK: ") );
393 break;
394 case SOUND_MIXER_CS_SETDBGLEVEL:
395 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_SETDBGLEVEL: ") );
396 break;
397 case OSS_GETVERSION:
398 CS_DBGOUT(CS_IOCTL, 4, printk("OSS_GETVERSION: ") );
399 break;
400 case SNDCTL_DSP_SYNC:
401 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SYNC: ") );
402 break;
403 case SNDCTL_DSP_SETDUPLEX:
404 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETDUPLEX: ") );
405 break;
406 case SNDCTL_DSP_GETCAPS:
407 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETCAPS: ") );
408 break;
409 case SNDCTL_DSP_RESET:
410 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_RESET: ") );
411 break;
412 case SNDCTL_DSP_SPEED:
413 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SPEED: ") );
414 break;
415 case SNDCTL_DSP_STEREO:
416 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_STEREO: ") );
417 break;
418 case SNDCTL_DSP_CHANNELS:
419 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_CHANNELS: ") );
420 break;
421 case SNDCTL_DSP_GETFMTS:
422 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETFMTS: ") );
423 break;
424 case SNDCTL_DSP_SETFMT:
425 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETFMT: ") );
426 break;
427 case SNDCTL_DSP_POST:
428 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_POST: ") );
429 break;
430 case SNDCTL_DSP_GETTRIGGER:
431 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETTRIGGER: ") );
432 break;
433 case SNDCTL_DSP_SETTRIGGER:
434 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETTRIGGER: ") );
435 break;
436 case SNDCTL_DSP_GETOSPACE:
437 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETOSPACE: ") );
438 break;
439 case SNDCTL_DSP_GETISPACE:
440 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETISPACE: ") );
441 break;
442 case SNDCTL_DSP_NONBLOCK:
443 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_NONBLOCK: ") );
444 break;
445 case SNDCTL_DSP_GETODELAY:
446 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETODELAY: ") );
447 break;
448 case SNDCTL_DSP_GETIPTR:
449 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETIPTR: ") );
450 break;
451 case SNDCTL_DSP_GETOPTR:
452 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETOPTR: ") );
453 break;
454 case SNDCTL_DSP_GETBLKSIZE:
455 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETBLKSIZE: ") );
456 break;
457 case SNDCTL_DSP_SETFRAGMENT:
458 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETFRAGMENT: ") );
459 break;
460 case SNDCTL_DSP_SUBDIVIDE:
461 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SUBDIVIDE: ") );
462 break;
463 case SOUND_PCM_READ_RATE:
464 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_RATE: ") );
465 break;
466 case SOUND_PCM_READ_CHANNELS:
467 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_CHANNELS: ") );
468 break;
469 case SOUND_PCM_READ_BITS:
470 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_BITS: ") );
471 break;
472 case SOUND_PCM_WRITE_FILTER:
473 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_WRITE_FILTER: ") );
474 break;
475 case SNDCTL_DSP_SETSYNCRO:
476 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETSYNCRO: ") );
477 break;
478 case SOUND_PCM_READ_FILTER:
479 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_FILTER: ") );
480 break;
481 case SNDCTL_DSP_CS_GETDBGMASK:
482 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_CS_GETDBGMASK: ") );
483 break;
484 case SNDCTL_DSP_CS_GETDBGLEVEL:
485 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_CS_GETDBGLEVEL: ") );
486 break;
487 case SNDCTL_DSP_CS_SETDBGMASK:
488 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_CS_SETDBGMASK: ") );
489 break;
490 case SNDCTL_DSP_CS_SETDBGLEVEL:
491 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_CS_SETDBGLEVEL: ") );
492 break;
493
494 case SOUND_MIXER_PRIVATE1:
495 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE1: ") );
496 break;
497 case SOUND_MIXER_PRIVATE2:
498 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE2: ") );
499 break;
500 case SOUND_MIXER_PRIVATE3:
501 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE3: ") );
502 break;
503 case SOUND_MIXER_PRIVATE4:
504 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE4: ") );
505 break;
506 case SOUND_MIXER_PRIVATE5:
507 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE5: ") );
508 break;
509 case SOUND_MIXER_INFO:
510 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_INFO: ") );
511 break;
512 case SOUND_OLD_MIXER_INFO:
513 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_OLD_MIXER_INFO: ") );
514 break;
515
516 default:
517 switch (_IOC_NR(x))
518 {
519 case SOUND_MIXER_VOLUME:
520 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_VOLUME: ") );
521 break;
522 case SOUND_MIXER_SPEAKER:
523 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_SPEAKER: ") );
524 break;
525 case SOUND_MIXER_RECLEV:
526 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECLEV: ") );
527 break;
528 case SOUND_MIXER_MIC:
529 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_MIC: ") );
530 break;
531 case SOUND_MIXER_SYNTH:
532 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_SYNTH: ") );
533 break;
534 case SOUND_MIXER_RECSRC:
535 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECSRC: ") );
536 break;
537 case SOUND_MIXER_DEVMASK:
538 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_DEVMASK: ") );
539 break;
540 case SOUND_MIXER_RECMASK:
541 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECMASK: ") );
542 break;
543 case SOUND_MIXER_STEREODEVS:
544 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_STEREODEVS: ") );
545 break;
546 case SOUND_MIXER_CAPS:
547 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CAPS:") );
548 break;
549 default:
550 i = _IOC_NR(x);
551 if (i >= SOUND_MIXER_NRDEVICES || !(vidx = mixtable1[i]))
552 {
553 CS_DBGOUT(CS_IOCTL, 4, printk("UNKNOWN IOCTL: 0x%.8x NR=%d ",x,i) );
554 }
555 else
556 {
557 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_IOCTL AC9x: 0x%.8x NR=%d ",
558 x,i) );
559 }
560 break;
561 }
562 }
563 CS_DBGOUT(CS_IOCTL, 4, printk("command = 0x%x IOC_NR=%d\n",x, _IOC_NR(x)) );
564 }
565 #endif
566
567 /*
568 * common I/O routines
569 */
570
571 static void cs461x_poke(struct cs_card *codec, unsigned long reg, unsigned int val)
572 {
573 writel(val, codec->ba1.idx[(reg >> 16) & 3]+(reg&0xffff));
574 }
575
576 static unsigned int cs461x_peek(struct cs_card *codec, unsigned long reg)
577 {
578 return readl(codec->ba1.idx[(reg >> 16) & 3]+(reg&0xffff));
579 }
580
581 static void cs461x_pokeBA0(struct cs_card *codec, unsigned long reg, unsigned int val)
582 {
583 writel(val, codec->ba0+reg);
584 }
585
586 static unsigned int cs461x_peekBA0(struct cs_card *codec, unsigned long reg)
587 {
588 return readl(codec->ba0+reg);
589 }
590
591
592 static u16 cs_ac97_get(struct ac97_codec *dev, u8 reg);
593 static void cs_ac97_set(struct ac97_codec *dev, u8 reg, u16 data);
594
595 static struct cs_channel *cs_alloc_pcm_channel(struct cs_card *card)
596 {
597 if(card->channel[1].used==1)
598 return NULL;
599 card->channel[1].used=1;
600 card->channel[1].num=1;
601 return &card->channel[1];
602 }
603
604 static struct cs_channel *cs_alloc_rec_pcm_channel(struct cs_card *card)
605 {
606 if(card->channel[0].used==1)
607 return NULL;
608 card->channel[0].used=1;
609 card->channel[0].num=0;
610 return &card->channel[0];
611 }
612
613 static void cs_free_pcm_channel(struct cs_card *card, int channel)
614 {
615 card->channel[channel].state = NULL;
616 card->channel[channel].used=0;
617 }
618
619 /*
620 * setup a divisor value to help with conversion from
621 * 16bit Stereo, down to 8bit stereo/mono or 16bit mono.
622 * assign a divisor of 1 if using 16bit Stereo as that is
623 * the only format that the static image will capture.
624 */
625 static void cs_set_divisor(struct dmabuf *dmabuf)
626 {
627 if(dmabuf->type == CS_TYPE_DAC)
628 dmabuf->divisor = 1;
629 else if( !(dmabuf->fmt & CS_FMT_STEREO) &&
630 (dmabuf->fmt & CS_FMT_16BIT))
631 dmabuf->divisor = 2;
632 else if( (dmabuf->fmt & CS_FMT_STEREO) &&
633 !(dmabuf->fmt & CS_FMT_16BIT))
634 dmabuf->divisor = 2;
635 else if( !(dmabuf->fmt & CS_FMT_STEREO) &&
636 !(dmabuf->fmt & CS_FMT_16BIT))
637 dmabuf->divisor = 4;
638 else
639 dmabuf->divisor = 1;
640
641 CS_DBGOUT(CS_PARMS | CS_FUNCTION, 8, printk(
642 "cs46xx: cs_set_divisor()- %s %d\n",
643 (dmabuf->type == CS_TYPE_ADC) ? "ADC" : "DAC",
644 dmabuf->divisor) );
645 }
646
647 /* set playback sample rate */
648 static unsigned int cs_set_dac_rate(struct cs_state * state, unsigned int rate)
649 {
650 struct dmabuf *dmabuf = &state->dmabuf;
651 unsigned int tmp1, tmp2;
652 unsigned int phiIncr;
653 unsigned int correctionPerGOF, correctionPerSec;
654 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_dac_rate()+ %d\n",rate) );
655
656 /*
657 * Compute the values used to drive the actual sample rate conversion.
658 * The following formulas are being computed, using inline assembly
659 * since we need to use 64 bit arithmetic to compute the values:
660 *
661 * phiIncr = floor((Fs,in * 2^26) / Fs,out)
662 * correctionPerGOF = floor((Fs,in * 2^26 - Fs,out * phiIncr) /
663 * GOF_PER_SEC)
664 * ulCorrectionPerSec = Fs,in * 2^26 - Fs,out * phiIncr -M
665 * GOF_PER_SEC * correctionPerGOF
666 *
667 * i.e.
668 *
669 * phiIncr:other = dividend:remainder((Fs,in * 2^26) / Fs,out)
670 * correctionPerGOF:correctionPerSec =
671 * dividend:remainder(ulOther / GOF_PER_SEC)
672 */
673 tmp1 = rate << 16;
674 phiIncr = tmp1 / 48000;
675 tmp1 -= phiIncr * 48000;
676 tmp1 <<= 10;
677 phiIncr <<= 10;
678 tmp2 = tmp1 / 48000;
679 phiIncr += tmp2;
680 tmp1 -= tmp2 * 48000;
681 correctionPerGOF = tmp1 / GOF_PER_SEC;
682 tmp1 -= correctionPerGOF * GOF_PER_SEC;
683 correctionPerSec = tmp1;
684
685 /*
686 * Fill in the SampleRateConverter control block.
687 */
688
689 spin_lock_irq(&state->card->lock);
690 cs461x_poke(state->card, BA1_PSRC,
691 ((correctionPerSec << 16) & 0xFFFF0000) | (correctionPerGOF & 0xFFFF));
692 cs461x_poke(state->card, BA1_PPI, phiIncr);
693 spin_unlock_irq(&state->card->lock);
694 dmabuf->rate = rate;
695
696 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_dac_rate()- %d\n",rate) );
697 return rate;
698 }
699
700 /* set recording sample rate */
701 static unsigned int cs_set_adc_rate(struct cs_state * state, unsigned int rate)
702 {
703 struct dmabuf *dmabuf = &state->dmabuf;
704 struct cs_card *card = state->card;
705 unsigned int phiIncr, coeffIncr, tmp1, tmp2;
706 unsigned int correctionPerGOF, correctionPerSec, initialDelay;
707 unsigned int frameGroupLength, cnt;
708 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_adc_rate()+ %d\n",rate) );
709
710 /*
711 * We can only decimate by up to a factor of 1/9th the hardware rate.
712 * Correct the value if an attempt is made to stray outside that limit.
713 */
714 if ((rate * 9) < 48000)
715 rate = 48000 / 9;
716
717 /*
718 * We can not capture at at rate greater than the Input Rate (48000).
719 * Return an error if an attempt is made to stray outside that limit.
720 */
721 if (rate > 48000)
722 rate = 48000;
723
724 /*
725 * Compute the values used to drive the actual sample rate conversion.
726 * The following formulas are being computed, using inline assembly
727 * since we need to use 64 bit arithmetic to compute the values:
728 *
729 * coeffIncr = -floor((Fs,out * 2^23) / Fs,in)
730 * phiIncr = floor((Fs,in * 2^26) / Fs,out)
731 * correctionPerGOF = floor((Fs,in * 2^26 - Fs,out * phiIncr) /
732 * GOF_PER_SEC)
733 * correctionPerSec = Fs,in * 2^26 - Fs,out * phiIncr -
734 * GOF_PER_SEC * correctionPerGOF
735 * initialDelay = ceil((24 * Fs,in) / Fs,out)
736 *
737 * i.e.
738 *
739 * coeffIncr = neg(dividend((Fs,out * 2^23) / Fs,in))
740 * phiIncr:ulOther = dividend:remainder((Fs,in * 2^26) / Fs,out)
741 * correctionPerGOF:correctionPerSec =
742 * dividend:remainder(ulOther / GOF_PER_SEC)
743 * initialDelay = dividend(((24 * Fs,in) + Fs,out - 1) / Fs,out)
744 */
745
746 tmp1 = rate << 16;
747 coeffIncr = tmp1 / 48000;
748 tmp1 -= coeffIncr * 48000;
749 tmp1 <<= 7;
750 coeffIncr <<= 7;
751 coeffIncr += tmp1 / 48000;
752 coeffIncr ^= 0xFFFFFFFF;
753 coeffIncr++;
754 tmp1 = 48000 << 16;
755 phiIncr = tmp1 / rate;
756 tmp1 -= phiIncr * rate;
757 tmp1 <<= 10;
758 phiIncr <<= 10;
759 tmp2 = tmp1 / rate;
760 phiIncr += tmp2;
761 tmp1 -= tmp2 * rate;
762 correctionPerGOF = tmp1 / GOF_PER_SEC;
763 tmp1 -= correctionPerGOF * GOF_PER_SEC;
764 correctionPerSec = tmp1;
765 initialDelay = ((48000 * 24) + rate - 1) / rate;
766
767 /*
768 * Fill in the VariDecimate control block.
769 */
770 spin_lock_irq(&card->lock);
771 cs461x_poke(card, BA1_CSRC,
772 ((correctionPerSec << 16) & 0xFFFF0000) | (correctionPerGOF & 0xFFFF));
773 cs461x_poke(card, BA1_CCI, coeffIncr);
774 cs461x_poke(card, BA1_CD,
775 (((BA1_VARIDEC_BUF_1 + (initialDelay << 2)) << 16) & 0xFFFF0000) | 0x80);
776 cs461x_poke(card, BA1_CPI, phiIncr);
777 spin_unlock_irq(&card->lock);
778
779 /*
780 * Figure out the frame group length for the write back task. Basically,
781 * this is just the factors of 24000 (2^6*3*5^3) that are not present in
782 * the output sample rate.
783 */
784 frameGroupLength = 1;
785 for (cnt = 2; cnt <= 64; cnt *= 2) {
786 if (((rate / cnt) * cnt) != rate)
787 frameGroupLength *= 2;
788 }
789 if (((rate / 3) * 3) != rate) {
790 frameGroupLength *= 3;
791 }
792 for (cnt = 5; cnt <= 125; cnt *= 5) {
793 if (((rate / cnt) * cnt) != rate)
794 frameGroupLength *= 5;
795 }
796
797 /*
798 * Fill in the WriteBack control block.
799 */
800 spin_lock_irq(&card->lock);
801 cs461x_poke(card, BA1_CFG1, frameGroupLength);
802 cs461x_poke(card, BA1_CFG2, (0x00800000 | frameGroupLength));
803 cs461x_poke(card, BA1_CCST, 0x0000FFFF);
804 cs461x_poke(card, BA1_CSPB, ((65536 * rate) / 24000));
805 cs461x_poke(card, (BA1_CSPB + 4), 0x0000FFFF);
806 spin_unlock_irq(&card->lock);
807 dmabuf->rate = rate;
808 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_adc_rate()- %d\n",rate) );
809 return rate;
810 }
811
812 /* prepare channel attributes for playback */
813 static void cs_play_setup(struct cs_state *state)
814 {
815 struct dmabuf *dmabuf = &state->dmabuf;
816 struct cs_card *card = state->card;
817 unsigned int tmp, Count, playFormat;
818
819 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_play_setup()+\n") );
820 cs461x_poke(card, BA1_PVOL, 0x80008000);
821 if(!dmabuf->SGok)
822 cs461x_poke(card, BA1_PBA, virt_to_bus(dmabuf->pbuf));
823
824 Count = 4;
825 playFormat=cs461x_peek(card, BA1_PFIE);
826 if ((dmabuf->fmt & CS_FMT_STEREO)) {
827 playFormat &= ~DMA_RQ_C2_AC_MONO_TO_STEREO;
828 Count *= 2;
829 }
830 else
831 playFormat |= DMA_RQ_C2_AC_MONO_TO_STEREO;
832
833 if ((dmabuf->fmt & CS_FMT_16BIT)) {
834 playFormat &= ~(DMA_RQ_C2_AC_8_TO_16_BIT
835 | DMA_RQ_C2_AC_SIGNED_CONVERT);
836 Count *= 2;
837 }
838 else
839 playFormat |= (DMA_RQ_C2_AC_8_TO_16_BIT
840 | DMA_RQ_C2_AC_SIGNED_CONVERT);
841
842 cs461x_poke(card, BA1_PFIE, playFormat);
843
844 tmp = cs461x_peek(card, BA1_PDTC);
845 tmp &= 0xfffffe00;
846 cs461x_poke(card, BA1_PDTC, tmp | --Count);
847
848 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_play_setup()-\n") );
849
850 }
851
852 struct InitStruct
853 {
854 u32 long off;
855 u32 long val;
856 } InitArray[] = { {0x00000040, 0x3fc0000f},
857 {0x0000004c, 0x04800000},
858
859 {0x000000b3, 0x00000780},
860 {0x000000b7, 0x00000000},
861 {0x000000bc, 0x07800000},
862
863 {0x000000cd, 0x00800000},
864 };
865
866 /*
867 * "SetCaptureSPValues()" -- Initialize record task values before each
868 * capture startup.
869 */
870 void SetCaptureSPValues(struct cs_card *card)
871 {
872 unsigned i, offset;
873 CS_DBGOUT(CS_FUNCTION, 8, printk("cs46xx: SetCaptureSPValues()+\n") );
874 for(i=0; i<sizeof(InitArray)/sizeof(struct InitStruct); i++)
875 {
876 offset = InitArray[i].off*4; /* 8bit to 32bit offset value */
877 cs461x_poke(card, offset, InitArray[i].val );
878 }
879 CS_DBGOUT(CS_FUNCTION, 8, printk("cs46xx: SetCaptureSPValues()-\n") );
880 }
881
882 /* prepare channel attributes for recording */
883 static void cs_rec_setup(struct cs_state *state)
884 {
885 struct cs_card *card = state->card;
886 struct dmabuf *dmabuf = &state->dmabuf;
887 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_rec_setup()+\n") );
888
889 SetCaptureSPValues(card);
890
891 /*
892 * set the attenuation to 0dB
893 */
894 cs461x_poke(card, BA1_CVOL, 0x80008000);
895
896 /*
897 * set the physical address of the capture buffer into the SP
898 */
899 cs461x_poke(card, BA1_CBA, virt_to_bus(dmabuf->rawbuf));
900
901 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_rec_setup()-\n") );
902 }
903
904
905 /* get current playback/recording dma buffer pointer (byte offset from LBA),
906 called with spinlock held! */
907
908 extern __inline__ unsigned cs_get_dma_addr(struct cs_state *state)
909 {
910 struct dmabuf *dmabuf = &state->dmabuf;
911 u32 offset;
912
913 if ( (!(dmabuf->enable & DAC_RUNNING)) &&
914 (!(dmabuf->enable & ADC_RUNNING) ) )
915 {
916 CS_DBGOUT(CS_ERROR, 2, printk(
917 "cs46xx: ERROR cs_get_dma_addr(): not enabled \n") );
918 return 0;
919 }
920
921 /*
922 * ganularity is byte boundry, good part.
923 */
924 if(dmabuf->enable & DAC_RUNNING)
925 {
926 offset = cs461x_peek(state->card, BA1_PBA);
927 }
928 else /* ADC_RUNNING must be set */
929 {
930 offset = cs461x_peek(state->card, BA1_CBA);
931 }
932 CS_DBGOUT(CS_PARMS | CS_FUNCTION, 9,
933 printk("cs46xx: cs_get_dma_addr() %d\n",offset) );
934 offset = (u32)bus_to_virt((unsigned long)offset) - (u32)dmabuf->rawbuf;
935 CS_DBGOUT(CS_PARMS | CS_FUNCTION, 8,
936 printk("cs46xx: cs_get_dma_addr()- %d\n",offset) );
937 return offset;
938 }
939
940 static void resync_dma_ptrs(struct cs_state *state)
941 {
942 struct dmabuf *dmabuf = &state->dmabuf;
943 int offset;
944
945 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: resync_dma_ptrs()+ \n") );
946 offset = 0;
947 dmabuf->hwptr=dmabuf->swptr = 0;
948 dmabuf->pringbuf = 0;
949 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: resync_dma_ptrs()- \n") );
950 }
951
952 /* Stop recording (lock held) */
953 extern __inline__ void __stop_adc(struct cs_state *state)
954 {
955 struct dmabuf *dmabuf = &state->dmabuf;
956 struct cs_card *card = state->card;
957 unsigned int tmp;
958
959 dmabuf->enable &= ~ADC_RUNNING;
960
961 tmp = cs461x_peek(card, BA1_CCTL);
962 tmp &= 0xFFFF0000;
963 cs461x_poke(card, BA1_CCTL, tmp );
964 }
965
966 static void stop_adc(struct cs_state *state)
967 {
968 unsigned long flags;
969
970 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_adc()+ \n") );
971 spin_lock_irqsave(&state->card->lock, flags);
972 __stop_adc(state);
973 spin_unlock_irqrestore(&state->card->lock, flags);
974 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_adc()- \n") );
975 }
976
977 static void start_adc(struct cs_state *state)
978 {
979 struct dmabuf *dmabuf = &state->dmabuf;
980 struct cs_card *card = state->card;
981 unsigned long flags;
982 unsigned int tmp;
983
984 spin_lock_irqsave(&card->lock, flags);
985 if (!(dmabuf->enable & ADC_RUNNING) &&
986 ((dmabuf->mapped || dmabuf->count < (signed)dmabuf->dmasize)
987 && dmabuf->ready))
988 {
989 dmabuf->enable |= ADC_RUNNING;
990 cs_set_divisor(dmabuf);
991 tmp = cs461x_peek(card, BA1_CCTL);
992 tmp &= 0xFFFF0000;
993 tmp |= card->cctl;
994 CS_DBGOUT(CS_FUNCTION, 2, printk(
995 "cs46xx: start_adc() poke 0x%x \n",tmp) );
996 cs461x_poke(card, BA1_CCTL, tmp);
997 }
998 spin_unlock_irqrestore(&card->lock, flags);
999 }
1000
1001 /* stop playback (lock held) */
1002 extern __inline__ void __stop_dac(struct cs_state *state)
1003 {
1004 struct dmabuf *dmabuf = &state->dmabuf;
1005 struct cs_card *card = state->card;
1006 unsigned int tmp;
1007
1008 dmabuf->enable &= ~DAC_RUNNING;
1009
1010 tmp=cs461x_peek(card, BA1_PCTL);
1011 tmp&=0xFFFF;
1012 cs461x_poke(card, BA1_PCTL, tmp);
1013 }
1014
1015 static void stop_dac(struct cs_state *state)
1016 {
1017 unsigned long flags;
1018
1019 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_dac()+ \n") );
1020 spin_lock_irqsave(&state->card->lock, flags);
1021 __stop_dac(state);
1022 spin_unlock_irqrestore(&state->card->lock, flags);
1023 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_dac()- \n") );
1024 }
1025
1026 static void start_dac(struct cs_state *state)
1027 {
1028 struct dmabuf *dmabuf = &state->dmabuf;
1029 struct cs_card *card = state->card;
1030 unsigned long flags;
1031 int tmp;
1032
1033 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: start_dac()+ \n") );
1034 spin_lock_irqsave(&card->lock, flags);
1035 if (!(dmabuf->enable & DAC_RUNNING) &&
1036 ((dmabuf->mapped || dmabuf->count > 0) && dmabuf->ready)) {
1037 dmabuf->enable |= DAC_RUNNING;
1038 tmp = cs461x_peek(card, BA1_PCTL);
1039 tmp &= 0xFFFF;
1040 tmp |= card->pctl;
1041 CS_DBGOUT(CS_PARMS, 6, printk(
1042 "cs46xx: start_dac() poke card=0x%.08x tmp=0x%.08x addr=0x%.08x \n",
1043 (unsigned)card, (unsigned)tmp,
1044 (unsigned)card->ba1.idx[(BA1_PCTL >> 16) & 3]+(BA1_PCTL&0xffff) ) );
1045 cs461x_poke(card, BA1_PCTL, tmp);
1046 }
1047 spin_unlock_irqrestore(&card->lock, flags);
1048 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: start_dac()- \n") );
1049 }
1050
1051 #define DMABUF_MINORDER 1
1052
1053 /*
1054 * allocate DMA buffer, playback and recording buffers are separate.
1055 */
1056 static int alloc_dmabuf(struct cs_state *state)
1057 {
1058 struct dmabuf *dmabuf = &state->dmabuf;
1059 void *rawbuf = NULL;
1060 void *tmpbuff = NULL;
1061 int order;
1062 struct page *page, *pend;
1063
1064 /* alloc as big a chunk as we can */
1065 for (order = defaultorder; order >= DMABUF_MINORDER; order--)
1066 if((rawbuf = (void *)__get_free_pages(GFP_KERNEL | GFP_DMA, order)))
1067 break;
1068
1069 if (!rawbuf)
1070 return -ENOMEM;
1071
1072 dmabuf->buforder = order;
1073 dmabuf->rawbuf = rawbuf;
1074
1075 /* now mark the pages as reserved; otherwise remap_page_range doesn't do what we want */
1076 pend = virt_to_page(rawbuf + (PAGE_SIZE << order) - 1);
1077 for (page = virt_to_page(rawbuf); page <= pend; page++)
1078 mem_map_reserve(page);
1079
1080 CS_DBGOUT(CS_PARMS, 9, printk("cs461x: allocated %ld (order = %d) bytes at %p\n",
1081 PAGE_SIZE << order, order, rawbuf) );
1082 /*
1083 * now the temp buffer for 16/8 conversions
1084 */
1085 for (order = defaultorder; order >= DMABUF_MINORDER; order--)
1086 if((tmpbuff = (void *)__get_free_pages(GFP_KERNEL | GFP_DMA, order)))
1087 break;
1088 if (!tmpbuff)
1089 return -ENOMEM;
1090 CS_DBGOUT(CS_PARMS, 9, printk("cs461x: allocated %ld (order = %d) bytes at %p\n",
1091 PAGE_SIZE << order, order, tmpbuff) );
1092
1093 dmabuf->tmpbuff = tmpbuff;
1094 dmabuf->buforder_tmpbuff = order;
1095
1096 /* now mark the pages as reserved; otherwise remap_page_range doesn't do what we want */
1097 pend = virt_to_page(tmpbuff + (PAGE_SIZE << order) - 1);
1098 for (page = virt_to_page(tmpbuff); page <= pend; page++)
1099 mem_map_reserve(page);
1100
1101 CS_DBGOUT(CS_PARMS, 9, printk("cs461x: allocated %ld (order = %d) bytes at %p\n",
1102 PAGE_SIZE << order, order, tmpbuff) );
1103
1104 dmabuf->ready = dmabuf->mapped = 0;
1105 dmabuf->SGok = 0;
1106 return 0;
1107 }
1108
1109 /* free DMA buffer */
1110 static void dealloc_dmabuf(struct cs_state *state)
1111 {
1112 struct dmabuf *dmabuf = &state->dmabuf;
1113 struct page *page, *pend;
1114
1115 if (dmabuf->rawbuf) {
1116 pend = virt_to_page(dmabuf->rawbuf + (PAGE_SIZE << dmabuf->buforder) - 1);
1117 for (page = virt_to_page(dmabuf->rawbuf); page <= pend; page++)
1118 mem_map_unreserve(page);
1119 pci_free_consistent(state->card->pci_dev, PAGE_SIZE << dmabuf->buforder,
1120 dmabuf->rawbuf, dmabuf->dma_handle);
1121 }
1122 dmabuf->rawbuf = NULL;
1123
1124 if (dmabuf->tmpbuff) {
1125 /* undo marking the pages as reserved */
1126 pend = virt_to_page(dmabuf->tmpbuff + (PAGE_SIZE << dmabuf->buforder_tmpbuff) - 1);
1127 for (page = virt_to_page(dmabuf->tmpbuff); page <= pend; page++)
1128 mem_map_unreserve(page);
1129 pci_free_consistent(state->card->pci_dev, PAGE_SIZE << dmabuf->buforder_tmpbuff,
1130 dmabuf->tmpbuff, dmabuf->dma_handle_tmpbuff);
1131 }
1132
1133 dmabuf->rawbuf = NULL;
1134 dmabuf->tmpbuff = NULL;
1135 dmabuf->mapped = dmabuf->ready = 0;
1136 dmabuf->SGok = 0;
1137 }
1138
1139 static int prog_dmabuf(struct cs_state *state)
1140 {
1141 struct dmabuf *dmabuf = &state->dmabuf;
1142 unsigned long flags;
1143 unsigned long allocated_pages, allocated_bytes;
1144 unsigned long tmp1, tmp2, fmt=0;
1145 unsigned long *ptmp = (unsigned long *) dmabuf->pbuf;
1146 unsigned long SGarray[9], nSGpages=0;
1147 int ret;
1148
1149 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()+ \n"));
1150 /*
1151 * check for CAPTURE and use only non-sg for initial release
1152 */
1153 if(dmabuf->type == CS_TYPE_ADC)
1154 {
1155 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf() ADC\n"));
1156 /*
1157 * add in non-sg support for capture.
1158 */
1159 spin_lock_irqsave(&state->card->lock, flags);
1160 /* add code to reset the rawbuf memory. TRW */
1161 resync_dma_ptrs(state);
1162 dmabuf->total_bytes = dmabuf->blocks = 0;
1163 dmabuf->count = dmabuf->error = dmabuf->underrun = 0;
1164
1165 dmabuf->SGok = 0;
1166
1167 spin_unlock_irqrestore(&state->card->lock, flags);
1168
1169 /* allocate DMA buffer if not allocated yet */
1170 if (!dmabuf->rawbuf || !dmabuf->tmpbuff)
1171 if ((ret = alloc_dmabuf(state)))
1172 return ret;
1173 /*
1174 * static image only supports 16Bit signed, stereo - hard code fmt
1175 */
1176 fmt = CS_FMT_16BIT | CS_FMT_STEREO;
1177
1178 dmabuf->numfrag = 2;
1179 dmabuf->fragsize = 2048;
1180 dmabuf->fragsamples = 2048 >> sample_shift[fmt];
1181 dmabuf->dmasize = 4096;
1182 dmabuf->fragshift = 11;
1183
1184 memset(dmabuf->rawbuf, (fmt & CS_FMT_16BIT) ? 0 : 0x80,
1185 dmabuf->dmasize);
1186 memset(dmabuf->tmpbuff, (fmt & CS_FMT_16BIT) ? 0 : 0x80,
1187 PAGE_SIZE<<dmabuf->buforder_tmpbuff);
1188
1189 /*
1190 * Now set up the ring
1191 */
1192
1193 spin_lock_irqsave(&state->card->lock, flags);
1194 cs_rec_setup(state);
1195 spin_unlock_irqrestore(&state->card->lock, flags);
1196
1197 /* set the ready flag for the dma buffer */
1198 dmabuf->ready = 1;
1199
1200 CS_DBGOUT(CS_PARMS, 4, printk(
1201 "cs461x: prog_dmabuf(): CAPTURE rate=%d fmt=0x%x numfrag=%d "
1202 "fragsize=%d dmasize=%d\n",
1203 dmabuf->rate, dmabuf->fmt, dmabuf->numfrag,
1204 dmabuf->fragsize, dmabuf->dmasize) );
1205
1206 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- 0 \n"));
1207 return 0;
1208 }
1209 else if (dmabuf->type == CS_TYPE_DAC)
1210 {
1211 /*
1212 * Must be DAC
1213 */
1214 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf() DAC\n"));
1215 spin_lock_irqsave(&state->card->lock, flags);
1216 resync_dma_ptrs(state);
1217 dmabuf->total_bytes = dmabuf->blocks = 0;
1218 dmabuf->count = dmabuf->error = dmabuf->underrun = 0;
1219
1220 dmabuf->SGok = 0;
1221
1222 spin_unlock_irqrestore(&state->card->lock, flags);
1223
1224 /* allocate DMA buffer if not allocated yet */
1225 if (!dmabuf->rawbuf)
1226 if ((ret = alloc_dmabuf(state)))
1227 return ret;
1228
1229 allocated_pages = 1 << dmabuf->buforder;
1230 allocated_bytes = allocated_pages*PAGE_SIZE;
1231
1232 if(allocated_pages < 2)
1233 {
1234 CS_DBGOUT(CS_FUNCTION, 4, printk(
1235 "cs46xx: prog_dmabuf() Error: allocated_pages too small (%d)\n",
1236 (unsigned)allocated_pages));
1237 return -ENOMEM;
1238 }
1239
1240 /* Use all the pages allocated, fragsize 4k. */
1241 /* Use 'pbuf' for S/G page map table. */
1242 dmabuf->SGok = 1; /* Use S/G. */
1243
1244 nSGpages = allocated_bytes/4096; /* S/G pages always 4k. */
1245
1246 /* Set up S/G variables. */
1247 *ptmp = virt_to_bus(dmabuf->rawbuf);
1248 *(ptmp+1) = 0x00000008;
1249 for(tmp1= 1; tmp1 < nSGpages; tmp1++) {
1250 *(ptmp+2*tmp1) = virt_to_bus( (dmabuf->rawbuf)+4096*tmp1);
1251 if( tmp1 == nSGpages-1)
1252 tmp2 = 0xbfff0000;
1253 else
1254 tmp2 = 0x80000000+8*(tmp1+1);
1255 *(ptmp+2*tmp1+1) = tmp2;
1256 }
1257 SGarray[0] = 0x82c0200d;
1258 SGarray[1] = 0xffff0000;
1259 SGarray[2] = *ptmp;
1260 SGarray[3] = 0x00010600;
1261 SGarray[4] = *(ptmp+2);
1262 SGarray[5] = 0x80000010;
1263 SGarray[6] = *ptmp;
1264 SGarray[7] = *(ptmp+2);
1265 SGarray[8] = (virt_to_bus(dmabuf->pbuf) & 0xffff000) | 0x10;
1266
1267 if (dmabuf->SGok) {
1268 dmabuf->numfrag = nSGpages;
1269 dmabuf->fragsize = 4096;
1270 dmabuf->fragsamples = 4096 >> sample_shift[dmabuf->fmt];
1271 dmabuf->fragshift = 12;
1272 dmabuf->dmasize = dmabuf->numfrag*4096;
1273 }
1274 else {
1275 SGarray[0] = 0xf2c0000f;
1276 SGarray[1] = 0x00000200;
1277 SGarray[2] = 0;
1278 SGarray[3] = 0x00010600;
1279 SGarray[4]=SGarray[5]=SGarray[6]=SGarray[7]=SGarray[8] = 0;
1280 dmabuf->numfrag = 2;
1281 dmabuf->fragsize = 2048;
1282 dmabuf->fragsamples = 2048 >> sample_shift[dmabuf->fmt];
1283 dmabuf->dmasize = 4096;
1284 dmabuf->fragshift = 11;
1285 }
1286 for(tmp1 = 0; tmp1 < sizeof(SGarray)/4; tmp1++)
1287 cs461x_poke( state->card, BA1_PDTC+tmp1*4, SGarray[tmp1]);
1288
1289 memset(dmabuf->rawbuf, (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
1290 dmabuf->dmasize);
1291
1292 /*
1293 * Now set up the ring
1294 */
1295
1296 spin_lock_irqsave(&state->card->lock, flags);
1297 cs_play_setup(state);
1298 spin_unlock_irqrestore(&state->card->lock, flags);
1299
1300 /* set the ready flag for the dma buffer */
1301 dmabuf->ready = 1;
1302
1303 CS_DBGOUT(CS_PARMS, 4, printk(
1304 "cs461x: prog_dmabuf(): PLAYBACK rate=%d fmt=0x%x numfrag=%d "
1305 "fragsize=%d dmasize=%d\n",
1306 dmabuf->rate, dmabuf->fmt, dmabuf->numfrag,
1307 dmabuf->fragsize, dmabuf->dmasize) );
1308
1309 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- \n"));
1310 return 0;
1311 }
1312 else
1313 {
1314 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- Invalid Type %d\n",
1315 dmabuf->type));
1316 }
1317 return 1;
1318 }
1319
1320 static void cs_clear_tail(struct cs_state *state)
1321 {
1322 }
1323
1324 static int drain_dac(struct cs_state *state, int nonblock)
1325 {
1326 DECLARE_WAITQUEUE(wait, current);
1327 struct dmabuf *dmabuf = &state->dmabuf;
1328 unsigned long flags;
1329 unsigned long tmo;
1330 int count;
1331
1332 if (dmabuf->mapped || !dmabuf->ready)
1333 return 0;
1334
1335 add_wait_queue(&dmabuf->wait, &wait);
1336 for (;;) {
1337 /* It seems that we have to set the current state to TASK_INTERRUPTIBLE
1338 every time to make the process really go to sleep */
1339 current->state = TASK_INTERRUPTIBLE;
1340
1341 spin_lock_irqsave(&state->card->lock, flags);
1342 count = dmabuf->count;
1343 spin_unlock_irqrestore(&state->card->lock, flags);
1344
1345 if (count <= 0)
1346 break;
1347
1348 if (signal_pending(current))
1349 break;
1350
1351 if (nonblock) {
1352 remove_wait_queue(&dmabuf->wait, &wait);
1353 current->state = TASK_RUNNING;
1354 return -EBUSY;
1355 }
1356
1357 tmo = (dmabuf->dmasize * HZ) / dmabuf->rate;
1358 tmo >>= sample_shift[dmabuf->fmt];
1359 tmo += (2048*HZ)/dmabuf->rate;
1360
1361 if (!schedule_timeout(tmo ? tmo : 1) && tmo){
1362 printk(KERN_ERR "cs461x: drain_dac, dma timeout? %d\n", count);
1363 break;
1364 }
1365 }
1366 remove_wait_queue(&dmabuf->wait, &wait);
1367 current->state = TASK_RUNNING;
1368 if (signal_pending(current))
1369 return -ERESTARTSYS;
1370
1371 return 0;
1372 }
1373
1374
1375 /* update buffer manangement pointers, especially, dmabuf->count and dmabuf->hwptr */
1376 static void cs_update_ptr(void)
1377 {
1378 struct cs_card *card=devs;
1379 struct cs_state *state;
1380 struct dmabuf *dmabuf;
1381 unsigned hwptr;
1382 int diff;
1383
1384 /* error handling and process wake up for ADC */
1385 state = card->states[0];
1386 if(state)
1387 {
1388 dmabuf = &state->dmabuf;
1389 if (dmabuf->enable & ADC_RUNNING) {
1390 /* update hardware pointer */
1391 hwptr = cs_get_dma_addr(state);
1392
1393 diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1394 CS_DBGOUT(CS_PARMS, 9, printk(
1395 "cs46xx: cs_update_ptr()+ ADC hwptr=%d diff=%d\n",
1396 hwptr,diff) );
1397 dmabuf->hwptr = hwptr;
1398 dmabuf->total_bytes += diff;
1399 dmabuf->count += diff;
1400 if (dmabuf->count > dmabuf->dmasize)
1401 dmabuf->count = dmabuf->dmasize;
1402
1403 if(dmabuf->mapped)
1404 {
1405 if (dmabuf->count >= (signed)dmabuf->fragsize)
1406 wake_up(&dmabuf->wait);
1407 } else
1408 {
1409 if (dmabuf->count > 0)
1410 wake_up(&dmabuf->wait);
1411 }
1412 }
1413 }
1414
1415 /*
1416 * Now the DAC
1417 */
1418 state = card->states[1];
1419 if(state)
1420 {
1421 dmabuf = &state->dmabuf;
1422 /* error handling and process wake up for DAC */
1423 if (dmabuf->enable & DAC_RUNNING) {
1424 /* update hardware pointer */
1425 hwptr = cs_get_dma_addr(state);
1426
1427 diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1428 CS_DBGOUT(CS_PARMS, 9, printk(
1429 "cs46xx: cs_update_ptr()+ DAC hwptr=%d diff=%d\n",
1430 hwptr,diff) );
1431 dmabuf->hwptr = hwptr;
1432 dmabuf->total_bytes += diff;
1433 if (dmabuf->mapped) {
1434 dmabuf->count += diff;
1435 if (dmabuf->count >= (signed)dmabuf->fragsize)
1436 wake_up(&dmabuf->wait);
1437 /*
1438 * other drivers use fragsize, but don't see any sense
1439 * in that, since dmasize is the buffer asked for
1440 * via mmap.
1441 */
1442 if( dmabuf->count > dmabuf->dmasize)
1443 dmabuf->count &= dmabuf->dmasize-1;
1444 } else {
1445 dmabuf->count -= diff;
1446 /*
1447 * backfill with silence and clear out the last
1448 * "diff" number of bytes.
1449 */
1450 if(hwptr >= diff)
1451 {
1452 memset(dmabuf->rawbuf + hwptr - diff,
1453 (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80, diff);
1454 }
1455 else
1456 {
1457 memset(dmabuf->rawbuf,
1458 (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
1459 (unsigned)hwptr);
1460 memset((void *)((unsigned)dmabuf->rawbuf +
1461 dmabuf->dmasize + hwptr - diff),
1462 (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
1463 diff - hwptr);
1464 }
1465
1466 if (dmabuf->count < 0 || dmabuf->count > dmabuf->dmasize) {
1467 CS_DBGOUT(CS_ERROR, 2, printk(
1468 "cs46xx: ERROR DAC count<0 or count > dmasize (%d)\n",
1469 dmabuf->count));
1470 /*
1471 * buffer underrun or buffer overrun, reset the
1472 * count of bytes written back to 0.
1473 */
1474 if(dmabuf->count < 0)
1475 dmabuf->underrun=1;
1476 dmabuf->count = 0;
1477 dmabuf->error++;
1478 }
1479 if (dmabuf->count < (signed)dmabuf->dmasize/2)
1480 wake_up(&dmabuf->wait);
1481 }
1482 }
1483 }
1484 }
1485
1486
1487 /* hold spinlock for the following! */
1488 static void cs_handle_midi(struct cs_card *card)
1489 {
1490 unsigned char ch;
1491 int wake;
1492 unsigned temp1;
1493
1494 wake = 0;
1495 while (!(cs461x_peekBA0(card, BA0_MIDSR) & MIDSR_RBE)) {
1496 ch = cs461x_peekBA0(card, BA0_MIDRP);
1497 if (card->midi.icnt < CS_MIDIINBUF) {
1498 card->midi.ibuf[card->midi.iwr] = ch;
1499 card->midi.iwr = (card->midi.iwr + 1) % CS_MIDIINBUF;
1500 card->midi.icnt++;
1501 }
1502 wake = 1;
1503 }
1504 if (wake)
1505 wake_up(&card->midi.iwait);
1506 wake = 0;
1507 while (!(cs461x_peekBA0(card, BA0_MIDSR) & MIDSR_TBF) && card->midi.ocnt > 0) {
1508 temp1 = ( card->midi.obuf[card->midi.ord] ) & 0x000000ff;
1509 cs461x_pokeBA0(card, BA0_MIDWP,temp1);
1510 card->midi.ord = (card->midi.ord + 1) % CS_MIDIOUTBUF;
1511 card->midi.ocnt--;
1512 if (card->midi.ocnt < CS_MIDIOUTBUF-16)
1513 wake = 1;
1514 }
1515 if (wake)
1516 wake_up(&card->midi.owait);
1517 }
1518
1519 static void cs_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1520 {
1521 struct cs_card *card = (struct cs_card *)dev_id;
1522 /* Single channel card */
1523 struct cs_state *recstate = card->channel[0].state;
1524 struct cs_state *playstate = card->channel[1].state;
1525 u32 status;
1526
1527 CS_DBGOUT(CS_INTERRUPT, 4, printk("cs46xx: cs_interrupt()+ \n"));
1528
1529 spin_lock(&card->lock);
1530
1531 status = cs461x_peekBA0(card, BA0_HISR);
1532
1533 if ((status & 0x7fffffff) == 0)
1534 {
1535 cs461x_pokeBA0(card, BA0_HICR, HICR_CHGM|HICR_IEV);
1536 spin_unlock(&card->lock);
1537 return;
1538 }
1539
1540 /*
1541 * check for playback or capture interrupt only
1542 */
1543 if( ((status & HISR_VC0) && playstate && playstate->dmabuf.ready) ||
1544 (((status & HISR_VC1) && recstate && recstate->dmabuf.ready)) )
1545 {
1546 CS_DBGOUT(CS_INTERRUPT, 8, printk(
1547 "cs46xx: cs_interrupt() interrupt bit(s) set (0x%x)\n",status));
1548 cs_update_ptr();
1549 }
1550
1551 if( status & HISR_MIDI )
1552 cs_handle_midi(card);
1553
1554 /* clear 'em */
1555 cs461x_pokeBA0(card, BA0_HICR, HICR_CHGM|HICR_IEV);
1556 spin_unlock(&card->lock);
1557 CS_DBGOUT(CS_INTERRUPT, 4, printk("cs46xx: cs_interrupt()- \n"));
1558 }
1559
1560
1561 /**********************************************************************/
1562
1563 static ssize_t cs_midi_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
1564 {
1565 struct cs_card *card = (struct cs_card *)file->private_data;
1566 ssize_t ret;
1567 unsigned long flags;
1568 unsigned ptr;
1569 int cnt;
1570
1571 if (ppos != &file->f_pos)
1572 return -ESPIPE;
1573 if (!access_ok(VERIFY_WRITE, buffer, count))
1574 return -EFAULT;
1575 ret = 0;
1576 while (count > 0) {
1577 spin_lock_irqsave(&card->lock, flags);
1578 ptr = card->midi.ird;
1579 cnt = CS_MIDIINBUF - ptr;
1580 if (card->midi.icnt < cnt)
1581 cnt = card->midi.icnt;
1582 spin_unlock_irqrestore(&card->lock, flags);
1583 if (cnt > count)
1584 cnt = count;
1585 if (cnt <= 0) {
1586 if (file->f_flags & O_NONBLOCK)
1587 return ret ? ret : -EAGAIN;
1588 interruptible_sleep_on(&card->midi.iwait);
1589 if (signal_pending(current))
1590 return ret ? ret : -ERESTARTSYS;
1591 continue;
1592 }
1593 if (copy_to_user(buffer, card->midi.ibuf + ptr, cnt))
1594 return ret ? ret : -EFAULT;
1595 ptr = (ptr + cnt) % CS_MIDIINBUF;
1596 spin_lock_irqsave(&card->lock, flags);
1597 card->midi.ird = ptr;
1598 card->midi.icnt -= cnt;
1599 spin_unlock_irqrestore(&card->lock, flags);
1600 count -= cnt;
1601 buffer += cnt;
1602 ret += cnt;
1603 }
1604 return ret;
1605 }
1606
1607
1608 static ssize_t cs_midi_write(struct file *file, const char *buffer, size_t count, loff_t *ppos)
1609 {
1610 struct cs_card *card = (struct cs_card *)file->private_data;
1611 ssize_t ret;
1612 unsigned long flags;
1613 unsigned ptr;
1614 int cnt;
1615
1616 if (ppos != &file->f_pos)
1617 return -ESPIPE;
1618 if (!access_ok(VERIFY_READ, buffer, count))
1619 return -EFAULT;
1620 ret = 0;
1621 while (count > 0) {
1622 spin_lock_irqsave(&card->lock, flags);
1623 ptr = card->midi.owr;
1624 cnt = CS_MIDIOUTBUF - ptr;
1625 if (card->midi.ocnt + cnt > CS_MIDIOUTBUF)
1626 cnt = CS_MIDIOUTBUF - card->midi.ocnt;
1627 if (cnt <= 0)
1628 cs_handle_midi(card);
1629 spin_unlock_irqrestore(&card->lock, flags);
1630 if (cnt > count)
1631 cnt = count;
1632 if (cnt <= 0) {
1633 if (file->f_flags & O_NONBLOCK)
1634 return ret ? ret : -EAGAIN;
1635 interruptible_sleep_on(&card->midi.owait);
1636 if (signal_pending(current))
1637 return ret ? ret : -ERESTARTSYS;
1638 continue;
1639 }
1640 if (copy_from_user(card->midi.obuf + ptr, buffer, cnt))
1641 return ret ? ret : -EFAULT;
1642 ptr = (ptr + cnt) % CS_MIDIOUTBUF;
1643 spin_lock_irqsave(&card->lock, flags);
1644 card->midi.owr = ptr;
1645 card->midi.ocnt += cnt;
1646 spin_unlock_irqrestore(&card->lock, flags);
1647 count -= cnt;
1648 buffer += cnt;
1649 ret += cnt;
1650 spin_lock_irqsave(&card->lock, flags);
1651 cs_handle_midi(card);
1652 spin_unlock_irqrestore(&card->lock, flags);
1653 }
1654 return ret;
1655 }
1656
1657
1658 static unsigned int cs_midi_poll(struct file *file, struct poll_table_struct *wait)
1659 {
1660 struct cs_card *card = (struct cs_card *)file->private_data;
1661 unsigned long flags;
1662 unsigned int mask = 0;
1663
1664 if (file->f_flags & FMODE_WRITE)
1665 poll_wait(file, &card->midi.owait, wait);
1666 if (file->f_flags & FMODE_READ)
1667 poll_wait(file, &card->midi.iwait, wait);
1668 spin_lock_irqsave(&card->lock, flags);
1669 if (file->f_flags & FMODE_READ) {
1670 if (card->midi.icnt > 0)
1671 mask |= POLLIN | POLLRDNORM;
1672 }
1673 if (file->f_flags & FMODE_WRITE) {
1674 if (card->midi.ocnt < CS_MIDIOUTBUF)
1675 mask |= POLLOUT | POLLWRNORM;
1676 }
1677 spin_unlock_irqrestore(&card->lock, flags);
1678 return mask;
1679 }
1680
1681
1682 static int cs_midi_open(struct inode *inode, struct file *file)
1683 {
1684 int minor = MINOR(inode->i_rdev);
1685 struct cs_card *card = devs;
1686 unsigned long flags;
1687 while (card && card->dev_midi != minor)
1688 card = card->next;
1689 if (!card)
1690 return -ENODEV;
1691 file->private_data = card;
1692 /* wait for device to become free */
1693 down(&card->midi.open_sem);
1694 while (card->midi.open_mode & file->f_mode) {
1695 if (file->f_flags & O_NONBLOCK) {
1696 up(&card->midi.open_sem);
1697 return -EBUSY;
1698 }
1699 up(&card->midi.open_sem);
1700 interruptible_sleep_on(&card->midi.open_wait);
1701 if (signal_pending(current))
1702 return -ERESTARTSYS;
1703 down(&card->midi.open_sem);
1704 }
1705 spin_lock_irqsave(&card->midi.lock, flags);
1706 if (!(card->midi.open_mode & (FMODE_READ | FMODE_WRITE))) {
1707 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
1708 card->midi.ord = card->midi.owr = card->midi.ocnt = 0;
1709 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
1710 cs461x_pokeBA0(card, BA0_MIDCR, 0x0000000f); /* Enable xmit, rcv. */
1711 cs461x_pokeBA0(card, BA0_HICR, HICR_IEV | HICR_CHGM); /* Enable interrupts */
1712 }
1713 if (file->f_mode & FMODE_READ) {
1714 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
1715 }
1716 if (file->f_mode & FMODE_WRITE) {
1717 card->midi.ord = card->midi.owr = card->midi.ocnt = 0;
1718 }
1719 spin_unlock_irqrestore(&card->midi.lock, flags);
1720 card->midi.open_mode |= (file->f_mode & (FMODE_READ | FMODE_WRITE));
1721 up(&card->midi.open_sem);
1722 MOD_INC_USE_COUNT;
1723 return 0;
1724 }
1725
1726
1727 static int cs_midi_release(struct inode *inode, struct file *file)
1728 {
1729 struct cs_card *card = (struct cs_card *)file->private_data;
1730 DECLARE_WAITQUEUE(wait, current);
1731 unsigned long flags;
1732 unsigned count, tmo;
1733
1734 if (file->f_mode & FMODE_WRITE) {
1735 current->state = TASK_INTERRUPTIBLE;
1736 add_wait_queue(&card->midi.owait, &wait);
1737 for (;;) {
1738 spin_lock_irqsave(&card->midi.lock, flags);
1739 count = card->midi.ocnt;
1740 spin_unlock_irqrestore(&card->midi.lock, flags);
1741 if (count <= 0)
1742 break;
1743 if (signal_pending(current))
1744 break;
1745 if (file->f_flags & O_NONBLOCK) {
1746 remove_wait_queue(&card->midi.owait, &wait);
1747 current->state = TASK_RUNNING;
1748 return -EBUSY;
1749 }
1750 tmo = (count * HZ) / 3100;
1751 if (!schedule_timeout(tmo ? : 1) && tmo)
1752 printk(KERN_DEBUG "cs46xx: midi timed out??\n");
1753 }
1754 remove_wait_queue(&card->midi.owait, &wait);
1755 current->state = TASK_RUNNING;
1756 }
1757 down(&card->midi.open_sem);
1758 card->midi.open_mode &= (~(file->f_mode & (FMODE_READ | FMODE_WRITE)));
1759 up(&card->midi.open_sem);
1760 wake_up(&card->midi.open_wait);
1761 MOD_DEC_USE_COUNT;
1762 return 0;
1763 }
1764
1765 /*
1766 * Midi file operations struct.
1767 */
1768 static /*const*/ struct file_operations cs_midi_fops = {
1769 llseek: cs_llseek,
1770 read: cs_midi_read,
1771 write: cs_midi_write,
1772 poll: cs_midi_poll,
1773 open: cs_midi_open,
1774 release: cs_midi_release,
1775 };
1776
1777 static loff_t cs_llseek(struct file *file, loff_t offset, int origin)
1778 {
1779 return -ESPIPE;
1780 }
1781
1782 /*
1783 *
1784 * CopySamples copies 16-bit stereo signed samples from the source to the
1785 * destination, possibly converting down to unsigned 8-bit and/or mono.
1786 * count specifies the number of output bytes to write.
1787 *
1788 * Arguments:
1789 *
1790 * dst - Pointer to a destination buffer.
1791 * src - Pointer to a source buffer
1792 * count - The number of bytes to copy into the destination buffer.
1793 * fmt - CS_FMT_16BIT and/or CS_FMT_STEREO bits
1794 * dmabuf - pointer to the dma buffer structure
1795 *
1796 * NOTES: only call this routine if the output desired is not 16 Signed Stereo
1797 *
1798 *
1799 */
1800 static void CopySamples(char *dst, char *src, int count, unsigned fmt,
1801 struct dmabuf *dmabuf)
1802 {
1803
1804 s32 s32AudioSample;
1805 s16 *psSrc=(s16 *)src;
1806 s16 *psDst=(s16 *)dst;
1807 u8 *pucDst=(u8 *)dst;
1808
1809 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs4281: CopySamples()+ ") );
1810 CS_DBGOUT(CS_WAVE_READ, 8, printk(KERN_INFO
1811 " dst=0x%x src=0x%x count=%d fmt=0x%x\n",
1812 (unsigned)dst,(unsigned)src,(unsigned)count,(unsigned)fmt) );
1813
1814 /*
1815 * See if the data should be output as 8-bit unsigned stereo.
1816 */
1817 if((fmt & CS_FMT_STEREO) && !(fmt & CS_FMT_16BIT))
1818 {
1819 /*
1820 * Convert each 16-bit signed stereo sample to 8-bit unsigned
1821 * stereo using rounding.
1822 */
1823 psSrc = (s16 *)src;
1824 count = count/2;
1825 while(count--)
1826 {
1827 *(pucDst++) = (u8)(((s16)(*psSrc++) + (s16)0x8000) >> 8);
1828 }
1829 }
1830 /*
1831 * See if the data should be output at 8-bit unsigned mono.
1832 */
1833 else if(!(fmt & CS_FMT_STEREO) && !(fmt & CS_FMT_16BIT))
1834 {
1835 /*
1836 * Convert each 16-bit signed stereo sample to 8-bit unsigned
1837 * mono using averaging and rounding.
1838 */
1839 psSrc = (s16 *)src;
1840 count = count/2;
1841 while(count--)
1842 {
1843 s32AudioSample = ((*psSrc)+(*(psSrc + 1)))/2 + (s32)0x80;
1844 if(s32AudioSample > 0x7fff)
1845 s32AudioSample = 0x7fff;
1846 *(pucDst++) = (u8)(((s16)s32AudioSample + (s16)0x8000) >> 8);
1847 psSrc += 2;
1848 }
1849 }
1850 /*
1851 * See if the data should be output at 16-bit signed mono.
1852 */
1853 else if(!(fmt & CS_FMT_STEREO) && (fmt & CS_FMT_16BIT))
1854 {
1855 /*
1856 * Convert each 16-bit signed stereo sample to 16-bit signed
1857 * mono using averaging.
1858 */
1859 psSrc = (s16 *)src;
1860 count = count/2;
1861 while(count--)
1862 {
1863 *(psDst++) = (s16)((*psSrc)+(*(psSrc + 1)))/2;
1864 psSrc += 2;
1865 }
1866 }
1867 }
1868
1869 /*
1870 * cs_copy_to_user()
1871 * replacement for the standard copy_to_user, to allow for a conversion from
1872 * 16 bit to 8 bit and from stereo to mono, if the record conversion is active.
1873 * The current CS46xx/CS4280 static image only records in 16bit unsigned Stereo,
1874 * so we convert from any of the other format combinations.
1875 */
1876 static unsigned cs_copy_to_user(
1877 struct cs_state *s,
1878 void *dest,
1879 void *hwsrc,
1880 unsigned cnt,
1881 unsigned *copied)
1882 {
1883 struct dmabuf *dmabuf = &s->dmabuf;
1884 void *src = hwsrc; /* default to the standard destination buffer addr */
1885
1886 CS_DBGOUT(CS_FUNCTION, 6, printk(KERN_INFO
1887 "cs_copy_to_user()+ fmt=0x%x cnt=%d dest=0x%.8x\n",
1888 dmabuf->fmt,(unsigned)cnt,(unsigned)dest) );
1889
1890 if(cnt > dmabuf->dmasize)
1891 {
1892 cnt = dmabuf->dmasize;
1893 }
1894 if(!cnt)
1895 {
1896 *copied = 0;
1897 return 0;
1898 }
1899 if(dmabuf->divisor != 1)
1900 {
1901 if(!dmabuf->tmpbuff)
1902 {
1903 *copied = cnt/dmabuf->divisor;
1904 return 0;
1905 }
1906
1907 CopySamples((char *)dmabuf->tmpbuff, (char *)hwsrc, cnt,
1908 dmabuf->fmt, dmabuf);
1909 src = dmabuf->tmpbuff;
1910 cnt = cnt/dmabuf->divisor;
1911 }
1912 if (copy_to_user(dest, src, cnt))
1913 {
1914 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_ERR
1915 "cs4281: cs_copy_to_user()- fault dest=0x%x src=0x%x cnt=%d\n",
1916 (unsigned)dest,(unsigned)src,cnt) );
1917 *copied = 0;
1918 return -EFAULT;
1919 }
1920 *copied = cnt;
1921 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO
1922 "cs4281: cs_copy_to_user()- copied bytes is %d \n",cnt) );
1923 return 0;
1924 }
1925
1926 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be copied to
1927 the user's buffer. it is filled by the dma machine and drained by this loop. */
1928 static ssize_t cs_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
1929 {
1930 struct cs_card *card=devs;
1931 struct cs_state *state;
1932 DECLARE_WAITQUEUE(wait, current);
1933 struct dmabuf *dmabuf;
1934 ssize_t ret = 0;
1935 unsigned long flags;
1936 unsigned swptr;
1937 int cnt;
1938 unsigned copied=0;
1939
1940 CS_DBGOUT(CS_WAVE_READ, 4, printk("cs461x: cs_read()+ %d\n",count) );
1941 state = (struct cs_state *)card->states[0];
1942 if(!state)
1943 return -ENODEV;
1944 dmabuf = &state->dmabuf;
1945
1946 if (ppos != &file->f_pos)
1947 return -ESPIPE;
1948 if (dmabuf->mapped)
1949 return -ENXIO;
1950 if (!dmabuf->ready && (ret = prog_dmabuf(state)))
1951 return ret;
1952 if (!access_ok(VERIFY_WRITE, buffer, count))
1953 return -EFAULT;
1954
1955 add_wait_queue(&state->dmabuf.wait, &wait);
1956 while (count > 0) {
1957 spin_lock_irqsave(&state->card->lock, flags);
1958 swptr = dmabuf->swptr;
1959 cnt = dmabuf->dmasize - swptr;
1960 if (dmabuf->count < cnt)
1961 cnt = dmabuf->count;
1962 if (cnt <= 0)
1963 __set_current_state(TASK_INTERRUPTIBLE);
1964 spin_unlock_irqrestore(&state->card->lock, flags);
1965
1966 if (cnt > (count * dmabuf->divisor))
1967 cnt = count * dmabuf->divisor;
1968 if (cnt <= 0) {
1969 /* buffer is empty, start the dma machine and wait for data to be
1970 recorded */
1971 start_adc(state);
1972 if (file->f_flags & O_NONBLOCK) {
1973 if (!ret) ret = -EAGAIN;
1974 break;
1975 }
1976 schedule();
1977 if (signal_pending(current)) {
1978 ret = ret ? ret : -ERESTARTSYS;
1979 break;
1980 }
1981 continue;
1982 }
1983
1984 CS_DBGOUT(CS_WAVE_READ, 2, printk(KERN_INFO
1985 "_read() copy_to cnt=%d count=%d ", cnt,count) );
1986 CS_DBGOUT(CS_WAVE_READ, 8, printk(KERN_INFO
1987 " .dmasize=%d .count=%d buffer=0x%.8x ret=%d\n",
1988 dmabuf->dmasize,dmabuf->count,(unsigned)buffer,ret) );
1989
1990 if (cs_copy_to_user(state, buffer,
1991 (void *)((unsigned)dmabuf->rawbuf + swptr), cnt, &copied))
1992 {
1993 if (!ret) ret = -EFAULT;
1994 break;
1995 }
1996 swptr = (swptr + cnt) % dmabuf->dmasize;
1997 spin_lock_irqsave(&card->lock, flags);
1998 dmabuf->swptr = swptr;
1999 dmabuf->count -= cnt;
2000 spin_unlock_irqrestore(&card->lock, flags);
2001 count -= copied;
2002 buffer += copied;
2003 ret += copied;
2004 start_adc(state);
2005 }
2006 remove_wait_queue(&state->dmabuf.wait, &wait);
2007 set_current_state(TASK_RUNNING);
2008 CS_DBGOUT(CS_WAVE_READ, 4, printk("cs461x: cs_read()- %d\n",ret) );
2009 return ret;
2010 }
2011
2012 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be dma to
2013 the soundcard. it is drained by the dma machine and filled by this loop. */
2014 static ssize_t cs_write(struct file *file, const char *buffer, size_t count, loff_t *ppos)
2015 {
2016 struct cs_card *card=devs;
2017 struct cs_state *state;
2018 DECLARE_WAITQUEUE(wait, current);
2019 struct dmabuf *dmabuf;
2020 ssize_t ret = 0;
2021 unsigned long flags;
2022 unsigned swptr;
2023 int cnt;
2024
2025 CS_DBGOUT(CS_WAVE_WRITE | CS_FUNCTION, 4,
2026 printk("cs461x: cs_write called, count = %d\n", count) );
2027 state = (struct cs_state *)card->states[1];
2028 if(!state)
2029 return -ENODEV;
2030 dmabuf = &state->dmabuf;
2031
2032 if (ppos != &file->f_pos)
2033 return -ESPIPE;
2034 if (dmabuf->mapped)
2035 return -ENXIO;
2036 if (!dmabuf->ready && (ret = prog_dmabuf(state)))
2037 return ret;
2038 if (!access_ok(VERIFY_READ, buffer, count))
2039 return -EFAULT;
2040 add_wait_queue(&state->dmabuf.wait, &wait);
2041 while (count > 0) {
2042 spin_lock_irqsave(&state->card->lock, flags);
2043 if (dmabuf->count < 0) {
2044 /* buffer underrun, we are recovering from sleep_on_timeout,
2045 resync hwptr and swptr */
2046 dmabuf->count = 0;
2047 dmabuf->swptr = dmabuf->hwptr;
2048 }
2049 if (dmabuf->underrun)
2050 {
2051 dmabuf->underrun = 0;
2052 dmabuf->hwptr = cs_get_dma_addr(state);
2053 dmabuf->swptr = dmabuf->hwptr;
2054 }
2055 swptr = dmabuf->swptr;
2056 cnt = dmabuf->dmasize - swptr;
2057 if (dmabuf->count + cnt > dmabuf->dmasize)
2058 cnt = dmabuf->dmasize - dmabuf->count;
2059 if (cnt <= 0)
2060 __set_current_state(TASK_INTERRUPTIBLE);
2061 spin_unlock_irqrestore(&state->card->lock, flags);
2062
2063 if (cnt > count)
2064 cnt = count;
2065 if (cnt <= 0) {
2066 /* buffer is full, start the dma machine and wait for data to be
2067 played */
2068 start_dac(state);
2069 if (file->f_flags & O_NONBLOCK) {
2070 if (!ret) ret = -EAGAIN;
2071 break;
2072 }
2073 schedule();
2074 if (signal_pending(current)) {
2075 ret = ret ? ret : -ERESTARTSYS;
2076 break;
2077 }
2078 continue;
2079 }
2080 if (copy_from_user(dmabuf->rawbuf + swptr, buffer, cnt)) {
2081 if (!ret) ret = -EFAULT;
2082 return ret;
2083 }
2084
2085 swptr = (swptr + cnt) % dmabuf->dmasize;
2086
2087 spin_lock_irqsave(&state->card->lock, flags);
2088 dmabuf->swptr = swptr;
2089 dmabuf->count += cnt;
2090 if(dmabuf->count > dmabuf->dmasize)
2091 {
2092 CS_DBGOUT(CS_WAVE_WRITE | CS_ERROR, 2, printk(
2093 "cs46xx: cs_write() d->count > dmasize - resetting\n"));
2094 dmabuf->count = dmabuf->dmasize;
2095 }
2096 dmabuf->endcleared = 0;
2097 spin_unlock_irqrestore(&state->card->lock, flags);
2098
2099 count -= cnt;
2100 buffer += cnt;
2101 ret += cnt;
2102 start_dac(state);
2103 }
2104 remove_wait_queue(&state->dmabuf.wait, &wait);
2105 set_current_state(TASK_RUNNING);
2106
2107 CS_DBGOUT(CS_WAVE_WRITE | CS_FUNCTION, 2,
2108 printk("cs46xx: cs_write()- ret=0x%x\n", ret) );
2109 return ret;
2110 }
2111
2112 static unsigned int cs_poll(struct file *file, struct poll_table_struct *wait)
2113 {
2114 struct cs_card *card = (struct cs_card *)file->private_data;
2115 struct dmabuf *dmabuf;
2116 struct cs_state *state;
2117
2118 unsigned long flags;
2119 unsigned int mask = 0;
2120
2121 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_poll()+ \n"));
2122 if (!(file->f_mode & (FMODE_WRITE | FMODE_READ)))
2123 {
2124 return -EINVAL;
2125 }
2126 if (file->f_mode & FMODE_WRITE)
2127 {
2128 state = card->states[1];
2129 if(state)
2130 {
2131 dmabuf = &state->dmabuf;
2132 poll_wait(file, &dmabuf->wait, wait);
2133 }
2134 }
2135 if (file->f_mode & FMODE_READ)
2136 {
2137 state = card->states[0];
2138 if(state)
2139 {
2140 dmabuf = &state->dmabuf;
2141 poll_wait(file, &dmabuf->wait, wait);
2142 }
2143 }
2144
2145 spin_lock_irqsave(&card->lock, flags);
2146 cs_update_ptr();
2147 if (file->f_mode & FMODE_READ) {
2148 state = card->states[0];
2149 if(state)
2150 {
2151 dmabuf = &state->dmabuf;
2152 if (dmabuf->count >= (signed)dmabuf->fragsize)
2153 mask |= POLLIN | POLLRDNORM;
2154 }
2155 }
2156 if (file->f_mode & FMODE_WRITE) {
2157 state = card->states[1];
2158 if(state)
2159 {
2160 dmabuf = &state->dmabuf;
2161 if (dmabuf->mapped) {
2162 if (dmabuf->count >= (signed)dmabuf->fragsize)
2163 mask |= POLLOUT | POLLWRNORM;
2164 } else {
2165 if ((signed)dmabuf->dmasize >= dmabuf->count
2166 + (signed)dmabuf->fragsize)
2167 mask |= POLLOUT | POLLWRNORM;
2168 }
2169 }
2170 }
2171 spin_unlock_irqrestore(&card->lock, flags);
2172
2173 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_poll()- \n"));
2174 return mask;
2175 }
2176
2177 /*
2178 * We let users mmap the ring buffer. Its not the real DMA buffer but
2179 * that side of the code is hidden in the IRQ handling. We do a software
2180 * emulation of DMA from a 64K or so buffer into a 2K FIFO.
2181 * (the hardware probably deserves a moan here but Crystal send me nice
2182 * toys ;)).
2183 */
2184
2185 static int cs_mmap(struct file *file, struct vm_area_struct *vma)
2186 {
2187 struct cs_card *card=devs;
2188 struct cs_state *state;
2189 struct dmabuf *dmabuf;
2190 int ret;
2191 unsigned long size;
2192
2193 CS_DBGOUT(CS_FUNCTION | CS_PARMS, 2, printk("cs46xx: cs_mmap()+ file=0x%x %s %s\n",
2194 (unsigned)file, vma->vm_flags & VM_WRITE ? "VM_WRITE" : "",
2195 vma->vm_flags & VM_READ ? "VM_READ" : "") );
2196
2197 if (vma->vm_flags & VM_WRITE) {
2198 state = card->states[1];
2199 if(state)
2200 {
2201 CS_DBGOUT(CS_OPEN, 2, printk(
2202 "cs46xx: cs_mmap() VM_WRITE - state TRUE prog_dmabuf DAC\n") );
2203 if ((ret = prog_dmabuf(state)) != 0)
2204 return ret;
2205 }
2206 } else if (vma->vm_flags & VM_READ) {
2207 state = card->states[0];
2208 if(state)
2209 {
2210 CS_DBGOUT(CS_OPEN, 2, printk(
2211 "cs46xx: cs_mmap() VM_READ - state TRUE prog_dmabuf ADC\n") );
2212 if ((ret = prog_dmabuf(state)) != 0)
2213 return ret;
2214 }
2215 } else {
2216 CS_DBGOUT(CS_ERROR, 2, printk(
2217 "cs46xx: cs_mmap() return -EINVAL\n") );
2218 return -EINVAL;
2219 }
2220
2221 /*
2222 * For now ONLY support playback, but seems like the only way to use
2223 * mmap() is to open an FD with RDWR, just read or just write access
2224 * does not function, get an error back from the kernel.
2225 * Also, QuakeIII opens with RDWR! So, there must be something
2226 * to needing read/write access mapping. So, allow read/write but
2227 * use the DAC only.
2228 */
2229 state = card->states[1];
2230 if(!(unsigned)state)
2231 return -EINVAL;
2232
2233 dmabuf = &state->dmabuf;
2234 if (vma->vm_pgoff != 0)
2235 return -EINVAL;
2236 size = vma->vm_end - vma->vm_start;
2237
2238 CS_DBGOUT(CS_PARMS, 2, printk("cs46xx: cs_mmap(): size=%d\n",(unsigned)size) );
2239
2240 if (size > (PAGE_SIZE << dmabuf->buforder))
2241 return -EINVAL;
2242 if (remap_page_range(vma->vm_start, virt_to_phys(dmabuf->rawbuf),
2243 size, vma->vm_page_prot))
2244 return -EAGAIN;
2245 dmabuf->mapped = 1;
2246
2247 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_mmap()-\n") );
2248 return 0;
2249 }
2250
2251 static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
2252 {
2253 struct cs_card *card = (struct cs_card *)file->private_data;
2254 struct cs_state *state;
2255 struct dmabuf *dmabuf=0;
2256 unsigned long flags;
2257 audio_buf_info abinfo;
2258 count_info cinfo;
2259 int val, valsave, mapped, ret;
2260
2261 state = (struct cs_state *)card->states[0];
2262 if(state)
2263 {
2264 dmabuf = &state->dmabuf;
2265 mapped = (file->f_mode & FMODE_READ) && dmabuf->mapped;
2266 }
2267 state = (struct cs_state *)card->states[1];
2268 if(state)
2269 {
2270 dmabuf = &state->dmabuf;
2271 mapped |= (file->f_mode & FMODE_WRITE) && dmabuf->mapped;
2272 }
2273
2274 #if CSDEBUG
2275 printioctl(cmd);
2276 #endif
2277
2278 switch (cmd)
2279 {
2280 case OSS_GETVERSION:
2281 return put_user(SOUND_VERSION, (int *)arg);
2282
2283 case SNDCTL_DSP_RESET:
2284 /* FIXME: spin_lock ? */
2285 if (file->f_mode & FMODE_WRITE) {
2286 state = (struct cs_state *)card->states[1];
2287 if(state)
2288 {
2289 dmabuf = &state->dmabuf;
2290 stop_dac(state);
2291 synchronize_irq();
2292 dmabuf->ready = 0;
2293 resync_dma_ptrs(state);
2294 dmabuf->swptr = dmabuf->hwptr = 0;
2295 dmabuf->count = dmabuf->total_bytes = 0;
2296 dmabuf->blocks = 0;
2297 dmabuf->SGok = 0;
2298 }
2299 }
2300 if (file->f_mode & FMODE_READ) {
2301 state = (struct cs_state *)card->states[0];
2302 if(state)
2303 {
2304 dmabuf = &state->dmabuf;
2305 stop_adc(state);
2306 synchronize_irq();
2307 resync_dma_ptrs(state);
2308 dmabuf->ready = 0;
2309 dmabuf->swptr = dmabuf->hwptr = 0;
2310 dmabuf->count = dmabuf->total_bytes = 0;
2311 dmabuf->blocks = 0;
2312 dmabuf->SGok = 0;
2313 }
2314 }
2315 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_RESET()-\n") );
2316 return 0;
2317
2318 case SNDCTL_DSP_SYNC:
2319 if (file->f_mode & FMODE_WRITE)
2320 return drain_dac(state, file->f_flags & O_NONBLOCK);
2321 return 0;
2322
2323 case SNDCTL_DSP_SPEED: /* set sample rate */
2324 if (get_user(val, (int *)arg))
2325 return -EFAULT;
2326 if (val >= 0) {
2327 if (file->f_mode & FMODE_READ) {
2328 state = (struct cs_state *)card->states[0];
2329 if(state)
2330 {
2331 dmabuf = &state->dmabuf;
2332 stop_adc(state);
2333 dmabuf->ready = 0;
2334 dmabuf->SGok = 0;
2335 cs_set_adc_rate(state, val);
2336 cs_set_divisor(dmabuf);
2337 }
2338 }
2339 if (file->f_mode & FMODE_WRITE) {
2340 state = (struct cs_state *)card->states[1];
2341 if(state)
2342 {
2343 dmabuf = &state->dmabuf;
2344 stop_dac(state);
2345 dmabuf->ready = 0;
2346 dmabuf->SGok = 0;
2347 cs_set_dac_rate(state, val);
2348 cs_set_divisor(dmabuf);
2349 }
2350 }
2351 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2352 "cs46xx: cs_ioctl() DSP_SPEED %s %s %d\n",
2353 file->f_mode & FMODE_WRITE ? "DAC" : "",
2354 file->f_mode & FMODE_READ ? "ADC" : "",
2355 dmabuf->rate ) );
2356 return put_user(dmabuf->rate, (int *)arg);
2357 }
2358 return put_user(0, (int *)arg);
2359
2360 case SNDCTL_DSP_STEREO: /* set stereo or mono channel */
2361 if (get_user(val, (int *)arg))
2362 return -EFAULT;
2363 if (file->f_mode & FMODE_WRITE) {
2364 state = (struct cs_state *)card->states[1];
2365 if(state)
2366 {
2367 dmabuf = &state->dmabuf;
2368 stop_dac(state);
2369 dmabuf->ready = 0;
2370 dmabuf->SGok = 0;
2371 if(val)
2372 dmabuf->fmt |= CS_FMT_STEREO;
2373 else
2374 dmabuf->fmt &= ~CS_FMT_STEREO;
2375 cs_set_divisor(dmabuf);
2376 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2377 "cs46xx: DSP_STEREO() DAC %s\n",
2378 (dmabuf->fmt & CS_FMT_STEREO) ?
2379 "STEREO":"MONO") );
2380 }
2381 }
2382 if (file->f_mode & FMODE_READ) {
2383 state = (struct cs_state *)card->states[0];
2384 if(state)
2385 {
2386 dmabuf = &state->dmabuf;
2387 stop_adc(state);
2388 dmabuf->ready = 0;
2389 dmabuf->SGok = 0;
2390 if(val)
2391 dmabuf->fmt |= CS_FMT_STEREO;
2392 else
2393 dmabuf->fmt &= ~CS_FMT_STEREO;
2394 cs_set_divisor(dmabuf);
2395 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2396 "cs46xx: DSP_STEREO() ADC %s\n",
2397 (dmabuf->fmt & CS_FMT_STEREO) ?
2398 "STEREO":"MONO") );
2399 }
2400 }
2401 return 0;
2402
2403 case SNDCTL_DSP_GETBLKSIZE:
2404 if (file->f_mode & FMODE_WRITE) {
2405 state = (struct cs_state *)card->states[1];
2406 if(state)
2407 {
2408 dmabuf = &state->dmabuf;
2409 if ((val = prog_dmabuf(state)))
2410 return val;
2411 return put_user(dmabuf->fragsize, (int *)arg);
2412 }
2413 }
2414 if (file->f_mode & FMODE_READ) {
2415 state = (struct cs_state *)card->states[0];
2416 if(state)
2417 {
2418 dmabuf = &state->dmabuf;
2419 if ((val = prog_dmabuf(state)))
2420 return val;
2421 return put_user(dmabuf->fragsize/dmabuf->divisor,
2422 (int *)arg);
2423 }
2424 }
2425 return put_user(0, (int *)arg);
2426
2427 case SNDCTL_DSP_GETFMTS: /* Returns a mask of supported sample format*/
2428 return put_user(AFMT_S16_LE | AFMT_U8, (int *)arg);
2429
2430 case SNDCTL_DSP_SETFMT: /* Select sample format */
2431 if (get_user(val, (int *)arg))
2432 return -EFAULT;
2433 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2434 "cs46xx: cs_ioctl() DSP_SETFMT %s %s %s %s\n",
2435 file->f_mode & FMODE_WRITE ? "DAC" : "",
2436 file->f_mode & FMODE_READ ? "ADC" : "",
2437 val == AFMT_S16_LE ? "16Bit Signed" : "",
2438 val == AFMT_U8 ? "8Bit Unsigned" : "") );
2439 valsave = val;
2440 if (val != AFMT_QUERY) {
2441 if(val==AFMT_S16_LE || val==AFMT_U8)
2442 {
2443 if (file->f_mode & FMODE_WRITE) {
2444 state = (struct cs_state *)card->states[1];
2445 if(state)
2446 {
2447 dmabuf = &state->dmabuf;
2448 stop_dac(state);
2449 dmabuf->ready = 0;
2450 dmabuf->SGok = 0;
2451 if(val==AFMT_S16_LE)
2452 dmabuf->fmt |= CS_FMT_16BIT;
2453 else
2454 dmabuf->fmt &= ~CS_FMT_16BIT;
2455 cs_set_divisor(dmabuf);
2456 if((ret = prog_dmabuf(state)))
2457 return ret;
2458 }
2459 }
2460 if (file->f_mode & FMODE_READ) {
2461 val = valsave;
2462 state = (struct cs_state *)card->states[0];
2463 if(state)
2464 {
2465 dmabuf = &state->dmabuf;
2466 stop_adc(state);
2467 dmabuf->ready = 0;
2468 dmabuf->SGok = 0;
2469 if(val==AFMT_S16_LE)
2470 dmabuf->fmt |= CS_FMT_16BIT;
2471 else
2472 dmabuf->fmt &= ~CS_FMT_16BIT;
2473 cs_set_divisor(dmabuf);
2474 if((ret = prog_dmabuf(state)))
2475 return ret;
2476 }
2477 }
2478 }
2479 else
2480 {
2481 CS_DBGOUT(CS_IOCTL | CS_ERROR, 2, printk(
2482 "cs46xx: DSP_SETFMT() Unsupported format (0x%x)\n",
2483 valsave) );
2484 }
2485 }
2486 else
2487 {
2488 if(file->f_mode & FMODE_WRITE)
2489 {
2490 state = (struct cs_state *)card->states[1];
2491 if(state)
2492 dmabuf = &state->dmabuf;
2493 }
2494 else if(file->f_mode & FMODE_READ)
2495 {
2496 state = (struct cs_state *)card->states[0];
2497 if(state)
2498 dmabuf = &state->dmabuf;
2499 }
2500 }
2501 if(dmabuf)
2502 {
2503 if(dmabuf->fmt & CS_FMT_16BIT)
2504 return put_user(AFMT_S16_LE, (int *)arg);
2505 else
2506 return put_user(AFMT_U8, (int *)arg);
2507 }
2508 return put_user(0, (int *)arg);
2509
2510 case SNDCTL_DSP_CHANNELS:
2511 if (get_user(val, (int *)arg))
2512 return -EFAULT;
2513 if (val != 0) {
2514 if (file->f_mode & FMODE_WRITE) {
2515 state = (struct cs_state *)card->states[1];
2516 if(state)
2517 {
2518 dmabuf = &state->dmabuf;
2519 stop_dac(state);
2520 dmabuf->ready = 0;
2521 dmabuf->SGok = 0;
2522 if(val>1)
2523 dmabuf->fmt |= CS_FMT_STEREO;
2524 else
2525 dmabuf->fmt &= ~CS_FMT_STEREO;
2526 cs_set_divisor(dmabuf);
2527 if (prog_dmabuf(state))
2528 return 0;
2529 }
2530 }
2531 if (file->f_mode & FMODE_READ) {
2532 state = (struct cs_state *)card->states[0];
2533 if(state)
2534 {
2535 dmabuf = &state->dmabuf;
2536 stop_adc(state);
2537 dmabuf->ready = 0;
2538 dmabuf->SGok = 0;
2539 if(val>1)
2540 dmabuf->fmt |= CS_FMT_STEREO;
2541 else
2542 dmabuf->fmt &= ~CS_FMT_STEREO;
2543 cs_set_divisor(dmabuf);
2544 if (prog_dmabuf(state))
2545 return 0;
2546 }
2547 }
2548 }
2549 return put_user((dmabuf->fmt & CS_FMT_STEREO) ? 2 : 1,
2550 (int *)arg);
2551
2552 case SNDCTL_DSP_POST:
2553 /*
2554 * There will be a longer than normal pause in the data.
2555 * so... do nothing, because there is nothing that we can do.
2556 */
2557 return 0;
2558
2559 case SNDCTL_DSP_SUBDIVIDE:
2560 if (file->f_mode & FMODE_WRITE) {
2561 state = (struct cs_state *)card->states[1];
2562 if(state)
2563 {
2564 dmabuf = &state->dmabuf;
2565 if (dmabuf->subdivision)
2566 return -EINVAL;
2567 if (get_user(val, (int *)arg))
2568 return -EFAULT;
2569 if (val != 1 && val != 2)
2570 return -EINVAL;
2571 dmabuf->subdivision = val;
2572 }
2573 }
2574 if (file->f_mode & FMODE_READ) {
2575 state = (struct cs_state *)card->states[0];
2576 if(state)
2577 {
2578 dmabuf = &state->dmabuf;
2579 if (dmabuf->subdivision)
2580 return -EINVAL;
2581 if (get_user(val, (int *)arg))
2582 return -EFAULT;
2583 if (val != 1 && val != 2)
2584 return -EINVAL;
2585 dmabuf->subdivision = val;
2586 }
2587 }
2588 return 0;
2589
2590 case SNDCTL_DSP_SETFRAGMENT:
2591 if (get_user(val, (int *)arg))
2592 return -EFAULT;
2593
2594 if (file->f_mode & FMODE_WRITE) {
2595 state = (struct cs_state *)card->states[1];
2596 if(state)
2597 {
2598 dmabuf = &state->dmabuf;
2599 dmabuf->ossfragshift = val & 0xffff;
2600 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2601 }
2602 }
2603 if (file->f_mode & FMODE_READ) {
2604 state = (struct cs_state *)card->states[0];
2605 if(state)
2606 {
2607 dmabuf = &state->dmabuf;
2608 dmabuf->ossfragshift = val & 0xffff;
2609 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2610 }
2611 }
2612 return 0;
2613
2614 case SNDCTL_DSP_GETOSPACE:
2615 state = (struct cs_state *)card->states[1];
2616 if(state)
2617 {
2618 dmabuf = &state->dmabuf;
2619 spin_lock_irqsave(&state->card->lock, flags);
2620 cs_update_ptr();
2621 abinfo.fragsize = dmabuf->fragsize;
2622 abinfo.fragstotal = dmabuf->numfrag;
2623 /*
2624 * for mmap we always have total space available
2625 */
2626 if (dmabuf->mapped)
2627 abinfo.bytes = dmabuf->dmasize;
2628 else
2629 abinfo.bytes = dmabuf->dmasize - dmabuf->count;
2630
2631 abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
2632 spin_unlock_irqrestore(&state->card->lock, flags);
2633 return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2634 }
2635 return -ENODEV;
2636
2637 case SNDCTL_DSP_GETISPACE:
2638 state = (struct cs_state *)card->states[0];
2639 if(state)
2640 {
2641 dmabuf = &state->dmabuf;
2642 spin_lock_irqsave(&state->card->lock, flags);
2643 cs_update_ptr();
2644 abinfo.fragsize = dmabuf->fragsize/dmabuf->divisor;
2645 abinfo.bytes = dmabuf->count/dmabuf->divisor;
2646 abinfo.fragstotal = dmabuf->numfrag;
2647 abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
2648 spin_unlock_irqrestore(&state->card->lock, flags);
2649 return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2650 }
2651 return -ENODEV;
2652
2653 case SNDCTL_DSP_NONBLOCK:
2654 file->f_flags |= O_NONBLOCK;
2655 return 0;
2656
2657 case SNDCTL_DSP_GETCAPS:
2658 return put_user(DSP_CAP_REALTIME|DSP_CAP_TRIGGER|DSP_CAP_MMAP,
2659 (int *)arg);
2660
2661 case SNDCTL_DSP_GETTRIGGER:
2662 val = 0;
2663 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_GETTRIGGER()+\n") );
2664 if (file->f_mode & FMODE_WRITE)
2665 {
2666 state = (struct cs_state *)card->states[1];
2667 if(state)
2668 {
2669 dmabuf = &state->dmabuf;
2670 if(dmabuf->enable & DAC_RUNNING)
2671 val |= PCM_ENABLE_INPUT;
2672 }
2673 }
2674 if (file->f_mode & FMODE_READ)
2675 {
2676 if(state)
2677 {
2678 state = (struct cs_state *)card->states[0];
2679 dmabuf = &state->dmabuf;
2680 if(dmabuf->enable & ADC_RUNNING)
2681 val |= PCM_ENABLE_OUTPUT;
2682 }
2683 }
2684 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_GETTRIGGER()- val=0x%x\n",val) );
2685 return put_user(val, (int *)arg);
2686
2687 case SNDCTL_DSP_SETTRIGGER:
2688 if (get_user(val, (int *)arg))
2689 return -EFAULT;
2690 if (file->f_mode & FMODE_READ) {
2691 state = (struct cs_state *)card->states[0];
2692 if(state)
2693 {
2694 dmabuf = &state->dmabuf;
2695 if (val & PCM_ENABLE_INPUT) {
2696 if (!dmabuf->ready && (ret = prog_dmabuf(state)))
2697 return ret;
2698 start_adc(state);
2699 } else
2700 stop_adc(state);
2701 }
2702 }
2703 if (file->f_mode & FMODE_WRITE) {
2704 state = (struct cs_state *)card->states[1];
2705 if(state)
2706 {
2707 dmabuf = &state->dmabuf;
2708 if (val & PCM_ENABLE_OUTPUT) {
2709 if (!dmabuf->ready && (ret = prog_dmabuf(state)))
2710 return ret;
2711 start_dac(state);
2712 } else
2713 stop_dac(state);
2714 }
2715 }
2716 return 0;
2717
2718 case SNDCTL_DSP_GETIPTR:
2719 state = (struct cs_state *)card->states[0];
2720 if(state)
2721 {
2722 dmabuf = &state->dmabuf;
2723 spin_lock_irqsave(&state->card->lock, flags);
2724 cs_update_ptr();
2725 cinfo.bytes = dmabuf->total_bytes/dmabuf->divisor;
2726 cinfo.blocks = dmabuf->count/dmabuf->divisor >> dmabuf->fragshift;
2727 cinfo.ptr = dmabuf->hwptr/dmabuf->divisor;
2728 spin_unlock_irqrestore(&state->card->lock, flags);
2729 return copy_to_user((void *)arg, &cinfo, sizeof(cinfo));
2730 }
2731 return -ENODEV;
2732
2733 case SNDCTL_DSP_GETOPTR:
2734 state = (struct cs_state *)card->states[1];
2735 if(state)
2736 {
2737 dmabuf = &state->dmabuf;
2738 spin_lock_irqsave(&state->card->lock, flags);
2739 cs_update_ptr();
2740 cinfo.bytes = dmabuf->total_bytes;
2741 if (dmabuf->mapped)
2742 {
2743 cinfo.blocks = (cinfo.bytes >> dmabuf->fragshift)
2744 - dmabuf->blocks;
2745 CS_DBGOUT(CS_PARMS, 8,
2746 printk("total_bytes=%d blocks=%d dmabuf->blocks=%d\n",
2747 cinfo.bytes,cinfo.blocks,dmabuf->blocks) );
2748 dmabuf->blocks = cinfo.bytes >> dmabuf->fragshift;
2749 }
2750 else
2751 {
2752 cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
2753 }
2754 cinfo.ptr = dmabuf->hwptr;
2755
2756 CS_DBGOUT(CS_PARMS, 4, printk(
2757 "cs46xx: GETOPTR bytes=%d blocks=%d ptr=%d\n",
2758 cinfo.bytes,cinfo.blocks,cinfo.ptr) );
2759 spin_unlock_irqrestore(&state->card->lock, flags);
2760 return copy_to_user((void *)arg, &cinfo, sizeof(cinfo));
2761 }
2762 return -ENODEV;
2763
2764 case SNDCTL_DSP_SETDUPLEX:
2765 return -EINVAL;
2766
2767 case SNDCTL_DSP_GETODELAY:
2768 if (!(file->f_mode & FMODE_WRITE))
2769 return -EINVAL;
2770 state = (struct cs_state *)card->states[1];
2771 if(state)
2772 {
2773 dmabuf = &state->dmabuf;
2774 spin_lock_irqsave(&state->card->lock, flags);
2775 cs_update_ptr();
2776 val = dmabuf->count;
2777 spin_unlock_irqrestore(&state->card->lock, flags);
2778 }
2779 else
2780 val = 0;
2781 return put_user(val, (int *)arg);
2782
2783 case SOUND_PCM_READ_RATE:
2784 state = (struct cs_state *)card->states[0];
2785 if(state)
2786 {
2787 dmabuf = &state->dmabuf;
2788 return put_user(dmabuf->rate, (int *)arg);
2789 }
2790 return put_user(0, (int *)arg);
2791
2792
2793 case SOUND_PCM_READ_CHANNELS:
2794 state = (struct cs_state *)card->states[0];
2795 if(state)
2796 {
2797 dmabuf = &state->dmabuf;
2798 return put_user((dmabuf->fmt & CS_FMT_STEREO) ? 2 : 1,
2799 (int *)arg);
2800 }
2801 return put_user(0, (int *)arg);
2802
2803 case SOUND_PCM_READ_BITS:
2804 state = (struct cs_state *)card->states[0];
2805 if(state)
2806 {
2807 dmabuf = &state->dmabuf;
2808 return put_user(AFMT_S16_LE | AFMT_U8, (int *)arg);
2809 }
2810 return put_user(0, (int *)arg);
2811
2812 case SNDCTL_DSP_MAPINBUF:
2813 case SNDCTL_DSP_MAPOUTBUF:
2814 case SNDCTL_DSP_SETSYNCRO:
2815 case SOUND_PCM_WRITE_FILTER:
2816 case SOUND_PCM_READ_FILTER:
2817 return -EINVAL;
2818 }
2819 return -EINVAL;
2820 }
2821
2822
2823 /*
2824 * AMP control - null AMP
2825 */
2826
2827 static void amp_none(struct cs_card *card, int change)
2828 {
2829 }
2830
2831 /*
2832 * Crystal EAPD mode
2833 */
2834
2835 static void amp_voyetra(struct cs_card *card, int change)
2836 {
2837 /* Manage the EAPD bit on the Crystal 4297
2838 and the Analog AD1885 */
2839
2840 int old=card->amplifier;
2841
2842 card->amplifier+=change;
2843 if(card->amplifier && !old)
2844 {
2845 /* Turn the EAPD amp on */
2846 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL,
2847 cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) |
2848 0x8000);
2849 }
2850 else if(old && !card->amplifier)
2851 {
2852 /* Turn the EAPD amp off */
2853 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL,
2854 cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
2855 ~0x8000);
2856 }
2857 }
2858
2859
2860
2861 /*
2862 * Untested
2863 */
2864
2865 static void amp_voyetra_4294(struct cs_card *card, int change)
2866 {
2867 struct ac97_codec *c=card->ac97_codec[0];
2868
2869 card->amplifier+=change;
2870
2871 if(card->amplifier)
2872 {
2873 /* Switch the GPIO pins 7 and 8 to open drain */
2874 cs_ac97_set(c, 0x4C, cs_ac97_get(c, 0x4C) & 0xFE7F);
2875 cs_ac97_set(c, 0x4E, cs_ac97_get(c, 0x4E) | 0x0180);
2876 /* Now wake the AMP (this might be backwards) */
2877 cs_ac97_set(c, 0x54, cs_ac97_get(c, 0x54) & ~0x0180);
2878 }
2879 else
2880 {
2881 cs_ac97_set(c, 0x54, cs_ac97_get(c, 0x54) | 0x0180);
2882 }
2883 }
2884
2885 /*
2886 * Handle the CLKRUN on a thinkpad. We must disable CLKRUN support
2887 * whenever we need to beat on the chip.
2888 *
2889 * The original idea and code for this hack comes from David Kaiser at
2890 * Linuxcare. Perhaps one day Crystal will document their chips well
2891 * enough to make them useful.
2892 */
2893
2894 static void clkrun_hack(struct cs_card *card, int change)
2895 {
2896 struct pci_dev *acpi_dev;
2897 u16 control;
2898 u8 pp;
2899 unsigned long port;
2900 int old=card->amplifier;
2901
2902 card->amplifier+=change;
2903
2904 acpi_dev = pci_find_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371AB_3, NULL);
2905 if(acpi_dev == NULL)
2906 return; /* Not a thinkpad thats for sure */
2907
2908 /* Find the control port */
2909 pci_read_config_byte(acpi_dev, 0x41, &pp);
2910 port=pp<<8;
2911
2912 /* Read ACPI port */
2913 control=inw(port+0x10);
2914
2915 /* Flip CLKRUN off while running */
2916 if(!card->amplifier && old)
2917 outw(control|0x2000, port+0x10);
2918 else if(card->amplifier && !old)
2919 outw(control&~0x2000, port+0x10);
2920 }
2921
2922
2923 static int cs_open(struct inode *inode, struct file *file)
2924 {
2925 struct cs_card *card = devs;
2926 struct cs_state *state = NULL;
2927 struct dmabuf *dmabuf = NULL;
2928 int ret=0;
2929
2930 CS_DBGOUT(CS_OPEN | CS_FUNCTION, 2, printk("cs46xx: cs_open()+ file=0x%x %s %s\n",
2931 (unsigned)file, file->f_mode & FMODE_WRITE ? "FMODE_WRITE" : "",
2932 file->f_mode & FMODE_READ ? "FMODE_READ" : "") );
2933
2934 /*
2935 * hardcode state[0] for capture, [1] for playback
2936 */
2937 if(file->f_mode & FMODE_READ)
2938 {
2939 CS_DBGOUT(CS_WAVE_READ, 2, printk("cs46xx: cs_open() FMODE_READ\n") );
2940 if (card->states[0] == NULL) {
2941 state = card->states[0] = (struct cs_state *)
2942 kmalloc(sizeof(struct cs_state), GFP_KERNEL);
2943 if (state == NULL)
2944 return -ENOMEM;
2945 memset(state, 0, sizeof(struct cs_state));
2946 dmabuf = &state->dmabuf;
2947 dmabuf->pbuf = (void *)get_free_page(GFP_KERNEL | GFP_DMA);
2948 if(dmabuf->pbuf==NULL)
2949 {
2950 kfree(state);
2951 card->states[0]=NULL;
2952 return -ENOMEM;
2953 }
2954 }
2955 else
2956 {
2957 state = card->states[0];
2958 if(state->open_mode & FMODE_READ)
2959 return -EBUSY;
2960 }
2961 dmabuf->channel = card->alloc_rec_pcm_channel(card);
2962
2963 if (dmabuf->channel == NULL) {
2964 kfree (card->states[0]);
2965 card->states[0] = NULL;;
2966 return -ENODEV;
2967 }
2968
2969 /* Now turn on external AMP if needed */
2970 state->card = card;
2971 state->card->active_ctrl(state->card,1);
2972 state->card->amplifier_ctrl(state->card,1);
2973
2974 dmabuf->channel->state = state;
2975 /* initialize the virtual channel */
2976 state->virt = 0;
2977 state->magic = CS_STATE_MAGIC;
2978 init_waitqueue_head(&dmabuf->wait);
2979 init_MUTEX(&state->open_sem);
2980 file->private_data = card;
2981
2982 down(&state->open_sem);
2983
2984 /* set default sample format. According to OSS Programmer's Guide /dev/dsp
2985 should be default to unsigned 8-bits, mono, with sample rate 8kHz and
2986 /dev/dspW will accept 16-bits sample */
2987
2988 /* Default input is 8bit mono */
2989 dmabuf->fmt &= ~CS_FMT_MASK;
2990 dmabuf->type = CS_TYPE_ADC;
2991 dmabuf->ossfragshift = 0;
2992 dmabuf->ossmaxfrags = 0;
2993 dmabuf->subdivision = 0;
2994 cs_set_adc_rate(state, 8000);
2995 cs_set_divisor(dmabuf);
2996
2997 state->open_mode |= FMODE_READ;
2998 up(&state->open_sem);
2999 MOD_INC_USE_COUNT;
3000 }
3001 if(file->f_mode & FMODE_WRITE)
3002 {
3003 CS_DBGOUT(CS_OPEN, 2, printk("cs46xx: cs_open() FMODE_WRITE\n") );
3004 if (card->states[1] == NULL) {
3005 state = card->states[1] = (struct cs_state *)
3006 kmalloc(sizeof(struct cs_state), GFP_KERNEL);
3007 if (state == NULL)
3008 return -ENOMEM;
3009 memset(state, 0, sizeof(struct cs_state));
3010 dmabuf = &state->dmabuf;
3011 dmabuf->pbuf = (void *)get_free_page(GFP_KERNEL | GFP_DMA);
3012 if(dmabuf->pbuf==NULL)
3013 {
3014 kfree(state);
3015 card->states[1]=NULL;
3016 return -ENOMEM;
3017 }
3018 }
3019 else
3020 {
3021 state = card->states[1];
3022 if(state->open_mode & FMODE_WRITE)
3023 return -EBUSY;
3024 }
3025 dmabuf->channel = card->alloc_pcm_channel(card);
3026
3027 if (dmabuf->channel == NULL) {
3028 kfree (card->states[1]);
3029 card->states[1] = NULL;;
3030 return -ENODEV;
3031 }
3032
3033 /* Now turn on external AMP if needed */
3034 state->card = card;
3035 state->card->active_ctrl(state->card,1);
3036 state->card->amplifier_ctrl(state->card,1);
3037
3038 dmabuf->channel->state = state;
3039 /* initialize the virtual channel */
3040 state->virt = 1;
3041 state->magic = CS_STATE_MAGIC;
3042 init_waitqueue_head(&dmabuf->wait);
3043 init_MUTEX(&state->open_sem);
3044 file->private_data = card;
3045
3046 down(&state->open_sem);
3047
3048 /* set default sample format. According to OSS Programmer's Guide /dev/dsp
3049 should be default to unsigned 8-bits, mono, with sample rate 8kHz and
3050 /dev/dspW will accept 16-bits sample */
3051
3052 /* Default output is 8bit mono. */
3053 dmabuf->fmt &= ~CS_FMT_MASK;
3054 dmabuf->type = CS_TYPE_DAC;
3055 dmabuf->ossfragshift = 0;
3056 dmabuf->ossmaxfrags = 0;
3057 dmabuf->subdivision = 0;
3058 cs_set_dac_rate(state, 8000);
3059 cs_set_divisor(dmabuf);
3060
3061 state->open_mode |= FMODE_WRITE;
3062 up(&state->open_sem);
3063 MOD_INC_USE_COUNT;
3064 if((ret = prog_dmabuf(state)))
3065 return ret;
3066 }
3067
3068 CS_DBGOUT(CS_OPEN | CS_FUNCTION, 2, printk("cs46xx: cs_open()- 0\n") );
3069 return 0;
3070 }
3071
3072 static int cs_release(struct inode *inode, struct file *file)
3073 {
3074 struct cs_card *card = (struct cs_card *)file->private_data;
3075 struct dmabuf *dmabuf;
3076 struct cs_state *state;
3077 CS_DBGOUT(CS_RELEASE | CS_FUNCTION, 2, printk("cs46xx: cs_release()+ file=0x%x %s %s\n",
3078 (unsigned)file, file->f_mode & FMODE_WRITE ? "FMODE_WRITE" : "",
3079 file->f_mode & FMODE_READ ? "FMODE_READ" : "") );
3080
3081 if (!(file->f_mode & (FMODE_WRITE | FMODE_READ)))
3082 {
3083 return -EINVAL;
3084 }
3085 state = card->states[1];
3086 if(state)
3087 {
3088 if ( (state->open_mode & FMODE_WRITE) & (file->f_mode & FMODE_WRITE) )
3089 {
3090 CS_DBGOUT(CS_RELEASE, 2, printk("cs46xx: cs_release() FMODE_WRITE\n") );
3091 dmabuf = &state->dmabuf;
3092 cs_clear_tail(state);
3093 drain_dac(state, file->f_flags & O_NONBLOCK);
3094 /* stop DMA state machine and free DMA buffers/channels */
3095 down(&state->open_sem);
3096 stop_dac(state);
3097 dealloc_dmabuf(state);
3098 state->card->free_pcm_channel(state->card, dmabuf->channel->num);
3099 free_page((unsigned long)state->dmabuf.pbuf);
3100
3101 /* we're covered by the open_sem */
3102 up(&state->open_sem);
3103 state->card->states[state->virt] = NULL;
3104 state->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
3105
3106 /* Now turn off external AMP if needed */
3107 state->card->amplifier_ctrl(state->card, -1);
3108 state->card->active_ctrl(state->card, -1);
3109
3110 kfree(state);
3111 }
3112 MOD_DEC_USE_COUNT;
3113 }
3114
3115 state = card->states[0];
3116 if(state)
3117 {
3118 if ( (state->open_mode & FMODE_READ) & (file->f_mode & FMODE_READ) )
3119 {
3120 CS_DBGOUT(CS_RELEASE, 2, printk("cs46xx: cs_release() FMODE_READ\n") );
3121 dmabuf = &state->dmabuf;
3122 down(&state->open_sem);
3123 stop_adc(state);
3124 dealloc_dmabuf(state);
3125 state->card->free_pcm_channel(state->card, dmabuf->channel->num);
3126 free_page((unsigned long)state->dmabuf.pbuf);
3127
3128 /* we're covered by the open_sem */
3129 up(&state->open_sem);
3130 state->card->states[state->virt] = NULL;
3131 state->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
3132
3133 /* Now turn off external AMP if needed */
3134 state->card->amplifier_ctrl(state->card, -1);
3135 state->card->active_ctrl(state->card, -1);
3136
3137 kfree(state);
3138 }
3139 MOD_DEC_USE_COUNT;
3140 }
3141
3142 CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 2, printk("cs46xx: cs_release()- 0\n") );
3143 return 0;
3144 }
3145
3146 static /*const*/ struct file_operations cs461x_fops = {
3147 llseek: cs_llseek,
3148 read: cs_read,
3149 write: cs_write,
3150 poll: cs_poll,
3151 ioctl: cs_ioctl,
3152 mmap: cs_mmap,
3153 open: cs_open,
3154 release: cs_release,
3155 };
3156
3157 /* Write AC97 codec registers */
3158
3159
3160 static u16 cs_ac97_get(struct ac97_codec *dev, u8 reg)
3161 {
3162 struct cs_card *card = dev->private_data;
3163 int count;
3164
3165 /*
3166 * 1. Write ACCAD = Command Address Register = 46Ch for AC97 register address
3167 * 2. Write ACCDA = Command Data Register = 470h for data to write to AC97
3168 * 3. Write ACCTL = Control Register = 460h for initiating the write
3169 * 4. Read ACCTL = 460h, DCV should be reset by now and 460h = 17h
3170 * 5. if DCV not cleared, break and return error
3171 * 6. Read ACSTS = Status Register = 464h, check VSTS bit
3172 */
3173
3174
3175 cs461x_peekBA0(card, BA0_ACSDA);
3176
3177 /*
3178 * Setup the AC97 control registers on the CS461x to send the
3179 * appropriate command to the AC97 to perform the read.
3180 * ACCAD = Command Address Register = 46Ch
3181 * ACCDA = Command Data Register = 470h
3182 * ACCTL = Control Register = 460h
3183 * set DCV - will clear when process completed
3184 * set CRW - Read command
3185 * set VFRM - valid frame enabled
3186 * set ESYN - ASYNC generation enabled
3187 * set RSTN - ARST# inactive, AC97 codec not reset
3188 */
3189
3190 cs461x_pokeBA0(card, BA0_ACCAD, reg);
3191 cs461x_pokeBA0(card, BA0_ACCDA, 0);
3192 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_DCV | ACCTL_CRW |
3193 ACCTL_VFRM | ACCTL_ESYN |
3194 ACCTL_RSTN);
3195
3196
3197 /*
3198 * Wait for the read to occur.
3199 */
3200 for (count = 0; count < 500; count++) {
3201 /*
3202 * First, we want to wait for a short time.
3203 */
3204 udelay(10);
3205 /*
3206 * Now, check to see if the read has completed.
3207 * ACCTL = 460h, DCV should be reset by now and 460h = 17h
3208 */
3209 if (!(cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV))
3210 break;
3211 }
3212
3213 /*
3214 * Make sure the read completed.
3215 */
3216 if (cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV) {
3217 printk(KERN_WARNING "cs461x: AC'97 read problem (ACCTL_DCV), reg = 0x%x\n", reg);
3218 return 0xffff;
3219 }
3220
3221 /*
3222 * Wait for the valid status bit to go active.
3223 */
3224 for (count = 0; count < 100; count++) {
3225 /*
3226 * Read the AC97 status register.
3227 * ACSTS = Status Register = 464h
3228 * VSTS - Valid Status
3229 */
3230 if (cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_VSTS)
3231 break;
3232 udelay(10);
3233 }
3234
3235 /*
3236 * Make sure we got valid status.
3237 */
3238 if (!(cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_VSTS)) {
3239 printk(KERN_WARNING "cs461x: AC'97 read problem (ACSTS_VSTS), reg = 0x%x\n", reg);
3240 return 0xffff;
3241 }
3242
3243 /*
3244 * Read the data returned from the AC97 register.
3245 * ACSDA = Status Data Register = 474h
3246 */
3247 #if 0
3248 printk("e) reg = 0x%x, val = 0x%x, BA0_ACCAD = 0x%x\n", reg,
3249 cs461x_peekBA0(card, BA0_ACSDA),
3250 cs461x_peekBA0(card, BA0_ACCAD));
3251 #endif
3252 return cs461x_peekBA0(card, BA0_ACSDA);
3253 }
3254
3255 static void cs_ac97_set(struct ac97_codec *dev, u8 reg, u16 val)
3256 {
3257 struct cs_card *card = dev->private_data;
3258 int count;
3259 int val2 = 0;
3260
3261 if(reg == AC97_CD_VOL)
3262 {
3263 val2 = cs_ac97_get(dev, AC97_CD_VOL);
3264 }
3265
3266 /*
3267 * 1. Write ACCAD = Command Address Register = 46Ch for AC97 register address
3268 * 2. Write ACCDA = Command Data Register = 470h for data to write to AC97
3269 * 3. Write ACCTL = Control Register = 460h for initiating the write
3270 * 4. Read ACCTL = 460h, DCV should be reset by now and 460h = 07h
3271 * 5. if DCV not cleared, break and return error
3272 */
3273
3274 /*
3275 * Setup the AC97 control registers on the CS461x to send the
3276 * appropriate command to the AC97 to perform the read.
3277 * ACCAD = Command Address Register = 46Ch
3278 * ACCDA = Command Data Register = 470h
3279 * ACCTL = Control Register = 460h
3280 * set DCV - will clear when process completed
3281 * reset CRW - Write command
3282 * set VFRM - valid frame enabled
3283 * set ESYN - ASYNC generation enabled
3284 * set RSTN - ARST# inactive, AC97 codec not reset
3285 */
3286 cs461x_pokeBA0(card, BA0_ACCAD, reg);
3287 cs461x_pokeBA0(card, BA0_ACCDA, val);
3288 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_DCV | ACCTL_VFRM |
3289 ACCTL_ESYN | ACCTL_RSTN);
3290 for (count = 0; count < 1000; count++) {
3291 /*
3292 * First, we want to wait for a short time.
3293 */
3294 udelay(10);
3295 /*
3296 * Now, check to see if the write has completed.
3297 * ACCTL = 460h, DCV should be reset by now and 460h = 07h
3298 */
3299 if (!(cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV))
3300 break;
3301 }
3302 /*
3303 * Make sure the write completed.
3304 */
3305 if (cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV)
3306 printk(KERN_WARNING "cs461x: AC'97 write problem, reg = 0x%x, val = 0x%x\n", reg, val);
3307
3308 /*
3309 * Adjust power if the mixer is selected/deselected according
3310 * to the CD.
3311 *
3312 * IF the CD is a valid input source (mixer or direct) AND
3313 * the CD is not muted THEN power is needed
3314 *
3315 * We do two things. When record select changes the input to
3316 * add/remove the CD we adjust the power count if the CD is
3317 * unmuted.
3318 *
3319 * When the CD mute changes we adjust the power level if the
3320 * CD was a valid input.
3321 *
3322 * We also check for CD volume != 0, as the CD mute isn't
3323 * normally tweaked from userspace.
3324 */
3325
3326 /* CD mute change ? */
3327
3328 if(reg==AC97_CD_VOL)
3329 {
3330 /* Mute bit change ? */
3331 if((val2^val)&0x8000 || ((val2 == 0x1f1f || val == 0x1f1f) && val2 != val))
3332 {
3333 /* This is a hack but its cleaner than the alternatives.
3334 Right now card->ac97_codec[0] might be NULL as we are
3335 still doing codec setup. This does an early assignment
3336 to avoid the problem if it occurs */
3337
3338 if(card->ac97_codec[0]==NULL)
3339 card->ac97_codec[0]=dev;
3340
3341 /* Mute on */
3342 if(val&0x8000 || val == 0x1f1f)
3343 card->amplifier_ctrl(card, -1);
3344 else /* Mute off power on */
3345 card->amplifier_ctrl(card, 1);
3346 }
3347 }
3348 }
3349
3350
3351 /* OSS /dev/mixer file operation methods */
3352
3353 static int cs_open_mixdev(struct inode *inode, struct file *file)
3354 {
3355 int i;
3356 int minor = MINOR(inode->i_rdev);
3357 struct cs_card *card = devs;
3358
3359 for (card = devs; card != NULL; card = card->next)
3360 for (i = 0; i < NR_AC97; i++)
3361 if (card->ac97_codec[i] != NULL &&
3362 card->ac97_codec[i]->dev_mixer == minor)
3363 goto match;
3364
3365 if (!card)
3366 return -ENODEV;
3367
3368 match:
3369 file->private_data = card->ac97_codec[i];
3370
3371 card->active_ctrl(card,1);
3372 MOD_INC_USE_COUNT;
3373 return 0;
3374 }
3375
3376 static int cs_release_mixdev(struct inode *inode, struct file *file)
3377 {
3378 int minor = MINOR(inode->i_rdev);
3379 struct cs_card *card = devs;
3380 int i;
3381
3382 for (card = devs; card != NULL; card = card->next)
3383 for (i = 0; i < NR_AC97; i++)
3384 if (card->ac97_codec[i] != NULL &&
3385 card->ac97_codec[i]->dev_mixer == minor)
3386 goto match;
3387
3388 if (!card)
3389 return -ENODEV;
3390 match:
3391 card->active_ctrl(card, -1);
3392 MOD_DEC_USE_COUNT;
3393 return 0;
3394 }
3395
3396 static int cs_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd,
3397 unsigned long arg)
3398 {
3399 struct ac97_codec *codec = (struct ac97_codec *)file->private_data;
3400
3401 #if CSDEBUG_INTERFACE
3402 int val;
3403
3404 if( (cmd == SOUND_MIXER_CS_GETDBGMASK) ||
3405 (cmd == SOUND_MIXER_CS_SETDBGMASK) ||
3406 (cmd == SOUND_MIXER_CS_GETDBGLEVEL) ||
3407 (cmd == SOUND_MIXER_CS_SETDBGLEVEL) )
3408 {
3409 switch(cmd)
3410 {
3411
3412 case SOUND_MIXER_CS_GETDBGMASK:
3413 return put_user(cs_debugmask, (unsigned long *)arg);
3414
3415 case SOUND_MIXER_CS_GETDBGLEVEL:
3416 return put_user(cs_debuglevel, (unsigned long *)arg);
3417
3418 case SOUND_MIXER_CS_SETDBGMASK:
3419 if (get_user(val, (unsigned long *)arg))
3420 return -EFAULT;
3421 cs_debugmask = val;
3422 return 0;
3423
3424 case SOUND_MIXER_CS_SETDBGLEVEL:
3425 if (get_user(val, (unsigned long *)arg))
3426 return -EFAULT;
3427 cs_debuglevel = val;
3428 return 0;
3429 default:
3430 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
3431 "cs4281: mixer_ioctl(): ERROR unknown debug cmd\n") );
3432 return 0;
3433 }
3434 }
3435 #endif
3436 return codec->mixer_ioctl(codec, cmd, arg);
3437 }
3438
3439 static /*const*/ struct file_operations cs_mixer_fops = {
3440 llseek: cs_llseek,
3441 ioctl: cs_ioctl_mixdev,
3442 open: cs_open_mixdev,
3443 release: cs_release_mixdev,
3444 };
3445
3446 /* AC97 codec initialisation. */
3447 static int __init cs_ac97_init(struct cs_card *card)
3448 {
3449 int num_ac97 = 0;
3450 int ready_2nd = 0;
3451 struct ac97_codec *codec;
3452 u16 eid;
3453
3454 for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
3455 if ((codec = kmalloc(sizeof(struct ac97_codec), GFP_KERNEL)) == NULL)
3456 return -ENOMEM;
3457 memset(codec, 0, sizeof(struct ac97_codec));
3458
3459 /* initialize some basic codec information, other fields will be filled
3460 in ac97_probe_codec */
3461 codec->private_data = card;
3462 codec->id = num_ac97;
3463
3464 codec->codec_read = cs_ac97_get;
3465 codec->codec_write = cs_ac97_set;
3466
3467 if (ac97_probe_codec(codec) == 0)
3468 break;
3469
3470 eid = cs_ac97_get(codec, AC97_EXTENDED_ID);
3471
3472 if(eid==0xFFFFFF)
3473 {
3474 printk(KERN_WARNING "cs461x: no codec attached ?\n");
3475 kfree(codec);
3476 break;
3477 }
3478
3479 card->ac97_features = eid;
3480
3481 if ((codec->dev_mixer = register_sound_mixer(&cs_mixer_fops, -1)) < 0) {
3482 printk(KERN_ERR "cs461x: couldn't register mixer!\n");
3483 kfree(codec);
3484 break;
3485 }
3486
3487 card->ac97_codec[num_ac97] = codec;
3488
3489 /* if there is no secondary codec at all, don't probe any more */
3490 if (!ready_2nd)
3491 return num_ac97+1;
3492 }
3493 return num_ac97;
3494 }
3495
3496 /*
3497 * load the static image into the DSP
3498 */
3499 #include "cs461x_image.h"
3500 static void cs461x_download_image(struct cs_card *card)
3501 {
3502 unsigned i, j, temp1, temp2, offset, count;
3503 unsigned char *pBA1 = ioremap(card->ba1_addr, 0x40000);
3504 for( i=0; i < CLEAR__COUNT; i++)
3505 {
3506 offset = ClrStat[i].BA1__DestByteOffset;
3507 count = ClrStat[i].BA1__SourceSize;
3508 for( temp1 = offset; temp1<(offset+count); temp1+=4 );
3509 writel(0, pBA1+temp1);
3510 }
3511
3512 for(i=0; i<FILL__COUNT; i++)
3513 {
3514 temp2 = FillStat[i].Offset;
3515 for(j=0; j<(FillStat[i].Size)/4; j++)
3516 {
3517 temp1 = (FillStat[i]).pFill[j];
3518 writel(temp1, pBA1+temp2+j*4);
3519 }
3520 }
3521 iounmap(pBA1);
3522 }
3523
3524
3525 /*
3526 * Chip reset
3527 */
3528
3529 static void cs461x_reset(struct cs_card *card)
3530 {
3531 int idx;
3532
3533 /*
3534 * Write the reset bit of the SP control register.
3535 */
3536 cs461x_poke(card, BA1_SPCR, SPCR_RSTSP);
3537
3538 /*
3539 * Write the control register.
3540 */
3541 cs461x_poke(card, BA1_SPCR, SPCR_DRQEN);
3542
3543 /*
3544 * Clear the trap registers.
3545 */
3546 for (idx = 0; idx < 8; idx++) {
3547 cs461x_poke(card, BA1_DREG, DREG_REGID_TRAP_SELECT + idx);
3548 cs461x_poke(card, BA1_TWPR, 0xFFFF);
3549 }
3550 cs461x_poke(card, BA1_DREG, 0);
3551
3552 /*
3553 * Set the frame timer to reflect the number of cycles per frame.
3554 */
3555 cs461x_poke(card, BA1_FRMT, 0xadf);
3556 }
3557
3558 static void cs461x_clear_serial_FIFOs(struct cs_card *card)
3559 {
3560 int idx, loop, powerdown = 0;
3561 unsigned int tmp;
3562
3563 /*
3564 * See if the devices are powered down. If so, we must power them up first
3565 * or they will not respond.
3566 */
3567 if (!((tmp = cs461x_peekBA0(card, BA0_CLKCR1)) & CLKCR1_SWCE)) {
3568 cs461x_pokeBA0(card, BA0_CLKCR1, tmp | CLKCR1_SWCE);
3569 powerdown = 1;
3570 }
3571
3572 /*
3573 * We want to clear out the serial port FIFOs so we don't end up playing
3574 * whatever random garbage happens to be in them. We fill the sample FIFOS
3575 * with zero (silence).
3576 */
3577 cs461x_pokeBA0(card, BA0_SERBWP, 0);
3578
3579 /*
3580 * Fill all 256 sample FIFO locations.
3581 */
3582 for (idx = 0; idx < 256; idx++) {
3583 /*
3584 * Make sure the previous FIFO write operation has completed.
3585 */
3586 for (loop = 0; loop < 5; loop++) {
3587 udelay(50);
3588 if (!(cs461x_peekBA0(card, BA0_SERBST) & SERBST_WBSY))
3589 break;
3590 }
3591 if (cs461x_peekBA0(card, BA0_SERBST) & SERBST_WBSY) {
3592 if (powerdown)
3593 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
3594 }
3595 /*
3596 * Write the serial port FIFO index.
3597 */
3598 cs461x_pokeBA0(card, BA0_SERBAD, idx);
3599 /*
3600 * Tell the serial port to load the new value into the FIFO location.
3601 */
3602 cs461x_pokeBA0(card, BA0_SERBCM, SERBCM_WRC);
3603 }
3604 /*
3605 * Now, if we powered up the devices, then power them back down again.
3606 * This is kinda ugly, but should never happen.
3607 */
3608 if (powerdown)
3609 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
3610 }
3611
3612 static void cs461x_powerup_dac(struct cs_card *card)
3613 {
3614 int count;
3615 unsigned int tmp;
3616
3617 /*
3618 * Power on the DACs on the AC97 card. We turn off the DAC
3619 * powerdown bit and write the new value of the power control
3620 * register.
3621 */
3622 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
3623 if (tmp & 2) /* already */
3624 return;
3625 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp & 0xfdff);
3626
3627 /*
3628 * Now, we wait until we sample a DAC ready state.
3629 */
3630 for (count = 0; count < 32; count++) {
3631 /*
3632 * First, lets wait a short while to let things settle out a
3633 * bit, and to prevent retrying the read too quickly.
3634 */
3635 udelay(50);
3636
3637 /*
3638 * Read the current state of the power control register.
3639 */
3640 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) & 2)
3641 break;
3642 }
3643
3644 /*
3645 * Check the status..
3646 */
3647 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) & 2))
3648 printk(KERN_WARNING "cs461x: powerup DAC failed\n");
3649 }
3650
3651 static void cs461x_powerup_adc(struct cs_card *card)
3652 {
3653 int count;
3654 unsigned int tmp;
3655
3656 /*
3657 * Power on the ADCs on the AC97 card. We turn off the DAC
3658 * powerdown bit and write the new value of the power control
3659 * register.
3660 */
3661 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
3662 if (tmp & 1) /* already */
3663 return;
3664 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp & 0xfeff);
3665
3666 /*
3667 * Now, we wait until we sample a ADC ready state.
3668 */
3669 for (count = 0; count < 32; count++) {
3670 /*
3671 * First, lets wait a short while to let things settle out a
3672 * bit, and to prevent retrying the read too quickly.
3673 */
3674 udelay(50);
3675
3676 /*
3677 * Read the current state of the power control register.
3678 */
3679 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) & 1)
3680 break;
3681 }
3682
3683 /*
3684 * Check the status..
3685 */
3686 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) & 1))
3687 printk(KERN_WARNING "cs461x: powerup ADC failed\n");
3688 }
3689
3690 static void cs461x_proc_start(struct cs_card *card)
3691 {
3692 int cnt;
3693
3694 /*
3695 * Set the frame timer to reflect the number of cycles per frame.
3696 */
3697 cs461x_poke(card, BA1_FRMT, 0xadf);
3698 /*
3699 * Turn on the run, run at frame, and DMA enable bits in the local copy of
3700 * the SP control register.
3701 */
3702 cs461x_poke(card, BA1_SPCR, SPCR_RUN | SPCR_RUNFR | SPCR_DRQEN);
3703 /*
3704 * Wait until the run at frame bit resets itself in the SP control
3705 * register.
3706 */
3707 for (cnt = 0; cnt < 25; cnt++) {
3708 udelay(50);
3709 if (!(cs461x_peek(card, BA1_SPCR) & SPCR_RUNFR))
3710 break;
3711 }
3712
3713 if (cs461x_peek(card, BA1_SPCR) & SPCR_RUNFR)
3714 printk(KERN_WARNING "cs461x: SPCR_RUNFR never reset\n");
3715 }
3716
3717 static void cs461x_proc_stop(struct cs_card *card)
3718 {
3719 /*
3720 * Turn off the run, run at frame, and DMA enable bits in the local copy of
3721 * the SP control register.
3722 */
3723 cs461x_poke(card, BA1_SPCR, 0);
3724 }
3725
3726
3727
3728 static int cs_hardware_init(struct cs_card *card)
3729 {
3730 unsigned long end_time;
3731 unsigned int tmp;
3732
3733 /*
3734 * First, blast the clock control register to zero so that the PLL starts
3735 * out in a known state, and blast the master serial port control register
3736 * to zero so that the serial ports also start out in a known state.
3737 */
3738 cs461x_pokeBA0(card, BA0_CLKCR1, 0);
3739 cs461x_pokeBA0(card, BA0_SERMC1, 0);
3740
3741 /*
3742 * If we are in AC97 mode, then we must set the part to a host controlled
3743 * AC-link. Otherwise, we won't be able to bring up the link.
3744 */
3745 cs461x_pokeBA0(card, BA0_SERACC, SERACC_HSP | SERACC_CODEC_TYPE_1_03); /* 1.03 card */
3746 /* cs461x_pokeBA0(card, BA0_SERACC, SERACC_HSP | SERACC_CODEC_TYPE_2_0); */ /* 2.00 card */
3747
3748 /*
3749 * Drive the ARST# pin low for a minimum of 1uS (as defined in the AC97
3750 * spec) and then drive it high. This is done for non AC97 modes since
3751 * there might be logic external to the CS461x that uses the ARST# line
3752 * for a reset.
3753 */
3754 cs461x_pokeBA0(card, BA0_ACCTL, 0);
3755 udelay(50);
3756 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_RSTN);
3757
3758 /*
3759 * The first thing we do here is to enable sync generation. As soon
3760 * as we start receiving bit clock, we'll start producing the SYNC
3761 * signal.
3762 */
3763 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_ESYN | ACCTL_RSTN);
3764
3765 /*
3766 * Now wait for a short while to allow the AC97 part to start
3767 * generating bit clock (so we don't try to start the PLL without an
3768 * input clock).
3769 */
3770 mdelay(5); /* 1 should be enough ?? (and pigs might fly) */
3771
3772 /*
3773 * Set the serial port timing configuration, so that
3774 * the clock control circuit gets its clock from the correct place.
3775 */
3776 cs461x_pokeBA0(card, BA0_SERMC1, SERMC1_PTC_AC97);
3777
3778 /*
3779 * Write the selected clock control setup to the hardware. Do not turn on
3780 * SWCE yet (if requested), so that the devices clocked by the output of
3781 * PLL are not clocked until the PLL is stable.
3782 */
3783 cs461x_pokeBA0(card, BA0_PLLCC, PLLCC_LPF_1050_2780_KHZ | PLLCC_CDR_73_104_MHZ);
3784 cs461x_pokeBA0(card, BA0_PLLM, 0x3a);
3785 cs461x_pokeBA0(card, BA0_CLKCR2, CLKCR2_PDIVS_8);
3786
3787 /*
3788 * Power up the PLL.
3789 */
3790 cs461x_pokeBA0(card, BA0_CLKCR1, CLKCR1_PLLP);
3791
3792 /*
3793 * Wait until the PLL has stabilized.
3794 */
3795 mdelay(5); /* Again 1 should be enough ?? */
3796
3797 /*
3798 * Turn on clocking of the core so that we can setup the serial ports.
3799 */
3800 tmp = cs461x_peekBA0(card, BA0_CLKCR1) | CLKCR1_SWCE;
3801 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
3802
3803 /*
3804 * Fill the serial port FIFOs with silence.
3805 */
3806 cs461x_clear_serial_FIFOs(card);
3807
3808 /*
3809 * Set the serial port FIFO pointer to the first sample in the FIFO.
3810 */
3811 /* cs461x_pokeBA0(card, BA0_SERBSP, 0); */
3812
3813 /*
3814 * Write the serial port configuration to the part. The master
3815 * enable bit is not set until all other values have been written.
3816 */
3817 cs461x_pokeBA0(card, BA0_SERC1, SERC1_SO1F_AC97 | SERC1_SO1EN);
3818 cs461x_pokeBA0(card, BA0_SERC2, SERC2_SI1F_AC97 | SERC1_SO1EN);
3819 cs461x_pokeBA0(card, BA0_SERMC1, SERMC1_PTC_AC97 | SERMC1_MSPE);
3820
3821
3822 mdelay(5); /* Shouldnt be needed ?? */
3823
3824 /*
3825 * Wait for the card ready signal from the AC97 card.
3826 */
3827 end_time = jiffies + 3 * (HZ >> 2);
3828 do {
3829 /*
3830 * Read the AC97 status register to see if we've seen a CODEC READY
3831 * signal from the AC97 card.
3832 */
3833 if (cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_CRDY)
3834 break;
3835 current->state = TASK_UNINTERRUPTIBLE;
3836 schedule_timeout(1);
3837 } while (time_before(jiffies, end_time));
3838
3839 /*
3840 * Make sure CODEC is READY.
3841 */
3842 if (!(cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_CRDY)) {
3843 printk(KERN_WARNING "cs461x: create - never read card ready from AC'97\n");
3844 printk(KERN_WARNING "cs461x: it is probably not a bug, try using the CS4232 driver\n");
3845 return -EIO;
3846 }
3847
3848 /*
3849 * Assert the vaid frame signal so that we can start sending commands
3850 * to the AC97 card.
3851 */
3852 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_VFRM | ACCTL_ESYN | ACCTL_RSTN);
3853
3854 /*
3855 * Wait until we've sampled input slots 3 and 4 as valid, meaning that
3856 * the card is pumping ADC data across the AC-link.
3857 */
3858 end_time = jiffies + 3 * (HZ >> 2);
3859 do {
3860 /*
3861 * Read the input slot valid register and see if input slots 3 and
3862 * 4 are valid yet.
3863 */
3864 if ((cs461x_peekBA0(card, BA0_ACISV) & (ACISV_ISV3 | ACISV_ISV4)) == (ACISV_ISV3 | ACISV_ISV4))
3865 break;
3866 current->state = TASK_UNINTERRUPTIBLE;
3867 schedule_timeout(1);
3868 } while (time_before(jiffies, end_time));
3869
3870 /*
3871 * Make sure input slots 3 and 4 are valid. If not, then return
3872 * an error.
3873 */
3874 if ((cs461x_peekBA0(card, BA0_ACISV) & (ACISV_ISV3 | ACISV_ISV4)) != (ACISV_ISV3 | ACISV_ISV4)) {
3875 printk(KERN_WARNING "cs461x: create - never read ISV3 & ISV4 from AC'97\n");
3876 return -EIO;
3877 }
3878
3879 /*
3880 * Now, assert valid frame and the slot 3 and 4 valid bits. This will
3881 * commense the transfer of digital audio data to the AC97 card.
3882 */
3883 cs461x_pokeBA0(card, BA0_ACOSV, ACOSV_SLV3 | ACOSV_SLV4);
3884
3885 /*
3886 * Power down the DAC and ADC. We will power them up (if) when we need
3887 * them.
3888 */
3889 /* cs461x_pokeBA0(card, BA0_AC97_POWERDOWN, 0x300); */
3890
3891 /*
3892 * Turn off the Processor by turning off the software clock enable flag in
3893 * the clock control register.
3894 */
3895 /* tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE; */
3896 /* cs461x_pokeBA0(card, BA0_CLKCR1, tmp); */
3897
3898 /*
3899 * Reset the processor.
3900 */
3901 cs461x_reset(card);
3902
3903 /*
3904 * Download the image to the processor.
3905 */
3906
3907 cs461x_download_image(card);
3908
3909 /*
3910 * Stop playback DMA.
3911 */
3912 tmp = cs461x_peek(card, BA1_PCTL);
3913 card->pctl = tmp & 0xffff0000;
3914 cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
3915
3916 /*
3917 * Stop capture DMA.
3918 */
3919 tmp = cs461x_peek(card, BA1_CCTL);
3920 card->cctl = tmp & 0x0000ffff;
3921 cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
3922
3923 /* initialize AC97 codec and register /dev/mixer */
3924 if (cs_ac97_init(card) <= 0)
3925 return -EIO;
3926
3927 mdelay(5); /* Do we need this ?? */
3928
3929 cs461x_powerup_adc(card);
3930 cs461x_powerup_dac(card);
3931
3932 cs461x_proc_start(card);
3933
3934 /*
3935 * Enable interrupts on the part.
3936 */
3937 cs461x_pokeBA0(card, BA0_HICR, HICR_IEV | HICR_CHGM);
3938
3939 tmp = cs461x_peek(card, BA1_PFIE);
3940 tmp &= ~0x0000f03f;
3941 cs461x_poke(card, BA1_PFIE, tmp); /* playback interrupt enable */
3942
3943 tmp = cs461x_peek(card, BA1_CIE);
3944 tmp &= ~0x0000003f;
3945 tmp |= 0x00000001;
3946 cs461x_poke(card, BA1_CIE, tmp); /* capture interrupt enable */
3947 return 0;
3948 }
3949
3950 /* install the driver, we do not allocate hardware channel nor DMA buffer now, they are defered
3951 untill "ACCESS" time (in prog_dmabuf called by open/read/write/ioctl/mmap) */
3952
3953
3954 /*
3955 * Card subid table
3956 */
3957
3958 struct cs_card_type
3959 {
3960 u16 vendor;
3961 u16 id;
3962 char *name;
3963 void (*amp)(struct cs_card *, int);
3964 void (*active)(struct cs_card *, int);
3965 };
3966
3967 static struct cs_card_type __initdata cards[]={
3968 {0x1489, 0x7001, "Genius Soundmaker 128 value", amp_none, NULL},
3969 {0x5053, 0x3357, "Voyetra", amp_voyetra, NULL},
3970 {0x1071, 0x6003, "Mitac MI6020/21", amp_voyetra, NULL},
3971 /* Not sure if the 570 needs the clkrun hack */
3972 {PCI_VENDOR_ID_IBM, 0x0132, "Thinkpad 570", amp_none, clkrun_hack},
3973 {PCI_VENDOR_ID_IBM, 0x0153, "Thinkpad 600X/A20/T20", amp_none, clkrun_hack},
3974 {PCI_VENDOR_ID_IBM, 0x1010, "Thinkpad 600E (unsupported)", NULL, NULL},
3975 {0, 0, "Card without SSID set", NULL, NULL },
3976 {0, 0, NULL, NULL, NULL}
3977 };
3978
3979 #ifdef CS46XX_PM
3980 static int cs46xx_pm_callback(struct pm_dev *dev, pm_request_t rqst, void *data)
3981 {
3982 struct cs_state *state = (struct cs_state *) dev->data;
3983
3984 if (state) {
3985 switch(rqst) {
3986 case PM_RESUME:
3987 printk( KERN_DEBUG "cs46xx: PM resume request\n");
3988 cs_hardware_init(state->card);
3989 break;
3990 case PM_SUSPEND:
3991 printk( KERN_DEBUG "cs46xx: PM suspend request\n");
3992 stop_dac(state);
3993 resync_dma_ptrs(state);
3994 break;
3995 }
3996 }
3997
3998 return 0;
3999 }
4000 #endif
4001
4002 static int __init cs_install(struct pci_dev *pci_dev)
4003 {
4004 struct cs_card *card;
4005 struct cs_card_type *cp = &cards[0];
4006 #ifdef CS46XX_PM
4007 struct pm_dev *pmdev;
4008 #endif
4009 u16 ss_card, ss_vendor;
4010
4011
4012 pci_read_config_word(pci_dev, PCI_SUBSYSTEM_VENDOR_ID, &ss_vendor);
4013 pci_read_config_word(pci_dev, PCI_SUBSYSTEM_ID, &ss_card);
4014
4015 if ((card = kmalloc(sizeof(struct cs_card), GFP_KERNEL)) == NULL) {
4016 printk(KERN_ERR "cs461x: out of memory\n");
4017 return -ENOMEM;
4018 }
4019 memset(card, 0, sizeof(*card));
4020
4021 card->ba0_addr = pci_dev->resource[0].start&PCI_BASE_ADDRESS_MEM_MASK;
4022 card->ba1_addr = pci_dev->resource[1].start&PCI_BASE_ADDRESS_MEM_MASK;
4023 card->pci_dev = pci_dev;
4024 card->irq = pci_dev->irq;
4025 card->magic = CS_CARD_MAGIC;
4026 spin_lock_init(&card->lock);
4027
4028 pci_set_master(pci_dev);
4029
4030 printk(KERN_INFO "cs461x: Card found at 0x%08lx and 0x%08lx, IRQ %d\n",
4031 card->ba0_addr, card->ba1_addr, card->irq);
4032
4033 card->alloc_pcm_channel = cs_alloc_pcm_channel;
4034 card->alloc_rec_pcm_channel = cs_alloc_rec_pcm_channel;
4035 card->free_pcm_channel = cs_free_pcm_channel;
4036 card->amplifier_ctrl = amp_none;
4037 card->active_ctrl = amp_none;
4038
4039 while (cp->name)
4040 {
4041 if(cp->vendor == ss_vendor && cp->id == ss_card)
4042 {
4043 card->amplifier_ctrl = cp->amp;
4044 if(cp->active)
4045 card->active_ctrl = cp->active;
4046 break;
4047 }
4048 cp++;
4049 }
4050 if (cp->name==NULL)
4051 {
4052 printk(KERN_INFO "cs461x: Unknown card (%04X:%04X) at 0x%08lx/0x%08lx, IRQ %d\n",
4053 ss_vendor, ss_card, card->ba0_addr, card->ba1_addr, card->irq);
4054 }
4055 else
4056 {
4057 printk(KERN_INFO "cs461x: %s at 0x%08lx/0x%08lx, IRQ %d\n",
4058 cp->name, card->ba0_addr, card->ba1_addr, card->irq);
4059 }
4060
4061 if (card->amplifier_ctrl==NULL)
4062 {
4063 card->amplifier_ctrl = amp_none;
4064 card->active_ctrl = clkrun_hack;
4065 }
4066
4067 if (external_amp == 1)
4068 {
4069 printk(KERN_INFO "cs461x: Crystal EAPD support forced on.\n");
4070 card->amplifier_ctrl = amp_voyetra;
4071 }
4072
4073 if (thinkpad == 1)
4074 {
4075 card->active_ctrl = clkrun_hack;
4076 printk(KERN_INFO "cs461x: Activating CLKRUN hack for Thinkpad.\n");
4077 }
4078
4079 card->active_ctrl(card, 1);
4080
4081 /* claim our iospace and irq */
4082
4083 card->ba0 = ioremap(card->ba0_addr, CS461X_BA0_SIZE);
4084 card->ba1.name.data0 = ioremap(card->ba1_addr + BA1_SP_DMEM0, CS461X_BA1_DATA0_SIZE);
4085 card->ba1.name.data1 = ioremap(card->ba1_addr + BA1_SP_DMEM1, CS461X_BA1_DATA1_SIZE);
4086 card->ba1.name.pmem = ioremap(card->ba1_addr + BA1_SP_PMEM, CS461X_BA1_PRG_SIZE);
4087 card->ba1.name.reg = ioremap(card->ba1_addr + BA1_SP_REG, CS461X_BA1_REG_SIZE);
4088
4089 CS_DBGOUT(CS_INIT, 4, printk("card->ba0=0x%.08x\n",(unsigned)card->ba0) );
4090 CS_DBGOUT(CS_INIT, 4, printk("card->ba1=0x%.08x 0x%.08x 0x%.08x 0x%.08x\n",
4091 (unsigned)card->ba1.name.data0,
4092 (unsigned)card->ba1.name.data1,
4093 (unsigned)card->ba1.name.pmem,
4094 (unsigned)card->ba1.name.reg) );
4095
4096 if(card->ba0 == 0 || card->ba1.name.data0 == 0 ||
4097 card->ba1.name.data1 == 0 || card->ba1.name.pmem == 0 ||
4098 card->ba1.name.reg == 0)
4099 goto fail2;
4100
4101 if (request_irq(card->irq, &cs_interrupt, SA_SHIRQ, "cs461x", card)) {
4102 printk(KERN_ERR "cs461x: unable to allocate irq %d\n", card->irq);
4103 goto fail2;
4104 }
4105 /* register /dev/dsp */
4106 if ((card->dev_audio = register_sound_dsp(&cs461x_fops, -1)) < 0) {
4107 printk(KERN_ERR "cs461x: unable to register dsp\n");
4108 goto fail;
4109 }
4110
4111 /* register /dev/midi */
4112 if((card->dev_midi = register_sound_midi(&cs_midi_fops, -1)) < 0)
4113 printk(KERN_ERR "cs461x: unable to register midi\n");
4114
4115 if (cs_hardware_init(card)<0)
4116 {
4117 unregister_sound_dsp(card->dev_audio);
4118 if(card->dev_midi)
4119 unregister_sound_midi(card->dev_midi);
4120 goto fail;
4121 }
4122 init_waitqueue_head(&card->midi.open_wait);
4123 init_MUTEX(&card->midi.open_sem);
4124 init_waitqueue_head(&card->midi.iwait);
4125 init_waitqueue_head(&card->midi.owait);
4126 card->next = devs;
4127 devs = card;
4128 cs461x_pokeBA0(card, BA0_MIDCR, MIDCR_MRST);
4129 cs461x_pokeBA0(card, BA0_MIDCR, 0);
4130
4131 card->active_ctrl(card, -1);
4132 #ifdef CS46XX_PM
4133 pmdev = pm_register(PM_PCI_DEV, PM_PCI_ID(pci_dev), cs46xx_pm_callback);
4134 if (pmdev)
4135 pmdev->data = card;
4136 #endif
4137 return 0;
4138
4139 fail:
4140 free_irq(card->irq, card);
4141 fail2:
4142 if(card->ba0)
4143 iounmap(card->ba0);
4144 if(card->ba1.name.data0)
4145 iounmap(card->ba1.name.data0);
4146 if(card->ba1.name.data1)
4147 iounmap(card->ba1.name.data1);
4148 if(card->ba1.name.pmem)
4149 iounmap(card->ba1.name.pmem);
4150 if(card->ba1.name.reg)
4151 iounmap(card->ba1.name.reg);
4152 kfree(card);
4153 return -ENODEV;
4154
4155 }
4156
4157 static void cs_remove(struct cs_card *card)
4158 {
4159 int i;
4160 unsigned int tmp;
4161
4162 card->active_ctrl(card,1);
4163
4164 tmp = cs461x_peek(card, BA1_PFIE);
4165 tmp &= ~0x0000f03f;
4166 tmp |= 0x00000010;
4167 cs461x_poke(card, BA1_PFIE, tmp); /* playback interrupt disable */
4168
4169 tmp = cs461x_peek(card, BA1_CIE);
4170 tmp &= ~0x0000003f;
4171 tmp |= 0x00000011;
4172 cs461x_poke(card, BA1_CIE, tmp); /* capture interrupt disable */
4173
4174 /*
4175 * Stop playback DMA.
4176 */
4177 tmp = cs461x_peek(card, BA1_PCTL);
4178 cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
4179
4180 /*
4181 * Stop capture DMA.
4182 */
4183 tmp = cs461x_peek(card, BA1_CCTL);
4184 cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
4185
4186 /*
4187 * Reset the processor.
4188 */
4189 cs461x_reset(card);
4190
4191 cs461x_proc_stop(card);
4192
4193 /*
4194 * Power down the DAC and ADC. We will power them up (if) when we need
4195 * them.
4196 */
4197 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, 0x300);
4198
4199 /*
4200 * Power down the PLL.
4201 */
4202 cs461x_pokeBA0(card, BA0_CLKCR1, 0);
4203
4204 /*
4205 * Turn off the Processor by turning off the software clock enable flag in
4206 * the clock control register.
4207 */
4208 tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE;
4209 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
4210
4211 card->active_ctrl(card,-1);
4212
4213 /* free hardware resources */
4214 free_irq(card->irq, card);
4215 iounmap(card->ba0);
4216 iounmap(card->ba1.name.data0);
4217 iounmap(card->ba1.name.data1);
4218 iounmap(card->ba1.name.pmem);
4219 iounmap(card->ba1.name.reg);
4220
4221 /* unregister audio devices */
4222 for (i = 0; i < NR_AC97; i++)
4223 if (card->ac97_codec[i] != NULL) {
4224 unregister_sound_mixer(card->ac97_codec[i]->dev_mixer);
4225 kfree (card->ac97_codec[i]);
4226 }
4227 unregister_sound_dsp(card->dev_audio);
4228 if(card->dev_midi)
4229 unregister_sound_midi(card->dev_midi);
4230 kfree(card);
4231 }
4232
4233 MODULE_AUTHOR("Alan Cox <alan@redhat.com>, Jaroslav Kysela, <audio@crystal.cirrus.com>");
4234 MODULE_DESCRIPTION("Crystal SoundFusion Audio Support");
4235
4236 int __init cs_probe(void)
4237 {
4238 struct pci_dev *pcidev = NULL;
4239 int foundone=0;
4240
4241 if (!pci_present()) /* No PCI bus in this machine! */
4242 return -ENODEV;
4243
4244 printk(KERN_INFO "Crystal 4280/461x + AC97 Audio, version "
4245 DRIVER_VERSION ", " __TIME__ " " __DATE__ "\n");
4246
4247 while( (pcidev = pci_find_device(PCI_VENDOR_ID_CIRRUS, 0x6001 , pcidev))!=NULL ) {
4248 if (cs_install(pcidev)==0)
4249 foundone++;
4250 }
4251 while( (pcidev = pci_find_device(PCI_VENDOR_ID_CIRRUS, 0x6003 , pcidev))!=NULL ) {
4252 if (cs_install(pcidev)==0)
4253 foundone++;
4254 }
4255 while( (pcidev = pci_find_device(PCI_VENDOR_ID_CIRRUS, 0x6004 , pcidev))!=NULL ) {
4256 if (cs_install(pcidev)==0)
4257 foundone++;
4258 }
4259
4260 printk(KERN_INFO "cs461x: Found %d audio device(s).\n",
4261 foundone);
4262 return foundone;
4263 }
4264
4265 int __init init_module(void)
4266 {
4267 if(cs_probe()==0)
4268 printk(KERN_ERR "cs461x: No devices found.\n");
4269 return 0;
4270 }
4271
4272 void __exit cleanup_module (void)
4273 {
4274 struct cs_card *next;
4275 #ifdef CS46XX_PM
4276 pm_unregister_all(cs46xx_pm_callback);
4277 #endif
4278 while(devs)
4279 {
4280 next=devs->next;
4281 cs_remove(devs);
4282 devs=next;
4283 }
4284 }
4285
4286 MODULE_PARM(external_amp, "i");
4287 MODULE_PARM(thinkpad, "i");
4288
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.