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 *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 *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=0x%.8x\n",
2050 dmabuf->fmt,(unsigned)cnt,(unsigned)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=0x%x src=0x%x cnt=%d\n",
2078 (unsigned)dest,(unsigned)src,cnt) );
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 *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=0x%.8x ret=%d\n",
2169 dmabuf->dmasize,dmabuf->count,(unsigned)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 *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;
2490 state = (struct cs_state *)card->states[0];
2493 dmabuf = &state->dmabuf;
2494 mapped = (file->f_mode & FMODE_READ) && dmabuf->mapped;
2496 state = (struct cs_state *)card->states[1];
2499 dmabuf = &state->dmabuf;
2500 mapped |= (file->f_mode & FMODE_WRITE) && dmabuf->mapped;
2509 case OSS_GETVERSION:
2510 return put_user(SOUND_VERSION, (int *)arg);
2512 case SNDCTL_DSP_RESET:
2513 /* FIXME: spin_lock ? */
2514 if (file->f_mode & FMODE_WRITE) {
2515 state = (struct cs_state *)card->states[1];
2518 dmabuf = &state->dmabuf;
2520 synchronize_irq(card->irq);
2522 resync_dma_ptrs(state);
2523 dmabuf->swptr = dmabuf->hwptr = 0;
2524 dmabuf->count = dmabuf->total_bytes = 0;
2529 if (file->f_mode & FMODE_READ) {
2530 state = (struct cs_state *)card->states[0];
2533 dmabuf = &state->dmabuf;
2535 synchronize_irq(card->irq);
2536 resync_dma_ptrs(state);
2538 dmabuf->swptr = dmabuf->hwptr = 0;
2539 dmabuf->count = dmabuf->total_bytes = 0;
2544 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_RESET()-\n") );
2547 case SNDCTL_DSP_SYNC:
2548 if (file->f_mode & FMODE_WRITE)
2549 return drain_dac(state, file->f_flags & O_NONBLOCK);
2552 case SNDCTL_DSP_SPEED: /* set sample rate */
2553 if (get_user(val, (int *)arg))
2556 if (file->f_mode & FMODE_READ) {
2557 state = (struct cs_state *)card->states[0];
2560 dmabuf = &state->dmabuf;
2564 cs_set_adc_rate(state, val);
2565 cs_set_divisor(dmabuf);
2568 if (file->f_mode & FMODE_WRITE) {
2569 state = (struct cs_state *)card->states[1];
2572 dmabuf = &state->dmabuf;
2576 cs_set_dac_rate(state, val);
2577 cs_set_divisor(dmabuf);
2580 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2581 "cs46xx: cs_ioctl() DSP_SPEED %s %s %d\n",
2582 file->f_mode & FMODE_WRITE ? "DAC" : "",
2583 file->f_mode & FMODE_READ ? "ADC" : "",
2585 return put_user(dmabuf->rate, (int *)arg);
2587 return put_user(0, (int *)arg);
2589 case SNDCTL_DSP_STEREO: /* set stereo or mono channel */
2590 if (get_user(val, (int *)arg))
2592 if (file->f_mode & FMODE_WRITE) {
2593 state = (struct cs_state *)card->states[1];
2596 dmabuf = &state->dmabuf;
2601 dmabuf->fmt |= CS_FMT_STEREO;
2603 dmabuf->fmt &= ~CS_FMT_STEREO;
2604 cs_set_divisor(dmabuf);
2605 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2606 "cs46xx: DSP_STEREO() DAC %s\n",
2607 (dmabuf->fmt & CS_FMT_STEREO) ?
2611 if (file->f_mode & FMODE_READ) {
2612 state = (struct cs_state *)card->states[0];
2615 dmabuf = &state->dmabuf;
2620 dmabuf->fmt |= CS_FMT_STEREO;
2622 dmabuf->fmt &= ~CS_FMT_STEREO;
2623 cs_set_divisor(dmabuf);
2624 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2625 "cs46xx: DSP_STEREO() ADC %s\n",
2626 (dmabuf->fmt & CS_FMT_STEREO) ?
2632 case SNDCTL_DSP_GETBLKSIZE:
2633 if (file->f_mode & FMODE_WRITE) {
2634 state = (struct cs_state *)card->states[1];
2637 dmabuf = &state->dmabuf;
2638 if ((val = prog_dmabuf(state)))
2640 return put_user(dmabuf->fragsize, (int *)arg);
2643 if (file->f_mode & FMODE_READ) {
2644 state = (struct cs_state *)card->states[0];
2647 dmabuf = &state->dmabuf;
2648 if ((val = prog_dmabuf(state)))
2650 return put_user(dmabuf->fragsize/dmabuf->divisor,
2654 return put_user(0, (int *)arg);
2656 case SNDCTL_DSP_GETFMTS: /* Returns a mask of supported sample format*/
2657 return put_user(AFMT_S16_LE | AFMT_U8, (int *)arg);
2659 case SNDCTL_DSP_SETFMT: /* Select sample format */
2660 if (get_user(val, (int *)arg))
2662 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2663 "cs46xx: cs_ioctl() DSP_SETFMT %s %s %s %s\n",
2664 file->f_mode & FMODE_WRITE ? "DAC" : "",
2665 file->f_mode & FMODE_READ ? "ADC" : "",
2666 val == AFMT_S16_LE ? "16Bit Signed" : "",
2667 val == AFMT_U8 ? "8Bit Unsigned" : "") );
2669 if (val != AFMT_QUERY) {
2670 if(val==AFMT_S16_LE || val==AFMT_U8)
2672 if (file->f_mode & FMODE_WRITE) {
2673 state = (struct cs_state *)card->states[1];
2676 dmabuf = &state->dmabuf;
2680 if(val==AFMT_S16_LE)
2681 dmabuf->fmt |= CS_FMT_16BIT;
2683 dmabuf->fmt &= ~CS_FMT_16BIT;
2684 cs_set_divisor(dmabuf);
2685 if((ret = prog_dmabuf(state)))
2689 if (file->f_mode & FMODE_READ) {
2691 state = (struct cs_state *)card->states[0];
2694 dmabuf = &state->dmabuf;
2698 if(val==AFMT_S16_LE)
2699 dmabuf->fmt |= CS_FMT_16BIT;
2701 dmabuf->fmt &= ~CS_FMT_16BIT;
2702 cs_set_divisor(dmabuf);
2703 if((ret = prog_dmabuf(state)))
2710 CS_DBGOUT(CS_IOCTL | CS_ERROR, 2, printk(
2711 "cs46xx: DSP_SETFMT() Unsupported format (0x%x)\n",
2717 if(file->f_mode & FMODE_WRITE)
2719 state = (struct cs_state *)card->states[1];
2721 dmabuf = &state->dmabuf;
2723 else if(file->f_mode & FMODE_READ)
2725 state = (struct cs_state *)card->states[0];
2727 dmabuf = &state->dmabuf;
2732 if(dmabuf->fmt & CS_FMT_16BIT)
2733 return put_user(AFMT_S16_LE, (int *)arg);
2735 return put_user(AFMT_U8, (int *)arg);
2737 return put_user(0, (int *)arg);
2739 case SNDCTL_DSP_CHANNELS:
2740 if (get_user(val, (int *)arg))
2743 if (file->f_mode & FMODE_WRITE) {
2744 state = (struct cs_state *)card->states[1];
2747 dmabuf = &state->dmabuf;
2752 dmabuf->fmt |= CS_FMT_STEREO;
2754 dmabuf->fmt &= ~CS_FMT_STEREO;
2755 cs_set_divisor(dmabuf);
2756 if (prog_dmabuf(state))
2760 if (file->f_mode & FMODE_READ) {
2761 state = (struct cs_state *)card->states[0];
2764 dmabuf = &state->dmabuf;
2769 dmabuf->fmt |= CS_FMT_STEREO;
2771 dmabuf->fmt &= ~CS_FMT_STEREO;
2772 cs_set_divisor(dmabuf);
2773 if (prog_dmabuf(state))
2778 return put_user((dmabuf->fmt & CS_FMT_STEREO) ? 2 : 1,
2781 case SNDCTL_DSP_POST:
2783 * There will be a longer than normal pause in the data.
2784 * so... do nothing, because there is nothing that we can do.
2788 case SNDCTL_DSP_SUBDIVIDE:
2789 if (file->f_mode & FMODE_WRITE) {
2790 state = (struct cs_state *)card->states[1];
2793 dmabuf = &state->dmabuf;
2794 if (dmabuf->subdivision)
2796 if (get_user(val, (int *)arg))
2798 if (val != 1 && val != 2)
2800 dmabuf->subdivision = val;
2803 if (file->f_mode & FMODE_READ) {
2804 state = (struct cs_state *)card->states[0];
2807 dmabuf = &state->dmabuf;
2808 if (dmabuf->subdivision)
2810 if (get_user(val, (int *)arg))
2812 if (val != 1 && val != 2)
2814 dmabuf->subdivision = val;
2819 case SNDCTL_DSP_SETFRAGMENT:
2820 if (get_user(val, (int *)arg))
2823 if (file->f_mode & FMODE_WRITE) {
2824 state = (struct cs_state *)card->states[1];
2827 dmabuf = &state->dmabuf;
2828 dmabuf->ossfragshift = val & 0xffff;
2829 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2832 if (file->f_mode & FMODE_READ) {
2833 state = (struct cs_state *)card->states[0];
2836 dmabuf = &state->dmabuf;
2837 dmabuf->ossfragshift = val & 0xffff;
2838 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2843 case SNDCTL_DSP_GETOSPACE:
2844 if (!(file->f_mode & FMODE_WRITE))
2846 state = (struct cs_state *)card->states[1];
2849 dmabuf = &state->dmabuf;
2850 spin_lock_irqsave(&state->card->lock, flags);
2851 cs_update_ptr(card, CS_TRUE);
2852 abinfo.fragsize = dmabuf->fragsize;
2853 abinfo.fragstotal = dmabuf->numfrag;
2855 * for mmap we always have total space available
2858 abinfo.bytes = dmabuf->dmasize;
2860 abinfo.bytes = dmabuf->dmasize - dmabuf->count;
2862 abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
2863 spin_unlock_irqrestore(&state->card->lock, flags);
2864 return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2868 case SNDCTL_DSP_GETISPACE:
2869 if (!(file->f_mode & FMODE_READ))
2871 state = (struct cs_state *)card->states[0];
2874 dmabuf = &state->dmabuf;
2875 spin_lock_irqsave(&state->card->lock, flags);
2876 cs_update_ptr(card, CS_TRUE);
2877 abinfo.fragsize = dmabuf->fragsize/dmabuf->divisor;
2878 abinfo.bytes = dmabuf->count/dmabuf->divisor;
2879 abinfo.fragstotal = dmabuf->numfrag;
2880 abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
2881 spin_unlock_irqrestore(&state->card->lock, flags);
2882 return copy_to_user((void *)arg, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2886 case SNDCTL_DSP_NONBLOCK:
2887 file->f_flags |= O_NONBLOCK;
2890 case SNDCTL_DSP_GETCAPS:
2891 return put_user(DSP_CAP_REALTIME|DSP_CAP_TRIGGER|DSP_CAP_MMAP,
2894 case SNDCTL_DSP_GETTRIGGER:
2896 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_GETTRIGGER()+\n") );
2897 if (file->f_mode & FMODE_WRITE)
2899 state = (struct cs_state *)card->states[1];
2902 dmabuf = &state->dmabuf;
2903 if(dmabuf->enable & DAC_RUNNING)
2904 val |= PCM_ENABLE_INPUT;
2907 if (file->f_mode & FMODE_READ)
2911 state = (struct cs_state *)card->states[0];
2912 dmabuf = &state->dmabuf;
2913 if(dmabuf->enable & ADC_RUNNING)
2914 val |= PCM_ENABLE_OUTPUT;
2917 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_GETTRIGGER()- val=0x%x\n",val) );
2918 return put_user(val, (int *)arg);
2920 case SNDCTL_DSP_SETTRIGGER:
2921 if (get_user(val, (int *)arg))
2923 if (file->f_mode & FMODE_READ) {
2924 state = (struct cs_state *)card->states[0];
2927 dmabuf = &state->dmabuf;
2928 if (val & PCM_ENABLE_INPUT) {
2929 if (!dmabuf->ready && (ret = prog_dmabuf(state)))
2936 if (file->f_mode & FMODE_WRITE) {
2937 state = (struct cs_state *)card->states[1];
2940 dmabuf = &state->dmabuf;
2941 if (val & PCM_ENABLE_OUTPUT) {
2942 if (!dmabuf->ready && (ret = prog_dmabuf(state)))
2951 case SNDCTL_DSP_GETIPTR:
2952 if (!(file->f_mode & FMODE_READ))
2954 state = (struct cs_state *)card->states[0];
2957 dmabuf = &state->dmabuf;
2958 spin_lock_irqsave(&state->card->lock, flags);
2959 cs_update_ptr(card, CS_TRUE);
2960 cinfo.bytes = dmabuf->total_bytes/dmabuf->divisor;
2961 cinfo.blocks = dmabuf->count/dmabuf->divisor >> dmabuf->fragshift;
2962 cinfo.ptr = dmabuf->hwptr/dmabuf->divisor;
2963 spin_unlock_irqrestore(&state->card->lock, flags);
2964 if (copy_to_user((void *)arg, &cinfo, sizeof(cinfo)))
2970 case SNDCTL_DSP_GETOPTR:
2971 if (!(file->f_mode & FMODE_WRITE))
2973 state = (struct cs_state *)card->states[1];
2976 dmabuf = &state->dmabuf;
2977 spin_lock_irqsave(&state->card->lock, flags);
2978 cs_update_ptr(card, CS_TRUE);
2979 cinfo.bytes = dmabuf->total_bytes;
2982 cinfo.blocks = (cinfo.bytes >> dmabuf->fragshift)
2984 CS_DBGOUT(CS_PARMS, 8,
2985 printk("total_bytes=%d blocks=%d dmabuf->blocks=%d\n",
2986 cinfo.bytes,cinfo.blocks,dmabuf->blocks) );
2987 dmabuf->blocks = cinfo.bytes >> dmabuf->fragshift;
2991 cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
2993 cinfo.ptr = dmabuf->hwptr;
2995 CS_DBGOUT(CS_PARMS, 4, printk(
2996 "cs46xx: GETOPTR bytes=%d blocks=%d ptr=%d\n",
2997 cinfo.bytes,cinfo.blocks,cinfo.ptr) );
2998 spin_unlock_irqrestore(&state->card->lock, flags);
2999 if (copy_to_user((void *)arg, &cinfo, sizeof(cinfo)))
3005 case SNDCTL_DSP_SETDUPLEX:
3008 case SNDCTL_DSP_GETODELAY:
3009 if (!(file->f_mode & FMODE_WRITE))
3011 state = (struct cs_state *)card->states[1];
3014 dmabuf = &state->dmabuf;
3015 spin_lock_irqsave(&state->card->lock, flags);
3016 cs_update_ptr(card, CS_TRUE);
3017 val = dmabuf->count;
3018 spin_unlock_irqrestore(&state->card->lock, flags);
3022 return put_user(val, (int *)arg);
3024 case SOUND_PCM_READ_RATE:
3025 if(file->f_mode & FMODE_READ)
3026 state = (struct cs_state *)card->states[0];
3028 state = (struct cs_state *)card->states[1];
3031 dmabuf = &state->dmabuf;
3032 return put_user(dmabuf->rate, (int *)arg);
3034 return put_user(0, (int *)arg);
3037 case SOUND_PCM_READ_CHANNELS:
3038 if(file->f_mode & FMODE_READ)
3039 state = (struct cs_state *)card->states[0];
3041 state = (struct cs_state *)card->states[1];
3044 dmabuf = &state->dmabuf;
3045 return put_user((dmabuf->fmt & CS_FMT_STEREO) ? 2 : 1,
3048 return put_user(0, (int *)arg);
3050 case SOUND_PCM_READ_BITS:
3051 if(file->f_mode & FMODE_READ)
3052 state = (struct cs_state *)card->states[0];
3054 state = (struct cs_state *)card->states[1];
3057 dmabuf = &state->dmabuf;
3058 return put_user((dmabuf->fmt & CS_FMT_16BIT) ?
3059 AFMT_S16_LE : AFMT_U8, (int *)arg);
3062 return put_user(0, (int *)arg);
3064 case SNDCTL_DSP_MAPINBUF:
3065 case SNDCTL_DSP_MAPOUTBUF:
3066 case SNDCTL_DSP_SETSYNCRO:
3067 case SOUND_PCM_WRITE_FILTER:
3068 case SOUND_PCM_READ_FILTER:
3076 * AMP control - null AMP
3079 static void amp_none(struct cs_card *card, int change)
3087 static void amp_voyetra(struct cs_card *card, int change)
3089 /* Manage the EAPD bit on the Crystal 4297
3090 and the Analog AD1885 */
3092 int old=card->amplifier;
3094 card->amplifier+=change;
3095 if(card->amplifier && !old)
3097 /* Turn the EAPD amp on */
3098 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL,
3099 cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) |
3102 else if(old && !card->amplifier)
3104 /* Turn the EAPD amp off */
3105 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL,
3106 cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
3113 * Game Theatre XP card - EGPIO[2] is used to enable the external amp.
3116 static void amp_hercules(struct cs_card *card, int change)
3118 int old=card->amplifier;
3121 CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
3122 "cs46xx: amp_hercules() called before initialized.\n"));
3125 card->amplifier+=change;
3126 if( (card->amplifier && !old) && !(hercules_egpio_disable))
3128 CS_DBGOUT(CS_PARMS, 4, printk(KERN_INFO
3129 "cs46xx: amp_hercules() external amp enabled\n"));
3130 cs461x_pokeBA0(card, BA0_EGPIODR,
3131 EGPIODR_GPOE2); /* enable EGPIO2 output */
3132 cs461x_pokeBA0(card, BA0_EGPIOPTR,
3133 EGPIOPTR_GPPT2); /* open-drain on output */
3135 else if(old && !card->amplifier)
3137 CS_DBGOUT(CS_PARMS, 4, printk(KERN_INFO
3138 "cs46xx: amp_hercules() external amp disabled\n"));
3139 cs461x_pokeBA0(card, BA0_EGPIODR, 0); /* disable */
3140 cs461x_pokeBA0(card, BA0_EGPIOPTR, 0); /* disable */
3145 * Handle the CLKRUN on a thinkpad. We must disable CLKRUN support
3146 * whenever we need to beat on the chip.
3148 * The original idea and code for this hack comes from David Kaiser at
3149 * Linuxcare. Perhaps one day Crystal will document their chips well
3150 * enough to make them useful.
3153 static void clkrun_hack(struct cs_card *card, int change)
3155 struct pci_dev *acpi_dev;
3159 int old=card->active;
3161 card->active+=change;
3163 acpi_dev = pci_find_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371AB_3, NULL);
3164 if(acpi_dev == NULL)
3165 return; /* Not a thinkpad thats for sure */
3167 /* Find the control port */
3168 pci_read_config_byte(acpi_dev, 0x41, &pp);
3171 /* Read ACPI port */
3172 control=inw(port+0x10);
3174 /* Flip CLKRUN off while running */
3175 if(!card->active && old)
3177 CS_DBGOUT(CS_PARMS , 9, printk( KERN_INFO
3178 "cs46xx: clkrun() enable clkrun - change=%d active=%d\n",
3179 change,card->active));
3180 outw(control|0x2000, port+0x10);
3185 * sometimes on a resume the bit is set, so always reset the bit.
3187 CS_DBGOUT(CS_PARMS , 9, printk( KERN_INFO
3188 "cs46xx: clkrun() disable clkrun - change=%d active=%d\n",
3189 change,card->active));
3190 outw(control&~0x2000, port+0x10);
3195 static int cs_open(struct inode *inode, struct file *file)
3197 struct cs_card *card = (struct cs_card *)file->private_data;
3198 struct cs_state *state = NULL;
3199 struct dmabuf *dmabuf = NULL;
3200 struct list_head *entry;
3201 unsigned int minor = iminor(inode);
3205 CS_DBGOUT(CS_OPEN | CS_FUNCTION, 2, printk("cs46xx: cs_open()+ file=0x%x %s %s\n",
3206 (unsigned)file, file->f_mode & FMODE_WRITE ? "FMODE_WRITE" : "",
3207 file->f_mode & FMODE_READ ? "FMODE_READ" : "") );
3209 list_for_each(entry, &cs46xx_devs)
3211 card = list_entry(entry, struct cs_card, list);
3213 if (!((card->dev_audio ^ minor) & ~0xf))
3216 if (entry == &cs46xx_devs)
3219 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 2, printk(KERN_INFO
3220 "cs46xx: cs_open(): Error - unable to find audio card struct\n"));
3225 * hardcode state[0] for capture, [1] for playback
3227 if(file->f_mode & FMODE_READ)
3229 CS_DBGOUT(CS_WAVE_READ, 2, printk("cs46xx: cs_open() FMODE_READ\n") );
3230 if (card->states[0] == NULL) {
3231 state = card->states[0] = (struct cs_state *)
3232 kmalloc(sizeof(struct cs_state), GFP_KERNEL);
3235 memset(state, 0, sizeof(struct cs_state));
3236 init_MUTEX(&state->sem);
3237 dmabuf = &state->dmabuf;
3238 dmabuf->pbuf = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
3239 if(dmabuf->pbuf==NULL)
3242 card->states[0]=NULL;
3248 state = card->states[0];
3249 if(state->open_mode & FMODE_READ)
3252 dmabuf->channel = card->alloc_rec_pcm_channel(card);
3254 if (dmabuf->channel == NULL) {
3255 kfree (card->states[0]);
3256 card->states[0] = NULL;
3260 /* Now turn on external AMP if needed */
3262 state->card->active_ctrl(state->card,1);
3263 state->card->amplifier_ctrl(state->card,1);
3265 if( (tmp = cs46xx_powerup(card, CS_POWER_ADC)) )
3267 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3268 "cs46xx: cs46xx_powerup of ADC failed (0x%x)\n",tmp) );
3272 dmabuf->channel->state = state;
3273 /* initialize the virtual channel */
3275 state->magic = CS_STATE_MAGIC;
3276 init_waitqueue_head(&dmabuf->wait);
3277 init_MUTEX(&state->open_sem);
3278 file->private_data = card;
3280 down(&state->open_sem);
3282 /* set default sample format. According to OSS Programmer's Guide /dev/dsp
3283 should be default to unsigned 8-bits, mono, with sample rate 8kHz and
3284 /dev/dspW will accept 16-bits sample */
3286 /* Default input is 8bit mono */
3287 dmabuf->fmt &= ~CS_FMT_MASK;
3288 dmabuf->type = CS_TYPE_ADC;
3289 dmabuf->ossfragshift = 0;
3290 dmabuf->ossmaxfrags = 0;
3291 dmabuf->subdivision = 0;
3292 cs_set_adc_rate(state, 8000);
3293 cs_set_divisor(dmabuf);
3295 state->open_mode |= FMODE_READ;
3296 up(&state->open_sem);
3298 if(file->f_mode & FMODE_WRITE)
3300 CS_DBGOUT(CS_OPEN, 2, printk("cs46xx: cs_open() FMODE_WRITE\n") );
3301 if (card->states[1] == NULL) {
3302 state = card->states[1] = (struct cs_state *)
3303 kmalloc(sizeof(struct cs_state), GFP_KERNEL);
3306 memset(state, 0, sizeof(struct cs_state));
3307 init_MUTEX(&state->sem);
3308 dmabuf = &state->dmabuf;
3309 dmabuf->pbuf = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
3310 if(dmabuf->pbuf==NULL)
3313 card->states[1]=NULL;
3319 state = card->states[1];
3320 if(state->open_mode & FMODE_WRITE)
3323 dmabuf->channel = card->alloc_pcm_channel(card);
3325 if (dmabuf->channel == NULL) {
3326 kfree (card->states[1]);
3327 card->states[1] = NULL;
3331 /* Now turn on external AMP if needed */
3333 state->card->active_ctrl(state->card,1);
3334 state->card->amplifier_ctrl(state->card,1);
3336 if( (tmp = cs46xx_powerup(card, CS_POWER_DAC)) )
3338 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3339 "cs46xx: cs46xx_powerup of DAC failed (0x%x)\n",tmp) );
3343 dmabuf->channel->state = state;
3344 /* initialize the virtual channel */
3346 state->magic = CS_STATE_MAGIC;
3347 init_waitqueue_head(&dmabuf->wait);
3348 init_MUTEX(&state->open_sem);
3349 file->private_data = card;
3351 down(&state->open_sem);
3353 /* set default sample format. According to OSS Programmer's Guide /dev/dsp
3354 should be default to unsigned 8-bits, mono, with sample rate 8kHz and
3355 /dev/dspW will accept 16-bits sample */
3357 /* Default output is 8bit mono. */
3358 dmabuf->fmt &= ~CS_FMT_MASK;
3359 dmabuf->type = CS_TYPE_DAC;
3360 dmabuf->ossfragshift = 0;
3361 dmabuf->ossmaxfrags = 0;
3362 dmabuf->subdivision = 0;
3363 cs_set_dac_rate(state, 8000);
3364 cs_set_divisor(dmabuf);
3366 state->open_mode |= FMODE_WRITE;
3367 up(&state->open_sem);
3368 if((ret = prog_dmabuf(state)))
3371 CS_DBGOUT(CS_OPEN | CS_FUNCTION, 2, printk("cs46xx: cs_open()- 0\n") );
3375 static int cs_release(struct inode *inode, struct file *file)
3377 struct cs_card *card = (struct cs_card *)file->private_data;
3378 struct dmabuf *dmabuf;
3379 struct cs_state *state;
3381 CS_DBGOUT(CS_RELEASE | CS_FUNCTION, 2, printk("cs46xx: cs_release()+ file=0x%x %s %s\n",
3382 (unsigned)file, file->f_mode & FMODE_WRITE ? "FMODE_WRITE" : "",
3383 file->f_mode & FMODE_READ ? "FMODE_READ" : "") );
3385 if (!(file->f_mode & (FMODE_WRITE | FMODE_READ)))
3389 state = card->states[1];
3392 if ( (state->open_mode & FMODE_WRITE) & (file->f_mode & FMODE_WRITE) )
3394 CS_DBGOUT(CS_RELEASE, 2, printk("cs46xx: cs_release() FMODE_WRITE\n") );
3395 dmabuf = &state->dmabuf;
3396 cs_clear_tail(state);
3397 drain_dac(state, file->f_flags & O_NONBLOCK);
3398 /* stop DMA state machine and free DMA buffers/channels */
3399 down(&state->open_sem);
3401 dealloc_dmabuf(state);
3402 state->card->free_pcm_channel(state->card, dmabuf->channel->num);
3403 free_page((unsigned long)state->dmabuf.pbuf);
3405 /* we're covered by the open_sem */
3406 up(&state->open_sem);
3407 state->card->states[state->virt] = NULL;
3408 state->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
3410 if( (tmp = cs461x_powerdown(card, CS_POWER_DAC, CS_FALSE )) )
3412 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
3413 "cs46xx: cs_release_mixdev() powerdown DAC failure (0x%x)\n",tmp) );
3416 /* Now turn off external AMP if needed */
3417 state->card->amplifier_ctrl(state->card, -1);
3418 state->card->active_ctrl(state->card, -1);
3424 state = card->states[0];
3427 if ( (state->open_mode & FMODE_READ) & (file->f_mode & FMODE_READ) )
3429 CS_DBGOUT(CS_RELEASE, 2, printk("cs46xx: cs_release() FMODE_READ\n") );
3430 dmabuf = &state->dmabuf;
3431 down(&state->open_sem);
3433 dealloc_dmabuf(state);
3434 state->card->free_pcm_channel(state->card, dmabuf->channel->num);
3435 free_page((unsigned long)state->dmabuf.pbuf);
3437 /* we're covered by the open_sem */
3438 up(&state->open_sem);
3439 state->card->states[state->virt] = NULL;
3440 state->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
3442 if( (tmp = cs461x_powerdown(card, CS_POWER_ADC, CS_FALSE )) )
3444 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
3445 "cs46xx: cs_release_mixdev() powerdown ADC failure (0x%x)\n",tmp) );
3448 /* Now turn off external AMP if needed */
3449 state->card->amplifier_ctrl(state->card, -1);
3450 state->card->active_ctrl(state->card, -1);
3456 CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 2, printk("cs46xx: cs_release()- 0\n") );
3460 static void printpm(struct cs_card *s)
3462 CS_DBGOUT(CS_PM, 9, printk("pm struct:\n"));
3463 CS_DBGOUT(CS_PM, 9, printk("flags:0x%x u32CLKCR1_SAVE: 0%x u32SSPMValue: 0x%x\n",
3464 (unsigned)s->pm.flags,s->pm.u32CLKCR1_SAVE,s->pm.u32SSPMValue));
3465 CS_DBGOUT(CS_PM, 9, printk("u32PPLVCvalue: 0x%x u32PPRVCvalue: 0x%x\n",
3466 s->pm.u32PPLVCvalue,s->pm.u32PPRVCvalue));
3467 CS_DBGOUT(CS_PM, 9, printk("u32FMLVCvalue: 0x%x u32FMRVCvalue: 0x%x\n",
3468 s->pm.u32FMLVCvalue,s->pm.u32FMRVCvalue));
3469 CS_DBGOUT(CS_PM, 9, printk("u32GPIORvalue: 0x%x u32JSCTLvalue: 0x%x\n",
3470 s->pm.u32GPIORvalue,s->pm.u32JSCTLvalue));
3471 CS_DBGOUT(CS_PM, 9, printk("u32SSCR: 0x%x u32SRCSA: 0x%x\n",
3472 s->pm.u32SSCR,s->pm.u32SRCSA));
3473 CS_DBGOUT(CS_PM, 9, printk("u32DacASR: 0x%x u32AdcASR: 0x%x\n",
3474 s->pm.u32DacASR,s->pm.u32AdcASR));
3475 CS_DBGOUT(CS_PM, 9, printk("u32DacSR: 0x%x u32AdcSR: 0x%x\n",
3476 s->pm.u32DacSR,s->pm.u32AdcSR));
3477 CS_DBGOUT(CS_PM, 9, printk("u32MIDCR_Save: 0x%x\n",
3478 s->pm.u32MIDCR_Save));
3479 CS_DBGOUT(CS_PM, 9, printk("u32AC97_powerdown: 0x%x _general_purpose 0x%x\n",
3480 s->pm.u32AC97_powerdown,s->pm.u32AC97_general_purpose));
3481 CS_DBGOUT(CS_PM, 9, printk("u32AC97_master_volume: 0x%x\n",
3482 s->pm.u32AC97_master_volume));
3483 CS_DBGOUT(CS_PM, 9, printk("u32AC97_headphone_volume: 0x%x\n",
3484 s->pm.u32AC97_headphone_volume));
3485 CS_DBGOUT(CS_PM, 9, printk("u32AC97_master_volume_mono: 0x%x\n",
3486 s->pm.u32AC97_master_volume_mono));
3487 CS_DBGOUT(CS_PM, 9, printk("u32AC97_pcm_out_volume: 0x%x\n",
3488 s->pm.u32AC97_pcm_out_volume));
3489 CS_DBGOUT(CS_PM, 9, printk("dmabuf_swptr_play: 0x%x dmabuf_count_play: %d\n",
3490 s->pm.dmabuf_swptr_play,s->pm.dmabuf_count_play));
3491 CS_DBGOUT(CS_PM, 9, printk("dmabuf_swptr_capture: 0x%x dmabuf_count_capture: %d\n",
3492 s->pm.dmabuf_swptr_capture,s->pm.dmabuf_count_capture));
3496 /****************************************************************************
3498 * Suspend - save the ac97 regs, mute the outputs and power down the part.
3500 ****************************************************************************/
3501 void cs46xx_ac97_suspend(struct cs_card *card)
3504 struct ac97_codec *dev=card->ac97_codec[0];
3507 CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_suspend()+\n"));
3511 stop_dac(card->states[1]);
3512 resync_dma_ptrs(card->states[1]);
3516 stop_adc(card->states[0]);
3517 resync_dma_ptrs(card->states[0]);
3520 for(Count = 0x2, i=0; (Count <= CS46XX_AC97_HIGHESTREGTORESTORE)
3521 && (i < CS46XX_AC97_NUMBER_RESTORE_REGS);
3524 card->pm.ac97[i] = cs_ac97_get(dev, BA0_AC97_RESET + Count);
3527 * Save the ac97 volume registers as well as the current powerdown state.
3528 * Now, mute the all the outputs (master, headphone, and mono), as well
3529 * as the PCM volume, in preparation for powering down the entire part.
3530 card->pm.u32AC97_master_volume = (u32)cs_ac97_get( dev,
3531 (u8)BA0_AC97_MASTER_VOLUME);
3532 card->pm.u32AC97_headphone_volume = (u32)cs_ac97_get(dev,
3533 (u8)BA0_AC97_HEADPHONE_VOLUME);
3534 card->pm.u32AC97_master_volume_mono = (u32)cs_ac97_get(dev,
3535 (u8)BA0_AC97_MASTER_VOLUME_MONO);
3536 card->pm.u32AC97_pcm_out_volume = (u32)cs_ac97_get(dev,
3537 (u8)BA0_AC97_PCM_OUT_VOLUME);
3542 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME, 0x8000);
3543 cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, 0x8000);
3544 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, 0x8000);
3545 cs_ac97_set(dev, (u8)BA0_AC97_PCM_OUT_VOLUME, 0x8000);
3548 * save the registers that cause pops
3550 card->pm.u32AC97_powerdown = (u32)cs_ac97_get(dev, (u8)AC97_POWER_CONTROL);
3551 card->pm.u32AC97_general_purpose = (u32)cs_ac97_get(dev, (u8)BA0_AC97_GENERAL_PURPOSE);
3553 * And power down everything on the AC97 codec.
3554 * well, for now, only power down the DAC/ADC and MIXER VREFON components.
3555 * trouble with removing VREF.
3557 if( (tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
3558 CS_POWER_MIXVON, CS_TRUE )) )
3560 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3561 "cs46xx: cs46xx_ac97_suspend() failure (0x%x)\n",tmp) );
3564 CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_suspend()-\n"));
3567 /****************************************************************************
3569 * Resume - power up the part and restore its registers..
3571 ****************************************************************************/
3572 void cs46xx_ac97_resume(struct cs_card *card)
3575 struct ac97_codec *dev=card->ac97_codec[0];
3577 CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_resume()+\n"));
3580 * First, we restore the state of the general purpose register. This
3581 * contains the mic select (mic1 or mic2) and if we restore this after
3582 * we restore the mic volume/boost state and mic2 was selected at
3583 * suspend time, we will end up with a brief period of time where mic1
3584 * is selected with the volume/boost settings for mic2, causing
3585 * acoustic feedback. So we restore the general purpose register
3586 * first, thereby getting the correct mic selected before we restore
3587 * the mic volume/boost.
3589 cs_ac97_set(dev, (u8)BA0_AC97_GENERAL_PURPOSE,
3590 (u16)card->pm.u32AC97_general_purpose);
3592 * Now, while the outputs are still muted, restore the state of power
3595 cs_ac97_set(dev, (u8)BA0_AC97_POWERDOWN, (u16)card->pm.u32AC97_powerdown);
3596 mdelay(5 * cs_laptop_wait);
3598 * Restore just the first set of registers, from register number
3599 * 0x02 to the register number that ulHighestRegToRestore specifies.
3601 for( Count = 0x2, i=0;
3602 (Count <= CS46XX_AC97_HIGHESTREGTORESTORE)
3603 && (i < CS46XX_AC97_NUMBER_RESTORE_REGS);
3606 cs_ac97_set(dev, (u8)(BA0_AC97_RESET + Count), (u16)card->pm.ac97[i]);
3609 /* Check if we have to init the amplifier */
3611 card->amp_init(card);
3613 CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_resume()-\n"));
3617 static int cs46xx_restart_part(struct cs_card *card)
3619 struct dmabuf *dmabuf;
3620 CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3621 printk( "cs46xx: cs46xx_restart_part()+\n"));
3624 dmabuf = &card->states[1]->dmabuf;
3626 resync_dma_ptrs(card->states[1]);
3627 cs_set_divisor(dmabuf);
3628 if(__prog_dmabuf(card->states[1]))
3630 CS_DBGOUT(CS_PM | CS_ERROR, 1,
3631 printk("cs46xx: cs46xx_restart_part()- (-1) prog_dmabuf() dac error\n"));
3634 cs_set_dac_rate(card->states[1], dmabuf->rate);
3638 dmabuf = &card->states[0]->dmabuf;
3640 resync_dma_ptrs(card->states[0]);
3641 cs_set_divisor(dmabuf);
3642 if(__prog_dmabuf(card->states[0]))
3644 CS_DBGOUT(CS_PM | CS_ERROR, 1,
3645 printk("cs46xx: cs46xx_restart_part()- (-1) prog_dmabuf() adc error\n"));
3648 cs_set_adc_rate(card->states[0], dmabuf->rate);
3650 card->pm.flags |= CS46XX_PM_RESUMED;
3652 start_adc(card->states[0]);
3654 start_dac(card->states[1]);
3656 card->pm.flags |= CS46XX_PM_IDLE;
3657 card->pm.flags &= ~(CS46XX_PM_SUSPENDING | CS46XX_PM_SUSPENDED
3658 | CS46XX_PM_RESUMING | CS46XX_PM_RESUMED);
3660 wake_up(&card->states[0]->dmabuf.wait);
3662 wake_up(&card->states[1]->dmabuf.wait);
3664 CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3665 printk( "cs46xx: cs46xx_restart_part()-\n"));
3670 static void cs461x_reset(struct cs_card *card);
3671 static void cs461x_proc_stop(struct cs_card *card);
3672 static int cs46xx_suspend(struct cs_card *card, u32 state)
3675 CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3676 printk("cs46xx: cs46xx_suspend()+ flags=0x%x s=0x%x\n",
3677 (unsigned)card->pm.flags,(unsigned)card));
3679 * check the current state, only suspend if IDLE
3681 if(!(card->pm.flags & CS46XX_PM_IDLE))
3683 CS_DBGOUT(CS_PM | CS_ERROR, 2,
3684 printk("cs46xx: cs46xx_suspend() unable to suspend, not IDLE\n"));
3687 card->pm.flags &= ~CS46XX_PM_IDLE;
3688 card->pm.flags |= CS46XX_PM_SUSPENDING;
3690 card->active_ctrl(card,1);
3692 tmp = cs461x_peek(card, BA1_PFIE);
3695 cs461x_poke(card, BA1_PFIE, tmp); /* playback interrupt disable */
3697 tmp = cs461x_peek(card, BA1_CIE);
3700 cs461x_poke(card, BA1_CIE, tmp); /* capture interrupt disable */
3703 * Stop playback DMA.
3705 tmp = cs461x_peek(card, BA1_PCTL);
3706 cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
3711 tmp = cs461x_peek(card, BA1_CCTL);
3712 cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
3716 card->pm.dmabuf_swptr_play = card->states[1]->dmabuf.swptr;
3717 card->pm.dmabuf_count_play = card->states[1]->dmabuf.count;
3721 card->pm.dmabuf_swptr_capture = card->states[0]->dmabuf.swptr;
3722 card->pm.dmabuf_count_capture = card->states[0]->dmabuf.count;
3725 cs46xx_ac97_suspend(card);
3728 * Reset the processor.
3732 cs461x_proc_stop(card);
3735 * Power down the DAC and ADC. For now leave the other areas on.
3737 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, 0x0300);
3740 * Power down the PLL.
3742 cs461x_pokeBA0(card, BA0_CLKCR1, 0);
3745 * Turn off the Processor by turning off the software clock enable flag in
3746 * the clock control register.
3748 tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE;
3749 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
3751 card->active_ctrl(card,-1);
3753 card->pm.flags &= ~CS46XX_PM_SUSPENDING;
3754 card->pm.flags |= CS46XX_PM_SUSPENDED;
3758 CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3759 printk("cs46xx: cs46xx_suspend()- flags=0x%x\n",
3760 (unsigned)card->pm.flags));
3764 static int cs46xx_resume(struct cs_card *card)
3768 CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3769 printk( "cs46xx: cs46xx_resume()+ flags=0x%x\n",
3770 (unsigned)card->pm.flags));
3771 if(!(card->pm.flags & CS46XX_PM_SUSPENDED))
3773 CS_DBGOUT(CS_PM | CS_ERROR, 2,
3774 printk("cs46xx: cs46xx_resume() unable to resume, not SUSPENDED\n"));
3777 card->pm.flags |= CS46XX_PM_RESUMING;
3778 card->pm.flags &= ~CS46XX_PM_SUSPENDED;
3780 card->active_ctrl(card, 1);
3784 if (cs_hardware_init(card) != 0)
3786 CS_DBGOUT(CS_PM | CS_ERROR, 4, printk(
3787 "cs46xx: cs46xx_resume()- ERROR in cs_hardware_init()\n"));
3788 mdelay(10 * cs_laptop_wait);
3796 CS_DBGOUT(CS_PM | CS_ERROR, 1, printk(
3797 "cs46xx: cs46xx_resume()- cs_hardware_init() failed, retried %d times.\n",i));
3801 if(cs46xx_restart_part(card))
3803 CS_DBGOUT(CS_PM | CS_ERROR, 4, printk(
3804 "cs46xx: cs46xx_resume(): cs46xx_restart_part() returned error\n"));
3807 card->active_ctrl(card, -1);
3809 CS_DBGOUT(CS_PM | CS_FUNCTION, 4, printk("cs46xx: cs46xx_resume()- flags=0x%x\n",
3810 (unsigned)card->pm.flags));
3814 static /*const*/ struct file_operations cs461x_fops = {
3815 CS_OWNER CS_THIS_MODULE
3816 .llseek = no_llseek,
3823 .release = cs_release,
3826 /* Write AC97 codec registers */
3829 static u16 _cs_ac97_get(struct ac97_codec *dev, u8 reg)
3831 struct cs_card *card = dev->private_data;
3837 * 1. Write ACCAD = Command Address Register = 46Ch for AC97 register address
3838 * 2. Write ACCDA = Command Data Register = 470h for data to write to AC97
3839 * 3. Write ACCTL = Control Register = 460h for initiating the write
3840 * 4. Read ACCTL = 460h, DCV should be reset by now and 460h = 17h
3841 * 5. if DCV not cleared, break and return error
3842 * 6. Read ACSTS = Status Register = 464h, check VSTS bit
3845 cs461x_peekBA0(card, BA0_ACSDA);
3848 * Setup the AC97 control registers on the CS461x to send the
3849 * appropriate command to the AC97 to perform the read.
3850 * ACCAD = Command Address Register = 46Ch
3851 * ACCDA = Command Data Register = 470h
3852 * ACCTL = Control Register = 460h
3853 * set DCV - will clear when process completed
3854 * set CRW - Read command
3855 * set VFRM - valid frame enabled
3856 * set ESYN - ASYNC generation enabled
3857 * set RSTN - ARST# inactive, AC97 codec not reset
3860 cs461x_pokeBA0(card, BA0_ACCAD, reg);
3861 cs461x_pokeBA0(card, BA0_ACCDA, 0);
3862 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_DCV | ACCTL_CRW |
3863 ACCTL_VFRM | ACCTL_ESYN |
3868 * Wait for the read to occur.
3870 if(!(card->pm.flags & CS46XX_PM_IDLE))
3873 loopcnt = 500 * cs_laptop_wait;
3874 loopcnt *= cs_laptop_wait;
3875 for (count = 0; count < loopcnt; count++) {
3877 * First, we want to wait for a short time.
3879 udelay(10 * cs_laptop_wait);
3881 * Now, check to see if the read has completed.
3882 * ACCTL = 460h, DCV should be reset by now and 460h = 17h
3884 if (!(cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV))
3889 * Make sure the read completed.
3891 if (cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV) {
3892 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
3893 "cs46xx: AC'97 read problem (ACCTL_DCV), reg = 0x%x returning 0xffff\n", reg));
3898 * Wait for the valid status bit to go active.
3901 if(!(card->pm.flags & CS46XX_PM_IDLE))
3905 loopcnt *= cs_laptop_wait;
3906 for (count = 0; count < loopcnt; count++) {
3908 * Read the AC97 status register.
3909 * ACSTS = Status Register = 464h
3910 * VSTS - Valid Status
3912 if (cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_VSTS)
3914 udelay(10 * cs_laptop_wait);
3918 * Make sure we got valid status.
3920 if (!( (tmp=cs461x_peekBA0(card, BA0_ACSTS)) & ACSTS_VSTS)) {
3921 CS_DBGOUT(CS_ERROR, 2, printk(KERN_WARNING
3922 "cs46xx: AC'97 read problem (ACSTS_VSTS), reg = 0x%x val=0x%x 0xffff \n",
3928 * Read the data returned from the AC97 register.
3929 * ACSDA = Status Data Register = 474h
3931 CS_DBGOUT(CS_FUNCTION, 9, printk(KERN_INFO
3932 "cs46xx: cs_ac97_get() reg = 0x%x, val = 0x%x, BA0_ACCAD = 0x%x\n",
3933 reg, cs461x_peekBA0(card, BA0_ACSDA),
3934 cs461x_peekBA0(card, BA0_ACCAD)));
3935 ret = cs461x_peekBA0(card, BA0_ACSDA);
3939 static u16 cs_ac97_get(struct ac97_codec *dev, u8 reg)
3942 struct cs_card *card = dev->private_data;
3944 spin_lock(&card->ac97_lock);
3945 ret = _cs_ac97_get(dev, reg);
3946 spin_unlock(&card->ac97_lock);
3950 static void cs_ac97_set(struct ac97_codec *dev, u8 reg, u16 val)
3952 struct cs_card *card = dev->private_data;
3956 spin_lock(&card->ac97_lock);
3958 if(reg == AC97_CD_VOL)
3960 val2 = _cs_ac97_get(dev, AC97_CD_VOL);
3965 * 1. Write ACCAD = Command Address Register = 46Ch for AC97 register address
3966 * 2. Write ACCDA = Command Data Register = 470h for data to write to AC97
3967 * 3. Write ACCTL = Control Register = 460h for initiating the write
3968 * 4. Read ACCTL = 460h, DCV should be reset by now and 460h = 07h
3969 * 5. if DCV not cleared, break and return error
3973 * Setup the AC97 control registers on the CS461x to send the
3974 * appropriate command to the AC97 to perform the read.
3975 * ACCAD = Command Address Register = 46Ch
3976 * ACCDA = Command Data Register = 470h
3977 * ACCTL = Control Register = 460h
3978 * set DCV - will clear when process completed
3979 * reset CRW - Write command
3980 * set VFRM - valid frame enabled
3981 * set ESYN - ASYNC generation enabled
3982 * set RSTN - ARST# inactive, AC97 codec not reset
3984 cs461x_pokeBA0(card, BA0_ACCAD, reg);
3985 cs461x_pokeBA0(card, BA0_ACCDA, val);
3986 cs461x_peekBA0(card, BA0_ACCTL);
3987 cs461x_pokeBA0(card, BA0_ACCTL, 0 | ACCTL_VFRM | ACCTL_ESYN | ACCTL_RSTN);
3988 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_DCV | ACCTL_VFRM |
3989 ACCTL_ESYN | ACCTL_RSTN);
3990 for (count = 0; count < 1000; count++) {
3992 * First, we want to wait for a short time.
3994 udelay(10 * cs_laptop_wait);
3996 * Now, check to see if the write has completed.
3997 * ACCTL = 460h, DCV should be reset by now and 460h = 07h
3999 if (!(cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV))
4003 * Make sure the write completed.
4005 if (cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV)
4007 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4008 "cs46xx: AC'97 write problem, reg = 0x%x, val = 0x%x\n", reg, val));
4011 spin_unlock(&card->ac97_lock);
4014 * Adjust power if the mixer is selected/deselected according
4017 * IF the CD is a valid input source (mixer or direct) AND
4018 * the CD is not muted THEN power is needed
4020 * We do two things. When record select changes the input to
4021 * add/remove the CD we adjust the power count if the CD is
4024 * When the CD mute changes we adjust the power level if the
4025 * CD was a valid input.
4027 * We also check for CD volume != 0, as the CD mute isn't
4028 * normally tweaked from userspace.
4031 /* CD mute change ? */
4033 if(reg==AC97_CD_VOL)
4035 /* Mute bit change ? */
4036 if((val2^val)&0x8000 || ((val2 == 0x1f1f || val == 0x1f1f) && val2 != val))
4038 /* This is a hack but its cleaner than the alternatives.
4039 Right now card->ac97_codec[0] might be NULL as we are
4040 still doing codec setup. This does an early assignment
4041 to avoid the problem if it occurs */
4043 if(card->ac97_codec[0]==NULL)
4044 card->ac97_codec[0]=dev;
4047 if(val&0x8000 || val == 0x1f1f)
4048 card->amplifier_ctrl(card, -1);
4049 else /* Mute off power on */
4052 card->amp_init(card);
4053 card->amplifier_ctrl(card, 1);
4060 /* OSS /dev/mixer file operation methods */
4062 static int cs_open_mixdev(struct inode *inode, struct file *file)
4065 unsigned int minor = iminor(inode);
4066 struct cs_card *card=NULL;
4067 struct list_head *entry;
4070 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4,
4071 printk(KERN_INFO "cs46xx: cs_open_mixdev()+\n"));
4073 list_for_each(entry, &cs46xx_devs)
4075 card = list_entry(entry, struct cs_card, list);
4076 for (i = 0; i < NR_AC97; i++)
4077 if (card->ac97_codec[i] != NULL &&
4078 card->ac97_codec[i]->dev_mixer == minor)
4083 CS_DBGOUT(CS_FUNCTION | CS_OPEN | CS_ERROR, 2,
4084 printk(KERN_INFO "cs46xx: cs46xx_open_mixdev()- -ENODEV\n"));
4088 if(!card->ac97_codec[i])
4090 file->private_data = card->ac97_codec[i];
4092 card->active_ctrl(card,1);
4093 if(!CS_IN_USE(&card->mixer_use_cnt))
4095 if( (tmp = cs46xx_powerup(card, CS_POWER_MIXVON )) )
4097 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
4098 "cs46xx: cs_open_mixdev() powerup failure (0x%x)\n",tmp) );
4102 card->amplifier_ctrl(card, 1);
4103 CS_INC_USE_COUNT(&card->mixer_use_cnt);
4104 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4,
4105 printk(KERN_INFO "cs46xx: cs_open_mixdev()- 0\n"));
4109 static int cs_release_mixdev(struct inode *inode, struct file *file)
4111 unsigned int minor = iminor(inode);
4112 struct cs_card *card=NULL;
4113 struct list_head *entry;
4117 CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 4,
4118 printk(KERN_INFO "cs46xx: cs_release_mixdev()+\n"));
4119 list_for_each(entry, &cs46xx_devs)
4121 card = list_entry(entry, struct cs_card, list);
4122 for (i = 0; i < NR_AC97; i++)
4123 if (card->ac97_codec[i] != NULL &&
4124 card->ac97_codec[i]->dev_mixer == minor)
4129 CS_DBGOUT(CS_FUNCTION | CS_OPEN | CS_ERROR, 2,
4130 printk(KERN_INFO "cs46xx: cs46xx_open_mixdev()- -ENODEV\n"));
4134 if(!CS_DEC_AND_TEST(&card->mixer_use_cnt))
4136 CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 4,
4137 printk(KERN_INFO "cs46xx: cs_release_mixdev()- no powerdown, usecnt>0\n"));
4138 card->active_ctrl(card, -1);
4139 card->amplifier_ctrl(card, -1);
4143 * ok, no outstanding mixer opens, so powerdown.
4145 if( (tmp = cs461x_powerdown(card, CS_POWER_MIXVON, CS_FALSE )) )
4147 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
4148 "cs46xx: cs_release_mixdev() powerdown MIXVON failure (0x%x)\n",tmp) );
4149 card->active_ctrl(card, -1);
4150 card->amplifier_ctrl(card, -1);
4153 card->active_ctrl(card, -1);
4154 card->amplifier_ctrl(card, -1);
4155 CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 4,
4156 printk(KERN_INFO "cs46xx: cs_release_mixdev()- 0\n"));
4160 void __exit cs46xx_cleanup_module(void);
4161 static int cs_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd,
4164 struct ac97_codec *codec = (struct ac97_codec *)file->private_data;
4165 struct cs_card *card=NULL;
4166 struct list_head *entry;
4168 #if CSDEBUG_INTERFACE
4171 if( (cmd == SOUND_MIXER_CS_GETDBGMASK) ||
4172 (cmd == SOUND_MIXER_CS_SETDBGMASK) ||
4173 (cmd == SOUND_MIXER_CS_GETDBGLEVEL) ||
4174 (cmd == SOUND_MIXER_CS_SETDBGLEVEL) ||
4175 (cmd == SOUND_MIXER_CS_APM))
4180 case SOUND_MIXER_CS_GETDBGMASK:
4181 return put_user(cs_debugmask, (unsigned long *)arg);
4183 case SOUND_MIXER_CS_GETDBGLEVEL:
4184 return put_user(cs_debuglevel, (unsigned long *)arg);
4186 case SOUND_MIXER_CS_SETDBGMASK:
4187 if (get_user(val, (unsigned long *)arg))
4192 case SOUND_MIXER_CS_SETDBGLEVEL:
4193 if (get_user(val, (unsigned long *)arg))
4195 cs_debuglevel = val;
4198 case SOUND_MIXER_CS_APM:
4199 if (get_user(val, (unsigned long *) arg))
4201 if(val == CS_IOCTL_CMD_SUSPEND)
4203 list_for_each(entry, &cs46xx_devs)
4205 card = list_entry(entry, struct cs_card, list);
4206 cs46xx_suspend(card, 0);
4210 else if(val == CS_IOCTL_CMD_RESUME)
4212 list_for_each(entry, &cs46xx_devs)
4214 card = list_entry(entry, struct cs_card, list);
4215 cs46xx_resume(card);
4220 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
4221 "cs46xx: mixer_ioctl(): invalid APM cmd (%d)\n",
4227 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
4228 "cs46xx: mixer_ioctl(): ERROR unknown debug cmd\n") );
4233 return codec->mixer_ioctl(codec, cmd, arg);
4236 static /*const*/ struct file_operations cs_mixer_fops = {
4237 CS_OWNER CS_THIS_MODULE
4238 .llseek = no_llseek,
4239 .ioctl = cs_ioctl_mixdev,
4240 .open = cs_open_mixdev,
4241 .release = cs_release_mixdev,
4244 /* AC97 codec initialisation. */
4245 static int __init cs_ac97_init(struct cs_card *card)
4249 struct ac97_codec *codec;
4252 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4253 "cs46xx: cs_ac97_init()+\n") );
4255 for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
4256 if ((codec = ac97_alloc_codec()) == NULL)
4259 /* initialize some basic codec information, other fields will be filled
4260 in ac97_probe_codec */
4261 codec->private_data = card;
4262 codec->id = num_ac97;
4264 codec->codec_read = cs_ac97_get;
4265 codec->codec_write = cs_ac97_set;
4267 if (ac97_probe_codec(codec) == 0)
4269 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4270 "cs46xx: cs_ac97_init()- codec number %d not found\n",
4272 card->ac97_codec[num_ac97] = 0;
4275 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4276 "cs46xx: cs_ac97_init() found codec %d\n",num_ac97) );
4278 eid = cs_ac97_get(codec, AC97_EXTENDED_ID);
4282 printk(KERN_WARNING "cs46xx: codec %d not present\n",num_ac97);
4283 ac97_release_codec(codec);
4287 card->ac97_features = eid;
4289 if ((codec->dev_mixer = register_sound_mixer(&cs_mixer_fops, -1)) < 0) {
4290 printk(KERN_ERR "cs46xx: couldn't register mixer!\n");
4291 ac97_release_codec(codec);
4294 card->ac97_codec[num_ac97] = codec;
4296 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4297 "cs46xx: cs_ac97_init() ac97_codec[%d] set to 0x%x\n",
4298 (unsigned int)num_ac97,
4299 (unsigned int)codec));
4300 /* if there is no secondary codec at all, don't probe any more */
4307 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4308 "cs46xx: cs_ac97_init()- %d\n", (unsigned int)num_ac97));
4313 * load the static image into the DSP
4315 #include "cs461x_image.h"
4316 static void cs461x_download_image(struct cs_card *card)
4318 unsigned i, j, temp1, temp2, offset, count;
4319 unsigned char *pBA1 = ioremap(card->ba1_addr, 0x40000);
4320 for( i=0; i < CLEAR__COUNT; i++)
4322 offset = ClrStat[i].BA1__DestByteOffset;
4323 count = ClrStat[i].BA1__SourceSize;
4324 for( temp1 = offset; temp1<(offset+count); temp1+=4 )
4325 writel(0, pBA1+temp1);
4328 for(i=0; i<FILL__COUNT; i++)
4330 temp2 = FillStat[i].Offset;
4331 for(j=0; j<(FillStat[i].Size)/4; j++)
4333 temp1 = (FillStat[i]).pFill[j];
4334 writel(temp1, pBA1+temp2+j*4);
4345 static void cs461x_reset(struct cs_card *card)
4350 * Write the reset bit of the SP control register.
4352 cs461x_poke(card, BA1_SPCR, SPCR_RSTSP);
4355 * Write the control register.
4357 cs461x_poke(card, BA1_SPCR, SPCR_DRQEN);
4360 * Clear the trap registers.
4362 for (idx = 0; idx < 8; idx++) {
4363 cs461x_poke(card, BA1_DREG, DREG_REGID_TRAP_SELECT + idx);
4364 cs461x_poke(card, BA1_TWPR, 0xFFFF);
4366 cs461x_poke(card, BA1_DREG, 0);
4369 * Set the frame timer to reflect the number of cycles per frame.
4371 cs461x_poke(card, BA1_FRMT, 0xadf);
4374 static void cs461x_clear_serial_FIFOs(struct cs_card *card, int type)
4376 int idx, loop, startfifo=0, endfifo=0, powerdown1 = 0;
4380 * See if the devices are powered down. If so, we must power them up first
4381 * or they will not respond.
4383 if (!((tmp = cs461x_peekBA0(card, BA0_CLKCR1)) & CLKCR1_SWCE)) {
4384 cs461x_pokeBA0(card, BA0_CLKCR1, tmp | CLKCR1_SWCE);
4389 * We want to clear out the serial port FIFOs so we don't end up playing
4390 * whatever random garbage happens to be in them. We fill the sample FIFOS
4391 * with zero (silence).
4393 cs461x_pokeBA0(card, BA0_SERBWP, 0);
4396 * Check for which FIFO locations to clear, if we are currently
4397 * playing or capturing then we don't want to put in 128 bytes of
4400 if(type & CS_TYPE_DAC)
4405 if(type & CS_TYPE_ADC)
4412 * Fill sample FIFO locations (256 locations total).
4414 for (idx = startfifo; idx < endfifo; idx++) {
4416 * Make sure the previous FIFO write operation has completed.
4418 for (loop = 0; loop < 5; loop++) {
4420 if (!(cs461x_peekBA0(card, BA0_SERBST) & SERBST_WBSY))
4423 if (cs461x_peekBA0(card, BA0_SERBST) & SERBST_WBSY) {
4425 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
4428 * Write the serial port FIFO index.
4430 cs461x_pokeBA0(card, BA0_SERBAD, idx);
4432 * Tell the serial port to load the new value into the FIFO location.
4434 cs461x_pokeBA0(card, BA0_SERBCM, SERBCM_WRC);
4437 * Now, if we powered up the devices, then power them back down again.
4438 * This is kinda ugly, but should never happen.
4441 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
4445 static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspendflag)
4448 unsigned int tmp=0,muted=0;
4450 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO
4451 "cs46xx: cs461x_powerdown()+ type=0x%x\n",type));
4452 if(!cs_powerdown && !suspendflag)
4454 CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4455 "cs46xx: cs461x_powerdown() DISABLED exiting\n"));
4458 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4459 CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4460 "cs46xx: cs461x_powerdown() powerdown reg=0x%x\n",tmp));
4462 * if powering down only the VREF, and not powering down the DAC/ADC,
4463 * then do not power down the VREF, UNLESS both the DAC and ADC are not
4464 * currently powered down. If powering down DAC and ADC, then
4465 * it is possible to power down the VREF (ON).
4467 if ( ((type & CS_POWER_MIXVON) &&
4468 (!(type & CS_POWER_ADC) || (!(type & CS_POWER_DAC))) )
4470 ((tmp & CS_AC97_POWER_CONTROL_ADC_ON) ||
4471 (tmp & CS_AC97_POWER_CONTROL_DAC_ON) ) )
4473 CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4474 "cs46xx: cs461x_powerdown()- 0 unable to powerdown. tmp=0x%x\n",tmp));
4478 * for now, always keep power to the mixer block.
4479 * not sure why it's a problem but it seems to be if we power off.
4481 type &= ~CS_POWER_MIXVON;
4482 type &= ~CS_POWER_MIXVOFF;
4485 * Power down indicated areas.
4487 if(type & CS_POWER_MIXVOFF)
4490 CS_DBGOUT(CS_FUNCTION, 4,
4491 printk(KERN_INFO "cs46xx: cs461x_powerdown()+ MIXVOFF\n"));
4493 * Power down the MIXER (VREF ON) on the AC97 card.
4495 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4496 if (tmp & CS_AC97_POWER_CONTROL_MIXVOFF_ON)
4500 cs_mute(card, CS_TRUE);
4503 tmp |= CS_AC97_POWER_CONTROL_MIXVOFF;
4504 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4506 * Now, we wait until we sample a ready state.
4508 for (count = 0; count < 32; count++) {
4510 * First, lets wait a short while to let things settle out a
4511 * bit, and to prevent retrying the read too quickly.
4516 * Read the current state of the power control register.
4518 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4519 CS_AC97_POWER_CONTROL_MIXVOFF_ON))
4524 * Check the status..
4526 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4527 CS_AC97_POWER_CONTROL_MIXVOFF_ON)
4529 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4530 "cs46xx: powerdown MIXVOFF failed\n"));
4535 if(type & CS_POWER_MIXVON)
4538 CS_DBGOUT(CS_FUNCTION, 4,
4539 printk(KERN_INFO "cs46xx: cs461x_powerdown()+ MIXVON\n"));
4541 * Power down the MIXER (VREF ON) on the AC97 card.
4543 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4544 if (tmp & CS_AC97_POWER_CONTROL_MIXVON_ON)
4548 cs_mute(card, CS_TRUE);
4551 tmp |= CS_AC97_POWER_CONTROL_MIXVON;
4552 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4554 * Now, we wait until we sample a ready state.
4556 for (count = 0; count < 32; count++) {
4558 * First, lets wait a short while to let things settle out a
4559 * bit, and to prevent retrying the read too quickly.
4564 * Read the current state of the power control register.
4566 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4567 CS_AC97_POWER_CONTROL_MIXVON_ON))
4572 * Check the status..
4574 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4575 CS_AC97_POWER_CONTROL_MIXVON_ON)
4577 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4578 "cs46xx: powerdown MIXVON failed\n"));
4583 if(type & CS_POWER_ADC)
4586 * Power down the ADC on the AC97 card.
4588 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO "cs46xx: cs461x_powerdown()+ ADC\n"));
4589 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4590 if (tmp & CS_AC97_POWER_CONTROL_ADC_ON)
4594 cs_mute(card, CS_TRUE);
4597 tmp |= CS_AC97_POWER_CONTROL_ADC;
4598 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4601 * Now, we wait until we sample a ready state.
4603 for (count = 0; count < 32; count++) {
4605 * First, lets wait a short while to let things settle out a
4606 * bit, and to prevent retrying the read too quickly.
4611 * Read the current state of the power control register.
4613 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4614 CS_AC97_POWER_CONTROL_ADC_ON))
4619 * Check the status..
4621 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4622 CS_AC97_POWER_CONTROL_ADC_ON)
4624 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4625 "cs46xx: powerdown ADC failed\n"));
4630 if(type & CS_POWER_DAC)
4633 * Power down the DAC on the AC97 card.
4636 CS_DBGOUT(CS_FUNCTION, 4,
4637 printk(KERN_INFO "cs46xx: cs461x_powerdown()+ DAC\n"));
4638 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4639 if (tmp & CS_AC97_POWER_CONTROL_DAC_ON)
4643 cs_mute(card, CS_TRUE);
4646 tmp |= CS_AC97_POWER_CONTROL_DAC;
4647 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4649 * Now, we wait until we sample a ready state.
4651 for (count = 0; count < 32; count++) {
4653 * First, lets wait a short while to let things settle out a
4654 * bit, and to prevent retrying the read too quickly.
4659 * Read the current state of the power control register.
4661 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4662 CS_AC97_POWER_CONTROL_DAC_ON))
4667 * Check the status..
4669 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4670 CS_AC97_POWER_CONTROL_DAC_ON)
4672 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4673 "cs46xx: powerdown DAC failed\n"));
4678 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4680 cs_mute(card, CS_FALSE);
4681 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO
4682 "cs46xx: cs461x_powerdown()- 0 tmp=0x%x\n",tmp));
4686 static int cs46xx_powerup(struct cs_card *card, unsigned int type)
4689 unsigned int tmp=0,muted=0;
4691 CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4692 "cs46xx: cs46xx_powerup()+ type=0x%x\n",type));
4694 * check for VREF and powerup if need to.
4696 if(type & CS_POWER_MIXVON)
4697 type |= CS_POWER_MIXVOFF;
4698 if(type & (CS_POWER_DAC | CS_POWER_ADC))
4699 type |= CS_POWER_MIXVON | CS_POWER_MIXVOFF;
4702 * Power up indicated areas.
4704 if(type & CS_POWER_MIXVOFF)
4707 CS_DBGOUT(CS_FUNCTION, 4,
4708 printk(KERN_INFO "cs46xx: cs46xx_powerup()+ MIXVOFF\n"));
4710 * Power up the MIXER (VREF ON) on the AC97 card.
4712 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4713 if (!(tmp & CS_AC97_POWER_CONTROL_MIXVOFF_ON))
4717 cs_mute(card, CS_TRUE);
4720 tmp &= ~CS_AC97_POWER_CONTROL_MIXVOFF;
4721 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4723 * Now, we wait until we sample a ready state.
4725 for (count = 0; count < 32; count++) {
4727 * First, lets wait a short while to let things settle out a
4728 * bit, and to prevent retrying the read too quickly.
4733 * Read the current state of the power control register.
4735 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4736 CS_AC97_POWER_CONTROL_MIXVOFF_ON)
4741 * Check the status..
4743 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4744 CS_AC97_POWER_CONTROL_MIXVOFF_ON))
4746 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4747 "cs46xx: powerup MIXVOFF failed\n"));
4752 if(type & CS_POWER_MIXVON)
4755 CS_DBGOUT(CS_FUNCTION, 4,
4756 printk(KERN_INFO "cs46xx: cs46xx_powerup()+ MIXVON\n"));
4758 * Power up the MIXER (VREF ON) on the AC97 card.
4760 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4761 if (!(tmp & CS_AC97_POWER_CONTROL_MIXVON_ON))
4765 cs_mute(card, CS_TRUE);
4768 tmp &= ~CS_AC97_POWER_CONTROL_MIXVON;
4769 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4771 * Now, we wait until we sample a ready state.
4773 for (count = 0; count < 32; count++) {
4775 * First, lets wait a short while to let things settle out a
4776 * bit, and to prevent retrying the read too quickly.
4781 * Read the current state of the power control register.
4783 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4784 CS_AC97_POWER_CONTROL_MIXVON_ON)
4789 * Check the status..
4791 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4792 CS_AC97_POWER_CONTROL_MIXVON_ON))
4794 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4795 "cs46xx: powerup MIXVON failed\n"));
4800 if(type & CS_POWER_ADC)
4803 * Power up the ADC on the AC97 card.
4805 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO "cs46xx: cs46xx_powerup()+ ADC\n"));
4806 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4807 if (!(tmp & CS_AC97_POWER_CONTROL_ADC_ON))
4811 cs_mute(card, CS_TRUE);
4814 tmp &= ~CS_AC97_POWER_CONTROL_ADC;
4815 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4818 * Now, we wait until we sample a ready state.
4820 for (count = 0; count < 32; count++) {
4822 * First, lets wait a short while to let things settle out a
4823 * bit, and to prevent retrying the read too quickly.
4828 * Read the current state of the power control register.
4830 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4831 CS_AC97_POWER_CONTROL_ADC_ON)
4836 * Check the status..
4838 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4839 CS_AC97_POWER_CONTROL_ADC_ON))
4841 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4842 "cs46xx: powerup ADC failed\n"));
4847 if(type & CS_POWER_DAC)
4850 * Power up the DAC on the AC97 card.
4853 CS_DBGOUT(CS_FUNCTION, 4,
4854 printk(KERN_INFO "cs46xx: cs46xx_powerup()+ DAC\n"));
4855 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4856 if (!(tmp & CS_AC97_POWER_CONTROL_DAC_ON))
4860 cs_mute(card, CS_TRUE);
4863 tmp &= ~CS_AC97_POWER_CONTROL_DAC;
4864 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4866 * Now, we wait until we sample a ready state.
4868 for (count = 0; count < 32; count++) {
4870 * First, lets wait a short while to let things settle out a
4871 * bit, and to prevent retrying the read too quickly.
4876 * Read the current state of the power control register.
4878 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4879 CS_AC97_POWER_CONTROL_DAC_ON)
4884 * Check the status..
4886 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4887 CS_AC97_POWER_CONTROL_DAC_ON))
4889 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4890 "cs46xx: powerup DAC failed\n"));
4895 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4897 cs_mute(card, CS_FALSE);
4898 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO
4899 "cs46xx: cs46xx_powerup()- 0 tmp=0x%x\n",tmp));
4904 static void cs461x_proc_start(struct cs_card *card)
4909 * Set the frame timer to reflect the number of cycles per frame.
4911 cs461x_poke(card, BA1_FRMT, 0xadf);
4913 * Turn on the run, run at frame, and DMA enable bits in the local copy of
4914 * the SP control register.
4916 cs461x_poke(card, BA1_SPCR, SPCR_RUN | SPCR_RUNFR | SPCR_DRQEN);
4918 * Wait until the run at frame bit resets itself in the SP control
4921 for (cnt = 0; cnt < 25; cnt++) {
4923 if (!(cs461x_peek(card, BA1_SPCR) & SPCR_RUNFR))
4927 if (cs461x_peek(card, BA1_SPCR) & SPCR_RUNFR)
4928 printk(KERN_WARNING "cs46xx: SPCR_RUNFR never reset\n");
4931 static void cs461x_proc_stop(struct cs_card *card)
4934 * Turn off the run, run at frame, and DMA enable bits in the local copy of
4935 * the SP control register.
4937 cs461x_poke(card, BA1_SPCR, 0);
4940 static int cs_hardware_init(struct cs_card *card)
4942 unsigned long end_time;
4943 unsigned int tmp,count;
4945 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4946 "cs46xx: cs_hardware_init()+\n") );
4948 * First, blast the clock control register to zero so that the PLL starts
4949 * out in a known state, and blast the master serial port control register
4950 * to zero so that the serial ports also start out in a known state.
4952 cs461x_pokeBA0(card, BA0_CLKCR1, 0);
4953 cs461x_pokeBA0(card, BA0_SERMC1, 0);
4956 * If we are in AC97 mode, then we must set the part to a host controlled
4957 * AC-link. Otherwise, we won't be able to bring up the link.
4959 cs461x_pokeBA0(card, BA0_SERACC, SERACC_HSP | SERACC_CODEC_TYPE_1_03); /* 1.03 card */
4960 /* cs461x_pokeBA0(card, BA0_SERACC, SERACC_HSP | SERACC_CODEC_TYPE_2_0); */ /* 2.00 card */
4963 * Drive the ARST# pin low for a minimum of 1uS (as defined in the AC97
4964 * spec) and then drive it high. This is done for non AC97 modes since
4965 * there might be logic external to the CS461x that uses the ARST# line
4968 cs461x_pokeBA0(card, BA0_ACCTL, 1);
4970 cs461x_pokeBA0(card, BA0_ACCTL, 0);
4972 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_RSTN);
4975 * The first thing we do here is to enable sync generation. As soon
4976 * as we start receiving bit clock, we'll start producing the SYNC
4979 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_ESYN | ACCTL_RSTN);
4982 * Now wait for a short while to allow the AC97 part to start
4983 * generating bit clock (so we don't try to start the PLL without an
4986 mdelay(5 * cs_laptop_wait); /* 1 should be enough ?? (and pigs might fly) */
4989 * Set the serial port timing configuration, so that
4990 * the clock control circuit gets its clock from the correct place.
4992 cs461x_pokeBA0(card, BA0_SERMC1, SERMC1_PTC_AC97);
4995 * The part seems to not be ready for a while after a resume.
4996 * so, if we are resuming, then wait for 700 mils. Note that 600 mils
4997 * is not enough for some platforms! tested on an IBM Thinkpads and
5000 if(!(card->pm.flags & CS46XX_PM_IDLE))
5003 * Write the selected clock control setup to the hardware. Do not turn on
5004 * SWCE yet (if requested), so that the devices clocked by the output of
5005 * PLL are not clocked until the PLL is stable.
5007 cs461x_pokeBA0(card, BA0_PLLCC, PLLCC_LPF_1050_2780_KHZ | PLLCC_CDR_73_104_MHZ);
5008 cs461x_pokeBA0(card, BA0_PLLM, 0x3a);
5009 cs461x_pokeBA0(card, BA0_CLKCR2, CLKCR2_PDIVS_8);
5014 cs461x_pokeBA0(card, BA0_CLKCR1, CLKCR1_PLLP);
5017 * Wait until the PLL has stabilized.
5019 mdelay(5 * cs_laptop_wait); /* Again 1 should be enough ?? */
5022 * Turn on clocking of the core so that we can setup the serial ports.
5024 tmp = cs461x_peekBA0(card, BA0_CLKCR1) | CLKCR1_SWCE;
5025 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
5028 * Fill the serial port FIFOs with silence.
5030 cs461x_clear_serial_FIFOs(card,CS_TYPE_DAC | CS_TYPE_ADC);
5033 * Set the serial port FIFO pointer to the first sample in the FIFO.
5035 /* cs461x_pokeBA0(card, BA0_SERBSP, 0); */
5038 * Write the serial port configuration to the part. The master
5039 * enable bit is not set until all other values have been written.
5041 cs461x_pokeBA0(card, BA0_SERC1, SERC1_SO1F_AC97 | SERC1_SO1EN);
5042 cs461x_pokeBA0(card, BA0_SERC2, SERC2_SI1F_AC97 | SERC1_SO1EN);
5043 cs461x_pokeBA0(card, BA0_SERMC1, SERMC1_PTC_AC97 | SERMC1_MSPE);
5046 mdelay(5 * cs_laptop_wait); /* Shouldnt be needed ?? */
5049 * If we are resuming under 2.2.x then we can not schedule a timeout.
5050 * so, just spin the CPU.
5052 if(card->pm.flags & CS46XX_PM_IDLE)
5055 * Wait for the card ready signal from the AC97 card.
5057 end_time = jiffies + 3 * (HZ >> 2);
5060 * Read the AC97 status register to see if we've seen a CODEC READY
5061 * signal from the AC97 card.
5063 if (cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_CRDY)
5065 current->state = TASK_UNINTERRUPTIBLE;
5066 schedule_timeout(1);
5067 } while (time_before(jiffies, end_time));
5071 for (count = 0; count < 100; count++) {
5072 // First, we want to wait for a short time.
5073 udelay(25 * cs_laptop_wait);
5075 if (cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_CRDY)
5081 * Make sure CODEC is READY.
5083 if (!(cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_CRDY)) {
5084 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_WARNING
5085 "cs46xx: create - never read card ready from AC'97\n"));
5086 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_WARNING
5087 "cs46xx: probably not a bug, try using the CS4232 driver,\n"));
5088 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_WARNING
5089 "cs46xx: or turn off any automatic Power Management support in the BIOS.\n"));
5094 * Assert the vaid frame signal so that we can start sending commands
5097 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_VFRM | ACCTL_ESYN | ACCTL_RSTN);
5099 if(card->pm.flags & CS46XX_PM_IDLE)
5102 * Wait until we've sampled input slots 3 and 4 as valid, meaning that
5103 * the card is pumping ADC data across the AC-link.
5105 end_time = jiffies + 3 * (HZ >> 2);
5108 * Read the input slot valid register and see if input slots 3 and
5111 if ((cs461x_peekBA0(card, BA0_ACISV) & (ACISV_ISV3 | ACISV_ISV4)) == (ACISV_ISV3 | ACISV_ISV4))
5113 current->state = TASK_UNINTERRUPTIBLE;
5114 schedule_timeout(1);
5115 } while (time_before(jiffies, end_time));
5119 for (count = 0; count < 100; count++) {
5120 // First, we want to wait for a short time.
5121 udelay(25 * cs_laptop_wait);
5123 if ((cs461x_peekBA0(card, BA0_ACISV) & (ACISV_ISV3 | ACISV_ISV4)) == (ACISV_ISV3 | ACISV_ISV4))
5128 * Make sure input slots 3 and 4 are valid. If not, then return
5131 if ((cs461x_peekBA0(card, BA0_ACISV) & (ACISV_ISV3 | ACISV_ISV4)) != (ACISV_ISV3 | ACISV_ISV4)) {
5132 printk(KERN_WARNING "cs46xx: create - never read ISV3 & ISV4 from AC'97\n");
5137 * Now, assert valid frame and the slot 3 and 4 valid bits. This will
5138 * commense the transfer of digital audio data to the AC97 card.
5140 cs461x_pokeBA0(card, BA0_ACOSV, ACOSV_SLV3 | ACOSV_SLV4);
5143 * Turn off the Processor by turning off the software clock enable flag in
5144 * the clock control register.
5146 /* tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE; */
5147 /* cs461x_pokeBA0(card, BA0_CLKCR1, tmp); */
5150 * Reset the processor.
5155 * Download the image to the processor.
5158 cs461x_download_image(card);
5161 * Stop playback DMA.
5163 tmp = cs461x_peek(card, BA1_PCTL);
5164 card->pctl = tmp & 0xffff0000;
5165 cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
5170 tmp = cs461x_peek(card, BA1_CCTL);
5171 card->cctl = tmp & 0x0000ffff;
5172 cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
5174 /* initialize AC97 codec and register /dev/mixer */
5175 if(card->pm.flags & CS46XX_PM_IDLE)
5177 if (cs_ac97_init(card) <= 0)
5179 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
5180 "cs46xx: cs_ac97_init() failure\n") );
5186 cs46xx_ac97_resume(card);
5189 cs461x_proc_start(card);
5192 * Enable interrupts on the part.
5194 cs461x_pokeBA0(card, BA0_HICR, HICR_IEV | HICR_CHGM);
5196 tmp = cs461x_peek(card, BA1_PFIE);
5198 cs461x_poke(card, BA1_PFIE, tmp); /* playback interrupt enable */
5200 tmp = cs461x_peek(card, BA1_CIE);
5203 cs461x_poke(card, BA1_CIE, tmp); /* capture interrupt enable */
5206 * If IDLE then Power down the part. We will power components up
5207 * when we need them.
5209 if(card->pm.flags & CS46XX_PM_IDLE)
5213 if( (tmp = cs46xx_powerup(card, CS_POWER_DAC | CS_POWER_ADC |
5214 CS_POWER_MIXVON )) )
5216 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
5217 "cs46xx: cs461x_powerup() failure (0x%x)\n",tmp) );
5223 if( (tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
5224 CS_POWER_MIXVON, CS_FALSE )) )
5226 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
5227 "cs46xx: cs461x_powerdown() failure (0x%x)\n",tmp) );
5232 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
5233 "cs46xx: cs_hardware_init()- 0\n"));
5237 /* install the driver, we do not allocate hardware channel nor DMA buffer now, they are defered
5238 until "ACCESS" time (in prog_dmabuf called by open/read/write/ioctl/mmap) */
5249 void (*amp)(struct cs_card *, int);
5250 void (*amp_init)(struct cs_card *);
5251 void (*active)(struct cs_card *, int);
5254 static struct cs_card_type cards[] = {
5258 .name = "Genius Soundmaker 128 value",
5270 .name = "Mitac MI6020/21",
5276 .name = "Hercules Game Theatre XP",
5277 .amp = amp_hercules,
5282 .name = "Hercules Game Theatre XP",
5283 .amp = amp_hercules,
5288 .name = "Hercules Game Theatre XP",
5289 .amp = amp_hercules,
5294 .name = "Hercules Game Theatre XP",
5295 .amp = amp_hercules,
5300 .name = "Hercules Game Theatre XP",
5301 .amp = amp_hercules,
5306 .name = "Hercules Game Theatre XP",
5307 .amp = amp_hercules,
5312 .name = "Hercules Fortissimo II",
5315 /* Not sure if the 570 needs the clkrun hack */
5317 .vendor = PCI_VENDOR_ID_IBM,
5319 .name = "Thinkpad 570",
5321 .active = clkrun_hack,
5324 .vendor = PCI_VENDOR_ID_IBM,
5326 .name = "Thinkpad 600X/A20/T20",
5328 .active = clkrun_hack,
5331 .vendor = PCI_VENDOR_ID_IBM,
5333 .name = "Thinkpad 600E (unsupported)",
5336 .name = "Card without SSID set",
5341 MODULE_AUTHOR("Alan Cox <alan@redhat.com>, Jaroslav Kysela, <pcaudio@crystal.cirrus.com>");
5342 MODULE_DESCRIPTION("Crystal SoundFusion Audio Support");
5343 MODULE_LICENSE("GPL");
5346 static const char cs46xx_banner[] = KERN_INFO "Crystal 4280/46xx + AC97 Audio, version " CS46XX_MAJOR_VERSION "." CS46XX_MINOR_VERSION "." CS46XX_ARCH ", " __TIME__ " " __DATE__ "\n";
5347 static const char fndmsg[] = KERN_INFO "cs46xx: Found %d audio device(s).\n";
5349 static int __devinit cs46xx_probe(struct pci_dev *pci_dev,
5350 const struct pci_device_id *pciid)
5352 struct pm_dev *pmdev;
5354 u16 ss_card, ss_vendor;
5355 struct cs_card *card;
5356 dma_addr_t dma_mask;
5357 struct cs_card_type *cp = &cards[0];
5359 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2,
5360 printk(KERN_INFO "cs46xx: probe()+\n"));
5362 dma_mask = 0xffffffff; /* this enables playback and recording */
5363 if (pci_enable_device(pci_dev)) {
5364 CS_DBGOUT(CS_INIT | CS_ERROR, 1, printk(KERN_ERR
5365 "cs46xx: pci_enable_device() failed\n"));
5368 if (!RSRCISMEMORYREGION(pci_dev, 0) ||
5369 !RSRCISMEMORYREGION(pci_dev, 1)) {
5370 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
5371 "cs46xx: probe()- Memory region not assigned\n"));
5374 if (pci_dev->irq == 0) {
5375 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
5376 "cs46xx: probe() IRQ not assigned\n"));
5379 if (!pci_dma_supported(pci_dev, 0xffffffff)) {
5380 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
5381 "cs46xx: probe() architecture does not support 32bit PCI busmaster DMA\n"));
5384 pci_read_config_word(pci_dev, PCI_SUBSYSTEM_VENDOR_ID, &ss_vendor);
5385 pci_read_config_word(pci_dev, PCI_SUBSYSTEM_ID, &ss_card);
5387 if ((card = kmalloc(sizeof(struct cs_card), GFP_KERNEL)) == NULL) {
5388 printk(KERN_ERR "cs46xx: out of memory\n");
5391 memset(card, 0, sizeof(*card));
5392 card->ba0_addr = RSRCADDRESS(pci_dev, 0);
5393 card->ba1_addr = RSRCADDRESS(pci_dev, 1);
5394 card->pci_dev = pci_dev;
5395 card->irq = pci_dev->irq;
5396 card->magic = CS_CARD_MAGIC;
5397 spin_lock_init(&card->lock);
5398 spin_lock_init(&card->ac97_lock);
5400 pci_set_master(pci_dev);
5402 printk(cs46xx_banner);
5403 printk(KERN_INFO "cs46xx: Card found at 0x%08lx and 0x%08lx, IRQ %d\n",
5404 card->ba0_addr, card->ba1_addr, card->irq);
5406 card->alloc_pcm_channel = cs_alloc_pcm_channel;
5407 card->alloc_rec_pcm_channel = cs_alloc_rec_pcm_channel;
5408 card->free_pcm_channel = cs_free_pcm_channel;
5409 card->amplifier_ctrl = amp_none;
5410 card->active_ctrl = amp_none;
5414 if(cp->vendor == ss_vendor && cp->id == ss_card)
5416 card->amplifier_ctrl = cp->amp;
5418 card->active_ctrl = cp->active;
5420 card->amp_init = cp->amp_init;
5427 printk(KERN_INFO "cs46xx: Unknown card (%04X:%04X) at 0x%08lx/0x%08lx, IRQ %d\n",
5428 ss_vendor, ss_card, card->ba0_addr, card->ba1_addr, card->irq);
5432 printk(KERN_INFO "cs46xx: %s (%04X:%04X) at 0x%08lx/0x%08lx, IRQ %d\n",
5433 cp->name, ss_vendor, ss_card, card->ba0_addr, card->ba1_addr, card->irq);
5436 if (card->amplifier_ctrl==NULL)
5438 card->amplifier_ctrl = amp_none;
5439 card->active_ctrl = clkrun_hack;
5442 if (external_amp == 1)
5444 printk(KERN_INFO "cs46xx: Crystal EAPD support forced on.\n");
5445 card->amplifier_ctrl = amp_voyetra;
5450 printk(KERN_INFO "cs46xx: Activating CLKRUN hack for Thinkpad.\n");
5451 card->active_ctrl = clkrun_hack;
5454 * The thinkpads don't work well without runtime updating on their kernel
5455 * delay values (or any laptop with variable CPU speeds really).
5456 * so, just to be safe set the init delay to 2100. Eliminates
5457 * failures on T21 Thinkpads. remove this code when the udelay
5458 * and mdelay kernel code is replaced by a pm timer, or the delays
5459 * work well for battery and/or AC power both.
5461 if(card->active_ctrl == clkrun_hack)
5466 if((card->active_ctrl == clkrun_hack) && !(powerdown == 1))
5469 * for some currently unknown reason, powering down the DAC and ADC component
5470 * blocks on thinkpads causes some funky behavior... distoorrrtion and ac97
5471 * codec access problems. probably the serial clock becomes unsynced.
5472 * added code to sync the chips back up, but only helped about 70% the time.
5478 card->active_ctrl(card, 1);
5480 /* claim our iospace and irq */
5482 card->ba0 = ioremap_nocache(card->ba0_addr, CS461X_BA0_SIZE);
5483 card->ba1.name.data0 = ioremap_nocache(card->ba1_addr + BA1_SP_DMEM0, CS461X_BA1_DATA0_SIZE);
5484 card->ba1.name.data1 = ioremap_nocache(card->ba1_addr + BA1_SP_DMEM1, CS461X_BA1_DATA1_SIZE);
5485 card->ba1.name.pmem = ioremap_nocache(card->ba1_addr + BA1_SP_PMEM, CS461X_BA1_PRG_SIZE);
5486 card->ba1.name.reg = ioremap_nocache(card->ba1_addr + BA1_SP_REG, CS461X_BA1_REG_SIZE);
5488 CS_DBGOUT(CS_INIT, 4, printk(KERN_INFO
5489 "cs46xx: card=0x%x card->ba0=0x%.08x\n",(unsigned)card,(unsigned)card->ba0) );
5490 CS_DBGOUT(CS_INIT, 4, printk(KERN_INFO
5491 "cs46xx: card->ba1=0x%.08x 0x%.08x 0x%.08x 0x%.08x\n",
5492 (unsigned)card->ba1.name.data0,
5493 (unsigned)card->ba1.name.data1,
5494 (unsigned)card->ba1.name.pmem,
5495 (unsigned)card->ba1.name.reg) );
5497 if(card->ba0 == 0 || card->ba1.name.data0 == 0 ||
5498 card->ba1.name.data1 == 0 || card->ba1.name.pmem == 0 ||
5499 card->ba1.name.reg == 0)
5502 if (request_irq(card->irq, &cs_interrupt, SA_SHIRQ, "cs46xx", card)) {
5503 printk(KERN_ERR "cs46xx: unable to allocate irq %d\n", card->irq);
5506 /* register /dev/dsp */
5507 if ((card->dev_audio = register_sound_dsp(&cs461x_fops, -1)) < 0) {
5508 printk(KERN_ERR "cs46xx: unable to register dsp\n");
5512 /* register /dev/midi */
5513 if((card->dev_midi = register_sound_midi(&cs_midi_fops, -1)) < 0)
5514 printk(KERN_ERR "cs46xx: unable to register midi\n");
5516 card->pm.flags |= CS46XX_PM_IDLE;
5519 if (cs_hardware_init(card) != 0)
5521 CS_DBGOUT(CS_ERROR, 4, printk(
5522 "cs46xx: ERROR in cs_hardware_init()... retrying\n"));
5523 for (j = 0; j < NR_AC97; j++)
5524 if (card->ac97_codec[j] != NULL) {
5525 unregister_sound_mixer(card->ac97_codec[j]->dev_mixer);
5526 ac97_release_codec(card->ac97_codec[j]);
5528 mdelay(10 * cs_laptop_wait);
5535 CS_DBGOUT(CS_PM | CS_ERROR, 1, printk(
5536 "cs46xx: cs46xx_probe()- cs_hardware_init() failed, retried %d times.\n",i));
5537 unregister_sound_dsp(card->dev_audio);
5539 unregister_sound_midi(card->dev_midi);
5543 init_waitqueue_head(&card->midi.open_wait);
5544 init_MUTEX(&card->midi.open_sem);
5545 init_waitqueue_head(&card->midi.iwait);
5546 init_waitqueue_head(&card->midi.owait);
5547 cs461x_pokeBA0(card, BA0_MIDCR, MIDCR_MRST);
5548 cs461x_pokeBA0(card, BA0_MIDCR, 0);
5551 * Check if we have to init the amplifier, but probably already done
5552 * since the CD logic in the ac97 init code will turn on the ext amp.
5556 card->active_ctrl(card, -1);
5558 PCI_SET_DRIVER_DATA(pci_dev, card);
5559 PCI_SET_DMA_MASK(pci_dev, dma_mask);
5560 list_add(&card->list, &cs46xx_devs);
5562 pmdev = cs_pm_register(PM_PCI_DEV, PM_PCI_ID(pci_dev), cs46xx_pm_callback);
5565 CS_DBGOUT(CS_INIT | CS_PM, 4, printk(KERN_INFO
5566 "cs46xx: probe() pm_register() succeeded (0x%x).\n",
5572 CS_DBGOUT(CS_INIT | CS_PM | CS_ERROR, 2, printk(KERN_INFO
5573 "cs46xx: probe() pm_register() failed (0x%x).\n",
5575 card->pm.flags |= CS46XX_PM_NOT_REGISTERED;
5578 CS_DBGOUT(CS_PM, 9, printk(KERN_INFO "cs46xx: pm.flags=0x%x card=0x%x\n",
5579 (unsigned)card->pm.flags,(unsigned)card));
5581 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5582 "cs46xx: probe()- device allocated successfully\n"));
5586 free_irq(card->irq, card);
5590 if(card->ba1.name.data0)
5591 iounmap(card->ba1.name.data0);
5592 if(card->ba1.name.data1)
5593 iounmap(card->ba1.name.data1);
5594 if(card->ba1.name.pmem)
5595 iounmap(card->ba1.name.pmem);
5596 if(card->ba1.name.reg)
5597 iounmap(card->ba1.name.reg);
5599 CS_DBGOUT(CS_INIT | CS_ERROR, 1, printk(KERN_INFO
5600 "cs46xx: probe()- no device allocated\n"));
5604 // ---------------------------------------------------------------------
5606 static void __devexit cs46xx_remove(struct pci_dev *pci_dev)
5608 struct cs_card *card = PCI_GET_DRIVER_DATA(pci_dev);
5612 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5613 "cs46xx: cs46xx_remove()+\n"));
5615 card->active_ctrl(card,1);
5617 tmp = cs461x_peek(card, BA1_PFIE);
5620 cs461x_poke(card, BA1_PFIE, tmp); /* playback interrupt disable */
5622 tmp = cs461x_peek(card, BA1_CIE);
5625 cs461x_poke(card, BA1_CIE, tmp); /* capture interrupt disable */
5628 * Stop playback DMA.
5630 tmp = cs461x_peek(card, BA1_PCTL);
5631 cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
5636 tmp = cs461x_peek(card, BA1_CCTL);
5637 cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
5640 * Reset the processor.
5644 cs461x_proc_stop(card);
5647 * Power down the DAC and ADC. We will power them up (if) when we need
5650 if( (tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
5651 CS_POWER_MIXVON, CS_TRUE )) )
5653 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
5654 "cs46xx: cs461x_powerdown() failure (0x%x)\n",tmp) );
5658 * Power down the PLL.
5660 cs461x_pokeBA0(card, BA0_CLKCR1, 0);
5663 * Turn off the Processor by turning off the software clock enable flag in
5664 * the clock control register.
5666 tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE;
5667 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
5669 card->active_ctrl(card,-1);
5671 /* free hardware resources */
5672 free_irq(card->irq, card);
5674 iounmap(card->ba1.name.data0);
5675 iounmap(card->ba1.name.data1);
5676 iounmap(card->ba1.name.pmem);
5677 iounmap(card->ba1.name.reg);
5679 /* unregister audio devices */
5680 for (i = 0; i < NR_AC97; i++)
5681 if (card->ac97_codec[i] != NULL) {
5682 unregister_sound_mixer(card->ac97_codec[i]->dev_mixer);
5683 ac97_release_codec(card->ac97_codec[i]);
5685 unregister_sound_dsp(card->dev_audio);
5687 unregister_sound_midi(card->dev_midi);
5688 list_del(&card->list);
5690 PCI_SET_DRIVER_DATA(pci_dev,NULL);
5692 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5693 "cs46xx: cs46xx_remove()-: remove successful\n"));
5698 CS46XX_4612, /* same as 4630 */
5699 CS46XX_4615, /* same as 4624 */
5702 static struct pci_device_id cs46xx_pci_tbl[] = {
5704 .vendor = PCI_VENDOR_ID_CIRRUS,
5705 .device = PCI_DEVICE_ID_CIRRUS_4610,
5706 .subvendor = PCI_ANY_ID,
5707 .subdevice = PCI_ANY_ID,
5708 .driver_data = CS46XX_4610,
5711 .vendor = PCI_VENDOR_ID_CIRRUS,
5712 .device = PCI_DEVICE_ID_CIRRUS_4612,
5713 .subvendor = PCI_ANY_ID,
5714 .subdevice = PCI_ANY_ID,
5715 .driver_data = CS46XX_4612,
5718 .vendor = PCI_VENDOR_ID_CIRRUS,
5719 .device = PCI_DEVICE_ID_CIRRUS_4615,
5720 .subvendor = PCI_ANY_ID,
5721 .subdevice = PCI_ANY_ID,
5722 .driver_data = CS46XX_4615,
5727 MODULE_DEVICE_TABLE(pci, cs46xx_pci_tbl);
5729 struct pci_driver cs46xx_pci_driver = {
5731 .id_table = cs46xx_pci_tbl,
5732 .probe = cs46xx_probe,
5733 .remove = __devexit_p(cs46xx_remove),
5734 .suspend = CS46XX_SUSPEND_TBL,
5735 .resume = CS46XX_RESUME_TBL,
5738 int __init cs46xx_init_module(void)
5741 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5742 "cs46xx: cs46xx_init_module()+ \n"));
5743 rtn = pci_module_init(&cs46xx_pci_driver);
5747 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(
5748 "cs46xx: Unable to detect valid cs46xx device\n"));
5751 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2,
5752 printk(KERN_INFO "cs46xx: cs46xx_init_module()- (%d)\n",rtn));
5756 void __exit cs46xx_cleanup_module(void)
5758 pci_unregister_driver(&cs46xx_pci_driver);
5759 cs_pm_unregister_all(cs46xx_pm_callback);
5760 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2,
5761 printk(KERN_INFO "cs46xx: cleanup_cs46xx() finished\n"));
5764 module_init(cs46xx_init_module);
5765 module_exit(cs46xx_cleanup_module);
5767 int cs46xx_pm_callback(struct pm_dev *dev, pm_request_t rqst, void *data)
5769 struct cs_card *card;
5771 CS_DBGOUT(CS_PM, 2, printk(KERN_INFO
5772 "cs46xx: cs46xx_pm_callback dev=0x%x rqst=0x%x card=%d\n",
5773 (unsigned)dev,(unsigned)rqst,(unsigned)data));
5774 card = (struct cs_card *) dev->data;
5778 CS_DBGOUT(CS_PM, 2, printk(KERN_INFO
5779 "cs46xx: PM suspend request\n"));
5780 if(cs46xx_suspend(card, 0))
5782 CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
5783 "cs46xx: PM suspend request refused\n"));
5788 CS_DBGOUT(CS_PM, 2, printk(KERN_INFO
5789 "cs46xx: PM resume request\n"));
5790 if(cs46xx_resume(card))
5792 CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
5793 "cs46xx: PM resume request refused\n"));
5803 #if CS46XX_ACPI_SUPPORT
5804 static int cs46xx_suspend_tbl(struct pci_dev *pcidev, u32 state)
5806 struct cs_card *s = PCI_GET_DRIVER_DATA(pcidev);
5807 CS_DBGOUT(CS_PM | CS_FUNCTION, 2,
5808 printk(KERN_INFO "cs46xx: cs46xx_suspend_tbl request\n"));
5809 cs46xx_suspend(s, 0);
5813 static int cs46xx_resume_tbl(struct pci_dev *pcidev)
5815 struct cs_card *s = PCI_GET_DRIVER_DATA(pcidev);
5816 CS_DBGOUT(CS_PM | CS_FUNCTION, 2,
5817 printk(KERN_INFO "cs46xx: cs46xx_resume_tbl request\n"));