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