You can import this changeset into BK by piping this whole message to: '| bk receive [path to repository]' or apply the patch as usual. =================================================================== ChangeSet@1.605.2.20, 2002-09-26 14:07:49+02:00, perex@pnote.perex-int.cz ALSA update 2002/08/01 : - CS46xx - added support for the new DSP image - S/PDIF and dual-codec support - sequencer - fixed deadlock at snd_seq_timer_start/stop include/sound/cs46xx.h | 46 include/sound/cs46xx_dsp_scb_types.h | 936 ++++++++++++++++++ include/sound/cs46xx_dsp_spos.h | 183 +++ include/sound/cs46xx_dsp_task_types.h | 215 ++++ include/sound/sndmagic.h | 1 include/sound/version.h | 2 sound/core/seq/seq_queue.c | 26 sound/core/seq/seq_timer.c | 32 sound/core/seq/seq_timer.h | 6 sound/isa/wavefront/wavefront.c | 4 sound/pci/Config.help | 10 sound/pci/Config.in | 4 sound/pci/cs46xx/Makefile | 3 sound/pci/cs46xx/cs46xx.c | 8 sound/pci/cs46xx/cs46xx_image.h | 11 sound/pci/cs46xx/cs46xx_lib.c | 811 ++++++++++++--- sound/pci/cs46xx/cs46xx_lib.h | 191 +++ sound/pci/cs46xx/dsp_spos.c | 1740 ++++++++++++++++++++++++++++++++++ sound/pci/cs46xx/dsp_spos.h | 150 ++ sound/pci/cs46xx/dsp_spos_scb_lib.c | 1383 +++++++++++++++++++++++++++ sound/pci/cs46xx/imgs/cwc4630.h | 320 ++++++ sound/pci/cs46xx/imgs/cwcasync.h | 176 +++ sound/pci/cs46xx/imgs/cwcbinhack.h | 48 sound/pci/cs46xx/imgs/cwcemb80.h | 1607 +++++++++++++++++++++++++++++++ sound/pci/cs46xx/imgs/cwcsnoop.h | 46 25 files changed, 7729 insertions(+), 230 deletions(-) diff -Nru a/include/sound/cs46xx.h b/include/sound/cs46xx.h --- a/include/sound/cs46xx.h Sun Sep 29 20:23:44 2002 +++ b/include/sound/cs46xx.h Sun Sep 29 20:23:44 2002 @@ -26,6 +26,7 @@ #include "pcm.h" #include "rawmidi.h" #include "ac97_codec.h" +#include "cs46xx_dsp_spos.h" #ifndef PCI_VENDOR_ID_CIRRUS #define PCI_VENDOR_ID_CIRRUS 0x1013 @@ -936,9 +937,10 @@ #define SERACC_CHIP_TYPE_MASK 0x00000001 #define SERACC_CHIP_TYPE_1_03 0x00000000 #define SERACC_CHIP_TYPE_2_0 0x00000001 -#define SERACC_TWO_CODECS 0x00000002 -#define SERACC_MDM 0x00000004 -#define SERACC_HSP 0x00000008 +#define SERACC_TWO_CODECS 0x00000002 +#define SERACC_MDM 0x00000004 +#define SERACC_HSP 0x00000008 +#define SERACC_ODT 0x00000010 /* only CS4630 */ #endif /* @@ -1626,12 +1628,38 @@ #define SAVE_REG_MAX 0x10 #define POWER_DOWN_ALL 0x7f0f +/* maxinum number of AC97 codecs connected, AC97 2.0 defined 4 */ +#define MAX_NR_AC97 4 +#define CS46XX_PRIMARY_CODEC_INDEX 0 +#define CS46XX_SECONDARY_CODEC_INDEX 1 +#define CS46XX_SECONDARY_CODEC_OFFSET 0x80 + /* * */ typedef struct _snd_cs46xx cs46xx_t; +typedef struct _snd_cs46xx_pcm_t { + unsigned char *hw_area; + dma_addr_t hw_addr; /* PCI bus address, not accessible */ + unsigned long hw_size; + + unsigned int ctl; + unsigned int shift; /* Shift count to trasform frames in bytes */ + unsigned int sw_bufsize; + unsigned int sw_data; /* Offset to next dst (or src) in sw ring buffer */ + unsigned int sw_io; + int sw_ready; /* Bytes ready to be transferred to/from hw */ + unsigned int hw_data; /* Offset to next dst (or src) in hw ring buffer */ + unsigned int hw_io; /* Ring buffer hw pointer */ + int hw_ready; /* Bytes ready for play (or captured) in hw ring buffer */ + size_t appl_ptr; /* Last seen appl_ptr */ + snd_pcm_substream_t *substream; + + pcm_channel_descriptor_t * pcm_channel; +} cs46xx_pcm_t; + typedef struct { char name[24]; unsigned long base; @@ -1674,10 +1702,11 @@ int hw_ready; /* Bytes ready for play (or captured) in hw ring buffer */ size_t appl_ptr; /* Last seen appl_ptr */ snd_pcm_substream_t *substream; - } play, capt; + } capt; - ac97_t *ac97; + int nr_ac97_codecs; + ac97_t *ac97[MAX_NR_AC97]; struct pci_dev *pci; snd_card_t *card; @@ -1703,6 +1732,13 @@ #ifdef CONFIG_PM struct pm_dev *pm_dev; +#endif + +#ifdef CONFIG_SND_CS46XX_NEW_DSP + dsp_spos_instance_t * dsp_spos_instance; +#else /* for compatibility */ + cs46xx_pcm_t *playback_pcm; + unsigned int play_ctl; #endif }; diff -Nru a/include/sound/cs46xx_dsp_scb_types.h b/include/sound/cs46xx_dsp_scb_types.h --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/include/sound/cs46xx_dsp_scb_types.h Sun Sep 29 20:23:44 2002 @@ -0,0 +1,936 @@ +/* + * The driver for the Cirrus Logic's Sound Fusion CS46XX based soundcards + * Copyright (c) by Jaroslav Kysela + * + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * NOTE: comments are copy/paste from cwcemb80.lst + * provided by Tom Woller at Cirrus (my only + * documentation about the SP OS running inside + * the DSP) + */ + +#ifndef __CS46XX_DSP_SCB_TYPES_H__ +#define __CS46XX_DSP_SCB_TYPES_H__ + +/* This structs are used internally by the SP */ + +typedef struct _basic_dma_req_t { + /* DMA Requestor Word 0 (DCW) fields: + + 31 [30-28]27 [26:24] 23 22 21 20 [19:18] [17:16] 15 14 13 12 11 10 9 8 7 6 [5:0] + _______________________________________________________________________________________ + |S| SBT |D| DBT |wb|wb| | | LS | SS |Opt|Do|SSG|DSG| | | | | | | Dword | + |H|_____ |H|_________|S_|D |__|__|______|_______|___|ne|__ |__ |__|__|_|_|_|_|_Count -1| + */ + u32 dcw; /* DMA Control Word */ + u32 dmw; /* DMA Mode Word */ + u32 saw; /* Source Address Word */ + u32 daw; /* Destination Address Word */ +} basic_dma_req_t; + +typedef struct _scatter_gather_ext_t { + u32 npaw; /* Next-Page Address Word */ + + /* DMA Requestor Word 5 (NPCW) fields: + + 31-30 29 28 [27:16] [15:12] [11:3] [2:0] + _________________________________________________________________________________________ + |SV |LE|SE| Sample-end byte offset | | Page-map entry offset for next | | + |page|__|__| ___________________________|_________|__page, if !sample-end___________|____| + */ + u32 npcw; /* Next-Page Control Word */ + u32 lbaw; /* Loop-Begin Address Word */ + u32 nplbaw; /* Next-Page after Loop-Begin Address Word */ + u32 sgaw; /* Scatter/Gather Address Word */ +} scatter_gather_ext_t; + +typedef struct _volume_control_t { + u16 rightTarg; /* Target volume for left & right channels */ + u16 leftTarg; + + u16 rightVol; /* Current left & right channel volumes */ + u16 leftVol; +} volume_control_t; + +/* Generic stream control block (SCB) structure definition */ +typedef struct _generic_scb_t { + /* For streaming I/O, the DSP should never alter any words in the DMA + requestor or the scatter/gather extension. Only ad hoc DMA request + streams are free to alter the requestor (currently only occur in the + DOS-based MIDI controller and in debugger-inserted code). + + If an SCB does not have any associated DMA requestor, these 9 ints + may be freed for use by other tasks, but the pointer to the SCB must + still be such that the insOrd:nextSCB appear at offset 9 from the + SCB pointer. + + Basic (non scatter/gather) DMA requestor (4 ints) + */ + + /* Initialized by the host, only modified by DMA + R/O for the DSP task */ + basic_dma_req_t basic_req; /* Optional */ + + /* Scatter/gather DMA requestor extension (5 ints) + Initialized by the host, only modified by DMA + DSP task never needs to even read these. + */ + scatter_gather_ext_t sg_ext; /* Optional */ + + /* Sublist pointer & next stream control block (SCB) link. + Initialized & modified by the host R/O for the DSP task + */ + u16 next_scb; /* REQUIRED */ + u16 sub_list_ptr; /* REQUIRED */ + + + /* Pointer to this tasks parameter block & stream function pointer + Initialized by the host R/O for the DSP task */ + u16 entry_point; /* REQUIRED */ + u16 this_spb; /* REQUIRED */ + + + /* rsConfig register for stream buffer (rsDMA reg. + is loaded from basicReq.daw for incoming streams, or + basicReq.saw, for outgoing streams) + + 31 30 29 [28:24] [23:16] 15 14 13 12 11 10 9 8 7 6 5 4 [3:0] + ______________________________________________________________________________ + |DMA |D|maxDMAsize| streamNum|dir|p| | | | | | |ds |shr 1|rev Cy | mod | + |prio |_|__________|__________|___|_|__|__|__|__|_|_|___|_____|_______|_______| + 31 30 29 [28:24] [23:16] 15 14 13 12 11 10 9 8 7 6 5 4 [3:0] + + + Initialized by the host R/O for the DSP task + */ + u32 strm_rs_config; /* REQUIRED */ + // + /* On mixer input streams: indicates mixer input stream configuration + On Tees, this is copied from the stream being snooped + + Stream sample pointer & MAC-unit mode for this stream + + Initialized by the host Updated by the DSP task + */ + u32 strm_buf_ptr; /* REQUIRED */ + + /* On mixer input streams: points to next mixer input and is updated by the + mixer subroutine in the "parent" DSP task + (least-significant 16 bits are preserved, unused) + + On Tees, the pointer is copied from the stream being snooped on + initialization, and, subsequently, it is copied into the + stream being snooped. + + On wavetable/3D voices: the strmBufPtr will use all 32 bits to allow for + fractional phase accumulation + + Fractional increment per output sample in the input sample buffer + + (Not used on mixer input streams & redefined on Tees) + On wavetable/3D voices: this 32-bit word specifies the integer.fractional + increment per output sample. + */ + u32 strmPhiIncr; + + + /* Standard stereo volume control + Initialized by the host (host updates target volumes) + + Current volumes update by the DSP task + On mixer input streams: required & updated by the mixer subroutine in the + "parent" DSP task + + On Tees, both current & target volumes are copied up on initialization, + and, subsequently, the target volume is copied up while the current + volume is copied down. + + These two 32-bit words are redefined for wavetable & 3-D voices. + */ + volume_control_t vol_ctrl_t; /* Optional */ +} generic_scb_t; + + +typedef struct _spos_control_block_t { + /* WARNING: Certain items in this structure are modified by the host + Any dword that can be modified by the host, must not be + modified by the SP as the host can only do atomic dword + writes, and to do otherwise, even a read modify write, + may lead to corrupted data on the SP. + + This rule does not apply to one off boot time initialisation prior to starting the SP + */ + + + /* First element on the Hyper forground task tree */ + u16 hfg_tree_root_ptr; /* HOST */ + /* First 3 dwords are written by the host and read-only on the DSP */ + u16 hfg_stack_base; /* HOST */ + + /* Point to this data structure to enable easy access */ + u16 spos_cb_ptr; /* SP */ + u16 prev_task_tree_ptr; /* SP && HOST */ + + + /* Currently Unused */ + u16 xxinterval_timer_period; + /* Enable extension of SPOS data structure */ + u16 HFGSPB_ptr; + + + u16 xxnum_HFG_ticks_thisInterval; + /* Modified by the DSP */ + u16 xxnum_tntervals; + + + /* Set by DSP upon encountering a trap (breakpoint) or a spurious + interrupt. The host must clear this dword after reading it + upon receiving spInt1. */ + u16 spurious_int_flag; /* (Host & SP) Nature of the spurious interrupt */ + u16 trap_flag; /* (Host & SP) Nature of detected Trap */ + + + u16 unused2; + u16 invalid_IP_flag; /* (Host & SP ) Indicate detection of invalid instruction pointer */ + + + /* pointer to forground task tree header for use in next task search */ + u16 fg_task_tree_hdr_ptr; /* HOST */ + /* Data structure for controlling synchronous link update */ + u16 hfg_sync_update_ptr; /* HOST */ + + u16 begin_foreground_FCNT; /* SP */ + /* Place holder for holding sleep timing */ + u16 last_FCNT_before_sleep; /* SP */ + + u16 unused7; /* SP */ + u16 next_task_treePtr; /* SP */ + + u32 nused5; + + u16 active_flags; /* SP */ + /* State flags, used to assist control of execution of Hyper Forground */ + u16 HFG_flags; /* SP */ + + u16 unused9; + u16 unused8; + + /* Space for saving enough context so that we can set up enough + to save some more context. + */ + u32 rFE_save_for_invalid_IP; + u32 r32_save_for_spurious_int; + u32 r32_save_for_trap; + u32 r32_save_for_HFG; +} spos_control_block_t; + +/* SPB for MIX_TO_OSTREAM algorithm family */ +typedef struct _mix2_ostream_spb_t +{ + /* 16b.16b integer.frac approximation to the + number of 3 sample triplets to output each + frame. (approximation must be floor, to + insure that the fractional error is always + positive) + */ + long outTripletsPerFrame; + + /* 16b.16b integer.frac accumulated number of + output triplets since the start of group + */ + long accumOutTriplets; +} mix2_ostream_spb_t; + +/* SCB for Timing master algorithm */ +typedef struct _timing_master_scb_t { + /* First 12 dwords from generic_scb_t */ + basic_dma_req_t basic_req; /* Optional */ + scatter_gather_ext_t sg_ext; /* Optional */ + u16 next_scb; /* REQUIRED */ + u16 sub_list_ptr; /* REQUIRED */ + + u16 entry_point; /* REQUIRED */ + u16 this_spb; /* REQUIRED */ + + + /* Initial values are 0000:xxxx */ + u16 reserved; + u16 extra_sample_accum; + + + /* Initial values are xxxx:0000 + hi: Current CODEC output FIFO pointer + (0 to 0x0f) + lo: Flag indicating that the CODEC + FIFO is sync'd (host clears to + resynchronize the FIFO pointer + upon start/restart) + */ + u16 codec_FIFO_syncd; + u16 codec_FIFO_ptr; + + + /* Init. 8000:0005 for 44.1k + 8000:0001 for 48k + hi: Fractional sample accumulator 0.16b + lo: Number of frames remaining to be + processed in the current group of + frames + */ + u16 frac_samp_accum_qm1; + u16 TM_frms_left_in_group; + + /* Init. 0001:0005 for 44.1k + 0000:0001 for 48k + hi: Fractional sample correction factor 0.16b + to be added every frameGroupLength frames + to correct for truncation error in + nsamp_per_frm_q15 + lo: Number of frames in the group + */ + u16 frac_samp_correction_qm1; + u16 TM_frm_group_length; + + /* Init. 44.1k*65536/8k = 0x00058333 for 44.1k + 48k*65536/8k = 0x00060000 for 48k + 16b.16b integer.frac approximation to the + number of samples to output each frame. + (approximation must be floor, to insure */ + u32 nsamp_per_frm_q15; +} timing_master_scb_t; + +/* SCB for CODEC output algorithm */ +typedef struct _codec_output_scb_t { + /* First 13 dwords from generic_scb_t */ + basic_dma_req_t basic_req; /* Optional */ + scatter_gather_ext_t sg_ext; /* Optional */ + u16 next_scb; /* REQUIRED */ + u16 sub_list_ptr; /* REQUIRED */ + + u16 entry_point; /* REQUIRED */ + u16 this_spb; /* REQUIRED */ + + u32 strm_rs_config; /* REQUIRED */ + u32 strm_buf_ptr; /* REQUIRED */ + + /* NOTE: The CODEC output task reads samples from the first task on its + sublist at the stream buffer pointer (init. to lag DMA destination + address word). After the required number of samples is transferred, + the CODEC output task advances sub_list_ptr->strm_buf_ptr past the samples + consumed. + */ + + /* Init. 0000:0010 for SDout + 0060:0010 for SDout2 + 0080:0010 for SDout3 + hi: Base IO address of FIFO to which + the left-channel samples are to + be written. + lo: Displacement for the base IO + address for left-channel to obtain + the base IO address for the FIFO + to which the right-channel samples + are to be written. + */ + u16 left_chan_base_IO_addr; + u16 right_chan_IO_disp; + + + /* Init: 0x0080:0004 for non-AC-97 + Init: 0x0080:0000 for AC-97 + hi: Exponential volume change rate + for input stream + lo: Positive shift count to shift the + 16-bit input sample to obtain the + 32-bit output word + */ + u16 CO_scale_shift_count; + u16 CO_exp_vol_change_rate; + + /* Pointer to SCB at end of input chain */ + u16 reserved; + u16 last_sub_ptr; +} codec_output_scb_t; + +/* SCB for CODEC input algorithm */ +typedef struct _codec_input_scb_t { + /* First 13 dwords from generic_scb_t */ + basic_dma_req_t basic_req; /* Optional */ + scatter_gather_ext_t sg_ext; /* Optional */ + u16 next_scb; /* REQUIRED */ + u16 sub_list_ptr; /* REQUIRED */ + + u16 entry_point; /* REQUIRED */ + u16 this_spb; /* REQUIRED */ + + u32 strm_rs_config; /* REQUIRED */ + u32 strm_buf_ptr; /* REQUIRED */ + + /* NOTE: The CODEC input task reads samples from the hardware FIFO + sublist at the DMA source address word (sub_list_ptr->basic_req.saw). + After the required number of samples is transferred, the CODEC + output task advances sub_list_ptr->basic_req.saw past the samples + consumed. SPuD must initialize the sub_list_ptr->basic_req.saw + to point half-way around from the initial sub_list_ptr->strm_nuf_ptr + to allow for lag/lead. + */ + + /* Init. 0000:0010 for SDout + 0060:0010 for SDout2 + 0080:0010 for SDout3 + hi: Base IO address of FIFO to which + the left-channel samples are to + be written. + lo: Displacement for the base IO + address for left-channel to obtain + the base IO address for the FIFO + to which the right-channel samples + are to be written. + */ + u16 rightChanINdisp; + u16 left_chan_base_IN_addr; + + /* Init. ?:fffc + lo: Negative shift count to shift the + 32-bit input dword to obtain the + 16-bit sample msb-aligned (count + is negative to shift left) + */ + u16 scaleShiftCount; + u16 reserver1; + + u32 reserved2; +} codec_input_scb_t; + + +typedef struct _pcm_serial_input_scb_t { + /* First 13 dwords from generic_scb_t */ + basic_dma_req_t basic_req; /* Optional */ + scatter_gather_ext_t sg_ext; /* Optional */ + u16 next_scb; /* REQUIRED */ + u16 sub_list_ptr; /* REQUIRED */ + + u16 entry_point; /* REQUIRED */ + u16 this_spb; /* REQUIRED */ + + u32 strm_buf_ptr; /* REQUIRED */ + u32 strm_rs_config; /* REQUIRED */ + + /* Init. Ptr to CODEC input SCB + hi: Pointer to the SCB containing the + input buffer to which CODEC input + samples are written + lo: Flag indicating the link to the CODEC + input task is to be initialized + */ + u16 init_codec_input_link; + u16 codec_input_buf_scb; + + /* Initialized by the host (host updates target volumes) */ + volume_control_t psi_vol_ctrl; + +} pcm_serial_input_scb_t; + +typedef struct _src_task_scb_t { + u16 frames_left_in_gof; + u16 gofs_left_in_sec; + + u16 const2_thirds; + u16 num_extra_tnput_samples; + + u16 cor_per_gof; + u16 correction_per_sec; + + u16 output_buf_producer_ptr; + u16 junk_DMA_MID; + + u16 gof_length; + u16 gofs_per_sec; + + u32 input_buf_strm_config; + + u16 reserved_for_SRC_use; + u16 input_buf_consumer_ptr; + + u32 accum_phi; + + u16 exp_src_vol_change_rate; + u16 input_buf_producer_ptr; + + u16 src_next_scb; + u16 src_sub_list_ptr; + + u16 src_entry_point; + u16 src_this_sbp; + + u32 src_strm_rs_config; + u32 src_strm_buf_ptr; + + u32 phiIncr6int_26frac; + + volume_control_t src_vol_ctrl; +} src_task_scb_t; + +typedef struct _decimate_by_pow2_scb_t { + /* decimationFactor = 2, 4, or 8 (larger factors waste too much memory + when compared to cascading decimators) + */ + u16 dec2_coef_base_ptr; + u16 dec2_coef_increment; + /* coefIncrement = 128 / decimationFactor (for our ROM filter) + coefBasePtr = 0x8000 (for our ROM filter) + */ + + u16 dec2_in_samples_per_out_triplet; + u16 dec2_extra_in_samples; + /* extraInSamples: # of accumulated, unused input samples (init. to 0) + inSamplesPerOutTriplet = 3 * decimationFactor + */ + + u16 dec2_const2_thirds; + u16 dec2_half_num_taps_mp5; + /* halfNumTapsM5: (1/2 number of taps in decimation filter) minus 5 + const2thirds: constant 2/3 in 16Q0 format (sign.15) + */ + + u16 dec2_output_buf_producer_ptr; + u16 dec2_junkdma_mid; + + u32 dec2_reserved2; + + u32 dec2_input_nuf_strm_config; + /* inputBufStrmConfig: rsConfig for the input buffer to the decimator + (buffer size = decimationFactor * 32 dwords) + */ + + u16 dec2_phi_incr; + u16 dec2_input_buf_consumer_ptr; + /* inputBufConsumerPtr: Input buffer read pointer (into SRC filter) + phiIncr = decimationFactor * 4 + */ + + u32 dec2_reserved3; + + u16 dec2_exp_vol_change_rate; + u16 dec2_input_buf_producer_ptr; + /* inputBufProducerPtr: Input buffer write pointer + expVolChangeRate: Exponential volume change rate for possible + future mixer on input streams + */ + + u16 dec2_next_scb; + u16 dec2_sub_list_ptr; + + u16 dec2_entry_point; + u16 dec2_this_spb; + + u32 dec2_strm_rs_config; + u32 dec2_strm_buf_ptr; + + u32 dec2_reserved4; + + volume_control_t dec2_vol_ctrl; /* Not used! */ +} decimate_by_pow2_scb_t; + +typedef struct _vari_decimate_scb_t { + u16 vdec_frames_left_in_gof; + u16 vdec_gofs_left_in_sec; + + u16 vdec_const2_thirds; + u16 vdec_extra_in_samples; + /* extraInSamples: # of accumulated, unused input samples (init. to 0) + const2thirds: constant 2/3 in 16Q0 format (sign.15) */ + + u16 vdec_cor_per_gof; + u16 vdec_correction_per_sec; + + u16 vdec_output_buf_producer_ptr; + u16 vdec_input_buf_consumer_ptr; + /* inputBufConsumerPtr: Input buffer read pointer (into SRC filter) */ + + u16 vdec_gof_length; + u16 vdec_gofs_per_sec; + + u32 vdec_input_buf_strm_config; + /* inputBufStrmConfig: rsConfig for the input buffer to the decimator + (buffer size = 64 dwords) */ + long vdec_coef_increment; + /* coefIncrement = - 128.0 / decimationFactor (as a 32Q15 number) */ + + long vdec_accumphi; + /* accumPhi: accumulated fractional phase increment (6.26) */ + + u16 vdec_exp_vol_change_rate; + u16 vdec_input_buf_producer_ptr; + /* inputBufProducerPtr: Input buffer write pointer + expVolChangeRate: Exponential volume change rate for possible + future mixer on input streams */ + + u16 vdec_next_scb; + u16 vdec_sub_list_ptr; + + u16 vdec_entry_point; + u16 vdec_this_spb; + + u32 vdec_strm_rs_config; + u32 vdec_strm_buf_ptr; + + u32 vdec_phi_incr_6int_26frac; + + volume_control_t vdec_vol_ctrl; +} vari_decimate_scb_t; + + +/* SCB for MIX_TO_OSTREAM algorithm family */ +typedef struct _mix2_ostream_scb_t { + /* First 13 dwords from generic_scb_t */ + basic_dma_req_t basic_req; /* Optional */ + scatter_gather_ext_t sg_ext; /* Optional */ + u16 next_scb; /* REQUIRED */ + u16 sub_list_ptr; /* REQUIRED */ + + u16 entry_point; /* REQUIRED */ + u16 this_spb; /* REQUIRED */ + + u32 strm_rs_config; /* REQUIRED */ + u32 strm_buf_ptr; /* REQUIRED */ + + + /* hi: Number of mixed-down input triplets + computed since start of group + lo: Number of frames remaining to be + processed in the current group of + frames + */ + u16 frames_left_in_group; + u16 accum_input_triplets; + + /* hi: Exponential volume change rate + for mixer on input streams + lo: Number of frames in the group + */ + u16 frame_group_length; + u16 exp_vol_change_rate; + + u16 const_FFFF; + u16 const_zero; +} mix2_ostream_scb_t; + + +/* SCB for S16_MIX algorithm */ +typedef struct _mix_only_scb_t { + /* First 13 dwords from generic_scb_t */ + basic_dma_req_t basic_req; /* Optional */ + scatter_gather_ext_t sg_ext; /* Optional */ + u16 next_scb; /* REQUIRED */ + u16 sub_list_ptr; /* REQUIRED */ + + u16 entry_point; /* REQUIRED */ + u16 this_spb; /* REQUIRED */ + + u32 strm_rs_config; /* REQUIRED */ + u32 strm_buf_ptr; /* REQUIRED */ + + u32 reserved; + volume_control_t vol_ctrl; +} mix_only_scb_t; + +/* SCB for the async. CODEC input algorithm */ +typedef struct _async_codec_input_scb_t { + u32 io_free2; + + u32 io_current_total; + u32 io_previous_total; + + u16 io_count; + u16 io_count_limit; + + u16 o_fifo_base_addr; + u16 ost_mo_format; + /* 1 = stereo; 0 = mono + xxx for ASER 1 (not allowed); 118 for ASER2 */ + + u32 ostrm_rs_config; + u32 ostrm_buf_ptr; + + u16 io_sclks_per_lr_clk; + u16 io_io_enable; + + u32 io_free4; + + u16 io_next_scb; + u16 io_sub_list_ptr; + + u16 io_entry_point; + u16 io_this_spb; + + u32 istrm_rs_config; + u32 istrm_buf_ptr; + + /* Init. 0000:8042: for ASER1 + 0000:8044: for ASER2 */ + u16 io_stat_reg_addr; + u16 iofifo_pointer; + + /* Init 1 stero:100 ASER1 + Init 0 mono:110 ASER2 + */ + u16 ififo_base_addr; + u16 ist_mo_format; + + u32 i_free; +} async_codec_input_scb_t; + + +/* SCB for the SP/DIF CODEC input and output */ +typedef struct _spdifiscb_t { + u16 status_ptr; + u16 status_start_ptr; + + u32 current_total; + u32 previous_total; + + u16 count; + u16 count_limit; + + u32 status_data; + + u16 status; + u16 free4; + + u32 free3; + + u16 free2; + u16 bit_count; + + u32 temp_status; + + u16 next_SCB; + u16 sub_list_ptr; + + u16 entry_point; + u16 this_spb; + + u32 strm_rs_config; + u32 strm_buf_ptr; + + u16 stat_reg_addr; + u16 fifo_pointer; + + u16 fifo_base_addr; + u16 st_mo_format; + + u32 Free1; +} spdifiscb_t; + + +/* SCB for the SP/DIF CODEC input and output */ +typedef struct _spdifoscb_t { + + + u32 free2; + + u32 free3[4]; + + /* Need to be here for compatibility with AsynchFGTxCode */ + u32 strm_rs_config; + + u32 strm_buf_ptr; + + u16 status; + u16 free5; + + u32 free4; + + u16 next_scb; + u16 sub_list_ptr; + + u16 entry_point; + u16 this_spb; + + u32 free6[2]; + + u16 stat_reg_addr; + u16 fifo_pointer; + + u16 fifo_base_addr; + u16 st_mo_format; + + u32 free1; +} spdifoscb_t; + + + +typedef struct _asynch_fg_rx_scb_t { + + u16 bot_buf_mask; + u16 buf_Mask; + + u16 max; + u16 min; + + u16 old_producer_pointer; + u16 hfg_scb_ptr; + + u16 delta; + u16 adjust_count; + + u32 unused2[5]; + + u16 sibling_ptr; + u16 child_ptr; + + u16 code_ptr; + u16 this_ptr; + + u32 strm_rs_config; + + u32 strm_buf_ptr; + + u32 unused_phi_incr; + + u16 righttarg; + u16 left_targ; + + u16 rightVol; + u16 leftVol; +} asynch_fg_rx_scb_t; + + + +typedef struct _asynch_fg_tx_scb_t { + u16 not_buf_mask; + u16 buf_mask; + + u16 Max; + u16 min; + + u16 unused1; + u16 hfg_scb_ptr; + + u16 delta; + u16 adjust_count; + + u32 accum_phi; + + u16 unused2; + u16 const_one_third; + + u32 unused3[3]; + + u16 sibling_ptr; + u16 child_ptr; + + u16 codePtr; + u16 this_ptr; + + u32 strm_rs_config; + + u32 strm_buf_ptr; + + u32 phi_incr; + + u16 unused_right_targ; + u16 unused_left_targ; + + u16 unused_right_vol; + u16 unused_left_vol; +} asynch_fg_tx_scb_t; + + +typedef struct _output_snoop_scb_t { + /* First 13 dwords from generic_scb_t */ + basic_dma_req_t basic_req; /* Optional */ + scatter_gather_ext_t sg_ext; /* Optional */ + u16 next_scb; /* REQUIRED */ + u16 sub_list_ptr; /* REQUIRED */ + + u16 entry_point; /* REQUIRED */ + u16 this_spb; /* REQUIRED */ + + u32 strm_rs_config; /* REQUIRED */ + u32 strm_buf_ptr; /* REQUIRED */ + + u16 init_snoop_input_link; + u16 snoop_child_input_scb; + + u32 snoop_input_buf_ptr; + + u16 reserved; + u16 input_scb; +} output_snoop_scb_t; + +typedef struct _spio_write_scb_t { + u16 address1; + u16 address2; + + u32 data1; + + u32 data2; + + u16 address3; + u16 address4; + + u32 data3; + + u32 data4; + + u16 unused1; + u16 data_ptr; + + u32 unused2[2]; + + u16 sibling_ptr; + u16 child_ptr; + + u16 entry_point; + u16 this_ptr; + + u32 unused3[5]; +} spio_write_scb_t; + +typedef struct _magic_snoop_task_t { + u32 i0; + u32 i1; + + u32 strm_buf_ptr1; + + u16 i2; + u16 snoop_scb; + + u32 i3; + u32 i4; + u32 i5; + u32 i6; + + u32 i7; + + u16 next_scb; + u16 sub_list_ptr; + + u16 entry_point; + u16 this_ptr; + + u32 strm_buf_config; + u32 strm_buf_ptr2; + + u32 i8; + + volume_control_t vdec_vol_ctrl; +} magic_snoop_task_t; +#endif /* __DSP_SCB_TYPES_H__ */ diff -Nru a/include/sound/cs46xx_dsp_spos.h b/include/sound/cs46xx_dsp_spos.h --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/include/sound/cs46xx_dsp_spos.h Sun Sep 29 20:23:44 2002 @@ -0,0 +1,183 @@ +/* + * The driver for the Cirrus Logic's Sound Fusion CS46XX based soundcards + * Copyright (c) by Jaroslav Kysela + * + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#ifndef __CS46XX_DSP_SPOS_H__ +#define __CS46XX_DSP_SPOS_H__ + +#include "cs46xx_dsp_scb_types.h" +#include "cs46xx_dsp_task_types.h" + +#define SYMBOL_CONSTANT 0x0 +#define SYMBOL_SAMPLE 0x1 +#define SYMBOL_PARAMETER 0x2 +#define SYMBOL_CODE 0x3 + +#define SEGTYPE_SP_PROGRAM 0x00000001 +#define SEGTYPE_SP_PARAMETER 0x00000002 +#define SEGTYPE_SP_SAMPLE 0x00000003 +#define SEGTYPE_SP_COEFFICIENT 0x00000004 + +#define DSP_SPOS_UU 0x0deadul /* unused */ +#define DSP_SPOS_DC 0x0badul /* dont care */ +#define DSP_SPOS_DC_DC 0x0bad0badul /* dont care */ +#define DSP_SPOS_UUUU 0xdeadc0edul /* unused */ +#define DSP_SPOS_UUHI 0xdeadul +#define DSP_SPOS_UULO 0xc0edul +#define DSP_SPOS_DCDC 0x0badf1d0ul /* dont care */ +#define DSP_SPOS_DCDCHI 0x0badul +#define DSP_SPOS_DCDCLO 0xf1d0ul + +#define DSP_MAX_TASK_NAME 60 +#define DSP_MAX_SYMBOL_NAME 100 +#define DSP_MAX_SCB_NAME 60 +#define DSP_MAX_SCB_DESC 200 +#define DSP_MAX_TASK_DESC 50 + +#define DSP_MAX_PCM_CHANNELS 32 +#define DSP_MAX_SRC_NR 6 + +struct _dsp_module_desc_t; + +typedef struct _symbol_entry_t { + u32 address; + char symbol_name[DSP_MAX_SYMBOL_NAME]; + int symbol_type; + + /* initialized by driver */ + struct _dsp_module_desc_t * module; + int deleted; +} symbol_entry_t; + +typedef struct _symbol_desc_t { + int nsymbols; + + symbol_entry_t * symbols; + + /* initialized by driver */ + int highest_frag_index; +} symbol_desc_t; + + +typedef struct _segment_desc_t { + int segment_type; + u32 offset; + u32 size; + u32 * data; +} segment_desc_t; + +typedef struct _dsp_module_desc_t { + char * module_name; + symbol_desc_t symbol_table; + int nsegments; + segment_desc_t * segments; + + /* initialized by driver */ + u32 overlay_begin_address; + u32 load_address; + int nfixups; +} dsp_module_desc_t; + +typedef struct _dsp_scb_descriptor_t { + char scb_name[DSP_MAX_SCB_NAME]; + u32 address; + int index; + + struct _dsp_scb_descriptor_t * sub_list_ptr; + struct _dsp_scb_descriptor_t * next_scb_ptr; + struct _dsp_scb_descriptor_t * parent_scb_ptr; + + symbol_entry_t * task_entry; + symbol_entry_t * scb_symbol; + + snd_info_entry_t *proc_info; + int ref_count; + + int deleted; +} dsp_scb_descriptor_t; + +typedef struct _dsp_task_descriptor_t { + char task_name[DSP_MAX_TASK_NAME]; + int size; + u32 address; + int index; +} dsp_task_descriptor_t; + +typedef struct _pcm_channel_descriptor_t { + int active; + int src_slot; + int pcm_slot; + u32 sample_rate; + u32 unlinked; + dsp_scb_descriptor_t * pcm_reader_scb; + dsp_scb_descriptor_t * src_scb; + + void * private_data; +} pcm_channel_descriptor_t; + +typedef struct _dsp_spos_instance_t { + symbol_desc_t symbol_table; /* currently availble loaded symbols in SP */ + + int nmodules; + dsp_module_desc_t * modules; /* modules loaded into SP */ + + segment_desc_t code; + + /* PCM playback */ + struct semaphore pcm_mutex; + + dsp_scb_descriptor_t * master_mix_scb; + int npcm_channels; + int nsrc_scb; + pcm_channel_descriptor_t pcm_channels[DSP_MAX_PCM_CHANNELS]; + int src_scb_slots[DSP_MAX_SRC_NR]; + + /* cache this symbols */ + symbol_entry_t * null_algorithm; /* used by PCMreaderSCB's */ + symbol_entry_t * s16_up; /* used by SRCtaskSCB's */ + + /* proc fs */ + snd_card_t * snd_card; + snd_info_entry_t * proc_dsp_dir; + snd_info_entry_t * proc_sym_info_entry; + snd_info_entry_t * proc_modules_info_entry; + snd_info_entry_t * proc_parameter_dump_info_entry; + snd_info_entry_t * proc_sample_dump_info_entry; + + /* SCB's descriptors */ + struct semaphore scb_mutex; + int nscb; + int scb_highest_frag_index; + dsp_scb_descriptor_t scbs[DSP_MAX_SCB_DESC]; + snd_info_entry_t * proc_scb_info_entry; + dsp_scb_descriptor_t * the_null_scb; + + /* Task's descriptors */ + int ntask; + dsp_task_descriptor_t tasks[DSP_MAX_TASK_DESC]; + snd_info_entry_t * proc_task_info_entry; + + /* SPDIF status */ + int spdif_status_out; + int spdif_status_in; +} dsp_spos_instance_t; + +#endif /* __DSP_SPOS_H__ */ + diff -Nru a/include/sound/cs46xx_dsp_task_types.h b/include/sound/cs46xx_dsp_task_types.h --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/include/sound/cs46xx_dsp_task_types.h Sun Sep 29 20:23:44 2002 @@ -0,0 +1,215 @@ +/* + * The driver for the Cirrus Logic's Sound Fusion CS46XX based soundcards + * Copyright (c) by Jaroslav Kysela + * + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * + * NOTE: comments are copy/paste from cwcemb80.lst + * provided by Tom Woller at Cirrus (my only + * documentation about the SP OS running inside + * the DSP) + */ + +#ifndef __CS46XX_DSP_TASK_TYPES_H__ +#define __CS46XX_DSP_TASK_TYPES_H__ + +/********************************************************************************************* +Example hierarchy of stream control blocks in the SP + +hfgTree +Ptr____Call (c) + \ + -------+------ ------------- ------------- ------------- ----- +| SBlaster IF |______\| Foreground |___\| Middlegr'nd |___\| Background |___\| Nul | +| |Goto /| tree header |g /| tree header |g /| tree header |g /| SCB |r + -------------- (g) ------------- ------------- ------------- ----- + |c |c |c |c + | | | | + \/ ------------- ------------- ------------- + | Foreground |_\ | Middlegr'nd |_\ | Background |_\ + | tree |g/ | tree |g/ | tree |g/ + ------------- ------------- ------------- + |c |c |c + | | | + \/ \/ \/ + +*********************************************************************************************/ + +#define HFG_FIRST_EXECUTE_MODE 0x0001 +#define HFG_FIRST_EXECUTE_MODE_BIT 0 +#define HFG_CONTEXT_SWITCH_MODE 0x0002 +#define HFG_CONTEXT_SWITCH_MODE_BIT 1 + +#define MAX_FG_STACK_SIZE 32 // THESE NEED TO BE COMPUTED PROPERLY +#define MAX_MG_STACK_SIZE 16 +#define MAX_BG_STACK_SIZE 9 +#define MAX_HFG_STACK_SIZE 4 + +#define SLEEP_ACTIVE_INCREMENT 0 /* Enable task tree thread to go to sleep + This should only ever be used on the Background thread */ +#define STANDARD_ACTIVE_INCREMENT 1 /* Task tree thread normal operation */ +#define SUSPEND_ACTIVE_INCREMENT 2 /* Cause execution to suspend in the task tree thread + This should only ever be used on the Background thread */ + +#define HOSTFLAGS_DISABLE_BG_SLEEP 0 /* Host-controlled flag that determines whether we go to sleep + at the end of BG */ + +/* Minimal context save area for Hyper Forground */ +typedef struct _hf_save_area_t { + u32 r10_save; + u32 r54_save; + u32 r98_save; + + u16 status_save; + u16 ind_save; + + u16 rci1_save; + u16 rci0_save; + + u32 r32_save; + u32 r76_save; + u32 rsd2_save; + + u16 rsi2_save; /* See TaskTreeParameterBlock for + remainder of registers */ + u16 rsa2Save; + /* saved as part of HFG context */ +} hf_save_area_t; + + +/* Task link data structure */ +typedef struct _tree_link_t { + /* Pointer to sibling task control block */ + u16 next_scb; + /* Pointer to child task control block */ + u16 sub_ptr; + + /* Pointer to code entry point */ + u16 entry_point; + /* Pointer to local data */ + u16 this_spb; +} tree_link_t; + + +typedef struct _task_tree_data_t { + /* Initial tock count; controls task tree execution rate */ + u16 tock_count_limit; + /* Tock down counter */ + u16 tock_count; + + /* Add to ActiveCount when TockCountLimit reached: + Subtract on task tree termination */ + u16 active_tncrement; + /* Number of pending activations for task tree */ + u16 active_count; + + /* BitNumber to enable modification of correct bit in ActiveTaskFlags */ + u16 active_bit; + /* Pointer to OS location for indicating current activity on task level */ + u16 active_task_flags_ptr; + + /* Data structure for controlling movement of memory blocks:- + currently unused */ + u16 mem_upd_ptr; + /* Data structure for controlling synchronous link update */ + u16 link_upd_ptr; + + /* Save area for remainder of full context. */ + u16 save_area; + /* Address of start of local stack for data storage */ + u16 data_stack_base_ptr; + +} task_tree_data_t; + + + +typedef struct _interval_timer_data_t +{ + /* These data items have the same relative locations to those */ + u16 interval_timer_period; + u16 itd_unused; + + /* used for this data in the SPOS control block for SPOS 1.0 */ + u16 num_FG_ticks_this_interval; + u16 num_intervals; +} interval_timer_data_t; + + +/* This structure contains extra storage for the task tree + Currently, this additional data is related only to a full context save */ +typedef struct _task_tree_context_block_t { + /* Up to 10 values are saved onto the stack. 8 for the task tree, 1 for + The access to the context switch (call or interrupt), and 1 spare that + users should never use. This last may be required by the system */ + u16 stack1; + u16 stack0; + u16 stack3; + u16 stack2; + u16 stack5; + u16 stack4; + u16 stack7; + u16 stack6; + u16 stack9; + u16 stack8; + + u32 saverfe; + + /* Value may be overwriten by stack save algorithm. + Retain the size of the stack data saved here if used */ + u16 reserved1; + u16 stack_size; + u32 saverba; /* (HFG) */ + u32 saverdc; + u32 savers_config_23; /* (HFG) */ + u32 savers_DMA23; /* (HFG) */ + u32 saversa0; + u32 saversi0; + u32 saversa1; + u32 saversi1; + u32 saversa3; + u32 saversd0; + u32 saversd1; + u32 saversd3; + u32 savers_config01; + u32 savers_DMA01; + u32 saveacc0hl; + u32 saveacc1hl; + u32 saveacc0xacc1x; + u32 saveacc2hl; + u32 saveacc3hl; + u32 saveacc2xacc3x; + u32 saveaux0hl; + u32 saveaux1hl; + u32 saveaux0xaux1x; + u32 saveaux2hl; + u32 saveaux3hl; + u32 saveaux2xaux3x; + u32 savershouthl; + u32 savershoutxmacmode; +} task_tree_context_block_t; + + +typedef struct _task_tree_control_block_t { + hf_save_area_t context; + tree_link_t links; + task_tree_data_t data; + task_tree_context_block_t context_blk; + interval_timer_data_t int_timer; +} task_tree_control_block_t; + + +#endif /* __DSP_TASK_TYPES_H__ */ diff -Nru a/include/sound/sndmagic.h b/include/sound/sndmagic.h --- a/include/sound/sndmagic.h Sun Sep 29 20:23:44 2002 +++ b/include/sound/sndmagic.h Sun Sep 29 20:23:44 2002 @@ -79,6 +79,7 @@ #define trident_t_magic 0xa15a1201 #define es1938_t_magic 0xa15a1301 #define cs46xx_t_magic 0xa15a1401 +#define cs46xx_pcm_t_magic 0xa15a1402 #define ensoniq_t_magic 0xa15a1501 #define sonicvibes_t_magic 0xa15a1601 #define mpu401_t_magic 0xa15a1701 diff -Nru a/include/sound/version.h b/include/sound/version.h --- a/include/sound/version.h Sun Sep 29 20:23:44 2002 +++ b/include/sound/version.h Sun Sep 29 20:23:44 2002 @@ -1,3 +1,3 @@ /* include/version.h. Generated automatically by configure. */ #define CONFIG_SND_VERSION "0.9.0rc2" -#define CONFIG_SND_DATE " (Wed Jul 31 15:28:28 2002 UTC)" +#define CONFIG_SND_DATE " (Thu Aug 01 15:59:56 2002 UTC)" diff -Nru a/sound/core/seq/seq_queue.c b/sound/core/seq/seq_queue.c --- a/sound/core/seq/seq_queue.c Sun Sep 29 20:23:44 2002 +++ b/sound/core/seq/seq_queue.c Sun Sep 29 20:23:44 2002 @@ -149,7 +149,7 @@ static void queue_delete(queue_t *q) { /* stop and release the timer */ - snd_seq_timer_stop(q->timer); + snd_seq_timer_stop(q->timer, 0); snd_seq_timer_close(q); /* wait until access free */ snd_use_lock_sync(&q->use_lock); @@ -348,7 +348,7 @@ /* enqueue a event to singe queue */ int snd_seq_enqueue_event(snd_seq_event_cell_t *cell, int atomic, int hop) { - int dest; + int dest, err; queue_t *q; snd_assert(cell != NULL, return -EINVAL); @@ -373,14 +373,20 @@ /* enqueue event in the real-time or midi queue */ switch (cell->event.flags & SNDRV_SEQ_TIME_STAMP_MASK) { case SNDRV_SEQ_TIME_STAMP_TICK: - snd_seq_prioq_cell_in(q->tickq, cell); + err = snd_seq_prioq_cell_in(q->tickq, cell); break; case SNDRV_SEQ_TIME_STAMP_REAL: - snd_seq_prioq_cell_in(q->timeq, cell); + default: + err = snd_seq_prioq_cell_in(q->timeq, cell); break; } + if (err < 0) { + queuefree(q); /* unlock */ + return err; + } + /* trigger dispatching */ snd_seq_check_queue(q, atomic, hop); @@ -601,7 +607,7 @@ spin_unlock_irqrestore(&q->owner_lock, flags); if (q->owner == client) { if (q->timer->running) - snd_seq_timer_stop(q->timer); + snd_seq_timer_stop(q->timer, 0); snd_seq_timer_reset(q->timer); } queuefree(q); @@ -711,17 +717,17 @@ case SNDRV_SEQ_EVENT_START: snd_seq_prioq_leave(q->tickq, ev->source.client, 1); snd_seq_prioq_leave(q->timeq, ev->source.client, 1); - snd_seq_timer_start(q->timer); - queue_broadcast_event(q, ev, from_timer_port, atomic, hop); + if (! snd_seq_timer_start(q->timer, atomic)) + queue_broadcast_event(q, ev, from_timer_port, atomic, hop); break; case SNDRV_SEQ_EVENT_CONTINUE: - snd_seq_timer_continue(q->timer); - queue_broadcast_event(q, ev, from_timer_port, atomic, hop); + if (! snd_seq_timer_continue(q->timer, atomic)) + queue_broadcast_event(q, ev, from_timer_port, atomic, hop); break; case SNDRV_SEQ_EVENT_STOP: - snd_seq_timer_stop(q->timer); + snd_seq_timer_stop(q->timer, atomic); queue_broadcast_event(q, ev, from_timer_port, atomic, hop); break; diff -Nru a/sound/core/seq/seq_timer.c b/sound/core/seq/seq_timer.c --- a/sound/core/seq/seq_timer.c Sun Sep 29 20:23:44 2002 +++ b/sound/core/seq/seq_timer.c Sun Sep 29 20:23:44 2002 @@ -89,7 +89,7 @@ t->running = 0; /* reset time */ - snd_seq_timer_stop(t); + snd_seq_timer_stop(t, 0); snd_seq_timer_reset(t); kfree(t); @@ -313,14 +313,18 @@ return 0; } -void snd_seq_timer_stop(seq_timer_t * tmr) +int snd_seq_timer_stop(seq_timer_t * tmr, int in_callback) { if (! tmr->timeri) - return; + return -EINVAL; if (!tmr->running) - return; + return 0; tmr->running = 0; - snd_timer_stop(tmr->timeri); + if (in_callback) + snd_timer_del(tmr->timeri); + else + snd_timer_stop(tmr->timeri); + return 0; } static int initialize_timer(seq_timer_t *tmr) @@ -345,34 +349,36 @@ return 0; } -void snd_seq_timer_start(seq_timer_t * tmr) +int snd_seq_timer_start(seq_timer_t * tmr, int in_callback) { if (! tmr->timeri) - return; + return -EINVAL; if (tmr->running) - snd_seq_timer_stop(tmr); + snd_seq_timer_stop(tmr, in_callback); snd_seq_timer_reset(tmr); if (initialize_timer(tmr) < 0) - return; + return -EINVAL; snd_timer_start(tmr->timeri, tmr->ticks); tmr->running = 1; do_gettimeofday(&tmr->last_update); + return 0; } -void snd_seq_timer_continue(seq_timer_t * tmr) +int snd_seq_timer_continue(seq_timer_t * tmr, int in_callback) { if (! tmr->timeri) - return; + return -EINVAL; if (tmr->running) - return; + return -EBUSY; if (! tmr->initialized) { snd_seq_timer_reset(tmr); if (initialize_timer(tmr) < 0) - return; + return -EINVAL; } snd_timer_start(tmr->timeri, tmr->ticks); tmr->running = 1; do_gettimeofday(&tmr->last_update); + return 0; } /* return current 'real' time. use timeofday() to get better granularity. */ diff -Nru a/sound/core/seq/seq_timer.h b/sound/core/seq/seq_timer.h --- a/sound/core/seq/seq_timer.h Sun Sep 29 20:23:44 2002 +++ b/sound/core/seq/seq_timer.h Sun Sep 29 20:23:44 2002 @@ -127,9 +127,9 @@ int snd_seq_timer_midi_close(queue_t *q); void snd_seq_timer_defaults(seq_timer_t *tmr); void snd_seq_timer_reset(seq_timer_t *tmr); -void snd_seq_timer_stop(seq_timer_t *tmr); -void snd_seq_timer_start(seq_timer_t *tmr); -void snd_seq_timer_continue(seq_timer_t *tmr); +int snd_seq_timer_stop(seq_timer_t *tmr, int in_callback); +int snd_seq_timer_start(seq_timer_t *tmr, int in_callback); +int snd_seq_timer_continue(seq_timer_t *tmr, int in_callback); int snd_seq_timer_set_tempo(seq_timer_t *tmr, int tempo); int snd_seq_timer_set_ppq(seq_timer_t *tmr, int ppq); int snd_seq_timer_set_position_tick(seq_timer_t *tmr, snd_seq_tick_time_t position); diff -Nru a/sound/isa/wavefront/wavefront.c b/sound/isa/wavefront/wavefront.c --- a/sound/isa/wavefront/wavefront.c Sun Sep 29 20:23:44 2002 +++ b/sound/isa/wavefront/wavefront.c Sun Sep 29 20:23:44 2002 @@ -71,8 +71,8 @@ MODULE_PARM_SYNTAX(snd_isapnp, SNDRV_ISAPNP_DESC); #endif MODULE_PARM(snd_cs4232_pcm_port, "1-" __MODULE_STRING(SNDRV_CARDS) "l"); -MODULE_PARM_DESC(snd_4232_port, "Port # for CS4232 PCM interface."); -MODULE_PARM_SYNTAX(snd_cs4232_port, SNDRV_PORT12_DESC); +MODULE_PARM_DESC(snd_cs4232_pcm_port, "Port # for CS4232 PCM interface."); +MODULE_PARM_SYNTAX(snd_cs4232_pcm_port, SNDRV_PORT12_DESC); MODULE_PARM(snd_cs4232_pcm_irq, "1-" __MODULE_STRING(SNDRV_CARDS) "i"); MODULE_PARM_DESC(snd_cs4232_pcm_irq, "IRQ # for CS4232 PCM interface."); MODULE_PARM_SYNTAX(snd_cs4232_pcm_irq, SNDRV_ENABLED ",allows:{{5},{7},{9},{11},{12},{15}},dialog:list"); diff -Nru a/sound/pci/Config.help b/sound/pci/Config.help --- a/sound/pci/Config.help Sun Sep 29 20:23:44 2002 +++ b/sound/pci/Config.help Sun Sep 29 20:23:44 2002 @@ -5,9 +5,8 @@ Say 'Y' or 'M' to include support for Cirrus Logic CS4610 / CS4612 / CS4614 / CS4615 / CS4622 / CS4624 / CS4630 / CS4280 chips. -CONFIG_SND_CS46XX_ACCEPT_VALID - Say 'Y' to allow sample resolution for mmap() transfers. - Note: This can be also specified via module option snd_mmap_valid. +CONFIG_SND_CS46XX_NEW_DSP + Say 'Y' to use a new DSP image for SPDIF and dual codecs. CONFIG_SND_CS4281 Say 'Y' or 'M' to include support for Cirrus Logic CS4281. @@ -39,6 +38,8 @@ soundcards. CONFIG_SND_TRIDENT + Say 'Y' or 'M' to include support for Trident 4D-Wave DX/NX and + SiS 7018 soundcards. CONFIG_SND_YMFPCI Say 'Y' or 'M' to include support for Yamaha PCI audio chips - @@ -75,7 +76,8 @@ Say 'Y' or 'M' to include support for ICE1712 (Envy24) based soundcards. CONFIG_SND_INTEL8X0 - Say 'Y' or 'M' to include support for Intel8x0 based soundcards. + Say 'Y' or 'M' to include support for Intel8x0 based soundcards, + SiS 7012, AMD768/8111 and NVidia NForce chips. CONFIG_SND_SONICVIBES Say 'Y' or 'M' to include support for S3 SonicVibes based soundcards. diff -Nru a/sound/pci/Config.in b/sound/pci/Config.in --- a/sound/pci/Config.in Sun Sep 29 20:23:44 2002 +++ b/sound/pci/Config.in Sun Sep 29 20:23:44 2002 @@ -5,9 +5,7 @@ dep_tristate 'ALi PCI Audio M5451' CONFIG_SND_ALI5451 $CONFIG_SND dep_tristate 'Cirrus Logic (Sound Fusion) CS4280/CS461x/CS462x/CS463x' CONFIG_SND_CS46XX $CONFIG_SND -if [ "$CONFIG_SND_CS46XX" != "n" ]; then - bool ' Cirrus Logic (Sound Fusion) MMAP support for OSS' CONFIG_SND_CS46XX_ACCEPT_VALID -fi +dep_mbool ' Cirrus Logic (Sound Fusion) New DSP support (EXPERIMENTAL)' CONFIG_SND_CS46XX_NEW_DSP $CONFIG_SND_CS46XX $CONFIG_EXPERIMENTAL dep_tristate 'Cirrus Logic CS4281' CONFIG_SND_CS4281 $CONFIG_SND dep_tristate 'EMU10K1 (SB Live!, E-mu APS)' CONFIG_SND_EMU10K1 $CONFIG_SND dep_tristate 'Korg 1212 IO' CONFIG_SND_KORG1212 $CONFIG_SND diff -Nru a/sound/pci/cs46xx/Makefile b/sound/pci/cs46xx/Makefile --- a/sound/pci/cs46xx/Makefile Sun Sep 29 20:23:44 2002 +++ b/sound/pci/cs46xx/Makefile Sun Sep 29 20:23:44 2002 @@ -4,6 +4,9 @@ # snd-cs46xx-objs := cs46xx.o cs46xx_lib.o +ifeq ($(CONFIG_SND_CS46XX_NEW_DSP),y) + snd-cs46xx-objs += dsp_spos.o dsp_spos_scb_lib.o +endif # Toplevel Module Dependency obj-$(CONFIG_SND_CS46XX) += snd-cs46xx.o diff -Nru a/sound/pci/cs46xx/cs46xx.c b/sound/pci/cs46xx/cs46xx.c --- a/sound/pci/cs46xx/cs46xx.c Sun Sep 29 20:23:44 2002 +++ b/sound/pci/cs46xx/cs46xx.c Sun Sep 29 20:23:44 2002 @@ -51,9 +51,7 @@ static int snd_enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; /* Enable this card */ static int snd_external_amp[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 0}; static int snd_thinkpad[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 0}; -#ifndef CONFIG_SND_CS46XX_ACCEPT_VALID static int snd_mmap_valid[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 0}; -#endif MODULE_PARM(snd_index, "1-" __MODULE_STRING(SNDRV_CARDS) "i"); MODULE_PARM_DESC(snd_index, "Index value for the CS46xx soundcard."); @@ -70,11 +68,9 @@ MODULE_PARM(snd_thinkpad, "1-" __MODULE_STRING(SNDRV_CARDS) "i"); MODULE_PARM_DESC(snd_thinkpad, "Force to enable Thinkpad's CLKRUN control."); MODULE_PARM_SYNTAX(snd_thinkpad, SNDRV_ENABLED "," SNDRV_BOOLEAN_FALSE_DESC); -#ifndef CONFIG_SND_CS46XX_ACCEPT_VALID MODULE_PARM(snd_mmap_valid, "1-" __MODULE_STRING(SNDRV_CARDS) "i"); MODULE_PARM_DESC(snd_mmap_valid, "Support OSS mmap."); MODULE_PARM_SYNTAX(snd_mmap_valid, SNDRV_ENABLED "," SNDRV_BOOLEAN_FALSE_DESC); -#endif static struct pci_device_id snd_cs46xx_ids[] __devinitdata = { { 0x1013, 0x6001, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0, }, /* CS4280 */ @@ -109,11 +105,7 @@ snd_card_free(card); return err; } -#ifdef CONFIG_SND_CS46XX_ACCEPT_VALID - chip->accept_valid = 1; -#else chip->accept_valid = snd_mmap_valid[dev]; -#endif if ((err = snd_cs46xx_pcm(chip, 0, NULL)) < 0) { snd_card_free(card); return err; diff -Nru a/sound/pci/cs46xx/cs46xx_image.h b/sound/pci/cs46xx/cs46xx_image.h --- a/sound/pci/cs46xx/cs46xx_image.h Sun Sep 29 20:23:44 2002 +++ b/sound/pci/cs46xx/cs46xx_image.h Sun Sep 29 20:23:44 2002 @@ -1,4 +1,13 @@ -struct BA1struct BA1Struct = { +struct BA1struct { + struct { + unsigned long offset; + unsigned long size; + } memory[BA1_MEMORY_COUNT]; + u32 map[BA1_DWORD_SIZE]; +}; + + +static struct BA1struct BA1Struct = { {{ 0x00000000, 0x00003000 },{ 0x00010000, 0x00003800 },{ 0x00020000, 0x00007000 }}, {0x00000000,0x00000000,0x00000000,0x00000000, 0x00000000,0x00000000,0x00000000,0x00000000, diff -Nru a/sound/pci/cs46xx/cs46xx_lib.c b/sound/pci/cs46xx/cs46xx_lib.c --- a/sound/pci/cs46xx/cs46xx_lib.c Sun Sep 29 20:23:44 2002 +++ b/sound/pci/cs46xx/cs46xx_lib.c Sun Sep 29 20:23:44 2002 @@ -45,75 +45,42 @@ #ifndef LINUX_2_2 #include #endif - -#define chip_t cs46xx_t - -/* - * constants - */ - -#define CS46XX_BA0_SIZE 0x1000 -#define CS46XX_BA1_DATA0_SIZE 0x3000 -#define CS46XX_BA1_DATA1_SIZE 0x3800 -#define CS46XX_BA1_PRG_SIZE 0x7000 -#define CS46XX_BA1_REG_SIZE 0x0100 - - -#define CS46XX_PERIOD_SIZE 2048 -#define CS46XX_FRAGS 2 -#define CS46XX_BUFFER_SIZE CS46XX_PERIOD_SIZE * CS46XX_FRAGS - -extern snd_pcm_ops_t snd_cs46xx_playback_ops; -extern snd_pcm_ops_t snd_cs46xx_playback_indirect_ops; -extern snd_pcm_ops_t snd_cs46xx_capture_ops; -extern snd_pcm_ops_t snd_cs46xx_capture_indirect_ops; - - -/* - * common I/O routines - */ - -static inline void snd_cs46xx_poke(cs46xx_t *chip, unsigned long reg, unsigned int val) -{ - unsigned int bank = reg >> 16; - unsigned int offset = reg & 0xffff; - writel(val, chip->region.idx[bank+1].remap_addr + offset); -} - -static inline unsigned int snd_cs46xx_peek(cs46xx_t *chip, unsigned long reg) -{ - unsigned int bank = reg >> 16; - unsigned int offset = reg & 0xffff; - return readl(chip->region.idx[bank+1].remap_addr + offset); -} - -static inline void snd_cs46xx_pokeBA0(cs46xx_t *chip, unsigned long offset, unsigned int val) -{ - writel(val, chip->region.name.ba0.remap_addr + offset); -} - -static inline unsigned int snd_cs46xx_peekBA0(cs46xx_t *chip, unsigned long offset) -{ - return readl(chip->region.name.ba0.remap_addr + offset); -} - +#include "cs46xx_lib.h" static unsigned short snd_cs46xx_codec_read(cs46xx_t *chip, - unsigned short reg) + unsigned short reg, + int codec_index) { int count; - unsigned short result; + unsigned short result,tmp; + u32 offset = 0; + snd_assert ( (codec_index == CS46XX_PRIMARY_CODEC_INDEX) || + (codec_index == CS46XX_SECONDARY_CODEC_INDEX), + return -EINVAL); + + if (codec_index == CS46XX_SECONDARY_CODEC_INDEX) + offset = CS46XX_SECONDARY_CODEC_OFFSET; /* * 1. Write ACCAD = Command Address Register = 46Ch for AC97 register address * 2. Write ACCDA = Command Data Register = 470h for data to write to AC97 - * 3. Write ACCTL = Control Register = 460h for initiating the write + * 3. Write ACCTL = Control Register = 460h for initiating the write7---55 * 4. Read ACCTL = 460h, DCV should be reset by now and 460h = 17h * 5. if DCV not cleared, break and return error * 6. Read ACSTS = Status Register = 464h, check VSTS bit */ - snd_cs46xx_peekBA0(chip, BA0_ACSDA); + snd_cs46xx_peekBA0(chip, BA0_ACSDA + offset); + + tmp = snd_cs46xx_peekBA0(chip, BA0_ACCTL); + if ((tmp & ACCTL_VFRM) == 0) { + snd_printk(KERN_WARNING "cs46xx: ACCTL_VFRM not set 0x%x\n",tmp); + snd_cs46xx_pokeBA0(chip, BA0_ACCTL, (tmp & (~ACCTL_ESYN)) | ACCTL_VFRM ); + mdelay(50); + tmp = snd_cs46xx_peekBA0(chip, BA0_ACCTL + offset); + snd_cs46xx_pokeBA0(chip, BA0_ACCTL, tmp | ACCTL_ESYN | ACCTL_VFRM ); + + } /* * Setup the AC97 control registers on the CS461x to send the @@ -130,10 +97,18 @@ snd_cs46xx_pokeBA0(chip, BA0_ACCAD, reg); snd_cs46xx_pokeBA0(chip, BA0_ACCDA, 0); - snd_cs46xx_pokeBA0(chip, BA0_ACCTL, ACCTL_DCV | ACCTL_CRW | - ACCTL_VFRM | ACCTL_ESYN | - ACCTL_RSTN); - + if (codec_index == CS46XX_PRIMARY_CODEC_INDEX) { + snd_cs46xx_pokeBA0(chip, BA0_ACCTL,/* clear ACCTL_DCV */ ACCTL_CRW | + ACCTL_VFRM | ACCTL_ESYN | + ACCTL_RSTN); + snd_cs46xx_pokeBA0(chip, BA0_ACCTL, ACCTL_DCV | ACCTL_CRW | + ACCTL_VFRM | ACCTL_ESYN | + ACCTL_RSTN); + } else { + snd_cs46xx_pokeBA0(chip, BA0_ACCTL, ACCTL_DCV | ACCTL_TC | + ACCTL_CRW | ACCTL_VFRM | ACCTL_ESYN | + ACCTL_RSTN); + } /* * Wait for the read to occur. @@ -165,12 +140,12 @@ * ACSTS = Status Register = 464h * VSTS - Valid Status */ - if (snd_cs46xx_peekBA0(chip, BA0_ACSTS) & ACSTS_VSTS) + if (snd_cs46xx_peekBA0(chip, BA0_ACSTS + offset) & ACSTS_VSTS) goto ok2; udelay(10); } - snd_printk("AC'97 read problem (ACSTS_VSTS), reg = 0x%x\n", reg); + snd_printk("AC'97 read problem (ACSTS_VSTS), codec_index %d, reg = 0x%x\n", codec_index, reg); result = 0xffff; goto end; @@ -184,7 +159,9 @@ snd_cs46xx_peekBA0(chip, BA0_ACSDA), snd_cs46xx_peekBA0(chip, BA0_ACCAD)); #endif - result = snd_cs46xx_peekBA0(chip, BA0_ACSDA); + + //snd_cs46xx_peekBA0(chip, BA0_ACCAD); + result = snd_cs46xx_peekBA0(chip, BA0_ACSDA + offset); end: return result; } @@ -194,8 +171,18 @@ { cs46xx_t *chip = snd_magic_cast(cs46xx_t, ac97->private_data, return -ENXIO); unsigned short val; + int codec_index = -1; + + /* UGGLY: nr_ac97_codecs == 0 primery codec detection is in progress */ + if (ac97 == chip->ac97[CS46XX_PRIMARY_CODEC_INDEX] || chip->nr_ac97_codecs == 0) + codec_index = CS46XX_PRIMARY_CODEC_INDEX; + /* UGGLY: nr_ac97_codecs == 1 secondary codec detection is in progress */ + else if (ac97 == chip->ac97[CS46XX_SECONDARY_CODEC_INDEX] || chip->nr_ac97_codecs == 1) + codec_index = CS46XX_SECONDARY_CODEC_INDEX; + else + snd_assert(0, return 0xffff); chip->active_ctrl(chip, 1); - val = snd_cs46xx_codec_read(chip, reg); + val = snd_cs46xx_codec_read(chip, reg, codec_index); chip->active_ctrl(chip, -1); return val; } @@ -203,8 +190,15 @@ static void snd_cs46xx_codec_write(cs46xx_t *chip, unsigned short reg, - unsigned short val) + unsigned short val, + int codec_index) { + int count; + + snd_assert ((codec_index == CS46XX_PRIMARY_CODEC_INDEX) || + (codec_index == CS46XX_SECONDARY_CODEC_INDEX), + return); + /* * 1. Write ACCAD = Command Address Register = 46Ch for AC97 register address * 2. Write ACCDA = Command Data Register = 470h for data to write to AC97 @@ -212,7 +206,6 @@ * 4. Read ACCTL = 460h, DCV should be reset by now and 460h = 07h * 5. if DCV not cleared, break and return error */ - int count; /* * Setup the AC97 control registers on the CS461x to send the @@ -226,10 +219,20 @@ * set ESYN - ASYNC generation enabled * set RSTN - ARST# inactive, AC97 codec not reset */ - snd_cs46xx_pokeBA0(chip, BA0_ACCAD, reg); - snd_cs46xx_pokeBA0(chip, BA0_ACCDA, val); - snd_cs46xx_pokeBA0(chip, BA0_ACCTL, ACCTL_DCV | ACCTL_VFRM | - ACCTL_ESYN | ACCTL_RSTN); + snd_cs46xx_pokeBA0(chip, BA0_ACCAD , reg); + snd_cs46xx_pokeBA0(chip, BA0_ACCDA , val); + snd_cs46xx_peekBA0(chip, BA0_ACCTL); + + if (codec_index == CS46XX_PRIMARY_CODEC_INDEX) { + snd_cs46xx_pokeBA0(chip, BA0_ACCTL, /* clear ACCTL_DCV */ ACCTL_VFRM | + ACCTL_ESYN | ACCTL_RSTN); + snd_cs46xx_pokeBA0(chip, BA0_ACCTL, ACCTL_DCV | ACCTL_VFRM | + ACCTL_ESYN | ACCTL_RSTN); + } else { + snd_cs46xx_pokeBA0(chip, BA0_ACCTL, ACCTL_DCV | ACCTL_TC | + ACCTL_VFRM | ACCTL_ESYN | ACCTL_RSTN); + } + for (count = 0; count < 4000; count++) { /* * First, we want to wait for a short time. @@ -243,7 +246,7 @@ return; } } - snd_printk("AC'97 write problem, reg = 0x%x, val = 0x%x\n", reg, val); + snd_printk("AC'97 write problem, codec_index = %d, reg = 0x%x, val = 0x%x\n", codec_index, reg, val); } static void snd_cs46xx_ac97_write(ac97_t *ac97, @@ -252,12 +255,21 @@ { cs46xx_t *chip = snd_magic_cast(cs46xx_t, ac97->private_data, return); int val2 = 0; + int codec_index = -1; + /* UGGLY: nr_ac97_codecs == 0 primery codec detection is in progress */ + if (ac97 == chip->ac97[CS46XX_PRIMARY_CODEC_INDEX] || chip->nr_ac97_codecs == 0) + codec_index = CS46XX_PRIMARY_CODEC_INDEX; + /* UGGLY: nr_ac97_codecs == 0 secondary codec detection is in progress */ + else if (ac97 == chip->ac97[CS46XX_SECONDARY_CODEC_INDEX] || chip->nr_ac97_codecs == 1) + codec_index = CS46XX_SECONDARY_CODEC_INDEX; + else + snd_assert(0,return); chip->active_ctrl(chip, 1); if (reg == AC97_CD) - val2 = snd_cs46xx_codec_read(chip, AC97_CD); + val2 = snd_cs46xx_codec_read(chip, AC97_CD, codec_index); - snd_cs46xx_codec_write(chip, reg, val); + snd_cs46xx_codec_write(chip, reg, val, codec_index); /* @@ -320,19 +332,36 @@ return 0; } -/* 3*1024 parameter, 3.5*1024 sample, 2*3.5*1024 code */ -#define BA1_DWORD_SIZE (13 * 1024 + 512) -#define BA1_MEMORY_COUNT 3 - -struct BA1struct { - struct { - unsigned long offset; - unsigned long size; - } memory[BA1_MEMORY_COUNT]; - u32 map[BA1_DWORD_SIZE]; -}; +#ifdef CONFIG_SND_CS46XX_NEW_DSP + +// #include "imgs/cwcemb80.h" +#include "imgs/cwc4630.h" +#include "imgs/cwcasync.h" +#include "imgs/cwcsnoop.h" +#include "imgs/cwcbinhack.h" + +int snd_cs46xx_clear_BA1(cs46xx_t *chip, + unsigned long offset, + unsigned long len) +{ + unsigned long dst; + unsigned int bank = offset >> 16; + offset = offset & 0xffff; + + snd_assert(!(offset & 3) && !(len & 3), return -EINVAL); + dst = chip->region.idx[bank+1].remap_addr + offset; + len /= sizeof(u32); + + /* writel already converts 32-bit value to right endianess */ + while (len-- > 0) { + writel(0, dst); + dst += sizeof(u32); + } + return 0; +} + +#else /* old DSP image */ -static #include "cs46xx_image.h" int snd_cs46xx_download_image(cs46xx_t *chip) @@ -350,6 +379,7 @@ } return 0; } +#endif /* CONFIG_SND_CS46XX_NEW_DSP */ /* * Chip reset @@ -640,38 +670,42 @@ static int snd_cs46xx_playback_transfer(snd_pcm_substream_t *substream, snd_pcm_uframes_t frames) { - cs46xx_t *chip = snd_pcm_substream_chip(substream); + /* cs46xx_t *chip = snd_pcm_substream_chip(substream); */ snd_pcm_runtime_t *runtime = substream->runtime; - snd_pcm_sframes_t diff = runtime->control->appl_ptr - chip->play.appl_ptr; + snd_pcm_sframes_t diff; + cs46xx_pcm_t * cpcm; + cpcm = snd_magic_cast(cs46xx_pcm_t, substream->runtime->private_data, return -ENXIO); + + diff = runtime->control->appl_ptr - cpcm->appl_ptr; if (diff) { if (diff < -(snd_pcm_sframes_t) (runtime->boundary / 2)) diff += runtime->boundary; - chip->play.sw_ready += diff << chip->play.shift; + cpcm->sw_ready += diff << cpcm->shift; } - chip->play.sw_ready += frames << chip->play.shift; - chip->play.appl_ptr = runtime->control->appl_ptr + frames; - while (chip->play.hw_ready < CS46XX_BUFFER_SIZE && - chip->play.sw_ready > 0) { - size_t hw_to_end = CS46XX_BUFFER_SIZE - chip->play.hw_data; - size_t sw_to_end = chip->play.sw_bufsize - chip->play.sw_data; - size_t bytes = CS46XX_BUFFER_SIZE - chip->play.hw_ready; - if (chip->play.sw_ready < bytes) - bytes = chip->play.sw_ready; + cpcm->sw_ready += frames << cpcm->shift; + cpcm->appl_ptr = runtime->control->appl_ptr + frames; + while (cpcm->hw_ready < CS46XX_BUFFER_SIZE && + cpcm->sw_ready > 0) { + size_t hw_to_end = CS46XX_BUFFER_SIZE - cpcm->hw_data; + size_t sw_to_end = cpcm->sw_bufsize - cpcm->sw_data; + size_t bytes = CS46XX_BUFFER_SIZE - cpcm->hw_ready; + if (cpcm->sw_ready < bytes) + bytes = cpcm->sw_ready; if (hw_to_end < bytes) bytes = hw_to_end; if (sw_to_end < bytes) bytes = sw_to_end; - memcpy(chip->play.hw_area + chip->play.hw_data, - runtime->dma_area + chip->play.sw_data, + memcpy(cpcm->hw_area + cpcm->hw_data, + runtime->dma_area + cpcm->sw_data, bytes); - chip->play.hw_data += bytes; - if (chip->play.hw_data == CS46XX_BUFFER_SIZE) - chip->play.hw_data = 0; - chip->play.sw_data += bytes; - if (chip->play.sw_data == chip->play.sw_bufsize) - chip->play.sw_data = 0; - chip->play.hw_ready += bytes; - chip->play.sw_ready -= bytes; + cpcm->hw_data += bytes; + if (cpcm->hw_data == CS46XX_BUFFER_SIZE) + cpcm->hw_data = 0; + cpcm->sw_data += bytes; + if (cpcm->sw_data == cpcm->sw_bufsize) + cpcm->sw_data = 0; + cpcm->hw_ready += bytes; + cpcm->sw_ready -= bytes; } return 0; } @@ -718,24 +752,45 @@ static snd_pcm_uframes_t snd_cs46xx_playback_direct_pointer(snd_pcm_substream_t * substream) { cs46xx_t *chip = snd_pcm_substream_chip(substream); - size_t ptr = snd_cs46xx_peek(chip, BA1_PBA) - chip->play.hw_addr; - return ptr >> chip->play.shift; + size_t ptr; + cs46xx_pcm_t *cpcm = snd_magic_cast(cs46xx_pcm_t, substream->runtime->private_data, return -ENXIO); + snd_assert (cpcm->pcm_channel,return -ENXIO); + +#ifdef CONFIG_SND_CS46XX_NEW_DSP + ptr = snd_cs46xx_peek(chip, (cpcm->pcm_channel->pcm_reader_scb->address + 2) << 2); +#else + ptr = snd_cs46xx_peek(chip, BA1_PBA); +#endif + ptr -= cpcm->hw_addr; + return ptr >> cpcm->shift; } static snd_pcm_uframes_t snd_cs46xx_playback_indirect_pointer(snd_pcm_substream_t * substream) { cs46xx_t *chip = snd_pcm_substream_chip(substream); - size_t ptr = snd_cs46xx_peek(chip, BA1_PBA) - chip->play.hw_addr; - ssize_t bytes = ptr - chip->play.hw_io; + size_t ptr; + cs46xx_pcm_t *cpcm = snd_magic_cast(cs46xx_pcm_t, substream->runtime->private_data, return -ENXIO); + ssize_t bytes; + +#ifdef CONFIG_SND_CS46XX_NEW_DSP + snd_assert (cpcm->pcm_channel,return -ENXIO); + ptr = snd_cs46xx_peek(chip, (cpcm->pcm_channel->pcm_reader_scb->address + 2) << 2); +#else + ptr = snd_cs46xx_peek(chip, BA1_PBA); +#endif + ptr -= cpcm->hw_addr; + + bytes = ptr - cpcm->hw_io; + if (bytes < 0) bytes += CS46XX_BUFFER_SIZE; - chip->play.hw_io = ptr; - chip->play.hw_ready -= bytes; - chip->play.sw_io += bytes; - if (chip->play.sw_io > chip->play.sw_bufsize) - chip->play.sw_io -= chip->play.sw_bufsize; + cpcm->hw_io = ptr; + cpcm->hw_ready -= bytes; + cpcm->sw_io += bytes; + if (cpcm->sw_io > cpcm->sw_bufsize) + cpcm->sw_io -= cpcm->sw_bufsize; snd_cs46xx_playback_transfer(substream, 0); - return chip->play.sw_io >> chip->play.shift; + return cpcm->sw_io >> cpcm->shift; } static snd_pcm_uframes_t snd_cs46xx_capture_direct_pointer(snd_pcm_substream_t * substream) @@ -768,10 +823,16 @@ snd_pcm_uframes_t frames) { snd_pcm_runtime_t *runtime = substream->runtime; - cs46xx_t *chip = snd_pcm_substream_chip(substream); - size_t hwoffb = hwoff << chip->play.shift; - size_t bytes = frames << chip->play.shift; - char *hwbuf = runtime->dma_area + hwoffb; + /*cs46xx_t *chip = snd_pcm_substream_chip(substream); */ + size_t hwoffb; + size_t bytes; + char *hwbuf; + cs46xx_pcm_t *cpcm = snd_magic_cast(cs46xx_pcm_t, substream->runtime->private_data, return -ENXIO); + + hwoffb = hwoff << cpcm->shift; + bytes = frames << cpcm->shift; + hwbuf = runtime->dma_area + hwoffb; + if (copy_from_user(hwbuf, src, bytes)) return -EFAULT; spin_lock_irq(&runtime->lock); @@ -803,24 +864,47 @@ int cmd) { cs46xx_t *chip = snd_pcm_substream_chip(substream); - unsigned int tmp; + /*snd_pcm_runtime_t *runtime = substream->runtime;*/ +#ifdef CONFIG_SND_CS46XX_NEW_DSP + cs46xx_pcm_t *cpcm = snd_magic_cast(cs46xx_pcm_t, substream->runtime->private_data, return -ENXIO); +#endif int result = 0; spin_lock(&chip->reg_lock); +#ifdef CONFIG_SND_CS46XX_NEW_DSP + if (! cpcm->pcm_channel) { + spin_unlock(&chip->reg_lock); + return -ENXIO; + } +#endif switch (cmd) { case SNDRV_PCM_TRIGGER_START: case SNDRV_PCM_TRIGGER_RESUME: if (substream->runtime->periods != CS46XX_FRAGS) snd_cs46xx_playback_transfer(substream, 0); +#ifdef CONFIG_SND_CS46XX_NEW_DSP + if (cpcm->pcm_channel->unlinked) + cs46xx_dsp_pcm_link(chip,cpcm->pcm_channel); +#else + { unsigned int tmp; tmp = snd_cs46xx_peek(chip, BA1_PCTL); tmp &= 0x0000ffff; - snd_cs46xx_poke(chip, BA1_PCTL, chip->play.ctl | tmp); + snd_cs46xx_poke(chip, BA1_PCTL, chip->play_ctl | tmp); + } +#endif break; case SNDRV_PCM_TRIGGER_STOP: case SNDRV_PCM_TRIGGER_SUSPEND: +#ifdef CONFIG_SND_CS46XX_NEW_DSP + if (!cpcm->pcm_channel->unlinked) + cs46xx_dsp_pcm_unlink(chip,cpcm->pcm_channel); +#else + { unsigned int tmp; tmp = snd_cs46xx_peek(chip, BA1_PCTL); tmp &= 0x0000ffff; snd_cs46xx_poke(chip, BA1_PCTL, tmp); + } +#endif break; default: result = -EINVAL; @@ -862,19 +946,22 @@ static int snd_cs46xx_playback_hw_params(snd_pcm_substream_t * substream, snd_pcm_hw_params_t * hw_params) { - cs46xx_t *chip = snd_pcm_substream_chip(substream); + /*cs46xx_t *chip = snd_pcm_substream_chip(substream);*/ snd_pcm_runtime_t *runtime = substream->runtime; + cs46xx_pcm_t *cpcm; int err; + cpcm = snd_magic_cast(cs46xx_pcm_t, runtime->private_data, return -ENXIO); + if (params_periods(hw_params) == CS46XX_FRAGS) { - if (runtime->dma_area != chip->play.hw_area) + if (runtime->dma_area != cpcm->hw_area) snd_pcm_lib_free_pages(substream); - runtime->dma_area = chip->play.hw_area; - runtime->dma_addr = chip->play.hw_addr; - runtime->dma_bytes = chip->play.hw_size; + runtime->dma_area = cpcm->hw_area; + runtime->dma_addr = cpcm->hw_addr; + runtime->dma_bytes = cpcm->hw_size; substream->ops = &snd_cs46xx_playback_ops; } else { - if (runtime->dma_area == chip->play.hw_area) { + if (runtime->dma_area == cpcm->hw_area) { runtime->dma_area = NULL; runtime->dma_addr = 0; runtime->dma_bytes = 0; @@ -888,11 +975,15 @@ static int snd_cs46xx_playback_hw_free(snd_pcm_substream_t * substream) { - cs46xx_t *chip = snd_pcm_substream_chip(substream); + /*cs46xx_t *chip = snd_pcm_substream_chip(substream);*/ snd_pcm_runtime_t *runtime = substream->runtime; + cs46xx_pcm_t *cpcm; - if (runtime->dma_area != chip->play.hw_area) + cpcm = snd_magic_cast(cs46xx_pcm_t, runtime->private_data, return -ENXIO); + + if (runtime->dma_area != cpcm->hw_area) snd_pcm_lib_free_pages(substream); + runtime->dma_area = NULL; runtime->dma_addr = 0; runtime->dma_bytes = 0; @@ -905,39 +996,92 @@ unsigned int pfie; cs46xx_t *chip = snd_pcm_substream_chip(substream); snd_pcm_runtime_t *runtime = substream->runtime; + cs46xx_pcm_t *cpcm; - pfie = snd_cs46xx_peek(chip, BA1_PFIE); + cpcm = snd_magic_cast(cs46xx_pcm_t, runtime->private_data, return -ENXIO); + +#ifdef CONFIG_SND_CS46XX_NEW_DSP + down (&chip->dsp_spos_instance->pcm_mutex); + if ( cpcm->pcm_channel->src_scb->ref_count == 1 && + cpcm->pcm_channel->sample_rate != runtime->rate) { + /* sample rate not set or we can reuse + the same SRC*/ + + cs46xx_dsp_set_src_sample_rate (chip,cpcm->pcm_channel->src_scb,runtime->rate); + cpcm->pcm_channel->sample_rate = runtime->rate; + } + up (&chip->dsp_spos_instance->pcm_mutex); + + if (cpcm->pcm_channel->sample_rate != runtime->rate && + cpcm->pcm_channel->src_scb->ref_count != 1) { + cs46xx_dsp_destroy_pcm_channel (chip,cpcm->pcm_channel); + + if ( (cpcm->pcm_channel = cs46xx_dsp_create_pcm_channel (chip,runtime->rate,cpcm)) == NULL) { + snd_printk(KERN_ERR "cs46xx: failed to re-create virtual PCM channel\n"); + return -ENXIO; + } + + cs46xx_dsp_pcm_unlink (chip,cpcm->pcm_channel); + cpcm->pcm_channel->sample_rate = runtime->rate; + } + + pfie = snd_cs46xx_peek(chip, (cpcm->pcm_channel->pcm_reader_scb->address + 1) << 2 ); pfie &= ~0x0000f03f; +#else + /* old dsp */ + pfie = snd_cs46xx_peek(chip, BA1_PFIE); + pfie &= ~0x0000f03f; +#endif - chip->play.shift = 2; + cpcm->shift = 2; + /* if to convert from stereo to mono */ if (runtime->channels == 1) { - chip->play.shift--; + cpcm->shift--; pfie |= 0x00002000; } + /* if to convert from 8 bit to 16 bit */ if (snd_pcm_format_width(runtime->format) == 8) { - chip->play.shift--; + cpcm->shift--; pfie |= 0x00001000; } + /* if to convert to unsigned */ if (snd_pcm_format_unsigned(runtime->format)) pfie |= 0x00008000; - if (snd_pcm_format_big_endian(runtime->format)) - pfie |= 0x00004000; + /* Never convert byte order when sample stream is 8 bit */ + if (snd_pcm_format_width(runtime->format) != 8) { + /* convert from big endian to little endian */ + if (snd_pcm_format_big_endian(runtime->format)) + pfie |= 0x00004000; + } - chip->play.sw_bufsize = snd_pcm_lib_buffer_bytes(substream); - chip->play.sw_data = chip->play.sw_io = chip->play.sw_ready = 0; - chip->play.hw_data = chip->play.hw_io = chip->play.hw_ready = 0; - chip->play.appl_ptr = 0; - snd_cs46xx_poke(chip, BA1_PBA, chip->play.hw_addr); + cpcm->sw_bufsize = snd_pcm_lib_buffer_bytes(substream); + cpcm->sw_data = cpcm->sw_io = cpcm->sw_ready = 0; + cpcm->hw_data = cpcm->hw_io = cpcm->hw_ready = 0; + cpcm->appl_ptr = 0; + +#ifdef CONFIG_SND_CS46XX_NEW_DSP + /* playback address */ + snd_cs46xx_poke(chip, (cpcm->pcm_channel->pcm_reader_scb->address + 2) << 2, cpcm->hw_addr); + tmp = snd_cs46xx_peek(chip, (cpcm->pcm_channel->pcm_reader_scb->address) << 2); + tmp &= ~0x000003ff; + tmp |= (4 << cpcm->shift) - 1; + /* playback transaction count register */ + snd_cs46xx_poke(chip, (cpcm->pcm_channel->pcm_reader_scb->address) << 2, tmp); + + /* playback format && interrupt enable */ + snd_cs46xx_poke(chip, (cpcm->pcm_channel->pcm_reader_scb->address + 1) << 2, pfie | cpcm->pcm_channel->pcm_slot); +#else + snd_cs46xx_poke(chip, BA1_PBA, cpcm->hw_addr); tmp = snd_cs46xx_peek(chip, BA1_PDTC); tmp &= ~0x000003ff; - tmp |= (4 << chip->play.shift) - 1; + tmp |= (4 << cpcm->shift) - 1; snd_cs46xx_poke(chip, BA1_PDTC, tmp); - snd_cs46xx_poke(chip, BA1_PFIE, pfie); - snd_cs46xx_set_play_sample_rate(chip, runtime->rate); +#endif + return 0; } @@ -999,26 +1143,68 @@ static void snd_cs46xx_interrupt(int irq, void *dev_id, struct pt_regs *regs) { cs46xx_t *chip = snd_magic_cast(cs46xx_t, dev_id, return); - unsigned int status; + u32 status1; +#ifdef CONFIG_SND_CS46XX_NEW_DSP + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + u32 status2; + int i; + cs46xx_pcm_t *cpcm = NULL; +#endif /* * Read the Interrupt Status Register to clear the interrupt */ - status = snd_cs46xx_peekBA0(chip, BA0_HISR); - if ((status & 0x7fffffff) == 0) { + status1 = snd_cs46xx_peekBA0(chip, BA0_HISR); + if ((status1 & 0x7fffffff) == 0) { snd_cs46xx_pokeBA0(chip, BA0_HICR, HICR_CHGM | HICR_IEV); return; } - if ((status & HISR_VC0) && chip->pcm) { - if (chip->play.substream) - snd_pcm_period_elapsed(chip->play.substream); +#ifdef CONFIG_SND_CS46XX_NEW_DSP + status2 = snd_cs46xx_peekBA0(chip, BA0_HSR0); + for (i = 0; i < DSP_MAX_PCM_CHANNELS; ++i) { + if (i <= 15) { + if ( status1 & (1 << i) ) { + if (i == 1) { + if (chip->capt.substream) + snd_pcm_period_elapsed(chip->capt.substream); + } else { + if (ins->pcm_channels[i].active && + ins->pcm_channels[i].private_data && + !ins->pcm_channels[i].unlinked) { + cpcm = snd_magic_cast(cs46xx_pcm_t, ins->pcm_channels[i].private_data, goto _invalid_pointer); + snd_pcm_period_elapsed(cpcm->substream); + } + } + } + } else { + if ( status2 & (1 << (i - 16))) { + if (ins->pcm_channels[i].active && + ins->pcm_channels[i].private_data && + !ins->pcm_channels[i].unlinked) { + cpcm = snd_magic_cast(cs46xx_pcm_t, ins->pcm_channels[i].private_data, goto _invalid_pointer); + snd_pcm_period_elapsed(cpcm->substream); + } + } + } + + continue; + _invalid_pointer: + printk (KERN_ERR "cs46xx: (interrupt) invalid pointer at pcm_channel[%d]\n",i); + } +#else + /* old dsp */ + if ((status1 & HISR_VC0) && chip->playback_pcm) { + if (chip->playback_pcm->substream) + snd_pcm_period_elapsed(chip->playback_pcm->substream); } - if ((status & HISR_VC1) && chip->pcm) { + if ((status1 & HISR_VC1) && chip->pcm) { if (chip->capt.substream) snd_pcm_period_elapsed(chip->capt.substream); } - if ((status & HISR_MIDI) && chip->rmidi) { +#endif + + if ((status1 & HISR_MIDI) && chip->rmidi) { unsigned char c; spin_lock(&chip->reg_lock); @@ -1088,14 +1274,49 @@ .fifo_size = 0, }; +static void snd_cs46xx_pcm_free_substream(snd_pcm_runtime_t *runtime) +{ + cs46xx_pcm_t * cpcm = snd_magic_cast(cs46xx_pcm_t, runtime->private_data, return); + + if (cpcm) + snd_magic_kfree(cpcm); +} + static int snd_cs46xx_playback_open(snd_pcm_substream_t * substream) { cs46xx_t *chip = snd_pcm_substream_chip(substream); + cs46xx_pcm_t * cpcm; + snd_pcm_runtime_t *runtime = substream->runtime; + + cpcm = snd_magic_kcalloc(cs46xx_pcm_t, 0, GFP_KERNEL); + if (cpcm == NULL) + return -ENOMEM; + cpcm->hw_size = PAGE_SIZE; + if ((cpcm->hw_area = snd_malloc_pci_pages(chip->pci, cpcm->hw_size, &cpcm->hw_addr)) == NULL) { + snd_magic_kfree(cpcm); + return -ENOMEM; + } - if ((chip->play.hw_area = snd_malloc_pci_pages(chip->pci, chip->play.hw_size, &chip->play.hw_addr)) == NULL) + runtime->hw = snd_cs46xx_playback; + runtime->private_data = cpcm; + runtime->private_free = snd_cs46xx_pcm_free_substream; + + cpcm->substream = substream; +#ifdef CONFIG_SND_CS46XX_NEW_DSP + cpcm->pcm_channel = cs46xx_dsp_create_pcm_channel (chip,runtime->rate,cpcm); + + if (cpcm->pcm_channel == NULL) { + snd_printk(KERN_ERR "cs46xx: failed to create virtual PCM channel\n"); + snd_free_pci_pages(chip->pci, cpcm->hw_size, cpcm->hw_area, cpcm->hw_addr); + snd_magic_kfree(cpcm); return -ENOMEM; - chip->play.substream = substream; - substream->runtime->hw = snd_cs46xx_playback; + } + + cs46xx_dsp_pcm_unlink (chip,cpcm->pcm_channel); +#else + chip->playback_pcm = cpcm; /* HACK */ +#endif + if (chip->accept_valid) substream->runtime->hw.info |= SNDRV_PCM_INFO_MMAP_VALID; chip->active_ctrl(chip, 1); @@ -1121,9 +1342,22 @@ static int snd_cs46xx_playback_close(snd_pcm_substream_t * substream) { cs46xx_t *chip = snd_pcm_substream_chip(substream); + snd_pcm_runtime_t *runtime = substream->runtime; + cs46xx_pcm_t * cpcm; + + cpcm = snd_magic_cast(cs46xx_pcm_t, runtime->private_data, return -ENXIO); + +#ifdef CONFIG_SND_CS46XX_NEW_DSP + if (cpcm->pcm_channel) { + cs46xx_dsp_destroy_pcm_channel(chip,cpcm->pcm_channel); + cpcm->pcm_channel = NULL; + } +#else + chip->playback_pcm = NULL; +#endif - chip->play.substream = NULL; - snd_free_pci_pages(chip->pci, chip->play.hw_size, chip->play.hw_area, chip->play.hw_addr); + cpcm->substream = NULL; + snd_free_pci_pages(chip->pci, cpcm->hw_size, cpcm->hw_area, cpcm->hw_addr); chip->active_ctrl(chip, -1); chip->amplifier_ctrl(chip, -1); return 0; @@ -1193,6 +1427,12 @@ snd_pcm_lib_preallocate_free_for_all(pcm); } +#ifdef CONFIG_SND_CS46XX_NEW_DSP +#define MAX_PLAYBACK_CHANNELS (DSP_MAX_PCM_CHANNELS - 1) +#else +#define MAX_PLAYBACK_CHANNELS 1 +#endif + int __devinit snd_cs46xx_pcm(cs46xx_t *chip, int device, snd_pcm_t ** rpcm) { snd_pcm_t *pcm; @@ -1200,7 +1440,7 @@ if (rpcm) *rpcm = NULL; - if ((err = snd_pcm_new(chip->card, "CS46xx", device, 1, 1, &pcm)) < 0) + if ((err = snd_pcm_new(chip->card, "CS46xx", device, MAX_PLAYBACK_CHANNELS, 1, &pcm)) < 0) return err; pcm->private_data = chip; pcm->private_free = snd_cs46xx_pcm_free; @@ -1227,8 +1467,17 @@ static void snd_cs46xx_mixer_free_ac97(ac97_t *ac97) { cs46xx_t *chip = snd_magic_cast(cs46xx_t, ac97->private_data, return); - chip->ac97 = NULL; - chip->eapd_switch = NULL; + + snd_assert ((ac97 == chip->ac97[CS46XX_PRIMARY_CODEC_INDEX]) || + (ac97 == chip->ac97[CS46XX_SECONDARY_CODEC_INDEX]), + return); + + if (ac97 == chip->ac97[CS46XX_PRIMARY_CODEC_INDEX]) { + chip->ac97[CS46XX_PRIMARY_CODEC_INDEX] = NULL; + chip->eapd_switch = NULL; + } + else + chip->ac97[CS46XX_SECONDARY_CODEC_INDEX] = NULL; } static int snd_cs46xx_vol_info(snd_kcontrol_t *kcontrol, @@ -1264,6 +1513,41 @@ return change; } +#ifdef CONFIG_SND_CS46XX_NEW_DSP + +static int snd_cs46xx_iec958_info(snd_kcontrol_t *kcontrol, + snd_ctl_elem_info_t *uinfo) +{ + uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; + uinfo->count = 1; + uinfo->value.integer.min = 0; + uinfo->value.integer.max = 1; + return 0; +} + +static int snd_cs46xx_iec958_get(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) +{ + cs46xx_t *chip = snd_kcontrol_chip(kcontrol); + ucontrol->value.integer.value[0] = chip->dsp_spos_instance->spdif_status_out; + return 0; +} + +static int snd_cs46xx_iec958_put(snd_kcontrol_t *kcontrol, + snd_ctl_elem_value_t *ucontrol) +{ + cs46xx_t *chip = snd_kcontrol_chip(kcontrol); + int change = chip->dsp_spos_instance->spdif_status_out; + + if (ucontrol->value.integer.value[0] && !change) + cs46xx_dsp_enable_spdif_out(chip); + else if (change) + cs46xx_dsp_disable_spdif_out(chip); + return (change != chip->dsp_spos_instance->spdif_status_out); +} + +#endif /* CONFIG_SND_CS46XX_NEW_DSP */ + static snd_kcontrol_new_t snd_cs46xx_controls[] __devinitdata = { { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, @@ -1280,7 +1564,17 @@ .get = snd_cs46xx_vol_get, .put = snd_cs46xx_vol_put, .private_value = BA1_CVOL, -}}; +}, +#ifdef CONFIG_SND_CS46XX_NEW_DSP +{ + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "IEC 958 output", + .info = snd_cs46xx_iec958_info, + .get = snd_cs46xx_iec958_get, + .put = snd_cs46xx_iec958_put, +}, +#endif + }; int __devinit snd_cs46xx_mixer(cs46xx_t *chip) { @@ -1290,12 +1584,17 @@ int err; int idx; + /* detect primary codec */ + chip->nr_ac97_codecs = 0; + snd_printdd("snd_cs46xx: detecting primary codec\n"); memset(&ac97, 0, sizeof(ac97)); ac97.write = snd_cs46xx_ac97_write; ac97.read = snd_cs46xx_ac97_read; ac97.private_data = chip; ac97.private_free = snd_cs46xx_mixer_free_ac97; + chip->ac97[CS46XX_PRIMARY_CODEC_INDEX] = &ac97; + snd_cs46xx_ac97_write(&ac97, AC97_MASTER, 0x8000); for (idx = 0; idx < 100; ++idx) { if (snd_cs46xx_ac97_read(&ac97, AC97_MASTER) == 0x8000) @@ -1303,11 +1602,60 @@ set_current_state(TASK_INTERRUPTIBLE); schedule_timeout(HZ/100); } + chip->ac97[CS46XX_PRIMARY_CODEC_INDEX] = NULL; return -ENXIO; _ok: - if ((err = snd_ac97_mixer(card, &ac97, &chip->ac97)) < 0) + if ((err = snd_ac97_mixer(card, &ac97, &chip->ac97[CS46XX_PRIMARY_CODEC_INDEX])) < 0) return err; + snd_printdd("snd_cs46xx: primary codec phase one\n"); + chip->nr_ac97_codecs = 1; + +#ifdef CONFIG_SND_CS46XX_NEW_DSP + snd_printdd("snd_cs46xx: detecting seconadry codec\n"); + /* try detect a secondary codec */ + memset(&ac97, 0, sizeof(ac97)); + ac97.write = snd_cs46xx_ac97_write; + ac97.read = snd_cs46xx_ac97_read; + ac97.private_data = chip; + ac97.private_free = snd_cs46xx_mixer_free_ac97; + ac97.num = CS46XX_SECONDARY_CODEC_INDEX; + + snd_cs46xx_ac97_write(&ac97, AC97_RESET, 0); + udelay(10); + + if (snd_cs46xx_ac97_read(&ac97, AC97_RESET) & 0x8000) { + snd_printdd("snd_cs46xx: seconadry codec not present\n"); + goto _no_sec_codec; + } + + chip->ac97[CS46XX_SECONDARY_CODEC_INDEX] = &ac97; + snd_cs46xx_ac97_write(&ac97, AC97_MASTER, 0x8000); + for (idx = 0; idx < 100; ++idx) { + if (snd_cs46xx_ac97_read(&ac97, AC97_MASTER) == 0x8000) { + goto _ok2; + } + set_current_state(TASK_INTERRUPTIBLE); + schedule_timeout(HZ/100); + } + + _no_sec_codec: + snd_printdd("snd_cs46xx: secondary codec did not respond ...\n"); + + chip->ac97[CS46XX_SECONDARY_CODEC_INDEX] = NULL; + chip->nr_ac97_codecs = 1; + + /* well, one codec only ... */ + goto _end; + _ok2: + if ((err = snd_ac97_mixer(card, &ac97, &chip->ac97[CS46XX_SECONDARY_CODEC_INDEX])) < 0) + return err; + chip->nr_ac97_codecs = 2; + + /* add cs4630 mixer controls */ + _end: +#endif /* CONFIG_SND_CS46XX_NEW_DSP */ + for (idx = 0; idx < sizeof(snd_cs46xx_controls) / sizeof(snd_cs46xx_controls[0]); idx++) { snd_kcontrol_t *kctl; @@ -1652,6 +2000,9 @@ } region->proc_entry = entry; } +#ifdef CONFIG_SND_CS46XX_NEW_DSP + cs46xx_dsp_proc_init(card, chip); +#endif return 0; } @@ -1666,6 +2017,9 @@ region->proc_entry = NULL; } } +#ifdef CONFIG_SND_CS46XX_NEW_DSP + cs46xx_dsp_proc_done(chip); +#endif return 0; } @@ -1761,6 +2115,9 @@ if (chip->active_ctrl) chip->active_ctrl(chip, -chip->amplifier); +#ifdef CONFIG_SND_CS46XX_NEW_DSP + cs46xx_dsp_spos_destroy(chip->dsp_spos_instance); +#endif snd_magic_kfree(chip); return 0; } @@ -1792,8 +2149,13 @@ * If we are in AC97 mode, then we must set the part to a host controlled * AC-link. Otherwise, we won't be able to bring up the link. */ - snd_cs46xx_pokeBA0(chip, BA0_SERACC, SERACC_HSP | SERACC_CHIP_TYPE_1_03); /* 1.03 codec */ - /* snd_cs46xx_pokeBA0(chip, BA0_SERACC, SERACC_HSP | SERACC_CHIP_TYPE_2_0); */ /* 2.00 codec */ +#ifdef CONFIG_SND_CS46XX_NEW_DSP + snd_cs46xx_pokeBA0(chip, BA0_SERACC, SERACC_HSP | SERACC_CHIP_TYPE_2_0 | + SERACC_TWO_CODECS); /* 2.00 dual codecs */ + /* snd_cs46xx_pokeBA0(chip, BA0_SERACC, SERACC_HSP | SERACC_CHIP_TYPE_2_0); */ /* 2.00 codec */ +#else + snd_cs46xx_pokeBA0(chip, BA0_SERACC, SERACC_HSP | SERACC_CHIP_TYPE_1_03); /* 1.03 codec */ +#endif /* * Drive the ARST# pin low for a minimum of 1uS (as defined in the AC97 @@ -1801,23 +2163,32 @@ * there might be logic external to the CS461x that uses the ARST# line * for a reset. */ - snd_cs46xx_pokeBA0(chip, BA0_ACCTL, 0); - udelay(50); - snd_cs46xx_pokeBA0(chip, BA0_ACCTL, ACCTL_RSTN); - + snd_cs46xx_pokeBA0(chip, BA0_ACCTL, 0); +#ifdef CONFIG_SND_CS46XX_NEW_DSP + snd_cs46xx_pokeBA0(chip, BA0_ACCTL2, 0); +#endif + udelay(50); + snd_cs46xx_pokeBA0(chip, BA0_ACCTL, ACCTL_RSTN); +#ifdef CONFIG_SND_CS46XX_NEW_DSP + snd_cs46xx_pokeBA0(chip, BA0_ACCTL2, ACCTL_RSTN); +#endif + /* * The first thing we do here is to enable sync generation. As soon * as we start receiving bit clock, we'll start producing the SYNC * signal. */ snd_cs46xx_pokeBA0(chip, BA0_ACCTL, ACCTL_ESYN | ACCTL_RSTN); +#ifdef CONFIG_SND_CS46XX_NEW_DSP + snd_cs46xx_pokeBA0(chip, BA0_ACCTL2, ACCTL_ESYN | ACCTL_RSTN); +#endif /* * Now wait for a short while to allow the AC97 part to start * generating bit clock (so we don't try to start the PLL without an * input clock). */ - mdelay(1); + mdelay(10); /* * Set the serial port timing configuration, so that @@ -1842,7 +2213,7 @@ /* * Wait until the PLL has stabilized. */ - mdelay(1); + mdelay(100); /* FIXME: schedule? */ /* * Turn on clocking of the core so that we can setup the serial ports. @@ -1867,6 +2238,16 @@ snd_cs46xx_pokeBA0(chip, BA0_SERC2, SERC2_SI1F_AC97 | SERC1_SO1EN); snd_cs46xx_pokeBA0(chip, BA0_SERMC1, SERMC1_PTC_AC97 | SERMC1_MSPE); +#ifdef CONFIG_SND_CS46XX_NEW_DSP + snd_cs46xx_pokeBA0(chip, BA0_SERC7, SERC7_ASDI2EN); + snd_cs46xx_pokeBA0(chip, BA0_SERC3, 0); + snd_cs46xx_pokeBA0(chip, BA0_SERC4, 0); + snd_cs46xx_pokeBA0(chip, BA0_SERC5, 0); + snd_cs46xx_pokeBA0(chip, BA0_SERC6, 1); +#endif + + mdelay(5); + /* * Wait for the codec ready signal from the AC97 codec. */ @@ -1889,14 +2270,35 @@ snd_printk("create - never read codec ready from AC'97\n"); snd_printk("it is not probably bug, try to use CS4236 driver\n"); - snd_cs46xx_free(chip); return -EIO; ok1: +#ifdef CONFIG_SND_CS46XX_NEW_DSP + { + int count; + for (count = 0; count < 150; count++) { + /* First, we want to wait for a short time. */ + udelay(25); + + if (snd_cs46xx_peekBA0(chip, BA0_ACSTS2) & ACSTS_CRDY) + break; + } + + /* + * Make sure CODEC is READY. + */ + if (!(snd_cs46xx_peekBA0(chip, BA0_ACSTS2) & ACSTS_CRDY)) + snd_printdd("cs46xx: never read card ready from secondary AC'97\n"); + } +#endif + /* * Assert the vaid frame signal so that we can start sending commands * to the AC97 codec. */ snd_cs46xx_pokeBA0(chip, BA0_ACCTL, ACCTL_VFRM | ACCTL_ESYN | ACCTL_RSTN); +#ifdef CONFIG_SND_CS46XX_NEW_DSP + snd_cs46xx_pokeBA0(chip, BA0_ACCTL2, ACCTL_VFRM | ACCTL_ESYN | ACCTL_RSTN); +#endif /* * Wait until we've sampled input slots 3 and 4 as valid, meaning that @@ -1919,7 +2321,6 @@ } snd_printk("create - never read ISV3 & ISV4 from AC'97\n"); - snd_cs46xx_free(chip); return -EIO; ok2: @@ -1927,7 +2328,7 @@ * Now, assert valid frame and the slot 3 and 4 valid bits. This will * commense the transfer of digital audio data to the AC97 codec. */ - snd_cs46xx_pokeBA0(chip, BA0_ACOSV, ACOSV_SLV3 | ACOSV_SLV4); + snd_cs46xx_pokeBA0(chip, BA0_ACOSV, ACOSV_SLV3 | ACOSV_SLV4 | ACOSV_SLV7 | ACOSV_SLV8); /* * Power down the DAC and ADC. We will power them up (if) when we need @@ -1950,9 +2351,41 @@ /* * Download the image to the processor. */ +#ifdef CONFIG_SND_CS46XX_NEW_DSP +#if 0 + if (cs46xx_dsp_load_module(chip, &cwcemb80_module) < 0) { + snd_printk(KERN_ERR "image download error\n"); + return -EIO; + } +#endif + + if (cs46xx_dsp_load_module(chip, &cwc4630_module) < 0) { + snd_printk(KERN_ERR "image download error [cwc4630]\n"); + return -EIO; + } + + if (cs46xx_dsp_load_module(chip, &cwcasync_module) < 0) { + snd_printk(KERN_ERR "image download error [cwcasync]\n"); + return -EIO; + } + + if (cs46xx_dsp_load_module(chip, &cwcsnoop_module) < 0) { + snd_printk(KERN_ERR "image download error [cwcsnoop]\n"); + return -EIO; + } + + if (cs46xx_dsp_load_module(chip, &cwcbinhack_module) < 0) { + snd_printk(KERN_ERR "image download error [cwcbinhack]\n"); + return -EIO; + } + + if (cs46xx_dsp_scb_and_task_init(chip) < 0) + return -EIO; + snd_printdd("[get here]\n"); +#else + /* old image */ if (snd_cs46xx_download_image(chip) < 0) { snd_printk("image download error\n"); - snd_cs46xx_free(chip); return -EIO; } @@ -1960,8 +2393,9 @@ * Stop playback DMA. */ tmp = snd_cs46xx_peek(chip, BA1_PCTL); - chip->play.ctl = tmp & 0xffff0000; + chip->play_ctl = tmp & 0xffff0000; snd_cs46xx_poke(chip, BA1_PCTL, tmp & 0x0000ffff); +#endif /* * Stop capture DMA. @@ -1970,6 +2404,8 @@ chip->capt.ctl = tmp & 0x0000ffff; snd_cs46xx_poke(chip, BA1_CCTL, tmp & 0xffff0000); + mdelay(5); + snd_cs46xx_set_play_sample_rate(chip, 8000); snd_cs46xx_set_capture_sample_rate(chip, 8000); @@ -1993,6 +2429,12 @@ snd_cs46xx_poke(chip, BA1_PVOL, 0x80008000); snd_cs46xx_poke(chip, BA1_CVOL, 0x80008000); +#ifdef CONFIG_SND_CS46XX_NEW_DSP + /* mute spdif out */ + cs46xx_dsp_disable_spdif_out(chip); + cs46xx_dsp_disable_spdif_in(chip); +#endif + return 0; } @@ -2018,7 +2460,8 @@ int oval, val; chip->amplifier += change; - oval = snd_cs46xx_codec_read(chip, AC97_POWERDOWN); + oval = snd_cs46xx_codec_read(chip, AC97_POWERDOWN, + CS46XX_PRIMARY_CODEC_INDEX); val = oval; if (chip->amplifier && !old) { /* Turn the EAPD amp on */ @@ -2028,7 +2471,8 @@ val &= ~0x8000; } if (val != oval) { - snd_cs46xx_codec_write(chip, AC97_POWERDOWN, val); + snd_cs46xx_codec_write(chip, AC97_POWERDOWN, val, + CS46XX_PRIMARY_CODEC_INDEX); if (chip->eapd_switch) snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, &chip->eapd_switch->id); @@ -2222,7 +2666,7 @@ mdelay(5); #endif - snd_ac97_resume(chip->ac97); + snd_ac97_resume(chip->ac97[CS46XX_PRIMARY_CODEC_INDEX]); if (amp_saved) chip->amplifier_ctrl(chip, 1); /* try to turn on */ @@ -2286,7 +2730,6 @@ spin_lock_init(&chip->reg_lock); chip->card = card; chip->pci = pci; - chip->play.hw_size = PAGE_SIZE; chip->capt.hw_size = PAGE_SIZE; chip->irq = -1; chip->ba0_addr = pci_resource_start(pci, 0); @@ -2378,6 +2821,14 @@ return -EBUSY; } chip->irq = pci->irq; + +#ifdef CONFIG_SND_CS46XX_NEW_DSP + chip->dsp_spos_instance = cs46xx_dsp_spos_create(chip); + if (chip->dsp_spos_instance == NULL) { + snd_cs46xx_free(chip); + return -ENOMEM; + } +#endif err = snd_cs46xx_chip_init(chip, 0); if (err < 0) { diff -Nru a/sound/pci/cs46xx/cs46xx_lib.h b/sound/pci/cs46xx/cs46xx_lib.h --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/sound/pci/cs46xx/cs46xx_lib.h Sun Sep 29 20:23:44 2002 @@ -0,0 +1,191 @@ +/* + * The driver for the Cirrus Logic's Sound Fusion CS46XX based soundcards + * Copyright (c) by Jaroslav Kysela + * + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#ifndef __CS46XX_LIB_H__ +#define __CS46XX_LIB_H__ + +#define chip_t cs46xx_t + +/* + * constants + */ + +#define CS46XX_BA0_SIZE 0x1000 +#define CS46XX_BA1_DATA0_SIZE 0x3000 +#define CS46XX_BA1_DATA1_SIZE 0x3800 +#define CS46XX_BA1_PRG_SIZE 0x7000 +#define CS46XX_BA1_REG_SIZE 0x0100 + + +#define CS46XX_PERIOD_SIZE 2048 +#define CS46XX_FRAGS 2 +#define CS46XX_BUFFER_SIZE CS46XX_PERIOD_SIZE * CS46XX_FRAGS + +#define SCB_NO_PARENT 0 +#define SCB_ON_PARENT_NEXT_SCB 1 +#define SCB_ON_PARENT_SUBLIST_SCB 2 + +/* 3*1024 parameter, 3.5*1024 sample, 2*3.5*1024 code */ +#define BA1_DWORD_SIZE (13 * 1024 + 512) +#define BA1_MEMORY_COUNT 3 + +extern snd_pcm_ops_t snd_cs46xx_playback_ops; +extern snd_pcm_ops_t snd_cs46xx_playback_indirect_ops; +extern snd_pcm_ops_t snd_cs46xx_capture_ops; +extern snd_pcm_ops_t snd_cs46xx_capture_indirect_ops; + + +/* + * common I/O routines + */ + +static inline void snd_cs46xx_poke(cs46xx_t *chip, unsigned long reg, unsigned int val) +{ + unsigned int bank = reg >> 16; + unsigned int offset = reg & 0xffff; + + /*if (bank == 0) printk("snd_cs46xx_poke: %04X - %08X\n",reg >> 2,val); */ + writel(val, chip->region.idx[bank+1].remap_addr + offset); +} + +static inline unsigned int snd_cs46xx_peek(cs46xx_t *chip, unsigned long reg) +{ + unsigned int bank = reg >> 16; + unsigned int offset = reg & 0xffff; + return readl(chip->region.idx[bank+1].remap_addr + offset); +} + +static inline void snd_cs46xx_pokeBA0(cs46xx_t *chip, unsigned long offset, unsigned int val) +{ + writel(val, chip->region.name.ba0.remap_addr + offset); +} + +static inline unsigned int snd_cs46xx_peekBA0(cs46xx_t *chip, unsigned long offset) +{ + return readl(chip->region.name.ba0.remap_addr + offset); +} + +dsp_spos_instance_t * cs46xx_dsp_spos_create (cs46xx_t * chip); +void cs46xx_dsp_spos_destroy (dsp_spos_instance_t * instance); +int cs46xx_dsp_load_module (cs46xx_t * chip,dsp_module_desc_t * module); +symbol_entry_t * cs46xx_dsp_lookup_symbol (cs46xx_t * chip,char * symbol_name,int symbol_type); +symbol_entry_t * cs46xx_dsp_lookup_symbol_addr (cs46xx_t * chip,u32 address,int symbol_type); +int cs46xx_dsp_proc_init (snd_card_t * card, cs46xx_t *chip); +int cs46xx_dsp_proc_done (cs46xx_t *chip); +int cs46xx_dsp_scb_and_task_init (cs46xx_t *chip); +int cs46xx_dsp_async_init (cs46xx_t *chip,dsp_scb_descriptor_t * fg_entry); +int snd_cs46xx_download (cs46xx_t *chip,u32 *src,unsigned long offset, + unsigned long len); +int snd_cs46xx_clear_BA1(cs46xx_t *chip,unsigned long offset,unsigned long len); +int cs46xx_dsp_enable_spdif_out (cs46xx_t *chip); +int cs46xx_dsp_disable_spdif_out (cs46xx_t *chip); +int cs46xx_dsp_enable_spdif_in (cs46xx_t *chip); +int cs46xx_dsp_disable_spdif_in (cs46xx_t *chip); +int cs46xx_poke_via_dsp (cs46xx_t *chip,u32 address,u32 data); +dsp_scb_descriptor_t * cs46xx_dsp_create_scb (cs46xx_t *chip,char * name, u32 * scb_data,u32 dest); +void cs46xx_dsp_proc_free_scb_desc (dsp_scb_descriptor_t * scb); +void cs46xx_dsp_proc_register_scb_desc (cs46xx_t *chip,dsp_scb_descriptor_t * scb); +dsp_task_descriptor_t * cs46xx_dsp_create_task_tree (cs46xx_t *chip,char * name, + u32 * task_data,u32 dest,int size); +dsp_scb_descriptor_t * cs46xx_dsp_create_timing_master_scb (cs46xx_t *chip); +dsp_scb_descriptor_t * cs46xx_dsp_create_codec_out_scb(cs46xx_t * chip,char * codec_name, + u16 channel_disp,u16 fifo_addr, + u16 child_scb_addr, + u32 dest, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type); +dsp_scb_descriptor_t * cs46xx_dsp_create_codec_in_scb(cs46xx_t * chip,char * codec_name, + u16 channel_disp,u16 fifo_addr, + u16 sample_buffer_addr, + u32 dest, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type); +void cs46xx_dsp_remove_scb (cs46xx_t *chip,dsp_scb_descriptor_t * scb); +dsp_scb_descriptor_t * cs46xx_dsp_create_generic_scb (cs46xx_t *chip,char * name, + u32 * scb_data,u32 dest, + char * task_entry_name, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type); +dsp_scb_descriptor_t * cs46xx_dsp_create_codec_in_scb(cs46xx_t * chip,char * codec_name, + u16 channel_disp,u16 fifo_addr, + u16 sample_buffer_addr, + u32 dest,dsp_scb_descriptor_t * parent_scb, + int scb_child_type); +dsp_scb_descriptor_t * cs46xx_dsp_create_pcm_reader_scb(cs46xx_t * chip,char * scb_name, + u16 sample_buffer_addr,u32 dest, + int virtual_channel,u32 playback_hw_addr, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type); +dsp_scb_descriptor_t * cs46xx_dsp_create_src_task_scb(cs46xx_t * chip,char * scb_name, + u16 src_buffer_addr, + u16 src_delay_buffer_addr,u32 dest, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type); +dsp_scb_descriptor_t * cs46xx_dsp_create_mix_only_scb(cs46xx_t * chip,char * scb_name, + u16 mix_buffer_addr,u32 dest, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type); + +dsp_scb_descriptor_t * cs46xx_dsp_create_vari_decimate_scb(cs46xx_t * chip,char * scb_name, + u16 vari_buffer_addr0, + u16 vari_buffer_addr1, + u32 dest, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type); +dsp_scb_descriptor_t * cs46xx_dsp_create_pcm_serial_input_scb(cs46xx_t * chip,char * scb_name,u32 dest, + dsp_scb_descriptor_t * input_scb, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type); +dsp_scb_descriptor_t * cs46xx_dsp_create_asynch_fg_tx_scb(cs46xx_t * chip,char * scb_name,u32 dest, + u16 hfg_scb_address, + u16 asynch_buffer_address, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type); +dsp_scb_descriptor_t * cs46xx_dsp_create_asynch_fg_rx_scb(cs46xx_t * chip,char * scb_name,u32 dest, + u16 hfg_scb_address, + u16 asynch_buffer_address, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type); +dsp_scb_descriptor_t * cs46xx_dsp_create_spio_write_scb(cs46xx_t * chip,char * scb_name,u32 dest, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type); +dsp_scb_descriptor_t * cs46xx_dsp_create_mix_to_ostream_scb(cs46xx_t * chip,char * scb_name, + u16 mix_buffer_addr,u16 writeback_spb,u32 dest, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type); +dsp_scb_descriptor_t * cs46xx_dsp_create_output_snoop_scb(cs46xx_t * chip,char * scb_name,u32 dest, + u16 snoop_buffer_address, + dsp_scb_descriptor_t * snoop_scb, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type); +dsp_scb_descriptor_t * cs46xx_dsp_create_magic_snoop_scb(cs46xx_t * chip,char * scb_name,u32 dest, + u16 snoop_buffer_address, + dsp_scb_descriptor_t * snoop_scb, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type); +pcm_channel_descriptor_t * cs46xx_dsp_create_pcm_channel (cs46xx_t * chip,u32 sample_rate, void * private_data); +void cs46xx_dsp_destroy_pcm_channel (cs46xx_t * chip, + pcm_channel_descriptor_t * pcm_channel); +void cs46xx_dsp_set_src_sample_rate(cs46xx_t * chip,dsp_scb_descriptor_t * src, + u32 rate); +int cs46xx_dsp_pcm_unlink (cs46xx_t * chip,pcm_channel_descriptor_t * pcm_channel); +int cs46xx_dsp_pcm_link (cs46xx_t * chip,pcm_channel_descriptor_t * pcm_channel); +#endif /* __CS46XX_LIB_H__ */ diff -Nru a/sound/pci/cs46xx/dsp_spos.c b/sound/pci/cs46xx/dsp_spos.c --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/sound/pci/cs46xx/dsp_spos.c Sun Sep 29 20:23:44 2002 @@ -0,0 +1,1740 @@ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* + * 2002-07 Benny Sjostrand benny@hostmobility.com + */ + + +#define __NO_VERSION__ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "cs46xx_lib.h" +#include "dsp_spos.h" + +#if 0 +/* OBSOLETE NOW */ + +static void handle_goto (cs46xx_t * chip,u32 * hival,u32 * loval,char * format, u32 overlay_begin_address); + +typedef struct _dsp_opcode_desc_t { + u32 hival,loval; + u32 himask,lomask; + void (*handler_func)(cs46xx_t * chip,u32 * hival,u32 * loval,char * format, u32 overlay_begin_address); + char * format; +} dsp_opcode_desc_t; + +/* NOTE: theese opcodes are known needed to be reallocated, + there may be more. */ +dsp_opcode_desc_t dsp_opcodes[] = { + { 0x01000,0x02730, 0xFF000,0x07FFF,handle_goto,"goto %s" }, + { 0x01000,0x00730, 0xFF000,0x07FFF,handle_goto,"goto %s after" }, + { 0x01000,0x02630, 0xFF000,0x07FFF,handle_goto,"if (tb) goto %s" }, + { 0x01000,0x00630, 0xFF000,0x07FFF,handle_goto,"if (tb) goto %s after" }, + { 0x01000,0x00530, 0xFF000,0x07FFF,handle_goto,"if (lt) goto %s after" }, + { 0x01000,0x02530, 0xFF000,0x07FFF,handle_goto,"if (lt) goto %s" }, + { 0x01000,0x006B0, 0xFF000,0x07FFF,handle_goto,"if (!tb) goto %s after" }, + { 0x01000,0x026B0, 0xFF000,0x07FFF,handle_goto,"if (!tb) goto %s" }, + { 0x01000,0x00FB0, 0xFF000,0x07FFF,handle_goto,"if (gt) goto %s after" }, + { 0x01000,0x02FB0, 0xFF000,0x07FFF,handle_goto,"if (gt) goto %s" }, + { 0x01000,0x02734, 0xFF000,0x07FFF,NULL,"goto *ind" }, + { 0x01000,0x00734, 0xFF000,0x07FFF,NULL,"goto *ind after" }, + { 0x01000,0x02130, 0xFF000,0x07FFF,handle_goto,"if (N) goto %s" }, + { 0x01000,0x00130, 0xFF000,0x07FFF,handle_goto,"if (N) goto %s after" }, + { 0x01000,0x020F2, 0xFF000,0x07FFF,handle_goto,"tb = Z, if(!Z) goto %s" }, + { 0x01000,0x000F2, 0xFF000,0x07FFF,handle_goto,"tb = Z, if(!Z) goto %s after" }, + { 0x01000,0x04030, 0xFF000,0x07FFF,handle_goto,"if(Z) goto %s" }, + { 0x01000,0x00030, 0xFF000,0x07FFF,handle_goto,"if(Z) goto %s after" }, + { 0x01000,0x020B0, 0xFF000,0x07FFF,handle_goto,"if(!Z) goto %s" }, + { 0x01000,0x000B0, 0xFF000,0x07FFF,handle_goto,"if(!Z) goto %s after" }, + { 0x01000,0x02731, 0xFF000,0x07FFF,handle_goto,"%s();" }, +}; + +static void handle_goto (cs46xx_t * chip,u32 * hival,u32 * loval, + char * format, u32 overlay_begin_address) +{ + u32 address ; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + + address = (*hival & 0x00FFF) << 5; + address |= *loval >> 15; + + snd_printdd("handle_goto[1]: %05x:%05x addr %04x\n",*hival,*loval,address); + + if ( !(address & 0x8000) ) { + address += (ins->code.offset / 2) - overlay_begin_address; + } else { + snd_printdd("handle_goto[1]: ROM symbol not reallocated\n"); + } + + *hival &= 0xFF000; + *loval &= 0x07FFF; + + *hival |= ( (address >> 5) & 0x00FFF); + *loval |= ( (address << 15) & 0xF8000); + + address = (*hival & 0x00FFF) << 5; + address |= *loval >> 15; + + snd_printdd("handle_goto:[2] %05x:%05x addr %04x\n",*hival,*loval,address); +} +#endif /* #if 0 */ + +static wide_opcode_t wide_opcodes[] = { + WIDE_FOR_BEGIN_LOOP, + WIDE_FOR_BEGIN_LOOP2, + WIDE_COND_GOTO_ADDR, + WIDE_COND_GOTO_CALL, + WIDE_TBEQ_COND_GOTO_ADDR, + WIDE_TBEQ_COND_CALL_ADDR, + WIDE_TBEQ_NCOND_GOTO_ADDR, + WIDE_TBEQ_NCOND_CALL_ADDR, + WIDE_TBEQ_COND_GOTO1_ADDR, + WIDE_TBEQ_COND_CALL1_ADDR, + WIDE_TBEQ_NCOND_GOTOI_ADDR, + WIDE_TBEQ_NCOND_CALL1_ADDR +}; + +static int shadow_and_reallocate_code (cs46xx_t * chip,u32 * data,u32 size, u32 overlay_begin_address) +{ + int i = 0,j, nreallocated = 0; + u32 hival,loval,address; + u32 mop_operands,mop_type,wide_op; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + + snd_assert( ((size % 2) == 0), return -EINVAL); + + while (i < size) { + loval = data[i++]; + hival = data[i++]; + + if (ins->code.offset > 0) { +#if 0 + /* OBSOLETE NOW */ + for (j = 0;j < sizeof(dsp_opcodes) / sizeof(dsp_opcode_desc_t); ++j) { + if ( (hival & dsp_opcodes[j].himask) == dsp_opcodes[j].hival && + (loval & dsp_opcodes[j].lomask) == dsp_opcodes[j].loval && + dsp_opcodes[j].handler_func != NULL) { + dsp_opcodes[j].handler_func (chip,&hival,&loval,dsp_opcodes[j].format, overlay_begin_address); + nreallocated ++; + } + } +#endif + + mop_operands = (hival >> 6) & 0x03fff; + mop_type = mop_operands >> 10; + + /* check for wide type instruction */ + if (mop_type == 0 && + (mop_operands & WIDE_LADD_INSTR_MASK) == 0 && + (mop_operands & WIDE_INSTR_MASK) != 0) { + wide_op = loval & 0x7f; + for (j = 0;j < sizeof(wide_opcodes) / sizeof(wide_opcode_t); ++j) { + if (wide_opcodes[j] == wide_op) { + /* need to reallocate instruction */ + address = (hival & 0x00FFF) << 5; + address |= loval >> 15; + + snd_printdd("handle_wideop[1]: %05x:%05x addr %04x\n",hival,loval,address); + + if ( !(address & 0x8000) ) { + address += (ins->code.offset / 2) - overlay_begin_address; + } else { + snd_printdd("handle_wideop[1]: ROM symbol not reallocated\n"); + } + + hival &= 0xFF000; + loval &= 0x07FFF; + + hival |= ( (address >> 5) & 0x00FFF); + loval |= ( (address << 15) & 0xF8000); + + address = (hival & 0x00FFF) << 5; + address |= loval >> 15; + + snd_printdd("handle_wideop:[2] %05x:%05x addr %04x\n",hival,loval,address); + nreallocated ++; + } /* wide_opcodes[j] == wide_op */ + } /* for */ + } /* mod_type == 0 ... */ + } /* ins->code.offset > 0 */ + + ins->code.data[ins->code.size++] = loval; + ins->code.data[ins->code.size++] = hival; + } + + snd_printdd("dsp_spos: %d instructions reallocated\n",nreallocated); + return nreallocated; +} + +static segment_desc_t * get_segment_desc (dsp_module_desc_t * module, int seg_type) +{ + int i; + for (i = 0;i < module->nsegments; ++i) { + if (module->segments[i].segment_type == seg_type) { + return (module->segments + i); + } + } + + return NULL; +}; + +static int find_free_symbol_index (dsp_spos_instance_t * ins) +{ + int index = ins->symbol_table.nsymbols,i; + + for (i = ins->symbol_table.highest_frag_index; i < ins->symbol_table.nsymbols; ++i) { + if (ins->symbol_table.symbols[i].deleted) { + index = i; + break; + } + } + + return index; +} + +static int add_symbols (cs46xx_t * chip, dsp_module_desc_t * module) +{ + int i; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + + if (module->symbol_table.nsymbols > 0) { + if (!strcmp(module->symbol_table.symbols[0].symbol_name, "OVERLAYBEGINADDRESS") && + module->symbol_table.symbols[0].symbol_type == SYMBOL_CONSTANT ) { + module->overlay_begin_address = module->symbol_table.symbols[0].address; + } + } + + for (i = 0;i < module->symbol_table.nsymbols; ++i) { + if (ins->symbol_table.nsymbols == (DSP_MAX_SYMBOLS - 1)) { + snd_printk(KERN_ERR "dsp_spos: symbol table is full\n"); + return -ENOMEM; + } + + + if (cs46xx_dsp_lookup_symbol(chip, + module->symbol_table.symbols[i].symbol_name, + module->symbol_table.symbols[i].symbol_type) == NULL) { + + ins->symbol_table.symbols[ins->symbol_table.nsymbols] = module->symbol_table.symbols[i]; + ins->symbol_table.symbols[ins->symbol_table.nsymbols].address += ((ins->code.offset / 2) - module->overlay_begin_address); + ins->symbol_table.symbols[ins->symbol_table.nsymbols].module = module; + ins->symbol_table.symbols[ins->symbol_table.nsymbols].deleted = 0; + + if (ins->symbol_table.nsymbols > ins->symbol_table.highest_frag_index) + ins->symbol_table.highest_frag_index = ins->symbol_table.nsymbols; + + ins->symbol_table.nsymbols++; + } else { + // if (0) printk ("dsp_spos: symbol <%s> duplicated, probably nothing wrong with that (Cirrus?)\n", + // module->symbol_table.symbols[i].symbol_name); + } + } + + return 0; +} + +static symbol_entry_t * add_symbol (cs46xx_t * chip, char * symbol_name, u32 address, int type) +{ + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + symbol_entry_t * symbol = NULL; + int index; + + if (ins->symbol_table.nsymbols == (DSP_MAX_SYMBOLS - 1)) { + snd_printk(KERN_ERR "dsp_spos: symbol table is full\n"); + return NULL; + } + + if (cs46xx_dsp_lookup_symbol(chip, + symbol_name, + type) != NULL) { + snd_printk(KERN_ERR "dsp_spos: symbol <%s> duplicated\n", symbol_name); + return NULL; + } + + index = find_free_symbol_index (ins); + + strcpy (ins->symbol_table.symbols[index].symbol_name, symbol_name); + ins->symbol_table.symbols[index].address = address; + ins->symbol_table.symbols[index].symbol_type = type; + ins->symbol_table.symbols[index].module = NULL; + ins->symbol_table.symbols[index].deleted = 0; + symbol = (ins->symbol_table.symbols + index); + + if (index > ins->symbol_table.highest_frag_index) + ins->symbol_table.highest_frag_index = index; + + if (index == ins->symbol_table.nsymbols) + ins->symbol_table.nsymbols++; /* no frag. in list */ + + return symbol; +} + +dsp_spos_instance_t * cs46xx_dsp_spos_create (cs46xx_t * chip) +{ + dsp_spos_instance_t * ins = kmalloc(sizeof(dsp_spos_instance_t), GFP_KERNEL); + + if (ins == NULL) + return NULL; + memset(ins, 0, sizeof(*ins)); + + init_MUTEX(&ins->scb_mutex); + init_MUTEX(&ins->pcm_mutex); + + /* better to use vmalloc for this big table */ + ins->symbol_table.nsymbols = 0; + ins->symbol_table.symbols = vmalloc(sizeof(symbol_entry_t) * DSP_MAX_SYMBOLS); + ins->symbol_table.highest_frag_index = 0; + + if (ins->symbol_table.symbols == NULL) { + cs46xx_dsp_spos_destroy(ins); + return NULL; + } + + ins->code.offset = 0; + ins->code.size = 0; + ins->code.data = kmalloc(DSP_CODE_BYTE_SIZE, GFP_KERNEL); + + if (ins->code.data == NULL) { + cs46xx_dsp_spos_destroy(ins); + return NULL; + } + + ins->nscb = 0; + ins->ntask = 0; + + ins->nmodules = 0; + ins->modules = kmalloc(sizeof(dsp_module_desc_t) * DSP_MAX_MODULES, GFP_KERNEL); + + if (ins->modules == NULL) { + cs46xx_dsp_spos_destroy(ins); + return NULL; + } + + return ins; +} + +void cs46xx_dsp_spos_destroy (dsp_spos_instance_t * ins) +{ + int i; + + snd_assert(ins != NULL, return); + + down(&ins->scb_mutex); + for (i = 0; i < ins->nscb; ++i) { + if (ins->scbs[i].deleted) continue; + + cs46xx_dsp_proc_free_scb_desc ( (ins->scbs + i) ); + } + up(&ins->scb_mutex); + + if (ins->code.data) + kfree(ins->code.data); + if (ins->symbol_table.symbols) + vfree(ins->symbol_table.symbols); + if (ins->modules) + kfree(ins->modules); + kfree(ins); +} + +int cs46xx_dsp_load_module (cs46xx_t * chip, dsp_module_desc_t * module) +{ + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + segment_desc_t * code = get_segment_desc (module,SEGTYPE_SP_PROGRAM); + segment_desc_t * parameter = get_segment_desc (module,SEGTYPE_SP_PARAMETER); + segment_desc_t * sample = get_segment_desc (module,SEGTYPE_SP_SAMPLE); + u32 doffset, dsize; + + if (ins->nmodules == DSP_MAX_MODULES - 1) { + snd_printk(KERN_ERR "dsp_spos: to many modules loaded into DSP\n"); + return -ENOMEM; + } + + snd_printdd("dsp_spos: loading module %s into DSP\n", module->module_name); + + if (ins->nmodules == 0) { + snd_printdd("dsp_spos: clearing parameter area\n"); + snd_cs46xx_clear_BA1(chip, DSP_PARAMETER_BYTE_OFFSET, DSP_PARAMETER_BYTE_SIZE); + } + + if (parameter == NULL) { + snd_printdd("dsp_spos: module got no parameter segment\n"); + } else { + if (ins->nmodules > 0) { + snd_printk(KERN_WARNING "dsp_spos: WARNING current parameter data may be overwriten!\n"); + } + + doffset = (parameter->offset * 4 + DSP_PARAMETER_BYTE_OFFSET); + dsize = parameter->size * 4; + + snd_printdd("dsp_spos: downloading parameter data to chip (%08x-%08x)\n", + doffset,doffset + dsize); + + if (snd_cs46xx_download (chip, parameter->data, doffset, dsize)) { + snd_printk(KERN_ERR "dsp_spos: failed to download parameter data to DSP\n"); + return -EINVAL; + } + } + + if (ins->nmodules == 0) { + snd_printdd("dsp_spos: clearing sample area\n"); + snd_cs46xx_clear_BA1(chip, DSP_SAMPLE_BYTE_OFFSET, DSP_SAMPLE_BYTE_SIZE); + } + + if (sample == NULL) { + snd_printdd("dsp_spos: module got no sample segment\n"); + } else { + if (ins->nmodules > 0) { + snd_printk(KERN_WARNING "dsp_spos: WARNING current sample data may be overwriten\n"); + } + + doffset = (sample->offset * 4 + DSP_SAMPLE_BYTE_OFFSET); + dsize = sample->size * 4; + + snd_printdd("dsp_spos: downloading sample data to chip (%08x-%08x)\n", + doffset,doffset + dsize); + + if (snd_cs46xx_download (chip,sample->data,doffset,dsize)) { + snd_printk(KERN_ERR "dsp_spos: failed to sample data to DSP\n"); + return -EINVAL; + } + } + + + if (ins->nmodules == 0) { + snd_printdd("dsp_spos: clearing code area\n"); + snd_cs46xx_clear_BA1(chip, DSP_CODE_BYTE_OFFSET, DSP_CODE_BYTE_SIZE); + } + + if (code == NULL) { + snd_printdd("dsp_spos: module got no code segment\n"); + } else { + if (ins->code.offset + code->size > DSP_CODE_BYTE_SIZE) { + snd_printk(KERN_ERR "dsp_spos: no space available in DSP\n"); + return -ENOMEM; + } + + module->load_address = ins->code.offset; + module->overlay_begin_address = 0x000; + + /* if module has a code segment it must have + symbol table */ + snd_assert(module->symbol_table.symbols != NULL ,return -ENOMEM); + if (add_symbols(chip,module)) { + snd_printk(KERN_ERR "dsp_spos: failed to load symbol table\n"); + return -ENOMEM; + } + + doffset = (code->offset * 4 + ins->code.offset * 4 + DSP_CODE_BYTE_OFFSET); + dsize = code->size * 4; + snd_printdd("dsp_spos: downloading code to chip (%08x-%08x)\n", + doffset,doffset + dsize); + + module->nfixups = shadow_and_reallocate_code(chip,code->data,code->size,module->overlay_begin_address); + + if (snd_cs46xx_download (chip,(ins->code.data + ins->code.offset),doffset,dsize)) { + snd_printk(KERN_ERR "dsp_spos: failed to download code to DSP\n"); + return -EINVAL; + } + + ins->code.offset += code->size; + } + + /* NOTE: module segments and symbol table must be + statically allocated. Case that module data is + not generated by the ospparser */ + ins->modules[ins->nmodules] = *module; + ins->nmodules++; + + return 0; +} + +symbol_entry_t * cs46xx_dsp_lookup_symbol (cs46xx_t * chip, char * symbol_name, int symbol_type) +{ + int i; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + + for ( i = 0; i < ins->symbol_table.nsymbols; ++i ) { + + if (ins->symbol_table.symbols[i].deleted) + continue; + + if (!strcmp(ins->symbol_table.symbols[i].symbol_name,symbol_name) && + ins->symbol_table.symbols[i].symbol_type == symbol_type) { + return (ins->symbol_table.symbols + i); + } + } + +#if 0 + printk ("dsp_spos: symbol <%s> type %02x not found\n", + symbol_name,symbol_type); +#endif + + return NULL; +} + + +symbol_entry_t * cs46xx_dsp_lookup_symbol_addr (cs46xx_t * chip, u32 address, int symbol_type) +{ + int i; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + + for ( i = 0; i < ins->symbol_table.nsymbols; ++i ) { + + if (ins->symbol_table.symbols[i].deleted) + continue; + + if (ins->symbol_table.symbols[i].address == address && + ins->symbol_table.symbols[i].symbol_type == symbol_type) { + return (ins->symbol_table.symbols + i); + } + } + + + return NULL; +} + + +static void cs46xx_dsp_proc_symbol_table_read (snd_info_entry_t *entry, snd_info_buffer_t * buffer) +{ + cs46xx_t *chip = snd_magic_cast(cs46xx_t, entry->private_data, return); + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + int i; + + snd_iprintf(buffer, "SYMBOLS:\n"); + for ( i = 0; i < ins->symbol_table.nsymbols; ++i ) { + char *module_str = "system"; + + if (ins->symbol_table.symbols[i].deleted) + continue; + + if (ins->symbol_table.symbols[i].module != NULL) { + module_str = ins->symbol_table.symbols[i].module->module_name; + } + + + snd_iprintf(buffer, "%04X <%02X> %s [%s]\n", + ins->symbol_table.symbols[i].address, + ins->symbol_table.symbols[i].symbol_type, + ins->symbol_table.symbols[i].symbol_name, + module_str); + } +} + + +static void cs46xx_dsp_proc_modules_read (snd_info_entry_t *entry, snd_info_buffer_t * buffer) +{ + cs46xx_t *chip = snd_magic_cast(cs46xx_t, entry->private_data, return); + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + int i,j; + + snd_iprintf(buffer, "MODULES:\n"); + for ( i = 0; i < ins->nmodules; ++i ) { + snd_iprintf(buffer, "\n%s:\n", ins->modules[i].module_name); + snd_iprintf(buffer, " %d symbols\n", ins->modules[i].symbol_table.nsymbols); + snd_iprintf(buffer, " %d fixups\n", ins->modules[i].nfixups); + + for (j = 0; j < ins->modules[i].nsegments; ++ j) { + segment_desc_t * desc = (ins->modules[i].segments + j); + snd_iprintf(buffer, " segment %02x offset %08x size %08x\n", + desc->segment_type,desc->offset, desc->size); + } + } +} + +static void cs46xx_dsp_proc_task_tree_read (snd_info_entry_t *entry, snd_info_buffer_t * buffer) +{ + cs46xx_t *chip = snd_magic_cast(cs46xx_t, entry->private_data, return); + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + int i,j,col; + unsigned long dst = chip->region.idx[1].remap_addr + DSP_PARAMETER_BYTE_OFFSET; + + snd_iprintf(buffer, "TASK TREES:\n"); + for ( i = 0; i < ins->ntask; ++i) { + snd_iprintf(buffer,"\n%04x %s:\n",ins->tasks[i].address,ins->tasks[i].task_name); + + for (col = 0,j = 0;j < ins->tasks[i].size; j++,col++) { + u32 val; + if (col == 4) { + snd_iprintf(buffer,"\n"); + col = 0; + } + val = readl(dst + (ins->tasks[i].address + j) * sizeof(u32)); + snd_iprintf(buffer,"%08x ",val); + } + } + + snd_iprintf(buffer,"\n"); +} + +static void cs46xx_dsp_proc_scb_read (snd_info_entry_t *entry, snd_info_buffer_t * buffer) +{ + cs46xx_t *chip = snd_magic_cast(cs46xx_t, entry->private_data, return); + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + int i; + + snd_iprintf(buffer, "SCB's:\n"); + for ( i = 0; i < ins->nscb; ++i) { + if (ins->scbs[i].deleted) + continue; + snd_iprintf(buffer,"\n%04x %s:\n\n",ins->scbs[i].address,ins->scbs[i].scb_name); + + if (ins->scbs[i].parent_scb_ptr != NULL) { + snd_iprintf(buffer,"parent [%s:%04x] ", + ins->scbs[i].parent_scb_ptr->scb_name, + ins->scbs[i].parent_scb_ptr->address); + } else snd_iprintf(buffer,"parent [none] "); + + snd_iprintf(buffer,"sub_list_ptr [%s:%04x]\nnext_scb_ptr [%s:%04x] task_entry [%s:%04x]\n", + ins->scbs[i].sub_list_ptr->scb_name, + ins->scbs[i].sub_list_ptr->address, + ins->scbs[i].next_scb_ptr->scb_name, + ins->scbs[i].next_scb_ptr->address, + ins->scbs[i].task_entry->symbol_name, + ins->scbs[i].task_entry->address); + } + + snd_iprintf(buffer,"\n"); +} + +static void cs46xx_dsp_proc_parameter_dump_read (snd_info_entry_t *entry, snd_info_buffer_t * buffer) +{ + cs46xx_t *chip = snd_magic_cast(cs46xx_t, entry->private_data, return); + /*dsp_spos_instance_t * ins = chip->dsp_spos_instance; */ + int i,col = 0; + unsigned long dst = chip->region.idx[1].remap_addr + DSP_PARAMETER_BYTE_OFFSET; + symbol_entry_t * symbol; + + for (i = 0;i < DSP_PARAMETER_BYTE_SIZE; i += sizeof(u32),col ++) { + if (col == 4) { + snd_iprintf(buffer,"\n"); + col = 0; + } + + if ( (symbol = cs46xx_dsp_lookup_symbol_addr (chip,i / sizeof(u32), SYMBOL_PARAMETER)) != NULL) { + col = 0; + snd_iprintf (buffer,"\n%s:\n",symbol->symbol_name); + } + + if (col == 0) { + snd_iprintf(buffer, "%04X ",i / sizeof(u32)); + } + + snd_iprintf(buffer,"%08X ",readl(dst + i)); + } +} + +static void cs46xx_dsp_proc_sample_dump_read (snd_info_entry_t *entry, snd_info_buffer_t * buffer) +{ + cs46xx_t *chip = snd_magic_cast(cs46xx_t, entry->private_data, return); + /*dsp_spos_instance_t * ins = chip->dsp_spos_instance; */ + int i,col = 0; + unsigned long dst = chip->region.idx[2].remap_addr; + + snd_iprintf(buffer,"PCMREADER:\n"); + for (i = PCM_READER_BUF1;i < PCM_READER_BUF1 + 0x30; i += sizeof(u32),col ++) { + if (col == 4) { + snd_iprintf(buffer,"\n"); + col = 0; + } + + if (col == 0) { + snd_iprintf(buffer, "%04X ",i); + } + + snd_iprintf(buffer,"%08X ",readl(dst + i)); + } + + snd_iprintf(buffer,"\nMIX_SAMPLE_BUF1:\n"); + + col = 0; + for (i = MIX_SAMPLE_BUF1;i < MIX_SAMPLE_BUF1 + 0x30; i += sizeof(u32),col ++) { + if (col == 4) { + snd_iprintf(buffer,"\n"); + col = 0; + } + + if (col == 0) { + snd_iprintf(buffer, "%04X ",i); + } + + snd_iprintf(buffer,"%08X ",readl(dst + i)); + } + + snd_iprintf(buffer,"\n\n"); + col = 0; + for (i = SPDIFO_IP_OUTPUT_BUFFER1 - 0x80;i < SPDIFO_IP_OUTPUT_BUFFER1; i += sizeof(u32),col ++) { + if (col == 4) { + snd_iprintf(buffer,"\n"); + col = 0; + } + + if (col == 0) { + snd_iprintf(buffer, "%04X ",i); + } + + snd_iprintf(buffer,"%08X ",readl(dst + i)); + } + + + snd_iprintf(buffer,"\nSPDIFO_BUFFER:\n"); + col = 0; + for (i = SPDIFO_IP_OUTPUT_BUFFER1;i < SPDIFO_IP_OUTPUT_BUFFER1 + 0x40; i += sizeof(u32),col ++) { + if (col == 4) { + snd_iprintf(buffer,"\n"); + col = 0; + } + + if (col == 0) { + snd_iprintf(buffer, "%04X ",i); + } + + snd_iprintf(buffer,"%08X ",readl(dst + i)); + } + + snd_iprintf(buffer,"\n...\n"); + col = 0; + + for (i = SPDIFO_IP_OUTPUT_BUFFER1+0xD0;i < SPDIFO_IP_OUTPUT_BUFFER1 + 0x110; i += sizeof(u32),col ++) { + if (col == 4) { + snd_iprintf(buffer,"\n"); + col = 0; + } + + if (col == 0) { + snd_iprintf(buffer, "%04X ",i); + } + + snd_iprintf(buffer,"%08X ",readl(dst + i)); + } + + + snd_iprintf(buffer,"\nOUTPUT_SNOOP:\n"); + col = 0; + for (i = 0x1200;i < 0x1240; i += sizeof(u32),col ++) { + if (col == 4) { + snd_iprintf(buffer,"\n"); + col = 0; + } + + if (col == 0) { + snd_iprintf(buffer, "%04X ",i); + } + + snd_iprintf(buffer,"%08X ",readl(dst + i)); + } + + snd_iprintf(buffer,"\n...\n"); + col = 0; + for (i = 0x12D0;i < 0x1310; i += sizeof(u32),col ++) { + if (col == 4) { + snd_iprintf(buffer,"\n"); + col = 0; + } + + if (col == 0) { + snd_iprintf(buffer, "%04X ",i); + } + + snd_iprintf(buffer,"%08X ",readl(dst + i)); + } + + snd_iprintf(buffer,"\n"); +} + +#if 0 +static void snd_ac97_proc_regs_read_main(ac97_t *ac97, snd_info_buffer_t * buffer, int subidx) +{ + int reg, val; + + for (reg = 0; reg < 0x80; reg += 2) { + val = snd_ac97_read(ac97, reg); + snd_iprintf(buffer, "%i:%02x = %04x\n", subidx, reg, val); + } +} +#endif + +int cs46xx_dsp_proc_init (snd_card_t * card, cs46xx_t *chip) +{ + snd_info_entry_t *entry; + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + int i; + + ins->snd_card = card; + + if ((entry = snd_info_create_card_entry(card, "dsp", card->proc_root)) != NULL) { + entry->content = SNDRV_INFO_CONTENT_TEXT; + entry->mode = S_IFDIR | S_IRUGO | S_IXUGO; + entry->c.text.read_size = 512; + + if (snd_info_register(entry) < 0) { + snd_info_free_entry(entry); + entry = NULL; + } + } + + ins->proc_dsp_dir = entry; + + if (!ins->proc_dsp_dir) + return -ENOMEM; + + if ((entry = snd_info_create_card_entry(card, "spos_symbols", ins->proc_dsp_dir)) != NULL) { + entry->content = SNDRV_INFO_CONTENT_TEXT; + entry->private_data = chip; + entry->mode = S_IFREG | S_IRUGO | S_IWUSR; + entry->c.text.read_size = 512; + entry->c.text.read = cs46xx_dsp_proc_symbol_table_read; + if (snd_info_register(entry) < 0) { + snd_info_free_entry(entry); + entry = NULL; + } + } + ins->proc_sym_info_entry = entry; + + if ((entry = snd_info_create_card_entry(card, "spos_modules", ins->proc_dsp_dir)) != NULL) { + entry->content = SNDRV_INFO_CONTENT_TEXT; + entry->private_data = chip; + entry->mode = S_IFREG | S_IRUGO | S_IWUSR; + entry->c.text.read_size = 512; + entry->c.text.read = cs46xx_dsp_proc_modules_read; + if (snd_info_register(entry) < 0) { + snd_info_free_entry(entry); + entry = NULL; + } + } + ins->proc_modules_info_entry = entry; + + if ((entry = snd_info_create_card_entry(card, "parameter", ins->proc_dsp_dir)) != NULL) { + entry->content = SNDRV_INFO_CONTENT_TEXT; + entry->private_data = chip; + entry->mode = S_IFREG | S_IRUGO | S_IWUSR; + entry->c.text.read_size = 512; + entry->c.text.read = cs46xx_dsp_proc_parameter_dump_read; + if (snd_info_register(entry) < 0) { + snd_info_free_entry(entry); + entry = NULL; + } + } + ins->proc_parameter_dump_info_entry = entry; + + if ((entry = snd_info_create_card_entry(card, "sample", ins->proc_dsp_dir)) != NULL) { + entry->content = SNDRV_INFO_CONTENT_TEXT; + entry->private_data = chip; + entry->mode = S_IFREG | S_IRUGO | S_IWUSR; + entry->c.text.read_size = 512; + entry->c.text.read = cs46xx_dsp_proc_sample_dump_read; + if (snd_info_register(entry) < 0) { + snd_info_free_entry(entry); + entry = NULL; + } + } + ins->proc_sample_dump_info_entry = entry; + + if ((entry = snd_info_create_card_entry(card, "task_tree", ins->proc_dsp_dir)) != NULL) { + entry->content = SNDRV_INFO_CONTENT_TEXT; + entry->private_data = chip; + entry->mode = S_IFREG | S_IRUGO | S_IWUSR; + entry->c.text.read_size = 512; + entry->c.text.read = cs46xx_dsp_proc_task_tree_read;; + if (snd_info_register(entry) < 0) { + snd_info_free_entry(entry); + entry = NULL; + } + } + ins->proc_task_info_entry = entry; + + if ((entry = snd_info_create_card_entry(card, "scb_info", ins->proc_dsp_dir)) != NULL) { + entry->content = SNDRV_INFO_CONTENT_TEXT; + entry->private_data = chip; + entry->mode = S_IFREG | S_IRUGO | S_IWUSR; + entry->c.text.read_size = 1024; + entry->c.text.read = cs46xx_dsp_proc_scb_read;; + if (snd_info_register(entry) < 0) { + snd_info_free_entry(entry); + entry = NULL; + } + } + ins->proc_scb_info_entry = entry; + + /* register/update SCB's entries on proc */ + for (i = 0; i < ins->nscb; ++i) { + if (ins->scbs[i].deleted) continue; + + cs46xx_dsp_proc_register_scb_desc (chip, (ins->scbs + i)); + } + + return 0; +} + +int cs46xx_dsp_proc_done (cs46xx_t *chip) +{ + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + int i; + + if (ins->proc_sym_info_entry) { + snd_info_unregister(ins->proc_sym_info_entry); + ins->proc_sym_info_entry = NULL; + } + + if (ins->proc_modules_info_entry) { + snd_info_unregister(ins->proc_modules_info_entry); + ins->proc_modules_info_entry = NULL; + } + + if (ins->proc_parameter_dump_info_entry) { + snd_info_unregister(ins->proc_parameter_dump_info_entry); + ins->proc_parameter_dump_info_entry = NULL; + } + + if (ins->proc_sample_dump_info_entry) { + snd_info_unregister(ins->proc_sample_dump_info_entry); + ins->proc_sample_dump_info_entry = NULL; + } + + if (ins->proc_scb_info_entry) { + snd_info_unregister(ins->proc_scb_info_entry); + ins->proc_scb_info_entry = NULL; + } + + if (ins->proc_task_info_entry) { + snd_info_unregister(ins->proc_task_info_entry); + ins->proc_task_info_entry = NULL; + } + + down(&ins->scb_mutex); + for (i = 0; i < ins->nscb; ++i) { + if (ins->scbs[i].deleted) continue; + cs46xx_dsp_proc_free_scb_desc ( (ins->scbs + i) ); + } + up(&ins->scb_mutex); + + if (ins->proc_dsp_dir) { + snd_info_unregister (ins->proc_dsp_dir); + ins->proc_dsp_dir = NULL; + } + + return 0; +} + +static int debug_tree = 0; +static void _dsp_create_task_tree (cs46xx_t *chip,u32 * task_data, u32 dest, int size) +{ + unsigned long spdst = chip->region.idx[1].remap_addr + + DSP_PARAMETER_BYTE_OFFSET + dest * sizeof(u32); + int i; + + for (i = 0; i < size; ++i) { + if (debug_tree) printk ("addr %08x, val %08x\n",(int)spdst,task_data[i]); + writel(task_data[i],spdst); + spdst += sizeof(u32); + } +} + +static int debug_scb = 0; +static void _dsp_create_scb (cs46xx_t *chip,u32 * scb_data, u32 dest) +{ + unsigned long spdst = chip->region.idx[1].remap_addr + + DSP_PARAMETER_BYTE_OFFSET + dest * sizeof(u32); + int i; + + for (i = 0; i < 0x10; ++i) { + if (debug_scb) printk ("addr %08x, val %08x\n",(int)spdst,scb_data[i]); + writel(scb_data[i],spdst); + spdst += sizeof(u32); + } +} + +static int find_free_scb_index (dsp_spos_instance_t * ins) +{ + int index = ins->nscb, i; + + for (i = ins->scb_highest_frag_index; i < ins->nscb; ++i) { + if (ins->scbs[i].deleted) { + index = i; + break; + } + } + + return index; +} + +static dsp_scb_descriptor_t * _map_scb (cs46xx_t *chip,char * name,u32 dest) +{ + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + dsp_scb_descriptor_t * desc = NULL; + int index; + + if (ins->nscb == DSP_MAX_SCB_DESC - 1) { + snd_printk(KERN_ERR "dsp_spos: got no place for other SCB\n"); + return NULL; + } + + index = find_free_scb_index (ins); + + strcpy(ins->scbs[index].scb_name, name); + ins->scbs[index].address = dest; + ins->scbs[index].index = index; + ins->scbs[index].proc_info = NULL; + ins->scbs[index].ref_count = 1; + ins->scbs[index].deleted = 0; + + desc = (ins->scbs + index); + ins->scbs[index].scb_symbol = add_symbol (chip, name, dest, SYMBOL_PARAMETER); + + if (index > ins->scb_highest_frag_index) + ins->scb_highest_frag_index = index; + + if (index == ins->nscb) + ins->nscb++; + + return desc; +} + +static dsp_task_descriptor_t * _map_task_tree (cs46xx_t *chip,char * name,u32 dest,u32 size) +{ + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + dsp_task_descriptor_t * desc = NULL; + + if (ins->ntask == DSP_MAX_TASK_DESC - 1) { + snd_printk(KERN_ERR "dsp_spos: got no place for other TASK\n"); + return NULL; + } + + strcpy(ins->tasks[ins->ntask].task_name,name); + ins->tasks[ins->ntask].address = dest; + ins->tasks[ins->ntask].size = size; + + /* quick find in list */ + ins->tasks[ins->ntask].index = ins->ntask; + desc = (ins->tasks + ins->ntask); + ins->ntask++; + + add_symbol (chip,name,dest,SYMBOL_PARAMETER); + return desc; +} + +dsp_scb_descriptor_t * cs46xx_dsp_create_scb (cs46xx_t *chip,char * name, u32 * scb_data,u32 dest) +{ + dsp_scb_descriptor_t * desc; + + desc = _map_scb (chip,name,dest); + if (desc) { + _dsp_create_scb(chip,scb_data,dest); + } else { + snd_printk(KERN_ERR "dsp_spos: failed to map SCB\n"); + } + + return desc; +} + + +dsp_task_descriptor_t * cs46xx_dsp_create_task_tree (cs46xx_t *chip,char * name, u32 * task_data,u32 dest,int size) +{ + dsp_task_descriptor_t * desc; + + desc = _map_task_tree (chip,name,dest,size); + if (desc) { + _dsp_create_task_tree(chip,task_data,dest,size); + } else { + snd_printk(KERN_ERR "dsp_spos: failed to map TASK\n"); + } + + return desc; +} + + +int cs46xx_dsp_scb_and_task_init (cs46xx_t *chip) +{ + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + symbol_entry_t * fg_task_tree_header_code; + symbol_entry_t * task_tree_header_code; + symbol_entry_t * task_tree_thread; + symbol_entry_t * null_algorithm; + symbol_entry_t * magic_snoop_task; + + dsp_scb_descriptor_t * timing_master_scb; + dsp_scb_descriptor_t * codec_out_scb; + dsp_scb_descriptor_t * codec_in_scb; + dsp_scb_descriptor_t * pcm_reader_scb; + dsp_scb_descriptor_t * src_task_scb; + dsp_scb_descriptor_t * master_mix_scb; + dsp_scb_descriptor_t * write_back_scb; + dsp_scb_descriptor_t * vari_decimate_scb; + dsp_scb_descriptor_t * pcm_serial_input_task; + dsp_scb_descriptor_t * asynch_tx_scb; + dsp_scb_descriptor_t * asynch_rx_scb; + dsp_scb_descriptor_t * sec_codec_out_scb; + dsp_scb_descriptor_t * magic_snoop_scb; + dsp_scb_descriptor_t * sec_magic_snoop_scb; + + spos_control_block_t sposcb = { + /* 0 */ HFG_TREE_SCB,HFG_STACK, + /* 1 */ SPOSCB_ADDR,BG_TREE_SCB_ADDR, + /* 2 */ DSP_SPOS_DC,0, + /* 3 */ DSP_SPOS_DC,DSP_SPOS_DC, + /* 4 */ 0,0, + /* 5 */ DSP_SPOS_UU,0, + /* 6 */ FG_TASK_HEADER_ADDR,0, + /* 7 */ 0,0, + /* 8 */ DSP_SPOS_UU,DSP_SPOS_DC, + /* 9 */ 0, + /* A */ 0,HFG_FIRST_EXECUTE_MODE, + /* B */ DSP_SPOS_UU,DSP_SPOS_UU, + /* C */ DSP_SPOS_DC_DC, + /* D */ DSP_SPOS_DC_DC, + /* E */ DSP_SPOS_DC_DC, + /* F */ DSP_SPOS_DC_DC + }; + + cs46xx_dsp_create_task_tree(chip, "sposCB", (u32 *)&sposcb, SPOSCB_ADDR, 0x10); + + null_algorithm = cs46xx_dsp_lookup_symbol(chip, "NULLALGORITHM", SYMBOL_CODE); + if (null_algorithm == NULL) { + snd_printk(KERN_ERR "dsp_spos: symbol NULLALGORITHM not found\n"); + return -EIO; + } + + fg_task_tree_header_code = cs46xx_dsp_lookup_symbol(chip, "FGTASKTREEHEADERCODE", SYMBOL_CODE); + if (fg_task_tree_header_code == NULL) { + snd_printk(KERN_ERR "dsp_spos: symbol FGTASKTREEHEADERCODE not found\n"); + return -EIO; + } + + task_tree_header_code = cs46xx_dsp_lookup_symbol(chip, "TASKTREEHEADERCODE", SYMBOL_CODE); + if (task_tree_header_code == NULL) { + snd_printk(KERN_ERR "dsp_spos: symbol TASKTREEHEADERCODE not found\n"); + return -EIO; + } + + task_tree_thread = cs46xx_dsp_lookup_symbol(chip, "TASKTREETHREAD", SYMBOL_CODE); + if (task_tree_thread == NULL) { + snd_printk(KERN_ERR "dsp_spos: symbol TASKTREETHREAD not found\n"); + return -EIO; + } + + magic_snoop_task = cs46xx_dsp_lookup_symbol(chip, "MAGICSNOOPTASK", SYMBOL_CODE); + if (magic_snoop_task == NULL) { + snd_printk(KERN_ERR "dsp_spos: symbol MAGICSNOOPTASK not found\n"); + return -EIO; + } + + { + /* create the null SCB */ + generic_scb_t null_scb = { + { 0, 0, 0, 0 }, + { 0, 0, 0, 0, 0 }, + NULL_SCB_ADDR, NULL_SCB_ADDR, + null_algorithm->address, 0, + 0,0,0, + { + 0,0, + 0,0, + } + }; + + ins->the_null_scb = cs46xx_dsp_create_scb(chip, "nullSCB", (u32 *)&null_scb, NULL_SCB_ADDR); + ins->the_null_scb->task_entry = null_algorithm; + ins->the_null_scb->sub_list_ptr = ins->the_null_scb; + ins->the_null_scb->next_scb_ptr = ins->the_null_scb; + ins->the_null_scb->parent_scb_ptr = NULL; + } + + { + /* setup foreground task tree */ + task_tree_control_block_t fg_task_tree_hdr = { + { FG_TASK_HEADER_ADDR | (DSP_SPOS_DC << 0x10), + DSP_SPOS_DC_DC, + DSP_SPOS_DC_DC, + 0x0000,DSP_SPOS_DC, + DSP_SPOS_DC, DSP_SPOS_DC, + DSP_SPOS_DC_DC, + DSP_SPOS_DC_DC, + DSP_SPOS_DC_DC, + DSP_SPOS_DC,DSP_SPOS_DC }, + + { + BG_TREE_SCB_ADDR,TIMINGMASTER_SCB_ADDR, + fg_task_tree_header_code->address, + FG_TASK_HEADER_ADDR + TCBData, + }, + + { + 4,0, + 1,0, + 2,SPOSCB_ADDR + HFGFlags, + 0,0, + FG_TASK_HEADER_ADDR + TCBContextBlk,FG_STACK + }, + + { + DSP_SPOS_DC,task_tree_thread->address, + DSP_SPOS_DC,DSP_SPOS_DC, + DSP_SPOS_DC,DSP_SPOS_DC, + DSP_SPOS_DC,DSP_SPOS_DC, + DSP_SPOS_DC,DSP_SPOS_DC, + DSP_SPOS_DCDC, + DSP_SPOS_UU,1, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC + }, + { + FG_INTERVAL_TIMER_PERIOD,DSP_SPOS_UU, + 0,0 + } + }; + + cs46xx_dsp_create_task_tree(chip,"FGtaskTreeHdr",(u32 *)&fg_task_tree_hdr,FG_TASK_HEADER_ADDR,0x35); + } + + + { + /* setup foreground task tree */ + task_tree_control_block_t bg_task_tree_hdr = { + { DSP_SPOS_DC_DC, + DSP_SPOS_DC_DC, + DSP_SPOS_DC_DC, + DSP_SPOS_DC, DSP_SPOS_DC, + DSP_SPOS_DC, DSP_SPOS_DC, + DSP_SPOS_DC_DC, + DSP_SPOS_DC_DC, + DSP_SPOS_DC_DC, + DSP_SPOS_DC,DSP_SPOS_DC }, + + { + NULL_SCB_ADDR,NULL_SCB_ADDR, /* Set up the background to do nothing */ + task_tree_header_code->address, + BG_TREE_SCB_ADDR + TCBData, + }, + + { + 9999,0, + 0,1, + 0,SPOSCB_ADDR + HFGFlags, + 0,0, + BG_TREE_SCB_ADDR + TCBContextBlk,BG_STACK + }, + + { + DSP_SPOS_DC,task_tree_thread->address, + DSP_SPOS_DC,DSP_SPOS_DC, + DSP_SPOS_DC,DSP_SPOS_DC, + DSP_SPOS_DC,DSP_SPOS_DC, + DSP_SPOS_DC,DSP_SPOS_DC, + DSP_SPOS_DCDC, + DSP_SPOS_UU,1, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC, + DSP_SPOS_DCDC + }, + { + BG_INTERVAL_TIMER_PERIOD,DSP_SPOS_UU, + 0,0 + } + }; + // debug_tree = 1; + cs46xx_dsp_create_task_tree(chip,"BGtaskTreeHdr",(u32 *)&bg_task_tree_hdr,BG_TREE_SCB_ADDR,0x35); + // debug_tree = 0; + + } + + //debug_scb = 1; + /* create timing master SCB */ + timing_master_scb = cs46xx_dsp_create_timing_master_scb(chip); + + /* create the CODEC output task */ + codec_out_scb = cs46xx_dsp_create_codec_out_scb(chip,"CodecOutSCB_I",0x0010,0x0000, + MASTERMIX_SCB_ADDR, + CODECOUT_SCB_ADDR,timing_master_scb, + SCB_ON_PARENT_SUBLIST_SCB); + + if (!codec_out_scb) goto _fail_end; + /* create the master mix SCB */ + master_mix_scb = cs46xx_dsp_create_mix_only_scb(chip,"MasterMixSCB", + MIX_SAMPLE_BUF1,MASTERMIX_SCB_ADDR, + codec_out_scb, + SCB_ON_PARENT_SUBLIST_SCB); + ins->master_mix_scb = master_mix_scb; + + if (!master_mix_scb) goto _fail_end; +#if 0 + /* the sample rate converter SCB */ + src_task_scb = cs46xx_dsp_create_src_task_scb(chip,"SrcTaskSCB_I", + SRC_OUTPUT_BUF1, + SRC_DELAY_BUF1,SRCTASK_SCB_ADDR, + asynch_tx_scb, + + SCB_ON_PARENT_SUBLIST_SCB); + /* create the PCM reader SCB */ + pcm_reader_scb = cs46xx_dsp_create_pcm_reader_scb(chip,"PCMReaderSCB_I", + PCM_READER_BUF1,PCMREADER_SCB_ADDR, + 0, /* playback how hw addr */ + src_task_scb, + SCB_ON_PARENT_SUBLIST_SCB); +#endif + + /* create codec in */ + codec_in_scb = cs46xx_dsp_create_codec_in_scb(chip,"CodecInSCB",0x0010,0x00A0, + MIX_SAMPLE_BUF1, + CODECIN_SCB_ADDR,codec_out_scb, + SCB_ON_PARENT_NEXT_SCB); + if (!codec_in_scb) goto _fail_end; + + /* create write back scb */ + write_back_scb = cs46xx_dsp_create_mix_to_ostream_scb(chip,"WriteBackSCB", + WRITE_BACK_BUF1,WRITE_BACK_SPB, + WRITEBACK_SCB_ADDR, + timing_master_scb, + SCB_ON_PARENT_NEXT_SCB); + if (!write_back_scb) goto _fail_end; + + { + mix2_ostream_spb_t mix2_ostream_spb = { + 0x00020000, + 0x0000ffff + }; + + /* dirty hack ... */ + _dsp_create_task_tree (chip,(u32 *)&mix2_ostream_spb,WRITE_BACK_SPB,2); + } + + /* input sample converter */ + vari_decimate_scb = cs46xx_dsp_create_vari_decimate_scb(chip,"VariDecimateSCB", + VARI_DECIMATE_BUF0, + VARI_DECIMATE_BUF1, + VARIDECIMATE_SCB_ADDR, + write_back_scb, + SCB_ON_PARENT_SUBLIST_SCB); + if (!vari_decimate_scb) goto _fail_end; + + + /* pcm input */ + pcm_serial_input_task = cs46xx_dsp_create_pcm_serial_input_scb(chip,"PCMSerialInput", + PCMSERIALIN_SCB_ADDR, + codec_in_scb, vari_decimate_scb, + SCB_ON_PARENT_SUBLIST_SCB); + if (!pcm_serial_input_task) goto _fail_end; + + +#if 0 /* asynch. receive task */ + asynch_rx_scb = cs46xx_dsp_create_asynch_fg_rx_scb(chip,"AsynchFGRxSCB", + ASYNCRX_SCB_ADDR, + SPDIFI_SCB_INST, + SPDIFI_IP_OUTPUT_BUFFER1, + master_mix_scb, + SCB_ON_PARENT_NEXT_SCB); + if (!asynch_rx_scb) goto _fail_end; +#endif + + + /* create secondary CODEC output */ + sec_codec_out_scb = cs46xx_dsp_create_codec_out_scb(chip,"CodecOutSCB_II",0x0010,0x0040, + OUTPUTSNOOP_SCB_ADDR, + SEC_CODECOUT_SCB_ADDR,codec_in_scb, + SCB_ON_PARENT_NEXT_SCB); + if (!sec_codec_out_scb) goto _fail_end; + + /* the magic snooper */ + magic_snoop_scb = cs46xx_dsp_create_magic_snoop_scb (chip,"MagicSnoopSCB_I",OUTPUTSNOOP_SCB_ADDR, + OUTPUT_SNOOP_BUFFER, + codec_out_scb, + sec_codec_out_scb, + SCB_ON_PARENT_SUBLIST_SCB); + if (!magic_snoop_scb) goto _fail_end; + + /* The asynch. transfer task */ + asynch_tx_scb = cs46xx_dsp_create_asynch_fg_tx_scb(chip,"AsynchFGTxSCB",ASYNCTX_SCB_ADDR, + SPDIFO_SCB_INST, + SPDIFO_IP_OUTPUT_BUFFER1, + magic_snoop_scb, + SCB_ON_PARENT_NEXT_SCB); + + if (!asynch_tx_scb) goto _fail_end; + + /* pcm input */ + pcm_serial_input_task = cs46xx_dsp_create_pcm_serial_input_scb(chip,"PCMSerialInput_II", + PCMSERIALINII_SCB_ADDR, + magic_snoop_scb,asynch_tx_scb, + SCB_ON_PARENT_SUBLIST_SCB); + + if (!pcm_serial_input_task) goto _fail_end; + + /* SP IO access */ + if (!cs46xx_dsp_create_spio_write_scb(chip,"SPIOWriteSCB",SPIOWRITE_SCB_ADDR, + asynch_tx_scb, + SCB_ON_PARENT_NEXT_SCB)) + goto _fail_end; + + + /* the magic snooper */ +#if 0 + sec_magic_snoop_scb = cs46xx_dsp_create_magic_snoop_scb (chip,"MagicSnoopSCB_II",OUTPUTSNOOPII_SCB_ADDR, + MIX_SAMPLE_BUF1, + master_mix_scb, + asynch_tx_scb, + SCB_ON_PARENT_SUBLIST_SCB); + if (!sec_magic_scb) goto _fail_end; +#endif + + //debug_scb = 0; + cs46xx_dsp_async_init(chip,timing_master_scb); + return 0; + + _fail_end: + snd_printk(KERN_ERR "dsp_spos: failed to setup SCB's in DSP\n"); + return -EINVAL; +} + +int cs46xx_dsp_async_init (cs46xx_t *chip, dsp_scb_descriptor_t * fg_entry) +{ + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + symbol_entry_t * s16_async_codec_input_task; + symbol_entry_t * spdifo_task; + symbol_entry_t * spdifi_task; + dsp_scb_descriptor_t * spdifi_scb_desc,* spdifo_scb_desc,* async_codec_scb_desc; + + s16_async_codec_input_task = cs46xx_dsp_lookup_symbol(chip, "S16_ASYNCCODECINPUTTASK", SYMBOL_CODE); + if (s16_async_codec_input_task == NULL) { + snd_printk(KERN_ERR "dsp_spos: symbol S16_ASYNCCODECINPUTTASK not found\n"); + return -EIO; + } + spdifo_task = cs46xx_dsp_lookup_symbol(chip, "SPDIFOTASK", SYMBOL_CODE); + if (spdifo_task == NULL) { + snd_printk(KERN_ERR "dsp_spos: symbol SPDIFOTASK not found\n"); + return -EIO; + } + + spdifi_task = cs46xx_dsp_lookup_symbol(chip, "SPDIFITASK", SYMBOL_CODE); + if (spdifi_task == NULL) { + snd_printk(KERN_ERR "dsp_spos: symbol SPDIFITASK not found\n"); + return -EIO; + } + + { + /* 0xBC0 */ + spdifoscb_t spdifo_scb = { + /* 0 */ DSP_SPOS_UUUU, + { + /* 1 */ 0xb0, //DSP_SPOS_UUUU, + /* 2 */ 0, //DSP_SPOS_UUUU, + /* 3 */ 0, //DSP_SPOS_UUUU, + /* 4 */ 0, //DSP_SPOS_UUUU, + }, + /* 5 */ 0x00000085, + /* 6 */ ( SPDIFO_IP_OUTPUT_BUFFER1 << 0x10 ) | 0xFFFC, + /* 7 */ 0,0, // DSP_SPOS_UU,1, //DSP_SPOS_DC,DSP_SPOS_UU, + /* 8 */ 0, //DSP_SPOS_UUUU, + /* 9 */ FG_TASK_HEADER_ADDR, NULL_SCB_ADDR, + /* A */ spdifo_task->address, + SPDIFO_SCB_INST + SPDIFOFIFOPointer, + { + /* B */ 0x0040, /*DSP_SPOS_UUUU,*/ + /* C */ 0x20ff, /*DSP_SPOS_UUUU,*/ + }, + /* D */ 0x804c,0, /* SPDIFOFIFOPointer:SPDIFOStatRegAddr; */ + /* E */ 0x0108,0x0001, /* SPDIFOStMoFormat:SPDIFOFIFOBaseAddr; */ + /* F */ DSP_SPOS_UUUU /* SPDIFOFree; */ + }; + + /* 0xBB0 */ + spdifiscb_t spdifi_scb = { + /* 0 */ DSP_SPOS_UULO,DSP_SPOS_UUHI, + /* 1 */ 0, + /* 2 */ 0, + /* 3 */ 1,4000, + /* 4 */ DSP_SPOS_UUUU, + /* 5 */ DSP_SPOS_UULO,DSP_SPOS_UUHI, + /* 6 */ DSP_SPOS_UUUU, + /* 7 */ DSP_SPOS_UU,DSP_SPOS_DC, + /* 8 */ DSP_SPOS_UUUU, + /* 9 */ SPDIFO_SCB_INST, NULL_SCB_ADDR, + /* A */ spdifi_task->address, + SPDIFI_SCB_INST + SPDIFIFIFOPointer, + + /* B */ 0x00000083, + /* C */ (SPDIFI_IP_OUTPUT_BUFFER1 << 0x10) | 0xFFFC, + /* D */ 0x8048,0, + /* E */ 0x01f0,0x0001, + /* F */ DSP_SPOS_UUUU + }; + + /* 0xBA0 */ + async_codec_input_scb_t async_codec_input_scb = { + /* 0 */ DSP_SPOS_UUUU, + /* 1 */ 0, + /* 2 */ 0, + /* 3 */ 1,4000, + /* 4 */ 0x0118,0x0001, + /* 5 */ 0x00000083, + /* 6 */ (ASYNC_IP_OUTPUT_BUFFER1 << 0x10) | 0xFFFC, + /* 7 */ DSP_SPOS_UU,0x3, + /* 8 */ DSP_SPOS_UUUU, + /* 9 */ SPDIFI_SCB_INST,NULL_SCB_ADDR, + /* A */ s16_async_codec_input_task->address, + HFG_TREE_SCB + AsyncCIOFIFOPointer, + + /* B */ RSCONFIG_SAMPLE_16STEREO + RSCONFIG_MODULO_64, + /* C */ (ASYNC_IP_OUTPUT_BUFFER1 << 0x10), /*(ASYNC_IP_OUTPUT_BUFFER1 << 0x10) | 0xFFFC,*/ + +#ifdef UseASER1Input + /* short AsyncCIFIFOPointer:AsyncCIStatRegAddr; + Init. 0000:8042: for ASER1 + 0000:8044: for ASER2 */ + /* D */ 0x8042,0, + + /* short AsyncCIStMoFormat:AsyncCIFIFOBaseAddr; + Init 1 stero:8050 ASER1 + Init 0 mono:8070 ASER2 + Init 1 Stereo : 0100 ASER1 (Set by script) */ + /* E */ 0x0100,0x0001, + +#endif + +#ifdef UseASER2Input + /* short AsyncCIFIFOPointer:AsyncCIStatRegAddr; + Init. 0000:8042: for ASER1 + 0000:8044: for ASER2 */ + /* D */ 0x8044,0, + + /* short AsyncCIStMoFormat:AsyncCIFIFOBaseAddr; + Init 1 stero:8050 ASER1 + Init 0 mono:8070 ASER2 + Init 1 Stereo : 0100 ASER1 (Set by script) */ + /* E */ 0x0110,0x0001, + +#endif + + /* short AsyncCIOutputBufModulo:AsyncCIFree; + AsyncCIOutputBufModulo: The modulo size for + the output buffer of this task */ + /* F */ 0, /* DSP_SPOS_UUUU */ + }; + + spdifo_scb_desc = cs46xx_dsp_create_scb(chip,"SPDIFOSCB",(u32 *)&spdifo_scb,SPDIFO_SCB_INST); + snd_assert(spdifo_scb_desc, return -EIO); + spdifi_scb_desc = cs46xx_dsp_create_scb(chip,"SPDIFISCB",(u32 *)&spdifi_scb,SPDIFI_SCB_INST); + snd_assert(spdifi_scb_desc, return -EIO); + async_codec_scb_desc = cs46xx_dsp_create_scb(chip,"AsynCodecInputSCB",(u32 *)&async_codec_input_scb, HFG_TREE_SCB); + snd_assert(async_codec_scb_desc, return -EIO); + + async_codec_scb_desc->parent_scb_ptr = NULL; + async_codec_scb_desc->next_scb_ptr = spdifi_scb_desc; + async_codec_scb_desc->sub_list_ptr = ins->the_null_scb; + async_codec_scb_desc->task_entry = s16_async_codec_input_task; + + spdifi_scb_desc->parent_scb_ptr = async_codec_scb_desc; + spdifi_scb_desc->next_scb_ptr = spdifo_scb_desc; + spdifi_scb_desc->sub_list_ptr = ins->the_null_scb; + spdifi_scb_desc->task_entry = spdifi_task; + + spdifo_scb_desc->parent_scb_ptr = spdifi_scb_desc; + spdifo_scb_desc->next_scb_ptr = fg_entry; + spdifo_scb_desc->sub_list_ptr = ins->the_null_scb; + spdifo_scb_desc->task_entry = spdifo_task; + + /* this one is faked, as the parnet of SPDIFO task + is the FG task tree */ + fg_entry->parent_scb_ptr = spdifo_scb_desc; + + /* dirty hack to start forground task ... */ + //snd_cs46xx_poke(chip,DSP_PARAMETER_BYTE_OFFSET + 0x070 * sizeof(u32),0x066a0ba0); + } + + return 0; +} + +int cs46xx_dsp_enable_spdif_out (cs46xx_t *chip) +{ + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + + /* set SPDIF output FIFO slot */ + snd_cs46xx_pokeBA0(chip, BA0_ASER_FADDR, ( 0x8100 | ((SP_SPDOUT_FIFO >> 4) << 4) )); + + /* Async MASTER ENABLE */ + snd_cs46xx_pokeBA0(chip, BA0_ASER_MASTER, 0x1 ); + +#if 0 + /* reset buffers */ + snd_cs46xx_poke (chip, (SPDIFO_SCB_INST + 6) << 2,(SPDIFO_IP_OUTPUT_BUFFER1 << 0x10) | 0xFFFC); + snd_cs46xx_poke (chip, (ASYNCTX_SCB_ADDR + 12) << 2, (SPDIFO_IP_OUTPUT_BUFFER1) << 0x10); + + /* insert the foreground asynch tranfer task */ + snd_cs46xx_poke (chip, (MASTERMIX_SCB_ADDR + 9) << 2, ASYNCTX_SCB_ADDR << 0x10 /*| ASYNCRX_SCB_ADDR*/); +#endif + + /* SPDIF output MASTER ENABLE */ + cs46xx_poke_via_dsp (chip,SP_SPDOUT_CONTROL, 0x80000000); + + /* right and left validate bit + NOTE: 0x80000000 and enables the SCMC protection on stream + */ + cs46xx_poke_via_dsp (chip,SP_SPDOUT_CSUV, 0x00000000 | (1 << 13) | (1 << 12)); + + /* monitor state */ + ins->spdif_status_out = 1; + + return 0; +} + +int cs46xx_dsp_disable_spdif_out (cs46xx_t *chip) +{ + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + +#if 0 + /* unlink the foreground asynch tranfer task */ + snd_cs46xx_poke (chip, (MASTERMIX_SCB_ADDR + 9) << 2, SRCTASK_SCB_ADDR << 0x10 /* | ASYNCRX_SCB_ADDR*/); +#endif + + /* Async MASTER DISABLE */ + snd_cs46xx_pokeBA0(chip, BA0_ASER_MASTER, 0x0 ); + + /* SPDIF output MASTER DISABLE */ + cs46xx_poke_via_dsp (chip,SP_SPDOUT_CONTROL, 0x0); + + /* monitor state */ + ins->spdif_status_out = 0; + + return 0; +} + +int cs46xx_dsp_enable_spdif_in (cs46xx_t *chip) +{ + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + + /* Async MASTER ENABLE */ + snd_cs46xx_pokeBA0(chip, BA0_ASER_MASTER, 0x1 ); + + /* Time countdown enable */ + cs46xx_poke_via_dsp (chip,SP_ASER_COUNTDOWN, 0x80000000); + + /* SPDIF input MASTER ENABLE */ + cs46xx_poke_via_dsp (chip,SP_SPDIN_CONTROL, 0x800003ff); + + /* monitor state */ + ins->spdif_status_in = 1; + + return 0; +} + +int cs46xx_dsp_disable_spdif_in (cs46xx_t *chip) +{ + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + + /* SPDIF input MASTER DISABLE */ + cs46xx_poke_via_dsp (chip,SP_SPDIN_CONTROL, 0x000003ff); + + /* monitor state */ + ins->spdif_status_in = 0; + return 0; +} + +int cs46xx_poke_via_dsp (cs46xx_t *chip,u32 address,u32 data) +{ + u32 temp; + int i; + + /* santiy check the parameters. (These numbers are not 100% correct. They are + a rough guess from looking at the controller spec.) */ + if (address < 0x8000 || address >= 0x9000) + return -EINVAL; + + /* initialize the SP_IO_WRITE SCB with the data. */ + temp = ( address << 16 ) | ( address & 0x0000FFFF); /* offset 0 <-- address2 : address1 */ + + snd_cs46xx_poke(chip,( SPIOWRITE_SCB_ADDR << 2), temp); + snd_cs46xx_poke(chip,((SPIOWRITE_SCB_ADDR + 1) << 2), data); /* offset 1 <-- data1 */ + snd_cs46xx_poke(chip,((SPIOWRITE_SCB_ADDR + 2) << 2), data); /* offset 1 <-- data2*/ + + /* Poke this location to tell the task to start */ + snd_cs46xx_poke(chip,((SPIOWRITE_SCB_ADDR + 6) << 2), SPIOWRITE_SCB_ADDR << 0x10); + + /* Verify that the task ran */ + for (i=0; i<25; i++) { + udelay(125); + + temp = snd_cs46xx_peek(chip,((SPIOWRITE_SCB_ADDR + 6) << 2)); + if (temp == 0x00000000) + break; + } + + if (i == 25) { + snd_printk(KERN_ERR "dsp_spos: SPIOWriteTask not responding\n"); + return -EBUSY; + } + + return 0; +} diff -Nru a/sound/pci/cs46xx/dsp_spos.h b/sound/pci/cs46xx/dsp_spos.h --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/sound/pci/cs46xx/dsp_spos.h Sun Sep 29 20:23:44 2002 @@ -0,0 +1,150 @@ +/* + * The driver for the Cirrus Logic's Sound Fusion CS46XX based soundcards + * Copyright (c) by Jaroslav Kysela + * + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* + * 2002-07 Benny Sjostrand benny@hostmobility.com + */ + +#define DSP_MAX_SYMBOLS 1024 +#define DSP_MAX_MODULES 64 + +#define DSP_CODE_BYTE_SIZE 0x00007000UL +#define DSP_PARAMETER_BYTE_SIZE 0x00003000UL +#define DSP_SAMPLE_BYTE_SIZE 0x00003800UL +#define DSP_PARAMETER_BYTE_OFFSET 0x00000000UL +#define DSP_SAMPLE_BYTE_OFFSET 0x00010000UL +#define DSP_CODE_BYTE_OFFSET 0x00020000UL + +#define WIDE_INSTR_MASK 0x0040 +#define WIDE_LADD_INSTR_MASK 0x0380 + +/* this instruction types + needs to be reallocated when load + code into DSP */ +typedef enum { + WIDE_FOR_BEGIN_LOOP = 0x20, + WIDE_FOR_BEGIN_LOOP2, + + WIDE_COND_GOTO_ADDR = 0x30, + WIDE_COND_GOTO_CALL, + + WIDE_TBEQ_COND_GOTO_ADDR = 0x70, + WIDE_TBEQ_COND_CALL_ADDR, + WIDE_TBEQ_NCOND_GOTO_ADDR, + WIDE_TBEQ_NCOND_CALL_ADDR, + WIDE_TBEQ_COND_GOTO1_ADDR, + WIDE_TBEQ_COND_CALL1_ADDR, + WIDE_TBEQ_NCOND_GOTOI_ADDR, + WIDE_TBEQ_NCOND_CALL1_ADDR, +} wide_opcode_t; + +/* SAMPLE segment */ +#define VARI_DECIMATE_BUF1 0x0000 +#define WRITE_BACK_BUF1 0x0400 +#define CODEC_INPUT_BUF1 0x0500 +#define PCM_READER_BUF1 0x0600 +#define SRC_DELAY_BUF1 0x0680 +#define VARI_DECIMATE_BUF0 0x0780 +#define SRC_OUTPUT_BUF1 0x07A0 +#define ASYNC_IP_OUTPUT_BUFFER1 0x0A00 +#define OUTPUT_SNOOP_BUFFER 0x0B00 +#define SPDIFI_IP_OUTPUT_BUFFER1 0x0E00 +#define SPDIFO_IP_OUTPUT_BUFFER1 0x1000 +#define MIX_SAMPLE_BUF1 0x1400 + +// #define SRC_OUTPUT_BUF2 0x1280 +// #define SRC_DELAY_BUF2 0x1288 + +/* Task stack address */ +#define HFG_STACK 0x066A +#define FG_STACK 0x066E +#define BG_STACK 0x068E + +/* SCB's addresses */ +#define SPOSCB_ADDR 0x070 +#define BG_TREE_SCB_ADDR 0x635 +#define NULL_SCB_ADDR 0x000 +#define TIMINGMASTER_SCB_ADDR 0x010 +#define CODECOUT_SCB_ADDR 0x020 +#define PCMREADER_SCB_ADDR 0x030 +#define WRITEBACK_SCB_ADDR 0x040 +#define CODECIN_SCB_ADDR 0x080 +#define MASTERMIX_SCB_ADDR 0x090 +#define SRCTASK_SCB_ADDR 0x0A0 +#define VARIDECIMATE_SCB_ADDR 0x0B0 +#define PCMSERIALIN_SCB_ADDR 0x0C0 +#define FG_TASK_HEADER_ADDR 0x600 +#define ASYNCTX_SCB_ADDR 0x0E0 +#define ASYNCRX_SCB_ADDR 0x0F0 +#define SRCTASKII_SCB_ADDR 0x100 +#define OUTPUTSNOOP_SCB_ADDR 0x110 +#define PCMSERIALINII_SCB_ADDR 0x120 +#define SPIOWRITE_SCB_ADDR 0x130 +#define SEC_CODECOUT_SCB_ADDR 0x140 +#define OUTPUTSNOOPII_SCB_ADDR 0x150 + +/* hyperforground SCB's*/ +#define HFG_TREE_SCB 0xBA0 +#define SPDIFI_SCB_INST 0xBB0 +#define SPDIFO_SCB_INST 0xBC0 +#define WRITE_BACK_SPB 0x0D0 + +/* offsets */ +#define AsyncCIOFIFOPointer 0xd +#define SPDIFOFIFOPointer 0xd +#define SPDIFIFIFOPointer 0xd +#define TCBData 0xb +#define HFGFlags 0xa +#define TCBContextBlk 0x10 +#define AFGTxAccumPhi 0x4 +#define SCBsubListPtr 0x9 +#define SCBfuncEntryPtr 0xA +#define SRCCorPerGof 0x2 +#define SRCPhiIncr6Int26Frac 0xd + +/* conf */ +#define UseASER1Input 1 + +/* constants */ +#define FG_INTERVAL_TIMER_PERIOD 0x0051 +#define BG_INTERVAL_TIMER_PERIOD 0x0100 +#define RSCONFIG_MODULO_32 0x00000002 +#define RSCONFIG_MODULO_64 0x00000003 +#define RSCONFIG_MODULO_256 0x00000005 +#define RSCONFIG_MODULO_8 0x00000009 +#define RSCONFIG_SAMPLE_16STEREO 0x000000C0 +#define RSCONFIG_SAMPLE_16MONO 0x00000080 +#define RSCONFIG_DMA_TO_HOST 0x00008000 +#define RSCONFIG_DMA_ENABLE 0x20000000 +#define RSCONFIG_STREAM_NUM_SHIFT 16 +#define RSCONFIG_MAX_DMA_SIZE_SHIFT 24 + +/* Only SP accesible registers */ +#define SP_ASER_COUNTDOWN 0x8040 +#define SP_SPDOUT_FIFO 0x0108 +#define SP_SPDIN_MI_FIFO 0x01E0 +#define SP_SPDIN_D_FIFO 0x01F0 +#define SP_SPDIN_STATUS 0x8048 +#define SP_SPDIN_CONTROL 0x8049 +#define SP_SPDIN_FIFOPTR 0x804A +#define SP_SPDOUT_STATUS 0x804C +#define SP_SPDOUT_CONTROL 0x804D +#define SP_SPDOUT_CSUV 0x808E diff -Nru a/sound/pci/cs46xx/dsp_spos_scb_lib.c b/sound/pci/cs46xx/dsp_spos_scb_lib.c --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/sound/pci/cs46xx/dsp_spos_scb_lib.c Sun Sep 29 20:23:44 2002 @@ -0,0 +1,1383 @@ +/* + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/* + * 2002-07 Benny Sjostrand benny@hostmobility.com + */ + + +#define __NO_VERSION__ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "cs46xx_lib.h" +#include "dsp_spos.h" + +typedef struct _proc_scb_info_t { + dsp_scb_descriptor_t * scb_desc; + cs46xx_t *chip; +} proc_scb_info_t; + +static void remove_symbol (cs46xx_t * chip,symbol_entry_t * symbol) +{ + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + int symbol_index = (int)(symbol - ins->symbol_table.symbols); + + snd_assert(ins->symbol_table.nsymbols > 0,return); + snd_assert(symbol_index >= 0 && symbol_index < ins->symbol_table.nsymbols, return); + + ins->symbol_table.symbols[symbol_index].deleted = 1; + + if (symbol_index < ins->symbol_table.highest_frag_index) { + ins->symbol_table.highest_frag_index = symbol_index; + } + + if (symbol_index == ins->symbol_table.nsymbols - 1) + ins->symbol_table.nsymbols --; + + if (ins->symbol_table.highest_frag_index > ins->symbol_table.nsymbols) { + ins->symbol_table.highest_frag_index = ins->symbol_table.nsymbols; + } + +} + +static void cs46xx_dsp_proc_scb_info_read (snd_info_entry_t *entry, snd_info_buffer_t * buffer) +{ + proc_scb_info_t * scb_info = (proc_scb_info_t *)entry->private_data; + dsp_scb_descriptor_t * scb = scb_info->scb_desc; + dsp_spos_instance_t * ins; + cs46xx_t *chip = snd_magic_cast(cs46xx_t, scb_info->chip, return); + int j,col; + unsigned long dst = chip->region.idx[1].remap_addr + DSP_PARAMETER_BYTE_OFFSET; + + ins = chip->dsp_spos_instance; + + down(&ins->scb_mutex); + snd_iprintf(buffer,"%04x %s:\n",scb->address,scb->scb_name); + + for (col = 0,j = 0;j < 0x10; j++,col++) { + if (col == 4) { + snd_iprintf(buffer,"\n"); + col = 0; + } + snd_iprintf(buffer,"%08x ",readl(dst + (scb->address + j) * sizeof(u32))); + } + + snd_iprintf(buffer,"\n"); + + if (scb->parent_scb_ptr != NULL) { + snd_iprintf(buffer,"parent [%s:%04x] ", + scb->parent_scb_ptr->scb_name, + scb->parent_scb_ptr->address); + } else snd_iprintf(buffer,"parent [none] "); + + snd_iprintf(buffer,"sub_list_ptr [%s:%04x]\nnext_scb_ptr [%s:%04x] task_entry [%s:%04x]\n", + scb->sub_list_ptr->scb_name, + scb->sub_list_ptr->address, + scb->next_scb_ptr->scb_name, + scb->next_scb_ptr->address, + scb->task_entry->symbol_name, + scb->task_entry->address); + + snd_iprintf(buffer,"index [%d] ref_count [%d]\n",scb->index,scb->ref_count); + up(&ins->scb_mutex); +} + +static void _dsp_unlink_scb (cs46xx_t *chip,dsp_scb_descriptor_t * scb) +{ + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + unsigned long flags; + + if ( scb->parent_scb_ptr ) { + /* unlink parent SCB */ + snd_assert ((scb->parent_scb_ptr->sub_list_ptr == scb || + scb->parent_scb_ptr->next_scb_ptr == scb),return); + + if (scb->parent_scb_ptr->sub_list_ptr == scb) { + + if (scb->next_scb_ptr == ins->the_null_scb) { + /* last and only node in parent sublist */ + scb->parent_scb_ptr->sub_list_ptr = scb->sub_list_ptr; + + if (scb->sub_list_ptr != ins->the_null_scb) { + scb->sub_list_ptr->parent_scb_ptr = scb->parent_scb_ptr; + } + scb->sub_list_ptr = ins->the_null_scb; + } else { + /* first node in parent sublist */ + scb->parent_scb_ptr->sub_list_ptr = scb->next_scb_ptr; + + if (scb->next_scb_ptr != ins->the_null_scb) { + /* update next node parent ptr. */ + scb->next_scb_ptr->parent_scb_ptr = scb->parent_scb_ptr; + } + scb->next_scb_ptr = ins->the_null_scb; + } + } else { + snd_assert ( (scb->sub_list_ptr == ins->the_null_scb), return); + scb->parent_scb_ptr->next_scb_ptr = scb->next_scb_ptr; + + if (scb->next_scb_ptr != ins->the_null_scb) { + /* update next node parent ptr. */ + scb->next_scb_ptr->parent_scb_ptr = scb->parent_scb_ptr; + } + scb->next_scb_ptr = ins->the_null_scb; + } + + spin_lock_irqsave(&chip->reg_lock, flags); + /* update entry in DSP RAM */ + snd_cs46xx_poke(chip, + (scb->address + SCBsubListPtr) << 2, + (scb->sub_list_ptr->address << 0x10) | + (scb->next_scb_ptr->address)); + /* update parent entry in DSP RAM */ + snd_cs46xx_poke(chip, + (scb->parent_scb_ptr->address + SCBsubListPtr) << 2, + (scb->parent_scb_ptr->sub_list_ptr->address << 0x10) | + (scb->parent_scb_ptr->next_scb_ptr->address)); + + scb->parent_scb_ptr = NULL; + spin_unlock_irqrestore(&chip->reg_lock, flags); + } +} + +void cs46xx_dsp_remove_scb (cs46xx_t *chip, dsp_scb_descriptor_t * scb) +{ + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + + down(&ins->scb_mutex); + /* check integrety */ + snd_assert ( (scb->index >= 0 && + scb->index < ins->nscb && + (ins->scbs + scb->index) == scb), goto _end ); + +#if 0 + /* cant remove a SCB with childs before + removing childs first */ + snd_assert ( (scb->sub_list_ptr == ins->the_null_scb && + scb->next_scb_ptr == ins->the_null_scb), + goto _end); +#endif + + _dsp_unlink_scb (chip,scb); + + cs46xx_dsp_proc_free_scb_desc(scb); + snd_assert (scb->scb_symbol != NULL, goto _end); + remove_symbol (chip,scb->scb_symbol); + + ins->scbs[scb->index].deleted = 1; + + if (scb->index < ins->scb_highest_frag_index) + ins->scb_highest_frag_index = scb->index; + + if (scb->index == ins->nscb - 1) { + ins->nscb --; + } + + if (ins->scb_highest_frag_index > ins->nscb) { + ins->scb_highest_frag_index = ins->nscb; + } + +#if 0 + /* !!!! THIS IS A PIECE OF SHIT MADE BY ME !!! */ + for(i = scb->index + 1;i < ins->nscb; ++i) { + ins->scbs[i - 1].index = i - 1; + } +#endif + +#ifdef CONFIG_SND_DEBUG + _end: +#endif + up(&ins->scb_mutex); +} + + +void cs46xx_dsp_proc_free_scb_desc (dsp_scb_descriptor_t * scb) +{ + if (scb->proc_info) { + proc_scb_info_t * scb_info = (proc_scb_info_t *)scb->proc_info->private_data; + + snd_printdd("cs46xx_dsp_proc_free_scb_desc: freeing %s\n",scb->scb_name); + + snd_info_unregister(scb->proc_info); + scb->proc_info = NULL; + + snd_assert (scb_info != NULL, return); + kfree (scb_info); + } +} + +void cs46xx_dsp_proc_register_scb_desc (cs46xx_t *chip,dsp_scb_descriptor_t * scb) +{ + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + snd_info_entry_t * entry; + proc_scb_info_t * scb_info; + + down(&ins->scb_mutex); + /* register to proc */ + if (ins->snd_card != NULL && ins->proc_dsp_dir != NULL && + scb->proc_info == NULL) { + + if ((entry = snd_info_create_card_entry(ins->snd_card, scb->scb_name, + ins->proc_dsp_dir)) != NULL) { + scb_info = kmalloc(sizeof(proc_scb_info_t), GFP_KERNEL); + scb_info->chip = chip; + scb_info->scb_desc = scb; + + entry->content = SNDRV_INFO_CONTENT_TEXT; + entry->private_data = scb_info; + entry->mode = S_IFREG | S_IRUGO | S_IWUSR; + + entry->c.text.read_size = 512; + entry->c.text.read = cs46xx_dsp_proc_scb_info_read; + + if (snd_info_register(entry) < 0) { + snd_info_free_entry(entry); + kfree (scb_info); + entry = NULL; + } + } + + scb->proc_info = entry; + } + up(&ins->scb_mutex); +} + +static dsp_scb_descriptor_t * +_dsp_create_generic_scb (cs46xx_t *chip,char * name, u32 * scb_data,u32 dest, + symbol_entry_t * task_entry, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type) +{ + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + dsp_scb_descriptor_t * scb; + + unsigned long flags; + + down(&ins->scb_mutex); + snd_assert (ins->the_null_scb != NULL,goto _fail_end); + + /* fill the data that will be wroten to DSP */ + scb_data[SCBsubListPtr] = + (ins->the_null_scb->address << 0x10) | ins->the_null_scb->address; + + scb_data[SCBfuncEntryPtr] &= 0xFFFF0000; + scb_data[SCBfuncEntryPtr] |= task_entry->address; + + snd_printdd("dsp_spos: creating SCB <%s>\n",name); + + scb = cs46xx_dsp_create_scb(chip,name,scb_data,dest); + + + scb->sub_list_ptr = ins->the_null_scb; + scb->next_scb_ptr = ins->the_null_scb; + + scb->parent_scb_ptr = parent_scb; + scb->task_entry = task_entry; + + + /* update parent SCB */ + if (scb->parent_scb_ptr) { +#if 0 + printk ("scb->parent_scb_ptr = %s\n",scb->parent_scb_ptr->scb_name); + printk ("scb->parent_scb_ptr->next_scb_ptr = %s\n",scb->parent_scb_ptr->next_scb_ptr->scb_name); + printk ("scb->parent_scb_ptr->sub_list_ptr = %s\n",scb->parent_scb_ptr->sub_list_ptr->scb_name); +#endif + /* link to parent SCB */ + if (scb_child_type == SCB_ON_PARENT_NEXT_SCB) { + snd_assert ( (scb->parent_scb_ptr->next_scb_ptr == ins->the_null_scb), + goto _fail_end); + + scb->parent_scb_ptr->next_scb_ptr = scb; + + } else if (scb_child_type == SCB_ON_PARENT_SUBLIST_SCB) { + snd_assert ( (scb->parent_scb_ptr->sub_list_ptr == ins->the_null_scb), + goto _fail_end); + + scb->parent_scb_ptr->sub_list_ptr = scb; + } else { + snd_assert (0,goto _fail_end); + } + + spin_lock_irqsave(&chip->reg_lock, flags); + /* update entry in DSP RAM */ + snd_cs46xx_poke(chip, + (scb->parent_scb_ptr->address + SCBsubListPtr) << 2, + (scb->parent_scb_ptr->sub_list_ptr->address << 0x10) | + (scb->parent_scb_ptr->next_scb_ptr->address)); + + spin_unlock_irqrestore(&chip->reg_lock, flags); + } + + + up(&ins->scb_mutex); + + cs46xx_dsp_proc_register_scb_desc (chip,scb); + + return scb; +#ifdef CONFIG_SND_DEBUG + _fail_end: + + up(&ins->scb_mutex); + return NULL; +#endif +} + +dsp_scb_descriptor_t * +cs46xx_dsp_create_generic_scb (cs46xx_t *chip,char * name, u32 * scb_data,u32 dest, + char * task_entry_name, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type) +{ + symbol_entry_t * task_entry; + + task_entry = cs46xx_dsp_lookup_symbol (chip,task_entry_name, + SYMBOL_CODE); + + if (task_entry == NULL) { + snd_printk (KERN_ERR "dsp_spos: symbol %s not found\n",task_entry_name); + return NULL; + } + + return _dsp_create_generic_scb (chip,name,scb_data,dest,task_entry, + parent_scb,scb_child_type); +} + +dsp_scb_descriptor_t * +cs46xx_dsp_create_timing_master_scb (cs46xx_t *chip) +{ + dsp_scb_descriptor_t * scb; + + timing_master_scb_t timing_master_scb = { + { 0, + 0, + 0, + 0 + }, + { 0, + 0, + 0, + 0, + 0 + }, + 0,0, + 0,NULL_SCB_ADDR, + 0,0, /* extraSampleAccum:TMreserved */ + 0,0, /* codecFIFOptr:codecFIFOsyncd */ + 0x0001,0x8000, /* fracSampAccumQm1:TMfrmsLeftInGroup */ + 0x0001,0x0000, /* fracSampCorrectionQm1:TMfrmGroupLength */ + 0x00060000 /* nSampPerFrmQ15 */ + }; + + scb = cs46xx_dsp_create_generic_scb(chip,"TimingMasterSCBInst",(u32 *)&timing_master_scb, + TIMINGMASTER_SCB_ADDR, + "TIMINGMASTER",NULL,SCB_NO_PARENT); + + return scb; +} + + +dsp_scb_descriptor_t * +cs46xx_dsp_create_codec_out_scb(cs46xx_t * chip,char * codec_name, + u16 channel_disp,u16 fifo_addr, + u16 child_scb_addr, + u32 dest,dsp_scb_descriptor_t * parent_scb, + int scb_child_type) +{ + dsp_scb_descriptor_t * scb; + + codec_output_scb_t codec_out_scb = { + { 0, + 0, + 0, + 0 + }, + { + 0, + 0, + 0, + 0, + 0 + }, + 0,0, + 0,NULL_SCB_ADDR, + 0, /* COstrmRsConfig */ + 0, /* COstrmBufPtr */ + channel_disp,fifo_addr, /* leftChanBaseIOaddr:rightChanIOdisp */ + 0x0000,0x0080, /* (!AC97!) COexpVolChangeRate:COscaleShiftCount */ + 0,child_scb_addr /* COreserved - need child scb to work with rom code */ + }; + + + scb = cs46xx_dsp_create_generic_scb(chip,codec_name,(u32 *)&codec_out_scb, + dest,"S16_CODECOUTPUTTASK",parent_scb, + scb_child_type); + + return scb; +} + +dsp_scb_descriptor_t * +cs46xx_dsp_create_codec_in_scb(cs46xx_t * chip,char * codec_name, + u16 channel_disp,u16 fifo_addr, + u16 sample_buffer_addr, + u32 dest,dsp_scb_descriptor_t * parent_scb, + int scb_child_type) +{ + + dsp_scb_descriptor_t * scb; + codec_input_scb_t codec_input_scb = { + { 0, + 0, + 0, + 0 + }, + { + 0, + 0, + 0, + 0, + 0 + }, + +#if 0 /* cs4620 */ + SyncIOSCB,NULL_SCB_ADDR +#else + 0 , 0, +#endif + 0,0, + + RSCONFIG_SAMPLE_16STEREO + RSCONFIG_MODULO_64, /* strmRsConfig */ + sample_buffer_addr << 0x10, /* strmBufPtr; defined as a dword ptr, used as a byte ptr */ + channel_disp,fifo_addr, /* (!AC97!) leftChanBaseINaddr=AC97primary + link input slot 3 :rightChanINdisp=""slot 4 */ + 0x0000,0x0000, /* (!AC97!) ????:scaleShiftCount; no shift needed + because AC97 is already 20 bits */ + 0x80008000 /* ??clw cwcgame.scb has 0 */ + }; + + scb = cs46xx_dsp_create_generic_scb(chip,codec_name,(u32 *)&codec_input_scb, + dest,"S16_CODECINPUTTASK",parent_scb, + scb_child_type); + return scb; +} + + +dsp_scb_descriptor_t * +cs46xx_dsp_create_pcm_reader_scb(cs46xx_t * chip,char * scb_name, + u16 sample_buffer_addr,u32 dest, + int virtual_channel, u32 playback_hw_addr, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type) +{ + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + dsp_scb_descriptor_t * scb; + + generic_scb_t pcm_reader_scb = { + + /* + Play DMA Task xfers data from host buffer to SP buffer + init/runtime variables: + PlayAC: Play Audio Data Conversion - SCB loc: 2nd dword, mask: 0x0000F000L + DATA_FMT_16BIT_ST_LTLEND(0x00000000L) from 16-bit stereo, little-endian + DATA_FMT_8_BIT_ST_SIGNED(0x00001000L) from 8-bit stereo, signed + DATA_FMT_16BIT_MN_LTLEND(0x00002000L) from 16-bit mono, little-endian + DATA_FMT_8_BIT_MN_SIGNED(0x00003000L) from 8-bit mono, signed + DATA_FMT_16BIT_ST_BIGEND(0x00004000L) from 16-bit stereo, big-endian + DATA_FMT_16BIT_MN_BIGEND(0x00006000L) from 16-bit mono, big-endian + DATA_FMT_8_BIT_ST_UNSIGNED(0x00009000L) from 8-bit stereo, unsigned + DATA_FMT_8_BIT_MN_UNSIGNED(0x0000b000L) from 8-bit mono, unsigned + ? Other combinations possible from: + DMA_RQ_C2_AUDIO_CONVERT_MASK 0x0000F000L + DMA_RQ_C2_AC_NONE 0x00000000L + DMA_RQ_C2_AC_8_TO_16_BIT 0x00001000L + DMA_RQ_C2_AC_MONO_TO_STEREO 0x00002000L + DMA_RQ_C2_AC_ENDIAN_CONVERT 0x00004000L + DMA_RQ_C2_AC_SIGNED_CONVERT 0x00008000L + + HostBuffAddr: Host Buffer Physical Byte Address - SCB loc:3rd dword, Mask: 0xFFFFFFFFL + aligned to dword boundary + */ + /* Basic (non scatter/gather) DMA requestor (4 ints) */ + { DMA_RQ_C1_SOURCE_ON_HOST + /* source buffer is on the host */ + DMA_RQ_C1_SOURCE_MOD1024 + /* source buffer is 1024 dwords (4096 bytes) */ + DMA_RQ_C1_DEST_MOD32 + /* dest buffer(PCMreaderBuf) is 32 dwords*/ + DMA_RQ_C1_WRITEBACK_SRC_FLAG + /* ?? */ + DMA_RQ_C1_WRITEBACK_DEST_FLAG + /* ?? */ + 15, /* DwordCount-1: picked 16 for DwordCount because Jim */ + /* Barnette said that is what we should use since */ + /* we are not running in optimized mode? */ + DMA_RQ_C2_AC_NONE + + DMA_RQ_C2_SIGNAL_SOURCE_PINGPONG + /* set play interrupt (bit0) in HISR when source */ + /* buffer (on host) crosses half-way point */ + virtual_channel, /* Play DMA channel arbitrarily set to 0 */ + playback_hw_addr, /* HostBuffAddr (source) */ + DMA_RQ_SD_SP_SAMPLE_ADDR + /* destination buffer is in SP Sample Memory */ + sample_buffer_addr /* SP Buffer Address (destination) */ + }, + /* Scatter/gather DMA requestor extension (5 ints) */ + { + 0, + 0, + 0, + 0, + 0 + }, + /* Sublist pointer & next stream control block (SCB) link. */ + NULL_SCB_ADDR,NULL_SCB_ADDR, + /* Pointer to this tasks parameter block & stream function pointer */ + 0,NULL_SCB_ADDR, + /* rsConfig register for stream buffer (rsDMA reg. is loaded from basicReq.daw */ + /* for incoming streams, or basicReq.saw, for outgoing streams) */ + RSCONFIG_DMA_ENABLE + /* enable DMA */ + (19 << RSCONFIG_MAX_DMA_SIZE_SHIFT) + /* MAX_DMA_SIZE picked to be 19 since SPUD */ + /* uses it for some reason */ + ((dest >> 4) << RSCONFIG_STREAM_NUM_SHIFT) + /* stream number = SCBaddr/16 */ + RSCONFIG_SAMPLE_16STEREO + + RSCONFIG_MODULO_32, /* dest buffer(PCMreaderBuf) is 32 dwords (256 bytes) */ + /* Stream sample pointer & MAC-unit mode for this stream */ + (sample_buffer_addr << 0x10), + /* Fractional increment per output sample in the input sample buffer */ + 0, + { + /* Standard stereo volume control */ + 0x8000,0x8000, + 0x8000,0x8000 + } + }; + + if (ins->null_algorithm == NULL) { + ins->null_algorithm = cs46xx_dsp_lookup_symbol (chip,"NULLALGORITHM", + SYMBOL_CODE); + + if (ins->null_algorithm == NULL) { + snd_printk (KERN_ERR "dsp_spos: symbol NULLALGORITHM not found\n"); + return NULL; + } + } + + scb = _dsp_create_generic_scb(chip,scb_name,(u32 *)&pcm_reader_scb, + dest,ins->null_algorithm,parent_scb, + scb_child_type); + + return scb; +} + +dsp_scb_descriptor_t * +cs46xx_dsp_create_src_task_scb(cs46xx_t * chip,char * scb_name, + u16 src_buffer_addr, + u16 src_delay_buffer_addr,u32 dest, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type) +{ + + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + dsp_scb_descriptor_t * scb; + + src_task_scb_t src_task_scb = { + 0x0028,0x00c8, + 0x5555,0x0000, + 0x0000,0x0000, + src_buffer_addr,1, + 0x0028,0x00c8, + RSCONFIG_SAMPLE_16STEREO + RSCONFIG_MODULO_32, + 0x0000,src_delay_buffer_addr, + 0x0, + 0x80,(src_delay_buffer_addr + (24 * 4)), + 0,0, /* next_scb, sub_list_ptr */ + 0,0, /* entry, this_spb */ + RSCONFIG_SAMPLE_16STEREO + RSCONFIG_MODULO_8, + src_buffer_addr << 0x10, + 0x04000000, + { + 0x8000,0x8000, + 0xFFFF,0xFFFF + } + }; + + if (ins->s16_up == NULL) { + ins->s16_up = cs46xx_dsp_lookup_symbol (chip,"S16_UPSRC", + SYMBOL_CODE); + + if (ins->s16_up == NULL) { + snd_printk (KERN_ERR "dsp_spos: symbol S16_UPSRC not found\n"); + return NULL; + } + } + + scb = _dsp_create_generic_scb(chip,scb_name,(u32 *)&src_task_scb, + dest,ins->s16_up,parent_scb, + scb_child_type); + + return scb; +} + + +dsp_scb_descriptor_t * +cs46xx_dsp_create_mix_only_scb(cs46xx_t * chip,char * scb_name, + u16 mix_buffer_addr,u32 dest, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type) +{ + dsp_scb_descriptor_t * scb; + + mix_only_scb_t master_mix_scb = { + /* 0 */ { 0, + /* 1 */ 0, + /* 2 */ mix_buffer_addr, + /* 3 */ 0 + /* */ }, + { + /* 4 */ 0, + /* 5 */ 0, + /* 6 */ 0, + /* 7 */ 0, + /* 8 */ 0x00000080 + }, + /* 9 */ 0,0, + /* A */ 0,0, + /* B */ RSCONFIG_SAMPLE_16STEREO + RSCONFIG_MODULO_64, + /* C */ (mix_buffer_addr + (32 * 4)) << 0x10, + /* D */ 0, + { + /* E */ 0x8000,0x8000, + /* F */ 0xFFFF,0xFFFF + } + }; + + + scb = cs46xx_dsp_create_generic_scb(chip,scb_name,(u32 *)&master_mix_scb, + dest,"S16_MIX",parent_scb, + scb_child_type); + return scb; +} + + +dsp_scb_descriptor_t * +cs46xx_dsp_create_mix_to_ostream_scb(cs46xx_t * chip,char * scb_name, + u16 mix_buffer_addr,u16 writeback_spb,u32 dest, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type) +{ + dsp_scb_descriptor_t * scb; + + mix2_ostream_scb_t mix2_ostream_scb = { + /* Basic (non scatter/gather) DMA requestor (4 ints) */ + { + DMA_RQ_C1_SOURCE_MOD64 + + DMA_RQ_C1_DEST_ON_HOST + + DMA_RQ_C1_DEST_MOD1024 + + DMA_RQ_C1_WRITEBACK_SRC_FLAG + + DMA_RQ_C1_WRITEBACK_DEST_FLAG + + 15, + + DMA_RQ_C2_AC_NONE + + DMA_RQ_C2_SIGNAL_DEST_PINGPONG + + + 1, + DMA_RQ_SD_SP_SAMPLE_ADDR + + mix_buffer_addr, + 0x0 + }, + + { 0, 0, 0, 0, 0, }, + 0,0, + 0,writeback_spb, + + RSCONFIG_DMA_ENABLE + + (19 << RSCONFIG_MAX_DMA_SIZE_SHIFT) + + + ((dest >> 4) << RSCONFIG_STREAM_NUM_SHIFT) + + RSCONFIG_DMA_TO_HOST + + RSCONFIG_SAMPLE_16STEREO + + RSCONFIG_MODULO_64, + (mix_buffer_addr + (32 * 4)) << 0x10, + 1,0, + 0x0001,0x0080, + 0xFFFF,0 + }; + + + scb = cs46xx_dsp_create_generic_scb(chip,scb_name,(u32 *)&mix2_ostream_scb, + dest,"S16_MIX_TO_OSTREAM",parent_scb, + scb_child_type); + + return scb; +} + + +dsp_scb_descriptor_t * +cs46xx_dsp_create_vari_decimate_scb(cs46xx_t * chip,char * scb_name, + u16 vari_buffer_addr0, + u16 vari_buffer_addr1, + u32 dest, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type) +{ + + dsp_scb_descriptor_t * scb; + + vari_decimate_scb_t vari_decimate_scb = { + 0x0028,0x00c8, + 0x5555,0x0000, + 0x0000,0x0000, + vari_buffer_addr0,vari_buffer_addr1, + + 0x0028,0x00c8, + RSCONFIG_SAMPLE_16STEREO + RSCONFIG_MODULO_256, + + 0xFF800000, + 0, + 0x0080,vari_buffer_addr1 + (25 * 4), + + 0,0, + 0,0, + + RSCONFIG_SAMPLE_16STEREO + RSCONFIG_MODULO_8, + vari_buffer_addr0 << 0x10, + 0x04000000, + { + 0x8000,0x8000, + 0xFFFF,0xFFFF + } + }; + + scb = cs46xx_dsp_create_generic_scb(chip,scb_name,(u32 *)&vari_decimate_scb, + dest,"VARIDECIMATE",parent_scb, + scb_child_type); + + return scb; +} + + +dsp_scb_descriptor_t * +cs46xx_dsp_create_pcm_serial_input_scb(cs46xx_t * chip,char * scb_name,u32 dest, + dsp_scb_descriptor_t * input_scb, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type) +{ + + dsp_scb_descriptor_t * scb; + + + pcm_serial_input_scb_t pcm_serial_input_scb = { + { 0, + 0, + 0, + 0 + }, + { + 0, + 0, + 0, + 0, + 0 + }, + + 0,0, + 0,0, + + 0x000000c1, + 0, + 0,input_scb->address, + { + 0x8000,0x8000, + 0x8000,0x8000 + } + }; + + scb = cs46xx_dsp_create_generic_scb(chip,scb_name,(u32 *)&pcm_serial_input_scb, + dest,"PCMSERIALINPUTTASK",parent_scb, + scb_child_type); + return scb; +} + + +dsp_scb_descriptor_t * +cs46xx_dsp_create_asynch_fg_tx_scb(cs46xx_t * chip,char * scb_name,u32 dest, + u16 hfg_scb_address, + u16 asynch_buffer_address, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type) +{ + + dsp_scb_descriptor_t * scb; + + asynch_fg_tx_scb_t asynch_fg_tx_scb = { + 0xfc00,0x03ff, /* Prototype sample buffer size of 256 dwords */ + 0x0058,0x0028, /* Min Delta 7 dwords == 28 bytes */ + /* : Max delta 25 dwords == 100 bytes */ + 0,hfg_scb_address, /* Point to HFG task SCB */ + 0,0, /* Initialize current Delta and Consumer ptr adjustment count */ + 0, /* Initialize accumulated Phi to 0 */ + 0,0x2aab, /* Const 1/3 */ + + { + 0, /* Define the unused elements */ + 0, + 0 + }, + + 0,0, + 0,dest + AFGTxAccumPhi, + + 0x000000c5, /* Stereo, 256 dword */ + (asynch_buffer_address) << 0x10, /* This should be automagically synchronized + to the producer pointer */ + + /* There is no correct initial value, it will depend upon the detected + rate etc */ + 0x18000000, /* Phi increment for approx 32k operation */ + 0x8000,0x8000, /* Volume controls are unused at this time */ + 0x8000,0x8000 + }; + + scb = cs46xx_dsp_create_generic_scb(chip,scb_name,(u32 *)&asynch_fg_tx_scb, + dest,"ASYNCHFGTXCODE",parent_scb, + scb_child_type); + + return scb; +} + + +dsp_scb_descriptor_t * +cs46xx_dsp_create_asynch_fg_rx_scb(cs46xx_t * chip,char * scb_name,u32 dest, + u16 hfg_scb_address, + u16 asynch_buffer_address, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type) +{ + + dsp_scb_descriptor_t * scb; + + asynch_fg_rx_scb_t asynch_fg_rx_scb = { + 0xff00,0x00ff, /* Prototype sample buffer size of 512 dwords */ + 0x0064,0x001c, /* Min Delta 7 dwords == 28 bytes */ + /* : Max delta 25 dwords == 100 bytes */ + 0,hfg_scb_address, /* Point to HFG task SCB */ + 0,0, /* Initialize current Delta and Consumer ptr adjustment count */ + { + 0, /* Define the unused elements */ + 0, + 0, + 0, + 0 + }, + + 0,0, + 0,dest, + + 0x000000c3, /* Stereo, 512 dword */ + (asynch_buffer_address << 0x10), /* This should be automagically + synchrinized to the producer pointer */ + + /* There is no correct initial value, it will depend upon the detected + rate etc */ + 0, + 0x8000,0x8000, + 0xFFFF,0xFFFF + }; + + scb = cs46xx_dsp_create_generic_scb(chip,scb_name,(u32 *)&asynch_fg_rx_scb, + dest,"ASYNCHFGRXCODE",parent_scb, + scb_child_type); + + return scb; +} + + +dsp_scb_descriptor_t * +cs46xx_dsp_create_output_snoop_scb(cs46xx_t * chip,char * scb_name,u32 dest, + u16 snoop_buffer_address, + dsp_scb_descriptor_t * snoop_scb, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type) +{ + + dsp_scb_descriptor_t * scb; + + output_snoop_scb_t output_snoop_scb = { + { 0, /* not used. Zero */ + 0, + 0, + 0, + }, + { + 0, /* not used. Zero */ + 0, + 0, + 0, + 0 + }, + + 0,0, + 0,0, + + 0x000000c3, + snoop_buffer_address << 0x10, + 0,0, + 0, + 0,snoop_scb->address + }; + + scb = cs46xx_dsp_create_generic_scb(chip,scb_name,(u32 *)&output_snoop_scb, + dest,"OUTPUTSNOOP",parent_scb, + scb_child_type); + return scb; +} + + +dsp_scb_descriptor_t * +cs46xx_dsp_create_spio_write_scb(cs46xx_t * chip,char * scb_name,u32 dest, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type) +{ + dsp_scb_descriptor_t * scb; + + spio_write_scb_t spio_write_scb = { + 0,0, /* SPIOWAddress2:SPIOWAddress1; */ + 0, /* SPIOWData1; */ + 0, /* SPIOWData2; */ + 0,0, /* SPIOWAddress4:SPIOWAddress3; */ + 0, /* SPIOWData3; */ + 0, /* SPIOWData4; */ + 0,0, /* SPIOWDataPtr:Unused1; */ + { 0,0 }, /* Unused2[2]; */ + + 0,0, /* SPIOWChildPtr:SPIOWSiblingPtr; */ + 0,0, /* SPIOWThisPtr:SPIOWEntryPoint; */ + + { + 0, + 0, + 0, + 0, + 0 /* Unused3[5]; */ + } + }; + + scb = cs46xx_dsp_create_generic_scb(chip,scb_name,(u32 *)&spio_write_scb, + dest,"SPIOWRITE",parent_scb, + scb_child_type); + + return scb; +} + +dsp_scb_descriptor_t * cs46xx_dsp_create_magic_snoop_scb(cs46xx_t * chip,char * scb_name,u32 dest, + u16 snoop_buffer_address, + dsp_scb_descriptor_t * snoop_scb, + dsp_scb_descriptor_t * parent_scb, + int scb_child_type) +{ + dsp_scb_descriptor_t * scb; + + magic_snoop_task_t magic_snoop_scb = { + /* 0 */ 0, /* i0 */ + /* 1 */ 0, /* i1 */ + /* 2 */ snoop_buffer_address << 0x10, + /* 3 */ 0,snoop_scb->address, + /* 4 */ 0, /* i3 */ + /* 5 */ 0, /* i4 */ + /* 6 */ 0, /* i5 */ + /* 7 */ 0, /* i6 */ + /* 8 */ 0, /* i7 */ + /* 9 */ 0,0, /* next_scb, sub_list_ptr */ + /* A */ 0,0, /* entry_point, this_ptr */ + /* B */ RSCONFIG_SAMPLE_16STEREO + RSCONFIG_MODULO_64, + /* C */ snoop_buffer_address << 0x10, + /* D */ 0, + /* E */ { 0x8000,0x8000, + /* F */ 0xffff,0xffff + } + }; + + scb = cs46xx_dsp_create_generic_scb(chip,scb_name,(u32 *)&magic_snoop_scb, + dest,"MAGICSNOOPTASK",parent_scb, + scb_child_type); + + return scb; +} + +static dsp_scb_descriptor_t * find_next_free_scb (cs46xx_t * chip,dsp_scb_descriptor_t * from) +{ + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + dsp_scb_descriptor_t * scb = from; + + while (scb->next_scb_ptr != ins->the_null_scb) { + snd_assert (scb->next_scb_ptr != NULL, return NULL); + + scb = scb->next_scb_ptr; + } + + return scb; +} + +static u32 pcm_reader_buffer_addr[DSP_MAX_PCM_CHANNELS] = { + 0x0600, /* 1 */ + 0x1500, /* 2 */ + 0x1580, /* 3 */ + 0x1600, /* 4 */ + 0x1680, /* 5 */ + 0x1700, /* 6 */ + 0x1780, /* 7 */ + 0x1800, /* 8 */ + 0x1880, /* 9 */ + 0x1900, /* 10 */ + 0x1980, /* 11 */ + 0x1A00, /* 12 */ + 0x1A80, /* 13 */ + 0x1B00, /* 14 */ + 0x1B80, /* 15 */ + 0x1C00, /* 16 */ + 0x1C80, /* 17 */ + 0x1D00, /* 18 */ + 0x1D80, /* 19 */ + 0x1E00, /* 20 */ + 0x1E80, /* 21 */ + 0x1F00, /* 22 */ + 0x1F80, /* 23 */ + 0x2000, /* 24 */ + 0x2080, /* 25 */ + 0x2100, /* 26 */ + 0x2180, /* 27 */ + 0x2200, /* 28 */ + 0x2280, /* 29 */ + 0x2300, /* 30 */ + 0x2380, /* 31 */ + 0x2400, /* 32 */ +}; + +static u32 src_output_buffer_addr[DSP_MAX_SRC_NR] = { + 0x2580, + 0x2680, + 0x2780, + 0x2980, + 0x2A80, + 0x2B80, +}; + +static u32 src_delay_buffer_addr[DSP_MAX_SRC_NR] = { + 0x2600, + 0x2700, + 0x2800, + 0x2900, + 0x2A00, + 0x2B00, +}; + +pcm_channel_descriptor_t * cs46xx_dsp_create_pcm_channel (cs46xx_t * chip,u32 sample_rate, void * private_data) +{ + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + dsp_scb_descriptor_t * src_scb = NULL,* pcm_scb; + dsp_scb_descriptor_t * pcm_parent_scb; + char scb_name[DSP_MAX_SCB_NAME]; + int i,pcm_index = -1, insert_point, src_index = -1; + unsigned long flags; + + down(&ins->pcm_mutex); + + /* default sample rate is 44100 */ + if (!sample_rate) sample_rate = 44100; + + /* search for a already created SRC SCB with the same sample rate */ + for (i = 0; i < DSP_MAX_PCM_CHANNELS && + (pcm_index == -1 || src_scb == NULL); ++i) { + + /* virtual channel reserved + for capture */ + if (i == 1) continue; + + if (ins->pcm_channels[i].active) { + if (!src_scb && ins->pcm_channels[i].sample_rate == sample_rate) { + src_scb = ins->pcm_channels[i].src_scb; + ins->pcm_channels[i].src_scb->ref_count ++; + src_index = ins->pcm_channels[i].src_slot; + } + } else if (pcm_index == -1) { + pcm_index = i; + } + } + + if (pcm_index == -1) { + snd_printk (KERN_ERR "dsp_spos: no free PCM channel\n"); + goto _end; + } + + if (src_scb == NULL) { + dsp_scb_descriptor_t * src_parent_scb; + + if (ins->nsrc_scb >= DSP_MAX_SRC_NR) { + snd_printk(KERN_ERR "dsp_spos: to many SRC instances\n!"); + goto _end; + } + + /* find a free slot */ + for (i = 0; i < DSP_MAX_SRC_NR; ++i) { + if (ins->src_scb_slots[i] == 0) { + src_index = i; + ins->src_scb_slots[i] = 1; + break; + } + } + snd_assert (src_index != -1,goto _end); + + /* we need to create a new SRC SCB */ + if (ins->master_mix_scb->sub_list_ptr == ins->the_null_scb) { + src_parent_scb = ins->master_mix_scb; + insert_point = SCB_ON_PARENT_SUBLIST_SCB; + } else { + src_parent_scb = find_next_free_scb(chip,ins->master_mix_scb->sub_list_ptr); + insert_point = SCB_ON_PARENT_NEXT_SCB; + } + + snprintf (scb_name,DSP_MAX_SCB_NAME,"SrcTask_SCB%d",src_index); + + snd_printdd( "dsp_spos: creating SRC \"%s\"\n",scb_name); + src_scb = cs46xx_dsp_create_src_task_scb(chip,scb_name, + src_output_buffer_addr[src_index], + src_delay_buffer_addr[src_index], + /* 0x400 - 0x600 source SCBs */ + 0x400 + (src_index * 0x10) , + src_parent_scb, + insert_point); + + if (!src_scb) { + snd_printk (KERN_ERR "dsp_spos: failed to create SRCtaskSCB\n"); + goto _end; + } + + cs46xx_dsp_set_src_sample_rate(chip,src_scb,sample_rate); + + ins->nsrc_scb ++; + + /* insert point for the PCMreader task */ + pcm_parent_scb = src_scb; + insert_point = SCB_ON_PARENT_SUBLIST_SCB; + } else { + snd_assert (src_scb->sub_list_ptr != ins->the_null_scb, goto _end); + pcm_parent_scb = find_next_free_scb(chip,src_scb->sub_list_ptr); + + insert_point = SCB_ON_PARENT_NEXT_SCB; + } + + + + snprintf (scb_name,DSP_MAX_SCB_NAME,"PCMReader_SCB%d",pcm_index); + + snd_printdd( "dsp_spos: creating PCM \"%s\"\n",scb_name); + + pcm_scb = cs46xx_dsp_create_pcm_reader_scb(chip,scb_name, + pcm_reader_buffer_addr[pcm_index], + /* 0x200 - 400 PCMreader SCBs */ + (pcm_index * 0x10) + 0x200, + pcm_index, /* virtual channel 0-31 */ + 0, /* pcm hw addr */ + pcm_parent_scb, + insert_point); + + if (!pcm_scb) { + snd_printk (KERN_ERR "dsp_spos: failed to create PCMreaderSCB\n"); + goto _end; + } + + spin_lock_irqsave(&chip->reg_lock, flags); + ins->pcm_channels[pcm_index].sample_rate = sample_rate; + ins->pcm_channels[pcm_index].pcm_reader_scb = pcm_scb; + ins->pcm_channels[pcm_index].src_scb = src_scb; + ins->pcm_channels[pcm_index].unlinked = 0; + ins->pcm_channels[pcm_index].private_data = private_data; + ins->pcm_channels[pcm_index].src_slot = src_index; + ins->pcm_channels[pcm_index].active = 1; + ins->pcm_channels[pcm_index].pcm_slot = pcm_index; + ins->npcm_channels ++; + spin_unlock_irqrestore(&chip->reg_lock, flags); + + up(&ins->pcm_mutex); + return (ins->pcm_channels + pcm_index); + _end: + + up(&ins->pcm_mutex); + return NULL; +} + +void cs46xx_dsp_destroy_pcm_channel (cs46xx_t * chip,pcm_channel_descriptor_t * pcm_channel) +{ + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + unsigned long flags; + + down(&ins->pcm_mutex); + + snd_assert(pcm_channel->active,goto _end); + snd_assert(ins->npcm_channels > 0,goto _end); + snd_assert(pcm_channel->src_scb->ref_count > 0,goto _end); + + spin_lock_irqsave(&chip->reg_lock, flags); + pcm_channel->unlinked = 1; + pcm_channel->active = 0; + pcm_channel->private_data = NULL; + pcm_channel->src_scb->ref_count --; + ins->npcm_channels --; + spin_unlock_irqrestore(&chip->reg_lock, flags); + + cs46xx_dsp_remove_scb(chip,pcm_channel->pcm_reader_scb); + + if (!pcm_channel->src_scb->ref_count) { + cs46xx_dsp_remove_scb(chip,pcm_channel->src_scb); + + snd_assert (pcm_channel->src_slot >= 0 && pcm_channel->src_slot <= DSP_MAX_SRC_NR, + goto _end); + + ins->src_scb_slots[pcm_channel->src_slot] = 0; + ins->nsrc_scb --; + } + + +#ifdef CONFIG_SND_DEBUG + _end: +#endif + + up(&ins->pcm_mutex); +} + +int cs46xx_dsp_pcm_unlink (cs46xx_t * chip,pcm_channel_descriptor_t * pcm_channel) +{ + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + unsigned long flags; + + down(&ins->pcm_mutex); + down(&ins->scb_mutex); + + snd_assert(pcm_channel->active,goto _end); + snd_assert(ins->npcm_channels > 0,goto _end); + + if (pcm_channel->unlinked) + goto _end; + + spin_lock_irqsave(&chip->reg_lock, flags); + pcm_channel->unlinked = 1; + spin_unlock_irqrestore(&chip->reg_lock, flags); + + _dsp_unlink_scb (chip,pcm_channel->pcm_reader_scb); + + _end: + up(&ins->scb_mutex); + up(&ins->pcm_mutex); + + return 0; +} + +int cs46xx_dsp_pcm_link (cs46xx_t * chip,pcm_channel_descriptor_t * pcm_channel) +{ + dsp_spos_instance_t * ins = chip->dsp_spos_instance; + dsp_scb_descriptor_t * parent_scb; + dsp_scb_descriptor_t * src_scb = pcm_channel->src_scb; + unsigned long flags; + + down(&ins->pcm_mutex); + down(&ins->scb_mutex); + + if (pcm_channel->unlinked == 0) + goto _end; + + if (src_scb->sub_list_ptr == ins->the_null_scb) { + parent_scb = src_scb; + parent_scb->sub_list_ptr = pcm_channel->pcm_reader_scb; + } else { + parent_scb = find_next_free_scb(chip,src_scb->sub_list_ptr); + parent_scb->next_scb_ptr = pcm_channel->pcm_reader_scb; + } + + snd_assert (pcm_channel->pcm_reader_scb->parent_scb_ptr == NULL, ; ); + pcm_channel->pcm_reader_scb->parent_scb_ptr = parent_scb; + + /* update entry in DSP RAM */ + spin_lock_irqsave(&chip->reg_lock, flags); + snd_cs46xx_poke(chip, + (parent_scb->address + SCBsubListPtr) << 2, + (parent_scb->sub_list_ptr->address << 0x10) | + (parent_scb->next_scb_ptr->address)); + + pcm_channel->unlinked = 0; + spin_unlock_irqrestore(&chip->reg_lock, flags); + + _end: + up(&ins->scb_mutex); + up(&ins->pcm_mutex); + + return 0; +} + +#define GOF_PER_SEC 200 + +void cs46xx_dsp_set_src_sample_rate(cs46xx_t *chip,dsp_scb_descriptor_t * src, u32 rate) +{ + unsigned long flags; + unsigned int tmp1, tmp2; + unsigned int phiIncr; + unsigned int correctionPerGOF, correctionPerSec; + + snd_printdd( "dsp_spos: setting SRC rate to %u\n",rate); + /* + * Compute the values used to drive the actual sample rate conversion. + * The following formulas are being computed, using inline assembly + * since we need to use 64 bit arithmetic to compute the values: + * + * phiIncr = floor((Fs,in * 2^26) / Fs,out) + * correctionPerGOF = floor((Fs,in * 2^26 - Fs,out * phiIncr) / + * GOF_PER_SEC) + * ulCorrectionPerSec = Fs,in * 2^26 - Fs,out * phiIncr -M + * GOF_PER_SEC * correctionPerGOF + * + * i.e. + * + * phiIncr:other = dividend:remainder((Fs,in * 2^26) / Fs,out) + * correctionPerGOF:correctionPerSec = + * dividend:remainder(ulOther / GOF_PER_SEC) + */ + tmp1 = rate << 16; + phiIncr = tmp1 / 48000; + tmp1 -= phiIncr * 48000; + tmp1 <<= 10; + phiIncr <<= 10; + tmp2 = tmp1 / 48000; + phiIncr += tmp2; + tmp1 -= tmp2 * 48000; + correctionPerGOF = tmp1 / GOF_PER_SEC; + tmp1 -= correctionPerGOF * GOF_PER_SEC; + correctionPerSec = tmp1; + + /* + * Fill in the SampleRateConverter control block. + */ + spin_lock_irqsave(&chip->reg_lock, flags); + + snd_cs46xx_poke(chip, (src->address + SRCCorPerGof) << 2, + ((correctionPerSec << 16) & 0xFFFF0000) | (correctionPerGOF & 0xFFFF)); + + snd_cs46xx_poke(chip, (src->address + SRCPhiIncr6Int26Frac) << 2, phiIncr); + + spin_unlock_irqrestore(&chip->reg_lock, flags); +} diff -Nru a/sound/pci/cs46xx/imgs/cwc4630.h b/sound/pci/cs46xx/imgs/cwc4630.h --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/sound/pci/cs46xx/imgs/cwc4630.h Sun Sep 29 20:23:44 2002 @@ -0,0 +1,320 @@ +/* generated from cwc4630.osp DO NOT MODIFY */ + +#ifndef __HEADER_cwc4630_H__ +#define __HEADER_cwc4630_H__ + +static symbol_entry_t cwc4630_symbols[] = { + { 0x0000, "BEGINADDRESS",0x00 }, + { 0x8000, "EXECCHILD",0x03 }, + { 0x8001, "EXECCHILD_98",0x03 }, + { 0x8003, "EXECCHILD_PUSH1IND",0x03 }, + { 0x8008, "EXECSIBLING",0x03 }, + { 0x800a, "EXECSIBLING_298",0x03 }, + { 0x800b, "EXECSIBLING_2IND1",0x03 }, + { 0x8010, "TIMINGMASTER",0x03 }, + { 0x804f, "S16_CODECINPUTTASK",0x03 }, + { 0x805e, "PCMSERIALINPUTTASK",0x03 }, + { 0x806d, "S16_MIX_TO_OSTREAM",0x03 }, + { 0x809a, "S16_MIX",0x03 }, + { 0x80bb, "S16_UPSRC",0x03 }, + { 0x813b, "MIX3_EXP",0x03 }, + { 0x8164, "DECIMATEBYPOW2",0x03 }, + { 0x8197, "VARIDECIMATE",0x03 }, + { 0x81f2, "_3DINPUTTASK",0x03 }, + { 0x820a, "_3DPRLGCINPTASK",0x03 }, + { 0x8227, "_3DSTEREOINPUTTASK",0x03 }, + { 0x8242, "_3DOUTPUTTASK",0x03 }, + { 0x82c4, "HRTF_MORPH_TASK",0x03 }, + { 0x82c6, "WAIT4DATA",0x03 }, + { 0x82fa, "PROLOGIC",0x03 }, + { 0x8496, "DECORRELATOR",0x03 }, + { 0x84a4, "STEREO2MONO",0x03 }, + { 0x0070, "SPOSCB",0x02 }, + { 0x0107, "TASKTREETHREAD",0x03 }, + { 0x013c, "TASKTREEHEADERCODE",0x03 }, + { 0x0145, "FGTASKTREEHEADERCODE",0x03 }, + { 0x0169, "NULLALGORITHM",0x03 }, + { 0x016d, "HFGEXECCHILD",0x03 }, + { 0x016e, "HFGEXECCHILD_98",0x03 }, + { 0x0170, "HFGEXECCHILD_PUSH1IND",0x03 }, + { 0x0173, "HFGEXECSIBLING",0x03 }, + { 0x0175, "HFGEXECSIBLING_298",0x03 }, + { 0x0176, "HFGEXECSIBLING_2IND1",0x03 }, + { 0x0179, "S16_CODECOUTPUTTASK",0x03 }, + { 0x0194, "#CODE_END",0x00 }, +}; /* cwc4630 symbols */ + +static u32 cwc4630_code[] = { +/* BEGINADDRESS */ +/* 0000 */ 0x00040730,0x00001002,0x000f619e,0x00001003, +/* 0002 */ 0x00001705,0x00001400,0x000a411e,0x00001003, +/* 0004 */ 0x00040730,0x00001002,0x000f619e,0x00001003, +/* 0006 */ 0x00009705,0x00001400,0x000a411e,0x00001003, +/* 0008 */ 0x00040730,0x00001002,0x000f619e,0x00001003, +/* 000A */ 0x00011705,0x00001400,0x000a411e,0x00001003, +/* 000C */ 0x00040730,0x00001002,0x000f619e,0x00001003, +/* 000E */ 0x00019705,0x00001400,0x000a411e,0x00001003, +/* 0010 */ 0x00040730,0x00001002,0x000f619e,0x00001003, +/* 0012 */ 0x00021705,0x00001400,0x000a411e,0x00001003, +/* 0014 */ 0x00040730,0x00001002,0x000f619e,0x00001003, +/* 0016 */ 0x00029705,0x00001400,0x000a411e,0x00001003, +/* 0018 */ 0x00040730,0x00001002,0x000f619e,0x00001003, +/* 001A */ 0x00031705,0x00001400,0x000a411e,0x00001003, +/* 001C */ 0x00040730,0x00001002,0x000f619e,0x00001003, +/* 001E */ 0x00039705,0x00001400,0x000a411e,0x00001003, +/* 0020 */ 0x000fe19e,0x00001003,0x0009c730,0x00001003, +/* 0022 */ 0x0008e19c,0x00001003,0x000083c1,0x00093040, +/* 0024 */ 0x00098730,0x00001002,0x000ee19e,0x00001003, +/* 0026 */ 0x00009705,0x00001400,0x000a211e,0x00001003, +/* 0028 */ 0x00098730,0x00001002,0x000ee19e,0x00001003, +/* 002A */ 0x00011705,0x00001400,0x000a211e,0x00001003, +/* 002C */ 0x00098730,0x00001002,0x000ee19e,0x00001003, +/* 002E */ 0x00019705,0x00001400,0x000a211e,0x00001003, +/* 0030 */ 0x00098730,0x00001002,0x000ee19e,0x00001003, +/* 0032 */ 0x00021705,0x00001400,0x000a211e,0x00001003, +/* 0034 */ 0x00098730,0x00001002,0x000ee19e,0x00001003, +/* 0036 */ 0x00029705,0x00001400,0x000a211e,0x00001003, +/* 0038 */ 0x00098730,0x00001002,0x000ee19e,0x00001003, +/* 003A */ 0x00031705,0x00001400,0x000a211e,0x00001003, +/* 003C */ 0x00098730,0x00001002,0x000ee19e,0x00001003, +/* 003E */ 0x00039705,0x00001400,0x000a211e,0x00001003, +/* 0040 */ 0x0001a730,0x00001008,0x000e2730,0x00001002, +/* 0042 */ 0x0000a731,0x00001002,0x0000a731,0x00001002, +/* 0044 */ 0x0000a731,0x00001002,0x0000a731,0x00001002, +/* 0046 */ 0x0000a731,0x00001002,0x0000a731,0x00001002, +/* 0048 */ 0x00000000,0x00000000,0x000f619c,0x00001003, +/* 004A */ 0x0007f801,0x000c0000,0x00000037,0x00001000, +/* 004C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 004E */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0050 */ 0x00000000,0x000c0000,0x00000000,0x00000000, +/* 0052 */ 0x0000373c,0x00001000,0x00000000,0x00000000, +/* 0054 */ 0x000ee19c,0x00001003,0x0007f801,0x000c0000, +/* 0056 */ 0x00000037,0x00001000,0x00000000,0x00000000, +/* 0058 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 005A */ 0x00000000,0x00000000,0x0000273c,0x00001000, +/* 005C */ 0x00000033,0x00001000,0x000e679e,0x00001003, +/* 005E */ 0x00007705,0x00001400,0x000ac71e,0x00001003, +/* 0060 */ 0x00087fc1,0x000c3be0,0x0007f801,0x000c0000, +/* 0062 */ 0x00000037,0x00001000,0x00000000,0x00000000, +/* 0064 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0066 */ 0x00000000,0x00000000,0x0000a730,0x00001003, +/* 0068 */ 0x00000033,0x00001000,0x0007f801,0x000c0000, +/* 006A */ 0x00000037,0x00001000,0x00000000,0x00000000, +/* 006C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 006E */ 0x00000000,0x00000000,0x00000000,0x000c0000, +/* 0070 */ 0x00000032,0x00001000,0x0000273d,0x00001000, +/* 0072 */ 0x0004a730,0x00001003,0x00000f41,0x00097140, +/* 0074 */ 0x0000a841,0x0009b240,0x0000a0c1,0x0009f040, +/* 0076 */ 0x0001c641,0x00093540,0x0001cec1,0x0009b5c0, +/* 0078 */ 0x00000000,0x00000000,0x0001bf05,0x0003fc40, +/* 007A */ 0x00002725,0x000aa400,0x00013705,0x00093a00, +/* 007C */ 0x0000002e,0x0009d6c0,0x0002ef8a,0x00000000, +/* 007E */ 0x00040630,0x00001004,0x0004ef0a,0x000eb785, +/* 0080 */ 0x0003fc8a,0x00000000,0x00000000,0x000c70e0, +/* 0082 */ 0x0007d182,0x0002c640,0x00008630,0x00001004, +/* 0084 */ 0x000799b8,0x0002c6c0,0x00031705,0x00092240, +/* 0086 */ 0x00039f05,0x000932c0,0x0003520a,0x00000000, +/* 0088 */ 0x00070731,0x0000100b,0x00010705,0x000b20c0, +/* 008A */ 0x00000000,0x000eba44,0x00032108,0x000c60c4, +/* 008C */ 0x00065208,0x000c2917,0x000486b0,0x00001007, +/* 008E */ 0x00012f05,0x00036880,0x0002818e,0x000c0000, +/* 0090 */ 0x0004410a,0x00000000,0x00048630,0x00001007, +/* 0092 */ 0x00029705,0x000c0000,0x00000000,0x00000000, +/* 0094 */ 0x00003fc1,0x0003fc40,0x000037c1,0x00091b40, +/* 0096 */ 0x00003fc1,0x000911c0,0x000037c1,0x000957c0, +/* 0098 */ 0x00003fc1,0x000951c0,0x000037c1,0x00000000, +/* 009A */ 0x00003fc1,0x000991c0,0x000037c1,0x00000000, +/* 009C */ 0x00003fc1,0x0009d1c0,0x000037c1,0x00000000, +/* 009E */ 0x0001ccc1,0x000915c0,0x0001c441,0x0009d800, +/* 00A0 */ 0x0009cdc1,0x00091240,0x0001c541,0x00091d00, +/* 00A2 */ 0x0009cfc1,0x00095240,0x0001c741,0x00095c80, +/* 00A4 */ 0x000e8ca9,0x00099240,0x000e85ad,0x00095640, +/* 00A6 */ 0x00069ca9,0x00099d80,0x000e952d,0x00099640, +/* 00A8 */ 0x000eaca9,0x0009d6c0,0x000ea5ad,0x00091a40, +/* 00AA */ 0x0006bca9,0x0009de80,0x000eb52d,0x00095a40, +/* 00AC */ 0x000ecca9,0x00099ac0,0x000ec5ad,0x0009da40, +/* 00AE */ 0x000edca9,0x0009d300,0x000a6e0a,0x00001000, +/* 00B0 */ 0x000ed52d,0x00091e40,0x000eeca9,0x00095ec0, +/* 00B2 */ 0x000ee5ad,0x00099e40,0x0006fca9,0x00002500, +/* 00B4 */ 0x000fb208,0x000c59a0,0x000ef52d,0x0009de40, +/* 00B6 */ 0x00068ca9,0x000912c1,0x000683ad,0x00095241, +/* 00B8 */ 0x00020f05,0x000991c1,0x00000000,0x00000000, +/* 00BA */ 0x00086f88,0x00001000,0x0009cf81,0x000b5340, +/* 00BC */ 0x0009c701,0x000b92c0,0x0009de81,0x000bd300, +/* 00BE */ 0x0009d601,0x000b1700,0x0001fd81,0x000b9d80, +/* 00C0 */ 0x0009f501,0x000b57c0,0x000a0f81,0x000bd740, +/* 00C2 */ 0x00020701,0x000b5c80,0x000a1681,0x000b97c0, +/* 00C4 */ 0x00021601,0x00002500,0x000a0701,0x000b9b40, +/* 00C6 */ 0x000a0f81,0x000b1bc0,0x00021681,0x00002d00, +/* 00C8 */ 0x00020f81,0x000bd800,0x000a0701,0x000b5bc0, +/* 00CA */ 0x00021601,0x00003500,0x000a0f81,0x000b5f40, +/* 00CC */ 0x000a0701,0x000bdbc0,0x00021681,0x00003d00, +/* 00CE */ 0x00020f81,0x000b1d00,0x000a0701,0x000b1fc0, +/* 00D0 */ 0x00021601,0x00020500,0x00020f81,0x000b1341, +/* 00D2 */ 0x000a0701,0x000b9fc0,0x00021681,0x00020d00, +/* 00D4 */ 0x00020f81,0x000bde80,0x000a0701,0x000bdfc0, +/* 00D6 */ 0x00021601,0x00021500,0x00020f81,0x000b9341, +/* 00D8 */ 0x00020701,0x000b53c1,0x00021681,0x00021d00, +/* 00DA */ 0x000a0f81,0x000d0380,0x0000b601,0x000b15c0, +/* 00DC */ 0x00007b01,0x00000000,0x00007b81,0x000bd1c0, +/* 00DE */ 0x00007b01,0x00000000,0x00007b81,0x000b91c0, +/* 00E0 */ 0x00007b01,0x000b57c0,0x00007b81,0x000b51c0, +/* 00E2 */ 0x00007b01,0x000b1b40,0x00007b81,0x000b11c0, +/* 00E4 */ 0x00087b01,0x000c3dc0,0x0007e488,0x000d7e45, +/* 00E6 */ 0x00000000,0x000d7a44,0x0007e48a,0x00000000, +/* 00E8 */ 0x00011f05,0x00084080,0x00000000,0x00000000, +/* 00EA */ 0x00001705,0x000b3540,0x00008a01,0x000bf040, +/* 00EC */ 0x00007081,0x000bb5c0,0x00055488,0x00000000, +/* 00EE */ 0x0000d482,0x0003fc40,0x0003fc88,0x00000000, +/* 00F0 */ 0x0001e401,0x000b3a00,0x0001ec81,0x000bd6c0, +/* 00F2 */ 0x0002ef88,0x000e7784,0x00056f08,0x00000000, +/* 00F4 */ 0x000d86b0,0x00001007,0x00008281,0x000bb240, +/* 00F6 */ 0x0000b801,0x000b7140,0x00007888,0x00000000, +/* 00F8 */ 0x0000073c,0x00001000,0x0007f188,0x000c0000, +/* 00FA */ 0x00000000,0x00000000,0x00055288,0x000c555c, +/* 00FC */ 0x0005528a,0x000c0000,0x0009fa88,0x000c5d00, +/* 00FE */ 0x0000fa88,0x00000000,0x00000032,0x00001000, +/* 0100 */ 0x0000073d,0x00001000,0x0007f188,0x000c0000, +/* 0102 */ 0x00000000,0x00000000,0x0008c01c,0x00001003, +/* 0104 */ 0x00002705,0x00001008,0x0008b201,0x000c1392, +/* 0106 */ 0x0000ba01,0x00000000, +/* TASKTREETHREAD */ +/* 0107 */ 0x00008731,0x00001400,0x0004c108,0x000fe0c4, +/* 0109 */ 0x00057488,0x00000000,0x000a6388,0x00001001, +/* 010B */ 0x0008b334,0x000bc141,0x0003020e,0x00000000, +/* 010D */ 0x000986b0,0x00001008,0x00003625,0x000c5dfa, +/* 010F */ 0x000a638a,0x00001001,0x0008020e,0x00001002, +/* 0111 */ 0x0009a6b0,0x00001008,0x0007f301,0x00000000, +/* 0113 */ 0x00000000,0x00000000,0x00002725,0x000a8c40, +/* 0115 */ 0x000000ae,0x00000000,0x000e8630,0x00001008, +/* 0117 */ 0x00000000,0x000c74e0,0x0007d182,0x0002d640, +/* 0119 */ 0x000b8630,0x00001008,0x000799b8,0x0002d6c0, +/* 011B */ 0x0000748a,0x000c3ec5,0x0007420a,0x000c0000, +/* 011D */ 0x00062208,0x000c4117,0x000a0630,0x00001009, +/* 011F */ 0x00000000,0x000c0000,0x0001022e,0x00000000, +/* 0121 */ 0x0006a630,0x00001009,0x00000032,0x00001000, +/* 0123 */ 0x000ca21c,0x00001003,0x00005a02,0x00000000, +/* 0125 */ 0x0001a630,0x00001009,0x00000000,0x000c0000, +/* 0127 */ 0x00000036,0x00001000,0x00000000,0x00000000, +/* 0129 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 012B */ 0x00000000,0x00000000,0x0003a730,0x00001008, +/* 012D */ 0x0007f801,0x000c0000,0x00000037,0x00001000, +/* 012F */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0131 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0133 */ 0x0003a730,0x00001008,0x00000033,0x00001000, +/* 0135 */ 0x0003a705,0x00001008,0x00007a01,0x000c0000, +/* 0137 */ 0x000e6288,0x000d550a,0x0006428a,0x00000000, +/* 0139 */ 0x00090730,0x0000100a,0x00000000,0x000c0000, +/* 013B */ 0x00000000,0x00000000, +/* TASKTREEHEADERCODE */ +/* 013C */ 0x0007aab0,0x00034880,0x000a8fb0,0x0000100b, +/* 013E */ 0x00057488,0x00000000,0x00033b94,0x00081140, +/* 0140 */ 0x000183ae,0x00000000,0x000a86b0,0x0000100b, +/* 0142 */ 0x00022f05,0x000c3545,0x0000eb8a,0x00000000, +/* 0144 */ 0x00042731,0x00001003, +/* FGTASKTREEHEADERCODE */ +/* 0145 */ 0x0007aab0,0x00034880,0x00078fb0,0x0000100a, +/* 0147 */ 0x00057488,0x00000000,0x00033b94,0x00081140, +/* 0149 */ 0x000183ae,0x00000000,0x000b06b0,0x0000100b, +/* 014B */ 0x00022f05,0x00000000,0x00007401,0x00091140, +/* 014D */ 0x00048f05,0x000951c0,0x00042731,0x00001003, +/* 014F */ 0x0000473d,0x00001000,0x000f19b0,0x000bbc47, +/* 0151 */ 0x00080000,0x000bffc7,0x000fe19e,0x00001003, +/* 0153 */ 0x00000000,0x00000000,0x0008e19c,0x00001003, +/* 0155 */ 0x000083c1,0x00093040,0x00000f41,0x00097140, +/* 0157 */ 0x0000a841,0x0009b240,0x0000a0c1,0x0009f040, +/* 0159 */ 0x0001c641,0x00093540,0x0001cec1,0x0009b5c0, +/* 015B */ 0x00000000,0x000fdc44,0x00055208,0x00000000, +/* 015D */ 0x00010705,0x000a2880,0x0000a23a,0x00093a00, +/* 015F */ 0x0003fc8a,0x000df6c5,0x0004ef0a,0x000c0000, +/* 0161 */ 0x00012f05,0x00036880,0x00065308,0x000c2997, +/* 0163 */ 0x000086b0,0x0000100b,0x0004410a,0x000d40c7, +/* 0165 */ 0x00000000,0x00000000,0x00088730,0x00001004, +/* 0167 */ 0x00056f0a,0x000ea105,0x00000000,0x00000000, +/* NULLALGORITHM */ +/* 0169 */ 0x0000473d,0x00001000,0x000f19b0,0x000bbc47, +/* 016B */ 0x00080000,0x000bffc7,0x0000273d,0x00001000, +/* HFGEXECCHILD */ +/* 016D */ 0x00000000,0x000eba44, +/* HFGEXECCHILD_98 */ +/* 016E */ 0x00048f05,0x0000f440,0x00007401,0x0000f7c0, +/* HFGEXECCHILD_PUSH1IND */ +/* 0170 */ 0x00000734,0x00001000,0x00010705,0x000a6880, +/* 0172 */ 0x00006a88,0x000c75c4, +/* HFGEXECSIBLING */ +/* 0173 */ 0x00000000,0x000e5084,0x00000000,0x000eba44, +/* HFGEXECSIBLING_298 */ +/* 0175 */ 0x00087401,0x000e4782, +/* HFGEXECSIBLING_2IND1 */ +/* 0176 */ 0x00000734,0x00001000,0x00010705,0x000a6880, +/* 0178 */ 0x00006a88,0x000c75c4, +/* S16_CODECOUTPUTTASK */ +/* 0179 */ 0x0007c108,0x000c0000,0x0007e721,0x000bed40, +/* 017B */ 0x00005f25,0x000badc0,0x0003ba97,0x000beb80, +/* 017D */ 0x00065590,0x000b2e00,0x00033217,0x00003ec0, +/* 017F */ 0x00065590,0x000b8e40,0x0003ed80,0x000491c0, +/* 0181 */ 0x00073fb0,0x00074c80,0x000583a0,0x0000100c, +/* 0183 */ 0x000ee388,0x00042970,0x00008301,0x00021ef2, +/* 0185 */ 0x000b8f14,0x0000000f,0x000c4d8d,0x0000001b, +/* 0187 */ 0x000d6dc2,0x000e06c6,0x000032ac,0x000c3916, +/* 0189 */ 0x0004edc2,0x00074c80,0x00078898,0x00001000, +/* 018B */ 0x00038894,0x00000032,0x000c4d8d,0x00092e1b, +/* 018D */ 0x000d6dc2,0x000e06c6,0x0004edc2,0x000c1956, +/* 018F */ 0x0000722c,0x00034a00,0x00041705,0x0009ed40, +/* 0191 */ 0x00058730,0x00001400,0x000d7488,0x000c3a00, +/* 0193 */ 0x00048f05,0x00000000 +}; +/* #CODE_END */ + +static u32 cwc4630_parameter[] = { +/* 0000 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0004 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0008 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 000C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0010 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0014 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0018 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 001C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0020 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0024 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0028 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 002C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0030 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0034 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0038 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 003C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0040 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0044 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0048 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 004C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0050 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0054 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0058 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 005C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0060 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0064 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0068 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 006C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0070 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0074 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0078 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 007C */ 0x00000000,0x00000000,0x00000000,0x00000000 +}; /* #PARAMETER_END */ + + +static segment_desc_t cwc4630_segments[] = { + { SEGTYPE_SP_PROGRAM, 0x00000000, 0x00000328, cwc4630_code }, + { SEGTYPE_SP_PARAMETER, 0x00000000, 0x00000080, cwc4630_parameter }, +}; + +static dsp_module_desc_t cwc4630_module = { + "cwc4630", + { + 38, + cwc4630_symbols + }, + 2, + cwc4630_segments, +}; + +#endif /* __HEADER_cwc4630_H__ */ diff -Nru a/sound/pci/cs46xx/imgs/cwcasync.h b/sound/pci/cs46xx/imgs/cwcasync.h --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/sound/pci/cs46xx/imgs/cwcasync.h Sun Sep 29 20:23:44 2002 @@ -0,0 +1,176 @@ +/* generated from cwcasync.osp DO NOT MODIFY */ + +#ifndef __HEADER_cwcasync_H__ +#define __HEADER_cwcasync_H__ + +static symbol_entry_t cwcasync_symbols[] = { + { 0x8000, "EXECCHILD",0x03 }, + { 0x8001, "EXECCHILD_98",0x03 }, + { 0x8003, "EXECCHILD_PUSH1IND",0x03 }, + { 0x8008, "EXECSIBLING",0x03 }, + { 0x800a, "EXECSIBLING_298",0x03 }, + { 0x800b, "EXECSIBLING_2IND1",0x03 }, + { 0x8010, "TIMINGMASTER",0x03 }, + { 0x804f, "S16_CODECINPUTTASK",0x03 }, + { 0x805e, "PCMSERIALINPUTTASK",0x03 }, + { 0x806d, "S16_MIX_TO_OSTREAM",0x03 }, + { 0x809a, "S16_MIX",0x03 }, + { 0x80bb, "S16_UPSRC",0x03 }, + { 0x813b, "MIX3_EXP",0x03 }, + { 0x8164, "DECIMATEBYPOW2",0x03 }, + { 0x8197, "VARIDECIMATE",0x03 }, + { 0x81f2, "_3DINPUTTASK",0x03 }, + { 0x820a, "_3DPRLGCINPTASK",0x03 }, + { 0x8227, "_3DSTEREOINPUTTASK",0x03 }, + { 0x8242, "_3DOUTPUTTASK",0x03 }, + { 0x82c4, "HRTF_MORPH_TASK",0x03 }, + { 0x82c6, "WAIT4DATA",0x03 }, + { 0x82fa, "PROLOGIC",0x03 }, + { 0x8496, "DECORRELATOR",0x03 }, + { 0x84a4, "STEREO2MONO",0x03 }, + { 0x0000, "OVERLAYBEGINADDRESS",0x00 }, + { 0x0000, "SPIOWRITE",0x03 }, + { 0x000d, "S16_ASYNCCODECINPUTTASK",0x03 }, + { 0x0043, "SPDIFITASK",0x03 }, + { 0x007b, "SPDIFOTASK",0x03 }, + { 0x0097, "ASYNCHFGTXCODE",0x03 }, + { 0x00be, "ASYNCHFGRXCODE",0x03 }, + { 0x00db, "#CODE_END",0x00 }, +}; /* cwcasync symbols */ + +static u32 cwcasync_code[] = { +/* OVERLAYBEGINADDRESS */ +/* 0000 */ 0x00002731,0x00001400,0x00003725,0x000a8440, +/* 0002 */ 0x000000ae,0x00000000,0x00060630,0x00001000, +/* 0004 */ 0x00000000,0x000c7560,0x00075282,0x0002d640, +/* 0006 */ 0x00021705,0x00000000,0x00072ab8,0x0002d6c0, +/* 0008 */ 0x00020630,0x00001000,0x000c74c2,0x000d4b82, +/* 000A */ 0x000475c2,0x00000000,0x0003430a,0x000c0000, +/* 000C */ 0x00042730,0x00001400, +/* S16_ASYNCCODECINPUTTASK */ +/* 000D */ 0x0006a108,0x000cf2c4,0x0004f4c0,0x00000000, +/* 000F */ 0x000fa418,0x0000101f,0x0005d402,0x0001c500, +/* 0011 */ 0x000f0630,0x00001000,0x00004418,0x00001380, +/* 0013 */ 0x000e243d,0x000d394a,0x00049705,0x00000000, +/* 0015 */ 0x0007d530,0x000b4240,0x000e00f2,0x00001000, +/* 0017 */ 0x00009134,0x000ca20a,0x00004c90,0x00001000, +/* 0019 */ 0x0005d705,0x00000000,0x00004f25,0x00098240, +/* 001B */ 0x00004725,0x00000000,0x0000e48a,0x00000000, +/* 001D */ 0x00027295,0x0009c2c0,0x0003df25,0x00000000, +/* 001F */ 0x000e8030,0x00001001,0x0005f718,0x000ac600, +/* 0021 */ 0x0007cf30,0x000c2a01,0x00082630,0x00001001, +/* 0023 */ 0x000504a0,0x00001001,0x00029314,0x000bcb80, +/* 0025 */ 0x0003cf25,0x000b0e00,0x0004f5c0,0x00000000, +/* 0027 */ 0x00049118,0x000d888a,0x0007dd02,0x000c6efa, +/* 0029 */ 0x00000000,0x00000000,0x0004f5c0,0x00069c80, +/* 002B */ 0x0000d402,0x00000000,0x000e8630,0x00001001, +/* 002D */ 0x00079130,0x00000000,0x00049118,0x00090e00, +/* 002F */ 0x0006c10a,0x00000000,0x00000000,0x000c0000, +/* 0031 */ 0x0007cf30,0x00030580,0x00005725,0x00000000, +/* 0033 */ 0x000d84a0,0x00001001,0x00029314,0x000b4780, +/* 0035 */ 0x0003cf25,0x000b8600,0x00000000,0x00000000, +/* 0037 */ 0x00000000,0x000c0000,0x00000000,0x00042c80, +/* 0039 */ 0x0001dec1,0x000e488c,0x00031114,0x00000000, +/* 003B */ 0x0004f5c2,0x00000000,0x0003640a,0x00000000, +/* 003D */ 0x00000000,0x000e5084,0x00000000,0x000eb844, +/* 003F */ 0x00007001,0x00000000,0x00000734,0x00001000, +/* 0041 */ 0x00010705,0x000a6880,0x00006a88,0x000c75c4, +/* SPDIFITASK */ +/* 0043 */ 0x0006a108,0x000cf2c4,0x0004f4c0,0x000d5384, +/* 0045 */ 0x0007e48a,0x00000000,0x00067718,0x00001000, +/* 0047 */ 0x0007a418,0x00001000,0x0007221a,0x00000000, +/* 0049 */ 0x0005d402,0x00014500,0x000b8630,0x00001002, +/* 004B */ 0x00004418,0x00001780,0x000e243d,0x000d394a, +/* 004D */ 0x00049705,0x00000000,0x0007d530,0x000b4240, +/* 004F */ 0x000ac0f2,0x00001002,0x00014414,0x00000000, +/* 0051 */ 0x00004c90,0x00001000,0x0005d705,0x00000000, +/* 0053 */ 0x00004f25,0x00098240,0x00004725,0x00000000, +/* 0055 */ 0x0000e48a,0x00000000,0x00027295,0x0009c2c0, +/* 0057 */ 0x0007df25,0x00000000,0x000ac030,0x00001003, +/* 0059 */ 0x0005f718,0x000fe798,0x00029314,0x000bcb80, +/* 005B */ 0x00000930,0x000b0e00,0x0004f5c0,0x000de204, +/* 005D */ 0x000884a0,0x00001003,0x0007cf25,0x000e3560, +/* 005F */ 0x00049118,0x00000000,0x00049118,0x000d888a, +/* 0061 */ 0x0007dd02,0x000c6efa,0x0000c434,0x00030040, +/* 0063 */ 0x000fda82,0x000c2312,0x000fdc0e,0x00001001, +/* 0065 */ 0x00083402,0x000c2b92,0x000706b0,0x00001003, +/* 0067 */ 0x00075a82,0x00000000,0x0000d625,0x000b0940, +/* 0069 */ 0x0000840e,0x00001002,0x0000aabc,0x000c511e, +/* 006B */ 0x00078730,0x00001003,0x0000aaf4,0x000e910a, +/* 006D */ 0x0004628a,0x00000000,0x00006aca,0x00000000, +/* 006F */ 0x00000930,0x00000000,0x0004f5c0,0x00069c80, +/* 0071 */ 0x00046ac0,0x00000000,0x0003c40a,0x000fc898, +/* 0073 */ 0x00049118,0x00090e00,0x0006c10a,0x00000000, +/* 0075 */ 0x00000000,0x000e5084,0x00000000,0x000eb844, +/* 0077 */ 0x00007001,0x00000000,0x00000734,0x00001000, +/* 0079 */ 0x00010705,0x000a6880,0x00006a88,0x000c75c4, +/* SPDIFOTASK */ +/* 007B */ 0x0006a108,0x000c0000,0x0004f4c0,0x000c3245, +/* 007D */ 0x0000a418,0x00001000,0x0003a20a,0x00000000, +/* 007F */ 0x00004418,0x00001380,0x000e243d,0x000d394a, +/* 0081 */ 0x000c9705,0x000def92,0x0008c030,0x00001004, +/* 0083 */ 0x0005f718,0x000fe798,0x00000000,0x000c0000, +/* 0085 */ 0x00005725,0x00000000,0x000704a0,0x00001004, +/* 0087 */ 0x00029314,0x000b4780,0x0003cf25,0x000b8600, +/* 0089 */ 0x00000000,0x00000000,0x00000000,0x000c0000, +/* 008B */ 0x00000000,0x00042c80,0x0001dec1,0x000e488c, +/* 008D */ 0x00031114,0x00000000,0x0004f5c2,0x00000000, +/* 008F */ 0x0004a918,0x00098600,0x0006c28a,0x00000000, +/* 0091 */ 0x00000000,0x000e5084,0x00000000,0x000eb844, +/* 0093 */ 0x00007001,0x00000000,0x00000734,0x00001000, +/* 0095 */ 0x00010705,0x000a6880,0x00006a88,0x000c75c4, +/* ASYNCHFGTXCODE */ +/* 0097 */ 0x0002a880,0x000b4e40,0x00042214,0x000e5548, +/* 0099 */ 0x000542bf,0x00000000,0x00000000,0x000481c0, +/* 009B */ 0x00000000,0x00000000,0x00000000,0x00000030, +/* 009D */ 0x0000072d,0x000fbf8a,0x00077f94,0x000ea7df, +/* 009F */ 0x0002ac95,0x000d3145,0x00002731,0x00001400, +/* 00A1 */ 0x00006288,0x000c71c4,0x00014108,0x000e6044, +/* 00A3 */ 0x00035408,0x00000000,0x00025418,0x000a0ec0, +/* 00A5 */ 0x0001443d,0x000ca21e,0x00046595,0x000d730c, +/* 00A7 */ 0x0006538e,0x00000000,0x00064630,0x00001005, +/* 00A9 */ 0x000e7b0e,0x000df782,0x000746b0,0x00001005, +/* 00AB */ 0x00036f05,0x000c0000,0x00043695,0x000d598c, +/* 00AD */ 0x0005331a,0x000f2185,0x00000000,0x00000000, +/* 00AF */ 0x000007ae,0x000bdb00,0x00040630,0x00001400, +/* 00B1 */ 0x0005e708,0x000c0000,0x0007ef30,0x000b1c00, +/* 00B3 */ 0x000d86a0,0x00001005,0x00066408,0x000c0000, +/* 00B5 */ 0x00000000,0x00000000,0x00021843,0x00000000, +/* 00B7 */ 0x00000cac,0x00062c00,0x00001dac,0x00063400, +/* 00B9 */ 0x00002cac,0x0006cc80,0x000db943,0x000e5ca1, +/* 00BB */ 0x00000000,0x00000000,0x0006680a,0x000f3205, +/* 00BD */ 0x00042730,0x00001400, +/* ASYNCHFGRXCODE */ +/* 00BE */ 0x00014108,0x000f2204,0x00025418,0x000a2ec0, +/* 00C0 */ 0x00015dbd,0x00038100,0x00015dbc,0x00000000, +/* 00C2 */ 0x0005e415,0x00034880,0x0001258a,0x000d730c, +/* 00C4 */ 0x0006538e,0x000baa40,0x00060630,0x00001006, +/* 00C6 */ 0x00067b0e,0x000ac380,0x0003ef05,0x00000000, +/* 00C8 */ 0x0000f734,0x0001c300,0x000586b0,0x00001400, +/* 00CA */ 0x000b6f05,0x000c3a00,0x00048f05,0x00000000, +/* 00CC */ 0x0005b695,0x0008c380,0x0002058e,0x00000000, +/* 00CE */ 0x000500b0,0x00001400,0x0002b318,0x000e998d, +/* 00D0 */ 0x0006430a,0x00000000,0x00000000,0x000ef384, +/* 00D2 */ 0x00004725,0x000c0000,0x00000000,0x000f3204, +/* 00D4 */ 0x00004f25,0x000c0000,0x00080000,0x000e5ca1, +/* 00D6 */ 0x000cb943,0x000e5ca1,0x0004b943,0x00000000, +/* 00D8 */ 0x00040730,0x00001400,0x000cb943,0x000e5ca1, +/* 00DA */ 0x0004b943,0x00000000 +}; +/* #CODE_END */ + +static segment_desc_t cwcasync_segments[] = { + { SEGTYPE_SP_PROGRAM, 0x00000000, 0x000001b6, cwcasync_code }, +}; + +static dsp_module_desc_t cwcasync_module = { + "cwcasync", + { + 32, + cwcasync_symbols + }, + 1, + cwcasync_segments, +}; + +#endif /* __HEADER_cwcasync_H__ */ diff -Nru a/sound/pci/cs46xx/imgs/cwcbinhack.h b/sound/pci/cs46xx/imgs/cwcbinhack.h --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/sound/pci/cs46xx/imgs/cwcbinhack.h Sun Sep 29 20:23:44 2002 @@ -0,0 +1,48 @@ +/* generated by Benny + MODIFY ON YOUR OWN RISK */ + +#ifndef __HEADER_cwcbinhack_H__ +#define __HEADER_cwcbinhack_H__ + +static symbol_entry_t cwcbinhack_symbols[] = { + { 0x02c8, "OVERLAYBEGINADDRESS",0x00 }, + { 0x02c8, "MAGICSNOOPTASK",0x03 }, + { 0x0308, "#CODE_END",0x00 }, +}; /* cwcbinhack symbols */ + +static u32 cwcbinhack_code[] = { + /* 0x02c8 */ + 0x0007bfb0,0x000bc240,0x00000c2e,0x000c6084, /* 1 */ + 0x000b8630,0x00001016,0x00006408,0x000efb84, /* 2 */ + 0x00016008,0x00000000,0x0001c088,0x000c0000, /* 3 */ + 0x000fc908,0x000e3392,0x0005f488,0x000efb84, /* 4 */ + 0x0001d402,0x000b2e00,0x0003d418,0x00001000, /* 5 */ + 0x0008d574,0x000c4293,0x00065625,0x000ea30e, /* 6 */ + 0x00096c01,0x000c6f92,0x0001a58a,0x000c6085, /* 7 */ + 0x00002f43,0x00000000,0x000e03a0,0x00001016, /* 8 */ + 0x0005e608,0x000c0000,0x00000000,0x00000000, /* 9 */ + 0x000ca108,0x000dcca1,0x00003bac,0x000c3205, /* 10 */ + 0x00073843,0x00000000,0x00010730,0x00001017, /* 11 */ + 0x0001600a,0x000c0000,0x00057488,0x00000000, /* 12 */ + 0x00000000,0x000e5084,0x00000000,0x000eba44, /* 13 */ + 0x00087401,0x000e4782,0x00000734,0x00001000, /* 14 */ + 0x00010705,0x000a6880,0x00006a88,0x000c75c4, /* 15 */ + 0x00000000,0x00000000,0x00000000,0x00000000, /* 16 */ +}; +/* #CODE_END */ + +static segment_desc_t cwcbinhack_segments[] = { + { SEGTYPE_SP_PROGRAM, 0x00000000, 64, cwcbinhack_code }, +}; + +static dsp_module_desc_t cwcbinhack_module = { + "cwcbinhack", + { + 3, + cwcbinhack_symbols + }, + 1, + cwcbinhack_segments, +}; + +#endif /* __HEADER_cwcbinhack_H__ */ diff -Nru a/sound/pci/cs46xx/imgs/cwcemb80.h b/sound/pci/cs46xx/imgs/cwcemb80.h --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/sound/pci/cs46xx/imgs/cwcemb80.h Sun Sep 29 20:23:44 2002 @@ -0,0 +1,1607 @@ +/* generated from cwcemb80.osp DO NOT MODIFY */ + +#ifndef __HEADER_cwcemb80_H__ +#define __HEADER_cwcemb80_H__ + +static symbol_entry_t cwcemb80_symbols[] = { + { 0x0000, "BEGINADDRESS",0x00 }, + { 0x8000, "EXECCHILD",0x03 }, + { 0x8001, "EXECCHILD_98",0x03 }, + { 0x8003, "EXECCHILD_PUSH1IND",0x03 }, + { 0x8008, "EXECSIBLING",0x03 }, + { 0x800a, "EXECSIBLING_298",0x03 }, + { 0x800b, "EXECSIBLING_2IND1",0x03 }, + { 0x8010, "TIMINGMASTER",0x03 }, + { 0x804f, "S16_CODECINPUTTASK",0x03 }, + { 0x805e, "PCMSERIALINPUTTASK",0x03 }, + { 0x806d, "S16_MIX_TO_OSTREAM",0x03 }, + { 0x809a, "S16_MIX",0x03 }, + { 0x80bb, "S16_UPSRC",0x03 }, + { 0x813b, "MIX3_EXP",0x03 }, + { 0x8164, "DECIMATEBYPOW2",0x03 }, + { 0x8197, "VARIDECIMATE",0x03 }, + { 0x81f2, "_3DINPUTTASK",0x03 }, + { 0x820a, "_3DPRLGCINPTASK",0x03 }, + { 0x8227, "_3DSTEREOINPUTTASK",0x03 }, + { 0x8242, "_3DOUTPUTTASK",0x03 }, + { 0x82c4, "HRTF_MORPH_TASK",0x03 }, + { 0x82c6, "WAIT4DATA",0x03 }, + { 0x82fa, "PROLOGIC",0x03 }, + { 0x8496, "DECORRELATOR",0x03 }, + { 0x84a4, "STEREO2MONO",0x03 }, + { 0x0070, "SPOSCB",0x02 }, + { 0x0105, "TASKTREETHREAD",0x03 }, + { 0x0136, "TASKTREEHEADERCODE",0x03 }, + { 0x013f, "FGTASKTREEHEADERCODE",0x03 }, + { 0x0163, "NULLALGORITHM",0x03 }, + { 0x0167, "HFGEXECCHILD",0x03 }, + { 0x0168, "HFGEXECCHILD_98",0x03 }, + { 0x016a, "HFGEXECCHILD_PUSH1IND",0x03 }, + { 0x016d, "HFGEXECSIBLING",0x03 }, + { 0x016f, "HFGEXECSIBLING_298",0x03 }, + { 0x0170, "HFGEXECSIBLING_2IND1",0x03 }, + { 0x0173, "S16_CODECOUTPUTTASK",0x03 }, + { 0x018e, "#CODE_END",0x00 }, +}; /* cwcemb80 symbols */ + +static u32 cwcemb80_code[] = { +/* BEGINADDRESS */ +/* 0000 */ 0x00040730,0x00001002,0x000f619e,0x00001003, +/* 0002 */ 0x00001705,0x00001400,0x000a411e,0x00001003, +/* 0004 */ 0x00040730,0x00001002,0x000f619e,0x00001003, +/* 0006 */ 0x00009705,0x00001400,0x000a411e,0x00001003, +/* 0008 */ 0x00040730,0x00001002,0x000f619e,0x00001003, +/* 000A */ 0x00011705,0x00001400,0x000a411e,0x00001003, +/* 000C */ 0x00040730,0x00001002,0x000f619e,0x00001003, +/* 000E */ 0x00019705,0x00001400,0x000a411e,0x00001003, +/* 0010 */ 0x00040730,0x00001002,0x000f619e,0x00001003, +/* 0012 */ 0x00021705,0x00001400,0x000a411e,0x00001003, +/* 0014 */ 0x00040730,0x00001002,0x000f619e,0x00001003, +/* 0016 */ 0x00029705,0x00001400,0x000a411e,0x00001003, +/* 0018 */ 0x00040730,0x00001002,0x000f619e,0x00001003, +/* 001A */ 0x00031705,0x00001400,0x000a411e,0x00001003, +/* 001C */ 0x00040730,0x00001002,0x000f619e,0x00001003, +/* 001E */ 0x00039705,0x00001400,0x000a411e,0x00001003, +/* 0020 */ 0x000fe19e,0x00001003,0x0009c730,0x00001003, +/* 0022 */ 0x0008e19c,0x00001003,0x000083c1,0x00093040, +/* 0024 */ 0x00098730,0x00001002,0x000ee19e,0x00001003, +/* 0026 */ 0x00009705,0x00001400,0x000a211e,0x00001003, +/* 0028 */ 0x00098730,0x00001002,0x000ee19e,0x00001003, +/* 002A */ 0x00011705,0x00001400,0x000a211e,0x00001003, +/* 002C */ 0x00098730,0x00001002,0x000ee19e,0x00001003, +/* 002E */ 0x00019705,0x00001400,0x000a211e,0x00001003, +/* 0030 */ 0x00098730,0x00001002,0x000ee19e,0x00001003, +/* 0032 */ 0x00021705,0x00001400,0x000a211e,0x00001003, +/* 0034 */ 0x00098730,0x00001002,0x000ee19e,0x00001003, +/* 0036 */ 0x00029705,0x00001400,0x000a211e,0x00001003, +/* 0038 */ 0x00098730,0x00001002,0x000ee19e,0x00001003, +/* 003A */ 0x00031705,0x00001400,0x000a211e,0x00001003, +/* 003C */ 0x00098730,0x00001002,0x000ee19e,0x00001003, +/* 003E */ 0x00039705,0x00001400,0x000a211e,0x00001003, +/* 0040 */ 0x0000a730,0x00001008,0x000e2730,0x00001002, +/* 0042 */ 0x0000a731,0x00001002,0x0000a731,0x00001002, +/* 0044 */ 0x0000a731,0x00001002,0x0000a731,0x00001002, +/* 0046 */ 0x0000a731,0x00001002,0x0000a731,0x00001002, +/* 0048 */ 0x00000000,0x00000000,0x000f619c,0x00001003, +/* 004A */ 0x0007f801,0x000c0000,0x00000037,0x00001000, +/* 004C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 004E */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0050 */ 0x00000000,0x000c0000,0x00000000,0x00000000, +/* 0052 */ 0x0000373c,0x00001000,0x00000000,0x00000000, +/* 0054 */ 0x000ee19c,0x00001003,0x0007f801,0x000c0000, +/* 0056 */ 0x00000037,0x00001000,0x00000000,0x00000000, +/* 0058 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 005A */ 0x00000000,0x00000000,0x0000273c,0x00001000, +/* 005C */ 0x00000033,0x00001000,0x000e679e,0x00001003, +/* 005E */ 0x00007705,0x00001400,0x000ac71e,0x00001003, +/* 0060 */ 0x00087fc1,0x000c3be0,0x0007f801,0x000c0000, +/* 0062 */ 0x00000037,0x00001000,0x00000000,0x00000000, +/* 0064 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0066 */ 0x00000000,0x00000000,0x0000a730,0x00001003, +/* 0068 */ 0x00000033,0x00001000,0x0007f801,0x000c0000, +/* 006A */ 0x00000037,0x00001000,0x00000000,0x00000000, +/* 006C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 006E */ 0x00000000,0x00000000,0x00000000,0x000c0000, +/* 0070 */ 0x00000032,0x00001000,0x0000273d,0x00001000, +/* 0072 */ 0x0004a730,0x00001003,0x00000f41,0x00097140, +/* 0074 */ 0x0000a841,0x0009b240,0x0000a0c1,0x0009f040, +/* 0076 */ 0x0001c641,0x00093540,0x0001cec1,0x0009b5c0, +/* 0078 */ 0x00000000,0x00000000,0x0001bf05,0x0003fc40, +/* 007A */ 0x00002725,0x000aa400,0x00013705,0x00093a00, +/* 007C */ 0x0000002e,0x0009d6c0,0x00038630,0x00001004, +/* 007E */ 0x0004ef0a,0x000eb785,0x0003fc8a,0x00000000, +/* 0080 */ 0x00000000,0x000c70e0,0x0007d182,0x0002c640, +/* 0082 */ 0x00000630,0x00001004,0x000799b8,0x0002c6c0, +/* 0084 */ 0x00031705,0x00092240,0x00039f05,0x000932c0, +/* 0086 */ 0x0003520a,0x00000000,0x00040731,0x0000100b, +/* 0088 */ 0x00010705,0x000b20c0,0x00000000,0x000eba44, +/* 008A */ 0x00032108,0x000c60c4,0x00065208,0x000c2917, +/* 008C */ 0x000406b0,0x00001007,0x00012f05,0x00036880, +/* 008E */ 0x0002818e,0x000c0000,0x0004410a,0x00000000, +/* 0090 */ 0x00040630,0x00001007,0x00029705,0x000c0000, +/* 0092 */ 0x00000000,0x00000000,0x00003fc1,0x0003fc40, +/* 0094 */ 0x000037c1,0x00091b40,0x00003fc1,0x000911c0, +/* 0096 */ 0x000037c1,0x000957c0,0x00003fc1,0x000951c0, +/* 0098 */ 0x000037c1,0x00000000,0x00003fc1,0x000991c0, +/* 009A */ 0x000037c1,0x00000000,0x00003fc1,0x0009d1c0, +/* 009C */ 0x000037c1,0x00000000,0x0001ccc1,0x000915c0, +/* 009E */ 0x0001c441,0x0009d800,0x0009cdc1,0x00091240, +/* 00A0 */ 0x0001c541,0x00091d00,0x0009cfc1,0x00095240, +/* 00A2 */ 0x0001c741,0x00095c80,0x000e8ca9,0x00099240, +/* 00A4 */ 0x000e85ad,0x00095640,0x00069ca9,0x00099d80, +/* 00A6 */ 0x000e952d,0x00099640,0x000eaca9,0x0009d6c0, +/* 00A8 */ 0x000ea5ad,0x00091a40,0x0006bca9,0x0009de80, +/* 00AA */ 0x000eb52d,0x00095a40,0x000ecca9,0x00099ac0, +/* 00AC */ 0x000ec5ad,0x0009da40,0x000edca9,0x0009d300, +/* 00AE */ 0x000a6e0a,0x00001000,0x000ed52d,0x00091e40, +/* 00B0 */ 0x000eeca9,0x00095ec0,0x000ee5ad,0x00099e40, +/* 00B2 */ 0x0006fca9,0x00002500,0x000fb208,0x000c59a0, +/* 00B4 */ 0x000ef52d,0x0009de40,0x00068ca9,0x000912c1, +/* 00B6 */ 0x000683ad,0x00095241,0x00020f05,0x000991c1, +/* 00B8 */ 0x00000000,0x00000000,0x00086f88,0x00001000, +/* 00BA */ 0x0009cf81,0x000b5340,0x0009c701,0x000b92c0, +/* 00BC */ 0x0009de81,0x000bd300,0x0009d601,0x000b1700, +/* 00BE */ 0x0001fd81,0x000b9d80,0x0009f501,0x000b57c0, +/* 00C0 */ 0x000a0f81,0x000bd740,0x00020701,0x000b5c80, +/* 00C2 */ 0x000a1681,0x000b97c0,0x00021601,0x00002500, +/* 00C4 */ 0x000a0701,0x000b9b40,0x000a0f81,0x000b1bc0, +/* 00C6 */ 0x00021681,0x00002d00,0x00020f81,0x000bd800, +/* 00C8 */ 0x000a0701,0x000b5bc0,0x00021601,0x00003500, +/* 00CA */ 0x000a0f81,0x000b5f40,0x000a0701,0x000bdbc0, +/* 00CC */ 0x00021681,0x00003d00,0x00020f81,0x000b1d00, +/* 00CE */ 0x000a0701,0x000b1fc0,0x00021601,0x00020500, +/* 00D0 */ 0x00020f81,0x000b1341,0x000a0701,0x000b9fc0, +/* 00D2 */ 0x00021681,0x00020d00,0x00020f81,0x000bde80, +/* 00D4 */ 0x000a0701,0x000bdfc0,0x00021601,0x00021500, +/* 00D6 */ 0x00020f81,0x000b9341,0x00020701,0x000b53c1, +/* 00D8 */ 0x00021681,0x00021d00,0x000a0f81,0x000d0380, +/* 00DA */ 0x0000b601,0x000b15c0,0x00007b01,0x00000000, +/* 00DC */ 0x00007b81,0x000bd1c0,0x00007b01,0x00000000, +/* 00DE */ 0x00007b81,0x000b91c0,0x00007b01,0x000b57c0, +/* 00E0 */ 0x00007b81,0x000b51c0,0x00007b01,0x000b1b40, +/* 00E2 */ 0x00007b81,0x000b11c0,0x00087b01,0x000c3dc0, +/* 00E4 */ 0x0007e488,0x000d7e45,0x00000000,0x000d7a44, +/* 00E6 */ 0x0007e48a,0x00000000,0x00011f05,0x00084080, +/* 00E8 */ 0x00000000,0x00000000,0x00001705,0x000b3540, +/* 00EA */ 0x00008a01,0x000bf040,0x00007081,0x000bb5c0, +/* 00EC */ 0x00055488,0x00000000,0x0000d482,0x0003fc40, +/* 00EE */ 0x0003fc88,0x00000000,0x0001e401,0x000b3a00, +/* 00F0 */ 0x0001ec81,0x000bd6c0,0x0004ef08,0x000eb784, +/* 00F2 */ 0x000c86b0,0x00001007,0x00008281,0x000bb240, +/* 00F4 */ 0x0000b801,0x000b7140,0x00007888,0x00000000, +/* 00F6 */ 0x0000073c,0x00001000,0x0007f188,0x000c0000, +/* 00F8 */ 0x00000000,0x00000000,0x00055288,0x000c555c, +/* 00FA */ 0x0005528a,0x000c0000,0x0009fa88,0x000c5d00, +/* 00FC */ 0x0000fa88,0x00000000,0x00000032,0x00001000, +/* 00FE */ 0x0000073d,0x00001000,0x0007f188,0x000c0000, +/* 0100 */ 0x00000000,0x00000000,0x0008c01c,0x00001003, +/* 0102 */ 0x00002705,0x00001008,0x0008b201,0x000c1392, +/* 0104 */ 0x0000ba01,0x00000000, +/* TASKTREETHREAD */ +/* 0105 */ 0x00008731,0x00001400,0x0004c108,0x000fe0c4, +/* 0107 */ 0x00057488,0x00000000,0x000a6388,0x00001001, +/* 0109 */ 0x0008b334,0x000bc141,0x0003020e,0x00000000, +/* 010B */ 0x000886b0,0x00001008,0x00003625,0x000c5dfa, +/* 010D */ 0x000a638a,0x00001001,0x0008020e,0x00001002, +/* 010F */ 0x0008a6b0,0x00001008,0x0007f301,0x00000000, +/* 0111 */ 0x00000000,0x00000000,0x00002725,0x000a8c40, +/* 0113 */ 0x000000ae,0x00000000,0x000d8630,0x00001008, +/* 0115 */ 0x00000000,0x000c74e0,0x0007d182,0x0002d640, +/* 0117 */ 0x000a8630,0x00001008,0x000799b8,0x0002d6c0, +/* 0119 */ 0x0000748a,0x000c3ec5,0x0007420a,0x000c0000, +/* 011B */ 0x00062208,0x000c4117,0x00070630,0x00001009, +/* 011D */ 0x00000000,0x000c0000,0x0001022e,0x00000000, +/* 011F */ 0x0003a630,0x00001009,0x00000000,0x000c0000, +/* 0121 */ 0x00000036,0x00001000,0x00000000,0x00000000, +/* 0123 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0125 */ 0x00000000,0x00000000,0x0002a730,0x00001008, +/* 0127 */ 0x0007f801,0x000c0000,0x00000037,0x00001000, +/* 0129 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 012B */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 012D */ 0x0002a730,0x00001008,0x00000033,0x00001000, +/* 012F */ 0x0002a705,0x00001008,0x00007a01,0x000c0000, +/* 0131 */ 0x000e6288,0x000d550a,0x0006428a,0x00000000, +/* 0133 */ 0x00060730,0x0000100a,0x00000000,0x000c0000, +/* 0135 */ 0x00000000,0x00000000, +/* TASKTREEHEADERCODE */ +/* 0136 */ 0x0007aab0,0x00034880,0x00078fb0,0x0000100b, +/* 0138 */ 0x00057488,0x00000000,0x00033b94,0x00081140, +/* 013A */ 0x000183ae,0x00000000,0x000786b0,0x0000100b, +/* 013C */ 0x00022f05,0x000c3545,0x0000eb8a,0x00000000, +/* 013E */ 0x00042731,0x00001003, +/* FGTASKTREEHEADERCODE */ +/* 013F */ 0x0007aab0,0x00034880,0x00048fb0,0x0000100a, +/* 0141 */ 0x00057488,0x00000000,0x00033b94,0x00081140, +/* 0143 */ 0x000183ae,0x00000000,0x000806b0,0x0000100b, +/* 0145 */ 0x00022f05,0x00000000,0x00007401,0x00091140, +/* 0147 */ 0x00048f05,0x000951c0,0x00042731,0x00001003, +/* 0149 */ 0x0000473d,0x00001000,0x000f19b0,0x000bbc47, +/* 014B */ 0x00080000,0x000bffc7,0x000fe19e,0x00001003, +/* 014D */ 0x00000000,0x00000000,0x0008e19c,0x00001003, +/* 014F */ 0x000083c1,0x00093040,0x00000f41,0x00097140, +/* 0151 */ 0x0000a841,0x0009b240,0x0000a0c1,0x0009f040, +/* 0153 */ 0x0001c641,0x00093540,0x0001cec1,0x0009b5c0, +/* 0155 */ 0x00000000,0x000fdc44,0x00055208,0x00000000, +/* 0157 */ 0x00010705,0x000a2880,0x0000a23a,0x00093a00, +/* 0159 */ 0x0003fc8a,0x000df6c5,0x0004ef0a,0x000c0000, +/* 015B */ 0x00012f05,0x00036880,0x00065308,0x000c2997, +/* 015D */ 0x000d86b0,0x0000100a,0x0004410a,0x000d40c7, +/* 015F */ 0x00000000,0x00000000,0x00080730,0x00001004, +/* 0161 */ 0x00056f0a,0x000ea105,0x00000000,0x00000000, +/* NULLALGORITHM */ +/* 0163 */ 0x0000473d,0x00001000,0x000f19b0,0x000bbc47, +/* 0165 */ 0x00080000,0x000bffc7,0x0000273d,0x00001000, +/* HFGEXECCHILD */ +/* 0167 */ 0x00000000,0x000eba44, +/* HFGEXECCHILD_98 */ +/* 0168 */ 0x00048f05,0x0000f440,0x00007401,0x0000f7c0, +/* HFGEXECCHILD_PUSH1IND */ +/* 016A */ 0x00000734,0x00001000,0x00010705,0x000a6880, +/* 016C */ 0x00006a88,0x000c75c4, +/* HFGEXECSIBLING */ +/* 016D */ 0x00000000,0x000e5084,0x00000000,0x000eba44, +/* HFGEXECSIBLING_298 */ +/* 016F */ 0x00087401,0x000e4782, +/* HFGEXECSIBLING_2IND1 */ +/* 0170 */ 0x00000734,0x00001000,0x00010705,0x000a6880, +/* 0172 */ 0x00006a88,0x000c75c4, +/* S16_CODECOUTPUTTASK */ +/* 0173 */ 0x0007c108,0x000c0000,0x0007e721,0x000bed40, +/* 0175 */ 0x00005f25,0x000badc0,0x0003ba97,0x000beb80, +/* 0177 */ 0x00065590,0x000b2e00,0x00033217,0x00003ec0, +/* 0179 */ 0x00065590,0x000b8e40,0x0003ed80,0x000491c0, +/* 017B */ 0x00073fb0,0x00074c80,0x000283a0,0x0000100c, +/* 017D */ 0x000ee388,0x00042970,0x00008301,0x00021ef2, +/* 017F */ 0x000b8f14,0x0000000f,0x000c4d8d,0x0000001b, +/* 0181 */ 0x000d6dc2,0x000e06c6,0x000032ac,0x000c3916, +/* 0183 */ 0x0004edc2,0x00074c80,0x00078898,0x00001000, +/* 0185 */ 0x00038894,0x00000032,0x000c4d8d,0x00092e1b, +/* 0187 */ 0x000d6dc2,0x000e06c6,0x0004edc2,0x000c1956, +/* 0189 */ 0x0000722c,0x00034a00,0x00041705,0x0009ed40, +/* 018B */ 0x00058730,0x00001400,0x000d7488,0x000c3a00, +/* 018D */ 0x00048f05,0x00000000 +}; +/* #CODE_END */ + +static u32 cwcemb80_parameter[] = { +/* 0000 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0004 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0008 */ 0x00000000,0x00000000,0x00000163,0x00000000, +/* 000C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0010 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0014 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0018 */ 0x00000000,0x00200040,0x00008010,0x00000000, +/* 001C */ 0x00000000,0x80000001,0x00000001,0x00060000, +/* 0020 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0024 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0028 */ 0x00000000,0x00900080,0x00000173,0x00000000, +/* 002C */ 0x00000000,0x00000010,0x00800000,0x00900000, +/* 0030 */ 0xf2c0000f,0x00000200,0x00000000,0x00010600, +/* 0034 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0038 */ 0x00000000,0x00000000,0x00000163,0x330300c2, +/* 003C */ 0x06000000,0x00000000,0x80008000,0x80008000, +/* 0040 */ 0x3fc0000f,0x00000301,0x00010400,0x00000000, +/* 0044 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0048 */ 0x00000000,0x00b00000,0x00d0806d,0x330480c3, +/* 004C */ 0x04800000,0x00000001,0x00800001,0x0000ffff, +/* 0050 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0054 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0058 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 005C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0060 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0064 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0068 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 006C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0070 */ 0x066a0600,0x06350070,0x0000929d,0x929d929d, +/* 0074 */ 0x00000000,0x0000735a,0x00000600,0x00000000, +/* 0078 */ 0x929d735a,0x00000000,0x00010000,0x735a735a, +/* 007C */ 0xa431ac75,0xa431ac75,0xa431ac75,0xa431ac75, +/* 0080 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0084 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0088 */ 0x00000000,0x00000000,0x0000804f,0x000000c3, +/* 008C */ 0x05000000,0x00a00010,0x00000000,0x80008000, +/* 0090 */ 0x00000000,0x00000000,0x00000700,0x00000000, +/* 0094 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0098 */ 0x00000080,0x00a00000,0x0000809a,0x000000c2, +/* 009C */ 0x07400000,0x00000000,0x80008000,0xffffffff, +/* 00A0 */ 0x00c80028,0x00005555,0x00000000,0x000107a0, +/* 00A4 */ 0x00c80028,0x000000c2,0x06800000,0x00000000, +/* 00A8 */ 0x06e00080,0x00300000,0x000080bb,0x000000c9, +/* 00AC */ 0x07a00000,0x04000000,0x80008000,0xffffffff, +/* 00B0 */ 0x00c80028,0x00005555,0x00000000,0x00000780, +/* 00B4 */ 0x00c80028,0x000000c5,0xff800000,0x00000000, +/* 00B8 */ 0x00640080,0x00c00000,0x00008197,0x000000c9, +/* 00BC */ 0x07800000,0x04000000,0x80008000,0xffffffff, +/* 00C0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00C4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00C8 */ 0x00000000,0x00000000,0x0000805e,0x000000c1, +/* 00CC */ 0x00000000,0x00800000,0x80008000,0x80008000, +/* 00D0 */ 0x00020000,0x0000ffff,0x00000000,0x00000000, +/* 00D4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00D8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00DC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00E0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00E4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00E8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00EC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00F0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00F4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00F8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00FC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0100 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0104 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0108 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 010C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0110 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0114 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0118 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 011C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0120 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0124 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0128 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 012C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0130 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0134 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0138 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 013C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0140 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0144 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0148 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 014C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0150 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0154 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0158 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 015C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0160 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0164 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0168 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 016C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0170 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0174 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0178 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 017C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0180 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0184 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0188 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 018C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0190 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0194 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0198 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 019C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01A0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01A4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01A8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01AC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01B0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01B4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01B8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01BC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01C0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01C4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01C8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01CC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01D0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01D4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01D8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01DC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01E0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01E4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01E8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01EC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01F0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01F4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01F8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01FC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0200 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0204 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0208 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 020C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0210 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0214 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0218 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 021C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0220 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0224 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0228 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 022C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0230 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0234 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0238 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 023C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0240 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0244 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0248 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 024C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0250 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0254 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0258 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 025C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0260 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0264 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0268 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 026C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0270 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0274 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0278 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 027C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0280 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0284 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0288 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 028C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0290 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0294 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0298 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 029C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02A0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02A4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02A8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02AC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02B0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02B4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02B8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02BC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02C0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02C4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02C8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02CC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02D0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02D4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02D8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02DC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02E0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02E4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02E8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02EC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02F0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02F4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02F8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02FC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0300 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0304 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0308 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 030C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0310 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0314 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0318 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 031C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0320 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0324 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0328 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 032C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0330 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0334 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0338 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 033C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0340 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0344 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0348 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 034C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0350 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0354 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0358 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 035C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0360 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0364 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0368 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 036C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0370 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0374 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0378 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 037C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0380 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0384 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0388 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 038C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0390 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0394 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0398 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 039C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03A0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03A4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03A8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03AC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03B0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03B4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03B8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03BC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03C0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03C4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03C8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03CC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03D0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03D4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03D8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03DC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03E0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03E4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03E8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03EC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03F0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03F4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03F8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03FC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0400 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0404 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0408 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 040C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0410 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0414 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0418 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 041C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0420 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0424 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0428 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 042C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0430 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0434 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0438 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 043C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0440 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0444 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0448 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 044C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0450 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0454 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0458 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 045C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0460 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0464 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0468 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 046C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0470 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0474 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0478 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 047C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0480 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0484 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0488 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 048C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0490 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0494 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0498 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 049C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04A0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04A4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04A8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04AC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04B0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04B4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04B8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04BC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04C0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04C4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04C8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04CC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04D0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04D4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04D8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04DC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04E0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04E4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04E8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04EC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04F0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04F4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04F8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04FC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0500 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0504 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0508 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 050C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0510 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0514 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0518 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 051C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0520 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0524 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0528 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 052C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0530 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0534 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0538 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 053C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0540 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0544 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0548 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 054C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0550 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0554 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0558 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 055C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0560 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0564 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0568 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 056C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0570 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0574 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0578 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 057C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0580 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0584 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0588 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 058C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0590 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0594 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0598 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 059C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05A0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05A4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05A8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05AC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05B0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05B4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05B8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05BC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05C0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05C4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05C8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05CC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05D0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05D4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05D8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05DC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05E0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05E4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05E8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05EC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05F0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05F4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05F8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05FC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0600 */ 0x929d0600,0x929d929d,0x929d929d,0x929d0000, +/* 0604 */ 0x929d929d,0x929d929d,0x929d929d,0x929d929d, +/* 0608 */ 0x929d929d,0x00100635,0x060b013f,0x00000004, +/* 060C */ 0x00000001,0x007a0002,0x00000000,0x066e0610, +/* 0610 */ 0x0105929d,0x929d929d,0x929d929d,0x929d929d, +/* 0614 */ 0x929d929d,0xa431ac75,0x0001735a,0xa431ac75, +/* 0618 */ 0xa431ac75,0xa431ac75,0xa431ac75,0xa431ac75, +/* 061C */ 0xa431ac75,0xa431ac75,0xa431ac75,0xa431ac75, +/* 0620 */ 0xa431ac75,0xa431ac75,0xa431ac75,0xa431ac75, +/* 0624 */ 0xa431ac75,0xa431ac75,0xa431ac75,0xa431ac75, +/* 0628 */ 0xa431ac75,0xa431ac75,0xa431ac75,0xa431ac75, +/* 062C */ 0xa431ac75,0xa431ac75,0xa431ac75,0xa431ac75, +/* 0630 */ 0xa431ac75,0xa431ac75,0xa431ac75,0x735a0051, +/* 0634 */ 0x00000000,0x929d929d,0x929d929d,0x929d929d, +/* 0638 */ 0x929d929d,0x929d929d,0x929d929d,0x929d929d, +/* 063C */ 0x929d929d,0x929d929d,0x00000000,0x06400136, +/* 0640 */ 0x0000270f,0x00010000,0x007a0000,0x00000000, +/* 0644 */ 0x068e0645,0x0105929d,0x929d929d,0x929d929d, +/* 0648 */ 0x929d929d,0x929d929d,0xa431ac75,0x0001735a, +/* 064C */ 0xa431ac75,0xa431ac75,0xa431ac75,0xa431ac75, +/* 0650 */ 0xa431ac75,0xa431ac75,0xa431ac75,0xa431ac75, +/* 0654 */ 0xa431ac75,0xa431ac75,0xa431ac75,0xa431ac75, +/* 0658 */ 0xa431ac75,0xa431ac75,0xa431ac75,0xa431ac75, +/* 065C */ 0xa431ac75,0xa431ac75,0xa431ac75,0xa431ac75, +/* 0660 */ 0xa431ac75,0xa431ac75,0xa431ac75,0xa431ac75, +/* 0664 */ 0xa431ac75,0xa431ac75,0xa431ac75,0xa431ac75, +/* 0668 */ 0x735a0100,0x00000000,0x00000000,0x00000000, +/* 066C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0670 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0674 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0678 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 067C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0680 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0684 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0688 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 068C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0690 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0694 */ 0x00000000,0x00000000,0x00000000 +}; /* #PARAMETER_END */ + +static u32 cwcemb80_sample[] = { +/* 0000 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0004 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0008 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 000C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0010 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0014 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0018 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 001C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0020 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0024 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0028 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 002C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0030 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0034 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0038 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 003C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0040 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0044 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0048 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 004C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0050 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0054 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0058 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 005C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0060 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0064 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0068 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 006C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0070 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0074 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0078 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 007C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0080 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0084 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0088 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 008C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0090 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0094 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0098 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 009C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00A0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00A4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00A8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00AC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00B0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00B4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00B8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00BC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00C0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00C4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00C8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00CC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00D0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00D4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00D8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00DC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00E0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00E4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00E8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00EC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00F0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00F4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00F8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 00FC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0100 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0104 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0108 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 010C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0110 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0114 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0118 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 011C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0120 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0124 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0128 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 012C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0130 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0134 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0138 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 013C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0140 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0144 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0148 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 014C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0150 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0154 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0158 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 015C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0160 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0164 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0168 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 016C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0170 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0174 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0178 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 017C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0180 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0184 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0188 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 018C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0190 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0194 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0198 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 019C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01A0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01A4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01A8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01AC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01B0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01B4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01B8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01BC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01C0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01C4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01C8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01CC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01D0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01D4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01D8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01DC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01E0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01E4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01E8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01EC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01F0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01F4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01F8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 01FC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0200 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0204 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0208 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 020C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0210 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0214 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0218 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 021C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0220 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0224 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0228 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 022C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0230 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0234 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0238 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 023C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0240 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0244 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0248 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 024C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0250 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0254 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0258 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 025C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0260 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0264 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0268 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 026C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0270 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0274 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0278 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 027C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0280 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0284 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0288 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 028C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0290 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0294 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0298 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 029C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02A0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02A4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02A8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02AC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02B0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02B4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02B8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02BC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02C0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02C4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02C8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02CC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02D0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02D4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02D8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02DC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02E0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02E4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02E8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02EC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02F0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02F4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02F8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 02FC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0300 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0304 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0308 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 030C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0310 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0314 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0318 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 031C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0320 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0324 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0328 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 032C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0330 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0334 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0338 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 033C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0340 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0344 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0348 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 034C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0350 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0354 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0358 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 035C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0360 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0364 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0368 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 036C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0370 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0374 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0378 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 037C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0380 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0384 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0388 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 038C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0390 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0394 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0398 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 039C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03A0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03A4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03A8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03AC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03B0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03B4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03B8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03BC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03C0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03C4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03C8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03CC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03D0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03D4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03D8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03DC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03E0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03E4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03E8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03EC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03F0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03F4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03F8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 03FC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0400 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0404 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0408 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 040C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0410 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0414 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0418 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 041C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0420 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0424 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0428 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 042C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0430 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0434 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0438 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 043C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0440 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0444 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0448 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 044C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0450 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0454 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0458 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 045C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0460 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0464 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0468 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 046C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0470 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0474 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0478 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 047C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0480 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0484 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0488 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 048C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0490 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0494 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0498 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 049C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04A0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04A4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04A8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04AC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04B0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04B4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04B8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04BC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04C0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04C4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04C8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04CC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04D0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04D4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04D8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04DC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04E0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04E4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04E8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04EC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04F0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04F4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04F8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 04FC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0500 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0504 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0508 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 050C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0510 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0514 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0518 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 051C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0520 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0524 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0528 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 052C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0530 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0534 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0538 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 053C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0540 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0544 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0548 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 054C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0550 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0554 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0558 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 055C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0560 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0564 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0568 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 056C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0570 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0574 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0578 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 057C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0580 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0584 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0588 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 058C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0590 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0594 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0598 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 059C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05A0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05A4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05A8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05AC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05B0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05B4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05B8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05BC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05C0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05C4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05C8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05CC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05D0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05D4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05D8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05DC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05E0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05E4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05E8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05EC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05F0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05F4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05F8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 05FC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0600 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0604 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0608 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 060C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0610 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0614 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0618 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 061C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0620 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0624 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0628 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 062C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0630 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0634 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0638 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 063C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0640 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0644 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0648 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 064C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0650 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0654 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0658 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 065C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0660 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0664 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0668 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 066C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0670 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0674 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0678 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 067C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0680 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0684 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0688 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 068C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0690 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0694 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0698 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 069C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 06A0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 06A4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 06A8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 06AC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 06B0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 06B4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 06B8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 06BC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 06C0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 06C4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 06C8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 06CC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 06D0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 06D4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 06D8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 06DC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 06E0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 06E4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 06E8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 06EC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 06F0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 06F4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 06F8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 06FC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0700 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0704 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0708 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 070C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0710 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0714 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0718 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 071C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0720 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0724 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0728 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 072C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0730 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0734 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0738 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 073C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0740 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0744 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0748 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 074C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0750 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0754 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0758 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 075C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0760 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0764 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0768 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 076C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0770 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0774 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0778 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 077C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0780 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0784 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0788 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 078C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0790 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0794 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0798 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 079C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 07A0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 07A4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 07A8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 07AC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 07B0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 07B4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 07B8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 07BC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 07C0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 07C4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 07C8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 07CC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 07D0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 07D4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 07D8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 07DC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 07E0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 07E4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 07E8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 07EC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 07F0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 07F4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 07F8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 07FC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0800 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0804 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0808 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 080C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0810 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0814 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0818 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 081C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0820 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0824 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0828 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 082C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0830 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0834 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0838 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 083C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0840 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0844 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0848 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 084C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0850 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0854 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0858 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 085C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0860 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0864 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0868 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 086C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0870 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0874 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0878 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 087C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0880 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0884 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0888 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 088C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0890 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0894 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0898 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 089C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 08A0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 08A4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 08A8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 08AC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 08B0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 08B4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 08B8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 08BC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 08C0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 08C4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 08C8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 08CC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 08D0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 08D4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 08D8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 08DC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 08E0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 08E4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 08E8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 08EC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 08F0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 08F4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 08F8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 08FC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0900 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0904 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0908 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 090C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0910 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0914 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0918 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 091C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0920 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0924 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0928 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 092C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0930 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0934 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0938 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 093C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0940 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0944 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0948 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 094C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0950 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0954 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0958 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 095C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0960 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0964 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0968 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 096C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0970 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0974 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0978 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 097C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0980 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0984 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0988 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 098C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0990 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0994 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0998 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 099C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 09A0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 09A4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 09A8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 09AC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 09B0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 09B4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 09B8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 09BC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 09C0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 09C4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 09C8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 09CC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 09D0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 09D4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 09D8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 09DC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 09E0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 09E4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 09E8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 09EC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 09F0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 09F4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 09F8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 09FC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A00 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A04 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A08 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A0C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A10 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A14 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A18 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A1C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A20 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A24 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A28 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A2C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A30 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A34 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A38 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A3C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A40 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A44 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A48 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A4C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A50 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A54 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A58 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A5C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A60 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A64 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A68 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A6C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A70 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A74 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A78 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A7C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A80 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A84 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A88 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A8C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A90 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A94 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A98 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0A9C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0AA0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0AA4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0AA8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0AAC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0AB0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0AB4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0AB8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0ABC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0AC0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0AC4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0AC8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0ACC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0AD0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0AD4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0AD8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0ADC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0AE0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0AE4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0AE8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0AEC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0AF0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0AF4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0AF8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0AFC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B00 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B04 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B08 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B0C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B10 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B14 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B18 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B1C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B20 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B24 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B28 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B2C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B30 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B34 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B38 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B3C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B40 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B44 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B48 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B4C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B50 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B54 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B58 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B5C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B60 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B64 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B68 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B6C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B70 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B74 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B78 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B7C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B80 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B84 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B88 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B8C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B90 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B94 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B98 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0B9C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0BA0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0BA4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0BA8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0BAC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0BB0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0BB4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0BB8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0BBC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0BC0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0BC4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0BC8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0BCC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0BD0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0BD4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0BD8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0BDC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0BE0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0BE4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0BE8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0BEC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0BF0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0BF4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0BF8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0BFC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C00 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C04 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C08 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C0C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C10 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C14 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C18 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C1C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C20 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C24 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C28 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C2C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C30 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C34 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C38 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C3C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C40 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C44 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C48 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C4C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C50 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C54 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C58 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C5C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C60 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C64 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C68 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C6C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C70 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C74 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C78 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C7C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C80 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C84 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C88 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C8C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C90 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C94 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C98 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0C9C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0CA0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0CA4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0CA8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0CAC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0CB0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0CB4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0CB8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0CBC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0CC0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0CC4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0CC8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0CCC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0CD0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0CD4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0CD8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0CDC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0CE0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0CE4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0CE8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0CEC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0CF0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0CF4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0CF8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0CFC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D00 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D04 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D08 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D0C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D10 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D14 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D18 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D1C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D20 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D24 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D28 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D2C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D30 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D34 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D38 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D3C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D40 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D44 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D48 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D4C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D50 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D54 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D58 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D5C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D60 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D64 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D68 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D6C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D70 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D74 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D78 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D7C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D80 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D84 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D88 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D8C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D90 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D94 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D98 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0D9C */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0DA0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0DA4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0DA8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0DAC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0DB0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0DB4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0DB8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0DBC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0DC0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0DC4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0DC8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0DCC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0DD0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0DD4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0DD8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0DDC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0DE0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0DE4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0DE8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0DEC */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0DF0 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0DF4 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0DF8 */ 0x00000000,0x00000000,0x00000000,0x00000000, +/* 0DFC */ 0x00000000,0x00000000,0x00000000,0x00010004 +}; /* #SAMPLE_END */ + + +static segment_desc_t cwcemb80_segments[] = { + { SEGTYPE_SP_PROGRAM, 0x00000000, 0x0000031c, cwcemb80_code }, + { SEGTYPE_SP_PARAMETER, 0x00000000, 0x00000697, cwcemb80_parameter }, + { SEGTYPE_SP_SAMPLE, 0x00000000, 0x00000e00, cwcemb80_sample }, +}; + +static dsp_module_desc_t cwcemb80_module = { + "cwcemb80", + { + 38, + cwcemb80_symbols + }, + 3, + cwcemb80_segments, +}; + +#endif /* __HEADER_cwcemb80_H__ */ diff -Nru a/sound/pci/cs46xx/imgs/cwcsnoop.h b/sound/pci/cs46xx/imgs/cwcsnoop.h --- /dev/null Wed Dec 31 16:00:00 1969 +++ b/sound/pci/cs46xx/imgs/cwcsnoop.h Sun Sep 29 20:23:44 2002 @@ -0,0 +1,46 @@ +/* generated from cwcsnoop.osp DO NOT MODIFY */ + +#ifndef __HEADER_cwcsnoop_H__ +#define __HEADER_cwcsnoop_H__ + +static symbol_entry_t cwcsnoop_symbols[] = { + { 0x0500, "OVERLAYBEGINADDRESS",0x00 }, + { 0x0500, "OUTPUTSNOOP",0x03 }, + { 0x051f, "#CODE_END",0x00 }, +}; /* cwcsnoop symbols */ + +static u32 cwcsnoop_code[] = { +/* 0000 */ 0x0007bfb0,0x000b4e40,0x0007c088,0x000c0617, +/* 0002 */ 0x00049705,0x00000000,0x00080630,0x00001028, +/* 0004 */ 0x00076408,0x000efb84,0x00066008,0x00000000, +/* 0006 */ 0x0007c908,0x000c0000,0x00046725,0x000efa44, +/* 0008 */ 0x0005f708,0x00000000,0x0001d402,0x000b2e00, +/* 000A */ 0x0003d418,0x00001000,0x0008d574,0x000c4293, +/* 000C */ 0x00065625,0x000ea30e,0x00096c01,0x000c6f92, +/* 000E */ 0x0006a58a,0x000f6085,0x00002f43,0x00000000, +/* 0010 */ 0x000a83a0,0x00001028,0x0005e608,0x000c0000, +/* 0012 */ 0x00000000,0x00000000,0x000ca108,0x000dcca1, +/* 0014 */ 0x00003bac,0x000fb205,0x00073843,0x00000000, +/* 0016 */ 0x000d8730,0x00001028,0x0006600a,0x000c0000, +/* 0018 */ 0x00057488,0x00000000,0x00000000,0x000e5084, +/* 001A */ 0x00000000,0x000eba44,0x00087401,0x000e4782, +/* 001C */ 0x00000734,0x00001000,0x00010705,0x000a6880, +/* 001E */ 0x00006a88,0x000c75c4 +}; +/* #CODE_END */ + +static segment_desc_t cwcsnoop_segments[] = { + { SEGTYPE_SP_PROGRAM, 0x00000000, 0x0000003e, cwcsnoop_code }, +}; + +static dsp_module_desc_t cwcsnoop_module = { + "cwcsnoop", + { + 3, + cwcsnoop_symbols + }, + 1, + cwcsnoop_segments, +}; + +#endif /* __HEADER_cwcsnoop_H__ */ =================================================================== This BitKeeper patch contains the following changesets: 1.605.2.20 ## Wrapped with gzip_uu ## begin 664 bkpatch2575 M'XL(`#!%EST``^Q<>W?;-I;_6_H4:#+3RHEE`>!;3G+J2$[&I_'C6,ZCV_;H M4"04<2R1BDC%]I39S[[W`J0>U%M)3F=G5VT$B@`N+H#??0"X\&/R-A:C>FDH M1N*^_)C\(XJ3>BD>Q^+(^Q?\OHXB^%WK10-1DV5JG=M:/PC']]4X&H?^[',9 MRE^YB=/PJ/DI$;Q@.1N$=>-$@G15-.*8?_#&9IU#!39E+=2CWF,^;J M3/B4Z[:IER6C/P_#*!%'\KD:A`GTITC(X29U#/BDS*;<+#<).S*I<<2/."64 MUZA3XR9A>IU:==UY2GF=4K**.'G*#5*EY9?DVW:F4?;(R9O6"1D/?3<1!&O5 MJ%VCC-0ABY`J:;1T\_X>'ES?%SZ)Q\-A-$I(-QJ1I"=(*.Y(LW5%@H'[4<@J M6*E5NVJ>O2)NZ!-_[/:K7N0++Z^;$8[%I[$(/3&:U.H&]]""+UR_'WFWQ$U( M'/IM*-=.@H$8M>/$'26U.(F&JDKY%Z)172M?3>>[7-WQ4RY3EY9?K!SY5"%Q MZ`4U+\:1J`6#CW'-N_/$H&/3H]YDMAG3=$-+@2.JI6:W0W73[Q@&LWW'^E;D M]909%MV/7]W4%NBQ%""I.:FG9XRQ["=O=AUXX?06R1H M?,T:6HXEJ:GIF%YH.5L MR]7LK@:*\]LUP5)N:]8,V_B]E%(V:5(MYIWG3&..!FG**-/UU!(=I],5AF8* MZKC^+E*WC'S&I&ZF``C;6&1R'E:@6Z%VX!6Y8V"P#)AYK@D@Y@,,#$-0NC5< MBW1SB.JI`:++)FQE?L!,WQI1V`T^'O5$?ZBJ:M0"XVE#CYAN<3/M^A0PR"RN M"^9R9ZN972":#Q,'6=?9;B*3XZ.`"]U).=!?(X7ENH4T+?#^"VH$,XMVTZ9 M[SJ&L$R?F8ZPQ$9#N)IR/GX::%%F[.9B3+#;*XJ%QL`#30U?=&W=8\+0'1,4 MZ->3!K'@ML[6NA:KK>@B/3"@@!H*@J)W`=J6L!SA&_8W(LY2:MM\/[>M$X0] MU[M=]%10@$`QDP`=0<,B^V[/A4[F]^B M5(/AM;1EJGK!&@7A`DN:"4Z1:U/7,XRNIC'+ZFIK\+>29,Z,ENJ&K;%-=B/K MR8+9H+#,`)DP=,_N6!IS'8N"BMY-'A8=868YUEJ+NU*L$C>^7>[Z@K_";*:G M7^WND:EKN/=[VZ#9X:FNT8.PEP1AB]R():M&%!`!]P:CSN\TPZ7:V M[]-8C,42[AS;,M(NZ!>3V0+<4\L2W8VJ;S7E'*#H+1DZDUM(RP&-^TG?4)[* M\Z[P.E(:@-PV##14.L!=[B?I,QM)6EW3ZWSS1I+.2-7X+AM)-^ZM&_<"N:+%X>S6TN,`Z-U+=]C4GM//G`TV5'*W4Z9+[^&??>A`U:*#+T! MS$VZG=+N1G=L<+ M>0--H7:[CLJ_$*70+DEU="?_KU;+5RN@L\?6U!DPQ,J/,WKDT8*;\:C<=#2' M:.4S!^95+S\&1RL(!6F=7I\T&NV;]Y?MQF7SM-$B2S_TGJH/+]8\;YXOKU*L MN=#F/UI7V]6TBS4OFS=;U624U)Z0*(3)QLU)C9(GM?(9@T4$,Y-`[CX"/VQ^NY(_*D M=]=V1\(]+I=@8=X&8(^@&+Z$I^,2#-A5XXQTQC%B?B3B^!!D*B&NY\%ST.D+ M')0I3=`5'[%V'/Q+')=!.J=9H&*(E_2/"Z]``+N);*B%3S`#8WB+TCYR8Y"J M`>F.W(&(H3#I/"3P,->@)''7[HR[JLF%'-`>KB1_V>W&0E(.Q7T"@IJ0"@AM M//(.D'9\1T8!,`^4NH"+98T$$=#/GF'(_(?C$A)^*;F2+Y!Z1Q"I+8'*2.JM M&BSR!C`HBS1[V[/7V\!>3[*'A*YGBD&M803968VLX`K>486A(I7M>NXP&0/_ MJQK'T0:@N,-AOSU,%%+>N,!T+$0X>:V*`@@1??&X`[@4+N+PR>3',>"WA-D` M1Y"]?ML7L3<*AF"!L!R9R3HN?R&S:,:J369:%JC!LRPM?9&L'V.&354&I%QU M/ARU7<^QVDK:83;E+V@&T]]F9/J/8ZAH48-8Y<'@/-?BQ03^&8@T4=NDG0"?I!\B!' M;$YDG^3\7`8YY;2E5BU[)=*MMHU^RZV[?ZG.N3;M]!H-5/M=30P?_3+HI M1M%-T?2-;@K[7L==NW@IFEFG5N823!T"V5\UKS.SB-Z`VN!!2)5/L)!GI\VWK7`)@B!+J'<&5T+@LDP M[(&!IH8J3YO!P8RZ:I[",#;JAE,W3`EM\O:F(LK'S89I"8@)*_6JGH==VN M&UJF5+8_\59+(5SL)+<6**6[:'0;D^$H@C[V'U#YJ*5K`7>KQW8?Z#WLK MDU*1U6A8^51](7\=$GH`!EHSF`2K3*1Y!M.?'!+PFS#7,F6N3$HE>$F>3_H_ M'`71I[8G^GTPJHJN=_OID.`;25J9?DU9?I`$=]Q/ZMN0&8@I&:BO$0-8ZY(* M5GP&?*,'79*#U`6!KGPZ.$8S/@[E#*'M+HT$.$ZAZD7I"[HH@`SD1B6X6M@\ M-A8#?[Y\9C$#.R`Y^&'9[,_4\Y#THJ%JVY%M<[JR;5@F);"*$M^E>2Y'2R4;QBIK]'B5SLK. M@+;363L=1:VV:5L<1:%98R;X0#JUEOM`?`NKYH#"TOY#%=9V/%@U3?+`[;I. M,QY@C8K+*#"]LDUD(DST)RXOD@$(`I8,PC9NS31G=MURC04,6-%ITQ+Y5OS^2_?MGZ55E2-B:7&9`G[EC'/_EI- MNFQI\+6'TH5=[DWDICO=!@BM)M6GMJ`^M8WJ4R/5_U3E"4M->4B_K3[;:Z'! M-(H[RTSCD&RCJ)8"_'@[D=^Z[G+A6E%]"O65@1DK\?Z5D2+E6T!%,F1'HW%O M5!V'0;43>;WQ`$"R70,&!Q/!&-53S:%4+7O,HACHFY<]G%3Y7RP&^1)T5@P& MD3_N"Y+O!<)R.)9F6L;%+,7URO':!]R6\K[1^3Z_;+Y]<]J^.KD^;S=/6XU* MMJ?.-2XW5Y0/^^@*#X$>RWV?1@LSR57CG,BMUZ[KB:-'@+=94JU?+VY./BPG M!FOUZW?MJ\OK&\9EFW-8G3O57XG//<()-KFT2\,)Y'Z>QE+=`+LJ46@MH'"S M,F9_N3+&(SZCKM')$=](#*+/@,3%[=[S\Y.K-EC/L^81(4'R4TSV+87O0B:(^^8F01C`:C6/R)L+M MSTH+VR*OQKB1=4`NLFL`^6%IY?3#U>GUV?DIR,";@Y]6CPOYVT+6Y-4LC8)X M%`*$U@K)7E%*F]7W2M(&-R@UJ&9AN`NUEY_4Z\8V_LM?O%N%(F/60=,5M\#S M:8ZZ\T?B$K+QT(G%0*0AA`%RUEJIJL1IU_QN3I M\\GYT%%$%B+,H[(Z?5J*[SS.;!M\[Q;L5@913AY^QF_P%X>(I2-WO#'2C5%F M";&VK#GBU@V]R(;4JJ]O]C>PMLJXC"3=C.9VD?;6_@+EQ3+GZ;EB:_ M<:799`S]?D@P9PTZ\TL(VV-TMUL17T44PV2M[&2)[X%3L(+?Z61IIW-(6C?X M+M%253(8]Y-@")81XZ4FP5/J0#[.?8ZYO-F@JDD0U6QH5=%3282'?@H*2BQ@ M6>:[HPM,7"',J_Y_O*ZV6Z=_=(7?@1$W`1=I@1]X:JFGY\#1.I&289,["-0.,9R[*?ZY`,Z)\F>VR9P5 M"U)[HTR9&A[7VG_U2=S_1K':W;YI_^[V3<8";ZDF)!CW41*Z30Q8[CO.LG!* M&43]"#0)5:>;D'!YB%?"J,.)>HA[.&HC\?%PFBDCWG",VD'HB_L#)&(H(@:Q M9R)Y\LHQX.JS.#-PX%KA\(I49L@1OM*\,.CP@:5I6[*RJ MM30(\>`PKS6_97P@X[7P4&`78D!KTIFU(8T8M\54V)9,2N0)(=H1>3\*$D%. M&HV;-T@B"I,1+#NOQ<<@QN"VYT0W:2];$N/A3H+A:HC).ZQHP3P;1NZMG,DD M.X;)PV2$N'UY0BM>+Q@>@BJF[9-&JWE"GF:3H+H-4Y.='J^I!BSB$0<.404K M_*C8;K][=7U^@".5'2++L+@18.2V\LOI]47[_@EBH&E;^V M[>OL$&W'#U+.6T=F%ECY'<_-FPRTDXX;S#!9?!WDEJ+^S^V8J3TA7E^XHXR# M9N,=>5++?C2NWP-KY4R:9UB<9WZ^P'7KYF+KD9@VFLZVN6>37XB,*MRRYTL: MOVD42:LAV)4/&7N9A5[*8R>732 M^,FQ9/PJGG^`L1F0RDS5PUG]2_[N'Z*&1H6:B=%LMLS#$S]FJX!22#3$8JVV M20I.FNI0$_7W9J$IZ)4SYICHH)8*Y@((59D4!@#IV]>OW_Q:+\2O2F4"_<9C MCLP)F/$0`ADR#:/R$<.V5?POS`/6QXK(4?6%C'M=+4=_@/7(2BYI&M7Z/,.K M*1VO[P8K>C/K.R*!OKXW2PW1VOZPE?U92FO^K%N9Y@H]S.TEO>_"1^+)4<(@ MDQ)XM/,042TBA#.4H!,QYS<`#4ZEY<*$YU)7M>!Y0$V+F#G&QJ&, MG9[S*?9R*?;R*-0`23W?Y`P=HB;G#NIZ/#9A>GFC^CIIDEQ:-Y8%83O$L2F6 M76FYU[HW7V-KR#ICH[3KO$*=,XY?:5BVIO\=K,@2R[%@,A`+NL*X3)9H>>G* MY6K^L*`JYW6[G/%U>CZ'Q!F7&UPK="_D2D?]_X`"IGLHX']3#3S1+TUN2,VK MDA*J7KY!]^+=CW:CN:A_3;DH44EI@8*$YJSZ1F5V];%^R(\(.4_BW?-_#@IWHGIN.$M3'.VX'SQ@C`3 MBDS6G]G#CYF%+AC"R@^520$-'-$?R0\5:%K^.EQ<"Y?PGE8.?IAYW!$*_/O? MD(>G[(^CD1BX0WF7;N+R024D6'LN=Q.C;@66^@>YGR>!U"=N7UW)`HG\#$S% M1./53B!M_%C@_L@H^-A+")X-N6$NDW<]/.M$;JM5\B)?9BJ*Z)@`J]*`(,M/ M"ZV#!IZ)`4-U/+FB%/7]Z=]PPX::FJ9BTF2@M[H>A057G^)B)5.7/KQ*L*OS ML,GD&&94)C\/CC-"AB)D8'CBI)*Z)0CD@!N8U,(=*N*IRU.89$W).S%M MC$^NS)8])),&84;!4P+E7GT!.OZSFPAY76\&!AO!, MT9`1[CFU^2(X-Z8,'3)-%;@_$`-O^#`=.[QJ"V,[U[?)3AN93HB\BSM;-L[+ M0@L6^"1GIJ6C:U*:(X6S+UF;[T*>^WQ9]V5_"N7DCF-IKN45I.,IZ>)DS!". MEQ'NS4!V0KDPYO_3WI_WMY'CB./PW_&K8&<^W6MW9+LN77:G=W0YT;?C8RVG MCTWRTZ,K#B14I/]ZTQRPUIBW=3NIA:R,F'U?5$V"U-6"5R*9,$.S#=09+_C:E$RZJ&DZFS>@T+HW MTF74%$+EH,+(464FV[BFFUJ'M+2VOPT)CY]];-UUNLE=K."`;@G1,V<_1%\9E2< MX;U_E!UK'>X]<1DHRTBP9\(4"@PQL%@B/PKC#(SD$.(?[%RDGT+ ME/&)04=2):4U^L3NL&6F+%=(;D:3+KO!M_V#U.2[\!OU9:-Q5)5E\WY$9];J MYK5I8P@,VNAH\CX9L)52A6^!0O"&"81LMZ48>?(/8I@^>';8K/BX@0U_PNPV MCBYE<`N'#5E$$B#W1!PN:0,-O/4'^MV&(V7OW,9*>Q:BHB7[VJRP&S/LCYN< M@(@QE1)N0V6Y&1HMP=JWEC&QM@QH5LJXQ<#^,$QFI_-W^BI`'^P`''AB4;@( MJ9V%28$<9@J!=9I=_,U"IL(K([S0UAFOL>`;.;U^GNXUG7?-2A6=<]B?+Z`3 MNU)GHQ-M(F)-(&H>E%QKTX>V#HP(VOU6N^J5#9S@\_<*O0!A-?WXR3 M[@P"S'^GK6#P@,GG_1\)*T2PD#@*G\[(QX3TXPD=[RT*".Z&0@LGI'/>H-SQ M=LN0-A2LBWW4VLR1.W(P!;-'RD;)'45J$+BGOO7D]F9=]+[=RELOEN%*(GD] MNGP'NZV(7@T_'P]G4QQ\Z[J1ZRB2-_Q@IIV=W$H);X[:*FN0F`+E#ZEA>`;JZ_"ZJO8 MZPL\:WWTJ]0EL!K4(FCQ(AR2TN(G"2TGB\/B1^4-I0/S8N/BB"U#<#Q2$1V2 MK@Y`.HA>%B^Z'T>#Q95:*]C3'9B!%2G@C('V1I=\:Q<3/LT99GJ(-H&IK?>XD81+#TNQ1P2D5XC6W>EMQ"P`K53*43=<@?4OIN1RGK<(?L$O_0Q`$ZTL;L M<(\M!S/A2?<@:!$H88;$6[-QQI6P58RW(V>W-PON*/I@-/%%!QC7VY9$5"S' MTX6R+Y:82?5:EKS-*CL%87]6H9^6QFL3$(\3@"*(K2(CRS7ACC!S#*5_R\S[ M$_S$;^<4UC7N'/TACZ8L,>BT1@(>UW"4M^,!"[):#6@ORR`NZ5^T@WA/5WD^ MO6QWSJ5GI("!8[CRD'V4=R1MP@_9/4._2,+R.GM[;"0K.]$Y1_]&[<%4_\`T1.6;;"FGFQ%&Z>^LQ:51+SJPEM&RLN4"N9S2=8^RZH=X M/*(H81$L^9#ST<0F70I#<+`I_H5_=(QI)`PD"2G1Z(PM[>P8A%R*5>DCNCY6 M-T#JM\#I1BA5N&3:,P^Y0%^FJX>(6TQY)Q;M?5O*?P@RBH`R6BE=(+3AO/E^ M\`[<>$8[?/O-INJFQ`I(F^ZO#0_/\-46EPBDJ:9U]IT^Y*TEV%D*>(A"C'F2 MLK\Y/?3U'K*.P64#G]\V\*D8E`N%M8KC=K.MU3&['@U0:E'HJD>U.G[AZ,.4 MXC<5$!ABF*G]E>W\_>`=\+RP'*E_T0X%4%/9NB*R$*OK/897P^?,'P%&@_XS M.2?[F^YE`S8S(WC?QTLXJ4%X!?+BZ*P+'-R2OOT,EMNJQB[QZ7'K6-=ON2)] M5GO1P@-7L02:A\*B&]`^;7C4O8DOJ98M^&)4,+?>"N0'4R-)&@! M-R/R]V*RR%YCDV+U#@54A!A9AP$,_LDJJ+D\`.3F^ENU`MHFRO%--T&X$,X* M0<$"X!+TLM;X!:.F"P'6]GWP@@L=YJM]WMMF\=?=*;7RPSI;:1MM*$FE6ZUW M5E2G-',_*")E_:"D[=1H4XE7^I",1ENK%MTGVS85 M''2Q'8Z`Y>"^;DX%'KLPPOXR<:M"?P*:)\E'J5C/!@7RE&4R?5H@@^3#J$]' M;6VF0'PJ>=E&)80#A;9"#U$>0"Q"/^-6OYF[K^Y;OZEGKM[) MDJ$X0!+?#+KSCR-(O*MQL/#37=M)6,!2M)9*)%SC[%%>K$[YJ8Z2?K58H9KI M<(KZS7ONZP8R1'PO"`T>X19CJN(EUP@"I6[A"RI`^&WW9\BR0'O(PC2A3_NK MUG'WXH^S5K=^>OJJ53LYE&7Y*0ANP?!'Z,2Y!WKN93+;NX8@3KB[97\=WW%H MTSUSZ6`OD\6RL>9ZW(J/@0;L#^*!UZ#K@N9IG6P/#^K$+Q!PM]+#T!P>_GKC MO+C;#Q/J]=4X%Y]XD1LWC:;O5()1O".TA M99VG\`KFI:FY:D(%"EPF"^O[2_!O?[)'Z[&^IL\+.`KNYO49Y5T5CO/!N&47 M,/!ZB;J5@>DAK-H MT(5XIWW3!0/B1^)6*/^;7J-Q:->CNV2VS19H;!&LGO46,;X\T^I]CT25)9@Q M\7MS%=.9,)TD7"7/P;6_OL/A"G+@M9MX8!($R+^@CS@+Q)G+.<`&U\GUG`IZ MCAAJI'*/?OB]LW.('@>8X&2/W9PR6!"'@\\/>2&\1)LM`X]%D;2E1W&3?I6U M\I"(3-ED3,,`(`?3JNL];XU=>=5E,6:\K7/>ZK0N6/3D)[?L"KOO*>7'-IXL M_`YN1%<\+WTY/TVX%+G0&^$&8DY/%L*(8SMMDVF7EF4<(PZ`-U!_^`1;8_S' MMW#'=[?IEY^([WFXG3VX4SM?*U'#JF;;\AIR^`BG[P-VAD[1 ME2RZ_=O9C&(!)7RR?5'K_$)'0\'/7Y]=M.NO6LPD[5\E$!X18[/"0O+RO_=] MUFO`D(FV@R43*'-;;31`6E!2W-`79&]OC]%C,[1SC35_UK-9!3=UDC'5'Z:0 M:04[@#%.:*LX-1F"J%BG`("G@R^1;SG:/I=PJ80#.3T/M)Y3LPTW1*C=@AT@ M7)_`,U'L]<'ZJW+;+Q7!NVIMOU#<8)A-X5[<:,''SK4)X6WHETH5IRH'E!S; MZ4JL[K+U1)9ZZQJV<5:EN^NH&?,NQ<_&B_; M9\S0"+H>#TY!R9I)Z+>#^;B"/<_3(_4@:X(WU8,TC^[41#0CER7[::I+&W[7 M"UEZ#7^/VO%:"QSM%2_"""$5\*KS5E\%!V=7$#5?2""L*>!5<=7M5H^=LOZ] M:7[_^8$Z9-;)>L;\#OV*O]XDV*`=VT5N19J`!?%A?T5H&5R7Z4MV@X__52\] M1NVC]N_'+2KA^5+QGRR!8Z54!2)_^>1JE)'Q&N5NK=-L!ZV3E22#TB'7,%86 MC-8M6%RW8*E`?(7;MQ)A1>8W[#,/6(HA\'9=XU[Q$US_52"()TQA$#L55$]@ M7ZG24!0_GCWC2S_09S2#-#T?$_(Q9JD:/\8CE@$UYK$H8'5G*^$3,34"Z*ZP MJ<7IZ^J@,($*!M,X;_[!CLI[5%-YK_SW]G^$C:\?"8$@KF1^.X.L5U0,@F?6 M>:O6_&,/WPO/J>\/]Y1*9JL1S+L"C.X.D-= MH#%-9T)K5U>[3TTBK=<-4*>^H!?D#:_C75Y_UNT(WO3_TIY@)5_<%8PL\*5= MP4J^N"L\DL&7=H97LT%W()!S3-O`[/%,Y07]-*6[\PH,`?,&=I6NDEG"6S.] M'M1M?#JKBFP:E]CV&/NK'1?AM9[GA(6!8U$//'0`A;*1O,,//\OHX&LL,/3I M>L<[T#7P8>=A(JEUIRGJF$IHSIZ=_M8Z M;Y[^=B+C))%E<7TP[%+(6PJQI>61/U*-&!&9UF@K"%`MXG^?2"L1XHI=)]MK M;GQA317<6@L@_UUEK8VJ'"/'/#K'5^P06Q).>=!8@--GY+PN=AC-*[`Y)/Q- M!3VW94N7$PL.8N8LMC2D&(#X[0=K06S]2@V'==.2VJN0R=Q\/XR"ZGTQJ)2* M]_W!H#(<#'K5J%<=],(^AL'U,NF)JNN$0'_X$+A]4A\M?DD2VA0BB^Q#PLU] M;'F_]WY_/)K\0N_6;T3`3 MQGX-&E;#TE\B20/]KR+SFF1#_8+B;H3NW=LZHN(#T>X/9"#1KZ!WT5L\O\A]SHB<8X8*5].(Y1,.#-Z"*S[&JQO3F M$XN6L]W?(;U/Y/_%L^E\''\@OWR:TV6._&3D'_N9`K'_"'1C-&=QK]@U#]S< MGD^'BX_Q+#DDGZ:W_/X97;,6LU$/%C]J"='U?I_VFNH:H^$G5A-]2GN5L*$L MDMGU'"(LPX\7)Z_)BV22S,`CZ+8W'O7)JU$_FT4CK2CZ/QF/020C$ZO*5+(%9"BY/?VA3BCT-:?'$%R@)D"<7*1MOS\]..ZT]0CH) M="UA52Q!]Q!I-H.L4XMX-)XK!/Q!"4T-VUNJ=UW%'Q)*\'XR@N1`,;6.;SZM M)B6K)L:(53!<6ERA])#GI2SP"'<\R+A!9%:!HG2!M"?]O0(I5LE%@I>1SL8Q M>*UT;J&*,/2HN3:=+Z#D<8U0X>7[_JX?>F7RNE-3/'YR>M$Z@`STD&YH3H"= M8$3[-_&<5H-6K`PY-IXO",#0;G\8#9`ER04M\-MT/&8NNWR.;E]_PNUP*#R8 M]F\QE1%>-HE[0&@87>>,G';`+6L"AV!49:`U0GEX!]E2H*5]IKI,0'?I"I4% MO(0ZC3IN$7:Z+[M=Z1>TI,A;*E@8&[-@^VRDMW-VE3R932#4.HR'=PV;!F$& M3?/X_%TJ7D;]+ESUG4%R.=!J:*U-BM[SY']N$XKL&<7%;$`\LMUL_+8#NG]YW.B_LF_3\O(_[7_`@8(A`B M$OY]>8]-R2_PN>]T[YN$_F;_X:.N^GL_2>X!@OT?_Q/_:^"^U:Y/*P?+`RZX M#/H?#S,N'9QL(HPX$DT"7.<#'%.5WRP]C^VEZ?(THQIPC5]),EO(@6E2%AI- MV$0Q``'R,TFQWZ&%0^?]>$&YN7L9PRK03>X6C$VAU^,&[U#/_($R5`W#* MZ00,J:_)[HKA?Z7_O&K==UJ4P+XV[V.;PB5 M=+-/H@Q3K.X6O.P]P]`]N%MRSETVEGO]&\`48)WX;B[[DRZK6A:!)^4!(R`*3D.!E"4$BF2XI[-JSK MM`9XBQ7`M)%5_CH='ZIA--@)N;4FWI)9(8#3T:5[?+EE53(?G"]L1)/S`JF&%;N^?%L3B+'0A MMO4=C_'"#E4?0;3/A49(Y0:R^TS*#J[(/`AY<6A*V>G;TM*>3:D`2%4`Q3]8:2#/P.4"\$ M),3S^;0_PC0NVA"F,\0>U3*KH'',L9KK^!.HR3":`;(854A`"9DB8F#'<%Y` MO1E&*&Y&<>T0&K^^E;CA&O?\MG_%U'#4HR?ST]G@`$00%(]O;B#X=+P0\JG* M%#R!&"C#6]G3)'H=UAVR/:&<8Y)NQQP@W'V%H>V@&.*^!FTMU3I7KZZF<'J$ MM$$+:<1>05W8WOG^J33Z@-D`#S@KTOH77Q'ICT.<7J=HR5#=6ZY='9/5S.Y* MQJ-M;A=9USEY-^DTXRG13S8E)I2@MT^;S6EL)K? M0KK"^0+CFJ9+O!7,<*:S,-7%D`YZ_X/8E3#VPF[HBX&O8PX2_@& M.HCK,KN6>&@?`O2H.[^Q#_(M)\-LSE*GJOOR0RDE"8N.0+9G<\9HEWNLQW2D M<(P`(JUKAUS$JF.8#>`$[XCJ^HU_!7?&> M#^3D]OI^,)K=WTB;0E@-="+=SZ]FQ+^?)1](XQ-]1EF82`OB9C::DGM-6TI_ MO>]*4T(:"Z+0?0KD_N%Q^983*(]OETP]JA$!>JZ[LSDL_I3O,G,KK2OMLYEV M.N&N7:,).!]S9H&]\<$(4HS-+:\):^)VAA8(]IE6)_%\L0L!:JBL[H.7!8MYP]0?]#>=?4@&!7([@4V,'::: M:$UJE%/(7Y.`A%-_)`C`=YSH^%FL1EA"0<$JP&:?JI0V,I7*A*WB/H>OZ[?!L,6/;B*`2Q?0OI2N.'[6^\10EYSJX'\Y8 MG!.ZF#+7[ICJ@]>W8\;DK#]'J@R5Q;,$]JM@6Y_?`1`\S*G&&88]8S*?U[-] M0A5!W%2:6KD+=/Z$;59A$:#0S@J,C&3L=]PXF=\D?5B^Y[PK[.:'-DA.N=Q1 M[*7FR=G5J$U+'\HEKK.(P6=E(*(W<0N(JQA+9^8V_LOF!ZSNF@6E%BIA!`E[ MAQ7/SF:&%>L3-M'4;)3L:WI@SL4;6<<.."MFP.3^R8-B::D+1BECL=2C$6\9Z,B7!54'7V2_0U%A\G.K,PSJI M.!!DK^0Z2'"P*QAOCU4$C)*QF#_`C:;%#,Q0DE%6/Q/#DF1&^"\09L(SFIZ M=K@"&E-HR?5X*,%,.#ZK"T.C7OYZM58'+>V M9[?C1!FD$"7K$X"#BSH$%>Y-I\PQ3[+FG.TU@@:%2OF<,J),G`A>`4QYWY). M?P3NP`'[\SZ\_'3#5.#+&1['H7G:N:"% MN&^$UD+(D,AX%7!"C31#R``^`6^[S+J?2+&A-TE'0KD*K'RISO,6N91#4T0: M(HA7Q5Q@N+&`5'09_@0KA@@8AK8.LF\/!X/=!Z&IFJ>+\P?F[8/C9D-F17[X M0>L%ZT=#;E:\QI5<5G-WAVOVAWB,5R5F//C(HBZCO MY=&+SEF=Y9UX*_:H[NXFM]==^HJVT7\_[P(RVKS90];.<6H2Z)AFX`L.,-?6 MD&2!UC$M>WM#^Y9,T(F4CH`R5PSAQV[(-CIQHFJR0YCKZ,TM'>+MG"]A/#;, M'CL-1MKC'&4IM!C=<&ZSO47@"3Q*8C(`VV7G=*B!W-!Q^7L:$5E;7=I.=SB. M+P^?`)&V7T(S/Q`X@#J)$8'\;$\`:$'+I.5(A\/J,!:4W.K8I2Z*T@O`@V`& MJ(EI<\'A$[;7#8]$1)WVF=&$43G9H4LR4^S-#,$BJ@YXY`!#Z,:TQH3:UI)M M+E]AC#6Y046%,:K&6&!.:=&_DJB`V2Y9_VHP8Y/$G/'L5,'D4JA;;,0AN3Y- M^E>SZ000CG$HN)8@VF&3'!P=V8NL9$'9B$5[L-\,81(3-K+N4>/DXE"?MB`/ MX/24,ME8C!2^8D_&27(#8A-^R.;'5#W'>KJ]!&KN8K%#5:=!T/*AR1;:%,*M M%8FR,VZOJ#I`3<,ZBK(.43<+/X5<,3\TY1!3X^``%UX6F$X*FO-\#IM(8KN( M`=-U%BG*@)I?GE M%781-[BF;.GFD7YAU_+V1A3"B0[K%NR]SJ?7"3N^Y[":ICL[:G6A$'!!5\TH M'@-O%@;JK2X8;.]ALMN>4QS!5KU-M^';]53\XD"/V[]W+TZ[E$W/6[5C:LU< M3NDR=W5-AO'UB"X$ENUYJM8&W2D/@CV_H9K5%M.7_%)OC_[?,`1@Y9]-[T;7 M;'77;#(JK7M@#PSI*LOME\4,\I4SNXK;"4G,B M=J1]F,*0H[PM1X:U\X'(LX&:AH:2$BDR%=5M0\:4'-QP^$ZH/6N7DDL^G^]V9[S`^SR_N0 M&ZWDH_;1J5@DI8&Q[<&<\>Z\X8XNZ,;3`W)$9:78:F/J-)\56*NL M`:L%JX:N8_\QX-8S:C=S,:W@0T?)5T.((X:>0;;^H,*#_+U/(>#O#E%;^,Q9 M&0!QV1PG!G,:R@+03*9QXDA-(G3="[R"*YUXB!PHW/:D^KGS/A$W.YC27`40(L+E" M`H@-Y`[&&]W_N?;YDG5QW!W.KN==.'2EDK^+51T2C1GW@/_\E;CP-L`%V'5< M5QO2=P9&"%O9J)QE_IIPK/2)#>@%].U5,KE<7,D1*@A>*=M8G=U.^DQJ$7\PG!T8PXL2%3C2.#489(BE;H;0J?B,$?2\5B6-JOO"<\ M-'6Q`NDQEV"8XC0#5`*T&QAW71@9:=++(5\*V2;?BN50+(72-R*-:%`3+&M! M:F$Q!-#2=85-85;2MJR$?Z5E99V%Q;(H6):6=187:TT8]7CIH8HJ(P\1;#7M M"_?)"R':I>8!IA$8I'/)4'+'?8A4P1*P2[B89UE\S@][^:IA'B\*8VU[A+,( M`L33U09.U@;*?PRVA40X;"#^#K6B:T/=60+W3[-\#Z>RX)Q.6Z(%,*#8PCJZ M>/`![GC,#=KM_JQCC8`3J1K M*5T(KN70YY7T\U"*WCKL^[=/)4;H>'$)A9NK5R.N[:+\I'V%)6!7..4(M,2X M*R3+]>36U)X4F\W1_`:,2-P?$P=Z/=:R!!0]$/Y$LB&0-SW8\33ZTDMU7%0+ MO=>%/HZ"D19\BM+=5\VSS2VC^[J_$08?Q&VS;OM4Y`&2SDSL+7TQH$-%8:[( M=X""&&G@1XD\AZPFN#K@I;ISD2`H8)?GV.>=\MKTK,-8X M!8=+N*D&#;"\*D*OHN^2NYLN;I;C&+HL$N)/P(<_5"@@4?UY%_[CK"J+5L&;F*9P-V^P,DV[GZ,/U$YBOMCDAB\=MM:.&&4M]8J#[)A M"=^'XY['5?$OMBHB)%S0:Y_P5<^Z6)ZHE*R2+N5PS&G$@GG(@G1"3D3SLDD8PXX:*2YE'7C3T!`@V_%:"?S10`'NW1B\<)P M:,MV2A>L$XQ"&@R>-FO5:SL\\$)O@"N>R*.SZ>"VG\PXL[+W?]Y.WG>I]@%9 M*B00K5GN"1%M!+)R?$IY6R,3<#EG<7G%@@LB/(#IG#>ZM_/D4+"``.3JP$SL M;V*];/_OYFHDZP)M'9">T=A3U1F#E(>,`"GEAWIDB`O1$KS0)81ZRF1"[T:) M6JS$G-_I-T(Z2)P1)]4_\8KI8CJE&AJ5'=?) M]73VR?3?L7\P!5]_>@T.6\Q!)J;2'D]K>0]H]=K*1A\&=-#)D"W6+/.Y^4(Z MS+'0J_"L+7WHGA,_J)#][/"VF4?VC)R?'D,\!4BH@P,`>%"OSEB2.@R=F5-: MK1K8&YB^;#KB9*"SJ\N/L?0^L]FKRK)>X]/VA%U8FQ^0OX%*IYV2"6]1P^Z= M:QM)W@X_R^-5G"4S=2)&!Q*2+(TS([!)''P!VG,7'4;BFWGW^J;(>@V/3VZO M+^C#X^(!V?;W`\VD@++L3HYH5J".7(_H:$B1(QP:96T>L%_@-!OLAP#LE_[+ M$VGGML&I=L\O9E&?)\FT(B#,0/^X'@W4',4WFDYD/&>"8Y(68)B1$E[5;X<= M^H+=*CA0]PN$3IM>9^&99'*V'\U?\BPS&2;]$5QGF6*5'3.5%,C[AP8+VD6G MWN<&?T,9_(`NFUH?T:5-VZ.$+8[SAC$[N'BR=S:2?81NZZ@-#XVN6[=7;*-( M$5,;Q1E_DQT%NXBO'['1YGZ=CEFHCG/:UJKM*J3@S70^'_7&28Y4&]ZB\PMS M6D674MO9!VRO,$70?3/7XX65`>A2:,IBFF=%]8+M4Y[Z13"U%0H`2 MZ2\B4+U:>=@%]6'/LRH0,;6+J'S^+[_(USR!':T-Y"U453%X,_PZ`V--]W_) MW')0-P"V2WM!*8/T?.F90O%?17HNE97IT:5$)3ZSBDJ&BXRHQ,<94.'/]4^C4,OQ/E*6?$7U$[@Y-P+.7?@[U!_^;S*:'&7]`ZVSL^"5( M*K/\J(W6TX7["X]S[QN>LZ'/KCI,S;W9Q`FM$2AUH@K2U' MK$^>B+VN*0;&#!@JU!;85&;66$P7\?A0/H:;)NBJS)\+'@8('ME;_TDI=CU: MJ&*TN=%PRO9$\/1"-TUX$4KBZVF7Z:%L]<0X(0K&>P<$M^OR+>![MT^M=L>4\OF%AO,O#]^SU3#\:Q+OZMA MTO_8O1VE,'*D1D8-*?4`ZK0I!UA=6C6@#S.*P<@ZA%%&(3`/]2I>%!Q(G/@Y MOH2T5'2@84[.'.CU(E[0>7^I>VJ,IDA5KGSIS5*:`.&F![[G\2:%9P:E)-#Q MP/<]WHRVF;Z22T8FEPBD(.)A+N6P?D9RLEMG^\WVD3FMP#6"'1-;YA5&"1X9 M%B%/,<;E@-RB94]Q\30W3&W3*SVWY-:XFE?92852"%N!2UC:[C`^/!3K$K(C MQQ+\"E5))@#8]]Y(^)1(;EXDUS==49N`06ZF.!0;R396SO*Q8F*Y;YRST6R= MAR;KB=X;G$?TIQK_B`ITGI%]@*"'/KM((>GJP"BYG#+5I.Y;G0A"[.IT>1.] M,Z]T"6^-A.T[]Q*,S\UO+UW?4-.N-QJ/%I]8C,<:^FT?O;BX:T"H@YSSNE5W MDRVK6SYC%0W&BE),HAU.N#()5%MZ$[Q["$Y8R@A#9(05N-&PQ#EFJG%,=AL) M)=%5=WC9G=U)U8N/OC=E!N]U/!=+"OP\QI^\S'5\QU]=CR;:2CH>:':R^ MPGMJ_++HUA.Q$3<&Z<#4YL&?MW,YSS6"\ZN`;XK`@@K9U!X&QV']A*U_-8+V M=;X`6:MMZ2`9#9&75JBLY\U;9E^TS6+1#GI'+'C8M"WE&;&P!D)3!7A*TF<60ML59SN9^4-%7J/C7>;[R4BJ/\]2V@#X("FN ME_^0IOS"H'R:[L*M$1-)/-I*W]!6\KD;!4.]YD;!1X6/&3]*G4[QEP9DL)F? M<6?5@#^3++FMOA$W5/?%/493%'!_,/_0^*E.Y$`I\XU?@>P5+QR:L)%1.C1^ M13E2`]X9\TI(\F"SF9VS&F=K#F&-P/7/1(L-==?Q)

B^%)2ILN)END*X""SMGJD!H(\%!Z-U'Y;)7O8^CH1\$Y:1< M30;%BCU%1>C]RZ>H8/C[A>"@EV8N8"7/20HQWS8MQ68$R^2C6(-@?B7\I^>C M\`/(1Q'Z/!^%B-_$C^$@#85,/P#O\1_(8=2+^^_!?X[([#+@U#K]2`:?)O'U MJ(\!W&&[":)@#/:^58J,2B7PUL^0P?C,*3D&I=UC@FD:HLA;V4SGC^/ZZ:MNX_2DW8V%0W=4@89"L_;W1/!(^7:`726WHNTE]"-O%^CCG[Z;I'K0YFY4A[ MC%N@D!KQ*IX17HBJ.LD;"T+>028^2AY>#)H01S\C\U(#5QQPOR.OEU27#(?7]`]6PX0]91X!J0'_2/272WN,E_"HNI)0"W$XBR^[ M(RJ?[[1^*2Q;.I9<@D-4JF?B*4,9HIY%QQBWJW"'8Z,_H!\H"PDFF(QS/T! M>5/5(VQY.+J[O9G#B-?B9+'`08G9Z&8!X;+DN.&%R;Y\OKX[3',\M,TI^]9D MTTSM/Z:V#%:5%OL-ZY5F(6&-3>`,\^)ZC3\/;:Q-0=E#!CV![;+A5)4`9QQ\ MQ,<]2X;:CG)J]MFZF4<([)>5$OC&((64NU*.**ZWDH5U)=.$K2]PYXG?O,QT M!VID8>Q$NW"K93Q=\)]X7XK]9,F6,+"3<%;$'3#8D\3-Q#P2TBIF&,"0;S/E ML=&L+W>R/DQ'`\QS-OH`7G=BUN>-)'3E$V*>=\8'8Q/L?*^7=1(W/+%76E!`L<*\A@!8UC98%KZ\8\ MN8YOKL`D`,1`XE\V7W,0S&/=@&,-(P1V7\.IE#J2%$]R>4<'>V-;IM_I#`5S MD'*1*LD6['=BA/VX#X8G1ACF>,9QIB?SY'8\[DHO'T0J:F)4T-*V&9=1J?8? M.>!SO]2%J%+BHX'3#L%DDL"L7R`;R!`>P-8K)M"EECNKB_\XM,D4!.2YE&=+ M2M`>:L^7%.2LLUYAF<^C.[B]OED/AL_L#`##`T.+8H"YG0V!SIP-.2-)/H-7 M-L7!SJSTP?Q-6G-\MZS[M`9CG#ES@%JN760B[=+I!:6[970X@`4[U+2+<\R> M\B:CPB[K)T]"GL'O&;A2,&<"V3A+O\W]6::W0B0;C^'HE*]*IJR#FC-;Y=PT M9OR]=)]O<0.8O!,>^;&/3*'].TECZIOOH;D3,;J>O)F+@%__IV^E?LG==#"O5XMJ; MUP:-G;:P*;X>M[`?M[`?M[`?\SNOR.^,RLR*!,^I,N`@^C4_6ZT[%F;G:D3I M/^M?(5?8\N_)"RF=,]JKJ^'E!27TUMEB!@G&&I#+B`HJX?7Y=HMP$?F,_9'6 M@2$_-WZT!4F;QRPJ-=7M"$]P]O8>PKOS0/CL*7UT/!H,QO3A?]!G_%&=&GNI M4B>W8W*_I;+>XN?^Q92R,]F_-U(%W%]N\`B\>N]G6^90=LGVY3)$SPL\U<5[-;;%[2L6:QQ>G+1^OVBVZ%K?^.E M46&PLB2KT=>.7,"4I64[%[7&+]U.^[];Y$D80#:4_7UR\;+5:9&35JM)+DY) MO44:I\=GM'--M8Z?_6'4-\]9QZP30\D3+RJ-RIRRN9CR+T^440Z]!GA!,\\<_A*M?7/W` MI$:80Y;I5P.1X4B;JKQ.[10.3H2;M?-FME_^$[''8/1G`N[V8ZH;)BS;HU'9 MZ\Y9Z\125X!U-6)(`J/RAL"@;NAT MF^U.K?ZJA00'VE%=B;=#!P,I='9E!N@!YDMA:B[DT9E=TZKF$&\(E>Z/B4'$ M#4?%`W'R0*_U%ZR_M`_'H\D(B"%3GF`F:3HD5%@M.5G2>\U70Y:&!&#D`>*3 MF>_AXT/^LQ@9/ZL5_E.XI/+K4;P(>N8.S"*S_LC7"]#?GE8":N49440CY9+Q M.<*I@S'ILHFU,AD^(.L1E)5N MZEI`/>[SRV:'F;`YXTZ>AD7OX&60,AYP-M,R;.4S%UH>Q53`&"[G:2CPHQNS M(6?)=Q0/DCQR6_!8TZFA8P(PM-=J3OK("@Q"QJ41&`>P#23.H_7I0X#:3WU MT8)7I7+4L32%/,\#;4%D@&`Q1/E0@8TAVN(\73TM=:AR\&D<0*TW=*;$D%L8 MPR MFJBCLELS<1XM#4G!5+R2+TPUAEPN*Q1IJPP9;U8RG(MWYP0+8>*$474 M71G/@4TZS%V(]7*),YW%EZH_.)]4?D.!T\\D/>7R[E*E\@JRPCR?%,L;BNVR MS)NX'<+#+<.^R)@%D16<,6>;&=.YEIK-GK=0O%P,NHQ@@A&0>#(--&M:V,^4 M!TUYAP$6X#%LN\L6(:B`R&A#?YANH!MI9&TYB53>51? MWT!EOJ,<5FBNV$U0J8,]6:[PP68%ICWM:;'%>136^2>Z MNE\K@N,'!^`?\D2)3Y[@;^\P4R1,%0FR18JI(E&V2/E0+U#*%J@:!2I2)WH" M>)\-$Y[4D3']KT`6,5KPRL&=04QTRJ8_4P+%43.+IWV>B`C0+#"5R$R)`$Q6 M((GQ3O)H2`RQ2+C6Q"Y?4;3IO>TJ?P_>WUZ,N4WW(Y""'Z3*#T+K*+Q4,>BX M^8S.!^]JG'KB9YYX=_#X+O4TR)0+,T\"@`Q-R-N[=)NW=^DV:9D[>)R&3+=Y M>Y=NDY8!2+/-&#>DKYL?S)+>_3]3O]^RT.[LT/(''[$EV[*F< MC]DC<'//6EP78T=M-_T1/VX3IV[C42]]_+VTZ(IC[Z6PQDEI5+DO!O1S[T?] M(`[ZU;`4#DJ]_M!^WAU5_D7.NY=C[Q>"@]XZ6X'E[R0\4Z_3R;OC^FW MR@34$.*TF?F5YPF=]H.8&B<8W6;C6V>E@U",+WMN3^LWCNU9EEQPOT'U:G"+ M>T:T63XN@18%0$?$;$2N7Z*EVS@].6J_Z'9.FN(T[:3U&T@GK`1TW03S4GQ* MYL)1P`\K?N:6V_))LOE,@#MN5?_10>#10>#10>"?>_]J M=`/.PFSB+]!>QGZ*:,;S+7-7GM=4KWGL8.6)=^=[VGT<^=[O-FL7HI1W%RXI MY,M"%7NAL_,7HD@YIY[SEBSBP=6BM]D^G[7.VZ=-=EH4>%$E_?[HO/:B0X), M[:^/CEKG#,Q2TX\&N'[,!)"'_TZ>I,I--N@81[1?:,.>721>M'^:C/`UF)ZI$(OYV>-SD] MMWW($8!%GY&B'^P8)8];QZ?G?W0;IZ]/+I[`+4.J;">S"3HS@T?W]&8.WK?@ MVLQ82BS2\.9P_=*P50E;H.N!]>,;V-G9K+#9Q%N=]:^OJ=QM[Y^2&95I<(#$ M)P&A,O\0-BWZG*M'W7N7WMY.G!=Y64(`.':)=CY)LO$T?%%!.[/X,AS1T M41D-[MY`$\_\=WNP<7J#EXXHN[!^[5"S*H,LH_]Z9Y+D_6JD/1B*GLP22OP) MQCE1 M(?^2#JT[T-OU&6K9U?,-0NBQ92MT(W;X71)=.4=C7,TL9J+/%[ M;R-(;Z!?;($O!6)RU_H5#J83`^EK0\-E#:JUBQL2T"V'6EBD4QMX(>=&R/"2 M$2*_>FWNP2$G<%>FF;KT`9M M:,AEIBP+XPD74IPH1"V7!ZC%Z`HU@+Z\)PZ5P'+1_3"*H38K1XCI*2*6T1IS MN%#K%A.E4"A3)Y@:`LWQRY<6 MJFY2F4PU#<7S%A]6"!'@-GZ*`0R(QZ]]CN:4FT7P6&#I+ZP6XNRAM/^BJ@1- M7"M8>>'T]D^;SU]3 M8C_I(+/H!>;%+#K_?P5?I?6.47"U/X?$5Q!Y\OG$VV?/8K:?\P MB,G'C>S)UVK@H9!/OE1=2&=1^":HUS-CB!VF+ZR.CT.;>U]8Z5`AR;AUZ3@MU\. MWE'YVF^@KC8R%DLRA=&RWK-_6%#>FW24R?S-R; M)#+K2'_%/1)5<--;)`K2O)10O0^"*`SNHR",!G$R'$1)$)<"/^<.2?5?]0Z) MAKE?"`[9YAROE3HG&91\D_LC3H3*WAY932B_''T56CU>'_G7O#Y"V2P(5EX? MT6:(V^41RG7""??QWL;CO8U_\WL;C--!(.S25_5D0KF@\R<8Y3"[>_#[[U?T MY_64I:0&B[@+5W];/V)IY?[X^F MYC-<)/?Q&,GV@DYRZ^-KVU-PGK0]GX_CGOF<1ZBE=+<_Q_NXME<0`-L*@H(( MWEB2-^&U-CUEDTKH]I1=HR$@?LAIO7/ZJG71(B>GOQE^_Z@]TQ5O0)7B2PB: M:#4;Z/>K$;AO,V^'\12^9D(IC>8$5IE(H$J6#O8PJ%X M`FF3Z2.>3!F[O/TCZ_2L.[R=]'>LO?["3C\QRHJ0XD:G#]EM%1;.E$XR"%/" M"K#@%N\G$`!HDB0#F9J=KMEB/4;[:(%Q$7C,!1`7&)TEBQ[U9/[F'7D.Z/H' M81>#O`+]&Y1ACGIW1T?\0?GHZ*B@4;;P%.G[_?PI^5Q(`7MK`Y-X2&6ZI8J@ MM+(*N,:QZ.V0)?W8N)+<_GC%M:H:+U97%6QQ=Y:XQS>T6G-JMB":;68+F5&-JPCOS> ME$-_14W?S[=W#A'T\^&#K+\0=9"LO9YMF1G:(* M6HPNP]`OO(U&^>WH:(?\]!.!Y-JBT/USVGOL,%YJHZ]XTAB\Q3<8;#_51O_& M?P>W^(IW!_`/]A4N]=W!;3[64H'55=!UBR2C.FB#M4L[?3YZ3&_;`2JM[[*T[Z# M,@'WQIX(;#T7K$)?<.3@,V2;0ZTDQ=XVD0.C""SN$`W9"MPL2&G@TY)0\`@Q M\1!T>YM/MX,WP;M-Z?99VSE$/=702S^.!HG0@!;Z+Z[]4";ZK=UL=:F=UJVW M7K1/NJ].3\\*UJ>!>-PX/6EV7YQ>G'9KS>9Y]FFC1M<,_O2BWOJO'`#U"@"R MKTZ6@)TL@9-@_I+F+.]4>^UE#3)(0_K@B<-5/)A^Q&MFBFO10]0'/#C,Z?T%-/7AS/06M-P'K<5Z`'V!'%#@[?($( M`T:.Y_-DMJ"S9AOCEGT/@@`O&!<(OQVZVVJ?_%I[M<,"+'Z\@IW8[1'YB=UW M0:'`9LASQ,F;T;-GD.?H"9M;QD/:)HJIC/SY&6XT_X-;:D\PEG':6*-/82]A M^T]$V9^\_>EP6[,)=J@@RSSEML/.(7GV[$_67]8+LBVFOVY6_/ENC]E:B(?, M&P3X0<6ZW>:"*UV2&6JV.CB`5D>Z$=B_/N<:WSR\Y:0'KY[YXS)@5D\+E'AR/([]V5V5!SN%07WAJ;&A+> M9%$:/9#'`&1C78%HKPEE0]N2)L?CEK7U&05@`3;U%^_"RMO40 M.CF]6:;)6,3=CK7Z%7J-T5T7Y08_FH:SSIA6*CJL4MMP+,H/?K(*4"[P:GU( MJW&E3F1IYANSR3+%RV]8NGAGRBWK&%3_Z$&4]702$S#M*J%`>.9FYKHAE1_:+@I&U((.07U@Y7=_ M5CF4*=U&;%(SZ<[>B]=O1N_V](S00!C9#INY?&094/*,C'!:?.:(Y`5A93W, MZ()#B*[/KD"SP`F8D'))_`DU2BSXG/&'GD%V3R39+HQ0"Y*HR):TI,(D@*[\ M.E-XRQ;DY0"!/&$QQY?L+TZ7'F6(]Q8LB;S")I;H9.R*C*P9%3F;DUK%TM!9 MPE5S-?C#AA.A43*4?$$*K".TG]SJ MWM-5H5Q=:"G7[7Q!ZSRVCAC@%]3$)14SD-\*E7\)@_Z\EC#=80K#.D67"O+# M//J+`DP'T?7*_7TXD]Z6L;O(=G:"_/3]_&-[KI;XS`2X3J[I&@J%"L0KB"V<'X'E>163T:)[_/JB]?OV#PQ; M(NT]8^;46W`A%F]9[HE>LN`I?B"1VPZY+*%98+/%V+(4O$K"9EE<#*B?C'94F.&$HI-MJ(I06=>8B).!1[ MP!`;F.KPCXL61DG-Y0JC@H?H^P1"L6C]FV"&%XD\?,0DCD%-]=LHK-["9N'=-2M1/.D`J8H7^[$$04;"T3@LTT[ MS1Q2AC2@WVK[]'NFG0R^:J/)+3,[=8S8`J5IE>"6`V%GGD]N;RP=LS(7R-GW M4&OZ^>&*&06`'Q2@MTVI"608]U8FJLV`!PUO?3.%![0 M/;=L4/'-J$[K!:3TZ-)Y<'9^^N*\=KQCJT9&6%ZWKAJMJ771.K?6QF[7K%E5 MIW9\]JJUPT_Z!B*"[(!E_=%Y9*+-T=3$1@5U'=V/+BS7X),LJ@(:LCBR4Z@S MI:HJ@WS9[B/4P=+"(2M\/]>K*TCC@S,#U^R$\IL9F;>3=3-0;6$L2VA,40SR MSHA^VZ->(C\V=;(Q@7]Z=-1I75A?P5JP8VCI&HM8=6VSGQP7E],%*$4*EG.# M\(90QF$6%W(#*T/3WVKG)^V3%SI=Q2.1_4^UB"M6)IG5=P)C2-@G`[F(JG'N M_LP?_D@@8'@N_K`:9%<"YP4:/#ZCT$QTYF!*Q$TUB8J]9LDU;\CV]U[E;A?^ MD38NGIKRN2(Z_XQ-FAUUS&P/SXKLH'43#_)3,V_-7:UA/!JS@S=9?W8,VKQZ M8AZIZ[;VETP&+G`VF`E,ZF2G@?Y/2'7-N9_#OBMF)\W9^?\7,9G4`;7 M<[;/(BO%\T3`;LSQ>E>_(KN+_B&KRXJ<&#W5X[68^PO9&Q?Y#9A;J?0Z:YN* MOL'83(O8F*T1;#53ZU;*,P3BC/*SK5]KD0/FU$WB0X&=JWB.5W@4KFHJ_;+]2Z/ZD8`X1APTXU\ZE&$]PK7-31L?IHW=S*6[Y2;0F3QBAC34T MPPYJ:4WS;$K":%R#XF4MX8(D<)4J!#,!*BZ8#$=WMS=`]WQ7.89OUE<4-:K; MA54G#JN%6-H,S^)SYPMEFVQ08&Z5=#//^P4*=7(),2/OQ_!)(D^FX4:8,1EP MHO02S"K*MMSAIJJZO[I'&O&<7PODE?&$M0@"[B@8[14=(7B.UNG\ANHEM;G3*O`RZ](?232L,A8NF6LW[FPSTP5QQ0 M88/?>\$=LML0;NAQH6(9$`_AH1P'3><+U`_69J2JT869<)?[@!JA@!OQ2(?,$#Y`#-V%\AWT`[Z4.''2$WX/ MD^^B4-E"X9^RW-M/U^26+V`TOM"8SLA&7]8`-_:`Q`+*%2SOY?GZ`FXNF*B,831U@6\$I;;X72M?<6HW]"'1%A4Q! MMM;'E6>NYFH.XN1/,7B]M.X0280_>&:;&7>4GYO;^9J/)$CH/YGJFM=I89[A M2LZU5[`06`I[^":F&[,5:(/2IY)-%O9(;IVQ`FQ7@J\,GU?PO\K2_>\P`ZC% M@Q?VC21*@_E"PFHIZ=+9Z')W6/.G%>0L)Q?GK94S"["L'7=9*H-)Y45WA,\L M!`,H0YB:3Y%T?*I)ONZCCX-74!<@3"`TBLB?SYX!JIX]X\P-ZAOWB>8[,F/0 M2R+AXF_OL/"TYVWB#[RFPBX>L;1V@/UG?):D!X13!(P0=H9*>[&3.V.>XLQX MRM(H:ANWN5WCIV9+5:!^[]^`[9=H/HWZ?\Q7L.::![&FTK*:A243BXH,'A8/ M11C'G;0>Q-^KD(;=&ZKFF/J/K0L,`%25`^C+.\HP1`K0)56SHV'3MVMI<=U7 MD^\Z+NO/9#I):&=VU,YTNN3\MM<%IQTZZO!MAAL4I9%J:EZY*V M+'V6XH5L2T?`57LS2_\O3(M"G1=[J^_2L<7S> MJC5;Y\8"#).`ONFR5Y`#W<\=.`< M6;2XZJQ$7*HL(B[U[/\.XGCG+&CJG#7;1Z?=]EGW]/7%V>L+0,Q1Z]PGNWAW M%]&65^;?"7&YJ..#9T,^V!R12S&('!C]7^#`O;V]-.[>KH&]9]Y=GBWA18J0P&-H@Z__5QG,1$A3(B3\]^*6%:8+.R;4U31T MW^A7RS+;,]O2IOK4:+*-+ZA&!'^7J67\Z.ZV1[4<>6I'ZRJPS2$QN>D3MHL` M7WYB:PI^I]@/&&;8#I#L%'1EF[5.R^7OY'X_.L#-T.])\_S7;ON$"MC& MZ]'Z'4PU4?::>6]WNNVC9ON>I$F MTV^O.^=KD,E6P+2![8?"AU^7LAI=:=/:/%3D9>SE0C1^*/-O3S3]#//;T4NT M:J/9YK-,;KC]VU/+LK7X[8B6:OQA:,>VA/[M"9?>^?J&HE%K^6%()H]]_^VI M9AYP'WX[HF'##S3!^CTL\2])+-\+HO7G&#^1_89T$LBUD&G_1R*:W6=9<@@> MJ6*143(GTPD$".GC5O+7O.J'==65^EZD+K])\-/V$;2;28#HQ[HVN=;%_ M+:M'C-&BU6GN#_#L=B*IF@N!C)"O)&;">2Q34-9IW@)E=L&J]ZANI'N1N^*N MTYE\8+-/RY;U)1BRKRMK$'8%T*_J?^W[\E_OMKRQ_.1AR5;61(\RY"T1#+Q,P+M!TKN]Q)6<;E&P\_9$2)&M)R.+O>$'&[V M)/.%Z>QDR,TTW9FGED%RA0(MAA4/UUFYP^TQZ39(T;_8P:X7Y(@IIR`-\"KF M>%M_7L"B;&<.QVONI!ZFCH8506066A8:#2"\@(GX6W>, MZ6-,&1:!2!*<07+!^=,0,01ES0Q1*RW_B+&;?7X:6VY7B5Q`-JE,-]=%M9 MAX*+*[[UG"DSN1V/N_'X,OHSH]NFU&%V/)I>4%<2V M4[Y"A)F2N]/;Q3K%1I/EI2`FXXPA8VFY^8S;UTM+\>Y?C^Z6ET.=O`M)JY>7 M^Q#/1O19?W3-A0&=!`WG)O'*Q"Z)`V:RHDJXHVW250;`?-?8#4'#4 M/N]<=%N_MQJOJ;%Z?-IL\3+UW#KI=U:DD1JQ:JV9^Z:5^^8H^X9*6.:*F[\P M<9T9#]P;]:<%LHV+TI2NTAA99&938:,:(KZ-KC;JM]*I:?/'F_QHB.7@"#`9,S'H.A MI`@N7H(#OYTSL]6Z#XFU MLQ;!TBO^&J,YKKUH-]`9%=JSCR9;[>:C,=M9CSA\,>%AJ2&R#LQX4+E9#"L, MO#-BN_X+IA"I50ARI1;$?Y@\U7RDGL)0U+)#S)]0P)0SZC8;$_!/8&%@W[#= M)^*7_`*79#\?JO!%="1=K;=6`TK0!\IU#$DK(%,]5;OM>O7,.)0'$AFET09A M7$WD=J=>(@?,N+FX/ECJSJ=Y.L`Y8$Z9XP8L_.1R!DR#"C)!_Z9#\Z, M`LX*2@V16BP2D\<77X*"IE/0&JD:=32.+^?F',MOO@&N$7>+^OA]0>B@1M,( MK6,N+;Q3XURBT3*@]^K;WJ M4OE`)]59Z[Q]VDR;)C@)4^O<2A.":L/PY((^>#F8/2V(U2TML`M6N^PN+&H7 M;;YXE>CEKQ(/*)&7R_M_YG)@JCPI?0A2C722!:&X!14,=DT$?B&&H\R4Q),[ MKK-4I)6AF=F ML]QJQ&5*X7AVQ"&@9M6"K=T@T]O%S>V"+5K0BK&A:VW!*,&QU8!GI[<+P$+[ M:0$,$=\K<'L$R4(_3,_'J_2ZG0L?[,LI7%`5;S+CD&6AR.D)G!J"EW'G=?U5 MNX.`ZMC\.Z./.W!D.R5=..&A-NG@,(T)CNCKT9U$MKFG;\4#O)M.QI\T-!PC MU/'H#FUG.6XS>$!A"1Z,?J\U8A[H-]W=])F$0(SY/(L9'AJ6X@<0P^/`0YAA M\/G[D,QTAM1/1^P;"EH!CJ'.K']!GW`^X0-DL[USWM!N:/O9E\W6J]H?[!W] MB>I9&H&LL'',P9=65=,R9)I\<=8X)NR82([9/#FRCMHLPL<-<3KPF3ERVJ=4 M3(Z"C.B1Y0X"^T>TBS?C^!,H1.1J^I%X'Z:R&C^=UJ'F"TP`BP3S"RQ4+BVEW.J=B/[[6D/$;P-8IJ"$< M6*]_.V]?T+%3=9`A0/O=.:O;"K-W60Z!3[[L7`M'YB"S6.*V#QUHH(9Y`YNA MZ4=B4Q07@D`N!FQ=&-(/6Z3Y6D\Q/QC-%I_(%:!<)F// MDG>^^4Z^RE`[Q8[J^?(%`VB<&8*-S`Q=5)YQE`D!F#EQSI6#1DE#&G;P31M> M:'CBDQC>4_6N]DJ?]>E"^E0N9`_-,^57(\4Z-JN4X,$1T$IEJ\T>72GZR>A# MHE0IXQC=BB)>8GC)"W'TU/#QT8OSN[2HJ'7^.&F<6Q0'&!_$.6GCJ_9)Y\+R M*A,"12]C:@8&]')Q80S3HE&(A<586N8)G7B#>/;)5$-1K4B[%;AIH:8:&GF& M#&1HP(,ANQ#MM!K=K%)JL)Q1?#F*,D.R"E6N=.&Y%\%S+RZ54@X1]F4G549J MI/1Q!YYRQ6/ER(D>*H8SBEG`KJ3BJ\Q`S=>KIV!J&'EXNJ!X$O-N,8LG\R$D M5$U-O,4Z$V]AFW@7;.+A;+M8,MM.\V>;)>"0.=N,<:XUW=Z:$VZ1,^&^D=3& M&;9$<+?;^:([/?J4PKZ!X!9'^NO*;H:01_(7*1FJT5E-$>Y-#9G#&SEN)K=*!6VP6QZDOD!.FH+"3 M,D=IIV]REI(G5FS`\]5R01O>TD4FM:\"@94T'&#[Z)S)G4;3BK+F@8P^_ZJ- M@ZWU'4C9D0"[Q&ND[$JG%[)4#@5&4<\-3X8]Y`BF6%Z2O<4K5]:KY3S0Y[A%.J=]>#S9W];#GIC[KD M?9CSGH@"T9(*F#^2<%5EQKGG58KB,3JJ;N?'4>3^*F2'D'MP0CDZ.FH(6.G# M2ELV'$U]HR_Z.9/HMG!YM0U+'@\(IU?;>6W*ITJ41[]8C>'-([647D>>\7$? MT?^?32DS)3.3>G6!M`@WY\R.\DTYX4;KW07><)A73-*AR5(51< M4GTY8$\ZBWAQGES6(%0PWPD4;KBT:[Y787OQ?B%=56=Q/#V:SJC1?*#JKL?S M)%7548:':2U*12-Z[V8)CWLLCN79?*GK\V6DS9?1BOGRZE1GCI=M@29?>CMK M4V1+FQ!^(8(M)]G%+6TN6.:)Q5D[K^E2?A7E96[:!F.;\/2%SM!I^\+B(&CP M\BB/E]L97FX;O$R,SU:*J5$2A,@V6QHC;^?M*$CG-2H*3$F@F+I2D&22'#KT M!(?F,ER:GVJ,MZ_/58GD#QM+Y"0;A5U*#**;0:`A47/-4*+9!"*8AFZWKM.7 M=K8O(]67]O*^C);TQ68?K^@0$),?T][@SKGJF'4!+1@7[-(]M'4@W.G0Z\0YHI]RP6[B(9[#O,-/] MA^7I]_Z^EBS]9OJ>^Z>!;+3'(,*T!K"*&%&(8!THE6*O%WOKA>]+)AB=&8<` MASD/=YN=[65#&DI$LE@58.$D\_&4'P*:@Z;*/M\.HM^ZL/QUCYA1OPWK-*R) M]V1[&Q>,)AS986T__PQ!^*G*1__=D2YPN'P1YH1%6B>U^JO6FDTR&+Q@2K`Z MY2U%]>)$K&QS6W4REF)V@Z&$?0P*VZMV6/0-%J!B7A/I\V]GF_AX[&:)\Y[OYQ/^VI M9+!0EJ9:?[H?1C%P-N^78A6(5WI^^JJ`"A_[2`S,1I=7U)*DHQXGPP4$WQIA M@,X>5?U MKP5I1S)>1Z;PPQWU/5`L3E7)T8)J7Q"T)U%17MADAH>W>BEX0(&,O@&C:W#KNITL(/@EGXRKL8D5-DY?GUPT3W\[L4H# M1BUVJKZYK&F?9$1-.!QN1#&*^_PIFSMC'YYB%D1LPK4F)CQG3'B'RT17JOEL M;$BQG86!C.)%S,)"TA^+Y/KFD$7=XY$+06&))XO1)XJ9I/]>*(LL'.Y\CY!M M:OS.X:;X=0\4`*H)XFD254R^I[PXFU'I3TO10I_@'2X=,:$2[O**7-Z"%\)P M-KTFS$<\C-D+:H"WQHG M6.S$66W&X?H^6HSHDO:_S-V9$J=]VD5G!O1W_CA:7.$+0`Y31P$S$`!,-@8+ M3XG@*B2?_<")2M64(PBZ`,*5)Q[WR$^[NZ)@0`[$5]AQ%0F),KHN'#VEG2S8 M*$"H[Q207A9]B$-O6Z"?$:;N`#22_E#KI(^=A,>^30XMK398I]J`[SDB$R'3=-U M5PL\_ASBEOX4%.F_(N/5[2`9QY^V_:#(;7O.(T3O9Y*\7ZN?+)P`A++`2IYK M2@\FAQ9A/3_+H'Y0B#:]SH&O=-R!&P@X/2GKW4SI\CZYS)SXUE]W_K`92ENT MO3EH)OLW_=$^&]^^:&/OBG9GZR3Y2(:C<7*PK.#6KR3:VKI)9LG=WV]H7Y(] M_+Y+>[_7_]_[)9#W`?A25X.2[X=15+T/_:)?OB\.DF$EZOM),:J6*F%YJTG\ M/8]XP;Y7W0]*5%4\"*.#J/K,"PZHO,AKF#SSR*ZW5:*\_O;YO7,63RZ23+%AG`H]V(?2*I7N_Y$7E^[X_\/TX\I.!%T25 M4K35)_71XI)_O8\G[O_3[5_&[O=MF@/TYG[_>78>X7@D/> M.EN*WW.204[T`HO_A52-6@Q+J(W\?SJQ%I?XQ'Y*?% MB/[Y^_QVGNP-DI\+!.K9]RK[GD^-CH/0.RB&Y(!"$<+2%Z`/%,9-H1/A`UT. M(98ROL=_=LGU[7@Q`N=[<%*4EUF8633?XX6,=T(!@6V8>(R"DC8S^#2)KT=] M^N"3@!J.[N!%(LVMH>9JC#MM>YN,SZL>!*6#4(R/KE8P.K@9=7MS`[OFM'X8 M):@8H^OXDFUZHZ:"EN#@-AZS9OFX!%H4P&C.5=0!@=MDY.-5,B'B=.RD28V_ MJ/3[[]V3UF_=9N<,*Z$@L*!0+']*:+U'Q*=S(JA$?G7KE.S./N)_E&V73Y#- M9T';(Y3IMO9_W()`DK#=/YB-/L"4IH/&*X6CV>QV3EY-+T?]_YB3#EIP1[?` M`(2-@_3B.1TI]@ORCLRQJL;TYA,SM;?[.W"D\?_BV70^CC^07S[-Z?)"?F+3 M`&G4_]^?*1#[CT`W*#JH@7U)M3' MS$:]6ZI3CM"FWZ>]OIY24GUB-=&GM%<)&PK5ZZ[G[(PB(2].7I,7$/:'4O/L MMC<>]$ M53:ZOAF/:-UT=%3<+#[10;`ZCEOGC9<4J%9OOVI?_$$'0X[:%R>M3H<OSL]-.BVK&G01U4%;%$G0/D684H72*QZ/Q7"'@#TKH M.>WC>$"NX@^)N(XQH'IVG[+7:E*R:F(,!\]57X52JO`,064H\%MA7,(91&85 M*$H72'O2WRN08I5<)'C9Z`QB!E-=[!:J"$./FK+3^0)*'M<(70)\W]_U0Z], M7G=J;&"@%;/Y!E)IE[ZJ)Q/*!9T_X;83B)@>_/[[%?UY/>V-QJ/%)Q#['/1O M=+$931(5(1S=YSJ8+B?S$@_<6QU"%P$3$KSMV!YSI_W?+>-0G^EG9?K_UZ\, MF-3FM`[(8,(LC/`FMK3$82JKVA&;X`K&6]Z.#B!@?`N,PD$*@L,$'$9A[KJ6!7=1;_V6# M+2M8501@N:>*_N[$A+>]S(&4@'[>2P"TO51MMI0/@N\^#D_9"\#&A-`\8UY8=1@QD@KAW[%770L-@O2S')?="!43B@R$D5E?C62K*B%<9. M:,]2!9DJRF(/1F,I&0.7I#YX)%B3Y?**L7(M6:Z^K%REQ3D<+S_PWB1&?_3P M.6GXLJ[&CS$BUVTFRF)\1">:-1U',MX[4K!%F MFBX0[%N1F!Y>*V:[/\J+1=:^91HM<@7@BB[8,^4>@#,K-;VE(Z8Y`>JUC,"3 MQ\YZL7I&WEF+-:S+3^>L;C3J-7F_V;:G,?4M7J(`,D@U;[RV%&@O*<`C>AF8 M@,L5.KXP7E>J0*S7H,)TJ0(:J]3@AFBMW[^]/KL:J1)*HZ;HF]_V7E$3[&PQ M4P6J>H'A[:3?`L<16<2[J^F\W9C.SI+9"VJWJ!H"O0!MG!H8LU)[L@A*1[.X MCXA`W/>GDZ&.>,.GE?BR$.RJF"3*"[]'4A\0KT5?E];K@NES,^WL&P9I`-4: M?H)6@Q5S0BKU1!5K-@J9]GG-`&Q8T2=#CTY,,H`*M6$"; MQ[4NU91?GNJS.@U:\6S$`5!^T&D'#?A@+1VFHJEVW#UY?=SMO&P?I9OV2Q;, M4E,46@0+T`(41(Q[3V&SC)HT>(MW!$>\(BE@2MM(G>PROUY=XAD^0X3S:"55 M@*Y_QVU>!`JTTC70`DU1!10XLA2@>M/%ZPX6@'L0V0+\6)07J&8+H.2[..<% M:I91B#:P0,-20+2!!9JV`IW7OQ+>2:K/+3WQ0.>V\:BWUU_SY$,!N)Z`J!J, M#?:B=U^LEL/HOE0L]_TXJI3CL#(,@Z+])*3H_:N?A&B8_(7@T)=M^&JESTD& M1=_T9,2)@)D3DC4(Z(>5\)]_1!(>%/V#H,*/$-@!!9ZJ4W0PGR=`R)YVP'`] MFL_!#8!G@X8]3^9;RK)&;W2"\7A"\Q:=]>M+M;OUM-.F/;P<)^8E-5';@N7?UL_8F MGE_OCZ;F,US&]]$UQO:"SG?KXVO;4W#3LCV?C^.>^9SUL4_I;G^.[F2V5Y`J MU0J",@G>O%7OGG*O'A!.5T^UY^IP^2DM+PX:V,D%Z9JITA?D'_FA0-3]$=-M M[W#K,TE59FW M>1=V>?)65F0!Z\@>^R$RY:KK4]F2$UZ4_$R\`O-#$IYNXE*8WC;X_I$??C`[ M]).E!Z)><3F+AY?*Z^D;O4(],ZXOPU*M;-*2NI;E=5ZC)%RFT>J7N7HR#8N\ MMG8D0HI7:XNJQ*Z9+W95OWY>TMQ&P\NOAGNA?4XQNN;N:TX)S/RT#1R"/R6K MXY<"D2_8917DN[LRT@!J($.@H6#ZL?SA9SE!:UJYBJNI@S,TS\+_>GX,)W[?!K+/H<[D1A)`1;\\(; M\@FO%KY_WK*7A63TY&D!N&Z\C7GER;;>9?K[SQWS,MK.CIS`^:T+L6+)UO1= M.LI/N@9N+;VA&`1,OJ/]$_>0B:5"A='"TE)\1%I>V66-3Z:3A+;,@]392AK7 M&V5GWTZ,*Y)J$$2[V:B5QBA\LL]ZG>:X%H0C*_C0W)CDAWRB],<7X3$\\^9KM;V8!`8EUT"I1O(7/;E\@I&/J9"'ZUWM,#,[V"<4M"EE+%7EWG_7TUHB8 MX6@V7SP40G2*9!!BD&LI0H!3V486P+#.\9Y1V#T9N-XB5IP0MTY&0)8>1$.> M/FEL)+Y.`U?7,_!Z^;HW5-K'X)4C]O;8+2SSQ&P&C2Q?Q6H]G_S.,/ MR?8/4K'"YP4FXO!>$`_ZSL?!%C86+Y-0-4M)L\QM%QQ:6LLP#EWYA4^MH'75 MT^(!:46M:QN[FZ*ZJ^_(;MSK',UB]2B6S=L5HUK&FL8H.65L:X\*R8&$IBL0 M)S6%I[@._@DLZLS_)ZU8I MR6#:VELB"I[VCMN_$QB77F1;-`ND5N5WY(K*(]LF=&U+11CHQY,%W]T@L;J? M1T8-9*>;H`,PAKEZIA8ZG1F-*1#F; M'AF20UV6G0ZY$6!]+80PW]S(5BZPC`P%NQAJ:X$]VC4NQ2UIZ6=5D;X_D=.PP[4BFV:J_?K%%6.!F M7B[?!LB*I2S;D>T5XDAIOP`+>Q!L(!MOJ)B5I'=6WNKW'`>#[:=+>WV`QSP@ M"[Z?2RMI;FP?/)$;0K<3X4&1'LBA7`[$([D2B!JTJ<@*R#FHZ4CO\=!)ELE? M%K`=T1N-!M_"(,ONG!$1H2B?EJM6%C$6.!"!6N1-;E8:U(5X-A!(@S4#7V"# M[$;_3'NYI>U1*(JH71%ICFW+.$AB4")]!FV-#=#L08$8+,(#"#_A\U'OSLZ. MN0_S1%+^.7E_C4?`VWS/)X4VNLJ].#KKPA7=UBNI.VO;=IP\J3>2"U"&B*OL M4(9O(,#Y!JADSPD5`>>_=MLG1Z?H[0)!Y2]:OU\<:H7U6:5M2>I%KD&GII5U MVT?GK1?D'KZ=OWYQRK[]]KIS;NO$'G@.[L%V6!>CX#TG13\XM)?6V M2LX$W=)CT5W"*2,+[)^9X/VK>$;+,U;$L'3L<`ARMF+8!KI@I>.,:I_,:8_: M;UH"E=-II0HO@<73(`J+JE<7CL"^0!+EBS>F)^5M'2W;:19R.JOF"8%MYE:0 MT0&&(QZ1`&<,'H^+L_&/$-X(PQ;P.T9/!)'>&.;,.SI:RE#9MFV62U:ME*78 M#J'6A.Y+^X[\\)S%R#H"E\3#927OGQ/+#J3<@)1KK(HA@#P+ZRDHX#]]/_\9 M5E6UF,[S,B&*>(O(R9*%@7UW>'X/BS)N-;37-,A%C1D#3CT0E1D!\]0/S'_! M8E28)J_8:K]F[M!IMALIG3?^W- M+5::;ZRM,Q@]U\O:XUEC9\YI/-E-T,,EVX1>5E)NO@OV`#M@?^F])(F-S;:* M4"):E8NWV>T!FYV@-A14_!:D9[ZMJ#+]Y+4M*F)*$I_0T-D\-2>[$'Q%98=] M>"5*C/-#MQ5@7Z+S+-5\EJA@2!MC\Z"'#.*:,SO6YL_R*6_7!0JZ?HJ#TPB00N[AAIR731^>&Q1N MB& ML)G_NO9I2\/9]?Q5,ERT)R]FT]N;%*R7A6VPT'"CZ416@)"ODLGEXDJ#+V'< M3]GA"0"?);.CV?5_^44L]YF=J*"O08X6JK$@C_Y]@:1C:H&G2+H"%#LYY2M_5C(SJ;\^0Z)B@,(`U881<_W(!O-3V7#*E)1Y5ZI1T^M6U M9C,0G^=WSOZ[SF2VCPH2?YS.%[/K\WEC.AF.+L4T7E&\?CN$FY58V*"JHB@4 MAKB^)YVK$6T&'59X[TU&,7HOY=4NAOA@/(5.&E3=A#M![.0' M`D9B=`\V^[C*VH8H M$*88H"HUM;1@>I`"-"E-9I0:8$ILEC<(V\V*CBSIA)$CYC4'8R+DD+"K`1"+ MFL1D0&?@`'PL"G`GA#_L?8+MD57B1GUTJ6%(H!,H^1S>4.WT&JY$\0UX!,-] M`YZ^'B+EAT035B?0W/.G3_%-E)%:GEUBZCWY3_HY2,FK0ZH`DSG\1&%$!ZQW MJ)?T8XH%`A6PFU^P;?V)4$+W1NQB.72BPJ\6YS$S[<1__F=__)'T/_8OZ13> M`TZ\HICU-.'V`))-93')E6U:^L_U1-L7Z3"0M1@PQO2K/-DF=I%62X4\T;2V M^<@$RX?1;'$;C[NUU@$GCO,_8#;XQC-&>X:B61'=.7NG/$?"`J7>O9G=()!M/(/\6R$ M*0,.9+6UQ@&KOG8[&$T)QK2@0DQA@OBW5<7KUHGS6T5((U:Q81UVB_M0G*#.>:;*E") MLUB,DUT0Q/'$K*W2Y;5UVB].6J(VWZBM8E3&3BML?3H^,?L4V/H$";+6Z!&M MR^A1:.D1JRJ_/W14]?8+U9]H&8YZHTMK=^30C*I*^4/+JTAB^O6),;(JJ\J" M:7$RE(.?5#V]3#VL/T8M_TE.\3IF?WK=&TWPXMZ"-UP_E_= M1M"MO6ZV\0#VU];YA8R!E^%.5;Y!S<.3=(P)C4FSY2L0TH**;CHNL[QO+P]A M,P!$B[RA,5RV/"5;NW8BQJ"5C^SE&5HMY2M87O01`5]2\4`UC"%DBCO`7Z3. MA,79U:4VLGPCIA_F6^-U:X8A,LA51S0T"4RZO"$O@ MJ.:T:UZUA,J7Z)Y>:[-%IPRMDZY=LD9>*ZR%O,[ML\8Q$_(4^SO0`JR56'^F M1BV@UWFC>_2J]H+5C/I+M@.J.'9%EC>*^\4<2U;UM@F]06ULUS\@-Z/^>TI; M,%DH==0[J8S]O]&UJ'S_1U%-'5-;47::QZ,!O]T\)Q_Q&#<1%X(!>CZ"6_P9 M>%I()#6@J]8$CD!'$[QP?3WZ7XA90!6L#`K4G'Z6>@X3I?9*$/ZL??+B[/0$ ML,-30X&R@8Z8L]GMS8)L4Z'D[4"++]N=+C[D59Y`U&C!$Q&S;%B7R[RO!C%`^W-C"[9XT_BEK\GJLPH2=8J]:E/ MMME`T@S<:795J%(>)C_%P5P,:Y.#(HBJ&6S[DQPGU]/9)U&MQ>JQ](Q"(8"%QYW=SARFSWX2I%UBU>$F=9Z*O.(?1'O@.X#X M%MWA6SFVJF?"XI2.7QAV@E4DV'0V9RB[W".8_B$&\PI7X1X(Y_/D?_8&\4Q0[G.`@`!]Q)U0:*Y%F"D64A MRA#/+L6;Y3$N^"8">\;Y4>RKBBF*78Y!;QAPQ9)\F(YOKV5B&G[)A)^*\#^9 M)UOH3/;9O%>-)_7Q^'(Z&RVNKLVS.6L!LNIP\"E44'OUXI0NNB^/GW*3':SV M],F@](Y9QX1/OG,^O!9>0PMWIYW/^IAI\T'V,G`G@U:XR0ZK@,&X&VX;(%_K(/SMU]FRP'TQ M#>WTG?Z3;^>"#1*PY/3]"AZVW!7I1^P+9C8*89,TA7J_8*MG@_U8E*6J)3N9 MLMAD$,M59!M(Q2ML6]N`^^G4@OB1KB<[\A`9CE2Y"TN!&&Y`ZLQXG_N!%U`\ M4SKU5JTHV6B1%LS*O66*2J>+%:FL*& MZ.LS:N8H2;I"D-H:75>`RM:^OO#4IX===+*!K"LRO_`4^WITUX5;S`\F,Z'" MOY3DRZU9[+H2HB.!ON(>!_!4WW>E$Q#L+(*'4_P!9&@C1'L0X(,T$L3;$-]Z MXBX_;MY!19-Z$MG]6+:G3(=_H'.=N!C MG>'T&49;PXT'NBYMI[F0*RNV,]XMY0_`7`N,_TR_().1!9!]VV+M;0E1S2:; M">E61>SL9T9_UME%0$\$UGY:,ML$\Q90R-1XA=KL"_^C+:4%63-81N M:KY9C\%HE!;KCZ[E/9J'$*0@,[%JC1J>.ZB_)NA& M[P)_(/I6L;2/ MMF(1YZ=618'MD;DX)56L`]?=CTPKT$).N8%N*&=DJ6'H+ADR],Z(!CV1S+<2 M"K`!-J<]C\?*I6>E7-A0*?315A&?;:EQ/Z1C:M8HG%SA=XPM37G=JS M!#*KC>&JS.T84P-`ZB1U<@X8#N*XEW*2A587Q-^'?1MI0#`I8VFIR4)XP_G6 M[02=5I#T_O+/.$FTG M!F`Q+CUWP^A13-TNIAC@%E(G$(2?32?@:;&EN=_RZ.HWL^G@M@^T40?3O-]8 M,^T5G$Y.II1:>-\(O0\I3:@Z-[Y-"C+._2"Y@`.8&2&=U07 M?2(XVJ_DJRF,[RB-U6$DG&S&-[2S=R0,WI/I33)C_@N:E[!VQ2I;W:_&Z>,< M'5(XH>,%/\('=\IL?9O[$&<6B+1\R"P.F+6.3K"+WV&#?-V%X0NWCU6O9H]+ M@_'Y\J5AEET:9JFE8<@M&GUI6+4R%/T@LS*4(JS&[_][K@Q?+K+MUTNR`CPK ML,.ENUV:U)9T62:UB7*[D!4L%=WR\(P+\1$*\7^RY%8HR1.\V@83MR:_5,%. M3Z)<^7G^+>6GN/8XF4YOOH[\9%4_G!B47?VKRU)@HC1ZZ=OT(\W:1&\P.``& M0;!'R'\GLZEP7[38HKH5BB?X-L@5]]-,\U0\4K)C"XZPLP34=#>]"OQ'CDR: ML@^@?:2QEID]6B;9;V*3SF]&TRYNUC_TM/G:EX:6L*LY*/"E,1Z(=5_?G<=3 M9$P*S!UF@P/]EW]HL8T4#%SK6:-(<*B6Y/R6(Z/E<'6U:Q2)EK<,1'VA*'&D:JQ@90#*K$7YU1;SR:7.(MS&7]@"58 M`K'X7K"@ZHUQ;YI^K+I^@XLW2M8^5"!IU=Y?C[2*L]E+47M:>1?%K2GA;ET[+VM"2?5K2G M9?E4>M.L-_BCQ=V:,AO=RN$& M/(J&]%-@?QY&(*48)R.1CFLOV@W4*3;9Z[:(I>7A0*D)..@B\43PXFSBMCS0 MV?3ZJ]P'IF!0-X[FXQ4DZMTH04,F.GD:3H^-S!PF#T6T57N>".;QF(-8O)^M MO,(UUGL#::O`*^*L<=R%A),GK5>==TQ$4#VWY+'IP.0`Y<\B?Q#(!Q7V(!0/ M!$@D'_`21?&@S$N4Y`->HBP>5'B)BGS`2U3%@ZKHF">?\"*^[&M-E)&=K8DR MLK=U449VMR[*R/XV1!G9X88H(WO<%&5DEYNBC.QS2^!.]KG%RP2RST>BC.SS MD2@C^AQXHDPDGX@RHL^!+\J4Y!-11O0Y"$29BGPBRH@^!R$O$WKRB2"XZ',0 MB3+8Y\^')M^!0RTW3VQ\!\Y0)^>2XX(BNJ_0+R7QI2R^((4)?JVIKW7VU=9L MQKD[M]62)QH37RKB2U5\J8DOP#.L/9A3,IJ'*2/LI]+BCF!&?F&7V24>V(TI ML(Q35)?0XE!_!4$VZW.-`.7-C^R\%T/!Y.DVM(`1(A;U0+%R*/Q"+*_:<>O= M(Z7%+H8:>>A%PH,0#Y)A?#N6%Y=P M7VLT)U$$NYTB)NUW&IYW=*33MK&D"&D\3^)9_XJ=2\C0)8R8`P+.Z#++!B:4 MIN,W&OYQGR??&V&./`*I#&S25L\`LJVA"3!![N\5D;CGO,R"\)9I!_R:JKQ_ M*N-#L4JA"_WXAJX+_.0#/?)Q"W@'STI&DUN6^43YZFNL.G\S>K<'5\<^)-QG MG^&0=TI&HD]!&&A]3@R4\T#DDO?L%;#7+/SXLA):+C>*F$-9MY&BP@H[GB[2 MR9Y@;"D2\/[J_#LZY/J5N%5A!5EUMV$R94FV*2\(VHE+#3(OB9ZV(\T'V,B2 MB:U/4X.Z$U'3S\^)*1`SMS*L':=]NX84VC`%A(R9OYU\QR]DZ)WG`6_WF1)' M8IY6'$(0(2_FS0_6'2W?AW:/A'4>R0>T!'QX.E,95!(76S)`F"2$?GIT/K_7 M0MJG=#-9WW8<=,3T7U\G5C$GB4%0 MP=9F;3@*7:Z2)>&4,Z&+TPUDM6YF):P%B1QM$PE(B8[L09EIR1Y^_3[^=NG/#ZWBM*JI-&J>XN& MI22/;W*T'-G%=V;1K&9B*PDF^AW5KL@N_4M5%!'3``(W\^UK+,<*/=/9]4<> ME=EL-F.@T>`,]I5>5/+(A@T9,^3!6):6RHX MLEE'"OH:POMI2#,0_GQ.LC'Q:`[LQC3*66;_L(-,Q)^ISH!EI9:=#6:2-I'2 MTB,[RVU682H55;9?>;/1VH1V^V[-6?B97;1BN]SK3$6*S'-F3/+)*)=`E:!U MZ5R$5<\Z%X4S8LYD3(=$LTU'.O8<:U?V\IU6%J=9@-,,YI'B$W.>F>J9F&#/ M&&RJ:99IEEBT,V^7&TZB.+.=*!"Y^DC0ZU]_:S*"UDIVVN*LY:A;3P/)3%HY M=&W:9G213:+79Y4O10%31]15Q%6`F@PJ9N'>8*7 M=\O,&91*>;ZZ9Z`5/5>FT"H8II1S368EOGCM\JF`F>A`3('>-""_'@]?-\J4 M%W?6JJ#S1I<8)!M97ZLI%5G?EA$,-B1GTT_+C>PEYKKVZBLD:[9;K5LB\3=; M+[:U/NS^S*AK*)QZ60OM?B9>;G&C:HOAE(;=<)H;U6N3QD^_DSSKI=^D)@^_ MSKVJWYC8T((+?.[`Q];4H]MIYF%45!(H)7^7=)C)Y75;$2I8-HU>MAA,;Y%R MU/[VI[2UQX\0S#2<4J\R329KE>\X(5.*F,PVN6[JQ;QI#W6`XJ)G]*"O>6+S MO_STSDNT]?9KSGIM1R(S(W?,Y?P!)[G#5+-G>5TURSCCY"1@L7*1.A;QX,@SPM3S3/ZE):QBFF1?9$B9 M74BEM%K1A=0"G\*B63Z;_DP<`AZ2S.Q;!4I2>W_[RW-(;2(%MX6IUD M:CN/LGFII;;SZ)!.*)4GISPG.?40`N=O+$(\>7%ZU#V#A"BM!J$V([!'6H^U M[H*LE]5VUF>!N'&#!&2250*HI^C9?7WC%^#?(/WFYFK4GO1GZ<=]F9'F+)G1 M\13,)YVDO]3\I\.3.W%H]U&Y\?TM[`#P;1T,G0T>28WI]U_S`Q*(6>TE^QE4'4PQ>"AS\E@ M]&$T@+E(5>88[,9-L7>0YE3R7'7:4OOMF$6TWL\@B2(7)@[M%+(AMSAJ$.H>Q\IPW*"?#2*9#N?`0LKV=&042<(?\H.6%A0RSVQE\B!([&_;C MC%&LU)XL@A)$XN3]D?-5*>,;+$Z?M[;@:!6BH>W?]$?[K"O[H^O+^7[_8S\J MA=[>%=4CMDZ2CY"?-SE857CK5Q)M;=TDL^3N[S>3Z2+9P^^[5)#O]?_W?@7T M?0"!TJM!R??#J.C?E[QB6+WO1T$_Z/O]?I*4*[TDVFH2?\\C7K#O5?>I-/'# M@S`Z*/K/O.#`\TA>X^291W:]K3H5L3,J5@?SO\>+*[JP[2UF\61.I6^\1R7O M/1GPR\(*J4HJT^J8\6OR0)1$(% M%)']J^EULH\M[_?>[].EX/9NEPT<&R0_%T"_ MHIVM['NTU]6#H'00AN2`0A'88XC@GQ):[Q'Q*>_XU6*ENG5*=FO.2[]]8JNKP@MVVO57[9,7EA*Q M6:(;6!OLI4O1YOQL.;A`E,J4F"X2#6D16W:B=,%B0@O:`E2D"Y8&O,9T0*=T MP6JL"F;?]GK\+8\2FGKOA_">0H;=UN]GV=<0%.NIB!M3_^/L]+<@6ZA:IH7, M`#/I(D.ZR#[MALW\`0=(,UKD[/S5"\"@O5109J68C_>2ZB+>HIX%+UVF#Z-[ M>7YQU#T^/3][V^A[@!/I..:1U\9*R26;2 M>'[8UPHQR<`N<*8+1D5:\.C%.D5+55HT%=`[4P;X^.71BUS90(LDJ2(6\>#Y MB`*C5)Z$H&5#539'2-!"Q4PAFYR@!4N6@C9108M6=3F0SWN>7P6:_PV*0?H: M)5`_'V(:/B:/N9B>,[&ON=4*>0W+(1?6NE]QA.ARZFA=D MZIV`?1V6_&JBGH8%#A=(.$"^"!+F1R(\&%4$?!M2;57W:2]BF-[-0GG M;S2^AF-[+=7>)N/S'>GG*_H%FXS/=Z2?K^@7;#0^1_KYBG[A1N-SI)^OZ!=N M,KY`T6^8I&K&K]6^T0L)I^A7H7#]#)Q7"?L\874UI&,1<(I^U8IM?$FZ%QQN MY?P+[..K.+:WX[T"U?.OYSV'.D7KIQ_ M.>TYTB]<.?_L[46*?GYLM%?A[06I7G`X;?VC<'ZFGYFG'"YRA"LYPBGZX:>0 M_@KRK&_!BZ)?>5CA06N]OE%%6%9P0KY$C17M9;YRN)8;7-&SP?57PVGT"\MA M7Q_)4CA%O\0J=S/8XG`EO9\FYI:VMXI^>7"U57!!:M0$OQ60K<\%F*W/!9*JV"BZWK=*FR`I]Y MXZLYCL]Q_I4VF']Z/\O&_`N#;#\IGPVR?%96](O2F..U#2.AOY1]J;^4=?E9 MD25Z023IX$F]9ZCTGK*BG]\O2;BP*.#\?B+A>L6^A%LU__S>4'![..RK]C3Z M!>6`EXAC.1_\4,Z2:A@KO!CT"_B,J0Y*?0X7),-*G*5?6=$O\DHZ/EE4,B]* MAAZ'2WKE2I'#513]:/?-FC-T+WN):*^BZ%<>^!5.]X"B5L!54KW@<(I^Y6JU M5Y%P8GR:ME`-`HG/BJ)?6!TJS`42KAAX%KQ4%/W*GK%"]C@=/-E>+_`DW2M6 M^9GTXHCC,PQ\H2+T2UY?CD_1KT1[)$H$59]/X:A2ZFEX*0LX3?\,%$>5X$XU M0U'%KR39^5?5[+_(][+TBTPZB/:JFOZI]*75ZV95FW^AE->,\_G3LIQ'?D_2 MKUJRP55]OV^!*Y8E':H5*US1!F?TLV:%JZZ$:UCA!BOA-/KU^VI\Q;Z4+Y&4 M.H.*A*MI]D-_H.`")9>*$LX?*+A`@]/PHL&5)5RQ7Y%PFOY2Z<=5@1<)EU2* M\4#`E23]:HI^I:H&-Q#\F="V!5Q5@U/T2V(%I^19$JOV_%C!*?J5>AI<(MOK MJ?:*&IRB7]+7^AG+]OJJO8$&I^B7#+3V0JF_E!(YN[1UK.YI<*I'?B+QF:C: MBHGDZ[JB7Y*H'E4E7&DHX;R@J-I3]!OVE'PI5F/1WE#U8I#(\=4U^FET]P/! M.J5*J.@>4-;A<(I^@:?D+IU'QB3(S(>ZHE^E-*Q4,GH!Y=H*KZ)7#%4_-?N/ MKC>B1%7*>6`!\12IP^$4_2AS23@,8\'FPW`@X9!K&5Q#FW_#HH1#"<3H[JE^ M#LJRGPU-?GJJGSC3&)Q?4NTI>=90]`M\V4]&8=Z>-FHE/QN*?GJ/_)[4"U1[ M7J#D1,.@GQI)Q=9>L:?Z6;/V,]3ZJ=%OJ/K9T/JI:AY8^QEJ_6Q9^XD2+U.; M/Y3];'JV?@:>[*=16RCYNAE8^UD=6OH9>*J?S*/KI];19HO3=IK;^E7N2[MHD+_?4J'T%U]H` MKJK@6IX-3IM_.EQ1@PNL<*AQ9.!\#4[1KZ+@^N%`M%=.(B&M!O2[T)-;5OMO M4);Z(,!9],^6HI_O2_E9B;R*ET61#J?I+THC[BE[Q:O$=)#/2D M'E(LRO$9[6GT&T1"G]?T.K`.+'!'VOX976U$>VC1\*=]Q2\E28Q-/1L[2GZ#=*:-,=+H$:M[(LU\U4J5G!JOA]I]%,ES*9-ZQSA?,\S MQC=8I<:?`*IKY)\WPJ"_-N&$BS3C?JRHRE",+.N-2J"LUOH"K*_'2"T/. MR[V^+W3QD(KQ),-FOM?4MKT-MA:-A"6QB4#)/HP%W)$2\[1'L=XCU@NM/;4M M[/N^:B^VM5<>AEDD4[AP];:BW.RHR.T0WR_J<'&2@4M,,[4BX,JV]JAI([<' MM^ M,/MC)4SZ#HUX\#WW)L6(SEB8+>GJ*? MG]>>97O0#PSZA:6,>,EP$8>KKN*S'+CZ"K@P?*?DE)+EB#8E%,@E(46-0>*KB5?#&/ MT;,[5$9[2^BGBWGE=R1%O79R6(YC(=+"2.Z@Q96A+NAZHLG6"E$?AKTJ%^05 M7^Y$^_K)(;6=LR(M-@6Y:$\[.0S43E^?:G:"*DG/AE+MY#`*C)U,MK;:G+(D M2(]24J.R*GN@(Y/<^.G+H-.3HKE*626=7;4_,WJJAM"K5-:$49 MA=/F;V13?X9^5?2SU^M'?/O4+ZKY6]$&-1SVRT*9L!U3^\55ZV?&F8/#:>MG MVKV$[+O&+FOS=X+C$+VKTV^"XQ"]:Y^]PT!=F4E%MBNO,753TTS;DXT#R M)_T>QJ(7L8)3]-..+P;#DEBOM6,/7AAY:T^5=2!SBQ;YL:)$J]/UJ4?936]/+0=`7NH[/X M0L?QA:X^B8[CBQS'M])7,P_.<7QVW\DUX!S'Y^S+Z.K3YC@^9Q]!Q_&Y^NR5 M'<=7=AS?2E^X/+A-Q\>O.?WMK'9>.VY=M,[5VJFNJ":7D&(2`ZSH5U398_V. M:J?UXN*/LU:W<]8].S]]0:LLZ)T1WT-(Z:S?G!+WL71XT2%K#9C@(;.BLVM; M9OZ4Z^G@=IRD^\Z>\GX_Y4^?8BW)>"R"N2AZ3C+(^::A"C:G6S96P6JZ@>GZ&*M@[5@%4;D< MK!VJ0'"24ZP"2A@0]]E8!:S6#8(5($!NM`+U=DFX`E;(%J^@@A+[,1C!8S"" MQV`$J=Q*K:`0:Z.BI6TO M4.Z)`J?V`L@<(H/UQ>_6J`9>+]$*G><4&O167-]'^;3L_CX38.8%?@M2B>4> MOQ?8'%V\4'/,B*1?E.G'8SFH*YF."\OWF/KE8DEL!A8#BV.&?H]?O_>JJB@' ML<4Q0]^;"M(]XDU'8C-P$/4JXOZC=H\_*A?[0::],`HM!T3&/?X@M1DH-KHM M;*GHH6T^QVJS>P@3F=4ZC/H66TESZ!E2_41MI_I\4[)I#3]A7ARJ>/!R)AD4;?VH./5'5%R,95"H" MB>7!0/!GOY0(1S5OI4./UEZIJNZKZ`X]BO,UN)3CF,2+YM!#^>0645_:*RQ$MHIU^EM&HOU.Y0 M9R=)H.B@.?3X`WGT#[[2XGS%]_W(TIZB'U#8(G_IVF"9?Z']I#CGN+02B?MW MH7[XX]G\T-/'G7P/57,(2!]]LL+6XTZI;DC!'X7K"WXJ."NBX[J'3EHDL=K* M93][NN9I'CIE8\%0"VK@6Q`%PFH=KWUA29).A4)<:M@G^0!/+BKN:A4S$% ME0A\H,10$H(:R.&.;`N&-K[,,L(WQ36!FEY26!7]2$SDT%,7(#0/G>$@%BIH M/PA]$??>$N^UI[<3\+%_:EX!_VP7&`PX4V?JDJ_LPLRQS.ZF&U>L$H ME]T6#,V;9=,%X]18,#3W%GW!T!$L%XQ^&,@;29I[BV<5_&%LO1%?/K(+\'"% M`-?<6_I*@`^2H9@@%5-0R1OQX0I!I>%:UZ@T]Y:,[L0GI"&&9'N*H!G=B3-> M2E_BYMT1Q54X0I?F5^C:7 M;*]J=3E?/4$T]Y:-)DBUZ#)!S.T7.4FJ&E%C64,ODCY9$=5RA-2#*VZB$]HJ M&06]X3*B1A5U3;"ZZAZ!^364<+K:6A87L8<]&;.C7!X*#Z@DI@N^@#O2QM<7 M>L(@]*53>'I3A\'5-*(J__Q^V1?:IA])D9*4/$G4FG:/H!AYV9D8%*5HB#UU M;;VF$3628@*NDO`%+"H59>_IZB28O:;H5Z)*KV6;*3*T32'D:HI^2;DG5LG! ML%R1[F?&JBSA-)^STM`2WB(*2[*?Q:J.@5Q7M)<5^+,,.K)I_I5)% M:@]A(.E>U[0GPYAQ1?= MA*?]+#JUZ`'%)/*%^[FZCN$'1>G,KDTC+7J`-HUZ$%:(H\7<^RL)."WZ@YI& M<5^N^6$RM!E#6O0`;RBEO-^743&*NA.\(KL6/:"G33]U*SCM*"G@M-NO/3E! M*ZJ?E-*5['4X/7I`$=1LO4<,KA<*^B75:F7`X;3H`26U#VSG.#H1I;&N10_0 MS$'[+@JPIX33=LV5<:G!5;3VM.F@10_HIR<,PZ=ZJN.EF1,]5>(E4QN'TW;- M4S4O=6G-.N7P@UAGKQR_5RJ8YR%K^=.PXAF'&GRL>]0$TJ/&.#$6+C4^=ZDQ M1['4IT8>3Z]TJNF-)E=Q__W:;C6RO*MCC:S`=-$([X,@C$KW?I!42UZ?BK%P M4`X\/\>U)OQ7=ZU1>/R%X,B7N42HPN)U)/)I-/D!)>>-6&=R'6WT]TM<;40Q:W(0:@6OZ0W`2A[77K0;G9/34ZM/A1>B/\VR@W7> MFV5'ZZ+#VN$Z3R\/G0`(PO?7>O(63Z^O]G^]OKB1WR^!\0RPO@9F;IS[XE*- M4LB388^#!1H8G3@6.XSJ_&;X#0`+-;!AORKK#4.Q%U,LW MH@:IC20`*VI@E4&Q+,YLHZ#*%8-246YQ)G%(U4L`*VE@U5)?WBXOR0TC/Y9* M+F"RB&!E#H`K*J!]=7NVZ`O-2NX M728O0X&A@>3V=#8)*Y9>^L:U=[_,X/P4P;/Q73+7K!%.9Q0=%4NN#R*X-P17L_EWU%.&26S31+*7:5ZF5SW*NNGEN.E755+#IY63>!^>GA?HF(T M*@UZQ:)?&53+_ZYZI4`A50I@V,OT`%'TG*1Q\TU5RHVIYJ)/4KR7'S7*#;++ M%8JR0I;&@7R,DN:2>S'+'./6>8>L\P]9IE[S#*WNKW'+'/_ MU[/,>8]9YC2\/&:9L\,]9IE[S#)G+?R892X=V%KRV6.6N8?+,A?:L[?I6>;2 M^>1$YVR^QQ6[_,1\7KD(%]S2RS&7RR>'73`XY#J?;#[8L&)F@MAQ.R[*3 MSB?':DOGD./NR;K]E\HGQVI+YY#C<*NR1&1RR'$X/`R.>0XG)YE+I5/CGU-YY#C M[LF:GVHZGQR'2^60XW"!!I?*)\>8.9U#CL/I6>92^>087Z=SR'$X1;],/CGV M-)U#CL/I6>92^>18>^D<>0XW!ZEKE4/CGV-)U#CL,I^F7R MR7&X5`XY[I^L99E+YY/C3U,YY#B20XW`:_=+YY%AMZ1QR'$[/ M,I?*)\?D1#J''(=;M?YE0R?N*9?'(,+IU#+N,GGLDGE^F%KV5],[*4F?GD M!/W,''(9/_%,/KE,/T.MG]8L92R?7*:V@=;/AK6?H;6?OC7+7":?7+J?+(=< MQD\\DT\NBV4MZUM@ZR?+)Y?%IY)+33O]!M9^^EH_2]9^5D,U_U(YY#)^XIE\ MAI9EKK]1MCA-_]PH6YP95G_];'&KZ)>7+:ZFT6&3;'':_-L@6YR196ZC M;'&K(M7F98O3YM]&V>)T^FV0+4[/LK))MKA567+RLL6IVW&;98O3,G)LE"U. MW8[;*%N<%I2JLE&VN)59KG*RQ1FY,BQ!R08YV>*LMQO7R!:GZ!=OE"U.N]VX M4;8X[;RX+2@8IMD;POTV^&;9&]3]-LL>YL6PVBC[&U+Z*>+75OV-DWS M62=!F5EDA>G,2E&DGA_8$965[]C;MY'"C[&W:R>'FV=NTH%9VY$0YV=M\ M-^1H,:SLR*GD9&\KVI"CLT).]C8MJ-Q&V=L<,UI%JS):Y61OBZSR5\>+/7N; MGF5NH^QMFOS=*'N;1K^-LK=9Y^\:V=L4_3;+WJ;HMU'V-BV&U4;9V[085JGD MT2+8I3U[6W%5EL^**25E]C9M_GUQ]K;0C=?UN%967M\@>YLU=N`:V=LJMNG] M9=G;C)/+#1*8Z2>7&V1ORTE':+'N;DBF;96_3XJIM ME+U-"S2Z4?:V55GF\K*WZ3;5!MG;M#!<&V5OT\)PN61O8R[0_RKIV\!?/@OW MKYR^+?`\I47A19DL7'9\%?9-V[+@7TL:W%\B?5L5AR7I5[;0+S=]&T=&Q:Q- MP@FGTF&`4ES&1@LL_?0]%2CO*Z9O8_P9AA#1LR^<"Z7)5;+!53PV0OTK@Q-. MEU2U-,8GQ;'O1;9^/FCZMI[Z.O#P3A6.+ZI0(23@Q/BB2JIF7]%/JD?TP^$> MT[?EP/VKI6\KE6*/1V\LP>&HU!RJ017X!?[@5PYG'U\Y+,I]AY*U/3X^J$HO M+*OP^5=XB04X'!]?'(5^3)7%PLJO#,[N]+4:+Q5'^E56T@]O28JGDJQ.'*]*/A77*TGE$.?\8<-@C8/&TE,LX\902-;[0'%^OIVJK"C@Y M/H6,:(WQU3<8'\R>K'-,>GQ%;"1O?,K)I13)\?6-\?G"$M+')YU5RJKF=<;7 M<)Q_#4?^;*PQ_XIJ+U$Z'S1L\E,.51M?:OX93AFJ$<3`LGXV'/XCAS'M_*0/0_.;7RK#[WSX-S&YSNF[_8=[3_? MT?[S'>T_WS%]M^^8OMMWM/]\1_O/=TS?[3NF[_8=TW?[CO:?[YB^VW=,W^T[ MIN_V'>T_WS%]M^]XFT_WQ'^\]WM/]\1_O/=TS? M[3NF[_8=TW?[&Z?O%CNKCN-SM/_\U?9?#ISC^-:P_^QPCN.K.HZOZCB^FN/X M:H[CJSF.K^8XOKKC^.J.XUMYR2$/SG%\CO:?[VC_^:OMOQPXQ_$U'V_HJ/]5W2T_XJ.]E_1T?XK.MI_14?[K^AH_Q4=[;^BH_U7=+3_BH[V7]'1 M_BLZVG]%1_NOZ&C_%1WMOZ*C_5=TM/^*CO9?T='^*SK:?T5'^Z_H:/\5'>V_ MHJ/]5W2T_XJ.]E_1T?XK.MI_14?[K^AH_Q4=[;^BH_U7=+3_BH[V7]'1_BLZ MVG]%1_NOZ&C_%1WMOZ*C_5=TM/^*CO9?T='^*SK:?T5'^Z_H:/^5A/T'\=9X M1#89R2WS58>+%)R]L#4N7$G8?UH)C.E6"C&>57ZHA4:*!)PY/A9I$&-I M!:GQE4J)5_)%/Z7]Y],U9H-^^MGQ:4'D/(QRB='IS'AR)6'_;1B'KB3LOTWA MA/VW,5SD".-2.%G#9^;<6W<,L?ZX'UU@&9_!G!!EO>23A MDF[_!641_U,$.>0L;IFWTOXK52B[L[P.RUF/61>M\>03R>7Q],T[^XN''[7#_ MRN''UX%S'-]?(OSX.G".XW/$H?GB.ZL=?,/QX#ISC^!S5CP<*/[X!G./X'+>?/?/M<(_AQW/@'L./V^$>PX_;X1[#CUOA'L./Y\`] MAA^WPSV&'[?#/88?M\$]AA_/@WL,/VZ'>PP_;H=[##]NA7L,/YX#]QA^W`[W M&'[<#O<8?MP*]QA^/`?N,?RX'>XQ_+@=[C'\N!7N,?QX#MQC^'$[W&/X<3O< M8_AQ*]QC^/$PX_;X1[#C]OA'L./6^$>PX_GP#V&'[?#/88?M\,]AA^WPCV&'\^! M>PP_;H=[##]NAWL,/VZ%>PP_G@/W&'[<#O<8?MP.]QA^W`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`KEN[]DA>5[_O^P/?CR$\&7A!52M%6G]1'BU^2 MA#:%."+[5]/K9!];WN^]WQ^/)K=WNVS@'Z>S]_LK4?@+P6%OG:W&]CE)X^9W MRIN5P-_:W?"S]4VHYCM0+2I]#;(U*.$NXO?Q_&I$VA_C$?EI,:)__CZ_G2=[ M@^3G`H%Z]KW*OD<[73T(2@=A2`XH%"'Q8)`,R.(J(?/;FYOI;$&F0S*ADV6UTHM+OOW=/6K]UFYTSK(2"S),%Q0OYE-!ZCXA/62?T M2Y7RUBG9G7W$_RAEU^"CS;FE[9&H!"O&93))9O&"]GLXFUX36>F4#JUY2DY. M+\CQ:;-]]`=;%?XV&DX&R="020@`,FGK;_35:)+DO%4K"HK!+A5VLT],H+)" M7#QJ"PH5U$40TD]/?VV=OZK]46^]:)_4FLWS5J?S%!G MIV=8(M1+^$-:XF^-TR8N=*H&M@:*CO`.SMF0>:=OPT#U%)B!=Q-674_;/2WW MACV^OO:B).)?RWVO4F%?^U[)+Q>*II!_2Y@NM7/=DCV5Y4*@=%45L<10).:2/%8=FLF:D2 M@\@+^*B#1+57DW#A(/(KY'P754,`I+:94+,D>Q:&7L*_54M_S M.5QI6`T$7$O!Q<5*S$H,2UY%H#881F$6+]KN<%P)8P/C;-1)R<06APM6:%O] MV!=P@S[](>`TK3#LQ7W>SUX@6*`<5JS]5/0;5,IAMI]`]]C23XU^Y:B2I9_V M-2EZ%4%WOV8;7](#SF#T*T>"#DE4K@@Z&+O8Y3#*T-WW)+?'I4I%]E/1CQ)0 MSIARL0]Z*I21D]>8G%D=E4L49QW5"Y.".=_7T@Q9\8QFB(]US5`JAH;D$XJA MSQ5#4%N@A' MY:!T/QQX5!'PRT&4^'%0+:ZC<60JK09%OQA50_^>3F*_B&I%,:U61,%*M8)J M%=$_7ZNH'D05KE4,1W=8>52X6_S$G\8=X-`:EA,1SPGERBOW: MX[4Q52A73Z$57<>S][0(K2"YHQ08`2?&8P'/!JT->&Z.&+2GQ6PTH$![5+N) MZ!*0K]QHO.*@T30K)-QJ4T$>;.7K781TXD_D/_[X#U"[*+Y)C'H$[IH*HKJ%:"`JD=-\NERG[% M]WT]*_H[Z3_?GY[_3RI]LK!<)AL +_?\!8X.-U#:R!``` ` end