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