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>
97 #include <asm/uaccess.h>
100 #include "cs46xx_wrapper-24.h"
103 /* MIDI buffer sizes */
104 #define CS_MIDIINBUF 500
105 #define CS_MIDIOUTBUF 500
107 #define ADC_RUNNING 1
108 #define DAC_RUNNING 2
110 #define CS_FMT_16BIT 1 /* These are fixed in fact */
111 #define CS_FMT_STEREO 2
112 #define CS_FMT_MASK 3
114 #define CS_TYPE_ADC 1
115 #define CS_TYPE_DAC 2
120 #define CS_INC_USE_COUNT(m) (atomic_inc(m))
121 #define CS_DEC_USE_COUNT(m) (atomic_dec(m))
122 #define CS_DEC_AND_TEST(m) (atomic_dec_and_test(m))
123 #define CS_IN_USE(m) (atomic_read(m) != 0)
125 #define CS_DBGBREAKPOINT {__asm__("INT $3");}
130 #define CS461X_BA0_SIZE 0x2000
131 #define CS461X_BA1_DATA0_SIZE 0x3000
132 #define CS461X_BA1_DATA1_SIZE 0x3800
133 #define CS461X_BA1_PRG_SIZE 0x7000
134 #define CS461X_BA1_REG_SIZE 0x0100
136 #define GOF_PER_SEC 200
138 #define CSDEBUG_INTERFACE 1
141 * Turn on/off debugging compilation by using 1/0 respectively for CSDEBUG
144 * CSDEBUG is usual mode is set to 1, then use the
145 * cs_debuglevel and cs_debugmask to turn on or off debugging.
146 * Debug level of 1 has been defined to be kernel errors and info
147 * that should be printed on any released driver.
150 #define CS_DBGOUT(mask,level,x) if ((cs_debuglevel >= (level)) && ((mask) & cs_debugmask)) {x;}
152 #define CS_DBGOUT(mask,level,x)
157 #define CS_INIT 0x00000001 /* initialization and probe functions */
158 #define CS_ERROR 0x00000002 /* tmp debugging bit placeholder */
159 #define CS_INTERRUPT 0x00000004 /* interrupt handler (separate from all other) */
160 #define CS_FUNCTION 0x00000008 /* enter/leave functions */
161 #define CS_WAVE_WRITE 0x00000010 /* write information for wave */
162 #define CS_WAVE_READ 0x00000020 /* read information for wave */
163 #define CS_MIDI_WRITE 0x00000040 /* write information for midi */
164 #define CS_MIDI_READ 0x00000080 /* read information for midi */
165 #define CS_MPU401_WRITE 0x00000100 /* write information for mpu401 */
166 #define CS_MPU401_READ 0x00000200 /* read information for mpu401 */
167 #define CS_OPEN 0x00000400 /* all open functions in the driver */
168 #define CS_RELEASE 0x00000800 /* all release functions in the driver */
169 #define CS_PARMS 0x00001000 /* functional and operational parameters */
170 #define CS_IOCTL 0x00002000 /* ioctl (non-mixer) */
171 #define CS_PM 0x00004000 /* PM */
172 #define CS_TMP 0x10000000 /* tmp debug mask bit */
174 #define CS_IOCTL_CMD_SUSPEND 0x1 // suspend
175 #define CS_IOCTL_CMD_RESUME 0x2 // resume
178 static unsigned long cs_debuglevel = 1; /* levels range from 1-9 */
179 module_param(cs_debuglevel, ulong, 0644);
180 static unsigned long cs_debugmask = CS_INIT | CS_ERROR; /* use CS_DBGOUT with various mask values */
181 module_param(cs_debugmask, ulong, 0644);
183 static unsigned long hercules_egpio_disable; /* if non-zero set all EGPIO to 0 */
184 module_param(hercules_egpio_disable, ulong, 0);
185 static unsigned long initdelay = 700; /* PM delay in millisecs */
186 module_param(initdelay, ulong, 0);
187 static unsigned long powerdown = -1; /* turn on/off powerdown processing in driver */
188 module_param(powerdown, ulong, 0);
189 #define DMABUF_DEFAULTORDER 3
190 static unsigned long defaultorder = DMABUF_DEFAULTORDER;
191 module_param(defaultorder, ulong, 0);
193 static int external_amp;
194 module_param(external_amp, bool, 0);
196 module_param(thinkpad, bool, 0);
199 * set the powerdown module parm to 0 to disable all
200 * powerdown. also set thinkpad to 1 to disable powerdown,
201 * but also to enable the clkrun functionality.
203 static unsigned cs_powerdown = 1;
204 static unsigned cs_laptop_wait = 1;
206 /* An instance of the 4610 channel */
214 #define CS46XX_MAJOR_VERSION "1"
215 #define CS46XX_MINOR_VERSION "28"
218 #define CS46XX_ARCH "64" //architecture key
220 #define CS46XX_ARCH "32" //architecture key
223 static struct list_head cs46xx_devs = { &cs46xx_devs, &cs46xx_devs };
225 /* magic numbers to protect our data structures */
226 #define CS_CARD_MAGIC 0x43525553 /* "CRUS" */
227 #define CS_STATE_MAGIC 0x4c4f4749 /* "LOGI" */
230 /* maxinum number of AC97 codecs connected, AC97 2.0 defined 4 */
233 static const unsigned sample_size[] = { 1, 2, 2, 4 };
234 static const unsigned sample_shift[] = { 0, 1, 1, 2 };
236 /* "software" or virtual channel, an instance of opened /dev/dsp */
239 struct cs_card *card; /* Card info */
241 /* single open lock mechanism, only used for recording */
242 struct mutex open_mutex;
243 wait_queue_head_t open_wait;
248 /* virtual channel number */
252 /* wave sample stuff */
254 unsigned char fmt, enable;
256 /* hardware channel */
257 struct cs_channel *channel;
258 int pringbuf; /* Software ring slot */
259 void *pbuf; /* 4K hardware DMA buffer */
261 /* OSS buffer management stuff */
263 dma_addr_t dma_handle;
269 void *tmpbuff; /* tmp buffer for sample conversions */
271 dma_addr_t dmaaddr_tmpbuff;
272 unsigned buforder_tmpbuff; /* Log base 2 of size in bytes.. */
274 /* our buffer acts like a circular ring */
275 unsigned hwptr; /* where dma last started, updated by update_ptr */
276 unsigned swptr; /* where driver last clear/filled, updated by read/write */
277 int count; /* bytes to be comsumed or been generated by dma machine */
278 unsigned total_bytes; /* total bytes dmaed by hardware */
279 unsigned blocks; /* total blocks */
281 unsigned error; /* number of over/underruns */
282 unsigned underrun; /* underrun pending before next write has occurred */
283 wait_queue_head_t wait; /* put process on wait queue when no more space in buffer */
285 /* redundant, but makes calculations easier */
288 unsigned fragsamples;
293 unsigned endcleared:1;
295 unsigned update_flag;
296 unsigned ossfragshift;
298 unsigned subdivision;
300 /* Guard against mmap/write/read races */
305 struct cs_channel channel[2];
308 /* We keep cs461x cards in a linked list */
309 struct cs_card *next;
311 /* The cs461x has a certain amount of cross channel interaction
312 so we use a single per card lock */
316 spinlock_t ac97_lock;
318 /* mixer use count */
319 atomic_t mixer_use_cnt;
321 /* PCI device stuff */
322 struct pci_dev *pci_dev;
323 struct list_head list;
325 unsigned int pctl, cctl; /* Hardware DMA flag sets */
327 /* soundcore stuff */
331 /* structures for abstraction of hardware facilities, codecs, banks and channels*/
332 struct ac97_codec *ac97_codec[NR_AC97];
333 struct cs_state *states[2];
337 int amplifier; /* Amplifier control */
338 void (*amplifier_ctrl)(struct cs_card *, int);
339 void (*amp_init)(struct cs_card *);
341 int active; /* Active clocking */
342 void (*active_ctrl)(struct cs_card *, int);
344 /* hardware resources */
345 unsigned long ba0_addr;
346 unsigned long ba1_addr;
363 /* Function support */
364 struct cs_channel *(*alloc_pcm_channel)(struct cs_card *);
365 struct cs_channel *(*alloc_rec_pcm_channel)(struct cs_card *);
366 void (*free_pcm_channel)(struct cs_card *, int chan);
368 /* /dev/midi stuff */
370 unsigned ird, iwr, icnt;
371 unsigned ord, owr, ocnt;
372 wait_queue_head_t open_wait;
373 wait_queue_head_t iwait;
374 wait_queue_head_t owait;
376 unsigned char ibuf[CS_MIDIINBUF];
377 unsigned char obuf[CS_MIDIOUTBUF];
379 struct mutex open_mutex;
384 static int cs_open_mixdev(struct inode *inode, struct file *file);
385 static int cs_release_mixdev(struct inode *inode, struct file *file);
386 static int cs_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd,
388 static int cs_hardware_init(struct cs_card *card);
389 static int cs46xx_powerup(struct cs_card *card, unsigned int type);
390 static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspendflag);
391 static void cs461x_clear_serial_FIFOs(struct cs_card *card, int type);
393 static int cs46xx_suspend_tbl(struct pci_dev *pcidev, pm_message_t state);
394 static int cs46xx_resume_tbl(struct pci_dev *pcidev);
401 #define SOUND_MIXER_CS_GETDBGLEVEL _SIOWR('M',120, int)
402 #define SOUND_MIXER_CS_SETDBGLEVEL _SIOWR('M',121, int)
403 #define SOUND_MIXER_CS_GETDBGMASK _SIOWR('M',122, int)
404 #define SOUND_MIXER_CS_SETDBGMASK _SIOWR('M',123, int)
405 #define SOUND_MIXER_CS_APM _SIOWR('M',124, int)
407 static void printioctl(unsigned int x)
411 /* these values are incorrect for the ac97 driver, fix.
412 * Index of mixtable1[] member is Device ID
413 * and must be <= SOUND_MIXER_NRDEVICES.
414 * Value of array member is index into s->mix.vol[]
416 static const unsigned char mixtable1[SOUND_MIXER_NRDEVICES] = {
417 [SOUND_MIXER_PCM] = 1, /* voice */
418 [SOUND_MIXER_LINE1] = 2, /* AUX */
419 [SOUND_MIXER_CD] = 3, /* CD */
420 [SOUND_MIXER_LINE] = 4, /* Line */
421 [SOUND_MIXER_SYNTH] = 5, /* FM */
422 [SOUND_MIXER_MIC] = 6, /* Mic */
423 [SOUND_MIXER_SPEAKER] = 7, /* Speaker */
424 [SOUND_MIXER_RECLEV] = 8, /* Recording level */
425 [SOUND_MIXER_VOLUME] = 9 /* Master Volume */
429 case SOUND_MIXER_CS_GETDBGMASK:
430 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_GETDBGMASK: ") );
432 case SOUND_MIXER_CS_GETDBGLEVEL:
433 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_GETDBGLEVEL: ") );
435 case SOUND_MIXER_CS_SETDBGMASK:
436 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_SETDBGMASK: ") );
438 case SOUND_MIXER_CS_SETDBGLEVEL:
439 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CS_SETDBGLEVEL: ") );
442 CS_DBGOUT(CS_IOCTL, 4, printk("OSS_GETVERSION: ") );
444 case SNDCTL_DSP_SYNC:
445 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SYNC: ") );
447 case SNDCTL_DSP_SETDUPLEX:
448 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETDUPLEX: ") );
450 case SNDCTL_DSP_GETCAPS:
451 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETCAPS: ") );
453 case SNDCTL_DSP_RESET:
454 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_RESET: ") );
456 case SNDCTL_DSP_SPEED:
457 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SPEED: ") );
459 case SNDCTL_DSP_STEREO:
460 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_STEREO: ") );
462 case SNDCTL_DSP_CHANNELS:
463 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_CHANNELS: ") );
465 case SNDCTL_DSP_GETFMTS:
466 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETFMTS: ") );
468 case SNDCTL_DSP_SETFMT:
469 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETFMT: ") );
471 case SNDCTL_DSP_POST:
472 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_POST: ") );
474 case SNDCTL_DSP_GETTRIGGER:
475 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETTRIGGER: ") );
477 case SNDCTL_DSP_SETTRIGGER:
478 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETTRIGGER: ") );
480 case SNDCTL_DSP_GETOSPACE:
481 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETOSPACE: ") );
483 case SNDCTL_DSP_GETISPACE:
484 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETISPACE: ") );
486 case SNDCTL_DSP_NONBLOCK:
487 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_NONBLOCK: ") );
489 case SNDCTL_DSP_GETODELAY:
490 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETODELAY: ") );
492 case SNDCTL_DSP_GETIPTR:
493 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETIPTR: ") );
495 case SNDCTL_DSP_GETOPTR:
496 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETOPTR: ") );
498 case SNDCTL_DSP_GETBLKSIZE:
499 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_GETBLKSIZE: ") );
501 case SNDCTL_DSP_SETFRAGMENT:
502 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETFRAGMENT: ") );
504 case SNDCTL_DSP_SUBDIVIDE:
505 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SUBDIVIDE: ") );
507 case SOUND_PCM_READ_RATE:
508 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_RATE: ") );
510 case SOUND_PCM_READ_CHANNELS:
511 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_CHANNELS: ") );
513 case SOUND_PCM_READ_BITS:
514 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_BITS: ") );
516 case SOUND_PCM_WRITE_FILTER:
517 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_WRITE_FILTER: ") );
519 case SNDCTL_DSP_SETSYNCRO:
520 CS_DBGOUT(CS_IOCTL, 4, printk("SNDCTL_DSP_SETSYNCRO: ") );
522 case SOUND_PCM_READ_FILTER:
523 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_PCM_READ_FILTER: ") );
525 case SOUND_MIXER_PRIVATE1:
526 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE1: ") );
528 case SOUND_MIXER_PRIVATE2:
529 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE2: ") );
531 case SOUND_MIXER_PRIVATE3:
532 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE3: ") );
534 case SOUND_MIXER_PRIVATE4:
535 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE4: ") );
537 case SOUND_MIXER_PRIVATE5:
538 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_PRIVATE5: ") );
540 case SOUND_MIXER_INFO:
541 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_INFO: ") );
543 case SOUND_OLD_MIXER_INFO:
544 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_OLD_MIXER_INFO: ") );
547 switch (_IOC_NR(x)) {
548 case SOUND_MIXER_VOLUME:
549 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_VOLUME: ") );
551 case SOUND_MIXER_SPEAKER:
552 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_SPEAKER: ") );
554 case SOUND_MIXER_RECLEV:
555 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECLEV: ") );
557 case SOUND_MIXER_MIC:
558 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_MIC: ") );
560 case SOUND_MIXER_SYNTH:
561 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_SYNTH: ") );
563 case SOUND_MIXER_RECSRC:
564 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECSRC: ") );
566 case SOUND_MIXER_DEVMASK:
567 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_DEVMASK: ") );
569 case SOUND_MIXER_RECMASK:
570 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_RECMASK: ") );
572 case SOUND_MIXER_STEREODEVS:
573 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_STEREODEVS: ") );
575 case SOUND_MIXER_CAPS:
576 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_CAPS:") );
580 if (i >= SOUND_MIXER_NRDEVICES || !(vidx = mixtable1[i])) {
581 CS_DBGOUT(CS_IOCTL, 4, printk("UNKNOWN IOCTL: 0x%.8x NR=%d ",x,i) );
583 CS_DBGOUT(CS_IOCTL, 4, printk("SOUND_MIXER_IOCTL AC9x: 0x%.8x NR=%d ",
589 CS_DBGOUT(CS_IOCTL, 4, printk("command = 0x%x IOC_NR=%d\n",x, _IOC_NR(x)) );
594 * common I/O routines
597 static void cs461x_poke(struct cs_card *codec, unsigned long reg, unsigned int val)
599 writel(val, codec->ba1.idx[(reg >> 16) & 3] + (reg & 0xffff));
602 static unsigned int cs461x_peek(struct cs_card *codec, unsigned long reg)
604 return readl(codec->ba1.idx[(reg >> 16) & 3] + (reg & 0xffff));
607 static void cs461x_pokeBA0(struct cs_card *codec, unsigned long reg, unsigned int val)
609 writel(val, codec->ba0 + reg);
612 static unsigned int cs461x_peekBA0(struct cs_card *codec, unsigned long reg)
614 return readl(codec->ba0 + reg);
618 static u16 cs_ac97_get(struct ac97_codec *dev, u8 reg);
619 static void cs_ac97_set(struct ac97_codec *dev, u8 reg, u16 data);
621 static struct cs_channel *cs_alloc_pcm_channel(struct cs_card *card)
623 if (card->channel[1].used == 1)
625 card->channel[1].used = 1;
626 card->channel[1].num = 1;
627 return &card->channel[1];
630 static struct cs_channel *cs_alloc_rec_pcm_channel(struct cs_card *card)
632 if (card->channel[0].used == 1)
634 card->channel[0].used = 1;
635 card->channel[0].num = 0;
636 return &card->channel[0];
639 static void cs_free_pcm_channel(struct cs_card *card, int channel)
641 card->channel[channel].state = NULL;
642 card->channel[channel].used = 0;
646 * setup a divisor value to help with conversion from
647 * 16bit Stereo, down to 8bit stereo/mono or 16bit mono.
648 * assign a divisor of 1 if using 16bit Stereo as that is
649 * the only format that the static image will capture.
651 static void cs_set_divisor(struct dmabuf *dmabuf)
653 if (dmabuf->type == CS_TYPE_DAC)
655 else if (!(dmabuf->fmt & CS_FMT_STEREO) &&
656 (dmabuf->fmt & CS_FMT_16BIT))
658 else if ((dmabuf->fmt & CS_FMT_STEREO) &&
659 !(dmabuf->fmt & CS_FMT_16BIT))
661 else if (!(dmabuf->fmt & CS_FMT_STEREO) &&
662 !(dmabuf->fmt & CS_FMT_16BIT))
667 CS_DBGOUT(CS_PARMS | CS_FUNCTION, 8, printk(
668 "cs46xx: cs_set_divisor()- %s %d\n",
669 (dmabuf->type == CS_TYPE_ADC) ? "ADC" : "DAC",
674 * mute some of the more prevalent registers to avoid popping.
676 static void cs_mute(struct cs_card *card, int state)
678 struct ac97_codec *dev = card->ac97_codec[0];
680 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs46xx: cs_mute()+ %s\n",
681 (state == CS_TRUE) ? "Muting" : "UnMuting"));
683 if (state == CS_TRUE) {
685 * fix pops when powering up on thinkpads
687 card->pm.u32AC97_master_volume = (u32)cs_ac97_get( dev,
688 (u8)BA0_AC97_MASTER_VOLUME);
689 card->pm.u32AC97_headphone_volume = (u32)cs_ac97_get(dev,
690 (u8)BA0_AC97_HEADPHONE_VOLUME);
691 card->pm.u32AC97_master_volume_mono = (u32)cs_ac97_get(dev,
692 (u8)BA0_AC97_MASTER_VOLUME_MONO);
693 card->pm.u32AC97_pcm_out_volume = (u32)cs_ac97_get(dev,
694 (u8)BA0_AC97_PCM_OUT_VOLUME);
696 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME, 0x8000);
697 cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, 0x8000);
698 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, 0x8000);
699 cs_ac97_set(dev, (u8)BA0_AC97_PCM_OUT_VOLUME, 0x8000);
701 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME, card->pm.u32AC97_master_volume);
702 cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, card->pm.u32AC97_headphone_volume);
703 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, card->pm.u32AC97_master_volume_mono);
704 cs_ac97_set(dev, (u8)BA0_AC97_PCM_OUT_VOLUME, card->pm.u32AC97_pcm_out_volume);
706 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs46xx: cs_mute()-\n"));
709 /* set playback sample rate */
710 static unsigned int cs_set_dac_rate(struct cs_state * state, unsigned int rate)
712 struct dmabuf *dmabuf = &state->dmabuf;
713 unsigned int tmp1, tmp2;
714 unsigned int phiIncr;
715 unsigned int correctionPerGOF, correctionPerSec;
718 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_dac_rate()+ %d\n",rate) );
721 * Compute the values used to drive the actual sample rate conversion.
722 * The following formulas are being computed, using inline assembly
723 * since we need to use 64 bit arithmetic to compute the values:
725 * phiIncr = floor((Fs,in * 2^26) / Fs,out)
726 * correctionPerGOF = floor((Fs,in * 2^26 - Fs,out * phiIncr) /
728 * ulCorrectionPerSec = Fs,in * 2^26 - Fs,out * phiIncr -M
729 * GOF_PER_SEC * correctionPerGOF
733 * phiIncr:other = dividend:remainder((Fs,in * 2^26) / Fs,out)
734 * correctionPerGOF:correctionPerSec =
735 * dividend:remainder(ulOther / GOF_PER_SEC)
738 phiIncr = tmp1 / 48000;
739 tmp1 -= phiIncr * 48000;
744 tmp1 -= tmp2 * 48000;
745 correctionPerGOF = tmp1 / GOF_PER_SEC;
746 tmp1 -= correctionPerGOF * GOF_PER_SEC;
747 correctionPerSec = tmp1;
750 * Fill in the SampleRateConverter control block.
752 spin_lock_irqsave(&state->card->lock, flags);
753 cs461x_poke(state->card, BA1_PSRC,
754 ((correctionPerSec << 16) & 0xFFFF0000) | (correctionPerGOF & 0xFFFF));
755 cs461x_poke(state->card, BA1_PPI, phiIncr);
756 spin_unlock_irqrestore(&state->card->lock, flags);
759 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_dac_rate()- %d\n",rate) );
763 /* set recording sample rate */
764 static unsigned int cs_set_adc_rate(struct cs_state *state, unsigned int rate)
766 struct dmabuf *dmabuf = &state->dmabuf;
767 struct cs_card *card = state->card;
768 unsigned int phiIncr, coeffIncr, tmp1, tmp2;
769 unsigned int correctionPerGOF, correctionPerSec, initialDelay;
770 unsigned int frameGroupLength, cnt;
772 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_adc_rate()+ %d\n",rate) );
775 * We can only decimate by up to a factor of 1/9th the hardware rate.
776 * Correct the value if an attempt is made to stray outside that limit.
778 if ((rate * 9) < 48000)
782 * We can not capture at at rate greater than the Input Rate (48000).
783 * Return an error if an attempt is made to stray outside that limit.
789 * Compute the values used to drive the actual sample rate conversion.
790 * The following formulas are being computed, using inline assembly
791 * since we need to use 64 bit arithmetic to compute the values:
793 * coeffIncr = -floor((Fs,out * 2^23) / Fs,in)
794 * phiIncr = floor((Fs,in * 2^26) / Fs,out)
795 * correctionPerGOF = floor((Fs,in * 2^26 - Fs,out * phiIncr) /
797 * correctionPerSec = Fs,in * 2^26 - Fs,out * phiIncr -
798 * GOF_PER_SEC * correctionPerGOF
799 * initialDelay = ceil((24 * Fs,in) / Fs,out)
803 * coeffIncr = neg(dividend((Fs,out * 2^23) / Fs,in))
804 * phiIncr:ulOther = dividend:remainder((Fs,in * 2^26) / Fs,out)
805 * correctionPerGOF:correctionPerSec =
806 * dividend:remainder(ulOther / GOF_PER_SEC)
807 * initialDelay = dividend(((24 * Fs,in) + Fs,out - 1) / Fs,out)
810 coeffIncr = tmp1 / 48000;
811 tmp1 -= coeffIncr * 48000;
814 coeffIncr += tmp1 / 48000;
815 coeffIncr ^= 0xFFFFFFFF;
818 phiIncr = tmp1 / rate;
819 tmp1 -= phiIncr * rate;
825 correctionPerGOF = tmp1 / GOF_PER_SEC;
826 tmp1 -= correctionPerGOF * GOF_PER_SEC;
827 correctionPerSec = tmp1;
828 initialDelay = ((48000 * 24) + rate - 1) / rate;
831 * Fill in the VariDecimate control block.
833 spin_lock_irqsave(&card->lock, flags);
834 cs461x_poke(card, BA1_CSRC,
835 ((correctionPerSec << 16) & 0xFFFF0000) | (correctionPerGOF & 0xFFFF));
836 cs461x_poke(card, BA1_CCI, coeffIncr);
837 cs461x_poke(card, BA1_CD,
838 (((BA1_VARIDEC_BUF_1 + (initialDelay << 2)) << 16) & 0xFFFF0000) | 0x80);
839 cs461x_poke(card, BA1_CPI, phiIncr);
840 spin_unlock_irqrestore(&card->lock, flags);
843 * Figure out the frame group length for the write back task. Basically,
844 * this is just the factors of 24000 (2^6*3*5^3) that are not present in
845 * the output sample rate.
847 frameGroupLength = 1;
848 for (cnt = 2; cnt <= 64; cnt *= 2) {
849 if (((rate / cnt) * cnt) != rate)
850 frameGroupLength *= 2;
852 if (((rate / 3) * 3) != rate) {
853 frameGroupLength *= 3;
855 for (cnt = 5; cnt <= 125; cnt *= 5) {
856 if (((rate / cnt) * cnt) != rate)
857 frameGroupLength *= 5;
861 * Fill in the WriteBack control block.
863 spin_lock_irqsave(&card->lock, flags);
864 cs461x_poke(card, BA1_CFG1, frameGroupLength);
865 cs461x_poke(card, BA1_CFG2, (0x00800000 | frameGroupLength));
866 cs461x_poke(card, BA1_CCST, 0x0000FFFF);
867 cs461x_poke(card, BA1_CSPB, ((65536 * rate) / 24000));
868 cs461x_poke(card, (BA1_CSPB + 4), 0x0000FFFF);
869 spin_unlock_irqrestore(&card->lock, flags);
871 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_set_adc_rate()- %d\n",rate) );
875 /* prepare channel attributes for playback */
876 static void cs_play_setup(struct cs_state *state)
878 struct dmabuf *dmabuf = &state->dmabuf;
879 struct cs_card *card = state->card;
880 unsigned int tmp, Count, playFormat;
882 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_play_setup()+\n") );
883 cs461x_poke(card, BA1_PVOL, 0x80008000);
885 cs461x_poke(card, BA1_PBA, virt_to_bus(dmabuf->pbuf));
888 playFormat=cs461x_peek(card, BA1_PFIE);
889 if ((dmabuf->fmt & CS_FMT_STEREO)) {
890 playFormat &= ~DMA_RQ_C2_AC_MONO_TO_STEREO;
893 playFormat |= DMA_RQ_C2_AC_MONO_TO_STEREO;
895 if ((dmabuf->fmt & CS_FMT_16BIT)) {
896 playFormat &= ~(DMA_RQ_C2_AC_8_TO_16_BIT
897 | DMA_RQ_C2_AC_SIGNED_CONVERT);
900 playFormat |= (DMA_RQ_C2_AC_8_TO_16_BIT
901 | DMA_RQ_C2_AC_SIGNED_CONVERT);
903 cs461x_poke(card, BA1_PFIE, playFormat);
905 tmp = cs461x_peek(card, BA1_PDTC);
907 cs461x_poke(card, BA1_PDTC, tmp | --Count);
909 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_play_setup()-\n") );
912 static struct InitStruct
916 } InitArray[] = { {0x00000040, 0x3fc0000f},
917 {0x0000004c, 0x04800000},
919 {0x000000b3, 0x00000780},
920 {0x000000b7, 0x00000000},
921 {0x000000bc, 0x07800000},
923 {0x000000cd, 0x00800000},
927 * "SetCaptureSPValues()" -- Initialize record task values before each
930 static void SetCaptureSPValues(struct cs_card *card)
933 CS_DBGOUT(CS_FUNCTION, 8, printk("cs46xx: SetCaptureSPValues()+\n") );
934 for (i = 0; i < sizeof(InitArray) / sizeof(struct InitStruct); i++) {
935 offset = InitArray[i].off*4; /* 8bit to 32bit offset value */
936 cs461x_poke(card, offset, InitArray[i].val );
938 CS_DBGOUT(CS_FUNCTION, 8, printk("cs46xx: SetCaptureSPValues()-\n") );
941 /* prepare channel attributes for recording */
942 static void cs_rec_setup(struct cs_state *state)
944 struct cs_card *card = state->card;
945 struct dmabuf *dmabuf = &state->dmabuf;
947 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_rec_setup()+\n"));
948 SetCaptureSPValues(card);
951 * set the attenuation to 0dB
953 cs461x_poke(card, BA1_CVOL, 0x80008000);
956 * set the physical address of the capture buffer into the SP
958 cs461x_poke(card, BA1_CBA, virt_to_bus(dmabuf->rawbuf));
960 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_rec_setup()-\n") );
964 /* get current playback/recording dma buffer pointer (byte offset from LBA),
965 called with spinlock held! */
967 static inline unsigned cs_get_dma_addr(struct cs_state *state)
969 struct dmabuf *dmabuf = &state->dmabuf;
972 if ( (!(dmabuf->enable & DAC_RUNNING)) &&
973 (!(dmabuf->enable & ADC_RUNNING) ) )
975 CS_DBGOUT(CS_ERROR, 2, printk(
976 "cs46xx: ERROR cs_get_dma_addr(): not enabled \n") );
981 * granularity is byte boundary, good part.
983 if (dmabuf->enable & DAC_RUNNING)
984 offset = cs461x_peek(state->card, BA1_PBA);
985 else /* ADC_RUNNING must be set */
986 offset = cs461x_peek(state->card, BA1_CBA);
988 CS_DBGOUT(CS_PARMS | CS_FUNCTION, 9,
989 printk("cs46xx: cs_get_dma_addr() %d\n",offset) );
990 offset = (u32)bus_to_virt((unsigned long)offset) - (u32)dmabuf->rawbuf;
991 CS_DBGOUT(CS_PARMS | CS_FUNCTION, 8,
992 printk("cs46xx: cs_get_dma_addr()- %d\n",offset) );
996 static void resync_dma_ptrs(struct cs_state *state)
998 struct dmabuf *dmabuf;
1000 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: resync_dma_ptrs()+ \n") );
1002 dmabuf = &state->dmabuf;
1003 dmabuf->hwptr=dmabuf->swptr = 0;
1004 dmabuf->pringbuf = 0;
1006 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: resync_dma_ptrs()- \n") );
1009 /* Stop recording (lock held) */
1010 static inline void __stop_adc(struct cs_state *state)
1012 struct dmabuf *dmabuf = &state->dmabuf;
1013 struct cs_card *card = state->card;
1016 dmabuf->enable &= ~ADC_RUNNING;
1018 tmp = cs461x_peek(card, BA1_CCTL);
1020 cs461x_poke(card, BA1_CCTL, tmp );
1023 static void stop_adc(struct cs_state *state)
1025 unsigned long flags;
1027 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_adc()+ \n") );
1028 spin_lock_irqsave(&state->card->lock, flags);
1030 spin_unlock_irqrestore(&state->card->lock, flags);
1031 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_adc()- \n") );
1034 static void start_adc(struct cs_state *state)
1036 struct dmabuf *dmabuf = &state->dmabuf;
1037 struct cs_card *card = state->card;
1038 unsigned long flags;
1041 spin_lock_irqsave(&card->lock, flags);
1042 if (!(dmabuf->enable & ADC_RUNNING) &&
1043 ((dmabuf->mapped || dmabuf->count < (signed)dmabuf->dmasize)
1044 && dmabuf->ready) &&
1045 ((card->pm.flags & CS46XX_PM_IDLE) ||
1046 (card->pm.flags & CS46XX_PM_RESUMED)) )
1048 dmabuf->enable |= ADC_RUNNING;
1049 cs_set_divisor(dmabuf);
1050 tmp = cs461x_peek(card, BA1_CCTL);
1053 CS_DBGOUT(CS_FUNCTION, 2, printk(
1054 "cs46xx: start_adc() poke 0x%x \n",tmp) );
1055 cs461x_poke(card, BA1_CCTL, tmp);
1057 spin_unlock_irqrestore(&card->lock, flags);
1060 /* stop playback (lock held) */
1061 static inline void __stop_dac(struct cs_state *state)
1063 struct dmabuf *dmabuf = &state->dmabuf;
1064 struct cs_card *card = state->card;
1067 dmabuf->enable &= ~DAC_RUNNING;
1069 tmp=cs461x_peek(card, BA1_PCTL);
1071 cs461x_poke(card, BA1_PCTL, tmp);
1074 static void stop_dac(struct cs_state *state)
1076 unsigned long flags;
1078 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_dac()+ \n") );
1079 spin_lock_irqsave(&state->card->lock, flags);
1081 spin_unlock_irqrestore(&state->card->lock, flags);
1082 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: stop_dac()- \n") );
1085 static void start_dac(struct cs_state *state)
1087 struct dmabuf *dmabuf = &state->dmabuf;
1088 struct cs_card *card = state->card;
1089 unsigned long flags;
1092 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: start_dac()+ \n") );
1093 spin_lock_irqsave(&card->lock, flags);
1094 if (!(dmabuf->enable & DAC_RUNNING) &&
1095 ((dmabuf->mapped || dmabuf->count > 0) && dmabuf->ready) &&
1096 ((card->pm.flags & CS46XX_PM_IDLE) ||
1097 (card->pm.flags & CS46XX_PM_RESUMED)) )
1099 dmabuf->enable |= DAC_RUNNING;
1100 tmp = cs461x_peek(card, BA1_PCTL);
1103 CS_DBGOUT(CS_PARMS, 6, printk(
1104 "cs46xx: start_dac() poke card=%p tmp=0x%.08x addr=%p \n",
1105 card, (unsigned)tmp,
1106 card->ba1.idx[(BA1_PCTL >> 16) & 3]+(BA1_PCTL&0xffff) ) );
1107 cs461x_poke(card, BA1_PCTL, tmp);
1109 spin_unlock_irqrestore(&card->lock, flags);
1110 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: start_dac()- \n") );
1113 #define DMABUF_MINORDER 1
1116 * allocate DMA buffer, playback and recording buffers are separate.
1118 static int alloc_dmabuf(struct cs_state *state)
1121 struct cs_card *card=state->card;
1122 struct dmabuf *dmabuf = &state->dmabuf;
1123 void *rawbuf = NULL;
1124 void *tmpbuff = NULL;
1126 struct page *map, *mapend;
1129 dmabuf->ready = dmabuf->mapped = 0;
1132 * check for order within limits, but do not overwrite value.
1134 if ((defaultorder > 1) && (defaultorder < 12))
1139 for (order = df; order >= DMABUF_MINORDER; order--)
1140 if ((rawbuf = (void *)pci_alloc_consistent(
1141 card->pci_dev, PAGE_SIZE << order, &dmabuf->dmaaddr)))
1144 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
1145 "cs46xx: alloc_dmabuf(): unable to allocate rawbuf\n"));
1148 dmabuf->buforder = order;
1149 dmabuf->rawbuf = rawbuf;
1150 // Now mark the pages as reserved; otherwise the
1151 // remap_pfn_range() in cs46xx_mmap doesn't work.
1152 // 1. get index to last page in mem_map array for rawbuf.
1153 mapend = virt_to_page(dmabuf->rawbuf +
1154 (PAGE_SIZE << dmabuf->buforder) - 1);
1156 // 2. mark each physical page in range as 'reserved'.
1157 for (map = virt_to_page(dmabuf->rawbuf); map <= mapend; map++)
1158 cs4x_mem_map_reserve(map);
1160 CS_DBGOUT(CS_PARMS, 9, printk("cs46xx: alloc_dmabuf(): allocated %ld (order = %d) bytes at %p\n",
1161 PAGE_SIZE << order, order, rawbuf) );
1164 * only allocate the conversion buffer for the ADC
1166 if (dmabuf->type == CS_TYPE_DAC) {
1167 dmabuf->tmpbuff = NULL;
1168 dmabuf->buforder_tmpbuff = 0;
1172 * now the temp buffer for 16/8 conversions
1175 tmpbuff = (void *) pci_alloc_consistent(
1176 card->pci_dev, PAGE_SIZE << order, &dmabuf->dmaaddr_tmpbuff);
1180 CS_DBGOUT(CS_PARMS, 9, printk("cs46xx: allocated %ld (order = %d) bytes at %p\n",
1181 PAGE_SIZE << order, order, tmpbuff) );
1183 dmabuf->tmpbuff = tmpbuff;
1184 dmabuf->buforder_tmpbuff = order;
1186 // Now mark the pages as reserved; otherwise the
1187 // remap_pfn_range() in cs46xx_mmap doesn't work.
1188 // 1. get index to last page in mem_map array for rawbuf.
1189 mapend = virt_to_page(dmabuf->tmpbuff +
1190 (PAGE_SIZE << dmabuf->buforder_tmpbuff) - 1);
1192 // 2. mark each physical page in range as 'reserved'.
1193 for (map = virt_to_page(dmabuf->tmpbuff); map <= mapend; map++)
1194 cs4x_mem_map_reserve(map);
1198 /* free DMA buffer */
1199 static void dealloc_dmabuf(struct cs_state *state)
1201 struct dmabuf *dmabuf = &state->dmabuf;
1202 struct page *map, *mapend;
1204 if (dmabuf->rawbuf) {
1205 // Undo prog_dmabuf()'s marking the pages as reserved
1206 mapend = virt_to_page(dmabuf->rawbuf +
1207 (PAGE_SIZE << dmabuf->buforder) - 1);
1208 for (map = virt_to_page(dmabuf->rawbuf); map <= mapend; map++)
1209 cs4x_mem_map_unreserve(map);
1210 free_dmabuf(state->card, dmabuf);
1213 if (dmabuf->tmpbuff) {
1214 // Undo prog_dmabuf()'s marking the pages as reserved
1215 mapend = virt_to_page(dmabuf->tmpbuff +
1216 (PAGE_SIZE << dmabuf->buforder_tmpbuff) - 1);
1217 for (map = virt_to_page(dmabuf->tmpbuff); map <= mapend; map++)
1218 cs4x_mem_map_unreserve(map);
1219 free_dmabuf2(state->card, dmabuf);
1222 dmabuf->rawbuf = NULL;
1223 dmabuf->tmpbuff = NULL;
1224 dmabuf->mapped = dmabuf->ready = 0;
1228 static int __prog_dmabuf(struct cs_state *state)
1230 struct dmabuf *dmabuf = &state->dmabuf;
1231 unsigned long flags;
1232 unsigned long allocated_pages, allocated_bytes;
1233 unsigned long tmp1, tmp2, fmt=0;
1234 unsigned long *ptmp = (unsigned long *) dmabuf->pbuf;
1235 unsigned long SGarray[9], nSGpages=0;
1238 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()+ \n"));
1240 * check for CAPTURE and use only non-sg for initial release
1242 if (dmabuf->type == CS_TYPE_ADC) {
1243 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf() ADC\n"));
1245 * add in non-sg support for capture.
1247 spin_lock_irqsave(&state->card->lock, flags);
1248 /* add code to reset the rawbuf memory. TRW */
1249 resync_dma_ptrs(state);
1250 dmabuf->total_bytes = dmabuf->blocks = 0;
1251 dmabuf->count = dmabuf->error = dmabuf->underrun = 0;
1255 spin_unlock_irqrestore(&state->card->lock, flags);
1257 /* allocate DMA buffer if not allocated yet */
1258 if (!dmabuf->rawbuf || !dmabuf->tmpbuff)
1259 if ((ret = alloc_dmabuf(state)))
1262 * static image only supports 16Bit signed, stereo - hard code fmt
1264 fmt = CS_FMT_16BIT | CS_FMT_STEREO;
1266 dmabuf->numfrag = 2;
1267 dmabuf->fragsize = 2048;
1268 dmabuf->fragsamples = 2048 >> sample_shift[fmt];
1269 dmabuf->dmasize = 4096;
1270 dmabuf->fragshift = 11;
1272 memset(dmabuf->rawbuf, (fmt & CS_FMT_16BIT) ? 0 : 0x80,
1274 memset(dmabuf->tmpbuff, (fmt & CS_FMT_16BIT) ? 0 : 0x80,
1275 PAGE_SIZE<<dmabuf->buforder_tmpbuff);
1278 * Now set up the ring
1281 spin_lock_irqsave(&state->card->lock, flags);
1282 cs_rec_setup(state);
1283 spin_unlock_irqrestore(&state->card->lock, flags);
1285 /* set the ready flag for the dma buffer */
1288 CS_DBGOUT(CS_PARMS, 4, printk(
1289 "cs46xx: prog_dmabuf(): CAPTURE rate=%d fmt=0x%x numfrag=%d "
1290 "fragsize=%d dmasize=%d\n",
1291 dmabuf->rate, dmabuf->fmt, dmabuf->numfrag,
1292 dmabuf->fragsize, dmabuf->dmasize) );
1294 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- 0 \n"));
1296 } else if (dmabuf->type == CS_TYPE_DAC) {
1300 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf() DAC\n"));
1301 spin_lock_irqsave(&state->card->lock, flags);
1302 resync_dma_ptrs(state);
1303 dmabuf->total_bytes = dmabuf->blocks = 0;
1304 dmabuf->count = dmabuf->error = dmabuf->underrun = 0;
1308 spin_unlock_irqrestore(&state->card->lock, flags);
1310 /* allocate DMA buffer if not allocated yet */
1311 if (!dmabuf->rawbuf)
1312 if ((ret = alloc_dmabuf(state)))
1315 allocated_pages = 1 << dmabuf->buforder;
1316 allocated_bytes = allocated_pages*PAGE_SIZE;
1318 if (allocated_pages < 2) {
1319 CS_DBGOUT(CS_FUNCTION, 4, printk(
1320 "cs46xx: prog_dmabuf() Error: allocated_pages too small (%d)\n",
1321 (unsigned)allocated_pages));
1325 /* Use all the pages allocated, fragsize 4k. */
1326 /* Use 'pbuf' for S/G page map table. */
1327 dmabuf->SGok = 1; /* Use S/G. */
1329 nSGpages = allocated_bytes/4096; /* S/G pages always 4k. */
1331 /* Set up S/G variables. */
1332 *ptmp = virt_to_bus(dmabuf->rawbuf);
1333 *(ptmp + 1) = 0x00000008;
1334 for (tmp1 = 1; tmp1 < nSGpages; tmp1++) {
1335 *(ptmp + 2 * tmp1) = virt_to_bus((dmabuf->rawbuf) + 4096 * tmp1);
1336 if (tmp1 == nSGpages - 1)
1339 tmp2 = 0x80000000 + 8 * (tmp1 + 1);
1340 *(ptmp + 2 * tmp1 + 1) = tmp2;
1342 SGarray[0] = 0x82c0200d;
1343 SGarray[1] = 0xffff0000;
1345 SGarray[3] = 0x00010600;
1346 SGarray[4] = *(ptmp+2);
1347 SGarray[5] = 0x80000010;
1349 SGarray[7] = *(ptmp+2);
1350 SGarray[8] = (virt_to_bus(dmabuf->pbuf) & 0xffff000) | 0x10;
1353 dmabuf->numfrag = nSGpages;
1354 dmabuf->fragsize = 4096;
1355 dmabuf->fragsamples = 4096 >> sample_shift[dmabuf->fmt];
1356 dmabuf->fragshift = 12;
1357 dmabuf->dmasize = dmabuf->numfrag * 4096;
1359 SGarray[0] = 0xf2c0000f;
1360 SGarray[1] = 0x00000200;
1362 SGarray[3] = 0x00010600;
1363 SGarray[4]=SGarray[5]=SGarray[6]=SGarray[7]=SGarray[8] = 0;
1364 dmabuf->numfrag = 2;
1365 dmabuf->fragsize = 2048;
1366 dmabuf->fragsamples = 2048 >> sample_shift[dmabuf->fmt];
1367 dmabuf->dmasize = 4096;
1368 dmabuf->fragshift = 11;
1370 for (tmp1 = 0; tmp1 < sizeof(SGarray) / 4; tmp1++)
1371 cs461x_poke(state->card, BA1_PDTC+tmp1 * 4, SGarray[tmp1]);
1373 memset(dmabuf->rawbuf, (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
1377 * Now set up the ring
1380 spin_lock_irqsave(&state->card->lock, flags);
1381 cs_play_setup(state);
1382 spin_unlock_irqrestore(&state->card->lock, flags);
1384 /* set the ready flag for the dma buffer */
1387 CS_DBGOUT(CS_PARMS, 4, printk(
1388 "cs46xx: prog_dmabuf(): PLAYBACK rate=%d fmt=0x%x numfrag=%d "
1389 "fragsize=%d dmasize=%d\n",
1390 dmabuf->rate, dmabuf->fmt, dmabuf->numfrag,
1391 dmabuf->fragsize, dmabuf->dmasize) );
1393 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- \n"));
1396 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: prog_dmabuf()- Invalid Type %d\n",
1402 static int prog_dmabuf(struct cs_state *state)
1406 mutex_lock(&state->sem);
1407 ret = __prog_dmabuf(state);
1408 mutex_unlock(&state->sem);
1413 static void cs_clear_tail(struct cs_state *state)
1417 static int drain_dac(struct cs_state *state, int nonblock)
1419 DECLARE_WAITQUEUE(wait, current);
1420 struct dmabuf *dmabuf = &state->dmabuf;
1421 struct cs_card *card=state->card;
1422 unsigned long flags;
1426 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()+ \n"));
1427 if (dmabuf->mapped || !dmabuf->ready)
1429 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()- 0, not ready\n"));
1433 add_wait_queue(&dmabuf->wait, &wait);
1435 /* It seems that we have to set the current state to TASK_INTERRUPTIBLE
1436 every time to make the process really go to sleep */
1437 current->state = TASK_INTERRUPTIBLE;
1439 spin_lock_irqsave(&state->card->lock, flags);
1440 count = dmabuf->count;
1441 spin_unlock_irqrestore(&state->card->lock, flags);
1446 if (signal_pending(current))
1450 remove_wait_queue(&dmabuf->wait, &wait);
1451 current->state = TASK_RUNNING;
1455 tmo = (dmabuf->dmasize * HZ) / dmabuf->rate;
1456 tmo >>= sample_shift[dmabuf->fmt];
1457 tmo += (2048*HZ)/dmabuf->rate;
1459 if (!schedule_timeout(tmo ? tmo : 1) && tmo){
1460 printk(KERN_ERR "cs46xx: drain_dac, dma timeout? %d\n", count);
1464 remove_wait_queue(&dmabuf->wait, &wait);
1465 current->state = TASK_RUNNING;
1466 if (signal_pending(current)) {
1467 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()- -ERESTARTSYS\n"));
1469 * set to silence and let that clear the fifos.
1471 cs461x_clear_serial_FIFOs(card, CS_TYPE_DAC);
1472 return -ERESTARTSYS;
1475 CS_DBGOUT(CS_FUNCTION, 4, printk("cs46xx: drain_dac()- 0\n"));
1480 /* update buffer manangement pointers, especially, dmabuf->count and dmabuf->hwptr */
1481 static void cs_update_ptr(struct cs_card *card, int wake)
1483 struct cs_state *state;
1484 struct dmabuf *dmabuf;
1488 /* error handling and process wake up for ADC */
1489 state = card->states[0];
1491 dmabuf = &state->dmabuf;
1492 if (dmabuf->enable & ADC_RUNNING) {
1493 /* update hardware pointer */
1494 hwptr = cs_get_dma_addr(state);
1496 diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1497 CS_DBGOUT(CS_PARMS, 9, printk(
1498 "cs46xx: cs_update_ptr()+ ADC hwptr=%d diff=%d\n",
1500 dmabuf->hwptr = hwptr;
1501 dmabuf->total_bytes += diff;
1502 dmabuf->count += diff;
1503 if (dmabuf->count > dmabuf->dmasize)
1504 dmabuf->count = dmabuf->dmasize;
1506 if (dmabuf->mapped) {
1507 if (wake && dmabuf->count >= (signed)dmabuf->fragsize)
1508 wake_up(&dmabuf->wait);
1510 if (wake && dmabuf->count > 0)
1511 wake_up(&dmabuf->wait);
1519 state = card->states[1];
1521 dmabuf = &state->dmabuf;
1522 /* error handling and process wake up for DAC */
1523 if (dmabuf->enable & DAC_RUNNING) {
1524 /* update hardware pointer */
1525 hwptr = cs_get_dma_addr(state);
1527 diff = (dmabuf->dmasize + hwptr - dmabuf->hwptr) % dmabuf->dmasize;
1528 CS_DBGOUT(CS_PARMS, 9, printk(
1529 "cs46xx: cs_update_ptr()+ DAC hwptr=%d diff=%d\n",
1531 dmabuf->hwptr = hwptr;
1532 dmabuf->total_bytes += diff;
1533 if (dmabuf->mapped) {
1534 dmabuf->count += diff;
1535 if (wake && dmabuf->count >= (signed)dmabuf->fragsize)
1536 wake_up(&dmabuf->wait);
1538 * other drivers use fragsize, but don't see any sense
1539 * in that, since dmasize is the buffer asked for
1542 if (dmabuf->count > dmabuf->dmasize)
1543 dmabuf->count &= dmabuf->dmasize-1;
1545 dmabuf->count -= diff;
1547 * backfill with silence and clear out the last
1548 * "diff" number of bytes.
1550 if (hwptr >= diff) {
1551 memset(dmabuf->rawbuf + hwptr - diff,
1552 (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80, diff);
1554 memset(dmabuf->rawbuf,
1555 (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
1557 memset((char *)dmabuf->rawbuf +
1558 dmabuf->dmasize + hwptr - diff,
1559 (dmabuf->fmt & CS_FMT_16BIT) ? 0 : 0x80,
1563 if (dmabuf->count < 0 || dmabuf->count > dmabuf->dmasize) {
1564 CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
1565 "cs46xx: ERROR DAC count<0 or count > dmasize (%d)\n",
1568 * buffer underrun or buffer overrun, reset the
1569 * count of bytes written back to 0.
1571 if (dmabuf->count < 0)
1572 dmabuf->underrun = 1;
1576 if (wake && dmabuf->count < (signed)dmabuf->dmasize / 2)
1577 wake_up(&dmabuf->wait);
1584 /* hold spinlock for the following! */
1585 static void cs_handle_midi(struct cs_card *card)
1592 while (!(cs461x_peekBA0(card, BA0_MIDSR) & MIDSR_RBE)) {
1593 ch = cs461x_peekBA0(card, BA0_MIDRP);
1594 if (card->midi.icnt < CS_MIDIINBUF) {
1595 card->midi.ibuf[card->midi.iwr] = ch;
1596 card->midi.iwr = (card->midi.iwr + 1) % CS_MIDIINBUF;
1602 wake_up(&card->midi.iwait);
1604 while (!(cs461x_peekBA0(card, BA0_MIDSR) & MIDSR_TBF) && card->midi.ocnt > 0) {
1605 temp1 = ( card->midi.obuf[card->midi.ord] ) & 0x000000ff;
1606 cs461x_pokeBA0(card, BA0_MIDWP,temp1);
1607 card->midi.ord = (card->midi.ord + 1) % CS_MIDIOUTBUF;
1609 if (card->midi.ocnt < CS_MIDIOUTBUF-16)
1613 wake_up(&card->midi.owait);
1616 static irqreturn_t cs_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1618 struct cs_card *card = (struct cs_card *)dev_id;
1619 /* Single channel card */
1620 struct cs_state *recstate = card->channel[0].state;
1621 struct cs_state *playstate = card->channel[1].state;
1624 CS_DBGOUT(CS_INTERRUPT, 9, printk("cs46xx: cs_interrupt()+ \n"));
1626 spin_lock(&card->lock);
1628 status = cs461x_peekBA0(card, BA0_HISR);
1630 if ((status & 0x7fffffff) == 0) {
1631 cs461x_pokeBA0(card, BA0_HICR, HICR_CHGM|HICR_IEV);
1632 spin_unlock(&card->lock);
1633 return IRQ_HANDLED; /* Might be IRQ_NONE.. */
1637 * check for playback or capture interrupt only
1639 if (((status & HISR_VC0) && playstate && playstate->dmabuf.ready) ||
1640 (((status & HISR_VC1) && recstate && recstate->dmabuf.ready))) {
1641 CS_DBGOUT(CS_INTERRUPT, 8, printk(
1642 "cs46xx: cs_interrupt() interrupt bit(s) set (0x%x)\n",status));
1643 cs_update_ptr(card, CS_TRUE);
1646 if (status & HISR_MIDI)
1647 cs_handle_midi(card);
1650 cs461x_pokeBA0(card, BA0_HICR, HICR_CHGM|HICR_IEV);
1651 spin_unlock(&card->lock);
1652 CS_DBGOUT(CS_INTERRUPT, 9, printk("cs46xx: cs_interrupt()- \n"));
1657 /**********************************************************************/
1659 static ssize_t cs_midi_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
1661 struct cs_card *card = file->private_data;
1663 unsigned long flags;
1667 if (!access_ok(VERIFY_WRITE, buffer, count))
1671 spin_lock_irqsave(&card->lock, flags);
1672 ptr = card->midi.ird;
1673 cnt = CS_MIDIINBUF - ptr;
1674 if (card->midi.icnt < cnt)
1675 cnt = card->midi.icnt;
1676 spin_unlock_irqrestore(&card->lock, flags);
1680 if (file->f_flags & O_NONBLOCK)
1681 return ret ? ret : -EAGAIN;
1682 interruptible_sleep_on(&card->midi.iwait);
1683 if (signal_pending(current))
1684 return ret ? ret : -ERESTARTSYS;
1687 if (copy_to_user(buffer, card->midi.ibuf + ptr, cnt))
1688 return ret ? ret : -EFAULT;
1689 ptr = (ptr + cnt) % CS_MIDIINBUF;
1690 spin_lock_irqsave(&card->lock, flags);
1691 card->midi.ird = ptr;
1692 card->midi.icnt -= cnt;
1693 spin_unlock_irqrestore(&card->lock, flags);
1702 static ssize_t cs_midi_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
1704 struct cs_card *card = file->private_data;
1706 unsigned long flags;
1710 if (!access_ok(VERIFY_READ, buffer, count))
1714 spin_lock_irqsave(&card->lock, flags);
1715 ptr = card->midi.owr;
1716 cnt = CS_MIDIOUTBUF - ptr;
1717 if (card->midi.ocnt + cnt > CS_MIDIOUTBUF)
1718 cnt = CS_MIDIOUTBUF - card->midi.ocnt;
1720 cs_handle_midi(card);
1721 spin_unlock_irqrestore(&card->lock, flags);
1725 if (file->f_flags & O_NONBLOCK)
1726 return ret ? ret : -EAGAIN;
1727 interruptible_sleep_on(&card->midi.owait);
1728 if (signal_pending(current))
1729 return ret ? ret : -ERESTARTSYS;
1732 if (copy_from_user(card->midi.obuf + ptr, buffer, cnt))
1733 return ret ? ret : -EFAULT;
1734 ptr = (ptr + cnt) % CS_MIDIOUTBUF;
1735 spin_lock_irqsave(&card->lock, flags);
1736 card->midi.owr = ptr;
1737 card->midi.ocnt += cnt;
1738 spin_unlock_irqrestore(&card->lock, flags);
1742 spin_lock_irqsave(&card->lock, flags);
1743 cs_handle_midi(card);
1744 spin_unlock_irqrestore(&card->lock, flags);
1750 static unsigned int cs_midi_poll(struct file *file, struct poll_table_struct *wait)
1752 struct cs_card *card = file->private_data;
1753 unsigned long flags;
1754 unsigned int mask = 0;
1756 if (file->f_flags & FMODE_WRITE)
1757 poll_wait(file, &card->midi.owait, wait);
1758 if (file->f_flags & FMODE_READ)
1759 poll_wait(file, &card->midi.iwait, wait);
1760 spin_lock_irqsave(&card->lock, flags);
1761 if (file->f_flags & FMODE_READ) {
1762 if (card->midi.icnt > 0)
1763 mask |= POLLIN | POLLRDNORM;
1765 if (file->f_flags & FMODE_WRITE) {
1766 if (card->midi.ocnt < CS_MIDIOUTBUF)
1767 mask |= POLLOUT | POLLWRNORM;
1769 spin_unlock_irqrestore(&card->lock, flags);
1774 static int cs_midi_open(struct inode *inode, struct file *file)
1776 unsigned int minor = iminor(inode);
1777 struct cs_card *card = NULL;
1778 unsigned long flags;
1779 struct list_head *entry;
1781 list_for_each(entry, &cs46xx_devs) {
1782 card = list_entry(entry, struct cs_card, list);
1783 if (card->dev_midi == minor)
1787 if (entry == &cs46xx_devs)
1790 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 2, printk(KERN_INFO
1791 "cs46xx: cs46xx_midi_open(): Error - unable to find card struct\n"));
1795 file->private_data = card;
1796 /* wait for device to become free */
1797 mutex_lock(&card->midi.open_mutex);
1798 while (card->midi.open_mode & file->f_mode) {
1799 if (file->f_flags & O_NONBLOCK) {
1800 mutex_unlock(&card->midi.open_mutex);
1803 mutex_unlock(&card->midi.open_mutex);
1804 interruptible_sleep_on(&card->midi.open_wait);
1805 if (signal_pending(current))
1806 return -ERESTARTSYS;
1807 mutex_lock(&card->midi.open_mutex);
1809 spin_lock_irqsave(&card->midi.lock, flags);
1810 if (!(card->midi.open_mode & (FMODE_READ | FMODE_WRITE))) {
1811 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
1812 card->midi.ord = card->midi.owr = card->midi.ocnt = 0;
1813 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
1814 cs461x_pokeBA0(card, BA0_MIDCR, 0x0000000f); /* Enable xmit, rcv. */
1815 cs461x_pokeBA0(card, BA0_HICR, HICR_IEV | HICR_CHGM); /* Enable interrupts */
1817 if (file->f_mode & FMODE_READ)
1818 card->midi.ird = card->midi.iwr = card->midi.icnt = 0;
1819 if (file->f_mode & FMODE_WRITE)
1820 card->midi.ord = card->midi.owr = card->midi.ocnt = 0;
1821 spin_unlock_irqrestore(&card->midi.lock, flags);
1822 card->midi.open_mode |= (file->f_mode & (FMODE_READ | FMODE_WRITE));
1823 mutex_unlock(&card->midi.open_mutex);
1828 static int cs_midi_release(struct inode *inode, struct file *file)
1830 struct cs_card *card = file->private_data;
1831 DECLARE_WAITQUEUE(wait, current);
1832 unsigned long flags;
1833 unsigned count, tmo;
1835 if (file->f_mode & FMODE_WRITE) {
1836 current->state = TASK_INTERRUPTIBLE;
1837 add_wait_queue(&card->midi.owait, &wait);
1839 spin_lock_irqsave(&card->midi.lock, flags);
1840 count = card->midi.ocnt;
1841 spin_unlock_irqrestore(&card->midi.lock, flags);
1844 if (signal_pending(current))
1846 if (file->f_flags & O_NONBLOCK)
1848 tmo = (count * HZ) / 3100;
1849 if (!schedule_timeout(tmo ? : 1) && tmo)
1850 printk(KERN_DEBUG "cs46xx: midi timed out??\n");
1852 remove_wait_queue(&card->midi.owait, &wait);
1853 current->state = TASK_RUNNING;
1855 mutex_lock(&card->midi.open_mutex);
1856 card->midi.open_mode &= (~(file->f_mode & (FMODE_READ | FMODE_WRITE)));
1857 mutex_unlock(&card->midi.open_mutex);
1858 wake_up(&card->midi.open_wait);
1863 * Midi file operations struct.
1865 static /*const*/ struct file_operations cs_midi_fops = {
1866 CS_OWNER CS_THIS_MODULE
1867 .llseek = no_llseek,
1868 .read = cs_midi_read,
1869 .write = cs_midi_write,
1870 .poll = cs_midi_poll,
1871 .open = cs_midi_open,
1872 .release = cs_midi_release,
1877 * CopySamples copies 16-bit stereo signed samples from the source to the
1878 * destination, possibly converting down to unsigned 8-bit and/or mono.
1879 * count specifies the number of output bytes to write.
1883 * dst - Pointer to a destination buffer.
1884 * src - Pointer to a source buffer
1885 * count - The number of bytes to copy into the destination buffer.
1886 * fmt - CS_FMT_16BIT and/or CS_FMT_STEREO bits
1887 * dmabuf - pointer to the dma buffer structure
1889 * NOTES: only call this routine if the output desired is not 16 Signed Stereo
1893 static void CopySamples(char *dst, char *src, int count, unsigned fmt,
1894 struct dmabuf *dmabuf)
1897 s16 *psSrc = (s16 *)src;
1898 s16 *psDst = (s16 *)dst;
1899 u8 *pucDst = (u8 *)dst;
1901 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO "cs46xx: CopySamples()+ ") );
1902 CS_DBGOUT(CS_WAVE_READ, 8, printk(KERN_INFO
1903 " dst=%p src=%p count=%d fmt=0x%x\n",
1904 dst,src,count,fmt) );
1907 * See if the data should be output as 8-bit unsigned stereo.
1909 if ((fmt & CS_FMT_STEREO) && !(fmt & CS_FMT_16BIT)) {
1911 * Convert each 16-bit signed stereo sample to 8-bit unsigned
1912 * stereo using rounding.
1917 *(pucDst++) = (u8)(((s16)(*psSrc++) + (s16)0x8000) >> 8);
1920 * See if the data should be output at 8-bit unsigned mono.
1922 else if (!(fmt & CS_FMT_STEREO) && !(fmt & CS_FMT_16BIT)) {
1924 * Convert each 16-bit signed stereo sample to 8-bit unsigned
1925 * mono using averaging and rounding.
1930 s32AudioSample = ((*psSrc) + (*(psSrc + 1))) / 2 + (s32)0x80;
1931 if (s32AudioSample > 0x7fff)
1932 s32AudioSample = 0x7fff;
1933 *(pucDst++) = (u8)(((s16)s32AudioSample + (s16)0x8000) >> 8);
1938 * See if the data should be output at 16-bit signed mono.
1940 else if (!(fmt & CS_FMT_STEREO) && (fmt & CS_FMT_16BIT)) {
1942 * Convert each 16-bit signed stereo sample to 16-bit signed
1943 * mono using averaging.
1948 *(psDst++) = (s16)((*psSrc) + (*(psSrc + 1))) / 2;
1956 * replacement for the standard copy_to_user, to allow for a conversion from
1957 * 16 bit to 8 bit and from stereo to mono, if the record conversion is active.
1958 * The current CS46xx/CS4280 static image only records in 16bit unsigned Stereo,
1959 * so we convert from any of the other format combinations.
1961 static unsigned cs_copy_to_user(
1968 struct dmabuf *dmabuf = &s->dmabuf;
1969 void *src = hwsrc; /* default to the standard destination buffer addr */
1971 CS_DBGOUT(CS_FUNCTION, 6, printk(KERN_INFO
1972 "cs_copy_to_user()+ fmt=0x%x cnt=%d dest=%p\n",
1973 dmabuf->fmt,(unsigned)cnt,dest) );
1975 if (cnt > dmabuf->dmasize)
1976 cnt = dmabuf->dmasize;
1981 if (dmabuf->divisor != 1) {
1982 if (!dmabuf->tmpbuff) {
1983 *copied = cnt / dmabuf->divisor;
1987 CopySamples((char *)dmabuf->tmpbuff, (char *)hwsrc, cnt,
1988 dmabuf->fmt, dmabuf);
1989 src = dmabuf->tmpbuff;
1990 cnt = cnt/dmabuf->divisor;
1992 if (copy_to_user(dest, src, cnt)) {
1993 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_ERR
1994 "cs46xx: cs_copy_to_user()- fault dest=%p src=%p cnt=%d\n",
2000 CS_DBGOUT(CS_FUNCTION, 2, printk(KERN_INFO
2001 "cs46xx: cs_copy_to_user()- copied bytes is %d \n",cnt));
2005 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be copied to
2006 the user's buffer. it is filled by the dma machine and drained by this loop. */
2007 static ssize_t cs_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
2009 struct cs_card *card = file->private_data;
2010 struct cs_state *state;
2011 DECLARE_WAITQUEUE(wait, current);
2012 struct dmabuf *dmabuf;
2014 unsigned long flags;
2017 unsigned copied = 0;
2019 CS_DBGOUT(CS_WAVE_READ | CS_FUNCTION, 4,
2020 printk("cs46xx: cs_read()+ %zd\n",count) );
2021 state = card->states[0];
2024 dmabuf = &state->dmabuf;
2028 if (!access_ok(VERIFY_WRITE, buffer, count))
2031 mutex_lock(&state->sem);
2032 if (!dmabuf->ready && (ret = __prog_dmabuf(state)))
2035 add_wait_queue(&state->dmabuf.wait, &wait);
2037 while (!(card->pm.flags & CS46XX_PM_IDLE)) {
2039 if (signal_pending(current)) {
2045 spin_lock_irqsave(&state->card->lock, flags);
2046 swptr = dmabuf->swptr;
2047 cnt = dmabuf->dmasize - swptr;
2048 if (dmabuf->count < cnt)
2049 cnt = dmabuf->count;
2051 __set_current_state(TASK_INTERRUPTIBLE);
2052 spin_unlock_irqrestore(&state->card->lock, flags);
2054 if (cnt > (count * dmabuf->divisor))
2055 cnt = count * dmabuf->divisor;
2057 /* buffer is empty, start the dma machine and wait for data to be
2060 if (file->f_flags & O_NONBLOCK) {
2065 mutex_unlock(&state->sem);
2067 if (signal_pending(current)) {
2072 mutex_lock(&state->sem);
2073 if (dmabuf->mapped) {
2081 CS_DBGOUT(CS_WAVE_READ, 2, printk(KERN_INFO
2082 "_read() copy_to cnt=%d count=%zd ", cnt,count) );
2083 CS_DBGOUT(CS_WAVE_READ, 8, printk(KERN_INFO
2084 " .dmasize=%d .count=%d buffer=%p ret=%zd\n",
2085 dmabuf->dmasize,dmabuf->count,buffer,ret));
2087 if (cs_copy_to_user(state, buffer,
2088 (char *)dmabuf->rawbuf + swptr, cnt, &copied)) {
2093 swptr = (swptr + cnt) % dmabuf->dmasize;
2094 spin_lock_irqsave(&card->lock, flags);
2095 dmabuf->swptr = swptr;
2096 dmabuf->count -= cnt;
2097 spin_unlock_irqrestore(&card->lock, flags);
2104 remove_wait_queue(&state->dmabuf.wait, &wait);
2106 mutex_unlock(&state->sem);
2107 set_current_state(TASK_RUNNING);
2108 CS_DBGOUT(CS_WAVE_READ | CS_FUNCTION, 4,
2109 printk("cs46xx: cs_read()- %zd\n",ret) );
2113 /* in this loop, dmabuf.count signifies the amount of data that is waiting to be dma to
2114 the soundcard. it is drained by the dma machine and filled by this loop. */
2115 static ssize_t cs_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
2117 struct cs_card *card = file->private_data;
2118 struct cs_state *state;
2119 DECLARE_WAITQUEUE(wait, current);
2120 struct dmabuf *dmabuf;
2122 unsigned long flags;
2126 CS_DBGOUT(CS_WAVE_WRITE | CS_FUNCTION, 4,
2127 printk("cs46xx: cs_write called, count = %zd\n", count) );
2128 state = card->states[1];
2131 if (!access_ok(VERIFY_READ, buffer, count))
2133 dmabuf = &state->dmabuf;
2135 mutex_lock(&state->sem);
2136 if (dmabuf->mapped) {
2141 if (!dmabuf->ready && (ret = __prog_dmabuf(state)))
2143 add_wait_queue(&state->dmabuf.wait, &wait);
2146 * Start the loop to read from the user's buffer and write to the dma buffer.
2147 * check for PM events and underrun/overrun in the loop.
2150 while (!(card->pm.flags & CS46XX_PM_IDLE)) {
2152 if (signal_pending(current)) {
2158 spin_lock_irqsave(&state->card->lock, flags);
2159 if (dmabuf->count < 0) {
2160 /* buffer underrun, we are recovering from sleep_on_timeout,
2161 resync hwptr and swptr */
2163 dmabuf->swptr = dmabuf->hwptr;
2165 if (dmabuf->underrun) {
2166 dmabuf->underrun = 0;
2167 dmabuf->hwptr = cs_get_dma_addr(state);
2168 dmabuf->swptr = dmabuf->hwptr;
2171 swptr = dmabuf->swptr;
2172 cnt = dmabuf->dmasize - swptr;
2173 if (dmabuf->count + cnt > dmabuf->dmasize)
2174 cnt = dmabuf->dmasize - dmabuf->count;
2176 __set_current_state(TASK_INTERRUPTIBLE);
2177 spin_unlock_irqrestore(&state->card->lock, flags);
2182 /* buffer is full, start the dma machine and wait for data to be
2185 if (file->f_flags & O_NONBLOCK) {
2190 mutex_unlock(&state->sem);
2192 if (signal_pending(current)) {
2197 mutex_lock(&state->sem);
2198 if (dmabuf->mapped) {
2205 if (copy_from_user(dmabuf->rawbuf + swptr, buffer, cnt)) {
2210 spin_lock_irqsave(&state->card->lock, flags);
2211 swptr = (swptr + cnt) % dmabuf->dmasize;
2212 dmabuf->swptr = swptr;
2213 dmabuf->count += cnt;
2214 if (dmabuf->count > dmabuf->dmasize) {
2215 CS_DBGOUT(CS_WAVE_WRITE | CS_ERROR, 2, printk(
2216 "cs46xx: cs_write() d->count > dmasize - resetting\n"));
2217 dmabuf->count = dmabuf->dmasize;
2219 dmabuf->endcleared = 0;
2220 spin_unlock_irqrestore(&state->card->lock, flags);
2228 mutex_unlock(&state->sem);
2229 remove_wait_queue(&state->dmabuf.wait, &wait);
2230 set_current_state(TASK_RUNNING);
2232 CS_DBGOUT(CS_WAVE_WRITE | CS_FUNCTION, 2,
2233 printk("cs46xx: cs_write()- ret=%zd\n", ret));
2237 static unsigned int cs_poll(struct file *file, struct poll_table_struct *wait)
2239 struct cs_card *card = file->private_data;
2240 struct dmabuf *dmabuf;
2241 struct cs_state *state;
2242 unsigned long flags;
2243 unsigned int mask = 0;
2245 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_poll()+ \n"));
2246 if (!(file->f_mode & (FMODE_WRITE | FMODE_READ))) {
2249 if (file->f_mode & FMODE_WRITE) {
2250 state = card->states[1];
2252 dmabuf = &state->dmabuf;
2253 poll_wait(file, &dmabuf->wait, wait);
2256 if (file->f_mode & FMODE_READ) {
2257 state = card->states[0];
2259 dmabuf = &state->dmabuf;
2260 poll_wait(file, &dmabuf->wait, wait);
2264 spin_lock_irqsave(&card->lock, flags);
2265 cs_update_ptr(card, CS_FALSE);
2266 if (file->f_mode & FMODE_READ) {
2267 state = card->states[0];
2269 dmabuf = &state->dmabuf;
2270 if (dmabuf->count >= (signed)dmabuf->fragsize)
2271 mask |= POLLIN | POLLRDNORM;
2274 if (file->f_mode & FMODE_WRITE) {
2275 state = card->states[1];
2277 dmabuf = &state->dmabuf;
2278 if (dmabuf->mapped) {
2279 if (dmabuf->count >= (signed)dmabuf->fragsize)
2280 mask |= POLLOUT | POLLWRNORM;
2282 if ((signed)dmabuf->dmasize >= dmabuf->count
2283 + (signed)dmabuf->fragsize)
2284 mask |= POLLOUT | POLLWRNORM;
2288 spin_unlock_irqrestore(&card->lock, flags);
2290 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_poll()- (0x%x) \n",
2296 * We let users mmap the ring buffer. Its not the real DMA buffer but
2297 * that side of the code is hidden in the IRQ handling. We do a software
2298 * emulation of DMA from a 64K or so buffer into a 2K FIFO.
2299 * (the hardware probably deserves a moan here but Crystal send me nice
2303 static int cs_mmap(struct file *file, struct vm_area_struct *vma)
2305 struct cs_card *card = file->private_data;
2306 struct cs_state *state;
2307 struct dmabuf *dmabuf;
2311 CS_DBGOUT(CS_FUNCTION | CS_PARMS, 2, printk("cs46xx: cs_mmap()+ file=%p %s %s\n",
2312 file, vma->vm_flags & VM_WRITE ? "VM_WRITE" : "",
2313 vma->vm_flags & VM_READ ? "VM_READ" : "") );
2315 if (vma->vm_flags & VM_WRITE) {
2316 state = card->states[1];
2318 CS_DBGOUT(CS_OPEN, 2, printk(
2319 "cs46xx: cs_mmap() VM_WRITE - state TRUE prog_dmabuf DAC\n") );
2320 if ((ret = prog_dmabuf(state)) != 0)
2323 } else if (vma->vm_flags & VM_READ) {
2324 state = card->states[0];
2326 CS_DBGOUT(CS_OPEN, 2, printk(
2327 "cs46xx: cs_mmap() VM_READ - state TRUE prog_dmabuf ADC\n") );
2328 if ((ret = prog_dmabuf(state)) != 0)
2332 CS_DBGOUT(CS_ERROR, 2, printk(
2333 "cs46xx: cs_mmap() return -EINVAL\n") );
2338 * For now ONLY support playback, but seems like the only way to use
2339 * mmap() is to open an FD with RDWR, just read or just write access
2340 * does not function, get an error back from the kernel.
2341 * Also, QuakeIII opens with RDWR! So, there must be something
2342 * to needing read/write access mapping. So, allow read/write but
2345 state = card->states[1];
2351 mutex_lock(&state->sem);
2352 dmabuf = &state->dmabuf;
2353 if (cs4x_pgoff(vma) != 0) {
2357 size = vma->vm_end - vma->vm_start;
2359 CS_DBGOUT(CS_PARMS, 2, printk("cs46xx: cs_mmap(): size=%d\n",(unsigned)size) );
2361 if (size > (PAGE_SIZE << dmabuf->buforder)) {
2365 if (remap_pfn_range(vma, vma->vm_start,
2366 virt_to_phys(dmabuf->rawbuf) >> PAGE_SHIFT,
2367 size, vma->vm_page_prot)) {
2373 CS_DBGOUT(CS_FUNCTION, 2, printk("cs46xx: cs_mmap()-\n") );
2375 mutex_unlock(&state->sem);
2379 static int cs_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
2381 struct cs_card *card = file->private_data;
2382 struct cs_state *state;
2383 struct dmabuf *dmabuf = NULL;
2384 unsigned long flags;
2385 audio_buf_info abinfo;
2387 int val, valsave, ret;
2389 void __user *argp = (void __user *)arg;
2390 int __user *p = argp;
2392 state = card->states[0];
2394 dmabuf = &state->dmabuf;
2395 mapped = (file->f_mode & FMODE_READ) && dmabuf->mapped;
2397 state = card->states[1];
2399 dmabuf = &state->dmabuf;
2400 mapped |= (file->f_mode & FMODE_WRITE) && dmabuf->mapped;
2408 case OSS_GETVERSION:
2409 return put_user(SOUND_VERSION, p);
2410 case SNDCTL_DSP_RESET:
2411 /* FIXME: spin_lock ? */
2412 if (file->f_mode & FMODE_WRITE) {
2413 state = card->states[1];
2415 dmabuf = &state->dmabuf;
2417 synchronize_irq(card->irq);
2419 resync_dma_ptrs(state);
2420 dmabuf->swptr = dmabuf->hwptr = 0;
2421 dmabuf->count = dmabuf->total_bytes = 0;
2426 if (file->f_mode & FMODE_READ) {
2427 state = card->states[0];
2429 dmabuf = &state->dmabuf;
2431 synchronize_irq(card->irq);
2432 resync_dma_ptrs(state);
2434 dmabuf->swptr = dmabuf->hwptr = 0;
2435 dmabuf->count = dmabuf->total_bytes = 0;
2440 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_RESET()-\n") );
2442 case SNDCTL_DSP_SYNC:
2443 if (file->f_mode & FMODE_WRITE)
2444 return drain_dac(state, file->f_flags & O_NONBLOCK);
2446 case SNDCTL_DSP_SPEED: /* set sample rate */
2447 if (get_user(val, p))
2450 if (file->f_mode & FMODE_READ) {
2451 state = card->states[0];
2453 dmabuf = &state->dmabuf;
2457 cs_set_adc_rate(state, val);
2458 cs_set_divisor(dmabuf);
2461 if (file->f_mode & FMODE_WRITE) {
2462 state = card->states[1];
2464 dmabuf = &state->dmabuf;
2468 cs_set_dac_rate(state, val);
2469 cs_set_divisor(dmabuf);
2472 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2473 "cs46xx: cs_ioctl() DSP_SPEED %s %s %d\n",
2474 file->f_mode & FMODE_WRITE ? "DAC" : "",
2475 file->f_mode & FMODE_READ ? "ADC" : "",
2477 return put_user(dmabuf->rate, p);
2479 return put_user(0, p);
2480 case SNDCTL_DSP_STEREO: /* set stereo or mono channel */
2481 if (get_user(val, p))
2483 if (file->f_mode & FMODE_WRITE) {
2484 state = card->states[1];
2486 dmabuf = &state->dmabuf;
2491 dmabuf->fmt |= CS_FMT_STEREO;
2493 dmabuf->fmt &= ~CS_FMT_STEREO;
2494 cs_set_divisor(dmabuf);
2495 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2496 "cs46xx: DSP_STEREO() DAC %s\n",
2497 (dmabuf->fmt & CS_FMT_STEREO) ?
2501 if (file->f_mode & FMODE_READ) {
2502 state = card->states[0];
2504 dmabuf = &state->dmabuf;
2509 dmabuf->fmt |= CS_FMT_STEREO;
2511 dmabuf->fmt &= ~CS_FMT_STEREO;
2512 cs_set_divisor(dmabuf);
2513 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2514 "cs46xx: DSP_STEREO() ADC %s\n",
2515 (dmabuf->fmt & CS_FMT_STEREO) ?
2520 case SNDCTL_DSP_GETBLKSIZE:
2521 if (file->f_mode & FMODE_WRITE) {
2522 state = card->states[1];
2524 dmabuf = &state->dmabuf;
2525 if ((val = prog_dmabuf(state)))
2527 return put_user(dmabuf->fragsize, p);
2530 if (file->f_mode & FMODE_READ) {
2531 state = card->states[0];
2533 dmabuf = &state->dmabuf;
2534 if ((val = prog_dmabuf(state)))
2536 return put_user(dmabuf->fragsize/dmabuf->divisor,
2540 return put_user(0, p);
2541 case SNDCTL_DSP_GETFMTS: /* Returns a mask of supported sample format*/
2542 return put_user(AFMT_S16_LE | AFMT_U8, p);
2543 case SNDCTL_DSP_SETFMT: /* Select sample format */
2544 if (get_user(val, p))
2546 CS_DBGOUT(CS_IOCTL | CS_PARMS, 4, printk(
2547 "cs46xx: cs_ioctl() DSP_SETFMT %s %s %s %s\n",
2548 file->f_mode & FMODE_WRITE ? "DAC" : "",
2549 file->f_mode & FMODE_READ ? "ADC" : "",
2550 val == AFMT_S16_LE ? "16Bit Signed" : "",
2551 val == AFMT_U8 ? "8Bit Unsigned" : "") );
2553 if (val != AFMT_QUERY) {
2554 if (val==AFMT_S16_LE || val==AFMT_U8) {
2555 if (file->f_mode & FMODE_WRITE) {
2556 state = card->states[1];
2558 dmabuf = &state->dmabuf;
2562 if (val == AFMT_S16_LE)
2563 dmabuf->fmt |= CS_FMT_16BIT;
2565 dmabuf->fmt &= ~CS_FMT_16BIT;
2566 cs_set_divisor(dmabuf);
2567 if ((ret = prog_dmabuf(state)))
2571 if (file->f_mode & FMODE_READ) {
2573 state = card->states[0];
2575 dmabuf = &state->dmabuf;
2579 if (val == AFMT_S16_LE)
2580 dmabuf->fmt |= CS_FMT_16BIT;
2582 dmabuf->fmt &= ~CS_FMT_16BIT;
2583 cs_set_divisor(dmabuf);
2584 if ((ret = prog_dmabuf(state)))
2589 CS_DBGOUT(CS_IOCTL | CS_ERROR, 2, printk(
2590 "cs46xx: DSP_SETFMT() Unsupported format (0x%x)\n",
2594 if (file->f_mode & FMODE_WRITE) {
2595 state = card->states[1];
2597 dmabuf = &state->dmabuf;
2598 } else if (file->f_mode & FMODE_READ) {
2599 state = card->states[0];
2601 dmabuf = &state->dmabuf;
2605 if (dmabuf->fmt & CS_FMT_16BIT)
2606 return put_user(AFMT_S16_LE, p);
2608 return put_user(AFMT_U8, p);
2610 return put_user(0, p);
2611 case SNDCTL_DSP_CHANNELS:
2612 if (get_user(val, p))
2615 if (file->f_mode & FMODE_WRITE) {
2616 state = card->states[1];
2618 dmabuf = &state->dmabuf;
2623 dmabuf->fmt |= CS_FMT_STEREO;
2625 dmabuf->fmt &= ~CS_FMT_STEREO;
2626 cs_set_divisor(dmabuf);
2627 if (prog_dmabuf(state))
2631 if (file->f_mode & FMODE_READ) {
2632 state = card->states[0];
2634 dmabuf = &state->dmabuf;
2639 dmabuf->fmt |= CS_FMT_STEREO;
2641 dmabuf->fmt &= ~CS_FMT_STEREO;
2642 cs_set_divisor(dmabuf);
2643 if (prog_dmabuf(state))
2648 return put_user((dmabuf->fmt & CS_FMT_STEREO) ? 2 : 1,
2650 case SNDCTL_DSP_POST:
2652 * There will be a longer than normal pause in the data.
2653 * so... do nothing, because there is nothing that we can do.
2656 case SNDCTL_DSP_SUBDIVIDE:
2657 if (file->f_mode & FMODE_WRITE) {
2658 state = card->states[1];
2660 dmabuf = &state->dmabuf;
2661 if (dmabuf->subdivision)
2663 if (get_user(val, p))
2665 if (val != 1 && val != 2)
2667 dmabuf->subdivision = val;
2670 if (file->f_mode & FMODE_READ) {
2671 state = card->states[0];
2673 dmabuf = &state->dmabuf;
2674 if (dmabuf->subdivision)
2676 if (get_user(val, p))
2678 if (val != 1 && val != 2)
2680 dmabuf->subdivision = val;
2684 case SNDCTL_DSP_SETFRAGMENT:
2685 if (get_user(val, p))
2687 if (file->f_mode & FMODE_WRITE) {
2688 state = card->states[1];
2690 dmabuf = &state->dmabuf;
2691 dmabuf->ossfragshift = val & 0xffff;
2692 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2695 if (file->f_mode & FMODE_READ) {
2696 state = card->states[0];
2698 dmabuf = &state->dmabuf;
2699 dmabuf->ossfragshift = val & 0xffff;
2700 dmabuf->ossmaxfrags = (val >> 16) & 0xffff;
2704 case SNDCTL_DSP_GETOSPACE:
2705 if (!(file->f_mode & FMODE_WRITE))
2707 state = card->states[1];
2709 dmabuf = &state->dmabuf;
2710 spin_lock_irqsave(&state->card->lock, flags);
2711 cs_update_ptr(card, CS_TRUE);
2712 abinfo.fragsize = dmabuf->fragsize;
2713 abinfo.fragstotal = dmabuf->numfrag;
2715 * for mmap we always have total space available
2718 abinfo.bytes = dmabuf->dmasize;
2720 abinfo.bytes = dmabuf->dmasize - dmabuf->count;
2722 abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
2723 spin_unlock_irqrestore(&state->card->lock, flags);
2724 return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2727 case SNDCTL_DSP_GETISPACE:
2728 if (!(file->f_mode & FMODE_READ))
2730 state = card->states[0];
2732 dmabuf = &state->dmabuf;
2733 spin_lock_irqsave(&state->card->lock, flags);
2734 cs_update_ptr(card, CS_TRUE);
2735 abinfo.fragsize = dmabuf->fragsize/dmabuf->divisor;
2736 abinfo.bytes = dmabuf->count/dmabuf->divisor;
2737 abinfo.fragstotal = dmabuf->numfrag;
2738 abinfo.fragments = abinfo.bytes >> dmabuf->fragshift;
2739 spin_unlock_irqrestore(&state->card->lock, flags);
2740 return copy_to_user(argp, &abinfo, sizeof(abinfo)) ? -EFAULT : 0;
2743 case SNDCTL_DSP_NONBLOCK:
2744 file->f_flags |= O_NONBLOCK;
2746 case SNDCTL_DSP_GETCAPS:
2747 return put_user(DSP_CAP_REALTIME|DSP_CAP_TRIGGER|DSP_CAP_MMAP,
2749 case SNDCTL_DSP_GETTRIGGER:
2751 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_GETTRIGGER()+\n") );
2752 if (file->f_mode & FMODE_WRITE) {
2753 state = card->states[1];
2755 dmabuf = &state->dmabuf;
2756 if (dmabuf->enable & DAC_RUNNING)
2757 val |= PCM_ENABLE_INPUT;
2760 if (file->f_mode & FMODE_READ) {
2762 state = card->states[0];
2763 dmabuf = &state->dmabuf;
2764 if (dmabuf->enable & ADC_RUNNING)
2765 val |= PCM_ENABLE_OUTPUT;
2768 CS_DBGOUT(CS_IOCTL, 2, printk("cs46xx: DSP_GETTRIGGER()- val=0x%x\n",val) );
2769 return put_user(val, p);
2770 case SNDCTL_DSP_SETTRIGGER:
2771 if (get_user(val, p))
2773 if (file->f_mode & FMODE_READ) {
2774 state = card->states[0];
2776 dmabuf = &state->dmabuf;
2777 if (val & PCM_ENABLE_INPUT) {
2778 if (!dmabuf->ready && (ret = prog_dmabuf(state)))
2785 if (file->f_mode & FMODE_WRITE) {
2786 state = card->states[1];
2788 dmabuf = &state->dmabuf;
2789 if (val & PCM_ENABLE_OUTPUT) {
2790 if (!dmabuf->ready && (ret = prog_dmabuf(state)))
2798 case SNDCTL_DSP_GETIPTR:
2799 if (!(file->f_mode & FMODE_READ))
2801 state = card->states[0];
2803 dmabuf = &state->dmabuf;
2804 spin_lock_irqsave(&state->card->lock, flags);
2805 cs_update_ptr(card, CS_TRUE);
2806 cinfo.bytes = dmabuf->total_bytes/dmabuf->divisor;
2807 cinfo.blocks = dmabuf->count/dmabuf->divisor >> dmabuf->fragshift;
2808 cinfo.ptr = dmabuf->hwptr/dmabuf->divisor;
2809 spin_unlock_irqrestore(&state->card->lock, flags);
2810 if (copy_to_user(argp, &cinfo, sizeof(cinfo)))
2815 case SNDCTL_DSP_GETOPTR:
2816 if (!(file->f_mode & FMODE_WRITE))
2818 state = card->states[1];
2820 dmabuf = &state->dmabuf;
2821 spin_lock_irqsave(&state->card->lock, flags);
2822 cs_update_ptr(card, CS_TRUE);
2823 cinfo.bytes = dmabuf->total_bytes;
2824 if (dmabuf->mapped) {
2825 cinfo.blocks = (cinfo.bytes >> dmabuf->fragshift)
2827 CS_DBGOUT(CS_PARMS, 8,
2828 printk("total_bytes=%d blocks=%d dmabuf->blocks=%d\n",
2829 cinfo.bytes,cinfo.blocks,dmabuf->blocks) );
2830 dmabuf->blocks = cinfo.bytes >> dmabuf->fragshift;
2832 cinfo.blocks = dmabuf->count >> dmabuf->fragshift;
2834 cinfo.ptr = dmabuf->hwptr;
2836 CS_DBGOUT(CS_PARMS, 4, printk(
2837 "cs46xx: GETOPTR bytes=%d blocks=%d ptr=%d\n",
2838 cinfo.bytes,cinfo.blocks,cinfo.ptr) );
2839 spin_unlock_irqrestore(&state->card->lock, flags);
2840 if (copy_to_user(argp, &cinfo, sizeof(cinfo)))
2845 case SNDCTL_DSP_SETDUPLEX:
2847 case SNDCTL_DSP_GETODELAY:
2848 if (!(file->f_mode & FMODE_WRITE))
2850 state = card->states[1];
2852 dmabuf = &state->dmabuf;
2853 spin_lock_irqsave(&state->card->lock, flags);
2854 cs_update_ptr(card, CS_TRUE);
2855 val = dmabuf->count;
2856 spin_unlock_irqrestore(&state->card->lock, flags);
2859 return put_user(val, p);
2860 case SOUND_PCM_READ_RATE:
2861 if (file->f_mode & FMODE_READ)
2862 state = card->states[0];
2864 state = card->states[1];
2866 dmabuf = &state->dmabuf;
2867 return put_user(dmabuf->rate, p);
2869 return put_user(0, p);
2870 case SOUND_PCM_READ_CHANNELS:
2871 if (file->f_mode & FMODE_READ)
2872 state = card->states[0];
2874 state = card->states[1];
2876 dmabuf = &state->dmabuf;
2877 return put_user((dmabuf->fmt & CS_FMT_STEREO) ? 2 : 1,
2880 return put_user(0, p);
2881 case SOUND_PCM_READ_BITS:
2882 if (file->f_mode & FMODE_READ)
2883 state = card->states[0];
2885 state = card->states[1];
2887 dmabuf = &state->dmabuf;
2888 return put_user((dmabuf->fmt & CS_FMT_16BIT) ?
2889 AFMT_S16_LE : AFMT_U8, p);
2892 return put_user(0, p);
2893 case SNDCTL_DSP_MAPINBUF:
2894 case SNDCTL_DSP_MAPOUTBUF:
2895 case SNDCTL_DSP_SETSYNCRO:
2896 case SOUND_PCM_WRITE_FILTER:
2897 case SOUND_PCM_READ_FILTER:
2905 * AMP control - null AMP
2908 static void amp_none(struct cs_card *card, int change)
2916 static void amp_voyetra(struct cs_card *card, int change)
2918 /* Manage the EAPD bit on the Crystal 4297
2919 and the Analog AD1885 */
2921 int old = card->amplifier;
2923 card->amplifier+=change;
2924 if (card->amplifier && !old) {
2925 /* Turn the EAPD amp on */
2926 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL,
2927 cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) |
2929 } else if(old && !card->amplifier) {
2930 /* Turn the EAPD amp off */
2931 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL,
2932 cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
2939 * Game Theatre XP card - EGPIO[2] is used to enable the external amp.
2942 static void amp_hercules(struct cs_card *card, int change)
2944 int old = card->amplifier;
2946 CS_DBGOUT(CS_ERROR, 2, printk(KERN_INFO
2947 "cs46xx: amp_hercules() called before initialized.\n"));
2950 card->amplifier+=change;
2951 if ((card->amplifier && !old) && !(hercules_egpio_disable)) {
2952 CS_DBGOUT(CS_PARMS, 4, printk(KERN_INFO
2953 "cs46xx: amp_hercules() external amp enabled\n"));
2954 cs461x_pokeBA0(card, BA0_EGPIODR,
2955 EGPIODR_GPOE2); /* enable EGPIO2 output */
2956 cs461x_pokeBA0(card, BA0_EGPIOPTR,
2957 EGPIOPTR_GPPT2); /* open-drain on output */
2958 } else if (old && !card->amplifier) {
2959 CS_DBGOUT(CS_PARMS, 4, printk(KERN_INFO
2960 "cs46xx: amp_hercules() external amp disabled\n"));
2961 cs461x_pokeBA0(card, BA0_EGPIODR, 0); /* disable */
2962 cs461x_pokeBA0(card, BA0_EGPIOPTR, 0); /* disable */
2967 * Handle the CLKRUN on a thinkpad. We must disable CLKRUN support
2968 * whenever we need to beat on the chip.
2970 * The original idea and code for this hack comes from David Kaiser at
2971 * Linuxcare. Perhaps one day Crystal will document their chips well
2972 * enough to make them useful.
2975 static void clkrun_hack(struct cs_card *card, int change)
2977 struct pci_dev *acpi_dev;
2981 int old = card->active;
2983 card->active+=change;
2985 acpi_dev = pci_find_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371AB_3, NULL);
2986 if (acpi_dev == NULL)
2987 return; /* Not a thinkpad thats for sure */
2989 /* Find the control port */
2990 pci_read_config_byte(acpi_dev, 0x41, &pp);
2993 /* Read ACPI port */
2994 control = inw(port + 0x10);
2996 /* Flip CLKRUN off while running */
2997 if (!card->active && old) {
2998 CS_DBGOUT(CS_PARMS , 9, printk( KERN_INFO
2999 "cs46xx: clkrun() enable clkrun - change=%d active=%d\n",
3000 change,card->active));
3001 outw(control|0x2000, port+0x10);
3004 * sometimes on a resume the bit is set, so always reset the bit.
3006 CS_DBGOUT(CS_PARMS , 9, printk( KERN_INFO
3007 "cs46xx: clkrun() disable clkrun - change=%d active=%d\n",
3008 change,card->active));
3009 outw(control&~0x2000, port+0x10);
3014 static int cs_open(struct inode *inode, struct file *file)
3016 struct cs_card *card = file->private_data;
3017 struct cs_state *state = NULL;
3018 struct dmabuf *dmabuf = NULL;
3019 struct list_head *entry;
3020 unsigned int minor = iminor(inode);
3024 CS_DBGOUT(CS_OPEN | CS_FUNCTION, 2, printk("cs46xx: cs_open()+ file=%p %s %s\n",
3025 file, file->f_mode & FMODE_WRITE ? "FMODE_WRITE" : "",
3026 file->f_mode & FMODE_READ ? "FMODE_READ" : "") );
3028 list_for_each(entry, &cs46xx_devs) {
3029 card = list_entry(entry, struct cs_card, list);
3031 if (!((card->dev_audio ^ minor) & ~0xf))
3034 if (entry == &cs46xx_devs)
3037 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 2, printk(KERN_INFO
3038 "cs46xx: cs_open(): Error - unable to find audio card struct\n"));
3043 * hardcode state[0] for capture, [1] for playback
3045 if (file->f_mode & FMODE_READ) {
3046 CS_DBGOUT(CS_WAVE_READ, 2, printk("cs46xx: cs_open() FMODE_READ\n") );
3047 if (card->states[0] == NULL) {
3048 state = card->states[0] =
3049 kmalloc(sizeof(struct cs_state), GFP_KERNEL);
3052 memset(state, 0, sizeof(struct cs_state));
3053 mutex_init(&state->sem);
3054 dmabuf = &state->dmabuf;
3055 dmabuf->pbuf = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
3056 if (dmabuf->pbuf == NULL) {
3058 card->states[0] = NULL;
3062 state = card->states[0];
3063 if (state->open_mode & FMODE_READ)
3066 dmabuf->channel = card->alloc_rec_pcm_channel(card);
3068 if (dmabuf->channel == NULL) {
3069 kfree(card->states[0]);
3070 card->states[0] = NULL;
3074 /* Now turn on external AMP if needed */
3076 state->card->active_ctrl(state->card, 1);
3077 state->card->amplifier_ctrl(state->card, 1);
3079 if ((tmp = cs46xx_powerup(card, CS_POWER_ADC))) {
3080 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3081 "cs46xx: cs46xx_powerup of ADC failed (0x%x)\n", tmp));
3085 dmabuf->channel->state = state;
3086 /* initialize the virtual channel */
3088 state->magic = CS_STATE_MAGIC;
3089 init_waitqueue_head(&dmabuf->wait);
3090 mutex_init(&state->open_mutex);
3091 file->private_data = card;
3093 mutex_lock(&state->open_mutex);
3095 /* set default sample format. According to OSS Programmer's Guide /dev/dsp
3096 should be default to unsigned 8-bits, mono, with sample rate 8kHz and
3097 /dev/dspW will accept 16-bits sample */
3099 /* Default input is 8bit mono */
3100 dmabuf->fmt &= ~CS_FMT_MASK;
3101 dmabuf->type = CS_TYPE_ADC;
3102 dmabuf->ossfragshift = 0;
3103 dmabuf->ossmaxfrags = 0;
3104 dmabuf->subdivision = 0;
3105 cs_set_adc_rate(state, 8000);
3106 cs_set_divisor(dmabuf);
3108 state->open_mode |= FMODE_READ;
3109 mutex_unlock(&state->open_mutex);
3111 if (file->f_mode & FMODE_WRITE) {
3112 CS_DBGOUT(CS_OPEN, 2, printk("cs46xx: cs_open() FMODE_WRITE\n") );
3113 if (card->states[1] == NULL) {
3114 state = card->states[1] =
3115 kmalloc(sizeof(struct cs_state), GFP_KERNEL);
3118 memset(state, 0, sizeof(struct cs_state));
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 can not 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 = kmalloc(sizeof(struct cs_card), GFP_KERNEL)) == NULL) {
5077 printk(KERN_ERR "cs46xx: out of memory\n");
5080 memset(card, 0, sizeof(*card));
5081 card->ba0_addr = RSRCADDRESS(pci_dev, 0);
5082 card->ba1_addr = RSRCADDRESS(pci_dev, 1);
5083 card->pci_dev = pci_dev;
5084 card->irq = pci_dev->irq;
5085 card->magic = CS_CARD_MAGIC;
5086 spin_lock_init(&card->lock);
5087 spin_lock_init(&card->ac97_lock);
5089 pci_set_master(pci_dev);
5091 printk(cs46xx_banner);
5092 printk(KERN_INFO "cs46xx: Card found at 0x%08lx and 0x%08lx, IRQ %d\n",
5093 card->ba0_addr, card->ba1_addr, card->irq);
5095 card->alloc_pcm_channel = cs_alloc_pcm_channel;
5096 card->alloc_rec_pcm_channel = cs_alloc_rec_pcm_channel;
5097 card->free_pcm_channel = cs_free_pcm_channel;
5098 card->amplifier_ctrl = amp_none;
5099 card->active_ctrl = amp_none;
5103 if (cp->vendor == ss_vendor && cp->id == ss_card) {
5104 card->amplifier_ctrl = cp->amp;
5106 card->active_ctrl = cp->active;
5108 card->amp_init = cp->amp_init;
5113 if (cp->name == NULL) {
5114 printk(KERN_INFO "cs46xx: Unknown card (%04X:%04X) at 0x%08lx/0x%08lx, IRQ %d\n",
5115 ss_vendor, ss_card, card->ba0_addr, card->ba1_addr, card->irq);
5117 printk(KERN_INFO "cs46xx: %s (%04X:%04X) at 0x%08lx/0x%08lx, IRQ %d\n",
5118 cp->name, ss_vendor, ss_card, card->ba0_addr, card->ba1_addr, card->irq);
5121 if (card->amplifier_ctrl == NULL) {
5122 card->amplifier_ctrl = amp_none;
5123 card->active_ctrl = clkrun_hack;
5126 if (external_amp == 1) {
5127 printk(KERN_INFO "cs46xx: Crystal EAPD support forced on.\n");
5128 card->amplifier_ctrl = amp_voyetra;
5131 if (thinkpad == 1) {
5132 printk(KERN_INFO "cs46xx: Activating CLKRUN hack for Thinkpad.\n");
5133 card->active_ctrl = clkrun_hack;
5136 * The thinkpads don't work well without runtime updating on their kernel
5137 * delay values (or any laptop with variable CPU speeds really).
5138 * so, just to be safe set the init delay to 2100. Eliminates
5139 * failures on T21 Thinkpads. remove this code when the udelay
5140 * and mdelay kernel code is replaced by a pm timer, or the delays
5141 * work well for battery and/or AC power both.
5143 if (card->active_ctrl == clkrun_hack) {
5147 if ((card->active_ctrl == clkrun_hack) && !(powerdown == 1)) {
5149 * for some currently unknown reason, powering down the DAC and ADC component
5150 * blocks on thinkpads causes some funky behavior... distoorrrtion and ac97
5151 * codec access problems. probably the serial clock becomes unsynced.
5152 * added code to sync the chips back up, but only helped about 70% the time.
5158 card->active_ctrl(card, 1);
5160 /* claim our iospace and irq */
5162 card->ba0 = ioremap_nocache(card->ba0_addr, CS461X_BA0_SIZE);
5163 card->ba1.name.data0 = ioremap_nocache(card->ba1_addr + BA1_SP_DMEM0, CS461X_BA1_DATA0_SIZE);
5164 card->ba1.name.data1 = ioremap_nocache(card->ba1_addr + BA1_SP_DMEM1, CS461X_BA1_DATA1_SIZE);
5165 card->ba1.name.pmem = ioremap_nocache(card->ba1_addr + BA1_SP_PMEM, CS461X_BA1_PRG_SIZE);
5166 card->ba1.name.reg = ioremap_nocache(card->ba1_addr + BA1_SP_REG, CS461X_BA1_REG_SIZE);
5168 CS_DBGOUT(CS_INIT, 4, printk(KERN_INFO
5169 "cs46xx: card=%p card->ba0=%p\n",card,card->ba0) );
5170 CS_DBGOUT(CS_INIT, 4, printk(KERN_INFO
5171 "cs46xx: card->ba1=%p %p %p %p\n",
5172 card->ba1.name.data0,
5173 card->ba1.name.data1,
5174 card->ba1.name.pmem,
5175 card->ba1.name.reg) );
5177 if (card->ba0 == 0 || card->ba1.name.data0 == 0 ||
5178 card->ba1.name.data1 == 0 || card->ba1.name.pmem == 0 ||
5179 card->ba1.name.reg == 0)
5182 if (request_irq(card->irq, &cs_interrupt, IRQF_SHARED, "cs46xx", card)) {
5183 printk(KERN_ERR "cs46xx: unable to allocate irq %d\n", card->irq);
5186 /* register /dev/dsp */
5187 if ((card->dev_audio = register_sound_dsp(&cs461x_fops, -1)) < 0) {
5188 printk(KERN_ERR "cs46xx: unable to register dsp\n");
5192 /* register /dev/midi */
5193 if ((card->dev_midi = register_sound_midi(&cs_midi_fops, -1)) < 0)
5194 printk(KERN_ERR "cs46xx: unable to register midi\n");
5196 card->pm.flags |= CS46XX_PM_IDLE;
5197 for (i = 0; i < 5; i++) {
5198 if (cs_hardware_init(card) != 0) {
5199 CS_DBGOUT(CS_ERROR, 4, printk(
5200 "cs46xx: ERROR in cs_hardware_init()... retrying\n"));
5201 for (j = 0; j < NR_AC97; j++)
5202 if (card->ac97_codec[j] != NULL) {
5203 unregister_sound_mixer(card->ac97_codec[j]->dev_mixer);
5204 ac97_release_codec(card->ac97_codec[j]);
5206 mdelay(10 * cs_laptop_wait);
5212 CS_DBGOUT(CS_PM | CS_ERROR, 1, printk(
5213 "cs46xx: cs46xx_probe()- cs_hardware_init() failed, retried %d times.\n",i));
5214 unregister_sound_dsp(card->dev_audio);
5216 unregister_sound_midi(card->dev_midi);
5220 init_waitqueue_head(&card->midi.open_wait);
5221 mutex_init(&card->midi.open_mutex);
5222 init_waitqueue_head(&card->midi.iwait);
5223 init_waitqueue_head(&card->midi.owait);
5224 cs461x_pokeBA0(card, BA0_MIDCR, MIDCR_MRST);
5225 cs461x_pokeBA0(card, BA0_MIDCR, 0);
5228 * Check if we have to init the amplifier, but probably already done
5229 * since the CD logic in the ac97 init code will turn on the ext amp.
5233 card->active_ctrl(card, -1);
5235 PCI_SET_DRIVER_DATA(pci_dev, card);
5236 PCI_SET_DMA_MASK(pci_dev, dma_mask);
5237 list_add(&card->list, &cs46xx_devs);
5239 CS_DBGOUT(CS_PM, 9, printk(KERN_INFO "cs46xx: pm.flags=0x%x card=%p\n",
5240 (unsigned)card->pm.flags,card));
5242 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5243 "cs46xx: probe()- device allocated successfully\n"));
5247 free_irq(card->irq, card);
5251 if (card->ba1.name.data0)
5252 iounmap(card->ba1.name.data0);
5253 if (card->ba1.name.data1)
5254 iounmap(card->ba1.name.data1);
5255 if (card->ba1.name.pmem)
5256 iounmap(card->ba1.name.pmem);
5257 if (card->ba1.name.reg)
5258 iounmap(card->ba1.name.reg);
5260 CS_DBGOUT(CS_INIT | CS_ERROR, 1, printk(KERN_INFO
5261 "cs46xx: probe()- no device allocated\n"));
5265 // ---------------------------------------------------------------------
5267 static void __devexit cs46xx_remove(struct pci_dev *pci_dev)
5269 struct cs_card *card = PCI_GET_DRIVER_DATA(pci_dev);
5273 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5274 "cs46xx: cs46xx_remove()+\n"));
5276 card->active_ctrl(card,1);
5278 tmp = cs461x_peek(card, BA1_PFIE);
5281 cs461x_poke(card, BA1_PFIE, tmp); /* playback interrupt disable */
5283 tmp = cs461x_peek(card, BA1_CIE);
5286 cs461x_poke(card, BA1_CIE, tmp); /* capture interrupt disable */
5289 * Stop playback DMA.
5291 tmp = cs461x_peek(card, BA1_PCTL);
5292 cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
5297 tmp = cs461x_peek(card, BA1_CCTL);
5298 cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
5301 * Reset the processor.
5305 cs461x_proc_stop(card);
5308 * Power down the DAC and ADC. We will power them up (if) when we need
5311 if ((tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
5312 CS_POWER_MIXVON, CS_TRUE))) {
5313 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
5314 "cs46xx: cs461x_powerdown() failure (0x%x)\n",tmp) );
5318 * Power down the PLL.
5320 cs461x_pokeBA0(card, BA0_CLKCR1, 0);
5323 * Turn off the Processor by turning off the software clock enable flag in
5324 * the clock control register.
5326 tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE;
5327 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
5329 card->active_ctrl(card,-1);
5331 /* free hardware resources */
5332 free_irq(card->irq, card);
5334 iounmap(card->ba1.name.data0);
5335 iounmap(card->ba1.name.data1);
5336 iounmap(card->ba1.name.pmem);
5337 iounmap(card->ba1.name.reg);
5339 /* unregister audio devices */
5340 for (i = 0; i < NR_AC97; i++)
5341 if (card->ac97_codec[i] != NULL) {
5342 unregister_sound_mixer(card->ac97_codec[i]->dev_mixer);
5343 ac97_release_codec(card->ac97_codec[i]);
5345 unregister_sound_dsp(card->dev_audio);
5347 unregister_sound_midi(card->dev_midi);
5348 list_del(&card->list);
5350 PCI_SET_DRIVER_DATA(pci_dev,NULL);
5352 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5353 "cs46xx: cs46xx_remove()-: remove successful\n"));
5358 CS46XX_4612, /* same as 4630 */
5359 CS46XX_4615, /* same as 4624 */
5362 static struct pci_device_id cs46xx_pci_tbl[] = {
5364 .vendor = PCI_VENDOR_ID_CIRRUS,
5365 .device = PCI_DEVICE_ID_CIRRUS_4610,
5366 .subvendor = PCI_ANY_ID,
5367 .subdevice = PCI_ANY_ID,
5368 .driver_data = CS46XX_4610,
5371 .vendor = PCI_VENDOR_ID_CIRRUS,
5372 .device = PCI_DEVICE_ID_CIRRUS_4612,
5373 .subvendor = PCI_ANY_ID,
5374 .subdevice = PCI_ANY_ID,
5375 .driver_data = CS46XX_4612,
5378 .vendor = PCI_VENDOR_ID_CIRRUS,
5379 .device = PCI_DEVICE_ID_CIRRUS_4615,
5380 .subvendor = PCI_ANY_ID,
5381 .subdevice = PCI_ANY_ID,
5382 .driver_data = CS46XX_4615,
5387 MODULE_DEVICE_TABLE(pci, cs46xx_pci_tbl);
5389 static struct pci_driver cs46xx_pci_driver = {
5391 .id_table = cs46xx_pci_tbl,
5392 .probe = cs46xx_probe,
5393 .remove = __devexit_p(cs46xx_remove),
5395 .suspend = cs46xx_suspend_tbl,
5396 .resume = cs46xx_resume_tbl,
5400 static int __init cs46xx_init_module(void)
5403 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5404 "cs46xx: cs46xx_init_module()+ \n"));
5405 rtn = pci_register_driver(&cs46xx_pci_driver);
5407 if (rtn == -ENODEV) {
5408 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(
5409 "cs46xx: Unable to detect valid cs46xx device\n"));
5412 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2,
5413 printk(KERN_INFO "cs46xx: cs46xx_init_module()- (%d)\n",rtn));
5417 static void __exit cs46xx_cleanup_module(void)
5419 pci_unregister_driver(&cs46xx_pci_driver);
5420 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2,
5421 printk(KERN_INFO "cs46xx: cleanup_cs46xx() finished\n"));
5424 module_init(cs46xx_init_module);
5425 module_exit(cs46xx_cleanup_module);
5428 static int cs46xx_suspend_tbl(struct pci_dev *pcidev, pm_message_t state)
5430 struct cs_card *s = PCI_GET_DRIVER_DATA(pcidev);
5431 CS_DBGOUT(CS_PM | CS_FUNCTION, 2,
5432 printk(KERN_INFO "cs46xx: cs46xx_suspend_tbl request\n"));
5433 cs46xx_suspend(s, state);
5437 static int cs46xx_resume_tbl(struct pci_dev *pcidev)
5439 struct cs_card *s = PCI_GET_DRIVER_DATA(pcidev);
5440 CS_DBGOUT(CS_PM | CS_FUNCTION, 2,
5441 printk(KERN_INFO "cs46xx: cs46xx_resume_tbl request\n"));