2 * Crystal SoundFusion CS46xx driver
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>
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>
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.
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.
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>
30 * <nils@kernelconcepts.de>
31 * Thanks to David Pollard for testing.
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.
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
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.
61 * Playback/Capture supported from 8k-48k.
62 * 16Bit Signed LE & 8Bit Unsigned, with Mono or Stereo supported.
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
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.
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
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>
96 #include <asm/uaccess.h>
97 #include <asm/hardirq.h>
99 #include "cs46xxpm-24.h"
100 #include "cs46xx_wrapper-24.h"
103 /* MIDI buffer sizes */
104 #define CS_MIDIINBUF 500
105 #define CS_MIDIOUTBUF 500
107 #define ADC_RUNNING 1
108 #define DAC_RUNNING 2
110 #define CS_FMT_16BIT 1 /* These are fixed in fact */
111 #define CS_FMT_STEREO 2
112 #define CS_FMT_MASK 3
114 #define CS_TYPE_ADC 1
115 #define CS_TYPE_DAC 2
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)
125 #define CS_DBGBREAKPOINT {__asm__("INT $3");}
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
136 #define GOF_PER_SEC 200
138 #define CSDEBUG_INTERFACE 1
141 * Turn on/off debugging compilation by using 1/0 respectively for CSDEBUG
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.
150 #define CS_DBGOUT(mask,level,x) if((cs_debuglevel >= (level)) && ((mask) & cs_debugmask)) {x;}
152 #define CS_DBGOUT(mask,level,x)
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 */
174 #define CS_IOCTL_CMD_SUSPEND 0x1 // suspend
175 #define CS_IOCTL_CMD_RESUME 0x2 // resume
178 static unsigned long cs_debuglevel=1; /* levels range from 1-9 */
179 MODULE_PARM(cs_debuglevel, "i");
180 static unsigned long cs_debugmask=CS_INIT | CS_ERROR; /* use CS_DBGOUT with various mask values */
181 MODULE_PARM(cs_debugmask, "i");
183 static unsigned long hercules_egpio_disable; /* if non-zero set all EGPIO to 0 */
184 MODULE_PARM(hercules_egpio_disable, "i");
185 static unsigned long initdelay=700; /* PM delay in millisecs */
186 MODULE_PARM(initdelay, "i");
187 static unsigned long powerdown=-1; /* turn on/off powerdown processing in driver */
188 MODULE_PARM(powerdown, "i");
189 #define DMABUF_DEFAULTORDER 3
190 static unsigned long defaultorder=DMABUF_DEFAULTORDER;
191 MODULE_PARM(defaultorder, "i");
193 static int external_amp;
194 MODULE_PARM(external_amp, "i");
196 MODULE_PARM(thinkpad, "i");
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.
203 static unsigned cs_powerdown=1;
204 static unsigned cs_laptop_wait=1;
206 /* An instance of the 4610 channel */
214 #define CS46XX_MAJOR_VERSION "1"
215 #define CS46XX_MINOR_VERSION "28"
218 #define CS46XX_ARCH "64" //architecture key
220 #define CS46XX_ARCH "32" //architecture key
223 struct list_head cs46xx_devs = { &cs46xx_devs, &cs46xx_devs };
225 /* magic numbers to protect our data structures */
226 #define CS_CARD_MAGIC 0x43525553 /* "CRUS" */
227 #define CS_STATE_MAGIC 0x4c4f4749 /* "LOGI" */
230 /* maxinum number of AC97 codecs connected, AC97 2.0 defined 4 */
233 static const unsigned sample_size[] = { 1, 2, 2, 4 };
234 static const unsigned sample_shift[] = { 0, 1, 1, 2 };
236 /* "software" or virtual channel, an instance of opened /dev/dsp */
239 struct cs_card *card; /* Card info */
241 /* single open lock mechanism, only used for recording */
242 struct semaphore open_sem;
243 wait_queue_head_t open_wait;
248 /* virtual channel number */
252 /* wave sample stuff */
254 unsigned char fmt, enable;
256 /* hardware channel */
257 struct cs_channel *channel;
258 int pringbuf; /* Software ring slot */
259 void *pbuf; /* 4K hardware DMA buffer */
261 /* OSS buffer management stuff */
263 dma_addr_t dma_handle;
269 void *tmpbuff; /* tmp buffer for sample conversions */
271 dma_addr_t dmaaddr_tmpbuff;
272 unsigned buforder_tmpbuff; /* Log base 2 of size in bytes.. */
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 */
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 */
285 /* redundant, but makes calculations easier */
288 unsigned fragsamples;
293 unsigned endcleared:1;
295 unsigned update_flag;
296 unsigned ossfragshift;
298 unsigned subdivision;
300 /* Guard against mmap/write/read races */
301 struct semaphore sem;
305 struct cs_channel channel[2];
308 /* We keep cs461x cards in a linked list */
309 struct cs_card *next;
311 /* The cs461x has a certain amount of cross channel interaction
312 so we use a single per card lock */
316 spinlock_t ac97_lock;
318 /* mixer use count */
319 atomic_t mixer_use_cnt;
321 /* PCI device stuff */
322 struct pci_dev * pci_dev;
323 struct list_head list;
325 unsigned int pctl, cctl; /* Hardware DMA flag sets */
327 /* soundcore stuff */
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];
337 int amplifier; /* Amplifier control */
338 void (*amplifier_ctrl)(struct cs_card *, int);
339 void (*amp_init)(struct cs_card *);
341 int active; /* Active clocking */
342 void (*active_ctrl)(struct cs_card *, int);
344 /* hardware resources */
345 unsigned long ba0_addr;
346 unsigned long ba1_addr;
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);
368 /* /dev/midi stuff */
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;
376 unsigned char ibuf[CS_MIDIINBUF];
377 unsigned char obuf[CS_MIDIOUTBUF];
379 struct semaphore open_sem;
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,
388 static int cs_hardware_init(struct cs_card *card);
389 static int cs46xx_powerup(struct cs_card *card, unsigned int type);
390 static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspendflag);
391 static void cs461x_clear_serial_FIFOs(struct cs_card *card, int type);
392 static int cs46xx_suspend_tbl(struct pci_dev *pcidev, u32 state);
393 static int cs46xx_resume_tbl(struct pci_dev *pcidev);
395 static inline unsigned ld2(unsigned int x)
424 #define SOUND_MIXER_CS_GETDBGLEVEL _SIOWR('M',120, int)
425 #define SOUND_MIXER_CS_SETDBGLEVEL _SIOWR('M',121, int)
426 #define SOUND_MIXER_CS_GETDBGMASK _SIOWR('M',122, int)
427 #define SOUND_MIXER_CS_SETDBGMASK _SIOWR('M',123, int)
428 #define SOUND_MIXER_CS_APM _SIOWR('M',124, int)
430 void printioctl(unsigned int x)
434 /* these values are incorrect for the ac97 driver, fix.
435 * Index of mixtable1[] member is Device ID
436 * and must be <= SOUND_MIXER_NRDEVICES.
437 * Value of array member is index into s->mix.vol[]
439 static const unsigned char mixtable1[SOUND_MIXER_NRDEVICES] = {
440 [SOUND_MIXER_PCM] = 1, /* voice */
441 [SOUND_MIXER_LINE1] = 2, /* AUX */
442 [SOUND_MIXER_CD] = 3, /* CD */
443 [SOUND_MIXER_LINE] = 4, /* Line */
444 [SOUND_MIXER_SYNTH] = 5, /* FM */
445 [SOUND_MIXER_MIC] = 6, /* Mic */
446 [SOUND_MIXER_SPEAKER] = 7, /* Speaker */
447 [SOUND_MIXER_RECLEV] = 8, /* Recording level */
448 [SOUND_MIXER_VOLUME] = 9 /* Master Volume */
453 case SOUND_MIXER_CS_GETDBGMASK:
454 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_GETDBGMASK: ") );
456 case SOUND_MIXER_CS_GETDBGLEVEL:
457 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_GETDBGLEVEL: ") );
459 case SOUND_MIXER_CS_SETDBGMASK:
460 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_SETDBGMASK: ") );
462 case SOUND_MIXER_CS_SETDBGLEVEL:
463 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_SETDBGLEVEL: ") );
466 CS_DBGOUT(CS_IOCTL, 4, printk("OSS_GETVERSION: ") );
468 case SNDCTL_DSP_SYNC:
469 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SYNC: ") );
471 case SNDCTL_DSP_SETDUPLEX:
472 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETDUPLEX: ") );
474 case SNDCTL_DSP_GETCAPS:
475 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETCAPS: ") );
477 case SNDCTL_DSP_RESET:
478 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_RESET: ") );
480 case SNDCTL_DSP_SPEED:
481 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SPEED: ") );
483 case SNDCTL_DSP_STEREO:
484 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_STEREO: ") );
486 case SNDCTL_DSP_CHANNELS:
487 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_CHANNELS: ") );
489 case SNDCTL_DSP_GETFMTS:
490 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETFMTS: ") );
492 case SNDCTL_DSP_SETFMT:
493 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETFMT: ") );
495 case SNDCTL_DSP_POST:
496 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_POST: ") );
498 case SNDCTL_DSP_GETTRIGGER:
499 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETTRIGGER: ") );
501 case SNDCTL_DSP_SETTRIGGER:
502 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETTRIGGER: ") );
504 case SNDCTL_DSP_GETOSPACE:
505 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETOSPACE: ") );
507 case SNDCTL_DSP_GETISPACE:
508 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETISPACE: ") );
510 case SNDCTL_DSP_NONBLOCK:
511 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_NONBLOCK: ") );
513 case SNDCTL_DSP_GETODELAY:
514 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETODELAY: ") );
516 case SNDCTL_DSP_GETIPTR:
517 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETIPTR: ") );
519 case SNDCTL_DSP_GETOPTR:
520 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETOPTR: ") );
522 case SNDCTL_DSP_GETBLKSIZE:
523 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETBLKSIZE: ") );
525 case SNDCTL_DSP_SETFRAGMENT:
526 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETFRAGMENT: ") );
528 case SNDCTL_DSP_SUBDIVIDE:
529 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SUBDIVIDE: ") );
531 case SOUND_PCM_READ_RATE:
532 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_RATE: ") );
534 case SOUND_PCM_READ_CHANNELS:
535 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_CHANNELS: ") );
537 case SOUND_PCM_READ_BITS:
538 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_BITS: ") );
540 case SOUND_PCM_WRITE_FILTER:
541 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_WRITE_FILTER: ") );
543 case SNDCTL_DSP_SETSYNCRO:
544 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETSYNCRO: ") );
546 case SOUND_PCM_READ_FILTER:
547 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_FILTER: ") );
550 case SOUND_MIXER_PRIVATE1:
551 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE1: ") );
553 case SOUND_MIXER_PRIVATE2:
554 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE2: ") );
556 case SOUND_MIXER_PRIVATE3:
557 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE3: ") );
559 case SOUND_MIXER_PRIVATE4:
560 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE4: ") );
562 case SOUND_MIXER_PRIVATE5:
563 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE5: ") );
565 case SOUND_MIXER_INFO:
566 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_INFO: ") );
568 case SOUND_OLD_MIXER_INFO:
569 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_OLD_MIXER_INFO: ") );
575 case SOUND_MIXER_VOLUME:
576 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_VOLUME: ") );
578 case SOUND_MIXER_SPEAKER:
579 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_SPEAKER: ") );
581 case SOUND_MIXER_RECLEV:
582 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECLEV: ") );
584 case SOUND_MIXER_MIC:
585 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_MIC: ") );
587 case SOUND_MIXER_SYNTH:
588 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_SYNTH: ") );
590 case SOUND_MIXER_RECSRC:
591 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECSRC: ") );
593 case SOUND_MIXER_DEVMASK:
594 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_DEVMASK: ") );
596 case SOUND_MIXER_RECMASK:
597 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECMASK: ") );
599 case SOUND_MIXER_STEREODEVS:
600 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_STEREODEVS: ") );
602 case SOUND_MIXER_CAPS:
603 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CAPS:") );
607 if (i >= SOUND_MIXER_NRDEVICES || !(vidx = mixtable1[i]))
609 CS_DBGOUT(CS_IOCTL, 4, printk("UNKNOWN IOCTL: 0x%.8x NR=%d ",x,i) );
613 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_IOCTL AC9x: 0x%.8x NR=%d ",
619 CS_DBGOUT(CS_IOCTL, 4, printk("command = 0x%x IOC_NR=%d\n",x, _IOC_NR(x)) );
624 * common I/O routines
627 static void cs461x_poke(struct cs_card *codec, unsigned long reg, unsigned int val)
629 writel(val, codec->ba1.idx[(reg >> 16) & 3]+(reg&0xffff));
632 static unsigned int cs461x_peek(struct cs_card *codec, unsigned long reg)
634 return readl(codec->ba1.idx[(reg >> 16) & 3]+(reg&0xffff));
637 static void cs461x_pokeBA0(struct cs_card *codec, unsigned long reg, unsigned int val)
639 writel(val, codec->ba0+reg);
642 static unsigned int cs461x_peekBA0(struct cs_card *codec, unsigned long reg)
644 return readl(codec->ba0+reg);
648 static u16 cs_ac97_get(struct ac97_codec *dev, u8 reg);
649 static void cs_ac97_set(struct ac97_codec *dev, u8 reg, u16 data);
651 static struct cs_channel *cs_alloc_pcm_channel(struct cs_card *card)
653 if(card->channel[1].used==1)
655 card->channel[1].used=1;
656 card->channel[1].num=1;
657 return &card->channel[1];
660 static struct cs_channel *cs_alloc_rec_pcm_channel(struct cs_card *card)
662 if(card->channel[0].used==1)
664 card->channel[0].used=1;
665 card->channel[0].num=0;
666 return &card->channel[0];
669 static void cs_free_pcm_channel(struct cs_card *card, int channel)
671 card->channel[channel].state = NULL;
672 card->channel[channel].used=0;
676 * setup a divisor value to help with conversion from
677 * 16bit Stereo, down to 8bit stereo/mono or 16bit mono.
678 * assign a divisor of 1 if using 16bit Stereo as that is
679 * the only format that the static image will capture.
681 static void cs_set_divisor(struct dmabuf *dmabuf)
683 if(dmabuf->type == CS_TYPE_DAC)
685 else if( !(dmabuf->fmt & CS_FMT_STEREO) &&
686 (dmabuf->fmt & CS_FMT_16BIT))
688 else if( (dmabuf->fmt & CS_FMT_STEREO) &&
689 !(dmabuf->fmt & CS_FMT_16BIT))
691 else if( !(dmabuf->fmt & CS_FMT_STEREO) &&
692 !(dmabuf->fmt & CS_FMT_16BIT))
697 CS_DBGOUT(CS_PARMS | CS_FUNCTION, 8, printk(
698 "cs46xx: cs_set_divisor()- %s %d\n",
699 (dmabuf->type == CS_TYPE_ADC) ? "ADC" : "DAC",
704 * mute some of the more prevalent registers to avoid popping.
706 static void cs_mute(struct cs_card *card, int state)
708 struct ac97_codec *dev=card->ac97_codec[0];
710 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs46xx: cs_mute()+ %s\n",
711 (state == CS_TRUE) ? "Muting" : "UnMuting") );
716 * fix pops when powering up on thinkpads
718 card->pm.u32AC97_master_volume = (u32)cs_ac97_get( dev,
719 (u8)BA0_AC97_MASTER_VOLUME);
720 card->pm.u32AC97_headphone_volume = (u32)cs_ac97_get(dev,
721 (u8)BA0_AC97_HEADPHONE_VOLUME);
722 card->pm.u32AC97_master_volume_mono = (u32)cs_ac97_get(dev,
723 (u8)BA0_AC97_MASTER_VOLUME_MONO);
724 card->pm.u32AC97_pcm_out_volume = (u32)cs_ac97_get(dev,
725 (u8)BA0_AC97_PCM_OUT_VOLUME);
727 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME, 0x8000);
728 cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, 0x8000);
729 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, 0x8000);
730 cs_ac97_set(dev, (u8)BA0_AC97_PCM_OUT_VOLUME, 0x8000);
734 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME, card->pm.u32AC97_master_volume);
735 cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, card->pm.u32AC97_headphone_volume);
736 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, card->pm.u32AC97_master_volume_mono);
737 cs_ac97_set(dev, (u8)BA0_AC97_PCM_OUT_VOLUME, card->pm.u32AC97_pcm_out_volume);
739 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs46xx: cs_mute()-\n"));
742 /* set playback sample rate */
743 static unsigned int cs_set_dac_rate(struct cs_state * state, unsigned int rate)
745 struct dmabuf *dmabuf = &state->dmabuf;
746 unsigned int tmp1, tmp2;
747 unsigned int phiIncr;
748 unsigned int correctionPerGOF, correctionPerSec;
751 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_dac_rate()+ %d\n",rate) );
754 * Compute the values used to drive the actual sample rate conversion.
755 * The following formulas are being computed, using inline assembly
756 * since we need to use 64 bit arithmetic to compute the values:
758 * phiIncr = floor((Fs,in * 2^26) / Fs,out)
759 * correctionPerGOF = floor((Fs,in * 2^26 - Fs,out * phiIncr) /
761 * ulCorrectionPerSec = Fs,in * 2^26 - Fs,out * phiIncr -M
762 * GOF_PER_SEC * correctionPerGOF
766 * phiIncr:other = dividend:remainder((Fs,in * 2^26) / Fs,out)
767 * correctionPerGOF:correctionPerSec =
768 * dividend:remainder(ulOther / GOF_PER_SEC)
771 phiIncr = tmp1 / 48000;
772 tmp1 -= phiIncr * 48000;
777 tmp1 -= tmp2 * 48000;
778 correctionPerGOF = tmp1 / GOF_PER_SEC;
779 tmp1 -= correctionPerGOF * GOF_PER_SEC;
780 correctionPerSec = tmp1;
783 * Fill in the SampleRateConverter control block.
786 spin_lock_irqsave(&state->card->lock, flags);
787 cs461x_poke(state->card, BA1_PSRC,
788 ((correctionPerSec << 16) & 0xFFFF0000) | (correctionPerGOF & 0xFFFF));
789 cs461x_poke(state->card, BA1_PPI, phiIncr);
790 spin_unlock_irqrestore(&state->card->lock, flags);
793 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_dac_rate()- %d\n",rate) );
797 /* set recording sample rate */
798 static unsigned int cs_set_adc_rate(struct cs_state * state, unsigned int rate)
800 struct dmabuf *dmabuf = &state->dmabuf;
801 struct cs_card *card = state->card;
802 unsigned int phiIncr, coeffIncr, tmp1, tmp2;
803 unsigned int correctionPerGOF, correctionPerSec, initialDelay;
804 unsigned int frameGroupLength, cnt;
806 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_adc_rate()+ %d\n",rate) );
809 * We can only decimate by up to a factor of 1/9th the hardware rate.
810 * Correct the value if an attempt is made to stray outside that limit.
812 if ((rate * 9) < 48000)
816 * We can not capture at at rate greater than the Input Rate (48000).
817 * Return an error if an attempt is made to stray outside that limit.
823 * Compute the values used to drive the actual sample rate conversion.
824 * The following formulas are being computed, using inline assembly
825 * since we need to use 64 bit arithmetic to compute the values:
827 * coeffIncr = -floor((Fs,out * 2^23) / Fs,in)
828 * phiIncr = floor((Fs,in * 2^26) / Fs,out)
829 * correctionPerGOF = floor((Fs,in * 2^26 - Fs,out * phiIncr) /
831 * correctionPerSec = Fs,in * 2^26 - Fs,out * phiIncr -
832 * GOF_PER_SEC * correctionPerGOF
833 * initialDelay = ceil((24 * Fs,in) / Fs,out)
837 * coeffIncr = neg(dividend((Fs,out * 2^23) / Fs,in))
838 * phiIncr:ulOther = dividend:remainder((Fs,in * 2^26) / Fs,out)
839 * correctionPerGOF:correctionPerSec =
840 * dividend:remainder(ulOther / GOF_PER_SEC)
841 * initialDelay = dividend(((24 * Fs,in) + Fs,out - 1) / Fs,out)
845 coeffIncr = tmp1 / 48000;
846 tmp1 -= coeffIncr * 48000;
849 coeffIncr += tmp1 / 48000;
850 coeffIncr ^= 0xFFFFFFFF;
853 phiIncr = tmp1 / rate;
854 tmp1 -= phiIncr * rate;
860 correctionPerGOF = tmp1 / GOF_PER_SEC;
861 tmp1 -= correctionPerGOF * GOF_PER_SEC;
862 correctionPerSec = tmp1;
863 initialDelay = ((48000 * 24) + rate - 1) / rate;
866 * Fill in the VariDecimate control block.
868 spin_lock_irqsave(&card->lock, flags);
869 cs461x_poke(card, BA1_CSRC,
870 ((correctionPerSec << 16) & 0xFFFF0000) | (correctionPerGOF & 0xFFFF));
871 cs461x_poke(card, BA1_CCI, coeffIncr);
872 cs461x_poke(card, BA1_CD,
873 (((BA1_VARIDEC_BUF_1 + (initialDelay << 2)) << 16) & 0xFFFF0000) | 0x80);
874 cs461x_poke(card, BA1_CPI, phiIncr);
875 spin_unlock_irqrestore(&card->lock, flags);
878 * Figure out the frame group length for the write back task. Basically,
879 * this is just the factors of 24000 (2^6*3*5^3) that are not present in
880 * the output sample rate.
882 frameGroupLength = 1;
883 for (cnt = 2; cnt <= 64; cnt *= 2) {
884 if (((rate / cnt) * cnt) != rate)
885 frameGroupLength *= 2;
887 if (((rate / 3) * 3) != rate) {
888 frameGroupLength *= 3;
890 for (cnt = 5; cnt <= 125; cnt *= 5) {
891 if (((rate / cnt) * cnt) != rate)
892 frameGroupLength *= 5;
896 * Fill in the WriteBack control block.
898 spin_lock_irqsave(&card->lock, flags);
899 cs461x_poke(card, BA1_CFG1, frameGroupLength);
900 cs461x_poke(card, BA1_CFG2, (0x00800000 | frameGroupLength));
901 cs461x_poke(card, BA1_CCST, 0x0000FFFF);
902 cs461x_poke(card, BA1_CSPB, ((65536 * rate) / 24000));
903 cs461x_poke(card, (BA1_CSPB + 4), 0x0000FFFF);
904 spin_unlock_irqrestore(&card->lock, flags);
906 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_adc_rate()- %d\n",rate) );
910 /* prepare channel attributes for playback */
911 static void cs_play_setup(struct cs_state *state)
913 struct dmabuf *dmabuf = &state->dmabuf;
914 struct cs_card *card = state->card;
915 unsigned int tmp, Count, playFormat;
917 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_play_setup()+\n") );
918 cs461x_poke(card, BA1_PVOL, 0x80008000);
920 cs461x_poke(card, BA1_PBA, virt_to_bus(dmabuf->pbuf));
923 playFormat=cs461x_peek(card, BA1_PFIE);
924 if ((dmabuf->fmt & CS_FMT_STEREO)) {
925 playFormat &= ~DMA_RQ_C2_AC_MONO_TO_STEREO;
929 playFormat |= DMA_RQ_C2_AC_MONO_TO_STEREO;
931 if ((dmabuf->fmt & CS_FMT_16BIT)) {
932 playFormat &= ~(DMA_RQ_C2_AC_8_TO_16_BIT
933 | DMA_RQ_C2_AC_SIGNED_CONVERT);
937 playFormat |= (DMA_RQ_C2_AC_8_TO_16_BIT
938 | DMA_RQ_C2_AC_SIGNED_CONVERT);
940 cs461x_poke(card, BA1_PFIE, playFormat);
942 tmp = cs461x_peek(card, BA1_PDTC);
944 cs461x_poke(card, BA1_PDTC, tmp | --Count);
946 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_play_setup()-\n") );
950 static struct InitStruct
954 } InitArray[] = { {0x00000040, 0x3fc0000f},
955 {0x0000004c, 0x04800000},
957 {0x000000b3, 0x00000780},
958 {0x000000b7, 0x00000000},
959 {0x000000bc, 0x07800000},
961 {0x000000cd, 0x00800000},
965 * "SetCaptureSPValues()" -- Initialize record task values before each
968 void SetCaptureSPValues(struct cs_card *card)
971 CS_DBGOUT(CS_FUNCTION, 8, printk("cs46xx: SetCaptureSPValues()+\n") );
972 for(i=0; i<sizeof(InitArray)/sizeof(struct InitStruct); i++)
974 offset = InitArray[i].off*4; /* 8bit to 32bit offset value */
975 cs461x_poke(card, offset, InitArray[i].val );
977 CS_DBGOUT(CS_FUNCTION, 8, printk("cs46xx: SetCaptureSPValues()-\n") );
980 /* prepare channel attributes for recording */
981 static void cs_rec_setup(struct cs_state *state)
983 struct cs_card *card = state->card;
984 struct dmabuf *dmabuf = &state->dmabuf;
985 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_rec_setup()+\n") );
987 SetCaptureSPValues(card);
990 * set the attenuation to 0dB
992 cs461x_poke(card, BA1_CVOL, 0x80008000);
995 * set the physical address of the capture buffer into the SP
997 cs461x_poke(card, BA1_CBA, virt_to_bus(dmabuf->rawbuf));
999 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_rec_setup()-\n") );
1003 /* get current playback/recording dma buffer pointer (byte offset from LBA),
1004 called with spinlock held! */
1006 static inline unsigned cs_get_dma_addr(struct cs_state *state)
1008 struct dmabuf *dmabuf = &state->dmabuf;
1011 if ( (!(dmabuf->enable & DAC_RUNNING)) &&
1012 (!(dmabuf->enable & ADC_RUNNING) ) )
1014 CS_DBGOUT(CS_ERROR, 2, printk(
1015 "cs46xx: ERROR cs_get_dma_addr(): not enabled \n") );
1020 * granularity is byte boundary, good part.
1022 if(dmabuf->enable & DAC_RUNNING)
1024 offset = cs461x_peek(state->card, BA1_PBA);
1026 else /* ADC_RUNNING must be set */
1028 offset = cs461x_peek(state->card, BA1_CBA);
1030 CS_DBGOUT(CS_PARMS | CS_FUNCTION, 9,
1031 printk("cs46xx: cs_get_dma_addr() %d\n",offset) );
1032 offset = (u32)bus_to_virt((unsigned long)offset) - (u32)dmabuf->rawbuf;
1033 CS_DBGOUT(CS_PARMS | CS_FUNCTION, 8,
1034 printk("cs46xx: cs_get_dma_addr()- %d\n",offset) );
1038 static void resync_dma_ptrs(struct cs_state *state)
1040 struct dmabuf *dmabuf;
1042 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: resync_dma_ptrs()+ \n") );
1045 dmabuf = &state->dmabuf;
1046 dmabuf->hwptr=dmabuf->swptr = 0;
1047 dmabuf->pringbuf = 0;
1049 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: resync_dma_ptrs()- \n") );
1052 /* Stop recording (lock held) */
1053 static inline void __stop_adc(struct cs_state *state)
1055 struct dmabuf *dmabuf = &state->dmabuf;
1056 struct cs_card *card = state->card;
1059 dmabuf->enable &= ~ADC_RUNNING;
1061 tmp = cs461x_peek(card, BA1_CCTL);
1063 cs461x_poke(card, BA1_CCTL, tmp );
1066 static void stop_adc(struct cs_state *state)
1068 unsigned long flags;
1070 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_adc()+ \n") );
1071 spin_lock_irqsave(&state->card->lock, flags);
1073 spin_unlock_irqrestore(&state->card->lock, flags);
1074 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_adc()- \n") );
1077 static void start_adc(struct cs_state *state)
1079 struct dmabuf *dmabuf = &state->dmabuf;
1080 struct cs_card *card = state->card;
1081 unsigned long flags;
1084 spin_lock_irqsave(&card->lock, flags);
1085 if (!(dmabuf->enable & ADC_RUNNING) &&
1086 ((dmabuf->mapped || dmabuf->count < (signed)dmabuf->dmasize)
1087 && dmabuf->ready) &&
1088 ((card->pm.flags & CS46XX_PM_IDLE) ||
1089 (card->pm.flags & CS46XX_PM_RESUMED)) )
1091 dmabuf->enable |= ADC_RUNNING;
1092 cs_set_divisor(dmabuf);
1093 tmp = cs461x_peek(card, BA1_CCTL);
1096 CS_DBGOUT(CS_FUNCTION, 2, printk(
1097 "cs46xx: start_adc() poke 0x%x \n",tmp) );
1098 cs461x_poke(card, BA1_CCTL, tmp);
1100 spin_unlock_irqrestore(&card->lock, flags);
1103 /* stop playback (lock held) */
1104 static inline void __stop_dac(struct cs_state *state)
1106 struct dmabuf *dmabuf = &state->dmabuf;
1107 struct cs_card *card = state->card;
1110 dmabuf->enable &= ~DAC_RUNNING;
1112 tmp=cs461x_peek(card, BA1_PCTL);
1114 cs461x_poke(card, BA1_PCTL, tmp);
1117 static void stop_dac(struct cs_state *state)
1119 unsigned long flags;
1121 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_dac()+ \n") );
1122 spin_lock_irqsave(&state->card->lock, flags);
1124 spin_unlock_irqrestore(&state->card->lock, flags);
1125 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_dac()- \n") );
1128 static void start_dac(struct cs_state *state)
1130 struct dmabuf *dmabuf = &state->dmabuf;
1131 struct cs_card *card = state->card;
1132 unsigned long flags;
1135 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: start_dac()+ \n") );
1136 spin_lock_irqsave(&card->lock, flags);
1137 if (!(dmabuf->enable & DAC_RUNNING) &&
1138 ((dmabuf->mapped || dmabuf->count > 0) && dmabuf->ready) &&
1139 ((card->pm.flags & CS46XX_PM_IDLE) ||
1140 (card->pm.flags & CS46XX_PM_RESUMED)) )
1142 dmabuf->enable |= DAC_RUNNING;
1143 tmp = cs461x_peek(card, BA1_PCTL);
1146 CS_DBGOUT(CS_PARMS, 6, printk(
1147 "cs46xx: start_dac() poke card=0x%.08x tmp=0x%.08x addr=0x%.08x \n",
1148 (unsigned)card, (unsigned)tmp,
1149 (unsigned)card->ba1.idx[(BA1_PCTL >> 16) & 3]+(BA1_PCTL&0xffff) ) );
1150 cs461x_poke(card, BA1_PCTL, tmp);
1152 spin_unlock_irqrestore(&card->lock, flags);
1153 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: start_dac()- \n") );
1156 #define DMABUF_MINORDER 1
1159 * allocate DMA buffer, playback and recording buffers are separate.
1161 static int alloc_dmabuf(struct cs_state *state)
1164 struct cs_card *card=state->card;
1165 struct dmabuf *dmabuf = &state->dmabuf;
1166 void *rawbuf = NULL;
1167 void *tmpbuff = NULL;
1169 struct page *map, *mapend;
1172 dmabuf->ready = dmabuf->mapped = 0;
1175 * check for order within limits, but do not overwrite value.
1177 if((defaultorder > 1) && (defaultorder < 12))
1182 for (order = df; order >= DMABUF_MINORDER; order--)
1183 if ( (rawbuf = (void *) pci_alloc_consistent(
1184 card->pci_dev, PAGE_SIZE << order, &dmabuf->dmaaddr)))
1187 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
1188 "cs46xx: alloc_dmabuf(): unable to allocate rawbuf\n"));
1191 dmabuf->buforder = order;
1192 dmabuf->rawbuf = rawbuf;
1193 // Now mark the pages as reserved; otherwise the
1194 // remap_page_range() in cs46xx_mmap doesn't work.
1195 // 1. get index to last page in mem_map array for rawbuf.
1196 mapend = virt_to_page(dmabuf->rawbuf +
1197 (PAGE_SIZE << dmabuf->buforder) - 1);
1199 // 2. mark each physical page in range as 'reserved'.
1200 for (map = virt_to_page(dmabuf->rawbuf); map <= mapend; map++)
1201 cs4x_mem_map_reserve(map);
1203 CS_DBGOUT(CS_PARMS, 9, printk("cs46xx: alloc_dmabuf(): allocated %ld (order = %d) bytes at %p\n",
1204 PAGE_SIZE << order, order, rawbuf) );
1207 * only allocate the conversion buffer for the ADC
1209 if(dmabuf->type == CS_TYPE_DAC)
1211 dmabuf->tmpbuff = NULL;
1212 dmabuf->buforder_tmpbuff = 0;
1216 * now the temp buffer for 16/8 conversions
1219 tmpbuff = (void *) pci_alloc_consistent(
1220 card->pci_dev, PAGE_SIZE << order, &dmabuf->dmaaddr_tmpbuff);
1224 CS_DBGOUT(CS_PARMS, 9, printk("cs46xx: allocated %ld (order = %d) bytes at %p\n",
1225 PAGE_SIZE << order, order, tmpbuff) );
1227 dmabuf->tmpbuff = tmpbuff;
1228 dmabuf->buforder_tmpbuff = order;
1230 // Now mark the pages as reserved; otherwise the
1231 // remap_page_range() in cs46xx_mmap doesn't work.
1232 // 1. get index to last page in mem_map array for rawbuf.
1233 mapend = virt_to_page(dmabuf->tmpbuff +
1234 (PAGE_SIZE << dmabuf->buforder_tmpbuff) - 1);
1236 // 2. mark each physical page in range as 'reserved'.
1237 for (map = virt_to_page(dmabuf->tmpbuff); map <= mapend; map++)
1238 cs4x_mem_map_reserve(map);
1242 /* free DMA buffer */
1243 static void dealloc_dmabuf(struct cs_state *state)
1245 struct dmabuf *dmabuf = &state->dmabuf;
1246 struct page *map, *mapend;
1248 if (dmabuf->rawbuf) {
1249 // Undo prog_dmabuf()'s marking the pages as reserved
1250 mapend = virt_to_page(dmabuf->rawbuf +
1251 (PAGE_SIZE << dmabuf->buforder) - 1);
1252 for (map = virt_to_page(dmabuf->rawbuf); map <= mapend; map++)
1253 cs4x_mem_map_unreserve(map);
1254 free_dmabuf(state->card, dmabuf);
1257 if (dmabuf->tmpbuff) {
1258 // Undo prog_dmabuf()'s marking the pages as reserved
1259 mapend = virt_to_page(dmabuf->tmpbuff +
1260 (PAGE_SIZE << dmabuf->buforder_tmpbuff) - 1);
1261 for (map = virt_to_page(dmabuf->tmpbuff); map <= mapend; map++)
1262 cs4x_mem_map_unreserve(map);
1263 free_dmabuf2(state->card, dmabuf);
1266 dmabuf->rawbuf = NULL;
1267 dmabuf->tmpbuff = NULL;
1268 dmabuf->mapped = dmabuf->ready = 0;
1272 static int __prog_dmabuf(struct cs_state *state)
1274 struct dmabuf *dmabuf = &state->dmabuf;
1275 unsigned long flags;
1276 unsigned long allocated_pages, allocated_bytes;
1277 unsigned long tmp1, tmp2, fmt=0;
1278 unsigned long *ptmp = (unsigned long *) dmabuf->pbuf;
1279 unsigned long SGarray[9], nSGpages=0;
1282 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()+ \n"));
1284 * check for CAPTURE and use only non-sg for initial release
1286 if(dmabuf->type == CS_TYPE_ADC)
1288 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf() ADC\n"));
1290 * add in non-sg support for capture.
1292 spin_lock_irqsave(&state->card->lock, flags);
1293 /* add code to reset the rawbuf memory. TRW */
1294 resync_dma_ptrs(state);
1295 dmabuf->total_bytes = dmabuf->blocks = 0;
1296 dmabuf->count = dmabuf->error = dmabuf->underrun = 0;
1300 spin_unlock_irqrestore(&state->card->lock, flags);
1302 /* allocate DMA buffer if not allocated yet */
1303 if (!dmabuf->rawbuf || !dmabuf->tmpbuff)
1304 if ((ret = alloc_dmabuf(state)))
1307 * static image only supports 16Bit signed, stereo - hard code fmt
1309 fmt = CS_FMT_16BIT | CS_FMT_STEREO;
1311 dmabuf->numfrag = 2;
1312 dmabuf->fragsize = 2048;
1313 dmabuf->fragsamples = 2048 >> sample_shift[fmt];
1314 dmabuf->dmasize = 4096;
1315 dmabuf->fragshift = 11;
1317 memset(dmabuf->rawbuf, (fmt & CS_FMT_16BIT) ? 0 : 0x80,
1319 memset(dmabuf->tmpbuff, (fmt & CS_FMT_16BIT) ? 0 : 0x80,
1320 PAGE_SIZE<<dmabuf->buforder_tmpbuff);
1323 * Now set up the ring
1326 spin_lock_irqsave(&state->card->lock, flags);
1327 cs_rec_setup(state);
1328 spin_unlock_irqrestore(&state->card->lock, flags);
1330 /* set the ready flag for the dma buffer */
1333 CS_DBGOUT(CS_PARMS, 4, printk(
1334 "cs46xx: prog_dmabuf(): CAPTURE rate=%d fmt=0x%x numfrag=%d "
1335 "fragsize=%d dmasize=%d\n",
1336 dmabuf->rate, dmabuf->fmt, dmabuf->numfrag,
1337 dmabuf->fragsize, dmabuf->dmasize) );
1339 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- 0 \n"));
1342 else if (dmabuf->type == CS_TYPE_DAC)
1347 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf() DAC\n"));
1348 spin_lock_irqsave(&state->card->lock, flags);
1349 resync_dma_ptrs(state);
1350 dmabuf->total_bytes = dmabuf->blocks = 0;
1351 dmabuf->count = dmabuf->error = dmabuf->underrun = 0;
1355 spin_unlock_irqrestore(&state->card->lock, flags);
1357 /* allocate DMA buffer if not allocated yet */
1358 if (!dmabuf->rawbuf)
1359 if ((ret = alloc_dmabuf(state)))
1362 allocated_pages = 1 << dmabuf->buforder;
1363 allocated_bytes = allocated_pages*PAGE_SIZE;
1365 if(allocated_pages < 2)
1367 CS_DBGOUT(CS_FUNCTION, 4, printk(
1368 "cs46xx: prog_dmabuf() Error: allocated_pages too small (%d)\n",
1369 (unsigned)allocated_pages));
1373 /* Use all the pages allocated, fragsize 4k. */
1374 /* Use 'pbuf' for S/G page map table. */
1375 dmabuf->SGok = 1; /* Use S/G. */
1377 nSGpages = allocated_bytes/4096; /* S/G pages always 4k. */
1379 /* Set up S/G variables. */
1380 *ptmp = virt_to_bus(dmabuf->rawbuf);
1381 *(ptmp+1) = 0x00000008;
1382 for(tmp1= 1; tmp1 < nSGpages; tmp1++) {
1383 *(ptmp+2*tmp1) = virt_to_bus( (dmabuf->rawbuf)+4096*tmp1);
1384 if( tmp1 == nSGpages-1)
1387 tmp2 = 0x80000000+8*(tmp1+1);
1388 *(ptmp+2*tmp1+1) = tmp2;
1390 SGarray[0] = 0x82c0200d;
1391 SGarray[1] = 0xffff0000;
1393 SGarray[3] = 0x00010600;
1394 SGarray[4] = *(ptmp+2);
1395 SGarray[5] = 0x80000010;
1397 SGarray[7] = *(ptmp+2);
1398 SGarray[8] = (virt_to_bus(dmabuf->pbuf) & 0xffff000) | 0x10;
1401 dmabuf->numfrag = nSGpages;
1402 dmabuf->fragsize = 4096;
1403 dmabuf->fragsamples = 4096 >> sample_shift[dmabuf->fmt];
1404 dmabuf->fragshift = 12;
1405 dmabuf->dmasize = dmabuf->numfrag*4096;
1408 SGarray[0] = 0xf2c0000f;
1409 SGarray[1] = 0x00000200;
1411 SGarray[3] = 0x00010600;
1412 SGarray[4]=SGarray[5]=SGarray[6]=SGarray[7]=SGarray[8] = 0;
1413 dmabuf->numfrag = 2;
1414 dmabuf->fragsize = 2048;
1415 dmabuf->fragsamples = 2048 >> sample_shift[dmabuf->fmt];
1416 dmabuf->dmasize = 4096;
1417 dmabuf->fragshift = 11;
1419 for(tmp1 = 0; tmp1 < sizeof(SGarray)/4; tmp1++)
1420 cs461x_poke( state->card, BA1_PDTC+tmp1*4, SGarray[tmp1]);
1422 memset(dmabuf->rawbuf, (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
1426 * Now set up the ring
1429 spin_lock_irqsave(&state->card->lock, flags);
1430 cs_play_setup(state);
1431 spin_unlock_irqrestore(&state->card->lock, flags);
1433 /* set the ready flag for the dma buffer */
1436 CS_DBGOUT(CS_PARMS, 4, printk(
1437 "cs46xx: prog_dmabuf(): PLAYBACK rate=%d fmt=0x%x numfrag=%d "
1438 "fragsize=%d dmasize=%d\n",
1439 dmabuf->rate, dmabuf->fmt, dmabuf->numfrag,
1440 dmabuf->fragsize, dmabuf->dmasize) );
1442 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- \n"));
1447 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- Invalid Type %d\n",
1453 static int prog_dmabuf(struct cs_state *state)
1458 ret = __prog_dmabuf(state);
1464 static void cs_clear_tail(struct cs_state *state)
1468 static int drain_dac(struct cs_state *state, int nonblock)
1470 DECLARE_WAITQUEUE(wait, current);
1471 struct dmabuf *dmabuf = &state->dmabuf;
1472 struct cs_card *card=state->card;
1473 unsigned long flags;
1477 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()+ \n"));
1478 if (dmabuf->mapped || !dmabuf->ready)
1480 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()- 0, not ready\n"));
1484 add_wait_queue(&dmabuf->wait, &wait);
1486 /* It seems that we have to set the current state to TASK_INTERRUPTIBLE
1487 every time to make the process really go to sleep */
1488 current->state = TASK_INTERRUPTIBLE;
1490 spin_lock_irqsave(&state->card->lock, flags);
1491 count = dmabuf->count;
1492 spin_unlock_irqrestore(&state->card->lock, flags);
1497 if (signal_pending(current))
1501 remove_wait_queue(&dmabuf->wait, &wait);
1502 current->state = TASK_RUNNING;
1506 tmo = (dmabuf->dmasize * HZ) / dmabuf->rate;
1507 tmo >>= sample_shift[dmabuf->fmt];
1508 tmo += (2048*HZ)/dmabuf->rate;
1510 if (!schedule_timeout(tmo ? tmo : 1) && tmo){
1511 printk(KERN_ERR "cs46xx: drain_dac, dma timeout? %d\n", count);
1515 remove_wait_queue(&dmabuf->wait, &wait);
1516 current->state = TASK_RUNNING;
1517 if (signal_pending(current))
1519 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()- -ERESTARTSYS\n"));
1521 * set to silence and let that clear the fifos.
1523 cs461x_clear_serial_FIFOs(card, CS_TYPE_DAC);
1524 return -ERESTARTSYS;
1527 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()- 0\n"));
1532 /* update buffer manangement pointers, especially, dmabuf->count and dmabuf->hwptr */
1533 static void cs_update_ptr(struct cs_card *card, int wake)
1535 struct cs_state *state;
1536 struct dmabuf *dmabuf;
1540 /* error handling and process wake up for ADC */
1541 state = card->states[0];
1544 dmabuf = &state->dmabuf;
1545 if (dmabuf->enable & ADC_RUNNING) {
1546 /* update hardware pointer */
1547 hwptr = cs_get_dma_addr(state);
1549 diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1550 CS_DBGOUT(CS_PARMS, 9, printk(
1551 "cs46xx: cs_update_ptr()+ ADC hwptr=%d diff=%d\n",
1553 dmabuf->hwptr = hwptr;
1554 dmabuf->total_bytes += diff;
1555 dmabuf->count += diff;
1556 if (dmabuf->count > dmabuf->dmasize)
1557 dmabuf->count = dmabuf->dmasize;
1561 if (wake && dmabuf->count >= (signed)dmabuf->fragsize)
1562 wake_up(&dmabuf->wait);
1565 if (wake && dmabuf->count > 0)
1566 wake_up(&dmabuf->wait);
1574 state = card->states[1];
1577 dmabuf = &state->dmabuf;
1578 /* error handling and process wake up for DAC */
1579 if (dmabuf->enable & DAC_RUNNING) {
1580 /* update hardware pointer */
1581 hwptr = cs_get_dma_addr(state);
1583 diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1584 CS_DBGOUT(CS_PARMS, 9, printk(
1585 "cs46xx: cs_update_ptr()+ DAC hwptr=%d diff=%d\n",
1587 dmabuf->hwptr = hwptr;
1588 dmabuf->total_bytes += diff;
1589 if (dmabuf->mapped) {
1590 dmabuf->count += diff;
1591 if (wake && dmabuf->count >= (signed)dmabuf->fragsize)
1592 wake_up(&dmabuf->wait);
1594 * other drivers use fragsize, but don't see any sense
1595 * in that, since dmasize is the buffer asked for
1598 if( dmabuf->count > dmabuf->dmasize)
1599 dmabuf->count &= dmabuf->dmasize-1;
1601 dmabuf->count -= diff;
1603 * backfill with silence and clear out the last
1604 * "diff" number of bytes.
1608 memset(dmabuf->rawbuf + hwptr - diff,
1609 (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80, diff);
1613 memset(dmabuf->rawbuf,
1614 (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
1616 memset((void *)((unsigned)dmabuf->rawbuf +
1617 dmabuf->dmasize + hwptr - diff),
1618 (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
1622 if (dmabuf->count < 0 || dmabuf->count > dmabuf->dmasize) {
1623 CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
1624 "cs46xx: ERROR DAC count<0 or count > dmasize (%d)\n",
1627 * buffer underrun or buffer overrun, reset the
1628 * count of bytes written back to 0.
1630 if(dmabuf->count < 0)
1635 if (wake && dmabuf->count < (signed)dmabuf->dmasize/2)
1636 wake_up(&dmabuf->wait);
1643 /* hold spinlock for the following! */
1644 static void cs_handle_midi(struct cs_card *card)
1651 while (!(cs461x_peekBA0(card, BA0_MIDSR) & MIDSR_RBE)) {
1652 ch = cs461x_peekBA0(card, BA0_MIDRP);
1653 if (card->midi.icnt < CS_MIDIINBUF) {
1654 card->midi.ibuf[card->midi.iwr] = ch;
1655 card->midi.iwr = (card->midi.iwr + 1) % CS_MIDIINBUF;
1661 wake_up(&card->midi.iwait);
1663 while (!(cs461x_peekBA0(card, BA0_MIDSR) & MIDSR_TBF) && card->midi.ocnt > 0) {
1664 temp1 = ( card->midi.obuf[card->midi.ord] ) & 0x000000ff;
1665 cs461x_pokeBA0(card, BA0_MIDWP,temp1);
1666 card->midi.ord = (card->midi.ord + 1) % CS_MIDIOUTBUF;
1668 if (card->midi.ocnt < CS_MIDIOUTBUF-16)
1672 wake_up(&card->midi.owait);
1675 static irqreturn_t cs_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1677 struct cs_card *card = (struct cs_card *)dev_id;
1678 /* Single channel card */
1679 struct cs_state *recstate = card->channel[0].state;
1680 struct cs_state *playstate = card->channel[1].state;
1683 CS_DBGOUT(CS_INTERRUPT, 9, printk("cs46xx: cs_interrupt()+ \n"));
1685 spin_lock(&card->lock);
1687 status = cs461x_peekBA0(card, BA0_HISR);
1689 if ((status & 0x7fffffff) == 0)
1691 cs461x_pokeBA0(card, BA0_HICR, HICR_CHGM|HICR_IEV);
1692 spin_unlock(&card->lock);
1693 return IRQ_HANDLED; /* Might be IRQ_NONE.. */
1697 * check for playback or capture interrupt only
1699 if( ((status & HISR_VC0) && playstate && playstate->dmabuf.ready) ||
1700 (((status & HISR_VC1) && recstate && recstate->dmabuf.ready)) )
1702 CS_DBGOUT(CS_INTERRUPT, 8, printk(
1703 "cs46xx: cs_interrupt() interrupt bit(s) set (0x%x)\n",status));
1704 cs_update_ptr(card, CS_TRUE);
1707 if( status & HISR_MIDI )
1708 cs_handle_midi(card);
1711 cs461x_pokeBA0(card, BA0_HICR, HICR_CHGM|HICR_IEV);
1712 spin_unlock(&card->lock);
1713 CS_DBGOUT(CS_INTERRUPT, 9, printk("cs46xx: cs_interrupt()- \n"));
1718 /**********************************************************************/
1720 static ssize_t cs_midi_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
1722 struct cs_card *card = (struct cs_card *)file->private_data;
1724 unsigned long flags;
1728 if (ppos != &file->f_pos)
1730 if (!access_ok(VERIFY_WRITE, buffer, count))
1734 spin_lock_irqsave(&card->lock, flags);
1735 ptr = card->midi.ird;
1736 cnt = CS_MIDIINBUF - ptr;
1737 if (card->midi.icnt < cnt)
1738 cnt = card->midi.icnt;
1739 spin_unlock_irqrestore(&card->lock, flags);
1743 if (file->f_flags & O_NONBLOCK)
1744 return ret ? ret : -EAGAIN;
1745 interruptible_sleep_on(&card->midi.iwait);
1746 if (signal_pending(current))
1747 return ret ? ret : -ERESTARTSYS;
1750 if (copy_to_user(buffer, card->midi.ibuf + ptr, cnt))
1751 return ret ? ret : -EFAULT;
1752 ptr = (ptr + cnt) % CS_MIDIINBUF;
1753 spin_lock_irqsave(&card->lock, flags);
1754 card->midi.ird = ptr;
1755 card->midi.icnt -= cnt;
1756 spin_unlock_irqrestore(&card->lock, flags);
1765 static ssize_t cs_midi_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
1767 struct cs_card *card = (struct cs_card *)file->private_data;
1769 unsigned long flags;
1773 if (ppos != &file->f_pos)
1775 if (!access_ok(VERIFY_READ, buffer, count))
1779 spin_lock_irqsave(&card->lock, flags);
1780 ptr = card->midi.owr;
1781 cnt = CS_MIDIOUTBUF - ptr;
1782 if (card->midi.ocnt + cnt > CS_MIDIOUTBUF)
1783 cnt = CS_MIDIOUTBUF - card->midi.ocnt;
1785 cs_handle_midi(card);
1786 spin_unlock_irqrestore(&card->lock, flags);
1790 if (file->f_flags & O_NONBLOCK)
1791 return ret ? ret : -EAGAIN;
1792 interruptible_sleep_on(&card->midi.owait);
1793 if (signal_pending(current))
1794 return ret ? ret : -ERESTARTSYS;
1797 if (copy_from_user(card->midi.obuf + ptr, buffer, cnt))
1798 return ret ? ret : -EFAULT;
1799 ptr = (ptr + cnt) % CS_MIDIOUTBUF;
1800 spin_lock_irqsave(&card->lock, flags);
1801 card->midi.owr = ptr;
1802 card->midi.ocnt += cnt;
1803 spin_unlock_irqrestore(&card->lock, flags);
1807 spin_lock_irqsave(&card->lock, flags);
1808 cs_handle_midi(card);
1809 spin_unlock_irqrestore(&card->lock, flags);
1815 static unsigned int cs_midi_poll(struct file *file, struct poll_table_struct *wait)
1817 struct cs_card *card = (struct cs_card *)file->private_data;
1818 unsigned long flags;
1819 unsigned int mask = 0;
1821 if (file->f_flags & FMODE_WRITE)
1822 poll_wait(file, &card->midi.owait, wait);
1823 if (file->f_flags & FMODE_READ)
1824 poll_wait(file, &card->midi.iwait, wait);
1825 spin_lock_irqsave(&card->lock, flags);
1826 if (file->f_flags & FMODE_READ) {
1827 if (card->midi.icnt > 0)
1828 mask |= POLLIN | POLLRDNORM;
1830 if (file->f_flags & FMODE_WRITE) {
1831 if (card->midi.ocnt < CS_MIDIOUTBUF)
1832 mask |= POLLOUT | POLLWRNORM;
1834 spin_unlock_irqrestore(&card->lock, flags);
1839 static int cs_midi_open(struct inode *inode, struct file *file)
1841 unsigned int minor = iminor(inode);
1842 struct cs_card *card=NULL;
1843 unsigned long flags;
1844 struct list_head *entry;
1846 list_for_each(entry, &cs46xx_devs)
1848 card = list_entry(entry, struct cs_card, list);
1849 if (card->dev_midi == minor)
1853 if (entry == &cs46xx_devs)
1857 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 2, printk(KERN_INFO
1858 "cs46xx: cs46xx_midi_open(): Error - unable to find card struct\n"));
1862 file->private_data = card;
1863 /* wait for device to become free */
1864 down(&card->midi.open_sem);
1865 while (card->midi.open_mode & file->f_mode) {
1866 if (file->f_flags & O_NONBLOCK) {
1867 up(&card->midi.open_sem);
1870 up(&card->midi.open_sem);
1871 interruptible_sleep_on(&card->midi.open_wait);
1872 if (signal_pending(current))
1873 return -ERESTARTSYS;
1874 down(&card->midi.open_sem);
1876 spin_lock_irqsave(&card->midi.lock, flags);
1877 if (!(card->midi.open_mode & (FMODE_READ | FMODE_WRITE))) {
1878 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
1879 card->midi.ord = card->midi.owr = card->midi.ocnt = 0;
1880 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
1881 cs461x_pokeBA0(card, BA0_MIDCR, 0x0000000f); /* Enable xmit, rcv. */
1882 cs461x_pokeBA0(card, BA0_HICR, HICR_IEV | HICR_CHGM); /* Enable interrupts */
1884 if (file->f_mode & FMODE_READ) {
1885 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
1887 if (file->f_mode & FMODE_WRITE) {
1888 card->midi.ord = card->midi.owr = card->midi.ocnt = 0;
1890 spin_unlock_irqrestore(&card->midi.lock, flags);
1891 card->midi.open_mode |= (file->f_mode & (FMODE_READ | FMODE_WRITE));
1892 up(&card->midi.open_sem);
1897 static int cs_midi_release(struct inode *inode, struct file *file)
1899 struct cs_card *card = (struct cs_card *)file->private_data;
1900 DECLARE_WAITQUEUE(wait, current);
1901 unsigned long flags;
1902 unsigned count, tmo;
1904 if (file->f_mode & FMODE_WRITE) {
1905 current->state = TASK_INTERRUPTIBLE;
1906 add_wait_queue(&card->midi.owait, &wait);
1908 spin_lock_irqsave(&card->midi.lock, flags);
1909 count = card->midi.ocnt;
1910 spin_unlock_irqrestore(&card->midi.lock, flags);
1913 if (signal_pending(current))
1915 if (file->f_flags & O_NONBLOCK)
1917 tmo = (count * HZ) / 3100;
1918 if (!schedule_timeout(tmo ? : 1) && tmo)
1919 printk(KERN_DEBUG "cs46xx: midi timed out??\n");
1921 remove_wait_queue(&card->midi.owait, &wait);
1922 current->state = TASK_RUNNING;
1924 down(&card->midi.open_sem);
1925 card->midi.open_mode &= (~(file->f_mode & (FMODE_READ | FMODE_WRITE)));
1926 up(&card->midi.open_sem);
1927 wake_up(&card->midi.open_wait);
1932 * Midi file operations struct.
1934 static /*const*/ struct file_operations cs_midi_fops = {
1935 CS_OWNER CS_THIS_MODULE
1936 .llseek = no_llseek,
1937 .read = cs_midi_read,
1938 .write = cs_midi_write,
1939 .poll = cs_midi_poll,
1940 .open = cs_midi_open,
1941 .release = cs_midi_release,
1946 * CopySamples copies 16-bit stereo signed samples from the source to the
1947 * destination, possibly converting down to unsigned 8-bit and/or mono.
1948 * count specifies the number of output bytes to write.
1952 * dst - Pointer to a destination buffer.
1953 * src - Pointer to a source buffer
1954 * count - The number of bytes to copy into the destination buffer.
1955 * fmt - CS_FMT_16BIT and/or CS_FMT_STEREO bits
1956 * dmabuf - pointer to the dma buffer structure
1958 * NOTES: only call this routine if the output desired is not 16 Signed Stereo
1962 static void CopySamples(char *dst, char *src, int count, unsigned fmt,
1963 struct dmabuf *dmabuf)
1967 s16 *psSrc=(s16 *)src;
1968 s16 *psDst=(s16 *)dst;
1969 u8 *pucDst=(u8 *)dst;
1971 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs46xx: CopySamples()+ ") );
1972 CS_DBGOUT(CS_WAVE_READ, 8, printk(KERN_INFO
1973 " dst=0x%x src=0x%x count=%d fmt=0x%x\n",
1974 (unsigned)dst,(unsigned)src,(unsigned)count,(unsigned)fmt) );
1977 * See if the data should be output as 8-bit unsigned stereo.
1979 if((fmt & CS_FMT_STEREO) && !(fmt & CS_FMT_16BIT))
1982 * Convert each 16-bit signed stereo sample to 8-bit unsigned
1983 * stereo using rounding.
1989 *(pucDst++) = (u8)(((s16)(*psSrc++) + (s16)0x8000) >> 8);
1993 * See if the data should be output at 8-bit unsigned mono.
1995 else if(!(fmt & CS_FMT_STEREO) && !(fmt & CS_FMT_16BIT))
1998 * Convert each 16-bit signed stereo sample to 8-bit unsigned
1999 * mono using averaging and rounding.
2005 s32AudioSample = ((*psSrc)+(*(psSrc + 1)))/2 + (s32)0x80;
2006 if(s32AudioSample > 0x7fff)
2007 s32AudioSample = 0x7fff;
2008 *(pucDst++) = (u8)(((s16)s32AudioSample + (s16)0x8000) >> 8);
2013 * See if the data should be output at 16-bit signed mono.
2015 else if(!(fmt & CS_FMT_STEREO) && (fmt & CS_FMT_16BIT))
2018 * Convert each 16-bit signed stereo sample to 16-bit signed
2019 * mono using averaging.
2025 *(psDst++) = (s16)((*psSrc)+(*(psSrc + 1)))/2;
2033 * replacement for the standard copy_to_user, to allow for a conversion from
2034 * 16 bit to 8 bit and from stereo to mono, if the record conversion is active.
2035 * The current CS46xx/CS4280 static image only records in 16bit unsigned Stereo,
2036 * so we convert from any of the other format combinations.
2038 static unsigned cs_copy_to_user(
2045 struct dmabuf *dmabuf = &s->dmabuf;
2046 void *src = hwsrc; /* default to the standard destination buffer addr */
2048 CS_DBGOUT(CS_FUNCTION, 6, printk(KERN_INFO
2049 "cs_copy_to_user()+ fmt=0x%x cnt=%d dest=%p\n",
2050 dmabuf->fmt,(unsigned)cnt,dest) );
2052 if(cnt > dmabuf->dmasize)
2054 cnt = dmabuf->dmasize;
2061 if(dmabuf->divisor != 1)
2063 if(!dmabuf->tmpbuff)
2065 *copied = cnt/dmabuf->divisor;
2069 CopySamples((char *)dmabuf->tmpbuff, (char *)hwsrc, cnt,
2070 dmabuf->fmt, dmabuf);
2071 src = dmabuf->tmpbuff;
2072 cnt = cnt/dmabuf->divisor;
2074 if (copy_to_user(dest, src, cnt))
2076 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_ERR
2077 "cs46xx: cs_copy_to_user()- fault dest=%p src=%p cnt=%d\n",
2083 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO
2084 "cs46xx: cs_copy_to_user()- copied bytes is %d \n",cnt) );
2088 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be copied to
2089 the user's buffer. it is filled by the dma machine and drained by this loop. */
2090 static ssize_t cs_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
2092 struct cs_card *card = (struct cs_card *) file->private_data;
2093 struct cs_state *state;
2094 DECLARE_WAITQUEUE(wait, current);
2095 struct dmabuf *dmabuf;
2097 unsigned long flags;
2102 CS_DBGOUT(CS_WAVE_READ | CS_FUNCTION, 4,
2103 printk("cs46xx: cs_read()+ %d\n",count) );
2104 state = (struct cs_state *)card->states[0];
2107 dmabuf = &state->dmabuf;
2109 if (ppos != &file->f_pos)
2113 if (!access_ok(VERIFY_WRITE, buffer, count))
2117 if (!dmabuf->ready && (ret = __prog_dmabuf(state)))
2120 add_wait_queue(&state->dmabuf.wait, &wait);
2122 while(!(card->pm.flags & CS46XX_PM_IDLE))
2125 if (signal_pending(current)) {
2126 if(!ret) ret = -ERESTARTSYS;
2130 spin_lock_irqsave(&state->card->lock, flags);
2131 swptr = dmabuf->swptr;
2132 cnt = dmabuf->dmasize - swptr;
2133 if (dmabuf->count < cnt)
2134 cnt = dmabuf->count;
2136 __set_current_state(TASK_INTERRUPTIBLE);
2137 spin_unlock_irqrestore(&state->card->lock, flags);
2139 if (cnt > (count * dmabuf->divisor))
2140 cnt = count * dmabuf->divisor;
2142 /* buffer is empty, start the dma machine and wait for data to be
2145 if (file->f_flags & O_NONBLOCK) {
2146 if (!ret) ret = -EAGAIN;
2151 if (signal_pending(current)) {
2152 if(!ret) ret = -ERESTARTSYS;
2165 CS_DBGOUT(CS_WAVE_READ, 2, printk(KERN_INFO
2166 "_read() copy_to cnt=%d count=%d ", cnt,count) );
2167 CS_DBGOUT(CS_WAVE_READ, 8, printk(KERN_INFO
2168 " .dmasize=%d .count=%d buffer=%p ret=%d\n",
2169 dmabuf->dmasize,dmabuf->count,buffer,ret) );
2171 if (cs_copy_to_user(state, buffer,
2172 (void *)((unsigned)dmabuf->rawbuf + swptr), cnt, &copied))
2174 if (!ret) ret = -EFAULT;
2177 swptr = (swptr + cnt) % dmabuf->dmasize;
2178 spin_lock_irqsave(&card->lock, flags);
2179 dmabuf->swptr = swptr;
2180 dmabuf->count -= cnt;
2181 spin_unlock_irqrestore(&card->lock, flags);
2188 remove_wait_queue(&state->dmabuf.wait, &wait);
2191 set_current_state(TASK_RUNNING);
2192 CS_DBGOUT(CS_WAVE_READ | CS_FUNCTION, 4,
2193 printk("cs46xx: cs_read()- %d\n",ret) );
2197 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be dma to
2198 the soundcard. it is drained by the dma machine and filled by this loop. */
2199 static ssize_t cs_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
2201 struct cs_card *card = (struct cs_card *) file->private_data;
2202 struct cs_state *state;
2203 DECLARE_WAITQUEUE(wait, current);
2204 struct dmabuf *dmabuf;
2206 unsigned long flags;
2210 CS_DBGOUT(CS_WAVE_WRITE | CS_FUNCTION, 4,
2211 printk("cs46xx: cs_write called, count = %d\n", count) );
2212 state = (struct cs_state *)card->states[1];
2215 if (!access_ok(VERIFY_READ, buffer, count))
2217 dmabuf = &state->dmabuf;
2219 if (ppos != &file->f_pos)
2229 if (!dmabuf->ready && (ret = __prog_dmabuf(state)))
2231 add_wait_queue(&state->dmabuf.wait, &wait);
2234 * Start the loop to read from the user's buffer and write to the dma buffer.
2235 * check for PM events and underrun/overrun in the loop.
2238 while(!(card->pm.flags & CS46XX_PM_IDLE))
2241 if (signal_pending(current)) {
2242 if(!ret) ret = -ERESTARTSYS;
2246 spin_lock_irqsave(&state->card->lock, flags);
2247 if (dmabuf->count < 0) {
2248 /* buffer underrun, we are recovering from sleep_on_timeout,
2249 resync hwptr and swptr */
2251 dmabuf->swptr = dmabuf->hwptr;
2253 if (dmabuf->underrun)
2255 dmabuf->underrun = 0;
2256 dmabuf->hwptr = cs_get_dma_addr(state);
2257 dmabuf->swptr = dmabuf->hwptr;
2260 swptr = dmabuf->swptr;
2261 cnt = dmabuf->dmasize - swptr;
2262 if (dmabuf->count + cnt > dmabuf->dmasize)
2263 cnt = dmabuf->dmasize - dmabuf->count;
2265 __set_current_state(TASK_INTERRUPTIBLE);
2266 spin_unlock_irqrestore(&state->card->lock, flags);
2271 /* buffer is full, start the dma machine and wait for data to be
2274 if (file->f_flags & O_NONBLOCK) {
2275 if (!ret) ret = -EAGAIN;
2280 if (signal_pending(current)) {
2281 if(!ret) ret = -ERESTARTSYS;
2293 if (copy_from_user(dmabuf->rawbuf + swptr, buffer, cnt)) {
2294 if (!ret) ret = -EFAULT;
2297 spin_lock_irqsave(&state->card->lock, flags);
2298 swptr = (swptr + cnt) % dmabuf->dmasize;
2299 dmabuf->swptr = swptr;
2300 dmabuf->count += cnt;
2301 if(dmabuf->count > dmabuf->dmasize)
2303 CS_DBGOUT(CS_WAVE_WRITE | CS_ERROR, 2, printk(
2304 "cs46xx: cs_write() d->count > dmasize - resetting\n"));
2305 dmabuf->count = dmabuf->dmasize;
2307 dmabuf->endcleared = 0;
2308 spin_unlock_irqrestore(&state->card->lock, flags);
2317 remove_wait_queue(&state->dmabuf.wait, &wait);
2318 set_current_state(TASK_RUNNING);
2320 CS_DBGOUT(CS_WAVE_WRITE | CS_FUNCTION, 2,
2321 printk("cs46xx: cs_write()- ret=0x%x\n", ret) );
2325 static unsigned int cs_poll(struct file *file, struct poll_table_struct *wait)
2327 struct cs_card *card = (struct cs_card *)file->private_data;
2328 struct dmabuf *dmabuf;
2329 struct cs_state *state;
2331 unsigned long flags;
2332 unsigned int mask = 0;
2334 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_poll()+ \n"));
2335 if (!(file->f_mode & (FMODE_WRITE | FMODE_READ)))
2339 if (file->f_mode & FMODE_WRITE)
2341 state = card->states[1];
2344 dmabuf = &state->dmabuf;
2345 poll_wait(file, &dmabuf->wait, wait);
2348 if (file->f_mode & FMODE_READ)
2350 state = card->states[0];
2353 dmabuf = &state->dmabuf;
2354 poll_wait(file, &dmabuf->wait, wait);
2358 spin_lock_irqsave(&card->lock, flags);
2359 cs_update_ptr(card, CS_FALSE);
2360 if (file->f_mode & FMODE_READ) {
2361 state = card->states[0];
2364 dmabuf = &state->dmabuf;
2365 if (dmabuf->count >= (signed)dmabuf->fragsize)
2366 mask |= POLLIN | POLLRDNORM;
2369 if (file->f_mode & FMODE_WRITE) {
2370 state = card->states[1];
2373 dmabuf = &state->dmabuf;
2374 if (dmabuf->mapped) {
2375 if (dmabuf->count >= (signed)dmabuf->fragsize)
2376 mask |= POLLOUT | POLLWRNORM;
2378 if ((signed)dmabuf->dmasize >= dmabuf->count
2379 + (signed)dmabuf->fragsize)
2380 mask |= POLLOUT | POLLWRNORM;
2384 spin_unlock_irqrestore(&card->lock, flags);
2386 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_poll()- (0x%x) \n",
2392 * We let users mmap the ring buffer. Its not the real DMA buffer but
2393 * that side of the code is hidden in the IRQ handling. We do a software
2394 * emulation of DMA from a 64K or so buffer into a 2K FIFO.
2395 * (the hardware probably deserves a moan here but Crystal send me nice
2399 static int cs_mmap(struct file *file, struct vm_area_struct *vma)
2401 struct cs_card *card = (struct cs_card *)file->private_data;
2402 struct cs_state *state;
2403 struct dmabuf *dmabuf;
2407 CS_DBGOUT(CS_FUNCTION | CS_PARMS, 2, printk("cs46xx: cs_mmap()+ file=0x%x %s %s\n",
2408 (unsigned)file, vma->vm_flags & VM_WRITE ? "VM_WRITE" : "",
2409 vma->vm_flags & VM_READ ? "VM_READ" : "") );
2411 if (vma->vm_flags & VM_WRITE) {
2412 state = card->states[1];
2415 CS_DBGOUT(CS_OPEN, 2, printk(
2416 "cs46xx: cs_mmap() VM_WRITE - state TRUE prog_dmabuf DAC\n") );
2417 if ((ret = prog_dmabuf(state)) != 0)
2420 } else if (vma->vm_flags & VM_READ) {
2421 state = card->states[0];
2424 CS_DBGOUT(CS_OPEN, 2, printk(
2425 "cs46xx: cs_mmap() VM_READ - state TRUE prog_dmabuf ADC\n") );
2426 if ((ret = prog_dmabuf(state)) != 0)
2430 CS_DBGOUT(CS_ERROR, 2, printk(
2431 "cs46xx: cs_mmap() return -EINVAL\n") );
2436 * For now ONLY support playback, but seems like the only way to use
2437 * mmap() is to open an FD with RDWR, just read or just write access
2438 * does not function, get an error back from the kernel.
2439 * Also, QuakeIII opens with RDWR! So, there must be something
2440 * to needing read/write access mapping. So, allow read/write but
2443 state = card->states[1];
2444 if(!(unsigned)state)
2451 dmabuf = &state->dmabuf;
2452 if (cs4x_pgoff(vma) != 0)
2457 size = vma->vm_end - vma->vm_start;
2459 CS_DBGOUT(CS_PARMS, 2, printk("cs46xx: cs_mmap(): size=%d\n",(unsigned)size) );
2461 if (size > (PAGE_SIZE << dmabuf->buforder))
2466 if (remap_page_range(vma, vma->vm_start, virt_to_phys(dmabuf->rawbuf),
2467 size, vma->vm_page_prot))
2474 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_mmap()-\n") );
2480 static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
2482 struct cs_card *card = (struct cs_card *)file->private_data;
2483 struct cs_state *state;
2484 struct dmabuf *dmabuf=0;
2485 unsigned long flags;
2486 audio_buf_info abinfo;
2488 int val, valsave, mapped, ret;
2489 void __user *argp = (void __user *)arg;
2490 int __user *p = argp;
2492 state = (struct cs_state *)card->states[0];
2495 dmabuf = &state->dmabuf;
2496 mapped = (file->f_mode & FMODE_READ) && dmabuf->mapped;
2498 state = (struct cs_state *)card->states[1];
2501 dmabuf = &state->dmabuf;
2502 mapped |= (file->f_mode & FMODE_WRITE) && dmabuf->mapped;
2511 case OSS_GETVERSION:
2512 return put_user(SOUND_VERSION, p);
2514 case SNDCTL_DSP_RESET:
2515 /* FIXME: spin_lock ? */
2516 if (file->f_mode & FMODE_WRITE) {
2517 state = (struct cs_state *)card->states[1];
2520 dmabuf = &state->dmabuf;
2522 synchronize_irq(card->irq);
2524 resync_dma_ptrs(state);
2525 dmabuf->swptr = dmabuf->hwptr = 0;
2526 dmabuf->count = dmabuf->total_bytes = 0;
2531 if (file->f_mode & FMODE_READ) {
2532 state = (struct cs_state *)card->states[0];
2535 dmabuf = &state->dmabuf;
2537 synchronize_irq(card->irq);
2538 resync_dma_ptrs(state);
2540 dmabuf->swptr = dmabuf->hwptr = 0;
2541 dmabuf->count = dmabuf->total_bytes = 0;
2546 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_RESET()-\n") );
2549 case SNDCTL_DSP_SYNC:
2550 if (file->f_mode & FMODE_WRITE)
2551 return drain_dac(state, file->f_flags & O_NONBLOCK);
2554 case SNDCTL_DSP_SPEED: /* set sample rate */
2555 if (get_user(val, p))
2558 if (file->f_mode & FMODE_READ) {
2559 state = (struct cs_state *)card->states[0];
2562 dmabuf = &state->dmabuf;
2566 cs_set_adc_rate(state, val);
2567 cs_set_divisor(dmabuf);
2570 if (file->f_mode & FMODE_WRITE) {
2571 state = (struct cs_state *)card->states[1];
2574 dmabuf = &state->dmabuf;
2578 cs_set_dac_rate(state, val);
2579 cs_set_divisor(dmabuf);
2582 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2583 "cs46xx: cs_ioctl() DSP_SPEED %s %s %d\n",
2584 file->f_mode & FMODE_WRITE ? "DAC" : "",
2585 file->f_mode & FMODE_READ ? "ADC" : "",
2587 return put_user(dmabuf->rate, p);
2589 return put_user(0, p);
2591 case SNDCTL_DSP_STEREO: /* set stereo or mono channel */
2592 if (get_user(val, p))
2594 if (file->f_mode & FMODE_WRITE) {
2595 state = (struct cs_state *)card->states[1];
2598 dmabuf = &state->dmabuf;
2603 dmabuf->fmt |= CS_FMT_STEREO;
2605 dmabuf->fmt &= ~CS_FMT_STEREO;
2606 cs_set_divisor(dmabuf);
2607 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2608 "cs46xx: DSP_STEREO() DAC %s\n",
2609 (dmabuf->fmt & CS_FMT_STEREO) ?
2613 if (file->f_mode & FMODE_READ) {
2614 state = (struct cs_state *)card->states[0];
2617 dmabuf = &state->dmabuf;
2622 dmabuf->fmt |= CS_FMT_STEREO;
2624 dmabuf->fmt &= ~CS_FMT_STEREO;
2625 cs_set_divisor(dmabuf);
2626 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2627 "cs46xx: DSP_STEREO() ADC %s\n",
2628 (dmabuf->fmt & CS_FMT_STEREO) ?
2634 case SNDCTL_DSP_GETBLKSIZE:
2635 if (file->f_mode & FMODE_WRITE) {
2636 state = (struct cs_state *)card->states[1];
2639 dmabuf = &state->dmabuf;
2640 if ((val = prog_dmabuf(state)))
2642 return put_user(dmabuf->fragsize, p);
2645 if (file->f_mode & FMODE_READ) {
2646 state = (struct cs_state *)card->states[0];
2649 dmabuf = &state->dmabuf;
2650 if ((val = prog_dmabuf(state)))
2652 return put_user(dmabuf->fragsize/dmabuf->divisor,
2656 return put_user(0, p);
2658 case SNDCTL_DSP_GETFMTS: /* Returns a mask of supported sample format*/
2659 return put_user(AFMT_S16_LE | AFMT_U8, p);
2661 case SNDCTL_DSP_SETFMT: /* Select sample format */
2662 if (get_user(val, p))
2664 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2665 "cs46xx: cs_ioctl() DSP_SETFMT %s %s %s %s\n",
2666 file->f_mode & FMODE_WRITE ? "DAC" : "",
2667 file->f_mode & FMODE_READ ? "ADC" : "",
2668 val == AFMT_S16_LE ? "16Bit Signed" : "",
2669 val == AFMT_U8 ? "8Bit Unsigned" : "") );
2671 if (val != AFMT_QUERY) {
2672 if(val==AFMT_S16_LE || val==AFMT_U8)
2674 if (file->f_mode & FMODE_WRITE) {
2675 state = (struct cs_state *)card->states[1];
2678 dmabuf = &state->dmabuf;
2682 if(val==AFMT_S16_LE)
2683 dmabuf->fmt |= CS_FMT_16BIT;
2685 dmabuf->fmt &= ~CS_FMT_16BIT;
2686 cs_set_divisor(dmabuf);
2687 if((ret = prog_dmabuf(state)))
2691 if (file->f_mode & FMODE_READ) {
2693 state = (struct cs_state *)card->states[0];
2696 dmabuf = &state->dmabuf;
2700 if(val==AFMT_S16_LE)
2701 dmabuf->fmt |= CS_FMT_16BIT;
2703 dmabuf->fmt &= ~CS_FMT_16BIT;
2704 cs_set_divisor(dmabuf);
2705 if((ret = prog_dmabuf(state)))
2712 CS_DBGOUT(CS_IOCTL | CS_ERROR, 2, printk(
2713 "cs46xx: DSP_SETFMT() Unsupported format (0x%x)\n",
2719 if(file->f_mode & FMODE_WRITE)
2721 state = (struct cs_state *)card->states[1];
2723 dmabuf = &state->dmabuf;
2725 else if(file->f_mode & FMODE_READ)
2727 state = (struct cs_state *)card->states[0];
2729 dmabuf = &state->dmabuf;
2734 if(dmabuf->fmt & CS_FMT_16BIT)
2735 return put_user(AFMT_S16_LE, p);
2737 return put_user(AFMT_U8, p);
2739 return put_user(0, p);
2741 case SNDCTL_DSP_CHANNELS:
2742 if (get_user(val, p))
2745 if (file->f_mode & FMODE_WRITE) {
2746 state = (struct cs_state *)card->states[1];
2749 dmabuf = &state->dmabuf;
2754 dmabuf->fmt |= CS_FMT_STEREO;
2756 dmabuf->fmt &= ~CS_FMT_STEREO;
2757 cs_set_divisor(dmabuf);
2758 if (prog_dmabuf(state))
2762 if (file->f_mode & FMODE_READ) {
2763 state = (struct cs_state *)card->states[0];
2766 dmabuf = &state->dmabuf;
2771 dmabuf->fmt |= CS_FMT_STEREO;
2773 dmabuf->fmt &= ~CS_FMT_STEREO;
2774 cs_set_divisor(dmabuf);
2775 if (prog_dmabuf(state))
2780 return put_user((dmabuf->fmt & CS_FMT_STEREO) ? 2 : 1,
2783 case SNDCTL_DSP_POST:
2785 * There will be a longer than normal pause in the data.
2786 * so... do nothing, because there is nothing that we can do.
2790 case SNDCTL_DSP_SUBDIVIDE:
2791 if (file->f_mode & FMODE_WRITE) {
2792 state = (struct cs_state *)card->states[1];
2795 dmabuf = &state->dmabuf;
2796 if (dmabuf->subdivision)
2798 if (get_user(val, p))
2800 if (val != 1 && val != 2)
2802 dmabuf->subdivision = val;
2805 if (file->f_mode & FMODE_READ) {
2806 state = (struct cs_state *)card->states[0];
2809 dmabuf = &state->dmabuf;
2810 if (dmabuf->subdivision)
2812 if (get_user(val, p))
2814 if (val != 1 && val != 2)
2816 dmabuf->subdivision = val;
2821 case SNDCTL_DSP_SETFRAGMENT:
2822 if (get_user(val, p))
2825 if (file->f_mode & FMODE_WRITE) {
2826 state = (struct cs_state *)card->states[1];
2829 dmabuf = &state->dmabuf;
2830 dmabuf->ossfragshift = val & 0xffff;
2831 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2834 if (file->f_mode & FMODE_READ) {
2835 state = (struct cs_state *)card->states[0];
2838 dmabuf = &state->dmabuf;
2839 dmabuf->ossfragshift = val & 0xffff;
2840 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2845 case SNDCTL_DSP_GETOSPACE:
2846 if (!(file->f_mode & FMODE_WRITE))
2848 state = (struct cs_state *)card->states[1];
2851 dmabuf = &state->dmabuf;
2852 spin_lock_irqsave(&state->card->lock, flags);
2853 cs_update_ptr(card, CS_TRUE);
2854 abinfo.fragsize = dmabuf->fragsize;
2855 abinfo.fragstotal = dmabuf->numfrag;
2857 * for mmap we always have total space available
2860 abinfo.bytes = dmabuf->dmasize;
2862 abinfo.bytes = dmabuf->dmasize - dmabuf->count;
2864 abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
2865 spin_unlock_irqrestore(&state->card->lock, flags);
2866 return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2870 case SNDCTL_DSP_GETISPACE:
2871 if (!(file->f_mode & FMODE_READ))
2873 state = (struct cs_state *)card->states[0];
2876 dmabuf = &state->dmabuf;
2877 spin_lock_irqsave(&state->card->lock, flags);
2878 cs_update_ptr(card, CS_TRUE);
2879 abinfo.fragsize = dmabuf->fragsize/dmabuf->divisor;
2880 abinfo.bytes = dmabuf->count/dmabuf->divisor;
2881 abinfo.fragstotal = dmabuf->numfrag;
2882 abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
2883 spin_unlock_irqrestore(&state->card->lock, flags);
2884 return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2888 case SNDCTL_DSP_NONBLOCK:
2889 file->f_flags |= O_NONBLOCK;
2892 case SNDCTL_DSP_GETCAPS:
2893 return put_user(DSP_CAP_REALTIME|DSP_CAP_TRIGGER|DSP_CAP_MMAP,
2896 case SNDCTL_DSP_GETTRIGGER:
2898 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_GETTRIGGER()+\n") );
2899 if (file->f_mode & FMODE_WRITE)
2901 state = (struct cs_state *)card->states[1];
2904 dmabuf = &state->dmabuf;
2905 if(dmabuf->enable & DAC_RUNNING)
2906 val |= PCM_ENABLE_INPUT;
2909 if (file->f_mode & FMODE_READ)
2913 state = (struct cs_state *)card->states[0];
2914 dmabuf = &state->dmabuf;
2915 if(dmabuf->enable & ADC_RUNNING)
2916 val |= PCM_ENABLE_OUTPUT;
2919 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_GETTRIGGER()- val=0x%x\n",val) );
2920 return put_user(val, p);
2922 case SNDCTL_DSP_SETTRIGGER:
2923 if (get_user(val, p))
2925 if (file->f_mode & FMODE_READ) {
2926 state = (struct cs_state *)card->states[0];
2929 dmabuf = &state->dmabuf;
2930 if (val & PCM_ENABLE_INPUT) {
2931 if (!dmabuf->ready && (ret = prog_dmabuf(state)))
2938 if (file->f_mode & FMODE_WRITE) {
2939 state = (struct cs_state *)card->states[1];
2942 dmabuf = &state->dmabuf;
2943 if (val & PCM_ENABLE_OUTPUT) {
2944 if (!dmabuf->ready && (ret = prog_dmabuf(state)))
2953 case SNDCTL_DSP_GETIPTR:
2954 if (!(file->f_mode & FMODE_READ))
2956 state = (struct cs_state *)card->states[0];
2959 dmabuf = &state->dmabuf;
2960 spin_lock_irqsave(&state->card->lock, flags);
2961 cs_update_ptr(card, CS_TRUE);
2962 cinfo.bytes = dmabuf->total_bytes/dmabuf->divisor;
2963 cinfo.blocks = dmabuf->count/dmabuf->divisor >> dmabuf->fragshift;
2964 cinfo.ptr = dmabuf->hwptr/dmabuf->divisor;
2965 spin_unlock_irqrestore(&state->card->lock, flags);
2966 if (copy_to_user(argp, &cinfo, sizeof(cinfo)))
2972 case SNDCTL_DSP_GETOPTR:
2973 if (!(file->f_mode & FMODE_WRITE))
2975 state = (struct cs_state *)card->states[1];
2978 dmabuf = &state->dmabuf;
2979 spin_lock_irqsave(&state->card->lock, flags);
2980 cs_update_ptr(card, CS_TRUE);
2981 cinfo.bytes = dmabuf->total_bytes;
2984 cinfo.blocks = (cinfo.bytes >> dmabuf->fragshift)
2986 CS_DBGOUT(CS_PARMS, 8,
2987 printk("total_bytes=%d blocks=%d dmabuf->blocks=%d\n",
2988 cinfo.bytes,cinfo.blocks,dmabuf->blocks) );
2989 dmabuf->blocks = cinfo.bytes >> dmabuf->fragshift;
2993 cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
2995 cinfo.ptr = dmabuf->hwptr;
2997 CS_DBGOUT(CS_PARMS, 4, printk(
2998 "cs46xx: GETOPTR bytes=%d blocks=%d ptr=%d\n",
2999 cinfo.bytes,cinfo.blocks,cinfo.ptr) );
3000 spin_unlock_irqrestore(&state->card->lock, flags);
3001 if (copy_to_user(argp, &cinfo, sizeof(cinfo)))
3007 case SNDCTL_DSP_SETDUPLEX:
3010 case SNDCTL_DSP_GETODELAY:
3011 if (!(file->f_mode & FMODE_WRITE))
3013 state = (struct cs_state *)card->states[1];
3016 dmabuf = &state->dmabuf;
3017 spin_lock_irqsave(&state->card->lock, flags);
3018 cs_update_ptr(card, CS_TRUE);
3019 val = dmabuf->count;
3020 spin_unlock_irqrestore(&state->card->lock, flags);
3024 return put_user(val, p);
3026 case SOUND_PCM_READ_RATE:
3027 if(file->f_mode & FMODE_READ)
3028 state = (struct cs_state *)card->states[0];
3030 state = (struct cs_state *)card->states[1];
3033 dmabuf = &state->dmabuf;
3034 return put_user(dmabuf->rate, p);
3036 return put_user(0, p);
3039 case SOUND_PCM_READ_CHANNELS:
3040 if(file->f_mode & FMODE_READ)
3041 state = (struct cs_state *)card->states[0];
3043 state = (struct cs_state *)card->states[1];
3046 dmabuf = &state->dmabuf;
3047 return put_user((dmabuf->fmt & CS_FMT_STEREO) ? 2 : 1,
3050 return put_user(0, p);
3052 case SOUND_PCM_READ_BITS:
3053 if(file->f_mode & FMODE_READ)
3054 state = (struct cs_state *)card->states[0];
3056 state = (struct cs_state *)card->states[1];
3059 dmabuf = &state->dmabuf;
3060 return put_user((dmabuf->fmt & CS_FMT_16BIT) ?
3061 AFMT_S16_LE : AFMT_U8, p);
3064 return put_user(0, p);
3066 case SNDCTL_DSP_MAPINBUF:
3067 case SNDCTL_DSP_MAPOUTBUF:
3068 case SNDCTL_DSP_SETSYNCRO:
3069 case SOUND_PCM_WRITE_FILTER:
3070 case SOUND_PCM_READ_FILTER:
3078 * AMP control - null AMP
3081 static void amp_none(struct cs_card *card, int change)
3089 static void amp_voyetra(struct cs_card *card, int change)
3091 /* Manage the EAPD bit on the Crystal 4297
3092 and the Analog AD1885 */
3094 int old=card->amplifier;
3096 card->amplifier+=change;
3097 if(card->amplifier && !old)
3099 /* Turn the EAPD amp on */
3100 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL,
3101 cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) |
3104 else if(old && !card->amplifier)
3106 /* Turn the EAPD amp off */
3107 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL,
3108 cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
3115 * Game Theatre XP card - EGPIO[2] is used to enable the external amp.
3118 static void amp_hercules(struct cs_card *card, int change)
3120 int old=card->amplifier;
3123 CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
3124 "cs46xx: amp_hercules() called before initialized.\n"));
3127 card->amplifier+=change;
3128 if( (card->amplifier && !old) && !(hercules_egpio_disable))
3130 CS_DBGOUT(CS_PARMS, 4, printk(KERN_INFO
3131 "cs46xx: amp_hercules() external amp enabled\n"));
3132 cs461x_pokeBA0(card, BA0_EGPIODR,
3133 EGPIODR_GPOE2); /* enable EGPIO2 output */
3134 cs461x_pokeBA0(card, BA0_EGPIOPTR,
3135 EGPIOPTR_GPPT2); /* open-drain on output */
3137 else if(old && !card->amplifier)
3139 CS_DBGOUT(CS_PARMS, 4, printk(KERN_INFO
3140 "cs46xx: amp_hercules() external amp disabled\n"));
3141 cs461x_pokeBA0(card, BA0_EGPIODR, 0); /* disable */
3142 cs461x_pokeBA0(card, BA0_EGPIOPTR, 0); /* disable */
3147 * Handle the CLKRUN on a thinkpad. We must disable CLKRUN support
3148 * whenever we need to beat on the chip.
3150 * The original idea and code for this hack comes from David Kaiser at
3151 * Linuxcare. Perhaps one day Crystal will document their chips well
3152 * enough to make them useful.
3155 static void clkrun_hack(struct cs_card *card, int change)
3157 struct pci_dev *acpi_dev;
3161 int old=card->active;
3163 card->active+=change;
3165 acpi_dev = pci_find_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371AB_3, NULL);
3166 if(acpi_dev == NULL)
3167 return; /* Not a thinkpad thats for sure */
3169 /* Find the control port */
3170 pci_read_config_byte(acpi_dev, 0x41, &pp);
3173 /* Read ACPI port */
3174 control=inw(port+0x10);
3176 /* Flip CLKRUN off while running */
3177 if(!card->active && old)
3179 CS_DBGOUT(CS_PARMS , 9, printk( KERN_INFO
3180 "cs46xx: clkrun() enable clkrun - change=%d active=%d\n",
3181 change,card->active));
3182 outw(control|0x2000, port+0x10);
3187 * sometimes on a resume the bit is set, so always reset the bit.
3189 CS_DBGOUT(CS_PARMS , 9, printk( KERN_INFO
3190 "cs46xx: clkrun() disable clkrun - change=%d active=%d\n",
3191 change,card->active));
3192 outw(control&~0x2000, port+0x10);
3197 static int cs_open(struct inode *inode, struct file *file)
3199 struct cs_card *card = (struct cs_card *)file->private_data;
3200 struct cs_state *state = NULL;
3201 struct dmabuf *dmabuf = NULL;
3202 struct list_head *entry;
3203 unsigned int minor = iminor(inode);
3207 CS_DBGOUT(CS_OPEN | CS_FUNCTION, 2, printk("cs46xx: cs_open()+ file=0x%x %s %s\n",
3208 (unsigned)file, file->f_mode & FMODE_WRITE ? "FMODE_WRITE" : "",
3209 file->f_mode & FMODE_READ ? "FMODE_READ" : "") );
3211 list_for_each(entry, &cs46xx_devs)
3213 card = list_entry(entry, struct cs_card, list);
3215 if (!((card->dev_audio ^ minor) & ~0xf))
3218 if (entry == &cs46xx_devs)
3221 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 2, printk(KERN_INFO
3222 "cs46xx: cs_open(): Error - unable to find audio card struct\n"));
3227 * hardcode state[0] for capture, [1] for playback
3229 if(file->f_mode & FMODE_READ)
3231 CS_DBGOUT(CS_WAVE_READ, 2, printk("cs46xx: cs_open() FMODE_READ\n") );
3232 if (card->states[0] == NULL) {
3233 state = card->states[0] = (struct cs_state *)
3234 kmalloc(sizeof(struct cs_state), GFP_KERNEL);
3237 memset(state, 0, sizeof(struct cs_state));
3238 init_MUTEX(&state->sem);
3239 dmabuf = &state->dmabuf;
3240 dmabuf->pbuf = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
3241 if(dmabuf->pbuf==NULL)
3244 card->states[0]=NULL;
3250 state = card->states[0];
3251 if(state->open_mode & FMODE_READ)
3254 dmabuf->channel = card->alloc_rec_pcm_channel(card);
3256 if (dmabuf->channel == NULL) {
3257 kfree (card->states[0]);
3258 card->states[0] = NULL;
3262 /* Now turn on external AMP if needed */
3264 state->card->active_ctrl(state->card,1);
3265 state->card->amplifier_ctrl(state->card,1);
3267 if( (tmp = cs46xx_powerup(card, CS_POWER_ADC)) )
3269 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3270 "cs46xx: cs46xx_powerup of ADC failed (0x%x)\n",tmp) );
3274 dmabuf->channel->state = state;
3275 /* initialize the virtual channel */
3277 state->magic = CS_STATE_MAGIC;
3278 init_waitqueue_head(&dmabuf->wait);
3279 init_MUTEX(&state->open_sem);
3280 file->private_data = card;
3282 down(&state->open_sem);
3284 /* set default sample format. According to OSS Programmer's Guide /dev/dsp
3285 should be default to unsigned 8-bits, mono, with sample rate 8kHz and
3286 /dev/dspW will accept 16-bits sample */
3288 /* Default input is 8bit mono */
3289 dmabuf->fmt &= ~CS_FMT_MASK;
3290 dmabuf->type = CS_TYPE_ADC;
3291 dmabuf->ossfragshift = 0;
3292 dmabuf->ossmaxfrags = 0;
3293 dmabuf->subdivision = 0;
3294 cs_set_adc_rate(state, 8000);
3295 cs_set_divisor(dmabuf);
3297 state->open_mode |= FMODE_READ;
3298 up(&state->open_sem);
3300 if(file->f_mode & FMODE_WRITE)
3302 CS_DBGOUT(CS_OPEN, 2, printk("cs46xx: cs_open() FMODE_WRITE\n") );
3303 if (card->states[1] == NULL) {
3304 state = card->states[1] = (struct cs_state *)
3305 kmalloc(sizeof(struct cs_state), GFP_KERNEL);
3308 memset(state, 0, sizeof(struct cs_state));
3309 init_MUTEX(&state->sem);
3310 dmabuf = &state->dmabuf;
3311 dmabuf->pbuf = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
3312 if(dmabuf->pbuf==NULL)
3315 card->states[1]=NULL;
3321 state = card->states[1];
3322 if(state->open_mode & FMODE_WRITE)
3325 dmabuf->channel = card->alloc_pcm_channel(card);
3327 if (dmabuf->channel == NULL) {
3328 kfree (card->states[1]);
3329 card->states[1] = NULL;
3333 /* Now turn on external AMP if needed */
3335 state->card->active_ctrl(state->card,1);
3336 state->card->amplifier_ctrl(state->card,1);
3338 if( (tmp = cs46xx_powerup(card, CS_POWER_DAC)) )
3340 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3341 "cs46xx: cs46xx_powerup of DAC failed (0x%x)\n",tmp) );
3345 dmabuf->channel->state = state;
3346 /* initialize the virtual channel */
3348 state->magic = CS_STATE_MAGIC;
3349 init_waitqueue_head(&dmabuf->wait);
3350 init_MUTEX(&state->open_sem);
3351 file->private_data = card;
3353 down(&state->open_sem);
3355 /* set default sample format. According to OSS Programmer's Guide /dev/dsp
3356 should be default to unsigned 8-bits, mono, with sample rate 8kHz and
3357 /dev/dspW will accept 16-bits sample */
3359 /* Default output is 8bit mono. */
3360 dmabuf->fmt &= ~CS_FMT_MASK;
3361 dmabuf->type = CS_TYPE_DAC;
3362 dmabuf->ossfragshift = 0;
3363 dmabuf->ossmaxfrags = 0;
3364 dmabuf->subdivision = 0;
3365 cs_set_dac_rate(state, 8000);
3366 cs_set_divisor(dmabuf);
3368 state->open_mode |= FMODE_WRITE;
3369 up(&state->open_sem);
3370 if((ret = prog_dmabuf(state)))
3373 CS_DBGOUT(CS_OPEN | CS_FUNCTION, 2, printk("cs46xx: cs_open()- 0\n") );
3377 static int cs_release(struct inode *inode, struct file *file)
3379 struct cs_card *card = (struct cs_card *)file->private_data;
3380 struct dmabuf *dmabuf;
3381 struct cs_state *state;
3383 CS_DBGOUT(CS_RELEASE | CS_FUNCTION, 2, printk("cs46xx: cs_release()+ file=0x%x %s %s\n",
3384 (unsigned)file, file->f_mode & FMODE_WRITE ? "FMODE_WRITE" : "",
3385 file->f_mode & FMODE_READ ? "FMODE_READ" : "") );
3387 if (!(file->f_mode & (FMODE_WRITE | FMODE_READ)))
3391 state = card->states[1];
3394 if ( (state->open_mode & FMODE_WRITE) & (file->f_mode & FMODE_WRITE) )
3396 CS_DBGOUT(CS_RELEASE, 2, printk("cs46xx: cs_release() FMODE_WRITE\n") );
3397 dmabuf = &state->dmabuf;
3398 cs_clear_tail(state);
3399 drain_dac(state, file->f_flags & O_NONBLOCK);
3400 /* stop DMA state machine and free DMA buffers/channels */
3401 down(&state->open_sem);
3403 dealloc_dmabuf(state);
3404 state->card->free_pcm_channel(state->card, dmabuf->channel->num);
3405 free_page((unsigned long)state->dmabuf.pbuf);
3407 /* we're covered by the open_sem */
3408 up(&state->open_sem);
3409 state->card->states[state->virt] = NULL;
3410 state->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
3412 if( (tmp = cs461x_powerdown(card, CS_POWER_DAC, CS_FALSE )) )
3414 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
3415 "cs46xx: cs_release_mixdev() powerdown DAC failure (0x%x)\n",tmp) );
3418 /* Now turn off external AMP if needed */
3419 state->card->amplifier_ctrl(state->card, -1);
3420 state->card->active_ctrl(state->card, -1);
3426 state = card->states[0];
3429 if ( (state->open_mode & FMODE_READ) & (file->f_mode & FMODE_READ) )
3431 CS_DBGOUT(CS_RELEASE, 2, printk("cs46xx: cs_release() FMODE_READ\n") );
3432 dmabuf = &state->dmabuf;
3433 down(&state->open_sem);
3435 dealloc_dmabuf(state);
3436 state->card->free_pcm_channel(state->card, dmabuf->channel->num);
3437 free_page((unsigned long)state->dmabuf.pbuf);
3439 /* we're covered by the open_sem */
3440 up(&state->open_sem);
3441 state->card->states[state->virt] = NULL;
3442 state->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
3444 if( (tmp = cs461x_powerdown(card, CS_POWER_ADC, CS_FALSE )) )
3446 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
3447 "cs46xx: cs_release_mixdev() powerdown ADC failure (0x%x)\n",tmp) );
3450 /* Now turn off external AMP if needed */
3451 state->card->amplifier_ctrl(state->card, -1);
3452 state->card->active_ctrl(state->card, -1);
3458 CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 2, printk("cs46xx: cs_release()- 0\n") );
3462 static void printpm(struct cs_card *s)
3464 CS_DBGOUT(CS_PM, 9, printk("pm struct:\n"));
3465 CS_DBGOUT(CS_PM, 9, printk("flags:0x%x u32CLKCR1_SAVE: 0%x u32SSPMValue: 0x%x\n",
3466 (unsigned)s->pm.flags,s->pm.u32CLKCR1_SAVE,s->pm.u32SSPMValue));
3467 CS_DBGOUT(CS_PM, 9, printk("u32PPLVCvalue: 0x%x u32PPRVCvalue: 0x%x\n",
3468 s->pm.u32PPLVCvalue,s->pm.u32PPRVCvalue));
3469 CS_DBGOUT(CS_PM, 9, printk("u32FMLVCvalue: 0x%x u32FMRVCvalue: 0x%x\n",
3470 s->pm.u32FMLVCvalue,s->pm.u32FMRVCvalue));
3471 CS_DBGOUT(CS_PM, 9, printk("u32GPIORvalue: 0x%x u32JSCTLvalue: 0x%x\n",
3472 s->pm.u32GPIORvalue,s->pm.u32JSCTLvalue));
3473 CS_DBGOUT(CS_PM, 9, printk("u32SSCR: 0x%x u32SRCSA: 0x%x\n",
3474 s->pm.u32SSCR,s->pm.u32SRCSA));
3475 CS_DBGOUT(CS_PM, 9, printk("u32DacASR: 0x%x u32AdcASR: 0x%x\n",
3476 s->pm.u32DacASR,s->pm.u32AdcASR));
3477 CS_DBGOUT(CS_PM, 9, printk("u32DacSR: 0x%x u32AdcSR: 0x%x\n",
3478 s->pm.u32DacSR,s->pm.u32AdcSR));
3479 CS_DBGOUT(CS_PM, 9, printk("u32MIDCR_Save: 0x%x\n",
3480 s->pm.u32MIDCR_Save));
3481 CS_DBGOUT(CS_PM, 9, printk("u32AC97_powerdown: 0x%x _general_purpose 0x%x\n",
3482 s->pm.u32AC97_powerdown,s->pm.u32AC97_general_purpose));
3483 CS_DBGOUT(CS_PM, 9, printk("u32AC97_master_volume: 0x%x\n",
3484 s->pm.u32AC97_master_volume));
3485 CS_DBGOUT(CS_PM, 9, printk("u32AC97_headphone_volume: 0x%x\n",
3486 s->pm.u32AC97_headphone_volume));
3487 CS_DBGOUT(CS_PM, 9, printk("u32AC97_master_volume_mono: 0x%x\n",
3488 s->pm.u32AC97_master_volume_mono));
3489 CS_DBGOUT(CS_PM, 9, printk("u32AC97_pcm_out_volume: 0x%x\n",
3490 s->pm.u32AC97_pcm_out_volume));
3491 CS_DBGOUT(CS_PM, 9, printk("dmabuf_swptr_play: 0x%x dmabuf_count_play: %d\n",
3492 s->pm.dmabuf_swptr_play,s->pm.dmabuf_count_play));
3493 CS_DBGOUT(CS_PM, 9, printk("dmabuf_swptr_capture: 0x%x dmabuf_count_capture: %d\n",
3494 s->pm.dmabuf_swptr_capture,s->pm.dmabuf_count_capture));
3498 /****************************************************************************
3500 * Suspend - save the ac97 regs, mute the outputs and power down the part.
3502 ****************************************************************************/
3503 void cs46xx_ac97_suspend(struct cs_card *card)
3506 struct ac97_codec *dev=card->ac97_codec[0];
3509 CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_suspend()+\n"));
3513 stop_dac(card->states[1]);
3514 resync_dma_ptrs(card->states[1]);
3518 stop_adc(card->states[0]);
3519 resync_dma_ptrs(card->states[0]);
3522 for(Count = 0x2, i=0; (Count <= CS46XX_AC97_HIGHESTREGTORESTORE)
3523 && (i < CS46XX_AC97_NUMBER_RESTORE_REGS);
3526 card->pm.ac97[i] = cs_ac97_get(dev, BA0_AC97_RESET + Count);
3529 * Save the ac97 volume registers as well as the current powerdown state.
3530 * Now, mute the all the outputs (master, headphone, and mono), as well
3531 * as the PCM volume, in preparation for powering down the entire part.
3532 card->pm.u32AC97_master_volume = (u32)cs_ac97_get( dev,
3533 (u8)BA0_AC97_MASTER_VOLUME);
3534 card->pm.u32AC97_headphone_volume = (u32)cs_ac97_get(dev,
3535 (u8)BA0_AC97_HEADPHONE_VOLUME);
3536 card->pm.u32AC97_master_volume_mono = (u32)cs_ac97_get(dev,
3537 (u8)BA0_AC97_MASTER_VOLUME_MONO);
3538 card->pm.u32AC97_pcm_out_volume = (u32)cs_ac97_get(dev,
3539 (u8)BA0_AC97_PCM_OUT_VOLUME);
3544 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME, 0x8000);
3545 cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, 0x8000);
3546 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, 0x8000);
3547 cs_ac97_set(dev, (u8)BA0_AC97_PCM_OUT_VOLUME, 0x8000);
3550 * save the registers that cause pops
3552 card->pm.u32AC97_powerdown = (u32)cs_ac97_get(dev, (u8)AC97_POWER_CONTROL);
3553 card->pm.u32AC97_general_purpose = (u32)cs_ac97_get(dev, (u8)BA0_AC97_GENERAL_PURPOSE);
3555 * And power down everything on the AC97 codec.
3556 * well, for now, only power down the DAC/ADC and MIXER VREFON components.
3557 * trouble with removing VREF.
3559 if( (tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
3560 CS_POWER_MIXVON, CS_TRUE )) )
3562 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3563 "cs46xx: cs46xx_ac97_suspend() failure (0x%x)\n",tmp) );
3566 CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_suspend()-\n"));
3569 /****************************************************************************
3571 * Resume - power up the part and restore its registers..
3573 ****************************************************************************/
3574 void cs46xx_ac97_resume(struct cs_card *card)
3577 struct ac97_codec *dev=card->ac97_codec[0];
3579 CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_resume()+\n"));
3582 * First, we restore the state of the general purpose register. This
3583 * contains the mic select (mic1 or mic2) and if we restore this after
3584 * we restore the mic volume/boost state and mic2 was selected at
3585 * suspend time, we will end up with a brief period of time where mic1
3586 * is selected with the volume/boost settings for mic2, causing
3587 * acoustic feedback. So we restore the general purpose register
3588 * first, thereby getting the correct mic selected before we restore
3589 * the mic volume/boost.
3591 cs_ac97_set(dev, (u8)BA0_AC97_GENERAL_PURPOSE,
3592 (u16)card->pm.u32AC97_general_purpose);
3594 * Now, while the outputs are still muted, restore the state of power
3597 cs_ac97_set(dev, (u8)BA0_AC97_POWERDOWN, (u16)card->pm.u32AC97_powerdown);
3598 mdelay(5 * cs_laptop_wait);
3600 * Restore just the first set of registers, from register number
3601 * 0x02 to the register number that ulHighestRegToRestore specifies.
3603 for( Count = 0x2, i=0;
3604 (Count <= CS46XX_AC97_HIGHESTREGTORESTORE)
3605 && (i < CS46XX_AC97_NUMBER_RESTORE_REGS);
3608 cs_ac97_set(dev, (u8)(BA0_AC97_RESET + Count), (u16)card->pm.ac97[i]);
3611 /* Check if we have to init the amplifier */
3613 card->amp_init(card);
3615 CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_resume()-\n"));
3619 static int cs46xx_restart_part(struct cs_card *card)
3621 struct dmabuf *dmabuf;
3622 CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3623 printk( "cs46xx: cs46xx_restart_part()+\n"));
3626 dmabuf = &card->states[1]->dmabuf;
3628 resync_dma_ptrs(card->states[1]);
3629 cs_set_divisor(dmabuf);
3630 if(__prog_dmabuf(card->states[1]))
3632 CS_DBGOUT(CS_PM | CS_ERROR, 1,
3633 printk("cs46xx: cs46xx_restart_part()- (-1) prog_dmabuf() dac error\n"));
3636 cs_set_dac_rate(card->states[1], dmabuf->rate);
3640 dmabuf = &card->states[0]->dmabuf;
3642 resync_dma_ptrs(card->states[0]);
3643 cs_set_divisor(dmabuf);
3644 if(__prog_dmabuf(card->states[0]))
3646 CS_DBGOUT(CS_PM | CS_ERROR, 1,
3647 printk("cs46xx: cs46xx_restart_part()- (-1) prog_dmabuf() adc error\n"));
3650 cs_set_adc_rate(card->states[0], dmabuf->rate);
3652 card->pm.flags |= CS46XX_PM_RESUMED;
3654 start_adc(card->states[0]);
3656 start_dac(card->states[1]);
3658 card->pm.flags |= CS46XX_PM_IDLE;
3659 card->pm.flags &= ~(CS46XX_PM_SUSPENDING | CS46XX_PM_SUSPENDED
3660 | CS46XX_PM_RESUMING | CS46XX_PM_RESUMED);
3662 wake_up(&card->states[0]->dmabuf.wait);
3664 wake_up(&card->states[1]->dmabuf.wait);
3666 CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3667 printk( "cs46xx: cs46xx_restart_part()-\n"));
3672 static void cs461x_reset(struct cs_card *card);
3673 static void cs461x_proc_stop(struct cs_card *card);
3674 static int cs46xx_suspend(struct cs_card *card, u32 state)
3677 CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3678 printk("cs46xx: cs46xx_suspend()+ flags=0x%x s=0x%x\n",
3679 (unsigned)card->pm.flags,(unsigned)card));
3681 * check the current state, only suspend if IDLE
3683 if(!(card->pm.flags & CS46XX_PM_IDLE))
3685 CS_DBGOUT(CS_PM | CS_ERROR, 2,
3686 printk("cs46xx: cs46xx_suspend() unable to suspend, not IDLE\n"));
3689 card->pm.flags &= ~CS46XX_PM_IDLE;
3690 card->pm.flags |= CS46XX_PM_SUSPENDING;
3692 card->active_ctrl(card,1);
3694 tmp = cs461x_peek(card, BA1_PFIE);
3697 cs461x_poke(card, BA1_PFIE, tmp); /* playback interrupt disable */
3699 tmp = cs461x_peek(card, BA1_CIE);
3702 cs461x_poke(card, BA1_CIE, tmp); /* capture interrupt disable */
3705 * Stop playback DMA.
3707 tmp = cs461x_peek(card, BA1_PCTL);
3708 cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
3713 tmp = cs461x_peek(card, BA1_CCTL);
3714 cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
3718 card->pm.dmabuf_swptr_play = card->states[1]->dmabuf.swptr;
3719 card->pm.dmabuf_count_play = card->states[1]->dmabuf.count;
3723 card->pm.dmabuf_swptr_capture = card->states[0]->dmabuf.swptr;
3724 card->pm.dmabuf_count_capture = card->states[0]->dmabuf.count;
3727 cs46xx_ac97_suspend(card);
3730 * Reset the processor.
3734 cs461x_proc_stop(card);
3737 * Power down the DAC and ADC. For now leave the other areas on.
3739 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, 0x0300);
3742 * Power down the PLL.
3744 cs461x_pokeBA0(card, BA0_CLKCR1, 0);
3747 * Turn off the Processor by turning off the software clock enable flag in
3748 * the clock control register.
3750 tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE;
3751 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
3753 card->active_ctrl(card,-1);
3755 card->pm.flags &= ~CS46XX_PM_SUSPENDING;
3756 card->pm.flags |= CS46XX_PM_SUSPENDED;
3760 CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3761 printk("cs46xx: cs46xx_suspend()- flags=0x%x\n",
3762 (unsigned)card->pm.flags));
3766 static int cs46xx_resume(struct cs_card *card)
3770 CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3771 printk( "cs46xx: cs46xx_resume()+ flags=0x%x\n",
3772 (unsigned)card->pm.flags));
3773 if(!(card->pm.flags & CS46XX_PM_SUSPENDED))
3775 CS_DBGOUT(CS_PM | CS_ERROR, 2,
3776 printk("cs46xx: cs46xx_resume() unable to resume, not SUSPENDED\n"));
3779 card->pm.flags |= CS46XX_PM_RESUMING;
3780 card->pm.flags &= ~CS46XX_PM_SUSPENDED;
3782 card->active_ctrl(card, 1);
3786 if (cs_hardware_init(card) != 0)
3788 CS_DBGOUT(CS_PM | CS_ERROR, 4, printk(
3789 "cs46xx: cs46xx_resume()- ERROR in cs_hardware_init()\n"));
3790 mdelay(10 * cs_laptop_wait);
3798 CS_DBGOUT(CS_PM | CS_ERROR, 1, printk(
3799 "cs46xx: cs46xx_resume()- cs_hardware_init() failed, retried %d times.\n",i));
3803 if(cs46xx_restart_part(card))
3805 CS_DBGOUT(CS_PM | CS_ERROR, 4, printk(
3806 "cs46xx: cs46xx_resume(): cs46xx_restart_part() returned error\n"));
3809 card->active_ctrl(card, -1);
3811 CS_DBGOUT(CS_PM | CS_FUNCTION, 4, printk("cs46xx: cs46xx_resume()- flags=0x%x\n",
3812 (unsigned)card->pm.flags));
3816 static /*const*/ struct file_operations cs461x_fops = {
3817 CS_OWNER CS_THIS_MODULE
3818 .llseek = no_llseek,
3825 .release = cs_release,
3828 /* Write AC97 codec registers */
3831 static u16 _cs_ac97_get(struct ac97_codec *dev, u8 reg)
3833 struct cs_card *card = dev->private_data;
3839 * 1. Write ACCAD = Command Address Register = 46Ch for AC97 register address
3840 * 2. Write ACCDA = Command Data Register = 470h for data to write to AC97
3841 * 3. Write ACCTL = Control Register = 460h for initiating the write
3842 * 4. Read ACCTL = 460h, DCV should be reset by now and 460h = 17h
3843 * 5. if DCV not cleared, break and return error
3844 * 6. Read ACSTS = Status Register = 464h, check VSTS bit
3847 cs461x_peekBA0(card, BA0_ACSDA);
3850 * Setup the AC97 control registers on the CS461x to send the
3851 * appropriate command to the AC97 to perform the read.
3852 * ACCAD = Command Address Register = 46Ch
3853 * ACCDA = Command Data Register = 470h
3854 * ACCTL = Control Register = 460h
3855 * set DCV - will clear when process completed
3856 * set CRW - Read command
3857 * set VFRM - valid frame enabled
3858 * set ESYN - ASYNC generation enabled
3859 * set RSTN - ARST# inactive, AC97 codec not reset
3862 cs461x_pokeBA0(card, BA0_ACCAD, reg);
3863 cs461x_pokeBA0(card, BA0_ACCDA, 0);
3864 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_DCV | ACCTL_CRW |
3865 ACCTL_VFRM | ACCTL_ESYN |
3870 * Wait for the read to occur.
3872 if(!(card->pm.flags & CS46XX_PM_IDLE))
3875 loopcnt = 500 * cs_laptop_wait;
3876 loopcnt *= cs_laptop_wait;
3877 for (count = 0; count < loopcnt; count++) {
3879 * First, we want to wait for a short time.
3881 udelay(10 * cs_laptop_wait);
3883 * Now, check to see if the read has completed.
3884 * ACCTL = 460h, DCV should be reset by now and 460h = 17h
3886 if (!(cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV))
3891 * Make sure the read completed.
3893 if (cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV) {
3894 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
3895 "cs46xx: AC'97 read problem (ACCTL_DCV), reg = 0x%x returning 0xffff\n", reg));
3900 * Wait for the valid status bit to go active.
3903 if(!(card->pm.flags & CS46XX_PM_IDLE))
3907 loopcnt *= cs_laptop_wait;
3908 for (count = 0; count < loopcnt; count++) {
3910 * Read the AC97 status register.
3911 * ACSTS = Status Register = 464h
3912 * VSTS - Valid Status
3914 if (cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_VSTS)
3916 udelay(10 * cs_laptop_wait);
3920 * Make sure we got valid status.
3922 if (!( (tmp=cs461x_peekBA0(card, BA0_ACSTS)) & ACSTS_VSTS)) {
3923 CS_DBGOUT(CS_ERROR, 2, printk(KERN_WARNING
3924 "cs46xx: AC'97 read problem (ACSTS_VSTS), reg = 0x%x val=0x%x 0xffff \n",
3930 * Read the data returned from the AC97 register.
3931 * ACSDA = Status Data Register = 474h
3933 CS_DBGOUT(CS_FUNCTION, 9, printk(KERN_INFO
3934 "cs46xx: cs_ac97_get() reg = 0x%x, val = 0x%x, BA0_ACCAD = 0x%x\n",
3935 reg, cs461x_peekBA0(card, BA0_ACSDA),
3936 cs461x_peekBA0(card, BA0_ACCAD)));
3937 ret = cs461x_peekBA0(card, BA0_ACSDA);
3941 static u16 cs_ac97_get(struct ac97_codec *dev, u8 reg)
3944 struct cs_card *card = dev->private_data;
3946 spin_lock(&card->ac97_lock);
3947 ret = _cs_ac97_get(dev, reg);
3948 spin_unlock(&card->ac97_lock);
3952 static void cs_ac97_set(struct ac97_codec *dev, u8 reg, u16 val)
3954 struct cs_card *card = dev->private_data;
3958 spin_lock(&card->ac97_lock);
3960 if(reg == AC97_CD_VOL)
3962 val2 = _cs_ac97_get(dev, AC97_CD_VOL);
3967 * 1. Write ACCAD = Command Address Register = 46Ch for AC97 register address
3968 * 2. Write ACCDA = Command Data Register = 470h for data to write to AC97
3969 * 3. Write ACCTL = Control Register = 460h for initiating the write
3970 * 4. Read ACCTL = 460h, DCV should be reset by now and 460h = 07h
3971 * 5. if DCV not cleared, break and return error
3975 * Setup the AC97 control registers on the CS461x to send the
3976 * appropriate command to the AC97 to perform the read.
3977 * ACCAD = Command Address Register = 46Ch
3978 * ACCDA = Command Data Register = 470h
3979 * ACCTL = Control Register = 460h
3980 * set DCV - will clear when process completed
3981 * reset CRW - Write command
3982 * set VFRM - valid frame enabled
3983 * set ESYN - ASYNC generation enabled
3984 * set RSTN - ARST# inactive, AC97 codec not reset
3986 cs461x_pokeBA0(card, BA0_ACCAD, reg);
3987 cs461x_pokeBA0(card, BA0_ACCDA, val);
3988 cs461x_peekBA0(card, BA0_ACCTL);
3989 cs461x_pokeBA0(card, BA0_ACCTL, 0 | ACCTL_VFRM | ACCTL_ESYN | ACCTL_RSTN);
3990 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_DCV | ACCTL_VFRM |
3991 ACCTL_ESYN | ACCTL_RSTN);
3992 for (count = 0; count < 1000; count++) {
3994 * First, we want to wait for a short time.
3996 udelay(10 * cs_laptop_wait);
3998 * Now, check to see if the write has completed.
3999 * ACCTL = 460h, DCV should be reset by now and 460h = 07h
4001 if (!(cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV))
4005 * Make sure the write completed.
4007 if (cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV)
4009 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4010 "cs46xx: AC'97 write problem, reg = 0x%x, val = 0x%x\n", reg, val));
4013 spin_unlock(&card->ac97_lock);
4016 * Adjust power if the mixer is selected/deselected according
4019 * IF the CD is a valid input source (mixer or direct) AND
4020 * the CD is not muted THEN power is needed
4022 * We do two things. When record select changes the input to
4023 * add/remove the CD we adjust the power count if the CD is
4026 * When the CD mute changes we adjust the power level if the
4027 * CD was a valid input.
4029 * We also check for CD volume != 0, as the CD mute isn't
4030 * normally tweaked from userspace.
4033 /* CD mute change ? */
4035 if(reg==AC97_CD_VOL)
4037 /* Mute bit change ? */
4038 if((val2^val)&0x8000 || ((val2 == 0x1f1f || val == 0x1f1f) && val2 != val))
4040 /* This is a hack but its cleaner than the alternatives.
4041 Right now card->ac97_codec[0] might be NULL as we are
4042 still doing codec setup. This does an early assignment
4043 to avoid the problem if it occurs */
4045 if(card->ac97_codec[0]==NULL)
4046 card->ac97_codec[0]=dev;
4049 if(val&0x8000 || val == 0x1f1f)
4050 card->amplifier_ctrl(card, -1);
4051 else /* Mute off power on */
4054 card->amp_init(card);
4055 card->amplifier_ctrl(card, 1);
4062 /* OSS /dev/mixer file operation methods */
4064 static int cs_open_mixdev(struct inode *inode, struct file *file)
4067 unsigned int minor = iminor(inode);
4068 struct cs_card *card=NULL;
4069 struct list_head *entry;
4072 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4,
4073 printk(KERN_INFO "cs46xx: cs_open_mixdev()+\n"));
4075 list_for_each(entry, &cs46xx_devs)
4077 card = list_entry(entry, struct cs_card, list);
4078 for (i = 0; i < NR_AC97; i++)
4079 if (card->ac97_codec[i] != NULL &&
4080 card->ac97_codec[i]->dev_mixer == minor)
4085 CS_DBGOUT(CS_FUNCTION | CS_OPEN | CS_ERROR, 2,
4086 printk(KERN_INFO "cs46xx: cs46xx_open_mixdev()- -ENODEV\n"));
4090 if(!card->ac97_codec[i])
4092 file->private_data = card->ac97_codec[i];
4094 card->active_ctrl(card,1);
4095 if(!CS_IN_USE(&card->mixer_use_cnt))
4097 if( (tmp = cs46xx_powerup(card, CS_POWER_MIXVON )) )
4099 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
4100 "cs46xx: cs_open_mixdev() powerup failure (0x%x)\n",tmp) );
4104 card->amplifier_ctrl(card, 1);
4105 CS_INC_USE_COUNT(&card->mixer_use_cnt);
4106 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4,
4107 printk(KERN_INFO "cs46xx: cs_open_mixdev()- 0\n"));
4111 static int cs_release_mixdev(struct inode *inode, struct file *file)
4113 unsigned int minor = iminor(inode);
4114 struct cs_card *card=NULL;
4115 struct list_head *entry;
4119 CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 4,
4120 printk(KERN_INFO "cs46xx: cs_release_mixdev()+\n"));
4121 list_for_each(entry, &cs46xx_devs)
4123 card = list_entry(entry, struct cs_card, list);
4124 for (i = 0; i < NR_AC97; i++)
4125 if (card->ac97_codec[i] != NULL &&
4126 card->ac97_codec[i]->dev_mixer == minor)
4131 CS_DBGOUT(CS_FUNCTION | CS_OPEN | CS_ERROR, 2,
4132 printk(KERN_INFO "cs46xx: cs46xx_open_mixdev()- -ENODEV\n"));
4136 if(!CS_DEC_AND_TEST(&card->mixer_use_cnt))
4138 CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 4,
4139 printk(KERN_INFO "cs46xx: cs_release_mixdev()- no powerdown, usecnt>0\n"));
4140 card->active_ctrl(card, -1);
4141 card->amplifier_ctrl(card, -1);
4145 * ok, no outstanding mixer opens, so powerdown.
4147 if( (tmp = cs461x_powerdown(card, CS_POWER_MIXVON, CS_FALSE )) )
4149 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
4150 "cs46xx: cs_release_mixdev() powerdown MIXVON failure (0x%x)\n",tmp) );
4151 card->active_ctrl(card, -1);
4152 card->amplifier_ctrl(card, -1);
4155 card->active_ctrl(card, -1);
4156 card->amplifier_ctrl(card, -1);
4157 CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 4,
4158 printk(KERN_INFO "cs46xx: cs_release_mixdev()- 0\n"));
4162 void __exit cs46xx_cleanup_module(void);
4163 static int cs_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd,
4166 struct ac97_codec *codec = (struct ac97_codec *)file->private_data;
4167 struct cs_card *card=NULL;
4168 struct list_head *entry;
4169 unsigned long __user *p = (long __user *)arg;
4171 #if CSDEBUG_INTERFACE
4174 if( (cmd == SOUND_MIXER_CS_GETDBGMASK) ||
4175 (cmd == SOUND_MIXER_CS_SETDBGMASK) ||
4176 (cmd == SOUND_MIXER_CS_GETDBGLEVEL) ||
4177 (cmd == SOUND_MIXER_CS_SETDBGLEVEL) ||
4178 (cmd == SOUND_MIXER_CS_APM))
4183 case SOUND_MIXER_CS_GETDBGMASK:
4184 return put_user(cs_debugmask, p);
4186 case SOUND_MIXER_CS_GETDBGLEVEL:
4187 return put_user(cs_debuglevel, p);
4189 case SOUND_MIXER_CS_SETDBGMASK:
4190 if (get_user(val, p))
4195 case SOUND_MIXER_CS_SETDBGLEVEL:
4196 if (get_user(val, p))
4198 cs_debuglevel = val;
4201 case SOUND_MIXER_CS_APM:
4202 if (get_user(val, p))
4204 if(val == CS_IOCTL_CMD_SUSPEND)
4206 list_for_each(entry, &cs46xx_devs)
4208 card = list_entry(entry, struct cs_card, list);
4209 cs46xx_suspend(card, 0);
4213 else if(val == CS_IOCTL_CMD_RESUME)
4215 list_for_each(entry, &cs46xx_devs)
4217 card = list_entry(entry, struct cs_card, list);
4218 cs46xx_resume(card);
4223 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
4224 "cs46xx: mixer_ioctl(): invalid APM cmd (%d)\n",
4230 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
4231 "cs46xx: mixer_ioctl(): ERROR unknown debug cmd\n") );
4236 return codec->mixer_ioctl(codec, cmd, arg);
4239 static /*const*/ struct file_operations cs_mixer_fops = {
4240 CS_OWNER CS_THIS_MODULE
4241 .llseek = no_llseek,
4242 .ioctl = cs_ioctl_mixdev,
4243 .open = cs_open_mixdev,
4244 .release = cs_release_mixdev,
4247 /* AC97 codec initialisation. */
4248 static int __init cs_ac97_init(struct cs_card *card)
4252 struct ac97_codec *codec;
4255 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4256 "cs46xx: cs_ac97_init()+\n") );
4258 for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
4259 if ((codec = ac97_alloc_codec()) == NULL)
4262 /* initialize some basic codec information, other fields will be filled
4263 in ac97_probe_codec */
4264 codec->private_data = card;
4265 codec->id = num_ac97;
4267 codec->codec_read = cs_ac97_get;
4268 codec->codec_write = cs_ac97_set;
4270 if (ac97_probe_codec(codec) == 0)
4272 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4273 "cs46xx: cs_ac97_init()- codec number %d not found\n",
4275 card->ac97_codec[num_ac97] = 0;
4278 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4279 "cs46xx: cs_ac97_init() found codec %d\n",num_ac97) );
4281 eid = cs_ac97_get(codec, AC97_EXTENDED_ID);
4285 printk(KERN_WARNING "cs46xx: codec %d not present\n",num_ac97);
4286 ac97_release_codec(codec);
4290 card->ac97_features = eid;
4292 if ((codec->dev_mixer = register_sound_mixer(&cs_mixer_fops, -1)) < 0) {
4293 printk(KERN_ERR "cs46xx: couldn't register mixer!\n");
4294 ac97_release_codec(codec);
4297 card->ac97_codec[num_ac97] = codec;
4299 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4300 "cs46xx: cs_ac97_init() ac97_codec[%d] set to 0x%x\n",
4301 (unsigned int)num_ac97,
4302 (unsigned int)codec));
4303 /* if there is no secondary codec at all, don't probe any more */
4310 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4311 "cs46xx: cs_ac97_init()- %d\n", (unsigned int)num_ac97));
4316 * load the static image into the DSP
4318 #include "cs461x_image.h"
4319 static void cs461x_download_image(struct cs_card *card)
4321 unsigned i, j, temp1, temp2, offset, count;
4322 unsigned char *pBA1 = ioremap(card->ba1_addr, 0x40000);
4323 for( i=0; i < CLEAR__COUNT; i++)
4325 offset = ClrStat[i].BA1__DestByteOffset;
4326 count = ClrStat[i].BA1__SourceSize;
4327 for( temp1 = offset; temp1<(offset+count); temp1+=4 )
4328 writel(0, pBA1+temp1);
4331 for(i=0; i<FILL__COUNT; i++)
4333 temp2 = FillStat[i].Offset;
4334 for(j=0; j<(FillStat[i].Size)/4; j++)
4336 temp1 = (FillStat[i]).pFill[j];
4337 writel(temp1, pBA1+temp2+j*4);
4348 static void cs461x_reset(struct cs_card *card)
4353 * Write the reset bit of the SP control register.
4355 cs461x_poke(card, BA1_SPCR, SPCR_RSTSP);
4358 * Write the control register.
4360 cs461x_poke(card, BA1_SPCR, SPCR_DRQEN);
4363 * Clear the trap registers.
4365 for (idx = 0; idx < 8; idx++) {
4366 cs461x_poke(card, BA1_DREG, DREG_REGID_TRAP_SELECT + idx);
4367 cs461x_poke(card, BA1_TWPR, 0xFFFF);
4369 cs461x_poke(card, BA1_DREG, 0);
4372 * Set the frame timer to reflect the number of cycles per frame.
4374 cs461x_poke(card, BA1_FRMT, 0xadf);
4377 static void cs461x_clear_serial_FIFOs(struct cs_card *card, int type)
4379 int idx, loop, startfifo=0, endfifo=0, powerdown1 = 0;
4383 * See if the devices are powered down. If so, we must power them up first
4384 * or they will not respond.
4386 if (!((tmp = cs461x_peekBA0(card, BA0_CLKCR1)) & CLKCR1_SWCE)) {
4387 cs461x_pokeBA0(card, BA0_CLKCR1, tmp | CLKCR1_SWCE);
4392 * We want to clear out the serial port FIFOs so we don't end up playing
4393 * whatever random garbage happens to be in them. We fill the sample FIFOS
4394 * with zero (silence).
4396 cs461x_pokeBA0(card, BA0_SERBWP, 0);
4399 * Check for which FIFO locations to clear, if we are currently
4400 * playing or capturing then we don't want to put in 128 bytes of
4403 if(type & CS_TYPE_DAC)
4408 if(type & CS_TYPE_ADC)
4415 * Fill sample FIFO locations (256 locations total).
4417 for (idx = startfifo; idx < endfifo; idx++) {
4419 * Make sure the previous FIFO write operation has completed.
4421 for (loop = 0; loop < 5; loop++) {
4423 if (!(cs461x_peekBA0(card, BA0_SERBST) & SERBST_WBSY))
4426 if (cs461x_peekBA0(card, BA0_SERBST) & SERBST_WBSY) {
4428 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
4431 * Write the serial port FIFO index.
4433 cs461x_pokeBA0(card, BA0_SERBAD, idx);
4435 * Tell the serial port to load the new value into the FIFO location.
4437 cs461x_pokeBA0(card, BA0_SERBCM, SERBCM_WRC);
4440 * Now, if we powered up the devices, then power them back down again.
4441 * This is kinda ugly, but should never happen.
4444 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
4448 static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspendflag)
4451 unsigned int tmp=0,muted=0;
4453 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO
4454 "cs46xx: cs461x_powerdown()+ type=0x%x\n",type));
4455 if(!cs_powerdown && !suspendflag)
4457 CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4458 "cs46xx: cs461x_powerdown() DISABLED exiting\n"));
4461 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4462 CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4463 "cs46xx: cs461x_powerdown() powerdown reg=0x%x\n",tmp));
4465 * if powering down only the VREF, and not powering down the DAC/ADC,
4466 * then do not power down the VREF, UNLESS both the DAC and ADC are not
4467 * currently powered down. If powering down DAC and ADC, then
4468 * it is possible to power down the VREF (ON).
4470 if ( ((type & CS_POWER_MIXVON) &&
4471 (!(type & CS_POWER_ADC) || (!(type & CS_POWER_DAC))) )
4473 ((tmp & CS_AC97_POWER_CONTROL_ADC_ON) ||
4474 (tmp & CS_AC97_POWER_CONTROL_DAC_ON) ) )
4476 CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4477 "cs46xx: cs461x_powerdown()- 0 unable to powerdown. tmp=0x%x\n",tmp));
4481 * for now, always keep power to the mixer block.
4482 * not sure why it's a problem but it seems to be if we power off.
4484 type &= ~CS_POWER_MIXVON;
4485 type &= ~CS_POWER_MIXVOFF;
4488 * Power down indicated areas.
4490 if(type & CS_POWER_MIXVOFF)
4493 CS_DBGOUT(CS_FUNCTION, 4,
4494 printk(KERN_INFO "cs46xx: cs461x_powerdown()+ MIXVOFF\n"));
4496 * Power down the MIXER (VREF ON) on the AC97 card.
4498 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4499 if (tmp & CS_AC97_POWER_CONTROL_MIXVOFF_ON)
4503 cs_mute(card, CS_TRUE);
4506 tmp |= CS_AC97_POWER_CONTROL_MIXVOFF;
4507 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4509 * Now, we wait until we sample a ready state.
4511 for (count = 0; count < 32; count++) {
4513 * First, lets wait a short while to let things settle out a
4514 * bit, and to prevent retrying the read too quickly.
4519 * Read the current state of the power control register.
4521 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4522 CS_AC97_POWER_CONTROL_MIXVOFF_ON))
4527 * Check the status..
4529 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4530 CS_AC97_POWER_CONTROL_MIXVOFF_ON)
4532 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4533 "cs46xx: powerdown MIXVOFF failed\n"));
4538 if(type & CS_POWER_MIXVON)
4541 CS_DBGOUT(CS_FUNCTION, 4,
4542 printk(KERN_INFO "cs46xx: cs461x_powerdown()+ MIXVON\n"));
4544 * Power down the MIXER (VREF ON) on the AC97 card.
4546 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4547 if (tmp & CS_AC97_POWER_CONTROL_MIXVON_ON)
4551 cs_mute(card, CS_TRUE);
4554 tmp |= CS_AC97_POWER_CONTROL_MIXVON;
4555 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4557 * Now, we wait until we sample a ready state.
4559 for (count = 0; count < 32; count++) {
4561 * First, lets wait a short while to let things settle out a
4562 * bit, and to prevent retrying the read too quickly.
4567 * Read the current state of the power control register.
4569 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4570 CS_AC97_POWER_CONTROL_MIXVON_ON))
4575 * Check the status..
4577 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4578 CS_AC97_POWER_CONTROL_MIXVON_ON)
4580 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4581 "cs46xx: powerdown MIXVON failed\n"));
4586 if(type & CS_POWER_ADC)
4589 * Power down the ADC on the AC97 card.
4591 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO "cs46xx: cs461x_powerdown()+ ADC\n"));
4592 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4593 if (tmp & CS_AC97_POWER_CONTROL_ADC_ON)
4597 cs_mute(card, CS_TRUE);
4600 tmp |= CS_AC97_POWER_CONTROL_ADC;
4601 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4604 * Now, we wait until we sample a ready state.
4606 for (count = 0; count < 32; count++) {
4608 * First, lets wait a short while to let things settle out a
4609 * bit, and to prevent retrying the read too quickly.
4614 * Read the current state of the power control register.
4616 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4617 CS_AC97_POWER_CONTROL_ADC_ON))
4622 * Check the status..
4624 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4625 CS_AC97_POWER_CONTROL_ADC_ON)
4627 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4628 "cs46xx: powerdown ADC failed\n"));
4633 if(type & CS_POWER_DAC)
4636 * Power down the DAC on the AC97 card.
4639 CS_DBGOUT(CS_FUNCTION, 4,
4640 printk(KERN_INFO "cs46xx: cs461x_powerdown()+ DAC\n"));
4641 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4642 if (tmp & CS_AC97_POWER_CONTROL_DAC_ON)
4646 cs_mute(card, CS_TRUE);
4649 tmp |= CS_AC97_POWER_CONTROL_DAC;
4650 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4652 * Now, we wait until we sample a ready state.
4654 for (count = 0; count < 32; count++) {
4656 * First, lets wait a short while to let things settle out a
4657 * bit, and to prevent retrying the read too quickly.
4662 * Read the current state of the power control register.
4664 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4665 CS_AC97_POWER_CONTROL_DAC_ON))
4670 * Check the status..
4672 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4673 CS_AC97_POWER_CONTROL_DAC_ON)
4675 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4676 "cs46xx: powerdown DAC failed\n"));
4681 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4683 cs_mute(card, CS_FALSE);
4684 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO
4685 "cs46xx: cs461x_powerdown()- 0 tmp=0x%x\n",tmp));
4689 static int cs46xx_powerup(struct cs_card *card, unsigned int type)
4692 unsigned int tmp=0,muted=0;
4694 CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4695 "cs46xx: cs46xx_powerup()+ type=0x%x\n",type));
4697 * check for VREF and powerup if need to.
4699 if(type & CS_POWER_MIXVON)
4700 type |= CS_POWER_MIXVOFF;
4701 if(type & (CS_POWER_DAC | CS_POWER_ADC))
4702 type |= CS_POWER_MIXVON | CS_POWER_MIXVOFF;
4705 * Power up indicated areas.
4707 if(type & CS_POWER_MIXVOFF)
4710 CS_DBGOUT(CS_FUNCTION, 4,
4711 printk(KERN_INFO "cs46xx: cs46xx_powerup()+ MIXVOFF\n"));
4713 * Power up the MIXER (VREF ON) on the AC97 card.
4715 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4716 if (!(tmp & CS_AC97_POWER_CONTROL_MIXVOFF_ON))
4720 cs_mute(card, CS_TRUE);
4723 tmp &= ~CS_AC97_POWER_CONTROL_MIXVOFF;
4724 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4726 * Now, we wait until we sample a ready state.
4728 for (count = 0; count < 32; count++) {
4730 * First, lets wait a short while to let things settle out a
4731 * bit, and to prevent retrying the read too quickly.
4736 * Read the current state of the power control register.
4738 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4739 CS_AC97_POWER_CONTROL_MIXVOFF_ON)
4744 * Check the status..
4746 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4747 CS_AC97_POWER_CONTROL_MIXVOFF_ON))
4749 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4750 "cs46xx: powerup MIXVOFF failed\n"));
4755 if(type & CS_POWER_MIXVON)
4758 CS_DBGOUT(CS_FUNCTION, 4,
4759 printk(KERN_INFO "cs46xx: cs46xx_powerup()+ MIXVON\n"));
4761 * Power up the MIXER (VREF ON) on the AC97 card.
4763 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4764 if (!(tmp & CS_AC97_POWER_CONTROL_MIXVON_ON))
4768 cs_mute(card, CS_TRUE);
4771 tmp &= ~CS_AC97_POWER_CONTROL_MIXVON;
4772 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4774 * Now, we wait until we sample a ready state.
4776 for (count = 0; count < 32; count++) {
4778 * First, lets wait a short while to let things settle out a
4779 * bit, and to prevent retrying the read too quickly.
4784 * Read the current state of the power control register.
4786 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4787 CS_AC97_POWER_CONTROL_MIXVON_ON)
4792 * Check the status..
4794 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4795 CS_AC97_POWER_CONTROL_MIXVON_ON))
4797 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4798 "cs46xx: powerup MIXVON failed\n"));
4803 if(type & CS_POWER_ADC)
4806 * Power up the ADC on the AC97 card.
4808 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO "cs46xx: cs46xx_powerup()+ ADC\n"));
4809 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4810 if (!(tmp & CS_AC97_POWER_CONTROL_ADC_ON))
4814 cs_mute(card, CS_TRUE);
4817 tmp &= ~CS_AC97_POWER_CONTROL_ADC;
4818 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4821 * Now, we wait until we sample a ready state.
4823 for (count = 0; count < 32; count++) {
4825 * First, lets wait a short while to let things settle out a
4826 * bit, and to prevent retrying the read too quickly.
4831 * Read the current state of the power control register.
4833 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4834 CS_AC97_POWER_CONTROL_ADC_ON)
4839 * Check the status..
4841 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4842 CS_AC97_POWER_CONTROL_ADC_ON))
4844 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4845 "cs46xx: powerup ADC failed\n"));
4850 if(type & CS_POWER_DAC)
4853 * Power up the DAC on the AC97 card.
4856 CS_DBGOUT(CS_FUNCTION, 4,
4857 printk(KERN_INFO "cs46xx: cs46xx_powerup()+ DAC\n"));
4858 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4859 if (!(tmp & CS_AC97_POWER_CONTROL_DAC_ON))
4863 cs_mute(card, CS_TRUE);
4866 tmp &= ~CS_AC97_POWER_CONTROL_DAC;
4867 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4869 * Now, we wait until we sample a ready state.
4871 for (count = 0; count < 32; count++) {
4873 * First, lets wait a short while to let things settle out a
4874 * bit, and to prevent retrying the read too quickly.
4879 * Read the current state of the power control register.
4881 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4882 CS_AC97_POWER_CONTROL_DAC_ON)
4887 * Check the status..
4889 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4890 CS_AC97_POWER_CONTROL_DAC_ON))
4892 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4893 "cs46xx: powerup DAC failed\n"));
4898 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4900 cs_mute(card, CS_FALSE);
4901 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO
4902 "cs46xx: cs46xx_powerup()- 0 tmp=0x%x\n",tmp));
4907 static void cs461x_proc_start(struct cs_card *card)
4912 * Set the frame timer to reflect the number of cycles per frame.
4914 cs461x_poke(card, BA1_FRMT, 0xadf);
4916 * Turn on the run, run at frame, and DMA enable bits in the local copy of
4917 * the SP control register.
4919 cs461x_poke(card, BA1_SPCR, SPCR_RUN | SPCR_RUNFR | SPCR_DRQEN);
4921 * Wait until the run at frame bit resets itself in the SP control
4924 for (cnt = 0; cnt < 25; cnt++) {
4926 if (!(cs461x_peek(card, BA1_SPCR) & SPCR_RUNFR))
4930 if (cs461x_peek(card, BA1_SPCR) & SPCR_RUNFR)
4931 printk(KERN_WARNING "cs46xx: SPCR_RUNFR never reset\n");
4934 static void cs461x_proc_stop(struct cs_card *card)
4937 * Turn off the run, run at frame, and DMA enable bits in the local copy of
4938 * the SP control register.
4940 cs461x_poke(card, BA1_SPCR, 0);
4943 static int cs_hardware_init(struct cs_card *card)
4945 unsigned long end_time;
4946 unsigned int tmp,count;
4948 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4949 "cs46xx: cs_hardware_init()+\n") );
4951 * First, blast the clock control register to zero so that the PLL starts
4952 * out in a known state, and blast the master serial port control register
4953 * to zero so that the serial ports also start out in a known state.
4955 cs461x_pokeBA0(card, BA0_CLKCR1, 0);
4956 cs461x_pokeBA0(card, BA0_SERMC1, 0);
4959 * If we are in AC97 mode, then we must set the part to a host controlled
4960 * AC-link. Otherwise, we won't be able to bring up the link.
4962 cs461x_pokeBA0(card, BA0_SERACC, SERACC_HSP | SERACC_CODEC_TYPE_1_03); /* 1.03 card */
4963 /* cs461x_pokeBA0(card, BA0_SERACC, SERACC_HSP | SERACC_CODEC_TYPE_2_0); */ /* 2.00 card */
4966 * Drive the ARST# pin low for a minimum of 1uS (as defined in the AC97
4967 * spec) and then drive it high. This is done for non AC97 modes since
4968 * there might be logic external to the CS461x that uses the ARST# line
4971 cs461x_pokeBA0(card, BA0_ACCTL, 1);
4973 cs461x_pokeBA0(card, BA0_ACCTL, 0);
4975 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_RSTN);
4978 * The first thing we do here is to enable sync generation. As soon
4979 * as we start receiving bit clock, we'll start producing the SYNC
4982 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_ESYN | ACCTL_RSTN);
4985 * Now wait for a short while to allow the AC97 part to start
4986 * generating bit clock (so we don't try to start the PLL without an
4989 mdelay(5 * cs_laptop_wait); /* 1 should be enough ?? (and pigs might fly) */
4992 * Set the serial port timing configuration, so that
4993 * the clock control circuit gets its clock from the correct place.
4995 cs461x_pokeBA0(card, BA0_SERMC1, SERMC1_PTC_AC97);
4998 * The part seems to not be ready for a while after a resume.
4999 * so, if we are resuming, then wait for 700 mils. Note that 600 mils
5000 * is not enough for some platforms! tested on an IBM Thinkpads and
5003 if(!(card->pm.flags & CS46XX_PM_IDLE))
5006 * Write the selected clock control setup to the hardware. Do not turn on
5007 * SWCE yet (if requested), so that the devices clocked by the output of
5008 * PLL are not clocked until the PLL is stable.
5010 cs461x_pokeBA0(card, BA0_PLLCC, PLLCC_LPF_1050_2780_KHZ | PLLCC_CDR_73_104_MHZ);
5011 cs461x_pokeBA0(card, BA0_PLLM, 0x3a);
5012 cs461x_pokeBA0(card, BA0_CLKCR2, CLKCR2_PDIVS_8);
5017 cs461x_pokeBA0(card, BA0_CLKCR1, CLKCR1_PLLP);
5020 * Wait until the PLL has stabilized.
5022 mdelay(5 * cs_laptop_wait); /* Again 1 should be enough ?? */
5025 * Turn on clocking of the core so that we can setup the serial ports.
5027 tmp = cs461x_peekBA0(card, BA0_CLKCR1) | CLKCR1_SWCE;
5028 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
5031 * Fill the serial port FIFOs with silence.
5033 cs461x_clear_serial_FIFOs(card,CS_TYPE_DAC | CS_TYPE_ADC);
5036 * Set the serial port FIFO pointer to the first sample in the FIFO.
5038 /* cs461x_pokeBA0(card, BA0_SERBSP, 0); */
5041 * Write the serial port configuration to the part. The master
5042 * enable bit is not set until all other values have been written.
5044 cs461x_pokeBA0(card, BA0_SERC1, SERC1_SO1F_AC97 | SERC1_SO1EN);
5045 cs461x_pokeBA0(card, BA0_SERC2, SERC2_SI1F_AC97 | SERC1_SO1EN);
5046 cs461x_pokeBA0(card, BA0_SERMC1, SERMC1_PTC_AC97 | SERMC1_MSPE);
5049 mdelay(5 * cs_laptop_wait); /* Shouldnt be needed ?? */
5052 * If we are resuming under 2.2.x then we can not schedule a timeout.
5053 * so, just spin the CPU.
5055 if(card->pm.flags & CS46XX_PM_IDLE)
5058 * Wait for the card ready signal from the AC97 card.
5060 end_time = jiffies + 3 * (HZ >> 2);
5063 * Read the AC97 status register to see if we've seen a CODEC READY
5064 * signal from the AC97 card.
5066 if (cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_CRDY)
5068 current->state = TASK_UNINTERRUPTIBLE;
5069 schedule_timeout(1);
5070 } while (time_before(jiffies, end_time));
5074 for (count = 0; count < 100; count++) {
5075 // First, we want to wait for a short time.
5076 udelay(25 * cs_laptop_wait);
5078 if (cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_CRDY)
5084 * Make sure CODEC is READY.
5086 if (!(cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_CRDY)) {
5087 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_WARNING
5088 "cs46xx: create - never read card ready from AC'97\n"));
5089 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_WARNING
5090 "cs46xx: probably not a bug, try using the CS4232 driver,\n"));
5091 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_WARNING
5092 "cs46xx: or turn off any automatic Power Management support in the BIOS.\n"));
5097 * Assert the vaid frame signal so that we can start sending commands
5100 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_VFRM | ACCTL_ESYN | ACCTL_RSTN);
5102 if(card->pm.flags & CS46XX_PM_IDLE)
5105 * Wait until we've sampled input slots 3 and 4 as valid, meaning that
5106 * the card is pumping ADC data across the AC-link.
5108 end_time = jiffies + 3 * (HZ >> 2);
5111 * Read the input slot valid register and see if input slots 3 and
5114 if ((cs461x_peekBA0(card, BA0_ACISV) & (ACISV_ISV3 | ACISV_ISV4)) == (ACISV_ISV3 | ACISV_ISV4))
5116 current->state = TASK_UNINTERRUPTIBLE;
5117 schedule_timeout(1);
5118 } while (time_before(jiffies, end_time));
5122 for (count = 0; count < 100; count++) {
5123 // First, we want to wait for a short time.
5124 udelay(25 * cs_laptop_wait);
5126 if ((cs461x_peekBA0(card, BA0_ACISV) & (ACISV_ISV3 | ACISV_ISV4)) == (ACISV_ISV3 | ACISV_ISV4))
5131 * Make sure input slots 3 and 4 are valid. If not, then return
5134 if ((cs461x_peekBA0(card, BA0_ACISV) & (ACISV_ISV3 | ACISV_ISV4)) != (ACISV_ISV3 | ACISV_ISV4)) {
5135 printk(KERN_WARNING "cs46xx: create - never read ISV3 & ISV4 from AC'97\n");
5140 * Now, assert valid frame and the slot 3 and 4 valid bits. This will
5141 * commense the transfer of digital audio data to the AC97 card.
5143 cs461x_pokeBA0(card, BA0_ACOSV, ACOSV_SLV3 | ACOSV_SLV4);
5146 * Turn off the Processor by turning off the software clock enable flag in
5147 * the clock control register.
5149 /* tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE; */
5150 /* cs461x_pokeBA0(card, BA0_CLKCR1, tmp); */
5153 * Reset the processor.
5158 * Download the image to the processor.
5161 cs461x_download_image(card);
5164 * Stop playback DMA.
5166 tmp = cs461x_peek(card, BA1_PCTL);
5167 card->pctl = tmp & 0xffff0000;
5168 cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
5173 tmp = cs461x_peek(card, BA1_CCTL);
5174 card->cctl = tmp & 0x0000ffff;
5175 cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
5177 /* initialize AC97 codec and register /dev/mixer */
5178 if(card->pm.flags & CS46XX_PM_IDLE)
5180 if (cs_ac97_init(card) <= 0)
5182 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
5183 "cs46xx: cs_ac97_init() failure\n") );
5189 cs46xx_ac97_resume(card);
5192 cs461x_proc_start(card);
5195 * Enable interrupts on the part.
5197 cs461x_pokeBA0(card, BA0_HICR, HICR_IEV | HICR_CHGM);
5199 tmp = cs461x_peek(card, BA1_PFIE);
5201 cs461x_poke(card, BA1_PFIE, tmp); /* playback interrupt enable */
5203 tmp = cs461x_peek(card, BA1_CIE);
5206 cs461x_poke(card, BA1_CIE, tmp); /* capture interrupt enable */
5209 * If IDLE then Power down the part. We will power components up
5210 * when we need them.
5212 if(card->pm.flags & CS46XX_PM_IDLE)
5216 if( (tmp = cs46xx_powerup(card, CS_POWER_DAC | CS_POWER_ADC |
5217 CS_POWER_MIXVON )) )
5219 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
5220 "cs46xx: cs461x_powerup() failure (0x%x)\n",tmp) );
5226 if( (tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
5227 CS_POWER_MIXVON, CS_FALSE )) )
5229 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
5230 "cs46xx: cs461x_powerdown() failure (0x%x)\n",tmp) );
5235 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
5236 "cs46xx: cs_hardware_init()- 0\n"));
5240 /* install the driver, we do not allocate hardware channel nor DMA buffer now, they are defered
5241 until "ACCESS" time (in prog_dmabuf called by open/read/write/ioctl/mmap) */
5252 void (*amp)(struct cs_card *, int);
5253 void (*amp_init)(struct cs_card *);
5254 void (*active)(struct cs_card *, int);
5257 static struct cs_card_type cards[] = {
5261 .name = "Genius Soundmaker 128 value",
5273 .name = "Mitac MI6020/21",
5279 .name = "Hercules Game Theatre XP",
5280 .amp = amp_hercules,
5285 .name = "Hercules Game Theatre XP",
5286 .amp = amp_hercules,
5291 .name = "Hercules Game Theatre XP",
5292 .amp = amp_hercules,
5297 .name = "Hercules Game Theatre XP",
5298 .amp = amp_hercules,
5303 .name = "Hercules Game Theatre XP",
5304 .amp = amp_hercules,
5309 .name = "Hercules Game Theatre XP",
5310 .amp = amp_hercules,
5315 .name = "Hercules Fortissimo II",
5318 /* Not sure if the 570 needs the clkrun hack */
5320 .vendor = PCI_VENDOR_ID_IBM,
5322 .name = "Thinkpad 570",
5324 .active = clkrun_hack,
5327 .vendor = PCI_VENDOR_ID_IBM,
5329 .name = "Thinkpad 600X/A20/T20",
5331 .active = clkrun_hack,
5334 .vendor = PCI_VENDOR_ID_IBM,
5336 .name = "Thinkpad 600E (unsupported)",
5339 .name = "Card without SSID set",
5344 MODULE_AUTHOR("Alan Cox <alan@redhat.com>, Jaroslav Kysela, <pcaudio@crystal.cirrus.com>");
5345 MODULE_DESCRIPTION("Crystal SoundFusion Audio Support");
5346 MODULE_LICENSE("GPL");
5349 static const char cs46xx_banner[] = KERN_INFO "Crystal 4280/46xx + AC97 Audio, version " CS46XX_MAJOR_VERSION "." CS46XX_MINOR_VERSION "." CS46XX_ARCH ", " __TIME__ " " __DATE__ "\n";
5350 static const char fndmsg[] = KERN_INFO "cs46xx: Found %d audio device(s).\n";
5352 static int __devinit cs46xx_probe(struct pci_dev *pci_dev,
5353 const struct pci_device_id *pciid)
5355 struct pm_dev *pmdev;
5357 u16 ss_card, ss_vendor;
5358 struct cs_card *card;
5359 dma_addr_t dma_mask;
5360 struct cs_card_type *cp = &cards[0];
5362 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2,
5363 printk(KERN_INFO "cs46xx: probe()+\n"));
5365 dma_mask = 0xffffffff; /* this enables playback and recording */
5366 if (pci_enable_device(pci_dev)) {
5367 CS_DBGOUT(CS_INIT | CS_ERROR, 1, printk(KERN_ERR
5368 "cs46xx: pci_enable_device() failed\n"));
5371 if (!RSRCISMEMORYREGION(pci_dev, 0) ||
5372 !RSRCISMEMORYREGION(pci_dev, 1)) {
5373 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
5374 "cs46xx: probe()- Memory region not assigned\n"));
5377 if (pci_dev->irq == 0) {
5378 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
5379 "cs46xx: probe() IRQ not assigned\n"));
5382 if (!pci_dma_supported(pci_dev, 0xffffffff)) {
5383 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
5384 "cs46xx: probe() architecture does not support 32bit PCI busmaster DMA\n"));
5387 pci_read_config_word(pci_dev, PCI_SUBSYSTEM_VENDOR_ID, &ss_vendor);
5388 pci_read_config_word(pci_dev, PCI_SUBSYSTEM_ID, &ss_card);
5390 if ((card = kmalloc(sizeof(struct cs_card), GFP_KERNEL)) == NULL) {
5391 printk(KERN_ERR "cs46xx: out of memory\n");
5394 memset(card, 0, sizeof(*card));
5395 card->ba0_addr = RSRCADDRESS(pci_dev, 0);
5396 card->ba1_addr = RSRCADDRESS(pci_dev, 1);
5397 card->pci_dev = pci_dev;
5398 card->irq = pci_dev->irq;
5399 card->magic = CS_CARD_MAGIC;
5400 spin_lock_init(&card->lock);
5401 spin_lock_init(&card->ac97_lock);
5403 pci_set_master(pci_dev);
5405 printk(cs46xx_banner);
5406 printk(KERN_INFO "cs46xx: Card found at 0x%08lx and 0x%08lx, IRQ %d\n",
5407 card->ba0_addr, card->ba1_addr, card->irq);
5409 card->alloc_pcm_channel = cs_alloc_pcm_channel;
5410 card->alloc_rec_pcm_channel = cs_alloc_rec_pcm_channel;
5411 card->free_pcm_channel = cs_free_pcm_channel;
5412 card->amplifier_ctrl = amp_none;
5413 card->active_ctrl = amp_none;
5417 if(cp->vendor == ss_vendor && cp->id == ss_card)
5419 card->amplifier_ctrl = cp->amp;
5421 card->active_ctrl = cp->active;
5423 card->amp_init = cp->amp_init;
5430 printk(KERN_INFO "cs46xx: Unknown card (%04X:%04X) at 0x%08lx/0x%08lx, IRQ %d\n",
5431 ss_vendor, ss_card, card->ba0_addr, card->ba1_addr, card->irq);
5435 printk(KERN_INFO "cs46xx: %s (%04X:%04X) at 0x%08lx/0x%08lx, IRQ %d\n",
5436 cp->name, ss_vendor, ss_card, card->ba0_addr, card->ba1_addr, card->irq);
5439 if (card->amplifier_ctrl==NULL)
5441 card->amplifier_ctrl = amp_none;
5442 card->active_ctrl = clkrun_hack;
5445 if (external_amp == 1)
5447 printk(KERN_INFO "cs46xx: Crystal EAPD support forced on.\n");
5448 card->amplifier_ctrl = amp_voyetra;
5453 printk(KERN_INFO "cs46xx: Activating CLKRUN hack for Thinkpad.\n");
5454 card->active_ctrl = clkrun_hack;
5457 * The thinkpads don't work well without runtime updating on their kernel
5458 * delay values (or any laptop with variable CPU speeds really).
5459 * so, just to be safe set the init delay to 2100. Eliminates
5460 * failures on T21 Thinkpads. remove this code when the udelay
5461 * and mdelay kernel code is replaced by a pm timer, or the delays
5462 * work well for battery and/or AC power both.
5464 if(card->active_ctrl == clkrun_hack)
5469 if((card->active_ctrl == clkrun_hack) && !(powerdown == 1))
5472 * for some currently unknown reason, powering down the DAC and ADC component
5473 * blocks on thinkpads causes some funky behavior... distoorrrtion and ac97
5474 * codec access problems. probably the serial clock becomes unsynced.
5475 * added code to sync the chips back up, but only helped about 70% the time.
5481 card->active_ctrl(card, 1);
5483 /* claim our iospace and irq */
5485 card->ba0 = ioremap_nocache(card->ba0_addr, CS461X_BA0_SIZE);
5486 card->ba1.name.data0 = ioremap_nocache(card->ba1_addr + BA1_SP_DMEM0, CS461X_BA1_DATA0_SIZE);
5487 card->ba1.name.data1 = ioremap_nocache(card->ba1_addr + BA1_SP_DMEM1, CS461X_BA1_DATA1_SIZE);
5488 card->ba1.name.pmem = ioremap_nocache(card->ba1_addr + BA1_SP_PMEM, CS461X_BA1_PRG_SIZE);
5489 card->ba1.name.reg = ioremap_nocache(card->ba1_addr + BA1_SP_REG, CS461X_BA1_REG_SIZE);
5491 CS_DBGOUT(CS_INIT, 4, printk(KERN_INFO
5492 "cs46xx: card=0x%x card->ba0=0x%.08x\n",(unsigned)card,(unsigned)card->ba0) );
5493 CS_DBGOUT(CS_INIT, 4, printk(KERN_INFO
5494 "cs46xx: card->ba1=0x%.08x 0x%.08x 0x%.08x 0x%.08x\n",
5495 (unsigned)card->ba1.name.data0,
5496 (unsigned)card->ba1.name.data1,
5497 (unsigned)card->ba1.name.pmem,
5498 (unsigned)card->ba1.name.reg) );
5500 if(card->ba0 == 0 || card->ba1.name.data0 == 0 ||
5501 card->ba1.name.data1 == 0 || card->ba1.name.pmem == 0 ||
5502 card->ba1.name.reg == 0)
5505 if (request_irq(card->irq, &cs_interrupt, SA_SHIRQ, "cs46xx", card)) {
5506 printk(KERN_ERR "cs46xx: unable to allocate irq %d\n", card->irq);
5509 /* register /dev/dsp */
5510 if ((card->dev_audio = register_sound_dsp(&cs461x_fops, -1)) < 0) {
5511 printk(KERN_ERR "cs46xx: unable to register dsp\n");
5515 /* register /dev/midi */
5516 if((card->dev_midi = register_sound_midi(&cs_midi_fops, -1)) < 0)
5517 printk(KERN_ERR "cs46xx: unable to register midi\n");
5519 card->pm.flags |= CS46XX_PM_IDLE;
5522 if (cs_hardware_init(card) != 0)
5524 CS_DBGOUT(CS_ERROR, 4, printk(
5525 "cs46xx: ERROR in cs_hardware_init()... retrying\n"));
5526 for (j = 0; j < NR_AC97; j++)
5527 if (card->ac97_codec[j] != NULL) {
5528 unregister_sound_mixer(card->ac97_codec[j]->dev_mixer);
5529 ac97_release_codec(card->ac97_codec[j]);
5531 mdelay(10 * cs_laptop_wait);
5538 CS_DBGOUT(CS_PM | CS_ERROR, 1, printk(
5539 "cs46xx: cs46xx_probe()- cs_hardware_init() failed, retried %d times.\n",i));
5540 unregister_sound_dsp(card->dev_audio);
5542 unregister_sound_midi(card->dev_midi);
5546 init_waitqueue_head(&card->midi.open_wait);
5547 init_MUTEX(&card->midi.open_sem);
5548 init_waitqueue_head(&card->midi.iwait);
5549 init_waitqueue_head(&card->midi.owait);
5550 cs461x_pokeBA0(card, BA0_MIDCR, MIDCR_MRST);
5551 cs461x_pokeBA0(card, BA0_MIDCR, 0);
5554 * Check if we have to init the amplifier, but probably already done
5555 * since the CD logic in the ac97 init code will turn on the ext amp.
5559 card->active_ctrl(card, -1);
5561 PCI_SET_DRIVER_DATA(pci_dev, card);
5562 PCI_SET_DMA_MASK(pci_dev, dma_mask);
5563 list_add(&card->list, &cs46xx_devs);
5565 pmdev = cs_pm_register(PM_PCI_DEV, PM_PCI_ID(pci_dev), cs46xx_pm_callback);
5568 CS_DBGOUT(CS_INIT | CS_PM, 4, printk(KERN_INFO
5569 "cs46xx: probe() pm_register() succeeded (0x%x).\n",
5575 CS_DBGOUT(CS_INIT | CS_PM | CS_ERROR, 2, printk(KERN_INFO
5576 "cs46xx: probe() pm_register() failed (0x%x).\n",
5578 card->pm.flags |= CS46XX_PM_NOT_REGISTERED;
5581 CS_DBGOUT(CS_PM, 9, printk(KERN_INFO "cs46xx: pm.flags=0x%x card=0x%x\n",
5582 (unsigned)card->pm.flags,(unsigned)card));
5584 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5585 "cs46xx: probe()- device allocated successfully\n"));
5589 free_irq(card->irq, card);
5593 if(card->ba1.name.data0)
5594 iounmap(card->ba1.name.data0);
5595 if(card->ba1.name.data1)
5596 iounmap(card->ba1.name.data1);
5597 if(card->ba1.name.pmem)
5598 iounmap(card->ba1.name.pmem);
5599 if(card->ba1.name.reg)
5600 iounmap(card->ba1.name.reg);
5602 CS_DBGOUT(CS_INIT | CS_ERROR, 1, printk(KERN_INFO
5603 "cs46xx: probe()- no device allocated\n"));
5607 // ---------------------------------------------------------------------
5609 static void __devexit cs46xx_remove(struct pci_dev *pci_dev)
5611 struct cs_card *card = PCI_GET_DRIVER_DATA(pci_dev);
5615 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5616 "cs46xx: cs46xx_remove()+\n"));
5618 card->active_ctrl(card,1);
5620 tmp = cs461x_peek(card, BA1_PFIE);
5623 cs461x_poke(card, BA1_PFIE, tmp); /* playback interrupt disable */
5625 tmp = cs461x_peek(card, BA1_CIE);
5628 cs461x_poke(card, BA1_CIE, tmp); /* capture interrupt disable */
5631 * Stop playback DMA.
5633 tmp = cs461x_peek(card, BA1_PCTL);
5634 cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
5639 tmp = cs461x_peek(card, BA1_CCTL);
5640 cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
5643 * Reset the processor.
5647 cs461x_proc_stop(card);
5650 * Power down the DAC and ADC. We will power them up (if) when we need
5653 if( (tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
5654 CS_POWER_MIXVON, CS_TRUE )) )
5656 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
5657 "cs46xx: cs461x_powerdown() failure (0x%x)\n",tmp) );
5661 * Power down the PLL.
5663 cs461x_pokeBA0(card, BA0_CLKCR1, 0);
5666 * Turn off the Processor by turning off the software clock enable flag in
5667 * the clock control register.
5669 tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE;
5670 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
5672 card->active_ctrl(card,-1);
5674 /* free hardware resources */
5675 free_irq(card->irq, card);
5677 iounmap(card->ba1.name.data0);
5678 iounmap(card->ba1.name.data1);
5679 iounmap(card->ba1.name.pmem);
5680 iounmap(card->ba1.name.reg);
5682 /* unregister audio devices */
5683 for (i = 0; i < NR_AC97; i++)
5684 if (card->ac97_codec[i] != NULL) {
5685 unregister_sound_mixer(card->ac97_codec[i]->dev_mixer);
5686 ac97_release_codec(card->ac97_codec[i]);
5688 unregister_sound_dsp(card->dev_audio);
5690 unregister_sound_midi(card->dev_midi);
5691 list_del(&card->list);
5693 PCI_SET_DRIVER_DATA(pci_dev,NULL);
5695 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5696 "cs46xx: cs46xx_remove()-: remove successful\n"));
5701 CS46XX_4612, /* same as 4630 */
5702 CS46XX_4615, /* same as 4624 */
5705 static struct pci_device_id cs46xx_pci_tbl[] = {
5707 .vendor = PCI_VENDOR_ID_CIRRUS,
5708 .device = PCI_DEVICE_ID_CIRRUS_4610,
5709 .subvendor = PCI_ANY_ID,
5710 .subdevice = PCI_ANY_ID,
5711 .driver_data = CS46XX_4610,
5714 .vendor = PCI_VENDOR_ID_CIRRUS,
5715 .device = PCI_DEVICE_ID_CIRRUS_4612,
5716 .subvendor = PCI_ANY_ID,
5717 .subdevice = PCI_ANY_ID,
5718 .driver_data = CS46XX_4612,
5721 .vendor = PCI_VENDOR_ID_CIRRUS,
5722 .device = PCI_DEVICE_ID_CIRRUS_4615,
5723 .subvendor = PCI_ANY_ID,
5724 .subdevice = PCI_ANY_ID,
5725 .driver_data = CS46XX_4615,
5730 MODULE_DEVICE_TABLE(pci, cs46xx_pci_tbl);
5732 struct pci_driver cs46xx_pci_driver = {
5734 .id_table = cs46xx_pci_tbl,
5735 .probe = cs46xx_probe,
5736 .remove = __devexit_p(cs46xx_remove),
5737 .suspend = CS46XX_SUSPEND_TBL,
5738 .resume = CS46XX_RESUME_TBL,
5741 int __init cs46xx_init_module(void)
5744 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5745 "cs46xx: cs46xx_init_module()+ \n"));
5746 rtn = pci_module_init(&cs46xx_pci_driver);
5750 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(
5751 "cs46xx: Unable to detect valid cs46xx device\n"));
5754 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2,
5755 printk(KERN_INFO "cs46xx: cs46xx_init_module()- (%d)\n",rtn));
5759 void __exit cs46xx_cleanup_module(void)
5761 pci_unregister_driver(&cs46xx_pci_driver);
5762 cs_pm_unregister_all(cs46xx_pm_callback);
5763 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2,
5764 printk(KERN_INFO "cs46xx: cleanup_cs46xx() finished\n"));
5767 module_init(cs46xx_init_module);
5768 module_exit(cs46xx_cleanup_module);
5770 int cs46xx_pm_callback(struct pm_dev *dev, pm_request_t rqst, void *data)
5772 struct cs_card *card;
5774 CS_DBGOUT(CS_PM, 2, printk(KERN_INFO
5775 "cs46xx: cs46xx_pm_callback dev=0x%x rqst=0x%x card=%d\n",
5776 (unsigned)dev,(unsigned)rqst,(unsigned)data));
5777 card = (struct cs_card *) dev->data;
5781 CS_DBGOUT(CS_PM, 2, printk(KERN_INFO
5782 "cs46xx: PM suspend request\n"));
5783 if(cs46xx_suspend(card, 0))
5785 CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
5786 "cs46xx: PM suspend request refused\n"));
5791 CS_DBGOUT(CS_PM, 2, printk(KERN_INFO
5792 "cs46xx: PM resume request\n"));
5793 if(cs46xx_resume(card))
5795 CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
5796 "cs46xx: PM resume request refused\n"));
5806 #if CS46XX_ACPI_SUPPORT
5807 static int cs46xx_suspend_tbl(struct pci_dev *pcidev, u32 state)
5809 struct cs_card *s = PCI_GET_DRIVER_DATA(pcidev);
5810 CS_DBGOUT(CS_PM | CS_FUNCTION, 2,
5811 printk(KERN_INFO "cs46xx: cs46xx_suspend_tbl request\n"));
5812 cs46xx_suspend(s, 0);
5816 static int cs46xx_resume_tbl(struct pci_dev *pcidev)
5818 struct cs_card *s = PCI_GET_DRIVER_DATA(pcidev);
5819 CS_DBGOUT(CS_PM | CS_FUNCTION, 2,
5820 printk(KERN_INFO "cs46xx: cs46xx_resume_tbl request\n"));