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
95 #include <asm/io.h>
96 #include <asm/dma.h>
97 #include <asm/uaccess.h>
98
99 #include "cs46xxpm-24.h"
100 #include "cs46xx_wrapper-24.h"
101 #include "cs461x.h"
102
103 /* MIDI buffer sizes */
104 #define CS_MIDIINBUF 500
105 #define CS_MIDIOUTBUF 500
106
107 #define ADC_RUNNING 1
108 #define DAC_RUNNING 2
109
110 #define CS_FMT_16BIT 1 /* These are fixed in fact */
111 #define CS_FMT_STEREO 2
112 #define CS_FMT_MASK 3
113
114 #define CS_TYPE_ADC 1
115 #define CS_TYPE_DAC 2
116
117 #define CS_TRUE 1
118 #define CS_FALSE 0
119
120 #define CS_INC_USE_COUNT(m) (atomic_inc(m))
121 #define CS_DEC_USE_COUNT(m) (atomic_dec(m))
122 #define CS_DEC_AND_TEST(m) (atomic_dec_and_test(m))
123 #define CS_IN_USE(m) (atomic_read(m) != 0)
124
125 #define CS_DBGBREAKPOINT {__asm__("INT $3");}
126 /*
127 * CS461x definitions
128 */
129
130 #define CS461X_BA0_SIZE 0x2000
131 #define CS461X_BA1_DATA0_SIZE 0x3000
132 #define CS461X_BA1_DATA1_SIZE 0x3800
133 #define CS461X_BA1_PRG_SIZE 0x7000
134 #define CS461X_BA1_REG_SIZE 0x0100
135
136 #define GOF_PER_SEC 200
137
138 #define CSDEBUG_INTERFACE 1
139 #define CSDEBUG 1
140 /*
141 * Turn on/off debugging compilation by using 1/0 respectively for CSDEBUG
142 *
143 *
144 * CSDEBUG is usual mode is set to 1, then use the
145 * cs_debuglevel and cs_debugmask to turn on or off debugging.
146 * Debug level of 1 has been defined to be kernel errors and info
147 * that should be printed on any released driver.
148 */
149 #if CSDEBUG
150 #define CS_DBGOUT(mask,level,x) if((cs_debuglevel >= (level)) && ((mask) & cs_debugmask)) {x;}
151 #else
152 #define CS_DBGOUT(mask,level,x)
153 #endif
154 /*
155 * cs_debugmask areas
156 */
157 #define CS_INIT 0x00000001 /* initialization and probe functions */
158 #define CS_ERROR 0x00000002 /* tmp debugging bit placeholder */
159 #define CS_INTERRUPT 0x00000004 /* interrupt handler (separate from all other) */
160 #define CS_FUNCTION 0x00000008 /* enter/leave functions */
161 #define CS_WAVE_WRITE 0x00000010 /* write information for wave */
162 #define CS_WAVE_READ 0x00000020 /* read information for wave */
163 #define CS_MIDI_WRITE 0x00000040 /* write information for midi */
164 #define CS_MIDI_READ 0x00000080 /* read information for midi */
165 #define CS_MPU401_WRITE 0x00000100 /* write information for mpu401 */
166 #define CS_MPU401_READ 0x00000200 /* read information for mpu401 */
167 #define CS_OPEN 0x00000400 /* all open functions in the driver */
168 #define CS_RELEASE 0x00000800 /* all release functions in the driver */
169 #define CS_PARMS 0x00001000 /* functional and operational parameters */
170 #define CS_IOCTL 0x00002000 /* ioctl (non-mixer) */
171 #define CS_PM 0x00004000 /* PM */
172 #define CS_TMP 0x10000000 /* tmp debug mask bit */
173
174 #define CS_IOCTL_CMD_SUSPEND 0x1 // suspend
175 #define CS_IOCTL_CMD_RESUME 0x2 // resume
176
177 #if CSDEBUG
178 static unsigned long cs_debuglevel=1; /* levels range from 1-9 */
179 module_param(cs_debuglevel, ulong, 0644);
180 static unsigned long cs_debugmask=CS_INIT | CS_ERROR; /* use CS_DBGOUT with various mask values */
181 module_param(cs_debugmask, ulong, 0644);
182 #endif
183 static unsigned long hercules_egpio_disable; /* if non-zero set all EGPIO to 0 */
184 module_param(hercules_egpio_disable, ulong, 0);
185 static unsigned long initdelay=700; /* PM delay in millisecs */
186 module_param(initdelay, ulong, 0);
187 static unsigned long powerdown=-1; /* turn on/off powerdown processing in driver */
188 module_param(powerdown, ulong, 0);
189 #define DMABUF_DEFAULTORDER 3
190 static unsigned long defaultorder=DMABUF_DEFAULTORDER;
191 module_param(defaultorder, ulong, 0);
192
193 static int external_amp;
194 module_param(external_amp, bool, 0);
195 static int thinkpad;
196 module_param(thinkpad, bool, 0);
197
198 /*
199 * set the powerdown module parm to 0 to disable all
200 * powerdown. also set thinkpad to 1 to disable powerdown,
201 * but also to enable the clkrun functionality.
202 */
203 static unsigned cs_powerdown=1;
204 static unsigned cs_laptop_wait=1;
205
206 /* An instance of the 4610 channel */
207 struct cs_channel
208 {
209 int used;
210 int num;
211 void *state;
212 };
213
214 #define CS46XX_MAJOR_VERSION "1"
215 #define CS46XX_MINOR_VERSION "28"
216
217 #ifdef __ia64__
218 #define CS46XX_ARCH "64" //architecture key
219 #else
220 #define CS46XX_ARCH "32" //architecture key
221 #endif
222
223 static struct list_head cs46xx_devs = { &cs46xx_devs, &cs46xx_devs };
224
225 /* magic numbers to protect our data structures */
226 #define CS_CARD_MAGIC 0x43525553 /* "CRUS" */
227 #define CS_STATE_MAGIC 0x4c4f4749 /* "LOGI" */
228 #define NR_HW_CH 3
229
230 /* maxinum number of AC97 codecs connected, AC97 2.0 defined 4 */
231 #define NR_AC97 2
232
233 static const unsigned sample_size[] = { 1, 2, 2, 4 };
234 static const unsigned sample_shift[] = { 0, 1, 1, 2 };
235
236 /* "software" or virtual channel, an instance of opened /dev/dsp */
237 struct cs_state {
238 unsigned int magic;
239 struct cs_card *card; /* Card info */
240
241 /* single open lock mechanism, only used for recording */
242 struct mutex open_mutex;
243 wait_queue_head_t open_wait;
244
245 /* file mode */
246 mode_t open_mode;
247
248 /* virtual channel number */
249 int virt;
250
251 struct dmabuf {
252 /* wave sample stuff */
253 unsigned int rate;
254 unsigned char fmt, enable;
255
256 /* hardware channel */
257 struct cs_channel *channel;
258 int pringbuf; /* Software ring slot */
259 void *pbuf; /* 4K hardware DMA buffer */
260
261 /* OSS buffer management stuff */
262 void *rawbuf;
263 dma_addr_t dma_handle;
264 unsigned buforder;
265 unsigned numfrag;
266 unsigned fragshift;
267 unsigned divisor;
268 unsigned type;
269 void *tmpbuff; /* tmp buffer for sample conversions */
270 dma_addr_t dmaaddr;
271 dma_addr_t dmaaddr_tmpbuff;
272 unsigned buforder_tmpbuff; /* Log base 2 of size in bytes.. */
273
274 /* our buffer acts like a circular ring */
275 unsigned hwptr; /* where dma last started, updated by update_ptr */
276 unsigned swptr; /* where driver last clear/filled, updated by read/write */
277 int count; /* bytes to be comsumed or been generated by dma machine */
278 unsigned total_bytes; /* total bytes dmaed by hardware */
279 unsigned blocks; /* total blocks */
280
281 unsigned error; /* number of over/underruns */
282 unsigned underrun; /* underrun pending before next write has occurred */
283 wait_queue_head_t wait; /* put process on wait queue when no more space in buffer */
284
285 /* redundant, but makes calculations easier */
286 unsigned fragsize;
287 unsigned dmasize;
288 unsigned fragsamples;
289
290 /* OSS stuff */
291 unsigned mapped:1;
292 unsigned ready:1;
293 unsigned endcleared:1;
294 unsigned SGok:1;
295 unsigned update_flag;
296 unsigned ossfragshift;
297 int ossmaxfrags;
298 unsigned subdivision;
299 } dmabuf;
300 /* Guard against mmap/write/read races */
301 struct mutex sem;
302 };
303
304 struct cs_card {
305 struct cs_channel channel[2];
306 unsigned int magic;
307
308 /* We keep cs461x cards in a linked list */
309 struct cs_card *next;
310
311 /* The cs461x has a certain amount of cross channel interaction
312 so we use a single per card lock */
313 spinlock_t lock;
314
315 /* Keep AC97 sane */
316 spinlock_t ac97_lock;
317
318 /* mixer use count */
319 atomic_t mixer_use_cnt;
320
321 /* PCI device stuff */
322 struct pci_dev * pci_dev;
323 struct list_head list;
324
325 unsigned int pctl, cctl; /* Hardware DMA flag sets */
326
327 /* soundcore stuff */
328 int dev_audio;
329 int dev_midi;
330
331 /* structures for abstraction of hardware facilities, codecs, banks and channels*/
332 struct ac97_codec *ac97_codec[NR_AC97];
333 struct cs_state *states[2];
334
335 u16 ac97_features;
336
337 int amplifier; /* Amplifier control */
338 void (*amplifier_ctrl)(struct cs_card *, int);
339 void (*amp_init)(struct cs_card *);
340
341 int active; /* Active clocking */
342 void (*active_ctrl)(struct cs_card *, int);
343
344 /* hardware resources */
345 unsigned long ba0_addr;
346 unsigned long ba1_addr;
347 u32 irq;
348
349 /* mappings */
350 void __iomem *ba0;
351 union
352 {
353 struct
354 {
355 u8 __iomem *data0;
356 u8 __iomem *data1;
357 u8 __iomem *pmem;
358 u8 __iomem *reg;
359 } name;
360 u8 __iomem *idx[4];
361 } ba1;
362
363 /* Function support */
364 struct cs_channel *(*alloc_pcm_channel)(struct cs_card *);
365 struct cs_channel *(*alloc_rec_pcm_channel)(struct cs_card *);
366 void (*free_pcm_channel)(struct cs_card *, int chan);
367
368 /* /dev/midi stuff */
369 struct {
370 unsigned ird, iwr, icnt;
371 unsigned ord, owr, ocnt;
372 wait_queue_head_t open_wait;
373 wait_queue_head_t iwait;
374 wait_queue_head_t owait;
375 spinlock_t lock;
376 unsigned char ibuf[CS_MIDIINBUF];
377 unsigned char obuf[CS_MIDIOUTBUF];
378 mode_t open_mode;
379 struct mutex open_mutex;
380 } midi;
381 struct cs46xx_pm pm;
382 };
383
384 static int cs_open_mixdev(struct inode *inode, struct file *file);
385 static int cs_release_mixdev(struct inode *inode, struct file *file);
386 static int cs_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd,
387 unsigned long arg);
388 static int cs_hardware_init(struct cs_card *card);
389 static int cs46xx_powerup(struct cs_card *card, unsigned int type);
390 static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspendflag);
391 static void cs461x_clear_serial_FIFOs(struct cs_card *card, int type);
392 static int cs46xx_suspend_tbl(struct pci_dev *pcidev, pm_message_t state);
393 static int cs46xx_resume_tbl(struct pci_dev *pcidev);
394
395 #if CSDEBUG
396
397 /* DEBUG ROUTINES */
398
399 #define SOUND_MIXER_CS_GETDBGLEVEL _SIOWR('M',120, int)
400 #define SOUND_MIXER_CS_SETDBGLEVEL _SIOWR('M',121, int)
401 #define SOUND_MIXER_CS_GETDBGMASK _SIOWR('M',122, int)
402 #define SOUND_MIXER_CS_SETDBGMASK _SIOWR('M',123, int)
403 #define SOUND_MIXER_CS_APM _SIOWR('M',124, int)
404
405 static void printioctl(unsigned int x)
406 {
407 unsigned int i;
408 unsigned char vidx;
409 /* these values are incorrect for the ac97 driver, fix.
410 * Index of mixtable1[] member is Device ID
411 * and must be <= SOUND_MIXER_NRDEVICES.
412 * Value of array member is index into s->mix.vol[]
413 */
414 static const unsigned char mixtable1[SOUND_MIXER_NRDEVICES] = {
415 [SOUND_MIXER_PCM] = 1, /* voice */
416 [SOUND_MIXER_LINE1] = 2, /* AUX */
417 [SOUND_MIXER_CD] = 3, /* CD */
418 [SOUND_MIXER_LINE] = 4, /* Line */
419 [SOUND_MIXER_SYNTH] = 5, /* FM */
420 [SOUND_MIXER_MIC] = 6, /* Mic */
421 [SOUND_MIXER_SPEAKER] = 7, /* Speaker */
422 [SOUND_MIXER_RECLEV] = 8, /* Recording level */
423 [SOUND_MIXER_VOLUME] = 9 /* Master Volume */
424 };
425
426 switch(x)
427 {
428 case SOUND_MIXER_CS_GETDBGMASK:
429 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_GETDBGMASK: ") );
430 break;
431 case SOUND_MIXER_CS_GETDBGLEVEL:
432 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_GETDBGLEVEL: ") );
433 break;
434 case SOUND_MIXER_CS_SETDBGMASK:
435 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_SETDBGMASK: ") );
436 break;
437 case SOUND_MIXER_CS_SETDBGLEVEL:
438 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_SETDBGLEVEL: ") );
439 break;
440 case OSS_GETVERSION:
441 CS_DBGOUT(CS_IOCTL, 4, printk("OSS_GETVERSION: ") );
442 break;
443 case SNDCTL_DSP_SYNC:
444 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SYNC: ") );
445 break;
446 case SNDCTL_DSP_SETDUPLEX:
447 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETDUPLEX: ") );
448 break;
449 case SNDCTL_DSP_GETCAPS:
450 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETCAPS: ") );
451 break;
452 case SNDCTL_DSP_RESET:
453 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_RESET: ") );
454 break;
455 case SNDCTL_DSP_SPEED:
456 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SPEED: ") );
457 break;
458 case SNDCTL_DSP_STEREO:
459 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_STEREO: ") );
460 break;
461 case SNDCTL_DSP_CHANNELS:
462 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_CHANNELS: ") );
463 break;
464 case SNDCTL_DSP_GETFMTS:
465 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETFMTS: ") );
466 break;
467 case SNDCTL_DSP_SETFMT:
468 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETFMT: ") );
469 break;
470 case SNDCTL_DSP_POST:
471 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_POST: ") );
472 break;
473 case SNDCTL_DSP_GETTRIGGER:
474 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETTRIGGER: ") );
475 break;
476 case SNDCTL_DSP_SETTRIGGER:
477 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETTRIGGER: ") );
478 break;
479 case SNDCTL_DSP_GETOSPACE:
480 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETOSPACE: ") );
481 break;
482 case SNDCTL_DSP_GETISPACE:
483 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETISPACE: ") );
484 break;
485 case SNDCTL_DSP_NONBLOCK:
486 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_NONBLOCK: ") );
487 break;
488 case SNDCTL_DSP_GETODELAY:
489 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETODELAY: ") );
490 break;
491 case SNDCTL_DSP_GETIPTR:
492 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETIPTR: ") );
493 break;
494 case SNDCTL_DSP_GETOPTR:
495 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETOPTR: ") );
496 break;
497 case SNDCTL_DSP_GETBLKSIZE:
498 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETBLKSIZE: ") );
499 break;
500 case SNDCTL_DSP_SETFRAGMENT:
501 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETFRAGMENT: ") );
502 break;
503 case SNDCTL_DSP_SUBDIVIDE:
504 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SUBDIVIDE: ") );
505 break;
506 case SOUND_PCM_READ_RATE:
507 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_RATE: ") );
508 break;
509 case SOUND_PCM_READ_CHANNELS:
510 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_CHANNELS: ") );
511 break;
512 case SOUND_PCM_READ_BITS:
513 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_BITS: ") );
514 break;
515 case SOUND_PCM_WRITE_FILTER:
516 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_WRITE_FILTER: ") );
517 break;
518 case SNDCTL_DSP_SETSYNCRO:
519 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETSYNCRO: ") );
520 break;
521 case SOUND_PCM_READ_FILTER:
522 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_FILTER: ") );
523 break;
524
525 case SOUND_MIXER_PRIVATE1:
526 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE1: ") );
527 break;
528 case SOUND_MIXER_PRIVATE2:
529 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE2: ") );
530 break;
531 case SOUND_MIXER_PRIVATE3:
532 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE3: ") );
533 break;
534 case SOUND_MIXER_PRIVATE4:
535 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE4: ") );
536 break;
537 case SOUND_MIXER_PRIVATE5:
538 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE5: ") );
539 break;
540 case SOUND_MIXER_INFO:
541 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_INFO: ") );
542 break;
543 case SOUND_OLD_MIXER_INFO:
544 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_OLD_MIXER_INFO: ") );
545 break;
546
547 default:
548 switch (_IOC_NR(x))
549 {
550 case SOUND_MIXER_VOLUME:
551 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_VOLUME: ") );
552 break;
553 case SOUND_MIXER_SPEAKER:
554 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_SPEAKER: ") );
555 break;
556 case SOUND_MIXER_RECLEV:
557 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECLEV: ") );
558 break;
559 case SOUND_MIXER_MIC:
560 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_MIC: ") );
561 break;
562 case SOUND_MIXER_SYNTH:
563 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_SYNTH: ") );
564 break;
565 case SOUND_MIXER_RECSRC:
566 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECSRC: ") );
567 break;
568 case SOUND_MIXER_DEVMASK:
569 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_DEVMASK: ") );
570 break;
571 case SOUND_MIXER_RECMASK:
572 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECMASK: ") );
573 break;
574 case SOUND_MIXER_STEREODEVS:
575 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_STEREODEVS: ") );
576 break;
577 case SOUND_MIXER_CAPS:
578 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CAPS:") );
579 break;
580 default:
581 i = _IOC_NR(x);
582 if (i >= SOUND_MIXER_NRDEVICES || !(vidx = mixtable1[i]))
583 {
584 CS_DBGOUT(CS_IOCTL, 4, printk("UNKNOWN IOCTL: 0x%.8x NR=%d ",x,i) );
585 }
586 else
587 {
588 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_IOCTL AC9x: 0x%.8x NR=%d ",
589 x,i) );
590 }
591 break;
592 }
593 }
594 CS_DBGOUT(CS_IOCTL, 4, printk("command = 0x%x IOC_NR=%d\n",x, _IOC_NR(x)) );
595 }
596 #endif
597
598 /*
599 * common I/O routines
600 */
601
602 static void cs461x_poke(struct cs_card *codec, unsigned long reg, unsigned int val)
603 {
604 writel(val, codec->ba1.idx[(reg >> 16) & 3]+(reg&0xffff));
605 }
606
607 static unsigned int cs461x_peek(struct cs_card *codec, unsigned long reg)
608 {
609 return readl(codec->ba1.idx[(reg >> 16) & 3]+(reg&0xffff));
610 }
611
612 static void cs461x_pokeBA0(struct cs_card *codec, unsigned long reg, unsigned int val)
613 {
614 writel(val, codec->ba0+reg);
615 }
616
617 static unsigned int cs461x_peekBA0(struct cs_card *codec, unsigned long reg)
618 {
619 return readl(codec->ba0+reg);
620 }
621
622
623 static u16 cs_ac97_get(struct ac97_codec *dev, u8 reg);
624 static void cs_ac97_set(struct ac97_codec *dev, u8 reg, u16 data);
625
626 static struct cs_channel *cs_alloc_pcm_channel(struct cs_card *card)
627 {
628 if(card->channel[1].used==1)
629 return NULL;
630 card->channel[1].used=1;
631 card->channel[1].num=1;
632 return &card->channel[1];
633 }
634
635 static struct cs_channel *cs_alloc_rec_pcm_channel(struct cs_card *card)
636 {
637 if(card->channel[0].used==1)
638 return NULL;
639 card->channel[0].used=1;
640 card->channel[0].num=0;
641 return &card->channel[0];
642 }
643
644 static void cs_free_pcm_channel(struct cs_card *card, int channel)
645 {
646 card->channel[channel].state = NULL;
647 card->channel[channel].used=0;
648 }
649
650 /*
651 * setup a divisor value to help with conversion from
652 * 16bit Stereo, down to 8bit stereo/mono or 16bit mono.
653 * assign a divisor of 1 if using 16bit Stereo as that is
654 * the only format that the static image will capture.
655 */
656 static void cs_set_divisor(struct dmabuf *dmabuf)
657 {
658 if(dmabuf->type == CS_TYPE_DAC)
659 dmabuf->divisor = 1;
660 else if( !(dmabuf->fmt & CS_FMT_STEREO) &&
661 (dmabuf->fmt & CS_FMT_16BIT))
662 dmabuf->divisor = 2;
663 else if( (dmabuf->fmt & CS_FMT_STEREO) &&
664 !(dmabuf->fmt & CS_FMT_16BIT))
665 dmabuf->divisor = 2;
666 else if( !(dmabuf->fmt & CS_FMT_STEREO) &&
667 !(dmabuf->fmt & CS_FMT_16BIT))
668 dmabuf->divisor = 4;
669 else
670 dmabuf->divisor = 1;
671
672 CS_DBGOUT(CS_PARMS | CS_FUNCTION, 8, printk(
673 "cs46xx: cs_set_divisor()- %s %d\n",
674 (dmabuf->type == CS_TYPE_ADC) ? "ADC" : "DAC",
675 dmabuf->divisor) );
676 }
677
678 /*
679 * mute some of the more prevalent registers to avoid popping.
680 */
681 static void cs_mute(struct cs_card *card, int state)
682 {
683 struct ac97_codec *dev=card->ac97_codec[0];
684
685 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs46xx: cs_mute()+ %s\n",
686 (state == CS_TRUE) ? "Muting" : "UnMuting") );
687
688 if(state == CS_TRUE)
689 {
690 /*
691 * fix pops when powering up on thinkpads
692 */
693 card->pm.u32AC97_master_volume = (u32)cs_ac97_get( dev,
694 (u8)BA0_AC97_MASTER_VOLUME);
695 card->pm.u32AC97_headphone_volume = (u32)cs_ac97_get(dev,
696 (u8)BA0_AC97_HEADPHONE_VOLUME);
697 card->pm.u32AC97_master_volume_mono = (u32)cs_ac97_get(dev,
698 (u8)BA0_AC97_MASTER_VOLUME_MONO);
699 card->pm.u32AC97_pcm_out_volume = (u32)cs_ac97_get(dev,
700 (u8)BA0_AC97_PCM_OUT_VOLUME);
701
702 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME, 0x8000);
703 cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, 0x8000);
704 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, 0x8000);
705 cs_ac97_set(dev, (u8)BA0_AC97_PCM_OUT_VOLUME, 0x8000);
706 }
707 else
708 {
709 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME, card->pm.u32AC97_master_volume);
710 cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, card->pm.u32AC97_headphone_volume);
711 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, card->pm.u32AC97_master_volume_mono);
712 cs_ac97_set(dev, (u8)BA0_AC97_PCM_OUT_VOLUME, card->pm.u32AC97_pcm_out_volume);
713 }
714 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs46xx: cs_mute()-\n"));
715 }
716
717 /* set playback sample rate */
718 static unsigned int cs_set_dac_rate(struct cs_state * state, unsigned int rate)
719 {
720 struct dmabuf *dmabuf = &state->dmabuf;
721 unsigned int tmp1, tmp2;
722 unsigned int phiIncr;
723 unsigned int correctionPerGOF, correctionPerSec;
724 unsigned long flags;
725
726 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_dac_rate()+ %d\n",rate) );
727
728 /*
729 * Compute the values used to drive the actual sample rate conversion.
730 * The following formulas are being computed, using inline assembly
731 * since we need to use 64 bit arithmetic to compute the values:
732 *
733 * phiIncr = floor((Fs,in * 2^26) / Fs,out)
734 * correctionPerGOF = floor((Fs,in * 2^26 - Fs,out * phiIncr) /
735 * GOF_PER_SEC)
736 * ulCorrectionPerSec = Fs,in * 2^26 - Fs,out * phiIncr -M
737 * GOF_PER_SEC * correctionPerGOF
738 *
739 * i.e.
740 *
741 * phiIncr:other = dividend:remainder((Fs,in * 2^26) / Fs,out)
742 * correctionPerGOF:correctionPerSec =
743 * dividend:remainder(ulOther / GOF_PER_SEC)
744 */
745 tmp1 = rate << 16;
746 phiIncr = tmp1 / 48000;
747 tmp1 -= phiIncr * 48000;
748 tmp1 <<= 10;
749 phiIncr <<= 10;
750 tmp2 = tmp1 / 48000;
751 phiIncr += tmp2;
752 tmp1 -= tmp2 * 48000;
753 correctionPerGOF = tmp1 / GOF_PER_SEC;
754 tmp1 -= correctionPerGOF * GOF_PER_SEC;
755 correctionPerSec = tmp1;
756
757 /*
758 * Fill in the SampleRateConverter control block.
759 */
760
761 spin_lock_irqsave(&state->card->lock, flags);
762 cs461x_poke(state->card, BA1_PSRC,
763 ((correctionPerSec << 16) & 0xFFFF0000) | (correctionPerGOF & 0xFFFF));
764 cs461x_poke(state->card, BA1_PPI, phiIncr);
765 spin_unlock_irqrestore(&state->card->lock, flags);
766 dmabuf->rate = rate;
767
768 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_dac_rate()- %d\n",rate) );
769 return rate;
770 }
771
772 /* set recording sample rate */
773 static unsigned int cs_set_adc_rate(struct cs_state * state, unsigned int rate)
774 {
775 struct dmabuf *dmabuf = &state->dmabuf;
776 struct cs_card *card = state->card;
777 unsigned int phiIncr, coeffIncr, tmp1, tmp2;
778 unsigned int correctionPerGOF, correctionPerSec, initialDelay;
779 unsigned int frameGroupLength, cnt;
780 unsigned long flags;
781 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_adc_rate()+ %d\n",rate) );
782
783 /*
784 * We can only decimate by up to a factor of 1/9th the hardware rate.
785 * Correct the value if an attempt is made to stray outside that limit.
786 */
787 if ((rate * 9) < 48000)
788 rate = 48000 / 9;
789
790 /*
791 * We can not capture at at rate greater than the Input Rate (48000).
792 * Return an error if an attempt is made to stray outside that limit.
793 */
794 if (rate > 48000)
795 rate = 48000;
796
797 /*
798 * Compute the values used to drive the actual sample rate conversion.
799 * The following formulas are being computed, using inline assembly
800 * since we need to use 64 bit arithmetic to compute the values:
801 *
802 * coeffIncr = -floor((Fs,out * 2^23) / Fs,in)
803 * phiIncr = floor((Fs,in * 2^26) / Fs,out)
804 * correctionPerGOF = floor((Fs,in * 2^26 - Fs,out * phiIncr) /
805 * GOF_PER_SEC)
806 * correctionPerSec = Fs,in * 2^26 - Fs,out * phiIncr -
807 * GOF_PER_SEC * correctionPerGOF
808 * initialDelay = ceil((24 * Fs,in) / Fs,out)
809 *
810 * i.e.
811 *
812 * coeffIncr = neg(dividend((Fs,out * 2^23) / Fs,in))
813 * phiIncr:ulOther = dividend:remainder((Fs,in * 2^26) / Fs,out)
814 * correctionPerGOF:correctionPerSec =
815 * dividend:remainder(ulOther / GOF_PER_SEC)
816 * initialDelay = dividend(((24 * Fs,in) + Fs,out - 1) / Fs,out)
817 */
818
819 tmp1 = rate << 16;
820 coeffIncr = tmp1 / 48000;
821 tmp1 -= coeffIncr * 48000;
822 tmp1 <<= 7;
823 coeffIncr <<= 7;
824 coeffIncr += tmp1 / 48000;
825 coeffIncr ^= 0xFFFFFFFF;
826 coeffIncr++;
827 tmp1 = 48000 << 16;
828 phiIncr = tmp1 / rate;
829 tmp1 -= phiIncr * rate;
830 tmp1 <<= 10;
831 phiIncr <<= 10;
832 tmp2 = tmp1 / rate;
833 phiIncr += tmp2;
834 tmp1 -= tmp2 * rate;
835 correctionPerGOF = tmp1 / GOF_PER_SEC;
836 tmp1 -= correctionPerGOF * GOF_PER_SEC;
837 correctionPerSec = tmp1;
838 initialDelay = ((48000 * 24) + rate - 1) / rate;
839
840 /*
841 * Fill in the VariDecimate control block.
842 */
843 spin_lock_irqsave(&card->lock, flags);
844 cs461x_poke(card, BA1_CSRC,
845 ((correctionPerSec << 16) & 0xFFFF0000) | (correctionPerGOF & 0xFFFF));
846 cs461x_poke(card, BA1_CCI, coeffIncr);
847 cs461x_poke(card, BA1_CD,
848 (((BA1_VARIDEC_BUF_1 + (initialDelay << 2)) << 16) & 0xFFFF0000) | 0x80);
849 cs461x_poke(card, BA1_CPI, phiIncr);
850 spin_unlock_irqrestore(&card->lock, flags);
851
852 /*
853 * Figure out the frame group length for the write back task. Basically,
854 * this is just the factors of 24000 (2^6*3*5^3) that are not present in
855 * the output sample rate.
856 */
857 frameGroupLength = 1;
858 for (cnt = 2; cnt <= 64; cnt *= 2) {
859 if (((rate / cnt) * cnt) != rate)
860 frameGroupLength *= 2;
861 }
862 if (((rate / 3) * 3) != rate) {
863 frameGroupLength *= 3;
864 }
865 for (cnt = 5; cnt <= 125; cnt *= 5) {
866 if (((rate / cnt) * cnt) != rate)
867 frameGroupLength *= 5;
868 }
869
870 /*
871 * Fill in the WriteBack control block.
872 */
873 spin_lock_irqsave(&card->lock, flags);
874 cs461x_poke(card, BA1_CFG1, frameGroupLength);
875 cs461x_poke(card, BA1_CFG2, (0x00800000 | frameGroupLength));
876 cs461x_poke(card, BA1_CCST, 0x0000FFFF);
877 cs461x_poke(card, BA1_CSPB, ((65536 * rate) / 24000));
878 cs461x_poke(card, (BA1_CSPB + 4), 0x0000FFFF);
879 spin_unlock_irqrestore(&card->lock, flags);
880 dmabuf->rate = rate;
881 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_adc_rate()- %d\n",rate) );
882 return rate;
883 }
884
885 /* prepare channel attributes for playback */
886 static void cs_play_setup(struct cs_state *state)
887 {
888 struct dmabuf *dmabuf = &state->dmabuf;
889 struct cs_card *card = state->card;
890 unsigned int tmp, Count, playFormat;
891
892 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_play_setup()+\n") );
893 cs461x_poke(card, BA1_PVOL, 0x80008000);
894 if(!dmabuf->SGok)
895 cs461x_poke(card, BA1_PBA, virt_to_bus(dmabuf->pbuf));
896
897 Count = 4;
898 playFormat=cs461x_peek(card, BA1_PFIE);
899 if ((dmabuf->fmt & CS_FMT_STEREO)) {
900 playFormat &= ~DMA_RQ_C2_AC_MONO_TO_STEREO;
901 Count *= 2;
902 }
903 else
904 playFormat |= DMA_RQ_C2_AC_MONO_TO_STEREO;
905
906 if ((dmabuf->fmt & CS_FMT_16BIT)) {
907 playFormat &= ~(DMA_RQ_C2_AC_8_TO_16_BIT
908 | DMA_RQ_C2_AC_SIGNED_CONVERT);
909 Count *= 2;
910 }
911 else
912 playFormat |= (DMA_RQ_C2_AC_8_TO_16_BIT
913 | DMA_RQ_C2_AC_SIGNED_CONVERT);
914
915 cs461x_poke(card, BA1_PFIE, playFormat);
916
917 tmp = cs461x_peek(card, BA1_PDTC);
918 tmp &= 0xfffffe00;
919 cs461x_poke(card, BA1_PDTC, tmp | --Count);
920
921 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_play_setup()-\n") );
922
923 }
924
925 static struct InitStruct
926 {
927 u32 off;
928 u32 val;
929 } InitArray[] = { {0x00000040, 0x3fc0000f},
930 {0x0000004c, 0x04800000},
931
932 {0x000000b3, 0x00000780},
933 {0x000000b7, 0x00000000},
934 {0x000000bc, 0x07800000},
935
936 {0x000000cd, 0x00800000},
937 };
938
939 /*
940 * "SetCaptureSPValues()" -- Initialize record task values before each
941 * capture startup.
942 */
943 static void SetCaptureSPValues(struct cs_card *card)
944 {
945 unsigned i, offset;
946 CS_DBGOUT(CS_FUNCTION, 8, printk("cs46xx: SetCaptureSPValues()+\n") );
947 for(i=0; i<sizeof(InitArray)/sizeof(struct InitStruct); i++)
948 {
949 offset = InitArray[i].off*4; /* 8bit to 32bit offset value */
950 cs461x_poke(card, offset, InitArray[i].val );
951 }
952 CS_DBGOUT(CS_FUNCTION, 8, printk("cs46xx: SetCaptureSPValues()-\n") );
953 }
954
955 /* prepare channel attributes for recording */
956 static void cs_rec_setup(struct cs_state *state)
957 {
958 struct cs_card *card = state->card;
959 struct dmabuf *dmabuf = &state->dmabuf;
960 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_rec_setup()+\n") );
961
962 SetCaptureSPValues(card);
963
964 /*
965 * set the attenuation to 0dB
966 */
967 cs461x_poke(card, BA1_CVOL, 0x80008000);
968
969 /*
970 * set the physical address of the capture buffer into the SP
971 */
972 cs461x_poke(card, BA1_CBA, virt_to_bus(dmabuf->rawbuf));
973
974 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_rec_setup()-\n") );
975 }
976
977
978 /* get current playback/recording dma buffer pointer (byte offset from LBA),
979 called with spinlock held! */
980
981 static inline unsigned cs_get_dma_addr(struct cs_state *state)
982 {
983 struct dmabuf *dmabuf = &state->dmabuf;
984 u32 offset;
985
986 if ( (!(dmabuf->enable & DAC_RUNNING)) &&
987 (!(dmabuf->enable & ADC_RUNNING) ) )
988 {
989 CS_DBGOUT(CS_ERROR, 2, printk(
990 "cs46xx: ERROR cs_get_dma_addr(): not enabled \n") );
991 return 0;
992 }
993
994 /*
995 * granularity is byte boundary, good part.
996 */
997 if(dmabuf->enable & DAC_RUNNING)
998 {
999 offset = cs461x_peek(state->card, BA1_PBA);
1000 }
1001 else /* ADC_RUNNING must be set */
1002 {
1003 offset = cs461x_peek(state->card, BA1_CBA);
1004 }
1005 CS_DBGOUT(CS_PARMS | CS_FUNCTION, 9,
1006 printk("cs46xx: cs_get_dma_addr() %d\n",offset) );
1007 offset = (u32)bus_to_virt((unsigned long)offset) - (u32)dmabuf->rawbuf;
1008 CS_DBGOUT(CS_PARMS | CS_FUNCTION, 8,
1009 printk("cs46xx: cs_get_dma_addr()- %d\n",offset) );
1010 return offset;
1011 }
1012
1013 static void resync_dma_ptrs(struct cs_state *state)
1014 {
1015 struct dmabuf *dmabuf;
1016
1017 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: resync_dma_ptrs()+ \n") );
1018 if(state)
1019 {
1020 dmabuf = &state->dmabuf;
1021 dmabuf->hwptr=dmabuf->swptr = 0;
1022 dmabuf->pringbuf = 0;
1023 }
1024 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: resync_dma_ptrs()- \n") );
1025 }
1026
1027 /* Stop recording (lock held) */
1028 static inline void __stop_adc(struct cs_state *state)
1029 {
1030 struct dmabuf *dmabuf = &state->dmabuf;
1031 struct cs_card *card = state->card;
1032 unsigned int tmp;
1033
1034 dmabuf->enable &= ~ADC_RUNNING;
1035
1036 tmp = cs461x_peek(card, BA1_CCTL);
1037 tmp &= 0xFFFF0000;
1038 cs461x_poke(card, BA1_CCTL, tmp );
1039 }
1040
1041 static void stop_adc(struct cs_state *state)
1042 {
1043 unsigned long flags;
1044
1045 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_adc()+ \n") );
1046 spin_lock_irqsave(&state->card->lock, flags);
1047 __stop_adc(state);
1048 spin_unlock_irqrestore(&state->card->lock, flags);
1049 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_adc()- \n") );
1050 }
1051
1052 static void start_adc(struct cs_state *state)
1053 {
1054 struct dmabuf *dmabuf = &state->dmabuf;
1055 struct cs_card *card = state->card;
1056 unsigned long flags;
1057 unsigned int tmp;
1058
1059 spin_lock_irqsave(&card->lock, flags);
1060 if (!(dmabuf->enable & ADC_RUNNING) &&
1061 ((dmabuf->mapped || dmabuf->count < (signed)dmabuf->dmasize)
1062 && dmabuf->ready) &&
1063 ((card->pm.flags & CS46XX_PM_IDLE) ||
1064 (card->pm.flags & CS46XX_PM_RESUMED)) )
1065 {
1066 dmabuf->enable |= ADC_RUNNING;
1067 cs_set_divisor(dmabuf);
1068 tmp = cs461x_peek(card, BA1_CCTL);
1069 tmp &= 0xFFFF0000;
1070 tmp |= card->cctl;
1071 CS_DBGOUT(CS_FUNCTION, 2, printk(
1072 "cs46xx: start_adc() poke 0x%x \n",tmp) );
1073 cs461x_poke(card, BA1_CCTL, tmp);
1074 }
1075 spin_unlock_irqrestore(&card->lock, flags);
1076 }
1077
1078 /* stop playback (lock held) */
1079 static inline void __stop_dac(struct cs_state *state)
1080 {
1081 struct dmabuf *dmabuf = &state->dmabuf;
1082 struct cs_card *card = state->card;
1083 unsigned int tmp;
1084
1085 dmabuf->enable &= ~DAC_RUNNING;
1086
1087 tmp=cs461x_peek(card, BA1_PCTL);
1088 tmp&=0xFFFF;
1089 cs461x_poke(card, BA1_PCTL, tmp);
1090 }
1091
1092 static void stop_dac(struct cs_state *state)
1093 {
1094 unsigned long flags;
1095
1096 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_dac()+ \n") );
1097 spin_lock_irqsave(&state->card->lock, flags);
1098 __stop_dac(state);
1099 spin_unlock_irqrestore(&state->card->lock, flags);
1100 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_dac()- \n") );
1101 }
1102
1103 static void start_dac(struct cs_state *state)
1104 {
1105 struct dmabuf *dmabuf = &state->dmabuf;
1106 struct cs_card *card = state->card;
1107 unsigned long flags;
1108 int tmp;
1109
1110 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: start_dac()+ \n") );
1111 spin_lock_irqsave(&card->lock, flags);
1112 if (!(dmabuf->enable & DAC_RUNNING) &&
1113 ((dmabuf->mapped || dmabuf->count > 0) && dmabuf->ready) &&
1114 ((card->pm.flags & CS46XX_PM_IDLE) ||
1115 (card->pm.flags & CS46XX_PM_RESUMED)) )
1116 {
1117 dmabuf->enable |= DAC_RUNNING;
1118 tmp = cs461x_peek(card, BA1_PCTL);
1119 tmp &= 0xFFFF;
1120 tmp |= card->pctl;
1121 CS_DBGOUT(CS_PARMS, 6, printk(
1122 "cs46xx: start_dac() poke card=%p tmp=0x%.08x addr=%p \n",
1123 card, (unsigned)tmp,
1124 card->ba1.idx[(BA1_PCTL >> 16) & 3]+(BA1_PCTL&0xffff) ) );
1125 cs461x_poke(card, BA1_PCTL, tmp);
1126 }
1127 spin_unlock_irqrestore(&card->lock, flags);
1128 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: start_dac()- \n") );
1129 }
1130
1131 #define DMABUF_MINORDER 1
1132
1133 /*
1134 * allocate DMA buffer, playback and recording buffers are separate.
1135 */
1136 static int alloc_dmabuf(struct cs_state *state)
1137 {
1138
1139 struct cs_card *card=state->card;
1140 struct dmabuf *dmabuf = &state->dmabuf;
1141 void *rawbuf = NULL;
1142 void *tmpbuff = NULL;
1143 int order;
1144 struct page *map, *mapend;
1145 unsigned long df;
1146
1147 dmabuf->ready = dmabuf->mapped = 0;
1148 dmabuf->SGok = 0;
1149 /*
1150 * check for order within limits, but do not overwrite value.
1151 */
1152 if((defaultorder > 1) && (defaultorder < 12))
1153 df = defaultorder;
1154 else
1155 df = 2;
1156
1157 for (order = df; order >= DMABUF_MINORDER; order--)
1158 if ( (rawbuf = (void *) pci_alloc_consistent(
1159 card->pci_dev, PAGE_SIZE << order, &dmabuf->dmaaddr)))
1160 break;
1161 if (!rawbuf) {
1162 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
1163 "cs46xx: alloc_dmabuf(): unable to allocate rawbuf\n"));
1164 return -ENOMEM;
1165 }
1166 dmabuf->buforder = order;
1167 dmabuf->rawbuf = rawbuf;
1168 // Now mark the pages as reserved; otherwise the
1169 // remap_pfn_range() in cs46xx_mmap doesn't work.
1170 // 1. get index to last page in mem_map array for rawbuf.
1171 mapend = virt_to_page(dmabuf->rawbuf +
1172 (PAGE_SIZE << dmabuf->buforder) - 1);
1173
1174 // 2. mark each physical page in range as 'reserved'.
1175 for (map = virt_to_page(dmabuf->rawbuf); map <= mapend; map++)
1176 cs4x_mem_map_reserve(map);
1177
1178 CS_DBGOUT(CS_PARMS, 9, printk("cs46xx: alloc_dmabuf(): allocated %ld (order = %d) bytes at %p\n",
1179 PAGE_SIZE << order, order, rawbuf) );
1180
1181 /*
1182 * only allocate the conversion buffer for the ADC
1183 */
1184 if(dmabuf->type == CS_TYPE_DAC)
1185 {
1186 dmabuf->tmpbuff = NULL;
1187 dmabuf->buforder_tmpbuff = 0;
1188 return 0;
1189 }
1190 /*
1191 * now the temp buffer for 16/8 conversions
1192 */
1193
1194 tmpbuff = (void *) pci_alloc_consistent(
1195 card->pci_dev, PAGE_SIZE << order, &dmabuf->dmaaddr_tmpbuff);
1196
1197 if (!tmpbuff)
1198 return -ENOMEM;
1199 CS_DBGOUT(CS_PARMS, 9, printk("cs46xx: allocated %ld (order = %d) bytes at %p\n",
1200 PAGE_SIZE << order, order, tmpbuff) );
1201
1202 dmabuf->tmpbuff = tmpbuff;
1203 dmabuf->buforder_tmpbuff = order;
1204
1205 // Now mark the pages as reserved; otherwise the
1206 // remap_pfn_range() in cs46xx_mmap doesn't work.
1207 // 1. get index to last page in mem_map array for rawbuf.
1208 mapend = virt_to_page(dmabuf->tmpbuff +
1209 (PAGE_SIZE << dmabuf->buforder_tmpbuff) - 1);
1210
1211 // 2. mark each physical page in range as 'reserved'.
1212 for (map = virt_to_page(dmabuf->tmpbuff); map <= mapend; map++)
1213 cs4x_mem_map_reserve(map);
1214 return 0;
1215 }
1216
1217 /* free DMA buffer */
1218 static void dealloc_dmabuf(struct cs_state *state)
1219 {
1220 struct dmabuf *dmabuf = &state->dmabuf;
1221 struct page *map, *mapend;
1222
1223 if (dmabuf->rawbuf) {
1224 // Undo prog_dmabuf()'s marking the pages as reserved
1225 mapend = virt_to_page(dmabuf->rawbuf +
1226 (PAGE_SIZE << dmabuf->buforder) - 1);
1227 for (map = virt_to_page(dmabuf->rawbuf); map <= mapend; map++)
1228 cs4x_mem_map_unreserve(map);
1229 free_dmabuf(state->card, dmabuf);
1230 }
1231
1232 if (dmabuf->tmpbuff) {
1233 // Undo prog_dmabuf()'s marking the pages as reserved
1234 mapend = virt_to_page(dmabuf->tmpbuff +
1235 (PAGE_SIZE << dmabuf->buforder_tmpbuff) - 1);
1236 for (map = virt_to_page(dmabuf->tmpbuff); map <= mapend; map++)
1237 cs4x_mem_map_unreserve(map);
1238 free_dmabuf2(state->card, dmabuf);
1239 }
1240
1241 dmabuf->rawbuf = NULL;
1242 dmabuf->tmpbuff = NULL;
1243 dmabuf->mapped = dmabuf->ready = 0;
1244 dmabuf->SGok = 0;
1245 }
1246
1247 static int __prog_dmabuf(struct cs_state *state)
1248 {
1249 struct dmabuf *dmabuf = &state->dmabuf;
1250 unsigned long flags;
1251 unsigned long allocated_pages, allocated_bytes;
1252 unsigned long tmp1, tmp2, fmt=0;
1253 unsigned long *ptmp = (unsigned long *) dmabuf->pbuf;
1254 unsigned long SGarray[9], nSGpages=0;
1255 int ret;
1256
1257 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()+ \n"));
1258 /*
1259 * check for CAPTURE and use only non-sg for initial release
1260 */
1261 if(dmabuf->type == CS_TYPE_ADC)
1262 {
1263 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf() ADC\n"));
1264 /*
1265 * add in non-sg support for capture.
1266 */
1267 spin_lock_irqsave(&state->card->lock, flags);
1268 /* add code to reset the rawbuf memory. TRW */
1269 resync_dma_ptrs(state);
1270 dmabuf->total_bytes = dmabuf->blocks = 0;
1271 dmabuf->count = dmabuf->error = dmabuf->underrun = 0;
1272
1273 dmabuf->SGok = 0;
1274
1275 spin_unlock_irqrestore(&state->card->lock, flags);
1276
1277 /* allocate DMA buffer if not allocated yet */
1278 if (!dmabuf->rawbuf || !dmabuf->tmpbuff)
1279 if ((ret = alloc_dmabuf(state)))
1280 return ret;
1281 /*
1282 * static image only supports 16Bit signed, stereo - hard code fmt
1283 */
1284 fmt = CS_FMT_16BIT | CS_FMT_STEREO;
1285
1286 dmabuf->numfrag = 2;
1287 dmabuf->fragsize = 2048;
1288 dmabuf->fragsamples = 2048 >> sample_shift[fmt];
1289 dmabuf->dmasize = 4096;
1290 dmabuf->fragshift = 11;
1291
1292 memset(dmabuf->rawbuf, (fmt & CS_FMT_16BIT) ? 0 : 0x80,
1293 dmabuf->dmasize);
1294 memset(dmabuf->tmpbuff, (fmt & CS_FMT_16BIT) ? 0 : 0x80,
1295 PAGE_SIZE<<dmabuf->buforder_tmpbuff);
1296
1297 /*
1298 * Now set up the ring
1299 */
1300
1301 spin_lock_irqsave(&state->card->lock, flags);
1302 cs_rec_setup(state);
1303 spin_unlock_irqrestore(&state->card->lock, flags);
1304
1305 /* set the ready flag for the dma buffer */
1306 dmabuf->ready = 1;
1307
1308 CS_DBGOUT(CS_PARMS, 4, printk(
1309 "cs46xx: prog_dmabuf(): CAPTURE rate=%d fmt=0x%x numfrag=%d "
1310 "fragsize=%d dmasize=%d\n",
1311 dmabuf->rate, dmabuf->fmt, dmabuf->numfrag,
1312 dmabuf->fragsize, dmabuf->dmasize) );
1313
1314 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- 0 \n"));
1315 return 0;
1316 }
1317 else if (dmabuf->type == CS_TYPE_DAC)
1318 {
1319 /*
1320 * Must be DAC
1321 */
1322 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf() DAC\n"));
1323 spin_lock_irqsave(&state->card->lock, flags);
1324 resync_dma_ptrs(state);
1325 dmabuf->total_bytes = dmabuf->blocks = 0;
1326 dmabuf->count = dmabuf->error = dmabuf->underrun = 0;
1327
1328 dmabuf->SGok = 0;
1329
1330 spin_unlock_irqrestore(&state->card->lock, flags);
1331
1332 /* allocate DMA buffer if not allocated yet */
1333 if (!dmabuf->rawbuf)
1334 if ((ret = alloc_dmabuf(state)))
1335 return ret;
1336
1337 allocated_pages = 1 << dmabuf->buforder;
1338 allocated_bytes = allocated_pages*PAGE_SIZE;
1339
1340 if(allocated_pages < 2)
1341 {
1342 CS_DBGOUT(CS_FUNCTION, 4, printk(
1343 "cs46xx: prog_dmabuf() Error: allocated_pages too small (%d)\n",
1344 (unsigned)allocated_pages));
1345 return -ENOMEM;
1346 }
1347
1348 /* Use all the pages allocated, fragsize 4k. */
1349 /* Use 'pbuf' for S/G page map table. */
1350 dmabuf->SGok = 1; /* Use S/G. */
1351
1352 nSGpages = allocated_bytes/4096; /* S/G pages always 4k. */
1353
1354 /* Set up S/G variables. */
1355 *ptmp = virt_to_bus(dmabuf->rawbuf);
1356 *(ptmp+1) = 0x00000008;
1357 for(tmp1= 1; tmp1 < nSGpages; tmp1++) {
1358 *(ptmp+2*tmp1) = virt_to_bus( (dmabuf->rawbuf)+4096*tmp1);
1359 if( tmp1 == nSGpages-1)
1360 tmp2 = 0xbfff0000;
1361 else
1362 tmp2 = 0x80000000+8*(tmp1+1);
1363 *(ptmp+2*tmp1+1) = tmp2;
1364 }
1365 SGarray[0] = 0x82c0200d;
1366 SGarray[1] = 0xffff0000;
1367 SGarray[2] = *ptmp;
1368 SGarray[3] = 0x00010600;
1369 SGarray[4] = *(ptmp+2);
1370 SGarray[5] = 0x80000010;
1371 SGarray[6] = *ptmp;
1372 SGarray[7] = *(ptmp+2);
1373 SGarray[8] = (virt_to_bus(dmabuf->pbuf) & 0xffff000) | 0x10;
1374
1375 if (dmabuf->SGok) {
1376 dmabuf->numfrag = nSGpages;
1377 dmabuf->fragsize = 4096;
1378 dmabuf->fragsamples = 4096 >> sample_shift[dmabuf->fmt];
1379 dmabuf->fragshift = 12;
1380 dmabuf->dmasize = dmabuf->numfrag*4096;
1381 }
1382 else {
1383 SGarray[0] = 0xf2c0000f;
1384 SGarray[1] = 0x00000200;
1385 SGarray[2] = 0;
1386 SGarray[3] = 0x00010600;
1387 SGarray[4]=SGarray[5]=SGarray[6]=SGarray[7]=SGarray[8] = 0;
1388 dmabuf->numfrag = 2;
1389 dmabuf->fragsize = 2048;
1390 dmabuf->fragsamples = 2048 >> sample_shift[dmabuf->fmt];
1391 dmabuf->dmasize = 4096;
1392 dmabuf->fragshift = 11;
1393 }
1394 for(tmp1 = 0; tmp1 < sizeof(SGarray)/4; tmp1++)
1395 cs461x_poke( state->card, BA1_PDTC+tmp1*4, SGarray[tmp1]);
1396
1397 memset(dmabuf->rawbuf, (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
1398 dmabuf->dmasize);
1399
1400 /*
1401 * Now set up the ring
1402 */
1403
1404 spin_lock_irqsave(&state->card->lock, flags);
1405 cs_play_setup(state);
1406 spin_unlock_irqrestore(&state->card->lock, flags);
1407
1408 /* set the ready flag for the dma buffer */
1409 dmabuf->ready = 1;
1410
1411 CS_DBGOUT(CS_PARMS, 4, printk(
1412 "cs46xx: prog_dmabuf(): PLAYBACK rate=%d fmt=0x%x numfrag=%d "
1413 "fragsize=%d dmasize=%d\n",
1414 dmabuf->rate, dmabuf->fmt, dmabuf->numfrag,
1415 dmabuf->fragsize, dmabuf->dmasize) );
1416
1417 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- \n"));
1418 return 0;
1419 }
1420 else
1421 {
1422 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- Invalid Type %d\n",
1423 dmabuf->type));
1424 }
1425 return 1;
1426 }
1427
1428 static int prog_dmabuf(struct cs_state *state)
1429 {
1430 int ret;
1431
1432 mutex_lock(&state->sem);
1433 ret = __prog_dmabuf(state);
1434 mutex_unlock(&state->sem);
1435
1436 return ret;
1437 }
1438
1439 static void cs_clear_tail(struct cs_state *state)
1440 {
1441 }
1442
1443 static int drain_dac(struct cs_state *state, int nonblock)
1444 {
1445 DECLARE_WAITQUEUE(wait, current);
1446 struct dmabuf *dmabuf = &state->dmabuf;
1447 struct cs_card *card=state->card;
1448 unsigned long flags;
1449 unsigned long tmo;
1450 int count;
1451
1452 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()+ \n"));
1453 if (dmabuf->mapped || !dmabuf->ready)
1454 {
1455 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()- 0, not ready\n"));
1456 return 0;
1457 }
1458
1459 add_wait_queue(&dmabuf->wait, &wait);
1460 for (;;) {
1461 /* It seems that we have to set the current state to TASK_INTERRUPTIBLE
1462 every time to make the process really go to sleep */
1463 current->state = TASK_INTERRUPTIBLE;
1464
1465 spin_lock_irqsave(&state->card->lock, flags);
1466 count = dmabuf->count;
1467 spin_unlock_irqrestore(&state->card->lock, flags);
1468
1469 if (count <= 0)
1470 break;
1471
1472 if (signal_pending(current))
1473 break;
1474
1475 if (nonblock) {
1476 remove_wait_queue(&dmabuf->wait, &wait);
1477 current->state = TASK_RUNNING;
1478 return -EBUSY;
1479 }
1480
1481 tmo = (dmabuf->dmasize * HZ) / dmabuf->rate;
1482 tmo >>= sample_shift[dmabuf->fmt];
1483 tmo += (2048*HZ)/dmabuf->rate;
1484
1485 if (!schedule_timeout(tmo ? tmo : 1) && tmo){
1486 printk(KERN_ERR "cs46xx: drain_dac, dma timeout? %d\n", count);
1487 break;
1488 }
1489 }
1490 remove_wait_queue(&dmabuf->wait, &wait);
1491 current->state = TASK_RUNNING;
1492 if (signal_pending(current))
1493 {
1494 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()- -ERESTARTSYS\n"));
1495 /*
1496 * set to silence and let that clear the fifos.
1497 */
1498 cs461x_clear_serial_FIFOs(card, CS_TYPE_DAC);
1499 return -ERESTARTSYS;
1500 }
1501
1502 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()- 0\n"));
1503 return 0;
1504 }
1505
1506
1507 /* update buffer manangement pointers, especially, dmabuf->count and dmabuf->hwptr */
1508 static void cs_update_ptr(struct cs_card *card, int wake)
1509 {
1510 struct cs_state *state;
1511 struct dmabuf *dmabuf;
1512 unsigned hwptr;
1513 int diff;
1514
1515 /* error handling and process wake up for ADC */
1516 state = card->states[0];
1517 if(state)
1518 {
1519 dmabuf = &state->dmabuf;
1520 if (dmabuf->enable & ADC_RUNNING) {
1521 /* update hardware pointer */
1522 hwptr = cs_get_dma_addr(state);
1523
1524 diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1525 CS_DBGOUT(CS_PARMS, 9, printk(
1526 "cs46xx: cs_update_ptr()+ ADC hwptr=%d diff=%d\n",
1527 hwptr,diff) );
1528 dmabuf->hwptr = hwptr;
1529 dmabuf->total_bytes += diff;
1530 dmabuf->count += diff;
1531 if (dmabuf->count > dmabuf->dmasize)
1532 dmabuf->count = dmabuf->dmasize;
1533
1534 if(dmabuf->mapped)
1535 {
1536 if (wake && dmabuf->count >= (signed)dmabuf->fragsize)
1537 wake_up(&dmabuf->wait);
1538 } else
1539 {
1540 if (wake && dmabuf->count > 0)
1541 wake_up(&dmabuf->wait);
1542 }
1543 }
1544 }
1545
1546 /*
1547 * Now the DAC
1548 */
1549 state = card->states[1];
1550 if(state)
1551 {
1552 dmabuf = &state->dmabuf;
1553 /* error handling and process wake up for DAC */
1554 if (dmabuf->enable & DAC_RUNNING) {
1555 /* update hardware pointer */
1556 hwptr = cs_get_dma_addr(state);
1557
1558 diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1559 CS_DBGOUT(CS_PARMS, 9, printk(
1560 "cs46xx: cs_update_ptr()+ DAC hwptr=%d diff=%d\n",
1561 hwptr,diff) );
1562 dmabuf->hwptr = hwptr;
1563 dmabuf->total_bytes += diff;
1564 if (dmabuf->mapped) {
1565 dmabuf->count += diff;
1566 if (wake && dmabuf->count >= (signed)dmabuf->fragsize)
1567 wake_up(&dmabuf->wait);
1568 /*
1569 * other drivers use fragsize, but don't see any sense
1570 * in that, since dmasize is the buffer asked for
1571 * via mmap.
1572 */
1573 if( dmabuf->count > dmabuf->dmasize)
1574 dmabuf->count &= dmabuf->dmasize-1;
1575 } else {
1576 dmabuf->count -= diff;
1577 /*
1578 * backfill with silence and clear out the last
1579 * "diff" number of bytes.
1580 */
1581 if(hwptr >= diff)
1582 {
1583 memset(dmabuf->rawbuf + hwptr - diff,
1584 (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80, diff);
1585 }
1586 else
1587 {
1588 memset(dmabuf->rawbuf,
1589 (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
1590 (unsigned)hwptr);
1591 memset((char *)dmabuf->rawbuf +
1592 dmabuf->dmasize + hwptr - diff,
1593 (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
1594 diff - hwptr);
1595 }
1596
1597 if (dmabuf->count < 0 || dmabuf->count > dmabuf->dmasize) {
1598 CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
1599 "cs46xx: ERROR DAC count<0 or count > dmasize (%d)\n",
1600 dmabuf->count));
1601 /*
1602 * buffer underrun or buffer overrun, reset the
1603 * count of bytes written back to 0.
1604 */
1605 if(dmabuf->count < 0)
1606 dmabuf->underrun=1;
1607 dmabuf->count = 0;
1608 dmabuf->error++;
1609 }
1610 if (wake && dmabuf->count < (signed)dmabuf->dmasize/2)
1611 wake_up(&dmabuf->wait);
1612 }
1613 }
1614 }
1615 }
1616
1617
1618 /* hold spinlock for the following! */
1619 static void cs_handle_midi(struct cs_card *card)
1620 {
1621 unsigned char ch;
1622 int wake;
1623 unsigned temp1;
1624
1625 wake = 0;
1626 while (!(cs461x_peekBA0(card, BA0_MIDSR) & MIDSR_RBE)) {
1627 ch = cs461x_peekBA0(card, BA0_MIDRP);
1628 if (card->midi.icnt < CS_MIDIINBUF) {
1629 card->midi.ibuf[card->midi.iwr] = ch;
1630 card->midi.iwr = (card->midi.iwr + 1) % CS_MIDIINBUF;
1631 card->midi.icnt++;
1632 }
1633 wake = 1;
1634 }
1635 if (wake)
1636 wake_up(&card->midi.iwait);
1637 wake = 0;
1638 while (!(cs461x_peekBA0(card, BA0_MIDSR) & MIDSR_TBF) && card->midi.ocnt > 0) {
1639 temp1 = ( card->midi.obuf[card->midi.ord] ) & 0x000000ff;
1640 cs461x_pokeBA0(card, BA0_MIDWP,temp1);
1641 card->midi.ord = (card->midi.ord + 1) % CS_MIDIOUTBUF;
1642 card->midi.ocnt--;
1643 if (card->midi.ocnt < CS_MIDIOUTBUF-16)
1644 wake = 1;
1645 }
1646 if (wake)
1647 wake_up(&card->midi.owait);
1648 }
1649
1650 static irqreturn_t cs_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1651 {
1652 struct cs_card *card = (struct cs_card *)dev_id;
1653 /* Single channel card */
1654 struct cs_state *recstate = card->channel[0].state;
1655 struct cs_state *playstate = card->channel[1].state;
1656 u32 status;
1657
1658 CS_DBGOUT(CS_INTERRUPT, 9, printk("cs46xx: cs_interrupt()+ \n"));
1659
1660 spin_lock(&card->lock);
1661
1662 status = cs461x_peekBA0(card, BA0_HISR);
1663
1664 if ((status & 0x7fffffff) == 0)
1665 {
1666 cs461x_pokeBA0(card, BA0_HICR, HICR_CHGM|HICR_IEV);
1667 spin_unlock(&card->lock);
1668 return IRQ_HANDLED; /* Might be IRQ_NONE.. */
1669 }
1670
1671 /*
1672 * check for playback or capture interrupt only
1673 */
1674 if( ((status & HISR_VC0) && playstate && playstate->dmabuf.ready) ||
1675 (((status & HISR_VC1) && recstate && recstate->dmabuf.ready)) )
1676 {
1677 CS_DBGOUT(CS_INTERRUPT, 8, printk(
1678 "cs46xx: cs_interrupt() interrupt bit(s) set (0x%x)\n",status));
1679 cs_update_ptr(card, CS_TRUE);
1680 }
1681
1682 if( status & HISR_MIDI )
1683 cs_handle_midi(card);
1684
1685 /* clear 'em */
1686 cs461x_pokeBA0(card, BA0_HICR, HICR_CHGM|HICR_IEV);
1687 spin_unlock(&card->lock);
1688 CS_DBGOUT(CS_INTERRUPT, 9, printk("cs46xx: cs_interrupt()- \n"));
1689 return IRQ_HANDLED;
1690 }
1691
1692
1693 /**********************************************************************/
1694
1695 static ssize_t cs_midi_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
1696 {
1697 struct cs_card *card = (struct cs_card *)file->private_data;
1698 ssize_t ret;
1699 unsigned long flags;
1700 unsigned ptr;
1701 int cnt;
1702
1703 if (!access_ok(VERIFY_WRITE, buffer, count))
1704 return -EFAULT;
1705 ret = 0;
1706 while (count > 0) {
1707 spin_lock_irqsave(&card->lock, flags);
1708 ptr = card->midi.ird;
1709 cnt = CS_MIDIINBUF - ptr;
1710 if (card->midi.icnt < cnt)
1711 cnt = card->midi.icnt;
1712 spin_unlock_irqrestore(&card->lock, flags);
1713 if (cnt > count)
1714 cnt = count;
1715 if (cnt <= 0) {
1716 if (file->f_flags & O_NONBLOCK)
1717 return ret ? ret : -EAGAIN;
1718 interruptible_sleep_on(&card->midi.iwait);
1719 if (signal_pending(current))
1720 return ret ? ret : -ERESTARTSYS;
1721 continue;
1722 }
1723 if (copy_to_user(buffer, card->midi.ibuf + ptr, cnt))
1724 return ret ? ret : -EFAULT;
1725 ptr = (ptr + cnt) % CS_MIDIINBUF;
1726 spin_lock_irqsave(&card->lock, flags);
1727 card->midi.ird = ptr;
1728 card->midi.icnt -= cnt;
1729 spin_unlock_irqrestore(&card->lock, flags);
1730 count -= cnt;
1731 buffer += cnt;
1732 ret += cnt;
1733 }
1734 return ret;
1735 }
1736
1737
1738 static ssize_t cs_midi_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
1739 {
1740 struct cs_card *card = (struct cs_card *)file->private_data;
1741 ssize_t ret;
1742 unsigned long flags;
1743 unsigned ptr;
1744 int cnt;
1745
1746 if (!access_ok(VERIFY_READ, buffer, count))
1747 return -EFAULT;
1748 ret = 0;
1749 while (count > 0) {
1750 spin_lock_irqsave(&card->lock, flags);
1751 ptr = card->midi.owr;
1752 cnt = CS_MIDIOUTBUF - ptr;
1753 if (card->midi.ocnt + cnt > CS_MIDIOUTBUF)
1754 cnt = CS_MIDIOUTBUF - card->midi.ocnt;
1755 if (cnt <= 0)
1756 cs_handle_midi(card);
1757 spin_unlock_irqrestore(&card->lock, flags);
1758 if (cnt > count)
1759 cnt = count;
1760 if (cnt <= 0) {
1761 if (file->f_flags & O_NONBLOCK)
1762 return ret ? ret : -EAGAIN;
1763 interruptible_sleep_on(&card->midi.owait);
1764 if (signal_pending(current))
1765 return ret ? ret : -ERESTARTSYS;
1766 continue;
1767 }
1768 if (copy_from_user(card->midi.obuf + ptr, buffer, cnt))
1769 return ret ? ret : -EFAULT;
1770 ptr = (ptr + cnt) % CS_MIDIOUTBUF;
1771 spin_lock_irqsave(&card->lock, flags);
1772 card->midi.owr = ptr;
1773 card->midi.ocnt += cnt;
1774 spin_unlock_irqrestore(&card->lock, flags);
1775 count -= cnt;
1776 buffer += cnt;
1777 ret += cnt;
1778 spin_lock_irqsave(&card->lock, flags);
1779 cs_handle_midi(card);
1780 spin_unlock_irqrestore(&card->lock, flags);
1781 }
1782 return ret;
1783 }
1784
1785
1786 static unsigned int cs_midi_poll(struct file *file, struct poll_table_struct *wait)
1787 {
1788 struct cs_card *card = (struct cs_card *)file->private_data;
1789 unsigned long flags;
1790 unsigned int mask = 0;
1791
1792 if (file->f_flags & FMODE_WRITE)
1793 poll_wait(file, &card->midi.owait, wait);
1794 if (file->f_flags & FMODE_READ)
1795 poll_wait(file, &card->midi.iwait, wait);
1796 spin_lock_irqsave(&card->lock, flags);
1797 if (file->f_flags & FMODE_READ) {
1798 if (card->midi.icnt > 0)
1799 mask |= POLLIN | POLLRDNORM;
1800 }
1801 if (file->f_flags & FMODE_WRITE) {
1802 if (card->midi.ocnt < CS_MIDIOUTBUF)
1803 mask |= POLLOUT | POLLWRNORM;
1804 }
1805 spin_unlock_irqrestore(&card->lock, flags);
1806 return mask;
1807 }
1808
1809
1810 static int cs_midi_open(struct inode *inode, struct file *file)
1811 {
1812 unsigned int minor = iminor(inode);
1813 struct cs_card *card=NULL;
1814 unsigned long flags;
1815 struct list_head *entry;
1816
1817 list_for_each(entry, &cs46xx_devs)
1818 {
1819 card = list_entry(entry, struct cs_card, list);
1820 if (card->dev_midi == minor)
1821 break;
1822 }
1823
1824 if (entry == &cs46xx_devs)
1825 return -ENODEV;
1826 if (!card)
1827 {
1828 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 2, printk(KERN_INFO
1829 "cs46xx: cs46xx_midi_open(): Error - unable to find card struct\n"));
1830 return -ENODEV;
1831 }
1832
1833 file->private_data = card;
1834 /* wait for device to become free */
1835 mutex_lock(&card->midi.open_mutex);
1836 while (card->midi.open_mode & file->f_mode) {
1837 if (file->f_flags & O_NONBLOCK) {
1838 mutex_unlock(&card->midi.open_mutex);
1839 return -EBUSY;
1840 }
1841 mutex_unlock(&card->midi.open_mutex);
1842 interruptible_sleep_on(&card->midi.open_wait);
1843 if (signal_pending(current))
1844 return -ERESTARTSYS;
1845 mutex_lock(&card->midi.open_mutex);
1846 }
1847 spin_lock_irqsave(&card->midi.lock, flags);
1848 if (!(card->midi.open_mode & (FMODE_READ | FMODE_WRITE))) {
1849 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
1850 card->midi.ord = card->midi.owr = card->midi.ocnt = 0;
1851 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
1852 cs461x_pokeBA0(card, BA0_MIDCR, 0x0000000f); /* Enable xmit, rcv. */
1853 cs461x_pokeBA0(card, BA0_HICR, HICR_IEV | HICR_CHGM); /* Enable interrupts */
1854 }
1855 if (file->f_mode & FMODE_READ) {
1856 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
1857 }
1858 if (file->f_mode & FMODE_WRITE) {
1859 card->midi.ord = card->midi.owr = card->midi.ocnt = 0;
1860 }
1861 spin_unlock_irqrestore(&card->midi.lock, flags);
1862 card->midi.open_mode |= (file->f_mode & (FMODE_READ | FMODE_WRITE));
1863 mutex_unlock(&card->midi.open_mutex);
1864 return 0;
1865 }
1866
1867
1868 static int cs_midi_release(struct inode *inode, struct file *file)
1869 {
1870 struct cs_card *card = (struct cs_card *)file->private_data;
1871 DECLARE_WAITQUEUE(wait, current);
1872 unsigned long flags;
1873 unsigned count, tmo;
1874
1875 if (file->f_mode & FMODE_WRITE) {
1876 current->state = TASK_INTERRUPTIBLE;
1877 add_wait_queue(&card->midi.owait, &wait);
1878 for (;;) {
1879 spin_lock_irqsave(&card->midi.lock, flags);
1880 count = card->midi.ocnt;
1881 spin_unlock_irqrestore(&card->midi.lock, flags);
1882 if (count <= 0)
1883 break;
1884 if (signal_pending(current))
1885 break;
1886 if (file->f_flags & O_NONBLOCK)
1887 break;
1888 tmo = (count * HZ) / 3100;
1889 if (!schedule_timeout(tmo ? : 1) && tmo)
1890 printk(KERN_DEBUG "cs46xx: midi timed out??\n");
1891 }
1892 remove_wait_queue(&card->midi.owait, &wait);
1893 current->state = TASK_RUNNING;
1894 }
1895 mutex_lock(&card->midi.open_mutex);
1896 card->midi.open_mode &= (~(file->f_mode & (FMODE_READ | FMODE_WRITE)));
1897 mutex_unlock(&card->midi.open_mutex);
1898 wake_up(&card->midi.open_wait);
1899 return 0;
1900 }
1901
1902 /*
1903 * Midi file operations struct.
1904 */
1905 static /*const*/ struct file_operations cs_midi_fops = {
1906 CS_OWNER CS_THIS_MODULE
1907 .llseek = no_llseek,
1908 .read = cs_midi_read,
1909 .write = cs_midi_write,
1910 .poll = cs_midi_poll,
1911 .open = cs_midi_open,
1912 .release = cs_midi_release,
1913 };
1914
1915 /*
1916 *
1917 * CopySamples copies 16-bit stereo signed samples from the source to the
1918 * destination, possibly converting down to unsigned 8-bit and/or mono.
1919 * count specifies the number of output bytes to write.
1920 *
1921 * Arguments:
1922 *
1923 * dst - Pointer to a destination buffer.
1924 * src - Pointer to a source buffer
1925 * count - The number of bytes to copy into the destination buffer.
1926 * fmt - CS_FMT_16BIT and/or CS_FMT_STEREO bits
1927 * dmabuf - pointer to the dma buffer structure
1928 *
1929 * NOTES: only call this routine if the output desired is not 16 Signed Stereo
1930 *
1931 *
1932 */
1933 static void CopySamples(char *dst, char *src, int count, unsigned fmt,
1934 struct dmabuf *dmabuf)
1935 {
1936
1937 s32 s32AudioSample;
1938 s16 *psSrc=(s16 *)src;
1939 s16 *psDst=(s16 *)dst;
1940 u8 *pucDst=(u8 *)dst;
1941
1942 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs46xx: CopySamples()+ ") );
1943 CS_DBGOUT(CS_WAVE_READ, 8, printk(KERN_INFO
1944 " dst=%p src=%p count=%d fmt=0x%x\n",
1945 dst,src,count,fmt) );
1946
1947 /*
1948 * See if the data should be output as 8-bit unsigned stereo.
1949 */
1950 if((fmt & CS_FMT_STEREO) && !(fmt & CS_FMT_16BIT))
1951 {
1952 /*
1953 * Convert each 16-bit signed stereo sample to 8-bit unsigned
1954 * stereo using rounding.
1955 */
1956 psSrc = (s16 *)src;
1957 count = count/2;
1958 while(count--)
1959 {
1960 *(pucDst++) = (u8)(((s16)(*psSrc++) + (s16)0x8000) >> 8);
1961 }
1962 }
1963 /*
1964 * See if the data should be output at 8-bit unsigned mono.
1965 */
1966 else if(!(fmt & CS_FMT_STEREO) && !(fmt & CS_FMT_16BIT))
1967 {
1968 /*
1969 * Convert each 16-bit signed stereo sample to 8-bit unsigned
1970 * mono using averaging and rounding.
1971 */
1972 psSrc = (s16 *)src;
1973 count = count/2;
1974 while(count--)
1975 {
1976 s32AudioSample = ((*psSrc)+(*(psSrc + 1)))/2 + (s32)0x80;
1977 if(s32AudioSample > 0x7fff)
1978 s32AudioSample = 0x7fff;
1979 *(pucDst++) = (u8)(((s16)s32AudioSample + (s16)0x8000) >> 8);
1980 psSrc += 2;
1981 }
1982 }
1983 /*
1984 * See if the data should be output at 16-bit signed mono.
1985 */
1986 else if(!(fmt & CS_FMT_STEREO) && (fmt & CS_FMT_16BIT))
1987 {
1988 /*
1989 * Convert each 16-bit signed stereo sample to 16-bit signed
1990 * mono using averaging.
1991 */
1992 psSrc = (s16 *)src;
1993 count = count/2;
1994 while(count--)
1995 {
1996 *(psDst++) = (s16)((*psSrc)+(*(psSrc + 1)))/2;
1997 psSrc += 2;
1998 }
1999 }
2000 }
2001
2002 /*
2003 * cs_copy_to_user()
2004 * replacement for the standard copy_to_user, to allow for a conversion from
2005 * 16 bit to 8 bit and from stereo to mono, if the record conversion is active.
2006 * The current CS46xx/CS4280 static image only records in 16bit unsigned Stereo,
2007 * so we convert from any of the other format combinations.
2008 */
2009 static unsigned cs_copy_to_user(
2010 struct cs_state *s,
2011 void __user *dest,
2012 void *hwsrc,
2013 unsigned cnt,
2014 unsigned *copied)
2015 {
2016 struct dmabuf *dmabuf = &s->dmabuf;
2017 void *src = hwsrc; /* default to the standard destination buffer addr */
2018
2019 CS_DBGOUT(CS_FUNCTION, 6, printk(KERN_INFO
2020 "cs_copy_to_user()+ fmt=0x%x cnt=%d dest=%p\n",
2021 dmabuf->fmt,(unsigned)cnt,dest) );
2022
2023 if(cnt > dmabuf->dmasize)
2024 {
2025 cnt = dmabuf->dmasize;
2026 }
2027 if(!cnt)
2028 {
2029 *copied = 0;
2030 return 0;
2031 }
2032 if(dmabuf->divisor != 1)
2033 {
2034 if(!dmabuf->tmpbuff)
2035 {
2036 *copied = cnt/dmabuf->divisor;
2037 return 0;
2038 }
2039
2040 CopySamples((char *)dmabuf->tmpbuff, (char *)hwsrc, cnt,
2041 dmabuf->fmt, dmabuf);
2042 src = dmabuf->tmpbuff;
2043 cnt = cnt/dmabuf->divisor;
2044 }
2045 if (copy_to_user(dest, src, cnt))
2046 {
2047 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_ERR
2048 "cs46xx: cs_copy_to_user()- fault dest=%p src=%p cnt=%d\n",
2049 dest,src,cnt) );
2050 *copied = 0;
2051 return -EFAULT;
2052 }
2053 *copied = cnt;
2054 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO
2055 "cs46xx: cs_copy_to_user()- copied bytes is %d \n",cnt) );
2056 return 0;
2057 }
2058
2059 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be copied to
2060 the user's buffer. it is filled by the dma machine and drained by this loop. */
2061 static ssize_t cs_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
2062 {
2063 struct cs_card *card = (struct cs_card *) file->private_data;
2064 struct cs_state *state;
2065 DECLARE_WAITQUEUE(wait, current);
2066 struct dmabuf *dmabuf;
2067 ssize_t ret = 0;
2068 unsigned long flags;
2069 unsigned swptr;
2070 int cnt;
2071 unsigned copied=0;
2072
2073 CS_DBGOUT(CS_WAVE_READ | CS_FUNCTION, 4,
2074 printk("cs46xx: cs_read()+ %zd\n",count) );
2075 state = (struct cs_state *)card->states[0];
2076 if(!state)
2077 return -ENODEV;
2078 dmabuf = &state->dmabuf;
2079
2080 if (dmabuf->mapped)
2081 return -ENXIO;
2082 if (!access_ok(VERIFY_WRITE, buffer, count))
2083 return -EFAULT;
2084
2085 mutex_lock(&state->sem);
2086 if (!dmabuf->ready && (ret = __prog_dmabuf(state)))
2087 goto out2;
2088
2089 add_wait_queue(&state->dmabuf.wait, &wait);
2090 while (count > 0) {
2091 while(!(card->pm.flags & CS46XX_PM_IDLE))
2092 {
2093 schedule();
2094 if (signal_pending(current)) {
2095 if(!ret) ret = -ERESTARTSYS;
2096 goto out;
2097 }
2098 }
2099 spin_lock_irqsave(&state->card->lock, flags);
2100 swptr = dmabuf->swptr;
2101 cnt = dmabuf->dmasize - swptr;
2102 if (dmabuf->count < cnt)
2103 cnt = dmabuf->count;
2104 if (cnt <= 0)
2105 __set_current_state(TASK_INTERRUPTIBLE);
2106 spin_unlock_irqrestore(&state->card->lock, flags);
2107
2108 if (cnt > (count * dmabuf->divisor))
2109 cnt = count * dmabuf->divisor;
2110 if (cnt <= 0) {
2111 /* buffer is empty, start the dma machine and wait for data to be
2112 recorded */
2113 start_adc(state);
2114 if (file->f_flags & O_NONBLOCK) {
2115 if (!ret) ret = -EAGAIN;
2116 goto out;
2117 }
2118 mutex_unlock(&state->sem);
2119 schedule();
2120 if (signal_pending(current)) {
2121 if(!ret) ret = -ERESTARTSYS;
2122 goto out;
2123 }
2124 mutex_lock(&state->sem);
2125 if (dmabuf->mapped)
2126 {
2127 if(!ret)
2128 ret = -ENXIO;
2129 goto out;
2130 }
2131 continue;
2132 }
2133
2134 CS_DBGOUT(CS_WAVE_READ, 2, printk(KERN_INFO
2135 "_read() copy_to cnt=%d count=%zd ", cnt,count) );
2136 CS_DBGOUT(CS_WAVE_READ, 8, printk(KERN_INFO
2137 " .dmasize=%d .count=%d buffer=%p ret=%zd\n",
2138 dmabuf->dmasize,dmabuf->count,buffer,ret) );
2139
2140 if (cs_copy_to_user(state, buffer,
2141 (char *)dmabuf->rawbuf + swptr, cnt, &copied))
2142 {
2143 if (!ret) ret = -EFAULT;
2144 goto out;
2145 }
2146 swptr = (swptr + cnt) % dmabuf->dmasize;
2147 spin_lock_irqsave(&card->lock, flags);
2148 dmabuf->swptr = swptr;
2149 dmabuf->count -= cnt;
2150 spin_unlock_irqrestore(&card->lock, flags);
2151 count -= copied;
2152 buffer += copied;
2153 ret += copied;
2154 start_adc(state);
2155 }
2156 out:
2157 remove_wait_queue(&state->dmabuf.wait, &wait);
2158 out2:
2159 mutex_unlock(&state->sem);
2160 set_current_state(TASK_RUNNING);
2161 CS_DBGOUT(CS_WAVE_READ | CS_FUNCTION, 4,
2162 printk("cs46xx: cs_read()- %zd\n",ret) );
2163 return ret;
2164 }
2165
2166 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be dma to
2167 the soundcard. it is drained by the dma machine and filled by this loop. */
2168 static ssize_t cs_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
2169 {
2170 struct cs_card *card = (struct cs_card *) file->private_data;
2171 struct cs_state *state;
2172 DECLARE_WAITQUEUE(wait, current);
2173 struct dmabuf *dmabuf;
2174 ssize_t ret;
2175 unsigned long flags;
2176 unsigned swptr;
2177 int cnt;
2178
2179 CS_DBGOUT(CS_WAVE_WRITE | CS_FUNCTION, 4,
2180 printk("cs46xx: cs_write called, count = %zd\n", count) );
2181 state = (struct cs_state *)card->states[1];
2182 if(!state)
2183 return -ENODEV;
2184 if (!access_ok(VERIFY_READ, buffer, count))
2185 return -EFAULT;
2186 dmabuf = &state->dmabuf;
2187
2188 mutex_lock(&state->sem);
2189 if (dmabuf->mapped)
2190 {
2191 ret = -ENXIO;
2192 goto out;
2193 }
2194
2195 if (!dmabuf->ready && (ret = __prog_dmabuf(state)))
2196 goto out;
2197 add_wait_queue(&state->dmabuf.wait, &wait);
2198 ret = 0;
2199 /*
2200 * Start the loop to read from the user's buffer and write to the dma buffer.
2201 * check for PM events and underrun/overrun in the loop.
2202 */
2203 while (count > 0) {
2204 while(!(card->pm.flags & CS46XX_PM_IDLE))
2205 {
2206 schedule();
2207 if (signal_pending(current)) {
2208 if(!ret) ret = -ERESTARTSYS;
2209 goto out;
2210 }
2211 }
2212 spin_lock_irqsave(&state->card->lock, flags);
2213 if (dmabuf->count < 0) {
2214 /* buffer underrun, we are recovering from sleep_on_timeout,
2215 resync hwptr and swptr */
2216 dmabuf->count = 0;
2217 dmabuf->swptr = dmabuf->hwptr;
2218 }
2219 if (dmabuf->underrun)
2220 {
2221 dmabuf->underrun = 0;
2222 dmabuf->hwptr = cs_get_dma_addr(state);
2223 dmabuf->swptr = dmabuf->hwptr;
2224 }
2225
2226 swptr = dmabuf->swptr;
2227 cnt = dmabuf->dmasize - swptr;
2228 if (dmabuf->count + cnt > dmabuf->dmasize)
2229 cnt = dmabuf->dmasize - dmabuf->count;
2230 if (cnt <= 0)
2231 __set_current_state(TASK_INTERRUPTIBLE);
2232 spin_unlock_irqrestore(&state->card->lock, flags);
2233
2234 if (cnt > count)
2235 cnt = count;
2236 if (cnt <= 0) {
2237 /* buffer is full, start the dma machine and wait for data to be
2238 played */
2239 start_dac(state);
2240 if (file->f_flags & O_NONBLOCK) {
2241 if (!ret) ret = -EAGAIN;
2242 goto out;
2243 }
2244 mutex_unlock(&state->sem);
2245 schedule();
2246 if (signal_pending(current)) {
2247 if(!ret) ret = -ERESTARTSYS;
2248 goto out;
2249 }
2250 mutex_lock(&state->sem);
2251 if (dmabuf->mapped)
2252 {
2253 if(!ret)
2254 ret = -ENXIO;
2255 goto out;
2256 }
2257 continue;
2258 }
2259 if (copy_from_user(dmabuf->rawbuf + swptr, buffer, cnt)) {
2260 if (!ret) ret = -EFAULT;
2261 goto out;
2262 }
2263 spin_lock_irqsave(&state->card->lock, flags);
2264 swptr = (swptr + cnt) % dmabuf->dmasize;
2265 dmabuf->swptr = swptr;
2266 dmabuf->count += cnt;
2267 if(dmabuf->count > dmabuf->dmasize)
2268 {
2269 CS_DBGOUT(CS_WAVE_WRITE | CS_ERROR, 2, printk(
2270 "cs46xx: cs_write() d->count > dmasize - resetting\n"));
2271 dmabuf->count = dmabuf->dmasize;
2272 }
2273 dmabuf->endcleared = 0;
2274 spin_unlock_irqrestore(&state->card->lock, flags);
2275
2276 count -= cnt;
2277 buffer += cnt;
2278 ret += cnt;
2279 start_dac(state);
2280 }
2281 out:
2282 mutex_unlock(&state->sem);
2283 remove_wait_queue(&state->dmabuf.wait, &wait);
2284 set_current_state(TASK_RUNNING);
2285
2286 CS_DBGOUT(CS_WAVE_WRITE | CS_FUNCTION, 2,
2287 printk("cs46xx: cs_write()- ret=%zd\n", ret) );
2288 return ret;
2289 }
2290
2291 static unsigned int cs_poll(struct file *file, struct poll_table_struct *wait)
2292 {
2293 struct cs_card *card = (struct cs_card *)file->private_data;
2294 struct dmabuf *dmabuf;
2295 struct cs_state *state;
2296
2297 unsigned long flags;
2298 unsigned int mask = 0;
2299
2300 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_poll()+ \n"));
2301 if (!(file->f_mode & (FMODE_WRITE | FMODE_READ)))
2302 {
2303 return -EINVAL;
2304 }
2305 if (file->f_mode & FMODE_WRITE)
2306 {
2307 state = card->states[1];
2308 if(state)
2309 {
2310 dmabuf = &state->dmabuf;
2311 poll_wait(file, &dmabuf->wait, wait);
2312 }
2313 }
2314 if (file->f_mode & FMODE_READ)
2315 {
2316 state = card->states[0];
2317 if(state)
2318 {
2319 dmabuf = &state->dmabuf;
2320 poll_wait(file, &dmabuf->wait, wait);
2321 }
2322 }
2323
2324 spin_lock_irqsave(&card->lock, flags);
2325 cs_update_ptr(card, CS_FALSE);
2326 if (file->f_mode & FMODE_READ) {
2327 state = card->states[0];
2328 if(state)
2329 {
2330 dmabuf = &state->dmabuf;
2331 if (dmabuf->count >= (signed)dmabuf->fragsize)
2332 mask |= POLLIN | POLLRDNORM;
2333 }
2334 }
2335 if (file->f_mode & FMODE_WRITE) {
2336 state = card->states[1];
2337 if(state)
2338 {
2339 dmabuf = &state->dmabuf;
2340 if (dmabuf->mapped) {
2341 if (dmabuf->count >= (signed)dmabuf->fragsize)
2342 mask |= POLLOUT | POLLWRNORM;
2343 } else {
2344 if ((signed)dmabuf->dmasize >= dmabuf->count
2345 + (signed)dmabuf->fragsize)
2346 mask |= POLLOUT | POLLWRNORM;
2347 }
2348 }
2349 }
2350 spin_unlock_irqrestore(&card->lock, flags);
2351
2352 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_poll()- (0x%x) \n",
2353 mask));
2354 return mask;
2355 }
2356
2357 /*
2358 * We let users mmap the ring buffer. Its not the real DMA buffer but
2359 * that side of the code is hidden in the IRQ handling. We do a software
2360 * emulation of DMA from a 64K or so buffer into a 2K FIFO.
2361 * (the hardware probably deserves a moan here but Crystal send me nice
2362 * toys ;)).
2363 */
2364
2365 static int cs_mmap(struct file *file, struct vm_area_struct *vma)
2366 {
2367 struct cs_card *card = (struct cs_card *)file->private_data;
2368 struct cs_state *state;
2369 struct dmabuf *dmabuf;
2370 int ret = 0;
2371 unsigned long size;
2372
2373 CS_DBGOUT(CS_FUNCTION | CS_PARMS, 2, printk("cs46xx: cs_mmap()+ file=%p %s %s\n",
2374 file, vma->vm_flags & VM_WRITE ? "VM_WRITE" : "",
2375 vma->vm_flags & VM_READ ? "VM_READ" : "") );
2376
2377 if (vma->vm_flags & VM_WRITE) {
2378 state = card->states[1];
2379 if(state)
2380 {
2381 CS_DBGOUT(CS_OPEN, 2, printk(
2382 "cs46xx: cs_mmap() VM_WRITE - state TRUE prog_dmabuf DAC\n") );
2383 if ((ret = prog_dmabuf(state)) != 0)
2384 return ret;
2385 }
2386 } else if (vma->vm_flags & VM_READ) {
2387 state = card->states[0];
2388 if(state)
2389 {
2390 CS_DBGOUT(CS_OPEN, 2, printk(
2391 "cs46xx: cs_mmap() VM_READ - state TRUE prog_dmabuf ADC\n") );
2392 if ((ret = prog_dmabuf(state)) != 0)
2393 return ret;
2394 }
2395 } else {
2396 CS_DBGOUT(CS_ERROR, 2, printk(
2397 "cs46xx: cs_mmap() return -EINVAL\n") );
2398 return -EINVAL;
2399 }
2400
2401 /*
2402 * For now ONLY support playback, but seems like the only way to use
2403 * mmap() is to open an FD with RDWR, just read or just write access
2404 * does not function, get an error back from the kernel.
2405 * Also, QuakeIII opens with RDWR! So, there must be something
2406 * to needing read/write access mapping. So, allow read/write but
2407 * use the DAC only.
2408 */
2409 state = card->states[1];
2410 if (!state) {
2411 ret = -EINVAL;
2412 goto out;
2413 }
2414
2415 mutex_lock(&state->sem);
2416 dmabuf = &state->dmabuf;
2417 if (cs4x_pgoff(vma) != 0)
2418 {
2419 ret = -EINVAL;
2420 goto out;
2421 }
2422 size = vma->vm_end - vma->vm_start;
2423
2424 CS_DBGOUT(CS_PARMS, 2, printk("cs46xx: cs_mmap(): size=%d\n",(unsigned)size) );
2425
2426 if (size > (PAGE_SIZE << dmabuf->buforder))
2427 {
2428 ret = -EINVAL;
2429 goto out;
2430 }
2431 if (remap_pfn_range(vma, vma->vm_start,
2432 virt_to_phys(dmabuf->rawbuf) >> PAGE_SHIFT,
2433 size, vma->vm_page_prot))
2434 {
2435 ret = -EAGAIN;
2436 goto out;
2437 }
2438 dmabuf->mapped = 1;
2439
2440 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_mmap()-\n") );
2441 out:
2442 mutex_unlock(&state->sem);
2443 return ret;
2444 }
2445
2446 static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
2447 {
2448 struct cs_card *card = (struct cs_card *)file->private_data;
2449 struct cs_state *state;
2450 struct dmabuf *dmabuf=NULL;
2451 unsigned long flags;
2452 audio_buf_info abinfo;
2453 count_info cinfo;
2454 int val, valsave, mapped, ret;
2455 void __user *argp = (void __user *)arg;
2456 int __user *p = argp;
2457
2458 state = (struct cs_state *)card->states[0];
2459 if(state)
2460 {
2461 dmabuf = &state->dmabuf;
2462 mapped = (file->f_mode & FMODE_READ) && dmabuf->mapped;
2463 }
2464 state = (struct cs_state *)card->states[1];
2465 if(state)
2466 {
2467 dmabuf = &state->dmabuf;
2468 mapped |= (file->f_mode & FMODE_WRITE) && dmabuf->mapped;
2469 }
2470
2471 #if CSDEBUG
2472 printioctl(cmd);
2473 #endif
2474
2475 switch (cmd)
2476 {
2477 case OSS_GETVERSION:
2478 return put_user(SOUND_VERSION, p);
2479
2480 case SNDCTL_DSP_RESET:
2481 /* FIXME: spin_lock ? */
2482 if (file->f_mode & FMODE_WRITE) {
2483 state = (struct cs_state *)card->states[1];
2484 if(state)
2485 {
2486 dmabuf = &state->dmabuf;
2487 stop_dac(state);
2488 synchronize_irq(card->irq);
2489 dmabuf->ready = 0;
2490 resync_dma_ptrs(state);
2491 dmabuf->swptr = dmabuf->hwptr = 0;
2492 dmabuf->count = dmabuf->total_bytes = 0;
2493 dmabuf->blocks = 0;
2494 dmabuf->SGok = 0;
2495 }
2496 }
2497 if (file->f_mode & FMODE_READ) {
2498 state = (struct cs_state *)card->states[0];
2499 if(state)
2500 {
2501 dmabuf = &state->dmabuf;
2502 stop_adc(state);
2503 synchronize_irq(card->irq);
2504 resync_dma_ptrs(state);
2505 dmabuf->ready = 0;
2506 dmabuf->swptr = dmabuf->hwptr = 0;
2507 dmabuf->count = dmabuf->total_bytes = 0;
2508 dmabuf->blocks = 0;
2509 dmabuf->SGok = 0;
2510 }
2511 }
2512 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_RESET()-\n") );
2513 return 0;
2514
2515 case SNDCTL_DSP_SYNC:
2516 if (file->f_mode & FMODE_WRITE)
2517 return drain_dac(state, file->f_flags & O_NONBLOCK);
2518 return 0;
2519
2520 case SNDCTL_DSP_SPEED: /* set sample rate */
2521 if (get_user(val, p))
2522 return -EFAULT;
2523 if (val >= 0) {
2524 if (file->f_mode & FMODE_READ) {
2525 state = (struct cs_state *)card->states[0];
2526 if(state)
2527 {
2528 dmabuf = &state->dmabuf;
2529 stop_adc(state);
2530 dmabuf->ready = 0;
2531 dmabuf->SGok = 0;
2532 cs_set_adc_rate(state, val);
2533 cs_set_divisor(dmabuf);
2534 }
2535 }
2536 if (file->f_mode & FMODE_WRITE) {
2537 state = (struct cs_state *)card->states[1];
2538 if(state)
2539 {
2540 dmabuf = &state->dmabuf;
2541 stop_dac(state);
2542 dmabuf->ready = 0;
2543 dmabuf->SGok = 0;
2544 cs_set_dac_rate(state, val);
2545 cs_set_divisor(dmabuf);
2546 }
2547 }
2548 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2549 "cs46xx: cs_ioctl() DSP_SPEED %s %s %d\n",
2550 file->f_mode & FMODE_WRITE ? "DAC" : "",
2551 file->f_mode & FMODE_READ ? "ADC" : "",
2552 dmabuf->rate ) );
2553 return put_user(dmabuf->rate, p);
2554 }
2555 return put_user(0, p);
2556
2557 case SNDCTL_DSP_STEREO: /* set stereo or mono channel */
2558 if (get_user(val, p))
2559 return -EFAULT;
2560 if (file->f_mode & FMODE_WRITE) {
2561 state = (struct cs_state *)card->states[1];
2562 if(state)
2563 {
2564 dmabuf = &state->dmabuf;
2565 stop_dac(state);
2566 dmabuf->ready = 0;
2567 dmabuf->SGok = 0;
2568 if(val)
2569 dmabuf->fmt |= CS_FMT_STEREO;
2570 else
2571 dmabuf->fmt &= ~CS_FMT_STEREO;
2572 cs_set_divisor(dmabuf);
2573 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2574 "cs46xx: DSP_STEREO() DAC %s\n",
2575 (dmabuf->fmt & CS_FMT_STEREO) ?
2576 "STEREO":"MONO") );
2577 }
2578 }
2579 if (file->f_mode & FMODE_READ) {
2580 state = (struct cs_state *)card->states[0];
2581 if(state)
2582 {
2583 dmabuf = &state->dmabuf;
2584 stop_adc(state);
2585 dmabuf->ready = 0;
2586 dmabuf->SGok = 0;
2587 if(val)
2588 dmabuf->fmt |= CS_FMT_STEREO;
2589 else
2590 dmabuf->fmt &= ~CS_FMT_STEREO;
2591 cs_set_divisor(dmabuf);
2592 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2593 "cs46xx: DSP_STEREO() ADC %s\n",
2594 (dmabuf->fmt & CS_FMT_STEREO) ?
2595 "STEREO":"MONO") );
2596 }
2597 }
2598 return 0;
2599
2600 case SNDCTL_DSP_GETBLKSIZE:
2601 if (file->f_mode & FMODE_WRITE) {
2602 state = (struct cs_state *)card->states[1];
2603 if(state)
2604 {
2605 dmabuf = &state->dmabuf;
2606 if ((val = prog_dmabuf(state)))
2607 return val;
2608 return put_user(dmabuf->fragsize, p);
2609 }
2610 }
2611 if (file->f_mode & FMODE_READ) {
2612 state = (struct cs_state *)card->states[0];
2613 if(state)
2614 {
2615 dmabuf = &state->dmabuf;
2616 if ((val = prog_dmabuf(state)))
2617 return val;
2618 return put_user(dmabuf->fragsize/dmabuf->divisor,
2619 p);
2620 }
2621 }
2622 return put_user(0, p);
2623
2624 case SNDCTL_DSP_GETFMTS: /* Returns a mask of supported sample format*/
2625 return put_user(AFMT_S16_LE | AFMT_U8, p);
2626
2627 case SNDCTL_DSP_SETFMT: /* Select sample format */
2628 if (get_user(val, p))
2629 return -EFAULT;
2630 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2631 "cs46xx: cs_ioctl() DSP_SETFMT %s %s %s %s\n",
2632 file->f_mode & FMODE_WRITE ? "DAC" : "",
2633 file->f_mode & FMODE_READ ? "ADC" : "",
2634 val == AFMT_S16_LE ? "16Bit Signed" : "",
2635 val == AFMT_U8 ? "8Bit Unsigned" : "") );
2636 valsave = val;
2637 if (val != AFMT_QUERY) {
2638 if(val==AFMT_S16_LE || val==AFMT_U8)
2639 {
2640 if (file->f_mode & FMODE_WRITE) {
2641 state = (struct cs_state *)card->states[1];
2642 if(state)
2643 {
2644 dmabuf = &state->dmabuf;
2645 stop_dac(state);
2646 dmabuf->ready = 0;
2647 dmabuf->SGok = 0;
2648 if(val==AFMT_S16_LE)
2649 dmabuf->fmt |= CS_FMT_16BIT;
2650 else
2651 dmabuf->fmt &= ~CS_FMT_16BIT;
2652 cs_set_divisor(dmabuf);
2653 if((ret = prog_dmabuf(state)))
2654 return ret;
2655 }
2656 }
2657 if (file->f_mode & FMODE_READ) {
2658 val = valsave;
2659 state = (struct cs_state *)card->states[0];
2660 if(state)
2661 {
2662 dmabuf = &state->dmabuf;
2663 stop_adc(state);
2664 dmabuf->ready = 0;
2665 dmabuf->SGok = 0;
2666 if(val==AFMT_S16_LE)
2667 dmabuf->fmt |= CS_FMT_16BIT;
2668 else
2669 dmabuf->fmt &= ~CS_FMT_16BIT;
2670 cs_set_divisor(dmabuf);
2671 if((ret = prog_dmabuf(state)))
2672 return ret;
2673 }
2674 }
2675 }
2676 else
2677 {
2678 CS_DBGOUT(CS_IOCTL | CS_ERROR, 2, printk(
2679 "cs46xx: DSP_SETFMT() Unsupported format (0x%x)\n",
2680 valsave) );
2681 }
2682 }
2683 else
2684 {
2685 if(file->f_mode & FMODE_WRITE)
2686 {
2687 state = (struct cs_state *)card->states[1];
2688 if(state)
2689 dmabuf = &state->dmabuf;
2690 }
2691 else if(file->f_mode & FMODE_READ)
2692 {
2693 state = (struct cs_state *)card->states[0];
2694 if(state)
2695 dmabuf = &state->dmabuf;
2696 }
2697 }
2698 if(dmabuf)
2699 {
2700 if(dmabuf->fmt & CS_FMT_16BIT)
2701 return put_user(AFMT_S16_LE, p);
2702 else
2703 return put_user(AFMT_U8, p);
2704 }
2705 return put_user(0, p);
2706
2707 case SNDCTL_DSP_CHANNELS:
2708 if (get_user(val, p))
2709 return -EFAULT;
2710 if (val != 0) {
2711 if (file->f_mode & FMODE_WRITE) {
2712 state = (struct cs_state *)card->states[1];
2713 if(state)
2714 {
2715 dmabuf = &state->dmabuf;
2716 stop_dac(state);
2717 dmabuf->ready = 0;
2718 dmabuf->SGok = 0;
2719 if(val>1)
2720 dmabuf->fmt |= CS_FMT_STEREO;
2721 else
2722 dmabuf->fmt &= ~CS_FMT_STEREO;
2723 cs_set_divisor(dmabuf);
2724 if (prog_dmabuf(state))
2725 return 0;
2726 }
2727 }
2728 if (file->f_mode & FMODE_READ) {
2729 state = (struct cs_state *)card->states[0];
2730 if(state)
2731 {
2732 dmabuf = &state->dmabuf;
2733 stop_adc(state);
2734 dmabuf->ready = 0;
2735 dmabuf->SGok = 0;
2736 if(val>1)
2737 dmabuf->fmt |= CS_FMT_STEREO;
2738 else
2739 dmabuf->fmt &= ~CS_FMT_STEREO;
2740 cs_set_divisor(dmabuf);
2741 if (prog_dmabuf(state))
2742 return 0;
2743 }
2744 }
2745 }
2746 return put_user((dmabuf->fmt & CS_FMT_STEREO) ? 2 : 1,
2747 p);
2748
2749 case SNDCTL_DSP_POST:
2750 /*
2751 * There will be a longer than normal pause in the data.
2752 * so... do nothing, because there is nothing that we can do.
2753 */
2754 return 0;
2755
2756 case SNDCTL_DSP_SUBDIVIDE:
2757 if (file->f_mode & FMODE_WRITE) {
2758 state = (struct cs_state *)card->states[1];
2759 if(state)
2760 {
2761 dmabuf = &state->dmabuf;
2762 if (dmabuf->subdivision)
2763 return -EINVAL;
2764 if (get_user(val, p))
2765 return -EFAULT;
2766 if (val != 1 && val != 2)
2767 return -EINVAL;
2768 dmabuf->subdivision = val;
2769 }
2770 }
2771 if (file->f_mode & FMODE_READ) {
2772 state = (struct cs_state *)card->states[0];
2773 if(state)
2774 {
2775 dmabuf = &state->dmabuf;
2776 if (dmabuf->subdivision)
2777 return -EINVAL;
2778 if (get_user(val, p))
2779 return -EFAULT;
2780 if (val != 1 && val != 2)
2781 return -EINVAL;
2782 dmabuf->subdivision = val;
2783 }
2784 }
2785 return 0;
2786
2787 case SNDCTL_DSP_SETFRAGMENT:
2788 if (get_user(val, p))
2789 return -EFAULT;
2790
2791 if (file->f_mode & FMODE_WRITE) {
2792 state = (struct cs_state *)card->states[1];
2793 if(state)
2794 {
2795 dmabuf = &state->dmabuf;
2796 dmabuf->ossfragshift = val & 0xffff;
2797 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2798 }
2799 }
2800 if (file->f_mode & FMODE_READ) {
2801 state = (struct cs_state *)card->states[0];
2802 if(state)
2803 {
2804 dmabuf = &state->dmabuf;
2805 dmabuf->ossfragshift = val & 0xffff;
2806 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2807 }
2808 }
2809 return 0;
2810
2811 case SNDCTL_DSP_GETOSPACE:
2812 if (!(file->f_mode & FMODE_WRITE))
2813 return -EINVAL;
2814 state = (struct cs_state *)card->states[1];
2815 if(state)
2816 {
2817 dmabuf = &state->dmabuf;
2818 spin_lock_irqsave(&state->card->lock, flags);
2819 cs_update_ptr(card, CS_TRUE);
2820 abinfo.fragsize = dmabuf->fragsize;
2821 abinfo.fragstotal = dmabuf->numfrag;
2822 /*
2823 * for mmap we always have total space available
2824 */
2825 if (dmabuf->mapped)
2826 abinfo.bytes = dmabuf->dmasize;
2827 else
2828 abinfo.bytes = dmabuf->dmasize - dmabuf->count;
2829
2830 abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
2831 spin_unlock_irqrestore(&state->card->lock, flags);
2832 return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2833 }
2834 return -ENODEV;
2835
2836 case SNDCTL_DSP_GETISPACE:
2837 if (!(file->f_mode & FMODE_READ))
2838 return -EINVAL;
2839 state = (struct cs_state *)card->states[0];
2840 if(state)
2841 {
2842 dmabuf = &state->dmabuf;
2843 spin_lock_irqsave(&state->card->lock, flags);
2844 cs_update_ptr(card, CS_TRUE);
2845 abinfo.fragsize = dmabuf->fragsize/dmabuf->divisor;
2846 abinfo.bytes = dmabuf->count/dmabuf->divisor;
2847 abinfo.fragstotal = dmabuf->numfrag;
2848 abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
2849 spin_unlock_irqrestore(&state->card->lock, flags);
2850 return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2851 }
2852 return -ENODEV;
2853
2854 case SNDCTL_DSP_NONBLOCK:
2855 file->f_flags |= O_NONBLOCK;
2856 return 0;
2857
2858 case SNDCTL_DSP_GETCAPS:
2859 return put_user(DSP_CAP_REALTIME|DSP_CAP_TRIGGER|DSP_CAP_MMAP,
2860 p);
2861
2862 case SNDCTL_DSP_GETTRIGGER:
2863 val = 0;
2864 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_GETTRIGGER()+\n") );
2865 if (file->f_mode & FMODE_WRITE)
2866 {
2867 state = (struct cs_state *)card->states[1];
2868 if(state)
2869 {
2870 dmabuf = &state->dmabuf;
2871 if(dmabuf->enable & DAC_RUNNING)
2872 val |= PCM_ENABLE_INPUT;
2873 }
2874 }
2875 if (file->f_mode & FMODE_READ)
2876 {
2877 if(state)
2878 {
2879 state = (struct cs_state *)card->states[0];
2880 dmabuf = &state->dmabuf;
2881 if(dmabuf->enable & ADC_RUNNING)
2882 val |= PCM_ENABLE_OUTPUT;
2883 }
2884 }
2885 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_GETTRIGGER()- val=0x%x\n",val) );
2886 return put_user(val, p);
2887
2888 case SNDCTL_DSP_SETTRIGGER:
2889 if (get_user(val, p))
2890 return -EFAULT;
2891 if (file->f_mode & FMODE_READ) {
2892 state = (struct cs_state *)card->states[0];
2893 if(state)
2894 {
2895 dmabuf = &state->dmabuf;
2896 if (val & PCM_ENABLE_INPUT) {
2897 if (!dmabuf->ready && (ret = prog_dmabuf(state)))
2898 return ret;
2899 start_adc(state);
2900 } else
2901 stop_adc(state);
2902 }
2903 }
2904 if (file->f_mode & FMODE_WRITE) {
2905 state = (struct cs_state *)card->states[1];
2906 if(state)
2907 {
2908 dmabuf = &state->dmabuf;
2909 if (val & PCM_ENABLE_OUTPUT) {
2910 if (!dmabuf->ready && (ret = prog_dmabuf(state)))
2911 return ret;
2912 start_dac(state);
2913 } else
2914 stop_dac(state);
2915 }
2916 }
2917 return 0;
2918
2919 case SNDCTL_DSP_GETIPTR:
2920 if (!(file->f_mode & FMODE_READ))
2921 return -EINVAL;
2922 state = (struct cs_state *)card->states[0];
2923 if(state)
2924 {
2925 dmabuf = &state->dmabuf;
2926 spin_lock_irqsave(&state->card->lock, flags);
2927 cs_update_ptr(card, CS_TRUE);
2928 cinfo.bytes = dmabuf->total_bytes/dmabuf->divisor;
2929 cinfo.blocks = dmabuf->count/dmabuf->divisor >> dmabuf->fragshift;
2930 cinfo.ptr = dmabuf->hwptr/dmabuf->divisor;
2931 spin_unlock_irqrestore(&state->card->lock, flags);
2932 if (copy_to_user(argp, &cinfo, sizeof(cinfo)))
2933 return -EFAULT;
2934 return 0;
2935 }
2936 return -ENODEV;
2937
2938 case SNDCTL_DSP_GETOPTR:
2939 if (!(file->f_mode & FMODE_WRITE))
2940 return -EINVAL;
2941 state = (struct cs_state *)card->states[1];
2942 if(state)
2943 {
2944 dmabuf = &state->dmabuf;
2945 spin_lock_irqsave(&state->card->lock, flags);
2946 cs_update_ptr(card, CS_TRUE);
2947 cinfo.bytes = dmabuf->total_bytes;
2948 if (dmabuf->mapped)
2949 {
2950 cinfo.blocks = (cinfo.bytes >> dmabuf->fragshift)
2951 - dmabuf->blocks;
2952 CS_DBGOUT(CS_PARMS, 8,
2953 printk("total_bytes=%d blocks=%d dmabuf->blocks=%d\n",
2954 cinfo.bytes,cinfo.blocks,dmabuf->blocks) );
2955 dmabuf->blocks = cinfo.bytes >> dmabuf->fragshift;
2956 }
2957 else
2958 {
2959 cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
2960 }
2961 cinfo.ptr = dmabuf->hwptr;
2962
2963 CS_DBGOUT(CS_PARMS, 4, printk(
2964 "cs46xx: GETOPTR bytes=%d blocks=%d ptr=%d\n",
2965 cinfo.bytes,cinfo.blocks,cinfo.ptr) );
2966 spin_unlock_irqrestore(&state->card->lock, flags);
2967 if (copy_to_user(argp, &cinfo, sizeof(cinfo)))
2968 return -EFAULT;
2969 return 0;
2970 }
2971 return -ENODEV;
2972
2973 case SNDCTL_DSP_SETDUPLEX:
2974 return 0;
2975
2976 case SNDCTL_DSP_GETODELAY:
2977 if (!(file->f_mode & FMODE_WRITE))
2978 return -EINVAL;
2979 state = (struct cs_state *)card->states[1];
2980 if(state)
2981 {
2982 dmabuf = &state->dmabuf;
2983 spin_lock_irqsave(&state->card->lock, flags);
2984 cs_update_ptr(card, CS_TRUE);
2985 val = dmabuf->count;
2986 spin_unlock_irqrestore(&state->card->lock, flags);
2987 }
2988 else
2989 val = 0;
2990 return put_user(val, p);
2991
2992 case SOUND_PCM_READ_RATE:
2993 if(file->f_mode & FMODE_READ)
2994 state = (struct cs_state *)card->states[0];
2995 else
2996 state = (struct cs_state *)card->states[1];
2997 if(state)
2998 {
2999 dmabuf = &state->dmabuf;
3000 return put_user(dmabuf->rate, p);
3001 }
3002 return put_user(0, p);
3003
3004
3005 case SOUND_PCM_READ_CHANNELS:
3006 if(file->f_mode & FMODE_READ)
3007 state = (struct cs_state *)card->states[0];
3008 else
3009 state = (struct cs_state *)card->states[1];
3010 if(state)
3011 {
3012 dmabuf = &state->dmabuf;
3013 return put_user((dmabuf->fmt & CS_FMT_STEREO) ? 2 : 1,
3014 p);
3015 }
3016 return put_user(0, p);
3017
3018 case SOUND_PCM_READ_BITS:
3019 if(file->f_mode & FMODE_READ)
3020 state = (struct cs_state *)card->states[0];
3021 else
3022 state = (struct cs_state *)card->states[1];
3023 if(state)
3024 {
3025 dmabuf = &state->dmabuf;
3026 return put_user((dmabuf->fmt & CS_FMT_16BIT) ?
3027 AFMT_S16_LE : AFMT_U8, p);
3028
3029 }
3030 return put_user(0, p);
3031
3032 case SNDCTL_DSP_MAPINBUF:
3033 case SNDCTL_DSP_MAPOUTBUF:
3034 case SNDCTL_DSP_SETSYNCRO:
3035 case SOUND_PCM_WRITE_FILTER:
3036 case SOUND_PCM_READ_FILTER:
3037 return -EINVAL;
3038 }
3039 return -EINVAL;
3040 }
3041
3042
3043 /*
3044 * AMP control - null AMP
3045 */
3046
3047 static void amp_none(struct cs_card *card, int change)
3048 {
3049 }
3050
3051 /*
3052 * Crystal EAPD mode
3053 */
3054
3055 static void amp_voyetra(struct cs_card *card, int change)
3056 {
3057 /* Manage the EAPD bit on the Crystal 4297
3058 and the Analog AD1885 */
3059
3060 int old=card->amplifier;
3061
3062 card->amplifier+=change;
3063 if(card->amplifier && !old)
3064 {
3065 /* Turn the EAPD amp on */
3066 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL,
3067 cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) |
3068 0x8000);
3069 }
3070 else if(old && !card->amplifier)
3071 {
3072 /* Turn the EAPD amp off */
3073 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL,
3074 cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
3075 ~0x8000);
3076 }
3077 }
3078
3079
3080 /*
3081 * Game Theatre XP card - EGPIO[2] is used to enable the external amp.
3082 */
3083
3084 static void amp_hercules(struct cs_card *card, int change)
3085 {
3086 int old=card->amplifier;
3087 if(!card)
3088 {
3089 CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
3090 "cs46xx: amp_hercules() called before initialized.\n"));
3091 return;
3092 }
3093 card->amplifier+=change;
3094 if( (card->amplifier && !old) && !(hercules_egpio_disable))
3095 {
3096 CS_DBGOUT(CS_PARMS, 4, printk(KERN_INFO
3097 "cs46xx: amp_hercules() external amp enabled\n"));
3098 cs461x_pokeBA0(card, BA0_EGPIODR,
3099 EGPIODR_GPOE2); /* enable EGPIO2 output */
3100 cs461x_pokeBA0(card, BA0_EGPIOPTR,
3101 EGPIOPTR_GPPT2); /* open-drain on output */
3102 }
3103 else if(old && !card->amplifier)
3104 {
3105 CS_DBGOUT(CS_PARMS, 4, printk(KERN_INFO
3106 "cs46xx: amp_hercules() external amp disabled\n"));
3107 cs461x_pokeBA0(card, BA0_EGPIODR, 0); /* disable */
3108 cs461x_pokeBA0(card, BA0_EGPIOPTR, 0); /* disable */
3109 }
3110 }
3111
3112 /*
3113 * Handle the CLKRUN on a thinkpad. We must disable CLKRUN support
3114 * whenever we need to beat on the chip.
3115 *
3116 * The original idea and code for this hack comes from David Kaiser at
3117 * Linuxcare. Perhaps one day Crystal will document their chips well
3118 * enough to make them useful.
3119 */
3120
3121 static void clkrun_hack(struct cs_card *card, int change)
3122 {
3123 struct pci_dev *acpi_dev;
3124 u16 control;
3125 u8 pp;
3126 unsigned long port;
3127 int old=card->active;
3128
3129 card->active+=change;
3130
3131 acpi_dev = pci_find_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371AB_3, NULL);
3132 if(acpi_dev == NULL)
3133 return; /* Not a thinkpad thats for sure */
3134
3135 /* Find the control port */
3136 pci_read_config_byte(acpi_dev, 0x41, &pp);
3137 port=pp<<8;
3138
3139 /* Read ACPI port */
3140 control=inw(port+0x10);
3141
3142 /* Flip CLKRUN off while running */
3143 if(!card->active && old)
3144 {
3145 CS_DBGOUT(CS_PARMS , 9, printk( KERN_INFO
3146 "cs46xx: clkrun() enable clkrun - change=%d active=%d\n",
3147 change,card->active));
3148 outw(control|0x2000, port+0x10);
3149 }
3150 else
3151 {
3152 /*
3153 * sometimes on a resume the bit is set, so always reset the bit.
3154 */
3155 CS_DBGOUT(CS_PARMS , 9, printk( KERN_INFO
3156 "cs46xx: clkrun() disable clkrun - change=%d active=%d\n",
3157 change,card->active));
3158 outw(control&~0x2000, port+0x10);
3159 }
3160 }
3161
3162
3163 static int cs_open(struct inode *inode, struct file *file)
3164 {
3165 struct cs_card *card = (struct cs_card *)file->private_data;
3166 struct cs_state *state = NULL;
3167 struct dmabuf *dmabuf = NULL;
3168 struct list_head *entry;
3169 unsigned int minor = iminor(inode);
3170 int ret=0;
3171 unsigned int tmp;
3172
3173 CS_DBGOUT(CS_OPEN | CS_FUNCTION, 2, printk("cs46xx: cs_open()+ file=%p %s %s\n",
3174 file, file->f_mode & FMODE_WRITE ? "FMODE_WRITE" : "",
3175 file->f_mode & FMODE_READ ? "FMODE_READ" : "") );
3176
3177 list_for_each(entry, &cs46xx_devs)
3178 {
3179 card = list_entry(entry, struct cs_card, list);
3180
3181 if (!((card->dev_audio ^ minor) & ~0xf))
3182 break;
3183 }
3184 if (entry == &cs46xx_devs)
3185 return -ENODEV;
3186 if (!card) {
3187 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 2, printk(KERN_INFO
3188 "cs46xx: cs_open(): Error - unable to find audio card struct\n"));
3189 return -ENODEV;
3190 }
3191
3192 /*
3193 * hardcode state[0] for capture, [1] for playback
3194 */
3195 if(file->f_mode & FMODE_READ)
3196 {
3197 CS_DBGOUT(CS_WAVE_READ, 2, printk("cs46xx: cs_open() FMODE_READ\n") );
3198 if (card->states[0] == NULL) {
3199 state = card->states[0] = (struct cs_state *)
3200 kmalloc(sizeof(struct cs_state), GFP_KERNEL);
3201 if (state == NULL)
3202 return -ENOMEM;
3203 memset(state, 0, sizeof(struct cs_state));
3204 mutex_init(&state->sem);
3205 dmabuf = &state->dmabuf;
3206 dmabuf->pbuf = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
3207 if(dmabuf->pbuf==NULL)
3208 {
3209 kfree(state);
3210 card->states[0]=NULL;
3211 return -ENOMEM;
3212 }
3213 }
3214 else
3215 {
3216 state = card->states[0];
3217 if(state->open_mode & FMODE_READ)
3218 return -EBUSY;
3219 }
3220 dmabuf->channel = card->alloc_rec_pcm_channel(card);
3221
3222 if (dmabuf->channel == NULL) {
3223 kfree (card->states[0]);
3224 card->states[0] = NULL;
3225 return -ENODEV;
3226 }
3227
3228 /* Now turn on external AMP if needed */
3229 state->card = card;
3230 state->card->active_ctrl(state->card,1);
3231 state->card->amplifier_ctrl(state->card,1);
3232
3233 if( (tmp = cs46xx_powerup(card, CS_POWER_ADC)) )
3234 {
3235 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3236 "cs46xx: cs46xx_powerup of ADC failed (0x%x)\n",tmp) );
3237 return -EIO;
3238 }
3239
3240 dmabuf->channel->state = state;
3241 /* initialize the virtual channel */
3242 state->virt = 0;
3243 state->magic = CS_STATE_MAGIC;
3244 init_waitqueue_head(&dmabuf->wait);
3245 mutex_init(&state->open_mutex);
3246 file->private_data = card;
3247
3248 mutex_lock(&state->open_mutex);
3249
3250 /* set default sample format. According to OSS Programmer's Guide /dev/dsp
3251 should be default to unsigned 8-bits, mono, with sample rate 8kHz and
3252 /dev/dspW will accept 16-bits sample */
3253
3254 /* Default input is 8bit mono */
3255 dmabuf->fmt &= ~CS_FMT_MASK;
3256 dmabuf->type = CS_TYPE_ADC;
3257 dmabuf->ossfragshift = 0;
3258 dmabuf->ossmaxfrags = 0;
3259 dmabuf->subdivision = 0;
3260 cs_set_adc_rate(state, 8000);
3261 cs_set_divisor(dmabuf);
3262
3263 state->open_mode |= FMODE_READ;
3264 mutex_unlock(&state->open_mutex);
3265 }
3266 if(file->f_mode & FMODE_WRITE)
3267 {
3268 CS_DBGOUT(CS_OPEN, 2, printk("cs46xx: cs_open() FMODE_WRITE\n") );
3269 if (card->states[1] == NULL) {
3270 state = card->states[1] = (struct cs_state *)
3271 kmalloc(sizeof(struct cs_state), GFP_KERNEL);
3272 if (state == NULL)
3273 return -ENOMEM;
3274 memset(state, 0, sizeof(struct cs_state));
3275 mutex_init(&state->sem);
3276 dmabuf = &state->dmabuf;
3277 dmabuf->pbuf = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
3278 if(dmabuf->pbuf==NULL)
3279 {
3280 kfree(state);
3281 card->states[1]=NULL;
3282 return -ENOMEM;
3283 }
3284 }
3285 else
3286 {
3287 state = card->states[1];
3288 if(state->open_mode & FMODE_WRITE)
3289 return -EBUSY;
3290 }
3291 dmabuf->channel = card->alloc_pcm_channel(card);
3292
3293 if (dmabuf->channel == NULL) {
3294 kfree (card->states[1]);
3295 card->states[1] = NULL;
3296 return -ENODEV;
3297 }
3298
3299 /* Now turn on external AMP if needed */
3300 state->card = card;
3301 state->card->active_ctrl(state->card,1);
3302 state->card->amplifier_ctrl(state->card,1);
3303
3304 if( (tmp = cs46xx_powerup(card, CS_POWER_DAC)) )
3305 {
3306 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3307 "cs46xx: cs46xx_powerup of DAC failed (0x%x)\n",tmp) );
3308 return -EIO;
3309 }
3310
3311 dmabuf->channel->state = state;
3312 /* initialize the virtual channel */
3313 state->virt = 1;
3314 state->magic = CS_STATE_MAGIC;
3315 init_waitqueue_head(&dmabuf->wait);
3316 mutex_init(&state->open_mutex);
3317 file->private_data = card;
3318
3319 mutex_lock(&state->open_mutex);
3320
3321 /* set default sample format. According to OSS Programmer's Guide /dev/dsp
3322 should be default to unsigned 8-bits, mono, with sample rate 8kHz and
3323 /dev/dspW will accept 16-bits sample */
3324
3325 /* Default output is 8bit mono. */
3326 dmabuf->fmt &= ~CS_FMT_MASK;
3327 dmabuf->type = CS_TYPE_DAC;
3328 dmabuf->ossfragshift = 0;
3329 dmabuf->ossmaxfrags = 0;
3330 dmabuf->subdivision = 0;
3331 cs_set_dac_rate(state, 8000);
3332 cs_set_divisor(dmabuf);
3333
3334 state->open_mode |= FMODE_WRITE;
3335 mutex_unlock(&state->open_mutex);
3336 if((ret = prog_dmabuf(state)))
3337 return ret;
3338 }
3339 CS_DBGOUT(CS_OPEN | CS_FUNCTION, 2, printk("cs46xx: cs_open()- 0\n") );
3340 return nonseekable_open(inode, file);
3341 }
3342
3343 static int cs_release(struct inode *inode, struct file *file)
3344 {
3345 struct cs_card *card = (struct cs_card *)file->private_data;
3346 struct dmabuf *dmabuf;
3347 struct cs_state *state;
3348 unsigned int tmp;
3349 CS_DBGOUT(CS_RELEASE | CS_FUNCTION, 2, printk("cs46xx: cs_release()+ file=%p %s %s\n",
3350 file, file->f_mode & FMODE_WRITE ? "FMODE_WRITE" : "",
3351 file->f_mode & FMODE_READ ? "FMODE_READ" : "") );
3352
3353 if (!(file->f_mode & (FMODE_WRITE | FMODE_READ)))
3354 {
3355 return -EINVAL;
3356 }
3357 state = card->states[1];
3358 if(state)
3359 {
3360 if ( (state->open_mode & FMODE_WRITE) & (file->f_mode & FMODE_WRITE) )
3361 {
3362 CS_DBGOUT(CS_RELEASE, 2, printk("cs46xx: cs_release() FMODE_WRITE\n") );
3363 dmabuf = &state->dmabuf;
3364 cs_clear_tail(state);
3365 drain_dac(state, file->f_flags & O_NONBLOCK);
3366 /* stop DMA state machine and free DMA buffers/channels */
3367 mutex_lock(&state->open_mutex);
3368 stop_dac(state);
3369 dealloc_dmabuf(state);
3370 state->card->free_pcm_channel(state->card, dmabuf->channel->num);
3371 free_page((unsigned long)state->dmabuf.pbuf);
3372
3373 /* we're covered by the open_mutex */
3374 mutex_unlock(&state->open_mutex);
3375 state->card->states[state->virt] = NULL;
3376 state->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
3377
3378 if( (tmp = cs461x_powerdown(card, CS_POWER_DAC, CS_FALSE )) )
3379 {
3380 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
3381 "cs46xx: cs_release_mixdev() powerdown DAC failure (0x%x)\n",tmp) );
3382 }
3383
3384 /* Now turn off external AMP if needed */
3385 state->card->amplifier_ctrl(state->card, -1);
3386 state->card->active_ctrl(state->card, -1);
3387
3388 kfree(state);
3389 }
3390 }
3391
3392 state = card->states[0];
3393 if(state)
3394 {
3395 if ( (state->open_mode & FMODE_READ) & (file->f_mode & FMODE_READ) )
3396 {
3397 CS_DBGOUT(CS_RELEASE, 2, printk("cs46xx: cs_release() FMODE_READ\n") );
3398 dmabuf = &state->dmabuf;
3399 mutex_lock(&state->open_mutex);
3400 stop_adc(state);
3401 dealloc_dmabuf(state);
3402 state->card->free_pcm_channel(state->card, dmabuf->channel->num);
3403 free_page((unsigned long)state->dmabuf.pbuf);
3404
3405 /* we're covered by the open_mutex */
3406 mutex_unlock(&state->open_mutex);
3407 state->card->states[state->virt] = NULL;
3408 state->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
3409
3410 if( (tmp = cs461x_powerdown(card, CS_POWER_ADC, CS_FALSE )) )
3411 {
3412 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
3413 "cs46xx: cs_release_mixdev() powerdown ADC failure (0x%x)\n",tmp) );
3414 }
3415
3416 /* Now turn off external AMP if needed */
3417 state->card->amplifier_ctrl(state->card, -1);
3418 state->card->active_ctrl(state->card, -1);
3419
3420 kfree(state);
3421 }
3422 }
3423
3424 CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 2, printk("cs46xx: cs_release()- 0\n") );
3425 return 0;
3426 }
3427
3428 static void printpm(struct cs_card *s)
3429 {
3430 CS_DBGOUT(CS_PM, 9, printk("pm struct:\n"));
3431 CS_DBGOUT(CS_PM, 9, printk("flags:0x%x u32CLKCR1_SAVE: 0%x u32SSPMValue: 0x%x\n",
3432 (unsigned)s->pm.flags,s->pm.u32CLKCR1_SAVE,s->pm.u32SSPMValue));
3433 CS_DBGOUT(CS_PM, 9, printk("u32PPLVCvalue: 0x%x u32PPRVCvalue: 0x%x\n",
3434 s->pm.u32PPLVCvalue,s->pm.u32PPRVCvalue));
3435 CS_DBGOUT(CS_PM, 9, printk("u32FMLVCvalue: 0x%x u32FMRVCvalue: 0x%x\n",
3436 s->pm.u32FMLVCvalue,s->pm.u32FMRVCvalue));
3437 CS_DBGOUT(CS_PM, 9, printk("u32GPIORvalue: 0x%x u32JSCTLvalue: 0x%x\n",
3438 s->pm.u32GPIORvalue,s->pm.u32JSCTLvalue));
3439 CS_DBGOUT(CS_PM, 9, printk("u32SSCR: 0x%x u32SRCSA: 0x%x\n",
3440 s->pm.u32SSCR,s->pm.u32SRCSA));
3441 CS_DBGOUT(CS_PM, 9, printk("u32DacASR: 0x%x u32AdcASR: 0x%x\n",
3442 s->pm.u32DacASR,s->pm.u32AdcASR));
3443 CS_DBGOUT(CS_PM, 9, printk("u32DacSR: 0x%x u32AdcSR: 0x%x\n",
3444 s->pm.u32DacSR,s->pm.u32AdcSR));
3445 CS_DBGOUT(CS_PM, 9, printk("u32MIDCR_Save: 0x%x\n",
3446 s->pm.u32MIDCR_Save));
3447 CS_DBGOUT(CS_PM, 9, printk("u32AC97_powerdown: 0x%x _general_purpose 0x%x\n",
3448 s->pm.u32AC97_powerdown,s->pm.u32AC97_general_purpose));
3449 CS_DBGOUT(CS_PM, 9, printk("u32AC97_master_volume: 0x%x\n",
3450 s->pm.u32AC97_master_volume));
3451 CS_DBGOUT(CS_PM, 9, printk("u32AC97_headphone_volume: 0x%x\n",
3452 s->pm.u32AC97_headphone_volume));
3453 CS_DBGOUT(CS_PM, 9, printk("u32AC97_master_volume_mono: 0x%x\n",
3454 s->pm.u32AC97_master_volume_mono));
3455 CS_DBGOUT(CS_PM, 9, printk("u32AC97_pcm_out_volume: 0x%x\n",
3456 s->pm.u32AC97_pcm_out_volume));
3457 CS_DBGOUT(CS_PM, 9, printk("dmabuf_swptr_play: 0x%x dmabuf_count_play: %d\n",
3458 s->pm.dmabuf_swptr_play,s->pm.dmabuf_count_play));
3459 CS_DBGOUT(CS_PM, 9, printk("dmabuf_swptr_capture: 0x%x dmabuf_count_capture: %d\n",
3460 s->pm.dmabuf_swptr_capture,s->pm.dmabuf_count_capture));
3461
3462 }
3463
3464 /****************************************************************************
3465 *
3466 * Suspend - save the ac97 regs, mute the outputs and power down the part.
3467 *
3468 ****************************************************************************/
3469 static void cs46xx_ac97_suspend(struct cs_card *card)
3470 {
3471 int Count,i;
3472 struct ac97_codec *dev=card->ac97_codec[0];
3473 unsigned int tmp;
3474
3475 CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_suspend()+\n"));
3476
3477 if(card->states[1])
3478 {
3479 stop_dac(card->states[1]);
3480 resync_dma_ptrs(card->states[1]);
3481 }
3482 if(card->states[0])
3483 {
3484 stop_adc(card->states[0]);
3485 resync_dma_ptrs(card->states[0]);
3486 }
3487
3488 for(Count = 0x2, i=0; (Count <= CS46XX_AC97_HIGHESTREGTORESTORE)
3489 && (i < CS46XX_AC97_NUMBER_RESTORE_REGS);
3490 Count += 2, i++)
3491 {
3492 card->pm.ac97[i] = cs_ac97_get(dev, BA0_AC97_RESET + Count);
3493 }
3494 /*
3495 * Save the ac97 volume registers as well as the current powerdown state.
3496 * Now, mute the all the outputs (master, headphone, and mono), as well
3497 * as the PCM volume, in preparation for powering down the entire part.
3498 card->pm.u32AC97_master_volume = (u32)cs_ac97_get( dev,
3499 (u8)BA0_AC97_MASTER_VOLUME);
3500 card->pm.u32AC97_headphone_volume = (u32)cs_ac97_get(dev,
3501 (u8)BA0_AC97_HEADPHONE_VOLUME);
3502 card->pm.u32AC97_master_volume_mono = (u32)cs_ac97_get(dev,
3503 (u8)BA0_AC97_MASTER_VOLUME_MONO);
3504 card->pm.u32AC97_pcm_out_volume = (u32)cs_ac97_get(dev,
3505 (u8)BA0_AC97_PCM_OUT_VOLUME);
3506 */
3507 /*
3508 * mute the outputs
3509 */
3510 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME, 0x8000);
3511 cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, 0x8000);
3512 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, 0x8000);
3513 cs_ac97_set(dev, (u8)BA0_AC97_PCM_OUT_VOLUME, 0x8000);
3514
3515 /*
3516 * save the registers that cause pops
3517 */
3518 card->pm.u32AC97_powerdown = (u32)cs_ac97_get(dev, (u8)AC97_POWER_CONTROL);
3519 card->pm.u32AC97_general_purpose = (u32)cs_ac97_get(dev, (u8)BA0_AC97_GENERAL_PURPOSE);
3520 /*
3521 * And power down everything on the AC97 codec.
3522 * well, for now, only power down the DAC/ADC and MIXER VREFON components.
3523 * trouble with removing VREF.
3524 */
3525 if( (tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
3526 CS_POWER_MIXVON, CS_TRUE )) )
3527 {
3528 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3529 "cs46xx: cs46xx_ac97_suspend() failure (0x%x)\n",tmp) );
3530 }
3531
3532 CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_suspend()-\n"));
3533 }
3534
3535 /****************************************************************************
3536 *
3537 * Resume - power up the part and restore its registers..
3538 *
3539 ****************************************************************************/
3540 static void cs46xx_ac97_resume(struct cs_card *card)
3541 {
3542 int Count,i;
3543 struct ac97_codec *dev=card->ac97_codec[0];
3544
3545 CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_resume()+\n"));
3546
3547 /*
3548 * First, we restore the state of the general purpose register. This
3549 * contains the mic select (mic1 or mic2) and if we restore this after
3550 * we restore the mic volume/boost state and mic2 was selected at
3551 * suspend time, we will end up with a brief period of time where mic1
3552 * is selected with the volume/boost settings for mic2, causing
3553 * acoustic feedback. So we restore the general purpose register
3554 * first, thereby getting the correct mic selected before we restore
3555 * the mic volume/boost.
3556 */
3557 cs_ac97_set(dev, (u8)BA0_AC97_GENERAL_PURPOSE,
3558 (u16)card->pm.u32AC97_general_purpose);
3559 /*
3560 * Now, while the outputs are still muted, restore the state of power
3561 * on the AC97 part.
3562 */
3563 cs_ac97_set(dev, (u8)BA0_AC97_POWERDOWN, (u16)card->pm.u32AC97_powerdown);
3564 mdelay(5 * cs_laptop_wait);
3565 /*
3566 * Restore just the first set of registers, from register number
3567 * 0x02 to the register number that ulHighestRegToRestore specifies.
3568 */
3569 for( Count = 0x2, i=0;
3570 (Count <= CS46XX_AC97_HIGHESTREGTORESTORE)
3571 && (i < CS46XX_AC97_NUMBER_RESTORE_REGS);
3572 Count += 2, i++)
3573 {
3574</