projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
uClibc: fix ubicom32 compile error with 0.9.32
[openwrt.git] / target / linux / ep93xx / patches-2.6.30 / 010-ep93xx-snd-ac97.patch
1 --- a/arch/arm/mach-ep93xx/include/mach/hardware.h
2 +++ b/arch/arm/mach-ep93xx/include/mach/hardware.h
3 @@ -5,6 +5,7 @@
4 #define __ASM_ARCH_HARDWARE_H
5
6 #include "ep93xx-regs.h"
7 +#include "regs_ac97.h"
8
9 #define pcibios_assign_all_busses() 0
10 #include "regs_raster.h"
11 --- /dev/null
12 +++ b/arch/arm/mach-ep93xx/include/mach/regs_ac97.h
13 @@ -0,0 +1,180 @@
14 +/*=============================================================================
15 + * FILE: regs_ac97.h
16 + *
17 + * DESCRIPTION: Ac'97 Register Definition
18 + *
19 + * Copyright Cirrus Logic, 2001-2003
20 + *
21 + * This program is free software; you can redistribute it and/or modify
22 + * it under the terms of the GNU General Public License as published by
23 + * the Free Software Foundation; either version 2 of the License, or
24 + * (at your option) any later version.
25 + *
26 + * This program is distributed in the hope that it will be useful,
27 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
28 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
29 + * GNU General Public License for more details.
30 + *
31 + * You should have received a copy of the GNU General Public License
32 + * along with this program; if not, write to the Free Software
33 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
34 + *=============================================================================
35 + */
36 +#ifndef _REGS_AC97_H_
37 +#define _REGS_AC97_H_
38 +
39 +//-----------------------------------------------------------------------------
40 +// Bit definitionses
41 +//-----------------------------------------------------------------------------
42 +#define AC97ISR_RIS 8
43 +#define AC97ISR_TIS 4
44 +#define AC97ISR_RTIS 2
45 +#define AC97ISR_TCIS 1
46 +
47 +#define AC97RGIS_SLOT1TXCOMPLETE 0x01
48 +#define AC97RGIS_SLOT2RXVALID 0x02
49 +#define AC97RGIS_GPIOTXCOMPLETE 0x04
50 +#define AC97RGIS_GPIOINTRX 0x08
51 +#define AC97RGIS_RWIS 0x10
52 +#define AC97RGIS_CODECREADY 0x20
53 +#define AC97RGIS_SLOT2TXCOMPLETE 0x40
54 +
55 +#define AC97SR_RXFE 0x0001
56 +#define AC97SR_TXFE 0x0002
57 +#define AC97SR_RXFF 0x0004
58 +#define AC97SR_TXFF 0x0008
59 +#define AC97SR_TXBUSY 0x0010
60 +#define AC97SR_RXOE 0x0020
61 +#define AC97SR_TXUE 0x0040
62 +
63 +#define AC97GSR_IFE 0x1
64 +#define AC97GSR_LOOP 0x2
65 +#define AC97GSR_OVERRIDECODECREADY 0x4
66 +
67 +#define AC97RESET_TIMEDRESET 0x1
68 +#define AC97RESET_FORCEDRESET 0x2
69 +#define AC97RESET_EFORCER 0x4
70 +
71 +#define AC97RXCR_REN 0x1
72 +
73 +#define AC97TXCR_TEN 0x1
74 +
75 +
76 +//****************************************************************************
77 +//
78 +// The Ac97 Codec registers, accessable through the Ac-link.
79 +// These are not controller registers and are not memory mapped.
80 +// Includes registers specific to CS4202 (Beavis).
81 +//
82 +//****************************************************************************
83 +#define AC97_REG_OFFSET_MASK 0x0000007E
84 +
85 +#define AC97_00_RESET 0x00000000
86 +#define AC97_02_MASTER_VOL 0x00000002
87 +#define AC97_04_HEADPHONE_VOL 0x00000004
88 +#define AC97_06_MONO_VOL 0x00000006
89 +#define AC97_08_TONE 0x00000008
90 +#define AC97_0A_PC_BEEP_VOL 0x0000000A
91 +#define AC97_0C_PHONE_VOL 0x0000000C
92 +#define AC97_0E_MIC_VOL 0x0000000E
93 +#define AC97_10_LINE_IN_VOL 0x00000010
94 +#define AC97_12_CD_VOL 0x00000012
95 +#define AC97_14_VIDEO_VOL 0x00000014
96 +#define AC97_16_AUX_VOL 0x00000016
97 +#define AC97_18_PCM_OUT_VOL 0x00000018
98 +#define AC97_1A_RECORD_SELECT 0x0000001A
99 +#define AC97_1C_RECORD_GAIN 0x0000001C
100 +#define AC97_1E_RESERVED_1E 0x0000001E
101 +#define AC97_20_GENERAL_PURPOSE 0x00000020
102 +#define AC97_22_3D_CONTROL 0x00000022
103 +#define AC97_24_MODEM_RATE 0x00000024
104 +#define AC97_26_POWERDOWN 0x00000026
105 +#define AC97_28_EXT_AUDIO_ID 0x00000028
106 +#define AC97_2A_EXT_AUDIO_POWER 0x0000002A
107 +#define AC97_2C_PCM_FRONT_DAC_RATE 0x0000002C
108 +#define AC97_2E_PCM_SURR_DAC_RATE 0x0000002E
109 +#define AC97_30_PCM_LFE_DAC_RATE 0x00000030
110 +#define AC97_32_PCM_LR_ADC_RATE 0x00000032
111 +#define AC97_34_MIC_ADC_RATE 0x00000034
112 +#define AC97_36_6CH_VOL_C_LFE 0x00000036
113 +#define AC97_38_6CH_VOL_SURROUND 0x00000038
114 +#define AC97_3A_SPDIF_CONTROL 0x0000003A
115 +#define AC97_3C_EXT_MODEM_ID 0x0000003C
116 +#define AC97_3E_EXT_MODEM_POWER 0x0000003E
117 +#define AC97_40_LINE1_CODEC_RATE 0x00000040
118 +#define AC97_42_LINE2_CODEC_RATE 0x00000042
119 +#define AC97_44_HANDSET_CODEC_RATE 0x00000044
120 +#define AC97_46_LINE1_CODEC_LEVEL 0x00000046
121 +#define AC97_48_LINE2_CODEC_LEVEL 0x00000048
122 +#define AC97_4A_HANDSET_CODEC_LEVEL 0x0000004A
123 +#define AC97_4C_GPIO_PIN_CONFIG 0x0000004C
124 +#define AC97_4E_GPIO_PIN_TYPE 0x0000004E
125 +#define AC97_50_GPIO_PIN_STICKY 0x00000050
126 +#define AC97_52_GPIO_PIN_WAKEUP 0x00000052
127 +#define AC97_54_GPIO_PIN_STATUS 0x00000054
128 +#define AC97_56_RESERVED 0x00000056
129 +#define AC97_58_RESERVED 0x00000058
130 +#define AC97_5A_CRYSTAL_REV_N_FAB_ID 0x0000005A
131 +#define AC97_5C_TEST_AND_MISC_CTRL 0x0000005C
132 +#define AC97_5E_AC_MODE 0x0000005E
133 +#define AC97_60_MISC_CRYSTAL_CONTROL 0x00000060
134 +#define AC97_62_VENDOR_RESERVED 0x00000062
135 +#define AC97_64_DAC_SRC_PHASE_INCR 0x00000064
136 +#define AC97_66_ADC_SRC_PHASE_INCR 0x00000066
137 +#define AC97_68_RESERVED_68 0x00000068
138 +#define AC97_6A_SERIAL_PORT_CONTROL 0x0000006A
139 +#define AC97_6C_VENDOR_RESERVED 0x0000006C
140 +#define AC97_6E_VENDOR_RESERVED 0x0000006E
141 +#define AC97_70_BDI_CONFIG 0x00000070
142 +#define AC97_72_BDI_WAKEUP 0x00000072
143 +#define AC97_74_VENDOR_RESERVED 0x00000074
144 +#define AC97_76_CAL_ADDRESS 0x00000076
145 +#define AC97_78_CAL_DATA 0x00000078
146 +#define AC97_7A_VENDOR_RESERVED 0x0000007A
147 +#define AC97_7C_VENDOR_ID1 0x0000007C
148 +#define AC97_7E_VENDOR_ID2 0x0000007E
149 +
150 +
151 +#ifndef __ASSEMBLY__
152 +
153 +//
154 +// enum type for use with reg AC97_RECORD_SELECT
155 +//
156 +typedef enum{
157 + RECORD_MIC = 0x0000,
158 + RECORD_CD = 0x0101,
159 + RECORD_VIDEO_IN = 0x0202,
160 + RECORD_AUX_IN = 0x0303,
161 + RECORD_LINE_IN = 0x0404,
162 + RECORD_STEREO_MIX = 0x0505,
163 + RECORD_MONO_MIX = 0x0606,
164 + RECORD_PHONE_IN = 0x0707
165 +} Ac97RecordSources;
166 +
167 +#endif /* __ASSEMBLY__ */
168 +
169 +//
170 +// Sample rates supported directly in AC97_PCM_FRONT_DAC_RATE and
171 +// AC97_PCM_LR_ADC_RATE.
172 +//
173 +#define Ac97_Fs_8000 0x1f40
174 +#define Ac97_Fs_11025 0x2b11
175 +#define Ac97_Fs_16000 0x3e80
176 +#define Ac97_Fs_22050 0x5622
177 +#define Ac97_Fs_32000 0x7d00
178 +#define Ac97_Fs_44100 0xac44
179 +#define Ac97_Fs_48000 0xbb80
180 +
181 +//
182 +// RSIZE and TSIZE in AC97RXCR and AC97TXCR
183 +//
184 +#define Ac97_SIZE_20 2
185 +#define Ac97_SIZE_18 1
186 +#define Ac97_SIZE_16 0
187 +#define Ac97_SIZE_12 3
188 +
189 +//=============================================================================
190 +//=============================================================================
191 +
192 +
193 +#endif /* _REGS_AC97_H_ */
194 --- a/sound/arm/Kconfig
195 +++ b/sound/arm/Kconfig
196 @@ -11,6 +11,23 @@ menuconfig SND_ARM
197
198 if SND_ARM
199
200 +config SND_EP93XX_AC97
201 + tristate "AC97 driver for the Cirrus EP93xx chip"
202 + depends on ARCH_EP93XX && SND
203 + select SND_EP93XX_PCM
204 + select SND_AC97_CODEC
205 + help
206 + Say Y here to use AC'97 audio with a Cirrus Logic EP93xx chip.
207 +
208 + To compile this driver as a module, choose M here: the module
209 + will be called snd-ep93xx-ac97.
210 +
211 +config SND_EP93XX_PCM
212 + tristate
213 + select SND_PCM
214 + help
215 + Generic PCM module for EP93xx
216 +
217 config SND_ARMAACI
218 tristate "ARM PrimeCell PL041 AC Link support"
219 depends on ARM_AMBA
220 --- a/sound/arm/Makefile
221 +++ b/sound/arm/Makefile
222 @@ -5,6 +5,9 @@
223 obj-$(CONFIG_SND_ARMAACI) += snd-aaci.o
224 snd-aaci-objs := aaci.o devdma.o
225
226 +obj-$(CONFIG_SND_EP93XX_AC97) += snd-ep93xx-ac97.o
227 +snd-ep93xx-ac97-objs := ep93xx-ac97.o
228 +
229 obj-$(CONFIG_SND_PXA2XX_PCM) += snd-pxa2xx-pcm.o
230 snd-pxa2xx-pcm-objs := pxa2xx-pcm.o
231
232 --- /dev/null
233 +++ b/sound/arm/ep93xx-ac97.c
234 @@ -0,0 +1,3482 @@
235 +/*
236 + * linux/sound/arm/ep93xx-ac97.c -- ALSA PCM interface for the edb93xx ac97 audio
237 + */
238 +
239 +#include <linux/autoconf.h>
240 +#include <linux/module.h>
241 +#include <linux/init.h>
242 +#include <linux/platform_device.h>
243 +#include <linux/delay.h>
244 +#include <linux/soundcard.h>
245 +
246 +#include <sound/driver.h>
247 +#include <sound/core.h>
248 +#include <sound/pcm.h>
249 +#include <sound/pcm_params.h>
250 +#include <sound/control.h>
251 +#include <sound/initval.h>
252 +#include <sound/ac97_codec.h>
253 +
254 +#include <asm/irq.h>
255 +#include <asm/semaphore.h>
256 +#include <asm/hardware.h>
257 +#include <asm/io.h>
258 +#include <asm/arch/dma.h>
259 +#include "ep93xx-ac97.h"
260 +
261 +#define DRIVER_VERSION "01/05/2009"
262 +#define DRIVER_DESC "EP93xx AC97 Audio driver"
263 +static int ac_link_enabled = 0;
264 +static int codec_supported_mixers;
265 +
266 +//#define DEBUG 1
267 +#ifdef DEBUG
268 +#define DPRINTK( fmt, arg... ) printk( fmt, ##arg )
269 +#else
270 +#define DPRINTK( fmt, arg... )
271 +#endif
272 +
273 +#define WL16 0
274 +#define WL24 1
275 +
276 +#define AUDIO_NAME "ep93xx-ac97"
277 +#define AUDIO_SAMPLE_RATE_DEFAULT 44100
278 +#define AUDIO_DEFAULT_VOLUME 0
279 +#define AUDIO_MAX_VOLUME 181
280 +#define AUDIO_DEFAULT_DMACHANNELS 3
281 +#define PLAYBACK_DEFAULT_DMACHANNELS 3
282 +#define CAPTURE_DEFAULT_DMACHANNELS 3
283 +
284 +#define CHANNEL_FRONT (1<<0)
285 +#define CHANNEL_REAR (1<<1)
286 +#define CHANNEL_CENTER_LFE (1<<2)
287 +
288 +static void snd_ep93xx_dma_tx_callback( ep93xx_dma_int_t DMAInt,
289 + ep93xx_dma_dev_t device,
290 + unsigned int user_data);
291 +static void snd_ep93xx_dma_rx_callback( ep93xx_dma_int_t DMAInt,
292 + ep93xx_dma_dev_t device,
293 + unsigned int user_data);
294 +
295 +static const struct snd_pcm_hardware ep93xx_ac97_pcm_hardware = {
296 +
297 +
298 + .info = ( SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_PAUSE ),
299 + .formats = ( SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S8 |
300 + SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_S16_LE |
301 + SNDRV_PCM_FMTBIT_U16_BE | SNDRV_PCM_FMTBIT_S16_BE |
302 + SNDRV_PCM_FMTBIT_U32_LE | SNDRV_PCM_FMTBIT_S32_LE |
303 + SNDRV_PCM_FMTBIT_U32_BE | SNDRV_PCM_FMTBIT_S32_BE ),
304 + .rates = ( SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |
305 + SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 |
306 + SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |
307 + SNDRV_PCM_RATE_48000 ),
308 + .rate_min = 8000,
309 + .rate_max = 48000,
310 + .channels_min = 1,/*2,*/
311 + .channels_max = 2,
312 +
313 + .period_bytes_min = 1 * 1024,
314 + .period_bytes_max = 32 * 1024,
315 + .periods_min = 1,
316 + .periods_max = 32,
317 + .buffer_bytes_max = 32 * 1024,
318 + .fifo_size = 0,
319 +};
320 +
321 +static audio_stream_t output_stream;
322 +static audio_stream_t input_stream;
323 +
324 +static audio_state_t audio_state =
325 +{
326 + .output_stream =&output_stream,
327 + .output_dma[0] =DMATx_AAC1,
328 + .output_id[0] ="Ac97 out",
329 +
330 + .input_stream =&input_stream,
331 + .input_dma[0] =DMARx_AAC1,
332 + .input_id[0] ="Ac97 in",
333 +
334 + .sem = __SEMAPHORE_INIT(audio_state.sem,1),
335 + .codec_set_by_playback = 0,
336 + .codec_set_by_capture = 0,
337 + .DAC_bit_width =16,
338 + .bCompactMode =0,
339 +};
340 +
341 +
342 +
343 +/*
344 + * peek
345 + *
346 + * Reads an AC97 codec register. Returns -1 if there was an error.
347 + */
348 +static int peek(unsigned int uiAddress)
349 +{
350 + unsigned int uiAC97RGIS;
351 +
352 + if( !ac_link_enabled )
353 + {
354 + printk("ep93xx ac97 peek: attempt to peek before enabling ac-link.\n");
355 + return -1;
356 + }
357 +
358 + /*
359 + * Check to make sure that the address is aligned on a word boundary
360 + * and is 7E or less.
361 + */
362 + if( ((uiAddress & 0x1)!=0) || (uiAddress > 0x007e))
363 + {
364 + return -1;
365 + }
366 +
367 + /*
368 + * How it is supposed to work is:
369 + * - The ac97 controller sends out a read addr in slot 1.
370 + * - In the next frame, the codec will echo that address back in slot 1
371 + * and send the data in slot 2. SLOT2RXVALID will be set to 1.
372 + *
373 + * Read until SLOT2RXVALID goes to 1. Reading the data in AC97S2DATA
374 + * clears SLOT2RXVALID.
375 + */
376 +
377 + /*
378 + * First, delay one frame in case of back to back peeks/pokes.
379 + */
380 + mdelay( 1 );
381 +
382 + /*
383 + * Write the address to AC97S1DATA, delay 1 frame, read the flags.
384 + */
385 + outl( uiAddress, AC97S1DATA);
386 + udelay( 21 * 4 );
387 + uiAC97RGIS = inl( AC97RGIS );
388 +
389 + /*
390 + * Return error if we timed out.
391 + */
392 + if( ((uiAC97RGIS & AC97RGIS_SLOT1TXCOMPLETE) == 0 ) &&
393 + ((uiAC97RGIS & AC97RGIS_SLOT2RXVALID) == 0 ) )
394 + {
395 + printk( "ep93xx-ac97 - peek failed reading reg 0x%02x.\n", uiAddress );
396 + return -1;
397 + }
398 +
399 + return ( inl(AC97S2DATA) & 0x000fffff);
400 +}
401 +
402 +/*
403 + * poke
404 + *
405 + * Writes an AC97 codec Register. Return -1 if error.
406 + */
407 +static int poke(unsigned int uiAddress, unsigned int uiValue)
408 +{
409 + unsigned int uiAC97RGIS;
410 +
411 + if( !ac_link_enabled )
412 + {
413 + printk("ep93xx ac97 poke: attempt to poke before enabling ac-link.\n");
414 + return -1;
415 + }
416 +
417 + /*
418 + * Check to make sure that the address is align on a word boundary and
419 + * is 7E or less. And that the value is a 16 bit value.
420 + */
421 + if( ((uiAddress & 0x1)!=0) || (uiAddress > 0x007e))
422 + {
423 + printk("ep93xx ac97 poke: address error.\n");
424 + return -1;
425 + }
426 +
427 + /*stop the audio loop from the input to the output directly*/
428 +
429 + if((uiAddress==AC97_0E_MIC_VOL)||(uiAddress==AC97_10_LINE_IN_VOL))
430 + {
431 + uiValue = (uiValue | 0x8000);
432 +
433 + }
434 +
435 + /*
436 + * First, delay one frame in case of back to back peeks/pokes.
437 + */
438 + mdelay( 1 );
439 +
440 + /*
441 + * Write the data to AC97S2DATA, then the address to AC97S1DATA.
442 + */
443 + outl( uiValue, AC97S2DATA );
444 + outl( uiAddress, AC97S1DATA );
445 +
446 + /*
447 + * Wait for the tx to complete, get status.
448 + */
449 + udelay( 30 );/*21*/
450 + uiAC97RGIS = inl(AC97RGIS);
451 +
452 + /*
453 + * Return error if we timed out.
454 + */
455 + if( !(inl(AC97RGIS) & AC97RGIS_SLOT1TXCOMPLETE) )
456 + {
457 + printk( "ep93xx-ac97: poke failed writing reg 0x%02x value 0x%02x.\n", uiAddress, uiValue );
458 + return -1;
459 + }
460 +
461 + return 0;
462 +}
463 +
464 +
465 +/*
466 + * When we get to the multichannel case the pre-fill and enable code
467 + * will go to the dma driver's start routine.
468 + */
469 +static void ep93xx_audio_enable( int input_or_output_stream )
470 +{
471 + unsigned int uiTemp;
472 +
473 + DPRINTK("ep93xx_audio_enable :%x\n",input_or_output_stream);
474 +
475 + /*
476 + * Enable the rx or tx channel depending on the value of
477 + * input_or_output_stream
478 + */
479 + if( input_or_output_stream )
480 + {
481 + uiTemp = inl(AC97TXCR1);
482 + outl( (uiTemp | AC97TXCR_TEN), AC97TXCR1 );
483 + }
484 + else
485 + {
486 + uiTemp = inl(AC97RXCR1);
487 + outl( (uiTemp | AC97RXCR_REN), AC97RXCR1 );
488 + }
489 +
490 +
491 + //DDEBUG("ep93xx_audio_enable - EXIT\n");
492 +}
493 +
494 +static void ep93xx_audio_disable( int input_or_output_stream )
495 +{
496 + unsigned int uiTemp;
497 +
498 + DPRINTK("ep93xx_audio_disable\n");
499 +
500 + /*
501 + * Disable the rx or tx channel depending on the value of
502 + * input_or_output_stream
503 + */
504 + if( input_or_output_stream )
505 + {
506 + uiTemp = inl(AC97TXCR1);
507 + outl( (uiTemp & ~AC97TXCR_TEN), AC97TXCR1 );
508 + }
509 + else
510 + {
511 + uiTemp = inl(AC97RXCR1);
512 + outl( (uiTemp & ~AC97RXCR_REN), AC97RXCR1 );
513 + }
514 +
515 + //DDEBUG("ep93xx_audio_disable - EXIT\n");
516 +}
517 +
518 +
519 +
520 +/*=======================================================================================*/
521 +/*
522 + * ep93xx_setup_src
523 + *
524 + * Once the ac-link is up and all is good, we want to set the codec to a
525 + * usable mode.
526 + */
527 +static void ep93xx_setup_src(void)
528 +{
529 + int iTemp;
530 +
531 + /*
532 + * Set the VRA bit to enable the SRC.
533 + */
534 + iTemp = peek( AC97_2A_EXT_AUDIO_POWER );
535 + poke( AC97_2A_EXT_AUDIO_POWER, (iTemp | 0x1) );
536 +
537 + /*
538 + * Set the DSRC/ASRC bits to enable the variable rate SRC.
539 + */
540 + iTemp = peek( AC97_60_MISC_CRYSTAL_CONTROL );
541 + poke( AC97_60_MISC_CRYSTAL_CONTROL, (iTemp | 0x0300) );
542 +}
543 +
544 +/*
545 + * ep93xx_set_samplerate
546 + *
547 + * lFrequency - Sample Rate in Hz
548 + * bCapture - 0 to set Tx sample rate; 1 to set Rx sample rate
549 + */
550 +static void ep93xx_set_samplerate( long lSampleRate, int bCapture )
551 +{
552 + unsigned short usDivider, usPhase;
553 +
554 + DPRINTK( "ep93xx_set_samplerate - Fs = %d\n", (int)lSampleRate );
555 +
556 + if( (lSampleRate < 7200) || (lSampleRate > 48000) )
557 + {
558 + printk( "ep93xx_set_samplerate - invalid Fs = %d\n",
559 + (int)lSampleRate );
560 + return;
561 + }
562 +
563 + /*
564 + * Calculate divider and phase increment.
565 + *
566 + * divider = round( 0x1770000 / lSampleRate )
567 + * Note that usually rounding is done by adding 0.5 to a floating
568 + * value and then truncating. To do this without using floating
569 + * point, I multiply the fraction by two, do the division, then add one,
570 + * then divide the whole by 2 and then truncate.
571 + * Same effect, no floating point math.
572 + *
573 + * Ph incr = trunc( (0x1000000 / usDivider) + 1 )
574 + */
575 +
576 + usDivider = (unsigned short)( ((2 * 0x1770000 / lSampleRate) + 1) / 2 );
577 +
578 + usPhase = (0x1000000 / usDivider) + 1;
579 +
580 + /*
581 + * Write them in the registers. Spec says divider must be
582 + * written after phase incr.
583 + */
584 + if(!bCapture)
585 + {
586 + poke( AC97_2C_PCM_FRONT_DAC_RATE, usDivider);
587 + poke( AC97_64_DAC_SRC_PHASE_INCR, usPhase);
588 + }
589 + else
590 + {
591 +
592 + poke( AC97_32_PCM_LR_ADC_RATE, usDivider);
593 + poke( AC97_66_ADC_SRC_PHASE_INCR, usPhase);
594 + }
595 +
596 + DPRINTK( "ep93xx_set_samplerate - phase = %d, divider = %d\n",
597 + (unsigned int)usPhase, (unsigned int)usDivider );
598 +
599 + /*
600 + * We sorta should report the actual samplerate back to the calling
601 + * application. But some applications freak out if they don't get
602 + * exactly what they asked for. So we fudge and tell them what
603 + * they want to hear.
604 + */
605 + //audio_samplerate = lSampleRate;
606 +
607 + DPRINTK( "ep93xx_set_samplerate - EXIT\n" );
608 +}
609 +
610 +/*
611 + * ep93xx_set_hw_format
612 + *
613 + * Sets up whether the controller is expecting 20 bit data in 32 bit words
614 + * or 16 bit data compacted to have a stereo sample in each 32 bit word.
615 + */
616 +static void ep93xx_set_hw_format( long format,long channel )
617 +{
618 + int bCompactMode;
619 +
620 + switch( format )
621 + {
622 + /*
623 + * Here's all the <=16 bit formats. We can squeeze both L and R
624 + * into one 32 bit sample so use compact mode.
625 + */
626 + case SNDRV_PCM_FORMAT_U8:
627 + case SNDRV_PCM_FORMAT_S8:
628 + case SNDRV_PCM_FORMAT_S16_LE:
629 + case SNDRV_PCM_FORMAT_U16_LE:
630 + bCompactMode = 1;
631 + break;
632 +
633 + /*
634 + * Add any other >16 bit formats here...
635 + */
636 + case SNDRV_PCM_FORMAT_S32_LE:
637 + default:
638 + bCompactMode = 0;
639 + break;
640 + }
641 +
642 + if( bCompactMode )
643 + {
644 + DPRINTK("ep93xx_set_hw_format - Setting serial mode to 16 bit compact.\n");
645 +
646 + /*
647 + * Turn on Compact Mode so we can fit each stereo sample into
648 + * a 32 bit word. Twice as efficent for DMA and FIFOs.
649 + */
650 + if(channel==2){
651 + outl( 0x00008018, AC97RXCR1 );
652 + outl( 0x00008018, AC97TXCR1 );
653 + }
654 + else {
655 + outl( 0x00008018, AC97RXCR1 );
656 + outl( 0x00008018, AC97TXCR1 );
657 + }
658 +
659 +
660 + audio_state.DAC_bit_width = 16;
661 + audio_state.bCompactMode = 1;
662 + }
663 + else
664 + {
665 + DPRINTK("ep93xx_set_hw_format - Setting serial mode to 20 bit non-CM.\n");
666 +
667 + /*
668 + * Turn off Compact Mode so we can do > 16 bits per channel
669 + */
670 + if(channel==2){
671 + outl( 0x00004018, AC97RXCR1 );
672 + outl( 0x00004018, AC97TXCR1 );
673 + }
674 + else{
675 + outl( 0x00004018, AC97RXCR1 );
676 + outl( 0x00004018, AC97TXCR1 );
677 + }
678 +
679 + audio_state.DAC_bit_width = 20;
680 + audio_state.bCompactMode = 0;
681 + }
682 +
683 +}
684 +
685 +/*
686 + * ep93xx_stop_loop
687 + *
688 + * Once the ac-link is up and all is good, we want to set the codec to a
689 + * usable mode.
690 + */
691 +static void ep93xx_stop_loop(void)
692 +{
693 + int iTemp;
694 +
695 + /*
696 + * Set the AC97_0E_MIC_VOL MUTE bit to enable the LOOP.
697 + */
698 + iTemp = peek( AC97_0E_MIC_VOL );
699 + poke( AC97_0E_MIC_VOL, (iTemp | 0x8000) );
700 +
701 + /*
702 + * Set the AC97_10_LINE_IN_VOL MUTE bit to enable the LOOP.
703 + */
704 + iTemp = peek( AC97_10_LINE_IN_VOL );
705 + poke( AC97_10_LINE_IN_VOL, (iTemp | 0x8000) );
706 +}
707 +
708 +/*
709 + * ep93xx_init_ac97_controller
710 + *
711 + * This routine sets up the Ac'97 Controller.
712 + */
713 +static void ep93xx_init_ac97_controller(void)
714 +{
715 + unsigned int uiDEVCFG, uiTemp;
716 +
717 + DPRINTK("ep93xx_init_ac97_controller - enter\n");
718 +
719 + /*
720 + * Configure the multiplexed Ac'97 pins to be Ac97 not I2s.
721 + * Configure the EGPIO4 and EGPIO6 to be GPIOS, not to be
722 + * SDOUT's for the second and third I2S controller channels.
723 + */
724 + uiDEVCFG = inl(EP93XX_SYSCON_DEVICE_CONFIG);
725 +
726 + uiDEVCFG &= ~(EP93XX_SYSCON_DEVCFG_CONFIG_I2SONAC97 |
727 + EP93XX_SYSCON_DEVCFG_A1onG |
728 + EP93XX_SYSCON_DEVCFG_A2onG);
729 +
730 + SysconSetLocked(EP93XX_SYSCON_DEVICE_CONFIG, uiDEVCFG);
731 +
732 + /*
733 + * Disable the AC97 controller internal loopback.
734 + * Disable Override codec ready.
735 + */
736 + outl( 0, AC97GCR );
737 +
738 + /*
739 + * Enable the AC97 Link.
740 + */
741 + uiTemp = inl(AC97GCR);
742 + outl( (uiTemp | AC97GSR_IFE), AC97GCR );
743 +
744 + /*
745 + * Set the TIMEDRESET bit. Will cause a > 1uSec reset of the ac-link.
746 + * This bit is self resetting.
747 + */
748 + outl( AC97RESET_TIMEDRESET, AC97RESET );
749 +
750 + /*
751 + * Delay briefly, but let's not hog the processor.
752 + */
753 + set_current_state(TASK_INTERRUPTIBLE);
754 + schedule_timeout( 5 ); /* 50 mSec */
755 +
756 + /*
757 + * Read the AC97 status register to see if we've seen a CODECREADY
758 + * signal from the AC97 codec.
759 + */
760 + if( !(inl(AC97RGIS) & AC97RGIS_CODECREADY))
761 + {
762 + printk( "ep93xx-ac97 - FAIL: CODECREADY still low!\n");
763 + return;
764 + }
765 +
766 + /*
767 + * Delay for a second, not hogging the processor
768 + */
769 + set_current_state(TASK_INTERRUPTIBLE);
770 + schedule_timeout( HZ ); /* 1 Sec */
771 +
772 + /*
773 + * Now the Ac-link is up. We can read and write codec registers.
774 + */
775 + ac_link_enabled = 1;
776 +
777 + /*
778 + * Set up the rx and tx channels
779 + * Set the CM bit, data size=16 bits, enable tx slots 3 & 4.
780 + */
781 + ep93xx_set_hw_format( EP93XX_DEFAULT_FORMAT,EP93XX_DEFAULT_NUM_CHANNELS );
782 +
783 + DPRINTK( "ep93xx-ac97 -- AC97RXCR1: %08x\n", inl(AC97RXCR1) );
784 + DPRINTK( "ep93xx-ac97 -- AC97TXCR1: %08x\n", inl(AC97TXCR1) );
785 +
786 + DPRINTK("ep93xx_init_ac97_controller - EXIT - success\n");
787 +
788 +}
789 +
790 +#ifdef alsa_ac97_debug
791 +static void ep93xx_dump_ac97_regs(void)
792 +{
793 + int i;
794 + unsigned int reg0, reg1, reg2, reg3, reg4, reg5, reg6, reg7;
795 +
796 + DPRINTK( "---------------------------------------------\n");
797 + DPRINTK( " : 0 2 4 6 8 A C E\n" );
798 +
799 + for( i=0 ; i < 0x80 ; i+=0x10 )
800 + {
801 + reg0 = 0xffff & (unsigned int)peek( i );
802 + reg1 = 0xffff & (unsigned int)peek( i + 0x2 );
803 + reg2 = 0xffff & (unsigned int)peek( i + 0x4 );
804 + reg3 = 0xffff & (unsigned int)peek( i + 0x6 );
805 + reg4 = 0xffff & (unsigned int)peek( i + 0x8 );
806 + reg5 = 0xffff & (unsigned int)peek( i + 0xa );
807 + reg6 = 0xffff & (unsigned int)peek( i + 0xc );
808 + reg7 = 0xffff & (unsigned int)peek( i + 0xe );
809 +
810 + DPRINTK( " %02x : %04x %04x %04x %04x %04x %04x %04x %04x\n",
811 + i, reg0, reg1, reg2, reg3, reg4, reg5, reg6, reg7);
812 + }
813 +
814 + DPRINTK( "---------------------------------------------\n");
815 +}
816 +#endif
817 +
818 +
819 +#define supported_mixer(FOO) \
820 + ( (FOO >= 0) && \
821 + (FOO < SOUND_MIXER_NRDEVICES) && \
822 + codec_supported_mixers & (1<<FOO) )
823 +
824 +/*
825 + * Available record sources.
826 + * LINE1 refers to AUX in.
827 + * IGAIN refers to input gain which means stereo mix.
828 + */
829 +#define AC97_RECORD_MASK \
830 + (SOUND_MASK_MIC | SOUND_MASK_CD | SOUND_MASK_IGAIN | SOUND_MASK_VIDEO |\
831 + SOUND_MASK_LINE1 | SOUND_MASK_LINE | SOUND_MASK_PHONEIN)
832 +
833 +#define AC97_STEREO_MASK \
834 + (SOUND_MASK_VOLUME | SOUND_MASK_PCM | SOUND_MASK_LINE | SOUND_MASK_CD | \
835 + SOUND_MASK_ALTPCM | SOUND_MASK_IGAIN | SOUND_MASK_LINE1 | SOUND_MASK_VIDEO)
836 +
837 +#define AC97_SUPPORTED_MASK \
838 + (AC97_STEREO_MASK | SOUND_MASK_BASS | SOUND_MASK_TREBLE | \
839 + SOUND_MASK_SPEAKER | SOUND_MASK_MIC | \
840 + SOUND_MASK_PHONEIN | SOUND_MASK_PHONEOUT)
841 +
842 +
843 +
844 +
845 +/* this table has default mixer values for all OSS mixers. */
846 +typedef struct {
847 + int mixer;
848 + unsigned int value;
849 +} mixer_defaults_t;
850 +
851 +/*
852 + * Default mixer settings that are set up during boot.
853 + *
854 + * These values are 16 bit numbers in which the upper byte is right volume
855 + * and the lower byte is left volume or mono volume for mono controls.
856 + *
857 + * OSS Range for each of left and right volumes is 0 to 100 (0x00 to 0x64).
858 + *
859 + */
860 +static mixer_defaults_t mixer_defaults[SOUND_MIXER_NRDEVICES] =
861 +{
862 + /* Outputs */
863 + {SOUND_MIXER_VOLUME, 0x6464}, /* 0 dB */ /* -46.5dB to 0 dB */
864 + {SOUND_MIXER_ALTPCM, 0x6464}, /* 0 dB */ /* -46.5dB to 0 dB */
865 + {SOUND_MIXER_PHONEOUT, 0x6464}, /* 0 dB */ /* -46.5dB to 0 dB */
866 +
867 + /* PCM playback gain */
868 + {SOUND_MIXER_PCM, 0x4b4b}, /* 0 dB */ /* -34.5dB to +12dB */
869 +
870 + /* Record gain */
871 + {SOUND_MIXER_IGAIN, 0x0000}, /* 0 dB */ /* -34.5dB to +12dB */
872 +
873 + /* Inputs */
874 + {SOUND_MIXER_MIC, 0x0000}, /* mute */ /* -34.5dB to +12dB */
875 + {SOUND_MIXER_LINE, 0x4b4b}, /* 0 dB */ /* -34.5dB to +12dB */
876 +
877 + /* Inputs that are not connected. */
878 + {SOUND_MIXER_SPEAKER, 0x0000}, /* mute */ /* -45dB to 0dB */
879 + {SOUND_MIXER_PHONEIN, 0x0000}, /* mute */ /* -34.5dB to +12dB */
880 + {SOUND_MIXER_CD, 0x0000}, /* mute */ /* -34.5dB to +12dB */
881 + {SOUND_MIXER_VIDEO, 0x0000}, /* mute */ /* -34.5dB to +12dB */
882 + {SOUND_MIXER_LINE1, 0x0000}, /* mute */ /* -34.5dB to +12dB */
883 +
884 + {-1,0} /* last entry */
885 +};
886 +
887 +/* table to scale scale from OSS mixer value to AC97 mixer register value */
888 +typedef struct {
889 + unsigned int offset;
890 + int scale;
891 +} ac97_mixer_hw_t;
892 +
893 +static ac97_mixer_hw_t ac97_hw[SOUND_MIXER_NRDEVICES] =
894 +{
895 + [SOUND_MIXER_VOLUME] = {AC97_02_MASTER_VOL, 64},
896 + [SOUND_MIXER_BASS] = {0, 0},
897 + [SOUND_MIXER_TREBLE] = {0, 0},
898 + [SOUND_MIXER_SYNTH] = {0, 0},
899 + [SOUND_MIXER_PCM] = {AC97_18_PCM_OUT_VOL, 32},
900 + [SOUND_MIXER_SPEAKER] = {AC97_0A_PC_BEEP_VOL, 32},
901 + [SOUND_MIXER_LINE] = {AC97_10_LINE_IN_VOL, 32},
902 + [SOUND_MIXER_MIC] = {AC97_0E_MIC_VOL, 32},
903 + [SOUND_MIXER_CD] = {AC97_12_CD_VOL, 32},
904 + [SOUND_MIXER_IMIX] = {0, 0},
905 + [SOUND_MIXER_ALTPCM] = {AC97_04_HEADPHONE_VOL, 64},
906 + [SOUND_MIXER_RECLEV] = {0, 0},
907 + [SOUND_MIXER_IGAIN] = {AC97_1C_RECORD_GAIN, 16},
908 + [SOUND_MIXER_OGAIN] = {0, 0},
909 + [SOUND_MIXER_LINE1] = {AC97_16_AUX_VOL, 32},
910 + [SOUND_MIXER_LINE2] = {0, 0},
911 + [SOUND_MIXER_LINE3] = {0, 0},
912 + [SOUND_MIXER_DIGITAL1] = {0, 0},
913 + [SOUND_MIXER_DIGITAL2] = {0, 0},
914 + [SOUND_MIXER_DIGITAL3] = {0, 0},
915 + [SOUND_MIXER_PHONEIN] = {AC97_0C_PHONE_VOL, 32},
916 + [SOUND_MIXER_PHONEOUT] = {AC97_06_MONO_VOL, 64},
917 + [SOUND_MIXER_VIDEO] = {AC97_14_VIDEO_VOL, 32},
918 + [SOUND_MIXER_RADIO] = {0, 0},
919 + [SOUND_MIXER_MONITOR] = {0, 0},
920 +};
921 +
922 +
923 +/* the following tables allow us to go from OSS <-> ac97 quickly. */
924 +enum ac97_recsettings
925 +{
926 + AC97_REC_MIC=0,
927 + AC97_REC_CD,
928 + AC97_REC_VIDEO,
929 + AC97_REC_AUX,
930 + AC97_REC_LINE,
931 + AC97_REC_STEREO, /* combination of all enabled outputs.. */
932 + AC97_REC_MONO, /*.. or the mono equivalent */
933 + AC97_REC_PHONE
934 +};
935 +
936 +static const unsigned int ac97_rm2oss[] =
937 +{
938 + [AC97_REC_MIC] = SOUND_MIXER_MIC,
939 + [AC97_REC_CD] = SOUND_MIXER_CD,
940 + [AC97_REC_VIDEO] = SOUND_MIXER_VIDEO,
941 + [AC97_REC_AUX] = SOUND_MIXER_LINE1,
942 + [AC97_REC_LINE] = SOUND_MIXER_LINE,
943 + [AC97_REC_STEREO]= SOUND_MIXER_IGAIN,
944 + [AC97_REC_PHONE] = SOUND_MIXER_PHONEIN
945 +};
946 +
947 +/* indexed by bit position */
948 +static const unsigned int ac97_oss_rm[] =
949 +{
950 + [SOUND_MIXER_MIC] = AC97_REC_MIC,
951 + [SOUND_MIXER_CD] = AC97_REC_CD,
952 + [SOUND_MIXER_VIDEO] = AC97_REC_VIDEO,
953 + [SOUND_MIXER_LINE1] = AC97_REC_AUX,
954 + [SOUND_MIXER_LINE] = AC97_REC_LINE,
955 + [SOUND_MIXER_IGAIN] = AC97_REC_STEREO,
956 + [SOUND_MIXER_PHONEIN] = AC97_REC_PHONE
957 +};
958 +
959 +
960 +/*
961 + * ep93xx_write_mixer
962 + *
963 + */
964 +static void ep93xx_write_mixer
965 +(
966 + int oss_channel,
967 + unsigned int left,
968 + unsigned int right
969 +)
970 +{
971 + u16 val = 0;
972 + ac97_mixer_hw_t * mh = &ac97_hw[oss_channel];
973 +
974 + DPRINTK("ac97_codec: wrote OSS %2d (ac97 0x%02x), "
975 + "l:%2d, r:%2d:",
976 + oss_channel, mh->offset, left, right);
977 +
978 + if( !mh->scale )
979 + {
980 + printk( "ep93xx-ac97.c: ep93xx_write_mixer - not a valid OSS channel\n");
981 + return;
982 + }
983 +
984 + if( AC97_STEREO_MASK & (1 << oss_channel) )
985 + {
986 + /* stereo mixers */
987 + if (left == 0 && right == 0)
988 + {
989 + val = 0x8000;
990 + }
991 + else
992 + {
993 + if (oss_channel == SOUND_MIXER_IGAIN)
994 + {
995 + right = (right * mh->scale) / 100;
996 + left = (left * mh->scale) / 100;
997 + if (right >= mh->scale)
998 + right = mh->scale-1;
999 + if (left >= mh->scale)
1000 + left = mh->scale-1;
1001 + }
1002 + else
1003 + {
1004 + right = ((100 - right) * mh->scale) / 100;
1005 + left = ((100 - left) * mh->scale) / 100;
1006 + if (right >= mh->scale)
1007 + right = mh->scale-1;
1008 + if (left >= mh->scale)
1009 + left = mh->scale-1;
1010 + }
1011 + val = (left << 8) | right;
1012 + }
1013 + }
1014 + else if(left == 0)
1015 + {
1016 + val = 0x8000;
1017 + }
1018 + else if( (oss_channel == SOUND_MIXER_SPEAKER) ||
1019 + (oss_channel == SOUND_MIXER_PHONEIN) ||
1020 + (oss_channel == SOUND_MIXER_PHONEOUT) )
1021 + {
1022 + left = ((100 - left) * mh->scale) / 100;
1023 + if (left >= mh->scale)
1024 + left = mh->scale-1;
1025 + val = left;
1026 + }
1027 + else if (oss_channel == SOUND_MIXER_MIC)
1028 + {
1029 + val = peek( mh->offset) & ~0x801f;
1030 + left = ((100 - left) * mh->scale) / 100;
1031 + if (left >= mh->scale)
1032 + left = mh->scale-1;
1033 + val |= left;
1034 + }
1035 + /*
1036 + * For bass and treble, the low bit is optional. Masking it
1037 + * lets us avoid the 0xf 'bypass'.
1038 + * Do a read, modify, write as we have two contols in one reg.
1039 + */
1040 + else if (oss_channel == SOUND_MIXER_BASS)
1041 + {
1042 + val = peek( mh->offset) & ~0x0f00;
1043 + left = ((100 - left) * mh->scale) / 100;
1044 + if (left >= mh->scale)
1045 + left = mh->scale-1;
1046 + val |= (left << 8) & 0x0e00;
1047 + }
1048 + else if (oss_channel == SOUND_MIXER_TREBLE)
1049 + {
1050 + val = peek( mh->offset) & ~0x000f;
1051 + left = ((100 - left) * mh->scale) / 100;
1052 + if (left >= mh->scale)
1053 + left = mh->scale-1;
1054 + val |= left & 0x000e;
1055 + }
1056 +
1057 + DPRINTK(" 0x%04x", val);
1058 +
1059 + poke( mh->offset, val );
1060 +
1061 +#ifdef alsa_ac97_debug
1062 + val = peek( mh->offset );
1063 + DEBUG(" -> 0x%04x\n", val);
1064 +#endif
1065 +
1066 +}
1067 +
1068 +/* a thin wrapper for write_mixer */
1069 +static void ep93xx_set_mixer
1070 +(
1071 + unsigned int oss_mixer,
1072 + unsigned int val
1073 +)
1074 +{
1075 + unsigned int left,right;
1076 +
1077 + /* cleanse input a little */
1078 + right = ((val >> 8) & 0xff) ;
1079 + left = (val & 0xff) ;
1080 +
1081 + if (right > 100) right = 100;
1082 + if (left > 100) left = 100;
1083 +
1084 + /*mixer_state[oss_mixer] = (right << 8) | left;*/
1085 + ep93xx_write_mixer( oss_mixer, left, right);
1086 +}
1087 +
1088 +static void ep93xx_init_mixer(void)
1089 +{
1090 + u16 cap;
1091 + int i;
1092 +
1093 + /* mixer masks */
1094 + codec_supported_mixers = AC97_SUPPORTED_MASK;
1095 +
1096 + cap = peek( AC97_00_RESET );
1097 + if( !(cap & 0x04) )
1098 + {
1099 + codec_supported_mixers &= ~(SOUND_MASK_BASS|SOUND_MASK_TREBLE);
1100 + }
1101 + if( !(cap & 0x10) )
1102 + {
1103 + codec_supported_mixers &= ~SOUND_MASK_ALTPCM;
1104 + }
1105 +
1106 + /*
1107 + * Detect bit resolution of output volume controls by writing to the
1108 + * 6th bit (not unmuting yet)
1109 + */
1110 + poke( AC97_02_MASTER_VOL, 0xa020 );
1111 + if( peek( AC97_02_MASTER_VOL) != 0xa020 )
1112 + {
1113 + ac97_hw[SOUND_MIXER_VOLUME].scale = 32;
1114 + }
1115 +
1116 + poke( AC97_04_HEADPHONE_VOL, 0xa020 );
1117 + if( peek( AC97_04_HEADPHONE_VOL) != 0xa020 )
1118 + {
1119 + ac97_hw[AC97_04_HEADPHONE_VOL].scale = 32;
1120 + }
1121 +
1122 + poke( AC97_06_MONO_VOL, 0x8020 );
1123 + if( peek( AC97_06_MONO_VOL) != 0x8020 )
1124 + {
1125 + ac97_hw[AC97_06_MONO_VOL].scale = 32;
1126 + }
1127 +
1128 + /* initialize mixer channel volumes */
1129 + for( i = 0;
1130 + (i < SOUND_MIXER_NRDEVICES) && (mixer_defaults[i].mixer != -1) ;
1131 + i++ )
1132 + {
1133 + if( !supported_mixer( mixer_defaults[i].mixer) )
1134 + {
1135 + continue;
1136 + }
1137 +
1138 + ep93xx_set_mixer( mixer_defaults[i].mixer, mixer_defaults[i].value);
1139 + }
1140 +
1141 +}
1142 +
1143 +static int ep93xx_set_recsource( int mask )
1144 +{
1145 + unsigned int val;
1146 +
1147 + /* Arg contains a bit for each recording source */
1148 + if( mask == 0 )
1149 + {
1150 + return 0;
1151 + }
1152 +
1153 + mask &= AC97_RECORD_MASK;
1154 +
1155 + if( mask == 0 )
1156 + {
1157 + return -EINVAL;
1158 + }
1159 +
1160 + /*
1161 + * May have more than one bit set. So clear out currently selected
1162 + * record source value first (AC97 supports only 1 input)
1163 + */
1164 + val = (1 << ac97_rm2oss[peek( AC97_1A_RECORD_SELECT ) & 0x07]);
1165 + if (mask != val)
1166 + mask &= ~val;
1167 +
1168 + val = ffs(mask);
1169 + val = ac97_oss_rm[val-1];
1170 + val |= val << 8; /* set both channels */
1171 +
1172 + /*
1173 + *
1174 + */
1175 + val = peek( AC97_1A_RECORD_SELECT ) & 0x0707;
1176 + if ((val&0x0404)!=0)
1177 + val=0x0404;
1178 + else if((val&0x0000)!=0)
1179 + val=0x0101;
1180 +
1181 +
1182 + DPRINTK("ac97_codec: setting ac97 recmask to 0x%04x\n", val);
1183 +
1184 + poke( AC97_1A_RECORD_SELECT, val);
1185 +
1186 + return 0;
1187 +}
1188 +
1189 +/*
1190 + * ep93xx_init_ac97_codec
1191 + *
1192 + * Program up the external Ac97 codec.
1193 + *
1194 + */
1195 +static void ep93xx_init_ac97_codec( void )
1196 +{
1197 + DPRINTK("ep93xx_init_ac97_codec - enter\n");
1198 +
1199 + ep93xx_setup_src();
1200 + ep93xx_set_samplerate( AUDIO_SAMPLE_RATE_DEFAULT, 0 );
1201 + ep93xx_set_samplerate( AUDIO_SAMPLE_RATE_DEFAULT, 1 );
1202 + ep93xx_init_mixer();
1203 +
1204 + DPRINTK("ep93xx_init_ac97_codec - EXIT\n");
1205 +
1206 +}
1207 +
1208 +
1209 +/*
1210 + * ep93xx_audio_init
1211 + * Audio interface
1212 + */
1213 +static void ep93xx_audio_init(void)
1214 +{
1215 + DPRINTK("ep93xx_audio_init - enter\n");
1216 + /*
1217 + * Init the controller, enable the ac-link.
1218 + * Initialize the codec.
1219 + */
1220 + ep93xx_init_ac97_controller();
1221 + ep93xx_init_ac97_codec();
1222 + /*stop the audio loop from the input to the output directly*/
1223 + ep93xx_stop_loop();
1224 +
1225 +#ifdef alsa_ac97_debug
1226 + ep93xx_dump_ac97_regs();
1227 +#endif
1228 + DPRINTK("ep93xx_audio_init - EXIT\n");
1229 +}
1230 +
1231 +/*====================================================================================*/
1232 +
1233 +
1234 +static void print_audio_format( long format )
1235 +{
1236 + switch( format ){
1237 + case SNDRV_PCM_FORMAT_S8:
1238 + DPRINTK( "AFMT_S8\n" );
1239 + break;
1240 +
1241 + case SNDRV_PCM_FORMAT_U8:
1242 + DPRINTK( "AFMT_U8\n" );
1243 + break;
1244 +
1245 + case SNDRV_PCM_FORMAT_S16_LE:
1246 + DPRINTK( "AFMT_S16_LE\n" );
1247 + break;
1248 +
1249 + case SNDRV_PCM_FORMAT_S16_BE:
1250 + DPRINTK( "AFMT_S16_BE\n" );
1251 + break;
1252 +
1253 + case SNDRV_PCM_FORMAT_U16_LE:
1254 + DPRINTK( "AFMT_U16_LE\n" );
1255 + break;
1256 + case SNDRV_PCM_FORMAT_U16_BE:
1257 + DPRINTK( "AFMT_U16_BE\n" );
1258 + break;
1259 +
1260 + case SNDRV_PCM_FORMAT_S24_LE:
1261 + DPRINTK( "AFMT_S24_LE\n" );
1262 + break;
1263 +
1264 + case SNDRV_PCM_FORMAT_S24_BE:
1265 + DPRINTK( "AFMT_S24_BE\n" );
1266 + break;
1267 +
1268 + case SNDRV_PCM_FORMAT_U24_LE:
1269 + DPRINTK( "AFMT_U24_LE\n" );
1270 + break;
1271 +
1272 + case SNDRV_PCM_FORMAT_U24_BE:
1273 + DPRINTK( "AFMT_U24_BE\n" );
1274 + break;
1275 + case SNDRV_PCM_FORMAT_S32_LE:
1276 + DPRINTK( "AFMT_S24_LE\n" );
1277 + break;
1278 +
1279 + case SNDRV_PCM_FORMAT_S32_BE:
1280 + DPRINTK( "AFMT_S24_BE\n" );
1281 + break;
1282 +
1283 + case SNDRV_PCM_FORMAT_U32_LE:
1284 + DPRINTK( "AFMT_U24_LE\n" );
1285 + break;
1286 +
1287 + case SNDRV_PCM_FORMAT_U32_BE:
1288 + DPRINTK( "AFMT_U24_BE\n" );
1289 + break;
1290 + default:
1291 + DPRINTK( "ep93xx_i2s_Unsupported Audio Format\n" );
1292 + break;
1293 + }
1294 +}
1295 +
1296 +static void audio_set_format( audio_stream_t * s, long val )
1297 +{
1298 + DPRINTK( "ep93xx_i2s_audio_set_format enter. Format requested (%d) %d ",
1299 + (int)val,SNDRV_PCM_FORMAT_S16_LE);
1300 + print_audio_format( val );
1301 +
1302 + switch( val ){
1303 + case SNDRV_PCM_FORMAT_S8:
1304 + s->audio_format = SNDRV_PCM_FORMAT_S8;
1305 + s->audio_stream_bitwidth = 8;
1306 + break;
1307 +
1308 + case SNDRV_PCM_FORMAT_U8:
1309 + s->audio_format = SNDRV_PCM_FORMAT_U8;
1310 + s->audio_stream_bitwidth = 8;
1311 + break;
1312 +
1313 + case SNDRV_PCM_FORMAT_S16_LE:
1314 + case SNDRV_PCM_FORMAT_S16_BE:
1315 + s->audio_format = SNDRV_PCM_FORMAT_S16_LE;
1316 + s->audio_stream_bitwidth = 16;
1317 + break;
1318 +
1319 + case SNDRV_PCM_FORMAT_U16_LE:
1320 + case SNDRV_PCM_FORMAT_U16_BE:
1321 + s->audio_format = SNDRV_PCM_FORMAT_U16_LE;
1322 + s->audio_stream_bitwidth = 16;
1323 + break;
1324 +
1325 + case SNDRV_PCM_FORMAT_S24_LE:
1326 + case SNDRV_PCM_FORMAT_S24_BE:
1327 + s->audio_format = SNDRV_PCM_FORMAT_S24_LE;
1328 + s->audio_stream_bitwidth = 24;
1329 + break;
1330 +
1331 + case SNDRV_PCM_FORMAT_U24_LE:
1332 + case SNDRV_PCM_FORMAT_U24_BE:
1333 + s->audio_format = SNDRV_PCM_FORMAT_U24_LE;
1334 + s->audio_stream_bitwidth = 24;
1335 + break;
1336 +
1337 + case SNDRV_PCM_FORMAT_U32_LE:
1338 + case SNDRV_PCM_FORMAT_U32_BE:
1339 + case SNDRV_PCM_FORMAT_S32_LE:
1340 + case SNDRV_PCM_FORMAT_S32_BE:
1341 + s->audio_format = SNDRV_PCM_FORMAT_S32_LE;
1342 + s->audio_stream_bitwidth = 32;
1343 + break;
1344 + default:
1345 + DPRINTK( "ep93xx_i2s_Unsupported Audio Format\n" );
1346 + break;
1347 + }
1348 +
1349 + DPRINTK( "ep93xx_i2s_audio_set_format EXIT format set to be (%d) ", (int)s->audio_format );
1350 + print_audio_format( (long)s->audio_format );
1351 +}
1352 +
1353 +static __inline__ unsigned long copy_to_user_S24_LE
1354 +(
1355 + audio_stream_t *stream,
1356 + const char *to,
1357 + unsigned long to_count
1358 +)
1359 +{
1360 + int *dma_buffer_0 = (int *)stream->hwbuf[0];
1361 + int *dma_buffer_1 = (int *)stream->hwbuf[1];
1362 + int *dma_buffer_2 = (int *)stream->hwbuf[2];
1363 +
1364 + int total_to_count = to_count;
1365 + int *user_ptr = (int *)to; /* 32 bit user buffer */
1366 + int count;
1367 +
1368 + count = 8 * stream->dma_num_channels;
1369 +
1370 + while (to_count > 0){
1371 +
1372 + __put_user( (int)( *dma_buffer_0++ ), user_ptr++ );
1373 + __put_user( (int)( *dma_buffer_0++ ), user_ptr++ );
1374 +
1375 + if(stream->audio_channels_flag & CHANNEL_REAR ){
1376 + __put_user( (int)( *dma_buffer_1++ ), user_ptr++ );
1377 + __put_user( (int)( *dma_buffer_1++ ), user_ptr++ );
1378 + }
1379 +
1380 + if(stream->audio_channels_flag & CHANNEL_CENTER_LFE ){
1381 + __put_user( (int)( *dma_buffer_2++ ), user_ptr++ );
1382 + __put_user( (int)( *dma_buffer_2++ ), user_ptr++ );
1383 + }
1384 + to_count -= count;
1385 + }
1386 + return total_to_count;
1387 +}
1388 +
1389 +static __inline__ unsigned long copy_to_user_U24_LE
1390 +(
1391 + audio_stream_t *stream,
1392 + const char *to,
1393 + unsigned long to_count
1394 +)
1395 +{
1396 + int *dma_buffer_0 = (int *)stream->hwbuf[0];
1397 + int *dma_buffer_1 = (int *)stream->hwbuf[1];
1398 + int *dma_buffer_2 = (int *)stream->hwbuf[2];
1399 +
1400 + int total_to_count = to_count;
1401 + unsigned int * user_ptr = (unsigned int *)to; /* 32 bit user buffer */
1402 + int count;
1403 +
1404 + count = 8 * stream->dma_num_channels;
1405 +
1406 + while (to_count > 0){
1407 + __put_user( ((unsigned int)( *dma_buffer_0++ )) ^ 0x8000, user_ptr++ );
1408 + __put_user( ((unsigned int)( *dma_buffer_0++ )) ^ 0x8000, user_ptr++ );
1409 +
1410 + if(stream->audio_channels_flag & CHANNEL_REAR ){
1411 + __put_user( ((unsigned int)( *dma_buffer_1++ )) ^ 0x8000, user_ptr++ );
1412 + __put_user( ((unsigned int)( *dma_buffer_1++ )) ^ 0x8000, user_ptr++ );
1413 + }
1414 +
1415 + if(stream->audio_channels_flag & CHANNEL_CENTER_LFE ){
1416 + __put_user( ((unsigned int)( *dma_buffer_2++ )) ^ 0x8000, user_ptr++ );
1417 + __put_user( ((unsigned int)( *dma_buffer_2++ )) ^ 0x8000, user_ptr++ );
1418 + }
1419 + to_count -= count;
1420 + }
1421 + return total_to_count;
1422 +}
1423 +
1424 +static __inline__ unsigned long copy_to_user_S16_LE
1425 +(
1426 + audio_stream_t *stream,
1427 + const char *to,
1428 + unsigned long to_count
1429 +)
1430 +{
1431 + int *dma_buffer_0 = (int *)stream->hwbuf[0];
1432 + int *dma_buffer_1 = (int *)stream->hwbuf[1];
1433 + int *dma_buffer_2 = (int *)stream->hwbuf[2];
1434 + int total_to_count = to_count;
1435 + short * user_ptr = (short *)to; /* 16 bit user buffer */
1436 + int count;
1437 +
1438 + count = 4 * stream->dma_num_channels;
1439 +
1440 + while (to_count > 0){
1441 +
1442 + __put_user( (short)( *dma_buffer_0++ ), user_ptr++ );
1443 + __put_user( (short)( *dma_buffer_0++ ), user_ptr++ );
1444 +
1445 + if( stream->audio_channels_flag & CHANNEL_REAR ){
1446 + __put_user( (short)( *dma_buffer_1++ ), user_ptr++ );
1447 + __put_user( (short)( *dma_buffer_1++ ), user_ptr++ );
1448 + }
1449 +
1450 + if( stream->audio_channels_flag & CHANNEL_CENTER_LFE ){
1451 + __put_user( (short)( *dma_buffer_2++ ), user_ptr++ );
1452 + __put_user( (short)( *dma_buffer_2++ ), user_ptr++ );
1453 + }
1454 + to_count -= count;
1455 + }
1456 + return total_to_count;
1457 +}
1458 +
1459 +static __inline__ unsigned long copy_to_user_U16_LE
1460 +(
1461 + audio_stream_t *stream,
1462 + const char *to,
1463 + unsigned long to_count
1464 +)
1465 +{
1466 + int *dma_buffer_0 = (int *)stream->hwbuf[0];
1467 + int *dma_buffer_1 = (int *)stream->hwbuf[1];
1468 + int *dma_buffer_2 = (int *)stream->hwbuf[2];
1469 + int count;
1470 + int total_to_count = to_count;
1471 + short * user_ptr = (short *)to; /* 16 bit user buffer */
1472 +
1473 + count = 4 * stream->dma_num_channels;
1474 +
1475 + while (to_count > 0){
1476 +
1477 + __put_user( ((unsigned short)( *dma_buffer_0++ )) ^ 0x8000, user_ptr++ );
1478 + __put_user( ((unsigned short)( *dma_buffer_0++ )) ^ 0x8000, user_ptr++ );
1479 +
1480 + if(stream->audio_channels_flag & CHANNEL_REAR ){
1481 + __put_user( ((unsigned short)( *dma_buffer_1++ )) ^ 0x8000, user_ptr++ );
1482 + __put_user( ((unsigned short)( *dma_buffer_1++ )) ^ 0x8000, user_ptr++ );
1483 + }
1484 +
1485 + if(stream->audio_channels_flag & CHANNEL_CENTER_LFE ){
1486 + __put_user( ((unsigned short)( *dma_buffer_2++ )) ^ 0x8000, user_ptr++ );
1487 + __put_user( ((unsigned short)( *dma_buffer_2++ )) ^ 0x8000, user_ptr++ );
1488 + }
1489 + to_count -= count;
1490 + }
1491 + return total_to_count;
1492 +}
1493 +
1494 +static __inline__ unsigned long copy_to_user_S8
1495 +(
1496 + audio_stream_t *stream,
1497 + const char *to,
1498 + unsigned long to_count
1499 +)
1500 +{
1501 + char *dma_buffer_0 = (char *)stream->hwbuf[0];
1502 + char *dma_buffer_1 = (char *)stream->hwbuf[1];
1503 + char *dma_buffer_2 = (char *)stream->hwbuf[2];
1504 + int count;
1505 + int total_to_count = to_count;
1506 + char * user_ptr = (char *)to; /* 8 bit user buffer */
1507 +
1508 + count = 2 * stream->dma_num_channels;
1509 +
1510 + dma_buffer_0++;
1511 + dma_buffer_1++;
1512 + dma_buffer_2++;
1513 +
1514 + while (to_count > 0){
1515 +
1516 + __put_user( (char)( *dma_buffer_0 ), user_ptr++ );
1517 + dma_buffer_0 += 4;
1518 + __put_user( (char)( *dma_buffer_0 ), user_ptr++ );
1519 + dma_buffer_0 += 4;
1520 +
1521 + if(stream->audio_channels_flag & CHANNEL_REAR ){
1522 + __put_user( (char)( *dma_buffer_1 ), user_ptr++ );
1523 + dma_buffer_1 += 4;
1524 + __put_user( (char)( *dma_buffer_1 ), user_ptr++ );
1525 + dma_buffer_1 += 4;
1526 + }
1527 +
1528 + if(stream->audio_channels_flag & CHANNEL_CENTER_LFE ){
1529 + __put_user( (char)( *dma_buffer_2 ), user_ptr++ );
1530 + dma_buffer_2 += 4;
1531 + __put_user( (char)( *dma_buffer_2 ), user_ptr++ );
1532 + dma_buffer_2 += 4;
1533 + }
1534 + to_count -= count;
1535 + }
1536 + return total_to_count;
1537 +}
1538 +
1539 +static __inline__ unsigned long copy_to_user_U8
1540 +(
1541 + audio_stream_t *stream,
1542 + const char *to,
1543 + unsigned long to_count
1544 +)
1545 +{
1546 + char *dma_buffer_0 = (char *)stream->hwbuf[0];
1547 + char *dma_buffer_1 = (char *)stream->hwbuf[1];
1548 + char *dma_buffer_2 = (char *)stream->hwbuf[2];
1549 + int count;
1550 + int total_to_count = to_count;
1551 + char * user_ptr = (char *)to; /* 8 bit user buffer */
1552 +
1553 + count = 2 * stream->dma_num_channels;
1554 +
1555 + dma_buffer_0++;
1556 + dma_buffer_1++;
1557 + dma_buffer_2++;
1558 +
1559 + while (to_count > 0){
1560 +
1561 + __put_user( (char)( *dma_buffer_0 ) ^ 0x80, user_ptr++ );
1562 + dma_buffer_0 += 4;
1563 + __put_user( (char)( *dma_buffer_0 ) ^ 0x80, user_ptr++ );
1564 + dma_buffer_0 += 4;
1565 +
1566 + if(stream->audio_channels_flag & CHANNEL_REAR ){
1567 + __put_user( (char)( *dma_buffer_1 ) ^ 0x80, user_ptr++ );
1568 + dma_buffer_1 += 4;
1569 + __put_user( (char)( *dma_buffer_1 ) ^ 0x80, user_ptr++ );
1570 + dma_buffer_1 += 4;
1571 + }
1572 +
1573 + if(stream->audio_channels_flag & CHANNEL_CENTER_LFE ){
1574 + __put_user( (char)( *dma_buffer_2 ) ^ 0x80, user_ptr++ );
1575 + dma_buffer_2 += 4;
1576 + __put_user( (char)( *dma_buffer_2 ) ^ 0x80, user_ptr++ );
1577 + dma_buffer_2 += 4;
1578 + }
1579 + to_count -= count;
1580 + }
1581 + return total_to_count;
1582 +}
1583 +
1584 +
1585 +
1586 +
1587 +static __inline__ unsigned long copy_to_user_S16_LE_CM
1588 +(
1589 + audio_stream_t *stream,
1590 + const char *to,
1591 + unsigned long to_count
1592 +)
1593 +{
1594 + short *dma_buffer_0 = (short *)stream->hwbuf[0];
1595 + int *dma_buffer_1 = (int *)stream->hwbuf[1];
1596 + int *dma_buffer_2 = (int *)stream->hwbuf[2];
1597 + int total_to_count = to_count;
1598 + short * user_ptr = (short *)to; /* 16 bit user buffer */
1599 + int count;
1600 +
1601 +
1602 + count = 4 * stream->dma_num_channels;
1603 +
1604 + while (to_count > 0){
1605 + if(stream->audio_num_channels == 2){
1606 + __put_user( (short)( *dma_buffer_0++ ), user_ptr++ );
1607 + __put_user( (short)( *dma_buffer_0++ ), user_ptr++ );
1608 + to_count -= count;
1609 + }
1610 + else{
1611 + dma_buffer_0++;
1612 + __put_user( (short)( *dma_buffer_0++ ), user_ptr++ );
1613 + to_count -= 2;
1614 + }
1615 +
1616 + if( stream->audio_channels_flag & CHANNEL_REAR ){
1617 + __put_user( (short)( *dma_buffer_1++ ), user_ptr++ );
1618 + __put_user( (short)( *dma_buffer_1++ ), user_ptr++ );
1619 + }
1620 +
1621 + if( stream->audio_channels_flag & CHANNEL_CENTER_LFE ){
1622 + __put_user( (short)( *dma_buffer_2++ ), user_ptr++ );
1623 + __put_user( (short)( *dma_buffer_2++ ), user_ptr++ );
1624 + }
1625 + //to_count -= count;
1626 + }
1627 + return total_to_count;
1628 +}
1629 +
1630 +static __inline__ unsigned long copy_to_user_U16_LE_CM
1631 +(
1632 + audio_stream_t *stream,
1633 + const char *to,
1634 + unsigned long to_count
1635 +)
1636 +{
1637 + unsigned short *dma_buffer_0 = (unsigned short *)stream->hwbuf[0];
1638 + int *dma_buffer_1 = (int *)stream->hwbuf[1];
1639 + int *dma_buffer_2 = (int *)stream->hwbuf[2];
1640 + int count;
1641 + int total_to_count = to_count;
1642 + unsigned short * user_ptr = (unsigned short *)to; /* 16 bit user buffer */
1643 +
1644 + count = 4 * stream->dma_num_channels;
1645 +
1646 + while (to_count > 0){
1647 +
1648 + if(stream->audio_num_channels == 2){
1649 + __put_user( ((unsigned short)( *dma_buffer_0++ )) ^ 0x8000, user_ptr++ );
1650 + __put_user( ((unsigned short)( *dma_buffer_0++ )) ^ 0x8000, user_ptr++ );
1651 + to_count -= count;
1652 + }
1653 + else{
1654 + dma_buffer_0++;
1655 + __put_user( ((unsigned short)( *dma_buffer_0++ )) ^ 0x8000, user_ptr++ );
1656 + to_count -= 2;
1657 + }
1658 +
1659 + if(stream->audio_channels_flag & CHANNEL_REAR ){
1660 + __put_user( ((unsigned short)( *dma_buffer_1++ )) ^ 0x8000, user_ptr++ );
1661 + __put_user( ((unsigned short)( *dma_buffer_1++ )) ^ 0x8000, user_ptr++ );
1662 + }
1663 +
1664 + if(stream->audio_channels_flag & CHANNEL_CENTER_LFE ){
1665 + __put_user( ((unsigned short)( *dma_buffer_2++ )) ^ 0x8000, user_ptr++ );
1666 + __put_user( ((unsigned short)( *dma_buffer_2++ )) ^ 0x8000, user_ptr++ );
1667 + }
1668 + //to_count -= count;
1669 + }
1670 + return total_to_count;
1671 +}
1672 +
1673 +static __inline__ unsigned long copy_to_user_S8_CM
1674 +(
1675 + audio_stream_t *stream,
1676 + const char *to,
1677 + unsigned long to_count
1678 +)
1679 +{
1680 + unsigned short *dma_buffer_0 = (unsigned short *)stream->hwbuf[0];
1681 + char *dma_buffer_1 = (char *)stream->hwbuf[1];
1682 + char *dma_buffer_2 = (char *)stream->hwbuf[2];
1683 + int count;
1684 + int total_to_count = to_count;
1685 + char * user_ptr = (char *)to; /* 8 bit user buffer */
1686 +
1687 + count = 2 * stream->dma_num_channels;
1688 +
1689 + dma_buffer_0++;
1690 + dma_buffer_1++;
1691 + dma_buffer_2++;
1692 +
1693 + while (to_count > 0){
1694 + if(stream->audio_num_channels == 2){
1695 + __put_user( (char)( *dma_buffer_0++ >> 8), user_ptr++ );
1696 + //dma_buffer_0 += 4;
1697 + __put_user( (char)( *dma_buffer_0++ >> 8), user_ptr++ );
1698 + //dma_buffer_0 += 4;
1699 + to_count -= count;
1700 + }
1701 + else{
1702 + dma_buffer_0++ ;
1703 + __put_user( (char)( *dma_buffer_0++ >> 8), user_ptr++ );
1704 +
1705 + to_count -= 1;
1706 + }
1707 + if(stream->audio_channels_flag & CHANNEL_REAR ){
1708 + __put_user( (char)( *dma_buffer_1 ), user_ptr++ );
1709 + dma_buffer_1 += 4;
1710 + __put_user( (char)( *dma_buffer_1 ), user_ptr++ );
1711 + dma_buffer_1 += 4;
1712 + }
1713 +
1714 + if(stream->audio_channels_flag & CHANNEL_CENTER_LFE ){
1715 + __put_user( (char)( *dma_buffer_2 ), user_ptr++ );
1716 + dma_buffer_2 += 4;
1717 + __put_user( (char)( *dma_buffer_2 ), user_ptr++ );
1718 + dma_buffer_2 += 4;
1719 + }
1720 + //to_count -= count;
1721 + }
1722 + return total_to_count;
1723 +}
1724 +
1725 +static __inline__ unsigned long copy_to_user_U8_CM
1726 +(
1727 + audio_stream_t *stream,
1728 + const char *to,
1729 + unsigned long to_count
1730 +)
1731 +{
1732 + unsigned short *dma_buffer_0 = (unsigned short *)stream->hwbuf[0];
1733 + char *dma_buffer_1 = (char *)stream->hwbuf[1];
1734 + char *dma_buffer_2 = (char *)stream->hwbuf[2];
1735 + int count;
1736 + int total_to_count = to_count;
1737 + char * user_ptr = (char *)to; /* 8 bit user buffer */
1738 +
1739 + count = 2 * stream->dma_num_channels;
1740 +
1741 + dma_buffer_0++;
1742 + dma_buffer_1++;
1743 + dma_buffer_2++;
1744 +
1745 + while (to_count > 0){
1746 + if(stream->audio_num_channels == 2){
1747 + __put_user( (char)( *dma_buffer_0++ >>8) ^ 0x80, user_ptr++ );
1748 + //dma_buffer_0 += 4;
1749 + __put_user( (char)( *dma_buffer_0++ >>8) ^ 0x80, user_ptr++ );
1750 + //dma_buffer_0 += 4;
1751 + to_count -= count;
1752 + }
1753 + else{
1754 + dma_buffer_0++;
1755 + __put_user( (char)( *dma_buffer_0++ >>8) ^ 0x80, user_ptr++ );
1756 + //dma_buffer_0 += 4;
1757 + to_count--;
1758 + }
1759 +
1760 + if(stream->audio_channels_flag & CHANNEL_REAR ){
1761 + __put_user( (char)( *dma_buffer_1 ) ^ 0x80, user_ptr++ );
1762 + dma_buffer_1 += 4;
1763 + __put_user( (char)( *dma_buffer_1 ) ^ 0x80, user_ptr++ );
1764 + dma_buffer_1 += 4;
1765 + }
1766 +
1767 + if(stream->audio_channels_flag & CHANNEL_CENTER_LFE ){
1768 + __put_user( (char)( *dma_buffer_2 ) ^ 0x80, user_ptr++ );
1769 + dma_buffer_2 += 4;
1770 + __put_user( (char)( *dma_buffer_2 ) ^ 0x80, user_ptr++ );
1771 + dma_buffer_2 += 4;
1772 + }
1773 + //to_count -= count;
1774 + }
1775 + return total_to_count;
1776 +}
1777 +
1778 +static __inline__ unsigned long copy_to_user_U32
1779 +(
1780 + audio_stream_t *stream,
1781 + const char *to,
1782 + unsigned long to_count
1783 +)
1784 +{
1785 + char *dma_buffer_0 = (char *)stream->hwbuf[0];
1786 +
1787 + if(__copy_to_user( (char *)to, dma_buffer_0, to_count))
1788 + {
1789 + return -EFAULT;
1790 + }
1791 + return to_count;
1792 +}
1793 +
1794 +static __inline__ int copy_to_user_with_conversion
1795 +(
1796 + audio_stream_t *stream,
1797 + const char *to,
1798 + int toCount,
1799 + int bCompactMode
1800 +)
1801 +{
1802 + int ret = 0;
1803 +
1804 + if( toCount == 0 ){
1805 + DPRINTK("ep93xx_i2s_copy_to_user_with_conversion - nothing to copy!\n");
1806 + }
1807 +
1808 + if( bCompactMode == 1 ){
1809 +
1810 + switch( stream->audio_format ){
1811 +
1812 + case SNDRV_PCM_FORMAT_S8:
1813 + ret = copy_to_user_S8_CM( stream, to, toCount );
1814 + break;
1815 +
1816 + case SNDRV_PCM_FORMAT_U8:
1817 + ret = copy_to_user_U8_CM( stream, to, toCount );
1818 + break;
1819 +
1820 + case SNDRV_PCM_FORMAT_S16_LE:
1821 + ret = copy_to_user_S16_LE_CM( stream, to, toCount );
1822 + break;
1823 +
1824 + case SNDRV_PCM_FORMAT_U16_LE:
1825 + ret = copy_to_user_U16_LE_CM( stream, to, toCount );
1826 + break;
1827 +
1828 + case SNDRV_PCM_FORMAT_S24_LE:
1829 + //ret = copy_to_user_S24_LE( stream, to, toCount );
1830 + //break;
1831 +
1832 + case SNDRV_PCM_FORMAT_U24_LE:
1833 + //ret = copy_to_user_U24_LE( stream, to, toCount );
1834 + //break;
1835 +
1836 + case SNDRV_PCM_FORMAT_S32_LE:
1837 + default:
1838 + DPRINTK( "ep93xx_i2s copy to user unsupported audio format %x\n",stream->audio_format );
1839 + break;
1840 + }
1841 +
1842 + }
1843 + else{
1844 +
1845 + switch( stream->audio_format ){
1846 +
1847 + case SNDRV_PCM_FORMAT_S8:
1848 + ret = copy_to_user_S8( stream, to, toCount );
1849 + break;
1850 +
1851 + case SNDRV_PCM_FORMAT_U8:
1852 + ret = copy_to_user_U8( stream, to, toCount );
1853 + break;
1854 +
1855 + case SNDRV_PCM_FORMAT_S16_LE:
1856 + ret = copy_to_user_S16_LE( stream, to, toCount );
1857 + break;
1858 +
1859 + case SNDRV_PCM_FORMAT_U16_LE:
1860 + ret = copy_to_user_U16_LE( stream, to, toCount );
1861 + break;
1862 +
1863 + case SNDRV_PCM_FORMAT_S24_LE:
1864 + //ret = copy_to_user_S24_LE( stream, to, toCount );
1865 + //break;
1866 +
1867 + case SNDRV_PCM_FORMAT_U24_LE:
1868 + //ret = copy_to_user_U24_LE( stream, to, toCount );
1869 + //break;
1870 + DPRINTK( "ep93xx_i2s copy to user unsupported audio format %x\n",stream->audio_format );
1871 + break;
1872 +
1873 + case SNDRV_PCM_FORMAT_S32_LE:
1874 +
1875 + //__copy_to_user( (char *)to, from, toCount);
1876 + ret = copy_to_user_U32( stream, to, toCount );
1877 + break;
1878 + default:
1879 + DPRINTK( "ep93xx_i2s copy to user unsupported audio format\n" );
1880 + break;
1881 + }
1882 +
1883 + }
1884 + return ret;
1885 +}
1886 +
1887 +static __inline__ int copy_from_user_S24_LE
1888 +(
1889 + audio_stream_t *stream,
1890 + const char *from,
1891 + int toCount
1892 +)
1893 +{
1894 + int *dma_buffer_0 = (int *)stream->hwbuf[0];
1895 + int *dma_buffer_1 = (int *)stream->hwbuf[1];
1896 + int *dma_buffer_2 = (int *)stream->hwbuf[2];
1897 + int count;
1898 +
1899 + unsigned int * user_buffer = (unsigned int *)from;
1900 + unsigned int data;
1901 +
1902 + int toCount0 = toCount;
1903 + count = 8 * stream->dma_num_channels;
1904 +
1905 + while (toCount > 0){
1906 +
1907 + __get_user(data, user_buffer++);
1908 + *dma_buffer_0++ = (unsigned int)data;
1909 + __get_user(data, user_buffer++);
1910 + *dma_buffer_0++ = (unsigned int)data;
1911 +
1912 + if(stream->audio_channels_flag & CHANNEL_REAR ){
1913 + __get_user(data, user_buffer++);
1914 + *dma_buffer_1++ = (unsigned int)data;
1915 + __get_user(data, user_buffer++);
1916 + *dma_buffer_1++ = (unsigned int)data;
1917 + }
1918 +
1919 + if(stream->audio_channels_flag & CHANNEL_CENTER_LFE ){
1920 + __get_user(data, user_buffer++);
1921 + *dma_buffer_2++ = (unsigned int)data;
1922 + __get_user(data, user_buffer++);
1923 + *dma_buffer_2++ = (unsigned int)data;
1924 + }
1925 + toCount -= count;
1926 + }
1927 + return toCount0 / 2;
1928 +}
1929 +
1930 +static __inline__ int copy_from_user_U24_LE
1931 +(
1932 + audio_stream_t *stream,
1933 + const char *from,
1934 + int toCount
1935 +)
1936 +{
1937 + int *dma_buffer_0 = (int *)stream->hwbuf[0];
1938 + int *dma_buffer_1 = (int *)stream->hwbuf[1];
1939 + int *dma_buffer_2 = (int *)stream->hwbuf[2];
1940 + int count;
1941 + unsigned int * user_buffer = (unsigned int *)from;
1942 + unsigned int data;
1943 +
1944 + int toCount0 = toCount;
1945 + count = 8 * stream->dma_num_channels;
1946 +
1947 + while (toCount > 0){
1948 +
1949 + __get_user(data, user_buffer++);
1950 + *dma_buffer_0++ = ((unsigned int)data ^ 0x8000);
1951 + __get_user(data, user_buffer++);
1952 + *dma_buffer_0++ = ((unsigned int)data ^ 0x8000);
1953 +
1954 + if(stream->audio_channels_flag & CHANNEL_REAR ){
1955 + __get_user(data, user_buffer++);
1956 + *dma_buffer_1++ = ((unsigned int)data ^ 0x8000);
1957 + __get_user(data, user_buffer++);
1958 + *dma_buffer_1++ = ((unsigned int)data ^ 0x8000);
1959 + }
1960 +
1961 + if(stream->audio_channels_flag & CHANNEL_CENTER_LFE ){
1962 + __get_user(data, user_buffer++);
1963 + *dma_buffer_2++ = ((unsigned int)data ^ 0x8000);
1964 + __get_user(data, user_buffer++);
1965 + *dma_buffer_2++ = ((unsigned int)data ^ 0x8000);
1966 + }
1967 + toCount -= count;
1968 + }
1969 + return toCount0 / 2;
1970 +}
1971 +
1972 +static __inline__ int copy_from_user_S16_LE
1973 +(
1974 + audio_stream_t *stream,
1975 + const char *from,
1976 + int toCount
1977 +)
1978 +{
1979 + int *dma_buffer_0 = (int *)stream->hwbuf[0];
1980 + int *dma_buffer_1 = (int *)stream->hwbuf[1];
1981 + int *dma_buffer_2 = (int *)stream->hwbuf[2];
1982 + unsigned short *user_buffer = (unsigned short *)from;
1983 + unsigned short data;
1984 +
1985 + int toCount0 = toCount;
1986 + int count;
1987 + count = 8 * stream->dma_num_channels;
1988 +
1989 + while (toCount > 0){
1990 +
1991 + __get_user(data, user_buffer++);
1992 + *dma_buffer_0++ = data;
1993 + if(stream->audio_num_channels == 2){
1994 + __get_user(data, user_buffer++);
1995 + }
1996 + *dma_buffer_0++ = data;
1997 +
1998 + if(stream->audio_channels_flag & CHANNEL_REAR ){
1999 + __get_user(data, user_buffer++);
2000 + *dma_buffer_1++ = data;
2001 + __get_user(data, user_buffer++);
2002 + *dma_buffer_1++ = data;
2003 + }
2004 +
2005 + if(stream->audio_channels_flag & CHANNEL_CENTER_LFE ){
2006 + __get_user(data, user_buffer++);
2007 + *dma_buffer_2++ = data;
2008 + __get_user(data, user_buffer++);
2009 + *dma_buffer_2++ = data;
2010 + }
2011 + toCount -= count;
2012 + }
2013 +
2014 + if(stream->audio_num_channels == 1){
2015 + return toCount0 / 4;
2016 + }
2017 + return toCount0 / 2;
2018 +}
2019 +
2020 +static __inline__ int copy_from_user_U16_LE
2021 +(
2022 + audio_stream_t *stream,
2023 + const char *from,
2024 + int toCount
2025 +)
2026 +{
2027 + int *dma_buffer_0 = (int *)stream->hwbuf[0];
2028 + int *dma_buffer_1 = (int *)stream->hwbuf[1];
2029 + int *dma_buffer_2 = (int *)stream->hwbuf[2];
2030 + int count;
2031 + unsigned short * user_buffer = (unsigned short *)from;
2032 + unsigned short data;
2033 +
2034 + int toCount0 = toCount;
2035 + count = 8 * stream->dma_num_channels;
2036 +
2037 + while (toCount > 0){
2038 +
2039 + __get_user(data, user_buffer++);
2040 + *dma_buffer_0++ = ((unsigned int)data ^ 0x8000);
2041 + if(stream->audio_num_channels == 2){
2042 + __get_user(data, user_buffer++);
2043 + }
2044 + *dma_buffer_0++ = ((unsigned int)data ^ 0x8000);
2045 +
2046 + if(stream->audio_channels_flag & CHANNEL_REAR ){
2047 + __get_user(data, user_buffer++);
2048 + *dma_buffer_1++ = ((unsigned int)data ^ 0x8000);
2049 + __get_user(data, user_buffer++);
2050 + *dma_buffer_1++ = ((unsigned int)data ^ 0x8000);
2051 + }
2052 +
2053 + if(stream->audio_channels_flag & CHANNEL_CENTER_LFE ){
2054 + __get_user(data, user_buffer++);
2055 + *dma_buffer_2++ = ((unsigned int)data ^ 0x8000);
2056 + __get_user(data, user_buffer++);
2057 + *dma_buffer_2++ = ((unsigned int)data ^ 0x8000);
2058 + }
2059 + toCount -= count;
2060 + }
2061 +
2062 + if(stream->audio_num_channels == 1){
2063 + return toCount0 / 4;
2064 + }
2065 + return toCount0 / 2;
2066 +}
2067 +
2068 +static __inline__ int copy_from_user_S8
2069 +(
2070 + audio_stream_t *stream,
2071 + const char *from,
2072 + int toCount
2073 +)
2074 +{
2075 + char *dma_buffer_0 = (char *)stream->hwbuf[0];
2076 + char *dma_buffer_1 = (char *)stream->hwbuf[1];
2077 + char *dma_buffer_2 = (char *)stream->hwbuf[2];
2078 + int count;
2079 + unsigned char * user_buffer = (unsigned char *)from;
2080 + unsigned char data;
2081 +
2082 + int toCount0 = toCount;
2083 + count = 8 * stream->dma_num_channels;
2084 +
2085 + dma_buffer_0++;
2086 + dma_buffer_1++;
2087 + dma_buffer_2++;
2088 +
2089 + while (toCount > 0){
2090 + __get_user(data, user_buffer++);
2091 + *dma_buffer_0 = data;
2092 + dma_buffer_0 += 4;
2093 + if(stream->audio_num_channels == 2){
2094 + __get_user(data, user_buffer++);
2095 + }
2096 + *dma_buffer_0 = data;
2097 + dma_buffer_0 += 4;
2098 +
2099 + if(stream->audio_channels_flag & CHANNEL_REAR ){
2100 + __get_user(data, user_buffer++);
2101 + *dma_buffer_1 = data;
2102 + dma_buffer_1 += 4;
2103 + __get_user(data, user_buffer++);
2104 + *dma_buffer_1 = data;
2105 + dma_buffer_1 += 4;
2106 + }
2107 +
2108 + if(stream->audio_channels_flag & CHANNEL_CENTER_LFE ){
2109 + __get_user(data, user_buffer++);
2110 + *dma_buffer_2 = data;
2111 + dma_buffer_2 += 4;
2112 + __get_user(data, user_buffer++);
2113 + *dma_buffer_2 = data;
2114 + dma_buffer_2 += 4;
2115 + }
2116 + toCount -= count;
2117 + }
2118 +
2119 + if(stream->audio_num_channels == 1){
2120 + return toCount0 / 8;
2121 + }
2122 + return toCount0 / 4;
2123 +}
2124 +
2125 +static __inline__ int copy_from_user_U8
2126 +(
2127 + audio_stream_t *stream,
2128 + const char *from,
2129 + int toCount
2130 +)
2131 +{
2132 + char *dma_buffer_0 = (char *)stream->hwbuf[0];
2133 + char *dma_buffer_1 = (char *)stream->hwbuf[1];
2134 + char *dma_buffer_2 = (char *)stream->hwbuf[2];
2135 + int count;
2136 + unsigned char *user_buffer = (unsigned char *)from;
2137 + unsigned char data;
2138 +
2139 + int toCount0 = toCount;
2140 + count = 8 * stream->dma_num_channels;
2141 +
2142 + dma_buffer_0 ++;
2143 + dma_buffer_1 ++;
2144 + dma_buffer_2 ++;
2145 +
2146 + while (toCount > 0){
2147 +
2148 + __get_user(data, user_buffer++);
2149 + *dma_buffer_0 = ((unsigned char)data ^ 0x80);
2150 + dma_buffer_0 += 4;
2151 + if(stream->audio_num_channels == 2){
2152 + __get_user(data, user_buffer++);
2153 + }
2154 + *dma_buffer_0 = ((unsigned char)data ^ 0x80);
2155 + dma_buffer_0 += 4;
2156 +
2157 + if(stream->audio_channels_flag & CHANNEL_REAR ){
2158 + __get_user(data, user_buffer++);
2159 + *dma_buffer_1 = ((unsigned char)data ^ 0x80);
2160 + dma_buffer_1 += 4;
2161 + __get_user(data, user_buffer++);
2162 + *dma_buffer_1 = ((unsigned char)data ^ 0x80);
2163 + dma_buffer_1 += 4;
2164 + }
2165 +
2166 + if(stream->audio_channels_flag & CHANNEL_CENTER_LFE ){
2167 + __get_user(data, user_buffer++);
2168 + *dma_buffer_2 = ((unsigned char)data ^ 0x80);
2169 + dma_buffer_2 += 4;
2170 + __get_user(data, user_buffer++);
2171 + *dma_buffer_2 = ((unsigned char)data ^ 0x80);
2172 + dma_buffer_2 += 4;
2173 + }
2174 + toCount -= count;
2175 + }
2176 +
2177 + if(stream->audio_num_channels == 1){
2178 + return toCount0 / 8;
2179 + }
2180 + return toCount0 / 4;
2181 +}
2182 +
2183 +static __inline__ int copy_from_user_S16_LE_CM
2184 +(
2185 + audio_stream_t *stream,
2186 + const char *from,
2187 + int toCount
2188 +)
2189 +{
2190 + unsigned int *dma_buffer_0 = (int *)stream->hwbuf[0];
2191 + unsigned int *dma_buffer_1 = (int *)stream->hwbuf[1];
2192 + unsigned int *dma_buffer_2 = (int *)stream->hwbuf[2];
2193 + unsigned short *user_buffer = (unsigned short *)from;
2194 + short data;
2195 + unsigned int val;
2196 + int toCount0 = toCount;
2197 + int count;
2198 + count = 4 * stream->dma_num_channels;
2199 +
2200 + //printk("count=%x tocount\n",count,toCount);
2201 + while (toCount > 0){
2202 +
2203 + __get_user(data, user_buffer++);
2204 + //*dma_buffer_0++ = data;
2205 + val = (unsigned int)data & 0x0000ffff;
2206 + if(stream->audio_num_channels == 2){
2207 + __get_user(data, user_buffer++);
2208 + }
2209 + *dma_buffer_0++ = ((unsigned int)data << 16) | val;
2210 +
2211 + if(stream->audio_channels_flag & CHANNEL_REAR ){
2212 + __get_user(data, user_buffer++);
2213 + //*dma_buffer_1++ = data;
2214 + val = (unsigned int)data & 0x0000ffff;
2215 + __get_user(data, user_buffer++);
2216 + *dma_buffer_1++ = ((unsigned int)data << 16) | val;
2217 + }
2218 +
2219 + if(stream->audio_channels_flag & CHANNEL_CENTER_LFE ){
2220 + __get_user(data, user_buffer++);
2221 + //*dma_buffer_2++ = data;
2222 + val = (unsigned int)data & 0x0000ffff;
2223 + __get_user(data, user_buffer++);
2224 + *dma_buffer_2++ = ((unsigned int)data << 16) | val;
2225 + }
2226 + toCount -= count;
2227 + }
2228 +
2229 + if(stream->audio_num_channels == 1){
2230 + return toCount0 /2 ;
2231 + }
2232 +
2233 + return toCount0 ;
2234 +}
2235 +
2236 +static __inline__ int copy_from_user_U16_LE_CM
2237 +(
2238 + audio_stream_t *stream,
2239 + const char *from,
2240 + int toCount
2241 +)
2242 +{
2243 + int *dma_buffer_0 = (int *)stream->hwbuf[0];
2244 + int *dma_buffer_1 = (int *)stream->hwbuf[1];
2245 + int *dma_buffer_2 = (int *)stream->hwbuf[2];
2246 + int count;
2247 + unsigned short * user_buffer = (unsigned short *)from;
2248 + unsigned short data;
2249 + unsigned int val;
2250 + int toCount0 = toCount;
2251 + count = 4 * stream->dma_num_channels;
2252 +
2253 + while (toCount > 0){
2254 +
2255 + __get_user(data, user_buffer++);
2256 + //*dma_buffer_0++ = ((unsigned int)data ^ 0x8000);
2257 + val = (unsigned int)data & 0x0000ffff;
2258 + if(stream->audio_num_channels == 2){
2259 + __get_user(data, user_buffer++);
2260 + }
2261 + //*dma_buffer_0++ = ((unsigned int)data ^ 0x8000);
2262 + *dma_buffer_0++ = (((unsigned int)data << 16) | val) ^ 0x80008000;
2263 +
2264 + if(stream->audio_channels_flag & CHANNEL_REAR ){
2265 + __get_user(data, user_buffer++);
2266 + //*dma_buffer_1++ = ((unsigned int)data ^ 0x8000);
2267 + val = (unsigned int)data & 0x0000ffff;
2268 + __get_user(data, user_buffer++);
2269 + //*dma_buffer_1++ = ((unsigned int)data ^ 0x8000);
2270 + *dma_buffer_1++ = (((unsigned int)data << 16) | val) ^ 0x80008000;
2271 + }
2272 +
2273 + if(stream->audio_channels_flag & CHANNEL_CENTER_LFE ){
2274 + __get_user(data, user_buffer++);
2275 + //*dma_buffer_2++ = ((unsigned int)data ^ 0x8000);
2276 + val = (unsigned int)data & 0x0000ffff;
2277 + __get_user(data, user_buffer++);
2278 + //*dma_buffer_2++ = ((unsigned int)data ^ 0x8000);
2279 + *dma_buffer_2++ = (((unsigned int)data << 16) | val) ^ 0x80008000;
2280 + }
2281 + toCount -= count;
2282 + }
2283 +
2284 + if(stream->audio_num_channels == 1){
2285 + return toCount0/2;
2286 + }
2287 + return toCount0 ;
2288 +}
2289 +
2290 +static __inline__ int copy_from_user_S8_CM
2291 +(
2292 + audio_stream_t *stream,
2293 + const char *from,
2294 + int toCount
2295 +)
2296 +{
2297 + char *dma_buffer_0 = (char *)stream->hwbuf[0];
2298 + char *dma_buffer_1 = (char *)stream->hwbuf[1];
2299 + char *dma_buffer_2 = (char *)stream->hwbuf[2];
2300 + int count;
2301 + unsigned char * user_buffer = (unsigned char *)from;
2302 + unsigned char data;
2303 + int toCount0 = toCount;
2304 + count = 4 * stream->dma_num_channels;
2305 +
2306 + dma_buffer_0++;
2307 + dma_buffer_1++;
2308 + dma_buffer_2++;
2309 +
2310 + while (toCount > 0){
2311 + __get_user(data, user_buffer++);
2312 + *dma_buffer_0 = data;
2313 + *(dma_buffer_0 +1 ) = 0;
2314 + dma_buffer_0 += 2;
2315 +
2316 + if(stream->audio_num_channels == 2){
2317 + __get_user(data, user_buffer++);
2318 + }
2319 + *dma_buffer_0 = data;
2320 + *(dma_buffer_0 +1 ) = 0;
2321 + dma_buffer_0 += 2;
2322 +
2323 + if(stream->audio_channels_flag & CHANNEL_REAR ){
2324 + __get_user(data, user_buffer++);
2325 + *dma_buffer_1 = data;
2326 + dma_buffer_1 += 2;
2327 + __get_user(data, user_buffer++);
2328 + *dma_buffer_1 = data;
2329 + dma_buffer_1 += 2;
2330 + }
2331 +
2332 + if(stream->audio_channels_flag & CHANNEL_CENTER_LFE ){
2333 + __get_user(data, user_buffer++);
2334 + *dma_buffer_2 = data;
2335 + dma_buffer_2 += 2;
2336 + __get_user(data, user_buffer++);
2337 + *dma_buffer_2 = data;
2338 + dma_buffer_2 += 2;
2339 + }
2340 + toCount -= count;
2341 + }
2342 +
2343 + if(stream->audio_num_channels == 1){
2344 + return toCount0 / 4;
2345 + }
2346 +
2347 + return toCount0 / 2;
2348 +}
2349 +
2350 +static __inline__ int copy_from_user_U8_CM
2351 +(
2352 + audio_stream_t *stream,
2353 + const char *from,
2354 + int toCount
2355 +)
2356 +{
2357 + unsigned char *dma_buffer_0 = (unsigned char *)stream->hwbuf[0];
2358 + unsigned char *dma_buffer_1 = (unsigned char *)stream->hwbuf[1];
2359 + unsigned char *dma_buffer_2 = (unsigned char *)stream->hwbuf[2];
2360 + int count;
2361 + unsigned char *user_buffer = (unsigned char *)from;
2362 + unsigned char data;
2363 +
2364 + int toCount0 = toCount;
2365 + count = 4 * stream->dma_num_channels;
2366 +
2367 + dma_buffer_0 ++;
2368 + dma_buffer_1 ++;
2369 + dma_buffer_2 ++;
2370 +
2371 + while (toCount > 0){
2372 +
2373 + __get_user(data, user_buffer++);
2374 + *dma_buffer_0 = ((unsigned char)data ^ 0x80);
2375 + *(dma_buffer_0 +1 ) = 0;
2376 + dma_buffer_0 += 2;
2377 +
2378 + if(stream->audio_num_channels == 2){
2379 + __get_user(data, user_buffer++);
2380 + }
2381 + *dma_buffer_0 = ((unsigned char)data ^ 0x80);
2382 + *(dma_buffer_0 +1 ) = 0;
2383 + dma_buffer_0 += 2;
2384 +
2385 +
2386 + if(stream->audio_channels_flag & CHANNEL_REAR ){
2387 + __get_user(data, user_buffer++);
2388 + *dma_buffer_1 = ((unsigned char)data ^ 0x80);
2389 + dma_buffer_1 += 2;
2390 + __get_user(data, user_buffer++);
2391 + *dma_buffer_1 = ((unsigned char)data ^ 0x80);
2392 + dma_buffer_1 += 2;
2393 + }
2394 +
2395 + if(stream->audio_channels_flag & CHANNEL_CENTER_LFE ){
2396 + __get_user(data, user_buffer++);
2397 + *dma_buffer_2 = ((unsigned char)data ^ 0x80);
2398 + dma_buffer_2 += 2;
2399 + __get_user(data, user_buffer++);
2400 + *dma_buffer_2 = ((unsigned char)data ^ 0x80);
2401 + dma_buffer_2 += 2;
2402 + }
2403 + toCount -= count;
2404 + }
2405 +
2406 + if(stream->audio_num_channels == 1){
2407 + return toCount0 / 4;
2408 + }
2409 +
2410 + return toCount0 / 2;
2411 +}
2412 +
2413 +static int copy_from_user_U32
2414 +(
2415 + audio_stream_t *stream,
2416 + const char *from,
2417 + int toCount
2418 +)
2419 +{
2420 + char *dma_buffer_0 = (char *)stream->hwbuf[0];
2421 +
2422 + if (copy_from_user( (char *)dma_buffer_0, from, toCount))
2423 + {
2424 + return -EFAULT;
2425 + }
2426 +
2427 + return toCount;
2428 +
2429 +}
2430 +
2431 +/*
2432 + * Returns negative for error
2433 + * Returns # of bytes transferred out of the from buffer
2434 + * for success.
2435 + */
2436 +static __inline__ int copy_from_user_with_conversion
2437 +(
2438 + audio_stream_t *stream,
2439 + const char *from,
2440 + int toCount,
2441 + int bCompactMode
2442 +)
2443 +{
2444 + int ret = 0;
2445 +// DPRINTK("copy_from_user_with_conversion\n");
2446 + if( toCount == 0 ){
2447 + DPRINTK("ep93xx_i2s_copy_from_user_with_conversion - nothing to copy!\n");
2448 + }
2449 +
2450 + if( bCompactMode == 1){
2451 +
2452 + switch( stream->audio_format ){
2453 +
2454 + case SNDRV_PCM_FORMAT_S8:
2455 + DPRINTK("SNDRV_PCM_FORMAT_S8 CM\n");
2456 + ret = copy_from_user_S8_CM( stream, from, toCount );
2457 + break;
2458 +
2459 + case SNDRV_PCM_FORMAT_U8:
2460 + DPRINTK("SNDRV_PCM_FORMAT_U8 CM\n");
2461 + ret = copy_from_user_U8_CM( stream, from, toCount );
2462 + break;
2463 +
2464 + case SNDRV_PCM_FORMAT_S16_LE:
2465 + DPRINTK("SNDRV_PCM_FORMAT_S16_LE CM\n");
2466 + ret = copy_from_user_S16_LE_CM( stream, from, toCount );
2467 + break;
2468 +
2469 + case SNDRV_PCM_FORMAT_U16_LE:
2470 + DPRINTK("SNDRV_PCM_FORMAT_U16_LE CM\n");
2471 + ret = copy_from_user_U16_LE_CM( stream, from, toCount );
2472 + break;
2473 +
2474 + case SNDRV_PCM_FORMAT_S24_LE:
2475 + DPRINTK("SNDRV_PCM_FORMAT_S24_LE CM\n");
2476 + //ret = copy_from_user_S24_LE( stream, from, toCount );
2477 + //break;
2478 +
2479 + case SNDRV_PCM_FORMAT_U24_LE:
2480 + DPRINTK("SNDRV_PCM_FORMAT_U24_LE CM\n");
2481 + //ret = copy_from_user_U24_LE( stream, from, toCount );
2482 + //break;
2483 + case SNDRV_PCM_FORMAT_S32_LE:
2484 + DPRINTK("SNDRV_PCM_FORMAT_S32_LE CM\n");
2485 + //break;
2486 + default:
2487 + DPRINTK( "ep93xx_i2s copy from user unsupported audio format\n" );
2488 + break;
2489 + }
2490 + }
2491 + else{
2492 + switch( stream->audio_format ){
2493 +
2494 + case SNDRV_PCM_FORMAT_S8:
2495 + DPRINTK("SNDRV_PCM_FORMAT_S8\n");
2496 + ret = copy_from_user_S8( stream, from, toCount );
2497 + break;
2498 +
2499 + case SNDRV_PCM_FORMAT_U8:
2500 + DPRINTK("SNDRV_PCM_FORMAT_U8\n");
2501 + ret = copy_from_user_U8( stream, from, toCount );
2502 + break;
2503 +
2504 + case SNDRV_PCM_FORMAT_S16_LE:
2505 + DPRINTK("SNDRV_PCM_FORMAT_S16_LE\n");
2506 + ret = copy_from_user_S16_LE( stream, from, toCount );
2507 + break;
2508 +
2509 + case SNDRV_PCM_FORMAT_U16_LE:
2510 + DPRINTK("SNDRV_PCM_FORMAT_U16_LE\n");
2511 + ret = copy_from_user_U16_LE( stream, from, toCount );
2512 + break;
2513 +
2514 + case SNDRV_PCM_FORMAT_S24_LE:
2515 + DPRINTK("SNDRV_PCM_FORMAT_S24_LE\n");
2516 + //ret = copy_from_user_S24_LE( stream, from, toCount );
2517 + //break;
2518 +
2519 + case SNDRV_PCM_FORMAT_U24_LE:
2520 + DPRINTK("SNDRV_PCM_FORMAT_U24_LE\n");
2521 + //ret = copy_from_user_U24_LE( stream, from, toCount );
2522 + //break;
2523 + DPRINTK( "ep93xx_i2s copy from user unsupported audio format\n" );
2524 + break;
2525 + case SNDRV_PCM_FORMAT_S32_LE:
2526 + DPRINTK("SNDRV_PCM_FORMAT_S32_LE\n");
2527 + ret = copy_from_user_U32( stream, from, toCount );
2528 + break;
2529 + default:
2530 + DPRINTK( "ep93xx_i2s copy from user unsupported audio format\n" );
2531 + break;
2532 + }
2533 + }
2534 +
2535 + return ret;
2536 +}
2537 +
2538 +
2539 +
2540 +/*
2541 + * For audio playback, we convert samples of arbitrary format to be 32 bit
2542 + * for our hardware. We're scaling a user buffer to a dma buffer. So when
2543 + * report byte counts, we scale them acording to the ratio of DMA sample
2544 + * size to user buffer sample size. When we report # of DMA fragments,
2545 + * we don't scale that. So:
2546 + *
2547 + * Also adjust the size and number of dma fragments if sample size changed.
2548 + *
2549 + * Input format Input sample Output sample size ratio (out:in)
2550 + * bits channels size (bytes) CM non-CM CM non-CM
2551 + * 8 stereo 2 4 8 2:1 4:1
2552 + * 16 stereo 4 4 8 1:1 2:1
2553 + * 24 stereo 6 4 8 X 8:6 not a real case
2554 + *
2555 + */
2556 +static void snd_ep93xx_dma2usr_ratio( audio_stream_t * stream,int bCompactMode )
2557 +{
2558 + unsigned int dma_sample_size, user_sample_size;
2559 +
2560 + if(bCompactMode == 1){
2561 + dma_sample_size = 4; /* each stereo sample is 2 * 32 bits */
2562 + }
2563 + else{
2564 + dma_sample_size = 8;
2565 + }
2566 +
2567 + // If stereo 16 bit, user sample is 4 bytes.
2568 + // If stereo 8 bit, user sample is 2 bytes.
2569 + if(stream->audio_num_channels == 1){
2570 + user_sample_size = stream->audio_stream_bitwidth / 8;
2571 + }
2572 + else{
2573 + user_sample_size = stream->audio_stream_bitwidth / 4;
2574 + }
2575 +
2576 + stream->dma2usr_ratio = dma_sample_size / user_sample_size;
2577 +}
2578 +
2579 +/*---------------------------------------------------------------------------------------------*/
2580 +
2581 +static int snd_ep93xx_dma_free(struct snd_pcm_substream *substream ){
2582 +
2583 +
2584 + audio_state_t *state = substream->private_data;
2585 + audio_stream_t *stream = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
2586 + state->output_stream:state->input_stream;
2587 + int i;
2588 +
2589 +
2590 + DPRINTK("snd_ep93xx_dma_free - enter\n");
2591 + for( i = 0 ; i < stream->dma_num_channels ;i++ ){
2592 + ep93xx_dma_free( stream->dmahandles[i] );
2593 + }
2594 + DPRINTK("snd_ep93xx_dma_free - exit\n");
2595 + return 0;
2596 +}
2597 +
2598 +static int snd_ep93xx_dma_config(struct snd_pcm_substream *substream ){
2599 +
2600 + audio_state_t *state = substream->private_data;
2601 + audio_stream_t *stream = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
2602 + state->output_stream:state->input_stream;
2603 + int i,err = 0;
2604 +
2605 + DPRINTK("snd_ep93xx_dma_config - enter\n");
2606 +
2607 + for( i = 0 ; i < stream->dma_num_channels ;i++ ){
2608 +
2609 + err = ep93xx_dma_request(&stream->dmahandles[i],
2610 + stream->devicename,
2611 + (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
2612 + state->output_dma[i]:state->input_dma[i] );
2613 + if (err){
2614 + printk("snd_ep93xx_dma_config - exit ERROR dma request failed\n");
2615 + return err;
2616 + }
2617 + err = ep93xx_dma_config( stream->dmahandles[i],
2618 + IGNORE_CHANNEL_ERROR,
2619 + 0,
2620 + (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
2621 + snd_ep93xx_dma_tx_callback:snd_ep93xx_dma_rx_callback,
2622 + (unsigned int)substream );
2623 + if (err){
2624 + printk("snd_ep93xx_dma_config - exit ERROR dma request failed\n");
2625 + return err;
2626 + }
2627 + }
2628 +
2629 + DPRINTK("snd_ep93xx_dma_config - enter\n");
2630 + return err;
2631 +}
2632 +
2633 +static void snd_ep93xx_dma_start( audio_state_t * state, audio_stream_t * stream )
2634 +{
2635 + int err,i;
2636 +
2637 + DPRINTK("snd_ep93xx_dma_start - enter\n");
2638 +
2639 + for(i = 0 ;i < stream->dma_num_channels;i++)
2640 + err = ep93xx_dma_start( stream->dmahandles[i], 1,(unsigned int *) stream->dmahandles );
2641 +
2642 + stream->active = 1;
2643 +
2644 + DPRINTK("snd_ep93xx_dma_start - exit\n");
2645 +}
2646 +
2647 +static void snd_ep93xx_dma_pause( audio_state_t * state, audio_stream_t * stream )
2648 +{
2649 + int i;
2650 +
2651 + DPRINTK("snd_ep93xx_dma_pause - enter\n");
2652 +
2653 + for(i = 0 ;i < stream->dma_num_channels;i++)
2654 + ep93xx_dma_pause( stream->dmahandles[i], 1,(unsigned int *)stream->dmahandles );
2655 +
2656 + stream->active = 0;
2657 + DPRINTK("snd_ep93xx_dma_pause - exit\n");
2658 +
2659 +}
2660 +
2661 +static void snd_ep93xx_dma_flush( audio_state_t * state, audio_stream_t * stream ){
2662 +
2663 + int i;
2664 +
2665 + DPRINTK("snd_ep93xx_dma_flush - enter\n");
2666 +
2667 + for( i = 0 ; i < stream->dma_num_channels ; i++ )
2668 + ep93xx_dma_flush( stream->dmahandles[i] );
2669 +
2670 + DPRINTK("snd_ep93xx_dma_flush - exit\n");
2671 +}
2672 +
2673 +static void snd_ep93xx_deallocate_buffers( struct snd_pcm_substream *substream, audio_stream_t *stream )
2674 +{
2675 + int i;
2676 + audio_channel_t *dma_chan;
2677 +
2678 + DPRINTK("snd_ep93xx_deallocate_buffers - enter\n");
2679 +
2680 + if( stream->dma_channels ){
2681 +
2682 + for(i = 0;i < stream->dma_num_channels;i++){
2683 +
2684 + dma_chan = &stream->dma_channels[i];
2685 +
2686 + if( dma_chan->area ){
2687 +
2688 + if( dma_chan->audio_buffers ){
2689 +
2690 + kfree(dma_chan->audio_buffers);
2691 + dma_chan->audio_buffers = NULL;
2692 +
2693 + }
2694 +
2695 + kfree(dma_chan->area);
2696 + dma_chan->area = NULL;
2697 + }
2698 + }
2699 + kfree(stream->dma_channels);
2700 + stream->dma_channels = NULL;
2701 + }
2702 + DPRINTK("snd_ep93xx_deallocate_buffers - exit\n");
2703 +}
2704 +
2705 +static int snd_ep93xx_allocate_buffers(struct snd_pcm_substream *substream, audio_stream_t *stream)
2706 +{
2707 + audio_channel_t *channel;
2708 + unsigned int size,tmpsize,bufsize,bufextsize;
2709 + int i,j;
2710 +
2711 +
2712 + DPRINTK("snd_ep93xx_allocate_buffers - enter\n" );
2713 +
2714 + if (stream->dma_channels){
2715 + printk("ep93xx_i2s %s BUSY\n",__FUNCTION__);
2716 + return -EBUSY;
2717 + }
2718 +
2719 + stream->dma_channels = (audio_channel_t *)kmalloc(sizeof(audio_channel_t) * stream->dma_num_channels , GFP_KERNEL);
2720 +
2721 + if (!stream->dma_channels){
2722 + printk(AUDIO_NAME ": unable to allocate dma_channels memory\n");
2723 + return - ENOMEM;
2724 + }
2725 +
2726 + size = ( stream->dmasize / stream->dma_num_channels ) * stream->dma2usr_ratio;
2727 +
2728 + for( i = 0; i < stream->dma_num_channels;i++){
2729 + channel = &stream->dma_channels[i];
2730 +
2731 + channel->area = kmalloc( size, GFP_DMA );
2732 +
2733 + if(!channel->area){
2734 + printk(AUDIO_NAME ": unable to allocate audio memory\n");
2735 + return -ENOMEM;
2736 + }
2737 + channel->bytes = size;
2738 + channel->addr = __virt_to_phys((int) channel->area);
2739 + memset( channel->area, 0, channel->bytes );
2740 +
2741 + bufsize = ( stream->fragsize / stream->dma_num_channels ) * stream->dma2usr_ratio;
2742 + channel->audio_buff_count = size / bufsize;
2743 + bufextsize = size % bufsize;
2744 +
2745 + if( bufextsize > 0 ){
2746 + channel->audio_buff_count++;
2747 + }
2748 +
2749 + channel->audio_buffers = (audio_buf_t *)kmalloc(sizeof(audio_buf_t) * channel->audio_buff_count , GFP_KERNEL);
2750 +
2751 + if (!channel->audio_buffers){
2752 + printk(AUDIO_NAME ": unable to allocate audio memory\n ");
2753 + return -ENOMEM;
2754 + }
2755 +
2756 + tmpsize = size;
2757 +
2758 + for( j = 0; j < channel->audio_buff_count; j++){
2759 +
2760 + channel->audio_buffers[j].dma_addr = channel->addr + j * bufsize;
2761 +
2762 + if( tmpsize >= bufsize ){
2763 + tmpsize -= bufsize;
2764 + channel->audio_buffers[j].bytes = bufsize;
2765 + channel->audio_buffers[j].reportedbytes = bufsize / stream->dma2usr_ratio;
2766 + }
2767 + else{
2768 + channel->audio_buffers[j].bytes = bufextsize;
2769 + channel->audio_buffers[j].reportedbytes = bufextsize / stream->dma2usr_ratio;
2770 + }
2771 + }
2772 + }
2773 +
2774 + DPRINTK("snd_ep93xx_allocate_buffers -- exit SUCCESS\n" );
2775 + return 0;
2776 +}
2777 +
2778 +/*
2779 + * DMA callback functions
2780 + */
2781 +
2782 +static void snd_ep93xx_dma_tx_callback
2783 +(
2784 + ep93xx_dma_int_t DMAInt,
2785 + ep93xx_dma_dev_t device,
2786 + unsigned int user_data
2787 +)
2788 +{
2789 + int handle;
2790 + int i,chan;
2791 + unsigned int buf_id;
2792 +
2793 + struct snd_pcm_substream *substream = (struct snd_pcm_substream *)user_data;
2794 + audio_state_t *state = (audio_state_t *)(substream->private_data);
2795 + audio_stream_t *stream = state->output_stream;
2796 + audio_buf_t *buf;
2797 +
2798 + switch( device )
2799 + {
2800 + case DMATx_I2S3:
2801 + DPRINTK( "snd_ep93xx_dma_tx_callback - DMATx_I2S3\n");
2802 + i = 2;
2803 + break;
2804 + case DMATx_I2S2:
2805 + DPRINTK( "snd_ep93xx_dma_tx_callback - DMATx_I2S2\n");
2806 + i = 1;
2807 + break;
2808 + case DMATx_I2S1:
2809 + default:
2810 + DPRINTK( "snd_ep93xx_dma_tx_callback - DMATx_I2S1\n");
2811 + i = 0;
2812 + break;
2813 + }
2814 +
2815 + if(stream->audio_num_channels == 1){
2816 + chan = 0;
2817 + }
2818 + else{
2819 + chan = stream->audio_num_channels / 2 - 1;
2820 + }
2821 + handle = stream->dmahandles[i];
2822 +
2823 + if(stream->stopped == 0){
2824 +
2825 + if( ep93xx_dma_remove_buffer( handle, &buf_id ) >= 0 ){
2826 +
2827 + buf = (audio_buf_t *)buf_id;
2828 + stream->bytecount += buf->reportedbytes;
2829 + ep93xx_dma_add_buffer( stream->dmahandles[i],
2830 + (unsigned int)buf->dma_addr,
2831 + 0,
2832 + buf->bytes,
2833 + 0,
2834 + (unsigned int) buf );
2835 + if(chan == i)
2836 + snd_pcm_period_elapsed(substream);
2837 + }
2838 + }
2839 +}
2840 +
2841 +static void snd_ep93xx_dma_rx_callback
2842 +(
2843 + ep93xx_dma_int_t DMAInt,
2844 + ep93xx_dma_dev_t device,
2845 + unsigned int user_data
2846 +)
2847 +{
2848 + int handle,i,chan;
2849 + unsigned int buf_id;
2850 + audio_buf_t *buf;
2851 +
2852 + struct snd_pcm_substream *substream = (struct snd_pcm_substream *)user_data;
2853 + audio_state_t *state = (audio_state_t *)(substream->private_data);
2854 + audio_stream_t *stream = state->input_stream;
2855 +
2856 + switch( device ){
2857 +
2858 + case DMARx_I2S3:
2859 + DPRINTK( "snd_ep93xx_dma_rx_callback - DMARx_I2S3\n");
2860 + i = 2;
2861 + break;
2862 + case DMARx_I2S2:
2863 + DPRINTK( "snd_ep93xx_dma_rx_callback - DMARx_I2S2\n");
2864 + i = 1;
2865 + break;
2866 + case DMARx_I2S1:
2867 + default:
2868 + DPRINTK( "snd_ep93xx_dma_rx_callback - DMARx_I2S1\n");
2869 + i = 0;
2870 + break;
2871 + }
2872 +
2873 + if(stream->audio_num_channels == 1){
2874 + chan = 0;
2875 + }
2876 + else{
2877 + chan = stream->audio_num_channels / 2 - 1;
2878 + }
2879 + handle = stream->dmahandles[i];
2880 +
2881 + if( stream->stopped == 0 ){
2882 +
2883 + if( ep93xx_dma_remove_buffer( handle, &buf_id ) >= 0 ){
2884 +
2885 + buf = (audio_buf_t *)buf_id;
2886 + stream->bytecount += buf->reportedbytes;
2887 + ep93xx_dma_add_buffer( stream->dmahandles[i],
2888 + (unsigned int)buf->dma_addr,
2889 + 0,
2890 + buf->bytes,
2891 + 0,
2892 + (unsigned int) buf );
2893 + if( i == chan )
2894 + snd_pcm_period_elapsed(substream);
2895 + }
2896 + }
2897 +}
2898 +
2899 +static int snd_ep93xx_release(struct snd_pcm_substream *substream)
2900 +{
2901 + audio_state_t *state = (audio_state_t *)substream->private_data;
2902 + audio_stream_t *stream = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
2903 + state->output_stream : state->input_stream;
2904 +
2905 + DPRINTK("snd_ep93xx_release - enter\n");
2906 +
2907 + down(&state->sem);
2908 + stream->active = 0;
2909 + stream->stopped = 0;
2910 + snd_ep93xx_deallocate_buffers(substream, stream);
2911 + up(&state->sem);
2912 +
2913 + DPRINTK("snd_ep93xx_release - exit\n");
2914 +
2915 + return 0;
2916 +}
2917 +
2918 +static int ep93xx_ac97_pcm_startup(struct snd_pcm_substream *substream)
2919 +{
2920 + struct snd_pcm_runtime *runtime = substream->runtime;
2921 + int r;
2922 + int iTempMasterVol,iTempHeadphoneVol,iTempMonoVol,iTempRecordSelect;
2923 + /*save the old mixer*/
2924 + iTempRecordSelect = peek(AC97_1A_RECORD_SELECT);
2925 + iTempMasterVol = peek( AC97_02_MASTER_VOL);
2926 + iTempHeadphoneVol = peek( AC97_04_HEADPHONE_VOL);
2927 + iTempMonoVol = peek( AC97_06_MONO_VOL);
2928 +
2929 + runtime->hw.channels_min = 1;
2930 + runtime->hw.channels_max = 2;
2931 +
2932 + ep93xx_audio_init();
2933 + /*ep93xx_init_ac97_controller();*/
2934 +
2935 + /*reset the old output mixer*/
2936 + poke( AC97_02_MASTER_VOL, iTempMasterVol);
2937 + poke( AC97_04_HEADPHONE_VOL,iTempHeadphoneVol );
2938 + poke( AC97_06_MONO_VOL, iTempMonoVol);
2939 + poke( AC97_1A_RECORD_SELECT,iTempRecordSelect);
2940 +
2941 + r = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
2942 + AC97_RATES_FRONT_DAC : AC97_RATES_ADC;
2943 +
2944 + DPRINTK(" ep93xx_ac97_pcm_startup=%x\n",r);
2945 +
2946 + return 0;
2947 +}
2948 +
2949 +
2950 +static int snd_ep93xx_pcm_hw_params(struct snd_pcm_substream *substream,
2951 + struct snd_pcm_hw_params *params)
2952 +{
2953 + DPRINTK("snd_ep93xx_pcm_hw_params - enter\n");
2954 + return snd_pcm_lib_malloc_pages(substream,params_buffer_bytes(params));
2955 +}
2956 +
2957 +static int snd_ep93xx_pcm_hw_free(struct snd_pcm_substream *substream)
2958 +{
2959 +
2960 + DPRINTK("snd_ep93xx_pcm_hw_free - enter\n");
2961 + return snd_pcm_lib_free_pages(substream);
2962 +}
2963 +
2964 +/*
2965 + *snd_ep93xx_pcm_prepare: need to finish these functions as lower
2966 + *chip_set_sample_format
2967 + *chip_set_sample_rate
2968 + *chip_set_channels
2969 + *chip_set_dma_setup
2970 + */
2971 +
2972 +static int snd_ep93xx_pcm_prepare_playback( struct snd_pcm_substream *substream)
2973 +{
2974 + audio_state_t *state = (audio_state_t *) substream->private_data;
2975 + struct snd_pcm_runtime *runtime = substream->runtime;
2976 + audio_stream_t *stream = state->output_stream;
2977 +
2978 + DPRINTK("snd_ep93xx_pcm_prepare_playback - enter\n");
2979 +
2980 + ep93xx_audio_disable(1);
2981 + ep93xx_ac97_pcm_startup(substream);
2982 +
2983 + snd_ep93xx_deallocate_buffers(substream,stream);
2984 +
2985 + //if(runtime->channels % 2 != 0)
2986 + // return -1;
2987 +
2988 + DPRINTK("The runtime item : \n");
2989 + DPRINTK("runtime->dma_addr = 0x%x\n", runtime->dma_addr);
2990 + DPRINTK("runtime->dma_area = 0x%x\n", runtime->dma_area);
2991 + DPRINTK("runtime->dma_bytes = %d\n", runtime->dma_bytes);
2992 + DPRINTK("runtime->frame_bits = %d\n", runtime->frame_bits);
2993 + DPRINTK("runtime->buffer_size = %d\n", runtime->buffer_size);
2994 + DPRINTK("runtime->period_size = %d\n", runtime->period_size);
2995 + DPRINTK("runtime->periods = %d\n", runtime->periods);
2996 + DPRINTK("runtime->rate = %d\n", runtime->rate);
2997 + DPRINTK("runtime->format = %d\n", runtime->format);
2998 + DPRINTK("runtime->channels = %d\n", runtime->channels);
2999 +
3000 + /* set requestd format when available */
3001 + stream->audio_num_channels = runtime->channels;
3002 + if(stream->audio_num_channels == 1){
3003 + stream->dma_num_channels = 1;
3004 + }
3005 + else{
3006 + stream->dma_num_channels = runtime->channels / 2;
3007 + }
3008 +
3009 + stream->audio_channels_flag = CHANNEL_FRONT;
3010 + if(stream->dma_num_channels == 2)
3011 + stream->audio_channels_flag |= CHANNEL_REAR;
3012 + if(stream->dma_num_channels == 3)
3013 + stream->audio_channels_flag |= CHANNEL_REAR | CHANNEL_CENTER_LFE;
3014 +
3015 + stream->dmasize = runtime->dma_bytes;
3016 + stream->nbfrags = runtime->periods;
3017 + stream->fragsize = frames_to_bytes (runtime, runtime->period_size);
3018 + stream->bytecount = 0;
3019 +
3020 + if( !state->codec_set_by_capture ){
3021 + state->codec_set_by_playback = 1;
3022 +
3023 + if( stream->audio_rate != runtime->rate ){
3024 + ep93xx_set_samplerate( runtime->rate,0 );
3025 + }
3026 + //if( stream->audio_format != runtime->format ){
3027 + // snd_ep93xx_i2s_init((stream->audio_stream_bitwidth == 24));
3028 + //}
3029 + }
3030 + else{
3031 + audio_stream_t *s = state->input_stream;
3032 + if( runtime->format != s->audio_format)
3033 + return -1;
3034 + if( runtime->rate != s->audio_rate )
3035 + return -1;
3036 + }
3037 +
3038 + stream->audio_format = runtime->format ;
3039 + ep93xx_set_hw_format(stream->audio_format,stream->audio_num_channels);
3040 +
3041 +
3042 + stream->audio_rate = runtime->rate;
3043 + audio_set_format( stream, runtime->format );
3044 + snd_ep93xx_dma2usr_ratio( stream,state->bCompactMode );
3045 +
3046 + if( snd_ep93xx_allocate_buffers( substream, stream ) != 0 ){
3047 + snd_ep93xx_deallocate_buffers( substream, stream );
3048 + return -1;
3049 + }
3050 +
3051 + ep93xx_audio_enable(1);
3052 +
3053 + DPRINTK("snd_ep93xx_pcm_prepare_playback - exit\n");
3054 + return 0;
3055 +}
3056 +
3057 +static int snd_ep93xx_pcm_prepare_capture( struct snd_pcm_substream *substream)
3058 +{
3059 + audio_state_t *state = (audio_state_t *) substream->private_data;
3060 + struct snd_pcm_runtime *runtime = substream->runtime;
3061 + audio_stream_t *stream = state->input_stream;
3062 +
3063 + ep93xx_audio_disable(0);
3064 + ep93xx_ac97_pcm_startup(substream);
3065 +
3066 + snd_ep93xx_deallocate_buffers(substream,stream);
3067 +
3068 + //if(runtime->channels % 2 != 0)
3069 + //return -1;
3070 +
3071 + DPRINTK("snd_ep93xx_pcm_prepare_capture - enter\n");
3072 +
3073 +// printk("The runtime item : \n");
3074 +// printk("runtime->dma_addr = 0x%x\n", runtime->dma_addr);
3075 +// printk("runtime->dma_area = 0x%x\n", runtime->dma_area);
3076 +// printk("runtime->dma_bytes = %d\n", runtime->dma_bytes);
3077 +// printk("runtime->frame_bits = %d\n", runtime->frame_bits);
3078 +// printk("runtime->buffer_size = %d\n", runtime->buffer_size);
3079 +// printk("runtime->period_size = %d\n", runtime->period_size);
3080 +// printk("runtime->periods = %d\n", runtime->periods);
3081 +// printk("runtime->rate = %d\n", runtime->rate);
3082 +// printk("runtime->format = %d\n", runtime->format);
3083 +// printk("runtime->channels = %d\n", runtime->channels);
3084 +
3085 + /* set requestd format when available */
3086 + stream->audio_num_channels = runtime->channels;
3087 + if(stream->audio_num_channels == 1){
3088 + stream->dma_num_channels = 1;
3089 + }
3090 + else{
3091 + stream->dma_num_channels = runtime->channels / 2;
3092 + }
3093 +
3094 + stream->audio_channels_flag = CHANNEL_FRONT;
3095 + if(stream->dma_num_channels == 2)
3096 + stream->audio_channels_flag |= CHANNEL_REAR;
3097 + if(stream->dma_num_channels == 3)
3098 + stream->audio_channels_flag |= CHANNEL_REAR | CHANNEL_CENTER_LFE;
3099 +
3100 + stream->dmasize = runtime->dma_bytes;
3101 + stream->nbfrags = runtime->periods;
3102 + stream->fragsize = frames_to_bytes (runtime, runtime->period_size);
3103 + stream->bytecount = 0;
3104 +
3105 + if( !state->codec_set_by_playback ){
3106 + state->codec_set_by_capture = 1;
3107 +
3108 + /*rate*/
3109 + if( stream->audio_rate != runtime->rate ){
3110 + ep93xx_set_samplerate( runtime->rate,1 );
3111 + }
3112 +
3113 + /*mixer*/
3114 + ep93xx_set_recsource(SOUND_MASK_MIC|SOUND_MASK_LINE1 | SOUND_MASK_LINE);
3115 + poke( AC97_1C_RECORD_GAIN, 0);
3116 +
3117 + /*format*/
3118 + //if( stream->audio_format != runtime->format ){
3119 + // snd_ep93xx_i2s_init((stream->audio_stream_bitwidth == 24));
3120 + //}
3121 + }
3122 + else{
3123 + audio_stream_t *s = state->output_stream;
3124 + if( runtime->format != s->audio_format)
3125 + return -1;
3126 + if( runtime->rate != s->audio_rate )
3127 + return -1;
3128 + }
3129 +
3130 + stream->audio_format = runtime->format ;
3131 + ep93xx_set_hw_format(stream->audio_format,stream->audio_num_channels);
3132 +
3133 +
3134 + stream->audio_rate = runtime->rate;
3135 + audio_set_format( stream, runtime->format );
3136 + snd_ep93xx_dma2usr_ratio( stream,state->bCompactMode );
3137 +
3138 + if( snd_ep93xx_allocate_buffers( substream, stream ) != 0 ){
3139 + snd_ep93xx_deallocate_buffers( substream, stream );
3140 + return -1;
3141 + }
3142 +
3143 + ep93xx_audio_enable(0);
3144 +
3145 + DPRINTK("snd_ep93xx_pcm_prepare_capture - exit\n");
3146 + return 0;
3147 +}
3148 +/*
3149 + *start/stop/pause dma translate
3150 + */
3151 +static int snd_ep93xx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
3152 +{
3153 + audio_state_t *state = (audio_state_t *)substream->private_data;
3154 + audio_stream_t *stream = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
3155 + state->output_stream:state->input_stream;
3156 + audio_buf_t *buf;
3157 + audio_channel_t *dma_channel;
3158 + int i,count,ret = 0;
3159 + unsigned long flags;
3160 +
3161 + DPRINTK("snd_ep93xx_pcm_triger %d - enter \n",cmd);
3162 +
3163 + switch (cmd){
3164 +
3165 + case SNDRV_PCM_TRIGGER_START:
3166 +
3167 + snd_ep93xx_dma_config( substream );
3168 +
3169 + stream->stopped = 0;
3170 +
3171 + if( !stream->active && !stream->stopped ){
3172 + stream->active = 1;
3173 + snd_ep93xx_dma_start( state, stream );
3174 + }
3175 +
3176 + local_irq_save(flags);
3177 +
3178 + for (i = 0; i < stream->dma_num_channels; i++){
3179 + dma_channel = &stream->dma_channels[i];
3180 +
3181 + for(count = 0 ;count < dma_channel->audio_buff_count; count++){
3182 +
3183 + buf = &dma_channel->audio_buffers[count];
3184 + ep93xx_dma_add_buffer( stream->dmahandles[i],
3185 + (unsigned int)buf->dma_addr,
3186 + 0,
3187 + buf->bytes,
3188 + 0,
3189 + (unsigned int) buf );
3190 + }
3191 + }
3192 +
3193 + local_irq_restore(flags);
3194 + break;
3195 +
3196 + case SNDRV_PCM_TRIGGER_STOP:
3197 + stream->stopped = 1;
3198 + snd_ep93xx_dma_pause( state, stream );
3199 + snd_ep93xx_dma_flush( state, stream );
3200 + snd_ep93xx_dma_free( substream );
3201 + break;
3202 +
3203 + case SNDRV_PCM_TRIGGER_SUSPEND:
3204 + break;
3205 + case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
3206 + break;
3207 + case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
3208 + break;
3209 +
3210 + default:
3211 + ret = -EINVAL;
3212 + }
3213 + DPRINTK("snd_ep93xx_pcm_triger %d - exit \n",cmd);
3214 + return ret;
3215 +}
3216 +
3217 +static snd_pcm_uframes_t snd_ep93xx_pcm_pointer_playback(struct snd_pcm_substream *substream)
3218 +{
3219 + audio_state_t *state = (audio_state_t *)(substream->private_data);
3220 + struct snd_pcm_runtime *runtime = substream->runtime;
3221 + audio_stream_t *stream = state->output_stream;
3222 + snd_pcm_uframes_t pointer = 0;
3223 +
3224 + pointer = bytes_to_frames( runtime,stream->bytecount );
3225 +
3226 + if (pointer >= runtime->buffer_size){
3227 + pointer = 0;
3228 + stream->bytecount = 0;
3229 + }
3230 +
3231 + DPRINTK("snd_ep93xx_pcm_pointer_playback - exit\n");
3232 + return pointer;
3233 +}
3234 +
3235 +static snd_pcm_uframes_t snd_ep93xx_pcm_pointer_capture(struct snd_pcm_substream *substream)
3236 +{
3237 + audio_state_t *state = (audio_state_t *)(substream->private_data);
3238 + struct snd_pcm_runtime *runtime = substream->runtime;
3239 + audio_stream_t *stream = state->input_stream;
3240 + snd_pcm_uframes_t pointer = 0;
3241 +
3242 + pointer = bytes_to_frames( runtime,stream->bytecount );
3243 +
3244 + if (pointer >= runtime->buffer_size){
3245 + pointer = 0;
3246 + stream->bytecount = 0;
3247 + }
3248 +
3249 + DPRINTK("snd_ep93xx_pcm_pointer_capture - exit\n");
3250 + return pointer;
3251 +}
3252 +
3253 +static int snd_ep93xx_pcm_open(struct snd_pcm_substream *substream)
3254 +{
3255 + audio_state_t *state = substream->private_data;
3256 + struct snd_pcm_runtime *runtime = substream->runtime;
3257 + audio_stream_t *stream = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
3258 + state->output_stream:state->input_stream;
3259 +
3260 + DPRINTK("snd_ep93xx_pcm_open - enter\n");
3261 +
3262 + down(&state->sem);
3263 +
3264 + runtime->hw = ep93xx_ac97_pcm_hardware;
3265 +
3266 + stream->dma_num_channels = AUDIO_DEFAULT_DMACHANNELS;
3267 + stream->dma_channels = NULL;
3268 + stream->audio_rate = 0;
3269 + stream->audio_stream_bitwidth = 0;
3270 +
3271 + up(&state->sem);
3272 +
3273 + DPRINTK("snd_ep93xx_pcm_open - exit\n");
3274 + return 0;
3275 +}
3276 +
3277 +/*
3278 + *free the HW dma channel
3279 + *free the HW dma buffer
3280 + *free the Hw dma decrotion using function :kfree
3281 + */
3282 +static int snd_ep93xx_pcm_close(struct snd_pcm_substream *substream)
3283 +{
3284 + audio_state_t *state = (audio_state_t *)(substream->private_data);
3285 +
3286 + DPRINTK("snd_ep93xx_pcm_close - enter\n");
3287 +
3288 + snd_ep93xx_release(substream);
3289 +
3290 + if(substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
3291 + state->codec_set_by_playback = 0;
3292 + else
3293 + state->codec_set_by_capture = 0;
3294 +
3295 + DPRINTK("snd_ep93xx_pcm_close - exit\n");
3296 + return 0;
3297 +}
3298 +
3299 +static int snd_ep93xx_pcm_copy_playback(struct snd_pcm_substream * substream,int channel,
3300 + snd_pcm_uframes_t pos,void __user *src, snd_pcm_uframes_t count)
3301 +{
3302 +
3303 + audio_state_t *state = (audio_state_t *)substream->private_data;
3304 + struct snd_pcm_runtime *runtime = substream->runtime;
3305 + audio_stream_t *stream = state->output_stream ;
3306 + audio_channel_t *dma_channel;
3307 + int i;
3308 + int tocount = frames_to_bytes(runtime,count);
3309 +
3310 + for( i = 0; i < stream->dma_num_channels; i++ ){
3311 +
3312 + dma_channel = &stream->dma_channels[i];
3313 + stream->hwbuf[i] = dma_channel->area + ( frames_to_bytes(runtime,pos) * stream->dma2usr_ratio / stream->dma_num_channels );
3314 +
3315 + }
3316 +
3317 + if(copy_from_user_with_conversion(stream ,(const char*)src,(tocount * stream->dma2usr_ratio),state->bCompactMode) <=0 ){
3318 + DPRINTK(KERN_ERR "copy_from_user_with_conversion() failed\n");
3319 + return -EFAULT;
3320 + }
3321 +
3322 + DPRINTK("snd_ep93xx_pcm_copy_playback - exit\n");
3323 + return 0;
3324 +}
3325 +
3326 +
3327 +static int snd_ep93xx_pcm_copy_capture(struct snd_pcm_substream * substream,int channel,
3328 + snd_pcm_uframes_t pos,void __user *src, snd_pcm_uframes_t count)
3329 +{
3330 + audio_state_t *state = (audio_state_t *)substream->private_data;
3331 + struct snd_pcm_runtime *runtime = substream->runtime;
3332 + audio_stream_t *stream = state->input_stream ;
3333 + audio_channel_t *dma_channel;
3334 + int i;
3335 +
3336 + int tocount = frames_to_bytes(runtime,count);
3337 +
3338 + for( i = 0; i < stream->dma_num_channels; i++ ){
3339 +
3340 + dma_channel = &stream->dma_channels[i];
3341 + stream->hwbuf[i] = dma_channel->area + ( frames_to_bytes(runtime,pos) * stream->dma2usr_ratio / stream->dma_num_channels );
3342 +
3343 + }
3344 +
3345 + if(copy_to_user_with_conversion(stream,(const char*)src,tocount,state->bCompactMode) <=0 ){
3346 +
3347 + DPRINTK(KERN_ERR "copy_to_user_with_conversion() failed\n");
3348 + return -EFAULT;
3349 + }
3350 +
3351 + DPRINTK("snd_ep93xx_pcm_copy_capture - exit\n");
3352 + return 0;
3353 +}
3354 +
3355 +/*----------------------------------------------------------------------------------*/
3356 +static unsigned short ep93xx_ac97_read(struct snd_ac97 *ac97, unsigned short reg)
3357 +{
3358 + int val = -1;
3359 + /*volatile u32 *reg_addr;*/
3360 +
3361 + DPRINTK(" number of codec:%x reg=%x\n",ac97->num,reg);
3362 + val=peek(reg);
3363 + if(val==-1){
3364 + printk(KERN_ERR "%s: read error (ac97_reg=%d )val=%x\n",
3365 + __FUNCTION__, reg, val);
3366 + return 0;
3367 + }
3368 +
3369 + return val;
3370 +}
3371 +
3372 +static void ep93xx_ac97_write(struct snd_ac97 *ac97, unsigned short reg, unsigned short val)
3373 +{
3374 + /*volatile u32 *reg_addr;*/
3375 + int ret;
3376 +
3377 + DPRINTK(" number of codec:%x rge=%x val=%x\n",ac97->num,reg,val);
3378 + ret=poke(reg, val);
3379 + if(ret!=0){
3380 + printk(KERN_ERR "%s: write error (ac97_reg=%d val=%x)\n",
3381 + __FUNCTION__, reg, val);
3382 + }
3383 +
3384 +}
3385 +
3386 +static void ep93xx_ac97_reset(struct snd_ac97 *ac97)
3387 +{
3388 +
3389 + DPRINTK(" ep93xx_ac97_reset\n");
3390 + ep93xx_audio_init();
3391 +
3392 +}
3393 +
3394 +static struct snd_ac97_bus_ops ep93xx_ac97_ops = {
3395 + .read = ep93xx_ac97_read,
3396 + .write = ep93xx_ac97_write,
3397 + .reset = ep93xx_ac97_reset,
3398 +};
3399 +
3400 +static struct snd_pcm *ep93xx_ac97_pcm;
3401 +static struct snd_ac97 *ep93xx_ac97_ac97;
3402 +
3403 +static struct snd_pcm_ops snd_ep93xx_pcm_playback_ops = {
3404 + .open = snd_ep93xx_pcm_open,
3405 + .close = snd_ep93xx_pcm_close,
3406 + .ioctl = snd_pcm_lib_ioctl,
3407 + .hw_params = snd_ep93xx_pcm_hw_params,
3408 + .hw_free = snd_ep93xx_pcm_hw_free,
3409 + .prepare = snd_ep93xx_pcm_prepare_playback,
3410 + .trigger = snd_ep93xx_pcm_trigger,
3411 + .pointer = snd_ep93xx_pcm_pointer_playback,
3412 + .copy = snd_ep93xx_pcm_copy_playback,
3413 +
3414 +};
3415 +
3416 +static struct snd_pcm_ops snd_ep93xx_pcm_capture_ops = {
3417 + .open = snd_ep93xx_pcm_open,
3418 + .close = snd_ep93xx_pcm_close,
3419 + .ioctl = snd_pcm_lib_ioctl,
3420 + .hw_params = snd_ep93xx_pcm_hw_params,
3421 + .hw_free = snd_ep93xx_pcm_hw_free,
3422 + .prepare = snd_ep93xx_pcm_prepare_capture,
3423 + .trigger = snd_ep93xx_pcm_trigger,
3424 + .pointer = snd_ep93xx_pcm_pointer_capture,
3425 + .copy = snd_ep93xx_pcm_copy_capture,
3426 +};
3427 +
3428 +/*--------------------------------------------------------------------------*/
3429 +
3430 +
3431 +static int snd_ep93xx_pcm_new(struct snd_card *card, audio_state_t *state, struct snd_pcm **rpcm)
3432 +{
3433 + struct snd_pcm *pcm;
3434 + int play = state->output_stream? 1 : 0;/*SNDRV_PCM_STREAM_PLAYBACK*/
3435 + int capt = state->input_stream ? 1 : 0;/*SNDRV_PCM_STREAM_CAPTURE*/
3436 + int ret = 0;
3437 +
3438 + DPRINTK("snd_ep93xx_pcm_new - enter\n");
3439 +
3440 + /* Register the new pcm device interface */
3441 + ret = snd_pcm_new(card, "EP93xx-AC97-PCM", 0, play, capt, &pcm);
3442 +
3443 + if (ret){
3444 + DPRINTK("%s--%x:card=%x,play=%x,capt=%x,&pcm=%x\n",__FUNCTION__,ret,(int)card,play,capt,(int)pcm);
3445 + goto out;
3446 + }
3447 +
3448 + /* allocate the pcm(DMA) memory */
3449 + ret = snd_pcm_lib_preallocate_pages_for_all(pcm, /*SNDRV_DMA_TYPE_DEV,0,*/SNDRV_DMA_TYPE_CONTINUOUS,snd_dma_continuous_data(GFP_KERNEL),128*1024,128*1024);
3450 +
3451 + DPRINTK("The substream item : \n");
3452 + DPRINTK("pcm->streams[0].substream->dma_buffer.addr = 0x%x\n", pcm->streams[0].substream->dma_buffer.addr);
3453 + DPRINTK("pcm->streams[0].substream->dma_buffer.area = 0x%x\n", pcm->streams[0].substream->dma_buffer.area);
3454 + DPRINTK("pcm->streams[0].substream->dma_buffer.bytes = 0x%x\n", pcm->streams[0].substream->dma_buffer.bytes);
3455 + DPRINTK("pcm->streams[1].substream->dma_buffer.addr = 0x%x\n", pcm->streams[1].substream->dma_buffer.addr);
3456 + DPRINTK("pcm->streams[1].substream->dma_buffer.area = 0x%x\n", pcm->streams[1].substream->dma_buffer.area);
3457 + DPRINTK("pcm->streams[1].substream->dma_buffer.bytes = 0x%x\n", pcm->streams[1].substream->dma_buffer.bytes);
3458 +
3459 + pcm->private_data = state;
3460 +
3461 + /* seem to free the pcm data struct-->self dma buffer */
3462 + pcm->private_free = (void*) snd_pcm_lib_preallocate_free_for_all;
3463 +
3464 + /* alsa pcm ops setting for SNDRV_PCM_STREAM_PLAYBACK */
3465 + if (play) {
3466 + int stream = SNDRV_PCM_STREAM_PLAYBACK;
3467 + snd_pcm_set_ops(pcm, stream, &snd_ep93xx_pcm_playback_ops);
3468 + }
3469 +
3470 + /* alsa pcm ops setting for SNDRV_PCM_STREAM_CAPTURE */
3471 + if (capt) {
3472 + int stream = SNDRV_PCM_STREAM_CAPTURE;
3473 + snd_pcm_set_ops(pcm, stream, &snd_ep93xx_pcm_capture_ops);
3474 + }
3475 +
3476 + if (rpcm)
3477 + *rpcm = pcm;
3478 + DPRINTK("snd_ep93xx_pcm_new - exit\n");
3479 +out:
3480 + return ret;
3481 +}
3482 +
3483 +#ifdef CONFIG_PM
3484 +
3485 +int ep93xx_ac97_do_suspend(struct snd_card *card, unsigned int state)
3486 +{
3487 + if (card->power_state != SNDRV_CTL_POWER_D3cold) {
3488 + snd_pcm_suspend_all(ep93xx_ac97_pcm);
3489 + snd_ac97_suspend(ep93xx_ac97_ac97);
3490 + snd_power_change_state(card, SNDRV_CTL_POWER_D3cold);
3491 + }
3492 +
3493 + return 0;
3494 +}
3495 +
3496 +int ep93xx_ac97_do_resume(struct snd_card *card, unsigned int state)
3497 +{
3498 + if (card->power_state != SNDRV_CTL_POWER_D0) {
3499 +
3500 + snd_ac97_resume(ep93xx_ac97_ac97);
3501 + snd_power_change_state(card, SNDRV_CTL_POWER_D0);
3502 + }
3503 +
3504 + return 0;
3505 +}
3506 +
3507 +int ep93xx_ac97_suspend(struct platform_device *_dev, u32 state, u32 level)
3508 +{
3509 + struct snd_card *card = platform_get_drvdata(_dev);
3510 + int ret = 0;
3511 +
3512 + if (card && level == SUSPEND_DISABLE)
3513 + ret = ep93xx_ac97_do_suspend(card, SNDRV_CTL_POWER_D3cold);
3514 +
3515 + return ret;
3516 +}
3517 +
3518 +int ep93xx_ac97_resume(struct platform_device *_dev, u32 level)
3519 +{
3520 + struct snd_card *card = platform_get_drvdata(_dev);
3521 + int ret = 0;
3522 +
3523 + if (card && level == RESUME_ENABLE)
3524 + ret = ep93xx_ac97_do_resume(card, SNDRV_CTL_POWER_D0);
3525 +
3526 + return ret;
3527 +}
3528 +
3529 +#else
3530 +/*
3531 +#define ep93xx_ac97_do_suspend NULL
3532 +#define ep93xx_ac97_do_resume NULL
3533 +#define ep93xx_ac97_suspend NULL
3534 +#define ep93xx_ac97_resume NULL
3535 +*/
3536 +
3537 +int ep93xx_ac97_do_suspend(struct snd_card *card, unsigned int state)
3538 +{
3539 + return 0;
3540 +}
3541 +
3542 +int ep93xx_ac97_do_resume(struct snd_card *card, unsigned int state)
3543 +{
3544 + return 0;
3545 +}
3546 +
3547 +int ep93xx_ac97_resume(struct platform_device *_dev, u32 level)
3548 +{
3549 + struct snd_card *card = platform_get_drvdata(_dev);
3550 + int ret = 0;
3551 +
3552 + //if (card && level == RESUME_ENABLE)
3553 + ret = ep93xx_ac97_do_resume(card, SNDRV_CTL_POWER_D0);
3554 +
3555 + return ret;
3556 +}
3557 +
3558 +int ep93xx_ac97_suspend(struct platform_device *_dev, u32 state, u32 level)
3559 +{
3560 + struct snd_card *card = platform_get_drvdata(_dev);
3561 + int ret = 0;
3562 +
3563 + //if (card && level == SUSPEND_DISABLE)
3564 + ret = ep93xx_ac97_do_suspend(card, SNDRV_CTL_POWER_D3cold);
3565 +
3566 + return ret;
3567 +}
3568 +
3569 +#endif
3570 +
3571 +
3572 +
3573 +/* module init & exit */
3574 +static int __devinit ep93xx_ac97_probe(struct platform_device *dev)
3575 +{
3576 + struct snd_card *card;
3577 + struct snd_ac97_bus *ac97_bus;
3578 + struct snd_ac97_template ac97_template;
3579 + int err = -ENOMEM;
3580 + struct resource *res = NULL;
3581 +
3582 + DPRINTK("snd_ep93xx_probe - enter\n");
3583 +
3584 + /* Enable audio early on, give the DAC time to come up. */
3585 + res = platform_get_resource( dev, IORESOURCE_MEM, 0);
3586 +
3587 + if(!res) {
3588 + printk("error : platform_get_resource \n");
3589 + return -ENODEV;
3590 + }
3591 +
3592 + if (!request_mem_region(res->start,res->end - res->start + 1, "snd-ac97-cs4202" )){
3593 + printk("error : request_mem_region\n");
3594 + return -EBUSY;
3595 + }
3596 +
3597 + /*enable ac97 codec*/
3598 + ep93xx_audio_init();
3599 +
3600 + /* register the soundcard */
3601 + card = snd_card_new(SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
3602 + THIS_MODULE, 0);
3603 + if (!card){
3604 + printk("AC97: snd_card_new error\n");
3605 + goto error;
3606 + }
3607 +
3608 + card->dev = &dev->dev;
3609 + /*regist the new pcm device*/
3610 + err = snd_ep93xx_pcm_new(card, &audio_state, &ep93xx_ac97_pcm);
3611 + if (err){
3612 + printk("AC97: ep93xx_ac97_pcm_new error\n");
3613 + goto error;
3614 + }
3615 + if (card == NULL) {
3616 + DPRINTK(KERN_ERR "snd_card_new() failed\n");
3617 + goto error;
3618 + }
3619 +
3620 + /*driver name*/
3621 + strcpy(card->driver, "CS4202A");
3622 + strcpy(card->shortname, "Cirrus Logic AC97 Audio ");
3623 + strcpy(card->longname, "Cirrus Logic AC97 Audio with CS4202A");
3624 +
3625 + /*regist the new ac97 device*/
3626 + err = snd_ac97_bus(card, 0, &ep93xx_ac97_ops, NULL, &ac97_bus);
3627 + if (err){
3628 + printk("AC97: snd_ac97_bus error\n");
3629 + goto error;
3630 + }
3631 +
3632 + memset(&ac97_template, 0, sizeof(ac97_template));
3633 + err = snd_ac97_mixer(ac97_bus, &ac97_template, &ep93xx_ac97_ac97);
3634 + if (err){
3635 + printk("AC97: snd_ac97_mixer error\n");
3636 + goto error;
3637 + }
3638 +
3639 + /**/
3640 + ep93xx_audio_init();
3641 + /*setting the card device callback*/
3642 + //err = snd_card_set_pm_callback(card, ep93xx_ac97_do_suspend,ep93xx_ac97_do_resume, (void*)NULL);
3643 + //if(err != 0){
3644 + // printk("snd_card_set_pm_callback error\n");
3645 + //}
3646 +
3647 + /*regist the new CARD device*/
3648 + err = snd_card_register(card);
3649 + if (err == 0) {
3650 + printk( KERN_INFO "Cirrus Logic ep93xx ac97 audio initialized\n" );
3651 + platform_set_drvdata(dev,card);
3652 + DPRINTK("snd_ep93xx_probe - exit\n");
3653 + return 0;
3654 + }
3655 +
3656 +error:
3657 + snd_card_free(card);
3658 + printk("snd_ep93xx_probe - error\n");
3659 + return err;
3660 +
3661 +return 0;
3662 +}
3663 +
3664 +static int __devexit ep93xx_ac97_remove(struct platform_device *dev)
3665 +{
3666 + struct resource *res;
3667 + struct snd_card *card = platform_get_drvdata(dev);
3668 +
3669 + res = platform_get_resource( dev, IORESOURCE_MEM, 0);
3670 + release_mem_region(res->start, res->end - res->start + 1);
3671 +
3672 + DPRINTK("snd_ep93xx_ac97_remove - enter\n");
3673 +
3674 + if (card) {
3675 + snd_card_free(card);
3676 + platform_set_drvdata(dev, NULL);
3677 + }
3678 + DPRINTK("snd_ep93xx_remove - exit\n");
3679 +
3680 +return 0;
3681 +}
3682 +
3683 +
3684 +static struct platform_driver ep93xx_ac97_driver = {
3685 + .probe = ep93xx_ac97_probe,
3686 + .remove = __devexit_p (ep93xx_ac97_remove),
3687 + .suspend = ep93xx_ac97_suspend,
3688 + .resume = ep93xx_ac97_resume,
3689 + .driver = {
3690 + .name = "ep93xx-ac97",
3691 + },
3692 +};
3693 +
3694 +
3695 +static int __init ep93xx_ac97_init(void)
3696 +{
3697 + int ret;
3698 +
3699 + DPRINTK(KERN_INFO "%s: version %s\n", DRIVER_DESC, DRIVER_VERSION);
3700 + DPRINTK("snd_ep93xx_AC97_init - enter\n");
3701 + ret = platform_driver_register(&ep93xx_ac97_driver);
3702 + DPRINTK("snd_ep93xx_AC97_init - exit\n");
3703 + return ret;
3704 +}
3705 +
3706 +static void __exit ep93xx_ac97_exit(void)
3707 +{
3708 + DPRINTK("ep93xx_ac97_exit - enter\n");
3709 + return platform_driver_unregister(&ep93xx_ac97_driver);
3710 +}
3711 +
3712 +module_init(ep93xx_ac97_init);
3713 +module_exit(ep93xx_ac97_exit);
3714 +
3715 +MODULE_DESCRIPTION("Cirrus Logic audio module");
3716 +MODULE_LICENSE("GPL");
3717 --- /dev/null
3718 +++ b/sound/arm/ep93xx-ac97.h
3719 @@ -0,0 +1,89 @@
3720 +/*
3721 + * linux/sound/arm/ep93xx-ac97.h -- ALSA PCM interface for the edb93xx ac97 audio
3722 + *
3723 + * Author: Fred Wei
3724 + * Created: July 19, 2005
3725 + * Copyright: Cirrus Logic, Inc.
3726 + *
3727 + * This program is free software; you can redistribute it and/or modify
3728 + * it under the terms of the GNU General Public License version 2 as
3729 + * published by the Free Software Foundation.
3730 + */
3731 +
3732 +#define EP93XX_DEFAULT_NUM_CHANNELS 2
3733 +#define EP93XX_DEFAULT_FORMAT SNDRV_PCM_FORMAT_S16_LE
3734 +#define EP93XX_DEFAULT_BIT_WIDTH 16
3735 +#define MAX_DEVICE_NAME 20
3736 +
3737 +/*
3738 + * Buffer Management
3739 + */
3740 +
3741 +typedef struct {
3742 +
3743 + unsigned char *area; /* virtual pointer */
3744 + dma_addr_t dma_addr; /* physical address */
3745 + size_t bytes;
3746 + size_t reportedbytes; /* buffer size */
3747 + int sent; /* indicates that dma has the buf */
3748 + char *start; /* points to actual buffer */
3749 +
3750 +} audio_buf_t;
3751 +
3752 +
3753 +typedef struct {
3754 +
3755 + unsigned char *area; /* virtual pointer */
3756 + dma_addr_t addr; /* physical address */
3757 + size_t bytes; /* buffer size in bytes */
3758 + unsigned char *buff_pos; /* virtual pointer */
3759 + audio_buf_t *audio_buffers; /* array of audio buffer structures */
3760 + int audio_buff_count;
3761 +
3762 +
3763 +} audio_channel_t;
3764 +
3765 +typedef struct audio_stream_s {
3766 +
3767 + /* dma stuff */
3768 + int dmahandles[3]; /* handles for dma driver instances */
3769 + char devicename[MAX_DEVICE_NAME]; /* string - name of device */
3770 + int dma_num_channels; /* 1, 2, or 3 DMA channels */
3771 + audio_channel_t *dma_channels;
3772 + u_int nbfrags; /* nbr of fragments i.e. buffers */
3773 + u_int fragsize; /* fragment i.e. buffer size */
3774 + u_int dmasize;
3775 + int bytecount; /* nbr of processed bytes */
3776 + int externedbytecount; /* nbr of processed bytes */
3777 + volatile int active; /* actually in progress */
3778 + volatile int stopped; /* might be active but stopped */
3779 + char *hwbuf[3];
3780 + long audio_rate;
3781 + long audio_num_channels; /* Range: 1 to 6 */
3782 + int audio_channels_flag;
3783 + long audio_format;
3784 + long audio_stream_bitwidth; /* Range: 8, 16, 24 */
3785 + int dma2usr_ratio;
3786 +
3787 +} audio_stream_t;
3788 +
3789 +
3790 +/*
3791 + * State structure for one instance
3792 + */
3793 +typedef struct {
3794 +
3795 + audio_stream_t *output_stream;
3796 + audio_stream_t *input_stream;
3797 + ep93xx_dma_dev_t output_dma[3];
3798 + ep93xx_dma_dev_t input_dma[3];
3799 + char *output_id[3];
3800 + char *input_id[3];
3801 + struct semaphore sem; /* to protect against races in attach() */
3802 + int codec_set_by_playback;
3803 + int codec_set_by_capture;
3804 + int DAC_bit_width; /* 16, 20, 24 bits */
3805 + int bCompactMode; /* set if 32bits = a stereo sample */
3806 +
3807 +} audio_state_t;
3808 +
Personal OpenWRT clone
This page took 0.191489 seconds and 5 git commands to generate.