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>
93 #include <linux/mutex.h>
98 #include <asm/uaccess.h>
100 #include "cs46xxpm.h"
101 #include "cs46xx_wrapper-24.h"
104 /* MIDI buffer sizes */
105 #define CS_MIDIINBUF 500
106 #define CS_MIDIOUTBUF 500
108 #define ADC_RUNNING 1
109 #define DAC_RUNNING 2
111 #define CS_FMT_16BIT 1 /* These are fixed in fact */
112 #define CS_FMT_STEREO 2
113 #define CS_FMT_MASK 3
115 #define CS_TYPE_ADC 1
116 #define CS_TYPE_DAC 2
121 #define CS_INC_USE_COUNT(m) (atomic_inc(m))
122 #define CS_DEC_USE_COUNT(m) (atomic_dec(m))
123 #define CS_DEC_AND_TEST(m) (atomic_dec_and_test(m))
124 #define CS_IN_USE(m) (atomic_read(m) != 0)
126 #define CS_DBGBREAKPOINT {__asm__("INT $3");}
131 #define CS461X_BA0_SIZE 0x2000
132 #define CS461X_BA1_DATA0_SIZE 0x3000
133 #define CS461X_BA1_DATA1_SIZE 0x3800
134 #define CS461X_BA1_PRG_SIZE 0x7000
135 #define CS461X_BA1_REG_SIZE 0x0100
137 #define GOF_PER_SEC 200
139 #define CSDEBUG_INTERFACE 1
142 * Turn on/off debugging compilation by using 1/0 respectively for CSDEBUG
145 * CSDEBUG is usual mode is set to 1, then use the
146 * cs_debuglevel and cs_debugmask to turn on or off debugging.
147 * Debug level of 1 has been defined to be kernel errors and info
148 * that should be printed on any released driver.
151 #define CS_DBGOUT(mask,level,x) if ((cs_debuglevel >= (level)) && ((mask) & cs_debugmask)) {x;}
153 #define CS_DBGOUT(mask,level,x)
158 #define CS_INIT 0x00000001 /* initialization and probe functions */
159 #define CS_ERROR 0x00000002 /* tmp debugging bit placeholder */
160 #define CS_INTERRUPT 0x00000004 /* interrupt handler (separate from all other) */
161 #define CS_FUNCTION 0x00000008 /* enter/leave functions */
162 #define CS_WAVE_WRITE 0x00000010 /* write information for wave */
163 #define CS_WAVE_READ 0x00000020 /* read information for wave */
164 #define CS_MIDI_WRITE 0x00000040 /* write information for midi */
165 #define CS_MIDI_READ 0x00000080 /* read information for midi */
166 #define CS_MPU401_WRITE 0x00000100 /* write information for mpu401 */
167 #define CS_MPU401_READ 0x00000200 /* read information for mpu401 */
168 #define CS_OPEN 0x00000400 /* all open functions in the driver */
169 #define CS_RELEASE 0x00000800 /* all release functions in the driver */
170 #define CS_PARMS 0x00001000 /* functional and operational parameters */
171 #define CS_IOCTL 0x00002000 /* ioctl (non-mixer) */
172 #define CS_PM 0x00004000 /* PM */
173 #define CS_TMP 0x10000000 /* tmp debug mask bit */
175 #define CS_IOCTL_CMD_SUSPEND 0x1 // suspend
176 #define CS_IOCTL_CMD_RESUME 0x2 // resume
179 static unsigned long cs_debuglevel = 1; /* levels range from 1-9 */
180 module_param(cs_debuglevel, ulong, 0644);
181 static unsigned long cs_debugmask = CS_INIT | CS_ERROR; /* use CS_DBGOUT with various mask values */
182 module_param(cs_debugmask, ulong, 0644);
184 static unsigned long hercules_egpio_disable; /* if non-zero set all EGPIO to 0 */
185 module_param(hercules_egpio_disable, ulong, 0);
186 static unsigned long initdelay = 700; /* PM delay in millisecs */
187 module_param(initdelay, ulong, 0);
188 static unsigned long powerdown = -1; /* turn on/off powerdown processing in driver */
189 module_param(powerdown, ulong, 0);
190 #define DMABUF_DEFAULTORDER 3
191 static unsigned long defaultorder = DMABUF_DEFAULTORDER;
192 module_param(defaultorder, ulong, 0);
194 static int external_amp;
195 module_param(external_amp, bool, 0);
197 module_param(thinkpad, bool, 0);
200 * set the powerdown module parm to 0 to disable all
201 * powerdown. also set thinkpad to 1 to disable powerdown,
202 * but also to enable the clkrun functionality.
204 static unsigned cs_powerdown = 1;
205 static unsigned cs_laptop_wait = 1;
207 /* An instance of the 4610 channel */
215 #define CS46XX_MAJOR_VERSION "1"
216 #define CS46XX_MINOR_VERSION "28"
219 #define CS46XX_ARCH "64" //architecture key
221 #define CS46XX_ARCH "32" //architecture key
224 static struct list_head cs46xx_devs = { &cs46xx_devs, &cs46xx_devs };
226 /* magic numbers to protect our data structures */
227 #define CS_CARD_MAGIC 0x43525553 /* "CRUS" */
228 #define CS_STATE_MAGIC 0x4c4f4749 /* "LOGI" */
231 /* maxinum number of AC97 codecs connected, AC97 2.0 defined 4 */
234 static const unsigned sample_size[] = { 1, 2, 2, 4 };
235 static const unsigned sample_shift[] = { 0, 1, 1, 2 };
237 /* "software" or virtual channel, an instance of opened /dev/dsp */
240 struct cs_card *card; /* Card info */
242 /* single open lock mechanism, only used for recording */
243 struct mutex open_mutex;
244 wait_queue_head_t open_wait;
249 /* virtual channel number */
253 /* wave sample stuff */
255 unsigned char fmt, enable;
257 /* hardware channel */
258 struct cs_channel *channel;
259 int pringbuf; /* Software ring slot */
260 void *pbuf; /* 4K hardware DMA buffer */
262 /* OSS buffer management stuff */
264 dma_addr_t dma_handle;
270 void *tmpbuff; /* tmp buffer for sample conversions */
272 dma_addr_t dmaaddr_tmpbuff;
273 unsigned buforder_tmpbuff; /* Log base 2 of size in bytes.. */
275 /* our buffer acts like a circular ring */
276 unsigned hwptr; /* where dma last started, updated by update_ptr */
277 unsigned swptr; /* where driver last clear/filled, updated by read/write */
278 int count; /* bytes to be comsumed or been generated by dma machine */
279 unsigned total_bytes; /* total bytes dmaed by hardware */
280 unsigned blocks; /* total blocks */
282 unsigned error; /* number of over/underruns */
283 unsigned underrun; /* underrun pending before next write has occurred */
284 wait_queue_head_t wait; /* put process on wait queue when no more space in buffer */
286 /* redundant, but makes calculations easier */
289 unsigned fragsamples;
294 unsigned endcleared:1;
296 unsigned update_flag;
297 unsigned ossfragshift;
299 unsigned subdivision;
301 /* Guard against mmap/write/read races */
306 struct cs_channel channel[2];
309 /* We keep cs461x cards in a linked list */
310 struct cs_card *next;
312 /* The cs461x has a certain amount of cross channel interaction
313 so we use a single per card lock */
317 spinlock_t ac97_lock;
319 /* mixer use count */
320 atomic_t mixer_use_cnt;
322 /* PCI device stuff */
323 struct pci_dev *pci_dev;
324 struct list_head list;
326 unsigned int pctl, cctl; /* Hardware DMA flag sets */
328 /* soundcore stuff */
332 /* structures for abstraction of hardware facilities, codecs, banks and channels*/
333 struct ac97_codec *ac97_codec[NR_AC97];
334 struct cs_state *states[2];
338 int amplifier; /* Amplifier control */
339 void (*amplifier_ctrl)(struct cs_card *, int);
340 void (*amp_init)(struct cs_card *);
342 int active; /* Active clocking */
343 void (*active_ctrl)(struct cs_card *, int);
345 /* hardware resources */
346 unsigned long ba0_addr;
347 unsigned long ba1_addr;
364 /* Function support */
365 struct cs_channel *(*alloc_pcm_channel)(struct cs_card *);
366 struct cs_channel *(*alloc_rec_pcm_channel)(struct cs_card *);
367 void (*free_pcm_channel)(struct cs_card *, int chan);
369 /* /dev/midi stuff */
371 unsigned ird, iwr, icnt;
372 unsigned ord, owr, ocnt;
373 wait_queue_head_t open_wait;
374 wait_queue_head_t iwait;
375 wait_queue_head_t owait;
377 unsigned char ibuf[CS_MIDIINBUF];
378 unsigned char obuf[CS_MIDIOUTBUF];
380 struct mutex open_mutex;
385 static int cs_open_mixdev(struct inode *inode, struct file *file);
386 static int cs_release_mixdev(struct inode *inode, struct file *file);
387 static int cs_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd,
389 static int cs_hardware_init(struct cs_card *card);
390 static int cs46xx_powerup(struct cs_card *card, unsigned int type);
391 static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspendflag);
392 static void cs461x_clear_serial_FIFOs(struct cs_card *card, int type);
394 static int cs46xx_suspend_tbl(struct pci_dev *pcidev, pm_message_t state);
395 static int cs46xx_resume_tbl(struct pci_dev *pcidev);
402 #define SOUND_MIXER_CS_GETDBGLEVEL _SIOWR('M',120, int)
403 #define SOUND_MIXER_CS_SETDBGLEVEL _SIOWR('M',121, int)
404 #define SOUND_MIXER_CS_GETDBGMASK _SIOWR('M',122, int)
405 #define SOUND_MIXER_CS_SETDBGMASK _SIOWR('M',123, int)
406 #define SOUND_MIXER_CS_APM _SIOWR('M',124, int)
408 static void printioctl(unsigned int x)
412 /* these values are incorrect for the ac97 driver, fix.
413 * Index of mixtable1[] member is Device ID
414 * and must be <= SOUND_MIXER_NRDEVICES.
415 * Value of array member is index into s->mix.vol[]
417 static const unsigned char mixtable1[SOUND_MIXER_NRDEVICES] = {
418 [SOUND_MIXER_PCM] = 1, /* voice */
419 [SOUND_MIXER_LINE1] = 2, /* AUX */
420 [SOUND_MIXER_CD] = 3, /* CD */
421 [SOUND_MIXER_LINE] = 4, /* Line */
422 [SOUND_MIXER_SYNTH] = 5, /* FM */
423 [SOUND_MIXER_MIC] = 6, /* Mic */
424 [SOUND_MIXER_SPEAKER] = 7, /* Speaker */
425 [SOUND_MIXER_RECLEV] = 8, /* Recording level */
426 [SOUND_MIXER_VOLUME] = 9 /* Master Volume */
430 case SOUND_MIXER_CS_GETDBGMASK:
431 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_GETDBGMASK: ") );
433 case SOUND_MIXER_CS_GETDBGLEVEL:
434 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_GETDBGLEVEL: ") );
436 case SOUND_MIXER_CS_SETDBGMASK:
437 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_SETDBGMASK: ") );
439 case SOUND_MIXER_CS_SETDBGLEVEL:
440 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_SETDBGLEVEL: ") );
443 CS_DBGOUT(CS_IOCTL, 4, printk("OSS_GETVERSION: ") );
445 case SNDCTL_DSP_SYNC:
446 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SYNC: ") );
448 case SNDCTL_DSP_SETDUPLEX:
449 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETDUPLEX: ") );
451 case SNDCTL_DSP_GETCAPS:
452 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETCAPS: ") );
454 case SNDCTL_DSP_RESET:
455 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_RESET: ") );
457 case SNDCTL_DSP_SPEED:
458 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SPEED: ") );
460 case SNDCTL_DSP_STEREO:
461 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_STEREO: ") );
463 case SNDCTL_DSP_CHANNELS:
464 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_CHANNELS: ") );
466 case SNDCTL_DSP_GETFMTS:
467 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETFMTS: ") );
469 case SNDCTL_DSP_SETFMT:
470 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETFMT: ") );
472 case SNDCTL_DSP_POST:
473 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_POST: ") );
475 case SNDCTL_DSP_GETTRIGGER:
476 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETTRIGGER: ") );
478 case SNDCTL_DSP_SETTRIGGER:
479 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETTRIGGER: ") );
481 case SNDCTL_DSP_GETOSPACE:
482 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETOSPACE: ") );
484 case SNDCTL_DSP_GETISPACE:
485 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETISPACE: ") );
487 case SNDCTL_DSP_NONBLOCK:
488 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_NONBLOCK: ") );
490 case SNDCTL_DSP_GETODELAY:
491 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETODELAY: ") );
493 case SNDCTL_DSP_GETIPTR:
494 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETIPTR: ") );
496 case SNDCTL_DSP_GETOPTR:
497 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETOPTR: ") );
499 case SNDCTL_DSP_GETBLKSIZE:
500 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETBLKSIZE: ") );
502 case SNDCTL_DSP_SETFRAGMENT:
503 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETFRAGMENT: ") );
505 case SNDCTL_DSP_SUBDIVIDE:
506 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SUBDIVIDE: ") );
508 case SOUND_PCM_READ_RATE:
509 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_RATE: ") );
511 case SOUND_PCM_READ_CHANNELS:
512 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_CHANNELS: ") );
514 case SOUND_PCM_READ_BITS:
515 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_BITS: ") );
517 case SOUND_PCM_WRITE_FILTER:
518 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_WRITE_FILTER: ") );
520 case SNDCTL_DSP_SETSYNCRO:
521 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETSYNCRO: ") );
523 case SOUND_PCM_READ_FILTER:
524 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_FILTER: ") );
526 case SOUND_MIXER_PRIVATE1:
527 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE1: ") );
529 case SOUND_MIXER_PRIVATE2:
530 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE2: ") );
532 case SOUND_MIXER_PRIVATE3:
533 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE3: ") );
535 case SOUND_MIXER_PRIVATE4:
536 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE4: ") );
538 case SOUND_MIXER_PRIVATE5:
539 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE5: ") );
541 case SOUND_MIXER_INFO:
542 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_INFO: ") );
544 case SOUND_OLD_MIXER_INFO:
545 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_OLD_MIXER_INFO: ") );
548 switch (_IOC_NR(x)) {
549 case SOUND_MIXER_VOLUME:
550 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_VOLUME: ") );
552 case SOUND_MIXER_SPEAKER:
553 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_SPEAKER: ") );
555 case SOUND_MIXER_RECLEV:
556 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECLEV: ") );
558 case SOUND_MIXER_MIC:
559 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_MIC: ") );
561 case SOUND_MIXER_SYNTH:
562 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_SYNTH: ") );
564 case SOUND_MIXER_RECSRC:
565 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECSRC: ") );
567 case SOUND_MIXER_DEVMASK:
568 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_DEVMASK: ") );
570 case SOUND_MIXER_RECMASK:
571 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECMASK: ") );
573 case SOUND_MIXER_STEREODEVS:
574 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_STEREODEVS: ") );
576 case SOUND_MIXER_CAPS:
577 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CAPS:") );
581 if (i >= SOUND_MIXER_NRDEVICES || !(vidx = mixtable1[i])) {
582 CS_DBGOUT(CS_IOCTL, 4, printk("UNKNOWN IOCTL: 0x%.8x NR=%d ",x,i) );
584 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_IOCTL AC9x: 0x%.8x NR=%d ",
590 CS_DBGOUT(CS_IOCTL, 4, printk("command = 0x%x IOC_NR=%d\n",x, _IOC_NR(x)) );
595 * common I/O routines
598 static void cs461x_poke(struct cs_card *codec, unsigned long reg, unsigned int val)
600 writel(val, codec->ba1.idx[(reg >> 16) & 3] + (reg & 0xffff));
603 static unsigned int cs461x_peek(struct cs_card *codec, unsigned long reg)
605 return readl(codec->ba1.idx[(reg >> 16) & 3] + (reg & 0xffff));
608 static void cs461x_pokeBA0(struct cs_card *codec, unsigned long reg, unsigned int val)
610 writel(val, codec->ba0 + reg);
613 static unsigned int cs461x_peekBA0(struct cs_card *codec, unsigned long reg)
615 return readl(codec->ba0 + reg);
619 static u16 cs_ac97_get(struct ac97_codec *dev, u8 reg);
620 static void cs_ac97_set(struct ac97_codec *dev, u8 reg, u16 data);
622 static struct cs_channel *cs_alloc_pcm_channel(struct cs_card *card)
624 if (card->channel[1].used == 1)
626 card->channel[1].used = 1;
627 card->channel[1].num = 1;
628 return &card->channel[1];
631 static struct cs_channel *cs_alloc_rec_pcm_channel(struct cs_card *card)
633 if (card->channel[0].used == 1)
635 card->channel[0].used = 1;
636 card->channel[0].num = 0;
637 return &card->channel[0];
640 static void cs_free_pcm_channel(struct cs_card *card, int channel)
642 card->channel[channel].state = NULL;
643 card->channel[channel].used = 0;
647 * setup a divisor value to help with conversion from
648 * 16bit Stereo, down to 8bit stereo/mono or 16bit mono.
649 * assign a divisor of 1 if using 16bit Stereo as that is
650 * the only format that the static image will capture.
652 static void cs_set_divisor(struct dmabuf *dmabuf)
654 if (dmabuf->type == CS_TYPE_DAC)
656 else if (!(dmabuf->fmt & CS_FMT_STEREO) &&
657 (dmabuf->fmt & CS_FMT_16BIT))
659 else if ((dmabuf->fmt & CS_FMT_STEREO) &&
660 !(dmabuf->fmt & CS_FMT_16BIT))
662 else if (!(dmabuf->fmt & CS_FMT_STEREO) &&
663 !(dmabuf->fmt & CS_FMT_16BIT))
668 CS_DBGOUT(CS_PARMS | CS_FUNCTION, 8, printk(
669 "cs46xx: cs_set_divisor()- %s %d\n",
670 (dmabuf->type == CS_TYPE_ADC) ? "ADC" : "DAC",
675 * mute some of the more prevalent registers to avoid popping.
677 static void cs_mute(struct cs_card *card, int state)
679 struct ac97_codec *dev = card->ac97_codec[0];
681 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs46xx: cs_mute()+ %s\n",
682 (state == CS_TRUE) ? "Muting" : "UnMuting"));
684 if (state == CS_TRUE) {
686 * fix pops when powering up on thinkpads
688 card->pm.u32AC97_master_volume = (u32)cs_ac97_get( dev,
689 (u8)BA0_AC97_MASTER_VOLUME);
690 card->pm.u32AC97_headphone_volume = (u32)cs_ac97_get(dev,
691 (u8)BA0_AC97_HEADPHONE_VOLUME);
692 card->pm.u32AC97_master_volume_mono = (u32)cs_ac97_get(dev,
693 (u8)BA0_AC97_MASTER_VOLUME_MONO);
694 card->pm.u32AC97_pcm_out_volume = (u32)cs_ac97_get(dev,
695 (u8)BA0_AC97_PCM_OUT_VOLUME);
697 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME, 0x8000);
698 cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, 0x8000);
699 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, 0x8000);
700 cs_ac97_set(dev, (u8)BA0_AC97_PCM_OUT_VOLUME, 0x8000);
702 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME, card->pm.u32AC97_master_volume);
703 cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, card->pm.u32AC97_headphone_volume);
704 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, card->pm.u32AC97_master_volume_mono);
705 cs_ac97_set(dev, (u8)BA0_AC97_PCM_OUT_VOLUME, card->pm.u32AC97_pcm_out_volume);
707 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs46xx: cs_mute()-\n"));
710 /* set playback sample rate */
711 static unsigned int cs_set_dac_rate(struct cs_state * state, unsigned int rate)
713 struct dmabuf *dmabuf = &state->dmabuf;
714 unsigned int tmp1, tmp2;
715 unsigned int phiIncr;
716 unsigned int correctionPerGOF, correctionPerSec;
719 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_dac_rate()+ %d\n",rate) );
722 * Compute the values used to drive the actual sample rate conversion.
723 * The following formulas are being computed, using inline assembly
724 * since we need to use 64 bit arithmetic to compute the values:
726 * phiIncr = floor((Fs,in * 2^26) / Fs,out)
727 * correctionPerGOF = floor((Fs,in * 2^26 - Fs,out * phiIncr) /
729 * ulCorrectionPerSec = Fs,in * 2^26 - Fs,out * phiIncr -M
730 * GOF_PER_SEC * correctionPerGOF
734 * phiIncr:other = dividend:remainder((Fs,in * 2^26) / Fs,out)
735 * correctionPerGOF:correctionPerSec =
736 * dividend:remainder(ulOther / GOF_PER_SEC)
739 phiIncr = tmp1 / 48000;
740 tmp1 -= phiIncr * 48000;
745 tmp1 -= tmp2 * 48000;
746 correctionPerGOF = tmp1 / GOF_PER_SEC;
747 tmp1 -= correctionPerGOF * GOF_PER_SEC;
748 correctionPerSec = tmp1;
751 * Fill in the SampleRateConverter control block.
753 spin_lock_irqsave(&state->card->lock, flags);
754 cs461x_poke(state->card, BA1_PSRC,
755 ((correctionPerSec << 16) & 0xFFFF0000) | (correctionPerGOF & 0xFFFF));
756 cs461x_poke(state->card, BA1_PPI, phiIncr);
757 spin_unlock_irqrestore(&state->card->lock, flags);
760 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_dac_rate()- %d\n",rate) );
764 /* set recording sample rate */
765 static unsigned int cs_set_adc_rate(struct cs_state *state, unsigned int rate)
767 struct dmabuf *dmabuf = &state->dmabuf;
768 struct cs_card *card = state->card;
769 unsigned int phiIncr, coeffIncr, tmp1, tmp2;
770 unsigned int correctionPerGOF, correctionPerSec, initialDelay;
771 unsigned int frameGroupLength, cnt;
773 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_adc_rate()+ %d\n",rate) );
776 * We can only decimate by up to a factor of 1/9th the hardware rate.
777 * Correct the value if an attempt is made to stray outside that limit.
779 if ((rate * 9) < 48000)
783 * We cannot capture at at rate greater than the Input Rate (48000).
784 * Return an error if an attempt is made to stray outside that limit.
790 * Compute the values used to drive the actual sample rate conversion.
791 * The following formulas are being computed, using inline assembly
792 * since we need to use 64 bit arithmetic to compute the values:
794 * coeffIncr = -floor((Fs,out * 2^23) / Fs,in)
795 * phiIncr = floor((Fs,in * 2^26) / Fs,out)
796 * correctionPerGOF = floor((Fs,in * 2^26 - Fs,out * phiIncr) /
798 * correctionPerSec = Fs,in * 2^26 - Fs,out * phiIncr -
799 * GOF_PER_SEC * correctionPerGOF
800 * initialDelay = ceil((24 * Fs,in) / Fs,out)
804 * coeffIncr = neg(dividend((Fs,out * 2^23) / Fs,in))
805 * phiIncr:ulOther = dividend:remainder((Fs,in * 2^26) / Fs,out)
806 * correctionPerGOF:correctionPerSec =
807 * dividend:remainder(ulOther / GOF_PER_SEC)
808 * initialDelay = dividend(((24 * Fs,in) + Fs,out - 1) / Fs,out)
811 coeffIncr = tmp1 / 48000;
812 tmp1 -= coeffIncr * 48000;
815 coeffIncr += tmp1 / 48000;
816 coeffIncr ^= 0xFFFFFFFF;
819 phiIncr = tmp1 / rate;
820 tmp1 -= phiIncr * rate;
826 correctionPerGOF = tmp1 / GOF_PER_SEC;
827 tmp1 -= correctionPerGOF * GOF_PER_SEC;
828 correctionPerSec = tmp1;
829 initialDelay = ((48000 * 24) + rate - 1) / rate;
832 * Fill in the VariDecimate control block.
834 spin_lock_irqsave(&card->lock, flags);
835 cs461x_poke(card, BA1_CSRC,
836 ((correctionPerSec << 16) & 0xFFFF0000) | (correctionPerGOF & 0xFFFF));
837 cs461x_poke(card, BA1_CCI, coeffIncr);
838 cs461x_poke(card, BA1_CD,
839 (((BA1_VARIDEC_BUF_1 + (initialDelay << 2)) << 16) & 0xFFFF0000) | 0x80);
840 cs461x_poke(card, BA1_CPI, phiIncr);
841 spin_unlock_irqrestore(&card->lock, flags);
844 * Figure out the frame group length for the write back task. Basically,
845 * this is just the factors of 24000 (2^6*3*5^3) that are not present in
846 * the output sample rate.
848 frameGroupLength = 1;
849 for (cnt = 2; cnt <= 64; cnt *= 2) {
850 if (((rate / cnt) * cnt) != rate)
851 frameGroupLength *= 2;
853 if (((rate / 3) * 3) != rate) {
854 frameGroupLength *= 3;
856 for (cnt = 5; cnt <= 125; cnt *= 5) {
857 if (((rate / cnt) * cnt) != rate)
858 frameGroupLength *= 5;
862 * Fill in the WriteBack control block.
864 spin_lock_irqsave(&card->lock, flags);
865 cs461x_poke(card, BA1_CFG1, frameGroupLength);
866 cs461x_poke(card, BA1_CFG2, (0x00800000 | frameGroupLength));
867 cs461x_poke(card, BA1_CCST, 0x0000FFFF);
868 cs461x_poke(card, BA1_CSPB, ((65536 * rate) / 24000));
869 cs461x_poke(card, (BA1_CSPB + 4), 0x0000FFFF);
870 spin_unlock_irqrestore(&card->lock, flags);
872 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_adc_rate()- %d\n",rate) );
876 /* prepare channel attributes for playback */
877 static void cs_play_setup(struct cs_state *state)
879 struct dmabuf *dmabuf = &state->dmabuf;
880 struct cs_card *card = state->card;
881 unsigned int tmp, Count, playFormat;
883 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_play_setup()+\n") );
884 cs461x_poke(card, BA1_PVOL, 0x80008000);
886 cs461x_poke(card, BA1_PBA, virt_to_bus(dmabuf->pbuf));
889 playFormat=cs461x_peek(card, BA1_PFIE);
890 if ((dmabuf->fmt & CS_FMT_STEREO)) {
891 playFormat &= ~DMA_RQ_C2_AC_MONO_TO_STEREO;
894 playFormat |= DMA_RQ_C2_AC_MONO_TO_STEREO;
896 if ((dmabuf->fmt & CS_FMT_16BIT)) {
897 playFormat &= ~(DMA_RQ_C2_AC_8_TO_16_BIT
898 | DMA_RQ_C2_AC_SIGNED_CONVERT);
901 playFormat |= (DMA_RQ_C2_AC_8_TO_16_BIT
902 | DMA_RQ_C2_AC_SIGNED_CONVERT);
904 cs461x_poke(card, BA1_PFIE, playFormat);
906 tmp = cs461x_peek(card, BA1_PDTC);
908 cs461x_poke(card, BA1_PDTC, tmp | --Count);
910 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_play_setup()-\n") );
913 static struct InitStruct
917 } InitArray[] = { {0x00000040, 0x3fc0000f},
918 {0x0000004c, 0x04800000},
920 {0x000000b3, 0x00000780},
921 {0x000000b7, 0x00000000},
922 {0x000000bc, 0x07800000},
924 {0x000000cd, 0x00800000},
928 * "SetCaptureSPValues()" -- Initialize record task values before each
931 static void SetCaptureSPValues(struct cs_card *card)
934 CS_DBGOUT(CS_FUNCTION, 8, printk("cs46xx: SetCaptureSPValues()+\n") );
935 for (i = 0; i < sizeof(InitArray) / sizeof(struct InitStruct); i++) {
936 offset = InitArray[i].off*4; /* 8bit to 32bit offset value */
937 cs461x_poke(card, offset, InitArray[i].val );
939 CS_DBGOUT(CS_FUNCTION, 8, printk("cs46xx: SetCaptureSPValues()-\n") );
942 /* prepare channel attributes for recording */
943 static void cs_rec_setup(struct cs_state *state)
945 struct cs_card *card = state->card;
946 struct dmabuf *dmabuf = &state->dmabuf;
948 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_rec_setup()+\n"));
949 SetCaptureSPValues(card);
952 * set the attenuation to 0dB
954 cs461x_poke(card, BA1_CVOL, 0x80008000);
957 * set the physical address of the capture buffer into the SP
959 cs461x_poke(card, BA1_CBA, virt_to_bus(dmabuf->rawbuf));
961 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_rec_setup()-\n") );
965 /* get current playback/recording dma buffer pointer (byte offset from LBA),
966 called with spinlock held! */
968 static inline unsigned cs_get_dma_addr(struct cs_state *state)
970 struct dmabuf *dmabuf = &state->dmabuf;
973 if ( (!(dmabuf->enable & DAC_RUNNING)) &&
974 (!(dmabuf->enable & ADC_RUNNING) ) )
976 CS_DBGOUT(CS_ERROR, 2, printk(
977 "cs46xx: ERROR cs_get_dma_addr(): not enabled \n") );
982 * granularity is byte boundary, good part.
984 if (dmabuf->enable & DAC_RUNNING)
985 offset = cs461x_peek(state->card, BA1_PBA);
986 else /* ADC_RUNNING must be set */
987 offset = cs461x_peek(state->card, BA1_CBA);
989 CS_DBGOUT(CS_PARMS | CS_FUNCTION, 9,
990 printk("cs46xx: cs_get_dma_addr() %d\n",offset) );
991 offset = (u32)bus_to_virt((unsigned long)offset) - (u32)dmabuf->rawbuf;
992 CS_DBGOUT(CS_PARMS | CS_FUNCTION, 8,
993 printk("cs46xx: cs_get_dma_addr()- %d\n",offset) );
997 static void resync_dma_ptrs(struct cs_state *state)
999 struct dmabuf *dmabuf;
1001 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: resync_dma_ptrs()+ \n") );
1003 dmabuf = &state->dmabuf;
1004 dmabuf->hwptr=dmabuf->swptr = 0;
1005 dmabuf->pringbuf = 0;
1007 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: resync_dma_ptrs()- \n") );
1010 /* Stop recording (lock held) */
1011 static inline void __stop_adc(struct cs_state *state)
1013 struct dmabuf *dmabuf = &state->dmabuf;
1014 struct cs_card *card = state->card;
1017 dmabuf->enable &= ~ADC_RUNNING;
1019 tmp = cs461x_peek(card, BA1_CCTL);
1021 cs461x_poke(card, BA1_CCTL, tmp );
1024 static void stop_adc(struct cs_state *state)
1026 unsigned long flags;
1028 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_adc()+ \n") );
1029 spin_lock_irqsave(&state->card->lock, flags);
1031 spin_unlock_irqrestore(&state->card->lock, flags);
1032 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_adc()- \n") );
1035 static void start_adc(struct cs_state *state)
1037 struct dmabuf *dmabuf = &state->dmabuf;
1038 struct cs_card *card = state->card;
1039 unsigned long flags;
1042 spin_lock_irqsave(&card->lock, flags);
1043 if (!(dmabuf->enable & ADC_RUNNING) &&
1044 ((dmabuf->mapped || dmabuf->count < (signed)dmabuf->dmasize)
1045 && dmabuf->ready) &&
1046 ((card->pm.flags & CS46XX_PM_IDLE) ||
1047 (card->pm.flags & CS46XX_PM_RESUMED)) )
1049 dmabuf->enable |= ADC_RUNNING;
1050 cs_set_divisor(dmabuf);
1051 tmp = cs461x_peek(card, BA1_CCTL);
1054 CS_DBGOUT(CS_FUNCTION, 2, printk(
1055 "cs46xx: start_adc() poke 0x%x \n",tmp) );
1056 cs461x_poke(card, BA1_CCTL, tmp);
1058 spin_unlock_irqrestore(&card->lock, flags);
1061 /* stop playback (lock held) */
1062 static inline void __stop_dac(struct cs_state *state)
1064 struct dmabuf *dmabuf = &state->dmabuf;
1065 struct cs_card *card = state->card;
1068 dmabuf->enable &= ~DAC_RUNNING;
1070 tmp=cs461x_peek(card, BA1_PCTL);
1072 cs461x_poke(card, BA1_PCTL, tmp);
1075 static void stop_dac(struct cs_state *state)
1077 unsigned long flags;
1079 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_dac()+ \n") );
1080 spin_lock_irqsave(&state->card->lock, flags);
1082 spin_unlock_irqrestore(&state->card->lock, flags);
1083 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_dac()- \n") );
1086 static void start_dac(struct cs_state *state)
1088 struct dmabuf *dmabuf = &state->dmabuf;
1089 struct cs_card *card = state->card;
1090 unsigned long flags;
1093 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: start_dac()+ \n") );
1094 spin_lock_irqsave(&card->lock, flags);
1095 if (!(dmabuf->enable & DAC_RUNNING) &&
1096 ((dmabuf->mapped || dmabuf->count > 0) && dmabuf->ready) &&
1097 ((card->pm.flags & CS46XX_PM_IDLE) ||
1098 (card->pm.flags & CS46XX_PM_RESUMED)) )
1100 dmabuf->enable |= DAC_RUNNING;
1101 tmp = cs461x_peek(card, BA1_PCTL);
1104 CS_DBGOUT(CS_PARMS, 6, printk(
1105 "cs46xx: start_dac() poke card=%p tmp=0x%.08x addr=%p \n",
1106 card, (unsigned)tmp,
1107 card->ba1.idx[(BA1_PCTL >> 16) & 3]+(BA1_PCTL&0xffff) ) );
1108 cs461x_poke(card, BA1_PCTL, tmp);
1110 spin_unlock_irqrestore(&card->lock, flags);
1111 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: start_dac()- \n") );
1114 #define DMABUF_MINORDER 1
1117 * allocate DMA buffer, playback and recording buffers are separate.
1119 static int alloc_dmabuf(struct cs_state *state)
1122 struct cs_card *card=state->card;
1123 struct dmabuf *dmabuf = &state->dmabuf;
1124 void *rawbuf = NULL;
1125 void *tmpbuff = NULL;
1127 struct page *map, *mapend;
1130 dmabuf->ready = dmabuf->mapped = 0;
1133 * check for order within limits, but do not overwrite value.
1135 if ((defaultorder > 1) && (defaultorder < 12))
1140 for (order = df; order >= DMABUF_MINORDER; order--)
1141 if ((rawbuf = (void *)pci_alloc_consistent(
1142 card->pci_dev, PAGE_SIZE << order, &dmabuf->dmaaddr)))
1145 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
1146 "cs46xx: alloc_dmabuf(): unable to allocate rawbuf\n"));
1149 dmabuf->buforder = order;
1150 dmabuf->rawbuf = rawbuf;
1151 // Now mark the pages as reserved; otherwise the
1152 // remap_pfn_range() in cs46xx_mmap doesn't work.
1153 // 1. get index to last page in mem_map array for rawbuf.
1154 mapend = virt_to_page(dmabuf->rawbuf +
1155 (PAGE_SIZE << dmabuf->buforder) - 1);
1157 // 2. mark each physical page in range as 'reserved'.
1158 for (map = virt_to_page(dmabuf->rawbuf); map <= mapend; map++)
1159 cs4x_mem_map_reserve(map);
1161 CS_DBGOUT(CS_PARMS, 9, printk("cs46xx: alloc_dmabuf(): allocated %ld (order = %d) bytes at %p\n",
1162 PAGE_SIZE << order, order, rawbuf) );
1165 * only allocate the conversion buffer for the ADC
1167 if (dmabuf->type == CS_TYPE_DAC) {
1168 dmabuf->tmpbuff = NULL;
1169 dmabuf->buforder_tmpbuff = 0;
1173 * now the temp buffer for 16/8 conversions
1176 tmpbuff = (void *) pci_alloc_consistent(
1177 card->pci_dev, PAGE_SIZE << order, &dmabuf->dmaaddr_tmpbuff);
1181 CS_DBGOUT(CS_PARMS, 9, printk("cs46xx: allocated %ld (order = %d) bytes at %p\n",
1182 PAGE_SIZE << order, order, tmpbuff) );
1184 dmabuf->tmpbuff = tmpbuff;
1185 dmabuf->buforder_tmpbuff = order;
1187 // Now mark the pages as reserved; otherwise the
1188 // remap_pfn_range() in cs46xx_mmap doesn't work.
1189 // 1. get index to last page in mem_map array for rawbuf.
1190 mapend = virt_to_page(dmabuf->tmpbuff +
1191 (PAGE_SIZE << dmabuf->buforder_tmpbuff) - 1);
1193 // 2. mark each physical page in range as 'reserved'.
1194 for (map = virt_to_page(dmabuf->tmpbuff); map <= mapend; map++)
1195 cs4x_mem_map_reserve(map);
1199 /* free DMA buffer */
1200 static void dealloc_dmabuf(struct cs_state *state)
1202 struct dmabuf *dmabuf = &state->dmabuf;
1203 struct page *map, *mapend;
1205 if (dmabuf->rawbuf) {
1206 // Undo prog_dmabuf()'s marking the pages as reserved
1207 mapend = virt_to_page(dmabuf->rawbuf +
1208 (PAGE_SIZE << dmabuf->buforder) - 1);
1209 for (map = virt_to_page(dmabuf->rawbuf); map <= mapend; map++)
1210 cs4x_mem_map_unreserve(map);
1211 free_dmabuf(state->card, dmabuf);
1214 if (dmabuf->tmpbuff) {
1215 // Undo prog_dmabuf()'s marking the pages as reserved
1216 mapend = virt_to_page(dmabuf->tmpbuff +
1217 (PAGE_SIZE << dmabuf->buforder_tmpbuff) - 1);
1218 for (map = virt_to_page(dmabuf->tmpbuff); map <= mapend; map++)
1219 cs4x_mem_map_unreserve(map);
1220 free_dmabuf2(state->card, dmabuf);
1223 dmabuf->rawbuf = NULL;
1224 dmabuf->tmpbuff = NULL;
1225 dmabuf->mapped = dmabuf->ready = 0;
1229 static int __prog_dmabuf(struct cs_state *state)
1231 struct dmabuf *dmabuf = &state->dmabuf;
1232 unsigned long flags;
1233 unsigned long allocated_pages, allocated_bytes;
1234 unsigned long tmp1, tmp2, fmt=0;
1235 unsigned long *ptmp = (unsigned long *) dmabuf->pbuf;
1236 unsigned long SGarray[9], nSGpages=0;
1239 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()+ \n"));
1241 * check for CAPTURE and use only non-sg for initial release
1243 if (dmabuf->type == CS_TYPE_ADC) {
1244 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf() ADC\n"));
1246 * add in non-sg support for capture.
1248 spin_lock_irqsave(&state->card->lock, flags);
1249 /* add code to reset the rawbuf memory. TRW */
1250 resync_dma_ptrs(state);
1251 dmabuf->total_bytes = dmabuf->blocks = 0;
1252 dmabuf->count = dmabuf->error = dmabuf->underrun = 0;
1256 spin_unlock_irqrestore(&state->card->lock, flags);
1258 /* allocate DMA buffer if not allocated yet */
1259 if (!dmabuf->rawbuf || !dmabuf->tmpbuff)
1260 if ((ret = alloc_dmabuf(state)))
1263 * static image only supports 16Bit signed, stereo - hard code fmt
1265 fmt = CS_FMT_16BIT | CS_FMT_STEREO;
1267 dmabuf->numfrag = 2;
1268 dmabuf->fragsize = 2048;
1269 dmabuf->fragsamples = 2048 >> sample_shift[fmt];
1270 dmabuf->dmasize = 4096;
1271 dmabuf->fragshift = 11;
1273 memset(dmabuf->rawbuf, (fmt & CS_FMT_16BIT) ? 0 : 0x80,
1275 memset(dmabuf->tmpbuff, (fmt & CS_FMT_16BIT) ? 0 : 0x80,
1276 PAGE_SIZE<<dmabuf->buforder_tmpbuff);
1279 * Now set up the ring
1282 spin_lock_irqsave(&state->card->lock, flags);
1283 cs_rec_setup(state);
1284 spin_unlock_irqrestore(&state->card->lock, flags);
1286 /* set the ready flag for the dma buffer */
1289 CS_DBGOUT(CS_PARMS, 4, printk(
1290 "cs46xx: prog_dmabuf(): CAPTURE rate=%d fmt=0x%x numfrag=%d "
1291 "fragsize=%d dmasize=%d\n",
1292 dmabuf->rate, dmabuf->fmt, dmabuf->numfrag,
1293 dmabuf->fragsize, dmabuf->dmasize) );
1295 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- 0 \n"));
1297 } else if (dmabuf->type == CS_TYPE_DAC) {
1301 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf() DAC\n"));
1302 spin_lock_irqsave(&state->card->lock, flags);
1303 resync_dma_ptrs(state);
1304 dmabuf->total_bytes = dmabuf->blocks = 0;
1305 dmabuf->count = dmabuf->error = dmabuf->underrun = 0;
1309 spin_unlock_irqrestore(&state->card->lock, flags);
1311 /* allocate DMA buffer if not allocated yet */
1312 if (!dmabuf->rawbuf)
1313 if ((ret = alloc_dmabuf(state)))
1316 allocated_pages = 1 << dmabuf->buforder;
1317 allocated_bytes = allocated_pages*PAGE_SIZE;
1319 if (allocated_pages < 2) {
1320 CS_DBGOUT(CS_FUNCTION, 4, printk(
1321 "cs46xx: prog_dmabuf() Error: allocated_pages too small (%d)\n",
1322 (unsigned)allocated_pages));
1326 /* Use all the pages allocated, fragsize 4k. */
1327 /* Use 'pbuf' for S/G page map table. */
1328 dmabuf->SGok = 1; /* Use S/G. */
1330 nSGpages = allocated_bytes/4096; /* S/G pages always 4k. */
1332 /* Set up S/G variables. */
1333 *ptmp = virt_to_bus(dmabuf->rawbuf);
1334 *(ptmp + 1) = 0x00000008;
1335 for (tmp1 = 1; tmp1 < nSGpages; tmp1++) {
1336 *(ptmp + 2 * tmp1) = virt_to_bus((dmabuf->rawbuf) + 4096 * tmp1);
1337 if (tmp1 == nSGpages - 1)
1340 tmp2 = 0x80000000 + 8 * (tmp1 + 1);
1341 *(ptmp + 2 * tmp1 + 1) = tmp2;
1343 SGarray[0] = 0x82c0200d;
1344 SGarray[1] = 0xffff0000;
1346 SGarray[3] = 0x00010600;
1347 SGarray[4] = *(ptmp+2);
1348 SGarray[5] = 0x80000010;
1350 SGarray[7] = *(ptmp+2);
1351 SGarray[8] = (virt_to_bus(dmabuf->pbuf) & 0xffff000) | 0x10;
1354 dmabuf->numfrag = nSGpages;
1355 dmabuf->fragsize = 4096;
1356 dmabuf->fragsamples = 4096 >> sample_shift[dmabuf->fmt];
1357 dmabuf->fragshift = 12;
1358 dmabuf->dmasize = dmabuf->numfrag * 4096;
1360 SGarray[0] = 0xf2c0000f;
1361 SGarray[1] = 0x00000200;
1363 SGarray[3] = 0x00010600;
1364 SGarray[4]=SGarray[5]=SGarray[6]=SGarray[7]=SGarray[8] = 0;
1365 dmabuf->numfrag = 2;
1366 dmabuf->fragsize = 2048;
1367 dmabuf->fragsamples = 2048 >> sample_shift[dmabuf->fmt];
1368 dmabuf->dmasize = 4096;
1369 dmabuf->fragshift = 11;
1371 for (tmp1 = 0; tmp1 < sizeof(SGarray) / 4; tmp1++)
1372 cs461x_poke(state->card, BA1_PDTC+tmp1 * 4, SGarray[tmp1]);
1374 memset(dmabuf->rawbuf, (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
1378 * Now set up the ring
1381 spin_lock_irqsave(&state->card->lock, flags);
1382 cs_play_setup(state);
1383 spin_unlock_irqrestore(&state->card->lock, flags);
1385 /* set the ready flag for the dma buffer */
1388 CS_DBGOUT(CS_PARMS, 4, printk(
1389 "cs46xx: prog_dmabuf(): PLAYBACK rate=%d fmt=0x%x numfrag=%d "
1390 "fragsize=%d dmasize=%d\n",
1391 dmabuf->rate, dmabuf->fmt, dmabuf->numfrag,
1392 dmabuf->fragsize, dmabuf->dmasize) );
1394 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- \n"));
1397 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- Invalid Type %d\n",
1403 static int prog_dmabuf(struct cs_state *state)
1407 mutex_lock(&state->sem);
1408 ret = __prog_dmabuf(state);
1409 mutex_unlock(&state->sem);
1414 static void cs_clear_tail(struct cs_state *state)
1418 static int drain_dac(struct cs_state *state, int nonblock)
1420 DECLARE_WAITQUEUE(wait, current);
1421 struct dmabuf *dmabuf = &state->dmabuf;
1422 struct cs_card *card=state->card;
1423 unsigned long flags;
1427 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()+ \n"));
1428 if (dmabuf->mapped || !dmabuf->ready)
1430 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()- 0, not ready\n"));
1434 add_wait_queue(&dmabuf->wait, &wait);
1436 /* It seems that we have to set the current state to TASK_INTERRUPTIBLE
1437 every time to make the process really go to sleep */
1438 current->state = TASK_INTERRUPTIBLE;
1440 spin_lock_irqsave(&state->card->lock, flags);
1441 count = dmabuf->count;
1442 spin_unlock_irqrestore(&state->card->lock, flags);
1447 if (signal_pending(current))
1451 remove_wait_queue(&dmabuf->wait, &wait);
1452 current->state = TASK_RUNNING;
1456 tmo = (dmabuf->dmasize * HZ) / dmabuf->rate;
1457 tmo >>= sample_shift[dmabuf->fmt];
1458 tmo += (2048*HZ)/dmabuf->rate;
1460 if (!schedule_timeout(tmo ? tmo : 1) && tmo){
1461 printk(KERN_ERR "cs46xx: drain_dac, dma timeout? %d\n", count);
1465 remove_wait_queue(&dmabuf->wait, &wait);
1466 current->state = TASK_RUNNING;
1467 if (signal_pending(current)) {
1468 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()- -ERESTARTSYS\n"));
1470 * set to silence and let that clear the fifos.
1472 cs461x_clear_serial_FIFOs(card, CS_TYPE_DAC);
1473 return -ERESTARTSYS;
1476 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()- 0\n"));
1481 /* update buffer manangement pointers, especially, dmabuf->count and dmabuf->hwptr */
1482 static void cs_update_ptr(struct cs_card *card, int wake)
1484 struct cs_state *state;
1485 struct dmabuf *dmabuf;
1489 /* error handling and process wake up for ADC */
1490 state = card->states[0];
1492 dmabuf = &state->dmabuf;
1493 if (dmabuf->enable & ADC_RUNNING) {
1494 /* update hardware pointer */
1495 hwptr = cs_get_dma_addr(state);
1497 diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1498 CS_DBGOUT(CS_PARMS, 9, printk(
1499 "cs46xx: cs_update_ptr()+ ADC hwptr=%d diff=%d\n",
1501 dmabuf->hwptr = hwptr;
1502 dmabuf->total_bytes += diff;
1503 dmabuf->count += diff;
1504 if (dmabuf->count > dmabuf->dmasize)
1505 dmabuf->count = dmabuf->dmasize;
1507 if (dmabuf->mapped) {
1508 if (wake && dmabuf->count >= (signed)dmabuf->fragsize)
1509 wake_up(&dmabuf->wait);
1511 if (wake && dmabuf->count > 0)
1512 wake_up(&dmabuf->wait);
1520 state = card->states[1];
1522 dmabuf = &state->dmabuf;
1523 /* error handling and process wake up for DAC */
1524 if (dmabuf->enable & DAC_RUNNING) {
1525 /* update hardware pointer */
1526 hwptr = cs_get_dma_addr(state);
1528 diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1529 CS_DBGOUT(CS_PARMS, 9, printk(
1530 "cs46xx: cs_update_ptr()+ DAC hwptr=%d diff=%d\n",
1532 dmabuf->hwptr = hwptr;
1533 dmabuf->total_bytes += diff;
1534 if (dmabuf->mapped) {
1535 dmabuf->count += diff;
1536 if (wake && dmabuf->count >= (signed)dmabuf->fragsize)
1537 wake_up(&dmabuf->wait);
1539 * other drivers use fragsize, but don't see any sense
1540 * in that, since dmasize is the buffer asked for
1543 if (dmabuf->count > dmabuf->dmasize)
1544 dmabuf->count &= dmabuf->dmasize-1;
1546 dmabuf->count -= diff;
1548 * backfill with silence and clear out the last
1549 * "diff" number of bytes.
1551 if (hwptr >= diff) {
1552 memset(dmabuf->rawbuf + hwptr - diff,
1553 (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80, diff);
1555 memset(dmabuf->rawbuf,
1556 (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
1558 memset((char *)dmabuf->rawbuf +
1559 dmabuf->dmasize + hwptr - diff,
1560 (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
1564 if (dmabuf->count < 0 || dmabuf->count > dmabuf->dmasize) {
1565 CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
1566 "cs46xx: ERROR DAC count<0 or count > dmasize (%d)\n",
1569 * buffer underrun or buffer overrun, reset the
1570 * count of bytes written back to 0.
1572 if (dmabuf->count < 0)
1573 dmabuf->underrun = 1;
1577 if (wake && dmabuf->count < (signed)dmabuf->dmasize / 2)
1578 wake_up(&dmabuf->wait);
1585 /* hold spinlock for the following! */
1586 static void cs_handle_midi(struct cs_card *card)
1593 while (!(cs461x_peekBA0(card, BA0_MIDSR) & MIDSR_RBE)) {
1594 ch = cs461x_peekBA0(card, BA0_MIDRP);
1595 if (card->midi.icnt < CS_MIDIINBUF) {
1596 card->midi.ibuf[card->midi.iwr] = ch;
1597 card->midi.iwr = (card->midi.iwr + 1) % CS_MIDIINBUF;
1603 wake_up(&card->midi.iwait);
1605 while (!(cs461x_peekBA0(card, BA0_MIDSR) & MIDSR_TBF) && card->midi.ocnt > 0) {
1606 temp1 = ( card->midi.obuf[card->midi.ord] ) & 0x000000ff;
1607 cs461x_pokeBA0(card, BA0_MIDWP,temp1);
1608 card->midi.ord = (card->midi.ord + 1) % CS_MIDIOUTBUF;
1610 if (card->midi.ocnt < CS_MIDIOUTBUF-16)
1614 wake_up(&card->midi.owait);
1617 static irqreturn_t cs_interrupt(int irq, void *dev_id)
1619 struct cs_card *card = (struct cs_card *)dev_id;
1620 /* Single channel card */
1621 struct cs_state *recstate = card->channel[0].state;
1622 struct cs_state *playstate = card->channel[1].state;
1625 CS_DBGOUT(CS_INTERRUPT, 9, printk("cs46xx: cs_interrupt()+ \n"));
1627 spin_lock(&card->lock);
1629 status = cs461x_peekBA0(card, BA0_HISR);
1631 if ((status & 0x7fffffff) == 0) {
1632 cs461x_pokeBA0(card, BA0_HICR, HICR_CHGM|HICR_IEV);
1633 spin_unlock(&card->lock);
1634 return IRQ_HANDLED; /* Might be IRQ_NONE.. */
1638 * check for playback or capture interrupt only
1640 if (((status & HISR_VC0) && playstate && playstate->dmabuf.ready) ||
1641 (((status & HISR_VC1) && recstate && recstate->dmabuf.ready))) {
1642 CS_DBGOUT(CS_INTERRUPT, 8, printk(
1643 "cs46xx: cs_interrupt() interrupt bit(s) set (0x%x)\n",status));
1644 cs_update_ptr(card, CS_TRUE);
1647 if (status & HISR_MIDI)
1648 cs_handle_midi(card);
1651 cs461x_pokeBA0(card, BA0_HICR, HICR_CHGM|HICR_IEV);
1652 spin_unlock(&card->lock);
1653 CS_DBGOUT(CS_INTERRUPT, 9, printk("cs46xx: cs_interrupt()- \n"));
1658 /**********************************************************************/
1660 static ssize_t cs_midi_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
1662 struct cs_card *card = file->private_data;
1664 unsigned long flags;
1668 if (!access_ok(VERIFY_WRITE, buffer, count))
1672 spin_lock_irqsave(&card->lock, flags);
1673 ptr = card->midi.ird;
1674 cnt = CS_MIDIINBUF - ptr;
1675 if (card->midi.icnt < cnt)
1676 cnt = card->midi.icnt;
1677 spin_unlock_irqrestore(&card->lock, flags);
1681 if (file->f_flags & O_NONBLOCK)
1682 return ret ? ret : -EAGAIN;
1683 interruptible_sleep_on(&card->midi.iwait);
1684 if (signal_pending(current))
1685 return ret ? ret : -ERESTARTSYS;
1688 if (copy_to_user(buffer, card->midi.ibuf + ptr, cnt))
1689 return ret ? ret : -EFAULT;
1690 ptr = (ptr + cnt) % CS_MIDIINBUF;
1691 spin_lock_irqsave(&card->lock, flags);
1692 card->midi.ird = ptr;
1693 card->midi.icnt -= cnt;
1694 spin_unlock_irqrestore(&card->lock, flags);
1703 static ssize_t cs_midi_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
1705 struct cs_card *card = file->private_data;
1707 unsigned long flags;
1711 if (!access_ok(VERIFY_READ, buffer, count))
1715 spin_lock_irqsave(&card->lock, flags);
1716 ptr = card->midi.owr;
1717 cnt = CS_MIDIOUTBUF - ptr;
1718 if (card->midi.ocnt + cnt > CS_MIDIOUTBUF)
1719 cnt = CS_MIDIOUTBUF - card->midi.ocnt;
1721 cs_handle_midi(card);
1722 spin_unlock_irqrestore(&card->lock, flags);
1726 if (file->f_flags & O_NONBLOCK)
1727 return ret ? ret : -EAGAIN;
1728 interruptible_sleep_on(&card->midi.owait);
1729 if (signal_pending(current))
1730 return ret ? ret : -ERESTARTSYS;
1733 if (copy_from_user(card->midi.obuf + ptr, buffer, cnt))
1734 return ret ? ret : -EFAULT;
1735 ptr = (ptr + cnt) % CS_MIDIOUTBUF;
1736 spin_lock_irqsave(&card->lock, flags);
1737 card->midi.owr = ptr;
1738 card->midi.ocnt += cnt;
1739 spin_unlock_irqrestore(&card->lock, flags);
1743 spin_lock_irqsave(&card->lock, flags);
1744 cs_handle_midi(card);
1745 spin_unlock_irqrestore(&card->lock, flags);
1751 static unsigned int cs_midi_poll(struct file *file, struct poll_table_struct *wait)
1753 struct cs_card *card = file->private_data;
1754 unsigned long flags;
1755 unsigned int mask = 0;
1757 if (file->f_flags & FMODE_WRITE)
1758 poll_wait(file, &card->midi.owait, wait);
1759 if (file->f_flags & FMODE_READ)
1760 poll_wait(file, &card->midi.iwait, wait);
1761 spin_lock_irqsave(&card->lock, flags);
1762 if (file->f_flags & FMODE_READ) {
1763 if (card->midi.icnt > 0)
1764 mask |= POLLIN | POLLRDNORM;
1766 if (file->f_flags & FMODE_WRITE) {
1767 if (card->midi.ocnt < CS_MIDIOUTBUF)
1768 mask |= POLLOUT | POLLWRNORM;
1770 spin_unlock_irqrestore(&card->lock, flags);
1775 static int cs_midi_open(struct inode *inode, struct file *file)
1777 unsigned int minor = iminor(inode);
1778 struct cs_card *card = NULL;
1779 unsigned long flags;
1780 struct list_head *entry;
1782 list_for_each(entry, &cs46xx_devs) {
1783 card = list_entry(entry, struct cs_card, list);
1784 if (card->dev_midi == minor)
1788 if (entry == &cs46xx_devs)
1791 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 2, printk(KERN_INFO
1792 "cs46xx: cs46xx_midi_open(): Error - unable to find card struct\n"));
1796 file->private_data = card;
1797 /* wait for device to become free */
1798 mutex_lock(&card->midi.open_mutex);
1799 while (card->midi.open_mode & file->f_mode) {
1800 if (file->f_flags & O_NONBLOCK) {
1801 mutex_unlock(&card->midi.open_mutex);
1804 mutex_unlock(&card->midi.open_mutex);
1805 interruptible_sleep_on(&card->midi.open_wait);
1806 if (signal_pending(current))
1807 return -ERESTARTSYS;
1808 mutex_lock(&card->midi.open_mutex);
1810 spin_lock_irqsave(&card->midi.lock, flags);
1811 if (!(card->midi.open_mode & (FMODE_READ | FMODE_WRITE))) {
1812 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
1813 card->midi.ord = card->midi.owr = card->midi.ocnt = 0;
1814 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
1815 cs461x_pokeBA0(card, BA0_MIDCR, 0x0000000f); /* Enable xmit, rcv. */
1816 cs461x_pokeBA0(card, BA0_HICR, HICR_IEV | HICR_CHGM); /* Enable interrupts */
1818 if (file->f_mode & FMODE_READ)
1819 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
1820 if (file->f_mode & FMODE_WRITE)
1821 card->midi.ord = card->midi.owr = card->midi.ocnt = 0;
1822 spin_unlock_irqrestore(&card->midi.lock, flags);
1823 card->midi.open_mode |= (file->f_mode & (FMODE_READ | FMODE_WRITE));
1824 mutex_unlock(&card->midi.open_mutex);
1829 static int cs_midi_release(struct inode *inode, struct file *file)
1831 struct cs_card *card = file->private_data;
1832 DECLARE_WAITQUEUE(wait, current);
1833 unsigned long flags;
1834 unsigned count, tmo;
1836 if (file->f_mode & FMODE_WRITE) {
1837 current->state = TASK_INTERRUPTIBLE;
1838 add_wait_queue(&card->midi.owait, &wait);
1840 spin_lock_irqsave(&card->midi.lock, flags);
1841 count = card->midi.ocnt;
1842 spin_unlock_irqrestore(&card->midi.lock, flags);
1845 if (signal_pending(current))
1847 if (file->f_flags & O_NONBLOCK)
1849 tmo = (count * HZ) / 3100;
1850 if (!schedule_timeout(tmo ? : 1) && tmo)
1851 printk(KERN_DEBUG "cs46xx: midi timed out??\n");
1853 remove_wait_queue(&card->midi.owait, &wait);
1854 current->state = TASK_RUNNING;
1856 mutex_lock(&card->midi.open_mutex);
1857 card->midi.open_mode &= (~(file->f_mode & (FMODE_READ | FMODE_WRITE)));
1858 mutex_unlock(&card->midi.open_mutex);
1859 wake_up(&card->midi.open_wait);
1864 * Midi file operations struct.
1866 static /*const*/ struct file_operations cs_midi_fops = {
1867 CS_OWNER CS_THIS_MODULE
1868 .llseek = no_llseek,
1869 .read = cs_midi_read,
1870 .write = cs_midi_write,
1871 .poll = cs_midi_poll,
1872 .open = cs_midi_open,
1873 .release = cs_midi_release,
1878 * CopySamples copies 16-bit stereo signed samples from the source to the
1879 * destination, possibly converting down to unsigned 8-bit and/or mono.
1880 * count specifies the number of output bytes to write.
1884 * dst - Pointer to a destination buffer.
1885 * src - Pointer to a source buffer
1886 * count - The number of bytes to copy into the destination buffer.
1887 * fmt - CS_FMT_16BIT and/or CS_FMT_STEREO bits
1888 * dmabuf - pointer to the dma buffer structure
1890 * NOTES: only call this routine if the output desired is not 16 Signed Stereo
1894 static void CopySamples(char *dst, char *src, int count, unsigned fmt,
1895 struct dmabuf *dmabuf)
1898 s16 *psSrc = (s16 *)src;
1899 s16 *psDst = (s16 *)dst;
1900 u8 *pucDst = (u8 *)dst;
1902 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs46xx: CopySamples()+ ") );
1903 CS_DBGOUT(CS_WAVE_READ, 8, printk(KERN_INFO
1904 " dst=%p src=%p count=%d fmt=0x%x\n",
1905 dst,src,count,fmt) );
1908 * See if the data should be output as 8-bit unsigned stereo.
1910 if ((fmt & CS_FMT_STEREO) && !(fmt & CS_FMT_16BIT)) {
1912 * Convert each 16-bit signed stereo sample to 8-bit unsigned
1913 * stereo using rounding.
1918 *(pucDst++) = (u8)(((s16)(*psSrc++) + (s16)0x8000) >> 8);
1921 * See if the data should be output at 8-bit unsigned mono.
1923 else if (!(fmt & CS_FMT_STEREO) && !(fmt & CS_FMT_16BIT)) {
1925 * Convert each 16-bit signed stereo sample to 8-bit unsigned
1926 * mono using averaging and rounding.
1931 s32AudioSample = ((*psSrc) + (*(psSrc + 1))) / 2 + (s32)0x80;
1932 if (s32AudioSample > 0x7fff)
1933 s32AudioSample = 0x7fff;
1934 *(pucDst++) = (u8)(((s16)s32AudioSample + (s16)0x8000) >> 8);
1939 * See if the data should be output at 16-bit signed mono.
1941 else if (!(fmt & CS_FMT_STEREO) && (fmt & CS_FMT_16BIT)) {
1943 * Convert each 16-bit signed stereo sample to 16-bit signed
1944 * mono using averaging.
1949 *(psDst++) = (s16)((*psSrc) + (*(psSrc + 1))) / 2;
1957 * replacement for the standard copy_to_user, to allow for a conversion from
1958 * 16 bit to 8 bit and from stereo to mono, if the record conversion is active.
1959 * The current CS46xx/CS4280 static image only records in 16bit unsigned Stereo,
1960 * so we convert from any of the other format combinations.
1962 static unsigned cs_copy_to_user(
1969 struct dmabuf *dmabuf = &s->dmabuf;
1970 void *src = hwsrc; /* default to the standard destination buffer addr */
1972 CS_DBGOUT(CS_FUNCTION, 6, printk(KERN_INFO
1973 "cs_copy_to_user()+ fmt=0x%x cnt=%d dest=%p\n",
1974 dmabuf->fmt,(unsigned)cnt,dest) );
1976 if (cnt > dmabuf->dmasize)
1977 cnt = dmabuf->dmasize;
1982 if (dmabuf->divisor != 1) {
1983 if (!dmabuf->tmpbuff) {
1984 *copied = cnt / dmabuf->divisor;
1988 CopySamples((char *)dmabuf->tmpbuff, (char *)hwsrc, cnt,
1989 dmabuf->fmt, dmabuf);
1990 src = dmabuf->tmpbuff;
1991 cnt = cnt/dmabuf->divisor;
1993 if (copy_to_user(dest, src, cnt)) {
1994 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_ERR
1995 "cs46xx: cs_copy_to_user()- fault dest=%p src=%p cnt=%d\n",
2001 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO
2002 "cs46xx: cs_copy_to_user()- copied bytes is %d \n",cnt));
2006 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be copied to
2007 the user's buffer. it is filled by the dma machine and drained by this loop. */
2008 static ssize_t cs_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
2010 struct cs_card *card = file->private_data;
2011 struct cs_state *state;
2012 DECLARE_WAITQUEUE(wait, current);
2013 struct dmabuf *dmabuf;
2015 unsigned long flags;
2018 unsigned copied = 0;
2020 CS_DBGOUT(CS_WAVE_READ | CS_FUNCTION, 4,
2021 printk("cs46xx: cs_read()+ %zd\n",count) );
2022 state = card->states[0];
2025 dmabuf = &state->dmabuf;
2029 if (!access_ok(VERIFY_WRITE, buffer, count))
2032 mutex_lock(&state->sem);
2033 if (!dmabuf->ready && (ret = __prog_dmabuf(state)))
2036 add_wait_queue(&state->dmabuf.wait, &wait);
2038 while (!(card->pm.flags & CS46XX_PM_IDLE)) {
2040 if (signal_pending(current)) {
2046 spin_lock_irqsave(&state->card->lock, flags);
2047 swptr = dmabuf->swptr;
2048 cnt = dmabuf->dmasize - swptr;
2049 if (dmabuf->count < cnt)
2050 cnt = dmabuf->count;
2052 __set_current_state(TASK_INTERRUPTIBLE);
2053 spin_unlock_irqrestore(&state->card->lock, flags);
2055 if (cnt > (count * dmabuf->divisor))
2056 cnt = count * dmabuf->divisor;
2058 /* buffer is empty, start the dma machine and wait for data to be
2061 if (file->f_flags & O_NONBLOCK) {
2066 mutex_unlock(&state->sem);
2068 if (signal_pending(current)) {
2073 mutex_lock(&state->sem);
2074 if (dmabuf->mapped) {
2082 CS_DBGOUT(CS_WAVE_READ, 2, printk(KERN_INFO
2083 "_read() copy_to cnt=%d count=%zd ", cnt,count) );
2084 CS_DBGOUT(CS_WAVE_READ, 8, printk(KERN_INFO
2085 " .dmasize=%d .count=%d buffer=%p ret=%zd\n",
2086 dmabuf->dmasize,dmabuf->count,buffer,ret));
2088 if (cs_copy_to_user(state, buffer,
2089 (char *)dmabuf->rawbuf + swptr, cnt, &copied)) {
2094 swptr = (swptr + cnt) % dmabuf->dmasize;
2095 spin_lock_irqsave(&card->lock, flags);
2096 dmabuf->swptr = swptr;
2097 dmabuf->count -= cnt;
2098 spin_unlock_irqrestore(&card->lock, flags);
2105 remove_wait_queue(&state->dmabuf.wait, &wait);
2107 mutex_unlock(&state->sem);
2108 set_current_state(TASK_RUNNING);
2109 CS_DBGOUT(CS_WAVE_READ | CS_FUNCTION, 4,
2110 printk("cs46xx: cs_read()- %zd\n",ret) );
2114 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be dma to
2115 the soundcard. it is drained by the dma machine and filled by this loop. */
2116 static ssize_t cs_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
2118 struct cs_card *card = file->private_data;
2119 struct cs_state *state;
2120 DECLARE_WAITQUEUE(wait, current);
2121 struct dmabuf *dmabuf;
2123 unsigned long flags;
2127 CS_DBGOUT(CS_WAVE_WRITE | CS_FUNCTION, 4,
2128 printk("cs46xx: cs_write called, count = %zd\n", count) );
2129 state = card->states[1];
2132 if (!access_ok(VERIFY_READ, buffer, count))
2134 dmabuf = &state->dmabuf;
2136 mutex_lock(&state->sem);
2137 if (dmabuf->mapped) {
2142 if (!dmabuf->ready && (ret = __prog_dmabuf(state)))
2144 add_wait_queue(&state->dmabuf.wait, &wait);
2147 * Start the loop to read from the user's buffer and write to the dma buffer.
2148 * check for PM events and underrun/overrun in the loop.
2151 while (!(card->pm.flags & CS46XX_PM_IDLE)) {
2153 if (signal_pending(current)) {
2159 spin_lock_irqsave(&state->card->lock, flags);
2160 if (dmabuf->count < 0) {
2161 /* buffer underrun, we are recovering from sleep_on_timeout,
2162 resync hwptr and swptr */
2164 dmabuf->swptr = dmabuf->hwptr;
2166 if (dmabuf->underrun) {
2167 dmabuf->underrun = 0;
2168 dmabuf->hwptr = cs_get_dma_addr(state);
2169 dmabuf->swptr = dmabuf->hwptr;
2172 swptr = dmabuf->swptr;
2173 cnt = dmabuf->dmasize - swptr;
2174 if (dmabuf->count + cnt > dmabuf->dmasize)
2175 cnt = dmabuf->dmasize - dmabuf->count;
2177 __set_current_state(TASK_INTERRUPTIBLE);
2178 spin_unlock_irqrestore(&state->card->lock, flags);
2183 /* buffer is full, start the dma machine and wait for data to be
2186 if (file->f_flags & O_NONBLOCK) {
2191 mutex_unlock(&state->sem);
2193 if (signal_pending(current)) {
2198 mutex_lock(&state->sem);
2199 if (dmabuf->mapped) {
2206 if (copy_from_user(dmabuf->rawbuf + swptr, buffer, cnt)) {
2211 spin_lock_irqsave(&state->card->lock, flags);
2212 swptr = (swptr + cnt) % dmabuf->dmasize;
2213 dmabuf->swptr = swptr;
2214 dmabuf->count += cnt;
2215 if (dmabuf->count > dmabuf->dmasize) {
2216 CS_DBGOUT(CS_WAVE_WRITE | CS_ERROR, 2, printk(
2217 "cs46xx: cs_write() d->count > dmasize - resetting\n"));
2218 dmabuf->count = dmabuf->dmasize;
2220 dmabuf->endcleared = 0;
2221 spin_unlock_irqrestore(&state->card->lock, flags);
2229 mutex_unlock(&state->sem);
2230 remove_wait_queue(&state->dmabuf.wait, &wait);
2231 set_current_state(TASK_RUNNING);
2233 CS_DBGOUT(CS_WAVE_WRITE | CS_FUNCTION, 2,
2234 printk("cs46xx: cs_write()- ret=%zd\n", ret));
2238 static unsigned int cs_poll(struct file *file, struct poll_table_struct *wait)
2240 struct cs_card *card = file->private_data;
2241 struct dmabuf *dmabuf;
2242 struct cs_state *state;
2243 unsigned long flags;
2244 unsigned int mask = 0;
2246 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_poll()+ \n"));
2247 if (!(file->f_mode & (FMODE_WRITE | FMODE_READ))) {
2250 if (file->f_mode & FMODE_WRITE) {
2251 state = card->states[1];
2253 dmabuf = &state->dmabuf;
2254 poll_wait(file, &dmabuf->wait, wait);
2257 if (file->f_mode & FMODE_READ) {
2258 state = card->states[0];
2260 dmabuf = &state->dmabuf;
2261 poll_wait(file, &dmabuf->wait, wait);
2265 spin_lock_irqsave(&card->lock, flags);
2266 cs_update_ptr(card, CS_FALSE);
2267 if (file->f_mode & FMODE_READ) {
2268 state = card->states[0];
2270 dmabuf = &state->dmabuf;
2271 if (dmabuf->count >= (signed)dmabuf->fragsize)
2272 mask |= POLLIN | POLLRDNORM;
2275 if (file->f_mode & FMODE_WRITE) {
2276 state = card->states[1];
2278 dmabuf = &state->dmabuf;
2279 if (dmabuf->mapped) {
2280 if (dmabuf->count >= (signed)dmabuf->fragsize)
2281 mask |= POLLOUT | POLLWRNORM;
2283 if ((signed)dmabuf->dmasize >= dmabuf->count
2284 + (signed)dmabuf->fragsize)
2285 mask |= POLLOUT | POLLWRNORM;
2289 spin_unlock_irqrestore(&card->lock, flags);
2291 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_poll()- (0x%x) \n",
2297 * We let users mmap the ring buffer. Its not the real DMA buffer but
2298 * that side of the code is hidden in the IRQ handling. We do a software
2299 * emulation of DMA from a 64K or so buffer into a 2K FIFO.
2300 * (the hardware probably deserves a moan here but Crystal send me nice
2304 static int cs_mmap(struct file *file, struct vm_area_struct *vma)
2306 struct cs_card *card = file->private_data;
2307 struct cs_state *state;
2308 struct dmabuf *dmabuf;
2312 CS_DBGOUT(CS_FUNCTION | CS_PARMS, 2, printk("cs46xx: cs_mmap()+ file=%p %s %s\n",
2313 file, vma->vm_flags & VM_WRITE ? "VM_WRITE" : "",
2314 vma->vm_flags & VM_READ ? "VM_READ" : "") );
2316 if (vma->vm_flags & VM_WRITE) {
2317 state = card->states[1];
2319 CS_DBGOUT(CS_OPEN, 2, printk(
2320 "cs46xx: cs_mmap() VM_WRITE - state TRUE prog_dmabuf DAC\n") );
2321 if ((ret = prog_dmabuf(state)) != 0)
2324 } else if (vma->vm_flags & VM_READ) {
2325 state = card->states[0];
2327 CS_DBGOUT(CS_OPEN, 2, printk(
2328 "cs46xx: cs_mmap() VM_READ - state TRUE prog_dmabuf ADC\n") );
2329 if ((ret = prog_dmabuf(state)) != 0)
2333 CS_DBGOUT(CS_ERROR, 2, printk(
2334 "cs46xx: cs_mmap() return -EINVAL\n") );
2339 * For now ONLY support playback, but seems like the only way to use
2340 * mmap() is to open an FD with RDWR, just read or just write access
2341 * does not function, get an error back from the kernel.
2342 * Also, QuakeIII opens with RDWR! So, there must be something
2343 * to needing read/write access mapping. So, allow read/write but
2346 state = card->states[1];
2352 mutex_lock(&state->sem);
2353 dmabuf = &state->dmabuf;
2354 if (cs4x_pgoff(vma) != 0) {
2358 size = vma->vm_end - vma->vm_start;
2360 CS_DBGOUT(CS_PARMS, 2, printk("cs46xx: cs_mmap(): size=%d\n",(unsigned)size) );
2362 if (size > (PAGE_SIZE << dmabuf->buforder)) {
2366 if (remap_pfn_range(vma, vma->vm_start,
2367 virt_to_phys(dmabuf->rawbuf) >> PAGE_SHIFT,
2368 size, vma->vm_page_prot)) {
2374 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_mmap()-\n") );
2376 mutex_unlock(&state->sem);
2380 static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
2382 struct cs_card *card = file->private_data;
2383 struct cs_state *state;
2384 struct dmabuf *dmabuf = NULL;
2385 unsigned long flags;
2386 audio_buf_info abinfo;
2388 int val, valsave, ret;
2390 void __user *argp = (void __user *)arg;
2391 int __user *p = argp;
2393 state = card->states[0];
2395 dmabuf = &state->dmabuf;
2396 mapped = (file->f_mode & FMODE_READ) && dmabuf->mapped;
2398 state = card->states[1];
2400 dmabuf = &state->dmabuf;
2401 mapped |= (file->f_mode & FMODE_WRITE) && dmabuf->mapped;
2409 case OSS_GETVERSION:
2410 return put_user(SOUND_VERSION, p);
2411 case SNDCTL_DSP_RESET:
2412 /* FIXME: spin_lock ? */
2413 if (file->f_mode & FMODE_WRITE) {
2414 state = card->states[1];
2416 dmabuf = &state->dmabuf;
2418 synchronize_irq(card->irq);
2420 resync_dma_ptrs(state);
2421 dmabuf->swptr = dmabuf->hwptr = 0;
2422 dmabuf->count = dmabuf->total_bytes = 0;
2427 if (file->f_mode & FMODE_READ) {
2428 state = card->states[0];
2430 dmabuf = &state->dmabuf;
2432 synchronize_irq(card->irq);
2433 resync_dma_ptrs(state);
2435 dmabuf->swptr = dmabuf->hwptr = 0;
2436 dmabuf->count = dmabuf->total_bytes = 0;
2441 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_RESET()-\n") );
2443 case SNDCTL_DSP_SYNC:
2444 if (file->f_mode & FMODE_WRITE)
2445 return drain_dac(state, file->f_flags & O_NONBLOCK);
2447 case SNDCTL_DSP_SPEED: /* set sample rate */
2448 if (get_user(val, p))
2451 if (file->f_mode & FMODE_READ) {
2452 state = card->states[0];
2454 dmabuf = &state->dmabuf;
2458 cs_set_adc_rate(state, val);
2459 cs_set_divisor(dmabuf);
2462 if (file->f_mode & FMODE_WRITE) {
2463 state = card->states[1];
2465 dmabuf = &state->dmabuf;
2469 cs_set_dac_rate(state, val);
2470 cs_set_divisor(dmabuf);
2473 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2474 "cs46xx: cs_ioctl() DSP_SPEED %s %s %d\n",
2475 file->f_mode & FMODE_WRITE ? "DAC" : "",
2476 file->f_mode & FMODE_READ ? "ADC" : "",
2478 return put_user(dmabuf->rate, p);
2480 return put_user(0, p);
2481 case SNDCTL_DSP_STEREO: /* set stereo or mono channel */
2482 if (get_user(val, p))
2484 if (file->f_mode & FMODE_WRITE) {
2485 state = card->states[1];
2487 dmabuf = &state->dmabuf;
2492 dmabuf->fmt |= CS_FMT_STEREO;
2494 dmabuf->fmt &= ~CS_FMT_STEREO;
2495 cs_set_divisor(dmabuf);
2496 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2497 "cs46xx: DSP_STEREO() DAC %s\n",
2498 (dmabuf->fmt & CS_FMT_STEREO) ?
2502 if (file->f_mode & FMODE_READ) {
2503 state = card->states[0];
2505 dmabuf = &state->dmabuf;
2510 dmabuf->fmt |= CS_FMT_STEREO;
2512 dmabuf->fmt &= ~CS_FMT_STEREO;
2513 cs_set_divisor(dmabuf);
2514 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2515 "cs46xx: DSP_STEREO() ADC %s\n",
2516 (dmabuf->fmt & CS_FMT_STEREO) ?
2521 case SNDCTL_DSP_GETBLKSIZE:
2522 if (file->f_mode & FMODE_WRITE) {
2523 state = card->states[1];
2525 dmabuf = &state->dmabuf;
2526 if ((val = prog_dmabuf(state)))
2528 return put_user(dmabuf->fragsize, p);
2531 if (file->f_mode & FMODE_READ) {
2532 state = card->states[0];
2534 dmabuf = &state->dmabuf;
2535 if ((val = prog_dmabuf(state)))
2537 return put_user(dmabuf->fragsize/dmabuf->divisor,
2541 return put_user(0, p);
2542 case SNDCTL_DSP_GETFMTS: /* Returns a mask of supported sample format*/
2543 return put_user(AFMT_S16_LE | AFMT_U8, p);
2544 case SNDCTL_DSP_SETFMT: /* Select sample format */
2545 if (get_user(val, p))
2547 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2548 "cs46xx: cs_ioctl() DSP_SETFMT %s %s %s %s\n",
2549 file->f_mode & FMODE_WRITE ? "DAC" : "",
2550 file->f_mode & FMODE_READ ? "ADC" : "",
2551 val == AFMT_S16_LE ? "16Bit Signed" : "",
2552 val == AFMT_U8 ? "8Bit Unsigned" : "") );
2554 if (val != AFMT_QUERY) {
2555 if (val==AFMT_S16_LE || val==AFMT_U8) {
2556 if (file->f_mode & FMODE_WRITE) {
2557 state = card->states[1];
2559 dmabuf = &state->dmabuf;
2563 if (val == AFMT_S16_LE)
2564 dmabuf->fmt |= CS_FMT_16BIT;
2566 dmabuf->fmt &= ~CS_FMT_16BIT;
2567 cs_set_divisor(dmabuf);
2568 if ((ret = prog_dmabuf(state)))
2572 if (file->f_mode & FMODE_READ) {
2574 state = card->states[0];
2576 dmabuf = &state->dmabuf;
2580 if (val == AFMT_S16_LE)
2581 dmabuf->fmt |= CS_FMT_16BIT;
2583 dmabuf->fmt &= ~CS_FMT_16BIT;
2584 cs_set_divisor(dmabuf);
2585 if ((ret = prog_dmabuf(state)))
2590 CS_DBGOUT(CS_IOCTL | CS_ERROR, 2, printk(
2591 "cs46xx: DSP_SETFMT() Unsupported format (0x%x)\n",
2595 if (file->f_mode & FMODE_WRITE) {
2596 state = card->states[1];
2598 dmabuf = &state->dmabuf;
2599 } else if (file->f_mode & FMODE_READ) {
2600 state = card->states[0];
2602 dmabuf = &state->dmabuf;
2606 if (dmabuf->fmt & CS_FMT_16BIT)
2607 return put_user(AFMT_S16_LE, p);
2609 return put_user(AFMT_U8, p);
2611 return put_user(0, p);
2612 case SNDCTL_DSP_CHANNELS:
2613 if (get_user(val, p))
2616 if (file->f_mode & FMODE_WRITE) {
2617 state = card->states[1];
2619 dmabuf = &state->dmabuf;
2624 dmabuf->fmt |= CS_FMT_STEREO;
2626 dmabuf->fmt &= ~CS_FMT_STEREO;
2627 cs_set_divisor(dmabuf);
2628 if (prog_dmabuf(state))
2632 if (file->f_mode & FMODE_READ) {
2633 state = card->states[0];
2635 dmabuf = &state->dmabuf;
2640 dmabuf->fmt |= CS_FMT_STEREO;
2642 dmabuf->fmt &= ~CS_FMT_STEREO;
2643 cs_set_divisor(dmabuf);
2644 if (prog_dmabuf(state))
2649 return put_user((dmabuf->fmt & CS_FMT_STEREO) ? 2 : 1,
2651 case SNDCTL_DSP_POST:
2653 * There will be a longer than normal pause in the data.
2654 * so... do nothing, because there is nothing that we can do.
2657 case SNDCTL_DSP_SUBDIVIDE:
2658 if (file->f_mode & FMODE_WRITE) {
2659 state = card->states[1];
2661 dmabuf = &state->dmabuf;
2662 if (dmabuf->subdivision)
2664 if (get_user(val, p))
2666 if (val != 1 && val != 2)
2668 dmabuf->subdivision = val;
2671 if (file->f_mode & FMODE_READ) {
2672 state = card->states[0];
2674 dmabuf = &state->dmabuf;
2675 if (dmabuf->subdivision)
2677 if (get_user(val, p))
2679 if (val != 1 && val != 2)
2681 dmabuf->subdivision = val;
2685 case SNDCTL_DSP_SETFRAGMENT:
2686 if (get_user(val, p))
2688 if (file->f_mode & FMODE_WRITE) {
2689 state = card->states[1];
2691 dmabuf = &state->dmabuf;
2692 dmabuf->ossfragshift = val & 0xffff;
2693 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2696 if (file->f_mode & FMODE_READ) {
2697 state = card->states[0];
2699 dmabuf = &state->dmabuf;
2700 dmabuf->ossfragshift = val & 0xffff;
2701 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2705 case SNDCTL_DSP_GETOSPACE:
2706 if (!(file->f_mode & FMODE_WRITE))
2708 state = card->states[1];
2710 dmabuf = &state->dmabuf;
2711 spin_lock_irqsave(&state->card->lock, flags);
2712 cs_update_ptr(card, CS_TRUE);
2713 abinfo.fragsize = dmabuf->fragsize;
2714 abinfo.fragstotal = dmabuf->numfrag;
2716 * for mmap we always have total space available
2719 abinfo.bytes = dmabuf->dmasize;
2721 abinfo.bytes = dmabuf->dmasize - dmabuf->count;
2723 abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
2724 spin_unlock_irqrestore(&state->card->lock, flags);
2725 return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2728 case SNDCTL_DSP_GETISPACE:
2729 if (!(file->f_mode & FMODE_READ))
2731 state = card->states[0];
2733 dmabuf = &state->dmabuf;
2734 spin_lock_irqsave(&state->card->lock, flags);
2735 cs_update_ptr(card, CS_TRUE);
2736 abinfo.fragsize = dmabuf->fragsize/dmabuf->divisor;
2737 abinfo.bytes = dmabuf->count/dmabuf->divisor;
2738 abinfo.fragstotal = dmabuf->numfrag;
2739 abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
2740 spin_unlock_irqrestore(&state->card->lock, flags);
2741 return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2744 case SNDCTL_DSP_NONBLOCK:
2745 file->f_flags |= O_NONBLOCK;
2747 case SNDCTL_DSP_GETCAPS:
2748 return put_user(DSP_CAP_REALTIME|DSP_CAP_TRIGGER|DSP_CAP_MMAP,
2750 case SNDCTL_DSP_GETTRIGGER:
2752 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_GETTRIGGER()+\n") );
2753 if (file->f_mode & FMODE_WRITE) {
2754 state = card->states[1];
2756 dmabuf = &state->dmabuf;
2757 if (dmabuf->enable & DAC_RUNNING)
2758 val |= PCM_ENABLE_INPUT;
2761 if (file->f_mode & FMODE_READ) {
2763 state = card->states[0];
2764 dmabuf = &state->dmabuf;
2765 if (dmabuf->enable & ADC_RUNNING)
2766 val |= PCM_ENABLE_OUTPUT;
2769 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_GETTRIGGER()- val=0x%x\n",val) );
2770 return put_user(val, p);
2771 case SNDCTL_DSP_SETTRIGGER:
2772 if (get_user(val, p))
2774 if (file->f_mode & FMODE_READ) {
2775 state = card->states[0];
2777 dmabuf = &state->dmabuf;
2778 if (val & PCM_ENABLE_INPUT) {
2779 if (!dmabuf->ready && (ret = prog_dmabuf(state)))
2786 if (file->f_mode & FMODE_WRITE) {
2787 state = card->states[1];
2789 dmabuf = &state->dmabuf;
2790 if (val & PCM_ENABLE_OUTPUT) {
2791 if (!dmabuf->ready && (ret = prog_dmabuf(state)))
2799 case SNDCTL_DSP_GETIPTR:
2800 if (!(file->f_mode & FMODE_READ))
2802 state = card->states[0];
2804 dmabuf = &state->dmabuf;
2805 spin_lock_irqsave(&state->card->lock, flags);
2806 cs_update_ptr(card, CS_TRUE);
2807 cinfo.bytes = dmabuf->total_bytes/dmabuf->divisor;
2808 cinfo.blocks = dmabuf->count/dmabuf->divisor >> dmabuf->fragshift;
2809 cinfo.ptr = dmabuf->hwptr/dmabuf->divisor;
2810 spin_unlock_irqrestore(&state->card->lock, flags);
2811 if (copy_to_user(argp, &cinfo, sizeof(cinfo)))
2816 case SNDCTL_DSP_GETOPTR:
2817 if (!(file->f_mode & FMODE_WRITE))
2819 state = card->states[1];
2821 dmabuf = &state->dmabuf;
2822 spin_lock_irqsave(&state->card->lock, flags);
2823 cs_update_ptr(card, CS_TRUE);
2824 cinfo.bytes = dmabuf->total_bytes;
2825 if (dmabuf->mapped) {
2826 cinfo.blocks = (cinfo.bytes >> dmabuf->fragshift)
2828 CS_DBGOUT(CS_PARMS, 8,
2829 printk("total_bytes=%d blocks=%d dmabuf->blocks=%d\n",
2830 cinfo.bytes,cinfo.blocks,dmabuf->blocks) );
2831 dmabuf->blocks = cinfo.bytes >> dmabuf->fragshift;
2833 cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
2835 cinfo.ptr = dmabuf->hwptr;
2837 CS_DBGOUT(CS_PARMS, 4, printk(
2838 "cs46xx: GETOPTR bytes=%d blocks=%d ptr=%d\n",
2839 cinfo.bytes,cinfo.blocks,cinfo.ptr) );
2840 spin_unlock_irqrestore(&state->card->lock, flags);
2841 if (copy_to_user(argp, &cinfo, sizeof(cinfo)))
2846 case SNDCTL_DSP_SETDUPLEX:
2848 case SNDCTL_DSP_GETODELAY:
2849 if (!(file->f_mode & FMODE_WRITE))
2851 state = card->states[1];
2853 dmabuf = &state->dmabuf;
2854 spin_lock_irqsave(&state->card->lock, flags);
2855 cs_update_ptr(card, CS_TRUE);
2856 val = dmabuf->count;
2857 spin_unlock_irqrestore(&state->card->lock, flags);
2860 return put_user(val, p);
2861 case SOUND_PCM_READ_RATE:
2862 if (file->f_mode & FMODE_READ)
2863 state = card->states[0];
2865 state = card->states[1];
2867 dmabuf = &state->dmabuf;
2868 return put_user(dmabuf->rate, p);
2870 return put_user(0, p);
2871 case SOUND_PCM_READ_CHANNELS:
2872 if (file->f_mode & FMODE_READ)
2873 state = card->states[0];
2875 state = card->states[1];
2877 dmabuf = &state->dmabuf;
2878 return put_user((dmabuf->fmt & CS_FMT_STEREO) ? 2 : 1,
2881 return put_user(0, p);
2882 case SOUND_PCM_READ_BITS:
2883 if (file->f_mode & FMODE_READ)
2884 state = card->states[0];
2886 state = card->states[1];
2888 dmabuf = &state->dmabuf;
2889 return put_user((dmabuf->fmt & CS_FMT_16BIT) ?
2890 AFMT_S16_LE : AFMT_U8, p);
2893 return put_user(0, p);
2894 case SNDCTL_DSP_MAPINBUF:
2895 case SNDCTL_DSP_MAPOUTBUF:
2896 case SNDCTL_DSP_SETSYNCRO:
2897 case SOUND_PCM_WRITE_FILTER:
2898 case SOUND_PCM_READ_FILTER:
2906 * AMP control - null AMP
2909 static void amp_none(struct cs_card *card, int change)
2917 static void amp_voyetra(struct cs_card *card, int change)
2919 /* Manage the EAPD bit on the Crystal 4297
2920 and the Analog AD1885 */
2922 int old = card->amplifier;
2924 card->amplifier+=change;
2925 if (card->amplifier && !old) {
2926 /* Turn the EAPD amp on */
2927 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL,
2928 cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) |
2930 } else if(old && !card->amplifier) {
2931 /* Turn the EAPD amp off */
2932 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL,
2933 cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
2940 * Game Theatre XP card - EGPIO[2] is used to enable the external amp.
2943 static void amp_hercules(struct cs_card *card, int change)
2945 int old = card->amplifier;
2947 CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
2948 "cs46xx: amp_hercules() called before initialized.\n"));
2951 card->amplifier+=change;
2952 if ((card->amplifier && !old) && !(hercules_egpio_disable)) {
2953 CS_DBGOUT(CS_PARMS, 4, printk(KERN_INFO
2954 "cs46xx: amp_hercules() external amp enabled\n"));
2955 cs461x_pokeBA0(card, BA0_EGPIODR,
2956 EGPIODR_GPOE2); /* enable EGPIO2 output */
2957 cs461x_pokeBA0(card, BA0_EGPIOPTR,
2958 EGPIOPTR_GPPT2); /* open-drain on output */
2959 } else if (old && !card->amplifier) {
2960 CS_DBGOUT(CS_PARMS, 4, printk(KERN_INFO
2961 "cs46xx: amp_hercules() external amp disabled\n"));
2962 cs461x_pokeBA0(card, BA0_EGPIODR, 0); /* disable */
2963 cs461x_pokeBA0(card, BA0_EGPIOPTR, 0); /* disable */
2968 * Handle the CLKRUN on a thinkpad. We must disable CLKRUN support
2969 * whenever we need to beat on the chip.
2971 * The original idea and code for this hack comes from David Kaiser at
2972 * Linuxcare. Perhaps one day Crystal will document their chips well
2973 * enough to make them useful.
2976 static void clkrun_hack(struct cs_card *card, int change)
2978 struct pci_dev *acpi_dev;
2982 int old = card->active;
2984 card->active+=change;
2986 acpi_dev = pci_get_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371AB_3, NULL);
2987 if (acpi_dev == NULL)
2988 return; /* Not a thinkpad thats for sure */
2990 /* Find the control port */
2991 pci_read_config_byte(acpi_dev, 0x41, &pp);
2994 /* Read ACPI port */
2995 control = inw(port + 0x10);
2997 /* Flip CLKRUN off while running */
2998 if (!card->active && old) {
2999 CS_DBGOUT(CS_PARMS , 9, printk( KERN_INFO
3000 "cs46xx: clkrun() enable clkrun - change=%d active=%d\n",
3001 change,card->active));
3002 outw(control|0x2000, port+0x10);
3005 * sometimes on a resume the bit is set, so always reset the bit.
3007 CS_DBGOUT(CS_PARMS , 9, printk( KERN_INFO
3008 "cs46xx: clkrun() disable clkrun - change=%d active=%d\n",
3009 change,card->active));
3010 outw(control&~0x2000, port+0x10);
3012 pci_dev_put(acpi_dev);
3016 static int cs_open(struct inode *inode, struct file *file)
3018 struct cs_card *card = file->private_data;
3019 struct cs_state *state = NULL;
3020 struct dmabuf *dmabuf = NULL;
3021 struct list_head *entry;
3022 unsigned int minor = iminor(inode);
3026 CS_DBGOUT(CS_OPEN | CS_FUNCTION, 2, printk("cs46xx: cs_open()+ file=%p %s %s\n",
3027 file, file->f_mode & FMODE_WRITE ? "FMODE_WRITE" : "",
3028 file->f_mode & FMODE_READ ? "FMODE_READ" : "") );
3030 list_for_each(entry, &cs46xx_devs) {
3031 card = list_entry(entry, struct cs_card, list);
3033 if (!((card->dev_audio ^ minor) & ~0xf))
3036 if (entry == &cs46xx_devs)
3039 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 2, printk(KERN_INFO
3040 "cs46xx: cs_open(): Error - unable to find audio card struct\n"));
3045 * hardcode state[0] for capture, [1] for playback
3047 if (file->f_mode & FMODE_READ) {
3048 CS_DBGOUT(CS_WAVE_READ, 2, printk("cs46xx: cs_open() FMODE_READ\n") );
3049 if (card->states[0] == NULL) {
3050 state = card->states[0] =
3051 kzalloc(sizeof(struct cs_state), GFP_KERNEL);
3054 mutex_init(&state->sem);
3055 dmabuf = &state->dmabuf;
3056 dmabuf->pbuf = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
3057 if (dmabuf->pbuf == NULL) {
3059 card->states[0] = NULL;
3063 state = card->states[0];
3064 if (state->open_mode & FMODE_READ)
3067 dmabuf->channel = card->alloc_rec_pcm_channel(card);
3069 if (dmabuf->channel == NULL) {
3070 kfree(card->states[0]);
3071 card->states[0] = NULL;
3075 /* Now turn on external AMP if needed */
3077 state->card->active_ctrl(state->card, 1);
3078 state->card->amplifier_ctrl(state->card, 1);
3080 if ((tmp = cs46xx_powerup(card, CS_POWER_ADC))) {
3081 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3082 "cs46xx: cs46xx_powerup of ADC failed (0x%x)\n", tmp));
3086 dmabuf->channel->state = state;
3087 /* initialize the virtual channel */
3089 state->magic = CS_STATE_MAGIC;
3090 init_waitqueue_head(&dmabuf->wait);
3091 mutex_init(&state->open_mutex);
3092 file->private_data = card;
3094 mutex_lock(&state->open_mutex);
3096 /* set default sample format. According to OSS Programmer's Guide /dev/dsp
3097 should be default to unsigned 8-bits, mono, with sample rate 8kHz and
3098 /dev/dspW will accept 16-bits sample */
3100 /* Default input is 8bit mono */
3101 dmabuf->fmt &= ~CS_FMT_MASK;
3102 dmabuf->type = CS_TYPE_ADC;
3103 dmabuf->ossfragshift = 0;
3104 dmabuf->ossmaxfrags = 0;
3105 dmabuf->subdivision = 0;
3106 cs_set_adc_rate(state, 8000);
3107 cs_set_divisor(dmabuf);
3109 state->open_mode |= FMODE_READ;
3110 mutex_unlock(&state->open_mutex);
3112 if (file->f_mode & FMODE_WRITE) {
3113 CS_DBGOUT(CS_OPEN, 2, printk("cs46xx: cs_open() FMODE_WRITE\n") );
3114 if (card->states[1] == NULL) {
3115 state = card->states[1] =
3116 kzalloc(sizeof(struct cs_state), GFP_KERNEL);
3119 mutex_init(&state->sem);
3120 dmabuf = &state->dmabuf;
3121 dmabuf->pbuf = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
3122 if (dmabuf->pbuf == NULL) {
3124 card->states[1] = NULL;
3128 state = card->states[1];
3129 if (state->open_mode & FMODE_WRITE)
3132 dmabuf->channel = card->alloc_pcm_channel(card);
3134 if (dmabuf->channel == NULL) {
3135 kfree(card->states[1]);
3136 card->states[1] = NULL;
3140 /* Now turn on external AMP if needed */
3142 state->card->active_ctrl(state->card, 1);
3143 state->card->amplifier_ctrl(state->card, 1);
3145 if ((tmp = cs46xx_powerup(card, CS_POWER_DAC))) {
3146 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3147 "cs46xx: cs46xx_powerup of DAC failed (0x%x)\n", tmp));
3151 dmabuf->channel->state = state;
3152 /* initialize the virtual channel */
3154 state->magic = CS_STATE_MAGIC;
3155 init_waitqueue_head(&dmabuf->wait);
3156 mutex_init(&state->open_mutex);
3157 file->private_data = card;
3159 mutex_lock(&state->open_mutex);
3161 /* set default sample format. According to OSS Programmer's Guide /dev/dsp
3162 should be default to unsigned 8-bits, mono, with sample rate 8kHz and
3163 /dev/dspW will accept 16-bits sample */
3165 /* Default output is 8bit mono. */
3166 dmabuf->fmt &= ~CS_FMT_MASK;
3167 dmabuf->type = CS_TYPE_DAC;
3168 dmabuf->ossfragshift = 0;
3169 dmabuf->ossmaxfrags = 0;
3170 dmabuf->subdivision = 0;
3171 cs_set_dac_rate(state, 8000);
3172 cs_set_divisor(dmabuf);
3174 state->open_mode |= FMODE_WRITE;
3175 mutex_unlock(&state->open_mutex);
3176 if ((ret = prog_dmabuf(state)))
3179 CS_DBGOUT(CS_OPEN | CS_FUNCTION, 2, printk("cs46xx: cs_open()- 0\n"));
3180 return nonseekable_open(inode, file);
3183 static int cs_release(struct inode *inode, struct file *file)
3185 struct cs_card *card = file->private_data;
3186 struct dmabuf *dmabuf;
3187 struct cs_state *state;
3189 CS_DBGOUT(CS_RELEASE | CS_FUNCTION, 2, printk("cs46xx: cs_release()+ file=%p %s %s\n",
3190 file, file->f_mode & FMODE_WRITE ? "FMODE_WRITE" : "",
3191 file->f_mode & FMODE_READ ? "FMODE_READ" : ""));
3193 if (!(file->f_mode & (FMODE_WRITE | FMODE_READ)))
3195 state = card->states[1];
3197 if ((state->open_mode & FMODE_WRITE) & (file->f_mode & FMODE_WRITE)) {
3198 CS_DBGOUT(CS_RELEASE, 2, printk("cs46xx: cs_release() FMODE_WRITE\n"));
3199 dmabuf = &state->dmabuf;
3200 cs_clear_tail(state);
3201 drain_dac(state, file->f_flags & O_NONBLOCK);
3202 /* stop DMA state machine and free DMA buffers/channels */
3203 mutex_lock(&state->open_mutex);
3205 dealloc_dmabuf(state);
3206 state->card->free_pcm_channel(state->card, dmabuf->channel->num);
3207 free_page((unsigned long)state->dmabuf.pbuf);
3209 /* we're covered by the open_mutex */
3210 mutex_unlock(&state->open_mutex);
3211 state->card->states[state->virt] = NULL;
3212 state->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
3214 if ((tmp = cs461x_powerdown(card, CS_POWER_DAC, CS_FALSE))) {
3215 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
3216 "cs46xx: cs_release_mixdev() powerdown DAC failure (0x%x)\n",tmp) );
3219 /* Now turn off external AMP if needed */
3220 state->card->amplifier_ctrl(state->card, -1);
3221 state->card->active_ctrl(state->card, -1);
3226 state = card->states[0];
3228 if ((state->open_mode & FMODE_READ) & (file->f_mode & FMODE_READ)) {
3229 CS_DBGOUT(CS_RELEASE, 2, printk("cs46xx: cs_release() FMODE_READ\n"));
3230 dmabuf = &state->dmabuf;
3231 mutex_lock(&state->open_mutex);
3233 dealloc_dmabuf(state);
3234 state->card->free_pcm_channel(state->card, dmabuf->channel->num);
3235 free_page((unsigned long)state->dmabuf.pbuf);
3237 /* we're covered by the open_mutex */
3238 mutex_unlock(&state->open_mutex);
3239 state->card->states[state->virt] = NULL;
3240 state->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
3242 if ((tmp = cs461x_powerdown(card, CS_POWER_ADC, CS_FALSE))) {
3243 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
3244 "cs46xx: cs_release_mixdev() powerdown ADC failure (0x%x)\n",tmp) );
3247 /* Now turn off external AMP if needed */
3248 state->card->amplifier_ctrl(state->card, -1);
3249 state->card->active_ctrl(state->card, -1);
3254 CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 2, printk("cs46xx: cs_release()- 0\n"));
3258 static void printpm(struct cs_card *s)
3260 CS_DBGOUT(CS_PM, 9, printk("pm struct:\n"));
3261 CS_DBGOUT(CS_PM, 9, printk("flags:0x%x u32CLKCR1_SAVE: 0%x u32SSPMValue: 0x%x\n",
3262 (unsigned)s->pm.flags,s->pm.u32CLKCR1_SAVE,s->pm.u32SSPMValue));
3263 CS_DBGOUT(CS_PM, 9, printk("u32PPLVCvalue: 0x%x u32PPRVCvalue: 0x%x\n",
3264 s->pm.u32PPLVCvalue,s->pm.u32PPRVCvalue));
3265 CS_DBGOUT(CS_PM, 9, printk("u32FMLVCvalue: 0x%x u32FMRVCvalue: 0x%x\n",
3266 s->pm.u32FMLVCvalue,s->pm.u32FMRVCvalue));
3267 CS_DBGOUT(CS_PM, 9, printk("u32GPIORvalue: 0x%x u32JSCTLvalue: 0x%x\n",
3268 s->pm.u32GPIORvalue,s->pm.u32JSCTLvalue));
3269 CS_DBGOUT(CS_PM, 9, printk("u32SSCR: 0x%x u32SRCSA: 0x%x\n",
3270 s->pm.u32SSCR,s->pm.u32SRCSA));
3271 CS_DBGOUT(CS_PM, 9, printk("u32DacASR: 0x%x u32AdcASR: 0x%x\n",
3272 s->pm.u32DacASR,s->pm.u32AdcASR));
3273 CS_DBGOUT(CS_PM, 9, printk("u32DacSR: 0x%x u32AdcSR: 0x%x\n",
3274 s->pm.u32DacSR,s->pm.u32AdcSR));
3275 CS_DBGOUT(CS_PM, 9, printk("u32MIDCR_Save: 0x%x\n",
3276 s->pm.u32MIDCR_Save));
3277 CS_DBGOUT(CS_PM, 9, printk("u32AC97_powerdown: 0x%x _general_purpose 0x%x\n",
3278 s->pm.u32AC97_powerdown,s->pm.u32AC97_general_purpose));
3279 CS_DBGOUT(CS_PM, 9, printk("u32AC97_master_volume: 0x%x\n",
3280 s->pm.u32AC97_master_volume));
3281 CS_DBGOUT(CS_PM, 9, printk("u32AC97_headphone_volume: 0x%x\n",
3282 s->pm.u32AC97_headphone_volume));
3283 CS_DBGOUT(CS_PM, 9, printk("u32AC97_master_volume_mono: 0x%x\n",
3284 s->pm.u32AC97_master_volume_mono));
3285 CS_DBGOUT(CS_PM, 9, printk("u32AC97_pcm_out_volume: 0x%x\n",
3286 s->pm.u32AC97_pcm_out_volume));
3287 CS_DBGOUT(CS_PM, 9, printk("dmabuf_swptr_play: 0x%x dmabuf_count_play: %d\n",
3288 s->pm.dmabuf_swptr_play,s->pm.dmabuf_count_play));
3289 CS_DBGOUT(CS_PM, 9, printk("dmabuf_swptr_capture: 0x%x dmabuf_count_capture: %d\n",
3290 s->pm.dmabuf_swptr_capture,s->pm.dmabuf_count_capture));
3294 /****************************************************************************
3296 * Suspend - save the ac97 regs, mute the outputs and power down the part.
3298 ****************************************************************************/
3299 static void cs46xx_ac97_suspend(struct cs_card *card)
3302 struct ac97_codec *dev=card->ac97_codec[0];
3305 CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_suspend()+\n"));
3307 if (card->states[1]) {
3308 stop_dac(card->states[1]);
3309 resync_dma_ptrs(card->states[1]);
3311 if (card->states[0]) {
3312 stop_adc(card->states[0]);
3313 resync_dma_ptrs(card->states[0]);
3316 for (Count = 0x2, i = 0; (Count <= CS46XX_AC97_HIGHESTREGTORESTORE)
3317 && (i < CS46XX_AC97_NUMBER_RESTORE_REGS);
3319 card->pm.ac97[i] = cs_ac97_get(dev, BA0_AC97_RESET + Count);
3322 * Save the ac97 volume registers as well as the current powerdown state.
3323 * Now, mute the all the outputs (master, headphone, and mono), as well
3324 * as the PCM volume, in preparation for powering down the entire part.
3325 card->pm.u32AC97_master_volume = (u32)cs_ac97_get( dev,
3326 (u8)BA0_AC97_MASTER_VOLUME);
3327 card->pm.u32AC97_headphone_volume = (u32)cs_ac97_get(dev,
3328 (u8)BA0_AC97_HEADPHONE_VOLUME);
3329 card->pm.u32AC97_master_volume_mono = (u32)cs_ac97_get(dev,
3330 (u8)BA0_AC97_MASTER_VOLUME_MONO);
3331 card->pm.u32AC97_pcm_out_volume = (u32)cs_ac97_get(dev,
3332 (u8)BA0_AC97_PCM_OUT_VOLUME);
3337 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME, 0x8000);
3338 cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, 0x8000);
3339 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, 0x8000);
3340 cs_ac97_set(dev, (u8)BA0_AC97_PCM_OUT_VOLUME, 0x8000);
3343 * save the registers that cause pops
3345 card->pm.u32AC97_powerdown = (u32)cs_ac97_get(dev, (u8)AC97_POWER_CONTROL);
3346 card->pm.u32AC97_general_purpose = (u32)cs_ac97_get(dev, (u8)BA0_AC97_GENERAL_PURPOSE);
3348 * And power down everything on the AC97 codec.
3349 * well, for now, only power down the DAC/ADC and MIXER VREFON components.
3350 * trouble with removing VREF.
3352 if ((tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
3353 CS_POWER_MIXVON, CS_TRUE))) {
3354 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3355 "cs46xx: cs46xx_ac97_suspend() failure (0x%x)\n",tmp));
3358 CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_suspend()-\n"));
3361 /****************************************************************************
3363 * Resume - power up the part and restore its registers..
3365 ****************************************************************************/
3366 static void cs46xx_ac97_resume(struct cs_card *card)
3369 struct ac97_codec *dev=card->ac97_codec[0];
3371 CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_resume()+\n"));
3374 * First, we restore the state of the general purpose register. This
3375 * contains the mic select (mic1 or mic2) and if we restore this after
3376 * we restore the mic volume/boost state and mic2 was selected at
3377 * suspend time, we will end up with a brief period of time where mic1
3378 * is selected with the volume/boost settings for mic2, causing
3379 * acoustic feedback. So we restore the general purpose register
3380 * first, thereby getting the correct mic selected before we restore
3381 * the mic volume/boost.
3383 cs_ac97_set(dev, (u8)BA0_AC97_GENERAL_PURPOSE,
3384 (u16)card->pm.u32AC97_general_purpose);
3386 * Now, while the outputs are still muted, restore the state of power
3389 cs_ac97_set(dev, (u8)BA0_AC97_POWERDOWN, (u16)card->pm.u32AC97_powerdown);
3390 mdelay(5 * cs_laptop_wait);
3392 * Restore just the first set of registers, from register number
3393 * 0x02 to the register number that ulHighestRegToRestore specifies.
3395 for (Count = 0x2, i=0; (Count <= CS46XX_AC97_HIGHESTREGTORESTORE) &&
3396 (i < CS46XX_AC97_NUMBER_RESTORE_REGS); Count += 2, i++) {
3397 cs_ac97_set(dev, (u8)(BA0_AC97_RESET + Count), (u16)card->pm.ac97[i]);
3400 /* Check if we have to init the amplifier */
3402 card->amp_init(card);
3404 CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_resume()-\n"));
3408 static int cs46xx_restart_part(struct cs_card *card)
3410 struct dmabuf *dmabuf;
3412 CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3413 printk( "cs46xx: cs46xx_restart_part()+\n"));
3414 if (card->states[1]) {
3415 dmabuf = &card->states[1]->dmabuf;
3417 resync_dma_ptrs(card->states[1]);
3418 cs_set_divisor(dmabuf);
3419 if (__prog_dmabuf(card->states[1])) {
3420 CS_DBGOUT(CS_PM | CS_ERROR, 1,
3421 printk("cs46xx: cs46xx_restart_part()- (-1) prog_dmabuf() dac error\n"));
3424 cs_set_dac_rate(card->states[1], dmabuf->rate);
3426 if (card->states[0]) {
3427 dmabuf = &card->states[0]->dmabuf;
3429 resync_dma_ptrs(card->states[0]);
3430 cs_set_divisor(dmabuf);
3431 if (__prog_dmabuf(card->states[0])) {
3432 CS_DBGOUT(CS_PM | CS_ERROR, 1,
3433 printk("cs46xx: cs46xx_restart_part()- (-1) prog_dmabuf() adc error\n"));
3436 cs_set_adc_rate(card->states[0], dmabuf->rate);
3438 card->pm.flags |= CS46XX_PM_RESUMED;
3439 if (card->states[0])
3440 start_adc(card->states[0]);
3441 if (card->states[1])
3442 start_dac(card->states[1]);
3444 card->pm.flags |= CS46XX_PM_IDLE;
3445 card->pm.flags &= ~(CS46XX_PM_SUSPENDING | CS46XX_PM_SUSPENDED
3446 | CS46XX_PM_RESUMING | CS46XX_PM_RESUMED);
3447 if (card->states[0])
3448 wake_up(&card->states[0]->dmabuf.wait);
3449 if (card->states[1])
3450 wake_up(&card->states[1]->dmabuf.wait);
3452 CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3453 printk( "cs46xx: cs46xx_restart_part()-\n"));
3457 static void cs461x_reset(struct cs_card *card);
3458 static void cs461x_proc_stop(struct cs_card *card);
3459 static int cs46xx_suspend(struct cs_card *card, pm_message_t state)
3463 CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3464 printk("cs46xx: cs46xx_suspend()+ flags=0x%x s=%p\n",
3465 (unsigned)card->pm.flags,card));
3467 * check the current state, only suspend if IDLE
3469 if (!(card->pm.flags & CS46XX_PM_IDLE)) {
3470 CS_DBGOUT(CS_PM | CS_ERROR, 2,
3471 printk("cs46xx: cs46xx_suspend() unable to suspend, not IDLE\n"));
3474 card->pm.flags &= ~CS46XX_PM_IDLE;
3475 card->pm.flags |= CS46XX_PM_SUSPENDING;
3477 card->active_ctrl(card,1);
3479 tmp = cs461x_peek(card, BA1_PFIE);
3482 cs461x_poke(card, BA1_PFIE, tmp); /* playback interrupt disable */
3484 tmp = cs461x_peek(card, BA1_CIE);
3487 cs461x_poke(card, BA1_CIE, tmp); /* capture interrupt disable */
3490 * Stop playback DMA.
3492 tmp = cs461x_peek(card, BA1_PCTL);
3493 cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
3498 tmp = cs461x_peek(card, BA1_CCTL);
3499 cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
3501 if (card->states[1]) {
3502 card->pm.dmabuf_swptr_play = card->states[1]->dmabuf.swptr;
3503 card->pm.dmabuf_count_play = card->states[1]->dmabuf.count;
3505 if (card->states[0]) {
3506 card->pm.dmabuf_swptr_capture = card->states[0]->dmabuf.swptr;
3507 card->pm.dmabuf_count_capture = card->states[0]->dmabuf.count;
3510 cs46xx_ac97_suspend(card);
3513 * Reset the processor.
3517 cs461x_proc_stop(card);
3520 * Power down the DAC and ADC. For now leave the other areas on.
3522 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, 0x0300);
3525 * Power down the PLL.
3527 cs461x_pokeBA0(card, BA0_CLKCR1, 0);
3530 * Turn off the Processor by turning off the software clock enable flag in
3531 * the clock control register.
3533 tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE;
3534 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
3536 card->active_ctrl(card,-1);
3538 card->pm.flags &= ~CS46XX_PM_SUSPENDING;
3539 card->pm.flags |= CS46XX_PM_SUSPENDED;
3543 CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3544 printk("cs46xx: cs46xx_suspend()- flags=0x%x\n",
3545 (unsigned)card->pm.flags));
3549 static int cs46xx_resume(struct cs_card *card)
3553 CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3554 printk( "cs46xx: cs46xx_resume()+ flags=0x%x\n",
3555 (unsigned)card->pm.flags));
3556 if (!(card->pm.flags & CS46XX_PM_SUSPENDED)) {
3557 CS_DBGOUT(CS_PM | CS_ERROR, 2,
3558 printk("cs46xx: cs46xx_resume() unable to resume, not SUSPENDED\n"));
3561 card->pm.flags |= CS46XX_PM_RESUMING;
3562 card->pm.flags &= ~CS46XX_PM_SUSPENDED;
3564 card->active_ctrl(card, 1);
3566 for (i = 0; i < 5; i++) {
3567 if (cs_hardware_init(card) != 0) {
3568 CS_DBGOUT(CS_PM | CS_ERROR, 4, printk(
3569 "cs46xx: cs46xx_resume()- ERROR in cs_hardware_init()\n"));
3570 mdelay(10 * cs_laptop_wait);
3577 CS_DBGOUT(CS_PM | CS_ERROR, 1, printk(
3578 "cs46xx: cs46xx_resume()- cs_hardware_init() failed, retried %d times.\n",i));
3582 if (cs46xx_restart_part(card)) {
3583 CS_DBGOUT(CS_PM | CS_ERROR, 4, printk(
3584 "cs46xx: cs46xx_resume(): cs46xx_restart_part() returned error\n"));
3587 card->active_ctrl(card, -1);
3589 CS_DBGOUT(CS_PM | CS_FUNCTION, 4, printk("cs46xx: cs46xx_resume()- flags=0x%x\n",
3590 (unsigned)card->pm.flags));
3594 static /*const*/ struct file_operations cs461x_fops = {
3595 CS_OWNER CS_THIS_MODULE
3596 .llseek = no_llseek,
3603 .release = cs_release,
3606 /* Write AC97 codec registers */
3609 static u16 _cs_ac97_get(struct ac97_codec *dev, u8 reg)
3611 struct cs_card *card = dev->private_data;
3617 * 1. Write ACCAD = Command Address Register = 46Ch for AC97 register address
3618 * 2. Write ACCDA = Command Data Register = 470h for data to write to AC97
3619 * 3. Write ACCTL = Control Register = 460h for initiating the write
3620 * 4. Read ACCTL = 460h, DCV should be reset by now and 460h = 17h
3621 * 5. if DCV not cleared, break and return error
3622 * 6. Read ACSTS = Status Register = 464h, check VSTS bit
3625 cs461x_peekBA0(card, BA0_ACSDA);
3628 * Setup the AC97 control registers on the CS461x to send the
3629 * appropriate command to the AC97 to perform the read.
3630 * ACCAD = Command Address Register = 46Ch
3631 * ACCDA = Command Data Register = 470h
3632 * ACCTL = Control Register = 460h
3633 * set DCV - will clear when process completed
3634 * set CRW - Read command
3635 * set VFRM - valid frame enabled
3636 * set ESYN - ASYNC generation enabled
3637 * set RSTN - ARST# inactive, AC97 codec not reset
3640 cs461x_pokeBA0(card, BA0_ACCAD, reg);
3641 cs461x_pokeBA0(card, BA0_ACCDA, 0);
3642 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_DCV | ACCTL_CRW |
3643 ACCTL_VFRM | ACCTL_ESYN |
3648 * Wait for the read to occur.
3650 if (!(card->pm.flags & CS46XX_PM_IDLE))
3653 loopcnt = 500 * cs_laptop_wait;
3654 loopcnt *= cs_laptop_wait;
3655 for (count = 0; count < loopcnt; count++) {
3657 * First, we want to wait for a short time.
3659 udelay(10 * cs_laptop_wait);
3661 * Now, check to see if the read has completed.
3662 * ACCTL = 460h, DCV should be reset by now and 460h = 17h
3664 if (!(cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV))
3669 * Make sure the read completed.
3671 if (cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV) {
3672 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
3673 "cs46xx: AC'97 read problem (ACCTL_DCV), reg = 0x%x returning 0xffff\n", reg));
3678 * Wait for the valid status bit to go active.
3681 if (!(card->pm.flags & CS46XX_PM_IDLE))
3685 loopcnt *= cs_laptop_wait;
3686 for (count = 0; count < loopcnt; count++) {
3688 * Read the AC97 status register.
3689 * ACSTS = Status Register = 464h
3690 * VSTS - Valid Status
3692 if (cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_VSTS)
3694 udelay(10 * cs_laptop_wait);
3698 * Make sure we got valid status.
3700 if (!((tmp = cs461x_peekBA0(card, BA0_ACSTS)) & ACSTS_VSTS)) {
3701 CS_DBGOUT(CS_ERROR, 2, printk(KERN_WARNING
3702 "cs46xx: AC'97 read problem (ACSTS_VSTS), reg = 0x%x val=0x%x 0xffff \n",
3708 * Read the data returned from the AC97 register.
3709 * ACSDA = Status Data Register = 474h
3711 CS_DBGOUT(CS_FUNCTION, 9, printk(KERN_INFO
3712 "cs46xx: cs_ac97_get() reg = 0x%x, val = 0x%x, BA0_ACCAD = 0x%x\n",
3713 reg, cs461x_peekBA0(card, BA0_ACSDA),
3714 cs461x_peekBA0(card, BA0_ACCAD)));
3715 ret = cs461x_peekBA0(card, BA0_ACSDA);
3719 static u16 cs_ac97_get(struct ac97_codec *dev, u8 reg)
3722 struct cs_card *card = dev->private_data;
3724 spin_lock(&card->ac97_lock);
3725 ret = _cs_ac97_get(dev, reg);
3726 spin_unlock(&card->ac97_lock);
3730 static void cs_ac97_set(struct ac97_codec *dev, u8 reg, u16 val)
3732 struct cs_card *card = dev->private_data;
3736 spin_lock(&card->ac97_lock);
3738 if (reg == AC97_CD_VOL)
3739 val2 = _cs_ac97_get(dev, AC97_CD_VOL);
3742 * 1. Write ACCAD = Command Address Register = 46Ch for AC97 register address
3743 * 2. Write ACCDA = Command Data Register = 470h for data to write to AC97
3744 * 3. Write ACCTL = Control Register = 460h for initiating the write
3745 * 4. Read ACCTL = 460h, DCV should be reset by now and 460h = 07h
3746 * 5. if DCV not cleared, break and return error
3750 * Setup the AC97 control registers on the CS461x to send the
3751 * appropriate command to the AC97 to perform the read.
3752 * ACCAD = Command Address Register = 46Ch
3753 * ACCDA = Command Data Register = 470h
3754 * ACCTL = Control Register = 460h
3755 * set DCV - will clear when process completed
3756 * reset CRW - Write command
3757 * set VFRM - valid frame enabled
3758 * set ESYN - ASYNC generation enabled
3759 * set RSTN - ARST# inactive, AC97 codec not reset
3761 cs461x_pokeBA0(card, BA0_ACCAD, reg);
3762 cs461x_pokeBA0(card, BA0_ACCDA, val);
3763 cs461x_peekBA0(card, BA0_ACCTL);
3764 cs461x_pokeBA0(card, BA0_ACCTL, 0 | ACCTL_VFRM | ACCTL_ESYN | ACCTL_RSTN);
3765 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_DCV | ACCTL_VFRM |
3766 ACCTL_ESYN | ACCTL_RSTN);
3767 for (count = 0; count < 1000; count++) {
3769 * First, we want to wait for a short time.
3771 udelay(10 * cs_laptop_wait);
3773 * Now, check to see if the write has completed.
3774 * ACCTL = 460h, DCV should be reset by now and 460h = 07h
3776 if (!(cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV))
3780 * Make sure the write completed.
3782 if (cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV) {
3783 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
3784 "cs46xx: AC'97 write problem, reg = 0x%x, val = 0x%x\n", reg, val));
3787 spin_unlock(&card->ac97_lock);
3790 * Adjust power if the mixer is selected/deselected according
3793 * IF the CD is a valid input source (mixer or direct) AND
3794 * the CD is not muted THEN power is needed
3796 * We do two things. When record select changes the input to
3797 * add/remove the CD we adjust the power count if the CD is
3800 * When the CD mute changes we adjust the power level if the
3801 * CD was a valid input.
3803 * We also check for CD volume != 0, as the CD mute isn't
3804 * normally tweaked from userspace.
3807 /* CD mute change ? */
3809 if (reg == AC97_CD_VOL) {
3810 /* Mute bit change ? */
3811 if ((val2^val) & 0x8000 ||
3812 ((val2 == 0x1f1f || val == 0x1f1f) && val2 != val)) {
3813 /* This is a hack but its cleaner than the alternatives.
3814 Right now card->ac97_codec[0] might be NULL as we are
3815 still doing codec setup. This does an early assignment
3816 to avoid the problem if it occurs */
3818 if (card->ac97_codec[0] == NULL)
3819 card->ac97_codec[0] = dev;
3822 if (val & 0x8000 || val == 0x1f1f)
3823 card->amplifier_ctrl(card, -1);
3824 else { /* Mute off power on */
3826 card->amp_init(card);
3827 card->amplifier_ctrl(card, 1);
3833 /* OSS /dev/mixer file operation methods */
3835 static int cs_open_mixdev(struct inode *inode, struct file *file)
3838 unsigned int minor = iminor(inode);
3839 struct cs_card *card = NULL;
3840 struct list_head *entry;
3843 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4,
3844 printk(KERN_INFO "cs46xx: cs_open_mixdev()+\n"));
3846 list_for_each(entry, &cs46xx_devs) {
3847 card = list_entry(entry, struct cs_card, list);
3848 for (i = 0; i < NR_AC97; i++)
3849 if (card->ac97_codec[i] != NULL &&
3850 card->ac97_codec[i]->dev_mixer == minor)
3854 CS_DBGOUT(CS_FUNCTION | CS_OPEN | CS_ERROR, 2,
3855 printk(KERN_INFO "cs46xx: cs46xx_open_mixdev()- -ENODEV\n"));
3859 if (!card->ac97_codec[i])
3861 file->private_data = card->ac97_codec[i];
3863 card->active_ctrl(card,1);
3864 if (!CS_IN_USE(&card->mixer_use_cnt)) {
3865 if ((tmp = cs46xx_powerup(card, CS_POWER_MIXVON))) {
3866 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3867 "cs46xx: cs_open_mixdev() powerup failure (0x%x)\n", tmp));
3871 card->amplifier_ctrl(card, 1);
3872 CS_INC_USE_COUNT(&card->mixer_use_cnt);
3873 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4,
3874 printk(KERN_INFO "cs46xx: cs_open_mixdev()- 0\n"));
3875 return nonseekable_open(inode, file);
3878 static int cs_release_mixdev(struct inode *inode, struct file *file)
3880 unsigned int minor = iminor(inode);
3881 struct cs_card *card = NULL;
3882 struct list_head *entry;
3886 CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 4,
3887 printk(KERN_INFO "cs46xx: cs_release_mixdev()+\n"));
3888 list_for_each(entry, &cs46xx_devs)
3890 card = list_entry(entry, struct cs_card, list);
3891 for (i = 0; i < NR_AC97; i++)
3892 if (card->ac97_codec[i] != NULL &&
3893 card->ac97_codec[i]->dev_mixer == minor)
3897 CS_DBGOUT(CS_FUNCTION | CS_OPEN | CS_ERROR, 2,
3898 printk(KERN_INFO "cs46xx: cs46xx_open_mixdev()- -ENODEV\n"));
3902 if (!CS_DEC_AND_TEST(&card->mixer_use_cnt)) {
3903 CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 4,
3904 printk(KERN_INFO "cs46xx: cs_release_mixdev()- no powerdown, usecnt>0\n"));
3905 card->active_ctrl(card, -1);
3906 card->amplifier_ctrl(card, -1);
3910 * ok, no outstanding mixer opens, so powerdown.
3912 if ((tmp = cs461x_powerdown(card, CS_POWER_MIXVON, CS_FALSE))) {
3913 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3914 "cs46xx: cs_release_mixdev() powerdown MIXVON failure (0x%x)\n", tmp));
3915 card->active_ctrl(card, -1);
3916 card->amplifier_ctrl(card, -1);
3919 card->active_ctrl(card, -1);
3920 card->amplifier_ctrl(card, -1);
3921 CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 4,
3922 printk(KERN_INFO "cs46xx: cs_release_mixdev()- 0\n"));
3926 static int cs_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd,
3929 struct ac97_codec *codec = file->private_data;
3930 struct cs_card *card = NULL;
3931 struct list_head *entry;
3932 unsigned long __user *p = (long __user *)arg;
3933 #if CSDEBUG_INTERFACE
3936 if ( (cmd == SOUND_MIXER_CS_GETDBGMASK) ||
3937 (cmd == SOUND_MIXER_CS_SETDBGMASK) ||
3938 (cmd == SOUND_MIXER_CS_GETDBGLEVEL) ||
3939 (cmd == SOUND_MIXER_CS_SETDBGLEVEL) ||
3940 (cmd == SOUND_MIXER_CS_APM)) {
3942 case SOUND_MIXER_CS_GETDBGMASK:
3943 return put_user(cs_debugmask, p);
3944 case SOUND_MIXER_CS_GETDBGLEVEL:
3945 return put_user(cs_debuglevel, p);
3946 case SOUND_MIXER_CS_SETDBGMASK:
3947 if (get_user(val, p))
3951 case SOUND_MIXER_CS_SETDBGLEVEL:
3952 if (get_user(val, p))
3954 cs_debuglevel = val;
3956 case SOUND_MIXER_CS_APM:
3957 if (get_user(val, p))
3959 if (val == CS_IOCTL_CMD_SUSPEND) {
3960 list_for_each(entry, &cs46xx_devs) {
3961 card = list_entry(entry, struct cs_card, list);
3962 cs46xx_suspend(card, PMSG_ON);
3965 } else if (val == CS_IOCTL_CMD_RESUME) {
3966 list_for_each(entry, &cs46xx_devs) {
3967 card = list_entry(entry, struct cs_card, list);
3968 cs46xx_resume(card);
3971 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
3972 "cs46xx: mixer_ioctl(): invalid APM cmd (%d)\n",
3977 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
3978 "cs46xx: mixer_ioctl(): ERROR unknown debug cmd\n"));
3983 return codec->mixer_ioctl(codec, cmd, arg);
3986 static /*const*/ struct file_operations cs_mixer_fops = {
3987 CS_OWNER CS_THIS_MODULE
3988 .llseek = no_llseek,
3989 .ioctl = cs_ioctl_mixdev,
3990 .open = cs_open_mixdev,
3991 .release = cs_release_mixdev,
3994 /* AC97 codec initialisation. */
3995 static int __init cs_ac97_init(struct cs_card *card)
3999 struct ac97_codec *codec;
4002 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4003 "cs46xx: cs_ac97_init()+\n") );
4005 for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
4006 if ((codec = ac97_alloc_codec()) == NULL)
4009 /* initialize some basic codec information, other fields will be filled
4010 in ac97_probe_codec */
4011 codec->private_data = card;
4012 codec->id = num_ac97;
4014 codec->codec_read = cs_ac97_get;
4015 codec->codec_write = cs_ac97_set;
4017 if (ac97_probe_codec(codec) == 0) {
4018 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4019 "cs46xx: cs_ac97_init()- codec number %d not found\n",
4021 card->ac97_codec[num_ac97] = NULL;
4024 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4025 "cs46xx: cs_ac97_init() found codec %d\n",num_ac97));
4027 eid = cs_ac97_get(codec, AC97_EXTENDED_ID);
4029 if (eid == 0xFFFF) {
4030 printk(KERN_WARNING "cs46xx: codec %d not present\n",num_ac97);
4031 ac97_release_codec(codec);
4035 card->ac97_features = eid;
4037 if ((codec->dev_mixer = register_sound_mixer(&cs_mixer_fops, -1)) < 0) {
4038 printk(KERN_ERR "cs46xx: couldn't register mixer!\n");
4039 ac97_release_codec(codec);
4042 card->ac97_codec[num_ac97] = codec;
4044 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4045 "cs46xx: cs_ac97_init() ac97_codec[%d] set to %p\n",
4046 (unsigned int)num_ac97,
4048 /* if there is no secondary codec at all, don't probe any more */
4055 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4056 "cs46xx: cs_ac97_init()- %d\n", (unsigned int)num_ac97));
4061 * load the static image into the DSP
4063 #include "cs461x_image.h"
4064 static void cs461x_download_image(struct cs_card *card)
4066 unsigned i, j, temp1, temp2, offset, count;
4067 unsigned char __iomem *pBA1 = ioremap(card->ba1_addr, 0x40000);
4068 for (i = 0; i < CLEAR__COUNT; i++) {
4069 offset = ClrStat[i].BA1__DestByteOffset;
4070 count = ClrStat[i].BA1__SourceSize;
4071 for (temp1 = offset; temp1 < (offset + count); temp1 += 4)
4072 writel(0, pBA1+temp1);
4075 for (i = 0; i < FILL__COUNT; i++) {
4076 temp2 = FillStat[i].Offset;
4077 for (j = 0; j < (FillStat[i].Size) / 4; j++) {
4078 temp1 = (FillStat[i]).pFill[j];
4079 writel(temp1, pBA1+temp2 + j * 4);
4089 static void cs461x_reset(struct cs_card *card)
4094 * Write the reset bit of the SP control register.
4096 cs461x_poke(card, BA1_SPCR, SPCR_RSTSP);
4099 * Write the control register.
4101 cs461x_poke(card, BA1_SPCR, SPCR_DRQEN);
4104 * Clear the trap registers.
4106 for (idx = 0; idx < 8; idx++) {
4107 cs461x_poke(card, BA1_DREG, DREG_REGID_TRAP_SELECT + idx);
4108 cs461x_poke(card, BA1_TWPR, 0xFFFF);
4110 cs461x_poke(card, BA1_DREG, 0);
4113 * Set the frame timer to reflect the number of cycles per frame.
4115 cs461x_poke(card, BA1_FRMT, 0xadf);
4118 static void cs461x_clear_serial_FIFOs(struct cs_card *card, int type)
4120 int idx, loop, startfifo=0, endfifo=0, powerdown1 = 0;
4124 * See if the devices are powered down. If so, we must power them up first
4125 * or they will not respond.
4127 if (!((tmp = cs461x_peekBA0(card, BA0_CLKCR1)) & CLKCR1_SWCE)) {
4128 cs461x_pokeBA0(card, BA0_CLKCR1, tmp | CLKCR1_SWCE);
4133 * We want to clear out the serial port FIFOs so we don't end up playing
4134 * whatever random garbage happens to be in them. We fill the sample FIFOS
4135 * with zero (silence).
4137 cs461x_pokeBA0(card, BA0_SERBWP, 0);
4140 * Check for which FIFO locations to clear, if we are currently
4141 * playing or capturing then we don't want to put in 128 bytes of
4144 if (type & CS_TYPE_DAC) {
4148 if (type & CS_TYPE_ADC) {
4154 * Fill sample FIFO locations (256 locations total).
4156 for (idx = startfifo; idx < endfifo; idx++) {
4158 * Make sure the previous FIFO write operation has completed.
4160 for (loop = 0; loop < 5; loop++) {
4162 if (!(cs461x_peekBA0(card, BA0_SERBST) & SERBST_WBSY))
4165 if (cs461x_peekBA0(card, BA0_SERBST) & SERBST_WBSY) {
4167 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
4170 * Write the serial port FIFO index.
4172 cs461x_pokeBA0(card, BA0_SERBAD, idx);
4174 * Tell the serial port to load the new value into the FIFO location.
4176 cs461x_pokeBA0(card, BA0_SERBCM, SERBCM_WRC);
4179 * Now, if we powered up the devices, then power them back down again.
4180 * This is kinda ugly, but should never happen.
4183 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
4187 static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspendflag)
4190 unsigned int tmp=0,muted=0;
4192 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO
4193 "cs46xx: cs461x_powerdown()+ type=0x%x\n",type));
4194 if (!cs_powerdown && !suspendflag) {
4195 CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4196 "cs46xx: cs461x_powerdown() DISABLED exiting\n"));
4199 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4200 CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4201 "cs46xx: cs461x_powerdown() powerdown reg=0x%x\n",tmp));
4203 * if powering down only the VREF, and not powering down the DAC/ADC,
4204 * then do not power down the VREF, UNLESS both the DAC and ADC are not
4205 * currently powered down. If powering down DAC and ADC, then
4206 * it is possible to power down the VREF (ON).
4208 if (((type & CS_POWER_MIXVON) &&
4209 (!(type & CS_POWER_ADC) || (!(type & CS_POWER_DAC))))
4211 ((tmp & CS_AC97_POWER_CONTROL_ADC_ON) ||
4212 (tmp & CS_AC97_POWER_CONTROL_DAC_ON))) {
4213 CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4214 "cs46xx: cs461x_powerdown()- 0 unable to powerdown. tmp=0x%x\n",tmp));
4218 * for now, always keep power to the mixer block.
4219 * not sure why it's a problem but it seems to be if we power off.
4221 type &= ~CS_POWER_MIXVON;
4222 type &= ~CS_POWER_MIXVOFF;
4225 * Power down indicated areas.
4227 if (type & CS_POWER_MIXVOFF) {
4229 CS_DBGOUT(CS_FUNCTION, 4,
4230 printk(KERN_INFO "cs46xx: cs461x_powerdown()+ MIXVOFF\n"));
4232 * Power down the MIXER (VREF ON) on the AC97 card.
4234 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4235 if (tmp & CS_AC97_POWER_CONTROL_MIXVOFF_ON) {
4237 cs_mute(card, CS_TRUE);
4240 tmp |= CS_AC97_POWER_CONTROL_MIXVOFF;
4241 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4243 * Now, we wait until we sample a ready state.
4245 for (count = 0; count < 32; count++) {
4247 * First, lets wait a short while to let things settle out a
4248 * bit, and to prevent retrying the read too quickly.
4253 * Read the current state of the power control register.
4255 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4256 CS_AC97_POWER_CONTROL_MIXVOFF_ON))
4261 * Check the status..
4263 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4264 CS_AC97_POWER_CONTROL_MIXVOFF_ON) {
4265 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4266 "cs46xx: powerdown MIXVOFF failed\n"));
4271 if (type & CS_POWER_MIXVON) {
4273 CS_DBGOUT(CS_FUNCTION, 4,
4274 printk(KERN_INFO "cs46xx: cs461x_powerdown()+ MIXVON\n"));
4276 * Power down the MIXER (VREF ON) on the AC97 card.
4278 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4279 if (tmp & CS_AC97_POWER_CONTROL_MIXVON_ON) {
4281 cs_mute(card, CS_TRUE);
4284 tmp |= CS_AC97_POWER_CONTROL_MIXVON;
4285 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp);
4287 * Now, we wait until we sample a ready state.
4289 for (count = 0; count < 32; count++) {
4291 * First, lets wait a short while to let things settle out a
4292 * bit, and to prevent retrying the read too quickly.
4297 * Read the current state of the power control register.
4299 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4300 CS_AC97_POWER_CONTROL_MIXVON_ON))
4305 * Check the status..
4307 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4308 CS_AC97_POWER_CONTROL_MIXVON_ON) {
4309 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4310 "cs46xx: powerdown MIXVON failed\n"));
4315 if (type & CS_POWER_ADC) {
4317 * Power down the ADC on the AC97 card.
4319 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO "cs46xx: cs461x_powerdown()+ ADC\n"));
4320 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4321 if (tmp & CS_AC97_POWER_CONTROL_ADC_ON) {
4323 cs_mute(card, CS_TRUE);
4326 tmp |= CS_AC97_POWER_CONTROL_ADC;
4327 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp);
4330 * Now, we wait until we sample a ready state.
4332 for (count = 0; count < 32; count++) {
4334 * First, lets wait a short while to let things settle out a
4335 * bit, and to prevent retrying the read too quickly.
4340 * Read the current state of the power control register.
4342 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4343 CS_AC97_POWER_CONTROL_ADC_ON))
4348 * Check the status..
4350 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4351 CS_AC97_POWER_CONTROL_ADC_ON) {
4352 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4353 "cs46xx: powerdown ADC failed\n"));
4358 if (type & CS_POWER_DAC) {
4360 * Power down the DAC on the AC97 card.
4363 CS_DBGOUT(CS_FUNCTION, 4,
4364 printk(KERN_INFO "cs46xx: cs461x_powerdown()+ DAC\n"));
4365 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4366 if (tmp & CS_AC97_POWER_CONTROL_DAC_ON) {
4368 cs_mute(card, CS_TRUE);
4371 tmp |= CS_AC97_POWER_CONTROL_DAC;
4372 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp);
4374 * Now, we wait until we sample a ready state.
4376 for (count = 0; count < 32; count++) {
4378 * First, lets wait a short while to let things settle out a
4379 * bit, and to prevent retrying the read too quickly.
4384 * Read the current state of the power control register.
4386 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4387 CS_AC97_POWER_CONTROL_DAC_ON))
4392 * Check the status..
4394 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4395 CS_AC97_POWER_CONTROL_DAC_ON) {
4396 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4397 "cs46xx: powerdown DAC failed\n"));
4402 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4404 cs_mute(card, CS_FALSE);
4405 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO
4406 "cs46xx: cs461x_powerdown()- 0 tmp=0x%x\n",tmp));
4410 static int cs46xx_powerup(struct cs_card *card, unsigned int type)
4413 unsigned int tmp = 0, muted = 0;
4415 CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4416 "cs46xx: cs46xx_powerup()+ type=0x%x\n",type));
4418 * check for VREF and powerup if need to.
4420 if (type & CS_POWER_MIXVON)
4421 type |= CS_POWER_MIXVOFF;
4422 if (type & (CS_POWER_DAC | CS_POWER_ADC))
4423 type |= CS_POWER_MIXVON | CS_POWER_MIXVOFF;
4426 * Power up indicated areas.
4428 if (type & CS_POWER_MIXVOFF) {
4430 CS_DBGOUT(CS_FUNCTION, 4,
4431 printk(KERN_INFO "cs46xx: cs46xx_powerup()+ MIXVOFF\n"));
4433 * Power up the MIXER (VREF ON) on the AC97 card.
4435 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4436 if (!(tmp & CS_AC97_POWER_CONTROL_MIXVOFF_ON)) {
4438 cs_mute(card, CS_TRUE);
4441 tmp &= ~CS_AC97_POWER_CONTROL_MIXVOFF;
4442 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4444 * Now, we wait until we sample a ready state.
4446 for (count = 0; count < 32; count++) {
4448 * First, lets wait a short while to let things settle out a
4449 * bit, and to prevent retrying the read too quickly.
4454 * Read the current state of the power control register.
4456 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4457 CS_AC97_POWER_CONTROL_MIXVOFF_ON)
4462 * Check the status..
4464 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4465 CS_AC97_POWER_CONTROL_MIXVOFF_ON)) {
4466 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4467 "cs46xx: powerup MIXVOFF failed\n"));
4472 if(type & CS_POWER_MIXVON) {
4474 CS_DBGOUT(CS_FUNCTION, 4,
4475 printk(KERN_INFO "cs46xx: cs46xx_powerup()+ MIXVON\n"));
4477 * Power up the MIXER (VREF ON) on the AC97 card.
4479 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4480 if (!(tmp & CS_AC97_POWER_CONTROL_MIXVON_ON)) {
4482 cs_mute(card, CS_TRUE);
4485 tmp &= ~CS_AC97_POWER_CONTROL_MIXVON;
4486 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4488 * Now, we wait until we sample a ready state.
4490 for (count = 0; count < 32; count++) {
4492 * First, lets wait a short while to let things settle out a
4493 * bit, and to prevent retrying the read too quickly.
4498 * Read the current state of the power control register.
4500 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4501 CS_AC97_POWER_CONTROL_MIXVON_ON)
4506 * Check the status..
4508 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4509 CS_AC97_POWER_CONTROL_MIXVON_ON)) {
4510 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4511 "cs46xx: powerup MIXVON failed\n"));
4516 if (type & CS_POWER_ADC) {
4518 * Power up the ADC on the AC97 card.
4520 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO "cs46xx: cs46xx_powerup()+ ADC\n"));
4521 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4522 if (!(tmp & CS_AC97_POWER_CONTROL_ADC_ON)) {
4524 cs_mute(card, CS_TRUE);
4527 tmp &= ~CS_AC97_POWER_CONTROL_ADC;
4528 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4531 * Now, we wait until we sample a ready state.
4533 for (count = 0; count < 32; count++) {
4535 * First, lets wait a short while to let things settle out a
4536 * bit, and to prevent retrying the read too quickly.
4541 * Read the current state of the power control register.
4543 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4544 CS_AC97_POWER_CONTROL_ADC_ON)
4549 * Check the status..
4551 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4552 CS_AC97_POWER_CONTROL_ADC_ON)) {
4553 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4554 "cs46xx: powerup ADC failed\n"));
4559 if (type & CS_POWER_DAC) {
4561 * Power up the DAC on the AC97 card.
4564 CS_DBGOUT(CS_FUNCTION, 4,
4565 printk(KERN_INFO "cs46xx: cs46xx_powerup()+ DAC\n"));
4566 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4567 if (!(tmp & CS_AC97_POWER_CONTROL_DAC_ON)) {
4569 cs_mute(card, CS_TRUE);
4572 tmp &= ~CS_AC97_POWER_CONTROL_DAC;
4573 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4575 * Now, we wait until we sample a ready state.
4577 for (count = 0; count < 32; count++) {
4579 * First, lets wait a short while to let things settle out a
4580 * bit, and to prevent retrying the read too quickly.
4585 * Read the current state of the power control register.
4587 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4588 CS_AC97_POWER_CONTROL_DAC_ON)
4593 * Check the status..
4595 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4596 CS_AC97_POWER_CONTROL_DAC_ON)) {
4597 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4598 "cs46xx: powerup DAC failed\n"));
4603 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4605 cs_mute(card, CS_FALSE);
4606 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO
4607 "cs46xx: cs46xx_powerup()- 0 tmp=0x%x\n",tmp));
4611 static void cs461x_proc_start(struct cs_card *card)
4616 * Set the frame timer to reflect the number of cycles per frame.
4618 cs461x_poke(card, BA1_FRMT, 0xadf);
4620 * Turn on the run, run at frame, and DMA enable bits in the local copy of
4621 * the SP control register.
4623 cs461x_poke(card, BA1_SPCR, SPCR_RUN | SPCR_RUNFR | SPCR_DRQEN);
4625 * Wait until the run at frame bit resets itself in the SP control
4628 for (cnt = 0; cnt < 25; cnt++) {
4630 if (!(cs461x_peek(card, BA1_SPCR) & SPCR_RUNFR))
4634 if (cs461x_peek(card, BA1_SPCR) & SPCR_RUNFR)
4635 printk(KERN_WARNING "cs46xx: SPCR_RUNFR never reset\n");
4638 static void cs461x_proc_stop(struct cs_card *card)
4641 * Turn off the run, run at frame, and DMA enable bits in the local copy of
4642 * the SP control register.
4644 cs461x_poke(card, BA1_SPCR, 0);
4647 static int cs_hardware_init(struct cs_card *card)
4649 unsigned long end_time;
4650 unsigned int tmp,count;
4652 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4653 "cs46xx: cs_hardware_init()+\n") );
4655 * First, blast the clock control register to zero so that the PLL starts
4656 * out in a known state, and blast the master serial port control register
4657 * to zero so that the serial ports also start out in a known state.
4659 cs461x_pokeBA0(card, BA0_CLKCR1, 0);
4660 cs461x_pokeBA0(card, BA0_SERMC1, 0);
4663 * If we are in AC97 mode, then we must set the part to a host controlled
4664 * AC-link. Otherwise, we won't be able to bring up the link.
4666 cs461x_pokeBA0(card, BA0_SERACC, SERACC_HSP | SERACC_CODEC_TYPE_1_03); /* 1.03 card */
4667 /* cs461x_pokeBA0(card, BA0_SERACC, SERACC_HSP | SERACC_CODEC_TYPE_2_0); */ /* 2.00 card */
4670 * Drive the ARST# pin low for a minimum of 1uS (as defined in the AC97
4671 * spec) and then drive it high. This is done for non AC97 modes since
4672 * there might be logic external to the CS461x that uses the ARST# line
4675 cs461x_pokeBA0(card, BA0_ACCTL, 1);
4677 cs461x_pokeBA0(card, BA0_ACCTL, 0);
4679 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_RSTN);
4682 * The first thing we do here is to enable sync generation. As soon
4683 * as we start receiving bit clock, we'll start producing the SYNC
4686 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_ESYN | ACCTL_RSTN);
4689 * Now wait for a short while to allow the AC97 part to start
4690 * generating bit clock (so we don't try to start the PLL without an
4693 mdelay(5 * cs_laptop_wait); /* 1 should be enough ?? (and pigs might fly) */
4696 * Set the serial port timing configuration, so that
4697 * the clock control circuit gets its clock from the correct place.
4699 cs461x_pokeBA0(card, BA0_SERMC1, SERMC1_PTC_AC97);
4702 * The part seems to not be ready for a while after a resume.
4703 * so, if we are resuming, then wait for 700 mils. Note that 600 mils
4704 * is not enough for some platforms! tested on an IBM Thinkpads and
4707 if (!(card->pm.flags & CS46XX_PM_IDLE))
4710 * Write the selected clock control setup to the hardware. Do not turn on
4711 * SWCE yet (if requested), so that the devices clocked by the output of
4712 * PLL are not clocked until the PLL is stable.
4714 cs461x_pokeBA0(card, BA0_PLLCC, PLLCC_LPF_1050_2780_KHZ | PLLCC_CDR_73_104_MHZ);
4715 cs461x_pokeBA0(card, BA0_PLLM, 0x3a);
4716 cs461x_pokeBA0(card, BA0_CLKCR2, CLKCR2_PDIVS_8);
4721 cs461x_pokeBA0(card, BA0_CLKCR1, CLKCR1_PLLP);
4724 * Wait until the PLL has stabilized.
4726 mdelay(5 * cs_laptop_wait); /* Again 1 should be enough ?? */
4729 * Turn on clocking of the core so that we can setup the serial ports.
4731 tmp = cs461x_peekBA0(card, BA0_CLKCR1) | CLKCR1_SWCE;
4732 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
4735 * Fill the serial port FIFOs with silence.
4737 cs461x_clear_serial_FIFOs(card,CS_TYPE_DAC | CS_TYPE_ADC);
4740 * Set the serial port FIFO pointer to the first sample in the FIFO.
4742 /* cs461x_pokeBA0(card, BA0_SERBSP, 0); */
4745 * Write the serial port configuration to the part. The master
4746 * enable bit is not set until all other values have been written.
4748 cs461x_pokeBA0(card, BA0_SERC1, SERC1_SO1F_AC97 | SERC1_SO1EN);
4749 cs461x_pokeBA0(card, BA0_SERC2, SERC2_SI1F_AC97 | SERC1_SO1EN);
4750 cs461x_pokeBA0(card, BA0_SERMC1, SERMC1_PTC_AC97 | SERMC1_MSPE);
4753 mdelay(5 * cs_laptop_wait); /* Shouldnt be needed ?? */
4756 * If we are resuming under 2.2.x then we cannot schedule a timeout,
4757 * so just spin the CPU.
4759 if (card->pm.flags & CS46XX_PM_IDLE) {
4761 * Wait for the card ready signal from the AC97 card.
4763 end_time = jiffies + 3 * (HZ >> 2);
4766 * Read the AC97 status register to see if we've seen a CODEC READY
4767 * signal from the AC97 card.
4769 if (cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_CRDY)
4771 current->state = TASK_UNINTERRUPTIBLE;
4772 schedule_timeout(1);
4773 } while (time_before(jiffies, end_time));
4775 for (count = 0; count < 100; count++) {
4776 // First, we want to wait for a short time.
4777 udelay(25 * cs_laptop_wait);
4779 if (cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_CRDY)
4785 * Make sure CODEC is READY.
4787 if (!(cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_CRDY)) {
4788 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_WARNING
4789 "cs46xx: create - never read card ready from AC'97\n"));
4790 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_WARNING
4791 "cs46xx: probably not a bug, try using the CS4232 driver,\n"));
4792 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_WARNING
4793 "cs46xx: or turn off any automatic Power Management support in the BIOS.\n"));
4798 * Assert the vaid frame signal so that we can start sending commands
4801 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_VFRM | ACCTL_ESYN | ACCTL_RSTN);
4803 if (card->pm.flags & CS46XX_PM_IDLE) {
4805 * Wait until we've sampled input slots 3 and 4 as valid, meaning that
4806 * the card is pumping ADC data across the AC-link.
4808 end_time = jiffies + 3 * (HZ >> 2);
4811 * Read the input slot valid register and see if input slots 3 and
4814 if ((cs461x_peekBA0(card, BA0_ACISV) & (ACISV_ISV3 | ACISV_ISV4)) == (ACISV_ISV3 | ACISV_ISV4))
4816 current->state = TASK_UNINTERRUPTIBLE;
4817 schedule_timeout(1);
4818 } while (time_before(jiffies, end_time));
4820 for (count = 0; count < 100; count++) {
4821 // First, we want to wait for a short time.
4822 udelay(25 * cs_laptop_wait);
4824 if ((cs461x_peekBA0(card, BA0_ACISV) & (ACISV_ISV3 | ACISV_ISV4)) == (ACISV_ISV3 | ACISV_ISV4))
4829 * Make sure input slots 3 and 4 are valid. If not, then return
4832 if ((cs461x_peekBA0(card, BA0_ACISV) & (ACISV_ISV3 | ACISV_ISV4)) != (ACISV_ISV3 | ACISV_ISV4)) {
4833 printk(KERN_WARNING "cs46xx: create - never read ISV3 & ISV4 from AC'97\n");
4838 * Now, assert valid frame and the slot 3 and 4 valid bits. This will
4839 * commense the transfer of digital audio data to the AC97 card.
4841 cs461x_pokeBA0(card, BA0_ACOSV, ACOSV_SLV3 | ACOSV_SLV4);
4844 * Turn off the Processor by turning off the software clock enable flag in
4845 * the clock control register.
4847 /* tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE; */
4848 /* cs461x_pokeBA0(card, BA0_CLKCR1, tmp); */
4851 * Reset the processor.
4856 * Download the image to the processor.
4859 cs461x_download_image(card);
4862 * Stop playback DMA.
4864 tmp = cs461x_peek(card, BA1_PCTL);
4865 card->pctl = tmp & 0xffff0000;
4866 cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
4871 tmp = cs461x_peek(card, BA1_CCTL);
4872 card->cctl = tmp & 0x0000ffff;
4873 cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
4875 /* initialize AC97 codec and register /dev/mixer */
4876 if (card->pm.flags & CS46XX_PM_IDLE) {
4877 if (cs_ac97_init(card) <= 0) {
4878 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
4879 "cs46xx: cs_ac97_init() failure\n"));
4883 cs46xx_ac97_resume(card);
4886 cs461x_proc_start(card);
4889 * Enable interrupts on the part.
4891 cs461x_pokeBA0(card, BA0_HICR, HICR_IEV | HICR_CHGM);
4893 tmp = cs461x_peek(card, BA1_PFIE);
4895 cs461x_poke(card, BA1_PFIE, tmp); /* playback interrupt enable */
4897 tmp = cs461x_peek(card, BA1_CIE);
4900 cs461x_poke(card, BA1_CIE, tmp); /* capture interrupt enable */
4903 * If IDLE then Power down the part. We will power components up
4904 * when we need them.
4906 if (card->pm.flags & CS46XX_PM_IDLE) {
4907 if (!cs_powerdown) {
4908 if ((tmp = cs46xx_powerup(card, CS_POWER_DAC | CS_POWER_ADC |
4909 CS_POWER_MIXVON))) {
4910 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
4911 "cs46xx: cs461x_powerup() failure (0x%x)\n",tmp) );
4915 if ((tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
4916 CS_POWER_MIXVON, CS_FALSE))) {
4917 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
4918 "cs46xx: cs461x_powerdown() failure (0x%x)\n",tmp) );
4923 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4924 "cs46xx: cs_hardware_init()- 0\n"));
4928 /* install the driver, we do not allocate hardware channel nor DMA buffer now, they are defered
4929 until "ACCESS" time (in prog_dmabuf called by open/read/write/ioctl/mmap) */
4940 void (*amp)(struct cs_card *, int);
4941 void (*amp_init)(struct cs_card *);
4942 void (*active)(struct cs_card *, int);
4945 static struct cs_card_type cards[] = {
4949 .name = "Genius Soundmaker 128 value",
4961 .name = "Mitac MI6020/21",
4967 .name = "Hercules Game Theatre XP",
4968 .amp = amp_hercules,
4973 .name = "Hercules Game Theatre XP",
4974 .amp = amp_hercules,
4979 .name = "Hercules Game Theatre XP",
4980 .amp = amp_hercules,
4985 .name = "Hercules Game Theatre XP",
4986 .amp = amp_hercules,
4991 .name = "Hercules Game Theatre XP",
4992 .amp = amp_hercules,
4997 .name = "Hercules Game Theatre XP",
4998 .amp = amp_hercules,
5003 .name = "Hercules Fortissimo II",
5006 /* Not sure if the 570 needs the clkrun hack */
5008 .vendor = PCI_VENDOR_ID_IBM,
5010 .name = "Thinkpad 570",
5012 .active = clkrun_hack,
5015 .vendor = PCI_VENDOR_ID_IBM,
5017 .name = "Thinkpad 600X/A20/T20",
5019 .active = clkrun_hack,
5022 .vendor = PCI_VENDOR_ID_IBM,
5024 .name = "Thinkpad 600E (unsupported)",
5027 .name = "Card without SSID set",
5032 MODULE_AUTHOR("Alan Cox <alan@redhat.com>, Jaroslav Kysela, <pcaudio@crystal.cirrus.com>");
5033 MODULE_DESCRIPTION("Crystal SoundFusion Audio Support");
5034 MODULE_LICENSE("GPL");
5036 static const char cs46xx_banner[] = KERN_INFO "Crystal 4280/46xx + AC97 Audio, version " CS46XX_MAJOR_VERSION "." CS46XX_MINOR_VERSION "." CS46XX_ARCH ", " __TIME__ " " __DATE__ "\n";
5037 static const char fndmsg[] = KERN_INFO "cs46xx: Found %d audio device(s).\n";
5039 static int __devinit cs46xx_probe(struct pci_dev *pci_dev,
5040 const struct pci_device_id *pciid)
5043 u16 ss_card, ss_vendor;
5044 struct cs_card *card;
5045 dma_addr_t dma_mask;
5046 struct cs_card_type *cp = &cards[0];
5048 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2,
5049 printk(KERN_INFO "cs46xx: probe()+\n"));
5051 dma_mask = 0xffffffff; /* this enables playback and recording */
5052 if (pci_enable_device(pci_dev)) {
5053 CS_DBGOUT(CS_INIT | CS_ERROR, 1, printk(KERN_ERR
5054 "cs46xx: pci_enable_device() failed\n"));
5057 if (!RSRCISMEMORYREGION(pci_dev, 0) ||
5058 !RSRCISMEMORYREGION(pci_dev, 1)) {
5059 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
5060 "cs46xx: probe()- Memory region not assigned\n"));
5063 if (pci_dev->irq == 0) {
5064 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
5065 "cs46xx: probe() IRQ not assigned\n"));
5068 if (!pci_dma_supported(pci_dev, 0xffffffff)) {
5069 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
5070 "cs46xx: probe() architecture does not support 32bit PCI busmaster DMA\n"));
5073 pci_read_config_word(pci_dev, PCI_SUBSYSTEM_VENDOR_ID, &ss_vendor);
5074 pci_read_config_word(pci_dev, PCI_SUBSYSTEM_ID, &ss_card);
5076 if ((card = kzalloc(sizeof(struct cs_card), GFP_KERNEL)) == NULL) {
5077 printk(KERN_ERR "cs46xx: out of memory\n");
5080 card->ba0_addr = RSRCADDRESS(pci_dev, 0);
5081 card->ba1_addr = RSRCADDRESS(pci_dev, 1);
5082 card->pci_dev = pci_dev;
5083 card->irq = pci_dev->irq;
5084 card->magic = CS_CARD_MAGIC;
5085 spin_lock_init(&card->lock);
5086 spin_lock_init(&card->ac97_lock);
5088 pci_set_master(pci_dev);
5090 printk(cs46xx_banner);
5091 printk(KERN_INFO "cs46xx: Card found at 0x%08lx and 0x%08lx, IRQ %d\n",
5092 card->ba0_addr, card->ba1_addr, card->irq);
5094 card->alloc_pcm_channel = cs_alloc_pcm_channel;
5095 card->alloc_rec_pcm_channel = cs_alloc_rec_pcm_channel;
5096 card->free_pcm_channel = cs_free_pcm_channel;
5097 card->amplifier_ctrl = amp_none;
5098 card->active_ctrl = amp_none;
5102 if (cp->vendor == ss_vendor && cp->id == ss_card) {
5103 card->amplifier_ctrl = cp->amp;
5105 card->active_ctrl = cp->active;
5107 card->amp_init = cp->amp_init;
5112 if (cp->name == NULL) {
5113 printk(KERN_INFO "cs46xx: Unknown card (%04X:%04X) at 0x%08lx/0x%08lx, IRQ %d\n",
5114 ss_vendor, ss_card, card->ba0_addr, card->ba1_addr, card->irq);
5116 printk(KERN_INFO "cs46xx: %s (%04X:%04X) at 0x%08lx/0x%08lx, IRQ %d\n",
5117 cp->name, ss_vendor, ss_card, card->ba0_addr, card->ba1_addr, card->irq);
5120 if (card->amplifier_ctrl == NULL) {
5121 card->amplifier_ctrl = amp_none;
5122 card->active_ctrl = clkrun_hack;
5125 if (external_amp == 1) {
5126 printk(KERN_INFO "cs46xx: Crystal EAPD support forced on.\n");
5127 card->amplifier_ctrl = amp_voyetra;
5130 if (thinkpad == 1) {
5131 printk(KERN_INFO "cs46xx: Activating CLKRUN hack for Thinkpad.\n");
5132 card->active_ctrl = clkrun_hack;
5135 * The thinkpads don't work well without runtime updating on their kernel
5136 * delay values (or any laptop with variable CPU speeds really).
5137 * so, just to be safe set the init delay to 2100. Eliminates
5138 * failures on T21 Thinkpads. remove this code when the udelay
5139 * and mdelay kernel code is replaced by a pm timer, or the delays
5140 * work well for battery and/or AC power both.
5142 if (card->active_ctrl == clkrun_hack) {
5146 if ((card->active_ctrl == clkrun_hack) && !(powerdown == 1)) {
5148 * for some currently unknown reason, powering down the DAC and ADC component
5149 * blocks on thinkpads causes some funky behavior... distoorrrtion and ac97
5150 * codec access problems. probably the serial clock becomes unsynced.
5151 * added code to sync the chips back up, but only helped about 70% the time.
5157 card->active_ctrl(card, 1);
5159 /* claim our iospace and irq */
5161 card->ba0 = ioremap_nocache(card->ba0_addr, CS461X_BA0_SIZE);
5162 card->ba1.name.data0 = ioremap_nocache(card->ba1_addr + BA1_SP_DMEM0, CS461X_BA1_DATA0_SIZE);
5163 card->ba1.name.data1 = ioremap_nocache(card->ba1_addr + BA1_SP_DMEM1, CS461X_BA1_DATA1_SIZE);
5164 card->ba1.name.pmem = ioremap_nocache(card->ba1_addr + BA1_SP_PMEM, CS461X_BA1_PRG_SIZE);
5165 card->ba1.name.reg = ioremap_nocache(card->ba1_addr + BA1_SP_REG, CS461X_BA1_REG_SIZE);
5167 CS_DBGOUT(CS_INIT, 4, printk(KERN_INFO
5168 "cs46xx: card=%p card->ba0=%p\n",card,card->ba0) );
5169 CS_DBGOUT(CS_INIT, 4, printk(KERN_INFO
5170 "cs46xx: card->ba1=%p %p %p %p\n",
5171 card->ba1.name.data0,
5172 card->ba1.name.data1,
5173 card->ba1.name.pmem,
5174 card->ba1.name.reg) );
5176 if (card->ba0 == 0 || card->ba1.name.data0 == 0 ||
5177 card->ba1.name.data1 == 0 || card->ba1.name.pmem == 0 ||
5178 card->ba1.name.reg == 0)
5181 if (request_irq(card->irq, &cs_interrupt, IRQF_SHARED, "cs46xx", card)) {
5182 printk(KERN_ERR "cs46xx: unable to allocate irq %d\n", card->irq);
5185 /* register /dev/dsp */
5186 if ((card->dev_audio = register_sound_dsp(&cs461x_fops, -1)) < 0) {
5187 printk(KERN_ERR "cs46xx: unable to register dsp\n");
5191 /* register /dev/midi */
5192 if ((card->dev_midi = register_sound_midi(&cs_midi_fops, -1)) < 0)
5193 printk(KERN_ERR "cs46xx: unable to register midi\n");
5195 card->pm.flags |= CS46XX_PM_IDLE;
5196 for (i = 0; i < 5; i++) {
5197 if (cs_hardware_init(card) != 0) {
5198 CS_DBGOUT(CS_ERROR, 4, printk(
5199 "cs46xx: ERROR in cs_hardware_init()... retrying\n"));
5200 for (j = 0; j < NR_AC97; j++)
5201 if (card->ac97_codec[j] != NULL) {
5202 unregister_sound_mixer(card->ac97_codec[j]->dev_mixer);
5203 ac97_release_codec(card->ac97_codec[j]);
5205 mdelay(10 * cs_laptop_wait);
5211 CS_DBGOUT(CS_PM | CS_ERROR, 1, printk(
5212 "cs46xx: cs46xx_probe()- cs_hardware_init() failed, retried %d times.\n",i));
5213 unregister_sound_dsp(card->dev_audio);
5215 unregister_sound_midi(card->dev_midi);
5219 init_waitqueue_head(&card->midi.open_wait);
5220 mutex_init(&card->midi.open_mutex);
5221 init_waitqueue_head(&card->midi.iwait);
5222 init_waitqueue_head(&card->midi.owait);
5223 cs461x_pokeBA0(card, BA0_MIDCR, MIDCR_MRST);
5224 cs461x_pokeBA0(card, BA0_MIDCR, 0);
5227 * Check if we have to init the amplifier, but probably already done
5228 * since the CD logic in the ac97 init code will turn on the ext amp.
5232 card->active_ctrl(card, -1);
5234 PCI_SET_DRIVER_DATA(pci_dev, card);
5235 PCI_SET_DMA_MASK(pci_dev, dma_mask);
5236 list_add(&card->list, &cs46xx_devs);
5238 CS_DBGOUT(CS_PM, 9, printk(KERN_INFO "cs46xx: pm.flags=0x%x card=%p\n",
5239 (unsigned)card->pm.flags,card));
5241 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5242 "cs46xx: probe()- device allocated successfully\n"));
5246 free_irq(card->irq, card);
5250 if (card->ba1.name.data0)
5251 iounmap(card->ba1.name.data0);
5252 if (card->ba1.name.data1)
5253 iounmap(card->ba1.name.data1);
5254 if (card->ba1.name.pmem)
5255 iounmap(card->ba1.name.pmem);
5256 if (card->ba1.name.reg)
5257 iounmap(card->ba1.name.reg);
5259 CS_DBGOUT(CS_INIT | CS_ERROR, 1, printk(KERN_INFO
5260 "cs46xx: probe()- no device allocated\n"));
5264 // ---------------------------------------------------------------------
5266 static void __devexit cs46xx_remove(struct pci_dev *pci_dev)
5268 struct cs_card *card = PCI_GET_DRIVER_DATA(pci_dev);
5272 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5273 "cs46xx: cs46xx_remove()+\n"));
5275 card->active_ctrl(card,1);
5277 tmp = cs461x_peek(card, BA1_PFIE);
5280 cs461x_poke(card, BA1_PFIE, tmp); /* playback interrupt disable */
5282 tmp = cs461x_peek(card, BA1_CIE);
5285 cs461x_poke(card, BA1_CIE, tmp); /* capture interrupt disable */
5288 * Stop playback DMA.
5290 tmp = cs461x_peek(card, BA1_PCTL);
5291 cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
5296 tmp = cs461x_peek(card, BA1_CCTL);
5297 cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
5300 * Reset the processor.
5304 cs461x_proc_stop(card);
5307 * Power down the DAC and ADC. We will power them up (if) when we need
5310 if ((tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
5311 CS_POWER_MIXVON, CS_TRUE))) {
5312 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
5313 "cs46xx: cs461x_powerdown() failure (0x%x)\n",tmp) );
5317 * Power down the PLL.
5319 cs461x_pokeBA0(card, BA0_CLKCR1, 0);
5322 * Turn off the Processor by turning off the software clock enable flag in
5323 * the clock control register.
5325 tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE;
5326 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
5328 card->active_ctrl(card,-1);
5330 /* free hardware resources */
5331 free_irq(card->irq, card);
5333 iounmap(card->ba1.name.data0);
5334 iounmap(card->ba1.name.data1);
5335 iounmap(card->ba1.name.pmem);
5336 iounmap(card->ba1.name.reg);
5338 /* unregister audio devices */
5339 for (i = 0; i < NR_AC97; i++)
5340 if (card->ac97_codec[i] != NULL) {
5341 unregister_sound_mixer(card->ac97_codec[i]->dev_mixer);
5342 ac97_release_codec(card->ac97_codec[i]);
5344 unregister_sound_dsp(card->dev_audio);
5346 unregister_sound_midi(card->dev_midi);
5347 list_del(&card->list);
5349 PCI_SET_DRIVER_DATA(pci_dev,NULL);
5351 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5352 "cs46xx: cs46xx_remove()-: remove successful\n"));
5357 CS46XX_4612, /* same as 4630 */
5358 CS46XX_4615, /* same as 4624 */
5361 static struct pci_device_id cs46xx_pci_tbl[] = {
5363 .vendor = PCI_VENDOR_ID_CIRRUS,
5364 .device = PCI_DEVICE_ID_CIRRUS_4610,
5365 .subvendor = PCI_ANY_ID,
5366 .subdevice = PCI_ANY_ID,
5367 .driver_data = CS46XX_4610,
5370 .vendor = PCI_VENDOR_ID_CIRRUS,
5371 .device = PCI_DEVICE_ID_CIRRUS_4612,
5372 .subvendor = PCI_ANY_ID,
5373 .subdevice = PCI_ANY_ID,
5374 .driver_data = CS46XX_4612,
5377 .vendor = PCI_VENDOR_ID_CIRRUS,
5378 .device = PCI_DEVICE_ID_CIRRUS_4615,
5379 .subvendor = PCI_ANY_ID,
5380 .subdevice = PCI_ANY_ID,
5381 .driver_data = CS46XX_4615,
5386 MODULE_DEVICE_TABLE(pci, cs46xx_pci_tbl);
5388 static struct pci_driver cs46xx_pci_driver = {
5390 .id_table = cs46xx_pci_tbl,
5391 .probe = cs46xx_probe,
5392 .remove = __devexit_p(cs46xx_remove),
5394 .suspend = cs46xx_suspend_tbl,
5395 .resume = cs46xx_resume_tbl,
5399 static int __init cs46xx_init_module(void)
5402 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5403 "cs46xx: cs46xx_init_module()+ \n"));
5404 rtn = pci_register_driver(&cs46xx_pci_driver);
5406 if (rtn == -ENODEV) {
5407 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(
5408 "cs46xx: Unable to detect valid cs46xx device\n"));
5411 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2,
5412 printk(KERN_INFO "cs46xx: cs46xx_init_module()- (%d)\n",rtn));
5416 static void __exit cs46xx_cleanup_module(void)
5418 pci_unregister_driver(&cs46xx_pci_driver);
5419 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2,
5420 printk(KERN_INFO "cs46xx: cleanup_cs46xx() finished\n"));
5423 module_init(cs46xx_init_module);
5424 module_exit(cs46xx_cleanup_module);
5427 static int cs46xx_suspend_tbl(struct pci_dev *pcidev, pm_message_t state)
5429 struct cs_card *s = PCI_GET_DRIVER_DATA(pcidev);
5430 CS_DBGOUT(CS_PM | CS_FUNCTION, 2,
5431 printk(KERN_INFO "cs46xx: cs46xx_suspend_tbl request\n"));
5432 cs46xx_suspend(s, state);
5436 static int cs46xx_resume_tbl(struct pci_dev *pcidev)
5438 struct cs_card *s = PCI_GET_DRIVER_DATA(pcidev);
5439 CS_DBGOUT(CS_PM | CS_FUNCTION, 2,
5440 printk(KERN_INFO "cs46xx: cs46xx_resume_tbl request\n"));
projects / linux-2.6 / blob