File: /usr/src/linux/drivers/sound/cs46xx.c
1 /*
2 * Crystal SoundFusion CS46xx driver
3 *
4 * Copyright 1998-2001 Cirrus Logic Corporation <pcaudio@crystal.cirrus.com>
5 * <twoller@crystal.cirrus.com>
6 * Copyright 1999-2000 Jaroslav Kysela <perex@suse.cz>
7 * Copyright 2000 Alan Cox <alan@redhat.com>
8 *
9 * The core of this code is taken from the ALSA project driver by
10 * Jaroslav. Please send Jaroslav the credit for the driver and
11 * report bugs in this port to <alan@redhat.com>
12 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
17 *
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
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 * 20010113-tw patch from Hans Grobler general cleanup.
47 * 20010117-tw 2.4.0 pci cleanup, wrapper code for 2.2.16-2.4.0
48 * 20010118-tw basic PM support for 2.2.16+ and 2.4.0/2.4.2.
49 * 20010228-dh patch from David Huggins - cs_update_ptr recursion.
50 * 20010409-tw add hercules game theatre XP amp code.
51 * 20010420-tw cleanup powerdown/up code.
52 * 20010521-tw eliminate pops, and fixes for powerdown.
53 * 20010525-tw added fixes for thinkpads with powerdown logic.
54 * 20010723-sh patch from Horms (Simon Horman) -
55 * SOUND_PCM_READ_BITS returns bits as set in driver
56 * rather than a logical or of the possible values.
57 * Various ioctls handle the case where the device
58 * is open for reading or writing but not both better.
59 *
60 * Status:
61 * Playback/Capture supported from 8k-48k.
62 * 16Bit Signed LE & 8Bit Unsigned, with Mono or Stereo supported.
63 *
64 * APM/PM - 2.2.x APM is enabled and functioning fine. APM can also
65 * be enabled for 2.4.x by modifying the CS46XX_ACPI_SUPPORT macro
66 * definition.
67 *
68 * Hercules Game Theatre XP - the EGPIO2 pin controls the external Amp,
69 * so, use the drain/polarity to enable.
70 * hercules_egpio_disable set to 1, will force a 0 to EGPIODR.
71 *
72 * VTB Santa Cruz - the GPIO7/GPIO8 on the Secondary Codec control
73 * the external amplifier for the "back" speakers, since we do not
74 * support the secondary codec then this external amp is also not
75 * turned on.
76 */
77
78 #include <linux/list.h>
79 #include <linux/version.h>
80 #include <linux/module.h>
81 #include <linux/string.h>
82 #include <linux/ioport.h>
83 #include <linux/sched.h>
84 #include <linux/delay.h>
85 #include <linux/sound.h>
86 #include <linux/slab.h>
87 #include <linux/soundcard.h>
88 #include <linux/pci.h>
89 #include <linux/bitops.h>
90 #include <asm/io.h>
91 #include <asm/dma.h>
92 #include <linux/init.h>
93 #include <linux/poll.h>
94 #include <linux/smp_lock.h>
95 #include <linux/wrapper.h>
96 #include <asm/uaccess.h>
97 #include <asm/hardirq.h>
98 #include <linux/ac97_codec.h>
99 #include "cs46xxpm-24.h"
100 #include "cs46xx_wrapper-24.h"
101
102 #include "cs461x.h"
103
104 /* MIDI buffer sizes */
105 #define CS_MIDIINBUF 500
106 #define CS_MIDIOUTBUF 500
107
108 #define ADC_RUNNING 1
109 #define DAC_RUNNING 2
110
111 #define CS_FMT_16BIT 1 /* These are fixed in fact */
112 #define CS_FMT_STEREO 2
113 #define CS_FMT_MASK 3
114
115 #define CS_TYPE_ADC 1
116 #define CS_TYPE_DAC 2
117
118 #define CS_TRUE 1
119 #define CS_FALSE 0
120
121 #define CS_INC_USE_COUNT(m) (atomic_inc(m))
122 #define CS_DEC_USE_COUNT(m) (atomic_dec(m))
123 #define CS_DEC_AND_TEST(m) (atomic_dec_and_test(m))
124 #define CS_IN_USE(m) (atomic_read(m) != 0)
125
126 #define CS_DBGBREAKPOINT {__asm__("INT $3");}
127 /*
128 * CS461x definitions
129 */
130
131 #define CS461X_BA0_SIZE 0x2000
132 #define CS461X_BA1_DATA0_SIZE 0x3000
133 #define CS461X_BA1_DATA1_SIZE 0x3800
134 #define CS461X_BA1_PRG_SIZE 0x7000
135 #define CS461X_BA1_REG_SIZE 0x0100
136
137 #define GOF_PER_SEC 200
138
139 #define CSDEBUG_INTERFACE 1
140 #define CSDEBUG 1
141 /*
142 * Turn on/off debugging compilation by using 1/0 respectively for CSDEBUG
143 *
144 *
145 * CSDEBUG is usual mode is set to 1, then use the
146 * cs_debuglevel and cs_debugmask to turn on or off debugging.
147 * Debug level of 1 has been defined to be kernel errors and info
148 * that should be printed on any released driver.
149 */
150 #if CSDEBUG
151 #define CS_DBGOUT(mask,level,x) if((cs_debuglevel >= (level)) && ((mask) & cs_debugmask)) {x;}
152 #else
153 #define CS_DBGOUT(mask,level,x)
154 #endif
155 /*
156 * cs_debugmask areas
157 */
158 #define CS_INIT 0x00000001 /* initialization and probe functions */
159 #define CS_ERROR 0x00000002 /* tmp debugging bit placeholder */
160 #define CS_INTERRUPT 0x00000004 /* interrupt handler (separate from all other) */
161 #define CS_FUNCTION 0x00000008 /* enter/leave functions */
162 #define CS_WAVE_WRITE 0x00000010 /* write information for wave */
163 #define CS_WAVE_READ 0x00000020 /* read information for wave */
164 #define CS_MIDI_WRITE 0x00000040 /* write information for midi */
165 #define CS_MIDI_READ 0x00000080 /* read information for midi */
166 #define CS_MPU401_WRITE 0x00000100 /* write information for mpu401 */
167 #define CS_MPU401_READ 0x00000200 /* read information for mpu401 */
168 #define CS_OPEN 0x00000400 /* all open functions in the driver */
169 #define CS_RELEASE 0x00000800 /* all release functions in the driver */
170 #define CS_PARMS 0x00001000 /* functional and operational parameters */
171 #define CS_IOCTL 0x00002000 /* ioctl (non-mixer) */
172 #define CS_PM 0x00004000 /* PM */
173 #define CS_TMP 0x10000000 /* tmp debug mask bit */
174
175 #define CS_IOCTL_CMD_SUSPEND 0x1 // suspend
176 #define CS_IOCTL_CMD_RESUME 0x2 // resume
177
178 #if CSDEBUG
179 static unsigned long cs_debuglevel=1; /* levels range from 1-9 */
180 MODULE_PARM(cs_debuglevel, "i");
181 static unsigned long cs_debugmask=CS_INIT | CS_ERROR; /* use CS_DBGOUT with various mask values */
182 MODULE_PARM(cs_debugmask, "i");
183 #endif
184 static unsigned long hercules_egpio_disable=0; /* if non-zero set all EGPIO to 0 */
185 MODULE_PARM(hercules_egpio_disable, "i");
186 static unsigned long initdelay=700; /* PM delay in millisecs */
187 MODULE_PARM(initdelay, "i");
188 static unsigned long powerdown=-1; /* turn on/off powerdown processing in driver */
189 MODULE_PARM(powerdown, "i");
190 #define DMABUF_DEFAULTORDER 3
191 static unsigned long defaultorder=DMABUF_DEFAULTORDER;
192 MODULE_PARM(defaultorder, "i");
193
194 static int external_amp;
195 MODULE_PARM(external_amp, "i");
196 static int thinkpad;
197 MODULE_PARM(thinkpad, "i");
198
199 /*
200 * set the powerdown module parm to 0 to disable all
201 * powerdown. also set thinkpad to 1 to disable powerdown,
202 * but also to enable the clkrun functionality.
203 */
204 static unsigned cs_powerdown=1;
205 static unsigned cs_laptop_wait=1;
206
207 /* An instance of the 4610 channel */
208 struct cs_channel
209 {
210 int used;
211 int num;
212 void *state;
213 };
214
215 #define CS46XX_MAJOR_VERSION "1"
216 #define CS46XX_MINOR_VERSION "28"
217
218 #ifdef __ia64__
219 #define CS46XX_ARCH "64" //architecture key
220 #else
221 #define CS46XX_ARCH "32" //architecture key
222 #endif
223
224 struct list_head cs46xx_devs = { &cs46xx_devs, &cs46xx_devs };
225
226 /* magic numbers to protect our data structures */
227 #define CS_CARD_MAGIC 0x43525553 /* "CRUS" */
228 #define CS_STATE_MAGIC 0x4c4f4749 /* "LOGI" */
229 #define NR_HW_CH 3
230
231 /* maxinum number of AC97 codecs connected, AC97 2.0 defined 4 */
232 #define NR_AC97 2
233
234 static const unsigned sample_size[] = { 1, 2, 2, 4 };
235 static const unsigned sample_shift[] = { 0, 1, 1, 2 };
236
237 /* "software" or virtual channel, an instance of opened /dev/dsp */
238 struct cs_state {
239 unsigned int magic;
240 struct cs_card *card; /* Card info */
241
242 /* single open lock mechanism, only used for recording */
243 struct semaphore open_sem;
244 wait_queue_head_t open_wait;
245
246 /* file mode */
247 mode_t open_mode;
248
249 /* virtual channel number */
250 int virt;
251
252 struct dmabuf {
253 /* wave sample stuff */
254 unsigned int rate;
255 unsigned char fmt, enable;
256
257 /* hardware channel */
258 struct cs_channel *channel;
259 int pringbuf; /* Software ring slot */
260 void *pbuf; /* 4K hardware DMA buffer */
261
262 /* OSS buffer management stuff */
263 void *rawbuf;
264 dma_addr_t dma_handle;
265 unsigned buforder;
266 unsigned numfrag;
267 unsigned fragshift;
268 unsigned divisor;
269 unsigned type;
270 void *tmpbuff; /* tmp buffer for sample conversions */
271 dma_addr_t dmaaddr;
272 dma_addr_t dmaaddr_tmpbuff;
273 unsigned buforder_tmpbuff; /* Log base 2 of size in bytes.. */
274
275 /* our buffer acts like a circular ring */
276 unsigned hwptr; /* where dma last started, updated by update_ptr */
277 unsigned swptr; /* where driver last clear/filled, updated by read/write */
278 int count; /* bytes to be comsumed or been generated by dma machine */
279 unsigned total_bytes; /* total bytes dmaed by hardware */
280 unsigned blocks; /* total blocks */
281
282 unsigned error; /* number of over/underruns */
283 unsigned underrun; /* underrun pending before next write has occurred */
284 wait_queue_head_t wait; /* put process on wait queue when no more space in buffer */
285
286 /* redundant, but makes calculations easier */
287 unsigned fragsize;
288 unsigned dmasize;
289 unsigned fragsamples;
290
291 /* OSS stuff */
292 unsigned mapped:1;
293 unsigned ready:1;
294 unsigned endcleared:1;
295 unsigned SGok:1;
296 unsigned update_flag;
297 unsigned ossfragshift;
298 int ossmaxfrags;
299 unsigned subdivision;
300 } dmabuf;
301 /* Guard against mmap/write/read races */
302 struct semaphore sem;
303 };
304
305 struct cs_card {
306 struct cs_channel channel[2];
307 unsigned int magic;
308
309 /* We keep cs461x cards in a linked list */
310 struct cs_card *next;
311
312 /* The cs461x has a certain amount of cross channel interaction
313 so we use a single per card lock */
314 spinlock_t lock;
315
316 /* mixer use count */
317 atomic_t mixer_use_cnt;
318
319 /* PCI device stuff */
320 struct pci_dev * pci_dev;
321 struct list_head list;
322
323 unsigned int pctl, cctl; /* Hardware DMA flag sets */
324
325 /* soundcore stuff */
326 int dev_audio;
327 int dev_midi;
328
329 /* structures for abstraction of hardware facilities, codecs, banks and channels*/
330 struct ac97_codec *ac97_codec[NR_AC97];
331 struct cs_state *states[2];
332
333 u16 ac97_features;
334
335 int amplifier; /* Amplifier control */
336 void (*amplifier_ctrl)(struct cs_card *, int);
337 void (*amp_init)(struct cs_card *);
338
339 int active; /* Active clocking */
340 void (*active_ctrl)(struct cs_card *, int);
341
342 /* hardware resources */
343 unsigned long ba0_addr;
344 unsigned long ba1_addr;
345 u32 irq;
346
347 /* mappings */
348 void *ba0;
349 union
350 {
351 struct
352 {
353 u8 *data0;
354 u8 *data1;
355 u8 *pmem;
356 u8 *reg;
357 } name;
358 u8 *idx[4];
359 } ba1;
360
361 /* Function support */
362 struct cs_channel *(*alloc_pcm_channel)(struct cs_card *);
363 struct cs_channel *(*alloc_rec_pcm_channel)(struct cs_card *);
364 void (*free_pcm_channel)(struct cs_card *, int chan);
365
366 /* /dev/midi stuff */
367 struct {
368 unsigned ird, iwr, icnt;
369 unsigned ord, owr, ocnt;
370 wait_queue_head_t open_wait;
371 wait_queue_head_t iwait;
372 wait_queue_head_t owait;
373 spinlock_t lock;
374 unsigned char ibuf[CS_MIDIINBUF];
375 unsigned char obuf[CS_MIDIOUTBUF];
376 mode_t open_mode;
377 struct semaphore open_sem;
378 } midi;
379 struct cs46xx_pm pm;
380 };
381
382 static int cs_open_mixdev(struct inode *inode, struct file *file);
383 static int cs_release_mixdev(struct inode *inode, struct file *file);
384 static int cs_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd,
385 unsigned long arg);
386 static int cs_hardware_init(struct cs_card *card);
387 static int cs46xx_powerup(struct cs_card *card, unsigned int type);
388 static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspendflag);
389 static void cs461x_clear_serial_FIFOs(struct cs_card *card, int type);
390 static int cs46xx_suspend_tbl(struct pci_dev *pcidev, u32 state);
391 static int cs46xx_resume_tbl(struct pci_dev *pcidev);
392
393 static inline unsigned ld2(unsigned int x)
394 {
395 unsigned r = 0;
396
397 if (x >= 0x10000) {
398 x >>= 16;
399 r += 16;
400 }
401 if (x >= 0x100) {
402 x >>= 8;
403 r += 8;
404 }
405 if (x >= 0x10) {
406 x >>= 4;
407 r += 4;
408 }
409 if (x >= 4) {
410 x >>= 2;
411 r += 2;
412 }
413 if (x >= 2)
414 r++;
415 return r;
416 }
417
418 #if CSDEBUG
419
420 /* DEBUG ROUTINES */
421
422 #define SOUND_MIXER_CS_GETDBGLEVEL _SIOWR('M',120, int)
423 #define SOUND_MIXER_CS_SETDBGLEVEL _SIOWR('M',121, int)
424 #define SOUND_MIXER_CS_GETDBGMASK _SIOWR('M',122, int)
425 #define SOUND_MIXER_CS_SETDBGMASK _SIOWR('M',123, int)
426 #define SOUND_MIXER_CS_APM _SIOWR('M',124, int)
427
428 void printioctl(unsigned int x)
429 {
430 unsigned int i;
431 unsigned char vidx;
432 /* these values are incorrect for the ac97 driver, fix.
433 * Index of mixtable1[] member is Device ID
434 * and must be <= SOUND_MIXER_NRDEVICES.
435 * Value of array member is index into s->mix.vol[]
436 */
437 static const unsigned char mixtable1[SOUND_MIXER_NRDEVICES] = {
438 [SOUND_MIXER_PCM] = 1, /* voice */
439 [SOUND_MIXER_LINE1] = 2, /* AUX */
440 [SOUND_MIXER_CD] = 3, /* CD */
441 [SOUND_MIXER_LINE] = 4, /* Line */
442 [SOUND_MIXER_SYNTH] = 5, /* FM */
443 [SOUND_MIXER_MIC] = 6, /* Mic */
444 [SOUND_MIXER_SPEAKER] = 7, /* Speaker */
445 [SOUND_MIXER_RECLEV] = 8, /* Recording level */
446 [SOUND_MIXER_VOLUME] = 9 /* Master Volume */
447 };
448
449 switch(x)
450 {
451 case SOUND_MIXER_CS_GETDBGMASK:
452 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_GETDBGMASK: ") );
453 break;
454 case SOUND_MIXER_CS_GETDBGLEVEL:
455 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_GETDBGLEVEL: ") );
456 break;
457 case SOUND_MIXER_CS_SETDBGMASK:
458 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_SETDBGMASK: ") );
459 break;
460 case SOUND_MIXER_CS_SETDBGLEVEL:
461 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_SETDBGLEVEL: ") );
462 break;
463 case OSS_GETVERSION:
464 CS_DBGOUT(CS_IOCTL, 4, printk("OSS_GETVERSION: ") );
465 break;
466 case SNDCTL_DSP_SYNC:
467 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SYNC: ") );
468 break;
469 case SNDCTL_DSP_SETDUPLEX:
470 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETDUPLEX: ") );
471 break;
472 case SNDCTL_DSP_GETCAPS:
473 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETCAPS: ") );
474 break;
475 case SNDCTL_DSP_RESET:
476 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_RESET: ") );
477 break;
478 case SNDCTL_DSP_SPEED:
479 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SPEED: ") );
480 break;
481 case SNDCTL_DSP_STEREO:
482 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_STEREO: ") );
483 break;
484 case SNDCTL_DSP_CHANNELS:
485 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_CHANNELS: ") );
486 break;
487 case SNDCTL_DSP_GETFMTS:
488 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETFMTS: ") );
489 break;
490 case SNDCTL_DSP_SETFMT:
491 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETFMT: ") );
492 break;
493 case SNDCTL_DSP_POST:
494 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_POST: ") );
495 break;
496 case SNDCTL_DSP_GETTRIGGER:
497 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETTRIGGER: ") );
498 break;
499 case SNDCTL_DSP_SETTRIGGER:
500 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETTRIGGER: ") );
501 break;
502 case SNDCTL_DSP_GETOSPACE:
503 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETOSPACE: ") );
504 break;
505 case SNDCTL_DSP_GETISPACE:
506 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETISPACE: ") );
507 break;
508 case SNDCTL_DSP_NONBLOCK:
509 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_NONBLOCK: ") );
510 break;
511 case SNDCTL_DSP_GETODELAY:
512 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETODELAY: ") );
513 break;
514 case SNDCTL_DSP_GETIPTR:
515 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETIPTR: ") );
516 break;
517 case SNDCTL_DSP_GETOPTR:
518 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETOPTR: ") );
519 break;
520 case SNDCTL_DSP_GETBLKSIZE:
521 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETBLKSIZE: ") );
522 break;
523 case SNDCTL_DSP_SETFRAGMENT:
524 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETFRAGMENT: ") );
525 break;
526 case SNDCTL_DSP_SUBDIVIDE:
527 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SUBDIVIDE: ") );
528 break;
529 case SOUND_PCM_READ_RATE:
530 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_RATE: ") );
531 break;
532 case SOUND_PCM_READ_CHANNELS:
533 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_CHANNELS: ") );
534 break;
535 case SOUND_PCM_READ_BITS:
536 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_BITS: ") );
537 break;
538 case SOUND_PCM_WRITE_FILTER:
539 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_WRITE_FILTER: ") );
540 break;
541 case SNDCTL_DSP_SETSYNCRO:
542 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETSYNCRO: ") );
543 break;
544 case SOUND_PCM_READ_FILTER:
545 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_FILTER: ") );
546 break;
547
548 case SOUND_MIXER_PRIVATE1:
549 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE1: ") );
550 break;
551 case SOUND_MIXER_PRIVATE2:
552 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE2: ") );
553 break;
554 case SOUND_MIXER_PRIVATE3:
555 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE3: ") );
556 break;
557 case SOUND_MIXER_PRIVATE4:
558 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE4: ") );
559 break;
560 case SOUND_MIXER_PRIVATE5:
561 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE5: ") );
562 break;
563 case SOUND_MIXER_INFO:
564 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_INFO: ") );
565 break;
566 case SOUND_OLD_MIXER_INFO:
567 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_OLD_MIXER_INFO: ") );
568 break;
569
570 default:
571 switch (_IOC_NR(x))
572 {
573 case SOUND_MIXER_VOLUME:
574 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_VOLUME: ") );
575 break;
576 case SOUND_MIXER_SPEAKER:
577 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_SPEAKER: ") );
578 break;
579 case SOUND_MIXER_RECLEV:
580 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECLEV: ") );
581 break;
582 case SOUND_MIXER_MIC:
583 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_MIC: ") );
584 break;
585 case SOUND_MIXER_SYNTH:
586 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_SYNTH: ") );
587 break;
588 case SOUND_MIXER_RECSRC:
589 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECSRC: ") );
590 break;
591 case SOUND_MIXER_DEVMASK:
592 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_DEVMASK: ") );
593 break;
594 case SOUND_MIXER_RECMASK:
595 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECMASK: ") );
596 break;
597 case SOUND_MIXER_STEREODEVS:
598 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_STEREODEVS: ") );
599 break;
600 case SOUND_MIXER_CAPS:
601 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CAPS:") );
602 break;
603 default:
604 i = _IOC_NR(x);
605 if (i >= SOUND_MIXER_NRDEVICES || !(vidx = mixtable1[i]))
606 {
607 CS_DBGOUT(CS_IOCTL, 4, printk("UNKNOWN IOCTL: 0x%.8x NR=%d ",x,i) );
608 }
609 else
610 {
611 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_IOCTL AC9x: 0x%.8x NR=%d ",
612 x,i) );
613 }
614 break;
615 }
616 }
617 CS_DBGOUT(CS_IOCTL, 4, printk("command = 0x%x IOC_NR=%d\n",x, _IOC_NR(x)) );
618 }
619 #endif
620
621 /*
622 * common I/O routines
623 */
624
625 static void cs461x_poke(struct cs_card *codec, unsigned long reg, unsigned int val)
626 {
627 writel(val, codec->ba1.idx[(reg >> 16) & 3]+(reg&0xffff));
628 }
629
630 static unsigned int cs461x_peek(struct cs_card *codec, unsigned long reg)
631 {
632 return readl(codec->ba1.idx[(reg >> 16) & 3]+(reg&0xffff));
633 }
634
635 static void cs461x_pokeBA0(struct cs_card *codec, unsigned long reg, unsigned int val)
636 {
637 writel(val, codec->ba0+reg);
638 }
639
640 static unsigned int cs461x_peekBA0(struct cs_card *codec, unsigned long reg)
641 {
642 return readl(codec->ba0+reg);
643 }
644
645
646 static u16 cs_ac97_get(struct ac97_codec *dev, u8 reg);
647 static void cs_ac97_set(struct ac97_codec *dev, u8 reg, u16 data);
648
649 static struct cs_channel *cs_alloc_pcm_channel(struct cs_card *card)
650 {
651 if(card->channel[1].used==1)
652 return NULL;
653 card->channel[1].used=1;
654 card->channel[1].num=1;
655 return &card->channel[1];
656 }
657
658 static struct cs_channel *cs_alloc_rec_pcm_channel(struct cs_card *card)
659 {
660 if(card->channel[0].used==1)
661 return NULL;
662 card->channel[0].used=1;
663 card->channel[0].num=0;
664 return &card->channel[0];
665 }
666
667 static void cs_free_pcm_channel(struct cs_card *card, int channel)
668 {
669 card->channel[channel].state = NULL;
670 card->channel[channel].used=0;
671 }
672
673 /*
674 * setup a divisor value to help with conversion from
675 * 16bit Stereo, down to 8bit stereo/mono or 16bit mono.
676 * assign a divisor of 1 if using 16bit Stereo as that is
677 * the only format that the static image will capture.
678 */
679 static void cs_set_divisor(struct dmabuf *dmabuf)
680 {
681 if(dmabuf->type == CS_TYPE_DAC)
682 dmabuf->divisor = 1;
683 else if( !(dmabuf->fmt & CS_FMT_STEREO) &&
684 (dmabuf->fmt & CS_FMT_16BIT))
685 dmabuf->divisor = 2;
686 else if( (dmabuf->fmt & CS_FMT_STEREO) &&
687 !(dmabuf->fmt & CS_FMT_16BIT))
688 dmabuf->divisor = 2;
689 else if( !(dmabuf->fmt & CS_FMT_STEREO) &&
690 !(dmabuf->fmt & CS_FMT_16BIT))
691 dmabuf->divisor = 4;
692 else
693 dmabuf->divisor = 1;
694
695 CS_DBGOUT(CS_PARMS | CS_FUNCTION, 8, printk(
696 "cs46xx: cs_set_divisor()- %s %d\n",
697 (dmabuf->type == CS_TYPE_ADC) ? "ADC" : "DAC",
698 dmabuf->divisor) );
699 }
700
701 /*
702 * mute some of the more prevalent registers to avoid popping.
703 */
704 static void cs_mute(struct cs_card *card, int state)
705 {
706 struct ac97_codec *dev=card->ac97_codec[0];
707
708 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs46xx: cs_mute()+ %s\n",
709 (state == CS_TRUE) ? "Muting" : "UnMuting") );
710
711 if(state == CS_TRUE)
712 {
713 /*
714 * fix pops when powering up on thinkpads
715 */
716 card->pm.u32AC97_master_volume = (u32)cs_ac97_get( dev,
717 (u8)BA0_AC97_MASTER_VOLUME);
718 card->pm.u32AC97_headphone_volume = (u32)cs_ac97_get(dev,
719 (u8)BA0_AC97_HEADPHONE_VOLUME);
720 card->pm.u32AC97_master_volume_mono = (u32)cs_ac97_get(dev,
721 (u8)BA0_AC97_MASTER_VOLUME_MONO);
722 card->pm.u32AC97_pcm_out_volume = (u32)cs_ac97_get(dev,
723 (u8)BA0_AC97_PCM_OUT_VOLUME);
724
725 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME, 0x8000);
726 cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, 0x8000);
727 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, 0x8000);
728 cs_ac97_set(dev, (u8)BA0_AC97_PCM_OUT_VOLUME, 0x8000);
729 }
730 else
731 {
732 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME, card->pm.u32AC97_master_volume);
733 cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, card->pm.u32AC97_headphone_volume);
734 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, card->pm.u32AC97_master_volume_mono);
735 cs_ac97_set(dev, (u8)BA0_AC97_PCM_OUT_VOLUME, card->pm.u32AC97_pcm_out_volume);
736 }
737 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs46xx: cs_mute()-\n"));
738 }
739
740 /* set playback sample rate */
741 static unsigned int cs_set_dac_rate(struct cs_state * state, unsigned int rate)
742 {
743 struct dmabuf *dmabuf = &state->dmabuf;
744 unsigned int tmp1, tmp2;
745 unsigned int phiIncr;
746 unsigned int correctionPerGOF, correctionPerSec;
747 unsigned long flags;
748
749 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_dac_rate()+ %d\n",rate) );
750
751 /*
752 * Compute the values used to drive the actual sample rate conversion.
753 * The following formulas are being computed, using inline assembly
754 * since we need to use 64 bit arithmetic to compute the values:
755 *
756 * phiIncr = floor((Fs,in * 2^26) / Fs,out)
757 * correctionPerGOF = floor((Fs,in * 2^26 - Fs,out * phiIncr) /
758 * GOF_PER_SEC)
759 * ulCorrectionPerSec = Fs,in * 2^26 - Fs,out * phiIncr -M
760 * GOF_PER_SEC * correctionPerGOF
761 *
762 * i.e.
763 *
764 * phiIncr:other = dividend:remainder((Fs,in * 2^26) / Fs,out)
765 * correctionPerGOF:correctionPerSec =
766 * dividend:remainder(ulOther / GOF_PER_SEC)
767 */
768 tmp1 = rate << 16;
769 phiIncr = tmp1 / 48000;
770 tmp1 -= phiIncr * 48000;
771 tmp1 <<= 10;
772 phiIncr <<= 10;
773 tmp2 = tmp1 / 48000;
774 phiIncr += tmp2;
775 tmp1 -= tmp2 * 48000;
776 correctionPerGOF = tmp1 / GOF_PER_SEC;
777 tmp1 -= correctionPerGOF * GOF_PER_SEC;
778 correctionPerSec = tmp1;
779
780 /*
781 * Fill in the SampleRateConverter control block.
782 */
783
784 spin_lock_irqsave(&state->card->lock, flags);
785 cs461x_poke(state->card, BA1_PSRC,
786 ((correctionPerSec << 16) & 0xFFFF0000) | (correctionPerGOF & 0xFFFF));
787 cs461x_poke(state->card, BA1_PPI, phiIncr);
788 spin_unlock_irqrestore(&state->card->lock, flags);
789 dmabuf->rate = rate;
790
791 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_dac_rate()- %d\n",rate) );
792 return rate;
793 }
794
795 /* set recording sample rate */
796 static unsigned int cs_set_adc_rate(struct cs_state * state, unsigned int rate)
797 {
798 struct dmabuf *dmabuf = &state->dmabuf;
799 struct cs_card *card = state->card;
800 unsigned int phiIncr, coeffIncr, tmp1, tmp2;
801 unsigned int correctionPerGOF, correctionPerSec, initialDelay;
802 unsigned int frameGroupLength, cnt;
803 unsigned long flags;
804 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_adc_rate()+ %d\n",rate) );
805
806 /*
807 * We can only decimate by up to a factor of 1/9th the hardware rate.
808 * Correct the value if an attempt is made to stray outside that limit.
809 */
810 if ((rate * 9) < 48000)
811 rate = 48000 / 9;
812
813 /*
814 * We can not capture at at rate greater than the Input Rate (48000).
815 * Return an error if an attempt is made to stray outside that limit.
816 */
817 if (rate > 48000)
818 rate = 48000;
819
820 /*
821 * Compute the values used to drive the actual sample rate conversion.
822 * The following formulas are being computed, using inline assembly
823 * since we need to use 64 bit arithmetic to compute the values:
824 *
825 * coeffIncr = -floor((Fs,out * 2^23) / Fs,in)
826 * phiIncr = floor((Fs,in * 2^26) / Fs,out)
827 * correctionPerGOF = floor((Fs,in * 2^26 - Fs,out * phiIncr) /
828 * GOF_PER_SEC)
829 * correctionPerSec = Fs,in * 2^26 - Fs,out * phiIncr -
830 * GOF_PER_SEC * correctionPerGOF
831 * initialDelay = ceil((24 * Fs,in) / Fs,out)
832 *
833 * i.e.
834 *
835 * coeffIncr = neg(dividend((Fs,out * 2^23) / Fs,in))
836 * phiIncr:ulOther = dividend:remainder((Fs,in * 2^26) / Fs,out)
837 * correctionPerGOF:correctionPerSec =
838 * dividend:remainder(ulOther / GOF_PER_SEC)
839 * initialDelay = dividend(((24 * Fs,in) + Fs,out - 1) / Fs,out)
840 */
841
842 tmp1 = rate << 16;
843 coeffIncr = tmp1 / 48000;
844 tmp1 -= coeffIncr * 48000;
845 tmp1 <<= 7;
846 coeffIncr <<= 7;
847 coeffIncr += tmp1 / 48000;
848 coeffIncr ^= 0xFFFFFFFF;
849 coeffIncr++;
850 tmp1 = 48000 << 16;
851 phiIncr = tmp1 / rate;
852 tmp1 -= phiIncr * rate;
853 tmp1 <<= 10;
854 phiIncr <<= 10;
855 tmp2 = tmp1 / rate;
856 phiIncr += tmp2;
857 tmp1 -= tmp2 * rate;
858 correctionPerGOF = tmp1 / GOF_PER_SEC;
859 tmp1 -= correctionPerGOF * GOF_PER_SEC;
860 correctionPerSec = tmp1;
861 initialDelay = ((48000 * 24) + rate - 1) / rate;
862
863 /*
864 * Fill in the VariDecimate control block.
865 */
866 spin_lock_irqsave(&card->lock, flags);
867 cs461x_poke(card, BA1_CSRC,
868 ((correctionPerSec << 16) & 0xFFFF0000) | (correctionPerGOF & 0xFFFF));
869 cs461x_poke(card, BA1_CCI, coeffIncr);
870 cs461x_poke(card, BA1_CD,
871 (((BA1_VARIDEC_BUF_1 + (initialDelay << 2)) << 16) & 0xFFFF0000) | 0x80);
872 cs461x_poke(card, BA1_CPI, phiIncr);
873 spin_unlock_irqrestore(&card->lock, flags);
874
875 /*
876 * Figure out the frame group length for the write back task. Basically,
877 * this is just the factors of 24000 (2^6*3*5^3) that are not present in
878 * the output sample rate.
879 */
880 frameGroupLength = 1;
881 for (cnt = 2; cnt <= 64; cnt *= 2) {
882 if (((rate / cnt) * cnt) != rate)
883 frameGroupLength *= 2;
884 }
885 if (((rate / 3) * 3) != rate) {
886 frameGroupLength *= 3;
887 }
888 for (cnt = 5; cnt <= 125; cnt *= 5) {
889 if (((rate / cnt) * cnt) != rate)
890 frameGroupLength *= 5;
891 }
892
893 /*
894 * Fill in the WriteBack control block.
895 */
896 spin_lock_irqsave(&card->lock, flags);
897 cs461x_poke(card, BA1_CFG1, frameGroupLength);
898 cs461x_poke(card, BA1_CFG2, (0x00800000 | frameGroupLength));
899 cs461x_poke(card, BA1_CCST, 0x0000FFFF);
900 cs461x_poke(card, BA1_CSPB, ((65536 * rate) / 24000));
901 cs461x_poke(card, (BA1_CSPB + 4), 0x0000FFFF);
902 spin_unlock_irqrestore(&card->lock, flags);
903 dmabuf->rate = rate;
904 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_adc_rate()- %d\n",rate) );
905 return rate;
906 }
907
908 /* prepare channel attributes for playback */
909 static void cs_play_setup(struct cs_state *state)
910 {
911 struct dmabuf *dmabuf = &state->dmabuf;
912 struct cs_card *card = state->card;
913 unsigned int tmp, Count, playFormat;
914
915 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_play_setup()+\n") );
916 cs461x_poke(card, BA1_PVOL, 0x80008000);
917 if(!dmabuf->SGok)
918 cs461x_poke(card, BA1_PBA, virt_to_bus(dmabuf->pbuf));
919
920 Count = 4;
921 playFormat=cs461x_peek(card, BA1_PFIE);
922 if ((dmabuf->fmt & CS_FMT_STEREO)) {
923 playFormat &= ~DMA_RQ_C2_AC_MONO_TO_STEREO;
924 Count *= 2;
925 }
926 else
927 playFormat |= DMA_RQ_C2_AC_MONO_TO_STEREO;
928
929 if ((dmabuf->fmt & CS_FMT_16BIT)) {
930 playFormat &= ~(DMA_RQ_C2_AC_8_TO_16_BIT
931 | DMA_RQ_C2_AC_SIGNED_CONVERT);
932 Count *= 2;
933 }
934 else
935 playFormat |= (DMA_RQ_C2_AC_8_TO_16_BIT
936 | DMA_RQ_C2_AC_SIGNED_CONVERT);
937
938 cs461x_poke(card, BA1_PFIE, playFormat);
939
940 tmp = cs461x_peek(card, BA1_PDTC);
941 tmp &= 0xfffffe00;
942 cs461x_poke(card, BA1_PDTC, tmp | --Count);
943
944 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_play_setup()-\n") );
945
946 }
947
948 struct InitStruct
949 {
950 u32 long off;
951 u32 long val;
952 } InitArray[] = { {0x00000040, 0x3fc0000f},
953 {0x0000004c, 0x04800000},
954
955 {0x000000b3, 0x00000780},
956 {0x000000b7, 0x00000000},
957 {0x000000bc, 0x07800000},
958
959 {0x000000cd, 0x00800000},
960 };
961
962 /*
963 * "SetCaptureSPValues()" -- Initialize record task values before each
964 * capture startup.
965 */
966 void SetCaptureSPValues(struct cs_card *card)
967 {
968 unsigned i, offset;
969 CS_DBGOUT(CS_FUNCTION, 8, printk("cs46xx: SetCaptureSPValues()+\n") );
970 for(i=0; i<sizeof(InitArray)/sizeof(struct InitStruct); i++)
971 {
972 offset = InitArray[i].off*4; /* 8bit to 32bit offset value */
973 cs461x_poke(card, offset, InitArray[i].val );
974 }
975 CS_DBGOUT(CS_FUNCTION, 8, printk("cs46xx: SetCaptureSPValues()-\n") );
976 }
977
978 /* prepare channel attributes for recording */
979 static void cs_rec_setup(struct cs_state *state)
980 {
981 struct cs_card *card = state->card;
982 struct dmabuf *dmabuf = &state->dmabuf;
983 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_rec_setup()+\n") );
984
985 SetCaptureSPValues(card);
986
987 /*
988 * set the attenuation to 0dB
989 */
990 cs461x_poke(card, BA1_CVOL, 0x80008000);
991
992 /*
993 * set the physical address of the capture buffer into the SP
994 */
995 cs461x_poke(card, BA1_CBA, virt_to_bus(dmabuf->rawbuf));
996
997 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_rec_setup()-\n") );
998 }
999
1000
1001 /* get current playback/recording dma buffer pointer (byte offset from LBA),
1002 called with spinlock held! */
1003
1004 static inline unsigned cs_get_dma_addr(struct cs_state *state)
1005 {
1006 struct dmabuf *dmabuf = &state->dmabuf;
1007 u32 offset;
1008
1009 if ( (!(dmabuf->enable & DAC_RUNNING)) &&
1010 (!(dmabuf->enable & ADC_RUNNING) ) )
1011 {
1012 CS_DBGOUT(CS_ERROR, 2, printk(
1013 "cs46xx: ERROR cs_get_dma_addr(): not enabled \n") );
1014 return 0;
1015 }
1016
1017 /*
1018 * ganularity is byte boundry, good part.
1019 */
1020 if(dmabuf->enable & DAC_RUNNING)
1021 {
1022 offset = cs461x_peek(state->card, BA1_PBA);
1023 }
1024 else /* ADC_RUNNING must be set */
1025 {
1026 offset = cs461x_peek(state->card, BA1_CBA);
1027 }
1028 CS_DBGOUT(CS_PARMS | CS_FUNCTION, 9,
1029 printk("cs46xx: cs_get_dma_addr() %d\n",offset) );
1030 offset = (u32)bus_to_virt((unsigned long)offset) - (u32)dmabuf->rawbuf;
1031 CS_DBGOUT(CS_PARMS | CS_FUNCTION, 8,
1032 printk("cs46xx: cs_get_dma_addr()- %d\n",offset) );
1033 return offset;
1034 }
1035
1036 static void resync_dma_ptrs(struct cs_state *state)
1037 {
1038 struct dmabuf *dmabuf;
1039
1040 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: resync_dma_ptrs()+ \n") );
1041 if(state)
1042 {
1043 dmabuf = &state->dmabuf;
1044 dmabuf->hwptr=dmabuf->swptr = 0;
1045 dmabuf->pringbuf = 0;
1046 }
1047 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: resync_dma_ptrs()- \n") );
1048 }
1049
1050 /* Stop recording (lock held) */
1051 static inline void __stop_adc(struct cs_state *state)
1052 {
1053 struct dmabuf *dmabuf = &state->dmabuf;
1054 struct cs_card *card = state->card;
1055 unsigned int tmp;
1056
1057 dmabuf->enable &= ~ADC_RUNNING;
1058
1059 tmp = cs461x_peek(card, BA1_CCTL);
1060 tmp &= 0xFFFF0000;
1061 cs461x_poke(card, BA1_CCTL, tmp );
1062 }
1063
1064 static void stop_adc(struct cs_state *state)
1065 {
1066 unsigned long flags;
1067
1068 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_adc()+ \n") );
1069 spin_lock_irqsave(&state->card->lock, flags);
1070 __stop_adc(state);
1071 spin_unlock_irqrestore(&state->card->lock, flags);
1072 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_adc()- \n") );
1073 }
1074
1075 static void start_adc(struct cs_state *state)
1076 {
1077 struct dmabuf *dmabuf = &state->dmabuf;
1078 struct cs_card *card = state->card;
1079 unsigned long flags;
1080 unsigned int tmp;
1081
1082 spin_lock_irqsave(&card->lock, flags);
1083 if (!(dmabuf->enable & ADC_RUNNING) &&
1084 ((dmabuf->mapped || dmabuf->count < (signed)dmabuf->dmasize)
1085 && dmabuf->ready) &&
1086 ((card->pm.flags & CS46XX_PM_IDLE) ||
1087 (card->pm.flags & CS46XX_PM_RESUMED)) )
1088 {
1089 dmabuf->enable |= ADC_RUNNING;
1090 cs_set_divisor(dmabuf);
1091 tmp = cs461x_peek(card, BA1_CCTL);
1092 tmp &= 0xFFFF0000;
1093 tmp |= card->cctl;
1094 CS_DBGOUT(CS_FUNCTION, 2, printk(
1095 "cs46xx: start_adc() poke 0x%x \n",tmp) );
1096 cs461x_poke(card, BA1_CCTL, tmp);
1097 }
1098 spin_unlock_irqrestore(&card->lock, flags);
1099 }
1100
1101 /* stop playback (lock held) */
1102 static inline void __stop_dac(struct cs_state *state)
1103 {
1104 struct dmabuf *dmabuf = &state->dmabuf;
1105 struct cs_card *card = state->card;
1106 unsigned int tmp;
1107
1108 dmabuf->enable &= ~DAC_RUNNING;
1109
1110 tmp=cs461x_peek(card, BA1_PCTL);
1111 tmp&=0xFFFF;
1112 cs461x_poke(card, BA1_PCTL, tmp);
1113 }
1114
1115 static void stop_dac(struct cs_state *state)
1116 {
1117 unsigned long flags;
1118
1119 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_dac()+ \n") );
1120 spin_lock_irqsave(&state->card->lock, flags);
1121 __stop_dac(state);
1122 spin_unlock_irqrestore(&state->card->lock, flags);
1123 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_dac()- \n") );
1124 }
1125
1126 static void start_dac(struct cs_state *state)
1127 {
1128 struct dmabuf *dmabuf = &state->dmabuf;
1129 struct cs_card *card = state->card;
1130 unsigned long flags;
1131 int tmp;
1132
1133 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: start_dac()+ \n") );
1134 spin_lock_irqsave(&card->lock, flags);
1135 if (!(dmabuf->enable & DAC_RUNNING) &&
1136 ((dmabuf->mapped || dmabuf->count > 0) && dmabuf->ready) &&
1137 ((card->pm.flags & CS46XX_PM_IDLE) ||
1138 (card->pm.flags & CS46XX_PM_RESUMED)) )
1139 {
1140 dmabuf->enable |= DAC_RUNNING;
1141 tmp = cs461x_peek(card, BA1_PCTL);
1142 tmp &= 0xFFFF;
1143 tmp |= card->pctl;
1144 CS_DBGOUT(CS_PARMS, 6, printk(
1145 "cs46xx: start_dac() poke card=0x%.08x tmp=0x%.08x addr=0x%.08x \n",
1146 (unsigned)card, (unsigned)tmp,
1147 (unsigned)card->ba1.idx[(BA1_PCTL >> 16) & 3]+(BA1_PCTL&0xffff) ) );
1148 cs461x_poke(card, BA1_PCTL, tmp);
1149 }
1150 spin_unlock_irqrestore(&card->lock, flags);
1151 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: start_dac()- \n") );
1152 }
1153
1154 #define DMABUF_MINORDER 1
1155
1156 /*
1157 * allocate DMA buffer, playback and recording buffers are separate.
1158 */
1159 static int alloc_dmabuf(struct cs_state *state)
1160 {
1161
1162 struct cs_card *card=state->card;
1163 struct dmabuf *dmabuf = &state->dmabuf;
1164 void *rawbuf = NULL;
1165 void *tmpbuff = NULL;
1166 int order;
1167 struct page *map, *mapend;
1168 unsigned long df;
1169
1170 dmabuf->ready = dmabuf->mapped = 0;
1171 dmabuf->SGok = 0;
1172 /*
1173 * check for order within limits, but do not overwrite value.
1174 */
1175 if((defaultorder > 1) && (defaultorder < 12))
1176 df = defaultorder;
1177 else
1178 df = 2;
1179
1180 for (order = df; order >= DMABUF_MINORDER; order--)
1181 if ( (rawbuf = (void *) pci_alloc_consistent(
1182 card->pci_dev, PAGE_SIZE << order, &dmabuf->dmaaddr)))
1183 break;
1184 if (!rawbuf) {
1185 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
1186 "cs46xx: alloc_dmabuf(): unable to allocate rawbuf\n"));
1187 return -ENOMEM;
1188 }
1189 dmabuf->buforder = order;
1190 dmabuf->rawbuf = rawbuf;
1191 // Now mark the pages as reserved; otherwise the
1192 // remap_page_range() in cs46xx_mmap doesn't work.
1193 // 1. get index to last page in mem_map array for rawbuf.
1194 mapend = virt_to_page(dmabuf->rawbuf +
1195 (PAGE_SIZE << dmabuf->buforder) - 1);
1196
1197 // 2. mark each physical page in range as 'reserved'.
1198 for (map = virt_to_page(dmabuf->rawbuf); map <= mapend; map++)
1199 cs4x_mem_map_reserve(map);
1200
1201 CS_DBGOUT(CS_PARMS, 9, printk("cs46xx: alloc_dmabuf(): allocated %ld (order = %d) bytes at %p\n",
1202 PAGE_SIZE << order, order, rawbuf) );
1203
1204 /*
1205 * only allocate the conversion buffer for the ADC
1206 */
1207 if(dmabuf->type == CS_TYPE_DAC)
1208 {
1209 dmabuf->tmpbuff = NULL;
1210 dmabuf->buforder_tmpbuff = 0;
1211 return 0;
1212 }
1213 /*
1214 * now the temp buffer for 16/8 conversions
1215 */
1216
1217 tmpbuff = (void *) pci_alloc_consistent(
1218 card->pci_dev, PAGE_SIZE << order, &dmabuf->dmaaddr_tmpbuff);
1219
1220 if (!tmpbuff)
1221 return -ENOMEM;
1222 CS_DBGOUT(CS_PARMS, 9, printk("cs46xx: allocated %ld (order = %d) bytes at %p\n",
1223 PAGE_SIZE << order, order, tmpbuff) );
1224
1225 dmabuf->tmpbuff = tmpbuff;
1226 dmabuf->buforder_tmpbuff = order;
1227
1228 // Now mark the pages as reserved; otherwise the
1229 // remap_page_range() in cs46xx_mmap doesn't work.
1230 // 1. get index to last page in mem_map array for rawbuf.
1231 mapend = virt_to_page(dmabuf->tmpbuff +
1232 (PAGE_SIZE << dmabuf->buforder_tmpbuff) - 1);
1233
1234 // 2. mark each physical page in range as 'reserved'.
1235 for (map = virt_to_page(dmabuf->tmpbuff); map <= mapend; map++)
1236 cs4x_mem_map_reserve(map);
1237 return 0;
1238 }
1239
1240 /* free DMA buffer */
1241 static void dealloc_dmabuf(struct cs_state *state)
1242 {
1243 struct dmabuf *dmabuf = &state->dmabuf;
1244 struct page *map, *mapend;
1245
1246 if (dmabuf->rawbuf) {
1247 // Undo prog_dmabuf()'s marking the pages as reserved
1248 mapend = virt_to_page(dmabuf->rawbuf +
1249 (PAGE_SIZE << dmabuf->buforder) - 1);
1250 for (map = virt_to_page(dmabuf->rawbuf); map <= mapend; map++)
1251 cs4x_mem_map_unreserve(map);
1252 free_dmabuf(state->card, dmabuf);
1253 }
1254
1255 if (dmabuf->tmpbuff) {
1256 // Undo prog_dmabuf()'s marking the pages as reserved
1257 mapend = virt_to_page(dmabuf->tmpbuff +
1258 (PAGE_SIZE << dmabuf->buforder_tmpbuff) - 1);
1259 for (map = virt_to_page(dmabuf->tmpbuff); map <= mapend; map++)
1260 cs4x_mem_map_unreserve(map);
1261 free_dmabuf2(state->card, dmabuf);
1262 }
1263
1264 dmabuf->rawbuf = NULL;
1265 dmabuf->tmpbuff = NULL;
1266 dmabuf->mapped = dmabuf->ready = 0;
1267 dmabuf->SGok = 0;
1268 }
1269
1270 static int __prog_dmabuf(struct cs_state *state)
1271 {
1272 struct dmabuf *dmabuf = &state->dmabuf;
1273 unsigned long flags;
1274 unsigned long allocated_pages, allocated_bytes;
1275 unsigned long tmp1, tmp2, fmt=0;
1276 unsigned long *ptmp = (unsigned long *) dmabuf->pbuf;
1277 unsigned long SGarray[9], nSGpages=0;
1278 int ret;
1279
1280 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()+ \n"));
1281 /*
1282 * check for CAPTURE and use only non-sg for initial release
1283 */
1284 if(dmabuf->type == CS_TYPE_ADC)
1285 {
1286 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf() ADC\n"));
1287 /*
1288 * add in non-sg support for capture.
1289 */
1290 spin_lock_irqsave(&state->card->lock, flags);
1291 /* add code to reset the rawbuf memory. TRW */
1292 resync_dma_ptrs(state);
1293 dmabuf->total_bytes = dmabuf->blocks = 0;
1294 dmabuf->count = dmabuf->error = dmabuf->underrun = 0;
1295
1296 dmabuf->SGok = 0;
1297
1298 spin_unlock_irqrestore(&state->card->lock, flags);
1299
1300 /* allocate DMA buffer if not allocated yet */
1301 if (!dmabuf->rawbuf || !dmabuf->tmpbuff)
1302 if ((ret = alloc_dmabuf(state)))
1303 return ret;
1304 /*
1305 * static image only supports 16Bit signed, stereo - hard code fmt
1306 */
1307 fmt = CS_FMT_16BIT | CS_FMT_STEREO;
1308
1309 dmabuf->numfrag = 2;
1310 dmabuf->fragsize = 2048;
1311 dmabuf->fragsamples = 2048 >> sample_shift[fmt];
1312 dmabuf->dmasize = 4096;
1313 dmabuf->fragshift = 11;
1314
1315 memset(dmabuf->rawbuf, (fmt & CS_FMT_16BIT) ? 0 : 0x80,
1316 dmabuf->dmasize);
1317 memset(dmabuf->tmpbuff, (fmt & CS_FMT_16BIT) ? 0 : 0x80,
1318 PAGE_SIZE<<dmabuf->buforder_tmpbuff);
1319
1320 /*
1321 * Now set up the ring
1322 */
1323
1324 spin_lock_irqsave(&state->card->lock, flags);
1325 cs_rec_setup(state);
1326 spin_unlock_irqrestore(&state->card->lock, flags);
1327
1328 /* set the ready flag for the dma buffer */
1329 dmabuf->ready = 1;
1330
1331 CS_DBGOUT(CS_PARMS, 4, printk(
1332 "cs46xx: prog_dmabuf(): CAPTURE rate=%d fmt=0x%x numfrag=%d "
1333 "fragsize=%d dmasize=%d\n",
1334 dmabuf->rate, dmabuf->fmt, dmabuf->numfrag,
1335 dmabuf->fragsize, dmabuf->dmasize) );
1336
1337 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- 0 \n"));
1338 return 0;
1339 }
1340 else if (dmabuf->type == CS_TYPE_DAC)
1341 {
1342 /*
1343 * Must be DAC
1344 */
1345 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf() DAC\n"));
1346 spin_lock_irqsave(&state->card->lock, flags);
1347 resync_dma_ptrs(state);
1348 dmabuf->total_bytes = dmabuf->blocks = 0;
1349 dmabuf->count = dmabuf->error = dmabuf->underrun = 0;
1350
1351 dmabuf->SGok = 0;
1352
1353 spin_unlock_irqrestore(&state->card->lock, flags);
1354
1355 /* allocate DMA buffer if not allocated yet */
1356 if (!dmabuf->rawbuf)
1357 if ((ret = alloc_dmabuf(state)))
1358 return ret;
1359
1360 allocated_pages = 1 << dmabuf->buforder;
1361 allocated_bytes = allocated_pages*PAGE_SIZE;
1362
1363 if(allocated_pages < 2)
1364 {
1365 CS_DBGOUT(CS_FUNCTION, 4, printk(
1366 "cs46xx: prog_dmabuf() Error: allocated_pages too small (%d)\n",
1367 (unsigned)allocated_pages));
1368 return -ENOMEM;
1369 }
1370
1371 /* Use all the pages allocated, fragsize 4k. */
1372 /* Use 'pbuf' for S/G page map table. */
1373 dmabuf->SGok = 1; /* Use S/G. */
1374
1375 nSGpages = allocated_bytes/4096; /* S/G pages always 4k. */
1376
1377 /* Set up S/G variables. */
1378 *ptmp = virt_to_bus(dmabuf->rawbuf);
1379 *(ptmp+1) = 0x00000008;
1380 for(tmp1= 1; tmp1 < nSGpages; tmp1++) {
1381 *(ptmp+2*tmp1) = virt_to_bus( (dmabuf->rawbuf)+4096*tmp1);
1382 if( tmp1 == nSGpages-1)
1383 tmp2 = 0xbfff0000;
1384 else
1385 tmp2 = 0x80000000+8*(tmp1+1);
1386 *(ptmp+2*tmp1+1) = tmp2;
1387 }
1388 SGarray[0] = 0x82c0200d;
1389 SGarray[1] = 0xffff0000;
1390 SGarray[2] = *ptmp;
1391 SGarray[3] = 0x00010600;
1392 SGarray[4] = *(ptmp+2);
1393 SGarray[5] = 0x80000010;
1394 SGarray[6] = *ptmp;
1395 SGarray[7] = *(ptmp+2);
1396 SGarray[8] = (virt_to_bus(dmabuf->pbuf) & 0xffff000) | 0x10;
1397
1398 if (dmabuf->SGok) {
1399 dmabuf->numfrag = nSGpages;
1400 dmabuf->fragsize = 4096;
1401 dmabuf->fragsamples = 4096 >> sample_shift[dmabuf->fmt];
1402 dmabuf->fragshift = 12;
1403 dmabuf->dmasize = dmabuf->numfrag*4096;
1404 }
1405 else {
1406 SGarray[0] = 0xf2c0000f;
1407 SGarray[1] = 0x00000200;
1408 SGarray[2] = 0;
1409 SGarray[3] = 0x00010600;
1410 SGarray[4]=SGarray[5]=SGarray[6]=SGarray[7]=SGarray[8] = 0;
1411 dmabuf->numfrag = 2;
1412 dmabuf->fragsize = 2048;
1413 dmabuf->fragsamples = 2048 >> sample_shift[dmabuf->fmt];
1414 dmabuf->dmasize = 4096;
1415 dmabuf->fragshift = 11;
1416 }
1417 for(tmp1 = 0; tmp1 < sizeof(SGarray)/4; tmp1++)
1418 cs461x_poke( state->card, BA1_PDTC+tmp1*4, SGarray[tmp1]);
1419
1420 memset(dmabuf->rawbuf, (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
1421 dmabuf->dmasize);
1422
1423 /*
1424 * Now set up the ring
1425 */
1426
1427 spin_lock_irqsave(&state->card->lock, flags);
1428 cs_play_setup(state);
1429 spin_unlock_irqrestore(&state->card->lock, flags);
1430
1431 /* set the ready flag for the dma buffer */
1432 dmabuf->ready = 1;
1433
1434 CS_DBGOUT(CS_PARMS, 4, printk(
1435 "cs46xx: prog_dmabuf(): PLAYBACK rate=%d fmt=0x%x numfrag=%d "
1436 "fragsize=%d dmasize=%d\n",
1437 dmabuf->rate, dmabuf->fmt, dmabuf->numfrag,
1438 dmabuf->fragsize, dmabuf->dmasize) );
1439
1440 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- \n"));
1441 return 0;
1442 }
1443 else
1444 {
1445 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- Invalid Type %d\n",
1446 dmabuf->type));
1447 }
1448 return 1;
1449 }
1450
1451 static int prog_dmabuf(struct cs_state *state)
1452 {
1453 int ret;
1454
1455 down(&state->sem);
1456 ret = __prog_dmabuf(state);
1457 up(&state->sem);
1458
1459 return ret;
1460 }
1461
1462 static void cs_clear_tail(struct cs_state *state)
1463 {
1464 }
1465
1466 static int drain_dac(struct cs_state *state, int nonblock)
1467 {
1468 DECLARE_WAITQUEUE(wait, current);
1469 struct dmabuf *dmabuf = &state->dmabuf;
1470 struct cs_card *card=state->card;
1471 unsigned long flags;
1472 unsigned long tmo;
1473 int count;
1474
1475 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()+ \n"));
1476 if (dmabuf->mapped || !dmabuf->ready)
1477 {
1478 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()- 0, not ready\n"));
1479 return 0;
1480 }
1481
1482 add_wait_queue(&dmabuf->wait, &wait);
1483 for (;;) {
1484 /* It seems that we have to set the current state to TASK_INTERRUPTIBLE
1485 every time to make the process really go to sleep */
1486 current->state = TASK_INTERRUPTIBLE;
1487
1488 spin_lock_irqsave(&state->card->lock, flags);
1489 count = dmabuf->count;
1490 spin_unlock_irqrestore(&state->card->lock, flags);
1491
1492 if (count <= 0)
1493 break;
1494
1495 if (signal_pending(current))
1496 break;
1497
1498 if (nonblock) {
1499 remove_wait_queue(&dmabuf->wait, &wait);
1500 current->state = TASK_RUNNING;
1501 return -EBUSY;
1502 }
1503
1504 tmo = (dmabuf->dmasize * HZ) / dmabuf->rate;
1505 tmo >>= sample_shift[dmabuf->fmt];
1506 tmo += (2048*HZ)/dmabuf->rate;
1507
1508 if (!schedule_timeout(tmo ? tmo : 1) && tmo){
1509 printk(KERN_ERR "cs46xx: drain_dac, dma timeout? %d\n", count);
1510 break;
1511 }
1512 }
1513 remove_wait_queue(&dmabuf->wait, &wait);
1514 current->state = TASK_RUNNING;
1515 if (signal_pending(current))
1516 {
1517 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()- -ERESTARTSYS\n"));
1518 /*
1519 * set to silence and let that clear the fifos.
1520 */
1521 cs461x_clear_serial_FIFOs(card, CS_TYPE_DAC);
1522 return -ERESTARTSYS;
1523 }
1524
1525 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()- 0\n"));
1526 return 0;
1527 }
1528
1529
1530 /* update buffer manangement pointers, especially, dmabuf->count and dmabuf->hwptr */
1531 static void cs_update_ptr(struct cs_card *card, int wake)
1532 {
1533 struct cs_state *state;
1534 struct dmabuf *dmabuf;
1535 unsigned hwptr;
1536 int diff;
1537
1538 /* error handling and process wake up for ADC */
1539 state = card->states[0];
1540 if(state)
1541 {
1542 dmabuf = &state->dmabuf;
1543 if (dmabuf->enable & ADC_RUNNING) {
1544 /* update hardware pointer */
1545 hwptr = cs_get_dma_addr(state);
1546
1547 diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1548 CS_DBGOUT(CS_PARMS, 9, printk(
1549 "cs46xx: cs_update_ptr()+ ADC hwptr=%d diff=%d\n",
1550 hwptr,diff) );
1551 dmabuf->hwptr = hwptr;
1552 dmabuf->total_bytes += diff;
1553 dmabuf->count += diff;
1554 if (dmabuf->count > dmabuf->dmasize)
1555 dmabuf->count = dmabuf->dmasize;
1556
1557 if(dmabuf->mapped)
1558 {
1559 if (wake && dmabuf->count >= (signed)dmabuf->fragsize)
1560 wake_up(&dmabuf->wait);
1561 } else
1562 {
1563 if (wake && dmabuf->count > 0)
1564 wake_up(&dmabuf->wait);
1565 }
1566 }
1567 }
1568
1569 /*
1570 * Now the DAC
1571 */
1572 state = card->states[1];
1573 if(state)
1574 {
1575 dmabuf = &state->dmabuf;
1576 /* error handling and process wake up for DAC */
1577 if (dmabuf->enable & DAC_RUNNING) {
1578 /* update hardware pointer */
1579 hwptr = cs_get_dma_addr(state);
1580
1581 diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1582 CS_DBGOUT(CS_PARMS, 9, printk(
1583 "cs46xx: cs_update_ptr()+ DAC hwptr=%d diff=%d\n",
1584 hwptr,diff) );
1585 dmabuf->hwptr = hwptr;
1586 dmabuf->total_bytes += diff;
1587 if (dmabuf->mapped) {
1588 dmabuf->count += diff;
1589 if (wake && dmabuf->count >= (signed)dmabuf->fragsize)
1590 wake_up(&dmabuf->wait);
1591 /*
1592 * other drivers use fragsize, but don't see any sense
1593 * in that, since dmasize is the buffer asked for
1594 * via mmap.
1595 */
1596 if( dmabuf->count > dmabuf->dmasize)
1597 dmabuf->count &= dmabuf->dmasize-1;
1598 } else {
1599 dmabuf->count -= diff;
1600 /*
1601 * backfill with silence and clear out the last
1602 * "diff" number of bytes.
1603 */
1604 if(hwptr >= diff)
1605 {
1606 memset(dmabuf->rawbuf + hwptr - diff,
1607 (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80, diff);
1608 }
1609 else
1610 {
1611 memset(dmabuf->rawbuf,
1612 (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
1613 (unsigned)hwptr);
1614 memset((void *)((unsigned)dmabuf->rawbuf +
1615 dmabuf->dmasize + hwptr - diff),
1616 (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
1617 diff - hwptr);
1618 }
1619
1620 if (dmabuf->count < 0 || dmabuf->count > dmabuf->dmasize) {
1621 CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
1622 "cs46xx: ERROR DAC count<0 or count > dmasize (%d)\n",
1623 dmabuf->count));
1624 /*
1625 * buffer underrun or buffer overrun, reset the
1626 * count of bytes written back to 0.
1627 */
1628 if(dmabuf->count < 0)
1629 dmabuf->underrun=1;
1630 dmabuf->count = 0;
1631 dmabuf->error++;
1632 }
1633 if (wake && dmabuf->count < (signed)dmabuf->dmasize/2)
1634 wake_up(&dmabuf->wait);
1635 }
1636 }
1637 }
1638 }
1639
1640
1641 /* hold spinlock for the following! */
1642 static void cs_handle_midi(struct cs_card *card)
1643 {
1644 unsigned char ch;
1645 int wake;
1646 unsigned temp1;
1647
1648 wake = 0;
1649 while (!(cs461x_peekBA0(card, BA0_MIDSR) & MIDSR_RBE)) {
1650 ch = cs461x_peekBA0(card, BA0_MIDRP);
1651 if (card->midi.icnt < CS_MIDIINBUF) {
1652 card->midi.ibuf[card->midi.iwr] = ch;
1653 card->midi.iwr = (card->midi.iwr + 1) % CS_MIDIINBUF;
1654 card->midi.icnt++;
1655 }
1656 wake = 1;
1657 }
1658 if (wake)
1659 wake_up(&card->midi.iwait);
1660 wake = 0;
1661 while (!(cs461x_peekBA0(card, BA0_MIDSR) & MIDSR_TBF) && card->midi.ocnt > 0) {
1662 temp1 = ( card->midi.obuf[card->midi.ord] ) & 0x000000ff;
1663 cs461x_pokeBA0(card, BA0_MIDWP,temp1);
1664 card->midi.ord = (card->midi.ord + 1) % CS_MIDIOUTBUF;
1665 card->midi.ocnt--;
1666 if (card->midi.ocnt < CS_MIDIOUTBUF-16)
1667 wake = 1;
1668 }
1669 if (wake)
1670 wake_up(&card->midi.owait);
1671 }
1672
1673 static void cs_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1674 {
1675 struct cs_card *card = (struct cs_card *)dev_id;
1676 /* Single channel card */
1677 struct cs_state *recstate = card->channel[0].state;
1678 struct cs_state *playstate = card->channel[1].state;
1679 u32 status;
1680
1681 CS_DBGOUT(CS_INTERRUPT, 9, printk("cs46xx: cs_interrupt()+ \n"));
1682
1683 spin_lock(&card->lock);
1684
1685 status = cs461x_peekBA0(card, BA0_HISR);
1686
1687 if ((status & 0x7fffffff) == 0)
1688 {
1689 cs461x_pokeBA0(card, BA0_HICR, HICR_CHGM|HICR_IEV);
1690 spin_unlock(&card->lock);
1691 return;
1692 }
1693
1694 /*
1695 * check for playback or capture interrupt only
1696 */
1697 if( ((status & HISR_VC0) && playstate && playstate->dmabuf.ready) ||
1698 (((status & HISR_VC1) && recstate && recstate->dmabuf.ready)) )
1699 {
1700 CS_DBGOUT(CS_INTERRUPT, 8, printk(
1701 "cs46xx: cs_interrupt() interrupt bit(s) set (0x%x)\n",status));
1702 cs_update_ptr(card, CS_TRUE);
1703 }
1704
1705 if( status & HISR_MIDI )
1706 cs_handle_midi(card);
1707
1708 /* clear 'em */
1709 cs461x_pokeBA0(card, BA0_HICR, HICR_CHGM|HICR_IEV);
1710 spin_unlock(&card->lock);
1711 CS_DBGOUT(CS_INTERRUPT, 9, printk("cs46xx: cs_interrupt()- \n"));
1712 }
1713
1714
1715 /**********************************************************************/
1716
1717 static ssize_t cs_midi_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
1718 {
1719 struct cs_card *card = (struct cs_card *)file->private_data;
1720 ssize_t ret;
1721 unsigned long flags;
1722 unsigned ptr;
1723 int cnt;
1724
1725 if (ppos != &file->f_pos)
1726 return -ESPIPE;
1727 if (!access_ok(VERIFY_WRITE, buffer, count))
1728 return -EFAULT;
1729 ret = 0;
1730 while (count > 0) {
1731 spin_lock_irqsave(&card->lock, flags);
1732 ptr = card->midi.ird;
1733 cnt = CS_MIDIINBUF - ptr;
1734 if (card->midi.icnt < cnt)
1735 cnt = card->midi.icnt;
1736 spin_unlock_irqrestore(&card->lock, flags);
1737 if (cnt > count)
1738 cnt = count;
1739 if (cnt <= 0) {
1740 if (file->f_flags & O_NONBLOCK)
1741 return ret ? ret : -EAGAIN;
1742 interruptible_sleep_on(&card->midi.iwait);
1743 if (signal_pending(current))
1744 return ret ? ret : -ERESTARTSYS;
1745 continue;
1746 }
1747 if (copy_to_user(buffer, card->midi.ibuf + ptr, cnt))
1748 return ret ? ret : -EFAULT;
1749 ptr = (ptr + cnt) % CS_MIDIINBUF;
1750 spin_lock_irqsave(&card->lock, flags);
1751 card->midi.ird = ptr;
1752 card->midi.icnt -= cnt;
1753 spin_unlock_irqrestore(&card->lock, flags);
1754 count -= cnt;
1755 buffer += cnt;
1756 ret += cnt;
1757 }
1758 return ret;
1759 }
1760
1761
1762 static ssize_t cs_midi_write(struct file *file, const char *buffer, size_t count, loff_t *ppos)
1763 {
1764 struct cs_card *card = (struct cs_card *)file->private_data;
1765 ssize_t ret;
1766 unsigned long flags;
1767 unsigned ptr;
1768 int cnt;
1769
1770 if (ppos != &file->f_pos)
1771 return -ESPIPE;
1772 if (!access_ok(VERIFY_READ, buffer, count))
1773 return -EFAULT;
1774 ret = 0;
1775 while (count > 0) {
1776 spin_lock_irqsave(&card->lock, flags);
1777 ptr = card->midi.owr;
1778 cnt = CS_MIDIOUTBUF - ptr;
1779 if (card->midi.ocnt + cnt > CS_MIDIOUTBUF)
1780 cnt = CS_MIDIOUTBUF - card->midi.ocnt;
1781 if (cnt <= 0)
1782 cs_handle_midi(card);
1783 spin_unlock_irqrestore(&card->lock, flags);
1784 if (cnt > count)
1785 cnt = count;
1786 if (cnt <= 0) {
1787 if (file->f_flags & O_NONBLOCK)
1788 return ret ? ret : -EAGAIN;
1789 interruptible_sleep_on(&card->midi.owait);
1790 if (signal_pending(current))
1791 return ret ? ret : -ERESTARTSYS;
1792 continue;
1793 }
1794 if (copy_from_user(card->midi.obuf + ptr, buffer, cnt))
1795 return ret ? ret : -EFAULT;
1796 ptr = (ptr + cnt) % CS_MIDIOUTBUF;
1797 spin_lock_irqsave(&card->lock, flags);
1798 card->midi.owr = ptr;
1799 card->midi.ocnt += cnt;
1800 spin_unlock_irqrestore(&card->lock, flags);
1801 count -= cnt;
1802 buffer += cnt;
1803 ret += cnt;
1804 spin_lock_irqsave(&card->lock, flags);
1805 cs_handle_midi(card);
1806 spin_unlock_irqrestore(&card->lock, flags);
1807 }
1808 return ret;
1809 }
1810
1811
1812 static unsigned int cs_midi_poll(struct file *file, struct poll_table_struct *wait)
1813 {
1814 struct cs_card *card = (struct cs_card *)file->private_data;
1815 unsigned long flags;
1816 unsigned int mask = 0;
1817
1818 if (file->f_flags & FMODE_WRITE)
1819 poll_wait(file, &card->midi.owait, wait);
1820 if (file->f_flags & FMODE_READ)
1821 poll_wait(file, &card->midi.iwait, wait);
1822 spin_lock_irqsave(&card->lock, flags);
1823 if (file->f_flags & FMODE_READ) {
1824 if (card->midi.icnt > 0)
1825 mask |= POLLIN | POLLRDNORM;
1826 }
1827 if (file->f_flags & FMODE_WRITE) {
1828 if (card->midi.ocnt < CS_MIDIOUTBUF)
1829 mask |= POLLOUT | POLLWRNORM;
1830 }
1831 spin_unlock_irqrestore(&card->lock, flags);
1832 return mask;
1833 }
1834
1835
1836 static int cs_midi_open(struct inode *inode, struct file *file)
1837 {
1838 int minor = MINOR(inode->i_rdev);
1839 struct cs_card *card=NULL;
1840 unsigned long flags;
1841 struct list_head *entry;
1842
1843 list_for_each(entry, &cs46xx_devs)
1844 {
1845 card = list_entry(entry, struct cs_card, list);
1846 if (card->dev_midi == minor)
1847 break;
1848 }
1849
1850 if (entry == &cs46xx_devs)
1851 return -ENODEV;
1852 if (!card)
1853 {
1854 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 2, printk(KERN_INFO
1855 "cs46xx: cs46xx_midi_open(): Error - unable to find card struct\n"));
1856 return -ENODEV;
1857 }
1858
1859 file->private_data = card;
1860 /* wait for device to become free */
1861 down(&card->midi.open_sem);
1862 while (card->midi.open_mode & file->f_mode) {
1863 if (file->f_flags & O_NONBLOCK) {
1864 up(&card->midi.open_sem);
1865 return -EBUSY;
1866 }
1867 up(&card->midi.open_sem);
1868 interruptible_sleep_on(&card->midi.open_wait);
1869 if (signal_pending(current))
1870 return -ERESTARTSYS;
1871 down(&card->midi.open_sem);
1872 }
1873 spin_lock_irqsave(&card->midi.lock, flags);
1874 if (!(card->midi.open_mode & (FMODE_READ | FMODE_WRITE))) {
1875 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
1876 card->midi.ord = card->midi.owr = card->midi.ocnt = 0;
1877 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
1878 cs461x_pokeBA0(card, BA0_MIDCR, 0x0000000f); /* Enable xmit, rcv. */
1879 cs461x_pokeBA0(card, BA0_HICR, HICR_IEV | HICR_CHGM); /* Enable interrupts */
1880 }
1881 if (file->f_mode & FMODE_READ) {
1882 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
1883 }
1884 if (file->f_mode & FMODE_WRITE) {
1885 card->midi.ord = card->midi.owr = card->midi.ocnt = 0;
1886 }
1887 spin_unlock_irqrestore(&card->midi.lock, flags);
1888 card->midi.open_mode |= (file->f_mode & (FMODE_READ | FMODE_WRITE));
1889 up(&card->midi.open_sem);
1890 MOD_INC_USE_COUNT; /* for 2.2 */
1891 return 0;
1892 }
1893
1894
1895 static int cs_midi_release(struct inode *inode, struct file *file)
1896 {
1897 struct cs_card *card = (struct cs_card *)file->private_data;
1898 DECLARE_WAITQUEUE(wait, current);
1899 unsigned long flags;
1900 unsigned count, tmo;
1901
1902 if (file->f_mode & FMODE_WRITE) {
1903 current->state = TASK_INTERRUPTIBLE;
1904 add_wait_queue(&card->midi.owait, &wait);
1905 for (;;) {
1906 spin_lock_irqsave(&card->midi.lock, flags);
1907 count = card->midi.ocnt;
1908 spin_unlock_irqrestore(&card->midi.lock, flags);
1909 if (count <= 0)
1910 break;
1911 if (signal_pending(current))
1912 break;
1913 if (file->f_flags & O_NONBLOCK) {
1914 remove_wait_queue(&card->midi.owait, &wait);
1915 current->state = TASK_RUNNING;
1916 return -EBUSY;
1917 }
1918 tmo = (count * HZ) / 3100;
1919 if (!schedule_timeout(tmo ? : 1) && tmo)
1920 printk(KERN_DEBUG "cs46xx: midi timed out??\n");
1921 }
1922 remove_wait_queue(&card->midi.owait, &wait);
1923 current->state = TASK_RUNNING;
1924 }
1925 down(&card->midi.open_sem);
1926 card->midi.open_mode &= (~(file->f_mode & (FMODE_READ | FMODE_WRITE)));
1927 up(&card->midi.open_sem);
1928 wake_up(&card->midi.open_wait);
1929 MOD_DEC_USE_COUNT; /* for 2.2 */
1930 return 0;
1931 }
1932
1933 /*
1934 * Midi file operations struct.
1935 */
1936 static /*const*/ struct file_operations cs_midi_fops = {
1937 CS_OWNER CS_THIS_MODULE
1938 llseek: no_llseek,
1939 read: cs_midi_read,
1940 write: cs_midi_write,
1941 poll: cs_midi_poll,
1942 open: cs_midi_open,
1943 release: cs_midi_release,
1944 };
1945
1946 /*
1947 *
1948 * CopySamples copies 16-bit stereo signed samples from the source to the
1949 * destination, possibly converting down to unsigned 8-bit and/or mono.
1950 * count specifies the number of output bytes to write.
1951 *
1952 * Arguments:
1953 *
1954 * dst - Pointer to a destination buffer.
1955 * src - Pointer to a source buffer
1956 * count - The number of bytes to copy into the destination buffer.
1957 * fmt - CS_FMT_16BIT and/or CS_FMT_STEREO bits
1958 * dmabuf - pointer to the dma buffer structure
1959 *
1960 * NOTES: only call this routine if the output desired is not 16 Signed Stereo
1961 *
1962 *
1963 */
1964 static void CopySamples(char *dst, char *src, int count, unsigned fmt,
1965 struct dmabuf *dmabuf)
1966 {
1967
1968 s32 s32AudioSample;
1969 s16 *psSrc=(s16 *)src;
1970 s16 *psDst=(s16 *)dst;
1971 u8 *pucDst=(u8 *)dst;
1972
1973 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs46xx: CopySamples()+ ") );
1974 CS_DBGOUT(CS_WAVE_READ, 8, printk(KERN_INFO
1975 " dst=0x%x src=0x%x count=%d fmt=0x%x\n",
1976 (unsigned)dst,(unsigned)src,(unsigned)count,(unsigned)fmt) );
1977
1978 /*
1979 * See if the data should be output as 8-bit unsigned stereo.
1980 */
1981 if((fmt & CS_FMT_STEREO) && !(fmt & CS_FMT_16BIT))
1982 {
1983 /*
1984 * Convert each 16-bit signed stereo sample to 8-bit unsigned
1985 * stereo using rounding.
1986 */
1987 psSrc = (s16 *)src;
1988 count = count/2;
1989 while(count--)
1990 {
1991 *(pucDst++) = (u8)(((s16)(*psSrc++) + (s16)0x8000) >> 8);
1992 }
1993 }
1994 /*
1995 * See if the data should be output at 8-bit unsigned mono.
1996 */
1997 else if(!(fmt & CS_FMT_STEREO) && !(fmt & CS_FMT_16BIT))
1998 {
1999 /*
2000 * Convert each 16-bit signed stereo sample to 8-bit unsigned
2001 * mono using averaging and rounding.
2002 */
2003 psSrc = (s16 *)src;
2004 count = count/2;
2005 while(count--)
2006 {
2007 s32AudioSample = ((*psSrc)+(*(psSrc + 1)))/2 + (s32)0x80;
2008 if(s32AudioSample > 0x7fff)
2009 s32AudioSample = 0x7fff;
2010 *(pucDst++) = (u8)(((s16)s32AudioSample + (s16)0x8000) >> 8);
2011 psSrc += 2;
2012 }
2013 }
2014 /*
2015 * See if the data should be output at 16-bit signed mono.
2016 */
2017 else if(!(fmt & CS_FMT_STEREO) && (fmt & CS_FMT_16BIT))
2018 {
2019 /*
2020 * Convert each 16-bit signed stereo sample to 16-bit signed
2021 * mono using averaging.
2022 */
2023 psSrc = (s16 *)src;
2024 count = count/2;
2025 while(count--)
2026 {
2027 *(psDst++) = (s16)((*psSrc)+(*(psSrc + 1)))/2;
2028 psSrc += 2;
2029 }
2030 }
2031 }
2032
2033 /*
2034 * cs_copy_to_user()
2035 * replacement for the standard copy_to_user, to allow for a conversion from
2036 * 16 bit to 8 bit and from stereo to mono, if the record conversion is active.
2037 * The current CS46xx/CS4280 static image only records in 16bit unsigned Stereo,
2038 * so we convert from any of the other format combinations.
2039 */
2040 static unsigned cs_copy_to_user(
2041 struct cs_state *s,
2042 void *dest,
2043 void *hwsrc,
2044 unsigned cnt,
2045 unsigned *copied)
2046 {
2047 struct dmabuf *dmabuf = &s->dmabuf;
2048 void *src = hwsrc; /* default to the standard destination buffer addr */
2049
2050 CS_DBGOUT(CS_FUNCTION, 6, printk(KERN_INFO
2051 "cs_copy_to_user()+ fmt=0x%x cnt=%d dest=0x%.8x\n",
2052 dmabuf->fmt,(unsigned)cnt,(unsigned)dest) );
2053
2054 if(cnt > dmabuf->dmasize)
2055 {
2056 cnt = dmabuf->dmasize;
2057 }
2058 if(!cnt)
2059 {
2060 *copied = 0;
2061 return 0;
2062 }
2063 if(dmabuf->divisor != 1)
2064 {
2065 if(!dmabuf->tmpbuff)
2066 {
2067 *copied = cnt/dmabuf->divisor;
2068 return 0;
2069 }
2070
2071 CopySamples((char *)dmabuf->tmpbuff, (char *)hwsrc, cnt,
2072 dmabuf->fmt, dmabuf);
2073 src = dmabuf->tmpbuff;
2074 cnt = cnt/dmabuf->divisor;
2075 }
2076 if (copy_to_user(dest, src, cnt))
2077 {
2078 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_ERR
2079 "cs46xx: cs_copy_to_user()- fault dest=0x%x src=0x%x cnt=%d\n",
2080 (unsigned)dest,(unsigned)src,cnt) );
2081 *copied = 0;
2082 return -EFAULT;
2083 }
2084 *copied = cnt;
2085 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO
2086 "cs46xx: cs_copy_to_user()- copied bytes is %d \n",cnt) );
2087 return 0;
2088 }
2089
2090 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be copied to
2091 the user's buffer. it is filled by the dma machine and drained by this loop. */
2092 static ssize_t cs_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
2093 {
2094 struct cs_card *card = (struct cs_card *) file->private_data;
2095 struct cs_state *state;
2096 DECLARE_WAITQUEUE(wait, current);
2097 struct dmabuf *dmabuf;
2098 ssize_t ret = 0;
2099 unsigned long flags;
2100 unsigned swptr;
2101 int cnt;
2102 unsigned copied=0;
2103
2104 CS_DBGOUT(CS_WAVE_READ | CS_FUNCTION, 4,
2105 printk("cs46xx: cs_read()+ %d\n",count) );
2106 state = (struct cs_state *)card->states[0];
2107 if(!state)
2108 return -ENODEV;
2109 dmabuf = &state->dmabuf;
2110
2111 if (ppos != &file->f_pos)
2112 return -ESPIPE;
2113 if (dmabuf->mapped)
2114 return -ENXIO;
2115 if (!access_ok(VERIFY_WRITE, buffer, count))
2116 return -EFAULT;
2117
2118 down(&state->sem);
2119 if (!dmabuf->ready && (ret = __prog_dmabuf(state)))
2120 goto out;
2121
2122 add_wait_queue(&state->dmabuf.wait, &wait);
2123 while (count > 0) {
2124 while(!(card->pm.flags & CS46XX_PM_IDLE))
2125 {
2126 schedule();
2127 if (signal_pending(current)) {
2128 if(!ret) ret = -ERESTARTSYS;
2129 goto out;
2130 }
2131 }
2132 spin_lock_irqsave(&state->card->lock, flags);
2133 swptr = dmabuf->swptr;
2134 cnt = dmabuf->dmasize - swptr;
2135 if (dmabuf->count < cnt)
2136 cnt = dmabuf->count;
2137 if (cnt <= 0)
2138 __set_current_state(TASK_INTERRUPTIBLE);
2139 spin_unlock_irqrestore(&state->card->lock, flags);
2140
2141 if (cnt > (count * dmabuf->divisor))
2142 cnt = count * dmabuf->divisor;
2143 if (cnt <= 0) {
2144 /* buffer is empty, start the dma machine and wait for data to be
2145 recorded */
2146 start_adc(state);
2147 if (file->f_flags & O_NONBLOCK) {
2148 if (!ret) ret = -EAGAIN;
2149 goto out;
2150 }
2151 up(&state->sem);
2152 schedule();
2153 if (signal_pending(current)) {
2154 if(!ret) ret = -ERESTARTSYS;
2155 goto out;
2156 }
2157 down(&state->sem);
2158 if (dmabuf->mapped)
2159 {
2160 if(!ret)
2161 ret = -ENXIO;
2162 goto out;
2163 }
2164 continue;
2165 }
2166
2167 CS_DBGOUT(CS_WAVE_READ, 2, printk(KERN_INFO
2168 "_read() copy_to cnt=%d count=%d ", cnt,count) );
2169 CS_DBGOUT(CS_WAVE_READ, 8, printk(KERN_INFO
2170 " .dmasize=%d .count=%d buffer=0x%.8x ret=%d\n",
2171 dmabuf->dmasize,dmabuf->count,(unsigned)buffer,ret) );
2172
2173 if (cs_copy_to_user(state, buffer,
2174 (void *)((unsigned)dmabuf->rawbuf + swptr), cnt, &copied))
2175 {
2176 if (!ret) ret = -EFAULT;
2177 goto out;
2178 }
2179 swptr = (swptr + cnt) % dmabuf->dmasize;
2180 spin_lock_irqsave(&card->lock, flags);
2181 dmabuf->swptr = swptr;
2182 dmabuf->count -= cnt;
2183 spin_unlock_irqrestore(&card->lock, flags);
2184 count -= copied;
2185 buffer += copied;
2186 ret += copied;
2187 start_adc(state);
2188 }
2189 out:
2190 up(&state->sem);
2191 remove_wait_queue(&state->dmabuf.wait, &wait);
2192 set_current_state(TASK_RUNNING);
2193 CS_DBGOUT(CS_WAVE_READ | CS_FUNCTION, 4,
2194 printk("cs46xx: cs_read()- %d\n",ret) );
2195 return ret;
2196 }
2197
2198 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be dma to
2199 the soundcard. it is drained by the dma machine and filled by this loop. */
2200 static ssize_t cs_write(struct file *file, const char *buffer, size_t count, loff_t *ppos)
2201 {
2202 struct cs_card *card = (struct cs_card *) file->private_data;
2203 struct cs_state *state;
2204 DECLARE_WAITQUEUE(wait, current);
2205 struct dmabuf *dmabuf;
2206 ssize_t ret;
2207 unsigned long flags;
2208 unsigned swptr;
2209 int cnt;
2210
2211 CS_DBGOUT(CS_WAVE_WRITE | CS_FUNCTION, 4,
2212 printk("cs46xx: cs_write called, count = %d\n", count) );
2213 state = (struct cs_state *)card->states[1];
2214 if(!state)
2215 return -ENODEV;
2216 dmabuf = &state->dmabuf;
2217
2218 if (ppos != &file->f_pos)
2219 return -ESPIPE;
2220
2221 down(&state->sem);
2222 if (dmabuf->mapped)
2223 {
2224 ret = -ENXIO;
2225 goto out;
2226 }
2227
2228 if (!dmabuf->ready && (ret = __prog_dmabuf(state)))
2229 goto out;
2230 if (!access_ok(VERIFY_READ, buffer, count))
2231 {
2232 ret = -EFAULT;
2233 goto out;
2234 }
2235 add_wait_queue(&state->dmabuf.wait, &wait);
2236 ret = 0;
2237 /*
2238 * Start the loop to read from the user's buffer and write to the dma buffer.
2239 * check for PM events and underrun/overrun in the loop.
2240 */
2241 while (count > 0) {
2242 while(!(card->pm.flags & CS46XX_PM_IDLE))
2243 {
2244 schedule();
2245 if (signal_pending(current)) {
2246 if(!ret) ret = -ERESTARTSYS;
2247 goto out;
2248 }
2249 }
2250 spin_lock_irqsave(&state->card->lock, flags);
2251 if (dmabuf->count < 0) {
2252 /* buffer underrun, we are recovering from sleep_on_timeout,
2253 resync hwptr and swptr */
2254 dmabuf->count = 0;
2255 dmabuf->swptr = dmabuf->hwptr;
2256 }
2257 if (dmabuf->underrun)
2258 {
2259 dmabuf->underrun = 0;
2260 dmabuf->hwptr = cs_get_dma_addr(state);
2261 dmabuf->swptr = dmabuf->hwptr;
2262 }
2263
2264 swptr = dmabuf->swptr;
2265 cnt = dmabuf->dmasize - swptr;
2266 if (dmabuf->count + cnt > dmabuf->dmasize)
2267 cnt = dmabuf->dmasize - dmabuf->count;
2268 if (cnt <= 0)
2269 __set_current_state(TASK_INTERRUPTIBLE);
2270 spin_unlock_irqrestore(&state->card->lock, flags);
2271
2272 if (cnt > count)
2273 cnt = count;
2274 if (cnt <= 0) {
2275 /* buffer is full, start the dma machine and wait for data to be
2276 played */
2277 start_dac(state);
2278 if (file->f_flags & O_NONBLOCK) {
2279 if (!ret) ret = -EAGAIN;
2280 goto out;
2281 }
2282 up(&state->sem);
2283 schedule();
2284 if (signal_pending(current)) {
2285 if(!ret) ret = -ERESTARTSYS;
2286 goto out;
2287 }
2288 down(&state->sem);
2289 if (dmabuf->mapped)
2290 {
2291 if(!ret)
2292 ret = -ENXIO;
2293 goto out;
2294 }
2295 continue;
2296 }
2297 if (copy_from_user(dmabuf->rawbuf + swptr, buffer, cnt)) {
2298 if (!ret) ret = -EFAULT;
2299 goto out;
2300 }
2301 spin_lock_irqsave(&state->card->lock, flags);
2302 swptr = (swptr + cnt) % dmabuf->dmasize;
2303 dmabuf->swptr = swptr;
2304 dmabuf->count += cnt;
2305 if(dmabuf->count > dmabuf->dmasize)
2306 {
2307 CS_DBGOUT(CS_WAVE_WRITE | CS_ERROR, 2, printk(
2308 "cs46xx: cs_write() d->count > dmasize - resetting\n"));
2309 dmabuf->count = dmabuf->dmasize;
2310 }
2311 dmabuf->endcleared = 0;
2312 spin_unlock_irqrestore(&state->card->lock, flags);
2313
2314 count -= cnt;
2315 buffer += cnt;
2316 ret += cnt;
2317 start_dac(state);
2318 }
2319 out:
2320 up(&state->sem);
2321 remove_wait_queue(&state->dmabuf.wait, &wait);
2322 set_current_state(TASK_RUNNING);
2323
2324 CS_DBGOUT(CS_WAVE_WRITE | CS_FUNCTION, 2,
2325 printk("cs46xx: cs_write()- ret=0x%x\n", ret) );
2326 return ret;
2327 }
2328
2329 static unsigned int cs_poll(struct file *file, struct poll_table_struct *wait)
2330 {
2331 struct cs_card *card = (struct cs_card *)file->private_data;
2332 struct dmabuf *dmabuf;
2333 struct cs_state *state;
2334
2335 unsigned long flags;
2336 unsigned int mask = 0;
2337
2338 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_poll()+ \n"));
2339 if (!(file->f_mode & (FMODE_WRITE | FMODE_READ)))
2340 {
2341 return -EINVAL;
2342 }
2343 if (file->f_mode & FMODE_WRITE)
2344 {
2345 state = card->states[1];
2346 if(state)
2347 {
2348 dmabuf = &state->dmabuf;
2349 poll_wait(file, &dmabuf->wait, wait);
2350 }
2351 }
2352 if (file->f_mode & FMODE_READ)
2353 {
2354 state = card->states[0];
2355 if(state)
2356 {
2357 dmabuf = &state->dmabuf;
2358 poll_wait(file, &dmabuf->wait, wait);
2359 }
2360 }
2361
2362 spin_lock_irqsave(&card->lock, flags);
2363 cs_update_ptr(card, CS_FALSE);
2364 if (file->f_mode & FMODE_READ) {
2365 state = card->states[0];
2366 if(state)
2367 {
2368 dmabuf = &state->dmabuf;
2369 if (dmabuf->count >= (signed)dmabuf->fragsize)
2370 mask |= POLLIN | POLLRDNORM;
2371 }
2372 }
2373 if (file->f_mode & FMODE_WRITE) {
2374 state = card->states[1];
2375 if(state)
2376 {
2377 dmabuf = &state->dmabuf;
2378 if (dmabuf->mapped) {
2379 if (dmabuf->count >= (signed)dmabuf->fragsize)
2380 mask |= POLLOUT | POLLWRNORM;
2381 } else {
2382 if ((signed)dmabuf->dmasize >= dmabuf->count
2383 + (signed)dmabuf->fragsize)
2384 mask |= POLLOUT | POLLWRNORM;
2385 }
2386 }
2387 }
2388 spin_unlock_irqrestore(&card->lock, flags);
2389
2390 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_poll()- (0x%x) \n",
2391 mask));
2392 return mask;
2393 }
2394
2395 /*
2396 * We let users mmap the ring buffer. Its not the real DMA buffer but
2397 * that side of the code is hidden in the IRQ handling. We do a software
2398 * emulation of DMA from a 64K or so buffer into a 2K FIFO.
2399 * (the hardware probably deserves a moan here but Crystal send me nice
2400 * toys ;)).
2401 */
2402
2403 static int cs_mmap(struct file *file, struct vm_area_struct *vma)
2404 {
2405 struct cs_card *card = (struct cs_card *)file->private_data;
2406 struct cs_state *state;
2407 struct dmabuf *dmabuf;
2408 int ret = 0;
2409 unsigned long size;
2410
2411 CS_DBGOUT(CS_FUNCTION | CS_PARMS, 2, printk("cs46xx: cs_mmap()+ file=0x%x %s %s\n",
2412 (unsigned)file, vma->vm_flags & VM_WRITE ? "VM_WRITE" : "",
2413 vma->vm_flags & VM_READ ? "VM_READ" : "") );
2414
2415 if (vma->vm_flags & VM_WRITE) {
2416 state = card->states[1];
2417 if(state)
2418 {
2419 CS_DBGOUT(CS_OPEN, 2, printk(
2420 "cs46xx: cs_mmap() VM_WRITE - state TRUE prog_dmabuf DAC\n") );
2421 if ((ret = prog_dmabuf(state)) != 0)
2422 return ret;
2423 }
2424 } else if (vma->vm_flags & VM_READ) {
2425 state = card->states[0];
2426 if(state)
2427 {
2428 CS_DBGOUT(CS_OPEN, 2, printk(
2429 "cs46xx: cs_mmap() VM_READ - state TRUE prog_dmabuf ADC\n") );
2430 if ((ret = prog_dmabuf(state)) != 0)
2431 return ret;
2432 }
2433 } else {
2434 CS_DBGOUT(CS_ERROR, 2, printk(
2435 "cs46xx: cs_mmap() return -EINVAL\n") );
2436 return -EINVAL;
2437 }
2438
2439 /*
2440 * For now ONLY support playback, but seems like the only way to use
2441 * mmap() is to open an FD with RDWR, just read or just write access
2442 * does not function, get an error back from the kernel.
2443 * Also, QuakeIII opens with RDWR! So, there must be something
2444 * to needing read/write access mapping. So, allow read/write but
2445 * use the DAC only.
2446 */
2447 state = card->states[1];
2448 if(!(unsigned)state)
2449 {
2450 ret = -EINVAL;
2451 goto out;
2452 }
2453
2454 down(&state->sem);
2455 dmabuf = &state->dmabuf;
2456 if (cs4x_pgoff(vma) != 0)
2457 {
2458 ret = -EINVAL;
2459 goto out;
2460 }
2461 size = vma->vm_end - vma->vm_start;
2462
2463 CS_DBGOUT(CS_PARMS, 2, printk("cs46xx: cs_mmap(): size=%d\n",(unsigned)size) );
2464
2465 if (size > (PAGE_SIZE << dmabuf->buforder))
2466 {
2467 ret = -EINVAL;
2468 goto out;
2469 }
2470 if (remap_page_range(vma->vm_start, virt_to_phys(dmabuf->rawbuf),
2471 size, vma->vm_page_prot))
2472 {
2473 ret = -EAGAIN;
2474 goto out;
2475 }
2476 dmabuf->mapped = 1;
2477
2478 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_mmap()-\n") );
2479 out:
2480 up(&state->sem);
2481 return ret;
2482 }
2483
2484 static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
2485 {
2486 struct cs_card *card = (struct cs_card *)file->private_data;
2487 struct cs_state *state;
2488 struct dmabuf *dmabuf=0;
2489 unsigned long flags;
2490 audio_buf_info abinfo;
2491 count_info cinfo;
2492 int val, valsave, mapped, ret;
2493
2494 state = (struct cs_state *)card->states[0];
2495 if(state)
2496 {
2497 dmabuf = &state->dmabuf;
2498 mapped = (file->f_mode & FMODE_READ) && dmabuf->mapped;
2499 }
2500 state = (struct cs_state *)card->states[1];
2501 if(state)
2502 {
2503 dmabuf = &state->dmabuf;
2504 mapped |= (file->f_mode & FMODE_WRITE) && dmabuf->mapped;
2505 }
2506
2507 #if CSDEBUG
2508 printioctl(cmd);
2509 #endif
2510
2511 switch (cmd)
2512 {
2513 case OSS_GETVERSION:
2514 return put_user(SOUND_VERSION, (int *)arg);
2515
2516 case SNDCTL_DSP_RESET:
2517 /* FIXME: spin_lock ? */
2518 if (file->f_mode & FMODE_WRITE) {
2519 state = (struct cs_state *)card->states[1];
2520 if(state)
2521 {
2522 dmabuf = &state->dmabuf;
2523 stop_dac(state);
2524 synchronize_irq();
2525 dmabuf->ready = 0;
2526 resync_dma_ptrs(state);
2527 dmabuf->swptr = dmabuf->hwptr = 0;
2528 dmabuf->count = dmabuf->total_bytes = 0;
2529 dmabuf->blocks = 0;
2530 dmabuf->SGok = 0;
2531 }
2532 }
2533 if (file->f_mode & FMODE_READ) {
2534 state = (struct cs_state *)card->states[0];
2535 if(state)
2536 {
2537 dmabuf = &state->dmabuf;
2538 stop_adc(state);
2539 synchronize_irq();
2540 resync_dma_ptrs(state);
2541 dmabuf->ready = 0;
2542 dmabuf->swptr = dmabuf->hwptr = 0;
2543 dmabuf->count = dmabuf->total_bytes = 0;
2544 dmabuf->blocks = 0;
2545 dmabuf->SGok = 0;
2546 }
2547 }
2548 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_RESET()-\n") );
2549 return 0;
2550
2551 case SNDCTL_DSP_SYNC:
2552 if (file->f_mode & FMODE_WRITE)
2553 return drain_dac(state, file->f_flags & O_NONBLOCK);
2554 return 0;
2555
2556 case SNDCTL_DSP_SPEED: /* set sample rate */
2557 if (get_user(val, (int *)arg))
2558 return -EFAULT;
2559 if (val >= 0) {
2560 if (file->f_mode & FMODE_READ) {
2561 state = (struct cs_state *)card->states[0];
2562 if(state)
2563 {
2564 dmabuf = &state->dmabuf;
2565 stop_adc(state);
2566 dmabuf->ready = 0;
2567 dmabuf->SGok = 0;
2568 cs_set_adc_rate(state, val);
2569 cs_set_divisor(dmabuf);
2570 }
2571 }
2572 if (file->f_mode & FMODE_WRITE) {
2573 state = (struct cs_state *)card->states[1];
2574 if(state)
2575 {
2576 dmabuf = &state->dmabuf;
2577 stop_dac(state);
2578 dmabuf->ready = 0;
2579 dmabuf->SGok = 0;
2580 cs_set_dac_rate(state, val);
2581 cs_set_divisor(dmabuf);
2582 }
2583 }
2584 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2585 "cs46xx: cs_ioctl() DSP_SPEED %s %s %d\n",
2586 file->f_mode & FMODE_WRITE ? "DAC" : "",
2587 file->f_mode & FMODE_READ ? "ADC" : "",
2588 dmabuf->rate ) );
2589 return put_user(dmabuf->rate, (int *)arg);
2590 }
2591 return put_user(0, (int *)arg);
2592
2593 case SNDCTL_DSP_STEREO: /* set stereo or mono channel */
2594 if (get_user(val, (int *)arg))
2595 return -EFAULT;
2596 if (file->f_mode & FMODE_WRITE) {
2597 state = (struct cs_state *)card->states[1];
2598 if(state)
2599 {
2600 dmabuf = &state->dmabuf;
2601 stop_dac(state);
2602 dmabuf->ready = 0;
2603 dmabuf->SGok = 0;
2604 if(val)
2605 dmabuf->fmt |= CS_FMT_STEREO;
2606 else
2607 dmabuf->fmt &= ~CS_FMT_STEREO;
2608 cs_set_divisor(dmabuf);
2609 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2610 "cs46xx: DSP_STEREO() DAC %s\n",
2611 (dmabuf->fmt & CS_FMT_STEREO) ?
2612 "STEREO":"MONO") );
2613 }
2614 }
2615 if (file->f_mode & FMODE_READ) {
2616 state = (struct cs_state *)card->states[0];
2617 if(state)
2618 {
2619 dmabuf = &state->dmabuf;
2620 stop_adc(state);
2621 dmabuf->ready = 0;
2622 dmabuf->SGok = 0;
2623 if(val)
2624 dmabuf->fmt |= CS_FMT_STEREO;
2625 else
2626 dmabuf->fmt &= ~CS_FMT_STEREO;
2627 cs_set_divisor(dmabuf);
2628 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2629 "cs46xx: DSP_STEREO() ADC %s\n",
2630 (dmabuf->fmt & CS_FMT_STEREO) ?
2631 "STEREO":"MONO") );
2632 }
2633 }
2634 return 0;
2635
2636 case SNDCTL_DSP_GETBLKSIZE:
2637 if (file->f_mode & FMODE_WRITE) {
2638 state = (struct cs_state *)card->states[1];
2639 if(state)
2640 {
2641 dmabuf = &state->dmabuf;
2642 if ((val = prog_dmabuf(state)))
2643 return val;
2644 return put_user(dmabuf->fragsize, (int *)arg);
2645 }
2646 }
2647 if (file->f_mode & FMODE_READ) {
2648 state = (struct cs_state *)card->states[0];
2649 if(state)
2650 {
2651 dmabuf = &state->dmabuf;
2652 if ((val = prog_dmabuf(state)))
2653 return val;
2654 return put_user(dmabuf->fragsize/dmabuf->divisor,
2655 (int *)arg);
2656 }
2657 }
2658 return put_user(0, (int *)arg);
2659
2660 case SNDCTL_DSP_GETFMTS: /* Returns a mask of supported sample format*/
2661 return put_user(AFMT_S16_LE | AFMT_U8, (int *)arg);
2662
2663 case SNDCTL_DSP_SETFMT: /* Select sample format */
2664 if (get_user(val, (int *)arg))
2665 return -EFAULT;
2666 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2667 "cs46xx: cs_ioctl() DSP_SETFMT %s %s %s %s\n",
2668 file->f_mode & FMODE_WRITE ? "DAC" : "",
2669 file->f_mode & FMODE_READ ? "ADC" : "",
2670 val == AFMT_S16_LE ? "16Bit Signed" : "",
2671 val == AFMT_U8 ? "8Bit Unsigned" : "") );
2672 valsave = val;
2673 if (val != AFMT_QUERY) {
2674 if(val==AFMT_S16_LE || val==AFMT_U8)
2675 {
2676 if (file->f_mode & FMODE_WRITE) {
2677 state = (struct cs_state *)card->states[1];
2678 if(state)
2679 {
2680 dmabuf = &state->dmabuf;
2681 stop_dac(state);
2682 dmabuf->ready = 0;
2683 dmabuf->SGok = 0;
2684 if(val==AFMT_S16_LE)
2685 dmabuf->fmt |= CS_FMT_16BIT;
2686 else
2687 dmabuf->fmt &= ~CS_FMT_16BIT;
2688 cs_set_divisor(dmabuf);
2689 if((ret = prog_dmabuf(state)))
2690 return ret;
2691 }
2692 }
2693 if (file->f_mode & FMODE_READ) {
2694 val = valsave;
2695 state = (struct cs_state *)card->states[0];
2696 if(state)
2697 {
2698 dmabuf = &state->dmabuf;
2699 stop_adc(state);
2700 dmabuf->ready = 0;
2701 dmabuf->SGok = 0;
2702 if(val==AFMT_S16_LE)
2703 dmabuf->fmt |= CS_FMT_16BIT;
2704 else
2705 dmabuf->fmt &= ~CS_FMT_16BIT;
2706 cs_set_divisor(dmabuf);
2707 if((ret = prog_dmabuf(state)))
2708 return ret;
2709 }
2710 }
2711 }
2712 else
2713 {
2714 CS_DBGOUT(CS_IOCTL | CS_ERROR, 2, printk(
2715 "cs46xx: DSP_SETFMT() Unsupported format (0x%x)\n",
2716 valsave) );
2717 }
2718 }
2719 else
2720 {
2721 if(file->f_mode & FMODE_WRITE)
2722 {
2723 state = (struct cs_state *)card->states[1];
2724 if(state)
2725 dmabuf = &state->dmabuf;
2726 }
2727 else if(file->f_mode & FMODE_READ)
2728 {
2729 state = (struct cs_state *)card->states[0];
2730 if(state)
2731 dmabuf = &state->dmabuf;
2732 }
2733 }
2734 if(dmabuf)
2735 {
2736 if(dmabuf->fmt & CS_FMT_16BIT)
2737 return put_user(AFMT_S16_LE, (int *)arg);
2738 else
2739 return put_user(AFMT_U8, (int *)arg);
2740 }
2741 return put_user(0, (int *)arg);
2742
2743 case SNDCTL_DSP_CHANNELS:
2744 if (get_user(val, (int *)arg))
2745 return -EFAULT;
2746 if (val != 0) {
2747 if (file->f_mode & FMODE_WRITE) {
2748 state = (struct cs_state *)card->states[1];
2749 if(state)
2750 {
2751 dmabuf = &state->dmabuf;
2752 stop_dac(state);
2753 dmabuf->ready = 0;
2754 dmabuf->SGok = 0;
2755 if(val>1)
2756 dmabuf->fmt |= CS_FMT_STEREO;
2757 else
2758 dmabuf->fmt &= ~CS_FMT_STEREO;
2759 cs_set_divisor(dmabuf);
2760 if (prog_dmabuf(state))
2761 return 0;
2762 }
2763 }
2764 if (file->f_mode & FMODE_READ) {
2765 state = (struct cs_state *)card->states[0];
2766 if(state)
2767 {
2768 dmabuf = &state->dmabuf;
2769 stop_adc(state);
2770 dmabuf->ready = 0;
2771 dmabuf->SGok = 0;
2772 if(val>1)
2773 dmabuf->fmt |= CS_FMT_STEREO;
2774 else
2775 dmabuf->fmt &= ~CS_FMT_STEREO;
2776 cs_set_divisor(dmabuf);
2777 if (prog_dmabuf(state))
2778 return 0;
2779 }
2780 }
2781 }
2782 return put_user((dmabuf->fmt & CS_FMT_STEREO) ? 2 : 1,
2783 (int *)arg);
2784
2785 case SNDCTL_DSP_POST:
2786 /*
2787 * There will be a longer than normal pause in the data.
2788 * so... do nothing, because there is nothing that we can do.
2789 */
2790 return 0;
2791
2792 case SNDCTL_DSP_SUBDIVIDE:
2793 if (file->f_mode & FMODE_WRITE) {
2794 state = (struct cs_state *)card->states[1];
2795 if(state)
2796 {
2797 dmabuf = &state->dmabuf;
2798 if (dmabuf->subdivision)
2799 return -EINVAL;
2800 if (get_user(val, (int *)arg))
2801 return -EFAULT;
2802 if (val != 1 && val != 2)
2803 return -EINVAL;
2804 dmabuf->subdivision = val;
2805 }
2806 }
2807 if (file->f_mode & FMODE_READ) {
2808 state = (struct cs_state *)card->states[0];
2809 if(state)
2810 {
2811 dmabuf = &state->dmabuf;
2812 if (dmabuf->subdivision)
2813 return -EINVAL;
2814 if (get_user(val, (int *)arg))
2815 return -EFAULT;
2816 if (val != 1 && val != 2)
2817 return -EINVAL;
2818 dmabuf->subdivision = val;
2819 }
2820 }
2821 return 0;
2822
2823 case SNDCTL_DSP_SETFRAGMENT:
2824 if (get_user(val, (int *)arg))
2825 return -EFAULT;
2826
2827 if (file->f_mode & FMODE_WRITE) {
2828 state = (struct cs_state *)card->states[1];
2829 if(state)
2830 {
2831 dmabuf = &state->dmabuf;
2832 dmabuf->ossfragshift = val & 0xffff;
2833 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2834 }
2835 }
2836 if (file->f_mode & FMODE_READ) {
2837 state = (struct cs_state *)card->states[0];
2838 if(state)
2839 {
2840 dmabuf = &state->dmabuf;
2841 dmabuf->ossfragshift = val & 0xffff;
2842 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2843 }
2844 }
2845 return 0;
2846
2847 case SNDCTL_DSP_GETOSPACE:
2848 if (!(file->f_mode & FMODE_WRITE))
2849 return -EINVAL;
2850 state = (struct cs_state *)card->states[1];
2851 if(state)
2852 {
2853 dmabuf = &state->dmabuf;
2854 spin_lock_irqsave(&state->card->lock, flags);
2855 cs_update_ptr(card, CS_TRUE);
2856 abinfo.fragsize = dmabuf->fragsize;
2857 abinfo.fragstotal = dmabuf->numfrag;
2858 /*
2859 * for mmap we always have total space available
2860 */
2861 if (dmabuf->mapped)
2862 abinfo.bytes = dmabuf->dmasize;
2863 else
2864 abinfo.bytes = dmabuf->dmasize - dmabuf->count;
2865
2866 abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
2867 spin_unlock_irqrestore(&state->card->lock, flags);
2868 return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2869 }
2870 return -ENODEV;
2871
2872 case SNDCTL_DSP_GETISPACE:
2873 if (!(file->f_mode & FMODE_READ))
2874 return -EINVAL;
2875 state = (struct cs_state *)card->states[0];
2876 if(state)
2877 {
2878 dmabuf = &state->dmabuf;
2879 spin_lock_irqsave(&state->card->lock, flags);
2880 cs_update_ptr(card, CS_TRUE);
2881 abinfo.fragsize = dmabuf->fragsize/dmabuf->divisor;
2882 abinfo.bytes = dmabuf->count/dmabuf->divisor;
2883 abinfo.fragstotal = dmabuf->numfrag;
2884 abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
2885 spin_unlock_irqrestore(&state->card->lock, flags);
2886 return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2887 }
2888 return -ENODEV;
2889
2890 case SNDCTL_DSP_NONBLOCK:
2891 file->f_flags |= O_NONBLOCK;
2892 return 0;
2893
2894 case SNDCTL_DSP_GETCAPS:
2895 return put_user(DSP_CAP_REALTIME|DSP_CAP_TRIGGER|DSP_CAP_MMAP,
2896 (int *)arg);
2897
2898 case SNDCTL_DSP_GETTRIGGER:
2899 val = 0;
2900 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_GETTRIGGER()+\n") );
2901 if (file->f_mode & FMODE_WRITE)
2902 {
2903 state = (struct cs_state *)card->states[1];
2904 if(state)
2905 {
2906 dmabuf = &state->dmabuf;
2907 if(dmabuf->enable & DAC_RUNNING)
2908 val |= PCM_ENABLE_INPUT;
2909 }
2910 }
2911 if (file->f_mode & FMODE_READ)
2912 {
2913 if(state)
2914 {
2915 state = (struct cs_state *)card->states[0];
2916 dmabuf = &state->dmabuf;
2917 if(dmabuf->enable & ADC_RUNNING)
2918 val |= PCM_ENABLE_OUTPUT;
2919 }
2920 }
2921 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_GETTRIGGER()- val=0x%x\n",val) );
2922 return put_user(val, (int *)arg);
2923
2924 case SNDCTL_DSP_SETTRIGGER:
2925 if (get_user(val, (int *)arg))
2926 return -EFAULT;
2927 if (file->f_mode & FMODE_READ) {
2928 state = (struct cs_state *)card->states[0];
2929 if(state)
2930 {
2931 dmabuf = &state->dmabuf;
2932 if (val & PCM_ENABLE_INPUT) {
2933 if (!dmabuf->ready && (ret = prog_dmabuf(state)))
2934 return ret;
2935 start_adc(state);
2936 } else
2937 stop_adc(state);
2938 }
2939 }
2940 if (file->f_mode & FMODE_WRITE) {
2941 state = (struct cs_state *)card->states[1];
2942 if(state)
2943 {
2944 dmabuf = &state->dmabuf;
2945 if (val & PCM_ENABLE_OUTPUT) {
2946 if (!dmabuf->ready && (ret = prog_dmabuf(state)))
2947 return ret;
2948 start_dac(state);
2949 } else
2950 stop_dac(state);
2951 }
2952 }
2953 return 0;
2954
2955 case SNDCTL_DSP_GETIPTR:
2956 if (!(file->f_mode & FMODE_READ))
2957 return -EINVAL;
2958 state = (struct cs_state *)card->states[0];
2959 if(state)
2960 {
2961 dmabuf = &state->dmabuf;
2962 spin_lock_irqsave(&state->card->lock, flags);
2963 cs_update_ptr(card, CS_TRUE);
2964 cinfo.bytes = dmabuf->total_bytes/dmabuf->divisor;
2965 cinfo.blocks = dmabuf->count/dmabuf->divisor >> dmabuf->fragshift;
2966 cinfo.ptr = dmabuf->hwptr/dmabuf->divisor;
2967 spin_unlock_irqrestore(&state->card->lock, flags);
2968 return copy_to_user((void *)arg, &cinfo, sizeof(cinfo));
2969 }
2970 return -ENODEV;
2971
2972 case SNDCTL_DSP_GETOPTR:
2973 if (!(file->f_mode & FMODE_WRITE))
2974 return -EINVAL;
2975 state = (struct cs_state *)card->states[1];
2976 if(state)
2977 {
2978 dmabuf = &state->dmabuf;
2979 spin_lock_irqsave(&state->card->lock, flags);
2980 cs_update_ptr(card, CS_TRUE);
2981 cinfo.bytes = dmabuf->total_bytes;
2982 if (dmabuf->mapped)
2983 {
2984 cinfo.blocks = (cinfo.bytes >> dmabuf->fragshift)
2985 - dmabuf->blocks;
2986 CS_DBGOUT(CS_PARMS, 8,
2987 printk("total_bytes=%d blocks=%d dmabuf->blocks=%d\n",
2988 cinfo.bytes,cinfo.blocks,dmabuf->blocks) );
2989 dmabuf->blocks = cinfo.bytes >> dmabuf->fragshift;
2990 }
2991 else
2992 {
2993 cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
2994 }
2995 cinfo.ptr = dmabuf->hwptr;
2996
2997 CS_DBGOUT(CS_PARMS, 4, printk(
2998 "cs46xx: GETOPTR bytes=%d blocks=%d ptr=%d\n",
2999 cinfo.bytes,cinfo.blocks,cinfo.ptr) );
3000 spin_unlock_irqrestore(&state->card->lock, flags);
3001 return copy_to_user((void *)arg, &cinfo, sizeof(cinfo));
3002 }
3003 return -ENODEV;
3004
3005 case SNDCTL_DSP_SETDUPLEX:
3006 return -EINVAL;
3007
3008 case SNDCTL_DSP_GETODELAY:
3009 if (!(file->f_mode & FMODE_WRITE))
3010 return -EINVAL;
3011 state = (struct cs_state *)card->states[1];
3012 if(state)
3013 {
3014 dmabuf = &state->dmabuf;
3015 spin_lock_irqsave(&state->card->lock, flags);
3016 cs_update_ptr(card, CS_TRUE);
3017 val = dmabuf->count;
3018 spin_unlock_irqrestore(&state->card->lock, flags);
3019 }
3020 else
3021 val = 0;
3022 return put_user(val, (int *)arg);
3023
3024 case SOUND_PCM_READ_RATE:
3025 if(file->f_mode & FMODE_READ)
3026 state = (struct cs_state *)card->states[0];
3027 else
3028 state = (struct cs_state *)card->states[1];
3029 if(state)
3030 {
3031 dmabuf = &state->dmabuf;
3032 return put_user(dmabuf->rate, (int *)arg);
3033 }
3034 return put_user(0, (int *)arg);
3035
3036
3037 case SOUND_PCM_READ_CHANNELS:
3038 if(file->f_mode & FMODE_READ)
3039 state = (struct cs_state *)card->states[0];
3040 else
3041 state = (struct cs_state *)card->states[1];
3042 if(state)
3043 {
3044 dmabuf = &state->dmabuf;
3045 return put_user((dmabuf->fmt & CS_FMT_STEREO) ? 2 : 1,
3046 (int *)arg);
3047 }
3048 return put_user(0, (int *)arg);
3049
3050 case SOUND_PCM_READ_BITS:
3051 if(file->f_mode & FMODE_READ)
3052 state = (struct cs_state *)card->states[0];
3053 else
3054 state = (struct cs_state *)card->states[1];
3055 if(state)
3056 {
3057 dmabuf = &state->dmabuf;
3058 return put_user((dmabuf->fmt & CS_FMT_16BIT) ?
3059 AFMT_S16_LE : AFMT_U8, (int *)arg);
3060
3061 }
3062 return put_user(0, (int *)arg);
3063
3064 case SNDCTL_DSP_MAPINBUF:
3065 case SNDCTL_DSP_MAPOUTBUF:
3066 case SNDCTL_DSP_SETSYNCRO:
3067 case SOUND_PCM_WRITE_FILTER:
3068 case SOUND_PCM_READ_FILTER:
3069 return -EINVAL;
3070 }
3071 return -EINVAL;
3072 }
3073
3074
3075 /*
3076 * AMP control - null AMP
3077 */
3078
3079 static void amp_none(struct cs_card *card, int change)
3080 {
3081 }
3082
3083 /*
3084 * Crystal EAPD mode
3085 */
3086
3087 static void amp_voyetra(struct cs_card *card, int change)
3088 {
3089 /* Manage the EAPD bit on the Crystal 4297
3090 and the Analog AD1885 */
3091
3092 int old=card->amplifier;
3093
3094 card->amplifier+=change;
3095 if(card->amplifier && !old)
3096 {
3097 /* Turn the EAPD amp on */
3098 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL,
3099 cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) |
3100 0x8000);
3101 }
3102 else if(old && !card->amplifier)
3103 {
3104 /* Turn the EAPD amp off */
3105 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL,
3106 cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
3107 ~0x8000);
3108 }
3109 }
3110
3111
3112 /*
3113 * Game Theatre XP card - EGPIO[2] is used to enable the external amp.
3114 */
3115
3116 static void amp_hercules(struct cs_card *card, int change)
3117 {
3118 int old=card->amplifier;
3119 if(!card)
3120 {
3121 CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
3122 "cs46xx: amp_hercules() called before initialized.\n"));
3123 return;
3124 }
3125 card->amplifier+=change;
3126 if( (card->amplifier && !old) && !(hercules_egpio_disable))
3127 {
3128 CS_DBGOUT(CS_PARMS, 4, printk(KERN_INFO
3129 "cs46xx: amp_hercules() external amp enabled\n"));
3130 cs461x_pokeBA0(card, BA0_EGPIODR,
3131 EGPIODR_GPOE2); /* enable EGPIO2 output */
3132 cs461x_pokeBA0(card, BA0_EGPIOPTR,
3133 EGPIOPTR_GPPT2); /* open-drain on output */
3134 }
3135 else if(old && !card->amplifier)
3136 {
3137 CS_DBGOUT(CS_PARMS, 4, printk(KERN_INFO
3138 "cs46xx: amp_hercules() external amp disabled\n"));
3139 cs461x_pokeBA0(card, BA0_EGPIODR, 0); /* disable */
3140 cs461x_pokeBA0(card, BA0_EGPIOPTR, 0); /* disable */
3141 }
3142 }
3143
3144 /*
3145 * Handle the CLKRUN on a thinkpad. We must disable CLKRUN support
3146 * whenever we need to beat on the chip.
3147 *
3148 * The original idea and code for this hack comes from David Kaiser at
3149 * Linuxcare. Perhaps one day Crystal will document their chips well
3150 * enough to make them useful.
3151 */
3152
3153 static void clkrun_hack(struct cs_card *card, int change)
3154 {
3155 struct pci_dev *acpi_dev;
3156 u16 control;
3157 u8 pp;
3158 unsigned long port;
3159 int old=card->active;
3160
3161 card->active+=change;
3162
3163 acpi_dev = pci_find_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371AB_3, NULL);
3164 if(acpi_dev == NULL)
3165 return; /* Not a thinkpad thats for sure */
3166
3167 /* Find the control port */
3168 pci_read_config_byte(acpi_dev, 0x41, &pp);
3169 port=pp<<8;
3170
3171 /* Read ACPI port */
3172 control=inw(port+0x10);
3173
3174 /* Flip CLKRUN off while running */
3175 if(!card->active && old)
3176 {
3177 CS_DBGOUT(CS_PARMS , 9, printk( KERN_INFO
3178 "cs46xx: clkrun() enable clkrun - change=%d active=%d\n",
3179 change,card->active));
3180 outw(control|0x2000, port+0x10);
3181 }
3182 else
3183 {
3184 /*
3185 * sometimes on a resume the bit is set, so always reset the bit.
3186 */
3187 CS_DBGOUT(CS_PARMS , 9, printk( KERN_INFO
3188 "cs46xx: clkrun() disable clkrun - change=%d active=%d\n",
3189 change,card->active));
3190 outw(control&~0x2000, port+0x10);
3191 }
3192 }
3193
3194
3195 static int cs_open(struct inode *inode, struct file *file)
3196 {
3197 struct cs_card *card = (struct cs_card *)file->private_data;
3198 struct cs_state *state = NULL;
3199 struct dmabuf *dmabuf = NULL;
3200 struct list_head *entry;
3201 int minor = MINOR(inode->i_rdev);
3202 int ret=0;
3203 unsigned int tmp;
3204
3205 CS_DBGOUT(CS_OPEN | CS_FUNCTION, 2, printk("cs46xx: cs_open()+ file=0x%x %s %s\n",
3206 (unsigned)file, file->f_mode & FMODE_WRITE ? "FMODE_WRITE" : "",
3207 file->f_mode & FMODE_READ ? "FMODE_READ" : "") );
3208
3209 list_for_each(entry, &cs46xx_devs)
3210 {
3211 card = list_entry(entry, struct cs_card, list);
3212
3213 if (!((card->dev_audio ^ minor) & ~0xf))
3214 break;
3215 }
3216 if (entry == &cs46xx_devs)
3217 return -ENODEV;
3218 if (!card) {
3219 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 2, printk(KERN_INFO
3220 "cs46xx: cs_open(): Error - unable to find audio card struct\n"));
3221 return -ENODEV;
3222 }
3223
3224 /*
3225 * hardcode state[0] for capture, [1] for playback
3226 */
3227 if(file->f_mode & FMODE_READ)
3228 {
3229 CS_DBGOUT(CS_WAVE_READ, 2, printk("cs46xx: cs_open() FMODE_READ\n") );
3230 if (card->states[0] == NULL) {
3231 state = card->states[0] = (struct cs_state *)
3232 kmalloc(sizeof(struct cs_state), GFP_KERNEL);
3233 if (state == NULL)
3234 return -ENOMEM;
3235 memset(state, 0, sizeof(struct cs_state));
3236 init_MUTEX(&state->sem);
3237 dmabuf = &state->dmabuf;
3238 dmabuf->pbuf = (void *)get_free_page(GFP_KERNEL | GFP_DMA);
3239 if(dmabuf->pbuf==NULL)
3240 {
3241 kfree(state);
3242 card->states[0]=NULL;
3243 return -ENOMEM;
3244 }
3245 }
3246 else
3247 {
3248 state = card->states[0];
3249 if(state->open_mode & FMODE_READ)
3250 return -EBUSY;
3251 }
3252 dmabuf->channel = card->alloc_rec_pcm_channel(card);
3253
3254 if (dmabuf->channel == NULL) {
3255 kfree (card->states[0]);
3256 card->states[0] = NULL;;
3257 return -ENODEV;
3258 }
3259
3260 /* Now turn on external AMP if needed */
3261 state->card = card;
3262 state->card->active_ctrl(state->card,1);
3263 state->card->amplifier_ctrl(state->card,1);
3264
3265 if( (tmp = cs46xx_powerup(card, CS_POWER_ADC)) )
3266 {
3267 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3268 "cs46xx: cs46xx_powerup of ADC failed (0x%x)\n",tmp) );
3269 return -EIO;
3270 }
3271
3272 dmabuf->channel->state = state;
3273 /* initialize the virtual channel */
3274 state->virt = 0;
3275 state->magic = CS_STATE_MAGIC;
3276 init_waitqueue_head(&dmabuf->wait);
3277 init_MUTEX(&state->open_sem);
3278 file->private_data = card;
3279
3280 down(&state->open_sem);
3281
3282 /* set default sample format. According to OSS Programmer's Guide /dev/dsp
3283 should be default to unsigned 8-bits, mono, with sample rate 8kHz and
3284 /dev/dspW will accept 16-bits sample */
3285
3286 /* Default input is 8bit mono */
3287 dmabuf->fmt &= ~CS_FMT_MASK;
3288 dmabuf->type = CS_TYPE_ADC;
3289 dmabuf->ossfragshift = 0;
3290 dmabuf->ossmaxfrags = 0;
3291 dmabuf->subdivision = 0;
3292 cs_set_adc_rate(state, 8000);
3293 cs_set_divisor(dmabuf);
3294
3295 state->open_mode |= FMODE_READ;
3296 up(&state->open_sem);
3297 }
3298 if(file->f_mode & FMODE_WRITE)
3299 {
3300 CS_DBGOUT(CS_OPEN, 2, printk("cs46xx: cs_open() FMODE_WRITE\n") );
3301 if (card->states[1] == NULL) {
3302 state = card->states[1] = (struct cs_state *)
3303 kmalloc(sizeof(struct cs_state), GFP_KERNEL);
3304 if (state == NULL)
3305 return -ENOMEM;
3306 memset(state, 0, sizeof(struct cs_state));
3307 init_MUTEX(&state->sem);
3308 dmabuf = &state->dmabuf;
3309 dmabuf->pbuf = (void *)get_free_page(GFP_KERNEL | GFP_DMA);
3310 if(dmabuf->pbuf==NULL)
3311 {
3312 kfree(state);
3313 card->states[1]=NULL;
3314 return -ENOMEM;
3315 }
3316 }
3317 else
3318 {
3319 state = card->states[1];
3320 if(state->open_mode & FMODE_WRITE)
3321 return -EBUSY;
3322 }
3323 dmabuf->channel = card->alloc_pcm_channel(card);
3324
3325 if (dmabuf->channel == NULL) {
3326 kfree (card->states[1]);
3327 card->states[1] = NULL;;
3328 return -ENODEV;
3329 }
3330
3331 /* Now turn on external AMP if needed */
3332 state->card = card;
3333 state->card->active_ctrl(state->card,1);
3334 state->card->amplifier_ctrl(state->card,1);
3335
3336 if( (tmp = cs46xx_powerup(card, CS_POWER_DAC)) )
3337 {
3338 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3339 "cs46xx: cs46xx_powerup of DAC failed (0x%x)\n",tmp) );
3340 return -EIO;
3341 }
3342
3343 dmabuf->channel->state = state;
3344 /* initialize the virtual channel */
3345 state->virt = 1;
3346 state->magic = CS_STATE_MAGIC;
3347 init_waitqueue_head(&dmabuf->wait);
3348 init_MUTEX(&state->open_sem);
3349 file->private_data = card;
3350
3351 down(&state->open_sem);
3352
3353 /* set default sample format. According to OSS Programmer's Guide /dev/dsp
3354 should be default to unsigned 8-bits, mono, with sample rate 8kHz and
3355 /dev/dspW will accept 16-bits sample */
3356
3357 /* Default output is 8bit mono. */
3358 dmabuf->fmt &= ~CS_FMT_MASK;
3359 dmabuf->type = CS_TYPE_DAC;
3360 dmabuf->ossfragshift = 0;
3361 dmabuf->ossmaxfrags = 0;
3362 dmabuf->subdivision = 0;
3363 cs_set_dac_rate(state, 8000);
3364 cs_set_divisor(dmabuf);
3365
3366 state->open_mode |= FMODE_WRITE;
3367 up(&state->open_sem);
3368 if((ret = prog_dmabuf(state)))
3369 return ret;
3370 }
3371 MOD_INC_USE_COUNT; /* for 2.2 */
3372 CS_DBGOUT(CS_OPEN | CS_FUNCTION, 2, printk("cs46xx: cs_open()- 0\n") );
3373 return 0;
3374 }
3375
3376 static int cs_release(struct inode *inode, struct file *file)
3377 {
3378 struct cs_card *card = (struct cs_card *)file->private_data;
3379 struct dmabuf *dmabuf;
3380 struct cs_state *state;
3381 unsigned int tmp;
3382 CS_DBGOUT(CS_RELEASE | CS_FUNCTION, 2, printk("cs46xx: cs_release()+ file=0x%x %s %s\n",
3383 (unsigned)file, file->f_mode & FMODE_WRITE ? "FMODE_WRITE" : "",
3384 file->f_mode & FMODE_READ ? "FMODE_READ" : "") );
3385
3386 if (!(file->f_mode & (FMODE_WRITE | FMODE_READ)))
3387 {
3388 return -EINVAL;
3389 }
3390 state = card->states[1];
3391 if(state)
3392 {
3393 if ( (state->open_mode & FMODE_WRITE) & (file->f_mode & FMODE_WRITE) )
3394 {
3395 CS_DBGOUT(CS_RELEASE, 2, printk("cs46xx: cs_release() FMODE_WRITE\n") );
3396 dmabuf = &state->dmabuf;
3397 cs_clear_tail(state);
3398 drain_dac(state, file->f_flags & O_NONBLOCK);
3399 /* stop DMA state machine and free DMA buffers/channels */
3400 down(&state->open_sem);
3401 stop_dac(state);
3402 dealloc_dmabuf(state);
3403 state->card->free_pcm_channel(state->card, dmabuf->channel->num);
3404 free_page((unsigned long)state->dmabuf.pbuf);
3405
3406 /* we're covered by the open_sem */
3407 up(&state->open_sem);
3408 state->card->states[state->virt] = NULL;
3409 state->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
3410
3411 if( (tmp = cs461x_powerdown(card, CS_POWER_DAC, CS_FALSE )) )
3412 {
3413 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
3414 "cs46xx: cs_release_mixdev() powerdown DAC failure (0x%x)\n",tmp) );
3415 }
3416
3417 /* Now turn off external AMP if needed */
3418 state->card->amplifier_ctrl(state->card, -1);
3419 state->card->active_ctrl(state->card, -1);
3420
3421 kfree(state);
3422 }
3423 }
3424
3425 state = card->states[0];
3426 if(state)
3427 {
3428 if ( (state->open_mode & FMODE_READ) & (file->f_mode & FMODE_READ) )
3429 {
3430 CS_DBGOUT(CS_RELEASE, 2, printk("cs46xx: cs_release() FMODE_READ\n") );
3431 dmabuf = &state->dmabuf;
3432 down(&state->open_sem);
3433 stop_adc(state);
3434 dealloc_dmabuf(state);
3435 state->card->free_pcm_channel(state->card, dmabuf->channel->num);
3436 free_page((unsigned long)state->dmabuf.pbuf);
3437
3438 /* we're covered by the open_sem */
3439 up(&state->open_sem);
3440 state->card->states[state->virt] = NULL;
3441 state->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
3442
3443 if( (tmp = cs461x_powerdown(card, CS_POWER_ADC, CS_FALSE )) )
3444 {
3445 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
3446 "cs46xx: cs_release_mixdev() powerdown ADC failure (0x%x)\n",tmp) );
3447 }
3448
3449 /* Now turn off external AMP if needed */
3450 state->card->amplifier_ctrl(state->card, -1);
3451 state->card->active_ctrl(state->card, -1);
3452
3453 kfree(state);
3454 }
3455 }
3456
3457 CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 2, printk("cs46xx: cs_release()- 0\n") );
3458 MOD_DEC_USE_COUNT; /* For 2.2 */
3459 return 0;
3460 }
3461
3462 static void printpm(struct cs_card *s)
3463 {
3464 CS_DBGOUT(CS_PM, 9, printk("pm struct:\n"));
3465 CS_DBGOUT(CS_PM, 9, printk("flags:0x%x u32CLKCR1_SAVE: 0%x u32SSPMValue: 0x%x\n",
3466 (unsigned)s->pm.flags,s->pm.u32CLKCR1_SAVE,s->pm.u32SSPMValue));
3467 CS_DBGOUT(CS_PM, 9, printk("u32PPLVCvalue: 0x%x u32PPRVCvalue: 0x%x\n",
3468 s->pm.u32PPLVCvalue,s->pm.u32PPRVCvalue));
3469 CS_DBGOUT(CS_PM, 9, printk("u32FMLVCvalue: 0x%x u32FMRVCvalue: 0x%x\n",
3470 s->pm.u32FMLVCvalue,s->pm.u32FMRVCvalue));
3471 CS_DBGOUT(CS_PM, 9, printk("u32GPIORvalue: 0x%x u32JSCTLvalue: 0x%x\n",
3472 s->pm.u32GPIORvalue,s->pm.u32JSCTLvalue));
3473 CS_DBGOUT(CS_PM, 9, printk("u32SSCR: 0x%x u32SRCSA: 0x%x\n",
3474 s->pm.u32SSCR,s->pm.u32SRCSA));
3475 CS_DBGOUT(CS_PM, 9, printk("u32DacASR: 0x%x u32AdcASR: 0x%x\n",
3476 s->pm.u32DacASR,s->pm.u32AdcASR));
3477 CS_DBGOUT(CS_PM, 9, printk("u32DacSR: 0x%x u32AdcSR: 0x%x\n",
3478 s->pm.u32DacSR,s->pm.u32AdcSR));
3479 CS_DBGOUT(CS_PM, 9, printk("u32MIDCR_Save: 0x%x\n",
3480 s->pm.u32MIDCR_Save));
3481 CS_DBGOUT(CS_PM, 9, printk("u32AC97_powerdown: 0x%x _general_purpose 0x%x\n",
3482 s->pm.u32AC97_powerdown,s->pm.u32AC97_general_purpose));
3483 CS_DBGOUT(CS_PM, 9, printk("u32AC97_master_volume: 0x%x\n",
3484 s->pm.u32AC97_master_volume));
3485 CS_DBGOUT(CS_PM, 9, printk("u32AC97_headphone_volume: 0x%x\n",
3486 s->pm.u32AC97_headphone_volume));
3487 CS_DBGOUT(CS_PM, 9, printk("u32AC97_master_volume_mono: 0x%x\n",
3488 s->pm.u32AC97_master_volume_mono));
3489 CS_DBGOUT(CS_PM, 9, printk("u32AC97_pcm_out_volume: 0x%x\n",
3490 s->pm.u32AC97_pcm_out_volume));
3491 CS_DBGOUT(CS_PM, 9, printk("dmabuf_swptr_play: 0x%x dmabuf_count_play: %d\n",
3492 s->pm.dmabuf_swptr_play,s->pm.dmabuf_count_play));
3493 CS_DBGOUT(CS_PM, 9, printk("dmabuf_swptr_capture: 0x%x dmabuf_count_capture: %d\n",
3494 s->pm.dmabuf_swptr_capture,s->pm.dmabuf_count_capture));
3495
3496 }
3497
3498 /****************************************************************************
3499 *
3500 * Suspend - save the ac97 regs, mute the outputs and power down the part.
3501 *
3502 ****************************************************************************/
3503 void cs46xx_ac97_suspend(struct cs_card *card)
3504 {
3505 int Count,i;
3506 struct ac97_codec *dev=card->ac97_codec[0];
3507 unsigned int tmp;
3508
3509 CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_suspend()+\n"));
3510
3511 if(card->states[1])
3512 {
3513 stop_dac(card->states[1]);
3514 resync_dma_ptrs(card->states[1]);
3515 }
3516 if(card->states[0])
3517 {
3518 stop_adc(card->states[0]);
3519 resync_dma_ptrs(card->states[0]);
3520 }
3521
3522 for(Count = 0x2, i=0; (Count <= CS46XX_AC97_HIGHESTREGTORESTORE)
3523 && (i < CS46XX_AC97_NUMBER_RESTORE_REGS);
3524 Count += 2, i++)
3525 {
3526 card->pm.ac97[i] = cs_ac97_get(dev, BA0_AC97_RESET + Count);
3527 }
3528 /*
3529 * Save the ac97 volume registers as well as the current powerdown state.
3530 * Now, mute the all the outputs (master, headphone, and mono), as well
3531 * as the PCM volume, in preparation for powering down the entire part.
3532 card->pm.u32AC97_master_volume = (u32)cs_ac97_get( dev,
3533 (u8)BA0_AC97_MASTER_VOLUME);
3534 card->pm.u32AC97_headphone_volume = (u32)cs_ac97_get(dev,
3535 (u8)BA0_AC97_HEADPHONE_VOLUME);
3536 card->pm.u32AC97_master_volume_mono = (u32)cs_ac97_get(dev,
3537 (u8)BA0_AC97_MASTER_VOLUME_MONO);
3538 card->pm.u32AC97_pcm_out_volume = (u32)cs_ac97_get(dev,
3539 (u8)BA0_AC97_PCM_OUT_VOLUME);
3540 */
3541 /*
3542 * mute the outputs
3543 */
3544 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME, 0x8000);
3545 cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, 0x8000);
3546 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, 0x8000);
3547 cs_ac97_set(dev, (u8)BA0_AC97_PCM_OUT_VOLUME, 0x8000);
3548
3549 /*
3550 * save the registers that cause pops
3551 */
3552 card->pm.u32AC97_powerdown = (u32)cs_ac97_get(dev, (u8)AC97_POWER_CONTROL);
3553 card->pm.u32AC97_general_purpose = (u32)cs_ac97_get(dev, (u8)BA0_AC97_GENERAL_PURPOSE);
3554 /*
3555 * And power down everything on the AC97 codec.
3556 * well, for now, only power down the DAC/ADC and MIXER VREFON components.
3557 * trouble with removing VREF.
3558 */
3559 if( (tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
3560 CS_POWER_MIXVON, CS_TRUE )) )
3561 {
3562 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3563 "cs46xx: cs46xx_ac97_suspend() failure (0x%x)\n",tmp) );
3564 }
3565
3566 CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_suspend()-\n"));
3567 }
3568
3569 /****************************************************************************
3570 *
3571 * Resume - power up the part and restore its registers..
3572 *
3573 ****************************************************************************/
3574 void cs46xx_ac97_resume(struct cs_card *card)
3575 {
3576 int Count,i;
3577 struct ac97_codec *dev=card->ac97_codec[0];
3578
3579 CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_resume()+\n"));
3580
3581 /*
3582 * First, we restore the state of the general purpose register. This
3583 * contains the mic select (mic1 or mic2) and if we restore this after
3584 * we restore the mic volume/boost state and mic2 was selected at
3585 * suspend time, we will end up with a brief period of time where mic1
3586 * is selected with the volume/boost settings for mic2, causing
3587 * acoustic feedback. So we restore the general purpose register
3588 * first, thereby getting the correct mic selected before we restore
3589 * the mic volume/boost.
3590 */
3591 cs_ac97_set(dev, (u8)BA0_AC97_GENERAL_PURPOSE,
3592 (u16)card->pm.u32AC97_general_purpose);
3593 /*
3594 * Now, while the outputs are still muted, restore the state of power
3595 * on the AC97 part.
3596 */
3597 cs_ac97_set(dev, (u8)BA0_AC97_POWERDOWN, (u16)card->pm.u32AC97_powerdown);
3598 mdelay(5 * cs_laptop_wait);
3599 /*
3600 * Restore just the first set of registers, from register number
3601 * 0x02 to the register number that ulHighestRegToRestore specifies.
3602 */
3603 for( Count = 0x2, i=0;
3604 (Count <= CS46XX_AC97_HIGHESTREGTORESTORE)
3605 && (i < CS46XX_AC97_NUMBER_RESTORE_REGS);
3606 Count += 2, i++)
3607 {
3608 cs_ac97_set(dev, (u8)(BA0_AC97_RESET + Count), (u16)card->pm.ac97[i]);
3609 }
3610
3611 /* Check if we have to init the amplifier */
3612 if(card->amp_init)
3613 card->amp_init(card);
3614
3615 CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_resume()-\n"));
3616 }
3617
3618
3619 static int cs46xx_restart_part(struct cs_card *card)
3620 {
3621 struct dmabuf *dmabuf;
3622 CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3623 printk( "cs46xx: cs46xx_restart_part()+\n"));
3624 if(card->states[1])
3625 {
3626 dmabuf = &card->states[1]->dmabuf;
3627 dmabuf->ready = 0;
3628 resync_dma_ptrs(card->states[1]);
3629 cs_set_divisor(dmabuf);
3630 if(__prog_dmabuf(card->states[1]))
3631 {
3632 CS_DBGOUT(CS_PM | CS_ERROR, 1,
3633 printk("cs46xx: cs46xx_restart_part()- (-1) prog_dmabuf() dac error\n"));
3634 return -1;
3635 }
3636 cs_set_dac_rate(card->states[1], dmabuf->rate);
3637 }
3638 if(card->states[0])
3639 {
3640 dmabuf = &card->states[0]->dmabuf;
3641 dmabuf->ready = 0;
3642 resync_dma_ptrs(card->states[0]);
3643 cs_set_divisor(dmabuf);
3644 if(__prog_dmabuf(card->states[0]))
3645 {
3646 CS_DBGOUT(CS_PM | CS_ERROR, 1,
3647 printk("cs46xx: cs46xx_restart_part()- (-1) prog_dmabuf() adc error\n"));
3648 return -1;
3649 }
3650 cs_set_adc_rate(card->states[0], dmabuf->rate);
3651 }
3652 card->pm.flags |= CS46XX_PM_RESUMED;
3653 if(card->states[0])
3654 start_adc(card->states[0]);
3655 if(card->states[1])
3656 start_dac(card->states[1]);
3657
3658 card->pm.flags |= CS46XX_PM_IDLE;
3659 card->pm.flags &= ~(CS46XX_PM_SUSPENDING | CS46XX_PM_SUSPENDED
3660 | CS46XX_PM_RESUMING | CS46XX_PM_RESUMED);
3661 if(card->states[0])
3662 wake_up(&card->states[0]->dmabuf.wait);
3663 if(card->states[1])
3664 wake_up(&card->states[1]->dmabuf.wait);
3665
3666 CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3667 printk( "cs46xx: cs46xx_restart_part()-\n"));
3668 return 0;
3669 }
3670
3671
3672 static void cs461x_reset(struct cs_card *card);
3673 static void cs461x_proc_stop(struct cs_card *card);
3674 static int cs46xx_suspend(struct cs_card *card, u32 state)
3675 {
3676 unsigned int tmp;
3677 CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3678 printk("cs46xx: cs46xx_suspend()+ flags=0x%x s=0x%x\n",
3679 (unsigned)card->pm.flags,(unsigned)card));
3680 /*
3681 * check the current state, only suspend if IDLE
3682 */
3683 if(!(card->pm.flags & CS46XX_PM_IDLE))
3684 {
3685 CS_DBGOUT(CS_PM | CS_ERROR, 2,
3686 printk("cs46xx: cs46xx_suspend() unable to suspend, not IDLE\n"));
3687 return 1;
3688 }
3689 card->pm.flags &= ~CS46XX_PM_IDLE;
3690 card->pm.flags |= CS46XX_PM_SUSPENDING;
3691
3692 card->active_ctrl(card,1);
3693
3694 tmp = cs461x_peek(card, BA1_PFIE);
3695 tmp &= ~0x0000f03f;
3696 tmp |= 0x00000010;
3697 cs461x_poke(card, BA1_PFIE, tmp); /* playback interrupt disable */
3698
3699 tmp = cs461x_peek(card, BA1_CIE);
3700 tmp &= ~0x0000003f;
3701 tmp |= 0x00000011;
3702 cs461x_poke(card, BA1_CIE, tmp); /* capture interrupt disable */
3703
3704 /*
3705 * Stop playback DMA.
3706 */
3707 tmp = cs461x_peek(card, BA1_PCTL);
3708 cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
3709
3710 /*
3711 * Stop capture DMA.
3712 */
3713 tmp = cs461x_peek(card, BA1_CCTL);
3714 cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
3715
3716 if(card->states[1])
3717 {
3718 card->pm.dmabuf_swptr_play = card->states[1]->dmabuf.swptr;
3719 card->pm.dmabuf_count_play = card->states[1]->dmabuf.count;
3720 }
3721 if(card->states[0])
3722 {
3723 card->pm.dmabuf_swptr_capture = card->states[0]->dmabuf.swptr;
3724 card->pm.dmabuf_count_capture = card->states[0]->dmabuf.count;
3725 }
3726
3727 cs46xx_ac97_suspend(card);
3728
3729 /*
3730 * Reset the processor.
3731 */
3732 cs461x_reset(card);
3733
3734 cs461x_proc_stop(card);
3735
3736 /*
3737 * Power down the DAC and ADC. For now leave the other areas on.
3738 */
3739 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, 0x0300);
3740
3741 /*
3742 * Power down the PLL.
3743 */
3744 cs461x_pokeBA0(card, BA0_CLKCR1, 0);
3745
3746 /*
3747 * Turn off the Processor by turning off the software clock enable flag in
3748 * the clock control register.
3749 */
3750 tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE;
3751 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
3752
3753 card->active_ctrl(card,-1);
3754
3755 card->pm.flags &= ~CS46XX_PM_SUSPENDING;
3756 card->pm.flags |= CS46XX_PM_SUSPENDED;
3757
3758 printpm(card);
3759
3760 CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3761 printk("cs46xx: cs46xx_suspend()- flags=0x%x\n",
3762 (unsigned)card->pm.flags));
3763 return 0;
3764 }
3765
3766 static int cs46xx_resume(struct cs_card *card)
3767 {
3768 int i;
3769
3770 CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3771 printk( "cs46xx: cs46xx_resume()+ flags=0x%x\n",
3772 (unsigned)card->pm.flags));
3773 if(!(card->pm.flags & CS46XX_PM_SUSPENDED))
3774 {
3775 CS_DBGOUT(CS_PM | CS_ERROR, 2,
3776 printk("cs46xx: cs46xx_resume() unable to resume, not SUSPENDED\n"));
3777 return 1;
3778 }
3779 card->pm.flags |= CS46XX_PM_RESUMING;
3780 card->pm.flags &= ~CS46XX_PM_SUSPENDED;
3781 printpm(card);
3782 card->active_ctrl(card, 1);
3783
3784 for(i=0;i<5;i++)
3785 {
3786 if (cs_hardware_init(card) != 0)
3787 {
3788 CS_DBGOUT(CS_PM | CS_ERROR, 4, printk(
3789 "cs46xx: cs46xx_resume()- ERROR in cs_hardware_init()\n"));
3790 mdelay(10 * cs_laptop_wait);
3791 cs461x_reset(card);
3792 continue;
3793 }
3794 break;
3795 }
3796 if(i>=4)
3797 {
3798 CS_DBGOUT(CS_PM | CS_ERROR, 1, printk(
3799 "cs46xx: cs46xx_resume()- cs_hardware_init() failed, retried %d times.\n",i));
3800 return 0;
3801 }
3802
3803 if(cs46xx_restart_part(card))
3804 {
3805 CS_DBGOUT(CS_PM | CS_ERROR, 4, printk(
3806 "cs46xx: cs46xx_resume(): cs46xx_restart_part() returned error\n"));
3807 }
3808
3809 card->active_ctrl(card, -1);
3810
3811 CS_DBGOUT(CS_PM | CS_FUNCTION, 4, printk("cs46xx: cs46xx_resume()- flags=0x%x\n",
3812 (unsigned)card->pm.flags));
3813 return 0;
3814 }
3815
3816 static /*const*/ struct file_operations cs461x_fops = {
3817 CS_OWNER CS_THIS_MODULE
3818 llseek: no_llseek,
3819 read: cs_read,
3820 write: cs_write,
3821 poll: cs_poll,
3822 ioctl: cs_ioctl,
3823 mmap: cs_mmap,
3824 open: cs_open,
3825 release: cs_release,
3826 };
3827
3828 /* Write AC97 codec registers */
3829
3830
3831 static u16 cs_ac97_get(struct ac97_codec *dev, u8 reg)
3832 {
3833 struct cs_card *card = dev->private_data;
3834 int count,loopcnt;
3835 unsigned int tmp;
3836
3837 /*
3838 * 1. Write ACCAD = Command Address Register = 46Ch for AC97 register address
3839 * 2. Write ACCDA = Command Data Register = 470h for data to write to AC97
3840 * 3. Write ACCTL = Control Register = 460h for initiating the write
3841 * 4. Read ACCTL = 460h, DCV should be reset by now and 460h = 17h
3842 * 5. if DCV not cleared, break and return error
3843 * 6. Read ACSTS = Status Register = 464h, check VSTS bit
3844 */
3845
3846
3847 cs461x_peekBA0(card, BA0_ACSDA);
3848
3849 /*
3850 * Setup the AC97 control registers on the CS461x to send the
3851 * appropriate command to the AC97 to perform the read.
3852 * ACCAD = Command Address Register = 46Ch
3853 * ACCDA = Command Data Register = 470h
3854 * ACCTL = Control Register = 460h
3855 * set DCV - will clear when process completed
3856 * set CRW - Read command
3857 * set VFRM - valid frame enabled
3858 * set ESYN - ASYNC generation enabled
3859 * set RSTN - ARST# inactive, AC97 codec not reset
3860 */
3861
3862 cs461x_pokeBA0(card, BA0_ACCAD, reg);
3863 cs461x_pokeBA0(card, BA0_ACCDA, 0);
3864 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_DCV | ACCTL_CRW |
3865 ACCTL_VFRM | ACCTL_ESYN |
3866 ACCTL_RSTN);
3867
3868
3869 /*
3870 * Wait for the read to occur.
3871 */
3872 if(!(card->pm.flags & CS46XX_PM_IDLE))
3873 loopcnt = 2000;
3874 else
3875 loopcnt = 500 * cs_laptop_wait;
3876 loopcnt *= cs_laptop_wait;
3877 for (count = 0; count < loopcnt; count++) {
3878 /*
3879 * First, we want to wait for a short time.
3880 */
3881 udelay(10 * cs_laptop_wait);
3882 /*
3883 * Now, check to see if the read has completed.
3884 * ACCTL = 460h, DCV should be reset by now and 460h = 17h
3885 */
3886 if (!(cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV))
3887 break;
3888 }
3889
3890 /*
3891 * Make sure the read completed.
3892 */
3893 if (cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV) {
3894 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
3895 "cs46xx: AC'97 read problem (ACCTL_DCV), reg = 0x%x returning 0xffff\n", reg));
3896 return 0xffff;
3897 }
3898
3899 /*
3900 * Wait for the valid status bit to go active.
3901 */
3902
3903 if(!(card->pm.flags & CS46XX_PM_IDLE))
3904 loopcnt = 2000;
3905 else
3906 loopcnt = 1000;
3907 loopcnt *= cs_laptop_wait;
3908 for (count = 0; count < loopcnt; count++) {
3909 /*
3910 * Read the AC97 status register.
3911 * ACSTS = Status Register = 464h
3912 * VSTS - Valid Status
3913 */
3914 if (cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_VSTS)
3915 break;
3916 udelay(10 * cs_laptop_wait);
3917 }
3918
3919 /*
3920 * Make sure we got valid status.
3921 */
3922 if (!( (tmp=cs461x_peekBA0(card, BA0_ACSTS)) & ACSTS_VSTS)) {
3923 CS_DBGOUT(CS_ERROR, 2, printk(KERN_WARNING
3924 "cs46xx: AC'97 read problem (ACSTS_VSTS), reg = 0x%x val=0x%x 0xffff \n",
3925 reg, tmp));
3926 return 0xffff;
3927 }
3928
3929 /*
3930 * Read the data returned from the AC97 register.
3931 * ACSDA = Status Data Register = 474h
3932 */
3933 CS_DBGOUT(CS_FUNCTION, 9, printk(KERN_INFO
3934 "cs46xx: cs_ac97_get() reg = 0x%x, val = 0x%x, BA0_ACCAD = 0x%x\n",
3935 reg, cs461x_peekBA0(card, BA0_ACSDA),
3936 cs461x_peekBA0(card, BA0_ACCAD)));
3937 return(cs461x_peekBA0(card, BA0_ACSDA));
3938 }
3939
3940 static void cs_ac97_set(struct ac97_codec *dev, u8 reg, u16 val)
3941 {
3942 struct cs_card *card = dev->private_data;
3943 int count;
3944 int val2 = 0;
3945
3946 if(reg == AC97_CD_VOL)
3947 {
3948 val2 = cs_ac97_get(dev, AC97_CD_VOL);
3949 }
3950
3951 /*
3952 * 1. Write ACCAD = Command Address Register = 46Ch for AC97 register address
3953 * 2. Write ACCDA = Command Data Register = 470h for data to write to AC97
3954 * 3. Write ACCTL = Control Register = 460h for initiating the write
3955 * 4. Read ACCTL = 460h, DCV should be reset by now and 460h = 07h
3956 * 5. if DCV not cleared, break and return error
3957 */
3958
3959 /*
3960 * Setup the AC97 control registers on the CS461x to send the
3961 * appropriate command to the AC97 to perform the read.
3962 * ACCAD = Command Address Register = 46Ch
3963 * ACCDA = Command Data Register = 470h
3964 * ACCTL = Control Register = 460h
3965 * set DCV - will clear when process completed
3966 * reset CRW - Write command
3967 * set VFRM - valid frame enabled
3968 * set ESYN - ASYNC generation enabled
3969 * set RSTN - ARST# inactive, AC97 codec not reset
3970 */
3971 cs461x_pokeBA0(card, BA0_ACCAD, reg);
3972 cs461x_pokeBA0(card, BA0_ACCDA, val);
3973 cs461x_peekBA0(card, BA0_ACCTL);
3974 cs461x_pokeBA0(card, BA0_ACCTL, 0 | ACCTL_VFRM | ACCTL_ESYN | ACCTL_RSTN);
3975 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_DCV | ACCTL_VFRM |
3976 ACCTL_ESYN | ACCTL_RSTN);
3977 for (count = 0; count < 1000; count++) {
3978 /*
3979 * First, we want to wait for a short time.
3980 */
3981 udelay(10 * cs_laptop_wait);
3982 /*
3983 * Now, check to see if the write has completed.
3984 * ACCTL = 460h, DCV should be reset by now and 460h = 07h
3985 */
3986 if (!(cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV))
3987 break;
3988 }
3989 /*
3990 * Make sure the write completed.
3991 */
3992 if (cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV)
3993 {
3994 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
3995 "cs46xx: AC'97 write problem, reg = 0x%x, val = 0x%x\n", reg, val));
3996 }
3997
3998 /*
3999 * Adjust power if the mixer is selected/deselected according
4000 * to the CD.
4001 *
4002 * IF the CD is a valid input source (mixer or direct) AND
4003 * the CD is not muted THEN power is needed
4004 *
4005 * We do two things. When record select changes the input to
4006 * add/remove the CD we adjust the power count if the CD is
4007 * unmuted.
4008 *
4009 * When the CD mute changes we adjust the power level if the
4010 * CD was a valid input.
4011 *
4012 * We also check for CD volume != 0, as the CD mute isn't
4013 * normally tweaked from userspace.
4014 */
4015
4016 /* CD mute change ? */
4017
4018 if(reg==AC97_CD_VOL)
4019 {
4020 /* Mute bit change ? */
4021 if((val2^val)&0x8000 || ((val2 == 0x1f1f || val == 0x1f1f) && val2 != val))
4022 {
4023 /* This is a hack but its cleaner than the alternatives.
4024 Right now card->ac97_codec[0] might be NULL as we are
4025 still doing codec setup. This does an early assignment
4026 to avoid the problem if it occurs */
4027
4028 if(card->ac97_codec[0]==NULL)
4029 card->ac97_codec[0]=dev;
4030
4031 /* Mute on */
4032 if(val&0x8000 || val == 0x1f1f)
4033 card->amplifier_ctrl(card, -1);
4034 else /* Mute off power on */
4035 {
4036 if(card->amp_init)
4037 card->amp_init(card);
4038 card->amplifier_ctrl(card, 1);
4039 }
4040 }
4041 }
4042 }
4043
4044
4045 /* OSS /dev/mixer file operation methods */
4046
4047 static int cs_open_mixdev(struct inode *inode, struct file *file)
4048 {
4049 int i=0;
4050 int minor = MINOR(inode->i_rdev);
4051 struct cs_card *card=NULL;
4052 struct list_head *entry;
4053 unsigned int tmp;
4054
4055 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4,
4056 printk(KERN_INFO "cs46xx: cs_open_mixdev()+\n"));
4057
4058 list_for_each(entry, &cs46xx_devs)
4059 {
4060 card = list_entry(entry, struct cs_card, list);
4061 for (i = 0; i < NR_AC97; i++)
4062 if (card->ac97_codec[i] != NULL &&
4063 card->ac97_codec[i]->dev_mixer == minor)
4064 goto match;
4065 }
4066 if (!card)
4067 {
4068 CS_DBGOUT(CS_FUNCTION | CS_OPEN | CS_ERROR, 2,
4069 printk(KERN_INFO "cs46xx: cs46xx_open_mixdev()- -ENODEV\n"));
4070 return -ENODEV;
4071 }
4072 match:
4073 if(!card->ac97_codec[i])
4074 return -ENODEV;
4075 file->private_data = card->ac97_codec[i];
4076
4077 card->active_ctrl(card,1);
4078 if(!CS_IN_USE(&card->mixer_use_cnt))
4079 {
4080 if( (tmp = cs46xx_powerup(card, CS_POWER_MIXVON )) )
4081 {
4082 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
4083 "cs46xx: cs_open_mixdev() powerup failure (0x%x)\n",tmp) );
4084 return -EIO;
4085 }
4086 }
4087 card->amplifier_ctrl(card, 1);
4088 CS_INC_USE_COUNT(&card->mixer_use_cnt);
4089 MOD_INC_USE_COUNT; /* for 2.2 */
4090 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4,
4091 printk(KERN_INFO "cs46xx: cs_open_mixdev()- 0\n"));
4092 return 0;
4093 }
4094
4095 static int cs_release_mixdev(struct inode *inode, struct file *file)
4096 {
4097 int minor = MINOR(inode->i_rdev);
4098 struct cs_card *card=NULL;
4099 struct list_head *entry;
4100 int i;
4101 unsigned int tmp;
4102
4103 CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 4,
4104 printk(KERN_INFO "cs46xx: cs_release_mixdev()+\n"));
4105 list_for_each(entry, &cs46xx_devs)
4106 {
4107 card = list_entry(entry, struct cs_card, list);
4108 for (i = 0; i < NR_AC97; i++)
4109 if (card->ac97_codec[i] != NULL &&
4110 card->ac97_codec[i]->dev_mixer == minor)
4111 goto match;
4112 }
4113 if (!card)
4114 {
4115 CS_DBGOUT(CS_FUNCTION | CS_OPEN | CS_ERROR, 2,
4116 printk(KERN_INFO "cs46xx: cs46xx_open_mixdev()- -ENODEV\n"));
4117 return -ENODEV;
4118 }
4119 match:
4120 MOD_DEC_USE_COUNT; /* for 2.2 */
4121 if(!CS_DEC_AND_TEST(&card->mixer_use_cnt))
4122 {
4123 CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 4,
4124 printk(KERN_INFO "cs46xx: cs_release_mixdev()- no powerdown, usecnt>0\n"));
4125 card->active_ctrl(card, -1);
4126 card->amplifier_ctrl(card, -1);
4127 return 0;
4128 }
4129 /*
4130 * ok, no outstanding mixer opens, so powerdown.
4131 */
4132 if( (tmp = cs461x_powerdown(card, CS_POWER_MIXVON, CS_FALSE )) )
4133 {
4134 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
4135 "cs46xx: cs_release_mixdev() powerdown MIXVON failure (0x%x)\n",tmp) );
4136 card->active_ctrl(card, -1);
4137 card->amplifier_ctrl(card, -1);
4138 return -EIO;
4139 }
4140 card->active_ctrl(card, -1);
4141 card->amplifier_ctrl(card, -1);
4142 CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 4,
4143 printk(KERN_INFO "cs46xx: cs_release_mixdev()- 0\n"));
4144 return 0;
4145 }
4146
4147 void __exit cs46xx_cleanup_module(void);
4148 static int cs_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd,
4149 unsigned long arg)
4150 {
4151 struct ac97_codec *codec = (struct ac97_codec *)file->private_data;
4152 struct cs_card *card=NULL;
4153 struct list_head *entry;
4154
4155 #if CSDEBUG_INTERFACE
4156 int val;
4157
4158 if( (cmd == SOUND_MIXER_CS_GETDBGMASK) ||
4159 (cmd == SOUND_MIXER_CS_SETDBGMASK) ||
4160 (cmd == SOUND_MIXER_CS_GETDBGLEVEL) ||
4161 (cmd == SOUND_MIXER_CS_SETDBGLEVEL) ||
4162 (cmd == SOUND_MIXER_CS_APM))
4163 {
4164 switch(cmd)
4165 {
4166
4167 case SOUND_MIXER_CS_GETDBGMASK:
4168 return put_user(cs_debugmask, (unsigned long *)arg);
4169
4170 case SOUND_MIXER_CS_GETDBGLEVEL:
4171 return put_user(cs_debuglevel, (unsigned long *)arg);
4172
4173 case SOUND_MIXER_CS_SETDBGMASK:
4174 if (get_user(val, (unsigned long *)arg))
4175 return -EFAULT;
4176 cs_debugmask = val;
4177 return 0;
4178
4179 case SOUND_MIXER_CS_SETDBGLEVEL:
4180 if (get_user(val, (unsigned long *)arg))
4181 return -EFAULT;
4182 cs_debuglevel = val;
4183 return 0;
4184
4185 case SOUND_MIXER_CS_APM:
4186 if (get_user(val, (unsigned long *) arg))
4187 return -EFAULT;
4188 if(val == CS_IOCTL_CMD_SUSPEND)
4189 {
4190 list_for_each(entry, &cs46xx_devs)
4191 {
4192 card = list_entry(entry, struct cs_card, list);
4193 cs46xx_suspend(card, 0);
4194 }
4195
4196 }
4197 else if(val == CS_IOCTL_CMD_RESUME)
4198 {
4199 list_for_each(entry, &cs46xx_devs)
4200 {
4201 card = list_entry(entry, struct cs_card, list);
4202 cs46xx_resume(card);
4203 }
4204 }
4205 else
4206 {
4207 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
4208 "cs46xx: mixer_ioctl(): invalid APM cmd (%d)\n",
4209 val));
4210 }
4211 return 0;
4212
4213 default:
4214 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
4215 "cs46xx: mixer_ioctl(): ERROR unknown debug cmd\n") );
4216 return 0;
4217 }
4218 }
4219 #endif
4220 return codec->mixer_ioctl(codec, cmd, arg);
4221 }
4222
4223 static /*const*/ struct file_operations cs_mixer_fops = {
4224 CS_OWNER CS_THIS_MODULE
4225 llseek: no_llseek,
4226 ioctl: cs_ioctl_mixdev,
4227 open: cs_open_mixdev,
4228 release: cs_release_mixdev,
4229 };
4230
4231 /* AC97 codec initialisation. */
4232 static int __init cs_ac97_init(struct cs_card *card)
4233 {
4234 int num_ac97 = 0;
4235 int ready_2nd = 0;
4236 struct ac97_codec *codec;
4237 u16 eid;
4238
4239 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4240 "cs46xx: cs_ac97_init()+\n") );
4241
4242 for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
4243 if ((codec = kmalloc(sizeof(struct ac97_codec), GFP_KERNEL)) == NULL)
4244 return -ENOMEM;
4245 memset(codec, 0, sizeof(struct ac97_codec));
4246
4247 /* initialize some basic codec information, other fields will be filled
4248 in ac97_probe_codec */
4249 codec->private_data = card;
4250 codec->id = num_ac97;
4251
4252 codec->codec_read = cs_ac97_get;
4253 codec->codec_write = cs_ac97_set;
4254
4255 if (ac97_probe_codec(codec) == 0)
4256 {
4257 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4258 "cs46xx: cs_ac97_init()- codec number %d not found\n",
4259 num_ac97) );
4260 card->ac97_codec[num_ac97] = 0;
4261 break;
4262 }
4263 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4264 "cs46xx: cs_ac97_init() found codec %d\n",num_ac97) );
4265
4266 eid = cs_ac97_get(codec, AC97_EXTENDED_ID);
4267
4268 if(eid==0xFFFFFF)
4269 {
4270 printk(KERN_WARNING "cs46xx: codec %d not present\n",num_ac97);
4271 kfree(codec);
4272 break;
4273 }
4274
4275 card->ac97_features = eid;
4276
4277 if ((codec->dev_mixer = register_sound_mixer(&cs_mixer_fops, -1)) < 0) {
4278 printk(KERN_ERR "cs46xx: couldn't register mixer!\n");
4279 kfree(codec);
4280 break;
4281 }
4282 card->ac97_codec[num_ac97] = codec;
4283
4284 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4285 "cs46xx: cs_ac97_init() ac97_codec[%d] set to 0x%x\n",
4286 (unsigned int)num_ac97,
4287 (unsigned int)codec));
4288 /* if there is no secondary codec at all, don't probe any more */
4289 if (!ready_2nd)
4290 {
4291 num_ac97 += 1;
4292 break;
4293 }
4294 }
4295 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4296 "cs46xx: cs_ac97_init()- %d\n", (unsigned int)num_ac97));
4297 return num_ac97;
4298 }
4299
4300 /*
4301 * load the static image into the DSP
4302 */
4303 #include "cs461x_image.h"
4304 static void cs461x_download_image(struct cs_card *card)
4305 {
4306 unsigned i, j, temp1, temp2, offset, count;
4307 unsigned char *pBA1 = ioremap(card->ba1_addr, 0x40000);
4308 for( i=0; i < CLEAR__COUNT; i++)
4309 {
4310 offset = ClrStat[i].BA1__DestByteOffset;
4311 count = ClrStat[i].BA1__SourceSize;
4312 for( temp1 = offset; temp1<(offset+count); temp1+=4 );
4313 writel(0, pBA1+temp1);
4314 }
4315
4316 for(i=0; i<FILL__COUNT; i++)
4317 {
4318 temp2 = FillStat[i].Offset;
4319 for(j=0; j<(FillStat[i].Size)/4; j++)
4320 {
4321 temp1 = (FillStat[i]).pFill[j];
4322 writel(temp1, pBA1+temp2+j*4);
4323 }
4324 }
4325 iounmap(pBA1);
4326 }
4327
4328
4329 /*
4330 * Chip reset
4331 */
4332
4333 static void cs461x_reset(struct cs_card *card)
4334 {
4335 int idx;
4336
4337 /*
4338 * Write the reset bit of the SP control register.
4339 */
4340 cs461x_poke(card, BA1_SPCR, SPCR_RSTSP);
4341
4342 /*
4343 * Write the control register.
4344 */
4345 cs461x_poke(card, BA1_SPCR, SPCR_DRQEN);
4346
4347 /*
4348 * Clear the trap registers.
4349 */
4350 for (idx = 0; idx < 8; idx++) {
4351 cs461x_poke(card, BA1_DREG, DREG_REGID_TRAP_SELECT + idx);
4352 cs461x_poke(card, BA1_TWPR, 0xFFFF);
4353 }
4354 cs461x_poke(card, BA1_DREG, 0);
4355
4356 /*
4357 * Set the frame timer to reflect the number of cycles per frame.
4358 */
4359 cs461x_poke(card, BA1_FRMT, 0xadf);
4360 }
4361
4362 static void cs461x_clear_serial_FIFOs(struct cs_card *card, int type)
4363 {
4364 int idx, loop, startfifo=0, endfifo=0, powerdown1 = 0;
4365 unsigned int tmp;
4366
4367 /*
4368 * See if the devices are powered down. If so, we must power them up first
4369 * or they will not respond.
4370 */
4371 if (!((tmp = cs461x_peekBA0(card, BA0_CLKCR1)) & CLKCR1_SWCE)) {
4372 cs461x_pokeBA0(card, BA0_CLKCR1, tmp | CLKCR1_SWCE);
4373 powerdown1 = 1;
4374 }
4375
4376 /*
4377 * We want to clear out the serial port FIFOs so we don't end up playing
4378 * whatever random garbage happens to be in them. We fill the sample FIFOS
4379 * with zero (silence).
4380 */
4381 cs461x_pokeBA0(card, BA0_SERBWP, 0);
4382
4383 /*
4384 * Check for which FIFO locations to clear, if we are currently
4385 * playing or capturing then we don't want to put in 128 bytes of
4386 * "noise".
4387 */
4388 if(type & CS_TYPE_DAC)
4389 {
4390 startfifo = 128;
4391 endfifo = 256;
4392 }
4393 if(type & CS_TYPE_ADC)
4394 {
4395 startfifo = 0;
4396 if(!endfifo)
4397 endfifo = 128;
4398 }
4399 /*
4400 * Fill sample FIFO locations (256 locations total).
4401 */
4402 for (idx = startfifo; idx < endfifo; idx++) {
4403 /*
4404 * Make sure the previous FIFO write operation has completed.
4405 */
4406 for (loop = 0; loop < 5; loop++) {
4407 udelay(50);
4408 if (!(cs461x_peekBA0(card, BA0_SERBST) & SERBST_WBSY))
4409 break;
4410 }
4411 if (cs461x_peekBA0(card, BA0_SERBST) & SERBST_WBSY) {
4412 if (powerdown1)
4413 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
4414 }
4415 /*
4416 * Write the serial port FIFO index.
4417 */
4418 cs461x_pokeBA0(card, BA0_SERBAD, idx);
4419 /*
4420 * Tell the serial port to load the new value into the FIFO location.
4421 */
4422 cs461x_pokeBA0(card, BA0_SERBCM, SERBCM_WRC);
4423 }
4424 /*
4425 * Now, if we powered up the devices, then power them back down again.
4426 * This is kinda ugly, but should never happen.
4427 */
4428 if (powerdown1)
4429 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
4430 }
4431
4432
4433 static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspendflag)
4434 {
4435 int count;
4436 unsigned int tmp=0,muted=0;
4437
4438 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO
4439 "cs46xx: cs461x_powerdown()+ type=0x%x\n",type));
4440 if(!cs_powerdown && !suspendflag)
4441 {
4442 CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4443 "cs46xx: cs461x_powerdown() DISABLED exiting\n"));
4444 return 0;
4445 }
4446 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4447 CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4448 "cs46xx: cs461x_powerdown() powerdown reg=0x%x\n",tmp));
4449 /*
4450 * if powering down only the VREF, and not powering down the DAC/ADC,
4451 * then do not power down the VREF, UNLESS both the DAC and ADC are not
4452 * currently powered down. If powering down DAC and ADC, then
4453 * it is possible to power down the VREF (ON).
4454 */
4455 if ( ((type & CS_POWER_MIXVON) &&
4456 (!(type & CS_POWER_ADC) || (!(type & CS_POWER_DAC))) )
4457 &&
4458 ((tmp & CS_AC97_POWER_CONTROL_ADC_ON) ||
4459 (tmp & CS_AC97_POWER_CONTROL_DAC_ON) ) )
4460 {
4461 CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4462 "cs46xx: cs461x_powerdown()- 0 unable to powerdown. tmp=0x%x\n",tmp));
4463 return 0;
4464 }
4465 /*
4466 * for now, always keep power to the mixer block.
4467 * not sure why it's a problem but it seems to be if we power off.
4468 */
4469 type &= ~CS_POWER_MIXVON;
4470 type &= ~CS_POWER_MIXVOFF;
4471
4472 /*
4473 * Power down indicated areas.
4474 */
4475 if(type & CS_POWER_MIXVOFF)
4476 {
4477
4478 CS_DBGOUT(CS_FUNCTION, 4,
4479 printk(KERN_INFO "cs46xx: cs461x_powerdown()+ MIXVOFF\n"));
4480 /*
4481 * Power down the MIXER (VREF ON) on the AC97 card.
4482 */
4483 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4484 if (tmp & CS_AC97_POWER_CONTROL_MIXVOFF_ON)
4485 {
4486 if(!muted)
4487 {
4488 cs_mute(card, CS_TRUE);
4489 muted=1;
4490 }
4491 tmp |= CS_AC97_POWER_CONTROL_MIXVOFF;
4492 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4493 /*
4494 * Now, we wait until we sample a ready state.
4495 */
4496 for (count = 0; count < 32; count++) {
4497 /*
4498 * First, lets wait a short while to let things settle out a
4499 * bit, and to prevent retrying the read too quickly.
4500 */
4501 udelay(500);
4502
4503 /*
4504 * Read the current state of the power control register.
4505 */
4506 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4507 CS_AC97_POWER_CONTROL_MIXVOFF_ON))
4508 break;
4509 }
4510
4511 /*
4512 * Check the status..
4513 */
4514 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4515 CS_AC97_POWER_CONTROL_MIXVOFF_ON)
4516 {
4517 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4518 "cs46xx: powerdown MIXVOFF failed\n"));
4519 return 1;
4520 }
4521 }
4522 }
4523 if(type & CS_POWER_MIXVON)
4524 {
4525
4526 CS_DBGOUT(CS_FUNCTION, 4,
4527 printk(KERN_INFO "cs46xx: cs461x_powerdown()+ MIXVON\n"));
4528 /*
4529 * Power down the MIXER (VREF ON) on the AC97 card.
4530 */
4531 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4532 if (tmp & CS_AC97_POWER_CONTROL_MIXVON_ON)
4533 {
4534 if(!muted)
4535 {
4536 cs_mute(card, CS_TRUE);
4537 muted=1;
4538 }
4539 tmp |= CS_AC97_POWER_CONTROL_MIXVON;
4540 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4541 /*
4542 * Now, we wait until we sample a ready state.
4543 */
4544 for (count = 0; count < 32; count++) {
4545 /*
4546 * First, lets wait a short while to let things settle out a
4547 * bit, and to prevent retrying the read too quickly.
4548 */
4549 udelay(500);
4550
4551 /*
4552 * Read the current state of the power control register.
4553 */
4554 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4555 CS_AC97_POWER_CONTROL_MIXVON_ON))
4556 break;
4557 }
4558
4559 /*
4560 * Check the status..
4561 */
4562 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4563 CS_AC97_POWER_CONTROL_MIXVON_ON)
4564 {
4565 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4566 "cs46xx: powerdown MIXVON failed\n"));
4567 return 1;
4568 }
4569 }
4570 }
4571 if(type & CS_POWER_ADC)
4572 {
4573 /*
4574 * Power down the ADC on the AC97 card.
4575 */
4576 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO "cs46xx: cs461x_powerdown()+ ADC\n"));
4577 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4578 if (tmp & CS_AC97_POWER_CONTROL_ADC_ON)
4579 {
4580 if(!muted)
4581 {
4582 cs_mute(card, CS_TRUE);
4583 muted=1;
4584 }
4585 tmp |= CS_AC97_POWER_CONTROL_ADC;
4586 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4587
4588 /*
4589 * Now, we wait until we sample a ready state.
4590 */
4591 for (count = 0; count < 32; count++) {
4592 /*
4593 * First, lets wait a short while to let things settle out a
4594 * bit, and to prevent retrying the read too quickly.
4595 */
4596 udelay(500);
4597
4598 /*
4599 * Read the current state of the power control register.
4600 */
4601 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4602 CS_AC97_POWER_CONTROL_ADC_ON))
4603 break;
4604 }
4605
4606 /*
4607 * Check the status..
4608 */
4609 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4610 CS_AC97_POWER_CONTROL_ADC_ON)
4611 {
4612 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4613 "cs46xx: powerdown ADC failed\n"));
4614 return 1;
4615 }
4616 }
4617 }
4618 if(type & CS_POWER_DAC)
4619 {
4620 /*
4621 * Power down the DAC on the AC97 card.
4622 */
4623
4624 CS_DBGOUT(CS_FUNCTION, 4,
4625 printk(KERN_INFO "cs46xx: cs461x_powerdown()+ DAC\n"));
4626 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4627 if (tmp & CS_AC97_POWER_CONTROL_DAC_ON)
4628 {
4629 if(!muted)
4630 {
4631 cs_mute(card, CS_TRUE);
4632 muted=1;
4633 }
4634 tmp |= CS_AC97_POWER_CONTROL_DAC;
4635 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4636 /*
4637 * Now, we wait until we sample a ready state.
4638 */
4639 for (count = 0; count < 32; count++) {
4640 /*
4641 * First, lets wait a short while to let things settle out a
4642 * bit, and to prevent retrying the read too quickly.
4643 */
4644 udelay(500);
4645
4646 /*
4647 * Read the current state of the power control register.
4648 */
4649 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4650 CS_AC97_POWER_CONTROL_DAC_ON))
4651 break;
4652 }
4653
4654 /*
4655 * Check the status..
4656 */
4657 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4658 CS_AC97_POWER_CONTROL_DAC_ON)
4659 {
4660 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4661 "cs46xx: powerdown DAC failed\n"));
4662 return 1;
4663 }
4664 }
4665 }
4666 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4667 if(muted)
4668 cs_mute(card, CS_FALSE);
4669 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO
4670 "cs46xx: cs461x_powerdown()- 0 tmp=0x%x\n",tmp));
4671 return 0;
4672 }
4673
4674 static int cs46xx_powerup(struct cs_card *card, unsigned int type)
4675 {
4676 int count;
4677 unsigned int tmp=0,muted=0;
4678
4679 CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4680 "cs46xx: cs46xx_powerup()+ type=0x%x\n",type));
4681 /*
4682 * check for VREF and powerup if need to.
4683 */
4684 if(type & CS_POWER_MIXVON)
4685 type |= CS_POWER_MIXVOFF;
4686 if(type & (CS_POWER_DAC | CS_POWER_ADC))
4687 type |= CS_POWER_MIXVON | CS_POWER_MIXVOFF;
4688
4689 /*
4690 * Power up indicated areas.
4691 */
4692 if(type & CS_POWER_MIXVOFF)
4693 {
4694
4695 CS_DBGOUT(CS_FUNCTION, 4,
4696 printk(KERN_INFO "cs46xx: cs46xx_powerup()+ MIXVOFF\n"));
4697 /*
4698 * Power up the MIXER (VREF ON) on the AC97 card.
4699 */
4700 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4701 if (!(tmp & CS_AC97_POWER_CONTROL_MIXVOFF_ON))
4702 {
4703 if(!muted)
4704 {
4705 cs_mute(card, CS_TRUE);
4706 muted=1;
4707 }
4708 tmp &= ~CS_AC97_POWER_CONTROL_MIXVOFF;
4709 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4710 /*
4711 * Now, we wait until we sample a ready state.
4712 */
4713 for (count = 0; count < 32; count++) {
4714 /*
4715 * First, lets wait a short while to let things settle out a
4716 * bit, and to prevent retrying the read too quickly.
4717 */
4718 udelay(500);
4719
4720 /*
4721 * Read the current state of the power control register.
4722 */
4723 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4724 CS_AC97_POWER_CONTROL_MIXVOFF_ON)
4725 break;
4726 }
4727
4728 /*
4729 * Check the status..
4730 */
4731 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4732 CS_AC97_POWER_CONTROL_MIXVOFF_ON))
4733 {
4734 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4735 "cs46xx: powerup MIXVOFF failed\n"));
4736 return 1;
4737 }
4738 }
4739 }
4740 if(type & CS_POWER_MIXVON)
4741 {
4742
4743 CS_DBGOUT(CS_FUNCTION, 4,
4744 printk(KERN_INFO "cs46xx: cs46xx_powerup()+ MIXVON\n"));
4745 /*
4746 * Power up the MIXER (VREF ON) on the AC97 card.
4747 */
4748 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4749 if (!(tmp & CS_AC97_POWER_CONTROL_MIXVON_ON))
4750 {
4751 if(!muted)
4752 {
4753 cs_mute(card, CS_TRUE);
4754 muted=1;
4755 }
4756 tmp &= ~CS_AC97_POWER_CONTROL_MIXVON;
4757 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4758 /*
4759 * Now, we wait until we sample a ready state.
4760 */
4761 for (count = 0; count < 32; count++) {
4762 /*
4763 * First, lets wait a short while to let things settle out a
4764 * bit, and to prevent retrying the read too quickly.
4765 */
4766 udelay(500);
4767
4768 /*
4769 * Read the current state of the power control register.
4770 */
4771 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4772 CS_AC97_POWER_CONTROL_MIXVON_ON)
4773 break;
4774 }
4775
4776 /*
4777 * Check the status..
4778 */
4779 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4780 CS_AC97_POWER_CONTROL_MIXVON_ON))
4781 {
4782 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4783 "cs46xx: powerup MIXVON failed\n"));
4784 return 1;
4785 }
4786 }
4787 }
4788 if(type & CS_POWER_ADC)
4789 {
4790 /*
4791 * Power up the ADC on the AC97 card.
4792 */
4793 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO "cs46xx: cs46xx_powerup()+ ADC\n"));
4794 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4795 if (!(tmp & CS_AC97_POWER_CONTROL_ADC_ON))
4796 {
4797 if(!muted)
4798 {
4799 cs_mute(card, CS_TRUE);
4800 muted=1;
4801 }
4802 tmp &= ~CS_AC97_POWER_CONTROL_ADC;
4803 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4804
4805 /*
4806 * Now, we wait until we sample a ready state.
4807 */
4808 for (count = 0; count < 32; count++) {
4809 /*
4810 * First, lets wait a short while to let things settle out a
4811 * bit, and to prevent retrying the read too quickly.
4812 */
4813 udelay(500);
4814
4815 /*
4816 * Read the current state of the power control register.
4817 */
4818 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4819 CS_AC97_POWER_CONTROL_ADC_ON)
4820 break;
4821 }
4822
4823 /*
4824 * Check the status..
4825 */
4826 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4827 CS_AC97_POWER_CONTROL_ADC_ON))
4828 {
4829 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4830 "cs46xx: powerup ADC failed\n"));
4831 return 1;
4832 }
4833 }
4834 }
4835 if(type & CS_POWER_DAC)
4836 {
4837 /*
4838 * Power up the DAC on the AC97 card.
4839 */
4840
4841 CS_DBGOUT(CS_FUNCTION, 4,
4842 printk(KERN_INFO "cs46xx: cs46xx_powerup()+ DAC\n"));
4843 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4844 if (!(tmp & CS_AC97_POWER_CONTROL_DAC_ON))
4845 {
4846 if(!muted)
4847 {
4848 cs_mute(card, CS_TRUE);
4849 muted=1;
4850 }
4851 tmp &= ~CS_AC97_POWER_CONTROL_DAC;
4852 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4853 /*
4854 * Now, we wait until we sample a ready state.
4855 */
4856 for (count = 0; count < 32; count++) {
4857 /*
4858 * First, lets wait a short while to let things settle out a
4859 * bit, and to prevent retrying the read too quickly.
4860 */
4861 udelay(500);
4862
4863 /*
4864 * Read the current state of the power control register.
4865 */
4866 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4867 CS_AC97_POWER_CONTROL_DAC_ON)
4868 break;
4869 }
4870
4871 /*
4872 * Check the status..
4873 */
4874 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4875 CS_AC97_POWER_CONTROL_DAC_ON))
4876 {
4877 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4878 "cs46xx: powerup DAC failed\n"));
4879 return 1;
4880 }
4881 }
4882 }
4883 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4884 if(muted)
4885 cs_mute(card, CS_FALSE);
4886 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO
4887 "cs46xx: cs46xx_powerup()- 0 tmp=0x%x\n",tmp));
4888 return 0;
4889 }
4890
4891
4892 static void cs461x_proc_start(struct cs_card *card)
4893 {
4894 int cnt;
4895
4896 /*
4897 * Set the frame timer to reflect the number of cycles per frame.
4898 */
4899 cs461x_poke(card, BA1_FRMT, 0xadf);
4900 /*
4901 * Turn on the run, run at frame, and DMA enable bits in the local copy of
4902 * the SP control register.
4903 */
4904 cs461x_poke(card, BA1_SPCR, SPCR_RUN | SPCR_RUNFR | SPCR_DRQEN);
4905 /*
4906 * Wait until the run at frame bit resets itself in the SP control
4907 * register.
4908 */
4909 for (cnt = 0; cnt < 25; cnt++) {
4910 udelay(50);
4911 if (!(cs461x_peek(card, BA1_SPCR) & SPCR_RUNFR))
4912 break;
4913 }
4914
4915 if (cs461x_peek(card, BA1_SPCR) & SPCR_RUNFR)
4916 printk(KERN_WARNING "cs46xx: SPCR_RUNFR never reset\n");
4917 }
4918
4919 static void cs461x_proc_stop(struct cs_card *card)
4920 {
4921 /*
4922 * Turn off the run, run at frame, and DMA enable bits in the local copy of
4923 * the SP control register.
4924 */
4925 cs461x_poke(card, BA1_SPCR, 0);
4926 }
4927
4928 static int cs_hardware_init(struct cs_card *card)
4929 {
4930 unsigned long end_time;
4931 unsigned int tmp,count;
4932
4933 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4934 "cs46xx: cs_hardware_init()+\n") );
4935 /*
4936 * First, blast the clock control register to zero so that the PLL starts
4937 * out in a known state, and blast the master serial port control register
4938 * to zero so that the serial ports also start out in a known state.
4939 */
4940 cs461x_pokeBA0(card, BA0_CLKCR1, 0);
4941 cs461x_pokeBA0(card, BA0_SERMC1, 0);
4942
4943 /*
4944 * If we are in AC97 mode, then we must set the part to a host controlled
4945 * AC-link. Otherwise, we won't be able to bring up the link.
4946 */
4947 cs461x_pokeBA0(card, BA0_SERACC, SERACC_HSP | SERACC_CODEC_TYPE_1_03); /* 1.03 card */
4948 /* cs461x_pokeBA0(card, BA0_SERACC, SERACC_HSP | SERACC_CODEC_TYPE_2_0); */ /* 2.00 card */
4949
4950 /*
4951 * Drive the ARST# pin low for a minimum of 1uS (as defined in the AC97
4952 * spec) and then drive it high. This is done for non AC97 modes since
4953 * there might be logic external to the CS461x that uses the ARST# line
4954 * for a reset.
4955 */
4956 cs461x_pokeBA0(card, BA0_ACCTL, 1);
4957 udelay(50);
4958 cs461x_pokeBA0(card, BA0_ACCTL, 0);
4959 udelay(50);
4960 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_RSTN);
4961
4962 /*
4963 * The first thing we do here is to enable sync generation. As soon
4964 * as we start receiving bit clock, we'll start producing the SYNC
4965 * signal.
4966 */
4967 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_ESYN | ACCTL_RSTN);
4968
4969 /*
4970 * Now wait for a short while to allow the AC97 part to start
4971 * generating bit clock (so we don't try to start the PLL without an
4972 * input clock).
4973 */
4974 mdelay(5 * cs_laptop_wait); /* 1 should be enough ?? (and pigs might fly) */
4975
4976 /*
4977 * Set the serial port timing configuration, so that
4978 * the clock control circuit gets its clock from the correct place.
4979 */
4980 cs461x_pokeBA0(card, BA0_SERMC1, SERMC1_PTC_AC97);
4981
4982 /*
4983 * The part seems to not be ready for a while after a resume.
4984 * so, if we are resuming, then wait for 700 mils. Note that 600 mils
4985 * is not enough for some platforms! tested on an IBM Thinkpads and
4986 * reference cards.
4987 */
4988 if(!(card->pm.flags & CS46XX_PM_IDLE))
4989 mdelay(initdelay);
4990 /*
4991 * Write the selected clock control setup to the hardware. Do not turn on
4992 * SWCE yet (if requested), so that the devices clocked by the output of
4993 * PLL are not clocked until the PLL is stable.
4994 */
4995 cs461x_pokeBA0(card, BA0_PLLCC, PLLCC_LPF_1050_2780_KHZ | PLLCC_CDR_73_104_MHZ);
4996 cs461x_pokeBA0(card, BA0_PLLM, 0x3a);
4997 cs461x_pokeBA0(card, BA0_CLKCR2, CLKCR2_PDIVS_8);
4998
4999 /*
5000 * Power up the PLL.
5001 */
5002 cs461x_pokeBA0(card, BA0_CLKCR1, CLKCR1_PLLP);
5003
5004 /*
5005 * Wait until the PLL has stabilized.
5006 */
5007 mdelay(5 * cs_laptop_wait); /* Again 1 should be enough ?? */
5008
5009 /*
5010 * Turn on clocking of the core so that we can setup the serial ports.
5011 */
5012 tmp = cs461x_peekBA0(card, BA0_CLKCR1) | CLKCR1_SWCE;
5013 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
5014
5015 /*
5016 * Fill the serial port FIFOs with silence.
5017 */
5018 cs461x_clear_serial_FIFOs(card,CS_TYPE_DAC | CS_TYPE_ADC);
5019
5020 /*
5021 * Set the serial port FIFO pointer to the first sample in the FIFO.
5022 */
5023 /* cs461x_pokeBA0(card, BA0_SERBSP, 0); */
5024
5025 /*
5026 * Write the serial port configuration to the part. The master
5027 * enable bit is not set until all other values have been written.
5028 */
5029 cs461x_pokeBA0(card, BA0_SERC1, SERC1_SO1F_AC97 | SERC1_SO1EN);
5030 cs461x_pokeBA0(card, BA0_SERC2, SERC2_SI1F_AC97 | SERC1_SO1EN);
5031 cs461x_pokeBA0(card, BA0_SERMC1, SERMC1_PTC_AC97 | SERMC1_MSPE);
5032
5033
5034 mdelay(5 * cs_laptop_wait); /* Shouldnt be needed ?? */
5035
5036 /*
5037 * If we are resuming under 2.2.x then we can not schedule a timeout.
5038 * so, just spin the CPU.
5039 */
5040 if(card->pm.flags & CS46XX_PM_IDLE)
5041 {
5042 /*
5043 * Wait for the card ready signal from the AC97 card.
5044 */
5045 end_time = jiffies + 3 * (HZ >> 2);
5046 do {
5047 /*
5048 * Read the AC97 status register to see if we've seen a CODEC READY
5049 * signal from the AC97 card.
5050 */
5051 if (cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_CRDY)
5052 break;
5053 current->state = TASK_UNINTERRUPTIBLE;
5054 schedule_timeout(1);
5055 } while (time_before(jiffies, end_time));
5056 }
5057 else
5058 {
5059 for (count = 0; count < 100; count++) {
5060 // First, we want to wait for a short time.
5061 udelay(25 * cs_laptop_wait);
5062
5063 if (cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_CRDY)
5064 break;
5065 }
5066 }
5067
5068 /*
5069 * Make sure CODEC is READY.
5070 */
5071 if (!(cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_CRDY)) {
5072 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_WARNING
5073 "cs46xx: create - never read card ready from AC'97\n"));
5074 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_WARNING
5075 "cs46xx: probably not a bug, try using the CS4232 driver,\n"));
5076 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_WARNING
5077 "cs46xx: or turn off any automatic Power Management support in the BIOS.\n"));
5078 return -EIO;
5079 }
5080
5081 /*
5082 * Assert the vaid frame signal so that we can start sending commands
5083 * to the AC97 card.
5084 */
5085 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_VFRM | ACCTL_ESYN | ACCTL_RSTN);
5086
5087 if(card->pm.flags & CS46XX_PM_IDLE)
5088 {
5089 /*
5090 * Wait until we've sampled input slots 3 and 4 as valid, meaning that
5091 * the card is pumping ADC data across the AC-link.
5092 */
5093 end_time = jiffies + 3 * (HZ >> 2);
5094 do {
5095 /*
5096 * Read the input slot valid register and see if input slots 3 and
5097 * 4 are valid yet.
5098 */
5099 if ((cs461x_peekBA0(card, BA0_ACISV) & (ACISV_ISV3 | ACISV_ISV4)) == (ACISV_ISV3 | ACISV_ISV4))
5100 break;
5101 current->state = TASK_UNINTERRUPTIBLE;
5102 schedule_timeout(1);
5103 } while (time_before(jiffies, end_time));
5104 }
5105 else
5106 {
5107 for (count = 0; count < 100; count++) {
5108 // First, we want to wait for a short time.
5109 udelay(25 * cs_laptop_wait);
5110
5111 if ((cs461x_peekBA0(card, BA0_ACISV) & (ACISV_ISV3 | ACISV_ISV4)) == (ACISV_ISV3 | ACISV_ISV4))
5112 break;
5113 }
5114 }
5115 /*
5116 * Make sure input slots 3 and 4 are valid. If not, then return
5117 * an error.
5118 */
5119 if ((cs461x_peekBA0(card, BA0_ACISV) & (ACISV_ISV3 | ACISV_ISV4)) != (ACISV_ISV3 | ACISV_ISV4)) {
5120 printk(KERN_WARNING "cs46xx: create - never read ISV3 & ISV4 from AC'97\n");
5121 return -EIO;
5122 }
5123
5124 /*
5125 * Now, assert valid frame and the slot 3 and 4 valid bits. This will
5126 * commense the transfer of digital audio data to the AC97 card.
5127 */
5128 cs461x_pokeBA0(card, BA0_ACOSV, ACOSV_SLV3 | ACOSV_SLV4);
5129
5130 /*
5131 * Turn off the Processor by turning off the software clock enable flag in
5132 * the clock control register.
5133 */
5134 /* tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE; */
5135 /* cs461x_pokeBA0(card, BA0_CLKCR1, tmp); */
5136
5137 /*
5138 * Reset the processor.
5139 */
5140 cs461x_reset(card);
5141
5142 /*
5143 * Download the image to the processor.
5144 */
5145
5146 cs461x_download_image(card);
5147
5148 /*
5149 * Stop playback DMA.
5150 */
5151 tmp = cs461x_peek(card, BA1_PCTL);
5152 card->pctl = tmp & 0xffff0000;
5153 cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
5154
5155 /*
5156 * Stop capture DMA.
5157 */
5158 tmp = cs461x_peek(card, BA1_CCTL);
5159 card->cctl = tmp & 0x0000ffff;
5160 cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
5161
5162 /* initialize AC97 codec and register /dev/mixer */
5163 if(card->pm.flags & CS46XX_PM_IDLE)
5164 {
5165 if (cs_ac97_init(card) <= 0)
5166 {
5167 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
5168 "cs46xx: cs_ac97_init() failure\n") );
5169 return -EIO;
5170 }
5171 }
5172 else
5173 {
5174 cs46xx_ac97_resume(card);
5175 }
5176
5177 cs461x_proc_start(card);
5178
5179 /*
5180 * Enable interrupts on the part.
5181 */
5182 cs461x_pokeBA0(card, BA0_HICR, HICR_IEV | HICR_CHGM);
5183
5184 tmp = cs461x_peek(card, BA1_PFIE);
5185 tmp &= ~0x0000f03f;
5186 cs461x_poke(card, BA1_PFIE, tmp); /* playback interrupt enable */
5187
5188 tmp = cs461x_peek(card, BA1_CIE);
5189 tmp &= ~0x0000003f;
5190 tmp |= 0x00000001;
5191 cs461x_poke(card, BA1_CIE, tmp); /* capture interrupt enable */
5192
5193 /*
5194 * If IDLE then Power down the part. We will power components up
5195 * when we need them.
5196 */
5197 if(card->pm.flags & CS46XX_PM_IDLE)
5198 {
5199 if(!cs_powerdown)
5200 {
5201 if( (tmp = cs46xx_powerup(card, CS_POWER_DAC | CS_POWER_ADC |
5202 CS_POWER_MIXVON )) )
5203 {
5204 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
5205 "cs46xx: cs461x_powerup() failure (0x%x)\n",tmp) );
5206 return -EIO;
5207 }
5208 }
5209 else
5210 {
5211 if( (tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
5212 CS_POWER_MIXVON, CS_FALSE )) )
5213 {
5214 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
5215 "cs46xx: cs461x_powerdown() failure (0x%x)\n",tmp) );
5216 return -EIO;
5217 }
5218 }
5219 }
5220 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
5221 "cs46xx: cs_hardware_init()- 0\n"));
5222 return 0;
5223 }
5224
5225 /* install the driver, we do not allocate hardware channel nor DMA buffer now, they are defered
5226 until "ACCESS" time (in prog_dmabuf called by open/read/write/ioctl/mmap) */
5227
5228 /*
5229 * Card subid table
5230 */
5231
5232 struct cs_card_type
5233 {
5234 u16 vendor;
5235 u16 id;
5236 char *name;
5237 void (*amp)(struct cs_card *, int);
5238 void (*amp_init)(struct cs_card *);
5239 void (*active)(struct cs_card *, int);
5240 };
5241
5242 static struct cs_card_type cards[]={
5243 {0x1489, 0x7001, "Genius Soundmaker 128 value", amp_none, NULL, NULL},
5244 {0x5053, 0x3357, "Voyetra", amp_voyetra, NULL, NULL},
5245 {0x1071, 0x6003, "Mitac MI6020/21", amp_voyetra, NULL, NULL},
5246 {0x14AF, 0x0050, "Hercules Game Theatre XP", amp_hercules, NULL, NULL},
5247 {0x1681, 0x0050, "Hercules Game Theatre XP", amp_hercules, NULL, NULL},
5248 {0x1681, 0x0051, "Hercules Game Theatre XP", amp_hercules, NULL, NULL},
5249 {0x1681, 0x0052, "Hercules Game Theatre XP", amp_hercules, NULL, NULL},
5250 {0x1681, 0x0053, "Hercules Game Theatre XP", amp_hercules, NULL, NULL},
5251 {0x1681, 0x0054, "Hercules Game Theatre XP", amp_hercules, NULL, NULL},
5252 /* Not sure if the 570 needs the clkrun hack */
5253 {PCI_VENDOR_ID_IBM, 0x0132, "Thinkpad 570", amp_none, NULL, clkrun_hack},
5254 {PCI_VENDOR_ID_IBM, 0x0153, "Thinkpad 600X/A20/T20", amp_none, NULL, clkrun_hack},
5255 {PCI_VENDOR_ID_IBM, 0x1010, "Thinkpad 600E (unsupported)", NULL, NULL, NULL},
5256 {0, 0, "Card without SSID set", NULL, NULL, NULL },
5257 {0, 0, NULL, NULL, NULL}
5258 };
5259
5260 MODULE_AUTHOR("Alan Cox <alan@redhat.com>, Jaroslav Kysela, <pcaudio@crystal.cirrus.com>");
5261 MODULE_DESCRIPTION("Crystal SoundFusion Audio Support");
5262
5263 static const char cs46xx_banner[] = KERN_INFO "Crystal 4280/46xx + AC97 Audio, version " CS46XX_MAJOR_VERSION "." CS46XX_MINOR_VERSION "." CS46XX_ARCH ", " __TIME__ " " __DATE__ "\n";
5264 static const char fndmsg[] = KERN_INFO "cs46xx: Found %d audio device(s).\n";
5265
5266 static int __devinit cs46xx_probe(struct pci_dev *pci_dev,
5267 const struct pci_device_id *pciid)
5268 {
5269 struct pm_dev *pmdev;
5270 int i,j;
5271 u16 ss_card, ss_vendor;
5272 struct cs_card *card;
5273 dma_addr_t dma_mask;
5274 struct cs_card_type *cp = &cards[0];
5275
5276 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2,
5277 printk(KERN_INFO "cs46xx: probe()+\n"));
5278
5279 dma_mask = 0xffffffff; /* this enables playback and recording */
5280 if (pci_enable_device(pci_dev)) {
5281 CS_DBGOUT(CS_INIT | CS_ERROR, 1, printk(KERN_ERR
5282 "cs46xx: pci_enable_device() failed\n"));
5283 return -1;
5284 }
5285 if (!RSRCISMEMORYREGION(pci_dev, 0) ||
5286 !RSRCISMEMORYREGION(pci_dev, 1)) {
5287 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
5288 "cs46xx: probe()- Memory region not assigned\n"));
5289 return -1;
5290 }
5291 if (pci_dev->irq == 0) {
5292 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
5293 "cs46xx: probe() IRQ not assigned\n"));
5294 return -1;
5295 }
5296 if (!pci_dma_supported(pci_dev, 0xffffffff)) {
5297 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
5298 "cs46xx: probe() architecture does not support 32bit PCI busmaster DMA\n"));
5299 return -1;
5300 }
5301 pci_read_config_word(pci_dev, PCI_SUBSYSTEM_VENDOR_ID, &ss_vendor);
5302 pci_read_config_word(pci_dev, PCI_SUBSYSTEM_ID, &ss_card);
5303
5304 if ((card = kmalloc(sizeof(struct cs_card), GFP_KERNEL)) == NULL) {
5305 printk(KERN_ERR "cs46xx: out of memory\n");
5306 return -ENOMEM;
5307 }
5308 memset(card, 0, sizeof(*card));
5309 card->ba0_addr = RSRCADDRESS(pci_dev, 0);
5310 card->ba1_addr = RSRCADDRESS(pci_dev, 1);
5311 card->pci_dev = pci_dev;
5312 card->irq = pci_dev->irq;
5313 card->magic = CS_CARD_MAGIC;
5314 spin_lock_init(&card->lock);
5315
5316 pci_set_master(pci_dev);
5317
5318 printk(cs46xx_banner);
5319 printk(KERN_INFO "cs46xx: Card found at 0x%08lx and 0x%08lx, IRQ %d\n",
5320 card->ba0_addr, card->ba1_addr, card->irq);
5321
5322 card->alloc_pcm_channel = cs_alloc_pcm_channel;
5323 card->alloc_rec_pcm_channel = cs_alloc_rec_pcm_channel;
5324 card->free_pcm_channel = cs_free_pcm_channel;
5325 card->amplifier_ctrl = amp_none;
5326 card->active_ctrl = amp_none;
5327
5328 while (cp->name)
5329 {
5330 if(cp->vendor == ss_vendor && cp->id == ss_card)
5331 {
5332 card->amplifier_ctrl = cp->amp;
5333 if(cp->active)
5334 card->active_ctrl = cp->active;
5335 if(cp->amp_init)
5336 card->amp_init = cp->amp_init;
5337 break;
5338 }
5339 cp++;
5340 }
5341 if (cp->name==NULL)
5342 {
5343 printk(KERN_INFO "cs46xx: Unknown card (%04X:%04X) at 0x%08lx/0x%08lx, IRQ %d\n",
5344 ss_vendor, ss_card, card->ba0_addr, card->ba1_addr, card->irq);
5345 }
5346 else
5347 {
5348 printk(KERN_INFO "cs46xx: %s (%04X:%04X) at 0x%08lx/0x%08lx, IRQ %d\n",
5349 cp->name, ss_vendor, ss_card, card->ba0_addr, card->ba1_addr, card->irq);
5350 }
5351
5352 if (card->amplifier_ctrl==NULL)
5353 {
5354 card->amplifier_ctrl = amp_none;
5355 card->active_ctrl = clkrun_hack;
5356 }
5357
5358 if (external_amp == 1)
5359 {
5360 printk(KERN_INFO "cs46xx: Crystal EAPD support forced on.\n");
5361 card->amplifier_ctrl = amp_voyetra;
5362 }
5363
5364 if (thinkpad == 1)
5365 {
5366 printk(KERN_INFO "cs46xx: Activating CLKRUN hack for Thinkpad.\n");
5367 card->active_ctrl = clkrun_hack;
5368 }
5369 /*
5370 * The thinkpads don't work well without runtime updating on their kernel
5371 * delay values (or any laptop with variable CPU speeds really).
5372 * so, just to be safe set the init delay to 2100. Eliminates
5373 * failures on T21 Thinkpads. remove this code when the udelay
5374 * and mdelay kernel code is replaced by a pm timer, or the delays
5375 * work well for battery and/or AC power both.
5376 */
5377 if(card->active_ctrl == clkrun_hack)
5378 {
5379 initdelay = 2100;
5380 cs_laptop_wait = 5;
5381 }
5382 if((card->active_ctrl == clkrun_hack) && !(powerdown == 1))
5383 {
5384 /*
5385 * for some currently unknown reason, powering down the DAC and ADC component
5386 * blocks on thinkpads causes some funky behavior... distoorrrtion and ac97
5387 * codec access problems. probably the serial clock becomes unsynced.
5388 * added code to sync the chips back up, but only helped about 70% the time.
5389 */
5390 cs_powerdown = 0;
5391 }
5392 if(powerdown == 0)
5393 cs_powerdown = 0;
5394 card->active_ctrl(card, 1);
5395
5396 /* claim our iospace and irq */
5397
5398 card->ba0 = ioremap_nocache(card->ba0_addr, CS461X_BA0_SIZE);
5399 card->ba1.name.data0 = ioremap_nocache(card->ba1_addr + BA1_SP_DMEM0, CS461X_BA1_DATA0_SIZE);
5400 card->ba1.name.data1 = ioremap_nocache(card->ba1_addr + BA1_SP_DMEM1, CS461X_BA1_DATA1_SIZE);
5401 card->ba1.name.pmem = ioremap_nocache(card->ba1_addr + BA1_SP_PMEM, CS461X_BA1_PRG_SIZE);
5402 card->ba1.name.reg = ioremap_nocache(card->ba1_addr + BA1_SP_REG, CS461X_BA1_REG_SIZE);
5403
5404 CS_DBGOUT(CS_INIT, 4, printk(KERN_INFO
5405 "cs46xx: card=0x%x card->ba0=0x%.08x\n",(unsigned)card,(unsigned)card->ba0) );
5406 CS_DBGOUT(CS_INIT, 4, printk(KERN_INFO
5407 "cs46xx: card->ba1=0x%.08x 0x%.08x 0x%.08x 0x%.08x\n",
5408 (unsigned)card->ba1.name.data0,
5409 (unsigned)card->ba1.name.data1,
5410 (unsigned)card->ba1.name.pmem,
5411 (unsigned)card->ba1.name.reg) );
5412
5413 if(card->ba0 == 0 || card->ba1.name.data0 == 0 ||
5414 card->ba1.name.data1 == 0 || card->ba1.name.pmem == 0 ||
5415 card->ba1.name.reg == 0)
5416 goto fail2;
5417
5418 if (request_irq(card->irq, &cs_interrupt, SA_SHIRQ, "cs46xx", card)) {
5419 printk(KERN_ERR "cs46xx: unable to allocate irq %d\n", card->irq);
5420 goto fail2;
5421 }
5422 /* register /dev/dsp */
5423 if ((card->dev_audio = register_sound_dsp(&cs461x_fops, -1)) < 0) {
5424 printk(KERN_ERR "cs46xx: unable to register dsp\n");
5425 goto fail;
5426 }
5427
5428 /* register /dev/midi */
5429 if((card->dev_midi = register_sound_midi(&cs_midi_fops, -1)) < 0)
5430 printk(KERN_ERR "cs46xx: unable to register midi\n");
5431
5432 card->pm.flags |= CS46XX_PM_IDLE;
5433 for(i=0;i<5;i++)
5434 {
5435 if (cs_hardware_init(card) != 0)
5436 {
5437 CS_DBGOUT(CS_ERROR, 4, printk(
5438 "cs46xx: ERROR in cs_hardware_init()... retrying\n"));
5439 for (j = 0; j < NR_AC97; j++)
5440 if (card->ac97_codec[j] != NULL) {
5441 unregister_sound_mixer(card->ac97_codec[j]->dev_mixer);
5442 kfree (card->ac97_codec[j]);
5443 }
5444 mdelay(10 * cs_laptop_wait);
5445 continue;
5446 }
5447 break;
5448 }
5449 if(i>=4)
5450 {
5451 CS_DBGOUT(CS_PM | CS_ERROR, 1, printk(
5452 "cs46xx: cs46xx_probe()- cs_hardware_init() failed, retried %d times.\n",i));
5453 unregister_sound_dsp(card->dev_audio);
5454 if(card->dev_midi)
5455 unregister_sound_midi(card->dev_midi);
5456 goto fail;
5457 }
5458
5459 init_waitqueue_head(&card->midi.open_wait);
5460 init_MUTEX(&card->midi.open_sem);
5461 init_waitqueue_head(&card->midi.iwait);
5462 init_waitqueue_head(&card->midi.owait);
5463 cs461x_pokeBA0(card, BA0_MIDCR, MIDCR_MRST);
5464 cs461x_pokeBA0(card, BA0_MIDCR, 0);
5465
5466 /*
5467 * Check if we have to init the amplifier, but probably already done
5468 * since the CD logic in the ac97 init code will turn on the ext amp.
5469 */
5470 if(cp->amp_init)
5471 cp->amp_init(card);
5472 card->active_ctrl(card, -1);
5473
5474 PCI_SET_DRIVER_DATA(pci_dev, card);
5475 PCI_SET_DMA_MASK(pci_dev, dma_mask);
5476 list_add(&card->list, &cs46xx_devs);
5477
5478 pmdev = cs_pm_register(PM_PCI_DEV, PM_PCI_ID(pci_dev), cs46xx_pm_callback);
5479 if (pmdev)
5480 {
5481 CS_DBGOUT(CS_INIT | CS_PM, 4, printk(KERN_INFO
5482 "cs46xx: probe() pm_register() succeeded (0x%x).\n",
5483 (unsigned)pmdev));
5484 pmdev->data = card;
5485 }
5486 else
5487 {
5488 CS_DBGOUT(CS_INIT | CS_PM | CS_ERROR, 2, printk(KERN_INFO
5489 "cs46xx: probe() pm_register() failed (0x%x).\n",
5490 (unsigned)pmdev));
5491 card->pm.flags |= CS46XX_PM_NOT_REGISTERED;
5492 }
5493
5494 CS_DBGOUT(CS_PM, 9, printk(KERN_INFO "cs46xx: pm.flags=0x%x card=0x%x\n",
5495 (unsigned)card->pm.flags,(unsigned)card));
5496
5497 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5498 "cs46xx: probe()- device allocated successfully\n"));
5499 return 0;
5500
5501 fail:
5502 free_irq(card->irq, card);
5503 fail2:
5504 if(card->ba0)
5505 iounmap(card->ba0);
5506 if(card->ba1.name.data0)
5507 iounmap(card->ba1.name.data0);
5508 if(card->ba1.name.data1)
5509 iounmap(card->ba1.name.data1);
5510 if(card->ba1.name.pmem)
5511 iounmap(card->ba1.name.pmem);
5512 if(card->ba1.name.reg)
5513 iounmap(card->ba1.name.reg);
5514 kfree(card);
5515 CS_DBGOUT(CS_INIT | CS_ERROR, 1, printk(KERN_INFO
5516 "cs46xx: probe()- no device allocated\n"));
5517 return -ENODEV;
5518 } // probe_cs46xx
5519
5520 // ---------------------------------------------------------------------
5521
5522 static void __devinit cs46xx_remove(struct pci_dev *pci_dev)
5523 {
5524 struct cs_card *card = PCI_GET_DRIVER_DATA(pci_dev);
5525 int i;
5526 unsigned int tmp;
5527
5528 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5529 "cs46xx: cs46xx_remove()+\n"));
5530
5531 card->active_ctrl(card,1);
5532
5533 tmp = cs461x_peek(card, BA1_PFIE);
5534 tmp &= ~0x0000f03f;
5535 tmp |= 0x00000010;
5536 cs461x_poke(card, BA1_PFIE, tmp); /* playback interrupt disable */
5537
5538 tmp = cs461x_peek(card, BA1_CIE);
5539 tmp &= ~0x0000003f;
5540 tmp |= 0x00000011;
5541 cs461x_poke(card, BA1_CIE, tmp); /* capture interrupt disable */
5542
5543 /*
5544 * Stop playback DMA.
5545 */
5546 tmp = cs461x_peek(card, BA1_PCTL);
5547 cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
5548
5549 /*
5550 * Stop capture DMA.
5551 */
5552 tmp = cs461x_peek(card, BA1_CCTL);
5553 cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
5554
5555 /*
5556 * Reset the processor.
5557 */
5558 cs461x_reset(card);
5559
5560 cs461x_proc_stop(card);
5561
5562 /*
5563 * Power down the DAC and ADC. We will power them up (if) when we need
5564 * them.
5565 */
5566 if( (tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
5567 CS_POWER_MIXVON, CS_TRUE )) )
5568 {
5569 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
5570 "cs46xx: cs461x_powerdown() failure (0x%x)\n",tmp) );
5571 }
5572
5573 /*
5574 * Power down the PLL.
5575 */
5576 cs461x_pokeBA0(card, BA0_CLKCR1, 0);
5577
5578 /*
5579 * Turn off the Processor by turning off the software clock enable flag in
5580 * the clock control register.
5581 */
5582 tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE;
5583 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
5584
5585 card->active_ctrl(card,-1);
5586
5587 /* free hardware resources */
5588 free_irq(card->irq, card);
5589 iounmap(card->ba0);
5590 iounmap(card->ba1.name.data0);
5591 iounmap(card->ba1.name.data1);
5592 iounmap(card->ba1.name.pmem);
5593 iounmap(card->ba1.name.reg);
5594
5595 /* unregister audio devices */
5596 for (i = 0; i < NR_AC97; i++)
5597 if (card->ac97_codec[i] != NULL) {
5598 unregister_sound_mixer(card->ac97_codec[i]->dev_mixer);
5599 kfree (card->ac97_codec[i]);
5600 }
5601 unregister_sound_dsp(card->dev_audio);
5602 if(card->dev_midi)
5603 unregister_sound_midi(card->dev_midi);
5604 list_del(&card->list);
5605 kfree(card);
5606 PCI_SET_DRIVER_DATA(pci_dev,NULL);
5607
5608 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5609 "cs46xx: cs46xx_remove()-: remove successful\n"));
5610 }
5611
5612 enum {
5613 CS46XX_4610 = 0,
5614 CS46XX_4612, /* same as 4630 */
5615 CS46XX_4615, /* same as 4624 */
5616 };
5617
5618 static struct pci_device_id cs46xx_pci_tbl[] __devinitdata = {
5619
5620 {PCI_VENDOR_ID_CIRRUS, PCI_DEVICE_ID_CIRRUS_4610, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CS46XX_4610},
5621 {PCI_VENDOR_ID_CIRRUS, PCI_DEVICE_ID_CIRRUS_4612, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CS46XX_4612},
5622 {PCI_VENDOR_ID_CIRRUS, PCI_DEVICE_ID_CIRRUS_4615, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CS46XX_4615},
5623 {0,}
5624 };
5625
5626 MODULE_DEVICE_TABLE(pci, cs46xx_pci_tbl);
5627
5628 struct pci_driver cs46xx_pci_driver = {
5629 name:"cs46xx",
5630 id_table:cs46xx_pci_tbl,
5631 probe:cs46xx_probe,
5632 remove:cs46xx_remove,
5633 suspend:CS46XX_SUSPEND_TBL,
5634 resume:CS46XX_RESUME_TBL,
5635 };
5636
5637 int __init cs46xx_init_module(void)
5638 {
5639 int rtn = 0;
5640 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5641 "cs46xx: cs46xx_init_module()+ \n"));
5642 if (!pci_present()) { /* No PCI bus in this machine! */
5643 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5644 "cs46xx: cs46xx_init_module()- no pci bus found\n"));
5645 return -ENODEV;
5646 }
5647 rtn = pci_module_init(&cs46xx_pci_driver);
5648
5649 if(rtn == -ENODEV)
5650 {
5651 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(
5652 "cs46xx: Unable to detect valid cs46xx device\n"));
5653 }
5654
5655 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2,
5656 printk(KERN_INFO "cs46xx: cs46xx_init_module()- (%d)\n",rtn));
5657 return rtn;
5658 }
5659
5660 void __exit cs46xx_cleanup_module(void)
5661 {
5662 pci_unregister_driver(&cs46xx_pci_driver);
5663 cs_pm_unregister_all(cs46xx_pm_callback);
5664 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2,
5665 printk(KERN_INFO "cs46xx: cleanup_cs46xx() finished\n"));
5666 }
5667
5668 module_init(cs46xx_init_module);
5669 module_exit(cs46xx_cleanup_module);
5670
5671 int cs46xx_pm_callback(struct pm_dev *dev, pm_request_t rqst, void *data)
5672 {
5673 struct cs_card *card;
5674
5675 CS_DBGOUT(CS_PM, 2, printk(KERN_INFO
5676 "cs46xx: cs46xx_pm_callback dev=0x%x rqst=0x%x card=%d\n",
5677 (unsigned)dev,(unsigned)rqst,(unsigned)data));
5678 card = (struct cs_card *) dev->data;
5679 if (card) {
5680 switch(rqst) {
5681 case PM_SUSPEND:
5682 CS_DBGOUT(CS_PM, 2, printk(KERN_INFO
5683 "cs46xx: PM suspend request\n"));
5684 if(cs46xx_suspend(card, 0))
5685 {
5686 CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
5687 "cs46xx: PM suspend request refused\n"));
5688 return 1;
5689 }
5690 break;
5691 case PM_RESUME:
5692 CS_DBGOUT(CS_PM, 2, printk(KERN_INFO
5693 "cs46xx: PM resume request\n"));
5694 if(cs46xx_resume(card))
5695 {
5696 CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
5697 "cs46xx: PM resume request refused\n"));
5698 return 1;
5699 }
5700 break;
5701 }
5702 }
5703
5704 return 0;
5705 }
5706
5707 #if CS46XX_ACPI_SUPPORT
5708 static int cs46xx_suspend_tbl(struct pci_dev *pcidev, u32 state)
5709 {
5710 struct cs_card *s = PCI_GET_DRIVER_DATA(pcidev);
5711 CS_DBGOUT(CS_PM | CS_FUNCTION, 2,
5712 printk(KERN_INFO "cs46xx: cs46xx_suspend_tbl request\n"));
5713 cs46xx_suspend(s, 0);
5714 return 0;
5715 }
5716
5717 static int cs46xx_resume_tbl(struct pci_dev *pcidev)
5718 {
5719 struct cs_card *s = PCI_GET_DRIVER_DATA(pcidev);
5720 CS_DBGOUT(CS_PM | CS_FUNCTION, 2,
5721 printk(KERN_INFO "cs46xx: cs46xx_resume_tbl request\n"));
5722 cs46xx_resume(s);
5723 return 0;
5724 }
5725 #endif
5726