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