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 cannot 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)
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_get_device(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_82371AB_3, NULL);
2986 if (acpi_dev == NULL)
2987 return; /* Not a thinkpad thats for sure */
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);
3011 pci_dev_put(acpi_dev);
3015 static int cs_open(struct inode *inode, struct file *file)
3017 struct cs_card *card = file->private_data;
3018 struct cs_state *state = NULL;
3019 struct dmabuf *dmabuf = NULL;
3020 struct list_head *entry;
3021 unsigned int minor = iminor(inode);
3025 CS_DBGOUT(CS_OPEN | CS_FUNCTION, 2, printk("cs46xx: cs_open()+ file=%p %s %s\n",
3026 file, file->f_mode & FMODE_WRITE ? "FMODE_WRITE" : "",
3027 file->f_mode & FMODE_READ ? "FMODE_READ" : "") );
3029 list_for_each(entry, &cs46xx_devs) {
3030 card = list_entry(entry, struct cs_card, list);
3032 if (!((card->dev_audio ^ minor) & ~0xf))
3035 if (entry == &cs46xx_devs)
3038 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 2, printk(KERN_INFO
3039 "cs46xx: cs_open(): Error - unable to find audio card struct\n"));
3044 * hardcode state[0] for capture, [1] for playback
3046 if (file->f_mode & FMODE_READ) {
3047 CS_DBGOUT(CS_WAVE_READ, 2, printk("cs46xx: cs_open() FMODE_READ\n") );
3048 if (card->states[0] == NULL) {
3049 state = card->states[0] =
3050 kmalloc(sizeof(struct cs_state), GFP_KERNEL);
3053 memset(state, 0, sizeof(struct cs_state));
3054 mutex_init(&state->sem);
3055 dmabuf = &state->dmabuf;
3056 dmabuf->pbuf = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
3057 if (dmabuf->pbuf == NULL) {
3059 card->states[0] = NULL;
3063 state = card->states[0];
3064 if (state->open_mode & FMODE_READ)
3067 dmabuf->channel = card->alloc_rec_pcm_channel(card);
3069 if (dmabuf->channel == NULL) {
3070 kfree(card->states[0]);
3071 card->states[0] = NULL;
3075 /* Now turn on external AMP if needed */
3077 state->card->active_ctrl(state->card, 1);
3078 state->card->amplifier_ctrl(state->card, 1);
3080 if ((tmp = cs46xx_powerup(card, CS_POWER_ADC))) {
3081 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3082 "cs46xx: cs46xx_powerup of ADC failed (0x%x)\n", tmp));
3086 dmabuf->channel->state = state;
3087 /* initialize the virtual channel */
3089 state->magic = CS_STATE_MAGIC;
3090 init_waitqueue_head(&dmabuf->wait);
3091 mutex_init(&state->open_mutex);
3092 file->private_data = card;
3094 mutex_lock(&state->open_mutex);
3096 /* set default sample format. According to OSS Programmer's Guide /dev/dsp
3097 should be default to unsigned 8-bits, mono, with sample rate 8kHz and
3098 /dev/dspW will accept 16-bits sample */
3100 /* Default input is 8bit mono */
3101 dmabuf->fmt &= ~CS_FMT_MASK;
3102 dmabuf->type = CS_TYPE_ADC;
3103 dmabuf->ossfragshift = 0;
3104 dmabuf->ossmaxfrags = 0;
3105 dmabuf->subdivision = 0;
3106 cs_set_adc_rate(state, 8000);
3107 cs_set_divisor(dmabuf);
3109 state->open_mode |= FMODE_READ;
3110 mutex_unlock(&state->open_mutex);
3112 if (file->f_mode & FMODE_WRITE) {
3113 CS_DBGOUT(CS_OPEN, 2, printk("cs46xx: cs_open() FMODE_WRITE\n") );
3114 if (card->states[1] == NULL) {
3115 state = card->states[1] =
3116 kmalloc(sizeof(struct cs_state), GFP_KERNEL);
3119 memset(state, 0, sizeof(struct cs_state));
3120 mutex_init(&state->sem);
3121 dmabuf = &state->dmabuf;
3122 dmabuf->pbuf = (void *)get_zeroed_page(GFP_KERNEL | GFP_DMA);
3123 if (dmabuf->pbuf == NULL) {
3125 card->states[1] = NULL;
3129 state = card->states[1];
3130 if (state->open_mode & FMODE_WRITE)
3133 dmabuf->channel = card->alloc_pcm_channel(card);
3135 if (dmabuf->channel == NULL) {
3136 kfree(card->states[1]);
3137 card->states[1] = NULL;
3141 /* Now turn on external AMP if needed */
3143 state->card->active_ctrl(state->card, 1);
3144 state->card->amplifier_ctrl(state->card, 1);
3146 if ((tmp = cs46xx_powerup(card, CS_POWER_DAC))) {
3147 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3148 "cs46xx: cs46xx_powerup of DAC failed (0x%x)\n", tmp));
3152 dmabuf->channel->state = state;
3153 /* initialize the virtual channel */
3155 state->magic = CS_STATE_MAGIC;
3156 init_waitqueue_head(&dmabuf->wait);
3157 mutex_init(&state->open_mutex);
3158 file->private_data = card;
3160 mutex_lock(&state->open_mutex);
3162 /* set default sample format. According to OSS Programmer's Guide /dev/dsp
3163 should be default to unsigned 8-bits, mono, with sample rate 8kHz and
3164 /dev/dspW will accept 16-bits sample */
3166 /* Default output is 8bit mono. */
3167 dmabuf->fmt &= ~CS_FMT_MASK;
3168 dmabuf->type = CS_TYPE_DAC;
3169 dmabuf->ossfragshift = 0;
3170 dmabuf->ossmaxfrags = 0;
3171 dmabuf->subdivision = 0;
3172 cs_set_dac_rate(state, 8000);
3173 cs_set_divisor(dmabuf);
3175 state->open_mode |= FMODE_WRITE;
3176 mutex_unlock(&state->open_mutex);
3177 if ((ret = prog_dmabuf(state)))
3180 CS_DBGOUT(CS_OPEN | CS_FUNCTION, 2, printk("cs46xx: cs_open()- 0\n"));
3181 return nonseekable_open(inode, file);
3184 static int cs_release(struct inode *inode, struct file *file)
3186 struct cs_card *card = file->private_data;
3187 struct dmabuf *dmabuf;
3188 struct cs_state *state;
3190 CS_DBGOUT(CS_RELEASE | CS_FUNCTION, 2, printk("cs46xx: cs_release()+ file=%p %s %s\n",
3191 file, file->f_mode & FMODE_WRITE ? "FMODE_WRITE" : "",
3192 file->f_mode & FMODE_READ ? "FMODE_READ" : ""));
3194 if (!(file->f_mode & (FMODE_WRITE | FMODE_READ)))
3196 state = card->states[1];
3198 if ((state->open_mode & FMODE_WRITE) & (file->f_mode & FMODE_WRITE)) {
3199 CS_DBGOUT(CS_RELEASE, 2, printk("cs46xx: cs_release() FMODE_WRITE\n"));
3200 dmabuf = &state->dmabuf;
3201 cs_clear_tail(state);
3202 drain_dac(state, file->f_flags & O_NONBLOCK);
3203 /* stop DMA state machine and free DMA buffers/channels */
3204 mutex_lock(&state->open_mutex);
3206 dealloc_dmabuf(state);
3207 state->card->free_pcm_channel(state->card, dmabuf->channel->num);
3208 free_page((unsigned long)state->dmabuf.pbuf);
3210 /* we're covered by the open_mutex */
3211 mutex_unlock(&state->open_mutex);
3212 state->card->states[state->virt] = NULL;
3213 state->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
3215 if ((tmp = cs461x_powerdown(card, CS_POWER_DAC, CS_FALSE))) {
3216 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
3217 "cs46xx: cs_release_mixdev() powerdown DAC failure (0x%x)\n",tmp) );
3220 /* Now turn off external AMP if needed */
3221 state->card->amplifier_ctrl(state->card, -1);
3222 state->card->active_ctrl(state->card, -1);
3227 state = card->states[0];
3229 if ((state->open_mode & FMODE_READ) & (file->f_mode & FMODE_READ)) {
3230 CS_DBGOUT(CS_RELEASE, 2, printk("cs46xx: cs_release() FMODE_READ\n"));
3231 dmabuf = &state->dmabuf;
3232 mutex_lock(&state->open_mutex);
3234 dealloc_dmabuf(state);
3235 state->card->free_pcm_channel(state->card, dmabuf->channel->num);
3236 free_page((unsigned long)state->dmabuf.pbuf);
3238 /* we're covered by the open_mutex */
3239 mutex_unlock(&state->open_mutex);
3240 state->card->states[state->virt] = NULL;
3241 state->open_mode &= (~file->f_mode) & (FMODE_READ|FMODE_WRITE);
3243 if ((tmp = cs461x_powerdown(card, CS_POWER_ADC, CS_FALSE))) {
3244 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
3245 "cs46xx: cs_release_mixdev() powerdown ADC failure (0x%x)\n",tmp) );
3248 /* Now turn off external AMP if needed */
3249 state->card->amplifier_ctrl(state->card, -1);
3250 state->card->active_ctrl(state->card, -1);
3255 CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 2, printk("cs46xx: cs_release()- 0\n"));
3259 static void printpm(struct cs_card *s)
3261 CS_DBGOUT(CS_PM, 9, printk("pm struct:\n"));
3262 CS_DBGOUT(CS_PM, 9, printk("flags:0x%x u32CLKCR1_SAVE: 0%x u32SSPMValue: 0x%x\n",
3263 (unsigned)s->pm.flags,s->pm.u32CLKCR1_SAVE,s->pm.u32SSPMValue));
3264 CS_DBGOUT(CS_PM, 9, printk("u32PPLVCvalue: 0x%x u32PPRVCvalue: 0x%x\n",
3265 s->pm.u32PPLVCvalue,s->pm.u32PPRVCvalue));
3266 CS_DBGOUT(CS_PM, 9, printk("u32FMLVCvalue: 0x%x u32FMRVCvalue: 0x%x\n",
3267 s->pm.u32FMLVCvalue,s->pm.u32FMRVCvalue));
3268 CS_DBGOUT(CS_PM, 9, printk("u32GPIORvalue: 0x%x u32JSCTLvalue: 0x%x\n",
3269 s->pm.u32GPIORvalue,s->pm.u32JSCTLvalue));
3270 CS_DBGOUT(CS_PM, 9, printk("u32SSCR: 0x%x u32SRCSA: 0x%x\n",
3271 s->pm.u32SSCR,s->pm.u32SRCSA));
3272 CS_DBGOUT(CS_PM, 9, printk("u32DacASR: 0x%x u32AdcASR: 0x%x\n",
3273 s->pm.u32DacASR,s->pm.u32AdcASR));
3274 CS_DBGOUT(CS_PM, 9, printk("u32DacSR: 0x%x u32AdcSR: 0x%x\n",
3275 s->pm.u32DacSR,s->pm.u32AdcSR));
3276 CS_DBGOUT(CS_PM, 9, printk("u32MIDCR_Save: 0x%x\n",
3277 s->pm.u32MIDCR_Save));
3278 CS_DBGOUT(CS_PM, 9, printk("u32AC97_powerdown: 0x%x _general_purpose 0x%x\n",
3279 s->pm.u32AC97_powerdown,s->pm.u32AC97_general_purpose));
3280 CS_DBGOUT(CS_PM, 9, printk("u32AC97_master_volume: 0x%x\n",
3281 s->pm.u32AC97_master_volume));
3282 CS_DBGOUT(CS_PM, 9, printk("u32AC97_headphone_volume: 0x%x\n",
3283 s->pm.u32AC97_headphone_volume));
3284 CS_DBGOUT(CS_PM, 9, printk("u32AC97_master_volume_mono: 0x%x\n",
3285 s->pm.u32AC97_master_volume_mono));
3286 CS_DBGOUT(CS_PM, 9, printk("u32AC97_pcm_out_volume: 0x%x\n",
3287 s->pm.u32AC97_pcm_out_volume));
3288 CS_DBGOUT(CS_PM, 9, printk("dmabuf_swptr_play: 0x%x dmabuf_count_play: %d\n",
3289 s->pm.dmabuf_swptr_play,s->pm.dmabuf_count_play));
3290 CS_DBGOUT(CS_PM, 9, printk("dmabuf_swptr_capture: 0x%x dmabuf_count_capture: %d\n",
3291 s->pm.dmabuf_swptr_capture,s->pm.dmabuf_count_capture));
3295 /****************************************************************************
3297 * Suspend - save the ac97 regs, mute the outputs and power down the part.
3299 ****************************************************************************/
3300 static void cs46xx_ac97_suspend(struct cs_card *card)
3303 struct ac97_codec *dev=card->ac97_codec[0];
3306 CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_suspend()+\n"));
3308 if (card->states[1]) {
3309 stop_dac(card->states[1]);
3310 resync_dma_ptrs(card->states[1]);
3312 if (card->states[0]) {
3313 stop_adc(card->states[0]);
3314 resync_dma_ptrs(card->states[0]);
3317 for (Count = 0x2, i = 0; (Count <= CS46XX_AC97_HIGHESTREGTORESTORE)
3318 && (i < CS46XX_AC97_NUMBER_RESTORE_REGS);
3320 card->pm.ac97[i] = cs_ac97_get(dev, BA0_AC97_RESET + Count);
3323 * Save the ac97 volume registers as well as the current powerdown state.
3324 * Now, mute the all the outputs (master, headphone, and mono), as well
3325 * as the PCM volume, in preparation for powering down the entire part.
3326 card->pm.u32AC97_master_volume = (u32)cs_ac97_get( dev,
3327 (u8)BA0_AC97_MASTER_VOLUME);
3328 card->pm.u32AC97_headphone_volume = (u32)cs_ac97_get(dev,
3329 (u8)BA0_AC97_HEADPHONE_VOLUME);
3330 card->pm.u32AC97_master_volume_mono = (u32)cs_ac97_get(dev,
3331 (u8)BA0_AC97_MASTER_VOLUME_MONO);
3332 card->pm.u32AC97_pcm_out_volume = (u32)cs_ac97_get(dev,
3333 (u8)BA0_AC97_PCM_OUT_VOLUME);
3338 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME, 0x8000);
3339 cs_ac97_set(dev, (u8)BA0_AC97_HEADPHONE_VOLUME, 0x8000);
3340 cs_ac97_set(dev, (u8)BA0_AC97_MASTER_VOLUME_MONO, 0x8000);
3341 cs_ac97_set(dev, (u8)BA0_AC97_PCM_OUT_VOLUME, 0x8000);
3344 * save the registers that cause pops
3346 card->pm.u32AC97_powerdown = (u32)cs_ac97_get(dev, (u8)AC97_POWER_CONTROL);
3347 card->pm.u32AC97_general_purpose = (u32)cs_ac97_get(dev, (u8)BA0_AC97_GENERAL_PURPOSE);
3349 * And power down everything on the AC97 codec.
3350 * well, for now, only power down the DAC/ADC and MIXER VREFON components.
3351 * trouble with removing VREF.
3353 if ((tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
3354 CS_POWER_MIXVON, CS_TRUE))) {
3355 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3356 "cs46xx: cs46xx_ac97_suspend() failure (0x%x)\n",tmp));
3359 CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_suspend()-\n"));
3362 /****************************************************************************
3364 * Resume - power up the part and restore its registers..
3366 ****************************************************************************/
3367 static void cs46xx_ac97_resume(struct cs_card *card)
3370 struct ac97_codec *dev=card->ac97_codec[0];
3372 CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_resume()+\n"));
3375 * First, we restore the state of the general purpose register. This
3376 * contains the mic select (mic1 or mic2) and if we restore this after
3377 * we restore the mic volume/boost state and mic2 was selected at
3378 * suspend time, we will end up with a brief period of time where mic1
3379 * is selected with the volume/boost settings for mic2, causing
3380 * acoustic feedback. So we restore the general purpose register
3381 * first, thereby getting the correct mic selected before we restore
3382 * the mic volume/boost.
3384 cs_ac97_set(dev, (u8)BA0_AC97_GENERAL_PURPOSE,
3385 (u16)card->pm.u32AC97_general_purpose);
3387 * Now, while the outputs are still muted, restore the state of power
3390 cs_ac97_set(dev, (u8)BA0_AC97_POWERDOWN, (u16)card->pm.u32AC97_powerdown);
3391 mdelay(5 * cs_laptop_wait);
3393 * Restore just the first set of registers, from register number
3394 * 0x02 to the register number that ulHighestRegToRestore specifies.
3396 for (Count = 0x2, i=0; (Count <= CS46XX_AC97_HIGHESTREGTORESTORE) &&
3397 (i < CS46XX_AC97_NUMBER_RESTORE_REGS); Count += 2, i++) {
3398 cs_ac97_set(dev, (u8)(BA0_AC97_RESET + Count), (u16)card->pm.ac97[i]);
3401 /* Check if we have to init the amplifier */
3403 card->amp_init(card);
3405 CS_DBGOUT(CS_PM, 9, printk("cs46xx: cs46xx_ac97_resume()-\n"));
3409 static int cs46xx_restart_part(struct cs_card *card)
3411 struct dmabuf *dmabuf;
3413 CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3414 printk( "cs46xx: cs46xx_restart_part()+\n"));
3415 if (card->states[1]) {
3416 dmabuf = &card->states[1]->dmabuf;
3418 resync_dma_ptrs(card->states[1]);
3419 cs_set_divisor(dmabuf);
3420 if (__prog_dmabuf(card->states[1])) {
3421 CS_DBGOUT(CS_PM | CS_ERROR, 1,
3422 printk("cs46xx: cs46xx_restart_part()- (-1) prog_dmabuf() dac error\n"));
3425 cs_set_dac_rate(card->states[1], dmabuf->rate);
3427 if (card->states[0]) {
3428 dmabuf = &card->states[0]->dmabuf;
3430 resync_dma_ptrs(card->states[0]);
3431 cs_set_divisor(dmabuf);
3432 if (__prog_dmabuf(card->states[0])) {
3433 CS_DBGOUT(CS_PM | CS_ERROR, 1,
3434 printk("cs46xx: cs46xx_restart_part()- (-1) prog_dmabuf() adc error\n"));
3437 cs_set_adc_rate(card->states[0], dmabuf->rate);
3439 card->pm.flags |= CS46XX_PM_RESUMED;
3440 if (card->states[0])
3441 start_adc(card->states[0]);
3442 if (card->states[1])
3443 start_dac(card->states[1]);
3445 card->pm.flags |= CS46XX_PM_IDLE;
3446 card->pm.flags &= ~(CS46XX_PM_SUSPENDING | CS46XX_PM_SUSPENDED
3447 | CS46XX_PM_RESUMING | CS46XX_PM_RESUMED);
3448 if (card->states[0])
3449 wake_up(&card->states[0]->dmabuf.wait);
3450 if (card->states[1])
3451 wake_up(&card->states[1]->dmabuf.wait);
3453 CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3454 printk( "cs46xx: cs46xx_restart_part()-\n"));
3458 static void cs461x_reset(struct cs_card *card);
3459 static void cs461x_proc_stop(struct cs_card *card);
3460 static int cs46xx_suspend(struct cs_card *card, pm_message_t state)
3464 CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3465 printk("cs46xx: cs46xx_suspend()+ flags=0x%x s=%p\n",
3466 (unsigned)card->pm.flags,card));
3468 * check the current state, only suspend if IDLE
3470 if (!(card->pm.flags & CS46XX_PM_IDLE)) {
3471 CS_DBGOUT(CS_PM | CS_ERROR, 2,
3472 printk("cs46xx: cs46xx_suspend() unable to suspend, not IDLE\n"));
3475 card->pm.flags &= ~CS46XX_PM_IDLE;
3476 card->pm.flags |= CS46XX_PM_SUSPENDING;
3478 card->active_ctrl(card,1);
3480 tmp = cs461x_peek(card, BA1_PFIE);
3483 cs461x_poke(card, BA1_PFIE, tmp); /* playback interrupt disable */
3485 tmp = cs461x_peek(card, BA1_CIE);
3488 cs461x_poke(card, BA1_CIE, tmp); /* capture interrupt disable */
3491 * Stop playback DMA.
3493 tmp = cs461x_peek(card, BA1_PCTL);
3494 cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
3499 tmp = cs461x_peek(card, BA1_CCTL);
3500 cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
3502 if (card->states[1]) {
3503 card->pm.dmabuf_swptr_play = card->states[1]->dmabuf.swptr;
3504 card->pm.dmabuf_count_play = card->states[1]->dmabuf.count;
3506 if (card->states[0]) {
3507 card->pm.dmabuf_swptr_capture = card->states[0]->dmabuf.swptr;
3508 card->pm.dmabuf_count_capture = card->states[0]->dmabuf.count;
3511 cs46xx_ac97_suspend(card);
3514 * Reset the processor.
3518 cs461x_proc_stop(card);
3521 * Power down the DAC and ADC. For now leave the other areas on.
3523 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, 0x0300);
3526 * Power down the PLL.
3528 cs461x_pokeBA0(card, BA0_CLKCR1, 0);
3531 * Turn off the Processor by turning off the software clock enable flag in
3532 * the clock control register.
3534 tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE;
3535 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
3537 card->active_ctrl(card,-1);
3539 card->pm.flags &= ~CS46XX_PM_SUSPENDING;
3540 card->pm.flags |= CS46XX_PM_SUSPENDED;
3544 CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3545 printk("cs46xx: cs46xx_suspend()- flags=0x%x\n",
3546 (unsigned)card->pm.flags));
3550 static int cs46xx_resume(struct cs_card *card)
3554 CS_DBGOUT(CS_PM | CS_FUNCTION, 4,
3555 printk( "cs46xx: cs46xx_resume()+ flags=0x%x\n",
3556 (unsigned)card->pm.flags));
3557 if (!(card->pm.flags & CS46XX_PM_SUSPENDED)) {
3558 CS_DBGOUT(CS_PM | CS_ERROR, 2,
3559 printk("cs46xx: cs46xx_resume() unable to resume, not SUSPENDED\n"));
3562 card->pm.flags |= CS46XX_PM_RESUMING;
3563 card->pm.flags &= ~CS46XX_PM_SUSPENDED;
3565 card->active_ctrl(card, 1);
3567 for (i = 0; i < 5; i++) {
3568 if (cs_hardware_init(card) != 0) {
3569 CS_DBGOUT(CS_PM | CS_ERROR, 4, printk(
3570 "cs46xx: cs46xx_resume()- ERROR in cs_hardware_init()\n"));
3571 mdelay(10 * cs_laptop_wait);
3578 CS_DBGOUT(CS_PM | CS_ERROR, 1, printk(
3579 "cs46xx: cs46xx_resume()- cs_hardware_init() failed, retried %d times.\n",i));
3583 if (cs46xx_restart_part(card)) {
3584 CS_DBGOUT(CS_PM | CS_ERROR, 4, printk(
3585 "cs46xx: cs46xx_resume(): cs46xx_restart_part() returned error\n"));
3588 card->active_ctrl(card, -1);
3590 CS_DBGOUT(CS_PM | CS_FUNCTION, 4, printk("cs46xx: cs46xx_resume()- flags=0x%x\n",
3591 (unsigned)card->pm.flags));
3595 static /*const*/ struct file_operations cs461x_fops = {
3596 CS_OWNER CS_THIS_MODULE
3597 .llseek = no_llseek,
3604 .release = cs_release,
3607 /* Write AC97 codec registers */
3610 static u16 _cs_ac97_get(struct ac97_codec *dev, u8 reg)
3612 struct cs_card *card = dev->private_data;
3618 * 1. Write ACCAD = Command Address Register = 46Ch for AC97 register address
3619 * 2. Write ACCDA = Command Data Register = 470h for data to write to AC97
3620 * 3. Write ACCTL = Control Register = 460h for initiating the write
3621 * 4. Read ACCTL = 460h, DCV should be reset by now and 460h = 17h
3622 * 5. if DCV not cleared, break and return error
3623 * 6. Read ACSTS = Status Register = 464h, check VSTS bit
3626 cs461x_peekBA0(card, BA0_ACSDA);
3629 * Setup the AC97 control registers on the CS461x to send the
3630 * appropriate command to the AC97 to perform the read.
3631 * ACCAD = Command Address Register = 46Ch
3632 * ACCDA = Command Data Register = 470h
3633 * ACCTL = Control Register = 460h
3634 * set DCV - will clear when process completed
3635 * set CRW - Read command
3636 * set VFRM - valid frame enabled
3637 * set ESYN - ASYNC generation enabled
3638 * set RSTN - ARST# inactive, AC97 codec not reset
3641 cs461x_pokeBA0(card, BA0_ACCAD, reg);
3642 cs461x_pokeBA0(card, BA0_ACCDA, 0);
3643 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_DCV | ACCTL_CRW |
3644 ACCTL_VFRM | ACCTL_ESYN |
3649 * Wait for the read to occur.
3651 if (!(card->pm.flags & CS46XX_PM_IDLE))
3654 loopcnt = 500 * cs_laptop_wait;
3655 loopcnt *= cs_laptop_wait;
3656 for (count = 0; count < loopcnt; count++) {
3658 * First, we want to wait for a short time.
3660 udelay(10 * cs_laptop_wait);
3662 * Now, check to see if the read has completed.
3663 * ACCTL = 460h, DCV should be reset by now and 460h = 17h
3665 if (!(cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV))
3670 * Make sure the read completed.
3672 if (cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV) {
3673 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
3674 "cs46xx: AC'97 read problem (ACCTL_DCV), reg = 0x%x returning 0xffff\n", reg));
3679 * Wait for the valid status bit to go active.
3682 if (!(card->pm.flags & CS46XX_PM_IDLE))
3686 loopcnt *= cs_laptop_wait;
3687 for (count = 0; count < loopcnt; count++) {
3689 * Read the AC97 status register.
3690 * ACSTS = Status Register = 464h
3691 * VSTS - Valid Status
3693 if (cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_VSTS)
3695 udelay(10 * cs_laptop_wait);
3699 * Make sure we got valid status.
3701 if (!((tmp = cs461x_peekBA0(card, BA0_ACSTS)) & ACSTS_VSTS)) {
3702 CS_DBGOUT(CS_ERROR, 2, printk(KERN_WARNING
3703 "cs46xx: AC'97 read problem (ACSTS_VSTS), reg = 0x%x val=0x%x 0xffff \n",
3709 * Read the data returned from the AC97 register.
3710 * ACSDA = Status Data Register = 474h
3712 CS_DBGOUT(CS_FUNCTION, 9, printk(KERN_INFO
3713 "cs46xx: cs_ac97_get() reg = 0x%x, val = 0x%x, BA0_ACCAD = 0x%x\n",
3714 reg, cs461x_peekBA0(card, BA0_ACSDA),
3715 cs461x_peekBA0(card, BA0_ACCAD)));
3716 ret = cs461x_peekBA0(card, BA0_ACSDA);
3720 static u16 cs_ac97_get(struct ac97_codec *dev, u8 reg)
3723 struct cs_card *card = dev->private_data;
3725 spin_lock(&card->ac97_lock);
3726 ret = _cs_ac97_get(dev, reg);
3727 spin_unlock(&card->ac97_lock);
3731 static void cs_ac97_set(struct ac97_codec *dev, u8 reg, u16 val)
3733 struct cs_card *card = dev->private_data;
3737 spin_lock(&card->ac97_lock);
3739 if (reg == AC97_CD_VOL)
3740 val2 = _cs_ac97_get(dev, AC97_CD_VOL);
3743 * 1. Write ACCAD = Command Address Register = 46Ch for AC97 register address
3744 * 2. Write ACCDA = Command Data Register = 470h for data to write to AC97
3745 * 3. Write ACCTL = Control Register = 460h for initiating the write
3746 * 4. Read ACCTL = 460h, DCV should be reset by now and 460h = 07h
3747 * 5. if DCV not cleared, break and return error
3751 * Setup the AC97 control registers on the CS461x to send the
3752 * appropriate command to the AC97 to perform the read.
3753 * ACCAD = Command Address Register = 46Ch
3754 * ACCDA = Command Data Register = 470h
3755 * ACCTL = Control Register = 460h
3756 * set DCV - will clear when process completed
3757 * reset CRW - Write command
3758 * set VFRM - valid frame enabled
3759 * set ESYN - ASYNC generation enabled
3760 * set RSTN - ARST# inactive, AC97 codec not reset
3762 cs461x_pokeBA0(card, BA0_ACCAD, reg);
3763 cs461x_pokeBA0(card, BA0_ACCDA, val);
3764 cs461x_peekBA0(card, BA0_ACCTL);
3765 cs461x_pokeBA0(card, BA0_ACCTL, 0 | ACCTL_VFRM | ACCTL_ESYN | ACCTL_RSTN);
3766 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_DCV | ACCTL_VFRM |
3767 ACCTL_ESYN | ACCTL_RSTN);
3768 for (count = 0; count < 1000; count++) {
3770 * First, we want to wait for a short time.
3772 udelay(10 * cs_laptop_wait);
3774 * Now, check to see if the write has completed.
3775 * ACCTL = 460h, DCV should be reset by now and 460h = 07h
3777 if (!(cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV))
3781 * Make sure the write completed.
3783 if (cs461x_peekBA0(card, BA0_ACCTL) & ACCTL_DCV) {
3784 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
3785 "cs46xx: AC'97 write problem, reg = 0x%x, val = 0x%x\n", reg, val));
3788 spin_unlock(&card->ac97_lock);
3791 * Adjust power if the mixer is selected/deselected according
3794 * IF the CD is a valid input source (mixer or direct) AND
3795 * the CD is not muted THEN power is needed
3797 * We do two things. When record select changes the input to
3798 * add/remove the CD we adjust the power count if the CD is
3801 * When the CD mute changes we adjust the power level if the
3802 * CD was a valid input.
3804 * We also check for CD volume != 0, as the CD mute isn't
3805 * normally tweaked from userspace.
3808 /* CD mute change ? */
3810 if (reg == AC97_CD_VOL) {
3811 /* Mute bit change ? */
3812 if ((val2^val) & 0x8000 ||
3813 ((val2 == 0x1f1f || val == 0x1f1f) && val2 != val)) {
3814 /* This is a hack but its cleaner than the alternatives.
3815 Right now card->ac97_codec[0] might be NULL as we are
3816 still doing codec setup. This does an early assignment
3817 to avoid the problem if it occurs */
3819 if (card->ac97_codec[0] == NULL)
3820 card->ac97_codec[0] = dev;
3823 if (val & 0x8000 || val == 0x1f1f)
3824 card->amplifier_ctrl(card, -1);
3825 else { /* Mute off power on */
3827 card->amp_init(card);
3828 card->amplifier_ctrl(card, 1);
3834 /* OSS /dev/mixer file operation methods */
3836 static int cs_open_mixdev(struct inode *inode, struct file *file)
3839 unsigned int minor = iminor(inode);
3840 struct cs_card *card = NULL;
3841 struct list_head *entry;
3844 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4,
3845 printk(KERN_INFO "cs46xx: cs_open_mixdev()+\n"));
3847 list_for_each(entry, &cs46xx_devs) {
3848 card = list_entry(entry, struct cs_card, list);
3849 for (i = 0; i < NR_AC97; i++)
3850 if (card->ac97_codec[i] != NULL &&
3851 card->ac97_codec[i]->dev_mixer == minor)
3855 CS_DBGOUT(CS_FUNCTION | CS_OPEN | CS_ERROR, 2,
3856 printk(KERN_INFO "cs46xx: cs46xx_open_mixdev()- -ENODEV\n"));
3860 if (!card->ac97_codec[i])
3862 file->private_data = card->ac97_codec[i];
3864 card->active_ctrl(card,1);
3865 if (!CS_IN_USE(&card->mixer_use_cnt)) {
3866 if ((tmp = cs46xx_powerup(card, CS_POWER_MIXVON))) {
3867 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3868 "cs46xx: cs_open_mixdev() powerup failure (0x%x)\n", tmp));
3872 card->amplifier_ctrl(card, 1);
3873 CS_INC_USE_COUNT(&card->mixer_use_cnt);
3874 CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4,
3875 printk(KERN_INFO "cs46xx: cs_open_mixdev()- 0\n"));
3876 return nonseekable_open(inode, file);
3879 static int cs_release_mixdev(struct inode *inode, struct file *file)
3881 unsigned int minor = iminor(inode);
3882 struct cs_card *card = NULL;
3883 struct list_head *entry;
3887 CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 4,
3888 printk(KERN_INFO "cs46xx: cs_release_mixdev()+\n"));
3889 list_for_each(entry, &cs46xx_devs)
3891 card = list_entry(entry, struct cs_card, list);
3892 for (i = 0; i < NR_AC97; i++)
3893 if (card->ac97_codec[i] != NULL &&
3894 card->ac97_codec[i]->dev_mixer == minor)
3898 CS_DBGOUT(CS_FUNCTION | CS_OPEN | CS_ERROR, 2,
3899 printk(KERN_INFO "cs46xx: cs46xx_open_mixdev()- -ENODEV\n"));
3903 if (!CS_DEC_AND_TEST(&card->mixer_use_cnt)) {
3904 CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 4,
3905 printk(KERN_INFO "cs46xx: cs_release_mixdev()- no powerdown, usecnt>0\n"));
3906 card->active_ctrl(card, -1);
3907 card->amplifier_ctrl(card, -1);
3911 * ok, no outstanding mixer opens, so powerdown.
3913 if ((tmp = cs461x_powerdown(card, CS_POWER_MIXVON, CS_FALSE))) {
3914 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
3915 "cs46xx: cs_release_mixdev() powerdown MIXVON failure (0x%x)\n", tmp));
3916 card->active_ctrl(card, -1);
3917 card->amplifier_ctrl(card, -1);
3920 card->active_ctrl(card, -1);
3921 card->amplifier_ctrl(card, -1);
3922 CS_DBGOUT(CS_FUNCTION | CS_RELEASE, 4,
3923 printk(KERN_INFO "cs46xx: cs_release_mixdev()- 0\n"));
3927 static int cs_ioctl_mixdev(struct inode *inode, struct file *file, unsigned int cmd,
3930 struct ac97_codec *codec = file->private_data;
3931 struct cs_card *card = NULL;
3932 struct list_head *entry;
3933 unsigned long __user *p = (long __user *)arg;
3934 #if CSDEBUG_INTERFACE
3937 if ( (cmd == SOUND_MIXER_CS_GETDBGMASK) ||
3938 (cmd == SOUND_MIXER_CS_SETDBGMASK) ||
3939 (cmd == SOUND_MIXER_CS_GETDBGLEVEL) ||
3940 (cmd == SOUND_MIXER_CS_SETDBGLEVEL) ||
3941 (cmd == SOUND_MIXER_CS_APM)) {
3943 case SOUND_MIXER_CS_GETDBGMASK:
3944 return put_user(cs_debugmask, p);
3945 case SOUND_MIXER_CS_GETDBGLEVEL:
3946 return put_user(cs_debuglevel, p);
3947 case SOUND_MIXER_CS_SETDBGMASK:
3948 if (get_user(val, p))
3952 case SOUND_MIXER_CS_SETDBGLEVEL:
3953 if (get_user(val, p))
3955 cs_debuglevel = val;
3957 case SOUND_MIXER_CS_APM:
3958 if (get_user(val, p))
3960 if (val == CS_IOCTL_CMD_SUSPEND) {
3961 list_for_each(entry, &cs46xx_devs) {
3962 card = list_entry(entry, struct cs_card, list);
3963 cs46xx_suspend(card, PMSG_ON);
3966 } else if (val == CS_IOCTL_CMD_RESUME) {
3967 list_for_each(entry, &cs46xx_devs) {
3968 card = list_entry(entry, struct cs_card, list);
3969 cs46xx_resume(card);
3972 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
3973 "cs46xx: mixer_ioctl(): invalid APM cmd (%d)\n",
3978 CS_DBGOUT(CS_ERROR, 1, printk(KERN_INFO
3979 "cs46xx: mixer_ioctl(): ERROR unknown debug cmd\n"));
3984 return codec->mixer_ioctl(codec, cmd, arg);
3987 static /*const*/ struct file_operations cs_mixer_fops = {
3988 CS_OWNER CS_THIS_MODULE
3989 .llseek = no_llseek,
3990 .ioctl = cs_ioctl_mixdev,
3991 .open = cs_open_mixdev,
3992 .release = cs_release_mixdev,
3995 /* AC97 codec initialisation. */
3996 static int __init cs_ac97_init(struct cs_card *card)
4000 struct ac97_codec *codec;
4003 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4004 "cs46xx: cs_ac97_init()+\n") );
4006 for (num_ac97 = 0; num_ac97 < NR_AC97; num_ac97++) {
4007 if ((codec = ac97_alloc_codec()) == NULL)
4010 /* initialize some basic codec information, other fields will be filled
4011 in ac97_probe_codec */
4012 codec->private_data = card;
4013 codec->id = num_ac97;
4015 codec->codec_read = cs_ac97_get;
4016 codec->codec_write = cs_ac97_set;
4018 if (ac97_probe_codec(codec) == 0) {
4019 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4020 "cs46xx: cs_ac97_init()- codec number %d not found\n",
4022 card->ac97_codec[num_ac97] = NULL;
4025 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4026 "cs46xx: cs_ac97_init() found codec %d\n",num_ac97));
4028 eid = cs_ac97_get(codec, AC97_EXTENDED_ID);
4030 if (eid == 0xFFFF) {
4031 printk(KERN_WARNING "cs46xx: codec %d not present\n",num_ac97);
4032 ac97_release_codec(codec);
4036 card->ac97_features = eid;
4038 if ((codec->dev_mixer = register_sound_mixer(&cs_mixer_fops, -1)) < 0) {
4039 printk(KERN_ERR "cs46xx: couldn't register mixer!\n");
4040 ac97_release_codec(codec);
4043 card->ac97_codec[num_ac97] = codec;
4045 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4046 "cs46xx: cs_ac97_init() ac97_codec[%d] set to %p\n",
4047 (unsigned int)num_ac97,
4049 /* if there is no secondary codec at all, don't probe any more */
4056 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4057 "cs46xx: cs_ac97_init()- %d\n", (unsigned int)num_ac97));
4062 * load the static image into the DSP
4064 #include "cs461x_image.h"
4065 static void cs461x_download_image(struct cs_card *card)
4067 unsigned i, j, temp1, temp2, offset, count;
4068 unsigned char __iomem *pBA1 = ioremap(card->ba1_addr, 0x40000);
4069 for (i = 0; i < CLEAR__COUNT; i++) {
4070 offset = ClrStat[i].BA1__DestByteOffset;
4071 count = ClrStat[i].BA1__SourceSize;
4072 for (temp1 = offset; temp1 < (offset + count); temp1 += 4)
4073 writel(0, pBA1+temp1);
4076 for (i = 0; i < FILL__COUNT; i++) {
4077 temp2 = FillStat[i].Offset;
4078 for (j = 0; j < (FillStat[i].Size) / 4; j++) {
4079 temp1 = (FillStat[i]).pFill[j];
4080 writel(temp1, pBA1+temp2 + j * 4);
4090 static void cs461x_reset(struct cs_card *card)
4095 * Write the reset bit of the SP control register.
4097 cs461x_poke(card, BA1_SPCR, SPCR_RSTSP);
4100 * Write the control register.
4102 cs461x_poke(card, BA1_SPCR, SPCR_DRQEN);
4105 * Clear the trap registers.
4107 for (idx = 0; idx < 8; idx++) {
4108 cs461x_poke(card, BA1_DREG, DREG_REGID_TRAP_SELECT + idx);
4109 cs461x_poke(card, BA1_TWPR, 0xFFFF);
4111 cs461x_poke(card, BA1_DREG, 0);
4114 * Set the frame timer to reflect the number of cycles per frame.
4116 cs461x_poke(card, BA1_FRMT, 0xadf);
4119 static void cs461x_clear_serial_FIFOs(struct cs_card *card, int type)
4121 int idx, loop, startfifo=0, endfifo=0, powerdown1 = 0;
4125 * See if the devices are powered down. If so, we must power them up first
4126 * or they will not respond.
4128 if (!((tmp = cs461x_peekBA0(card, BA0_CLKCR1)) & CLKCR1_SWCE)) {
4129 cs461x_pokeBA0(card, BA0_CLKCR1, tmp | CLKCR1_SWCE);
4134 * We want to clear out the serial port FIFOs so we don't end up playing
4135 * whatever random garbage happens to be in them. We fill the sample FIFOS
4136 * with zero (silence).
4138 cs461x_pokeBA0(card, BA0_SERBWP, 0);
4141 * Check for which FIFO locations to clear, if we are currently
4142 * playing or capturing then we don't want to put in 128 bytes of
4145 if (type & CS_TYPE_DAC) {
4149 if (type & CS_TYPE_ADC) {
4155 * Fill sample FIFO locations (256 locations total).
4157 for (idx = startfifo; idx < endfifo; idx++) {
4159 * Make sure the previous FIFO write operation has completed.
4161 for (loop = 0; loop < 5; loop++) {
4163 if (!(cs461x_peekBA0(card, BA0_SERBST) & SERBST_WBSY))
4166 if (cs461x_peekBA0(card, BA0_SERBST) & SERBST_WBSY) {
4168 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
4171 * Write the serial port FIFO index.
4173 cs461x_pokeBA0(card, BA0_SERBAD, idx);
4175 * Tell the serial port to load the new value into the FIFO location.
4177 cs461x_pokeBA0(card, BA0_SERBCM, SERBCM_WRC);
4180 * Now, if we powered up the devices, then power them back down again.
4181 * This is kinda ugly, but should never happen.
4184 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
4188 static int cs461x_powerdown(struct cs_card *card, unsigned int type, int suspendflag)
4191 unsigned int tmp=0,muted=0;
4193 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO
4194 "cs46xx: cs461x_powerdown()+ type=0x%x\n",type));
4195 if (!cs_powerdown && !suspendflag) {
4196 CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4197 "cs46xx: cs461x_powerdown() DISABLED exiting\n"));
4200 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4201 CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4202 "cs46xx: cs461x_powerdown() powerdown reg=0x%x\n",tmp));
4204 * if powering down only the VREF, and not powering down the DAC/ADC,
4205 * then do not power down the VREF, UNLESS both the DAC and ADC are not
4206 * currently powered down. If powering down DAC and ADC, then
4207 * it is possible to power down the VREF (ON).
4209 if (((type & CS_POWER_MIXVON) &&
4210 (!(type & CS_POWER_ADC) || (!(type & CS_POWER_DAC))))
4212 ((tmp & CS_AC97_POWER_CONTROL_ADC_ON) ||
4213 (tmp & CS_AC97_POWER_CONTROL_DAC_ON))) {
4214 CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4215 "cs46xx: cs461x_powerdown()- 0 unable to powerdown. tmp=0x%x\n",tmp));
4219 * for now, always keep power to the mixer block.
4220 * not sure why it's a problem but it seems to be if we power off.
4222 type &= ~CS_POWER_MIXVON;
4223 type &= ~CS_POWER_MIXVOFF;
4226 * Power down indicated areas.
4228 if (type & CS_POWER_MIXVOFF) {
4230 CS_DBGOUT(CS_FUNCTION, 4,
4231 printk(KERN_INFO "cs46xx: cs461x_powerdown()+ MIXVOFF\n"));
4233 * Power down the MIXER (VREF ON) on the AC97 card.
4235 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4236 if (tmp & CS_AC97_POWER_CONTROL_MIXVOFF_ON) {
4238 cs_mute(card, CS_TRUE);
4241 tmp |= CS_AC97_POWER_CONTROL_MIXVOFF;
4242 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4244 * Now, we wait until we sample a ready state.
4246 for (count = 0; count < 32; count++) {
4248 * First, lets wait a short while to let things settle out a
4249 * bit, and to prevent retrying the read too quickly.
4254 * Read the current state of the power control register.
4256 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4257 CS_AC97_POWER_CONTROL_MIXVOFF_ON))
4262 * Check the status..
4264 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4265 CS_AC97_POWER_CONTROL_MIXVOFF_ON) {
4266 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4267 "cs46xx: powerdown MIXVOFF failed\n"));
4272 if (type & CS_POWER_MIXVON) {
4274 CS_DBGOUT(CS_FUNCTION, 4,
4275 printk(KERN_INFO "cs46xx: cs461x_powerdown()+ MIXVON\n"));
4277 * Power down the MIXER (VREF ON) on the AC97 card.
4279 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4280 if (tmp & CS_AC97_POWER_CONTROL_MIXVON_ON) {
4282 cs_mute(card, CS_TRUE);
4285 tmp |= CS_AC97_POWER_CONTROL_MIXVON;
4286 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp);
4288 * Now, we wait until we sample a ready state.
4290 for (count = 0; count < 32; count++) {
4292 * First, lets wait a short while to let things settle out a
4293 * bit, and to prevent retrying the read too quickly.
4298 * Read the current state of the power control register.
4300 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4301 CS_AC97_POWER_CONTROL_MIXVON_ON))
4306 * Check the status..
4308 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4309 CS_AC97_POWER_CONTROL_MIXVON_ON) {
4310 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4311 "cs46xx: powerdown MIXVON failed\n"));
4316 if (type & CS_POWER_ADC) {
4318 * Power down the ADC on the AC97 card.
4320 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO "cs46xx: cs461x_powerdown()+ ADC\n"));
4321 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4322 if (tmp & CS_AC97_POWER_CONTROL_ADC_ON) {
4324 cs_mute(card, CS_TRUE);
4327 tmp |= CS_AC97_POWER_CONTROL_ADC;
4328 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp);
4331 * Now, we wait until we sample a ready state.
4333 for (count = 0; count < 32; count++) {
4335 * First, lets wait a short while to let things settle out a
4336 * bit, and to prevent retrying the read too quickly.
4341 * Read the current state of the power control register.
4343 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4344 CS_AC97_POWER_CONTROL_ADC_ON))
4349 * Check the status..
4351 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4352 CS_AC97_POWER_CONTROL_ADC_ON) {
4353 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4354 "cs46xx: powerdown ADC failed\n"));
4359 if (type & CS_POWER_DAC) {
4361 * Power down the DAC on the AC97 card.
4364 CS_DBGOUT(CS_FUNCTION, 4,
4365 printk(KERN_INFO "cs46xx: cs461x_powerdown()+ DAC\n"));
4366 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4367 if (tmp & CS_AC97_POWER_CONTROL_DAC_ON) {
4369 cs_mute(card, CS_TRUE);
4372 tmp |= CS_AC97_POWER_CONTROL_DAC;
4373 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp);
4375 * Now, we wait until we sample a ready state.
4377 for (count = 0; count < 32; count++) {
4379 * First, lets wait a short while to let things settle out a
4380 * bit, and to prevent retrying the read too quickly.
4385 * Read the current state of the power control register.
4387 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4388 CS_AC97_POWER_CONTROL_DAC_ON))
4393 * Check the status..
4395 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4396 CS_AC97_POWER_CONTROL_DAC_ON) {
4397 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4398 "cs46xx: powerdown DAC failed\n"));
4403 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4405 cs_mute(card, CS_FALSE);
4406 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO
4407 "cs46xx: cs461x_powerdown()- 0 tmp=0x%x\n",tmp));
4411 static int cs46xx_powerup(struct cs_card *card, unsigned int type)
4414 unsigned int tmp = 0, muted = 0;
4416 CS_DBGOUT(CS_FUNCTION, 8, printk(KERN_INFO
4417 "cs46xx: cs46xx_powerup()+ type=0x%x\n",type));
4419 * check for VREF and powerup if need to.
4421 if (type & CS_POWER_MIXVON)
4422 type |= CS_POWER_MIXVOFF;
4423 if (type & (CS_POWER_DAC | CS_POWER_ADC))
4424 type |= CS_POWER_MIXVON | CS_POWER_MIXVOFF;
4427 * Power up indicated areas.
4429 if (type & CS_POWER_MIXVOFF) {
4431 CS_DBGOUT(CS_FUNCTION, 4,
4432 printk(KERN_INFO "cs46xx: cs46xx_powerup()+ MIXVOFF\n"));
4434 * Power up the MIXER (VREF ON) on the AC97 card.
4436 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4437 if (!(tmp & CS_AC97_POWER_CONTROL_MIXVOFF_ON)) {
4439 cs_mute(card, CS_TRUE);
4442 tmp &= ~CS_AC97_POWER_CONTROL_MIXVOFF;
4443 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4445 * Now, we wait until we sample a ready state.
4447 for (count = 0; count < 32; count++) {
4449 * First, lets wait a short while to let things settle out a
4450 * bit, and to prevent retrying the read too quickly.
4455 * Read the current state of the power control register.
4457 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4458 CS_AC97_POWER_CONTROL_MIXVOFF_ON)
4463 * Check the status..
4465 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4466 CS_AC97_POWER_CONTROL_MIXVOFF_ON)) {
4467 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4468 "cs46xx: powerup MIXVOFF failed\n"));
4473 if(type & CS_POWER_MIXVON) {
4475 CS_DBGOUT(CS_FUNCTION, 4,
4476 printk(KERN_INFO "cs46xx: cs46xx_powerup()+ MIXVON\n"));
4478 * Power up the MIXER (VREF ON) on the AC97 card.
4480 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4481 if (!(tmp & CS_AC97_POWER_CONTROL_MIXVON_ON)) {
4483 cs_mute(card, CS_TRUE);
4486 tmp &= ~CS_AC97_POWER_CONTROL_MIXVON;
4487 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4489 * Now, we wait until we sample a ready state.
4491 for (count = 0; count < 32; count++) {
4493 * First, lets wait a short while to let things settle out a
4494 * bit, and to prevent retrying the read too quickly.
4499 * Read the current state of the power control register.
4501 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4502 CS_AC97_POWER_CONTROL_MIXVON_ON)
4507 * Check the status..
4509 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4510 CS_AC97_POWER_CONTROL_MIXVON_ON)) {
4511 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4512 "cs46xx: powerup MIXVON failed\n"));
4517 if (type & CS_POWER_ADC) {
4519 * Power up the ADC on the AC97 card.
4521 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO "cs46xx: cs46xx_powerup()+ ADC\n"));
4522 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4523 if (!(tmp & CS_AC97_POWER_CONTROL_ADC_ON)) {
4525 cs_mute(card, CS_TRUE);
4528 tmp &= ~CS_AC97_POWER_CONTROL_ADC;
4529 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4532 * Now, we wait until we sample a ready state.
4534 for (count = 0; count < 32; count++) {
4536 * First, lets wait a short while to let things settle out a
4537 * bit, and to prevent retrying the read too quickly.
4542 * Read the current state of the power control register.
4544 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4545 CS_AC97_POWER_CONTROL_ADC_ON)
4550 * Check the status..
4552 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4553 CS_AC97_POWER_CONTROL_ADC_ON)) {
4554 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4555 "cs46xx: powerup ADC failed\n"));
4560 if (type & CS_POWER_DAC) {
4562 * Power up the DAC on the AC97 card.
4565 CS_DBGOUT(CS_FUNCTION, 4,
4566 printk(KERN_INFO "cs46xx: cs46xx_powerup()+ DAC\n"));
4567 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4568 if (!(tmp & CS_AC97_POWER_CONTROL_DAC_ON)) {
4570 cs_mute(card, CS_TRUE);
4573 tmp &= ~CS_AC97_POWER_CONTROL_DAC;
4574 cs_ac97_set(card->ac97_codec[0], AC97_POWER_CONTROL, tmp );
4576 * Now, we wait until we sample a ready state.
4578 for (count = 0; count < 32; count++) {
4580 * First, lets wait a short while to let things settle out a
4581 * bit, and to prevent retrying the read too quickly.
4586 * Read the current state of the power control register.
4588 if (cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4589 CS_AC97_POWER_CONTROL_DAC_ON)
4594 * Check the status..
4596 if (!(cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL) &
4597 CS_AC97_POWER_CONTROL_DAC_ON)) {
4598 CS_DBGOUT(CS_ERROR, 1, printk(KERN_WARNING
4599 "cs46xx: powerup DAC failed\n"));
4604 tmp = cs_ac97_get(card->ac97_codec[0], AC97_POWER_CONTROL);
4606 cs_mute(card, CS_FALSE);
4607 CS_DBGOUT(CS_FUNCTION, 4, printk(KERN_INFO
4608 "cs46xx: cs46xx_powerup()- 0 tmp=0x%x\n",tmp));
4612 static void cs461x_proc_start(struct cs_card *card)
4617 * Set the frame timer to reflect the number of cycles per frame.
4619 cs461x_poke(card, BA1_FRMT, 0xadf);
4621 * Turn on the run, run at frame, and DMA enable bits in the local copy of
4622 * the SP control register.
4624 cs461x_poke(card, BA1_SPCR, SPCR_RUN | SPCR_RUNFR | SPCR_DRQEN);
4626 * Wait until the run at frame bit resets itself in the SP control
4629 for (cnt = 0; cnt < 25; cnt++) {
4631 if (!(cs461x_peek(card, BA1_SPCR) & SPCR_RUNFR))
4635 if (cs461x_peek(card, BA1_SPCR) & SPCR_RUNFR)
4636 printk(KERN_WARNING "cs46xx: SPCR_RUNFR never reset\n");
4639 static void cs461x_proc_stop(struct cs_card *card)
4642 * Turn off the run, run at frame, and DMA enable bits in the local copy of
4643 * the SP control register.
4645 cs461x_poke(card, BA1_SPCR, 0);
4648 static int cs_hardware_init(struct cs_card *card)
4650 unsigned long end_time;
4651 unsigned int tmp,count;
4653 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4654 "cs46xx: cs_hardware_init()+\n") );
4656 * First, blast the clock control register to zero so that the PLL starts
4657 * out in a known state, and blast the master serial port control register
4658 * to zero so that the serial ports also start out in a known state.
4660 cs461x_pokeBA0(card, BA0_CLKCR1, 0);
4661 cs461x_pokeBA0(card, BA0_SERMC1, 0);
4664 * If we are in AC97 mode, then we must set the part to a host controlled
4665 * AC-link. Otherwise, we won't be able to bring up the link.
4667 cs461x_pokeBA0(card, BA0_SERACC, SERACC_HSP | SERACC_CODEC_TYPE_1_03); /* 1.03 card */
4668 /* cs461x_pokeBA0(card, BA0_SERACC, SERACC_HSP | SERACC_CODEC_TYPE_2_0); */ /* 2.00 card */
4671 * Drive the ARST# pin low for a minimum of 1uS (as defined in the AC97
4672 * spec) and then drive it high. This is done for non AC97 modes since
4673 * there might be logic external to the CS461x that uses the ARST# line
4676 cs461x_pokeBA0(card, BA0_ACCTL, 1);
4678 cs461x_pokeBA0(card, BA0_ACCTL, 0);
4680 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_RSTN);
4683 * The first thing we do here is to enable sync generation. As soon
4684 * as we start receiving bit clock, we'll start producing the SYNC
4687 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_ESYN | ACCTL_RSTN);
4690 * Now wait for a short while to allow the AC97 part to start
4691 * generating bit clock (so we don't try to start the PLL without an
4694 mdelay(5 * cs_laptop_wait); /* 1 should be enough ?? (and pigs might fly) */
4697 * Set the serial port timing configuration, so that
4698 * the clock control circuit gets its clock from the correct place.
4700 cs461x_pokeBA0(card, BA0_SERMC1, SERMC1_PTC_AC97);
4703 * The part seems to not be ready for a while after a resume.
4704 * so, if we are resuming, then wait for 700 mils. Note that 600 mils
4705 * is not enough for some platforms! tested on an IBM Thinkpads and
4708 if (!(card->pm.flags & CS46XX_PM_IDLE))
4711 * Write the selected clock control setup to the hardware. Do not turn on
4712 * SWCE yet (if requested), so that the devices clocked by the output of
4713 * PLL are not clocked until the PLL is stable.
4715 cs461x_pokeBA0(card, BA0_PLLCC, PLLCC_LPF_1050_2780_KHZ | PLLCC_CDR_73_104_MHZ);
4716 cs461x_pokeBA0(card, BA0_PLLM, 0x3a);
4717 cs461x_pokeBA0(card, BA0_CLKCR2, CLKCR2_PDIVS_8);
4722 cs461x_pokeBA0(card, BA0_CLKCR1, CLKCR1_PLLP);
4725 * Wait until the PLL has stabilized.
4727 mdelay(5 * cs_laptop_wait); /* Again 1 should be enough ?? */
4730 * Turn on clocking of the core so that we can setup the serial ports.
4732 tmp = cs461x_peekBA0(card, BA0_CLKCR1) | CLKCR1_SWCE;
4733 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
4736 * Fill the serial port FIFOs with silence.
4738 cs461x_clear_serial_FIFOs(card,CS_TYPE_DAC | CS_TYPE_ADC);
4741 * Set the serial port FIFO pointer to the first sample in the FIFO.
4743 /* cs461x_pokeBA0(card, BA0_SERBSP, 0); */
4746 * Write the serial port configuration to the part. The master
4747 * enable bit is not set until all other values have been written.
4749 cs461x_pokeBA0(card, BA0_SERC1, SERC1_SO1F_AC97 | SERC1_SO1EN);
4750 cs461x_pokeBA0(card, BA0_SERC2, SERC2_SI1F_AC97 | SERC1_SO1EN);
4751 cs461x_pokeBA0(card, BA0_SERMC1, SERMC1_PTC_AC97 | SERMC1_MSPE);
4754 mdelay(5 * cs_laptop_wait); /* Shouldnt be needed ?? */
4757 * If we are resuming under 2.2.x then we cannot schedule a timeout,
4758 * so just spin the CPU.
4760 if (card->pm.flags & CS46XX_PM_IDLE) {
4762 * Wait for the card ready signal from the AC97 card.
4764 end_time = jiffies + 3 * (HZ >> 2);
4767 * Read the AC97 status register to see if we've seen a CODEC READY
4768 * signal from the AC97 card.
4770 if (cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_CRDY)
4772 current->state = TASK_UNINTERRUPTIBLE;
4773 schedule_timeout(1);
4774 } while (time_before(jiffies, end_time));
4776 for (count = 0; count < 100; count++) {
4777 // First, we want to wait for a short time.
4778 udelay(25 * cs_laptop_wait);
4780 if (cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_CRDY)
4786 * Make sure CODEC is READY.
4788 if (!(cs461x_peekBA0(card, BA0_ACSTS) & ACSTS_CRDY)) {
4789 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_WARNING
4790 "cs46xx: create - never read card ready from AC'97\n"));
4791 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_WARNING
4792 "cs46xx: probably not a bug, try using the CS4232 driver,\n"));
4793 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_WARNING
4794 "cs46xx: or turn off any automatic Power Management support in the BIOS.\n"));
4799 * Assert the vaid frame signal so that we can start sending commands
4802 cs461x_pokeBA0(card, BA0_ACCTL, ACCTL_VFRM | ACCTL_ESYN | ACCTL_RSTN);
4804 if (card->pm.flags & CS46XX_PM_IDLE) {
4806 * Wait until we've sampled input slots 3 and 4 as valid, meaning that
4807 * the card is pumping ADC data across the AC-link.
4809 end_time = jiffies + 3 * (HZ >> 2);
4812 * Read the input slot valid register and see if input slots 3 and
4815 if ((cs461x_peekBA0(card, BA0_ACISV) & (ACISV_ISV3 | ACISV_ISV4)) == (ACISV_ISV3 | ACISV_ISV4))
4817 current->state = TASK_UNINTERRUPTIBLE;
4818 schedule_timeout(1);
4819 } while (time_before(jiffies, end_time));
4821 for (count = 0; count < 100; count++) {
4822 // First, we want to wait for a short time.
4823 udelay(25 * cs_laptop_wait);
4825 if ((cs461x_peekBA0(card, BA0_ACISV) & (ACISV_ISV3 | ACISV_ISV4)) == (ACISV_ISV3 | ACISV_ISV4))
4830 * Make sure input slots 3 and 4 are valid. If not, then return
4833 if ((cs461x_peekBA0(card, BA0_ACISV) & (ACISV_ISV3 | ACISV_ISV4)) != (ACISV_ISV3 | ACISV_ISV4)) {
4834 printk(KERN_WARNING "cs46xx: create - never read ISV3 & ISV4 from AC'97\n");
4839 * Now, assert valid frame and the slot 3 and 4 valid bits. This will
4840 * commense the transfer of digital audio data to the AC97 card.
4842 cs461x_pokeBA0(card, BA0_ACOSV, ACOSV_SLV3 | ACOSV_SLV4);
4845 * Turn off the Processor by turning off the software clock enable flag in
4846 * the clock control register.
4848 /* tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE; */
4849 /* cs461x_pokeBA0(card, BA0_CLKCR1, tmp); */
4852 * Reset the processor.
4857 * Download the image to the processor.
4860 cs461x_download_image(card);
4863 * Stop playback DMA.
4865 tmp = cs461x_peek(card, BA1_PCTL);
4866 card->pctl = tmp & 0xffff0000;
4867 cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
4872 tmp = cs461x_peek(card, BA1_CCTL);
4873 card->cctl = tmp & 0x0000ffff;
4874 cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
4876 /* initialize AC97 codec and register /dev/mixer */
4877 if (card->pm.flags & CS46XX_PM_IDLE) {
4878 if (cs_ac97_init(card) <= 0) {
4879 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
4880 "cs46xx: cs_ac97_init() failure\n"));
4884 cs46xx_ac97_resume(card);
4887 cs461x_proc_start(card);
4890 * Enable interrupts on the part.
4892 cs461x_pokeBA0(card, BA0_HICR, HICR_IEV | HICR_CHGM);
4894 tmp = cs461x_peek(card, BA1_PFIE);
4896 cs461x_poke(card, BA1_PFIE, tmp); /* playback interrupt enable */
4898 tmp = cs461x_peek(card, BA1_CIE);
4901 cs461x_poke(card, BA1_CIE, tmp); /* capture interrupt enable */
4904 * If IDLE then Power down the part. We will power components up
4905 * when we need them.
4907 if (card->pm.flags & CS46XX_PM_IDLE) {
4908 if (!cs_powerdown) {
4909 if ((tmp = cs46xx_powerup(card, CS_POWER_DAC | CS_POWER_ADC |
4910 CS_POWER_MIXVON))) {
4911 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
4912 "cs46xx: cs461x_powerup() failure (0x%x)\n",tmp) );
4916 if ((tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
4917 CS_POWER_MIXVON, CS_FALSE))) {
4918 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
4919 "cs46xx: cs461x_powerdown() failure (0x%x)\n",tmp) );
4924 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2, printk(KERN_INFO
4925 "cs46xx: cs_hardware_init()- 0\n"));
4929 /* install the driver, we do not allocate hardware channel nor DMA buffer now, they are defered
4930 until "ACCESS" time (in prog_dmabuf called by open/read/write/ioctl/mmap) */
4941 void (*amp)(struct cs_card *, int);
4942 void (*amp_init)(struct cs_card *);
4943 void (*active)(struct cs_card *, int);
4946 static struct cs_card_type cards[] = {
4950 .name = "Genius Soundmaker 128 value",
4962 .name = "Mitac MI6020/21",
4968 .name = "Hercules Game Theatre XP",
4969 .amp = amp_hercules,
4974 .name = "Hercules Game Theatre XP",
4975 .amp = amp_hercules,
4980 .name = "Hercules Game Theatre XP",
4981 .amp = amp_hercules,
4986 .name = "Hercules Game Theatre XP",
4987 .amp = amp_hercules,
4992 .name = "Hercules Game Theatre XP",
4993 .amp = amp_hercules,
4998 .name = "Hercules Game Theatre XP",
4999 .amp = amp_hercules,
5004 .name = "Hercules Fortissimo II",
5007 /* Not sure if the 570 needs the clkrun hack */
5009 .vendor = PCI_VENDOR_ID_IBM,
5011 .name = "Thinkpad 570",
5013 .active = clkrun_hack,
5016 .vendor = PCI_VENDOR_ID_IBM,
5018 .name = "Thinkpad 600X/A20/T20",
5020 .active = clkrun_hack,
5023 .vendor = PCI_VENDOR_ID_IBM,
5025 .name = "Thinkpad 600E (unsupported)",
5028 .name = "Card without SSID set",
5033 MODULE_AUTHOR("Alan Cox <alan@redhat.com>, Jaroslav Kysela, <pcaudio@crystal.cirrus.com>");
5034 MODULE_DESCRIPTION("Crystal SoundFusion Audio Support");
5035 MODULE_LICENSE("GPL");
5037 static const char cs46xx_banner[] = KERN_INFO "Crystal 4280/46xx + AC97 Audio, version " CS46XX_MAJOR_VERSION "." CS46XX_MINOR_VERSION "." CS46XX_ARCH ", " __TIME__ " " __DATE__ "\n";
5038 static const char fndmsg[] = KERN_INFO "cs46xx: Found %d audio device(s).\n";
5040 static int __devinit cs46xx_probe(struct pci_dev *pci_dev,
5041 const struct pci_device_id *pciid)
5044 u16 ss_card, ss_vendor;
5045 struct cs_card *card;
5046 dma_addr_t dma_mask;
5047 struct cs_card_type *cp = &cards[0];
5049 CS_DBGOUT(CS_FUNCTION | CS_INIT, 2,
5050 printk(KERN_INFO "cs46xx: probe()+\n"));
5052 dma_mask = 0xffffffff; /* this enables playback and recording */
5053 if (pci_enable_device(pci_dev)) {
5054 CS_DBGOUT(CS_INIT | CS_ERROR, 1, printk(KERN_ERR
5055 "cs46xx: pci_enable_device() failed\n"));
5058 if (!RSRCISMEMORYREGION(pci_dev, 0) ||
5059 !RSRCISMEMORYREGION(pci_dev, 1)) {
5060 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
5061 "cs46xx: probe()- Memory region not assigned\n"));
5064 if (pci_dev->irq == 0) {
5065 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
5066 "cs46xx: probe() IRQ not assigned\n"));
5069 if (!pci_dma_supported(pci_dev, 0xffffffff)) {
5070 CS_DBGOUT(CS_ERROR, 1, printk(KERN_ERR
5071 "cs46xx: probe() architecture does not support 32bit PCI busmaster DMA\n"));
5074 pci_read_config_word(pci_dev, PCI_SUBSYSTEM_VENDOR_ID, &ss_vendor);
5075 pci_read_config_word(pci_dev, PCI_SUBSYSTEM_ID, &ss_card);
5077 if ((card = kmalloc(sizeof(struct cs_card), GFP_KERNEL)) == NULL) {
5078 printk(KERN_ERR "cs46xx: out of memory\n");
5081 memset(card, 0, sizeof(*card));
5082 card->ba0_addr = RSRCADDRESS(pci_dev, 0);
5083 card->ba1_addr = RSRCADDRESS(pci_dev, 1);
5084 card->pci_dev = pci_dev;
5085 card->irq = pci_dev->irq;
5086 card->magic = CS_CARD_MAGIC;
5087 spin_lock_init(&card->lock);
5088 spin_lock_init(&card->ac97_lock);
5090 pci_set_master(pci_dev);
5092 printk(cs46xx_banner);
5093 printk(KERN_INFO "cs46xx: Card found at 0x%08lx and 0x%08lx, IRQ %d\n",
5094 card->ba0_addr, card->ba1_addr, card->irq);
5096 card->alloc_pcm_channel = cs_alloc_pcm_channel;
5097 card->alloc_rec_pcm_channel = cs_alloc_rec_pcm_channel;
5098 card->free_pcm_channel = cs_free_pcm_channel;
5099 card->amplifier_ctrl = amp_none;
5100 card->active_ctrl = amp_none;
5104 if (cp->vendor == ss_vendor && cp->id == ss_card) {
5105 card->amplifier_ctrl = cp->amp;
5107 card->active_ctrl = cp->active;
5109 card->amp_init = cp->amp_init;
5114 if (cp->name == NULL) {
5115 printk(KERN_INFO "cs46xx: Unknown card (%04X:%04X) at 0x%08lx/0x%08lx, IRQ %d\n",
5116 ss_vendor, ss_card, card->ba0_addr, card->ba1_addr, card->irq);
5118 printk(KERN_INFO "cs46xx: %s (%04X:%04X) at 0x%08lx/0x%08lx, IRQ %d\n",
5119 cp->name, ss_vendor, ss_card, card->ba0_addr, card->ba1_addr, card->irq);
5122 if (card->amplifier_ctrl == NULL) {
5123 card->amplifier_ctrl = amp_none;
5124 card->active_ctrl = clkrun_hack;
5127 if (external_amp == 1) {
5128 printk(KERN_INFO "cs46xx: Crystal EAPD support forced on.\n");
5129 card->amplifier_ctrl = amp_voyetra;
5132 if (thinkpad == 1) {
5133 printk(KERN_INFO "cs46xx: Activating CLKRUN hack for Thinkpad.\n");
5134 card->active_ctrl = clkrun_hack;
5137 * The thinkpads don't work well without runtime updating on their kernel
5138 * delay values (or any laptop with variable CPU speeds really).
5139 * so, just to be safe set the init delay to 2100. Eliminates
5140 * failures on T21 Thinkpads. remove this code when the udelay
5141 * and mdelay kernel code is replaced by a pm timer, or the delays
5142 * work well for battery and/or AC power both.
5144 if (card->active_ctrl == clkrun_hack) {
5148 if ((card->active_ctrl == clkrun_hack) && !(powerdown == 1)) {
5150 * for some currently unknown reason, powering down the DAC and ADC component
5151 * blocks on thinkpads causes some funky behavior... distoorrrtion and ac97
5152 * codec access problems. probably the serial clock becomes unsynced.
5153 * added code to sync the chips back up, but only helped about 70% the time.
5159 card->active_ctrl(card, 1);
5161 /* claim our iospace and irq */
5163 card->ba0 = ioremap_nocache(card->ba0_addr, CS461X_BA0_SIZE);
5164 card->ba1.name.data0 = ioremap_nocache(card->ba1_addr + BA1_SP_DMEM0, CS461X_BA1_DATA0_SIZE);
5165 card->ba1.name.data1 = ioremap_nocache(card->ba1_addr + BA1_SP_DMEM1, CS461X_BA1_DATA1_SIZE);
5166 card->ba1.name.pmem = ioremap_nocache(card->ba1_addr + BA1_SP_PMEM, CS461X_BA1_PRG_SIZE);
5167 card->ba1.name.reg = ioremap_nocache(card->ba1_addr + BA1_SP_REG, CS461X_BA1_REG_SIZE);
5169 CS_DBGOUT(CS_INIT, 4, printk(KERN_INFO
5170 "cs46xx: card=%p card->ba0=%p\n",card,card->ba0) );
5171 CS_DBGOUT(CS_INIT, 4, printk(KERN_INFO
5172 "cs46xx: card->ba1=%p %p %p %p\n",
5173 card->ba1.name.data0,
5174 card->ba1.name.data1,
5175 card->ba1.name.pmem,
5176 card->ba1.name.reg) );
5178 if (card->ba0 == 0 || card->ba1.name.data0 == 0 ||
5179 card->ba1.name.data1 == 0 || card->ba1.name.pmem == 0 ||
5180 card->ba1.name.reg == 0)
5183 if (request_irq(card->irq, &cs_interrupt, IRQF_SHARED, "cs46xx", card)) {
5184 printk(KERN_ERR "cs46xx: unable to allocate irq %d\n", card->irq);
5187 /* register /dev/dsp */
5188 if ((card->dev_audio = register_sound_dsp(&cs461x_fops, -1)) < 0) {
5189 printk(KERN_ERR "cs46xx: unable to register dsp\n");
5193 /* register /dev/midi */
5194 if ((card->dev_midi = register_sound_midi(&cs_midi_fops, -1)) < 0)
5195 printk(KERN_ERR "cs46xx: unable to register midi\n");
5197 card->pm.flags |= CS46XX_PM_IDLE;
5198 for (i = 0; i < 5; i++) {
5199 if (cs_hardware_init(card) != 0) {
5200 CS_DBGOUT(CS_ERROR, 4, printk(
5201 "cs46xx: ERROR in cs_hardware_init()... retrying\n"));
5202 for (j = 0; j < NR_AC97; j++)
5203 if (card->ac97_codec[j] != NULL) {
5204 unregister_sound_mixer(card->ac97_codec[j]->dev_mixer);
5205 ac97_release_codec(card->ac97_codec[j]);
5207 mdelay(10 * cs_laptop_wait);
5213 CS_DBGOUT(CS_PM | CS_ERROR, 1, printk(
5214 "cs46xx: cs46xx_probe()- cs_hardware_init() failed, retried %d times.\n",i));
5215 unregister_sound_dsp(card->dev_audio);
5217 unregister_sound_midi(card->dev_midi);
5221 init_waitqueue_head(&card->midi.open_wait);
5222 mutex_init(&card->midi.open_mutex);
5223 init_waitqueue_head(&card->midi.iwait);
5224 init_waitqueue_head(&card->midi.owait);
5225 cs461x_pokeBA0(card, BA0_MIDCR, MIDCR_MRST);
5226 cs461x_pokeBA0(card, BA0_MIDCR, 0);
5229 * Check if we have to init the amplifier, but probably already done
5230 * since the CD logic in the ac97 init code will turn on the ext amp.
5234 card->active_ctrl(card, -1);
5236 PCI_SET_DRIVER_DATA(pci_dev, card);
5237 PCI_SET_DMA_MASK(pci_dev, dma_mask);
5238 list_add(&card->list, &cs46xx_devs);
5240 CS_DBGOUT(CS_PM, 9, printk(KERN_INFO "cs46xx: pm.flags=0x%x card=%p\n",
5241 (unsigned)card->pm.flags,card));
5243 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5244 "cs46xx: probe()- device allocated successfully\n"));
5248 free_irq(card->irq, card);
5252 if (card->ba1.name.data0)
5253 iounmap(card->ba1.name.data0);
5254 if (card->ba1.name.data1)
5255 iounmap(card->ba1.name.data1);
5256 if (card->ba1.name.pmem)
5257 iounmap(card->ba1.name.pmem);
5258 if (card->ba1.name.reg)
5259 iounmap(card->ba1.name.reg);
5261 CS_DBGOUT(CS_INIT | CS_ERROR, 1, printk(KERN_INFO
5262 "cs46xx: probe()- no device allocated\n"));
5266 // ---------------------------------------------------------------------
5268 static void __devexit cs46xx_remove(struct pci_dev *pci_dev)
5270 struct cs_card *card = PCI_GET_DRIVER_DATA(pci_dev);
5274 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5275 "cs46xx: cs46xx_remove()+\n"));
5277 card->active_ctrl(card,1);
5279 tmp = cs461x_peek(card, BA1_PFIE);
5282 cs461x_poke(card, BA1_PFIE, tmp); /* playback interrupt disable */
5284 tmp = cs461x_peek(card, BA1_CIE);
5287 cs461x_poke(card, BA1_CIE, tmp); /* capture interrupt disable */
5290 * Stop playback DMA.
5292 tmp = cs461x_peek(card, BA1_PCTL);
5293 cs461x_poke(card, BA1_PCTL, tmp & 0x0000ffff);
5298 tmp = cs461x_peek(card, BA1_CCTL);
5299 cs461x_poke(card, BA1_CCTL, tmp & 0xffff0000);
5302 * Reset the processor.
5306 cs461x_proc_stop(card);
5309 * Power down the DAC and ADC. We will power them up (if) when we need
5312 if ((tmp = cs461x_powerdown(card, CS_POWER_DAC | CS_POWER_ADC |
5313 CS_POWER_MIXVON, CS_TRUE))) {
5314 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(KERN_INFO
5315 "cs46xx: cs461x_powerdown() failure (0x%x)\n",tmp) );
5319 * Power down the PLL.
5321 cs461x_pokeBA0(card, BA0_CLKCR1, 0);
5324 * Turn off the Processor by turning off the software clock enable flag in
5325 * the clock control register.
5327 tmp = cs461x_peekBA0(card, BA0_CLKCR1) & ~CLKCR1_SWCE;
5328 cs461x_pokeBA0(card, BA0_CLKCR1, tmp);
5330 card->active_ctrl(card,-1);
5332 /* free hardware resources */
5333 free_irq(card->irq, card);
5335 iounmap(card->ba1.name.data0);
5336 iounmap(card->ba1.name.data1);
5337 iounmap(card->ba1.name.pmem);
5338 iounmap(card->ba1.name.reg);
5340 /* unregister audio devices */
5341 for (i = 0; i < NR_AC97; i++)
5342 if (card->ac97_codec[i] != NULL) {
5343 unregister_sound_mixer(card->ac97_codec[i]->dev_mixer);
5344 ac97_release_codec(card->ac97_codec[i]);
5346 unregister_sound_dsp(card->dev_audio);
5348 unregister_sound_midi(card->dev_midi);
5349 list_del(&card->list);
5351 PCI_SET_DRIVER_DATA(pci_dev,NULL);
5353 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5354 "cs46xx: cs46xx_remove()-: remove successful\n"));
5359 CS46XX_4612, /* same as 4630 */
5360 CS46XX_4615, /* same as 4624 */
5363 static struct pci_device_id cs46xx_pci_tbl[] = {
5365 .vendor = PCI_VENDOR_ID_CIRRUS,
5366 .device = PCI_DEVICE_ID_CIRRUS_4610,
5367 .subvendor = PCI_ANY_ID,
5368 .subdevice = PCI_ANY_ID,
5369 .driver_data = CS46XX_4610,
5372 .vendor = PCI_VENDOR_ID_CIRRUS,
5373 .device = PCI_DEVICE_ID_CIRRUS_4612,
5374 .subvendor = PCI_ANY_ID,
5375 .subdevice = PCI_ANY_ID,
5376 .driver_data = CS46XX_4612,
5379 .vendor = PCI_VENDOR_ID_CIRRUS,
5380 .device = PCI_DEVICE_ID_CIRRUS_4615,
5381 .subvendor = PCI_ANY_ID,
5382 .subdevice = PCI_ANY_ID,
5383 .driver_data = CS46XX_4615,
5388 MODULE_DEVICE_TABLE(pci, cs46xx_pci_tbl);
5390 static struct pci_driver cs46xx_pci_driver = {
5392 .id_table = cs46xx_pci_tbl,
5393 .probe = cs46xx_probe,
5394 .remove = __devexit_p(cs46xx_remove),
5396 .suspend = cs46xx_suspend_tbl,
5397 .resume = cs46xx_resume_tbl,
5401 static int __init cs46xx_init_module(void)
5404 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2, printk(KERN_INFO
5405 "cs46xx: cs46xx_init_module()+ \n"));
5406 rtn = pci_register_driver(&cs46xx_pci_driver);
5408 if (rtn == -ENODEV) {
5409 CS_DBGOUT(CS_ERROR | CS_INIT, 1, printk(
5410 "cs46xx: Unable to detect valid cs46xx device\n"));
5413 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2,
5414 printk(KERN_INFO "cs46xx: cs46xx_init_module()- (%d)\n",rtn));
5418 static void __exit cs46xx_cleanup_module(void)
5420 pci_unregister_driver(&cs46xx_pci_driver);
5421 CS_DBGOUT(CS_INIT | CS_FUNCTION, 2,
5422 printk(KERN_INFO "cs46xx: cleanup_cs46xx() finished\n"));
5425 module_init(cs46xx_init_module);
5426 module_exit(cs46xx_cleanup_module);
5429 static int cs46xx_suspend_tbl(struct pci_dev *pcidev, pm_message_t state)
5431 struct cs_card *s = PCI_GET_DRIVER_DATA(pcidev);
5432 CS_DBGOUT(CS_PM | CS_FUNCTION, 2,
5433 printk(KERN_INFO "cs46xx: cs46xx_suspend_tbl request\n"));
5434 cs46xx_suspend(s, state);
5438 static int cs46xx_resume_tbl(struct pci_dev *pcidev)
5440 struct cs_card *s = PCI_GET_DRIVER_DATA(pcidev);
5441 CS_DBGOUT(CS_PM | CS_FUNCTION, 2,
5442 printk(KERN_INFO "cs46xx: cs46xx_resume_tbl request\n"));
projects / linux-2.6 / blob