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