From 7b42176a2969bc913cd2949e7edd935466745b11 Mon Sep 17 00:00:00 2001 From: Markus Pietrek Date: Wed, 4 Aug 2010 15:59:50 +0900 Subject: sound/soc/sh/siu: Fixed undefined dma_length of scatter gather list Without this patch, an undefined/random sg->dma_length is used and the sound will be played/captured wrongly. Signed-off-by: Markus Pietrek Signed-off-by: Paul Mundt --- sound/soc/sh/siu_pcm.c | 2 ++ 1 file changed, 2 insertions(+) (limited to 'sound') diff --git a/sound/soc/sh/siu_pcm.c b/sound/soc/sh/siu_pcm.c index 36170be..b0ccd0b 100644 --- a/sound/soc/sh/siu_pcm.c +++ b/sound/soc/sh/siu_pcm.c @@ -127,6 +127,7 @@ static int siu_pcm_wr_set(struct siu_port *port_info, sg_init_table(&sg, 1); sg_set_page(&sg, pfn_to_page(PFN_DOWN(buff)), size, offset_in_page(buff)); + sg_dma_len(&sg) = size; sg_dma_address(&sg) = buff; desc = siu_stream->chan->device->device_prep_slave_sg(siu_stream->chan, @@ -176,6 +177,7 @@ static int siu_pcm_rd_set(struct siu_port *port_info, sg_init_table(&sg, 1); sg_set_page(&sg, pfn_to_page(PFN_DOWN(buff)), size, offset_in_page(buff)); + sg_dma_len(&sg) = size; sg_dma_address(&sg) = buff; desc = siu_stream->chan->device->device_prep_slave_sg(siu_stream->chan, -- cgit v1.1 From 597603d615d2b19a9e451d8cfac24372856a522d Mon Sep 17 00:00:00 2001 From: Jaroslav Kysela Date: Mon, 9 Aug 2010 14:21:11 +0200 Subject: ALSA: introduce the snd-aloop module for the PCM loopback The snd-aloop module allows redirecting of the PCM playback in the kernel back to the user space using the standard ALSA PCM capture API. The module also allows time synchronization with another timing source and notifications of playback stream parameter changes. Signed-off-by: Jaroslav Kysela --- sound/drivers/Kconfig | 19 + sound/drivers/Makefile | 2 + sound/drivers/aloop.c | 1055 ++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 1076 insertions(+) create mode 100644 sound/drivers/aloop.c (limited to 'sound') diff --git a/sound/drivers/Kconfig b/sound/drivers/Kconfig index 84714a6..b6ae762 100644 --- a/sound/drivers/Kconfig +++ b/sound/drivers/Kconfig @@ -74,6 +74,25 @@ config SND_DUMMY To compile this driver as a module, choose M here: the module will be called snd-dummy. +config SND_ALOOP + tristate "Generic loopback driver (PCM)" + select SND_PCM + help + Say 'Y' or 'M' to include support for the PCM loopback device. + This module returns played samples back to the user space using + the standard ALSA PCM device. The devices are routed 0->1 and + 1->0, where first number is the playback PCM device and second + number is the capture device. Module creates two PCM devices and + configured number of substreams (see the pcm_substreams module + parameter). + + The looback device allow time sychronization with an external + timing source using the time shift universal control (+-20% + of system time). + + To compile this driver as a module, choose M here: the module + will be called snd-aloop. + config SND_VIRMIDI tristate "Virtual MIDI soundcard" depends on SND_SEQUENCER diff --git a/sound/drivers/Makefile b/sound/drivers/Makefile index d4a07f9..1a8440c 100644 --- a/sound/drivers/Makefile +++ b/sound/drivers/Makefile @@ -4,6 +4,7 @@ # snd-dummy-objs := dummy.o +snd-aloop-objs := aloop.o snd-mtpav-objs := mtpav.o snd-mts64-objs := mts64.o snd-portman2x4-objs := portman2x4.o @@ -13,6 +14,7 @@ snd-ml403-ac97cr-objs := ml403-ac97cr.o pcm-indirect2.o # Toplevel Module Dependency obj-$(CONFIG_SND_DUMMY) += snd-dummy.o +obj-$(CONFIG_SND_ALOOP) += snd-aloop.o obj-$(CONFIG_SND_VIRMIDI) += snd-virmidi.o obj-$(CONFIG_SND_SERIAL_U16550) += snd-serial-u16550.o obj-$(CONFIG_SND_MTPAV) += snd-mtpav.o diff --git a/sound/drivers/aloop.c b/sound/drivers/aloop.c new file mode 100644 index 0000000..3123a15 --- /dev/null +++ b/sound/drivers/aloop.c @@ -0,0 +1,1055 @@ +/* + * Loopback soundcard + * + * Original code: + * Copyright (c) by Jaroslav Kysela + * + * More accurate positioning and full-duplex support: + * Copyright (c) Ahmet İnan + * + * Major (almost complete) rewrite: + * Copyright (c) by Takashi Iwai + * + * A next major update in 2010 (separate timers for playback and capture): + * Copyright (c) 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 + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +MODULE_AUTHOR("Jaroslav Kysela "); +MODULE_DESCRIPTION("A loopback soundcard"); +MODULE_LICENSE("GPL"); +MODULE_SUPPORTED_DEVICE("{{ALSA,Loopback soundcard}}"); + +#define MAX_PCM_SUBSTREAMS 8 + +static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ +static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ +static int enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 0}; +static int pcm_substreams[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 8}; +static int pcm_notify[SNDRV_CARDS]; + +module_param_array(index, int, NULL, 0444); +MODULE_PARM_DESC(index, "Index value for loopback soundcard."); +module_param_array(id, charp, NULL, 0444); +MODULE_PARM_DESC(id, "ID string for loopback soundcard."); +module_param_array(enable, bool, NULL, 0444); +MODULE_PARM_DESC(enable, "Enable this loopback soundcard."); +module_param_array(pcm_substreams, int, NULL, 0444); +MODULE_PARM_DESC(pcm_substreams, "PCM substreams # (1-8) for loopback driver."); +module_param_array(pcm_notify, int, NULL, 0444); +MODULE_PARM_DESC(pcm_notify, "Break capture when PCM format/rate/channels changes."); + +#define NO_PITCH 100000 + +struct loopback_pcm; + +struct loopback_cable { + spinlock_t lock; + struct loopback_pcm *streams[2]; + struct snd_pcm_hardware hw; + /* flags */ + unsigned int valid; + unsigned int running; +}; + +struct loopback_setup { + unsigned int notify: 1; + unsigned int rate_shift; + unsigned int format; + unsigned int rate; + unsigned int channels; + struct snd_ctl_elem_id active_id; + struct snd_ctl_elem_id format_id; + struct snd_ctl_elem_id rate_id; + struct snd_ctl_elem_id channels_id; +}; + +struct loopback { + struct snd_card *card; + struct mutex cable_lock; + struct loopback_cable *cables[MAX_PCM_SUBSTREAMS][2]; + struct snd_pcm *pcm[2]; + struct loopback_setup setup[MAX_PCM_SUBSTREAMS][2]; +}; + +struct loopback_pcm { + struct loopback *loopback; + struct snd_pcm_substream *substream; + struct loopback_cable *cable; + unsigned int pcm_buffer_size; + unsigned int buf_pos; /* position in buffer */ + unsigned int silent_size; + /* PCM parameters */ + unsigned int pcm_period_size; + unsigned int pcm_bps; /* bytes per second */ + unsigned int pcm_salign; /* bytes per sample * channels */ + unsigned int pcm_rate_shift; /* rate shift value */ + /* flags */ + unsigned int period_update_pending :1; + /* timer stuff */ + unsigned int irq_pos; /* fractional IRQ position */ + unsigned int period_size_frac; + unsigned long last_jiffies; + struct timer_list timer; +}; + +static struct platform_device *devices[SNDRV_CARDS]; + +static inline unsigned int byte_pos(struct loopback_pcm *dpcm, unsigned int x) +{ + if (dpcm->pcm_rate_shift == NO_PITCH) { + x /= HZ; + } else { + x = div_u64(NO_PITCH * (unsigned long long)x, + HZ * (unsigned long long)dpcm->pcm_rate_shift); + } + return x - (x % dpcm->pcm_salign); +} + +static inline unsigned int frac_pos(struct loopback_pcm *dpcm, unsigned int x) +{ + if (dpcm->pcm_rate_shift == NO_PITCH) { /* no pitch */ + return x * HZ; + } else { + x = div_u64(dpcm->pcm_rate_shift * (unsigned long long)x * HZ, + NO_PITCH); + } + return x; +} + +static inline struct loopback_setup *get_setup(struct loopback_pcm *dpcm) +{ + int device = dpcm->substream->pstr->pcm->device; + + if (dpcm->substream->stream == SNDRV_PCM_STREAM_PLAYBACK) + device ^= 1; + return &dpcm->loopback->setup[dpcm->substream->number][device]; +} + +static inline unsigned int get_notify(struct loopback_pcm *dpcm) +{ + return get_setup(dpcm)->notify; +} + +static inline unsigned int get_rate_shift(struct loopback_pcm *dpcm) +{ + return get_setup(dpcm)->rate_shift; +} + +static void loopback_timer_start(struct loopback_pcm *dpcm) +{ + unsigned long tick; + unsigned int rate_shift = get_rate_shift(dpcm); + + if (rate_shift != dpcm->pcm_rate_shift) { + dpcm->pcm_rate_shift = rate_shift; + dpcm->period_size_frac = frac_pos(dpcm, dpcm->pcm_period_size); + } + tick = dpcm->period_size_frac - dpcm->irq_pos; + tick = (tick + dpcm->pcm_bps - 1) / dpcm->pcm_bps; + dpcm->timer.expires = jiffies + tick; + add_timer(&dpcm->timer); +} + +static inline void loopback_timer_stop(struct loopback_pcm *dpcm) +{ + del_timer(&dpcm->timer); +} + +#define CABLE_VALID_PLAYBACK (1 << SNDRV_PCM_STREAM_PLAYBACK) +#define CABLE_VALID_CAPTURE (1 << SNDRV_PCM_STREAM_CAPTURE) +#define CABLE_VALID_BOTH (CABLE_VALID_PLAYBACK|CABLE_VALID_CAPTURE) + +static int loopback_check_format(struct loopback_cable *cable, int stream) +{ + struct snd_pcm_runtime *runtime; + struct loopback_setup *setup; + struct snd_card *card; + int check; + + if (cable->valid != CABLE_VALID_BOTH) { + if (stream == SNDRV_PCM_STREAM_PLAYBACK) + goto __notify; + return 0; + } + runtime = cable->streams[SNDRV_PCM_STREAM_PLAYBACK]-> + substream->runtime; + check = cable->hw.formats != (1ULL << runtime->format) || + cable->hw.rate_min != runtime->rate || + cable->hw.rate_max != runtime->rate || + cable->hw.channels_min != runtime->channels || + cable->hw.channels_max != runtime->channels; + if (!check) + return 0; + if (stream == SNDRV_PCM_STREAM_CAPTURE) { + return -EIO; + } else { + snd_pcm_stop(cable->streams[SNDRV_PCM_STREAM_CAPTURE]-> + substream, SNDRV_PCM_STATE_DRAINING); + __notify: + runtime = cable->streams[SNDRV_PCM_STREAM_PLAYBACK]-> + substream->runtime; + setup = get_setup(cable->streams[SNDRV_PCM_STREAM_PLAYBACK]); + card = cable->streams[SNDRV_PCM_STREAM_PLAYBACK]->loopback->card; + if (setup->format != runtime->format) { + snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, + &setup->format_id); + setup->format = runtime->format; + } + if (setup->rate != runtime->rate) { + snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, + &setup->rate_id); + setup->rate = runtime->rate; + } + if (setup->channels != runtime->channels) { + snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, + &setup->channels_id); + setup->channels = runtime->channels; + } + } + return 0; +} + +static void loopback_active_notify(struct loopback_pcm *dpcm) +{ + snd_ctl_notify(dpcm->loopback->card, + SNDRV_CTL_EVENT_MASK_VALUE, + &get_setup(dpcm)->active_id); +} + +static int loopback_trigger(struct snd_pcm_substream *substream, int cmd) +{ + struct snd_pcm_runtime *runtime = substream->runtime; + struct loopback_pcm *dpcm = runtime->private_data; + struct loopback_cable *cable = dpcm->cable; + int err; + + switch (cmd) { + case SNDRV_PCM_TRIGGER_START: + err = loopback_check_format(cable, substream->stream); + if (err < 0) + return err; + dpcm->last_jiffies = jiffies; + dpcm->pcm_rate_shift = 0; + loopback_timer_start(dpcm); + cable->running |= (1 << substream->stream); + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) + loopback_active_notify(dpcm); + break; + case SNDRV_PCM_TRIGGER_STOP: + cable->running &= ~(1 << substream->stream); + loopback_timer_stop(dpcm); + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) + loopback_active_notify(dpcm); + break; + default: + return -EINVAL; + } + return 0; +} + +static int loopback_prepare(struct snd_pcm_substream *substream) +{ + struct snd_pcm_runtime *runtime = substream->runtime; + struct loopback_pcm *dpcm = runtime->private_data; + struct loopback_cable *cable = dpcm->cable; + unsigned int bps, salign; + + salign = (snd_pcm_format_width(runtime->format) * + runtime->channels) / 8; + bps = salign * runtime->rate; + if (bps <= 0 || salign <= 0) + return -EINVAL; + + dpcm->buf_pos = 0; + dpcm->pcm_buffer_size = frames_to_bytes(runtime, runtime->buffer_size); + if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) { + /* clear capture buffer */ + dpcm->silent_size = dpcm->pcm_buffer_size; + snd_pcm_format_set_silence(runtime->format, runtime->dma_area, + runtime->buffer_size * runtime->channels); + } + + dpcm->irq_pos = 0; + dpcm->period_update_pending = 0; + dpcm->pcm_bps = bps; + dpcm->pcm_salign = salign; + dpcm->pcm_period_size = frames_to_bytes(runtime, runtime->period_size); + + mutex_lock(&dpcm->loopback->cable_lock); + if (!(cable->valid & ~(1 << substream->stream))) { + cable->hw.formats = (1ULL << runtime->format); + cable->hw.rate_min = runtime->rate; + cable->hw.rate_max = runtime->rate; + cable->hw.channels_min = runtime->channels; + cable->hw.channels_max = runtime->channels; + } + cable->valid |= 1 << substream->stream; + mutex_unlock(&dpcm->loopback->cable_lock); + + return 0; +} + +static void clear_capture_buf(struct loopback_pcm *dpcm, unsigned int bytes) +{ + struct snd_pcm_runtime *runtime = dpcm->substream->runtime; + char *dst = runtime->dma_area; + unsigned int dst_off = dpcm->buf_pos; + + if (dpcm->silent_size >= dpcm->pcm_buffer_size) + return; + if (dpcm->silent_size + bytes > dpcm->pcm_buffer_size) + bytes = dpcm->pcm_buffer_size - dpcm->silent_size; + + for (;;) { + unsigned int size = bytes; + if (dst_off + size > dpcm->pcm_buffer_size) + size = dpcm->pcm_buffer_size - dst_off; + snd_pcm_format_set_silence(runtime->format, dst + dst_off, + bytes_to_frames(runtime, size) * + runtime->channels); + dpcm->silent_size += size; + bytes -= size; + if (!bytes) + break; + dst_off = 0; + } +} + +static void copy_play_buf(struct loopback_pcm *play, + struct loopback_pcm *capt, + unsigned int bytes) +{ + struct snd_pcm_runtime *runtime = play->substream->runtime; + char *src = play->substream->runtime->dma_area; + char *dst = capt->substream->runtime->dma_area; + unsigned int src_off = play->buf_pos; + unsigned int dst_off = capt->buf_pos; + unsigned int clear_bytes = 0; + + /* check if playback is draining, trim the capture copy size + * when our pointer is at the end of playback ring buffer */ + if (runtime->status->state == SNDRV_PCM_STATE_DRAINING && + snd_pcm_playback_hw_avail(runtime) < runtime->buffer_size) { + snd_pcm_uframes_t appl_ptr, appl_ptr1, diff; + appl_ptr = appl_ptr1 = runtime->control->appl_ptr; + appl_ptr1 -= appl_ptr1 % runtime->buffer_size; + appl_ptr1 += play->buf_pos / play->pcm_salign; + if (appl_ptr < appl_ptr1) + appl_ptr1 -= runtime->buffer_size; + diff = (appl_ptr - appl_ptr1) * play->pcm_salign; + if (diff < bytes) { + clear_bytes = bytes - diff; + bytes = diff; + } + } + + for (;;) { + unsigned int size = bytes; + if (src_off + size > play->pcm_buffer_size) + size = play->pcm_buffer_size - src_off; + if (dst_off + size > capt->pcm_buffer_size) + size = capt->pcm_buffer_size - dst_off; + memcpy(dst + dst_off, src + src_off, size); + capt->silent_size = 0; + bytes -= size; + if (!bytes) + break; + src_off = (src_off + size) % play->pcm_buffer_size; + dst_off = (dst_off + size) % capt->pcm_buffer_size; + } + + if (clear_bytes > 0) + clear_capture_buf(capt, clear_bytes); +} + +#define BYTEPOS_UPDATE_POSONLY 0 +#define BYTEPOS_UPDATE_CLEAR 1 +#define BYTEPOS_UPDATE_COPY 2 + +static void loopback_bytepos_update(struct loopback_pcm *dpcm, + unsigned int delta, + unsigned int cmd) +{ + unsigned int count; + unsigned long last_pos; + + last_pos = byte_pos(dpcm, dpcm->irq_pos); + dpcm->irq_pos += delta * dpcm->pcm_bps; + count = byte_pos(dpcm, dpcm->irq_pos) - last_pos; + if (!count) + return; + if (cmd == BYTEPOS_UPDATE_CLEAR) + clear_capture_buf(dpcm, count); + else if (cmd == BYTEPOS_UPDATE_COPY) + copy_play_buf(dpcm->cable->streams[SNDRV_PCM_STREAM_PLAYBACK], + dpcm->cable->streams[SNDRV_PCM_STREAM_CAPTURE], + count); + dpcm->buf_pos += count; + dpcm->buf_pos %= dpcm->pcm_buffer_size; + if (dpcm->irq_pos >= dpcm->period_size_frac) { + dpcm->irq_pos %= dpcm->period_size_frac; + dpcm->period_update_pending = 1; + } +} + +static void loopback_pos_update(struct loopback_cable *cable) +{ + struct loopback_pcm *dpcm_play = + cable->streams[SNDRV_PCM_STREAM_PLAYBACK]; + struct loopback_pcm *dpcm_capt = + cable->streams[SNDRV_PCM_STREAM_CAPTURE]; + unsigned long delta_play = 0, delta_capt = 0; + + spin_lock(&cable->lock); + if (cable->running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) { + delta_play = jiffies - dpcm_play->last_jiffies; + dpcm_play->last_jiffies += delta_play; + } + + if (cable->running & (1 << SNDRV_PCM_STREAM_CAPTURE)) { + delta_capt = jiffies - dpcm_capt->last_jiffies; + dpcm_capt->last_jiffies += delta_capt; + } + + if (delta_play == 0 && delta_capt == 0) { + spin_unlock(&cable->lock); + return; + } + + if (delta_play > delta_capt) { + loopback_bytepos_update(dpcm_play, delta_play - delta_capt, + BYTEPOS_UPDATE_POSONLY); + delta_play = delta_capt; + } else if (delta_play < delta_capt) { + loopback_bytepos_update(dpcm_capt, delta_capt - delta_play, + BYTEPOS_UPDATE_CLEAR); + delta_capt = delta_play; + } + + if (delta_play == 0 && delta_capt == 0) { + spin_unlock(&cable->lock); + return; + } + /* note delta_capt == delta_play at this moment */ + loopback_bytepos_update(dpcm_capt, delta_capt, BYTEPOS_UPDATE_COPY); + loopback_bytepos_update(dpcm_play, delta_play, BYTEPOS_UPDATE_POSONLY); + spin_unlock(&cable->lock); +} + +static void loopback_timer_function(unsigned long data) +{ + struct loopback_pcm *dpcm = (struct loopback_pcm *)data; + int stream; + + loopback_pos_update(dpcm->cable); + stream = dpcm->substream->stream; + if (dpcm->cable->running & (1 << stream)) + loopback_timer_start(dpcm); + if (dpcm->period_update_pending) { + dpcm->period_update_pending = 0; + if (dpcm->cable->running & (1 << stream)) + snd_pcm_period_elapsed(dpcm->substream); + } +} + +static snd_pcm_uframes_t loopback_pointer(struct snd_pcm_substream *substream) +{ + struct snd_pcm_runtime *runtime = substream->runtime; + struct loopback_pcm *dpcm = runtime->private_data; + + loopback_pos_update(dpcm->cable); + return bytes_to_frames(runtime, dpcm->buf_pos); +} + +static struct snd_pcm_hardware loopback_pcm_hardware = +{ + .info = (SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP | + SNDRV_PCM_INFO_MMAP_VALID), + .formats = (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE | + SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE | + SNDRV_PCM_FMTBIT_FLOAT_LE | SNDRV_PCM_FMTBIT_FLOAT_BE), + .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_192000, + .rate_min = 8000, + .rate_max = 192000, + .channels_min = 1, + .channels_max = 32, + .buffer_bytes_max = 2 * 1024 * 1024, + .period_bytes_min = 64, + .period_bytes_max = 2 * 1024 * 1024, + .periods_min = 1, + .periods_max = 1024, + .fifo_size = 0, +}; + +static void loopback_runtime_free(struct snd_pcm_runtime *runtime) +{ + struct loopback_pcm *dpcm = runtime->private_data; + kfree(dpcm); +} + +static int loopback_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params) +{ + return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params)); +} + +static int loopback_hw_free(struct snd_pcm_substream *substream) +{ + struct snd_pcm_runtime *runtime = substream->runtime; + struct loopback_pcm *dpcm = runtime->private_data; + struct loopback_cable *cable = dpcm->cable; + + mutex_lock(&dpcm->loopback->cable_lock); + cable->valid &= ~(1 << substream->stream); + mutex_unlock(&dpcm->loopback->cable_lock); + return snd_pcm_lib_free_pages(substream); +} + +static unsigned int get_cable_index(struct snd_pcm_substream *substream) +{ + if (!substream->pcm->device) + return substream->stream; + else + return !substream->stream; +} + +static int loopback_open(struct snd_pcm_substream *substream) +{ + struct snd_pcm_runtime *runtime = substream->runtime; + struct loopback *loopback = substream->private_data; + struct loopback_pcm *dpcm; + struct loopback_cable *cable; + int err = 0; + int dev = get_cable_index(substream); + + mutex_lock(&loopback->cable_lock); + dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL); + if (!dpcm) { + err = -ENOMEM; + goto unlock; + } + dpcm->loopback = loopback; + dpcm->substream = substream; + setup_timer(&dpcm->timer, loopback_timer_function, + (unsigned long)dpcm); + + cable = loopback->cables[substream->number][dev]; + if (!cable) { + cable = kzalloc(sizeof(*cable), GFP_KERNEL); + if (!cable) { + kfree(dpcm); + err = -ENOMEM; + goto unlock; + } + spin_lock_init(&cable->lock); + cable->hw = loopback_pcm_hardware; + loopback->cables[substream->number][dev] = cable; + } + dpcm->cable = cable; + cable->streams[substream->stream] = dpcm; + + snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS); + + runtime->private_data = dpcm; + runtime->private_free = loopback_runtime_free; + if (get_notify(dpcm) && + substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { + runtime->hw = loopback_pcm_hardware; + } else { + runtime->hw = cable->hw; + } + unlock: + mutex_unlock(&loopback->cable_lock); + return err; +} + +static int loopback_close(struct snd_pcm_substream *substream) +{ + struct loopback *loopback = substream->private_data; + struct loopback_pcm *dpcm = substream->runtime->private_data; + struct loopback_cable *cable; + int dev = get_cable_index(substream); + + loopback_timer_stop(dpcm); + mutex_lock(&loopback->cable_lock); + cable = loopback->cables[substream->number][dev]; + if (cable->streams[!substream->stream]) { + /* other stream is still alive */ + cable->streams[substream->stream] = NULL; + } else { + /* free the cable */ + loopback->cables[substream->number][dev] = NULL; + kfree(cable); + } + mutex_unlock(&loopback->cable_lock); + return 0; +} + +static struct snd_pcm_ops loopback_playback_ops = { + .open = loopback_open, + .close = loopback_close, + .ioctl = snd_pcm_lib_ioctl, + .hw_params = loopback_hw_params, + .hw_free = loopback_hw_free, + .prepare = loopback_prepare, + .trigger = loopback_trigger, + .pointer = loopback_pointer, +}; + +static struct snd_pcm_ops loopback_capture_ops = { + .open = loopback_open, + .close = loopback_close, + .ioctl = snd_pcm_lib_ioctl, + .hw_params = loopback_hw_params, + .hw_free = loopback_hw_free, + .prepare = loopback_prepare, + .trigger = loopback_trigger, + .pointer = loopback_pointer, +}; + +static int __devinit loopback_pcm_new(struct loopback *loopback, + int device, int substreams) +{ + struct snd_pcm *pcm; + int err; + + err = snd_pcm_new(loopback->card, "Loopback PCM", device, + substreams, substreams, &pcm); + if (err < 0) + return err; + snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &loopback_playback_ops); + snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &loopback_capture_ops); + + pcm->private_data = loopback; + pcm->info_flags = 0; + strcpy(pcm->name, "Loopback PCM"); + + loopback->pcm[device] = pcm; + + snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS, + snd_dma_continuous_data(GFP_KERNEL), + 0, 2 * 1024 * 1024); + return 0; +} + +static int loopback_rate_shift_info(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_info *uinfo) +{ + uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; + uinfo->count = 1; + uinfo->value.integer.min = 80000; + uinfo->value.integer.max = 120000; + uinfo->value.integer.step = 1; + return 0; +} + +static int loopback_rate_shift_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct loopback *loopback = snd_kcontrol_chip(kcontrol); + + ucontrol->value.integer.value[0] = + loopback->setup[kcontrol->id.subdevice] + [kcontrol->id.device].rate_shift; + return 0; +} + +static int loopback_rate_shift_put(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct loopback *loopback = snd_kcontrol_chip(kcontrol); + unsigned int val; + int change = 0; + + val = ucontrol->value.integer.value[0]; + if (val < 80000) + val = 80000; + if (val > 120000) + val = 120000; + mutex_lock(&loopback->cable_lock); + if (val != loopback->setup[kcontrol->id.subdevice] + [kcontrol->id.device].rate_shift) { + loopback->setup[kcontrol->id.subdevice] + [kcontrol->id.device].rate_shift = val; + change = 1; + } + mutex_unlock(&loopback->cable_lock); + return change; +} + +static int loopback_notify_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct loopback *loopback = snd_kcontrol_chip(kcontrol); + + ucontrol->value.integer.value[0] = + loopback->setup[kcontrol->id.subdevice] + [kcontrol->id.device].notify; + return 0; +} + +static int loopback_notify_put(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct loopback *loopback = snd_kcontrol_chip(kcontrol); + unsigned int val; + int change = 0; + + val = ucontrol->value.integer.value[0] ? 1 : 0; + if (val != loopback->setup[kcontrol->id.subdevice] + [kcontrol->id.device].notify) { + loopback->setup[kcontrol->id.subdevice] + [kcontrol->id.device].notify = val; + change = 1; + } + return change; +} + +static int loopback_active_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct loopback *loopback = snd_kcontrol_chip(kcontrol); + struct loopback_cable *cable = loopback->cables + [kcontrol->id.subdevice][kcontrol->id.device]; + unsigned int val = 0; + + if (cable != NULL) + val = (cable->running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) ? + 1 : 0; + ucontrol->value.integer.value[0] = val; + return 0; +} + +static int loopback_format_info(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_info *uinfo) +{ + uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; + uinfo->count = 1; + uinfo->value.integer.min = 0; + uinfo->value.integer.max = SNDRV_PCM_FORMAT_LAST; + uinfo->value.integer.step = 1; + return 0; +} + +static int loopback_format_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct loopback *loopback = snd_kcontrol_chip(kcontrol); + + ucontrol->value.integer.value[0] = + loopback->setup[kcontrol->id.subdevice] + [kcontrol->id.device].format; + return 0; +} + +static int loopback_rate_info(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_info *uinfo) +{ + uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; + uinfo->count = 1; + uinfo->value.integer.min = 0; + uinfo->value.integer.max = 192000; + uinfo->value.integer.step = 1; + return 0; +} + +static int loopback_rate_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct loopback *loopback = snd_kcontrol_chip(kcontrol); + + ucontrol->value.integer.value[0] = + loopback->setup[kcontrol->id.subdevice] + [kcontrol->id.device].rate; + return 0; +} + +static int loopback_channels_info(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_info *uinfo) +{ + uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; + uinfo->count = 1; + uinfo->value.integer.min = 1; + uinfo->value.integer.max = 1024; + uinfo->value.integer.step = 1; + return 0; +} + +static int loopback_channels_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct loopback *loopback = snd_kcontrol_chip(kcontrol); + + ucontrol->value.integer.value[0] = + loopback->setup[kcontrol->id.subdevice] + [kcontrol->id.device].rate; + return 0; +} + +static struct snd_kcontrol_new loopback_controls[] __devinitdata = { +{ + .iface = SNDRV_CTL_ELEM_IFACE_PCM, + .name = "PCM Rate Shift 100000", + .info = loopback_rate_shift_info, + .get = loopback_rate_shift_get, + .put = loopback_rate_shift_put, +}, +{ + .iface = SNDRV_CTL_ELEM_IFACE_PCM, + .name = "PCM Notify", + .info = snd_ctl_boolean_mono_info, + .get = loopback_notify_get, + .put = loopback_notify_put, +}, +#define ACTIVE_IDX 2 +{ + .access = SNDRV_CTL_ELEM_ACCESS_READ, + .iface = SNDRV_CTL_ELEM_IFACE_PCM, + .name = "PCM Slave Active", + .info = snd_ctl_boolean_mono_info, + .get = loopback_active_get, +}, +#define FORMAT_IDX 3 +{ + .access = SNDRV_CTL_ELEM_ACCESS_READ, + .iface = SNDRV_CTL_ELEM_IFACE_PCM, + .name = "PCM Slave Format", + .info = loopback_format_info, + .get = loopback_format_get +}, +#define RATE_IDX 4 +{ + .access = SNDRV_CTL_ELEM_ACCESS_READ, + .iface = SNDRV_CTL_ELEM_IFACE_PCM, + .name = "PCM Slave Rate", + .info = loopback_rate_info, + .get = loopback_rate_get +}, +#define CHANNELS_IDX 5 +{ + .access = SNDRV_CTL_ELEM_ACCESS_READ, + .iface = SNDRV_CTL_ELEM_IFACE_PCM, + .name = "PCM Slave Channels", + .info = loopback_channels_info, + .get = loopback_channels_get +} +}; + +static int __devinit loopback_mixer_new(struct loopback *loopback, int notify) +{ + struct snd_card *card = loopback->card; + struct snd_pcm *pcm; + struct snd_kcontrol *kctl; + struct loopback_setup *setup; + int err, dev, substr, substr_count, idx; + + strcpy(card->mixername, "Loopback Mixer"); + for (dev = 0; dev < 2; dev++) { + pcm = loopback->pcm[dev]; + substr_count = + pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream_count; + for (substr = 0; substr < substr_count; substr++) { + setup = &loopback->setup[substr][dev]; + setup->notify = notify; + setup->rate_shift = NO_PITCH; + setup->format = SNDRV_PCM_FORMAT_S16_LE; + setup->rate = 48000; + setup->channels = 2; + for (idx = 0; idx < ARRAY_SIZE(loopback_controls); + idx++) { + kctl = snd_ctl_new1(&loopback_controls[idx], + loopback); + if (!kctl) + return -ENOMEM; + kctl->id.device = dev; + kctl->id.subdevice = substr; + switch (idx) { + case ACTIVE_IDX: + setup->active_id = kctl->id; + break; + case FORMAT_IDX: + setup->format_id = kctl->id; + break; + case RATE_IDX: + setup->rate_id = kctl->id; + break; + case CHANNELS_IDX: + setup->channels_id = kctl->id; + break; + default: + break; + } + err = snd_ctl_add(card, kctl); + if (err < 0) + return err; + } + } + } + return 0; +} + +static int __devinit loopback_probe(struct platform_device *devptr) +{ + struct snd_card *card; + struct loopback *loopback; + int dev = devptr->id; + int err; + + err = snd_card_create(index[dev], id[dev], THIS_MODULE, + sizeof(struct loopback), &card); + if (err < 0) + return err; + loopback = card->private_data; + + if (pcm_substreams[dev] < 1) + pcm_substreams[dev] = 1; + if (pcm_substreams[dev] > MAX_PCM_SUBSTREAMS) + pcm_substreams[dev] = MAX_PCM_SUBSTREAMS; + + loopback->card = card; + mutex_init(&loopback->cable_lock); + + err = loopback_pcm_new(loopback, 0, pcm_substreams[dev]); + if (err < 0) + goto __nodev; + err = loopback_pcm_new(loopback, 1, pcm_substreams[dev]); + if (err < 0) + goto __nodev; + err = loopback_mixer_new(loopback, pcm_notify[dev] ? 1 : 0); + if (err < 0) + goto __nodev; + strcpy(card->driver, "Loopback"); + strcpy(card->shortname, "Loopback"); + sprintf(card->longname, "Loopback %i", dev + 1); + err = snd_card_register(card); + if (!err) { + platform_set_drvdata(devptr, card); + return 0; + } + __nodev: + snd_card_free(card); + return err; +} + +static int __devexit loopback_remove(struct platform_device *devptr) +{ + snd_card_free(platform_get_drvdata(devptr)); + platform_set_drvdata(devptr, NULL); + return 0; +} + +#ifdef CONFIG_PM +static int loopback_suspend(struct platform_device *pdev, + pm_message_t state) +{ + struct snd_card *card = platform_get_drvdata(pdev); + struct loopback *loopback = card->private_data; + + snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); + + snd_pcm_suspend_all(loopback->pcm[0]); + snd_pcm_suspend_all(loopback->pcm[1]); + return 0; +} + +static int loopback_resume(struct platform_device *pdev) +{ + struct snd_card *card = platform_get_drvdata(pdev); + + snd_power_change_state(card, SNDRV_CTL_POWER_D0); + return 0; +} +#endif + +#define SND_LOOPBACK_DRIVER "snd_aloop" + +static struct platform_driver loopback_driver = { + .probe = loopback_probe, + .remove = __devexit_p(loopback_remove), +#ifdef CONFIG_PM + .suspend = loopback_suspend, + .resume = loopback_resume, +#endif + .driver = { + .name = SND_LOOPBACK_DRIVER + }, +}; + +static void loopback_unregister_all(void) +{ + int i; + + for (i = 0; i < ARRAY_SIZE(devices); ++i) + platform_device_unregister(devices[i]); + platform_driver_unregister(&loopback_driver); +} + +static int __init alsa_card_loopback_init(void) +{ + int i, err, cards; + + err = platform_driver_register(&loopback_driver); + if (err < 0) + return err; + + + cards = 0; + for (i = 0; i < SNDRV_CARDS; i++) { + struct platform_device *device; + if (!enable[i]) + continue; + device = platform_device_register_simple(SND_LOOPBACK_DRIVER, + i, NULL, 0); + if (IS_ERR(device)) + continue; + if (!platform_get_drvdata(device)) { + platform_device_unregister(device); + continue; + } + devices[i] = device; + cards++; + } + if (!cards) { +#ifdef MODULE + printk(KERN_ERR "aloop: No loopback enabled\n"); +#endif + loopback_unregister_all(); + return -ENODEV; + } + return 0; +} + +static void __exit alsa_card_loopback_exit(void) +{ + loopback_unregister_all(); +} + +module_init(alsa_card_loopback_init) +module_exit(alsa_card_loopback_exit) -- cgit v1.1 From 495311927ffbe3604e915aeafdf03325e9925b9d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ren=C3=A9=20Herman?= Date: Wed, 11 Aug 2010 13:08:06 +0200 Subject: ALSA: ISA: New Aztech Sound Galaxy driver This is a new driver for Aztech Sound Galaxy ISA soundcards based on the AZT1605 and AZT2316 chipsets. It's constructed as two seperate drivers for either chipset generated from the same source file, with (very) minimal ifdeffery. The drivers check the SB DSP version to decide if they are being loaded for the right chip. AZT1605 returns 2.1 by default and AZT2316 3.1. This isn't full-proof as the DSP version can actually be set through software but it's close enough -- as far as I've been able to see, the DSP version can not be stored in the EEPROM and the cards will therefore startup with the defaults. This distinction could (with the same success rate) also be used to decide which chip we're looking at at runtime meaning a single, merged driver is also an option but I feel it's actually nicer this way. A merged driver would have to postpone translating the passed in resource values to the card configuration until it knew which one it was looking at and would need to postpone erring out on mpu_irq=10 for azt1605 and mpu_irq=3 for azt2316. The drivers have been tested on various cards. For snd-azt1605: FCC-ID I38-MMSN811: Aztech Sound Galaxy Nova 16 Extra FCC-ID I38-MMSN822: Aztech Sound Galaxy Pro 16 II and for snd-azt2316: FCC-ID I38-MMSN824: Aztech Sound Galaxy Pro 16 AB FCC-ID I38-MMSN826: Trust Sound Expert DeLuxe Wave 32 (05201) FCC-ID I38-MMSN830: Trust Sound Expert DeLuxe 16+ (05202) FCC-ID I38-MMSN837: Packard Bell ISA Soundcard 030069 FCC-ID I38-MMSN846: Trust Sound Expert DeLuxe 16-3D (06300) FCC-ID I38-MMSN847: Trust Sound Expert DeLuxe Wave 32-3D (06301) FCC-ID I38-MMSN852: Aztech Sound Galaxy Waverider Pro 32-3D 826 and 846 were also marketed directly by Aztech and then known as: FCC-ID I38-MMSN826: Aztech Sound Galaxy Waverider 32+ FCC-ID I38-MMSN846: Aztech Sound Galaxy Nova 16 Extra II-3D Together, these cover the AZT1605 and AT2316A, AZT2316R and AZT2316-S chipsets. All cards work fully -- full-duplex PCM, MIDI and FM. Full duplex is a little flaky on some. I38-MSN811 tends to not work in full-duplex but sometimes does with the highest success rate being achieved when you first start the capture and then a playback instead of the other way around (it's a CS4231-KL codec). The cards with an AD1845XP codec (my I38-MMSN826 and one of my I38-MMSN830s) are also somewhat duplex-challenged. Sometimes full-duplex works, sometimes not and this varies from try to try. This seems likely to be a timing problem somewhere inside wss-lib. I38-MMSN826 has an additional "ICS2115 WaveFront" wavetable synth onboard that isn't supported yet. The wavetable synths on I38-MMSN847 and I38-MMSN852 are wired directly to the standard MPU-401 UART and the AUX1 input on the codec and work without problem. CD-ROM audio on the cards is routed to the codec "Line" input, Line-In to its Aux input, and FM/Wavetable to its AUX1 input. I did not rename the controls due to the capture source enumeration: I see that capture-source overrides are hardcoded in wss-lib and this is just too ugly to live. Versus the old snd-sgalaxy driver these drivers add support for the models without a configuration EEPROM (which are common), full-duplex, MPU-401 UART and OPL3. In the future they might grow support for that ICS2115 WaveFront synth on 826 and an hwdep interface to write to the EEPROM on the models that have one. Signed-off-by: Rene Herman Signed-off-by: Takashi Iwai --- sound/isa/Kconfig | 26 ++ sound/isa/Makefile | 2 +- sound/isa/galaxy/Makefile | 10 + sound/isa/galaxy/azt1605.c | 91 +++++++ sound/isa/galaxy/azt2316.c | 111 ++++++++ sound/isa/galaxy/galaxy.c | 652 +++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 891 insertions(+), 1 deletion(-) create mode 100644 sound/isa/galaxy/Makefile create mode 100644 sound/isa/galaxy/azt1605.c create mode 100644 sound/isa/galaxy/azt2316.c create mode 100644 sound/isa/galaxy/galaxy.c (limited to 'sound') diff --git a/sound/isa/Kconfig b/sound/isa/Kconfig index c6990c6..f9aa13d 100644 --- a/sound/isa/Kconfig +++ b/sound/isa/Kconfig @@ -77,6 +77,32 @@ config SND_ALS100 To compile this driver as a module, choose M here: the module will be called snd-als100. +config SND_AZT1605 + tristate "Aztech AZT1605 Driver" + depends on SND + select SND_WSS_LIB + select SND_MPU401_UART + select SND_OPL3_LIB + help + Say Y here to include support for Aztech Sound Galaxy cards + based on the AZT1605 chipset. + + To compile this driver as a module, choose M here: the module + will be called snd-azt1605. + +config SND_AZT2316 + tristate "Aztech AZT2316 Driver" + depends on SND + select SND_WSS_LIB + select SND_MPU401_UART + select SND_OPL3_LIB + help + Say Y here to include support for Aztech Sound Galaxy cards + based on the AZT2316 chipset. + + To compile this driver as a module, choose M here: the module + will be called snd-azt2316. + config SND_AZT2320 tristate "Aztech Systems AZT2320" depends on PNP diff --git a/sound/isa/Makefile b/sound/isa/Makefile index c73d30c..d2bd8f5 100644 --- a/sound/isa/Makefile +++ b/sound/isa/Makefile @@ -24,5 +24,5 @@ obj-$(CONFIG_SND_SC6000) += snd-sc6000.o obj-$(CONFIG_SND_SGALAXY) += snd-sgalaxy.o obj-$(CONFIG_SND_SSCAPE) += snd-sscape.o -obj-$(CONFIG_SND) += ad1816a/ ad1848/ cs423x/ es1688/ gus/ msnd/ opti9xx/ \ +obj-$(CONFIG_SND) += ad1816a/ ad1848/ cs423x/ es1688/ galaxy/ gus/ msnd/ opti9xx/ \ sb/ wavefront/ wss/ diff --git a/sound/isa/galaxy/Makefile b/sound/isa/galaxy/Makefile new file mode 100644 index 0000000..e307066 --- /dev/null +++ b/sound/isa/galaxy/Makefile @@ -0,0 +1,10 @@ +# +# Makefile for ALSA +# Copyright (c) 2001 by Jaroslav Kysela +# + +snd-azt1605-objs := azt1605.o +snd-azt2316-objs := azt2316.o + +obj-$(CONFIG_SND_AZT1605) += snd-azt1605.o +obj-$(CONFIG_SND_AZT2316) += snd-azt2316.o diff --git a/sound/isa/galaxy/azt1605.c b/sound/isa/galaxy/azt1605.c new file mode 100644 index 0000000..9a97643 --- /dev/null +++ b/sound/isa/galaxy/azt1605.c @@ -0,0 +1,91 @@ +/* + * Aztech AZT1605 Driver + * Copyright (C) 2007,2010 Rene Herman + * + * 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, see . + * + */ + +#define AZT1605 + +#define CRD_NAME "Aztech AZT1605" +#define DRV_NAME "AZT1605" +#define DEV_NAME "azt1605" + +#define GALAXY_DSP_MAJOR 2 +#define GALAXY_DSP_MINOR 1 + +#define GALAXY_CONFIG_SIZE 3 + +/* + * 24-bit config register + */ + +#define GALAXY_CONFIG_SBA_220 (0 << 0) +#define GALAXY_CONFIG_SBA_240 (1 << 0) +#define GALAXY_CONFIG_SBA_260 (2 << 0) +#define GALAXY_CONFIG_SBA_280 (3 << 0) +#define GALAXY_CONFIG_SBA_MASK GALAXY_CONFIG_SBA_280 + +#define GALAXY_CONFIG_MPUA_300 (0 << 2) +#define GALAXY_CONFIG_MPUA_330 (1 << 2) + +#define GALAXY_CONFIG_MPU_ENABLE (1 << 3) + +#define GALAXY_CONFIG_GAME_ENABLE (1 << 4) + +#define GALAXY_CONFIG_CD_PANASONIC (1 << 5) +#define GALAXY_CONFIG_CD_MITSUMI (1 << 6) +#define GALAXY_CONFIG_CD_MASK (\ + GALAXY_CONFIG_CD_PANASONIC | GALAXY_CONFIG_CD_MITSUMI) + +#define GALAXY_CONFIG_UNUSED (1 << 7) +#define GALAXY_CONFIG_UNUSED_MASK GALAXY_CONFIG_UNUSED + +#define GALAXY_CONFIG_SBIRQ_2 (1 << 8) +#define GALAXY_CONFIG_SBIRQ_3 (1 << 9) +#define GALAXY_CONFIG_SBIRQ_5 (1 << 10) +#define GALAXY_CONFIG_SBIRQ_7 (1 << 11) + +#define GALAXY_CONFIG_MPUIRQ_2 (1 << 12) +#define GALAXY_CONFIG_MPUIRQ_3 (1 << 13) +#define GALAXY_CONFIG_MPUIRQ_5 (1 << 14) +#define GALAXY_CONFIG_MPUIRQ_7 (1 << 15) + +#define GALAXY_CONFIG_WSSA_530 (0 << 16) +#define GALAXY_CONFIG_WSSA_604 (1 << 16) +#define GALAXY_CONFIG_WSSA_E80 (2 << 16) +#define GALAXY_CONFIG_WSSA_F40 (3 << 16) + +#define GALAXY_CONFIG_WSS_ENABLE (1 << 18) + +#define GALAXY_CONFIG_CDIRQ_11 (1 << 19) +#define GALAXY_CONFIG_CDIRQ_12 (1 << 20) +#define GALAXY_CONFIG_CDIRQ_15 (1 << 21) +#define GALAXY_CONFIG_CDIRQ_MASK (\ + GALAXY_CONFIG_CDIRQ_11 | GALAXY_CONFIG_CDIRQ_12 |\ + GALAXY_CONFIG_CDIRQ_15) + +#define GALAXY_CONFIG_CDDMA_DISABLE (0 << 22) +#define GALAXY_CONFIG_CDDMA_0 (1 << 22) +#define GALAXY_CONFIG_CDDMA_1 (2 << 22) +#define GALAXY_CONFIG_CDDMA_3 (3 << 22) +#define GALAXY_CONFIG_CDDMA_MASK GALAXY_CONFIG_CDDMA_3 + +#define GALAXY_CONFIG_MASK (\ + GALAXY_CONFIG_SBA_MASK | GALAXY_CONFIG_CD_MASK |\ + GALAXY_CONFIG_UNUSED_MASK | GALAXY_CONFIG_CDIRQ_MASK |\ + GALAXY_CONFIG_CDDMA_MASK) + +#include "galaxy.c" diff --git a/sound/isa/galaxy/azt2316.c b/sound/isa/galaxy/azt2316.c new file mode 100644 index 0000000..1894411 --- /dev/null +++ b/sound/isa/galaxy/azt2316.c @@ -0,0 +1,111 @@ +/* + * Aztech AZT2316 Driver + * Copyright (C) 2007,2010 Rene Herman + * + * 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, see . + * + */ + +#define AZT2316 + +#define CRD_NAME "Aztech AZT2316" +#define DRV_NAME "AZT2316" +#define DEV_NAME "azt2316" + +#define GALAXY_DSP_MAJOR 3 +#define GALAXY_DSP_MINOR 1 + +#define GALAXY_CONFIG_SIZE 4 + +/* + * 32-bit config register + */ + +#define GALAXY_CONFIG_SBA_220 (0 << 0) +#define GALAXY_CONFIG_SBA_240 (1 << 0) +#define GALAXY_CONFIG_SBA_260 (2 << 0) +#define GALAXY_CONFIG_SBA_280 (3 << 0) +#define GALAXY_CONFIG_SBA_MASK GALAXY_CONFIG_SBA_280 + +#define GALAXY_CONFIG_SBIRQ_2 (1 << 2) +#define GALAXY_CONFIG_SBIRQ_5 (1 << 3) +#define GALAXY_CONFIG_SBIRQ_7 (1 << 4) +#define GALAXY_CONFIG_SBIRQ_10 (1 << 5) + +#define GALAXY_CONFIG_SBDMA_DISABLE (0 << 6) +#define GALAXY_CONFIG_SBDMA_0 (1 << 6) +#define GALAXY_CONFIG_SBDMA_1 (2 << 6) +#define GALAXY_CONFIG_SBDMA_3 (3 << 6) + +#define GALAXY_CONFIG_WSSA_530 (0 << 8) +#define GALAXY_CONFIG_WSSA_604 (1 << 8) +#define GALAXY_CONFIG_WSSA_E80 (2 << 8) +#define GALAXY_CONFIG_WSSA_F40 (3 << 8) + +#define GALAXY_CONFIG_WSS_ENABLE (1 << 10) + +#define GALAXY_CONFIG_GAME_ENABLE (1 << 11) + +#define GALAXY_CONFIG_MPUA_300 (0 << 12) +#define GALAXY_CONFIG_MPUA_330 (1 << 12) + +#define GALAXY_CONFIG_MPU_ENABLE (1 << 13) + +#define GALAXY_CONFIG_CDA_310 (0 << 14) +#define GALAXY_CONFIG_CDA_320 (1 << 14) +#define GALAXY_CONFIG_CDA_340 (2 << 14) +#define GALAXY_CONFIG_CDA_350 (3 << 14) +#define GALAXY_CONFIG_CDA_MASK GALAXY_CONFIG_CDA_350 + +#define GALAXY_CONFIG_CD_DISABLE (0 << 16) +#define GALAXY_CONFIG_CD_PANASONIC (1 << 16) +#define GALAXY_CONFIG_CD_SONY (2 << 16) +#define GALAXY_CONFIG_CD_MITSUMI (3 << 16) +#define GALAXY_CONFIG_CD_AZTECH (4 << 16) +#define GALAXY_CONFIG_CD_UNUSED_5 (5 << 16) +#define GALAXY_CONFIG_CD_UNUSED_6 (6 << 16) +#define GALAXY_CONFIG_CD_UNUSED_7 (7 << 16) +#define GALAXY_CONFIG_CD_MASK GALAXY_CONFIG_CD_UNUSED_7 + +#define GALAXY_CONFIG_CDDMA8_DISABLE (0 << 20) +#define GALAXY_CONFIG_CDDMA8_0 (1 << 20) +#define GALAXY_CONFIG_CDDMA8_1 (2 << 20) +#define GALAXY_CONFIG_CDDMA8_3 (3 << 20) +#define GALAXY_CONFIG_CDDMA8_MASK GALAXY_CONFIG_CDDMA8_3 + +#define GALAXY_CONFIG_CDDMA16_DISABLE (0 << 22) +#define GALAXY_CONFIG_CDDMA16_5 (1 << 22) +#define GALAXY_CONFIG_CDDMA16_6 (2 << 22) +#define GALAXY_CONFIG_CDDMA16_7 (3 << 22) +#define GALAXY_CONFIG_CDDMA16_MASK GALAXY_CONFIG_CDDMA16_7 + +#define GALAXY_CONFIG_MPUIRQ_2 (1 << 24) +#define GALAXY_CONFIG_MPUIRQ_5 (1 << 25) +#define GALAXY_CONFIG_MPUIRQ_7 (1 << 26) +#define GALAXY_CONFIG_MPUIRQ_10 (1 << 27) + +#define GALAXY_CONFIG_CDIRQ_5 (1 << 28) +#define GALAXY_CONFIG_CDIRQ_11 (1 << 29) +#define GALAXY_CONFIG_CDIRQ_12 (1 << 30) +#define GALAXY_CONFIG_CDIRQ_15 (1 << 31) +#define GALAXY_CONFIG_CDIRQ_MASK (\ + GALAXY_CONFIG_CDIRQ_5 | GALAXY_CONFIG_CDIRQ_11 |\ + GALAXY_CONFIG_CDIRQ_12 | GALAXY_CONFIG_CDIRQ_15) + +#define GALAXY_CONFIG_MASK (\ + GALAXY_CONFIG_SBA_MASK | GALAXY_CONFIG_CDA_MASK |\ + GALAXY_CONFIG_CD_MASK | GALAXY_CONFIG_CDDMA16_MASK |\ + GALAXY_CONFIG_CDDMA8_MASK | GALAXY_CONFIG_CDIRQ_MASK) + +#include "galaxy.c" diff --git a/sound/isa/galaxy/galaxy.c b/sound/isa/galaxy/galaxy.c new file mode 100644 index 0000000..ee54df0 --- /dev/null +++ b/sound/isa/galaxy/galaxy.c @@ -0,0 +1,652 @@ +/* + * Aztech AZT1605/AZT2316 Driver + * Copyright (C) 2007,2010 Rene Herman + * + * 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, see . + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +MODULE_DESCRIPTION(CRD_NAME); +MODULE_AUTHOR("Rene Herman"); +MODULE_LICENSE("GPL"); + +static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; +static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; +static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE; + +module_param_array(index, int, NULL, 0444); +MODULE_PARM_DESC(index, "Index value for " CRD_NAME " soundcard."); +module_param_array(id, charp, NULL, 0444); +MODULE_PARM_DESC(id, "ID string for " CRD_NAME " soundcard."); +module_param_array(enable, bool, NULL, 0444); +MODULE_PARM_DESC(enable, "Enable " CRD_NAME " soundcard."); + +static long port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; +static long wss_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; +static long mpu_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; +static long fm_port[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; +static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; +static int mpu_irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; +static int dma1[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; +static int dma2[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; + +module_param_array(port, long, NULL, 0444); +MODULE_PARM_DESC(port, "Port # for " CRD_NAME " driver."); +module_param_array(wss_port, long, NULL, 0444); +MODULE_PARM_DESC(wss_port, "WSS port # for " CRD_NAME " driver."); +module_param_array(mpu_port, long, NULL, 0444); +MODULE_PARM_DESC(mpu_port, "MPU-401 port # for " CRD_NAME " driver."); +module_param_array(fm_port, long, NULL, 0444); +MODULE_PARM_DESC(fm_port, "FM port # for " CRD_NAME " driver."); +module_param_array(irq, int, NULL, 0444); +MODULE_PARM_DESC(irq, "IRQ # for " CRD_NAME " driver."); +module_param_array(mpu_irq, int, NULL, 0444); +MODULE_PARM_DESC(mpu_irq, "MPU-401 IRQ # for " CRD_NAME " driver."); +module_param_array(dma1, int, NULL, 0444); +MODULE_PARM_DESC(dma1, "Playback DMA # for " CRD_NAME " driver."); +module_param_array(dma2, int, NULL, 0444); +MODULE_PARM_DESC(dma2, "Capture DMA # for " CRD_NAME " driver."); + +/* + * Generic SB DSP support routines + */ + +#define DSP_PORT_RESET 0x6 +#define DSP_PORT_READ 0xa +#define DSP_PORT_COMMAND 0xc +#define DSP_PORT_STATUS 0xc +#define DSP_PORT_DATA_AVAIL 0xe + +#define DSP_SIGNATURE 0xaa + +#define DSP_COMMAND_GET_VERSION 0xe1 + +static int __devinit dsp_get_byte(void __iomem *port, u8 *val) +{ + int loops = 1000; + + while (!(ioread8(port + DSP_PORT_DATA_AVAIL) & 0x80)) { + if (!loops--) + return -EIO; + cpu_relax(); + } + *val = ioread8(port + DSP_PORT_READ); + return 0; +} + +static int __devinit dsp_reset(void __iomem *port) +{ + u8 val; + + iowrite8(1, port + DSP_PORT_RESET); + udelay(10); + iowrite8(0, port + DSP_PORT_RESET); + + if (dsp_get_byte(port, &val) < 0 || val != DSP_SIGNATURE) + return -ENODEV; + + return 0; +} + +static int __devinit dsp_command(void __iomem *port, u8 cmd) +{ + int loops = 1000; + + while (ioread8(port + DSP_PORT_STATUS) & 0x80) { + if (!loops--) + return -EIO; + cpu_relax(); + } + iowrite8(cmd, port + DSP_PORT_COMMAND); + return 0; +} + +static int __devinit dsp_get_version(void __iomem *port, u8 *major, u8 *minor) +{ + int err; + + err = dsp_command(port, DSP_COMMAND_GET_VERSION); + if (err < 0) + return err; + + err = dsp_get_byte(port, major); + if (err < 0) + return err; + + err = dsp_get_byte(port, minor); + if (err < 0) + return err; + + return 0; +} + +/* + * Generic WSS support routines + */ + +#define WSS_CONFIG_DMA_0 (1 << 0) +#define WSS_CONFIG_DMA_1 (2 << 0) +#define WSS_CONFIG_DMA_3 (3 << 0) +#define WSS_CONFIG_DUPLEX (1 << 2) +#define WSS_CONFIG_IRQ_7 (1 << 3) +#define WSS_CONFIG_IRQ_9 (2 << 3) +#define WSS_CONFIG_IRQ_10 (3 << 3) +#define WSS_CONFIG_IRQ_11 (4 << 3) + +#define WSS_PORT_CONFIG 0 +#define WSS_PORT_SIGNATURE 3 + +#define WSS_SIGNATURE 4 + +static int __devinit wss_detect(void __iomem *wss_port) +{ + if ((ioread8(wss_port + WSS_PORT_SIGNATURE) & 0x3f) != WSS_SIGNATURE) + return -ENODEV; + + return 0; +} + +static void wss_set_config(void __iomem *wss_port, u8 wss_config) +{ + iowrite8(wss_config, wss_port + WSS_PORT_CONFIG); +} + +/* + * Aztech Sound Galaxy specifics + */ + +#define GALAXY_PORT_CONFIG 1024 +#define CONFIG_PORT_SET 4 + +#define DSP_COMMAND_GALAXY_8 8 +#define GALAXY_COMMAND_GET_TYPE 5 + +#define DSP_COMMAND_GALAXY_9 9 +#define GALAXY_COMMAND_WSSMODE 0 +#define GALAXY_COMMAND_SB8MODE 1 + +#define GALAXY_MODE_WSS GALAXY_COMMAND_WSSMODE +#define GALAXY_MODE_SB8 GALAXY_COMMAND_SB8MODE + +struct snd_galaxy { + void __iomem *port; + void __iomem *config_port; + void __iomem *wss_port; + u32 config; + struct resource *res_port; + struct resource *res_config_port; + struct resource *res_wss_port; +}; + +static u32 config[SNDRV_CARDS]; +static u8 wss_config[SNDRV_CARDS]; + +static int __devinit snd_galaxy_match(struct device *dev, unsigned int n) +{ + if (!enable[n]) + return 0; + + switch (port[n]) { + case SNDRV_AUTO_PORT: + dev_err(dev, "please specify port\n"); + return 0; + case 0x220: + config[n] |= GALAXY_CONFIG_SBA_220; + break; + case 0x240: + config[n] |= GALAXY_CONFIG_SBA_240; + break; + case 0x260: + config[n] |= GALAXY_CONFIG_SBA_260; + break; + case 0x280: + config[n] |= GALAXY_CONFIG_SBA_280; + break; + default: + dev_err(dev, "invalid port %#lx\n", port[n]); + return 0; + } + + switch (wss_port[n]) { + case SNDRV_AUTO_PORT: + dev_err(dev, "please specify wss_port\n"); + return 0; + case 0x530: + config[n] |= GALAXY_CONFIG_WSS_ENABLE | GALAXY_CONFIG_WSSA_530; + break; + case 0x604: + config[n] |= GALAXY_CONFIG_WSS_ENABLE | GALAXY_CONFIG_WSSA_604; + break; + case 0xe80: + config[n] |= GALAXY_CONFIG_WSS_ENABLE | GALAXY_CONFIG_WSSA_E80; + break; + case 0xf40: + config[n] |= GALAXY_CONFIG_WSS_ENABLE | GALAXY_CONFIG_WSSA_F40; + break; + default: + dev_err(dev, "invalid WSS port %#lx\n", wss_port[n]); + return 0; + } + + switch (irq[n]) { + case SNDRV_AUTO_IRQ: + dev_err(dev, "please specify irq\n"); + return 0; + case 7: + wss_config[n] |= WSS_CONFIG_IRQ_7; + break; + case 2: + irq[n] = 9; + case 9: + wss_config[n] |= WSS_CONFIG_IRQ_9; + break; + case 10: + wss_config[n] |= WSS_CONFIG_IRQ_10; + break; + case 11: + wss_config[n] |= WSS_CONFIG_IRQ_11; + break; + default: + dev_err(dev, "invalid IRQ %d\n", irq[n]); + return 0; + } + + switch (dma1[n]) { + case SNDRV_AUTO_DMA: + dev_err(dev, "please specify dma1\n"); + return 0; + case 0: + wss_config[n] |= WSS_CONFIG_DMA_0; + break; + case 1: + wss_config[n] |= WSS_CONFIG_DMA_1; + break; + case 3: + wss_config[n] |= WSS_CONFIG_DMA_3; + break; + default: + dev_err(dev, "invalid playback DMA %d\n", dma1[n]); + return 0; + } + + if (dma2[n] == SNDRV_AUTO_DMA || dma2[n] == dma1[n]) { + dma2[n] = -1; + goto mpu; + } + + wss_config[n] |= WSS_CONFIG_DUPLEX; + switch (dma2[n]) { + case 0: + break; + case 1: + if (dma1[n] == 0) + break; + default: + dev_err(dev, "invalid capture DMA %d\n", dma2[n]); + return 0; + } + +mpu: + switch (mpu_port[n]) { + case SNDRV_AUTO_PORT: + dev_warn(dev, "mpu_port not specified; not using MPU-401\n"); + mpu_port[n] = -1; + goto fm; + case 0x300: + config[n] |= GALAXY_CONFIG_MPU_ENABLE | GALAXY_CONFIG_MPUA_300; + break; + case 0x330: + config[n] |= GALAXY_CONFIG_MPU_ENABLE | GALAXY_CONFIG_MPUA_330; + break; + default: + dev_err(dev, "invalid MPU port %#lx\n", mpu_port[n]); + return 0; + } + + switch (mpu_irq[n]) { + case SNDRV_AUTO_IRQ: + dev_warn(dev, "mpu_irq not specified: using polling mode\n"); + mpu_irq[n] = -1; + break; + case 2: + mpu_irq[n] = 9; + case 9: + config[n] |= GALAXY_CONFIG_MPUIRQ_2; + break; +#ifdef AZT1605 + case 3: + config[n] |= GALAXY_CONFIG_MPUIRQ_3; + break; +#endif + case 5: + config[n] |= GALAXY_CONFIG_MPUIRQ_5; + break; + case 7: + config[n] |= GALAXY_CONFIG_MPUIRQ_7; + break; +#ifdef AZT2316 + case 10: + config[n] |= GALAXY_CONFIG_MPUIRQ_10; + break; +#endif + default: + dev_err(dev, "invalid MPU IRQ %d\n", mpu_irq[n]); + return 0; + } + + if (mpu_irq[n] == irq[n]) { + dev_err(dev, "cannot share IRQ between WSS and MPU-401\n"); + return 0; + } + +fm: + switch (fm_port[n]) { + case SNDRV_AUTO_PORT: + dev_warn(dev, "fm_port not specified: not using OPL3\n"); + fm_port[n] = -1; + break; + case 0x388: + break; + default: + dev_err(dev, "illegal FM port %#lx\n", fm_port[n]); + return 0; + } + + config[n] |= GALAXY_CONFIG_GAME_ENABLE; + return 1; +} + +static int __devinit galaxy_init(struct snd_galaxy *galaxy, u8 *type) +{ + u8 major; + u8 minor; + int err; + + err = dsp_reset(galaxy->port); + if (err < 0) + return err; + + err = dsp_get_version(galaxy->port, &major, &minor); + if (err < 0) + return err; + + if (major != GALAXY_DSP_MAJOR || minor != GALAXY_DSP_MINOR) + return -ENODEV; + + err = dsp_command(galaxy->port, DSP_COMMAND_GALAXY_8); + if (err < 0) + return err; + + err = dsp_command(galaxy->port, GALAXY_COMMAND_GET_TYPE); + if (err < 0) + return err; + + err = dsp_get_byte(galaxy->port, type); + if (err < 0) + return err; + + return 0; +} + +static int __devinit galaxy_set_mode(struct snd_galaxy *galaxy, u8 mode) +{ + int err; + + err = dsp_command(galaxy->port, DSP_COMMAND_GALAXY_9); + if (err < 0) + return err; + + err = dsp_command(galaxy->port, mode); + if (err < 0) + return err; + +#ifdef AZT1605 + /* + * Needed for MPU IRQ on AZT1605, but AZT2316 loses WSS again + */ + err = dsp_reset(galaxy->port); + if (err < 0) + return err; +#endif + + return 0; +} + +static void galaxy_set_config(struct snd_galaxy *galaxy, u32 config) +{ + u8 tmp = ioread8(galaxy->config_port + CONFIG_PORT_SET); + int i; + + iowrite8(tmp | 0x80, galaxy->config_port + CONFIG_PORT_SET); + for (i = 0; i < GALAXY_CONFIG_SIZE; i++) { + iowrite8(config, galaxy->config_port + i); + config >>= 8; + } + iowrite8(tmp & 0x7f, galaxy->config_port + CONFIG_PORT_SET); + msleep(10); +} + +static void __devinit galaxy_config(struct snd_galaxy *galaxy, u32 config) +{ + int i; + + for (i = GALAXY_CONFIG_SIZE; i; i--) { + u8 tmp = ioread8(galaxy->config_port + i - 1); + galaxy->config = (galaxy->config << 8) | tmp; + } + config |= galaxy->config & GALAXY_CONFIG_MASK; + galaxy_set_config(galaxy, config); +} + +static int __devinit galaxy_wss_config(struct snd_galaxy *galaxy, u8 wss_config) +{ + int err; + + err = wss_detect(galaxy->wss_port); + if (err < 0) + return err; + + wss_set_config(galaxy->wss_port, wss_config); + + err = galaxy_set_mode(galaxy, GALAXY_MODE_WSS); + if (err < 0) + return err; + + return 0; +} + +static void snd_galaxy_free(struct snd_card *card) +{ + struct snd_galaxy *galaxy = card->private_data; + + if (galaxy->wss_port) { + wss_set_config(galaxy->wss_port, 0); + ioport_unmap(galaxy->wss_port); + release_and_free_resource(galaxy->res_wss_port); + } + if (galaxy->config_port) { + galaxy_set_config(galaxy, galaxy->config); + ioport_unmap(galaxy->config_port); + release_and_free_resource(galaxy->res_config_port); + } + if (galaxy->port) { + ioport_unmap(galaxy->port); + release_and_free_resource(galaxy->res_port); + } +} + +static int __devinit snd_galaxy_probe(struct device *dev, unsigned int n) +{ + struct snd_galaxy *galaxy; + struct snd_wss *chip; + struct snd_card *card; + u8 type; + int err; + + err = snd_card_create(index[n], id[n], THIS_MODULE, sizeof *galaxy, + &card); + if (err < 0) + return err; + + snd_card_set_dev(card, dev); + + card->private_free = snd_galaxy_free; + galaxy = card->private_data; + + galaxy->res_port = request_region(port[n], 16, DRV_NAME); + if (!galaxy->res_port) { + dev_err(dev, "could not grab ports %#lx-%#lx\n", port[n], + port[n] + 15); + err = -EBUSY; + goto error; + } + galaxy->port = ioport_map(port[n], 16); + + err = galaxy_init(galaxy, &type); + if (err < 0) { + dev_err(dev, "did not find a Sound Galaxy at %#lx\n", port[n]); + goto error; + } + dev_info(dev, "Sound Galaxy (type %d) found at %#lx\n", type, port[n]); + + galaxy->res_config_port = request_region(port[n] + GALAXY_PORT_CONFIG, + 16, DRV_NAME); + if (!galaxy->res_config_port) { + dev_err(dev, "could not grab ports %#lx-%#lx\n", + port[n] + GALAXY_PORT_CONFIG, + port[n] + GALAXY_PORT_CONFIG + 15); + err = -EBUSY; + goto error; + } + galaxy->config_port = ioport_map(port[n] + GALAXY_PORT_CONFIG, 16); + + galaxy_config(galaxy, config[n]); + + galaxy->res_wss_port = request_region(wss_port[n], 4, DRV_NAME); + if (!galaxy->res_wss_port) { + dev_err(dev, "could not grab ports %#lx-%#lx\n", wss_port[n], + wss_port[n] + 3); + err = -EBUSY; + goto error; + } + galaxy->wss_port = ioport_map(wss_port[n], 4); + + err = galaxy_wss_config(galaxy, wss_config[n]); + if (err < 0) { + dev_err(dev, "could not configure WSS\n"); + goto error; + } + + strcpy(card->driver, DRV_NAME); + strcpy(card->shortname, DRV_NAME); + sprintf(card->longname, "%s at %#lx/%#lx, irq %d, dma %d/%d", + card->shortname, port[n], wss_port[n], irq[n], dma1[n], + dma2[n]); + + err = snd_wss_create(card, wss_port[n] + 4, -1, irq[n], dma1[n], + dma2[n], WSS_HW_DETECT, 0, &chip); + if (err < 0) + goto error; + + err = snd_wss_pcm(chip, 0, NULL); + if (err < 0) + goto error; + + err = snd_wss_mixer(chip); + if (err < 0) + goto error; + + err = snd_wss_timer(chip, 0, NULL); + if (err < 0) + goto error; + + if (mpu_port[n] >= 0) { + err = snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401, + mpu_port[n], 0, mpu_irq[n], + IRQF_DISABLED, NULL); + if (err < 0) + goto error; + } + + if (fm_port[n] >= 0) { + struct snd_opl3 *opl3; + + err = snd_opl3_create(card, fm_port[n], fm_port[n] + 2, + OPL3_HW_AUTO, 0, &opl3); + if (err < 0) { + dev_err(dev, "no OPL device at %#lx\n", fm_port[n]); + goto error; + } + err = snd_opl3_timer_new(opl3, 1, 2); + if (err < 0) + goto error; + + err = snd_opl3_hwdep_new(opl3, 0, 1, NULL); + if (err < 0) + goto error; + } + + err = snd_card_register(card); + if (err < 0) + goto error; + + dev_set_drvdata(dev, card); + return 0; + +error: + snd_card_free(card); + return err; +} + +static int __devexit snd_galaxy_remove(struct device *dev, unsigned int n) +{ + snd_card_free(dev_get_drvdata(dev)); + dev_set_drvdata(dev, NULL); + return 0; +} + +static struct isa_driver snd_galaxy_driver = { + .match = snd_galaxy_match, + .probe = snd_galaxy_probe, + .remove = __devexit_p(snd_galaxy_remove), + + .driver = { + .name = DEV_NAME + } +}; + +static int __init alsa_card_galaxy_init(void) +{ + return isa_register_driver(&snd_galaxy_driver, SNDRV_CARDS); +} + +static void __exit alsa_card_galaxy_exit(void) +{ + isa_unregister_driver(&snd_galaxy_driver); +} + +module_init(alsa_card_galaxy_init); +module_exit(alsa_card_galaxy_exit); -- cgit v1.1 From cbaa9f60d5d5c3af10f94e0d49789d5b82341a4a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ren=C3=A9=20Herman?= Date: Fri, 13 Aug 2010 10:43:48 +0200 Subject: ALSA: ISA: Remove snd-sgalaxy Its hardware is handled more fully by the new azt1605/azt2316 drivers. Signed-off-by: Rene Herman Signed-off-by: Takashi Iwai --- sound/isa/Kconfig | 10 -- sound/isa/Makefile | 2 - sound/isa/sgalaxy.c | 369 ---------------------------------------------------- 3 files changed, 381 deletions(-) delete mode 100644 sound/isa/sgalaxy.c (limited to 'sound') diff --git a/sound/isa/Kconfig b/sound/isa/Kconfig index f9aa13d..52064cf 100644 --- a/sound/isa/Kconfig +++ b/sound/isa/Kconfig @@ -377,16 +377,6 @@ config SND_SB16_CSP coprocessor can do variable tasks like various compression and decompression algorithms. -config SND_SGALAXY - tristate "Aztech Sound Galaxy" - select SND_WSS_LIB - help - Say Y here to include support for Aztech Sound Galaxy - soundcards. - - To compile this driver as a module, choose M here: the module - will be called snd-sgalaxy. - config SND_SSCAPE tristate "Ensoniq SoundScape driver" select SND_MPU401_UART diff --git a/sound/isa/Makefile b/sound/isa/Makefile index d2bd8f5..8d781e4 100644 --- a/sound/isa/Makefile +++ b/sound/isa/Makefile @@ -10,7 +10,6 @@ snd-cmi8330-objs := cmi8330.o snd-es18xx-objs := es18xx.o snd-opl3sa2-objs := opl3sa2.o snd-sc6000-objs := sc6000.o -snd-sgalaxy-objs := sgalaxy.o snd-sscape-objs := sscape.o # Toplevel Module Dependency @@ -21,7 +20,6 @@ obj-$(CONFIG_SND_CMI8330) += snd-cmi8330.o obj-$(CONFIG_SND_ES18XX) += snd-es18xx.o obj-$(CONFIG_SND_OPL3SA2) += snd-opl3sa2.o obj-$(CONFIG_SND_SC6000) += snd-sc6000.o -obj-$(CONFIG_SND_SGALAXY) += snd-sgalaxy.o obj-$(CONFIG_SND_SSCAPE) += snd-sscape.o obj-$(CONFIG_SND) += ad1816a/ ad1848/ cs423x/ es1688/ galaxy/ gus/ msnd/ opti9xx/ \ diff --git a/sound/isa/sgalaxy.c b/sound/isa/sgalaxy.c deleted file mode 100644 index 6fe27b9..0000000 --- a/sound/isa/sgalaxy.c +++ /dev/null @@ -1,369 +0,0 @@ -/* - * Driver for Aztech Sound Galaxy cards - * Copyright (c) by Christopher Butler -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#define SNDRV_LEGACY_FIND_FREE_IRQ -#define SNDRV_LEGACY_FIND_FREE_DMA -#include - -MODULE_AUTHOR("Christopher Butler "); -MODULE_DESCRIPTION("Aztech Sound Galaxy"); -MODULE_LICENSE("GPL"); -MODULE_SUPPORTED_DEVICE("{{Aztech Systems,Sound Galaxy}}"); - -static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ -static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ -static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE; /* Enable this card */ -static long sbport[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* 0x220,0x240 */ -static long wssport[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; /* 0x530,0xe80,0xf40,0x604 */ -static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; /* 7,9,10,11 */ -static int dma1[SNDRV_CARDS] = SNDRV_DEFAULT_DMA; /* 0,1,3 */ - -module_param_array(index, int, NULL, 0444); -MODULE_PARM_DESC(index, "Index value for Sound Galaxy soundcard."); -module_param_array(id, charp, NULL, 0444); -MODULE_PARM_DESC(id, "ID string for Sound Galaxy soundcard."); -module_param_array(sbport, long, NULL, 0444); -MODULE_PARM_DESC(sbport, "Port # for Sound Galaxy SB driver."); -module_param_array(wssport, long, NULL, 0444); -MODULE_PARM_DESC(wssport, "Port # for Sound Galaxy WSS driver."); -module_param_array(irq, int, NULL, 0444); -MODULE_PARM_DESC(irq, "IRQ # for Sound Galaxy driver."); -module_param_array(dma1, int, NULL, 0444); -MODULE_PARM_DESC(dma1, "DMA1 # for Sound Galaxy driver."); - -#define SGALAXY_AUXC_LEFT 18 -#define SGALAXY_AUXC_RIGHT 19 - -#define PFX "sgalaxy: " - -/* - - */ - -#define AD1848P1( port, x ) ( port + c_d_c_AD1848##x ) - -/* from lowlevel/sb/sb.c - to avoid having to allocate a struct snd_sb for the */ -/* short time we actually need it.. */ - -static int snd_sgalaxy_sbdsp_reset(unsigned long port) -{ - int i; - - outb(1, SBP1(port, RESET)); - udelay(10); - outb(0, SBP1(port, RESET)); - udelay(30); - for (i = 0; i < 1000 && !(inb(SBP1(port, DATA_AVAIL)) & 0x80); i++); - if (inb(SBP1(port, READ)) != 0xaa) { - snd_printd("sb_reset: failed at 0x%lx!!!\n", port); - return -ENODEV; - } - return 0; -} - -static int __devinit snd_sgalaxy_sbdsp_command(unsigned long port, - unsigned char val) -{ - int i; - - for (i = 10000; i; i--) - if ((inb(SBP1(port, STATUS)) & 0x80) == 0) { - outb(val, SBP1(port, COMMAND)); - return 1; - } - - return 0; -} - -static irqreturn_t snd_sgalaxy_dummy_interrupt(int irq, void *dev_id) -{ - return IRQ_NONE; -} - -static int __devinit snd_sgalaxy_setup_wss(unsigned long port, int irq, int dma) -{ - static int interrupt_bits[] = {-1, -1, -1, -1, -1, -1, -1, 0x08, -1, - 0x10, 0x18, 0x20, -1, -1, -1, -1}; - static int dma_bits[] = {1, 2, 0, 3}; - int tmp, tmp1; - - if ((tmp = inb(port + 3)) == 0xff) - { - snd_printdd("I/O address dead (0x%lx)\n", port); - return 0; - } -#if 0 - snd_printdd("WSS signature = 0x%x\n", tmp); -#endif - - if ((tmp & 0x3f) != 0x04 && - (tmp & 0x3f) != 0x0f && - (tmp & 0x3f) != 0x00) { - snd_printdd("No WSS signature detected on port 0x%lx\n", - port + 3); - return 0; - } - -#if 0 - snd_printdd(PFX "setting up IRQ/DMA for WSS\n"); -#endif - - /* initialize IRQ for WSS codec */ - tmp = interrupt_bits[irq % 16]; - if (tmp < 0) - return -EINVAL; - - if (request_irq(irq, snd_sgalaxy_dummy_interrupt, IRQF_DISABLED, "sgalaxy", NULL)) { - snd_printk(KERN_ERR "sgalaxy: can't grab irq %d\n", irq); - return -EIO; - } - - outb(tmp | 0x40, port); - tmp1 = dma_bits[dma % 4]; - outb(tmp | tmp1, port); - - free_irq(irq, NULL); - - return 0; -} - -static int __devinit snd_sgalaxy_detect(int dev, int irq, int dma) -{ -#if 0 - snd_printdd(PFX "switching to WSS mode\n"); -#endif - - /* switch to WSS mode */ - snd_sgalaxy_sbdsp_reset(sbport[dev]); - - snd_sgalaxy_sbdsp_command(sbport[dev], 9); - snd_sgalaxy_sbdsp_command(sbport[dev], 0); - - udelay(400); - return snd_sgalaxy_setup_wss(wssport[dev], irq, dma); -} - -static struct snd_kcontrol_new snd_sgalaxy_controls[] = { -WSS_DOUBLE("Aux Playback Switch", 0, - SGALAXY_AUXC_LEFT, SGALAXY_AUXC_RIGHT, 7, 7, 1, 1), -WSS_DOUBLE("Aux Playback Volume", 0, - SGALAXY_AUXC_LEFT, SGALAXY_AUXC_RIGHT, 0, 0, 31, 0) -}; - -static int __devinit snd_sgalaxy_mixer(struct snd_wss *chip) -{ - struct snd_card *card = chip->card; - struct snd_ctl_elem_id id1, id2; - unsigned int idx; - int err; - - memset(&id1, 0, sizeof(id1)); - memset(&id2, 0, sizeof(id2)); - id1.iface = id2.iface = SNDRV_CTL_ELEM_IFACE_MIXER; - /* reassign AUX0 to LINE */ - strcpy(id1.name, "Aux Playback Switch"); - strcpy(id2.name, "Line Playback Switch"); - if ((err = snd_ctl_rename_id(card, &id1, &id2)) < 0) - return err; - strcpy(id1.name, "Aux Playback Volume"); - strcpy(id2.name, "Line Playback Volume"); - if ((err = snd_ctl_rename_id(card, &id1, &id2)) < 0) - return err; - /* reassign AUX1 to FM */ - strcpy(id1.name, "Aux Playback Switch"); id1.index = 1; - strcpy(id2.name, "FM Playback Switch"); - if ((err = snd_ctl_rename_id(card, &id1, &id2)) < 0) - return err; - strcpy(id1.name, "Aux Playback Volume"); - strcpy(id2.name, "FM Playback Volume"); - if ((err = snd_ctl_rename_id(card, &id1, &id2)) < 0) - return err; - /* build AUX2 input */ - for (idx = 0; idx < ARRAY_SIZE(snd_sgalaxy_controls); idx++) { - err = snd_ctl_add(card, - snd_ctl_new1(&snd_sgalaxy_controls[idx], chip)); - if (err < 0) - return err; - } - return 0; -} - -static int __devinit snd_sgalaxy_match(struct device *devptr, unsigned int dev) -{ - if (!enable[dev]) - return 0; - if (sbport[dev] == SNDRV_AUTO_PORT) { - snd_printk(KERN_ERR PFX "specify SB port\n"); - return 0; - } - if (wssport[dev] == SNDRV_AUTO_PORT) { - snd_printk(KERN_ERR PFX "specify WSS port\n"); - return 0; - } - return 1; -} - -static int __devinit snd_sgalaxy_probe(struct device *devptr, unsigned int dev) -{ - static int possible_irqs[] = {7, 9, 10, 11, -1}; - static int possible_dmas[] = {1, 3, 0, -1}; - int err, xirq, xdma1; - struct snd_card *card; - struct snd_wss *chip; - - err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card); - if (err < 0) - return err; - - xirq = irq[dev]; - if (xirq == SNDRV_AUTO_IRQ) { - if ((xirq = snd_legacy_find_free_irq(possible_irqs)) < 0) { - snd_printk(KERN_ERR PFX "unable to find a free IRQ\n"); - err = -EBUSY; - goto _err; - } - } - xdma1 = dma1[dev]; - if (xdma1 == SNDRV_AUTO_DMA) { - if ((xdma1 = snd_legacy_find_free_dma(possible_dmas)) < 0) { - snd_printk(KERN_ERR PFX "unable to find a free DMA\n"); - err = -EBUSY; - goto _err; - } - } - - if ((err = snd_sgalaxy_detect(dev, xirq, xdma1)) < 0) - goto _err; - - err = snd_wss_create(card, wssport[dev] + 4, -1, - xirq, xdma1, -1, - WSS_HW_DETECT, 0, &chip); - if (err < 0) - goto _err; - card->private_data = chip; - - err = snd_wss_pcm(chip, 0, NULL); - if (err < 0) { - snd_printdd(PFX "error creating new WSS PCM device\n"); - goto _err; - } - err = snd_wss_mixer(chip); - if (err < 0) { - snd_printdd(PFX "error creating new WSS mixer\n"); - goto _err; - } - if ((err = snd_sgalaxy_mixer(chip)) < 0) { - snd_printdd(PFX "the mixer rewrite failed\n"); - goto _err; - } - - strcpy(card->driver, "Sound Galaxy"); - strcpy(card->shortname, "Sound Galaxy"); - sprintf(card->longname, "Sound Galaxy at 0x%lx, irq %d, dma %d", - wssport[dev], xirq, xdma1); - - snd_card_set_dev(card, devptr); - - if ((err = snd_card_register(card)) < 0) - goto _err; - - dev_set_drvdata(devptr, card); - return 0; - - _err: - snd_card_free(card); - return err; -} - -static int __devexit snd_sgalaxy_remove(struct device *devptr, unsigned int dev) -{ - snd_card_free(dev_get_drvdata(devptr)); - dev_set_drvdata(devptr, NULL); - return 0; -} - -#ifdef CONFIG_PM -static int snd_sgalaxy_suspend(struct device *pdev, unsigned int n, - pm_message_t state) -{ - struct snd_card *card = dev_get_drvdata(pdev); - struct snd_wss *chip = card->private_data; - - snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); - chip->suspend(chip); - return 0; -} - -static int snd_sgalaxy_resume(struct device *pdev, unsigned int n) -{ - struct snd_card *card = dev_get_drvdata(pdev); - struct snd_wss *chip = card->private_data; - - chip->resume(chip); - snd_wss_out(chip, SGALAXY_AUXC_LEFT, chip->image[SGALAXY_AUXC_LEFT]); - snd_wss_out(chip, SGALAXY_AUXC_RIGHT, chip->image[SGALAXY_AUXC_RIGHT]); - - snd_power_change_state(card, SNDRV_CTL_POWER_D0); - return 0; -} -#endif - -#define DEV_NAME "sgalaxy" - -static struct isa_driver snd_sgalaxy_driver = { - .match = snd_sgalaxy_match, - .probe = snd_sgalaxy_probe, - .remove = __devexit_p(snd_sgalaxy_remove), -#ifdef CONFIG_PM - .suspend = snd_sgalaxy_suspend, - .resume = snd_sgalaxy_resume, -#endif - .driver = { - .name = DEV_NAME - }, -}; - -static int __init alsa_card_sgalaxy_init(void) -{ - return isa_register_driver(&snd_sgalaxy_driver, SNDRV_CARDS); -} - -static void __exit alsa_card_sgalaxy_exit(void) -{ - isa_unregister_driver(&snd_sgalaxy_driver); -} - -module_init(alsa_card_sgalaxy_init) -module_exit(alsa_card_sgalaxy_exit) -- cgit v1.1 From 4f4e8f69895c8696a4bcc751817d4b186023ac44 Mon Sep 17 00:00:00 2001 From: Paul Zimmerman Date: Fri, 13 Aug 2010 12:42:07 -0700 Subject: ALSA: usb: USB3 SuperSpeed sound support This is V2 of the patch, after feedback from Clemens and Daniel. This patch adds SuperSpeed support to the USB drivers under sound/. It adds tests for USB_SPEED_SUPER to the appropriate places that check for the USB speed. This patch has been tested with our SS USB3 device emulating a set of Yamaha speakers and a Logitech microphone, but with the descriptors modified to add USB3 support. It has also been tested with the real speakers and microphone, to make sure that USB2 devices still work. Signed-off-by: Paul Zimmerman Cc: Clemens Ladisch Cc: Daniel Mack Cc: Greg Kroah-Hartman Signed-off-by: Takashi Iwai --- sound/usb/card.c | 31 +++++++++++++++++++++++-------- sound/usb/helper.c | 17 +++++++++++------ sound/usb/midi.c | 9 ++++++++- sound/usb/pcm.c | 4 ++-- sound/usb/proc.c | 2 +- sound/usb/urb.c | 2 +- 6 files changed, 46 insertions(+), 19 deletions(-) (limited to 'sound') diff --git a/sound/usb/card.c b/sound/usb/card.c index 9feb00c..498a2d8 100644 --- a/sound/usb/card.c +++ b/sound/usb/card.c @@ -299,9 +299,13 @@ static int snd_usb_audio_create(struct usb_device *dev, int idx, *rchip = NULL; - if (snd_usb_get_speed(dev) != USB_SPEED_LOW && - snd_usb_get_speed(dev) != USB_SPEED_FULL && - snd_usb_get_speed(dev) != USB_SPEED_HIGH) { + switch (snd_usb_get_speed(dev)) { + case USB_SPEED_LOW: + case USB_SPEED_FULL: + case USB_SPEED_HIGH: + case USB_SPEED_SUPER: + break; + default: snd_printk(KERN_ERR "unknown device speed %d\n", snd_usb_get_speed(dev)); return -ENXIO; } @@ -377,11 +381,22 @@ static int snd_usb_audio_create(struct usb_device *dev, int idx, if (len < sizeof(card->longname)) usb_make_path(dev, card->longname + len, sizeof(card->longname) - len); - strlcat(card->longname, - snd_usb_get_speed(dev) == USB_SPEED_LOW ? ", low speed" : - snd_usb_get_speed(dev) == USB_SPEED_FULL ? ", full speed" : - ", high speed", - sizeof(card->longname)); + switch (snd_usb_get_speed(dev)) { + case USB_SPEED_LOW: + strlcat(card->longname, ", low speed", sizeof(card->longname)); + break; + case USB_SPEED_FULL: + strlcat(card->longname, ", full speed", sizeof(card->longname)); + break; + case USB_SPEED_HIGH: + strlcat(card->longname, ", high speed", sizeof(card->longname)); + break; + case USB_SPEED_SUPER: + strlcat(card->longname, ", super speed", sizeof(card->longname)); + break; + default: + break; + } snd_usb_audio_create_proc(chip); diff --git a/sound/usb/helper.c b/sound/usb/helper.c index d48d6f8..f280c19 100644 --- a/sound/usb/helper.c +++ b/sound/usb/helper.c @@ -103,11 +103,16 @@ int snd_usb_ctl_msg(struct usb_device *dev, unsigned int pipe, __u8 request, unsigned char snd_usb_parse_datainterval(struct snd_usb_audio *chip, struct usb_host_interface *alts) { - if (snd_usb_get_speed(chip->dev) == USB_SPEED_HIGH && - get_endpoint(alts, 0)->bInterval >= 1 && - get_endpoint(alts, 0)->bInterval <= 4) - return get_endpoint(alts, 0)->bInterval - 1; - else - return 0; + switch (snd_usb_get_speed(chip->dev)) { + case USB_SPEED_HIGH: + case USB_SPEED_SUPER: + if (get_endpoint(alts, 0)->bInterval >= 1 && + get_endpoint(alts, 0)->bInterval <= 4) + return get_endpoint(alts, 0)->bInterval - 1; + break; + default: + break; + } + return 0; } diff --git a/sound/usb/midi.c b/sound/usb/midi.c index b9c2bc6..156cd07 100644 --- a/sound/usb/midi.c +++ b/sound/usb/midi.c @@ -834,7 +834,14 @@ static void snd_usbmidi_us122l_output(struct snd_usb_midi_out_endpoint *ep, if (!ep->ports[0].active) return; - count = snd_usb_get_speed(ep->umidi->dev) == USB_SPEED_HIGH ? 1 : 2; + switch (snd_usb_get_speed(ep->umidi->dev)) { + case USB_SPEED_HIGH: + case USB_SPEED_SUPER: + count = 1; + break; + default: + count = 2; + } count = snd_rawmidi_transmit(ep->ports[0].substream, urb->transfer_buffer, count); diff --git a/sound/usb/pcm.c b/sound/usb/pcm.c index 4568298..ebd09ac 100644 --- a/sound/usb/pcm.c +++ b/sound/usb/pcm.c @@ -467,7 +467,7 @@ static int hw_check_valid_format(struct snd_usb_substream *subs, return 0; } /* check whether the period time is >= the data packet interval */ - if (snd_usb_get_speed(subs->dev) == USB_SPEED_HIGH) { + if (snd_usb_get_speed(subs->dev) != USB_SPEED_FULL) { ptime = 125 * (1 << fp->datainterval); if (ptime > pt->max || (ptime == pt->max && pt->openmax)) { hwc_debug(" > check: ptime %u > max %u\n", ptime, pt->max); @@ -735,7 +735,7 @@ static int setup_hw_info(struct snd_pcm_runtime *runtime, struct snd_usb_substre } param_period_time_if_needed = SNDRV_PCM_HW_PARAM_PERIOD_TIME; - if (snd_usb_get_speed(subs->dev) != USB_SPEED_HIGH) + if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL) /* full speed devices have fixed data packet interval */ ptmin = 1000; if (ptmin == 1000) diff --git a/sound/usb/proc.c b/sound/usb/proc.c index f5e3f35..3c650ab 100644 --- a/sound/usb/proc.c +++ b/sound/usb/proc.c @@ -107,7 +107,7 @@ static void proc_dump_substream_formats(struct snd_usb_substream *subs, struct s } snd_iprintf(buffer, "\n"); } - if (snd_usb_get_speed(subs->dev) == USB_SPEED_HIGH) + if (snd_usb_get_speed(subs->dev) != USB_SPEED_FULL) snd_iprintf(buffer, " Data packet interval: %d us\n", 125 * (1 << fp->datainterval)); // snd_iprintf(buffer, " Max Packet Size = %d\n", fp->maxpacksize); diff --git a/sound/usb/urb.c b/sound/usb/urb.c index de607d4..8deeaad 100644 --- a/sound/usb/urb.c +++ b/sound/usb/urb.c @@ -244,7 +244,7 @@ int snd_usb_init_substream_urbs(struct snd_usb_substream *subs, else subs->curpacksize = maxsize; - if (snd_usb_get_speed(subs->dev) == USB_SPEED_HIGH) + if (snd_usb_get_speed(subs->dev) != USB_SPEED_FULL) packs_per_ms = 8 >> subs->datainterval; else packs_per_ms = 1; -- cgit v1.1 From a5ba6beb839cfa288960c92cd2668a2601c24dda Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Mon, 16 Aug 2010 08:08:48 +0200 Subject: ALSA: riptide - Fix detection / load of firmware files The detection and loading of firmeware on riptide driver has been broken due to rewrite of some codes, checking the presense wrongly. This patch fixes the logic again. Reference: kernel bug 16596 https://bugzilla.kernel.org/show_bug.cgi?id=16596 Cc: Signed-off-by: Takashi Iwai --- sound/pci/riptide/riptide.c | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) (limited to 'sound') diff --git a/sound/pci/riptide/riptide.c b/sound/pci/riptide/riptide.c index f64fb7d..ad5202e 100644 --- a/sound/pci/riptide/riptide.c +++ b/sound/pci/riptide/riptide.c @@ -1224,15 +1224,14 @@ static int try_to_load_firmware(struct cmdif *cif, struct snd_riptide *chip) firmware.firmware.ASIC, firmware.firmware.CODEC, firmware.firmware.AUXDSP, firmware.firmware.PROG); + if (!chip) + return 1; + for (i = 0; i < FIRMWARE_VERSIONS; i++) { if (!memcmp(&firmware_versions[i], &firmware, sizeof(firmware))) - break; - } - if (i >= FIRMWARE_VERSIONS) - return 0; /* no match */ + return 1; /* OK */ - if (!chip) - return 1; /* OK */ + } snd_printdd("Writing Firmware\n"); if (!chip->fw_entry) { -- cgit v1.1 From c3e68fad88143fd1fe8fe640207fb19c0f087dbc Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Mon, 16 Aug 2010 10:15:57 +0200 Subject: ALSA: hda - Add quirk for Dell Vostro 1220 model=dell-vostro is needed for Dell Vostro 1220 with Coexnat 5067. Reference: Novell bnc#631066 https://bugzilla.novell.com/show_bug.cgi?id=631066 Cc: Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_conexant.c | 1 + 1 file changed, 1 insertion(+) (limited to 'sound') diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c index 31b5d9e..c424952 100644 --- a/sound/pci/hda/patch_conexant.c +++ b/sound/pci/hda/patch_conexant.c @@ -3049,6 +3049,7 @@ static struct snd_pci_quirk cxt5066_cfg_tbl[] = { SND_PCI_QUIRK(0x1028, 0x02f5, "Dell", CXT5066_DELL_LAPTOP), SND_PCI_QUIRK(0x152d, 0x0833, "OLPC XO-1.5", CXT5066_OLPC_XO_1_5), + SND_PCI_QUIRK(0x1028, 0x02d8, "Dell Vostro", CXT5066_DELL_VOSTO), SND_PCI_QUIRK(0x1028, 0x0402, "Dell Vostro", CXT5066_DELL_VOSTO), SND_PCI_QUIRK(0x1028, 0x0408, "Dell Inspiron One 19T", CXT5066_IDEAPAD), SND_PCI_QUIRK(0x1179, 0xff50, "Toshiba Satellite P500-PSPGSC-01800T", CXT5066_OLPC_XO_1_5), -- cgit v1.1 From c69aefabe004d24e6eedf83b6f253647f77dfc43 Mon Sep 17 00:00:00 2001 From: Kailang Yang Date: Tue, 17 Aug 2010 10:39:22 +0200 Subject: ALSA: hda - Fix ALC680 base model capture - Fix capture mixer elements for ALC680 base model - Support auto change ADC for recording from MIC - Cancel capture source assigned in auto mode. Signed-off-by: Kailang Yang Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 176 ++++++++++++++++++++++++++++++++++-------- 1 file changed, 144 insertions(+), 32 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index 2cd1ae8..a4dd045 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -19030,6 +19030,7 @@ static int patch_alc888(struct hda_codec *codec) /* * ALC680 support */ +#define ALC680_DIGIN_NID ALC880_DIGIN_NID #define ALC680_DIGOUT_NID ALC880_DIGOUT_NID #define alc680_modes alc260_modes @@ -19044,23 +19045,93 @@ static hda_nid_t alc680_adc_nids[3] = { 0x07, 0x08, 0x09 }; +/* + * Analog capture ADC cgange + */ +static int alc680_capture_pcm_prepare(struct hda_pcm_stream *hinfo, + struct hda_codec *codec, + unsigned int stream_tag, + unsigned int format, + struct snd_pcm_substream *substream) +{ + struct alc_spec *spec = codec->spec; + struct auto_pin_cfg *cfg = &spec->autocfg; + unsigned int pre_mic, pre_line; + + pre_mic = snd_hda_jack_detect(codec, cfg->input_pins[AUTO_PIN_MIC]); + pre_line = snd_hda_jack_detect(codec, cfg->input_pins[AUTO_PIN_LINE]); + + spec->cur_adc_stream_tag = stream_tag; + spec->cur_adc_format = format; + + if (pre_mic || pre_line) { + if (pre_mic) + snd_hda_codec_setup_stream(codec, 0x08, stream_tag, 0, + format); + else + snd_hda_codec_setup_stream(codec, 0x09, stream_tag, 0, + format); + } else + snd_hda_codec_setup_stream(codec, 0x07, stream_tag, 0, format); + return 0; +} + +static int alc680_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, + struct hda_codec *codec, + struct snd_pcm_substream *substream) +{ + snd_hda_codec_cleanup_stream(codec, 0x07); + snd_hda_codec_cleanup_stream(codec, 0x08); + snd_hda_codec_cleanup_stream(codec, 0x09); + return 0; +} + +static struct hda_pcm_stream alc680_pcm_analog_auto_capture = { + .substreams = 1, /* can be overridden */ + .channels_min = 2, + .channels_max = 2, + /* NID is set in alc_build_pcms */ + .ops = { + .prepare = alc680_capture_pcm_prepare, + .cleanup = alc680_capture_pcm_cleanup + }, +}; + static struct snd_kcontrol_new alc680_base_mixer[] = { /* output mixer control */ HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT), HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT), HDA_CODEC_VOLUME("Headphone Playback Volume", 0x4, 0x0, HDA_OUTPUT), HDA_CODEC_MUTE("Headphone Playback Switch", 0x16, 0x0, HDA_OUTPUT), + HDA_CODEC_VOLUME("Int Mic Boost", 0x12, 0, HDA_INPUT), HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT), + HDA_CODEC_VOLUME("Line In Boost", 0x19, 0, HDA_INPUT), { } }; -static struct snd_kcontrol_new alc680_capture_mixer[] = { - HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT), - HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT), - HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x08, 0x0, HDA_INPUT), - HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x08, 0x0, HDA_INPUT), - HDA_CODEC_VOLUME_IDX("Capture Volume", 2, 0x09, 0x0, HDA_INPUT), - HDA_CODEC_MUTE_IDX("Capture Switch", 2, 0x09, 0x0, HDA_INPUT), +static struct hda_bind_ctls alc680_bind_cap_vol = { + .ops = &snd_hda_bind_vol, + .values = { + HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT), + HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT), + HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT), + 0 + }, +}; + +static struct hda_bind_ctls alc680_bind_cap_switch = { + .ops = &snd_hda_bind_sw, + .values = { + HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT), + HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT), + HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT), + 0 + }, +}; + +static struct snd_kcontrol_new alc680_master_capture_mixer[] = { + HDA_BIND_VOL("Capture Volume", &alc680_bind_cap_vol), + HDA_BIND_SW("Capture Switch", &alc680_bind_cap_switch), { } /* end */ }; @@ -19068,25 +19139,73 @@ static struct snd_kcontrol_new alc680_capture_mixer[] = { * generic initialization of ADC, input mixers and output mixers */ static struct hda_verb alc680_init_verbs[] = { - /* Unmute DAC0-1 and set vol = 0 */ - {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, - {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, - {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO}, + {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, + {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, + {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, - {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, - {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40}, - {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0}, - {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24}, - {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20}, + {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, + {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, + {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, + {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, + {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80}, + {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, + + {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, + {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, + { } }; +/* toggle speaker-output according to the hp-jack state */ +static void alc680_base_setup(struct hda_codec *codec) +{ + struct alc_spec *spec = codec->spec; + + spec->autocfg.hp_pins[0] = 0x16; + spec->autocfg.speaker_pins[0] = 0x14; + spec->autocfg.speaker_pins[1] = 0x15; + spec->autocfg.input_pins[AUTO_PIN_MIC] = 0x18; + spec->autocfg.input_pins[AUTO_PIN_LINE] = 0x19; +} + +static void alc680_rec_autoswitch(struct hda_codec *codec) +{ + struct alc_spec *spec = codec->spec; + struct auto_pin_cfg *cfg = &spec->autocfg; + unsigned int present; + hda_nid_t new_adc; + + present = snd_hda_jack_detect(codec, cfg->input_pins[AUTO_PIN_MIC]); + + new_adc = present ? 0x8 : 0x7; + __snd_hda_codec_cleanup_stream(codec, !present ? 0x8 : 0x7, 1); + snd_hda_codec_setup_stream(codec, new_adc, + spec->cur_adc_stream_tag, 0, + spec->cur_adc_format); + +} + +static void alc680_unsol_event(struct hda_codec *codec, + unsigned int res) +{ + if ((res >> 26) == ALC880_HP_EVENT) + alc_automute_amp(codec); + if ((res >> 26) == ALC880_MIC_EVENT) + alc680_rec_autoswitch(codec); +} + +static void alc680_inithook(struct hda_codec *codec) +{ + alc_automute_amp(codec); + alc680_rec_autoswitch(codec); +} + /* create input playback/capture controls for the given pin */ static int alc680_new_analog_output(struct alc_spec *spec, hda_nid_t nid, const char *ctlname, int idx) @@ -19197,13 +19316,7 @@ static void alc680_auto_init_hp_out(struct hda_codec *codec) #define alc680_pcm_analog_capture alc880_pcm_analog_capture #define alc680_pcm_analog_alt_capture alc880_pcm_analog_alt_capture #define alc680_pcm_digital_playback alc880_pcm_digital_playback - -static struct hda_input_mux alc680_capture_source = { - .num_items = 1, - .items = { - { "Mic", 0x0 }, - }, -}; +#define alc680_pcm_digital_capture alc880_pcm_digital_capture /* * BIOS auto configuration @@ -19218,6 +19331,7 @@ static int alc680_parse_auto_config(struct hda_codec *codec) alc680_ignore); if (err < 0) return err; + if (!spec->autocfg.line_outs) { if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) { spec->multiout.max_channels = 2; @@ -19239,8 +19353,6 @@ static int alc680_parse_auto_config(struct hda_codec *codec) add_mixer(spec, spec->kctls.list); add_verb(spec, alc680_init_verbs); - spec->num_mux_defs = 1; - spec->input_mux = &alc680_capture_source; err = alc_auto_add_mic_boost(codec); if (err < 0) @@ -19279,17 +19391,17 @@ static struct snd_pci_quirk alc680_cfg_tbl[] = { static struct alc_config_preset alc680_presets[] = { [ALC680_BASE] = { .mixers = { alc680_base_mixer }, - .cap_mixer = alc680_capture_mixer, + .cap_mixer = alc680_master_capture_mixer, .init_verbs = { alc680_init_verbs }, .num_dacs = ARRAY_SIZE(alc680_dac_nids), .dac_nids = alc680_dac_nids, - .num_adc_nids = ARRAY_SIZE(alc680_adc_nids), - .adc_nids = alc680_adc_nids, - .hp_nid = 0x04, .dig_out_nid = ALC680_DIGOUT_NID, .num_channel_mode = ARRAY_SIZE(alc680_modes), .channel_mode = alc680_modes, - .input_mux = &alc680_capture_source, + .unsol_event = alc680_unsol_event, + .setup = alc680_base_setup, + .init_hook = alc680_inithook, + }, }; @@ -19333,9 +19445,9 @@ static int patch_alc680(struct hda_codec *codec) setup_preset(codec, &alc680_presets[board_config]); spec->stream_analog_playback = &alc680_pcm_analog_playback; - spec->stream_analog_capture = &alc680_pcm_analog_capture; - spec->stream_analog_alt_capture = &alc680_pcm_analog_alt_capture; + spec->stream_analog_capture = &alc680_pcm_analog_auto_capture; spec->stream_digital_playback = &alc680_pcm_digital_playback; + spec->stream_digital_capture = &alc680_pcm_digital_capture; if (!spec->adc_nids) { spec->adc_nids = alc680_adc_nids; -- cgit v1.1 From 56385a12d9bb9e173751f74b6c430742018cafc0 Mon Sep 17 00:00:00 2001 From: Jaroslav Kysela Date: Wed, 18 Aug 2010 14:08:17 +0200 Subject: ALSA: emu10k1 - delay the PCM interrupts (add pcm_irq_delay parameter) With some hardware combinations, the PCM interrupts are acknowledged before the period boundary from the emu10k1 chip. The midlevel PCM code gets confused and the playback stream is interrupted. It seems that the interrupt processing shift by 2 samples is enough to fix this issue. This default value does not harm other, non-affected hardware. More information: Kernel bugzilla bug#16300 [A copmile warning fixed by tiwai] Signed-off-by: Jaroslav Kysela Cc: Signed-off-by: Takashi Iwai --- sound/core/pcm_native.c | 4 ++++ sound/pci/emu10k1/emu10k1.c | 4 ++++ sound/pci/emu10k1/emupcm.c | 30 ++++++++++++++++++++++++++---- sound/pci/emu10k1/memory.c | 4 +++- 4 files changed, 37 insertions(+), 5 deletions(-) (limited to 'sound') diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c index a3b2a64..134fc6c 100644 --- a/sound/core/pcm_native.c +++ b/sound/core/pcm_native.c @@ -978,6 +978,10 @@ static int snd_pcm_do_pause(struct snd_pcm_substream *substream, int push) { if (substream->runtime->trigger_master != substream) return 0; + /* some drivers might use hw_ptr to recover from the pause - + update the hw_ptr now */ + if (push) + snd_pcm_update_hw_ptr(substream); /* The jiffies check in snd_pcm_update_hw_ptr*() is done by * a delta betwen the current jiffies, this gives a large enough * delta, effectively to skip the check once. diff --git a/sound/pci/emu10k1/emu10k1.c b/sound/pci/emu10k1/emu10k1.c index 4203782..aff8387 100644 --- a/sound/pci/emu10k1/emu10k1.c +++ b/sound/pci/emu10k1/emu10k1.c @@ -52,6 +52,7 @@ static int max_synth_voices[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 64}; static int max_buffer_size[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 128}; static int enable_ir[SNDRV_CARDS]; static uint subsystem[SNDRV_CARDS]; /* Force card subsystem model */ +static uint delay_pcm_irq[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 2}; module_param_array(index, int, NULL, 0444); MODULE_PARM_DESC(index, "Index value for the EMU10K1 soundcard."); @@ -73,6 +74,8 @@ module_param_array(enable_ir, bool, NULL, 0444); MODULE_PARM_DESC(enable_ir, "Enable IR."); module_param_array(subsystem, uint, NULL, 0444); MODULE_PARM_DESC(subsystem, "Force card subsystem model."); +module_param_array(delay_pcm_irq, uint, NULL, 0444); +MODULE_PARM_DESC(delay_pcm_irq, "Delay PCM interrupt by specified number of samples (default 0)."); /* * Class 0401: 1102:0008 (rev 00) Subsystem: 1102:1001 -> Audigy2 Value Model:SB0400 */ @@ -127,6 +130,7 @@ static int __devinit snd_card_emu10k1_probe(struct pci_dev *pci, &emu)) < 0) goto error; card->private_data = emu; + emu->delay_pcm_irq = delay_pcm_irq[dev] & 0x1f; if ((err = snd_emu10k1_pcm(emu, 0, NULL)) < 0) goto error; if ((err = snd_emu10k1_pcm_mic(emu, 1, NULL)) < 0) diff --git a/sound/pci/emu10k1/emupcm.c b/sound/pci/emu10k1/emupcm.c index 55b83ef..622bace 100644 --- a/sound/pci/emu10k1/emupcm.c +++ b/sound/pci/emu10k1/emupcm.c @@ -332,7 +332,7 @@ static void snd_emu10k1_pcm_init_voice(struct snd_emu10k1 *emu, evoice->epcm->ccca_start_addr = start_addr + ccis; if (extra) { start_addr += ccis; - end_addr += ccis; + end_addr += ccis + emu->delay_pcm_irq; } if (stereo && !extra) { snd_emu10k1_ptr_write(emu, CPF, voice, CPF_STEREO_MASK); @@ -360,7 +360,9 @@ static void snd_emu10k1_pcm_init_voice(struct snd_emu10k1 *emu, /* Assumption that PT is already 0 so no harm overwriting */ snd_emu10k1_ptr_write(emu, PTRX, voice, (send_amount[0] << 8) | send_amount[1]); snd_emu10k1_ptr_write(emu, DSL, voice, end_addr | (send_amount[3] << 24)); - snd_emu10k1_ptr_write(emu, PSST, voice, start_addr | (send_amount[2] << 24)); + snd_emu10k1_ptr_write(emu, PSST, voice, + (start_addr + (extra ? emu->delay_pcm_irq : 0)) | + (send_amount[2] << 24)); if (emu->card_capabilities->emu_model) pitch_target = PITCH_48000; /* Disable interpolators on emu1010 card */ else @@ -732,6 +734,23 @@ static void snd_emu10k1_playback_stop_voice(struct snd_emu10k1 *emu, struct snd_ snd_emu10k1_ptr_write(emu, IP, voice, 0); } +static inline void snd_emu10k1_playback_mangle_extra(struct snd_emu10k1 *emu, + struct snd_emu10k1_pcm *epcm, + struct snd_pcm_substream *substream, + struct snd_pcm_runtime *runtime) +{ + unsigned int ptr, period_pos; + + /* try to sychronize the current position for the interrupt + source voice */ + period_pos = runtime->status->hw_ptr - runtime->hw_ptr_interrupt; + period_pos %= runtime->period_size; + ptr = snd_emu10k1_ptr_read(emu, CCCA, epcm->extra->number); + ptr &= ~0x00ffffff; + ptr |= epcm->ccca_start_addr + period_pos; + snd_emu10k1_ptr_write(emu, CCCA, epcm->extra->number, ptr); +} + static int snd_emu10k1_playback_trigger(struct snd_pcm_substream *substream, int cmd) { @@ -753,6 +772,8 @@ static int snd_emu10k1_playback_trigger(struct snd_pcm_substream *substream, /* follow thru */ case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: case SNDRV_PCM_TRIGGER_RESUME: + if (cmd == SNDRV_PCM_TRIGGER_PAUSE_RELEASE) + snd_emu10k1_playback_mangle_extra(emu, epcm, substream, runtime); mix = &emu->pcm_mixer[substream->number]; snd_emu10k1_playback_prepare_voice(emu, epcm->voices[0], 1, 0, mix); snd_emu10k1_playback_prepare_voice(emu, epcm->voices[1], 0, 0, mix); @@ -869,8 +890,9 @@ static snd_pcm_uframes_t snd_emu10k1_playback_pointer(struct snd_pcm_substream * #endif /* printk(KERN_DEBUG - "ptr = 0x%x, buffer_size = 0x%x, period_size = 0x%x\n", - ptr, runtime->buffer_size, runtime->period_size); + "ptr = 0x%lx, buffer_size = 0x%lx, period_size = 0x%lx\n", + (long)ptr, (long)runtime->buffer_size, + (long)runtime->period_size); */ return ptr; } diff --git a/sound/pci/emu10k1/memory.c b/sound/pci/emu10k1/memory.c index ffb1ddb..957a311 100644 --- a/sound/pci/emu10k1/memory.c +++ b/sound/pci/emu10k1/memory.c @@ -310,8 +310,10 @@ snd_emu10k1_alloc_pages(struct snd_emu10k1 *emu, struct snd_pcm_substream *subst if (snd_BUG_ON(!hdr)) return NULL; + idx = runtime->period_size >= runtime->buffer_size ? + (emu->delay_pcm_irq * 2) : 0; mutex_lock(&hdr->block_mutex); - blk = search_empty(emu, runtime->dma_bytes); + blk = search_empty(emu, runtime->dma_bytes + idx); if (blk == NULL) { mutex_unlock(&hdr->block_mutex); return NULL; -- cgit v1.1 From bd76af0f87f7a1815b311bde269a3f18305b3169 Mon Sep 17 00:00:00 2001 From: Jaroslav Kysela Date: Wed, 18 Aug 2010 14:16:54 +0200 Subject: ALSA: pcm midlevel code - add time check for double interrupt acknowledge The current code in pcm_lib.c do all checks using only the position in the ring buffer. Unfortunately, where the interrupts gets delayed or merged into one, we need another timing source to check when the buffer size boundary overlaps to avoid the wrong updating of the ring buffer pointers. This code uses jiffies to check the right time window without any performance impact. Signed-off-by: Jaroslav Kysela Signed-off-by: Takashi Iwai --- sound/core/pcm_lib.c | 14 +++++++++----- sound/core/pcm_native.c | 2 ++ 2 files changed, 11 insertions(+), 5 deletions(-) (limited to 'sound') diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c index e23e0e7..a1707cc 100644 --- a/sound/core/pcm_lib.c +++ b/sound/core/pcm_lib.c @@ -334,11 +334,15 @@ static int snd_pcm_update_hw_ptr0(struct snd_pcm_substream *substream, /* delta = "expected next hw_ptr" for in_interrupt != 0 */ delta = runtime->hw_ptr_interrupt + runtime->period_size; if (delta > new_hw_ptr) { - hw_base += runtime->buffer_size; - if (hw_base >= runtime->boundary) - hw_base = 0; - new_hw_ptr = hw_base + pos; - goto __delta; + /* check for double acknowledged interrupts */ + hdelta = jiffies - runtime->hw_ptr_jiffies; + if (hdelta > runtime->hw_ptr_buffer_jiffies/2) { + hw_base += runtime->buffer_size; + if (hw_base >= runtime->boundary) + hw_base = 0; + new_hw_ptr = hw_base + pos; + goto __delta; + } } } /* new_hw_ptr might be lower than old_hw_ptr in case when */ diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c index 134fc6c..e2e7389 100644 --- a/sound/core/pcm_native.c +++ b/sound/core/pcm_native.c @@ -864,6 +864,8 @@ static void snd_pcm_post_start(struct snd_pcm_substream *substream, int state) struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_trigger_tstamp(substream); runtime->hw_ptr_jiffies = jiffies; + runtime->hw_ptr_buffer_jiffies = (runtime->buffer_size * HZ) / + runtime->rate; runtime->status->state = state; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && runtime->silence_size > 0) -- cgit v1.1 From 4d8ec5f3b65dd64fa785192dc7ab2807916a05b2 Mon Sep 17 00:00:00 2001 From: Charles Chin Date: Thu, 19 Aug 2010 08:06:16 +0200 Subject: ALSA: hda - Add support for IDT 92HD89XX codecs Just added new codec ids. These are almost compatible with existing ones. Signed-off-by: Charles Chin Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_sigmatel.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+) (limited to 'sound') diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c index f3f861b..95148e5 100644 --- a/sound/pci/hda/patch_sigmatel.c +++ b/sound/pci/hda/patch_sigmatel.c @@ -6303,6 +6303,21 @@ static struct hda_codec_preset snd_hda_preset_sigmatel[] = { { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx }, { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx }, { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx }, + { .id = 0x111d76c0, .name = "92HD89C3", .patch = patch_stac92hd73xx }, + { .id = 0x111d76c1, .name = "92HD89C2", .patch = patch_stac92hd73xx }, + { .id = 0x111d76c2, .name = "92HD89C1", .patch = patch_stac92hd73xx }, + { .id = 0x111d76c3, .name = "92HD89B3", .patch = patch_stac92hd73xx }, + { .id = 0x111d76c4, .name = "92HD89B2", .patch = patch_stac92hd73xx }, + { .id = 0x111d76c5, .name = "92HD89B1", .patch = patch_stac92hd73xx }, + { .id = 0x111d76c6, .name = "92HD89E3", .patch = patch_stac92hd73xx }, + { .id = 0x111d76c7, .name = "92HD89E2", .patch = patch_stac92hd73xx }, + { .id = 0x111d76c8, .name = "92HD89E1", .patch = patch_stac92hd73xx }, + { .id = 0x111d76c9, .name = "92HD89D3", .patch = patch_stac92hd73xx }, + { .id = 0x111d76ca, .name = "92HD89D2", .patch = patch_stac92hd73xx }, + { .id = 0x111d76cb, .name = "92HD89D1", .patch = patch_stac92hd73xx }, + { .id = 0x111d76cc, .name = "92HD89F3", .patch = patch_stac92hd73xx }, + { .id = 0x111d76cd, .name = "92HD89F2", .patch = patch_stac92hd73xx }, + { .id = 0x111d76ce, .name = "92HD89F1", .patch = patch_stac92hd73xx }, {} /* terminator */ }; -- cgit v1.1 From 274714f55c023c683a6b2deedfb2209a9457f4ec Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Thu, 19 Aug 2010 08:11:53 +0200 Subject: ALSA: hda - Fix build error with CONFIG_PROC_FS=n hdmi_eld_update_pcm_info() must be always compiled in. Signed-off-by: Takashi Iwai --- sound/pci/hda/hda_eld.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/hda_eld.c b/sound/pci/hda/hda_eld.c index 803b298..26c3ade 100644 --- a/sound/pci/hda/hda_eld.c +++ b/sound/pci/hda/hda_eld.c @@ -596,6 +596,8 @@ void snd_hda_eld_proc_free(struct hda_codec *codec, struct hdmi_eld *eld) } EXPORT_SYMBOL_HDA(snd_hda_eld_proc_free); +#endif /* CONFIG_PROC_FS */ + /* update PCM info based on ELD */ void hdmi_eld_update_pcm_info(struct hdmi_eld *eld, struct hda_pcm_stream *pcm, struct hda_pcm_stream *codec_pars) @@ -644,5 +646,3 @@ void hdmi_eld_update_pcm_info(struct hdmi_eld *eld, struct hda_pcm_stream *pcm, pcm->maxbps = min(pcm->maxbps, codec_pars->maxbps); } EXPORT_SYMBOL_HDA(hdmi_eld_update_pcm_info); - -#endif /* CONFIG_PROC_FS */ -- cgit v1.1 From 9c77b846ec8b4e0c7107dd7f820172462dc84a61 Mon Sep 17 00:00:00 2001 From: Daniel T Chen Date: Wed, 18 Aug 2010 19:33:43 -0400 Subject: ALSA: intel8x0: Mute External Amplifier by default for ThinkPad X31 BugLink: https://bugs.launchpad.net/bugs/619439 This ThinkPad model needs External Amplifier muted for audible playback, so set the inv_eapd quirk for it. Reported-and-tested-by: Dennis Bell Cc: Signed-off-by: Daniel T Chen Signed-off-by: Takashi Iwai --- sound/pci/intel8x0.c | 6 ++++++ 1 file changed, 6 insertions(+) (limited to 'sound') diff --git a/sound/pci/intel8x0.c b/sound/pci/intel8x0.c index 6433e65..4677492 100644 --- a/sound/pci/intel8x0.c +++ b/sound/pci/intel8x0.c @@ -1776,6 +1776,12 @@ static struct ac97_quirk ac97_quirks[] __devinitdata = { }, { .subvendor = 0x1014, + .subdevice = 0x0534, + .name = "ThinkPad X31", + .type = AC97_TUNE_INV_EAPD + }, + { + .subvendor = 0x1014, .subdevice = 0x1f00, .name = "MS-9128", .type = AC97_TUNE_ALC_JACK -- cgit v1.1 From d7d28bc29f4ea7c2d23ed002a9973c64a92bcdb8 Mon Sep 17 00:00:00 2001 From: Jaroslav Kysela Date: Wed, 18 Aug 2010 14:16:54 +0200 Subject: ALSA: pcm midlevel code - add time check for double interrupt acknowledge The current code in pcm_lib.c do all checks using only the position in the ring buffer. Unfortunately, where the interrupts gets delayed or merged into one, we need another timing source to check when the buffer size boundary overlaps to avoid the wrong updating of the ring buffer pointers. This code uses jiffies to check the right time window without any performance impact. Signed-off-by: Jaroslav Kysela --- sound/core/pcm_lib.c | 14 +++++++++----- sound/core/pcm_native.c | 2 ++ 2 files changed, 11 insertions(+), 5 deletions(-) (limited to 'sound') diff --git a/sound/core/pcm_lib.c b/sound/core/pcm_lib.c index e9d98be..d6ecca2 100644 --- a/sound/core/pcm_lib.c +++ b/sound/core/pcm_lib.c @@ -329,11 +329,15 @@ static int snd_pcm_update_hw_ptr0(struct snd_pcm_substream *substream, /* delta = "expected next hw_ptr" for in_interrupt != 0 */ delta = runtime->hw_ptr_interrupt + runtime->period_size; if (delta > new_hw_ptr) { - hw_base += runtime->buffer_size; - if (hw_base >= runtime->boundary) - hw_base = 0; - new_hw_ptr = hw_base + pos; - goto __delta; + /* check for double acknowledged interrupts */ + hdelta = jiffies - runtime->hw_ptr_jiffies; + if (hdelta > runtime->hw_ptr_buffer_jiffies/2) { + hw_base += runtime->buffer_size; + if (hw_base >= runtime->boundary) + hw_base = 0; + new_hw_ptr = hw_base + pos; + goto __delta; + } } } /* new_hw_ptr might be lower than old_hw_ptr in case when */ diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c index 303ac04..2d2e1b6 100644 --- a/sound/core/pcm_native.c +++ b/sound/core/pcm_native.c @@ -867,6 +867,8 @@ static void snd_pcm_post_start(struct snd_pcm_substream *substream, int state) struct snd_pcm_runtime *runtime = substream->runtime; snd_pcm_trigger_tstamp(substream); runtime->hw_ptr_jiffies = jiffies; + runtime->hw_ptr_buffer_jiffies = (runtime->buffer_size * HZ) / + runtime->rate; runtime->status->state = state; if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && runtime->silence_size > 0) -- cgit v1.1 From 4f34760787c3751a3146f0eecdc79c3e97b94962 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Fri, 20 Aug 2010 09:41:59 +0200 Subject: ALSA: hda - Fix conflict of sticky PCM parameter in HDMI codecs Intel and Nvidia HDMI codec drivers have own implementations of sticky PCM parameters. Now HD-audio core part already has it, thus both setups conflict. The fix is simply remove the part in patch_intelhdmi.c and patch_nvhdmi.c and simply call snd_hda_codec_setup_stream() as usual. Reported-and-tested-by: Stephen Warren Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_hdmi.c | 21 +-------------------- sound/pci/hda/patch_intelhdmi.c | 8 -------- sound/pci/hda/patch_nvhdmi.c | 8 -------- 3 files changed, 1 insertion(+), 36 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_hdmi.c b/sound/pci/hda/patch_hdmi.c index 2bc0f07..afd6022 100644 --- a/sound/pci/hda/patch_hdmi.c +++ b/sound/pci/hda/patch_hdmi.c @@ -707,8 +707,6 @@ static int hdmi_setup_stream(struct hda_codec *codec, hda_nid_t nid, u32 stream_tag, int format) { struct hdmi_spec *spec = codec->spec; - int tag; - int fmt; int pinctl; int new_pinctl = 0; int i; @@ -745,24 +743,7 @@ static int hdmi_setup_stream(struct hda_codec *codec, hda_nid_t nid, return -EINVAL; } - tag = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0) >> 4; - fmt = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_STREAM_FORMAT, 0); - - snd_printdd("hdmi_setup_stream: " - "NID=0x%x, %sstream=0x%x, %sformat=0x%x\n", - nid, - tag == stream_tag ? "" : "new-", - stream_tag, - fmt == format ? "" : "new-", - format); - - if (tag != stream_tag) - snd_hda_codec_write(codec, nid, 0, - AC_VERB_SET_CHANNEL_STREAMID, - stream_tag << 4); - if (fmt != format) - snd_hda_codec_write(codec, nid, 0, - AC_VERB_SET_STREAM_FORMAT, format); + snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format); return 0; } diff --git a/sound/pci/hda/patch_intelhdmi.c b/sound/pci/hda/patch_intelhdmi.c index d382d3c..36a9b83 100644 --- a/sound/pci/hda/patch_intelhdmi.c +++ b/sound/pci/hda/patch_intelhdmi.c @@ -69,20 +69,12 @@ static int intel_hdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo, return hdmi_setup_stream(codec, hinfo->nid, stream_tag, format); } -static int intel_hdmi_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, - struct hda_codec *codec, - struct snd_pcm_substream *substream) -{ - return 0; -} - static struct hda_pcm_stream intel_hdmi_pcm_playback = { .substreams = 1, .channels_min = 2, .ops = { .open = hdmi_pcm_open, .prepare = intel_hdmi_playback_pcm_prepare, - .cleanup = intel_hdmi_playback_pcm_cleanup, }, }; diff --git a/sound/pci/hda/patch_nvhdmi.c b/sound/pci/hda/patch_nvhdmi.c index f636870..69b950d 100644 --- a/sound/pci/hda/patch_nvhdmi.c +++ b/sound/pci/hda/patch_nvhdmi.c @@ -326,13 +326,6 @@ static int nvhdmi_dig_playback_pcm_prepare_8ch(struct hda_pcm_stream *hinfo, return 0; } -static int nvhdmi_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, - struct hda_codec *codec, - struct snd_pcm_substream *substream) -{ - return 0; -} - static int nvhdmi_dig_playback_pcm_prepare_2ch(struct hda_pcm_stream *hinfo, struct hda_codec *codec, unsigned int stream_tag, @@ -350,7 +343,6 @@ static struct hda_pcm_stream nvhdmi_pcm_digital_playback_8ch_89 = { .ops = { .open = hdmi_pcm_open, .prepare = nvhdmi_dig_playback_pcm_prepare_8ch_89, - .cleanup = nvhdmi_playback_pcm_cleanup, }, }; -- cgit v1.1 From 3f50ac6a0ec80a83a1a033fe5004fb319ad72db7 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Fri, 20 Aug 2010 09:44:36 +0200 Subject: ALSA: hda - Fix stream and channel-ids codec-bus wide The new sticky PCM parameter introduced the delayed clean-ups of stream- and channel-id tags. In the current implementation, this check (adding dirty flag) and actual clean-ups are done only for the codec chip. However, with HD-audio architecture, multiple codecs can be on a single bus, and the controller assign stream- and channel-ids in the bus-wide. In this patch, the stream-id and channel-id are checked over all codecs connected to the corresponding bus. Together with it, the mutex is moved to struct hda_bus, as this becomes also bus-wide. Reported-and-tested-by: Stephen Warren Signed-off-by: Takashi Iwai --- sound/pci/hda/hda_codec.c | 33 ++++++++++++++++++++------------- sound/pci/hda/hda_codec.h | 2 +- 2 files changed, 21 insertions(+), 14 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c index dd8fb86..3827092 100644 --- a/sound/pci/hda/hda_codec.c +++ b/sound/pci/hda/hda_codec.c @@ -589,6 +589,7 @@ int /*__devinit*/ snd_hda_bus_new(struct snd_card *card, bus->ops = temp->ops; mutex_init(&bus->cmd_mutex); + mutex_init(&bus->prepare_mutex); INIT_LIST_HEAD(&bus->codec_list); snprintf(bus->workq_name, sizeof(bus->workq_name), @@ -1068,7 +1069,6 @@ int /*__devinit*/ snd_hda_codec_new(struct hda_bus *bus, codec->addr = codec_addr; mutex_init(&codec->spdif_mutex); mutex_init(&codec->control_mutex); - mutex_init(&codec->prepare_mutex); init_hda_cache(&codec->amp_cache, sizeof(struct hda_amp_info)); init_hda_cache(&codec->cmd_cache, sizeof(struct hda_cache_head)); snd_array_init(&codec->mixers, sizeof(struct hda_nid_item), 32); @@ -1213,6 +1213,7 @@ void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid, u32 stream_tag, int channel_id, int format) { + struct hda_codec *c; struct hda_cvt_setup *p; unsigned int oldval, newval; int i; @@ -1253,10 +1254,12 @@ void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid, p->dirty = 0; /* make other inactive cvts with the same stream-tag dirty */ - for (i = 0; i < codec->cvt_setups.used; i++) { - p = snd_array_elem(&codec->cvt_setups, i); - if (!p->active && p->stream_tag == stream_tag) - p->dirty = 1; + list_for_each_entry(c, &codec->bus->codec_list, list) { + for (i = 0; i < c->cvt_setups.used; i++) { + p = snd_array_elem(&c->cvt_setups, i); + if (!p->active && p->stream_tag == stream_tag) + p->dirty = 1; + } } } EXPORT_SYMBOL_HDA(snd_hda_codec_setup_stream); @@ -1306,12 +1309,16 @@ static void really_cleanup_stream(struct hda_codec *codec, /* clean up the all conflicting obsolete streams */ static void purify_inactive_streams(struct hda_codec *codec) { + struct hda_codec *c; int i; - for (i = 0; i < codec->cvt_setups.used; i++) { - struct hda_cvt_setup *p = snd_array_elem(&codec->cvt_setups, i); - if (p->dirty) - really_cleanup_stream(codec, p); + list_for_each_entry(c, &codec->bus->codec_list, list) { + for (i = 0; i < c->cvt_setups.used; i++) { + struct hda_cvt_setup *p; + p = snd_array_elem(&c->cvt_setups, i); + if (p->dirty) + really_cleanup_stream(c, p); + } } } @@ -3502,11 +3509,11 @@ int snd_hda_codec_prepare(struct hda_codec *codec, struct snd_pcm_substream *substream) { int ret; - mutex_lock(&codec->prepare_mutex); + mutex_lock(&codec->bus->prepare_mutex); ret = hinfo->ops.prepare(hinfo, codec, stream, format, substream); if (ret >= 0) purify_inactive_streams(codec); - mutex_unlock(&codec->prepare_mutex); + mutex_unlock(&codec->bus->prepare_mutex); return ret; } EXPORT_SYMBOL_HDA(snd_hda_codec_prepare); @@ -3515,9 +3522,9 @@ void snd_hda_codec_cleanup(struct hda_codec *codec, struct hda_pcm_stream *hinfo, struct snd_pcm_substream *substream) { - mutex_lock(&codec->prepare_mutex); + mutex_lock(&codec->bus->prepare_mutex); hinfo->ops.cleanup(hinfo, codec, substream); - mutex_unlock(&codec->prepare_mutex); + mutex_unlock(&codec->bus->prepare_mutex); } EXPORT_SYMBOL_HDA(snd_hda_codec_cleanup); diff --git a/sound/pci/hda/hda_codec.h b/sound/pci/hda/hda_codec.h index 4303353..62c7022 100644 --- a/sound/pci/hda/hda_codec.h +++ b/sound/pci/hda/hda_codec.h @@ -648,6 +648,7 @@ struct hda_bus { struct hda_codec *caddr_tbl[HDA_MAX_CODEC_ADDRESS + 1]; struct mutex cmd_mutex; + struct mutex prepare_mutex; /* unsolicited event queue */ struct hda_bus_unsolicited *unsol; @@ -826,7 +827,6 @@ struct hda_codec { struct mutex spdif_mutex; struct mutex control_mutex; - struct mutex prepare_mutex; unsigned int spdif_status; /* IEC958 status bits */ unsigned short spdif_ctls; /* SPDIF control bits */ unsigned int spdif_in_enable; /* SPDIF input enable? */ -- cgit v1.1 From 23b224d9d42a111ce451e4300304415a0ba5da75 Mon Sep 17 00:00:00 2001 From: Garnet MacPhee Date: Sat, 21 Aug 2010 14:37:34 -0600 Subject: ALSA: ice1712: Add support for Edirol DA-2496 This device is similar to the M-Audio Delta 1010LT in that it uses the AK4524VF ADC/DAC, but it does not use the CS8427 for SPDIF. The SPDIF appears to be set up correctly, but I am not able to test it as I do not have any devices that use it. This patch makes the ADC/DAC's and the hardware mixer visible to apps such as alsamixer and envy24control. Signed-off-by: Garnet MacPhee Signed-off-by: Takashi Iwai --- sound/pci/ice1712/delta.c | 10 ++++++++++ sound/pci/ice1712/delta.h | 4 +++- 2 files changed, 13 insertions(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/pci/ice1712/delta.c b/sound/pci/ice1712/delta.c index d216362..712c171 100644 --- a/sound/pci/ice1712/delta.c +++ b/sound/pci/ice1712/delta.c @@ -563,6 +563,7 @@ static int __devinit snd_ice1712_delta_init(struct snd_ice1712 *ice) case ICE1712_SUBDEVICE_DELTA1010E: case ICE1712_SUBDEVICE_DELTA1010LT: case ICE1712_SUBDEVICE_MEDIASTATION: + case ICE1712_SUBDEVICE_EDIROLDA2496: ice->num_total_dacs = 8; ice->num_total_adcs = 8; break; @@ -635,6 +636,7 @@ static int __devinit snd_ice1712_delta_init(struct snd_ice1712 *ice) err = snd_ice1712_akm4xxx_init(ak, &akm_delta410, &akm_delta410_priv, ice); break; case ICE1712_SUBDEVICE_DELTA1010LT: + case ICE1712_SUBDEVICE_EDIROLDA2496: err = snd_ice1712_akm4xxx_init(ak, &akm_delta1010lt, &akm_delta1010lt_priv, ice); break; case ICE1712_SUBDEVICE_DELTA66: @@ -734,6 +736,7 @@ static int __devinit snd_ice1712_delta_add_controls(struct snd_ice1712 *ice) case ICE1712_SUBDEVICE_DELTA66: case ICE1712_SUBDEVICE_VX442: case ICE1712_SUBDEVICE_DELTA66E: + case ICE1712_SUBDEVICE_EDIROLDA2496: err = snd_ice1712_akm4xxx_build_controls(ice); if (err < 0) return err; @@ -813,5 +816,12 @@ struct snd_ice1712_card_info snd_ice1712_delta_cards[] __devinitdata = { .chip_init = snd_ice1712_delta_init, .build_controls = snd_ice1712_delta_add_controls, }, + { + .subvendor = ICE1712_SUBDEVICE_EDIROLDA2496, + .name = "Edirol DA2496", + .model = "da2496", + .chip_init = snd_ice1712_delta_init, + .build_controls = snd_ice1712_delta_add_controls, + }, { } /* terminator */ }; diff --git a/sound/pci/ice1712/delta.h b/sound/pci/ice1712/delta.h index f7f14df..1a0ac6c 100644 --- a/sound/pci/ice1712/delta.h +++ b/sound/pci/ice1712/delta.h @@ -34,7 +34,8 @@ "{MidiMan M Audio,Delta 410},"\ "{MidiMan M Audio,Audiophile 24/96},"\ "{Digigram,VX442},"\ - "{Lionstracs,Mediastation}," + "{Lionstracs,Mediastation},"\ + "{Edirol,DA2496}," #define ICE1712_SUBDEVICE_DELTA1010 0x121430d6 #define ICE1712_SUBDEVICE_DELTA1010E 0xff1430d6 @@ -47,6 +48,7 @@ #define ICE1712_SUBDEVICE_DELTA1010LT 0x12143bd6 #define ICE1712_SUBDEVICE_VX442 0x12143cd6 #define ICE1712_SUBDEVICE_MEDIASTATION 0x694c0100 +#define ICE1712_SUBDEVICE_EDIROLDA2496 0xce164010 /* entry point */ extern struct snd_ice1712_card_info snd_ice1712_delta_cards[]; -- cgit v1.1 From 6f0ef6ea1d11ef242de584e345355b0de756fcb2 Mon Sep 17 00:00:00 2001 From: Jerone Young Date: Mon, 23 Aug 2010 08:34:36 +0200 Subject: ALSA: hda - Add support for Lenovo S10-3t This patch adds quirk for the Lenovo S10-3t so the headphone & microphone jacks will now work. Signed-off-by: Jerone Young Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_conexant.c | 1 + 1 file changed, 1 insertion(+) (limited to 'sound') diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c index c424952..5cdb80e 100644 --- a/sound/pci/hda/patch_conexant.c +++ b/sound/pci/hda/patch_conexant.c @@ -3059,6 +3059,7 @@ static struct snd_pci_quirk cxt5066_cfg_tbl[] = { SND_PCI_QUIRK(0x17aa, 0x21b4, "Thinkpad Edge", CXT5066_IDEAPAD), SND_PCI_QUIRK(0x17aa, 0x215e, "Lenovo Thinkpad", CXT5066_THINKPAD), SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo G series", CXT5066_IDEAPAD), + SND_PCI_QUIRK(0x17aa, 0x390a, "Lenovo S10-3t", CXT5066_IDEAPAD), SND_PCI_QUIRK(0x17aa, 0x3938, "Lenovo G series (AMD)", CXT5066_IDEAPAD), SND_PCI_QUIRK(0x17aa, 0x3a0d, "ideapad", CXT5066_IDEAPAD), {} -- cgit v1.1 From dbbcbc073ad3132bfbc410b11546b2fb4bdf2568 Mon Sep 17 00:00:00 2001 From: David Henningsson Date: Mon, 23 Aug 2010 08:14:35 +0200 Subject: ALSA: hda - Add Sony VAIO quirk for ALC269 The attached patch enables playback on a Sony VAIO machine. BugLink: http://launchpad.net/bugs/618271 Signed-off-by: David Henningsson Cc: Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 1 + 1 file changed, 1 insertion(+) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index a4dd045..627bf99 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -14467,6 +14467,7 @@ static const struct alc_fixup alc269_fixups[] = { static struct snd_pci_quirk alc269_fixup_tbl[] = { SND_PCI_QUIRK(0x104d, 0x9071, "Sony VAIO", ALC269_FIXUP_SONY_VAIO), + SND_PCI_QUIRK(0x104d, 0x9077, "Sony VAIO", ALC269_FIXUP_SONY_VAIO), {} }; -- cgit v1.1 From 60f1deb595c08687a96157a6a3ce08ef34142362 Mon Sep 17 00:00:00 2001 From: Eliot Blennerhassett Date: Sat, 28 Aug 2010 19:52:24 +1200 Subject: ALSA: asihpi - Return hw error directly from oustream_write. If hw error is ignored, status is updated with invalid info. Signed-off-by: Eliot Blennerhassett Signed-off-by: Takashi Iwai --- sound/pci/asihpi/hpi6205.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) (limited to 'sound') diff --git a/sound/pci/asihpi/hpi6205.c b/sound/pci/asihpi/hpi6205.c index 3b44134..22c5fc6 100644 --- a/sound/pci/asihpi/hpi6205.c +++ b/sound/pci/asihpi/hpi6205.c @@ -941,8 +941,7 @@ static void outstream_host_buffer_free(struct hpi_adapter_obj *pao, } -static u32 outstream_get_space_available(struct hpi_hostbuffer_status - *status) +static u32 outstream_get_space_available(struct hpi_hostbuffer_status *status) { return status->size_in_bytes - (status->host_index - status->dSP_index); @@ -987,6 +986,10 @@ static void outstream_write(struct hpi_adapter_obj *pao, /* write it */ phm->function = HPI_OSTREAM_WRITE; hw_message(pao, phm, phr); + + if (phr->error) + return; + /* update status information that the DSP would typically * update (and will update next time the DSP * buffer update task reads data from the host BBM buffer) -- cgit v1.1 From 3182c8a72b31414e043184a97b0d5d3c0d590168 Mon Sep 17 00:00:00 2001 From: Akinobu Mita Date: Sat, 28 Aug 2010 13:25:33 +0900 Subject: sound: oss: fix uninitialized spinlock The spinlock lock in sound_timer.c is used without initialization. Signed-off-by: Akinobu Mita Signed-off-by: Takashi Iwai --- sound/oss/sound_timer.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/oss/sound_timer.c b/sound/oss/sound_timer.c index f0f0c19..48cda6c 100644 --- a/sound/oss/sound_timer.c +++ b/sound/oss/sound_timer.c @@ -26,7 +26,7 @@ static unsigned long prev_event_time; static volatile unsigned long usecs_per_tmr; /* Length of the current interval */ static struct sound_lowlev_timer *tmr; -static spinlock_t lock; +static DEFINE_SPINLOCK(lock); static unsigned long tmr2ticks(int tmr_value) { -- cgit v1.1 From 7a28826ac73d31a379d93785d8fbd24ab492b0bd Mon Sep 17 00:00:00 2001 From: Dan Carpenter Date: Fri, 27 Aug 2010 22:02:15 +0200 Subject: ALSA: pcm: add more format names There were some new formats added in commit 15c0cee6c809 "ALSA: pcm: Define G723 3-bit and 5-bit formats". That commit increased SNDRV_PCM_FORMAT_LAST as well. My concern is that there are a couple places which do: for (i = 0; i < SNDRV_PCM_FORMAT_LAST; i++) { if (dummy->pcm_hw.formats & (1ULL << i)) snd_iprintf(buffer, " %s", snd_pcm_format_name(i)); } I haven't tested these but it looks like if "i" were equal to SNDRV_PCM_FORMAT_G723_24 or higher then we might read past the end of the array. Signed-off-by: Dan Carpenter Signed-off-by: Takashi Iwai --- sound/core/pcm.c | 6 ++++++ 1 file changed, 6 insertions(+) (limited to 'sound') diff --git a/sound/core/pcm.c b/sound/core/pcm.c index cbe815d..204af48 100644 --- a/sound/core/pcm.c +++ b/sound/core/pcm.c @@ -203,10 +203,16 @@ static char *snd_pcm_format_names[] = { FORMAT(S18_3BE), FORMAT(U18_3LE), FORMAT(U18_3BE), + FORMAT(G723_24), + FORMAT(G723_24_1B), + FORMAT(G723_40), + FORMAT(G723_40_1B), }; const char *snd_pcm_format_name(snd_pcm_format_t format) { + if (format >= ARRAY_SIZE(snd_pcm_format_names)) + return "Unknown"; return snd_pcm_format_names[format]; } EXPORT_SYMBOL_GPL(snd_pcm_format_name); -- cgit v1.1 From 73413b120d5d6eb6c98451bbc19acf43e0e300ae Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Mon, 30 Aug 2010 09:39:57 +0200 Subject: ALSA: hda - embed alc_fixup contents into struct definitions Instead of defining each content as a separate struct, put all into the definition of struct alc_fixup arrays so that reader doesn't go back to see the definition again. Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 70 ++++++++++++++++++------------------------- 1 file changed, 29 insertions(+), 41 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index 627bf99..50e0c82 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -6799,14 +6799,12 @@ enum { PINFIX_HP_DC5750, }; -static struct alc_pincfg alc260_hp_dc5750_pinfix[] = { - { 0x11, 0x90130110 }, /* speaker */ - { } -}; - static const struct alc_fixup alc260_fixups[] = { [PINFIX_HP_DC5750] = { - .pins = alc260_hp_dc5750_pinfix + .pins = (const struct alc_pincfg[]) { + { 0x11, 0x90130110 }, /* speaker */ + { } + } }, }; @@ -10452,24 +10450,20 @@ enum { PINFIX_PB_M5210, }; -static struct alc_pincfg alc882_abit_aw9d_pinfix[] = { - { 0x15, 0x01080104 }, /* side */ - { 0x16, 0x01011012 }, /* rear */ - { 0x17, 0x01016011 }, /* clfe */ - { } -}; - -static const struct hda_verb pb_m5210_verbs[] = { - { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 }, - {} -}; - static const struct alc_fixup alc882_fixups[] = { [PINFIX_ABIT_AW9D_MAX] = { - .pins = alc882_abit_aw9d_pinfix + .pins = (const struct alc_pincfg[]) { + { 0x15, 0x01080104 }, /* side */ + { 0x16, 0x01011012 }, /* rear */ + { 0x17, 0x01016011 }, /* clfe */ + { } + } }, [PINFIX_PB_M5210] = { - .verbs = pb_m5210_verbs + .verbs = (const struct hda_verb[]) { + { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 }, + {} + } }, }; @@ -14454,14 +14448,12 @@ enum { ALC269_FIXUP_SONY_VAIO, }; -static const struct hda_verb alc269_sony_vaio_fixup_verbs[] = { - {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD}, - {} -}; - static const struct alc_fixup alc269_fixups[] = { [ALC269_FIXUP_SONY_VAIO] = { - .verbs = alc269_sony_vaio_fixup_verbs + .verbs = (const struct hda_verb[]) { + {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD}, + {} + } }, }; @@ -15819,15 +15811,13 @@ enum { PINFIX_FSC_AMILO_PI1505, }; -static struct alc_pincfg alc861_fsc_amilo_pi1505_pinfix[] = { - { 0x0b, 0x0221101f }, /* HP */ - { 0x0f, 0x90170310 }, /* speaker */ - { } -}; - static const struct alc_fixup alc861_fixups[] = { [PINFIX_FSC_AMILO_PI1505] = { - .pins = alc861_fsc_amilo_pi1505_pinfix + .pins = (const struct alc_pincfg[]) { + { 0x0b, 0x0221101f }, /* HP */ + { 0x0f, 0x90170310 }, /* speaker */ + { } + } }, }; @@ -16794,16 +16784,14 @@ enum { }; /* reset GPIO1 */ -static const struct hda_verb alc660vd_fix_asus_gpio1_verbs[] = { - {0x01, AC_VERB_SET_GPIO_MASK, 0x03}, - {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01}, - {0x01, AC_VERB_SET_GPIO_DATA, 0x01}, - { } -}; - static const struct alc_fixup alc861vd_fixups[] = { [ALC660VD_FIX_ASUS_GPIO1] = { - .verbs = alc660vd_fix_asus_gpio1_verbs, + .verbs = (const struct hda_verb[]) { + {0x01, AC_VERB_SET_GPIO_MASK, 0x03}, + {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01}, + {0x01, AC_VERB_SET_GPIO_DATA, 0x01}, + { } + } }, }; -- cgit v1.1 From f3268512c3a5dea587cfe875b8bca98d9e164cd9 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Mon, 30 Aug 2010 11:00:19 +0200 Subject: ALSA: hda - Refactor input-pin parser for VIA codecs patch_via.c has redundant codes for parsing the input-pins. Although they are pretty similar, but all implemented in different functions just because of hard-coded ids and slight incompatibilities. This patch refactors the codes to use the common helper function, resulting in the reduction of many lines. Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_via.c | 390 +++++++--------------------------------------- 1 file changed, 60 insertions(+), 330 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_via.c b/sound/pci/hda/patch_via.c index ae3acb2..4186138 100644 --- a/sound/pci/hda/patch_via.c +++ b/sound/pci/hda/patch_via.c @@ -2413,51 +2413,53 @@ static int vt1708_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) } /* create playback/capture controls for input pins */ -static int vt1708_auto_create_analog_input_ctls(struct via_spec *spec, - const struct auto_pin_cfg *cfg) +static int vt_auto_create_analog_input_ctls(struct via_spec *spec, + const struct auto_pin_cfg *cfg, + hda_nid_t cap_nid, + hda_nid_t pin_idxs[], int num_idxs) { - static char *labels[] = { - "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL - }; struct hda_input_mux *imux = &spec->private_imux[0]; - int i, err, idx = 0; + int i, err, idx; /* for internal loopback recording select */ - imux->items[imux->num_items].label = "Stereo Mixer"; - imux->items[imux->num_items].index = idx; - imux->num_items++; + for (idx = 0; idx < num_idxs; idx++) { + if (pin_idxs[idx] == 0xff) { + imux->items[imux->num_items].label = "Stereo Mixer"; + imux->items[imux->num_items].index = idx; + imux->num_items++; + break; + } + } for (i = 0; i < AUTO_PIN_LAST; i++) { if (!cfg->input_pins[i]) continue; - switch (cfg->input_pins[i]) { - case 0x1d: /* Mic */ - idx = 2; - break; - - case 0x1e: /* Line In */ - idx = 3; - break; - - case 0x21: /* Front Mic */ - idx = 4; - break; - - case 0x24: /* CD */ - idx = 1; - break; - } - err = via_new_analog_input(spec, labels[i], idx, 0x17); + for (idx = 0; idx < num_idxs; idx++) + if (pin_idxs[idx] == cfg->input_pins[i]) + break; + if (idx >= num_idxs) + continue; + err = via_new_analog_input(spec, auto_pin_cfg_labels[i], + idx, cap_nid); if (err < 0) return err; - imux->items[imux->num_items].label = labels[i]; + imux->items[imux->num_items].label = auto_pin_cfg_labels[i]; imux->items[imux->num_items].index = idx; imux->num_items++; } return 0; } +/* create playback/capture controls for input pins */ +static int vt1708_auto_create_analog_input_ctls(struct via_spec *spec, + const struct auto_pin_cfg *cfg) +{ + static hda_nid_t pin_idxs[] = { 0xff, 0x24, 0x1d, 0x1e, 0x21 }; + return vt_auto_create_analog_input_ctls(spec, cfg, 0x17, pin_idxs, + ARRAY_SIZE(pin_idxs)); +} + #ifdef CONFIG_SND_HDA_POWER_SAVE static struct hda_amp_list vt1708_loopbacks[] = { { 0x17, HDA_INPUT, 1 }, @@ -3024,46 +3026,9 @@ static int vt1709_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) static int vt1709_auto_create_analog_input_ctls(struct via_spec *spec, const struct auto_pin_cfg *cfg) { - static char *labels[] = { - "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL - }; - struct hda_input_mux *imux = &spec->private_imux[0]; - int i, err, idx = 0; - - /* for internal loopback recording select */ - imux->items[imux->num_items].label = "Stereo Mixer"; - imux->items[imux->num_items].index = idx; - imux->num_items++; - - for (i = 0; i < AUTO_PIN_LAST; i++) { - if (!cfg->input_pins[i]) - continue; - - switch (cfg->input_pins[i]) { - case 0x1d: /* Mic */ - idx = 2; - break; - - case 0x1e: /* Line In */ - idx = 3; - break; - - case 0x21: /* Front Mic */ - idx = 4; - break; - - case 0x23: /* CD */ - idx = 1; - break; - } - err = via_new_analog_input(spec, labels[i], idx, 0x18); - if (err < 0) - return err; - imux->items[imux->num_items].label = labels[i]; - imux->items[imux->num_items].index = idx; - imux->num_items++; - } - return 0; + static hda_nid_t pin_idxs[] = { 0xff, 0x23, 0x1d, 0x1e, 0x21 }; + return vt_auto_create_analog_input_ctls(spec, cfg, 0x18, pin_idxs, + ARRAY_SIZE(pin_idxs)); } static int vt1709_parse_auto_config(struct hda_codec *codec) @@ -3591,46 +3556,9 @@ static int vt1708B_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) static int vt1708B_auto_create_analog_input_ctls(struct via_spec *spec, const struct auto_pin_cfg *cfg) { - static char *labels[] = { - "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL - }; - struct hda_input_mux *imux = &spec->private_imux[0]; - int i, err, idx = 0; - - /* for internal loopback recording select */ - imux->items[imux->num_items].label = "Stereo Mixer"; - imux->items[imux->num_items].index = idx; - imux->num_items++; - - for (i = 0; i < AUTO_PIN_LAST; i++) { - if (!cfg->input_pins[i]) - continue; - - switch (cfg->input_pins[i]) { - case 0x1a: /* Mic */ - idx = 2; - break; - - case 0x1b: /* Line In */ - idx = 3; - break; - - case 0x1e: /* Front Mic */ - idx = 4; - break; - - case 0x1f: /* CD */ - idx = 1; - break; - } - err = via_new_analog_input(spec, labels[i], idx, 0x16); - if (err < 0) - return err; - imux->items[imux->num_items].label = labels[i]; - imux->items[imux->num_items].index = idx; - imux->num_items++; - } - return 0; + static hda_nid_t pin_idxs[] = { 0xff, 0x1f, 0x1a, 0x1b, 0x1e }; + return vt_auto_create_analog_input_ctls(spec, cfg, 0x16, pin_idxs, + ARRAY_SIZE(pin_idxs)); } static int vt1708B_parse_auto_config(struct hda_codec *codec) @@ -4064,46 +3992,9 @@ static int vt1708S_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) static int vt1708S_auto_create_analog_input_ctls(struct via_spec *spec, const struct auto_pin_cfg *cfg) { - static char *labels[] = { - "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL - }; - struct hda_input_mux *imux = &spec->private_imux[0]; - int i, err, idx = 0; - - /* for internal loopback recording select */ - imux->items[imux->num_items].label = "Stereo Mixer"; - imux->items[imux->num_items].index = 5; - imux->num_items++; - - for (i = 0; i < AUTO_PIN_LAST; i++) { - if (!cfg->input_pins[i]) - continue; - - switch (cfg->input_pins[i]) { - case 0x1a: /* Mic */ - idx = 2; - break; - - case 0x1b: /* Line In */ - idx = 3; - break; - - case 0x1e: /* Front Mic */ - idx = 4; - break; - - case 0x1f: /* CD */ - idx = 1; - break; - } - err = via_new_analog_input(spec, labels[i], idx, 0x16); - if (err < 0) - return err; - imux->items[imux->num_items].label = labels[i]; - imux->items[imux->num_items].index = idx-1; - imux->num_items++; - } - return 0; + static hda_nid_t pin_idxs[] = { 0x1f, 0x1a, 0x1b, 0x1e, 0, 0xff }; + return vt_auto_create_analog_input_ctls(spec, cfg, 0x16, pin_idxs, + ARRAY_SIZE(pin_idxs)); } /* fill out digital output widgets; one for master and one for slave outputs */ @@ -4457,42 +4348,9 @@ static int vt1702_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) static int vt1702_auto_create_analog_input_ctls(struct via_spec *spec, const struct auto_pin_cfg *cfg) { - static char *labels[] = { - "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL - }; - struct hda_input_mux *imux = &spec->private_imux[0]; - int i, err, idx = 0; - - /* for internal loopback recording select */ - imux->items[imux->num_items].label = "Stereo Mixer"; - imux->items[imux->num_items].index = 3; - imux->num_items++; - - for (i = 0; i < AUTO_PIN_LAST; i++) { - if (!cfg->input_pins[i]) - continue; - - switch (cfg->input_pins[i]) { - case 0x14: /* Mic */ - idx = 1; - break; - - case 0x15: /* Line In */ - idx = 2; - break; - - case 0x18: /* Front Mic */ - idx = 3; - break; - } - err = via_new_analog_input(spec, labels[i], idx, 0x1A); - if (err < 0) - return err; - imux->items[imux->num_items].label = labels[i]; - imux->items[imux->num_items].index = idx-1; - imux->num_items++; - } - return 0; + static hda_nid_t pin_idxs[] = { 0x14, 0x15, 0x18, 0xff }; + return vt_auto_create_analog_input_ctls(spec, cfg, 0x1a, pin_idxs, + ARRAY_SIZE(pin_idxs)); } static int vt1702_parse_auto_config(struct hda_codec *codec) @@ -4875,46 +4733,9 @@ static int vt1718S_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) static int vt1718S_auto_create_analog_input_ctls(struct via_spec *spec, const struct auto_pin_cfg *cfg) { - static char *labels[] = { - "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL - }; - struct hda_input_mux *imux = &spec->private_imux[0]; - int i, err, idx = 0; - - /* for internal loopback recording select */ - imux->items[imux->num_items].label = "Stereo Mixer"; - imux->items[imux->num_items].index = 5; - imux->num_items++; - - for (i = 0; i < AUTO_PIN_LAST; i++) { - if (!cfg->input_pins[i]) - continue; - - switch (cfg->input_pins[i]) { - case 0x2b: /* Mic */ - idx = 1; - break; - - case 0x2a: /* Line In */ - idx = 2; - break; - - case 0x29: /* Front Mic */ - idx = 3; - break; - - case 0x2c: /* CD */ - idx = 0; - break; - } - err = via_new_analog_input(spec, labels[i], idx, 0x21); - if (err < 0) - return err; - imux->items[imux->num_items].label = labels[i]; - imux->items[imux->num_items].index = idx; - imux->num_items++; - } - return 0; + static hda_nid_t pin_idxs[] = { 0x2c, 0x2b, 0x2a, 0x29, 0, 0xff }; + return vt_auto_create_analog_input_ctls(spec, cfg, 0x21, pin_idxs, + ARRAY_SIZE(pin_idxs)); } static int vt1718S_parse_auto_config(struct hda_codec *codec) @@ -5374,46 +5195,9 @@ static int vt1716S_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) static int vt1716S_auto_create_analog_input_ctls(struct via_spec *spec, const struct auto_pin_cfg *cfg) { - static char *labels[] = { - "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL - }; - struct hda_input_mux *imux = &spec->private_imux[0]; - int i, err, idx = 0; - - /* for internal loopback recording select */ - imux->items[imux->num_items].label = "Stereo Mixer"; - imux->items[imux->num_items].index = 5; - imux->num_items++; - - for (i = 0; i < AUTO_PIN_LAST; i++) { - if (!cfg->input_pins[i]) - continue; - - switch (cfg->input_pins[i]) { - case 0x1a: /* Mic */ - idx = 2; - break; - - case 0x1b: /* Line In */ - idx = 3; - break; - - case 0x1e: /* Front Mic */ - idx = 4; - break; - - case 0x1f: /* CD */ - idx = 1; - break; - } - err = via_new_analog_input(spec, labels[i], idx, 0x16); - if (err < 0) - return err; - imux->items[imux->num_items].label = labels[i]; - imux->items[imux->num_items].index = idx-1; - imux->num_items++; - } - return 0; + static hda_nid_t pin_idxs[] = { 0x1f, 0x1a, 0x1b, 0x1e, 0, 0xff }; + return vt_auto_create_analog_input_ctls(spec, cfg, 0x16, pin_idxs, + ARRAY_SIZE(pin_idxs)); } static int vt1716S_parse_auto_config(struct hda_codec *codec) @@ -5720,47 +5504,19 @@ static int vt2002P_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) static int vt2002P_auto_create_analog_input_ctls(struct via_spec *spec, const struct auto_pin_cfg *cfg) { - static char *labels[] = { - "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL - }; struct hda_input_mux *imux = &spec->private_imux[0]; - int i, err, idx = 0; - - for (i = 0; i < AUTO_PIN_LAST; i++) { - if (!cfg->input_pins[i]) - continue; - - switch (cfg->input_pins[i]) { - case 0x2b: /* Mic */ - idx = 0; - break; - - case 0x2a: /* Line In */ - idx = 1; - break; - - case 0x29: /* Front Mic */ - idx = 2; - break; - } - err = via_new_analog_input(spec, labels[i], idx, 0x21); - if (err < 0) - return err; - imux->items[imux->num_items].label = labels[i]; - imux->items[imux->num_items].index = idx; - imux->num_items++; - } + static hda_nid_t pin_idxs[] = { 0x2b, 0x2a, 0x29, 0xff }; + int err; + err = vt_auto_create_analog_input_ctls(spec, cfg, 0x21, pin_idxs, + ARRAY_SIZE(pin_idxs)); + if (err < 0) + return err; /* build volume/mute control of loopback */ err = via_new_analog_input(spec, "Stereo Mixer", 3, 0x21); if (err < 0) return err; - /* for internal loopback recording select */ - imux->items[imux->num_items].label = "Stereo Mixer"; - imux->items[imux->num_items].index = 3; - imux->num_items++; - /* for digital mic select */ imux->items[imux->num_items].label = "Digital Mic"; imux->items[imux->num_items].index = 4; @@ -6070,46 +5826,20 @@ static int vt1812_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) static int vt1812_auto_create_analog_input_ctls(struct via_spec *spec, const struct auto_pin_cfg *cfg) { - static char *labels[] = { - "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux", NULL - }; struct hda_input_mux *imux = &spec->private_imux[0]; - int i, err, idx = 0; - - for (i = 0; i < AUTO_PIN_LAST; i++) { - if (!cfg->input_pins[i]) - continue; - - switch (cfg->input_pins[i]) { - case 0x2b: /* Mic */ - idx = 0; - break; + static hda_nid_t pin_idxs[] = { 0x2b, 0x2a, 0x29, 0, 0, 0xff }; + int err; - case 0x2a: /* Line In */ - idx = 1; - break; + err = vt_auto_create_analog_input_ctls(spec, cfg, 0x21, pin_idxs, + ARRAY_SIZE(pin_idxs)); + if (err < 0) + return err; - case 0x29: /* Front Mic */ - idx = 2; - break; - } - err = via_new_analog_input(spec, labels[i], idx, 0x21); - if (err < 0) - return err; - imux->items[imux->num_items].label = labels[i]; - imux->items[imux->num_items].index = idx; - imux->num_items++; - } /* build volume/mute control of loopback */ err = via_new_analog_input(spec, "Stereo Mixer", 5, 0x21); if (err < 0) return err; - /* for internal loopback recording select */ - imux->items[imux->num_items].label = "Stereo Mixer"; - imux->items[imux->num_items].index = 5; - imux->num_items++; - /* for digital mic select */ imux->items[imux->num_items].label = "Digital Mic"; imux->items[imux->num_items].index = 6; -- cgit v1.1 From 75e0eb24ee3ec3549c2e53707dcc87e5f7a2c791 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Mon, 30 Aug 2010 12:56:55 +0200 Subject: ALSA: hda - Add inputs[] to auto_pin_cfg struct Added the new fields to contain all input-pins to struct auto_pin_cfg. Unlike the existing input_pins[], this array contains all input pins even if the multiple pins are assigned for a single role (i.e. two front mics). The former input_pins[] still remains for a while, but will be removed in near future. Signed-off-by: Takashi Iwai --- sound/pci/hda/hda_codec.c | 40 +++++++++++++++++++++++++++++----------- sound/pci/hda/hda_local.h | 12 +++++++++++- 2 files changed, 40 insertions(+), 12 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c index 3827092..280a739 100644 --- a/sound/pci/hda/hda_codec.c +++ b/sound/pci/hda/hda_codec.c @@ -4372,6 +4372,17 @@ static void sort_pins_by_sequence(hda_nid_t *pins, short *sequences, } +/* add the found input-pin to the cfg->inputs[] table */ +static void add_auto_cfg_input_pin(struct auto_pin_cfg *cfg, hda_nid_t nid, + int type) +{ + if (cfg->num_inputs < AUTO_CFG_MAX_INS) { + cfg->inputs[cfg->num_inputs].pin = nid; + cfg->inputs[cfg->num_inputs].type = type; + cfg->num_inputs++; + } +} + /* * Parse all pin widgets and store the useful pin nids to cfg * @@ -4398,6 +4409,7 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec, short sequences_line_out[ARRAY_SIZE(cfg->line_out_pins)]; short sequences_speaker[ARRAY_SIZE(cfg->speaker_pins)]; short sequences_hp[ARRAY_SIZE(cfg->hp_pins)]; + int i; memset(cfg, 0, sizeof(*cfg)); @@ -4482,19 +4494,26 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec, cfg->input_pins[preferred] = nid; else if (!cfg->input_pins[alt]) cfg->input_pins[alt] = nid; + add_auto_cfg_input_pin(cfg, nid, preferred); break; } - case AC_JACK_LINE_IN: + case AC_JACK_LINE_IN: { + int type; if (loc == AC_JACK_LOC_FRONT) - cfg->input_pins[AUTO_PIN_FRONT_LINE] = nid; + type = AUTO_PIN_FRONT_LINE; else - cfg->input_pins[AUTO_PIN_LINE] = nid; + type = AUTO_PIN_LINE; + cfg->input_pins[type] = nid; + add_auto_cfg_input_pin(cfg, nid, type); break; + } case AC_JACK_CD: cfg->input_pins[AUTO_PIN_CD] = nid; + add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_CD); break; case AC_JACK_AUX: cfg->input_pins[AUTO_PIN_AUX] = nid; + add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_AUX); break; case AC_JACK_SPDIF_OUT: case AC_JACK_DIG_OTHER_OUT: @@ -4621,14 +4640,13 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec, if (cfg->dig_outs) snd_printd(" dig-out=0x%x/0x%x\n", cfg->dig_out_pins[0], cfg->dig_out_pins[1]); - snd_printd(" inputs: mic=0x%x, fmic=0x%x, line=0x%x, fline=0x%x," - " cd=0x%x, aux=0x%x\n", - cfg->input_pins[AUTO_PIN_MIC], - cfg->input_pins[AUTO_PIN_FRONT_MIC], - cfg->input_pins[AUTO_PIN_LINE], - cfg->input_pins[AUTO_PIN_FRONT_LINE], - cfg->input_pins[AUTO_PIN_CD], - cfg->input_pins[AUTO_PIN_AUX]); + snd_printd(" inputs:"); + for (i = 0; i < cfg->num_inputs; i++) { + snd_printdd(" %s=0x%x", + auto_pin_cfg_labels[cfg->inputs[i].type], + cfg->inputs[i].pin); + } + snd_printd("\n"); if (cfg->dig_in_pin) snd_printd(" dig-in=0x%x\n", cfg->dig_in_pin); diff --git a/sound/pci/hda/hda_local.h b/sound/pci/hda/hda_local.h index 28ab4ae..44c9094 100644 --- a/sound/pci/hda/hda_local.h +++ b/sound/pci/hda/hda_local.h @@ -383,6 +383,14 @@ enum { extern const char *auto_pin_cfg_labels[AUTO_PIN_LAST]; #define AUTO_CFG_MAX_OUTS 5 +#define AUTO_CFG_MAX_INS 8 + +struct auto_pin_cfg_item { + hda_nid_t pin; + int type; +}; + +struct auto_pin_cfg; struct auto_pin_cfg { int line_outs; @@ -393,7 +401,9 @@ struct auto_pin_cfg { int hp_outs; int line_out_type; /* AUTO_PIN_XXX_OUT */ hda_nid_t hp_pins[AUTO_CFG_MAX_OUTS]; - hda_nid_t input_pins[AUTO_PIN_LAST]; + hda_nid_t input_pins[AUTO_PIN_LAST]; /* old config; to be deprecated */ + int num_inputs; + struct auto_pin_cfg_item inputs[AUTO_CFG_MAX_INS]; int dig_outs; hda_nid_t dig_out_pins[2]; hda_nid_t dig_in_pin; -- cgit v1.1 From d7b1ae9d8851bd247590cf7ab53248a2dac0419f Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Mon, 30 Aug 2010 13:00:16 +0200 Subject: ALSA: hda - Add snd_hda_get_input_pin_label() helper function Added snd_hda_get_input_pin_label() helper function to return the string that can be used for control or capture-source ids. Signed-off-by: Takashi Iwai --- sound/pci/hda/hda_codec.c | 25 ++++++++++++++++++++++++- sound/pci/hda/hda_local.h | 2 ++ 2 files changed, 26 insertions(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c index 280a739..72334b7 100644 --- a/sound/pci/hda/hda_codec.c +++ b/sound/pci/hda/hda_codec.c @@ -4654,12 +4654,35 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec, } EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config); -/* labels for input pins */ +/* labels for input pins - for obsoleted config stuff */ const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = { "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux" }; EXPORT_SYMBOL_HDA(auto_pin_cfg_labels); +static const char *input_labels[AUTO_PIN_LAST][4] = { + { "Mic", "Mic 2", "Mic 3", "Mic 4" }, + { "Front Mic", "Front Mic 2", "Front Mic 3", "Front Mic 4" }, + { "Line", "Line 2", "Line 3", "Line 4" }, + { "Front Line", "Front Line 2", "Front Line 3", "Front Line 4" }, + { "CD", "CD 2", "CD 3", "CD 4" }, + { "Aux", "Aux 2", "Aux 3", "Aux 4" }, +}; + +const char *snd_hda_get_input_pin_label(const struct auto_pin_cfg *cfg, + int input) +{ + int type = cfg->inputs[input].type; + int idx; + + for (idx = 0; idx < 3 && --input >= 0; idx++) { + if (type != cfg->inputs[input].type) + break; + } + return input_labels[type][idx]; +} +EXPORT_SYMBOL_HDA(snd_hda_get_input_pin_label); + #ifdef CONFIG_PM /* diff --git a/sound/pci/hda/hda_local.h b/sound/pci/hda/hda_local.h index 44c9094..fb56174 100644 --- a/sound/pci/hda/hda_local.h +++ b/sound/pci/hda/hda_local.h @@ -391,6 +391,8 @@ struct auto_pin_cfg_item { }; struct auto_pin_cfg; +const char *snd_hda_get_input_pin_label(const struct auto_pin_cfg *cfg, + int input); struct auto_pin_cfg { int line_outs; -- cgit v1.1 From 9e042e71325eeda03636aedfde6f2d27d6332188 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Mon, 30 Aug 2010 13:04:44 +0200 Subject: ALSA: hda - Use new inputs[] field to parse input-pins for AD codecs Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_analog.c | 30 ++++++++++++++++++------------ 1 file changed, 18 insertions(+), 12 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_analog.c b/sound/pci/hda/patch_analog.c index b697fd2..3409d31 100644 --- a/sound/pci/hda/patch_analog.c +++ b/sound/pci/hda/patch_analog.c @@ -2880,7 +2880,7 @@ static int ad1988_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin, /* create input playback/capture controls for the given pin */ static int new_analog_input(struct ad198x_spec *spec, hda_nid_t pin, - const char *ctlname, int boost) + const char *ctlname, int ctlidx, int boost) { char name[32]; int err, idx; @@ -2913,16 +2913,23 @@ static int ad1988_auto_create_analog_input_ctls(struct ad198x_spec *spec, const struct auto_pin_cfg *cfg) { struct hda_input_mux *imux = &spec->private_imux; - int i, err; + int i, err, type, type_idx = 0; - for (i = 0; i < AUTO_PIN_LAST; i++) { - err = new_analog_input(spec, cfg->input_pins[i], - auto_pin_cfg_labels[i], - i <= AUTO_PIN_FRONT_MIC); + for (i = 0; i < cfg->num_inputs; i++) { + type = cfg->inputs[i].type; + if (i > 0 && type != cfg->inputs[i - 1].type) + type_idx++; + else + type_idx = 0; + err = new_analog_input(spec, cfg->inputs[i].pin, + auto_pin_cfg_labels[type], type_idx, + type <= AUTO_PIN_FRONT_MIC); if (err < 0) return err; - imux->items[imux->num_items].label = auto_pin_cfg_labels[i]; - imux->items[imux->num_items].index = ad1988_pin_to_adc_idx(cfg->input_pins[i]); + imux->items[imux->num_items].label = + snd_hda_get_input_pin_label(cfg, i); + imux->items[imux->num_items].index = + ad1988_pin_to_adc_idx(cfg->inputs[i].pin); imux->num_items++; } imux->items[imux->num_items].label = "Mix"; @@ -2994,12 +3001,11 @@ static void ad1988_auto_init_extra_out(struct hda_codec *codec) static void ad1988_auto_init_analog_input(struct hda_codec *codec) { struct ad198x_spec *spec = codec->spec; + const struct auto_pin_cfg *cfg = &spec->autocfg; int i, idx; - for (i = 0; i < AUTO_PIN_LAST; i++) { - hda_nid_t nid = spec->autocfg.input_pins[i]; - if (! nid) - continue; + for (i = 0; i < cfg->num_inputs; i++) { + hda_nid_t nid = cfg->inputs[i].pin; switch (nid) { case 0x15: /* port-C */ snd_hda_codec_write(codec, 0x33, 0, AC_VERB_SET_CONNECT_SEL, 0x0); -- cgit v1.1 From fa4968a8b231816d161583e604a9f972e5713f17 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Mon, 30 Aug 2010 13:05:08 +0200 Subject: ALSA: hda - Use new inputs[] field to parse input-pins for CA-IBG codecs Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_ca0110.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_ca0110.c b/sound/pci/hda/patch_ca0110.c index af47801..42b3fb4 100644 --- a/sound/pci/hda/patch_ca0110.c +++ b/sound/pci/hda/patch_ca0110.c @@ -468,13 +468,14 @@ static void parse_input(struct hda_codec *codec) spec->dig_in = nid; continue; } - for (j = 0; j < AUTO_PIN_LAST; j++) - if (cfg->input_pins[j] == pin) + for (j = 0; j < cfg->num_inputs; j++) + if (cfg->inputs[j].pin == pin) break; - if (j >= AUTO_PIN_LAST) + if (j >= cfg->num_inputs) continue; spec->input_pins[n] = pin; - spec->input_labels[n] = auto_pin_cfg_labels[j]; + spec->input_labels[n] = + auto_pin_cfg_labels[cfg->inputs[j].type]; spec->adcs[n] = nid; n++; } -- cgit v1.1 From c1e0bb92174dd16ffba5be0e4e5fbd366f61ff7f Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Mon, 30 Aug 2010 13:05:30 +0200 Subject: ALSA: hda - Use new inputs[] field to parse input-pins for CirrusLogic codecs Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_cirrus.c | 38 +++++++++++++++++--------------------- 1 file changed, 17 insertions(+), 21 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_cirrus.c b/sound/pci/hda/patch_cirrus.c index 4ef5efa..ee1aea7 100644 --- a/sound/pci/hda/patch_cirrus.c +++ b/sound/pci/hda/patch_cirrus.c @@ -329,7 +329,7 @@ static int is_ext_mic(struct hda_codec *codec, unsigned int idx) { struct cs_spec *spec = codec->spec; struct auto_pin_cfg *cfg = &spec->autocfg; - hda_nid_t pin = cfg->input_pins[idx]; + hda_nid_t pin = cfg->inputs[idx].pin; unsigned int val = snd_hda_query_pin_caps(codec, pin); if (!(val & AC_PINCAP_PRES_DETECT)) return 0; @@ -424,10 +424,8 @@ static int parse_input(struct hda_codec *codec) struct auto_pin_cfg *cfg = &spec->autocfg; int i; - for (i = 0; i < AUTO_PIN_LAST; i++) { - hda_nid_t pin = cfg->input_pins[i]; - if (!pin) - continue; + for (i = 0; i < cfg->num_inputs; i++) { + hda_nid_t pin = cfg->inputs[i].pin; spec->input_idx[spec->num_inputs] = i; spec->capsrc_idx[i] = spec->num_inputs++; spec->cur_input = i; @@ -438,16 +436,17 @@ static int parse_input(struct hda_codec *codec) /* check whether the automatic mic switch is available */ if (spec->num_inputs == 2 && - spec->adc_nid[AUTO_PIN_MIC] && spec->adc_nid[AUTO_PIN_FRONT_MIC]) { - if (is_ext_mic(codec, cfg->input_pins[AUTO_PIN_FRONT_MIC])) { - if (!is_ext_mic(codec, cfg->input_pins[AUTO_PIN_MIC])) { + cfg->inputs[0].type <= AUTO_PIN_FRONT_MIC && + cfg->inputs[1].type == AUTO_PIN_FRONT_MIC) { + if (is_ext_mic(codec, cfg->inputs[0].pin)) { + if (!is_ext_mic(codec, cfg->inputs[1].pin)) { spec->mic_detect = 1; - spec->automic_idx = AUTO_PIN_FRONT_MIC; + spec->automic_idx = 0; } } else { - if (is_ext_mic(codec, cfg->input_pins[AUTO_PIN_MIC])) { + if (is_ext_mic(codec, cfg->inputs[1].pin)) { spec->mic_detect = 1; - spec->automic_idx = AUTO_PIN_MIC; + spec->automic_idx = 1; } } } @@ -853,15 +852,12 @@ static void cs_automic(struct hda_codec *codec) hda_nid_t nid; unsigned int present; - nid = cfg->input_pins[spec->automic_idx]; + nid = cfg->inputs[spec->automic_idx].pin; present = snd_hda_jack_detect(codec, nid); if (present) change_cur_input(codec, spec->automic_idx, 0); - else { - unsigned int imic = (spec->automic_idx == AUTO_PIN_MIC) ? - AUTO_PIN_FRONT_MIC : AUTO_PIN_MIC; - change_cur_input(codec, imic, 0); - } + else + change_cur_input(codec, !spec->automic_idx, 0); } /* @@ -918,14 +914,14 @@ static void init_input(struct hda_codec *codec) unsigned int coef; int i; - for (i = 0; i < AUTO_PIN_LAST; i++) { + for (i = 0; i < cfg->num_inputs; i++) { unsigned int ctl; - hda_nid_t pin = cfg->input_pins[i]; - if (!pin || !spec->adc_nid[i]) + hda_nid_t pin = cfg->inputs[i].pin; + if (!spec->adc_nid[i]) continue; /* set appropriate pin control and mute first */ ctl = PIN_IN; - if (i <= AUTO_PIN_FRONT_MIC) { + if (cfg->inputs[i].type <= AUTO_PIN_FRONT_MIC) { unsigned int caps = snd_hda_query_pin_caps(codec, pin); caps >>= AC_PINCAP_VREF_SHIFT; if (caps & AC_PINCAP_VREF_80) -- cgit v1.1 From 66ceeb6bc2809bef0cfa18b1e22ddad5fc9b58b0 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Mon, 30 Aug 2010 13:05:52 +0200 Subject: ALSA: hda - Use new inputs[] field to parse input-pins for Realtek codecs Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 208 ++++++++++++++++++++++-------------------- 1 file changed, 110 insertions(+), 98 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index 50e0c82..3e0f481 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -1265,16 +1265,14 @@ static void alc_init_auto_mic(struct hda_codec *codec) int i; /* there must be only two mic inputs exclusively */ - for (i = AUTO_PIN_LINE; i < AUTO_PIN_LAST; i++) - if (cfg->input_pins[i]) + for (i = 0; i < cfg->num_inputs; i++) + if (cfg->inputs[i].type >= AUTO_PIN_LINE) return; fixed = ext = 0; - for (i = AUTO_PIN_MIC; i <= AUTO_PIN_FRONT_MIC; i++) { - hda_nid_t nid = cfg->input_pins[i]; + for (i = 0; i < cfg->num_inputs; i++) { + hda_nid_t nid = cfg->inputs[i].pin; unsigned int defcfg; - if (!nid) - return; defcfg = snd_hda_codec_get_pincfg(codec, nid); switch (get_defcfg_connect(defcfg)) { case AC_JACK_PORT_FIXED: @@ -4719,7 +4717,7 @@ static struct snd_kcontrol_new alc880_control_templates[] = { /* add dynamic controls */ static int add_control(struct alc_spec *spec, int type, const char *name, - unsigned long val) + int cidx, unsigned long val) { struct snd_kcontrol_new *knew; @@ -4731,6 +4729,7 @@ static int add_control(struct alc_spec *spec, int type, const char *name, knew->name = kstrdup(name, GFP_KERNEL); if (!knew->name) return -ENOMEM; + knew->index = cidx; if (get_amp_nid_(val)) knew->subdevice = HDA_SUBDEV_AMP_FLAG; knew->private_value = val; @@ -4739,17 +4738,21 @@ static int add_control(struct alc_spec *spec, int type, const char *name, static int add_control_with_pfx(struct alc_spec *spec, int type, const char *pfx, const char *dir, - const char *sfx, unsigned long val) + const char *sfx, int cidx, unsigned long val) { char name[32]; snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx); - return add_control(spec, type, name, val); + return add_control(spec, type, name, cidx, val); } -#define add_pb_vol_ctrl(spec, type, pfx, val) \ - add_control_with_pfx(spec, type, pfx, "Playback", "Volume", val) -#define add_pb_sw_ctrl(spec, type, pfx, val) \ - add_control_with_pfx(spec, type, pfx, "Playback", "Switch", val) +#define add_pb_vol_ctrl(spec, type, pfx, val) \ + add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val) +#define add_pb_sw_ctrl(spec, type, pfx, val) \ + add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val) +#define __add_pb_vol_ctrl(spec, type, pfx, cidx, val) \ + add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val) +#define __add_pb_sw_ctrl(spec, type, pfx, cidx, val) \ + add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val) #define alc880_is_fixed_pin(nid) ((nid) >= 0x14 && (nid) <= 0x17) #define alc880_fixed_pin_idx(nid) ((nid) - 0x14) @@ -4902,16 +4905,16 @@ static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin, /* create input playback/capture controls for the given pin */ static int new_analog_input(struct alc_spec *spec, hda_nid_t pin, - const char *ctlname, + const char *ctlname, int ctlidx, int idx, hda_nid_t mix_nid) { int err; - err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, + err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx, HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); if (err < 0) return err; - err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, + err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx, HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); if (err < 0) return err; @@ -4932,21 +4935,26 @@ static int alc_auto_create_input_ctls(struct hda_codec *codec, { struct alc_spec *spec = codec->spec; struct hda_input_mux *imux = &spec->private_imux[0]; - int i, err, idx; + int i, err, idx, type, type_idx = 0; - for (i = 0; i < AUTO_PIN_LAST; i++) { + for (i = 0; i < cfg->num_inputs; i++) { hda_nid_t pin; - pin = cfg->input_pins[i]; + pin = cfg->inputs[i].pin; if (!alc_is_input_pin(codec, pin)) continue; + type = cfg->inputs[i].type; + if (i > 0 && type == cfg->inputs[i - 1].type) + type_idx++; + else + type_idx = 0; if (mixer) { idx = get_connection_index(codec, mixer, pin); if (idx >= 0) { err = new_analog_input(spec, pin, - auto_pin_cfg_labels[i], - idx, mixer); + auto_pin_cfg_labels[type], + type_idx, idx, mixer); if (err < 0) return err; } @@ -4959,7 +4967,7 @@ static int alc_auto_create_input_ctls(struct hda_codec *codec, idx = get_connection_index(codec, cap2, pin); if (idx >= 0) { imux->items[imux->num_items].label = - auto_pin_cfg_labels[i]; + snd_hda_get_input_pin_label(cfg, i); imux->items[imux->num_items].index = idx; imux->num_items++; } @@ -5034,10 +5042,11 @@ static void alc880_auto_init_extra_out(struct hda_codec *codec) static void alc880_auto_init_analog_input(struct hda_codec *codec) { struct alc_spec *spec = codec->spec; + struct auto_pin_cfg *cfg = &spec->autocfg; int i; - for (i = 0; i < AUTO_PIN_LAST; i++) { - hda_nid_t nid = spec->autocfg.input_pins[i]; + for (i = 0; i < cfg->num_inputs; i++) { + hda_nid_t nid = cfg->inputs[i].pin; if (alc_is_input_pin(codec, nid)) { alc_set_input_pin(codec, nid, i); if (nid != ALC880_PIN_CD_NID && @@ -5204,19 +5213,13 @@ static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin) static void fixup_single_adc(struct hda_codec *codec) { struct alc_spec *spec = codec->spec; - hda_nid_t pin = 0; + struct auto_pin_cfg *cfg = &spec->autocfg; int i; /* search for the input pin; there must be only one */ - for (i = 0; i < AUTO_PIN_LAST; i++) { - if (spec->autocfg.input_pins[i]) { - pin = spec->autocfg.input_pins[i]; - break; - } - } - if (!pin) + if (cfg->num_inputs != 1) return; - i = init_capsrc_for_pin(codec, pin); + i = init_capsrc_for_pin(codec, cfg->inputs[0].pin); if (i >= 0) { /* use only this ADC */ if (spec->capsrc_nids) @@ -5269,6 +5272,7 @@ static void fillup_priv_adc_nids(struct hda_codec *codec, hda_nid_t *nids, int num_nids) { struct alc_spec *spec = codec->spec; + struct auto_pin_cfg *cfg = &spec->autocfg; int n; hda_nid_t fallback_adc = 0, fallback_cap = 0; @@ -5294,10 +5298,8 @@ static void fillup_priv_adc_nids(struct hda_codec *codec, hda_nid_t *nids, fallback_adc = adc; fallback_cap = cap; } - for (i = 0; i < AUTO_PIN_LAST; i++) { - hda_nid_t nid = spec->autocfg.input_pins[i]; - if (!nid) - continue; + for (i = 0; i < cfg->num_inputs; i++) { + hda_nid_t nid = cfg->inputs[i].pin; for (j = 0; j < nconns; j++) { if (conn[j] == nid) break; @@ -5305,7 +5307,7 @@ static void fillup_priv_adc_nids(struct hda_codec *codec, hda_nid_t *nids, if (j >= nconns) break; } - if (i >= AUTO_PIN_LAST) { + if (i >= cfg->num_inputs) { int num_adcs = spec->num_adc_nids; spec->private_adc_nids[num_adcs] = adc; spec->private_capsrc_nids[num_adcs] = cap; @@ -6672,10 +6674,11 @@ static void alc260_auto_init_multi_out(struct hda_codec *codec) static void alc260_auto_init_analog_input(struct hda_codec *codec) { struct alc_spec *spec = codec->spec; + struct auto_pin_cfg *cfg = &spec->autocfg; int i; - for (i = 0; i < AUTO_PIN_LAST; i++) { - hda_nid_t nid = spec->autocfg.input_pins[i]; + for (i = 0; i < cfg->num_inputs; i++) { + hda_nid_t nid = cfg->inputs[i].pin; if (nid >= 0x12) { alc_set_input_pin(codec, nid, i); if (nid != ALC260_PIN_CD_NID && @@ -10538,12 +10541,11 @@ static void alc882_auto_init_hp_out(struct hda_codec *codec) static void alc882_auto_init_analog_input(struct hda_codec *codec) { struct alc_spec *spec = codec->spec; + struct auto_pin_cfg *cfg = &spec->autocfg; int i; - for (i = 0; i < AUTO_PIN_LAST; i++) { - hda_nid_t nid = spec->autocfg.input_pins[i]; - if (!nid) - continue; + for (i = 0; i < cfg->num_inputs; i++) { + hda_nid_t nid = cfg->inputs[i].pin; alc_set_input_pin(codec, nid, i); if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) snd_hda_codec_write(codec, nid, 0, @@ -10606,24 +10608,23 @@ static void alc882_auto_init_input_src(struct hda_codec *codec) static int alc_auto_add_mic_boost(struct hda_codec *codec) { struct alc_spec *spec = codec->spec; - int err; + struct auto_pin_cfg *cfg = &spec->autocfg; + int i, err; hda_nid_t nid; - nid = spec->autocfg.input_pins[AUTO_PIN_MIC]; - if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) { - err = add_control(spec, ALC_CTL_WIDGET_VOL, - "Mic Boost", - HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT)); - if (err < 0) - return err; - } - nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC]; - if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) { - err = add_control(spec, ALC_CTL_WIDGET_VOL, - "Front Mic Boost", + for (i = 0; i < cfg->num_inputs; i++) { + if (cfg->inputs[i].type > AUTO_PIN_FRONT_MIC) + break; + nid = cfg->inputs[i].pin; + if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) { + char label[32]; + snprintf(label, sizeof(label), "%s Boost", + snd_hda_get_input_pin_label(cfg, i)); + err = add_control(spec, ALC_CTL_WIDGET_VOL, label, 0, HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT)); - if (err < 0) - return err; + if (err < 0) + return err; + } } return 0; } @@ -15577,10 +15578,11 @@ static void alc861_auto_init_hp_out(struct hda_codec *codec) static void alc861_auto_init_analog_input(struct hda_codec *codec) { struct alc_spec *spec = codec->spec; + struct auto_pin_cfg *cfg = &spec->autocfg; int i; - for (i = 0; i < AUTO_PIN_LAST; i++) { - hda_nid_t nid = spec->autocfg.input_pins[i]; + for (i = 0; i < cfg->num_inputs; i++) { + hda_nid_t nid = cfg->inputs[i].pin; if (nid >= 0x0c && nid <= 0x11) alc_set_input_pin(codec, nid, i); } @@ -16569,10 +16571,11 @@ static void alc861vd_auto_init_hp_out(struct hda_codec *codec) static void alc861vd_auto_init_analog_input(struct hda_codec *codec) { struct alc_spec *spec = codec->spec; + struct auto_pin_cfg *cfg = &spec->autocfg; int i; - for (i = 0; i < AUTO_PIN_LAST; i++) { - hda_nid_t nid = spec->autocfg.input_pins[i]; + for (i = 0; i < cfg->num_inputs; i++) { + hda_nid_t nid = cfg->inputs[i].pin; if (alc_is_input_pin(codec, nid)) { alc_set_input_pin(codec, nid, i); if (nid != ALC861VD_PIN_CD_NID && @@ -18805,10 +18808,11 @@ static void alc662_auto_init_hp_out(struct hda_codec *codec) static void alc662_auto_init_analog_input(struct hda_codec *codec) { struct alc_spec *spec = codec->spec; + struct auto_pin_cfg *cfg = &spec->autocfg; int i; - for (i = 0; i < AUTO_PIN_LAST; i++) { - hda_nid_t nid = spec->autocfg.input_pins[i]; + for (i = 0; i < cfg->num_inputs; i++) { + hda_nid_t nid = cfg->inputs[i].pin; if (alc_is_input_pin(codec, nid)) { alc_set_input_pin(codec, nid, i); if (nid != ALC662_PIN_CD_NID && @@ -19037,6 +19041,39 @@ static hda_nid_t alc680_adc_nids[3] = { /* * Analog capture ADC cgange */ +static void alc680_rec_autoswitch(struct hda_codec *codec) +{ + struct alc_spec *spec = codec->spec; + struct auto_pin_cfg *cfg = &spec->autocfg; + int pin_found = 0; + int type_found = AUTO_PIN_LAST; + hda_nid_t nid; + int i; + + for (i = 0; i < cfg->num_inputs; i++) { + nid = cfg->inputs[i].pin; + if (!(snd_hda_query_pin_caps(codec, nid) & + AC_PINCAP_PRES_DETECT)) + continue; + if (snd_hda_jack_detect(codec, nid)) { + if (cfg->inputs[i].type < type_found) { + type_found = cfg->inputs[i].type; + pin_found = nid; + } + } + } + + nid = 0x07; + if (pin_found) + snd_hda_get_connections(codec, pin_found, &nid, 1); + + if (nid != spec->cur_adc) + __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1); + spec->cur_adc = nid; + snd_hda_codec_setup_stream(codec, nid, spec->cur_adc_stream_tag, 0, + spec->cur_adc_format); +} + static int alc680_capture_pcm_prepare(struct hda_pcm_stream *hinfo, struct hda_codec *codec, unsigned int stream_tag, @@ -19044,24 +19081,12 @@ static int alc680_capture_pcm_prepare(struct hda_pcm_stream *hinfo, struct snd_pcm_substream *substream) { struct alc_spec *spec = codec->spec; - struct auto_pin_cfg *cfg = &spec->autocfg; - unsigned int pre_mic, pre_line; - - pre_mic = snd_hda_jack_detect(codec, cfg->input_pins[AUTO_PIN_MIC]); - pre_line = snd_hda_jack_detect(codec, cfg->input_pins[AUTO_PIN_LINE]); + spec->cur_adc = 0x07; spec->cur_adc_stream_tag = stream_tag; spec->cur_adc_format = format; - if (pre_mic || pre_line) { - if (pre_mic) - snd_hda_codec_setup_stream(codec, 0x08, stream_tag, 0, - format); - else - snd_hda_codec_setup_stream(codec, 0x09, stream_tag, 0, - format); - } else - snd_hda_codec_setup_stream(codec, 0x07, stream_tag, 0, format); + alc680_rec_autoswitch(codec); return 0; } @@ -19147,6 +19172,7 @@ static struct hda_verb alc680_init_verbs[] = { {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN}, {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, + {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, { } }; @@ -19159,25 +19185,11 @@ static void alc680_base_setup(struct hda_codec *codec) spec->autocfg.hp_pins[0] = 0x16; spec->autocfg.speaker_pins[0] = 0x14; spec->autocfg.speaker_pins[1] = 0x15; - spec->autocfg.input_pins[AUTO_PIN_MIC] = 0x18; - spec->autocfg.input_pins[AUTO_PIN_LINE] = 0x19; -} - -static void alc680_rec_autoswitch(struct hda_codec *codec) -{ - struct alc_spec *spec = codec->spec; - struct auto_pin_cfg *cfg = &spec->autocfg; - unsigned int present; - hda_nid_t new_adc; - - present = snd_hda_jack_detect(codec, cfg->input_pins[AUTO_PIN_MIC]); - - new_adc = present ? 0x8 : 0x7; - __snd_hda_codec_cleanup_stream(codec, !present ? 0x8 : 0x7, 1); - snd_hda_codec_setup_stream(codec, new_adc, - spec->cur_adc_stream_tag, 0, - spec->cur_adc_format); - + spec->autocfg.num_inputs = 2; + spec->autocfg.inputs[0].pin = 0x18; + spec->autocfg.inputs[0].type = AUTO_PIN_MIC; + spec->autocfg.inputs[1].pin = 0x19; + spec->autocfg.inputs[1].type = AUTO_PIN_LINE; } static void alc680_unsol_event(struct hda_codec *codec, -- cgit v1.1 From eea7dc932bfa802ad0377755ea821f416f4f8623 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Mon, 30 Aug 2010 13:06:15 +0200 Subject: ALSA: hda - Use new inputs[] field to parse input-pins for STAC/IDT codecs Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_sigmatel.c | 183 +++++++++++++++++++++-------------------- 1 file changed, 96 insertions(+), 87 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c index 95148e5..d226edd 100644 --- a/sound/pci/hda/patch_sigmatel.c +++ b/sound/pci/hda/patch_sigmatel.c @@ -1180,14 +1180,11 @@ static int stac92xx_build_controls(struct hda_codec *codec) if (err < 0) return err; } - for (i = 0; i < AUTO_PIN_LAST; i++) { - nid = cfg->input_pins[i]; - if (nid) { - err = stac92xx_add_jack(codec, nid, - SND_JACK_MICROPHONE); - if (err < 0) - return err; - } + for (i = 0; i < cfg->num_inputs; i++) { + nid = cfg->inputs[i].pin; + err = stac92xx_add_jack(codec, nid, SND_JACK_MICROPHONE); + if (err < 0) + return err; } return 0; @@ -2821,41 +2818,55 @@ static hda_nid_t check_line_out_switch(struct hda_codec *codec) struct auto_pin_cfg *cfg = &spec->autocfg; hda_nid_t nid; unsigned int pincap; + int i; if (cfg->line_out_type != AUTO_PIN_LINE_OUT) return 0; - nid = cfg->input_pins[AUTO_PIN_LINE]; - pincap = snd_hda_query_pin_caps(codec, nid); - if (pincap & AC_PINCAP_OUT) - return nid; + for (i = 0; i < cfg->num_inputs; i++) { + if (cfg->inputs[i].type == AUTO_PIN_LINE) { + nid = cfg->inputs[i].pin; + pincap = snd_hda_query_pin_caps(codec, nid); + if (pincap & AC_PINCAP_OUT) + return nid; + } + } return 0; } +static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid); + /* check whether the mic-input can be used as line-out */ -static hda_nid_t check_mic_out_switch(struct hda_codec *codec) +static hda_nid_t check_mic_out_switch(struct hda_codec *codec, hda_nid_t *dac) { struct sigmatel_spec *spec = codec->spec; struct auto_pin_cfg *cfg = &spec->autocfg; unsigned int def_conf, pincap; - unsigned int mic_pin; + int i, mic_type; + *dac = 0; if (cfg->line_out_type != AUTO_PIN_LINE_OUT) return 0; - mic_pin = AUTO_PIN_MIC; - for (;;) { - hda_nid_t nid = cfg->input_pins[mic_pin]; + mic_type = AUTO_PIN_MIC; + again: + for (i = 0; i < cfg->num_inputs; i++) { + hda_nid_t nid = cfg->inputs[i].pin; + if (cfg->inputs[i].type != mic_type) + continue; def_conf = snd_hda_codec_get_pincfg(codec, nid); /* some laptops have an internal analog microphone * which can't be used as a output */ if (get_defcfg_connect(def_conf) != AC_JACK_PORT_FIXED) { pincap = snd_hda_query_pin_caps(codec, nid); - if (pincap & AC_PINCAP_OUT) - return nid; + if (pincap & AC_PINCAP_OUT) { + *dac = get_unassigned_dac(codec, nid); + if (*dac) + return nid; + } } - if (mic_pin == AUTO_PIN_MIC) - mic_pin = AUTO_PIN_FRONT_MIC; - else - break; + } + if (mic_type == AUTO_PIN_MIC) { + mic_type = AUTO_PIN_FRONT_MIC; + goto again; } return 0; } @@ -3002,17 +3013,14 @@ static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec) } } /* add mic as output */ - nid = check_mic_out_switch(codec); - if (nid) { - dac = get_unassigned_dac(codec, nid); - if (dac) { - snd_printdd("STAC: Add mic-in 0x%x as output %d\n", - nid, cfg->line_outs); - cfg->line_out_pins[cfg->line_outs] = nid; - cfg->line_outs++; - spec->mic_switch = nid; - add_spec_dacs(spec, dac); - } + nid = check_mic_out_switch(codec, &dac); + if (nid && dac) { + snd_printdd("STAC: Add mic-in 0x%x as output %d\n", + nid, cfg->line_outs); + cfg->line_out_pins[cfg->line_outs] = nid; + cfg->line_outs++; + spec->mic_switch = nid; + add_spec_dacs(spec, dac); } snd_printd("stac92xx: dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n", @@ -3202,13 +3210,13 @@ static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec, return err; } - for (idx = AUTO_PIN_MIC; idx <= AUTO_PIN_FRONT_LINE; idx++) { - nid = cfg->input_pins[idx]; - if (nid) { - err = stac92xx_add_jack_mode_control(codec, nid, idx); - if (err < 0) - return err; - } + for (idx = 0; idx < cfg->num_inputs; idx++) { + if (cfg->inputs[idx].type > AUTO_PIN_FRONT_LINE) + break; + nid = cfg->inputs[idx].pin; + err = stac92xx_add_jack_mode_control(codec, nid, idx); + if (err < 0) + return err; } return 0; @@ -3415,7 +3423,7 @@ static int get_connection_index(struct hda_codec *codec, hda_nid_t mux, /* create a volume assigned to the given pin (only if supported) */ /* return 1 if the volume control is created */ static int create_elem_capture_vol(struct hda_codec *codec, hda_nid_t nid, - const char *label, int direction) + const char *label, int idx, int direction) { unsigned int caps, nums; char name[32]; @@ -3432,8 +3440,8 @@ static int create_elem_capture_vol(struct hda_codec *codec, hda_nid_t nid, if (!nums) return 0; snprintf(name, sizeof(name), "%s Capture Volume", label); - err = stac92xx_add_control(codec->spec, STAC_CTL_WIDGET_VOL, name, - HDA_COMPOSE_AMP_VAL(nid, 3, 0, direction)); + err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx, name, + HDA_COMPOSE_AMP_VAL(nid, 3, 0, direction)); if (err < 0) return err; return 1; @@ -3485,11 +3493,11 @@ static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec, else label = stac92xx_dmic_labels[dimux->num_items]; - err = create_elem_capture_vol(codec, nid, label, HDA_INPUT); + err = create_elem_capture_vol(codec, nid, label, 0, HDA_INPUT); if (err < 0) return err; if (!err) { - err = create_elem_capture_vol(codec, nid, label, + err = create_elem_capture_vol(codec, nid, label, 0, HDA_OUTPUT); if (err < 0) return err; @@ -3540,10 +3548,11 @@ static int set_mic_route(struct hda_codec *codec, int i; mic->pin = pin; - for (i = AUTO_PIN_MIC; i <= AUTO_PIN_FRONT_MIC; i++) - if (pin == cfg->input_pins[i]) + for (i = 0; i < cfg->num_inputs; i++) { + if (pin == cfg->inputs[i].pin) break; - if (i <= AUTO_PIN_FRONT_MIC) { + } + if (i < cfg->num_inputs && cfg->inputs[i].type <= AUTO_PIN_FRONT_MIC) { /* analog pin */ i = get_connection_index(codec, spec->mux_nids[0], pin); if (i < 0) @@ -3577,13 +3586,13 @@ static int stac_check_auto_mic(struct hda_codec *codec) hda_nid_t fixed, ext; int i; - for (i = AUTO_PIN_LINE; i < AUTO_PIN_LAST; i++) { - if (cfg->input_pins[i]) + for (i = 0; i < cfg->num_inputs; i++) { + if (cfg->inputs[i].type >= AUTO_PIN_LINE) return 0; /* must be exclusively mics */ } fixed = ext = 0; - for (i = AUTO_PIN_MIC; i <= AUTO_PIN_FRONT_MIC; i++) - if (check_mic_pin(codec, cfg->input_pins[i], &fixed, &ext)) + for (i = 0; i < cfg->num_inputs; i++) + if (check_mic_pin(codec, cfg->inputs[i].pin, &fixed, &ext)) return 0; for (i = 0; i < spec->num_dmics; i++) if (check_mic_pin(codec, spec->dmic_nids[i], &fixed, &ext)) @@ -3603,14 +3612,12 @@ static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const { struct sigmatel_spec *spec = codec->spec; struct hda_input_mux *imux = &spec->private_imux; - int i, j; + int i, j, type_idx = 0; - for (i = 0; i < AUTO_PIN_LAST; i++) { - hda_nid_t nid = cfg->input_pins[i]; + for (i = 0; i < cfg->num_inputs; i++) { + hda_nid_t nid = cfg->inputs[i].pin; int index, err; - if (!nid) - continue; index = -1; for (j = 0; j < spec->num_muxes; j++) { index = get_connection_index(codec, spec->mux_nids[j], @@ -3621,13 +3628,18 @@ static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const if (index < 0) continue; + if (i > 0 && cfg->inputs[i].type == cfg->inputs[i - 1].type) + type_idx++; + else + type_idx = 0; err = create_elem_capture_vol(codec, nid, - auto_pin_cfg_labels[i], + auto_pin_cfg_labels[i], type_idx, HDA_INPUT); if (err < 0) return err; - imux->items[imux->num_items].label = auto_pin_cfg_labels[i]; + imux->items[imux->num_items].label = + snd_hda_get_input_pin_label(cfg, i); imux->items[imux->num_items].index = index; imux->num_items++; } @@ -4304,37 +4316,34 @@ static int stac92xx_init(struct hda_codec *codec) if (enable_pin_detect(codec, spec->ext_mic.pin, STAC_MIC_EVENT)) stac_issue_unsol_event(codec, spec->ext_mic.pin); } - for (i = 0; i < AUTO_PIN_LAST; i++) { - hda_nid_t nid = cfg->input_pins[i]; - if (nid) { - unsigned int pinctl, conf; - if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC) { - /* for mic pins, force to initialize */ - pinctl = stac92xx_get_default_vref(codec, nid); + for (i = 0; i < cfg->num_inputs; i++) { + hda_nid_t nid = cfg->inputs[i].pin; + int type = cfg->inputs[i].type; + unsigned int pinctl, conf; + if (type == AUTO_PIN_MIC || type == AUTO_PIN_FRONT_MIC) { + /* for mic pins, force to initialize */ + pinctl = stac92xx_get_default_vref(codec, nid); + pinctl |= AC_PINCTL_IN_EN; + stac92xx_auto_set_pinctl(codec, nid, pinctl); + } else { + pinctl = snd_hda_codec_read(codec, nid, 0, + AC_VERB_GET_PIN_WIDGET_CONTROL, 0); + /* if PINCTL already set then skip */ + /* Also, if both INPUT and OUTPUT are set, + * it must be a BIOS bug; need to override, too + */ + if (!(pinctl & AC_PINCTL_IN_EN) || + (pinctl & AC_PINCTL_OUT_EN)) { + pinctl &= ~AC_PINCTL_OUT_EN; pinctl |= AC_PINCTL_IN_EN; stac92xx_auto_set_pinctl(codec, nid, pinctl); - } else { - pinctl = snd_hda_codec_read(codec, nid, 0, - AC_VERB_GET_PIN_WIDGET_CONTROL, 0); - /* if PINCTL already set then skip */ - /* Also, if both INPUT and OUTPUT are set, - * it must be a BIOS bug; need to override, too - */ - if (!(pinctl & AC_PINCTL_IN_EN) || - (pinctl & AC_PINCTL_OUT_EN)) { - pinctl &= ~AC_PINCTL_OUT_EN; - pinctl |= AC_PINCTL_IN_EN; - stac92xx_auto_set_pinctl(codec, nid, - pinctl); - } - } - conf = snd_hda_codec_get_pincfg(codec, nid); - if (get_defcfg_connect(conf) != AC_JACK_PORT_FIXED) { - if (enable_pin_detect(codec, nid, - STAC_INSERT_EVENT)) - stac_issue_unsol_event(codec, nid); } } + conf = snd_hda_codec_get_pincfg(codec, nid); + if (get_defcfg_connect(conf) != AC_JACK_PORT_FIXED) { + if (enable_pin_detect(codec, nid, STAC_INSERT_EVENT)) + stac_issue_unsol_event(codec, nid); + } } for (i = 0; i < spec->num_dmics; i++) stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i], -- cgit v1.1 From 7b315bb4980448250c80a7464c256b54d546cb26 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Mon, 30 Aug 2010 13:06:30 +0200 Subject: ALSA: hda - Use new inputs[] field to parse input-pins for VIA codecs Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_via.c | 144 +++++++++++++++++++++++----------------------- 1 file changed, 73 insertions(+), 71 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_via.c b/sound/pci/hda/patch_via.c index 4186138..93b86ad 100644 --- a/sound/pci/hda/patch_via.c +++ b/sound/pci/hda/patch_via.c @@ -444,8 +444,8 @@ static hda_nid_t vt1812_adc_nids[2] = { /* add dynamic controls */ -static int via_add_control(struct via_spec *spec, int type, const char *name, - unsigned long val) +static int __via_add_control(struct via_spec *spec, int type, const char *name, + int idx, unsigned long val) { struct snd_kcontrol_new *knew; @@ -463,6 +463,9 @@ static int via_add_control(struct via_spec *spec, int type, const char *name, return 0; } +#define via_add_control(spec, type, name, val) \ + __via_add_control(spec, type, name, 0, val) + static struct snd_kcontrol_new *via_clone_control(struct via_spec *spec, struct snd_kcontrol_new *tmpl) { @@ -494,18 +497,18 @@ static void via_free_kctls(struct hda_codec *codec) /* create input playback/capture controls for the given pin */ static int via_new_analog_input(struct via_spec *spec, const char *ctlname, - int idx, int mix_nid) + int type_idx, int idx, int mix_nid) { char name[32]; int err; sprintf(name, "%s Playback Volume", ctlname); - err = via_add_control(spec, VIA_CTL_WIDGET_VOL, name, + err = __via_add_control(spec, VIA_CTL_WIDGET_VOL, name, type_idx, HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); if (err < 0) return err; sprintf(name, "%s Playback Switch", ctlname); - err = via_add_control(spec, VIA_CTL_WIDGET_ANALOG_MUTE, name, + err = __via_add_control(spec, VIA_CTL_WIDGET_ANALOG_MUTE, name, type_idx, HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT)); if (err < 0) return err; @@ -557,14 +560,12 @@ static int is_smart51_pins(struct via_spec *spec, hda_nid_t pin); static void via_auto_init_analog_input(struct hda_codec *codec) { struct via_spec *spec = codec->spec; + const struct auto_pin_cfg *cfg = &spec->autocfg; unsigned int ctl; int i; - for (i = 0; i < AUTO_PIN_LAST; i++) { - hda_nid_t nid = spec->autocfg.input_pins[i]; - if (!nid) - continue; - + for (i = 0; i < cfg->num_inputs; i++) { + hda_nid_t nid = cfg->inputs[i].pin; if (spec->smart51_enabled && is_smart51_pins(spec, nid)) ctl = PIN_OUT; else if (i <= AUTO_PIN_FRONT_MIC) @@ -1322,15 +1323,14 @@ static void mute_aa_path(struct hda_codec *codec, int mute) } static int is_smart51_pins(struct via_spec *spec, hda_nid_t pin) { - int res = 0; - int index; - for (index = AUTO_PIN_MIC; index < AUTO_PIN_FRONT_LINE; index++) { - if (pin == spec->autocfg.input_pins[index]) { - res = 1; - break; - } + const struct auto_pin_cfg *cfg = &spec->autocfg; + int i; + + for (i = 0; i < cfg->num_inputs; i++) { + if (pin == cfg->inputs[i].pin) + return cfg->inputs[i].type < AUTO_PIN_FRONT_LINE; } - return res; + return 0; } static int via_smart51_info(struct snd_kcontrol *kcontrol, @@ -1348,25 +1348,21 @@ static int via_smart51_get(struct snd_kcontrol *kcontrol, { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct via_spec *spec = codec->spec; - int index[] = { AUTO_PIN_MIC, AUTO_PIN_FRONT_MIC, AUTO_PIN_LINE }; + const struct auto_pin_cfg *cfg = &spec->autocfg; int on = 1; int i; - for (i = 0; i < ARRAY_SIZE(index); i++) { - hda_nid_t nid = spec->autocfg.input_pins[index[i]]; - if (nid) { - int ctl = - snd_hda_codec_read(codec, nid, 0, - AC_VERB_GET_PIN_WIDGET_CONTROL, - 0); - if (i == AUTO_PIN_FRONT_MIC - && spec->hp_independent_mode - && spec->codec_type != VT1718S) - continue; /* ignore FMic for independent HP */ - if (ctl & AC_PINCTL_IN_EN - && !(ctl & AC_PINCTL_OUT_EN)) - on = 0; - } + for (i = 0; i < cfg->num_inputs; i++) { + hda_nid_t nid = cfg->inputs[i].pin; + int ctl = snd_hda_codec_read(codec, nid, 0, + AC_VERB_GET_PIN_WIDGET_CONTROL, 0); + if (cfg->inputs[i].type >= AUTO_PIN_FRONT_LINE) + continue; + if (cfg->inputs[i].type == AUTO_PIN_FRONT_MIC && + spec->hp_independent_mode && spec->codec_type != VT1718S) + continue; /* ignore FMic for independent HP */ + if ((ctl & AC_PINCTL_IN_EN) && !(ctl & AC_PINCTL_OUT_EN)) + on = 0; } *ucontrol->value.integer.value = on; return 0; @@ -1377,36 +1373,38 @@ static int via_smart51_put(struct snd_kcontrol *kcontrol, { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct via_spec *spec = codec->spec; + const struct auto_pin_cfg *cfg = &spec->autocfg; int out_in = *ucontrol->value.integer.value ? AC_PINCTL_OUT_EN : AC_PINCTL_IN_EN; - int index[] = { AUTO_PIN_MIC, AUTO_PIN_FRONT_MIC, AUTO_PIN_LINE }; int i; - for (i = 0; i < ARRAY_SIZE(index); i++) { - hda_nid_t nid = spec->autocfg.input_pins[index[i]]; - if (i == AUTO_PIN_FRONT_MIC - && spec->hp_independent_mode - && spec->codec_type != VT1718S) + for (i = 0; i < cfg->num_inputs; i++) { + hda_nid_t nid = cfg->inputs[i].pin; + unsigned int parm; + + if (cfg->inputs[i].type >= AUTO_PIN_FRONT_LINE) + continue; + if (cfg->inputs[i].type == AUTO_PIN_FRONT_MIC && + spec->hp_independent_mode && spec->codec_type != VT1718S) continue; /* don't retask FMic for independent HP */ - if (nid) { - unsigned int parm = snd_hda_codec_read( - codec, nid, 0, - AC_VERB_GET_PIN_WIDGET_CONTROL, 0); - parm &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN); - parm |= out_in; - snd_hda_codec_write(codec, nid, 0, - AC_VERB_SET_PIN_WIDGET_CONTROL, - parm); - if (out_in == AC_PINCTL_OUT_EN) { - mute_aa_path(codec, 1); - notify_aa_path_ctls(codec); - } - if (spec->codec_type == VT1718S) - snd_hda_codec_amp_stereo( + + parm = snd_hda_codec_read(codec, nid, 0, + AC_VERB_GET_PIN_WIDGET_CONTROL, 0); + parm &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN); + parm |= out_in; + snd_hda_codec_write(codec, nid, 0, + AC_VERB_SET_PIN_WIDGET_CONTROL, + parm); + if (out_in == AC_PINCTL_OUT_EN) { + mute_aa_path(codec, 1); + notify_aa_path_ctls(codec); + } + if (spec->codec_type == VT1718S) { + snd_hda_codec_amp_stereo( codec, nid, HDA_OUTPUT, 0, HDA_AMP_MUTE, HDA_AMP_UNMUTE); } - if (i == AUTO_PIN_FRONT_MIC) { + if (cfg->inputs[i].type == AUTO_PIN_FRONT_MIC) { if (spec->codec_type == VT1708S || spec->codec_type == VT1716S) { /* input = index 1 (AOW3) */ @@ -1442,7 +1440,7 @@ static struct snd_kcontrol_new via_smart51_mixer[2] = { static int via_smart51_build(struct via_spec *spec) { struct snd_kcontrol_new *knew; - int index[] = { AUTO_PIN_MIC, AUTO_PIN_FRONT_MIC, AUTO_PIN_LINE }; + const struct auto_pin_cfg *cfg = &spec->autocfg; hda_nid_t nid; int i; @@ -1450,13 +1448,14 @@ static int via_smart51_build(struct via_spec *spec) if (knew == NULL) return -ENOMEM; - for (i = 0; i < ARRAY_SIZE(index); i++) { - nid = spec->autocfg.input_pins[index[i]]; - if (nid) { + for (i = 0; i < cfg->num_inputs; i++) { + nid = cfg->inputs[i].pin; + if (cfg->inputs[i].type < AUTO_PIN_FRONT_LINE) { knew = via_clone_control(spec, &via_smart51_mixer[1]); if (knew == NULL) return -ENOMEM; knew->subdevice = nid; + break; } } @@ -2419,7 +2418,7 @@ static int vt_auto_create_analog_input_ctls(struct via_spec *spec, hda_nid_t pin_idxs[], int num_idxs) { struct hda_input_mux *imux = &spec->private_imux[0]; - int i, err, idx; + int i, err, idx, type, type_idx = 0; /* for internal loopback recording select */ for (idx = 0; idx < num_idxs; idx++) { @@ -2431,20 +2430,23 @@ static int vt_auto_create_analog_input_ctls(struct via_spec *spec, } } - for (i = 0; i < AUTO_PIN_LAST; i++) { - if (!cfg->input_pins[i]) - continue; - + for (i = 0; i < cfg->num_inputs; i++) { + type = cfg->inputs[i].type; for (idx = 0; idx < num_idxs; idx++) - if (pin_idxs[idx] == cfg->input_pins[i]) + if (pin_idxs[idx] == cfg->inputs[i].pin) break; if (idx >= num_idxs) continue; - err = via_new_analog_input(spec, auto_pin_cfg_labels[i], - idx, cap_nid); + if (i > 0 && type == cfg->inputs[i - 1].type) + type_idx++; + else + type_idx = 0; + err = via_new_analog_input(spec, auto_pin_cfg_labels[type], + type_idx, idx, cap_nid); if (err < 0) return err; - imux->items[imux->num_items].label = auto_pin_cfg_labels[i]; + imux->items[imux->num_items].label = + snd_hda_get_input_pin_label(cfg, i); imux->items[imux->num_items].index = idx; imux->num_items++; } @@ -5513,7 +5515,7 @@ static int vt2002P_auto_create_analog_input_ctls(struct via_spec *spec, if (err < 0) return err; /* build volume/mute control of loopback */ - err = via_new_analog_input(spec, "Stereo Mixer", 3, 0x21); + err = via_new_analog_input(spec, "Stereo Mixer", 0, 3, 0x21); if (err < 0) return err; @@ -5836,7 +5838,7 @@ static int vt1812_auto_create_analog_input_ctls(struct via_spec *spec, return err; /* build volume/mute control of loopback */ - err = via_new_analog_input(spec, "Stereo Mixer", 5, 0x21); + err = via_new_analog_input(spec, "Stereo Mixer", 0, 5, 0x21); if (err < 0) return err; -- cgit v1.1 From 048e78a5bc22c27410cb5ca9680c3c7ac400607f Mon Sep 17 00:00:00 2001 From: David Henningsson Date: Thu, 2 Sep 2010 08:35:47 +0200 Subject: ALSA: hda - Add a new hp-laptop model for Conexant 5066, tested on HP G60 This new model adds the following functionality to HP G60: - Automute of internal speakers - Autoswitch of internal/external mics - Remove SPDIF not physically present BugLink: http://launchpad.net/bugs/587388 Cc: stable@kernel.org Signed-off-by: David Henningsson Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_conexant.c | 57 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) (limited to 'sound') diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c index 5cdb80e..4f06199 100644 --- a/sound/pci/hda/patch_conexant.c +++ b/sound/pci/hda/patch_conexant.c @@ -116,6 +116,7 @@ struct conexant_spec { unsigned int dell_vostro:1; unsigned int ideapad:1; unsigned int thinkpad:1; + unsigned int hp_laptop:1; unsigned int ext_mic_present; unsigned int recording; @@ -2299,6 +2300,18 @@ static void cxt5066_ideapad_automic(struct hda_codec *codec) } } +/* toggle input of built-in digital mic and mic jack appropriately */ +static void cxt5066_hp_laptop_automic(struct hda_codec *codec) +{ + unsigned int present; + + present = snd_hda_jack_detect(codec, 0x1b); + snd_printdd("CXT5066: external microphone present=%d\n", present); + snd_hda_codec_write(codec, 0x17, 0, AC_VERB_SET_CONNECT_SEL, + present ? 1 : 3); +} + + /* toggle input of built-in digital mic and mic jack appropriately order is: external mic -> dock mic -> interal mic */ static void cxt5066_thinkpad_automic(struct hda_codec *codec) @@ -2408,6 +2421,20 @@ static void cxt5066_ideapad_event(struct hda_codec *codec, unsigned int res) } /* unsolicited event for jack sensing */ +static void cxt5066_hp_laptop_event(struct hda_codec *codec, unsigned int res) +{ + snd_printdd("CXT5066_hp_laptop: unsol event %x (%x)\n", res, res >> 26); + switch (res >> 26) { + case CONEXANT_HP_EVENT: + cxt5066_hp_automute(codec); + break; + case CONEXANT_MIC_EVENT: + cxt5066_hp_laptop_automic(codec); + break; + } +} + +/* unsolicited event for jack sensing */ static void cxt5066_thinkpad_event(struct hda_codec *codec, unsigned int res) { snd_printdd("CXT5066_thinkpad: unsol event %x (%x)\n", res, res >> 26); @@ -2989,6 +3016,14 @@ static struct hda_verb cxt5066_init_verbs_portd_lo[] = { { } /* end */ }; + +static struct hda_verb cxt5066_init_verbs_hp_laptop[] = { + {0x14, AC_VERB_SET_CONNECT_SEL, 0x0}, + {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_HP_EVENT}, + {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | CONEXANT_MIC_EVENT}, + { } /* end */ +}; + /* initialize jack-sensing, too */ static int cxt5066_init(struct hda_codec *codec) { @@ -3004,6 +3039,8 @@ static int cxt5066_init(struct hda_codec *codec) cxt5066_ideapad_automic(codec); else if (spec->thinkpad) cxt5066_thinkpad_automic(codec); + else if (spec->hp_laptop) + cxt5066_hp_laptop_automic(codec); } cxt5066_set_mic_boost(codec); return 0; @@ -3031,6 +3068,7 @@ enum { CXT5066_DELL_VOSTO, /* Dell Vostro 1015i */ CXT5066_IDEAPAD, /* Lenovo IdeaPad U150 */ CXT5066_THINKPAD, /* Lenovo ThinkPad T410s, others? */ + CXT5066_HP_LAPTOP, /* HP Laptop */ CXT5066_MODELS }; @@ -3041,6 +3079,7 @@ static const char *cxt5066_models[CXT5066_MODELS] = { [CXT5066_DELL_VOSTO] = "dell-vostro", [CXT5066_IDEAPAD] = "ideapad", [CXT5066_THINKPAD] = "thinkpad", + [CXT5066_HP_LAPTOP] = "hp-laptop", }; static struct snd_pci_quirk cxt5066_cfg_tbl[] = { @@ -3052,6 +3091,7 @@ static struct snd_pci_quirk cxt5066_cfg_tbl[] = { SND_PCI_QUIRK(0x1028, 0x02d8, "Dell Vostro", CXT5066_DELL_VOSTO), SND_PCI_QUIRK(0x1028, 0x0402, "Dell Vostro", CXT5066_DELL_VOSTO), SND_PCI_QUIRK(0x1028, 0x0408, "Dell Inspiron One 19T", CXT5066_IDEAPAD), + SND_PCI_QUIRK(0x103c, 0x360b, "HP G60", CXT5066_HP_LAPTOP), SND_PCI_QUIRK(0x1179, 0xff50, "Toshiba Satellite P500-PSPGSC-01800T", CXT5066_OLPC_XO_1_5), SND_PCI_QUIRK(0x1179, 0xffe0, "Toshiba Satellite Pro T130-15F", CXT5066_OLPC_XO_1_5), SND_PCI_QUIRK(0x17aa, 0x21b2, "Thinkpad X100e", CXT5066_IDEAPAD), @@ -3116,6 +3156,23 @@ static int patch_cxt5066(struct hda_codec *codec) spec->num_init_verbs++; spec->dell_automute = 1; break; + case CXT5066_HP_LAPTOP: + codec->patch_ops.init = cxt5066_init; + codec->patch_ops.unsol_event = cxt5066_hp_laptop_event; + spec->init_verbs[spec->num_init_verbs] = + cxt5066_init_verbs_hp_laptop; + spec->num_init_verbs++; + spec->hp_laptop = 1; + spec->mixers[spec->num_mixers++] = cxt5066_mixer_master; + spec->mixers[spec->num_mixers++] = cxt5066_mixers; + /* no S/PDIF out */ + spec->multiout.dig_out_nid = 0; + /* input source automatically selected */ + spec->input_mux = NULL; + spec->port_d_mode = 0; + spec->mic_boost = 3; /* default 30dB gain */ + break; + case CXT5066_OLPC_XO_1_5: codec->patch_ops.init = cxt5066_olpc_init; codec->patch_ops.unsol_event = cxt5066_olpc_unsol_event; -- cgit v1.1 From 65f04443c96dbda11b8fff21d6390e082846aa3c Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Thu, 2 Sep 2010 12:58:25 +0200 Subject: ALSA: usb-audio: fix Fast Track Ultra (8R) 44.1 sample rates The M-Audio Fast Track Ultra series devices did not play sound correctly at 44.1/88.2 kHz. Changing the output endpoint attribute to adaptive fixes this. Signed-off-by: Felix Homann Signed-off-by: Clemens Ladisch Signed-off-by: Takashi Iwai --- sound/usb/endpoint.c | 2 -- sound/usb/quirks-table.h | 90 +++++++++++++++++++++++++++++++++++++++++++++--- 2 files changed, 85 insertions(+), 7 deletions(-) (limited to 'sound') diff --git a/sound/usb/endpoint.c b/sound/usb/endpoint.c index 1a701f1..bb9f938 100644 --- a/sound/usb/endpoint.c +++ b/sound/usb/endpoint.c @@ -404,8 +404,6 @@ int snd_usb_parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no) break; case USB_ID(0x041e, 0x3020): /* Creative SB Audigy 2 NX */ case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */ - case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra 8 */ - case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */ /* doesn't set the sample rate attribute, but supports it */ fp->attributes |= UAC_EP_CS_ATTR_SAMPLE_RATE; break; diff --git a/sound/usb/quirks-table.h b/sound/usb/quirks-table.h index 2e8003f..4818fbd 100644 --- a/sound/usb/quirks-table.h +++ b/sound/usb/quirks-table.h @@ -1830,7 +1830,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), USB_DEVICE(0x0763, 0x2080), .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { /* .vendor_name = "M-Audio", */ - /* .product_name = "Fast Track Ultra 8", */ + /* .product_name = "Fast Track Ultra", */ .ifnum = QUIRK_ANY_INTERFACE, .type = QUIRK_COMPOSITE, .data = & (const struct snd_usb_audio_quirk[]) { @@ -1840,11 +1840,51 @@ YAMAHA_DEVICE(0x7010, "UB99"), }, { .ifnum = 1, - .type = QUIRK_AUDIO_STANDARD_INTERFACE + .type = QUIRK_AUDIO_FIXED_ENDPOINT, + .data = & (const struct audioformat) { + .formats = SNDRV_PCM_FMTBIT_S24_3LE, + .channels = 8, + .iface = 1, + .altsetting = 1, + .altset_idx = 1, + .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, + .endpoint = 0x01, + .ep_attr = 0x09, + .rates = SNDRV_PCM_RATE_44100 | + SNDRV_PCM_RATE_48000 | + SNDRV_PCM_RATE_88200 | + SNDRV_PCM_RATE_96000, + .rate_min = 44100, + .rate_max = 96000, + .nr_rates = 4, + .rate_table = (unsigned int[]) { + 44100, 48000, 88200, 96000 + } + } }, { .ifnum = 2, - .type = QUIRK_AUDIO_STANDARD_INTERFACE + .type = QUIRK_AUDIO_FIXED_ENDPOINT, + .data = & (const struct audioformat) { + .formats = SNDRV_PCM_FMTBIT_S24_3LE, + .channels = 8, + .iface = 2, + .altsetting = 1, + .altset_idx = 1, + .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, + .endpoint = 0x81, + .ep_attr = 0x05, + .rates = SNDRV_PCM_RATE_44100 | + SNDRV_PCM_RATE_48000 | + SNDRV_PCM_RATE_88200 | + SNDRV_PCM_RATE_96000, + .rate_min = 44100, + .rate_max = 96000, + .nr_rates = 4, + .rate_table = (unsigned int[]) { + 44100, 48000, 88200, 96000 + } + } }, /* interface 3 (MIDI) is standard compliant */ { @@ -1867,11 +1907,51 @@ YAMAHA_DEVICE(0x7010, "UB99"), }, { .ifnum = 1, - .type = QUIRK_AUDIO_STANDARD_INTERFACE + .type = QUIRK_AUDIO_FIXED_ENDPOINT, + .data = & (const struct audioformat) { + .formats = SNDRV_PCM_FMTBIT_S24_3LE, + .channels = 8, + .iface = 1, + .altsetting = 1, + .altset_idx = 1, + .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, + .endpoint = 0x01, + .ep_attr = 0x09, + .rates = SNDRV_PCM_RATE_44100 | + SNDRV_PCM_RATE_48000 | + SNDRV_PCM_RATE_88200 | + SNDRV_PCM_RATE_96000, + .rate_min = 44100, + .rate_max = 96000, + .nr_rates = 4, + .rate_table = (unsigned int[]) { + 44100, 48000, 88200, 96000 + } + } }, { .ifnum = 2, - .type = QUIRK_AUDIO_STANDARD_INTERFACE + .type = QUIRK_AUDIO_FIXED_ENDPOINT, + .data = & (const struct audioformat) { + .formats = SNDRV_PCM_FMTBIT_S24_3LE, + .channels = 8, + .iface = 2, + .altsetting = 1, + .altset_idx = 1, + .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE, + .endpoint = 0x81, + .ep_attr = 0x05, + .rates = SNDRV_PCM_RATE_44100 | + SNDRV_PCM_RATE_48000 | + SNDRV_PCM_RATE_88200 | + SNDRV_PCM_RATE_96000, + .rate_min = 44100, + .rate_max = 96000, + .nr_rates = 4, + .rate_table = (unsigned int[]) { + 44100, 48000, 88200, 96000 + } + } }, /* interface 3 (MIDI) is standard compliant */ { -- cgit v1.1 From 7b6717e144de6592e614fd7fc3b914b6bf686a9d Mon Sep 17 00:00:00 2001 From: Daniel Mack Date: Thu, 2 Sep 2010 17:13:15 +0800 Subject: ALSA: usb-audio: Assume first control interface is for audio For devices with more than one control interface, let's assume the first one contains the audio controls. Unfortunately, there is no field in any of the descriptors to tell us whether a control interface is for audio or MIDI controls, so a better check is not easy to implement. On a composite device with audio and MIDI functions, for example, the code currently overwrites chip->ctrl_intf, causing operations on the control interface to fail if they are issued after the device probe. Signed-off-by: Daniel Mack Signed-off-by: Takashi Iwai --- sound/usb/card.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/usb/card.c b/sound/usb/card.c index 9feb00c..b443a33 100644 --- a/sound/usb/card.c +++ b/sound/usb/card.c @@ -465,7 +465,13 @@ static void *snd_usb_audio_probe(struct usb_device *dev, goto __error; } - chip->ctrl_intf = alts; + /* + * For devices with more than one control interface, we assume the + * first contains the audio controls. We might need a more specific + * check here in the future. + */ + if (!chip->ctrl_intf) + chip->ctrl_intf = alts; if (err > 0) { /* create normal USB audio interfaces */ -- cgit v1.1 From aa70201fdc374f245cfa1874e11df145ace3ffaf Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Mon, 30 Aug 2010 16:32:43 +0200 Subject: ALSA: usb-audio: add Edirol PCR-1 PCM support Add a quirk for the other logical device of the PCR-1 so that not only the MIDI interface but also the audio interface works. Signed-off-by: Clemens Ladisch Signed-off-by: Takashi Iwai --- sound/usb/quirks-table.h | 27 +++++++++++++++++++++++++-- 1 file changed, 25 insertions(+), 2 deletions(-) (limited to 'sound') diff --git a/sound/usb/quirks-table.h b/sound/usb/quirks-table.h index 4818fbd..838b81b 100644 --- a/sound/usb/quirks-table.h +++ b/sound/usb/quirks-table.h @@ -1136,11 +1136,34 @@ YAMAHA_DEVICE(0x7010, "UB99"), } }, { + /* has ID 0x0066 when not in "Advanced Driver" mode */ + USB_DEVICE(0x0582, 0x0064), + .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + /* .vendor_name = "EDIROL", */ + /* .product_name = "PCR-1", */ + .ifnum = QUIRK_ANY_INTERFACE, + .type = QUIRK_COMPOSITE, + .data = (const struct snd_usb_audio_quirk[]) { + { + .ifnum = 1, + .type = QUIRK_AUDIO_STANDARD_INTERFACE + }, + { + .ifnum = 2, + .type = QUIRK_AUDIO_STANDARD_INTERFACE + }, + { + .ifnum = -1 + } + } + } +}, +{ /* has ID 0x0067 when not in "Advanced Driver" mode */ USB_DEVICE(0x0582, 0x0065), .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { - .vendor_name = "EDIROL", - .product_name = "PCR-1", + /* .vendor_name = "EDIROL", */ + /* .product_name = "PCR-1", */ .ifnum = 0, .type = QUIRK_MIDI_FIXED_ENDPOINT, .data = & (const struct snd_usb_midi_endpoint_info) { -- cgit v1.1 From 9d0c91938e3a42c683e4e55d108b928e89a3bbc4 Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Mon, 30 Aug 2010 16:42:17 +0200 Subject: ALSA: usb-audio: add Roland A-PRO support Add a quirk for the Roland/Cakewalk A-300PRO/A-500PRO/A-800PRO keyboards. Signed-off-by: Clemens Ladisch Signed-off-by: Takashi Iwai --- sound/usb/quirks-table.h | 14 ++++++++++++++ 1 file changed, 14 insertions(+) (limited to 'sound') diff --git a/sound/usb/quirks-table.h b/sound/usb/quirks-table.h index 838b81b..92f099a8 100644 --- a/sound/usb/quirks-table.h +++ b/sound/usb/quirks-table.h @@ -1548,6 +1548,20 @@ YAMAHA_DEVICE(0x7010, "UB99"), } } }, +{ + /* has ID 0x0110 when not in Advanced Driver mode */ + USB_DEVICE_VENDOR_SPEC(0x0582, 0x010f), + .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + /* .vendor_name = "Roland", */ + /* .product_name = "A-PRO", */ + .ifnum = 1, + .type = QUIRK_MIDI_FIXED_ENDPOINT, + .data = & (const struct snd_usb_midi_endpoint_info) { + .out_cables = 0x0003, + .in_cables = 0x0007 + } + } +}, /* Guillemot devices */ { -- cgit v1.1 From 7b28079b3284ccb15ad4f003fb7073890600d0c1 Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Mon, 30 Aug 2010 16:45:38 +0200 Subject: ALSA: usb-audio: add BOSS ME-25 support Add a quirk to make the BOSS ME-25 work. Many thanks to Kees van Veen. Signed-off-by: Clemens Ladisch Signed-off-by: Takashi Iwai --- sound/usb/quirks-table.h | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) (limited to 'sound') diff --git a/sound/usb/quirks-table.h b/sound/usb/quirks-table.h index 92f099a8..c86c613 100644 --- a/sound/usb/quirks-table.h +++ b/sound/usb/quirks-table.h @@ -1562,6 +1562,36 @@ YAMAHA_DEVICE(0x7010, "UB99"), } } }, +{ + USB_DEVICE(0x0582, 0x0113), + .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + /* .vendor_name = "BOSS", */ + /* .product_name = "ME-25", */ + .ifnum = QUIRK_ANY_INTERFACE, + .type = QUIRK_COMPOSITE, + .data = (const struct snd_usb_audio_quirk[]) { + { + .ifnum = 0, + .type = QUIRK_AUDIO_STANDARD_INTERFACE + }, + { + .ifnum = 1, + .type = QUIRK_AUDIO_STANDARD_INTERFACE + }, + { + .ifnum = 2, + .type = QUIRK_MIDI_FIXED_ENDPOINT, + .data = & (const struct snd_usb_midi_endpoint_info) { + .out_cables = 0x0001, + .in_cables = 0x0001 + } + }, + { + .ifnum = -1 + } + } + } +}, /* Guillemot devices */ { -- cgit v1.1 From a2acad8298a42b7be684a32fafaf83332bba9c2b Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Fri, 3 Sep 2010 10:53:11 +0200 Subject: ALSA: usb-audio: fix detection of vendor-specific device protocol settings The Audio Class v2 support code in 2.6.35 added checks for the bInterfaceProtocol field. However, there are devices (usually those detected by vendor-specific quirks) that do not have one of the predefined values in this field, which made the driver reject them. To fix this regression, restore the old behaviour, i.e., assume that a device with an unknown bInterfaceProtocol field (other than UAC_VERSION_2) has more or less UAC-v1-compatible descriptors. [compile warning fixes by tiwai] Signed-off-by: Clemens Ladisch Cc: Daniel Mack Cc: Signed-off-by: Takashi Iwai --- sound/usb/card.c | 9 +++++---- sound/usb/clock.c | 3 +-- sound/usb/endpoint.c | 11 ++++++----- sound/usb/format.c | 22 ++++++++++------------ sound/usb/mixer.c | 10 +++++++++- sound/usb/pcm.c | 3 +-- 6 files changed, 32 insertions(+), 26 deletions(-) (limited to 'sound') diff --git a/sound/usb/card.c b/sound/usb/card.c index b443a33..32e4be8 100644 --- a/sound/usb/card.c +++ b/sound/usb/card.c @@ -216,6 +216,11 @@ static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif) } switch (protocol) { + default: + snd_printdd(KERN_WARNING "unknown interface protocol %#02x, assuming v1\n", + protocol); + /* fall through */ + case UAC_VERSION_1: { struct uac1_ac_header_descriptor *h1 = control_header; @@ -253,10 +258,6 @@ static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif) break; } - - default: - snd_printk(KERN_ERR "unknown protocol version 0x%02x\n", protocol); - return -EINVAL; } return 0; diff --git a/sound/usb/clock.c b/sound/usb/clock.c index b853f8d..7754a10 100644 --- a/sound/usb/clock.c +++ b/sound/usb/clock.c @@ -295,12 +295,11 @@ int snd_usb_init_sample_rate(struct snd_usb_audio *chip, int iface, switch (altsd->bInterfaceProtocol) { case UAC_VERSION_1: + default: return set_sample_rate_v1(chip, iface, alts, fmt, rate); case UAC_VERSION_2: return set_sample_rate_v2(chip, iface, alts, fmt, rate); } - - return -EINVAL; } diff --git a/sound/usb/endpoint.c b/sound/usb/endpoint.c index 1a701f1..ef0a07e 100644 --- a/sound/usb/endpoint.c +++ b/sound/usb/endpoint.c @@ -275,6 +275,12 @@ int snd_usb_parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no) /* get audio formats */ switch (protocol) { + default: + snd_printdd(KERN_WARNING "%d:%u:%d: unknown interface protocol %#02x, assuming v1\n", + dev->devnum, iface_no, altno, protocol); + protocol = UAC_VERSION_1; + /* fall through */ + case UAC_VERSION_1: { struct uac1_as_header_descriptor *as = snd_usb_find_csint_desc(alts->extra, alts->extralen, NULL, UAC_AS_GENERAL); @@ -336,11 +342,6 @@ int snd_usb_parse_audio_endpoints(struct snd_usb_audio *chip, int iface_no) dev->devnum, iface_no, altno, as->bTerminalLink); continue; } - - default: - snd_printk(KERN_ERR "%d:%u:%d : unknown interface protocol %04x\n", - dev->devnum, iface_no, altno, protocol); - continue; } /* get format type */ diff --git a/sound/usb/format.c b/sound/usb/format.c index 3a13754..6914821 100644 --- a/sound/usb/format.c +++ b/sound/usb/format.c @@ -49,7 +49,8 @@ static u64 parse_audio_format_i_type(struct snd_usb_audio *chip, u64 pcm_formats; switch (protocol) { - case UAC_VERSION_1: { + case UAC_VERSION_1: + default: { struct uac_format_type_i_discrete_descriptor *fmt = _fmt; sample_width = fmt->bBitResolution; sample_bytes = fmt->bSubframeSize; @@ -64,9 +65,6 @@ static u64 parse_audio_format_i_type(struct snd_usb_audio *chip, format <<= 1; break; } - - default: - return -EINVAL; } pcm_formats = 0; @@ -384,6 +382,10 @@ static int parse_audio_format_i(struct snd_usb_audio *chip, * audio class v2 uses class specific EP0 range requests for that. */ switch (protocol) { + default: + snd_printdd(KERN_WARNING "%d:%u:%d : invalid protocol version %d, assuming v1\n", + chip->dev->devnum, fp->iface, fp->altsetting, protocol); + /* fall through */ case UAC_VERSION_1: fp->channels = fmt->bNrChannels; ret = parse_audio_format_rates_v1(chip, fp, (unsigned char *) fmt, 7); @@ -392,10 +394,6 @@ static int parse_audio_format_i(struct snd_usb_audio *chip, /* fp->channels is already set in this case */ ret = parse_audio_format_rates_v2(chip, fp); break; - default: - snd_printk(KERN_ERR "%d:%u:%d : invalid protocol version %d\n", - chip->dev->devnum, fp->iface, fp->altsetting, protocol); - return -EINVAL; } if (fp->channels < 1) { @@ -438,6 +436,10 @@ static int parse_audio_format_ii(struct snd_usb_audio *chip, fp->channels = 1; switch (protocol) { + default: + snd_printdd(KERN_WARNING "%d:%u:%d : invalid protocol version %d, assuming v1\n", + chip->dev->devnum, fp->iface, fp->altsetting, protocol); + /* fall through */ case UAC_VERSION_1: { struct uac_format_type_ii_discrete_descriptor *fmt = _fmt; brate = le16_to_cpu(fmt->wMaxBitRate); @@ -456,10 +458,6 @@ static int parse_audio_format_ii(struct snd_usb_audio *chip, ret = parse_audio_format_rates_v2(chip, fp); break; } - default: - snd_printk(KERN_ERR "%d:%u:%d : invalid protocol version %d\n", - chip->dev->devnum, fp->iface, fp->altsetting, protocol); - return -EINVAL; } return ret; diff --git a/sound/usb/mixer.c b/sound/usb/mixer.c index c166db0..3ed3901 100644 --- a/sound/usb/mixer.c +++ b/sound/usb/mixer.c @@ -2175,7 +2175,15 @@ int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif, } host_iface = &usb_ifnum_to_if(chip->dev, ctrlif)->altsetting[0]; - mixer->protocol = get_iface_desc(host_iface)->bInterfaceProtocol; + switch (get_iface_desc(host_iface)->bInterfaceProtocol) { + case UAC_VERSION_1: + default: + mixer->protocol = UAC_VERSION_1; + break; + case UAC_VERSION_2: + mixer->protocol = UAC_VERSION_2; + break; + } if ((err = snd_usb_mixer_controls(mixer)) < 0 || (err = snd_usb_mixer_status_create(mixer)) < 0) diff --git a/sound/usb/pcm.c b/sound/usb/pcm.c index 3634ced..3b5135c 100644 --- a/sound/usb/pcm.c +++ b/sound/usb/pcm.c @@ -173,13 +173,12 @@ int snd_usb_init_pitch(struct snd_usb_audio *chip, int iface, switch (altsd->bInterfaceProtocol) { case UAC_VERSION_1: + default: return init_pitch_v1(chip, iface, alts, fmt); case UAC_VERSION_2: return init_pitch_v2(chip, iface, alts, fmt); } - - return -EINVAL; } /* -- cgit v1.1 From 9fe856e47e1751204faf3d604c6d20ab24bd3b93 Mon Sep 17 00:00:00 2001 From: Joe Perches Date: Sat, 4 Sep 2010 18:52:54 -0700 Subject: sound: Remove unnecessary casts of private_data Signed-off-by: Joe Perches Signed-off-by: Takashi Iwai --- sound/core/oss/mixer_oss.c | 22 +++++++++++----------- sound/core/pcm.c | 3 +-- sound/drivers/virmidi.c | 2 +- sound/i2c/other/ak4xxx-adda.c | 2 +- sound/isa/ad1816a/ad1816a.c | 2 +- sound/isa/azt2320.c | 2 +- sound/isa/gus/gusmax.c | 4 ++-- sound/isa/sb/sb8.c | 2 +- sound/oss/au1550_ac97.c | 18 +++++++++--------- sound/pci/emu10k1/emumpu401.c | 2 +- sound/pci/ice1712/pontis.c | 6 +++--- sound/pci/ice1712/prodigy192.c | 2 +- sound/pci/rme96.c | 8 ++++---- sound/pci/rme9652/hdsp.c | 8 ++++---- 14 files changed, 41 insertions(+), 42 deletions(-) (limited to 'sound') diff --git a/sound/core/oss/mixer_oss.c b/sound/core/oss/mixer_oss.c index f50ebf2..86afb13c 100644 --- a/sound/core/oss/mixer_oss.c +++ b/sound/core/oss/mixer_oss.c @@ -77,7 +77,7 @@ static int snd_mixer_oss_release(struct inode *inode, struct file *file) struct snd_mixer_oss_file *fmixer; if (file->private_data) { - fmixer = (struct snd_mixer_oss_file *) file->private_data; + fmixer = file->private_data; module_put(fmixer->card->module); snd_card_file_remove(fmixer->card, file); kfree(fmixer); @@ -368,7 +368,7 @@ static int snd_mixer_oss_ioctl1(struct snd_mixer_oss_file *fmixer, unsigned int static long snd_mixer_oss_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - return snd_mixer_oss_ioctl1((struct snd_mixer_oss_file *) file->private_data, cmd, arg); + return snd_mixer_oss_ioctl1(file->private_data, cmd, arg); } int snd_mixer_oss_ioctl_card(struct snd_card *card, unsigned int cmd, unsigned long arg) @@ -582,7 +582,7 @@ static int snd_mixer_oss_get_volume1(struct snd_mixer_oss_file *fmixer, struct snd_mixer_oss_slot *pslot, int *left, int *right) { - struct slot *slot = (struct slot *)pslot->private_data; + struct slot *slot = pslot->private_data; *left = *right = 100; if (slot->present & SNDRV_MIXER_OSS_PRESENT_PVOLUME) { @@ -691,7 +691,7 @@ static int snd_mixer_oss_put_volume1(struct snd_mixer_oss_file *fmixer, struct snd_mixer_oss_slot *pslot, int left, int right) { - struct slot *slot = (struct slot *)pslot->private_data; + struct slot *slot = pslot->private_data; if (slot->present & SNDRV_MIXER_OSS_PRESENT_PVOLUME) { snd_mixer_oss_put_volume1_vol(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_PVOLUME], left, right); @@ -740,7 +740,7 @@ static int snd_mixer_oss_get_recsrc1_sw(struct snd_mixer_oss_file *fmixer, struct snd_mixer_oss_slot *pslot, int *active) { - struct slot *slot = (struct slot *)pslot->private_data; + struct slot *slot = pslot->private_data; int left, right; left = right = 1; @@ -753,7 +753,7 @@ static int snd_mixer_oss_get_recsrc1_route(struct snd_mixer_oss_file *fmixer, struct snd_mixer_oss_slot *pslot, int *active) { - struct slot *slot = (struct slot *)pslot->private_data; + struct slot *slot = pslot->private_data; int left, right; left = right = 1; @@ -766,7 +766,7 @@ static int snd_mixer_oss_put_recsrc1_sw(struct snd_mixer_oss_file *fmixer, struct snd_mixer_oss_slot *pslot, int active) { - struct slot *slot = (struct slot *)pslot->private_data; + struct slot *slot = pslot->private_data; snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CSWITCH], active, active, 0); return 0; @@ -776,7 +776,7 @@ static int snd_mixer_oss_put_recsrc1_route(struct snd_mixer_oss_file *fmixer, struct snd_mixer_oss_slot *pslot, int active) { - struct slot *slot = (struct slot *)pslot->private_data; + struct slot *slot = pslot->private_data; snd_mixer_oss_put_volume1_sw(fmixer, pslot, slot->numid[SNDRV_MIXER_OSS_ITEM_CROUTE], active, active, 1); return 0; @@ -813,7 +813,7 @@ static int snd_mixer_oss_get_recsrc2(struct snd_mixer_oss_file *fmixer, unsigned if (!(mixer->mask_recsrc & (1 << idx))) continue; pslot = &mixer->slots[idx]; - slot = (struct slot *)pslot->private_data; + slot = pslot->private_data; if (slot->signature != SNDRV_MIXER_OSS_SIGNATURE) continue; if (!(slot->present & SNDRV_MIXER_OSS_PRESENT_CAPTURE)) @@ -861,7 +861,7 @@ static int snd_mixer_oss_put_recsrc2(struct snd_mixer_oss_file *fmixer, unsigned if (!(mixer->mask_recsrc & (1 << idx))) continue; pslot = &mixer->slots[idx]; - slot = (struct slot *)pslot->private_data; + slot = pslot->private_data; if (slot->signature != SNDRV_MIXER_OSS_SIGNATURE) continue; if (!(slot->present & SNDRV_MIXER_OSS_PRESENT_CAPTURE)) @@ -925,7 +925,7 @@ static int snd_mixer_oss_build_test(struct snd_mixer_oss *mixer, struct slot *sl static void snd_mixer_oss_slot_free(struct snd_mixer_oss_slot *chn) { - struct slot *p = (struct slot *)chn->private_data; + struct slot *p = chn->private_data; if (p) { if (p->allocated && p->assigned) { kfree(p->assigned->name); diff --git a/sound/core/pcm.c b/sound/core/pcm.c index 204af48..88525a9 100644 --- a/sound/core/pcm.c +++ b/sound/core/pcm.c @@ -364,8 +364,7 @@ static void snd_pcm_stream_proc_info_read(struct snd_info_entry *entry, static void snd_pcm_substream_proc_info_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { - snd_pcm_proc_info_read((struct snd_pcm_substream *)entry->private_data, - buffer); + snd_pcm_proc_info_read(entry->private_data, buffer); } static void snd_pcm_substream_proc_hw_params_read(struct snd_info_entry *entry, diff --git a/sound/drivers/virmidi.c b/sound/drivers/virmidi.c index 0e631c3..f4cd493 100644 --- a/sound/drivers/virmidi.c +++ b/sound/drivers/virmidi.c @@ -94,7 +94,7 @@ static int __devinit snd_virmidi_probe(struct platform_device *devptr) sizeof(struct snd_card_virmidi), &card); if (err < 0) return err; - vmidi = (struct snd_card_virmidi *)card->private_data; + vmidi = card->private_data; vmidi->card = card; if (midi_devs[dev] > MAX_MIDI_DEVICES) { diff --git a/sound/i2c/other/ak4xxx-adda.c b/sound/i2c/other/ak4xxx-adda.c index 1adb8a3..ebab6c7 100644 --- a/sound/i2c/other/ak4xxx-adda.c +++ b/sound/i2c/other/ak4xxx-adda.c @@ -878,7 +878,7 @@ static int build_deemphasis(struct snd_akm4xxx *ak, int num_emphs) static void proc_regs_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { - struct snd_akm4xxx *ak = (struct snd_akm4xxx *)entry->private_data; + struct snd_akm4xxx *ak = entry->private_data; int reg, val, chip; for (chip = 0; chip < ak->num_chips; chip++) { for (reg = 0; reg < ak->total_regs; reg++) { diff --git a/sound/isa/ad1816a/ad1816a.c b/sound/isa/ad1816a/ad1816a.c index bbcbf92..3cb75bc 100644 --- a/sound/isa/ad1816a/ad1816a.c +++ b/sound/isa/ad1816a/ad1816a.c @@ -162,7 +162,7 @@ static int __devinit snd_card_ad1816a_probe(int dev, struct pnp_card_link *pcard sizeof(struct snd_card_ad1816a), &card); if (error < 0) return error; - acard = (struct snd_card_ad1816a *)card->private_data; + acard = card->private_data; if ((error = snd_card_ad1816a_pnp(dev, acard, pcard, pid))) { snd_card_free(card); diff --git a/sound/isa/azt2320.c b/sound/isa/azt2320.c index f7aa637..aac8dc1 100644 --- a/sound/isa/azt2320.c +++ b/sound/isa/azt2320.c @@ -188,7 +188,7 @@ static int __devinit snd_card_azt2320_probe(int dev, sizeof(struct snd_card_azt2320), &card); if (error < 0) return error; - acard = (struct snd_card_azt2320 *)card->private_data; + acard = card->private_data; if ((error = snd_card_azt2320_pnp(dev, acard, pcard, pid))) { snd_card_free(card); diff --git a/sound/isa/gus/gusmax.c b/sound/isa/gus/gusmax.c index f26eac8..3e4a58b 100644 --- a/sound/isa/gus/gusmax.c +++ b/sound/isa/gus/gusmax.c @@ -191,7 +191,7 @@ static int __devinit snd_gusmax_mixer(struct snd_wss *chip) static void snd_gusmax_free(struct snd_card *card) { - struct snd_gusmax *maxcard = (struct snd_gusmax *)card->private_data; + struct snd_gusmax *maxcard = card->private_data; if (maxcard == NULL) return; @@ -219,7 +219,7 @@ static int __devinit snd_gusmax_probe(struct device *pdev, unsigned int dev) if (err < 0) return err; card->private_free = snd_gusmax_free; - maxcard = (struct snd_gusmax *)card->private_data; + maxcard = card->private_data; maxcard->card = card; maxcard->irq = -1; diff --git a/sound/isa/sb/sb8.c b/sound/isa/sb/sb8.c index 81284a8..2259e3f 100644 --- a/sound/isa/sb/sb8.c +++ b/sound/isa/sb/sb8.c @@ -72,7 +72,7 @@ static irqreturn_t snd_sb8_interrupt(int irq, void *dev_id) static void snd_sb8_free(struct snd_card *card) { - struct snd_sb8 *acard = (struct snd_sb8 *)card->private_data; + struct snd_sb8 *acard = card->private_data; if (acard == NULL) return; diff --git a/sound/oss/au1550_ac97.c b/sound/oss/au1550_ac97.c index c6f2621..8a12621 100644 --- a/sound/oss/au1550_ac97.c +++ b/sound/oss/au1550_ac97.c @@ -171,7 +171,7 @@ au1550_delay(int msec) static u16 rdcodec(struct ac97_codec *codec, u8 addr) { - struct au1550_state *s = (struct au1550_state *)codec->private_data; + struct au1550_state *s = codec->private_data; unsigned long flags; u32 cmd, val; u16 data; @@ -239,7 +239,7 @@ rdcodec(struct ac97_codec *codec, u8 addr) static void wrcodec(struct ac97_codec *codec, u8 addr, u16 data) { - struct au1550_state *s = (struct au1550_state *)codec->private_data; + struct au1550_state *s = codec->private_data; unsigned long flags; u32 cmd, val; int i; @@ -820,7 +820,7 @@ mixdev_ioctl(struct ac97_codec *codec, unsigned int cmd, static long au1550_ioctl_mixdev(struct file *file, unsigned int cmd, unsigned long arg) { - struct au1550_state *s = (struct au1550_state *)file->private_data; + struct au1550_state *s = file->private_data; struct ac97_codec *codec = s->codec; int ret; @@ -1031,7 +1031,7 @@ copy_dmabuf_user(struct dmabuf *db, char* userbuf, int count, int to_user) static ssize_t au1550_read(struct file *file, char *buffer, size_t count, loff_t *ppos) { - struct au1550_state *s = (struct au1550_state *)file->private_data; + struct au1550_state *s = file->private_data; struct dmabuf *db = &s->dma_adc; DECLARE_WAITQUEUE(wait, current); ssize_t ret; @@ -1111,7 +1111,7 @@ out2: static ssize_t au1550_write(struct file *file, const char *buffer, size_t count, loff_t * ppos) { - struct au1550_state *s = (struct au1550_state *)file->private_data; + struct au1550_state *s = file->private_data; struct dmabuf *db = &s->dma_dac; DECLARE_WAITQUEUE(wait, current); ssize_t ret = 0; @@ -1211,7 +1211,7 @@ out2: static unsigned int au1550_poll(struct file *file, struct poll_table_struct *wait) { - struct au1550_state *s = (struct au1550_state *)file->private_data; + struct au1550_state *s = file->private_data; unsigned long flags; unsigned int mask = 0; @@ -1250,7 +1250,7 @@ au1550_poll(struct file *file, struct poll_table_struct *wait) static int au1550_mmap(struct file *file, struct vm_area_struct *vma) { - struct au1550_state *s = (struct au1550_state *)file->private_data; + struct au1550_state *s = file->private_data; struct dmabuf *db; unsigned long size; int ret = 0; @@ -1342,7 +1342,7 @@ dma_count_done(struct dmabuf *db) static int au1550_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { - struct au1550_state *s = (struct au1550_state *)file->private_data; + struct au1550_state *s = file->private_data; unsigned long flags; audio_buf_info abinfo; count_info cinfo; @@ -1868,7 +1868,7 @@ out2: static int au1550_release(struct inode *inode, struct file *file) { - struct au1550_state *s = (struct au1550_state *)file->private_data; + struct au1550_state *s = file->private_data; lock_kernel(); diff --git a/sound/pci/emu10k1/emumpu401.c b/sound/pci/emu10k1/emumpu401.c index 8578c70..bab5648 100644 --- a/sound/pci/emu10k1/emumpu401.c +++ b/sound/pci/emu10k1/emumpu401.c @@ -321,7 +321,7 @@ static struct snd_rawmidi_ops snd_emu10k1_midi_input = static void snd_emu10k1_midi_free(struct snd_rawmidi *rmidi) { - struct snd_emu10k1_midi *midi = (struct snd_emu10k1_midi *)rmidi->private_data; + struct snd_emu10k1_midi *midi = rmidi->private_data; midi->interrupt = NULL; midi->rmidi = NULL; } diff --git a/sound/pci/ice1712/pontis.c b/sound/pci/ice1712/pontis.c index 6bc3f91..cdb873f 100644 --- a/sound/pci/ice1712/pontis.c +++ b/sound/pci/ice1712/pontis.c @@ -638,7 +638,7 @@ static struct snd_kcontrol_new pontis_controls[] __devinitdata = { */ static void wm_proc_regs_write(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { - struct snd_ice1712 *ice = (struct snd_ice1712 *)entry->private_data; + struct snd_ice1712 *ice = entry->private_data; char line[64]; unsigned int reg, val; mutex_lock(&ice->gpio_mutex); @@ -653,7 +653,7 @@ static void wm_proc_regs_write(struct snd_info_entry *entry, struct snd_info_buf static void wm_proc_regs_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { - struct snd_ice1712 *ice = (struct snd_ice1712 *)entry->private_data; + struct snd_ice1712 *ice = entry->private_data; int reg, val; mutex_lock(&ice->gpio_mutex); @@ -676,7 +676,7 @@ static void wm_proc_init(struct snd_ice1712 *ice) static void cs_proc_regs_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { - struct snd_ice1712 *ice = (struct snd_ice1712 *)entry->private_data; + struct snd_ice1712 *ice = entry->private_data; int reg, val; mutex_lock(&ice->gpio_mutex); diff --git a/sound/pci/ice1712/prodigy192.c b/sound/pci/ice1712/prodigy192.c index 2a8e5cd..e36ddb9 100644 --- a/sound/pci/ice1712/prodigy192.c +++ b/sound/pci/ice1712/prodigy192.c @@ -654,7 +654,7 @@ static int prodigy192_ak4114_init(struct snd_ice1712 *ice) static void stac9460_proc_regs_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { - struct snd_ice1712 *ice = (struct snd_ice1712 *)entry->private_data; + struct snd_ice1712 *ice = entry->private_data; int reg, val; /* registers 0x0 - 0x14 */ for (reg = 0; reg <= 0x15; reg++) { diff --git a/sound/pci/rme96.c b/sound/pci/rme96.c index d19dc05..d5f5b44 100644 --- a/sound/pci/rme96.c +++ b/sound/pci/rme96.c @@ -1527,14 +1527,14 @@ snd_rme96_free(void *private_data) static void snd_rme96_free_spdif_pcm(struct snd_pcm *pcm) { - struct rme96 *rme96 = (struct rme96 *) pcm->private_data; + struct rme96 *rme96 = pcm->private_data; rme96->spdif_pcm = NULL; } static void snd_rme96_free_adat_pcm(struct snd_pcm *pcm) { - struct rme96 *rme96 = (struct rme96 *) pcm->private_data; + struct rme96 *rme96 = pcm->private_data; rme96->adat_pcm = NULL; } @@ -1661,7 +1661,7 @@ static void snd_rme96_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { int n; - struct rme96 *rme96 = (struct rme96 *)entry->private_data; + struct rme96 *rme96 = entry->private_data; rme96->rcreg = readl(rme96->iobase + RME96_IO_CONTROL_REGISTER); @@ -2348,7 +2348,7 @@ snd_rme96_probe(struct pci_dev *pci, if (err < 0) return err; card->private_free = snd_rme96_card_free; - rme96 = (struct rme96 *)card->private_data; + rme96 = card->private_data; rme96->card = card; rme96->pci = pci; snd_card_set_dev(card, &pci->dev); diff --git a/sound/pci/rme9652/hdsp.c b/sound/pci/rme9652/hdsp.c index b92adef..599e090 100644 --- a/sound/pci/rme9652/hdsp.c +++ b/sound/pci/rme9652/hdsp.c @@ -3284,7 +3284,7 @@ static int snd_hdsp_create_controls(struct snd_card *card, struct hdsp *hdsp) static void snd_hdsp_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { - struct hdsp *hdsp = (struct hdsp *) entry->private_data; + struct hdsp *hdsp = entry->private_data; unsigned int status; unsigned int status2; char *pref_sync_ref; @@ -4566,7 +4566,7 @@ static int hdsp_get_peak(struct hdsp *hdsp, struct hdsp_peak_rms __user *peak_rm static int snd_hdsp_hwdep_ioctl(struct snd_hwdep *hw, struct file *file, unsigned int cmd, unsigned long arg) { - struct hdsp *hdsp = (struct hdsp *)hw->private_data; + struct hdsp *hdsp = hw->private_data; void __user *argp = (void __user *)arg; int err; @@ -5155,7 +5155,7 @@ static int snd_hdsp_free(struct hdsp *hdsp) static void snd_hdsp_card_free(struct snd_card *card) { - struct hdsp *hdsp = (struct hdsp *) card->private_data; + struct hdsp *hdsp = card->private_data; if (hdsp) snd_hdsp_free(hdsp); @@ -5181,7 +5181,7 @@ static int __devinit snd_hdsp_probe(struct pci_dev *pci, if (err < 0) return err; - hdsp = (struct hdsp *) card->private_data; + hdsp = card->private_data; card->private_free = snd_hdsp_card_free; hdsp->dev = dev; hdsp->pci = pci; -- cgit v1.1 From add7c0a6a4b8669ebd726f9c08ba6002900ca671 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Thu, 16 Jul 2009 18:19:12 +0200 Subject: ALSA: ca0106 - clean up playback pointer callback Clean up the playback pointer callback function a bit, and make the pointer check more strictly to avoid bogus pointers. Signed-off-by: Takashi Iwai --- sound/pci/ca0106/ca0106_main.c | 34 ++++++++++++++++------------------ 1 file changed, 16 insertions(+), 18 deletions(-) (limited to 'sound') diff --git a/sound/pci/ca0106/ca0106_main.c b/sound/pci/ca0106/ca0106_main.c index 0a3d3d6..8e69620 100644 --- a/sound/pci/ca0106/ca0106_main.c +++ b/sound/pci/ca0106/ca0106_main.c @@ -1002,29 +1002,27 @@ snd_ca0106_pcm_pointer_playback(struct snd_pcm_substream *substream) struct snd_ca0106 *emu = snd_pcm_substream_chip(substream); struct snd_pcm_runtime *runtime = substream->runtime; struct snd_ca0106_pcm *epcm = runtime->private_data; - snd_pcm_uframes_t ptr, ptr1, ptr2,ptr3,ptr4 = 0; + unsigned int ptr, prev_ptr; int channel = epcm->channel_id; + int timeout = 10; if (!epcm->running) return 0; - ptr3 = snd_ca0106_ptr_read(emu, PLAYBACK_LIST_PTR, channel); - ptr1 = snd_ca0106_ptr_read(emu, PLAYBACK_POINTER, channel); - ptr4 = snd_ca0106_ptr_read(emu, PLAYBACK_LIST_PTR, channel); - if (ptr3 != ptr4) ptr1 = snd_ca0106_ptr_read(emu, PLAYBACK_POINTER, channel); - ptr2 = bytes_to_frames(runtime, ptr1); - ptr2+= (ptr4 >> 3) * runtime->period_size; - ptr=ptr2; - if (ptr >= runtime->buffer_size) - ptr -= runtime->buffer_size; - /* - printk(KERN_DEBUG "ptr1 = 0x%lx, ptr2=0x%lx, ptr=0x%lx, " - "buffer_size = 0x%x, period_size = 0x%x, bits=%d, rate=%d\n", - ptr1, ptr2, ptr, (int)runtime->buffer_size, - (int)runtime->period_size, (int)runtime->frame_bits, - (int)runtime->rate); - */ - return ptr; + prev_ptr = -1; + do { + ptr = snd_ca0106_ptr_read(emu, PLAYBACK_LIST_PTR, channel); + ptr = (ptr >> 3) * runtime->period_size; + ptr += bytes_to_frames(runtime, + snd_ca0106_ptr_read(emu, PLAYBACK_POINTER, channel)); + if (ptr >= runtime->buffer_size) + ptr -= runtime->buffer_size; + if (prev_ptr == ptr) + return ptr; + prev_ptr = ptr; + } while (--timeout); + snd_printk(KERN_WARNING "ca0106: unstable DMA pointer!\n"); + return 0; } /* pointer_capture callback */ -- cgit v1.1 From 4d155641c81203440da64c4633b4efaab75f63b3 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Tue, 7 Sep 2010 11:58:30 +0200 Subject: ALSA: hda - Add quirk for Lenovo T400s Lenovo T400s requires the quirk to make automatic HP/mic switching working. Reported-by: Frank Becker Cc: Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_conexant.c | 1 + 1 file changed, 1 insertion(+) (limited to 'sound') diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c index 4f06199..71f9d64 100644 --- a/sound/pci/hda/patch_conexant.c +++ b/sound/pci/hda/patch_conexant.c @@ -3094,6 +3094,7 @@ static struct snd_pci_quirk cxt5066_cfg_tbl[] = { SND_PCI_QUIRK(0x103c, 0x360b, "HP G60", CXT5066_HP_LAPTOP), SND_PCI_QUIRK(0x1179, 0xff50, "Toshiba Satellite P500-PSPGSC-01800T", CXT5066_OLPC_XO_1_5), SND_PCI_QUIRK(0x1179, 0xffe0, "Toshiba Satellite Pro T130-15F", CXT5066_OLPC_XO_1_5), + SND_PCI_QUIRK(0x17aa, 0x20f2, "Lenovo T400s", CXT5066_THINKPAD), SND_PCI_QUIRK(0x17aa, 0x21b2, "Thinkpad X100e", CXT5066_IDEAPAD), SND_PCI_QUIRK(0x17aa, 0x21b3, "Thinkpad Edge 13 (197)", CXT5066_IDEAPAD), SND_PCI_QUIRK(0x17aa, 0x21b4, "Thinkpad Edge", CXT5066_IDEAPAD), -- cgit v1.1 From 4c25b93223340deff73381cc47f9244fb379a74d Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Tue, 7 Sep 2010 13:37:10 +0200 Subject: ALSA: virtuoso: work around missing reset in the Xonar DS Windows driver For the WM8776 chip, this driver uses a different sample format and more features than the Windows driver. When rebooting from Linux into Windows, the latter driver does not reset the chip but assumes all its registers have their default settings, so we get garbled sound or, if the output happened to be muted before rebooting, no sound. To make that driver happy, hook our driver's cleanup function into the shutdown notifier and ensure that the chip gets reset. Signed-off-by: Clemens Ladisch Reported-and-tested-by: Nathan Schagen Cc: Signed-off-by: Takashi Iwai --- sound/pci/oxygen/oxygen.h | 1 + sound/pci/oxygen/oxygen_lib.c | 21 ++++++++++++++++++--- sound/pci/oxygen/virtuoso.c | 1 + sound/pci/oxygen/xonar_wm87x6.c | 1 + 4 files changed, 21 insertions(+), 3 deletions(-) (limited to 'sound') diff --git a/sound/pci/oxygen/oxygen.h b/sound/pci/oxygen/oxygen.h index 6147216..a3409ed 100644 --- a/sound/pci/oxygen/oxygen.h +++ b/sound/pci/oxygen/oxygen.h @@ -155,6 +155,7 @@ void oxygen_pci_remove(struct pci_dev *pci); int oxygen_pci_suspend(struct pci_dev *pci, pm_message_t state); int oxygen_pci_resume(struct pci_dev *pci); #endif +void oxygen_pci_shutdown(struct pci_dev *pci); /* oxygen_mixer.c */ diff --git a/sound/pci/oxygen/oxygen_lib.c b/sound/pci/oxygen/oxygen_lib.c index fad03d6..7e93cf8 100644 --- a/sound/pci/oxygen/oxygen_lib.c +++ b/sound/pci/oxygen/oxygen_lib.c @@ -519,16 +519,21 @@ static void oxygen_init(struct oxygen *chip) } } -static void oxygen_card_free(struct snd_card *card) +static void oxygen_shutdown(struct oxygen *chip) { - struct oxygen *chip = card->private_data; - spin_lock_irq(&chip->reg_lock); chip->interrupt_mask = 0; chip->pcm_running = 0; oxygen_write16(chip, OXYGEN_DMA_STATUS, 0); oxygen_write16(chip, OXYGEN_INTERRUPT_MASK, 0); spin_unlock_irq(&chip->reg_lock); +} + +static void oxygen_card_free(struct snd_card *card) +{ + struct oxygen *chip = card->private_data; + + oxygen_shutdown(chip); if (chip->irq >= 0) free_irq(chip->irq, chip); flush_scheduled_work(); @@ -778,3 +783,13 @@ int oxygen_pci_resume(struct pci_dev *pci) } EXPORT_SYMBOL(oxygen_pci_resume); #endif /* CONFIG_PM */ + +void oxygen_pci_shutdown(struct pci_dev *pci) +{ + struct snd_card *card = pci_get_drvdata(pci); + struct oxygen *chip = card->private_data; + + oxygen_shutdown(chip); + chip->model.cleanup(chip); +} +EXPORT_SYMBOL(oxygen_pci_shutdown); diff --git a/sound/pci/oxygen/virtuoso.c b/sound/pci/oxygen/virtuoso.c index f03a2f2..06c863e 100644 --- a/sound/pci/oxygen/virtuoso.c +++ b/sound/pci/oxygen/virtuoso.c @@ -95,6 +95,7 @@ static struct pci_driver xonar_driver = { .suspend = oxygen_pci_suspend, .resume = oxygen_pci_resume, #endif + .shutdown = oxygen_pci_shutdown, }; static int __init alsa_card_xonar_init(void) diff --git a/sound/pci/oxygen/xonar_wm87x6.c b/sound/pci/oxygen/xonar_wm87x6.c index dbc4b89..0b89932 100644 --- a/sound/pci/oxygen/xonar_wm87x6.c +++ b/sound/pci/oxygen/xonar_wm87x6.c @@ -193,6 +193,7 @@ static void xonar_ds_init(struct oxygen *chip) static void xonar_ds_cleanup(struct oxygen *chip) { xonar_disable_output(chip); + wm8776_write(chip, WM8776_RESET, 0); } static void xonar_ds_suspend(struct oxygen *chip) -- cgit v1.1 From fe6ce80ae25953d95ebaf9bce27b585218cda25c Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Tue, 7 Sep 2010 13:38:49 +0200 Subject: ALSA: virtuoso: fix setting of Xonar DS line-in/mic-in controls The Line and Mic inputs cannot be used at the same time, so the driver has to automatically disable one of them if both are set. However, it forgot to notify userspace about this change, so the mixer state would be inconsistent. To fix this, check if the other control gets muted, and send a notification event in this case. Signed-off-by: Clemens Ladisch Reported-and-tested-by: Nathan Schagen Cc: Signed-off-by: Takashi Iwai --- sound/pci/oxygen/xonar_wm87x6.c | 21 ++++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/pci/oxygen/xonar_wm87x6.c b/sound/pci/oxygen/xonar_wm87x6.c index 0b89932..b82c1cf 100644 --- a/sound/pci/oxygen/xonar_wm87x6.c +++ b/sound/pci/oxygen/xonar_wm87x6.c @@ -53,6 +53,8 @@ struct xonar_wm87x6 { struct xonar_generic generic; u16 wm8776_regs[0x17]; u16 wm8766_regs[0x10]; + struct snd_kcontrol *line_adcmux_control; + struct snd_kcontrol *mic_adcmux_control; struct snd_kcontrol *lc_controls[13]; }; @@ -604,6 +606,7 @@ static int wm8776_input_mux_put(struct snd_kcontrol *ctl, { struct oxygen *chip = ctl->private_data; struct xonar_wm87x6 *data = chip->model_data; + struct snd_kcontrol *other_ctl; unsigned int mux_bit = ctl->private_value; u16 reg; int changed; @@ -611,8 +614,18 @@ static int wm8776_input_mux_put(struct snd_kcontrol *ctl, mutex_lock(&chip->mutex); reg = data->wm8776_regs[WM8776_ADCMUX]; if (value->value.integer.value[0]) { - reg &= ~0x003; reg |= mux_bit; + /* line-in and mic-in are exclusive */ + mux_bit ^= 3; + if (reg & mux_bit) { + reg &= ~mux_bit; + if (mux_bit == 1) + other_ctl = data->line_adcmux_control; + else + other_ctl = data->mic_adcmux_control; + snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE, + &other_ctl->id); + } } else reg &= ~mux_bit; changed = reg != data->wm8776_regs[WM8776_ADCMUX]; @@ -964,7 +977,13 @@ static int xonar_ds_mixer_init(struct oxygen *chip) err = snd_ctl_add(chip->card, ctl); if (err < 0) return err; + if (!strcmp(ctl->id.name, "Line Capture Switch")) + data->line_adcmux_control = ctl; + else if (!strcmp(ctl->id.name, "Mic Capture Switch")) + data->mic_adcmux_control = ctl; } + if (!data->line_adcmux_control || !data->mic_adcmux_control) + return -ENXIO; BUILD_BUG_ON(ARRAY_SIZE(lc_controls) != ARRAY_SIZE(data->lc_controls)); for (i = 0; i < ARRAY_SIZE(lc_controls); ++i) { ctl = snd_ctl_new1(&lc_controls[i], chip); -- cgit v1.1 From 76195fb096ca6db2f8bbaffb96e3025aaf1649a0 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Wed, 8 Sep 2010 08:27:02 +0200 Subject: ALSA: usb - Release capture substream URBs properly Due to the wrong "return" in the loop, a capture substream won't be released at disconnection properly if the device is capture only and has no playback substream. This caused Oops occasionally at the device reconnection. Reported-by: Kim Minhyoung Cc: Signed-off-by: Takashi Iwai --- sound/usb/card.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/usb/card.c b/sound/usb/card.c index 32e4be8..4eabafa 100644 --- a/sound/usb/card.c +++ b/sound/usb/card.c @@ -126,7 +126,7 @@ static void snd_usb_stream_disconnect(struct list_head *head) for (idx = 0; idx < 2; idx++) { subs = &as->substream[idx]; if (!subs->num_formats) - return; + continue; snd_usb_release_substream_urbs(subs, 1); subs->interface = -1; } -- cgit v1.1 From a769cbcf60cee51f4431c0938acd39e7e5b76b8d Mon Sep 17 00:00:00 2001 From: Brian Austin Date: Tue, 7 Sep 2010 14:36:22 -0500 Subject: ALSA: hda - Add errata initverb sequence for CS42xx codecs Add init verb sequence for errata ER880C3 http://www.cirrus.com/en/pubs/errata/ER880C3.pdf Signed-off-by: Brian Austin Cc: Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_cirrus.c | 50 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+) (limited to 'sound') diff --git a/sound/pci/hda/patch_cirrus.c b/sound/pci/hda/patch_cirrus.c index 4ef5efa..488fd9a 100644 --- a/sound/pci/hda/patch_cirrus.c +++ b/sound/pci/hda/patch_cirrus.c @@ -972,6 +972,53 @@ static struct hda_verb cs_coef_init_verbs[] = { {} /* terminator */ }; +/* Errata: CS4207 rev C0/C1/C2 Silicon + * + * http://www.cirrus.com/en/pubs/errata/ER880C3.pdf + * + * 6. At high temperature (TA > +85°C), the digital supply current (IVD) + * may be excessive (up to an additional 200 μA), which is most easily + * observed while the part is being held in reset (RESET# active low). + * + * Root Cause: At initial powerup of the device, the logic that drives + * the clock and write enable to the S/PDIF SRC RAMs is not properly + * initialized. + * Certain random patterns will cause a steady leakage current in those + * RAM cells. The issue will resolve once the SRCs are used (turned on). + * + * Workaround: The following verb sequence briefly turns on the S/PDIF SRC + * blocks, which will alleviate the issue. + */ + +static struct hda_verb cs_errata_init_verbs[] = { + {0x01, AC_VERB_SET_POWER_STATE, 0x00}, /* AFG: D0 */ + {0x11, AC_VERB_SET_PROC_STATE, 0x01}, /* VPW: processing on */ + + {0x11, AC_VERB_SET_COEF_INDEX, 0x0008}, + {0x11, AC_VERB_SET_PROC_COEF, 0x9999}, + {0x11, AC_VERB_SET_COEF_INDEX, 0x0017}, + {0x11, AC_VERB_SET_PROC_COEF, 0xa412}, + {0x11, AC_VERB_SET_COEF_INDEX, 0x0001}, + {0x11, AC_VERB_SET_PROC_COEF, 0x0009}, + + {0x07, AC_VERB_SET_POWER_STATE, 0x00}, /* S/PDIF Rx: D0 */ + {0x08, AC_VERB_SET_POWER_STATE, 0x00}, /* S/PDIF Tx: D0 */ + + {0x11, AC_VERB_SET_COEF_INDEX, 0x0017}, + {0x11, AC_VERB_SET_PROC_COEF, 0x2412}, + {0x11, AC_VERB_SET_COEF_INDEX, 0x0008}, + {0x11, AC_VERB_SET_PROC_COEF, 0x0000}, + {0x11, AC_VERB_SET_COEF_INDEX, 0x0001}, + {0x11, AC_VERB_SET_PROC_COEF, 0x0008}, + {0x11, AC_VERB_SET_PROC_STATE, 0x00}, + + {0x07, AC_VERB_SET_POWER_STATE, 0x03}, /* S/PDIF Rx: D3 */ + {0x08, AC_VERB_SET_POWER_STATE, 0x03}, /* S/PDIF Tx: D3 */ + /*{0x01, AC_VERB_SET_POWER_STATE, 0x03},*/ /* AFG: D3 This is already handled */ + + {} /* terminator */ +}; + /* SPDIF setup */ static void init_digital(struct hda_codec *codec) { @@ -991,6 +1038,9 @@ static int cs_init(struct hda_codec *codec) { struct cs_spec *spec = codec->spec; + /* init_verb sequence for C0/C1/C2 errata*/ + snd_hda_sequence_write(codec, cs_errata_init_verbs); + snd_hda_sequence_write(codec, cs_coef_init_verbs); if (spec->gpio_mask) { -- cgit v1.1 From 080dc7bc2562615a5be0a705a9d1a8c24eb198d4 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Wed, 8 Sep 2010 08:38:41 +0200 Subject: ALSA: hda - Enable PC-beep for EeePC with ALC269 codec EeePC 1001HAG has a similar problem like other ASUS machine, which doesn't set the codec SSID properly for indicating the beep capability. To enable PC-beep again, put this to the whitelist. Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 1 + 1 file changed, 1 insertion(+) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index 627bf99..bcbf916 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -5334,6 +5334,7 @@ static void fillup_priv_adc_nids(struct hda_codec *codec, hda_nid_t *nids, static struct snd_pci_quirk beep_white_list[] = { SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1), + SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1), SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1), {} }; -- cgit v1.1 From ab5a6ebee38f3ed311f0565ecd3fba5cf111564a Mon Sep 17 00:00:00 2001 From: Vitaliy Kulikov Date: Wed, 8 Sep 2010 09:00:17 +0200 Subject: ALSA: hda - Adding support for new IDT 92HD90BXX and 92HD91BXX codecs Adding support for digital MIC in 92HD83/90/91XXX codecs family. Signed-off-by: Vitaliy Kulikov Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_sigmatel.c | 79 ++++++++++++++++++++++++------------------ 1 file changed, 46 insertions(+), 33 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c index d226edd..82d1e43 100644 --- a/sound/pci/hda/patch_sigmatel.c +++ b/sound/pci/hda/patch_sigmatel.c @@ -382,6 +382,11 @@ static unsigned int stac92hd83xxx_pwr_mapping[4] = { 0x03, 0x0c, 0x20, 0x40, }; +#define STAC92HD83XXX_NUM_DMICS 2 +static hda_nid_t stac92hd83xxx_dmic_nids[STAC92HD83XXX_NUM_DMICS + 1] = { + 0x11, 0x20, 0 +}; + #define STAC92HD83XXX_NUM_CAPS 2 static unsigned long stac92hd83xxx_capvols[] = { HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT), @@ -4695,6 +4700,36 @@ static void stac92xx_report_jack(struct hda_codec *codec, hda_nid_t nid) } } +/* get the pin connection (fixed, none, etc) */ +static unsigned int stac_get_defcfg_connect(struct hda_codec *codec, int idx) +{ + struct sigmatel_spec *spec = codec->spec; + unsigned int cfg; + + cfg = snd_hda_codec_get_pincfg(codec, spec->pin_nids[idx]); + return get_defcfg_connect(cfg); +} + +static int stac92xx_connected_ports(struct hda_codec *codec, + hda_nid_t *nids, int num_nids) +{ + struct sigmatel_spec *spec = codec->spec; + int idx, num; + unsigned int def_conf; + + for (num = 0; num < num_nids; num++) { + for (idx = 0; idx < spec->num_pins; idx++) + if (spec->pin_nids[idx] == nids[num]) + break; + if (idx >= spec->num_pins) + break; + def_conf = stac_get_defcfg_connect(codec, idx); + if (def_conf == AC_JACK_PORT_NONE) + break; + } + return num; +} + static void stac92xx_mic_detect(struct hda_codec *codec) { struct sigmatel_spec *spec = codec->spec; @@ -5325,6 +5360,8 @@ static int patch_stac92hd83xxx(struct hda_codec *codec) spec->linear_tone_beep = 1; codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs; spec->digbeep_nid = 0x21; + spec->dmic_nids = stac92hd83xxx_dmic_nids; + spec->dmux_nids = stac92hd83xxx_mux_nids; spec->mux_nids = stac92hd83xxx_mux_nids; spec->num_muxes = ARRAY_SIZE(stac92hd83xxx_mux_nids); spec->adc_nids = stac92hd83xxx_adc_nids; @@ -5370,9 +5407,13 @@ again: case 0x111d76d4: case 0x111d7605: case 0x111d76d5: + case 0x111d76e7: if (spec->board_config == STAC_92HD83XXX_PWR_REF) break; spec->num_pwrs = 0; + spec->num_dmics = stac92xx_connected_ports(codec, + stac92hd83xxx_dmic_nids, + STAC92HD83XXX_NUM_DMICS); break; } @@ -5431,36 +5472,6 @@ again: return 0; } -/* get the pin connection (fixed, none, etc) */ -static unsigned int stac_get_defcfg_connect(struct hda_codec *codec, int idx) -{ - struct sigmatel_spec *spec = codec->spec; - unsigned int cfg; - - cfg = snd_hda_codec_get_pincfg(codec, spec->pin_nids[idx]); - return get_defcfg_connect(cfg); -} - -static int stac92hd71bxx_connected_ports(struct hda_codec *codec, - hda_nid_t *nids, int num_nids) -{ - struct sigmatel_spec *spec = codec->spec; - int idx, num; - unsigned int def_conf; - - for (num = 0; num < num_nids; num++) { - for (idx = 0; idx < spec->num_pins; idx++) - if (spec->pin_nids[idx] == nids[num]) - break; - if (idx >= spec->num_pins) - break; - def_conf = stac_get_defcfg_connect(codec, idx); - if (def_conf == AC_JACK_PORT_NONE) - break; - } - return num; -} - static int stac92hd71bxx_connected_smuxes(struct hda_codec *codec, hda_nid_t dig0pin) { @@ -5599,7 +5610,7 @@ again: case 0x111d76b5: spec->init = stac92hd71bxx_core_init; codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs; - spec->num_dmics = stac92hd71bxx_connected_ports(codec, + spec->num_dmics = stac92xx_connected_ports(codec, stac92hd71bxx_dmic_nids, STAC92HD71BXX_NUM_DMICS); break; @@ -5631,7 +5642,7 @@ again: snd_hda_codec_set_pincfg(codec, 0x0f, 0x40f000f0); snd_hda_codec_set_pincfg(codec, 0x19, 0x40f000f3); stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS - 1] = 0; - spec->num_dmics = stac92hd71bxx_connected_ports(codec, + spec->num_dmics = stac92xx_connected_ports(codec, stac92hd71bxx_dmic_nids, STAC92HD71BXX_NUM_DMICS - 1); break; @@ -5645,7 +5656,7 @@ again: default: spec->init = stac92hd71bxx_core_init; codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs; - spec->num_dmics = stac92hd71bxx_connected_ports(codec, + spec->num_dmics = stac92xx_connected_ports(codec, stac92hd71bxx_dmic_nids, STAC92HD71BXX_NUM_DMICS); break; @@ -6327,6 +6338,8 @@ static struct hda_codec_preset snd_hda_preset_sigmatel[] = { { .id = 0x111d76cc, .name = "92HD89F3", .patch = patch_stac92hd73xx }, { .id = 0x111d76cd, .name = "92HD89F2", .patch = patch_stac92hd73xx }, { .id = 0x111d76ce, .name = "92HD89F1", .patch = patch_stac92hd73xx }, + { .id = 0x111d76e0, .name = "92HD91BXX", .patch = patch_stac92hd83xxx}, + { .id = 0x111d76e7, .name = "92HD90BXX", .patch = patch_stac92hd83xxx}, {} /* terminator */ }; -- cgit v1.1 From 263d0328c46995d8e4fb478005177839104483d2 Mon Sep 17 00:00:00 2001 From: Vitaliy Kulikov Date: Wed, 8 Sep 2010 08:56:03 +0200 Subject: ALSA: hda - Improve input control names for IDT/STAC codecs Changing the way the input controls are named using port connection type and jack location info. Signed-off-by: Vitaliy Kulikov Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_sigmatel.c | 107 +++++++++++++++++++++++++++++++++-------- 1 file changed, 88 insertions(+), 19 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c index 82d1e43..7f09e14 100644 --- a/sound/pci/hda/patch_sigmatel.c +++ b/sound/pci/hda/patch_sigmatel.c @@ -191,6 +191,11 @@ struct sigmatel_mic_route { signed char dmux_idx; }; +struct unique_input_names { + int num; + char uname[HDA_MAX_NUM_INPUTS][32]; +}; + struct sigmatel_spec { struct snd_kcontrol_new *mixers[4]; unsigned int num_mixers; @@ -307,6 +312,7 @@ struct sigmatel_spec { struct hda_input_mux private_imux; struct hda_input_mux private_smux; struct hda_input_mux private_mono_mux; + struct unique_input_names private_u_inp_names; }; static hda_nid_t stac9200_adc_nids[1] = { @@ -3452,6 +3458,76 @@ static int create_elem_capture_vol(struct hda_codec *codec, hda_nid_t nid, return 1; } +static const char *get_input_src_label(struct hda_codec *codec, hda_nid_t nid) +{ + unsigned int def_conf; + + def_conf = snd_hda_codec_get_pincfg(codec, nid); + + switch (get_defcfg_device(def_conf)) { + case AC_JACK_MIC_IN: + if (get_defcfg_connect(def_conf) == AC_JACK_PORT_FIXED || + ((get_defcfg_location(def_conf) & 0xf0) + == AC_JACK_LOC_INTERNAL)) + return "Internal Mic"; + if ((get_defcfg_location(def_conf) & 0xf0) + == AC_JACK_LOC_SEPARATE) + return "Dock Mic"; + if (get_defcfg_location(def_conf) == AC_JACK_LOC_REAR) + return "Rear Mic"; + return "Mic"; + case AC_JACK_LINE_IN: + if ((get_defcfg_location(def_conf) & 0xf0) + == AC_JACK_LOC_SEPARATE) + return "Dock Line"; + return "Line"; + case AC_JACK_AUX: + return "Aux"; + case AC_JACK_CD: + return "CD"; + case AC_JACK_SPDIF_IN: + return "SPDIF In"; + case AC_JACK_DIG_OTHER_IN: + return "Digital In"; + } + + snd_printd("invalid inp pin %02x device config %08x", nid, def_conf); + return NULL; +} + +static const char *get_unique_inp_src_label(struct hda_codec *codec, + hda_nid_t nid) +{ + int i, n; + const char *label; + struct sigmatel_spec *spec = codec->spec; + struct hda_input_mux *imux = &spec->private_imux; + struct hda_input_mux *dimux = &spec->private_dimux; + struct unique_input_names *unames = &spec->private_u_inp_names; + + label = get_input_src_label(codec, nid); + n = 0; + + for (i = 0; i < imux->num_items; i++) { + if (!strncmp(label, imux->items[i].label, strlen(label))) + n++; + } + if (snd_hda_get_bool_hint(codec, "separate_dmux") == 1) { + for (i = 0; i < dimux->num_items; i++) { + if (!strncmp(label, dimux->items[i].label, + strlen(label))) + n++; + } + } + if (n > 0 && unames->num < HDA_MAX_NUM_INPUTS) { + sprintf(&unames->uname[unames->num][0], "%.28s %d", label, n); + label = &unames->uname[unames->num][0]; + unames->num++; + } + + return label; +} + /* create playback/capture controls for input pins on dmic capable codecs */ static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg) @@ -3459,24 +3535,13 @@ static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec, struct sigmatel_spec *spec = codec->spec; struct hda_input_mux *imux = &spec->private_imux; struct hda_input_mux *dimux = &spec->private_dimux; - int err, i, active_mics; + int err, i; unsigned int def_conf; dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0]; dimux->items[dimux->num_items].index = 0; dimux->num_items++; - active_mics = 0; - for (i = 0; i < spec->num_dmics; i++) { - /* check the validity: sometimes it's a dead vendor-spec node */ - if (get_wcaps_type(get_wcaps(codec, spec->dmic_nids[i])) - != AC_WID_PIN) - continue; - def_conf = snd_hda_codec_get_pincfg(codec, spec->dmic_nids[i]); - if (get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE) - active_mics++; - } - for (i = 0; i < spec->num_dmics; i++) { hda_nid_t nid; int index; @@ -3493,10 +3558,9 @@ static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec, if (index < 0) continue; - if (active_mics == 1) - label = "Digital Mic"; - else - label = stac92xx_dmic_labels[dimux->num_items]; + label = get_unique_inp_src_label(codec, nid); + if (label == NULL) + return -EINVAL; err = create_elem_capture_vol(codec, nid, label, 0, HDA_INPUT); if (err < 0) @@ -3618,6 +3682,7 @@ static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct sigmatel_spec *spec = codec->spec; struct hda_input_mux *imux = &spec->private_imux; int i, j, type_idx = 0; + const char *label; for (i = 0; i < cfg->num_inputs; i++) { hda_nid_t nid = cfg->inputs[i].pin; @@ -3637,14 +3702,18 @@ static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const type_idx++; else type_idx = 0; + + label = get_unique_inp_src_label(codec, nid); + if (label == NULL) + return -EINVAL; + err = create_elem_capture_vol(codec, nid, - auto_pin_cfg_labels[i], type_idx, + label, type_idx, HDA_INPUT); if (err < 0) return err; - imux->items[imux->num_items].label = - snd_hda_get_input_pin_label(cfg, i); + imux->items[imux->num_items].label = label; imux->items[imux->num_items].index = index; imux->num_items++; } -- cgit v1.1 From e4ee8dd8afcbcbe502fa8a3d3af6eb09c96dd806 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Wed, 8 Sep 2010 09:58:12 +0200 Subject: ALSA: msnd-classic: Fix invalid cfg parameter The driver doesn't probe the device properly because of left-over cfg[] that isn't used at all for msnd-classic device. This is only for msnd- pinnacle. Signed-off-by: Takashi Iwai --- sound/isa/msnd/msnd_pinnacle.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) (limited to 'sound') diff --git a/sound/isa/msnd/msnd_pinnacle.c b/sound/isa/msnd/msnd_pinnacle.c index 5f3e684..91d6023 100644 --- a/sound/isa/msnd/msnd_pinnacle.c +++ b/sound/isa/msnd/msnd_pinnacle.c @@ -764,9 +764,9 @@ static long io[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; static int irq[SNDRV_CARDS] = SNDRV_DEFAULT_IRQ; static long mem[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; +#ifndef MSND_CLASSIC static long cfg[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; -#ifndef MSND_CLASSIC /* Extra Peripheral Configuration (Default: Disable) */ static long ide_io0[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; static long ide_io1[SNDRV_CARDS] = SNDRV_DEFAULT_PORT; @@ -894,7 +894,11 @@ static int __devinit snd_msnd_isa_probe(struct device *pdev, unsigned int idx) struct snd_card *card; struct snd_msnd *chip; - if (has_isapnp(idx) || cfg[idx] == SNDRV_AUTO_PORT) { + if (has_isapnp(idx) +#ifndef MSND_CLASSIC + || cfg[idx] == SNDRV_AUTO_PORT +#endif + ) { printk(KERN_INFO LOGNAME ": Assuming PnP mode\n"); return -ENODEV; } -- cgit v1.1 From 27f7ad53829f79e799a253285318bff79ece15bd Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Mon, 6 Sep 2010 09:13:45 +0200 Subject: ALSA: seq/oss - Fix double-free at error path of snd_seq_oss_open() The error handling in snd_seq_oss_open() has several bad codes that do dereferecing released pointers and double-free of kmalloc'ed data. The object dp is release in free_devinfo() that is called via private_free callback. The rest shouldn't touch this object any more. The patch changes delete_port() to call kfree() in any case, and gets rid of unnecessary calls of destructors in snd_seq_oss_open(). Fixes CVE-2010-3080. Reported-and-tested-by: Tavis Ormandy Cc: Signed-off-by: Takashi Iwai --- sound/core/seq/oss/seq_oss_init.c | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) (limited to 'sound') diff --git a/sound/core/seq/oss/seq_oss_init.c b/sound/core/seq/oss/seq_oss_init.c index 6857122..69cd7b3 100644 --- a/sound/core/seq/oss/seq_oss_init.c +++ b/sound/core/seq/oss/seq_oss_init.c @@ -281,13 +281,10 @@ snd_seq_oss_open(struct file *file, int level) return 0; _error: - snd_seq_oss_writeq_delete(dp->writeq); - snd_seq_oss_readq_delete(dp->readq); snd_seq_oss_synth_cleanup(dp); snd_seq_oss_midi_cleanup(dp); - delete_port(dp); delete_seq_queue(dp->queue); - kfree(dp); + delete_port(dp); return rc; } @@ -350,8 +347,10 @@ create_port(struct seq_oss_devinfo *dp) static int delete_port(struct seq_oss_devinfo *dp) { - if (dp->port < 0) + if (dp->port < 0) { + kfree(dp); return 0; + } debug_printk(("delete_port %i\n", dp->port)); return snd_seq_event_port_detach(dp->cseq, dp->port); -- cgit v1.1 From 122661b67899980f1372812d907e73ebcfb3d037 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Wed, 8 Sep 2010 14:57:04 +0200 Subject: ALSA: hda - Fix wrong HP pin detection in snd_hda_parse_pin_def_config() snd_hda_parse_pin_def_config() has some workaround for re-assigning some pins declared as headphones to line-outs. This didn't work properly for some cases because it used memmove() stupidly wrongly. Reference: Novell bnc#637263 https://bugzilla.novell.com/show_bug.cgi?id=637263 Cc: Signed-off-by: Takashi Iwai --- sound/pci/hda/hda_codec.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c index 3827092..1482921 100644 --- a/sound/pci/hda/hda_codec.c +++ b/sound/pci/hda/hda_codec.c @@ -4536,7 +4536,7 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec, cfg->hp_outs--; memmove(cfg->hp_pins + i, cfg->hp_pins + i + 1, sizeof(cfg->hp_pins[0]) * (cfg->hp_outs - i)); - memmove(sequences_hp + i - 1, sequences_hp + i, + memmove(sequences_hp + i, sequences_hp + i + 1, sizeof(sequences_hp[0]) * (cfg->hp_outs - i)); } } -- cgit v1.1 From 03642c9a444079aa13f0864383a8f9ca04bfd198 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Wed, 8 Sep 2010 15:28:19 +0200 Subject: ALSA: hda - Clear left-over hp_pins in snd_hda_parse_pin_def_config() In snd_hda_parse_def_config(), some unused values may remain in hp_pins[] array during the headphone-reassignment workaround. This patch clears the unused array members. Signed-off-by: Takashi Iwai --- sound/pci/hda/hda_codec.c | 2 ++ 1 file changed, 2 insertions(+) (limited to 'sound') diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c index 2980c27..bfdde7b 100644 --- a/sound/pci/hda/hda_codec.c +++ b/sound/pci/hda/hda_codec.c @@ -4558,6 +4558,8 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec, memmove(sequences_hp + i, sequences_hp + i + 1, sizeof(sequences_hp[0]) * (cfg->hp_outs - i)); } + memset(cfg->hp_pins + cfg->hp_outs, 0, + sizeof(hda_nid_t) * (AUTO_CFG_MAX_OUTS - cfg->hp_outs)); } /* sort by sequence */ -- cgit v1.1 From bb35febd16fe5ac8c30f9116a25210c4f63a5267 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Wed, 8 Sep 2010 15:30:49 +0200 Subject: ALSA: hda - Support multiple headphone auto-mute Currently headphone auto-mute using alc_automute_pin() assumes only the single pin used for the headphone output. Since there are devices with multiple headphone jacks, we need to check all these pins there, too. Also this patch merges the common code between alc_automute_pin() and alc_automute_amp() helper functions. Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 92 +++++++++++++++++++++++-------------------- 1 file changed, 50 insertions(+), 42 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index 81e4b1d..ee59df7 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -990,25 +990,46 @@ static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid, alc_fix_pll(codec); } -static void alc_automute_pin(struct hda_codec *codec) +static void alc_automute_speaker(struct hda_codec *codec, int pinctl) { struct alc_spec *spec = codec->spec; - unsigned int nid = spec->autocfg.hp_pins[0]; + unsigned int mute; + hda_nid_t nid; int i; - if (!nid) - return; - spec->jack_present = snd_hda_jack_detect(codec, nid); + spec->jack_present = 0; + for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) { + nid = spec->autocfg.hp_pins[i]; + if (!nid) + break; + if (snd_hda_jack_detect(codec, nid)) { + spec->jack_present = 1; + break; + } + } + + mute = spec->jack_present ? HDA_AMP_MUTE : 0; + /* Toggle internal speakers muting */ for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) { nid = spec->autocfg.speaker_pins[i]; if (!nid) break; - snd_hda_codec_write(codec, nid, 0, + if (pinctl) { + snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, spec->jack_present ? 0 : PIN_OUT); + } else { + snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, + HDA_AMP_MUTE, mute); + } } } +static void alc_automute_pin(struct hda_codec *codec) +{ + alc_automute_speaker(codec, 1); +} + static int get_connection_index(struct hda_codec *codec, hda_nid_t mux, hda_nid_t nid) { @@ -1236,24 +1257,35 @@ static void alc_auto_init_amp(struct hda_codec *codec, int type) static void alc_init_auto_hp(struct hda_codec *codec) { struct alc_spec *spec = codec->spec; + struct auto_pin_cfg *cfg = &spec->autocfg; + int i; - if (!spec->autocfg.hp_pins[0]) - return; + if (!cfg->hp_pins[0]) { + if (cfg->line_out_type != AUTO_PIN_HP_OUT) + return; + } - if (!spec->autocfg.speaker_pins[0]) { - if (spec->autocfg.line_out_pins[0] && - spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT) - spec->autocfg.speaker_pins[0] = - spec->autocfg.line_out_pins[0]; - else + if (!cfg->speaker_pins[0]) { + if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) return; + memcpy(cfg->speaker_pins, cfg->line_out_pins, + sizeof(cfg->speaker_pins)); + cfg->speaker_outs = cfg->line_outs; + } + + if (!cfg->hp_pins[0]) { + memcpy(cfg->hp_pins, cfg->line_out_pins, + sizeof(cfg->hp_pins)); + cfg->hp_outs = cfg->line_outs; } - snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n", - spec->autocfg.hp_pins[0]); - snd_hda_codec_write_cache(codec, spec->autocfg.hp_pins[0], 0, + for (i = 0; i < cfg->hp_outs; i++) { + snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n", + cfg->hp_pins[i]); + snd_hda_codec_write_cache(codec, cfg->hp_pins[i], 0, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT); + } spec->unsol_event = alc_sku_unsol_event; } @@ -1711,31 +1743,7 @@ static struct hda_verb alc888_fujitsu_xa3530_verbs[] = { static void alc_automute_amp(struct hda_codec *codec) { - struct alc_spec *spec = codec->spec; - unsigned int mute; - hda_nid_t nid; - int i; - - spec->jack_present = 0; - for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) { - nid = spec->autocfg.hp_pins[i]; - if (!nid) - break; - if (snd_hda_jack_detect(codec, nid)) { - spec->jack_present = 1; - break; - } - } - - mute = spec->jack_present ? HDA_AMP_MUTE : 0; - /* Toggle internal speakers muting */ - for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) { - nid = spec->autocfg.speaker_pins[i]; - if (!nid) - break; - snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, - HDA_AMP_MUTE, mute); - } + alc_automute_speaker(codec, 0); } static void alc_automute_amp_unsol_event(struct hda_codec *codec, -- cgit v1.1 From 033688a5a80f9d56b2e7d56c4cb8188ae1448919 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Wed, 8 Sep 2010 15:47:09 +0200 Subject: ALSA: hda - Add multiple headphone support to ALC262 codec This patch changes the alc262 auto-parser to allow multiple pins assigned for a single purpose (line-out, headphone or speaker). Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 71 +++++++++++++++++++++++++------------------ 1 file changed, 42 insertions(+), 29 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index ee59df7..26069e3 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -11824,7 +11824,7 @@ static int alc262_check_volbit(hda_nid_t nid) } static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid, - const char *pfx, int *vbits) + const char *pfx, int *vbits, int idx) { unsigned long val; int vbit; @@ -11839,11 +11839,11 @@ static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid, val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT); else val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT); - return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, val); + return __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, idx, val); } static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid, - const char *pfx) + const char *pfx, int idx) { unsigned long val; @@ -11853,7 +11853,7 @@ static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid, val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT); else val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); - return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, val); + return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, idx, val); } /* add playback controls from the parsed DAC table */ @@ -11862,7 +11862,7 @@ static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec, { const char *pfx; int vbits; - int err; + int i, err; spec->multiout.num_dacs = 1; /* only use one dac */ spec->multiout.dac_nids = spec->private_dac_nids; @@ -11872,39 +11872,52 @@ static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec, pfx = "Master"; else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) pfx = "Speaker"; + else if (cfg->line_out_type == AUTO_PIN_HP_OUT) + pfx = "Headphone"; else pfx = "Front"; - err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[0], pfx); - if (err < 0) - return err; - err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[0], "Speaker"); - if (err < 0) - return err; - err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[0], "Headphone"); - if (err < 0) - return err; + for (i = 0; i < 2; i++) { + err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[i], pfx, i); + if (err < 0) + return err; + if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) { + err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[i], + "Speaker", i); + if (err < 0) + return err; + } + if (cfg->line_out_type != AUTO_PIN_HP_OUT) { + err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[i], + "Headphone", i); + if (err < 0) + return err; + } + } vbits = alc262_check_volbit(cfg->line_out_pins[0]) | alc262_check_volbit(cfg->speaker_pins[0]) | alc262_check_volbit(cfg->hp_pins[0]); if (vbits == 1 || vbits == 2) pfx = "Master"; /* only one mixer is used */ - else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) - pfx = "Speaker"; - else - pfx = "Front"; vbits = 0; - err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[0], pfx, &vbits); - if (err < 0) - return err; - err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[0], "Speaker", - &vbits); - if (err < 0) - return err; - err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[0], "Headphone", - &vbits); - if (err < 0) - return err; + for (i = 0; i < 2; i++) { + err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[i], pfx, + &vbits, i); + if (err < 0) + return err; + if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) { + err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[i], + "Speaker", &vbits, i); + if (err < 0) + return err; + } + if (cfg->line_out_type != AUTO_PIN_HP_OUT) { + err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[i], + "Headphone", &vbits, i); + if (err < 0) + return err; + } + } return 0; } -- cgit v1.1 From 18675e4283f575594d55ef1239c14ab5b4de53b6 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Wed, 8 Sep 2010 15:55:44 +0200 Subject: ALSA: hda - Add fixup for FSC Celsius H270 Added a fixup table for ALC262 codec containing the entry for FSC Celsius H270. Now both headphone jacks are detected properly as headphones. Reference: Novell bnc637263 https://bugzilla.novell.com/show_bug.cgi?id=637263 Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index 26069e3..f11a9ca 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -12205,6 +12205,35 @@ static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = { {} }; +/* + * Pin config fixes + */ +enum { + PINFIX_FSC_H270, +}; + +static const struct alc_fixup alc262_fixups[] = { + [PINFIX_FSC_H270] = { + .pins = (const struct alc_pincfg[]) { + { 0x14, 0x99130110 }, /* speaker */ + { 0x15, 0x0221142f }, /* front HP */ + { 0x1b, 0x0121141f }, /* rear HP */ + { } + } + }, + [PINFIX_PB_M5210] = { + .verbs = (const struct hda_verb[]) { + { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 }, + {} + } + }, +}; + +static struct snd_pci_quirk alc262_fixup_tbl[] = { + SND_PCI_QUIRK(0x1734, 0x1147, "FSC Celsius H270", PINFIX_FSC_H270), + {} +}; + #ifdef CONFIG_SND_HDA_POWER_SAVE #define alc262_loopbacks alc880_loopbacks @@ -12628,6 +12657,9 @@ static int patch_alc262(struct hda_codec *codec) board_config = ALC262_AUTO; } + if (board_config == ALC262_AUTO) + alc_pick_fixup(codec, alc262_fixup_tbl, alc262_fixups, 1); + if (board_config == ALC262_AUTO) { /* automatic parse from the BIOS config */ err = alc262_parse_auto_config(codec); @@ -12696,6 +12728,9 @@ static int patch_alc262(struct hda_codec *codec) if (!spec->no_analog && has_cdefine_beep(codec)) set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT); + if (board_config == ALC262_AUTO) + alc_pick_fixup(codec, alc262_fixup_tbl, alc262_fixups, 0); + spec->vmaster_nid = 0x0c; codec->patch_ops = alc_patch_ops; -- cgit v1.1 From a7a13d0676335a7dc9dd72264cca02606e43aaba Mon Sep 17 00:00:00 2001 From: Dan Carpenter Date: Thu, 9 Sep 2010 00:11:41 +0200 Subject: ALSA: rawmidi: fix the get next midi device ioctl If we pass in a device which is higher than SNDRV_RAWMIDI_DEVICES then the "next device" should be -1. This function just returns device + 1. But the main thing is that "device + 1" can lead to a (harmless) integer overflow and that annoys static analysis tools. [fix the case for device == SNDRV_RAWMIDI_DEVICE by tiwai] Signed-off-by: Dan Carpenter Signed-off-by: Takashi Iwai --- sound/core/rawmidi.c | 2 ++ 1 file changed, 2 insertions(+) (limited to 'sound') diff --git a/sound/core/rawmidi.c b/sound/core/rawmidi.c index eb68326..a7868ad 100644 --- a/sound/core/rawmidi.c +++ b/sound/core/rawmidi.c @@ -829,6 +829,8 @@ static int snd_rawmidi_control_ioctl(struct snd_card *card, if (get_user(device, (int __user *)argp)) return -EFAULT; + if (device >= SNDRV_RAWMIDI_DEVICES) /* next device is -1 */ + device = SNDRV_RAWMIDI_DEVICES - 1; mutex_lock(®ister_mutex); device = device < 0 ? 0 : device + 1; while (device < SNDRV_RAWMIDI_DEVICES) { -- cgit v1.1 From 6cb3b707f95954ac18f19b4b3919af235738371a Mon Sep 17 00:00:00 2001 From: David Henningsson Date: Thu, 9 Sep 2010 08:51:44 +0200 Subject: ALSA: HDA: Add fixup pins for Ideapad Y550 By adding the subwoofer as a speaker pin, it is treated correctly when auto-muting. BugLink: https://launchpad.net/bugs/611803 Signed-off-by: David Henningsson Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 26 +++++++++++++++++++++++++- 1 file changed, 25 insertions(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index f11a9ca..0c25d22 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -18963,6 +18963,26 @@ static void alc662_auto_init(struct hda_codec *codec) alc_inithook(codec); } +enum { + ALC662_FIXUP_IDEAPAD, +}; + +static const struct alc_fixup alc662_fixups[] = { + [ALC662_FIXUP_IDEAPAD] = { + .pins = (const struct alc_pincfg[]) { + { 0x17, 0x99130112 }, /* subwoofer */ + { } + } + }, +}; + +static struct snd_pci_quirk alc662_fixup_tbl[] = { + SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD), + {} +}; + + + static int patch_alc662(struct hda_codec *codec) { struct alc_spec *spec; @@ -18995,6 +19015,7 @@ static int patch_alc662(struct hda_codec *codec) } if (board_config == ALC662_AUTO) { + alc_pick_fixup(codec, alc662_fixup_tbl, alc662_fixups, 1); /* automatic parse from the BIOS config */ err = alc662_parse_auto_config(codec); if (err < 0) { @@ -19053,8 +19074,11 @@ static int patch_alc662(struct hda_codec *codec) spec->vmaster_nid = 0x02; codec->patch_ops = alc_patch_ops; - if (board_config == ALC662_AUTO) + if (board_config == ALC662_AUTO) { spec->init_hook = alc662_auto_init; + alc_pick_fixup(codec, alc662_fixup_tbl, alc662_fixups, 0); + } + #ifdef CONFIG_SND_HDA_POWER_SAVE if (!spec->loopback.amplist) spec->loopback.amplist = alc662_loopbacks; -- cgit v1.1 From da0dab5ecb5001f76e739e71ee199db4c61e7af2 Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Thu, 9 Sep 2010 12:18:35 +0200 Subject: ALSA: virtuoso: fix WM8766 register writes with MSB The check for the volume update latch bit was accidentally in the wrong function, where it would prevent the MSB from being written, instead of correctly ignoring it for cached values. Signed-off-by: Clemens Ladisch Signed-off-by: Takashi Iwai --- sound/pci/oxygen/xonar_wm87x6.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'sound') diff --git a/sound/pci/oxygen/xonar_wm87x6.c b/sound/pci/oxygen/xonar_wm87x6.c index b82c1cf..4346006d 100644 --- a/sound/pci/oxygen/xonar_wm87x6.c +++ b/sound/pci/oxygen/xonar_wm87x6.c @@ -97,8 +97,12 @@ static void wm8766_write(struct oxygen *chip, (0 << OXYGEN_SPI_CODEC_SHIFT) | OXYGEN_SPI_CEN_LATCH_CLOCK_LO, (reg << 9) | value); - if (reg < ARRAY_SIZE(data->wm8766_regs)) + if (reg < ARRAY_SIZE(data->wm8766_regs)) { + if ((reg >= WM8766_LDA1 && reg <= WM8766_RDA1) || + (reg >= WM8766_LDA2 && reg <= WM8766_MASTDA)) + value &= ~WM8766_UPDATE; data->wm8766_regs[reg] = value; + } } static void wm8766_write_cached(struct oxygen *chip, @@ -107,12 +111,8 @@ static void wm8766_write_cached(struct oxygen *chip, struct xonar_wm87x6 *data = chip->model_data; if (reg >= ARRAY_SIZE(data->wm8766_regs) || - value != data->wm8766_regs[reg]) { - if ((reg >= WM8766_LDA1 && reg <= WM8766_RDA1) || - (reg >= WM8766_LDA2 && reg <= WM8766_MASTDA)) - value &= ~WM8766_UPDATE; + value != data->wm8766_regs[reg]) wm8766_write(chip, reg, value); - } } static void wm8776_registers_init(struct oxygen *chip) -- cgit v1.1 From 9bac84edf0360ac94a27308778ef98dc9068777c Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Thu, 9 Sep 2010 12:19:21 +0200 Subject: ALSA: virtuoso: fix Xonar DS input switches Use the correct number, register bits, and names for the input switches. Signed-off-by: Clemens Ladisch Signed-off-by: Takashi Iwai --- sound/pci/oxygen/xonar_wm87x6.c | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/pci/oxygen/xonar_wm87x6.c b/sound/pci/oxygen/xonar_wm87x6.c index 4346006d..fb3f95c 100644 --- a/sound/pci/oxygen/xonar_wm87x6.c +++ b/sound/pci/oxygen/xonar_wm87x6.c @@ -29,6 +29,13 @@ * GPIO 6 -> route input jack to input 1/2 (1/0) * GPIO 7 -> enable output to speakers * GPIO 8 -> enable output to speakers + * + * WM8766: + * + * input 1 <- line + * input 2 <- mic + * input 3 <- front mic + * input 4 <- aux */ #include @@ -896,7 +903,10 @@ static const struct snd_kcontrol_new ds_controls[] = { .put = wm8776_input_mux_put, .private_value = 1 << 1, }, - WM8776_BIT_SWITCH("Aux", WM8776_ADCMUX, 1 << 2, 0, 0), + WM8776_BIT_SWITCH("Front Mic Capture Switch", + WM8776_ADCMUX, 1 << 2, 0, 0), + WM8776_BIT_SWITCH("Aux Capture Switch", + WM8776_ADCMUX, 1 << 3, 0, 0), { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "ADC Filter Capture Enum", -- cgit v1.1 From 435feac648cab190990aa0bf9355f77d1f082db3 Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Thu, 9 Sep 2010 12:20:29 +0200 Subject: ALSA: virtuoso: add Xonar DS headphone jack detection Now that the polarity of the headphone detection pin is known, replace the debugging message with a proper jack plug input device. Signed-off-by: Clemens Ladisch Signed-off-by: Takashi Iwai --- sound/pci/Kconfig | 1 + sound/pci/oxygen/xonar_wm87x6.c | 25 +++++++++++++++++++------ 2 files changed, 20 insertions(+), 6 deletions(-) (limited to 'sound') diff --git a/sound/pci/Kconfig b/sound/pci/Kconfig index e7a8cd0..b40f2b8 100644 --- a/sound/pci/Kconfig +++ b/sound/pci/Kconfig @@ -817,6 +817,7 @@ config SND_VIA82XX_MODEM config SND_VIRTUOSO tristate "Asus Virtuoso 100/200 (Xonar)" select SND_OXYGEN_LIB + select SND_JACK if INPUT=y || INPUT=SND help Say Y here to include support for sound cards based on the Asus AV100/AV200 chips, i.e., Xonar D1, DX, D2, D2X, diff --git a/sound/pci/oxygen/xonar_wm87x6.c b/sound/pci/oxygen/xonar_wm87x6.c index fb3f95c..9d57b5e 100644 --- a/sound/pci/oxygen/xonar_wm87x6.c +++ b/sound/pci/oxygen/xonar_wm87x6.c @@ -25,8 +25,8 @@ * SPI 0 -> WM8766 (surround, center/LFE, back) * SPI 1 -> WM8776 (front, input) * - * GPIO 4 <- headphone detect - * GPIO 6 -> route input jack to input 1/2 (1/0) + * GPIO 4 <- headphone detect, 0 = plugged + * GPIO 6 -> route input jack to mic-in (0) or line-in (1) * GPIO 7 -> enable output to speakers * GPIO 8 -> enable output to speakers * @@ -42,6 +42,7 @@ #include #include #include +#include #include #include #include @@ -63,6 +64,7 @@ struct xonar_wm87x6 { struct snd_kcontrol *line_adcmux_control; struct snd_kcontrol *mic_adcmux_control; struct snd_kcontrol *lc_controls[13]; + struct snd_jack *hp_jack; }; static void wm8776_write(struct oxygen *chip, @@ -177,6 +179,16 @@ static void wm8776_init(struct oxygen *chip) wm8776_registers_init(chip); } +static void xonar_ds_report_hp_jack(struct oxygen *chip) +{ + struct xonar_wm87x6 *data = chip->model_data; + u16 bits; + + bits = oxygen_read16(chip, OXYGEN_GPIO_DATA); + snd_jack_report(data->hp_jack, + bits & GPIO_DS_HP_DETECT ? 0 : SND_JACK_HEADPHONE); +} + static void xonar_ds_init(struct oxygen *chip) { struct xonar_wm87x6 *data = chip->model_data; @@ -195,6 +207,10 @@ static void xonar_ds_init(struct oxygen *chip) xonar_enable_output(chip); + snd_jack_new(chip->card, "Headphone", + SND_JACK_HEADPHONE, &data->hp_jack); + xonar_ds_report_hp_jack(chip); + snd_component_add(chip->card, "WM8776"); snd_component_add(chip->card, "WM8766"); } @@ -332,10 +348,7 @@ static void update_wm87x6_mute(struct oxygen *chip) static void xonar_ds_gpio_changed(struct oxygen *chip) { - u16 bits; - - bits = oxygen_read16(chip, OXYGEN_GPIO_DATA); - snd_printk(KERN_INFO "HP detect: %d\n", !!(bits & GPIO_DS_HP_DETECT)); + xonar_ds_report_hp_jack(chip); } static int wm8776_bit_switch_get(struct snd_kcontrol *ctl, -- cgit v1.1 From 84cf83a28d4a3cd1fac1384cbaa4ed0ba650d309 Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Thu, 9 Sep 2010 12:23:06 +0200 Subject: ALSA: virtuoso: automatically handle Xonar DS headphone routing Automatically mute the speaker outputs as long as a headphone is plugged. Signed-off-by: Clemens Ladisch Signed-off-by: Takashi Iwai --- sound/pci/oxygen/xonar_wm87x6.c | 57 +++++++++++++++++++++++++++++++---------- 1 file changed, 44 insertions(+), 13 deletions(-) (limited to 'sound') diff --git a/sound/pci/oxygen/xonar_wm87x6.c b/sound/pci/oxygen/xonar_wm87x6.c index 9d57b5e..cee07fe 100644 --- a/sound/pci/oxygen/xonar_wm87x6.c +++ b/sound/pci/oxygen/xonar_wm87x6.c @@ -27,8 +27,8 @@ * * GPIO 4 <- headphone detect, 0 = plugged * GPIO 6 -> route input jack to mic-in (0) or line-in (1) - * GPIO 7 -> enable output to speakers - * GPIO 8 -> enable output to speakers + * GPIO 7 -> enable output to front L/R speaker channels + * GPIO 8 -> enable output to other speaker channels and front panel headphone * * WM8766: * @@ -52,7 +52,8 @@ #define GPIO_DS_HP_DETECT 0x0010 #define GPIO_DS_INPUT_ROUTE 0x0040 -#define GPIO_DS_OUTPUT_ENABLE 0x0180 +#define GPIO_DS_OUTPUT_FRONTLR 0x0080 +#define GPIO_DS_OUTPUT_ENABLE 0x0100 #define LC_CONTROL_LIMITER 0x40000000 #define LC_CONTROL_ALC 0x20000000 @@ -150,7 +151,10 @@ static void wm8776_registers_init(struct oxygen *chip) static void wm8766_registers_init(struct oxygen *chip) { + struct xonar_wm87x6 *data = chip->model_data; + wm8766_write(chip, WM8766_RESET, 0); + wm8766_write(chip, WM8766_DAC_CTRL, data->wm8766_regs[WM8766_DAC_CTRL]); wm8766_write(chip, WM8766_INT_CTRL, WM8766_FMT_LJUST | WM8766_IWL_24); wm8766_write(chip, WM8766_DAC_CTRL2, WM8766_ZCD | (chip->dac_mute ? WM8766_DMUTE_MASK : 0)); @@ -179,14 +183,38 @@ static void wm8776_init(struct oxygen *chip) wm8776_registers_init(chip); } -static void xonar_ds_report_hp_jack(struct oxygen *chip) +static void wm8766_init(struct oxygen *chip) { struct xonar_wm87x6 *data = chip->model_data; - u16 bits; - bits = oxygen_read16(chip, OXYGEN_GPIO_DATA); - snd_jack_report(data->hp_jack, - bits & GPIO_DS_HP_DETECT ? 0 : SND_JACK_HEADPHONE); + data->wm8766_regs[WM8766_DAC_CTRL] = + WM8766_PL_LEFT_LEFT | WM8766_PL_RIGHT_RIGHT; + wm8766_registers_init(chip); +} + +static void xonar_ds_handle_hp_jack(struct oxygen *chip) +{ + struct xonar_wm87x6 *data = chip->model_data; + bool hp_plugged; + unsigned int reg; + + mutex_lock(&chip->mutex); + + hp_plugged = !(oxygen_read16(chip, OXYGEN_GPIO_DATA) & + GPIO_DS_HP_DETECT); + + oxygen_write16_masked(chip, OXYGEN_GPIO_DATA, + hp_plugged ? 0 : GPIO_DS_OUTPUT_FRONTLR, + GPIO_DS_OUTPUT_FRONTLR); + + reg = data->wm8766_regs[WM8766_DAC_CTRL] & ~WM8766_MUTEALL; + if (hp_plugged) + reg |= WM8766_MUTEALL; + wm8766_write_cached(chip, WM8766_DAC_CTRL, reg); + + snd_jack_report(data->hp_jack, hp_plugged ? SND_JACK_HEADPHONE : 0); + + mutex_unlock(&chip->mutex); } static void xonar_ds_init(struct oxygen *chip) @@ -197,10 +225,12 @@ static void xonar_ds_init(struct oxygen *chip) data->generic.output_enable_bit = GPIO_DS_OUTPUT_ENABLE; wm8776_init(chip); - wm8766_registers_init(chip); + wm8766_init(chip); - oxygen_write16_masked(chip, OXYGEN_GPIO_CONTROL, GPIO_DS_INPUT_ROUTE, - GPIO_DS_HP_DETECT | GPIO_DS_INPUT_ROUTE); + oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, + GPIO_DS_INPUT_ROUTE | GPIO_DS_OUTPUT_FRONTLR); + oxygen_clear_bits16(chip, OXYGEN_GPIO_CONTROL, + GPIO_DS_HP_DETECT); oxygen_set_bits16(chip, OXYGEN_GPIO_DATA, GPIO_DS_INPUT_ROUTE); oxygen_set_bits16(chip, OXYGEN_GPIO_INTERRUPT_MASK, GPIO_DS_HP_DETECT); chip->interrupt_mask |= OXYGEN_INT_GPIO; @@ -209,7 +239,7 @@ static void xonar_ds_init(struct oxygen *chip) snd_jack_new(chip->card, "Headphone", SND_JACK_HEADPHONE, &data->hp_jack); - xonar_ds_report_hp_jack(chip); + xonar_ds_handle_hp_jack(chip); snd_component_add(chip->card, "WM8776"); snd_component_add(chip->card, "WM8766"); @@ -231,6 +261,7 @@ static void xonar_ds_resume(struct oxygen *chip) wm8776_registers_init(chip); wm8766_registers_init(chip); xonar_enable_output(chip); + xonar_ds_handle_hp_jack(chip); } static void wm8776_adc_hardware_filter(unsigned int channel, @@ -348,7 +379,7 @@ static void update_wm87x6_mute(struct oxygen *chip) static void xonar_ds_gpio_changed(struct oxygen *chip) { - xonar_ds_report_hp_jack(chip); + xonar_ds_handle_hp_jack(chip); } static int wm8776_bit_switch_get(struct snd_kcontrol *ctl, -- cgit v1.1 From 2dbf0ea29c1e4dff4ee5f0c59b367168fa2e5a40 Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Thu, 9 Sep 2010 12:24:35 +0200 Subject: ALSA: virtuoso: Xonar DS: add stereo upmixing to center/LFE channels Add the possibility to route a mix of the two channels of stereo data to the center and LFE outputs. Due to a WM8766 restriction, all surround and back channels also get the mixed L/R signal in this case. Signed-off-by: Clemens Ladisch Signed-off-by: Takashi Iwai --- sound/pci/oxygen/xonar_wm87x6.c | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) (limited to 'sound') diff --git a/sound/pci/oxygen/xonar_wm87x6.c b/sound/pci/oxygen/xonar_wm87x6.c index cee07fe..aceaaa0 100644 --- a/sound/pci/oxygen/xonar_wm87x6.c +++ b/sound/pci/oxygen/xonar_wm87x6.c @@ -377,6 +377,24 @@ static void update_wm87x6_mute(struct oxygen *chip) (chip->dac_mute ? WM8766_DMUTE_MASK : 0)); } +static void update_wm8766_center_lfe_mix(struct oxygen *chip, bool mixed) +{ + struct xonar_wm87x6 *data = chip->model_data; + unsigned int reg; + + /* + * The WM8766 can mix left and right channels, but this setting + * applies to all three stereo pairs. + */ + reg = data->wm8766_regs[WM8766_DAC_CTRL] & + ~(WM8766_PL_LEFT_MASK | WM8766_PL_RIGHT_MASK); + if (mixed) + reg |= WM8766_PL_LEFT_LRMIX | WM8766_PL_RIGHT_LRMIX; + else + reg |= WM8766_PL_LEFT_LEFT | WM8766_PL_RIGHT_RIGHT; + wm8766_write_cached(chip, WM8766_DAC_CTRL, reg); +} + static void xonar_ds_gpio_changed(struct oxygen *chip) { xonar_ds_handle_hp_jack(chip); @@ -1067,6 +1085,7 @@ static const struct oxygen_model model_xonar_ds = { .set_adc_params = set_wm8776_adc_params, .update_dac_volume = update_wm87x6_volume, .update_dac_mute = update_wm87x6_mute, + .update_center_lfe_mix = update_wm8766_center_lfe_mix, .gpio_changed = xonar_ds_gpio_changed, .dac_tlv = wm87x6_dac_db_scale, .model_data_size = sizeof(struct xonar_wm87x6), -- cgit v1.1 From 99f08bf59019ca6c9056f10ee8f7e1ba6663251c Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Thu, 9 Sep 2010 12:25:29 +0200 Subject: ALSA: oxygen: fix CONFIG_SND_OXYGEN_LIB dependency selection As the select directive does not handle indirect dependencies, select those explicitly in the driver sections. Signed-off-by: Clemens Ladisch Signed-off-by: Takashi Iwai --- sound/pci/Kconfig | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) (limited to 'sound') diff --git a/sound/pci/Kconfig b/sound/pci/Kconfig index b40f2b8..0e75d55 100644 --- a/sound/pci/Kconfig +++ b/sound/pci/Kconfig @@ -207,12 +207,12 @@ config SND_CMIPCI config SND_OXYGEN_LIB tristate - select SND_PCM - select SND_MPU401_UART config SND_OXYGEN tristate "C-Media 8788 (Oxygen)" select SND_OXYGEN_LIB + select SND_PCM + select SND_MPU401_UART help Say Y here to include support for sound cards based on the C-Media CMI8788 (Oxygen HD Audio) chip: @@ -581,6 +581,8 @@ config SND_HDSPM config SND_HIFIER tristate "TempoTec HiFier Fantasia" select SND_OXYGEN_LIB + select SND_PCM + select SND_MPU401_UART help Say Y here to include support for the MediaTek/TempoTec HiFier Fantasia sound card. @@ -817,6 +819,8 @@ config SND_VIA82XX_MODEM config SND_VIRTUOSO tristate "Asus Virtuoso 100/200 (Xonar)" select SND_OXYGEN_LIB + select SND_PCM + select SND_MPU401_UART select SND_JACK if INPUT=y || INPUT=SND help Say Y here to include support for sound cards based on the -- cgit v1.1 From 51485e8e24919be10bd61dba1dede0032de2d952 Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Thu, 9 Sep 2010 12:26:52 +0200 Subject: ALSA: virtuoso: update Kconfig text Update the Xonar config texts with the latest information about the Xonar DS, HDAV1.3 Slim, and Xense. Signed-off-by: Clemens Ladisch Signed-off-by: Takashi Iwai --- sound/pci/Kconfig | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'sound') diff --git a/sound/pci/Kconfig b/sound/pci/Kconfig index 0e75d55..12e3465 100644 --- a/sound/pci/Kconfig +++ b/sound/pci/Kconfig @@ -817,17 +817,17 @@ config SND_VIA82XX_MODEM will be called snd-via82xx-modem. config SND_VIRTUOSO - tristate "Asus Virtuoso 100/200 (Xonar)" + tristate "Asus Virtuoso 66/100/200 (Xonar)" select SND_OXYGEN_LIB select SND_PCM select SND_MPU401_UART select SND_JACK if INPUT=y || INPUT=SND help Say Y here to include support for sound cards based on the - Asus AV100/AV200 chips, i.e., Xonar D1, DX, D2, D2X, + Asus AV66/AV100/AV200 chips, i.e., Xonar D1, DX, D2, D2X, DS, Essence ST (Deluxe), and Essence STX. - Support for the DS is experimental. - Support for the HDAV1.3 (Deluxe) is very experimental. + Support for the HDAV1.3 (Deluxe) is incomplete; for the + HDAV1.3 Slim and Xense, missing. To compile this driver as a module, choose M here: the module will be called snd-virtuoso. -- cgit v1.1 From b5786e85cb2ffd0b07e86dec38a442bd20765ad8 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Thu, 9 Sep 2010 14:21:17 +0200 Subject: ALSA: hda - Keep char arrays in input_mux items Keep char array in the input_mux item itself instead of pointing to an external string. This is a preliminary work for improving the input-mux name based on the pin role. Signed-off-by: Takashi Iwai --- sound/pci/hda/hda_codec.c | 18 ++++++------------ sound/pci/hda/hda_generic.c | 2 +- sound/pci/hda/hda_local.h | 6 +++--- sound/pci/hda/patch_analog.c | 6 +++--- sound/pci/hda/patch_realtek.c | 10 +++++----- sound/pci/hda/patch_sigmatel.c | 16 ++++++++-------- sound/pci/hda/patch_via.c | 15 ++++++++------- 7 files changed, 34 insertions(+), 39 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c index bfdde7b..4348c33 100644 --- a/sound/pci/hda/hda_codec.c +++ b/sound/pci/hda/hda_codec.c @@ -4662,17 +4662,8 @@ const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = { }; EXPORT_SYMBOL_HDA(auto_pin_cfg_labels); -static const char *input_labels[AUTO_PIN_LAST][4] = { - { "Mic", "Mic 2", "Mic 3", "Mic 4" }, - { "Front Mic", "Front Mic 2", "Front Mic 3", "Front Mic 4" }, - { "Line", "Line 2", "Line 3", "Line 4" }, - { "Front Line", "Front Line 2", "Front Line 3", "Front Line 4" }, - { "CD", "CD 2", "CD 3", "CD 4" }, - { "Aux", "Aux 2", "Aux 3", "Aux 4" }, -}; - -const char *snd_hda_get_input_pin_label(const struct auto_pin_cfg *cfg, - int input) +void snd_hda_get_input_pin_label(const struct auto_pin_cfg *cfg, + int input, char *str) { int type = cfg->inputs[input].type; int idx; @@ -4681,7 +4672,10 @@ const char *snd_hda_get_input_pin_label(const struct auto_pin_cfg *cfg, if (type != cfg->inputs[input].type) break; } - return input_labels[type][idx]; + if (idx > 0) + sprintf(str, "%s %d", auto_pin_cfg_labels[type], idx); + else + strcpy(str, auto_pin_cfg_labels[type]); } EXPORT_SYMBOL_HDA(snd_hda_get_input_pin_label); diff --git a/sound/pci/hda/hda_generic.c b/sound/pci/hda/hda_generic.c index 5ea2128..cce18ba 100644 --- a/sound/pci/hda/hda_generic.c +++ b/sound/pci/hda/hda_generic.c @@ -566,7 +566,7 @@ static int parse_adc_sub_nodes(struct hda_codec *codec, struct hda_gspec *spec, } label = spec->cap_labels[spec->input_mux.num_items]; strcpy(label, type); - spec->input_mux.items[spec->input_mux.num_items].label = label; + strcpy(spec->input_mux.items[spec->input_mux.num_items].label, label); /* unmute the PIN external input */ unmute_input(codec, node, 0); /* index = 0? */ diff --git a/sound/pci/hda/hda_local.h b/sound/pci/hda/hda_local.h index fb56174..b448b0a 100644 --- a/sound/pci/hda/hda_local.h +++ b/sound/pci/hda/hda_local.h @@ -215,7 +215,7 @@ int snd_hda_create_spdif_in_ctls(struct hda_codec *codec, hda_nid_t nid); */ #define HDA_MAX_NUM_INPUTS 16 struct hda_input_mux_item { - const char *label; + char label[32]; unsigned int index; }; struct hda_input_mux { @@ -391,8 +391,8 @@ struct auto_pin_cfg_item { }; struct auto_pin_cfg; -const char *snd_hda_get_input_pin_label(const struct auto_pin_cfg *cfg, - int input); +void snd_hda_get_input_pin_label(const struct auto_pin_cfg *cfg, + int input, char *label); struct auto_pin_cfg { int line_outs; diff --git a/sound/pci/hda/patch_analog.c b/sound/pci/hda/patch_analog.c index 3409d31..8de3a0d 100644 --- a/sound/pci/hda/patch_analog.c +++ b/sound/pci/hda/patch_analog.c @@ -2926,13 +2926,13 @@ static int ad1988_auto_create_analog_input_ctls(struct ad198x_spec *spec, type <= AUTO_PIN_FRONT_MIC); if (err < 0) return err; - imux->items[imux->num_items].label = - snd_hda_get_input_pin_label(cfg, i); + snd_hda_get_input_pin_label(cfg, i, + imux->items[imux->num_items].label); imux->items[imux->num_items].index = ad1988_pin_to_adc_idx(cfg->inputs[i].pin); imux->num_items++; } - imux->items[imux->num_items].label = "Mix"; + strcpy(imux->items[imux->num_items].label, "Mix"); imux->items[imux->num_items].index = 9; imux->num_items++; diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index 0c25d22..0a7d9d5 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -4974,8 +4974,8 @@ static int alc_auto_create_input_ctls(struct hda_codec *codec, if (idx < 0 && cap2) idx = get_connection_index(codec, cap2, pin); if (idx >= 0) { - imux->items[imux->num_items].label = - snd_hda_get_input_pin_label(cfg, i); + snd_hda_get_input_pin_label(cfg, i, + imux->items[imux->num_items].label); imux->items[imux->num_items].index = idx; imux->num_items++; } @@ -10626,9 +10626,9 @@ static int alc_auto_add_mic_boost(struct hda_codec *codec) break; nid = cfg->inputs[i].pin; if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) { - char label[32]; - snprintf(label, sizeof(label), "%s Boost", - snd_hda_get_input_pin_label(cfg, i)); + char pinname[32], label[32]; + snd_hda_get_input_pin_label(cfg, i, pinname); + snprintf(label, sizeof(label), "%s Boost", pinname); err = add_control(spec, ALC_CTL_WIDGET_VOL, label, 0, HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT)); if (err < 0) diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c index 7f09e14..852dae9 100644 --- a/sound/pci/hda/patch_sigmatel.c +++ b/sound/pci/hda/patch_sigmatel.c @@ -1116,7 +1116,7 @@ static int stac92xx_build_controls(struct hda_codec *codec) struct hda_input_mux *smux = &spec->private_smux; /* check for mute support on SPDIF out */ if (wcaps & AC_WCAP_OUT_AMP) { - smux->items[smux->num_items].label = "Off"; + strcpy(smux->items[smux->num_items].label, "Off"); smux->items[smux->num_items].index = 0; smux->num_items++; spec->spdif_mute = 1; @@ -3274,8 +3274,8 @@ static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec) return -EINVAL; for (i = 0; i < num_cons; i++) { - mono_mux->items[mono_mux->num_items].label = - stac92xx_mono_labels[i]; + strcpy(mono_mux->items[mono_mux->num_items].label, + stac92xx_mono_labels[i]); mono_mux->items[mono_mux->num_items].index = i; mono_mux->num_items++; } @@ -3404,7 +3404,7 @@ static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec) labels = stac92xx_spdif_labels; for (i = 0; i < num_cons; i++) { - spdif_mux->items[spdif_mux->num_items].label = labels[i]; + strcpy(spdif_mux->items[spdif_mux->num_items].label, labels[i]); spdif_mux->items[spdif_mux->num_items].index = i; spdif_mux->num_items++; } @@ -3538,7 +3538,7 @@ static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec, int err, i; unsigned int def_conf; - dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0]; + strcpy(dimux->items[dimux->num_items].label, stac92xx_dmic_labels[0]); dimux->items[dimux->num_items].index = 0; dimux->num_items++; @@ -3572,11 +3572,11 @@ static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec, return err; } - dimux->items[dimux->num_items].label = label; + strcpy(dimux->items[dimux->num_items].label, label); dimux->items[dimux->num_items].index = index; dimux->num_items++; if (snd_hda_get_bool_hint(codec, "separate_dmux") != 1) { - imux->items[imux->num_items].label = label; + strcpy(imux->items[imux->num_items].label, label); imux->items[imux->num_items].index = index; imux->num_items++; } @@ -3713,7 +3713,7 @@ static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const if (err < 0) return err; - imux->items[imux->num_items].label = label; + strcpy(imux->items[imux->num_items].label, label); imux->items[imux->num_items].index = index; imux->num_items++; } diff --git a/sound/pci/hda/patch_via.c b/sound/pci/hda/patch_via.c index 93b86ad..9c1909d 100644 --- a/sound/pci/hda/patch_via.c +++ b/sound/pci/hda/patch_via.c @@ -2376,7 +2376,7 @@ static void create_hp_imux(struct via_spec *spec) /* for hp mode select */ i = 0; while (texts[i] != NULL) { - imux->items[imux->num_items].label = texts[i]; + strcpy(imux->items[imux->num_items].label, texts[i]); imux->items[imux->num_items].index = i; imux->num_items++; i++; @@ -2423,7 +2423,8 @@ static int vt_auto_create_analog_input_ctls(struct via_spec *spec, /* for internal loopback recording select */ for (idx = 0; idx < num_idxs; idx++) { if (pin_idxs[idx] == 0xff) { - imux->items[imux->num_items].label = "Stereo Mixer"; + strcpy(imux->items[imux->num_items].label, + "Stereo Mixer"); imux->items[imux->num_items].index = idx; imux->num_items++; break; @@ -2445,8 +2446,8 @@ static int vt_auto_create_analog_input_ctls(struct via_spec *spec, type_idx, idx, cap_nid); if (err < 0) return err; - imux->items[imux->num_items].label = - snd_hda_get_input_pin_label(cfg, i); + snd_hda_get_input_pin_label(cfg, i, + imux->items[imux->num_items].label); imux->items[imux->num_items].index = idx; imux->num_items++; } @@ -4336,7 +4337,7 @@ static int vt1702_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) /* for hp mode select */ i = 0; while (texts[i] != NULL) { - imux->items[imux->num_items].label = texts[i]; + strcpy(imux->items[imux->num_items].label, texts[i]); imux->items[imux->num_items].index = i; imux->num_items++; i++; @@ -5520,7 +5521,7 @@ static int vt2002P_auto_create_analog_input_ctls(struct via_spec *spec, return err; /* for digital mic select */ - imux->items[imux->num_items].label = "Digital Mic"; + strcpy(imux->items[imux->num_items].label, "Digital Mic"); imux->items[imux->num_items].index = 4; imux->num_items++; @@ -5843,7 +5844,7 @@ static int vt1812_auto_create_analog_input_ctls(struct via_spec *spec, return err; /* for digital mic select */ - imux->items[imux->num_items].label = "Digital Mic"; + strcpy(imux->items[imux->num_items].label, "Digital Mic"); imux->items[imux->num_items].index = 6; imux->num_items++; -- cgit v1.1 From 86e2959a10828dd2614e037fb2502bc833adca52 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Thu, 9 Sep 2010 14:50:17 +0200 Subject: ALSA: hda - Remove AUTO_PIN_FRONT_{MIC|LINE} We can assign multiple pins to a single role now, let's reduce the redundant FRONT_MIC and FRONT_LINE. Also, autocfg->input_pins[] is no longer used, so this is removed as well. Signed-off-by: Takashi Iwai --- sound/pci/hda/hda_codec.c | 50 +++++------------------------------------- sound/pci/hda/hda_local.h | 5 +---- sound/pci/hda/patch_analog.c | 4 ++-- sound/pci/hda/patch_cirrus.c | 6 ++--- sound/pci/hda/patch_realtek.c | 8 +++---- sound/pci/hda/patch_sigmatel.c | 20 ++++++----------- sound/pci/hda/patch_via.c | 16 +++++++------- 7 files changed, 31 insertions(+), 78 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c index 4348c33..0ee4439 100644 --- a/sound/pci/hda/hda_codec.c +++ b/sound/pci/hda/hda_codec.c @@ -4396,7 +4396,7 @@ static void add_auto_cfg_input_pin(struct auto_pin_cfg *cfg, hda_nid_t nid, * output, i.e. to line_out_pins[0]. So, line_outs is always positive * if any analog output exists. * - * The analog input pins are assigned to input_pins array. + * The analog input pins are assigned to inputs array. * The digital input/output pins are assigned to dig_in_pin and dig_out_pin, * respectively. */ @@ -4480,39 +4480,16 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec, sequences_hp[cfg->hp_outs] = (assoc << 4) | seq; cfg->hp_outs++; break; - case AC_JACK_MIC_IN: { - int preferred, alt; - if (loc == AC_JACK_LOC_FRONT || - (loc & 0x30) == AC_JACK_LOC_INTERNAL) { - preferred = AUTO_PIN_FRONT_MIC; - alt = AUTO_PIN_MIC; - } else { - preferred = AUTO_PIN_MIC; - alt = AUTO_PIN_FRONT_MIC; - } - if (!cfg->input_pins[preferred]) - cfg->input_pins[preferred] = nid; - else if (!cfg->input_pins[alt]) - cfg->input_pins[alt] = nid; - add_auto_cfg_input_pin(cfg, nid, preferred); + case AC_JACK_MIC_IN: + add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_MIC); break; - } - case AC_JACK_LINE_IN: { - int type; - if (loc == AC_JACK_LOC_FRONT) - type = AUTO_PIN_FRONT_LINE; - else - type = AUTO_PIN_LINE; - cfg->input_pins[type] = nid; - add_auto_cfg_input_pin(cfg, nid, type); + case AC_JACK_LINE_IN: + add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_LINE_IN); break; - } case AC_JACK_CD: - cfg->input_pins[AUTO_PIN_CD] = nid; add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_CD); break; case AC_JACK_AUX: - cfg->input_pins[AUTO_PIN_AUX] = nid; add_auto_cfg_input_pin(cfg, nid, AUTO_PIN_AUX); break; case AC_JACK_SPDIF_OUT: @@ -4570,21 +4547,6 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec, sort_pins_by_sequence(cfg->hp_pins, sequences_hp, cfg->hp_outs); - /* if we have only one mic, make it AUTO_PIN_MIC */ - if (!cfg->input_pins[AUTO_PIN_MIC] && - cfg->input_pins[AUTO_PIN_FRONT_MIC]) { - cfg->input_pins[AUTO_PIN_MIC] = - cfg->input_pins[AUTO_PIN_FRONT_MIC]; - cfg->input_pins[AUTO_PIN_FRONT_MIC] = 0; - } - /* ditto for line-in */ - if (!cfg->input_pins[AUTO_PIN_LINE] && - cfg->input_pins[AUTO_PIN_FRONT_LINE]) { - cfg->input_pins[AUTO_PIN_LINE] = - cfg->input_pins[AUTO_PIN_FRONT_LINE]; - cfg->input_pins[AUTO_PIN_FRONT_LINE] = 0; - } - /* * FIX-UP: if no line-outs are detected, try to use speaker or HP pin * as a primary output @@ -4658,7 +4620,7 @@ EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config); /* labels for input pins - for obsoleted config stuff */ const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = { - "Mic", "Front Mic", "Line", "Front Line", "CD", "Aux" + "Mic", "Line", "CD", "Aux" }; EXPORT_SYMBOL_HDA(auto_pin_cfg_labels); diff --git a/sound/pci/hda/hda_local.h b/sound/pci/hda/hda_local.h index b448b0a..72e7b2f 100644 --- a/sound/pci/hda/hda_local.h +++ b/sound/pci/hda/hda_local.h @@ -366,9 +366,7 @@ struct hda_bus_unsolicited { enum { AUTO_PIN_MIC, - AUTO_PIN_FRONT_MIC, - AUTO_PIN_LINE, - AUTO_PIN_FRONT_LINE, + AUTO_PIN_LINE_IN, AUTO_PIN_CD, AUTO_PIN_AUX, AUTO_PIN_LAST @@ -403,7 +401,6 @@ struct auto_pin_cfg { int hp_outs; int line_out_type; /* AUTO_PIN_XXX_OUT */ hda_nid_t hp_pins[AUTO_CFG_MAX_OUTS]; - hda_nid_t input_pins[AUTO_PIN_LAST]; /* old config; to be deprecated */ int num_inputs; struct auto_pin_cfg_item inputs[AUTO_CFG_MAX_INS]; int dig_outs; diff --git a/sound/pci/hda/patch_analog.c b/sound/pci/hda/patch_analog.c index 8de3a0d..85fc0b9 100644 --- a/sound/pci/hda/patch_analog.c +++ b/sound/pci/hda/patch_analog.c @@ -2923,7 +2923,7 @@ static int ad1988_auto_create_analog_input_ctls(struct ad198x_spec *spec, type_idx = 0; err = new_analog_input(spec, cfg->inputs[i].pin, auto_pin_cfg_labels[type], type_idx, - type <= AUTO_PIN_FRONT_MIC); + type == AUTO_PIN_MIC); if (err < 0) return err; snd_hda_get_input_pin_label(cfg, i, @@ -3015,7 +3015,7 @@ static void ad1988_auto_init_analog_input(struct hda_codec *codec) break; } snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, - i <= AUTO_PIN_FRONT_MIC ? PIN_VREF80 : PIN_IN); + i == AUTO_PIN_MIC ? PIN_VREF80 : PIN_IN); if (nid != AD1988_PIN_CD_NID) snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); diff --git a/sound/pci/hda/patch_cirrus.c b/sound/pci/hda/patch_cirrus.c index 6adfc56..adb5ec5 100644 --- a/sound/pci/hda/patch_cirrus.c +++ b/sound/pci/hda/patch_cirrus.c @@ -436,8 +436,8 @@ static int parse_input(struct hda_codec *codec) /* check whether the automatic mic switch is available */ if (spec->num_inputs == 2 && - cfg->inputs[0].type <= AUTO_PIN_FRONT_MIC && - cfg->inputs[1].type == AUTO_PIN_FRONT_MIC) { + cfg->inputs[0].type == AUTO_PIN_MIC && + cfg->inputs[1].type == AUTO_PIN_MIC) { if (is_ext_mic(codec, cfg->inputs[0].pin)) { if (!is_ext_mic(codec, cfg->inputs[1].pin)) { spec->mic_detect = 1; @@ -921,7 +921,7 @@ static void init_input(struct hda_codec *codec) continue; /* set appropriate pin control and mute first */ ctl = PIN_IN; - if (cfg->inputs[i].type <= AUTO_PIN_FRONT_MIC) { + if (cfg->inputs[i].type == AUTO_PIN_MIC) { unsigned int caps = snd_hda_query_pin_caps(codec, pin); caps >>= AC_PINCAP_VREF_SHIFT; if (caps & AC_PINCAP_VREF_80) diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index 0a7d9d5..8ae30cc 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -846,7 +846,7 @@ static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid, { unsigned int val = PIN_IN; - if (auto_pin_type <= AUTO_PIN_FRONT_MIC) { + if (auto_pin_type == AUTO_PIN_MIC) { unsigned int pincap; unsigned int oldval; oldval = snd_hda_codec_read(codec, nid, 0, @@ -1298,7 +1298,7 @@ static void alc_init_auto_mic(struct hda_codec *codec) /* there must be only two mic inputs exclusively */ for (i = 0; i < cfg->num_inputs; i++) - if (cfg->inputs[i].type >= AUTO_PIN_LINE) + if (cfg->inputs[i].type >= AUTO_PIN_LINE_IN) return; fixed = ext = 0; @@ -10622,7 +10622,7 @@ static int alc_auto_add_mic_boost(struct hda_codec *codec) hda_nid_t nid; for (i = 0; i < cfg->num_inputs; i++) { - if (cfg->inputs[i].type > AUTO_PIN_FRONT_MIC) + if (cfg->inputs[i].type > AUTO_PIN_MIC) break; nid = cfg->inputs[i].pin; if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) { @@ -19270,7 +19270,7 @@ static void alc680_base_setup(struct hda_codec *codec) spec->autocfg.inputs[0].pin = 0x18; spec->autocfg.inputs[0].type = AUTO_PIN_MIC; spec->autocfg.inputs[1].pin = 0x19; - spec->autocfg.inputs[1].type = AUTO_PIN_LINE; + spec->autocfg.inputs[1].type = AUTO_PIN_LINE_IN; } static void alc680_unsol_event(struct hda_codec *codec, diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c index 852dae9..d9c8b4d 100644 --- a/sound/pci/hda/patch_sigmatel.c +++ b/sound/pci/hda/patch_sigmatel.c @@ -2834,7 +2834,7 @@ static hda_nid_t check_line_out_switch(struct hda_codec *codec) if (cfg->line_out_type != AUTO_PIN_LINE_OUT) return 0; for (i = 0; i < cfg->num_inputs; i++) { - if (cfg->inputs[i].type == AUTO_PIN_LINE) { + if (cfg->inputs[i].type == AUTO_PIN_LINE_IN) { nid = cfg->inputs[i].pin; pincap = snd_hda_query_pin_caps(codec, nid); if (pincap & AC_PINCAP_OUT) @@ -2852,16 +2852,14 @@ static hda_nid_t check_mic_out_switch(struct hda_codec *codec, hda_nid_t *dac) struct sigmatel_spec *spec = codec->spec; struct auto_pin_cfg *cfg = &spec->autocfg; unsigned int def_conf, pincap; - int i, mic_type; + int i; *dac = 0; if (cfg->line_out_type != AUTO_PIN_LINE_OUT) return 0; - mic_type = AUTO_PIN_MIC; - again: for (i = 0; i < cfg->num_inputs; i++) { hda_nid_t nid = cfg->inputs[i].pin; - if (cfg->inputs[i].type != mic_type) + if (cfg->inputs[i].type != AUTO_PIN_MIC) continue; def_conf = snd_hda_codec_get_pincfg(codec, nid); /* some laptops have an internal analog microphone @@ -2875,10 +2873,6 @@ static hda_nid_t check_mic_out_switch(struct hda_codec *codec, hda_nid_t *dac) } } } - if (mic_type == AUTO_PIN_MIC) { - mic_type = AUTO_PIN_FRONT_MIC; - goto again; - } return 0; } @@ -3222,7 +3216,7 @@ static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec, } for (idx = 0; idx < cfg->num_inputs; idx++) { - if (cfg->inputs[idx].type > AUTO_PIN_FRONT_LINE) + if (cfg->inputs[idx].type > AUTO_PIN_LINE_IN) break; nid = cfg->inputs[idx].pin; err = stac92xx_add_jack_mode_control(codec, nid, idx); @@ -3621,7 +3615,7 @@ static int set_mic_route(struct hda_codec *codec, if (pin == cfg->inputs[i].pin) break; } - if (i < cfg->num_inputs && cfg->inputs[i].type <= AUTO_PIN_FRONT_MIC) { + if (i < cfg->num_inputs && cfg->inputs[i].type == AUTO_PIN_MIC) { /* analog pin */ i = get_connection_index(codec, spec->mux_nids[0], pin); if (i < 0) @@ -3656,7 +3650,7 @@ static int stac_check_auto_mic(struct hda_codec *codec) int i; for (i = 0; i < cfg->num_inputs; i++) { - if (cfg->inputs[i].type >= AUTO_PIN_LINE) + if (cfg->inputs[i].type >= AUTO_PIN_LINE_IN) return 0; /* must be exclusively mics */ } fixed = ext = 0; @@ -4394,7 +4388,7 @@ static int stac92xx_init(struct hda_codec *codec) hda_nid_t nid = cfg->inputs[i].pin; int type = cfg->inputs[i].type; unsigned int pinctl, conf; - if (type == AUTO_PIN_MIC || type == AUTO_PIN_FRONT_MIC) { + if (type == AUTO_PIN_MIC) { /* for mic pins, force to initialize */ pinctl = stac92xx_get_default_vref(codec, nid); pinctl |= AC_PINCTL_IN_EN; diff --git a/sound/pci/hda/patch_via.c b/sound/pci/hda/patch_via.c index 9c1909d..de5f61d 100644 --- a/sound/pci/hda/patch_via.c +++ b/sound/pci/hda/patch_via.c @@ -568,7 +568,7 @@ static void via_auto_init_analog_input(struct hda_codec *codec) hda_nid_t nid = cfg->inputs[i].pin; if (spec->smart51_enabled && is_smart51_pins(spec, nid)) ctl = PIN_OUT; - else if (i <= AUTO_PIN_FRONT_MIC) + else if (i == AUTO_PIN_MIC) ctl = PIN_VREF50; else ctl = PIN_IN; @@ -1328,7 +1328,7 @@ static int is_smart51_pins(struct via_spec *spec, hda_nid_t pin) for (i = 0; i < cfg->num_inputs; i++) { if (pin == cfg->inputs[i].pin) - return cfg->inputs[i].type < AUTO_PIN_FRONT_LINE; + return cfg->inputs[i].type <= AUTO_PIN_LINE_IN; } return 0; } @@ -1356,9 +1356,9 @@ static int via_smart51_get(struct snd_kcontrol *kcontrol, hda_nid_t nid = cfg->inputs[i].pin; int ctl = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0); - if (cfg->inputs[i].type >= AUTO_PIN_FRONT_LINE) + if (cfg->inputs[i].type > AUTO_PIN_LINE_IN) continue; - if (cfg->inputs[i].type == AUTO_PIN_FRONT_MIC && + if (cfg->inputs[i].type == AUTO_PIN_MIC && spec->hp_independent_mode && spec->codec_type != VT1718S) continue; /* ignore FMic for independent HP */ if ((ctl & AC_PINCTL_IN_EN) && !(ctl & AC_PINCTL_OUT_EN)) @@ -1382,9 +1382,9 @@ static int via_smart51_put(struct snd_kcontrol *kcontrol, hda_nid_t nid = cfg->inputs[i].pin; unsigned int parm; - if (cfg->inputs[i].type >= AUTO_PIN_FRONT_LINE) + if (cfg->inputs[i].type > AUTO_PIN_LINE_IN) continue; - if (cfg->inputs[i].type == AUTO_PIN_FRONT_MIC && + if (cfg->inputs[i].type == AUTO_PIN_MIC && spec->hp_independent_mode && spec->codec_type != VT1718S) continue; /* don't retask FMic for independent HP */ @@ -1404,7 +1404,7 @@ static int via_smart51_put(struct snd_kcontrol *kcontrol, codec, nid, HDA_OUTPUT, 0, HDA_AMP_MUTE, HDA_AMP_UNMUTE); } - if (cfg->inputs[i].type == AUTO_PIN_FRONT_MIC) { + if (cfg->inputs[i].type == AUTO_PIN_MIC) { if (spec->codec_type == VT1708S || spec->codec_type == VT1716S) { /* input = index 1 (AOW3) */ @@ -1450,7 +1450,7 @@ static int via_smart51_build(struct via_spec *spec) for (i = 0; i < cfg->num_inputs; i++) { nid = cfg->inputs[i].pin; - if (cfg->inputs[i].type < AUTO_PIN_FRONT_LINE) { + if (cfg->inputs[i].type <= AUTO_PIN_LINE_IN) { knew = via_clone_control(spec, &via_smart51_mixer[1]); if (knew == NULL) return -ENOMEM; -- cgit v1.1 From 10a20af7c944649dc6d1ffa06bc759f5f3a16cd9 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Thu, 9 Sep 2010 16:28:02 +0200 Subject: ALSA: hda - Improve the input source name labels This patch improves the input-source label strings to be generated from the pin information instead of fixed strings per AUTO_PIN_* type. This gives more suitable labels, especially for mic and line-in pins. Signed-off-by: Takashi Iwai --- sound/pci/hda/hda_codec.c | 91 +++++++++++++++++++++----- sound/pci/hda/hda_generic.c | 41 ++---------- sound/pci/hda/hda_local.h | 11 ++-- sound/pci/hda/patch_analog.c | 27 ++++---- sound/pci/hda/patch_ca0110.c | 3 +- sound/pci/hda/patch_cirrus.c | 4 +- sound/pci/hda/patch_realtek.c | 20 +++--- sound/pci/hda/patch_sigmatel.c | 144 ++++++----------------------------------- sound/pci/hda/patch_via.c | 100 ++++++++++++---------------- 9 files changed, 174 insertions(+), 267 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c index 0ee4439..e328434 100644 --- a/sound/pci/hda/hda_codec.c +++ b/sound/pci/hda/hda_codec.c @@ -4607,7 +4607,7 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec, snd_printd(" inputs:"); for (i = 0; i < cfg->num_inputs; i++) { snd_printdd(" %s=0x%x", - auto_pin_cfg_labels[cfg->inputs[i].type], + hda_get_autocfg_input_label(codec, cfg, i), cfg->inputs[i].pin); } snd_printd("\n"); @@ -4618,28 +4618,87 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec, } EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config); -/* labels for input pins - for obsoleted config stuff */ -const char *auto_pin_cfg_labels[AUTO_PIN_LAST] = { - "Mic", "Line", "CD", "Aux" -}; -EXPORT_SYMBOL_HDA(auto_pin_cfg_labels); +const char *hda_get_input_pin_label(struct hda_codec *codec, hda_nid_t pin, + int check_location) +{ + unsigned int def_conf, loc; + + def_conf = snd_hda_codec_get_pincfg(codec, pin); + loc = get_defcfg_location(def_conf); + + switch (get_defcfg_device(def_conf)) { + case AC_JACK_MIC_IN: + if (!check_location) + return "Mic"; + if (get_defcfg_connect(def_conf) == AC_JACK_PORT_FIXED || + (loc & 0x30) == AC_JACK_LOC_INTERNAL) + return "Internal Mic"; + if ((loc & 0x30) == AC_JACK_LOC_SEPARATE) + return "Dock Mic"; + if (loc == AC_JACK_LOC_REAR) + return "Rear Mic"; + return "Mic"; + case AC_JACK_LINE_IN: + if (!check_location) + return "Line"; + if ((loc & 0xf0) == AC_JACK_LOC_SEPARATE) + return "Dock Line"; + return "Line"; + case AC_JACK_AUX: + return "Aux"; + case AC_JACK_CD: + return "CD"; + case AC_JACK_SPDIF_IN: + return "SPDIF In"; + case AC_JACK_DIG_OTHER_IN: + return "Digital In"; + default: + return "Misc"; + } +} +EXPORT_SYMBOL_HDA(hda_get_input_pin_label); -void snd_hda_get_input_pin_label(const struct auto_pin_cfg *cfg, - int input, char *str) +const char *hda_get_autocfg_input_label(struct hda_codec *codec, + const struct auto_pin_cfg *cfg, + int input) { int type = cfg->inputs[input].type; - int idx; + int has_multiple_pins = 0; - for (idx = 0; idx < 3 && --input >= 0; idx++) { - if (type != cfg->inputs[input].type) - break; + if ((input > 0 && cfg->inputs[input - 1].type == type) || + (input < cfg->num_inputs - 1 && cfg->inputs[input + 1].type == type)) + has_multiple_pins = 1; + return hda_get_input_pin_label(codec, cfg->inputs[input].pin, + has_multiple_pins); +} +EXPORT_SYMBOL_HDA(hda_get_autocfg_input_label); + +int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label, + int index, int *type_idx) +{ + int i, label_idx = 0; + if (imux->num_items >= HDA_MAX_NUM_INPUTS) { + snd_printd(KERN_ERR "hda_codec: Too many imux items!\n"); + return -EINVAL; + } + for (i = 0; i < imux->num_items; i++) { + if (!strncmp(label, imux->items[i].label, strlen(label))) + label_idx++; } - if (idx > 0) - sprintf(str, "%s %d", auto_pin_cfg_labels[type], idx); + if (type_idx) + *type_idx = label_idx; + if (label_idx > 0) + snprintf(imux->items[imux->num_items].label, + sizeof(imux->items[imux->num_items].label), + "%s %d", label, label_idx); else - strcpy(str, auto_pin_cfg_labels[type]); + strlcpy(imux->items[imux->num_items].label, label, + sizeof(imux->items[imux->num_items].label)); + imux->items[imux->num_items].index = index; + imux->num_items++; + return 0; } -EXPORT_SYMBOL_HDA(snd_hda_get_input_pin_label); +EXPORT_SYMBOL_HDA(snd_hda_add_imux_item); #ifdef CONFIG_PM diff --git a/sound/pci/hda/hda_generic.c b/sound/pci/hda/hda_generic.c index cce18ba..fb0582f8 100644 --- a/sound/pci/hda/hda_generic.c +++ b/sound/pci/hda/hda_generic.c @@ -61,7 +61,6 @@ struct hda_gspec { struct hda_gnode *cap_vol_node; /* Node for capture volume */ unsigned int cur_cap_src; /* current capture source */ struct hda_input_mux input_mux; - char cap_labels[HDA_MAX_NUM_INPUTS][16]; unsigned int def_amp_in_caps; unsigned int def_amp_out_caps; @@ -506,11 +505,10 @@ static const char *get_input_type(struct hda_gnode *node, unsigned int *pinctl) * returns 0 if not found, 1 if found, or a negative error code. */ static int parse_adc_sub_nodes(struct hda_codec *codec, struct hda_gspec *spec, - struct hda_gnode *node) + struct hda_gnode *node, int idx) { int i, err; unsigned int pinctl; - char *label; const char *type; if (node->checked) @@ -523,7 +521,7 @@ static int parse_adc_sub_nodes(struct hda_codec *codec, struct hda_gspec *spec, child = hda_get_node(spec, node->conn_list[i]); if (! child) continue; - err = parse_adc_sub_nodes(codec, spec, child); + err = parse_adc_sub_nodes(codec, spec, child, idx); if (err < 0) return err; if (err > 0) { @@ -564,9 +562,7 @@ static int parse_adc_sub_nodes(struct hda_codec *codec, struct hda_gspec *spec, return 0; type = "Input"; } - label = spec->cap_labels[spec->input_mux.num_items]; - strcpy(label, type); - strcpy(spec->input_mux.items[spec->input_mux.num_items].label, label); + snd_hda_add_imux_item(&spec->input_mux, type, idx, NULL); /* unmute the PIN external input */ unmute_input(codec, node, 0); /* index = 0? */ @@ -577,29 +573,6 @@ static int parse_adc_sub_nodes(struct hda_codec *codec, struct hda_gspec *spec, return 1; /* found */ } -/* add a capture source element */ -static void add_cap_src(struct hda_gspec *spec, int idx) -{ - struct hda_input_mux_item *csrc; - char *buf; - int num, ocap; - - num = spec->input_mux.num_items; - csrc = &spec->input_mux.items[num]; - buf = spec->cap_labels[num]; - for (ocap = 0; ocap < num; ocap++) { - if (! strcmp(buf, spec->cap_labels[ocap])) { - /* same label already exists, - * put the index number to be unique - */ - sprintf(buf, "%s %d", spec->cap_labels[ocap], num); - break; - } - } - csrc->index = idx; - spec->input_mux.num_items++; -} - /* * parse input */ @@ -624,22 +597,18 @@ static int parse_input_path(struct hda_codec *codec, struct hda_gnode *adc_node) for (i = 0; i < adc_node->nconns; i++) { node = hda_get_node(spec, adc_node->conn_list[i]); if (node && node->type == AC_WID_PIN) { - err = parse_adc_sub_nodes(codec, spec, node); + err = parse_adc_sub_nodes(codec, spec, node, i); if (err < 0) return err; - else if (err > 0) - add_cap_src(spec, i); } } /* ... then check the rests, more complicated connections */ for (i = 0; i < adc_node->nconns; i++) { node = hda_get_node(spec, adc_node->conn_list[i]); if (node && node->type != AC_WID_PIN) { - err = parse_adc_sub_nodes(codec, spec, node); + err = parse_adc_sub_nodes(codec, spec, node, i); if (err < 0) return err; - else if (err > 0) - add_cap_src(spec, i); } } diff --git a/sound/pci/hda/hda_local.h b/sound/pci/hda/hda_local.h index 72e7b2f..6943efc 100644 --- a/sound/pci/hda/hda_local.h +++ b/sound/pci/hda/hda_local.h @@ -378,8 +378,6 @@ enum { AUTO_PIN_HP_OUT }; -extern const char *auto_pin_cfg_labels[AUTO_PIN_LAST]; - #define AUTO_CFG_MAX_OUTS 5 #define AUTO_CFG_MAX_INS 8 @@ -389,8 +387,13 @@ struct auto_pin_cfg_item { }; struct auto_pin_cfg; -void snd_hda_get_input_pin_label(const struct auto_pin_cfg *cfg, - int input, char *label); +const char *hda_get_input_pin_label(struct hda_codec *codec, hda_nid_t pin, + int check_location); +const char *hda_get_autocfg_input_label(struct hda_codec *codec, + const struct auto_pin_cfg *cfg, + int input); +int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label, + int index, int *type_index_ret); struct auto_pin_cfg { int line_outs; diff --git a/sound/pci/hda/patch_analog.c b/sound/pci/hda/patch_analog.c index 85fc0b9..05db1cf 100644 --- a/sound/pci/hda/patch_analog.c +++ b/sound/pci/hda/patch_analog.c @@ -2909,32 +2909,27 @@ static int new_analog_input(struct ad198x_spec *spec, hda_nid_t pin, } /* create playback/capture controls for input pins */ -static int ad1988_auto_create_analog_input_ctls(struct ad198x_spec *spec, +static int ad1988_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg) { + struct ad198x_spec *spec = codec->spec; struct hda_input_mux *imux = &spec->private_imux; - int i, err, type, type_idx = 0; + int i, err, type, type_idx; for (i = 0; i < cfg->num_inputs; i++) { + const char *label; type = cfg->inputs[i].type; - if (i > 0 && type != cfg->inputs[i - 1].type) - type_idx++; - else - type_idx = 0; + label = hda_get_autocfg_input_label(codec, cfg, i); + snd_hda_add_imux_item(imux, label, + ad1988_pin_to_adc_idx(cfg->inputs[i].pin), + &type_idx); err = new_analog_input(spec, cfg->inputs[i].pin, - auto_pin_cfg_labels[type], type_idx, + label, type_idx, type == AUTO_PIN_MIC); if (err < 0) return err; - snd_hda_get_input_pin_label(cfg, i, - imux->items[imux->num_items].label); - imux->items[imux->num_items].index = - ad1988_pin_to_adc_idx(cfg->inputs[i].pin); - imux->num_items++; } - strcpy(imux->items[imux->num_items].label, "Mix"); - imux->items[imux->num_items].index = 9; - imux->num_items++; + snd_hda_add_imux_item(imux, "Mix", 9, NULL); if ((err = add_control(spec, AD_CTL_WIDGET_VOL, "Analog Mix Playback Volume", @@ -3046,7 +3041,7 @@ static int ad1988_parse_auto_config(struct hda_codec *codec) "Speaker")) < 0 || (err = ad1988_auto_create_extra_out(codec, spec->autocfg.hp_pins[0], "Headphone")) < 0 || - (err = ad1988_auto_create_analog_input_ctls(spec, &spec->autocfg)) < 0) + (err = ad1988_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0) return err; spec->multiout.max_channels = spec->multiout.num_dacs * 2; diff --git a/sound/pci/hda/patch_ca0110.c b/sound/pci/hda/patch_ca0110.c index 42b3fb4..cca11fd 100644 --- a/sound/pci/hda/patch_ca0110.c +++ b/sound/pci/hda/patch_ca0110.c @@ -474,8 +474,7 @@ static void parse_input(struct hda_codec *codec) if (j >= cfg->num_inputs) continue; spec->input_pins[n] = pin; - spec->input_labels[n] = - auto_pin_cfg_labels[cfg->inputs[j].type]; + spec->input_labels[n] = hda_get_input_pin_label(codec, pin, 1); spec->adcs[n] = nid; n++; } diff --git a/sound/pci/hda/patch_cirrus.c b/sound/pci/hda/patch_cirrus.c index adb5ec5..ae75283 100644 --- a/sound/pci/hda/patch_cirrus.c +++ b/sound/pci/hda/patch_cirrus.c @@ -673,6 +673,7 @@ static int cs_capture_source_info(struct snd_kcontrol *kcontrol, { struct hda_codec *codec = snd_kcontrol_chip(kcontrol); struct cs_spec *spec = codec->spec; + struct auto_pin_cfg *cfg = &spec->autocfg; unsigned int idx; uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; @@ -681,7 +682,8 @@ static int cs_capture_source_info(struct snd_kcontrol *kcontrol, if (uinfo->value.enumerated.item >= spec->num_inputs) uinfo->value.enumerated.item = spec->num_inputs - 1; idx = spec->input_idx[uinfo->value.enumerated.item]; - strcpy(uinfo->value.enumerated.name, auto_pin_cfg_labels[idx]); + strcpy(uinfo->value.enumerated.name, + hda_get_input_pin_label(codec, cfg->inputs[idx].pin, 1)); return 0; } diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index 8ae30cc..9c2c19c 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -4947,6 +4947,7 @@ static int alc_auto_create_input_ctls(struct hda_codec *codec, for (i = 0; i < cfg->num_inputs; i++) { hda_nid_t pin; + const char *label; pin = cfg->inputs[i].pin; if (!alc_is_input_pin(codec, pin)) @@ -4957,12 +4958,13 @@ static int alc_auto_create_input_ctls(struct hda_codec *codec, type_idx++; else type_idx = 0; + label = hda_get_autocfg_input_label(codec, cfg, i); if (mixer) { idx = get_connection_index(codec, mixer, pin); if (idx >= 0) { err = new_analog_input(spec, pin, - auto_pin_cfg_labels[type], - type_idx, idx, mixer); + label, type_idx, + idx, mixer); if (err < 0) return err; } @@ -4973,12 +4975,8 @@ static int alc_auto_create_input_ctls(struct hda_codec *codec, idx = get_connection_index(codec, cap1, pin); if (idx < 0 && cap2) idx = get_connection_index(codec, cap2, pin); - if (idx >= 0) { - snd_hda_get_input_pin_label(cfg, i, - imux->items[imux->num_items].label); - imux->items[imux->num_items].index = idx; - imux->num_items++; - } + if (idx >= 0) + snd_hda_add_imux_item(imux, label, idx, NULL); } return 0; } @@ -10626,9 +10624,9 @@ static int alc_auto_add_mic_boost(struct hda_codec *codec) break; nid = cfg->inputs[i].pin; if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) { - char pinname[32], label[32]; - snd_hda_get_input_pin_label(cfg, i, pinname); - snprintf(label, sizeof(label), "%s Boost", pinname); + char label[32]; + snprintf(label, sizeof(label), "%s Boost", + hda_get_autocfg_input_label(codec, cfg, i)); err = add_control(spec, ALC_CTL_WIDGET_VOL, label, 0, HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT)); if (err < 0) diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c index d9c8b4d..e4e7d43 100644 --- a/sound/pci/hda/patch_sigmatel.c +++ b/sound/pci/hda/patch_sigmatel.c @@ -191,11 +191,6 @@ struct sigmatel_mic_route { signed char dmux_idx; }; -struct unique_input_names { - int num; - char uname[HDA_MAX_NUM_INPUTS][32]; -}; - struct sigmatel_spec { struct snd_kcontrol_new *mixers[4]; unsigned int num_mixers; @@ -312,7 +307,6 @@ struct sigmatel_spec { struct hda_input_mux private_imux; struct hda_input_mux private_smux; struct hda_input_mux private_mono_mux; - struct unique_input_names private_u_inp_names; }; static hda_nid_t stac9200_adc_nids[1] = { @@ -1116,9 +1110,7 @@ static int stac92xx_build_controls(struct hda_codec *codec) struct hda_input_mux *smux = &spec->private_smux; /* check for mute support on SPDIF out */ if (wcaps & AC_WCAP_OUT_AMP) { - strcpy(smux->items[smux->num_items].label, "Off"); - smux->items[smux->num_items].index = 0; - smux->num_items++; + snd_hda_add_imux_item(smux, "Off", 0, NULL); spec->spdif_mute = 1; } stac_smux_mixer.count = spec->num_smuxes; @@ -2797,7 +2789,7 @@ static inline int stac92xx_add_jack_mode_control(struct hda_codec *codec, } if (control) { - strcpy(name, auto_pin_cfg_labels[idx]); + strcpy(name, hda_get_input_pin_label(codec, nid, 1)); return stac92xx_add_control(codec->spec, control, strcat(name, " Jack Mode"), nid); } @@ -3267,12 +3259,9 @@ static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec) if (num_cons <= 0 || num_cons > ARRAY_SIZE(stac92xx_mono_labels)) return -EINVAL; - for (i = 0; i < num_cons; i++) { - strcpy(mono_mux->items[mono_mux->num_items].label, - stac92xx_mono_labels[i]); - mono_mux->items[mono_mux->num_items].index = i; - mono_mux->num_items++; - } + for (i = 0; i < num_cons; i++) + snd_hda_add_imux_item(mono_mux, stac92xx_mono_labels[i], i, + NULL); return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX, "Mono Mux", spec->mono_nid); @@ -3397,11 +3386,8 @@ static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec) if (!labels) labels = stac92xx_spdif_labels; - for (i = 0; i < num_cons; i++) { - strcpy(spdif_mux->items[spdif_mux->num_items].label, labels[i]); - spdif_mux->items[spdif_mux->num_items].index = i; - spdif_mux->num_items++; - } + for (i = 0; i < num_cons; i++) + snd_hda_add_imux_item(spdif_mux, labels[i], i, NULL); return 0; } @@ -3452,76 +3438,6 @@ static int create_elem_capture_vol(struct hda_codec *codec, hda_nid_t nid, return 1; } -static const char *get_input_src_label(struct hda_codec *codec, hda_nid_t nid) -{ - unsigned int def_conf; - - def_conf = snd_hda_codec_get_pincfg(codec, nid); - - switch (get_defcfg_device(def_conf)) { - case AC_JACK_MIC_IN: - if (get_defcfg_connect(def_conf) == AC_JACK_PORT_FIXED || - ((get_defcfg_location(def_conf) & 0xf0) - == AC_JACK_LOC_INTERNAL)) - return "Internal Mic"; - if ((get_defcfg_location(def_conf) & 0xf0) - == AC_JACK_LOC_SEPARATE) - return "Dock Mic"; - if (get_defcfg_location(def_conf) == AC_JACK_LOC_REAR) - return "Rear Mic"; - return "Mic"; - case AC_JACK_LINE_IN: - if ((get_defcfg_location(def_conf) & 0xf0) - == AC_JACK_LOC_SEPARATE) - return "Dock Line"; - return "Line"; - case AC_JACK_AUX: - return "Aux"; - case AC_JACK_CD: - return "CD"; - case AC_JACK_SPDIF_IN: - return "SPDIF In"; - case AC_JACK_DIG_OTHER_IN: - return "Digital In"; - } - - snd_printd("invalid inp pin %02x device config %08x", nid, def_conf); - return NULL; -} - -static const char *get_unique_inp_src_label(struct hda_codec *codec, - hda_nid_t nid) -{ - int i, n; - const char *label; - struct sigmatel_spec *spec = codec->spec; - struct hda_input_mux *imux = &spec->private_imux; - struct hda_input_mux *dimux = &spec->private_dimux; - struct unique_input_names *unames = &spec->private_u_inp_names; - - label = get_input_src_label(codec, nid); - n = 0; - - for (i = 0; i < imux->num_items; i++) { - if (!strncmp(label, imux->items[i].label, strlen(label))) - n++; - } - if (snd_hda_get_bool_hint(codec, "separate_dmux") == 1) { - for (i = 0; i < dimux->num_items; i++) { - if (!strncmp(label, dimux->items[i].label, - strlen(label))) - n++; - } - } - if (n > 0 && unames->num < HDA_MAX_NUM_INPUTS) { - sprintf(&unames->uname[unames->num][0], "%.28s %d", label, n); - label = &unames->uname[unames->num][0]; - unames->num++; - } - - return label; -} - /* create playback/capture controls for input pins on dmic capable codecs */ static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg) @@ -3532,13 +3448,11 @@ static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec, int err, i; unsigned int def_conf; - strcpy(dimux->items[dimux->num_items].label, stac92xx_dmic_labels[0]); - dimux->items[dimux->num_items].index = 0; - dimux->num_items++; + snd_hda_add_imux_item(dimux, stac92xx_dmic_labels[0], 0, NULL); for (i = 0; i < spec->num_dmics; i++) { hda_nid_t nid; - int index; + int index, type_idx; const char *label; nid = spec->dmic_nids[i]; @@ -3552,28 +3466,22 @@ static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec, if (index < 0) continue; - label = get_unique_inp_src_label(codec, nid); - if (label == NULL) - return -EINVAL; + label = hda_get_input_pin_label(codec, nid, 1); + snd_hda_add_imux_item(dimux, label, index, &type_idx); - err = create_elem_capture_vol(codec, nid, label, 0, HDA_INPUT); + err = create_elem_capture_vol(codec, nid, label, type_idx, + HDA_INPUT); if (err < 0) return err; if (!err) { - err = create_elem_capture_vol(codec, nid, label, 0, - HDA_OUTPUT); + err = create_elem_capture_vol(codec, nid, label, + type_idx, HDA_OUTPUT); if (err < 0) return err; } - strcpy(dimux->items[dimux->num_items].label, label); - dimux->items[dimux->num_items].index = index; - dimux->num_items++; - if (snd_hda_get_bool_hint(codec, "separate_dmux") != 1) { - strcpy(imux->items[imux->num_items].label, label); - imux->items[imux->num_items].index = index; - imux->num_items++; - } + if (snd_hda_get_bool_hint(codec, "separate_dmux") != 1) + snd_hda_add_imux_item(imux, label, index, NULL); } return 0; @@ -3675,12 +3583,12 @@ static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const { struct sigmatel_spec *spec = codec->spec; struct hda_input_mux *imux = &spec->private_imux; - int i, j, type_idx = 0; + int i, j; const char *label; for (i = 0; i < cfg->num_inputs; i++) { hda_nid_t nid = cfg->inputs[i].pin; - int index, err; + int index, err, type_idx; index = -1; for (j = 0; j < spec->num_muxes; j++) { @@ -3692,24 +3600,14 @@ static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const if (index < 0) continue; - if (i > 0 && cfg->inputs[i].type == cfg->inputs[i - 1].type) - type_idx++; - else - type_idx = 0; - - label = get_unique_inp_src_label(codec, nid); - if (label == NULL) - return -EINVAL; + label = hda_get_autocfg_input_label(codec, cfg, i); + snd_hda_add_imux_item(imux, label, index, &type_idx); err = create_elem_capture_vol(codec, nid, label, type_idx, HDA_INPUT); if (err < 0) return err; - - strcpy(imux->items[imux->num_items].label, label); - imux->items[imux->num_items].index = index; - imux->num_items++; } spec->num_analog_muxes = imux->num_items; diff --git a/sound/pci/hda/patch_via.c b/sound/pci/hda/patch_via.c index de5f61d..d1c3f8d 100644 --- a/sound/pci/hda/patch_via.c +++ b/sound/pci/hda/patch_via.c @@ -2374,13 +2374,8 @@ static void create_hp_imux(struct via_spec *spec) static const char *texts[] = { "OFF", "ON", NULL}; /* for hp mode select */ - i = 0; - while (texts[i] != NULL) { - strcpy(imux->items[imux->num_items].label, texts[i]); - imux->items[imux->num_items].index = i; - imux->num_items++; - i++; - } + for (i = 0; texts[i]; i++) + snd_hda_add_imux_item(imux, texts[i], i, NULL); spec->hp_mux = &spec->private_imux[1]; } @@ -2412,26 +2407,25 @@ static int vt1708_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) } /* create playback/capture controls for input pins */ -static int vt_auto_create_analog_input_ctls(struct via_spec *spec, +static int vt_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg, hda_nid_t cap_nid, hda_nid_t pin_idxs[], int num_idxs) { + struct via_spec *spec = codec->spec; struct hda_input_mux *imux = &spec->private_imux[0]; int i, err, idx, type, type_idx = 0; /* for internal loopback recording select */ for (idx = 0; idx < num_idxs; idx++) { if (pin_idxs[idx] == 0xff) { - strcpy(imux->items[imux->num_items].label, - "Stereo Mixer"); - imux->items[imux->num_items].index = idx; - imux->num_items++; + snd_hda_add_imux_item(imux, "Stereo Mixer", idx, NULL); break; } } for (i = 0; i < cfg->num_inputs; i++) { + const char *label; type = cfg->inputs[i].type; for (idx = 0; idx < num_idxs; idx++) if (pin_idxs[idx] == cfg->inputs[i].pin) @@ -2442,24 +2436,21 @@ static int vt_auto_create_analog_input_ctls(struct via_spec *spec, type_idx++; else type_idx = 0; - err = via_new_analog_input(spec, auto_pin_cfg_labels[type], - type_idx, idx, cap_nid); + label = hda_get_autocfg_input_label(codec, cfg, i); + err = via_new_analog_input(spec, label, type_idx, idx, cap_nid); if (err < 0) return err; - snd_hda_get_input_pin_label(cfg, i, - imux->items[imux->num_items].label); - imux->items[imux->num_items].index = idx; - imux->num_items++; + snd_hda_add_imux_item(imux, label, idx, NULL); } return 0; } /* create playback/capture controls for input pins */ -static int vt1708_auto_create_analog_input_ctls(struct via_spec *spec, +static int vt1708_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg) { static hda_nid_t pin_idxs[] = { 0xff, 0x24, 0x1d, 0x1e, 0x21 }; - return vt_auto_create_analog_input_ctls(spec, cfg, 0x17, pin_idxs, + return vt_auto_create_analog_input_ctls(codec, cfg, 0x17, pin_idxs, ARRAY_SIZE(pin_idxs)); } @@ -2559,7 +2550,7 @@ static int vt1708_parse_auto_config(struct hda_codec *codec) err = vt1708_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); if (err < 0) return err; - err = vt1708_auto_create_analog_input_ctls(spec, &spec->autocfg); + err = vt1708_auto_create_analog_input_ctls(codec, &spec->autocfg); if (err < 0) return err; /* add jack detect on/off control */ @@ -3026,11 +3017,11 @@ static int vt1709_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) } /* create playback/capture controls for input pins */ -static int vt1709_auto_create_analog_input_ctls(struct via_spec *spec, +static int vt1709_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg) { static hda_nid_t pin_idxs[] = { 0xff, 0x23, 0x1d, 0x1e, 0x21 }; - return vt_auto_create_analog_input_ctls(spec, cfg, 0x18, pin_idxs, + return vt_auto_create_analog_input_ctls(codec, cfg, 0x18, pin_idxs, ARRAY_SIZE(pin_idxs)); } @@ -3054,7 +3045,7 @@ static int vt1709_parse_auto_config(struct hda_codec *codec) err = vt1709_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); if (err < 0) return err; - err = vt1709_auto_create_analog_input_ctls(spec, &spec->autocfg); + err = vt1709_auto_create_analog_input_ctls(codec, &spec->autocfg); if (err < 0) return err; @@ -3556,11 +3547,11 @@ static int vt1708B_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) } /* create playback/capture controls for input pins */ -static int vt1708B_auto_create_analog_input_ctls(struct via_spec *spec, +static int vt1708B_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg) { static hda_nid_t pin_idxs[] = { 0xff, 0x1f, 0x1a, 0x1b, 0x1e }; - return vt_auto_create_analog_input_ctls(spec, cfg, 0x16, pin_idxs, + return vt_auto_create_analog_input_ctls(codec, cfg, 0x16, pin_idxs, ARRAY_SIZE(pin_idxs)); } @@ -3584,7 +3575,7 @@ static int vt1708B_parse_auto_config(struct hda_codec *codec) err = vt1708B_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); if (err < 0) return err; - err = vt1708B_auto_create_analog_input_ctls(spec, &spec->autocfg); + err = vt1708B_auto_create_analog_input_ctls(codec, &spec->autocfg); if (err < 0) return err; @@ -3992,11 +3983,11 @@ static int vt1708S_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) } /* create playback/capture controls for input pins */ -static int vt1708S_auto_create_analog_input_ctls(struct via_spec *spec, +static int vt1708S_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg) { static hda_nid_t pin_idxs[] = { 0x1f, 0x1a, 0x1b, 0x1e, 0, 0xff }; - return vt_auto_create_analog_input_ctls(spec, cfg, 0x16, pin_idxs, + return vt_auto_create_analog_input_ctls(codec, cfg, 0x16, pin_idxs, ARRAY_SIZE(pin_idxs)); } @@ -4045,7 +4036,7 @@ static int vt1708S_parse_auto_config(struct hda_codec *codec) err = vt1708S_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); if (err < 0) return err; - err = vt1708S_auto_create_analog_input_ctls(spec, &spec->autocfg); + err = vt1708S_auto_create_analog_input_ctls(codec, &spec->autocfg); if (err < 0) return err; @@ -4335,24 +4326,19 @@ static int vt1702_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) imux = &spec->private_imux[1]; /* for hp mode select */ - i = 0; - while (texts[i] != NULL) { - strcpy(imux->items[imux->num_items].label, texts[i]); - imux->items[imux->num_items].index = i; - imux->num_items++; - i++; - } + for (i = 0; texts[i]; i++) + snd_hda_add_imux_item(imux, texts[i], i, NULL); spec->hp_mux = &spec->private_imux[1]; return 0; } /* create playback/capture controls for input pins */ -static int vt1702_auto_create_analog_input_ctls(struct via_spec *spec, +static int vt1702_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg) { static hda_nid_t pin_idxs[] = { 0x14, 0x15, 0x18, 0xff }; - return vt_auto_create_analog_input_ctls(spec, cfg, 0x1a, pin_idxs, + return vt_auto_create_analog_input_ctls(codec, cfg, 0x1a, pin_idxs, ARRAY_SIZE(pin_idxs)); } @@ -4382,7 +4368,7 @@ static int vt1702_parse_auto_config(struct hda_codec *codec) (0x17 << AC_AMPCAP_NUM_STEPS_SHIFT) | (0x5 << AC_AMPCAP_STEP_SIZE_SHIFT) | (1 << AC_AMPCAP_MUTE_SHIFT)); - err = vt1702_auto_create_analog_input_ctls(spec, &spec->autocfg); + err = vt1702_auto_create_analog_input_ctls(codec, &spec->autocfg); if (err < 0) return err; @@ -4733,11 +4719,11 @@ static int vt1718S_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) } /* create playback/capture controls for input pins */ -static int vt1718S_auto_create_analog_input_ctls(struct via_spec *spec, +static int vt1718S_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg) { static hda_nid_t pin_idxs[] = { 0x2c, 0x2b, 0x2a, 0x29, 0, 0xff }; - return vt_auto_create_analog_input_ctls(spec, cfg, 0x21, pin_idxs, + return vt_auto_create_analog_input_ctls(codec, cfg, 0x21, pin_idxs, ARRAY_SIZE(pin_idxs)); } @@ -4762,7 +4748,7 @@ static int vt1718S_parse_auto_config(struct hda_codec *codec) err = vt1718S_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); if (err < 0) return err; - err = vt1718S_auto_create_analog_input_ctls(spec, &spec->autocfg); + err = vt1718S_auto_create_analog_input_ctls(codec, &spec->autocfg); if (err < 0) return err; @@ -5195,11 +5181,11 @@ static int vt1716S_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) } /* create playback/capture controls for input pins */ -static int vt1716S_auto_create_analog_input_ctls(struct via_spec *spec, +static int vt1716S_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg) { static hda_nid_t pin_idxs[] = { 0x1f, 0x1a, 0x1b, 0x1e, 0, 0xff }; - return vt_auto_create_analog_input_ctls(spec, cfg, 0x16, pin_idxs, + return vt_auto_create_analog_input_ctls(codec, cfg, 0x16, pin_idxs, ARRAY_SIZE(pin_idxs)); } @@ -5223,7 +5209,7 @@ static int vt1716S_parse_auto_config(struct hda_codec *codec) err = vt1716S_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); if (err < 0) return err; - err = vt1716S_auto_create_analog_input_ctls(spec, &spec->autocfg); + err = vt1716S_auto_create_analog_input_ctls(codec, &spec->autocfg); if (err < 0) return err; @@ -5504,14 +5490,15 @@ static int vt2002P_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) } /* create playback/capture controls for input pins */ -static int vt2002P_auto_create_analog_input_ctls(struct via_spec *spec, +static int vt2002P_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg) { + struct via_spec *spec = codec->spec; struct hda_input_mux *imux = &spec->private_imux[0]; static hda_nid_t pin_idxs[] = { 0x2b, 0x2a, 0x29, 0xff }; int err; - err = vt_auto_create_analog_input_ctls(spec, cfg, 0x21, pin_idxs, + err = vt_auto_create_analog_input_ctls(codec, cfg, 0x21, pin_idxs, ARRAY_SIZE(pin_idxs)); if (err < 0) return err; @@ -5521,9 +5508,7 @@ static int vt2002P_auto_create_analog_input_ctls(struct via_spec *spec, return err; /* for digital mic select */ - strcpy(imux->items[imux->num_items].label, "Digital Mic"); - imux->items[imux->num_items].index = 4; - imux->num_items++; + snd_hda_add_imux_item(imux, "Digital Mic", 4, NULL); return 0; } @@ -5551,7 +5536,7 @@ static int vt2002P_parse_auto_config(struct hda_codec *codec) err = vt2002P_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); if (err < 0) return err; - err = vt2002P_auto_create_analog_input_ctls(spec, &spec->autocfg); + err = vt2002P_auto_create_analog_input_ctls(codec, &spec->autocfg); if (err < 0) return err; @@ -5826,14 +5811,15 @@ static int vt1812_auto_create_hp_ctls(struct via_spec *spec, hda_nid_t pin) } /* create playback/capture controls for input pins */ -static int vt1812_auto_create_analog_input_ctls(struct via_spec *spec, +static int vt1812_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg) { + struct via_spec *spec = codec->spec; struct hda_input_mux *imux = &spec->private_imux[0]; static hda_nid_t pin_idxs[] = { 0x2b, 0x2a, 0x29, 0, 0, 0xff }; int err; - err = vt_auto_create_analog_input_ctls(spec, cfg, 0x21, pin_idxs, + err = vt_auto_create_analog_input_ctls(codec, cfg, 0x21, pin_idxs, ARRAY_SIZE(pin_idxs)); if (err < 0) return err; @@ -5844,9 +5830,7 @@ static int vt1812_auto_create_analog_input_ctls(struct via_spec *spec, return err; /* for digital mic select */ - strcpy(imux->items[imux->num_items].label, "Digital Mic"); - imux->items[imux->num_items].index = 6; - imux->num_items++; + snd_hda_add_imux_item(imux, "Digital Mic", 6, NULL); return 0; } @@ -5874,7 +5858,7 @@ static int vt1812_parse_auto_config(struct hda_codec *codec) err = vt1812_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]); if (err < 0) return err; - err = vt1812_auto_create_analog_input_ctls(spec, &spec->autocfg); + err = vt1812_auto_create_analog_input_ctls(codec, &spec->autocfg); if (err < 0) return err; -- cgit v1.1 From a1c985158382cbce0b58b3264f771b3b153668a6 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Thu, 9 Sep 2010 21:36:27 +0200 Subject: ALSA: hda - Reduce redundant mic location prefix in input source labels When the mic pins are assigned to the same location, we can omit the redundant location prefix like "Front" or "Rear". Signed-off-by: Takashi Iwai --- sound/pci/hda/hda_codec.c | 90 ++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 77 insertions(+), 13 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c index e328434..affb460 100644 --- a/sound/pci/hda/hda_codec.c +++ b/sound/pci/hda/hda_codec.c @@ -4618,32 +4618,64 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec, } EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config); +enum { + MIC_ATTR_INT, + MIC_ATTR_DOCK, + MIC_ATTR_NORMAL, + MIC_ATTR_FRONT, + MIC_ATTR_REAR, +}; + +static int get_mic_pin_attr(unsigned int def_conf) +{ + unsigned int loc = get_defcfg_location(def_conf); + if (get_defcfg_connect(def_conf) == AC_JACK_PORT_FIXED || + (loc & 0x30) == AC_JACK_LOC_INTERNAL) + return MIC_ATTR_INT; + if ((loc & 0x30) == AC_JACK_LOC_SEPARATE) + return MIC_ATTR_DOCK; + if (loc == AC_JACK_LOC_REAR) + return MIC_ATTR_REAR; + if (loc == AC_JACK_LOC_FRONT) + return MIC_ATTR_FRONT; + return MIC_ATTR_NORMAL; +} + +enum { + LINE_ATTR_DOCK, + LINE_ATTR_NORMAL, +}; + +static int get_line_pin_attr(unsigned int def_conf) +{ + unsigned int loc = get_defcfg_location(def_conf); + if ((loc & 0xf0) == AC_JACK_LOC_SEPARATE) + return LINE_ATTR_DOCK; + return LINE_ATTR_NORMAL; +} + const char *hda_get_input_pin_label(struct hda_codec *codec, hda_nid_t pin, int check_location) { - unsigned int def_conf, loc; + unsigned int def_conf; + static const char *mic_names[] = { + "Internal Mic", "Dock Mic", "Mic", "Front Mic", "Rear Mic", + }; + static const char *line_names[] = { + "Dock Line", "Line", + }; def_conf = snd_hda_codec_get_pincfg(codec, pin); - loc = get_defcfg_location(def_conf); switch (get_defcfg_device(def_conf)) { case AC_JACK_MIC_IN: if (!check_location) return "Mic"; - if (get_defcfg_connect(def_conf) == AC_JACK_PORT_FIXED || - (loc & 0x30) == AC_JACK_LOC_INTERNAL) - return "Internal Mic"; - if ((loc & 0x30) == AC_JACK_LOC_SEPARATE) - return "Dock Mic"; - if (loc == AC_JACK_LOC_REAR) - return "Rear Mic"; - return "Mic"; + return mic_names[get_mic_pin_attr(def_conf)]; case AC_JACK_LINE_IN: if (!check_location) return "Line"; - if ((loc & 0xf0) == AC_JACK_LOC_SEPARATE) - return "Dock Line"; - return "Line"; + return line_names[get_line_pin_attr(def_conf)]; case AC_JACK_AUX: return "Aux"; case AC_JACK_CD: @@ -4658,6 +4690,36 @@ const char *hda_get_input_pin_label(struct hda_codec *codec, hda_nid_t pin, } EXPORT_SYMBOL_HDA(hda_get_input_pin_label); +/* Check whether the location prefix needs to be added to the label. + * If all mic-jacks are in the same location (e.g. rear panel), we don't + * have to put "Front" prefix to each label. In such a case, returns false. + */ +static int check_mic_location_need(struct hda_codec *codec, + const struct auto_pin_cfg *cfg, + int input) +{ + unsigned int defc; + int i, attr, attr2; + + defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[input].pin); + attr = get_mic_pin_attr(defc); + /* for internal or docking mics, we need locations */ + if (attr <= MIC_ATTR_NORMAL) + return 1; + + attr = 0; + for (i = 0; i < cfg->num_inputs; i++) { + defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[i].pin); + attr2 = get_mic_pin_attr(defc); + if (attr2 >= MIC_ATTR_NORMAL) { + if (attr && attr != attr2) + return 1; /* different locations found */ + attr = attr2; + } + } + return 0; +} + const char *hda_get_autocfg_input_label(struct hda_codec *codec, const struct auto_pin_cfg *cfg, int input) @@ -4668,6 +4730,8 @@ const char *hda_get_autocfg_input_label(struct hda_codec *codec, if ((input > 0 && cfg->inputs[input - 1].type == type) || (input < cfg->num_inputs - 1 && cfg->inputs[input + 1].type == type)) has_multiple_pins = 1; + if (has_multiple_pins && type == AUTO_PIN_MIC) + has_multiple_pins &= check_mic_location_need(codec, cfg, input); return hda_get_input_pin_label(codec, cfg->inputs[input].pin, has_multiple_pins); } -- cgit v1.1 From 990061c28ab6c84e1120afb772b69d92d8965da8 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Thu, 9 Sep 2010 22:08:44 +0200 Subject: ALSA: hda - Add comments to new helper functions Signed-off-by: Takashi Iwai --- sound/pci/hda/hda_codec.c | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) (limited to 'sound') diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c index affb460..ec38bdf 100644 --- a/sound/pci/hda/hda_codec.c +++ b/sound/pci/hda/hda_codec.c @@ -4654,6 +4654,14 @@ static int get_line_pin_attr(unsigned int def_conf) return LINE_ATTR_NORMAL; } +/** + * hda_get_input_pin_label - Give a label for the given input pin + * + * When check_location is true, the function checks the pin location + * for mic and line-in pins, and set an appropriate prefix like "Front", + * "Rear", "Internal". + */ + const char *hda_get_input_pin_label(struct hda_codec *codec, hda_nid_t pin, int check_location) { @@ -4720,6 +4728,14 @@ static int check_mic_location_need(struct hda_codec *codec, return 0; } +/** + * hda_get_autocfg_input_label - Get a label for the given input + * + * Get a label for the given input pin defined by the autocfg item. + * Unlike hda_get_input_pin_label(), this function checks all inputs + * defined in autocfg and avoids the redundant mic/line prefix as much as + * possible. + */ const char *hda_get_autocfg_input_label(struct hda_codec *codec, const struct auto_pin_cfg *cfg, int input) @@ -4737,6 +4753,13 @@ const char *hda_get_autocfg_input_label(struct hda_codec *codec, } EXPORT_SYMBOL_HDA(hda_get_autocfg_input_label); +/** + * snd_hda_add_imux_item - Add an item to input_mux + * + * When the same label is used already in the existing items, the number + * suffix is appended to the label. This label index number is stored + * to type_idx when non-NULL pointer is given. + */ int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label, int index, int *type_idx) { -- cgit v1.1 From 4a4d4a6985dd37a3c96534027f054be796bf95f6 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Thu, 9 Sep 2010 22:22:02 +0200 Subject: ALSA: hda - Sort input pins in snd_hda_parse_pin_def_config() Sort inputs[] array in autocfg so that the codec parsers can filter out easily per input pin types. Signed-off-by: Takashi Iwai --- sound/pci/hda/hda_codec.c | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) (limited to 'sound') diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c index ec38bdf..08d81b8 100644 --- a/sound/pci/hda/hda_codec.c +++ b/sound/pci/hda/hda_codec.c @@ -4383,6 +4383,23 @@ static void add_auto_cfg_input_pin(struct auto_pin_cfg *cfg, hda_nid_t nid, } } +/* sort inputs in the order of AUTO_PIN_* type */ +static void sort_autocfg_input_pins(struct auto_pin_cfg *cfg) +{ + int i, j; + + for (i = 0; i < cfg->num_inputs; i++) { + for (j = i + 1; j < cfg->num_inputs; j++) { + if (cfg->inputs[i].type > cfg->inputs[j].type) { + struct auto_pin_cfg_item tmp; + tmp = cfg->inputs[i]; + cfg->inputs[i] = cfg->inputs[j]; + cfg->inputs[j] = tmp; + } + } + } +} + /* * Parse all pin widgets and store the useful pin nids to cfg * @@ -4585,6 +4602,8 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec, break; } + sort_autocfg_input_pins(cfg); + /* * debug prints of the parsed results */ -- cgit v1.1 From 6008fd5aa4c15f2ea80a9f997983a9cbfa14ba73 Mon Sep 17 00:00:00 2001 From: Daniel Mack Date: Fri, 10 Sep 2010 16:12:34 +0800 Subject: ALSA: snd-usb-caiaq: drop version number Let git do the job. Signed-off-by: Daniel Mack Signed-off-by: Takashi Iwai --- sound/usb/caiaq/device.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/usb/caiaq/device.c b/sound/usb/caiaq/device.c index cdfb856..da9cb6d 100644 --- a/sound/usb/caiaq/device.c +++ b/sound/usb/caiaq/device.c @@ -36,7 +36,7 @@ #include "input.h" MODULE_AUTHOR("Daniel Mack "); -MODULE_DESCRIPTION("caiaq USB audio, version 1.3.21"); +MODULE_DESCRIPTION("caiaq USB audio"); MODULE_LICENSE("GPL"); MODULE_SUPPORTED_DEVICE("{{Native Instruments, RigKontrol2}," "{Native Instruments, RigKontrol3}," -- cgit v1.1 From 15c5ab607045e278ebf4d2ca4aea2250617d50ca Mon Sep 17 00:00:00 2001 From: Daniel Mack Date: Fri, 10 Sep 2010 17:04:57 +0800 Subject: ALSA: snd-usb-caiaq: Add support for Traktor Kontrol S4 This patch adds support for the new Traktor Kontrol S4 by Native Instruments. It features a new audio data streaming model, MIDI in and out ports, a huge number of 174 dimmable LEDs, 96 buttons and 46 absolute encoder axis, including some rotary encoders. All features are supported by the driver now. Did some code refactoring along the way. Signed-off-by: Daniel Mack Signed-off-by: Takashi Iwai --- sound/usb/Kconfig | 2 + sound/usb/caiaq/audio.c | 175 +++++++++++++++++++++++++++++--- sound/usb/caiaq/control.c | 208 +++++++++++++++++++++++++++++++++++++- sound/usb/caiaq/device.c | 8 +- sound/usb/caiaq/device.h | 6 +- sound/usb/caiaq/input.c | 248 +++++++++++++++++++++++++++++++++++++++++----- 6 files changed, 598 insertions(+), 49 deletions(-) (limited to 'sound') diff --git a/sound/usb/Kconfig b/sound/usb/Kconfig index 44d6d2e..112984f 100644 --- a/sound/usb/Kconfig +++ b/sound/usb/Kconfig @@ -65,6 +65,7 @@ config SND_USB_CAIAQ * Native Instruments Guitar Rig Session I/O * Native Instruments Guitar Rig mobile * Native Instruments Traktor Kontrol X1 + * Native Instruments Traktor Kontrol S4 To compile this driver as a module, choose M here: the module will be called snd-usb-caiaq. @@ -82,6 +83,7 @@ config SND_USB_CAIAQ_INPUT * Native Instruments Kore Controller * Native Instruments Kore Controller 2 * Native Instruments Audio Kontrol 1 + * Native Instruments Traktor Kontrol S4 config SND_USB_US122L tristate "Tascam US-122L USB driver" diff --git a/sound/usb/caiaq/audio.c b/sound/usb/caiaq/audio.c index 4328cad..68b9747 100644 --- a/sound/usb/caiaq/audio.c +++ b/sound/usb/caiaq/audio.c @@ -111,7 +111,7 @@ static int stream_start(struct snd_usb_caiaqdev *dev) memset(dev->sub_capture, 0, sizeof(dev->sub_capture)); dev->input_panic = 0; dev->output_panic = 0; - dev->first_packet = 1; + dev->first_packet = 4; dev->streaming = 1; dev->warned = 0; @@ -169,7 +169,7 @@ static int snd_usb_caiaq_substream_close(struct snd_pcm_substream *substream) } static int snd_usb_caiaq_pcm_hw_params(struct snd_pcm_substream *sub, - struct snd_pcm_hw_params *hw_params) + struct snd_pcm_hw_params *hw_params) { debug("%s(%p)\n", __func__, sub); return snd_pcm_lib_malloc_pages(sub, params_buffer_bytes(hw_params)); @@ -189,7 +189,7 @@ static int snd_usb_caiaq_pcm_hw_free(struct snd_pcm_substream *sub) #endif static unsigned int rates[] = { 5512, 8000, 11025, 16000, 22050, 32000, 44100, - 48000, 64000, 88200, 96000, 176400, 192000 }; + 48000, 64000, 88200, 96000, 176400, 192000 }; static int snd_usb_caiaq_pcm_prepare(struct snd_pcm_substream *substream) { @@ -201,12 +201,39 @@ static int snd_usb_caiaq_pcm_prepare(struct snd_pcm_substream *substream) debug("%s(%p)\n", __func__, substream); if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { - dev->period_out_count[index] = BYTES_PER_SAMPLE + 1; - dev->audio_out_buf_pos[index] = BYTES_PER_SAMPLE + 1; + int out_pos; + + switch (dev->spec.data_alignment) { + case 0: + case 2: + out_pos = BYTES_PER_SAMPLE + 1; + break; + case 3: + default: + out_pos = 0; + break; + } + + dev->period_out_count[index] = out_pos; + dev->audio_out_buf_pos[index] = out_pos; } else { - int in_pos = (dev->spec.data_alignment == 2) ? 0 : 2; - dev->period_in_count[index] = BYTES_PER_SAMPLE + in_pos; - dev->audio_in_buf_pos[index] = BYTES_PER_SAMPLE + in_pos; + int in_pos; + + switch (dev->spec.data_alignment) { + case 0: + in_pos = BYTES_PER_SAMPLE + 2; + break; + case 2: + in_pos = BYTES_PER_SAMPLE; + break; + case 3: + default: + in_pos = 0; + break; + } + + dev->period_in_count[index] = in_pos; + dev->audio_in_buf_pos[index] = in_pos; } if (dev->streaming) @@ -221,7 +248,7 @@ static int snd_usb_caiaq_pcm_prepare(struct snd_pcm_substream *substream) snd_pcm_limit_hw_rates(runtime); bytes_per_sample = BYTES_PER_SAMPLE; - if (dev->spec.data_alignment == 2) + if (dev->spec.data_alignment >= 2) bytes_per_sample++; bpp = ((runtime->rate / 8000) + CLOCK_DRIFT_TOLERANCE) @@ -253,6 +280,8 @@ static int snd_usb_caiaq_pcm_trigger(struct snd_pcm_substream *sub, int cmd) { struct snd_usb_caiaqdev *dev = snd_pcm_substream_chip(sub); + debug("%s(%p) cmd %d\n", __func__, sub, cmd); + switch (cmd) { case SNDRV_PCM_TRIGGER_START: case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: @@ -402,6 +431,61 @@ static void read_in_urb_mode2(struct snd_usb_caiaqdev *dev, } } +static void read_in_urb_mode3(struct snd_usb_caiaqdev *dev, + const struct urb *urb, + const struct usb_iso_packet_descriptor *iso) +{ + unsigned char *usb_buf = urb->transfer_buffer + iso->offset; + int stream, i; + + /* paranoia check */ + if (iso->actual_length % (BYTES_PER_SAMPLE_USB * CHANNELS_PER_STREAM)) + return; + + for (i = 0; i < iso->actual_length;) { + for (stream = 0; stream < dev->n_streams; stream++) { + struct snd_pcm_substream *sub = dev->sub_capture[stream]; + char *audio_buf = NULL; + int c, n, sz = 0; + + if (sub && !dev->input_panic) { + struct snd_pcm_runtime *rt = sub->runtime; + audio_buf = rt->dma_area; + sz = frames_to_bytes(rt, rt->buffer_size); + } + + for (c = 0; c < CHANNELS_PER_STREAM; c++) { + /* 3 audio data bytes, followed by 1 check byte */ + if (audio_buf) { + for (n = 0; n < BYTES_PER_SAMPLE; n++) { + audio_buf[dev->audio_in_buf_pos[stream]++] = usb_buf[i+n]; + + if (dev->audio_in_buf_pos[stream] == sz) + dev->audio_in_buf_pos[stream] = 0; + } + + dev->period_in_count[stream] += BYTES_PER_SAMPLE; + } + + i += BYTES_PER_SAMPLE; + + if (usb_buf[i] != ((stream << 1) | c) && + !dev->first_packet) { + if (!dev->input_panic) + printk(" EXPECTED: %02x got %02x, c %d, stream %d, i %d\n", + ((stream << 1) | c), usb_buf[i], c, stream, i); + dev->input_panic = 1; + } + + i++; + } + } + } + + if (dev->first_packet > 0) + dev->first_packet--; +} + static void read_in_urb(struct snd_usb_caiaqdev *dev, const struct urb *urb, const struct usb_iso_packet_descriptor *iso) @@ -419,6 +503,9 @@ static void read_in_urb(struct snd_usb_caiaqdev *dev, case 2: read_in_urb_mode2(dev, urb, iso); break; + case 3: + read_in_urb_mode3(dev, urb, iso); + break; } if ((dev->input_panic || dev->output_panic) && !dev->warned) { @@ -429,9 +516,9 @@ static void read_in_urb(struct snd_usb_caiaqdev *dev, } } -static void fill_out_urb(struct snd_usb_caiaqdev *dev, - struct urb *urb, - const struct usb_iso_packet_descriptor *iso) +static void fill_out_urb_mode_0(struct snd_usb_caiaqdev *dev, + struct urb *urb, + const struct usb_iso_packet_descriptor *iso) { unsigned char *usb_buf = urb->transfer_buffer + iso->offset; struct snd_pcm_substream *sub; @@ -457,9 +544,67 @@ static void fill_out_urb(struct snd_usb_caiaqdev *dev, /* fill in the check bytes */ if (dev->spec.data_alignment == 2 && i % (dev->n_streams * BYTES_PER_SAMPLE_USB) == - (dev->n_streams * CHANNELS_PER_STREAM)) - for (stream = 0; stream < dev->n_streams; stream++, i++) - usb_buf[i] = MAKE_CHECKBYTE(dev, stream, i); + (dev->n_streams * CHANNELS_PER_STREAM)) + for (stream = 0; stream < dev->n_streams; stream++, i++) + usb_buf[i] = MAKE_CHECKBYTE(dev, stream, i); + } +} + +static void fill_out_urb_mode_3(struct snd_usb_caiaqdev *dev, + struct urb *urb, + const struct usb_iso_packet_descriptor *iso) +{ + unsigned char *usb_buf = urb->transfer_buffer + iso->offset; + int stream, i; + + for (i = 0; i < iso->length;) { + for (stream = 0; stream < dev->n_streams; stream++) { + struct snd_pcm_substream *sub = dev->sub_playback[stream]; + char *audio_buf = NULL; + int c, n, sz = 0; + + if (sub) { + struct snd_pcm_runtime *rt = sub->runtime; + audio_buf = rt->dma_area; + sz = frames_to_bytes(rt, rt->buffer_size); + } + + for (c = 0; c < CHANNELS_PER_STREAM; c++) { + for (n = 0; n < BYTES_PER_SAMPLE; n++) { + if (audio_buf) { + usb_buf[i+n] = audio_buf[dev->audio_out_buf_pos[stream]++]; + + if (dev->audio_out_buf_pos[stream] == sz) + dev->audio_out_buf_pos[stream] = 0; + } else { + usb_buf[i+n] = 0; + } + } + + if (audio_buf) + dev->period_out_count[stream] += BYTES_PER_SAMPLE; + + i += BYTES_PER_SAMPLE; + + /* fill in the check byte pattern */ + usb_buf[i++] = (stream << 1) | c; + } + } + } +} + +static inline void fill_out_urb(struct snd_usb_caiaqdev *dev, + struct urb *urb, + const struct usb_iso_packet_descriptor *iso) +{ + switch (dev->spec.data_alignment) { + case 0: + case 2: + fill_out_urb_mode_0(dev, urb, iso); + break; + case 3: + fill_out_urb_mode_3(dev, urb, iso); + break; } } diff --git a/sound/usb/caiaq/control.c b/sound/usb/caiaq/control.c index 91c804c..00e5d0a 100644 --- a/sound/usb/caiaq/control.c +++ b/sound/usb/caiaq/control.c @@ -55,6 +55,10 @@ static int control_info(struct snd_kcontrol *kcontrol, case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1): maxval = 127; break; + + case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4): + maxval = 31; + break; } if (is_intval) { @@ -93,6 +97,7 @@ static int control_put(struct snd_kcontrol *kcontrol, struct snd_usb_audio *chip = snd_kcontrol_chip(kcontrol); struct snd_usb_caiaqdev *dev = caiaqdev(chip->card); int pos = kcontrol->private_value; + int v = ucontrol->value.integer.value[0]; unsigned char cmd = EP1_CMD_WRITE_IO; if (dev->chip.usb_id == @@ -100,12 +105,27 @@ static int control_put(struct snd_kcontrol *kcontrol, cmd = EP1_CMD_DIMM_LEDS; if (pos & CNT_INTVAL) { - dev->control_state[pos & ~CNT_INTVAL] - = ucontrol->value.integer.value[0]; - snd_usb_caiaq_send_command(dev, cmd, - dev->control_state, sizeof(dev->control_state)); + int i = pos & ~CNT_INTVAL; + + dev->control_state[i] = v; + + if (dev->chip.usb_id == + USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4)) { + int actual_len; + + dev->ep8_out_buf[0] = i; + dev->ep8_out_buf[1] = v; + + usb_bulk_msg(dev->chip.dev, + usb_sndbulkpipe(dev->chip.dev, 8), + dev->ep8_out_buf, sizeof(dev->ep8_out_buf), + &actual_len, 200); + } else { + snd_usb_caiaq_send_command(dev, cmd, + dev->control_state, sizeof(dev->control_state)); + } } else { - if (ucontrol->value.integer.value[0]) + if (v) dev->control_state[pos / 8] |= 1 << (pos % 8); else dev->control_state[pos / 8] &= ~(1 << (pos % 8)); @@ -296,6 +316,179 @@ static struct caiaq_controller kontrolx1_controller[] = { { "LED Deck B: SYNC", 8 | CNT_INTVAL }, }; +static struct caiaq_controller kontrols4_controller[] = { + { "LED: Master: Quant", 10 | CNT_INTVAL }, + { "LED: Master: Headphone", 11 | CNT_INTVAL }, + { "LED: Master: Master", 12 | CNT_INTVAL }, + { "LED: Master: Snap", 14 | CNT_INTVAL }, + { "LED: Master: Warning", 15 | CNT_INTVAL }, + { "LED: Master: Master button", 112 | CNT_INTVAL }, + { "LED: Master: Snap button", 113 | CNT_INTVAL }, + { "LED: Master: Rec", 118 | CNT_INTVAL }, + { "LED: Master: Size", 119 | CNT_INTVAL }, + { "LED: Master: Quant button", 120 | CNT_INTVAL }, + { "LED: Master: Browser button", 121 | CNT_INTVAL }, + { "LED: Master: Play button", 126 | CNT_INTVAL }, + { "LED: Master: Undo button", 127 | CNT_INTVAL }, + + { "LED: Channel A: >", 4 | CNT_INTVAL }, + { "LED: Channel A: <", 5 | CNT_INTVAL }, + { "LED: Channel A: Meter 1", 97 | CNT_INTVAL }, + { "LED: Channel A: Meter 2", 98 | CNT_INTVAL }, + { "LED: Channel A: Meter 3", 99 | CNT_INTVAL }, + { "LED: Channel A: Meter 4", 100 | CNT_INTVAL }, + { "LED: Channel A: Meter 5", 101 | CNT_INTVAL }, + { "LED: Channel A: Meter 6", 102 | CNT_INTVAL }, + { "LED: Channel A: Meter clip", 103 | CNT_INTVAL }, + { "LED: Channel A: Active", 114 | CNT_INTVAL }, + { "LED: Channel A: Cue", 116 | CNT_INTVAL }, + { "LED: Channel A: FX1", 149 | CNT_INTVAL }, + { "LED: Channel A: FX2", 148 | CNT_INTVAL }, + + { "LED: Channel B: >", 2 | CNT_INTVAL }, + { "LED: Channel B: <", 3 | CNT_INTVAL }, + { "LED: Channel B: Meter 1", 89 | CNT_INTVAL }, + { "LED: Channel B: Meter 2", 90 | CNT_INTVAL }, + { "LED: Channel B: Meter 3", 91 | CNT_INTVAL }, + { "LED: Channel B: Meter 4", 92 | CNT_INTVAL }, + { "LED: Channel B: Meter 5", 93 | CNT_INTVAL }, + { "LED: Channel B: Meter 6", 94 | CNT_INTVAL }, + { "LED: Channel B: Meter clip", 95 | CNT_INTVAL }, + { "LED: Channel B: Active", 122 | CNT_INTVAL }, + { "LED: Channel B: Cue", 125 | CNT_INTVAL }, + { "LED: Channel B: FX1", 147 | CNT_INTVAL }, + { "LED: Channel B: FX2", 146 | CNT_INTVAL }, + + { "LED: Channel C: >", 6 | CNT_INTVAL }, + { "LED: Channel C: <", 7 | CNT_INTVAL }, + { "LED: Channel C: Meter 1", 105 | CNT_INTVAL }, + { "LED: Channel C: Meter 2", 106 | CNT_INTVAL }, + { "LED: Channel C: Meter 3", 107 | CNT_INTVAL }, + { "LED: Channel C: Meter 4", 108 | CNT_INTVAL }, + { "LED: Channel C: Meter 5", 109 | CNT_INTVAL }, + { "LED: Channel C: Meter 6", 110 | CNT_INTVAL }, + { "LED: Channel C: Meter clip", 111 | CNT_INTVAL }, + { "LED: Channel C: Active", 115 | CNT_INTVAL }, + { "LED: Channel C: Cue", 117 | CNT_INTVAL }, + { "LED: Channel C: FX1", 151 | CNT_INTVAL }, + { "LED: Channel C: FX2", 150 | CNT_INTVAL }, + + { "LED: Channel D: >", 0 | CNT_INTVAL }, + { "LED: Channel D: <", 1 | CNT_INTVAL }, + { "LED: Channel D: Meter 1", 81 | CNT_INTVAL }, + { "LED: Channel D: Meter 2", 82 | CNT_INTVAL }, + { "LED: Channel D: Meter 3", 83 | CNT_INTVAL }, + { "LED: Channel D: Meter 4", 84 | CNT_INTVAL }, + { "LED: Channel D: Meter 5", 85 | CNT_INTVAL }, + { "LED: Channel D: Meter 6", 86 | CNT_INTVAL }, + { "LED: Channel D: Meter clip", 87 | CNT_INTVAL }, + { "LED: Channel D: Active", 123 | CNT_INTVAL }, + { "LED: Channel D: Cue", 124 | CNT_INTVAL }, + { "LED: Channel D: FX1", 145 | CNT_INTVAL }, + { "LED: Channel D: FX2", 144 | CNT_INTVAL }, + + { "LED: Deck A: 1 (blue)", 22 | CNT_INTVAL }, + { "LED: Deck A: 1 (green)", 23 | CNT_INTVAL }, + { "LED: Deck A: 2 (blue)", 20 | CNT_INTVAL }, + { "LED: Deck A: 2 (green)", 21 | CNT_INTVAL }, + { "LED: Deck A: 3 (blue)", 18 | CNT_INTVAL }, + { "LED: Deck A: 3 (green)", 19 | CNT_INTVAL }, + { "LED: Deck A: 4 (blue)", 16 | CNT_INTVAL }, + { "LED: Deck A: 4 (green)", 17 | CNT_INTVAL }, + { "LED: Deck A: Load", 44 | CNT_INTVAL }, + { "LED: Deck A: Deck C button", 45 | CNT_INTVAL }, + { "LED: Deck A: In", 47 | CNT_INTVAL }, + { "LED: Deck A: Out", 46 | CNT_INTVAL }, + { "LED: Deck A: Shift", 24 | CNT_INTVAL }, + { "LED: Deck A: Sync", 27 | CNT_INTVAL }, + { "LED: Deck A: Cue", 26 | CNT_INTVAL }, + { "LED: Deck A: Play", 25 | CNT_INTVAL }, + { "LED: Deck A: Tempo up", 33 | CNT_INTVAL }, + { "LED: Deck A: Tempo down", 32 | CNT_INTVAL }, + { "LED: Deck A: Master", 34 | CNT_INTVAL }, + { "LED: Deck A: Keylock", 35 | CNT_INTVAL }, + { "LED: Deck A: Deck A", 37 | CNT_INTVAL }, + { "LED: Deck A: Deck C", 36 | CNT_INTVAL }, + { "LED: Deck A: Samples", 38 | CNT_INTVAL }, + { "LED: Deck A: On Air", 39 | CNT_INTVAL }, + { "LED: Deck A: Sample 1", 31 | CNT_INTVAL }, + { "LED: Deck A: Sample 2", 30 | CNT_INTVAL }, + { "LED: Deck A: Sample 3", 29 | CNT_INTVAL }, + { "LED: Deck A: Sample 4", 28 | CNT_INTVAL }, + { "LED: Deck A: Digit 1 - A", 55 | CNT_INTVAL }, + { "LED: Deck A: Digit 1 - B", 54 | CNT_INTVAL }, + { "LED: Deck A: Digit 1 - C", 53 | CNT_INTVAL }, + { "LED: Deck A: Digit 1 - D", 52 | CNT_INTVAL }, + { "LED: Deck A: Digit 1 - E", 51 | CNT_INTVAL }, + { "LED: Deck A: Digit 1 - F", 50 | CNT_INTVAL }, + { "LED: Deck A: Digit 1 - G", 49 | CNT_INTVAL }, + { "LED: Deck A: Digit 1 - dot", 48 | CNT_INTVAL }, + { "LED: Deck A: Digit 2 - A", 63 | CNT_INTVAL }, + { "LED: Deck A: Digit 2 - B", 62 | CNT_INTVAL }, + { "LED: Deck A: Digit 2 - C", 61 | CNT_INTVAL }, + { "LED: Deck A: Digit 2 - D", 60 | CNT_INTVAL }, + { "LED: Deck A: Digit 2 - E", 59 | CNT_INTVAL }, + { "LED: Deck A: Digit 2 - F", 58 | CNT_INTVAL }, + { "LED: Deck A: Digit 2 - G", 57 | CNT_INTVAL }, + { "LED: Deck A: Digit 2 - dot", 56 | CNT_INTVAL }, + + { "LED: Deck B: 1 (blue)", 78 | CNT_INTVAL }, + { "LED: Deck B: 1 (green)", 79 | CNT_INTVAL }, + { "LED: Deck B: 2 (blue)", 76 | CNT_INTVAL }, + { "LED: Deck B: 2 (green)", 77 | CNT_INTVAL }, + { "LED: Deck B: 3 (blue)", 74 | CNT_INTVAL }, + { "LED: Deck B: 3 (green)", 75 | CNT_INTVAL }, + { "LED: Deck B: 4 (blue)", 72 | CNT_INTVAL }, + { "LED: Deck B: 4 (green)", 73 | CNT_INTVAL }, + { "LED: Deck B: Load", 180 | CNT_INTVAL }, + { "LED: Deck B: Deck D button", 181 | CNT_INTVAL }, + { "LED: Deck B: In", 183 | CNT_INTVAL }, + { "LED: Deck B: Out", 182 | CNT_INTVAL }, + { "LED: Deck B: Shift", 64 | CNT_INTVAL }, + { "LED: Deck B: Sync", 67 | CNT_INTVAL }, + { "LED: Deck B: Cue", 66 | CNT_INTVAL }, + { "LED: Deck B: Play", 65 | CNT_INTVAL }, + { "LED: Deck B: Tempo up", 185 | CNT_INTVAL }, + { "LED: Deck B: Tempo down", 184 | CNT_INTVAL }, + { "LED: Deck B: Master", 186 | CNT_INTVAL }, + { "LED: Deck B: Keylock", 187 | CNT_INTVAL }, + { "LED: Deck B: Deck B", 189 | CNT_INTVAL }, + { "LED: Deck B: Deck D", 188 | CNT_INTVAL }, + { "LED: Deck B: Samples", 190 | CNT_INTVAL }, + { "LED: Deck B: On Air", 191 | CNT_INTVAL }, + { "LED: Deck B: Sample 1", 71 | CNT_INTVAL }, + { "LED: Deck B: Sample 2", 70 | CNT_INTVAL }, + { "LED: Deck B: Sample 3", 69 | CNT_INTVAL }, + { "LED: Deck B: Sample 4", 68 | CNT_INTVAL }, + { "LED: Deck B: Digit 1 - A", 175 | CNT_INTVAL }, + { "LED: Deck B: Digit 1 - B", 174 | CNT_INTVAL }, + { "LED: Deck B: Digit 1 - C", 173 | CNT_INTVAL }, + { "LED: Deck B: Digit 1 - D", 172 | CNT_INTVAL }, + { "LED: Deck B: Digit 1 - E", 171 | CNT_INTVAL }, + { "LED: Deck B: Digit 1 - F", 170 | CNT_INTVAL }, + { "LED: Deck B: Digit 1 - G", 169 | CNT_INTVAL }, + { "LED: Deck B: Digit 1 - dot", 168 | CNT_INTVAL }, + { "LED: Deck B: Digit 2 - A", 167 | CNT_INTVAL }, + { "LED: Deck B: Digit 2 - B", 166 | CNT_INTVAL }, + { "LED: Deck B: Digit 2 - C", 165 | CNT_INTVAL }, + { "LED: Deck B: Digit 2 - D", 164 | CNT_INTVAL }, + { "LED: Deck B: Digit 2 - E", 163 | CNT_INTVAL }, + { "LED: Deck B: Digit 2 - F", 162 | CNT_INTVAL }, + { "LED: Deck B: Digit 2 - G", 161 | CNT_INTVAL }, + { "LED: Deck B: Digit 2 - dot", 160 | CNT_INTVAL }, + + { "LED: FX1: dry/wet", 153 | CNT_INTVAL }, + { "LED: FX1: 1", 154 | CNT_INTVAL }, + { "LED: FX1: 2", 155 | CNT_INTVAL }, + { "LED: FX1: 3", 156 | CNT_INTVAL }, + { "LED: FX1: Mode", 157 | CNT_INTVAL }, + { "LED: FX2: dry/wet", 129 | CNT_INTVAL }, + { "LED: FX2: 1", 130 | CNT_INTVAL }, + { "LED: FX2: 2", 131 | CNT_INTVAL }, + { "LED: FX2: 3", 132 | CNT_INTVAL }, + { "LED: FX2: Mode", 133 | CNT_INTVAL }, +}; + static int __devinit add_controls(struct caiaq_controller *c, int num, struct snd_usb_caiaqdev *dev) { @@ -354,6 +547,11 @@ int __devinit snd_usb_caiaq_control_init(struct snd_usb_caiaqdev *dev) ret = add_controls(kontrolx1_controller, ARRAY_SIZE(kontrolx1_controller), dev); break; + + case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4): + ret = add_controls(kontrols4_controller, + ARRAY_SIZE(kontrols4_controller), dev); + break; } return ret; diff --git a/sound/usb/caiaq/device.c b/sound/usb/caiaq/device.c index da9cb6d..6480c32 100644 --- a/sound/usb/caiaq/device.c +++ b/sound/usb/caiaq/device.c @@ -48,7 +48,8 @@ MODULE_SUPPORTED_DEVICE("{{Native Instruments, RigKontrol2}," "{Native Instruments, Audio 8 DJ}," "{Native Instruments, Session I/O}," "{Native Instruments, GuitarRig mobile}" - "{Native Instruments, Traktor Kontrol X1}"); + "{Native Instruments, Traktor Kontrol X1}" + "{Native Instruments, Traktor Kontrol S4}"); static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-max */ static char* id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* Id for this card */ @@ -134,6 +135,11 @@ static struct usb_device_id snd_usb_id_table[] = { .idVendor = USB_VID_NATIVEINSTRUMENTS, .idProduct = USB_PID_TRAKTORKONTROLX1 }, + { + .match_flags = USB_DEVICE_ID_MATCH_DEVICE, + .idVendor = USB_VID_NATIVEINSTRUMENTS, + .idProduct = USB_PID_TRAKTORKONTROLS4 + }, { /* terminator */ } }; diff --git a/sound/usb/caiaq/device.h b/sound/usb/caiaq/device.h index f1117ec..e3d8a3e 100644 --- a/sound/usb/caiaq/device.h +++ b/sound/usb/caiaq/device.h @@ -16,6 +16,7 @@ #define USB_PID_SESSIONIO 0x1915 #define USB_PID_GUITARRIGMOBILE 0x0d8d #define USB_PID_TRAKTORKONTROLX1 0x2305 +#define USB_PID_TRAKTORKONTROLS4 0xbaff #define EP1_BUFSIZE 64 #define EP4_BUFSIZE 512 @@ -99,13 +100,14 @@ struct snd_usb_caiaqdev { struct snd_pcm_substream *sub_capture[MAX_STREAMS]; /* Controls */ - unsigned char control_state[64]; + unsigned char control_state[256]; + unsigned char ep8_out_buf[2]; /* Linux input */ #ifdef CONFIG_SND_USB_CAIAQ_INPUT struct input_dev *input_dev; char phys[64]; /* physical device path */ - unsigned short keycode[64]; + unsigned short keycode[128]; struct urb *ep4_in_urb; unsigned char ep4_in_buf[EP4_BUFSIZE]; #endif diff --git a/sound/usb/caiaq/input.c b/sound/usb/caiaq/input.c index dcb6207..4432ef7 100644 --- a/sound/usb/caiaq/input.c +++ b/sound/usb/caiaq/input.c @@ -67,7 +67,12 @@ static unsigned short keycode_kore[] = { KEY_BRL_DOT5 }; -#define KONTROLX1_INPUTS 40 +#define KONTROLX1_INPUTS (40) +#define KONTROLS4_BUTTONS (12 * 8) +#define KONTROLS4_AXIS (46) + +#define KONTROLS4_BUTTON(X) ((X) + BTN_MISC) +#define KONTROLS4_ABS(X) ((X) + ABS_HAT0X) #define DEG90 (range / 2) #define DEG180 (range) @@ -139,6 +144,13 @@ static unsigned int decode_erp(unsigned char a, unsigned char b) #undef HIGH_PEAK #undef LOW_PEAK +static inline void snd_caiaq_input_report_abs(struct snd_usb_caiaqdev *dev, + int axis, const unsigned char *buf, + int offset) +{ + input_report_abs(dev->input_dev, axis, + (buf[offset * 2] << 8) | buf[offset * 2 + 1]); +} static void snd_caiaq_input_read_analog(struct snd_usb_caiaqdev *dev, const unsigned char *buf, @@ -148,36 +160,30 @@ static void snd_caiaq_input_read_analog(struct snd_usb_caiaqdev *dev, switch (dev->chip.usb_id) { case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL2): - input_report_abs(input_dev, ABS_X, (buf[4] << 8) | buf[5]); - input_report_abs(input_dev, ABS_Y, (buf[0] << 8) | buf[1]); - input_report_abs(input_dev, ABS_Z, (buf[2] << 8) | buf[3]); - input_sync(input_dev); + snd_caiaq_input_report_abs(dev, ABS_X, buf, 2); + snd_caiaq_input_report_abs(dev, ABS_Y, buf, 0); + snd_caiaq_input_report_abs(dev, ABS_Z, buf, 1); break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL3): - input_report_abs(input_dev, ABS_X, (buf[0] << 8) | buf[1]); - input_report_abs(input_dev, ABS_Y, (buf[2] << 8) | buf[3]); - input_report_abs(input_dev, ABS_Z, (buf[4] << 8) | buf[5]); - input_sync(input_dev); - break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER): case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER2): - input_report_abs(input_dev, ABS_X, (buf[0] << 8) | buf[1]); - input_report_abs(input_dev, ABS_Y, (buf[2] << 8) | buf[3]); - input_report_abs(input_dev, ABS_Z, (buf[4] << 8) | buf[5]); - input_sync(input_dev); + snd_caiaq_input_report_abs(dev, ABS_X, buf, 0); + snd_caiaq_input_report_abs(dev, ABS_Y, buf, 1); + snd_caiaq_input_report_abs(dev, ABS_Z, buf, 2); break; case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1): - input_report_abs(input_dev, ABS_HAT0X, (buf[8] << 8) | buf[9]); - input_report_abs(input_dev, ABS_HAT0Y, (buf[4] << 8) | buf[5]); - input_report_abs(input_dev, ABS_HAT1X, (buf[12] << 8) | buf[13]); - input_report_abs(input_dev, ABS_HAT1Y, (buf[2] << 8) | buf[3]); - input_report_abs(input_dev, ABS_HAT2X, (buf[14] << 8) | buf[15]); - input_report_abs(input_dev, ABS_HAT2Y, (buf[0] << 8) | buf[1]); - input_report_abs(input_dev, ABS_HAT3X, (buf[10] << 8) | buf[11]); - input_report_abs(input_dev, ABS_HAT3Y, (buf[6] << 8) | buf[7]); - input_sync(input_dev); + snd_caiaq_input_report_abs(dev, ABS_HAT0X, buf, 4); + snd_caiaq_input_report_abs(dev, ABS_HAT0Y, buf, 2); + snd_caiaq_input_report_abs(dev, ABS_HAT1X, buf, 6); + snd_caiaq_input_report_abs(dev, ABS_HAT1Y, buf, 1); + snd_caiaq_input_report_abs(dev, ABS_HAT2X, buf, 7); + snd_caiaq_input_report_abs(dev, ABS_HAT2Y, buf, 0); + snd_caiaq_input_report_abs(dev, ABS_HAT3X, buf, 5); + snd_caiaq_input_report_abs(dev, ABS_HAT3Y, buf, 3); break; } + + input_sync(input_dev); } static void snd_caiaq_input_read_erp(struct snd_usb_caiaqdev *dev, @@ -250,6 +256,150 @@ static void snd_caiaq_input_read_io(struct snd_usb_caiaqdev *dev, input_sync(input_dev); } +#define TKS4_MSGBLOCK_SIZE 16 + +static void snd_usb_caiaq_tks4_dispatch(struct snd_usb_caiaqdev *dev, + const unsigned char *buf, + unsigned int len) +{ + while (len) { + unsigned int i, block_id = (buf[0] << 8) | buf[1]; + + switch (block_id) { + case 0: + /* buttons */ + for (i = 0; i < KONTROLS4_BUTTONS; i++) + input_report_key(dev->input_dev, KONTROLS4_BUTTON(i), + (buf[4 + (i / 8)] >> (i % 8)) & 1); + break; + + case 1: + /* left wheel */ + input_report_abs(dev->input_dev, KONTROLS4_ABS(36), buf[9] | ((buf[8] & 0x3) << 8)); + /* right wheel */ + input_report_abs(dev->input_dev, KONTROLS4_ABS(37), buf[13] | ((buf[12] & 0x3) << 8)); + + /* rotary encoders */ + input_report_abs(dev->input_dev, KONTROLS4_ABS(38), buf[3] & 0xf); + input_report_abs(dev->input_dev, KONTROLS4_ABS(39), buf[4] >> 4); + input_report_abs(dev->input_dev, KONTROLS4_ABS(40), buf[4] & 0xf); + input_report_abs(dev->input_dev, KONTROLS4_ABS(41), buf[5] >> 4); + input_report_abs(dev->input_dev, KONTROLS4_ABS(42), buf[5] & 0xf); + input_report_abs(dev->input_dev, KONTROLS4_ABS(43), buf[6] >> 4); + input_report_abs(dev->input_dev, KONTROLS4_ABS(44), buf[6] & 0xf); + input_report_abs(dev->input_dev, KONTROLS4_ABS(45), buf[7] >> 4); + input_report_abs(dev->input_dev, KONTROLS4_ABS(46), buf[7] & 0xf); + + break; + case 2: + /* Volume Fader Channel D */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(0), buf, 1); + /* Volume Fader Channel B */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(1), buf, 2); + /* Volume Fader Channel A */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(2), buf, 3); + /* Volume Fader Channel C */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(3), buf, 4); + /* Loop Volume */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(4), buf, 6); + /* Crossfader */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(7), buf, 7); + + break; + + case 3: + /* Tempo Fader R */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(6), buf, 3); + /* Tempo Fader L */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(5), buf, 4); + /* Mic Volume */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(8), buf, 6); + /* Cue Mix */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(9), buf, 7); + + break; + + case 4: + /* Wheel distance sensor L */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(10), buf, 1); + /* Wheel distance sensor R */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(11), buf, 2); + /* Channel D EQ - Filter */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(12), buf, 3); + /* Channel D EQ - Low */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(13), buf, 4); + /* Channel D EQ - Mid */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(14), buf, 5); + /* Channel D EQ - Hi */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(15), buf, 6); + /* FX2 - dry/wet */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(16), buf, 7); + + break; + + case 5: + /* FX2 - 1 */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(17), buf, 1); + /* FX2 - 2 */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(18), buf, 2); + /* FX2 - 3 */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(19), buf, 3); + /* Channel B EQ - Filter */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(20), buf, 4); + /* Channel B EQ - Low */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(21), buf, 5); + /* Channel B EQ - Mid */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(22), buf, 6); + /* Channel B EQ - Hi */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(23), buf, 7); + + break; + + case 6: + /* Channel A EQ - Filter */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(24), buf, 1); + /* Channel A EQ - Low */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(25), buf, 2); + /* Channel A EQ - Mid */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(26), buf, 3); + /* Channel A EQ - Hi */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(27), buf, 4); + /* Channel C EQ - Filter */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(28), buf, 5); + /* Channel C EQ - Low */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(29), buf, 6); + /* Channel C EQ - Mid */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(30), buf, 7); + + break; + + case 7: + /* Channel C EQ - Hi */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(31), buf, 1); + /* FX1 - wet/dry */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(32), buf, 2); + /* FX1 - 1 */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(33), buf, 3); + /* FX1 - 2 */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(34), buf, 4); + /* FX1 - 3 */ + snd_caiaq_input_report_abs(dev, KONTROLS4_ABS(35), buf, 5); + + break; + + default: + debug("%s(): bogus block (id %d)\n", + __func__, block_id); + return; + } + + len -= TKS4_MSGBLOCK_SIZE; + buf += TKS4_MSGBLOCK_SIZE; + } + + input_sync(dev->input_dev); +} + static void snd_usb_caiaq_ep4_reply_dispatch(struct urb *urb) { struct snd_usb_caiaqdev *dev = urb->context; @@ -259,11 +409,11 @@ static void snd_usb_caiaq_ep4_reply_dispatch(struct urb *urb) if (urb->status || !dev || urb != dev->ep4_in_urb) return; - if (urb->actual_length < 24) - goto requeue; - switch (dev->chip.usb_id) { case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1): + if (urb->actual_length < 24) + goto requeue; + if (buf[0] & 0x3) snd_caiaq_input_read_io(dev, buf + 1, 7); @@ -271,6 +421,10 @@ static void snd_usb_caiaq_ep4_reply_dispatch(struct urb *urb) snd_caiaq_input_read_analog(dev, buf + 8, 16); break; + + case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4): + snd_usb_caiaq_tks4_dispatch(dev, buf, urb->actual_length); + break; } requeue: @@ -289,6 +443,7 @@ static int snd_usb_caiaq_input_open(struct input_dev *idev) switch (dev->chip.usb_id) { case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1): + case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4): if (usb_submit_urb(dev->ep4_in_urb, GFP_KERNEL) != 0) return -EIO; break; @@ -306,6 +461,7 @@ static void snd_usb_caiaq_input_close(struct input_dev *idev) switch (dev->chip.usb_id) { case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1): + case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4): usb_kill_urb(dev->ep4_in_urb); break; } @@ -456,6 +612,46 @@ int snd_usb_caiaq_input_init(struct snd_usb_caiaqdev *dev) snd_usb_caiaq_set_auto_msg(dev, 1, 10, 5); break; + + case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4): + input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); + BUILD_BUG_ON(sizeof(dev->keycode) < KONTROLS4_BUTTONS); + for (i = 0; i < KONTROLS4_BUTTONS; i++) + dev->keycode[i] = KONTROLS4_BUTTON(i); + input->keycodemax = KONTROLS4_BUTTONS; + + for (i = 0; i < KONTROLS4_AXIS; i++) { + int axis = KONTROLS4_ABS(i); + input->absbit[BIT_WORD(axis)] |= BIT_MASK(axis); + } + + /* 36 analog potentiometers and faders */ + for (i = 0; i < 36; i++) + input_set_abs_params(input, KONTROLS4_ABS(i), 0, 0xfff, 0, 10); + + /* 2 encoder wheels */ + input_set_abs_params(input, KONTROLS4_ABS(36), 0, 0x3ff, 0, 1); + input_set_abs_params(input, KONTROLS4_ABS(37), 0, 0x3ff, 0, 1); + + /* 9 rotary encoders */ + for (i = 0; i < 9; i++) + input_set_abs_params(input, KONTROLS4_ABS(38+i), 0, 0xf, 0, 1); + + dev->ep4_in_urb = usb_alloc_urb(0, GFP_KERNEL); + if (!dev->ep4_in_urb) { + ret = -ENOMEM; + goto exit_free_idev; + } + + usb_fill_bulk_urb(dev->ep4_in_urb, usb_dev, + usb_rcvbulkpipe(usb_dev, 0x4), + dev->ep4_in_buf, EP4_BUFSIZE, + snd_usb_caiaq_ep4_reply_dispatch, dev); + + snd_usb_caiaq_set_auto_msg(dev, 1, 10, 5); + + break; + default: /* no input methods supported on this device */ goto exit_free_idev; -- cgit v1.1 From cea310e8f8702226f982f09386cfd3c5793c5e2f Mon Sep 17 00:00:00 2001 From: Seth Heasley Date: Fri, 10 Sep 2010 16:29:56 -0700 Subject: ALSA: hda_intel: ALSA HD Audio patch for Intel Patsburg DeviceIDs This patch adds the Intel Patsburg (PCH) HD Audio Controller DeviceIDs. Signed-off-by: Seth Heasley Signed-off-by: Takashi Iwai --- sound/pci/hda/hda_intel.c | 3 +++ 1 file changed, 3 insertions(+) (limited to 'sound') diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c index 1053fff..34940a0 100644 --- a/sound/pci/hda/hda_intel.c +++ b/sound/pci/hda/hda_intel.c @@ -126,6 +126,7 @@ MODULE_SUPPORTED_DEVICE("{{Intel, ICH6}," "{Intel, ICH10}," "{Intel, PCH}," "{Intel, CPT}," + "{Intel, PBG}," "{Intel, SCH}," "{ATI, SB450}," "{ATI, SB600}," @@ -2749,6 +2750,8 @@ static DEFINE_PCI_DEVICE_TABLE(azx_ids) = { { PCI_DEVICE(0x8086, 0x3b57), .driver_data = AZX_DRIVER_ICH }, /* CPT */ { PCI_DEVICE(0x8086, 0x1c20), .driver_data = AZX_DRIVER_PCH }, + /* PBG */ + { PCI_DEVICE(0x8086, 0x1d20), .driver_data = AZX_DRIVER_PCH }, /* SCH */ { PCI_DEVICE(0x8086, 0x811b), .driver_data = AZX_DRIVER_SCH }, /* ATI SB 450/600 */ -- cgit v1.1 From 2ca9cac965e81da4b74f2dcec4b87ebfd106b357 Mon Sep 17 00:00:00 2001 From: Anisse Astier Date: Fri, 10 Sep 2010 15:47:55 +0200 Subject: ALSA: hda - Add quirk for Toshiba C650D using a Conexant CX20585 Add a quirk for laptop Toshiba Satellite C650D to have proper external HP and external Mic support. Signed-off-by: Anisse Astier Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_conexant.c | 1 + 1 file changed, 1 insertion(+) (limited to 'sound') diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c index 71f9d64..972e7c4 100644 --- a/sound/pci/hda/patch_conexant.c +++ b/sound/pci/hda/patch_conexant.c @@ -3092,6 +3092,7 @@ static struct snd_pci_quirk cxt5066_cfg_tbl[] = { SND_PCI_QUIRK(0x1028, 0x0402, "Dell Vostro", CXT5066_DELL_VOSTO), SND_PCI_QUIRK(0x1028, 0x0408, "Dell Inspiron One 19T", CXT5066_IDEAPAD), SND_PCI_QUIRK(0x103c, 0x360b, "HP G60", CXT5066_HP_LAPTOP), + SND_PCI_QUIRK(0x1179, 0xff1e, "Toshiba Satellite C650D", CXT5066_IDEAPAD), SND_PCI_QUIRK(0x1179, 0xff50, "Toshiba Satellite P500-PSPGSC-01800T", CXT5066_OLPC_XO_1_5), SND_PCI_QUIRK(0x1179, 0xffe0, "Toshiba Satellite Pro T130-15F", CXT5066_OLPC_XO_1_5), SND_PCI_QUIRK(0x17aa, 0x20f2, "Lenovo T400s", CXT5066_THINKPAD), -- cgit v1.1 From 147fcf1c211f1a87bf4d0711b7e9637f3d6ce080 Mon Sep 17 00:00:00 2001 From: Joe Perches Date: Sat, 11 Sep 2010 22:10:59 -0700 Subject: sound: Remove pr_ uses of KERN_ Signed-off-by: Joe Perches Acked-by: Mark Brown Acked-by: Geoff Levand Signed-off-by: Takashi Iwai --- sound/ppc/snd_ps3.c | 2 +- sound/soc/s3c24xx/s3c-dma.c | 3 +-- 2 files changed, 2 insertions(+), 3 deletions(-) (limited to 'sound') diff --git a/sound/ppc/snd_ps3.c b/sound/ppc/snd_ps3.c index 2f12da4..581a670 100644 --- a/sound/ppc/snd_ps3.c +++ b/sound/ppc/snd_ps3.c @@ -579,7 +579,7 @@ static int snd_ps3_delay_to_bytes(struct snd_pcm_substream *substream, rate * delay_ms / 1000) * substream->runtime->channels; - pr_debug(KERN_ERR "%s: time=%d rate=%d bytes=%ld, frames=%d, ret=%d\n", + pr_debug("%s: time=%d rate=%d bytes=%ld, frames=%d, ret=%d\n", __func__, delay_ms, rate, diff --git a/sound/soc/s3c24xx/s3c-dma.c b/sound/soc/s3c24xx/s3c-dma.c index 1b61c23..f1b1bc4 100644 --- a/sound/soc/s3c24xx/s3c-dma.c +++ b/sound/soc/s3c24xx/s3c-dma.c @@ -94,8 +94,7 @@ static void s3c_dma_enqueue(struct snd_pcm_substream *substream) if ((pos + len) > prtd->dma_end) { len = prtd->dma_end - pos; - pr_debug(KERN_DEBUG "%s: corrected dma len %ld\n", - __func__, len); + pr_debug("%s: corrected dma len %ld\n", __func__, len); } ret = s3c2410_dma_enqueue(prtd->params->channel, -- cgit v1.1 From 47023ec774b6f73bb11d9f3b00b21f2bbd87e0f2 Mon Sep 17 00:00:00 2001 From: Joe Perches Date: Mon, 13 Sep 2010 21:24:02 -0700 Subject: sound: Use static const char * const where possible Signed-off-by: Joe Perches Signed-off-by: Takashi Iwai --- sound/core/pcm_native.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c index e2e7389..eb40942 100644 --- a/sound/core/pcm_native.c +++ b/sound/core/pcm_native.c @@ -142,7 +142,7 @@ int snd_pcm_info_user(struct snd_pcm_substream *substream, #ifdef RULES_DEBUG #define HW_PARAM(v) [SNDRV_PCM_HW_PARAM_##v] = #v -char *snd_pcm_hw_param_names[] = { +static const char * const snd_pcm_hw_param_names[] = { HW_PARAM(ACCESS), HW_PARAM(FORMAT), HW_PARAM(SUBFORMAT), -- cgit v1.1 From a254dba37c5a372fc8b44ba29509ba052d4e859d Mon Sep 17 00:00:00 2001 From: Ben Hutchings Date: Sun, 12 Sep 2010 02:41:47 +0100 Subject: ALSA: emux: Add trivial compat ioctl handler Reported-by: Carmen Cru Signed-off-by: Ben Hutchings Signed-off-by: Takashi Iwai --- sound/synth/emux/emux_hwdep.c | 3 +++ 1 file changed, 3 insertions(+) (limited to 'sound') diff --git a/sound/synth/emux/emux_hwdep.c b/sound/synth/emux/emux_hwdep.c index ff0b2a8..5ae1eae 100644 --- a/sound/synth/emux/emux_hwdep.c +++ b/sound/synth/emux/emux_hwdep.c @@ -128,6 +128,9 @@ snd_emux_init_hwdep(struct snd_emux *emu) strcpy(hw->name, SNDRV_EMUX_HWDEP_NAME); hw->iface = SNDRV_HWDEP_IFACE_EMUX_WAVETABLE; hw->ops.ioctl = snd_emux_hwdep_ioctl; + /* The ioctl parameter types are compatible between 32- and + * 64-bit architectures, so use the same function. */ + hw->ops.ioctl_compat = snd_emux_hwdep_ioctl; hw->exclusive = 1; hw->private_data = emu; if ((err = snd_card_register(emu->card)) < 0) -- cgit v1.1 From 7b6c3a34e93aafc5dd9adc7dee87c7fa61d8bdbb Mon Sep 17 00:00:00 2001 From: Andreas Schwab Date: Sat, 11 Sep 2010 13:16:41 +0200 Subject: ALSA: sound/ppc/powermac: remove undefined operations Modifying an object twice without an intervening sequence point is undefined. Signed-off-by: Andreas Schwab Signed-off-by: Takashi Iwai --- sound/ppc/tumbler.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/ppc/tumbler.c b/sound/ppc/tumbler.c index 20afdf9..961d982 100644 --- a/sound/ppc/tumbler.c +++ b/sound/ppc/tumbler.c @@ -785,7 +785,7 @@ static int snapper_set_capture_source(struct pmac_tumbler *mix) if (! mix->i2c.client) return -ENODEV; if (mix->capture_source) - mix->acs = mix->acs |= 2; + mix->acs |= 2; else mix->acs &= ~2; return i2c_smbus_write_byte_data(mix->i2c.client, TAS_REG_ACS, mix->acs); -- cgit v1.1 From 645ef9ef1fc0ff70456495b1e21d3420b7b08541 Mon Sep 17 00:00:00 2001 From: Arnd Bergmann Date: Tue, 14 Sep 2010 21:53:41 +0200 Subject: sound: autoconvert trivial BKL users to private mutex The usage of the BKL in the OSS sound drivers is trivial, and each of them only locks against itself, so it can be turned into per-driver mutexes. This is the script that was used for the conversion: file=$1 name=$2 if grep -q lock_kernel ${file} ; then if grep -q 'include.*linux.mutex.h' ${file} ; then sed -i '/include.*/d' ${file} else sed -i 's/include.*.*$/include /g' ${file} fi sed -i ${file} \ -e "/^#include.*linux.mutex.h/,$ { 1,/^\(static\|int\|long\)/ { /^\(static\|int\|long\)/istatic DEFINE_MUTEX(${name}_mutex); } }" \ -e "s/\(un\)*lock_kernel\>[ ]*()/mutex_\1lock(\&${name}_mutex)/g" \ -e '/[ ]*cycle_kernel_lock();/d' else sed -i -e '/include.*\/d' ${file} \ -e '/cycle_kernel_lock()/d' fi Signed-off-by: Arnd Bergmann Signed-off-by: Takashi Iwai --- sound/oss/au1550_ac97.c | 30 ++++++++++++++-------------- sound/oss/dmasound/dmasound_core.c | 41 +++++++++++++++++++------------------- sound/oss/msnd_pinnacle.c | 15 +++++++------- sound/oss/sh_dac_audio.c | 13 ++++++------ sound/oss/soundcard.c | 41 +++++++++++++++++++------------------- sound/oss/swarm_cs4297a.c | 20 +++++++++---------- sound/oss/vwsnd.c | 30 ++++++++++++++-------------- 7 files changed, 97 insertions(+), 93 deletions(-) (limited to 'sound') diff --git a/sound/oss/au1550_ac97.c b/sound/oss/au1550_ac97.c index 8a12621..a8f626d 100644 --- a/sound/oss/au1550_ac97.c +++ b/sound/oss/au1550_ac97.c @@ -43,7 +43,6 @@ #include #include #include -#include #include #include #include @@ -77,6 +76,7 @@ /* Boot options * 0 = no VRA, 1 = use VRA if codec supports it */ +static DEFINE_MUTEX(au1550_ac97_mutex); static int vra = 1; module_param(vra, bool, 0); MODULE_PARM_DESC(vra, "if 1 use VRA if codec supports it"); @@ -798,9 +798,9 @@ au1550_llseek(struct file *file, loff_t offset, int origin) static int au1550_open_mixdev(struct inode *inode, struct file *file) { - lock_kernel(); + mutex_lock(&au1550_ac97_mutex); file->private_data = &au1550_state; - unlock_kernel(); + mutex_unlock(&au1550_ac97_mutex); return 0; } @@ -824,9 +824,9 @@ au1550_ioctl_mixdev(struct file *file, unsigned int cmd, unsigned long arg) struct ac97_codec *codec = s->codec; int ret; - lock_kernel(); + mutex_lock(&au1550_ac97_mutex); ret = mixdev_ioctl(codec, cmd, arg); - unlock_kernel(); + mutex_unlock(&au1550_ac97_mutex); return ret; } @@ -1255,7 +1255,7 @@ au1550_mmap(struct file *file, struct vm_area_struct *vma) unsigned long size; int ret = 0; - lock_kernel(); + mutex_lock(&au1550_ac97_mutex); mutex_lock(&s->sem); if (vma->vm_flags & VM_WRITE) db = &s->dma_dac; @@ -1283,7 +1283,7 @@ au1550_mmap(struct file *file, struct vm_area_struct *vma) db->mapped = 1; out: mutex_unlock(&s->sem); - unlock_kernel(); + mutex_unlock(&au1550_ac97_mutex); return ret; } @@ -1781,9 +1781,9 @@ au1550_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg) { int ret; - lock_kernel(); + mutex_lock(&au1550_ac97_mutex); ret = au1550_ioctl(file, cmd, arg); - unlock_kernel(); + mutex_unlock(&au1550_ac97_mutex); return ret; } @@ -1804,7 +1804,7 @@ au1550_open(struct inode *inode, struct file *file) #endif file->private_data = s; - lock_kernel(); + mutex_lock(&au1550_ac97_mutex); /* wait for device to become free */ mutex_lock(&s->open_mutex); while (s->open_mode & file->f_mode) { @@ -1861,7 +1861,7 @@ au1550_open(struct inode *inode, struct file *file) out: mutex_unlock(&s->open_mutex); out2: - unlock_kernel(); + mutex_unlock(&au1550_ac97_mutex); return ret; } @@ -1870,12 +1870,12 @@ au1550_release(struct inode *inode, struct file *file) { struct au1550_state *s = file->private_data; - lock_kernel(); + mutex_lock(&au1550_ac97_mutex); if (file->f_mode & FMODE_WRITE) { - unlock_kernel(); + mutex_unlock(&au1550_ac97_mutex); drain_dac(s, file->f_flags & O_NONBLOCK); - lock_kernel(); + mutex_lock(&au1550_ac97_mutex); } mutex_lock(&s->open_mutex); @@ -1892,7 +1892,7 @@ au1550_release(struct inode *inode, struct file *file) s->open_mode &= ((~file->f_mode) & (FMODE_READ|FMODE_WRITE)); mutex_unlock(&s->open_mutex); wake_up(&s->open_wait); - unlock_kernel(); + mutex_unlock(&au1550_ac97_mutex); return 0; } diff --git a/sound/oss/dmasound/dmasound_core.c b/sound/oss/dmasound/dmasound_core.c index 6ecd41a..87e2c72 100644 --- a/sound/oss/dmasound/dmasound_core.c +++ b/sound/oss/dmasound/dmasound_core.c @@ -181,7 +181,7 @@ #include #include #include -#include +#include #include @@ -194,6 +194,7 @@ * Declarations */ +static DEFINE_MUTEX(dmasound_core_mutex); int dmasound_catchRadius = 0; module_param(dmasound_catchRadius, int, 0); @@ -323,22 +324,22 @@ static struct { static int mixer_open(struct inode *inode, struct file *file) { - lock_kernel(); + mutex_lock(&dmasound_core_mutex); if (!try_module_get(dmasound.mach.owner)) { - unlock_kernel(); + mutex_unlock(&dmasound_core_mutex); return -ENODEV; } mixer.busy = 1; - unlock_kernel(); + mutex_unlock(&dmasound_core_mutex); return 0; } static int mixer_release(struct inode *inode, struct file *file) { - lock_kernel(); + mutex_lock(&dmasound_core_mutex); mixer.busy = 0; module_put(dmasound.mach.owner); - unlock_kernel(); + mutex_unlock(&dmasound_core_mutex); return 0; } @@ -370,9 +371,9 @@ static long mixer_unlocked_ioctl(struct file *file, u_int cmd, u_long arg) { int ret; - lock_kernel(); + mutex_lock(&dmasound_core_mutex); ret = mixer_ioctl(file, cmd, arg); - unlock_kernel(); + mutex_unlock(&dmasound_core_mutex); return ret; } @@ -752,9 +753,9 @@ static int sq_open(struct inode *inode, struct file *file) { int rc; - lock_kernel(); + mutex_lock(&dmasound_core_mutex); if (!try_module_get(dmasound.mach.owner)) { - unlock_kernel(); + mutex_unlock(&dmasound_core_mutex); return -ENODEV; } @@ -799,11 +800,11 @@ static int sq_open(struct inode *inode, struct file *file) sound_set_format(AFMT_MU_LAW); } #endif - unlock_kernel(); + mutex_unlock(&dmasound_core_mutex); return 0; out: module_put(dmasound.mach.owner); - unlock_kernel(); + mutex_unlock(&dmasound_core_mutex); return rc; } @@ -869,7 +870,7 @@ static int sq_release(struct inode *inode, struct file *file) { int rc = 0; - lock_kernel(); + mutex_lock(&dmasound_core_mutex); if (file->f_mode & FMODE_WRITE) { if (write_sq.busy) @@ -900,7 +901,7 @@ static int sq_release(struct inode *inode, struct file *file) write_sq_wake_up(file); /* checks f_mode */ #endif /* blocking open() */ - unlock_kernel(); + mutex_unlock(&dmasound_core_mutex); return rc; } @@ -1141,9 +1142,9 @@ static long sq_unlocked_ioctl(struct file *file, u_int cmd, u_long arg) { int ret; - lock_kernel(); + mutex_lock(&dmasound_core_mutex); ret = sq_ioctl(file, cmd, arg); - unlock_kernel(); + mutex_unlock(&dmasound_core_mutex); return ret; } @@ -1257,7 +1258,7 @@ static int state_open(struct inode *inode, struct file *file) int len = 0; int ret; - lock_kernel(); + mutex_lock(&dmasound_core_mutex); ret = -EBUSY; if (state.busy) goto out; @@ -1329,16 +1330,16 @@ printk("dmasound: stat buffer used %d bytes\n", len) ; state.len = len; ret = 0; out: - unlock_kernel(); + mutex_unlock(&dmasound_core_mutex); return ret; } static int state_release(struct inode *inode, struct file *file) { - lock_kernel(); + mutex_lock(&dmasound_core_mutex); state.busy = 0; module_put(dmasound.mach.owner); - unlock_kernel(); + mutex_unlock(&dmasound_core_mutex); return 0; } diff --git a/sound/oss/msnd_pinnacle.c b/sound/oss/msnd_pinnacle.c index 2e48b17..b4c1eb5 100644 --- a/sound/oss/msnd_pinnacle.c +++ b/sound/oss/msnd_pinnacle.c @@ -39,7 +39,7 @@ #include #include #include -#include +#include #include #include #include @@ -79,6 +79,7 @@ dev.rec_sample_rate / \ dev.rec_channels) +static DEFINE_MUTEX(msnd_pinnacle_mutex); static multisound_dev_t dev; #ifndef HAVE_DSPCODEH @@ -651,12 +652,12 @@ static long dev_ioctl(struct file *file, unsigned int cmd, unsigned long arg) ret = -EINVAL; - lock_kernel(); + mutex_lock(&msnd_pinnacle_mutex); if (minor == dev.dsp_minor) ret = dsp_ioctl(file, cmd, arg); else if (minor == dev.mixer_minor) ret = mixer_ioctl(cmd, arg); - unlock_kernel(); + mutex_unlock(&msnd_pinnacle_mutex); return ret; } @@ -761,7 +762,7 @@ static int dev_open(struct inode *inode, struct file *file) int minor = iminor(inode); int err = 0; - lock_kernel(); + mutex_lock(&msnd_pinnacle_mutex); if (minor == dev.dsp_minor) { if ((file->f_mode & FMODE_WRITE && test_bit(F_AUDIO_WRITE_INUSE, &dev.flags)) || @@ -791,7 +792,7 @@ static int dev_open(struct inode *inode, struct file *file) } else err = -EINVAL; out: - unlock_kernel(); + mutex_unlock(&msnd_pinnacle_mutex); return err; } @@ -800,14 +801,14 @@ static int dev_release(struct inode *inode, struct file *file) int minor = iminor(inode); int err = 0; - lock_kernel(); + mutex_lock(&msnd_pinnacle_mutex); if (minor == dev.dsp_minor) err = dsp_release(file); else if (minor == dev.mixer_minor) { /* nothing */ } else err = -EINVAL; - unlock_kernel(); + mutex_unlock(&msnd_pinnacle_mutex); return err; } diff --git a/sound/oss/sh_dac_audio.c b/sound/oss/sh_dac_audio.c index 479e302..53bba16b 100644 --- a/sound/oss/sh_dac_audio.c +++ b/sound/oss/sh_dac_audio.c @@ -16,7 +16,7 @@ #include #include #include -#include +#include #include #include #include @@ -34,6 +34,7 @@ #define BUFFER_SIZE 48000 +static DEFINE_MUTEX(sh_dac_audio_mutex); static int rate; static int empty; static char *data_buffer, *buffer_begin, *buffer_end; @@ -163,9 +164,9 @@ static long dac_audio_unlocked_ioctl(struct file *file, u_int cmd, u_long arg) { int ret; - lock_kernel(); + mutex_lock(&sh_dac_audio_mutex); ret = dac_audio_ioctl(file, cmd, arg); - unlock_kernel(); + mutex_unlock(&sh_dac_audio_mutex); return ret; } @@ -229,16 +230,16 @@ static int dac_audio_open(struct inode *inode, struct file *file) if (file->f_mode & FMODE_READ) return -ENODEV; - lock_kernel(); + mutex_lock(&sh_dac_audio_mutex); if (in_use) { - unlock_kernel(); + mutex_unlock(&sh_dac_audio_mutex); return -EBUSY; } in_use = 1; dac_audio_start(); - unlock_kernel(); + mutex_unlock(&sh_dac_audio_mutex); return 0; } diff --git a/sound/oss/soundcard.c b/sound/oss/soundcard.c index 92aa762..938ed94 100644 --- a/sound/oss/soundcard.c +++ b/sound/oss/soundcard.c @@ -40,7 +40,7 @@ #include #include #include -#include +#include #include #include #include @@ -56,6 +56,7 @@ * Table for permanently allocated memory (used when unloading the module) */ void * sound_mem_blocks[MAX_MEM_BLOCKS]; +static DEFINE_MUTEX(soundcard_mutex); int sound_nblocks = 0; /* Persistent DMA buffers */ @@ -151,7 +152,7 @@ static ssize_t sound_read(struct file *file, char __user *buf, size_t count, lof * big one anyway, we might as well bandage here.. */ - lock_kernel(); + mutex_lock(&soundcard_mutex); DEB(printk("sound_read(dev=%d, count=%d)\n", dev, count)); switch (dev & 0x0f) { @@ -169,7 +170,7 @@ static ssize_t sound_read(struct file *file, char __user *buf, size_t count, lof case SND_DEV_MIDIN: ret = MIDIbuf_read(dev, file, buf, count); } - unlock_kernel(); + mutex_unlock(&soundcard_mutex); return ret; } @@ -178,7 +179,7 @@ static ssize_t sound_write(struct file *file, const char __user *buf, size_t cou int dev = iminor(file->f_path.dentry->d_inode); int ret = -EINVAL; - lock_kernel(); + mutex_lock(&soundcard_mutex); DEB(printk("sound_write(dev=%d, count=%d)\n", dev, count)); switch (dev & 0x0f) { case SND_DEV_SEQ: @@ -196,7 +197,7 @@ static ssize_t sound_write(struct file *file, const char __user *buf, size_t cou ret = MIDIbuf_write(dev, file, buf, count); break; } - unlock_kernel(); + mutex_unlock(&soundcard_mutex); return ret; } @@ -210,7 +211,7 @@ static int sound_open(struct inode *inode, struct file *file) printk(KERN_ERR "Invalid minor device %d\n", dev); return -ENXIO; } - lock_kernel(); + mutex_lock(&soundcard_mutex); switch (dev & 0x0f) { case SND_DEV_CTL: dev >>= 4; @@ -247,7 +248,7 @@ static int sound_open(struct inode *inode, struct file *file) retval = -ENXIO; } - unlock_kernel(); + mutex_unlock(&soundcard_mutex); return 0; } @@ -255,7 +256,7 @@ static int sound_release(struct inode *inode, struct file *file) { int dev = iminor(inode); - lock_kernel(); + mutex_lock(&soundcard_mutex); DEB(printk("sound_release(dev=%d)\n", dev)); switch (dev & 0x0f) { case SND_DEV_CTL: @@ -280,7 +281,7 @@ static int sound_release(struct inode *inode, struct file *file) default: printk(KERN_ERR "Sound error: Releasing unknown device 0x%02x\n", dev); } - unlock_kernel(); + mutex_unlock(&soundcard_mutex); return 0; } @@ -354,7 +355,7 @@ static long sound_ioctl(struct file *file, unsigned int cmd, unsigned long arg) if (cmd == OSS_GETVERSION) return __put_user(SOUND_VERSION, (int __user *)p); - lock_kernel(); + mutex_lock(&soundcard_mutex); if (_IOC_TYPE(cmd) == 'M' && num_mixers > 0 && /* Mixer ioctl */ (dev & 0x0f) != SND_DEV_CTL) { dtype = dev & 0x0f; @@ -369,7 +370,7 @@ static long sound_ioctl(struct file *file, unsigned int cmd, unsigned long arg) ret = sound_mixer_ioctl(dev >> 4, cmd, p); break; } - unlock_kernel(); + mutex_unlock(&soundcard_mutex); return ret; } @@ -399,7 +400,7 @@ static long sound_ioctl(struct file *file, unsigned int cmd, unsigned long arg) break; } - unlock_kernel(); + mutex_unlock(&soundcard_mutex); return ret; } @@ -439,35 +440,35 @@ static int sound_mmap(struct file *file, struct vm_area_struct *vma) printk(KERN_ERR "Sound: mmap() not supported for other than audio devices\n"); return -EINVAL; } - lock_kernel(); + mutex_lock(&soundcard_mutex); if (vma->vm_flags & VM_WRITE) /* Map write and read/write to the output buf */ dmap = audio_devs[dev]->dmap_out; else if (vma->vm_flags & VM_READ) dmap = audio_devs[dev]->dmap_in; else { printk(KERN_ERR "Sound: Undefined mmap() access\n"); - unlock_kernel(); + mutex_unlock(&soundcard_mutex); return -EINVAL; } if (dmap == NULL) { printk(KERN_ERR "Sound: mmap() error. dmap == NULL\n"); - unlock_kernel(); + mutex_unlock(&soundcard_mutex); return -EIO; } if (dmap->raw_buf == NULL) { printk(KERN_ERR "Sound: mmap() called when raw_buf == NULL\n"); - unlock_kernel(); + mutex_unlock(&soundcard_mutex); return -EIO; } if (dmap->mapping_flags) { printk(KERN_ERR "Sound: mmap() called twice for the same DMA buffer\n"); - unlock_kernel(); + mutex_unlock(&soundcard_mutex); return -EIO; } if (vma->vm_pgoff != 0) { printk(KERN_ERR "Sound: mmap() offset must be 0.\n"); - unlock_kernel(); + mutex_unlock(&soundcard_mutex); return -EINVAL; } size = vma->vm_end - vma->vm_start; @@ -478,7 +479,7 @@ static int sound_mmap(struct file *file, struct vm_area_struct *vma) if (remap_pfn_range(vma, vma->vm_start, virt_to_phys(dmap->raw_buf) >> PAGE_SHIFT, vma->vm_end - vma->vm_start, vma->vm_page_prot)) { - unlock_kernel(); + mutex_unlock(&soundcard_mutex); return -EAGAIN; } @@ -490,7 +491,7 @@ static int sound_mmap(struct file *file, struct vm_area_struct *vma) memset(dmap->raw_buf, dmap->neutral_byte, dmap->bytes_in_use); - unlock_kernel(); + mutex_unlock(&soundcard_mutex); return 0; } diff --git a/sound/oss/swarm_cs4297a.c b/sound/oss/swarm_cs4297a.c index b15840a..44357d8 100644 --- a/sound/oss/swarm_cs4297a.c +++ b/sound/oss/swarm_cs4297a.c @@ -68,7 +68,6 @@ #include #include #include -#include #include #include #include @@ -94,6 +93,7 @@ struct cs4297a_state; +static DEFINE_MUTEX(swarm_cs4297a_mutex); static void stop_dac(struct cs4297a_state *s); static void stop_adc(struct cs4297a_state *s); static void start_dac(struct cs4297a_state *s); @@ -1535,7 +1535,7 @@ static int cs4297a_open_mixdev(struct inode *inode, struct file *file) CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4, printk(KERN_INFO "cs4297a: cs4297a_open_mixdev()+\n")); - lock_kernel(); + mutex_lock(&swarm_cs4297a_mutex); list_for_each(entry, &cs4297a_devs) { s = list_entry(entry, struct cs4297a_state, list); @@ -1547,7 +1547,7 @@ static int cs4297a_open_mixdev(struct inode *inode, struct file *file) CS_DBGOUT(CS_FUNCTION | CS_OPEN | CS_ERROR, 2, printk(KERN_INFO "cs4297a: cs4297a_open_mixdev()- -ENODEV\n")); - unlock_kernel(); + mutex_unlock(&swarm_cs4297a_mutex); return -ENODEV; } VALIDATE_STATE(s); @@ -1555,7 +1555,7 @@ static int cs4297a_open_mixdev(struct inode *inode, struct file *file) CS_DBGOUT(CS_FUNCTION | CS_OPEN, 4, printk(KERN_INFO "cs4297a: cs4297a_open_mixdev()- 0\n")); - unlock_kernel(); + mutex_unlock(&swarm_cs4297a_mutex); return nonseekable_open(inode, file); } @@ -1575,10 +1575,10 @@ static int cs4297a_ioctl_mixdev(struct file *file, unsigned int cmd, unsigned long arg) { int ret; - lock_kernel(); + mutex_lock(&swarm_cs4297a_mutex); ret = mixer_ioctl((struct cs4297a_state *) file->private_data, cmd, arg); - unlock_kernel(); + mutex_unlock(&swarm_cs4297a_mutex); return ret; } @@ -2350,9 +2350,9 @@ static long cs4297a_unlocked_ioctl(struct file *file, u_int cmd, u_long arg) { int ret; - lock_kernel(); + mutex_lock(&swarm_cs4297a_mutex); ret = cs4297a_ioctl(file, cmd, arg); - unlock_kernel(); + mutex_unlock(&swarm_cs4297a_mutex); return ret; } @@ -2509,9 +2509,9 @@ static int cs4297a_open(struct inode *inode, struct file *file) { int ret; - lock_kernel(); + mutex_lock(&swarm_cs4297a_mutex); ret = cs4297a_open(inode, file); - unlock_kernel(); + mutex_unlock(&swarm_cs4297a_mutex); return ret; } diff --git a/sound/oss/vwsnd.c b/sound/oss/vwsnd.c index 8cd73cd..643f111 100644 --- a/sound/oss/vwsnd.c +++ b/sound/oss/vwsnd.c @@ -145,7 +145,6 @@ #include #include -#include #include #include #include @@ -160,6 +159,7 @@ #ifdef VWSND_DEBUG +static DEFINE_MUTEX(vwsnd_mutex); static int shut_up = 1; /* @@ -2891,11 +2891,11 @@ static long vwsnd_audio_ioctl(struct file *file, vwsnd_dev_t *devc = (vwsnd_dev_t *) file->private_data; int ret; - lock_kernel(); + mutex_lock(&vwsnd_mutex); mutex_lock(&devc->io_mutex); ret = vwsnd_audio_do_ioctl(file, cmd, arg); mutex_unlock(&devc->io_mutex); - unlock_kernel(); + mutex_unlock(&vwsnd_mutex); return ret; } @@ -2922,7 +2922,7 @@ static int vwsnd_audio_open(struct inode *inode, struct file *file) DBGE("(inode=0x%p, file=0x%p)\n", inode, file); - lock_kernel(); + mutex_lock(&vwsnd_mutex); INC_USE_COUNT; for (devc = vwsnd_dev_list; devc; devc = devc->next_dev) if ((devc->audio_minor & ~0x0F) == (minor & ~0x0F)) @@ -2930,7 +2930,7 @@ static int vwsnd_audio_open(struct inode *inode, struct file *file) if (devc == NULL) { DEC_USE_COUNT; - unlock_kernel(); + mutex_unlock(&vwsnd_mutex); return -ENODEV; } @@ -2939,13 +2939,13 @@ static int vwsnd_audio_open(struct inode *inode, struct file *file) mutex_unlock(&devc->open_mutex); if (file->f_flags & O_NONBLOCK) { DEC_USE_COUNT; - unlock_kernel(); + mutex_unlock(&vwsnd_mutex); return -EBUSY; } interruptible_sleep_on(&devc->open_wait); if (signal_pending(current)) { DEC_USE_COUNT; - unlock_kernel(); + mutex_unlock(&vwsnd_mutex); return -ERESTARTSYS; } mutex_lock(&devc->open_mutex); @@ -2998,7 +2998,7 @@ static int vwsnd_audio_open(struct inode *inode, struct file *file) file->private_data = devc; DBGRV(); - unlock_kernel(); + mutex_unlock(&vwsnd_mutex); return 0; } @@ -3012,7 +3012,7 @@ static int vwsnd_audio_release(struct inode *inode, struct file *file) vwsnd_port_t *wport = NULL, *rport = NULL; int err = 0; - lock_kernel(); + mutex_lock(&vwsnd_mutex); mutex_lock(&devc->io_mutex); { DBGEV("(inode=0x%p, file=0x%p)\n", inode, file); @@ -3040,7 +3040,7 @@ static int vwsnd_audio_release(struct inode *inode, struct file *file) wake_up(&devc->open_wait); DEC_USE_COUNT; DBGR(); - unlock_kernel(); + mutex_unlock(&vwsnd_mutex); return err; } @@ -3068,18 +3068,18 @@ static int vwsnd_mixer_open(struct inode *inode, struct file *file) DBGEV("(inode=0x%p, file=0x%p)\n", inode, file); INC_USE_COUNT; - lock_kernel(); + mutex_lock(&vwsnd_mutex); for (devc = vwsnd_dev_list; devc; devc = devc->next_dev) if (devc->mixer_minor == iminor(inode)) break; if (devc == NULL) { DEC_USE_COUNT; - unlock_kernel(); + mutex_unlock(&vwsnd_mutex); return -ENODEV; } file->private_data = devc; - unlock_kernel(); + mutex_unlock(&vwsnd_mutex); return 0; } @@ -3223,7 +3223,7 @@ static long vwsnd_mixer_ioctl(struct file *file, DBGEV("(devc=0x%p, cmd=0x%x, arg=0x%lx)\n", devc, cmd, arg); - lock_kernel(); + mutex_lock(&vwsnd_mutex); mutex_lock(&devc->mix_mutex); { if ((cmd & ~nrmask) == MIXER_READ(0)) @@ -3234,7 +3234,7 @@ static long vwsnd_mixer_ioctl(struct file *file, retval = -EINVAL; } mutex_unlock(&devc->mix_mutex); - unlock_kernel(); + mutex_unlock(&vwsnd_mutex); return retval; } -- cgit v1.1 From 9ad0e496519d99eb2c34f01e41500a775122c744 Mon Sep 17 00:00:00 2001 From: Kailang Yang Date: Tue, 14 Sep 2010 23:22:00 +0200 Subject: ALSA: hda - Add input jack layer support to Realtek codec Signed-off-by: Kailang Yang Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 98 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 98 insertions(+) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index 9c2c19c..3b04087 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -28,6 +28,7 @@ #include #include #include +#include #include "hda_codec.h" #include "hda_local.h" #include "hda_beep.h" @@ -282,6 +283,12 @@ struct alc_mic_route { unsigned char amix_idx; }; +struct alc_jack { + hda_nid_t nid; + int type; + struct snd_jack *jack; +}; + #define MUX_IDX_UNDEF ((unsigned char)-1) struct alc_customize_define { @@ -357,6 +364,9 @@ struct alc_spec { /* PCM information */ struct hda_pcm pcm_rec[3]; /* used in alc_build_pcms() */ + /* jack detection */ + struct snd_array jacks; + /* dynamic controls, init_verbs and input_mux */ struct auto_pin_cfg autocfg; struct alc_customize_define cdefine; @@ -990,6 +1000,91 @@ static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid, alc_fix_pll(codec); } +#ifdef CONFIG_SND_HDA_INPUT_JACK +static void alc_free_jack_priv(struct snd_jack *jack) +{ + struct alc_jack *jacks = jack->private_data; + jacks->nid = 0; + jacks->jack = NULL; +} + +static int alc_add_jack(struct hda_codec *codec, + hda_nid_t nid, int type) +{ + struct alc_spec *spec; + struct alc_jack *jack; + const char *name; + int err; + + spec = codec->spec; + snd_array_init(&spec->jacks, sizeof(*jack), 32); + jack = snd_array_new(&spec->jacks); + if (!jack) + return -ENOMEM; + + jack->nid = nid; + jack->type = type; + name = (type == SND_JACK_HEADPHONE) ? "Headphone" : "Mic" ; + + err = snd_jack_new(codec->bus->card, name, type, &jack->jack); + if (err < 0) + return err; + jack->jack->private_data = jack; + jack->jack->private_free = alc_free_jack_priv; + return 0; +} + +static void alc_report_jack(struct hda_codec *codec, hda_nid_t nid) +{ + struct alc_spec *spec = codec->spec; + struct alc_jack *jacks = spec->jacks.list; + + if (jacks) { + int i; + for (i = 0; i < spec->jacks.used; i++) { + if (jacks->nid == nid) { + unsigned int present; + present = snd_hda_jack_detect(codec, nid); + + present = (present) ? jacks->type : 0; + + snd_jack_report(jacks->jack, present); + } + jacks++; + } + } +} + +static int alc_init_jacks(struct hda_codec *codec) +{ + struct alc_spec *spec = codec->spec; + int err; + unsigned int hp_nid = spec->autocfg.hp_pins[0]; + unsigned int mic_nid = spec->ext_mic.pin; + + err = alc_add_jack(codec, hp_nid, SND_JACK_HEADPHONE); + if (err < 0) + return err; + alc_report_jack(codec, hp_nid); + + err = alc_add_jack(codec, mic_nid, SND_JACK_MICROPHONE); + if (err < 0) + return err; + alc_report_jack(codec, mic_nid); + + return 0; +} +#else +static inline void alc_report_jack(struct hda_codec *codec, hda_nid_t nid) +{ +} + +static inline int alc_init_jacks(struct hda_codec *codec) +{ + return 0; +} +#endif + static void alc_automute_speaker(struct hda_codec *codec, int pinctl) { struct alc_spec *spec = codec->spec; @@ -1006,6 +1101,7 @@ static void alc_automute_speaker(struct hda_codec *codec, int pinctl) spec->jack_present = 1; break; } + alc_report_jack(codec, spec->autocfg.hp_pins[i]); } mute = spec->jack_present ? HDA_AMP_MUTE : 0; @@ -1111,6 +1207,7 @@ static void alc_mic_automute(struct hda_codec *codec) AC_VERB_SET_CONNECT_SEL, alive->mux_idx); } + alc_report_jack(codec, spec->ext_mic.pin); /* FIXME: analog mixer */ } @@ -14496,6 +14593,7 @@ static void alc269_auto_init(struct hda_codec *codec) alc269_auto_init_hp_out(codec); alc269_auto_init_analog_input(codec); alc_auto_init_digital(codec); + alc_init_jacks(codec); if (spec->unsol_event) alc_inithook(codec); } -- cgit v1.1 From 3894335876a6257ac46e14845bd37ae6fb0f7c87 Mon Sep 17 00:00:00 2001 From: Stephen Warren Date: Tue, 14 Sep 2010 10:48:59 -0600 Subject: ALSA: patch_nvhdmi.c: Fix supported sample rate list. 22050 isn't a valid HDMI sample rate. 32000 is. Signed-off-by: Stephen Warren Acked-By: Wei Ni Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_nvhdmi.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_nvhdmi.c b/sound/pci/hda/patch_nvhdmi.c index 69b950d..baa108b 100644 --- a/sound/pci/hda/patch_nvhdmi.c +++ b/sound/pci/hda/patch_nvhdmi.c @@ -84,7 +84,7 @@ static struct hda_verb nvhdmi_basic_init_7x[] = { #else /* support all rates and formats */ #define SUPPORTED_RATES \ - (SNDRV_PCM_RATE_22050 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |\ + (SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |\ SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_176400 |\ SNDRV_PCM_RATE_192000) #define SUPPORTED_MAXBPS 24 -- cgit v1.1 From 1446c5fba73044a1c72153e1203b23b1820431c5 Mon Sep 17 00:00:00 2001 From: Jaroslav Kysela Date: Wed, 15 Sep 2010 08:01:57 +0200 Subject: ALSA: snd-aloop - fix the "PCM Playback Channels" kcontrol Obvious copy-and-paste error. Signed-off-by: Jaroslav Kysela --- sound/drivers/aloop.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/drivers/aloop.c b/sound/drivers/aloop.c index 3123a15..f2b8f86 100644 --- a/sound/drivers/aloop.c +++ b/sound/drivers/aloop.c @@ -809,7 +809,7 @@ static int loopback_channels_get(struct snd_kcontrol *kcontrol, ucontrol->value.integer.value[0] = loopback->setup[kcontrol->id.subdevice] - [kcontrol->id.device].rate; + [kcontrol->id.device].channels; return 0; } -- cgit v1.1 From 977ddd6b2e63716cfefe669bbdb30ec0bcea1fe4 Mon Sep 17 00:00:00 2001 From: Kailang Yang Date: Wed, 15 Sep 2010 10:02:29 +0200 Subject: ALSA: hda - Set up COEFs for ALC269 to avoid click noises at power-saving For avoiding the click noises at power-saving, set some COEF values for ALC269* codecs. Signed-off-by: Kailang Yang Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 114 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 114 insertions(+) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index 3b04087..ab2947d 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -1673,6 +1673,15 @@ static int alc_read_coef_idx(struct hda_codec *codec, return val; } +static void alc_write_coef_idx(struct hda_codec *codec, unsigned int coef_idx, + unsigned int coef_val) +{ + snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, + coef_idx); + snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, + coef_val); +} + /* set right pin controls for digital I/O */ static void alc_auto_init_digital(struct hda_codec *codec) { @@ -14598,6 +14607,68 @@ static void alc269_auto_init(struct hda_codec *codec) alc_inithook(codec); } +#ifdef CONFIG_SND_HDA_POWER_SAVE +static int alc269_suspend(struct hda_codec *codec, pm_message_t state) +{ + struct alc_spec *spec = codec->spec; + int val; + + if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) { + val = alc_read_coef_idx(codec, 0x04); + /* Power down output pin */ + alc_write_coef_idx(codec, 0x04, val & ~(1<<11)); + } + + if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) { + val = alc_read_coef_idx(codec, 0x04); + /* Power down output pin */ + alc_write_coef_idx(codec, 0x04, val & ~(1<<11)); + msleep(150); + } + + alc_shutup(codec); + if (spec && spec->power_hook) + spec->power_hook(codec); + return 0; +} +#endif +#ifdef SND_HDA_NEEDS_RESUME +static int alc269_resume(struct hda_codec *codec) +{ + int val; + + if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) { + val = alc_read_coef_idx(codec, 0x04); + /* Power down output pin */ + alc_write_coef_idx(codec, 0x04, val & ~(1<<11)); + msleep(150); + } + + codec->patch_ops.init(codec); + + if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) { + val = alc_read_coef_idx(codec, 0x04); + /* Power up output pin */ + alc_write_coef_idx(codec, 0x04, val | (1<<11)); + msleep(200); + } + + if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) { + val = alc_read_coef_idx(codec, 0x04); + /* Power up output pin */ + alc_write_coef_idx(codec, 0x04, val | (1<<11)); + } + + snd_hda_codec_resume_amp(codec); + snd_hda_codec_resume_cache(codec); +#ifdef CONFIG_SND_HDA_POWER_SAVE + if (codec->patch_ops.check_power_status) + codec->patch_ops.check_power_status(codec, 0x01); +#endif + return 0; +} +#endif + enum { ALC269_FIXUP_SONY_VAIO, }; @@ -14814,6 +14885,41 @@ static struct alc_config_preset alc269_presets[] = { }, }; +static int alc269_fill_coef(struct hda_codec *codec) +{ + int val; + + if ((alc_read_coef_idx(codec, 0) & 0x00ff) < 0x015) { + alc_write_coef_idx(codec, 0xf, 0x960b); + alc_write_coef_idx(codec, 0xe, 0x8817); + } + + if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x016) { + alc_write_coef_idx(codec, 0xf, 0x960b); + alc_write_coef_idx(codec, 0xe, 0x8814); + } + + if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) { + val = alc_read_coef_idx(codec, 0x04); + /* Power up output pin */ + alc_write_coef_idx(codec, 0x04, val | (1<<11)); + } + + if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) { + val = alc_read_coef_idx(codec, 0xd); + if ((val & 0x0c00) >> 10 != 0x1) { + /* Capless ramp up clock control */ + alc_write_coef_idx(codec, 0xd, val | 1<<10); + } + val = alc_read_coef_idx(codec, 0x17); + if ((val & 0x01c0) >> 6 != 0x4) { + /* Class D power on reset */ + alc_write_coef_idx(codec, 0x17, val | 1<<7); + } + } + return 0; +} + static int patch_alc269(struct hda_codec *codec) { struct alc_spec *spec; @@ -14839,6 +14945,8 @@ static int patch_alc269(struct hda_codec *codec) } else alc_fix_pll_init(codec, 0x20, 0x04, 15); + alc269_fill_coef(codec); + board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST, alc269_models, alc269_cfg_tbl); @@ -14917,6 +15025,12 @@ static int patch_alc269(struct hda_codec *codec) spec->vmaster_nid = 0x02; codec->patch_ops = alc_patch_ops; +#ifdef CONFIG_SND_HDA_POWER_SAVE + codec->patch_ops.suspend = alc269_suspend; +#endif +#ifdef SND_HDA_NEEDS_RESUME + codec->patch_ops.resume = alc269_resume; +#endif if (board_config == ALC269_AUTO) spec->init_hook = alc269_auto_init; #ifdef CONFIG_SND_HDA_POWER_SAVE -- cgit v1.1 From f2e5731dfd3ba08b023d0626d36ccf78f54ab5e7 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Wed, 15 Sep 2010 10:07:08 +0200 Subject: ALSA: hda - Preliminary support for new Conexant audio codecs This patch adds the preliminary support for new Conexant audio codecs with 14f1:5097, 14f1:5098, 14f1:50a1, 14f1:50a2, 14f1:50ab, 14f1:50ac, 14f1:50b8 and 14f1:50b9. Unlike other Conexant parsers, this is designed to be mostly automatic, parsing from BIOS pin configurations. Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_conexant.c | 640 ++++++++++++++++++++++++++++++++++++++++- 1 file changed, 639 insertions(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c index 972e7c4..7eee0ff 100644 --- a/sound/pci/hda/patch_conexant.c +++ b/sound/pci/hda/patch_conexant.c @@ -57,6 +57,12 @@ struct conexant_jack { }; +struct pin_dac_pair { + hda_nid_t pin; + hda_nid_t dac; + int type; +}; + struct conexant_spec { struct snd_kcontrol_new *mixers[5]; @@ -77,6 +83,7 @@ struct conexant_spec { unsigned int cur_eapd; unsigned int hp_present; unsigned int auto_mic; + int auto_mic_ext; /* autocfg.inputs[] index for ext mic */ unsigned int need_dac_fix; /* capture */ @@ -110,9 +117,12 @@ struct conexant_spec { struct auto_pin_cfg autocfg; struct hda_input_mux private_imux; hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS]; + struct pin_dac_pair dac_info[8]; + int dac_info_filled; - unsigned int dell_automute; unsigned int port_d_mode; + unsigned int auto_mute:1; /* used in auto-parser */ + unsigned int dell_automute:1; unsigned int dell_vostro:1; unsigned int ideapad:1; unsigned int thinkpad:1; @@ -3254,6 +3264,610 @@ static int patch_cxt5066(struct hda_codec *codec) } /* + * Automatic parser for CX20641 & co + */ + +static hda_nid_t cx_auto_adc_nids[] = { 0x14 }; + +/* get the connection index of @nid in the widget @mux */ +static int get_connection_index(struct hda_codec *codec, hda_nid_t mux, + hda_nid_t nid) +{ + hda_nid_t conn[HDA_MAX_NUM_INPUTS]; + int i, nums; + + nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn)); + for (i = 0; i < nums; i++) + if (conn[i] == nid) + return i; + return -1; +} + +/* get an unassigned DAC from the given list. + * Return the nid if found and reduce the DAC list, or return zero if + * not found + */ +static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t pin, + hda_nid_t *dacs, int *num_dacs) +{ + int i, nums = *num_dacs; + hda_nid_t ret = 0; + + for (i = 0; i < nums; i++) { + if (get_connection_index(codec, pin, dacs[i]) >= 0) { + ret = dacs[i]; + break; + } + } + if (!ret) + return 0; + if (--nums > 0) + memmove(dacs, dacs + 1, nums * sizeof(hda_nid_t)); + *num_dacs = nums; + return ret; +} + +#define MAX_AUTO_DACS 5 + +/* fill analog DAC list from the widget tree */ +static int fill_cx_auto_dacs(struct hda_codec *codec, hda_nid_t *dacs) +{ + hda_nid_t nid, end_nid; + int nums = 0; + + end_nid = codec->start_nid + codec->num_nodes; + for (nid = codec->start_nid; nid < end_nid; nid++) { + unsigned int wcaps = get_wcaps(codec, nid); + unsigned int type = get_wcaps_type(wcaps); + if (type == AC_WID_AUD_OUT && !(wcaps & AC_WCAP_DIGITAL)) { + dacs[nums++] = nid; + if (nums >= MAX_AUTO_DACS) + break; + } + } + return nums; +} + +/* fill pin_dac_pair list from the pin and dac list */ +static int fill_dacs_for_pins(struct hda_codec *codec, hda_nid_t *pins, + int num_pins, hda_nid_t *dacs, int *rest, + struct pin_dac_pair *filled, int type) +{ + int i, nums; + + nums = 0; + for (i = 0; i < num_pins; i++) { + filled[nums].pin = pins[i]; + filled[nums].type = type; + filled[nums].dac = get_unassigned_dac(codec, pins[i], dacs, rest); + nums++; + } + return nums; +} + +/* parse analog output paths */ +static void cx_auto_parse_output(struct hda_codec *codec) +{ + struct conexant_spec *spec = codec->spec; + struct auto_pin_cfg *cfg = &spec->autocfg; + hda_nid_t dacs[MAX_AUTO_DACS]; + int i, j, nums, rest; + + rest = fill_cx_auto_dacs(codec, dacs); + /* parse all analog output pins */ + nums = fill_dacs_for_pins(codec, cfg->line_out_pins, cfg->line_outs, + dacs, &rest, spec->dac_info, + AUTO_PIN_LINE_OUT); + nums += fill_dacs_for_pins(codec, cfg->hp_pins, cfg->hp_outs, + dacs, &rest, spec->dac_info + nums, + AUTO_PIN_HP_OUT); + nums += fill_dacs_for_pins(codec, cfg->speaker_pins, cfg->speaker_outs, + dacs, &rest, spec->dac_info + nums, + AUTO_PIN_SPEAKER_OUT); + spec->dac_info_filled = nums; + /* fill multiout struct */ + for (i = 0; i < nums; i++) { + hda_nid_t dac = spec->dac_info[i].dac; + if (!dac) + continue; + switch (spec->dac_info[i].type) { + case AUTO_PIN_LINE_OUT: + spec->private_dac_nids[spec->multiout.num_dacs] = dac; + spec->multiout.num_dacs++; + break; + case AUTO_PIN_HP_OUT: + case AUTO_PIN_SPEAKER_OUT: + if (!spec->multiout.hp_nid) { + spec->multiout.hp_nid = dac; + break; + } + for (j = 0; j < ARRAY_SIZE(spec->multiout.extra_out_nid); j++) + if (!spec->multiout.extra_out_nid[j]) { + spec->multiout.extra_out_nid[j] = dac; + break; + } + break; + } + } + spec->multiout.dac_nids = spec->private_dac_nids; + spec->multiout.max_channels = nums * 2; + + if (cfg->hp_outs > 0) + spec->auto_mute = 1; + spec->vmaster_nid = spec->private_dac_nids[0]; +} + +/* auto-mute/unmute speaker and line outs according to headphone jack */ +static void cx_auto_hp_automute(struct hda_codec *codec) +{ + struct conexant_spec *spec = codec->spec; + struct auto_pin_cfg *cfg = &spec->autocfg; + int i, present; + + if (!spec->auto_mute) + return; + present = 0; + for (i = 0; i < cfg->hp_outs; i++) { + if (snd_hda_jack_detect(codec, cfg->hp_pins[i])) { + present = 1; + break; + } + } + for (i = 0; i < cfg->line_outs; i++) { + snd_hda_codec_write(codec, cfg->line_out_pins[i], 0, + AC_VERB_SET_PIN_WIDGET_CONTROL, + present ? 0 : PIN_OUT); + } + for (i = 0; i < cfg->speaker_outs; i++) { + snd_hda_codec_write(codec, cfg->speaker_pins[i], 0, + AC_VERB_SET_PIN_WIDGET_CONTROL, + present ? 0 : PIN_OUT); + } +} + +/* automatic switch internal and external mic */ +static void cx_auto_automic(struct hda_codec *codec) +{ + struct conexant_spec *spec = codec->spec; + struct auto_pin_cfg *cfg = &spec->autocfg; + struct hda_input_mux *imux = &spec->private_imux; + int ext_idx = spec->auto_mic_ext; + + if (!spec->auto_mic) + return; + if (snd_hda_jack_detect(codec, cfg->inputs[ext_idx].pin)) { + snd_hda_codec_write(codec, spec->adc_nids[0], 0, + AC_VERB_SET_CONNECT_SEL, + imux->items[ext_idx].index); + } else { + snd_hda_codec_write(codec, spec->adc_nids[0], 0, + AC_VERB_SET_CONNECT_SEL, + imux->items[!ext_idx].index); + } +} + +static void cx_auto_unsol_event(struct hda_codec *codec, unsigned int res) +{ + int nid = (res & AC_UNSOL_RES_SUBTAG) >> 20; + switch (res >> 26) { + case CONEXANT_HP_EVENT: + cx_auto_hp_automute(codec); + conexant_report_jack(codec, nid); + break; + case CONEXANT_MIC_EVENT: + cx_auto_automic(codec); + conexant_report_jack(codec, nid); + break; + } +} + +static int is_int_mic_conn(unsigned int def_conf) +{ + unsigned int loc = get_defcfg_location(def_conf); + return get_defcfg_connect(def_conf) == AC_JACK_PORT_FIXED || + (loc & 0x30) == AC_JACK_LOC_INTERNAL; +} + +/* return true if it's an internal-mic pin */ +static int is_int_mic(struct hda_codec *codec, hda_nid_t pin) +{ + unsigned int def_conf = snd_hda_codec_get_pincfg(codec, pin); + return get_defcfg_device(def_conf) == AC_JACK_MIC_IN && + is_int_mic_conn(def_conf); +} + +/* return true if it's an external-mic pin */ +static int is_ext_mic(struct hda_codec *codec, hda_nid_t pin) +{ + unsigned int def_conf = snd_hda_codec_get_pincfg(codec, pin); + return get_defcfg_device(def_conf) == AC_JACK_MIC_IN && + !is_int_mic_conn(def_conf); +} + +/* check whether the pin config is suitable for auto-mic switching; + * auto-mic is enabled only when one int-mic and one-ext mic exist + */ +static void cx_auto_check_auto_mic(struct hda_codec *codec) +{ + struct conexant_spec *spec = codec->spec; + struct auto_pin_cfg *cfg = &spec->autocfg; + + if (is_ext_mic(codec, cfg->inputs[0].pin) && + is_int_mic(codec, cfg->inputs[1].pin)) { + spec->auto_mic = 1; + spec->auto_mic_ext = 1; + return; + } + if (is_int_mic(codec, cfg->inputs[1].pin) && + is_ext_mic(codec, cfg->inputs[0].pin)) { + spec->auto_mic = 1; + spec->auto_mic_ext = 0; + return; + } +} + +static void cx_auto_parse_input(struct hda_codec *codec) +{ + struct conexant_spec *spec = codec->spec; + struct auto_pin_cfg *cfg = &spec->autocfg; + struct hda_input_mux *imux; + int i; + + imux = &spec->private_imux; + for (i = 0; i < cfg->num_inputs; i++) { + int idx = get_connection_index(codec, spec->adc_nids[0], + cfg->inputs[i].pin); + if (idx >= 0) { + const char *label; + label = hda_get_autocfg_input_label(codec, cfg, i); + snd_hda_add_imux_item(imux, label, idx, NULL); + } + } + if (imux->num_items == 2 && cfg->num_inputs == 2) + cx_auto_check_auto_mic(codec); + if (imux->num_items > 1 && !spec->auto_mic) + spec->input_mux = imux; +} + +/* get digital-input audio widget corresponding to the given pin */ +static hda_nid_t cx_auto_get_dig_in(struct hda_codec *codec, hda_nid_t pin) +{ + hda_nid_t nid, end_nid; + + end_nid = codec->start_nid + codec->num_nodes; + for (nid = codec->start_nid; nid < end_nid; nid++) { + unsigned int wcaps = get_wcaps(codec, nid); + unsigned int type = get_wcaps_type(wcaps); + if (type == AC_WID_AUD_IN && (wcaps & AC_WCAP_DIGITAL)) { + if (get_connection_index(codec, nid, pin) >= 0) + return nid; + } + } + return 0; +} + +static void cx_auto_parse_digital(struct hda_codec *codec) +{ + struct conexant_spec *spec = codec->spec; + struct auto_pin_cfg *cfg = &spec->autocfg; + hda_nid_t nid; + + if (cfg->dig_outs && + snd_hda_get_connections(codec, cfg->dig_out_pins[0], &nid, 1) == 1) + spec->multiout.dig_out_nid = nid; + if (cfg->dig_in_pin) + spec->dig_in_nid = cx_auto_get_dig_in(codec, cfg->dig_in_pin); +} + +#ifdef CONFIG_SND_HDA_INPUT_BEEP +static void cx_auto_parse_beep(struct hda_codec *codec) +{ + struct conexant_spec *spec = codec->spec; + hda_nid_t nid, end_nid; + + end_nid = codec->start_nid + codec->num_nodes; + for (nid = codec->start_nid; nid < end_nid; nid++) + if (get_wcaps_type(get_wcaps(codec, nid)) == AC_WID_BEEP) { + set_beep_amp(spec, nid, 0, HDA_OUTPUT); + break; + } +} +#else +#define cx_auto_parse_beep(codec) +#endif + +static int cx_auto_parse_auto_config(struct hda_codec *codec) +{ + struct conexant_spec *spec = codec->spec; + int err; + + err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL); + if (err < 0) + return err; + + cx_auto_parse_output(codec); + cx_auto_parse_input(codec); + cx_auto_parse_digital(codec); + cx_auto_parse_beep(codec); + return 0; +} + +static void cx_auto_turn_on_eapd(struct hda_codec *codec, int num_pins, + hda_nid_t *pins) +{ + int i; + for (i = 0; i < num_pins; i++) { + if (snd_hda_query_pin_caps(codec, pins[i]) & AC_PINCAP_EAPD) + snd_hda_codec_write(codec, pins[i], 0, + AC_VERB_SET_EAPD_BTLENABLE, 0x02); + } +} + +static void select_connection(struct hda_codec *codec, hda_nid_t pin, + hda_nid_t src) +{ + int idx = get_connection_index(codec, pin, src); + if (idx >= 0) + snd_hda_codec_write(codec, pin, 0, + AC_VERB_SET_CONNECT_SEL, idx); +} + +static void cx_auto_init_output(struct hda_codec *codec) +{ + struct conexant_spec *spec = codec->spec; + struct auto_pin_cfg *cfg = &spec->autocfg; + hda_nid_t nid; + int i; + + for (i = 0; i < spec->multiout.num_dacs; i++) + snd_hda_codec_write(codec, spec->multiout.dac_nids[i], 0, + AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE); + + for (i = 0; i < cfg->hp_outs; i++) + snd_hda_codec_write(codec, cfg->hp_pins[i], 0, + AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP); + if (spec->auto_mute) { + for (i = 0; i < cfg->hp_outs; i++) { + snd_hda_codec_write(codec, cfg->hp_pins[i], 0, + AC_VERB_SET_UNSOLICITED_ENABLE, + AC_USRSP_EN | CONEXANT_HP_EVENT); + } + cx_auto_hp_automute(codec); + } else { + for (i = 0; i < cfg->line_outs; i++) + snd_hda_codec_write(codec, cfg->line_out_pins[i], 0, + AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); + for (i = 0; i < cfg->speaker_outs; i++) + snd_hda_codec_write(codec, cfg->speaker_pins[i], 0, + AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); + } + + for (i = 0; i < spec->dac_info_filled; i++) { + nid = spec->dac_info[i].dac; + if (!nid) + nid = spec->multiout.dac_nids[0]; + select_connection(codec, spec->dac_info[i].pin, nid); + } + + /* turn on EAPD */ + cx_auto_turn_on_eapd(codec, cfg->line_outs, cfg->line_out_pins); + cx_auto_turn_on_eapd(codec, cfg->hp_outs, cfg->hp_pins); + cx_auto_turn_on_eapd(codec, cfg->speaker_outs, cfg->speaker_pins); +} + +static void cx_auto_init_input(struct hda_codec *codec) +{ + struct conexant_spec *spec = codec->spec; + struct auto_pin_cfg *cfg = &spec->autocfg; + int i; + + for (i = 0; i < spec->num_adc_nids; i++) + snd_hda_codec_write(codec, spec->adc_nids[i], 0, + AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)); + + for (i = 0; i < cfg->num_inputs; i++) { + unsigned int type; + if (cfg->inputs[i].type == AUTO_PIN_MIC) + type = PIN_VREF80; + else + type = PIN_IN; + snd_hda_codec_write(codec, cfg->inputs[i].pin, 0, + AC_VERB_SET_PIN_WIDGET_CONTROL, type); + } + + if (spec->auto_mic) { + int ext_idx = spec->auto_mic_ext; + snd_hda_codec_write(codec, cfg->inputs[ext_idx].pin, 0, + AC_VERB_SET_UNSOLICITED_ENABLE, + AC_USRSP_EN | CONEXANT_MIC_EVENT); + cx_auto_automic(codec); + } else { + for (i = 0; i < spec->num_adc_nids; i++) { + snd_hda_codec_write(codec, spec->adc_nids[i], 0, + AC_VERB_SET_CONNECT_SEL, + spec->private_imux.items[0].index); + } + } +} + +static void cx_auto_init_digital(struct hda_codec *codec) +{ + struct conexant_spec *spec = codec->spec; + struct auto_pin_cfg *cfg = &spec->autocfg; + + if (spec->multiout.dig_out_nid) + snd_hda_codec_write(codec, cfg->dig_out_pins[0], 0, + AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); + if (spec->dig_in_nid) + snd_hda_codec_write(codec, cfg->dig_in_pin, 0, + AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN); +} + +static int cx_auto_init(struct hda_codec *codec) +{ + /*snd_hda_sequence_write(codec, cx_auto_init_verbs);*/ + cx_auto_init_output(codec); + cx_auto_init_input(codec); + cx_auto_init_digital(codec); + return 0; +} + +static int cx_auto_add_volume(struct hda_codec *codec, const char *basename, + const char *dir, int cidx, + hda_nid_t nid, int hda_dir) +{ + static char name[32]; + static struct snd_kcontrol_new knew[] = { + HDA_CODEC_VOLUME(name, 0, 0, 0), + HDA_CODEC_MUTE(name, 0, 0, 0), + }; + static char *sfx[2] = { "Volume", "Switch" }; + int i, err; + + for (i = 0; i < 2; i++) { + struct snd_kcontrol *kctl; + knew[i].private_value = HDA_COMPOSE_AMP_VAL(nid, 3, 0, hda_dir); + knew[i].subdevice = HDA_SUBDEV_AMP_FLAG; + knew[i].index = cidx; + snprintf(name, sizeof(name), "%s%s %s", basename, dir, sfx[i]); + kctl = snd_ctl_new1(&knew[i], codec); + if (!kctl) + return -ENOMEM; + err = snd_hda_ctl_add(codec, nid, kctl); + if (err < 0) + return err; + if (!(query_amp_caps(codec, nid, hda_dir) & AC_AMPCAP_MUTE)) + break; + } + return 0; +} + +#define cx_auto_add_pb_volume(codec, nid, str, idx) \ + cx_auto_add_volume(codec, str, " Playback", idx, nid, HDA_OUTPUT) + +static int cx_auto_build_output_controls(struct hda_codec *codec) +{ + struct conexant_spec *spec = codec->spec; + int i, err; + int num_line = 0, num_hp = 0, num_spk = 0; + static const char *texts[3] = { "Front", "Surround", "CLFE" }; + + if (spec->dac_info_filled == 1) + return cx_auto_add_pb_volume(codec, spec->dac_info[0].dac, + "Master", 0); + for (i = 0; i < spec->dac_info_filled; i++) { + const char *label; + int idx, type; + if (!spec->dac_info[i].dac) + continue; + type = spec->dac_info[i].type; + if (type == AUTO_PIN_LINE_OUT) + type = spec->autocfg.line_out_type; + switch (type) { + case AUTO_PIN_LINE_OUT: + default: + label = texts[num_line++]; + idx = 0; + break; + case AUTO_PIN_HP_OUT: + label = "Headphone"; + idx = num_hp++; + break; + case AUTO_PIN_SPEAKER_OUT: + label = "Speaker"; + idx = num_spk++; + break; + } + err = cx_auto_add_pb_volume(codec, spec->dac_info[i].dac, + label, idx); + if (err < 0) + return err; + } + return 0; +} + +static int cx_auto_build_input_controls(struct hda_codec *codec) +{ + struct conexant_spec *spec = codec->spec; + struct auto_pin_cfg *cfg = &spec->autocfg; + static const char *prev_label; + int i, err, cidx; + + err = cx_auto_add_volume(codec, "Capture", "", 0, spec->adc_nids[0], + HDA_INPUT); + if (err < 0) + return err; + prev_label = NULL; + cidx = 0; + for (i = 0; i < cfg->num_inputs; i++) { + hda_nid_t nid = cfg->inputs[i].pin; + const char *label; + if (!(get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) + continue; + label = hda_get_autocfg_input_label(codec, cfg, i); + if (label == prev_label) + cidx++; + else + cidx = 0; + prev_label = label; + err = cx_auto_add_volume(codec, label, " Capture", cidx, + nid, HDA_INPUT); + if (err < 0) + return err; + } + return 0; +} + +static int cx_auto_build_controls(struct hda_codec *codec) +{ + int err; + + err = cx_auto_build_output_controls(codec); + if (err < 0) + return err; + err = cx_auto_build_input_controls(codec); + if (err < 0) + return err; + return conexant_build_controls(codec); +} + +static struct hda_codec_ops cx_auto_patch_ops = { + .build_controls = cx_auto_build_controls, + .build_pcms = conexant_build_pcms, + .init = cx_auto_init, + .free = conexant_free, + .unsol_event = cx_auto_unsol_event, +#ifdef CONFIG_SND_HDA_POWER_SAVE + .suspend = conexant_suspend, +#endif + .reboot_notify = snd_hda_shutup_pins, +}; + +static int patch_conexant_auto(struct hda_codec *codec) +{ + struct conexant_spec *spec; + int err; + + spec = kzalloc(sizeof(*spec), GFP_KERNEL); + if (!spec) + return -ENOMEM; + codec->spec = spec; + spec->adc_nids = cx_auto_adc_nids; + spec->num_adc_nids = ARRAY_SIZE(cx_auto_adc_nids); + spec->capsrc_nids = spec->adc_nids; + err = cx_auto_parse_auto_config(codec); + if (err < 0) { + kfree(codec->spec); + codec->spec = NULL; + return err; + } + codec->patch_ops = cx_auto_patch_ops; + if (spec->beep_amp) + snd_hda_attach_beep_device(codec, spec->beep_amp); + return 0; +} + +/* */ static struct hda_codec_preset snd_hda_preset_conexant[] = { @@ -3271,6 +3885,22 @@ static struct hda_codec_preset snd_hda_preset_conexant[] = { .patch = patch_cxt5066 }, { .id = 0x14f15069, .name = "CX20585", .patch = patch_cxt5066 }, + { .id = 0x14f15097, .name = "CX20631", + .patch = patch_conexant_auto }, + { .id = 0x14f15098, .name = "CX20632", + .patch = patch_conexant_auto }, + { .id = 0x14f150a1, .name = "CX20641", + .patch = patch_conexant_auto }, + { .id = 0x14f150a2, .name = "CX20642", + .patch = patch_conexant_auto }, + { .id = 0x14f150ab, .name = "CX20651", + .patch = patch_conexant_auto }, + { .id = 0x14f150ac, .name = "CX20652", + .patch = patch_conexant_auto }, + { .id = 0x14f150b8, .name = "CX20664", + .patch = patch_conexant_auto }, + { .id = 0x14f150b9, .name = "CX20665", + .patch = patch_conexant_auto }, {} /* terminator */ }; @@ -3281,6 +3911,14 @@ MODULE_ALIAS("snd-hda-codec-id:14f15066"); MODULE_ALIAS("snd-hda-codec-id:14f15067"); MODULE_ALIAS("snd-hda-codec-id:14f15068"); MODULE_ALIAS("snd-hda-codec-id:14f15069"); +MODULE_ALIAS("snd-hda-codec-id:14f15097"); +MODULE_ALIAS("snd-hda-codec-id:14f15098"); +MODULE_ALIAS("snd-hda-codec-id:14f150a1"); +MODULE_ALIAS("snd-hda-codec-id:14f150a2"); +MODULE_ALIAS("snd-hda-codec-id:14f150ab"); +MODULE_ALIAS("snd-hda-codec-id:14f150ac"); +MODULE_ALIAS("snd-hda-codec-id:14f150b8"); +MODULE_ALIAS("snd-hda-codec-id:14f150b9"); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("Conexant HD-audio codec"); -- cgit v1.1 From b686453543fd56332e8730a2abd7bf5bca756149 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Wed, 15 Sep 2010 10:17:26 +0200 Subject: ALSA: hda - Reduce pci id list for Intel with class id Most of Intel controllers work as generic HD-audio without quirks, and it'll be hopefully so in future. Let's mark pci id with the PCI_CLASS_MULTIMEDIA_HD_AUDIO for Intel so that the driver will work with any new control chips in future. Signed-off-by: Takashi Iwai --- sound/pci/hda/hda_intel.c | 18 +++++------------- 1 file changed, 5 insertions(+), 13 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c index 34940a0..5f6f903 100644 --- a/sound/pci/hda/hda_intel.c +++ b/sound/pci/hda/hda_intel.c @@ -2735,25 +2735,17 @@ static void __devexit azx_remove(struct pci_dev *pci) /* PCI IDs */ static DEFINE_PCI_DEVICE_TABLE(azx_ids) = { - /* ICH 6..10 */ - { PCI_DEVICE(0x8086, 0x2668), .driver_data = AZX_DRIVER_ICH }, - { PCI_DEVICE(0x8086, 0x27d8), .driver_data = AZX_DRIVER_ICH }, - { PCI_DEVICE(0x8086, 0x269a), .driver_data = AZX_DRIVER_ICH }, - { PCI_DEVICE(0x8086, 0x284b), .driver_data = AZX_DRIVER_ICH }, - { PCI_DEVICE(0x8086, 0x2911), .driver_data = AZX_DRIVER_ICH }, - { PCI_DEVICE(0x8086, 0x293e), .driver_data = AZX_DRIVER_ICH }, - { PCI_DEVICE(0x8086, 0x293f), .driver_data = AZX_DRIVER_ICH }, - { PCI_DEVICE(0x8086, 0x3a3e), .driver_data = AZX_DRIVER_ICH }, - { PCI_DEVICE(0x8086, 0x3a6e), .driver_data = AZX_DRIVER_ICH }, - /* PCH */ - { PCI_DEVICE(0x8086, 0x3b56), .driver_data = AZX_DRIVER_ICH }, - { PCI_DEVICE(0x8086, 0x3b57), .driver_data = AZX_DRIVER_ICH }, /* CPT */ { PCI_DEVICE(0x8086, 0x1c20), .driver_data = AZX_DRIVER_PCH }, /* PBG */ { PCI_DEVICE(0x8086, 0x1d20), .driver_data = AZX_DRIVER_PCH }, /* SCH */ { PCI_DEVICE(0x8086, 0x811b), .driver_data = AZX_DRIVER_SCH }, + /* Generic Intel */ + { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_ANY_ID), + .class = PCI_CLASS_MULTIMEDIA_HD_AUDIO << 8, + .class_mask = 0xffffff, + .driver_data = AZX_DRIVER_ICH }, /* ATI SB 450/600 */ { PCI_DEVICE(0x1002, 0x437b), .driver_data = AZX_DRIVER_ATI }, { PCI_DEVICE(0x1002, 0x4383), .driver_data = AZX_DRIVER_ATI }, -- cgit v1.1 From 3b119f662d9054d734e3c74d662e7de6d7b35687 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Wed, 15 Sep 2010 15:53:50 +0200 Subject: ALSA: hda - Add quirk for Acer laptop with CX20585 codec Its pin configuration is compatible with ideapad. Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_conexant.c | 1 + 1 file changed, 1 insertion(+) (limited to 'sound') diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c index 7eee0ff..7e22ed1 100644 --- a/sound/pci/hda/patch_conexant.c +++ b/sound/pci/hda/patch_conexant.c @@ -3098,6 +3098,7 @@ static struct snd_pci_quirk cxt5066_cfg_tbl[] = { SND_PCI_QUIRK(0x1028, 0x02f5, "Dell", CXT5066_DELL_LAPTOP), SND_PCI_QUIRK(0x152d, 0x0833, "OLPC XO-1.5", CXT5066_OLPC_XO_1_5), + SND_PCI_QUIRK(0x1025, 0x040a, "Acer", CXT5066_IDEAPAD), SND_PCI_QUIRK(0x1028, 0x02d8, "Dell Vostro", CXT5066_DELL_VOSTO), SND_PCI_QUIRK(0x1028, 0x0402, "Dell Vostro", CXT5066_DELL_VOSTO), SND_PCI_QUIRK(0x1028, 0x0408, "Dell Inspiron One 19T", CXT5066_IDEAPAD), -- cgit v1.1 From 1a4e34e67c6de2385d9d493e69c0f6fce886b14d Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Thu, 16 Sep 2010 07:42:34 +0200 Subject: ALSA: usb-audio - Fix an unused-variable compile warning Used only when CONFIG_SND_DEBUG=y sound/usb/mixer.c: In function 'get_min_max': sound/usb/mixer.c:762: warning: unused variable 'chip' Reported-by: Andrew Morton Signed-off-by: Takashi Iwai --- sound/usb/mixer.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) (limited to 'sound') diff --git a/sound/usb/mixer.c b/sound/usb/mixer.c index 3ed3901..5f12e29 100644 --- a/sound/usb/mixer.c +++ b/sound/usb/mixer.c @@ -759,8 +759,6 @@ static void usb_mixer_elem_free(struct snd_kcontrol *kctl) */ static int get_min_max(struct usb_mixer_elem_info *cval, int default_min) { - struct snd_usb_audio *chip = cval->mixer->chip; - /* for failsafe */ cval->min = default_min; cval->max = cval->min + 1; @@ -783,7 +781,7 @@ static int get_min_max(struct usb_mixer_elem_info *cval, int default_min) if (get_ctl_value(cval, UAC_GET_MAX, (cval->control << 8) | minchn, &cval->max) < 0 || get_ctl_value(cval, UAC_GET_MIN, (cval->control << 8) | minchn, &cval->min) < 0) { snd_printd(KERN_ERR "%d:%d: cannot get min/max values for control %d (id %d)\n", - cval->id, snd_usb_ctrl_intf(chip), cval->control, cval->id); + cval->id, snd_usb_ctrl_intf(cval->mixer->chip), cval->control, cval->id); return -EINVAL; } if (get_ctl_value(cval, UAC_GET_RES, (cval->control << 8) | minchn, &cval->res) < 0) { -- cgit v1.1 From 4437ecdc7190302ed02fb1467c116aff29c325b2 Mon Sep 17 00:00:00 2001 From: Peter Ujfalusi Date: Thu, 16 Sep 2010 10:26:54 +0300 Subject: ALSA: core: Allow card id change to the same string When user want to change the card id to the same string on the card via /sys/class/sound/cardX/id, do not report error. Instead return with success without doing anything. Signed-off-by: Peter Ujfalusi Signed-off-by: Takashi Iwai --- sound/core/init.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) (limited to 'sound') diff --git a/sound/core/init.c b/sound/core/init.c index ec4a50c..2de45fb 100644 --- a/sound/core/init.c +++ b/sound/core/init.c @@ -607,11 +607,16 @@ card_id_store_attr(struct device *dev, struct device_attribute *attr, return -EEXIST; } for (idx = 0; idx < snd_ecards_limit; idx++) { - if (snd_cards[idx] && !strcmp(snd_cards[idx]->id, buf1)) - goto __exist; + if (snd_cards[idx] && !strcmp(snd_cards[idx]->id, buf1)) { + if (card == snd_cards[idx]) + goto __ok; + else + goto __exist; + } } strcpy(card->id, buf1); snd_info_card_id_change(card); +__ok: mutex_unlock(&snd_card_mutex); return count; -- cgit v1.1 From 145a902bfeb1f89a41165bd2d1e633ce070bcb73 Mon Sep 17 00:00:00 2001 From: David Henningsson Date: Thu, 16 Sep 2010 10:07:53 +0200 Subject: ALSA: HDA: Enable internal speaker on Dell M101z BugLink: http://launchpad.net/bugs/640254 In some cases a magic processing coefficient is needed to enable the internal speaker on Dell M101z. According to Realtek, this processing coefficient is only present on ALC269vb. Cc: stable@kernel.org Signed-off-by: David Henningsson Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 10 ++++++++++ 1 file changed, 10 insertions(+) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index bcbf916..a1312a6 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -14453,6 +14453,7 @@ static void alc269_auto_init(struct hda_codec *codec) enum { ALC269_FIXUP_SONY_VAIO, + ALC269_FIXUP_DELL_M101Z, }; static const struct hda_verb alc269_sony_vaio_fixup_verbs[] = { @@ -14464,11 +14465,20 @@ static const struct alc_fixup alc269_fixups[] = { [ALC269_FIXUP_SONY_VAIO] = { .verbs = alc269_sony_vaio_fixup_verbs }, + [ALC269_FIXUP_DELL_M101Z] = { + .verbs = (const struct hda_verb[]) { + /* Enables internal speaker */ + {0x20, AC_VERB_SET_COEF_INDEX, 13}, + {0x20, AC_VERB_SET_PROC_COEF, 0x4040}, + {} + } + }, }; static struct snd_pci_quirk alc269_fixup_tbl[] = { SND_PCI_QUIRK(0x104d, 0x9071, "Sony VAIO", ALC269_FIXUP_SONY_VAIO), SND_PCI_QUIRK(0x104d, 0x9077, "Sony VAIO", ALC269_FIXUP_SONY_VAIO), + SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z), {} }; -- cgit v1.1 From 5855fb8076e784a657bc2441cd29f166c7c1ea8c Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Thu, 16 Sep 2010 18:24:02 +0200 Subject: ALSA: hda - Fix initialization of secondary headphone and speaker The secondary or later headphones or speakers aren't initialized preoprly for some codecs. Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index ab2947d..945826d 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -10634,16 +10634,21 @@ static void alc882_auto_init_hp_out(struct hda_codec *codec) { struct alc_spec *spec = codec->spec; hda_nid_t pin, dac; + int i; - pin = spec->autocfg.hp_pins[0]; - if (pin) { + for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) { + pin = spec->autocfg.hp_pins[i]; + if (!pin) + break; dac = spec->multiout.hp_nid; if (!dac) dac = spec->multiout.dac_nids[0]; /* to front */ alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, dac); } - pin = spec->autocfg.speaker_pins[0]; - if (pin) { + for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) { + pin = spec->autocfg.speaker_pins[i]; + if (!pin) + break; dac = spec->multiout.extra_out_nid[0]; if (!dac) dac = spec->multiout.dac_nids[0]; /* to front */ -- cgit v1.1 From 30ea098fc000bb05081a1999269658f1a88af36a Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Thu, 16 Sep 2010 18:47:56 +0200 Subject: ALSA: hda - Fix input-pin setup for Realtek codecs Through the transition of autocfg to individual inputs array, I forgot to rewrite the argument passed to alc_set_input_pin(). This resulted in wrongly setup input pins. Fixed now. Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index 945826d..5df8879 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -5160,7 +5160,7 @@ static void alc880_auto_init_analog_input(struct hda_codec *codec) for (i = 0; i < cfg->num_inputs; i++) { hda_nid_t nid = cfg->inputs[i].pin; if (alc_is_input_pin(codec, nid)) { - alc_set_input_pin(codec, nid, i); + alc_set_input_pin(codec, nid, cfg->inputs[i].type); if (nid != ALC880_PIN_CD_NID && (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)) snd_hda_codec_write(codec, nid, 0, @@ -6793,7 +6793,7 @@ static void alc260_auto_init_analog_input(struct hda_codec *codec) for (i = 0; i < cfg->num_inputs; i++) { hda_nid_t nid = cfg->inputs[i].pin; if (nid >= 0x12) { - alc_set_input_pin(codec, nid, i); + alc_set_input_pin(codec, nid, cfg->inputs[i].type); if (nid != ALC260_PIN_CD_NID && (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)) snd_hda_codec_write(codec, nid, 0, @@ -10664,7 +10664,7 @@ static void alc882_auto_init_analog_input(struct hda_codec *codec) for (i = 0; i < cfg->num_inputs; i++) { hda_nid_t nid = cfg->inputs[i].pin; - alc_set_input_pin(codec, nid, i); + alc_set_input_pin(codec, nid, cfg->inputs[i].type); if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP) snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE, @@ -15856,7 +15856,7 @@ static void alc861_auto_init_analog_input(struct hda_codec *codec) for (i = 0; i < cfg->num_inputs; i++) { hda_nid_t nid = cfg->inputs[i].pin; if (nid >= 0x0c && nid <= 0x11) - alc_set_input_pin(codec, nid, i); + alc_set_input_pin(codec, nid, cfg->inputs[i].type); } } @@ -16849,7 +16849,7 @@ static void alc861vd_auto_init_analog_input(struct hda_codec *codec) for (i = 0; i < cfg->num_inputs; i++) { hda_nid_t nid = cfg->inputs[i].pin; if (alc_is_input_pin(codec, nid)) { - alc_set_input_pin(codec, nid, i); + alc_set_input_pin(codec, nid, cfg->inputs[i].type); if (nid != ALC861VD_PIN_CD_NID && (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)) snd_hda_codec_write(codec, nid, 0, @@ -19086,7 +19086,7 @@ static void alc662_auto_init_analog_input(struct hda_codec *codec) for (i = 0; i < cfg->num_inputs; i++) { hda_nid_t nid = cfg->inputs[i].pin; if (alc_is_input_pin(codec, nid)) { - alc_set_input_pin(codec, nid, i); + alc_set_input_pin(codec, nid, cfg->inputs[i].type); if (nid != ALC662_PIN_CD_NID && (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)) snd_hda_codec_write(codec, nid, 0, -- cgit v1.1 From 26e34e9e15aa48e9375ea4e97bc4234ad995b7c8 Mon Sep 17 00:00:00 2001 From: Dan Carpenter Date: Thu, 16 Sep 2010 20:13:47 +0200 Subject: ALSA: usb/mixer: remove bogus cast "uinfo->value.enumerated.item" is an unsigned int. If it's negative when we do the comparison: if ((int)uinfo->value.enumerated.item >= cval->max) then we would read past the end of the array on the next line. I also changed the strcpy() to strlcpy() out of paranoia. Signed-off-by: Dan Carpenter Signed-off-by: Takashi Iwai --- sound/usb/mixer.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'sound') diff --git a/sound/usb/mixer.c b/sound/usb/mixer.c index 5f12e29..f2d74d6 100644 --- a/sound/usb/mixer.c +++ b/sound/usb/mixer.c @@ -1640,9 +1640,10 @@ static int mixer_ctl_selector_info(struct snd_kcontrol *kcontrol, struct snd_ctl uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; uinfo->count = 1; uinfo->value.enumerated.items = cval->max; - if ((int)uinfo->value.enumerated.item >= cval->max) + if (uinfo->value.enumerated.item >= cval->max) uinfo->value.enumerated.item = cval->max - 1; - strcpy(uinfo->value.enumerated.name, itemlist[uinfo->value.enumerated.item]); + strlcpy(uinfo->value.enumerated.name, itemlist[uinfo->value.enumerated.item], + sizeof(uinfo->value.enumerated.name)); return 0; } -- cgit v1.1 From 8699a0b657b43fa6401537dfe345bee7aa8115ec Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Thu, 16 Sep 2010 22:52:32 +0200 Subject: ALSA: pcm - Fix unbalanced pm_qos_request The pm_qos_request isn't freed properly when OSS PCM emulation is used because it skips snd_pcm_hw_free() call but directly releases the stream. This resulted in Oops later. Tested-by: Simon Kirby Signed-off-by: Takashi Iwai --- sound/core/pcm_native.c | 2 ++ 1 file changed, 2 insertions(+) (limited to 'sound') diff --git a/sound/core/pcm_native.c b/sound/core/pcm_native.c index 134fc6c..d4eb2ef 100644 --- a/sound/core/pcm_native.c +++ b/sound/core/pcm_native.c @@ -1992,6 +1992,8 @@ void snd_pcm_release_substream(struct snd_pcm_substream *substream) substream->ops->close(substream); substream->hw_opened = 0; } + if (pm_qos_request_active(&substream->latency_pm_qos_req)) + pm_qos_remove_request(&substream->latency_pm_qos_req); if (substream->pcm_release) { substream->pcm_release(substream); substream->pcm_release = NULL; -- cgit v1.1 From 901d46d5a8eb821b03ca9e8cf005beb0c92f31ea Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Thu, 16 Sep 2010 23:06:50 +0200 Subject: ALSA: pcm - Fix race with proc files The PCM proc files may open a race against substream close, which can end up with an Oops. Use the open_mutex to protect for it. Signed-off-by: Takashi Iwai --- sound/core/pcm.c | 33 ++++++++++++++++++++++++--------- 1 file changed, 24 insertions(+), 9 deletions(-) (limited to 'sound') diff --git a/sound/core/pcm.c b/sound/core/pcm.c index 204af48..ac242a3 100644 --- a/sound/core/pcm.c +++ b/sound/core/pcm.c @@ -372,14 +372,17 @@ static void snd_pcm_substream_proc_hw_params_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { struct snd_pcm_substream *substream = entry->private_data; - struct snd_pcm_runtime *runtime = substream->runtime; + struct snd_pcm_runtime *runtime; + + mutex_lock(&substream->pcm->open_mutex); + runtime = substream->runtime; if (!runtime) { snd_iprintf(buffer, "closed\n"); - return; + goto unlock; } if (runtime->status->state == SNDRV_PCM_STATE_OPEN) { snd_iprintf(buffer, "no setup\n"); - return; + goto unlock; } snd_iprintf(buffer, "access: %s\n", snd_pcm_access_name(runtime->access)); snd_iprintf(buffer, "format: %s\n", snd_pcm_format_name(runtime->format)); @@ -398,20 +401,25 @@ static void snd_pcm_substream_proc_hw_params_read(struct snd_info_entry *entry, snd_iprintf(buffer, "OSS period frames: %lu\n", (unsigned long)runtime->oss.period_frames); } #endif + unlock: + mutex_unlock(&substream->pcm->open_mutex); } static void snd_pcm_substream_proc_sw_params_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { struct snd_pcm_substream *substream = entry->private_data; - struct snd_pcm_runtime *runtime = substream->runtime; + struct snd_pcm_runtime *runtime; + + mutex_lock(&substream->pcm->open_mutex); + runtime = substream->runtime; if (!runtime) { snd_iprintf(buffer, "closed\n"); - return; + goto unlock; } if (runtime->status->state == SNDRV_PCM_STATE_OPEN) { snd_iprintf(buffer, "no setup\n"); - return; + goto unlock; } snd_iprintf(buffer, "tstamp_mode: %s\n", snd_pcm_tstamp_mode_name(runtime->tstamp_mode)); snd_iprintf(buffer, "period_step: %u\n", runtime->period_step); @@ -421,24 +429,29 @@ static void snd_pcm_substream_proc_sw_params_read(struct snd_info_entry *entry, snd_iprintf(buffer, "silence_threshold: %lu\n", runtime->silence_threshold); snd_iprintf(buffer, "silence_size: %lu\n", runtime->silence_size); snd_iprintf(buffer, "boundary: %lu\n", runtime->boundary); + unlock: + mutex_unlock(&substream->pcm->open_mutex); } static void snd_pcm_substream_proc_status_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer) { struct snd_pcm_substream *substream = entry->private_data; - struct snd_pcm_runtime *runtime = substream->runtime; + struct snd_pcm_runtime *runtime; struct snd_pcm_status status; int err; + + mutex_lock(&substream->pcm->open_mutex); + runtime = substream->runtime; if (!runtime) { snd_iprintf(buffer, "closed\n"); - return; + goto unlock; } memset(&status, 0, sizeof(status)); err = snd_pcm_status(substream, &status); if (err < 0) { snd_iprintf(buffer, "error %d\n", err); - return; + goto unlock; } snd_iprintf(buffer, "state: %s\n", snd_pcm_state_name(status.state)); snd_iprintf(buffer, "owner_pid : %d\n", pid_vnr(substream->pid)); @@ -452,6 +465,8 @@ static void snd_pcm_substream_proc_status_read(struct snd_info_entry *entry, snd_iprintf(buffer, "-----\n"); snd_iprintf(buffer, "hw_ptr : %ld\n", runtime->status->hw_ptr); snd_iprintf(buffer, "appl_ptr : %ld\n", runtime->control->appl_ptr); + unlock: + mutex_unlock(&substream->pcm->open_mutex); } #ifdef CONFIG_SND_PCM_XRUN_DEBUG -- cgit v1.1 From 9907790aa06bfc04bf78b445e732ea10039c61e4 Mon Sep 17 00:00:00 2001 From: Charles Chin Date: Fri, 17 Sep 2010 10:22:32 +0200 Subject: ALSA: hda - Fix automatic MIC switching and include dock MIC for IDT codecs Signed-off-by: Charles Chin Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_sigmatel.c | 40 +++++++++++++++++++++++++++++----------- 1 file changed, 29 insertions(+), 11 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c index e4e7d43..7eb359a 100644 --- a/sound/pci/hda/patch_sigmatel.c +++ b/sound/pci/hda/patch_sigmatel.c @@ -263,6 +263,7 @@ struct sigmatel_spec { struct sigmatel_mic_route ext_mic; struct sigmatel_mic_route int_mic; + struct sigmatel_mic_route dock_mic; const char **spdif_labels; @@ -3488,7 +3489,7 @@ static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec, } static int check_mic_pin(struct hda_codec *codec, hda_nid_t nid, - hda_nid_t *fixed, hda_nid_t *ext) + hda_nid_t *fixed, hda_nid_t *ext, hda_nid_t *dock) { unsigned int cfg; @@ -3496,15 +3497,22 @@ static int check_mic_pin(struct hda_codec *codec, hda_nid_t nid, return 0; cfg = snd_hda_codec_get_pincfg(codec, nid); switch (get_defcfg_connect(cfg)) { + case AC_JACK_PORT_BOTH: case AC_JACK_PORT_FIXED: if (*fixed) return 1; /* already occupied */ *fixed = nid; break; case AC_JACK_PORT_COMPLEX: - if (*ext) - return 1; /* already occupied */ - *ext = nid; + if ((get_defcfg_location(cfg) & 0xF0) == AC_JACK_LOC_SEPARATE) { + if (*dock) + return 1; /* already occupied */ + *dock = nid; + } else { + if (*ext) + return 1; /* already occupied */ + *ext = nid; + } break; } return 0; @@ -3519,6 +3527,8 @@ static int set_mic_route(struct hda_codec *codec, int i; mic->pin = pin; + if (pin == 0) + return 0; for (i = 0; i < cfg->num_inputs; i++) { if (pin == cfg->inputs[i].pin) break; @@ -3554,26 +3564,29 @@ static int stac_check_auto_mic(struct hda_codec *codec) { struct sigmatel_spec *spec = codec->spec; struct auto_pin_cfg *cfg = &spec->autocfg; - hda_nid_t fixed, ext; + hda_nid_t fixed, ext, dock; int i; for (i = 0; i < cfg->num_inputs; i++) { if (cfg->inputs[i].type >= AUTO_PIN_LINE_IN) return 0; /* must be exclusively mics */ } - fixed = ext = 0; + fixed = ext = dock = 0; for (i = 0; i < cfg->num_inputs; i++) - if (check_mic_pin(codec, cfg->inputs[i].pin, &fixed, &ext)) + if (check_mic_pin(codec, cfg->inputs[i].pin, + &fixed, &ext, &dock)) return 0; for (i = 0; i < spec->num_dmics; i++) - if (check_mic_pin(codec, spec->dmic_nids[i], &fixed, &ext)) + if (check_mic_pin(codec, spec->dmic_nids[i], + &fixed, &ext, &dock)) return 0; - if (!fixed || !ext) - return 0; + if (!fixed && !ext && !dock) + return 0; /* no input to switch */ if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP)) return 0; /* no unsol support */ if (set_mic_route(codec, &spec->ext_mic, ext) || - set_mic_route(codec, &spec->int_mic, fixed)) + set_mic_route(codec, &spec->int_mic, fixed) || + set_mic_route(codec, &spec->dock_mic, dock)) return 0; /* something is wrong */ return 1; } @@ -4281,6 +4294,9 @@ static int stac92xx_init(struct hda_codec *codec) AC_VERB_SET_CONNECT_SEL, 0); if (enable_pin_detect(codec, spec->ext_mic.pin, STAC_MIC_EVENT)) stac_issue_unsol_event(codec, spec->ext_mic.pin); + if (enable_pin_detect(codec, spec->dock_mic.pin, + STAC_MIC_EVENT)) + stac_issue_unsol_event(codec, spec->dock_mic.pin); } for (i = 0; i < cfg->num_inputs; i++) { hda_nid_t nid = cfg->inputs[i].pin; @@ -4698,6 +4714,8 @@ static void stac92xx_mic_detect(struct hda_codec *codec) if (get_pin_presence(codec, spec->ext_mic.pin)) mic = &spec->ext_mic; + else if (get_pin_presence(codec, spec->dock_mic.pin)) + mic = &spec->dock_mic; else mic = &spec->int_mic; if (mic->dmux_idx >= 0) -- cgit v1.1 From 41c89ef3aafea5f35601fa75edba90e7417f604e Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Fri, 17 Sep 2010 10:26:37 +0200 Subject: ALSA: hda - Fix mic attribute check for internal mics Now Windows claims that the BIOS sets pins for internal mics to be BOTH connection instead of FIXED. Signed-off-by: Takashi Iwai --- sound/pci/hda/hda_codec.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c index 08d81b8..9f668ef 100644 --- a/sound/pci/hda/hda_codec.c +++ b/sound/pci/hda/hda_codec.c @@ -4648,8 +4648,11 @@ enum { static int get_mic_pin_attr(unsigned int def_conf) { unsigned int loc = get_defcfg_location(def_conf); - if (get_defcfg_connect(def_conf) == AC_JACK_PORT_FIXED || - (loc & 0x30) == AC_JACK_LOC_INTERNAL) + unsigned int conn = get_defcfg_connect(def_conf); + /* Windows may claim the internal mic to be BOTH, too */ + if (conn == AC_JACK_PORT_FIXED || conn == AC_JACK_PORT_BOTH) + return MIC_ATTR_INT; + if ((loc & 0x30) == AC_JACK_LOC_INTERNAL) return MIC_ATTR_INT; if ((loc & 0x30) == AC_JACK_LOC_SEPARATE) return MIC_ATTR_DOCK; -- cgit v1.1 From 1feba3b7367b333c3fc7deba638a3a1068f22932 Mon Sep 17 00:00:00 2001 From: David Henningsson Date: Fri, 17 Sep 2010 10:52:50 +0200 Subject: ALSA: HDA: Fix spelling (change VOSTO to VOSTRO) It was just a boring day. Signed-off-by: David Henningsson Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_conexant.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c index 7e22ed1..a12a9f6 100644 --- a/sound/pci/hda/patch_conexant.c +++ b/sound/pci/hda/patch_conexant.c @@ -3075,7 +3075,7 @@ enum { CXT5066_LAPTOP, /* Laptops w/ EAPD support */ CXT5066_DELL_LAPTOP, /* Dell Laptop */ CXT5066_OLPC_XO_1_5, /* OLPC XO 1.5 */ - CXT5066_DELL_VOSTO, /* Dell Vostro 1015i */ + CXT5066_DELL_VOSTRO, /* Dell Vostro 1015i */ CXT5066_IDEAPAD, /* Lenovo IdeaPad U150 */ CXT5066_THINKPAD, /* Lenovo ThinkPad T410s, others? */ CXT5066_HP_LAPTOP, /* HP Laptop */ @@ -3086,7 +3086,7 @@ static const char *cxt5066_models[CXT5066_MODELS] = { [CXT5066_LAPTOP] = "laptop", [CXT5066_DELL_LAPTOP] = "dell-laptop", [CXT5066_OLPC_XO_1_5] = "olpc-xo-1_5", - [CXT5066_DELL_VOSTO] = "dell-vostro", + [CXT5066_DELL_VOSTRO] = "dell-vostro", [CXT5066_IDEAPAD] = "ideapad", [CXT5066_THINKPAD] = "thinkpad", [CXT5066_HP_LAPTOP] = "hp-laptop", @@ -3099,8 +3099,8 @@ static struct snd_pci_quirk cxt5066_cfg_tbl[] = { CXT5066_DELL_LAPTOP), SND_PCI_QUIRK(0x152d, 0x0833, "OLPC XO-1.5", CXT5066_OLPC_XO_1_5), SND_PCI_QUIRK(0x1025, 0x040a, "Acer", CXT5066_IDEAPAD), - SND_PCI_QUIRK(0x1028, 0x02d8, "Dell Vostro", CXT5066_DELL_VOSTO), - SND_PCI_QUIRK(0x1028, 0x0402, "Dell Vostro", CXT5066_DELL_VOSTO), + SND_PCI_QUIRK(0x1028, 0x02d8, "Dell Vostro", CXT5066_DELL_VOSTRO), + SND_PCI_QUIRK(0x1028, 0x0402, "Dell Vostro", CXT5066_DELL_VOSTRO), SND_PCI_QUIRK(0x1028, 0x0408, "Dell Inspiron One 19T", CXT5066_IDEAPAD), SND_PCI_QUIRK(0x103c, 0x360b, "HP G60", CXT5066_HP_LAPTOP), SND_PCI_QUIRK(0x1179, 0xff1e, "Toshiba Satellite C650D", CXT5066_IDEAPAD), @@ -3207,7 +3207,7 @@ static int patch_cxt5066(struct hda_codec *codec) spec->capture_prepare = cxt5066_olpc_capture_prepare; spec->capture_cleanup = cxt5066_olpc_capture_cleanup; break; - case CXT5066_DELL_VOSTO: + case CXT5066_DELL_VOSTRO: codec->patch_ops.init = cxt5066_init; codec->patch_ops.unsol_event = cxt5066_vostro_event; spec->init_verbs[0] = cxt5066_init_verbs_vostro; -- cgit v1.1 From 5637edb2e1c2d13b276748508ae17f319fb7f066 Mon Sep 17 00:00:00 2001 From: David Henningsson Date: Fri, 17 Sep 2010 10:58:03 +0200 Subject: ALSA: HDA: Sort CXT5066 quirk table It was just a boring day. Signed-off-by: David Henningsson Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_conexant.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c index a12a9f6..e501a85 100644 --- a/sound/pci/hda/patch_conexant.c +++ b/sound/pci/hda/patch_conexant.c @@ -3093,19 +3093,19 @@ static const char *cxt5066_models[CXT5066_MODELS] = { }; static struct snd_pci_quirk cxt5066_cfg_tbl[] = { - SND_PCI_QUIRK(0x14f1, 0x0101, "Conexant Reference board", - CXT5066_LAPTOP), - SND_PCI_QUIRK(0x1028, 0x02f5, "Dell", - CXT5066_DELL_LAPTOP), - SND_PCI_QUIRK(0x152d, 0x0833, "OLPC XO-1.5", CXT5066_OLPC_XO_1_5), SND_PCI_QUIRK(0x1025, 0x040a, "Acer", CXT5066_IDEAPAD), SND_PCI_QUIRK(0x1028, 0x02d8, "Dell Vostro", CXT5066_DELL_VOSTRO), + SND_PCI_QUIRK(0x1028, 0x02f5, "Dell", + CXT5066_DELL_LAPTOP), SND_PCI_QUIRK(0x1028, 0x0402, "Dell Vostro", CXT5066_DELL_VOSTRO), SND_PCI_QUIRK(0x1028, 0x0408, "Dell Inspiron One 19T", CXT5066_IDEAPAD), SND_PCI_QUIRK(0x103c, 0x360b, "HP G60", CXT5066_HP_LAPTOP), SND_PCI_QUIRK(0x1179, 0xff1e, "Toshiba Satellite C650D", CXT5066_IDEAPAD), SND_PCI_QUIRK(0x1179, 0xff50, "Toshiba Satellite P500-PSPGSC-01800T", CXT5066_OLPC_XO_1_5), SND_PCI_QUIRK(0x1179, 0xffe0, "Toshiba Satellite Pro T130-15F", CXT5066_OLPC_XO_1_5), + SND_PCI_QUIRK(0x14f1, 0x0101, "Conexant Reference board", + CXT5066_LAPTOP), + SND_PCI_QUIRK(0x152d, 0x0833, "OLPC XO-1.5", CXT5066_OLPC_XO_1_5), SND_PCI_QUIRK(0x17aa, 0x20f2, "Lenovo T400s", CXT5066_THINKPAD), SND_PCI_QUIRK(0x17aa, 0x21b2, "Thinkpad X100e", CXT5066_IDEAPAD), SND_PCI_QUIRK(0x17aa, 0x21b3, "Thinkpad Edge 13 (197)", CXT5066_IDEAPAD), -- cgit v1.1 From 99ae28bea984df4c38234eb6d2f29a552def6c1b Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Fri, 17 Sep 2010 14:42:34 +0200 Subject: ALSA: hda - Make snd_hda_get_input_pin_attr() helper Make the helper function to give the input-pin attribute for jack connectivity and location. This simplifies checks of input-pin jacks a bit in some places. Signed-off-by: Takashi Iwai --- sound/pci/hda/hda_codec.c | 62 +++++++++++++++++------------------------- sound/pci/hda/hda_local.h | 11 ++++++++ sound/pci/hda/patch_cirrus.c | 2 +- sound/pci/hda/patch_conexant.c | 11 ++------ sound/pci/hda/patch_realtek.c | 10 +++---- sound/pci/hda/patch_sigmatel.c | 30 ++++++++++---------- 6 files changed, 59 insertions(+), 67 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c index 9f668ef..e15a7575 100644 --- a/sound/pci/hda/hda_codec.c +++ b/sound/pci/hda/hda_codec.c @@ -4637,44 +4637,26 @@ int snd_hda_parse_pin_def_config(struct hda_codec *codec, } EXPORT_SYMBOL_HDA(snd_hda_parse_pin_def_config); -enum { - MIC_ATTR_INT, - MIC_ATTR_DOCK, - MIC_ATTR_NORMAL, - MIC_ATTR_FRONT, - MIC_ATTR_REAR, -}; - -static int get_mic_pin_attr(unsigned int def_conf) +int snd_hda_get_input_pin_attr(unsigned int def_conf) { unsigned int loc = get_defcfg_location(def_conf); unsigned int conn = get_defcfg_connect(def_conf); + if (conn == AC_JACK_PORT_NONE) + return INPUT_PIN_ATTR_UNUSED; /* Windows may claim the internal mic to be BOTH, too */ if (conn == AC_JACK_PORT_FIXED || conn == AC_JACK_PORT_BOTH) - return MIC_ATTR_INT; + return INPUT_PIN_ATTR_INT; if ((loc & 0x30) == AC_JACK_LOC_INTERNAL) - return MIC_ATTR_INT; + return INPUT_PIN_ATTR_INT; if ((loc & 0x30) == AC_JACK_LOC_SEPARATE) - return MIC_ATTR_DOCK; + return INPUT_PIN_ATTR_DOCK; if (loc == AC_JACK_LOC_REAR) - return MIC_ATTR_REAR; + return INPUT_PIN_ATTR_REAR; if (loc == AC_JACK_LOC_FRONT) - return MIC_ATTR_FRONT; - return MIC_ATTR_NORMAL; -} - -enum { - LINE_ATTR_DOCK, - LINE_ATTR_NORMAL, -}; - -static int get_line_pin_attr(unsigned int def_conf) -{ - unsigned int loc = get_defcfg_location(def_conf); - if ((loc & 0xf0) == AC_JACK_LOC_SEPARATE) - return LINE_ATTR_DOCK; - return LINE_ATTR_NORMAL; + return INPUT_PIN_ATTR_FRONT; + return INPUT_PIN_ATTR_NORMAL; } +EXPORT_SYMBOL_HDA(snd_hda_get_input_pin_attr); /** * hda_get_input_pin_label - Give a label for the given input pin @@ -4691,9 +4673,7 @@ const char *hda_get_input_pin_label(struct hda_codec *codec, hda_nid_t pin, static const char *mic_names[] = { "Internal Mic", "Dock Mic", "Mic", "Front Mic", "Rear Mic", }; - static const char *line_names[] = { - "Dock Line", "Line", - }; + int attr; def_conf = snd_hda_codec_get_pincfg(codec, pin); @@ -4701,11 +4681,19 @@ const char *hda_get_input_pin_label(struct hda_codec *codec, hda_nid_t pin, case AC_JACK_MIC_IN: if (!check_location) return "Mic"; - return mic_names[get_mic_pin_attr(def_conf)]; + attr = snd_hda_get_input_pin_attr(def_conf); + if (!attr) + return "None"; + return mic_names[attr - 1]; case AC_JACK_LINE_IN: if (!check_location) return "Line"; - return line_names[get_line_pin_attr(def_conf)]; + attr = snd_hda_get_input_pin_attr(def_conf); + if (!attr) + return "None"; + if (attr == INPUT_PIN_ATTR_DOCK) + return "Dock Line"; + return "Line"; case AC_JACK_AUX: return "Aux"; case AC_JACK_CD: @@ -4732,16 +4720,16 @@ static int check_mic_location_need(struct hda_codec *codec, int i, attr, attr2; defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[input].pin); - attr = get_mic_pin_attr(defc); + attr = snd_hda_get_input_pin_attr(defc); /* for internal or docking mics, we need locations */ - if (attr <= MIC_ATTR_NORMAL) + if (attr <= INPUT_PIN_ATTR_NORMAL) return 1; attr = 0; for (i = 0; i < cfg->num_inputs; i++) { defc = snd_hda_codec_get_pincfg(codec, cfg->inputs[i].pin); - attr2 = get_mic_pin_attr(defc); - if (attr2 >= MIC_ATTR_NORMAL) { + attr2 = snd_hda_get_input_pin_attr(defc); + if (attr2 >= INPUT_PIN_ATTR_NORMAL) { if (attr && attr != attr2) return 1; /* different locations found */ attr = attr2; diff --git a/sound/pci/hda/hda_local.h b/sound/pci/hda/hda_local.h index 6943efc..d7dfa54 100644 --- a/sound/pci/hda/hda_local.h +++ b/sound/pci/hda/hda_local.h @@ -395,6 +395,17 @@ const char *hda_get_autocfg_input_label(struct hda_codec *codec, int snd_hda_add_imux_item(struct hda_input_mux *imux, const char *label, int index, int *type_index_ret); +enum { + INPUT_PIN_ATTR_UNUSED, /* pin not connected */ + INPUT_PIN_ATTR_INT, /* internal mic/line-in */ + INPUT_PIN_ATTR_DOCK, /* docking mic/line-in */ + INPUT_PIN_ATTR_NORMAL, /* mic/line-in jack */ + INPUT_PIN_ATTR_FRONT, /* mic/line-in jack in front */ + INPUT_PIN_ATTR_REAR, /* mic/line-in jack in rear */ +}; + +int snd_hda_get_input_pin_attr(unsigned int def_conf); + struct auto_pin_cfg { int line_outs; /* sorted in the order of Front/Surr/CLFE/Side */ diff --git a/sound/pci/hda/patch_cirrus.c b/sound/pci/hda/patch_cirrus.c index ae75283..483c3f2 100644 --- a/sound/pci/hda/patch_cirrus.c +++ b/sound/pci/hda/patch_cirrus.c @@ -334,7 +334,7 @@ static int is_ext_mic(struct hda_codec *codec, unsigned int idx) if (!(val & AC_PINCAP_PRES_DETECT)) return 0; val = snd_hda_codec_get_pincfg(codec, pin); - return (get_defcfg_connect(val) == AC_JACK_PORT_COMPLEX); + return (snd_hda_get_input_pin_attr(val) != INPUT_PIN_ATTR_INT); } static hda_nid_t get_adc(struct hda_codec *codec, hda_nid_t pin, diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c index e501a85..09d573c 100644 --- a/sound/pci/hda/patch_conexant.c +++ b/sound/pci/hda/patch_conexant.c @@ -3462,19 +3462,12 @@ static void cx_auto_unsol_event(struct hda_codec *codec, unsigned int res) } } -static int is_int_mic_conn(unsigned int def_conf) -{ - unsigned int loc = get_defcfg_location(def_conf); - return get_defcfg_connect(def_conf) == AC_JACK_PORT_FIXED || - (loc & 0x30) == AC_JACK_LOC_INTERNAL; -} - /* return true if it's an internal-mic pin */ static int is_int_mic(struct hda_codec *codec, hda_nid_t pin) { unsigned int def_conf = snd_hda_codec_get_pincfg(codec, pin); return get_defcfg_device(def_conf) == AC_JACK_MIC_IN && - is_int_mic_conn(def_conf); + snd_hda_get_input_pin_attr(def_conf) == INPUT_PIN_ATTR_INT; } /* return true if it's an external-mic pin */ @@ -3482,7 +3475,7 @@ static int is_ext_mic(struct hda_codec *codec, hda_nid_t pin) { unsigned int def_conf = snd_hda_codec_get_pincfg(codec, pin); return get_defcfg_device(def_conf) == AC_JACK_MIC_IN && - !is_int_mic_conn(def_conf); + snd_hda_get_input_pin_attr(def_conf) != INPUT_PIN_ATTR_INT; } /* check whether the pin config is suitable for auto-mic switching; diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index 5df8879..6045f28 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -1403,19 +1403,19 @@ static void alc_init_auto_mic(struct hda_codec *codec) hda_nid_t nid = cfg->inputs[i].pin; unsigned int defcfg; defcfg = snd_hda_codec_get_pincfg(codec, nid); - switch (get_defcfg_connect(defcfg)) { - case AC_JACK_PORT_FIXED: + switch (snd_hda_get_input_pin_attr(defcfg)) { + case INPUT_PIN_ATTR_INT: if (fixed) return; /* already occupied */ fixed = nid; break; - case AC_JACK_PORT_COMPLEX: + case INPUT_PIN_ATTR_UNUSED: + return; /* invalid entry */ + default: if (ext) return; /* already occupied */ ext = nid; break; - default: - return; /* invalid entry */ } } if (!ext || !fixed) diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c index 7eb359a..6bfbc2f 100644 --- a/sound/pci/hda/patch_sigmatel.c +++ b/sound/pci/hda/patch_sigmatel.c @@ -2778,7 +2778,7 @@ static inline int stac92xx_add_jack_mode_control(struct hda_codec *codec, struct sigmatel_spec *spec = codec->spec; char name[22]; - if (!((get_defcfg_connect(def_conf)) & AC_JACK_PORT_FIXED)) { + if (snd_hda_get_input_pin_attr(def_conf) != INPUT_PIN_ATTR_INT) { if (stac92xx_get_default_vref(codec, nid) == AC_PINCTL_VREF_GRD && nid == spec->line_switch) control = STAC_CTL_WIDGET_IO_SWITCH; @@ -2857,7 +2857,7 @@ static hda_nid_t check_mic_out_switch(struct hda_codec *codec, hda_nid_t *dac) def_conf = snd_hda_codec_get_pincfg(codec, nid); /* some laptops have an internal analog microphone * which can't be used as a output */ - if (get_defcfg_connect(def_conf) != AC_JACK_PORT_FIXED) { + if (snd_hda_get_input_pin_attr(def_conf) != INPUT_PIN_ATTR_INT) { pincap = snd_hda_query_pin_caps(codec, nid); if (pincap & AC_PINCAP_OUT) { *dac = get_unassigned_dac(codec, nid); @@ -3496,23 +3496,23 @@ static int check_mic_pin(struct hda_codec *codec, hda_nid_t nid, if (!nid) return 0; cfg = snd_hda_codec_get_pincfg(codec, nid); - switch (get_defcfg_connect(cfg)) { - case AC_JACK_PORT_BOTH: - case AC_JACK_PORT_FIXED: + switch (snd_hda_get_input_pin_attr(cfg)) { + case INPUT_PIN_ATTR_INT: if (*fixed) return 1; /* already occupied */ *fixed = nid; break; - case AC_JACK_PORT_COMPLEX: - if ((get_defcfg_location(cfg) & 0xF0) == AC_JACK_LOC_SEPARATE) { - if (*dock) - return 1; /* already occupied */ - *dock = nid; - } else { - if (*ext) - return 1; /* already occupied */ - *ext = nid; - } + case INPUT_PIN_ATTR_UNUSED: + break; + case INPUT_PIN_ATTR_DOCK: + if (*dock) + return 1; /* already occupied */ + *dock = nid; + break; + default: + if (*ext) + return 1; /* already occupied */ + *ext = nid; break; } return 0; -- cgit v1.1 From f68b3b291d39f1e3361b194a95459f9cbdaf31e6 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Fri, 17 Sep 2010 14:45:14 +0200 Subject: ALSA: hda - Check the external mic pin more strictly for Conexant chips The external mic jack for auto-mic switch must be really an external jack and with a presense-detection capability. This patch makes the check more paranoia. Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_conexant.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c index 09d573c..a6c68cb 100644 --- a/sound/pci/hda/patch_conexant.c +++ b/sound/pci/hda/patch_conexant.c @@ -3475,7 +3475,8 @@ static int is_ext_mic(struct hda_codec *codec, hda_nid_t pin) { unsigned int def_conf = snd_hda_codec_get_pincfg(codec, pin); return get_defcfg_device(def_conf) == AC_JACK_MIC_IN && - snd_hda_get_input_pin_attr(def_conf) != INPUT_PIN_ATTR_INT; + snd_hda_get_input_pin_attr(def_conf) >= INPUT_PIN_ATTR_NORMAL && + (snd_hda_query_pin_caps(codec, pin) & AC_PINCAP_PRES_DETECT); } /* check whether the pin config is suitable for auto-mic switching; -- cgit v1.1 From 84eb01be18df7012ac31bf678da5aaf1accc6a77 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Tue, 7 Sep 2010 12:27:25 +0200 Subject: ALSA: hda - Merge all HDMI modules into the unified module This patch merges all three patch_*hdmi variants to the single HDMI parser. There is only one snd-hda-codec-hdmi module now. In this patch, the behavior of each parser isn't changed much. The old ATI parser still doesn't use the dynamic parser yet. In later patches, they'll be cleaned up. Also, this patch gets rid of the individual snd-hda-eld module and builds into snd-hda-codec-hdmi, since this is referred only from the HDMI parser. Signed-off-by: Takashi Iwai --- sound/pci/hda/Kconfig | 39 +-- sound/pci/hda/Makefile | 15 +- sound/pci/hda/hda_eld.c | 7 - sound/pci/hda/patch_atihdmi.c | 224 ------------- sound/pci/hda/patch_hdmi.c | 685 +++++++++++++++++++++++++++++++++++++++- sound/pci/hda/patch_intelhdmi.c | 220 ------------- sound/pci/hda/patch_nvhdmi.c | 608 ----------------------------------- 7 files changed, 691 insertions(+), 1107 deletions(-) delete mode 100644 sound/pci/hda/patch_atihdmi.c delete mode 100644 sound/pci/hda/patch_intelhdmi.c delete mode 100644 sound/pci/hda/patch_nvhdmi.c (limited to 'sound') diff --git a/sound/pci/hda/Kconfig b/sound/pci/hda/Kconfig index 9194c3c..0ea5cc6 100644 --- a/sound/pci/hda/Kconfig +++ b/sound/pci/hda/Kconfig @@ -119,47 +119,20 @@ config SND_HDA_CODEC_VIA snd-hda-codec-via. This module is automatically loaded at probing. -config SND_HDA_CODEC_ATIHDMI - bool "Build ATI HDMI HD-audio codec support" - default y - help - Say Y here to include ATI HDMI HD-audio codec support in - snd-hda-intel driver, such as ATI RS600 HDMI. - - When the HD-audio driver is built as a module, the codec - support code is also built as another module, - snd-hda-codec-atihdmi. - This module is automatically loaded at probing. - -config SND_HDA_CODEC_NVHDMI - bool "Build NVIDIA HDMI HD-audio codec support" - default y - help - Say Y here to include NVIDIA HDMI HD-audio codec support in - snd-hda-intel driver, such as NVIDIA MCP78 HDMI. - - When the HD-audio driver is built as a module, the codec - support code is also built as another module, - snd-hda-codec-nvhdmi. - This module is automatically loaded at probing. - -config SND_HDA_CODEC_INTELHDMI - bool "Build INTEL HDMI HD-audio codec support" +config SND_HDA_CODEC_HDMI + bool "Build HDMI/DisplayPort HD-audio codec support" select SND_DYNAMIC_MINORS default y help - Say Y here to include INTEL HDMI HD-audio codec support in - snd-hda-intel driver, such as Eaglelake integrated HDMI. + Say Y here to include HDMI and DisplayPort HD-audio codec + support in snd-hda-intel driver. This includes all AMD/ATI, + Intel and Nvidia HDMI/DisplayPort codecs. When the HD-audio driver is built as a module, the codec support code is also built as another module, - snd-hda-codec-intelhdmi. + snd-hda-codec-hdmi. This module is automatically loaded at probing. -config SND_HDA_ELD - def_bool y - depends on SND_HDA_CODEC_INTELHDMI || SND_HDA_CODEC_NVHDMI - config SND_HDA_CODEC_CIRRUS bool "Build Cirrus Logic codec support" depends on SND_HDA_INTEL diff --git a/sound/pci/hda/Makefile b/sound/pci/hda/Makefile index 24bc195..17ef365 100644 --- a/sound/pci/hda/Makefile +++ b/sound/pci/hda/Makefile @@ -3,7 +3,6 @@ snd-hda-intel-objs := hda_intel.o snd-hda-codec-y := hda_codec.o snd-hda-codec-$(CONFIG_SND_HDA_GENERIC) += hda_generic.o snd-hda-codec-$(CONFIG_PROC_FS) += hda_proc.o -snd-hda-codec-$(CONFIG_SND_HDA_ELD) += hda_eld.o snd-hda-codec-$(CONFIG_SND_HDA_HWDEP) += hda_hwdep.o snd-hda-codec-$(CONFIG_SND_HDA_INPUT_BEEP) += hda_beep.o @@ -12,13 +11,11 @@ snd-hda-codec-cmedia-objs := patch_cmedia.o snd-hda-codec-analog-objs := patch_analog.o snd-hda-codec-idt-objs := patch_sigmatel.o snd-hda-codec-si3054-objs := patch_si3054.o -snd-hda-codec-atihdmi-objs := patch_atihdmi.o snd-hda-codec-cirrus-objs := patch_cirrus.o snd-hda-codec-ca0110-objs := patch_ca0110.o snd-hda-codec-conexant-objs := patch_conexant.o snd-hda-codec-via-objs := patch_via.o -snd-hda-codec-nvhdmi-objs := patch_nvhdmi.o -snd-hda-codec-intelhdmi-objs := patch_intelhdmi.o +snd-hda-codec-hdmi-objs := patch_hdmi.o hda_eld.o # common driver obj-$(CONFIG_SND_HDA_INTEL) := snd-hda-codec.o @@ -39,9 +36,6 @@ endif ifdef CONFIG_SND_HDA_CODEC_SI3054 obj-$(CONFIG_SND_HDA_INTEL) += snd-hda-codec-si3054.o endif -ifdef CONFIG_SND_HDA_CODEC_ATIHDMI -obj-$(CONFIG_SND_HDA_INTEL) += snd-hda-codec-atihdmi.o -endif ifdef CONFIG_SND_HDA_CODEC_CIRRUS obj-$(CONFIG_SND_HDA_INTEL) += snd-hda-codec-cirrus.o endif @@ -54,11 +48,8 @@ endif ifdef CONFIG_SND_HDA_CODEC_VIA obj-$(CONFIG_SND_HDA_INTEL) += snd-hda-codec-via.o endif -ifdef CONFIG_SND_HDA_CODEC_NVHDMI -obj-$(CONFIG_SND_HDA_INTEL) += snd-hda-codec-nvhdmi.o -endif -ifdef CONFIG_SND_HDA_CODEC_INTELHDMI -obj-$(CONFIG_SND_HDA_INTEL) += snd-hda-codec-intelhdmi.o +ifdef CONFIG_SND_HDA_CODEC_HDMI +obj-$(CONFIG_SND_HDA_INTEL) += snd-hda-codec-hdmi.o endif # this must be the last entry after codec drivers; diff --git a/sound/pci/hda/hda_eld.c b/sound/pci/hda/hda_eld.c index 26c3ade..cb0c23a 100644 --- a/sound/pci/hda/hda_eld.c +++ b/sound/pci/hda/hda_eld.c @@ -332,7 +332,6 @@ int snd_hdmi_get_eld_size(struct hda_codec *codec, hda_nid_t nid) return snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_HDMI_DIP_SIZE, AC_DIPSIZE_ELD_BUF); } -EXPORT_SYMBOL_HDA(snd_hdmi_get_eld_size); int snd_hdmi_get_eld(struct hdmi_eld *eld, struct hda_codec *codec, hda_nid_t nid) @@ -368,7 +367,6 @@ int snd_hdmi_get_eld(struct hdmi_eld *eld, kfree(buf); return ret; } -EXPORT_SYMBOL_HDA(snd_hdmi_get_eld); static void hdmi_show_short_audio_desc(struct cea_sad *a) { @@ -407,7 +405,6 @@ void snd_print_channel_allocation(int spk_alloc, char *buf, int buflen) } buf[j] = '\0'; /* necessary when j == 0 */ } -EXPORT_SYMBOL_HDA(snd_print_channel_allocation); void snd_hdmi_show_eld(struct hdmi_eld *e) { @@ -426,7 +423,6 @@ void snd_hdmi_show_eld(struct hdmi_eld *e) for (i = 0; i < e->sad_count; i++) hdmi_show_short_audio_desc(e->sad + i); } -EXPORT_SYMBOL_HDA(snd_hdmi_show_eld); #ifdef CONFIG_PROC_FS @@ -585,7 +581,6 @@ int snd_hda_eld_proc_new(struct hda_codec *codec, struct hdmi_eld *eld, return 0; } -EXPORT_SYMBOL_HDA(snd_hda_eld_proc_new); void snd_hda_eld_proc_free(struct hda_codec *codec, struct hdmi_eld *eld) { @@ -594,7 +589,6 @@ void snd_hda_eld_proc_free(struct hda_codec *codec, struct hdmi_eld *eld) eld->proc_entry = NULL; } } -EXPORT_SYMBOL_HDA(snd_hda_eld_proc_free); #endif /* CONFIG_PROC_FS */ @@ -645,4 +639,3 @@ void hdmi_eld_update_pcm_info(struct hdmi_eld *eld, struct hda_pcm_stream *pcm, pcm->channels_max = min(pcm->channels_max, codec_pars->channels_max); pcm->maxbps = min(pcm->maxbps, codec_pars->maxbps); } -EXPORT_SYMBOL_HDA(hdmi_eld_update_pcm_info); diff --git a/sound/pci/hda/patch_atihdmi.c b/sound/pci/hda/patch_atihdmi.c deleted file mode 100644 index fb684f0..0000000 --- a/sound/pci/hda/patch_atihdmi.c +++ /dev/null @@ -1,224 +0,0 @@ -/* - * Universal Interface for Intel High Definition Audio Codec - * - * HD audio interface patch for ATI HDMI codecs - * - * Copyright (c) 2006 ATI Technologies Inc. - * - * - * This driver 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 driver 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 - */ - -#include -#include -#include -#include -#include "hda_codec.h" -#include "hda_local.h" - -struct atihdmi_spec { - struct hda_multi_out multiout; - - struct hda_pcm pcm_rec; -}; - -#define CVT_NID 0x02 /* audio converter */ -#define PIN_NID 0x03 /* HDMI output pin */ - -static struct hda_verb atihdmi_basic_init[] = { - /* enable digital output on pin widget */ - { 0x03, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, - {} /* terminator */ -}; - -/* - * Controls - */ -static int atihdmi_build_controls(struct hda_codec *codec) -{ - struct atihdmi_spec *spec = codec->spec; - int err; - - err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid); - if (err < 0) - return err; - - return 0; -} - -static int atihdmi_init(struct hda_codec *codec) -{ - snd_hda_sequence_write(codec, atihdmi_basic_init); - /* SI codec requires to unmute the pin */ - if (get_wcaps(codec, PIN_NID) & AC_WCAP_OUT_AMP) - snd_hda_codec_write(codec, PIN_NID, 0, - AC_VERB_SET_AMP_GAIN_MUTE, - AMP_OUT_UNMUTE); - return 0; -} - -/* - * Digital out - */ -static int atihdmi_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, - struct hda_codec *codec, - struct snd_pcm_substream *substream) -{ - struct atihdmi_spec *spec = codec->spec; - return snd_hda_multi_out_dig_open(codec, &spec->multiout); -} - -static int atihdmi_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, - struct hda_codec *codec, - struct snd_pcm_substream *substream) -{ - struct atihdmi_spec *spec = codec->spec; - return snd_hda_multi_out_dig_close(codec, &spec->multiout); -} - -static int atihdmi_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo, - struct hda_codec *codec, - unsigned int stream_tag, - unsigned int format, - struct snd_pcm_substream *substream) -{ - struct atihdmi_spec *spec = codec->spec; - int chans = substream->runtime->channels; - int i, err; - - err = snd_hda_multi_out_dig_prepare(codec, &spec->multiout, stream_tag, - format, substream); - if (err < 0) - return err; - snd_hda_codec_write(codec, CVT_NID, 0, AC_VERB_SET_CVT_CHAN_COUNT, - chans - 1); - /* FIXME: XXX */ - for (i = 0; i < chans; i++) { - snd_hda_codec_write(codec, CVT_NID, 0, - AC_VERB_SET_HDMI_CHAN_SLOT, - (i << 4) | i); - } - return 0; -} - -static struct hda_pcm_stream atihdmi_pcm_digital_playback = { - .substreams = 1, - .channels_min = 2, - .channels_max = 2, - .nid = CVT_NID, /* NID to query formats and rates and setup streams */ - .ops = { - .open = atihdmi_dig_playback_pcm_open, - .close = atihdmi_dig_playback_pcm_close, - .prepare = atihdmi_dig_playback_pcm_prepare - }, -}; - -static int atihdmi_build_pcms(struct hda_codec *codec) -{ - struct atihdmi_spec *spec = codec->spec; - struct hda_pcm *info = &spec->pcm_rec; - unsigned int chans; - - codec->num_pcms = 1; - codec->pcm_info = info; - - info->name = "ATI HDMI"; - info->pcm_type = HDA_PCM_TYPE_HDMI; - info->stream[SNDRV_PCM_STREAM_PLAYBACK] = atihdmi_pcm_digital_playback; - - /* FIXME: we must check ELD and change the PCM parameters dynamically - */ - chans = get_wcaps(codec, CVT_NID); - chans = get_wcaps_channels(chans); - info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = chans; - - return 0; -} - -static void atihdmi_free(struct hda_codec *codec) -{ - kfree(codec->spec); -} - -static struct hda_codec_ops atihdmi_patch_ops = { - .build_controls = atihdmi_build_controls, - .build_pcms = atihdmi_build_pcms, - .init = atihdmi_init, - .free = atihdmi_free, -}; - -static int patch_atihdmi(struct hda_codec *codec) -{ - struct atihdmi_spec *spec; - - spec = kzalloc(sizeof(*spec), GFP_KERNEL); - if (spec == NULL) - return -ENOMEM; - - codec->spec = spec; - - spec->multiout.num_dacs = 0; /* no analog */ - spec->multiout.max_channels = 2; - /* NID for copying analog to digital, - * seems to be unused in pure-digital - * case. - */ - spec->multiout.dig_out_nid = CVT_NID; - - codec->patch_ops = atihdmi_patch_ops; - - return 0; -} - -/* - * patch entries - */ -static struct hda_codec_preset snd_hda_preset_atihdmi[] = { - { .id = 0x1002793c, .name = "RS600 HDMI", .patch = patch_atihdmi }, - { .id = 0x10027919, .name = "RS600 HDMI", .patch = patch_atihdmi }, - { .id = 0x1002791a, .name = "RS690/780 HDMI", .patch = patch_atihdmi }, - { .id = 0x1002aa01, .name = "R6xx HDMI", .patch = patch_atihdmi }, - { .id = 0x10951390, .name = "SiI1390 HDMI", .patch = patch_atihdmi }, - { .id = 0x17e80047, .name = "Chrontel HDMI", .patch = patch_atihdmi }, - {} /* terminator */ -}; - -MODULE_ALIAS("snd-hda-codec-id:1002793c"); -MODULE_ALIAS("snd-hda-codec-id:10027919"); -MODULE_ALIAS("snd-hda-codec-id:1002791a"); -MODULE_ALIAS("snd-hda-codec-id:1002aa01"); -MODULE_ALIAS("snd-hda-codec-id:10951390"); -MODULE_ALIAS("snd-hda-codec-id:17e80047"); - -MODULE_LICENSE("GPL"); -MODULE_DESCRIPTION("ATI HDMI HD-audio codec"); - -static struct hda_codec_preset_list atihdmi_list = { - .preset = snd_hda_preset_atihdmi, - .owner = THIS_MODULE, -}; - -static int __init patch_atihdmi_init(void) -{ - return snd_hda_add_codec_preset(&atihdmi_list); -} - -static void __exit patch_atihdmi_exit(void) -{ - snd_hda_delete_codec_preset(&atihdmi_list); -} - -module_init(patch_atihdmi_init) -module_exit(patch_atihdmi_exit) diff --git a/sound/pci/hda/patch_hdmi.c b/sound/pci/hda/patch_hdmi.c index afd6022..cb997ca 100644 --- a/sound/pci/hda/patch_hdmi.c +++ b/sound/pci/hda/patch_hdmi.c @@ -3,6 +3,9 @@ * patch_hdmi.c - routines for HDMI/DisplayPort codecs * * Copyright(c) 2008-2010 Intel Corporation. All rights reserved. + * Copyright (c) 2006 ATI Technologies Inc. + * Copyright (c) 2008 NVIDIA Corp. All rights reserved. + * Copyright (c) 2008 Wei Ni * * Authors: * Wu Fengguang @@ -25,6 +28,22 @@ * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +#include +#include +#include +#include +#include "hda_codec.h" +#include "hda_local.h" + +/* + * The HDMI/DisplayPort configuration can be highly dynamic. A graphics device + * could support two independent pipes, each of them can be connected to one or + * more ports (DVI, HDMI or DisplayPort). + * + * The HDA correspondence of pipes/ports are converter/pin nodes. + */ +#define MAX_HDMI_CVTS 3 +#define MAX_HDMI_PINS 3 struct hdmi_spec { int num_cvts; @@ -49,10 +68,10 @@ struct hdmi_spec { struct hda_pcm_stream codec_pcm_pars[MAX_HDMI_CVTS]; /* - * nvhdmi specific + * ati/nvhdmi specific */ struct hda_multi_out multiout; - unsigned int codec_type; + struct hda_pcm_stream *pcm_playback; /* misc flags */ /* PD bit indicates only the update, not the current state */ @@ -791,7 +810,6 @@ static int hdmi_pcm_open(struct hda_pcm_stream *hinfo, /* * HDA/HDMI auto parsing */ - static int hdmi_read_pin_conn(struct hda_codec *codec, hda_nid_t pin_nid) { struct hdmi_spec *spec = codec->spec; @@ -922,3 +940,664 @@ static int hdmi_parse_codec(struct hda_codec *codec) return 0; } +/* + */ +static char *generic_hdmi_pcm_names[MAX_HDMI_CVTS] = { + "HDMI 0", + "HDMI 1", + "HDMI 2", +}; + +/* + * HDMI callbacks + */ + +static int generic_hdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo, + struct hda_codec *codec, + unsigned int stream_tag, + unsigned int format, + struct snd_pcm_substream *substream) +{ + hdmi_set_channel_count(codec, hinfo->nid, + substream->runtime->channels); + + hdmi_setup_audio_infoframe(codec, hinfo->nid, substream); + + return hdmi_setup_stream(codec, hinfo->nid, stream_tag, format); +} + +static struct hda_pcm_stream generic_hdmi_pcm_playback = { + .substreams = 1, + .channels_min = 2, + .ops = { + .open = hdmi_pcm_open, + .prepare = generic_hdmi_playback_pcm_prepare, + }, +}; + +static int generic_hdmi_build_pcms(struct hda_codec *codec) +{ + struct hdmi_spec *spec = codec->spec; + struct hda_pcm *info = spec->pcm_rec; + int i; + + codec->num_pcms = spec->num_cvts; + codec->pcm_info = info; + + for (i = 0; i < codec->num_pcms; i++, info++) { + unsigned int chans; + struct hda_pcm_stream *pstr; + + chans = get_wcaps(codec, spec->cvt[i]); + chans = get_wcaps_channels(chans); + + info->name = generic_hdmi_pcm_names[i]; + info->pcm_type = HDA_PCM_TYPE_HDMI; + pstr = &info->stream[SNDRV_PCM_STREAM_PLAYBACK]; + if (spec->pcm_playback) + *pstr = *spec->pcm_playback; + else + *pstr = generic_hdmi_pcm_playback; + pstr->nid = spec->cvt[i]; + if (pstr->channels_max <= 2 && chans && chans <= 16) + pstr->channels_max = chans; + } + + return 0; +} + +static int generic_hdmi_build_controls(struct hda_codec *codec) +{ + struct hdmi_spec *spec = codec->spec; + int err; + int i; + + for (i = 0; i < codec->num_pcms; i++) { + err = snd_hda_create_spdif_out_ctls(codec, spec->cvt[i]); + if (err < 0) + return err; + } + + return 0; +} + +static int generic_hdmi_init(struct hda_codec *codec) +{ + struct hdmi_spec *spec = codec->spec; + int i; + + for (i = 0; spec->pin[i]; i++) { + hdmi_enable_output(codec, spec->pin[i]); + snd_hda_codec_write(codec, spec->pin[i], 0, + AC_VERB_SET_UNSOLICITED_ENABLE, + AC_USRSP_EN | spec->pin[i]); + } + return 0; +} + +static void generic_hdmi_free(struct hda_codec *codec) +{ + struct hdmi_spec *spec = codec->spec; + int i; + + for (i = 0; i < spec->num_pins; i++) + snd_hda_eld_proc_free(codec, &spec->sink_eld[i]); + + kfree(spec); +} + +static struct hda_codec_ops generic_hdmi_patch_ops = { + .init = generic_hdmi_init, + .free = generic_hdmi_free, + .build_pcms = generic_hdmi_build_pcms, + .build_controls = generic_hdmi_build_controls, + .unsol_event = hdmi_unsol_event, +}; + +static int patch_generic_hdmi(struct hda_codec *codec) +{ + struct hdmi_spec *spec; + int i; + + spec = kzalloc(sizeof(*spec), GFP_KERNEL); + if (spec == NULL) + return -ENOMEM; + + codec->spec = spec; + if (hdmi_parse_codec(codec) < 0) { + codec->spec = NULL; + kfree(spec); + return -EINVAL; + } + codec->patch_ops = generic_hdmi_patch_ops; + + for (i = 0; i < spec->num_pins; i++) + snd_hda_eld_proc_new(codec, &spec->sink_eld[i], i); + + init_channel_allocations(); + + return 0; +} + +/* + * Nvidia specific implementations + */ + +#define Nv_VERB_SET_Channel_Allocation 0xF79 +#define Nv_VERB_SET_Info_Frame_Checksum 0xF7A +#define Nv_VERB_SET_Audio_Protection_On 0xF98 +#define Nv_VERB_SET_Audio_Protection_Off 0xF99 + +#define nvhdmi_master_con_nid_7x 0x04 +#define nvhdmi_master_pin_nid_7x 0x05 + +static hda_nid_t nvhdmi_con_nids_7x[4] = { + /*front, rear, clfe, rear_surr */ + 0x6, 0x8, 0xa, 0xc, +}; + +static struct hda_verb nvhdmi_basic_init_7x[] = { + /* set audio protect on */ + { 0x1, Nv_VERB_SET_Audio_Protection_On, 0x1}, + /* enable digital output on pin widget */ + { 0x5, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 }, + { 0x7, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 }, + { 0x9, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 }, + { 0xb, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 }, + { 0xd, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 }, + {} /* terminator */ +}; + +#ifdef LIMITED_RATE_FMT_SUPPORT +/* support only the safe format and rate */ +#define SUPPORTED_RATES SNDRV_PCM_RATE_48000 +#define SUPPORTED_MAXBPS 16 +#define SUPPORTED_FORMATS SNDRV_PCM_FMTBIT_S16_LE +#else +/* support all rates and formats */ +#define SUPPORTED_RATES \ + (SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |\ + SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_176400 |\ + SNDRV_PCM_RATE_192000) +#define SUPPORTED_MAXBPS 24 +#define SUPPORTED_FORMATS \ + (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE) +#endif + +static int nvhdmi_7x_init(struct hda_codec *codec) +{ + snd_hda_sequence_write(codec, nvhdmi_basic_init_7x); + return 0; +} + +static int simple_playback_pcm_open(struct hda_pcm_stream *hinfo, + struct hda_codec *codec, + struct snd_pcm_substream *substream) +{ + struct hdmi_spec *spec = codec->spec; + return snd_hda_multi_out_dig_open(codec, &spec->multiout); +} + +static int simple_playback_pcm_close(struct hda_pcm_stream *hinfo, + struct hda_codec *codec, + struct snd_pcm_substream *substream) +{ + struct hdmi_spec *spec = codec->spec; + return snd_hda_multi_out_dig_close(codec, &spec->multiout); +} + +static int simple_playback_pcm_prepare(struct hda_pcm_stream *hinfo, + struct hda_codec *codec, + unsigned int stream_tag, + unsigned int format, + struct snd_pcm_substream *substream) +{ + struct hdmi_spec *spec = codec->spec; + return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, + stream_tag, format, substream); +} + +static int nvhdmi_8ch_7x_pcm_close(struct hda_pcm_stream *hinfo, + struct hda_codec *codec, + struct snd_pcm_substream *substream) +{ + struct hdmi_spec *spec = codec->spec; + int i; + + snd_hda_codec_write(codec, nvhdmi_master_con_nid_7x, + 0, AC_VERB_SET_CHANNEL_STREAMID, 0); + for (i = 0; i < 4; i++) { + /* set the stream id */ + snd_hda_codec_write(codec, nvhdmi_con_nids_7x[i], 0, + AC_VERB_SET_CHANNEL_STREAMID, 0); + /* set the stream format */ + snd_hda_codec_write(codec, nvhdmi_con_nids_7x[i], 0, + AC_VERB_SET_STREAM_FORMAT, 0); + } + + return snd_hda_multi_out_dig_close(codec, &spec->multiout); +} + +static int nvhdmi_8ch_7x_pcm_prepare(struct hda_pcm_stream *hinfo, + struct hda_codec *codec, + unsigned int stream_tag, + unsigned int format, + struct snd_pcm_substream *substream) +{ + int chs; + unsigned int dataDCC1, dataDCC2, chan, chanmask, channel_id; + int i; + + mutex_lock(&codec->spdif_mutex); + + chs = substream->runtime->channels; + chan = chs ? (chs - 1) : 1; + + switch (chs) { + default: + case 0: + case 2: + chanmask = 0x00; + break; + case 4: + chanmask = 0x08; + break; + case 6: + chanmask = 0x0b; + break; + case 8: + chanmask = 0x13; + break; + } + dataDCC1 = AC_DIG1_ENABLE | AC_DIG1_COPYRIGHT; + dataDCC2 = 0x2; + + /* set the Audio InforFrame Channel Allocation */ + snd_hda_codec_write(codec, 0x1, 0, + Nv_VERB_SET_Channel_Allocation, chanmask); + + /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */ + if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE)) + snd_hda_codec_write(codec, + nvhdmi_master_con_nid_7x, + 0, + AC_VERB_SET_DIGI_CONVERT_1, + codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff); + + /* set the stream id */ + snd_hda_codec_write(codec, nvhdmi_master_con_nid_7x, 0, + AC_VERB_SET_CHANNEL_STREAMID, (stream_tag << 4) | 0x0); + + /* set the stream format */ + snd_hda_codec_write(codec, nvhdmi_master_con_nid_7x, 0, + AC_VERB_SET_STREAM_FORMAT, format); + + /* turn on again (if needed) */ + /* enable and set the channel status audio/data flag */ + if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE)) { + snd_hda_codec_write(codec, + nvhdmi_master_con_nid_7x, + 0, + AC_VERB_SET_DIGI_CONVERT_1, + codec->spdif_ctls & 0xff); + snd_hda_codec_write(codec, + nvhdmi_master_con_nid_7x, + 0, + AC_VERB_SET_DIGI_CONVERT_2, dataDCC2); + } + + for (i = 0; i < 4; i++) { + if (chs == 2) + channel_id = 0; + else + channel_id = i * 2; + + /* turn off SPDIF once; + *otherwise the IEC958 bits won't be updated + */ + if (codec->spdif_status_reset && + (codec->spdif_ctls & AC_DIG1_ENABLE)) + snd_hda_codec_write(codec, + nvhdmi_con_nids_7x[i], + 0, + AC_VERB_SET_DIGI_CONVERT_1, + codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff); + /* set the stream id */ + snd_hda_codec_write(codec, + nvhdmi_con_nids_7x[i], + 0, + AC_VERB_SET_CHANNEL_STREAMID, + (stream_tag << 4) | channel_id); + /* set the stream format */ + snd_hda_codec_write(codec, + nvhdmi_con_nids_7x[i], + 0, + AC_VERB_SET_STREAM_FORMAT, + format); + /* turn on again (if needed) */ + /* enable and set the channel status audio/data flag */ + if (codec->spdif_status_reset && + (codec->spdif_ctls & AC_DIG1_ENABLE)) { + snd_hda_codec_write(codec, + nvhdmi_con_nids_7x[i], + 0, + AC_VERB_SET_DIGI_CONVERT_1, + codec->spdif_ctls & 0xff); + snd_hda_codec_write(codec, + nvhdmi_con_nids_7x[i], + 0, + AC_VERB_SET_DIGI_CONVERT_2, dataDCC2); + } + } + + /* set the Audio Info Frame Checksum */ + snd_hda_codec_write(codec, 0x1, 0, + Nv_VERB_SET_Info_Frame_Checksum, + (0x71 - chan - chanmask)); + + mutex_unlock(&codec->spdif_mutex); + return 0; +} + +static struct hda_pcm_stream nvhdmi_pcm_playback_8ch_7x = { + .substreams = 1, + .channels_min = 2, + .channels_max = 8, + .nid = nvhdmi_master_con_nid_7x, + .rates = SUPPORTED_RATES, + .maxbps = SUPPORTED_MAXBPS, + .formats = SUPPORTED_FORMATS, + .ops = { + .open = simple_playback_pcm_open, + .close = nvhdmi_8ch_7x_pcm_close, + .prepare = nvhdmi_8ch_7x_pcm_prepare + }, +}; + +static struct hda_pcm_stream nvhdmi_pcm_playback_2ch = { + .substreams = 1, + .channels_min = 2, + .channels_max = 2, + .nid = nvhdmi_master_con_nid_7x, + .rates = SUPPORTED_RATES, + .maxbps = SUPPORTED_MAXBPS, + .formats = SUPPORTED_FORMATS, + .ops = { + .open = simple_playback_pcm_open, + .close = simple_playback_pcm_close, + .prepare = simple_playback_pcm_prepare + }, +}; + +static struct hda_codec_ops nvhdmi_patch_ops_8ch_7x = { + .build_controls = generic_hdmi_build_controls, + .build_pcms = generic_hdmi_build_pcms, + .init = nvhdmi_7x_init, + .free = generic_hdmi_free, +}; + +static struct hda_codec_ops nvhdmi_patch_ops_2ch = { + .build_controls = generic_hdmi_build_controls, + .build_pcms = generic_hdmi_build_pcms, + .init = nvhdmi_7x_init, + .free = generic_hdmi_free, +}; + +static int patch_nvhdmi_8ch_89(struct hda_codec *codec) +{ + struct hdmi_spec *spec; + int err = patch_generic_hdmi(codec); + + if (err < 0) + return err; + spec = codec->spec; + spec->old_pin_detect = 1; + return 0; +} + +static int patch_nvhdmi_2ch(struct hda_codec *codec) +{ + struct hdmi_spec *spec; + + spec = kzalloc(sizeof(*spec), GFP_KERNEL); + if (spec == NULL) + return -ENOMEM; + + codec->spec = spec; + + spec->multiout.num_dacs = 0; /* no analog */ + spec->multiout.max_channels = 2; + spec->multiout.dig_out_nid = nvhdmi_master_con_nid_7x; + spec->old_pin_detect = 1; + spec->num_cvts = 1; + spec->cvt[0] = nvhdmi_master_con_nid_7x; + spec->pcm_playback = &nvhdmi_pcm_playback_2ch; + + codec->patch_ops = nvhdmi_patch_ops_2ch; + + return 0; +} + +static int patch_nvhdmi_8ch_7x(struct hda_codec *codec) +{ + struct hdmi_spec *spec; + int err = patch_nvhdmi_2ch(codec); + + if (err < 0) + return err; + spec = codec->spec; + spec->multiout.max_channels = 8; + spec->pcm_playback = &nvhdmi_pcm_playback_8ch_7x; + codec->patch_ops = nvhdmi_patch_ops_8ch_7x; + return 0; +} + +/* + * ATI-specific implementations + * + * FIXME: we may omit the whole this and use the generic code once after + * it's confirmed to work. + */ + +#define ATIHDMI_CVT_NID 0x02 /* audio converter */ +#define ATIHDMI_PIN_NID 0x03 /* HDMI output pin */ + +static int atihdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo, + struct hda_codec *codec, + unsigned int stream_tag, + unsigned int format, + struct snd_pcm_substream *substream) +{ + struct hdmi_spec *spec = codec->spec; + int chans = substream->runtime->channels; + int i, err; + + err = simple_playback_pcm_prepare(hinfo, codec, stream_tag, format, + substream); + if (err < 0) + return err; + snd_hda_codec_write(codec, spec->cvt[0], 0, AC_VERB_SET_CVT_CHAN_COUNT, + chans - 1); + /* FIXME: XXX */ + for (i = 0; i < chans; i++) { + snd_hda_codec_write(codec, spec->cvt[0], 0, + AC_VERB_SET_HDMI_CHAN_SLOT, + (i << 4) | i); + } + return 0; +} + +static struct hda_pcm_stream atihdmi_pcm_digital_playback = { + .substreams = 1, + .channels_min = 2, + .channels_max = 2, + .nid = ATIHDMI_CVT_NID, + .ops = { + .open = simple_playback_pcm_open, + .close = simple_playback_pcm_close, + .prepare = atihdmi_playback_pcm_prepare + }, +}; + +static struct hda_verb atihdmi_basic_init[] = { + /* enable digital output on pin widget */ + { 0x03, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, + {} /* terminator */ +}; + +static int atihdmi_init(struct hda_codec *codec) +{ + struct hdmi_spec *spec = codec->spec; + + snd_hda_sequence_write(codec, atihdmi_basic_init); + /* SI codec requires to unmute the pin */ + if (get_wcaps(codec, spec->pin[0]) & AC_WCAP_OUT_AMP) + snd_hda_codec_write(codec, spec->pin[0], 0, + AC_VERB_SET_AMP_GAIN_MUTE, + AMP_OUT_UNMUTE); + return 0; +} + +static struct hda_codec_ops atihdmi_patch_ops = { + .build_controls = generic_hdmi_build_controls, + .build_pcms = generic_hdmi_build_pcms, + .init = atihdmi_init, + .free = generic_hdmi_free, +}; + + +static int patch_atihdmi(struct hda_codec *codec) +{ + struct hdmi_spec *spec; + + spec = kzalloc(sizeof(*spec), GFP_KERNEL); + if (spec == NULL) + return -ENOMEM; + + codec->spec = spec; + + spec->multiout.num_dacs = 0; /* no analog */ + spec->multiout.max_channels = 2; + spec->multiout.dig_out_nid = ATIHDMI_CVT_NID; + spec->num_cvts = 1; + spec->cvt[0] = ATIHDMI_CVT_NID; + spec->pin[0] = ATIHDMI_PIN_NID; + spec->pcm_playback = &atihdmi_pcm_digital_playback; + + codec->patch_ops = atihdmi_patch_ops; + + return 0; +} + + +/* + * patch entries + */ +static struct hda_codec_preset snd_hda_preset_hdmi[] = { +{ .id = 0x1002793c, .name = "RS600 HDMI", .patch = patch_atihdmi }, +{ .id = 0x10027919, .name = "RS600 HDMI", .patch = patch_atihdmi }, +{ .id = 0x1002791a, .name = "RS690/780 HDMI", .patch = patch_atihdmi }, +{ .id = 0x1002aa01, .name = "R6xx HDMI", .patch = patch_atihdmi }, +{ .id = 0x10951390, .name = "SiI1390 HDMI", .patch = patch_generic_hdmi }, +{ .id = 0x10951392, .name = "SiI1392 HDMI", .patch = patch_generic_hdmi }, +{ .id = 0x17e80047, .name = "Chrontel HDMI", .patch = patch_generic_hdmi }, +{ .id = 0x10de0002, .name = "MCP77/78 HDMI", .patch = patch_nvhdmi_8ch_7x }, +{ .id = 0x10de0003, .name = "MCP77/78 HDMI", .patch = patch_nvhdmi_8ch_7x }, +{ .id = 0x10de0005, .name = "MCP77/78 HDMI", .patch = patch_nvhdmi_8ch_7x }, +{ .id = 0x10de0006, .name = "MCP77/78 HDMI", .patch = patch_nvhdmi_8ch_7x }, +{ .id = 0x10de0007, .name = "MCP79/7A HDMI", .patch = patch_nvhdmi_8ch_7x }, +{ .id = 0x10de000a, .name = "GPU 0a HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, +{ .id = 0x10de000b, .name = "GPU 0b HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, +{ .id = 0x10de000c, .name = "MCP89 HDMI", .patch = patch_nvhdmi_8ch_89 }, +{ .id = 0x10de000d, .name = "GPU 0d HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, +{ .id = 0x10de0010, .name = "GPU 10 HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, +{ .id = 0x10de0011, .name = "GPU 11 HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, +{ .id = 0x10de0012, .name = "GPU 12 HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, +{ .id = 0x10de0013, .name = "GPU 13 HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, +{ .id = 0x10de0014, .name = "GPU 14 HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, +{ .id = 0x10de0018, .name = "GPU 18 HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, +{ .id = 0x10de0019, .name = "GPU 19 HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, +{ .id = 0x10de001a, .name = "GPU 1a HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, +{ .id = 0x10de001b, .name = "GPU 1b HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, +{ .id = 0x10de001c, .name = "GPU 1c HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, +{ .id = 0x10de0040, .name = "GPU 40 HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, +{ .id = 0x10de0041, .name = "GPU 41 HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, +{ .id = 0x10de0042, .name = "GPU 42 HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, +{ .id = 0x10de0043, .name = "GPU 43 HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, +{ .id = 0x10de0044, .name = "GPU 44 HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, +{ .id = 0x10de0067, .name = "MCP67 HDMI", .patch = patch_nvhdmi_2ch }, +{ .id = 0x10de8001, .name = "MCP73 HDMI", .patch = patch_nvhdmi_2ch }, +{ .id = 0x80860054, .name = "IbexPeak HDMI", .patch = patch_generic_hdmi }, +{ .id = 0x80862801, .name = "Bearlake HDMI", .patch = patch_generic_hdmi }, +{ .id = 0x80862802, .name = "Cantiga HDMI", .patch = patch_generic_hdmi }, +{ .id = 0x80862803, .name = "Eaglelake HDMI", .patch = patch_generic_hdmi }, +{ .id = 0x80862804, .name = "IbexPeak HDMI", .patch = patch_generic_hdmi }, +{ .id = 0x80862805, .name = "CougarPoint HDMI", .patch = patch_generic_hdmi }, +{ .id = 0x808629fb, .name = "Crestline HDMI", .patch = patch_generic_hdmi }, +{} /* terminator */ +}; + +MODULE_ALIAS("snd-hda-codec-id:1002793c"); +MODULE_ALIAS("snd-hda-codec-id:10027919"); +MODULE_ALIAS("snd-hda-codec-id:1002791a"); +MODULE_ALIAS("snd-hda-codec-id:1002aa01"); +MODULE_ALIAS("snd-hda-codec-id:10951390"); +MODULE_ALIAS("snd-hda-codec-id:10951392"); +MODULE_ALIAS("snd-hda-codec-id:10de0002"); +MODULE_ALIAS("snd-hda-codec-id:10de0003"); +MODULE_ALIAS("snd-hda-codec-id:10de0005"); +MODULE_ALIAS("snd-hda-codec-id:10de0006"); +MODULE_ALIAS("snd-hda-codec-id:10de0007"); +MODULE_ALIAS("snd-hda-codec-id:10de000a"); +MODULE_ALIAS("snd-hda-codec-id:10de000b"); +MODULE_ALIAS("snd-hda-codec-id:10de000c"); +MODULE_ALIAS("snd-hda-codec-id:10de000d"); +MODULE_ALIAS("snd-hda-codec-id:10de0010"); +MODULE_ALIAS("snd-hda-codec-id:10de0011"); +MODULE_ALIAS("snd-hda-codec-id:10de0012"); +MODULE_ALIAS("snd-hda-codec-id:10de0013"); +MODULE_ALIAS("snd-hda-codec-id:10de0014"); +MODULE_ALIAS("snd-hda-codec-id:10de0018"); +MODULE_ALIAS("snd-hda-codec-id:10de0019"); +MODULE_ALIAS("snd-hda-codec-id:10de001a"); +MODULE_ALIAS("snd-hda-codec-id:10de001b"); +MODULE_ALIAS("snd-hda-codec-id:10de001c"); +MODULE_ALIAS("snd-hda-codec-id:10de0040"); +MODULE_ALIAS("snd-hda-codec-id:10de0041"); +MODULE_ALIAS("snd-hda-codec-id:10de0042"); +MODULE_ALIAS("snd-hda-codec-id:10de0043"); +MODULE_ALIAS("snd-hda-codec-id:10de0044"); +MODULE_ALIAS("snd-hda-codec-id:10de0067"); +MODULE_ALIAS("snd-hda-codec-id:10de8001"); +MODULE_ALIAS("snd-hda-codec-id:17e80047"); +MODULE_ALIAS("snd-hda-codec-id:80860054"); +MODULE_ALIAS("snd-hda-codec-id:80862801"); +MODULE_ALIAS("snd-hda-codec-id:80862802"); +MODULE_ALIAS("snd-hda-codec-id:80862803"); +MODULE_ALIAS("snd-hda-codec-id:80862804"); +MODULE_ALIAS("snd-hda-codec-id:80862805"); +MODULE_ALIAS("snd-hda-codec-id:808629fb"); + +MODULE_LICENSE("GPL"); +MODULE_DESCRIPTION("HDMI HD-audio codec"); +MODULE_ALIAS("snd-hda-codec-intelhdmi"); +MODULE_ALIAS("snd-hda-codec-nvhdmi"); +MODULE_ALIAS("snd-hda-codec-atihdmi"); + +static struct hda_codec_preset_list intel_list = { + .preset = snd_hda_preset_hdmi, + .owner = THIS_MODULE, +}; + +static int __init patch_hdmi_init(void) +{ + return snd_hda_add_codec_preset(&intel_list); +} + +static void __exit patch_hdmi_exit(void) +{ + snd_hda_delete_codec_preset(&intel_list); +} + +module_init(patch_hdmi_init) +module_exit(patch_hdmi_exit) diff --git a/sound/pci/hda/patch_intelhdmi.c b/sound/pci/hda/patch_intelhdmi.c deleted file mode 100644 index 36a9b83..0000000 --- a/sound/pci/hda/patch_intelhdmi.c +++ /dev/null @@ -1,220 +0,0 @@ -/* - * - * patch_intelhdmi.c - Patch for Intel HDMI codecs - * - * Copyright(c) 2008 Intel Corporation. All rights reserved. - * - * Authors: - * Jiang Zhe - * Wu Fengguang - * - * Maintained by: - * Wu Fengguang - * - * 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. - */ - -#include -#include -#include -#include -#include "hda_codec.h" -#include "hda_local.h" - -/* - * The HDMI/DisplayPort configuration can be highly dynamic. A graphics device - * could support two independent pipes, each of them can be connected to one or - * more ports (DVI, HDMI or DisplayPort). - * - * The HDA correspondence of pipes/ports are converter/pin nodes. - */ -#define MAX_HDMI_CVTS 3 -#define MAX_HDMI_PINS 3 - -#include "patch_hdmi.c" - -static char *intel_hdmi_pcm_names[MAX_HDMI_CVTS] = { - "INTEL HDMI 0", - "INTEL HDMI 1", - "INTEL HDMI 2", -}; - -/* - * HDMI callbacks - */ - -static int intel_hdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo, - struct hda_codec *codec, - unsigned int stream_tag, - unsigned int format, - struct snd_pcm_substream *substream) -{ - hdmi_set_channel_count(codec, hinfo->nid, - substream->runtime->channels); - - hdmi_setup_audio_infoframe(codec, hinfo->nid, substream); - - return hdmi_setup_stream(codec, hinfo->nid, stream_tag, format); -} - -static struct hda_pcm_stream intel_hdmi_pcm_playback = { - .substreams = 1, - .channels_min = 2, - .ops = { - .open = hdmi_pcm_open, - .prepare = intel_hdmi_playback_pcm_prepare, - }, -}; - -static int intel_hdmi_build_pcms(struct hda_codec *codec) -{ - struct hdmi_spec *spec = codec->spec; - struct hda_pcm *info = spec->pcm_rec; - int i; - - codec->num_pcms = spec->num_cvts; - codec->pcm_info = info; - - for (i = 0; i < codec->num_pcms; i++, info++) { - unsigned int chans; - - chans = get_wcaps(codec, spec->cvt[i]); - chans = get_wcaps_channels(chans); - - info->name = intel_hdmi_pcm_names[i]; - info->pcm_type = HDA_PCM_TYPE_HDMI; - info->stream[SNDRV_PCM_STREAM_PLAYBACK] = - intel_hdmi_pcm_playback; - info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->cvt[i]; - info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = chans; - } - - return 0; -} - -static int intel_hdmi_build_controls(struct hda_codec *codec) -{ - struct hdmi_spec *spec = codec->spec; - int err; - int i; - - for (i = 0; i < codec->num_pcms; i++) { - err = snd_hda_create_spdif_out_ctls(codec, spec->cvt[i]); - if (err < 0) - return err; - } - - return 0; -} - -static int intel_hdmi_init(struct hda_codec *codec) -{ - struct hdmi_spec *spec = codec->spec; - int i; - - for (i = 0; spec->pin[i]; i++) { - hdmi_enable_output(codec, spec->pin[i]); - snd_hda_codec_write(codec, spec->pin[i], 0, - AC_VERB_SET_UNSOLICITED_ENABLE, - AC_USRSP_EN | spec->pin[i]); - } - return 0; -} - -static void intel_hdmi_free(struct hda_codec *codec) -{ - struct hdmi_spec *spec = codec->spec; - int i; - - for (i = 0; i < spec->num_pins; i++) - snd_hda_eld_proc_free(codec, &spec->sink_eld[i]); - - kfree(spec); -} - -static struct hda_codec_ops intel_hdmi_patch_ops = { - .init = intel_hdmi_init, - .free = intel_hdmi_free, - .build_pcms = intel_hdmi_build_pcms, - .build_controls = intel_hdmi_build_controls, - .unsol_event = hdmi_unsol_event, -}; - -static int patch_intel_hdmi(struct hda_codec *codec) -{ - struct hdmi_spec *spec; - int i; - - spec = kzalloc(sizeof(*spec), GFP_KERNEL); - if (spec == NULL) - return -ENOMEM; - - codec->spec = spec; - if (hdmi_parse_codec(codec) < 0) { - codec->spec = NULL; - kfree(spec); - return -EINVAL; - } - codec->patch_ops = intel_hdmi_patch_ops; - - for (i = 0; i < spec->num_pins; i++) - snd_hda_eld_proc_new(codec, &spec->sink_eld[i], i); - - init_channel_allocations(); - - return 0; -} - -static struct hda_codec_preset snd_hda_preset_intelhdmi[] = { -{ .id = 0x808629fb, .name = "Crestline HDMI", .patch = patch_intel_hdmi }, -{ .id = 0x80862801, .name = "Bearlake HDMI", .patch = patch_intel_hdmi }, -{ .id = 0x80862802, .name = "Cantiga HDMI", .patch = patch_intel_hdmi }, -{ .id = 0x80862803, .name = "Eaglelake HDMI", .patch = patch_intel_hdmi }, -{ .id = 0x80862804, .name = "IbexPeak HDMI", .patch = patch_intel_hdmi }, -{ .id = 0x80860054, .name = "IbexPeak HDMI", .patch = patch_intel_hdmi }, -{ .id = 0x80862805, .name = "CougarPoint HDMI", .patch = patch_intel_hdmi }, -{ .id = 0x10951392, .name = "SiI1392 HDMI", .patch = patch_intel_hdmi }, -{} /* terminator */ -}; - -MODULE_ALIAS("snd-hda-codec-id:808629fb"); -MODULE_ALIAS("snd-hda-codec-id:80862801"); -MODULE_ALIAS("snd-hda-codec-id:80862802"); -MODULE_ALIAS("snd-hda-codec-id:80862803"); -MODULE_ALIAS("snd-hda-codec-id:80862804"); -MODULE_ALIAS("snd-hda-codec-id:80862805"); -MODULE_ALIAS("snd-hda-codec-id:80860054"); -MODULE_ALIAS("snd-hda-codec-id:10951392"); - -MODULE_LICENSE("GPL"); -MODULE_DESCRIPTION("Intel HDMI HD-audio codec"); - -static struct hda_codec_preset_list intel_list = { - .preset = snd_hda_preset_intelhdmi, - .owner = THIS_MODULE, -}; - -static int __init patch_intelhdmi_init(void) -{ - return snd_hda_add_codec_preset(&intel_list); -} - -static void __exit patch_intelhdmi_exit(void) -{ - snd_hda_delete_codec_preset(&intel_list); -} - -module_init(patch_intelhdmi_init) -module_exit(patch_intelhdmi_exit) diff --git a/sound/pci/hda/patch_nvhdmi.c b/sound/pci/hda/patch_nvhdmi.c deleted file mode 100644 index baa108b..0000000 --- a/sound/pci/hda/patch_nvhdmi.c +++ /dev/null @@ -1,608 +0,0 @@ -/* - * Universal Interface for Intel High Definition Audio Codec - * - * HD audio interface patch for NVIDIA HDMI codecs - * - * Copyright (c) 2008 NVIDIA Corp. All rights reserved. - * Copyright (c) 2008 Wei Ni - * - * - * This driver 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 driver 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 - */ - -#include -#include -#include -#include -#include "hda_codec.h" -#include "hda_local.h" - -#define MAX_HDMI_CVTS 1 -#define MAX_HDMI_PINS 1 - -#include "patch_hdmi.c" - -static char *nvhdmi_pcm_names[MAX_HDMI_CVTS] = { - "NVIDIA HDMI", -}; - -/* define below to restrict the supported rates and formats */ -/* #define LIMITED_RATE_FMT_SUPPORT */ - -enum HDACodec { - HDA_CODEC_NVIDIA_MCP7X, - HDA_CODEC_NVIDIA_MCP89, - HDA_CODEC_NVIDIA_GT21X, - HDA_CODEC_INVALID -}; - -#define Nv_VERB_SET_Channel_Allocation 0xF79 -#define Nv_VERB_SET_Info_Frame_Checksum 0xF7A -#define Nv_VERB_SET_Audio_Protection_On 0xF98 -#define Nv_VERB_SET_Audio_Protection_Off 0xF99 - -#define nvhdmi_master_con_nid_7x 0x04 -#define nvhdmi_master_pin_nid_7x 0x05 - -#define nvhdmi_master_con_nid_89 0x04 -#define nvhdmi_master_pin_nid_89 0x05 - -static hda_nid_t nvhdmi_con_nids_7x[4] = { - /*front, rear, clfe, rear_surr */ - 0x6, 0x8, 0xa, 0xc, -}; - -static struct hda_verb nvhdmi_basic_init_7x[] = { - /* set audio protect on */ - { 0x1, Nv_VERB_SET_Audio_Protection_On, 0x1}, - /* enable digital output on pin widget */ - { 0x5, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 }, - { 0x7, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 }, - { 0x9, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 }, - { 0xb, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 }, - { 0xd, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x5 }, - {} /* terminator */ -}; - -#ifdef LIMITED_RATE_FMT_SUPPORT -/* support only the safe format and rate */ -#define SUPPORTED_RATES SNDRV_PCM_RATE_48000 -#define SUPPORTED_MAXBPS 16 -#define SUPPORTED_FORMATS SNDRV_PCM_FMTBIT_S16_LE -#else -/* support all rates and formats */ -#define SUPPORTED_RATES \ - (SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |\ - SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_176400 |\ - SNDRV_PCM_RATE_192000) -#define SUPPORTED_MAXBPS 24 -#define SUPPORTED_FORMATS \ - (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE) -#endif - -/* - * Controls - */ -static int nvhdmi_build_controls(struct hda_codec *codec) -{ - struct hdmi_spec *spec = codec->spec; - int err; - int i; - - if ((spec->codec_type == HDA_CODEC_NVIDIA_MCP89) - || (spec->codec_type == HDA_CODEC_NVIDIA_GT21X)) { - for (i = 0; i < codec->num_pcms; i++) { - err = snd_hda_create_spdif_out_ctls(codec, - spec->cvt[i]); - if (err < 0) - return err; - } - } else { - err = snd_hda_create_spdif_out_ctls(codec, - spec->multiout.dig_out_nid); - if (err < 0) - return err; - } - - return 0; -} - -static int nvhdmi_init(struct hda_codec *codec) -{ - struct hdmi_spec *spec = codec->spec; - int i; - if ((spec->codec_type == HDA_CODEC_NVIDIA_MCP89) - || (spec->codec_type == HDA_CODEC_NVIDIA_GT21X)) { - for (i = 0; spec->pin[i]; i++) { - hdmi_enable_output(codec, spec->pin[i]); - snd_hda_codec_write(codec, spec->pin[i], 0, - AC_VERB_SET_UNSOLICITED_ENABLE, - AC_USRSP_EN | spec->pin[i]); - } - } else { - snd_hda_sequence_write(codec, nvhdmi_basic_init_7x); - } - return 0; -} - -static void nvhdmi_free(struct hda_codec *codec) -{ - struct hdmi_spec *spec = codec->spec; - int i; - - if ((spec->codec_type == HDA_CODEC_NVIDIA_MCP89) - || (spec->codec_type == HDA_CODEC_NVIDIA_GT21X)) { - for (i = 0; i < spec->num_pins; i++) - snd_hda_eld_proc_free(codec, &spec->sink_eld[i]); - } - - kfree(spec); -} - -/* - * Digital out - */ -static int nvhdmi_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, - struct hda_codec *codec, - struct snd_pcm_substream *substream) -{ - struct hdmi_spec *spec = codec->spec; - return snd_hda_multi_out_dig_open(codec, &spec->multiout); -} - -static int nvhdmi_dig_playback_pcm_close_8ch_7x(struct hda_pcm_stream *hinfo, - struct hda_codec *codec, - struct snd_pcm_substream *substream) -{ - struct hdmi_spec *spec = codec->spec; - int i; - - snd_hda_codec_write(codec, nvhdmi_master_con_nid_7x, - 0, AC_VERB_SET_CHANNEL_STREAMID, 0); - for (i = 0; i < 4; i++) { - /* set the stream id */ - snd_hda_codec_write(codec, nvhdmi_con_nids_7x[i], 0, - AC_VERB_SET_CHANNEL_STREAMID, 0); - /* set the stream format */ - snd_hda_codec_write(codec, nvhdmi_con_nids_7x[i], 0, - AC_VERB_SET_STREAM_FORMAT, 0); - } - - return snd_hda_multi_out_dig_close(codec, &spec->multiout); -} - -static int nvhdmi_dig_playback_pcm_close_2ch(struct hda_pcm_stream *hinfo, - struct hda_codec *codec, - struct snd_pcm_substream *substream) -{ - struct hdmi_spec *spec = codec->spec; - return snd_hda_multi_out_dig_close(codec, &spec->multiout); -} - -static int nvhdmi_dig_playback_pcm_prepare_8ch_89(struct hda_pcm_stream *hinfo, - struct hda_codec *codec, - unsigned int stream_tag, - unsigned int format, - struct snd_pcm_substream *substream) -{ - hdmi_set_channel_count(codec, hinfo->nid, - substream->runtime->channels); - - hdmi_setup_audio_infoframe(codec, hinfo->nid, substream); - - return hdmi_setup_stream(codec, hinfo->nid, stream_tag, format); -} - -static int nvhdmi_dig_playback_pcm_prepare_8ch(struct hda_pcm_stream *hinfo, - struct hda_codec *codec, - unsigned int stream_tag, - unsigned int format, - struct snd_pcm_substream *substream) -{ - int chs; - unsigned int dataDCC1, dataDCC2, chan, chanmask, channel_id; - int i; - - mutex_lock(&codec->spdif_mutex); - - chs = substream->runtime->channels; - chan = chs ? (chs - 1) : 1; - - switch (chs) { - default: - case 0: - case 2: - chanmask = 0x00; - break; - case 4: - chanmask = 0x08; - break; - case 6: - chanmask = 0x0b; - break; - case 8: - chanmask = 0x13; - break; - } - dataDCC1 = AC_DIG1_ENABLE | AC_DIG1_COPYRIGHT; - dataDCC2 = 0x2; - - /* set the Audio InforFrame Channel Allocation */ - snd_hda_codec_write(codec, 0x1, 0, - Nv_VERB_SET_Channel_Allocation, chanmask); - - /* turn off SPDIF once; otherwise the IEC958 bits won't be updated */ - if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE)) - snd_hda_codec_write(codec, - nvhdmi_master_con_nid_7x, - 0, - AC_VERB_SET_DIGI_CONVERT_1, - codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff); - - /* set the stream id */ - snd_hda_codec_write(codec, nvhdmi_master_con_nid_7x, 0, - AC_VERB_SET_CHANNEL_STREAMID, (stream_tag << 4) | 0x0); - - /* set the stream format */ - snd_hda_codec_write(codec, nvhdmi_master_con_nid_7x, 0, - AC_VERB_SET_STREAM_FORMAT, format); - - /* turn on again (if needed) */ - /* enable and set the channel status audio/data flag */ - if (codec->spdif_status_reset && (codec->spdif_ctls & AC_DIG1_ENABLE)) { - snd_hda_codec_write(codec, - nvhdmi_master_con_nid_7x, - 0, - AC_VERB_SET_DIGI_CONVERT_1, - codec->spdif_ctls & 0xff); - snd_hda_codec_write(codec, - nvhdmi_master_con_nid_7x, - 0, - AC_VERB_SET_DIGI_CONVERT_2, dataDCC2); - } - - for (i = 0; i < 4; i++) { - if (chs == 2) - channel_id = 0; - else - channel_id = i * 2; - - /* turn off SPDIF once; - *otherwise the IEC958 bits won't be updated - */ - if (codec->spdif_status_reset && - (codec->spdif_ctls & AC_DIG1_ENABLE)) - snd_hda_codec_write(codec, - nvhdmi_con_nids_7x[i], - 0, - AC_VERB_SET_DIGI_CONVERT_1, - codec->spdif_ctls & ~AC_DIG1_ENABLE & 0xff); - /* set the stream id */ - snd_hda_codec_write(codec, - nvhdmi_con_nids_7x[i], - 0, - AC_VERB_SET_CHANNEL_STREAMID, - (stream_tag << 4) | channel_id); - /* set the stream format */ - snd_hda_codec_write(codec, - nvhdmi_con_nids_7x[i], - 0, - AC_VERB_SET_STREAM_FORMAT, - format); - /* turn on again (if needed) */ - /* enable and set the channel status audio/data flag */ - if (codec->spdif_status_reset && - (codec->spdif_ctls & AC_DIG1_ENABLE)) { - snd_hda_codec_write(codec, - nvhdmi_con_nids_7x[i], - 0, - AC_VERB_SET_DIGI_CONVERT_1, - codec->spdif_ctls & 0xff); - snd_hda_codec_write(codec, - nvhdmi_con_nids_7x[i], - 0, - AC_VERB_SET_DIGI_CONVERT_2, dataDCC2); - } - } - - /* set the Audio Info Frame Checksum */ - snd_hda_codec_write(codec, 0x1, 0, - Nv_VERB_SET_Info_Frame_Checksum, - (0x71 - chan - chanmask)); - - mutex_unlock(&codec->spdif_mutex); - return 0; -} - -static int nvhdmi_dig_playback_pcm_prepare_2ch(struct hda_pcm_stream *hinfo, - struct hda_codec *codec, - unsigned int stream_tag, - unsigned int format, - struct snd_pcm_substream *substream) -{ - struct hdmi_spec *spec = codec->spec; - return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, stream_tag, - format, substream); -} - -static struct hda_pcm_stream nvhdmi_pcm_digital_playback_8ch_89 = { - .substreams = 1, - .channels_min = 2, - .ops = { - .open = hdmi_pcm_open, - .prepare = nvhdmi_dig_playback_pcm_prepare_8ch_89, - }, -}; - -static struct hda_pcm_stream nvhdmi_pcm_digital_playback_8ch_7x = { - .substreams = 1, - .channels_min = 2, - .channels_max = 8, - .nid = nvhdmi_master_con_nid_7x, - .rates = SUPPORTED_RATES, - .maxbps = SUPPORTED_MAXBPS, - .formats = SUPPORTED_FORMATS, - .ops = { - .open = nvhdmi_dig_playback_pcm_open, - .close = nvhdmi_dig_playback_pcm_close_8ch_7x, - .prepare = nvhdmi_dig_playback_pcm_prepare_8ch - }, -}; - -static struct hda_pcm_stream nvhdmi_pcm_digital_playback_2ch = { - .substreams = 1, - .channels_min = 2, - .channels_max = 2, - .nid = nvhdmi_master_con_nid_7x, - .rates = SUPPORTED_RATES, - .maxbps = SUPPORTED_MAXBPS, - .formats = SUPPORTED_FORMATS, - .ops = { - .open = nvhdmi_dig_playback_pcm_open, - .close = nvhdmi_dig_playback_pcm_close_2ch, - .prepare = nvhdmi_dig_playback_pcm_prepare_2ch - }, -}; - -static int nvhdmi_build_pcms_8ch_89(struct hda_codec *codec) -{ - struct hdmi_spec *spec = codec->spec; - struct hda_pcm *info = spec->pcm_rec; - int i; - - codec->num_pcms = spec->num_cvts; - codec->pcm_info = info; - - for (i = 0; i < codec->num_pcms; i++, info++) { - unsigned int chans; - - chans = get_wcaps(codec, spec->cvt[i]); - chans = get_wcaps_channels(chans); - - info->name = nvhdmi_pcm_names[i]; - info->pcm_type = HDA_PCM_TYPE_HDMI; - info->stream[SNDRV_PCM_STREAM_PLAYBACK] - = nvhdmi_pcm_digital_playback_8ch_89; - info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->cvt[i]; - info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = chans; - } - - return 0; -} - -static int nvhdmi_build_pcms_8ch_7x(struct hda_codec *codec) -{ - struct hdmi_spec *spec = codec->spec; - struct hda_pcm *info = spec->pcm_rec; - - codec->num_pcms = 1; - codec->pcm_info = info; - - info->name = "NVIDIA HDMI"; - info->pcm_type = HDA_PCM_TYPE_HDMI; - info->stream[SNDRV_PCM_STREAM_PLAYBACK] - = nvhdmi_pcm_digital_playback_8ch_7x; - - return 0; -} - -static int nvhdmi_build_pcms_2ch(struct hda_codec *codec) -{ - struct hdmi_spec *spec = codec->spec; - struct hda_pcm *info = spec->pcm_rec; - - codec->num_pcms = 1; - codec->pcm_info = info; - - info->name = "NVIDIA HDMI"; - info->pcm_type = HDA_PCM_TYPE_HDMI; - info->stream[SNDRV_PCM_STREAM_PLAYBACK] - = nvhdmi_pcm_digital_playback_2ch; - - return 0; -} - -static struct hda_codec_ops nvhdmi_patch_ops_8ch_89 = { - .build_controls = nvhdmi_build_controls, - .build_pcms = nvhdmi_build_pcms_8ch_89, - .init = nvhdmi_init, - .free = nvhdmi_free, - .unsol_event = hdmi_unsol_event, -}; - -static struct hda_codec_ops nvhdmi_patch_ops_8ch_7x = { - .build_controls = nvhdmi_build_controls, - .build_pcms = nvhdmi_build_pcms_8ch_7x, - .init = nvhdmi_init, - .free = nvhdmi_free, -}; - -static struct hda_codec_ops nvhdmi_patch_ops_2ch = { - .build_controls = nvhdmi_build_controls, - .build_pcms = nvhdmi_build_pcms_2ch, - .init = nvhdmi_init, - .free = nvhdmi_free, -}; - -static int patch_nvhdmi_8ch_89(struct hda_codec *codec) -{ - struct hdmi_spec *spec; - int i; - - spec = kzalloc(sizeof(*spec), GFP_KERNEL); - if (spec == NULL) - return -ENOMEM; - - codec->spec = spec; - spec->codec_type = HDA_CODEC_NVIDIA_MCP89; - spec->old_pin_detect = 1; - - if (hdmi_parse_codec(codec) < 0) { - codec->spec = NULL; - kfree(spec); - return -EINVAL; - } - codec->patch_ops = nvhdmi_patch_ops_8ch_89; - - for (i = 0; i < spec->num_pins; i++) - snd_hda_eld_proc_new(codec, &spec->sink_eld[i], i); - - init_channel_allocations(); - - return 0; -} - -static int patch_nvhdmi_8ch_7x(struct hda_codec *codec) -{ - struct hdmi_spec *spec; - - spec = kzalloc(sizeof(*spec), GFP_KERNEL); - if (spec == NULL) - return -ENOMEM; - - codec->spec = spec; - - spec->multiout.num_dacs = 0; /* no analog */ - spec->multiout.max_channels = 8; - spec->multiout.dig_out_nid = nvhdmi_master_con_nid_7x; - spec->codec_type = HDA_CODEC_NVIDIA_MCP7X; - spec->old_pin_detect = 1; - - codec->patch_ops = nvhdmi_patch_ops_8ch_7x; - - return 0; -} - -static int patch_nvhdmi_2ch(struct hda_codec *codec) -{ - struct hdmi_spec *spec; - - spec = kzalloc(sizeof(*spec), GFP_KERNEL); - if (spec == NULL) - return -ENOMEM; - - codec->spec = spec; - - spec->multiout.num_dacs = 0; /* no analog */ - spec->multiout.max_channels = 2; - spec->multiout.dig_out_nid = nvhdmi_master_con_nid_7x; - spec->codec_type = HDA_CODEC_NVIDIA_MCP7X; - spec->old_pin_detect = 1; - - codec->patch_ops = nvhdmi_patch_ops_2ch; - - return 0; -} - -/* - * patch entries - */ -static struct hda_codec_preset snd_hda_preset_nvhdmi[] = { - { .id = 0x10de0002, .name = "MCP77/78 HDMI", .patch = patch_nvhdmi_8ch_7x }, - { .id = 0x10de0003, .name = "MCP77/78 HDMI", .patch = patch_nvhdmi_8ch_7x }, - { .id = 0x10de0005, .name = "MCP77/78 HDMI", .patch = patch_nvhdmi_8ch_7x }, - { .id = 0x10de0006, .name = "MCP77/78 HDMI", .patch = patch_nvhdmi_8ch_7x }, - { .id = 0x10de0007, .name = "MCP79/7A HDMI", .patch = patch_nvhdmi_8ch_7x }, - { .id = 0x10de000a, .name = "GPU 0a HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, - { .id = 0x10de000b, .name = "GPU 0b HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, - { .id = 0x10de000c, .name = "MCP89 HDMI", .patch = patch_nvhdmi_8ch_89 }, - { .id = 0x10de000d, .name = "GPU 0d HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, - { .id = 0x10de0010, .name = "GPU 10 HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, - { .id = 0x10de0011, .name = "GPU 11 HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, - { .id = 0x10de0012, .name = "GPU 12 HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, - { .id = 0x10de0013, .name = "GPU 13 HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, - { .id = 0x10de0014, .name = "GPU 14 HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, - { .id = 0x10de0018, .name = "GPU 18 HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, - { .id = 0x10de0019, .name = "GPU 19 HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, - { .id = 0x10de001a, .name = "GPU 1a HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, - { .id = 0x10de001b, .name = "GPU 1b HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, - { .id = 0x10de001c, .name = "GPU 1c HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, - { .id = 0x10de0040, .name = "GPU 40 HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, - { .id = 0x10de0041, .name = "GPU 41 HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, - { .id = 0x10de0042, .name = "GPU 42 HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, - { .id = 0x10de0043, .name = "GPU 43 HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, - { .id = 0x10de0044, .name = "GPU 44 HDMI/DP", .patch = patch_nvhdmi_8ch_89 }, - { .id = 0x10de0067, .name = "MCP67 HDMI", .patch = patch_nvhdmi_2ch }, - { .id = 0x10de8001, .name = "MCP73 HDMI", .patch = patch_nvhdmi_2ch }, - {} /* terminator */ -}; - -MODULE_ALIAS("snd-hda-codec-id:10de0002"); -MODULE_ALIAS("snd-hda-codec-id:10de0003"); -MODULE_ALIAS("snd-hda-codec-id:10de0005"); -MODULE_ALIAS("snd-hda-codec-id:10de0006"); -MODULE_ALIAS("snd-hda-codec-id:10de0007"); -MODULE_ALIAS("snd-hda-codec-id:10de000a"); -MODULE_ALIAS("snd-hda-codec-id:10de000b"); -MODULE_ALIAS("snd-hda-codec-id:10de000c"); -MODULE_ALIAS("snd-hda-codec-id:10de000d"); -MODULE_ALIAS("snd-hda-codec-id:10de0010"); -MODULE_ALIAS("snd-hda-codec-id:10de0011"); -MODULE_ALIAS("snd-hda-codec-id:10de0012"); -MODULE_ALIAS("snd-hda-codec-id:10de0013"); -MODULE_ALIAS("snd-hda-codec-id:10de0014"); -MODULE_ALIAS("snd-hda-codec-id:10de0018"); -MODULE_ALIAS("snd-hda-codec-id:10de0019"); -MODULE_ALIAS("snd-hda-codec-id:10de001a"); -MODULE_ALIAS("snd-hda-codec-id:10de001b"); -MODULE_ALIAS("snd-hda-codec-id:10de001c"); -MODULE_ALIAS("snd-hda-codec-id:10de0040"); -MODULE_ALIAS("snd-hda-codec-id:10de0041"); -MODULE_ALIAS("snd-hda-codec-id:10de0042"); -MODULE_ALIAS("snd-hda-codec-id:10de0043"); -MODULE_ALIAS("snd-hda-codec-id:10de0044"); -MODULE_ALIAS("snd-hda-codec-id:10de0067"); -MODULE_ALIAS("snd-hda-codec-id:10de8001"); - -MODULE_LICENSE("GPL"); -MODULE_DESCRIPTION("NVIDIA HDMI HD-audio codec"); - -static struct hda_codec_preset_list nvhdmi_list = { - .preset = snd_hda_preset_nvhdmi, - .owner = THIS_MODULE, -}; - -static int __init patch_nvhdmi_init(void) -{ - return snd_hda_add_codec_preset(&nvhdmi_list); -} - -static void __exit patch_nvhdmi_exit(void) -{ - snd_hda_delete_codec_preset(&nvhdmi_list); -} - -module_init(patch_nvhdmi_init) -module_exit(patch_nvhdmi_exit) -- cgit v1.1 From f6837bbd599c2a4e1f621441f84286434bcc91ae Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Mon, 20 Sep 2010 14:56:32 +0200 Subject: ALSA: hda - Fix up autocfg output pin numbers in realtek parser When quirks are applied, the numbers of output pins in autocfg aren't set up properly but only pin arrays are changed. Let's fix it up so that the rest of the parser can use autocfg.line_outs & co safely. Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index 6045f28..bb3cf3b 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -876,6 +876,28 @@ static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid, snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val); } +static void alc_fixup_autocfg_pin_nums(struct hda_codec *codec) +{ + struct alc_spec *spec = codec->spec; + struct auto_pin_cfg *cfg = &spec->autocfg; + + if (!cfg->line_outs) { + while (cfg->line_outs < AUTO_CFG_MAX_OUTS && + cfg->line_out_pins[cfg->line_outs]) + cfg->line_outs++; + } + if (!cfg->speaker_outs) { + while (cfg->speaker_outs < AUTO_CFG_MAX_OUTS && + cfg->speaker_pins[cfg->speaker_outs]) + cfg->speaker_outs++; + } + if (!cfg->hp_outs) { + while (cfg->hp_outs < AUTO_CFG_MAX_OUTS && + cfg->hp_pins[cfg->hp_outs]) + cfg->hp_outs++; + } +} + /* */ static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix) @@ -944,6 +966,8 @@ static void setup_preset(struct hda_codec *codec, if (preset->setup) preset->setup(codec); + + alc_fixup_autocfg_pin_nums(codec); } /* Enable GPIO mask and set output */ -- cgit v1.1 From e1ca7b4ea29707920650d86b22afdb7e94ad5986 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Mon, 20 Sep 2010 14:58:57 +0200 Subject: ALSA: hda - Fix initialization of multiple output pins for ALC268/269 When multiple pins are assigned to headphones or speakers, they haven't been initialized properly. Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 20 ++++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index bb3cf3b..c4d9ad7 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -13484,8 +13484,10 @@ static void alc268_auto_set_output_and_unmute(struct hda_codec *codec, static void alc268_auto_init_multi_out(struct hda_codec *codec) { struct alc_spec *spec = codec->spec; - hda_nid_t nid = spec->autocfg.line_out_pins[0]; - if (nid) { + int i; + + for (i = 0; i < spec->autocfg.line_outs; i++) { + hda_nid_t nid = spec->autocfg.line_out_pins[i]; int pin_type = get_pin_type(spec->autocfg.line_out_type); alc268_auto_set_output_and_unmute(codec, nid, pin_type); } @@ -13495,13 +13497,19 @@ static void alc268_auto_init_hp_out(struct hda_codec *codec) { struct alc_spec *spec = codec->spec; hda_nid_t pin; + int i; - pin = spec->autocfg.hp_pins[0]; - if (pin) + for (i = 0; i < spec->autocfg.hp_outs; i++) { + pin = spec->autocfg.hp_pins[i]; alc268_auto_set_output_and_unmute(codec, pin, PIN_HP); - pin = spec->autocfg.speaker_pins[0]; - if (pin) + } + for (i = 0; i < spec->autocfg.speaker_outs; i++) { + pin = spec->autocfg.speaker_pins[i]; alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT); + } + if (spec->autocfg.mono_out_pin) + snd_hda_codec_write(codec, spec->autocfg.mono_out_pin, 0, + AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT); } static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec) -- cgit v1.1 From d433a67831ab2c470cc53a3ff9b60f656767be15 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Mon, 20 Sep 2010 15:11:54 +0200 Subject: ALSA: hda - Optimize the check of ALC269 codec variants Don't call the COEF check for checking ACL269 codec variants at each time in init but remember the type at the initialization. Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 21 +++++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index c4d9ad7..9bcf34e 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -393,6 +393,7 @@ struct alc_spec { unsigned int no_analog :1; /* digital I/O only */ unsigned int dual_adc_switch:1; /* switch ADCs (for ALC275) */ int init_amp; + int codec_variant; /* flag for other variants */ /* for virtual master */ hda_nid_t vmaster_nid; @@ -14568,6 +14569,13 @@ static int alc275_setup_dual_adc(struct hda_codec *codec) return 0; } +/* different alc269-variants */ +enum { + ALC269_TYPE_NORMAL, + ALC269_TYPE_ALC259, + ALC269_TYPE_ALC271X, +}; + /* * BIOS auto configuration */ @@ -14596,7 +14604,7 @@ static int alc269_parse_auto_config(struct hda_codec *codec) if (spec->kctls.list) add_mixer(spec, spec->kctls.list); - if ((alc_read_coef_idx(codec, 0) & 0x00f0) == 0x0010) { + if (spec->codec_variant != ALC269_TYPE_NORMAL) { add_verb(spec, alc269vb_init_verbs); alc_ssid_check(codec, 0, 0x1b, 0x14, 0x21); } else { @@ -14962,7 +14970,6 @@ static int patch_alc269(struct hda_codec *codec) struct alc_spec *spec; int board_config; int err; - int is_alc269vb = 0; spec = kzalloc(sizeof(*spec), GFP_KERNEL); if (spec == NULL) @@ -14974,11 +14981,13 @@ static int patch_alc269(struct hda_codec *codec) if ((alc_read_coef_idx(codec, 0) & 0x00f0) == 0x0010){ if (codec->bus->pci->subsystem_vendor == 0x1025 && - spec->cdefine.platform_type == 1) + spec->cdefine.platform_type == 1) { alc_codec_rename(codec, "ALC271X"); - else + spec->codec_variant = ALC269_TYPE_ALC271X; + } else { alc_codec_rename(codec, "ALC259"); - is_alc269vb = 1; + spec->codec_variant = ALC269_TYPE_ALC259; + } } else alc_fix_pll_init(codec, 0x20, 0x04, 15); @@ -15040,7 +15049,7 @@ static int patch_alc269(struct hda_codec *codec) spec->stream_digital_capture = &alc269_pcm_digital_capture; if (!spec->adc_nids) { /* wasn't filled automatically? use default */ - if (!is_alc269vb) { + if (spec->codec_variant != ALC269_TYPE_NORMAL) { spec->adc_nids = alc269_adc_nids; spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids); spec->capsrc_nids = alc269_capsrc_nids; -- cgit v1.1 From f3550d1b052a8acf4159b407dbdd1def47f223f9 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Mon, 20 Sep 2010 15:09:03 +0200 Subject: ALSA: hda - Fix capture widget for ALC269vb and co ALC269vb and other variants don't use the widgets 0x24 but prefer the widget 0x22 instead. We need to fix the input parser. Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index 9bcf34e..4abe3da1 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -14593,7 +14593,11 @@ static int alc269_parse_auto_config(struct hda_codec *codec) err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg); if (err < 0) return err; - err = alc269_auto_create_input_ctls(codec, &spec->autocfg); + if (spec->codec_variant == ALC269_TYPE_NORMAL) + err = alc269_auto_create_input_ctls(codec, &spec->autocfg); + else + err = alc_auto_create_input_ctls(codec, &spec->autocfg, 0, + 0x22, 0); if (err < 0) return err; -- cgit v1.1 From 0ec33d1f952934ea3251cefc6d108b47818eedd0 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Mon, 20 Sep 2010 15:20:52 +0200 Subject: ALSA: hda - Refactor ALC269 power-ups/downs in PM callbacks Create a helper function to simplify the code. Also, cleaned up the ifdef SND_HDA_NEEDS_RESUME and CONFIG_SND_HDA_POWER_SAVE. The former is always defined when the latter is set. Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 51 ++++++++++++++++++------------------------- 1 file changed, 21 insertions(+), 30 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index 4abe3da1..8689216 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -4128,10 +4128,8 @@ static int alc_resume(struct hda_codec *codec) codec->patch_ops.init(codec); snd_hda_codec_resume_amp(codec); snd_hda_codec_resume_cache(codec); -#ifdef CONFIG_SND_HDA_POWER_SAVE if (codec->patch_ops.check_power_status) codec->patch_ops.check_power_status(codec, 0x01); -#endif return 0; } #endif @@ -14656,22 +14654,26 @@ static void alc269_auto_init(struct hda_codec *codec) alc_inithook(codec); } +#ifdef SND_HDA_NEEDS_RESUME +static void alc269_toggle_power_output(struct hda_codec *codec, int power_up) +{ + int val = alc_read_coef_idx(codec, 0x04); + if (power_up) + val |= 1 << 11; + else + val &= ~(1 << 11); + alc_write_coef_idx(codec, 0x04, val); +} + #ifdef CONFIG_SND_HDA_POWER_SAVE static int alc269_suspend(struct hda_codec *codec, pm_message_t state) { struct alc_spec *spec = codec->spec; - int val; - - if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) { - val = alc_read_coef_idx(codec, 0x04); - /* Power down output pin */ - alc_write_coef_idx(codec, 0x04, val & ~(1<<11)); - } + if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) + alc269_toggle_power_output(codec, 0); if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) { - val = alc_read_coef_idx(codec, 0x04); - /* Power down output pin */ - alc_write_coef_idx(codec, 0x04, val & ~(1<<11)); + alc269_toggle_power_output(codec, 0); msleep(150); } @@ -14680,43 +14682,32 @@ static int alc269_suspend(struct hda_codec *codec, pm_message_t state) spec->power_hook(codec); return 0; } -#endif -#ifdef SND_HDA_NEEDS_RESUME +#endif /* CONFIG_SND_HDA_POWER_SAVE */ + static int alc269_resume(struct hda_codec *codec) { - int val; - if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) { - val = alc_read_coef_idx(codec, 0x04); - /* Power down output pin */ - alc_write_coef_idx(codec, 0x04, val & ~(1<<11)); + alc269_toggle_power_output(codec, 0); msleep(150); } codec->patch_ops.init(codec); if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x017) { - val = alc_read_coef_idx(codec, 0x04); - /* Power up output pin */ - alc_write_coef_idx(codec, 0x04, val | (1<<11)); + alc269_toggle_power_output(codec, 1); msleep(200); } - if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) { - val = alc_read_coef_idx(codec, 0x04); - /* Power up output pin */ - alc_write_coef_idx(codec, 0x04, val | (1<<11)); - } + if ((alc_read_coef_idx(codec, 0) & 0x00ff) == 0x018) + alc269_toggle_power_output(codec, 1); snd_hda_codec_resume_amp(codec); snd_hda_codec_resume_cache(codec); -#ifdef CONFIG_SND_HDA_POWER_SAVE if (codec->patch_ops.check_power_status) codec->patch_ops.check_power_status(codec, 0x01); -#endif return 0; } -#endif +#endif /* SND_HDA_NEEDS_RESUME */ enum { ALC269_FIXUP_SONY_VAIO, -- cgit v1.1 From 53d7d69d8ffdfa60c5b66cc2e9ee0774aaaef5c0 Mon Sep 17 00:00:00 2001 From: Wu Fengguang Date: Tue, 21 Sep 2010 14:25:49 +0800 Subject: ALSA: hdmi - support infoframe for DisplayPort DisplayPort works mostly in the same way as HDMI, except that it expects a slightly different audio infoframe format. Citations from "HDA036-A: Display Port Support and HDMI Miscellaneous Corrections": The HDMI specification defines a data island packet with a header of 4 bytes (3 bytes content + 1 byte ECC) and packet body of 32 bytes (28 bytes content and 4 bytes ECC). Display Port specification on the other hand defines a data island packet (secondary data packet) with header of 4 bytes protected by 4 bytes of parity, and data of theoretically up to 1024 bytes with each 16 bytes chunk of data protected by 4 bytes of parity. Note that the ECC or parity bytes are not present in the DIP content populated by software and are hardware generated. It tests DP connection based on the ELD conn_type field, which will be set by the graphics driver and can be overriden manually by users through the /proc/asound/card0/eld* interface. The DP infoframe is tested OK on Intel SandyBridge/CougarPoint platform. Signed-off-by: Wu Fengguang Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_hdmi.c | 110 ++++++++++++++++++++++++++++++--------------- 1 file changed, 73 insertions(+), 37 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_hdmi.c b/sound/pci/hda/patch_hdmi.c index cb997ca..1f4ae1a 100644 --- a/sound/pci/hda/patch_hdmi.c +++ b/sound/pci/hda/patch_hdmi.c @@ -84,13 +84,25 @@ struct hdmi_audio_infoframe { u8 ver; /* 0x01 */ u8 len; /* 0x0a */ - u8 checksum; /* PB0 */ + u8 checksum; + u8 CC02_CT47; /* CC in bits 0:2, CT in 4:7 */ u8 SS01_SF24; u8 CXT04; u8 CA; u8 LFEPBL01_LSV36_DM_INH7; - u8 reserved[5]; /* PB6 - PB10 */ +}; + +struct dp_audio_infoframe { + u8 type; /* 0x84 */ + u8 len; /* 0x1b */ + u8 ver; /* 0x11 << 2 */ + + u8 CC02_CT47; /* match with HDMI infoframe from this on */ + u8 SS01_SF24; + u8 CXT04; + u8 CA; + u8 LFEPBL01_LSV36_DM_INH7; }; /* @@ -194,7 +206,7 @@ static int hdmi_channel_mapping[0x32][8] = { * This is an ordered list! * * The preceding ones have better chances to be selected by - * hdmi_setup_channel_allocation(). + * hdmi_channel_allocation(). */ static struct cea_channel_speaker_allocation channel_allocations[] = { /* channel: 7 6 5 4 3 2 1 0 */ @@ -371,14 +383,14 @@ static void init_channel_allocations(void) * * TODO: it could select the wrong CA from multiple candidates. */ -static int hdmi_setup_channel_allocation(struct hda_codec *codec, hda_nid_t nid, - struct hdmi_audio_infoframe *ai) +static int hdmi_channel_allocation(struct hda_codec *codec, hda_nid_t nid, + int channels) { struct hdmi_spec *spec = codec->spec; struct hdmi_eld *eld; int i; + int ca = 0; int spk_mask = 0; - int channels = 1 + (ai->CC02_CT47 & 0x7); char buf[SND_PRINT_CHANNEL_ALLOCATION_ADVISED_BUFSIZE]; /* @@ -416,16 +428,16 @@ static int hdmi_setup_channel_allocation(struct hda_codec *codec, hda_nid_t nid, if (channels == channel_allocations[i].channels && (spk_mask & channel_allocations[i].spk_mask) == channel_allocations[i].spk_mask) { - ai->CA = channel_allocations[i].ca_index; + ca = channel_allocations[i].ca_index; break; } } snd_print_channel_allocation(eld->spk_alloc, buf, sizeof(buf)); snd_printdd("HDMI: select CA 0x%x for %d-channel allocation: %s\n", - ai->CA, channels, buf); + ca, channels, buf); - return ai->CA; + return ca; } static void hdmi_debug_channel_mapping(struct hda_codec *codec, @@ -447,10 +459,9 @@ static void hdmi_debug_channel_mapping(struct hda_codec *codec, static void hdmi_setup_channel_mapping(struct hda_codec *codec, hda_nid_t pin_nid, - struct hdmi_audio_infoframe *ai) + int ca) { int i; - int ca = ai->CA; int err; if (hdmi_channel_mapping[ca][1] == 0) { @@ -547,41 +558,37 @@ static void hdmi_clear_dip_buffers(struct hda_codec *codec, hda_nid_t pin_nid) #endif } -static void hdmi_checksum_audio_infoframe(struct hdmi_audio_infoframe *ai) +static void hdmi_checksum_audio_infoframe(struct hdmi_audio_infoframe *hdmi_ai) { - u8 *bytes = (u8 *)ai; + u8 *bytes = (u8 *)hdmi_ai; u8 sum = 0; int i; - ai->checksum = 0; + hdmi_ai->checksum = 0; - for (i = 0; i < sizeof(*ai); i++) + for (i = 0; i < sizeof(*hdmi_ai); i++) sum += bytes[i]; - ai->checksum = -sum; + hdmi_ai->checksum = -sum; } static void hdmi_fill_audio_infoframe(struct hda_codec *codec, hda_nid_t pin_nid, - struct hdmi_audio_infoframe *ai) + u8 *dip, int size) { - u8 *bytes = (u8 *)ai; int i; hdmi_debug_dip_size(codec, pin_nid); hdmi_clear_dip_buffers(codec, pin_nid); /* be paranoid */ - hdmi_checksum_audio_infoframe(ai); - hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0); - for (i = 0; i < sizeof(*ai); i++) - hdmi_write_dip_byte(codec, pin_nid, bytes[i]); + for (i = 0; i < size; i++) + hdmi_write_dip_byte(codec, pin_nid, dip[i]); } static bool hdmi_infoframe_uptodate(struct hda_codec *codec, hda_nid_t pin_nid, - struct hdmi_audio_infoframe *ai) + u8 *dip, int size) { - u8 *bytes = (u8 *)ai; u8 val; int i; @@ -590,10 +597,10 @@ static bool hdmi_infoframe_uptodate(struct hda_codec *codec, hda_nid_t pin_nid, return false; hdmi_set_dip_index(codec, pin_nid, 0x0, 0x0); - for (i = 0; i < sizeof(*ai); i++) { + for (i = 0; i < size; i++) { val = snd_hda_codec_read(codec, pin_nid, 0, AC_VERB_GET_HDMI_DIP_DATA, 0); - if (val != bytes[i]) + if (val != dip[i]) return false; } @@ -605,15 +612,13 @@ static void hdmi_setup_audio_infoframe(struct hda_codec *codec, hda_nid_t nid, { struct hdmi_spec *spec = codec->spec; hda_nid_t pin_nid; + int channels = substream->runtime->channels; + int ca; int i; - struct hdmi_audio_infoframe ai = { - .type = 0x84, - .ver = 0x01, - .len = 0x0a, - .CC02_CT47 = substream->runtime->channels - 1, - }; + u8 ai[max(sizeof(struct hdmi_audio_infoframe), + sizeof(struct dp_audio_infoframe))]; - hdmi_setup_channel_allocation(codec, nid, &ai); + ca = hdmi_channel_allocation(codec, nid, channels); for (i = 0; i < spec->num_pins; i++) { if (spec->pin_cvt[i] != nid) @@ -622,14 +627,45 @@ static void hdmi_setup_audio_infoframe(struct hda_codec *codec, hda_nid_t nid, continue; pin_nid = spec->pin[i]; - if (!hdmi_infoframe_uptodate(codec, pin_nid, &ai)) { + + memset(ai, 0, sizeof(ai)); + if (spec->sink_eld[i].conn_type == 0) { /* HDMI */ + struct hdmi_audio_infoframe *hdmi_ai; + + hdmi_ai = (struct hdmi_audio_infoframe *)ai; + hdmi_ai->type = 0x84; + hdmi_ai->ver = 0x01; + hdmi_ai->len = 0x0a; + hdmi_ai->CC02_CT47 = channels - 1; + hdmi_checksum_audio_infoframe(hdmi_ai); + } else if (spec->sink_eld[i].conn_type == 1) { /* DisplayPort */ + struct dp_audio_infoframe *dp_ai; + + dp_ai = (struct dp_audio_infoframe *)ai; + dp_ai->type = 0x84; + dp_ai->len = 0x1b; + dp_ai->ver = 0x11 << 2; + dp_ai->CC02_CT47 = channels - 1; + } else { + snd_printd("HDMI: unknown connection type at pin %d\n", + pin_nid); + continue; + } + + /* + * sizeof(ai) is used instead of sizeof(*hdmi_ai) or + * sizeof(*dp_ai) to avoid partial match/update problems when + * the user switches between HDMI/DP monitors. + */ + if (!hdmi_infoframe_uptodate(codec, pin_nid, ai, sizeof(ai))) { snd_printdd("hdmi_setup_audio_infoframe: " "cvt=%d pin=%d channels=%d\n", nid, pin_nid, - substream->runtime->channels); - hdmi_setup_channel_mapping(codec, pin_nid, &ai); + channels); + hdmi_setup_channel_mapping(codec, pin_nid, ca); hdmi_stop_infoframe_trans(codec, pin_nid); - hdmi_fill_audio_infoframe(codec, pin_nid, &ai); + hdmi_fill_audio_infoframe(codec, pin_nid, + ai, sizeof(ai)); hdmi_start_infoframe_trans(codec, pin_nid); } } -- cgit v1.1 From 9396d3174b761685d6fefb1103e66b96a2e5db6d Mon Sep 17 00:00:00 2001 From: Jerry Zhou Date: Tue, 21 Sep 2010 14:44:51 +0800 Subject: ALSA: hdmi - fix surround41 channel mapping Channel 2 and channel 3 were all wrongly mapped to HDMI slot 4. This shows up as a bug that one channel is "lost" when playing in surround41 mode. Signed-off-by: Jerry Zhou Signed-off-by: Wu Fengguang Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_hdmi.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_hdmi.c b/sound/pci/hda/patch_hdmi.c index 1f4ae1a..d3e49aa 100644 --- a/sound/pci/hda/patch_hdmi.c +++ b/sound/pci/hda/patch_hdmi.c @@ -193,7 +193,7 @@ static int hdmi_channel_mapping[0x32][8] = { /* 4ch */ [0x03] = { 0x00, 0x11, 0x23, 0x32, 0x44, 0xf5, 0xf6, 0xf7 }, /* surround41 */ - [0x09] = { 0x00, 0x11, 0x24, 0x34, 0x43, 0xf2, 0xf6, 0xf7 }, + [0x09] = { 0x00, 0x11, 0x24, 0x35, 0x42, 0xf3, 0xf6, 0xf7 }, /* surround50 */ [0x0a] = { 0x00, 0x11, 0x24, 0x35, 0x43, 0xf2, 0xf6, 0xf7 }, /* surround51 */ -- cgit v1.1 From 9e5341b92d1d2dde11691b394721b45b36416bef Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Tue, 21 Sep 2010 09:57:06 +0200 Subject: ALSA: hda - Introduce hda_call_check_power_status() helper Replace the explicit ifdef check and call of check_power_status ops with a new helper function, hda_call_check_power_status(). Signed-off-by: Takashi Iwai --- sound/pci/hda/hda_codec.c | 5 +---- sound/pci/hda/hda_codec.h | 12 ++++++++++++ sound/pci/hda/patch_realtek.c | 11 +++-------- sound/pci/hda/patch_sigmatel.c | 12 ++++-------- 4 files changed, 20 insertions(+), 20 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c index e15a7575..053f827 100644 --- a/sound/pci/hda/hda_codec.c +++ b/sound/pci/hda/hda_codec.c @@ -2228,10 +2228,7 @@ int snd_hda_mixer_amp_switch_put(struct snd_kcontrol *kcontrol, change |= snd_hda_codec_amp_update(codec, nid, 1, dir, idx, HDA_AMP_MUTE, *valp ? 0 : HDA_AMP_MUTE); -#ifdef CONFIG_SND_HDA_POWER_SAVE - if (codec->patch_ops.check_power_status) - codec->patch_ops.check_power_status(codec, nid); -#endif + hda_call_check_power_status(codec, nid); snd_hda_power_down(codec); return change; } diff --git a/sound/pci/hda/hda_codec.h b/sound/pci/hda/hda_codec.h index 62c7022..ebf8eb02 100644 --- a/sound/pci/hda/hda_codec.h +++ b/sound/pci/hda/hda_codec.h @@ -989,6 +989,18 @@ int snd_hda_suspend(struct hda_bus *bus); int snd_hda_resume(struct hda_bus *bus); #endif +#ifdef CONFIG_SND_HDA_POWER_SAVE +static inline +int hda_call_check_power_status(struct hda_codec *codec, hda_nid_t nid) +{ + if (codec->patch_ops.check_power_status) + return codec->patch_ops.check_power_status(codec, nid); + return 0; +} +#else +#define hda_call_check_power_status(codec, nid) 0 +#endif + /* * get widget information */ diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index 8689216..9bedca0 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -3729,10 +3729,7 @@ static int alc_init(struct hda_codec *codec) if (spec->init_hook) spec->init_hook(codec); -#ifdef CONFIG_SND_HDA_POWER_SAVE - if (codec->patch_ops.check_power_status) - codec->patch_ops.check_power_status(codec, 0x01); -#endif + hda_call_check_power_status(codec, 0x01); return 0; } @@ -4128,8 +4125,7 @@ static int alc_resume(struct hda_codec *codec) codec->patch_ops.init(codec); snd_hda_codec_resume_amp(codec); snd_hda_codec_resume_cache(codec); - if (codec->patch_ops.check_power_status) - codec->patch_ops.check_power_status(codec, 0x01); + hda_call_check_power_status(codec, 0x01); return 0; } #endif @@ -14703,8 +14699,7 @@ static int alc269_resume(struct hda_codec *codec) snd_hda_codec_resume_amp(codec); snd_hda_codec_resume_cache(codec); - if (codec->patch_ops.check_power_status) - codec->patch_ops.check_power_status(codec, 0x01); + hda_call_check_power_status(codec, 0x01); return 0; } #endif /* SND_HDA_NEEDS_RESUME */ diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c index 6bfbc2f..a90327b 100644 --- a/sound/pci/hda/patch_sigmatel.c +++ b/sound/pci/hda/patch_sigmatel.c @@ -4372,11 +4372,9 @@ static int stac92xx_init(struct hda_codec *codec) stac_issue_unsol_event(codec, nid); } -#ifdef CONFIG_SND_HDA_POWER_SAVE /* sync mute LED */ - if (spec->gpio_led && codec->patch_ops.check_power_status) - codec->patch_ops.check_power_status(codec, 0x01); -#endif + if (spec->gpio_led) + hda_call_check_power_status(codec, 0x01); if (spec->dac_list) stac92xx_power_down(codec); return 0; @@ -4958,11 +4956,9 @@ static int stac92xx_resume(struct hda_codec *codec) stac_issue_unsol_event(codec, spec->autocfg.line_out_pins[0]); } -#ifdef CONFIG_SND_HDA_POWER_SAVE /* sync mute LED */ - if (spec->gpio_led && codec->patch_ops.check_power_status) - codec->patch_ops.check_power_status(codec, 0x01); -#endif + if (spec->gpio_led) + hda_call_check_power_status(codec, 0x01); return 0; } -- cgit v1.1 From 0f9f1ee9d1412d45a22bfd69dfd4d4324b506e9e Mon Sep 17 00:00:00 2001 From: Luke Yelavich Date: Tue, 21 Sep 2010 17:05:46 +1000 Subject: ALSA: hda - Add Dell Latitude E6400 model quirk BugLink: https://bugs.launchpad.net/ubuntu/+source/linux/+bug/643891 Set the Dell Latitude E6400 (1028:0233) SSID to use AD1984_DELL_DESKTOP Cc: stable@kernel.org Signed-off-by: Luke Yelavich Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_analog.c | 1 + 1 file changed, 1 insertion(+) (limited to 'sound') diff --git a/sound/pci/hda/patch_analog.c b/sound/pci/hda/patch_analog.c index b697fd2..10bbbaf 100644 --- a/sound/pci/hda/patch_analog.c +++ b/sound/pci/hda/patch_analog.c @@ -3641,6 +3641,7 @@ static struct snd_pci_quirk ad1984_cfg_tbl[] = { /* Lenovo Thinkpad T61/X61 */ SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo Thinkpad", AD1984_THINKPAD), SND_PCI_QUIRK(0x1028, 0x0214, "Dell T3400", AD1984_DELL_DESKTOP), + SND_PCI_QUIRK(0x1028, 0x0233, "Dell Latitude E6400", AD1984_DELL_DESKTOP), {} }; -- cgit v1.1 From 265a02478db5217eda8063004ded1ef0a461c240 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Tue, 21 Sep 2010 11:26:21 +0200 Subject: ALSA: hda - Check invalid NIDs in alc_init_jacks() The headphone and external-mic pin NIDs can be null, and the jack input elements should be skipped in such a case. Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index 9bedca0..f5ccba0 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -1087,15 +1087,19 @@ static int alc_init_jacks(struct hda_codec *codec) unsigned int hp_nid = spec->autocfg.hp_pins[0]; unsigned int mic_nid = spec->ext_mic.pin; - err = alc_add_jack(codec, hp_nid, SND_JACK_HEADPHONE); - if (err < 0) - return err; - alc_report_jack(codec, hp_nid); + if (hp_nid) { + err = alc_add_jack(codec, hp_nid, SND_JACK_HEADPHONE); + if (err < 0) + return err; + alc_report_jack(codec, hp_nid); + } - err = alc_add_jack(codec, mic_nid, SND_JACK_MICROPHONE); - if (err < 0) - return err; - alc_report_jack(codec, mic_nid); + if (mic_nid) { + err = alc_add_jack(codec, mic_nid, SND_JACK_MICROPHONE); + if (err < 0) + return err; + alc_report_jack(codec, mic_nid); + } return 0; } -- cgit v1.1 From abdd8f510686da0a58e475bc0143d1069e5f53da Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Tue, 21 Sep 2010 17:38:14 +0200 Subject: ALSA: hda - Apply ALC269 VAIO fix-up to all Sony laptops with ALC269 We've applied a fix-up for ALC269 VAIO only for two models. But all Sony VAIO models with ALC269 codec seem to require the similar fix. Let's apply it with vendor-id mask. Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index f2a3044..eea88b7 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -14731,8 +14731,7 @@ static const struct alc_fixup alc269_fixups[] = { }; static struct snd_pci_quirk alc269_fixup_tbl[] = { - SND_PCI_QUIRK(0x104d, 0x9071, "Sony VAIO", ALC269_FIXUP_SONY_VAIO), - SND_PCI_QUIRK(0x104d, 0x9077, "Sony VAIO", ALC269_FIXUP_SONY_VAIO), + SND_PCI_QUIRK_VENDOR(0x104d, "Sony VAIO", ALC269_FIXUP_SONY_VAIO), SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z), {} }; -- cgit v1.1 From 0873a5ae747847ee55a63db409dff3476e45bcd9 Mon Sep 17 00:00:00 2001 From: "Erik J. Staab" Date: Wed, 22 Sep 2010 11:07:41 +0200 Subject: ALSA: oxygen: fix analog capture on Claro halo cards On the HT-Omega Claro halo card, the ADC data must be captured from the second I2S input. Using the default first input, which isn't connected to anything, would result in silence. Signed-off-by: Erik J. Staab Signed-off-by: Clemens Ladisch Cc: Signed-off-by: Takashi Iwai --- sound/pci/oxygen/oxygen.c | 4 ++++ 1 file changed, 4 insertions(+) (limited to 'sound') diff --git a/sound/pci/oxygen/oxygen.c b/sound/pci/oxygen/oxygen.c index 289cb4d..6c0a11a 100644 --- a/sound/pci/oxygen/oxygen.c +++ b/sound/pci/oxygen/oxygen.c @@ -543,6 +543,10 @@ static int __devinit get_oxygen_model(struct oxygen *chip, chip->model.suspend = claro_suspend; chip->model.resume = claro_resume; chip->model.set_adc_params = set_ak5385_params; + chip->model.device_config = PLAYBACK_0_TO_I2S | + PLAYBACK_1_TO_SPDIF | + CAPTURE_0_FROM_I2S_2 | + CAPTURE_1_FROM_SPDIF; break; } if (id->driver_data == MODEL_MERIDIAN || -- cgit v1.1 From 095a0f6df246bdc57b57d616c4698e41fbd3bf43 Mon Sep 17 00:00:00 2001 From: John Kacur Date: Wed, 22 Sep 2010 13:47:01 +0200 Subject: SOUND-OSS: Remove sh_dac_audio Remove the SH DAC oss driver since there is an equivalent alsa driver. oss has been deprecated for years. Furthermore this driver has BKL code which we are trying to remove. Rather than attempt to fix this, simply remove the driver. Signed-off-by: John Kacur Acked-by: Paul Mundt Acked-by: Ralf Baechle Signed-off-by: Takashi Iwai --- sound/oss/Kconfig | 8 -- sound/oss/Makefile | 1 - sound/oss/sh_dac_audio.c | 326 ----------------------------------------------- 3 files changed, 335 deletions(-) delete mode 100644 sound/oss/sh_dac_audio.c (limited to 'sound') diff --git a/sound/oss/Kconfig b/sound/oss/Kconfig index a513651..76c0902 100644 --- a/sound/oss/Kconfig +++ b/sound/oss/Kconfig @@ -545,11 +545,3 @@ config SOUND_KAHLUA endif # SOUND_OSS -config SOUND_SH_DAC_AUDIO - tristate "SuperH DAC audio support" - depends on CPU_SH3 && HIGH_RES_TIMERS - -config SOUND_SH_DAC_AUDIO_CHANNEL - int "DAC channel" - default "1" - depends on SOUND_SH_DAC_AUDIO diff --git a/sound/oss/Makefile b/sound/oss/Makefile index 567b8a7..96f14dc 100644 --- a/sound/oss/Makefile +++ b/sound/oss/Makefile @@ -9,7 +9,6 @@ obj-$(CONFIG_SOUND_OSS) += sound.o # Please leave it as is, cause the link order is significant ! -obj-$(CONFIG_SOUND_SH_DAC_AUDIO) += sh_dac_audio.o obj-$(CONFIG_SOUND_AEDSP16) += aedsp16.o obj-$(CONFIG_SOUND_PSS) += pss.o ad1848.o mpu401.o obj-$(CONFIG_SOUND_TRIX) += trix.o ad1848.o sb_lib.o uart401.o diff --git a/sound/oss/sh_dac_audio.c b/sound/oss/sh_dac_audio.c deleted file mode 100644 index 53bba16b..0000000 --- a/sound/oss/sh_dac_audio.c +++ /dev/null @@ -1,326 +0,0 @@ -/* - * sound/oss/sh_dac_audio.c - * - * SH DAC based sound :( - * - * Copyright (C) 2004,2005 Andriy Skulysh - * - * This file is subject to the terms and conditions of the GNU General Public - * License. See the file "COPYING" in the main directory of this archive - * for more details. - */ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#define MODNAME "sh_dac_audio" - -#define BUFFER_SIZE 48000 - -static DEFINE_MUTEX(sh_dac_audio_mutex); -static int rate; -static int empty; -static char *data_buffer, *buffer_begin, *buffer_end; -static int in_use, device_major; -static struct hrtimer hrtimer; -static ktime_t wakeups_per_second; - -static void dac_audio_start_timer(void) -{ - hrtimer_start(&hrtimer, wakeups_per_second, HRTIMER_MODE_REL); -} - -static void dac_audio_stop_timer(void) -{ - hrtimer_cancel(&hrtimer); -} - -static void dac_audio_reset(void) -{ - dac_audio_stop_timer(); - buffer_begin = buffer_end = data_buffer; - empty = 1; -} - -static void dac_audio_sync(void) -{ - while (!empty) - schedule(); -} - -static void dac_audio_start(void) -{ - if (mach_is_hp6xx()) { - u16 v = __raw_readw(HD64461_GPADR); - v &= ~HD64461_GPADR_SPEAKER; - __raw_writew(v, HD64461_GPADR); - } - - sh_dac_enable(CONFIG_SOUND_SH_DAC_AUDIO_CHANNEL); -} -static void dac_audio_stop(void) -{ - dac_audio_stop_timer(); - - if (mach_is_hp6xx()) { - u16 v = __raw_readw(HD64461_GPADR); - v |= HD64461_GPADR_SPEAKER; - __raw_writew(v, HD64461_GPADR); - } - - sh_dac_output(0, CONFIG_SOUND_SH_DAC_AUDIO_CHANNEL); - sh_dac_disable(CONFIG_SOUND_SH_DAC_AUDIO_CHANNEL); -} - -static void dac_audio_set_rate(void) -{ - wakeups_per_second = ktime_set(0, 1000000000 / rate); -} - -static int dac_audio_ioctl(struct file *file, - unsigned int cmd, unsigned long arg) -{ - int val; - - switch (cmd) { - case OSS_GETVERSION: - return put_user(SOUND_VERSION, (int *)arg); - - case SNDCTL_DSP_SYNC: - dac_audio_sync(); - return 0; - - case SNDCTL_DSP_RESET: - dac_audio_reset(); - return 0; - - case SNDCTL_DSP_GETFMTS: - return put_user(AFMT_U8, (int *)arg); - - case SNDCTL_DSP_SETFMT: - return put_user(AFMT_U8, (int *)arg); - - case SNDCTL_DSP_NONBLOCK: - spin_lock(&file->f_lock); - file->f_flags |= O_NONBLOCK; - spin_unlock(&file->f_lock); - return 0; - - case SNDCTL_DSP_GETCAPS: - return 0; - - case SOUND_PCM_WRITE_RATE: - val = *(int *)arg; - if (val > 0) { - rate = val; - dac_audio_set_rate(); - } - return put_user(rate, (int *)arg); - - case SNDCTL_DSP_STEREO: - return put_user(0, (int *)arg); - - case SOUND_PCM_WRITE_CHANNELS: - return put_user(1, (int *)arg); - - case SNDCTL_DSP_SETDUPLEX: - return -EINVAL; - - case SNDCTL_DSP_PROFILE: - return -EINVAL; - - case SNDCTL_DSP_GETBLKSIZE: - return put_user(BUFFER_SIZE, (int *)arg); - - case SNDCTL_DSP_SETFRAGMENT: - return 0; - - default: - printk(KERN_ERR "sh_dac_audio: unimplemented ioctl=0x%x\n", - cmd); - return -EINVAL; - } - return -EINVAL; -} - -static long dac_audio_unlocked_ioctl(struct file *file, u_int cmd, u_long arg) -{ - int ret; - - mutex_lock(&sh_dac_audio_mutex); - ret = dac_audio_ioctl(file, cmd, arg); - mutex_unlock(&sh_dac_audio_mutex); - - return ret; -} - -static ssize_t dac_audio_write(struct file *file, const char *buf, size_t count, - loff_t * ppos) -{ - int free; - int nbytes; - - if (!count) { - dac_audio_sync(); - return 0; - } - - free = buffer_begin - buffer_end; - - if (free < 0) - free += BUFFER_SIZE; - if ((free == 0) && (empty)) - free = BUFFER_SIZE; - if (count > free) - count = free; - if (buffer_begin > buffer_end) { - if (copy_from_user((void *)buffer_end, buf, count)) - return -EFAULT; - - buffer_end += count; - } else { - nbytes = data_buffer + BUFFER_SIZE - buffer_end; - if (nbytes > count) { - if (copy_from_user((void *)buffer_end, buf, count)) - return -EFAULT; - buffer_end += count; - } else { - if (copy_from_user((void *)buffer_end, buf, nbytes)) - return -EFAULT; - if (copy_from_user - ((void *)data_buffer, buf + nbytes, count - nbytes)) - return -EFAULT; - buffer_end = data_buffer + count - nbytes; - } - } - - if (empty) { - empty = 0; - dac_audio_start_timer(); - } - - return count; -} - -static ssize_t dac_audio_read(struct file *file, char *buf, size_t count, - loff_t * ppos) -{ - return -EINVAL; -} - -static int dac_audio_open(struct inode *inode, struct file *file) -{ - if (file->f_mode & FMODE_READ) - return -ENODEV; - - mutex_lock(&sh_dac_audio_mutex); - if (in_use) { - mutex_unlock(&sh_dac_audio_mutex); - return -EBUSY; - } - - in_use = 1; - - dac_audio_start(); - mutex_unlock(&sh_dac_audio_mutex); - return 0; -} - -static int dac_audio_release(struct inode *inode, struct file *file) -{ - dac_audio_sync(); - dac_audio_stop(); - in_use = 0; - - return 0; -} - -const struct file_operations dac_audio_fops = { - .read = dac_audio_read, - .write = dac_audio_write, - .unlocked_ioctl = dac_audio_unlocked_ioctl, - .open = dac_audio_open, - .release = dac_audio_release, -}; - -static enum hrtimer_restart sh_dac_audio_timer(struct hrtimer *handle) -{ - if (!empty) { - sh_dac_output(*buffer_begin, CONFIG_SOUND_SH_DAC_AUDIO_CHANNEL); - buffer_begin++; - - if (buffer_begin == data_buffer + BUFFER_SIZE) - buffer_begin = data_buffer; - if (buffer_begin == buffer_end) - empty = 1; - } - - if (!empty) - hrtimer_start(&hrtimer, wakeups_per_second, HRTIMER_MODE_REL); - - return HRTIMER_NORESTART; -} - -static int __init dac_audio_init(void) -{ - if ((device_major = register_sound_dsp(&dac_audio_fops, -1)) < 0) { - printk(KERN_ERR "Cannot register dsp device"); - return device_major; - } - - in_use = 0; - - data_buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL); - if (data_buffer == NULL) - return -ENOMEM; - - dac_audio_reset(); - rate = 8000; - dac_audio_set_rate(); - - /* Today: High Resolution Timer driven DAC playback. - * The timer callback gets called once per sample. Ouch. - * - * Future: A much better approach would be to use the - * SH7720 CMT+DMAC+DAC hardware combination like this: - * - Program sample rate using CMT0 or CMT1 - * - Program DMAC to use CMT for timing and output to DAC - * - Play sound using DMAC, let CPU sleep. - * - While at it, rewrite this driver to use ALSA. - */ - - hrtimer_init(&hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); - hrtimer.function = sh_dac_audio_timer; - - return 0; -} - -static void __exit dac_audio_exit(void) -{ - unregister_sound_dsp(device_major); - kfree((void *)data_buffer); -} - -module_init(dac_audio_init); -module_exit(dac_audio_exit); - -MODULE_AUTHOR("Andriy Skulysh, askulysh@image.kiev.ua"); -MODULE_DESCRIPTION("SH DAC sound driver"); -MODULE_LICENSE("GPL"); -- cgit v1.1 From b42e17963c20ecb80905083ceaecc79fd9bd30f1 Mon Sep 17 00:00:00 2001 From: Thomas Weber Date: Thu, 23 Sep 2010 11:46:50 +0200 Subject: Fix typo configue => configure in comments Signed-off-by: Thomas Weber Acked-by: David S. Miller Signed-off-by: Jiri Kosina --- sound/soc/s3c24xx/neo1973_gta02_wm8753.c | 2 +- sound/soc/s3c24xx/neo1973_wm8753.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'sound') diff --git a/sound/soc/s3c24xx/neo1973_gta02_wm8753.c b/sound/soc/s3c24xx/neo1973_gta02_wm8753.c index 209c259..4719558 100644 --- a/sound/soc/s3c24xx/neo1973_gta02_wm8753.c +++ b/sound/soc/s3c24xx/neo1973_gta02_wm8753.c @@ -182,7 +182,7 @@ static int neo1973_gta02_voice_hw_params( if (ret < 0) return ret; - /* configue and enable PLL for 12.288MHz output */ + /* configure and enable PLL for 12.288MHz output */ ret = snd_soc_dai_set_pll(codec_dai, WM8753_PLL2, 0, iis_clkrate / 4, 12288000); if (ret < 0) diff --git a/sound/soc/s3c24xx/neo1973_wm8753.c b/sound/soc/s3c24xx/neo1973_wm8753.c index 0cb4f86..4ac6209 100644 --- a/sound/soc/s3c24xx/neo1973_wm8753.c +++ b/sound/soc/s3c24xx/neo1973_wm8753.c @@ -201,7 +201,7 @@ static int neo1973_voice_hw_params(struct snd_pcm_substream *substream, if (ret < 0) return ret; - /* configue and enable PLL for 12.288MHz output */ + /* configure and enable PLL for 12.288MHz output */ ret = snd_soc_dai_set_pll(codec_dai, WM8753_PLL2, 0, iis_clkrate / 4, 12288000); if (ret < 0) -- cgit v1.1 From 4e7d7c6018567fa03f387d06602d4145c75ebbe0 Mon Sep 17 00:00:00 2001 From: Vince Weaver Date: Wed, 22 Sep 2010 17:31:37 -0400 Subject: ALSA: hda - MacBookPro 5,3 line-in support I've found the following patch is necessary to enable line-in on my MacBookPro 5,3 machine. With the patch applied I've successfully recorded audio from the line-in jack. This is based on the existing 5,5 support. Signed-off-by: Vince Weaver Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_cirrus.c | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_cirrus.c b/sound/pci/hda/patch_cirrus.c index 483c3f2..5c00106 100644 --- a/sound/pci/hda/patch_cirrus.c +++ b/sound/pci/hda/patch_cirrus.c @@ -65,6 +65,7 @@ struct cs_spec { /* available models */ enum { + CS420X_MBP53, CS420X_MBP55, CS420X_IMAC27, CS420X_AUTO, @@ -839,7 +840,8 @@ static void cs_automute(struct hda_codec *codec) AC_VERB_SET_PIN_WIDGET_CONTROL, hp_present ? 0 : PIN_OUT); } - if (spec->board_config == CS420X_MBP55 || + if (spec->board_config == CS420X_MBP53 || + spec->board_config == CS420X_MBP55 || spec->board_config == CS420X_IMAC27) { unsigned int gpio = hp_present ? 0x02 : 0x08; snd_hda_codec_write(codec, 0x01, 0, @@ -1128,6 +1130,7 @@ static int cs_parse_auto_config(struct hda_codec *codec) } static const char *cs420x_models[CS420X_MODELS] = { + [CS420X_MBP53] = "mbp53", [CS420X_MBP55] = "mbp55", [CS420X_IMAC27] = "imac27", [CS420X_AUTO] = "auto", @@ -1135,6 +1138,7 @@ static const char *cs420x_models[CS420X_MODELS] = { static struct snd_pci_quirk cs420x_cfg_tbl[] = { + SND_PCI_QUIRK(0x10de, 0x0ac0, "MacBookPro 5,3", CS420X_MBP53), SND_PCI_QUIRK(0x10de, 0xcb79, "MacBookPro 5,5", CS420X_MBP55), SND_PCI_QUIRK(0x8086, 0x7270, "IMac 27 Inch", CS420X_IMAC27), {} /* terminator */ @@ -1145,6 +1149,20 @@ struct cs_pincfg { u32 val; }; +static struct cs_pincfg mbp53_pincfgs[] = { + { 0x09, 0x012b4050 }, + { 0x0a, 0x90100141 }, + { 0x0b, 0x90100140 }, + { 0x0c, 0x018b3020 }, + { 0x0d, 0x90a00110 }, + { 0x0e, 0x400000f0 }, + { 0x0f, 0x01cbe030 }, + { 0x10, 0x014be060 }, + { 0x12, 0x400000f0 }, + { 0x15, 0x400000f0 }, + {} /* terminator */ +}; + static struct cs_pincfg mbp55_pincfgs[] = { { 0x09, 0x012b4030 }, { 0x0a, 0x90100121 }, @@ -1174,6 +1192,7 @@ static struct cs_pincfg imac27_pincfgs[] = { }; static struct cs_pincfg *cs_pincfgs[CS420X_MODELS] = { + [CS420X_MBP53] = mbp53_pincfgs, [CS420X_MBP55] = mbp55_pincfgs, [CS420X_IMAC27] = imac27_pincfgs, }; @@ -1206,6 +1225,7 @@ static int patch_cs420x(struct hda_codec *codec) switch (spec->board_config) { case CS420X_IMAC27: + case CS420X_MBP53: case CS420X_MBP55: /* GPIO1 = headphones */ /* GPIO3 = speakers */ -- cgit v1.1 From 01fdf1801e349302fce5d9865470a7100a2d9b74 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Fri, 24 Sep 2010 09:09:42 +0200 Subject: ALSA: hda - Fix auto-parse of SPDIF input of Realtek codecs The SPDIF in audio widget must be searched through the list as the widget that contains the given pin as the connection source. The current code was implemented in a reverse way. Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 22 ++++++++++++++++------ 1 file changed, 16 insertions(+), 6 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index a1312a6..a432e6e 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -1594,12 +1594,22 @@ static void alc_auto_parse_digital(struct hda_codec *codec) } if (spec->autocfg.dig_in_pin) { - hda_nid_t dig_nid; - err = snd_hda_get_connections(codec, - spec->autocfg.dig_in_pin, - &dig_nid, 1); - if (err > 0) - spec->dig_in_nid = dig_nid; + dig_nid = codec->start_nid; + for (i = 0; i < codec->num_nodes; i++, dig_nid++) { + unsigned int wcaps = get_wcaps(codec, dig_nid); + if (get_wcaps_type(wcaps) != AC_WID_AUD_IN) + continue; + if (!(wcaps & AC_WCAP_DIGITAL)) + continue; + if (!(wcaps & AC_WCAP_CONN_LIST)) + continue; + err = get_connection_index(codec, dig_nid, + spec->autocfg.dig_in_pin); + if (err >= 0) { + spec->dig_in_nid = dig_nid; + break; + } + } } } -- cgit v1.1 From f41cc2a85d52ac6971299922084ac5ac59dc339d Mon Sep 17 00:00:00 2001 From: Vitaliy Kulikov Date: Fri, 24 Sep 2010 16:21:53 -0500 Subject: ALSA: hda - Fix switching between dmic and mic using the same mux on IDT/STAC Fix bug in switching between dmic and mic when both use the same mux. Signed-off-by: Vitaliy Kulikov Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_sigmatel.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c index a90327b..d8dfafea 100644 --- a/sound/pci/hda/patch_sigmatel.c +++ b/sound/pci/hda/patch_sigmatel.c @@ -3481,8 +3481,10 @@ static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec, return err; } - if (snd_hda_get_bool_hint(codec, "separate_dmux") != 1) + if (snd_hda_get_bool_hint(codec, "separate_dmux") != 1) { snd_hda_add_imux_item(imux, label, index, NULL); + spec->num_analog_muxes++; + } } return 0; -- cgit v1.1 From e68d3b316ab7b02a074edc4f770e6a746390cb7d Mon Sep 17 00:00:00 2001 From: Dan Rosenberg Date: Sat, 25 Sep 2010 11:07:27 -0400 Subject: ALSA: sound/pci/rme9652: prevent reading uninitialized stack memory The SNDRV_HDSP_IOCTL_GET_CONFIG_INFO and SNDRV_HDSP_IOCTL_GET_CONFIG_INFO ioctls in hdspm.c and hdsp.c allow unprivileged users to read uninitialized kernel stack memory, because several fields of the hdsp{m}_config_info structs declared on the stack are not altered or zeroed before being copied back to the user. This patch takes care of it. Signed-off-by: Dan Rosenberg Cc: Signed-off-by: Takashi Iwai --- sound/pci/rme9652/hdsp.c | 1 + sound/pci/rme9652/hdspm.c | 1 + 2 files changed, 2 insertions(+) (limited to 'sound') diff --git a/sound/pci/rme9652/hdsp.c b/sound/pci/rme9652/hdsp.c index b92adef..d6fa7bf 100644 --- a/sound/pci/rme9652/hdsp.c +++ b/sound/pci/rme9652/hdsp.c @@ -4609,6 +4609,7 @@ static int snd_hdsp_hwdep_ioctl(struct snd_hwdep *hw, struct file *file, unsigne if (err < 0) return err; + memset(&info, 0, sizeof(info)); spin_lock_irqsave(&hdsp->lock, flags); info.pref_sync_ref = (unsigned char)hdsp_pref_sync_ref(hdsp); info.wordclock_sync_check = (unsigned char)hdsp_wc_sync_check(hdsp); diff --git a/sound/pci/rme9652/hdspm.c b/sound/pci/rme9652/hdspm.c index 547b713..0c98ef9 100644 --- a/sound/pci/rme9652/hdspm.c +++ b/sound/pci/rme9652/hdspm.c @@ -4127,6 +4127,7 @@ static int snd_hdspm_hwdep_ioctl(struct snd_hwdep * hw, struct file *file, case SNDRV_HDSPM_IOCTL_GET_CONFIG_INFO: + memset(&info, 0, sizeof(info)); spin_lock_irq(&hdspm->lock); info.pref_sync_ref = hdspm_pref_sync_ref(hdspm); info.wordclock_sync_check = hdspm_wc_sync_check(hdspm); -- cgit v1.1 From e35d4b119578a054515ccb4ed5dddc4e8a81ec15 Mon Sep 17 00:00:00 2001 From: Otavio Salvador Date: Sun, 26 Sep 2010 23:35:06 -0300 Subject: ALSA: hda: add Vortex86MX PCI ids Signed-off-by: Otavio Salvador Signed-off-by: Takashi Iwai --- sound/pci/hda/hda_intel.c | 2 ++ 1 file changed, 2 insertions(+) (limited to 'sound') diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c index 5f6f903..ec07e47 100644 --- a/sound/pci/hda/hda_intel.c +++ b/sound/pci/hda/hda_intel.c @@ -2791,6 +2791,8 @@ static DEFINE_PCI_DEVICE_TABLE(azx_ids) = { /* this entry seems still valid -- i.e. without emu20kx chip */ { PCI_DEVICE(0x1102, 0x0009), .driver_data = AZX_DRIVER_GENERIC }, #endif + /* Vortex86MX */ + { PCI_DEVICE(0x17f3, 0x3010), .driver_data = AZX_DRIVER_GENERIC }, /* AMD/ATI Generic, PCI class code and Vendor ID for HD Audio */ { PCI_DEVICE(PCI_VENDOR_ID_ATI, PCI_ANY_ID), .class = PCI_CLASS_MULTIMEDIA_HD_AUDIO << 8, -- cgit v1.1 From 5591bf07225523600450edd9e6ad258bb877b779 Mon Sep 17 00:00:00 2001 From: Dan Rosenberg Date: Tue, 28 Sep 2010 14:18:20 -0400 Subject: ALSA: prevent heap corruption in snd_ctl_new() The snd_ctl_new() function in sound/core/control.c allocates space for a snd_kcontrol struct by performing arithmetic operations on a user-provided size without checking for integer overflow. If a user provides a large enough size, an overflow will occur, the allocated chunk will be too small, and a second user-influenced value will be written repeatedly past the bounds of this chunk. This code is reachable by unprivileged users who have permission to open a /dev/snd/controlC* device (on many distros, this is group "audio") via the SNDRV_CTL_IOCTL_ELEM_ADD and SNDRV_CTL_IOCTL_ELEM_REPLACE ioctls. Signed-off-by: Dan Rosenberg Cc: Signed-off-by: Takashi Iwai --- sound/core/control.c | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'sound') diff --git a/sound/core/control.c b/sound/core/control.c index 070aab4..45a8180 100644 --- a/sound/core/control.c +++ b/sound/core/control.c @@ -31,6 +31,7 @@ /* max number of user-defined controls */ #define MAX_USER_CONTROLS 32 +#define MAX_CONTROL_COUNT 1028 struct snd_kctl_ioctl { struct list_head list; /* list of all ioctls */ @@ -195,6 +196,10 @@ static struct snd_kcontrol *snd_ctl_new(struct snd_kcontrol *control, if (snd_BUG_ON(!control || !control->count)) return NULL; + + if (control->count > MAX_CONTROL_COUNT) + return NULL; + kctl = kzalloc(sizeof(*kctl) + sizeof(struct snd_kcontrol_volatile) * control->count, GFP_KERNEL); if (kctl == NULL) { snd_printk(KERN_ERR "Cannot allocate control instance\n"); -- cgit v1.1 From c123e5e437a0e61e364c1cbad3ef9a7384975fb2 Mon Sep 17 00:00:00 2001 From: Luke Yelavich Date: Tue, 28 Sep 2010 12:04:06 +1000 Subject: ALSA: hda - Add quirk for another Acer laptop with a CX20585 codec BugLink: https://bugs.launchpad.net/ubuntu/+source/alsa-driver/+bug/647374 Set another Acer laptop (SSID 1025:043d) to use CXT5066_IDEAPAD Signed-off-by: Luke Yelavich Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_conexant.c | 1 + 1 file changed, 1 insertion(+) (limited to 'sound') diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c index a6c68cb..80cc74b 100644 --- a/sound/pci/hda/patch_conexant.c +++ b/sound/pci/hda/patch_conexant.c @@ -3094,6 +3094,7 @@ static const char *cxt5066_models[CXT5066_MODELS] = { static struct snd_pci_quirk cxt5066_cfg_tbl[] = { SND_PCI_QUIRK(0x1025, 0x040a, "Acer", CXT5066_IDEAPAD), + SND_PCI_QUIRK(0x1025, 0x043d, "Acer", CXT5066_IDEAPAD), SND_PCI_QUIRK(0x1028, 0x02d8, "Dell Vostro", CXT5066_DELL_VOSTRO), SND_PCI_QUIRK(0x1028, 0x02f5, "Dell", CXT5066_DELL_LAPTOP), -- cgit v1.1 From 37979e1546a790c44adbc7f27a85569944480ebc Mon Sep 17 00:00:00 2001 From: Dominik Brodowski Date: Thu, 29 Jul 2010 16:33:23 +0200 Subject: pcmcia: simplify IntType IntType was only set to INT_MEMORY (driver pcmciamtd) or INT_MEMORY_AND_IO (all other drivers). As this flags seems to relate to ioport access, make it conditional to the driver having requested IO port access. There are two drivers which do not request IO ports, but did set INT_MEMORY_AND_IO: ray_cs and b43. For those, we consistently only set INT_MEMORY in future. CC: netdev@vger.kernel.org CC: linux-wireless@vger.kernel.org CC: linux-ide@vger.kernel.org CC: linux-usb@vger.kernel.org CC: laforge@gnumonks.org CC: linux-mtd@lists.infradead.org CC: alsa-devel@alsa-project.org CC: linux-serial@vger.kernel.org CC: Jiri Kosina CC: linux-scsi@vger.kernel.org Acked-by: Gustavo F. Padovan (for drivers/bluetooth) Tested-by: Wolfram Sang Signed-off-by: Dominik Brodowski --- sound/pcmcia/pdaudiocf/pdaudiocf.c | 1 - sound/pcmcia/vx/vxpocket.c | 1 - 2 files changed, 2 deletions(-) (limited to 'sound') diff --git a/sound/pcmcia/pdaudiocf/pdaudiocf.c b/sound/pcmcia/pdaudiocf/pdaudiocf.c index 7ab9174..2e1282d 100644 --- a/sound/pcmcia/pdaudiocf/pdaudiocf.c +++ b/sound/pcmcia/pdaudiocf/pdaudiocf.c @@ -143,7 +143,6 @@ static int snd_pdacf_probe(struct pcmcia_device *link) link->resource[0]->end = 16; link->conf.Attributes = CONF_ENABLE_IRQ | CONF_ENABLE_PULSE_IRQ; - link->conf.IntType = INT_MEMORY_AND_IO; link->conf.ConfigIndex = 1; link->conf.Present = PRESENT_OPTION; diff --git a/sound/pcmcia/vx/vxpocket.c b/sound/pcmcia/vx/vxpocket.c index a6edfc3..a48b3ee 100644 --- a/sound/pcmcia/vx/vxpocket.c +++ b/sound/pcmcia/vx/vxpocket.c @@ -163,7 +163,6 @@ static int snd_vxpocket_new(struct snd_card *card, int ibl, link->resource[0]->end = 16; link->conf.Attributes = CONF_ENABLE_IRQ; - link->conf.IntType = INT_MEMORY_AND_IO; link->conf.ConfigIndex = 1; link->conf.Present = PRESENT_OPTION; -- cgit v1.1 From 7feabb6412ea23edd298c0fa90e5aa6733eb4a42 Mon Sep 17 00:00:00 2001 From: Dominik Brodowski Date: Thu, 29 Jul 2010 18:35:47 +0200 Subject: pcmcia: move config_{base,index,regs} to struct pcmcia_device Several drivers prefer to explicitly set config_{base,index,regs}, formerly known as ConfigBase, ConfigIndex and Present. Instead of passing these values inside config_req_t, store it in struct pcmcia_device. CC: netdev@vger.kernel.org CC: linux-wireless@vger.kernel.org CC: linux-ide@vger.kernel.org CC: linux-usb@vger.kernel.org CC: laforge@gnumonks.org CC: linux-mtd@lists.infradead.org CC: alsa-devel@alsa-project.org CC: linux-serial@vger.kernel.org CC: Jiri Kosina CC: linux-scsi@vger.kernel.org Acked-by: Gustavo F. Padovan (for drivers/bluetooth) Tested-by: Wolfram Sang Signed-off-by: Dominik Brodowski --- sound/pcmcia/pdaudiocf/pdaudiocf.c | 6 +++--- sound/pcmcia/vx/vxpocket.c | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) (limited to 'sound') diff --git a/sound/pcmcia/pdaudiocf/pdaudiocf.c b/sound/pcmcia/pdaudiocf/pdaudiocf.c index 2e1282d..4df07fc 100644 --- a/sound/pcmcia/pdaudiocf/pdaudiocf.c +++ b/sound/pcmcia/pdaudiocf/pdaudiocf.c @@ -143,8 +143,8 @@ static int snd_pdacf_probe(struct pcmcia_device *link) link->resource[0]->end = 16; link->conf.Attributes = CONF_ENABLE_IRQ | CONF_ENABLE_PULSE_IRQ; - link->conf.ConfigIndex = 1; - link->conf.Present = PRESENT_OPTION; + link->config_index = 1; + link->config_regs = PRESENT_OPTION; return pdacf_config(link); } @@ -216,7 +216,7 @@ static int pdacf_config(struct pcmcia_device *link) int ret; snd_printdd(KERN_DEBUG "pdacf_config called\n"); - link->conf.ConfigIndex = 0x5; + link->config_index = 0x5; ret = pcmcia_request_io(link); if (ret) diff --git a/sound/pcmcia/vx/vxpocket.c b/sound/pcmcia/vx/vxpocket.c index a48b3ee..16186ad 100644 --- a/sound/pcmcia/vx/vxpocket.c +++ b/sound/pcmcia/vx/vxpocket.c @@ -163,8 +163,8 @@ static int snd_vxpocket_new(struct snd_card *card, int ibl, link->resource[0]->end = 16; link->conf.Attributes = CONF_ENABLE_IRQ; - link->conf.ConfigIndex = 1; - link->conf.Present = PRESENT_OPTION; + link->config_index = 1; + link->config_regs = PRESENT_OPTION; *chip_ret = vxp; return 0; -- cgit v1.1 From 1ac71e5a35eebee60cdcf15b3980bd94498f037b Mon Sep 17 00:00:00 2001 From: Dominik Brodowski Date: Thu, 29 Jul 2010 19:27:09 +0200 Subject: pcmcia: convert pcmcia_request_configuration to pcmcia_enable_device pcmcia_enable_device() now replaces pcmcia_request_configuration(). Instead of config_req_t, all necessary flags are either passed as a parameter to pcmcia_enable_device(), or (in rare circumstances) set in struct pcmcia_device -> flags. With the last remaining user of include/pcmcia/cs.h gone, remove all references. CC: netdev@vger.kernel.org CC: linux-wireless@vger.kernel.org CC: linux-ide@vger.kernel.org CC: linux-usb@vger.kernel.org CC: laforge@gnumonks.org CC: linux-mtd@lists.infradead.org CC: alsa-devel@alsa-project.org CC: linux-serial@vger.kernel.org CC: Jiri Kosina CC: linux-scsi@vger.kernel.org Acked-by: Gustavo F. Padovan (for drivers/bluetooth) Tested-by: Wolfram Sang Signed-off-by: Dominik Brodowski --- sound/pcmcia/pdaudiocf/pdaudiocf.c | 5 +++-- sound/pcmcia/pdaudiocf/pdaudiocf.h | 1 - sound/pcmcia/vx/vxpocket.c | 6 +++--- sound/pcmcia/vx/vxpocket.h | 1 - 4 files changed, 6 insertions(+), 7 deletions(-) (limited to 'sound') diff --git a/sound/pcmcia/pdaudiocf/pdaudiocf.c b/sound/pcmcia/pdaudiocf/pdaudiocf.c index 4df07fc..2476d5f 100644 --- a/sound/pcmcia/pdaudiocf/pdaudiocf.c +++ b/sound/pcmcia/pdaudiocf/pdaudiocf.c @@ -142,7 +142,7 @@ static int snd_pdacf_probe(struct pcmcia_device *link) link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO; link->resource[0]->end = 16; - link->conf.Attributes = CONF_ENABLE_IRQ | CONF_ENABLE_PULSE_IRQ; + link->config_flags = CONF_ENABLE_IRQ | CONF_ENABLE_PULSE_IRQ; link->config_index = 1; link->config_regs = PRESENT_OPTION; @@ -217,6 +217,7 @@ static int pdacf_config(struct pcmcia_device *link) snd_printdd(KERN_DEBUG "pdacf_config called\n"); link->config_index = 0x5; + link->config_flags |= CONF_ENABLE_IRQ | CONF_ENABLE_PULSE_IRQ; ret = pcmcia_request_io(link); if (ret) @@ -226,7 +227,7 @@ static int pdacf_config(struct pcmcia_device *link) if (ret) goto failed; - ret = pcmcia_request_configuration(link, &link->conf); + ret = pcmcia_enable_device(link); if (ret) goto failed; diff --git a/sound/pcmcia/pdaudiocf/pdaudiocf.h b/sound/pcmcia/pdaudiocf/pdaudiocf.h index 5cc3e45..bd26e09 100644 --- a/sound/pcmcia/pdaudiocf/pdaudiocf.h +++ b/sound/pcmcia/pdaudiocf/pdaudiocf.h @@ -24,7 +24,6 @@ #include #include #include -#include #include #include diff --git a/sound/pcmcia/vx/vxpocket.c b/sound/pcmcia/vx/vxpocket.c index 16186ad..017a8d6 100644 --- a/sound/pcmcia/vx/vxpocket.c +++ b/sound/pcmcia/vx/vxpocket.c @@ -2,7 +2,7 @@ * Driver for Digigram VXpocket V2/440 soundcards * * Copyright (c) 2002 by Takashi Iwai - * + * 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 @@ -162,7 +162,7 @@ static int snd_vxpocket_new(struct snd_card *card, int ibl, link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO; link->resource[0]->end = 16; - link->conf.Attributes = CONF_ENABLE_IRQ; + link->config_flags |= CONF_ENABLE_IRQ; link->config_index = 1; link->config_regs = PRESENT_OPTION; @@ -233,7 +233,7 @@ static int vxpocket_config(struct pcmcia_device *link) if (ret) goto failed; - ret = pcmcia_request_configuration(link, &link->conf); + ret = pcmcia_enable_device(link); if (ret) goto failed; diff --git a/sound/pcmcia/vx/vxpocket.h b/sound/pcmcia/vx/vxpocket.h index d911066..13d658c 100644 --- a/sound/pcmcia/vx/vxpocket.h +++ b/sound/pcmcia/vx/vxpocket.h @@ -23,7 +23,6 @@ #include -#include #include #include -- cgit v1.1 From 2e9b981a7c63ee8278df6823f8389d69dad1a499 Mon Sep 17 00:00:00 2001 From: Dominik Brodowski Date: Sun, 8 Aug 2010 11:36:26 +0200 Subject: pcmcia: move driver name to struct pcmcia_driver Tested-by: Wolfram Sang Signed-off-by: Dominik Brodowski --- sound/pcmcia/pdaudiocf/pdaudiocf.c | 4 +--- sound/pcmcia/vx/vxpocket.c | 4 +--- 2 files changed, 2 insertions(+), 6 deletions(-) (limited to 'sound') diff --git a/sound/pcmcia/pdaudiocf/pdaudiocf.c b/sound/pcmcia/pdaudiocf/pdaudiocf.c index 2476d5f..8cc4733 100644 --- a/sound/pcmcia/pdaudiocf/pdaudiocf.c +++ b/sound/pcmcia/pdaudiocf/pdaudiocf.c @@ -287,9 +287,7 @@ MODULE_DEVICE_TABLE(pcmcia, snd_pdacf_ids); static struct pcmcia_driver pdacf_cs_driver = { .owner = THIS_MODULE, - .drv = { - .name = "snd-pdaudiocf", - }, + .name = "snd-pdaudiocf", .probe = snd_pdacf_probe, .remove = snd_pdacf_detach, .id_table = snd_pdacf_ids, diff --git a/sound/pcmcia/vx/vxpocket.c b/sound/pcmcia/vx/vxpocket.c index 017a8d6..80000d6 100644 --- a/sound/pcmcia/vx/vxpocket.c +++ b/sound/pcmcia/vx/vxpocket.c @@ -358,9 +358,7 @@ MODULE_DEVICE_TABLE(pcmcia, vxp_ids); static struct pcmcia_driver vxp_cs_driver = { .owner = THIS_MODULE, - .drv = { - .name = "snd-vxpocket", - }, + .name = "snd-vxpocket", .probe = vxpocket_probe, .remove = vxpocket_detach, .id_table = vxp_ids, -- cgit v1.1 From 20d9a26dbbbec32aa7c9da49b979f201bd7104b9 Mon Sep 17 00:00:00 2001 From: Jaroslav Kysela Date: Thu, 30 Sep 2010 00:16:50 +0200 Subject: ALSA: snd-aloop - fix capture buffer silence In a special case, some old samples are left in the capture ring buffer. Fix it. Signed-off-by: Jaroslav Kysela --- sound/drivers/aloop.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'sound') diff --git a/sound/drivers/aloop.c b/sound/drivers/aloop.c index f2b8f86..2748fee 100644 --- a/sound/drivers/aloop.c +++ b/sound/drivers/aloop.c @@ -347,7 +347,7 @@ static void copy_play_buf(struct loopback_pcm *play, unsigned int bytes) { struct snd_pcm_runtime *runtime = play->substream->runtime; - char *src = play->substream->runtime->dma_area; + char *src = runtime->dma_area; char *dst = capt->substream->runtime->dma_area; unsigned int src_off = play->buf_pos; unsigned int dst_off = capt->buf_pos; @@ -385,8 +385,10 @@ static void copy_play_buf(struct loopback_pcm *play, dst_off = (dst_off + size) % capt->pcm_buffer_size; } - if (clear_bytes > 0) + if (clear_bytes > 0) { clear_capture_buf(capt, clear_bytes); + capt->silent_size = 0; + } } #define BYTEPOS_UPDATE_POSONLY 0 -- cgit v1.1 From 4cb36310848fd17766aa72afd1f2873f54b4e055 Mon Sep 17 00:00:00 2001 From: David Henningsson Date: Thu, 30 Sep 2010 10:12:50 +0200 Subject: ALSA: HDA: Add position_fix=3 module option, and refactor related code What was previously known as via_dmapos_patch, and hard-coded to be used for VIA and ATI controllers, is now configurable through a module option. The background is that some VIA controllers seem to prefer via_dmapos_patch to be turned off. Signed-off-by: David Henningsson Signed-off-by: Takashi Iwai --- sound/pci/hda/hda_intel.c | 41 +++++++++++++++++++---------------------- 1 file changed, 19 insertions(+), 22 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c index ec07e47..38b063e 100644 --- a/sound/pci/hda/hda_intel.c +++ b/sound/pci/hda/hda_intel.c @@ -78,8 +78,8 @@ MODULE_PARM_DESC(enable, "Enable Intel HD audio interface."); module_param_array(model, charp, NULL, 0444); MODULE_PARM_DESC(model, "Use the given board model."); module_param_array(position_fix, int, NULL, 0444); -MODULE_PARM_DESC(position_fix, "Fix DMA pointer " - "(0 = auto, 1 = none, 2 = POSBUF)."); +MODULE_PARM_DESC(position_fix, "DMA pointer read method." + "(0 = auto, 1 = LPIB, 2 = POSBUF, 3 = VIACOMBO)."); module_param_array(bdl_pos_adj, int, NULL, 0644); MODULE_PARM_DESC(bdl_pos_adj, "BDL position adjustment offset."); module_param_array(probe_mask, int, NULL, 0444); @@ -305,6 +305,7 @@ enum { POS_FIX_AUTO, POS_FIX_LPIB, POS_FIX_POSBUF, + POS_FIX_VIACOMBO, }; /* Defines for ATI HD Audio support in SB450 south bridge */ @@ -433,7 +434,6 @@ struct azx { unsigned int polling_mode :1; unsigned int msi :1; unsigned int irq_pending_warned :1; - unsigned int via_dmapos_patch :1; /* enable DMA-position fix for VIA */ unsigned int probing :1; /* codec probing phase */ /* for debugging */ @@ -1309,11 +1309,8 @@ static int azx_setup_controller(struct azx *chip, struct azx_dev *azx_dev) azx_sd_writel(azx_dev, SD_BDLPU, upper_32_bits(azx_dev->bdl.addr)); /* enable the position buffer */ - if (chip->position_fix[0] == POS_FIX_POSBUF || - chip->position_fix[0] == POS_FIX_AUTO || - chip->position_fix[1] == POS_FIX_POSBUF || - chip->position_fix[1] == POS_FIX_AUTO || - chip->via_dmapos_patch) { + if (chip->position_fix[0] != POS_FIX_LPIB || + chip->position_fix[1] != POS_FIX_LPIB) { if (!(azx_readl(chip, DPLBASE) & ICH6_DPLBASE_ENABLE)) azx_writel(chip, DPLBASE, (u32)chip->posbuf.addr | ICH6_DPLBASE_ENABLE); @@ -1852,20 +1849,21 @@ static unsigned int azx_get_position(struct azx *chip, struct azx_dev *azx_dev) { unsigned int pos; + int stream = azx_dev->substream->stream; - if (chip->via_dmapos_patch) + switch (chip->position_fix[stream]) { + case POS_FIX_LPIB: + /* read LPIB */ + pos = azx_sd_readl(azx_dev, SD_LPIB); + break; + case POS_FIX_VIACOMBO: pos = azx_via_get_position(chip, azx_dev); - else { - int stream = azx_dev->substream->stream; - if (chip->position_fix[stream] == POS_FIX_POSBUF || - chip->position_fix[stream] == POS_FIX_AUTO) { - /* use the position buffer */ - pos = le32_to_cpu(*azx_dev->posbuf); - } else { - /* read LPIB */ - pos = azx_sd_readl(azx_dev, SD_LPIB); - } + break; + default: + /* use the position buffer */ + pos = le32_to_cpu(*azx_dev->posbuf); } + if (pos >= azx_dev->bufsize) pos = 0; return pos; @@ -2313,6 +2311,7 @@ static int __devinit check_position_fix(struct azx *chip, int fix) switch (fix) { case POS_FIX_LPIB: case POS_FIX_POSBUF: + case POS_FIX_VIACOMBO: return fix; } @@ -2320,11 +2319,9 @@ static int __devinit check_position_fix(struct azx *chip, int fix) switch (chip->driver_type) { case AZX_DRIVER_VIA: case AZX_DRIVER_ATI: - chip->via_dmapos_patch = 1; /* Use link position directly, avoid any transfer problem. */ - return POS_FIX_LPIB; + return POS_FIX_VIACOMBO; } - chip->via_dmapos_patch = 0; q = snd_pci_quirk_lookup(chip->pci, position_fix_list); if (q) { -- cgit v1.1 From e913b146493993c8ac33561655c590e58b500c6f Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Thu, 30 Sep 2010 22:59:12 +0200 Subject: ALSA: i2c/other/ak4xx-adda: Fix a compile warning with CONFIG_PROCFS=n Signed-off-by: Takashi Iwai --- sound/i2c/other/ak4xxx-adda.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/i2c/other/ak4xxx-adda.c b/sound/i2c/other/ak4xxx-adda.c index 1adb8a3..42d7844 100644 --- a/sound/i2c/other/ak4xxx-adda.c +++ b/sound/i2c/other/ak4xxx-adda.c @@ -900,7 +900,7 @@ static int proc_init(struct snd_akm4xxx *ak) return 0; } #else /* !CONFIG_PROC_FS */ -static int proc_init(struct snd_akm4xxx *ak) {} +static int proc_init(struct snd_akm4xxx *ak) { return 0; } #endif int snd_akm4xxx_build_controls(struct snd_akm4xxx *ak) -- cgit v1.1 From ac446fb7e690b317050ed158ba5dfd9273dc9e74 Mon Sep 17 00:00:00 2001 From: Jaroslav Kysela Date: Sat, 2 Oct 2010 16:00:53 +0200 Subject: ALSA: snd-aloop - fix "PCM Slave Active" element read value Simple coding fix. Signed-off-by: Jaroslav Kysela --- sound/drivers/aloop.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/drivers/aloop.c b/sound/drivers/aloop.c index 2748fee..040030a 100644 --- a/sound/drivers/aloop.c +++ b/sound/drivers/aloop.c @@ -739,7 +739,7 @@ static int loopback_active_get(struct snd_kcontrol *kcontrol, { struct loopback *loopback = snd_kcontrol_chip(kcontrol); struct loopback_cable *cable = loopback->cables - [kcontrol->id.subdevice][kcontrol->id.device]; + [kcontrol->id.subdevice][kcontrol->id.device ^ 1]; unsigned int val = 0; if (cable != NULL) -- cgit v1.1 From d41185882b828896ccecac319c9f65f708baaf0d Mon Sep 17 00:00:00 2001 From: Valentine Sinitsyn Date: Fri, 1 Oct 2010 22:24:08 +0600 Subject: ALSA: hda - Added fixup for Lenovo Y550P Signed-off-by: Valentine Sinitsyn Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 1 + 1 file changed, 1 insertion(+) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index f6427cc..b4e0959 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -19246,6 +19246,7 @@ static const struct alc_fixup alc662_fixups[] = { }; static struct snd_pci_quirk alc662_fixup_tbl[] = { + SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD), SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD), {} }; -- cgit v1.1 From 422fdc318efd7d34d8b79decde0f8cb90a336c11 Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Mon, 4 Oct 2010 13:09:12 +0200 Subject: ALSA: usb-audio: add more Yamaha USB MIDI devices Add quirks for more devices (according to driver V.3.0.4-2). Signed-off-by: Clemens Ladisch Signed-off-by: Takashi Iwai --- sound/usb/quirks-table.h | 12 ++++++++++++ 1 file changed, 12 insertions(+) (limited to 'sound') diff --git a/sound/usb/quirks-table.h b/sound/usb/quirks-table.h index c86c613..682e3e0 100644 --- a/sound/usb/quirks-table.h +++ b/sound/usb/quirks-table.h @@ -240,9 +240,21 @@ YAMAHA_DEVICE(0x104f, NULL), YAMAHA_DEVICE(0x1050, NULL), YAMAHA_DEVICE(0x1051, NULL), YAMAHA_DEVICE(0x1052, NULL), +YAMAHA_INTERFACE(0x1053, 0, NULL), +YAMAHA_INTERFACE(0x1054, 0, NULL), +YAMAHA_DEVICE(0x1055, NULL), +YAMAHA_DEVICE(0x1056, NULL), +YAMAHA_DEVICE(0x1057, NULL), +YAMAHA_DEVICE(0x1058, NULL), +YAMAHA_DEVICE(0x1059, NULL), +YAMAHA_DEVICE(0x105a, NULL), +YAMAHA_DEVICE(0x105b, NULL), +YAMAHA_DEVICE(0x105c, NULL), +YAMAHA_DEVICE(0x105d, NULL), YAMAHA_DEVICE(0x2000, "DGP-7"), YAMAHA_DEVICE(0x2001, "DGP-5"), YAMAHA_DEVICE(0x2002, NULL), +YAMAHA_DEVICE(0x2003, NULL), YAMAHA_DEVICE(0x5000, "CS1D"), YAMAHA_DEVICE(0x5001, "DSP1D"), YAMAHA_DEVICE(0x5002, "DME32"), -- cgit v1.1 From 45bc307f328c044e69cad2a18a9ae972bb15f254 Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Mon, 4 Oct 2010 13:17:26 +0200 Subject: ALSA: virtuoso: fix Xonar DS chip name The controller on the Xonar DS is labeled "AV66", not "AV200". Signed-off-by: Clemens Ladisch Signed-off-by: Takashi Iwai --- sound/pci/oxygen/virtuoso.c | 4 ++-- sound/pci/oxygen/xonar_wm87x6.c | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) (limited to 'sound') diff --git a/sound/pci/oxygen/virtuoso.c b/sound/pci/oxygen/virtuoso.c index 06c863e..599bb9a 100644 --- a/sound/pci/oxygen/virtuoso.c +++ b/sound/pci/oxygen/virtuoso.c @@ -25,9 +25,9 @@ #include "xonar.h" MODULE_AUTHOR("Clemens Ladisch "); -MODULE_DESCRIPTION("Asus AVx00 driver"); +MODULE_DESCRIPTION("Asus Virtuoso driver"); MODULE_LICENSE("GPL v2"); -MODULE_SUPPORTED_DEVICE("{{Asus,AV100},{Asus,AV200}}"); +MODULE_SUPPORTED_DEVICE("{{Asus,AV66},{Asus,AV100},{Asus,AV200}}"); static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; diff --git a/sound/pci/oxygen/xonar_wm87x6.c b/sound/pci/oxygen/xonar_wm87x6.c index aceaaa0..5f9f59c 100644 --- a/sound/pci/oxygen/xonar_wm87x6.c +++ b/sound/pci/oxygen/xonar_wm87x6.c @@ -1071,7 +1071,7 @@ static int xonar_ds_mixer_init(struct oxygen *chip) static const struct oxygen_model model_xonar_ds = { .shortname = "Xonar DS", - .longname = "Asus Virtuoso 200", + .longname = "Asus Virtuoso 66", .chip = "AV200", .init = xonar_ds_init, .control_filter = xonar_ds_control_filter, -- cgit v1.1 From b6ca8ab399d913eed0d89d65d6b768337a3d20d7 Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Mon, 4 Oct 2010 13:21:52 +0200 Subject: ALSA: oxygen: handle CD input configuration with a flag There are more models without a CD input than with one, so handle this explicitly with a device_config flag to avoid having to define a control filter callback to filter it out. Signed-off-by: Clemens Ladisch Signed-off-by: Takashi Iwai --- sound/pci/oxygen/oxygen.c | 3 ++- sound/pci/oxygen/oxygen.h | 1 + sound/pci/oxygen/oxygen_mixer.c | 3 +++ sound/pci/oxygen/xonar_cs43xx.c | 8 -------- sound/pci/oxygen/xonar_pcm179x.c | 11 ++--------- sound/pci/oxygen/xonar_wm87x6.c | 8 -------- 6 files changed, 8 insertions(+), 26 deletions(-) (limited to 'sound') diff --git a/sound/pci/oxygen/oxygen.c b/sound/pci/oxygen/oxygen.c index 289cb4d..f4fdf6d 100644 --- a/sound/pci/oxygen/oxygen.c +++ b/sound/pci/oxygen/oxygen.c @@ -505,7 +505,8 @@ static const struct oxygen_model model_generic = { PLAYBACK_2_TO_AC97_1 | CAPTURE_0_FROM_I2S_1 | CAPTURE_1_FROM_SPDIF | - CAPTURE_2_FROM_AC97_1, + CAPTURE_2_FROM_AC97_1 | + AC97_CD_INPUT, .dac_channels = 8, .dac_volume_min = 0, .dac_volume_max = 255, diff --git a/sound/pci/oxygen/oxygen.h b/sound/pci/oxygen/oxygen.h index a3409ed..7d5222c 100644 --- a/sound/pci/oxygen/oxygen.h +++ b/sound/pci/oxygen/oxygen.h @@ -34,6 +34,7 @@ /* CAPTURE_3_FROM_I2S_3 not implemented */ #define MIDI_OUTPUT 0x0800 #define MIDI_INPUT 0x1000 +#define AC97_CD_INPUT 0x2000 enum { CONTROL_SPDIF_PCM, diff --git a/sound/pci/oxygen/oxygen_mixer.c b/sound/pci/oxygen/oxygen_mixer.c index f375b8a..7d40ba8 100644 --- a/sound/pci/oxygen/oxygen_mixer.c +++ b/sound/pci/oxygen/oxygen_mixer.c @@ -972,6 +972,9 @@ static int add_controls(struct oxygen *chip, if (!strcmp(template.name, "Stereo Upmixing") && chip->model.dac_channels == 2) continue; + if (!strncmp(template.name, "CD Capture ", 11) && + !(chip->model.device_config & AC97_CD_INPUT)) + continue; if (!strcmp(template.name, "Master Playback Volume") && chip->model.dac_tlv) { template.tlv.p = chip->model.dac_tlv; diff --git a/sound/pci/oxygen/xonar_cs43xx.c b/sound/pci/oxygen/xonar_cs43xx.c index 7c4986b..aa27c310 100644 --- a/sound/pci/oxygen/xonar_cs43xx.c +++ b/sound/pci/oxygen/xonar_cs43xx.c @@ -367,13 +367,6 @@ static void xonar_d1_line_mic_ac97_switch(struct oxygen *chip, static const DECLARE_TLV_DB_SCALE(cs4362a_db_scale, -6000, 100, 0); -static int xonar_d1_control_filter(struct snd_kcontrol_new *template) -{ - if (!strncmp(template->name, "CD Capture ", 11)) - return 1; /* no CD input */ - return 0; -} - static int xonar_d1_mixer_init(struct oxygen *chip) { int err; @@ -391,7 +384,6 @@ static const struct oxygen_model model_xonar_d1 = { .longname = "Asus Virtuoso 100", .chip = "AV200", .init = xonar_d1_init, - .control_filter = xonar_d1_control_filter, .mixer_init = xonar_d1_mixer_init, .cleanup = xonar_d1_cleanup, .suspend = xonar_d1_suspend, diff --git a/sound/pci/oxygen/xonar_pcm179x.c b/sound/pci/oxygen/xonar_pcm179x.c index ba18fb5..338f885 100644 --- a/sound/pci/oxygen/xonar_pcm179x.c +++ b/sound/pci/oxygen/xonar_pcm179x.c @@ -915,13 +915,6 @@ static int xonar_d2_control_filter(struct snd_kcontrol_new *template) return 0; } -static int xonar_st_control_filter(struct snd_kcontrol_new *template) -{ - if (!strncmp(template->name, "CD Capture ", 11)) - return 1; /* no CD input */ - return 0; -} - static int add_pcm1796_controls(struct oxygen *chip) { int err; @@ -991,7 +984,8 @@ static const struct oxygen_model model_xonar_d2 = { CAPTURE_0_FROM_I2S_2 | CAPTURE_1_FROM_SPDIF | MIDI_OUTPUT | - MIDI_INPUT, + MIDI_INPUT | + AC97_CD_INPUT, .dac_channels = 8, .dac_volume_min = 255 - 2*60, .dac_volume_max = 255, @@ -1037,7 +1031,6 @@ static const struct oxygen_model model_xonar_st = { .longname = "Asus Virtuoso 100", .chip = "AV200", .init = xonar_st_init, - .control_filter = xonar_st_control_filter, .mixer_init = xonar_st_mixer_init, .cleanup = xonar_st_cleanup, .suspend = xonar_st_suspend, diff --git a/sound/pci/oxygen/xonar_wm87x6.c b/sound/pci/oxygen/xonar_wm87x6.c index 5f9f59c..200f760 100644 --- a/sound/pci/oxygen/xonar_wm87x6.c +++ b/sound/pci/oxygen/xonar_wm87x6.c @@ -1028,13 +1028,6 @@ static const struct snd_kcontrol_new lc_controls[] = { LC_CONTROL_ALC, wm8776_ngth_db_scale), }; -static int xonar_ds_control_filter(struct snd_kcontrol_new *template) -{ - if (!strncmp(template->name, "CD Capture ", 11)) - return 1; /* no CD input */ - return 0; -} - static int xonar_ds_mixer_init(struct oxygen *chip) { struct xonar_wm87x6 *data = chip->model_data; @@ -1074,7 +1067,6 @@ static const struct oxygen_model model_xonar_ds = { .longname = "Asus Virtuoso 66", .chip = "AV200", .init = xonar_ds_init, - .control_filter = xonar_ds_control_filter, .mixer_init = xonar_ds_mixer_init, .cleanup = xonar_ds_cleanup, .suspend = xonar_ds_suspend, -- cgit v1.1 From 2b830bae1fc2a27b3b0ab86091013bdec3c12427 Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Mon, 4 Oct 2010 13:22:51 +0200 Subject: ALSA: virtuoso: add HDAV1.3 Slim PCI ID Add a PCI ID for the Xonar HDAV1.3 Slim. There is no actual support, but the presence of the ID allows the EEPROM repair code to work for this card. Signed-off-by: Clemens Ladisch Signed-off-by: Takashi Iwai --- sound/pci/oxygen/virtuoso.c | 1 + sound/pci/oxygen/xonar_pcm179x.c | 15 +++++++++++++++ 2 files changed, 16 insertions(+) (limited to 'sound') diff --git a/sound/pci/oxygen/virtuoso.c b/sound/pci/oxygen/virtuoso.c index 599bb9a..469010a 100644 --- a/sound/pci/oxygen/virtuoso.c +++ b/sound/pci/oxygen/virtuoso.c @@ -49,6 +49,7 @@ static DEFINE_PCI_DEVICE_TABLE(xonar_ids) = { { OXYGEN_PCI_SUBID(0x1043, 0x834f) }, { OXYGEN_PCI_SUBID(0x1043, 0x835c) }, { OXYGEN_PCI_SUBID(0x1043, 0x835d) }, + { OXYGEN_PCI_SUBID(0x1043, 0x835e) }, { OXYGEN_PCI_SUBID(0x1043, 0x838e) }, { OXYGEN_PCI_SUBID_BROKEN_EEPROM }, { } diff --git a/sound/pci/oxygen/xonar_pcm179x.c b/sound/pci/oxygen/xonar_pcm179x.c index 338f885..571d0ae 100644 --- a/sound/pci/oxygen/xonar_pcm179x.c +++ b/sound/pci/oxygen/xonar_pcm179x.c @@ -132,6 +132,18 @@ * GPIO 5 <- 0 */ +/* + * Xonar HDAV1.3 Slim + * ------------------ + * + * CMI8788: + * + * GPIO 1 -> enable output + * + * TXD -> HDMI controller + * RXD <- HDMI controller + */ + #include #include #include @@ -1101,6 +1113,9 @@ int __devinit get_xonar_pcm179x_model(struct oxygen *chip, chip->model.resume = xonar_stx_resume; chip->model.set_dac_params = set_pcm1796_params; break; + case 0x835e: + snd_printk(KERN_ERR "the HDAV1.3 Slim is not supported\n"); + return -ENODEV; default: return -EINVAL; } -- cgit v1.1 From d737f3eedef0717c8b8233bb6455ff13637ff243 Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Mon, 4 Oct 2010 13:23:26 +0200 Subject: ALSA: virtuoso: fix Xonar STX anti-pop delay The anti-pop delay for the STX should be 800 ms, not 100 ms like the ST. Signed-off-by: Clemens Ladisch Signed-off-by: Takashi Iwai --- sound/pci/oxygen/xonar_pcm179x.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/pci/oxygen/xonar_pcm179x.c b/sound/pci/oxygen/xonar_pcm179x.c index 571d0ae..d491fd6 100644 --- a/sound/pci/oxygen/xonar_pcm179x.c +++ b/sound/pci/oxygen/xonar_pcm179x.c @@ -374,7 +374,6 @@ static void xonar_st_init_common(struct oxygen *chip) { struct xonar_pcm179x *data = chip->model_data; - data->generic.anti_pop_delay = 100; data->generic.output_enable_bit = GPIO_ST_OUTPUT_ENABLE; data->dacs = chip->model.private_data ? 4 : 1; data->hp_gain_offset = 2*-18; @@ -420,6 +419,7 @@ static void xonar_st_init(struct oxygen *chip) { struct xonar_pcm179x *data = chip->model_data; + data->generic.anti_pop_delay = 100; data->has_cs2000 = 1; data->cs2000_fun_cfg_1 = CS2000_REF_CLK_DIV_1; @@ -440,6 +440,7 @@ static void xonar_stx_init(struct oxygen *chip) struct xonar_pcm179x *data = chip->model_data; xonar_st_init_i2c(chip); + data->generic.anti_pop_delay = 800; data->generic.ext_power_reg = OXYGEN_GPI_DATA; data->generic.ext_power_int_reg = OXYGEN_GPI_INTERRUPT_MASK; data->generic.ext_power_bit = GPI_EXT_POWER; -- cgit v1.1 From de0074ee7ae7d61da40567afa53912d7e3e16b25 Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Mon, 4 Oct 2010 13:24:43 +0200 Subject: ALSA: oxygen: fix chip ID register symbols Rename the symbol for the XCID pins, fix up a decimal/hex confusion for the CMI8787 package ID, and add the other known package IDs. Signed-off-by: Clemens Ladisch Signed-off-by: Takashi Iwai --- sound/pci/oxygen/oxygen_regs.h | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) (limited to 'sound') diff --git a/sound/pci/oxygen/oxygen_regs.h b/sound/pci/oxygen/oxygen_regs.h index 72de159..4dcd41b 100644 --- a/sound/pci/oxygen/oxygen_regs.h +++ b/sound/pci/oxygen/oxygen_regs.h @@ -436,13 +436,15 @@ /* OXYGEN_CHANNEL_* */ #define OXYGEN_CODEC_VERSION 0xe4 -#define OXYGEN_XCID_MASK 0x07 +#define OXYGEN_CODEC_ID_MASK 0x07 #define OXYGEN_REVISION 0xe6 -#define OXYGEN_REVISION_XPKGID_MASK 0x0007 +#define OXYGEN_PACKAGE_ID_MASK 0x0007 +#define OXYGEN_PACKAGE_ID_8786 0x0004 +#define OXYGEN_PACKAGE_ID_8787 0x0006 +#define OXYGEN_PACKAGE_ID_8788 0x0007 #define OXYGEN_REVISION_MASK 0xfff8 -#define OXYGEN_REVISION_2 0x0008 /* bit flag */ -#define OXYGEN_REVISION_8787 0x0014 /* 8 bits */ +#define OXYGEN_REVISION_2 0x0008 #define OXYGEN_OFFSIN_48K 0xe8 #define OXYGEN_OFFSBASE_48K 0xe9 -- cgit v1.1 From 9a0b37926595b57c4b5fc56aa6fd243bed4ee4eb Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Mon, 4 Oct 2010 13:25:13 +0200 Subject: ALSA: oxygen: fix input monitor dB scale The input monitor half volume bit results in a factor of 0.5, so the minimum scale value should be -6 dB. Signed-off-by: Clemens Ladisch Signed-off-by: Takashi Iwai --- sound/pci/oxygen/oxygen_mixer.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/pci/oxygen/oxygen_mixer.c b/sound/pci/oxygen/oxygen_mixer.c index 7d40ba8..2849b36 100644 --- a/sound/pci/oxygen/oxygen_mixer.c +++ b/sound/pci/oxygen/oxygen_mixer.c @@ -708,7 +708,7 @@ static int ac97_fp_rec_volume_put(struct snd_kcontrol *ctl, .private_value = ((codec) << 24) | ((stereo) << 16) | (index), \ } -static DECLARE_TLV_DB_SCALE(monitor_db_scale, -1000, 1000, 0); +static DECLARE_TLV_DB_SCALE(monitor_db_scale, -600, 600, 0); static DECLARE_TLV_DB_SCALE(ac97_db_scale, -3450, 150, 0); static DECLARE_TLV_DB_SCALE(ac97_rec_db_scale, 0, 150, 0); -- cgit v1.1 From 93943beb29be7084afb61556e96bc454079bfb0e Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Wed, 6 Oct 2010 10:57:11 +0200 Subject: ALSA: oxygen: reduce minimum period count The interrupt counter is independent of the buffer counter, so there are no restrictions on the period size. Having fewer periods also makes PulseAudio happy. Signed-off-by: Clemens Ladisch Signed-off-by: Takashi Iwai --- sound/pci/oxygen/oxygen_pcm.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'sound') diff --git a/sound/pci/oxygen/oxygen_pcm.c b/sound/pci/oxygen/oxygen_pcm.c index 9dff695..8146674 100644 --- a/sound/pci/oxygen/oxygen_pcm.c +++ b/sound/pci/oxygen/oxygen_pcm.c @@ -56,8 +56,8 @@ static const struct snd_pcm_hardware oxygen_stereo_hardware = { .channels_max = 2, .buffer_bytes_max = BUFFER_BYTES_MAX, .period_bytes_min = PERIOD_BYTES_MIN, - .period_bytes_max = BUFFER_BYTES_MAX / 2, - .periods_min = 2, + .period_bytes_max = BUFFER_BYTES_MAX, + .periods_min = 1, .periods_max = BUFFER_BYTES_MAX / PERIOD_BYTES_MIN, }; static const struct snd_pcm_hardware oxygen_multichannel_hardware = { @@ -82,8 +82,8 @@ static const struct snd_pcm_hardware oxygen_multichannel_hardware = { .channels_max = 8, .buffer_bytes_max = BUFFER_BYTES_MAX_MULTICH, .period_bytes_min = PERIOD_BYTES_MIN, - .period_bytes_max = BUFFER_BYTES_MAX_MULTICH / 2, - .periods_min = 2, + .period_bytes_max = BUFFER_BYTES_MAX_MULTICH, + .periods_min = 1, .periods_max = BUFFER_BYTES_MAX_MULTICH / PERIOD_BYTES_MIN, }; static const struct snd_pcm_hardware oxygen_ac97_hardware = { @@ -100,8 +100,8 @@ static const struct snd_pcm_hardware oxygen_ac97_hardware = { .channels_max = 2, .buffer_bytes_max = BUFFER_BYTES_MAX, .period_bytes_min = PERIOD_BYTES_MIN, - .period_bytes_max = BUFFER_BYTES_MAX / 2, - .periods_min = 2, + .period_bytes_max = BUFFER_BYTES_MAX, + .periods_min = 1, .periods_max = BUFFER_BYTES_MAX / PERIOD_BYTES_MIN, }; -- cgit v1.1 From 7cb4ced5aa83b681c76b004c8960b4f2a6471fef Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Wed, 6 Oct 2010 10:57:50 +0200 Subject: ALSA: oxygen: rewrite PCIe bridge initialization Change the PCIe/PCI bridge initialization code to configure only the bridge that is actually connected to the sound chip, instead of any bridge found in the system. The new code also makes it easier to add other bridges. Signed-off-by: Clemens Ladisch Signed-off-by: Takashi Iwai --- sound/pci/oxygen/oxygen_lib.c | 40 +++++++++++++++++++++++----------------- 1 file changed, 23 insertions(+), 17 deletions(-) (limited to 'sound') diff --git a/sound/pci/oxygen/oxygen_lib.c b/sound/pci/oxygen/oxygen_lib.c index 7e93cf8..d10cc6e 100644 --- a/sound/pci/oxygen/oxygen_lib.c +++ b/sound/pci/oxygen/oxygen_lib.c @@ -308,25 +308,31 @@ static void oxygen_restore_eeprom(struct oxygen *chip, } } -static void pci_bridge_magic(void) +static void configure_pcie_bridge(struct pci_dev *pci) { - struct pci_dev *pci = NULL; + enum { PI7C9X110 }; + static const struct pci_device_id bridge_ids[] = { + { PCI_DEVICE(0x12d8, 0xe110), .driver_data = PI7C9X110 }, + { } + }; + struct pci_dev *bridge; + const struct pci_device_id *id; u32 tmp; - for (;;) { - /* If there is any Pericom PI7C9X110 PCI-E/PCI bridge ... */ - pci = pci_get_device(0x12d8, 0xe110, pci); - if (!pci) - break; - /* - * ... configure its secondary internal arbiter to park to - * the secondary port, instead of to the last master. - */ - if (!pci_read_config_dword(pci, 0x40, &tmp)) { - tmp |= 1; - pci_write_config_dword(pci, 0x40, tmp); - } - /* Why? Try asking C-Media. */ + if (!pci->bus || !pci->bus->self) + return; + bridge = pci->bus->self; + + id = pci_match_id(bridge_ids, bridge); + if (!id) + return; + + switch (id->driver_data) { + case PI7C9X110: /* Pericom PI7C9X110 PCIe/PCI bridge */ + pci_read_config_dword(bridge, 0x40, &tmp); + tmp |= 1; /* park the PCI arbiter to the sound chip */ + pci_write_config_dword(bridge, 0x40, tmp); + break; } } @@ -613,7 +619,7 @@ int oxygen_pci_probe(struct pci_dev *pci, int index, char *id, snd_card_set_dev(card, &pci->dev); card->private_free = oxygen_card_free; - pci_bridge_magic(); + configure_pcie_bridge(pci); oxygen_init(chip); chip->model.init(chip); -- cgit v1.1 From ebebeece4ba596973c0c181a8cce5fd77bae427c Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Wed, 6 Oct 2010 10:58:50 +0200 Subject: ALSA: oxygen: add PEX8111 initialization Configure the PEX8111 bridge on the PCI Express cards so that the audio DMA controller can do proper burst reads and is less likely to lose data. This is usually done automatically, but is required on older cards where the user has not applied the PLX firmware update. Signed-off-by: Clemens Ladisch Signed-off-by: Takashi Iwai --- sound/pci/oxygen/oxygen_lib.c | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/pci/oxygen/oxygen_lib.c b/sound/pci/oxygen/oxygen_lib.c index d10cc6e..e5ebe56 100644 --- a/sound/pci/oxygen/oxygen_lib.c +++ b/sound/pci/oxygen/oxygen_lib.c @@ -310,8 +310,10 @@ static void oxygen_restore_eeprom(struct oxygen *chip, static void configure_pcie_bridge(struct pci_dev *pci) { - enum { PI7C9X110 }; + enum { PEX811X, PI7C9X110 }; static const struct pci_device_id bridge_ids[] = { + { PCI_VDEVICE(PLX, 0x8111), .driver_data = PEX811X }, + { PCI_VDEVICE(PLX, 0x8112), .driver_data = PEX811X }, { PCI_DEVICE(0x12d8, 0xe110), .driver_data = PI7C9X110 }, { } }; @@ -328,6 +330,19 @@ static void configure_pcie_bridge(struct pci_dev *pci) return; switch (id->driver_data) { + case PEX811X: /* PLX PEX8111/PEX8112 PCIe/PCI bridge */ + pci_read_config_dword(bridge, 0x48, &tmp); + tmp |= 1; /* enable blind prefetching */ + tmp |= 1 << 11; /* enable beacon generation */ + pci_write_config_dword(bridge, 0x48, tmp); + + pci_write_config_dword(bridge, 0x84, 0x0c); + pci_read_config_dword(bridge, 0x88, &tmp); + tmp &= ~(7 << 27); + tmp |= 2 << 27; /* set prefetch size to 128 bytes */ + pci_write_config_dword(bridge, 0x88, tmp); + break; + case PI7C9X110: /* Pericom PI7C9X110 PCIe/PCI bridge */ pci_read_config_dword(bridge, 0x40, &tmp); tmp |= 1; /* park the PCI arbiter to the sound chip */ -- cgit v1.1 From dd1d3a49db4ae5c6afffadaff526b96c7993c7dd Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Wed, 6 Oct 2010 17:28:56 +0200 Subject: ALSA: oxygen - Add a SSID for CMI8787-HG2PCI This board has a strange PCI SSID 13f6:ffff. Works as compabile as MODEL_CMEDIA_REF. Reported-by: Takashi Sakamoto Signed-off-by: Takashi Iwai --- sound/pci/oxygen/oxygen.c | 1 + 1 file changed, 1 insertion(+) (limited to 'sound') diff --git a/sound/pci/oxygen/oxygen.c b/sound/pci/oxygen/oxygen.c index f4fdf6d..1d915ef 100644 --- a/sound/pci/oxygen/oxygen.c +++ b/sound/pci/oxygen/oxygen.c @@ -79,6 +79,7 @@ static DEFINE_PCI_DEVICE_TABLE(oxygen_ids) = { { OXYGEN_PCI_SUBID(0x13f6, 0x0001), .driver_data = MODEL_CMEDIA_REF }, { OXYGEN_PCI_SUBID(0x13f6, 0x0010), .driver_data = MODEL_CMEDIA_REF }, { OXYGEN_PCI_SUBID(0x13f6, 0x8788), .driver_data = MODEL_CMEDIA_REF }, + { OXYGEN_PCI_SUBID(0x13f6, 0xffff), .driver_data = MODEL_CMEDIA_REF }, { OXYGEN_PCI_SUBID(0x147a, 0xa017), .driver_data = MODEL_CMEDIA_REF }, { OXYGEN_PCI_SUBID(0x1a58, 0x0910), .driver_data = MODEL_CMEDIA_REF }, { OXYGEN_PCI_SUBID(0x415a, 0x5431), .driver_data = MODEL_MERIDIAN }, -- cgit v1.1 From de535a5be53a06738409538c471a10a9de357bdd Mon Sep 17 00:00:00 2001 From: Mark Brown Date: Wed, 6 Oct 2010 16:20:07 -0700 Subject: ASoC: Staticise AD1980 DAI It doesn't need to be exported with multi-component. Signed-off-by: Mark Brown Acked-by: Liam Girdwood --- sound/soc/codecs/ad1980.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/soc/codecs/ad1980.c b/sound/soc/codecs/ad1980.c index d36bd1c..410ccd5 100644 --- a/sound/soc/codecs/ad1980.c +++ b/sound/soc/codecs/ad1980.c @@ -133,7 +133,7 @@ static int ac97_write(struct snd_soc_codec *codec, unsigned int reg, return 0; } -struct snd_soc_dai_driver ad1980_dai = { +static struct snd_soc_dai_driver ad1980_dai = { .name = "ad1980-hifi", .ac97_control = 1, .playback = { -- cgit v1.1 From 4c14d78e8ad3bacfe1f70cb49ae17afcd658e368 Mon Sep 17 00:00:00 2001 From: Mark Brown Date: Wed, 6 Oct 2010 15:54:28 -0700 Subject: ASoC: Use delayed work for debounce of GPIO based jacks Rather than block the workqueue by sleeping to do the debounce use delayed work to implement the debounce time. This should also means that we extend the debounce time on each new bounce, potentially allowing shorter debounce times for clean insertions. Signed-off-by: Mark Brown Acked-by: Jarkko Nikula Acked-by: Liam Girdwood --- sound/soc/soc-jack.c | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) (limited to 'sound') diff --git a/sound/soc/soc-jack.c b/sound/soc/soc-jack.c index 8862770..8a0a920 100644 --- a/sound/soc/soc-jack.c +++ b/sound/soc/soc-jack.c @@ -188,9 +188,6 @@ static void snd_soc_jack_gpio_detect(struct snd_soc_jack_gpio *gpio) int enable; int report; - if (gpio->debounce_time > 0) - mdelay(gpio->debounce_time); - enable = gpio_get_value(gpio->gpio); if (gpio->invert) enable = !enable; @@ -211,7 +208,8 @@ static irqreturn_t gpio_handler(int irq, void *data) { struct snd_soc_jack_gpio *gpio = data; - schedule_work(&gpio->work); + schedule_delayed_work(&gpio->work, + msecs_to_jiffies(gpio->debounce_time)); return IRQ_HANDLED; } @@ -221,7 +219,7 @@ static void gpio_work(struct work_struct *work) { struct snd_soc_jack_gpio *gpio; - gpio = container_of(work, struct snd_soc_jack_gpio, work); + gpio = container_of(work, struct snd_soc_jack_gpio, work.work); snd_soc_jack_gpio_detect(gpio); } @@ -262,7 +260,7 @@ int snd_soc_jack_add_gpios(struct snd_soc_jack *jack, int count, if (ret) goto err; - INIT_WORK(&gpios[i].work, gpio_work); + INIT_DELAYED_WORK(&gpios[i].work, gpio_work); gpios[i].jack = jack; ret = request_irq(gpio_to_irq(gpios[i].gpio), @@ -312,6 +310,7 @@ void snd_soc_jack_free_gpios(struct snd_soc_jack *jack, int count, gpio_unexport(gpios[i].gpio); #endif free_irq(gpio_to_irq(gpios[i].gpio), &gpios[i]); + cancel_delayed_work_sync(&gpios[i].work); gpio_free(gpios[i].gpio); gpios[i].jack = NULL; } -- cgit v1.1 From 5c75848a7ca19c83c7b8afd0822bdcb716992c0c Mon Sep 17 00:00:00 2001 From: Mark Brown Date: Wed, 6 Oct 2010 16:18:17 -0700 Subject: ASoC: Staticise CS4270 DAI It's not needed with multi-component. Signed-off-by: Mark Brown Acked-by: Liam Girdwood Acked-by: Timur Tabi --- sound/soc/codecs/cs4270.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/soc/codecs/cs4270.c b/sound/soc/codecs/cs4270.c index 5fd8e0d..6d4bdc6 100644 --- a/sound/soc/codecs/cs4270.c +++ b/sound/soc/codecs/cs4270.c @@ -518,7 +518,7 @@ static struct snd_soc_dai_ops cs4270_dai_ops = { .digital_mute = cs4270_dai_mute, }; -struct snd_soc_dai_driver cs4270_dai = { +static struct snd_soc_dai_driver cs4270_dai = { .name = "cs4270-hifi", .playback = { .stream_name = "Playback", -- cgit v1.1 From cf4c87abe238ec17cd0255b4e21abd949d7f811e Mon Sep 17 00:00:00 2001 From: Paul Walmsley Date: Fri, 8 Oct 2010 11:40:19 -0600 Subject: OMAP: McBSP: implement McBSP CLKR and FSR signal muxing via mach-omap2/mcbsp.c The OMAP ASoC McBSP code implemented CLKR and FSR signal muxing via direct System Control Module writes on OMAP2+. This required the omap_ctrl_{read,write}l() functions to be exported, which is against policy: the only code that should call those functions directly is OMAP core code, not device drivers. omap_ctrl_{read,write}*() are no longer exported, so the driver no longer builds as a module. Fix the pinmuxing part of the problem by removing calls to omap_ctrl_{read,write}l() from the OMAP ASoC McBSP code and implementing signal muxing functions in arch/arm/mach-omap2/mcbsp.c. Due to the unfortunate way that McBSP support is implemented in ASoC and the OMAP tree, these symbols must be exported for use by sound/soc/omap/omap-mcbsp.c. Going forward, the McBSP device driver should be moved from arch/arm/*omap* into drivers/ or sound/soc/*, and the CPU DAI driver should be implemented as a platform_driver as many other ASoC CPU DAI drivers are. These two steps should resolve many of the layering problems, which will rapidly reappear during a McBSP hwmod/PM runtime conversion. Signed-off-by: Paul Walmsley Acked-by: Jarkko Nikula Acked-by: Peter Ujfalusi Acked-by: Liam Girdwood Acked-by: Mark Brown --- sound/soc/omap/omap-mcbsp.c | 52 +++++++++++++++------------------------------ 1 file changed, 17 insertions(+), 35 deletions(-) (limited to 'sound') diff --git a/sound/soc/omap/omap-mcbsp.c b/sound/soc/omap/omap-mcbsp.c index 86f21390..f50a5ab 100644 --- a/sound/soc/omap/omap-mcbsp.c +++ b/sound/soc/omap/omap-mcbsp.c @@ -661,48 +661,23 @@ static int omap_mcbsp_dai_set_clks_src(struct omap_mcbsp_data *mcbsp_data, return 0; } -static int omap_mcbsp_dai_set_rcvr_src(struct omap_mcbsp_data *mcbsp_data, - int clk_id) -{ - int sel_bit, set = 0; - u16 reg = OMAP2_CONTROL_DEVCONF0; - - if (cpu_class_is_omap1()) - return -EINVAL; /* TODO: Can this be implemented for OMAP1? */ - if (mcbsp_data->bus_id != 0) - return -EINVAL; - - switch (clk_id) { - case OMAP_MCBSP_CLKR_SRC_CLKX: - set = 1; - case OMAP_MCBSP_CLKR_SRC_CLKR: - sel_bit = 3; - break; - case OMAP_MCBSP_FSR_SRC_FSX: - set = 1; - case OMAP_MCBSP_FSR_SRC_FSR: - sel_bit = 4; - break; - default: - return -EINVAL; - } - - if (set) - omap_ctrl_writel(omap_ctrl_readl(reg) | (1 << sel_bit), reg); - else - omap_ctrl_writel(omap_ctrl_readl(reg) & ~(1 << sel_bit), reg); - - return 0; -} - static int omap_mcbsp_dai_set_dai_sysclk(struct snd_soc_dai *cpu_dai, int clk_id, unsigned int freq, int dir) { struct omap_mcbsp_data *mcbsp_data = to_mcbsp(cpu_dai->private_data); struct omap_mcbsp_reg_cfg *regs = &mcbsp_data->regs; + struct omap_mcbsp_platform_data *pdata = cpu_dai->dev->platform_data; int err = 0; + /* The McBSP signal muxing functions are only available on McBSP1 */ + if (clk_id == OMAP_MCBSP_CLKR_SRC_CLKR || + clk_id == OMAP_MCBSP_CLKR_SRC_CLKX || + clk_id == OMAP_MCBSP_FSR_SRC_FSR || + clk_id == OMAP_MCBSP_FSR_SRC_FSX) + if (cpu_class_is_omap1() || mcbsp_data->bus_id != 0) + return -EINVAL; + mcbsp_data->in_freq = freq; switch (clk_id) { @@ -720,11 +695,18 @@ static int omap_mcbsp_dai_set_dai_sysclk(struct snd_soc_dai *cpu_dai, regs->pcr0 |= SCLKME; break; + case OMAP_MCBSP_CLKR_SRC_CLKR: + omap2_mcbsp1_mux_clkr_src(CLKR_SRC_CLKR); + break; case OMAP_MCBSP_CLKR_SRC_CLKX: + omap2_mcbsp1_mux_clkr_src(CLKR_SRC_CLKX); + break; case OMAP_MCBSP_FSR_SRC_FSR: + omap2_mcbsp1_mux_fsr_src(FSR_SRC_FSR); + break; case OMAP_MCBSP_FSR_SRC_FSX: - err = omap_mcbsp_dai_set_rcvr_src(mcbsp_data, clk_id); + omap2_mcbsp1_mux_fsr_src(FSR_SRC_FSX); break; default: err = -ENODEV; -- cgit v1.1 From d13586574d373ef40acd4725c9a269daa355e412 Mon Sep 17 00:00:00 2001 From: Paul Walmsley Date: Fri, 8 Oct 2010 11:40:19 -0600 Subject: OMAP: McBSP: implement functional clock switching via clock framework Previously the OMAP McBSP ASoC driver implemented CLKS switching by using omap_ctrl_{read,write}l() directly. This is against policy; the OMAP System Control Module functions are not intended to be exported to drivers. These symbols are no longer exported, so as a result, the OMAP McBSP ASoC driver does not build as a module. Resolve the CLKS clock changing portion of this problem by creating a clock parent changing function that lives in arch/arm/mach-omap2/mcbsp.c, and modify the ASoC driver to use it. Due to the unfortunate way that McBSP support is implemented in ASoC and the OMAP tree, this symbol must be exported for use by sound/soc/omap/omap-mcbsp.c. Going forward, the McBSP device driver should be moved from arch/arm/*omap* into drivers/ or sound/soc/* and the CPU DAI driver should be implemented as a platform_driver as many other ASoC CPU DAI drivers are. These two steps should resolve many of the layering problems, which will rapidly reappear during a McBSP hwmod/PM runtime conversions. Signed-off-by: Paul Walmsley Acked-by: Jarkko Nikula Acked-by: Peter Ujfalusi Acked-by: Liam Girdwood Acked-by: Mark Brown --- sound/soc/omap/omap-mcbsp.c | 69 +++++++++------------------------------------ 1 file changed, 13 insertions(+), 56 deletions(-) (limited to 'sound') diff --git a/sound/soc/omap/omap-mcbsp.c b/sound/soc/omap/omap-mcbsp.c index f50a5ab..b59ad11 100644 --- a/sound/soc/omap/omap-mcbsp.c +++ b/sound/soc/omap/omap-mcbsp.c @@ -31,7 +31,6 @@ #include #include -#include #include #include #include "omap-mcbsp.h" @@ -608,66 +607,12 @@ static int omap_mcbsp_dai_set_clkdiv(struct snd_soc_dai *cpu_dai, return 0; } -static int omap_mcbsp_dai_set_clks_src(struct omap_mcbsp_data *mcbsp_data, - int clk_id) -{ - int sel_bit; - u16 reg, reg_devconf1 = OMAP243X_CONTROL_DEVCONF1; - - if (cpu_class_is_omap1()) { - /* OMAP1's can use only external source clock */ - if (unlikely(clk_id == OMAP_MCBSP_SYSCLK_CLKS_FCLK)) - return -EINVAL; - else - return 0; - } - - if (cpu_is_omap2420() && mcbsp_data->bus_id > 1) - return -EINVAL; - - if (cpu_is_omap343x()) - reg_devconf1 = OMAP343X_CONTROL_DEVCONF1; - - switch (mcbsp_data->bus_id) { - case 0: - reg = OMAP2_CONTROL_DEVCONF0; - sel_bit = 2; - break; - case 1: - reg = OMAP2_CONTROL_DEVCONF0; - sel_bit = 6; - break; - case 2: - reg = reg_devconf1; - sel_bit = 0; - break; - case 3: - reg = reg_devconf1; - sel_bit = 2; - break; - case 4: - reg = reg_devconf1; - sel_bit = 4; - break; - default: - return -EINVAL; - } - - if (clk_id == OMAP_MCBSP_SYSCLK_CLKS_FCLK) - omap_ctrl_writel(omap_ctrl_readl(reg) & ~(1 << sel_bit), reg); - else - omap_ctrl_writel(omap_ctrl_readl(reg) | (1 << sel_bit), reg); - - return 0; -} - static int omap_mcbsp_dai_set_dai_sysclk(struct snd_soc_dai *cpu_dai, int clk_id, unsigned int freq, int dir) { struct omap_mcbsp_data *mcbsp_data = to_mcbsp(cpu_dai->private_data); struct omap_mcbsp_reg_cfg *regs = &mcbsp_data->regs; - struct omap_mcbsp_platform_data *pdata = cpu_dai->dev->platform_data; int err = 0; /* The McBSP signal muxing functions are only available on McBSP1 */ @@ -685,8 +630,20 @@ static int omap_mcbsp_dai_set_dai_sysclk(struct snd_soc_dai *cpu_dai, regs->srgr2 |= CLKSM; break; case OMAP_MCBSP_SYSCLK_CLKS_FCLK: + if (cpu_class_is_omap1()) { + err = -EINVAL; + break; + } + err = omap2_mcbsp_set_clks_src(mcbsp_data->bus_id, + MCBSP_CLKS_PRCM_SRC); + break; case OMAP_MCBSP_SYSCLK_CLKS_EXT: - err = omap_mcbsp_dai_set_clks_src(mcbsp_data, clk_id); + if (cpu_class_is_omap1()) { + err = 0; + break; + } + err = omap2_mcbsp_set_clks_src(mcbsp_data->bus_id, + MCBSP_CLKS_PAD_SRC); break; case OMAP_MCBSP_SYSCLK_CLKX_EXT: -- cgit v1.1 From b1c73fc8e697eb73e23603e465e9af2711ed4183 Mon Sep 17 00:00:00 2001 From: Jaroslav Kysela Date: Mon, 11 Oct 2010 10:45:00 +0200 Subject: ALSA: snd-aloop: Fix hw_params restrictions and checking This patch fixes the hw_params restrictions when first (or playback) stream sets the final hardware parameters. Also, fix the hw_params checking in the trigger callback. Signed-off-by: Jaroslav Kysela --- sound/drivers/aloop.c | 124 ++++++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 106 insertions(+), 18 deletions(-) (limited to 'sound') diff --git a/sound/drivers/aloop.c b/sound/drivers/aloop.c index 040030a..3c00882 100644 --- a/sound/drivers/aloop.c +++ b/sound/drivers/aloop.c @@ -188,7 +188,7 @@ static inline void loopback_timer_stop(struct loopback_pcm *dpcm) static int loopback_check_format(struct loopback_cable *cable, int stream) { - struct snd_pcm_runtime *runtime; + struct snd_pcm_runtime *runtime, *cruntime; struct loopback_setup *setup; struct snd_card *card; int check; @@ -200,11 +200,11 @@ static int loopback_check_format(struct loopback_cable *cable, int stream) } runtime = cable->streams[SNDRV_PCM_STREAM_PLAYBACK]-> substream->runtime; - check = cable->hw.formats != (1ULL << runtime->format) || - cable->hw.rate_min != runtime->rate || - cable->hw.rate_max != runtime->rate || - cable->hw.channels_min != runtime->channels || - cable->hw.channels_max != runtime->channels; + cruntime = cable->streams[SNDRV_PCM_STREAM_CAPTURE]-> + substream->runtime; + check = runtime->format != cruntime->format || + runtime->rate != cruntime->rate || + runtime->channels != cruntime->channels; if (!check) return 0; if (stream == SNDRV_PCM_STREAM_CAPTURE) { @@ -274,12 +274,42 @@ static int loopback_trigger(struct snd_pcm_substream *substream, int cmd) return 0; } +static void params_change_substream(struct loopback_pcm *dpcm, + struct snd_pcm_runtime *runtime) +{ + struct snd_pcm_runtime *dst_runtime; + + if (dpcm == NULL || dpcm->substream == NULL) + return; + dst_runtime = dpcm->substream->runtime; + if (dst_runtime == NULL) + return; + dst_runtime->hw = dpcm->cable->hw; +} + +static void params_change(struct snd_pcm_substream *substream) +{ + struct snd_pcm_runtime *runtime = substream->runtime; + struct loopback_pcm *dpcm = runtime->private_data; + struct loopback_cable *cable = dpcm->cable; + + cable->hw.formats = (1ULL << runtime->format); + cable->hw.rate_min = runtime->rate; + cable->hw.rate_max = runtime->rate; + cable->hw.channels_min = runtime->channels; + cable->hw.channels_max = runtime->channels; + params_change_substream(cable->streams[SNDRV_PCM_STREAM_PLAYBACK], + runtime); + params_change_substream(cable->streams[SNDRV_PCM_STREAM_CAPTURE], + runtime); +} + static int loopback_prepare(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime = substream->runtime; struct loopback_pcm *dpcm = runtime->private_data; struct loopback_cable *cable = dpcm->cable; - unsigned int bps, salign; + int bps, salign; salign = (snd_pcm_format_width(runtime->format) * runtime->channels) / 8; @@ -303,13 +333,10 @@ static int loopback_prepare(struct snd_pcm_substream *substream) dpcm->pcm_period_size = frames_to_bytes(runtime, runtime->period_size); mutex_lock(&dpcm->loopback->cable_lock); - if (!(cable->valid & ~(1 << substream->stream))) { - cable->hw.formats = (1ULL << runtime->format); - cable->hw.rate_min = runtime->rate; - cable->hw.rate_max = runtime->rate; - cable->hw.channels_min = runtime->channels; - cable->hw.channels_max = runtime->channels; - } + if (!(cable->valid & ~(1 << substream->stream)) || + (get_setup(dpcm)->notify && + substream->stream == SNDRV_PCM_STREAM_PLAYBACK)) + params_change(substream); cable->valid |= 1 << substream->stream; mutex_unlock(&dpcm->loopback->cable_lock); @@ -542,6 +569,47 @@ static unsigned int get_cable_index(struct snd_pcm_substream *substream) return !substream->stream; } +static int rule_format(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) +{ + + struct snd_pcm_hardware *hw = rule->private; + struct snd_mask *maskp = hw_param_mask(params, rule->var); + + maskp->bits[0] &= (u_int32_t)hw->formats; + maskp->bits[1] &= (u_int32_t)(hw->formats >> 32); + memset(maskp->bits + 2, 0, (SNDRV_MASK_MAX-64) / 8); /* clear rest */ + if (! maskp->bits[0] && ! maskp->bits[1]) + return -EINVAL; + return 0; +} + +static int rule_rate(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) +{ + struct snd_pcm_hardware *hw = rule->private; + struct snd_interval t; + + t.min = hw->rate_min; + t.max = hw->rate_max; + t.openmin = t.openmax = 0; + t.integer = 0; + return snd_interval_refine(hw_param_interval(params, rule->var), &t); +} + +static int rule_channels(struct snd_pcm_hw_params *params, + struct snd_pcm_hw_rule *rule) +{ + struct snd_pcm_hardware *hw = rule->private; + struct snd_interval t; + + t.min = hw->channels_min; + t.max = hw->channels_max; + t.openmin = t.openmax = 0; + t.integer = 0; + return snd_interval_refine(hw_param_interval(params, rule->var), &t); +} + static int loopback_open(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime = substream->runtime; @@ -579,14 +647,34 @@ static int loopback_open(struct snd_pcm_substream *substream) snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS); + /* use dynamic rules based on actual runtime->hw values */ + /* note that the default rules created in the PCM midlevel code */ + /* are cached -> they do not reflect the actual state */ + err = snd_pcm_hw_rule_add(runtime, 0, + SNDRV_PCM_HW_PARAM_FORMAT, + rule_format, &runtime->hw, + SNDRV_PCM_HW_PARAM_FORMAT, -1); + if (err < 0) + goto unlock; + err = snd_pcm_hw_rule_add(runtime, 0, + SNDRV_PCM_HW_PARAM_RATE, + rule_rate, &runtime->hw, + SNDRV_PCM_HW_PARAM_RATE, -1); + if (err < 0) + goto unlock; + err = snd_pcm_hw_rule_add(runtime, 0, + SNDRV_PCM_HW_PARAM_CHANNELS, + rule_channels, &runtime->hw, + SNDRV_PCM_HW_PARAM_CHANNELS, -1); + if (err < 0) + goto unlock; + runtime->private_data = dpcm; runtime->private_free = loopback_runtime_free; - if (get_notify(dpcm) && - substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { + if (get_notify(dpcm)) runtime->hw = loopback_pcm_hardware; - } else { + else runtime->hw = cable->hw; - } unlock: mutex_unlock(&loopback->cable_lock); return err; -- cgit v1.1 From 838c364ff05c143fd1810e8ad1469935d6c23a7a Mon Sep 17 00:00:00 2001 From: Jaroslav Kysela Date: Fri, 8 Oct 2010 10:48:50 +0200 Subject: ALSA: OSS mixer emulation - fix locking Fix mutex release and cleanup some locking code. Cc: Signed-off-by: Jaroslav Kysela --- sound/core/oss/mixer_oss.c | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) (limited to 'sound') diff --git a/sound/core/oss/mixer_oss.c b/sound/core/oss/mixer_oss.c index f50ebf2..8442a08 100644 --- a/sound/core/oss/mixer_oss.c +++ b/sound/core/oss/mixer_oss.c @@ -618,8 +618,10 @@ static void snd_mixer_oss_put_volume1_vol(struct snd_mixer_oss_file *fmixer, if (numid == ID_UNKNOWN) return; down_read(&card->controls_rwsem); - if ((kctl = snd_ctl_find_numid(card, numid)) == NULL) + if ((kctl = snd_ctl_find_numid(card, numid)) == NULL) { + up_read(&card->controls_rwsem); return; + } uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL); uctl = kzalloc(sizeof(*uctl), GFP_KERNEL); if (uinfo == NULL || uctl == NULL) @@ -658,7 +660,7 @@ static void snd_mixer_oss_put_volume1_sw(struct snd_mixer_oss_file *fmixer, return; down_read(&card->controls_rwsem); if ((kctl = snd_ctl_find_numid(card, numid)) == NULL) { - up_read(&fmixer->card->controls_rwsem); + up_read(&card->controls_rwsem); return; } uinfo = kzalloc(sizeof(*uinfo), GFP_KERNEL); @@ -797,7 +799,7 @@ static int snd_mixer_oss_get_recsrc2(struct snd_mixer_oss_file *fmixer, unsigned uctl = kzalloc(sizeof(*uctl), GFP_KERNEL); if (uinfo == NULL || uctl == NULL) { err = -ENOMEM; - goto __unlock; + goto __free_only; } down_read(&card->controls_rwsem); kctl = snd_mixer_oss_test_id(mixer, "Capture Source", 0); @@ -826,6 +828,7 @@ static int snd_mixer_oss_get_recsrc2(struct snd_mixer_oss_file *fmixer, unsigned err = 0; __unlock: up_read(&card->controls_rwsem); + __free_only: kfree(uctl); kfree(uinfo); return err; @@ -847,7 +850,7 @@ static int snd_mixer_oss_put_recsrc2(struct snd_mixer_oss_file *fmixer, unsigned uctl = kzalloc(sizeof(*uctl), GFP_KERNEL); if (uinfo == NULL || uctl == NULL) { err = -ENOMEM; - goto __unlock; + goto __free_only; } down_read(&card->controls_rwsem); kctl = snd_mixer_oss_test_id(mixer, "Capture Source", 0); @@ -880,6 +883,7 @@ static int snd_mixer_oss_put_recsrc2(struct snd_mixer_oss_file *fmixer, unsigned err = 0; __unlock: up_read(&card->controls_rwsem); + __free_only: kfree(uctl); kfree(uinfo); return err; -- cgit v1.1 From f57f6c046ff54b7115c6cafd3e29a60342352cce Mon Sep 17 00:00:00 2001 From: Mark Brown Date: Thu, 7 Oct 2010 17:41:04 -0700 Subject: ASoC: Shrink code size for WM8962 register defaults table Dramatically reduce the code size for the WM8962 register defaults table by switching to explicitly initialise only defined registers, relying on static defaulting to zero for the overwelming bulk of the register map. Similar treatement for the register access table will come later and will produce a similarly dramatic code size shrink. Signed-off-by: Mark Brown Acked-by: Liam Girdwood --- sound/soc/codecs/wm8962-tables.c | 21143 ------------------------------------- sound/soc/codecs/wm8962.c | 687 ++ sound/soc/codecs/wm8962.h | 2 - 3 files changed, 687 insertions(+), 21145 deletions(-) (limited to 'sound') diff --git a/sound/soc/codecs/wm8962-tables.c b/sound/soc/codecs/wm8962-tables.c index 6fa98ea..8231eaa 100644 --- a/sound/soc/codecs/wm8962-tables.c +++ b/sound/soc/codecs/wm8962-tables.c @@ -12,21149 +12,6 @@ #include "wm8962.h" -const u16 wm8962_reg[WM8962_MAX_REGISTER + 1] = { - 0x009F, /* R0 - Left Input volume */ - 0x049F, /* R1 - Right Input volume */ - 0x0000, /* R2 - HPOUTL volume */ - 0x0000, /* R3 - HPOUTR volume */ - 0x0020, /* R4 - Clocking1 */ - 0x0018, /* R5 - ADC & DAC Control 1 */ - 0x2008, /* R6 - ADC & DAC Control 2 */ - 0x000A, /* R7 - Audio Interface 0 */ - 0x01E4, /* R8 - Clocking2 */ - 0x0300, /* R9 - Audio Interface 1 */ - 0x00C0, /* R10 - Left DAC volume */ - 0x00C0, /* R11 - Right DAC volume */ - 0x0000, /* R12 */ - 0x0000, /* R13 */ - 0x0040, /* R14 - Audio Interface 2 */ - 0x6243, /* R15 - Software Reset */ - 0x0000, /* R16 */ - 0x007B, /* R17 - ALC1 */ - 0x0000, /* R18 - ALC2 */ - 0x1C32, /* R19 - ALC3 */ - 0x3200, /* R20 - Noise Gate */ - 0x00C0, /* R21 - Left ADC volume */ - 0x00C0, /* R22 - Right ADC volume */ - 0x0160, /* R23 - Additional control(1) */ - 0x0000, /* R24 - Additional control(2) */ - 0x0000, /* R25 - Pwr Mgmt (1) */ - 0x0000, /* R26 - Pwr Mgmt (2) */ - 0x0010, /* R27 - Additional Control (3) */ - 0x0000, /* R28 - Anti-pop */ - 0x0000, /* R29 */ - 0x005E, /* R30 - Clocking 3 */ - 0x0000, /* R31 - Input mixer control (1) */ - 0x0145, /* R32 - Left input mixer volume */ - 0x0145, /* R33 - Right input mixer volume */ - 0x0009, /* R34 - Input mixer control (2) */ - 0x0003, /* R35 - Input bias control */ - 0x0000, /* R36 */ - 0x0008, /* R37 - Left input PGA control */ - 0x0008, /* R38 - Right input PGA control */ - 0x0000, /* R39 */ - 0x0000, /* R40 - SPKOUTL volume */ - 0x0000, /* R41 - SPKOUTR volume */ - 0x0000, /* R42 */ - 0x0000, /* R43 */ - 0x0000, /* R44 */ - 0x0000, /* R45 */ - 0x0000, /* R46 */ - 0x0000, /* R47 - Thermal Shutdown Status */ - 0x8027, /* R48 - Additional Control (4) */ - 0x0010, /* R49 - Class D Control 1 */ - 0x0000, /* R50 */ - 0x0003, /* R51 - Class D Control 2 */ - 0x0000, /* R52 */ - 0x0000, /* R53 */ - 0x0000, /* R54 */ - 0x0000, /* R55 */ - 0x0506, /* R56 - Clocking 4 */ - 0x0000, /* R57 - DAC DSP Mixing (1) */ - 0x0000, /* R58 - DAC DSP Mixing (2) */ - 0x0000, /* R59 */ - 0x0300, /* R60 - DC Servo 0 */ - 0x0300, /* R61 - DC Servo 1 */ - 0x0000, /* R62 */ - 0x0000, /* R63 */ - 0x0810, /* R64 - DC Servo 4 */ - 0x0000, /* R65 */ - 0x0000, /* R66 - DC Servo 6 */ - 0x0000, /* R67 */ - 0x001B, /* R68 - Analogue PGA Bias */ - 0x0000, /* R69 - Analogue HP 0 */ - 0x0000, /* R70 */ - 0x01FB, /* R71 - Analogue HP 2 */ - 0x0000, /* R72 - Charge Pump 1 */ - 0x0000, /* R73 */ - 0x0000, /* R74 */ - 0x0000, /* R75 */ - 0x0000, /* R76 */ - 0x0000, /* R77 */ - 0x0000, /* R78 */ - 0x0000, /* R79 */ - 0x0000, /* R80 */ - 0x0000, /* R81 */ - 0x0004, /* R82 - Charge Pump B */ - 0x0000, /* R83 */ - 0x0000, /* R84 */ - 0x0000, /* R85 */ - 0x0000, /* R86 */ - 0x0000, /* R87 - Write Sequencer Control 1 */ - 0x0000, /* R88 */ - 0x0000, /* R89 */ - 0x0000, /* R90 - Write Sequencer Control 2 */ - 0x0000, /* R91 */ - 0x0000, /* R92 */ - 0x0000, /* R93 - Write Sequencer Control 3 */ - 0x0000, /* R94 - Control Interface */ - 0x0000, /* R95 */ - 0x0000, /* R96 */ - 0x0000, /* R97 */ - 0x0000, /* R98 */ - 0x0000, /* R99 - Mixer Enables */ - 0x0000, /* R100 - Headphone Mixer (1) */ - 0x0000, /* R101 - Headphone Mixer (2) */ - 0x013F, /* R102 - Headphone Mixer (3) */ - 0x013F, /* R103 - Headphone Mixer (4) */ - 0x0000, /* R104 */ - 0x0000, /* R105 - Speaker Mixer (1) */ - 0x0000, /* R106 - Speaker Mixer (2) */ - 0x013F, /* R107 - Speaker Mixer (3) */ - 0x013F, /* R108 - Speaker Mixer (4) */ - 0x0003, /* R109 - Speaker Mixer (5) */ - 0x0002, /* R110 - Beep Generator (1) */ - 0x0000, /* R111 */ - 0x0000, /* R112 */ - 0x0000, /* R113 */ - 0x0000, /* R114 */ - 0x0006, /* R115 - Oscillator Trim (3) */ - 0x0026, /* R116 - Oscillator Trim (4) */ - 0x0000, /* R117 */ - 0x0000, /* R118 */ - 0x0000, /* R119 - Oscillator Trim (7) */ - 0x0000, /* R120 */ - 0x0000, /* R121 */ - 0x0000, /* R122 */ - 0x0000, /* R123 */ - 0x0011, /* R124 - Analogue Clocking1 */ - 0x004B, /* R125 - Analogue Clocking2 */ - 0x000D, /* R126 - Analogue Clocking3 */ - 0x0000, /* R127 - PLL Software Reset */ - 0x0000, /* R128 */ - 0x0000, /* R129 - PLL2 */ - 0x0000, /* R130 */ - 0x0000, /* R131 - PLL 4 */ - 0x0000, /* R132 */ - 0x0000, /* R133 */ - 0x0000, /* R134 */ - 0x0000, /* R135 */ - 0x0067, /* R136 - PLL 9 */ - 0x001C, /* R137 - PLL 10 */ - 0x0071, /* R138 - PLL 11 */ - 0x00C7, /* R139 - PLL 12 */ - 0x0067, /* R140 - PLL 13 */ - 0x0048, /* R141 - PLL 14 */ - 0x0022, /* R142 - PLL 15 */ - 0x0097, /* R143 - PLL 16 */ - 0x0000, /* R144 */ - 0x0000, /* R145 */ - 0x0000, /* R146 */ - 0x0000, /* R147 */ - 0x0000, /* R148 */ - 0x0000, /* R149 */ - 0x0000, /* R150 */ - 0x0000, /* R151 */ - 0x0000, /* R152 */ - 0x0000, /* R153 */ - 0x0000, /* R154 */ - 0x000C, /* R155 - FLL Control (1) */ - 0x0039, /* R156 - FLL Control (2) */ - 0x0180, /* R157 - FLL Control (3) */ - 0x0000, /* R158 */ - 0x0032, /* R159 - FLL Control (5) */ - 0x0018, /* R160 - FLL Control (6) */ - 0x007D, /* R161 - FLL Control (7) */ - 0x0008, /* R162 - FLL Control (8) */ - 0x0000, /* R163 */ - 0x0000, /* R164 */ - 0x0000, /* R165 */ - 0x0000, /* R166 */ - 0x0000, /* R167 */ - 0x0000, /* R168 */ - 0x0000, /* R169 */ - 0x0000, /* R170 */ - 0x0000, /* R171 */ - 0x0000, /* R172 */ - 0x0000, /* R173 */ - 0x0000, /* R174 */ - 0x0000, /* R175 */ - 0x0000, /* R176 */ - 0x0000, /* R177 */ - 0x0000, /* R178 */ - 0x0000, /* R179 */ - 0x0000, /* R180 */ - 0x0000, /* R181 */ - 0x0000, /* R182 */ - 0x0000, /* R183 */ - 0x0000, /* R184 */ - 0x0000, /* R185 */ - 0x0000, /* R186 */ - 0x0000, /* R187 */ - 0x0000, /* R188 */ - 0x0000, /* R189 */ - 0x0000, /* R190 */ - 0x0000, /* R191 */ - 0x0000, /* R192 */ - 0x0000, /* R193 */ - 0x0000, /* R194 */ - 0x0000, /* R195 */ - 0x0000, /* R196 */ - 0x0000, /* R197 */ - 0x0000, /* R198 */ - 0x0000, /* R199 */ - 0x0000, /* R200 */ - 0x0000, /* R201 */ - 0x0000, /* R202 */ - 0x0000, /* R203 */ - 0x0000, /* R204 */ - 0x0000, /* R205 */ - 0x0000, /* R206 */ - 0x0000, /* R207 */ - 0x0000, /* R208 */ - 0x0000, /* R209 */ - 0x0000, /* R210 */ - 0x0000, /* R211 */ - 0x0000, /* R212 */ - 0x0000, /* R213 */ - 0x0000, /* R214 */ - 0x0000, /* R215 */ - 0x0000, /* R216 */ - 0x0000, /* R217 */ - 0x0000, /* R218 */ - 0x0000, /* R219 */ - 0x0000, /* R220 */ - 0x0000, /* R221 */ - 0x0000, /* R222 */ - 0x0000, /* R223 */ - 0x0000, /* R224 */ - 0x0000, /* R225 */ - 0x0000, /* R226 */ - 0x0000, /* R227 */ - 0x0000, /* R228 */ - 0x0000, /* R229 */ - 0x0000, /* R230 */ - 0x0000, /* R231 */ - 0x0000, /* R232 */ - 0x0000, /* R233 */ - 0x0000, /* R234 */ - 0x0000, /* R235 */ - 0x0000, /* R236 */ - 0x0000, /* R237 */ - 0x0000, /* R238 */ - 0x0000, /* R239 */ - 0x0000, /* R240 */ - 0x0000, /* R241 */ - 0x0000, /* R242 */ - 0x0000, /* R243 */ - 0x0000, /* R244 */ - 0x0000, /* R245 */ - 0x0000, /* R246 */ - 0x0000, /* R247 */ - 0x0000, /* R248 */ - 0x0000, /* R249 */ - 0x0000, /* R250 */ - 0x0000, /* R251 */ - 0x0005, /* R252 - General test 1 */ - 0x0000, /* R253 */ - 0x0000, /* R254 */ - 0x0000, /* R255 */ - 0x0000, /* R256 - DF1 */ - 0x0000, /* R257 - DF2 */ - 0x0000, /* R258 - DF3 */ - 0x0000, /* R259 - DF4 */ - 0x0000, /* R260 - DF5 */ - 0x0000, /* R261 - DF6 */ - 0x0000, /* R262 - DF7 */ - 0x0000, /* R263 */ - 0x0000, /* R264 - LHPF1 */ - 0x0000, /* R265 - LHPF2 */ - 0x0000, /* R266 */ - 0x0000, /* R267 */ - 0x0000, /* R268 - THREED1 */ - 0x0000, /* R269 - THREED2 */ - 0x0000, /* R270 - THREED3 */ - 0x0000, /* R271 - THREED4 */ - 0x0000, /* R272 */ - 0x0000, /* R273 */ - 0x0000, /* R274 */ - 0x0000, /* R275 */ - 0x000C, /* R276 - DRC 1 */ - 0x0925, /* R277 - DRC 2 */ - 0x0000, /* R278 - DRC 3 */ - 0x0000, /* R279 - DRC 4 */ - 0x0000, /* R280 - DRC 5 */ - 0x0000, /* R281 */ - 0x0000, /* R282 */ - 0x0000, /* R283 */ - 0x0000, /* R284 */ - 0x0000, /* R285 - Tloopback */ - 0x0000, /* R286 */ - 0x0000, /* R287 */ - 0x0000, /* R288 */ - 0x0000, /* R289 */ - 0x0000, /* R290 */ - 0x0000, /* R291 */ - 0x0000, /* R292 */ - 0x0000, /* R293 */ - 0x0000, /* R294 */ - 0x0000, /* R295 */ - 0x0000, /* R296 */ - 0x0000, /* R297 */ - 0x0000, /* R298 */ - 0x0000, /* R299 */ - 0x0000, /* R300 */ - 0x0000, /* R301 */ - 0x0000, /* R302 */ - 0x0000, /* R303 */ - 0x0000, /* R304 */ - 0x0000, /* R305 */ - 0x0000, /* R306 */ - 0x0000, /* R307 */ - 0x0000, /* R308 */ - 0x0000, /* R309 */ - 0x0000, /* R310 */ - 0x0000, /* R311 */ - 0x0000, /* R312 */ - 0x0000, /* R313 */ - 0x0000, /* R314 */ - 0x0000, /* R315 */ - 0x0000, /* R316 */ - 0x0000, /* R317 */ - 0x0000, /* R318 */ - 0x0000, /* R319 */ - 0x0000, /* R320 */ - 0x0000, /* R321 */ - 0x0000, /* R322 */ - 0x0000, /* R323 */ - 0x0000, /* R324 */ - 0x0000, /* R325 */ - 0x0000, /* R326 */ - 0x0000, /* R327 */ - 0x0000, /* R328 */ - 0x0000, /* R329 */ - 0x0000, /* R330 */ - 0x0000, /* R331 */ - 0x0000, /* R332 */ - 0x0000, /* R333 */ - 0x0000, /* R334 */ - 0x0004, /* R335 - EQ1 */ - 0x6318, /* R336 - EQ2 */ - 0x6300, /* R337 - EQ3 */ - 0x0FCA, /* R338 - EQ4 */ - 0x0400, /* R339 - EQ5 */ - 0x00D8, /* R340 - EQ6 */ - 0x1EB5, /* R341 - EQ7 */ - 0xF145, /* R342 - EQ8 */ - 0x0B75, /* R343 - EQ9 */ - 0x01C5, /* R344 - EQ10 */ - 0x1C58, /* R345 - EQ11 */ - 0xF373, /* R346 - EQ12 */ - 0x0A54, /* R347 - EQ13 */ - 0x0558, /* R348 - EQ14 */ - 0x168E, /* R349 - EQ15 */ - 0xF829, /* R350 - EQ16 */ - 0x07AD, /* R351 - EQ17 */ - 0x1103, /* R352 - EQ18 */ - 0x0564, /* R353 - EQ19 */ - 0x0559, /* R354 - EQ20 */ - 0x4000, /* R355 - EQ21 */ - 0x6318, /* R356 - EQ22 */ - 0x6300, /* R357 - EQ23 */ - 0x0FCA, /* R358 - EQ24 */ - 0x0400, /* R359 - EQ25 */ - 0x00D8, /* R360 - EQ26 */ - 0x1EB5, /* R361 - EQ27 */ - 0xF145, /* R362 - EQ28 */ - 0x0B75, /* R363 - EQ29 */ - 0x01C5, /* R364 - EQ30 */ - 0x1C58, /* R365 - EQ31 */ - 0xF373, /* R366 - EQ32 */ - 0x0A54, /* R367 - EQ33 */ - 0x0558, /* R368 - EQ34 */ - 0x168E, /* R369 - EQ35 */ - 0xF829, /* R370 - EQ36 */ - 0x07AD, /* R371 - EQ37 */ - 0x1103, /* R372 - EQ38 */ - 0x0564, /* R373 - EQ39 */ - 0x0559, /* R374 - EQ40 */ - 0x4000, /* R375 - EQ41 */ - 0x0000, /* R376 */ - 0x0000, /* R377 */ - 0x0000, /* R378 */ - 0x0000, /* R379 */ - 0x0000, /* R380 */ - 0x0000, /* R381 */ - 0x0000, /* R382 */ - 0x0000, /* R383 */ - 0x0000, /* R384 */ - 0x0000, /* R385 */ - 0x0000, /* R386 */ - 0x0000, /* R387 */ - 0x0000, /* R388 */ - 0x0000, /* R389 */ - 0x0000, /* R390 */ - 0x0000, /* R391 */ - 0x0000, /* R392 */ - 0x0000, /* R393 */ - 0x0000, /* R394 */ - 0x0000, /* R395 */ - 0x0000, /* R396 */ - 0x0000, /* R397 */ - 0x0000, /* R398 */ - 0x0000, /* R399 */ - 0x0000, /* R400 */ - 0x0000, /* R401 */ - 0x0000, /* R402 */ - 0x0000, /* R403 */ - 0x0000, /* R404 */ - 0x0000, /* R405 */ - 0x0000, /* R406 */ - 0x0000, /* R407 */ - 0x0000, /* R408 */ - 0x0000, /* R409 */ - 0x0000, /* R410 */ - 0x0000, /* R411 */ - 0x0000, /* R412 */ - 0x0000, /* R413 */ - 0x0000, /* R414 */ - 0x0000, /* R415 */ - 0x0000, /* R416 */ - 0x0000, /* R417 */ - 0x0000, /* R418 */ - 0x0000, /* R419 */ - 0x0000, /* R420 */ - 0x0000, /* R421 */ - 0x0000, /* R422 */ - 0x0000, /* R423 */ - 0x0000, /* R424 */ - 0x0000, /* R425 */ - 0x0000, /* R426 */ - 0x0000, /* R427 */ - 0x0000, /* R428 */ - 0x0000, /* R429 */ - 0x0000, /* R430 */ - 0x0000, /* R431 */ - 0x0000, /* R432 */ - 0x0000, /* R433 */ - 0x0000, /* R434 */ - 0x0000, /* R435 */ - 0x0000, /* R436 */ - 0x0000, /* R437 */ - 0x0000, /* R438 */ - 0x0000, /* R439 */ - 0x0000, /* R440 */ - 0x0000, /* R441 */ - 0x0000, /* R442 */ - 0x0000, /* R443 */ - 0x0000, /* R444 */ - 0x0000, /* R445 */ - 0x0000, /* R446 */ - 0x0000, /* R447 */ - 0x0000, /* R448 */ - 0x0000, /* R449 */ - 0x0000, /* R450 */ - 0x0000, /* R451 */ - 0x0000, /* R452 */ - 0x0000, /* R453 */ - 0x0000, /* R454 */ - 0x0000, /* R455 */ - 0x0000, /* R456 */ - 0x0000, /* R457 */ - 0x0000, /* R458 */ - 0x0000, /* R459 */ - 0x0000, /* R460 */ - 0x0000, /* R461 */ - 0x0000, /* R462 */ - 0x0000, /* R463 */ - 0x0000, /* R464 */ - 0x0000, /* R465 */ - 0x0000, /* R466 */ - 0x0000, /* R467 */ - 0x0000, /* R468 */ - 0x0000, /* R469 */ - 0x0000, /* R470 */ - 0x0000, /* R471 */ - 0x0000, /* R472 */ - 0x0000, /* R473 */ - 0x0000, /* R474 */ - 0x0000, /* R475 */ - 0x0000, /* R476 */ - 0x0000, /* R477 */ - 0x0000, /* R478 */ - 0x0000, /* R479 */ - 0x0000, /* R480 */ - 0x0000, /* R481 */ - 0x0000, /* R482 */ - 0x0000, /* R483 */ - 0x0000, /* R484 */ - 0x0000, /* R485 */ - 0x0000, /* R486 */ - 0x0000, /* R487 */ - 0x0000, /* R488 */ - 0x0000, /* R489 */ - 0x0000, /* R490 */ - 0x0000, /* R491 */ - 0x0000, /* R492 */ - 0x0000, /* R493 */ - 0x0000, /* R494 */ - 0x0000, /* R495 */ - 0x0000, /* R496 */ - 0x0000, /* R497 */ - 0x0000, /* R498 */ - 0x0000, /* R499 */ - 0x0000, /* R500 */ - 0x0000, /* R501 */ - 0x0000, /* R502 */ - 0x0000, /* R503 */ - 0x0000, /* R504 */ - 0x0000, /* R505 */ - 0x0000, /* R506 */ - 0x0000, /* R507 */ - 0x0000, /* R508 */ - 0x0000, /* R509 */ - 0x0000, /* R510 */ - 0x0000, /* R511 */ - 0x0000, /* R512 */ - 0x0000, /* R513 - GPIO 2 */ - 0x0000, /* R514 - GPIO 3 */ - 0x0000, /* R515 */ - 0x8100, /* R516 - GPIO 5 */ - 0x8100, /* R517 - GPIO 6 */ - 0x0000, /* R518 */ - 0x0000, /* R519 */ - 0x0000, /* R520 */ - 0x0000, /* R521 */ - 0x0000, /* R522 */ - 0x0000, /* R523 */ - 0x0000, /* R524 */ - 0x0000, /* R525 */ - 0x0000, /* R526 */ - 0x0000, /* R527 */ - 0x0000, /* R528 */ - 0x0000, /* R529 */ - 0x0000, /* R530 */ - 0x0000, /* R531 */ - 0x0000, /* R532 */ - 0x0000, /* R533 */ - 0x0000, /* R534 */ - 0x0000, /* R535 */ - 0x0000, /* R536 */ - 0x0000, /* R537 */ - 0x0000, /* R538 */ - 0x0000, /* R539 */ - 0x0000, /* R540 */ - 0x0000, /* R541 */ - 0x0000, /* R542 */ - 0x0000, /* R543 */ - 0x0000, /* R544 */ - 0x0000, /* R545 */ - 0x0000, /* R546 */ - 0x0000, /* R547 */ - 0x0000, /* R548 */ - 0x0000, /* R549 */ - 0x0000, /* R550 */ - 0x0000, /* R551 */ - 0x0000, /* R552 */ - 0x0000, /* R553 */ - 0x0000, /* R554 */ - 0x0000, /* R555 */ - 0x0000, /* R556 */ - 0x0000, /* R557 */ - 0x0000, /* R558 */ - 0x0000, /* R559 */ - 0x0000, /* R560 - Interrupt Status 1 */ - 0x0000, /* R561 - Interrupt Status 2 */ - 0x0000, /* R562 */ - 0x0000, /* R563 */ - 0x0000, /* R564 */ - 0x0000, /* R565 */ - 0x0000, /* R566 */ - 0x0000, /* R567 */ - 0x0030, /* R568 - Interrupt Status 1 Mask */ - 0xFFED, /* R569 - Interrupt Status 2 Mask */ - 0x0000, /* R570 */ - 0x0000, /* R571 */ - 0x0000, /* R572 */ - 0x0000, /* R573 */ - 0x0000, /* R574 */ - 0x0000, /* R575 */ - 0x0000, /* R576 - Interrupt Control */ - 0x0000, /* R577 */ - 0x0000, /* R578 */ - 0x0000, /* R579 */ - 0x0000, /* R580 */ - 0x0000, /* R581 */ - 0x0000, /* R582 */ - 0x0000, /* R583 */ - 0x002D, /* R584 - IRQ Debounce */ - 0x0000, /* R585 */ - 0x0000, /* R586 - MICINT Source Pol */ - 0x0000, /* R587 */ - 0x0000, /* R588 */ - 0x0000, /* R589 */ - 0x0000, /* R590 */ - 0x0000, /* R591 */ - 0x0000, /* R592 */ - 0x0000, /* R593 */ - 0x0000, /* R594 */ - 0x0000, /* R595 */ - 0x0000, /* R596 */ - 0x0000, /* R597 */ - 0x0000, /* R598 */ - 0x0000, /* R599 */ - 0x0000, /* R600 */ - 0x0000, /* R601 */ - 0x0000, /* R602 */ - 0x0000, /* R603 */ - 0x0000, /* R604 */ - 0x0000, /* R605 */ - 0x0000, /* R606 */ - 0x0000, /* R607 */ - 0x0000, /* R608 */ - 0x0000, /* R609 */ - 0x0000, /* R610 */ - 0x0000, /* R611 */ - 0x0000, /* R612 */ - 0x0000, /* R613 */ - 0x0000, /* R614 */ - 0x0000, /* R615 */ - 0x0000, /* R616 */ - 0x0000, /* R617 */ - 0x0000, /* R618 */ - 0x0000, /* R619 */ - 0x0000, /* R620 */ - 0x0000, /* R621 */ - 0x0000, /* R622 */ - 0x0000, /* R623 */ - 0x0000, /* R624 */ - 0x0000, /* R625 */ - 0x0000, /* R626 */ - 0x0000, /* R627 */ - 0x0000, /* R628 */ - 0x0000, /* R629 */ - 0x0000, /* R630 */ - 0x0000, /* R631 */ - 0x0000, /* R632 */ - 0x0000, /* R633 */ - 0x0000, /* R634 */ - 0x0000, /* R635 */ - 0x0000, /* R636 */ - 0x0000, /* R637 */ - 0x0000, /* R638 */ - 0x0000, /* R639 */ - 0x0000, /* R640 */ - 0x0000, /* R641 */ - 0x0000, /* R642 */ - 0x0000, /* R643 */ - 0x0000, /* R644 */ - 0x0000, /* R645 */ - 0x0000, /* R646 */ - 0x0000, /* R647 */ - 0x0000, /* R648 */ - 0x0000, /* R649 */ - 0x0000, /* R650 */ - 0x0000, /* R651 */ - 0x0000, /* R652 */ - 0x0000, /* R653 */ - 0x0000, /* R654 */ - 0x0000, /* R655 */ - 0x0000, /* R656 */ - 0x0000, /* R657 */ - 0x0000, /* R658 */ - 0x0000, /* R659 */ - 0x0000, /* R660 */ - 0x0000, /* R661 */ - 0x0000, /* R662 */ - 0x0000, /* R663 */ - 0x0000, /* R664 */ - 0x0000, /* R665 */ - 0x0000, /* R666 */ - 0x0000, /* R667 */ - 0x0000, /* R668 */ - 0x0000, /* R669 */ - 0x0000, /* R670 */ - 0x0000, /* R671 */ - 0x0000, /* R672 */ - 0x0000, /* R673 */ - 0x0000, /* R674 */ - 0x0000, /* R675 */ - 0x0000, /* R676 */ - 0x0000, /* R677 */ - 0x0000, /* R678 */ - 0x0000, /* R679 */ - 0x0000, /* R680 */ - 0x0000, /* R681 */ - 0x0000, /* R682 */ - 0x0000, /* R683 */ - 0x0000, /* R684 */ - 0x0000, /* R685 */ - 0x0000, /* R686 */ - 0x0000, /* R687 */ - 0x0000, /* R688 */ - 0x0000, /* R689 */ - 0x0000, /* R690 */ - 0x0000, /* R691 */ - 0x0000, /* R692 */ - 0x0000, /* R693 */ - 0x0000, /* R694 */ - 0x0000, /* R695 */ - 0x0000, /* R696 */ - 0x0000, /* R697 */ - 0x0000, /* R698 */ - 0x0000, /* R699 */ - 0x0000, /* R700 */ - 0x0000, /* R701 */ - 0x0000, /* R702 */ - 0x0000, /* R703 */ - 0x0000, /* R704 */ - 0x0000, /* R705 */ - 0x0000, /* R706 */ - 0x0000, /* R707 */ - 0x0000, /* R708 */ - 0x0000, /* R709 */ - 0x0000, /* R710 */ - 0x0000, /* R711 */ - 0x0000, /* R712 */ - 0x0000, /* R713 */ - 0x0000, /* R714 */ - 0x0000, /* R715 */ - 0x0000, /* R716 */ - 0x0000, /* R717 */ - 0x0000, /* R718 */ - 0x0000, /* R719 */ - 0x0000, /* R720 */ - 0x0000, /* R721 */ - 0x0000, /* R722 */ - 0x0000, /* R723 */ - 0x0000, /* R724 */ - 0x0000, /* R725 */ - 0x0000, /* R726 */ - 0x0000, /* R727 */ - 0x0000, /* R728 */ - 0x0000, /* R729 */ - 0x0000, /* R730 */ - 0x0000, /* R731 */ - 0x0000, /* R732 */ - 0x0000, /* R733 */ - 0x0000, /* R734 */ - 0x0000, /* R735 */ - 0x0000, /* R736 */ - 0x0000, /* R737 */ - 0x0000, /* R738 */ - 0x0000, /* R739 */ - 0x0000, /* R740 */ - 0x0000, /* R741 */ - 0x0000, /* R742 */ - 0x0000, /* R743 */ - 0x0000, /* R744 */ - 0x0000, /* R745 */ - 0x0000, /* R746 */ - 0x0000, /* R747 */ - 0x0000, /* R748 */ - 0x0000, /* R749 */ - 0x0000, /* R750 */ - 0x0000, /* R751 */ - 0x0000, /* R752 */ - 0x0000, /* R753 */ - 0x0000, /* R754 */ - 0x0000, /* R755 */ - 0x0000, /* R756 */ - 0x0000, /* R757 */ - 0x0000, /* R758 */ - 0x0000, /* R759 */ - 0x0000, /* R760 */ - 0x0000, /* R761 */ - 0x0000, /* R762 */ - 0x0000, /* R763 */ - 0x0000, /* R764 */ - 0x0000, /* R765 */ - 0x0000, /* R766 */ - 0x0000, /* R767 */ - 0x1C00, /* R768 - DSP2 Power Management */ - 0x0000, /* R769 */ - 0x0000, /* R770 */ - 0x0000, /* R771 */ - 0x0000, /* R772 */ - 0x0000, /* R773 */ - 0x0000, /* R774 */ - 0x0000, /* R775 */ - 0x0000, /* R776 */ - 0x0000, /* R777 */ - 0x0000, /* R778 */ - 0x0000, /* R779 */ - 0x0000, /* R780 */ - 0x0000, /* R781 */ - 0x0000, /* R782 */ - 0x0000, /* R783 */ - 0x0000, /* R784 */ - 0x0000, /* R785 */ - 0x0000, /* R786 */ - 0x0000, /* R787 */ - 0x0000, /* R788 */ - 0x0000, /* R789 */ - 0x0000, /* R790 */ - 0x0000, /* R791 */ - 0x0000, /* R792 */ - 0x0000, /* R793 */ - 0x0000, /* R794 */ - 0x0000, /* R795 */ - 0x0000, /* R796 */ - 0x0000, /* R797 */ - 0x0000, /* R798 */ - 0x0000, /* R799 */ - 0x0000, /* R800 */ - 0x0000, /* R801 */ - 0x0000, /* R802 */ - 0x0000, /* R803 */ - 0x0000, /* R804 */ - 0x0000, /* R805 */ - 0x0000, /* R806 */ - 0x0000, /* R807 */ - 0x0000, /* R808 */ - 0x0000, /* R809 */ - 0x0000, /* R810 */ - 0x0000, /* R811 */ - 0x0000, /* R812 */ - 0x0000, /* R813 */ - 0x0000, /* R814 */ - 0x0000, /* R815 */ - 0x0000, /* R816 */ - 0x0000, /* R817 */ - 0x0000, /* R818 */ - 0x0000, /* R819 */ - 0x0000, /* R820 */ - 0x0000, /* R821 */ - 0x0000, /* R822 */ - 0x0000, /* R823 */ - 0x0000, /* R824 */ - 0x0000, /* R825 */ - 0x0000, /* R826 */ - 0x0000, /* R827 */ - 0x0000, /* R828 */ - 0x0000, /* R829 */ - 0x0000, /* R830 */ - 0x0000, /* R831 */ - 0x0000, /* R832 */ - 0x0000, /* R833 */ - 0x0000, /* R834 */ - 0x0000, /* R835 */ - 0x0000, /* R836 */ - 0x0000, /* R837 */ - 0x0000, /* R838 */ - 0x0000, /* R839 */ - 0x0000, /* R840 */ - 0x0000, /* R841 */ - 0x0000, /* R842 */ - 0x0000, /* R843 */ - 0x0000, /* R844 */ - 0x0000, /* R845 */ - 0x0000, /* R846 */ - 0x0000, /* R847 */ - 0x0000, /* R848 */ - 0x0000, /* R849 */ - 0x0000, /* R850 */ - 0x0000, /* R851 */ - 0x0000, /* R852 */ - 0x0000, /* R853 */ - 0x0000, /* R854 */ - 0x0000, /* R855 */ - 0x0000, /* R856 */ - 0x0000, /* R857 */ - 0x0000, /* R858 */ - 0x0000, /* R859 */ - 0x0000, /* R860 */ - 0x0000, /* R861 */ - 0x0000, /* R862 */ - 0x0000, /* R863 */ - 0x0000, /* R864 */ - 0x0000, /* R865 */ - 0x0000, /* R866 */ - 0x0000, /* R867 */ - 0x0000, /* R868 */ - 0x0000, /* R869 */ - 0x0000, /* R870 */ - 0x0000, /* R871 */ - 0x0000, /* R872 */ - 0x0000, /* R873 */ - 0x0000, /* R874 */ - 0x0000, /* R875 */ - 0x0000, /* R876 */ - 0x0000, /* R877 */ - 0x0000, /* R878 */ - 0x0000, /* R879 */ - 0x0000, /* R880 */ - 0x0000, /* R881 */ - 0x0000, /* R882 */ - 0x0000, /* R883 */ - 0x0000, /* R884 */ - 0x0000, /* R885 */ - 0x0000, /* R886 */ - 0x0000, /* R887 */ - 0x0000, /* R888 */ - 0x0000, /* R889 */ - 0x0000, /* R890 */ - 0x0000, /* R891 */ - 0x0000, /* R892 */ - 0x0000, /* R893 */ - 0x0000, /* R894 */ - 0x0000, /* R895 */ - 0x0000, /* R896 */ - 0x0000, /* R897 */ - 0x0000, /* R898 */ - 0x0000, /* R899 */ - 0x0000, /* R900 */ - 0x0000, /* R901 */ - 0x0000, /* R902 */ - 0x0000, /* R903 */ - 0x0000, /* R904 */ - 0x0000, /* R905 */ - 0x0000, /* R906 */ - 0x0000, /* R907 */ - 0x0000, /* R908 */ - 0x0000, /* R909 */ - 0x0000, /* R910 */ - 0x0000, /* R911 */ - 0x0000, /* R912 */ - 0x0000, /* R913 */ - 0x0000, /* R914 */ - 0x0000, /* R915 */ - 0x0000, /* R916 */ - 0x0000, /* R917 */ - 0x0000, /* R918 */ - 0x0000, /* R919 */ - 0x0000, /* R920 */ - 0x0000, /* R921 */ - 0x0000, /* R922 */ - 0x0000, /* R923 */ - 0x0000, /* R924 */ - 0x0000, /* R925 */ - 0x0000, /* R926 */ - 0x0000, /* R927 */ - 0x0000, /* R928 */ - 0x0000, /* R929 */ - 0x0000, /* R930 */ - 0x0000, /* R931 */ - 0x0000, /* R932 */ - 0x0000, /* R933 */ - 0x0000, /* R934 */ - 0x0000, /* R935 */ - 0x0000, /* R936 */ - 0x0000, /* R937 */ - 0x0000, /* R938 */ - 0x0000, /* R939 */ - 0x0000, /* R940 */ - 0x0000, /* R941 */ - 0x0000, /* R942 */ - 0x0000, /* R943 */ - 0x0000, /* R944 */ - 0x0000, /* R945 */ - 0x0000, /* R946 */ - 0x0000, /* R947 */ - 0x0000, /* R948 */ - 0x0000, /* R949 */ - 0x0000, /* R950 */ - 0x0000, /* R951 */ - 0x0000, /* R952 */ - 0x0000, /* R953 */ - 0x0000, /* R954 */ - 0x0000, /* R955 */ - 0x0000, /* R956 */ - 0x0000, /* R957 */ - 0x0000, /* R958 */ - 0x0000, /* R959 */ - 0x0000, /* R960 */ - 0x0000, /* R961 */ - 0x0000, /* R962 */ - 0x0000, /* R963 */ - 0x0000, /* R964 */ - 0x0000, /* R965 */ - 0x0000, /* R966 */ - 0x0000, /* R967 */ - 0x0000, /* R968 */ - 0x0000, /* R969 */ - 0x0000, /* R970 */ - 0x0000, /* R971 */ - 0x0000, /* R972 */ - 0x0000, /* R973 */ - 0x0000, /* R974 */ - 0x0000, /* R975 */ - 0x0000, /* R976 */ - 0x0000, /* R977 */ - 0x0000, /* R978 */ - 0x0000, /* R979 */ - 0x0000, /* R980 */ - 0x0000, /* R981 */ - 0x0000, /* R982 */ - 0x0000, /* R983 */ - 0x0000, /* R984 */ - 0x0000, /* R985 */ - 0x0000, /* R986 */ - 0x0000, /* R987 */ - 0x0000, /* R988 */ - 0x0000, /* R989 */ - 0x0000, /* R990 */ - 0x0000, /* R991 */ - 0x0000, /* R992 */ - 0x0000, /* R993 */ - 0x0000, /* R994 */ - 0x0000, /* R995 */ - 0x0000, /* R996 */ - 0x0000, /* R997 */ - 0x0000, /* R998 */ - 0x0000, /* R999 */ - 0x0000, /* R1000 */ - 0x0000, /* R1001 */ - 0x0000, /* R1002 */ - 0x0000, /* R1003 */ - 0x0000, /* R1004 */ - 0x0000, /* R1005 */ - 0x0000, /* R1006 */ - 0x0000, /* R1007 */ - 0x0000, /* R1008 */ - 0x0000, /* R1009 */ - 0x0000, /* R1010 */ - 0x0000, /* R1011 */ - 0x0000, /* R1012 */ - 0x0000, /* R1013 */ - 0x0000, /* R1014 */ - 0x0000, /* R1015 */ - 0x0000, /* R1016 */ - 0x0000, /* R1017 */ - 0x0000, /* R1018 */ - 0x0000, /* R1019 */ - 0x0000, /* R1020 */ - 0x0000, /* R1021 */ - 0x0000, /* R1022 */ - 0x0000, /* R1023 */ - 0x0000, /* R1024 */ - 0x0000, /* R1025 */ - 0x0000, /* R1026 */ - 0x0000, /* R1027 */ - 0x0000, /* R1028 */ - 0x0000, /* R1029 */ - 0x0000, /* R1030 */ - 0x0000, /* R1031 */ - 0x0000, /* R1032 */ - 0x0000, /* R1033 */ - 0x0000, /* R1034 */ - 0x0000, /* R1035 */ - 0x0000, /* R1036 */ - 0x0000, /* R1037 - DSP2_ExecControl */ - 0x0000, /* R1038 */ - 0x0000, /* R1039 */ - 0x0000, /* R1040 */ - 0x0000, /* R1041 */ - 0x0000, /* R1042 */ - 0x0000, /* R1043 */ - 0x0000, /* R1044 */ - 0x0000, /* R1045 */ - 0x0000, /* R1046 */ - 0x0000, /* R1047 */ - 0x0000, /* R1048 */ - 0x0000, /* R1049 */ - 0x0000, /* R1050 */ - 0x0000, /* R1051 */ - 0x0000, /* R1052 */ - 0x0000, /* R1053 */ - 0x0000, /* R1054 */ - 0x0000, /* R1055 */ - 0x0000, /* R1056 */ - 0x0000, /* R1057 */ - 0x0000, /* R1058 */ - 0x0000, /* R1059 */ - 0x0000, /* R1060 */ - 0x0000, /* R1061 */ - 0x0000, /* R1062 */ - 0x0000, /* R1063 */ - 0x0000, /* R1064 */ - 0x0000, /* R1065 */ - 0x0000, /* R1066 */ - 0x0000, /* R1067 */ - 0x0000, /* R1068 */ - 0x0000, /* R1069 */ - 0x0000, /* R1070 */ - 0x0000, /* R1071 */ - 0x0000, /* R1072 */ - 0x0000, /* R1073 */ - 0x0000, /* R1074 */ - 0x0000, /* R1075 */ - 0x0000, /* R1076 */ - 0x0000, /* R1077 */ - 0x0000, /* R1078 */ - 0x0000, /* R1079 */ - 0x0000, /* R1080 */ - 0x0000, /* R1081 */ - 0x0000, /* R1082 */ - 0x0000, /* R1083 */ - 0x0000, /* R1084 */ - 0x0000, /* R1085 */ - 0x0000, /* R1086 */ - 0x0000, /* R1087 */ - 0x0000, /* R1088 */ - 0x0000, /* R1089 */ - 0x0000, /* R1090 */ - 0x0000, /* R1091 */ - 0x0000, /* R1092 */ - 0x0000, /* R1093 */ - 0x0000, /* R1094 */ - 0x0000, /* R1095 */ - 0x0000, /* R1096 */ - 0x0000, /* R1097 */ - 0x0000, /* R1098 */ - 0x0000, /* R1099 */ - 0x0000, /* R1100 */ - 0x0000, /* R1101 */ - 0x0000, /* R1102 */ - 0x0000, /* R1103 */ - 0x0000, /* R1104 */ - 0x0000, /* R1105 */ - 0x0000, /* R1106 */ - 0x0000, /* R1107 */ - 0x0000, /* R1108 */ - 0x0000, /* R1109 */ - 0x0000, /* R1110 */ - 0x0000, /* R1111 */ - 0x0000, /* R1112 */ - 0x0000, /* R1113 */ - 0x0000, /* R1114 */ - 0x0000, /* R1115 */ - 0x0000, /* R1116 */ - 0x0000, /* R1117 */ - 0x0000, /* R1118 */ - 0x0000, /* R1119 */ - 0x0000, /* R1120 */ - 0x0000, /* R1121 */ - 0x0000, /* R1122 */ - 0x0000, /* R1123 */ - 0x0000, /* R1124 */ - 0x0000, /* R1125 */ - 0x0000, /* R1126 */ - 0x0000, /* R1127 */ - 0x0000, /* R1128 */ - 0x0000, /* R1129 */ - 0x0000, /* R1130 */ - 0x0000, /* R1131 */ - 0x0000, /* R1132 */ - 0x0000, /* R1133 */ - 0x0000, /* R1134 */ - 0x0000, /* R1135 */ - 0x0000, /* R1136 */ - 0x0000, /* R1137 */ - 0x0000, /* R1138 */ - 0x0000, /* R1139 */ - 0x0000, /* R1140 */ - 0x0000, /* R1141 */ - 0x0000, /* R1142 */ - 0x0000, /* R1143 */ - 0x0000, /* R1144 */ - 0x0000, /* R1145 */ - 0x0000, /* R1146 */ - 0x0000, /* R1147 */ - 0x0000, /* R1148 */ - 0x0000, /* R1149 */ - 0x0000, /* R1150 */ - 0x0000, /* R1151 */ - 0x0000, /* R1152 */ - 0x0000, /* R1153 */ - 0x0000, /* R1154 */ - 0x0000, /* R1155 */ - 0x0000, /* R1156 */ - 0x0000, /* R1157 */ - 0x0000, /* R1158 */ - 0x0000, /* R1159 */ - 0x0000, /* R1160 */ - 0x0000, /* R1161 */ - 0x0000, /* R1162 */ - 0x0000, /* R1163 */ - 0x0000, /* R1164 */ - 0x0000, /* R1165 */ - 0x0000, /* R1166 */ - 0x0000, /* R1167 */ - 0x0000, /* R1168 */ - 0x0000, /* R1169 */ - 0x0000, /* R1170 */ - 0x0000, /* R1171 */ - 0x0000, /* R1172 */ - 0x0000, /* R1173 */ - 0x0000, /* R1174 */ - 0x0000, /* R1175 */ - 0x0000, /* R1176 */ - 0x0000, /* R1177 */ - 0x0000, /* R1178 */ - 0x0000, /* R1179 */ - 0x0000, /* R1180 */ - 0x0000, /* R1181 */ - 0x0000, /* R1182 */ - 0x0000, /* R1183 */ - 0x0000, /* R1184 */ - 0x0000, /* R1185 */ - 0x0000, /* R1186 */ - 0x0000, /* R1187 */ - 0x0000, /* R1188 */ - 0x0000, /* R1189 */ - 0x0000, /* R1190 */ - 0x0000, /* R1191 */ - 0x0000, /* R1192 */ - 0x0000, /* R1193 */ - 0x0000, /* R1194 */ - 0x0000, /* R1195 */ - 0x0000, /* R1196 */ - 0x0000, /* R1197 */ - 0x0000, /* R1198 */ - 0x0000, /* R1199 */ - 0x0000, /* R1200 */ - 0x0000, /* R1201 */ - 0x0000, /* R1202 */ - 0x0000, /* R1203 */ - 0x0000, /* R1204 */ - 0x0000, /* R1205 */ - 0x0000, /* R1206 */ - 0x0000, /* R1207 */ - 0x0000, /* R1208 */ - 0x0000, /* R1209 */ - 0x0000, /* R1210 */ - 0x0000, /* R1211 */ - 0x0000, /* R1212 */ - 0x0000, /* R1213 */ - 0x0000, /* R1214 */ - 0x0000, /* R1215 */ - 0x0000, /* R1216 */ - 0x0000, /* R1217 */ - 0x0000, /* R1218 */ - 0x0000, /* R1219 */ - 0x0000, /* R1220 */ - 0x0000, /* R1221 */ - 0x0000, /* R1222 */ - 0x0000, /* R1223 */ - 0x0000, /* R1224 */ - 0x0000, /* R1225 */ - 0x0000, /* R1226 */ - 0x0000, /* R1227 */ - 0x0000, /* R1228 */ - 0x0000, /* R1229 */ - 0x0000, /* R1230 */ - 0x0000, /* R1231 */ - 0x0000, /* R1232 */ - 0x0000, /* R1233 */ - 0x0000, /* R1234 */ - 0x0000, /* R1235 */ - 0x0000, /* R1236 */ - 0x0000, /* R1237 */ - 0x0000, /* R1238 */ - 0x0000, /* R1239 */ - 0x0000, /* R1240 */ - 0x0000, /* R1241 */ - 0x0000, /* R1242 */ - 0x0000, /* R1243 */ - 0x0000, /* R1244 */ - 0x0000, /* R1245 */ - 0x0000, /* R1246 */ - 0x0000, /* R1247 */ - 0x0000, /* R1248 */ - 0x0000, /* R1249 */ - 0x0000, /* R1250 */ - 0x0000, /* R1251 */ - 0x0000, /* R1252 */ - 0x0000, /* R1253 */ - 0x0000, /* R1254 */ - 0x0000, /* R1255 */ - 0x0000, /* R1256 */ - 0x0000, /* R1257 */ - 0x0000, /* R1258 */ - 0x0000, /* R1259 */ - 0x0000, /* R1260 */ - 0x0000, /* R1261 */ - 0x0000, /* R1262 */ - 0x0000, /* R1263 */ - 0x0000, /* R1264 */ - 0x0000, /* R1265 */ - 0x0000, /* R1266 */ - 0x0000, /* R1267 */ - 0x0000, /* R1268 */ - 0x0000, /* R1269 */ - 0x0000, /* R1270 */ - 0x0000, /* R1271 */ - 0x0000, /* R1272 */ - 0x0000, /* R1273 */ - 0x0000, /* R1274 */ - 0x0000, /* R1275 */ - 0x0000, /* R1276 */ - 0x0000, /* R1277 */ - 0x0000, /* R1278 */ - 0x0000, /* R1279 */ - 0x0000, /* R1280 */ - 0x0000, /* R1281 */ - 0x0000, /* R1282 */ - 0x0000, /* R1283 */ - 0x0000, /* R1284 */ - 0x0000, /* R1285 */ - 0x0000, /* R1286 */ - 0x0000, /* R1287 */ - 0x0000, /* R1288 */ - 0x0000, /* R1289 */ - 0x0000, /* R1290 */ - 0x0000, /* R1291 */ - 0x0000, /* R1292 */ - 0x0000, /* R1293 */ - 0x0000, /* R1294 */ - 0x0000, /* R1295 */ - 0x0000, /* R1296 */ - 0x0000, /* R1297 */ - 0x0000, /* R1298 */ - 0x0000, /* R1299 */ - 0x0000, /* R1300 */ - 0x0000, /* R1301 */ - 0x0000, /* R1302 */ - 0x0000, /* R1303 */ - 0x0000, /* R1304 */ - 0x0000, /* R1305 */ - 0x0000, /* R1306 */ - 0x0000, /* R1307 */ - 0x0000, /* R1308 */ - 0x0000, /* R1309 */ - 0x0000, /* R1310 */ - 0x0000, /* R1311 */ - 0x0000, /* R1312 */ - 0x0000, /* R1313 */ - 0x0000, /* R1314 */ - 0x0000, /* R1315 */ - 0x0000, /* R1316 */ - 0x0000, /* R1317 */ - 0x0000, /* R1318 */ - 0x0000, /* R1319 */ - 0x0000, /* R1320 */ - 0x0000, /* R1321 */ - 0x0000, /* R1322 */ - 0x0000, /* R1323 */ - 0x0000, /* R1324 */ - 0x0000, /* R1325 */ - 0x0000, /* R1326 */ - 0x0000, /* R1327 */ - 0x0000, /* R1328 */ - 0x0000, /* R1329 */ - 0x0000, /* R1330 */ - 0x0000, /* R1331 */ - 0x0000, /* R1332 */ - 0x0000, /* R1333 */ - 0x0000, /* R1334 */ - 0x0000, /* R1335 */ - 0x0000, /* R1336 */ - 0x0000, /* R1337 */ - 0x0000, /* R1338 */ - 0x0000, /* R1339 */ - 0x0000, /* R1340 */ - 0x0000, /* R1341 */ - 0x0000, /* R1342 */ - 0x0000, /* R1343 */ - 0x0000, /* R1344 */ - 0x0000, /* R1345 */ - 0x0000, /* R1346 */ - 0x0000, /* R1347 */ - 0x0000, /* R1348 */ - 0x0000, /* R1349 */ - 0x0000, /* R1350 */ - 0x0000, /* R1351 */ - 0x0000, /* R1352 */ - 0x0000, /* R1353 */ - 0x0000, /* R1354 */ - 0x0000, /* R1355 */ - 0x0000, /* R1356 */ - 0x0000, /* R1357 */ - 0x0000, /* R1358 */ - 0x0000, /* R1359 */ - 0x0000, /* R1360 */ - 0x0000, /* R1361 */ - 0x0000, /* R1362 */ - 0x0000, /* R1363 */ - 0x0000, /* R1364 */ - 0x0000, /* R1365 */ - 0x0000, /* R1366 */ - 0x0000, /* R1367 */ - 0x0000, /* R1368 */ - 0x0000, /* R1369 */ - 0x0000, /* R1370 */ - 0x0000, /* R1371 */ - 0x0000, /* R1372 */ - 0x0000, /* R1373 */ - 0x0000, /* R1374 */ - 0x0000, /* R1375 */ - 0x0000, /* R1376 */ - 0x0000, /* R1377 */ - 0x0000, /* R1378 */ - 0x0000, /* R1379 */ - 0x0000, /* R1380 */ - 0x0000, /* R1381 */ - 0x0000, /* R1382 */ - 0x0000, /* R1383 */ - 0x0000, /* R1384 */ - 0x0000, /* R1385 */ - 0x0000, /* R1386 */ - 0x0000, /* R1387 */ - 0x0000, /* R1388 */ - 0x0000, /* R1389 */ - 0x0000, /* R1390 */ - 0x0000, /* R1391 */ - 0x0000, /* R1392 */ - 0x0000, /* R1393 */ - 0x0000, /* R1394 */ - 0x0000, /* R1395 */ - 0x0000, /* R1396 */ - 0x0000, /* R1397 */ - 0x0000, /* R1398 */ - 0x0000, /* R1399 */ - 0x0000, /* R1400 */ - 0x0000, /* R1401 */ - 0x0000, /* R1402 */ - 0x0000, /* R1403 */ - 0x0000, /* R1404 */ - 0x0000, /* R1405 */ - 0x0000, /* R1406 */ - 0x0000, /* R1407 */ - 0x0000, /* R1408 */ - 0x0000, /* R1409 */ - 0x0000, /* R1410 */ - 0x0000, /* R1411 */ - 0x0000, /* R1412 */ - 0x0000, /* R1413 */ - 0x0000, /* R1414 */ - 0x0000, /* R1415 */ - 0x0000, /* R1416 */ - 0x0000, /* R1417 */ - 0x0000, /* R1418 */ - 0x0000, /* R1419 */ - 0x0000, /* R1420 */ - 0x0000, /* R1421 */ - 0x0000, /* R1422 */ - 0x0000, /* R1423 */ - 0x0000, /* R1424 */ - 0x0000, /* R1425 */ - 0x0000, /* R1426 */ - 0x0000, /* R1427 */ - 0x0000, /* R1428 */ - 0x0000, /* R1429 */ - 0x0000, /* R1430 */ - 0x0000, /* R1431 */ - 0x0000, /* R1432 */ - 0x0000, /* R1433 */ - 0x0000, /* R1434 */ - 0x0000, /* R1435 */ - 0x0000, /* R1436 */ - 0x0000, /* R1437 */ - 0x0000, /* R1438 */ - 0x0000, /* R1439 */ - 0x0000, /* R1440 */ - 0x0000, /* R1441 */ - 0x0000, /* R1442 */ - 0x0000, /* R1443 */ - 0x0000, /* R1444 */ - 0x0000, /* R1445 */ - 0x0000, /* R1446 */ - 0x0000, /* R1447 */ - 0x0000, /* R1448 */ - 0x0000, /* R1449 */ - 0x0000, /* R1450 */ - 0x0000, /* R1451 */ - 0x0000, /* R1452 */ - 0x0000, /* R1453 */ - 0x0000, /* R1454 */ - 0x0000, /* R1455 */ - 0x0000, /* R1456 */ - 0x0000, /* R1457 */ - 0x0000, /* R1458 */ - 0x0000, /* R1459 */ - 0x0000, /* R1460 */ - 0x0000, /* R1461 */ - 0x0000, /* R1462 */ - 0x0000, /* R1463 */ - 0x0000, /* R1464 */ - 0x0000, /* R1465 */ - 0x0000, /* R1466 */ - 0x0000, /* R1467 */ - 0x0000, /* R1468 */ - 0x0000, /* R1469 */ - 0x0000, /* R1470 */ - 0x0000, /* R1471 */ - 0x0000, /* R1472 */ - 0x0000, /* R1473 */ - 0x0000, /* R1474 */ - 0x0000, /* R1475 */ - 0x0000, /* R1476 */ - 0x0000, /* R1477 */ - 0x0000, /* R1478 */ - 0x0000, /* R1479 */ - 0x0000, /* R1480 */ - 0x0000, /* R1481 */ - 0x0000, /* R1482 */ - 0x0000, /* R1483 */ - 0x0000, /* R1484 */ - 0x0000, /* R1485 */ - 0x0000, /* R1486 */ - 0x0000, /* R1487 */ - 0x0000, /* R1488 */ - 0x0000, /* R1489 */ - 0x0000, /* R1490 */ - 0x0000, /* R1491 */ - 0x0000, /* R1492 */ - 0x0000, /* R1493 */ - 0x0000, /* R1494 */ - 0x0000, /* R1495 */ - 0x0000, /* R1496 */ - 0x0000, /* R1497 */ - 0x0000, /* R1498 */ - 0x0000, /* R1499 */ - 0x0000, /* R1500 */ - 0x0000, /* R1501 */ - 0x0000, /* R1502 */ - 0x0000, /* R1503 */ - 0x0000, /* R1504 */ - 0x0000, /* R1505 */ - 0x0000, /* R1506 */ - 0x0000, /* R1507 */ - 0x0000, /* R1508 */ - 0x0000, /* R1509 */ - 0x0000, /* R1510 */ - 0x0000, /* R1511 */ - 0x0000, /* R1512 */ - 0x0000, /* R1513 */ - 0x0000, /* R1514 */ - 0x0000, /* R1515 */ - 0x0000, /* R1516 */ - 0x0000, /* R1517 */ - 0x0000, /* R1518 */ - 0x0000, /* R1519 */ - 0x0000, /* R1520 */ - 0x0000, /* R1521 */ - 0x0000, /* R1522 */ - 0x0000, /* R1523 */ - 0x0000, /* R1524 */ - 0x0000, /* R1525 */ - 0x0000, /* R1526 */ - 0x0000, /* R1527 */ - 0x0000, /* R1528 */ - 0x0000, /* R1529 */ - 0x0000, /* R1530 */ - 0x0000, /* R1531 */ - 0x0000, /* R1532 */ - 0x0000, /* R1533 */ - 0x0000, /* R1534 */ - 0x0000, /* R1535 */ - 0x0000, /* R1536 */ - 0x0000, /* R1537 */ - 0x0000, /* R1538 */ - 0x0000, /* R1539 */ - 0x0000, /* R1540 */ - 0x0000, /* R1541 */ - 0x0000, /* R1542 */ - 0x0000, /* R1543 */ - 0x0000, /* R1544 */ - 0x0000, /* R1545 */ - 0x0000, /* R1546 */ - 0x0000, /* R1547 */ - 0x0000, /* R1548 */ - 0x0000, /* R1549 */ - 0x0000, /* R1550 */ - 0x0000, /* R1551 */ - 0x0000, /* R1552 */ - 0x0000, /* R1553 */ - 0x0000, /* R1554 */ - 0x0000, /* R1555 */ - 0x0000, /* R1556 */ - 0x0000, /* R1557 */ - 0x0000, /* R1558 */ - 0x0000, /* R1559 */ - 0x0000, /* R1560 */ - 0x0000, /* R1561 */ - 0x0000, /* R1562 */ - 0x0000, /* R1563 */ - 0x0000, /* R1564 */ - 0x0000, /* R1565 */ - 0x0000, /* R1566 */ - 0x0000, /* R1567 */ - 0x0000, /* R1568 */ - 0x0000, /* R1569 */ - 0x0000, /* R1570 */ - 0x0000, /* R1571 */ - 0x0000, /* R1572 */ - 0x0000, /* R1573 */ - 0x0000, /* R1574 */ - 0x0000, /* R1575 */ - 0x0000, /* R1576 */ - 0x0000, /* R1577 */ - 0x0000, /* R1578 */ - 0x0000, /* R1579 */ - 0x0000, /* R1580 */ - 0x0000, /* R1581 */ - 0x0000, /* R1582 */ - 0x0000, /* R1583 */ - 0x0000, /* R1584 */ - 0x0000, /* R1585 */ - 0x0000, /* R1586 */ - 0x0000, /* R1587 */ - 0x0000, /* R1588 */ - 0x0000, /* R1589 */ - 0x0000, /* R1590 */ - 0x0000, /* R1591 */ - 0x0000, /* R1592 */ - 0x0000, /* R1593 */ - 0x0000, /* R1594 */ - 0x0000, /* R1595 */ - 0x0000, /* R1596 */ - 0x0000, /* R1597 */ - 0x0000, /* R1598 */ - 0x0000, /* R1599 */ - 0x0000, /* R1600 */ - 0x0000, /* R1601 */ - 0x0000, /* R1602 */ - 0x0000, /* R1603 */ - 0x0000, /* R1604 */ - 0x0000, /* R1605 */ - 0x0000, /* R1606 */ - 0x0000, /* R1607 */ - 0x0000, /* R1608 */ - 0x0000, /* R1609 */ - 0x0000, /* R1610 */ - 0x0000, /* R1611 */ - 0x0000, /* R1612 */ - 0x0000, /* R1613 */ - 0x0000, /* R1614 */ - 0x0000, /* R1615 */ - 0x0000, /* R1616 */ - 0x0000, /* R1617 */ - 0x0000, /* R1618 */ - 0x0000, /* R1619 */ - 0x0000, /* R1620 */ - 0x0000, /* R1621 */ - 0x0000, /* R1622 */ - 0x0000, /* R1623 */ - 0x0000, /* R1624 */ - 0x0000, /* R1625 */ - 0x0000, /* R1626 */ - 0x0000, /* R1627 */ - 0x0000, /* R1628 */ - 0x0000, /* R1629 */ - 0x0000, /* R1630 */ - 0x0000, /* R1631 */ - 0x0000, /* R1632 */ - 0x0000, /* R1633 */ - 0x0000, /* R1634 */ - 0x0000, /* R1635 */ - 0x0000, /* R1636 */ - 0x0000, /* R1637 */ - 0x0000, /* R1638 */ - 0x0000, /* R1639 */ - 0x0000, /* R1640 */ - 0x0000, /* R1641 */ - 0x0000, /* R1642 */ - 0x0000, /* R1643 */ - 0x0000, /* R1644 */ - 0x0000, /* R1645 */ - 0x0000, /* R1646 */ - 0x0000, /* R1647 */ - 0x0000, /* R1648 */ - 0x0000, /* R1649 */ - 0x0000, /* R1650 */ - 0x0000, /* R1651 */ - 0x0000, /* R1652 */ - 0x0000, /* R1653 */ - 0x0000, /* R1654 */ - 0x0000, /* R1655 */ - 0x0000, /* R1656 */ - 0x0000, /* R1657 */ - 0x0000, /* R1658 */ - 0x0000, /* R1659 */ - 0x0000, /* R1660 */ - 0x0000, /* R1661 */ - 0x0000, /* R1662 */ - 0x0000, /* R1663 */ - 0x0000, /* R1664 */ - 0x0000, /* R1665 */ - 0x0000, /* R1666 */ - 0x0000, /* R1667 */ - 0x0000, /* R1668 */ - 0x0000, /* R1669 */ - 0x0000, /* R1670 */ - 0x0000, /* R1671 */ - 0x0000, /* R1672 */ - 0x0000, /* R1673 */ - 0x0000, /* R1674 */ - 0x0000, /* R1675 */ - 0x0000, /* R1676 */ - 0x0000, /* R1677 */ - 0x0000, /* R1678 */ - 0x0000, /* R1679 */ - 0x0000, /* R1680 */ - 0x0000, /* R1681 */ - 0x0000, /* R1682 */ - 0x0000, /* R1683 */ - 0x0000, /* R1684 */ - 0x0000, /* R1685 */ - 0x0000, /* R1686 */ - 0x0000, /* R1687 */ - 0x0000, /* R1688 */ - 0x0000, /* R1689 */ - 0x0000, /* R1690 */ - 0x0000, /* R1691 */ - 0x0000, /* R1692 */ - 0x0000, /* R1693 */ - 0x0000, /* R1694 */ - 0x0000, /* R1695 */ - 0x0000, /* R1696 */ - 0x0000, /* R1697 */ - 0x0000, /* R1698 */ - 0x0000, /* R1699 */ - 0x0000, /* R1700 */ - 0x0000, /* R1701 */ - 0x0000, /* R1702 */ - 0x0000, /* R1703 */ - 0x0000, /* R1704 */ - 0x0000, /* R1705 */ - 0x0000, /* R1706 */ - 0x0000, /* R1707 */ - 0x0000, /* R1708 */ - 0x0000, /* R1709 */ - 0x0000, /* R1710 */ - 0x0000, /* R1711 */ - 0x0000, /* R1712 */ - 0x0000, /* R1713 */ - 0x0000, /* R1714 */ - 0x0000, /* R1715 */ - 0x0000, /* R1716 */ - 0x0000, /* R1717 */ - 0x0000, /* R1718 */ - 0x0000, /* R1719 */ - 0x0000, /* R1720 */ - 0x0000, /* R1721 */ - 0x0000, /* R1722 */ - 0x0000, /* R1723 */ - 0x0000, /* R1724 */ - 0x0000, /* R1725 */ - 0x0000, /* R1726 */ - 0x0000, /* R1727 */ - 0x0000, /* R1728 */ - 0x0000, /* R1729 */ - 0x0000, /* R1730 */ - 0x0000, /* R1731 */ - 0x0000, /* R1732 */ - 0x0000, /* R1733 */ - 0x0000, /* R1734 */ - 0x0000, /* R1735 */ - 0x0000, /* R1736 */ - 0x0000, /* R1737 */ - 0x0000, /* R1738 */ - 0x0000, /* R1739 */ - 0x0000, /* R1740 */ - 0x0000, /* R1741 */ - 0x0000, /* R1742 */ - 0x0000, /* R1743 */ - 0x0000, /* R1744 */ - 0x0000, /* R1745 */ - 0x0000, /* R1746 */ - 0x0000, /* R1747 */ - 0x0000, /* R1748 */ - 0x0000, /* R1749 */ - 0x0000, /* R1750 */ - 0x0000, /* R1751 */ - 0x0000, /* R1752 */ - 0x0000, /* R1753 */ - 0x0000, /* R1754 */ - 0x0000, /* R1755 */ - 0x0000, /* R1756 */ - 0x0000, /* R1757 */ - 0x0000, /* R1758 */ - 0x0000, /* R1759 */ - 0x0000, /* R1760 */ - 0x0000, /* R1761 */ - 0x0000, /* R1762 */ - 0x0000, /* R1763 */ - 0x0000, /* R1764 */ - 0x0000, /* R1765 */ - 0x0000, /* R1766 */ - 0x0000, /* R1767 */ - 0x0000, /* R1768 */ - 0x0000, /* R1769 */ - 0x0000, /* R1770 */ - 0x0000, /* R1771 */ - 0x0000, /* R1772 */ - 0x0000, /* R1773 */ - 0x0000, /* R1774 */ - 0x0000, /* R1775 */ - 0x0000, /* R1776 */ - 0x0000, /* R1777 */ - 0x0000, /* R1778 */ - 0x0000, /* R1779 */ - 0x0000, /* R1780 */ - 0x0000, /* R1781 */ - 0x0000, /* R1782 */ - 0x0000, /* R1783 */ - 0x0000, /* R1784 */ - 0x0000, /* R1785 */ - 0x0000, /* R1786 */ - 0x0000, /* R1787 */ - 0x0000, /* R1788 */ - 0x0000, /* R1789 */ - 0x0000, /* R1790 */ - 0x0000, /* R1791 */ - 0x0000, /* R1792 */ - 0x0000, /* R1793 */ - 0x0000, /* R1794 */ - 0x0000, /* R1795 */ - 0x0000, /* R1796 */ - 0x0000, /* R1797 */ - 0x0000, /* R1798 */ - 0x0000, /* R1799 */ - 0x0000, /* R1800 */ - 0x0000, /* R1801 */ - 0x0000, /* R1802 */ - 0x0000, /* R1803 */ - 0x0000, /* R1804 */ - 0x0000, /* R1805 */ - 0x0000, /* R1806 */ - 0x0000, /* R1807 */ - 0x0000, /* R1808 */ - 0x0000, /* R1809 */ - 0x0000, /* R1810 */ - 0x0000, /* R1811 */ - 0x0000, /* R1812 */ - 0x0000, /* R1813 */ - 0x0000, /* R1814 */ - 0x0000, /* R1815 */ - 0x0000, /* R1816 */ - 0x0000, /* R1817 */ - 0x0000, /* R1818 */ - 0x0000, /* R1819 */ - 0x0000, /* R1820 */ - 0x0000, /* R1821 */ - 0x0000, /* R1822 */ - 0x0000, /* R1823 */ - 0x0000, /* R1824 */ - 0x0000, /* R1825 */ - 0x0000, /* R1826 */ - 0x0000, /* R1827 */ - 0x0000, /* R1828 */ - 0x0000, /* R1829 */ - 0x0000, /* R1830 */ - 0x0000, /* R1831 */ - 0x0000, /* R1832 */ - 0x0000, /* R1833 */ - 0x0000, /* R1834 */ - 0x0000, /* R1835 */ - 0x0000, /* R1836 */ - 0x0000, /* R1837 */ - 0x0000, /* R1838 */ - 0x0000, /* R1839 */ - 0x0000, /* R1840 */ - 0x0000, /* R1841 */ - 0x0000, /* R1842 */ - 0x0000, /* R1843 */ - 0x0000, /* R1844 */ - 0x0000, /* R1845 */ - 0x0000, /* R1846 */ - 0x0000, /* R1847 */ - 0x0000, /* R1848 */ - 0x0000, /* R1849 */ - 0x0000, /* R1850 */ - 0x0000, /* R1851 */ - 0x0000, /* R1852 */ - 0x0000, /* R1853 */ - 0x0000, /* R1854 */ - 0x0000, /* R1855 */ - 0x0000, /* R1856 */ - 0x0000, /* R1857 */ - 0x0000, /* R1858 */ - 0x0000, /* R1859 */ - 0x0000, /* R1860 */ - 0x0000, /* R1861 */ - 0x0000, /* R1862 */ - 0x0000, /* R1863 */ - 0x0000, /* R1864 */ - 0x0000, /* R1865 */ - 0x0000, /* R1866 */ - 0x0000, /* R1867 */ - 0x0000, /* R1868 */ - 0x0000, /* R1869 */ - 0x0000, /* R1870 */ - 0x0000, /* R1871 */ - 0x0000, /* R1872 */ - 0x0000, /* R1873 */ - 0x0000, /* R1874 */ - 0x0000, /* R1875 */ - 0x0000, /* R1876 */ - 0x0000, /* R1877 */ - 0x0000, /* R1878 */ - 0x0000, /* R1879 */ - 0x0000, /* R1880 */ - 0x0000, /* R1881 */ - 0x0000, /* R1882 */ - 0x0000, /* R1883 */ - 0x0000, /* R1884 */ - 0x0000, /* R1885 */ - 0x0000, /* R1886 */ - 0x0000, /* R1887 */ - 0x0000, /* R1888 */ - 0x0000, /* R1889 */ - 0x0000, /* R1890 */ - 0x0000, /* R1891 */ - 0x0000, /* R1892 */ - 0x0000, /* R1893 */ - 0x0000, /* R1894 */ - 0x0000, /* R1895 */ - 0x0000, /* R1896 */ - 0x0000, /* R1897 */ - 0x0000, /* R1898 */ - 0x0000, /* R1899 */ - 0x0000, /* R1900 */ - 0x0000, /* R1901 */ - 0x0000, /* R1902 */ - 0x0000, /* R1903 */ - 0x0000, /* R1904 */ - 0x0000, /* R1905 */ - 0x0000, /* R1906 */ - 0x0000, /* R1907 */ - 0x0000, /* R1908 */ - 0x0000, /* R1909 */ - 0x0000, /* R1910 */ - 0x0000, /* R1911 */ - 0x0000, /* R1912 */ - 0x0000, /* R1913 */ - 0x0000, /* R1914 */ - 0x0000, /* R1915 */ - 0x0000, /* R1916 */ - 0x0000, /* R1917 */ - 0x0000, /* R1918 */ - 0x0000, /* R1919 */ - 0x0000, /* R1920 */ - 0x0000, /* R1921 */ - 0x0000, /* R1922 */ - 0x0000, /* R1923 */ - 0x0000, /* R1924 */ - 0x0000, /* R1925 */ - 0x0000, /* R1926 */ - 0x0000, /* R1927 */ - 0x0000, /* R1928 */ - 0x0000, /* R1929 */ - 0x0000, /* R1930 */ - 0x0000, /* R1931 */ - 0x0000, /* R1932 */ - 0x0000, /* R1933 */ - 0x0000, /* R1934 */ - 0x0000, /* R1935 */ - 0x0000, /* R1936 */ - 0x0000, /* R1937 */ - 0x0000, /* R1938 */ - 0x0000, /* R1939 */ - 0x0000, /* R1940 */ - 0x0000, /* R1941 */ - 0x0000, /* R1942 */ - 0x0000, /* R1943 */ - 0x0000, /* R1944 */ - 0x0000, /* R1945 */ - 0x0000, /* R1946 */ - 0x0000, /* R1947 */ - 0x0000, /* R1948 */ - 0x0000, /* R1949 */ - 0x0000, /* R1950 */ - 0x0000, /* R1951 */ - 0x0000, /* R1952 */ - 0x0000, /* R1953 */ - 0x0000, /* R1954 */ - 0x0000, /* R1955 */ - 0x0000, /* R1956 */ - 0x0000, /* R1957 */ - 0x0000, /* R1958 */ - 0x0000, /* R1959 */ - 0x0000, /* R1960 */ - 0x0000, /* R1961 */ - 0x0000, /* R1962 */ - 0x0000, /* R1963 */ - 0x0000, /* R1964 */ - 0x0000, /* R1965 */ - 0x0000, /* R1966 */ - 0x0000, /* R1967 */ - 0x0000, /* R1968 */ - 0x0000, /* R1969 */ - 0x0000, /* R1970 */ - 0x0000, /* R1971 */ - 0x0000, /* R1972 */ - 0x0000, /* R1973 */ - 0x0000, /* R1974 */ - 0x0000, /* R1975 */ - 0x0000, /* R1976 */ - 0x0000, /* R1977 */ - 0x0000, /* R1978 */ - 0x0000, /* R1979 */ - 0x0000, /* R1980 */ - 0x0000, /* R1981 */ - 0x0000, /* R1982 */ - 0x0000, /* R1983 */ - 0x0000, /* R1984 */ - 0x0000, /* R1985 */ - 0x0000, /* R1986 */ - 0x0000, /* R1987 */ - 0x0000, /* R1988 */ - 0x0000, /* R1989 */ - 0x0000, /* R1990 */ - 0x0000, /* R1991 */ - 0x0000, /* R1992 */ - 0x0000, /* R1993 */ - 0x0000, /* R1994 */ - 0x0000, /* R1995 */ - 0x0000, /* R1996 */ - 0x0000, /* R1997 */ - 0x0000, /* R1998 */ - 0x0000, /* R1999 */ - 0x0000, /* R2000 */ - 0x0000, /* R2001 */ - 0x0000, /* R2002 */ - 0x0000, /* R2003 */ - 0x0000, /* R2004 */ - 0x0000, /* R2005 */ - 0x0000, /* R2006 */ - 0x0000, /* R2007 */ - 0x0000, /* R2008 */ - 0x0000, /* R2009 */ - 0x0000, /* R2010 */ - 0x0000, /* R2011 */ - 0x0000, /* R2012 */ - 0x0000, /* R2013 */ - 0x0000, /* R2014 */ - 0x0000, /* R2015 */ - 0x0000, /* R2016 */ - 0x0000, /* R2017 */ - 0x0000, /* R2018 */ - 0x0000, /* R2019 */ - 0x0000, /* R2020 */ - 0x0000, /* R2021 */ - 0x0000, /* R2022 */ - 0x0000, /* R2023 */ - 0x0000, /* R2024 */ - 0x0000, /* R2025 */ - 0x0000, /* R2026 */ - 0x0000, /* R2027 */ - 0x0000, /* R2028 */ - 0x0000, /* R2029 */ - 0x0000, /* R2030 */ - 0x0000, /* R2031 */ - 0x0000, /* R2032 */ - 0x0000, /* R2033 */ - 0x0000, /* R2034 */ - 0x0000, /* R2035 */ - 0x0000, /* R2036 */ - 0x0000, /* R2037 */ - 0x0000, /* R2038 */ - 0x0000, /* R2039 */ - 0x0000, /* R2040 */ - 0x0000, /* R2041 */ - 0x0000, /* R2042 */ - 0x0000, /* R2043 */ - 0x0000, /* R2044 */ - 0x0000, /* R2045 */ - 0x0000, /* R2046 */ - 0x0000, /* R2047 */ - 0x0000, /* R2048 */ - 0x0000, /* R2049 */ - 0x0000, /* R2050 */ - 0x0000, /* R2051 */ - 0x0000, /* R2052 */ - 0x0000, /* R2053 */ - 0x0000, /* R2054 */ - 0x0000, /* R2055 */ - 0x0000, /* R2056 */ - 0x0000, /* R2057 */ - 0x0000, /* R2058 */ - 0x0000, /* R2059 */ - 0x0000, /* R2060 */ - 0x0000, /* R2061 */ - 0x0000, /* R2062 */ - 0x0000, /* R2063 */ - 0x0000, /* R2064 */ - 0x0000, /* R2065 */ - 0x0000, /* R2066 */ - 0x0000, /* R2067 */ - 0x0000, /* R2068 */ - 0x0000, /* R2069 */ - 0x0000, /* R2070 */ - 0x0000, /* R2071 */ - 0x0000, /* R2072 */ - 0x0000, /* R2073 */ - 0x0000, /* R2074 */ - 0x0000, /* R2075 */ - 0x0000, /* R2076 */ - 0x0000, /* R2077 */ - 0x0000, /* R2078 */ - 0x0000, /* R2079 */ - 0x0000, /* R2080 */ - 0x0000, /* R2081 */ - 0x0000, /* R2082 */ - 0x0000, /* R2083 */ - 0x0000, /* R2084 */ - 0x0000, /* R2085 */ - 0x0000, /* R2086 */ - 0x0000, /* R2087 */ - 0x0000, /* R2088 */ - 0x0000, /* R2089 */ - 0x0000, /* R2090 */ - 0x0000, /* R2091 */ - 0x0000, /* R2092 */ - 0x0000, /* R2093 */ - 0x0000, /* R2094 */ - 0x0000, /* R2095 */ - 0x0000, /* R2096 */ - 0x0000, /* R2097 */ - 0x0000, /* R2098 */ - 0x0000, /* R2099 */ - 0x0000, /* R2100 */ - 0x0000, /* R2101 */ - 0x0000, /* R2102 */ - 0x0000, /* R2103 */ - 0x0000, /* R2104 */ - 0x0000, /* R2105 */ - 0x0000, /* R2106 */ - 0x0000, /* R2107 */ - 0x0000, /* R2108 */ - 0x0000, /* R2109 */ - 0x0000, /* R2110 */ - 0x0000, /* R2111 */ - 0x0000, /* R2112 */ - 0x0000, /* R2113 */ - 0x0000, /* R2114 */ - 0x0000, /* R2115 */ - 0x0000, /* R2116 */ - 0x0000, /* R2117 */ - 0x0000, /* R2118 */ - 0x0000, /* R2119 */ - 0x0000, /* R2120 */ - 0x0000, /* R2121 */ - 0x0000, /* R2122 */ - 0x0000, /* R2123 */ - 0x0000, /* R2124 */ - 0x0000, /* R2125 */ - 0x0000, /* R2126 */ - 0x0000, /* R2127 */ - 0x0000, /* R2128 */ - 0x0000, /* R2129 */ - 0x0000, /* R2130 */ - 0x0000, /* R2131 */ - 0x0000, /* R2132 */ - 0x0000, /* R2133 */ - 0x0000, /* R2134 */ - 0x0000, /* R2135 */ - 0x0000, /* R2136 */ - 0x0000, /* R2137 */ - 0x0000, /* R2138 */ - 0x0000, /* R2139 */ - 0x0000, /* R2140 */ - 0x0000, /* R2141 */ - 0x0000, /* R2142 */ - 0x0000, /* R2143 */ - 0x0000, /* R2144 */ - 0x0000, /* R2145 */ - 0x0000, /* R2146 */ - 0x0000, /* R2147 */ - 0x0000, /* R2148 */ - 0x0000, /* R2149 */ - 0x0000, /* R2150 */ - 0x0000, /* R2151 */ - 0x0000, /* R2152 */ - 0x0000, /* R2153 */ - 0x0000, /* R2154 */ - 0x0000, /* R2155 */ - 0x0000, /* R2156 */ - 0x0000, /* R2157 */ - 0x0000, /* R2158 */ - 0x0000, /* R2159 */ - 0x0000, /* R2160 */ - 0x0000, /* R2161 */ - 0x0000, /* R2162 */ - 0x0000, /* R2163 */ - 0x0000, /* R2164 */ - 0x0000, /* R2165 */ - 0x0000, /* R2166 */ - 0x0000, /* R2167 */ - 0x0000, /* R2168 */ - 0x0000, /* R2169 */ - 0x0000, /* R2170 */ - 0x0000, /* R2171 */ - 0x0000, /* R2172 */ - 0x0000, /* R2173 */ - 0x0000, /* R2174 */ - 0x0000, /* R2175 */ - 0x0000, /* R2176 */ - 0x0000, /* R2177 */ - 0x0000, /* R2178 */ - 0x0000, /* R2179 */ - 0x0000, /* R2180 */ - 0x0000, /* R2181 */ - 0x0000, /* R2182 */ - 0x0000, /* R2183 */ - 0x0000, /* R2184 */ - 0x0000, /* R2185 */ - 0x0000, /* R2186 */ - 0x0000, /* R2187 */ - 0x0000, /* R2188 */ - 0x0000, /* R2189 */ - 0x0000, /* R2190 */ - 0x0000, /* R2191 */ - 0x0000, /* R2192 */ - 0x0000, /* R2193 */ - 0x0000, /* R2194 */ - 0x0000, /* R2195 */ - 0x0000, /* R2196 */ - 0x0000, /* R2197 */ - 0x0000, /* R2198 */ - 0x0000, /* R2199 */ - 0x0000, /* R2200 */ - 0x0000, /* R2201 */ - 0x0000, /* R2202 */ - 0x0000, /* R2203 */ - 0x0000, /* R2204 */ - 0x0000, /* R2205 */ - 0x0000, /* R2206 */ - 0x0000, /* R2207 */ - 0x0000, /* R2208 */ - 0x0000, /* R2209 */ - 0x0000, /* R2210 */ - 0x0000, /* R2211 */ - 0x0000, /* R2212 */ - 0x0000, /* R2213 */ - 0x0000, /* R2214 */ - 0x0000, /* R2215 */ - 0x0000, /* R2216 */ - 0x0000, /* R2217 */ - 0x0000, /* R2218 */ - 0x0000, /* R2219 */ - 0x0000, /* R2220 */ - 0x0000, /* R2221 */ - 0x0000, /* R2222 */ - 0x0000, /* R2223 */ - 0x0000, /* R2224 */ - 0x0000, /* R2225 */ - 0x0000, /* R2226 */ - 0x0000, /* R2227 */ - 0x0000, /* R2228 */ - 0x0000, /* R2229 */ - 0x0000, /* R2230 */ - 0x0000, /* R2231 */ - 0x0000, /* R2232 */ - 0x0000, /* R2233 */ - 0x0000, /* R2234 */ - 0x0000, /* R2235 */ - 0x0000, /* R2236 */ - 0x0000, /* R2237 */ - 0x0000, /* R2238 */ - 0x0000, /* R2239 */ - 0x0000, /* R2240 */ - 0x0000, /* R2241 */ - 0x0000, /* R2242 */ - 0x0000, /* R2243 */ - 0x0000, /* R2244 */ - 0x0000, /* R2245 */ - 0x0000, /* R2246 */ - 0x0000, /* R2247 */ - 0x0000, /* R2248 */ - 0x0000, /* R2249 */ - 0x0000, /* R2250 */ - 0x0000, /* R2251 */ - 0x0000, /* R2252 */ - 0x0000, /* R2253 */ - 0x0000, /* R2254 */ - 0x0000, /* R2255 */ - 0x0000, /* R2256 */ - 0x0000, /* R2257 */ - 0x0000, /* R2258 */ - 0x0000, /* R2259 */ - 0x0000, /* R2260 */ - 0x0000, /* R2261 */ - 0x0000, /* R2262 */ - 0x0000, /* R2263 */ - 0x0000, /* R2264 */ - 0x0000, /* R2265 */ - 0x0000, /* R2266 */ - 0x0000, /* R2267 */ - 0x0000, /* R2268 */ - 0x0000, /* R2269 */ - 0x0000, /* R2270 */ - 0x0000, /* R2271 */ - 0x0000, /* R2272 */ - 0x0000, /* R2273 */ - 0x0000, /* R2274 */ - 0x0000, /* R2275 */ - 0x0000, /* R2276 */ - 0x0000, /* R2277 */ - 0x0000, /* R2278 */ - 0x0000, /* R2279 */ - 0x0000, /* R2280 */ - 0x0000, /* R2281 */ - 0x0000, /* R2282 */ - 0x0000, /* R2283 */ - 0x0000, /* R2284 */ - 0x0000, /* R2285 */ - 0x0000, /* R2286 */ - 0x0000, /* R2287 */ - 0x0000, /* R2288 */ - 0x0000, /* R2289 */ - 0x0000, /* R2290 */ - 0x0000, /* R2291 */ - 0x0000, /* R2292 */ - 0x0000, /* R2293 */ - 0x0000, /* R2294 */ - 0x0000, /* R2295 */ - 0x0000, /* R2296 */ - 0x0000, /* R2297 */ - 0x0000, /* R2298 */ - 0x0000, /* R2299 */ - 0x0000, /* R2300 */ - 0x0000, /* R2301 */ - 0x0000, /* R2302 */ - 0x0000, /* R2303 */ - 0x0000, /* R2304 */ - 0x0000, /* R2305 */ - 0x0000, /* R2306 */ - 0x0000, /* R2307 */ - 0x0000, /* R2308 */ - 0x0000, /* R2309 */ - 0x0000, /* R2310 */ - 0x0000, /* R2311 */ - 0x0000, /* R2312 */ - 0x0000, /* R2313 */ - 0x0000, /* R2314 */ - 0x0000, /* R2315 */ - 0x0000, /* R2316 */ - 0x0000, /* R2317 */ - 0x0000, /* R2318 */ - 0x0000, /* R2319 */ - 0x0000, /* R2320 */ - 0x0000, /* R2321 */ - 0x0000, /* R2322 */ - 0x0000, /* R2323 */ - 0x0000, /* R2324 */ - 0x0000, /* R2325 */ - 0x0000, /* R2326 */ - 0x0000, /* R2327 */ - 0x0000, /* R2328 */ - 0x0000, /* R2329 */ - 0x0000, /* R2330 */ - 0x0000, /* R2331 */ - 0x0000, /* R2332 */ - 0x0000, /* R2333 */ - 0x0000, /* R2334 */ - 0x0000, /* R2335 */ - 0x0000, /* R2336 */ - 0x0000, /* R2337 */ - 0x0000, /* R2338 */ - 0x0000, /* R2339 */ - 0x0000, /* R2340 */ - 0x0000, /* R2341 */ - 0x0000, /* R2342 */ - 0x0000, /* R2343 */ - 0x0000, /* R2344 */ - 0x0000, /* R2345 */ - 0x0000, /* R2346 */ - 0x0000, /* R2347 */ - 0x0000, /* R2348 */ - 0x0000, /* R2349 */ - 0x0000, /* R2350 */ - 0x0000, /* R2351 */ - 0x0000, /* R2352 */ - 0x0000, /* R2353 */ - 0x0000, /* R2354 */ - 0x0000, /* R2355 */ - 0x0000, /* R2356 */ - 0x0000, /* R2357 */ - 0x0000, /* R2358 */ - 0x0000, /* R2359 */ - 0x0000, /* R2360 */ - 0x0000, /* R2361 */ - 0x0000, /* R2362 */ - 0x0000, /* R2363 */ - 0x0000, /* R2364 */ - 0x0000, /* R2365 */ - 0x0000, /* R2366 */ - 0x0000, /* R2367 */ - 0x0000, /* R2368 */ - 0x0000, /* R2369 */ - 0x0000, /* R2370 */ - 0x0000, /* R2371 */ - 0x0000, /* R2372 */ - 0x0000, /* R2373 */ - 0x0000, /* R2374 */ - 0x0000, /* R2375 */ - 0x0000, /* R2376 */ - 0x0000, /* R2377 */ - 0x0000, /* R2378 */ - 0x0000, /* R2379 */ - 0x0000, /* R2380 */ - 0x0000, /* R2381 */ - 0x0000, /* R2382 */ - 0x0000, /* R2383 */ - 0x0000, /* R2384 */ - 0x0000, /* R2385 */ - 0x0000, /* R2386 */ - 0x0000, /* R2387 */ - 0x0000, /* R2388 */ - 0x0000, /* R2389 */ - 0x0000, /* R2390 */ - 0x0000, /* R2391 */ - 0x0000, /* R2392 */ - 0x0000, /* R2393 */ - 0x0000, /* R2394 */ - 0x0000, /* R2395 */ - 0x0000, /* R2396 */ - 0x0000, /* R2397 */ - 0x0000, /* R2398 */ - 0x0000, /* R2399 */ - 0x0000, /* R2400 */ - 0x0000, /* R2401 */ - 0x0000, /* R2402 */ - 0x0000, /* R2403 */ - 0x0000, /* R2404 */ - 0x0000, /* R2405 */ - 0x0000, /* R2406 */ - 0x0000, /* R2407 */ - 0x0000, /* R2408 */ - 0x0000, /* R2409 */ - 0x0000, /* R2410 */ - 0x0000, /* R2411 */ - 0x0000, /* R2412 */ - 0x0000, /* R2413 */ - 0x0000, /* R2414 */ - 0x0000, /* R2415 */ - 0x0000, /* R2416 */ - 0x0000, /* R2417 */ - 0x0000, /* R2418 */ - 0x0000, /* R2419 */ - 0x0000, /* R2420 */ - 0x0000, /* R2421 */ - 0x0000, /* R2422 */ - 0x0000, /* R2423 */ - 0x0000, /* R2424 */ - 0x0000, /* R2425 */ - 0x0000, /* R2426 */ - 0x0000, /* R2427 */ - 0x0000, /* R2428 */ - 0x0000, /* R2429 */ - 0x0000, /* R2430 */ - 0x0000, /* R2431 */ - 0x0000, /* R2432 */ - 0x0000, /* R2433 */ - 0x0000, /* R2434 */ - 0x0000, /* R2435 */ - 0x0000, /* R2436 */ - 0x0000, /* R2437 */ - 0x0000, /* R2438 */ - 0x0000, /* R2439 */ - 0x0000, /* R2440 */ - 0x0000, /* R2441 */ - 0x0000, /* R2442 */ - 0x0000, /* R2443 */ - 0x0000, /* R2444 */ - 0x0000, /* R2445 */ - 0x0000, /* R2446 */ - 0x0000, /* R2447 */ - 0x0000, /* R2448 */ - 0x0000, /* R2449 */ - 0x0000, /* R2450 */ - 0x0000, /* R2451 */ - 0x0000, /* R2452 */ - 0x0000, /* R2453 */ - 0x0000, /* R2454 */ - 0x0000, /* R2455 */ - 0x0000, /* R2456 */ - 0x0000, /* R2457 */ - 0x0000, /* R2458 */ - 0x0000, /* R2459 */ - 0x0000, /* R2460 */ - 0x0000, /* R2461 */ - 0x0000, /* R2462 */ - 0x0000, /* R2463 */ - 0x0000, /* R2464 */ - 0x0000, /* R2465 */ - 0x0000, /* R2466 */ - 0x0000, /* R2467 */ - 0x0000, /* R2468 */ - 0x0000, /* R2469 */ - 0x0000, /* R2470 */ - 0x0000, /* R2471 */ - 0x0000, /* R2472 */ - 0x0000, /* R2473 */ - 0x0000, /* R2474 */ - 0x0000, /* R2475 */ - 0x0000, /* R2476 */ - 0x0000, /* R2477 */ - 0x0000, /* R2478 */ - 0x0000, /* R2479 */ - 0x0000, /* R2480 */ - 0x0000, /* R2481 */ - 0x0000, /* R2482 */ - 0x0000, /* R2483 */ - 0x0000, /* R2484 */ - 0x0000, /* R2485 */ - 0x0000, /* R2486 */ - 0x0000, /* R2487 */ - 0x0000, /* R2488 */ - 0x0000, /* R2489 */ - 0x0000, /* R2490 */ - 0x0000, /* R2491 */ - 0x0000, /* R2492 */ - 0x0000, /* R2493 */ - 0x0000, /* R2494 */ - 0x0000, /* R2495 */ - 0x0000, /* R2496 */ - 0x0000, /* R2497 */ - 0x0000, /* R2498 */ - 0x0000, /* R2499 */ - 0x0000, /* R2500 */ - 0x0000, /* R2501 */ - 0x0000, /* R2502 */ - 0x0000, /* R2503 */ - 0x0000, /* R2504 */ - 0x0000, /* R2505 */ - 0x0000, /* R2506 */ - 0x0000, /* R2507 */ - 0x0000, /* R2508 */ - 0x0000, /* R2509 */ - 0x0000, /* R2510 */ - 0x0000, /* R2511 */ - 0x0000, /* R2512 */ - 0x0000, /* R2513 */ - 0x0000, /* R2514 */ - 0x0000, /* R2515 */ - 0x0000, /* R2516 */ - 0x0000, /* R2517 */ - 0x0000, /* R2518 */ - 0x0000, /* R2519 */ - 0x0000, /* R2520 */ - 0x0000, /* R2521 */ - 0x0000, /* R2522 */ - 0x0000, /* R2523 */ - 0x0000, /* R2524 */ - 0x0000, /* R2525 */ - 0x0000, /* R2526 */ - 0x0000, /* R2527 */ - 0x0000, /* R2528 */ - 0x0000, /* R2529 */ - 0x0000, /* R2530 */ - 0x0000, /* R2531 */ - 0x0000, /* R2532 */ - 0x0000, /* R2533 */ - 0x0000, /* R2534 */ - 0x0000, /* R2535 */ - 0x0000, /* R2536 */ - 0x0000, /* R2537 */ - 0x0000, /* R2538 */ - 0x0000, /* R2539 */ - 0x0000, /* R2540 */ - 0x0000, /* R2541 */ - 0x0000, /* R2542 */ - 0x0000, /* R2543 */ - 0x0000, /* R2544 */ - 0x0000, /* R2545 */ - 0x0000, /* R2546 */ - 0x0000, /* R2547 */ - 0x0000, /* R2548 */ - 0x0000, /* R2549 */ - 0x0000, /* R2550 */ - 0x0000, /* R2551 */ - 0x0000, /* R2552 */ - 0x0000, /* R2553 */ - 0x0000, /* R2554 */ - 0x0000, /* R2555 */ - 0x0000, /* R2556 */ - 0x0000, /* R2557 */ - 0x0000, /* R2558 */ - 0x0000, /* R2559 */ - 0x0000, /* R2560 */ - 0x0000, /* R2561 */ - 0x0000, /* R2562 */ - 0x0000, /* R2563 */ - 0x0000, /* R2564 */ - 0x0000, /* R2565 */ - 0x0000, /* R2566 */ - 0x0000, /* R2567 */ - 0x0000, /* R2568 */ - 0x0000, /* R2569 */ - 0x0000, /* R2570 */ - 0x0000, /* R2571 */ - 0x0000, /* R2572 */ - 0x0000, /* R2573 */ - 0x0000, /* R2574 */ - 0x0000, /* R2575 */ - 0x0000, /* R2576 */ - 0x0000, /* R2577 */ - 0x0000, /* R2578 */ - 0x0000, /* R2579 */ - 0x0000, /* R2580 */ - 0x0000, /* R2581 */ - 0x0000, /* R2582 */ - 0x0000, /* R2583 */ - 0x0000, /* R2584 */ - 0x0000, /* R2585 */ - 0x0000, /* R2586 */ - 0x0000, /* R2587 */ - 0x0000, /* R2588 */ - 0x0000, /* R2589 */ - 0x0000, /* R2590 */ - 0x0000, /* R2591 */ - 0x0000, /* R2592 */ - 0x0000, /* R2593 */ - 0x0000, /* R2594 */ - 0x0000, /* R2595 */ - 0x0000, /* R2596 */ - 0x0000, /* R2597 */ - 0x0000, /* R2598 */ - 0x0000, /* R2599 */ - 0x0000, /* R2600 */ - 0x0000, /* R2601 */ - 0x0000, /* R2602 */ - 0x0000, /* R2603 */ - 0x0000, /* R2604 */ - 0x0000, /* R2605 */ - 0x0000, /* R2606 */ - 0x0000, /* R2607 */ - 0x0000, /* R2608 */ - 0x0000, /* R2609 */ - 0x0000, /* R2610 */ - 0x0000, /* R2611 */ - 0x0000, /* R2612 */ - 0x0000, /* R2613 */ - 0x0000, /* R2614 */ - 0x0000, /* R2615 */ - 0x0000, /* R2616 */ - 0x0000, /* R2617 */ - 0x0000, /* R2618 */ - 0x0000, /* R2619 */ - 0x0000, /* R2620 */ - 0x0000, /* R2621 */ - 0x0000, /* R2622 */ - 0x0000, /* R2623 */ - 0x0000, /* R2624 */ - 0x0000, /* R2625 */ - 0x0000, /* R2626 */ - 0x0000, /* R2627 */ - 0x0000, /* R2628 */ - 0x0000, /* R2629 */ - 0x0000, /* R2630 */ - 0x0000, /* R2631 */ - 0x0000, /* R2632 */ - 0x0000, /* R2633 */ - 0x0000, /* R2634 */ - 0x0000, /* R2635 */ - 0x0000, /* R2636 */ - 0x0000, /* R2637 */ - 0x0000, /* R2638 */ - 0x0000, /* R2639 */ - 0x0000, /* R2640 */ - 0x0000, /* R2641 */ - 0x0000, /* R2642 */ - 0x0000, /* R2643 */ - 0x0000, /* R2644 */ - 0x0000, /* R2645 */ - 0x0000, /* R2646 */ - 0x0000, /* R2647 */ - 0x0000, /* R2648 */ - 0x0000, /* R2649 */ - 0x0000, /* R2650 */ - 0x0000, /* R2651 */ - 0x0000, /* R2652 */ - 0x0000, /* R2653 */ - 0x0000, /* R2654 */ - 0x0000, /* R2655 */ - 0x0000, /* R2656 */ - 0x0000, /* R2657 */ - 0x0000, /* R2658 */ - 0x0000, /* R2659 */ - 0x0000, /* R2660 */ - 0x0000, /* R2661 */ - 0x0000, /* R2662 */ - 0x0000, /* R2663 */ - 0x0000, /* R2664 */ - 0x0000, /* R2665 */ - 0x0000, /* R2666 */ - 0x0000, /* R2667 */ - 0x0000, /* R2668 */ - 0x0000, /* R2669 */ - 0x0000, /* R2670 */ - 0x0000, /* R2671 */ - 0x0000, /* R2672 */ - 0x0000, /* R2673 */ - 0x0000, /* R2674 */ - 0x0000, /* R2675 */ - 0x0000, /* R2676 */ - 0x0000, /* R2677 */ - 0x0000, /* R2678 */ - 0x0000, /* R2679 */ - 0x0000, /* R2680 */ - 0x0000, /* R2681 */ - 0x0000, /* R2682 */ - 0x0000, /* R2683 */ - 0x0000, /* R2684 */ - 0x0000, /* R2685 */ - 0x0000, /* R2686 */ - 0x0000, /* R2687 */ - 0x0000, /* R2688 */ - 0x0000, /* R2689 */ - 0x0000, /* R2690 */ - 0x0000, /* R2691 */ - 0x0000, /* R2692 */ - 0x0000, /* R2693 */ - 0x0000, /* R2694 */ - 0x0000, /* R2695 */ - 0x0000, /* R2696 */ - 0x0000, /* R2697 */ - 0x0000, /* R2698 */ - 0x0000, /* R2699 */ - 0x0000, /* R2700 */ - 0x0000, /* R2701 */ - 0x0000, /* R2702 */ - 0x0000, /* R2703 */ - 0x0000, /* R2704 */ - 0x0000, /* R2705 */ - 0x0000, /* R2706 */ - 0x0000, /* R2707 */ - 0x0000, /* R2708 */ - 0x0000, /* R2709 */ - 0x0000, /* R2710 */ - 0x0000, /* R2711 */ - 0x0000, /* R2712 */ - 0x0000, /* R2713 */ - 0x0000, /* R2714 */ - 0x0000, /* R2715 */ - 0x0000, /* R2716 */ - 0x0000, /* R2717 */ - 0x0000, /* R2718 */ - 0x0000, /* R2719 */ - 0x0000, /* R2720 */ - 0x0000, /* R2721 */ - 0x0000, /* R2722 */ - 0x0000, /* R2723 */ - 0x0000, /* R2724 */ - 0x0000, /* R2725 */ - 0x0000, /* R2726 */ - 0x0000, /* R2727 */ - 0x0000, /* R2728 */ - 0x0000, /* R2729 */ - 0x0000, /* R2730 */ - 0x0000, /* R2731 */ - 0x0000, /* R2732 */ - 0x0000, /* R2733 */ - 0x0000, /* R2734 */ - 0x0000, /* R2735 */ - 0x0000, /* R2736 */ - 0x0000, /* R2737 */ - 0x0000, /* R2738 */ - 0x0000, /* R2739 */ - 0x0000, /* R2740 */ - 0x0000, /* R2741 */ - 0x0000, /* R2742 */ - 0x0000, /* R2743 */ - 0x0000, /* R2744 */ - 0x0000, /* R2745 */ - 0x0000, /* R2746 */ - 0x0000, /* R2747 */ - 0x0000, /* R2748 */ - 0x0000, /* R2749 */ - 0x0000, /* R2750 */ - 0x0000, /* R2751 */ - 0x0000, /* R2752 */ - 0x0000, /* R2753 */ - 0x0000, /* R2754 */ - 0x0000, /* R2755 */ - 0x0000, /* R2756 */ - 0x0000, /* R2757 */ - 0x0000, /* R2758 */ - 0x0000, /* R2759 */ - 0x0000, /* R2760 */ - 0x0000, /* R2761 */ - 0x0000, /* R2762 */ - 0x0000, /* R2763 */ - 0x0000, /* R2764 */ - 0x0000, /* R2765 */ - 0x0000, /* R2766 */ - 0x0000, /* R2767 */ - 0x0000, /* R2768 */ - 0x0000, /* R2769 */ - 0x0000, /* R2770 */ - 0x0000, /* R2771 */ - 0x0000, /* R2772 */ - 0x0000, /* R2773 */ - 0x0000, /* R2774 */ - 0x0000, /* R2775 */ - 0x0000, /* R2776 */ - 0x0000, /* R2777 */ - 0x0000, /* R2778 */ - 0x0000, /* R2779 */ - 0x0000, /* R2780 */ - 0x0000, /* R2781 */ - 0x0000, /* R2782 */ - 0x0000, /* R2783 */ - 0x0000, /* R2784 */ - 0x0000, /* R2785 */ - 0x0000, /* R2786 */ - 0x0000, /* R2787 */ - 0x0000, /* R2788 */ - 0x0000, /* R2789 */ - 0x0000, /* R2790 */ - 0x0000, /* R2791 */ - 0x0000, /* R2792 */ - 0x0000, /* R2793 */ - 0x0000, /* R2794 */ - 0x0000, /* R2795 */ - 0x0000, /* R2796 */ - 0x0000, /* R2797 */ - 0x0000, /* R2798 */ - 0x0000, /* R2799 */ - 0x0000, /* R2800 */ - 0x0000, /* R2801 */ - 0x0000, /* R2802 */ - 0x0000, /* R2803 */ - 0x0000, /* R2804 */ - 0x0000, /* R2805 */ - 0x0000, /* R2806 */ - 0x0000, /* R2807 */ - 0x0000, /* R2808 */ - 0x0000, /* R2809 */ - 0x0000, /* R2810 */ - 0x0000, /* R2811 */ - 0x0000, /* R2812 */ - 0x0000, /* R2813 */ - 0x0000, /* R2814 */ - 0x0000, /* R2815 */ - 0x0000, /* R2816 */ - 0x0000, /* R2817 */ - 0x0000, /* R2818 */ - 0x0000, /* R2819 */ - 0x0000, /* R2820 */ - 0x0000, /* R2821 */ - 0x0000, /* R2822 */ - 0x0000, /* R2823 */ - 0x0000, /* R2824 */ - 0x0000, /* R2825 */ - 0x0000, /* R2826 */ - 0x0000, /* R2827 */ - 0x0000, /* R2828 */ - 0x0000, /* R2829 */ - 0x0000, /* R2830 */ - 0x0000, /* R2831 */ - 0x0000, /* R2832 */ - 0x0000, /* R2833 */ - 0x0000, /* R2834 */ - 0x0000, /* R2835 */ - 0x0000, /* R2836 */ - 0x0000, /* R2837 */ - 0x0000, /* R2838 */ - 0x0000, /* R2839 */ - 0x0000, /* R2840 */ - 0x0000, /* R2841 */ - 0x0000, /* R2842 */ - 0x0000, /* R2843 */ - 0x0000, /* R2844 */ - 0x0000, /* R2845 */ - 0x0000, /* R2846 */ - 0x0000, /* R2847 */ - 0x0000, /* R2848 */ - 0x0000, /* R2849 */ - 0x0000, /* R2850 */ - 0x0000, /* R2851 */ - 0x0000, /* R2852 */ - 0x0000, /* R2853 */ - 0x0000, /* R2854 */ - 0x0000, /* R2855 */ - 0x0000, /* R2856 */ - 0x0000, /* R2857 */ - 0x0000, /* R2858 */ - 0x0000, /* R2859 */ - 0x0000, /* R2860 */ - 0x0000, /* R2861 */ - 0x0000, /* R2862 */ - 0x0000, /* R2863 */ - 0x0000, /* R2864 */ - 0x0000, /* R2865 */ - 0x0000, /* R2866 */ - 0x0000, /* R2867 */ - 0x0000, /* R2868 */ - 0x0000, /* R2869 */ - 0x0000, /* R2870 */ - 0x0000, /* R2871 */ - 0x0000, /* R2872 */ - 0x0000, /* R2873 */ - 0x0000, /* R2874 */ - 0x0000, /* R2875 */ - 0x0000, /* R2876 */ - 0x0000, /* R2877 */ - 0x0000, /* R2878 */ - 0x0000, /* R2879 */ - 0x0000, /* R2880 */ - 0x0000, /* R2881 */ - 0x0000, /* R2882 */ - 0x0000, /* R2883 */ - 0x0000, /* R2884 */ - 0x0000, /* R2885 */ - 0x0000, /* R2886 */ - 0x0000, /* R2887 */ - 0x0000, /* R2888 */ - 0x0000, /* R2889 */ - 0x0000, /* R2890 */ - 0x0000, /* R2891 */ - 0x0000, /* R2892 */ - 0x0000, /* R2893 */ - 0x0000, /* R2894 */ - 0x0000, /* R2895 */ - 0x0000, /* R2896 */ - 0x0000, /* R2897 */ - 0x0000, /* R2898 */ - 0x0000, /* R2899 */ - 0x0000, /* R2900 */ - 0x0000, /* R2901 */ - 0x0000, /* R2902 */ - 0x0000, /* R2903 */ - 0x0000, /* R2904 */ - 0x0000, /* R2905 */ - 0x0000, /* R2906 */ - 0x0000, /* R2907 */ - 0x0000, /* R2908 */ - 0x0000, /* R2909 */ - 0x0000, /* R2910 */ - 0x0000, /* R2911 */ - 0x0000, /* R2912 */ - 0x0000, /* R2913 */ - 0x0000, /* R2914 */ - 0x0000, /* R2915 */ - 0x0000, /* R2916 */ - 0x0000, /* R2917 */ - 0x0000, /* R2918 */ - 0x0000, /* R2919 */ - 0x0000, /* R2920 */ - 0x0000, /* R2921 */ - 0x0000, /* R2922 */ - 0x0000, /* R2923 */ - 0x0000, /* R2924 */ - 0x0000, /* R2925 */ - 0x0000, /* R2926 */ - 0x0000, /* R2927 */ - 0x0000, /* R2928 */ - 0x0000, /* R2929 */ - 0x0000, /* R2930 */ - 0x0000, /* R2931 */ - 0x0000, /* R2932 */ - 0x0000, /* R2933 */ - 0x0000, /* R2934 */ - 0x0000, /* R2935 */ - 0x0000, /* R2936 */ - 0x0000, /* R2937 */ - 0x0000, /* R2938 */ - 0x0000, /* R2939 */ - 0x0000, /* R2940 */ - 0x0000, /* R2941 */ - 0x0000, /* R2942 */ - 0x0000, /* R2943 */ - 0x0000, /* R2944 */ - 0x0000, /* R2945 */ - 0x0000, /* R2946 */ - 0x0000, /* R2947 */ - 0x0000, /* R2948 */ - 0x0000, /* R2949 */ - 0x0000, /* R2950 */ - 0x0000, /* R2951 */ - 0x0000, /* R2952 */ - 0x0000, /* R2953 */ - 0x0000, /* R2954 */ - 0x0000, /* R2955 */ - 0x0000, /* R2956 */ - 0x0000, /* R2957 */ - 0x0000, /* R2958 */ - 0x0000, /* R2959 */ - 0x0000, /* R2960 */ - 0x0000, /* R2961 */ - 0x0000, /* R2962 */ - 0x0000, /* R2963 */ - 0x0000, /* R2964 */ - 0x0000, /* R2965 */ - 0x0000, /* R2966 */ - 0x0000, /* R2967 */ - 0x0000, /* R2968 */ - 0x0000, /* R2969 */ - 0x0000, /* R2970 */ - 0x0000, /* R2971 */ - 0x0000, /* R2972 */ - 0x0000, /* R2973 */ - 0x0000, /* R2974 */ - 0x0000, /* R2975 */ - 0x0000, /* R2976 */ - 0x0000, /* R2977 */ - 0x0000, /* R2978 */ - 0x0000, /* R2979 */ - 0x0000, /* R2980 */ - 0x0000, /* R2981 */ - 0x0000, /* R2982 */ - 0x0000, /* R2983 */ - 0x0000, /* R2984 */ - 0x0000, /* R2985 */ - 0x0000, /* R2986 */ - 0x0000, /* R2987 */ - 0x0000, /* R2988 */ - 0x0000, /* R2989 */ - 0x0000, /* R2990 */ - 0x0000, /* R2991 */ - 0x0000, /* R2992 */ - 0x0000, /* R2993 */ - 0x0000, /* R2994 */ - 0x0000, /* R2995 */ - 0x0000, /* R2996 */ - 0x0000, /* R2997 */ - 0x0000, /* R2998 */ - 0x0000, /* R2999 */ - 0x0000, /* R3000 */ - 0x0000, /* R3001 */ - 0x0000, /* R3002 */ - 0x0000, /* R3003 */ - 0x0000, /* R3004 */ - 0x0000, /* R3005 */ - 0x0000, /* R3006 */ - 0x0000, /* R3007 */ - 0x0000, /* R3008 */ - 0x0000, /* R3009 */ - 0x0000, /* R3010 */ - 0x0000, /* R3011 */ - 0x0000, /* R3012 */ - 0x0000, /* R3013 */ - 0x0000, /* R3014 */ - 0x0000, /* R3015 */ - 0x0000, /* R3016 */ - 0x0000, /* R3017 */ - 0x0000, /* R3018 */ - 0x0000, /* R3019 */ - 0x0000, /* R3020 */ - 0x0000, /* R3021 */ - 0x0000, /* R3022 */ - 0x0000, /* R3023 */ - 0x0000, /* R3024 */ - 0x0000, /* R3025 */ - 0x0000, /* R3026 */ - 0x0000, /* R3027 */ - 0x0000, /* R3028 */ - 0x0000, /* R3029 */ - 0x0000, /* R3030 */ - 0x0000, /* R3031 */ - 0x0000, /* R3032 */ - 0x0000, /* R3033 */ - 0x0000, /* R3034 */ - 0x0000, /* R3035 */ - 0x0000, /* R3036 */ - 0x0000, /* R3037 */ - 0x0000, /* R3038 */ - 0x0000, /* R3039 */ - 0x0000, /* R3040 */ - 0x0000, /* R3041 */ - 0x0000, /* R3042 */ - 0x0000, /* R3043 */ - 0x0000, /* R3044 */ - 0x0000, /* R3045 */ - 0x0000, /* R3046 */ - 0x0000, /* R3047 */ - 0x0000, /* R3048 */ - 0x0000, /* R3049 */ - 0x0000, /* R3050 */ - 0x0000, /* R3051 */ - 0x0000, /* R3052 */ - 0x0000, /* R3053 */ - 0x0000, /* R3054 */ - 0x0000, /* R3055 */ - 0x0000, /* R3056 */ - 0x0000, /* R3057 */ - 0x0000, /* R3058 */ - 0x0000, /* R3059 */ - 0x0000, /* R3060 */ - 0x0000, /* R3061 */ - 0x0000, /* R3062 */ - 0x0000, /* R3063 */ - 0x0000, /* R3064 */ - 0x0000, /* R3065 */ - 0x0000, /* R3066 */ - 0x0000, /* R3067 */ - 0x0000, /* R3068 */ - 0x0000, /* R3069 */ - 0x0000, /* R3070 */ - 0x0000, /* R3071 */ - 0x0000, /* R3072 */ - 0x0000, /* R3073 */ - 0x0000, /* R3074 */ - 0x0000, /* R3075 */ - 0x0000, /* R3076 */ - 0x0000, /* R3077 */ - 0x0000, /* R3078 */ - 0x0000, /* R3079 */ - 0x0000, /* R3080 */ - 0x0000, /* R3081 */ - 0x0000, /* R3082 */ - 0x0000, /* R3083 */ - 0x0000, /* R3084 */ - 0x0000, /* R3085 */ - 0x0000, /* R3086 */ - 0x0000, /* R3087 */ - 0x0000, /* R3088 */ - 0x0000, /* R3089 */ - 0x0000, /* R3090 */ - 0x0000, /* R3091 */ - 0x0000, /* R3092 */ - 0x0000, /* R3093 */ - 0x0000, /* R3094 */ - 0x0000, /* R3095 */ - 0x0000, /* R3096 */ - 0x0000, /* R3097 */ - 0x0000, /* R3098 */ - 0x0000, /* R3099 */ - 0x0000, /* R3100 */ - 0x0000, /* R3101 */ - 0x0000, /* R3102 */ - 0x0000, /* R3103 */ - 0x0000, /* R3104 */ - 0x0000, /* R3105 */ - 0x0000, /* R3106 */ - 0x0000, /* R3107 */ - 0x0000, /* R3108 */ - 0x0000, /* R3109 */ - 0x0000, /* R3110 */ - 0x0000, /* R3111 */ - 0x0000, /* R3112 */ - 0x0000, /* R3113 */ - 0x0000, /* R3114 */ - 0x0000, /* R3115 */ - 0x0000, /* R3116 */ - 0x0000, /* R3117 */ - 0x0000, /* R3118 */ - 0x0000, /* R3119 */ - 0x0000, /* R3120 */ - 0x0000, /* R3121 */ - 0x0000, /* R3122 */ - 0x0000, /* R3123 */ - 0x0000, /* R3124 */ - 0x0000, /* R3125 */ - 0x0000, /* R3126 */ - 0x0000, /* R3127 */ - 0x0000, /* R3128 */ - 0x0000, /* R3129 */ - 0x0000, /* R3130 */ - 0x0000, /* R3131 */ - 0x0000, /* R3132 */ - 0x0000, /* R3133 */ - 0x0000, /* R3134 */ - 0x0000, /* R3135 */ - 0x0000, /* R3136 */ - 0x0000, /* R3137 */ - 0x0000, /* R3138 */ - 0x0000, /* R3139 */ - 0x0000, /* R3140 */ - 0x0000, /* R3141 */ - 0x0000, /* R3142 */ - 0x0000, /* R3143 */ - 0x0000, /* R3144 */ - 0x0000, /* R3145 */ - 0x0000, /* R3146 */ - 0x0000, /* R3147 */ - 0x0000, /* R3148 */ - 0x0000, /* R3149 */ - 0x0000, /* R3150 */ - 0x0000, /* R3151 */ - 0x0000, /* R3152 */ - 0x0000, /* R3153 */ - 0x0000, /* R3154 */ - 0x0000, /* R3155 */ - 0x0000, /* R3156 */ - 0x0000, /* R3157 */ - 0x0000, /* R3158 */ - 0x0000, /* R3159 */ - 0x0000, /* R3160 */ - 0x0000, /* R3161 */ - 0x0000, /* R3162 */ - 0x0000, /* R3163 */ - 0x0000, /* R3164 */ - 0x0000, /* R3165 */ - 0x0000, /* R3166 */ - 0x0000, /* R3167 */ - 0x0000, /* R3168 */ - 0x0000, /* R3169 */ - 0x0000, /* R3170 */ - 0x0000, /* R3171 */ - 0x0000, /* R3172 */ - 0x0000, /* R3173 */ - 0x0000, /* R3174 */ - 0x0000, /* R3175 */ - 0x0000, /* R3176 */ - 0x0000, /* R3177 */ - 0x0000, /* R3178 */ - 0x0000, /* R3179 */ - 0x0000, /* R3180 */ - 0x0000, /* R3181 */ - 0x0000, /* R3182 */ - 0x0000, /* R3183 */ - 0x0000, /* R3184 */ - 0x0000, /* R3185 */ - 0x0000, /* R3186 */ - 0x0000, /* R3187 */ - 0x0000, /* R3188 */ - 0x0000, /* R3189 */ - 0x0000, /* R3190 */ - 0x0000, /* R3191 */ - 0x0000, /* R3192 */ - 0x0000, /* R3193 */ - 0x0000, /* R3194 */ - 0x0000, /* R3195 */ - 0x0000, /* R3196 */ - 0x0000, /* R3197 */ - 0x0000, /* R3198 */ - 0x0000, /* R3199 */ - 0x0000, /* R3200 */ - 0x0000, /* R3201 */ - 0x0000, /* R3202 */ - 0x0000, /* R3203 */ - 0x0000, /* R3204 */ - 0x0000, /* R3205 */ - 0x0000, /* R3206 */ - 0x0000, /* R3207 */ - 0x0000, /* R3208 */ - 0x0000, /* R3209 */ - 0x0000, /* R3210 */ - 0x0000, /* R3211 */ - 0x0000, /* R3212 */ - 0x0000, /* R3213 */ - 0x0000, /* R3214 */ - 0x0000, /* R3215 */ - 0x0000, /* R3216 */ - 0x0000, /* R3217 */ - 0x0000, /* R3218 */ - 0x0000, /* R3219 */ - 0x0000, /* R3220 */ - 0x0000, /* R3221 */ - 0x0000, /* R3222 */ - 0x0000, /* R3223 */ - 0x0000, /* R3224 */ - 0x0000, /* R3225 */ - 0x0000, /* R3226 */ - 0x0000, /* R3227 */ - 0x0000, /* R3228 */ - 0x0000, /* R3229 */ - 0x0000, /* R3230 */ - 0x0000, /* R3231 */ - 0x0000, /* R3232 */ - 0x0000, /* R3233 */ - 0x0000, /* R3234 */ - 0x0000, /* R3235 */ - 0x0000, /* R3236 */ - 0x0000, /* R3237 */ - 0x0000, /* R3238 */ - 0x0000, /* R3239 */ - 0x0000, /* R3240 */ - 0x0000, /* R3241 */ - 0x0000, /* R3242 */ - 0x0000, /* R3243 */ - 0x0000, /* R3244 */ - 0x0000, /* R3245 */ - 0x0000, /* R3246 */ - 0x0000, /* R3247 */ - 0x0000, /* R3248 */ - 0x0000, /* R3249 */ - 0x0000, /* R3250 */ - 0x0000, /* R3251 */ - 0x0000, /* R3252 */ - 0x0000, /* R3253 */ - 0x0000, /* R3254 */ - 0x0000, /* R3255 */ - 0x0000, /* R3256 */ - 0x0000, /* R3257 */ - 0x0000, /* R3258 */ - 0x0000, /* R3259 */ - 0x0000, /* R3260 */ - 0x0000, /* R3261 */ - 0x0000, /* R3262 */ - 0x0000, /* R3263 */ - 0x0000, /* R3264 */ - 0x0000, /* R3265 */ - 0x0000, /* R3266 */ - 0x0000, /* R3267 */ - 0x0000, /* R3268 */ - 0x0000, /* R3269 */ - 0x0000, /* R3270 */ - 0x0000, /* R3271 */ - 0x0000, /* R3272 */ - 0x0000, /* R3273 */ - 0x0000, /* R3274 */ - 0x0000, /* R3275 */ - 0x0000, /* R3276 */ - 0x0000, /* R3277 */ - 0x0000, /* R3278 */ - 0x0000, /* R3279 */ - 0x0000, /* R3280 */ - 0x0000, /* R3281 */ - 0x0000, /* R3282 */ - 0x0000, /* R3283 */ - 0x0000, /* R3284 */ - 0x0000, /* R3285 */ - 0x0000, /* R3286 */ - 0x0000, /* R3287 */ - 0x0000, /* R3288 */ - 0x0000, /* R3289 */ - 0x0000, /* R3290 */ - 0x0000, /* R3291 */ - 0x0000, /* R3292 */ - 0x0000, /* R3293 */ - 0x0000, /* R3294 */ - 0x0000, /* R3295 */ - 0x0000, /* R3296 */ - 0x0000, /* R3297 */ - 0x0000, /* R3298 */ - 0x0000, /* R3299 */ - 0x0000, /* R3300 */ - 0x0000, /* R3301 */ - 0x0000, /* R3302 */ - 0x0000, /* R3303 */ - 0x0000, /* R3304 */ - 0x0000, /* R3305 */ - 0x0000, /* R3306 */ - 0x0000, /* R3307 */ - 0x0000, /* R3308 */ - 0x0000, /* R3309 */ - 0x0000, /* R3310 */ - 0x0000, /* R3311 */ - 0x0000, /* R3312 */ - 0x0000, /* R3313 */ - 0x0000, /* R3314 */ - 0x0000, /* R3315 */ - 0x0000, /* R3316 */ - 0x0000, /* R3317 */ - 0x0000, /* R3318 */ - 0x0000, /* R3319 */ - 0x0000, /* R3320 */ - 0x0000, /* R3321 */ - 0x0000, /* R3322 */ - 0x0000, /* R3323 */ - 0x0000, /* R3324 */ - 0x0000, /* R3325 */ - 0x0000, /* R3326 */ - 0x0000, /* R3327 */ - 0x0000, /* R3328 */ - 0x0000, /* R3329 */ - 0x0000, /* R3330 */ - 0x0000, /* R3331 */ - 0x0000, /* R3332 */ - 0x0000, /* R3333 */ - 0x0000, /* R3334 */ - 0x0000, /* R3335 */ - 0x0000, /* R3336 */ - 0x0000, /* R3337 */ - 0x0000, /* R3338 */ - 0x0000, /* R3339 */ - 0x0000, /* R3340 */ - 0x0000, /* R3341 */ - 0x0000, /* R3342 */ - 0x0000, /* R3343 */ - 0x0000, /* R3344 */ - 0x0000, /* R3345 */ - 0x0000, /* R3346 */ - 0x0000, /* R3347 */ - 0x0000, /* R3348 */ - 0x0000, /* R3349 */ - 0x0000, /* R3350 */ - 0x0000, /* R3351 */ - 0x0000, /* R3352 */ - 0x0000, /* R3353 */ - 0x0000, /* R3354 */ - 0x0000, /* R3355 */ - 0x0000, /* R3356 */ - 0x0000, /* R3357 */ - 0x0000, /* R3358 */ - 0x0000, /* R3359 */ - 0x0000, /* R3360 */ - 0x0000, /* R3361 */ - 0x0000, /* R3362 */ - 0x0000, /* R3363 */ - 0x0000, /* R3364 */ - 0x0000, /* R3365 */ - 0x0000, /* R3366 */ - 0x0000, /* R3367 */ - 0x0000, /* R3368 */ - 0x0000, /* R3369 */ - 0x0000, /* R3370 */ - 0x0000, /* R3371 */ - 0x0000, /* R3372 */ - 0x0000, /* R3373 */ - 0x0000, /* R3374 */ - 0x0000, /* R3375 */ - 0x0000, /* R3376 */ - 0x0000, /* R3377 */ - 0x0000, /* R3378 */ - 0x0000, /* R3379 */ - 0x0000, /* R3380 */ - 0x0000, /* R3381 */ - 0x0000, /* R3382 */ - 0x0000, /* R3383 */ - 0x0000, /* R3384 */ - 0x0000, /* R3385 */ - 0x0000, /* R3386 */ - 0x0000, /* R3387 */ - 0x0000, /* R3388 */ - 0x0000, /* R3389 */ - 0x0000, /* R3390 */ - 0x0000, /* R3391 */ - 0x0000, /* R3392 */ - 0x0000, /* R3393 */ - 0x0000, /* R3394 */ - 0x0000, /* R3395 */ - 0x0000, /* R3396 */ - 0x0000, /* R3397 */ - 0x0000, /* R3398 */ - 0x0000, /* R3399 */ - 0x0000, /* R3400 */ - 0x0000, /* R3401 */ - 0x0000, /* R3402 */ - 0x0000, /* R3403 */ - 0x0000, /* R3404 */ - 0x0000, /* R3405 */ - 0x0000, /* R3406 */ - 0x0000, /* R3407 */ - 0x0000, /* R3408 */ - 0x0000, /* R3409 */ - 0x0000, /* R3410 */ - 0x0000, /* R3411 */ - 0x0000, /* R3412 */ - 0x0000, /* R3413 */ - 0x0000, /* R3414 */ - 0x0000, /* R3415 */ - 0x0000, /* R3416 */ - 0x0000, /* R3417 */ - 0x0000, /* R3418 */ - 0x0000, /* R3419 */ - 0x0000, /* R3420 */ - 0x0000, /* R3421 */ - 0x0000, /* R3422 */ - 0x0000, /* R3423 */ - 0x0000, /* R3424 */ - 0x0000, /* R3425 */ - 0x0000, /* R3426 */ - 0x0000, /* R3427 */ - 0x0000, /* R3428 */ - 0x0000, /* R3429 */ - 0x0000, /* R3430 */ - 0x0000, /* R3431 */ - 0x0000, /* R3432 */ - 0x0000, /* R3433 */ - 0x0000, /* R3434 */ - 0x0000, /* R3435 */ - 0x0000, /* R3436 */ - 0x0000, /* R3437 */ - 0x0000, /* R3438 */ - 0x0000, /* R3439 */ - 0x0000, /* R3440 */ - 0x0000, /* R3441 */ - 0x0000, /* R3442 */ - 0x0000, /* R3443 */ - 0x0000, /* R3444 */ - 0x0000, /* R3445 */ - 0x0000, /* R3446 */ - 0x0000, /* R3447 */ - 0x0000, /* R3448 */ - 0x0000, /* R3449 */ - 0x0000, /* R3450 */ - 0x0000, /* R3451 */ - 0x0000, /* R3452 */ - 0x0000, /* R3453 */ - 0x0000, /* R3454 */ - 0x0000, /* R3455 */ - 0x0000, /* R3456 */ - 0x0000, /* R3457 */ - 0x0000, /* R3458 */ - 0x0000, /* R3459 */ - 0x0000, /* R3460 */ - 0x0000, /* R3461 */ - 0x0000, /* R3462 */ - 0x0000, /* R3463 */ - 0x0000, /* R3464 */ - 0x0000, /* R3465 */ - 0x0000, /* R3466 */ - 0x0000, /* R3467 */ - 0x0000, /* R3468 */ - 0x0000, /* R3469 */ - 0x0000, /* R3470 */ - 0x0000, /* R3471 */ - 0x0000, /* R3472 */ - 0x0000, /* R3473 */ - 0x0000, /* R3474 */ - 0x0000, /* R3475 */ - 0x0000, /* R3476 */ - 0x0000, /* R3477 */ - 0x0000, /* R3478 */ - 0x0000, /* R3479 */ - 0x0000, /* R3480 */ - 0x0000, /* R3481 */ - 0x0000, /* R3482 */ - 0x0000, /* R3483 */ - 0x0000, /* R3484 */ - 0x0000, /* R3485 */ - 0x0000, /* R3486 */ - 0x0000, /* R3487 */ - 0x0000, /* R3488 */ - 0x0000, /* R3489 */ - 0x0000, /* R3490 */ - 0x0000, /* R3491 */ - 0x0000, /* R3492 */ - 0x0000, /* R3493 */ - 0x0000, /* R3494 */ - 0x0000, /* R3495 */ - 0x0000, /* R3496 */ - 0x0000, /* R3497 */ - 0x0000, /* R3498 */ - 0x0000, /* R3499 */ - 0x0000, /* R3500 */ - 0x0000, /* R3501 */ - 0x0000, /* R3502 */ - 0x0000, /* R3503 */ - 0x0000, /* R3504 */ - 0x0000, /* R3505 */ - 0x0000, /* R3506 */ - 0x0000, /* R3507 */ - 0x0000, /* R3508 */ - 0x0000, /* R3509 */ - 0x0000, /* R3510 */ - 0x0000, /* R3511 */ - 0x0000, /* R3512 */ - 0x0000, /* R3513 */ - 0x0000, /* R3514 */ - 0x0000, /* R3515 */ - 0x0000, /* R3516 */ - 0x0000, /* R3517 */ - 0x0000, /* R3518 */ - 0x0000, /* R3519 */ - 0x0000, /* R3520 */ - 0x0000, /* R3521 */ - 0x0000, /* R3522 */ - 0x0000, /* R3523 */ - 0x0000, /* R3524 */ - 0x0000, /* R3525 */ - 0x0000, /* R3526 */ - 0x0000, /* R3527 */ - 0x0000, /* R3528 */ - 0x0000, /* R3529 */ - 0x0000, /* R3530 */ - 0x0000, /* R3531 */ - 0x0000, /* R3532 */ - 0x0000, /* R3533 */ - 0x0000, /* R3534 */ - 0x0000, /* R3535 */ - 0x0000, /* R3536 */ - 0x0000, /* R3537 */ - 0x0000, /* R3538 */ - 0x0000, /* R3539 */ - 0x0000, /* R3540 */ - 0x0000, /* R3541 */ - 0x0000, /* R3542 */ - 0x0000, /* R3543 */ - 0x0000, /* R3544 */ - 0x0000, /* R3545 */ - 0x0000, /* R3546 */ - 0x0000, /* R3547 */ - 0x0000, /* R3548 */ - 0x0000, /* R3549 */ - 0x0000, /* R3550 */ - 0x0000, /* R3551 */ - 0x0000, /* R3552 */ - 0x0000, /* R3553 */ - 0x0000, /* R3554 */ - 0x0000, /* R3555 */ - 0x0000, /* R3556 */ - 0x0000, /* R3557 */ - 0x0000, /* R3558 */ - 0x0000, /* R3559 */ - 0x0000, /* R3560 */ - 0x0000, /* R3561 */ - 0x0000, /* R3562 */ - 0x0000, /* R3563 */ - 0x0000, /* R3564 */ - 0x0000, /* R3565 */ - 0x0000, /* R3566 */ - 0x0000, /* R3567 */ - 0x0000, /* R3568 */ - 0x0000, /* R3569 */ - 0x0000, /* R3570 */ - 0x0000, /* R3571 */ - 0x0000, /* R3572 */ - 0x0000, /* R3573 */ - 0x0000, /* R3574 */ - 0x0000, /* R3575 */ - 0x0000, /* R3576 */ - 0x0000, /* R3577 */ - 0x0000, /* R3578 */ - 0x0000, /* R3579 */ - 0x0000, /* R3580 */ - 0x0000, /* R3581 */ - 0x0000, /* R3582 */ - 0x0000, /* R3583 */ - 0x0000, /* R3584 */ - 0x0000, /* R3585 */ - 0x0000, /* R3586 */ - 0x0000, /* R3587 */ - 0x0000, /* R3588 */ - 0x0000, /* R3589 */ - 0x0000, /* R3590 */ - 0x0000, /* R3591 */ - 0x0000, /* R3592 */ - 0x0000, /* R3593 */ - 0x0000, /* R3594 */ - 0x0000, /* R3595 */ - 0x0000, /* R3596 */ - 0x0000, /* R3597 */ - 0x0000, /* R3598 */ - 0x0000, /* R3599 */ - 0x0000, /* R3600 */ - 0x0000, /* R3601 */ - 0x0000, /* R3602 */ - 0x0000, /* R3603 */ - 0x0000, /* R3604 */ - 0x0000, /* R3605 */ - 0x0000, /* R3606 */ - 0x0000, /* R3607 */ - 0x0000, /* R3608 */ - 0x0000, /* R3609 */ - 0x0000, /* R3610 */ - 0x0000, /* R3611 */ - 0x0000, /* R3612 */ - 0x0000, /* R3613 */ - 0x0000, /* R3614 */ - 0x0000, /* R3615 */ - 0x0000, /* R3616 */ - 0x0000, /* R3617 */ - 0x0000, /* R3618 */ - 0x0000, /* R3619 */ - 0x0000, /* R3620 */ - 0x0000, /* R3621 */ - 0x0000, /* R3622 */ - 0x0000, /* R3623 */ - 0x0000, /* R3624 */ - 0x0000, /* R3625 */ - 0x0000, /* R3626 */ - 0x0000, /* R3627 */ - 0x0000, /* R3628 */ - 0x0000, /* R3629 */ - 0x0000, /* R3630 */ - 0x0000, /* R3631 */ - 0x0000, /* R3632 */ - 0x0000, /* R3633 */ - 0x0000, /* R3634 */ - 0x0000, /* R3635 */ - 0x0000, /* R3636 */ - 0x0000, /* R3637 */ - 0x0000, /* R3638 */ - 0x0000, /* R3639 */ - 0x0000, /* R3640 */ - 0x0000, /* R3641 */ - 0x0000, /* R3642 */ - 0x0000, /* R3643 */ - 0x0000, /* R3644 */ - 0x0000, /* R3645 */ - 0x0000, /* R3646 */ - 0x0000, /* R3647 */ - 0x0000, /* R3648 */ - 0x0000, /* R3649 */ - 0x0000, /* R3650 */ - 0x0000, /* R3651 */ - 0x0000, /* R3652 */ - 0x0000, /* R3653 */ - 0x0000, /* R3654 */ - 0x0000, /* R3655 */ - 0x0000, /* R3656 */ - 0x0000, /* R3657 */ - 0x0000, /* R3658 */ - 0x0000, /* R3659 */ - 0x0000, /* R3660 */ - 0x0000, /* R3661 */ - 0x0000, /* R3662 */ - 0x0000, /* R3663 */ - 0x0000, /* R3664 */ - 0x0000, /* R3665 */ - 0x0000, /* R3666 */ - 0x0000, /* R3667 */ - 0x0000, /* R3668 */ - 0x0000, /* R3669 */ - 0x0000, /* R3670 */ - 0x0000, /* R3671 */ - 0x0000, /* R3672 */ - 0x0000, /* R3673 */ - 0x0000, /* R3674 */ - 0x0000, /* R3675 */ - 0x0000, /* R3676 */ - 0x0000, /* R3677 */ - 0x0000, /* R3678 */ - 0x0000, /* R3679 */ - 0x0000, /* R3680 */ - 0x0000, /* R3681 */ - 0x0000, /* R3682 */ - 0x0000, /* R3683 */ - 0x0000, /* R3684 */ - 0x0000, /* R3685 */ - 0x0000, /* R3686 */ - 0x0000, /* R3687 */ - 0x0000, /* R3688 */ - 0x0000, /* R3689 */ - 0x0000, /* R3690 */ - 0x0000, /* R3691 */ - 0x0000, /* R3692 */ - 0x0000, /* R3693 */ - 0x0000, /* R3694 */ - 0x0000, /* R3695 */ - 0x0000, /* R3696 */ - 0x0000, /* R3697 */ - 0x0000, /* R3698 */ - 0x0000, /* R3699 */ - 0x0000, /* R3700 */ - 0x0000, /* R3701 */ - 0x0000, /* R3702 */ - 0x0000, /* R3703 */ - 0x0000, /* R3704 */ - 0x0000, /* R3705 */ - 0x0000, /* R3706 */ - 0x0000, /* R3707 */ - 0x0000, /* R3708 */ - 0x0000, /* R3709 */ - 0x0000, /* R3710 */ - 0x0000, /* R3711 */ - 0x0000, /* R3712 */ - 0x0000, /* R3713 */ - 0x0000, /* R3714 */ - 0x0000, /* R3715 */ - 0x0000, /* R3716 */ - 0x0000, /* R3717 */ - 0x0000, /* R3718 */ - 0x0000, /* R3719 */ - 0x0000, /* R3720 */ - 0x0000, /* R3721 */ - 0x0000, /* R3722 */ - 0x0000, /* R3723 */ - 0x0000, /* R3724 */ - 0x0000, /* R3725 */ - 0x0000, /* R3726 */ - 0x0000, /* R3727 */ - 0x0000, /* R3728 */ - 0x0000, /* R3729 */ - 0x0000, /* R3730 */ - 0x0000, /* R3731 */ - 0x0000, /* R3732 */ - 0x0000, /* R3733 */ - 0x0000, /* R3734 */ - 0x0000, /* R3735 */ - 0x0000, /* R3736 */ - 0x0000, /* R3737 */ - 0x0000, /* R3738 */ - 0x0000, /* R3739 */ - 0x0000, /* R3740 */ - 0x0000, /* R3741 */ - 0x0000, /* R3742 */ - 0x0000, /* R3743 */ - 0x0000, /* R3744 */ - 0x0000, /* R3745 */ - 0x0000, /* R3746 */ - 0x0000, /* R3747 */ - 0x0000, /* R3748 */ - 0x0000, /* R3749 */ - 0x0000, /* R3750 */ - 0x0000, /* R3751 */ - 0x0000, /* R3752 */ - 0x0000, /* R3753 */ - 0x0000, /* R3754 */ - 0x0000, /* R3755 */ - 0x0000, /* R3756 */ - 0x0000, /* R3757 */ - 0x0000, /* R3758 */ - 0x0000, /* R3759 */ - 0x0000, /* R3760 */ - 0x0000, /* R3761 */ - 0x0000, /* R3762 */ - 0x0000, /* R3763 */ - 0x0000, /* R3764 */ - 0x0000, /* R3765 */ - 0x0000, /* R3766 */ - 0x0000, /* R3767 */ - 0x0000, /* R3768 */ - 0x0000, /* R3769 */ - 0x0000, /* R3770 */ - 0x0000, /* R3771 */ - 0x0000, /* R3772 */ - 0x0000, /* R3773 */ - 0x0000, /* R3774 */ - 0x0000, /* R3775 */ - 0x0000, /* R3776 */ - 0x0000, /* R3777 */ - 0x0000, /* R3778 */ - 0x0000, /* R3779 */ - 0x0000, /* R3780 */ - 0x0000, /* R3781 */ - 0x0000, /* R3782 */ - 0x0000, /* R3783 */ - 0x0000, /* R3784 */ - 0x0000, /* R3785 */ - 0x0000, /* R3786 */ - 0x0000, /* R3787 */ - 0x0000, /* R3788 */ - 0x0000, /* R3789 */ - 0x0000, /* R3790 */ - 0x0000, /* R3791 */ - 0x0000, /* R3792 */ - 0x0000, /* R3793 */ - 0x0000, /* R3794 */ - 0x0000, /* R3795 */ - 0x0000, /* R3796 */ - 0x0000, /* R3797 */ - 0x0000, /* R3798 */ - 0x0000, /* R3799 */ - 0x0000, /* R3800 */ - 0x0000, /* R3801 */ - 0x0000, /* R3802 */ - 0x0000, /* R3803 */ - 0x0000, /* R3804 */ - 0x0000, /* R3805 */ - 0x0000, /* R3806 */ - 0x0000, /* R3807 */ - 0x0000, /* R3808 */ - 0x0000, /* R3809 */ - 0x0000, /* R3810 */ - 0x0000, /* R3811 */ - 0x0000, /* R3812 */ - 0x0000, /* R3813 */ - 0x0000, /* R3814 */ - 0x0000, /* R3815 */ - 0x0000, /* R3816 */ - 0x0000, /* R3817 */ - 0x0000, /* R3818 */ - 0x0000, /* R3819 */ - 0x0000, /* R3820 */ - 0x0000, /* R3821 */ - 0x0000, /* R3822 */ - 0x0000, /* R3823 */ - 0x0000, /* R3824 */ - 0x0000, /* R3825 */ - 0x0000, /* R3826 */ - 0x0000, /* R3827 */ - 0x0000, /* R3828 */ - 0x0000, /* R3829 */ - 0x0000, /* R3830 */ - 0x0000, /* R3831 */ - 0x0000, /* R3832 */ - 0x0000, /* R3833 */ - 0x0000, /* R3834 */ - 0x0000, /* R3835 */ - 0x0000, /* R3836 */ - 0x0000, /* R3837 */ - 0x0000, /* R3838 */ - 0x0000, /* R3839 */ - 0x0000, /* R3840 */ - 0x0000, /* R3841 */ - 0x0000, /* R3842 */ - 0x0000, /* R3843 */ - 0x0000, /* R3844 */ - 0x0000, /* R3845 */ - 0x0000, /* R3846 */ - 0x0000, /* R3847 */ - 0x0000, /* R3848 */ - 0x0000, /* R3849 */ - 0x0000, /* R3850 */ - 0x0000, /* R3851 */ - 0x0000, /* R3852 */ - 0x0000, /* R3853 */ - 0x0000, /* R3854 */ - 0x0000, /* R3855 */ - 0x0000, /* R3856 */ - 0x0000, /* R3857 */ - 0x0000, /* R3858 */ - 0x0000, /* R3859 */ - 0x0000, /* R3860 */ - 0x0000, /* R3861 */ - 0x0000, /* R3862 */ - 0x0000, /* R3863 */ - 0x0000, /* R3864 */ - 0x0000, /* R3865 */ - 0x0000, /* R3866 */ - 0x0000, /* R3867 */ - 0x0000, /* R3868 */ - 0x0000, /* R3869 */ - 0x0000, /* R3870 */ - 0x0000, /* R3871 */ - 0x0000, /* R3872 */ - 0x0000, /* R3873 */ - 0x0000, /* R3874 */ - 0x0000, /* R3875 */ - 0x0000, /* R3876 */ - 0x0000, /* R3877 */ - 0x0000, /* R3878 */ - 0x0000, /* R3879 */ - 0x0000, /* R3880 */ - 0x0000, /* R3881 */ - 0x0000, /* R3882 */ - 0x0000, /* R3883 */ - 0x0000, /* R3884 */ - 0x0000, /* R3885 */ - 0x0000, /* R3886 */ - 0x0000, /* R3887 */ - 0x0000, /* R3888 */ - 0x0000, /* R3889 */ - 0x0000, /* R3890 */ - 0x0000, /* R3891 */ - 0x0000, /* R3892 */ - 0x0000, /* R3893 */ - 0x0000, /* R3894 */ - 0x0000, /* R3895 */ - 0x0000, /* R3896 */ - 0x0000, /* R3897 */ - 0x0000, /* R3898 */ - 0x0000, /* R3899 */ - 0x0000, /* R3900 */ - 0x0000, /* R3901 */ - 0x0000, /* R3902 */ - 0x0000, /* R3903 */ - 0x0000, /* R3904 */ - 0x0000, /* R3905 */ - 0x0000, /* R3906 */ - 0x0000, /* R3907 */ - 0x0000, /* R3908 */ - 0x0000, /* R3909 */ - 0x0000, /* R3910 */ - 0x0000, /* R3911 */ - 0x0000, /* R3912 */ - 0x0000, /* R3913 */ - 0x0000, /* R3914 */ - 0x0000, /* R3915 */ - 0x0000, /* R3916 */ - 0x0000, /* R3917 */ - 0x0000, /* R3918 */ - 0x0000, /* R3919 */ - 0x0000, /* R3920 */ - 0x0000, /* R3921 */ - 0x0000, /* R3922 */ - 0x0000, /* R3923 */ - 0x0000, /* R3924 */ - 0x0000, /* R3925 */ - 0x0000, /* R3926 */ - 0x0000, /* R3927 */ - 0x0000, /* R3928 */ - 0x0000, /* R3929 */ - 0x0000, /* R3930 */ - 0x0000, /* R3931 */ - 0x0000, /* R3932 */ - 0x0000, /* R3933 */ - 0x0000, /* R3934 */ - 0x0000, /* R3935 */ - 0x0000, /* R3936 */ - 0x0000, /* R3937 */ - 0x0000, /* R3938 */ - 0x0000, /* R3939 */ - 0x0000, /* R3940 */ - 0x0000, /* R3941 */ - 0x0000, /* R3942 */ - 0x0000, /* R3943 */ - 0x0000, /* R3944 */ - 0x0000, /* R3945 */ - 0x0000, /* R3946 */ - 0x0000, /* R3947 */ - 0x0000, /* R3948 */ - 0x0000, /* R3949 */ - 0x0000, /* R3950 */ - 0x0000, /* R3951 */ - 0x0000, /* R3952 */ - 0x0000, /* R3953 */ - 0x0000, /* R3954 */ - 0x0000, /* R3955 */ - 0x0000, /* R3956 */ - 0x0000, /* R3957 */ - 0x0000, /* R3958 */ - 0x0000, /* R3959 */ - 0x0000, /* R3960 */ - 0x0000, /* R3961 */ - 0x0000, /* R3962 */ - 0x0000, /* R3963 */ - 0x0000, /* R3964 */ - 0x0000, /* R3965 */ - 0x0000, /* R3966 */ - 0x0000, /* R3967 */ - 0x0000, /* R3968 */ - 0x0000, /* R3969 */ - 0x0000, /* R3970 */ - 0x0000, /* R3971 */ - 0x0000, /* R3972 */ - 0x0000, /* R3973 */ - 0x0000, /* R3974 */ - 0x0000, /* R3975 */ - 0x0000, /* R3976 */ - 0x0000, /* R3977 */ - 0x0000, /* R3978 */ - 0x0000, /* R3979 */ - 0x0000, /* R3980 */ - 0x0000, /* R3981 */ - 0x0000, /* R3982 */ - 0x0000, /* R3983 */ - 0x0000, /* R3984 */ - 0x0000, /* R3985 */ - 0x0000, /* R3986 */ - 0x0000, /* R3987 */ - 0x0000, /* R3988 */ - 0x0000, /* R3989 */ - 0x0000, /* R3990 */ - 0x0000, /* R3991 */ - 0x0000, /* R3992 */ - 0x0000, /* R3993 */ - 0x0000, /* R3994 */ - 0x0000, /* R3995 */ - 0x0000, /* R3996 */ - 0x0000, /* R3997 */ - 0x0000, /* R3998 */ - 0x0000, /* R3999 */ - 0x0000, /* R4000 */ - 0x0000, /* R4001 */ - 0x0000, /* R4002 */ - 0x0000, /* R4003 */ - 0x0000, /* R4004 */ - 0x0000, /* R4005 */ - 0x0000, /* R4006 */ - 0x0000, /* R4007 */ - 0x0000, /* R4008 */ - 0x0000, /* R4009 */ - 0x0000, /* R4010 */ - 0x0000, /* R4011 */ - 0x0000, /* R4012 */ - 0x0000, /* R4013 */ - 0x0000, /* R4014 */ - 0x0000, /* R4015 */ - 0x0000, /* R4016 */ - 0x0000, /* R4017 */ - 0x0000, /* R4018 */ - 0x0000, /* R4019 */ - 0x0000, /* R4020 */ - 0x0000, /* R4021 */ - 0x0000, /* R4022 */ - 0x0000, /* R4023 */ - 0x0000, /* R4024 */ - 0x0000, /* R4025 */ - 0x0000, /* R4026 */ - 0x0000, /* R4027 */ - 0x0000, /* R4028 */ - 0x0000, /* R4029 */ - 0x0000, /* R4030 */ - 0x0000, /* R4031 */ - 0x0000, /* R4032 */ - 0x0000, /* R4033 */ - 0x0000, /* R4034 */ - 0x0000, /* R4035 */ - 0x0000, /* R4036 */ - 0x0000, /* R4037 */ - 0x0000, /* R4038 */ - 0x0000, /* R4039 */ - 0x0000, /* R4040 */ - 0x0000, /* R4041 */ - 0x0000, /* R4042 */ - 0x0000, /* R4043 */ - 0x0000, /* R4044 */ - 0x0000, /* R4045 */ - 0x0000, /* R4046 */ - 0x0000, /* R4047 */ - 0x0000, /* R4048 */ - 0x0000, /* R4049 */ - 0x0000, /* R4050 */ - 0x0000, /* R4051 */ - 0x0000, /* R4052 */ - 0x0000, /* R4053 */ - 0x0000, /* R4054 */ - 0x0000, /* R4055 */ - 0x0000, /* R4056 */ - 0x0000, /* R4057 */ - 0x0000, /* R4058 */ - 0x0000, /* R4059 */ - 0x0000, /* R4060 */ - 0x0000, /* R4061 */ - 0x0000, /* R4062 */ - 0x0000, /* R4063 */ - 0x0000, /* R4064 */ - 0x0000, /* R4065 */ - 0x0000, /* R4066 */ - 0x0000, /* R4067 */ - 0x0000, /* R4068 */ - 0x0000, /* R4069 */ - 0x0000, /* R4070 */ - 0x0000, /* R4071 */ - 0x0000, /* R4072 */ - 0x0000, /* R4073 */ - 0x0000, /* R4074 */ - 0x0000, /* R4075 */ - 0x0000, /* R4076 */ - 0x0000, /* R4077 */ - 0x0000, /* R4078 */ - 0x0000, /* R4079 */ - 0x0000, /* R4080 */ - 0x0000, /* R4081 */ - 0x0000, /* R4082 */ - 0x0000, /* R4083 */ - 0x0000, /* R4084 */ - 0x0000, /* R4085 */ - 0x0000, /* R4086 */ - 0x0000, /* R4087 */ - 0x0000, /* R4088 */ - 0x0000, /* R4089 */ - 0x0000, /* R4090 */ - 0x0000, /* R4091 */ - 0x0000, /* R4092 */ - 0x0000, /* R4093 */ - 0x0000, /* R4094 */ - 0x0000, /* R4095 */ - 0x001C, /* R4096 - Write Sequencer 0 */ - 0x0003, /* R4097 - Write Sequencer 1 */ - 0x0103, /* R4098 - Write Sequencer 2 */ - 0x0000, /* R4099 - Write Sequencer 3 */ - 0x0019, /* R4100 - Write Sequencer 4 */ - 0x0007, /* R4101 - Write Sequencer 5 */ - 0x0206, /* R4102 - Write Sequencer 6 */ - 0x0000, /* R4103 - Write Sequencer 7 */ - 0x0048, /* R4104 - Write Sequencer 8 */ - 0x0001, /* R4105 - Write Sequencer 9 */ - 0x0000, /* R4106 - Write Sequencer 10 */ - 0x0006, /* R4107 - Write Sequencer 11 */ - 0x001A, /* R4108 - Write Sequencer 12 */ - 0x000F, /* R4109 - Write Sequencer 13 */ - 0x0305, /* R4110 - Write Sequencer 14 */ - 0x0000, /* R4111 - Write Sequencer 15 */ - 0x0045, /* R4112 - Write Sequencer 16 */ - 0x0011, /* R4113 - Write Sequencer 17 */ - 0x0400, /* R4114 - Write Sequencer 18 */ - 0x0000, /* R4115 - Write Sequencer 19 */ - 0x0045, /* R4116 - Write Sequencer 20 */ - 0x0019, /* R4117 - Write Sequencer 21 */ - 0x0401, /* R4118 - Write Sequencer 22 */ - 0x0000, /* R4119 - Write Sequencer 23 */ - 0x0002, /* R4120 - Write Sequencer 24 */ - 0x0030, /* R4121 - Write Sequencer 25 */ - 0x0600, /* R4122 - Write Sequencer 26 */ - 0x0000, /* R4123 - Write Sequencer 27 */ - 0x0003, /* R4124 - Write Sequencer 28 */ - 0x0030, /* R4125 - Write Sequencer 29 */ - 0x0600, /* R4126 - Write Sequencer 30 */ - 0x0000, /* R4127 - Write Sequencer 31 */ - 0x0003, /* R4128 - Write Sequencer 32 */ - 0x0001, /* R4129 - Write Sequencer 33 */ - 0x0008, /* R4130 - Write Sequencer 34 */ - 0x0000, /* R4131 - Write Sequencer 35 */ - 0x003D, /* R4132 - Write Sequencer 36 */ - 0x0033, /* R4133 - Write Sequencer 37 */ - 0x0502, /* R4134 - Write Sequencer 38 */ - 0x000A, /* R4135 - Write Sequencer 39 */ - 0x00FE, /* R4136 - Write Sequencer 40 */ - 0x0000, /* R4137 - Write Sequencer 41 */ - 0x0000, /* R4138 - Write Sequencer 42 */ - 0x0000, /* R4139 - Write Sequencer 43 */ - 0x0007, /* R4140 - Write Sequencer 44 */ - 0x0000, /* R4141 - Write Sequencer 45 */ - 0x0102, /* R4142 - Write Sequencer 46 */ - 0x0000, /* R4143 - Write Sequencer 47 */ - 0x0045, /* R4144 - Write Sequencer 48 */ - 0x001D, /* R4145 - Write Sequencer 49 */ - 0x0402, /* R4146 - Write Sequencer 50 */ - 0x0000, /* R4147 - Write Sequencer 51 */ - 0x0045, /* R4148 - Write Sequencer 52 */ - 0x001F, /* R4149 - Write Sequencer 53 */ - 0x0403, /* R4150 - Write Sequencer 54 */ - 0x0000, /* R4151 - Write Sequencer 55 */ - 0x00FE, /* R4152 - Write Sequencer 56 */ - 0x0000, /* R4153 - Write Sequencer 57 */ - 0x0000, /* R4154 - Write Sequencer 58 */ - 0x0000, /* R4155 - Write Sequencer 59 */ - 0x0005, /* R4156 - Write Sequencer 60 */ - 0x0000, /* R4157 - Write Sequencer 61 */ - 0x0003, /* R4158 - Write Sequencer 62 */ - 0x0107, /* R4159 - Write Sequencer 63 */ - 0x00FE, /* R4160 - Write Sequencer 64 */ - 0x0000, /* R4161 - Write Sequencer 65 */ - 0x0000, /* R4162 - Write Sequencer 66 */ - 0x0000, /* R4163 - Write Sequencer 67 */ - 0x00FE, /* R4164 - Write Sequencer 68 */ - 0x0000, /* R4165 - Write Sequencer 69 */ - 0x0000, /* R4166 - Write Sequencer 70 */ - 0x0000, /* R4167 - Write Sequencer 71 */ - 0x0020, /* R4168 - Write Sequencer 72 */ - 0x0007, /* R4169 - Write Sequencer 73 */ - 0x0203, /* R4170 - Write Sequencer 74 */ - 0x0000, /* R4171 - Write Sequencer 75 */ - 0x0021, /* R4172 - Write Sequencer 76 */ - 0x0007, /* R4173 - Write Sequencer 77 */ - 0x0203, /* R4174 - Write Sequencer 78 */ - 0x0000, /* R4175 - Write Sequencer 79 */ - 0x0019, /* R4176 - Write Sequencer 80 */ - 0x0019, /* R4177 - Write Sequencer 81 */ - 0x0401, /* R4178 - Write Sequencer 82 */ - 0x0000, /* R4179 - Write Sequencer 83 */ - 0x003C, /* R4180 - Write Sequencer 84 */ - 0x0033, /* R4181 - Write Sequencer 85 */ - 0x0502, /* R4182 - Write Sequencer 86 */ - 0x000A, /* R4183 - Write Sequencer 87 */ - 0x00FE, /* R4184 - Write Sequencer 88 */ - 0x0000, /* R4185 - Write Sequencer 89 */ - 0x0000, /* R4186 - Write Sequencer 90 */ - 0x0000, /* R4187 - Write Sequencer 91 */ - 0x0019, /* R4188 - Write Sequencer 92 */ - 0x0003, /* R4189 - Write Sequencer 93 */ - 0x0102, /* R4190 - Write Sequencer 94 */ - 0x0000, /* R4191 - Write Sequencer 95 */ - 0x0020, /* R4192 - Write Sequencer 96 */ - 0x0000, /* R4193 - Write Sequencer 97 */ - 0x0203, /* R4194 - Write Sequencer 98 */ - 0x0000, /* R4195 - Write Sequencer 99 */ - 0x0021, /* R4196 - Write Sequencer 100 */ - 0x0000, /* R4197 - Write Sequencer 101 */ - 0x0203, /* R4198 - Write Sequencer 102 */ - 0x0100, /* R4199 - Write Sequencer 103 */ - 0x00FE, /* R4200 - Write Sequencer 104 */ - 0x0000, /* R4201 - Write Sequencer 105 */ - 0x0000, /* R4202 - Write Sequencer 106 */ - 0x0000, /* R4203 - Write Sequencer 107 */ - 0x0005, /* R4204 - Write Sequencer 108 */ - 0x0001, /* R4205 - Write Sequencer 109 */ - 0x0003, /* R4206 - Write Sequencer 110 */ - 0x0008, /* R4207 - Write Sequencer 111 */ - 0x0000, /* R4208 - Write Sequencer 112 */ - 0x0001, /* R4209 - Write Sequencer 113 */ - 0x0007, /* R4210 - Write Sequencer 114 */ - 0x0000, /* R4211 - Write Sequencer 115 */ - 0x0001, /* R4212 - Write Sequencer 116 */ - 0x0003, /* R4213 - Write Sequencer 117 */ - 0x0107, /* R4214 - Write Sequencer 118 */ - 0x0000, /* R4215 - Write Sequencer 119 */ - 0x0045, /* R4216 - Write Sequencer 120 */ - 0x000E, /* R4217 - Write Sequencer 121 */ - 0x0403, /* R4218 - Write Sequencer 122 */ - 0x0000, /* R4219 - Write Sequencer 123 */ - 0x0060, /* R4220 - Write Sequencer 124 */ - 0x000E, /* R4221 - Write Sequencer 125 */ - 0x0403, /* R4222 - Write Sequencer 126 */ - 0x0000, /* R4223 - Write Sequencer 127 */ - 0x0002, /* R4224 - Write Sequencer 128 */ - 0x0000, /* R4225 - Write Sequencer 129 */ - 0x0600, /* R4226 - Write Sequencer 130 */ - 0x0000, /* R4227 - Write Sequencer 131 */ - 0x0003, /* R4228 - Write Sequencer 132 */ - 0x0000, /* R4229 - Write Sequencer 133 */ - 0x0600, /* R4230 - Write Sequencer 134 */ - 0x0000, /* R4231 - Write Sequencer 135 */ - 0x0003, /* R4232 - Write Sequencer 136 */ - 0x0001, /* R4233 - Write Sequencer 137 */ - 0x0008, /* R4234 - Write Sequencer 138 */ - 0x0000, /* R4235 - Write Sequencer 139 */ - 0x0028, /* R4236 - Write Sequencer 140 */ - 0x0000, /* R4237 - Write Sequencer 141 */ - 0x0600, /* R4238 - Write Sequencer 142 */ - 0x0000, /* R4239 - Write Sequencer 143 */ - 0x0029, /* R4240 - Write Sequencer 144 */ - 0x0000, /* R4241 - Write Sequencer 145 */ - 0x0600, /* R4242 - Write Sequencer 146 */ - 0x0000, /* R4243 - Write Sequencer 147 */ - 0x0029, /* R4244 - Write Sequencer 148 */ - 0x0001, /* R4245 - Write Sequencer 149 */ - 0x0008, /* R4246 - Write Sequencer 150 */ - 0x0000, /* R4247 - Write Sequencer 151 */ - 0x003C, /* R4248 - Write Sequencer 152 */ - 0x0000, /* R4249 - Write Sequencer 153 */ - 0x0403, /* R4250 - Write Sequencer 154 */ - 0x0000, /* R4251 - Write Sequencer 155 */ - 0x003D, /* R4252 - Write Sequencer 156 */ - 0x0000, /* R4253 - Write Sequencer 157 */ - 0x0403, /* R4254 - Write Sequencer 158 */ - 0x0000, /* R4255 - Write Sequencer 159 */ - 0x003E, /* R4256 - Write Sequencer 160 */ - 0x0000, /* R4257 - Write Sequencer 161 */ - 0x0403, /* R4258 - Write Sequencer 162 */ - 0x0000, /* R4259 - Write Sequencer 163 */ - 0x0045, /* R4260 - Write Sequencer 164 */ - 0x0000, /* R4261 - Write Sequencer 165 */ - 0x0700, /* R4262 - Write Sequencer 166 */ - 0x0000, /* R4263 - Write Sequencer 167 */ - 0x0060, /* R4264 - Write Sequencer 168 */ - 0x0000, /* R4265 - Write Sequencer 169 */ - 0x0700, /* R4266 - Write Sequencer 170 */ - 0x0000, /* R4267 - Write Sequencer 171 */ - 0x0031, /* R4268 - Write Sequencer 172 */ - 0x0000, /* R4269 - Write Sequencer 173 */ - 0x0106, /* R4270 - Write Sequencer 174 */ - 0x0000, /* R4271 - Write Sequencer 175 */ - 0x0063, /* R4272 - Write Sequencer 176 */ - 0x0000, /* R4273 - Write Sequencer 177 */ - 0x0300, /* R4274 - Write Sequencer 178 */ - 0x0000, /* R4275 - Write Sequencer 179 */ - 0x001A, /* R4276 - Write Sequencer 180 */ - 0x0000, /* R4277 - Write Sequencer 181 */ - 0x0503, /* R4278 - Write Sequencer 182 */ - 0x0000, /* R4279 - Write Sequencer 183 */ - 0x0048, /* R4280 - Write Sequencer 184 */ - 0x0000, /* R4281 - Write Sequencer 185 */ - 0x0000, /* R4282 - Write Sequencer 186 */ - 0x0000, /* R4283 - Write Sequencer 187 */ - 0x0019, /* R4284 - Write Sequencer 188 */ - 0x0000, /* R4285 - Write Sequencer 189 */ - 0x0501, /* R4286 - Write Sequencer 190 */ - 0x0000, /* R4287 - Write Sequencer 191 */ - 0x001C, /* R4288 - Write Sequencer 192 */ - 0x0000, /* R4289 - Write Sequencer 193 */ - 0x0103, /* R4290 - Write Sequencer 194 */ - 0x0000, /* R4291 - Write Sequencer 195 */ - 0x0019, /* R4292 - Write Sequencer 196 */ - 0x0000, /* R4293 - Write Sequencer 197 */ - 0x0107, /* R4294 - Write Sequencer 198 */ - 0x0100, /* R4295 - Write Sequencer 199 */ - 0x00FE, /* R4296 - Write Sequencer 200 */ - 0x0000, /* R4297 - Write Sequencer 201 */ - 0x0000, /* R4298 - Write Sequencer 202 */ - 0x0000, /* R4299 - Write Sequencer 203 */ - 0x00FE, /* R4300 - Write Sequencer 204 */ - 0x0000, /* R4301 - Write Sequencer 205 */ - 0x0000, /* R4302 - Write Sequencer 206 */ - 0x0000, /* R4303 - Write Sequencer 207 */ - 0x001C, /* R4304 - Write Sequencer 208 */ - 0x0003, /* R4305 - Write Sequencer 209 */ - 0x0103, /* R4306 - Write Sequencer 210 */ - 0x0000, /* R4307 - Write Sequencer 211 */ - 0x0019, /* R4308 - Write Sequencer 212 */ - 0x0007, /* R4309 - Write Sequencer 213 */ - 0x0206, /* R4310 - Write Sequencer 214 */ - 0x0000, /* R4311 - Write Sequencer 215 */ - 0x0048, /* R4312 - Write Sequencer 216 */ - 0x0001, /* R4313 - Write Sequencer 217 */ - 0x0000, /* R4314 - Write Sequencer 218 */ - 0x0006, /* R4315 - Write Sequencer 219 */ - 0x001A, /* R4316 - Write Sequencer 220 */ - 0x000F, /* R4317 - Write Sequencer 221 */ - 0x0305, /* R4318 - Write Sequencer 222 */ - 0x0000, /* R4319 - Write Sequencer 223 */ - 0x0045, /* R4320 - Write Sequencer 224 */ - 0x0011, /* R4321 - Write Sequencer 225 */ - 0x0400, /* R4322 - Write Sequencer 226 */ - 0x0000, /* R4323 - Write Sequencer 227 */ - 0x0045, /* R4324 - Write Sequencer 228 */ - 0x0019, /* R4325 - Write Sequencer 229 */ - 0x0401, /* R4326 - Write Sequencer 230 */ - 0x0000, /* R4327 - Write Sequencer 231 */ - 0x0060, /* R4328 - Write Sequencer 232 */ - 0x0011, /* R4329 - Write Sequencer 233 */ - 0x0400, /* R4330 - Write Sequencer 234 */ - 0x0000, /* R4331 - Write Sequencer 235 */ - 0x0060, /* R4332 - Write Sequencer 236 */ - 0x0019, /* R4333 - Write Sequencer 237 */ - 0x0401, /* R4334 - Write Sequencer 238 */ - 0x0000, /* R4335 - Write Sequencer 239 */ - 0x0002, /* R4336 - Write Sequencer 240 */ - 0x0030, /* R4337 - Write Sequencer 241 */ - 0x0600, /* R4338 - Write Sequencer 242 */ - 0x0000, /* R4339 - Write Sequencer 243 */ - 0x0003, /* R4340 - Write Sequencer 244 */ - 0x0030, /* R4341 - Write Sequencer 245 */ - 0x0600, /* R4342 - Write Sequencer 246 */ - 0x0000, /* R4343 - Write Sequencer 247 */ - 0x0003, /* R4344 - Write Sequencer 248 */ - 0x0001, /* R4345 - Write Sequencer 249 */ - 0x0008, /* R4346 - Write Sequencer 250 */ - 0x0000, /* R4347 - Write Sequencer 251 */ - 0x003D, /* R4348 - Write Sequencer 252 */ - 0x0033, /* R4349 - Write Sequencer 253 */ - 0x0502, /* R4350 - Write Sequencer 254 */ - 0x000A, /* R4351 - Write Sequencer 255 */ - 0x003E, /* R4352 - Write Sequencer 256 */ - 0x0033, /* R4353 - Write Sequencer 257 */ - 0x0502, /* R4354 - Write Sequencer 258 */ - 0x000A, /* R4355 - Write Sequencer 259 */ - 0x0007, /* R4356 - Write Sequencer 260 */ - 0x0000, /* R4357 - Write Sequencer 261 */ - 0x0102, /* R4358 - Write Sequencer 262 */ - 0x0000, /* R4359 - Write Sequencer 263 */ - 0x0045, /* R4360 - Write Sequencer 264 */ - 0x001D, /* R4361 - Write Sequencer 265 */ - 0x0402, /* R4362 - Write Sequencer 266 */ - 0x0000, /* R4363 - Write Sequencer 267 */ - 0x0045, /* R4364 - Write Sequencer 268 */ - 0x001F, /* R4365 - Write Sequencer 269 */ - 0x0403, /* R4366 - Write Sequencer 270 */ - 0x0000, /* R4367 - Write Sequencer 271 */ - 0x0060, /* R4368 - Write Sequencer 272 */ - 0x001D, /* R4369 - Write Sequencer 273 */ - 0x0402, /* R4370 - Write Sequencer 274 */ - 0x0000, /* R4371 - Write Sequencer 275 */ - 0x0060, /* R4372 - Write Sequencer 276 */ - 0x001F, /* R4373 - Write Sequencer 277 */ - 0x0403, /* R4374 - Write Sequencer 278 */ - 0x0000, /* R4375 - Write Sequencer 279 */ - 0x0005, /* R4376 - Write Sequencer 280 */ - 0x0000, /* R4377 - Write Sequencer 281 */ - 0x0003, /* R4378 - Write Sequencer 282 */ - 0x0108, /* R4379 - Write Sequencer 283 */ - 0x00FE, /* R4380 - Write Sequencer 284 */ - 0x0000, /* R4381 - Write Sequencer 285 */ - 0x0000, /* R4382 - Write Sequencer 286 */ - 0x0000, /* R4383 - Write Sequencer 287 */ - 0x0045, /* R4384 - Write Sequencer 288 */ - 0x000E, /* R4385 - Write Sequencer 289 */ - 0x0403, /* R4386 - Write Sequencer 290 */ - 0x0000, /* R4387 - Write Sequencer 291 */ - 0x001A, /* R4388 - Write Sequencer 292 */ - 0x0003, /* R4389 - Write Sequencer 293 */ - 0x0100, /* R4390 - Write Sequencer 294 */ - 0x0000, /* R4391 - Write Sequencer 295 */ - 0x0002, /* R4392 - Write Sequencer 296 */ - 0x0001, /* R4393 - Write Sequencer 297 */ - 0x0008, /* R4394 - Write Sequencer 298 */ - 0x0000, /* R4395 - Write Sequencer 299 */ - 0x0045, /* R4396 - Write Sequencer 300 */ - 0x0000, /* R4397 - Write Sequencer 301 */ - 0x0700, /* R4398 - Write Sequencer 302 */ - 0x0000, /* R4399 - Write Sequencer 303 */ - 0x0060, /* R4400 - Write Sequencer 304 */ - 0x0011, /* R4401 - Write Sequencer 305 */ - 0x0400, /* R4402 - Write Sequencer 306 */ - 0x0000, /* R4403 - Write Sequencer 307 */ - 0x0060, /* R4404 - Write Sequencer 308 */ - 0x0019, /* R4405 - Write Sequencer 309 */ - 0x0401, /* R4406 - Write Sequencer 310 */ - 0x0000, /* R4407 - Write Sequencer 311 */ - 0x001A, /* R4408 - Write Sequencer 312 */ - 0x0000, /* R4409 - Write Sequencer 313 */ - 0x0100, /* R4410 - Write Sequencer 314 */ - 0x0000, /* R4411 - Write Sequencer 315 */ - 0x0002, /* R4412 - Write Sequencer 316 */ - 0x0001, /* R4413 - Write Sequencer 317 */ - 0x0008, /* R4414 - Write Sequencer 318 */ - 0x0000, /* R4415 - Write Sequencer 319 */ - 0x0060, /* R4416 - Write Sequencer 320 */ - 0x001D, /* R4417 - Write Sequencer 321 */ - 0x0402, /* R4418 - Write Sequencer 322 */ - 0x0000, /* R4419 - Write Sequencer 323 */ - 0x0060, /* R4420 - Write Sequencer 324 */ - 0x001F, /* R4421 - Write Sequencer 325 */ - 0x0403, /* R4422 - Write Sequencer 326 */ - 0x0000, /* R4423 - Write Sequencer 327 */ - 0x0005, /* R4424 - Write Sequencer 328 */ - 0x0000, /* R4425 - Write Sequencer 329 */ - 0x0003, /* R4426 - Write Sequencer 330 */ - 0x0100, /* R4427 - Write Sequencer 331 */ - 0x00FE, /* R4428 - Write Sequencer 332 */ - 0x0000, /* R4429 - Write Sequencer 333 */ - 0x0000, /* R4430 - Write Sequencer 334 */ - 0x0000, /* R4431 - Write Sequencer 335 */ - 0x0060, /* R4432 - Write Sequencer 336 */ - 0x000E, /* R4433 - Write Sequencer 337 */ - 0x0403, /* R4434 - Write Sequencer 338 */ - 0x0000, /* R4435 - Write Sequencer 339 */ - 0x001A, /* R4436 - Write Sequencer 340 */ - 0x0003, /* R4437 - Write Sequencer 341 */ - 0x0100, /* R4438 - Write Sequencer 342 */ - 0x0000, /* R4439 - Write Sequencer 343 */ - 0x0002, /* R4440 - Write Sequencer 344 */ - 0x0001, /* R4441 - Write Sequencer 345 */ - 0x0008, /* R4442 - Write Sequencer 346 */ - 0x0000, /* R4443 - Write Sequencer 347 */ - 0x0060, /* R4444 - Write Sequencer 348 */ - 0x0000, /* R4445 - Write Sequencer 349 */ - 0x0700, /* R4446 - Write Sequencer 350 */ - 0x0000, /* R4447 - Write Sequencer 351 */ - 0x0045, /* R4448 - Write Sequencer 352 */ - 0x0011, /* R4449 - Write Sequencer 353 */ - 0x0400, /* R4450 - Write Sequencer 354 */ - 0x0000, /* R4451 - Write Sequencer 355 */ - 0x0045, /* R4452 - Write Sequencer 356 */ - 0x0019, /* R4453 - Write Sequencer 357 */ - 0x0401, /* R4454 - Write Sequencer 358 */ - 0x0000, /* R4455 - Write Sequencer 359 */ - 0x001A, /* R4456 - Write Sequencer 360 */ - 0x0000, /* R4457 - Write Sequencer 361 */ - 0x0100, /* R4458 - Write Sequencer 362 */ - 0x0000, /* R4459 - Write Sequencer 363 */ - 0x0002, /* R4460 - Write Sequencer 364 */ - 0x0001, /* R4461 - Write Sequencer 365 */ - 0x0008, /* R4462 - Write Sequencer 366 */ - 0x0000, /* R4463 - Write Sequencer 367 */ - 0x0045, /* R4464 - Write Sequencer 368 */ - 0x001D, /* R4465 - Write Sequencer 369 */ - 0x0402, /* R4466 - Write Sequencer 370 */ - 0x0000, /* R4467 - Write Sequencer 371 */ - 0x0045, /* R4468 - Write Sequencer 372 */ - 0x001F, /* R4469 - Write Sequencer 373 */ - 0x0403, /* R4470 - Write Sequencer 374 */ - 0x0000, /* R4471 - Write Sequencer 375 */ - 0x0005, /* R4472 - Write Sequencer 376 */ - 0x0000, /* R4473 - Write Sequencer 377 */ - 0x0003, /* R4474 - Write Sequencer 378 */ - 0x0100, /* R4475 - Write Sequencer 379 */ - 0x00FE, /* R4476 - Write Sequencer 380 */ - 0x0000, /* R4477 - Write Sequencer 381 */ - 0x0000, /* R4478 - Write Sequencer 382 */ - 0x0000, /* R4479 - Write Sequencer 383 */ - 0x00FE, /* R4480 - Write Sequencer 384 */ - 0x0000, /* R4481 - Write Sequencer 385 */ - 0x0000, /* R4482 - Write Sequencer 386 */ - 0x0000, /* R4483 - Write Sequencer 387 */ - 0x00FE, /* R4484 - Write Sequencer 388 */ - 0x0000, /* R4485 - Write Sequencer 389 */ - 0x0000, /* R4486 - Write Sequencer 390 */ - 0x0000, /* R4487 - Write Sequencer 391 */ - 0x00FE, /* R4488 - Write Sequencer 392 */ - 0x0000, /* R4489 - Write Sequencer 393 */ - 0x0000, /* R4490 - Write Sequencer 394 */ - 0x0000, /* R4491 - Write Sequencer 395 */ - 0x00FE, /* R4492 - Write Sequencer 396 */ - 0x0000, /* R4493 - Write Sequencer 397 */ - 0x0000, /* R4494 - Write Sequencer 398 */ - 0x0000, /* R4495 - Write Sequencer 399 */ - 0x0031, /* R4496 - Write Sequencer 400 */ - 0x0001, /* R4497 - Write Sequencer 401 */ - 0x0004, /* R4498 - Write Sequencer 402 */ - 0x0000, /* R4499 - Write Sequencer 403 */ - 0x0031, /* R4500 - Write Sequencer 404 */ - 0x0007, /* R4501 - Write Sequencer 405 */ - 0x0200, /* R4502 - Write Sequencer 406 */ - 0x0000, /* R4503 - Write Sequencer 407 */ - 0x0031, /* R4504 - Write Sequencer 408 */ - 0x0000, /* R4505 - Write Sequencer 409 */ - 0x0106, /* R4506 - Write Sequencer 410 */ - 0x0100, /* R4507 - Write Sequencer 411 */ - 0x00FE, /* R4508 - Write Sequencer 412 */ - 0x0000, /* R4509 - Write Sequencer 413 */ - 0x0000, /* R4510 - Write Sequencer 414 */ - 0x0000, /* R4511 - Write Sequencer 415 */ - 0x0031, /* R4512 - Write Sequencer 416 */ - 0x0003, /* R4513 - Write Sequencer 417 */ - 0x0106, /* R4514 - Write Sequencer 418 */ - 0x0000, /* R4515 - Write Sequencer 419 */ - 0x0031, /* R4516 - Write Sequencer 420 */ - 0x0004, /* R4517 - Write Sequencer 421 */ - 0x0200, /* R4518 - Write Sequencer 422 */ - 0x0000, /* R4519 - Write Sequencer 423 */ - 0x0031, /* R4520 - Write Sequencer 424 */ - 0x0000, /* R4521 - Write Sequencer 425 */ - 0x0004, /* R4522 - Write Sequencer 426 */ - 0x0100, /* R4523 - Write Sequencer 427 */ - 0x0000, /* R4524 - Write Sequencer 428 */ - 0x0000, /* R4525 - Write Sequencer 429 */ - 0x0000, /* R4526 - Write Sequencer 430 */ - 0x0000, /* R4527 - Write Sequencer 431 */ - 0x0000, /* R4528 - Write Sequencer 432 */ - 0x0000, /* R4529 - Write Sequencer 433 */ - 0x0000, /* R4530 - Write Sequencer 434 */ - 0x0000, /* R4531 - Write Sequencer 435 */ - 0x0000, /* R4532 - Write Sequencer 436 */ - 0x0000, /* R4533 - Write Sequencer 437 */ - 0x0000, /* R4534 - Write Sequencer 438 */ - 0x0000, /* R4535 - Write Sequencer 439 */ - 0x0000, /* R4536 - Write Sequencer 440 */ - 0x0000, /* R4537 - Write Sequencer 441 */ - 0x0000, /* R4538 - Write Sequencer 442 */ - 0x0000, /* R4539 - Write Sequencer 443 */ - 0x0000, /* R4540 - Write Sequencer 444 */ - 0x0000, /* R4541 - Write Sequencer 445 */ - 0x0000, /* R4542 - Write Sequencer 446 */ - 0x0000, /* R4543 - Write Sequencer 447 */ - 0x0000, /* R4544 - Write Sequencer 448 */ - 0x0000, /* R4545 - Write Sequencer 449 */ - 0x0000, /* R4546 - Write Sequencer 450 */ - 0x0000, /* R4547 - Write Sequencer 451 */ - 0x0000, /* R4548 - Write Sequencer 452 */ - 0x0000, /* R4549 - Write Sequencer 453 */ - 0x0000, /* R4550 - Write Sequencer 454 */ - 0x0000, /* R4551 - Write Sequencer 455 */ - 0x0000, /* R4552 - Write Sequencer 456 */ - 0x0000, /* R4553 - Write Sequencer 457 */ - 0x0000, /* R4554 - Write Sequencer 458 */ - 0x0000, /* R4555 - Write Sequencer 459 */ - 0x0000, /* R4556 - Write Sequencer 460 */ - 0x0000, /* R4557 - Write Sequencer 461 */ - 0x0000, /* R4558 - Write Sequencer 462 */ - 0x0000, /* R4559 - Write Sequencer 463 */ - 0x0000, /* R4560 - Write Sequencer 464 */ - 0x0000, /* R4561 - Write Sequencer 465 */ - 0x0000, /* R4562 - Write Sequencer 466 */ - 0x0000, /* R4563 - Write Sequencer 467 */ - 0x0000, /* R4564 - Write Sequencer 468 */ - 0x0000, /* R4565 - Write Sequencer 469 */ - 0x0000, /* R4566 - Write Sequencer 470 */ - 0x0000, /* R4567 - Write Sequencer 471 */ - 0x0000, /* R4568 - Write Sequencer 472 */ - 0x0000, /* R4569 - Write Sequencer 473 */ - 0x0000, /* R4570 - Write Sequencer 474 */ - 0x0000, /* R4571 - Write Sequencer 475 */ - 0x0000, /* R4572 - Write Sequencer 476 */ - 0x0000, /* R4573 - Write Sequencer 477 */ - 0x0000, /* R4574 - Write Sequencer 478 */ - 0x0000, /* R4575 - Write Sequencer 479 */ - 0x0000, /* R4576 - Write Sequencer 480 */ - 0x0000, /* R4577 - Write Sequencer 481 */ - 0x0000, /* R4578 - Write Sequencer 482 */ - 0x0000, /* R4579 - Write Sequencer 483 */ - 0x0000, /* R4580 - Write Sequencer 484 */ - 0x0000, /* R4581 - Write Sequencer 485 */ - 0x0000, /* R4582 - Write Sequencer 486 */ - 0x0000, /* R4583 - Write Sequencer 487 */ - 0x0000, /* R4584 - Write Sequencer 488 */ - 0x0000, /* R4585 - Write Sequencer 489 */ - 0x0000, /* R4586 - Write Sequencer 490 */ - 0x0000, /* R4587 - Write Sequencer 491 */ - 0x0000, /* R4588 - Write Sequencer 492 */ - 0x0000, /* R4589 - Write Sequencer 493 */ - 0x0000, /* R4590 - Write Sequencer 494 */ - 0x0000, /* R4591 - Write Sequencer 495 */ - 0x0000, /* R4592 - Write Sequencer 496 */ - 0x0000, /* R4593 - Write Sequencer 497 */ - 0x0000, /* R4594 - Write Sequencer 498 */ - 0x0000, /* R4595 - Write Sequencer 499 */ - 0x0000, /* R4596 - Write Sequencer 500 */ - 0x0000, /* R4597 - Write Sequencer 501 */ - 0x0000, /* R4598 - Write Sequencer 502 */ - 0x0000, /* R4599 - Write Sequencer 503 */ - 0x0000, /* R4600 - Write Sequencer 504 */ - 0x0000, /* R4601 - Write Sequencer 505 */ - 0x0000, /* R4602 - Write Sequencer 506 */ - 0x0000, /* R4603 - Write Sequencer 507 */ - 0x0000, /* R4604 - Write Sequencer 508 */ - 0x0000, /* R4605 - Write Sequencer 509 */ - 0x0000, /* R4606 - Write Sequencer 510 */ - 0x0000, /* R4607 - Write Sequencer 511 */ - 0x0000, /* R4608 */ - 0x0000, /* R4609 */ - 0x0000, /* R4610 */ - 0x0000, /* R4611 */ - 0x0000, /* R4612 */ - 0x0000, /* R4613 */ - 0x0000, /* R4614 */ - 0x0000, /* R4615 */ - 0x0000, /* R4616 */ - 0x0000, /* R4617 */ - 0x0000, /* R4618 */ - 0x0000, /* R4619 */ - 0x0000, /* R4620 */ - 0x0000, /* R4621 */ - 0x0000, /* R4622 */ - 0x0000, /* R4623 */ - 0x0000, /* R4624 */ - 0x0000, /* R4625 */ - 0x0000, /* R4626 */ - 0x0000, /* R4627 */ - 0x0000, /* R4628 */ - 0x0000, /* R4629 */ - 0x0000, /* R4630 */ - 0x0000, /* R4631 */ - 0x0000, /* R4632 */ - 0x0000, /* R4633 */ - 0x0000, /* R4634 */ - 0x0000, /* R4635 */ - 0x0000, /* R4636 */ - 0x0000, /* R4637 */ - 0x0000, /* R4638 */ - 0x0000, /* R4639 */ - 0x0000, /* R4640 */ - 0x0000, /* R4641 */ - 0x0000, /* R4642 */ - 0x0000, /* R4643 */ - 0x0000, /* R4644 */ - 0x0000, /* R4645 */ - 0x0000, /* R4646 */ - 0x0000, /* R4647 */ - 0x0000, /* R4648 */ - 0x0000, /* R4649 */ - 0x0000, /* R4650 */ - 0x0000, /* R4651 */ - 0x0000, /* R4652 */ - 0x0000, /* R4653 */ - 0x0000, /* R4654 */ - 0x0000, /* R4655 */ - 0x0000, /* R4656 */ - 0x0000, /* R4657 */ - 0x0000, /* R4658 */ - 0x0000, /* R4659 */ - 0x0000, /* R4660 */ - 0x0000, /* R4661 */ - 0x0000, /* R4662 */ - 0x0000, /* R4663 */ - 0x0000, /* R4664 */ - 0x0000, /* R4665 */ - 0x0000, /* R4666 */ - 0x0000, /* R4667 */ - 0x0000, /* R4668 */ - 0x0000, /* R4669 */ - 0x0000, /* R4670 */ - 0x0000, /* R4671 */ - 0x0000, /* R4672 */ - 0x0000, /* R4673 */ - 0x0000, /* R4674 */ - 0x0000, /* R4675 */ - 0x0000, /* R4676 */ - 0x0000, /* R4677 */ - 0x0000, /* R4678 */ - 0x0000, /* R4679 */ - 0x0000, /* R4680 */ - 0x0000, /* R4681 */ - 0x0000, /* R4682 */ - 0x0000, /* R4683 */ - 0x0000, /* R4684 */ - 0x0000, /* R4685 */ - 0x0000, /* R4686 */ - 0x0000, /* R4687 */ - 0x0000, /* R4688 */ - 0x0000, /* R4689 */ - 0x0000, /* R4690 */ - 0x0000, /* R4691 */ - 0x0000, /* R4692 */ - 0x0000, /* R4693 */ - 0x0000, /* R4694 */ - 0x0000, /* R4695 */ - 0x0000, /* R4696 */ - 0x0000, /* R4697 */ - 0x0000, /* R4698 */ - 0x0000, /* R4699 */ - 0x0000, /* R4700 */ - 0x0000, /* R4701 */ - 0x0000, /* R4702 */ - 0x0000, /* R4703 */ - 0x0000, /* R4704 */ - 0x0000, /* R4705 */ - 0x0000, /* R4706 */ - 0x0000, /* R4707 */ - 0x0000, /* R4708 */ - 0x0000, /* R4709 */ - 0x0000, /* R4710 */ - 0x0000, /* R4711 */ - 0x0000, /* R4712 */ - 0x0000, /* R4713 */ - 0x0000, /* R4714 */ - 0x0000, /* R4715 */ - 0x0000, /* R4716 */ - 0x0000, /* R4717 */ - 0x0000, /* R4718 */ - 0x0000, /* R4719 */ - 0x0000, /* R4720 */ - 0x0000, /* R4721 */ - 0x0000, /* R4722 */ - 0x0000, /* R4723 */ - 0x0000, /* R4724 */ - 0x0000, /* R4725 */ - 0x0000, /* R4726 */ - 0x0000, /* R4727 */ - 0x0000, /* R4728 */ - 0x0000, /* R4729 */ - 0x0000, /* R4730 */ - 0x0000, /* R4731 */ - 0x0000, /* R4732 */ - 0x0000, /* R4733 */ - 0x0000, /* R4734 */ - 0x0000, /* R4735 */ - 0x0000, /* R4736 */ - 0x0000, /* R4737 */ - 0x0000, /* R4738 */ - 0x0000, /* R4739 */ - 0x0000, /* R4740 */ - 0x0000, /* R4741 */ - 0x0000, /* R4742 */ - 0x0000, /* R4743 */ - 0x0000, /* R4744 */ - 0x0000, /* R4745 */ - 0x0000, /* R4746 */ - 0x0000, /* R4747 */ - 0x0000, /* R4748 */ - 0x0000, /* R4749 */ - 0x0000, /* R4750 */ - 0x0000, /* R4751 */ - 0x0000, /* R4752 */ - 0x0000, /* R4753 */ - 0x0000, /* R4754 */ - 0x0000, /* R4755 */ - 0x0000, /* R4756 */ - 0x0000, /* R4757 */ - 0x0000, /* R4758 */ - 0x0000, /* R4759 */ - 0x0000, /* R4760 */ - 0x0000, /* R4761 */ - 0x0000, /* R4762 */ - 0x0000, /* R4763 */ - 0x0000, /* R4764 */ - 0x0000, /* R4765 */ - 0x0000, /* R4766 */ - 0x0000, /* R4767 */ - 0x0000, /* R4768 */ - 0x0000, /* R4769 */ - 0x0000, /* R4770 */ - 0x0000, /* R4771 */ - 0x0000, /* R4772 */ - 0x0000, /* R4773 */ - 0x0000, /* R4774 */ - 0x0000, /* R4775 */ - 0x0000, /* R4776 */ - 0x0000, /* R4777 */ - 0x0000, /* R4778 */ - 0x0000, /* R4779 */ - 0x0000, /* R4780 */ - 0x0000, /* R4781 */ - 0x0000, /* R4782 */ - 0x0000, /* R4783 */ - 0x0000, /* R4784 */ - 0x0000, /* R4785 */ - 0x0000, /* R4786 */ - 0x0000, /* R4787 */ - 0x0000, /* R4788 */ - 0x0000, /* R4789 */ - 0x0000, /* R4790 */ - 0x0000, /* R4791 */ - 0x0000, /* R4792 */ - 0x0000, /* R4793 */ - 0x0000, /* R4794 */ - 0x0000, /* R4795 */ - 0x0000, /* R4796 */ - 0x0000, /* R4797 */ - 0x0000, /* R4798 */ - 0x0000, /* R4799 */ - 0x0000, /* R4800 */ - 0x0000, /* R4801 */ - 0x0000, /* R4802 */ - 0x0000, /* R4803 */ - 0x0000, /* R4804 */ - 0x0000, /* R4805 */ - 0x0000, /* R4806 */ - 0x0000, /* R4807 */ - 0x0000, /* R4808 */ - 0x0000, /* R4809 */ - 0x0000, /* R4810 */ - 0x0000, /* R4811 */ - 0x0000, /* R4812 */ - 0x0000, /* R4813 */ - 0x0000, /* R4814 */ - 0x0000, /* R4815 */ - 0x0000, /* R4816 */ - 0x0000, /* R4817 */ - 0x0000, /* R4818 */ - 0x0000, /* R4819 */ - 0x0000, /* R4820 */ - 0x0000, /* R4821 */ - 0x0000, /* R4822 */ - 0x0000, /* R4823 */ - 0x0000, /* R4824 */ - 0x0000, /* R4825 */ - 0x0000, /* R4826 */ - 0x0000, /* R4827 */ - 0x0000, /* R4828 */ - 0x0000, /* R4829 */ - 0x0000, /* R4830 */ - 0x0000, /* R4831 */ - 0x0000, /* R4832 */ - 0x0000, /* R4833 */ - 0x0000, /* R4834 */ - 0x0000, /* R4835 */ - 0x0000, /* R4836 */ - 0x0000, /* R4837 */ - 0x0000, /* R4838 */ - 0x0000, /* R4839 */ - 0x0000, /* R4840 */ - 0x0000, /* R4841 */ - 0x0000, /* R4842 */ - 0x0000, /* R4843 */ - 0x0000, /* R4844 */ - 0x0000, /* R4845 */ - 0x0000, /* R4846 */ - 0x0000, /* R4847 */ - 0x0000, /* R4848 */ - 0x0000, /* R4849 */ - 0x0000, /* R4850 */ - 0x0000, /* R4851 */ - 0x0000, /* R4852 */ - 0x0000, /* R4853 */ - 0x0000, /* R4854 */ - 0x0000, /* R4855 */ - 0x0000, /* R4856 */ - 0x0000, /* R4857 */ - 0x0000, /* R4858 */ - 0x0000, /* R4859 */ - 0x0000, /* R4860 */ - 0x0000, /* R4861 */ - 0x0000, /* R4862 */ - 0x0000, /* R4863 */ - 0x0000, /* R4864 */ - 0x0000, /* R4865 */ - 0x0000, /* R4866 */ - 0x0000, /* R4867 */ - 0x0000, /* R4868 */ - 0x0000, /* R4869 */ - 0x0000, /* R4870 */ - 0x0000, /* R4871 */ - 0x0000, /* R4872 */ - 0x0000, /* R4873 */ - 0x0000, /* R4874 */ - 0x0000, /* R4875 */ - 0x0000, /* R4876 */ - 0x0000, /* R4877 */ - 0x0000, /* R4878 */ - 0x0000, /* R4879 */ - 0x0000, /* R4880 */ - 0x0000, /* R4881 */ - 0x0000, /* R4882 */ - 0x0000, /* R4883 */ - 0x0000, /* R4884 */ - 0x0000, /* R4885 */ - 0x0000, /* R4886 */ - 0x0000, /* R4887 */ - 0x0000, /* R4888 */ - 0x0000, /* R4889 */ - 0x0000, /* R4890 */ - 0x0000, /* R4891 */ - 0x0000, /* R4892 */ - 0x0000, /* R4893 */ - 0x0000, /* R4894 */ - 0x0000, /* R4895 */ - 0x0000, /* R4896 */ - 0x0000, /* R4897 */ - 0x0000, /* R4898 */ - 0x0000, /* R4899 */ - 0x0000, /* R4900 */ - 0x0000, /* R4901 */ - 0x0000, /* R4902 */ - 0x0000, /* R4903 */ - 0x0000, /* R4904 */ - 0x0000, /* R4905 */ - 0x0000, /* R4906 */ - 0x0000, /* R4907 */ - 0x0000, /* R4908 */ - 0x0000, /* R4909 */ - 0x0000, /* R4910 */ - 0x0000, /* R4911 */ - 0x0000, /* R4912 */ - 0x0000, /* R4913 */ - 0x0000, /* R4914 */ - 0x0000, /* R4915 */ - 0x0000, /* R4916 */ - 0x0000, /* R4917 */ - 0x0000, /* R4918 */ - 0x0000, /* R4919 */ - 0x0000, /* R4920 */ - 0x0000, /* R4921 */ - 0x0000, /* R4922 */ - 0x0000, /* R4923 */ - 0x0000, /* R4924 */ - 0x0000, /* R4925 */ - 0x0000, /* R4926 */ - 0x0000, /* R4927 */ - 0x0000, /* R4928 */ - 0x0000, /* R4929 */ - 0x0000, /* R4930 */ - 0x0000, /* R4931 */ - 0x0000, /* R4932 */ - 0x0000, /* R4933 */ - 0x0000, /* R4934 */ - 0x0000, /* R4935 */ - 0x0000, /* R4936 */ - 0x0000, /* R4937 */ - 0x0000, /* R4938 */ - 0x0000, /* R4939 */ - 0x0000, /* R4940 */ - 0x0000, /* R4941 */ - 0x0000, /* R4942 */ - 0x0000, /* R4943 */ - 0x0000, /* R4944 */ - 0x0000, /* R4945 */ - 0x0000, /* R4946 */ - 0x0000, /* R4947 */ - 0x0000, /* R4948 */ - 0x0000, /* R4949 */ - 0x0000, /* R4950 */ - 0x0000, /* R4951 */ - 0x0000, /* R4952 */ - 0x0000, /* R4953 */ - 0x0000, /* R4954 */ - 0x0000, /* R4955 */ - 0x0000, /* R4956 */ - 0x0000, /* R4957 */ - 0x0000, /* R4958 */ - 0x0000, /* R4959 */ - 0x0000, /* R4960 */ - 0x0000, /* R4961 */ - 0x0000, /* R4962 */ - 0x0000, /* R4963 */ - 0x0000, /* R4964 */ - 0x0000, /* R4965 */ - 0x0000, /* R4966 */ - 0x0000, /* R4967 */ - 0x0000, /* R4968 */ - 0x0000, /* R4969 */ - 0x0000, /* R4970 */ - 0x0000, /* R4971 */ - 0x0000, /* R4972 */ - 0x0000, /* R4973 */ - 0x0000, /* R4974 */ - 0x0000, /* R4975 */ - 0x0000, /* R4976 */ - 0x0000, /* R4977 */ - 0x0000, /* R4978 */ - 0x0000, /* R4979 */ - 0x0000, /* R4980 */ - 0x0000, /* R4981 */ - 0x0000, /* R4982 */ - 0x0000, /* R4983 */ - 0x0000, /* R4984 */ - 0x0000, /* R4985 */ - 0x0000, /* R4986 */ - 0x0000, /* R4987 */ - 0x0000, /* R4988 */ - 0x0000, /* R4989 */ - 0x0000, /* R4990 */ - 0x0000, /* R4991 */ - 0x0000, /* R4992 */ - 0x0000, /* R4993 */ - 0x0000, /* R4994 */ - 0x0000, /* R4995 */ - 0x0000, /* R4996 */ - 0x0000, /* R4997 */ - 0x0000, /* R4998 */ - 0x0000, /* R4999 */ - 0x0000, /* R5000 */ - 0x0000, /* R5001 */ - 0x0000, /* R5002 */ - 0x0000, /* R5003 */ - 0x0000, /* R5004 */ - 0x0000, /* R5005 */ - 0x0000, /* R5006 */ - 0x0000, /* R5007 */ - 0x0000, /* R5008 */ - 0x0000, /* R5009 */ - 0x0000, /* R5010 */ - 0x0000, /* R5011 */ - 0x0000, /* R5012 */ - 0x0000, /* R5013 */ - 0x0000, /* R5014 */ - 0x0000, /* R5015 */ - 0x0000, /* R5016 */ - 0x0000, /* R5017 */ - 0x0000, /* R5018 */ - 0x0000, /* R5019 */ - 0x0000, /* R5020 */ - 0x0000, /* R5021 */ - 0x0000, /* R5022 */ - 0x0000, /* R5023 */ - 0x0000, /* R5024 */ - 0x0000, /* R5025 */ - 0x0000, /* R5026 */ - 0x0000, /* R5027 */ - 0x0000, /* R5028 */ - 0x0000, /* R5029 */ - 0x0000, /* R5030 */ - 0x0000, /* R5031 */ - 0x0000, /* R5032 */ - 0x0000, /* R5033 */ - 0x0000, /* R5034 */ - 0x0000, /* R5035 */ - 0x0000, /* R5036 */ - 0x0000, /* R5037 */ - 0x0000, /* R5038 */ - 0x0000, /* R5039 */ - 0x0000, /* R5040 */ - 0x0000, /* R5041 */ - 0x0000, /* R5042 */ - 0x0000, /* R5043 */ - 0x0000, /* R5044 */ - 0x0000, /* R5045 */ - 0x0000, /* R5046 */ - 0x0000, /* R5047 */ - 0x0000, /* R5048 */ - 0x0000, /* R5049 */ - 0x0000, /* R5050 */ - 0x0000, /* R5051 */ - 0x0000, /* R5052 */ - 0x0000, /* R5053 */ - 0x0000, /* R5054 */ - 0x0000, /* R5055 */ - 0x0000, /* R5056 */ - 0x0000, /* R5057 */ - 0x0000, /* R5058 */ - 0x0000, /* R5059 */ - 0x0000, /* R5060 */ - 0x0000, /* R5061 */ - 0x0000, /* R5062 */ - 0x0000, /* R5063 */ - 0x0000, /* R5064 */ - 0x0000, /* R5065 */ - 0x0000, /* R5066 */ - 0x0000, /* R5067 */ - 0x0000, /* R5068 */ - 0x0000, /* R5069 */ - 0x0000, /* R5070 */ - 0x0000, /* R5071 */ - 0x0000, /* R5072 */ - 0x0000, /* R5073 */ - 0x0000, /* R5074 */ - 0x0000, /* R5075 */ - 0x0000, /* R5076 */ - 0x0000, /* R5077 */ - 0x0000, /* R5078 */ - 0x0000, /* R5079 */ - 0x0000, /* R5080 */ - 0x0000, /* R5081 */ - 0x0000, /* R5082 */ - 0x0000, /* R5083 */ - 0x0000, /* R5084 */ - 0x0000, /* R5085 */ - 0x0000, /* R5086 */ - 0x0000, /* R5087 */ - 0x0000, /* R5088 */ - 0x0000, /* R5089 */ - 0x0000, /* R5090 */ - 0x0000, /* R5091 */ - 0x0000, /* R5092 */ - 0x0000, /* R5093 */ - 0x0000, /* R5094 */ - 0x0000, /* R5095 */ - 0x0000, /* R5096 */ - 0x0000, /* R5097 */ - 0x0000, /* R5098 */ - 0x0000, /* R5099 */ - 0x0000, /* R5100 */ - 0x0000, /* R5101 */ - 0x0000, /* R5102 */ - 0x0000, /* R5103 */ - 0x0000, /* R5104 */ - 0x0000, /* R5105 */ - 0x0000, /* R5106 */ - 0x0000, /* R5107 */ - 0x0000, /* R5108 */ - 0x0000, /* R5109 */ - 0x0000, /* R5110 */ - 0x0000, /* R5111 */ - 0x0000, /* R5112 */ - 0x0000, /* R5113 */ - 0x0000, /* R5114 */ - 0x0000, /* R5115 */ - 0x0000, /* R5116 */ - 0x0000, /* R5117 */ - 0x0000, /* R5118 */ - 0x0000, /* R5119 */ - 0x0000, /* R5120 */ - 0x0000, /* R5121 */ - 0x0000, /* R5122 */ - 0x0000, /* R5123 */ - 0x0000, /* R5124 */ - 0x0000, /* R5125 */ - 0x0000, /* R5126 */ - 0x0000, /* R5127 */ - 0x0000, /* R5128 */ - 0x0000, /* R5129 */ - 0x0000, /* R5130 */ - 0x0000, /* R5131 */ - 0x0000, /* R5132 */ - 0x0000, /* R5133 */ - 0x0000, /* R5134 */ - 0x0000, /* R5135 */ - 0x0000, /* R5136 */ - 0x0000, /* R5137 */ - 0x0000, /* R5138 */ - 0x0000, /* R5139 */ - 0x0000, /* R5140 */ - 0x0000, /* R5141 */ - 0x0000, /* R5142 */ - 0x0000, /* R5143 */ - 0x0000, /* R5144 */ - 0x0000, /* R5145 */ - 0x0000, /* R5146 */ - 0x0000, /* R5147 */ - 0x0000, /* R5148 */ - 0x0000, /* R5149 */ - 0x0000, /* R5150 */ - 0x0000, /* R5151 */ - 0x0000, /* R5152 */ - 0x0000, /* R5153 */ - 0x0000, /* R5154 */ - 0x0000, /* R5155 */ - 0x0000, /* R5156 */ - 0x0000, /* R5157 */ - 0x0000, /* R5158 */ - 0x0000, /* R5159 */ - 0x0000, /* R5160 */ - 0x0000, /* R5161 */ - 0x0000, /* R5162 */ - 0x0000, /* R5163 */ - 0x0000, /* R5164 */ - 0x0000, /* R5165 */ - 0x0000, /* R5166 */ - 0x0000, /* R5167 */ - 0x0000, /* R5168 */ - 0x0000, /* R5169 */ - 0x0000, /* R5170 */ - 0x0000, /* R5171 */ - 0x0000, /* R5172 */ - 0x0000, /* R5173 */ - 0x0000, /* R5174 */ - 0x0000, /* R5175 */ - 0x0000, /* R5176 */ - 0x0000, /* R5177 */ - 0x0000, /* R5178 */ - 0x0000, /* R5179 */ - 0x0000, /* R5180 */ - 0x0000, /* R5181 */ - 0x0000, /* R5182 */ - 0x0000, /* R5183 */ - 0x0000, /* R5184 */ - 0x0000, /* R5185 */ - 0x0000, /* R5186 */ - 0x0000, /* R5187 */ - 0x0000, /* R5188 */ - 0x0000, /* R5189 */ - 0x0000, /* R5190 */ - 0x0000, /* R5191 */ - 0x0000, /* R5192 */ - 0x0000, /* R5193 */ - 0x0000, /* R5194 */ - 0x0000, /* R5195 */ - 0x0000, /* R5196 */ - 0x0000, /* R5197 */ - 0x0000, /* R5198 */ - 0x0000, /* R5199 */ - 0x0000, /* R5200 */ - 0x0000, /* R5201 */ - 0x0000, /* R5202 */ - 0x0000, /* R5203 */ - 0x0000, /* R5204 */ - 0x0000, /* R5205 */ - 0x0000, /* R5206 */ - 0x0000, /* R5207 */ - 0x0000, /* R5208 */ - 0x0000, /* R5209 */ - 0x0000, /* R5210 */ - 0x0000, /* R5211 */ - 0x0000, /* R5212 */ - 0x0000, /* R5213 */ - 0x0000, /* R5214 */ - 0x0000, /* R5215 */ - 0x0000, /* R5216 */ - 0x0000, /* R5217 */ - 0x0000, /* R5218 */ - 0x0000, /* R5219 */ - 0x0000, /* R5220 */ - 0x0000, /* R5221 */ - 0x0000, /* R5222 */ - 0x0000, /* R5223 */ - 0x0000, /* R5224 */ - 0x0000, /* R5225 */ - 0x0000, /* R5226 */ - 0x0000, /* R5227 */ - 0x0000, /* R5228 */ - 0x0000, /* R5229 */ - 0x0000, /* R5230 */ - 0x0000, /* R5231 */ - 0x0000, /* R5232 */ - 0x0000, /* R5233 */ - 0x0000, /* R5234 */ - 0x0000, /* R5235 */ - 0x0000, /* R5236 */ - 0x0000, /* R5237 */ - 0x0000, /* R5238 */ - 0x0000, /* R5239 */ - 0x0000, /* R5240 */ - 0x0000, /* R5241 */ - 0x0000, /* R5242 */ - 0x0000, /* R5243 */ - 0x0000, /* R5244 */ - 0x0000, /* R5245 */ - 0x0000, /* R5246 */ - 0x0000, /* R5247 */ - 0x0000, /* R5248 */ - 0x0000, /* R5249 */ - 0x0000, /* R5250 */ - 0x0000, /* R5251 */ - 0x0000, /* R5252 */ - 0x0000, /* R5253 */ - 0x0000, /* R5254 */ - 0x0000, /* R5255 */ - 0x0000, /* R5256 */ - 0x0000, /* R5257 */ - 0x0000, /* R5258 */ - 0x0000, /* R5259 */ - 0x0000, /* R5260 */ - 0x0000, /* R5261 */ - 0x0000, /* R5262 */ - 0x0000, /* R5263 */ - 0x0000, /* R5264 */ - 0x0000, /* R5265 */ - 0x0000, /* R5266 */ - 0x0000, /* R5267 */ - 0x0000, /* R5268 */ - 0x0000, /* R5269 */ - 0x0000, /* R5270 */ - 0x0000, /* R5271 */ - 0x0000, /* R5272 */ - 0x0000, /* R5273 */ - 0x0000, /* R5274 */ - 0x0000, /* R5275 */ - 0x0000, /* R5276 */ - 0x0000, /* R5277 */ - 0x0000, /* R5278 */ - 0x0000, /* R5279 */ - 0x0000, /* R5280 */ - 0x0000, /* R5281 */ - 0x0000, /* R5282 */ - 0x0000, /* R5283 */ - 0x0000, /* R5284 */ - 0x0000, /* R5285 */ - 0x0000, /* R5286 */ - 0x0000, /* R5287 */ - 0x0000, /* R5288 */ - 0x0000, /* R5289 */ - 0x0000, /* R5290 */ - 0x0000, /* R5291 */ - 0x0000, /* R5292 */ - 0x0000, /* R5293 */ - 0x0000, /* R5294 */ - 0x0000, /* R5295 */ - 0x0000, /* R5296 */ - 0x0000, /* R5297 */ - 0x0000, /* R5298 */ - 0x0000, /* R5299 */ - 0x0000, /* R5300 */ - 0x0000, /* R5301 */ - 0x0000, /* R5302 */ - 0x0000, /* R5303 */ - 0x0000, /* R5304 */ - 0x0000, /* R5305 */ - 0x0000, /* R5306 */ - 0x0000, /* R5307 */ - 0x0000, /* R5308 */ - 0x0000, /* R5309 */ - 0x0000, /* R5310 */ - 0x0000, /* R5311 */ - 0x0000, /* R5312 */ - 0x0000, /* R5313 */ - 0x0000, /* R5314 */ - 0x0000, /* R5315 */ - 0x0000, /* R5316 */ - 0x0000, /* R5317 */ - 0x0000, /* R5318 */ - 0x0000, /* R5319 */ - 0x0000, /* R5320 */ - 0x0000, /* R5321 */ - 0x0000, /* R5322 */ - 0x0000, /* R5323 */ - 0x0000, /* R5324 */ - 0x0000, /* R5325 */ - 0x0000, /* R5326 */ - 0x0000, /* R5327 */ - 0x0000, /* R5328 */ - 0x0000, /* R5329 */ - 0x0000, /* R5330 */ - 0x0000, /* R5331 */ - 0x0000, /* R5332 */ - 0x0000, /* R5333 */ - 0x0000, /* R5334 */ - 0x0000, /* R5335 */ - 0x0000, /* R5336 */ - 0x0000, /* R5337 */ - 0x0000, /* R5338 */ - 0x0000, /* R5339 */ - 0x0000, /* R5340 */ - 0x0000, /* R5341 */ - 0x0000, /* R5342 */ - 0x0000, /* R5343 */ - 0x0000, /* R5344 */ - 0x0000, /* R5345 */ - 0x0000, /* R5346 */ - 0x0000, /* R5347 */ - 0x0000, /* R5348 */ - 0x0000, /* R5349 */ - 0x0000, /* R5350 */ - 0x0000, /* R5351 */ - 0x0000, /* R5352 */ - 0x0000, /* R5353 */ - 0x0000, /* R5354 */ - 0x0000, /* R5355 */ - 0x0000, /* R5356 */ - 0x0000, /* R5357 */ - 0x0000, /* R5358 */ - 0x0000, /* R5359 */ - 0x0000, /* R5360 */ - 0x0000, /* R5361 */ - 0x0000, /* R5362 */ - 0x0000, /* R5363 */ - 0x0000, /* R5364 */ - 0x0000, /* R5365 */ - 0x0000, /* R5366 */ - 0x0000, /* R5367 */ - 0x0000, /* R5368 */ - 0x0000, /* R5369 */ - 0x0000, /* R5370 */ - 0x0000, /* R5371 */ - 0x0000, /* R5372 */ - 0x0000, /* R5373 */ - 0x0000, /* R5374 */ - 0x0000, /* R5375 */ - 0x0000, /* R5376 */ - 0x0000, /* R5377 */ - 0x0000, /* R5378 */ - 0x0000, /* R5379 */ - 0x0000, /* R5380 */ - 0x0000, /* R5381 */ - 0x0000, /* R5382 */ - 0x0000, /* R5383 */ - 0x0000, /* R5384 */ - 0x0000, /* R5385 */ - 0x0000, /* R5386 */ - 0x0000, /* R5387 */ - 0x0000, /* R5388 */ - 0x0000, /* R5389 */ - 0x0000, /* R5390 */ - 0x0000, /* R5391 */ - 0x0000, /* R5392 */ - 0x0000, /* R5393 */ - 0x0000, /* R5394 */ - 0x0000, /* R5395 */ - 0x0000, /* R5396 */ - 0x0000, /* R5397 */ - 0x0000, /* R5398 */ - 0x0000, /* R5399 */ - 0x0000, /* R5400 */ - 0x0000, /* R5401 */ - 0x0000, /* R5402 */ - 0x0000, /* R5403 */ - 0x0000, /* R5404 */ - 0x0000, /* R5405 */ - 0x0000, /* R5406 */ - 0x0000, /* R5407 */ - 0x0000, /* R5408 */ - 0x0000, /* R5409 */ - 0x0000, /* R5410 */ - 0x0000, /* R5411 */ - 0x0000, /* R5412 */ - 0x0000, /* R5413 */ - 0x0000, /* R5414 */ - 0x0000, /* R5415 */ - 0x0000, /* R5416 */ - 0x0000, /* R5417 */ - 0x0000, /* R5418 */ - 0x0000, /* R5419 */ - 0x0000, /* R5420 */ - 0x0000, /* R5421 */ - 0x0000, /* R5422 */ - 0x0000, /* R5423 */ - 0x0000, /* R5424 */ - 0x0000, /* R5425 */ - 0x0000, /* R5426 */ - 0x0000, /* R5427 */ - 0x0000, /* R5428 */ - 0x0000, /* R5429 */ - 0x0000, /* R5430 */ - 0x0000, /* R5431 */ - 0x0000, /* R5432 */ - 0x0000, /* R5433 */ - 0x0000, /* R5434 */ - 0x0000, /* R5435 */ - 0x0000, /* R5436 */ - 0x0000, /* R5437 */ - 0x0000, /* R5438 */ - 0x0000, /* R5439 */ - 0x0000, /* R5440 */ - 0x0000, /* R5441 */ - 0x0000, /* R5442 */ - 0x0000, /* R5443 */ - 0x0000, /* R5444 */ - 0x0000, /* R5445 */ - 0x0000, /* R5446 */ - 0x0000, /* R5447 */ - 0x0000, /* R5448 */ - 0x0000, /* R5449 */ - 0x0000, /* R5450 */ - 0x0000, /* R5451 */ - 0x0000, /* R5452 */ - 0x0000, /* R5453 */ - 0x0000, /* R5454 */ - 0x0000, /* R5455 */ - 0x0000, /* R5456 */ - 0x0000, /* R5457 */ - 0x0000, /* R5458 */ - 0x0000, /* R5459 */ - 0x0000, /* R5460 */ - 0x0000, /* R5461 */ - 0x0000, /* R5462 */ - 0x0000, /* R5463 */ - 0x0000, /* R5464 */ - 0x0000, /* R5465 */ - 0x0000, /* R5466 */ - 0x0000, /* R5467 */ - 0x0000, /* R5468 */ - 0x0000, /* R5469 */ - 0x0000, /* R5470 */ - 0x0000, /* R5471 */ - 0x0000, /* R5472 */ - 0x0000, /* R5473 */ - 0x0000, /* R5474 */ - 0x0000, /* R5475 */ - 0x0000, /* R5476 */ - 0x0000, /* R5477 */ - 0x0000, /* R5478 */ - 0x0000, /* R5479 */ - 0x0000, /* R5480 */ - 0x0000, /* R5481 */ - 0x0000, /* R5482 */ - 0x0000, /* R5483 */ - 0x0000, /* R5484 */ - 0x0000, /* R5485 */ - 0x0000, /* R5486 */ - 0x0000, /* R5487 */ - 0x0000, /* R5488 */ - 0x0000, /* R5489 */ - 0x0000, /* R5490 */ - 0x0000, /* R5491 */ - 0x0000, /* R5492 */ - 0x0000, /* R5493 */ - 0x0000, /* R5494 */ - 0x0000, /* R5495 */ - 0x0000, /* R5496 */ - 0x0000, /* R5497 */ - 0x0000, /* R5498 */ - 0x0000, /* R5499 */ - 0x0000, /* R5500 */ - 0x0000, /* R5501 */ - 0x0000, /* R5502 */ - 0x0000, /* R5503 */ - 0x0000, /* R5504 */ - 0x0000, /* R5505 */ - 0x0000, /* R5506 */ - 0x0000, /* R5507 */ - 0x0000, /* R5508 */ - 0x0000, /* R5509 */ - 0x0000, /* R5510 */ - 0x0000, /* R5511 */ - 0x0000, /* R5512 */ - 0x0000, /* R5513 */ - 0x0000, /* R5514 */ - 0x0000, /* R5515 */ - 0x0000, /* R5516 */ - 0x0000, /* R5517 */ - 0x0000, /* R5518 */ - 0x0000, /* R5519 */ - 0x0000, /* R5520 */ - 0x0000, /* R5521 */ - 0x0000, /* R5522 */ - 0x0000, /* R5523 */ - 0x0000, /* R5524 */ - 0x0000, /* R5525 */ - 0x0000, /* R5526 */ - 0x0000, /* R5527 */ - 0x0000, /* R5528 */ - 0x0000, /* R5529 */ - 0x0000, /* R5530 */ - 0x0000, /* R5531 */ - 0x0000, /* R5532 */ - 0x0000, /* R5533 */ - 0x0000, /* R5534 */ - 0x0000, /* R5535 */ - 0x0000, /* R5536 */ - 0x0000, /* R5537 */ - 0x0000, /* R5538 */ - 0x0000, /* R5539 */ - 0x0000, /* R5540 */ - 0x0000, /* R5541 */ - 0x0000, /* R5542 */ - 0x0000, /* R5543 */ - 0x0000, /* R5544 */ - 0x0000, /* R5545 */ - 0x0000, /* R5546 */ - 0x0000, /* R5547 */ - 0x0000, /* R5548 */ - 0x0000, /* R5549 */ - 0x0000, /* R5550 */ - 0x0000, /* R5551 */ - 0x0000, /* R5552 */ - 0x0000, /* R5553 */ - 0x0000, /* R5554 */ - 0x0000, /* R5555 */ - 0x0000, /* R5556 */ - 0x0000, /* R5557 */ - 0x0000, /* R5558 */ - 0x0000, /* R5559 */ - 0x0000, /* R5560 */ - 0x0000, /* R5561 */ - 0x0000, /* R5562 */ - 0x0000, /* R5563 */ - 0x0000, /* R5564 */ - 0x0000, /* R5565 */ - 0x0000, /* R5566 */ - 0x0000, /* R5567 */ - 0x0000, /* R5568 */ - 0x0000, /* R5569 */ - 0x0000, /* R5570 */ - 0x0000, /* R5571 */ - 0x0000, /* R5572 */ - 0x0000, /* R5573 */ - 0x0000, /* R5574 */ - 0x0000, /* R5575 */ - 0x0000, /* R5576 */ - 0x0000, /* R5577 */ - 0x0000, /* R5578 */ - 0x0000, /* R5579 */ - 0x0000, /* R5580 */ - 0x0000, /* R5581 */ - 0x0000, /* R5582 */ - 0x0000, /* R5583 */ - 0x0000, /* R5584 */ - 0x0000, /* R5585 */ - 0x0000, /* R5586 */ - 0x0000, /* R5587 */ - 0x0000, /* R5588 */ - 0x0000, /* R5589 */ - 0x0000, /* R5590 */ - 0x0000, /* R5591 */ - 0x0000, /* R5592 */ - 0x0000, /* R5593 */ - 0x0000, /* R5594 */ - 0x0000, /* R5595 */ - 0x0000, /* R5596 */ - 0x0000, /* R5597 */ - 0x0000, /* R5598 */ - 0x0000, /* R5599 */ - 0x0000, /* R5600 */ - 0x0000, /* R5601 */ - 0x0000, /* R5602 */ - 0x0000, /* R5603 */ - 0x0000, /* R5604 */ - 0x0000, /* R5605 */ - 0x0000, /* R5606 */ - 0x0000, /* R5607 */ - 0x0000, /* R5608 */ - 0x0000, /* R5609 */ - 0x0000, /* R5610 */ - 0x0000, /* R5611 */ - 0x0000, /* R5612 */ - 0x0000, /* R5613 */ - 0x0000, /* R5614 */ - 0x0000, /* R5615 */ - 0x0000, /* R5616 */ - 0x0000, /* R5617 */ - 0x0000, /* R5618 */ - 0x0000, /* R5619 */ - 0x0000, /* R5620 */ - 0x0000, /* R5621 */ - 0x0000, /* R5622 */ - 0x0000, /* R5623 */ - 0x0000, /* R5624 */ - 0x0000, /* R5625 */ - 0x0000, /* R5626 */ - 0x0000, /* R5627 */ - 0x0000, /* R5628 */ - 0x0000, /* R5629 */ - 0x0000, /* R5630 */ - 0x0000, /* R5631 */ - 0x0000, /* R5632 */ - 0x0000, /* R5633 */ - 0x0000, /* R5634 */ - 0x0000, /* R5635 */ - 0x0000, /* R5636 */ - 0x0000, /* R5637 */ - 0x0000, /* R5638 */ - 0x0000, /* R5639 */ - 0x0000, /* R5640 */ - 0x0000, /* R5641 */ - 0x0000, /* R5642 */ - 0x0000, /* R5643 */ - 0x0000, /* R5644 */ - 0x0000, /* R5645 */ - 0x0000, /* R5646 */ - 0x0000, /* R5647 */ - 0x0000, /* R5648 */ - 0x0000, /* R5649 */ - 0x0000, /* R5650 */ - 0x0000, /* R5651 */ - 0x0000, /* R5652 */ - 0x0000, /* R5653 */ - 0x0000, /* R5654 */ - 0x0000, /* R5655 */ - 0x0000, /* R5656 */ - 0x0000, /* R5657 */ - 0x0000, /* R5658 */ - 0x0000, /* R5659 */ - 0x0000, /* R5660 */ - 0x0000, /* R5661 */ - 0x0000, /* R5662 */ - 0x0000, /* R5663 */ - 0x0000, /* R5664 */ - 0x0000, /* R5665 */ - 0x0000, /* R5666 */ - 0x0000, /* R5667 */ - 0x0000, /* R5668 */ - 0x0000, /* R5669 */ - 0x0000, /* R5670 */ - 0x0000, /* R5671 */ - 0x0000, /* R5672 */ - 0x0000, /* R5673 */ - 0x0000, /* R5674 */ - 0x0000, /* R5675 */ - 0x0000, /* R5676 */ - 0x0000, /* R5677 */ - 0x0000, /* R5678 */ - 0x0000, /* R5679 */ - 0x0000, /* R5680 */ - 0x0000, /* R5681 */ - 0x0000, /* R5682 */ - 0x0000, /* R5683 */ - 0x0000, /* R5684 */ - 0x0000, /* R5685 */ - 0x0000, /* R5686 */ - 0x0000, /* R5687 */ - 0x0000, /* R5688 */ - 0x0000, /* R5689 */ - 0x0000, /* R5690 */ - 0x0000, /* R5691 */ - 0x0000, /* R5692 */ - 0x0000, /* R5693 */ - 0x0000, /* R5694 */ - 0x0000, /* R5695 */ - 0x0000, /* R5696 */ - 0x0000, /* R5697 */ - 0x0000, /* R5698 */ - 0x0000, /* R5699 */ - 0x0000, /* R5700 */ - 0x0000, /* R5701 */ - 0x0000, /* R5702 */ - 0x0000, /* R5703 */ - 0x0000, /* R5704 */ - 0x0000, /* R5705 */ - 0x0000, /* R5706 */ - 0x0000, /* R5707 */ - 0x0000, /* R5708 */ - 0x0000, /* R5709 */ - 0x0000, /* R5710 */ - 0x0000, /* R5711 */ - 0x0000, /* R5712 */ - 0x0000, /* R5713 */ - 0x0000, /* R5714 */ - 0x0000, /* R5715 */ - 0x0000, /* R5716 */ - 0x0000, /* R5717 */ - 0x0000, /* R5718 */ - 0x0000, /* R5719 */ - 0x0000, /* R5720 */ - 0x0000, /* R5721 */ - 0x0000, /* R5722 */ - 0x0000, /* R5723 */ - 0x0000, /* R5724 */ - 0x0000, /* R5725 */ - 0x0000, /* R5726 */ - 0x0000, /* R5727 */ - 0x0000, /* R5728 */ - 0x0000, /* R5729 */ - 0x0000, /* R5730 */ - 0x0000, /* R5731 */ - 0x0000, /* R5732 */ - 0x0000, /* R5733 */ - 0x0000, /* R5734 */ - 0x0000, /* R5735 */ - 0x0000, /* R5736 */ - 0x0000, /* R5737 */ - 0x0000, /* R5738 */ - 0x0000, /* R5739 */ - 0x0000, /* R5740 */ - 0x0000, /* R5741 */ - 0x0000, /* R5742 */ - 0x0000, /* R5743 */ - 0x0000, /* R5744 */ - 0x0000, /* R5745 */ - 0x0000, /* R5746 */ - 0x0000, /* R5747 */ - 0x0000, /* R5748 */ - 0x0000, /* R5749 */ - 0x0000, /* R5750 */ - 0x0000, /* R5751 */ - 0x0000, /* R5752 */ - 0x0000, /* R5753 */ - 0x0000, /* R5754 */ - 0x0000, /* R5755 */ - 0x0000, /* R5756 */ - 0x0000, /* R5757 */ - 0x0000, /* R5758 */ - 0x0000, /* R5759 */ - 0x0000, /* R5760 */ - 0x0000, /* R5761 */ - 0x0000, /* R5762 */ - 0x0000, /* R5763 */ - 0x0000, /* R5764 */ - 0x0000, /* R5765 */ - 0x0000, /* R5766 */ - 0x0000, /* R5767 */ - 0x0000, /* R5768 */ - 0x0000, /* R5769 */ - 0x0000, /* R5770 */ - 0x0000, /* R5771 */ - 0x0000, /* R5772 */ - 0x0000, /* R5773 */ - 0x0000, /* R5774 */ - 0x0000, /* R5775 */ - 0x0000, /* R5776 */ - 0x0000, /* R5777 */ - 0x0000, /* R5778 */ - 0x0000, /* R5779 */ - 0x0000, /* R5780 */ - 0x0000, /* R5781 */ - 0x0000, /* R5782 */ - 0x0000, /* R5783 */ - 0x0000, /* R5784 */ - 0x0000, /* R5785 */ - 0x0000, /* R5786 */ - 0x0000, /* R5787 */ - 0x0000, /* R5788 */ - 0x0000, /* R5789 */ - 0x0000, /* R5790 */ - 0x0000, /* R5791 */ - 0x0000, /* R5792 */ - 0x0000, /* R5793 */ - 0x0000, /* R5794 */ - 0x0000, /* R5795 */ - 0x0000, /* R5796 */ - 0x0000, /* R5797 */ - 0x0000, /* R5798 */ - 0x0000, /* R5799 */ - 0x0000, /* R5800 */ - 0x0000, /* R5801 */ - 0x0000, /* R5802 */ - 0x0000, /* R5803 */ - 0x0000, /* R5804 */ - 0x0000, /* R5805 */ - 0x0000, /* R5806 */ - 0x0000, /* R5807 */ - 0x0000, /* R5808 */ - 0x0000, /* R5809 */ - 0x0000, /* R5810 */ - 0x0000, /* R5811 */ - 0x0000, /* R5812 */ - 0x0000, /* R5813 */ - 0x0000, /* R5814 */ - 0x0000, /* R5815 */ - 0x0000, /* R5816 */ - 0x0000, /* R5817 */ - 0x0000, /* R5818 */ - 0x0000, /* R5819 */ - 0x0000, /* R5820 */ - 0x0000, /* R5821 */ - 0x0000, /* R5822 */ - 0x0000, /* R5823 */ - 0x0000, /* R5824 */ - 0x0000, /* R5825 */ - 0x0000, /* R5826 */ - 0x0000, /* R5827 */ - 0x0000, /* R5828 */ - 0x0000, /* R5829 */ - 0x0000, /* R5830 */ - 0x0000, /* R5831 */ - 0x0000, /* R5832 */ - 0x0000, /* R5833 */ - 0x0000, /* R5834 */ - 0x0000, /* R5835 */ - 0x0000, /* R5836 */ - 0x0000, /* R5837 */ - 0x0000, /* R5838 */ - 0x0000, /* R5839 */ - 0x0000, /* R5840 */ - 0x0000, /* R5841 */ - 0x0000, /* R5842 */ - 0x0000, /* R5843 */ - 0x0000, /* R5844 */ - 0x0000, /* R5845 */ - 0x0000, /* R5846 */ - 0x0000, /* R5847 */ - 0x0000, /* R5848 */ - 0x0000, /* R5849 */ - 0x0000, /* R5850 */ - 0x0000, /* R5851 */ - 0x0000, /* R5852 */ - 0x0000, /* R5853 */ - 0x0000, /* R5854 */ - 0x0000, /* R5855 */ - 0x0000, /* R5856 */ - 0x0000, /* R5857 */ - 0x0000, /* R5858 */ - 0x0000, /* R5859 */ - 0x0000, /* R5860 */ - 0x0000, /* R5861 */ - 0x0000, /* R5862 */ - 0x0000, /* R5863 */ - 0x0000, /* R5864 */ - 0x0000, /* R5865 */ - 0x0000, /* R5866 */ - 0x0000, /* R5867 */ - 0x0000, /* R5868 */ - 0x0000, /* R5869 */ - 0x0000, /* R5870 */ - 0x0000, /* R5871 */ - 0x0000, /* R5872 */ - 0x0000, /* R5873 */ - 0x0000, /* R5874 */ - 0x0000, /* R5875 */ - 0x0000, /* R5876 */ - 0x0000, /* R5877 */ - 0x0000, /* R5878 */ - 0x0000, /* R5879 */ - 0x0000, /* R5880 */ - 0x0000, /* R5881 */ - 0x0000, /* R5882 */ - 0x0000, /* R5883 */ - 0x0000, /* R5884 */ - 0x0000, /* R5885 */ - 0x0000, /* R5886 */ - 0x0000, /* R5887 */ - 0x0000, /* R5888 */ - 0x0000, /* R5889 */ - 0x0000, /* R5890 */ - 0x0000, /* R5891 */ - 0x0000, /* R5892 */ - 0x0000, /* R5893 */ - 0x0000, /* R5894 */ - 0x0000, /* R5895 */ - 0x0000, /* R5896 */ - 0x0000, /* R5897 */ - 0x0000, /* R5898 */ - 0x0000, /* R5899 */ - 0x0000, /* R5900 */ - 0x0000, /* R5901 */ - 0x0000, /* R5902 */ - 0x0000, /* R5903 */ - 0x0000, /* R5904 */ - 0x0000, /* R5905 */ - 0x0000, /* R5906 */ - 0x0000, /* R5907 */ - 0x0000, /* R5908 */ - 0x0000, /* R5909 */ - 0x0000, /* R5910 */ - 0x0000, /* R5911 */ - 0x0000, /* R5912 */ - 0x0000, /* R5913 */ - 0x0000, /* R5914 */ - 0x0000, /* R5915 */ - 0x0000, /* R5916 */ - 0x0000, /* R5917 */ - 0x0000, /* R5918 */ - 0x0000, /* R5919 */ - 0x0000, /* R5920 */ - 0x0000, /* R5921 */ - 0x0000, /* R5922 */ - 0x0000, /* R5923 */ - 0x0000, /* R5924 */ - 0x0000, /* R5925 */ - 0x0000, /* R5926 */ - 0x0000, /* R5927 */ - 0x0000, /* R5928 */ - 0x0000, /* R5929 */ - 0x0000, /* R5930 */ - 0x0000, /* R5931 */ - 0x0000, /* R5932 */ - 0x0000, /* R5933 */ - 0x0000, /* R5934 */ - 0x0000, /* R5935 */ - 0x0000, /* R5936 */ - 0x0000, /* R5937 */ - 0x0000, /* R5938 */ - 0x0000, /* R5939 */ - 0x0000, /* R5940 */ - 0x0000, /* R5941 */ - 0x0000, /* R5942 */ - 0x0000, /* R5943 */ - 0x0000, /* R5944 */ - 0x0000, /* R5945 */ - 0x0000, /* R5946 */ - 0x0000, /* R5947 */ - 0x0000, /* R5948 */ - 0x0000, /* R5949 */ - 0x0000, /* R5950 */ - 0x0000, /* R5951 */ - 0x0000, /* R5952 */ - 0x0000, /* R5953 */ - 0x0000, /* R5954 */ - 0x0000, /* R5955 */ - 0x0000, /* R5956 */ - 0x0000, /* R5957 */ - 0x0000, /* R5958 */ - 0x0000, /* R5959 */ - 0x0000, /* R5960 */ - 0x0000, /* R5961 */ - 0x0000, /* R5962 */ - 0x0000, /* R5963 */ - 0x0000, /* R5964 */ - 0x0000, /* R5965 */ - 0x0000, /* R5966 */ - 0x0000, /* R5967 */ - 0x0000, /* R5968 */ - 0x0000, /* R5969 */ - 0x0000, /* R5970 */ - 0x0000, /* R5971 */ - 0x0000, /* R5972 */ - 0x0000, /* R5973 */ - 0x0000, /* R5974 */ - 0x0000, /* R5975 */ - 0x0000, /* R5976 */ - 0x0000, /* R5977 */ - 0x0000, /* R5978 */ - 0x0000, /* R5979 */ - 0x0000, /* R5980 */ - 0x0000, /* R5981 */ - 0x0000, /* R5982 */ - 0x0000, /* R5983 */ - 0x0000, /* R5984 */ - 0x0000, /* R5985 */ - 0x0000, /* R5986 */ - 0x0000, /* R5987 */ - 0x0000, /* R5988 */ - 0x0000, /* R5989 */ - 0x0000, /* R5990 */ - 0x0000, /* R5991 */ - 0x0000, /* R5992 */ - 0x0000, /* R5993 */ - 0x0000, /* R5994 */ - 0x0000, /* R5995 */ - 0x0000, /* R5996 */ - 0x0000, /* R5997 */ - 0x0000, /* R5998 */ - 0x0000, /* R5999 */ - 0x0000, /* R6000 */ - 0x0000, /* R6001 */ - 0x0000, /* R6002 */ - 0x0000, /* R6003 */ - 0x0000, /* R6004 */ - 0x0000, /* R6005 */ - 0x0000, /* R6006 */ - 0x0000, /* R6007 */ - 0x0000, /* R6008 */ - 0x0000, /* R6009 */ - 0x0000, /* R6010 */ - 0x0000, /* R6011 */ - 0x0000, /* R6012 */ - 0x0000, /* R6013 */ - 0x0000, /* R6014 */ - 0x0000, /* R6015 */ - 0x0000, /* R6016 */ - 0x0000, /* R6017 */ - 0x0000, /* R6018 */ - 0x0000, /* R6019 */ - 0x0000, /* R6020 */ - 0x0000, /* R6021 */ - 0x0000, /* R6022 */ - 0x0000, /* R6023 */ - 0x0000, /* R6024 */ - 0x0000, /* R6025 */ - 0x0000, /* R6026 */ - 0x0000, /* R6027 */ - 0x0000, /* R6028 */ - 0x0000, /* R6029 */ - 0x0000, /* R6030 */ - 0x0000, /* R6031 */ - 0x0000, /* R6032 */ - 0x0000, /* R6033 */ - 0x0000, /* R6034 */ - 0x0000, /* R6035 */ - 0x0000, /* R6036 */ - 0x0000, /* R6037 */ - 0x0000, /* R6038 */ - 0x0000, /* R6039 */ - 0x0000, /* R6040 */ - 0x0000, /* R6041 */ - 0x0000, /* R6042 */ - 0x0000, /* R6043 */ - 0x0000, /* R6044 */ - 0x0000, /* R6045 */ - 0x0000, /* R6046 */ - 0x0000, /* R6047 */ - 0x0000, /* R6048 */ - 0x0000, /* R6049 */ - 0x0000, /* R6050 */ - 0x0000, /* R6051 */ - 0x0000, /* R6052 */ - 0x0000, /* R6053 */ - 0x0000, /* R6054 */ - 0x0000, /* R6055 */ - 0x0000, /* R6056 */ - 0x0000, /* R6057 */ - 0x0000, /* R6058 */ - 0x0000, /* R6059 */ - 0x0000, /* R6060 */ - 0x0000, /* R6061 */ - 0x0000, /* R6062 */ - 0x0000, /* R6063 */ - 0x0000, /* R6064 */ - 0x0000, /* R6065 */ - 0x0000, /* R6066 */ - 0x0000, /* R6067 */ - 0x0000, /* R6068 */ - 0x0000, /* R6069 */ - 0x0000, /* R6070 */ - 0x0000, /* R6071 */ - 0x0000, /* R6072 */ - 0x0000, /* R6073 */ - 0x0000, /* R6074 */ - 0x0000, /* R6075 */ - 0x0000, /* R6076 */ - 0x0000, /* R6077 */ - 0x0000, /* R6078 */ - 0x0000, /* R6079 */ - 0x0000, /* R6080 */ - 0x0000, /* R6081 */ - 0x0000, /* R6082 */ - 0x0000, /* R6083 */ - 0x0000, /* R6084 */ - 0x0000, /* R6085 */ - 0x0000, /* R6086 */ - 0x0000, /* R6087 */ - 0x0000, /* R6088 */ - 0x0000, /* R6089 */ - 0x0000, /* R6090 */ - 0x0000, /* R6091 */ - 0x0000, /* R6092 */ - 0x0000, /* R6093 */ - 0x0000, /* R6094 */ - 0x0000, /* R6095 */ - 0x0000, /* R6096 */ - 0x0000, /* R6097 */ - 0x0000, /* R6098 */ - 0x0000, /* R6099 */ - 0x0000, /* R6100 */ - 0x0000, /* R6101 */ - 0x0000, /* R6102 */ - 0x0000, /* R6103 */ - 0x0000, /* R6104 */ - 0x0000, /* R6105 */ - 0x0000, /* R6106 */ - 0x0000, /* R6107 */ - 0x0000, /* R6108 */ - 0x0000, /* R6109 */ - 0x0000, /* R6110 */ - 0x0000, /* R6111 */ - 0x0000, /* R6112 */ - 0x0000, /* R6113 */ - 0x0000, /* R6114 */ - 0x0000, /* R6115 */ - 0x0000, /* R6116 */ - 0x0000, /* R6117 */ - 0x0000, /* R6118 */ - 0x0000, /* R6119 */ - 0x0000, /* R6120 */ - 0x0000, /* R6121 */ - 0x0000, /* R6122 */ - 0x0000, /* R6123 */ - 0x0000, /* R6124 */ - 0x0000, /* R6125 */ - 0x0000, /* R6126 */ - 0x0000, /* R6127 */ - 0x0000, /* R6128 */ - 0x0000, /* R6129 */ - 0x0000, /* R6130 */ - 0x0000, /* R6131 */ - 0x0000, /* R6132 */ - 0x0000, /* R6133 */ - 0x0000, /* R6134 */ - 0x0000, /* R6135 */ - 0x0000, /* R6136 */ - 0x0000, /* R6137 */ - 0x0000, /* R6138 */ - 0x0000, /* R6139 */ - 0x0000, /* R6140 */ - 0x0000, /* R6141 */ - 0x0000, /* R6142 */ - 0x0000, /* R6143 */ - 0x0000, /* R6144 */ - 0x0000, /* R6145 */ - 0x0000, /* R6146 */ - 0x0000, /* R6147 */ - 0x0000, /* R6148 */ - 0x0000, /* R6149 */ - 0x0000, /* R6150 */ - 0x0000, /* R6151 */ - 0x0000, /* R6152 */ - 0x0000, /* R6153 */ - 0x0000, /* R6154 */ - 0x0000, /* R6155 */ - 0x0000, /* R6156 */ - 0x0000, /* R6157 */ - 0x0000, /* R6158 */ - 0x0000, /* R6159 */ - 0x0000, /* R6160 */ - 0x0000, /* R6161 */ - 0x0000, /* R6162 */ - 0x0000, /* R6163 */ - 0x0000, /* R6164 */ - 0x0000, /* R6165 */ - 0x0000, /* R6166 */ - 0x0000, /* R6167 */ - 0x0000, /* R6168 */ - 0x0000, /* R6169 */ - 0x0000, /* R6170 */ - 0x0000, /* R6171 */ - 0x0000, /* R6172 */ - 0x0000, /* R6173 */ - 0x0000, /* R6174 */ - 0x0000, /* R6175 */ - 0x0000, /* R6176 */ - 0x0000, /* R6177 */ - 0x0000, /* R6178 */ - 0x0000, /* R6179 */ - 0x0000, /* R6180 */ - 0x0000, /* R6181 */ - 0x0000, /* R6182 */ - 0x0000, /* R6183 */ - 0x0000, /* R6184 */ - 0x0000, /* R6185 */ - 0x0000, /* R6186 */ - 0x0000, /* R6187 */ - 0x0000, /* R6188 */ - 0x0000, /* R6189 */ - 0x0000, /* R6190 */ - 0x0000, /* R6191 */ - 0x0000, /* R6192 */ - 0x0000, /* R6193 */ - 0x0000, /* R6194 */ - 0x0000, /* R6195 */ - 0x0000, /* R6196 */ - 0x0000, /* R6197 */ - 0x0000, /* R6198 */ - 0x0000, /* R6199 */ - 0x0000, /* R6200 */ - 0x0000, /* R6201 */ - 0x0000, /* R6202 */ - 0x0000, /* R6203 */ - 0x0000, /* R6204 */ - 0x0000, /* R6205 */ - 0x0000, /* R6206 */ - 0x0000, /* R6207 */ - 0x0000, /* R6208 */ - 0x0000, /* R6209 */ - 0x0000, /* R6210 */ - 0x0000, /* R6211 */ - 0x0000, /* R6212 */ - 0x0000, /* R6213 */ - 0x0000, /* R6214 */ - 0x0000, /* R6215 */ - 0x0000, /* R6216 */ - 0x0000, /* R6217 */ - 0x0000, /* R6218 */ - 0x0000, /* R6219 */ - 0x0000, /* R6220 */ - 0x0000, /* R6221 */ - 0x0000, /* R6222 */ - 0x0000, /* R6223 */ - 0x0000, /* R6224 */ - 0x0000, /* R6225 */ - 0x0000, /* R6226 */ - 0x0000, /* R6227 */ - 0x0000, /* R6228 */ - 0x0000, /* R6229 */ - 0x0000, /* R6230 */ - 0x0000, /* R6231 */ - 0x0000, /* R6232 */ - 0x0000, /* R6233 */ - 0x0000, /* R6234 */ - 0x0000, /* R6235 */ - 0x0000, /* R6236 */ - 0x0000, /* R6237 */ - 0x0000, /* R6238 */ - 0x0000, /* R6239 */ - 0x0000, /* R6240 */ - 0x0000, /* R6241 */ - 0x0000, /* R6242 */ - 0x0000, /* R6243 */ - 0x0000, /* R6244 */ - 0x0000, /* R6245 */ - 0x0000, /* R6246 */ - 0x0000, /* R6247 */ - 0x0000, /* R6248 */ - 0x0000, /* R6249 */ - 0x0000, /* R6250 */ - 0x0000, /* R6251 */ - 0x0000, /* R6252 */ - 0x0000, /* R6253 */ - 0x0000, /* R6254 */ - 0x0000, /* R6255 */ - 0x0000, /* R6256 */ - 0x0000, /* R6257 */ - 0x0000, /* R6258 */ - 0x0000, /* R6259 */ - 0x0000, /* R6260 */ - 0x0000, /* R6261 */ - 0x0000, /* R6262 */ - 0x0000, /* R6263 */ - 0x0000, /* R6264 */ - 0x0000, /* R6265 */ - 0x0000, /* R6266 */ - 0x0000, /* R6267 */ - 0x0000, /* R6268 */ - 0x0000, /* R6269 */ - 0x0000, /* R6270 */ - 0x0000, /* R6271 */ - 0x0000, /* R6272 */ - 0x0000, /* R6273 */ - 0x0000, /* R6274 */ - 0x0000, /* R6275 */ - 0x0000, /* R6276 */ - 0x0000, /* R6277 */ - 0x0000, /* R6278 */ - 0x0000, /* R6279 */ - 0x0000, /* R6280 */ - 0x0000, /* R6281 */ - 0x0000, /* R6282 */ - 0x0000, /* R6283 */ - 0x0000, /* R6284 */ - 0x0000, /* R6285 */ - 0x0000, /* R6286 */ - 0x0000, /* R6287 */ - 0x0000, /* R6288 */ - 0x0000, /* R6289 */ - 0x0000, /* R6290 */ - 0x0000, /* R6291 */ - 0x0000, /* R6292 */ - 0x0000, /* R6293 */ - 0x0000, /* R6294 */ - 0x0000, /* R6295 */ - 0x0000, /* R6296 */ - 0x0000, /* R6297 */ - 0x0000, /* R6298 */ - 0x0000, /* R6299 */ - 0x0000, /* R6300 */ - 0x0000, /* R6301 */ - 0x0000, /* R6302 */ - 0x0000, /* R6303 */ - 0x0000, /* R6304 */ - 0x0000, /* R6305 */ - 0x0000, /* R6306 */ - 0x0000, /* R6307 */ - 0x0000, /* R6308 */ - 0x0000, /* R6309 */ - 0x0000, /* R6310 */ - 0x0000, /* R6311 */ - 0x0000, /* R6312 */ - 0x0000, /* R6313 */ - 0x0000, /* R6314 */ - 0x0000, /* R6315 */ - 0x0000, /* R6316 */ - 0x0000, /* R6317 */ - 0x0000, /* R6318 */ - 0x0000, /* R6319 */ - 0x0000, /* R6320 */ - 0x0000, /* R6321 */ - 0x0000, /* R6322 */ - 0x0000, /* R6323 */ - 0x0000, /* R6324 */ - 0x0000, /* R6325 */ - 0x0000, /* R6326 */ - 0x0000, /* R6327 */ - 0x0000, /* R6328 */ - 0x0000, /* R6329 */ - 0x0000, /* R6330 */ - 0x0000, /* R6331 */ - 0x0000, /* R6332 */ - 0x0000, /* R6333 */ - 0x0000, /* R6334 */ - 0x0000, /* R6335 */ - 0x0000, /* R6336 */ - 0x0000, /* R6337 */ - 0x0000, /* R6338 */ - 0x0000, /* R6339 */ - 0x0000, /* R6340 */ - 0x0000, /* R6341 */ - 0x0000, /* R6342 */ - 0x0000, /* R6343 */ - 0x0000, /* R6344 */ - 0x0000, /* R6345 */ - 0x0000, /* R6346 */ - 0x0000, /* R6347 */ - 0x0000, /* R6348 */ - 0x0000, /* R6349 */ - 0x0000, /* R6350 */ - 0x0000, /* R6351 */ - 0x0000, /* R6352 */ - 0x0000, /* R6353 */ - 0x0000, /* R6354 */ - 0x0000, /* R6355 */ - 0x0000, /* R6356 */ - 0x0000, /* R6357 */ - 0x0000, /* R6358 */ - 0x0000, /* R6359 */ - 0x0000, /* R6360 */ - 0x0000, /* R6361 */ - 0x0000, /* R6362 */ - 0x0000, /* R6363 */ - 0x0000, /* R6364 */ - 0x0000, /* R6365 */ - 0x0000, /* R6366 */ - 0x0000, /* R6367 */ - 0x0000, /* R6368 */ - 0x0000, /* R6369 */ - 0x0000, /* R6370 */ - 0x0000, /* R6371 */ - 0x0000, /* R6372 */ - 0x0000, /* R6373 */ - 0x0000, /* R6374 */ - 0x0000, /* R6375 */ - 0x0000, /* R6376 */ - 0x0000, /* R6377 */ - 0x0000, /* R6378 */ - 0x0000, /* R6379 */ - 0x0000, /* R6380 */ - 0x0000, /* R6381 */ - 0x0000, /* R6382 */ - 0x0000, /* R6383 */ - 0x0000, /* R6384 */ - 0x0000, /* R6385 */ - 0x0000, /* R6386 */ - 0x0000, /* R6387 */ - 0x0000, /* R6388 */ - 0x0000, /* R6389 */ - 0x0000, /* R6390 */ - 0x0000, /* R6391 */ - 0x0000, /* R6392 */ - 0x0000, /* R6393 */ - 0x0000, /* R6394 */ - 0x0000, /* R6395 */ - 0x0000, /* R6396 */ - 0x0000, /* R6397 */ - 0x0000, /* R6398 */ - 0x0000, /* R6399 */ - 0x0000, /* R6400 */ - 0x0000, /* R6401 */ - 0x0000, /* R6402 */ - 0x0000, /* R6403 */ - 0x0000, /* R6404 */ - 0x0000, /* R6405 */ - 0x0000, /* R6406 */ - 0x0000, /* R6407 */ - 0x0000, /* R6408 */ - 0x0000, /* R6409 */ - 0x0000, /* R6410 */ - 0x0000, /* R6411 */ - 0x0000, /* R6412 */ - 0x0000, /* R6413 */ - 0x0000, /* R6414 */ - 0x0000, /* R6415 */ - 0x0000, /* R6416 */ - 0x0000, /* R6417 */ - 0x0000, /* R6418 */ - 0x0000, /* R6419 */ - 0x0000, /* R6420 */ - 0x0000, /* R6421 */ - 0x0000, /* R6422 */ - 0x0000, /* R6423 */ - 0x0000, /* R6424 */ - 0x0000, /* R6425 */ - 0x0000, /* R6426 */ - 0x0000, /* R6427 */ - 0x0000, /* R6428 */ - 0x0000, /* R6429 */ - 0x0000, /* R6430 */ - 0x0000, /* R6431 */ - 0x0000, /* R6432 */ - 0x0000, /* R6433 */ - 0x0000, /* R6434 */ - 0x0000, /* R6435 */ - 0x0000, /* R6436 */ - 0x0000, /* R6437 */ - 0x0000, /* R6438 */ - 0x0000, /* R6439 */ - 0x0000, /* R6440 */ - 0x0000, /* R6441 */ - 0x0000, /* R6442 */ - 0x0000, /* R6443 */ - 0x0000, /* R6444 */ - 0x0000, /* R6445 */ - 0x0000, /* R6446 */ - 0x0000, /* R6447 */ - 0x0000, /* R6448 */ - 0x0000, /* R6449 */ - 0x0000, /* R6450 */ - 0x0000, /* R6451 */ - 0x0000, /* R6452 */ - 0x0000, /* R6453 */ - 0x0000, /* R6454 */ - 0x0000, /* R6455 */ - 0x0000, /* R6456 */ - 0x0000, /* R6457 */ - 0x0000, /* R6458 */ - 0x0000, /* R6459 */ - 0x0000, /* R6460 */ - 0x0000, /* R6461 */ - 0x0000, /* R6462 */ - 0x0000, /* R6463 */ - 0x0000, /* R6464 */ - 0x0000, /* R6465 */ - 0x0000, /* R6466 */ - 0x0000, /* R6467 */ - 0x0000, /* R6468 */ - 0x0000, /* R6469 */ - 0x0000, /* R6470 */ - 0x0000, /* R6471 */ - 0x0000, /* R6472 */ - 0x0000, /* R6473 */ - 0x0000, /* R6474 */ - 0x0000, /* R6475 */ - 0x0000, /* R6476 */ - 0x0000, /* R6477 */ - 0x0000, /* R6478 */ - 0x0000, /* R6479 */ - 0x0000, /* R6480 */ - 0x0000, /* R6481 */ - 0x0000, /* R6482 */ - 0x0000, /* R6483 */ - 0x0000, /* R6484 */ - 0x0000, /* R6485 */ - 0x0000, /* R6486 */ - 0x0000, /* R6487 */ - 0x0000, /* R6488 */ - 0x0000, /* R6489 */ - 0x0000, /* R6490 */ - 0x0000, /* R6491 */ - 0x0000, /* R6492 */ - 0x0000, /* R6493 */ - 0x0000, /* R6494 */ - 0x0000, /* R6495 */ - 0x0000, /* R6496 */ - 0x0000, /* R6497 */ - 0x0000, /* R6498 */ - 0x0000, /* R6499 */ - 0x0000, /* R6500 */ - 0x0000, /* R6501 */ - 0x0000, /* R6502 */ - 0x0000, /* R6503 */ - 0x0000, /* R6504 */ - 0x0000, /* R6505 */ - 0x0000, /* R6506 */ - 0x0000, /* R6507 */ - 0x0000, /* R6508 */ - 0x0000, /* R6509 */ - 0x0000, /* R6510 */ - 0x0000, /* R6511 */ - 0x0000, /* R6512 */ - 0x0000, /* R6513 */ - 0x0000, /* R6514 */ - 0x0000, /* R6515 */ - 0x0000, /* R6516 */ - 0x0000, /* R6517 */ - 0x0000, /* R6518 */ - 0x0000, /* R6519 */ - 0x0000, /* R6520 */ - 0x0000, /* R6521 */ - 0x0000, /* R6522 */ - 0x0000, /* R6523 */ - 0x0000, /* R6524 */ - 0x0000, /* R6525 */ - 0x0000, /* R6526 */ - 0x0000, /* R6527 */ - 0x0000, /* R6528 */ - 0x0000, /* R6529 */ - 0x0000, /* R6530 */ - 0x0000, /* R6531 */ - 0x0000, /* R6532 */ - 0x0000, /* R6533 */ - 0x0000, /* R6534 */ - 0x0000, /* R6535 */ - 0x0000, /* R6536 */ - 0x0000, /* R6537 */ - 0x0000, /* R6538 */ - 0x0000, /* R6539 */ - 0x0000, /* R6540 */ - 0x0000, /* R6541 */ - 0x0000, /* R6542 */ - 0x0000, /* R6543 */ - 0x0000, /* R6544 */ - 0x0000, /* R6545 */ - 0x0000, /* R6546 */ - 0x0000, /* R6547 */ - 0x0000, /* R6548 */ - 0x0000, /* R6549 */ - 0x0000, /* R6550 */ - 0x0000, /* R6551 */ - 0x0000, /* R6552 */ - 0x0000, /* R6553 */ - 0x0000, /* R6554 */ - 0x0000, /* R6555 */ - 0x0000, /* R6556 */ - 0x0000, /* R6557 */ - 0x0000, /* R6558 */ - 0x0000, /* R6559 */ - 0x0000, /* R6560 */ - 0x0000, /* R6561 */ - 0x0000, /* R6562 */ - 0x0000, /* R6563 */ - 0x0000, /* R6564 */ - 0x0000, /* R6565 */ - 0x0000, /* R6566 */ - 0x0000, /* R6567 */ - 0x0000, /* R6568 */ - 0x0000, /* R6569 */ - 0x0000, /* R6570 */ - 0x0000, /* R6571 */ - 0x0000, /* R6572 */ - 0x0000, /* R6573 */ - 0x0000, /* R6574 */ - 0x0000, /* R6575 */ - 0x0000, /* R6576 */ - 0x0000, /* R6577 */ - 0x0000, /* R6578 */ - 0x0000, /* R6579 */ - 0x0000, /* R6580 */ - 0x0000, /* R6581 */ - 0x0000, /* R6582 */ - 0x0000, /* R6583 */ - 0x0000, /* R6584 */ - 0x0000, /* R6585 */ - 0x0000, /* R6586 */ - 0x0000, /* R6587 */ - 0x0000, /* R6588 */ - 0x0000, /* R6589 */ - 0x0000, /* R6590 */ - 0x0000, /* R6591 */ - 0x0000, /* R6592 */ - 0x0000, /* R6593 */ - 0x0000, /* R6594 */ - 0x0000, /* R6595 */ - 0x0000, /* R6596 */ - 0x0000, /* R6597 */ - 0x0000, /* R6598 */ - 0x0000, /* R6599 */ - 0x0000, /* R6600 */ - 0x0000, /* R6601 */ - 0x0000, /* R6602 */ - 0x0000, /* R6603 */ - 0x0000, /* R6604 */ - 0x0000, /* R6605 */ - 0x0000, /* R6606 */ - 0x0000, /* R6607 */ - 0x0000, /* R6608 */ - 0x0000, /* R6609 */ - 0x0000, /* R6610 */ - 0x0000, /* R6611 */ - 0x0000, /* R6612 */ - 0x0000, /* R6613 */ - 0x0000, /* R6614 */ - 0x0000, /* R6615 */ - 0x0000, /* R6616 */ - 0x0000, /* R6617 */ - 0x0000, /* R6618 */ - 0x0000, /* R6619 */ - 0x0000, /* R6620 */ - 0x0000, /* R6621 */ - 0x0000, /* R6622 */ - 0x0000, /* R6623 */ - 0x0000, /* R6624 */ - 0x0000, /* R6625 */ - 0x0000, /* R6626 */ - 0x0000, /* R6627 */ - 0x0000, /* R6628 */ - 0x0000, /* R6629 */ - 0x0000, /* R6630 */ - 0x0000, /* R6631 */ - 0x0000, /* R6632 */ - 0x0000, /* R6633 */ - 0x0000, /* R6634 */ - 0x0000, /* R6635 */ - 0x0000, /* R6636 */ - 0x0000, /* R6637 */ - 0x0000, /* R6638 */ - 0x0000, /* R6639 */ - 0x0000, /* R6640 */ - 0x0000, /* R6641 */ - 0x0000, /* R6642 */ - 0x0000, /* R6643 */ - 0x0000, /* R6644 */ - 0x0000, /* R6645 */ - 0x0000, /* R6646 */ - 0x0000, /* R6647 */ - 0x0000, /* R6648 */ - 0x0000, /* R6649 */ - 0x0000, /* R6650 */ - 0x0000, /* R6651 */ - 0x0000, /* R6652 */ - 0x0000, /* R6653 */ - 0x0000, /* R6654 */ - 0x0000, /* R6655 */ - 0x0000, /* R6656 */ - 0x0000, /* R6657 */ - 0x0000, /* R6658 */ - 0x0000, /* R6659 */ - 0x0000, /* R6660 */ - 0x0000, /* R6661 */ - 0x0000, /* R6662 */ - 0x0000, /* R6663 */ - 0x0000, /* R6664 */ - 0x0000, /* R6665 */ - 0x0000, /* R6666 */ - 0x0000, /* R6667 */ - 0x0000, /* R6668 */ - 0x0000, /* R6669 */ - 0x0000, /* R6670 */ - 0x0000, /* R6671 */ - 0x0000, /* R6672 */ - 0x0000, /* R6673 */ - 0x0000, /* R6674 */ - 0x0000, /* R6675 */ - 0x0000, /* R6676 */ - 0x0000, /* R6677 */ - 0x0000, /* R6678 */ - 0x0000, /* R6679 */ - 0x0000, /* R6680 */ - 0x0000, /* R6681 */ - 0x0000, /* R6682 */ - 0x0000, /* R6683 */ - 0x0000, /* R6684 */ - 0x0000, /* R6685 */ - 0x0000, /* R6686 */ - 0x0000, /* R6687 */ - 0x0000, /* R6688 */ - 0x0000, /* R6689 */ - 0x0000, /* R6690 */ - 0x0000, /* R6691 */ - 0x0000, /* R6692 */ - 0x0000, /* R6693 */ - 0x0000, /* R6694 */ - 0x0000, /* R6695 */ - 0x0000, /* R6696 */ - 0x0000, /* R6697 */ - 0x0000, /* R6698 */ - 0x0000, /* R6699 */ - 0x0000, /* R6700 */ - 0x0000, /* R6701 */ - 0x0000, /* R6702 */ - 0x0000, /* R6703 */ - 0x0000, /* R6704 */ - 0x0000, /* R6705 */ - 0x0000, /* R6706 */ - 0x0000, /* R6707 */ - 0x0000, /* R6708 */ - 0x0000, /* R6709 */ - 0x0000, /* R6710 */ - 0x0000, /* R6711 */ - 0x0000, /* R6712 */ - 0x0000, /* R6713 */ - 0x0000, /* R6714 */ - 0x0000, /* R6715 */ - 0x0000, /* R6716 */ - 0x0000, /* R6717 */ - 0x0000, /* R6718 */ - 0x0000, /* R6719 */ - 0x0000, /* R6720 */ - 0x0000, /* R6721 */ - 0x0000, /* R6722 */ - 0x0000, /* R6723 */ - 0x0000, /* R6724 */ - 0x0000, /* R6725 */ - 0x0000, /* R6726 */ - 0x0000, /* R6727 */ - 0x0000, /* R6728 */ - 0x0000, /* R6729 */ - 0x0000, /* R6730 */ - 0x0000, /* R6731 */ - 0x0000, /* R6732 */ - 0x0000, /* R6733 */ - 0x0000, /* R6734 */ - 0x0000, /* R6735 */ - 0x0000, /* R6736 */ - 0x0000, /* R6737 */ - 0x0000, /* R6738 */ - 0x0000, /* R6739 */ - 0x0000, /* R6740 */ - 0x0000, /* R6741 */ - 0x0000, /* R6742 */ - 0x0000, /* R6743 */ - 0x0000, /* R6744 */ - 0x0000, /* R6745 */ - 0x0000, /* R6746 */ - 0x0000, /* R6747 */ - 0x0000, /* R6748 */ - 0x0000, /* R6749 */ - 0x0000, /* R6750 */ - 0x0000, /* R6751 */ - 0x0000, /* R6752 */ - 0x0000, /* R6753 */ - 0x0000, /* R6754 */ - 0x0000, /* R6755 */ - 0x0000, /* R6756 */ - 0x0000, /* R6757 */ - 0x0000, /* R6758 */ - 0x0000, /* R6759 */ - 0x0000, /* R6760 */ - 0x0000, /* R6761 */ - 0x0000, /* R6762 */ - 0x0000, /* R6763 */ - 0x0000, /* R6764 */ - 0x0000, /* R6765 */ - 0x0000, /* R6766 */ - 0x0000, /* R6767 */ - 0x0000, /* R6768 */ - 0x0000, /* R6769 */ - 0x0000, /* R6770 */ - 0x0000, /* R6771 */ - 0x0000, /* R6772 */ - 0x0000, /* R6773 */ - 0x0000, /* R6774 */ - 0x0000, /* R6775 */ - 0x0000, /* R6776 */ - 0x0000, /* R6777 */ - 0x0000, /* R6778 */ - 0x0000, /* R6779 */ - 0x0000, /* R6780 */ - 0x0000, /* R6781 */ - 0x0000, /* R6782 */ - 0x0000, /* R6783 */ - 0x0000, /* R6784 */ - 0x0000, /* R6785 */ - 0x0000, /* R6786 */ - 0x0000, /* R6787 */ - 0x0000, /* R6788 */ - 0x0000, /* R6789 */ - 0x0000, /* R6790 */ - 0x0000, /* R6791 */ - 0x0000, /* R6792 */ - 0x0000, /* R6793 */ - 0x0000, /* R6794 */ - 0x0000, /* R6795 */ - 0x0000, /* R6796 */ - 0x0000, /* R6797 */ - 0x0000, /* R6798 */ - 0x0000, /* R6799 */ - 0x0000, /* R6800 */ - 0x0000, /* R6801 */ - 0x0000, /* R6802 */ - 0x0000, /* R6803 */ - 0x0000, /* R6804 */ - 0x0000, /* R6805 */ - 0x0000, /* R6806 */ - 0x0000, /* R6807 */ - 0x0000, /* R6808 */ - 0x0000, /* R6809 */ - 0x0000, /* R6810 */ - 0x0000, /* R6811 */ - 0x0000, /* R6812 */ - 0x0000, /* R6813 */ - 0x0000, /* R6814 */ - 0x0000, /* R6815 */ - 0x0000, /* R6816 */ - 0x0000, /* R6817 */ - 0x0000, /* R6818 */ - 0x0000, /* R6819 */ - 0x0000, /* R6820 */ - 0x0000, /* R6821 */ - 0x0000, /* R6822 */ - 0x0000, /* R6823 */ - 0x0000, /* R6824 */ - 0x0000, /* R6825 */ - 0x0000, /* R6826 */ - 0x0000, /* R6827 */ - 0x0000, /* R6828 */ - 0x0000, /* R6829 */ - 0x0000, /* R6830 */ - 0x0000, /* R6831 */ - 0x0000, /* R6832 */ - 0x0000, /* R6833 */ - 0x0000, /* R6834 */ - 0x0000, /* R6835 */ - 0x0000, /* R6836 */ - 0x0000, /* R6837 */ - 0x0000, /* R6838 */ - 0x0000, /* R6839 */ - 0x0000, /* R6840 */ - 0x0000, /* R6841 */ - 0x0000, /* R6842 */ - 0x0000, /* R6843 */ - 0x0000, /* R6844 */ - 0x0000, /* R6845 */ - 0x0000, /* R6846 */ - 0x0000, /* R6847 */ - 0x0000, /* R6848 */ - 0x0000, /* R6849 */ - 0x0000, /* R6850 */ - 0x0000, /* R6851 */ - 0x0000, /* R6852 */ - 0x0000, /* R6853 */ - 0x0000, /* R6854 */ - 0x0000, /* R6855 */ - 0x0000, /* R6856 */ - 0x0000, /* R6857 */ - 0x0000, /* R6858 */ - 0x0000, /* R6859 */ - 0x0000, /* R6860 */ - 0x0000, /* R6861 */ - 0x0000, /* R6862 */ - 0x0000, /* R6863 */ - 0x0000, /* R6864 */ - 0x0000, /* R6865 */ - 0x0000, /* R6866 */ - 0x0000, /* R6867 */ - 0x0000, /* R6868 */ - 0x0000, /* R6869 */ - 0x0000, /* R6870 */ - 0x0000, /* R6871 */ - 0x0000, /* R6872 */ - 0x0000, /* R6873 */ - 0x0000, /* R6874 */ - 0x0000, /* R6875 */ - 0x0000, /* R6876 */ - 0x0000, /* R6877 */ - 0x0000, /* R6878 */ - 0x0000, /* R6879 */ - 0x0000, /* R6880 */ - 0x0000, /* R6881 */ - 0x0000, /* R6882 */ - 0x0000, /* R6883 */ - 0x0000, /* R6884 */ - 0x0000, /* R6885 */ - 0x0000, /* R6886 */ - 0x0000, /* R6887 */ - 0x0000, /* R6888 */ - 0x0000, /* R6889 */ - 0x0000, /* R6890 */ - 0x0000, /* R6891 */ - 0x0000, /* R6892 */ - 0x0000, /* R6893 */ - 0x0000, /* R6894 */ - 0x0000, /* R6895 */ - 0x0000, /* R6896 */ - 0x0000, /* R6897 */ - 0x0000, /* R6898 */ - 0x0000, /* R6899 */ - 0x0000, /* R6900 */ - 0x0000, /* R6901 */ - 0x0000, /* R6902 */ - 0x0000, /* R6903 */ - 0x0000, /* R6904 */ - 0x0000, /* R6905 */ - 0x0000, /* R6906 */ - 0x0000, /* R6907 */ - 0x0000, /* R6908 */ - 0x0000, /* R6909 */ - 0x0000, /* R6910 */ - 0x0000, /* R6911 */ - 0x0000, /* R6912 */ - 0x0000, /* R6913 */ - 0x0000, /* R6914 */ - 0x0000, /* R6915 */ - 0x0000, /* R6916 */ - 0x0000, /* R6917 */ - 0x0000, /* R6918 */ - 0x0000, /* R6919 */ - 0x0000, /* R6920 */ - 0x0000, /* R6921 */ - 0x0000, /* R6922 */ - 0x0000, /* R6923 */ - 0x0000, /* R6924 */ - 0x0000, /* R6925 */ - 0x0000, /* R6926 */ - 0x0000, /* R6927 */ - 0x0000, /* R6928 */ - 0x0000, /* R6929 */ - 0x0000, /* R6930 */ - 0x0000, /* R6931 */ - 0x0000, /* R6932 */ - 0x0000, /* R6933 */ - 0x0000, /* R6934 */ - 0x0000, /* R6935 */ - 0x0000, /* R6936 */ - 0x0000, /* R6937 */ - 0x0000, /* R6938 */ - 0x0000, /* R6939 */ - 0x0000, /* R6940 */ - 0x0000, /* R6941 */ - 0x0000, /* R6942 */ - 0x0000, /* R6943 */ - 0x0000, /* R6944 */ - 0x0000, /* R6945 */ - 0x0000, /* R6946 */ - 0x0000, /* R6947 */ - 0x0000, /* R6948 */ - 0x0000, /* R6949 */ - 0x0000, /* R6950 */ - 0x0000, /* R6951 */ - 0x0000, /* R6952 */ - 0x0000, /* R6953 */ - 0x0000, /* R6954 */ - 0x0000, /* R6955 */ - 0x0000, /* R6956 */ - 0x0000, /* R6957 */ - 0x0000, /* R6958 */ - 0x0000, /* R6959 */ - 0x0000, /* R6960 */ - 0x0000, /* R6961 */ - 0x0000, /* R6962 */ - 0x0000, /* R6963 */ - 0x0000, /* R6964 */ - 0x0000, /* R6965 */ - 0x0000, /* R6966 */ - 0x0000, /* R6967 */ - 0x0000, /* R6968 */ - 0x0000, /* R6969 */ - 0x0000, /* R6970 */ - 0x0000, /* R6971 */ - 0x0000, /* R6972 */ - 0x0000, /* R6973 */ - 0x0000, /* R6974 */ - 0x0000, /* R6975 */ - 0x0000, /* R6976 */ - 0x0000, /* R6977 */ - 0x0000, /* R6978 */ - 0x0000, /* R6979 */ - 0x0000, /* R6980 */ - 0x0000, /* R6981 */ - 0x0000, /* R6982 */ - 0x0000, /* R6983 */ - 0x0000, /* R6984 */ - 0x0000, /* R6985 */ - 0x0000, /* R6986 */ - 0x0000, /* R6987 */ - 0x0000, /* R6988 */ - 0x0000, /* R6989 */ - 0x0000, /* R6990 */ - 0x0000, /* R6991 */ - 0x0000, /* R6992 */ - 0x0000, /* R6993 */ - 0x0000, /* R6994 */ - 0x0000, /* R6995 */ - 0x0000, /* R6996 */ - 0x0000, /* R6997 */ - 0x0000, /* R6998 */ - 0x0000, /* R6999 */ - 0x0000, /* R7000 */ - 0x0000, /* R7001 */ - 0x0000, /* R7002 */ - 0x0000, /* R7003 */ - 0x0000, /* R7004 */ - 0x0000, /* R7005 */ - 0x0000, /* R7006 */ - 0x0000, /* R7007 */ - 0x0000, /* R7008 */ - 0x0000, /* R7009 */ - 0x0000, /* R7010 */ - 0x0000, /* R7011 */ - 0x0000, /* R7012 */ - 0x0000, /* R7013 */ - 0x0000, /* R7014 */ - 0x0000, /* R7015 */ - 0x0000, /* R7016 */ - 0x0000, /* R7017 */ - 0x0000, /* R7018 */ - 0x0000, /* R7019 */ - 0x0000, /* R7020 */ - 0x0000, /* R7021 */ - 0x0000, /* R7022 */ - 0x0000, /* R7023 */ - 0x0000, /* R7024 */ - 0x0000, /* R7025 */ - 0x0000, /* R7026 */ - 0x0000, /* R7027 */ - 0x0000, /* R7028 */ - 0x0000, /* R7029 */ - 0x0000, /* R7030 */ - 0x0000, /* R7031 */ - 0x0000, /* R7032 */ - 0x0000, /* R7033 */ - 0x0000, /* R7034 */ - 0x0000, /* R7035 */ - 0x0000, /* R7036 */ - 0x0000, /* R7037 */ - 0x0000, /* R7038 */ - 0x0000, /* R7039 */ - 0x0000, /* R7040 */ - 0x0000, /* R7041 */ - 0x0000, /* R7042 */ - 0x0000, /* R7043 */ - 0x0000, /* R7044 */ - 0x0000, /* R7045 */ - 0x0000, /* R7046 */ - 0x0000, /* R7047 */ - 0x0000, /* R7048 */ - 0x0000, /* R7049 */ - 0x0000, /* R7050 */ - 0x0000, /* R7051 */ - 0x0000, /* R7052 */ - 0x0000, /* R7053 */ - 0x0000, /* R7054 */ - 0x0000, /* R7055 */ - 0x0000, /* R7056 */ - 0x0000, /* R7057 */ - 0x0000, /* R7058 */ - 0x0000, /* R7059 */ - 0x0000, /* R7060 */ - 0x0000, /* R7061 */ - 0x0000, /* R7062 */ - 0x0000, /* R7063 */ - 0x0000, /* R7064 */ - 0x0000, /* R7065 */ - 0x0000, /* R7066 */ - 0x0000, /* R7067 */ - 0x0000, /* R7068 */ - 0x0000, /* R7069 */ - 0x0000, /* R7070 */ - 0x0000, /* R7071 */ - 0x0000, /* R7072 */ - 0x0000, /* R7073 */ - 0x0000, /* R7074 */ - 0x0000, /* R7075 */ - 0x0000, /* R7076 */ - 0x0000, /* R7077 */ - 0x0000, /* R7078 */ - 0x0000, /* R7079 */ - 0x0000, /* R7080 */ - 0x0000, /* R7081 */ - 0x0000, /* R7082 */ - 0x0000, /* R7083 */ - 0x0000, /* R7084 */ - 0x0000, /* R7085 */ - 0x0000, /* R7086 */ - 0x0000, /* R7087 */ - 0x0000, /* R7088 */ - 0x0000, /* R7089 */ - 0x0000, /* R7090 */ - 0x0000, /* R7091 */ - 0x0000, /* R7092 */ - 0x0000, /* R7093 */ - 0x0000, /* R7094 */ - 0x0000, /* R7095 */ - 0x0000, /* R7096 */ - 0x0000, /* R7097 */ - 0x0000, /* R7098 */ - 0x0000, /* R7099 */ - 0x0000, /* R7100 */ - 0x0000, /* R7101 */ - 0x0000, /* R7102 */ - 0x0000, /* R7103 */ - 0x0000, /* R7104 */ - 0x0000, /* R7105 */ - 0x0000, /* R7106 */ - 0x0000, /* R7107 */ - 0x0000, /* R7108 */ - 0x0000, /* R7109 */ - 0x0000, /* R7110 */ - 0x0000, /* R7111 */ - 0x0000, /* R7112 */ - 0x0000, /* R7113 */ - 0x0000, /* R7114 */ - 0x0000, /* R7115 */ - 0x0000, /* R7116 */ - 0x0000, /* R7117 */ - 0x0000, /* R7118 */ - 0x0000, /* R7119 */ - 0x0000, /* R7120 */ - 0x0000, /* R7121 */ - 0x0000, /* R7122 */ - 0x0000, /* R7123 */ - 0x0000, /* R7124 */ - 0x0000, /* R7125 */ - 0x0000, /* R7126 */ - 0x0000, /* R7127 */ - 0x0000, /* R7128 */ - 0x0000, /* R7129 */ - 0x0000, /* R7130 */ - 0x0000, /* R7131 */ - 0x0000, /* R7132 */ - 0x0000, /* R7133 */ - 0x0000, /* R7134 */ - 0x0000, /* R7135 */ - 0x0000, /* R7136 */ - 0x0000, /* R7137 */ - 0x0000, /* R7138 */ - 0x0000, /* R7139 */ - 0x0000, /* R7140 */ - 0x0000, /* R7141 */ - 0x0000, /* R7142 */ - 0x0000, /* R7143 */ - 0x0000, /* R7144 */ - 0x0000, /* R7145 */ - 0x0000, /* R7146 */ - 0x0000, /* R7147 */ - 0x0000, /* R7148 */ - 0x0000, /* R7149 */ - 0x0000, /* R7150 */ - 0x0000, /* R7151 */ - 0x0000, /* R7152 */ - 0x0000, /* R7153 */ - 0x0000, /* R7154 */ - 0x0000, /* R7155 */ - 0x0000, /* R7156 */ - 0x0000, /* R7157 */ - 0x0000, /* R7158 */ - 0x0000, /* R7159 */ - 0x0000, /* R7160 */ - 0x0000, /* R7161 */ - 0x0000, /* R7162 */ - 0x0000, /* R7163 */ - 0x0000, /* R7164 */ - 0x0000, /* R7165 */ - 0x0000, /* R7166 */ - 0x0000, /* R7167 */ - 0x0000, /* R7168 */ - 0x0000, /* R7169 */ - 0x0000, /* R7170 */ - 0x0000, /* R7171 */ - 0x0000, /* R7172 */ - 0x0000, /* R7173 */ - 0x0000, /* R7174 */ - 0x0000, /* R7175 */ - 0x0000, /* R7176 */ - 0x0000, /* R7177 */ - 0x0000, /* R7178 */ - 0x0000, /* R7179 */ - 0x0000, /* R7180 */ - 0x0000, /* R7181 */ - 0x0000, /* R7182 */ - 0x0000, /* R7183 */ - 0x0000, /* R7184 */ - 0x0000, /* R7185 */ - 0x0000, /* R7186 */ - 0x0000, /* R7187 */ - 0x0000, /* R7188 */ - 0x0000, /* R7189 */ - 0x0000, /* R7190 */ - 0x0000, /* R7191 */ - 0x0000, /* R7192 */ - 0x0000, /* R7193 */ - 0x0000, /* R7194 */ - 0x0000, /* R7195 */ - 0x0000, /* R7196 */ - 0x0000, /* R7197 */ - 0x0000, /* R7198 */ - 0x0000, /* R7199 */ - 0x0000, /* R7200 */ - 0x0000, /* R7201 */ - 0x0000, /* R7202 */ - 0x0000, /* R7203 */ - 0x0000, /* R7204 */ - 0x0000, /* R7205 */ - 0x0000, /* R7206 */ - 0x0000, /* R7207 */ - 0x0000, /* R7208 */ - 0x0000, /* R7209 */ - 0x0000, /* R7210 */ - 0x0000, /* R7211 */ - 0x0000, /* R7212 */ - 0x0000, /* R7213 */ - 0x0000, /* R7214 */ - 0x0000, /* R7215 */ - 0x0000, /* R7216 */ - 0x0000, /* R7217 */ - 0x0000, /* R7218 */ - 0x0000, /* R7219 */ - 0x0000, /* R7220 */ - 0x0000, /* R7221 */ - 0x0000, /* R7222 */ - 0x0000, /* R7223 */ - 0x0000, /* R7224 */ - 0x0000, /* R7225 */ - 0x0000, /* R7226 */ - 0x0000, /* R7227 */ - 0x0000, /* R7228 */ - 0x0000, /* R7229 */ - 0x0000, /* R7230 */ - 0x0000, /* R7231 */ - 0x0000, /* R7232 */ - 0x0000, /* R7233 */ - 0x0000, /* R7234 */ - 0x0000, /* R7235 */ - 0x0000, /* R7236 */ - 0x0000, /* R7237 */ - 0x0000, /* R7238 */ - 0x0000, /* R7239 */ - 0x0000, /* R7240 */ - 0x0000, /* R7241 */ - 0x0000, /* R7242 */ - 0x0000, /* R7243 */ - 0x0000, /* R7244 */ - 0x0000, /* R7245 */ - 0x0000, /* R7246 */ - 0x0000, /* R7247 */ - 0x0000, /* R7248 */ - 0x0000, /* R7249 */ - 0x0000, /* R7250 */ - 0x0000, /* R7251 */ - 0x0000, /* R7252 */ - 0x0000, /* R7253 */ - 0x0000, /* R7254 */ - 0x0000, /* R7255 */ - 0x0000, /* R7256 */ - 0x0000, /* R7257 */ - 0x0000, /* R7258 */ - 0x0000, /* R7259 */ - 0x0000, /* R7260 */ - 0x0000, /* R7261 */ - 0x0000, /* R7262 */ - 0x0000, /* R7263 */ - 0x0000, /* R7264 */ - 0x0000, /* R7265 */ - 0x0000, /* R7266 */ - 0x0000, /* R7267 */ - 0x0000, /* R7268 */ - 0x0000, /* R7269 */ - 0x0000, /* R7270 */ - 0x0000, /* R7271 */ - 0x0000, /* R7272 */ - 0x0000, /* R7273 */ - 0x0000, /* R7274 */ - 0x0000, /* R7275 */ - 0x0000, /* R7276 */ - 0x0000, /* R7277 */ - 0x0000, /* R7278 */ - 0x0000, /* R7279 */ - 0x0000, /* R7280 */ - 0x0000, /* R7281 */ - 0x0000, /* R7282 */ - 0x0000, /* R7283 */ - 0x0000, /* R7284 */ - 0x0000, /* R7285 */ - 0x0000, /* R7286 */ - 0x0000, /* R7287 */ - 0x0000, /* R7288 */ - 0x0000, /* R7289 */ - 0x0000, /* R7290 */ - 0x0000, /* R7291 */ - 0x0000, /* R7292 */ - 0x0000, /* R7293 */ - 0x0000, /* R7294 */ - 0x0000, /* R7295 */ - 0x0000, /* R7296 */ - 0x0000, /* R7297 */ - 0x0000, /* R7298 */ - 0x0000, /* R7299 */ - 0x0000, /* R7300 */ - 0x0000, /* R7301 */ - 0x0000, /* R7302 */ - 0x0000, /* R7303 */ - 0x0000, /* R7304 */ - 0x0000, /* R7305 */ - 0x0000, /* R7306 */ - 0x0000, /* R7307 */ - 0x0000, /* R7308 */ - 0x0000, /* R7309 */ - 0x0000, /* R7310 */ - 0x0000, /* R7311 */ - 0x0000, /* R7312 */ - 0x0000, /* R7313 */ - 0x0000, /* R7314 */ - 0x0000, /* R7315 */ - 0x0000, /* R7316 */ - 0x0000, /* R7317 */ - 0x0000, /* R7318 */ - 0x0000, /* R7319 */ - 0x0000, /* R7320 */ - 0x0000, /* R7321 */ - 0x0000, /* R7322 */ - 0x0000, /* R7323 */ - 0x0000, /* R7324 */ - 0x0000, /* R7325 */ - 0x0000, /* R7326 */ - 0x0000, /* R7327 */ - 0x0000, /* R7328 */ - 0x0000, /* R7329 */ - 0x0000, /* R7330 */ - 0x0000, /* R7331 */ - 0x0000, /* R7332 */ - 0x0000, /* R7333 */ - 0x0000, /* R7334 */ - 0x0000, /* R7335 */ - 0x0000, /* R7336 */ - 0x0000, /* R7337 */ - 0x0000, /* R7338 */ - 0x0000, /* R7339 */ - 0x0000, /* R7340 */ - 0x0000, /* R7341 */ - 0x0000, /* R7342 */ - 0x0000, /* R7343 */ - 0x0000, /* R7344 */ - 0x0000, /* R7345 */ - 0x0000, /* R7346 */ - 0x0000, /* R7347 */ - 0x0000, /* R7348 */ - 0x0000, /* R7349 */ - 0x0000, /* R7350 */ - 0x0000, /* R7351 */ - 0x0000, /* R7352 */ - 0x0000, /* R7353 */ - 0x0000, /* R7354 */ - 0x0000, /* R7355 */ - 0x0000, /* R7356 */ - 0x0000, /* R7357 */ - 0x0000, /* R7358 */ - 0x0000, /* R7359 */ - 0x0000, /* R7360 */ - 0x0000, /* R7361 */ - 0x0000, /* R7362 */ - 0x0000, /* R7363 */ - 0x0000, /* R7364 */ - 0x0000, /* R7365 */ - 0x0000, /* R7366 */ - 0x0000, /* R7367 */ - 0x0000, /* R7368 */ - 0x0000, /* R7369 */ - 0x0000, /* R7370 */ - 0x0000, /* R7371 */ - 0x0000, /* R7372 */ - 0x0000, /* R7373 */ - 0x0000, /* R7374 */ - 0x0000, /* R7375 */ - 0x0000, /* R7376 */ - 0x0000, /* R7377 */ - 0x0000, /* R7378 */ - 0x0000, /* R7379 */ - 0x0000, /* R7380 */ - 0x0000, /* R7381 */ - 0x0000, /* R7382 */ - 0x0000, /* R7383 */ - 0x0000, /* R7384 */ - 0x0000, /* R7385 */ - 0x0000, /* R7386 */ - 0x0000, /* R7387 */ - 0x0000, /* R7388 */ - 0x0000, /* R7389 */ - 0x0000, /* R7390 */ - 0x0000, /* R7391 */ - 0x0000, /* R7392 */ - 0x0000, /* R7393 */ - 0x0000, /* R7394 */ - 0x0000, /* R7395 */ - 0x0000, /* R7396 */ - 0x0000, /* R7397 */ - 0x0000, /* R7398 */ - 0x0000, /* R7399 */ - 0x0000, /* R7400 */ - 0x0000, /* R7401 */ - 0x0000, /* R7402 */ - 0x0000, /* R7403 */ - 0x0000, /* R7404 */ - 0x0000, /* R7405 */ - 0x0000, /* R7406 */ - 0x0000, /* R7407 */ - 0x0000, /* R7408 */ - 0x0000, /* R7409 */ - 0x0000, /* R7410 */ - 0x0000, /* R7411 */ - 0x0000, /* R7412 */ - 0x0000, /* R7413 */ - 0x0000, /* R7414 */ - 0x0000, /* R7415 */ - 0x0000, /* R7416 */ - 0x0000, /* R7417 */ - 0x0000, /* R7418 */ - 0x0000, /* R7419 */ - 0x0000, /* R7420 */ - 0x0000, /* R7421 */ - 0x0000, /* R7422 */ - 0x0000, /* R7423 */ - 0x0000, /* R7424 */ - 0x0000, /* R7425 */ - 0x0000, /* R7426 */ - 0x0000, /* R7427 */ - 0x0000, /* R7428 */ - 0x0000, /* R7429 */ - 0x0000, /* R7430 */ - 0x0000, /* R7431 */ - 0x0000, /* R7432 */ - 0x0000, /* R7433 */ - 0x0000, /* R7434 */ - 0x0000, /* R7435 */ - 0x0000, /* R7436 */ - 0x0000, /* R7437 */ - 0x0000, /* R7438 */ - 0x0000, /* R7439 */ - 0x0000, /* R7440 */ - 0x0000, /* R7441 */ - 0x0000, /* R7442 */ - 0x0000, /* R7443 */ - 0x0000, /* R7444 */ - 0x0000, /* R7445 */ - 0x0000, /* R7446 */ - 0x0000, /* R7447 */ - 0x0000, /* R7448 */ - 0x0000, /* R7449 */ - 0x0000, /* R7450 */ - 0x0000, /* R7451 */ - 0x0000, /* R7452 */ - 0x0000, /* R7453 */ - 0x0000, /* R7454 */ - 0x0000, /* R7455 */ - 0x0000, /* R7456 */ - 0x0000, /* R7457 */ - 0x0000, /* R7458 */ - 0x0000, /* R7459 */ - 0x0000, /* R7460 */ - 0x0000, /* R7461 */ - 0x0000, /* R7462 */ - 0x0000, /* R7463 */ - 0x0000, /* R7464 */ - 0x0000, /* R7465 */ - 0x0000, /* R7466 */ - 0x0000, /* R7467 */ - 0x0000, /* R7468 */ - 0x0000, /* R7469 */ - 0x0000, /* R7470 */ - 0x0000, /* R7471 */ - 0x0000, /* R7472 */ - 0x0000, /* R7473 */ - 0x0000, /* R7474 */ - 0x0000, /* R7475 */ - 0x0000, /* R7476 */ - 0x0000, /* R7477 */ - 0x0000, /* R7478 */ - 0x0000, /* R7479 */ - 0x0000, /* R7480 */ - 0x0000, /* R7481 */ - 0x0000, /* R7482 */ - 0x0000, /* R7483 */ - 0x0000, /* R7484 */ - 0x0000, /* R7485 */ - 0x0000, /* R7486 */ - 0x0000, /* R7487 */ - 0x0000, /* R7488 */ - 0x0000, /* R7489 */ - 0x0000, /* R7490 */ - 0x0000, /* R7491 */ - 0x0000, /* R7492 */ - 0x0000, /* R7493 */ - 0x0000, /* R7494 */ - 0x0000, /* R7495 */ - 0x0000, /* R7496 */ - 0x0000, /* R7497 */ - 0x0000, /* R7498 */ - 0x0000, /* R7499 */ - 0x0000, /* R7500 */ - 0x0000, /* R7501 */ - 0x0000, /* R7502 */ - 0x0000, /* R7503 */ - 0x0000, /* R7504 */ - 0x0000, /* R7505 */ - 0x0000, /* R7506 */ - 0x0000, /* R7507 */ - 0x0000, /* R7508 */ - 0x0000, /* R7509 */ - 0x0000, /* R7510 */ - 0x0000, /* R7511 */ - 0x0000, /* R7512 */ - 0x0000, /* R7513 */ - 0x0000, /* R7514 */ - 0x0000, /* R7515 */ - 0x0000, /* R7516 */ - 0x0000, /* R7517 */ - 0x0000, /* R7518 */ - 0x0000, /* R7519 */ - 0x0000, /* R7520 */ - 0x0000, /* R7521 */ - 0x0000, /* R7522 */ - 0x0000, /* R7523 */ - 0x0000, /* R7524 */ - 0x0000, /* R7525 */ - 0x0000, /* R7526 */ - 0x0000, /* R7527 */ - 0x0000, /* R7528 */ - 0x0000, /* R7529 */ - 0x0000, /* R7530 */ - 0x0000, /* R7531 */ - 0x0000, /* R7532 */ - 0x0000, /* R7533 */ - 0x0000, /* R7534 */ - 0x0000, /* R7535 */ - 0x0000, /* R7536 */ - 0x0000, /* R7537 */ - 0x0000, /* R7538 */ - 0x0000, /* R7539 */ - 0x0000, /* R7540 */ - 0x0000, /* R7541 */ - 0x0000, /* R7542 */ - 0x0000, /* R7543 */ - 0x0000, /* R7544 */ - 0x0000, /* R7545 */ - 0x0000, /* R7546 */ - 0x0000, /* R7547 */ - 0x0000, /* R7548 */ - 0x0000, /* R7549 */ - 0x0000, /* R7550 */ - 0x0000, /* R7551 */ - 0x0000, /* R7552 */ - 0x0000, /* R7553 */ - 0x0000, /* R7554 */ - 0x0000, /* R7555 */ - 0x0000, /* R7556 */ - 0x0000, /* R7557 */ - 0x0000, /* R7558 */ - 0x0000, /* R7559 */ - 0x0000, /* R7560 */ - 0x0000, /* R7561 */ - 0x0000, /* R7562 */ - 0x0000, /* R7563 */ - 0x0000, /* R7564 */ - 0x0000, /* R7565 */ - 0x0000, /* R7566 */ - 0x0000, /* R7567 */ - 0x0000, /* R7568 */ - 0x0000, /* R7569 */ - 0x0000, /* R7570 */ - 0x0000, /* R7571 */ - 0x0000, /* R7572 */ - 0x0000, /* R7573 */ - 0x0000, /* R7574 */ - 0x0000, /* R7575 */ - 0x0000, /* R7576 */ - 0x0000, /* R7577 */ - 0x0000, /* R7578 */ - 0x0000, /* R7579 */ - 0x0000, /* R7580 */ - 0x0000, /* R7581 */ - 0x0000, /* R7582 */ - 0x0000, /* R7583 */ - 0x0000, /* R7584 */ - 0x0000, /* R7585 */ - 0x0000, /* R7586 */ - 0x0000, /* R7587 */ - 0x0000, /* R7588 */ - 0x0000, /* R7589 */ - 0x0000, /* R7590 */ - 0x0000, /* R7591 */ - 0x0000, /* R7592 */ - 0x0000, /* R7593 */ - 0x0000, /* R7594 */ - 0x0000, /* R7595 */ - 0x0000, /* R7596 */ - 0x0000, /* R7597 */ - 0x0000, /* R7598 */ - 0x0000, /* R7599 */ - 0x0000, /* R7600 */ - 0x0000, /* R7601 */ - 0x0000, /* R7602 */ - 0x0000, /* R7603 */ - 0x0000, /* R7604 */ - 0x0000, /* R7605 */ - 0x0000, /* R7606 */ - 0x0000, /* R7607 */ - 0x0000, /* R7608 */ - 0x0000, /* R7609 */ - 0x0000, /* R7610 */ - 0x0000, /* R7611 */ - 0x0000, /* R7612 */ - 0x0000, /* R7613 */ - 0x0000, /* R7614 */ - 0x0000, /* R7615 */ - 0x0000, /* R7616 */ - 0x0000, /* R7617 */ - 0x0000, /* R7618 */ - 0x0000, /* R7619 */ - 0x0000, /* R7620 */ - 0x0000, /* R7621 */ - 0x0000, /* R7622 */ - 0x0000, /* R7623 */ - 0x0000, /* R7624 */ - 0x0000, /* R7625 */ - 0x0000, /* R7626 */ - 0x0000, /* R7627 */ - 0x0000, /* R7628 */ - 0x0000, /* R7629 */ - 0x0000, /* R7630 */ - 0x0000, /* R7631 */ - 0x0000, /* R7632 */ - 0x0000, /* R7633 */ - 0x0000, /* R7634 */ - 0x0000, /* R7635 */ - 0x0000, /* R7636 */ - 0x0000, /* R7637 */ - 0x0000, /* R7638 */ - 0x0000, /* R7639 */ - 0x0000, /* R7640 */ - 0x0000, /* R7641 */ - 0x0000, /* R7642 */ - 0x0000, /* R7643 */ - 0x0000, /* R7644 */ - 0x0000, /* R7645 */ - 0x0000, /* R7646 */ - 0x0000, /* R7647 */ - 0x0000, /* R7648 */ - 0x0000, /* R7649 */ - 0x0000, /* R7650 */ - 0x0000, /* R7651 */ - 0x0000, /* R7652 */ - 0x0000, /* R7653 */ - 0x0000, /* R7654 */ - 0x0000, /* R7655 */ - 0x0000, /* R7656 */ - 0x0000, /* R7657 */ - 0x0000, /* R7658 */ - 0x0000, /* R7659 */ - 0x0000, /* R7660 */ - 0x0000, /* R7661 */ - 0x0000, /* R7662 */ - 0x0000, /* R7663 */ - 0x0000, /* R7664 */ - 0x0000, /* R7665 */ - 0x0000, /* R7666 */ - 0x0000, /* R7667 */ - 0x0000, /* R7668 */ - 0x0000, /* R7669 */ - 0x0000, /* R7670 */ - 0x0000, /* R7671 */ - 0x0000, /* R7672 */ - 0x0000, /* R7673 */ - 0x0000, /* R7674 */ - 0x0000, /* R7675 */ - 0x0000, /* R7676 */ - 0x0000, /* R7677 */ - 0x0000, /* R7678 */ - 0x0000, /* R7679 */ - 0x0000, /* R7680 */ - 0x0000, /* R7681 */ - 0x0000, /* R7682 */ - 0x0000, /* R7683 */ - 0x0000, /* R7684 */ - 0x0000, /* R7685 */ - 0x0000, /* R7686 */ - 0x0000, /* R7687 */ - 0x0000, /* R7688 */ - 0x0000, /* R7689 */ - 0x0000, /* R7690 */ - 0x0000, /* R7691 */ - 0x0000, /* R7692 */ - 0x0000, /* R7693 */ - 0x0000, /* R7694 */ - 0x0000, /* R7695 */ - 0x0000, /* R7696 */ - 0x0000, /* R7697 */ - 0x0000, /* R7698 */ - 0x0000, /* R7699 */ - 0x0000, /* R7700 */ - 0x0000, /* R7701 */ - 0x0000, /* R7702 */ - 0x0000, /* R7703 */ - 0x0000, /* R7704 */ - 0x0000, /* R7705 */ - 0x0000, /* R7706 */ - 0x0000, /* R7707 */ - 0x0000, /* R7708 */ - 0x0000, /* R7709 */ - 0x0000, /* R7710 */ - 0x0000, /* R7711 */ - 0x0000, /* R7712 */ - 0x0000, /* R7713 */ - 0x0000, /* R7714 */ - 0x0000, /* R7715 */ - 0x0000, /* R7716 */ - 0x0000, /* R7717 */ - 0x0000, /* R7718 */ - 0x0000, /* R7719 */ - 0x0000, /* R7720 */ - 0x0000, /* R7721 */ - 0x0000, /* R7722 */ - 0x0000, /* R7723 */ - 0x0000, /* R7724 */ - 0x0000, /* R7725 */ - 0x0000, /* R7726 */ - 0x0000, /* R7727 */ - 0x0000, /* R7728 */ - 0x0000, /* R7729 */ - 0x0000, /* R7730 */ - 0x0000, /* R7731 */ - 0x0000, /* R7732 */ - 0x0000, /* R7733 */ - 0x0000, /* R7734 */ - 0x0000, /* R7735 */ - 0x0000, /* R7736 */ - 0x0000, /* R7737 */ - 0x0000, /* R7738 */ - 0x0000, /* R7739 */ - 0x0000, /* R7740 */ - 0x0000, /* R7741 */ - 0x0000, /* R7742 */ - 0x0000, /* R7743 */ - 0x0000, /* R7744 */ - 0x0000, /* R7745 */ - 0x0000, /* R7746 */ - 0x0000, /* R7747 */ - 0x0000, /* R7748 */ - 0x0000, /* R7749 */ - 0x0000, /* R7750 */ - 0x0000, /* R7751 */ - 0x0000, /* R7752 */ - 0x0000, /* R7753 */ - 0x0000, /* R7754 */ - 0x0000, /* R7755 */ - 0x0000, /* R7756 */ - 0x0000, /* R7757 */ - 0x0000, /* R7758 */ - 0x0000, /* R7759 */ - 0x0000, /* R7760 */ - 0x0000, /* R7761 */ - 0x0000, /* R7762 */ - 0x0000, /* R7763 */ - 0x0000, /* R7764 */ - 0x0000, /* R7765 */ - 0x0000, /* R7766 */ - 0x0000, /* R7767 */ - 0x0000, /* R7768 */ - 0x0000, /* R7769 */ - 0x0000, /* R7770 */ - 0x0000, /* R7771 */ - 0x0000, /* R7772 */ - 0x0000, /* R7773 */ - 0x0000, /* R7774 */ - 0x0000, /* R7775 */ - 0x0000, /* R7776 */ - 0x0000, /* R7777 */ - 0x0000, /* R7778 */ - 0x0000, /* R7779 */ - 0x0000, /* R7780 */ - 0x0000, /* R7781 */ - 0x0000, /* R7782 */ - 0x0000, /* R7783 */ - 0x0000, /* R7784 */ - 0x0000, /* R7785 */ - 0x0000, /* R7786 */ - 0x0000, /* R7787 */ - 0x0000, /* R7788 */ - 0x0000, /* R7789 */ - 0x0000, /* R7790 */ - 0x0000, /* R7791 */ - 0x0000, /* R7792 */ - 0x0000, /* R7793 */ - 0x0000, /* R7794 */ - 0x0000, /* R7795 */ - 0x0000, /* R7796 */ - 0x0000, /* R7797 */ - 0x0000, /* R7798 */ - 0x0000, /* R7799 */ - 0x0000, /* R7800 */ - 0x0000, /* R7801 */ - 0x0000, /* R7802 */ - 0x0000, /* R7803 */ - 0x0000, /* R7804 */ - 0x0000, /* R7805 */ - 0x0000, /* R7806 */ - 0x0000, /* R7807 */ - 0x0000, /* R7808 */ - 0x0000, /* R7809 */ - 0x0000, /* R7810 */ - 0x0000, /* R7811 */ - 0x0000, /* R7812 */ - 0x0000, /* R7813 */ - 0x0000, /* R7814 */ - 0x0000, /* R7815 */ - 0x0000, /* R7816 */ - 0x0000, /* R7817 */ - 0x0000, /* R7818 */ - 0x0000, /* R7819 */ - 0x0000, /* R7820 */ - 0x0000, /* R7821 */ - 0x0000, /* R7822 */ - 0x0000, /* R7823 */ - 0x0000, /* R7824 */ - 0x0000, /* R7825 */ - 0x0000, /* R7826 */ - 0x0000, /* R7827 */ - 0x0000, /* R7828 */ - 0x0000, /* R7829 */ - 0x0000, /* R7830 */ - 0x0000, /* R7831 */ - 0x0000, /* R7832 */ - 0x0000, /* R7833 */ - 0x0000, /* R7834 */ - 0x0000, /* R7835 */ - 0x0000, /* R7836 */ - 0x0000, /* R7837 */ - 0x0000, /* R7838 */ - 0x0000, /* R7839 */ - 0x0000, /* R7840 */ - 0x0000, /* R7841 */ - 0x0000, /* R7842 */ - 0x0000, /* R7843 */ - 0x0000, /* R7844 */ - 0x0000, /* R7845 */ - 0x0000, /* R7846 */ - 0x0000, /* R7847 */ - 0x0000, /* R7848 */ - 0x0000, /* R7849 */ - 0x0000, /* R7850 */ - 0x0000, /* R7851 */ - 0x0000, /* R7852 */ - 0x0000, /* R7853 */ - 0x0000, /* R7854 */ - 0x0000, /* R7855 */ - 0x0000, /* R7856 */ - 0x0000, /* R7857 */ - 0x0000, /* R7858 */ - 0x0000, /* R7859 */ - 0x0000, /* R7860 */ - 0x0000, /* R7861 */ - 0x0000, /* R7862 */ - 0x0000, /* R7863 */ - 0x0000, /* R7864 */ - 0x0000, /* R7865 */ - 0x0000, /* R7866 */ - 0x0000, /* R7867 */ - 0x0000, /* R7868 */ - 0x0000, /* R7869 */ - 0x0000, /* R7870 */ - 0x0000, /* R7871 */ - 0x0000, /* R7872 */ - 0x0000, /* R7873 */ - 0x0000, /* R7874 */ - 0x0000, /* R7875 */ - 0x0000, /* R7876 */ - 0x0000, /* R7877 */ - 0x0000, /* R7878 */ - 0x0000, /* R7879 */ - 0x0000, /* R7880 */ - 0x0000, /* R7881 */ - 0x0000, /* R7882 */ - 0x0000, /* R7883 */ - 0x0000, /* R7884 */ - 0x0000, /* R7885 */ - 0x0000, /* R7886 */ - 0x0000, /* R7887 */ - 0x0000, /* R7888 */ - 0x0000, /* R7889 */ - 0x0000, /* R7890 */ - 0x0000, /* R7891 */ - 0x0000, /* R7892 */ - 0x0000, /* R7893 */ - 0x0000, /* R7894 */ - 0x0000, /* R7895 */ - 0x0000, /* R7896 */ - 0x0000, /* R7897 */ - 0x0000, /* R7898 */ - 0x0000, /* R7899 */ - 0x0000, /* R7900 */ - 0x0000, /* R7901 */ - 0x0000, /* R7902 */ - 0x0000, /* R7903 */ - 0x0000, /* R7904 */ - 0x0000, /* R7905 */ - 0x0000, /* R7906 */ - 0x0000, /* R7907 */ - 0x0000, /* R7908 */ - 0x0000, /* R7909 */ - 0x0000, /* R7910 */ - 0x0000, /* R7911 */ - 0x0000, /* R7912 */ - 0x0000, /* R7913 */ - 0x0000, /* R7914 */ - 0x0000, /* R7915 */ - 0x0000, /* R7916 */ - 0x0000, /* R7917 */ - 0x0000, /* R7918 */ - 0x0000, /* R7919 */ - 0x0000, /* R7920 */ - 0x0000, /* R7921 */ - 0x0000, /* R7922 */ - 0x0000, /* R7923 */ - 0x0000, /* R7924 */ - 0x0000, /* R7925 */ - 0x0000, /* R7926 */ - 0x0000, /* R7927 */ - 0x0000, /* R7928 */ - 0x0000, /* R7929 */ - 0x0000, /* R7930 */ - 0x0000, /* R7931 */ - 0x0000, /* R7932 */ - 0x0000, /* R7933 */ - 0x0000, /* R7934 */ - 0x0000, /* R7935 */ - 0x0000, /* R7936 */ - 0x0000, /* R7937 */ - 0x0000, /* R7938 */ - 0x0000, /* R7939 */ - 0x0000, /* R7940 */ - 0x0000, /* R7941 */ - 0x0000, /* R7942 */ - 0x0000, /* R7943 */ - 0x0000, /* R7944 */ - 0x0000, /* R7945 */ - 0x0000, /* R7946 */ - 0x0000, /* R7947 */ - 0x0000, /* R7948 */ - 0x0000, /* R7949 */ - 0x0000, /* R7950 */ - 0x0000, /* R7951 */ - 0x0000, /* R7952 */ - 0x0000, /* R7953 */ - 0x0000, /* R7954 */ - 0x0000, /* R7955 */ - 0x0000, /* R7956 */ - 0x0000, /* R7957 */ - 0x0000, /* R7958 */ - 0x0000, /* R7959 */ - 0x0000, /* R7960 */ - 0x0000, /* R7961 */ - 0x0000, /* R7962 */ - 0x0000, /* R7963 */ - 0x0000, /* R7964 */ - 0x0000, /* R7965 */ - 0x0000, /* R7966 */ - 0x0000, /* R7967 */ - 0x0000, /* R7968 */ - 0x0000, /* R7969 */ - 0x0000, /* R7970 */ - 0x0000, /* R7971 */ - 0x0000, /* R7972 */ - 0x0000, /* R7973 */ - 0x0000, /* R7974 */ - 0x0000, /* R7975 */ - 0x0000, /* R7976 */ - 0x0000, /* R7977 */ - 0x0000, /* R7978 */ - 0x0000, /* R7979 */ - 0x0000, /* R7980 */ - 0x0000, /* R7981 */ - 0x0000, /* R7982 */ - 0x0000, /* R7983 */ - 0x0000, /* R7984 */ - 0x0000, /* R7985 */ - 0x0000, /* R7986 */ - 0x0000, /* R7987 */ - 0x0000, /* R7988 */ - 0x0000, /* R7989 */ - 0x0000, /* R7990 */ - 0x0000, /* R7991 */ - 0x0000, /* R7992 */ - 0x0000, /* R7993 */ - 0x0000, /* R7994 */ - 0x0000, /* R7995 */ - 0x0000, /* R7996 */ - 0x0000, /* R7997 */ - 0x0000, /* R7998 */ - 0x0000, /* R7999 */ - 0x0000, /* R8000 */ - 0x0000, /* R8001 */ - 0x0000, /* R8002 */ - 0x0000, /* R8003 */ - 0x0000, /* R8004 */ - 0x0000, /* R8005 */ - 0x0000, /* R8006 */ - 0x0000, /* R8007 */ - 0x0000, /* R8008 */ - 0x0000, /* R8009 */ - 0x0000, /* R8010 */ - 0x0000, /* R8011 */ - 0x0000, /* R8012 */ - 0x0000, /* R8013 */ - 0x0000, /* R8014 */ - 0x0000, /* R8015 */ - 0x0000, /* R8016 */ - 0x0000, /* R8017 */ - 0x0000, /* R8018 */ - 0x0000, /* R8019 */ - 0x0000, /* R8020 */ - 0x0000, /* R8021 */ - 0x0000, /* R8022 */ - 0x0000, /* R8023 */ - 0x0000, /* R8024 */ - 0x0000, /* R8025 */ - 0x0000, /* R8026 */ - 0x0000, /* R8027 */ - 0x0000, /* R8028 */ - 0x0000, /* R8029 */ - 0x0000, /* R8030 */ - 0x0000, /* R8031 */ - 0x0000, /* R8032 */ - 0x0000, /* R8033 */ - 0x0000, /* R8034 */ - 0x0000, /* R8035 */ - 0x0000, /* R8036 */ - 0x0000, /* R8037 */ - 0x0000, /* R8038 */ - 0x0000, /* R8039 */ - 0x0000, /* R8040 */ - 0x0000, /* R8041 */ - 0x0000, /* R8042 */ - 0x0000, /* R8043 */ - 0x0000, /* R8044 */ - 0x0000, /* R8045 */ - 0x0000, /* R8046 */ - 0x0000, /* R8047 */ - 0x0000, /* R8048 */ - 0x0000, /* R8049 */ - 0x0000, /* R8050 */ - 0x0000, /* R8051 */ - 0x0000, /* R8052 */ - 0x0000, /* R8053 */ - 0x0000, /* R8054 */ - 0x0000, /* R8055 */ - 0x0000, /* R8056 */ - 0x0000, /* R8057 */ - 0x0000, /* R8058 */ - 0x0000, /* R8059 */ - 0x0000, /* R8060 */ - 0x0000, /* R8061 */ - 0x0000, /* R8062 */ - 0x0000, /* R8063 */ - 0x0000, /* R8064 */ - 0x0000, /* R8065 */ - 0x0000, /* R8066 */ - 0x0000, /* R8067 */ - 0x0000, /* R8068 */ - 0x0000, /* R8069 */ - 0x0000, /* R8070 */ - 0x0000, /* R8071 */ - 0x0000, /* R8072 */ - 0x0000, /* R8073 */ - 0x0000, /* R8074 */ - 0x0000, /* R8075 */ - 0x0000, /* R8076 */ - 0x0000, /* R8077 */ - 0x0000, /* R8078 */ - 0x0000, /* R8079 */ - 0x0000, /* R8080 */ - 0x0000, /* R8081 */ - 0x0000, /* R8082 */ - 0x0000, /* R8083 */ - 0x0000, /* R8084 */ - 0x0000, /* R8085 */ - 0x0000, /* R8086 */ - 0x0000, /* R8087 */ - 0x0000, /* R8088 */ - 0x0000, /* R8089 */ - 0x0000, /* R8090 */ - 0x0000, /* R8091 */ - 0x0000, /* R8092 */ - 0x0000, /* R8093 */ - 0x0000, /* R8094 */ - 0x0000, /* R8095 */ - 0x0000, /* R8096 */ - 0x0000, /* R8097 */ - 0x0000, /* R8098 */ - 0x0000, /* R8099 */ - 0x0000, /* R8100 */ - 0x0000, /* R8101 */ - 0x0000, /* R8102 */ - 0x0000, /* R8103 */ - 0x0000, /* R8104 */ - 0x0000, /* R8105 */ - 0x0000, /* R8106 */ - 0x0000, /* R8107 */ - 0x0000, /* R8108 */ - 0x0000, /* R8109 */ - 0x0000, /* R8110 */ - 0x0000, /* R8111 */ - 0x0000, /* R8112 */ - 0x0000, /* R8113 */ - 0x0000, /* R8114 */ - 0x0000, /* R8115 */ - 0x0000, /* R8116 */ - 0x0000, /* R8117 */ - 0x0000, /* R8118 */ - 0x0000, /* R8119 */ - 0x0000, /* R8120 */ - 0x0000, /* R8121 */ - 0x0000, /* R8122 */ - 0x0000, /* R8123 */ - 0x0000, /* R8124 */ - 0x0000, /* R8125 */ - 0x0000, /* R8126 */ - 0x0000, /* R8127 */ - 0x0000, /* R8128 */ - 0x0000, /* R8129 */ - 0x0000, /* R8130 */ - 0x0000, /* R8131 */ - 0x0000, /* R8132 */ - 0x0000, /* R8133 */ - 0x0000, /* R8134 */ - 0x0000, /* R8135 */ - 0x0000, /* R8136 */ - 0x0000, /* R8137 */ - 0x0000, /* R8138 */ - 0x0000, /* R8139 */ - 0x0000, /* R8140 */ - 0x0000, /* R8141 */ - 0x0000, /* R8142 */ - 0x0000, /* R8143 */ - 0x0000, /* R8144 */ - 0x0000, /* R8145 */ - 0x0000, /* R8146 */ - 0x0000, /* R8147 */ - 0x0000, /* R8148 */ - 0x0000, /* R8149 */ - 0x0000, /* R8150 */ - 0x0000, /* R8151 */ - 0x0000, /* R8152 */ - 0x0000, /* R8153 */ - 0x0000, /* R8154 */ - 0x0000, /* R8155 */ - 0x0000, /* R8156 */ - 0x0000, /* R8157 */ - 0x0000, /* R8158 */ - 0x0000, /* R8159 */ - 0x0000, /* R8160 */ - 0x0000, /* R8161 */ - 0x0000, /* R8162 */ - 0x0000, /* R8163 */ - 0x0000, /* R8164 */ - 0x0000, /* R8165 */ - 0x0000, /* R8166 */ - 0x0000, /* R8167 */ - 0x0000, /* R8168 */ - 0x0000, /* R8169 */ - 0x0000, /* R8170 */ - 0x0000, /* R8171 */ - 0x0000, /* R8172 */ - 0x0000, /* R8173 */ - 0x0000, /* R8174 */ - 0x0000, /* R8175 */ - 0x0000, /* R8176 */ - 0x0000, /* R8177 */ - 0x0000, /* R8178 */ - 0x0000, /* R8179 */ - 0x0000, /* R8180 */ - 0x0000, /* R8181 */ - 0x0000, /* R8182 */ - 0x0000, /* R8183 */ - 0x0000, /* R8184 */ - 0x0000, /* R8185 */ - 0x0000, /* R8186 */ - 0x0000, /* R8187 */ - 0x0000, /* R8188 */ - 0x0000, /* R8189 */ - 0x0000, /* R8190 */ - 0x0000, /* R8191 */ - 0x0000, /* R8192 - DSP2 Instruction RAM 0 */ - 0x0000, /* R8193 */ - 0x0000, /* R8194 */ - 0x0000, /* R8195 */ - 0x0000, /* R8196 */ - 0x0000, /* R8197 */ - 0x0000, /* R8198 */ - 0x0000, /* R8199 */ - 0x0000, /* R8200 */ - 0x0000, /* R8201 */ - 0x0000, /* R8202 */ - 0x0000, /* R8203 */ - 0x0000, /* R8204 */ - 0x0000, /* R8205 */ - 0x0000, /* R8206 */ - 0x0000, /* R8207 */ - 0x0000, /* R8208 */ - 0x0000, /* R8209 */ - 0x0000, /* R8210 */ - 0x0000, /* R8211 */ - 0x0000, /* R8212 */ - 0x0000, /* R8213 */ - 0x0000, /* R8214 */ - 0x0000, /* R8215 */ - 0x0000, /* R8216 */ - 0x0000, /* R8217 */ - 0x0000, /* R8218 */ - 0x0000, /* R8219 */ - 0x0000, /* R8220 */ - 0x0000, /* R8221 */ - 0x0000, /* R8222 */ - 0x0000, /* R8223 */ - 0x0000, /* R8224 */ - 0x0000, /* R8225 */ - 0x0000, /* R8226 */ - 0x0000, /* R8227 */ - 0x0000, /* R8228 */ - 0x0000, /* R8229 */ - 0x0000, /* R8230 */ - 0x0000, /* R8231 */ - 0x0000, /* R8232 */ - 0x0000, /* R8233 */ - 0x0000, /* R8234 */ - 0x0000, /* R8235 */ - 0x0000, /* R8236 */ - 0x0000, /* R8237 */ - 0x0000, /* R8238 */ - 0x0000, /* R8239 */ - 0x0000, /* R8240 */ - 0x0000, /* R8241 */ - 0x0000, /* R8242 */ - 0x0000, /* R8243 */ - 0x0000, /* R8244 */ - 0x0000, /* R8245 */ - 0x0000, /* R8246 */ - 0x0000, /* R8247 */ - 0x0000, /* R8248 */ - 0x0000, /* R8249 */ - 0x0000, /* R8250 */ - 0x0000, /* R8251 */ - 0x0000, /* R8252 */ - 0x0000, /* R8253 */ - 0x0000, /* R8254 */ - 0x0000, /* R8255 */ - 0x0000, /* R8256 */ - 0x0000, /* R8257 */ - 0x0000, /* R8258 */ - 0x0000, /* R8259 */ - 0x0000, /* R8260 */ - 0x0000, /* R8261 */ - 0x0000, /* R8262 */ - 0x0000, /* R8263 */ - 0x0000, /* R8264 */ - 0x0000, /* R8265 */ - 0x0000, /* R8266 */ - 0x0000, /* R8267 */ - 0x0000, /* R8268 */ - 0x0000, /* R8269 */ - 0x0000, /* R8270 */ - 0x0000, /* R8271 */ - 0x0000, /* R8272 */ - 0x0000, /* R8273 */ - 0x0000, /* R8274 */ - 0x0000, /* R8275 */ - 0x0000, /* R8276 */ - 0x0000, /* R8277 */ - 0x0000, /* R8278 */ - 0x0000, /* R8279 */ - 0x0000, /* R8280 */ - 0x0000, /* R8281 */ - 0x0000, /* R8282 */ - 0x0000, /* R8283 */ - 0x0000, /* R8284 */ - 0x0000, /* R8285 */ - 0x0000, /* R8286 */ - 0x0000, /* R8287 */ - 0x0000, /* R8288 */ - 0x0000, /* R8289 */ - 0x0000, /* R8290 */ - 0x0000, /* R8291 */ - 0x0000, /* R8292 */ - 0x0000, /* R8293 */ - 0x0000, /* R8294 */ - 0x0000, /* R8295 */ - 0x0000, /* R8296 */ - 0x0000, /* R8297 */ - 0x0000, /* R8298 */ - 0x0000, /* R8299 */ - 0x0000, /* R8300 */ - 0x0000, /* R8301 */ - 0x0000, /* R8302 */ - 0x0000, /* R8303 */ - 0x0000, /* R8304 */ - 0x0000, /* R8305 */ - 0x0000, /* R8306 */ - 0x0000, /* R8307 */ - 0x0000, /* R8308 */ - 0x0000, /* R8309 */ - 0x0000, /* R8310 */ - 0x0000, /* R8311 */ - 0x0000, /* R8312 */ - 0x0000, /* R8313 */ - 0x0000, /* R8314 */ - 0x0000, /* R8315 */ - 0x0000, /* R8316 */ - 0x0000, /* R8317 */ - 0x0000, /* R8318 */ - 0x0000, /* R8319 */ - 0x0000, /* R8320 */ - 0x0000, /* R8321 */ - 0x0000, /* R8322 */ - 0x0000, /* R8323 */ - 0x0000, /* R8324 */ - 0x0000, /* R8325 */ - 0x0000, /* R8326 */ - 0x0000, /* R8327 */ - 0x0000, /* R8328 */ - 0x0000, /* R8329 */ - 0x0000, /* R8330 */ - 0x0000, /* R8331 */ - 0x0000, /* R8332 */ - 0x0000, /* R8333 */ - 0x0000, /* R8334 */ - 0x0000, /* R8335 */ - 0x0000, /* R8336 */ - 0x0000, /* R8337 */ - 0x0000, /* R8338 */ - 0x0000, /* R8339 */ - 0x0000, /* R8340 */ - 0x0000, /* R8341 */ - 0x0000, /* R8342 */ - 0x0000, /* R8343 */ - 0x0000, /* R8344 */ - 0x0000, /* R8345 */ - 0x0000, /* R8346 */ - 0x0000, /* R8347 */ - 0x0000, /* R8348 */ - 0x0000, /* R8349 */ - 0x0000, /* R8350 */ - 0x0000, /* R8351 */ - 0x0000, /* R8352 */ - 0x0000, /* R8353 */ - 0x0000, /* R8354 */ - 0x0000, /* R8355 */ - 0x0000, /* R8356 */ - 0x0000, /* R8357 */ - 0x0000, /* R8358 */ - 0x0000, /* R8359 */ - 0x0000, /* R8360 */ - 0x0000, /* R8361 */ - 0x0000, /* R8362 */ - 0x0000, /* R8363 */ - 0x0000, /* R8364 */ - 0x0000, /* R8365 */ - 0x0000, /* R8366 */ - 0x0000, /* R8367 */ - 0x0000, /* R8368 */ - 0x0000, /* R8369 */ - 0x0000, /* R8370 */ - 0x0000, /* R8371 */ - 0x0000, /* R8372 */ - 0x0000, /* R8373 */ - 0x0000, /* R8374 */ - 0x0000, /* R8375 */ - 0x0000, /* R8376 */ - 0x0000, /* R8377 */ - 0x0000, /* R8378 */ - 0x0000, /* R8379 */ - 0x0000, /* R8380 */ - 0x0000, /* R8381 */ - 0x0000, /* R8382 */ - 0x0000, /* R8383 */ - 0x0000, /* R8384 */ - 0x0000, /* R8385 */ - 0x0000, /* R8386 */ - 0x0000, /* R8387 */ - 0x0000, /* R8388 */ - 0x0000, /* R8389 */ - 0x0000, /* R8390 */ - 0x0000, /* R8391 */ - 0x0000, /* R8392 */ - 0x0000, /* R8393 */ - 0x0000, /* R8394 */ - 0x0000, /* R8395 */ - 0x0000, /* R8396 */ - 0x0000, /* R8397 */ - 0x0000, /* R8398 */ - 0x0000, /* R8399 */ - 0x0000, /* R8400 */ - 0x0000, /* R8401 */ - 0x0000, /* R8402 */ - 0x0000, /* R8403 */ - 0x0000, /* R8404 */ - 0x0000, /* R8405 */ - 0x0000, /* R8406 */ - 0x0000, /* R8407 */ - 0x0000, /* R8408 */ - 0x0000, /* R8409 */ - 0x0000, /* R8410 */ - 0x0000, /* R8411 */ - 0x0000, /* R8412 */ - 0x0000, /* R8413 */ - 0x0000, /* R8414 */ - 0x0000, /* R8415 */ - 0x0000, /* R8416 */ - 0x0000, /* R8417 */ - 0x0000, /* R8418 */ - 0x0000, /* R8419 */ - 0x0000, /* R8420 */ - 0x0000, /* R8421 */ - 0x0000, /* R8422 */ - 0x0000, /* R8423 */ - 0x0000, /* R8424 */ - 0x0000, /* R8425 */ - 0x0000, /* R8426 */ - 0x0000, /* R8427 */ - 0x0000, /* R8428 */ - 0x0000, /* R8429 */ - 0x0000, /* R8430 */ - 0x0000, /* R8431 */ - 0x0000, /* R8432 */ - 0x0000, /* R8433 */ - 0x0000, /* R8434 */ - 0x0000, /* R8435 */ - 0x0000, /* R8436 */ - 0x0000, /* R8437 */ - 0x0000, /* R8438 */ - 0x0000, /* R8439 */ - 0x0000, /* R8440 */ - 0x0000, /* R8441 */ - 0x0000, /* R8442 */ - 0x0000, /* R8443 */ - 0x0000, /* R8444 */ - 0x0000, /* R8445 */ - 0x0000, /* R8446 */ - 0x0000, /* R8447 */ - 0x0000, /* R8448 */ - 0x0000, /* R8449 */ - 0x0000, /* R8450 */ - 0x0000, /* R8451 */ - 0x0000, /* R8452 */ - 0x0000, /* R8453 */ - 0x0000, /* R8454 */ - 0x0000, /* R8455 */ - 0x0000, /* R8456 */ - 0x0000, /* R8457 */ - 0x0000, /* R8458 */ - 0x0000, /* R8459 */ - 0x0000, /* R8460 */ - 0x0000, /* R8461 */ - 0x0000, /* R8462 */ - 0x0000, /* R8463 */ - 0x0000, /* R8464 */ - 0x0000, /* R8465 */ - 0x0000, /* R8466 */ - 0x0000, /* R8467 */ - 0x0000, /* R8468 */ - 0x0000, /* R8469 */ - 0x0000, /* R8470 */ - 0x0000, /* R8471 */ - 0x0000, /* R8472 */ - 0x0000, /* R8473 */ - 0x0000, /* R8474 */ - 0x0000, /* R8475 */ - 0x0000, /* R8476 */ - 0x0000, /* R8477 */ - 0x0000, /* R8478 */ - 0x0000, /* R8479 */ - 0x0000, /* R8480 */ - 0x0000, /* R8481 */ - 0x0000, /* R8482 */ - 0x0000, /* R8483 */ - 0x0000, /* R8484 */ - 0x0000, /* R8485 */ - 0x0000, /* R8486 */ - 0x0000, /* R8487 */ - 0x0000, /* R8488 */ - 0x0000, /* R8489 */ - 0x0000, /* R8490 */ - 0x0000, /* R8491 */ - 0x0000, /* R8492 */ - 0x0000, /* R8493 */ - 0x0000, /* R8494 */ - 0x0000, /* R8495 */ - 0x0000, /* R8496 */ - 0x0000, /* R8497 */ - 0x0000, /* R8498 */ - 0x0000, /* R8499 */ - 0x0000, /* R8500 */ - 0x0000, /* R8501 */ - 0x0000, /* R8502 */ - 0x0000, /* R8503 */ - 0x0000, /* R8504 */ - 0x0000, /* R8505 */ - 0x0000, /* R8506 */ - 0x0000, /* R8507 */ - 0x0000, /* R8508 */ - 0x0000, /* R8509 */ - 0x0000, /* R8510 */ - 0x0000, /* R8511 */ - 0x0000, /* R8512 */ - 0x0000, /* R8513 */ - 0x0000, /* R8514 */ - 0x0000, /* R8515 */ - 0x0000, /* R8516 */ - 0x0000, /* R8517 */ - 0x0000, /* R8518 */ - 0x0000, /* R8519 */ - 0x0000, /* R8520 */ - 0x0000, /* R8521 */ - 0x0000, /* R8522 */ - 0x0000, /* R8523 */ - 0x0000, /* R8524 */ - 0x0000, /* R8525 */ - 0x0000, /* R8526 */ - 0x0000, /* R8527 */ - 0x0000, /* R8528 */ - 0x0000, /* R8529 */ - 0x0000, /* R8530 */ - 0x0000, /* R8531 */ - 0x0000, /* R8532 */ - 0x0000, /* R8533 */ - 0x0000, /* R8534 */ - 0x0000, /* R8535 */ - 0x0000, /* R8536 */ - 0x0000, /* R8537 */ - 0x0000, /* R8538 */ - 0x0000, /* R8539 */ - 0x0000, /* R8540 */ - 0x0000, /* R8541 */ - 0x0000, /* R8542 */ - 0x0000, /* R8543 */ - 0x0000, /* R8544 */ - 0x0000, /* R8545 */ - 0x0000, /* R8546 */ - 0x0000, /* R8547 */ - 0x0000, /* R8548 */ - 0x0000, /* R8549 */ - 0x0000, /* R8550 */ - 0x0000, /* R8551 */ - 0x0000, /* R8552 */ - 0x0000, /* R8553 */ - 0x0000, /* R8554 */ - 0x0000, /* R8555 */ - 0x0000, /* R8556 */ - 0x0000, /* R8557 */ - 0x0000, /* R8558 */ - 0x0000, /* R8559 */ - 0x0000, /* R8560 */ - 0x0000, /* R8561 */ - 0x0000, /* R8562 */ - 0x0000, /* R8563 */ - 0x0000, /* R8564 */ - 0x0000, /* R8565 */ - 0x0000, /* R8566 */ - 0x0000, /* R8567 */ - 0x0000, /* R8568 */ - 0x0000, /* R8569 */ - 0x0000, /* R8570 */ - 0x0000, /* R8571 */ - 0x0000, /* R8572 */ - 0x0000, /* R8573 */ - 0x0000, /* R8574 */ - 0x0000, /* R8575 */ - 0x0000, /* R8576 */ - 0x0000, /* R8577 */ - 0x0000, /* R8578 */ - 0x0000, /* R8579 */ - 0x0000, /* R8580 */ - 0x0000, /* R8581 */ - 0x0000, /* R8582 */ - 0x0000, /* R8583 */ - 0x0000, /* R8584 */ - 0x0000, /* R8585 */ - 0x0000, /* R8586 */ - 0x0000, /* R8587 */ - 0x0000, /* R8588 */ - 0x0000, /* R8589 */ - 0x0000, /* R8590 */ - 0x0000, /* R8591 */ - 0x0000, /* R8592 */ - 0x0000, /* R8593 */ - 0x0000, /* R8594 */ - 0x0000, /* R8595 */ - 0x0000, /* R8596 */ - 0x0000, /* R8597 */ - 0x0000, /* R8598 */ - 0x0000, /* R8599 */ - 0x0000, /* R8600 */ - 0x0000, /* R8601 */ - 0x0000, /* R8602 */ - 0x0000, /* R8603 */ - 0x0000, /* R8604 */ - 0x0000, /* R8605 */ - 0x0000, /* R8606 */ - 0x0000, /* R8607 */ - 0x0000, /* R8608 */ - 0x0000, /* R8609 */ - 0x0000, /* R8610 */ - 0x0000, /* R8611 */ - 0x0000, /* R8612 */ - 0x0000, /* R8613 */ - 0x0000, /* R8614 */ - 0x0000, /* R8615 */ - 0x0000, /* R8616 */ - 0x0000, /* R8617 */ - 0x0000, /* R8618 */ - 0x0000, /* R8619 */ - 0x0000, /* R8620 */ - 0x0000, /* R8621 */ - 0x0000, /* R8622 */ - 0x0000, /* R8623 */ - 0x0000, /* R8624 */ - 0x0000, /* R8625 */ - 0x0000, /* R8626 */ - 0x0000, /* R8627 */ - 0x0000, /* R8628 */ - 0x0000, /* R8629 */ - 0x0000, /* R8630 */ - 0x0000, /* R8631 */ - 0x0000, /* R8632 */ - 0x0000, /* R8633 */ - 0x0000, /* R8634 */ - 0x0000, /* R8635 */ - 0x0000, /* R8636 */ - 0x0000, /* R8637 */ - 0x0000, /* R8638 */ - 0x0000, /* R8639 */ - 0x0000, /* R8640 */ - 0x0000, /* R8641 */ - 0x0000, /* R8642 */ - 0x0000, /* R8643 */ - 0x0000, /* R8644 */ - 0x0000, /* R8645 */ - 0x0000, /* R8646 */ - 0x0000, /* R8647 */ - 0x0000, /* R8648 */ - 0x0000, /* R8649 */ - 0x0000, /* R8650 */ - 0x0000, /* R8651 */ - 0x0000, /* R8652 */ - 0x0000, /* R8653 */ - 0x0000, /* R8654 */ - 0x0000, /* R8655 */ - 0x0000, /* R8656 */ - 0x0000, /* R8657 */ - 0x0000, /* R8658 */ - 0x0000, /* R8659 */ - 0x0000, /* R8660 */ - 0x0000, /* R8661 */ - 0x0000, /* R8662 */ - 0x0000, /* R8663 */ - 0x0000, /* R8664 */ - 0x0000, /* R8665 */ - 0x0000, /* R8666 */ - 0x0000, /* R8667 */ - 0x0000, /* R8668 */ - 0x0000, /* R8669 */ - 0x0000, /* R8670 */ - 0x0000, /* R8671 */ - 0x0000, /* R8672 */ - 0x0000, /* R8673 */ - 0x0000, /* R8674 */ - 0x0000, /* R8675 */ - 0x0000, /* R8676 */ - 0x0000, /* R8677 */ - 0x0000, /* R8678 */ - 0x0000, /* R8679 */ - 0x0000, /* R8680 */ - 0x0000, /* R8681 */ - 0x0000, /* R8682 */ - 0x0000, /* R8683 */ - 0x0000, /* R8684 */ - 0x0000, /* R8685 */ - 0x0000, /* R8686 */ - 0x0000, /* R8687 */ - 0x0000, /* R8688 */ - 0x0000, /* R8689 */ - 0x0000, /* R8690 */ - 0x0000, /* R8691 */ - 0x0000, /* R8692 */ - 0x0000, /* R8693 */ - 0x0000, /* R8694 */ - 0x0000, /* R8695 */ - 0x0000, /* R8696 */ - 0x0000, /* R8697 */ - 0x0000, /* R8698 */ - 0x0000, /* R8699 */ - 0x0000, /* R8700 */ - 0x0000, /* R8701 */ - 0x0000, /* R8702 */ - 0x0000, /* R8703 */ - 0x0000, /* R8704 */ - 0x0000, /* R8705 */ - 0x0000, /* R8706 */ - 0x0000, /* R8707 */ - 0x0000, /* R8708 */ - 0x0000, /* R8709 */ - 0x0000, /* R8710 */ - 0x0000, /* R8711 */ - 0x0000, /* R8712 */ - 0x0000, /* R8713 */ - 0x0000, /* R8714 */ - 0x0000, /* R8715 */ - 0x0000, /* R8716 */ - 0x0000, /* R8717 */ - 0x0000, /* R8718 */ - 0x0000, /* R8719 */ - 0x0000, /* R8720 */ - 0x0000, /* R8721 */ - 0x0000, /* R8722 */ - 0x0000, /* R8723 */ - 0x0000, /* R8724 */ - 0x0000, /* R8725 */ - 0x0000, /* R8726 */ - 0x0000, /* R8727 */ - 0x0000, /* R8728 */ - 0x0000, /* R8729 */ - 0x0000, /* R8730 */ - 0x0000, /* R8731 */ - 0x0000, /* R8732 */ - 0x0000, /* R8733 */ - 0x0000, /* R8734 */ - 0x0000, /* R8735 */ - 0x0000, /* R8736 */ - 0x0000, /* R8737 */ - 0x0000, /* R8738 */ - 0x0000, /* R8739 */ - 0x0000, /* R8740 */ - 0x0000, /* R8741 */ - 0x0000, /* R8742 */ - 0x0000, /* R8743 */ - 0x0000, /* R8744 */ - 0x0000, /* R8745 */ - 0x0000, /* R8746 */ - 0x0000, /* R8747 */ - 0x0000, /* R8748 */ - 0x0000, /* R8749 */ - 0x0000, /* R8750 */ - 0x0000, /* R8751 */ - 0x0000, /* R8752 */ - 0x0000, /* R8753 */ - 0x0000, /* R8754 */ - 0x0000, /* R8755 */ - 0x0000, /* R8756 */ - 0x0000, /* R8757 */ - 0x0000, /* R8758 */ - 0x0000, /* R8759 */ - 0x0000, /* R8760 */ - 0x0000, /* R8761 */ - 0x0000, /* R8762 */ - 0x0000, /* R8763 */ - 0x0000, /* R8764 */ - 0x0000, /* R8765 */ - 0x0000, /* R8766 */ - 0x0000, /* R8767 */ - 0x0000, /* R8768 */ - 0x0000, /* R8769 */ - 0x0000, /* R8770 */ - 0x0000, /* R8771 */ - 0x0000, /* R8772 */ - 0x0000, /* R8773 */ - 0x0000, /* R8774 */ - 0x0000, /* R8775 */ - 0x0000, /* R8776 */ - 0x0000, /* R8777 */ - 0x0000, /* R8778 */ - 0x0000, /* R8779 */ - 0x0000, /* R8780 */ - 0x0000, /* R8781 */ - 0x0000, /* R8782 */ - 0x0000, /* R8783 */ - 0x0000, /* R8784 */ - 0x0000, /* R8785 */ - 0x0000, /* R8786 */ - 0x0000, /* R8787 */ - 0x0000, /* R8788 */ - 0x0000, /* R8789 */ - 0x0000, /* R8790 */ - 0x0000, /* R8791 */ - 0x0000, /* R8792 */ - 0x0000, /* R8793 */ - 0x0000, /* R8794 */ - 0x0000, /* R8795 */ - 0x0000, /* R8796 */ - 0x0000, /* R8797 */ - 0x0000, /* R8798 */ - 0x0000, /* R8799 */ - 0x0000, /* R8800 */ - 0x0000, /* R8801 */ - 0x0000, /* R8802 */ - 0x0000, /* R8803 */ - 0x0000, /* R8804 */ - 0x0000, /* R8805 */ - 0x0000, /* R8806 */ - 0x0000, /* R8807 */ - 0x0000, /* R8808 */ - 0x0000, /* R8809 */ - 0x0000, /* R8810 */ - 0x0000, /* R8811 */ - 0x0000, /* R8812 */ - 0x0000, /* R8813 */ - 0x0000, /* R8814 */ - 0x0000, /* R8815 */ - 0x0000, /* R8816 */ - 0x0000, /* R8817 */ - 0x0000, /* R8818 */ - 0x0000, /* R8819 */ - 0x0000, /* R8820 */ - 0x0000, /* R8821 */ - 0x0000, /* R8822 */ - 0x0000, /* R8823 */ - 0x0000, /* R8824 */ - 0x0000, /* R8825 */ - 0x0000, /* R8826 */ - 0x0000, /* R8827 */ - 0x0000, /* R8828 */ - 0x0000, /* R8829 */ - 0x0000, /* R8830 */ - 0x0000, /* R8831 */ - 0x0000, /* R8832 */ - 0x0000, /* R8833 */ - 0x0000, /* R8834 */ - 0x0000, /* R8835 */ - 0x0000, /* R8836 */ - 0x0000, /* R8837 */ - 0x0000, /* R8838 */ - 0x0000, /* R8839 */ - 0x0000, /* R8840 */ - 0x0000, /* R8841 */ - 0x0000, /* R8842 */ - 0x0000, /* R8843 */ - 0x0000, /* R8844 */ - 0x0000, /* R8845 */ - 0x0000, /* R8846 */ - 0x0000, /* R8847 */ - 0x0000, /* R8848 */ - 0x0000, /* R8849 */ - 0x0000, /* R8850 */ - 0x0000, /* R8851 */ - 0x0000, /* R8852 */ - 0x0000, /* R8853 */ - 0x0000, /* R8854 */ - 0x0000, /* R8855 */ - 0x0000, /* R8856 */ - 0x0000, /* R8857 */ - 0x0000, /* R8858 */ - 0x0000, /* R8859 */ - 0x0000, /* R8860 */ - 0x0000, /* R8861 */ - 0x0000, /* R8862 */ - 0x0000, /* R8863 */ - 0x0000, /* R8864 */ - 0x0000, /* R8865 */ - 0x0000, /* R8866 */ - 0x0000, /* R8867 */ - 0x0000, /* R8868 */ - 0x0000, /* R8869 */ - 0x0000, /* R8870 */ - 0x0000, /* R8871 */ - 0x0000, /* R8872 */ - 0x0000, /* R8873 */ - 0x0000, /* R8874 */ - 0x0000, /* R8875 */ - 0x0000, /* R8876 */ - 0x0000, /* R8877 */ - 0x0000, /* R8878 */ - 0x0000, /* R8879 */ - 0x0000, /* R8880 */ - 0x0000, /* R8881 */ - 0x0000, /* R8882 */ - 0x0000, /* R8883 */ - 0x0000, /* R8884 */ - 0x0000, /* R8885 */ - 0x0000, /* R8886 */ - 0x0000, /* R8887 */ - 0x0000, /* R8888 */ - 0x0000, /* R8889 */ - 0x0000, /* R8890 */ - 0x0000, /* R8891 */ - 0x0000, /* R8892 */ - 0x0000, /* R8893 */ - 0x0000, /* R8894 */ - 0x0000, /* R8895 */ - 0x0000, /* R8896 */ - 0x0000, /* R8897 */ - 0x0000, /* R8898 */ - 0x0000, /* R8899 */ - 0x0000, /* R8900 */ - 0x0000, /* R8901 */ - 0x0000, /* R8902 */ - 0x0000, /* R8903 */ - 0x0000, /* R8904 */ - 0x0000, /* R8905 */ - 0x0000, /* R8906 */ - 0x0000, /* R8907 */ - 0x0000, /* R8908 */ - 0x0000, /* R8909 */ - 0x0000, /* R8910 */ - 0x0000, /* R8911 */ - 0x0000, /* R8912 */ - 0x0000, /* R8913 */ - 0x0000, /* R8914 */ - 0x0000, /* R8915 */ - 0x0000, /* R8916 */ - 0x0000, /* R8917 */ - 0x0000, /* R8918 */ - 0x0000, /* R8919 */ - 0x0000, /* R8920 */ - 0x0000, /* R8921 */ - 0x0000, /* R8922 */ - 0x0000, /* R8923 */ - 0x0000, /* R8924 */ - 0x0000, /* R8925 */ - 0x0000, /* R8926 */ - 0x0000, /* R8927 */ - 0x0000, /* R8928 */ - 0x0000, /* R8929 */ - 0x0000, /* R8930 */ - 0x0000, /* R8931 */ - 0x0000, /* R8932 */ - 0x0000, /* R8933 */ - 0x0000, /* R8934 */ - 0x0000, /* R8935 */ - 0x0000, /* R8936 */ - 0x0000, /* R8937 */ - 0x0000, /* R8938 */ - 0x0000, /* R8939 */ - 0x0000, /* R8940 */ - 0x0000, /* R8941 */ - 0x0000, /* R8942 */ - 0x0000, /* R8943 */ - 0x0000, /* R8944 */ - 0x0000, /* R8945 */ - 0x0000, /* R8946 */ - 0x0000, /* R8947 */ - 0x0000, /* R8948 */ - 0x0000, /* R8949 */ - 0x0000, /* R8950 */ - 0x0000, /* R8951 */ - 0x0000, /* R8952 */ - 0x0000, /* R8953 */ - 0x0000, /* R8954 */ - 0x0000, /* R8955 */ - 0x0000, /* R8956 */ - 0x0000, /* R8957 */ - 0x0000, /* R8958 */ - 0x0000, /* R8959 */ - 0x0000, /* R8960 */ - 0x0000, /* R8961 */ - 0x0000, /* R8962 */ - 0x0000, /* R8963 */ - 0x0000, /* R8964 */ - 0x0000, /* R8965 */ - 0x0000, /* R8966 */ - 0x0000, /* R8967 */ - 0x0000, /* R8968 */ - 0x0000, /* R8969 */ - 0x0000, /* R8970 */ - 0x0000, /* R8971 */ - 0x0000, /* R8972 */ - 0x0000, /* R8973 */ - 0x0000, /* R8974 */ - 0x0000, /* R8975 */ - 0x0000, /* R8976 */ - 0x0000, /* R8977 */ - 0x0000, /* R8978 */ - 0x0000, /* R8979 */ - 0x0000, /* R8980 */ - 0x0000, /* R8981 */ - 0x0000, /* R8982 */ - 0x0000, /* R8983 */ - 0x0000, /* R8984 */ - 0x0000, /* R8985 */ - 0x0000, /* R8986 */ - 0x0000, /* R8987 */ - 0x0000, /* R8988 */ - 0x0000, /* R8989 */ - 0x0000, /* R8990 */ - 0x0000, /* R8991 */ - 0x0000, /* R8992 */ - 0x0000, /* R8993 */ - 0x0000, /* R8994 */ - 0x0000, /* R8995 */ - 0x0000, /* R8996 */ - 0x0000, /* R8997 */ - 0x0000, /* R8998 */ - 0x0000, /* R8999 */ - 0x0000, /* R9000 */ - 0x0000, /* R9001 */ - 0x0000, /* R9002 */ - 0x0000, /* R9003 */ - 0x0000, /* R9004 */ - 0x0000, /* R9005 */ - 0x0000, /* R9006 */ - 0x0000, /* R9007 */ - 0x0000, /* R9008 */ - 0x0000, /* R9009 */ - 0x0000, /* R9010 */ - 0x0000, /* R9011 */ - 0x0000, /* R9012 */ - 0x0000, /* R9013 */ - 0x0000, /* R9014 */ - 0x0000, /* R9015 */ - 0x0000, /* R9016 */ - 0x0000, /* R9017 */ - 0x0000, /* R9018 */ - 0x0000, /* R9019 */ - 0x0000, /* R9020 */ - 0x0000, /* R9021 */ - 0x0000, /* R9022 */ - 0x0000, /* R9023 */ - 0x0000, /* R9024 */ - 0x0000, /* R9025 */ - 0x0000, /* R9026 */ - 0x0000, /* R9027 */ - 0x0000, /* R9028 */ - 0x0000, /* R9029 */ - 0x0000, /* R9030 */ - 0x0000, /* R9031 */ - 0x0000, /* R9032 */ - 0x0000, /* R9033 */ - 0x0000, /* R9034 */ - 0x0000, /* R9035 */ - 0x0000, /* R9036 */ - 0x0000, /* R9037 */ - 0x0000, /* R9038 */ - 0x0000, /* R9039 */ - 0x0000, /* R9040 */ - 0x0000, /* R9041 */ - 0x0000, /* R9042 */ - 0x0000, /* R9043 */ - 0x0000, /* R9044 */ - 0x0000, /* R9045 */ - 0x0000, /* R9046 */ - 0x0000, /* R9047 */ - 0x0000, /* R9048 */ - 0x0000, /* R9049 */ - 0x0000, /* R9050 */ - 0x0000, /* R9051 */ - 0x0000, /* R9052 */ - 0x0000, /* R9053 */ - 0x0000, /* R9054 */ - 0x0000, /* R9055 */ - 0x0000, /* R9056 */ - 0x0000, /* R9057 */ - 0x0000, /* R9058 */ - 0x0000, /* R9059 */ - 0x0000, /* R9060 */ - 0x0000, /* R9061 */ - 0x0000, /* R9062 */ - 0x0000, /* R9063 */ - 0x0000, /* R9064 */ - 0x0000, /* R9065 */ - 0x0000, /* R9066 */ - 0x0000, /* R9067 */ - 0x0000, /* R9068 */ - 0x0000, /* R9069 */ - 0x0000, /* R9070 */ - 0x0000, /* R9071 */ - 0x0000, /* R9072 */ - 0x0000, /* R9073 */ - 0x0000, /* R9074 */ - 0x0000, /* R9075 */ - 0x0000, /* R9076 */ - 0x0000, /* R9077 */ - 0x0000, /* R9078 */ - 0x0000, /* R9079 */ - 0x0000, /* R9080 */ - 0x0000, /* R9081 */ - 0x0000, /* R9082 */ - 0x0000, /* R9083 */ - 0x0000, /* R9084 */ - 0x0000, /* R9085 */ - 0x0000, /* R9086 */ - 0x0000, /* R9087 */ - 0x0000, /* R9088 */ - 0x0000, /* R9089 */ - 0x0000, /* R9090 */ - 0x0000, /* R9091 */ - 0x0000, /* R9092 */ - 0x0000, /* R9093 */ - 0x0000, /* R9094 */ - 0x0000, /* R9095 */ - 0x0000, /* R9096 */ - 0x0000, /* R9097 */ - 0x0000, /* R9098 */ - 0x0000, /* R9099 */ - 0x0000, /* R9100 */ - 0x0000, /* R9101 */ - 0x0000, /* R9102 */ - 0x0000, /* R9103 */ - 0x0000, /* R9104 */ - 0x0000, /* R9105 */ - 0x0000, /* R9106 */ - 0x0000, /* R9107 */ - 0x0000, /* R9108 */ - 0x0000, /* R9109 */ - 0x0000, /* R9110 */ - 0x0000, /* R9111 */ - 0x0000, /* R9112 */ - 0x0000, /* R9113 */ - 0x0000, /* R9114 */ - 0x0000, /* R9115 */ - 0x0000, /* R9116 */ - 0x0000, /* R9117 */ - 0x0000, /* R9118 */ - 0x0000, /* R9119 */ - 0x0000, /* R9120 */ - 0x0000, /* R9121 */ - 0x0000, /* R9122 */ - 0x0000, /* R9123 */ - 0x0000, /* R9124 */ - 0x0000, /* R9125 */ - 0x0000, /* R9126 */ - 0x0000, /* R9127 */ - 0x0000, /* R9128 */ - 0x0000, /* R9129 */ - 0x0000, /* R9130 */ - 0x0000, /* R9131 */ - 0x0000, /* R9132 */ - 0x0000, /* R9133 */ - 0x0000, /* R9134 */ - 0x0000, /* R9135 */ - 0x0000, /* R9136 */ - 0x0000, /* R9137 */ - 0x0000, /* R9138 */ - 0x0000, /* R9139 */ - 0x0000, /* R9140 */ - 0x0000, /* R9141 */ - 0x0000, /* R9142 */ - 0x0000, /* R9143 */ - 0x0000, /* R9144 */ - 0x0000, /* R9145 */ - 0x0000, /* R9146 */ - 0x0000, /* R9147 */ - 0x0000, /* R9148 */ - 0x0000, /* R9149 */ - 0x0000, /* R9150 */ - 0x0000, /* R9151 */ - 0x0000, /* R9152 */ - 0x0000, /* R9153 */ - 0x0000, /* R9154 */ - 0x0000, /* R9155 */ - 0x0000, /* R9156 */ - 0x0000, /* R9157 */ - 0x0000, /* R9158 */ - 0x0000, /* R9159 */ - 0x0000, /* R9160 */ - 0x0000, /* R9161 */ - 0x0000, /* R9162 */ - 0x0000, /* R9163 */ - 0x0000, /* R9164 */ - 0x0000, /* R9165 */ - 0x0000, /* R9166 */ - 0x0000, /* R9167 */ - 0x0000, /* R9168 */ - 0x0000, /* R9169 */ - 0x0000, /* R9170 */ - 0x0000, /* R9171 */ - 0x0000, /* R9172 */ - 0x0000, /* R9173 */ - 0x0000, /* R9174 */ - 0x0000, /* R9175 */ - 0x0000, /* R9176 */ - 0x0000, /* R9177 */ - 0x0000, /* R9178 */ - 0x0000, /* R9179 */ - 0x0000, /* R9180 */ - 0x0000, /* R9181 */ - 0x0000, /* R9182 */ - 0x0000, /* R9183 */ - 0x0000, /* R9184 */ - 0x0000, /* R9185 */ - 0x0000, /* R9186 */ - 0x0000, /* R9187 */ - 0x0000, /* R9188 */ - 0x0000, /* R9189 */ - 0x0000, /* R9190 */ - 0x0000, /* R9191 */ - 0x0000, /* R9192 */ - 0x0000, /* R9193 */ - 0x0000, /* R9194 */ - 0x0000, /* R9195 */ - 0x0000, /* R9196 */ - 0x0000, /* R9197 */ - 0x0000, /* R9198 */ - 0x0000, /* R9199 */ - 0x0000, /* R9200 */ - 0x0000, /* R9201 */ - 0x0000, /* R9202 */ - 0x0000, /* R9203 */ - 0x0000, /* R9204 */ - 0x0000, /* R9205 */ - 0x0000, /* R9206 */ - 0x0000, /* R9207 */ - 0x0000, /* R9208 */ - 0x0000, /* R9209 */ - 0x0000, /* R9210 */ - 0x0000, /* R9211 */ - 0x0000, /* R9212 */ - 0x0000, /* R9213 */ - 0x0000, /* R9214 */ - 0x0000, /* R9215 */ - 0x0030, /* R9216 - DSP2 Address RAM 2 */ - 0x0000, /* R9217 - DSP2 Address RAM 1 */ - 0x0000, /* R9218 - DSP2 Address RAM 0 */ - 0x0000, /* R9219 */ - 0x0000, /* R9220 */ - 0x0000, /* R9221 */ - 0x0000, /* R9222 */ - 0x0000, /* R9223 */ - 0x0000, /* R9224 */ - 0x0000, /* R9225 */ - 0x0000, /* R9226 */ - 0x0000, /* R9227 */ - 0x0000, /* R9228 */ - 0x0000, /* R9229 */ - 0x0000, /* R9230 */ - 0x0000, /* R9231 */ - 0x0000, /* R9232 */ - 0x0000, /* R9233 */ - 0x0000, /* R9234 */ - 0x0000, /* R9235 */ - 0x0000, /* R9236 */ - 0x0000, /* R9237 */ - 0x0000, /* R9238 */ - 0x0000, /* R9239 */ - 0x0000, /* R9240 */ - 0x0000, /* R9241 */ - 0x0000, /* R9242 */ - 0x0000, /* R9243 */ - 0x0000, /* R9244 */ - 0x0000, /* R9245 */ - 0x0000, /* R9246 */ - 0x0000, /* R9247 */ - 0x0000, /* R9248 */ - 0x0000, /* R9249 */ - 0x0000, /* R9250 */ - 0x0000, /* R9251 */ - 0x0000, /* R9252 */ - 0x0000, /* R9253 */ - 0x0000, /* R9254 */ - 0x0000, /* R9255 */ - 0x0000, /* R9256 */ - 0x0000, /* R9257 */ - 0x0000, /* R9258 */ - 0x0000, /* R9259 */ - 0x0000, /* R9260 */ - 0x0000, /* R9261 */ - 0x0000, /* R9262 */ - 0x0000, /* R9263 */ - 0x0000, /* R9264 */ - 0x0000, /* R9265 */ - 0x0000, /* R9266 */ - 0x0000, /* R9267 */ - 0x0000, /* R9268 */ - 0x0000, /* R9269 */ - 0x0000, /* R9270 */ - 0x0000, /* R9271 */ - 0x0000, /* R9272 */ - 0x0000, /* R9273 */ - 0x0000, /* R9274 */ - 0x0000, /* R9275 */ - 0x0000, /* R9276 */ - 0x0000, /* R9277 */ - 0x0000, /* R9278 */ - 0x0000, /* R9279 */ - 0x0000, /* R9280 */ - 0x0000, /* R9281 */ - 0x0000, /* R9282 */ - 0x0000, /* R9283 */ - 0x0000, /* R9284 */ - 0x0000, /* R9285 */ - 0x0000, /* R9286 */ - 0x0000, /* R9287 */ - 0x0000, /* R9288 */ - 0x0000, /* R9289 */ - 0x0000, /* R9290 */ - 0x0000, /* R9291 */ - 0x0000, /* R9292 */ - 0x0000, /* R9293 */ - 0x0000, /* R9294 */ - 0x0000, /* R9295 */ - 0x0000, /* R9296 */ - 0x0000, /* R9297 */ - 0x0000, /* R9298 */ - 0x0000, /* R9299 */ - 0x0000, /* R9300 */ - 0x0000, /* R9301 */ - 0x0000, /* R9302 */ - 0x0000, /* R9303 */ - 0x0000, /* R9304 */ - 0x0000, /* R9305 */ - 0x0000, /* R9306 */ - 0x0000, /* R9307 */ - 0x0000, /* R9308 */ - 0x0000, /* R9309 */ - 0x0000, /* R9310 */ - 0x0000, /* R9311 */ - 0x0000, /* R9312 */ - 0x0000, /* R9313 */ - 0x0000, /* R9314 */ - 0x0000, /* R9315 */ - 0x0000, /* R9316 */ - 0x0000, /* R9317 */ - 0x0000, /* R9318 */ - 0x0000, /* R9319 */ - 0x0000, /* R9320 */ - 0x0000, /* R9321 */ - 0x0000, /* R9322 */ - 0x0000, /* R9323 */ - 0x0000, /* R9324 */ - 0x0000, /* R9325 */ - 0x0000, /* R9326 */ - 0x0000, /* R9327 */ - 0x0000, /* R9328 */ - 0x0000, /* R9329 */ - 0x0000, /* R9330 */ - 0x0000, /* R9331 */ - 0x0000, /* R9332 */ - 0x0000, /* R9333 */ - 0x0000, /* R9334 */ - 0x0000, /* R9335 */ - 0x0000, /* R9336 */ - 0x0000, /* R9337 */ - 0x0000, /* R9338 */ - 0x0000, /* R9339 */ - 0x0000, /* R9340 */ - 0x0000, /* R9341 */ - 0x0000, /* R9342 */ - 0x0000, /* R9343 */ - 0x0000, /* R9344 */ - 0x0000, /* R9345 */ - 0x0000, /* R9346 */ - 0x0000, /* R9347 */ - 0x0000, /* R9348 */ - 0x0000, /* R9349 */ - 0x0000, /* R9350 */ - 0x0000, /* R9351 */ - 0x0000, /* R9352 */ - 0x0000, /* R9353 */ - 0x0000, /* R9354 */ - 0x0000, /* R9355 */ - 0x0000, /* R9356 */ - 0x0000, /* R9357 */ - 0x0000, /* R9358 */ - 0x0000, /* R9359 */ - 0x0000, /* R9360 */ - 0x0000, /* R9361 */ - 0x0000, /* R9362 */ - 0x0000, /* R9363 */ - 0x0000, /* R9364 */ - 0x0000, /* R9365 */ - 0x0000, /* R9366 */ - 0x0000, /* R9367 */ - 0x0000, /* R9368 */ - 0x0000, /* R9369 */ - 0x0000, /* R9370 */ - 0x0000, /* R9371 */ - 0x0000, /* R9372 */ - 0x0000, /* R9373 */ - 0x0000, /* R9374 */ - 0x0000, /* R9375 */ - 0x0000, /* R9376 */ - 0x0000, /* R9377 */ - 0x0000, /* R9378 */ - 0x0000, /* R9379 */ - 0x0000, /* R9380 */ - 0x0000, /* R9381 */ - 0x0000, /* R9382 */ - 0x0000, /* R9383 */ - 0x0000, /* R9384 */ - 0x0000, /* R9385 */ - 0x0000, /* R9386 */ - 0x0000, /* R9387 */ - 0x0000, /* R9388 */ - 0x0000, /* R9389 */ - 0x0000, /* R9390 */ - 0x0000, /* R9391 */ - 0x0000, /* R9392 */ - 0x0000, /* R9393 */ - 0x0000, /* R9394 */ - 0x0000, /* R9395 */ - 0x0000, /* R9396 */ - 0x0000, /* R9397 */ - 0x0000, /* R9398 */ - 0x0000, /* R9399 */ - 0x0000, /* R9400 */ - 0x0000, /* R9401 */ - 0x0000, /* R9402 */ - 0x0000, /* R9403 */ - 0x0000, /* R9404 */ - 0x0000, /* R9405 */ - 0x0000, /* R9406 */ - 0x0000, /* R9407 */ - 0x0000, /* R9408 */ - 0x0000, /* R9409 */ - 0x0000, /* R9410 */ - 0x0000, /* R9411 */ - 0x0000, /* R9412 */ - 0x0000, /* R9413 */ - 0x0000, /* R9414 */ - 0x0000, /* R9415 */ - 0x0000, /* R9416 */ - 0x0000, /* R9417 */ - 0x0000, /* R9418 */ - 0x0000, /* R9419 */ - 0x0000, /* R9420 */ - 0x0000, /* R9421 */ - 0x0000, /* R9422 */ - 0x0000, /* R9423 */ - 0x0000, /* R9424 */ - 0x0000, /* R9425 */ - 0x0000, /* R9426 */ - 0x0000, /* R9427 */ - 0x0000, /* R9428 */ - 0x0000, /* R9429 */ - 0x0000, /* R9430 */ - 0x0000, /* R9431 */ - 0x0000, /* R9432 */ - 0x0000, /* R9433 */ - 0x0000, /* R9434 */ - 0x0000, /* R9435 */ - 0x0000, /* R9436 */ - 0x0000, /* R9437 */ - 0x0000, /* R9438 */ - 0x0000, /* R9439 */ - 0x0000, /* R9440 */ - 0x0000, /* R9441 */ - 0x0000, /* R9442 */ - 0x0000, /* R9443 */ - 0x0000, /* R9444 */ - 0x0000, /* R9445 */ - 0x0000, /* R9446 */ - 0x0000, /* R9447 */ - 0x0000, /* R9448 */ - 0x0000, /* R9449 */ - 0x0000, /* R9450 */ - 0x0000, /* R9451 */ - 0x0000, /* R9452 */ - 0x0000, /* R9453 */ - 0x0000, /* R9454 */ - 0x0000, /* R9455 */ - 0x0000, /* R9456 */ - 0x0000, /* R9457 */ - 0x0000, /* R9458 */ - 0x0000, /* R9459 */ - 0x0000, /* R9460 */ - 0x0000, /* R9461 */ - 0x0000, /* R9462 */ - 0x0000, /* R9463 */ - 0x0000, /* R9464 */ - 0x0000, /* R9465 */ - 0x0000, /* R9466 */ - 0x0000, /* R9467 */ - 0x0000, /* R9468 */ - 0x0000, /* R9469 */ - 0x0000, /* R9470 */ - 0x0000, /* R9471 */ - 0x0000, /* R9472 */ - 0x0000, /* R9473 */ - 0x0000, /* R9474 */ - 0x0000, /* R9475 */ - 0x0000, /* R9476 */ - 0x0000, /* R9477 */ - 0x0000, /* R9478 */ - 0x0000, /* R9479 */ - 0x0000, /* R9480 */ - 0x0000, /* R9481 */ - 0x0000, /* R9482 */ - 0x0000, /* R9483 */ - 0x0000, /* R9484 */ - 0x0000, /* R9485 */ - 0x0000, /* R9486 */ - 0x0000, /* R9487 */ - 0x0000, /* R9488 */ - 0x0000, /* R9489 */ - 0x0000, /* R9490 */ - 0x0000, /* R9491 */ - 0x0000, /* R9492 */ - 0x0000, /* R9493 */ - 0x0000, /* R9494 */ - 0x0000, /* R9495 */ - 0x0000, /* R9496 */ - 0x0000, /* R9497 */ - 0x0000, /* R9498 */ - 0x0000, /* R9499 */ - 0x0000, /* R9500 */ - 0x0000, /* R9501 */ - 0x0000, /* R9502 */ - 0x0000, /* R9503 */ - 0x0000, /* R9504 */ - 0x0000, /* R9505 */ - 0x0000, /* R9506 */ - 0x0000, /* R9507 */ - 0x0000, /* R9508 */ - 0x0000, /* R9509 */ - 0x0000, /* R9510 */ - 0x0000, /* R9511 */ - 0x0000, /* R9512 */ - 0x0000, /* R9513 */ - 0x0000, /* R9514 */ - 0x0000, /* R9515 */ - 0x0000, /* R9516 */ - 0x0000, /* R9517 */ - 0x0000, /* R9518 */ - 0x0000, /* R9519 */ - 0x0000, /* R9520 */ - 0x0000, /* R9521 */ - 0x0000, /* R9522 */ - 0x0000, /* R9523 */ - 0x0000, /* R9524 */ - 0x0000, /* R9525 */ - 0x0000, /* R9526 */ - 0x0000, /* R9527 */ - 0x0000, /* R9528 */ - 0x0000, /* R9529 */ - 0x0000, /* R9530 */ - 0x0000, /* R9531 */ - 0x0000, /* R9532 */ - 0x0000, /* R9533 */ - 0x0000, /* R9534 */ - 0x0000, /* R9535 */ - 0x0000, /* R9536 */ - 0x0000, /* R9537 */ - 0x0000, /* R9538 */ - 0x0000, /* R9539 */ - 0x0000, /* R9540 */ - 0x0000, /* R9541 */ - 0x0000, /* R9542 */ - 0x0000, /* R9543 */ - 0x0000, /* R9544 */ - 0x0000, /* R9545 */ - 0x0000, /* R9546 */ - 0x0000, /* R9547 */ - 0x0000, /* R9548 */ - 0x0000, /* R9549 */ - 0x0000, /* R9550 */ - 0x0000, /* R9551 */ - 0x0000, /* R9552 */ - 0x0000, /* R9553 */ - 0x0000, /* R9554 */ - 0x0000, /* R9555 */ - 0x0000, /* R9556 */ - 0x0000, /* R9557 */ - 0x0000, /* R9558 */ - 0x0000, /* R9559 */ - 0x0000, /* R9560 */ - 0x0000, /* R9561 */ - 0x0000, /* R9562 */ - 0x0000, /* R9563 */ - 0x0000, /* R9564 */ - 0x0000, /* R9565 */ - 0x0000, /* R9566 */ - 0x0000, /* R9567 */ - 0x0000, /* R9568 */ - 0x0000, /* R9569 */ - 0x0000, /* R9570 */ - 0x0000, /* R9571 */ - 0x0000, /* R9572 */ - 0x0000, /* R9573 */ - 0x0000, /* R9574 */ - 0x0000, /* R9575 */ - 0x0000, /* R9576 */ - 0x0000, /* R9577 */ - 0x0000, /* R9578 */ - 0x0000, /* R9579 */ - 0x0000, /* R9580 */ - 0x0000, /* R9581 */ - 0x0000, /* R9582 */ - 0x0000, /* R9583 */ - 0x0000, /* R9584 */ - 0x0000, /* R9585 */ - 0x0000, /* R9586 */ - 0x0000, /* R9587 */ - 0x0000, /* R9588 */ - 0x0000, /* R9589 */ - 0x0000, /* R9590 */ - 0x0000, /* R9591 */ - 0x0000, /* R9592 */ - 0x0000, /* R9593 */ - 0x0000, /* R9594 */ - 0x0000, /* R9595 */ - 0x0000, /* R9596 */ - 0x0000, /* R9597 */ - 0x0000, /* R9598 */ - 0x0000, /* R9599 */ - 0x0000, /* R9600 */ - 0x0000, /* R9601 */ - 0x0000, /* R9602 */ - 0x0000, /* R9603 */ - 0x0000, /* R9604 */ - 0x0000, /* R9605 */ - 0x0000, /* R9606 */ - 0x0000, /* R9607 */ - 0x0000, /* R9608 */ - 0x0000, /* R9609 */ - 0x0000, /* R9610 */ - 0x0000, /* R9611 */ - 0x0000, /* R9612 */ - 0x0000, /* R9613 */ - 0x0000, /* R9614 */ - 0x0000, /* R9615 */ - 0x0000, /* R9616 */ - 0x0000, /* R9617 */ - 0x0000, /* R9618 */ - 0x0000, /* R9619 */ - 0x0000, /* R9620 */ - 0x0000, /* R9621 */ - 0x0000, /* R9622 */ - 0x0000, /* R9623 */ - 0x0000, /* R9624 */ - 0x0000, /* R9625 */ - 0x0000, /* R9626 */ - 0x0000, /* R9627 */ - 0x0000, /* R9628 */ - 0x0000, /* R9629 */ - 0x0000, /* R9630 */ - 0x0000, /* R9631 */ - 0x0000, /* R9632 */ - 0x0000, /* R9633 */ - 0x0000, /* R9634 */ - 0x0000, /* R9635 */ - 0x0000, /* R9636 */ - 0x0000, /* R9637 */ - 0x0000, /* R9638 */ - 0x0000, /* R9639 */ - 0x0000, /* R9640 */ - 0x0000, /* R9641 */ - 0x0000, /* R9642 */ - 0x0000, /* R9643 */ - 0x0000, /* R9644 */ - 0x0000, /* R9645 */ - 0x0000, /* R9646 */ - 0x0000, /* R9647 */ - 0x0000, /* R9648 */ - 0x0000, /* R9649 */ - 0x0000, /* R9650 */ - 0x0000, /* R9651 */ - 0x0000, /* R9652 */ - 0x0000, /* R9653 */ - 0x0000, /* R9654 */ - 0x0000, /* R9655 */ - 0x0000, /* R9656 */ - 0x0000, /* R9657 */ - 0x0000, /* R9658 */ - 0x0000, /* R9659 */ - 0x0000, /* R9660 */ - 0x0000, /* R9661 */ - 0x0000, /* R9662 */ - 0x0000, /* R9663 */ - 0x0000, /* R9664 */ - 0x0000, /* R9665 */ - 0x0000, /* R9666 */ - 0x0000, /* R9667 */ - 0x0000, /* R9668 */ - 0x0000, /* R9669 */ - 0x0000, /* R9670 */ - 0x0000, /* R9671 */ - 0x0000, /* R9672 */ - 0x0000, /* R9673 */ - 0x0000, /* R9674 */ - 0x0000, /* R9675 */ - 0x0000, /* R9676 */ - 0x0000, /* R9677 */ - 0x0000, /* R9678 */ - 0x0000, /* R9679 */ - 0x0000, /* R9680 */ - 0x0000, /* R9681 */ - 0x0000, /* R9682 */ - 0x0000, /* R9683 */ - 0x0000, /* R9684 */ - 0x0000, /* R9685 */ - 0x0000, /* R9686 */ - 0x0000, /* R9687 */ - 0x0000, /* R9688 */ - 0x0000, /* R9689 */ - 0x0000, /* R9690 */ - 0x0000, /* R9691 */ - 0x0000, /* R9692 */ - 0x0000, /* R9693 */ - 0x0000, /* R9694 */ - 0x0000, /* R9695 */ - 0x0000, /* R9696 */ - 0x0000, /* R9697 */ - 0x0000, /* R9698 */ - 0x0000, /* R9699 */ - 0x0000, /* R9700 */ - 0x0000, /* R9701 */ - 0x0000, /* R9702 */ - 0x0000, /* R9703 */ - 0x0000, /* R9704 */ - 0x0000, /* R9705 */ - 0x0000, /* R9706 */ - 0x0000, /* R9707 */ - 0x0000, /* R9708 */ - 0x0000, /* R9709 */ - 0x0000, /* R9710 */ - 0x0000, /* R9711 */ - 0x0000, /* R9712 */ - 0x0000, /* R9713 */ - 0x0000, /* R9714 */ - 0x0000, /* R9715 */ - 0x0000, /* R9716 */ - 0x0000, /* R9717 */ - 0x0000, /* R9718 */ - 0x0000, /* R9719 */ - 0x0000, /* R9720 */ - 0x0000, /* R9721 */ - 0x0000, /* R9722 */ - 0x0000, /* R9723 */ - 0x0000, /* R9724 */ - 0x0000, /* R9725 */ - 0x0000, /* R9726 */ - 0x0000, /* R9727 */ - 0x0000, /* R9728 */ - 0x0000, /* R9729 */ - 0x0000, /* R9730 */ - 0x0000, /* R9731 */ - 0x0000, /* R9732 */ - 0x0000, /* R9733 */ - 0x0000, /* R9734 */ - 0x0000, /* R9735 */ - 0x0000, /* R9736 */ - 0x0000, /* R9737 */ - 0x0000, /* R9738 */ - 0x0000, /* R9739 */ - 0x0000, /* R9740 */ - 0x0000, /* R9741 */ - 0x0000, /* R9742 */ - 0x0000, /* R9743 */ - 0x0000, /* R9744 */ - 0x0000, /* R9745 */ - 0x0000, /* R9746 */ - 0x0000, /* R9747 */ - 0x0000, /* R9748 */ - 0x0000, /* R9749 */ - 0x0000, /* R9750 */ - 0x0000, /* R9751 */ - 0x0000, /* R9752 */ - 0x0000, /* R9753 */ - 0x0000, /* R9754 */ - 0x0000, /* R9755 */ - 0x0000, /* R9756 */ - 0x0000, /* R9757 */ - 0x0000, /* R9758 */ - 0x0000, /* R9759 */ - 0x0000, /* R9760 */ - 0x0000, /* R9761 */ - 0x0000, /* R9762 */ - 0x0000, /* R9763 */ - 0x0000, /* R9764 */ - 0x0000, /* R9765 */ - 0x0000, /* R9766 */ - 0x0000, /* R9767 */ - 0x0000, /* R9768 */ - 0x0000, /* R9769 */ - 0x0000, /* R9770 */ - 0x0000, /* R9771 */ - 0x0000, /* R9772 */ - 0x0000, /* R9773 */ - 0x0000, /* R9774 */ - 0x0000, /* R9775 */ - 0x0000, /* R9776 */ - 0x0000, /* R9777 */ - 0x0000, /* R9778 */ - 0x0000, /* R9779 */ - 0x0000, /* R9780 */ - 0x0000, /* R9781 */ - 0x0000, /* R9782 */ - 0x0000, /* R9783 */ - 0x0000, /* R9784 */ - 0x0000, /* R9785 */ - 0x0000, /* R9786 */ - 0x0000, /* R9787 */ - 0x0000, /* R9788 */ - 0x0000, /* R9789 */ - 0x0000, /* R9790 */ - 0x0000, /* R9791 */ - 0x0000, /* R9792 */ - 0x0000, /* R9793 */ - 0x0000, /* R9794 */ - 0x0000, /* R9795 */ - 0x0000, /* R9796 */ - 0x0000, /* R9797 */ - 0x0000, /* R9798 */ - 0x0000, /* R9799 */ - 0x0000, /* R9800 */ - 0x0000, /* R9801 */ - 0x0000, /* R9802 */ - 0x0000, /* R9803 */ - 0x0000, /* R9804 */ - 0x0000, /* R9805 */ - 0x0000, /* R9806 */ - 0x0000, /* R9807 */ - 0x0000, /* R9808 */ - 0x0000, /* R9809 */ - 0x0000, /* R9810 */ - 0x0000, /* R9811 */ - 0x0000, /* R9812 */ - 0x0000, /* R9813 */ - 0x0000, /* R9814 */ - 0x0000, /* R9815 */ - 0x0000, /* R9816 */ - 0x0000, /* R9817 */ - 0x0000, /* R9818 */ - 0x0000, /* R9819 */ - 0x0000, /* R9820 */ - 0x0000, /* R9821 */ - 0x0000, /* R9822 */ - 0x0000, /* R9823 */ - 0x0000, /* R9824 */ - 0x0000, /* R9825 */ - 0x0000, /* R9826 */ - 0x0000, /* R9827 */ - 0x0000, /* R9828 */ - 0x0000, /* R9829 */ - 0x0000, /* R9830 */ - 0x0000, /* R9831 */ - 0x0000, /* R9832 */ - 0x0000, /* R9833 */ - 0x0000, /* R9834 */ - 0x0000, /* R9835 */ - 0x0000, /* R9836 */ - 0x0000, /* R9837 */ - 0x0000, /* R9838 */ - 0x0000, /* R9839 */ - 0x0000, /* R9840 */ - 0x0000, /* R9841 */ - 0x0000, /* R9842 */ - 0x0000, /* R9843 */ - 0x0000, /* R9844 */ - 0x0000, /* R9845 */ - 0x0000, /* R9846 */ - 0x0000, /* R9847 */ - 0x0000, /* R9848 */ - 0x0000, /* R9849 */ - 0x0000, /* R9850 */ - 0x0000, /* R9851 */ - 0x0000, /* R9852 */ - 0x0000, /* R9853 */ - 0x0000, /* R9854 */ - 0x0000, /* R9855 */ - 0x0000, /* R9856 */ - 0x0000, /* R9857 */ - 0x0000, /* R9858 */ - 0x0000, /* R9859 */ - 0x0000, /* R9860 */ - 0x0000, /* R9861 */ - 0x0000, /* R9862 */ - 0x0000, /* R9863 */ - 0x0000, /* R9864 */ - 0x0000, /* R9865 */ - 0x0000, /* R9866 */ - 0x0000, /* R9867 */ - 0x0000, /* R9868 */ - 0x0000, /* R9869 */ - 0x0000, /* R9870 */ - 0x0000, /* R9871 */ - 0x0000, /* R9872 */ - 0x0000, /* R9873 */ - 0x0000, /* R9874 */ - 0x0000, /* R9875 */ - 0x0000, /* R9876 */ - 0x0000, /* R9877 */ - 0x0000, /* R9878 */ - 0x0000, /* R9879 */ - 0x0000, /* R9880 */ - 0x0000, /* R9881 */ - 0x0000, /* R9882 */ - 0x0000, /* R9883 */ - 0x0000, /* R9884 */ - 0x0000, /* R9885 */ - 0x0000, /* R9886 */ - 0x0000, /* R9887 */ - 0x0000, /* R9888 */ - 0x0000, /* R9889 */ - 0x0000, /* R9890 */ - 0x0000, /* R9891 */ - 0x0000, /* R9892 */ - 0x0000, /* R9893 */ - 0x0000, /* R9894 */ - 0x0000, /* R9895 */ - 0x0000, /* R9896 */ - 0x0000, /* R9897 */ - 0x0000, /* R9898 */ - 0x0000, /* R9899 */ - 0x0000, /* R9900 */ - 0x0000, /* R9901 */ - 0x0000, /* R9902 */ - 0x0000, /* R9903 */ - 0x0000, /* R9904 */ - 0x0000, /* R9905 */ - 0x0000, /* R9906 */ - 0x0000, /* R9907 */ - 0x0000, /* R9908 */ - 0x0000, /* R9909 */ - 0x0000, /* R9910 */ - 0x0000, /* R9911 */ - 0x0000, /* R9912 */ - 0x0000, /* R9913 */ - 0x0000, /* R9914 */ - 0x0000, /* R9915 */ - 0x0000, /* R9916 */ - 0x0000, /* R9917 */ - 0x0000, /* R9918 */ - 0x0000, /* R9919 */ - 0x0000, /* R9920 */ - 0x0000, /* R9921 */ - 0x0000, /* R9922 */ - 0x0000, /* R9923 */ - 0x0000, /* R9924 */ - 0x0000, /* R9925 */ - 0x0000, /* R9926 */ - 0x0000, /* R9927 */ - 0x0000, /* R9928 */ - 0x0000, /* R9929 */ - 0x0000, /* R9930 */ - 0x0000, /* R9931 */ - 0x0000, /* R9932 */ - 0x0000, /* R9933 */ - 0x0000, /* R9934 */ - 0x0000, /* R9935 */ - 0x0000, /* R9936 */ - 0x0000, /* R9937 */ - 0x0000, /* R9938 */ - 0x0000, /* R9939 */ - 0x0000, /* R9940 */ - 0x0000, /* R9941 */ - 0x0000, /* R9942 */ - 0x0000, /* R9943 */ - 0x0000, /* R9944 */ - 0x0000, /* R9945 */ - 0x0000, /* R9946 */ - 0x0000, /* R9947 */ - 0x0000, /* R9948 */ - 0x0000, /* R9949 */ - 0x0000, /* R9950 */ - 0x0000, /* R9951 */ - 0x0000, /* R9952 */ - 0x0000, /* R9953 */ - 0x0000, /* R9954 */ - 0x0000, /* R9955 */ - 0x0000, /* R9956 */ - 0x0000, /* R9957 */ - 0x0000, /* R9958 */ - 0x0000, /* R9959 */ - 0x0000, /* R9960 */ - 0x0000, /* R9961 */ - 0x0000, /* R9962 */ - 0x0000, /* R9963 */ - 0x0000, /* R9964 */ - 0x0000, /* R9965 */ - 0x0000, /* R9966 */ - 0x0000, /* R9967 */ - 0x0000, /* R9968 */ - 0x0000, /* R9969 */ - 0x0000, /* R9970 */ - 0x0000, /* R9971 */ - 0x0000, /* R9972 */ - 0x0000, /* R9973 */ - 0x0000, /* R9974 */ - 0x0000, /* R9975 */ - 0x0000, /* R9976 */ - 0x0000, /* R9977 */ - 0x0000, /* R9978 */ - 0x0000, /* R9979 */ - 0x0000, /* R9980 */ - 0x0000, /* R9981 */ - 0x0000, /* R9982 */ - 0x0000, /* R9983 */ - 0x0000, /* R9984 */ - 0x0000, /* R9985 */ - 0x0000, /* R9986 */ - 0x0000, /* R9987 */ - 0x0000, /* R9988 */ - 0x0000, /* R9989 */ - 0x0000, /* R9990 */ - 0x0000, /* R9991 */ - 0x0000, /* R9992 */ - 0x0000, /* R9993 */ - 0x0000, /* R9994 */ - 0x0000, /* R9995 */ - 0x0000, /* R9996 */ - 0x0000, /* R9997 */ - 0x0000, /* R9998 */ - 0x0000, /* R9999 */ - 0x0000, /* R10000 */ - 0x0000, /* R10001 */ - 0x0000, /* R10002 */ - 0x0000, /* R10003 */ - 0x0000, /* R10004 */ - 0x0000, /* R10005 */ - 0x0000, /* R10006 */ - 0x0000, /* R10007 */ - 0x0000, /* R10008 */ - 0x0000, /* R10009 */ - 0x0000, /* R10010 */ - 0x0000, /* R10011 */ - 0x0000, /* R10012 */ - 0x0000, /* R10013 */ - 0x0000, /* R10014 */ - 0x0000, /* R10015 */ - 0x0000, /* R10016 */ - 0x0000, /* R10017 */ - 0x0000, /* R10018 */ - 0x0000, /* R10019 */ - 0x0000, /* R10020 */ - 0x0000, /* R10021 */ - 0x0000, /* R10022 */ - 0x0000, /* R10023 */ - 0x0000, /* R10024 */ - 0x0000, /* R10025 */ - 0x0000, /* R10026 */ - 0x0000, /* R10027 */ - 0x0000, /* R10028 */ - 0x0000, /* R10029 */ - 0x0000, /* R10030 */ - 0x0000, /* R10031 */ - 0x0000, /* R10032 */ - 0x0000, /* R10033 */ - 0x0000, /* R10034 */ - 0x0000, /* R10035 */ - 0x0000, /* R10036 */ - 0x0000, /* R10037 */ - 0x0000, /* R10038 */ - 0x0000, /* R10039 */ - 0x0000, /* R10040 */ - 0x0000, /* R10041 */ - 0x0000, /* R10042 */ - 0x0000, /* R10043 */ - 0x0000, /* R10044 */ - 0x0000, /* R10045 */ - 0x0000, /* R10046 */ - 0x0000, /* R10047 */ - 0x0000, /* R10048 */ - 0x0000, /* R10049 */ - 0x0000, /* R10050 */ - 0x0000, /* R10051 */ - 0x0000, /* R10052 */ - 0x0000, /* R10053 */ - 0x0000, /* R10054 */ - 0x0000, /* R10055 */ - 0x0000, /* R10056 */ - 0x0000, /* R10057 */ - 0x0000, /* R10058 */ - 0x0000, /* R10059 */ - 0x0000, /* R10060 */ - 0x0000, /* R10061 */ - 0x0000, /* R10062 */ - 0x0000, /* R10063 */ - 0x0000, /* R10064 */ - 0x0000, /* R10065 */ - 0x0000, /* R10066 */ - 0x0000, /* R10067 */ - 0x0000, /* R10068 */ - 0x0000, /* R10069 */ - 0x0000, /* R10070 */ - 0x0000, /* R10071 */ - 0x0000, /* R10072 */ - 0x0000, /* R10073 */ - 0x0000, /* R10074 */ - 0x0000, /* R10075 */ - 0x0000, /* R10076 */ - 0x0000, /* R10077 */ - 0x0000, /* R10078 */ - 0x0000, /* R10079 */ - 0x0000, /* R10080 */ - 0x0000, /* R10081 */ - 0x0000, /* R10082 */ - 0x0000, /* R10083 */ - 0x0000, /* R10084 */ - 0x0000, /* R10085 */ - 0x0000, /* R10086 */ - 0x0000, /* R10087 */ - 0x0000, /* R10088 */ - 0x0000, /* R10089 */ - 0x0000, /* R10090 */ - 0x0000, /* R10091 */ - 0x0000, /* R10092 */ - 0x0000, /* R10093 */ - 0x0000, /* R10094 */ - 0x0000, /* R10095 */ - 0x0000, /* R10096 */ - 0x0000, /* R10097 */ - 0x0000, /* R10098 */ - 0x0000, /* R10099 */ - 0x0000, /* R10100 */ - 0x0000, /* R10101 */ - 0x0000, /* R10102 */ - 0x0000, /* R10103 */ - 0x0000, /* R10104 */ - 0x0000, /* R10105 */ - 0x0000, /* R10106 */ - 0x0000, /* R10107 */ - 0x0000, /* R10108 */ - 0x0000, /* R10109 */ - 0x0000, /* R10110 */ - 0x0000, /* R10111 */ - 0x0000, /* R10112 */ - 0x0000, /* R10113 */ - 0x0000, /* R10114 */ - 0x0000, /* R10115 */ - 0x0000, /* R10116 */ - 0x0000, /* R10117 */ - 0x0000, /* R10118 */ - 0x0000, /* R10119 */ - 0x0000, /* R10120 */ - 0x0000, /* R10121 */ - 0x0000, /* R10122 */ - 0x0000, /* R10123 */ - 0x0000, /* R10124 */ - 0x0000, /* R10125 */ - 0x0000, /* R10126 */ - 0x0000, /* R10127 */ - 0x0000, /* R10128 */ - 0x0000, /* R10129 */ - 0x0000, /* R10130 */ - 0x0000, /* R10131 */ - 0x0000, /* R10132 */ - 0x0000, /* R10133 */ - 0x0000, /* R10134 */ - 0x0000, /* R10135 */ - 0x0000, /* R10136 */ - 0x0000, /* R10137 */ - 0x0000, /* R10138 */ - 0x0000, /* R10139 */ - 0x0000, /* R10140 */ - 0x0000, /* R10141 */ - 0x0000, /* R10142 */ - 0x0000, /* R10143 */ - 0x0000, /* R10144 */ - 0x0000, /* R10145 */ - 0x0000, /* R10146 */ - 0x0000, /* R10147 */ - 0x0000, /* R10148 */ - 0x0000, /* R10149 */ - 0x0000, /* R10150 */ - 0x0000, /* R10151 */ - 0x0000, /* R10152 */ - 0x0000, /* R10153 */ - 0x0000, /* R10154 */ - 0x0000, /* R10155 */ - 0x0000, /* R10156 */ - 0x0000, /* R10157 */ - 0x0000, /* R10158 */ - 0x0000, /* R10159 */ - 0x0000, /* R10160 */ - 0x0000, /* R10161 */ - 0x0000, /* R10162 */ - 0x0000, /* R10163 */ - 0x0000, /* R10164 */ - 0x0000, /* R10165 */ - 0x0000, /* R10166 */ - 0x0000, /* R10167 */ - 0x0000, /* R10168 */ - 0x0000, /* R10169 */ - 0x0000, /* R10170 */ - 0x0000, /* R10171 */ - 0x0000, /* R10172 */ - 0x0000, /* R10173 */ - 0x0000, /* R10174 */ - 0x0000, /* R10175 */ - 0x0000, /* R10176 */ - 0x0000, /* R10177 */ - 0x0000, /* R10178 */ - 0x0000, /* R10179 */ - 0x0000, /* R10180 */ - 0x0000, /* R10181 */ - 0x0000, /* R10182 */ - 0x0000, /* R10183 */ - 0x0000, /* R10184 */ - 0x0000, /* R10185 */ - 0x0000, /* R10186 */ - 0x0000, /* R10187 */ - 0x0000, /* R10188 */ - 0x0000, /* R10189 */ - 0x0000, /* R10190 */ - 0x0000, /* R10191 */ - 0x0000, /* R10192 */ - 0x0000, /* R10193 */ - 0x0000, /* R10194 */ - 0x0000, /* R10195 */ - 0x0000, /* R10196 */ - 0x0000, /* R10197 */ - 0x0000, /* R10198 */ - 0x0000, /* R10199 */ - 0x0000, /* R10200 */ - 0x0000, /* R10201 */ - 0x0000, /* R10202 */ - 0x0000, /* R10203 */ - 0x0000, /* R10204 */ - 0x0000, /* R10205 */ - 0x0000, /* R10206 */ - 0x0000, /* R10207 */ - 0x0000, /* R10208 */ - 0x0000, /* R10209 */ - 0x0000, /* R10210 */ - 0x0000, /* R10211 */ - 0x0000, /* R10212 */ - 0x0000, /* R10213 */ - 0x0000, /* R10214 */ - 0x0000, /* R10215 */ - 0x0000, /* R10216 */ - 0x0000, /* R10217 */ - 0x0000, /* R10218 */ - 0x0000, /* R10219 */ - 0x0000, /* R10220 */ - 0x0000, /* R10221 */ - 0x0000, /* R10222 */ - 0x0000, /* R10223 */ - 0x0000, /* R10224 */ - 0x0000, /* R10225 */ - 0x0000, /* R10226 */ - 0x0000, /* R10227 */ - 0x0000, /* R10228 */ - 0x0000, /* R10229 */ - 0x0000, /* R10230 */ - 0x0000, /* R10231 */ - 0x0000, /* R10232 */ - 0x0000, /* R10233 */ - 0x0000, /* R10234 */ - 0x0000, /* R10235 */ - 0x0000, /* R10236 */ - 0x0000, /* R10237 */ - 0x0000, /* R10238 */ - 0x0000, /* R10239 */ - 0x0000, /* R10240 */ - 0x0000, /* R10241 */ - 0x0000, /* R10242 */ - 0x0000, /* R10243 */ - 0x0000, /* R10244 */ - 0x0000, /* R10245 */ - 0x0000, /* R10246 */ - 0x0000, /* R10247 */ - 0x0000, /* R10248 */ - 0x0000, /* R10249 */ - 0x0000, /* R10250 */ - 0x0000, /* R10251 */ - 0x0000, /* R10252 */ - 0x0000, /* R10253 */ - 0x0000, /* R10254 */ - 0x0000, /* R10255 */ - 0x0000, /* R10256 */ - 0x0000, /* R10257 */ - 0x0000, /* R10258 */ - 0x0000, /* R10259 */ - 0x0000, /* R10260 */ - 0x0000, /* R10261 */ - 0x0000, /* R10262 */ - 0x0000, /* R10263 */ - 0x0000, /* R10264 */ - 0x0000, /* R10265 */ - 0x0000, /* R10266 */ - 0x0000, /* R10267 */ - 0x0000, /* R10268 */ - 0x0000, /* R10269 */ - 0x0000, /* R10270 */ - 0x0000, /* R10271 */ - 0x0000, /* R10272 */ - 0x0000, /* R10273 */ - 0x0000, /* R10274 */ - 0x0000, /* R10275 */ - 0x0000, /* R10276 */ - 0x0000, /* R10277 */ - 0x0000, /* R10278 */ - 0x0000, /* R10279 */ - 0x0000, /* R10280 */ - 0x0000, /* R10281 */ - 0x0000, /* R10282 */ - 0x0000, /* R10283 */ - 0x0000, /* R10284 */ - 0x0000, /* R10285 */ - 0x0000, /* R10286 */ - 0x0000, /* R10287 */ - 0x0000, /* R10288 */ - 0x0000, /* R10289 */ - 0x0000, /* R10290 */ - 0x0000, /* R10291 */ - 0x0000, /* R10292 */ - 0x0000, /* R10293 */ - 0x0000, /* R10294 */ - 0x0000, /* R10295 */ - 0x0000, /* R10296 */ - 0x0000, /* R10297 */ - 0x0000, /* R10298 */ - 0x0000, /* R10299 */ - 0x0000, /* R10300 */ - 0x0000, /* R10301 */ - 0x0000, /* R10302 */ - 0x0000, /* R10303 */ - 0x0000, /* R10304 */ - 0x0000, /* R10305 */ - 0x0000, /* R10306 */ - 0x0000, /* R10307 */ - 0x0000, /* R10308 */ - 0x0000, /* R10309 */ - 0x0000, /* R10310 */ - 0x0000, /* R10311 */ - 0x0000, /* R10312 */ - 0x0000, /* R10313 */ - 0x0000, /* R10314 */ - 0x0000, /* R10315 */ - 0x0000, /* R10316 */ - 0x0000, /* R10317 */ - 0x0000, /* R10318 */ - 0x0000, /* R10319 */ - 0x0000, /* R10320 */ - 0x0000, /* R10321 */ - 0x0000, /* R10322 */ - 0x0000, /* R10323 */ - 0x0000, /* R10324 */ - 0x0000, /* R10325 */ - 0x0000, /* R10326 */ - 0x0000, /* R10327 */ - 0x0000, /* R10328 */ - 0x0000, /* R10329 */ - 0x0000, /* R10330 */ - 0x0000, /* R10331 */ - 0x0000, /* R10332 */ - 0x0000, /* R10333 */ - 0x0000, /* R10334 */ - 0x0000, /* R10335 */ - 0x0000, /* R10336 */ - 0x0000, /* R10337 */ - 0x0000, /* R10338 */ - 0x0000, /* R10339 */ - 0x0000, /* R10340 */ - 0x0000, /* R10341 */ - 0x0000, /* R10342 */ - 0x0000, /* R10343 */ - 0x0000, /* R10344 */ - 0x0000, /* R10345 */ - 0x0000, /* R10346 */ - 0x0000, /* R10347 */ - 0x0000, /* R10348 */ - 0x0000, /* R10349 */ - 0x0000, /* R10350 */ - 0x0000, /* R10351 */ - 0x0000, /* R10352 */ - 0x0000, /* R10353 */ - 0x0000, /* R10354 */ - 0x0000, /* R10355 */ - 0x0000, /* R10356 */ - 0x0000, /* R10357 */ - 0x0000, /* R10358 */ - 0x0000, /* R10359 */ - 0x0000, /* R10360 */ - 0x0000, /* R10361 */ - 0x0000, /* R10362 */ - 0x0000, /* R10363 */ - 0x0000, /* R10364 */ - 0x0000, /* R10365 */ - 0x0000, /* R10366 */ - 0x0000, /* R10367 */ - 0x0000, /* R10368 */ - 0x0000, /* R10369 */ - 0x0000, /* R10370 */ - 0x0000, /* R10371 */ - 0x0000, /* R10372 */ - 0x0000, /* R10373 */ - 0x0000, /* R10374 */ - 0x0000, /* R10375 */ - 0x0000, /* R10376 */ - 0x0000, /* R10377 */ - 0x0000, /* R10378 */ - 0x0000, /* R10379 */ - 0x0000, /* R10380 */ - 0x0000, /* R10381 */ - 0x0000, /* R10382 */ - 0x0000, /* R10383 */ - 0x0000, /* R10384 */ - 0x0000, /* R10385 */ - 0x0000, /* R10386 */ - 0x0000, /* R10387 */ - 0x0000, /* R10388 */ - 0x0000, /* R10389 */ - 0x0000, /* R10390 */ - 0x0000, /* R10391 */ - 0x0000, /* R10392 */ - 0x0000, /* R10393 */ - 0x0000, /* R10394 */ - 0x0000, /* R10395 */ - 0x0000, /* R10396 */ - 0x0000, /* R10397 */ - 0x0000, /* R10398 */ - 0x0000, /* R10399 */ - 0x0000, /* R10400 */ - 0x0000, /* R10401 */ - 0x0000, /* R10402 */ - 0x0000, /* R10403 */ - 0x0000, /* R10404 */ - 0x0000, /* R10405 */ - 0x0000, /* R10406 */ - 0x0000, /* R10407 */ - 0x0000, /* R10408 */ - 0x0000, /* R10409 */ - 0x0000, /* R10410 */ - 0x0000, /* R10411 */ - 0x0000, /* R10412 */ - 0x0000, /* R10413 */ - 0x0000, /* R10414 */ - 0x0000, /* R10415 */ - 0x0000, /* R10416 */ - 0x0000, /* R10417 */ - 0x0000, /* R10418 */ - 0x0000, /* R10419 */ - 0x0000, /* R10420 */ - 0x0000, /* R10421 */ - 0x0000, /* R10422 */ - 0x0000, /* R10423 */ - 0x0000, /* R10424 */ - 0x0000, /* R10425 */ - 0x0000, /* R10426 */ - 0x0000, /* R10427 */ - 0x0000, /* R10428 */ - 0x0000, /* R10429 */ - 0x0000, /* R10430 */ - 0x0000, /* R10431 */ - 0x0000, /* R10432 */ - 0x0000, /* R10433 */ - 0x0000, /* R10434 */ - 0x0000, /* R10435 */ - 0x0000, /* R10436 */ - 0x0000, /* R10437 */ - 0x0000, /* R10438 */ - 0x0000, /* R10439 */ - 0x0000, /* R10440 */ - 0x0000, /* R10441 */ - 0x0000, /* R10442 */ - 0x0000, /* R10443 */ - 0x0000, /* R10444 */ - 0x0000, /* R10445 */ - 0x0000, /* R10446 */ - 0x0000, /* R10447 */ - 0x0000, /* R10448 */ - 0x0000, /* R10449 */ - 0x0000, /* R10450 */ - 0x0000, /* R10451 */ - 0x0000, /* R10452 */ - 0x0000, /* R10453 */ - 0x0000, /* R10454 */ - 0x0000, /* R10455 */ - 0x0000, /* R10456 */ - 0x0000, /* R10457 */ - 0x0000, /* R10458 */ - 0x0000, /* R10459 */ - 0x0000, /* R10460 */ - 0x0000, /* R10461 */ - 0x0000, /* R10462 */ - 0x0000, /* R10463 */ - 0x0000, /* R10464 */ - 0x0000, /* R10465 */ - 0x0000, /* R10466 */ - 0x0000, /* R10467 */ - 0x0000, /* R10468 */ - 0x0000, /* R10469 */ - 0x0000, /* R10470 */ - 0x0000, /* R10471 */ - 0x0000, /* R10472 */ - 0x0000, /* R10473 */ - 0x0000, /* R10474 */ - 0x0000, /* R10475 */ - 0x0000, /* R10476 */ - 0x0000, /* R10477 */ - 0x0000, /* R10478 */ - 0x0000, /* R10479 */ - 0x0000, /* R10480 */ - 0x0000, /* R10481 */ - 0x0000, /* R10482 */ - 0x0000, /* R10483 */ - 0x0000, /* R10484 */ - 0x0000, /* R10485 */ - 0x0000, /* R10486 */ - 0x0000, /* R10487 */ - 0x0000, /* R10488 */ - 0x0000, /* R10489 */ - 0x0000, /* R10490 */ - 0x0000, /* R10491 */ - 0x0000, /* R10492 */ - 0x0000, /* R10493 */ - 0x0000, /* R10494 */ - 0x0000, /* R10495 */ - 0x0000, /* R10496 */ - 0x0000, /* R10497 */ - 0x0000, /* R10498 */ - 0x0000, /* R10499 */ - 0x0000, /* R10500 */ - 0x0000, /* R10501 */ - 0x0000, /* R10502 */ - 0x0000, /* R10503 */ - 0x0000, /* R10504 */ - 0x0000, /* R10505 */ - 0x0000, /* R10506 */ - 0x0000, /* R10507 */ - 0x0000, /* R10508 */ - 0x0000, /* R10509 */ - 0x0000, /* R10510 */ - 0x0000, /* R10511 */ - 0x0000, /* R10512 */ - 0x0000, /* R10513 */ - 0x0000, /* R10514 */ - 0x0000, /* R10515 */ - 0x0000, /* R10516 */ - 0x0000, /* R10517 */ - 0x0000, /* R10518 */ - 0x0000, /* R10519 */ - 0x0000, /* R10520 */ - 0x0000, /* R10521 */ - 0x0000, /* R10522 */ - 0x0000, /* R10523 */ - 0x0000, /* R10524 */ - 0x0000, /* R10525 */ - 0x0000, /* R10526 */ - 0x0000, /* R10527 */ - 0x0000, /* R10528 */ - 0x0000, /* R10529 */ - 0x0000, /* R10530 */ - 0x0000, /* R10531 */ - 0x0000, /* R10532 */ - 0x0000, /* R10533 */ - 0x0000, /* R10534 */ - 0x0000, /* R10535 */ - 0x0000, /* R10536 */ - 0x0000, /* R10537 */ - 0x0000, /* R10538 */ - 0x0000, /* R10539 */ - 0x0000, /* R10540 */ - 0x0000, /* R10541 */ - 0x0000, /* R10542 */ - 0x0000, /* R10543 */ - 0x0000, /* R10544 */ - 0x0000, /* R10545 */ - 0x0000, /* R10546 */ - 0x0000, /* R10547 */ - 0x0000, /* R10548 */ - 0x0000, /* R10549 */ - 0x0000, /* R10550 */ - 0x0000, /* R10551 */ - 0x0000, /* R10552 */ - 0x0000, /* R10553 */ - 0x0000, /* R10554 */ - 0x0000, /* R10555 */ - 0x0000, /* R10556 */ - 0x0000, /* R10557 */ - 0x0000, /* R10558 */ - 0x0000, /* R10559 */ - 0x0000, /* R10560 */ - 0x0000, /* R10561 */ - 0x0000, /* R10562 */ - 0x0000, /* R10563 */ - 0x0000, /* R10564 */ - 0x0000, /* R10565 */ - 0x0000, /* R10566 */ - 0x0000, /* R10567 */ - 0x0000, /* R10568 */ - 0x0000, /* R10569 */ - 0x0000, /* R10570 */ - 0x0000, /* R10571 */ - 0x0000, /* R10572 */ - 0x0000, /* R10573 */ - 0x0000, /* R10574 */ - 0x0000, /* R10575 */ - 0x0000, /* R10576 */ - 0x0000, /* R10577 */ - 0x0000, /* R10578 */ - 0x0000, /* R10579 */ - 0x0000, /* R10580 */ - 0x0000, /* R10581 */ - 0x0000, /* R10582 */ - 0x0000, /* R10583 */ - 0x0000, /* R10584 */ - 0x0000, /* R10585 */ - 0x0000, /* R10586 */ - 0x0000, /* R10587 */ - 0x0000, /* R10588 */ - 0x0000, /* R10589 */ - 0x0000, /* R10590 */ - 0x0000, /* R10591 */ - 0x0000, /* R10592 */ - 0x0000, /* R10593 */ - 0x0000, /* R10594 */ - 0x0000, /* R10595 */ - 0x0000, /* R10596 */ - 0x0000, /* R10597 */ - 0x0000, /* R10598 */ - 0x0000, /* R10599 */ - 0x0000, /* R10600 */ - 0x0000, /* R10601 */ - 0x0000, /* R10602 */ - 0x0000, /* R10603 */ - 0x0000, /* R10604 */ - 0x0000, /* R10605 */ - 0x0000, /* R10606 */ - 0x0000, /* R10607 */ - 0x0000, /* R10608 */ - 0x0000, /* R10609 */ - 0x0000, /* R10610 */ - 0x0000, /* R10611 */ - 0x0000, /* R10612 */ - 0x0000, /* R10613 */ - 0x0000, /* R10614 */ - 0x0000, /* R10615 */ - 0x0000, /* R10616 */ - 0x0000, /* R10617 */ - 0x0000, /* R10618 */ - 0x0000, /* R10619 */ - 0x0000, /* R10620 */ - 0x0000, /* R10621 */ - 0x0000, /* R10622 */ - 0x0000, /* R10623 */ - 0x0000, /* R10624 */ - 0x0000, /* R10625 */ - 0x0000, /* R10626 */ - 0x0000, /* R10627 */ - 0x0000, /* R10628 */ - 0x0000, /* R10629 */ - 0x0000, /* R10630 */ - 0x0000, /* R10631 */ - 0x0000, /* R10632 */ - 0x0000, /* R10633 */ - 0x0000, /* R10634 */ - 0x0000, /* R10635 */ - 0x0000, /* R10636 */ - 0x0000, /* R10637 */ - 0x0000, /* R10638 */ - 0x0000, /* R10639 */ - 0x0000, /* R10640 */ - 0x0000, /* R10641 */ - 0x0000, /* R10642 */ - 0x0000, /* R10643 */ - 0x0000, /* R10644 */ - 0x0000, /* R10645 */ - 0x0000, /* R10646 */ - 0x0000, /* R10647 */ - 0x0000, /* R10648 */ - 0x0000, /* R10649 */ - 0x0000, /* R10650 */ - 0x0000, /* R10651 */ - 0x0000, /* R10652 */ - 0x0000, /* R10653 */ - 0x0000, /* R10654 */ - 0x0000, /* R10655 */ - 0x0000, /* R10656 */ - 0x0000, /* R10657 */ - 0x0000, /* R10658 */ - 0x0000, /* R10659 */ - 0x0000, /* R10660 */ - 0x0000, /* R10661 */ - 0x0000, /* R10662 */ - 0x0000, /* R10663 */ - 0x0000, /* R10664 */ - 0x0000, /* R10665 */ - 0x0000, /* R10666 */ - 0x0000, /* R10667 */ - 0x0000, /* R10668 */ - 0x0000, /* R10669 */ - 0x0000, /* R10670 */ - 0x0000, /* R10671 */ - 0x0000, /* R10672 */ - 0x0000, /* R10673 */ - 0x0000, /* R10674 */ - 0x0000, /* R10675 */ - 0x0000, /* R10676 */ - 0x0000, /* R10677 */ - 0x0000, /* R10678 */ - 0x0000, /* R10679 */ - 0x0000, /* R10680 */ - 0x0000, /* R10681 */ - 0x0000, /* R10682 */ - 0x0000, /* R10683 */ - 0x0000, /* R10684 */ - 0x0000, /* R10685 */ - 0x0000, /* R10686 */ - 0x0000, /* R10687 */ - 0x0000, /* R10688 */ - 0x0000, /* R10689 */ - 0x0000, /* R10690 */ - 0x0000, /* R10691 */ - 0x0000, /* R10692 */ - 0x0000, /* R10693 */ - 0x0000, /* R10694 */ - 0x0000, /* R10695 */ - 0x0000, /* R10696 */ - 0x0000, /* R10697 */ - 0x0000, /* R10698 */ - 0x0000, /* R10699 */ - 0x0000, /* R10700 */ - 0x0000, /* R10701 */ - 0x0000, /* R10702 */ - 0x0000, /* R10703 */ - 0x0000, /* R10704 */ - 0x0000, /* R10705 */ - 0x0000, /* R10706 */ - 0x0000, /* R10707 */ - 0x0000, /* R10708 */ - 0x0000, /* R10709 */ - 0x0000, /* R10710 */ - 0x0000, /* R10711 */ - 0x0000, /* R10712 */ - 0x0000, /* R10713 */ - 0x0000, /* R10714 */ - 0x0000, /* R10715 */ - 0x0000, /* R10716 */ - 0x0000, /* R10717 */ - 0x0000, /* R10718 */ - 0x0000, /* R10719 */ - 0x0000, /* R10720 */ - 0x0000, /* R10721 */ - 0x0000, /* R10722 */ - 0x0000, /* R10723 */ - 0x0000, /* R10724 */ - 0x0000, /* R10725 */ - 0x0000, /* R10726 */ - 0x0000, /* R10727 */ - 0x0000, /* R10728 */ - 0x0000, /* R10729 */ - 0x0000, /* R10730 */ - 0x0000, /* R10731 */ - 0x0000, /* R10732 */ - 0x0000, /* R10733 */ - 0x0000, /* R10734 */ - 0x0000, /* R10735 */ - 0x0000, /* R10736 */ - 0x0000, /* R10737 */ - 0x0000, /* R10738 */ - 0x0000, /* R10739 */ - 0x0000, /* R10740 */ - 0x0000, /* R10741 */ - 0x0000, /* R10742 */ - 0x0000, /* R10743 */ - 0x0000, /* R10744 */ - 0x0000, /* R10745 */ - 0x0000, /* R10746 */ - 0x0000, /* R10747 */ - 0x0000, /* R10748 */ - 0x0000, /* R10749 */ - 0x0000, /* R10750 */ - 0x0000, /* R10751 */ - 0x0000, /* R10752 */ - 0x0000, /* R10753 */ - 0x0000, /* R10754 */ - 0x0000, /* R10755 */ - 0x0000, /* R10756 */ - 0x0000, /* R10757 */ - 0x0000, /* R10758 */ - 0x0000, /* R10759 */ - 0x0000, /* R10760 */ - 0x0000, /* R10761 */ - 0x0000, /* R10762 */ - 0x0000, /* R10763 */ - 0x0000, /* R10764 */ - 0x0000, /* R10765 */ - 0x0000, /* R10766 */ - 0x0000, /* R10767 */ - 0x0000, /* R10768 */ - 0x0000, /* R10769 */ - 0x0000, /* R10770 */ - 0x0000, /* R10771 */ - 0x0000, /* R10772 */ - 0x0000, /* R10773 */ - 0x0000, /* R10774 */ - 0x0000, /* R10775 */ - 0x0000, /* R10776 */ - 0x0000, /* R10777 */ - 0x0000, /* R10778 */ - 0x0000, /* R10779 */ - 0x0000, /* R10780 */ - 0x0000, /* R10781 */ - 0x0000, /* R10782 */ - 0x0000, /* R10783 */ - 0x0000, /* R10784 */ - 0x0000, /* R10785 */ - 0x0000, /* R10786 */ - 0x0000, /* R10787 */ - 0x0000, /* R10788 */ - 0x0000, /* R10789 */ - 0x0000, /* R10790 */ - 0x0000, /* R10791 */ - 0x0000, /* R10792 */ - 0x0000, /* R10793 */ - 0x0000, /* R10794 */ - 0x0000, /* R10795 */ - 0x0000, /* R10796 */ - 0x0000, /* R10797 */ - 0x0000, /* R10798 */ - 0x0000, /* R10799 */ - 0x0000, /* R10800 */ - 0x0000, /* R10801 */ - 0x0000, /* R10802 */ - 0x0000, /* R10803 */ - 0x0000, /* R10804 */ - 0x0000, /* R10805 */ - 0x0000, /* R10806 */ - 0x0000, /* R10807 */ - 0x0000, /* R10808 */ - 0x0000, /* R10809 */ - 0x0000, /* R10810 */ - 0x0000, /* R10811 */ - 0x0000, /* R10812 */ - 0x0000, /* R10813 */ - 0x0000, /* R10814 */ - 0x0000, /* R10815 */ - 0x0000, /* R10816 */ - 0x0000, /* R10817 */ - 0x0000, /* R10818 */ - 0x0000, /* R10819 */ - 0x0000, /* R10820 */ - 0x0000, /* R10821 */ - 0x0000, /* R10822 */ - 0x0000, /* R10823 */ - 0x0000, /* R10824 */ - 0x0000, /* R10825 */ - 0x0000, /* R10826 */ - 0x0000, /* R10827 */ - 0x0000, /* R10828 */ - 0x0000, /* R10829 */ - 0x0000, /* R10830 */ - 0x0000, /* R10831 */ - 0x0000, /* R10832 */ - 0x0000, /* R10833 */ - 0x0000, /* R10834 */ - 0x0000, /* R10835 */ - 0x0000, /* R10836 */ - 0x0000, /* R10837 */ - 0x0000, /* R10838 */ - 0x0000, /* R10839 */ - 0x0000, /* R10840 */ - 0x0000, /* R10841 */ - 0x0000, /* R10842 */ - 0x0000, /* R10843 */ - 0x0000, /* R10844 */ - 0x0000, /* R10845 */ - 0x0000, /* R10846 */ - 0x0000, /* R10847 */ - 0x0000, /* R10848 */ - 0x0000, /* R10849 */ - 0x0000, /* R10850 */ - 0x0000, /* R10851 */ - 0x0000, /* R10852 */ - 0x0000, /* R10853 */ - 0x0000, /* R10854 */ - 0x0000, /* R10855 */ - 0x0000, /* R10856 */ - 0x0000, /* R10857 */ - 0x0000, /* R10858 */ - 0x0000, /* R10859 */ - 0x0000, /* R10860 */ - 0x0000, /* R10861 */ - 0x0000, /* R10862 */ - 0x0000, /* R10863 */ - 0x0000, /* R10864 */ - 0x0000, /* R10865 */ - 0x0000, /* R10866 */ - 0x0000, /* R10867 */ - 0x0000, /* R10868 */ - 0x0000, /* R10869 */ - 0x0000, /* R10870 */ - 0x0000, /* R10871 */ - 0x0000, /* R10872 */ - 0x0000, /* R10873 */ - 0x0000, /* R10874 */ - 0x0000, /* R10875 */ - 0x0000, /* R10876 */ - 0x0000, /* R10877 */ - 0x0000, /* R10878 */ - 0x0000, /* R10879 */ - 0x0000, /* R10880 */ - 0x0000, /* R10881 */ - 0x0000, /* R10882 */ - 0x0000, /* R10883 */ - 0x0000, /* R10884 */ - 0x0000, /* R10885 */ - 0x0000, /* R10886 */ - 0x0000, /* R10887 */ - 0x0000, /* R10888 */ - 0x0000, /* R10889 */ - 0x0000, /* R10890 */ - 0x0000, /* R10891 */ - 0x0000, /* R10892 */ - 0x0000, /* R10893 */ - 0x0000, /* R10894 */ - 0x0000, /* R10895 */ - 0x0000, /* R10896 */ - 0x0000, /* R10897 */ - 0x0000, /* R10898 */ - 0x0000, /* R10899 */ - 0x0000, /* R10900 */ - 0x0000, /* R10901 */ - 0x0000, /* R10902 */ - 0x0000, /* R10903 */ - 0x0000, /* R10904 */ - 0x0000, /* R10905 */ - 0x0000, /* R10906 */ - 0x0000, /* R10907 */ - 0x0000, /* R10908 */ - 0x0000, /* R10909 */ - 0x0000, /* R10910 */ - 0x0000, /* R10911 */ - 0x0000, /* R10912 */ - 0x0000, /* R10913 */ - 0x0000, /* R10914 */ - 0x0000, /* R10915 */ - 0x0000, /* R10916 */ - 0x0000, /* R10917 */ - 0x0000, /* R10918 */ - 0x0000, /* R10919 */ - 0x0000, /* R10920 */ - 0x0000, /* R10921 */ - 0x0000, /* R10922 */ - 0x0000, /* R10923 */ - 0x0000, /* R10924 */ - 0x0000, /* R10925 */ - 0x0000, /* R10926 */ - 0x0000, /* R10927 */ - 0x0000, /* R10928 */ - 0x0000, /* R10929 */ - 0x0000, /* R10930 */ - 0x0000, /* R10931 */ - 0x0000, /* R10932 */ - 0x0000, /* R10933 */ - 0x0000, /* R10934 */ - 0x0000, /* R10935 */ - 0x0000, /* R10936 */ - 0x0000, /* R10937 */ - 0x0000, /* R10938 */ - 0x0000, /* R10939 */ - 0x0000, /* R10940 */ - 0x0000, /* R10941 */ - 0x0000, /* R10942 */ - 0x0000, /* R10943 */ - 0x0000, /* R10944 */ - 0x0000, /* R10945 */ - 0x0000, /* R10946 */ - 0x0000, /* R10947 */ - 0x0000, /* R10948 */ - 0x0000, /* R10949 */ - 0x0000, /* R10950 */ - 0x0000, /* R10951 */ - 0x0000, /* R10952 */ - 0x0000, /* R10953 */ - 0x0000, /* R10954 */ - 0x0000, /* R10955 */ - 0x0000, /* R10956 */ - 0x0000, /* R10957 */ - 0x0000, /* R10958 */ - 0x0000, /* R10959 */ - 0x0000, /* R10960 */ - 0x0000, /* R10961 */ - 0x0000, /* R10962 */ - 0x0000, /* R10963 */ - 0x0000, /* R10964 */ - 0x0000, /* R10965 */ - 0x0000, /* R10966 */ - 0x0000, /* R10967 */ - 0x0000, /* R10968 */ - 0x0000, /* R10969 */ - 0x0000, /* R10970 */ - 0x0000, /* R10971 */ - 0x0000, /* R10972 */ - 0x0000, /* R10973 */ - 0x0000, /* R10974 */ - 0x0000, /* R10975 */ - 0x0000, /* R10976 */ - 0x0000, /* R10977 */ - 0x0000, /* R10978 */ - 0x0000, /* R10979 */ - 0x0000, /* R10980 */ - 0x0000, /* R10981 */ - 0x0000, /* R10982 */ - 0x0000, /* R10983 */ - 0x0000, /* R10984 */ - 0x0000, /* R10985 */ - 0x0000, /* R10986 */ - 0x0000, /* R10987 */ - 0x0000, /* R10988 */ - 0x0000, /* R10989 */ - 0x0000, /* R10990 */ - 0x0000, /* R10991 */ - 0x0000, /* R10992 */ - 0x0000, /* R10993 */ - 0x0000, /* R10994 */ - 0x0000, /* R10995 */ - 0x0000, /* R10996 */ - 0x0000, /* R10997 */ - 0x0000, /* R10998 */ - 0x0000, /* R10999 */ - 0x0000, /* R11000 */ - 0x0000, /* R11001 */ - 0x0000, /* R11002 */ - 0x0000, /* R11003 */ - 0x0000, /* R11004 */ - 0x0000, /* R11005 */ - 0x0000, /* R11006 */ - 0x0000, /* R11007 */ - 0x0000, /* R11008 */ - 0x0000, /* R11009 */ - 0x0000, /* R11010 */ - 0x0000, /* R11011 */ - 0x0000, /* R11012 */ - 0x0000, /* R11013 */ - 0x0000, /* R11014 */ - 0x0000, /* R11015 */ - 0x0000, /* R11016 */ - 0x0000, /* R11017 */ - 0x0000, /* R11018 */ - 0x0000, /* R11019 */ - 0x0000, /* R11020 */ - 0x0000, /* R11021 */ - 0x0000, /* R11022 */ - 0x0000, /* R11023 */ - 0x0000, /* R11024 */ - 0x0000, /* R11025 */ - 0x0000, /* R11026 */ - 0x0000, /* R11027 */ - 0x0000, /* R11028 */ - 0x0000, /* R11029 */ - 0x0000, /* R11030 */ - 0x0000, /* R11031 */ - 0x0000, /* R11032 */ - 0x0000, /* R11033 */ - 0x0000, /* R11034 */ - 0x0000, /* R11035 */ - 0x0000, /* R11036 */ - 0x0000, /* R11037 */ - 0x0000, /* R11038 */ - 0x0000, /* R11039 */ - 0x0000, /* R11040 */ - 0x0000, /* R11041 */ - 0x0000, /* R11042 */ - 0x0000, /* R11043 */ - 0x0000, /* R11044 */ - 0x0000, /* R11045 */ - 0x0000, /* R11046 */ - 0x0000, /* R11047 */ - 0x0000, /* R11048 */ - 0x0000, /* R11049 */ - 0x0000, /* R11050 */ - 0x0000, /* R11051 */ - 0x0000, /* R11052 */ - 0x0000, /* R11053 */ - 0x0000, /* R11054 */ - 0x0000, /* R11055 */ - 0x0000, /* R11056 */ - 0x0000, /* R11057 */ - 0x0000, /* R11058 */ - 0x0000, /* R11059 */ - 0x0000, /* R11060 */ - 0x0000, /* R11061 */ - 0x0000, /* R11062 */ - 0x0000, /* R11063 */ - 0x0000, /* R11064 */ - 0x0000, /* R11065 */ - 0x0000, /* R11066 */ - 0x0000, /* R11067 */ - 0x0000, /* R11068 */ - 0x0000, /* R11069 */ - 0x0000, /* R11070 */ - 0x0000, /* R11071 */ - 0x0000, /* R11072 */ - 0x0000, /* R11073 */ - 0x0000, /* R11074 */ - 0x0000, /* R11075 */ - 0x0000, /* R11076 */ - 0x0000, /* R11077 */ - 0x0000, /* R11078 */ - 0x0000, /* R11079 */ - 0x0000, /* R11080 */ - 0x0000, /* R11081 */ - 0x0000, /* R11082 */ - 0x0000, /* R11083 */ - 0x0000, /* R11084 */ - 0x0000, /* R11085 */ - 0x0000, /* R11086 */ - 0x0000, /* R11087 */ - 0x0000, /* R11088 */ - 0x0000, /* R11089 */ - 0x0000, /* R11090 */ - 0x0000, /* R11091 */ - 0x0000, /* R11092 */ - 0x0000, /* R11093 */ - 0x0000, /* R11094 */ - 0x0000, /* R11095 */ - 0x0000, /* R11096 */ - 0x0000, /* R11097 */ - 0x0000, /* R11098 */ - 0x0000, /* R11099 */ - 0x0000, /* R11100 */ - 0x0000, /* R11101 */ - 0x0000, /* R11102 */ - 0x0000, /* R11103 */ - 0x0000, /* R11104 */ - 0x0000, /* R11105 */ - 0x0000, /* R11106 */ - 0x0000, /* R11107 */ - 0x0000, /* R11108 */ - 0x0000, /* R11109 */ - 0x0000, /* R11110 */ - 0x0000, /* R11111 */ - 0x0000, /* R11112 */ - 0x0000, /* R11113 */ - 0x0000, /* R11114 */ - 0x0000, /* R11115 */ - 0x0000, /* R11116 */ - 0x0000, /* R11117 */ - 0x0000, /* R11118 */ - 0x0000, /* R11119 */ - 0x0000, /* R11120 */ - 0x0000, /* R11121 */ - 0x0000, /* R11122 */ - 0x0000, /* R11123 */ - 0x0000, /* R11124 */ - 0x0000, /* R11125 */ - 0x0000, /* R11126 */ - 0x0000, /* R11127 */ - 0x0000, /* R11128 */ - 0x0000, /* R11129 */ - 0x0000, /* R11130 */ - 0x0000, /* R11131 */ - 0x0000, /* R11132 */ - 0x0000, /* R11133 */ - 0x0000, /* R11134 */ - 0x0000, /* R11135 */ - 0x0000, /* R11136 */ - 0x0000, /* R11137 */ - 0x0000, /* R11138 */ - 0x0000, /* R11139 */ - 0x0000, /* R11140 */ - 0x0000, /* R11141 */ - 0x0000, /* R11142 */ - 0x0000, /* R11143 */ - 0x0000, /* R11144 */ - 0x0000, /* R11145 */ - 0x0000, /* R11146 */ - 0x0000, /* R11147 */ - 0x0000, /* R11148 */ - 0x0000, /* R11149 */ - 0x0000, /* R11150 */ - 0x0000, /* R11151 */ - 0x0000, /* R11152 */ - 0x0000, /* R11153 */ - 0x0000, /* R11154 */ - 0x0000, /* R11155 */ - 0x0000, /* R11156 */ - 0x0000, /* R11157 */ - 0x0000, /* R11158 */ - 0x0000, /* R11159 */ - 0x0000, /* R11160 */ - 0x0000, /* R11161 */ - 0x0000, /* R11162 */ - 0x0000, /* R11163 */ - 0x0000, /* R11164 */ - 0x0000, /* R11165 */ - 0x0000, /* R11166 */ - 0x0000, /* R11167 */ - 0x0000, /* R11168 */ - 0x0000, /* R11169 */ - 0x0000, /* R11170 */ - 0x0000, /* R11171 */ - 0x0000, /* R11172 */ - 0x0000, /* R11173 */ - 0x0000, /* R11174 */ - 0x0000, /* R11175 */ - 0x0000, /* R11176 */ - 0x0000, /* R11177 */ - 0x0000, /* R11178 */ - 0x0000, /* R11179 */ - 0x0000, /* R11180 */ - 0x0000, /* R11181 */ - 0x0000, /* R11182 */ - 0x0000, /* R11183 */ - 0x0000, /* R11184 */ - 0x0000, /* R11185 */ - 0x0000, /* R11186 */ - 0x0000, /* R11187 */ - 0x0000, /* R11188 */ - 0x0000, /* R11189 */ - 0x0000, /* R11190 */ - 0x0000, /* R11191 */ - 0x0000, /* R11192 */ - 0x0000, /* R11193 */ - 0x0000, /* R11194 */ - 0x0000, /* R11195 */ - 0x0000, /* R11196 */ - 0x0000, /* R11197 */ - 0x0000, /* R11198 */ - 0x0000, /* R11199 */ - 0x0000, /* R11200 */ - 0x0000, /* R11201 */ - 0x0000, /* R11202 */ - 0x0000, /* R11203 */ - 0x0000, /* R11204 */ - 0x0000, /* R11205 */ - 0x0000, /* R11206 */ - 0x0000, /* R11207 */ - 0x0000, /* R11208 */ - 0x0000, /* R11209 */ - 0x0000, /* R11210 */ - 0x0000, /* R11211 */ - 0x0000, /* R11212 */ - 0x0000, /* R11213 */ - 0x0000, /* R11214 */ - 0x0000, /* R11215 */ - 0x0000, /* R11216 */ - 0x0000, /* R11217 */ - 0x0000, /* R11218 */ - 0x0000, /* R11219 */ - 0x0000, /* R11220 */ - 0x0000, /* R11221 */ - 0x0000, /* R11222 */ - 0x0000, /* R11223 */ - 0x0000, /* R11224 */ - 0x0000, /* R11225 */ - 0x0000, /* R11226 */ - 0x0000, /* R11227 */ - 0x0000, /* R11228 */ - 0x0000, /* R11229 */ - 0x0000, /* R11230 */ - 0x0000, /* R11231 */ - 0x0000, /* R11232 */ - 0x0000, /* R11233 */ - 0x0000, /* R11234 */ - 0x0000, /* R11235 */ - 0x0000, /* R11236 */ - 0x0000, /* R11237 */ - 0x0000, /* R11238 */ - 0x0000, /* R11239 */ - 0x0000, /* R11240 */ - 0x0000, /* R11241 */ - 0x0000, /* R11242 */ - 0x0000, /* R11243 */ - 0x0000, /* R11244 */ - 0x0000, /* R11245 */ - 0x0000, /* R11246 */ - 0x0000, /* R11247 */ - 0x0000, /* R11248 */ - 0x0000, /* R11249 */ - 0x0000, /* R11250 */ - 0x0000, /* R11251 */ - 0x0000, /* R11252 */ - 0x0000, /* R11253 */ - 0x0000, /* R11254 */ - 0x0000, /* R11255 */ - 0x0000, /* R11256 */ - 0x0000, /* R11257 */ - 0x0000, /* R11258 */ - 0x0000, /* R11259 */ - 0x0000, /* R11260 */ - 0x0000, /* R11261 */ - 0x0000, /* R11262 */ - 0x0000, /* R11263 */ - 0x0000, /* R11264 */ - 0x0000, /* R11265 */ - 0x0000, /* R11266 */ - 0x0000, /* R11267 */ - 0x0000, /* R11268 */ - 0x0000, /* R11269 */ - 0x0000, /* R11270 */ - 0x0000, /* R11271 */ - 0x0000, /* R11272 */ - 0x0000, /* R11273 */ - 0x0000, /* R11274 */ - 0x0000, /* R11275 */ - 0x0000, /* R11276 */ - 0x0000, /* R11277 */ - 0x0000, /* R11278 */ - 0x0000, /* R11279 */ - 0x0000, /* R11280 */ - 0x0000, /* R11281 */ - 0x0000, /* R11282 */ - 0x0000, /* R11283 */ - 0x0000, /* R11284 */ - 0x0000, /* R11285 */ - 0x0000, /* R11286 */ - 0x0000, /* R11287 */ - 0x0000, /* R11288 */ - 0x0000, /* R11289 */ - 0x0000, /* R11290 */ - 0x0000, /* R11291 */ - 0x0000, /* R11292 */ - 0x0000, /* R11293 */ - 0x0000, /* R11294 */ - 0x0000, /* R11295 */ - 0x0000, /* R11296 */ - 0x0000, /* R11297 */ - 0x0000, /* R11298 */ - 0x0000, /* R11299 */ - 0x0000, /* R11300 */ - 0x0000, /* R11301 */ - 0x0000, /* R11302 */ - 0x0000, /* R11303 */ - 0x0000, /* R11304 */ - 0x0000, /* R11305 */ - 0x0000, /* R11306 */ - 0x0000, /* R11307 */ - 0x0000, /* R11308 */ - 0x0000, /* R11309 */ - 0x0000, /* R11310 */ - 0x0000, /* R11311 */ - 0x0000, /* R11312 */ - 0x0000, /* R11313 */ - 0x0000, /* R11314 */ - 0x0000, /* R11315 */ - 0x0000, /* R11316 */ - 0x0000, /* R11317 */ - 0x0000, /* R11318 */ - 0x0000, /* R11319 */ - 0x0000, /* R11320 */ - 0x0000, /* R11321 */ - 0x0000, /* R11322 */ - 0x0000, /* R11323 */ - 0x0000, /* R11324 */ - 0x0000, /* R11325 */ - 0x0000, /* R11326 */ - 0x0000, /* R11327 */ - 0x0000, /* R11328 */ - 0x0000, /* R11329 */ - 0x0000, /* R11330 */ - 0x0000, /* R11331 */ - 0x0000, /* R11332 */ - 0x0000, /* R11333 */ - 0x0000, /* R11334 */ - 0x0000, /* R11335 */ - 0x0000, /* R11336 */ - 0x0000, /* R11337 */ - 0x0000, /* R11338 */ - 0x0000, /* R11339 */ - 0x0000, /* R11340 */ - 0x0000, /* R11341 */ - 0x0000, /* R11342 */ - 0x0000, /* R11343 */ - 0x0000, /* R11344 */ - 0x0000, /* R11345 */ - 0x0000, /* R11346 */ - 0x0000, /* R11347 */ - 0x0000, /* R11348 */ - 0x0000, /* R11349 */ - 0x0000, /* R11350 */ - 0x0000, /* R11351 */ - 0x0000, /* R11352 */ - 0x0000, /* R11353 */ - 0x0000, /* R11354 */ - 0x0000, /* R11355 */ - 0x0000, /* R11356 */ - 0x0000, /* R11357 */ - 0x0000, /* R11358 */ - 0x0000, /* R11359 */ - 0x0000, /* R11360 */ - 0x0000, /* R11361 */ - 0x0000, /* R11362 */ - 0x0000, /* R11363 */ - 0x0000, /* R11364 */ - 0x0000, /* R11365 */ - 0x0000, /* R11366 */ - 0x0000, /* R11367 */ - 0x0000, /* R11368 */ - 0x0000, /* R11369 */ - 0x0000, /* R11370 */ - 0x0000, /* R11371 */ - 0x0000, /* R11372 */ - 0x0000, /* R11373 */ - 0x0000, /* R11374 */ - 0x0000, /* R11375 */ - 0x0000, /* R11376 */ - 0x0000, /* R11377 */ - 0x0000, /* R11378 */ - 0x0000, /* R11379 */ - 0x0000, /* R11380 */ - 0x0000, /* R11381 */ - 0x0000, /* R11382 */ - 0x0000, /* R11383 */ - 0x0000, /* R11384 */ - 0x0000, /* R11385 */ - 0x0000, /* R11386 */ - 0x0000, /* R11387 */ - 0x0000, /* R11388 */ - 0x0000, /* R11389 */ - 0x0000, /* R11390 */ - 0x0000, /* R11391 */ - 0x0000, /* R11392 */ - 0x0000, /* R11393 */ - 0x0000, /* R11394 */ - 0x0000, /* R11395 */ - 0x0000, /* R11396 */ - 0x0000, /* R11397 */ - 0x0000, /* R11398 */ - 0x0000, /* R11399 */ - 0x0000, /* R11400 */ - 0x0000, /* R11401 */ - 0x0000, /* R11402 */ - 0x0000, /* R11403 */ - 0x0000, /* R11404 */ - 0x0000, /* R11405 */ - 0x0000, /* R11406 */ - 0x0000, /* R11407 */ - 0x0000, /* R11408 */ - 0x0000, /* R11409 */ - 0x0000, /* R11410 */ - 0x0000, /* R11411 */ - 0x0000, /* R11412 */ - 0x0000, /* R11413 */ - 0x0000, /* R11414 */ - 0x0000, /* R11415 */ - 0x0000, /* R11416 */ - 0x0000, /* R11417 */ - 0x0000, /* R11418 */ - 0x0000, /* R11419 */ - 0x0000, /* R11420 */ - 0x0000, /* R11421 */ - 0x0000, /* R11422 */ - 0x0000, /* R11423 */ - 0x0000, /* R11424 */ - 0x0000, /* R11425 */ - 0x0000, /* R11426 */ - 0x0000, /* R11427 */ - 0x0000, /* R11428 */ - 0x0000, /* R11429 */ - 0x0000, /* R11430 */ - 0x0000, /* R11431 */ - 0x0000, /* R11432 */ - 0x0000, /* R11433 */ - 0x0000, /* R11434 */ - 0x0000, /* R11435 */ - 0x0000, /* R11436 */ - 0x0000, /* R11437 */ - 0x0000, /* R11438 */ - 0x0000, /* R11439 */ - 0x0000, /* R11440 */ - 0x0000, /* R11441 */ - 0x0000, /* R11442 */ - 0x0000, /* R11443 */ - 0x0000, /* R11444 */ - 0x0000, /* R11445 */ - 0x0000, /* R11446 */ - 0x0000, /* R11447 */ - 0x0000, /* R11448 */ - 0x0000, /* R11449 */ - 0x0000, /* R11450 */ - 0x0000, /* R11451 */ - 0x0000, /* R11452 */ - 0x0000, /* R11453 */ - 0x0000, /* R11454 */ - 0x0000, /* R11455 */ - 0x0000, /* R11456 */ - 0x0000, /* R11457 */ - 0x0000, /* R11458 */ - 0x0000, /* R11459 */ - 0x0000, /* R11460 */ - 0x0000, /* R11461 */ - 0x0000, /* R11462 */ - 0x0000, /* R11463 */ - 0x0000, /* R11464 */ - 0x0000, /* R11465 */ - 0x0000, /* R11466 */ - 0x0000, /* R11467 */ - 0x0000, /* R11468 */ - 0x0000, /* R11469 */ - 0x0000, /* R11470 */ - 0x0000, /* R11471 */ - 0x0000, /* R11472 */ - 0x0000, /* R11473 */ - 0x0000, /* R11474 */ - 0x0000, /* R11475 */ - 0x0000, /* R11476 */ - 0x0000, /* R11477 */ - 0x0000, /* R11478 */ - 0x0000, /* R11479 */ - 0x0000, /* R11480 */ - 0x0000, /* R11481 */ - 0x0000, /* R11482 */ - 0x0000, /* R11483 */ - 0x0000, /* R11484 */ - 0x0000, /* R11485 */ - 0x0000, /* R11486 */ - 0x0000, /* R11487 */ - 0x0000, /* R11488 */ - 0x0000, /* R11489 */ - 0x0000, /* R11490 */ - 0x0000, /* R11491 */ - 0x0000, /* R11492 */ - 0x0000, /* R11493 */ - 0x0000, /* R11494 */ - 0x0000, /* R11495 */ - 0x0000, /* R11496 */ - 0x0000, /* R11497 */ - 0x0000, /* R11498 */ - 0x0000, /* R11499 */ - 0x0000, /* R11500 */ - 0x0000, /* R11501 */ - 0x0000, /* R11502 */ - 0x0000, /* R11503 */ - 0x0000, /* R11504 */ - 0x0000, /* R11505 */ - 0x0000, /* R11506 */ - 0x0000, /* R11507 */ - 0x0000, /* R11508 */ - 0x0000, /* R11509 */ - 0x0000, /* R11510 */ - 0x0000, /* R11511 */ - 0x0000, /* R11512 */ - 0x0000, /* R11513 */ - 0x0000, /* R11514 */ - 0x0000, /* R11515 */ - 0x0000, /* R11516 */ - 0x0000, /* R11517 */ - 0x0000, /* R11518 */ - 0x0000, /* R11519 */ - 0x0000, /* R11520 */ - 0x0000, /* R11521 */ - 0x0000, /* R11522 */ - 0x0000, /* R11523 */ - 0x0000, /* R11524 */ - 0x0000, /* R11525 */ - 0x0000, /* R11526 */ - 0x0000, /* R11527 */ - 0x0000, /* R11528 */ - 0x0000, /* R11529 */ - 0x0000, /* R11530 */ - 0x0000, /* R11531 */ - 0x0000, /* R11532 */ - 0x0000, /* R11533 */ - 0x0000, /* R11534 */ - 0x0000, /* R11535 */ - 0x0000, /* R11536 */ - 0x0000, /* R11537 */ - 0x0000, /* R11538 */ - 0x0000, /* R11539 */ - 0x0000, /* R11540 */ - 0x0000, /* R11541 */ - 0x0000, /* R11542 */ - 0x0000, /* R11543 */ - 0x0000, /* R11544 */ - 0x0000, /* R11545 */ - 0x0000, /* R11546 */ - 0x0000, /* R11547 */ - 0x0000, /* R11548 */ - 0x0000, /* R11549 */ - 0x0000, /* R11550 */ - 0x0000, /* R11551 */ - 0x0000, /* R11552 */ - 0x0000, /* R11553 */ - 0x0000, /* R11554 */ - 0x0000, /* R11555 */ - 0x0000, /* R11556 */ - 0x0000, /* R11557 */ - 0x0000, /* R11558 */ - 0x0000, /* R11559 */ - 0x0000, /* R11560 */ - 0x0000, /* R11561 */ - 0x0000, /* R11562 */ - 0x0000, /* R11563 */ - 0x0000, /* R11564 */ - 0x0000, /* R11565 */ - 0x0000, /* R11566 */ - 0x0000, /* R11567 */ - 0x0000, /* R11568 */ - 0x0000, /* R11569 */ - 0x0000, /* R11570 */ - 0x0000, /* R11571 */ - 0x0000, /* R11572 */ - 0x0000, /* R11573 */ - 0x0000, /* R11574 */ - 0x0000, /* R11575 */ - 0x0000, /* R11576 */ - 0x0000, /* R11577 */ - 0x0000, /* R11578 */ - 0x0000, /* R11579 */ - 0x0000, /* R11580 */ - 0x0000, /* R11581 */ - 0x0000, /* R11582 */ - 0x0000, /* R11583 */ - 0x0000, /* R11584 */ - 0x0000, /* R11585 */ - 0x0000, /* R11586 */ - 0x0000, /* R11587 */ - 0x0000, /* R11588 */ - 0x0000, /* R11589 */ - 0x0000, /* R11590 */ - 0x0000, /* R11591 */ - 0x0000, /* R11592 */ - 0x0000, /* R11593 */ - 0x0000, /* R11594 */ - 0x0000, /* R11595 */ - 0x0000, /* R11596 */ - 0x0000, /* R11597 */ - 0x0000, /* R11598 */ - 0x0000, /* R11599 */ - 0x0000, /* R11600 */ - 0x0000, /* R11601 */ - 0x0000, /* R11602 */ - 0x0000, /* R11603 */ - 0x0000, /* R11604 */ - 0x0000, /* R11605 */ - 0x0000, /* R11606 */ - 0x0000, /* R11607 */ - 0x0000, /* R11608 */ - 0x0000, /* R11609 */ - 0x0000, /* R11610 */ - 0x0000, /* R11611 */ - 0x0000, /* R11612 */ - 0x0000, /* R11613 */ - 0x0000, /* R11614 */ - 0x0000, /* R11615 */ - 0x0000, /* R11616 */ - 0x0000, /* R11617 */ - 0x0000, /* R11618 */ - 0x0000, /* R11619 */ - 0x0000, /* R11620 */ - 0x0000, /* R11621 */ - 0x0000, /* R11622 */ - 0x0000, /* R11623 */ - 0x0000, /* R11624 */ - 0x0000, /* R11625 */ - 0x0000, /* R11626 */ - 0x0000, /* R11627 */ - 0x0000, /* R11628 */ - 0x0000, /* R11629 */ - 0x0000, /* R11630 */ - 0x0000, /* R11631 */ - 0x0000, /* R11632 */ - 0x0000, /* R11633 */ - 0x0000, /* R11634 */ - 0x0000, /* R11635 */ - 0x0000, /* R11636 */ - 0x0000, /* R11637 */ - 0x0000, /* R11638 */ - 0x0000, /* R11639 */ - 0x0000, /* R11640 */ - 0x0000, /* R11641 */ - 0x0000, /* R11642 */ - 0x0000, /* R11643 */ - 0x0000, /* R11644 */ - 0x0000, /* R11645 */ - 0x0000, /* R11646 */ - 0x0000, /* R11647 */ - 0x0000, /* R11648 */ - 0x0000, /* R11649 */ - 0x0000, /* R11650 */ - 0x0000, /* R11651 */ - 0x0000, /* R11652 */ - 0x0000, /* R11653 */ - 0x0000, /* R11654 */ - 0x0000, /* R11655 */ - 0x0000, /* R11656 */ - 0x0000, /* R11657 */ - 0x0000, /* R11658 */ - 0x0000, /* R11659 */ - 0x0000, /* R11660 */ - 0x0000, /* R11661 */ - 0x0000, /* R11662 */ - 0x0000, /* R11663 */ - 0x0000, /* R11664 */ - 0x0000, /* R11665 */ - 0x0000, /* R11666 */ - 0x0000, /* R11667 */ - 0x0000, /* R11668 */ - 0x0000, /* R11669 */ - 0x0000, /* R11670 */ - 0x0000, /* R11671 */ - 0x0000, /* R11672 */ - 0x0000, /* R11673 */ - 0x0000, /* R11674 */ - 0x0000, /* R11675 */ - 0x0000, /* R11676 */ - 0x0000, /* R11677 */ - 0x0000, /* R11678 */ - 0x0000, /* R11679 */ - 0x0000, /* R11680 */ - 0x0000, /* R11681 */ - 0x0000, /* R11682 */ - 0x0000, /* R11683 */ - 0x0000, /* R11684 */ - 0x0000, /* R11685 */ - 0x0000, /* R11686 */ - 0x0000, /* R11687 */ - 0x0000, /* R11688 */ - 0x0000, /* R11689 */ - 0x0000, /* R11690 */ - 0x0000, /* R11691 */ - 0x0000, /* R11692 */ - 0x0000, /* R11693 */ - 0x0000, /* R11694 */ - 0x0000, /* R11695 */ - 0x0000, /* R11696 */ - 0x0000, /* R11697 */ - 0x0000, /* R11698 */ - 0x0000, /* R11699 */ - 0x0000, /* R11700 */ - 0x0000, /* R11701 */ - 0x0000, /* R11702 */ - 0x0000, /* R11703 */ - 0x0000, /* R11704 */ - 0x0000, /* R11705 */ - 0x0000, /* R11706 */ - 0x0000, /* R11707 */ - 0x0000, /* R11708 */ - 0x0000, /* R11709 */ - 0x0000, /* R11710 */ - 0x0000, /* R11711 */ - 0x0000, /* R11712 */ - 0x0000, /* R11713 */ - 0x0000, /* R11714 */ - 0x0000, /* R11715 */ - 0x0000, /* R11716 */ - 0x0000, /* R11717 */ - 0x0000, /* R11718 */ - 0x0000, /* R11719 */ - 0x0000, /* R11720 */ - 0x0000, /* R11721 */ - 0x0000, /* R11722 */ - 0x0000, /* R11723 */ - 0x0000, /* R11724 */ - 0x0000, /* R11725 */ - 0x0000, /* R11726 */ - 0x0000, /* R11727 */ - 0x0000, /* R11728 */ - 0x0000, /* R11729 */ - 0x0000, /* R11730 */ - 0x0000, /* R11731 */ - 0x0000, /* R11732 */ - 0x0000, /* R11733 */ - 0x0000, /* R11734 */ - 0x0000, /* R11735 */ - 0x0000, /* R11736 */ - 0x0000, /* R11737 */ - 0x0000, /* R11738 */ - 0x0000, /* R11739 */ - 0x0000, /* R11740 */ - 0x0000, /* R11741 */ - 0x0000, /* R11742 */ - 0x0000, /* R11743 */ - 0x0000, /* R11744 */ - 0x0000, /* R11745 */ - 0x0000, /* R11746 */ - 0x0000, /* R11747 */ - 0x0000, /* R11748 */ - 0x0000, /* R11749 */ - 0x0000, /* R11750 */ - 0x0000, /* R11751 */ - 0x0000, /* R11752 */ - 0x0000, /* R11753 */ - 0x0000, /* R11754 */ - 0x0000, /* R11755 */ - 0x0000, /* R11756 */ - 0x0000, /* R11757 */ - 0x0000, /* R11758 */ - 0x0000, /* R11759 */ - 0x0000, /* R11760 */ - 0x0000, /* R11761 */ - 0x0000, /* R11762 */ - 0x0000, /* R11763 */ - 0x0000, /* R11764 */ - 0x0000, /* R11765 */ - 0x0000, /* R11766 */ - 0x0000, /* R11767 */ - 0x0000, /* R11768 */ - 0x0000, /* R11769 */ - 0x0000, /* R11770 */ - 0x0000, /* R11771 */ - 0x0000, /* R11772 */ - 0x0000, /* R11773 */ - 0x0000, /* R11774 */ - 0x0000, /* R11775 */ - 0x0000, /* R11776 */ - 0x0000, /* R11777 */ - 0x0000, /* R11778 */ - 0x0000, /* R11779 */ - 0x0000, /* R11780 */ - 0x0000, /* R11781 */ - 0x0000, /* R11782 */ - 0x0000, /* R11783 */ - 0x0000, /* R11784 */ - 0x0000, /* R11785 */ - 0x0000, /* R11786 */ - 0x0000, /* R11787 */ - 0x0000, /* R11788 */ - 0x0000, /* R11789 */ - 0x0000, /* R11790 */ - 0x0000, /* R11791 */ - 0x0000, /* R11792 */ - 0x0000, /* R11793 */ - 0x0000, /* R11794 */ - 0x0000, /* R11795 */ - 0x0000, /* R11796 */ - 0x0000, /* R11797 */ - 0x0000, /* R11798 */ - 0x0000, /* R11799 */ - 0x0000, /* R11800 */ - 0x0000, /* R11801 */ - 0x0000, /* R11802 */ - 0x0000, /* R11803 */ - 0x0000, /* R11804 */ - 0x0000, /* R11805 */ - 0x0000, /* R11806 */ - 0x0000, /* R11807 */ - 0x0000, /* R11808 */ - 0x0000, /* R11809 */ - 0x0000, /* R11810 */ - 0x0000, /* R11811 */ - 0x0000, /* R11812 */ - 0x0000, /* R11813 */ - 0x0000, /* R11814 */ - 0x0000, /* R11815 */ - 0x0000, /* R11816 */ - 0x0000, /* R11817 */ - 0x0000, /* R11818 */ - 0x0000, /* R11819 */ - 0x0000, /* R11820 */ - 0x0000, /* R11821 */ - 0x0000, /* R11822 */ - 0x0000, /* R11823 */ - 0x0000, /* R11824 */ - 0x0000, /* R11825 */ - 0x0000, /* R11826 */ - 0x0000, /* R11827 */ - 0x0000, /* R11828 */ - 0x0000, /* R11829 */ - 0x0000, /* R11830 */ - 0x0000, /* R11831 */ - 0x0000, /* R11832 */ - 0x0000, /* R11833 */ - 0x0000, /* R11834 */ - 0x0000, /* R11835 */ - 0x0000, /* R11836 */ - 0x0000, /* R11837 */ - 0x0000, /* R11838 */ - 0x0000, /* R11839 */ - 0x0000, /* R11840 */ - 0x0000, /* R11841 */ - 0x0000, /* R11842 */ - 0x0000, /* R11843 */ - 0x0000, /* R11844 */ - 0x0000, /* R11845 */ - 0x0000, /* R11846 */ - 0x0000, /* R11847 */ - 0x0000, /* R11848 */ - 0x0000, /* R11849 */ - 0x0000, /* R11850 */ - 0x0000, /* R11851 */ - 0x0000, /* R11852 */ - 0x0000, /* R11853 */ - 0x0000, /* R11854 */ - 0x0000, /* R11855 */ - 0x0000, /* R11856 */ - 0x0000, /* R11857 */ - 0x0000, /* R11858 */ - 0x0000, /* R11859 */ - 0x0000, /* R11860 */ - 0x0000, /* R11861 */ - 0x0000, /* R11862 */ - 0x0000, /* R11863 */ - 0x0000, /* R11864 */ - 0x0000, /* R11865 */ - 0x0000, /* R11866 */ - 0x0000, /* R11867 */ - 0x0000, /* R11868 */ - 0x0000, /* R11869 */ - 0x0000, /* R11870 */ - 0x0000, /* R11871 */ - 0x0000, /* R11872 */ - 0x0000, /* R11873 */ - 0x0000, /* R11874 */ - 0x0000, /* R11875 */ - 0x0000, /* R11876 */ - 0x0000, /* R11877 */ - 0x0000, /* R11878 */ - 0x0000, /* R11879 */ - 0x0000, /* R11880 */ - 0x0000, /* R11881 */ - 0x0000, /* R11882 */ - 0x0000, /* R11883 */ - 0x0000, /* R11884 */ - 0x0000, /* R11885 */ - 0x0000, /* R11886 */ - 0x0000, /* R11887 */ - 0x0000, /* R11888 */ - 0x0000, /* R11889 */ - 0x0000, /* R11890 */ - 0x0000, /* R11891 */ - 0x0000, /* R11892 */ - 0x0000, /* R11893 */ - 0x0000, /* R11894 */ - 0x0000, /* R11895 */ - 0x0000, /* R11896 */ - 0x0000, /* R11897 */ - 0x0000, /* R11898 */ - 0x0000, /* R11899 */ - 0x0000, /* R11900 */ - 0x0000, /* R11901 */ - 0x0000, /* R11902 */ - 0x0000, /* R11903 */ - 0x0000, /* R11904 */ - 0x0000, /* R11905 */ - 0x0000, /* R11906 */ - 0x0000, /* R11907 */ - 0x0000, /* R11908 */ - 0x0000, /* R11909 */ - 0x0000, /* R11910 */ - 0x0000, /* R11911 */ - 0x0000, /* R11912 */ - 0x0000, /* R11913 */ - 0x0000, /* R11914 */ - 0x0000, /* R11915 */ - 0x0000, /* R11916 */ - 0x0000, /* R11917 */ - 0x0000, /* R11918 */ - 0x0000, /* R11919 */ - 0x0000, /* R11920 */ - 0x0000, /* R11921 */ - 0x0000, /* R11922 */ - 0x0000, /* R11923 */ - 0x0000, /* R11924 */ - 0x0000, /* R11925 */ - 0x0000, /* R11926 */ - 0x0000, /* R11927 */ - 0x0000, /* R11928 */ - 0x0000, /* R11929 */ - 0x0000, /* R11930 */ - 0x0000, /* R11931 */ - 0x0000, /* R11932 */ - 0x0000, /* R11933 */ - 0x0000, /* R11934 */ - 0x0000, /* R11935 */ - 0x0000, /* R11936 */ - 0x0000, /* R11937 */ - 0x0000, /* R11938 */ - 0x0000, /* R11939 */ - 0x0000, /* R11940 */ - 0x0000, /* R11941 */ - 0x0000, /* R11942 */ - 0x0000, /* R11943 */ - 0x0000, /* R11944 */ - 0x0000, /* R11945 */ - 0x0000, /* R11946 */ - 0x0000, /* R11947 */ - 0x0000, /* R11948 */ - 0x0000, /* R11949 */ - 0x0000, /* R11950 */ - 0x0000, /* R11951 */ - 0x0000, /* R11952 */ - 0x0000, /* R11953 */ - 0x0000, /* R11954 */ - 0x0000, /* R11955 */ - 0x0000, /* R11956 */ - 0x0000, /* R11957 */ - 0x0000, /* R11958 */ - 0x0000, /* R11959 */ - 0x0000, /* R11960 */ - 0x0000, /* R11961 */ - 0x0000, /* R11962 */ - 0x0000, /* R11963 */ - 0x0000, /* R11964 */ - 0x0000, /* R11965 */ - 0x0000, /* R11966 */ - 0x0000, /* R11967 */ - 0x0000, /* R11968 */ - 0x0000, /* R11969 */ - 0x0000, /* R11970 */ - 0x0000, /* R11971 */ - 0x0000, /* R11972 */ - 0x0000, /* R11973 */ - 0x0000, /* R11974 */ - 0x0000, /* R11975 */ - 0x0000, /* R11976 */ - 0x0000, /* R11977 */ - 0x0000, /* R11978 */ - 0x0000, /* R11979 */ - 0x0000, /* R11980 */ - 0x0000, /* R11981 */ - 0x0000, /* R11982 */ - 0x0000, /* R11983 */ - 0x0000, /* R11984 */ - 0x0000, /* R11985 */ - 0x0000, /* R11986 */ - 0x0000, /* R11987 */ - 0x0000, /* R11988 */ - 0x0000, /* R11989 */ - 0x0000, /* R11990 */ - 0x0000, /* R11991 */ - 0x0000, /* R11992 */ - 0x0000, /* R11993 */ - 0x0000, /* R11994 */ - 0x0000, /* R11995 */ - 0x0000, /* R11996 */ - 0x0000, /* R11997 */ - 0x0000, /* R11998 */ - 0x0000, /* R11999 */ - 0x0000, /* R12000 */ - 0x0000, /* R12001 */ - 0x0000, /* R12002 */ - 0x0000, /* R12003 */ - 0x0000, /* R12004 */ - 0x0000, /* R12005 */ - 0x0000, /* R12006 */ - 0x0000, /* R12007 */ - 0x0000, /* R12008 */ - 0x0000, /* R12009 */ - 0x0000, /* R12010 */ - 0x0000, /* R12011 */ - 0x0000, /* R12012 */ - 0x0000, /* R12013 */ - 0x0000, /* R12014 */ - 0x0000, /* R12015 */ - 0x0000, /* R12016 */ - 0x0000, /* R12017 */ - 0x0000, /* R12018 */ - 0x0000, /* R12019 */ - 0x0000, /* R12020 */ - 0x0000, /* R12021 */ - 0x0000, /* R12022 */ - 0x0000, /* R12023 */ - 0x0000, /* R12024 */ - 0x0000, /* R12025 */ - 0x0000, /* R12026 */ - 0x0000, /* R12027 */ - 0x0000, /* R12028 */ - 0x0000, /* R12029 */ - 0x0000, /* R12030 */ - 0x0000, /* R12031 */ - 0x0000, /* R12032 */ - 0x0000, /* R12033 */ - 0x0000, /* R12034 */ - 0x0000, /* R12035 */ - 0x0000, /* R12036 */ - 0x0000, /* R12037 */ - 0x0000, /* R12038 */ - 0x0000, /* R12039 */ - 0x0000, /* R12040 */ - 0x0000, /* R12041 */ - 0x0000, /* R12042 */ - 0x0000, /* R12043 */ - 0x0000, /* R12044 */ - 0x0000, /* R12045 */ - 0x0000, /* R12046 */ - 0x0000, /* R12047 */ - 0x0000, /* R12048 */ - 0x0000, /* R12049 */ - 0x0000, /* R12050 */ - 0x0000, /* R12051 */ - 0x0000, /* R12052 */ - 0x0000, /* R12053 */ - 0x0000, /* R12054 */ - 0x0000, /* R12055 */ - 0x0000, /* R12056 */ - 0x0000, /* R12057 */ - 0x0000, /* R12058 */ - 0x0000, /* R12059 */ - 0x0000, /* R12060 */ - 0x0000, /* R12061 */ - 0x0000, /* R12062 */ - 0x0000, /* R12063 */ - 0x0000, /* R12064 */ - 0x0000, /* R12065 */ - 0x0000, /* R12066 */ - 0x0000, /* R12067 */ - 0x0000, /* R12068 */ - 0x0000, /* R12069 */ - 0x0000, /* R12070 */ - 0x0000, /* R12071 */ - 0x0000, /* R12072 */ - 0x0000, /* R12073 */ - 0x0000, /* R12074 */ - 0x0000, /* R12075 */ - 0x0000, /* R12076 */ - 0x0000, /* R12077 */ - 0x0000, /* R12078 */ - 0x0000, /* R12079 */ - 0x0000, /* R12080 */ - 0x0000, /* R12081 */ - 0x0000, /* R12082 */ - 0x0000, /* R12083 */ - 0x0000, /* R12084 */ - 0x0000, /* R12085 */ - 0x0000, /* R12086 */ - 0x0000, /* R12087 */ - 0x0000, /* R12088 */ - 0x0000, /* R12089 */ - 0x0000, /* R12090 */ - 0x0000, /* R12091 */ - 0x0000, /* R12092 */ - 0x0000, /* R12093 */ - 0x0000, /* R12094 */ - 0x0000, /* R12095 */ - 0x0000, /* R12096 */ - 0x0000, /* R12097 */ - 0x0000, /* R12098 */ - 0x0000, /* R12099 */ - 0x0000, /* R12100 */ - 0x0000, /* R12101 */ - 0x0000, /* R12102 */ - 0x0000, /* R12103 */ - 0x0000, /* R12104 */ - 0x0000, /* R12105 */ - 0x0000, /* R12106 */ - 0x0000, /* R12107 */ - 0x0000, /* R12108 */ - 0x0000, /* R12109 */ - 0x0000, /* R12110 */ - 0x0000, /* R12111 */ - 0x0000, /* R12112 */ - 0x0000, /* R12113 */ - 0x0000, /* R12114 */ - 0x0000, /* R12115 */ - 0x0000, /* R12116 */ - 0x0000, /* R12117 */ - 0x0000, /* R12118 */ - 0x0000, /* R12119 */ - 0x0000, /* R12120 */ - 0x0000, /* R12121 */ - 0x0000, /* R12122 */ - 0x0000, /* R12123 */ - 0x0000, /* R12124 */ - 0x0000, /* R12125 */ - 0x0000, /* R12126 */ - 0x0000, /* R12127 */ - 0x0000, /* R12128 */ - 0x0000, /* R12129 */ - 0x0000, /* R12130 */ - 0x0000, /* R12131 */ - 0x0000, /* R12132 */ - 0x0000, /* R12133 */ - 0x0000, /* R12134 */ - 0x0000, /* R12135 */ - 0x0000, /* R12136 */ - 0x0000, /* R12137 */ - 0x0000, /* R12138 */ - 0x0000, /* R12139 */ - 0x0000, /* R12140 */ - 0x0000, /* R12141 */ - 0x0000, /* R12142 */ - 0x0000, /* R12143 */ - 0x0000, /* R12144 */ - 0x0000, /* R12145 */ - 0x0000, /* R12146 */ - 0x0000, /* R12147 */ - 0x0000, /* R12148 */ - 0x0000, /* R12149 */ - 0x0000, /* R12150 */ - 0x0000, /* R12151 */ - 0x0000, /* R12152 */ - 0x0000, /* R12153 */ - 0x0000, /* R12154 */ - 0x0000, /* R12155 */ - 0x0000, /* R12156 */ - 0x0000, /* R12157 */ - 0x0000, /* R12158 */ - 0x0000, /* R12159 */ - 0x0000, /* R12160 */ - 0x0000, /* R12161 */ - 0x0000, /* R12162 */ - 0x0000, /* R12163 */ - 0x0000, /* R12164 */ - 0x0000, /* R12165 */ - 0x0000, /* R12166 */ - 0x0000, /* R12167 */ - 0x0000, /* R12168 */ - 0x0000, /* R12169 */ - 0x0000, /* R12170 */ - 0x0000, /* R12171 */ - 0x0000, /* R12172 */ - 0x0000, /* R12173 */ - 0x0000, /* R12174 */ - 0x0000, /* R12175 */ - 0x0000, /* R12176 */ - 0x0000, /* R12177 */ - 0x0000, /* R12178 */ - 0x0000, /* R12179 */ - 0x0000, /* R12180 */ - 0x0000, /* R12181 */ - 0x0000, /* R12182 */ - 0x0000, /* R12183 */ - 0x0000, /* R12184 */ - 0x0000, /* R12185 */ - 0x0000, /* R12186 */ - 0x0000, /* R12187 */ - 0x0000, /* R12188 */ - 0x0000, /* R12189 */ - 0x0000, /* R12190 */ - 0x0000, /* R12191 */ - 0x0000, /* R12192 */ - 0x0000, /* R12193 */ - 0x0000, /* R12194 */ - 0x0000, /* R12195 */ - 0x0000, /* R12196 */ - 0x0000, /* R12197 */ - 0x0000, /* R12198 */ - 0x0000, /* R12199 */ - 0x0000, /* R12200 */ - 0x0000, /* R12201 */ - 0x0000, /* R12202 */ - 0x0000, /* R12203 */ - 0x0000, /* R12204 */ - 0x0000, /* R12205 */ - 0x0000, /* R12206 */ - 0x0000, /* R12207 */ - 0x0000, /* R12208 */ - 0x0000, /* R12209 */ - 0x0000, /* R12210 */ - 0x0000, /* R12211 */ - 0x0000, /* R12212 */ - 0x0000, /* R12213 */ - 0x0000, /* R12214 */ - 0x0000, /* R12215 */ - 0x0000, /* R12216 */ - 0x0000, /* R12217 */ - 0x0000, /* R12218 */ - 0x0000, /* R12219 */ - 0x0000, /* R12220 */ - 0x0000, /* R12221 */ - 0x0000, /* R12222 */ - 0x0000, /* R12223 */ - 0x0000, /* R12224 */ - 0x0000, /* R12225 */ - 0x0000, /* R12226 */ - 0x0000, /* R12227 */ - 0x0000, /* R12228 */ - 0x0000, /* R12229 */ - 0x0000, /* R12230 */ - 0x0000, /* R12231 */ - 0x0000, /* R12232 */ - 0x0000, /* R12233 */ - 0x0000, /* R12234 */ - 0x0000, /* R12235 */ - 0x0000, /* R12236 */ - 0x0000, /* R12237 */ - 0x0000, /* R12238 */ - 0x0000, /* R12239 */ - 0x0000, /* R12240 */ - 0x0000, /* R12241 */ - 0x0000, /* R12242 */ - 0x0000, /* R12243 */ - 0x0000, /* R12244 */ - 0x0000, /* R12245 */ - 0x0000, /* R12246 */ - 0x0000, /* R12247 */ - 0x0000, /* R12248 */ - 0x0000, /* R12249 */ - 0x0000, /* R12250 */ - 0x0000, /* R12251 */ - 0x0000, /* R12252 */ - 0x0000, /* R12253 */ - 0x0000, /* R12254 */ - 0x0000, /* R12255 */ - 0x0000, /* R12256 */ - 0x0000, /* R12257 */ - 0x0000, /* R12258 */ - 0x0000, /* R12259 */ - 0x0000, /* R12260 */ - 0x0000, /* R12261 */ - 0x0000, /* R12262 */ - 0x0000, /* R12263 */ - 0x0000, /* R12264 */ - 0x0000, /* R12265 */ - 0x0000, /* R12266 */ - 0x0000, /* R12267 */ - 0x0000, /* R12268 */ - 0x0000, /* R12269 */ - 0x0000, /* R12270 */ - 0x0000, /* R12271 */ - 0x0000, /* R12272 */ - 0x0000, /* R12273 */ - 0x0000, /* R12274 */ - 0x0000, /* R12275 */ - 0x0000, /* R12276 */ - 0x0000, /* R12277 */ - 0x0000, /* R12278 */ - 0x0000, /* R12279 */ - 0x0000, /* R12280 */ - 0x0000, /* R12281 */ - 0x0000, /* R12282 */ - 0x0000, /* R12283 */ - 0x0000, /* R12284 */ - 0x0000, /* R12285 */ - 0x0000, /* R12286 */ - 0x0000, /* R12287 */ - 0x0000, /* R12288 - DSP2 Data1 RAM 1 */ - 0x0000, /* R12289 - DSP2 Data1 RAM 0 */ - 0x0000, /* R12290 */ - 0x0000, /* R12291 */ - 0x0000, /* R12292 */ - 0x0000, /* R12293 */ - 0x0000, /* R12294 */ - 0x0000, /* R12295 */ - 0x0000, /* R12296 */ - 0x0000, /* R12297 */ - 0x0000, /* R12298 */ - 0x0000, /* R12299 */ - 0x0000, /* R12300 */ - 0x0000, /* R12301 */ - 0x0000, /* R12302 */ - 0x0000, /* R12303 */ - 0x0000, /* R12304 */ - 0x0000, /* R12305 */ - 0x0000, /* R12306 */ - 0x0000, /* R12307 */ - 0x0000, /* R12308 */ - 0x0000, /* R12309 */ - 0x0000, /* R12310 */ - 0x0000, /* R12311 */ - 0x0000, /* R12312 */ - 0x0000, /* R12313 */ - 0x0000, /* R12314 */ - 0x0000, /* R12315 */ - 0x0000, /* R12316 */ - 0x0000, /* R12317 */ - 0x0000, /* R12318 */ - 0x0000, /* R12319 */ - 0x0000, /* R12320 */ - 0x0000, /* R12321 */ - 0x0000, /* R12322 */ - 0x0000, /* R12323 */ - 0x0000, /* R12324 */ - 0x0000, /* R12325 */ - 0x0000, /* R12326 */ - 0x0000, /* R12327 */ - 0x0000, /* R12328 */ - 0x0000, /* R12329 */ - 0x0000, /* R12330 */ - 0x0000, /* R12331 */ - 0x0000, /* R12332 */ - 0x0000, /* R12333 */ - 0x0000, /* R12334 */ - 0x0000, /* R12335 */ - 0x0000, /* R12336 */ - 0x0000, /* R12337 */ - 0x0000, /* R12338 */ - 0x0000, /* R12339 */ - 0x0000, /* R12340 */ - 0x0000, /* R12341 */ - 0x0000, /* R12342 */ - 0x0000, /* R12343 */ - 0x0000, /* R12344 */ - 0x0000, /* R12345 */ - 0x0000, /* R12346 */ - 0x0000, /* R12347 */ - 0x0000, /* R12348 */ - 0x0000, /* R12349 */ - 0x0000, /* R12350 */ - 0x0000, /* R12351 */ - 0x0000, /* R12352 */ - 0x0000, /* R12353 */ - 0x0000, /* R12354 */ - 0x0000, /* R12355 */ - 0x0000, /* R12356 */ - 0x0000, /* R12357 */ - 0x0000, /* R12358 */ - 0x0000, /* R12359 */ - 0x0000, /* R12360 */ - 0x0000, /* R12361 */ - 0x0000, /* R12362 */ - 0x0000, /* R12363 */ - 0x0000, /* R12364 */ - 0x0000, /* R12365 */ - 0x0000, /* R12366 */ - 0x0000, /* R12367 */ - 0x0000, /* R12368 */ - 0x0000, /* R12369 */ - 0x0000, /* R12370 */ - 0x0000, /* R12371 */ - 0x0000, /* R12372 */ - 0x0000, /* R12373 */ - 0x0000, /* R12374 */ - 0x0000, /* R12375 */ - 0x0000, /* R12376 */ - 0x0000, /* R12377 */ - 0x0000, /* R12378 */ - 0x0000, /* R12379 */ - 0x0000, /* R12380 */ - 0x0000, /* R12381 */ - 0x0000, /* R12382 */ - 0x0000, /* R12383 */ - 0x0000, /* R12384 */ - 0x0000, /* R12385 */ - 0x0000, /* R12386 */ - 0x0000, /* R12387 */ - 0x0000, /* R12388 */ - 0x0000, /* R12389 */ - 0x0000, /* R12390 */ - 0x0000, /* R12391 */ - 0x0000, /* R12392 */ - 0x0000, /* R12393 */ - 0x0000, /* R12394 */ - 0x0000, /* R12395 */ - 0x0000, /* R12396 */ - 0x0000, /* R12397 */ - 0x0000, /* R12398 */ - 0x0000, /* R12399 */ - 0x0000, /* R12400 */ - 0x0000, /* R12401 */ - 0x0000, /* R12402 */ - 0x0000, /* R12403 */ - 0x0000, /* R12404 */ - 0x0000, /* R12405 */ - 0x0000, /* R12406 */ - 0x0000, /* R12407 */ - 0x0000, /* R12408 */ - 0x0000, /* R12409 */ - 0x0000, /* R12410 */ - 0x0000, /* R12411 */ - 0x0000, /* R12412 */ - 0x0000, /* R12413 */ - 0x0000, /* R12414 */ - 0x0000, /* R12415 */ - 0x0000, /* R12416 */ - 0x0000, /* R12417 */ - 0x0000, /* R12418 */ - 0x0000, /* R12419 */ - 0x0000, /* R12420 */ - 0x0000, /* R12421 */ - 0x0000, /* R12422 */ - 0x0000, /* R12423 */ - 0x0000, /* R12424 */ - 0x0000, /* R12425 */ - 0x0000, /* R12426 */ - 0x0000, /* R12427 */ - 0x0000, /* R12428 */ - 0x0000, /* R12429 */ - 0x0000, /* R12430 */ - 0x0000, /* R12431 */ - 0x0000, /* R12432 */ - 0x0000, /* R12433 */ - 0x0000, /* R12434 */ - 0x0000, /* R12435 */ - 0x0000, /* R12436 */ - 0x0000, /* R12437 */ - 0x0000, /* R12438 */ - 0x0000, /* R12439 */ - 0x0000, /* R12440 */ - 0x0000, /* R12441 */ - 0x0000, /* R12442 */ - 0x0000, /* R12443 */ - 0x0000, /* R12444 */ - 0x0000, /* R12445 */ - 0x0000, /* R12446 */ - 0x0000, /* R12447 */ - 0x0000, /* R12448 */ - 0x0000, /* R12449 */ - 0x0000, /* R12450 */ - 0x0000, /* R12451 */ - 0x0000, /* R12452 */ - 0x0000, /* R12453 */ - 0x0000, /* R12454 */ - 0x0000, /* R12455 */ - 0x0000, /* R12456 */ - 0x0000, /* R12457 */ - 0x0000, /* R12458 */ - 0x0000, /* R12459 */ - 0x0000, /* R12460 */ - 0x0000, /* R12461 */ - 0x0000, /* R12462 */ - 0x0000, /* R12463 */ - 0x0000, /* R12464 */ - 0x0000, /* R12465 */ - 0x0000, /* R12466 */ - 0x0000, /* R12467 */ - 0x0000, /* R12468 */ - 0x0000, /* R12469 */ - 0x0000, /* R12470 */ - 0x0000, /* R12471 */ - 0x0000, /* R12472 */ - 0x0000, /* R12473 */ - 0x0000, /* R12474 */ - 0x0000, /* R12475 */ - 0x0000, /* R12476 */ - 0x0000, /* R12477 */ - 0x0000, /* R12478 */ - 0x0000, /* R12479 */ - 0x0000, /* R12480 */ - 0x0000, /* R12481 */ - 0x0000, /* R12482 */ - 0x0000, /* R12483 */ - 0x0000, /* R12484 */ - 0x0000, /* R12485 */ - 0x0000, /* R12486 */ - 0x0000, /* R12487 */ - 0x0000, /* R12488 */ - 0x0000, /* R12489 */ - 0x0000, /* R12490 */ - 0x0000, /* R12491 */ - 0x0000, /* R12492 */ - 0x0000, /* R12493 */ - 0x0000, /* R12494 */ - 0x0000, /* R12495 */ - 0x0000, /* R12496 */ - 0x0000, /* R12497 */ - 0x0000, /* R12498 */ - 0x0000, /* R12499 */ - 0x0000, /* R12500 */ - 0x0000, /* R12501 */ - 0x0000, /* R12502 */ - 0x0000, /* R12503 */ - 0x0000, /* R12504 */ - 0x0000, /* R12505 */ - 0x0000, /* R12506 */ - 0x0000, /* R12507 */ - 0x0000, /* R12508 */ - 0x0000, /* R12509 */ - 0x0000, /* R12510 */ - 0x0000, /* R12511 */ - 0x0000, /* R12512 */ - 0x0000, /* R12513 */ - 0x0000, /* R12514 */ - 0x0000, /* R12515 */ - 0x0000, /* R12516 */ - 0x0000, /* R12517 */ - 0x0000, /* R12518 */ - 0x0000, /* R12519 */ - 0x0000, /* R12520 */ - 0x0000, /* R12521 */ - 0x0000, /* R12522 */ - 0x0000, /* R12523 */ - 0x0000, /* R12524 */ - 0x0000, /* R12525 */ - 0x0000, /* R12526 */ - 0x0000, /* R12527 */ - 0x0000, /* R12528 */ - 0x0000, /* R12529 */ - 0x0000, /* R12530 */ - 0x0000, /* R12531 */ - 0x0000, /* R12532 */ - 0x0000, /* R12533 */ - 0x0000, /* R12534 */ - 0x0000, /* R12535 */ - 0x0000, /* R12536 */ - 0x0000, /* R12537 */ - 0x0000, /* R12538 */ - 0x0000, /* R12539 */ - 0x0000, /* R12540 */ - 0x0000, /* R12541 */ - 0x0000, /* R12542 */ - 0x0000, /* R12543 */ - 0x0000, /* R12544 */ - 0x0000, /* R12545 */ - 0x0000, /* R12546 */ - 0x0000, /* R12547 */ - 0x0000, /* R12548 */ - 0x0000, /* R12549 */ - 0x0000, /* R12550 */ - 0x0000, /* R12551 */ - 0x0000, /* R12552 */ - 0x0000, /* R12553 */ - 0x0000, /* R12554 */ - 0x0000, /* R12555 */ - 0x0000, /* R12556 */ - 0x0000, /* R12557 */ - 0x0000, /* R12558 */ - 0x0000, /* R12559 */ - 0x0000, /* R12560 */ - 0x0000, /* R12561 */ - 0x0000, /* R12562 */ - 0x0000, /* R12563 */ - 0x0000, /* R12564 */ - 0x0000, /* R12565 */ - 0x0000, /* R12566 */ - 0x0000, /* R12567 */ - 0x0000, /* R12568 */ - 0x0000, /* R12569 */ - 0x0000, /* R12570 */ - 0x0000, /* R12571 */ - 0x0000, /* R12572 */ - 0x0000, /* R12573 */ - 0x0000, /* R12574 */ - 0x0000, /* R12575 */ - 0x0000, /* R12576 */ - 0x0000, /* R12577 */ - 0x0000, /* R12578 */ - 0x0000, /* R12579 */ - 0x0000, /* R12580 */ - 0x0000, /* R12581 */ - 0x0000, /* R12582 */ - 0x0000, /* R12583 */ - 0x0000, /* R12584 */ - 0x0000, /* R12585 */ - 0x0000, /* R12586 */ - 0x0000, /* R12587 */ - 0x0000, /* R12588 */ - 0x0000, /* R12589 */ - 0x0000, /* R12590 */ - 0x0000, /* R12591 */ - 0x0000, /* R12592 */ - 0x0000, /* R12593 */ - 0x0000, /* R12594 */ - 0x0000, /* R12595 */ - 0x0000, /* R12596 */ - 0x0000, /* R12597 */ - 0x0000, /* R12598 */ - 0x0000, /* R12599 */ - 0x0000, /* R12600 */ - 0x0000, /* R12601 */ - 0x0000, /* R12602 */ - 0x0000, /* R12603 */ - 0x0000, /* R12604 */ - 0x0000, /* R12605 */ - 0x0000, /* R12606 */ - 0x0000, /* R12607 */ - 0x0000, /* R12608 */ - 0x0000, /* R12609 */ - 0x0000, /* R12610 */ - 0x0000, /* R12611 */ - 0x0000, /* R12612 */ - 0x0000, /* R12613 */ - 0x0000, /* R12614 */ - 0x0000, /* R12615 */ - 0x0000, /* R12616 */ - 0x0000, /* R12617 */ - 0x0000, /* R12618 */ - 0x0000, /* R12619 */ - 0x0000, /* R12620 */ - 0x0000, /* R12621 */ - 0x0000, /* R12622 */ - 0x0000, /* R12623 */ - 0x0000, /* R12624 */ - 0x0000, /* R12625 */ - 0x0000, /* R12626 */ - 0x0000, /* R12627 */ - 0x0000, /* R12628 */ - 0x0000, /* R12629 */ - 0x0000, /* R12630 */ - 0x0000, /* R12631 */ - 0x0000, /* R12632 */ - 0x0000, /* R12633 */ - 0x0000, /* R12634 */ - 0x0000, /* R12635 */ - 0x0000, /* R12636 */ - 0x0000, /* R12637 */ - 0x0000, /* R12638 */ - 0x0000, /* R12639 */ - 0x0000, /* R12640 */ - 0x0000, /* R12641 */ - 0x0000, /* R12642 */ - 0x0000, /* R12643 */ - 0x0000, /* R12644 */ - 0x0000, /* R12645 */ - 0x0000, /* R12646 */ - 0x0000, /* R12647 */ - 0x0000, /* R12648 */ - 0x0000, /* R12649 */ - 0x0000, /* R12650 */ - 0x0000, /* R12651 */ - 0x0000, /* R12652 */ - 0x0000, /* R12653 */ - 0x0000, /* R12654 */ - 0x0000, /* R12655 */ - 0x0000, /* R12656 */ - 0x0000, /* R12657 */ - 0x0000, /* R12658 */ - 0x0000, /* R12659 */ - 0x0000, /* R12660 */ - 0x0000, /* R12661 */ - 0x0000, /* R12662 */ - 0x0000, /* R12663 */ - 0x0000, /* R12664 */ - 0x0000, /* R12665 */ - 0x0000, /* R12666 */ - 0x0000, /* R12667 */ - 0x0000, /* R12668 */ - 0x0000, /* R12669 */ - 0x0000, /* R12670 */ - 0x0000, /* R12671 */ - 0x0000, /* R12672 */ - 0x0000, /* R12673 */ - 0x0000, /* R12674 */ - 0x0000, /* R12675 */ - 0x0000, /* R12676 */ - 0x0000, /* R12677 */ - 0x0000, /* R12678 */ - 0x0000, /* R12679 */ - 0x0000, /* R12680 */ - 0x0000, /* R12681 */ - 0x0000, /* R12682 */ - 0x0000, /* R12683 */ - 0x0000, /* R12684 */ - 0x0000, /* R12685 */ - 0x0000, /* R12686 */ - 0x0000, /* R12687 */ - 0x0000, /* R12688 */ - 0x0000, /* R12689 */ - 0x0000, /* R12690 */ - 0x0000, /* R12691 */ - 0x0000, /* R12692 */ - 0x0000, /* R12693 */ - 0x0000, /* R12694 */ - 0x0000, /* R12695 */ - 0x0000, /* R12696 */ - 0x0000, /* R12697 */ - 0x0000, /* R12698 */ - 0x0000, /* R12699 */ - 0x0000, /* R12700 */ - 0x0000, /* R12701 */ - 0x0000, /* R12702 */ - 0x0000, /* R12703 */ - 0x0000, /* R12704 */ - 0x0000, /* R12705 */ - 0x0000, /* R12706 */ - 0x0000, /* R12707 */ - 0x0000, /* R12708 */ - 0x0000, /* R12709 */ - 0x0000, /* R12710 */ - 0x0000, /* R12711 */ - 0x0000, /* R12712 */ - 0x0000, /* R12713 */ - 0x0000, /* R12714 */ - 0x0000, /* R12715 */ - 0x0000, /* R12716 */ - 0x0000, /* R12717 */ - 0x0000, /* R12718 */ - 0x0000, /* R12719 */ - 0x0000, /* R12720 */ - 0x0000, /* R12721 */ - 0x0000, /* R12722 */ - 0x0000, /* R12723 */ - 0x0000, /* R12724 */ - 0x0000, /* R12725 */ - 0x0000, /* R12726 */ - 0x0000, /* R12727 */ - 0x0000, /* R12728 */ - 0x0000, /* R12729 */ - 0x0000, /* R12730 */ - 0x0000, /* R12731 */ - 0x0000, /* R12732 */ - 0x0000, /* R12733 */ - 0x0000, /* R12734 */ - 0x0000, /* R12735 */ - 0x0000, /* R12736 */ - 0x0000, /* R12737 */ - 0x0000, /* R12738 */ - 0x0000, /* R12739 */ - 0x0000, /* R12740 */ - 0x0000, /* R12741 */ - 0x0000, /* R12742 */ - 0x0000, /* R12743 */ - 0x0000, /* R12744 */ - 0x0000, /* R12745 */ - 0x0000, /* R12746 */ - 0x0000, /* R12747 */ - 0x0000, /* R12748 */ - 0x0000, /* R12749 */ - 0x0000, /* R12750 */ - 0x0000, /* R12751 */ - 0x0000, /* R12752 */ - 0x0000, /* R12753 */ - 0x0000, /* R12754 */ - 0x0000, /* R12755 */ - 0x0000, /* R12756 */ - 0x0000, /* R12757 */ - 0x0000, /* R12758 */ - 0x0000, /* R12759 */ - 0x0000, /* R12760 */ - 0x0000, /* R12761 */ - 0x0000, /* R12762 */ - 0x0000, /* R12763 */ - 0x0000, /* R12764 */ - 0x0000, /* R12765 */ - 0x0000, /* R12766 */ - 0x0000, /* R12767 */ - 0x0000, /* R12768 */ - 0x0000, /* R12769 */ - 0x0000, /* R12770 */ - 0x0000, /* R12771 */ - 0x0000, /* R12772 */ - 0x0000, /* R12773 */ - 0x0000, /* R12774 */ - 0x0000, /* R12775 */ - 0x0000, /* R12776 */ - 0x0000, /* R12777 */ - 0x0000, /* R12778 */ - 0x0000, /* R12779 */ - 0x0000, /* R12780 */ - 0x0000, /* R12781 */ - 0x0000, /* R12782 */ - 0x0000, /* R12783 */ - 0x0000, /* R12784 */ - 0x0000, /* R12785 */ - 0x0000, /* R12786 */ - 0x0000, /* R12787 */ - 0x0000, /* R12788 */ - 0x0000, /* R12789 */ - 0x0000, /* R12790 */ - 0x0000, /* R12791 */ - 0x0000, /* R12792 */ - 0x0000, /* R12793 */ - 0x0000, /* R12794 */ - 0x0000, /* R12795 */ - 0x0000, /* R12796 */ - 0x0000, /* R12797 */ - 0x0000, /* R12798 */ - 0x0000, /* R12799 */ - 0x0000, /* R12800 */ - 0x0000, /* R12801 */ - 0x0000, /* R12802 */ - 0x0000, /* R12803 */ - 0x0000, /* R12804 */ - 0x0000, /* R12805 */ - 0x0000, /* R12806 */ - 0x0000, /* R12807 */ - 0x0000, /* R12808 */ - 0x0000, /* R12809 */ - 0x0000, /* R12810 */ - 0x0000, /* R12811 */ - 0x0000, /* R12812 */ - 0x0000, /* R12813 */ - 0x0000, /* R12814 */ - 0x0000, /* R12815 */ - 0x0000, /* R12816 */ - 0x0000, /* R12817 */ - 0x0000, /* R12818 */ - 0x0000, /* R12819 */ - 0x0000, /* R12820 */ - 0x0000, /* R12821 */ - 0x0000, /* R12822 */ - 0x0000, /* R12823 */ - 0x0000, /* R12824 */ - 0x0000, /* R12825 */ - 0x0000, /* R12826 */ - 0x0000, /* R12827 */ - 0x0000, /* R12828 */ - 0x0000, /* R12829 */ - 0x0000, /* R12830 */ - 0x0000, /* R12831 */ - 0x0000, /* R12832 */ - 0x0000, /* R12833 */ - 0x0000, /* R12834 */ - 0x0000, /* R12835 */ - 0x0000, /* R12836 */ - 0x0000, /* R12837 */ - 0x0000, /* R12838 */ - 0x0000, /* R12839 */ - 0x0000, /* R12840 */ - 0x0000, /* R12841 */ - 0x0000, /* R12842 */ - 0x0000, /* R12843 */ - 0x0000, /* R12844 */ - 0x0000, /* R12845 */ - 0x0000, /* R12846 */ - 0x0000, /* R12847 */ - 0x0000, /* R12848 */ - 0x0000, /* R12849 */ - 0x0000, /* R12850 */ - 0x0000, /* R12851 */ - 0x0000, /* R12852 */ - 0x0000, /* R12853 */ - 0x0000, /* R12854 */ - 0x0000, /* R12855 */ - 0x0000, /* R12856 */ - 0x0000, /* R12857 */ - 0x0000, /* R12858 */ - 0x0000, /* R12859 */ - 0x0000, /* R12860 */ - 0x0000, /* R12861 */ - 0x0000, /* R12862 */ - 0x0000, /* R12863 */ - 0x0000, /* R12864 */ - 0x0000, /* R12865 */ - 0x0000, /* R12866 */ - 0x0000, /* R12867 */ - 0x0000, /* R12868 */ - 0x0000, /* R12869 */ - 0x0000, /* R12870 */ - 0x0000, /* R12871 */ - 0x0000, /* R12872 */ - 0x0000, /* R12873 */ - 0x0000, /* R12874 */ - 0x0000, /* R12875 */ - 0x0000, /* R12876 */ - 0x0000, /* R12877 */ - 0x0000, /* R12878 */ - 0x0000, /* R12879 */ - 0x0000, /* R12880 */ - 0x0000, /* R12881 */ - 0x0000, /* R12882 */ - 0x0000, /* R12883 */ - 0x0000, /* R12884 */ - 0x0000, /* R12885 */ - 0x0000, /* R12886 */ - 0x0000, /* R12887 */ - 0x0000, /* R12888 */ - 0x0000, /* R12889 */ - 0x0000, /* R12890 */ - 0x0000, /* R12891 */ - 0x0000, /* R12892 */ - 0x0000, /* R12893 */ - 0x0000, /* R12894 */ - 0x0000, /* R12895 */ - 0x0000, /* R12896 */ - 0x0000, /* R12897 */ - 0x0000, /* R12898 */ - 0x0000, /* R12899 */ - 0x0000, /* R12900 */ - 0x0000, /* R12901 */ - 0x0000, /* R12902 */ - 0x0000, /* R12903 */ - 0x0000, /* R12904 */ - 0x0000, /* R12905 */ - 0x0000, /* R12906 */ - 0x0000, /* R12907 */ - 0x0000, /* R12908 */ - 0x0000, /* R12909 */ - 0x0000, /* R12910 */ - 0x0000, /* R12911 */ - 0x0000, /* R12912 */ - 0x0000, /* R12913 */ - 0x0000, /* R12914 */ - 0x0000, /* R12915 */ - 0x0000, /* R12916 */ - 0x0000, /* R12917 */ - 0x0000, /* R12918 */ - 0x0000, /* R12919 */ - 0x0000, /* R12920 */ - 0x0000, /* R12921 */ - 0x0000, /* R12922 */ - 0x0000, /* R12923 */ - 0x0000, /* R12924 */ - 0x0000, /* R12925 */ - 0x0000, /* R12926 */ - 0x0000, /* R12927 */ - 0x0000, /* R12928 */ - 0x0000, /* R12929 */ - 0x0000, /* R12930 */ - 0x0000, /* R12931 */ - 0x0000, /* R12932 */ - 0x0000, /* R12933 */ - 0x0000, /* R12934 */ - 0x0000, /* R12935 */ - 0x0000, /* R12936 */ - 0x0000, /* R12937 */ - 0x0000, /* R12938 */ - 0x0000, /* R12939 */ - 0x0000, /* R12940 */ - 0x0000, /* R12941 */ - 0x0000, /* R12942 */ - 0x0000, /* R12943 */ - 0x0000, /* R12944 */ - 0x0000, /* R12945 */ - 0x0000, /* R12946 */ - 0x0000, /* R12947 */ - 0x0000, /* R12948 */ - 0x0000, /* R12949 */ - 0x0000, /* R12950 */ - 0x0000, /* R12951 */ - 0x0000, /* R12952 */ - 0x0000, /* R12953 */ - 0x0000, /* R12954 */ - 0x0000, /* R12955 */ - 0x0000, /* R12956 */ - 0x0000, /* R12957 */ - 0x0000, /* R12958 */ - 0x0000, /* R12959 */ - 0x0000, /* R12960 */ - 0x0000, /* R12961 */ - 0x0000, /* R12962 */ - 0x0000, /* R12963 */ - 0x0000, /* R12964 */ - 0x0000, /* R12965 */ - 0x0000, /* R12966 */ - 0x0000, /* R12967 */ - 0x0000, /* R12968 */ - 0x0000, /* R12969 */ - 0x0000, /* R12970 */ - 0x0000, /* R12971 */ - 0x0000, /* R12972 */ - 0x0000, /* R12973 */ - 0x0000, /* R12974 */ - 0x0000, /* R12975 */ - 0x0000, /* R12976 */ - 0x0000, /* R12977 */ - 0x0000, /* R12978 */ - 0x0000, /* R12979 */ - 0x0000, /* R12980 */ - 0x0000, /* R12981 */ - 0x0000, /* R12982 */ - 0x0000, /* R12983 */ - 0x0000, /* R12984 */ - 0x0000, /* R12985 */ - 0x0000, /* R12986 */ - 0x0000, /* R12987 */ - 0x0000, /* R12988 */ - 0x0000, /* R12989 */ - 0x0000, /* R12990 */ - 0x0000, /* R12991 */ - 0x0000, /* R12992 */ - 0x0000, /* R12993 */ - 0x0000, /* R12994 */ - 0x0000, /* R12995 */ - 0x0000, /* R12996 */ - 0x0000, /* R12997 */ - 0x0000, /* R12998 */ - 0x0000, /* R12999 */ - 0x0000, /* R13000 */ - 0x0000, /* R13001 */ - 0x0000, /* R13002 */ - 0x0000, /* R13003 */ - 0x0000, /* R13004 */ - 0x0000, /* R13005 */ - 0x0000, /* R13006 */ - 0x0000, /* R13007 */ - 0x0000, /* R13008 */ - 0x0000, /* R13009 */ - 0x0000, /* R13010 */ - 0x0000, /* R13011 */ - 0x0000, /* R13012 */ - 0x0000, /* R13013 */ - 0x0000, /* R13014 */ - 0x0000, /* R13015 */ - 0x0000, /* R13016 */ - 0x0000, /* R13017 */ - 0x0000, /* R13018 */ - 0x0000, /* R13019 */ - 0x0000, /* R13020 */ - 0x0000, /* R13021 */ - 0x0000, /* R13022 */ - 0x0000, /* R13023 */ - 0x0000, /* R13024 */ - 0x0000, /* R13025 */ - 0x0000, /* R13026 */ - 0x0000, /* R13027 */ - 0x0000, /* R13028 */ - 0x0000, /* R13029 */ - 0x0000, /* R13030 */ - 0x0000, /* R13031 */ - 0x0000, /* R13032 */ - 0x0000, /* R13033 */ - 0x0000, /* R13034 */ - 0x0000, /* R13035 */ - 0x0000, /* R13036 */ - 0x0000, /* R13037 */ - 0x0000, /* R13038 */ - 0x0000, /* R13039 */ - 0x0000, /* R13040 */ - 0x0000, /* R13041 */ - 0x0000, /* R13042 */ - 0x0000, /* R13043 */ - 0x0000, /* R13044 */ - 0x0000, /* R13045 */ - 0x0000, /* R13046 */ - 0x0000, /* R13047 */ - 0x0000, /* R13048 */ - 0x0000, /* R13049 */ - 0x0000, /* R13050 */ - 0x0000, /* R13051 */ - 0x0000, /* R13052 */ - 0x0000, /* R13053 */ - 0x0000, /* R13054 */ - 0x0000, /* R13055 */ - 0x0000, /* R13056 */ - 0x0000, /* R13057 */ - 0x0000, /* R13058 */ - 0x0000, /* R13059 */ - 0x0000, /* R13060 */ - 0x0000, /* R13061 */ - 0x0000, /* R13062 */ - 0x0000, /* R13063 */ - 0x0000, /* R13064 */ - 0x0000, /* R13065 */ - 0x0000, /* R13066 */ - 0x0000, /* R13067 */ - 0x0000, /* R13068 */ - 0x0000, /* R13069 */ - 0x0000, /* R13070 */ - 0x0000, /* R13071 */ - 0x0000, /* R13072 */ - 0x0000, /* R13073 */ - 0x0000, /* R13074 */ - 0x0000, /* R13075 */ - 0x0000, /* R13076 */ - 0x0000, /* R13077 */ - 0x0000, /* R13078 */ - 0x0000, /* R13079 */ - 0x0000, /* R13080 */ - 0x0000, /* R13081 */ - 0x0000, /* R13082 */ - 0x0000, /* R13083 */ - 0x0000, /* R13084 */ - 0x0000, /* R13085 */ - 0x0000, /* R13086 */ - 0x0000, /* R13087 */ - 0x0000, /* R13088 */ - 0x0000, /* R13089 */ - 0x0000, /* R13090 */ - 0x0000, /* R13091 */ - 0x0000, /* R13092 */ - 0x0000, /* R13093 */ - 0x0000, /* R13094 */ - 0x0000, /* R13095 */ - 0x0000, /* R13096 */ - 0x0000, /* R13097 */ - 0x0000, /* R13098 */ - 0x0000, /* R13099 */ - 0x0000, /* R13100 */ - 0x0000, /* R13101 */ - 0x0000, /* R13102 */ - 0x0000, /* R13103 */ - 0x0000, /* R13104 */ - 0x0000, /* R13105 */ - 0x0000, /* R13106 */ - 0x0000, /* R13107 */ - 0x0000, /* R13108 */ - 0x0000, /* R13109 */ - 0x0000, /* R13110 */ - 0x0000, /* R13111 */ - 0x0000, /* R13112 */ - 0x0000, /* R13113 */ - 0x0000, /* R13114 */ - 0x0000, /* R13115 */ - 0x0000, /* R13116 */ - 0x0000, /* R13117 */ - 0x0000, /* R13118 */ - 0x0000, /* R13119 */ - 0x0000, /* R13120 */ - 0x0000, /* R13121 */ - 0x0000, /* R13122 */ - 0x0000, /* R13123 */ - 0x0000, /* R13124 */ - 0x0000, /* R13125 */ - 0x0000, /* R13126 */ - 0x0000, /* R13127 */ - 0x0000, /* R13128 */ - 0x0000, /* R13129 */ - 0x0000, /* R13130 */ - 0x0000, /* R13131 */ - 0x0000, /* R13132 */ - 0x0000, /* R13133 */ - 0x0000, /* R13134 */ - 0x0000, /* R13135 */ - 0x0000, /* R13136 */ - 0x0000, /* R13137 */ - 0x0000, /* R13138 */ - 0x0000, /* R13139 */ - 0x0000, /* R13140 */ - 0x0000, /* R13141 */ - 0x0000, /* R13142 */ - 0x0000, /* R13143 */ - 0x0000, /* R13144 */ - 0x0000, /* R13145 */ - 0x0000, /* R13146 */ - 0x0000, /* R13147 */ - 0x0000, /* R13148 */ - 0x0000, /* R13149 */ - 0x0000, /* R13150 */ - 0x0000, /* R13151 */ - 0x0000, /* R13152 */ - 0x0000, /* R13153 */ - 0x0000, /* R13154 */ - 0x0000, /* R13155 */ - 0x0000, /* R13156 */ - 0x0000, /* R13157 */ - 0x0000, /* R13158 */ - 0x0000, /* R13159 */ - 0x0000, /* R13160 */ - 0x0000, /* R13161 */ - 0x0000, /* R13162 */ - 0x0000, /* R13163 */ - 0x0000, /* R13164 */ - 0x0000, /* R13165 */ - 0x0000, /* R13166 */ - 0x0000, /* R13167 */ - 0x0000, /* R13168 */ - 0x0000, /* R13169 */ - 0x0000, /* R13170 */ - 0x0000, /* R13171 */ - 0x0000, /* R13172 */ - 0x0000, /* R13173 */ - 0x0000, /* R13174 */ - 0x0000, /* R13175 */ - 0x0000, /* R13176 */ - 0x0000, /* R13177 */ - 0x0000, /* R13178 */ - 0x0000, /* R13179 */ - 0x0000, /* R13180 */ - 0x0000, /* R13181 */ - 0x0000, /* R13182 */ - 0x0000, /* R13183 */ - 0x0000, /* R13184 */ - 0x0000, /* R13185 */ - 0x0000, /* R13186 */ - 0x0000, /* R13187 */ - 0x0000, /* R13188 */ - 0x0000, /* R13189 */ - 0x0000, /* R13190 */ - 0x0000, /* R13191 */ - 0x0000, /* R13192 */ - 0x0000, /* R13193 */ - 0x0000, /* R13194 */ - 0x0000, /* R13195 */ - 0x0000, /* R13196 */ - 0x0000, /* R13197 */ - 0x0000, /* R13198 */ - 0x0000, /* R13199 */ - 0x0000, /* R13200 */ - 0x0000, /* R13201 */ - 0x0000, /* R13202 */ - 0x0000, /* R13203 */ - 0x0000, /* R13204 */ - 0x0000, /* R13205 */ - 0x0000, /* R13206 */ - 0x0000, /* R13207 */ - 0x0000, /* R13208 */ - 0x0000, /* R13209 */ - 0x0000, /* R13210 */ - 0x0000, /* R13211 */ - 0x0000, /* R13212 */ - 0x0000, /* R13213 */ - 0x0000, /* R13214 */ - 0x0000, /* R13215 */ - 0x0000, /* R13216 */ - 0x0000, /* R13217 */ - 0x0000, /* R13218 */ - 0x0000, /* R13219 */ - 0x0000, /* R13220 */ - 0x0000, /* R13221 */ - 0x0000, /* R13222 */ - 0x0000, /* R13223 */ - 0x0000, /* R13224 */ - 0x0000, /* R13225 */ - 0x0000, /* R13226 */ - 0x0000, /* R13227 */ - 0x0000, /* R13228 */ - 0x0000, /* R13229 */ - 0x0000, /* R13230 */ - 0x0000, /* R13231 */ - 0x0000, /* R13232 */ - 0x0000, /* R13233 */ - 0x0000, /* R13234 */ - 0x0000, /* R13235 */ - 0x0000, /* R13236 */ - 0x0000, /* R13237 */ - 0x0000, /* R13238 */ - 0x0000, /* R13239 */ - 0x0000, /* R13240 */ - 0x0000, /* R13241 */ - 0x0000, /* R13242 */ - 0x0000, /* R13243 */ - 0x0000, /* R13244 */ - 0x0000, /* R13245 */ - 0x0000, /* R13246 */ - 0x0000, /* R13247 */ - 0x0000, /* R13248 */ - 0x0000, /* R13249 */ - 0x0000, /* R13250 */ - 0x0000, /* R13251 */ - 0x0000, /* R13252 */ - 0x0000, /* R13253 */ - 0x0000, /* R13254 */ - 0x0000, /* R13255 */ - 0x0000, /* R13256 */ - 0x0000, /* R13257 */ - 0x0000, /* R13258 */ - 0x0000, /* R13259 */ - 0x0000, /* R13260 */ - 0x0000, /* R13261 */ - 0x0000, /* R13262 */ - 0x0000, /* R13263 */ - 0x0000, /* R13264 */ - 0x0000, /* R13265 */ - 0x0000, /* R13266 */ - 0x0000, /* R13267 */ - 0x0000, /* R13268 */ - 0x0000, /* R13269 */ - 0x0000, /* R13270 */ - 0x0000, /* R13271 */ - 0x0000, /* R13272 */ - 0x0000, /* R13273 */ - 0x0000, /* R13274 */ - 0x0000, /* R13275 */ - 0x0000, /* R13276 */ - 0x0000, /* R13277 */ - 0x0000, /* R13278 */ - 0x0000, /* R13279 */ - 0x0000, /* R13280 */ - 0x0000, /* R13281 */ - 0x0000, /* R13282 */ - 0x0000, /* R13283 */ - 0x0000, /* R13284 */ - 0x0000, /* R13285 */ - 0x0000, /* R13286 */ - 0x0000, /* R13287 */ - 0x0000, /* R13288 */ - 0x0000, /* R13289 */ - 0x0000, /* R13290 */ - 0x0000, /* R13291 */ - 0x0000, /* R13292 */ - 0x0000, /* R13293 */ - 0x0000, /* R13294 */ - 0x0000, /* R13295 */ - 0x0000, /* R13296 */ - 0x0000, /* R13297 */ - 0x0000, /* R13298 */ - 0x0000, /* R13299 */ - 0x0000, /* R13300 */ - 0x0000, /* R13301 */ - 0x0000, /* R13302 */ - 0x0000, /* R13303 */ - 0x0000, /* R13304 */ - 0x0000, /* R13305 */ - 0x0000, /* R13306 */ - 0x0000, /* R13307 */ - 0x0000, /* R13308 */ - 0x0000, /* R13309 */ - 0x0000, /* R13310 */ - 0x0000, /* R13311 */ - 0x0000, /* R13312 - DSP2 Data2 RAM 1 */ - 0x0000, /* R13313 - DSP2 Data2 RAM 0 */ - 0x0000, /* R13314 */ - 0x0000, /* R13315 */ - 0x0000, /* R13316 */ - 0x0000, /* R13317 */ - 0x0000, /* R13318 */ - 0x0000, /* R13319 */ - 0x0000, /* R13320 */ - 0x0000, /* R13321 */ - 0x0000, /* R13322 */ - 0x0000, /* R13323 */ - 0x0000, /* R13324 */ - 0x0000, /* R13325 */ - 0x0000, /* R13326 */ - 0x0000, /* R13327 */ - 0x0000, /* R13328 */ - 0x0000, /* R13329 */ - 0x0000, /* R13330 */ - 0x0000, /* R13331 */ - 0x0000, /* R13332 */ - 0x0000, /* R13333 */ - 0x0000, /* R13334 */ - 0x0000, /* R13335 */ - 0x0000, /* R13336 */ - 0x0000, /* R13337 */ - 0x0000, /* R13338 */ - 0x0000, /* R13339 */ - 0x0000, /* R13340 */ - 0x0000, /* R13341 */ - 0x0000, /* R13342 */ - 0x0000, /* R13343 */ - 0x0000, /* R13344 */ - 0x0000, /* R13345 */ - 0x0000, /* R13346 */ - 0x0000, /* R13347 */ - 0x0000, /* R13348 */ - 0x0000, /* R13349 */ - 0x0000, /* R13350 */ - 0x0000, /* R13351 */ - 0x0000, /* R13352 */ - 0x0000, /* R13353 */ - 0x0000, /* R13354 */ - 0x0000, /* R13355 */ - 0x0000, /* R13356 */ - 0x0000, /* R13357 */ - 0x0000, /* R13358 */ - 0x0000, /* R13359 */ - 0x0000, /* R13360 */ - 0x0000, /* R13361 */ - 0x0000, /* R13362 */ - 0x0000, /* R13363 */ - 0x0000, /* R13364 */ - 0x0000, /* R13365 */ - 0x0000, /* R13366 */ - 0x0000, /* R13367 */ - 0x0000, /* R13368 */ - 0x0000, /* R13369 */ - 0x0000, /* R13370 */ - 0x0000, /* R13371 */ - 0x0000, /* R13372 */ - 0x0000, /* R13373 */ - 0x0000, /* R13374 */ - 0x0000, /* R13375 */ - 0x0000, /* R13376 */ - 0x0000, /* R13377 */ - 0x0000, /* R13378 */ - 0x0000, /* R13379 */ - 0x0000, /* R13380 */ - 0x0000, /* R13381 */ - 0x0000, /* R13382 */ - 0x0000, /* R13383 */ - 0x0000, /* R13384 */ - 0x0000, /* R13385 */ - 0x0000, /* R13386 */ - 0x0000, /* R13387 */ - 0x0000, /* R13388 */ - 0x0000, /* R13389 */ - 0x0000, /* R13390 */ - 0x0000, /* R13391 */ - 0x0000, /* R13392 */ - 0x0000, /* R13393 */ - 0x0000, /* R13394 */ - 0x0000, /* R13395 */ - 0x0000, /* R13396 */ - 0x0000, /* R13397 */ - 0x0000, /* R13398 */ - 0x0000, /* R13399 */ - 0x0000, /* R13400 */ - 0x0000, /* R13401 */ - 0x0000, /* R13402 */ - 0x0000, /* R13403 */ - 0x0000, /* R13404 */ - 0x0000, /* R13405 */ - 0x0000, /* R13406 */ - 0x0000, /* R13407 */ - 0x0000, /* R13408 */ - 0x0000, /* R13409 */ - 0x0000, /* R13410 */ - 0x0000, /* R13411 */ - 0x0000, /* R13412 */ - 0x0000, /* R13413 */ - 0x0000, /* R13414 */ - 0x0000, /* R13415 */ - 0x0000, /* R13416 */ - 0x0000, /* R13417 */ - 0x0000, /* R13418 */ - 0x0000, /* R13419 */ - 0x0000, /* R13420 */ - 0x0000, /* R13421 */ - 0x0000, /* R13422 */ - 0x0000, /* R13423 */ - 0x0000, /* R13424 */ - 0x0000, /* R13425 */ - 0x0000, /* R13426 */ - 0x0000, /* R13427 */ - 0x0000, /* R13428 */ - 0x0000, /* R13429 */ - 0x0000, /* R13430 */ - 0x0000, /* R13431 */ - 0x0000, /* R13432 */ - 0x0000, /* R13433 */ - 0x0000, /* R13434 */ - 0x0000, /* R13435 */ - 0x0000, /* R13436 */ - 0x0000, /* R13437 */ - 0x0000, /* R13438 */ - 0x0000, /* R13439 */ - 0x0000, /* R13440 */ - 0x0000, /* R13441 */ - 0x0000, /* R13442 */ - 0x0000, /* R13443 */ - 0x0000, /* R13444 */ - 0x0000, /* R13445 */ - 0x0000, /* R13446 */ - 0x0000, /* R13447 */ - 0x0000, /* R13448 */ - 0x0000, /* R13449 */ - 0x0000, /* R13450 */ - 0x0000, /* R13451 */ - 0x0000, /* R13452 */ - 0x0000, /* R13453 */ - 0x0000, /* R13454 */ - 0x0000, /* R13455 */ - 0x0000, /* R13456 */ - 0x0000, /* R13457 */ - 0x0000, /* R13458 */ - 0x0000, /* R13459 */ - 0x0000, /* R13460 */ - 0x0000, /* R13461 */ - 0x0000, /* R13462 */ - 0x0000, /* R13463 */ - 0x0000, /* R13464 */ - 0x0000, /* R13465 */ - 0x0000, /* R13466 */ - 0x0000, /* R13467 */ - 0x0000, /* R13468 */ - 0x0000, /* R13469 */ - 0x0000, /* R13470 */ - 0x0000, /* R13471 */ - 0x0000, /* R13472 */ - 0x0000, /* R13473 */ - 0x0000, /* R13474 */ - 0x0000, /* R13475 */ - 0x0000, /* R13476 */ - 0x0000, /* R13477 */ - 0x0000, /* R13478 */ - 0x0000, /* R13479 */ - 0x0000, /* R13480 */ - 0x0000, /* R13481 */ - 0x0000, /* R13482 */ - 0x0000, /* R13483 */ - 0x0000, /* R13484 */ - 0x0000, /* R13485 */ - 0x0000, /* R13486 */ - 0x0000, /* R13487 */ - 0x0000, /* R13488 */ - 0x0000, /* R13489 */ - 0x0000, /* R13490 */ - 0x0000, /* R13491 */ - 0x0000, /* R13492 */ - 0x0000, /* R13493 */ - 0x0000, /* R13494 */ - 0x0000, /* R13495 */ - 0x0000, /* R13496 */ - 0x0000, /* R13497 */ - 0x0000, /* R13498 */ - 0x0000, /* R13499 */ - 0x0000, /* R13500 */ - 0x0000, /* R13501 */ - 0x0000, /* R13502 */ - 0x0000, /* R13503 */ - 0x0000, /* R13504 */ - 0x0000, /* R13505 */ - 0x0000, /* R13506 */ - 0x0000, /* R13507 */ - 0x0000, /* R13508 */ - 0x0000, /* R13509 */ - 0x0000, /* R13510 */ - 0x0000, /* R13511 */ - 0x0000, /* R13512 */ - 0x0000, /* R13513 */ - 0x0000, /* R13514 */ - 0x0000, /* R13515 */ - 0x0000, /* R13516 */ - 0x0000, /* R13517 */ - 0x0000, /* R13518 */ - 0x0000, /* R13519 */ - 0x0000, /* R13520 */ - 0x0000, /* R13521 */ - 0x0000, /* R13522 */ - 0x0000, /* R13523 */ - 0x0000, /* R13524 */ - 0x0000, /* R13525 */ - 0x0000, /* R13526 */ - 0x0000, /* R13527 */ - 0x0000, /* R13528 */ - 0x0000, /* R13529 */ - 0x0000, /* R13530 */ - 0x0000, /* R13531 */ - 0x0000, /* R13532 */ - 0x0000, /* R13533 */ - 0x0000, /* R13534 */ - 0x0000, /* R13535 */ - 0x0000, /* R13536 */ - 0x0000, /* R13537 */ - 0x0000, /* R13538 */ - 0x0000, /* R13539 */ - 0x0000, /* R13540 */ - 0x0000, /* R13541 */ - 0x0000, /* R13542 */ - 0x0000, /* R13543 */ - 0x0000, /* R13544 */ - 0x0000, /* R13545 */ - 0x0000, /* R13546 */ - 0x0000, /* R13547 */ - 0x0000, /* R13548 */ - 0x0000, /* R13549 */ - 0x0000, /* R13550 */ - 0x0000, /* R13551 */ - 0x0000, /* R13552 */ - 0x0000, /* R13553 */ - 0x0000, /* R13554 */ - 0x0000, /* R13555 */ - 0x0000, /* R13556 */ - 0x0000, /* R13557 */ - 0x0000, /* R13558 */ - 0x0000, /* R13559 */ - 0x0000, /* R13560 */ - 0x0000, /* R13561 */ - 0x0000, /* R13562 */ - 0x0000, /* R13563 */ - 0x0000, /* R13564 */ - 0x0000, /* R13565 */ - 0x0000, /* R13566 */ - 0x0000, /* R13567 */ - 0x0000, /* R13568 */ - 0x0000, /* R13569 */ - 0x0000, /* R13570 */ - 0x0000, /* R13571 */ - 0x0000, /* R13572 */ - 0x0000, /* R13573 */ - 0x0000, /* R13574 */ - 0x0000, /* R13575 */ - 0x0000, /* R13576 */ - 0x0000, /* R13577 */ - 0x0000, /* R13578 */ - 0x0000, /* R13579 */ - 0x0000, /* R13580 */ - 0x0000, /* R13581 */ - 0x0000, /* R13582 */ - 0x0000, /* R13583 */ - 0x0000, /* R13584 */ - 0x0000, /* R13585 */ - 0x0000, /* R13586 */ - 0x0000, /* R13587 */ - 0x0000, /* R13588 */ - 0x0000, /* R13589 */ - 0x0000, /* R13590 */ - 0x0000, /* R13591 */ - 0x0000, /* R13592 */ - 0x0000, /* R13593 */ - 0x0000, /* R13594 */ - 0x0000, /* R13595 */ - 0x0000, /* R13596 */ - 0x0000, /* R13597 */ - 0x0000, /* R13598 */ - 0x0000, /* R13599 */ - 0x0000, /* R13600 */ - 0x0000, /* R13601 */ - 0x0000, /* R13602 */ - 0x0000, /* R13603 */ - 0x0000, /* R13604 */ - 0x0000, /* R13605 */ - 0x0000, /* R13606 */ - 0x0000, /* R13607 */ - 0x0000, /* R13608 */ - 0x0000, /* R13609 */ - 0x0000, /* R13610 */ - 0x0000, /* R13611 */ - 0x0000, /* R13612 */ - 0x0000, /* R13613 */ - 0x0000, /* R13614 */ - 0x0000, /* R13615 */ - 0x0000, /* R13616 */ - 0x0000, /* R13617 */ - 0x0000, /* R13618 */ - 0x0000, /* R13619 */ - 0x0000, /* R13620 */ - 0x0000, /* R13621 */ - 0x0000, /* R13622 */ - 0x0000, /* R13623 */ - 0x0000, /* R13624 */ - 0x0000, /* R13625 */ - 0x0000, /* R13626 */ - 0x0000, /* R13627 */ - 0x0000, /* R13628 */ - 0x0000, /* R13629 */ - 0x0000, /* R13630 */ - 0x0000, /* R13631 */ - 0x0000, /* R13632 */ - 0x0000, /* R13633 */ - 0x0000, /* R13634 */ - 0x0000, /* R13635 */ - 0x0000, /* R13636 */ - 0x0000, /* R13637 */ - 0x0000, /* R13638 */ - 0x0000, /* R13639 */ - 0x0000, /* R13640 */ - 0x0000, /* R13641 */ - 0x0000, /* R13642 */ - 0x0000, /* R13643 */ - 0x0000, /* R13644 */ - 0x0000, /* R13645 */ - 0x0000, /* R13646 */ - 0x0000, /* R13647 */ - 0x0000, /* R13648 */ - 0x0000, /* R13649 */ - 0x0000, /* R13650 */ - 0x0000, /* R13651 */ - 0x0000, /* R13652 */ - 0x0000, /* R13653 */ - 0x0000, /* R13654 */ - 0x0000, /* R13655 */ - 0x0000, /* R13656 */ - 0x0000, /* R13657 */ - 0x0000, /* R13658 */ - 0x0000, /* R13659 */ - 0x0000, /* R13660 */ - 0x0000, /* R13661 */ - 0x0000, /* R13662 */ - 0x0000, /* R13663 */ - 0x0000, /* R13664 */ - 0x0000, /* R13665 */ - 0x0000, /* R13666 */ - 0x0000, /* R13667 */ - 0x0000, /* R13668 */ - 0x0000, /* R13669 */ - 0x0000, /* R13670 */ - 0x0000, /* R13671 */ - 0x0000, /* R13672 */ - 0x0000, /* R13673 */ - 0x0000, /* R13674 */ - 0x0000, /* R13675 */ - 0x0000, /* R13676 */ - 0x0000, /* R13677 */ - 0x0000, /* R13678 */ - 0x0000, /* R13679 */ - 0x0000, /* R13680 */ - 0x0000, /* R13681 */ - 0x0000, /* R13682 */ - 0x0000, /* R13683 */ - 0x0000, /* R13684 */ - 0x0000, /* R13685 */ - 0x0000, /* R13686 */ - 0x0000, /* R13687 */ - 0x0000, /* R13688 */ - 0x0000, /* R13689 */ - 0x0000, /* R13690 */ - 0x0000, /* R13691 */ - 0x0000, /* R13692 */ - 0x0000, /* R13693 */ - 0x0000, /* R13694 */ - 0x0000, /* R13695 */ - 0x0000, /* R13696 */ - 0x0000, /* R13697 */ - 0x0000, /* R13698 */ - 0x0000, /* R13699 */ - 0x0000, /* R13700 */ - 0x0000, /* R13701 */ - 0x0000, /* R13702 */ - 0x0000, /* R13703 */ - 0x0000, /* R13704 */ - 0x0000, /* R13705 */ - 0x0000, /* R13706 */ - 0x0000, /* R13707 */ - 0x0000, /* R13708 */ - 0x0000, /* R13709 */ - 0x0000, /* R13710 */ - 0x0000, /* R13711 */ - 0x0000, /* R13712 */ - 0x0000, /* R13713 */ - 0x0000, /* R13714 */ - 0x0000, /* R13715 */ - 0x0000, /* R13716 */ - 0x0000, /* R13717 */ - 0x0000, /* R13718 */ - 0x0000, /* R13719 */ - 0x0000, /* R13720 */ - 0x0000, /* R13721 */ - 0x0000, /* R13722 */ - 0x0000, /* R13723 */ - 0x0000, /* R13724 */ - 0x0000, /* R13725 */ - 0x0000, /* R13726 */ - 0x0000, /* R13727 */ - 0x0000, /* R13728 */ - 0x0000, /* R13729 */ - 0x0000, /* R13730 */ - 0x0000, /* R13731 */ - 0x0000, /* R13732 */ - 0x0000, /* R13733 */ - 0x0000, /* R13734 */ - 0x0000, /* R13735 */ - 0x0000, /* R13736 */ - 0x0000, /* R13737 */ - 0x0000, /* R13738 */ - 0x0000, /* R13739 */ - 0x0000, /* R13740 */ - 0x0000, /* R13741 */ - 0x0000, /* R13742 */ - 0x0000, /* R13743 */ - 0x0000, /* R13744 */ - 0x0000, /* R13745 */ - 0x0000, /* R13746 */ - 0x0000, /* R13747 */ - 0x0000, /* R13748 */ - 0x0000, /* R13749 */ - 0x0000, /* R13750 */ - 0x0000, /* R13751 */ - 0x0000, /* R13752 */ - 0x0000, /* R13753 */ - 0x0000, /* R13754 */ - 0x0000, /* R13755 */ - 0x0000, /* R13756 */ - 0x0000, /* R13757 */ - 0x0000, /* R13758 */ - 0x0000, /* R13759 */ - 0x0000, /* R13760 */ - 0x0000, /* R13761 */ - 0x0000, /* R13762 */ - 0x0000, /* R13763 */ - 0x0000, /* R13764 */ - 0x0000, /* R13765 */ - 0x0000, /* R13766 */ - 0x0000, /* R13767 */ - 0x0000, /* R13768 */ - 0x0000, /* R13769 */ - 0x0000, /* R13770 */ - 0x0000, /* R13771 */ - 0x0000, /* R13772 */ - 0x0000, /* R13773 */ - 0x0000, /* R13774 */ - 0x0000, /* R13775 */ - 0x0000, /* R13776 */ - 0x0000, /* R13777 */ - 0x0000, /* R13778 */ - 0x0000, /* R13779 */ - 0x0000, /* R13780 */ - 0x0000, /* R13781 */ - 0x0000, /* R13782 */ - 0x0000, /* R13783 */ - 0x0000, /* R13784 */ - 0x0000, /* R13785 */ - 0x0000, /* R13786 */ - 0x0000, /* R13787 */ - 0x0000, /* R13788 */ - 0x0000, /* R13789 */ - 0x0000, /* R13790 */ - 0x0000, /* R13791 */ - 0x0000, /* R13792 */ - 0x0000, /* R13793 */ - 0x0000, /* R13794 */ - 0x0000, /* R13795 */ - 0x0000, /* R13796 */ - 0x0000, /* R13797 */ - 0x0000, /* R13798 */ - 0x0000, /* R13799 */ - 0x0000, /* R13800 */ - 0x0000, /* R13801 */ - 0x0000, /* R13802 */ - 0x0000, /* R13803 */ - 0x0000, /* R13804 */ - 0x0000, /* R13805 */ - 0x0000, /* R13806 */ - 0x0000, /* R13807 */ - 0x0000, /* R13808 */ - 0x0000, /* R13809 */ - 0x0000, /* R13810 */ - 0x0000, /* R13811 */ - 0x0000, /* R13812 */ - 0x0000, /* R13813 */ - 0x0000, /* R13814 */ - 0x0000, /* R13815 */ - 0x0000, /* R13816 */ - 0x0000, /* R13817 */ - 0x0000, /* R13818 */ - 0x0000, /* R13819 */ - 0x0000, /* R13820 */ - 0x0000, /* R13821 */ - 0x0000, /* R13822 */ - 0x0000, /* R13823 */ - 0x0000, /* R13824 */ - 0x0000, /* R13825 */ - 0x0000, /* R13826 */ - 0x0000, /* R13827 */ - 0x0000, /* R13828 */ - 0x0000, /* R13829 */ - 0x0000, /* R13830 */ - 0x0000, /* R13831 */ - 0x0000, /* R13832 */ - 0x0000, /* R13833 */ - 0x0000, /* R13834 */ - 0x0000, /* R13835 */ - 0x0000, /* R13836 */ - 0x0000, /* R13837 */ - 0x0000, /* R13838 */ - 0x0000, /* R13839 */ - 0x0000, /* R13840 */ - 0x0000, /* R13841 */ - 0x0000, /* R13842 */ - 0x0000, /* R13843 */ - 0x0000, /* R13844 */ - 0x0000, /* R13845 */ - 0x0000, /* R13846 */ - 0x0000, /* R13847 */ - 0x0000, /* R13848 */ - 0x0000, /* R13849 */ - 0x0000, /* R13850 */ - 0x0000, /* R13851 */ - 0x0000, /* R13852 */ - 0x0000, /* R13853 */ - 0x0000, /* R13854 */ - 0x0000, /* R13855 */ - 0x0000, /* R13856 */ - 0x0000, /* R13857 */ - 0x0000, /* R13858 */ - 0x0000, /* R13859 */ - 0x0000, /* R13860 */ - 0x0000, /* R13861 */ - 0x0000, /* R13862 */ - 0x0000, /* R13863 */ - 0x0000, /* R13864 */ - 0x0000, /* R13865 */ - 0x0000, /* R13866 */ - 0x0000, /* R13867 */ - 0x0000, /* R13868 */ - 0x0000, /* R13869 */ - 0x0000, /* R13870 */ - 0x0000, /* R13871 */ - 0x0000, /* R13872 */ - 0x0000, /* R13873 */ - 0x0000, /* R13874 */ - 0x0000, /* R13875 */ - 0x0000, /* R13876 */ - 0x0000, /* R13877 */ - 0x0000, /* R13878 */ - 0x0000, /* R13879 */ - 0x0000, /* R13880 */ - 0x0000, /* R13881 */ - 0x0000, /* R13882 */ - 0x0000, /* R13883 */ - 0x0000, /* R13884 */ - 0x0000, /* R13885 */ - 0x0000, /* R13886 */ - 0x0000, /* R13887 */ - 0x0000, /* R13888 */ - 0x0000, /* R13889 */ - 0x0000, /* R13890 */ - 0x0000, /* R13891 */ - 0x0000, /* R13892 */ - 0x0000, /* R13893 */ - 0x0000, /* R13894 */ - 0x0000, /* R13895 */ - 0x0000, /* R13896 */ - 0x0000, /* R13897 */ - 0x0000, /* R13898 */ - 0x0000, /* R13899 */ - 0x0000, /* R13900 */ - 0x0000, /* R13901 */ - 0x0000, /* R13902 */ - 0x0000, /* R13903 */ - 0x0000, /* R13904 */ - 0x0000, /* R13905 */ - 0x0000, /* R13906 */ - 0x0000, /* R13907 */ - 0x0000, /* R13908 */ - 0x0000, /* R13909 */ - 0x0000, /* R13910 */ - 0x0000, /* R13911 */ - 0x0000, /* R13912 */ - 0x0000, /* R13913 */ - 0x0000, /* R13914 */ - 0x0000, /* R13915 */ - 0x0000, /* R13916 */ - 0x0000, /* R13917 */ - 0x0000, /* R13918 */ - 0x0000, /* R13919 */ - 0x0000, /* R13920 */ - 0x0000, /* R13921 */ - 0x0000, /* R13922 */ - 0x0000, /* R13923 */ - 0x0000, /* R13924 */ - 0x0000, /* R13925 */ - 0x0000, /* R13926 */ - 0x0000, /* R13927 */ - 0x0000, /* R13928 */ - 0x0000, /* R13929 */ - 0x0000, /* R13930 */ - 0x0000, /* R13931 */ - 0x0000, /* R13932 */ - 0x0000, /* R13933 */ - 0x0000, /* R13934 */ - 0x0000, /* R13935 */ - 0x0000, /* R13936 */ - 0x0000, /* R13937 */ - 0x0000, /* R13938 */ - 0x0000, /* R13939 */ - 0x0000, /* R13940 */ - 0x0000, /* R13941 */ - 0x0000, /* R13942 */ - 0x0000, /* R13943 */ - 0x0000, /* R13944 */ - 0x0000, /* R13945 */ - 0x0000, /* R13946 */ - 0x0000, /* R13947 */ - 0x0000, /* R13948 */ - 0x0000, /* R13949 */ - 0x0000, /* R13950 */ - 0x0000, /* R13951 */ - 0x0000, /* R13952 */ - 0x0000, /* R13953 */ - 0x0000, /* R13954 */ - 0x0000, /* R13955 */ - 0x0000, /* R13956 */ - 0x0000, /* R13957 */ - 0x0000, /* R13958 */ - 0x0000, /* R13959 */ - 0x0000, /* R13960 */ - 0x0000, /* R13961 */ - 0x0000, /* R13962 */ - 0x0000, /* R13963 */ - 0x0000, /* R13964 */ - 0x0000, /* R13965 */ - 0x0000, /* R13966 */ - 0x0000, /* R13967 */ - 0x0000, /* R13968 */ - 0x0000, /* R13969 */ - 0x0000, /* R13970 */ - 0x0000, /* R13971 */ - 0x0000, /* R13972 */ - 0x0000, /* R13973 */ - 0x0000, /* R13974 */ - 0x0000, /* R13975 */ - 0x0000, /* R13976 */ - 0x0000, /* R13977 */ - 0x0000, /* R13978 */ - 0x0000, /* R13979 */ - 0x0000, /* R13980 */ - 0x0000, /* R13981 */ - 0x0000, /* R13982 */ - 0x0000, /* R13983 */ - 0x0000, /* R13984 */ - 0x0000, /* R13985 */ - 0x0000, /* R13986 */ - 0x0000, /* R13987 */ - 0x0000, /* R13988 */ - 0x0000, /* R13989 */ - 0x0000, /* R13990 */ - 0x0000, /* R13991 */ - 0x0000, /* R13992 */ - 0x0000, /* R13993 */ - 0x0000, /* R13994 */ - 0x0000, /* R13995 */ - 0x0000, /* R13996 */ - 0x0000, /* R13997 */ - 0x0000, /* R13998 */ - 0x0000, /* R13999 */ - 0x0000, /* R14000 */ - 0x0000, /* R14001 */ - 0x0000, /* R14002 */ - 0x0000, /* R14003 */ - 0x0000, /* R14004 */ - 0x0000, /* R14005 */ - 0x0000, /* R14006 */ - 0x0000, /* R14007 */ - 0x0000, /* R14008 */ - 0x0000, /* R14009 */ - 0x0000, /* R14010 */ - 0x0000, /* R14011 */ - 0x0000, /* R14012 */ - 0x0000, /* R14013 */ - 0x0000, /* R14014 */ - 0x0000, /* R14015 */ - 0x0000, /* R14016 */ - 0x0000, /* R14017 */ - 0x0000, /* R14018 */ - 0x0000, /* R14019 */ - 0x0000, /* R14020 */ - 0x0000, /* R14021 */ - 0x0000, /* R14022 */ - 0x0000, /* R14023 */ - 0x0000, /* R14024 */ - 0x0000, /* R14025 */ - 0x0000, /* R14026 */ - 0x0000, /* R14027 */ - 0x0000, /* R14028 */ - 0x0000, /* R14029 */ - 0x0000, /* R14030 */ - 0x0000, /* R14031 */ - 0x0000, /* R14032 */ - 0x0000, /* R14033 */ - 0x0000, /* R14034 */ - 0x0000, /* R14035 */ - 0x0000, /* R14036 */ - 0x0000, /* R14037 */ - 0x0000, /* R14038 */ - 0x0000, /* R14039 */ - 0x0000, /* R14040 */ - 0x0000, /* R14041 */ - 0x0000, /* R14042 */ - 0x0000, /* R14043 */ - 0x0000, /* R14044 */ - 0x0000, /* R14045 */ - 0x0000, /* R14046 */ - 0x0000, /* R14047 */ - 0x0000, /* R14048 */ - 0x0000, /* R14049 */ - 0x0000, /* R14050 */ - 0x0000, /* R14051 */ - 0x0000, /* R14052 */ - 0x0000, /* R14053 */ - 0x0000, /* R14054 */ - 0x0000, /* R14055 */ - 0x0000, /* R14056 */ - 0x0000, /* R14057 */ - 0x0000, /* R14058 */ - 0x0000, /* R14059 */ - 0x0000, /* R14060 */ - 0x0000, /* R14061 */ - 0x0000, /* R14062 */ - 0x0000, /* R14063 */ - 0x0000, /* R14064 */ - 0x0000, /* R14065 */ - 0x0000, /* R14066 */ - 0x0000, /* R14067 */ - 0x0000, /* R14068 */ - 0x0000, /* R14069 */ - 0x0000, /* R14070 */ - 0x0000, /* R14071 */ - 0x0000, /* R14072 */ - 0x0000, /* R14073 */ - 0x0000, /* R14074 */ - 0x0000, /* R14075 */ - 0x0000, /* R14076 */ - 0x0000, /* R14077 */ - 0x0000, /* R14078 */ - 0x0000, /* R14079 */ - 0x0000, /* R14080 */ - 0x0000, /* R14081 */ - 0x0000, /* R14082 */ - 0x0000, /* R14083 */ - 0x0000, /* R14084 */ - 0x0000, /* R14085 */ - 0x0000, /* R14086 */ - 0x0000, /* R14087 */ - 0x0000, /* R14088 */ - 0x0000, /* R14089 */ - 0x0000, /* R14090 */ - 0x0000, /* R14091 */ - 0x0000, /* R14092 */ - 0x0000, /* R14093 */ - 0x0000, /* R14094 */ - 0x0000, /* R14095 */ - 0x0000, /* R14096 */ - 0x0000, /* R14097 */ - 0x0000, /* R14098 */ - 0x0000, /* R14099 */ - 0x0000, /* R14100 */ - 0x0000, /* R14101 */ - 0x0000, /* R14102 */ - 0x0000, /* R14103 */ - 0x0000, /* R14104 */ - 0x0000, /* R14105 */ - 0x0000, /* R14106 */ - 0x0000, /* R14107 */ - 0x0000, /* R14108 */ - 0x0000, /* R14109 */ - 0x0000, /* R14110 */ - 0x0000, /* R14111 */ - 0x0000, /* R14112 */ - 0x0000, /* R14113 */ - 0x0000, /* R14114 */ - 0x0000, /* R14115 */ - 0x0000, /* R14116 */ - 0x0000, /* R14117 */ - 0x0000, /* R14118 */ - 0x0000, /* R14119 */ - 0x0000, /* R14120 */ - 0x0000, /* R14121 */ - 0x0000, /* R14122 */ - 0x0000, /* R14123 */ - 0x0000, /* R14124 */ - 0x0000, /* R14125 */ - 0x0000, /* R14126 */ - 0x0000, /* R14127 */ - 0x0000, /* R14128 */ - 0x0000, /* R14129 */ - 0x0000, /* R14130 */ - 0x0000, /* R14131 */ - 0x0000, /* R14132 */ - 0x0000, /* R14133 */ - 0x0000, /* R14134 */ - 0x0000, /* R14135 */ - 0x0000, /* R14136 */ - 0x0000, /* R14137 */ - 0x0000, /* R14138 */ - 0x0000, /* R14139 */ - 0x0000, /* R14140 */ - 0x0000, /* R14141 */ - 0x0000, /* R14142 */ - 0x0000, /* R14143 */ - 0x0000, /* R14144 */ - 0x0000, /* R14145 */ - 0x0000, /* R14146 */ - 0x0000, /* R14147 */ - 0x0000, /* R14148 */ - 0x0000, /* R14149 */ - 0x0000, /* R14150 */ - 0x0000, /* R14151 */ - 0x0000, /* R14152 */ - 0x0000, /* R14153 */ - 0x0000, /* R14154 */ - 0x0000, /* R14155 */ - 0x0000, /* R14156 */ - 0x0000, /* R14157 */ - 0x0000, /* R14158 */ - 0x0000, /* R14159 */ - 0x0000, /* R14160 */ - 0x0000, /* R14161 */ - 0x0000, /* R14162 */ - 0x0000, /* R14163 */ - 0x0000, /* R14164 */ - 0x0000, /* R14165 */ - 0x0000, /* R14166 */ - 0x0000, /* R14167 */ - 0x0000, /* R14168 */ - 0x0000, /* R14169 */ - 0x0000, /* R14170 */ - 0x0000, /* R14171 */ - 0x0000, /* R14172 */ - 0x0000, /* R14173 */ - 0x0000, /* R14174 */ - 0x0000, /* R14175 */ - 0x0000, /* R14176 */ - 0x0000, /* R14177 */ - 0x0000, /* R14178 */ - 0x0000, /* R14179 */ - 0x0000, /* R14180 */ - 0x0000, /* R14181 */ - 0x0000, /* R14182 */ - 0x0000, /* R14183 */ - 0x0000, /* R14184 */ - 0x0000, /* R14185 */ - 0x0000, /* R14186 */ - 0x0000, /* R14187 */ - 0x0000, /* R14188 */ - 0x0000, /* R14189 */ - 0x0000, /* R14190 */ - 0x0000, /* R14191 */ - 0x0000, /* R14192 */ - 0x0000, /* R14193 */ - 0x0000, /* R14194 */ - 0x0000, /* R14195 */ - 0x0000, /* R14196 */ - 0x0000, /* R14197 */ - 0x0000, /* R14198 */ - 0x0000, /* R14199 */ - 0x0000, /* R14200 */ - 0x0000, /* R14201 */ - 0x0000, /* R14202 */ - 0x0000, /* R14203 */ - 0x0000, /* R14204 */ - 0x0000, /* R14205 */ - 0x0000, /* R14206 */ - 0x0000, /* R14207 */ - 0x0000, /* R14208 */ - 0x0000, /* R14209 */ - 0x0000, /* R14210 */ - 0x0000, /* R14211 */ - 0x0000, /* R14212 */ - 0x0000, /* R14213 */ - 0x0000, /* R14214 */ - 0x0000, /* R14215 */ - 0x0000, /* R14216 */ - 0x0000, /* R14217 */ - 0x0000, /* R14218 */ - 0x0000, /* R14219 */ - 0x0000, /* R14220 */ - 0x0000, /* R14221 */ - 0x0000, /* R14222 */ - 0x0000, /* R14223 */ - 0x0000, /* R14224 */ - 0x0000, /* R14225 */ - 0x0000, /* R14226 */ - 0x0000, /* R14227 */ - 0x0000, /* R14228 */ - 0x0000, /* R14229 */ - 0x0000, /* R14230 */ - 0x0000, /* R14231 */ - 0x0000, /* R14232 */ - 0x0000, /* R14233 */ - 0x0000, /* R14234 */ - 0x0000, /* R14235 */ - 0x0000, /* R14236 */ - 0x0000, /* R14237 */ - 0x0000, /* R14238 */ - 0x0000, /* R14239 */ - 0x0000, /* R14240 */ - 0x0000, /* R14241 */ - 0x0000, /* R14242 */ - 0x0000, /* R14243 */ - 0x0000, /* R14244 */ - 0x0000, /* R14245 */ - 0x0000, /* R14246 */ - 0x0000, /* R14247 */ - 0x0000, /* R14248 */ - 0x0000, /* R14249 */ - 0x0000, /* R14250 */ - 0x0000, /* R14251 */ - 0x0000, /* R14252 */ - 0x0000, /* R14253 */ - 0x0000, /* R14254 */ - 0x0000, /* R14255 */ - 0x0000, /* R14256 */ - 0x0000, /* R14257 */ - 0x0000, /* R14258 */ - 0x0000, /* R14259 */ - 0x0000, /* R14260 */ - 0x0000, /* R14261 */ - 0x0000, /* R14262 */ - 0x0000, /* R14263 */ - 0x0000, /* R14264 */ - 0x0000, /* R14265 */ - 0x0000, /* R14266 */ - 0x0000, /* R14267 */ - 0x0000, /* R14268 */ - 0x0000, /* R14269 */ - 0x0000, /* R14270 */ - 0x0000, /* R14271 */ - 0x0000, /* R14272 */ - 0x0000, /* R14273 */ - 0x0000, /* R14274 */ - 0x0000, /* R14275 */ - 0x0000, /* R14276 */ - 0x0000, /* R14277 */ - 0x0000, /* R14278 */ - 0x0000, /* R14279 */ - 0x0000, /* R14280 */ - 0x0000, /* R14281 */ - 0x0000, /* R14282 */ - 0x0000, /* R14283 */ - 0x0000, /* R14284 */ - 0x0000, /* R14285 */ - 0x0000, /* R14286 */ - 0x0000, /* R14287 */ - 0x0000, /* R14288 */ - 0x0000, /* R14289 */ - 0x0000, /* R14290 */ - 0x0000, /* R14291 */ - 0x0000, /* R14292 */ - 0x0000, /* R14293 */ - 0x0000, /* R14294 */ - 0x0000, /* R14295 */ - 0x0000, /* R14296 */ - 0x0000, /* R14297 */ - 0x0000, /* R14298 */ - 0x0000, /* R14299 */ - 0x0000, /* R14300 */ - 0x0000, /* R14301 */ - 0x0000, /* R14302 */ - 0x0000, /* R14303 */ - 0x0000, /* R14304 */ - 0x0000, /* R14305 */ - 0x0000, /* R14306 */ - 0x0000, /* R14307 */ - 0x0000, /* R14308 */ - 0x0000, /* R14309 */ - 0x0000, /* R14310 */ - 0x0000, /* R14311 */ - 0x0000, /* R14312 */ - 0x0000, /* R14313 */ - 0x0000, /* R14314 */ - 0x0000, /* R14315 */ - 0x0000, /* R14316 */ - 0x0000, /* R14317 */ - 0x0000, /* R14318 */ - 0x0000, /* R14319 */ - 0x0000, /* R14320 */ - 0x0000, /* R14321 */ - 0x0000, /* R14322 */ - 0x0000, /* R14323 */ - 0x0000, /* R14324 */ - 0x0000, /* R14325 */ - 0x0000, /* R14326 */ - 0x0000, /* R14327 */ - 0x0000, /* R14328 */ - 0x0000, /* R14329 */ - 0x0000, /* R14330 */ - 0x0000, /* R14331 */ - 0x0000, /* R14332 */ - 0x0000, /* R14333 */ - 0x0000, /* R14334 */ - 0x0000, /* R14335 */ - 0x0000, /* R14336 - DSP2 Data3 RAM 1 */ - 0x0000, /* R14337 - DSP2 Data3 RAM 0 */ - 0x0000, /* R14338 */ - 0x0000, /* R14339 */ - 0x0000, /* R14340 */ - 0x0000, /* R14341 */ - 0x0000, /* R14342 */ - 0x0000, /* R14343 */ - 0x0000, /* R14344 */ - 0x0000, /* R14345 */ - 0x0000, /* R14346 */ - 0x0000, /* R14347 */ - 0x0000, /* R14348 */ - 0x0000, /* R14349 */ - 0x0000, /* R14350 */ - 0x0000, /* R14351 */ - 0x0000, /* R14352 */ - 0x0000, /* R14353 */ - 0x0000, /* R14354 */ - 0x0000, /* R14355 */ - 0x0000, /* R14356 */ - 0x0000, /* R14357 */ - 0x0000, /* R14358 */ - 0x0000, /* R14359 */ - 0x0000, /* R14360 */ - 0x0000, /* R14361 */ - 0x0000, /* R14362 */ - 0x0000, /* R14363 */ - 0x0000, /* R14364 */ - 0x0000, /* R14365 */ - 0x0000, /* R14366 */ - 0x0000, /* R14367 */ - 0x0000, /* R14368 */ - 0x0000, /* R14369 */ - 0x0000, /* R14370 */ - 0x0000, /* R14371 */ - 0x0000, /* R14372 */ - 0x0000, /* R14373 */ - 0x0000, /* R14374 */ - 0x0000, /* R14375 */ - 0x0000, /* R14376 */ - 0x0000, /* R14377 */ - 0x0000, /* R14378 */ - 0x0000, /* R14379 */ - 0x0000, /* R14380 */ - 0x0000, /* R14381 */ - 0x0000, /* R14382 */ - 0x0000, /* R14383 */ - 0x0000, /* R14384 */ - 0x0000, /* R14385 */ - 0x0000, /* R14386 */ - 0x0000, /* R14387 */ - 0x0000, /* R14388 */ - 0x0000, /* R14389 */ - 0x0000, /* R14390 */ - 0x0000, /* R14391 */ - 0x0000, /* R14392 */ - 0x0000, /* R14393 */ - 0x0000, /* R14394 */ - 0x0000, /* R14395 */ - 0x0000, /* R14396 */ - 0x0000, /* R14397 */ - 0x0000, /* R14398 */ - 0x0000, /* R14399 */ - 0x0000, /* R14400 */ - 0x0000, /* R14401 */ - 0x0000, /* R14402 */ - 0x0000, /* R14403 */ - 0x0000, /* R14404 */ - 0x0000, /* R14405 */ - 0x0000, /* R14406 */ - 0x0000, /* R14407 */ - 0x0000, /* R14408 */ - 0x0000, /* R14409 */ - 0x0000, /* R14410 */ - 0x0000, /* R14411 */ - 0x0000, /* R14412 */ - 0x0000, /* R14413 */ - 0x0000, /* R14414 */ - 0x0000, /* R14415 */ - 0x0000, /* R14416 */ - 0x0000, /* R14417 */ - 0x0000, /* R14418 */ - 0x0000, /* R14419 */ - 0x0000, /* R14420 */ - 0x0000, /* R14421 */ - 0x0000, /* R14422 */ - 0x0000, /* R14423 */ - 0x0000, /* R14424 */ - 0x0000, /* R14425 */ - 0x0000, /* R14426 */ - 0x0000, /* R14427 */ - 0x0000, /* R14428 */ - 0x0000, /* R14429 */ - 0x0000, /* R14430 */ - 0x0000, /* R14431 */ - 0x0000, /* R14432 */ - 0x0000, /* R14433 */ - 0x0000, /* R14434 */ - 0x0000, /* R14435 */ - 0x0000, /* R14436 */ - 0x0000, /* R14437 */ - 0x0000, /* R14438 */ - 0x0000, /* R14439 */ - 0x0000, /* R14440 */ - 0x0000, /* R14441 */ - 0x0000, /* R14442 */ - 0x0000, /* R14443 */ - 0x0000, /* R14444 */ - 0x0000, /* R14445 */ - 0x0000, /* R14446 */ - 0x0000, /* R14447 */ - 0x0000, /* R14448 */ - 0x0000, /* R14449 */ - 0x0000, /* R14450 */ - 0x0000, /* R14451 */ - 0x0000, /* R14452 */ - 0x0000, /* R14453 */ - 0x0000, /* R14454 */ - 0x0000, /* R14455 */ - 0x0000, /* R14456 */ - 0x0000, /* R14457 */ - 0x0000, /* R14458 */ - 0x0000, /* R14459 */ - 0x0000, /* R14460 */ - 0x0000, /* R14461 */ - 0x0000, /* R14462 */ - 0x0000, /* R14463 */ - 0x0000, /* R14464 */ - 0x0000, /* R14465 */ - 0x0000, /* R14466 */ - 0x0000, /* R14467 */ - 0x0000, /* R14468 */ - 0x0000, /* R14469 */ - 0x0000, /* R14470 */ - 0x0000, /* R14471 */ - 0x0000, /* R14472 */ - 0x0000, /* R14473 */ - 0x0000, /* R14474 */ - 0x0000, /* R14475 */ - 0x0000, /* R14476 */ - 0x0000, /* R14477 */ - 0x0000, /* R14478 */ - 0x0000, /* R14479 */ - 0x0000, /* R14480 */ - 0x0000, /* R14481 */ - 0x0000, /* R14482 */ - 0x0000, /* R14483 */ - 0x0000, /* R14484 */ - 0x0000, /* R14485 */ - 0x0000, /* R14486 */ - 0x0000, /* R14487 */ - 0x0000, /* R14488 */ - 0x0000, /* R14489 */ - 0x0000, /* R14490 */ - 0x0000, /* R14491 */ - 0x0000, /* R14492 */ - 0x0000, /* R14493 */ - 0x0000, /* R14494 */ - 0x0000, /* R14495 */ - 0x0000, /* R14496 */ - 0x0000, /* R14497 */ - 0x0000, /* R14498 */ - 0x0000, /* R14499 */ - 0x0000, /* R14500 */ - 0x0000, /* R14501 */ - 0x0000, /* R14502 */ - 0x0000, /* R14503 */ - 0x0000, /* R14504 */ - 0x0000, /* R14505 */ - 0x0000, /* R14506 */ - 0x0000, /* R14507 */ - 0x0000, /* R14508 */ - 0x0000, /* R14509 */ - 0x0000, /* R14510 */ - 0x0000, /* R14511 */ - 0x0000, /* R14512 */ - 0x0000, /* R14513 */ - 0x0000, /* R14514 */ - 0x0000, /* R14515 */ - 0x0000, /* R14516 */ - 0x0000, /* R14517 */ - 0x0000, /* R14518 */ - 0x0000, /* R14519 */ - 0x0000, /* R14520 */ - 0x0000, /* R14521 */ - 0x0000, /* R14522 */ - 0x0000, /* R14523 */ - 0x0000, /* R14524 */ - 0x0000, /* R14525 */ - 0x0000, /* R14526 */ - 0x0000, /* R14527 */ - 0x0000, /* R14528 */ - 0x0000, /* R14529 */ - 0x0000, /* R14530 */ - 0x0000, /* R14531 */ - 0x0000, /* R14532 */ - 0x0000, /* R14533 */ - 0x0000, /* R14534 */ - 0x0000, /* R14535 */ - 0x0000, /* R14536 */ - 0x0000, /* R14537 */ - 0x0000, /* R14538 */ - 0x0000, /* R14539 */ - 0x0000, /* R14540 */ - 0x0000, /* R14541 */ - 0x0000, /* R14542 */ - 0x0000, /* R14543 */ - 0x0000, /* R14544 */ - 0x0000, /* R14545 */ - 0x0000, /* R14546 */ - 0x0000, /* R14547 */ - 0x0000, /* R14548 */ - 0x0000, /* R14549 */ - 0x0000, /* R14550 */ - 0x0000, /* R14551 */ - 0x0000, /* R14552 */ - 0x0000, /* R14553 */ - 0x0000, /* R14554 */ - 0x0000, /* R14555 */ - 0x0000, /* R14556 */ - 0x0000, /* R14557 */ - 0x0000, /* R14558 */ - 0x0000, /* R14559 */ - 0x0000, /* R14560 */ - 0x0000, /* R14561 */ - 0x0000, /* R14562 */ - 0x0000, /* R14563 */ - 0x0000, /* R14564 */ - 0x0000, /* R14565 */ - 0x0000, /* R14566 */ - 0x0000, /* R14567 */ - 0x0000, /* R14568 */ - 0x0000, /* R14569 */ - 0x0000, /* R14570 */ - 0x0000, /* R14571 */ - 0x0000, /* R14572 */ - 0x0000, /* R14573 */ - 0x0000, /* R14574 */ - 0x0000, /* R14575 */ - 0x0000, /* R14576 */ - 0x0000, /* R14577 */ - 0x0000, /* R14578 */ - 0x0000, /* R14579 */ - 0x0000, /* R14580 */ - 0x0000, /* R14581 */ - 0x0000, /* R14582 */ - 0x0000, /* R14583 */ - 0x0000, /* R14584 */ - 0x0000, /* R14585 */ - 0x0000, /* R14586 */ - 0x0000, /* R14587 */ - 0x0000, /* R14588 */ - 0x0000, /* R14589 */ - 0x0000, /* R14590 */ - 0x0000, /* R14591 */ - 0x0000, /* R14592 */ - 0x0000, /* R14593 */ - 0x0000, /* R14594 */ - 0x0000, /* R14595 */ - 0x0000, /* R14596 */ - 0x0000, /* R14597 */ - 0x0000, /* R14598 */ - 0x0000, /* R14599 */ - 0x0000, /* R14600 */ - 0x0000, /* R14601 */ - 0x0000, /* R14602 */ - 0x0000, /* R14603 */ - 0x0000, /* R14604 */ - 0x0000, /* R14605 */ - 0x0000, /* R14606 */ - 0x0000, /* R14607 */ - 0x0000, /* R14608 */ - 0x0000, /* R14609 */ - 0x0000, /* R14610 */ - 0x0000, /* R14611 */ - 0x0000, /* R14612 */ - 0x0000, /* R14613 */ - 0x0000, /* R14614 */ - 0x0000, /* R14615 */ - 0x0000, /* R14616 */ - 0x0000, /* R14617 */ - 0x0000, /* R14618 */ - 0x0000, /* R14619 */ - 0x0000, /* R14620 */ - 0x0000, /* R14621 */ - 0x0000, /* R14622 */ - 0x0000, /* R14623 */ - 0x0000, /* R14624 */ - 0x0000, /* R14625 */ - 0x0000, /* R14626 */ - 0x0000, /* R14627 */ - 0x0000, /* R14628 */ - 0x0000, /* R14629 */ - 0x0000, /* R14630 */ - 0x0000, /* R14631 */ - 0x0000, /* R14632 */ - 0x0000, /* R14633 */ - 0x0000, /* R14634 */ - 0x0000, /* R14635 */ - 0x0000, /* R14636 */ - 0x0000, /* R14637 */ - 0x0000, /* R14638 */ - 0x0000, /* R14639 */ - 0x0000, /* R14640 */ - 0x0000, /* R14641 */ - 0x0000, /* R14642 */ - 0x0000, /* R14643 */ - 0x0000, /* R14644 */ - 0x0000, /* R14645 */ - 0x0000, /* R14646 */ - 0x0000, /* R14647 */ - 0x0000, /* R14648 */ - 0x0000, /* R14649 */ - 0x0000, /* R14650 */ - 0x0000, /* R14651 */ - 0x0000, /* R14652 */ - 0x0000, /* R14653 */ - 0x0000, /* R14654 */ - 0x0000, /* R14655 */ - 0x0000, /* R14656 */ - 0x0000, /* R14657 */ - 0x0000, /* R14658 */ - 0x0000, /* R14659 */ - 0x0000, /* R14660 */ - 0x0000, /* R14661 */ - 0x0000, /* R14662 */ - 0x0000, /* R14663 */ - 0x0000, /* R14664 */ - 0x0000, /* R14665 */ - 0x0000, /* R14666 */ - 0x0000, /* R14667 */ - 0x0000, /* R14668 */ - 0x0000, /* R14669 */ - 0x0000, /* R14670 */ - 0x0000, /* R14671 */ - 0x0000, /* R14672 */ - 0x0000, /* R14673 */ - 0x0000, /* R14674 */ - 0x0000, /* R14675 */ - 0x0000, /* R14676 */ - 0x0000, /* R14677 */ - 0x0000, /* R14678 */ - 0x0000, /* R14679 */ - 0x0000, /* R14680 */ - 0x0000, /* R14681 */ - 0x0000, /* R14682 */ - 0x0000, /* R14683 */ - 0x0000, /* R14684 */ - 0x0000, /* R14685 */ - 0x0000, /* R14686 */ - 0x0000, /* R14687 */ - 0x0000, /* R14688 */ - 0x0000, /* R14689 */ - 0x0000, /* R14690 */ - 0x0000, /* R14691 */ - 0x0000, /* R14692 */ - 0x0000, /* R14693 */ - 0x0000, /* R14694 */ - 0x0000, /* R14695 */ - 0x0000, /* R14696 */ - 0x0000, /* R14697 */ - 0x0000, /* R14698 */ - 0x0000, /* R14699 */ - 0x0000, /* R14700 */ - 0x0000, /* R14701 */ - 0x0000, /* R14702 */ - 0x0000, /* R14703 */ - 0x0000, /* R14704 */ - 0x0000, /* R14705 */ - 0x0000, /* R14706 */ - 0x0000, /* R14707 */ - 0x0000, /* R14708 */ - 0x0000, /* R14709 */ - 0x0000, /* R14710 */ - 0x0000, /* R14711 */ - 0x0000, /* R14712 */ - 0x0000, /* R14713 */ - 0x0000, /* R14714 */ - 0x0000, /* R14715 */ - 0x0000, /* R14716 */ - 0x0000, /* R14717 */ - 0x0000, /* R14718 */ - 0x0000, /* R14719 */ - 0x0000, /* R14720 */ - 0x0000, /* R14721 */ - 0x0000, /* R14722 */ - 0x0000, /* R14723 */ - 0x0000, /* R14724 */ - 0x0000, /* R14725 */ - 0x0000, /* R14726 */ - 0x0000, /* R14727 */ - 0x0000, /* R14728 */ - 0x0000, /* R14729 */ - 0x0000, /* R14730 */ - 0x0000, /* R14731 */ - 0x0000, /* R14732 */ - 0x0000, /* R14733 */ - 0x0000, /* R14734 */ - 0x0000, /* R14735 */ - 0x0000, /* R14736 */ - 0x0000, /* R14737 */ - 0x0000, /* R14738 */ - 0x0000, /* R14739 */ - 0x0000, /* R14740 */ - 0x0000, /* R14741 */ - 0x0000, /* R14742 */ - 0x0000, /* R14743 */ - 0x0000, /* R14744 */ - 0x0000, /* R14745 */ - 0x0000, /* R14746 */ - 0x0000, /* R14747 */ - 0x0000, /* R14748 */ - 0x0000, /* R14749 */ - 0x0000, /* R14750 */ - 0x0000, /* R14751 */ - 0x0000, /* R14752 */ - 0x0000, /* R14753 */ - 0x0000, /* R14754 */ - 0x0000, /* R14755 */ - 0x0000, /* R14756 */ - 0x0000, /* R14757 */ - 0x0000, /* R14758 */ - 0x0000, /* R14759 */ - 0x0000, /* R14760 */ - 0x0000, /* R14761 */ - 0x0000, /* R14762 */ - 0x0000, /* R14763 */ - 0x0000, /* R14764 */ - 0x0000, /* R14765 */ - 0x0000, /* R14766 */ - 0x0000, /* R14767 */ - 0x0000, /* R14768 */ - 0x0000, /* R14769 */ - 0x0000, /* R14770 */ - 0x0000, /* R14771 */ - 0x0000, /* R14772 */ - 0x0000, /* R14773 */ - 0x0000, /* R14774 */ - 0x0000, /* R14775 */ - 0x0000, /* R14776 */ - 0x0000, /* R14777 */ - 0x0000, /* R14778 */ - 0x0000, /* R14779 */ - 0x0000, /* R14780 */ - 0x0000, /* R14781 */ - 0x0000, /* R14782 */ - 0x0000, /* R14783 */ - 0x0000, /* R14784 */ - 0x0000, /* R14785 */ - 0x0000, /* R14786 */ - 0x0000, /* R14787 */ - 0x0000, /* R14788 */ - 0x0000, /* R14789 */ - 0x0000, /* R14790 */ - 0x0000, /* R14791 */ - 0x0000, /* R14792 */ - 0x0000, /* R14793 */ - 0x0000, /* R14794 */ - 0x0000, /* R14795 */ - 0x0000, /* R14796 */ - 0x0000, /* R14797 */ - 0x0000, /* R14798 */ - 0x0000, /* R14799 */ - 0x0000, /* R14800 */ - 0x0000, /* R14801 */ - 0x0000, /* R14802 */ - 0x0000, /* R14803 */ - 0x0000, /* R14804 */ - 0x0000, /* R14805 */ - 0x0000, /* R14806 */ - 0x0000, /* R14807 */ - 0x0000, /* R14808 */ - 0x0000, /* R14809 */ - 0x0000, /* R14810 */ - 0x0000, /* R14811 */ - 0x0000, /* R14812 */ - 0x0000, /* R14813 */ - 0x0000, /* R14814 */ - 0x0000, /* R14815 */ - 0x0000, /* R14816 */ - 0x0000, /* R14817 */ - 0x0000, /* R14818 */ - 0x0000, /* R14819 */ - 0x0000, /* R14820 */ - 0x0000, /* R14821 */ - 0x0000, /* R14822 */ - 0x0000, /* R14823 */ - 0x0000, /* R14824 */ - 0x0000, /* R14825 */ - 0x0000, /* R14826 */ - 0x0000, /* R14827 */ - 0x0000, /* R14828 */ - 0x0000, /* R14829 */ - 0x0000, /* R14830 */ - 0x0000, /* R14831 */ - 0x0000, /* R14832 */ - 0x0000, /* R14833 */ - 0x0000, /* R14834 */ - 0x0000, /* R14835 */ - 0x0000, /* R14836 */ - 0x0000, /* R14837 */ - 0x0000, /* R14838 */ - 0x0000, /* R14839 */ - 0x0000, /* R14840 */ - 0x0000, /* R14841 */ - 0x0000, /* R14842 */ - 0x0000, /* R14843 */ - 0x0000, /* R14844 */ - 0x0000, /* R14845 */ - 0x0000, /* R14846 */ - 0x0000, /* R14847 */ - 0x0000, /* R14848 */ - 0x0000, /* R14849 */ - 0x0000, /* R14850 */ - 0x0000, /* R14851 */ - 0x0000, /* R14852 */ - 0x0000, /* R14853 */ - 0x0000, /* R14854 */ - 0x0000, /* R14855 */ - 0x0000, /* R14856 */ - 0x0000, /* R14857 */ - 0x0000, /* R14858 */ - 0x0000, /* R14859 */ - 0x0000, /* R14860 */ - 0x0000, /* R14861 */ - 0x0000, /* R14862 */ - 0x0000, /* R14863 */ - 0x0000, /* R14864 */ - 0x0000, /* R14865 */ - 0x0000, /* R14866 */ - 0x0000, /* R14867 */ - 0x0000, /* R14868 */ - 0x0000, /* R14869 */ - 0x0000, /* R14870 */ - 0x0000, /* R14871 */ - 0x0000, /* R14872 */ - 0x0000, /* R14873 */ - 0x0000, /* R14874 */ - 0x0000, /* R14875 */ - 0x0000, /* R14876 */ - 0x0000, /* R14877 */ - 0x0000, /* R14878 */ - 0x0000, /* R14879 */ - 0x0000, /* R14880 */ - 0x0000, /* R14881 */ - 0x0000, /* R14882 */ - 0x0000, /* R14883 */ - 0x0000, /* R14884 */ - 0x0000, /* R14885 */ - 0x0000, /* R14886 */ - 0x0000, /* R14887 */ - 0x0000, /* R14888 */ - 0x0000, /* R14889 */ - 0x0000, /* R14890 */ - 0x0000, /* R14891 */ - 0x0000, /* R14892 */ - 0x0000, /* R14893 */ - 0x0000, /* R14894 */ - 0x0000, /* R14895 */ - 0x0000, /* R14896 */ - 0x0000, /* R14897 */ - 0x0000, /* R14898 */ - 0x0000, /* R14899 */ - 0x0000, /* R14900 */ - 0x0000, /* R14901 */ - 0x0000, /* R14902 */ - 0x0000, /* R14903 */ - 0x0000, /* R14904 */ - 0x0000, /* R14905 */ - 0x0000, /* R14906 */ - 0x0000, /* R14907 */ - 0x0000, /* R14908 */ - 0x0000, /* R14909 */ - 0x0000, /* R14910 */ - 0x0000, /* R14911 */ - 0x0000, /* R14912 */ - 0x0000, /* R14913 */ - 0x0000, /* R14914 */ - 0x0000, /* R14915 */ - 0x0000, /* R14916 */ - 0x0000, /* R14917 */ - 0x0000, /* R14918 */ - 0x0000, /* R14919 */ - 0x0000, /* R14920 */ - 0x0000, /* R14921 */ - 0x0000, /* R14922 */ - 0x0000, /* R14923 */ - 0x0000, /* R14924 */ - 0x0000, /* R14925 */ - 0x0000, /* R14926 */ - 0x0000, /* R14927 */ - 0x0000, /* R14928 */ - 0x0000, /* R14929 */ - 0x0000, /* R14930 */ - 0x0000, /* R14931 */ - 0x0000, /* R14932 */ - 0x0000, /* R14933 */ - 0x0000, /* R14934 */ - 0x0000, /* R14935 */ - 0x0000, /* R14936 */ - 0x0000, /* R14937 */ - 0x0000, /* R14938 */ - 0x0000, /* R14939 */ - 0x0000, /* R14940 */ - 0x0000, /* R14941 */ - 0x0000, /* R14942 */ - 0x0000, /* R14943 */ - 0x0000, /* R14944 */ - 0x0000, /* R14945 */ - 0x0000, /* R14946 */ - 0x0000, /* R14947 */ - 0x0000, /* R14948 */ - 0x0000, /* R14949 */ - 0x0000, /* R14950 */ - 0x0000, /* R14951 */ - 0x0000, /* R14952 */ - 0x0000, /* R14953 */ - 0x0000, /* R14954 */ - 0x0000, /* R14955 */ - 0x0000, /* R14956 */ - 0x0000, /* R14957 */ - 0x0000, /* R14958 */ - 0x0000, /* R14959 */ - 0x0000, /* R14960 */ - 0x0000, /* R14961 */ - 0x0000, /* R14962 */ - 0x0000, /* R14963 */ - 0x0000, /* R14964 */ - 0x0000, /* R14965 */ - 0x0000, /* R14966 */ - 0x0000, /* R14967 */ - 0x0000, /* R14968 */ - 0x0000, /* R14969 */ - 0x0000, /* R14970 */ - 0x0000, /* R14971 */ - 0x0000, /* R14972 */ - 0x0000, /* R14973 */ - 0x0000, /* R14974 */ - 0x0000, /* R14975 */ - 0x0000, /* R14976 */ - 0x0000, /* R14977 */ - 0x0000, /* R14978 */ - 0x0000, /* R14979 */ - 0x0000, /* R14980 */ - 0x0000, /* R14981 */ - 0x0000, /* R14982 */ - 0x0000, /* R14983 */ - 0x0000, /* R14984 */ - 0x0000, /* R14985 */ - 0x0000, /* R14986 */ - 0x0000, /* R14987 */ - 0x0000, /* R14988 */ - 0x0000, /* R14989 */ - 0x0000, /* R14990 */ - 0x0000, /* R14991 */ - 0x0000, /* R14992 */ - 0x0000, /* R14993 */ - 0x0000, /* R14994 */ - 0x0000, /* R14995 */ - 0x0000, /* R14996 */ - 0x0000, /* R14997 */ - 0x0000, /* R14998 */ - 0x0000, /* R14999 */ - 0x0000, /* R15000 */ - 0x0000, /* R15001 */ - 0x0000, /* R15002 */ - 0x0000, /* R15003 */ - 0x0000, /* R15004 */ - 0x0000, /* R15005 */ - 0x0000, /* R15006 */ - 0x0000, /* R15007 */ - 0x0000, /* R15008 */ - 0x0000, /* R15009 */ - 0x0000, /* R15010 */ - 0x0000, /* R15011 */ - 0x0000, /* R15012 */ - 0x0000, /* R15013 */ - 0x0000, /* R15014 */ - 0x0000, /* R15015 */ - 0x0000, /* R15016 */ - 0x0000, /* R15017 */ - 0x0000, /* R15018 */ - 0x0000, /* R15019 */ - 0x0000, /* R15020 */ - 0x0000, /* R15021 */ - 0x0000, /* R15022 */ - 0x0000, /* R15023 */ - 0x0000, /* R15024 */ - 0x0000, /* R15025 */ - 0x0000, /* R15026 */ - 0x0000, /* R15027 */ - 0x0000, /* R15028 */ - 0x0000, /* R15029 */ - 0x0000, /* R15030 */ - 0x0000, /* R15031 */ - 0x0000, /* R15032 */ - 0x0000, /* R15033 */ - 0x0000, /* R15034 */ - 0x0000, /* R15035 */ - 0x0000, /* R15036 */ - 0x0000, /* R15037 */ - 0x0000, /* R15038 */ - 0x0000, /* R15039 */ - 0x0000, /* R15040 */ - 0x0000, /* R15041 */ - 0x0000, /* R15042 */ - 0x0000, /* R15043 */ - 0x0000, /* R15044 */ - 0x0000, /* R15045 */ - 0x0000, /* R15046 */ - 0x0000, /* R15047 */ - 0x0000, /* R15048 */ - 0x0000, /* R15049 */ - 0x0000, /* R15050 */ - 0x0000, /* R15051 */ - 0x0000, /* R15052 */ - 0x0000, /* R15053 */ - 0x0000, /* R15054 */ - 0x0000, /* R15055 */ - 0x0000, /* R15056 */ - 0x0000, /* R15057 */ - 0x0000, /* R15058 */ - 0x0000, /* R15059 */ - 0x0000, /* R15060 */ - 0x0000, /* R15061 */ - 0x0000, /* R15062 */ - 0x0000, /* R15063 */ - 0x0000, /* R15064 */ - 0x0000, /* R15065 */ - 0x0000, /* R15066 */ - 0x0000, /* R15067 */ - 0x0000, /* R15068 */ - 0x0000, /* R15069 */ - 0x0000, /* R15070 */ - 0x0000, /* R15071 */ - 0x0000, /* R15072 */ - 0x0000, /* R15073 */ - 0x0000, /* R15074 */ - 0x0000, /* R15075 */ - 0x0000, /* R15076 */ - 0x0000, /* R15077 */ - 0x0000, /* R15078 */ - 0x0000, /* R15079 */ - 0x0000, /* R15080 */ - 0x0000, /* R15081 */ - 0x0000, /* R15082 */ - 0x0000, /* R15083 */ - 0x0000, /* R15084 */ - 0x0000, /* R15085 */ - 0x0000, /* R15086 */ - 0x0000, /* R15087 */ - 0x0000, /* R15088 */ - 0x0000, /* R15089 */ - 0x0000, /* R15090 */ - 0x0000, /* R15091 */ - 0x0000, /* R15092 */ - 0x0000, /* R15093 */ - 0x0000, /* R15094 */ - 0x0000, /* R15095 */ - 0x0000, /* R15096 */ - 0x0000, /* R15097 */ - 0x0000, /* R15098 */ - 0x0000, /* R15099 */ - 0x0000, /* R15100 */ - 0x0000, /* R15101 */ - 0x0000, /* R15102 */ - 0x0000, /* R15103 */ - 0x0000, /* R15104 */ - 0x0000, /* R15105 */ - 0x0000, /* R15106 */ - 0x0000, /* R15107 */ - 0x0000, /* R15108 */ - 0x0000, /* R15109 */ - 0x0000, /* R15110 */ - 0x0000, /* R15111 */ - 0x0000, /* R15112 */ - 0x0000, /* R15113 */ - 0x0000, /* R15114 */ - 0x0000, /* R15115 */ - 0x0000, /* R15116 */ - 0x0000, /* R15117 */ - 0x0000, /* R15118 */ - 0x0000, /* R15119 */ - 0x0000, /* R15120 */ - 0x0000, /* R15121 */ - 0x0000, /* R15122 */ - 0x0000, /* R15123 */ - 0x0000, /* R15124 */ - 0x0000, /* R15125 */ - 0x0000, /* R15126 */ - 0x0000, /* R15127 */ - 0x0000, /* R15128 */ - 0x0000, /* R15129 */ - 0x0000, /* R15130 */ - 0x0000, /* R15131 */ - 0x0000, /* R15132 */ - 0x0000, /* R15133 */ - 0x0000, /* R15134 */ - 0x0000, /* R15135 */ - 0x0000, /* R15136 */ - 0x0000, /* R15137 */ - 0x0000, /* R15138 */ - 0x0000, /* R15139 */ - 0x0000, /* R15140 */ - 0x0000, /* R15141 */ - 0x0000, /* R15142 */ - 0x0000, /* R15143 */ - 0x0000, /* R15144 */ - 0x0000, /* R15145 */ - 0x0000, /* R15146 */ - 0x0000, /* R15147 */ - 0x0000, /* R15148 */ - 0x0000, /* R15149 */ - 0x0000, /* R15150 */ - 0x0000, /* R15151 */ - 0x0000, /* R15152 */ - 0x0000, /* R15153 */ - 0x0000, /* R15154 */ - 0x0000, /* R15155 */ - 0x0000, /* R15156 */ - 0x0000, /* R15157 */ - 0x0000, /* R15158 */ - 0x0000, /* R15159 */ - 0x0000, /* R15160 */ - 0x0000, /* R15161 */ - 0x0000, /* R15162 */ - 0x0000, /* R15163 */ - 0x0000, /* R15164 */ - 0x0000, /* R15165 */ - 0x0000, /* R15166 */ - 0x0000, /* R15167 */ - 0x0000, /* R15168 */ - 0x0000, /* R15169 */ - 0x0000, /* R15170 */ - 0x0000, /* R15171 */ - 0x0000, /* R15172 */ - 0x0000, /* R15173 */ - 0x0000, /* R15174 */ - 0x0000, /* R15175 */ - 0x0000, /* R15176 */ - 0x0000, /* R15177 */ - 0x0000, /* R15178 */ - 0x0000, /* R15179 */ - 0x0000, /* R15180 */ - 0x0000, /* R15181 */ - 0x0000, /* R15182 */ - 0x0000, /* R15183 */ - 0x0000, /* R15184 */ - 0x0000, /* R15185 */ - 0x0000, /* R15186 */ - 0x0000, /* R15187 */ - 0x0000, /* R15188 */ - 0x0000, /* R15189 */ - 0x0000, /* R15190 */ - 0x0000, /* R15191 */ - 0x0000, /* R15192 */ - 0x0000, /* R15193 */ - 0x0000, /* R15194 */ - 0x0000, /* R15195 */ - 0x0000, /* R15196 */ - 0x0000, /* R15197 */ - 0x0000, /* R15198 */ - 0x0000, /* R15199 */ - 0x0000, /* R15200 */ - 0x0000, /* R15201 */ - 0x0000, /* R15202 */ - 0x0000, /* R15203 */ - 0x0000, /* R15204 */ - 0x0000, /* R15205 */ - 0x0000, /* R15206 */ - 0x0000, /* R15207 */ - 0x0000, /* R15208 */ - 0x0000, /* R15209 */ - 0x0000, /* R15210 */ - 0x0000, /* R15211 */ - 0x0000, /* R15212 */ - 0x0000, /* R15213 */ - 0x0000, /* R15214 */ - 0x0000, /* R15215 */ - 0x0000, /* R15216 */ - 0x0000, /* R15217 */ - 0x0000, /* R15218 */ - 0x0000, /* R15219 */ - 0x0000, /* R15220 */ - 0x0000, /* R15221 */ - 0x0000, /* R15222 */ - 0x0000, /* R15223 */ - 0x0000, /* R15224 */ - 0x0000, /* R15225 */ - 0x0000, /* R15226 */ - 0x0000, /* R15227 */ - 0x0000, /* R15228 */ - 0x0000, /* R15229 */ - 0x0000, /* R15230 */ - 0x0000, /* R15231 */ - 0x0000, /* R15232 */ - 0x0000, /* R15233 */ - 0x0000, /* R15234 */ - 0x0000, /* R15235 */ - 0x0000, /* R15236 */ - 0x0000, /* R15237 */ - 0x0000, /* R15238 */ - 0x0000, /* R15239 */ - 0x0000, /* R15240 */ - 0x0000, /* R15241 */ - 0x0000, /* R15242 */ - 0x0000, /* R15243 */ - 0x0000, /* R15244 */ - 0x0000, /* R15245 */ - 0x0000, /* R15246 */ - 0x0000, /* R15247 */ - 0x0000, /* R15248 */ - 0x0000, /* R15249 */ - 0x0000, /* R15250 */ - 0x0000, /* R15251 */ - 0x0000, /* R15252 */ - 0x0000, /* R15253 */ - 0x0000, /* R15254 */ - 0x0000, /* R15255 */ - 0x0000, /* R15256 */ - 0x0000, /* R15257 */ - 0x0000, /* R15258 */ - 0x0000, /* R15259 */ - 0x0000, /* R15260 */ - 0x0000, /* R15261 */ - 0x0000, /* R15262 */ - 0x0000, /* R15263 */ - 0x0000, /* R15264 */ - 0x0000, /* R15265 */ - 0x0000, /* R15266 */ - 0x0000, /* R15267 */ - 0x0000, /* R15268 */ - 0x0000, /* R15269 */ - 0x0000, /* R15270 */ - 0x0000, /* R15271 */ - 0x0000, /* R15272 */ - 0x0000, /* R15273 */ - 0x0000, /* R15274 */ - 0x0000, /* R15275 */ - 0x0000, /* R15276 */ - 0x0000, /* R15277 */ - 0x0000, /* R15278 */ - 0x0000, /* R15279 */ - 0x0000, /* R15280 */ - 0x0000, /* R15281 */ - 0x0000, /* R15282 */ - 0x0000, /* R15283 */ - 0x0000, /* R15284 */ - 0x0000, /* R15285 */ - 0x0000, /* R15286 */ - 0x0000, /* R15287 */ - 0x0000, /* R15288 */ - 0x0000, /* R15289 */ - 0x0000, /* R15290 */ - 0x0000, /* R15291 */ - 0x0000, /* R15292 */ - 0x0000, /* R15293 */ - 0x0000, /* R15294 */ - 0x0000, /* R15295 */ - 0x0000, /* R15296 */ - 0x0000, /* R15297 */ - 0x0000, /* R15298 */ - 0x0000, /* R15299 */ - 0x0000, /* R15300 */ - 0x0000, /* R15301 */ - 0x0000, /* R15302 */ - 0x0000, /* R15303 */ - 0x0000, /* R15304 */ - 0x0000, /* R15305 */ - 0x0000, /* R15306 */ - 0x0000, /* R15307 */ - 0x0000, /* R15308 */ - 0x0000, /* R15309 */ - 0x0000, /* R15310 */ - 0x0000, /* R15311 */ - 0x0000, /* R15312 */ - 0x0000, /* R15313 */ - 0x0000, /* R15314 */ - 0x0000, /* R15315 */ - 0x0000, /* R15316 */ - 0x0000, /* R15317 */ - 0x0000, /* R15318 */ - 0x0000, /* R15319 */ - 0x0000, /* R15320 */ - 0x0000, /* R15321 */ - 0x0000, /* R15322 */ - 0x0000, /* R15323 */ - 0x0000, /* R15324 */ - 0x0000, /* R15325 */ - 0x0000, /* R15326 */ - 0x0000, /* R15327 */ - 0x0000, /* R15328 */ - 0x0000, /* R15329 */ - 0x0000, /* R15330 */ - 0x0000, /* R15331 */ - 0x0000, /* R15332 */ - 0x0000, /* R15333 */ - 0x0000, /* R15334 */ - 0x0000, /* R15335 */ - 0x0000, /* R15336 */ - 0x0000, /* R15337 */ - 0x0000, /* R15338 */ - 0x0000, /* R15339 */ - 0x0000, /* R15340 */ - 0x0000, /* R15341 */ - 0x0000, /* R15342 */ - 0x0000, /* R15343 */ - 0x0000, /* R15344 */ - 0x0000, /* R15345 */ - 0x0000, /* R15346 */ - 0x0000, /* R15347 */ - 0x0000, /* R15348 */ - 0x0000, /* R15349 */ - 0x0000, /* R15350 */ - 0x0000, /* R15351 */ - 0x0000, /* R15352 */ - 0x0000, /* R15353 */ - 0x0000, /* R15354 */ - 0x0000, /* R15355 */ - 0x0000, /* R15356 */ - 0x0000, /* R15357 */ - 0x0000, /* R15358 */ - 0x0000, /* R15359 */ - 0x000A, /* R15360 - DSP2 Coeff RAM 0 */ - 0x0000, /* R15361 */ - 0x0000, /* R15362 */ - 0x0000, /* R15363 */ - 0x0000, /* R15364 */ - 0x0000, /* R15365 */ - 0x0000, /* R15366 */ - 0x0000, /* R15367 */ - 0x0000, /* R15368 */ - 0x0000, /* R15369 */ - 0x0000, /* R15370 */ - 0x0000, /* R15371 */ - 0x0000, /* R15372 */ - 0x0000, /* R15373 */ - 0x0000, /* R15374 */ - 0x0000, /* R15375 */ - 0x0000, /* R15376 */ - 0x0000, /* R15377 */ - 0x0000, /* R15378 */ - 0x0000, /* R15379 */ - 0x0000, /* R15380 */ - 0x0000, /* R15381 */ - 0x0000, /* R15382 */ - 0x0000, /* R15383 */ - 0x0000, /* R15384 */ - 0x0000, /* R15385 */ - 0x0000, /* R15386 */ - 0x0000, /* R15387 */ - 0x0000, /* R15388 */ - 0x0000, /* R15389 */ - 0x0000, /* R15390 */ - 0x0000, /* R15391 */ - 0x0000, /* R15392 */ - 0x0000, /* R15393 */ - 0x0000, /* R15394 */ - 0x0000, /* R15395 */ - 0x0000, /* R15396 */ - 0x0000, /* R15397 */ - 0x0000, /* R15398 */ - 0x0000, /* R15399 */ - 0x0000, /* R15400 */ - 0x0000, /* R15401 */ - 0x0000, /* R15402 */ - 0x0000, /* R15403 */ - 0x0000, /* R15404 */ - 0x0000, /* R15405 */ - 0x0000, /* R15406 */ - 0x0000, /* R15407 */ - 0x0000, /* R15408 */ - 0x0000, /* R15409 */ - 0x0000, /* R15410 */ - 0x0000, /* R15411 */ - 0x0000, /* R15412 */ - 0x0000, /* R15413 */ - 0x0000, /* R15414 */ - 0x0000, /* R15415 */ - 0x0000, /* R15416 */ - 0x0000, /* R15417 */ - 0x0000, /* R15418 */ - 0x0000, /* R15419 */ - 0x0000, /* R15420 */ - 0x0000, /* R15421 */ - 0x0000, /* R15422 */ - 0x0000, /* R15423 */ - 0x0000, /* R15424 */ - 0x0000, /* R15425 */ - 0x0000, /* R15426 */ - 0x0000, /* R15427 */ - 0x0000, /* R15428 */ - 0x0000, /* R15429 */ - 0x0000, /* R15430 */ - 0x0000, /* R15431 */ - 0x0000, /* R15432 */ - 0x0000, /* R15433 */ - 0x0000, /* R15434 */ - 0x0000, /* R15435 */ - 0x0000, /* R15436 */ - 0x0000, /* R15437 */ - 0x0000, /* R15438 */ - 0x0000, /* R15439 */ - 0x0000, /* R15440 */ - 0x0000, /* R15441 */ - 0x0000, /* R15442 */ - 0x0000, /* R15443 */ - 0x0000, /* R15444 */ - 0x0000, /* R15445 */ - 0x0000, /* R15446 */ - 0x0000, /* R15447 */ - 0x0000, /* R15448 */ - 0x0000, /* R15449 */ - 0x0000, /* R15450 */ - 0x0000, /* R15451 */ - 0x0000, /* R15452 */ - 0x0000, /* R15453 */ - 0x0000, /* R15454 */ - 0x0000, /* R15455 */ - 0x0000, /* R15456 */ - 0x0000, /* R15457 */ - 0x0000, /* R15458 */ - 0x0000, /* R15459 */ - 0x0000, /* R15460 */ - 0x0000, /* R15461 */ - 0x0000, /* R15462 */ - 0x0000, /* R15463 */ - 0x0000, /* R15464 */ - 0x0000, /* R15465 */ - 0x0000, /* R15466 */ - 0x0000, /* R15467 */ - 0x0000, /* R15468 */ - 0x0000, /* R15469 */ - 0x0000, /* R15470 */ - 0x0000, /* R15471 */ - 0x0000, /* R15472 */ - 0x0000, /* R15473 */ - 0x0000, /* R15474 */ - 0x0000, /* R15475 */ - 0x0000, /* R15476 */ - 0x0000, /* R15477 */ - 0x0000, /* R15478 */ - 0x0000, /* R15479 */ - 0x0000, /* R15480 */ - 0x0000, /* R15481 */ - 0x0000, /* R15482 */ - 0x0000, /* R15483 */ - 0x0000, /* R15484 */ - 0x0000, /* R15485 */ - 0x0000, /* R15486 */ - 0x0000, /* R15487 */ - 0x0000, /* R15488 */ - 0x0000, /* R15489 */ - 0x0000, /* R15490 */ - 0x0000, /* R15491 */ - 0x0000, /* R15492 */ - 0x0000, /* R15493 */ - 0x0000, /* R15494 */ - 0x0000, /* R15495 */ - 0x0000, /* R15496 */ - 0x0000, /* R15497 */ - 0x0000, /* R15498 */ - 0x0000, /* R15499 */ - 0x0000, /* R15500 */ - 0x0000, /* R15501 */ - 0x0000, /* R15502 */ - 0x0000, /* R15503 */ - 0x0000, /* R15504 */ - 0x0000, /* R15505 */ - 0x0000, /* R15506 */ - 0x0000, /* R15507 */ - 0x0000, /* R15508 */ - 0x0000, /* R15509 */ - 0x0000, /* R15510 */ - 0x0000, /* R15511 */ - 0x0000, /* R15512 */ - 0x0000, /* R15513 */ - 0x0000, /* R15514 */ - 0x0000, /* R15515 */ - 0x0000, /* R15516 */ - 0x0000, /* R15517 */ - 0x0000, /* R15518 */ - 0x0000, /* R15519 */ - 0x0000, /* R15520 */ - 0x0000, /* R15521 */ - 0x0000, /* R15522 */ - 0x0000, /* R15523 */ - 0x0000, /* R15524 */ - 0x0000, /* R15525 */ - 0x0000, /* R15526 */ - 0x0000, /* R15527 */ - 0x0000, /* R15528 */ - 0x0000, /* R15529 */ - 0x0000, /* R15530 */ - 0x0000, /* R15531 */ - 0x0000, /* R15532 */ - 0x0000, /* R15533 */ - 0x0000, /* R15534 */ - 0x0000, /* R15535 */ - 0x0000, /* R15536 */ - 0x0000, /* R15537 */ - 0x0000, /* R15538 */ - 0x0000, /* R15539 */ - 0x0000, /* R15540 */ - 0x0000, /* R15541 */ - 0x0000, /* R15542 */ - 0x0000, /* R15543 */ - 0x0000, /* R15544 */ - 0x0000, /* R15545 */ - 0x0000, /* R15546 */ - 0x0000, /* R15547 */ - 0x0000, /* R15548 */ - 0x0000, /* R15549 */ - 0x0000, /* R15550 */ - 0x0000, /* R15551 */ - 0x0000, /* R15552 */ - 0x0000, /* R15553 */ - 0x0000, /* R15554 */ - 0x0000, /* R15555 */ - 0x0000, /* R15556 */ - 0x0000, /* R15557 */ - 0x0000, /* R15558 */ - 0x0000, /* R15559 */ - 0x0000, /* R15560 */ - 0x0000, /* R15561 */ - 0x0000, /* R15562 */ - 0x0000, /* R15563 */ - 0x0000, /* R15564 */ - 0x0000, /* R15565 */ - 0x0000, /* R15566 */ - 0x0000, /* R15567 */ - 0x0000, /* R15568 */ - 0x0000, /* R15569 */ - 0x0000, /* R15570 */ - 0x0000, /* R15571 */ - 0x0000, /* R15572 */ - 0x0000, /* R15573 */ - 0x0000, /* R15574 */ - 0x0000, /* R15575 */ - 0x0000, /* R15576 */ - 0x0000, /* R15577 */ - 0x0000, /* R15578 */ - 0x0000, /* R15579 */ - 0x0000, /* R15580 */ - 0x0000, /* R15581 */ - 0x0000, /* R15582 */ - 0x0000, /* R15583 */ - 0x0000, /* R15584 */ - 0x0000, /* R15585 */ - 0x0000, /* R15586 */ - 0x0000, /* R15587 */ - 0x0000, /* R15588 */ - 0x0000, /* R15589 */ - 0x0000, /* R15590 */ - 0x0000, /* R15591 */ - 0x0000, /* R15592 */ - 0x0000, /* R15593 */ - 0x0000, /* R15594 */ - 0x0000, /* R15595 */ - 0x0000, /* R15596 */ - 0x0000, /* R15597 */ - 0x0000, /* R15598 */ - 0x0000, /* R15599 */ - 0x0000, /* R15600 */ - 0x0000, /* R15601 */ - 0x0000, /* R15602 */ - 0x0000, /* R15603 */ - 0x0000, /* R15604 */ - 0x0000, /* R15605 */ - 0x0000, /* R15606 */ - 0x0000, /* R15607 */ - 0x0000, /* R15608 */ - 0x0000, /* R15609 */ - 0x0000, /* R15610 */ - 0x0000, /* R15611 */ - 0x0000, /* R15612 */ - 0x0000, /* R15613 */ - 0x0000, /* R15614 */ - 0x0000, /* R15615 */ - 0x0000, /* R15616 */ - 0x0000, /* R15617 */ - 0x0000, /* R15618 */ - 0x0000, /* R15619 */ - 0x0000, /* R15620 */ - 0x0000, /* R15621 */ - 0x0000, /* R15622 */ - 0x0000, /* R15623 */ - 0x0000, /* R15624 */ - 0x0000, /* R15625 */ - 0x0000, /* R15626 */ - 0x0000, /* R15627 */ - 0x0000, /* R15628 */ - 0x0000, /* R15629 */ - 0x0000, /* R15630 */ - 0x0000, /* R15631 */ - 0x0000, /* R15632 */ - 0x0000, /* R15633 */ - 0x0000, /* R15634 */ - 0x0000, /* R15635 */ - 0x0000, /* R15636 */ - 0x0000, /* R15637 */ - 0x0000, /* R15638 */ - 0x0000, /* R15639 */ - 0x0000, /* R15640 */ - 0x0000, /* R15641 */ - 0x0000, /* R15642 */ - 0x0000, /* R15643 */ - 0x0000, /* R15644 */ - 0x0000, /* R15645 */ - 0x0000, /* R15646 */ - 0x0000, /* R15647 */ - 0x0000, /* R15648 */ - 0x0000, /* R15649 */ - 0x0000, /* R15650 */ - 0x0000, /* R15651 */ - 0x0000, /* R15652 */ - 0x0000, /* R15653 */ - 0x0000, /* R15654 */ - 0x0000, /* R15655 */ - 0x0000, /* R15656 */ - 0x0000, /* R15657 */ - 0x0000, /* R15658 */ - 0x0000, /* R15659 */ - 0x0000, /* R15660 */ - 0x0000, /* R15661 */ - 0x0000, /* R15662 */ - 0x0000, /* R15663 */ - 0x0000, /* R15664 */ - 0x0000, /* R15665 */ - 0x0000, /* R15666 */ - 0x0000, /* R15667 */ - 0x0000, /* R15668 */ - 0x0000, /* R15669 */ - 0x0000, /* R15670 */ - 0x0000, /* R15671 */ - 0x0000, /* R15672 */ - 0x0000, /* R15673 */ - 0x0000, /* R15674 */ - 0x0000, /* R15675 */ - 0x0000, /* R15676 */ - 0x0000, /* R15677 */ - 0x0000, /* R15678 */ - 0x0000, /* R15679 */ - 0x0000, /* R15680 */ - 0x0000, /* R15681 */ - 0x0000, /* R15682 */ - 0x0000, /* R15683 */ - 0x0000, /* R15684 */ - 0x0000, /* R15685 */ - 0x0000, /* R15686 */ - 0x0000, /* R15687 */ - 0x0000, /* R15688 */ - 0x0000, /* R15689 */ - 0x0000, /* R15690 */ - 0x0000, /* R15691 */ - 0x0000, /* R15692 */ - 0x0000, /* R15693 */ - 0x0000, /* R15694 */ - 0x0000, /* R15695 */ - 0x0000, /* R15696 */ - 0x0000, /* R15697 */ - 0x0000, /* R15698 */ - 0x0000, /* R15699 */ - 0x0000, /* R15700 */ - 0x0000, /* R15701 */ - 0x0000, /* R15702 */ - 0x0000, /* R15703 */ - 0x0000, /* R15704 */ - 0x0000, /* R15705 */ - 0x0000, /* R15706 */ - 0x0000, /* R15707 */ - 0x0000, /* R15708 */ - 0x0000, /* R15709 */ - 0x0000, /* R15710 */ - 0x0000, /* R15711 */ - 0x0000, /* R15712 */ - 0x0000, /* R15713 */ - 0x0000, /* R15714 */ - 0x0000, /* R15715 */ - 0x0000, /* R15716 */ - 0x0000, /* R15717 */ - 0x0000, /* R15718 */ - 0x0000, /* R15719 */ - 0x0000, /* R15720 */ - 0x0000, /* R15721 */ - 0x0000, /* R15722 */ - 0x0000, /* R15723 */ - 0x0000, /* R15724 */ - 0x0000, /* R15725 */ - 0x0000, /* R15726 */ - 0x0000, /* R15727 */ - 0x0000, /* R15728 */ - 0x0000, /* R15729 */ - 0x0000, /* R15730 */ - 0x0000, /* R15731 */ - 0x0000, /* R15732 */ - 0x0000, /* R15733 */ - 0x0000, /* R15734 */ - 0x0000, /* R15735 */ - 0x0000, /* R15736 */ - 0x0000, /* R15737 */ - 0x0000, /* R15738 */ - 0x0000, /* R15739 */ - 0x0000, /* R15740 */ - 0x0000, /* R15741 */ - 0x0000, /* R15742 */ - 0x0000, /* R15743 */ - 0x0000, /* R15744 */ - 0x0000, /* R15745 */ - 0x0000, /* R15746 */ - 0x0000, /* R15747 */ - 0x0000, /* R15748 */ - 0x0000, /* R15749 */ - 0x0000, /* R15750 */ - 0x0000, /* R15751 */ - 0x0000, /* R15752 */ - 0x0000, /* R15753 */ - 0x0000, /* R15754 */ - 0x0000, /* R15755 */ - 0x0000, /* R15756 */ - 0x0000, /* R15757 */ - 0x0000, /* R15758 */ - 0x0000, /* R15759 */ - 0x0000, /* R15760 */ - 0x0000, /* R15761 */ - 0x0000, /* R15762 */ - 0x0000, /* R15763 */ - 0x0000, /* R15764 */ - 0x0000, /* R15765 */ - 0x0000, /* R15766 */ - 0x0000, /* R15767 */ - 0x0000, /* R15768 */ - 0x0000, /* R15769 */ - 0x0000, /* R15770 */ - 0x0000, /* R15771 */ - 0x0000, /* R15772 */ - 0x0000, /* R15773 */ - 0x0000, /* R15774 */ - 0x0000, /* R15775 */ - 0x0000, /* R15776 */ - 0x0000, /* R15777 */ - 0x0000, /* R15778 */ - 0x0000, /* R15779 */ - 0x0000, /* R15780 */ - 0x0000, /* R15781 */ - 0x0000, /* R15782 */ - 0x0000, /* R15783 */ - 0x0000, /* R15784 */ - 0x0000, /* R15785 */ - 0x0000, /* R15786 */ - 0x0000, /* R15787 */ - 0x0000, /* R15788 */ - 0x0000, /* R15789 */ - 0x0000, /* R15790 */ - 0x0000, /* R15791 */ - 0x0000, /* R15792 */ - 0x0000, /* R15793 */ - 0x0000, /* R15794 */ - 0x0000, /* R15795 */ - 0x0000, /* R15796 */ - 0x0000, /* R15797 */ - 0x0000, /* R15798 */ - 0x0000, /* R15799 */ - 0x0000, /* R15800 */ - 0x0000, /* R15801 */ - 0x0000, /* R15802 */ - 0x0000, /* R15803 */ - 0x0000, /* R15804 */ - 0x0000, /* R15805 */ - 0x0000, /* R15806 */ - 0x0000, /* R15807 */ - 0x0000, /* R15808 */ - 0x0000, /* R15809 */ - 0x0000, /* R15810 */ - 0x0000, /* R15811 */ - 0x0000, /* R15812 */ - 0x0000, /* R15813 */ - 0x0000, /* R15814 */ - 0x0000, /* R15815 */ - 0x0000, /* R15816 */ - 0x0000, /* R15817 */ - 0x0000, /* R15818 */ - 0x0000, /* R15819 */ - 0x0000, /* R15820 */ - 0x0000, /* R15821 */ - 0x0000, /* R15822 */ - 0x0000, /* R15823 */ - 0x0000, /* R15824 */ - 0x0000, /* R15825 */ - 0x0000, /* R15826 */ - 0x0000, /* R15827 */ - 0x0000, /* R15828 */ - 0x0000, /* R15829 */ - 0x0000, /* R15830 */ - 0x0000, /* R15831 */ - 0x0000, /* R15832 */ - 0x0000, /* R15833 */ - 0x0000, /* R15834 */ - 0x0000, /* R15835 */ - 0x0000, /* R15836 */ - 0x0000, /* R15837 */ - 0x0000, /* R15838 */ - 0x0000, /* R15839 */ - 0x0000, /* R15840 */ - 0x0000, /* R15841 */ - 0x0000, /* R15842 */ - 0x0000, /* R15843 */ - 0x0000, /* R15844 */ - 0x0000, /* R15845 */ - 0x0000, /* R15846 */ - 0x0000, /* R15847 */ - 0x0000, /* R15848 */ - 0x0000, /* R15849 */ - 0x0000, /* R15850 */ - 0x0000, /* R15851 */ - 0x0000, /* R15852 */ - 0x0000, /* R15853 */ - 0x0000, /* R15854 */ - 0x0000, /* R15855 */ - 0x0000, /* R15856 */ - 0x0000, /* R15857 */ - 0x0000, /* R15858 */ - 0x0000, /* R15859 */ - 0x0000, /* R15860 */ - 0x0000, /* R15861 */ - 0x0000, /* R15862 */ - 0x0000, /* R15863 */ - 0x0000, /* R15864 */ - 0x0000, /* R15865 */ - 0x0000, /* R15866 */ - 0x0000, /* R15867 */ - 0x0000, /* R15868 */ - 0x0000, /* R15869 */ - 0x0000, /* R15870 */ - 0x0000, /* R15871 */ - 0x0000, /* R15872 */ - 0x0000, /* R15873 */ - 0x0000, /* R15874 */ - 0x0000, /* R15875 */ - 0x0000, /* R15876 */ - 0x0000, /* R15877 */ - 0x0000, /* R15878 */ - 0x0000, /* R15879 */ - 0x0000, /* R15880 */ - 0x0000, /* R15881 */ - 0x0000, /* R15882 */ - 0x0000, /* R15883 */ - 0x0000, /* R15884 */ - 0x0000, /* R15885 */ - 0x0000, /* R15886 */ - 0x0000, /* R15887 */ - 0x0000, /* R15888 */ - 0x0000, /* R15889 */ - 0x0000, /* R15890 */ - 0x0000, /* R15891 */ - 0x0000, /* R15892 */ - 0x0000, /* R15893 */ - 0x0000, /* R15894 */ - 0x0000, /* R15895 */ - 0x0000, /* R15896 */ - 0x0000, /* R15897 */ - 0x0000, /* R15898 */ - 0x0000, /* R15899 */ - 0x0000, /* R15900 */ - 0x0000, /* R15901 */ - 0x0000, /* R15902 */ - 0x0000, /* R15903 */ - 0x0000, /* R15904 */ - 0x0000, /* R15905 */ - 0x0000, /* R15906 */ - 0x0000, /* R15907 */ - 0x0000, /* R15908 */ - 0x0000, /* R15909 */ - 0x0000, /* R15910 */ - 0x0000, /* R15911 */ - 0x0000, /* R15912 */ - 0x0000, /* R15913 */ - 0x0000, /* R15914 */ - 0x0000, /* R15915 */ - 0x0000, /* R15916 */ - 0x0000, /* R15917 */ - 0x0000, /* R15918 */ - 0x0000, /* R15919 */ - 0x0000, /* R15920 */ - 0x0000, /* R15921 */ - 0x0000, /* R15922 */ - 0x0000, /* R15923 */ - 0x0000, /* R15924 */ - 0x0000, /* R15925 */ - 0x0000, /* R15926 */ - 0x0000, /* R15927 */ - 0x0000, /* R15928 */ - 0x0000, /* R15929 */ - 0x0000, /* R15930 */ - 0x0000, /* R15931 */ - 0x0000, /* R15932 */ - 0x0000, /* R15933 */ - 0x0000, /* R15934 */ - 0x0000, /* R15935 */ - 0x0000, /* R15936 */ - 0x0000, /* R15937 */ - 0x0000, /* R15938 */ - 0x0000, /* R15939 */ - 0x0000, /* R15940 */ - 0x0000, /* R15941 */ - 0x0000, /* R15942 */ - 0x0000, /* R15943 */ - 0x0000, /* R15944 */ - 0x0000, /* R15945 */ - 0x0000, /* R15946 */ - 0x0000, /* R15947 */ - 0x0000, /* R15948 */ - 0x0000, /* R15949 */ - 0x0000, /* R15950 */ - 0x0000, /* R15951 */ - 0x0000, /* R15952 */ - 0x0000, /* R15953 */ - 0x0000, /* R15954 */ - 0x0000, /* R15955 */ - 0x0000, /* R15956 */ - 0x0000, /* R15957 */ - 0x0000, /* R15958 */ - 0x0000, /* R15959 */ - 0x0000, /* R15960 */ - 0x0000, /* R15961 */ - 0x0000, /* R15962 */ - 0x0000, /* R15963 */ - 0x0000, /* R15964 */ - 0x0000, /* R15965 */ - 0x0000, /* R15966 */ - 0x0000, /* R15967 */ - 0x0000, /* R15968 */ - 0x0000, /* R15969 */ - 0x0000, /* R15970 */ - 0x0000, /* R15971 */ - 0x0000, /* R15972 */ - 0x0000, /* R15973 */ - 0x0000, /* R15974 */ - 0x0000, /* R15975 */ - 0x0000, /* R15976 */ - 0x0000, /* R15977 */ - 0x0000, /* R15978 */ - 0x0000, /* R15979 */ - 0x0000, /* R15980 */ - 0x0000, /* R15981 */ - 0x0000, /* R15982 */ - 0x0000, /* R15983 */ - 0x0000, /* R15984 */ - 0x0000, /* R15985 */ - 0x0000, /* R15986 */ - 0x0000, /* R15987 */ - 0x0000, /* R15988 */ - 0x0000, /* R15989 */ - 0x0000, /* R15990 */ - 0x0000, /* R15991 */ - 0x0000, /* R15992 */ - 0x0000, /* R15993 */ - 0x0000, /* R15994 */ - 0x0000, /* R15995 */ - 0x0000, /* R15996 */ - 0x0000, /* R15997 */ - 0x0000, /* R15998 */ - 0x0000, /* R15999 */ - 0x0000, /* R16000 */ - 0x0000, /* R16001 */ - 0x0000, /* R16002 */ - 0x0000, /* R16003 */ - 0x0000, /* R16004 */ - 0x0000, /* R16005 */ - 0x0000, /* R16006 */ - 0x0000, /* R16007 */ - 0x0000, /* R16008 */ - 0x0000, /* R16009 */ - 0x0000, /* R16010 */ - 0x0000, /* R16011 */ - 0x0000, /* R16012 */ - 0x0000, /* R16013 */ - 0x0000, /* R16014 */ - 0x0000, /* R16015 */ - 0x0000, /* R16016 */ - 0x0000, /* R16017 */ - 0x0000, /* R16018 */ - 0x0000, /* R16019 */ - 0x0000, /* R16020 */ - 0x0000, /* R16021 */ - 0x0000, /* R16022 */ - 0x0000, /* R16023 */ - 0x0000, /* R16024 */ - 0x0000, /* R16025 */ - 0x0000, /* R16026 */ - 0x0000, /* R16027 */ - 0x0000, /* R16028 */ - 0x0000, /* R16029 */ - 0x0000, /* R16030 */ - 0x0000, /* R16031 */ - 0x0000, /* R16032 */ - 0x0000, /* R16033 */ - 0x0000, /* R16034 */ - 0x0000, /* R16035 */ - 0x0000, /* R16036 */ - 0x0000, /* R16037 */ - 0x0000, /* R16038 */ - 0x0000, /* R16039 */ - 0x0000, /* R16040 */ - 0x0000, /* R16041 */ - 0x0000, /* R16042 */ - 0x0000, /* R16043 */ - 0x0000, /* R16044 */ - 0x0000, /* R16045 */ - 0x0000, /* R16046 */ - 0x0000, /* R16047 */ - 0x0000, /* R16048 */ - 0x0000, /* R16049 */ - 0x0000, /* R16050 */ - 0x0000, /* R16051 */ - 0x0000, /* R16052 */ - 0x0000, /* R16053 */ - 0x0000, /* R16054 */ - 0x0000, /* R16055 */ - 0x0000, /* R16056 */ - 0x0000, /* R16057 */ - 0x0000, /* R16058 */ - 0x0000, /* R16059 */ - 0x0000, /* R16060 */ - 0x0000, /* R16061 */ - 0x0000, /* R16062 */ - 0x0000, /* R16063 */ - 0x0000, /* R16064 */ - 0x0000, /* R16065 */ - 0x0000, /* R16066 */ - 0x0000, /* R16067 */ - 0x0000, /* R16068 */ - 0x0000, /* R16069 */ - 0x0000, /* R16070 */ - 0x0000, /* R16071 */ - 0x0000, /* R16072 */ - 0x0000, /* R16073 */ - 0x0000, /* R16074 */ - 0x0000, /* R16075 */ - 0x0000, /* R16076 */ - 0x0000, /* R16077 */ - 0x0000, /* R16078 */ - 0x0000, /* R16079 */ - 0x0000, /* R16080 */ - 0x0000, /* R16081 */ - 0x0000, /* R16082 */ - 0x0000, /* R16083 */ - 0x0000, /* R16084 */ - 0x0000, /* R16085 */ - 0x0000, /* R16086 */ - 0x0000, /* R16087 */ - 0x0000, /* R16088 */ - 0x0000, /* R16089 */ - 0x0000, /* R16090 */ - 0x0000, /* R16091 */ - 0x0000, /* R16092 */ - 0x0000, /* R16093 */ - 0x0000, /* R16094 */ - 0x0000, /* R16095 */ - 0x0000, /* R16096 */ - 0x0000, /* R16097 */ - 0x0000, /* R16098 */ - 0x0000, /* R16099 */ - 0x0000, /* R16100 */ - 0x0000, /* R16101 */ - 0x0000, /* R16102 */ - 0x0000, /* R16103 */ - 0x0000, /* R16104 */ - 0x0000, /* R16105 */ - 0x0000, /* R16106 */ - 0x0000, /* R16107 */ - 0x0000, /* R16108 */ - 0x0000, /* R16109 */ - 0x0000, /* R16110 */ - 0x0000, /* R16111 */ - 0x0000, /* R16112 */ - 0x0000, /* R16113 */ - 0x0000, /* R16114 */ - 0x0000, /* R16115 */ - 0x0000, /* R16116 */ - 0x0000, /* R16117 */ - 0x0000, /* R16118 */ - 0x0000, /* R16119 */ - 0x0000, /* R16120 */ - 0x0000, /* R16121 */ - 0x0000, /* R16122 */ - 0x0000, /* R16123 */ - 0x0000, /* R16124 */ - 0x0000, /* R16125 */ - 0x0000, /* R16126 */ - 0x0000, /* R16127 */ - 0x0000, /* R16128 */ - 0x0000, /* R16129 */ - 0x0000, /* R16130 */ - 0x0000, /* R16131 */ - 0x0000, /* R16132 */ - 0x0000, /* R16133 */ - 0x0000, /* R16134 */ - 0x0000, /* R16135 */ - 0x0000, /* R16136 */ - 0x0000, /* R16137 */ - 0x0000, /* R16138 */ - 0x0000, /* R16139 */ - 0x0000, /* R16140 */ - 0x0000, /* R16141 */ - 0x0000, /* R16142 */ - 0x0000, /* R16143 */ - 0x0000, /* R16144 */ - 0x0000, /* R16145 */ - 0x0000, /* R16146 */ - 0x0000, /* R16147 */ - 0x0000, /* R16148 */ - 0x0000, /* R16149 */ - 0x0000, /* R16150 */ - 0x0000, /* R16151 */ - 0x0000, /* R16152 */ - 0x0000, /* R16153 */ - 0x0000, /* R16154 */ - 0x0000, /* R16155 */ - 0x0000, /* R16156 */ - 0x0000, /* R16157 */ - 0x0000, /* R16158 */ - 0x0000, /* R16159 */ - 0x0000, /* R16160 */ - 0x0000, /* R16161 */ - 0x0000, /* R16162 */ - 0x0000, /* R16163 */ - 0x0000, /* R16164 */ - 0x0000, /* R16165 */ - 0x0000, /* R16166 */ - 0x0000, /* R16167 */ - 0x0000, /* R16168 */ - 0x0000, /* R16169 */ - 0x0000, /* R16170 */ - 0x0000, /* R16171 */ - 0x0000, /* R16172 */ - 0x0000, /* R16173 */ - 0x0000, /* R16174 */ - 0x0000, /* R16175 */ - 0x0000, /* R16176 */ - 0x0000, /* R16177 */ - 0x0000, /* R16178 */ - 0x0000, /* R16179 */ - 0x0000, /* R16180 */ - 0x0000, /* R16181 */ - 0x0000, /* R16182 */ - 0x0000, /* R16183 */ - 0x0000, /* R16184 */ - 0x0000, /* R16185 */ - 0x0000, /* R16186 */ - 0x0000, /* R16187 */ - 0x0000, /* R16188 */ - 0x0000, /* R16189 */ - 0x0000, /* R16190 */ - 0x0000, /* R16191 */ - 0x0000, /* R16192 */ - 0x0000, /* R16193 */ - 0x0000, /* R16194 */ - 0x0000, /* R16195 */ - 0x0000, /* R16196 */ - 0x0000, /* R16197 */ - 0x0000, /* R16198 */ - 0x0000, /* R16199 */ - 0x0000, /* R16200 */ - 0x0000, /* R16201 */ - 0x0000, /* R16202 */ - 0x0000, /* R16203 */ - 0x0000, /* R16204 */ - 0x0000, /* R16205 */ - 0x0000, /* R16206 */ - 0x0000, /* R16207 */ - 0x0000, /* R16208 */ - 0x0000, /* R16209 */ - 0x0000, /* R16210 */ - 0x0000, /* R16211 */ - 0x0000, /* R16212 */ - 0x0000, /* R16213 */ - 0x0000, /* R16214 */ - 0x0000, /* R16215 */ - 0x0000, /* R16216 */ - 0x0000, /* R16217 */ - 0x0000, /* R16218 */ - 0x0000, /* R16219 */ - 0x0000, /* R16220 */ - 0x0000, /* R16221 */ - 0x0000, /* R16222 */ - 0x0000, /* R16223 */ - 0x0000, /* R16224 */ - 0x0000, /* R16225 */ - 0x0000, /* R16226 */ - 0x0000, /* R16227 */ - 0x0000, /* R16228 */ - 0x0000, /* R16229 */ - 0x0000, /* R16230 */ - 0x0000, /* R16231 */ - 0x0000, /* R16232 */ - 0x0000, /* R16233 */ - 0x0000, /* R16234 */ - 0x0000, /* R16235 */ - 0x0000, /* R16236 */ - 0x0000, /* R16237 */ - 0x0000, /* R16238 */ - 0x0000, /* R16239 */ - 0x0000, /* R16240 */ - 0x0000, /* R16241 */ - 0x0000, /* R16242 */ - 0x0000, /* R16243 */ - 0x0000, /* R16244 */ - 0x0000, /* R16245 */ - 0x0000, /* R16246 */ - 0x0000, /* R16247 */ - 0x0000, /* R16248 */ - 0x0000, /* R16249 */ - 0x0000, /* R16250 */ - 0x0000, /* R16251 */ - 0x0000, /* R16252 */ - 0x0000, /* R16253 */ - 0x0000, /* R16254 */ - 0x0000, /* R16255 */ - 0x0000, /* R16256 */ - 0x0000, /* R16257 */ - 0x0000, /* R16258 */ - 0x0000, /* R16259 */ - 0x0000, /* R16260 */ - 0x0000, /* R16261 */ - 0x0000, /* R16262 */ - 0x0000, /* R16263 */ - 0x0000, /* R16264 */ - 0x0000, /* R16265 */ - 0x0000, /* R16266 */ - 0x0000, /* R16267 */ - 0x0000, /* R16268 */ - 0x0000, /* R16269 */ - 0x0000, /* R16270 */ - 0x0000, /* R16271 */ - 0x0000, /* R16272 */ - 0x0000, /* R16273 */ - 0x0000, /* R16274 */ - 0x0000, /* R16275 */ - 0x0000, /* R16276 */ - 0x0000, /* R16277 */ - 0x0000, /* R16278 */ - 0x0000, /* R16279 */ - 0x0000, /* R16280 */ - 0x0000, /* R16281 */ - 0x0000, /* R16282 */ - 0x0000, /* R16283 */ - 0x0000, /* R16284 */ - 0x0000, /* R16285 */ - 0x0000, /* R16286 */ - 0x0000, /* R16287 */ - 0x0000, /* R16288 */ - 0x0000, /* R16289 */ - 0x0000, /* R16290 */ - 0x0000, /* R16291 */ - 0x0000, /* R16292 */ - 0x0000, /* R16293 */ - 0x0000, /* R16294 */ - 0x0000, /* R16295 */ - 0x0000, /* R16296 */ - 0x0000, /* R16297 */ - 0x0000, /* R16298 */ - 0x0000, /* R16299 */ - 0x0000, /* R16300 */ - 0x0000, /* R16301 */ - 0x0000, /* R16302 */ - 0x0000, /* R16303 */ - 0x0000, /* R16304 */ - 0x0000, /* R16305 */ - 0x0000, /* R16306 */ - 0x0000, /* R16307 */ - 0x0000, /* R16308 */ - 0x0000, /* R16309 */ - 0x0000, /* R16310 */ - 0x0000, /* R16311 */ - 0x0000, /* R16312 */ - 0x0000, /* R16313 */ - 0x0000, /* R16314 */ - 0x0000, /* R16315 */ - 0x0000, /* R16316 */ - 0x0000, /* R16317 */ - 0x0000, /* R16318 */ - 0x0000, /* R16319 */ - 0x0000, /* R16320 */ - 0x0000, /* R16321 */ - 0x0000, /* R16322 */ - 0x0000, /* R16323 */ - 0x0000, /* R16324 */ - 0x0000, /* R16325 */ - 0x0000, /* R16326 */ - 0x0000, /* R16327 */ - 0x0000, /* R16328 */ - 0x0000, /* R16329 */ - 0x0000, /* R16330 */ - 0x0000, /* R16331 */ - 0x0000, /* R16332 */ - 0x0000, /* R16333 */ - 0x0000, /* R16334 */ - 0x0000, /* R16335 */ - 0x0000, /* R16336 */ - 0x0000, /* R16337 */ - 0x0000, /* R16338 */ - 0x0000, /* R16339 */ - 0x0000, /* R16340 */ - 0x0000, /* R16341 */ - 0x0000, /* R16342 */ - 0x0000, /* R16343 */ - 0x0000, /* R16344 */ - 0x0000, /* R16345 */ - 0x0000, /* R16346 */ - 0x0000, /* R16347 */ - 0x0000, /* R16348 */ - 0x0000, /* R16349 */ - 0x0000, /* R16350 */ - 0x0000, /* R16351 */ - 0x0000, /* R16352 */ - 0x0000, /* R16353 */ - 0x0000, /* R16354 */ - 0x0000, /* R16355 */ - 0x0000, /* R16356 */ - 0x0000, /* R16357 */ - 0x0000, /* R16358 */ - 0x0000, /* R16359 */ - 0x0000, /* R16360 */ - 0x0000, /* R16361 */ - 0x0000, /* R16362 */ - 0x0000, /* R16363 */ - 0x0000, /* R16364 */ - 0x0000, /* R16365 */ - 0x0000, /* R16366 */ - 0x0000, /* R16367 */ - 0x0000, /* R16368 */ - 0x0000, /* R16369 */ - 0x0000, /* R16370 */ - 0x0000, /* R16371 */ - 0x0000, /* R16372 */ - 0x0000, /* R16373 */ - 0x0000, /* R16374 */ - 0x0000, /* R16375 */ - 0x0000, /* R16376 */ - 0x0000, /* R16377 */ - 0x0000, /* R16378 */ - 0x0000, /* R16379 */ - 0x0000, /* R16380 */ - 0x0000, /* R16381 */ - 0x0000, /* R16382 */ - 0x0000, /* R16383 */ - 0x0000, /* R16384 - RETUNEADC_SHARED_COEFF_1 */ - 0x0000, /* R16385 - RETUNEADC_SHARED_COEFF_0 */ - 0x0000, /* R16386 - RETUNEDAC_SHARED_COEFF_1 */ - 0x0000, /* R16387 - RETUNEDAC_SHARED_COEFF_0 */ - 0x0000, /* R16388 - SOUNDSTAGE_ENABLES_1 */ - 0x0000, /* R16389 - SOUNDSTAGE_ENABLES_0 */ - 0x0000, /* R16390 */ - 0x0000, /* R16391 */ - 0x0000, /* R16392 */ - 0x0000, /* R16393 */ - 0x0000, /* R16394 */ - 0x0000, /* R16395 */ - 0x0000, /* R16396 */ - 0x0000, /* R16397 */ - 0x0000, /* R16398 */ - 0x0000, /* R16399 */ - 0x0000, /* R16400 */ - 0x0000, /* R16401 */ - 0x0000, /* R16402 */ - 0x0000, /* R16403 */ - 0x0000, /* R16404 */ - 0x0000, /* R16405 */ - 0x0000, /* R16406 */ - 0x0000, /* R16407 */ - 0x0000, /* R16408 */ - 0x0000, /* R16409 */ - 0x0000, /* R16410 */ - 0x0000, /* R16411 */ - 0x0000, /* R16412 */ - 0x0000, /* R16413 */ - 0x0000, /* R16414 */ - 0x0000, /* R16415 */ - 0x0000, /* R16416 */ - 0x0000, /* R16417 */ - 0x0000, /* R16418 */ - 0x0000, /* R16419 */ - 0x0000, /* R16420 */ - 0x0000, /* R16421 */ - 0x0000, /* R16422 */ - 0x0000, /* R16423 */ - 0x0000, /* R16424 */ - 0x0000, /* R16425 */ - 0x0000, /* R16426 */ - 0x0000, /* R16427 */ - 0x0000, /* R16428 */ - 0x0000, /* R16429 */ - 0x0000, /* R16430 */ - 0x0000, /* R16431 */ - 0x0000, /* R16432 */ - 0x0000, /* R16433 */ - 0x0000, /* R16434 */ - 0x0000, /* R16435 */ - 0x0000, /* R16436 */ - 0x0000, /* R16437 */ - 0x0000, /* R16438 */ - 0x0000, /* R16439 */ - 0x0000, /* R16440 */ - 0x0000, /* R16441 */ - 0x0000, /* R16442 */ - 0x0000, /* R16443 */ - 0x0000, /* R16444 */ - 0x0000, /* R16445 */ - 0x0000, /* R16446 */ - 0x0000, /* R16447 */ - 0x0000, /* R16448 */ - 0x0000, /* R16449 */ - 0x0000, /* R16450 */ - 0x0000, /* R16451 */ - 0x0000, /* R16452 */ - 0x0000, /* R16453 */ - 0x0000, /* R16454 */ - 0x0000, /* R16455 */ - 0x0000, /* R16456 */ - 0x0000, /* R16457 */ - 0x0000, /* R16458 */ - 0x0000, /* R16459 */ - 0x0000, /* R16460 */ - 0x0000, /* R16461 */ - 0x0000, /* R16462 */ - 0x0000, /* R16463 */ - 0x0000, /* R16464 */ - 0x0000, /* R16465 */ - 0x0000, /* R16466 */ - 0x0000, /* R16467 */ - 0x0000, /* R16468 */ - 0x0000, /* R16469 */ - 0x0000, /* R16470 */ - 0x0000, /* R16471 */ - 0x0000, /* R16472 */ - 0x0000, /* R16473 */ - 0x0000, /* R16474 */ - 0x0000, /* R16475 */ - 0x0000, /* R16476 */ - 0x0000, /* R16477 */ - 0x0000, /* R16478 */ - 0x0000, /* R16479 */ - 0x0000, /* R16480 */ - 0x0000, /* R16481 */ - 0x0000, /* R16482 */ - 0x0000, /* R16483 */ - 0x0000, /* R16484 */ - 0x0000, /* R16485 */ - 0x0000, /* R16486 */ - 0x0000, /* R16487 */ - 0x0000, /* R16488 */ - 0x0000, /* R16489 */ - 0x0000, /* R16490 */ - 0x0000, /* R16491 */ - 0x0000, /* R16492 */ - 0x0000, /* R16493 */ - 0x0000, /* R16494 */ - 0x0000, /* R16495 */ - 0x0000, /* R16496 */ - 0x0000, /* R16497 */ - 0x0000, /* R16498 */ - 0x0000, /* R16499 */ - 0x0000, /* R16500 */ - 0x0000, /* R16501 */ - 0x0000, /* R16502 */ - 0x0000, /* R16503 */ - 0x0000, /* R16504 */ - 0x0000, /* R16505 */ - 0x0000, /* R16506 */ - 0x0000, /* R16507 */ - 0x0000, /* R16508 */ - 0x0000, /* R16509 */ - 0x0000, /* R16510 */ - 0x0000, /* R16511 */ - 0x0000, /* R16512 */ - 0x0000, /* R16513 */ - 0x0000, /* R16514 */ - 0x0000, /* R16515 */ - 0x0000, /* R16516 */ - 0x0000, /* R16517 */ - 0x0000, /* R16518 */ - 0x0000, /* R16519 */ - 0x0000, /* R16520 */ - 0x0000, /* R16521 */ - 0x0000, /* R16522 */ - 0x0000, /* R16523 */ - 0x0000, /* R16524 */ - 0x0000, /* R16525 */ - 0x0000, /* R16526 */ - 0x0000, /* R16527 */ - 0x0000, /* R16528 */ - 0x0000, /* R16529 */ - 0x0000, /* R16530 */ - 0x0000, /* R16531 */ - 0x0000, /* R16532 */ - 0x0000, /* R16533 */ - 0x0000, /* R16534 */ - 0x0000, /* R16535 */ - 0x0000, /* R16536 */ - 0x0000, /* R16537 */ - 0x0000, /* R16538 */ - 0x0000, /* R16539 */ - 0x0000, /* R16540 */ - 0x0000, /* R16541 */ - 0x0000, /* R16542 */ - 0x0000, /* R16543 */ - 0x0000, /* R16544 */ - 0x0000, /* R16545 */ - 0x0000, /* R16546 */ - 0x0000, /* R16547 */ - 0x0000, /* R16548 */ - 0x0000, /* R16549 */ - 0x0000, /* R16550 */ - 0x0000, /* R16551 */ - 0x0000, /* R16552 */ - 0x0000, /* R16553 */ - 0x0000, /* R16554 */ - 0x0000, /* R16555 */ - 0x0000, /* R16556 */ - 0x0000, /* R16557 */ - 0x0000, /* R16558 */ - 0x0000, /* R16559 */ - 0x0000, /* R16560 */ - 0x0000, /* R16561 */ - 0x0000, /* R16562 */ - 0x0000, /* R16563 */ - 0x0000, /* R16564 */ - 0x0000, /* R16565 */ - 0x0000, /* R16566 */ - 0x0000, /* R16567 */ - 0x0000, /* R16568 */ - 0x0000, /* R16569 */ - 0x0000, /* R16570 */ - 0x0000, /* R16571 */ - 0x0000, /* R16572 */ - 0x0000, /* R16573 */ - 0x0000, /* R16574 */ - 0x0000, /* R16575 */ - 0x0000, /* R16576 */ - 0x0000, /* R16577 */ - 0x0000, /* R16578 */ - 0x0000, /* R16579 */ - 0x0000, /* R16580 */ - 0x0000, /* R16581 */ - 0x0000, /* R16582 */ - 0x0000, /* R16583 */ - 0x0000, /* R16584 */ - 0x0000, /* R16585 */ - 0x0000, /* R16586 */ - 0x0000, /* R16587 */ - 0x0000, /* R16588 */ - 0x0000, /* R16589 */ - 0x0000, /* R16590 */ - 0x0000, /* R16591 */ - 0x0000, /* R16592 */ - 0x0000, /* R16593 */ - 0x0000, /* R16594 */ - 0x0000, /* R16595 */ - 0x0000, /* R16596 */ - 0x0000, /* R16597 */ - 0x0000, /* R16598 */ - 0x0000, /* R16599 */ - 0x0000, /* R16600 */ - 0x0000, /* R16601 */ - 0x0000, /* R16602 */ - 0x0000, /* R16603 */ - 0x0000, /* R16604 */ - 0x0000, /* R16605 */ - 0x0000, /* R16606 */ - 0x0000, /* R16607 */ - 0x0000, /* R16608 */ - 0x0000, /* R16609 */ - 0x0000, /* R16610 */ - 0x0000, /* R16611 */ - 0x0000, /* R16612 */ - 0x0000, /* R16613 */ - 0x0000, /* R16614 */ - 0x0000, /* R16615 */ - 0x0000, /* R16616 */ - 0x0000, /* R16617 */ - 0x0000, /* R16618 */ - 0x0000, /* R16619 */ - 0x0000, /* R16620 */ - 0x0000, /* R16621 */ - 0x0000, /* R16622 */ - 0x0000, /* R16623 */ - 0x0000, /* R16624 */ - 0x0000, /* R16625 */ - 0x0000, /* R16626 */ - 0x0000, /* R16627 */ - 0x0000, /* R16628 */ - 0x0000, /* R16629 */ - 0x0000, /* R16630 */ - 0x0000, /* R16631 */ - 0x0000, /* R16632 */ - 0x0000, /* R16633 */ - 0x0000, /* R16634 */ - 0x0000, /* R16635 */ - 0x0000, /* R16636 */ - 0x0000, /* R16637 */ - 0x0000, /* R16638 */ - 0x0000, /* R16639 */ - 0x0000, /* R16640 */ - 0x0000, /* R16641 */ - 0x0000, /* R16642 */ - 0x0000, /* R16643 */ - 0x0000, /* R16644 */ - 0x0000, /* R16645 */ - 0x0000, /* R16646 */ - 0x0000, /* R16647 */ - 0x0000, /* R16648 */ - 0x0000, /* R16649 */ - 0x0000, /* R16650 */ - 0x0000, /* R16651 */ - 0x0000, /* R16652 */ - 0x0000, /* R16653 */ - 0x0000, /* R16654 */ - 0x0000, /* R16655 */ - 0x0000, /* R16656 */ - 0x0000, /* R16657 */ - 0x0000, /* R16658 */ - 0x0000, /* R16659 */ - 0x0000, /* R16660 */ - 0x0000, /* R16661 */ - 0x0000, /* R16662 */ - 0x0000, /* R16663 */ - 0x0000, /* R16664 */ - 0x0000, /* R16665 */ - 0x0000, /* R16666 */ - 0x0000, /* R16667 */ - 0x0000, /* R16668 */ - 0x0000, /* R16669 */ - 0x0000, /* R16670 */ - 0x0000, /* R16671 */ - 0x0000, /* R16672 */ - 0x0000, /* R16673 */ - 0x0000, /* R16674 */ - 0x0000, /* R16675 */ - 0x0000, /* R16676 */ - 0x0000, /* R16677 */ - 0x0000, /* R16678 */ - 0x0000, /* R16679 */ - 0x0000, /* R16680 */ - 0x0000, /* R16681 */ - 0x0000, /* R16682 */ - 0x0000, /* R16683 */ - 0x0000, /* R16684 */ - 0x0000, /* R16685 */ - 0x0000, /* R16686 */ - 0x0000, /* R16687 */ - 0x0000, /* R16688 */ - 0x0000, /* R16689 */ - 0x0000, /* R16690 */ - 0x0000, /* R16691 */ - 0x0000, /* R16692 */ - 0x0000, /* R16693 */ - 0x0000, /* R16694 */ - 0x0000, /* R16695 */ - 0x0000, /* R16696 */ - 0x0000, /* R16697 */ - 0x0000, /* R16698 */ - 0x0000, /* R16699 */ - 0x0000, /* R16700 */ - 0x0000, /* R16701 */ - 0x0000, /* R16702 */ - 0x0000, /* R16703 */ - 0x0000, /* R16704 */ - 0x0000, /* R16705 */ - 0x0000, /* R16706 */ - 0x0000, /* R16707 */ - 0x0000, /* R16708 */ - 0x0000, /* R16709 */ - 0x0000, /* R16710 */ - 0x0000, /* R16711 */ - 0x0000, /* R16712 */ - 0x0000, /* R16713 */ - 0x0000, /* R16714 */ - 0x0000, /* R16715 */ - 0x0000, /* R16716 */ - 0x0000, /* R16717 */ - 0x0000, /* R16718 */ - 0x0000, /* R16719 */ - 0x0000, /* R16720 */ - 0x0000, /* R16721 */ - 0x0000, /* R16722 */ - 0x0000, /* R16723 */ - 0x0000, /* R16724 */ - 0x0000, /* R16725 */ - 0x0000, /* R16726 */ - 0x0000, /* R16727 */ - 0x0000, /* R16728 */ - 0x0000, /* R16729 */ - 0x0000, /* R16730 */ - 0x0000, /* R16731 */ - 0x0000, /* R16732 */ - 0x0000, /* R16733 */ - 0x0000, /* R16734 */ - 0x0000, /* R16735 */ - 0x0000, /* R16736 */ - 0x0000, /* R16737 */ - 0x0000, /* R16738 */ - 0x0000, /* R16739 */ - 0x0000, /* R16740 */ - 0x0000, /* R16741 */ - 0x0000, /* R16742 */ - 0x0000, /* R16743 */ - 0x0000, /* R16744 */ - 0x0000, /* R16745 */ - 0x0000, /* R16746 */ - 0x0000, /* R16747 */ - 0x0000, /* R16748 */ - 0x0000, /* R16749 */ - 0x0000, /* R16750 */ - 0x0000, /* R16751 */ - 0x0000, /* R16752 */ - 0x0000, /* R16753 */ - 0x0000, /* R16754 */ - 0x0000, /* R16755 */ - 0x0000, /* R16756 */ - 0x0000, /* R16757 */ - 0x0000, /* R16758 */ - 0x0000, /* R16759 */ - 0x0000, /* R16760 */ - 0x0000, /* R16761 */ - 0x0000, /* R16762 */ - 0x0000, /* R16763 */ - 0x0000, /* R16764 */ - 0x0000, /* R16765 */ - 0x0000, /* R16766 */ - 0x0000, /* R16767 */ - 0x0000, /* R16768 */ - 0x0000, /* R16769 */ - 0x0000, /* R16770 */ - 0x0000, /* R16771 */ - 0x0000, /* R16772 */ - 0x0000, /* R16773 */ - 0x0000, /* R16774 */ - 0x0000, /* R16775 */ - 0x0000, /* R16776 */ - 0x0000, /* R16777 */ - 0x0000, /* R16778 */ - 0x0000, /* R16779 */ - 0x0000, /* R16780 */ - 0x0000, /* R16781 */ - 0x0000, /* R16782 */ - 0x0000, /* R16783 */ - 0x0000, /* R16784 */ - 0x0000, /* R16785 */ - 0x0000, /* R16786 */ - 0x0000, /* R16787 */ - 0x0000, /* R16788 */ - 0x0000, /* R16789 */ - 0x0000, /* R16790 */ - 0x0000, /* R16791 */ - 0x0000, /* R16792 */ - 0x0000, /* R16793 */ - 0x0000, /* R16794 */ - 0x0000, /* R16795 */ - 0x0000, /* R16796 */ - 0x0000, /* R16797 */ - 0x0000, /* R16798 */ - 0x0000, /* R16799 */ - 0x0000, /* R16800 */ - 0x0000, /* R16801 */ - 0x0000, /* R16802 */ - 0x0000, /* R16803 */ - 0x0000, /* R16804 */ - 0x0000, /* R16805 */ - 0x0000, /* R16806 */ - 0x0000, /* R16807 */ - 0x0000, /* R16808 */ - 0x0000, /* R16809 */ - 0x0000, /* R16810 */ - 0x0000, /* R16811 */ - 0x0000, /* R16812 */ - 0x0000, /* R16813 */ - 0x0000, /* R16814 */ - 0x0000, /* R16815 */ - 0x0000, /* R16816 */ - 0x0000, /* R16817 */ - 0x0000, /* R16818 */ - 0x0000, /* R16819 */ - 0x0000, /* R16820 */ - 0x0000, /* R16821 */ - 0x0000, /* R16822 */ - 0x0000, /* R16823 */ - 0x0000, /* R16824 */ - 0x0000, /* R16825 */ - 0x0000, /* R16826 */ - 0x0000, /* R16827 */ - 0x0000, /* R16828 */ - 0x0000, /* R16829 */ - 0x0000, /* R16830 */ - 0x0000, /* R16831 */ - 0x0000, /* R16832 */ - 0x0000, /* R16833 */ - 0x0000, /* R16834 */ - 0x0000, /* R16835 */ - 0x0000, /* R16836 */ - 0x0000, /* R16837 */ - 0x0000, /* R16838 */ - 0x0000, /* R16839 */ - 0x0000, /* R16840 */ - 0x0000, /* R16841 */ - 0x0000, /* R16842 */ - 0x0000, /* R16843 */ - 0x0000, /* R16844 */ - 0x0000, /* R16845 */ - 0x0000, /* R16846 */ - 0x0000, /* R16847 */ - 0x0000, /* R16848 */ - 0x0000, /* R16849 */ - 0x0000, /* R16850 */ - 0x0000, /* R16851 */ - 0x0000, /* R16852 */ - 0x0000, /* R16853 */ - 0x0000, /* R16854 */ - 0x0000, /* R16855 */ - 0x0000, /* R16856 */ - 0x0000, /* R16857 */ - 0x0000, /* R16858 */ - 0x0000, /* R16859 */ - 0x0000, /* R16860 */ - 0x0000, /* R16861 */ - 0x0000, /* R16862 */ - 0x0000, /* R16863 */ - 0x0000, /* R16864 */ - 0x0000, /* R16865 */ - 0x0000, /* R16866 */ - 0x0000, /* R16867 */ - 0x0000, /* R16868 */ - 0x0000, /* R16869 */ - 0x0000, /* R16870 */ - 0x0000, /* R16871 */ - 0x0000, /* R16872 */ - 0x0000, /* R16873 */ - 0x0000, /* R16874 */ - 0x0000, /* R16875 */ - 0x0000, /* R16876 */ - 0x0000, /* R16877 */ - 0x0000, /* R16878 */ - 0x0000, /* R16879 */ - 0x0000, /* R16880 */ - 0x0000, /* R16881 */ - 0x0000, /* R16882 */ - 0x0000, /* R16883 */ - 0x0000, /* R16884 */ - 0x0000, /* R16885 */ - 0x0000, /* R16886 */ - 0x0000, /* R16887 */ - 0x0000, /* R16888 */ - 0x0000, /* R16889 */ - 0x0000, /* R16890 */ - 0x0000, /* R16891 */ - 0x0000, /* R16892 */ - 0x0000, /* R16893 */ - 0x0000, /* R16894 */ - 0x0000, /* R16895 */ - 0x0002, /* R16896 - HDBASS_AI_1 */ - 0xBD12, /* R16897 - HDBASS_AI_0 */ - 0x007C, /* R16898 - HDBASS_AR_1 */ - 0x586C, /* R16899 - HDBASS_AR_0 */ - 0x0053, /* R16900 - HDBASS_B_1 */ - 0x8121, /* R16901 - HDBASS_B_0 */ - 0x003F, /* R16902 - HDBASS_K_1 */ - 0x8BD8, /* R16903 - HDBASS_K_0 */ - 0x0032, /* R16904 - HDBASS_N1_1 */ - 0xF52D, /* R16905 - HDBASS_N1_0 */ - 0x0065, /* R16906 - HDBASS_N2_1 */ - 0xAC8C, /* R16907 - HDBASS_N2_0 */ - 0x006B, /* R16908 - HDBASS_N3_1 */ - 0xE087, /* R16909 - HDBASS_N3_0 */ - 0x0072, /* R16910 - HDBASS_N4_1 */ - 0x1483, /* R16911 - HDBASS_N4_0 */ - 0x0072, /* R16912 - HDBASS_N5_1 */ - 0x1483, /* R16913 - HDBASS_N5_0 */ - 0x0043, /* R16914 - HDBASS_X1_1 */ - 0x3525, /* R16915 - HDBASS_X1_0 */ - 0x0006, /* R16916 - HDBASS_X2_1 */ - 0x6A4A, /* R16917 - HDBASS_X2_0 */ - 0x0043, /* R16918 - HDBASS_X3_1 */ - 0x6079, /* R16919 - HDBASS_X3_0 */ - 0x0008, /* R16920 - HDBASS_ATK_1 */ - 0x0000, /* R16921 - HDBASS_ATK_0 */ - 0x0001, /* R16922 - HDBASS_DCY_1 */ - 0x0000, /* R16923 - HDBASS_DCY_0 */ - 0x0059, /* R16924 - HDBASS_PG_1 */ - 0x999A, /* R16925 - HDBASS_PG_0 */ - 0x0000, /* R16926 */ - 0x0000, /* R16927 */ - 0x0000, /* R16928 */ - 0x0000, /* R16929 */ - 0x0000, /* R16930 */ - 0x0000, /* R16931 */ - 0x0000, /* R16932 */ - 0x0000, /* R16933 */ - 0x0000, /* R16934 */ - 0x0000, /* R16935 */ - 0x0000, /* R16936 */ - 0x0000, /* R16937 */ - 0x0000, /* R16938 */ - 0x0000, /* R16939 */ - 0x0000, /* R16940 */ - 0x0000, /* R16941 */ - 0x0000, /* R16942 */ - 0x0000, /* R16943 */ - 0x0000, /* R16944 */ - 0x0000, /* R16945 */ - 0x0000, /* R16946 */ - 0x0000, /* R16947 */ - 0x0000, /* R16948 */ - 0x0000, /* R16949 */ - 0x0000, /* R16950 */ - 0x0000, /* R16951 */ - 0x0000, /* R16952 */ - 0x0000, /* R16953 */ - 0x0000, /* R16954 */ - 0x0000, /* R16955 */ - 0x0000, /* R16956 */ - 0x0000, /* R16957 */ - 0x0000, /* R16958 */ - 0x0000, /* R16959 */ - 0x0000, /* R16960 */ - 0x0000, /* R16961 */ - 0x0000, /* R16962 */ - 0x0000, /* R16963 */ - 0x0000, /* R16964 */ - 0x0000, /* R16965 */ - 0x0000, /* R16966 */ - 0x0000, /* R16967 */ - 0x0000, /* R16968 */ - 0x0000, /* R16969 */ - 0x0000, /* R16970 */ - 0x0000, /* R16971 */ - 0x0000, /* R16972 */ - 0x0000, /* R16973 */ - 0x0000, /* R16974 */ - 0x0000, /* R16975 */ - 0x0000, /* R16976 */ - 0x0000, /* R16977 */ - 0x0000, /* R16978 */ - 0x0000, /* R16979 */ - 0x0000, /* R16980 */ - 0x0000, /* R16981 */ - 0x0000, /* R16982 */ - 0x0000, /* R16983 */ - 0x0000, /* R16984 */ - 0x0000, /* R16985 */ - 0x0000, /* R16986 */ - 0x0000, /* R16987 */ - 0x0000, /* R16988 */ - 0x0000, /* R16989 */ - 0x0000, /* R16990 */ - 0x0000, /* R16991 */ - 0x0000, /* R16992 */ - 0x0000, /* R16993 */ - 0x0000, /* R16994 */ - 0x0000, /* R16995 */ - 0x0000, /* R16996 */ - 0x0000, /* R16997 */ - 0x0000, /* R16998 */ - 0x0000, /* R16999 */ - 0x0000, /* R17000 */ - 0x0000, /* R17001 */ - 0x0000, /* R17002 */ - 0x0000, /* R17003 */ - 0x0000, /* R17004 */ - 0x0000, /* R17005 */ - 0x0000, /* R17006 */ - 0x0000, /* R17007 */ - 0x0000, /* R17008 */ - 0x0000, /* R17009 */ - 0x0000, /* R17010 */ - 0x0000, /* R17011 */ - 0x0000, /* R17012 */ - 0x0000, /* R17013 */ - 0x0000, /* R17014 */ - 0x0000, /* R17015 */ - 0x0000, /* R17016 */ - 0x0000, /* R17017 */ - 0x0000, /* R17018 */ - 0x0000, /* R17019 */ - 0x0000, /* R17020 */ - 0x0000, /* R17021 */ - 0x0000, /* R17022 */ - 0x0000, /* R17023 */ - 0x0000, /* R17024 */ - 0x0000, /* R17025 */ - 0x0000, /* R17026 */ - 0x0000, /* R17027 */ - 0x0000, /* R17028 */ - 0x0000, /* R17029 */ - 0x0000, /* R17030 */ - 0x0000, /* R17031 */ - 0x0000, /* R17032 */ - 0x0000, /* R17033 */ - 0x0000, /* R17034 */ - 0x0000, /* R17035 */ - 0x0000, /* R17036 */ - 0x0000, /* R17037 */ - 0x0000, /* R17038 */ - 0x0000, /* R17039 */ - 0x0000, /* R17040 */ - 0x0000, /* R17041 */ - 0x0000, /* R17042 */ - 0x0000, /* R17043 */ - 0x0000, /* R17044 */ - 0x0000, /* R17045 */ - 0x0000, /* R17046 */ - 0x0000, /* R17047 */ - 0x0000, /* R17048 */ - 0x0000, /* R17049 */ - 0x0000, /* R17050 */ - 0x0000, /* R17051 */ - 0x0000, /* R17052 */ - 0x0000, /* R17053 */ - 0x0000, /* R17054 */ - 0x0000, /* R17055 */ - 0x0000, /* R17056 */ - 0x0000, /* R17057 */ - 0x0000, /* R17058 */ - 0x0000, /* R17059 */ - 0x0000, /* R17060 */ - 0x0000, /* R17061 */ - 0x0000, /* R17062 */ - 0x0000, /* R17063 */ - 0x0000, /* R17064 */ - 0x0000, /* R17065 */ - 0x0000, /* R17066 */ - 0x0000, /* R17067 */ - 0x0000, /* R17068 */ - 0x0000, /* R17069 */ - 0x0000, /* R17070 */ - 0x0000, /* R17071 */ - 0x0000, /* R17072 */ - 0x0000, /* R17073 */ - 0x0000, /* R17074 */ - 0x0000, /* R17075 */ - 0x0000, /* R17076 */ - 0x0000, /* R17077 */ - 0x0000, /* R17078 */ - 0x0000, /* R17079 */ - 0x0000, /* R17080 */ - 0x0000, /* R17081 */ - 0x0000, /* R17082 */ - 0x0000, /* R17083 */ - 0x0000, /* R17084 */ - 0x0000, /* R17085 */ - 0x0000, /* R17086 */ - 0x0000, /* R17087 */ - 0x0000, /* R17088 */ - 0x0000, /* R17089 */ - 0x0000, /* R17090 */ - 0x0000, /* R17091 */ - 0x0000, /* R17092 */ - 0x0000, /* R17093 */ - 0x0000, /* R17094 */ - 0x0000, /* R17095 */ - 0x0000, /* R17096 */ - 0x0000, /* R17097 */ - 0x0000, /* R17098 */ - 0x0000, /* R17099 */ - 0x0000, /* R17100 */ - 0x0000, /* R17101 */ - 0x0000, /* R17102 */ - 0x0000, /* R17103 */ - 0x0000, /* R17104 */ - 0x0000, /* R17105 */ - 0x0000, /* R17106 */ - 0x0000, /* R17107 */ - 0x0000, /* R17108 */ - 0x0000, /* R17109 */ - 0x0000, /* R17110 */ - 0x0000, /* R17111 */ - 0x0000, /* R17112 */ - 0x0000, /* R17113 */ - 0x0000, /* R17114 */ - 0x0000, /* R17115 */ - 0x0000, /* R17116 */ - 0x0000, /* R17117 */ - 0x0000, /* R17118 */ - 0x0000, /* R17119 */ - 0x0000, /* R17120 */ - 0x0000, /* R17121 */ - 0x0000, /* R17122 */ - 0x0000, /* R17123 */ - 0x0000, /* R17124 */ - 0x0000, /* R17125 */ - 0x0000, /* R17126 */ - 0x0000, /* R17127 */ - 0x0000, /* R17128 */ - 0x0000, /* R17129 */ - 0x0000, /* R17130 */ - 0x0000, /* R17131 */ - 0x0000, /* R17132 */ - 0x0000, /* R17133 */ - 0x0000, /* R17134 */ - 0x0000, /* R17135 */ - 0x0000, /* R17136 */ - 0x0000, /* R17137 */ - 0x0000, /* R17138 */ - 0x0000, /* R17139 */ - 0x0000, /* R17140 */ - 0x0000, /* R17141 */ - 0x0000, /* R17142 */ - 0x0000, /* R17143 */ - 0x0000, /* R17144 */ - 0x0000, /* R17145 */ - 0x0000, /* R17146 */ - 0x0000, /* R17147 */ - 0x0000, /* R17148 */ - 0x0000, /* R17149 */ - 0x0000, /* R17150 */ - 0x0000, /* R17151 */ - 0x0000, /* R17152 */ - 0x0000, /* R17153 */ - 0x0000, /* R17154 */ - 0x0000, /* R17155 */ - 0x0000, /* R17156 */ - 0x0000, /* R17157 */ - 0x0000, /* R17158 */ - 0x0000, /* R17159 */ - 0x0000, /* R17160 */ - 0x0000, /* R17161 */ - 0x0000, /* R17162 */ - 0x0000, /* R17163 */ - 0x0000, /* R17164 */ - 0x0000, /* R17165 */ - 0x0000, /* R17166 */ - 0x0000, /* R17167 */ - 0x0000, /* R17168 */ - 0x0000, /* R17169 */ - 0x0000, /* R17170 */ - 0x0000, /* R17171 */ - 0x0000, /* R17172 */ - 0x0000, /* R17173 */ - 0x0000, /* R17174 */ - 0x0000, /* R17175 */ - 0x0000, /* R17176 */ - 0x0000, /* R17177 */ - 0x0000, /* R17178 */ - 0x0000, /* R17179 */ - 0x0000, /* R17180 */ - 0x0000, /* R17181 */ - 0x0000, /* R17182 */ - 0x0000, /* R17183 */ - 0x0000, /* R17184 */ - 0x0000, /* R17185 */ - 0x0000, /* R17186 */ - 0x0000, /* R17187 */ - 0x0000, /* R17188 */ - 0x0000, /* R17189 */ - 0x0000, /* R17190 */ - 0x0000, /* R17191 */ - 0x0000, /* R17192 */ - 0x0000, /* R17193 */ - 0x0000, /* R17194 */ - 0x0000, /* R17195 */ - 0x0000, /* R17196 */ - 0x0000, /* R17197 */ - 0x0000, /* R17198 */ - 0x0000, /* R17199 */ - 0x0000, /* R17200 */ - 0x0000, /* R17201 */ - 0x0000, /* R17202 */ - 0x0000, /* R17203 */ - 0x0000, /* R17204 */ - 0x0000, /* R17205 */ - 0x0000, /* R17206 */ - 0x0000, /* R17207 */ - 0x0000, /* R17208 */ - 0x0000, /* R17209 */ - 0x0000, /* R17210 */ - 0x0000, /* R17211 */ - 0x0000, /* R17212 */ - 0x0000, /* R17213 */ - 0x0000, /* R17214 */ - 0x0000, /* R17215 */ - 0x0000, /* R17216 */ - 0x0000, /* R17217 */ - 0x0000, /* R17218 */ - 0x0000, /* R17219 */ - 0x0000, /* R17220 */ - 0x0000, /* R17221 */ - 0x0000, /* R17222 */ - 0x0000, /* R17223 */ - 0x0000, /* R17224 */ - 0x0000, /* R17225 */ - 0x0000, /* R17226 */ - 0x0000, /* R17227 */ - 0x0000, /* R17228 */ - 0x0000, /* R17229 */ - 0x0000, /* R17230 */ - 0x0000, /* R17231 */ - 0x0000, /* R17232 */ - 0x0000, /* R17233 */ - 0x0000, /* R17234 */ - 0x0000, /* R17235 */ - 0x0000, /* R17236 */ - 0x0000, /* R17237 */ - 0x0000, /* R17238 */ - 0x0000, /* R17239 */ - 0x0000, /* R17240 */ - 0x0000, /* R17241 */ - 0x0000, /* R17242 */ - 0x0000, /* R17243 */ - 0x0000, /* R17244 */ - 0x0000, /* R17245 */ - 0x0000, /* R17246 */ - 0x0000, /* R17247 */ - 0x0000, /* R17248 */ - 0x0000, /* R17249 */ - 0x0000, /* R17250 */ - 0x0000, /* R17251 */ - 0x0000, /* R17252 */ - 0x0000, /* R17253 */ - 0x0000, /* R17254 */ - 0x0000, /* R17255 */ - 0x0000, /* R17256 */ - 0x0000, /* R17257 */ - 0x0000, /* R17258 */ - 0x0000, /* R17259 */ - 0x0000, /* R17260 */ - 0x0000, /* R17261 */ - 0x0000, /* R17262 */ - 0x0000, /* R17263 */ - 0x0000, /* R17264 */ - 0x0000, /* R17265 */ - 0x0000, /* R17266 */ - 0x0000, /* R17267 */ - 0x0000, /* R17268 */ - 0x0000, /* R17269 */ - 0x0000, /* R17270 */ - 0x0000, /* R17271 */ - 0x0000, /* R17272 */ - 0x0000, /* R17273 */ - 0x0000, /* R17274 */ - 0x0000, /* R17275 */ - 0x0000, /* R17276 */ - 0x0000, /* R17277 */ - 0x0000, /* R17278 */ - 0x0000, /* R17279 */ - 0x0000, /* R17280 */ - 0x0000, /* R17281 */ - 0x0000, /* R17282 */ - 0x0000, /* R17283 */ - 0x0000, /* R17284 */ - 0x0000, /* R17285 */ - 0x0000, /* R17286 */ - 0x0000, /* R17287 */ - 0x0000, /* R17288 */ - 0x0000, /* R17289 */ - 0x0000, /* R17290 */ - 0x0000, /* R17291 */ - 0x0000, /* R17292 */ - 0x0000, /* R17293 */ - 0x0000, /* R17294 */ - 0x0000, /* R17295 */ - 0x0000, /* R17296 */ - 0x0000, /* R17297 */ - 0x0000, /* R17298 */ - 0x0000, /* R17299 */ - 0x0000, /* R17300 */ - 0x0000, /* R17301 */ - 0x0000, /* R17302 */ - 0x0000, /* R17303 */ - 0x0000, /* R17304 */ - 0x0000, /* R17305 */ - 0x0000, /* R17306 */ - 0x0000, /* R17307 */ - 0x0000, /* R17308 */ - 0x0000, /* R17309 */ - 0x0000, /* R17310 */ - 0x0000, /* R17311 */ - 0x0000, /* R17312 */ - 0x0000, /* R17313 */ - 0x0000, /* R17314 */ - 0x0000, /* R17315 */ - 0x0000, /* R17316 */ - 0x0000, /* R17317 */ - 0x0000, /* R17318 */ - 0x0000, /* R17319 */ - 0x0000, /* R17320 */ - 0x0000, /* R17321 */ - 0x0000, /* R17322 */ - 0x0000, /* R17323 */ - 0x0000, /* R17324 */ - 0x0000, /* R17325 */ - 0x0000, /* R17326 */ - 0x0000, /* R17327 */ - 0x0000, /* R17328 */ - 0x0000, /* R17329 */ - 0x0000, /* R17330 */ - 0x0000, /* R17331 */ - 0x0000, /* R17332 */ - 0x0000, /* R17333 */ - 0x0000, /* R17334 */ - 0x0000, /* R17335 */ - 0x0000, /* R17336 */ - 0x0000, /* R17337 */ - 0x0000, /* R17338 */ - 0x0000, /* R17339 */ - 0x0000, /* R17340 */ - 0x0000, /* R17341 */ - 0x0000, /* R17342 */ - 0x0000, /* R17343 */ - 0x0000, /* R17344 */ - 0x0000, /* R17345 */ - 0x0000, /* R17346 */ - 0x0000, /* R17347 */ - 0x0000, /* R17348 */ - 0x0000, /* R17349 */ - 0x0000, /* R17350 */ - 0x0000, /* R17351 */ - 0x0000, /* R17352 */ - 0x0000, /* R17353 */ - 0x0000, /* R17354 */ - 0x0000, /* R17355 */ - 0x0000, /* R17356 */ - 0x0000, /* R17357 */ - 0x0000, /* R17358 */ - 0x0000, /* R17359 */ - 0x0000, /* R17360 */ - 0x0000, /* R17361 */ - 0x0000, /* R17362 */ - 0x0000, /* R17363 */ - 0x0000, /* R17364 */ - 0x0000, /* R17365 */ - 0x0000, /* R17366 */ - 0x0000, /* R17367 */ - 0x0000, /* R17368 */ - 0x0000, /* R17369 */ - 0x0000, /* R17370 */ - 0x0000, /* R17371 */ - 0x0000, /* R17372 */ - 0x0000, /* R17373 */ - 0x0000, /* R17374 */ - 0x0000, /* R17375 */ - 0x0000, /* R17376 */ - 0x0000, /* R17377 */ - 0x0000, /* R17378 */ - 0x0000, /* R17379 */ - 0x0000, /* R17380 */ - 0x0000, /* R17381 */ - 0x0000, /* R17382 */ - 0x0000, /* R17383 */ - 0x0000, /* R17384 */ - 0x0000, /* R17385 */ - 0x0000, /* R17386 */ - 0x0000, /* R17387 */ - 0x0000, /* R17388 */ - 0x0000, /* R17389 */ - 0x0000, /* R17390 */ - 0x0000, /* R17391 */ - 0x0000, /* R17392 */ - 0x0000, /* R17393 */ - 0x0000, /* R17394 */ - 0x0000, /* R17395 */ - 0x0000, /* R17396 */ - 0x0000, /* R17397 */ - 0x0000, /* R17398 */ - 0x0000, /* R17399 */ - 0x0000, /* R17400 */ - 0x0000, /* R17401 */ - 0x0000, /* R17402 */ - 0x0000, /* R17403 */ - 0x0000, /* R17404 */ - 0x0000, /* R17405 */ - 0x0000, /* R17406 */ - 0x0000, /* R17407 */ - 0x0083, /* R17408 - HPF_C_1 */ - 0x98AD, /* R17409 - HPF_C_0 */ - 0x0000, /* R17410 */ - 0x0000, /* R17411 */ - 0x0000, /* R17412 */ - 0x0000, /* R17413 */ - 0x0000, /* R17414 */ - 0x0000, /* R17415 */ - 0x0000, /* R17416 */ - 0x0000, /* R17417 */ - 0x0000, /* R17418 */ - 0x0000, /* R17419 */ - 0x0000, /* R17420 */ - 0x0000, /* R17421 */ - 0x0000, /* R17422 */ - 0x0000, /* R17423 */ - 0x0000, /* R17424 */ - 0x0000, /* R17425 */ - 0x0000, /* R17426 */ - 0x0000, /* R17427 */ - 0x0000, /* R17428 */ - 0x0000, /* R17429 */ - 0x0000, /* R17430 */ - 0x0000, /* R17431 */ - 0x0000, /* R17432 */ - 0x0000, /* R17433 */ - 0x0000, /* R17434 */ - 0x0000, /* R17435 */ - 0x0000, /* R17436 */ - 0x0000, /* R17437 */ - 0x0000, /* R17438 */ - 0x0000, /* R17439 */ - 0x0000, /* R17440 */ - 0x0000, /* R17441 */ - 0x0000, /* R17442 */ - 0x0000, /* R17443 */ - 0x0000, /* R17444 */ - 0x0000, /* R17445 */ - 0x0000, /* R17446 */ - 0x0000, /* R17447 */ - 0x0000, /* R17448 */ - 0x0000, /* R17449 */ - 0x0000, /* R17450 */ - 0x0000, /* R17451 */ - 0x0000, /* R17452 */ - 0x0000, /* R17453 */ - 0x0000, /* R17454 */ - 0x0000, /* R17455 */ - 0x0000, /* R17456 */ - 0x0000, /* R17457 */ - 0x0000, /* R17458 */ - 0x0000, /* R17459 */ - 0x0000, /* R17460 */ - 0x0000, /* R17461 */ - 0x0000, /* R17462 */ - 0x0000, /* R17463 */ - 0x0000, /* R17464 */ - 0x0000, /* R17465 */ - 0x0000, /* R17466 */ - 0x0000, /* R17467 */ - 0x0000, /* R17468 */ - 0x0000, /* R17469 */ - 0x0000, /* R17470 */ - 0x0000, /* R17471 */ - 0x0000, /* R17472 */ - 0x0000, /* R17473 */ - 0x0000, /* R17474 */ - 0x0000, /* R17475 */ - 0x0000, /* R17476 */ - 0x0000, /* R17477 */ - 0x0000, /* R17478 */ - 0x0000, /* R17479 */ - 0x0000, /* R17480 */ - 0x0000, /* R17481 */ - 0x0000, /* R17482 */ - 0x0000, /* R17483 */ - 0x0000, /* R17484 */ - 0x0000, /* R17485 */ - 0x0000, /* R17486 */ - 0x0000, /* R17487 */ - 0x0000, /* R17488 */ - 0x0000, /* R17489 */ - 0x0000, /* R17490 */ - 0x0000, /* R17491 */ - 0x0000, /* R17492 */ - 0x0000, /* R17493 */ - 0x0000, /* R17494 */ - 0x0000, /* R17495 */ - 0x0000, /* R17496 */ - 0x0000, /* R17497 */ - 0x0000, /* R17498 */ - 0x0000, /* R17499 */ - 0x0000, /* R17500 */ - 0x0000, /* R17501 */ - 0x0000, /* R17502 */ - 0x0000, /* R17503 */ - 0x0000, /* R17504 */ - 0x0000, /* R17505 */ - 0x0000, /* R17506 */ - 0x0000, /* R17507 */ - 0x0000, /* R17508 */ - 0x0000, /* R17509 */ - 0x0000, /* R17510 */ - 0x0000, /* R17511 */ - 0x0000, /* R17512 */ - 0x0000, /* R17513 */ - 0x0000, /* R17514 */ - 0x0000, /* R17515 */ - 0x0000, /* R17516 */ - 0x0000, /* R17517 */ - 0x0000, /* R17518 */ - 0x0000, /* R17519 */ - 0x0000, /* R17520 */ - 0x0000, /* R17521 */ - 0x0000, /* R17522 */ - 0x0000, /* R17523 */ - 0x0000, /* R17524 */ - 0x0000, /* R17525 */ - 0x0000, /* R17526 */ - 0x0000, /* R17527 */ - 0x0000, /* R17528 */ - 0x0000, /* R17529 */ - 0x0000, /* R17530 */ - 0x0000, /* R17531 */ - 0x0000, /* R17532 */ - 0x0000, /* R17533 */ - 0x0000, /* R17534 */ - 0x0000, /* R17535 */ - 0x0000, /* R17536 */ - 0x0000, /* R17537 */ - 0x0000, /* R17538 */ - 0x0000, /* R17539 */ - 0x0000, /* R17540 */ - 0x0000, /* R17541 */ - 0x0000, /* R17542 */ - 0x0000, /* R17543 */ - 0x0000, /* R17544 */ - 0x0000, /* R17545 */ - 0x0000, /* R17546 */ - 0x0000, /* R17547 */ - 0x0000, /* R17548 */ - 0x0000, /* R17549 */ - 0x0000, /* R17550 */ - 0x0000, /* R17551 */ - 0x0000, /* R17552 */ - 0x0000, /* R17553 */ - 0x0000, /* R17554 */ - 0x0000, /* R17555 */ - 0x0000, /* R17556 */ - 0x0000, /* R17557 */ - 0x0000, /* R17558 */ - 0x0000, /* R17559 */ - 0x0000, /* R17560 */ - 0x0000, /* R17561 */ - 0x0000, /* R17562 */ - 0x0000, /* R17563 */ - 0x0000, /* R17564 */ - 0x0000, /* R17565 */ - 0x0000, /* R17566 */ - 0x0000, /* R17567 */ - 0x0000, /* R17568 */ - 0x0000, /* R17569 */ - 0x0000, /* R17570 */ - 0x0000, /* R17571 */ - 0x0000, /* R17572 */ - 0x0000, /* R17573 */ - 0x0000, /* R17574 */ - 0x0000, /* R17575 */ - 0x0000, /* R17576 */ - 0x0000, /* R17577 */ - 0x0000, /* R17578 */ - 0x0000, /* R17579 */ - 0x0000, /* R17580 */ - 0x0000, /* R17581 */ - 0x0000, /* R17582 */ - 0x0000, /* R17583 */ - 0x0000, /* R17584 */ - 0x0000, /* R17585 */ - 0x0000, /* R17586 */ - 0x0000, /* R17587 */ - 0x0000, /* R17588 */ - 0x0000, /* R17589 */ - 0x0000, /* R17590 */ - 0x0000, /* R17591 */ - 0x0000, /* R17592 */ - 0x0000, /* R17593 */ - 0x0000, /* R17594 */ - 0x0000, /* R17595 */ - 0x0000, /* R17596 */ - 0x0000, /* R17597 */ - 0x0000, /* R17598 */ - 0x0000, /* R17599 */ - 0x0000, /* R17600 */ - 0x0000, /* R17601 */ - 0x0000, /* R17602 */ - 0x0000, /* R17603 */ - 0x0000, /* R17604 */ - 0x0000, /* R17605 */ - 0x0000, /* R17606 */ - 0x0000, /* R17607 */ - 0x0000, /* R17608 */ - 0x0000, /* R17609 */ - 0x0000, /* R17610 */ - 0x0000, /* R17611 */ - 0x0000, /* R17612 */ - 0x0000, /* R17613 */ - 0x0000, /* R17614 */ - 0x0000, /* R17615 */ - 0x0000, /* R17616 */ - 0x0000, /* R17617 */ - 0x0000, /* R17618 */ - 0x0000, /* R17619 */ - 0x0000, /* R17620 */ - 0x0000, /* R17621 */ - 0x0000, /* R17622 */ - 0x0000, /* R17623 */ - 0x0000, /* R17624 */ - 0x0000, /* R17625 */ - 0x0000, /* R17626 */ - 0x0000, /* R17627 */ - 0x0000, /* R17628 */ - 0x0000, /* R17629 */ - 0x0000, /* R17630 */ - 0x0000, /* R17631 */ - 0x0000, /* R17632 */ - 0x0000, /* R17633 */ - 0x0000, /* R17634 */ - 0x0000, /* R17635 */ - 0x0000, /* R17636 */ - 0x0000, /* R17637 */ - 0x0000, /* R17638 */ - 0x0000, /* R17639 */ - 0x0000, /* R17640 */ - 0x0000, /* R17641 */ - 0x0000, /* R17642 */ - 0x0000, /* R17643 */ - 0x0000, /* R17644 */ - 0x0000, /* R17645 */ - 0x0000, /* R17646 */ - 0x0000, /* R17647 */ - 0x0000, /* R17648 */ - 0x0000, /* R17649 */ - 0x0000, /* R17650 */ - 0x0000, /* R17651 */ - 0x0000, /* R17652 */ - 0x0000, /* R17653 */ - 0x0000, /* R17654 */ - 0x0000, /* R17655 */ - 0x0000, /* R17656 */ - 0x0000, /* R17657 */ - 0x0000, /* R17658 */ - 0x0000, /* R17659 */ - 0x0000, /* R17660 */ - 0x0000, /* R17661 */ - 0x0000, /* R17662 */ - 0x0000, /* R17663 */ - 0x0000, /* R17664 */ - 0x0000, /* R17665 */ - 0x0000, /* R17666 */ - 0x0000, /* R17667 */ - 0x0000, /* R17668 */ - 0x0000, /* R17669 */ - 0x0000, /* R17670 */ - 0x0000, /* R17671 */ - 0x0000, /* R17672 */ - 0x0000, /* R17673 */ - 0x0000, /* R17674 */ - 0x0000, /* R17675 */ - 0x0000, /* R17676 */ - 0x0000, /* R17677 */ - 0x0000, /* R17678 */ - 0x0000, /* R17679 */ - 0x0000, /* R17680 */ - 0x0000, /* R17681 */ - 0x0000, /* R17682 */ - 0x0000, /* R17683 */ - 0x0000, /* R17684 */ - 0x0000, /* R17685 */ - 0x0000, /* R17686 */ - 0x0000, /* R17687 */ - 0x0000, /* R17688 */ - 0x0000, /* R17689 */ - 0x0000, /* R17690 */ - 0x0000, /* R17691 */ - 0x0000, /* R17692 */ - 0x0000, /* R17693 */ - 0x0000, /* R17694 */ - 0x0000, /* R17695 */ - 0x0000, /* R17696 */ - 0x0000, /* R17697 */ - 0x0000, /* R17698 */ - 0x0000, /* R17699 */ - 0x0000, /* R17700 */ - 0x0000, /* R17701 */ - 0x0000, /* R17702 */ - 0x0000, /* R17703 */ - 0x0000, /* R17704 */ - 0x0000, /* R17705 */ - 0x0000, /* R17706 */ - 0x0000, /* R17707 */ - 0x0000, /* R17708 */ - 0x0000, /* R17709 */ - 0x0000, /* R17710 */ - 0x0000, /* R17711 */ - 0x0000, /* R17712 */ - 0x0000, /* R17713 */ - 0x0000, /* R17714 */ - 0x0000, /* R17715 */ - 0x0000, /* R17716 */ - 0x0000, /* R17717 */ - 0x0000, /* R17718 */ - 0x0000, /* R17719 */ - 0x0000, /* R17720 */ - 0x0000, /* R17721 */ - 0x0000, /* R17722 */ - 0x0000, /* R17723 */ - 0x0000, /* R17724 */ - 0x0000, /* R17725 */ - 0x0000, /* R17726 */ - 0x0000, /* R17727 */ - 0x0000, /* R17728 */ - 0x0000, /* R17729 */ - 0x0000, /* R17730 */ - 0x0000, /* R17731 */ - 0x0000, /* R17732 */ - 0x0000, /* R17733 */ - 0x0000, /* R17734 */ - 0x0000, /* R17735 */ - 0x0000, /* R17736 */ - 0x0000, /* R17737 */ - 0x0000, /* R17738 */ - 0x0000, /* R17739 */ - 0x0000, /* R17740 */ - 0x0000, /* R17741 */ - 0x0000, /* R17742 */ - 0x0000, /* R17743 */ - 0x0000, /* R17744 */ - 0x0000, /* R17745 */ - 0x0000, /* R17746 */ - 0x0000, /* R17747 */ - 0x0000, /* R17748 */ - 0x0000, /* R17749 */ - 0x0000, /* R17750 */ - 0x0000, /* R17751 */ - 0x0000, /* R17752 */ - 0x0000, /* R17753 */ - 0x0000, /* R17754 */ - 0x0000, /* R17755 */ - 0x0000, /* R17756 */ - 0x0000, /* R17757 */ - 0x0000, /* R17758 */ - 0x0000, /* R17759 */ - 0x0000, /* R17760 */ - 0x0000, /* R17761 */ - 0x0000, /* R17762 */ - 0x0000, /* R17763 */ - 0x0000, /* R17764 */ - 0x0000, /* R17765 */ - 0x0000, /* R17766 */ - 0x0000, /* R17767 */ - 0x0000, /* R17768 */ - 0x0000, /* R17769 */ - 0x0000, /* R17770 */ - 0x0000, /* R17771 */ - 0x0000, /* R17772 */ - 0x0000, /* R17773 */ - 0x0000, /* R17774 */ - 0x0000, /* R17775 */ - 0x0000, /* R17776 */ - 0x0000, /* R17777 */ - 0x0000, /* R17778 */ - 0x0000, /* R17779 */ - 0x0000, /* R17780 */ - 0x0000, /* R17781 */ - 0x0000, /* R17782 */ - 0x0000, /* R17783 */ - 0x0000, /* R17784 */ - 0x0000, /* R17785 */ - 0x0000, /* R17786 */ - 0x0000, /* R17787 */ - 0x0000, /* R17788 */ - 0x0000, /* R17789 */ - 0x0000, /* R17790 */ - 0x0000, /* R17791 */ - 0x0000, /* R17792 */ - 0x0000, /* R17793 */ - 0x0000, /* R17794 */ - 0x0000, /* R17795 */ - 0x0000, /* R17796 */ - 0x0000, /* R17797 */ - 0x0000, /* R17798 */ - 0x0000, /* R17799 */ - 0x0000, /* R17800 */ - 0x0000, /* R17801 */ - 0x0000, /* R17802 */ - 0x0000, /* R17803 */ - 0x0000, /* R17804 */ - 0x0000, /* R17805 */ - 0x0000, /* R17806 */ - 0x0000, /* R17807 */ - 0x0000, /* R17808 */ - 0x0000, /* R17809 */ - 0x0000, /* R17810 */ - 0x0000, /* R17811 */ - 0x0000, /* R17812 */ - 0x0000, /* R17813 */ - 0x0000, /* R17814 */ - 0x0000, /* R17815 */ - 0x0000, /* R17816 */ - 0x0000, /* R17817 */ - 0x0000, /* R17818 */ - 0x0000, /* R17819 */ - 0x0000, /* R17820 */ - 0x0000, /* R17821 */ - 0x0000, /* R17822 */ - 0x0000, /* R17823 */ - 0x0000, /* R17824 */ - 0x0000, /* R17825 */ - 0x0000, /* R17826 */ - 0x0000, /* R17827 */ - 0x0000, /* R17828 */ - 0x0000, /* R17829 */ - 0x0000, /* R17830 */ - 0x0000, /* R17831 */ - 0x0000, /* R17832 */ - 0x0000, /* R17833 */ - 0x0000, /* R17834 */ - 0x0000, /* R17835 */ - 0x0000, /* R17836 */ - 0x0000, /* R17837 */ - 0x0000, /* R17838 */ - 0x0000, /* R17839 */ - 0x0000, /* R17840 */ - 0x0000, /* R17841 */ - 0x0000, /* R17842 */ - 0x0000, /* R17843 */ - 0x0000, /* R17844 */ - 0x0000, /* R17845 */ - 0x0000, /* R17846 */ - 0x0000, /* R17847 */ - 0x0000, /* R17848 */ - 0x0000, /* R17849 */ - 0x0000, /* R17850 */ - 0x0000, /* R17851 */ - 0x0000, /* R17852 */ - 0x0000, /* R17853 */ - 0x0000, /* R17854 */ - 0x0000, /* R17855 */ - 0x0000, /* R17856 */ - 0x0000, /* R17857 */ - 0x0000, /* R17858 */ - 0x0000, /* R17859 */ - 0x0000, /* R17860 */ - 0x0000, /* R17861 */ - 0x0000, /* R17862 */ - 0x0000, /* R17863 */ - 0x0000, /* R17864 */ - 0x0000, /* R17865 */ - 0x0000, /* R17866 */ - 0x0000, /* R17867 */ - 0x0000, /* R17868 */ - 0x0000, /* R17869 */ - 0x0000, /* R17870 */ - 0x0000, /* R17871 */ - 0x0000, /* R17872 */ - 0x0000, /* R17873 */ - 0x0000, /* R17874 */ - 0x0000, /* R17875 */ - 0x0000, /* R17876 */ - 0x0000, /* R17877 */ - 0x0000, /* R17878 */ - 0x0000, /* R17879 */ - 0x0000, /* R17880 */ - 0x0000, /* R17881 */ - 0x0000, /* R17882 */ - 0x0000, /* R17883 */ - 0x0000, /* R17884 */ - 0x0000, /* R17885 */ - 0x0000, /* R17886 */ - 0x0000, /* R17887 */ - 0x0000, /* R17888 */ - 0x0000, /* R17889 */ - 0x0000, /* R17890 */ - 0x0000, /* R17891 */ - 0x0000, /* R17892 */ - 0x0000, /* R17893 */ - 0x0000, /* R17894 */ - 0x0000, /* R17895 */ - 0x0000, /* R17896 */ - 0x0000, /* R17897 */ - 0x0000, /* R17898 */ - 0x0000, /* R17899 */ - 0x0000, /* R17900 */ - 0x0000, /* R17901 */ - 0x0000, /* R17902 */ - 0x0000, /* R17903 */ - 0x0000, /* R17904 */ - 0x0000, /* R17905 */ - 0x0000, /* R17906 */ - 0x0000, /* R17907 */ - 0x0000, /* R17908 */ - 0x0000, /* R17909 */ - 0x0000, /* R17910 */ - 0x0000, /* R17911 */ - 0x0000, /* R17912 */ - 0x0000, /* R17913 */ - 0x0000, /* R17914 */ - 0x0000, /* R17915 */ - 0x0000, /* R17916 */ - 0x0000, /* R17917 */ - 0x0000, /* R17918 */ - 0x0000, /* R17919 */ - 0x007F, /* R17920 - ADCL_RETUNE_C1_1 */ - 0xFFFF, /* R17921 - ADCL_RETUNE_C1_0 */ - 0x0000, /* R17922 - ADCL_RETUNE_C2_1 */ - 0x0000, /* R17923 - ADCL_RETUNE_C2_0 */ - 0x0000, /* R17924 - ADCL_RETUNE_C3_1 */ - 0x0000, /* R17925 - ADCL_RETUNE_C3_0 */ - 0x0000, /* R17926 - ADCL_RETUNE_C4_1 */ - 0x0000, /* R17927 - ADCL_RETUNE_C4_0 */ - 0x0000, /* R17928 - ADCL_RETUNE_C5_1 */ - 0x0000, /* R17929 - ADCL_RETUNE_C5_0 */ - 0x0000, /* R17930 - ADCL_RETUNE_C6_1 */ - 0x0000, /* R17931 - ADCL_RETUNE_C6_0 */ - 0x0000, /* R17932 - ADCL_RETUNE_C7_1 */ - 0x0000, /* R17933 - ADCL_RETUNE_C7_0 */ - 0x0000, /* R17934 - ADCL_RETUNE_C8_1 */ - 0x0000, /* R17935 - ADCL_RETUNE_C8_0 */ - 0x0000, /* R17936 - ADCL_RETUNE_C9_1 */ - 0x0000, /* R17937 - ADCL_RETUNE_C9_0 */ - 0x0000, /* R17938 - ADCL_RETUNE_C10_1 */ - 0x0000, /* R17939 - ADCL_RETUNE_C10_0 */ - 0x0000, /* R17940 - ADCL_RETUNE_C11_1 */ - 0x0000, /* R17941 - ADCL_RETUNE_C11_0 */ - 0x0000, /* R17942 - ADCL_RETUNE_C12_1 */ - 0x0000, /* R17943 - ADCL_RETUNE_C12_0 */ - 0x0000, /* R17944 - ADCL_RETUNE_C13_1 */ - 0x0000, /* R17945 - ADCL_RETUNE_C13_0 */ - 0x0000, /* R17946 - ADCL_RETUNE_C14_1 */ - 0x0000, /* R17947 - ADCL_RETUNE_C14_0 */ - 0x0000, /* R17948 - ADCL_RETUNE_C15_1 */ - 0x0000, /* R17949 - ADCL_RETUNE_C15_0 */ - 0x0000, /* R17950 - ADCL_RETUNE_C16_1 */ - 0x0000, /* R17951 - ADCL_RETUNE_C16_0 */ - 0x0000, /* R17952 - ADCL_RETUNE_C17_1 */ - 0x0000, /* R17953 - ADCL_RETUNE_C17_0 */ - 0x0000, /* R17954 - ADCL_RETUNE_C18_1 */ - 0x0000, /* R17955 - ADCL_RETUNE_C18_0 */ - 0x0000, /* R17956 - ADCL_RETUNE_C19_1 */ - 0x0000, /* R17957 - ADCL_RETUNE_C19_0 */ - 0x0000, /* R17958 - ADCL_RETUNE_C20_1 */ - 0x0000, /* R17959 - ADCL_RETUNE_C20_0 */ - 0x0000, /* R17960 - ADCL_RETUNE_C21_1 */ - 0x0000, /* R17961 - ADCL_RETUNE_C21_0 */ - 0x0000, /* R17962 - ADCL_RETUNE_C22_1 */ - 0x0000, /* R17963 - ADCL_RETUNE_C22_0 */ - 0x0000, /* R17964 - ADCL_RETUNE_C23_1 */ - 0x0000, /* R17965 - ADCL_RETUNE_C23_0 */ - 0x0000, /* R17966 - ADCL_RETUNE_C24_1 */ - 0x0000, /* R17967 - ADCL_RETUNE_C24_0 */ - 0x0000, /* R17968 - ADCL_RETUNE_C25_1 */ - 0x0000, /* R17969 - ADCL_RETUNE_C25_0 */ - 0x0000, /* R17970 - ADCL_RETUNE_C26_1 */ - 0x0000, /* R17971 - ADCL_RETUNE_C26_0 */ - 0x0000, /* R17972 - ADCL_RETUNE_C27_1 */ - 0x0000, /* R17973 - ADCL_RETUNE_C27_0 */ - 0x0000, /* R17974 - ADCL_RETUNE_C28_1 */ - 0x0000, /* R17975 - ADCL_RETUNE_C28_0 */ - 0x0000, /* R17976 - ADCL_RETUNE_C29_1 */ - 0x0000, /* R17977 - ADCL_RETUNE_C29_0 */ - 0x0000, /* R17978 - ADCL_RETUNE_C30_1 */ - 0x0000, /* R17979 - ADCL_RETUNE_C30_0 */ - 0x0000, /* R17980 - ADCL_RETUNE_C31_1 */ - 0x0000, /* R17981 - ADCL_RETUNE_C31_0 */ - 0x0000, /* R17982 - ADCL_RETUNE_C32_1 */ - 0x0000, /* R17983 - ADCL_RETUNE_C32_0 */ - 0x0000, /* R17984 */ - 0x0000, /* R17985 */ - 0x0000, /* R17986 */ - 0x0000, /* R17987 */ - 0x0000, /* R17988 */ - 0x0000, /* R17989 */ - 0x0000, /* R17990 */ - 0x0000, /* R17991 */ - 0x0000, /* R17992 */ - 0x0000, /* R17993 */ - 0x0000, /* R17994 */ - 0x0000, /* R17995 */ - 0x0000, /* R17996 */ - 0x0000, /* R17997 */ - 0x0000, /* R17998 */ - 0x0000, /* R17999 */ - 0x0000, /* R18000 */ - 0x0000, /* R18001 */ - 0x0000, /* R18002 */ - 0x0000, /* R18003 */ - 0x0000, /* R18004 */ - 0x0000, /* R18005 */ - 0x0000, /* R18006 */ - 0x0000, /* R18007 */ - 0x0000, /* R18008 */ - 0x0000, /* R18009 */ - 0x0000, /* R18010 */ - 0x0000, /* R18011 */ - 0x0000, /* R18012 */ - 0x0000, /* R18013 */ - 0x0000, /* R18014 */ - 0x0000, /* R18015 */ - 0x0000, /* R18016 */ - 0x0000, /* R18017 */ - 0x0000, /* R18018 */ - 0x0000, /* R18019 */ - 0x0000, /* R18020 */ - 0x0000, /* R18021 */ - 0x0000, /* R18022 */ - 0x0000, /* R18023 */ - 0x0000, /* R18024 */ - 0x0000, /* R18025 */ - 0x0000, /* R18026 */ - 0x0000, /* R18027 */ - 0x0000, /* R18028 */ - 0x0000, /* R18029 */ - 0x0000, /* R18030 */ - 0x0000, /* R18031 */ - 0x0000, /* R18032 */ - 0x0000, /* R18033 */ - 0x0000, /* R18034 */ - 0x0000, /* R18035 */ - 0x0000, /* R18036 */ - 0x0000, /* R18037 */ - 0x0000, /* R18038 */ - 0x0000, /* R18039 */ - 0x0000, /* R18040 */ - 0x0000, /* R18041 */ - 0x0000, /* R18042 */ - 0x0000, /* R18043 */ - 0x0000, /* R18044 */ - 0x0000, /* R18045 */ - 0x0000, /* R18046 */ - 0x0000, /* R18047 */ - 0x0000, /* R18048 */ - 0x0000, /* R18049 */ - 0x0000, /* R18050 */ - 0x0000, /* R18051 */ - 0x0000, /* R18052 */ - 0x0000, /* R18053 */ - 0x0000, /* R18054 */ - 0x0000, /* R18055 */ - 0x0000, /* R18056 */ - 0x0000, /* R18057 */ - 0x0000, /* R18058 */ - 0x0000, /* R18059 */ - 0x0000, /* R18060 */ - 0x0000, /* R18061 */ - 0x0000, /* R18062 */ - 0x0000, /* R18063 */ - 0x0000, /* R18064 */ - 0x0000, /* R18065 */ - 0x0000, /* R18066 */ - 0x0000, /* R18067 */ - 0x0000, /* R18068 */ - 0x0000, /* R18069 */ - 0x0000, /* R18070 */ - 0x0000, /* R18071 */ - 0x0000, /* R18072 */ - 0x0000, /* R18073 */ - 0x0000, /* R18074 */ - 0x0000, /* R18075 */ - 0x0000, /* R18076 */ - 0x0000, /* R18077 */ - 0x0000, /* R18078 */ - 0x0000, /* R18079 */ - 0x0000, /* R18080 */ - 0x0000, /* R18081 */ - 0x0000, /* R18082 */ - 0x0000, /* R18083 */ - 0x0000, /* R18084 */ - 0x0000, /* R18085 */ - 0x0000, /* R18086 */ - 0x0000, /* R18087 */ - 0x0000, /* R18088 */ - 0x0000, /* R18089 */ - 0x0000, /* R18090 */ - 0x0000, /* R18091 */ - 0x0000, /* R18092 */ - 0x0000, /* R18093 */ - 0x0000, /* R18094 */ - 0x0000, /* R18095 */ - 0x0000, /* R18096 */ - 0x0000, /* R18097 */ - 0x0000, /* R18098 */ - 0x0000, /* R18099 */ - 0x0000, /* R18100 */ - 0x0000, /* R18101 */ - 0x0000, /* R18102 */ - 0x0000, /* R18103 */ - 0x0000, /* R18104 */ - 0x0000, /* R18105 */ - 0x0000, /* R18106 */ - 0x0000, /* R18107 */ - 0x0000, /* R18108 */ - 0x0000, /* R18109 */ - 0x0000, /* R18110 */ - 0x0000, /* R18111 */ - 0x0000, /* R18112 */ - 0x0000, /* R18113 */ - 0x0000, /* R18114 */ - 0x0000, /* R18115 */ - 0x0000, /* R18116 */ - 0x0000, /* R18117 */ - 0x0000, /* R18118 */ - 0x0000, /* R18119 */ - 0x0000, /* R18120 */ - 0x0000, /* R18121 */ - 0x0000, /* R18122 */ - 0x0000, /* R18123 */ - 0x0000, /* R18124 */ - 0x0000, /* R18125 */ - 0x0000, /* R18126 */ - 0x0000, /* R18127 */ - 0x0000, /* R18128 */ - 0x0000, /* R18129 */ - 0x0000, /* R18130 */ - 0x0000, /* R18131 */ - 0x0000, /* R18132 */ - 0x0000, /* R18133 */ - 0x0000, /* R18134 */ - 0x0000, /* R18135 */ - 0x0000, /* R18136 */ - 0x0000, /* R18137 */ - 0x0000, /* R18138 */ - 0x0000, /* R18139 */ - 0x0000, /* R18140 */ - 0x0000, /* R18141 */ - 0x0000, /* R18142 */ - 0x0000, /* R18143 */ - 0x0000, /* R18144 */ - 0x0000, /* R18145 */ - 0x0000, /* R18146 */ - 0x0000, /* R18147 */ - 0x0000, /* R18148 */ - 0x0000, /* R18149 */ - 0x0000, /* R18150 */ - 0x0000, /* R18151 */ - 0x0000, /* R18152 */ - 0x0000, /* R18153 */ - 0x0000, /* R18154 */ - 0x0000, /* R18155 */ - 0x0000, /* R18156 */ - 0x0000, /* R18157 */ - 0x0000, /* R18158 */ - 0x0000, /* R18159 */ - 0x0000, /* R18160 */ - 0x0000, /* R18161 */ - 0x0000, /* R18162 */ - 0x0000, /* R18163 */ - 0x0000, /* R18164 */ - 0x0000, /* R18165 */ - 0x0000, /* R18166 */ - 0x0000, /* R18167 */ - 0x0000, /* R18168 */ - 0x0000, /* R18169 */ - 0x0000, /* R18170 */ - 0x0000, /* R18171 */ - 0x0000, /* R18172 */ - 0x0000, /* R18173 */ - 0x0000, /* R18174 */ - 0x0000, /* R18175 */ - 0x0000, /* R18176 */ - 0x0000, /* R18177 */ - 0x0000, /* R18178 */ - 0x0000, /* R18179 */ - 0x0000, /* R18180 */ - 0x0000, /* R18181 */ - 0x0000, /* R18182 */ - 0x0000, /* R18183 */ - 0x0000, /* R18184 */ - 0x0000, /* R18185 */ - 0x0000, /* R18186 */ - 0x0000, /* R18187 */ - 0x0000, /* R18188 */ - 0x0000, /* R18189 */ - 0x0000, /* R18190 */ - 0x0000, /* R18191 */ - 0x0000, /* R18192 */ - 0x0000, /* R18193 */ - 0x0000, /* R18194 */ - 0x0000, /* R18195 */ - 0x0000, /* R18196 */ - 0x0000, /* R18197 */ - 0x0000, /* R18198 */ - 0x0000, /* R18199 */ - 0x0000, /* R18200 */ - 0x0000, /* R18201 */ - 0x0000, /* R18202 */ - 0x0000, /* R18203 */ - 0x0000, /* R18204 */ - 0x0000, /* R18205 */ - 0x0000, /* R18206 */ - 0x0000, /* R18207 */ - 0x0000, /* R18208 */ - 0x0000, /* R18209 */ - 0x0000, /* R18210 */ - 0x0000, /* R18211 */ - 0x0000, /* R18212 */ - 0x0000, /* R18213 */ - 0x0000, /* R18214 */ - 0x0000, /* R18215 */ - 0x0000, /* R18216 */ - 0x0000, /* R18217 */ - 0x0000, /* R18218 */ - 0x0000, /* R18219 */ - 0x0000, /* R18220 */ - 0x0000, /* R18221 */ - 0x0000, /* R18222 */ - 0x0000, /* R18223 */ - 0x0000, /* R18224 */ - 0x0000, /* R18225 */ - 0x0000, /* R18226 */ - 0x0000, /* R18227 */ - 0x0000, /* R18228 */ - 0x0000, /* R18229 */ - 0x0000, /* R18230 */ - 0x0000, /* R18231 */ - 0x0000, /* R18232 */ - 0x0000, /* R18233 */ - 0x0000, /* R18234 */ - 0x0000, /* R18235 */ - 0x0000, /* R18236 */ - 0x0000, /* R18237 */ - 0x0000, /* R18238 */ - 0x0000, /* R18239 */ - 0x0000, /* R18240 */ - 0x0000, /* R18241 */ - 0x0000, /* R18242 */ - 0x0000, /* R18243 */ - 0x0000, /* R18244 */ - 0x0000, /* R18245 */ - 0x0000, /* R18246 */ - 0x0000, /* R18247 */ - 0x0000, /* R18248 */ - 0x0000, /* R18249 */ - 0x0000, /* R18250 */ - 0x0000, /* R18251 */ - 0x0000, /* R18252 */ - 0x0000, /* R18253 */ - 0x0000, /* R18254 */ - 0x0000, /* R18255 */ - 0x0000, /* R18256 */ - 0x0000, /* R18257 */ - 0x0000, /* R18258 */ - 0x0000, /* R18259 */ - 0x0000, /* R18260 */ - 0x0000, /* R18261 */ - 0x0000, /* R18262 */ - 0x0000, /* R18263 */ - 0x0000, /* R18264 */ - 0x0000, /* R18265 */ - 0x0000, /* R18266 */ - 0x0000, /* R18267 */ - 0x0000, /* R18268 */ - 0x0000, /* R18269 */ - 0x0000, /* R18270 */ - 0x0000, /* R18271 */ - 0x0000, /* R18272 */ - 0x0000, /* R18273 */ - 0x0000, /* R18274 */ - 0x0000, /* R18275 */ - 0x0000, /* R18276 */ - 0x0000, /* R18277 */ - 0x0000, /* R18278 */ - 0x0000, /* R18279 */ - 0x0000, /* R18280 */ - 0x0000, /* R18281 */ - 0x0000, /* R18282 */ - 0x0000, /* R18283 */ - 0x0000, /* R18284 */ - 0x0000, /* R18285 */ - 0x0000, /* R18286 */ - 0x0000, /* R18287 */ - 0x0000, /* R18288 */ - 0x0000, /* R18289 */ - 0x0000, /* R18290 */ - 0x0000, /* R18291 */ - 0x0000, /* R18292 */ - 0x0000, /* R18293 */ - 0x0000, /* R18294 */ - 0x0000, /* R18295 */ - 0x0000, /* R18296 */ - 0x0000, /* R18297 */ - 0x0000, /* R18298 */ - 0x0000, /* R18299 */ - 0x0000, /* R18300 */ - 0x0000, /* R18301 */ - 0x0000, /* R18302 */ - 0x0000, /* R18303 */ - 0x0000, /* R18304 */ - 0x0000, /* R18305 */ - 0x0000, /* R18306 */ - 0x0000, /* R18307 */ - 0x0000, /* R18308 */ - 0x0000, /* R18309 */ - 0x0000, /* R18310 */ - 0x0000, /* R18311 */ - 0x0000, /* R18312 */ - 0x0000, /* R18313 */ - 0x0000, /* R18314 */ - 0x0000, /* R18315 */ - 0x0000, /* R18316 */ - 0x0000, /* R18317 */ - 0x0000, /* R18318 */ - 0x0000, /* R18319 */ - 0x0000, /* R18320 */ - 0x0000, /* R18321 */ - 0x0000, /* R18322 */ - 0x0000, /* R18323 */ - 0x0000, /* R18324 */ - 0x0000, /* R18325 */ - 0x0000, /* R18326 */ - 0x0000, /* R18327 */ - 0x0000, /* R18328 */ - 0x0000, /* R18329 */ - 0x0000, /* R18330 */ - 0x0000, /* R18331 */ - 0x0000, /* R18332 */ - 0x0000, /* R18333 */ - 0x0000, /* R18334 */ - 0x0000, /* R18335 */ - 0x0000, /* R18336 */ - 0x0000, /* R18337 */ - 0x0000, /* R18338 */ - 0x0000, /* R18339 */ - 0x0000, /* R18340 */ - 0x0000, /* R18341 */ - 0x0000, /* R18342 */ - 0x0000, /* R18343 */ - 0x0000, /* R18344 */ - 0x0000, /* R18345 */ - 0x0000, /* R18346 */ - 0x0000, /* R18347 */ - 0x0000, /* R18348 */ - 0x0000, /* R18349 */ - 0x0000, /* R18350 */ - 0x0000, /* R18351 */ - 0x0000, /* R18352 */ - 0x0000, /* R18353 */ - 0x0000, /* R18354 */ - 0x0000, /* R18355 */ - 0x0000, /* R18356 */ - 0x0000, /* R18357 */ - 0x0000, /* R18358 */ - 0x0000, /* R18359 */ - 0x0000, /* R18360 */ - 0x0000, /* R18361 */ - 0x0000, /* R18362 */ - 0x0000, /* R18363 */ - 0x0000, /* R18364 */ - 0x0000, /* R18365 */ - 0x0000, /* R18366 */ - 0x0000, /* R18367 */ - 0x0000, /* R18368 */ - 0x0000, /* R18369 */ - 0x0000, /* R18370 */ - 0x0000, /* R18371 */ - 0x0000, /* R18372 */ - 0x0000, /* R18373 */ - 0x0000, /* R18374 */ - 0x0000, /* R18375 */ - 0x0000, /* R18376 */ - 0x0000, /* R18377 */ - 0x0000, /* R18378 */ - 0x0000, /* R18379 */ - 0x0000, /* R18380 */ - 0x0000, /* R18381 */ - 0x0000, /* R18382 */ - 0x0000, /* R18383 */ - 0x0000, /* R18384 */ - 0x0000, /* R18385 */ - 0x0000, /* R18386 */ - 0x0000, /* R18387 */ - 0x0000, /* R18388 */ - 0x0000, /* R18389 */ - 0x0000, /* R18390 */ - 0x0000, /* R18391 */ - 0x0000, /* R18392 */ - 0x0000, /* R18393 */ - 0x0000, /* R18394 */ - 0x0000, /* R18395 */ - 0x0000, /* R18396 */ - 0x0000, /* R18397 */ - 0x0000, /* R18398 */ - 0x0000, /* R18399 */ - 0x0000, /* R18400 */ - 0x0000, /* R18401 */ - 0x0000, /* R18402 */ - 0x0000, /* R18403 */ - 0x0000, /* R18404 */ - 0x0000, /* R18405 */ - 0x0000, /* R18406 */ - 0x0000, /* R18407 */ - 0x0000, /* R18408 */ - 0x0000, /* R18409 */ - 0x0000, /* R18410 */ - 0x0000, /* R18411 */ - 0x0000, /* R18412 */ - 0x0000, /* R18413 */ - 0x0000, /* R18414 */ - 0x0000, /* R18415 */ - 0x0000, /* R18416 */ - 0x0000, /* R18417 */ - 0x0000, /* R18418 */ - 0x0000, /* R18419 */ - 0x0000, /* R18420 */ - 0x0000, /* R18421 */ - 0x0000, /* R18422 */ - 0x0000, /* R18423 */ - 0x0000, /* R18424 */ - 0x0000, /* R18425 */ - 0x0000, /* R18426 */ - 0x0000, /* R18427 */ - 0x0000, /* R18428 */ - 0x0000, /* R18429 */ - 0x0000, /* R18430 */ - 0x0000, /* R18431 */ - 0x0020, /* R18432 - RETUNEADC_PG2_1 */ - 0x0000, /* R18433 - RETUNEADC_PG2_0 */ - 0x0040, /* R18434 - RETUNEADC_PG_1 */ - 0x0000, /* R18435 - RETUNEADC_PG_0 */ - 0x0000, /* R18436 */ - 0x0000, /* R18437 */ - 0x0000, /* R18438 */ - 0x0000, /* R18439 */ - 0x0000, /* R18440 */ - 0x0000, /* R18441 */ - 0x0000, /* R18442 */ - 0x0000, /* R18443 */ - 0x0000, /* R18444 */ - 0x0000, /* R18445 */ - 0x0000, /* R18446 */ - 0x0000, /* R18447 */ - 0x0000, /* R18448 */ - 0x0000, /* R18449 */ - 0x0000, /* R18450 */ - 0x0000, /* R18451 */ - 0x0000, /* R18452 */ - 0x0000, /* R18453 */ - 0x0000, /* R18454 */ - 0x0000, /* R18455 */ - 0x0000, /* R18456 */ - 0x0000, /* R18457 */ - 0x0000, /* R18458 */ - 0x0000, /* R18459 */ - 0x0000, /* R18460 */ - 0x0000, /* R18461 */ - 0x0000, /* R18462 */ - 0x0000, /* R18463 */ - 0x0000, /* R18464 */ - 0x0000, /* R18465 */ - 0x0000, /* R18466 */ - 0x0000, /* R18467 */ - 0x0000, /* R18468 */ - 0x0000, /* R18469 */ - 0x0000, /* R18470 */ - 0x0000, /* R18471 */ - 0x0000, /* R18472 */ - 0x0000, /* R18473 */ - 0x0000, /* R18474 */ - 0x0000, /* R18475 */ - 0x0000, /* R18476 */ - 0x0000, /* R18477 */ - 0x0000, /* R18478 */ - 0x0000, /* R18479 */ - 0x0000, /* R18480 */ - 0x0000, /* R18481 */ - 0x0000, /* R18482 */ - 0x0000, /* R18483 */ - 0x0000, /* R18484 */ - 0x0000, /* R18485 */ - 0x0000, /* R18486 */ - 0x0000, /* R18487 */ - 0x0000, /* R18488 */ - 0x0000, /* R18489 */ - 0x0000, /* R18490 */ - 0x0000, /* R18491 */ - 0x0000, /* R18492 */ - 0x0000, /* R18493 */ - 0x0000, /* R18494 */ - 0x0000, /* R18495 */ - 0x0000, /* R18496 */ - 0x0000, /* R18497 */ - 0x0000, /* R18498 */ - 0x0000, /* R18499 */ - 0x0000, /* R18500 */ - 0x0000, /* R18501 */ - 0x0000, /* R18502 */ - 0x0000, /* R18503 */ - 0x0000, /* R18504 */ - 0x0000, /* R18505 */ - 0x0000, /* R18506 */ - 0x0000, /* R18507 */ - 0x0000, /* R18508 */ - 0x0000, /* R18509 */ - 0x0000, /* R18510 */ - 0x0000, /* R18511 */ - 0x0000, /* R18512 */ - 0x0000, /* R18513 */ - 0x0000, /* R18514 */ - 0x0000, /* R18515 */ - 0x0000, /* R18516 */ - 0x0000, /* R18517 */ - 0x0000, /* R18518 */ - 0x0000, /* R18519 */ - 0x0000, /* R18520 */ - 0x0000, /* R18521 */ - 0x0000, /* R18522 */ - 0x0000, /* R18523 */ - 0x0000, /* R18524 */ - 0x0000, /* R18525 */ - 0x0000, /* R18526 */ - 0x0000, /* R18527 */ - 0x0000, /* R18528 */ - 0x0000, /* R18529 */ - 0x0000, /* R18530 */ - 0x0000, /* R18531 */ - 0x0000, /* R18532 */ - 0x0000, /* R18533 */ - 0x0000, /* R18534 */ - 0x0000, /* R18535 */ - 0x0000, /* R18536 */ - 0x0000, /* R18537 */ - 0x0000, /* R18538 */ - 0x0000, /* R18539 */ - 0x0000, /* R18540 */ - 0x0000, /* R18541 */ - 0x0000, /* R18542 */ - 0x0000, /* R18543 */ - 0x0000, /* R18544 */ - 0x0000, /* R18545 */ - 0x0000, /* R18546 */ - 0x0000, /* R18547 */ - 0x0000, /* R18548 */ - 0x0000, /* R18549 */ - 0x0000, /* R18550 */ - 0x0000, /* R18551 */ - 0x0000, /* R18552 */ - 0x0000, /* R18553 */ - 0x0000, /* R18554 */ - 0x0000, /* R18555 */ - 0x0000, /* R18556 */ - 0x0000, /* R18557 */ - 0x0000, /* R18558 */ - 0x0000, /* R18559 */ - 0x0000, /* R18560 */ - 0x0000, /* R18561 */ - 0x0000, /* R18562 */ - 0x0000, /* R18563 */ - 0x0000, /* R18564 */ - 0x0000, /* R18565 */ - 0x0000, /* R18566 */ - 0x0000, /* R18567 */ - 0x0000, /* R18568 */ - 0x0000, /* R18569 */ - 0x0000, /* R18570 */ - 0x0000, /* R18571 */ - 0x0000, /* R18572 */ - 0x0000, /* R18573 */ - 0x0000, /* R18574 */ - 0x0000, /* R18575 */ - 0x0000, /* R18576 */ - 0x0000, /* R18577 */ - 0x0000, /* R18578 */ - 0x0000, /* R18579 */ - 0x0000, /* R18580 */ - 0x0000, /* R18581 */ - 0x0000, /* R18582 */ - 0x0000, /* R18583 */ - 0x0000, /* R18584 */ - 0x0000, /* R18585 */ - 0x0000, /* R18586 */ - 0x0000, /* R18587 */ - 0x0000, /* R18588 */ - 0x0000, /* R18589 */ - 0x0000, /* R18590 */ - 0x0000, /* R18591 */ - 0x0000, /* R18592 */ - 0x0000, /* R18593 */ - 0x0000, /* R18594 */ - 0x0000, /* R18595 */ - 0x0000, /* R18596 */ - 0x0000, /* R18597 */ - 0x0000, /* R18598 */ - 0x0000, /* R18599 */ - 0x0000, /* R18600 */ - 0x0000, /* R18601 */ - 0x0000, /* R18602 */ - 0x0000, /* R18603 */ - 0x0000, /* R18604 */ - 0x0000, /* R18605 */ - 0x0000, /* R18606 */ - 0x0000, /* R18607 */ - 0x0000, /* R18608 */ - 0x0000, /* R18609 */ - 0x0000, /* R18610 */ - 0x0000, /* R18611 */ - 0x0000, /* R18612 */ - 0x0000, /* R18613 */ - 0x0000, /* R18614 */ - 0x0000, /* R18615 */ - 0x0000, /* R18616 */ - 0x0000, /* R18617 */ - 0x0000, /* R18618 */ - 0x0000, /* R18619 */ - 0x0000, /* R18620 */ - 0x0000, /* R18621 */ - 0x0000, /* R18622 */ - 0x0000, /* R18623 */ - 0x0000, /* R18624 */ - 0x0000, /* R18625 */ - 0x0000, /* R18626 */ - 0x0000, /* R18627 */ - 0x0000, /* R18628 */ - 0x0000, /* R18629 */ - 0x0000, /* R18630 */ - 0x0000, /* R18631 */ - 0x0000, /* R18632 */ - 0x0000, /* R18633 */ - 0x0000, /* R18634 */ - 0x0000, /* R18635 */ - 0x0000, /* R18636 */ - 0x0000, /* R18637 */ - 0x0000, /* R18638 */ - 0x0000, /* R18639 */ - 0x0000, /* R18640 */ - 0x0000, /* R18641 */ - 0x0000, /* R18642 */ - 0x0000, /* R18643 */ - 0x0000, /* R18644 */ - 0x0000, /* R18645 */ - 0x0000, /* R18646 */ - 0x0000, /* R18647 */ - 0x0000, /* R18648 */ - 0x0000, /* R18649 */ - 0x0000, /* R18650 */ - 0x0000, /* R18651 */ - 0x0000, /* R18652 */ - 0x0000, /* R18653 */ - 0x0000, /* R18654 */ - 0x0000, /* R18655 */ - 0x0000, /* R18656 */ - 0x0000, /* R18657 */ - 0x0000, /* R18658 */ - 0x0000, /* R18659 */ - 0x0000, /* R18660 */ - 0x0000, /* R18661 */ - 0x0000, /* R18662 */ - 0x0000, /* R18663 */ - 0x0000, /* R18664 */ - 0x0000, /* R18665 */ - 0x0000, /* R18666 */ - 0x0000, /* R18667 */ - 0x0000, /* R18668 */ - 0x0000, /* R18669 */ - 0x0000, /* R18670 */ - 0x0000, /* R18671 */ - 0x0000, /* R18672 */ - 0x0000, /* R18673 */ - 0x0000, /* R18674 */ - 0x0000, /* R18675 */ - 0x0000, /* R18676 */ - 0x0000, /* R18677 */ - 0x0000, /* R18678 */ - 0x0000, /* R18679 */ - 0x0000, /* R18680 */ - 0x0000, /* R18681 */ - 0x0000, /* R18682 */ - 0x0000, /* R18683 */ - 0x0000, /* R18684 */ - 0x0000, /* R18685 */ - 0x0000, /* R18686 */ - 0x0000, /* R18687 */ - 0x0000, /* R18688 */ - 0x0000, /* R18689 */ - 0x0000, /* R18690 */ - 0x0000, /* R18691 */ - 0x0000, /* R18692 */ - 0x0000, /* R18693 */ - 0x0000, /* R18694 */ - 0x0000, /* R18695 */ - 0x0000, /* R18696 */ - 0x0000, /* R18697 */ - 0x0000, /* R18698 */ - 0x0000, /* R18699 */ - 0x0000, /* R18700 */ - 0x0000, /* R18701 */ - 0x0000, /* R18702 */ - 0x0000, /* R18703 */ - 0x0000, /* R18704 */ - 0x0000, /* R18705 */ - 0x0000, /* R18706 */ - 0x0000, /* R18707 */ - 0x0000, /* R18708 */ - 0x0000, /* R18709 */ - 0x0000, /* R18710 */ - 0x0000, /* R18711 */ - 0x0000, /* R18712 */ - 0x0000, /* R18713 */ - 0x0000, /* R18714 */ - 0x0000, /* R18715 */ - 0x0000, /* R18716 */ - 0x0000, /* R18717 */ - 0x0000, /* R18718 */ - 0x0000, /* R18719 */ - 0x0000, /* R18720 */ - 0x0000, /* R18721 */ - 0x0000, /* R18722 */ - 0x0000, /* R18723 */ - 0x0000, /* R18724 */ - 0x0000, /* R18725 */ - 0x0000, /* R18726 */ - 0x0000, /* R18727 */ - 0x0000, /* R18728 */ - 0x0000, /* R18729 */ - 0x0000, /* R18730 */ - 0x0000, /* R18731 */ - 0x0000, /* R18732 */ - 0x0000, /* R18733 */ - 0x0000, /* R18734 */ - 0x0000, /* R18735 */ - 0x0000, /* R18736 */ - 0x0000, /* R18737 */ - 0x0000, /* R18738 */ - 0x0000, /* R18739 */ - 0x0000, /* R18740 */ - 0x0000, /* R18741 */ - 0x0000, /* R18742 */ - 0x0000, /* R18743 */ - 0x0000, /* R18744 */ - 0x0000, /* R18745 */ - 0x0000, /* R18746 */ - 0x0000, /* R18747 */ - 0x0000, /* R18748 */ - 0x0000, /* R18749 */ - 0x0000, /* R18750 */ - 0x0000, /* R18751 */ - 0x0000, /* R18752 */ - 0x0000, /* R18753 */ - 0x0000, /* R18754 */ - 0x0000, /* R18755 */ - 0x0000, /* R18756 */ - 0x0000, /* R18757 */ - 0x0000, /* R18758 */ - 0x0000, /* R18759 */ - 0x0000, /* R18760 */ - 0x0000, /* R18761 */ - 0x0000, /* R18762 */ - 0x0000, /* R18763 */ - 0x0000, /* R18764 */ - 0x0000, /* R18765 */ - 0x0000, /* R18766 */ - 0x0000, /* R18767 */ - 0x0000, /* R18768 */ - 0x0000, /* R18769 */ - 0x0000, /* R18770 */ - 0x0000, /* R18771 */ - 0x0000, /* R18772 */ - 0x0000, /* R18773 */ - 0x0000, /* R18774 */ - 0x0000, /* R18775 */ - 0x0000, /* R18776 */ - 0x0000, /* R18777 */ - 0x0000, /* R18778 */ - 0x0000, /* R18779 */ - 0x0000, /* R18780 */ - 0x0000, /* R18781 */ - 0x0000, /* R18782 */ - 0x0000, /* R18783 */ - 0x0000, /* R18784 */ - 0x0000, /* R18785 */ - 0x0000, /* R18786 */ - 0x0000, /* R18787 */ - 0x0000, /* R18788 */ - 0x0000, /* R18789 */ - 0x0000, /* R18790 */ - 0x0000, /* R18791 */ - 0x0000, /* R18792 */ - 0x0000, /* R18793 */ - 0x0000, /* R18794 */ - 0x0000, /* R18795 */ - 0x0000, /* R18796 */ - 0x0000, /* R18797 */ - 0x0000, /* R18798 */ - 0x0000, /* R18799 */ - 0x0000, /* R18800 */ - 0x0000, /* R18801 */ - 0x0000, /* R18802 */ - 0x0000, /* R18803 */ - 0x0000, /* R18804 */ - 0x0000, /* R18805 */ - 0x0000, /* R18806 */ - 0x0000, /* R18807 */ - 0x0000, /* R18808 */ - 0x0000, /* R18809 */ - 0x0000, /* R18810 */ - 0x0000, /* R18811 */ - 0x0000, /* R18812 */ - 0x0000, /* R18813 */ - 0x0000, /* R18814 */ - 0x0000, /* R18815 */ - 0x0000, /* R18816 */ - 0x0000, /* R18817 */ - 0x0000, /* R18818 */ - 0x0000, /* R18819 */ - 0x0000, /* R18820 */ - 0x0000, /* R18821 */ - 0x0000, /* R18822 */ - 0x0000, /* R18823 */ - 0x0000, /* R18824 */ - 0x0000, /* R18825 */ - 0x0000, /* R18826 */ - 0x0000, /* R18827 */ - 0x0000, /* R18828 */ - 0x0000, /* R18829 */ - 0x0000, /* R18830 */ - 0x0000, /* R18831 */ - 0x0000, /* R18832 */ - 0x0000, /* R18833 */ - 0x0000, /* R18834 */ - 0x0000, /* R18835 */ - 0x0000, /* R18836 */ - 0x0000, /* R18837 */ - 0x0000, /* R18838 */ - 0x0000, /* R18839 */ - 0x0000, /* R18840 */ - 0x0000, /* R18841 */ - 0x0000, /* R18842 */ - 0x0000, /* R18843 */ - 0x0000, /* R18844 */ - 0x0000, /* R18845 */ - 0x0000, /* R18846 */ - 0x0000, /* R18847 */ - 0x0000, /* R18848 */ - 0x0000, /* R18849 */ - 0x0000, /* R18850 */ - 0x0000, /* R18851 */ - 0x0000, /* R18852 */ - 0x0000, /* R18853 */ - 0x0000, /* R18854 */ - 0x0000, /* R18855 */ - 0x0000, /* R18856 */ - 0x0000, /* R18857 */ - 0x0000, /* R18858 */ - 0x0000, /* R18859 */ - 0x0000, /* R18860 */ - 0x0000, /* R18861 */ - 0x0000, /* R18862 */ - 0x0000, /* R18863 */ - 0x0000, /* R18864 */ - 0x0000, /* R18865 */ - 0x0000, /* R18866 */ - 0x0000, /* R18867 */ - 0x0000, /* R18868 */ - 0x0000, /* R18869 */ - 0x0000, /* R18870 */ - 0x0000, /* R18871 */ - 0x0000, /* R18872 */ - 0x0000, /* R18873 */ - 0x0000, /* R18874 */ - 0x0000, /* R18875 */ - 0x0000, /* R18876 */ - 0x0000, /* R18877 */ - 0x0000, /* R18878 */ - 0x0000, /* R18879 */ - 0x0000, /* R18880 */ - 0x0000, /* R18881 */ - 0x0000, /* R18882 */ - 0x0000, /* R18883 */ - 0x0000, /* R18884 */ - 0x0000, /* R18885 */ - 0x0000, /* R18886 */ - 0x0000, /* R18887 */ - 0x0000, /* R18888 */ - 0x0000, /* R18889 */ - 0x0000, /* R18890 */ - 0x0000, /* R18891 */ - 0x0000, /* R18892 */ - 0x0000, /* R18893 */ - 0x0000, /* R18894 */ - 0x0000, /* R18895 */ - 0x0000, /* R18896 */ - 0x0000, /* R18897 */ - 0x0000, /* R18898 */ - 0x0000, /* R18899 */ - 0x0000, /* R18900 */ - 0x0000, /* R18901 */ - 0x0000, /* R18902 */ - 0x0000, /* R18903 */ - 0x0000, /* R18904 */ - 0x0000, /* R18905 */ - 0x0000, /* R18906 */ - 0x0000, /* R18907 */ - 0x0000, /* R18908 */ - 0x0000, /* R18909 */ - 0x0000, /* R18910 */ - 0x0000, /* R18911 */ - 0x0000, /* R18912 */ - 0x0000, /* R18913 */ - 0x0000, /* R18914 */ - 0x0000, /* R18915 */ - 0x0000, /* R18916 */ - 0x0000, /* R18917 */ - 0x0000, /* R18918 */ - 0x0000, /* R18919 */ - 0x0000, /* R18920 */ - 0x0000, /* R18921 */ - 0x0000, /* R18922 */ - 0x0000, /* R18923 */ - 0x0000, /* R18924 */ - 0x0000, /* R18925 */ - 0x0000, /* R18926 */ - 0x0000, /* R18927 */ - 0x0000, /* R18928 */ - 0x0000, /* R18929 */ - 0x0000, /* R18930 */ - 0x0000, /* R18931 */ - 0x0000, /* R18932 */ - 0x0000, /* R18933 */ - 0x0000, /* R18934 */ - 0x0000, /* R18935 */ - 0x0000, /* R18936 */ - 0x0000, /* R18937 */ - 0x0000, /* R18938 */ - 0x0000, /* R18939 */ - 0x0000, /* R18940 */ - 0x0000, /* R18941 */ - 0x0000, /* R18942 */ - 0x0000, /* R18943 */ - 0x007F, /* R18944 - ADCR_RETUNE_C1_1 */ - 0xFFFF, /* R18945 - ADCR_RETUNE_C1_0 */ - 0x0000, /* R18946 - ADCR_RETUNE_C2_1 */ - 0x0000, /* R18947 - ADCR_RETUNE_C2_0 */ - 0x0000, /* R18948 - ADCR_RETUNE_C3_1 */ - 0x0000, /* R18949 - ADCR_RETUNE_C3_0 */ - 0x0000, /* R18950 - ADCR_RETUNE_C4_1 */ - 0x0000, /* R18951 - ADCR_RETUNE_C4_0 */ - 0x0000, /* R18952 - ADCR_RETUNE_C5_1 */ - 0x0000, /* R18953 - ADCR_RETUNE_C5_0 */ - 0x0000, /* R18954 - ADCR_RETUNE_C6_1 */ - 0x0000, /* R18955 - ADCR_RETUNE_C6_0 */ - 0x0000, /* R18956 - ADCR_RETUNE_C7_1 */ - 0x0000, /* R18957 - ADCR_RETUNE_C7_0 */ - 0x0000, /* R18958 - ADCR_RETUNE_C8_1 */ - 0x0000, /* R18959 - ADCR_RETUNE_C8_0 */ - 0x0000, /* R18960 - ADCR_RETUNE_C9_1 */ - 0x0000, /* R18961 - ADCR_RETUNE_C9_0 */ - 0x0000, /* R18962 - ADCR_RETUNE_C10_1 */ - 0x0000, /* R18963 - ADCR_RETUNE_C10_0 */ - 0x0000, /* R18964 - ADCR_RETUNE_C11_1 */ - 0x0000, /* R18965 - ADCR_RETUNE_C11_0 */ - 0x0000, /* R18966 - ADCR_RETUNE_C12_1 */ - 0x0000, /* R18967 - ADCR_RETUNE_C12_0 */ - 0x0000, /* R18968 - ADCR_RETUNE_C13_1 */ - 0x0000, /* R18969 - ADCR_RETUNE_C13_0 */ - 0x0000, /* R18970 - ADCR_RETUNE_C14_1 */ - 0x0000, /* R18971 - ADCR_RETUNE_C14_0 */ - 0x0000, /* R18972 - ADCR_RETUNE_C15_1 */ - 0x0000, /* R18973 - ADCR_RETUNE_C15_0 */ - 0x0000, /* R18974 - ADCR_RETUNE_C16_1 */ - 0x0000, /* R18975 - ADCR_RETUNE_C16_0 */ - 0x0000, /* R18976 - ADCR_RETUNE_C17_1 */ - 0x0000, /* R18977 - ADCR_RETUNE_C17_0 */ - 0x0000, /* R18978 - ADCR_RETUNE_C18_1 */ - 0x0000, /* R18979 - ADCR_RETUNE_C18_0 */ - 0x0000, /* R18980 - ADCR_RETUNE_C19_1 */ - 0x0000, /* R18981 - ADCR_RETUNE_C19_0 */ - 0x0000, /* R18982 - ADCR_RETUNE_C20_1 */ - 0x0000, /* R18983 - ADCR_RETUNE_C20_0 */ - 0x0000, /* R18984 - ADCR_RETUNE_C21_1 */ - 0x0000, /* R18985 - ADCR_RETUNE_C21_0 */ - 0x0000, /* R18986 - ADCR_RETUNE_C22_1 */ - 0x0000, /* R18987 - ADCR_RETUNE_C22_0 */ - 0x0000, /* R18988 - ADCR_RETUNE_C23_1 */ - 0x0000, /* R18989 - ADCR_RETUNE_C23_0 */ - 0x0000, /* R18990 - ADCR_RETUNE_C24_1 */ - 0x0000, /* R18991 - ADCR_RETUNE_C24_0 */ - 0x0000, /* R18992 - ADCR_RETUNE_C25_1 */ - 0x0000, /* R18993 - ADCR_RETUNE_C25_0 */ - 0x0000, /* R18994 - ADCR_RETUNE_C26_1 */ - 0x0000, /* R18995 - ADCR_RETUNE_C26_0 */ - 0x0000, /* R18996 - ADCR_RETUNE_C27_1 */ - 0x0000, /* R18997 - ADCR_RETUNE_C27_0 */ - 0x0000, /* R18998 - ADCR_RETUNE_C28_1 */ - 0x0000, /* R18999 - ADCR_RETUNE_C28_0 */ - 0x0000, /* R19000 - ADCR_RETUNE_C29_1 */ - 0x0000, /* R19001 - ADCR_RETUNE_C29_0 */ - 0x0000, /* R19002 - ADCR_RETUNE_C30_1 */ - 0x0000, /* R19003 - ADCR_RETUNE_C30_0 */ - 0x0000, /* R19004 - ADCR_RETUNE_C31_1 */ - 0x0000, /* R19005 - ADCR_RETUNE_C31_0 */ - 0x0000, /* R19006 - ADCR_RETUNE_C32_1 */ - 0x0000, /* R19007 - ADCR_RETUNE_C32_0 */ - 0x0000, /* R19008 */ - 0x0000, /* R19009 */ - 0x0000, /* R19010 */ - 0x0000, /* R19011 */ - 0x0000, /* R19012 */ - 0x0000, /* R19013 */ - 0x0000, /* R19014 */ - 0x0000, /* R19015 */ - 0x0000, /* R19016 */ - 0x0000, /* R19017 */ - 0x0000, /* R19018 */ - 0x0000, /* R19019 */ - 0x0000, /* R19020 */ - 0x0000, /* R19021 */ - 0x0000, /* R19022 */ - 0x0000, /* R19023 */ - 0x0000, /* R19024 */ - 0x0000, /* R19025 */ - 0x0000, /* R19026 */ - 0x0000, /* R19027 */ - 0x0000, /* R19028 */ - 0x0000, /* R19029 */ - 0x0000, /* R19030 */ - 0x0000, /* R19031 */ - 0x0000, /* R19032 */ - 0x0000, /* R19033 */ - 0x0000, /* R19034 */ - 0x0000, /* R19035 */ - 0x0000, /* R19036 */ - 0x0000, /* R19037 */ - 0x0000, /* R19038 */ - 0x0000, /* R19039 */ - 0x0000, /* R19040 */ - 0x0000, /* R19041 */ - 0x0000, /* R19042 */ - 0x0000, /* R19043 */ - 0x0000, /* R19044 */ - 0x0000, /* R19045 */ - 0x0000, /* R19046 */ - 0x0000, /* R19047 */ - 0x0000, /* R19048 */ - 0x0000, /* R19049 */ - 0x0000, /* R19050 */ - 0x0000, /* R19051 */ - 0x0000, /* R19052 */ - 0x0000, /* R19053 */ - 0x0000, /* R19054 */ - 0x0000, /* R19055 */ - 0x0000, /* R19056 */ - 0x0000, /* R19057 */ - 0x0000, /* R19058 */ - 0x0000, /* R19059 */ - 0x0000, /* R19060 */ - 0x0000, /* R19061 */ - 0x0000, /* R19062 */ - 0x0000, /* R19063 */ - 0x0000, /* R19064 */ - 0x0000, /* R19065 */ - 0x0000, /* R19066 */ - 0x0000, /* R19067 */ - 0x0000, /* R19068 */ - 0x0000, /* R19069 */ - 0x0000, /* R19070 */ - 0x0000, /* R19071 */ - 0x0000, /* R19072 */ - 0x0000, /* R19073 */ - 0x0000, /* R19074 */ - 0x0000, /* R19075 */ - 0x0000, /* R19076 */ - 0x0000, /* R19077 */ - 0x0000, /* R19078 */ - 0x0000, /* R19079 */ - 0x0000, /* R19080 */ - 0x0000, /* R19081 */ - 0x0000, /* R19082 */ - 0x0000, /* R19083 */ - 0x0000, /* R19084 */ - 0x0000, /* R19085 */ - 0x0000, /* R19086 */ - 0x0000, /* R19087 */ - 0x0000, /* R19088 */ - 0x0000, /* R19089 */ - 0x0000, /* R19090 */ - 0x0000, /* R19091 */ - 0x0000, /* R19092 */ - 0x0000, /* R19093 */ - 0x0000, /* R19094 */ - 0x0000, /* R19095 */ - 0x0000, /* R19096 */ - 0x0000, /* R19097 */ - 0x0000, /* R19098 */ - 0x0000, /* R19099 */ - 0x0000, /* R19100 */ - 0x0000, /* R19101 */ - 0x0000, /* R19102 */ - 0x0000, /* R19103 */ - 0x0000, /* R19104 */ - 0x0000, /* R19105 */ - 0x0000, /* R19106 */ - 0x0000, /* R19107 */ - 0x0000, /* R19108 */ - 0x0000, /* R19109 */ - 0x0000, /* R19110 */ - 0x0000, /* R19111 */ - 0x0000, /* R19112 */ - 0x0000, /* R19113 */ - 0x0000, /* R19114 */ - 0x0000, /* R19115 */ - 0x0000, /* R19116 */ - 0x0000, /* R19117 */ - 0x0000, /* R19118 */ - 0x0000, /* R19119 */ - 0x0000, /* R19120 */ - 0x0000, /* R19121 */ - 0x0000, /* R19122 */ - 0x0000, /* R19123 */ - 0x0000, /* R19124 */ - 0x0000, /* R19125 */ - 0x0000, /* R19126 */ - 0x0000, /* R19127 */ - 0x0000, /* R19128 */ - 0x0000, /* R19129 */ - 0x0000, /* R19130 */ - 0x0000, /* R19131 */ - 0x0000, /* R19132 */ - 0x0000, /* R19133 */ - 0x0000, /* R19134 */ - 0x0000, /* R19135 */ - 0x0000, /* R19136 */ - 0x0000, /* R19137 */ - 0x0000, /* R19138 */ - 0x0000, /* R19139 */ - 0x0000, /* R19140 */ - 0x0000, /* R19141 */ - 0x0000, /* R19142 */ - 0x0000, /* R19143 */ - 0x0000, /* R19144 */ - 0x0000, /* R19145 */ - 0x0000, /* R19146 */ - 0x0000, /* R19147 */ - 0x0000, /* R19148 */ - 0x0000, /* R19149 */ - 0x0000, /* R19150 */ - 0x0000, /* R19151 */ - 0x0000, /* R19152 */ - 0x0000, /* R19153 */ - 0x0000, /* R19154 */ - 0x0000, /* R19155 */ - 0x0000, /* R19156 */ - 0x0000, /* R19157 */ - 0x0000, /* R19158 */ - 0x0000, /* R19159 */ - 0x0000, /* R19160 */ - 0x0000, /* R19161 */ - 0x0000, /* R19162 */ - 0x0000, /* R19163 */ - 0x0000, /* R19164 */ - 0x0000, /* R19165 */ - 0x0000, /* R19166 */ - 0x0000, /* R19167 */ - 0x0000, /* R19168 */ - 0x0000, /* R19169 */ - 0x0000, /* R19170 */ - 0x0000, /* R19171 */ - 0x0000, /* R19172 */ - 0x0000, /* R19173 */ - 0x0000, /* R19174 */ - 0x0000, /* R19175 */ - 0x0000, /* R19176 */ - 0x0000, /* R19177 */ - 0x0000, /* R19178 */ - 0x0000, /* R19179 */ - 0x0000, /* R19180 */ - 0x0000, /* R19181 */ - 0x0000, /* R19182 */ - 0x0000, /* R19183 */ - 0x0000, /* R19184 */ - 0x0000, /* R19185 */ - 0x0000, /* R19186 */ - 0x0000, /* R19187 */ - 0x0000, /* R19188 */ - 0x0000, /* R19189 */ - 0x0000, /* R19190 */ - 0x0000, /* R19191 */ - 0x0000, /* R19192 */ - 0x0000, /* R19193 */ - 0x0000, /* R19194 */ - 0x0000, /* R19195 */ - 0x0000, /* R19196 */ - 0x0000, /* R19197 */ - 0x0000, /* R19198 */ - 0x0000, /* R19199 */ - 0x0000, /* R19200 */ - 0x0000, /* R19201 */ - 0x0000, /* R19202 */ - 0x0000, /* R19203 */ - 0x0000, /* R19204 */ - 0x0000, /* R19205 */ - 0x0000, /* R19206 */ - 0x0000, /* R19207 */ - 0x0000, /* R19208 */ - 0x0000, /* R19209 */ - 0x0000, /* R19210 */ - 0x0000, /* R19211 */ - 0x0000, /* R19212 */ - 0x0000, /* R19213 */ - 0x0000, /* R19214 */ - 0x0000, /* R19215 */ - 0x0000, /* R19216 */ - 0x0000, /* R19217 */ - 0x0000, /* R19218 */ - 0x0000, /* R19219 */ - 0x0000, /* R19220 */ - 0x0000, /* R19221 */ - 0x0000, /* R19222 */ - 0x0000, /* R19223 */ - 0x0000, /* R19224 */ - 0x0000, /* R19225 */ - 0x0000, /* R19226 */ - 0x0000, /* R19227 */ - 0x0000, /* R19228 */ - 0x0000, /* R19229 */ - 0x0000, /* R19230 */ - 0x0000, /* R19231 */ - 0x0000, /* R19232 */ - 0x0000, /* R19233 */ - 0x0000, /* R19234 */ - 0x0000, /* R19235 */ - 0x0000, /* R19236 */ - 0x0000, /* R19237 */ - 0x0000, /* R19238 */ - 0x0000, /* R19239 */ - 0x0000, /* R19240 */ - 0x0000, /* R19241 */ - 0x0000, /* R19242 */ - 0x0000, /* R19243 */ - 0x0000, /* R19244 */ - 0x0000, /* R19245 */ - 0x0000, /* R19246 */ - 0x0000, /* R19247 */ - 0x0000, /* R19248 */ - 0x0000, /* R19249 */ - 0x0000, /* R19250 */ - 0x0000, /* R19251 */ - 0x0000, /* R19252 */ - 0x0000, /* R19253 */ - 0x0000, /* R19254 */ - 0x0000, /* R19255 */ - 0x0000, /* R19256 */ - 0x0000, /* R19257 */ - 0x0000, /* R19258 */ - 0x0000, /* R19259 */ - 0x0000, /* R19260 */ - 0x0000, /* R19261 */ - 0x0000, /* R19262 */ - 0x0000, /* R19263 */ - 0x0000, /* R19264 */ - 0x0000, /* R19265 */ - 0x0000, /* R19266 */ - 0x0000, /* R19267 */ - 0x0000, /* R19268 */ - 0x0000, /* R19269 */ - 0x0000, /* R19270 */ - 0x0000, /* R19271 */ - 0x0000, /* R19272 */ - 0x0000, /* R19273 */ - 0x0000, /* R19274 */ - 0x0000, /* R19275 */ - 0x0000, /* R19276 */ - 0x0000, /* R19277 */ - 0x0000, /* R19278 */ - 0x0000, /* R19279 */ - 0x0000, /* R19280 */ - 0x0000, /* R19281 */ - 0x0000, /* R19282 */ - 0x0000, /* R19283 */ - 0x0000, /* R19284 */ - 0x0000, /* R19285 */ - 0x0000, /* R19286 */ - 0x0000, /* R19287 */ - 0x0000, /* R19288 */ - 0x0000, /* R19289 */ - 0x0000, /* R19290 */ - 0x0000, /* R19291 */ - 0x0000, /* R19292 */ - 0x0000, /* R19293 */ - 0x0000, /* R19294 */ - 0x0000, /* R19295 */ - 0x0000, /* R19296 */ - 0x0000, /* R19297 */ - 0x0000, /* R19298 */ - 0x0000, /* R19299 */ - 0x0000, /* R19300 */ - 0x0000, /* R19301 */ - 0x0000, /* R19302 */ - 0x0000, /* R19303 */ - 0x0000, /* R19304 */ - 0x0000, /* R19305 */ - 0x0000, /* R19306 */ - 0x0000, /* R19307 */ - 0x0000, /* R19308 */ - 0x0000, /* R19309 */ - 0x0000, /* R19310 */ - 0x0000, /* R19311 */ - 0x0000, /* R19312 */ - 0x0000, /* R19313 */ - 0x0000, /* R19314 */ - 0x0000, /* R19315 */ - 0x0000, /* R19316 */ - 0x0000, /* R19317 */ - 0x0000, /* R19318 */ - 0x0000, /* R19319 */ - 0x0000, /* R19320 */ - 0x0000, /* R19321 */ - 0x0000, /* R19322 */ - 0x0000, /* R19323 */ - 0x0000, /* R19324 */ - 0x0000, /* R19325 */ - 0x0000, /* R19326 */ - 0x0000, /* R19327 */ - 0x0000, /* R19328 */ - 0x0000, /* R19329 */ - 0x0000, /* R19330 */ - 0x0000, /* R19331 */ - 0x0000, /* R19332 */ - 0x0000, /* R19333 */ - 0x0000, /* R19334 */ - 0x0000, /* R19335 */ - 0x0000, /* R19336 */ - 0x0000, /* R19337 */ - 0x0000, /* R19338 */ - 0x0000, /* R19339 */ - 0x0000, /* R19340 */ - 0x0000, /* R19341 */ - 0x0000, /* R19342 */ - 0x0000, /* R19343 */ - 0x0000, /* R19344 */ - 0x0000, /* R19345 */ - 0x0000, /* R19346 */ - 0x0000, /* R19347 */ - 0x0000, /* R19348 */ - 0x0000, /* R19349 */ - 0x0000, /* R19350 */ - 0x0000, /* R19351 */ - 0x0000, /* R19352 */ - 0x0000, /* R19353 */ - 0x0000, /* R19354 */ - 0x0000, /* R19355 */ - 0x0000, /* R19356 */ - 0x0000, /* R19357 */ - 0x0000, /* R19358 */ - 0x0000, /* R19359 */ - 0x0000, /* R19360 */ - 0x0000, /* R19361 */ - 0x0000, /* R19362 */ - 0x0000, /* R19363 */ - 0x0000, /* R19364 */ - 0x0000, /* R19365 */ - 0x0000, /* R19366 */ - 0x0000, /* R19367 */ - 0x0000, /* R19368 */ - 0x0000, /* R19369 */ - 0x0000, /* R19370 */ - 0x0000, /* R19371 */ - 0x0000, /* R19372 */ - 0x0000, /* R19373 */ - 0x0000, /* R19374 */ - 0x0000, /* R19375 */ - 0x0000, /* R19376 */ - 0x0000, /* R19377 */ - 0x0000, /* R19378 */ - 0x0000, /* R19379 */ - 0x0000, /* R19380 */ - 0x0000, /* R19381 */ - 0x0000, /* R19382 */ - 0x0000, /* R19383 */ - 0x0000, /* R19384 */ - 0x0000, /* R19385 */ - 0x0000, /* R19386 */ - 0x0000, /* R19387 */ - 0x0000, /* R19388 */ - 0x0000, /* R19389 */ - 0x0000, /* R19390 */ - 0x0000, /* R19391 */ - 0x0000, /* R19392 */ - 0x0000, /* R19393 */ - 0x0000, /* R19394 */ - 0x0000, /* R19395 */ - 0x0000, /* R19396 */ - 0x0000, /* R19397 */ - 0x0000, /* R19398 */ - 0x0000, /* R19399 */ - 0x0000, /* R19400 */ - 0x0000, /* R19401 */ - 0x0000, /* R19402 */ - 0x0000, /* R19403 */ - 0x0000, /* R19404 */ - 0x0000, /* R19405 */ - 0x0000, /* R19406 */ - 0x0000, /* R19407 */ - 0x0000, /* R19408 */ - 0x0000, /* R19409 */ - 0x0000, /* R19410 */ - 0x0000, /* R19411 */ - 0x0000, /* R19412 */ - 0x0000, /* R19413 */ - 0x0000, /* R19414 */ - 0x0000, /* R19415 */ - 0x0000, /* R19416 */ - 0x0000, /* R19417 */ - 0x0000, /* R19418 */ - 0x0000, /* R19419 */ - 0x0000, /* R19420 */ - 0x0000, /* R19421 */ - 0x0000, /* R19422 */ - 0x0000, /* R19423 */ - 0x0000, /* R19424 */ - 0x0000, /* R19425 */ - 0x0000, /* R19426 */ - 0x0000, /* R19427 */ - 0x0000, /* R19428 */ - 0x0000, /* R19429 */ - 0x0000, /* R19430 */ - 0x0000, /* R19431 */ - 0x0000, /* R19432 */ - 0x0000, /* R19433 */ - 0x0000, /* R19434 */ - 0x0000, /* R19435 */ - 0x0000, /* R19436 */ - 0x0000, /* R19437 */ - 0x0000, /* R19438 */ - 0x0000, /* R19439 */ - 0x0000, /* R19440 */ - 0x0000, /* R19441 */ - 0x0000, /* R19442 */ - 0x0000, /* R19443 */ - 0x0000, /* R19444 */ - 0x0000, /* R19445 */ - 0x0000, /* R19446 */ - 0x0000, /* R19447 */ - 0x0000, /* R19448 */ - 0x0000, /* R19449 */ - 0x0000, /* R19450 */ - 0x0000, /* R19451 */ - 0x0000, /* R19452 */ - 0x0000, /* R19453 */ - 0x0000, /* R19454 */ - 0x0000, /* R19455 */ - 0x007F, /* R19456 - DACL_RETUNE_C1_1 */ - 0xFFFF, /* R19457 - DACL_RETUNE_C1_0 */ - 0x0000, /* R19458 - DACL_RETUNE_C2_1 */ - 0x0000, /* R19459 - DACL_RETUNE_C2_0 */ - 0x0000, /* R19460 - DACL_RETUNE_C3_1 */ - 0x0000, /* R19461 - DACL_RETUNE_C3_0 */ - 0x0000, /* R19462 - DACL_RETUNE_C4_1 */ - 0x0000, /* R19463 - DACL_RETUNE_C4_0 */ - 0x0000, /* R19464 - DACL_RETUNE_C5_1 */ - 0x0000, /* R19465 - DACL_RETUNE_C5_0 */ - 0x0000, /* R19466 - DACL_RETUNE_C6_1 */ - 0x0000, /* R19467 - DACL_RETUNE_C6_0 */ - 0x0000, /* R19468 - DACL_RETUNE_C7_1 */ - 0x0000, /* R19469 - DACL_RETUNE_C7_0 */ - 0x0000, /* R19470 - DACL_RETUNE_C8_1 */ - 0x0000, /* R19471 - DACL_RETUNE_C8_0 */ - 0x0000, /* R19472 - DACL_RETUNE_C9_1 */ - 0x0000, /* R19473 - DACL_RETUNE_C9_0 */ - 0x0000, /* R19474 - DACL_RETUNE_C10_1 */ - 0x0000, /* R19475 - DACL_RETUNE_C10_0 */ - 0x0000, /* R19476 - DACL_RETUNE_C11_1 */ - 0x0000, /* R19477 - DACL_RETUNE_C11_0 */ - 0x0000, /* R19478 - DACL_RETUNE_C12_1 */ - 0x0000, /* R19479 - DACL_RETUNE_C12_0 */ - 0x0000, /* R19480 - DACL_RETUNE_C13_1 */ - 0x0000, /* R19481 - DACL_RETUNE_C13_0 */ - 0x0000, /* R19482 - DACL_RETUNE_C14_1 */ - 0x0000, /* R19483 - DACL_RETUNE_C14_0 */ - 0x0000, /* R19484 - DACL_RETUNE_C15_1 */ - 0x0000, /* R19485 - DACL_RETUNE_C15_0 */ - 0x0000, /* R19486 - DACL_RETUNE_C16_1 */ - 0x0000, /* R19487 - DACL_RETUNE_C16_0 */ - 0x0000, /* R19488 - DACL_RETUNE_C17_1 */ - 0x0000, /* R19489 - DACL_RETUNE_C17_0 */ - 0x0000, /* R19490 - DACL_RETUNE_C18_1 */ - 0x0000, /* R19491 - DACL_RETUNE_C18_0 */ - 0x0000, /* R19492 - DACL_RETUNE_C19_1 */ - 0x0000, /* R19493 - DACL_RETUNE_C19_0 */ - 0x0000, /* R19494 - DACL_RETUNE_C20_1 */ - 0x0000, /* R19495 - DACL_RETUNE_C20_0 */ - 0x0000, /* R19496 - DACL_RETUNE_C21_1 */ - 0x0000, /* R19497 - DACL_RETUNE_C21_0 */ - 0x0000, /* R19498 - DACL_RETUNE_C22_1 */ - 0x0000, /* R19499 - DACL_RETUNE_C22_0 */ - 0x0000, /* R19500 - DACL_RETUNE_C23_1 */ - 0x0000, /* R19501 - DACL_RETUNE_C23_0 */ - 0x0000, /* R19502 - DACL_RETUNE_C24_1 */ - 0x0000, /* R19503 - DACL_RETUNE_C24_0 */ - 0x0000, /* R19504 - DACL_RETUNE_C25_1 */ - 0x0000, /* R19505 - DACL_RETUNE_C25_0 */ - 0x0000, /* R19506 - DACL_RETUNE_C26_1 */ - 0x0000, /* R19507 - DACL_RETUNE_C26_0 */ - 0x0000, /* R19508 - DACL_RETUNE_C27_1 */ - 0x0000, /* R19509 - DACL_RETUNE_C27_0 */ - 0x0000, /* R19510 - DACL_RETUNE_C28_1 */ - 0x0000, /* R19511 - DACL_RETUNE_C28_0 */ - 0x0000, /* R19512 - DACL_RETUNE_C29_1 */ - 0x0000, /* R19513 - DACL_RETUNE_C29_0 */ - 0x0000, /* R19514 - DACL_RETUNE_C30_1 */ - 0x0000, /* R19515 - DACL_RETUNE_C30_0 */ - 0x0000, /* R19516 - DACL_RETUNE_C31_1 */ - 0x0000, /* R19517 - DACL_RETUNE_C31_0 */ - 0x0000, /* R19518 - DACL_RETUNE_C32_1 */ - 0x0000, /* R19519 - DACL_RETUNE_C32_0 */ - 0x0000, /* R19520 */ - 0x0000, /* R19521 */ - 0x0000, /* R19522 */ - 0x0000, /* R19523 */ - 0x0000, /* R19524 */ - 0x0000, /* R19525 */ - 0x0000, /* R19526 */ - 0x0000, /* R19527 */ - 0x0000, /* R19528 */ - 0x0000, /* R19529 */ - 0x0000, /* R19530 */ - 0x0000, /* R19531 */ - 0x0000, /* R19532 */ - 0x0000, /* R19533 */ - 0x0000, /* R19534 */ - 0x0000, /* R19535 */ - 0x0000, /* R19536 */ - 0x0000, /* R19537 */ - 0x0000, /* R19538 */ - 0x0000, /* R19539 */ - 0x0000, /* R19540 */ - 0x0000, /* R19541 */ - 0x0000, /* R19542 */ - 0x0000, /* R19543 */ - 0x0000, /* R19544 */ - 0x0000, /* R19545 */ - 0x0000, /* R19546 */ - 0x0000, /* R19547 */ - 0x0000, /* R19548 */ - 0x0000, /* R19549 */ - 0x0000, /* R19550 */ - 0x0000, /* R19551 */ - 0x0000, /* R19552 */ - 0x0000, /* R19553 */ - 0x0000, /* R19554 */ - 0x0000, /* R19555 */ - 0x0000, /* R19556 */ - 0x0000, /* R19557 */ - 0x0000, /* R19558 */ - 0x0000, /* R19559 */ - 0x0000, /* R19560 */ - 0x0000, /* R19561 */ - 0x0000, /* R19562 */ - 0x0000, /* R19563 */ - 0x0000, /* R19564 */ - 0x0000, /* R19565 */ - 0x0000, /* R19566 */ - 0x0000, /* R19567 */ - 0x0000, /* R19568 */ - 0x0000, /* R19569 */ - 0x0000, /* R19570 */ - 0x0000, /* R19571 */ - 0x0000, /* R19572 */ - 0x0000, /* R19573 */ - 0x0000, /* R19574 */ - 0x0000, /* R19575 */ - 0x0000, /* R19576 */ - 0x0000, /* R19577 */ - 0x0000, /* R19578 */ - 0x0000, /* R19579 */ - 0x0000, /* R19580 */ - 0x0000, /* R19581 */ - 0x0000, /* R19582 */ - 0x0000, /* R19583 */ - 0x0000, /* R19584 */ - 0x0000, /* R19585 */ - 0x0000, /* R19586 */ - 0x0000, /* R19587 */ - 0x0000, /* R19588 */ - 0x0000, /* R19589 */ - 0x0000, /* R19590 */ - 0x0000, /* R19591 */ - 0x0000, /* R19592 */ - 0x0000, /* R19593 */ - 0x0000, /* R19594 */ - 0x0000, /* R19595 */ - 0x0000, /* R19596 */ - 0x0000, /* R19597 */ - 0x0000, /* R19598 */ - 0x0000, /* R19599 */ - 0x0000, /* R19600 */ - 0x0000, /* R19601 */ - 0x0000, /* R19602 */ - 0x0000, /* R19603 */ - 0x0000, /* R19604 */ - 0x0000, /* R19605 */ - 0x0000, /* R19606 */ - 0x0000, /* R19607 */ - 0x0000, /* R19608 */ - 0x0000, /* R19609 */ - 0x0000, /* R19610 */ - 0x0000, /* R19611 */ - 0x0000, /* R19612 */ - 0x0000, /* R19613 */ - 0x0000, /* R19614 */ - 0x0000, /* R19615 */ - 0x0000, /* R19616 */ - 0x0000, /* R19617 */ - 0x0000, /* R19618 */ - 0x0000, /* R19619 */ - 0x0000, /* R19620 */ - 0x0000, /* R19621 */ - 0x0000, /* R19622 */ - 0x0000, /* R19623 */ - 0x0000, /* R19624 */ - 0x0000, /* R19625 */ - 0x0000, /* R19626 */ - 0x0000, /* R19627 */ - 0x0000, /* R19628 */ - 0x0000, /* R19629 */ - 0x0000, /* R19630 */ - 0x0000, /* R19631 */ - 0x0000, /* R19632 */ - 0x0000, /* R19633 */ - 0x0000, /* R19634 */ - 0x0000, /* R19635 */ - 0x0000, /* R19636 */ - 0x0000, /* R19637 */ - 0x0000, /* R19638 */ - 0x0000, /* R19639 */ - 0x0000, /* R19640 */ - 0x0000, /* R19641 */ - 0x0000, /* R19642 */ - 0x0000, /* R19643 */ - 0x0000, /* R19644 */ - 0x0000, /* R19645 */ - 0x0000, /* R19646 */ - 0x0000, /* R19647 */ - 0x0000, /* R19648 */ - 0x0000, /* R19649 */ - 0x0000, /* R19650 */ - 0x0000, /* R19651 */ - 0x0000, /* R19652 */ - 0x0000, /* R19653 */ - 0x0000, /* R19654 */ - 0x0000, /* R19655 */ - 0x0000, /* R19656 */ - 0x0000, /* R19657 */ - 0x0000, /* R19658 */ - 0x0000, /* R19659 */ - 0x0000, /* R19660 */ - 0x0000, /* R19661 */ - 0x0000, /* R19662 */ - 0x0000, /* R19663 */ - 0x0000, /* R19664 */ - 0x0000, /* R19665 */ - 0x0000, /* R19666 */ - 0x0000, /* R19667 */ - 0x0000, /* R19668 */ - 0x0000, /* R19669 */ - 0x0000, /* R19670 */ - 0x0000, /* R19671 */ - 0x0000, /* R19672 */ - 0x0000, /* R19673 */ - 0x0000, /* R19674 */ - 0x0000, /* R19675 */ - 0x0000, /* R19676 */ - 0x0000, /* R19677 */ - 0x0000, /* R19678 */ - 0x0000, /* R19679 */ - 0x0000, /* R19680 */ - 0x0000, /* R19681 */ - 0x0000, /* R19682 */ - 0x0000, /* R19683 */ - 0x0000, /* R19684 */ - 0x0000, /* R19685 */ - 0x0000, /* R19686 */ - 0x0000, /* R19687 */ - 0x0000, /* R19688 */ - 0x0000, /* R19689 */ - 0x0000, /* R19690 */ - 0x0000, /* R19691 */ - 0x0000, /* R19692 */ - 0x0000, /* R19693 */ - 0x0000, /* R19694 */ - 0x0000, /* R19695 */ - 0x0000, /* R19696 */ - 0x0000, /* R19697 */ - 0x0000, /* R19698 */ - 0x0000, /* R19699 */ - 0x0000, /* R19700 */ - 0x0000, /* R19701 */ - 0x0000, /* R19702 */ - 0x0000, /* R19703 */ - 0x0000, /* R19704 */ - 0x0000, /* R19705 */ - 0x0000, /* R19706 */ - 0x0000, /* R19707 */ - 0x0000, /* R19708 */ - 0x0000, /* R19709 */ - 0x0000, /* R19710 */ - 0x0000, /* R19711 */ - 0x0000, /* R19712 */ - 0x0000, /* R19713 */ - 0x0000, /* R19714 */ - 0x0000, /* R19715 */ - 0x0000, /* R19716 */ - 0x0000, /* R19717 */ - 0x0000, /* R19718 */ - 0x0000, /* R19719 */ - 0x0000, /* R19720 */ - 0x0000, /* R19721 */ - 0x0000, /* R19722 */ - 0x0000, /* R19723 */ - 0x0000, /* R19724 */ - 0x0000, /* R19725 */ - 0x0000, /* R19726 */ - 0x0000, /* R19727 */ - 0x0000, /* R19728 */ - 0x0000, /* R19729 */ - 0x0000, /* R19730 */ - 0x0000, /* R19731 */ - 0x0000, /* R19732 */ - 0x0000, /* R19733 */ - 0x0000, /* R19734 */ - 0x0000, /* R19735 */ - 0x0000, /* R19736 */ - 0x0000, /* R19737 */ - 0x0000, /* R19738 */ - 0x0000, /* R19739 */ - 0x0000, /* R19740 */ - 0x0000, /* R19741 */ - 0x0000, /* R19742 */ - 0x0000, /* R19743 */ - 0x0000, /* R19744 */ - 0x0000, /* R19745 */ - 0x0000, /* R19746 */ - 0x0000, /* R19747 */ - 0x0000, /* R19748 */ - 0x0000, /* R19749 */ - 0x0000, /* R19750 */ - 0x0000, /* R19751 */ - 0x0000, /* R19752 */ - 0x0000, /* R19753 */ - 0x0000, /* R19754 */ - 0x0000, /* R19755 */ - 0x0000, /* R19756 */ - 0x0000, /* R19757 */ - 0x0000, /* R19758 */ - 0x0000, /* R19759 */ - 0x0000, /* R19760 */ - 0x0000, /* R19761 */ - 0x0000, /* R19762 */ - 0x0000, /* R19763 */ - 0x0000, /* R19764 */ - 0x0000, /* R19765 */ - 0x0000, /* R19766 */ - 0x0000, /* R19767 */ - 0x0000, /* R19768 */ - 0x0000, /* R19769 */ - 0x0000, /* R19770 */ - 0x0000, /* R19771 */ - 0x0000, /* R19772 */ - 0x0000, /* R19773 */ - 0x0000, /* R19774 */ - 0x0000, /* R19775 */ - 0x0000, /* R19776 */ - 0x0000, /* R19777 */ - 0x0000, /* R19778 */ - 0x0000, /* R19779 */ - 0x0000, /* R19780 */ - 0x0000, /* R19781 */ - 0x0000, /* R19782 */ - 0x0000, /* R19783 */ - 0x0000, /* R19784 */ - 0x0000, /* R19785 */ - 0x0000, /* R19786 */ - 0x0000, /* R19787 */ - 0x0000, /* R19788 */ - 0x0000, /* R19789 */ - 0x0000, /* R19790 */ - 0x0000, /* R19791 */ - 0x0000, /* R19792 */ - 0x0000, /* R19793 */ - 0x0000, /* R19794 */ - 0x0000, /* R19795 */ - 0x0000, /* R19796 */ - 0x0000, /* R19797 */ - 0x0000, /* R19798 */ - 0x0000, /* R19799 */ - 0x0000, /* R19800 */ - 0x0000, /* R19801 */ - 0x0000, /* R19802 */ - 0x0000, /* R19803 */ - 0x0000, /* R19804 */ - 0x0000, /* R19805 */ - 0x0000, /* R19806 */ - 0x0000, /* R19807 */ - 0x0000, /* R19808 */ - 0x0000, /* R19809 */ - 0x0000, /* R19810 */ - 0x0000, /* R19811 */ - 0x0000, /* R19812 */ - 0x0000, /* R19813 */ - 0x0000, /* R19814 */ - 0x0000, /* R19815 */ - 0x0000, /* R19816 */ - 0x0000, /* R19817 */ - 0x0000, /* R19818 */ - 0x0000, /* R19819 */ - 0x0000, /* R19820 */ - 0x0000, /* R19821 */ - 0x0000, /* R19822 */ - 0x0000, /* R19823 */ - 0x0000, /* R19824 */ - 0x0000, /* R19825 */ - 0x0000, /* R19826 */ - 0x0000, /* R19827 */ - 0x0000, /* R19828 */ - 0x0000, /* R19829 */ - 0x0000, /* R19830 */ - 0x0000, /* R19831 */ - 0x0000, /* R19832 */ - 0x0000, /* R19833 */ - 0x0000, /* R19834 */ - 0x0000, /* R19835 */ - 0x0000, /* R19836 */ - 0x0000, /* R19837 */ - 0x0000, /* R19838 */ - 0x0000, /* R19839 */ - 0x0000, /* R19840 */ - 0x0000, /* R19841 */ - 0x0000, /* R19842 */ - 0x0000, /* R19843 */ - 0x0000, /* R19844 */ - 0x0000, /* R19845 */ - 0x0000, /* R19846 */ - 0x0000, /* R19847 */ - 0x0000, /* R19848 */ - 0x0000, /* R19849 */ - 0x0000, /* R19850 */ - 0x0000, /* R19851 */ - 0x0000, /* R19852 */ - 0x0000, /* R19853 */ - 0x0000, /* R19854 */ - 0x0000, /* R19855 */ - 0x0000, /* R19856 */ - 0x0000, /* R19857 */ - 0x0000, /* R19858 */ - 0x0000, /* R19859 */ - 0x0000, /* R19860 */ - 0x0000, /* R19861 */ - 0x0000, /* R19862 */ - 0x0000, /* R19863 */ - 0x0000, /* R19864 */ - 0x0000, /* R19865 */ - 0x0000, /* R19866 */ - 0x0000, /* R19867 */ - 0x0000, /* R19868 */ - 0x0000, /* R19869 */ - 0x0000, /* R19870 */ - 0x0000, /* R19871 */ - 0x0000, /* R19872 */ - 0x0000, /* R19873 */ - 0x0000, /* R19874 */ - 0x0000, /* R19875 */ - 0x0000, /* R19876 */ - 0x0000, /* R19877 */ - 0x0000, /* R19878 */ - 0x0000, /* R19879 */ - 0x0000, /* R19880 */ - 0x0000, /* R19881 */ - 0x0000, /* R19882 */ - 0x0000, /* R19883 */ - 0x0000, /* R19884 */ - 0x0000, /* R19885 */ - 0x0000, /* R19886 */ - 0x0000, /* R19887 */ - 0x0000, /* R19888 */ - 0x0000, /* R19889 */ - 0x0000, /* R19890 */ - 0x0000, /* R19891 */ - 0x0000, /* R19892 */ - 0x0000, /* R19893 */ - 0x0000, /* R19894 */ - 0x0000, /* R19895 */ - 0x0000, /* R19896 */ - 0x0000, /* R19897 */ - 0x0000, /* R19898 */ - 0x0000, /* R19899 */ - 0x0000, /* R19900 */ - 0x0000, /* R19901 */ - 0x0000, /* R19902 */ - 0x0000, /* R19903 */ - 0x0000, /* R19904 */ - 0x0000, /* R19905 */ - 0x0000, /* R19906 */ - 0x0000, /* R19907 */ - 0x0000, /* R19908 */ - 0x0000, /* R19909 */ - 0x0000, /* R19910 */ - 0x0000, /* R19911 */ - 0x0000, /* R19912 */ - 0x0000, /* R19913 */ - 0x0000, /* R19914 */ - 0x0000, /* R19915 */ - 0x0000, /* R19916 */ - 0x0000, /* R19917 */ - 0x0000, /* R19918 */ - 0x0000, /* R19919 */ - 0x0000, /* R19920 */ - 0x0000, /* R19921 */ - 0x0000, /* R19922 */ - 0x0000, /* R19923 */ - 0x0000, /* R19924 */ - 0x0000, /* R19925 */ - 0x0000, /* R19926 */ - 0x0000, /* R19927 */ - 0x0000, /* R19928 */ - 0x0000, /* R19929 */ - 0x0000, /* R19930 */ - 0x0000, /* R19931 */ - 0x0000, /* R19932 */ - 0x0000, /* R19933 */ - 0x0000, /* R19934 */ - 0x0000, /* R19935 */ - 0x0000, /* R19936 */ - 0x0000, /* R19937 */ - 0x0000, /* R19938 */ - 0x0000, /* R19939 */ - 0x0000, /* R19940 */ - 0x0000, /* R19941 */ - 0x0000, /* R19942 */ - 0x0000, /* R19943 */ - 0x0000, /* R19944 */ - 0x0000, /* R19945 */ - 0x0000, /* R19946 */ - 0x0000, /* R19947 */ - 0x0000, /* R19948 */ - 0x0000, /* R19949 */ - 0x0000, /* R19950 */ - 0x0000, /* R19951 */ - 0x0000, /* R19952 */ - 0x0000, /* R19953 */ - 0x0000, /* R19954 */ - 0x0000, /* R19955 */ - 0x0000, /* R19956 */ - 0x0000, /* R19957 */ - 0x0000, /* R19958 */ - 0x0000, /* R19959 */ - 0x0000, /* R19960 */ - 0x0000, /* R19961 */ - 0x0000, /* R19962 */ - 0x0000, /* R19963 */ - 0x0000, /* R19964 */ - 0x0000, /* R19965 */ - 0x0000, /* R19966 */ - 0x0000, /* R19967 */ - 0x0020, /* R19968 - RETUNEDAC_PG2_1 */ - 0x0000, /* R19969 - RETUNEDAC_PG2_0 */ - 0x0040, /* R19970 - RETUNEDAC_PG_1 */ - 0x0000, /* R19971 - RETUNEDAC_PG_0 */ - 0x0000, /* R19972 */ - 0x0000, /* R19973 */ - 0x0000, /* R19974 */ - 0x0000, /* R19975 */ - 0x0000, /* R19976 */ - 0x0000, /* R19977 */ - 0x0000, /* R19978 */ - 0x0000, /* R19979 */ - 0x0000, /* R19980 */ - 0x0000, /* R19981 */ - 0x0000, /* R19982 */ - 0x0000, /* R19983 */ - 0x0000, /* R19984 */ - 0x0000, /* R19985 */ - 0x0000, /* R19986 */ - 0x0000, /* R19987 */ - 0x0000, /* R19988 */ - 0x0000, /* R19989 */ - 0x0000, /* R19990 */ - 0x0000, /* R19991 */ - 0x0000, /* R19992 */ - 0x0000, /* R19993 */ - 0x0000, /* R19994 */ - 0x0000, /* R19995 */ - 0x0000, /* R19996 */ - 0x0000, /* R19997 */ - 0x0000, /* R19998 */ - 0x0000, /* R19999 */ - 0x0000, /* R20000 */ - 0x0000, /* R20001 */ - 0x0000, /* R20002 */ - 0x0000, /* R20003 */ - 0x0000, /* R20004 */ - 0x0000, /* R20005 */ - 0x0000, /* R20006 */ - 0x0000, /* R20007 */ - 0x0000, /* R20008 */ - 0x0000, /* R20009 */ - 0x0000, /* R20010 */ - 0x0000, /* R20011 */ - 0x0000, /* R20012 */ - 0x0000, /* R20013 */ - 0x0000, /* R20014 */ - 0x0000, /* R20015 */ - 0x0000, /* R20016 */ - 0x0000, /* R20017 */ - 0x0000, /* R20018 */ - 0x0000, /* R20019 */ - 0x0000, /* R20020 */ - 0x0000, /* R20021 */ - 0x0000, /* R20022 */ - 0x0000, /* R20023 */ - 0x0000, /* R20024 */ - 0x0000, /* R20025 */ - 0x0000, /* R20026 */ - 0x0000, /* R20027 */ - 0x0000, /* R20028 */ - 0x0000, /* R20029 */ - 0x0000, /* R20030 */ - 0x0000, /* R20031 */ - 0x0000, /* R20032 */ - 0x0000, /* R20033 */ - 0x0000, /* R20034 */ - 0x0000, /* R20035 */ - 0x0000, /* R20036 */ - 0x0000, /* R20037 */ - 0x0000, /* R20038 */ - 0x0000, /* R20039 */ - 0x0000, /* R20040 */ - 0x0000, /* R20041 */ - 0x0000, /* R20042 */ - 0x0000, /* R20043 */ - 0x0000, /* R20044 */ - 0x0000, /* R20045 */ - 0x0000, /* R20046 */ - 0x0000, /* R20047 */ - 0x0000, /* R20048 */ - 0x0000, /* R20049 */ - 0x0000, /* R20050 */ - 0x0000, /* R20051 */ - 0x0000, /* R20052 */ - 0x0000, /* R20053 */ - 0x0000, /* R20054 */ - 0x0000, /* R20055 */ - 0x0000, /* R20056 */ - 0x0000, /* R20057 */ - 0x0000, /* R20058 */ - 0x0000, /* R20059 */ - 0x0000, /* R20060 */ - 0x0000, /* R20061 */ - 0x0000, /* R20062 */ - 0x0000, /* R20063 */ - 0x0000, /* R20064 */ - 0x0000, /* R20065 */ - 0x0000, /* R20066 */ - 0x0000, /* R20067 */ - 0x0000, /* R20068 */ - 0x0000, /* R20069 */ - 0x0000, /* R20070 */ - 0x0000, /* R20071 */ - 0x0000, /* R20072 */ - 0x0000, /* R20073 */ - 0x0000, /* R20074 */ - 0x0000, /* R20075 */ - 0x0000, /* R20076 */ - 0x0000, /* R20077 */ - 0x0000, /* R20078 */ - 0x0000, /* R20079 */ - 0x0000, /* R20080 */ - 0x0000, /* R20081 */ - 0x0000, /* R20082 */ - 0x0000, /* R20083 */ - 0x0000, /* R20084 */ - 0x0000, /* R20085 */ - 0x0000, /* R20086 */ - 0x0000, /* R20087 */ - 0x0000, /* R20088 */ - 0x0000, /* R20089 */ - 0x0000, /* R20090 */ - 0x0000, /* R20091 */ - 0x0000, /* R20092 */ - 0x0000, /* R20093 */ - 0x0000, /* R20094 */ - 0x0000, /* R20095 */ - 0x0000, /* R20096 */ - 0x0000, /* R20097 */ - 0x0000, /* R20098 */ - 0x0000, /* R20099 */ - 0x0000, /* R20100 */ - 0x0000, /* R20101 */ - 0x0000, /* R20102 */ - 0x0000, /* R20103 */ - 0x0000, /* R20104 */ - 0x0000, /* R20105 */ - 0x0000, /* R20106 */ - 0x0000, /* R20107 */ - 0x0000, /* R20108 */ - 0x0000, /* R20109 */ - 0x0000, /* R20110 */ - 0x0000, /* R20111 */ - 0x0000, /* R20112 */ - 0x0000, /* R20113 */ - 0x0000, /* R20114 */ - 0x0000, /* R20115 */ - 0x0000, /* R20116 */ - 0x0000, /* R20117 */ - 0x0000, /* R20118 */ - 0x0000, /* R20119 */ - 0x0000, /* R20120 */ - 0x0000, /* R20121 */ - 0x0000, /* R20122 */ - 0x0000, /* R20123 */ - 0x0000, /* R20124 */ - 0x0000, /* R20125 */ - 0x0000, /* R20126 */ - 0x0000, /* R20127 */ - 0x0000, /* R20128 */ - 0x0000, /* R20129 */ - 0x0000, /* R20130 */ - 0x0000, /* R20131 */ - 0x0000, /* R20132 */ - 0x0000, /* R20133 */ - 0x0000, /* R20134 */ - 0x0000, /* R20135 */ - 0x0000, /* R20136 */ - 0x0000, /* R20137 */ - 0x0000, /* R20138 */ - 0x0000, /* R20139 */ - 0x0000, /* R20140 */ - 0x0000, /* R20141 */ - 0x0000, /* R20142 */ - 0x0000, /* R20143 */ - 0x0000, /* R20144 */ - 0x0000, /* R20145 */ - 0x0000, /* R20146 */ - 0x0000, /* R20147 */ - 0x0000, /* R20148 */ - 0x0000, /* R20149 */ - 0x0000, /* R20150 */ - 0x0000, /* R20151 */ - 0x0000, /* R20152 */ - 0x0000, /* R20153 */ - 0x0000, /* R20154 */ - 0x0000, /* R20155 */ - 0x0000, /* R20156 */ - 0x0000, /* R20157 */ - 0x0000, /* R20158 */ - 0x0000, /* R20159 */ - 0x0000, /* R20160 */ - 0x0000, /* R20161 */ - 0x0000, /* R20162 */ - 0x0000, /* R20163 */ - 0x0000, /* R20164 */ - 0x0000, /* R20165 */ - 0x0000, /* R20166 */ - 0x0000, /* R20167 */ - 0x0000, /* R20168 */ - 0x0000, /* R20169 */ - 0x0000, /* R20170 */ - 0x0000, /* R20171 */ - 0x0000, /* R20172 */ - 0x0000, /* R20173 */ - 0x0000, /* R20174 */ - 0x0000, /* R20175 */ - 0x0000, /* R20176 */ - 0x0000, /* R20177 */ - 0x0000, /* R20178 */ - 0x0000, /* R20179 */ - 0x0000, /* R20180 */ - 0x0000, /* R20181 */ - 0x0000, /* R20182 */ - 0x0000, /* R20183 */ - 0x0000, /* R20184 */ - 0x0000, /* R20185 */ - 0x0000, /* R20186 */ - 0x0000, /* R20187 */ - 0x0000, /* R20188 */ - 0x0000, /* R20189 */ - 0x0000, /* R20190 */ - 0x0000, /* R20191 */ - 0x0000, /* R20192 */ - 0x0000, /* R20193 */ - 0x0000, /* R20194 */ - 0x0000, /* R20195 */ - 0x0000, /* R20196 */ - 0x0000, /* R20197 */ - 0x0000, /* R20198 */ - 0x0000, /* R20199 */ - 0x0000, /* R20200 */ - 0x0000, /* R20201 */ - 0x0000, /* R20202 */ - 0x0000, /* R20203 */ - 0x0000, /* R20204 */ - 0x0000, /* R20205 */ - 0x0000, /* R20206 */ - 0x0000, /* R20207 */ - 0x0000, /* R20208 */ - 0x0000, /* R20209 */ - 0x0000, /* R20210 */ - 0x0000, /* R20211 */ - 0x0000, /* R20212 */ - 0x0000, /* R20213 */ - 0x0000, /* R20214 */ - 0x0000, /* R20215 */ - 0x0000, /* R20216 */ - 0x0000, /* R20217 */ - 0x0000, /* R20218 */ - 0x0000, /* R20219 */ - 0x0000, /* R20220 */ - 0x0000, /* R20221 */ - 0x0000, /* R20222 */ - 0x0000, /* R20223 */ - 0x0000, /* R20224 */ - 0x0000, /* R20225 */ - 0x0000, /* R20226 */ - 0x0000, /* R20227 */ - 0x0000, /* R20228 */ - 0x0000, /* R20229 */ - 0x0000, /* R20230 */ - 0x0000, /* R20231 */ - 0x0000, /* R20232 */ - 0x0000, /* R20233 */ - 0x0000, /* R20234 */ - 0x0000, /* R20235 */ - 0x0000, /* R20236 */ - 0x0000, /* R20237 */ - 0x0000, /* R20238 */ - 0x0000, /* R20239 */ - 0x0000, /* R20240 */ - 0x0000, /* R20241 */ - 0x0000, /* R20242 */ - 0x0000, /* R20243 */ - 0x0000, /* R20244 */ - 0x0000, /* R20245 */ - 0x0000, /* R20246 */ - 0x0000, /* R20247 */ - 0x0000, /* R20248 */ - 0x0000, /* R20249 */ - 0x0000, /* R20250 */ - 0x0000, /* R20251 */ - 0x0000, /* R20252 */ - 0x0000, /* R20253 */ - 0x0000, /* R20254 */ - 0x0000, /* R20255 */ - 0x0000, /* R20256 */ - 0x0000, /* R20257 */ - 0x0000, /* R20258 */ - 0x0000, /* R20259 */ - 0x0000, /* R20260 */ - 0x0000, /* R20261 */ - 0x0000, /* R20262 */ - 0x0000, /* R20263 */ - 0x0000, /* R20264 */ - 0x0000, /* R20265 */ - 0x0000, /* R20266 */ - 0x0000, /* R20267 */ - 0x0000, /* R20268 */ - 0x0000, /* R20269 */ - 0x0000, /* R20270 */ - 0x0000, /* R20271 */ - 0x0000, /* R20272 */ - 0x0000, /* R20273 */ - 0x0000, /* R20274 */ - 0x0000, /* R20275 */ - 0x0000, /* R20276 */ - 0x0000, /* R20277 */ - 0x0000, /* R20278 */ - 0x0000, /* R20279 */ - 0x0000, /* R20280 */ - 0x0000, /* R20281 */ - 0x0000, /* R20282 */ - 0x0000, /* R20283 */ - 0x0000, /* R20284 */ - 0x0000, /* R20285 */ - 0x0000, /* R20286 */ - 0x0000, /* R20287 */ - 0x0000, /* R20288 */ - 0x0000, /* R20289 */ - 0x0000, /* R20290 */ - 0x0000, /* R20291 */ - 0x0000, /* R20292 */ - 0x0000, /* R20293 */ - 0x0000, /* R20294 */ - 0x0000, /* R20295 */ - 0x0000, /* R20296 */ - 0x0000, /* R20297 */ - 0x0000, /* R20298 */ - 0x0000, /* R20299 */ - 0x0000, /* R20300 */ - 0x0000, /* R20301 */ - 0x0000, /* R20302 */ - 0x0000, /* R20303 */ - 0x0000, /* R20304 */ - 0x0000, /* R20305 */ - 0x0000, /* R20306 */ - 0x0000, /* R20307 */ - 0x0000, /* R20308 */ - 0x0000, /* R20309 */ - 0x0000, /* R20310 */ - 0x0000, /* R20311 */ - 0x0000, /* R20312 */ - 0x0000, /* R20313 */ - 0x0000, /* R20314 */ - 0x0000, /* R20315 */ - 0x0000, /* R20316 */ - 0x0000, /* R20317 */ - 0x0000, /* R20318 */ - 0x0000, /* R20319 */ - 0x0000, /* R20320 */ - 0x0000, /* R20321 */ - 0x0000, /* R20322 */ - 0x0000, /* R20323 */ - 0x0000, /* R20324 */ - 0x0000, /* R20325 */ - 0x0000, /* R20326 */ - 0x0000, /* R20327 */ - 0x0000, /* R20328 */ - 0x0000, /* R20329 */ - 0x0000, /* R20330 */ - 0x0000, /* R20331 */ - 0x0000, /* R20332 */ - 0x0000, /* R20333 */ - 0x0000, /* R20334 */ - 0x0000, /* R20335 */ - 0x0000, /* R20336 */ - 0x0000, /* R20337 */ - 0x0000, /* R20338 */ - 0x0000, /* R20339 */ - 0x0000, /* R20340 */ - 0x0000, /* R20341 */ - 0x0000, /* R20342 */ - 0x0000, /* R20343 */ - 0x0000, /* R20344 */ - 0x0000, /* R20345 */ - 0x0000, /* R20346 */ - 0x0000, /* R20347 */ - 0x0000, /* R20348 */ - 0x0000, /* R20349 */ - 0x0000, /* R20350 */ - 0x0000, /* R20351 */ - 0x0000, /* R20352 */ - 0x0000, /* R20353 */ - 0x0000, /* R20354 */ - 0x0000, /* R20355 */ - 0x0000, /* R20356 */ - 0x0000, /* R20357 */ - 0x0000, /* R20358 */ - 0x0000, /* R20359 */ - 0x0000, /* R20360 */ - 0x0000, /* R20361 */ - 0x0000, /* R20362 */ - 0x0000, /* R20363 */ - 0x0000, /* R20364 */ - 0x0000, /* R20365 */ - 0x0000, /* R20366 */ - 0x0000, /* R20367 */ - 0x0000, /* R20368 */ - 0x0000, /* R20369 */ - 0x0000, /* R20370 */ - 0x0000, /* R20371 */ - 0x0000, /* R20372 */ - 0x0000, /* R20373 */ - 0x0000, /* R20374 */ - 0x0000, /* R20375 */ - 0x0000, /* R20376 */ - 0x0000, /* R20377 */ - 0x0000, /* R20378 */ - 0x0000, /* R20379 */ - 0x0000, /* R20380 */ - 0x0000, /* R20381 */ - 0x0000, /* R20382 */ - 0x0000, /* R20383 */ - 0x0000, /* R20384 */ - 0x0000, /* R20385 */ - 0x0000, /* R20386 */ - 0x0000, /* R20387 */ - 0x0000, /* R20388 */ - 0x0000, /* R20389 */ - 0x0000, /* R20390 */ - 0x0000, /* R20391 */ - 0x0000, /* R20392 */ - 0x0000, /* R20393 */ - 0x0000, /* R20394 */ - 0x0000, /* R20395 */ - 0x0000, /* R20396 */ - 0x0000, /* R20397 */ - 0x0000, /* R20398 */ - 0x0000, /* R20399 */ - 0x0000, /* R20400 */ - 0x0000, /* R20401 */ - 0x0000, /* R20402 */ - 0x0000, /* R20403 */ - 0x0000, /* R20404 */ - 0x0000, /* R20405 */ - 0x0000, /* R20406 */ - 0x0000, /* R20407 */ - 0x0000, /* R20408 */ - 0x0000, /* R20409 */ - 0x0000, /* R20410 */ - 0x0000, /* R20411 */ - 0x0000, /* R20412 */ - 0x0000, /* R20413 */ - 0x0000, /* R20414 */ - 0x0000, /* R20415 */ - 0x0000, /* R20416 */ - 0x0000, /* R20417 */ - 0x0000, /* R20418 */ - 0x0000, /* R20419 */ - 0x0000, /* R20420 */ - 0x0000, /* R20421 */ - 0x0000, /* R20422 */ - 0x0000, /* R20423 */ - 0x0000, /* R20424 */ - 0x0000, /* R20425 */ - 0x0000, /* R20426 */ - 0x0000, /* R20427 */ - 0x0000, /* R20428 */ - 0x0000, /* R20429 */ - 0x0000, /* R20430 */ - 0x0000, /* R20431 */ - 0x0000, /* R20432 */ - 0x0000, /* R20433 */ - 0x0000, /* R20434 */ - 0x0000, /* R20435 */ - 0x0000, /* R20436 */ - 0x0000, /* R20437 */ - 0x0000, /* R20438 */ - 0x0000, /* R20439 */ - 0x0000, /* R20440 */ - 0x0000, /* R20441 */ - 0x0000, /* R20442 */ - 0x0000, /* R20443 */ - 0x0000, /* R20444 */ - 0x0000, /* R20445 */ - 0x0000, /* R20446 */ - 0x0000, /* R20447 */ - 0x0000, /* R20448 */ - 0x0000, /* R20449 */ - 0x0000, /* R20450 */ - 0x0000, /* R20451 */ - 0x0000, /* R20452 */ - 0x0000, /* R20453 */ - 0x0000, /* R20454 */ - 0x0000, /* R20455 */ - 0x0000, /* R20456 */ - 0x0000, /* R20457 */ - 0x0000, /* R20458 */ - 0x0000, /* R20459 */ - 0x0000, /* R20460 */ - 0x0000, /* R20461 */ - 0x0000, /* R20462 */ - 0x0000, /* R20463 */ - 0x0000, /* R20464 */ - 0x0000, /* R20465 */ - 0x0000, /* R20466 */ - 0x0000, /* R20467 */ - 0x0000, /* R20468 */ - 0x0000, /* R20469 */ - 0x0000, /* R20470 */ - 0x0000, /* R20471 */ - 0x0000, /* R20472 */ - 0x0000, /* R20473 */ - 0x0000, /* R20474 */ - 0x0000, /* R20475 */ - 0x0000, /* R20476 */ - 0x0000, /* R20477 */ - 0x0000, /* R20478 */ - 0x0000, /* R20479 */ - 0x007F, /* R20480 - DACR_RETUNE_C1_1 */ - 0xFFFF, /* R20481 - DACR_RETUNE_C1_0 */ - 0x0000, /* R20482 - DACR_RETUNE_C2_1 */ - 0x0000, /* R20483 - DACR_RETUNE_C2_0 */ - 0x0000, /* R20484 - DACR_RETUNE_C3_1 */ - 0x0000, /* R20485 - DACR_RETUNE_C3_0 */ - 0x0000, /* R20486 - DACR_RETUNE_C4_1 */ - 0x0000, /* R20487 - DACR_RETUNE_C4_0 */ - 0x0000, /* R20488 - DACR_RETUNE_C5_1 */ - 0x0000, /* R20489 - DACR_RETUNE_C5_0 */ - 0x0000, /* R20490 - DACR_RETUNE_C6_1 */ - 0x0000, /* R20491 - DACR_RETUNE_C6_0 */ - 0x0000, /* R20492 - DACR_RETUNE_C7_1 */ - 0x0000, /* R20493 - DACR_RETUNE_C7_0 */ - 0x0000, /* R20494 - DACR_RETUNE_C8_1 */ - 0x0000, /* R20495 - DACR_RETUNE_C8_0 */ - 0x0000, /* R20496 - DACR_RETUNE_C9_1 */ - 0x0000, /* R20497 - DACR_RETUNE_C9_0 */ - 0x0000, /* R20498 - DACR_RETUNE_C10_1 */ - 0x0000, /* R20499 - DACR_RETUNE_C10_0 */ - 0x0000, /* R20500 - DACR_RETUNE_C11_1 */ - 0x0000, /* R20501 - DACR_RETUNE_C11_0 */ - 0x0000, /* R20502 - DACR_RETUNE_C12_1 */ - 0x0000, /* R20503 - DACR_RETUNE_C12_0 */ - 0x0000, /* R20504 - DACR_RETUNE_C13_1 */ - 0x0000, /* R20505 - DACR_RETUNE_C13_0 */ - 0x0000, /* R20506 - DACR_RETUNE_C14_1 */ - 0x0000, /* R20507 - DACR_RETUNE_C14_0 */ - 0x0000, /* R20508 - DACR_RETUNE_C15_1 */ - 0x0000, /* R20509 - DACR_RETUNE_C15_0 */ - 0x0000, /* R20510 - DACR_RETUNE_C16_1 */ - 0x0000, /* R20511 - DACR_RETUNE_C16_0 */ - 0x0000, /* R20512 - DACR_RETUNE_C17_1 */ - 0x0000, /* R20513 - DACR_RETUNE_C17_0 */ - 0x0000, /* R20514 - DACR_RETUNE_C18_1 */ - 0x0000, /* R20515 - DACR_RETUNE_C18_0 */ - 0x0000, /* R20516 - DACR_RETUNE_C19_1 */ - 0x0000, /* R20517 - DACR_RETUNE_C19_0 */ - 0x0000, /* R20518 - DACR_RETUNE_C20_1 */ - 0x0000, /* R20519 - DACR_RETUNE_C20_0 */ - 0x0000, /* R20520 - DACR_RETUNE_C21_1 */ - 0x0000, /* R20521 - DACR_RETUNE_C21_0 */ - 0x0000, /* R20522 - DACR_RETUNE_C22_1 */ - 0x0000, /* R20523 - DACR_RETUNE_C22_0 */ - 0x0000, /* R20524 - DACR_RETUNE_C23_1 */ - 0x0000, /* R20525 - DACR_RETUNE_C23_0 */ - 0x0000, /* R20526 - DACR_RETUNE_C24_1 */ - 0x0000, /* R20527 - DACR_RETUNE_C24_0 */ - 0x0000, /* R20528 - DACR_RETUNE_C25_1 */ - 0x0000, /* R20529 - DACR_RETUNE_C25_0 */ - 0x0000, /* R20530 - DACR_RETUNE_C26_1 */ - 0x0000, /* R20531 - DACR_RETUNE_C26_0 */ - 0x0000, /* R20532 - DACR_RETUNE_C27_1 */ - 0x0000, /* R20533 - DACR_RETUNE_C27_0 */ - 0x0000, /* R20534 - DACR_RETUNE_C28_1 */ - 0x0000, /* R20535 - DACR_RETUNE_C28_0 */ - 0x0000, /* R20536 - DACR_RETUNE_C29_1 */ - 0x0000, /* R20537 - DACR_RETUNE_C29_0 */ - 0x0000, /* R20538 - DACR_RETUNE_C30_1 */ - 0x0000, /* R20539 - DACR_RETUNE_C30_0 */ - 0x0000, /* R20540 - DACR_RETUNE_C31_1 */ - 0x0000, /* R20541 - DACR_RETUNE_C31_0 */ - 0x0000, /* R20542 - DACR_RETUNE_C32_1 */ - 0x0000, /* R20543 - DACR_RETUNE_C32_0 */ - 0x0000, /* R20544 */ - 0x0000, /* R20545 */ - 0x0000, /* R20546 */ - 0x0000, /* R20547 */ - 0x0000, /* R20548 */ - 0x0000, /* R20549 */ - 0x0000, /* R20550 */ - 0x0000, /* R20551 */ - 0x0000, /* R20552 */ - 0x0000, /* R20553 */ - 0x0000, /* R20554 */ - 0x0000, /* R20555 */ - 0x0000, /* R20556 */ - 0x0000, /* R20557 */ - 0x0000, /* R20558 */ - 0x0000, /* R20559 */ - 0x0000, /* R20560 */ - 0x0000, /* R20561 */ - 0x0000, /* R20562 */ - 0x0000, /* R20563 */ - 0x0000, /* R20564 */ - 0x0000, /* R20565 */ - 0x0000, /* R20566 */ - 0x0000, /* R20567 */ - 0x0000, /* R20568 */ - 0x0000, /* R20569 */ - 0x0000, /* R20570 */ - 0x0000, /* R20571 */ - 0x0000, /* R20572 */ - 0x0000, /* R20573 */ - 0x0000, /* R20574 */ - 0x0000, /* R20575 */ - 0x0000, /* R20576 */ - 0x0000, /* R20577 */ - 0x0000, /* R20578 */ - 0x0000, /* R20579 */ - 0x0000, /* R20580 */ - 0x0000, /* R20581 */ - 0x0000, /* R20582 */ - 0x0000, /* R20583 */ - 0x0000, /* R20584 */ - 0x0000, /* R20585 */ - 0x0000, /* R20586 */ - 0x0000, /* R20587 */ - 0x0000, /* R20588 */ - 0x0000, /* R20589 */ - 0x0000, /* R20590 */ - 0x0000, /* R20591 */ - 0x0000, /* R20592 */ - 0x0000, /* R20593 */ - 0x0000, /* R20594 */ - 0x0000, /* R20595 */ - 0x0000, /* R20596 */ - 0x0000, /* R20597 */ - 0x0000, /* R20598 */ - 0x0000, /* R20599 */ - 0x0000, /* R20600 */ - 0x0000, /* R20601 */ - 0x0000, /* R20602 */ - 0x0000, /* R20603 */ - 0x0000, /* R20604 */ - 0x0000, /* R20605 */ - 0x0000, /* R20606 */ - 0x0000, /* R20607 */ - 0x0000, /* R20608 */ - 0x0000, /* R20609 */ - 0x0000, /* R20610 */ - 0x0000, /* R20611 */ - 0x0000, /* R20612 */ - 0x0000, /* R20613 */ - 0x0000, /* R20614 */ - 0x0000, /* R20615 */ - 0x0000, /* R20616 */ - 0x0000, /* R20617 */ - 0x0000, /* R20618 */ - 0x0000, /* R20619 */ - 0x0000, /* R20620 */ - 0x0000, /* R20621 */ - 0x0000, /* R20622 */ - 0x0000, /* R20623 */ - 0x0000, /* R20624 */ - 0x0000, /* R20625 */ - 0x0000, /* R20626 */ - 0x0000, /* R20627 */ - 0x0000, /* R20628 */ - 0x0000, /* R20629 */ - 0x0000, /* R20630 */ - 0x0000, /* R20631 */ - 0x0000, /* R20632 */ - 0x0000, /* R20633 */ - 0x0000, /* R20634 */ - 0x0000, /* R20635 */ - 0x0000, /* R20636 */ - 0x0000, /* R20637 */ - 0x0000, /* R20638 */ - 0x0000, /* R20639 */ - 0x0000, /* R20640 */ - 0x0000, /* R20641 */ - 0x0000, /* R20642 */ - 0x0000, /* R20643 */ - 0x0000, /* R20644 */ - 0x0000, /* R20645 */ - 0x0000, /* R20646 */ - 0x0000, /* R20647 */ - 0x0000, /* R20648 */ - 0x0000, /* R20649 */ - 0x0000, /* R20650 */ - 0x0000, /* R20651 */ - 0x0000, /* R20652 */ - 0x0000, /* R20653 */ - 0x0000, /* R20654 */ - 0x0000, /* R20655 */ - 0x0000, /* R20656 */ - 0x0000, /* R20657 */ - 0x0000, /* R20658 */ - 0x0000, /* R20659 */ - 0x0000, /* R20660 */ - 0x0000, /* R20661 */ - 0x0000, /* R20662 */ - 0x0000, /* R20663 */ - 0x0000, /* R20664 */ - 0x0000, /* R20665 */ - 0x0000, /* R20666 */ - 0x0000, /* R20667 */ - 0x0000, /* R20668 */ - 0x0000, /* R20669 */ - 0x0000, /* R20670 */ - 0x0000, /* R20671 */ - 0x0000, /* R20672 */ - 0x0000, /* R20673 */ - 0x0000, /* R20674 */ - 0x0000, /* R20675 */ - 0x0000, /* R20676 */ - 0x0000, /* R20677 */ - 0x0000, /* R20678 */ - 0x0000, /* R20679 */ - 0x0000, /* R20680 */ - 0x0000, /* R20681 */ - 0x0000, /* R20682 */ - 0x0000, /* R20683 */ - 0x0000, /* R20684 */ - 0x0000, /* R20685 */ - 0x0000, /* R20686 */ - 0x0000, /* R20687 */ - 0x0000, /* R20688 */ - 0x0000, /* R20689 */ - 0x0000, /* R20690 */ - 0x0000, /* R20691 */ - 0x0000, /* R20692 */ - 0x0000, /* R20693 */ - 0x0000, /* R20694 */ - 0x0000, /* R20695 */ - 0x0000, /* R20696 */ - 0x0000, /* R20697 */ - 0x0000, /* R20698 */ - 0x0000, /* R20699 */ - 0x0000, /* R20700 */ - 0x0000, /* R20701 */ - 0x0000, /* R20702 */ - 0x0000, /* R20703 */ - 0x0000, /* R20704 */ - 0x0000, /* R20705 */ - 0x0000, /* R20706 */ - 0x0000, /* R20707 */ - 0x0000, /* R20708 */ - 0x0000, /* R20709 */ - 0x0000, /* R20710 */ - 0x0000, /* R20711 */ - 0x0000, /* R20712 */ - 0x0000, /* R20713 */ - 0x0000, /* R20714 */ - 0x0000, /* R20715 */ - 0x0000, /* R20716 */ - 0x0000, /* R20717 */ - 0x0000, /* R20718 */ - 0x0000, /* R20719 */ - 0x0000, /* R20720 */ - 0x0000, /* R20721 */ - 0x0000, /* R20722 */ - 0x0000, /* R20723 */ - 0x0000, /* R20724 */ - 0x0000, /* R20725 */ - 0x0000, /* R20726 */ - 0x0000, /* R20727 */ - 0x0000, /* R20728 */ - 0x0000, /* R20729 */ - 0x0000, /* R20730 */ - 0x0000, /* R20731 */ - 0x0000, /* R20732 */ - 0x0000, /* R20733 */ - 0x0000, /* R20734 */ - 0x0000, /* R20735 */ - 0x0000, /* R20736 */ - 0x0000, /* R20737 */ - 0x0000, /* R20738 */ - 0x0000, /* R20739 */ - 0x0000, /* R20740 */ - 0x0000, /* R20741 */ - 0x0000, /* R20742 */ - 0x0000, /* R20743 */ - 0x0000, /* R20744 */ - 0x0000, /* R20745 */ - 0x0000, /* R20746 */ - 0x0000, /* R20747 */ - 0x0000, /* R20748 */ - 0x0000, /* R20749 */ - 0x0000, /* R20750 */ - 0x0000, /* R20751 */ - 0x0000, /* R20752 */ - 0x0000, /* R20753 */ - 0x0000, /* R20754 */ - 0x0000, /* R20755 */ - 0x0000, /* R20756 */ - 0x0000, /* R20757 */ - 0x0000, /* R20758 */ - 0x0000, /* R20759 */ - 0x0000, /* R20760 */ - 0x0000, /* R20761 */ - 0x0000, /* R20762 */ - 0x0000, /* R20763 */ - 0x0000, /* R20764 */ - 0x0000, /* R20765 */ - 0x0000, /* R20766 */ - 0x0000, /* R20767 */ - 0x0000, /* R20768 */ - 0x0000, /* R20769 */ - 0x0000, /* R20770 */ - 0x0000, /* R20771 */ - 0x0000, /* R20772 */ - 0x0000, /* R20773 */ - 0x0000, /* R20774 */ - 0x0000, /* R20775 */ - 0x0000, /* R20776 */ - 0x0000, /* R20777 */ - 0x0000, /* R20778 */ - 0x0000, /* R20779 */ - 0x0000, /* R20780 */ - 0x0000, /* R20781 */ - 0x0000, /* R20782 */ - 0x0000, /* R20783 */ - 0x0000, /* R20784 */ - 0x0000, /* R20785 */ - 0x0000, /* R20786 */ - 0x0000, /* R20787 */ - 0x0000, /* R20788 */ - 0x0000, /* R20789 */ - 0x0000, /* R20790 */ - 0x0000, /* R20791 */ - 0x0000, /* R20792 */ - 0x0000, /* R20793 */ - 0x0000, /* R20794 */ - 0x0000, /* R20795 */ - 0x0000, /* R20796 */ - 0x0000, /* R20797 */ - 0x0000, /* R20798 */ - 0x0000, /* R20799 */ - 0x0000, /* R20800 */ - 0x0000, /* R20801 */ - 0x0000, /* R20802 */ - 0x0000, /* R20803 */ - 0x0000, /* R20804 */ - 0x0000, /* R20805 */ - 0x0000, /* R20806 */ - 0x0000, /* R20807 */ - 0x0000, /* R20808 */ - 0x0000, /* R20809 */ - 0x0000, /* R20810 */ - 0x0000, /* R20811 */ - 0x0000, /* R20812 */ - 0x0000, /* R20813 */ - 0x0000, /* R20814 */ - 0x0000, /* R20815 */ - 0x0000, /* R20816 */ - 0x0000, /* R20817 */ - 0x0000, /* R20818 */ - 0x0000, /* R20819 */ - 0x0000, /* R20820 */ - 0x0000, /* R20821 */ - 0x0000, /* R20822 */ - 0x0000, /* R20823 */ - 0x0000, /* R20824 */ - 0x0000, /* R20825 */ - 0x0000, /* R20826 */ - 0x0000, /* R20827 */ - 0x0000, /* R20828 */ - 0x0000, /* R20829 */ - 0x0000, /* R20830 */ - 0x0000, /* R20831 */ - 0x0000, /* R20832 */ - 0x0000, /* R20833 */ - 0x0000, /* R20834 */ - 0x0000, /* R20835 */ - 0x0000, /* R20836 */ - 0x0000, /* R20837 */ - 0x0000, /* R20838 */ - 0x0000, /* R20839 */ - 0x0000, /* R20840 */ - 0x0000, /* R20841 */ - 0x0000, /* R20842 */ - 0x0000, /* R20843 */ - 0x0000, /* R20844 */ - 0x0000, /* R20845 */ - 0x0000, /* R20846 */ - 0x0000, /* R20847 */ - 0x0000, /* R20848 */ - 0x0000, /* R20849 */ - 0x0000, /* R20850 */ - 0x0000, /* R20851 */ - 0x0000, /* R20852 */ - 0x0000, /* R20853 */ - 0x0000, /* R20854 */ - 0x0000, /* R20855 */ - 0x0000, /* R20856 */ - 0x0000, /* R20857 */ - 0x0000, /* R20858 */ - 0x0000, /* R20859 */ - 0x0000, /* R20860 */ - 0x0000, /* R20861 */ - 0x0000, /* R20862 */ - 0x0000, /* R20863 */ - 0x0000, /* R20864 */ - 0x0000, /* R20865 */ - 0x0000, /* R20866 */ - 0x0000, /* R20867 */ - 0x0000, /* R20868 */ - 0x0000, /* R20869 */ - 0x0000, /* R20870 */ - 0x0000, /* R20871 */ - 0x0000, /* R20872 */ - 0x0000, /* R20873 */ - 0x0000, /* R20874 */ - 0x0000, /* R20875 */ - 0x0000, /* R20876 */ - 0x0000, /* R20877 */ - 0x0000, /* R20878 */ - 0x0000, /* R20879 */ - 0x0000, /* R20880 */ - 0x0000, /* R20881 */ - 0x0000, /* R20882 */ - 0x0000, /* R20883 */ - 0x0000, /* R20884 */ - 0x0000, /* R20885 */ - 0x0000, /* R20886 */ - 0x0000, /* R20887 */ - 0x0000, /* R20888 */ - 0x0000, /* R20889 */ - 0x0000, /* R20890 */ - 0x0000, /* R20891 */ - 0x0000, /* R20892 */ - 0x0000, /* R20893 */ - 0x0000, /* R20894 */ - 0x0000, /* R20895 */ - 0x0000, /* R20896 */ - 0x0000, /* R20897 */ - 0x0000, /* R20898 */ - 0x0000, /* R20899 */ - 0x0000, /* R20900 */ - 0x0000, /* R20901 */ - 0x0000, /* R20902 */ - 0x0000, /* R20903 */ - 0x0000, /* R20904 */ - 0x0000, /* R20905 */ - 0x0000, /* R20906 */ - 0x0000, /* R20907 */ - 0x0000, /* R20908 */ - 0x0000, /* R20909 */ - 0x0000, /* R20910 */ - 0x0000, /* R20911 */ - 0x0000, /* R20912 */ - 0x0000, /* R20913 */ - 0x0000, /* R20914 */ - 0x0000, /* R20915 */ - 0x0000, /* R20916 */ - 0x0000, /* R20917 */ - 0x0000, /* R20918 */ - 0x0000, /* R20919 */ - 0x0000, /* R20920 */ - 0x0000, /* R20921 */ - 0x0000, /* R20922 */ - 0x0000, /* R20923 */ - 0x0000, /* R20924 */ - 0x0000, /* R20925 */ - 0x0000, /* R20926 */ - 0x0000, /* R20927 */ - 0x0000, /* R20928 */ - 0x0000, /* R20929 */ - 0x0000, /* R20930 */ - 0x0000, /* R20931 */ - 0x0000, /* R20932 */ - 0x0000, /* R20933 */ - 0x0000, /* R20934 */ - 0x0000, /* R20935 */ - 0x0000, /* R20936 */ - 0x0000, /* R20937 */ - 0x0000, /* R20938 */ - 0x0000, /* R20939 */ - 0x0000, /* R20940 */ - 0x0000, /* R20941 */ - 0x0000, /* R20942 */ - 0x0000, /* R20943 */ - 0x0000, /* R20944 */ - 0x0000, /* R20945 */ - 0x0000, /* R20946 */ - 0x0000, /* R20947 */ - 0x0000, /* R20948 */ - 0x0000, /* R20949 */ - 0x0000, /* R20950 */ - 0x0000, /* R20951 */ - 0x0000, /* R20952 */ - 0x0000, /* R20953 */ - 0x0000, /* R20954 */ - 0x0000, /* R20955 */ - 0x0000, /* R20956 */ - 0x0000, /* R20957 */ - 0x0000, /* R20958 */ - 0x0000, /* R20959 */ - 0x0000, /* R20960 */ - 0x0000, /* R20961 */ - 0x0000, /* R20962 */ - 0x0000, /* R20963 */ - 0x0000, /* R20964 */ - 0x0000, /* R20965 */ - 0x0000, /* R20966 */ - 0x0000, /* R20967 */ - 0x0000, /* R20968 */ - 0x0000, /* R20969 */ - 0x0000, /* R20970 */ - 0x0000, /* R20971 */ - 0x0000, /* R20972 */ - 0x0000, /* R20973 */ - 0x0000, /* R20974 */ - 0x0000, /* R20975 */ - 0x0000, /* R20976 */ - 0x0000, /* R20977 */ - 0x0000, /* R20978 */ - 0x0000, /* R20979 */ - 0x0000, /* R20980 */ - 0x0000, /* R20981 */ - 0x0000, /* R20982 */ - 0x0000, /* R20983 */ - 0x0000, /* R20984 */ - 0x0000, /* R20985 */ - 0x0000, /* R20986 */ - 0x0000, /* R20987 */ - 0x0000, /* R20988 */ - 0x0000, /* R20989 */ - 0x0000, /* R20990 */ - 0x0000, /* R20991 */ - 0x008C, /* R20992 - VSS_XHD2_1 */ - 0x0200, /* R20993 - VSS_XHD2_0 */ - 0x0035, /* R20994 - VSS_XHD3_1 */ - 0x0700, /* R20995 - VSS_XHD3_0 */ - 0x003A, /* R20996 - VSS_XHN1_1 */ - 0x4100, /* R20997 - VSS_XHN1_0 */ - 0x008B, /* R20998 - VSS_XHN2_1 */ - 0x7D00, /* R20999 - VSS_XHN2_0 */ - 0x003A, /* R21000 - VSS_XHN3_1 */ - 0x4100, /* R21001 - VSS_XHN3_0 */ - 0x008C, /* R21002 - VSS_XLA_1 */ - 0xFEE8, /* R21003 - VSS_XLA_0 */ - 0x0078, /* R21004 - VSS_XLB_1 */ - 0x0000, /* R21005 - VSS_XLB_0 */ - 0x003F, /* R21006 - VSS_XLG_1 */ - 0xB260, /* R21007 - VSS_XLG_0 */ - 0x002D, /* R21008 - VSS_PG2_1 */ - 0x1818, /* R21009 - VSS_PG2_0 */ - 0x0020, /* R21010 - VSS_PG_1 */ - 0x0000, /* R21011 - VSS_PG_0 */ - 0x00F1, /* R21012 - VSS_XTD1_1 */ - 0x8340, /* R21013 - VSS_XTD1_0 */ - 0x00FB, /* R21014 - VSS_XTD2_1 */ - 0x8300, /* R21015 - VSS_XTD2_0 */ - 0x00EE, /* R21016 - VSS_XTD3_1 */ - 0xAEC0, /* R21017 - VSS_XTD3_0 */ - 0x00FB, /* R21018 - VSS_XTD4_1 */ - 0xAC40, /* R21019 - VSS_XTD4_0 */ - 0x00F1, /* R21020 - VSS_XTD5_1 */ - 0x7F80, /* R21021 - VSS_XTD5_0 */ - 0x00F4, /* R21022 - VSS_XTD6_1 */ - 0x3B40, /* R21023 - VSS_XTD6_0 */ - 0x00F5, /* R21024 - VSS_XTD7_1 */ - 0xFB00, /* R21025 - VSS_XTD7_0 */ - 0x00EA, /* R21026 - VSS_XTD8_1 */ - 0x10C0, /* R21027 - VSS_XTD8_0 */ - 0x00FC, /* R21028 - VSS_XTD9_1 */ - 0xC580, /* R21029 - VSS_XTD9_0 */ - 0x00E2, /* R21030 - VSS_XTD10_1 */ - 0x75C0, /* R21031 - VSS_XTD10_0 */ - 0x0004, /* R21032 - VSS_XTD11_1 */ - 0xB480, /* R21033 - VSS_XTD11_0 */ - 0x00D4, /* R21034 - VSS_XTD12_1 */ - 0xF980, /* R21035 - VSS_XTD12_0 */ - 0x0004, /* R21036 - VSS_XTD13_1 */ - 0x9140, /* R21037 - VSS_XTD13_0 */ - 0x00D8, /* R21038 - VSS_XTD14_1 */ - 0xA480, /* R21039 - VSS_XTD14_0 */ - 0x0002, /* R21040 - VSS_XTD15_1 */ - 0x3DC0, /* R21041 - VSS_XTD15_0 */ - 0x00CF, /* R21042 - VSS_XTD16_1 */ - 0x7A80, /* R21043 - VSS_XTD16_0 */ - 0x00DC, /* R21044 - VSS_XTD17_1 */ - 0x0600, /* R21045 - VSS_XTD17_0 */ - 0x00F2, /* R21046 - VSS_XTD18_1 */ - 0xDAC0, /* R21047 - VSS_XTD18_0 */ - 0x00BA, /* R21048 - VSS_XTD19_1 */ - 0xF340, /* R21049 - VSS_XTD19_0 */ - 0x000A, /* R21050 - VSS_XTD20_1 */ - 0x7940, /* R21051 - VSS_XTD20_0 */ - 0x001C, /* R21052 - VSS_XTD21_1 */ - 0x0680, /* R21053 - VSS_XTD21_0 */ - 0x00FD, /* R21054 - VSS_XTD22_1 */ - 0x2D00, /* R21055 - VSS_XTD22_0 */ - 0x001C, /* R21056 - VSS_XTD23_1 */ - 0xE840, /* R21057 - VSS_XTD23_0 */ - 0x000D, /* R21058 - VSS_XTD24_1 */ - 0xDC40, /* R21059 - VSS_XTD24_0 */ - 0x00FC, /* R21060 - VSS_XTD25_1 */ - 0x9D00, /* R21061 - VSS_XTD25_0 */ - 0x0009, /* R21062 - VSS_XTD26_1 */ - 0x5580, /* R21063 - VSS_XTD26_0 */ - 0x00FE, /* R21064 - VSS_XTD27_1 */ - 0x7E80, /* R21065 - VSS_XTD27_0 */ - 0x000E, /* R21066 - VSS_XTD28_1 */ - 0xAB40, /* R21067 - VSS_XTD28_0 */ - 0x00F9, /* R21068 - VSS_XTD29_1 */ - 0x9880, /* R21069 - VSS_XTD29_0 */ - 0x0009, /* R21070 - VSS_XTD30_1 */ - 0x87C0, /* R21071 - VSS_XTD30_0 */ - 0x00FD, /* R21072 - VSS_XTD31_1 */ - 0x2C40, /* R21073 - VSS_XTD31_0 */ - 0x0009, /* R21074 - VSS_XTD32_1 */ - 0x4800, /* R21075 - VSS_XTD32_0 */ - 0x0003, /* R21076 - VSS_XTS1_1 */ - 0x5F40, /* R21077 - VSS_XTS1_0 */ - 0x0000, /* R21078 - VSS_XTS2_1 */ - 0x8700, /* R21079 - VSS_XTS2_0 */ - 0x00FA, /* R21080 - VSS_XTS3_1 */ - 0xE4C0, /* R21081 - VSS_XTS3_0 */ - 0x0000, /* R21082 - VSS_XTS4_1 */ - 0x0B40, /* R21083 - VSS_XTS4_0 */ - 0x0004, /* R21084 - VSS_XTS5_1 */ - 0xE180, /* R21085 - VSS_XTS5_0 */ - 0x0001, /* R21086 - VSS_XTS6_1 */ - 0x1F40, /* R21087 - VSS_XTS6_0 */ - 0x00F8, /* R21088 - VSS_XTS7_1 */ - 0xB000, /* R21089 - VSS_XTS7_0 */ - 0x00FB, /* R21090 - VSS_XTS8_1 */ - 0xCBC0, /* R21091 - VSS_XTS8_0 */ - 0x0004, /* R21092 - VSS_XTS9_1 */ - 0xF380, /* R21093 - VSS_XTS9_0 */ - 0x0007, /* R21094 - VSS_XTS10_1 */ - 0xDF40, /* R21095 - VSS_XTS10_0 */ - 0x00FF, /* R21096 - VSS_XTS11_1 */ - 0x0700, /* R21097 - VSS_XTS11_0 */ - 0x00EF, /* R21098 - VSS_XTS12_1 */ - 0xD700, /* R21099 - VSS_XTS12_0 */ - 0x00FB, /* R21100 - VSS_XTS13_1 */ - 0xAF40, /* R21101 - VSS_XTS13_0 */ - 0x0010, /* R21102 - VSS_XTS14_1 */ - 0x8A80, /* R21103 - VSS_XTS14_0 */ - 0x0011, /* R21104 - VSS_XTS15_1 */ - 0x07C0, /* R21105 - VSS_XTS15_0 */ - 0x00E0, /* R21106 - VSS_XTS16_1 */ - 0x0800, /* R21107 - VSS_XTS16_0 */ - 0x00D2, /* R21108 - VSS_XTS17_1 */ - 0x7600, /* R21109 - VSS_XTS17_0 */ - 0x0020, /* R21110 - VSS_XTS18_1 */ - 0xCF40, /* R21111 - VSS_XTS18_0 */ - 0x0030, /* R21112 - VSS_XTS19_1 */ - 0x2340, /* R21113 - VSS_XTS19_0 */ - 0x00FD, /* R21114 - VSS_XTS20_1 */ - 0x69C0, /* R21115 - VSS_XTS20_0 */ - 0x0028, /* R21116 - VSS_XTS21_1 */ - 0x3500, /* R21117 - VSS_XTS21_0 */ - 0x0006, /* R21118 - VSS_XTS22_1 */ - 0x3300, /* R21119 - VSS_XTS22_0 */ - 0x00D9, /* R21120 - VSS_XTS23_1 */ - 0xF6C0, /* R21121 - VSS_XTS23_0 */ - 0x00F3, /* R21122 - VSS_XTS24_1 */ - 0x3340, /* R21123 - VSS_XTS24_0 */ - 0x000F, /* R21124 - VSS_XTS25_1 */ - 0x4200, /* R21125 - VSS_XTS25_0 */ - 0x0004, /* R21126 - VSS_XTS26_1 */ - 0x0C80, /* R21127 - VSS_XTS26_0 */ - 0x00FB, /* R21128 - VSS_XTS27_1 */ - 0x3F80, /* R21129 - VSS_XTS27_0 */ - 0x00F7, /* R21130 - VSS_XTS28_1 */ - 0x57C0, /* R21131 - VSS_XTS28_0 */ - 0x0003, /* R21132 - VSS_XTS29_1 */ - 0x5400, /* R21133 - VSS_XTS29_0 */ - 0x0000, /* R21134 - VSS_XTS30_1 */ - 0xC6C0, /* R21135 - VSS_XTS30_0 */ - 0x0003, /* R21136 - VSS_XTS31_1 */ - 0x12C0, /* R21137 - VSS_XTS31_0 */ - 0x00FD, /* R21138 - VSS_XTS32_1 */ - 0x8580, /* R21139 - VSS_XTS32_0 */ -}; - const struct wm8962_reg_access wm8962_reg_access[WM8962_MAX_REGISTER + 1] = { { 0x00FF, 0x01FF, 0x0000 }, /* R0 - Left Input volume */ { 0xFEFF, 0x01FF, 0xFFFF }, /* R1 - Right Input volume */ diff --git a/sound/soc/codecs/wm8962.c b/sound/soc/codecs/wm8962.c index 6d30f34..d817ac9 100644 --- a/sound/soc/codecs/wm8962.c +++ b/sound/soc/codecs/wm8962.c @@ -106,6 +106,693 @@ WM8962_REGULATOR_EVENT(5) WM8962_REGULATOR_EVENT(6) WM8962_REGULATOR_EVENT(7) +static const u16 wm8962_reg[WM8962_MAX_REGISTER + 1] = { + [0] = 0x009F, /* R0 - Left Input volume */ + [1] = 0x049F, /* R1 - Right Input volume */ + [2] = 0x0000, /* R2 - HPOUTL volume */ + [3] = 0x0000, /* R3 - HPOUTR volume */ + [4] = 0x0020, /* R4 - Clocking1 */ + [5] = 0x0018, /* R5 - ADC & DAC Control 1 */ + [6] = 0x2008, /* R6 - ADC & DAC Control 2 */ + [7] = 0x000A, /* R7 - Audio Interface 0 */ + [8] = 0x01E4, /* R8 - Clocking2 */ + [9] = 0x0300, /* R9 - Audio Interface 1 */ + [10] = 0x00C0, /* R10 - Left DAC volume */ + [11] = 0x00C0, /* R11 - Right DAC volume */ + + [14] = 0x0040, /* R14 - Audio Interface 2 */ + [15] = 0x6243, /* R15 - Software Reset */ + + [17] = 0x007B, /* R17 - ALC1 */ + [18] = 0x0000, /* R18 - ALC2 */ + [19] = 0x1C32, /* R19 - ALC3 */ + [20] = 0x3200, /* R20 - Noise Gate */ + [21] = 0x00C0, /* R21 - Left ADC volume */ + [22] = 0x00C0, /* R22 - Right ADC volume */ + [23] = 0x0160, /* R23 - Additional control(1) */ + [24] = 0x0000, /* R24 - Additional control(2) */ + [25] = 0x0000, /* R25 - Pwr Mgmt (1) */ + [26] = 0x0000, /* R26 - Pwr Mgmt (2) */ + [27] = 0x0010, /* R27 - Additional Control (3) */ + [28] = 0x0000, /* R28 - Anti-pop */ + + [30] = 0x005E, /* R30 - Clocking 3 */ + [31] = 0x0000, /* R31 - Input mixer control (1) */ + [32] = 0x0145, /* R32 - Left input mixer volume */ + [33] = 0x0145, /* R33 - Right input mixer volume */ + [34] = 0x0009, /* R34 - Input mixer control (2) */ + [35] = 0x0003, /* R35 - Input bias control */ + [37] = 0x0008, /* R37 - Left input PGA control */ + [38] = 0x0008, /* R38 - Right input PGA control */ + + [40] = 0x0000, /* R40 - SPKOUTL volume */ + [41] = 0x0000, /* R41 - SPKOUTR volume */ + + [47] = 0x0000, /* R47 - Thermal Shutdown Status */ + [48] = 0x8027, /* R48 - Additional Control (4) */ + [49] = 0x0010, /* R49 - Class D Control 1 */ + + [51] = 0x0003, /* R51 - Class D Control 2 */ + + [56] = 0x0506, /* R56 - Clocking 4 */ + [57] = 0x0000, /* R57 - DAC DSP Mixing (1) */ + [58] = 0x0000, /* R58 - DAC DSP Mixing (2) */ + + [60] = 0x0300, /* R60 - DC Servo 0 */ + [61] = 0x0300, /* R61 - DC Servo 1 */ + + [64] = 0x0810, /* R64 - DC Servo 4 */ + + [66] = 0x0000, /* R66 - DC Servo 6 */ + + [68] = 0x001B, /* R68 - Analogue PGA Bias */ + [69] = 0x0000, /* R69 - Analogue HP 0 */ + + [71] = 0x01FB, /* R71 - Analogue HP 2 */ + [72] = 0x0000, /* R72 - Charge Pump 1 */ + + [82] = 0x0004, /* R82 - Charge Pump B */ + + [87] = 0x0000, /* R87 - Write Sequencer Control 1 */ + + [90] = 0x0000, /* R90 - Write Sequencer Control 2 */ + + [93] = 0x0000, /* R93 - Write Sequencer Control 3 */ + [94] = 0x0000, /* R94 - Control Interface */ + + [99] = 0x0000, /* R99 - Mixer Enables */ + [100] = 0x0000, /* R100 - Headphone Mixer (1) */ + [101] = 0x0000, /* R101 - Headphone Mixer (2) */ + [102] = 0x013F, /* R102 - Headphone Mixer (3) */ + [103] = 0x013F, /* R103 - Headphone Mixer (4) */ + + [105] = 0x0000, /* R105 - Speaker Mixer (1) */ + [106] = 0x0000, /* R106 - Speaker Mixer (2) */ + [107] = 0x013F, /* R107 - Speaker Mixer (3) */ + [108] = 0x013F, /* R108 - Speaker Mixer (4) */ + [109] = 0x0003, /* R109 - Speaker Mixer (5) */ + [110] = 0x0002, /* R110 - Beep Generator (1) */ + + [115] = 0x0006, /* R115 - Oscillator Trim (3) */ + [116] = 0x0026, /* R116 - Oscillator Trim (4) */ + + [119] = 0x0000, /* R119 - Oscillator Trim (7) */ + + [124] = 0x0011, /* R124 - Analogue Clocking1 */ + [125] = 0x004B, /* R125 - Analogue Clocking2 */ + [126] = 0x000D, /* R126 - Analogue Clocking3 */ + [127] = 0x0000, /* R127 - PLL Software Reset */ + + [129] = 0x0000, /* R129 - PLL2 */ + + [131] = 0x0000, /* R131 - PLL 4 */ + + [136] = 0x0067, /* R136 - PLL 9 */ + [137] = 0x001C, /* R137 - PLL 10 */ + [138] = 0x0071, /* R138 - PLL 11 */ + [139] = 0x00C7, /* R139 - PLL 12 */ + [140] = 0x0067, /* R140 - PLL 13 */ + [141] = 0x0048, /* R141 - PLL 14 */ + [142] = 0x0022, /* R142 - PLL 15 */ + [143] = 0x0097, /* R143 - PLL 16 */ + + [155] = 0x000C, /* R155 - FLL Control (1) */ + [156] = 0x0039, /* R156 - FLL Control (2) */ + [157] = 0x0180, /* R157 - FLL Control (3) */ + + [159] = 0x0032, /* R159 - FLL Control (5) */ + [160] = 0x0018, /* R160 - FLL Control (6) */ + [161] = 0x007D, /* R161 - FLL Control (7) */ + [162] = 0x0008, /* R162 - FLL Control (8) */ + + [252] = 0x0005, /* R252 - General test 1 */ + + [256] = 0x0000, /* R256 - DF1 */ + [257] = 0x0000, /* R257 - DF2 */ + [258] = 0x0000, /* R258 - DF3 */ + [259] = 0x0000, /* R259 - DF4 */ + [260] = 0x0000, /* R260 - DF5 */ + [261] = 0x0000, /* R261 - DF6 */ + [262] = 0x0000, /* R262 - DF7 */ + + [264] = 0x0000, /* R264 - LHPF1 */ + [265] = 0x0000, /* R265 - LHPF2 */ + + [268] = 0x0000, /* R268 - THREED1 */ + [269] = 0x0000, /* R269 - THREED2 */ + [270] = 0x0000, /* R270 - THREED3 */ + [271] = 0x0000, /* R271 - THREED4 */ + + [276] = 0x000C, /* R276 - DRC 1 */ + [277] = 0x0925, /* R277 - DRC 2 */ + [278] = 0x0000, /* R278 - DRC 3 */ + [279] = 0x0000, /* R279 - DRC 4 */ + [280] = 0x0000, /* R280 - DRC 5 */ + + [285] = 0x0000, /* R285 - Tloopback */ + + [335] = 0x0004, /* R335 - EQ1 */ + [336] = 0x6318, /* R336 - EQ2 */ + [337] = 0x6300, /* R337 - EQ3 */ + [338] = 0x0FCA, /* R338 - EQ4 */ + [339] = 0x0400, /* R339 - EQ5 */ + [340] = 0x00D8, /* R340 - EQ6 */ + [341] = 0x1EB5, /* R341 - EQ7 */ + [342] = 0xF145, /* R342 - EQ8 */ + [343] = 0x0B75, /* R343 - EQ9 */ + [344] = 0x01C5, /* R344 - EQ10 */ + [345] = 0x1C58, /* R345 - EQ11 */ + [346] = 0xF373, /* R346 - EQ12 */ + [347] = 0x0A54, /* R347 - EQ13 */ + [348] = 0x0558, /* R348 - EQ14 */ + [349] = 0x168E, /* R349 - EQ15 */ + [350] = 0xF829, /* R350 - EQ16 */ + [351] = 0x07AD, /* R351 - EQ17 */ + [352] = 0x1103, /* R352 - EQ18 */ + [353] = 0x0564, /* R353 - EQ19 */ + [354] = 0x0559, /* R354 - EQ20 */ + [355] = 0x4000, /* R355 - EQ21 */ + [356] = 0x6318, /* R356 - EQ22 */ + [357] = 0x6300, /* R357 - EQ23 */ + [358] = 0x0FCA, /* R358 - EQ24 */ + [359] = 0x0400, /* R359 - EQ25 */ + [360] = 0x00D8, /* R360 - EQ26 */ + [361] = 0x1EB5, /* R361 - EQ27 */ + [362] = 0xF145, /* R362 - EQ28 */ + [363] = 0x0B75, /* R363 - EQ29 */ + [364] = 0x01C5, /* R364 - EQ30 */ + [365] = 0x1C58, /* R365 - EQ31 */ + [366] = 0xF373, /* R366 - EQ32 */ + [367] = 0x0A54, /* R367 - EQ33 */ + [368] = 0x0558, /* R368 - EQ34 */ + [369] = 0x168E, /* R369 - EQ35 */ + [370] = 0xF829, /* R370 - EQ36 */ + [371] = 0x07AD, /* R371 - EQ37 */ + [372] = 0x1103, /* R372 - EQ38 */ + [373] = 0x0564, /* R373 - EQ39 */ + [374] = 0x0559, /* R374 - EQ40 */ + [375] = 0x4000, /* R375 - EQ41 */ + + [513] = 0x0000, /* R513 - GPIO 2 */ + [514] = 0x0000, /* R514 - GPIO 3 */ + + [516] = 0x8100, /* R516 - GPIO 5 */ + [517] = 0x8100, /* R517 - GPIO 6 */ + + [560] = 0x0000, /* R560 - Interrupt Status 1 */ + [561] = 0x0000, /* R561 - Interrupt Status 2 */ + + [568] = 0x0030, /* R568 - Interrupt Status 1 Mask */ + [569] = 0xFFED, /* R569 - Interrupt Status 2 Mask */ + + [576] = 0x0000, /* R576 - Interrupt Control */ + + [584] = 0x002D, /* R584 - IRQ Debounce */ + + [586] = 0x0000, /* R586 - MICINT Source Pol */ + + [768] = 0x1C00, /* R768 - DSP2 Power Management */ + + [1037] = 0x0000, /* R1037 - DSP2_ExecControl */ + + [8192] = 0x0000, /* R8192 - DSP2 Instruction RAM 0 */ + + [9216] = 0x0030, /* R9216 - DSP2 Address RAM 2 */ + [9217] = 0x0000, /* R9217 - DSP2 Address RAM 1 */ + [9218] = 0x0000, /* R9218 - DSP2 Address RAM 0 */ + + [12288] = 0x0000, /* R12288 - DSP2 Data1 RAM 1 */ + [12289] = 0x0000, /* R12289 - DSP2 Data1 RAM 0 */ + + [13312] = 0x0000, /* R13312 - DSP2 Data2 RAM 1 */ + [13313] = 0x0000, /* R13313 - DSP2 Data2 RAM 0 */ + + [14336] = 0x0000, /* R14336 - DSP2 Data3 RAM 1 */ + [14337] = 0x0000, /* R14337 - DSP2 Data3 RAM 0 */ + + [15360] = 0x000A, /* R15360 - DSP2 Coeff RAM 0 */ + + [16384] = 0x0000, /* R16384 - RETUNEADC_SHARED_COEFF_1 */ + [16385] = 0x0000, /* R16385 - RETUNEADC_SHARED_COEFF_0 */ + [16386] = 0x0000, /* R16386 - RETUNEDAC_SHARED_COEFF_1 */ + [16387] = 0x0000, /* R16387 - RETUNEDAC_SHARED_COEFF_0 */ + [16388] = 0x0000, /* R16388 - SOUNDSTAGE_ENABLES_1 */ + [16389] = 0x0000, /* R16389 - SOUNDSTAGE_ENABLES_0 */ + + [16896] = 0x0002, /* R16896 - HDBASS_AI_1 */ + [16897] = 0xBD12, /* R16897 - HDBASS_AI_0 */ + [16898] = 0x007C, /* R16898 - HDBASS_AR_1 */ + [16899] = 0x586C, /* R16899 - HDBASS_AR_0 */ + [16900] = 0x0053, /* R16900 - HDBASS_B_1 */ + [16901] = 0x8121, /* R16901 - HDBASS_B_0 */ + [16902] = 0x003F, /* R16902 - HDBASS_K_1 */ + [16903] = 0x8BD8, /* R16903 - HDBASS_K_0 */ + [16904] = 0x0032, /* R16904 - HDBASS_N1_1 */ + [16905] = 0xF52D, /* R16905 - HDBASS_N1_0 */ + [16906] = 0x0065, /* R16906 - HDBASS_N2_1 */ + [16907] = 0xAC8C, /* R16907 - HDBASS_N2_0 */ + [16908] = 0x006B, /* R16908 - HDBASS_N3_1 */ + [16909] = 0xE087, /* R16909 - HDBASS_N3_0 */ + [16910] = 0x0072, /* R16910 - HDBASS_N4_1 */ + [16911] = 0x1483, /* R16911 - HDBASS_N4_0 */ + [16912] = 0x0072, /* R16912 - HDBASS_N5_1 */ + [16913] = 0x1483, /* R16913 - HDBASS_N5_0 */ + [16914] = 0x0043, /* R16914 - HDBASS_X1_1 */ + [16915] = 0x3525, /* R16915 - HDBASS_X1_0 */ + [16916] = 0x0006, /* R16916 - HDBASS_X2_1 */ + [16917] = 0x6A4A, /* R16917 - HDBASS_X2_0 */ + [16918] = 0x0043, /* R16918 - HDBASS_X3_1 */ + [16919] = 0x6079, /* R16919 - HDBASS_X3_0 */ + [16920] = 0x0008, /* R16920 - HDBASS_ATK_1 */ + [16921] = 0x0000, /* R16921 - HDBASS_ATK_0 */ + [16922] = 0x0001, /* R16922 - HDBASS_DCY_1 */ + [16923] = 0x0000, /* R16923 - HDBASS_DCY_0 */ + [16924] = 0x0059, /* R16924 - HDBASS_PG_1 */ + [16925] = 0x999A, /* R16925 - HDBASS_PG_0 */ + + [17048] = 0x0083, /* R17408 - HPF_C_1 */ + [17049] = 0x98AD, /* R17409 - HPF_C_0 */ + + [17920] = 0x007F, /* R17920 - ADCL_RETUNE_C1_1 */ + [17921] = 0xFFFF, /* R17921 - ADCL_RETUNE_C1_0 */ + [17922] = 0x0000, /* R17922 - ADCL_RETUNE_C2_1 */ + [17923] = 0x0000, /* R17923 - ADCL_RETUNE_C2_0 */ + [17924] = 0x0000, /* R17924 - ADCL_RETUNE_C3_1 */ + [17925] = 0x0000, /* R17925 - ADCL_RETUNE_C3_0 */ + [17926] = 0x0000, /* R17926 - ADCL_RETUNE_C4_1 */ + [17927] = 0x0000, /* R17927 - ADCL_RETUNE_C4_0 */ + [17928] = 0x0000, /* R17928 - ADCL_RETUNE_C5_1 */ + [17929] = 0x0000, /* R17929 - ADCL_RETUNE_C5_0 */ + [17930] = 0x0000, /* R17930 - ADCL_RETUNE_C6_1 */ + [17931] = 0x0000, /* R17931 - ADCL_RETUNE_C6_0 */ + [17932] = 0x0000, /* R17932 - ADCL_RETUNE_C7_1 */ + [17933] = 0x0000, /* R17933 - ADCL_RETUNE_C7_0 */ + [17934] = 0x0000, /* R17934 - ADCL_RETUNE_C8_1 */ + [17935] = 0x0000, /* R17935 - ADCL_RETUNE_C8_0 */ + [17936] = 0x0000, /* R17936 - ADCL_RETUNE_C9_1 */ + [17937] = 0x0000, /* R17937 - ADCL_RETUNE_C9_0 */ + [17938] = 0x0000, /* R17938 - ADCL_RETUNE_C10_1 */ + [17939] = 0x0000, /* R17939 - ADCL_RETUNE_C10_0 */ + [17940] = 0x0000, /* R17940 - ADCL_RETUNE_C11_1 */ + [17941] = 0x0000, /* R17941 - ADCL_RETUNE_C11_0 */ + [17942] = 0x0000, /* R17942 - ADCL_RETUNE_C12_1 */ + [17943] = 0x0000, /* R17943 - ADCL_RETUNE_C12_0 */ + [17944] = 0x0000, /* R17944 - ADCL_RETUNE_C13_1 */ + [17945] = 0x0000, /* R17945 - ADCL_RETUNE_C13_0 */ + [17946] = 0x0000, /* R17946 - ADCL_RETUNE_C14_1 */ + [17947] = 0x0000, /* R17947 - ADCL_RETUNE_C14_0 */ + [17948] = 0x0000, /* R17948 - ADCL_RETUNE_C15_1 */ + [17949] = 0x0000, /* R17949 - ADCL_RETUNE_C15_0 */ + [17950] = 0x0000, /* R17950 - ADCL_RETUNE_C16_1 */ + [17951] = 0x0000, /* R17951 - ADCL_RETUNE_C16_0 */ + [17952] = 0x0000, /* R17952 - ADCL_RETUNE_C17_1 */ + [17953] = 0x0000, /* R17953 - ADCL_RETUNE_C17_0 */ + [17954] = 0x0000, /* R17954 - ADCL_RETUNE_C18_1 */ + [17955] = 0x0000, /* R17955 - ADCL_RETUNE_C18_0 */ + [17956] = 0x0000, /* R17956 - ADCL_RETUNE_C19_1 */ + [17957] = 0x0000, /* R17957 - ADCL_RETUNE_C19_0 */ + [17958] = 0x0000, /* R17958 - ADCL_RETUNE_C20_1 */ + [17959] = 0x0000, /* R17959 - ADCL_RETUNE_C20_0 */ + [17960] = 0x0000, /* R17960 - ADCL_RETUNE_C21_1 */ + [17961] = 0x0000, /* R17961 - ADCL_RETUNE_C21_0 */ + [17962] = 0x0000, /* R17962 - ADCL_RETUNE_C22_1 */ + [17963] = 0x0000, /* R17963 - ADCL_RETUNE_C22_0 */ + [17964] = 0x0000, /* R17964 - ADCL_RETUNE_C23_1 */ + [17965] = 0x0000, /* R17965 - ADCL_RETUNE_C23_0 */ + [17966] = 0x0000, /* R17966 - ADCL_RETUNE_C24_1 */ + [17967] = 0x0000, /* R17967 - ADCL_RETUNE_C24_0 */ + [17968] = 0x0000, /* R17968 - ADCL_RETUNE_C25_1 */ + [17969] = 0x0000, /* R17969 - ADCL_RETUNE_C25_0 */ + [17970] = 0x0000, /* R17970 - ADCL_RETUNE_C26_1 */ + [17971] = 0x0000, /* R17971 - ADCL_RETUNE_C26_0 */ + [17972] = 0x0000, /* R17972 - ADCL_RETUNE_C27_1 */ + [17973] = 0x0000, /* R17973 - ADCL_RETUNE_C27_0 */ + [17974] = 0x0000, /* R17974 - ADCL_RETUNE_C28_1 */ + [17975] = 0x0000, /* R17975 - ADCL_RETUNE_C28_0 */ + [17976] = 0x0000, /* R17976 - ADCL_RETUNE_C29_1 */ + [17977] = 0x0000, /* R17977 - ADCL_RETUNE_C29_0 */ + [17978] = 0x0000, /* R17978 - ADCL_RETUNE_C30_1 */ + [17979] = 0x0000, /* R17979 - ADCL_RETUNE_C30_0 */ + [17980] = 0x0000, /* R17980 - ADCL_RETUNE_C31_1 */ + [17981] = 0x0000, /* R17981 - ADCL_RETUNE_C31_0 */ + [17982] = 0x0000, /* R17982 - ADCL_RETUNE_C32_1 */ + [17983] = 0x0000, /* R17983 - ADCL_RETUNE_C32_0 */ + + [18432] = 0x0020, /* R18432 - RETUNEADC_PG2_1 */ + [18433] = 0x0000, /* R18433 - RETUNEADC_PG2_0 */ + [18434] = 0x0040, /* R18434 - RETUNEADC_PG_1 */ + [18435] = 0x0000, /* R18435 - RETUNEADC_PG_0 */ + + [18944] = 0x007F, /* R18944 - ADCR_RETUNE_C1_1 */ + [18945] = 0xFFFF, /* R18945 - ADCR_RETUNE_C1_0 */ + [18946] = 0x0000, /* R18946 - ADCR_RETUNE_C2_1 */ + [18947] = 0x0000, /* R18947 - ADCR_RETUNE_C2_0 */ + [18948] = 0x0000, /* R18948 - ADCR_RETUNE_C3_1 */ + [18949] = 0x0000, /* R18949 - ADCR_RETUNE_C3_0 */ + [18950] = 0x0000, /* R18950 - ADCR_RETUNE_C4_1 */ + [18951] = 0x0000, /* R18951 - ADCR_RETUNE_C4_0 */ + [18952] = 0x0000, /* R18952 - ADCR_RETUNE_C5_1 */ + [18953] = 0x0000, /* R18953 - ADCR_RETUNE_C5_0 */ + [18954] = 0x0000, /* R18954 - ADCR_RETUNE_C6_1 */ + [18955] = 0x0000, /* R18955 - ADCR_RETUNE_C6_0 */ + [18956] = 0x0000, /* R18956 - ADCR_RETUNE_C7_1 */ + [18957] = 0x0000, /* R18957 - ADCR_RETUNE_C7_0 */ + [18958] = 0x0000, /* R18958 - ADCR_RETUNE_C8_1 */ + [18959] = 0x0000, /* R18959 - ADCR_RETUNE_C8_0 */ + [18960] = 0x0000, /* R18960 - ADCR_RETUNE_C9_1 */ + [18961] = 0x0000, /* R18961 - ADCR_RETUNE_C9_0 */ + [18962] = 0x0000, /* R18962 - ADCR_RETUNE_C10_1 */ + [18963] = 0x0000, /* R18963 - ADCR_RETUNE_C10_0 */ + [18964] = 0x0000, /* R18964 - ADCR_RETUNE_C11_1 */ + [18965] = 0x0000, /* R18965 - ADCR_RETUNE_C11_0 */ + [18966] = 0x0000, /* R18966 - ADCR_RETUNE_C12_1 */ + [18967] = 0x0000, /* R18967 - ADCR_RETUNE_C12_0 */ + [18968] = 0x0000, /* R18968 - ADCR_RETUNE_C13_1 */ + [18969] = 0x0000, /* R18969 - ADCR_RETUNE_C13_0 */ + [18970] = 0x0000, /* R18970 - ADCR_RETUNE_C14_1 */ + [18971] = 0x0000, /* R18971 - ADCR_RETUNE_C14_0 */ + [18972] = 0x0000, /* R18972 - ADCR_RETUNE_C15_1 */ + [18973] = 0x0000, /* R18973 - ADCR_RETUNE_C15_0 */ + [18974] = 0x0000, /* R18974 - ADCR_RETUNE_C16_1 */ + [18975] = 0x0000, /* R18975 - ADCR_RETUNE_C16_0 */ + [18976] = 0x0000, /* R18976 - ADCR_RETUNE_C17_1 */ + [18977] = 0x0000, /* R18977 - ADCR_RETUNE_C17_0 */ + [18978] = 0x0000, /* R18978 - ADCR_RETUNE_C18_1 */ + [18979] = 0x0000, /* R18979 - ADCR_RETUNE_C18_0 */ + [18980] = 0x0000, /* R18980 - ADCR_RETUNE_C19_1 */ + [18981] = 0x0000, /* R18981 - ADCR_RETUNE_C19_0 */ + [18982] = 0x0000, /* R18982 - ADCR_RETUNE_C20_1 */ + [18983] = 0x0000, /* R18983 - ADCR_RETUNE_C20_0 */ + [18984] = 0x0000, /* R18984 - ADCR_RETUNE_C21_1 */ + [18985] = 0x0000, /* R18985 - ADCR_RETUNE_C21_0 */ + [18986] = 0x0000, /* R18986 - ADCR_RETUNE_C22_1 */ + [18987] = 0x0000, /* R18987 - ADCR_RETUNE_C22_0 */ + [18988] = 0x0000, /* R18988 - ADCR_RETUNE_C23_1 */ + [18989] = 0x0000, /* R18989 - ADCR_RETUNE_C23_0 */ + [18990] = 0x0000, /* R18990 - ADCR_RETUNE_C24_1 */ + [18991] = 0x0000, /* R18991 - ADCR_RETUNE_C24_0 */ + [18992] = 0x0000, /* R18992 - ADCR_RETUNE_C25_1 */ + [18993] = 0x0000, /* R18993 - ADCR_RETUNE_C25_0 */ + [18994] = 0x0000, /* R18994 - ADCR_RETUNE_C26_1 */ + [18995] = 0x0000, /* R18995 - ADCR_RETUNE_C26_0 */ + [18996] = 0x0000, /* R18996 - ADCR_RETUNE_C27_1 */ + [18997] = 0x0000, /* R18997 - ADCR_RETUNE_C27_0 */ + [18998] = 0x0000, /* R18998 - ADCR_RETUNE_C28_1 */ + [18999] = 0x0000, /* R18999 - ADCR_RETUNE_C28_0 */ + [19000] = 0x0000, /* R19000 - ADCR_RETUNE_C29_1 */ + [19001] = 0x0000, /* R19001 - ADCR_RETUNE_C29_0 */ + [19002] = 0x0000, /* R19002 - ADCR_RETUNE_C30_1 */ + [19003] = 0x0000, /* R19003 - ADCR_RETUNE_C30_0 */ + [19004] = 0x0000, /* R19004 - ADCR_RETUNE_C31_1 */ + [19005] = 0x0000, /* R19005 - ADCR_RETUNE_C31_0 */ + [19006] = 0x0000, /* R19006 - ADCR_RETUNE_C32_1 */ + [19007] = 0x0000, /* R19007 - ADCR_RETUNE_C32_0 */ + + [19456] = 0x007F, /* R19456 - DACL_RETUNE_C1_1 */ + [19457] = 0xFFFF, /* R19457 - DACL_RETUNE_C1_0 */ + [19458] = 0x0000, /* R19458 - DACL_RETUNE_C2_1 */ + [19459] = 0x0000, /* R19459 - DACL_RETUNE_C2_0 */ + [19460] = 0x0000, /* R19460 - DACL_RETUNE_C3_1 */ + [19461] = 0x0000, /* R19461 - DACL_RETUNE_C3_0 */ + [19462] = 0x0000, /* R19462 - DACL_RETUNE_C4_1 */ + [19463] = 0x0000, /* R19463 - DACL_RETUNE_C4_0 */ + [19464] = 0x0000, /* R19464 - DACL_RETUNE_C5_1 */ + [19465] = 0x0000, /* R19465 - DACL_RETUNE_C5_0 */ + [19466] = 0x0000, /* R19466 - DACL_RETUNE_C6_1 */ + [19467] = 0x0000, /* R19467 - DACL_RETUNE_C6_0 */ + [19468] = 0x0000, /* R19468 - DACL_RETUNE_C7_1 */ + [19469] = 0x0000, /* R19469 - DACL_RETUNE_C7_0 */ + [19470] = 0x0000, /* R19470 - DACL_RETUNE_C8_1 */ + [19471] = 0x0000, /* R19471 - DACL_RETUNE_C8_0 */ + [19472] = 0x0000, /* R19472 - DACL_RETUNE_C9_1 */ + [19473] = 0x0000, /* R19473 - DACL_RETUNE_C9_0 */ + [19474] = 0x0000, /* R19474 - DACL_RETUNE_C10_1 */ + [19475] = 0x0000, /* R19475 - DACL_RETUNE_C10_0 */ + [19476] = 0x0000, /* R19476 - DACL_RETUNE_C11_1 */ + [19477] = 0x0000, /* R19477 - DACL_RETUNE_C11_0 */ + [19478] = 0x0000, /* R19478 - DACL_RETUNE_C12_1 */ + [19479] = 0x0000, /* R19479 - DACL_RETUNE_C12_0 */ + [19480] = 0x0000, /* R19480 - DACL_RETUNE_C13_1 */ + [19481] = 0x0000, /* R19481 - DACL_RETUNE_C13_0 */ + [19482] = 0x0000, /* R19482 - DACL_RETUNE_C14_1 */ + [19483] = 0x0000, /* R19483 - DACL_RETUNE_C14_0 */ + [19484] = 0x0000, /* R19484 - DACL_RETUNE_C15_1 */ + [19485] = 0x0000, /* R19485 - DACL_RETUNE_C15_0 */ + [19486] = 0x0000, /* R19486 - DACL_RETUNE_C16_1 */ + [19487] = 0x0000, /* R19487 - DACL_RETUNE_C16_0 */ + [19488] = 0x0000, /* R19488 - DACL_RETUNE_C17_1 */ + [19489] = 0x0000, /* R19489 - DACL_RETUNE_C17_0 */ + [19490] = 0x0000, /* R19490 - DACL_RETUNE_C18_1 */ + [19491] = 0x0000, /* R19491 - DACL_RETUNE_C18_0 */ + [19492] = 0x0000, /* R19492 - DACL_RETUNE_C19_1 */ + [19493] = 0x0000, /* R19493 - DACL_RETUNE_C19_0 */ + [19494] = 0x0000, /* R19494 - DACL_RETUNE_C20_1 */ + [19495] = 0x0000, /* R19495 - DACL_RETUNE_C20_0 */ + [19496] = 0x0000, /* R19496 - DACL_RETUNE_C21_1 */ + [19497] = 0x0000, /* R19497 - DACL_RETUNE_C21_0 */ + [19498] = 0x0000, /* R19498 - DACL_RETUNE_C22_1 */ + [19499] = 0x0000, /* R19499 - DACL_RETUNE_C22_0 */ + [19500] = 0x0000, /* R19500 - DACL_RETUNE_C23_1 */ + [19501] = 0x0000, /* R19501 - DACL_RETUNE_C23_0 */ + [19502] = 0x0000, /* R19502 - DACL_RETUNE_C24_1 */ + [19503] = 0x0000, /* R19503 - DACL_RETUNE_C24_0 */ + [19504] = 0x0000, /* R19504 - DACL_RETUNE_C25_1 */ + [19505] = 0x0000, /* R19505 - DACL_RETUNE_C25_0 */ + [19506] = 0x0000, /* R19506 - DACL_RETUNE_C26_1 */ + [19507] = 0x0000, /* R19507 - DACL_RETUNE_C26_0 */ + [19508] = 0x0000, /* R19508 - DACL_RETUNE_C27_1 */ + [19509] = 0x0000, /* R19509 - DACL_RETUNE_C27_0 */ + [19510] = 0x0000, /* R19510 - DACL_RETUNE_C28_1 */ + [19511] = 0x0000, /* R19511 - DACL_RETUNE_C28_0 */ + [19512] = 0x0000, /* R19512 - DACL_RETUNE_C29_1 */ + [19513] = 0x0000, /* R19513 - DACL_RETUNE_C29_0 */ + [19514] = 0x0000, /* R19514 - DACL_RETUNE_C30_1 */ + [19515] = 0x0000, /* R19515 - DACL_RETUNE_C30_0 */ + [19516] = 0x0000, /* R19516 - DACL_RETUNE_C31_1 */ + [19517] = 0x0000, /* R19517 - DACL_RETUNE_C31_0 */ + [19518] = 0x0000, /* R19518 - DACL_RETUNE_C32_1 */ + [19519] = 0x0000, /* R19519 - DACL_RETUNE_C32_0 */ + + [19968] = 0x0020, /* R19968 - RETUNEDAC_PG2_1 */ + [19969] = 0x0000, /* R19969 - RETUNEDAC_PG2_0 */ + [19970] = 0x0040, /* R19970 - RETUNEDAC_PG_1 */ + [19971] = 0x0000, /* R19971 - RETUNEDAC_PG_0 */ + + [20480] = 0x007F, /* R20480 - DACR_RETUNE_C1_1 */ + [20481] = 0xFFFF, /* R20481 - DACR_RETUNE_C1_0 */ + [20482] = 0x0000, /* R20482 - DACR_RETUNE_C2_1 */ + [20483] = 0x0000, /* R20483 - DACR_RETUNE_C2_0 */ + [20484] = 0x0000, /* R20484 - DACR_RETUNE_C3_1 */ + [20485] = 0x0000, /* R20485 - DACR_RETUNE_C3_0 */ + [20486] = 0x0000, /* R20486 - DACR_RETUNE_C4_1 */ + [20487] = 0x0000, /* R20487 - DACR_RETUNE_C4_0 */ + [20488] = 0x0000, /* R20488 - DACR_RETUNE_C5_1 */ + [20489] = 0x0000, /* R20489 - DACR_RETUNE_C5_0 */ + [20490] = 0x0000, /* R20490 - DACR_RETUNE_C6_1 */ + [20491] = 0x0000, /* R20491 - DACR_RETUNE_C6_0 */ + [20492] = 0x0000, /* R20492 - DACR_RETUNE_C7_1 */ + [20493] = 0x0000, /* R20493 - DACR_RETUNE_C7_0 */ + [20494] = 0x0000, /* R20494 - DACR_RETUNE_C8_1 */ + [20495] = 0x0000, /* R20495 - DACR_RETUNE_C8_0 */ + [20496] = 0x0000, /* R20496 - DACR_RETUNE_C9_1 */ + [20497] = 0x0000, /* R20497 - DACR_RETUNE_C9_0 */ + [20498] = 0x0000, /* R20498 - DACR_RETUNE_C10_1 */ + [20499] = 0x0000, /* R20499 - DACR_RETUNE_C10_0 */ + [20500] = 0x0000, /* R20500 - DACR_RETUNE_C11_1 */ + [20501] = 0x0000, /* R20501 - DACR_RETUNE_C11_0 */ + [20502] = 0x0000, /* R20502 - DACR_RETUNE_C12_1 */ + [20503] = 0x0000, /* R20503 - DACR_RETUNE_C12_0 */ + [20504] = 0x0000, /* R20504 - DACR_RETUNE_C13_1 */ + [20505] = 0x0000, /* R20505 - DACR_RETUNE_C13_0 */ + [20506] = 0x0000, /* R20506 - DACR_RETUNE_C14_1 */ + [20507] = 0x0000, /* R20507 - DACR_RETUNE_C14_0 */ + [20508] = 0x0000, /* R20508 - DACR_RETUNE_C15_1 */ + [20509] = 0x0000, /* R20509 - DACR_RETUNE_C15_0 */ + [20510] = 0x0000, /* R20510 - DACR_RETUNE_C16_1 */ + [20511] = 0x0000, /* R20511 - DACR_RETUNE_C16_0 */ + [20512] = 0x0000, /* R20512 - DACR_RETUNE_C17_1 */ + [20513] = 0x0000, /* R20513 - DACR_RETUNE_C17_0 */ + [20514] = 0x0000, /* R20514 - DACR_RETUNE_C18_1 */ + [20515] = 0x0000, /* R20515 - DACR_RETUNE_C18_0 */ + [20516] = 0x0000, /* R20516 - DACR_RETUNE_C19_1 */ + [20517] = 0x0000, /* R20517 - DACR_RETUNE_C19_0 */ + [20518] = 0x0000, /* R20518 - DACR_RETUNE_C20_1 */ + [20519] = 0x0000, /* R20519 - DACR_RETUNE_C20_0 */ + [20520] = 0x0000, /* R20520 - DACR_RETUNE_C21_1 */ + [20521] = 0x0000, /* R20521 - DACR_RETUNE_C21_0 */ + [20522] = 0x0000, /* R20522 - DACR_RETUNE_C22_1 */ + [20523] = 0x0000, /* R20523 - DACR_RETUNE_C22_0 */ + [20524] = 0x0000, /* R20524 - DACR_RETUNE_C23_1 */ + [20525] = 0x0000, /* R20525 - DACR_RETUNE_C23_0 */ + [20526] = 0x0000, /* R20526 - DACR_RETUNE_C24_1 */ + [20527] = 0x0000, /* R20527 - DACR_RETUNE_C24_0 */ + [20528] = 0x0000, /* R20528 - DACR_RETUNE_C25_1 */ + [20529] = 0x0000, /* R20529 - DACR_RETUNE_C25_0 */ + [20530] = 0x0000, /* R20530 - DACR_RETUNE_C26_1 */ + [20531] = 0x0000, /* R20531 - DACR_RETUNE_C26_0 */ + [20532] = 0x0000, /* R20532 - DACR_RETUNE_C27_1 */ + [20533] = 0x0000, /* R20533 - DACR_RETUNE_C27_0 */ + [20534] = 0x0000, /* R20534 - DACR_RETUNE_C28_1 */ + [20535] = 0x0000, /* R20535 - DACR_RETUNE_C28_0 */ + [20536] = 0x0000, /* R20536 - DACR_RETUNE_C29_1 */ + [20537] = 0x0000, /* R20537 - DACR_RETUNE_C29_0 */ + [20538] = 0x0000, /* R20538 - DACR_RETUNE_C30_1 */ + [20539] = 0x0000, /* R20539 - DACR_RETUNE_C30_0 */ + [20540] = 0x0000, /* R20540 - DACR_RETUNE_C31_1 */ + [20541] = 0x0000, /* R20541 - DACR_RETUNE_C31_0 */ + [20542] = 0x0000, /* R20542 - DACR_RETUNE_C32_1 */ + [20543] = 0x0000, /* R20543 - DACR_RETUNE_C32_0 */ + + [20992] = 0x008C, /* R20992 - VSS_XHD2_1 */ + [20993] = 0x0200, /* R20993 - VSS_XHD2_0 */ + [20994] = 0x0035, /* R20994 - VSS_XHD3_1 */ + [20995] = 0x0700, /* R20995 - VSS_XHD3_0 */ + [20996] = 0x003A, /* R20996 - VSS_XHN1_1 */ + [20997] = 0x4100, /* R20997 - VSS_XHN1_0 */ + [20998] = 0x008B, /* R20998 - VSS_XHN2_1 */ + [20999] = 0x7D00, /* R20999 - VSS_XHN2_0 */ + [21000] = 0x003A, /* R21000 - VSS_XHN3_1 */ + [21001] = 0x4100, /* R21001 - VSS_XHN3_0 */ + [21002] = 0x008C, /* R21002 - VSS_XLA_1 */ + [21003] = 0xFEE8, /* R21003 - VSS_XLA_0 */ + [21004] = 0x0078, /* R21004 - VSS_XLB_1 */ + [21005] = 0x0000, /* R21005 - VSS_XLB_0 */ + [21006] = 0x003F, /* R21006 - VSS_XLG_1 */ + [21007] = 0xB260, /* R21007 - VSS_XLG_0 */ + [21008] = 0x002D, /* R21008 - VSS_PG2_1 */ + [21009] = 0x1818, /* R21009 - VSS_PG2_0 */ + [21010] = 0x0020, /* R21010 - VSS_PG_1 */ + [21011] = 0x0000, /* R21011 - VSS_PG_0 */ + [21012] = 0x00F1, /* R21012 - VSS_XTD1_1 */ + [21013] = 0x8340, /* R21013 - VSS_XTD1_0 */ + [21014] = 0x00FB, /* R21014 - VSS_XTD2_1 */ + [21015] = 0x8300, /* R21015 - VSS_XTD2_0 */ + [21016] = 0x00EE, /* R21016 - VSS_XTD3_1 */ + [21017] = 0xAEC0, /* R21017 - VSS_XTD3_0 */ + [21018] = 0x00FB, /* R21018 - VSS_XTD4_1 */ + [21019] = 0xAC40, /* R21019 - VSS_XTD4_0 */ + [21020] = 0x00F1, /* R21020 - VSS_XTD5_1 */ + [21021] = 0x7F80, /* R21021 - VSS_XTD5_0 */ + [21022] = 0x00F4, /* R21022 - VSS_XTD6_1 */ + [21023] = 0x3B40, /* R21023 - VSS_XTD6_0 */ + [21024] = 0x00F5, /* R21024 - VSS_XTD7_1 */ + [21025] = 0xFB00, /* R21025 - VSS_XTD7_0 */ + [21026] = 0x00EA, /* R21026 - VSS_XTD8_1 */ + [21027] = 0x10C0, /* R21027 - VSS_XTD8_0 */ + [21028] = 0x00FC, /* R21028 - VSS_XTD9_1 */ + [21029] = 0xC580, /* R21029 - VSS_XTD9_0 */ + [21030] = 0x00E2, /* R21030 - VSS_XTD10_1 */ + [21031] = 0x75C0, /* R21031 - VSS_XTD10_0 */ + [21032] = 0x0004, /* R21032 - VSS_XTD11_1 */ + [21033] = 0xB480, /* R21033 - VSS_XTD11_0 */ + [21034] = 0x00D4, /* R21034 - VSS_XTD12_1 */ + [21035] = 0xF980, /* R21035 - VSS_XTD12_0 */ + [21036] = 0x0004, /* R21036 - VSS_XTD13_1 */ + [21037] = 0x9140, /* R21037 - VSS_XTD13_0 */ + [21038] = 0x00D8, /* R21038 - VSS_XTD14_1 */ + [21039] = 0xA480, /* R21039 - VSS_XTD14_0 */ + [21040] = 0x0002, /* R21040 - VSS_XTD15_1 */ + [21041] = 0x3DC0, /* R21041 - VSS_XTD15_0 */ + [21042] = 0x00CF, /* R21042 - VSS_XTD16_1 */ + [21043] = 0x7A80, /* R21043 - VSS_XTD16_0 */ + [21044] = 0x00DC, /* R21044 - VSS_XTD17_1 */ + [21045] = 0x0600, /* R21045 - VSS_XTD17_0 */ + [21046] = 0x00F2, /* R21046 - VSS_XTD18_1 */ + [21047] = 0xDAC0, /* R21047 - VSS_XTD18_0 */ + [21048] = 0x00BA, /* R21048 - VSS_XTD19_1 */ + [21049] = 0xF340, /* R21049 - VSS_XTD19_0 */ + [21050] = 0x000A, /* R21050 - VSS_XTD20_1 */ + [21051] = 0x7940, /* R21051 - VSS_XTD20_0 */ + [21052] = 0x001C, /* R21052 - VSS_XTD21_1 */ + [21053] = 0x0680, /* R21053 - VSS_XTD21_0 */ + [21054] = 0x00FD, /* R21054 - VSS_XTD22_1 */ + [21055] = 0x2D00, /* R21055 - VSS_XTD22_0 */ + [21056] = 0x001C, /* R21056 - VSS_XTD23_1 */ + [21057] = 0xE840, /* R21057 - VSS_XTD23_0 */ + [21058] = 0x000D, /* R21058 - VSS_XTD24_1 */ + [21059] = 0xDC40, /* R21059 - VSS_XTD24_0 */ + [21060] = 0x00FC, /* R21060 - VSS_XTD25_1 */ + [21061] = 0x9D00, /* R21061 - VSS_XTD25_0 */ + [21062] = 0x0009, /* R21062 - VSS_XTD26_1 */ + [21063] = 0x5580, /* R21063 - VSS_XTD26_0 */ + [21064] = 0x00FE, /* R21064 - VSS_XTD27_1 */ + [21065] = 0x7E80, /* R21065 - VSS_XTD27_0 */ + [21066] = 0x000E, /* R21066 - VSS_XTD28_1 */ + [21067] = 0xAB40, /* R21067 - VSS_XTD28_0 */ + [21068] = 0x00F9, /* R21068 - VSS_XTD29_1 */ + [21069] = 0x9880, /* R21069 - VSS_XTD29_0 */ + [21070] = 0x0009, /* R21070 - VSS_XTD30_1 */ + [21071] = 0x87C0, /* R21071 - VSS_XTD30_0 */ + [21072] = 0x00FD, /* R21072 - VSS_XTD31_1 */ + [21073] = 0x2C40, /* R21073 - VSS_XTD31_0 */ + [21074] = 0x0009, /* R21074 - VSS_XTD32_1 */ + [21075] = 0x4800, /* R21075 - VSS_XTD32_0 */ + [21076] = 0x0003, /* R21076 - VSS_XTS1_1 */ + [21077] = 0x5F40, /* R21077 - VSS_XTS1_0 */ + [21078] = 0x0000, /* R21078 - VSS_XTS2_1 */ + [21079] = 0x8700, /* R21079 - VSS_XTS2_0 */ + [21080] = 0x00FA, /* R21080 - VSS_XTS3_1 */ + [21081] = 0xE4C0, /* R21081 - VSS_XTS3_0 */ + [21082] = 0x0000, /* R21082 - VSS_XTS4_1 */ + [21083] = 0x0B40, /* R21083 - VSS_XTS4_0 */ + [21084] = 0x0004, /* R21084 - VSS_XTS5_1 */ + [21085] = 0xE180, /* R21085 - VSS_XTS5_0 */ + [21086] = 0x0001, /* R21086 - VSS_XTS6_1 */ + [21087] = 0x1F40, /* R21087 - VSS_XTS6_0 */ + [21088] = 0x00F8, /* R21088 - VSS_XTS7_1 */ + [21089] = 0xB000, /* R21089 - VSS_XTS7_0 */ + [21090] = 0x00FB, /* R21090 - VSS_XTS8_1 */ + [21091] = 0xCBC0, /* R21091 - VSS_XTS8_0 */ + [21092] = 0x0004, /* R21092 - VSS_XTS9_1 */ + [21093] = 0xF380, /* R21093 - VSS_XTS9_0 */ + [21094] = 0x0007, /* R21094 - VSS_XTS10_1 */ + [21095] = 0xDF40, /* R21095 - VSS_XTS10_0 */ + [21096] = 0x00FF, /* R21096 - VSS_XTS11_1 */ + [21097] = 0x0700, /* R21097 - VSS_XTS11_0 */ + [21098] = 0x00EF, /* R21098 - VSS_XTS12_1 */ + [21099] = 0xD700, /* R21099 - VSS_XTS12_0 */ + [21100] = 0x00FB, /* R21100 - VSS_XTS13_1 */ + [21101] = 0xAF40, /* R21101 - VSS_XTS13_0 */ + [21102] = 0x0010, /* R21102 - VSS_XTS14_1 */ + [21103] = 0x8A80, /* R21103 - VSS_XTS14_0 */ + [21104] = 0x0011, /* R21104 - VSS_XTS15_1 */ + [21105] = 0x07C0, /* R21105 - VSS_XTS15_0 */ + [21106] = 0x00E0, /* R21106 - VSS_XTS16_1 */ + [21107] = 0x0800, /* R21107 - VSS_XTS16_0 */ + [21108] = 0x00D2, /* R21108 - VSS_XTS17_1 */ + [21109] = 0x7600, /* R21109 - VSS_XTS17_0 */ + [21110] = 0x0020, /* R21110 - VSS_XTS18_1 */ + [21111] = 0xCF40, /* R21111 - VSS_XTS18_0 */ + [21112] = 0x0030, /* R21112 - VSS_XTS19_1 */ + [21113] = 0x2340, /* R21113 - VSS_XTS19_0 */ + [21114] = 0x00FD, /* R21114 - VSS_XTS20_1 */ + [21115] = 0x69C0, /* R21115 - VSS_XTS20_0 */ + [21116] = 0x0028, /* R21116 - VSS_XTS21_1 */ + [21117] = 0x3500, /* R21117 - VSS_XTS21_0 */ + [21118] = 0x0006, /* R21118 - VSS_XTS22_1 */ + [21119] = 0x3300, /* R21119 - VSS_XTS22_0 */ + [21120] = 0x00D9, /* R21120 - VSS_XTS23_1 */ + [21121] = 0xF6C0, /* R21121 - VSS_XTS23_0 */ + [21122] = 0x00F3, /* R21122 - VSS_XTS24_1 */ + [21123] = 0x3340, /* R21123 - VSS_XTS24_0 */ + [21124] = 0x000F, /* R21124 - VSS_XTS25_1 */ + [21125] = 0x4200, /* R21125 - VSS_XTS25_0 */ + [21126] = 0x0004, /* R21126 - VSS_XTS26_1 */ + [21127] = 0x0C80, /* R21127 - VSS_XTS26_0 */ + [21128] = 0x00FB, /* R21128 - VSS_XTS27_1 */ + [21129] = 0x3F80, /* R21129 - VSS_XTS27_0 */ + [21130] = 0x00F7, /* R21130 - VSS_XTS28_1 */ + [21131] = 0x57C0, /* R21131 - VSS_XTS28_0 */ + [21132] = 0x0003, /* R21132 - VSS_XTS29_1 */ + [21133] = 0x5400, /* R21133 - VSS_XTS29_0 */ + [21134] = 0x0000, /* R21134 - VSS_XTS30_1 */ + [21135] = 0xC6C0, /* R21135 - VSS_XTS30_0 */ + [21136] = 0x0003, /* R21136 - VSS_XTS31_1 */ + [21137] = 0x12C0, /* R21137 - VSS_XTS31_0 */ + [21138] = 0x00FD, /* R21138 - VSS_XTS32_1 */ + [21139] = 0x8580, /* R21139 - VSS_XTS32_0 */ +}; + static int wm8962_volatile_register(unsigned int reg) { if (wm8962_reg_access[reg].vol) diff --git a/sound/soc/codecs/wm8962.h b/sound/soc/codecs/wm8962.h index 2af6c93..588726df 100644 --- a/sound/soc/codecs/wm8962.h +++ b/sound/soc/codecs/wm8962.h @@ -3775,8 +3775,6 @@ #define WM8962_VSS_ENA_SHIFT 0 /* VSS_ENA */ #define WM8962_VSS_ENA_WIDTH 1 /* VSS_ENA */ -extern const u16 wm8962_reg[WM8962_MAX_REGISTER + 1]; - struct wm8962_reg_access { u16 read; u16 write; -- cgit v1.1 From c969f19f8fd17e600a16fe91aab66d86936cce0a Mon Sep 17 00:00:00 2001 From: Mark Brown Date: Thu, 7 Oct 2010 20:41:04 -0700 Subject: ASoC: Compress WM8962 register access map Reduce the source code size still futher by only specifying non-zero rows in the WM8962 access map. Signed-off-by: Mark Brown Acked-by: Liam Girdwood --- sound/soc/codecs/Makefile | 2 +- sound/soc/codecs/wm8962-tables.c | 21156 ------------------------------------- sound/soc/codecs/wm8962.c | 1147 ++ sound/soc/codecs/wm8962.h | 9 - 4 files changed, 1148 insertions(+), 21166 deletions(-) delete mode 100644 sound/soc/codecs/wm8962-tables.c (limited to 'sound') diff --git a/sound/soc/codecs/Makefile b/sound/soc/codecs/Makefile index 0c5f329..af4d4c4 100644 --- a/sound/soc/codecs/Makefile +++ b/sound/soc/codecs/Makefile @@ -49,7 +49,7 @@ snd-soc-wm8940-objs := wm8940.o snd-soc-wm8955-objs := wm8955.o snd-soc-wm8960-objs := wm8960.o snd-soc-wm8961-objs := wm8961.o -snd-soc-wm8962-objs := wm8962.o wm8962-tables.o +snd-soc-wm8962-objs := wm8962.o snd-soc-wm8971-objs := wm8971.o snd-soc-wm8974-objs := wm8974.o snd-soc-wm8978-objs := wm8978.o diff --git a/sound/soc/codecs/wm8962-tables.c b/sound/soc/codecs/wm8962-tables.c deleted file mode 100644 index 8231eaa..0000000 --- a/sound/soc/codecs/wm8962-tables.c +++ /dev/null @@ -1,21156 +0,0 @@ -/* - * wm8962-tables.c -- WM8962 ASoC driver - * - * Copyright 2010 Wolfson Microelectronics, plc - * - * Author: Mark Brown - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. - */ - -#include "wm8962.h" - -const struct wm8962_reg_access wm8962_reg_access[WM8962_MAX_REGISTER + 1] = { - { 0x00FF, 0x01FF, 0x0000 }, /* R0 - Left Input volume */ - { 0xFEFF, 0x01FF, 0xFFFF }, /* R1 - Right Input volume */ - { 0x00FF, 0x01FF, 0x0000 }, /* R2 - HPOUTL volume */ - { 0x00FF, 0x01FF, 0x0000 }, /* R3 - HPOUTR volume */ - { 0x07FE, 0x07FE, 0xFFFF }, /* R4 - Clocking1 */ - { 0x007F, 0x007F, 0x0000 }, /* R5 - ADC & DAC Control 1 */ - { 0x37ED, 0x37ED, 0x0000 }, /* R6 - ADC & DAC Control 2 */ - { 0x1FFF, 0x1FFF, 0x0000 }, /* R7 - Audio Interface 0 */ - { 0x0FEF, 0x0FEF, 0xFFFF }, /* R8 - Clocking2 */ - { 0x0B9F, 0x039F, 0x0000 }, /* R9 - Audio Interface 1 */ - { 0x00FF, 0x01FF, 0x0000 }, /* R10 - Left DAC volume */ - { 0x00FF, 0x01FF, 0x0000 }, /* R11 - Right DAC volume */ - { 0x0000, 0x0000, 0x0000 }, /* R12 */ - { 0x0000, 0x0000, 0x0000 }, /* R13 */ - { 0x07FF, 0x07FF, 0x0000 }, /* R14 - Audio Interface 2 */ - { 0xFFFF, 0xFFFF, 0xFFFF }, /* R15 - Software Reset */ - { 0x0000, 0x0000, 0x0000 }, /* R16 */ - { 0x07FF, 0x07FF, 0x0000 }, /* R17 - ALC1 */ - { 0xF8FF, 0x00FF, 0xFFFF }, /* R18 - ALC2 */ - { 0x1DFF, 0x1DFF, 0x0000 }, /* R19 - ALC3 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20 - Noise Gate */ - { 0x00FF, 0x01FF, 0x0000 }, /* R21 - Left ADC volume */ - { 0x00FF, 0x01FF, 0x0000 }, /* R22 - Right ADC volume */ - { 0x0161, 0x0161, 0x0000 }, /* R23 - Additional control(1) */ - { 0x0008, 0x0008, 0x0000 }, /* R24 - Additional control(2) */ - { 0x07FE, 0x07FE, 0x0000 }, /* R25 - Pwr Mgmt (1) */ - { 0x01FB, 0x01FB, 0x0000 }, /* R26 - Pwr Mgmt (2) */ - { 0x0017, 0x0017, 0x0000 }, /* R27 - Additional Control (3) */ - { 0x001C, 0x001C, 0x0000 }, /* R28 - Anti-pop */ - { 0x0000, 0x0000, 0x0000 }, /* R29 */ - { 0xFFFE, 0xFFFE, 0x0000 }, /* R30 - Clocking 3 */ - { 0x000F, 0x000F, 0x0000 }, /* R31 - Input mixer control (1) */ - { 0x01FF, 0x01FF, 0x0000 }, /* R32 - Left input mixer volume */ - { 0x01FF, 0x01FF, 0x0000 }, /* R33 - Right input mixer volume */ - { 0x003F, 0x003F, 0x0000 }, /* R34 - Input mixer control (2) */ - { 0x003F, 0x003F, 0x0000 }, /* R35 - Input bias control */ - { 0x0000, 0x0000, 0x0000 }, /* R36 */ - { 0x001F, 0x001F, 0x0000 }, /* R37 - Left input PGA control */ - { 0x001F, 0x001F, 0x0000 }, /* R38 - Right input PGA control */ - { 0x0000, 0x0000, 0x0000 }, /* R39 */ - { 0x00FF, 0x01FF, 0x0000 }, /* R40 - SPKOUTL volume */ - { 0x00FF, 0x01FF, 0x0000 }, /* R41 - SPKOUTR volume */ - { 0x0000, 0x0000, 0x0000 }, /* R42 */ - { 0x0000, 0x0000, 0x0000 }, /* R43 */ - { 0x0000, 0x0000, 0x0000 }, /* R44 */ - { 0x0000, 0x0000, 0x0000 }, /* R45 */ - { 0x0000, 0x0000, 0x0000 }, /* R46 */ - { 0x000F, 0x0000, 0x0000 }, /* R47 - Thermal Shutdown Status */ - { 0x7EC7, 0x7E07, 0xFFFF }, /* R48 - Additional Control (4) */ - { 0x00D3, 0x00D7, 0xFFFF }, /* R49 - Class D Control 1 */ - { 0x0000, 0x0000, 0x0000 }, /* R50 */ - { 0x0047, 0x0047, 0x0000 }, /* R51 - Class D Control 2 */ - { 0x0000, 0x0000, 0x0000 }, /* R52 */ - { 0x0000, 0x0000, 0x0000 }, /* R53 */ - { 0x0000, 0x0000, 0x0000 }, /* R54 */ - { 0x0000, 0x0000, 0x0000 }, /* R55 */ - { 0x001E, 0x001E, 0x0000 }, /* R56 - Clocking 4 */ - { 0x02FC, 0x02FC, 0x0000 }, /* R57 - DAC DSP Mixing (1) */ - { 0x00FC, 0x00FC, 0x0000 }, /* R58 - DAC DSP Mixing (2) */ - { 0x0000, 0x0000, 0x0000 }, /* R59 */ - { 0x00CC, 0x00CC, 0x0000 }, /* R60 - DC Servo 0 */ - { 0x00DD, 0x00DD, 0x0000 }, /* R61 - DC Servo 1 */ - { 0x0000, 0x0000, 0x0000 }, /* R62 */ - { 0x0000, 0x0000, 0x0000 }, /* R63 */ - { 0x3F80, 0x3F80, 0x0000 }, /* R64 - DC Servo 4 */ - { 0x0000, 0x0000, 0x0000 }, /* R65 */ - { 0x0780, 0x0000, 0xFFFF }, /* R66 - DC Servo 6 */ - { 0x0000, 0x0000, 0x0000 }, /* R67 */ - { 0x0007, 0x0007, 0x0000 }, /* R68 - Analogue PGA Bias */ - { 0x00FF, 0x00FF, 0x0000 }, /* R69 - Analogue HP 0 */ - { 0x0000, 0x0000, 0x0000 }, /* R70 */ - { 0x01FF, 0x01FF, 0x0000 }, /* R71 - Analogue HP 2 */ - { 0x0001, 0x0001, 0x0000 }, /* R72 - Charge Pump 1 */ - { 0x0000, 0x0000, 0x0000 }, /* R73 */ - { 0x0000, 0x0000, 0x0000 }, /* R74 */ - { 0x0000, 0x0000, 0x0000 }, /* R75 */ - { 0x0000, 0x0000, 0x0000 }, /* R76 */ - { 0x0000, 0x0000, 0x0000 }, /* R77 */ - { 0x0000, 0x0000, 0x0000 }, /* R78 */ - { 0x0000, 0x0000, 0x0000 }, /* R79 */ - { 0x0000, 0x0000, 0x0000 }, /* R80 */ - { 0x0000, 0x0000, 0x0000 }, /* R81 */ - { 0x0001, 0x0001, 0x0000 }, /* R82 - Charge Pump B */ - { 0x0000, 0x0000, 0x0000 }, /* R83 */ - { 0x0000, 0x0000, 0x0000 }, /* R84 */ - { 0x0000, 0x0000, 0x0000 }, /* R85 */ - { 0x0000, 0x0000, 0x0000 }, /* R86 */ - { 0x00A0, 0x00A0, 0x0000 }, /* R87 - Write Sequencer Control 1 */ - { 0x0000, 0x0000, 0x0000 }, /* R88 */ - { 0x0000, 0x0000, 0x0000 }, /* R89 */ - { 0x007F, 0x01FF, 0x0000 }, /* R90 - Write Sequencer Control 2 */ - { 0x0000, 0x0000, 0x0000 }, /* R91 */ - { 0x0000, 0x0000, 0x0000 }, /* R92 */ - { 0x03F9, 0x0000, 0x0000 }, /* R93 - Write Sequencer Control 3 */ - { 0x0070, 0x0070, 0x0000 }, /* R94 - Control Interface */ - { 0x0000, 0x0000, 0x0000 }, /* R95 */ - { 0x0000, 0x0000, 0x0000 }, /* R96 */ - { 0x0000, 0x0000, 0x0000 }, /* R97 */ - { 0x0000, 0x0000, 0x0000 }, /* R98 */ - { 0x000F, 0x000F, 0x0000 }, /* R99 - Mixer Enables */ - { 0x00BF, 0x00BF, 0x0000 }, /* R100 - Headphone Mixer (1) */ - { 0x00BF, 0x00BF, 0x0000 }, /* R101 - Headphone Mixer (2) */ - { 0x01FF, 0x01FF, 0x0000 }, /* R102 - Headphone Mixer (3) */ - { 0x01FF, 0x01FF, 0x0000 }, /* R103 - Headphone Mixer (4) */ - { 0x0000, 0x0000, 0x0000 }, /* R104 */ - { 0x00BF, 0x00BF, 0x0000 }, /* R105 - Speaker Mixer (1) */ - { 0x00BF, 0x00BF, 0x0000 }, /* R106 - Speaker Mixer (2) */ - { 0x01FF, 0x01FF, 0x0000 }, /* R107 - Speaker Mixer (3) */ - { 0x01FF, 0x01FF, 0x0000 }, /* R108 - Speaker Mixer (4) */ - { 0x00F0, 0x00F0, 0x0000 }, /* R109 - Speaker Mixer (5) */ - { 0x00F7, 0x00F7, 0x0000 }, /* R110 - Beep Generator (1) */ - { 0x0000, 0x0000, 0x0000 }, /* R111 */ - { 0x0000, 0x0000, 0x0000 }, /* R112 */ - { 0x0000, 0x0000, 0x0000 }, /* R113 */ - { 0x0000, 0x0000, 0x0000 }, /* R114 */ - { 0x001F, 0x001F, 0x0000 }, /* R115 - Oscillator Trim (3) */ - { 0x001F, 0x001F, 0x0000 }, /* R116 - Oscillator Trim (4) */ - { 0x0000, 0x0000, 0x0000 }, /* R117 */ - { 0x0000, 0x0000, 0x0000 }, /* R118 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R119 - Oscillator Trim (7) */ - { 0x0000, 0x0000, 0x0000 }, /* R120 */ - { 0x0000, 0x0000, 0x0000 }, /* R121 */ - { 0x0000, 0x0000, 0x0000 }, /* R122 */ - { 0x0000, 0x0000, 0x0000 }, /* R123 */ - { 0x0079, 0x0079, 0x0000 }, /* R124 - Analogue Clocking1 */ - { 0x00DF, 0x00DF, 0x0000 }, /* R125 - Analogue Clocking2 */ - { 0x000D, 0x000D, 0x0000 }, /* R126 - Analogue Clocking3 */ - { 0x0000, 0xFFFF, 0x0000 }, /* R127 - PLL Software Reset */ - { 0x0000, 0x0000, 0x0000 }, /* R128 */ - { 0x00B0, 0x00B0, 0x0000 }, /* R129 - PLL2 */ - { 0x0000, 0x0000, 0x0000 }, /* R130 */ - { 0x0003, 0x0003, 0x0000 }, /* R131 - PLL 4 */ - { 0x0000, 0x0000, 0x0000 }, /* R132 */ - { 0x0000, 0x0000, 0x0000 }, /* R133 */ - { 0x0000, 0x0000, 0x0000 }, /* R134 */ - { 0x0000, 0x0000, 0x0000 }, /* R135 */ - { 0x005F, 0x005F, 0x0000 }, /* R136 - PLL 9 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R137 - PLL 10 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R138 - PLL 11 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R139 - PLL 12 */ - { 0x005F, 0x005F, 0x0000 }, /* R140 - PLL 13 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R141 - PLL 14 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R142 - PLL 15 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R143 - PLL 16 */ - { 0x0000, 0x0000, 0x0000 }, /* R144 */ - { 0x0000, 0x0000, 0x0000 }, /* R145 */ - { 0x0000, 0x0000, 0x0000 }, /* R146 */ - { 0x0000, 0x0000, 0x0000 }, /* R147 */ - { 0x0000, 0x0000, 0x0000 }, /* R148 */ - { 0x0000, 0x0000, 0x0000 }, /* R149 */ - { 0x0000, 0x0000, 0x0000 }, /* R150 */ - { 0x0000, 0x0000, 0x0000 }, /* R151 */ - { 0x0000, 0x0000, 0x0000 }, /* R152 */ - { 0x0000, 0x0000, 0x0000 }, /* R153 */ - { 0x0000, 0x0000, 0x0000 }, /* R154 */ - { 0x0067, 0x0067, 0x0000 }, /* R155 - FLL Control (1) */ - { 0x01FB, 0x01FB, 0x0000 }, /* R156 - FLL Control (2) */ - { 0x0007, 0x0007, 0x0000 }, /* R157 - FLL Control (3) */ - { 0x0000, 0x0000, 0x0000 }, /* R158 */ - { 0x007F, 0x007F, 0x0000 }, /* R159 - FLL Control (5) */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R160 - FLL Control (6) */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R161 - FLL Control (7) */ - { 0x03FF, 0x03FF, 0x0000 }, /* R162 - FLL Control (8) */ - { 0x0000, 0x0000, 0x0000 }, /* R163 */ - { 0x0000, 0x0000, 0x0000 }, /* R164 */ - { 0x0000, 0x0000, 0x0000 }, /* R165 */ - { 0x0000, 0x0000, 0x0000 }, /* R166 */ - { 0x0000, 0x0000, 0x0000 }, /* R167 */ - { 0x0000, 0x0000, 0x0000 }, /* R168 */ - { 0x0000, 0x0000, 0x0000 }, /* R169 */ - { 0x0000, 0x0000, 0x0000 }, /* R170 */ - { 0x0000, 0x0000, 0x0000 }, /* R171 */ - { 0x0000, 0x0000, 0x0000 }, /* R172 */ - { 0x0000, 0x0000, 0x0000 }, /* R173 */ - { 0x0000, 0x0000, 0x0000 }, /* R174 */ - { 0x0000, 0x0000, 0x0000 }, /* R175 */ - { 0x0000, 0x0000, 0x0000 }, /* R176 */ - { 0x0000, 0x0000, 0x0000 }, /* R177 */ - { 0x0000, 0x0000, 0x0000 }, /* R178 */ - { 0x0000, 0x0000, 0x0000 }, /* R179 */ - { 0x0000, 0x0000, 0x0000 }, /* R180 */ - { 0x0000, 0x0000, 0x0000 }, /* R181 */ - { 0x0000, 0x0000, 0x0000 }, /* R182 */ - { 0x0000, 0x0000, 0x0000 }, /* R183 */ - { 0x0000, 0x0000, 0x0000 }, /* R184 */ - { 0x0000, 0x0000, 0x0000 }, /* R185 */ - { 0x0000, 0x0000, 0x0000 }, /* R186 */ - { 0x0000, 0x0000, 0x0000 }, /* R187 */ - { 0x0000, 0x0000, 0x0000 }, /* R188 */ - { 0x0000, 0x0000, 0x0000 }, /* R189 */ - { 0x0000, 0x0000, 0x0000 }, /* R190 */ - { 0x0000, 0x0000, 0x0000 }, /* R191 */ - { 0x0000, 0x0000, 0x0000 }, /* R192 */ - { 0x0000, 0x0000, 0x0000 }, /* R193 */ - { 0x0000, 0x0000, 0x0000 }, /* R194 */ - { 0x0000, 0x0000, 0x0000 }, /* R195 */ - { 0x0000, 0x0000, 0x0000 }, /* R196 */ - { 0x0000, 0x0000, 0x0000 }, /* R197 */ - { 0x0000, 0x0000, 0x0000 }, /* R198 */ - { 0x0000, 0x0000, 0x0000 }, /* R199 */ - { 0x0000, 0x0000, 0x0000 }, /* R200 */ - { 0x0000, 0x0000, 0x0000 }, /* R201 */ - { 0x0000, 0x0000, 0x0000 }, /* R202 */ - { 0x0000, 0x0000, 0x0000 }, /* R203 */ - { 0x0000, 0x0000, 0x0000 }, /* R204 */ - { 0x0000, 0x0000, 0x0000 }, /* R205 */ - { 0x0000, 0x0000, 0x0000 }, /* R206 */ - { 0x0000, 0x0000, 0x0000 }, /* R207 */ - { 0x0000, 0x0000, 0x0000 }, /* R208 */ - { 0x0000, 0x0000, 0x0000 }, /* R209 */ - { 0x0000, 0x0000, 0x0000 }, /* R210 */ - { 0x0000, 0x0000, 0x0000 }, /* R211 */ - { 0x0000, 0x0000, 0x0000 }, /* R212 */ - { 0x0000, 0x0000, 0x0000 }, /* R213 */ - { 0x0000, 0x0000, 0x0000 }, /* R214 */ - { 0x0000, 0x0000, 0x0000 }, /* R215 */ - { 0x0000, 0x0000, 0x0000 }, /* R216 */ - { 0x0000, 0x0000, 0x0000 }, /* R217 */ - { 0x0000, 0x0000, 0x0000 }, /* R218 */ - { 0x0000, 0x0000, 0x0000 }, /* R219 */ - { 0x0000, 0x0000, 0x0000 }, /* R220 */ - { 0x0000, 0x0000, 0x0000 }, /* R221 */ - { 0x0000, 0x0000, 0x0000 }, /* R222 */ - { 0x0000, 0x0000, 0x0000 }, /* R223 */ - { 0x0000, 0x0000, 0x0000 }, /* R224 */ - { 0x0000, 0x0000, 0x0000 }, /* R225 */ - { 0x0000, 0x0000, 0x0000 }, /* R226 */ - { 0x0000, 0x0000, 0x0000 }, /* R227 */ - { 0x0000, 0x0000, 0x0000 }, /* R228 */ - { 0x0000, 0x0000, 0x0000 }, /* R229 */ - { 0x0000, 0x0000, 0x0000 }, /* R230 */ - { 0x0000, 0x0000, 0x0000 }, /* R231 */ - { 0x0000, 0x0000, 0x0000 }, /* R232 */ - { 0x0000, 0x0000, 0x0000 }, /* R233 */ - { 0x0000, 0x0000, 0x0000 }, /* R234 */ - { 0x0000, 0x0000, 0x0000 }, /* R235 */ - { 0x0000, 0x0000, 0x0000 }, /* R236 */ - { 0x0000, 0x0000, 0x0000 }, /* R237 */ - { 0x0000, 0x0000, 0x0000 }, /* R238 */ - { 0x0000, 0x0000, 0x0000 }, /* R239 */ - { 0x0000, 0x0000, 0x0000 }, /* R240 */ - { 0x0000, 0x0000, 0x0000 }, /* R241 */ - { 0x0000, 0x0000, 0x0000 }, /* R242 */ - { 0x0000, 0x0000, 0x0000 }, /* R243 */ - { 0x0000, 0x0000, 0x0000 }, /* R244 */ - { 0x0000, 0x0000, 0x0000 }, /* R245 */ - { 0x0000, 0x0000, 0x0000 }, /* R246 */ - { 0x0000, 0x0000, 0x0000 }, /* R247 */ - { 0x0000, 0x0000, 0x0000 }, /* R248 */ - { 0x0000, 0x0000, 0x0000 }, /* R249 */ - { 0x0000, 0x0000, 0x0000 }, /* R250 */ - { 0x0000, 0x0000, 0x0000 }, /* R251 */ - { 0x0005, 0x0005, 0x0000 }, /* R252 - General test 1 */ - { 0x0000, 0x0000, 0x0000 }, /* R253 */ - { 0x0000, 0x0000, 0x0000 }, /* R254 */ - { 0x0000, 0x0000, 0x0000 }, /* R255 */ - { 0x000F, 0x000F, 0x0000 }, /* R256 - DF1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R257 - DF2 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R258 - DF3 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R259 - DF4 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R260 - DF5 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R261 - DF6 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R262 - DF7 */ - { 0x0000, 0x0000, 0x0000 }, /* R263 */ - { 0x0003, 0x0003, 0x0000 }, /* R264 - LHPF1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R265 - LHPF2 */ - { 0x0000, 0x0000, 0x0000 }, /* R266 */ - { 0x0000, 0x0000, 0x0000 }, /* R267 */ - { 0x0077, 0x0077, 0x0000 }, /* R268 - THREED1 */ - { 0xFFFC, 0xFFFC, 0x0000 }, /* R269 - THREED2 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R270 - THREED3 */ - { 0xFFFC, 0xFFFC, 0x0000 }, /* R271 - THREED4 */ - { 0x0000, 0x0000, 0x0000 }, /* R272 */ - { 0x0000, 0x0000, 0x0000 }, /* R273 */ - { 0x0000, 0x0000, 0x0000 }, /* R274 */ - { 0x0000, 0x0000, 0x0000 }, /* R275 */ - { 0x7FFF, 0x7FFF, 0x0000 }, /* R276 - DRC 1 */ - { 0x1FFF, 0x1FFF, 0x0000 }, /* R277 - DRC 2 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R278 - DRC 3 */ - { 0x07FF, 0x07FF, 0x0000 }, /* R279 - DRC 4 */ - { 0x03FF, 0x03FF, 0x0000 }, /* R280 - DRC 5 */ - { 0x0000, 0x0000, 0x0000 }, /* R281 */ - { 0x0000, 0x0000, 0x0000 }, /* R282 */ - { 0x0000, 0x0000, 0x0000 }, /* R283 */ - { 0x0000, 0x0000, 0x0000 }, /* R284 */ - { 0x0003, 0x0003, 0x0000 }, /* R285 - Tloopback */ - { 0x0000, 0x0000, 0x0000 }, /* R286 */ - { 0x0000, 0x0000, 0x0000 }, /* R287 */ - { 0x0000, 0x0000, 0x0000 }, /* R288 */ - { 0x0000, 0x0000, 0x0000 }, /* R289 */ - { 0x0000, 0x0000, 0x0000 }, /* R290 */ - { 0x0000, 0x0000, 0x0000 }, /* R291 */ - { 0x0000, 0x0000, 0x0000 }, /* R292 */ - { 0x0000, 0x0000, 0x0000 }, /* R293 */ - { 0x0000, 0x0000, 0x0000 }, /* R294 */ - { 0x0000, 0x0000, 0x0000 }, /* R295 */ - { 0x0000, 0x0000, 0x0000 }, /* R296 */ - { 0x0000, 0x0000, 0x0000 }, /* R297 */ - { 0x0000, 0x0000, 0x0000 }, /* R298 */ - { 0x0000, 0x0000, 0x0000 }, /* R299 */ - { 0x0000, 0x0000, 0x0000 }, /* R300 */ - { 0x0000, 0x0000, 0x0000 }, /* R301 */ - { 0x0000, 0x0000, 0x0000 }, /* R302 */ - { 0x0000, 0x0000, 0x0000 }, /* R303 */ - { 0x0000, 0x0000, 0x0000 }, /* R304 */ - { 0x0000, 0x0000, 0x0000 }, /* R305 */ - { 0x0000, 0x0000, 0x0000 }, /* R306 */ - { 0x0000, 0x0000, 0x0000 }, /* R307 */ - { 0x0000, 0x0000, 0x0000 }, /* R308 */ - { 0x0000, 0x0000, 0x0000 }, /* R309 */ - { 0x0000, 0x0000, 0x0000 }, /* R310 */ - { 0x0000, 0x0000, 0x0000 }, /* R311 */ - { 0x0000, 0x0000, 0x0000 }, /* R312 */ - { 0x0000, 0x0000, 0x0000 }, /* R313 */ - { 0x0000, 0x0000, 0x0000 }, /* R314 */ - { 0x0000, 0x0000, 0x0000 }, /* R315 */ - { 0x0000, 0x0000, 0x0000 }, /* R316 */ - { 0x0000, 0x0000, 0x0000 }, /* R317 */ - { 0x0000, 0x0000, 0x0000 }, /* R318 */ - { 0x0000, 0x0000, 0x0000 }, /* R319 */ - { 0x0000, 0x0000, 0x0000 }, /* R320 */ - { 0x0000, 0x0000, 0x0000 }, /* R321 */ - { 0x0000, 0x0000, 0x0000 }, /* R322 */ - { 0x0000, 0x0000, 0x0000 }, /* R323 */ - { 0x0000, 0x0000, 0x0000 }, /* R324 */ - { 0x0000, 0x0000, 0x0000 }, /* R325 */ - { 0x0000, 0x0000, 0x0000 }, /* R326 */ - { 0x0000, 0x0000, 0x0000 }, /* R327 */ - { 0x0000, 0x0000, 0x0000 }, /* R328 */ - { 0x0000, 0x0000, 0x0000 }, /* R329 */ - { 0x0000, 0x0000, 0x0000 }, /* R330 */ - { 0x0000, 0x0000, 0x0000 }, /* R331 */ - { 0x0000, 0x0000, 0x0000 }, /* R332 */ - { 0x0000, 0x0000, 0x0000 }, /* R333 */ - { 0x0000, 0x0000, 0x0000 }, /* R334 */ - { 0x0007, 0x0007, 0x0000 }, /* R335 - EQ1 */ - { 0xFFFE, 0xFFFE, 0x0000 }, /* R336 - EQ2 */ - { 0xFFC0, 0xFFC0, 0x0000 }, /* R337 - EQ3 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R338 - EQ4 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R339 - EQ5 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R340 - EQ6 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R341 - EQ7 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R342 - EQ8 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R343 - EQ9 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R344 - EQ10 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R345 - EQ11 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R346 - EQ12 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R347 - EQ13 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R348 - EQ14 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R349 - EQ15 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R350 - EQ16 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R351 - EQ17 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R352 - EQ18 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R353 - EQ19 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R354 - EQ20 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R355 - EQ21 */ - { 0xFFFE, 0xFFFE, 0x0000 }, /* R356 - EQ22 */ - { 0xFFC0, 0xFFC0, 0x0000 }, /* R357 - EQ23 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R358 - EQ24 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R359 - EQ25 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R360 - EQ26 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R361 - EQ27 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R362 - EQ28 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R363 - EQ29 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R364 - EQ30 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R365 - EQ31 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R366 - EQ32 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R367 - EQ33 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R368 - EQ34 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R369 - EQ35 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R370 - EQ36 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R371 - EQ37 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R372 - EQ38 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R373 - EQ39 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R374 - EQ40 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R375 - EQ41 */ - { 0x0000, 0x0000, 0x0000 }, /* R376 */ - { 0x0000, 0x0000, 0x0000 }, /* R377 */ - { 0x0000, 0x0000, 0x0000 }, /* R378 */ - { 0x0000, 0x0000, 0x0000 }, /* R379 */ - { 0x0000, 0x0000, 0x0000 }, /* R380 */ - { 0x0000, 0x0000, 0x0000 }, /* R381 */ - { 0x0000, 0x0000, 0x0000 }, /* R382 */ - { 0x0000, 0x0000, 0x0000 }, /* R383 */ - { 0x0000, 0x0000, 0x0000 }, /* R384 */ - { 0x0000, 0x0000, 0x0000 }, /* R385 */ - { 0x0000, 0x0000, 0x0000 }, /* R386 */ - { 0x0000, 0x0000, 0x0000 }, /* R387 */ - { 0x0000, 0x0000, 0x0000 }, /* R388 */ - { 0x0000, 0x0000, 0x0000 }, /* R389 */ - { 0x0000, 0x0000, 0x0000 }, /* R390 */ - { 0x0000, 0x0000, 0x0000 }, /* R391 */ - { 0x0000, 0x0000, 0x0000 }, /* R392 */ - { 0x0000, 0x0000, 0x0000 }, /* R393 */ - { 0x0000, 0x0000, 0x0000 }, /* R394 */ - { 0x0000, 0x0000, 0x0000 }, /* R395 */ - { 0x0000, 0x0000, 0x0000 }, /* R396 */ - { 0x0000, 0x0000, 0x0000 }, /* R397 */ - { 0x0000, 0x0000, 0x0000 }, /* R398 */ - { 0x0000, 0x0000, 0x0000 }, /* R399 */ - { 0x0000, 0x0000, 0x0000 }, /* R400 */ - { 0x0000, 0x0000, 0x0000 }, /* R401 */ - { 0x0000, 0x0000, 0x0000 }, /* R402 */ - { 0x0000, 0x0000, 0x0000 }, /* R403 */ - { 0x0000, 0x0000, 0x0000 }, /* R404 */ - { 0x0000, 0x0000, 0x0000 }, /* R405 */ - { 0x0000, 0x0000, 0x0000 }, /* R406 */ - { 0x0000, 0x0000, 0x0000 }, /* R407 */ - { 0x0000, 0x0000, 0x0000 }, /* R408 */ - { 0x0000, 0x0000, 0x0000 }, /* R409 */ - { 0x0000, 0x0000, 0x0000 }, /* R410 */ - { 0x0000, 0x0000, 0x0000 }, /* R411 */ - { 0x0000, 0x0000, 0x0000 }, /* R412 */ - { 0x0000, 0x0000, 0x0000 }, /* R413 */ - { 0x0000, 0x0000, 0x0000 }, /* R414 */ - { 0x0000, 0x0000, 0x0000 }, /* R415 */ - { 0x0000, 0x0000, 0x0000 }, /* R416 */ - { 0x0000, 0x0000, 0x0000 }, /* R417 */ - { 0x0000, 0x0000, 0x0000 }, /* R418 */ - { 0x0000, 0x0000, 0x0000 }, /* R419 */ - { 0x0000, 0x0000, 0x0000 }, /* R420 */ - { 0x0000, 0x0000, 0x0000 }, /* R421 */ - { 0x0000, 0x0000, 0x0000 }, /* R422 */ - { 0x0000, 0x0000, 0x0000 }, /* R423 */ - { 0x0000, 0x0000, 0x0000 }, /* R424 */ - { 0x0000, 0x0000, 0x0000 }, /* R425 */ - { 0x0000, 0x0000, 0x0000 }, /* R426 */ - { 0x0000, 0x0000, 0x0000 }, /* R427 */ - { 0x0000, 0x0000, 0x0000 }, /* R428 */ - { 0x0000, 0x0000, 0x0000 }, /* R429 */ - { 0x0000, 0x0000, 0x0000 }, /* R430 */ - { 0x0000, 0x0000, 0x0000 }, /* R431 */ - { 0x0000, 0x0000, 0x0000 }, /* R432 */ - { 0x0000, 0x0000, 0x0000 }, /* R433 */ - { 0x0000, 0x0000, 0x0000 }, /* R434 */ - { 0x0000, 0x0000, 0x0000 }, /* R435 */ - { 0x0000, 0x0000, 0x0000 }, /* R436 */ - { 0x0000, 0x0000, 0x0000 }, /* R437 */ - { 0x0000, 0x0000, 0x0000 }, /* R438 */ - { 0x0000, 0x0000, 0x0000 }, /* R439 */ - { 0x0000, 0x0000, 0x0000 }, /* R440 */ - { 0x0000, 0x0000, 0x0000 }, /* R441 */ - { 0x0000, 0x0000, 0x0000 }, /* R442 */ - { 0x0000, 0x0000, 0x0000 }, /* R443 */ - { 0x0000, 0x0000, 0x0000 }, /* R444 */ - { 0x0000, 0x0000, 0x0000 }, /* R445 */ - { 0x0000, 0x0000, 0x0000 }, /* R446 */ - { 0x0000, 0x0000, 0x0000 }, /* R447 */ - { 0x0000, 0x0000, 0x0000 }, /* R448 */ - { 0x0000, 0x0000, 0x0000 }, /* R449 */ - { 0x0000, 0x0000, 0x0000 }, /* R450 */ - { 0x0000, 0x0000, 0x0000 }, /* R451 */ - { 0x0000, 0x0000, 0x0000 }, /* R452 */ - { 0x0000, 0x0000, 0x0000 }, /* R453 */ - { 0x0000, 0x0000, 0x0000 }, /* R454 */ - { 0x0000, 0x0000, 0x0000 }, /* R455 */ - { 0x0000, 0x0000, 0x0000 }, /* R456 */ - { 0x0000, 0x0000, 0x0000 }, /* R457 */ - { 0x0000, 0x0000, 0x0000 }, /* R458 */ - { 0x0000, 0x0000, 0x0000 }, /* R459 */ - { 0x0000, 0x0000, 0x0000 }, /* R460 */ - { 0x0000, 0x0000, 0x0000 }, /* R461 */ - { 0x0000, 0x0000, 0x0000 }, /* R462 */ - { 0x0000, 0x0000, 0x0000 }, /* R463 */ - { 0x0000, 0x0000, 0x0000 }, /* R464 */ - { 0x0000, 0x0000, 0x0000 }, /* R465 */ - { 0x0000, 0x0000, 0x0000 }, /* R466 */ - { 0x0000, 0x0000, 0x0000 }, /* R467 */ - { 0x0000, 0x0000, 0x0000 }, /* R468 */ - { 0x0000, 0x0000, 0x0000 }, /* R469 */ - { 0x0000, 0x0000, 0x0000 }, /* R470 */ - { 0x0000, 0x0000, 0x0000 }, /* R471 */ - { 0x0000, 0x0000, 0x0000 }, /* R472 */ - { 0x0000, 0x0000, 0x0000 }, /* R473 */ - { 0x0000, 0x0000, 0x0000 }, /* R474 */ - { 0x0000, 0x0000, 0x0000 }, /* R475 */ - { 0x0000, 0x0000, 0x0000 }, /* R476 */ - { 0x0000, 0x0000, 0x0000 }, /* R477 */ - { 0x0000, 0x0000, 0x0000 }, /* R478 */ - { 0x0000, 0x0000, 0x0000 }, /* R479 */ - { 0x0000, 0x0000, 0x0000 }, /* R480 */ - { 0x0000, 0x0000, 0x0000 }, /* R481 */ - { 0x0000, 0x0000, 0x0000 }, /* R482 */ - { 0x0000, 0x0000, 0x0000 }, /* R483 */ - { 0x0000, 0x0000, 0x0000 }, /* R484 */ - { 0x0000, 0x0000, 0x0000 }, /* R485 */ - { 0x0000, 0x0000, 0x0000 }, /* R486 */ - { 0x0000, 0x0000, 0x0000 }, /* R487 */ - { 0x0000, 0x0000, 0x0000 }, /* R488 */ - { 0x0000, 0x0000, 0x0000 }, /* R489 */ - { 0x0000, 0x0000, 0x0000 }, /* R490 */ - { 0x0000, 0x0000, 0x0000 }, /* R491 */ - { 0x0000, 0x0000, 0x0000 }, /* R492 */ - { 0x0000, 0x0000, 0x0000 }, /* R493 */ - { 0x0000, 0x0000, 0x0000 }, /* R494 */ - { 0x0000, 0x0000, 0x0000 }, /* R495 */ - { 0x0000, 0x0000, 0x0000 }, /* R496 */ - { 0x0000, 0x0000, 0x0000 }, /* R497 */ - { 0x0000, 0x0000, 0x0000 }, /* R498 */ - { 0x0000, 0x0000, 0x0000 }, /* R499 */ - { 0x0000, 0x0000, 0x0000 }, /* R500 */ - { 0x0000, 0x0000, 0x0000 }, /* R501 */ - { 0x0000, 0x0000, 0x0000 }, /* R502 */ - { 0x0000, 0x0000, 0x0000 }, /* R503 */ - { 0x0000, 0x0000, 0x0000 }, /* R504 */ - { 0x0000, 0x0000, 0x0000 }, /* R505 */ - { 0x0000, 0x0000, 0x0000 }, /* R506 */ - { 0x0000, 0x0000, 0x0000 }, /* R507 */ - { 0x0000, 0x0000, 0x0000 }, /* R508 */ - { 0x0000, 0x0000, 0x0000 }, /* R509 */ - { 0x0000, 0x0000, 0x0000 }, /* R510 */ - { 0x0000, 0x0000, 0x0000 }, /* R511 */ - { 0x0000, 0x0000, 0x0000 }, /* R512 */ - { 0x045F, 0x045F, 0x0000 }, /* R513 - GPIO 2 */ - { 0x045F, 0x045F, 0x0000 }, /* R514 - GPIO 3 */ - { 0x0000, 0x0000, 0x0000 }, /* R515 */ - { 0xE75F, 0xE75F, 0x0000 }, /* R516 - GPIO 5 */ - { 0xE75F, 0xE75F, 0x0000 }, /* R517 - GPIO 6 */ - { 0x0000, 0x0000, 0x0000 }, /* R518 */ - { 0x0000, 0x0000, 0x0000 }, /* R519 */ - { 0x0000, 0x0000, 0x0000 }, /* R520 */ - { 0x0000, 0x0000, 0x0000 }, /* R521 */ - { 0x0000, 0x0000, 0x0000 }, /* R522 */ - { 0x0000, 0x0000, 0x0000 }, /* R523 */ - { 0x0000, 0x0000, 0x0000 }, /* R524 */ - { 0x0000, 0x0000, 0x0000 }, /* R525 */ - { 0x0000, 0x0000, 0x0000 }, /* R526 */ - { 0x0000, 0x0000, 0x0000 }, /* R527 */ - { 0x0000, 0x0000, 0x0000 }, /* R528 */ - { 0x0000, 0x0000, 0x0000 }, /* R529 */ - { 0x0000, 0x0000, 0x0000 }, /* R530 */ - { 0x0000, 0x0000, 0x0000 }, /* R531 */ - { 0x0000, 0x0000, 0x0000 }, /* R532 */ - { 0x0000, 0x0000, 0x0000 }, /* R533 */ - { 0x0000, 0x0000, 0x0000 }, /* R534 */ - { 0x0000, 0x0000, 0x0000 }, /* R535 */ - { 0x0000, 0x0000, 0x0000 }, /* R536 */ - { 0x0000, 0x0000, 0x0000 }, /* R537 */ - { 0x0000, 0x0000, 0x0000 }, /* R538 */ - { 0x0000, 0x0000, 0x0000 }, /* R539 */ - { 0x0000, 0x0000, 0x0000 }, /* R540 */ - { 0x0000, 0x0000, 0x0000 }, /* R541 */ - { 0x0000, 0x0000, 0x0000 }, /* R542 */ - { 0x0000, 0x0000, 0x0000 }, /* R543 */ - { 0x0000, 0x0000, 0x0000 }, /* R544 */ - { 0x0000, 0x0000, 0x0000 }, /* R545 */ - { 0x0000, 0x0000, 0x0000 }, /* R546 */ - { 0x0000, 0x0000, 0x0000 }, /* R547 */ - { 0x0000, 0x0000, 0x0000 }, /* R548 */ - { 0x0000, 0x0000, 0x0000 }, /* R549 */ - { 0x0000, 0x0000, 0x0000 }, /* R550 */ - { 0x0000, 0x0000, 0x0000 }, /* R551 */ - { 0x0000, 0x0000, 0x0000 }, /* R552 */ - { 0x0000, 0x0000, 0x0000 }, /* R553 */ - { 0x0000, 0x0000, 0x0000 }, /* R554 */ - { 0x0000, 0x0000, 0x0000 }, /* R555 */ - { 0x0000, 0x0000, 0x0000 }, /* R556 */ - { 0x0000, 0x0000, 0x0000 }, /* R557 */ - { 0x0000, 0x0000, 0x0000 }, /* R558 */ - { 0x0000, 0x0000, 0x0000 }, /* R559 */ - { 0x0030, 0x0030, 0xFFFF }, /* R560 - Interrupt Status 1 */ - { 0xFFED, 0xFFED, 0xFFFF }, /* R561 - Interrupt Status 2 */ - { 0x0000, 0x0000, 0x0000 }, /* R562 */ - { 0x0000, 0x0000, 0x0000 }, /* R563 */ - { 0x0000, 0x0000, 0x0000 }, /* R564 */ - { 0x0000, 0x0000, 0x0000 }, /* R565 */ - { 0x0000, 0x0000, 0x0000 }, /* R566 */ - { 0x0000, 0x0000, 0x0000 }, /* R567 */ - { 0x0030, 0x0030, 0x0000 }, /* R568 - Interrupt Status 1 Mask */ - { 0xFFED, 0xFFED, 0x0000 }, /* R569 - Interrupt Status 2 Mask */ - { 0x0000, 0x0000, 0x0000 }, /* R570 */ - { 0x0000, 0x0000, 0x0000 }, /* R571 */ - { 0x0000, 0x0000, 0x0000 }, /* R572 */ - { 0x0000, 0x0000, 0x0000 }, /* R573 */ - { 0x0000, 0x0000, 0x0000 }, /* R574 */ - { 0x0000, 0x0000, 0x0000 }, /* R575 */ - { 0x0001, 0x0001, 0x0000 }, /* R576 - Interrupt Control */ - { 0x0000, 0x0000, 0x0000 }, /* R577 */ - { 0x0000, 0x0000, 0x0000 }, /* R578 */ - { 0x0000, 0x0000, 0x0000 }, /* R579 */ - { 0x0000, 0x0000, 0x0000 }, /* R580 */ - { 0x0000, 0x0000, 0x0000 }, /* R581 */ - { 0x0000, 0x0000, 0x0000 }, /* R582 */ - { 0x0000, 0x0000, 0x0000 }, /* R583 */ - { 0x002D, 0x002D, 0x0000 }, /* R584 - IRQ Debounce */ - { 0x0000, 0x0000, 0x0000 }, /* R585 */ - { 0xC000, 0xC000, 0x0000 }, /* R586 - MICINT Source Pol */ - { 0x0000, 0x0000, 0x0000 }, /* R587 */ - { 0x0000, 0x0000, 0x0000 }, /* R588 */ - { 0x0000, 0x0000, 0x0000 }, /* R589 */ - { 0x0000, 0x0000, 0x0000 }, /* R590 */ - { 0x0000, 0x0000, 0x0000 }, /* R591 */ - { 0x0000, 0x0000, 0x0000 }, /* R592 */ - { 0x0000, 0x0000, 0x0000 }, /* R593 */ - { 0x0000, 0x0000, 0x0000 }, /* R594 */ - { 0x0000, 0x0000, 0x0000 }, /* R595 */ - { 0x0000, 0x0000, 0x0000 }, /* R596 */ - { 0x0000, 0x0000, 0x0000 }, /* R597 */ - { 0x0000, 0x0000, 0x0000 }, /* R598 */ - { 0x0000, 0x0000, 0x0000 }, /* R599 */ - { 0x0000, 0x0000, 0x0000 }, /* R600 */ - { 0x0000, 0x0000, 0x0000 }, /* R601 */ - { 0x0000, 0x0000, 0x0000 }, /* R602 */ - { 0x0000, 0x0000, 0x0000 }, /* R603 */ - { 0x0000, 0x0000, 0x0000 }, /* R604 */ - { 0x0000, 0x0000, 0x0000 }, /* R605 */ - { 0x0000, 0x0000, 0x0000 }, /* R606 */ - { 0x0000, 0x0000, 0x0000 }, /* R607 */ - { 0x0000, 0x0000, 0x0000 }, /* R608 */ - { 0x0000, 0x0000, 0x0000 }, /* R609 */ - { 0x0000, 0x0000, 0x0000 }, /* R610 */ - { 0x0000, 0x0000, 0x0000 }, /* R611 */ - { 0x0000, 0x0000, 0x0000 }, /* R612 */ - { 0x0000, 0x0000, 0x0000 }, /* R613 */ - { 0x0000, 0x0000, 0x0000 }, /* R614 */ - { 0x0000, 0x0000, 0x0000 }, /* R615 */ - { 0x0000, 0x0000, 0x0000 }, /* R616 */ - { 0x0000, 0x0000, 0x0000 }, /* R617 */ - { 0x0000, 0x0000, 0x0000 }, /* R618 */ - { 0x0000, 0x0000, 0x0000 }, /* R619 */ - { 0x0000, 0x0000, 0x0000 }, /* R620 */ - { 0x0000, 0x0000, 0x0000 }, /* R621 */ - { 0x0000, 0x0000, 0x0000 }, /* R622 */ - { 0x0000, 0x0000, 0x0000 }, /* R623 */ - { 0x0000, 0x0000, 0x0000 }, /* R624 */ - { 0x0000, 0x0000, 0x0000 }, /* R625 */ - { 0x0000, 0x0000, 0x0000 }, /* R626 */ - { 0x0000, 0x0000, 0x0000 }, /* R627 */ - { 0x0000, 0x0000, 0x0000 }, /* R628 */ - { 0x0000, 0x0000, 0x0000 }, /* R629 */ - { 0x0000, 0x0000, 0x0000 }, /* R630 */ - { 0x0000, 0x0000, 0x0000 }, /* R631 */ - { 0x0000, 0x0000, 0x0000 }, /* R632 */ - { 0x0000, 0x0000, 0x0000 }, /* R633 */ - { 0x0000, 0x0000, 0x0000 }, /* R634 */ - { 0x0000, 0x0000, 0x0000 }, /* R635 */ - { 0x0000, 0x0000, 0x0000 }, /* R636 */ - { 0x0000, 0x0000, 0x0000 }, /* R637 */ - { 0x0000, 0x0000, 0x0000 }, /* R638 */ - { 0x0000, 0x0000, 0x0000 }, /* R639 */ - { 0x0000, 0x0000, 0x0000 }, /* R640 */ - { 0x0000, 0x0000, 0x0000 }, /* R641 */ - { 0x0000, 0x0000, 0x0000 }, /* R642 */ - { 0x0000, 0x0000, 0x0000 }, /* R643 */ - { 0x0000, 0x0000, 0x0000 }, /* R644 */ - { 0x0000, 0x0000, 0x0000 }, /* R645 */ - { 0x0000, 0x0000, 0x0000 }, /* R646 */ - { 0x0000, 0x0000, 0x0000 }, /* R647 */ - { 0x0000, 0x0000, 0x0000 }, /* R648 */ - { 0x0000, 0x0000, 0x0000 }, /* R649 */ - { 0x0000, 0x0000, 0x0000 }, /* R650 */ - { 0x0000, 0x0000, 0x0000 }, /* R651 */ - { 0x0000, 0x0000, 0x0000 }, /* R652 */ - { 0x0000, 0x0000, 0x0000 }, /* R653 */ - { 0x0000, 0x0000, 0x0000 }, /* R654 */ - { 0x0000, 0x0000, 0x0000 }, /* R655 */ - { 0x0000, 0x0000, 0x0000 }, /* R656 */ - { 0x0000, 0x0000, 0x0000 }, /* R657 */ - { 0x0000, 0x0000, 0x0000 }, /* R658 */ - { 0x0000, 0x0000, 0x0000 }, /* R659 */ - { 0x0000, 0x0000, 0x0000 }, /* R660 */ - { 0x0000, 0x0000, 0x0000 }, /* R661 */ - { 0x0000, 0x0000, 0x0000 }, /* R662 */ - { 0x0000, 0x0000, 0x0000 }, /* R663 */ - { 0x0000, 0x0000, 0x0000 }, /* R664 */ - { 0x0000, 0x0000, 0x0000 }, /* R665 */ - { 0x0000, 0x0000, 0x0000 }, /* R666 */ - { 0x0000, 0x0000, 0x0000 }, /* R667 */ - { 0x0000, 0x0000, 0x0000 }, /* R668 */ - { 0x0000, 0x0000, 0x0000 }, /* R669 */ - { 0x0000, 0x0000, 0x0000 }, /* R670 */ - { 0x0000, 0x0000, 0x0000 }, /* R671 */ - { 0x0000, 0x0000, 0x0000 }, /* R672 */ - { 0x0000, 0x0000, 0x0000 }, /* R673 */ - { 0x0000, 0x0000, 0x0000 }, /* R674 */ - { 0x0000, 0x0000, 0x0000 }, /* R675 */ - { 0x0000, 0x0000, 0x0000 }, /* R676 */ - { 0x0000, 0x0000, 0x0000 }, /* R677 */ - { 0x0000, 0x0000, 0x0000 }, /* R678 */ - { 0x0000, 0x0000, 0x0000 }, /* R679 */ - { 0x0000, 0x0000, 0x0000 }, /* R680 */ - { 0x0000, 0x0000, 0x0000 }, /* R681 */ - { 0x0000, 0x0000, 0x0000 }, /* R682 */ - { 0x0000, 0x0000, 0x0000 }, /* R683 */ - { 0x0000, 0x0000, 0x0000 }, /* R684 */ - { 0x0000, 0x0000, 0x0000 }, /* R685 */ - { 0x0000, 0x0000, 0x0000 }, /* R686 */ - { 0x0000, 0x0000, 0x0000 }, /* R687 */ - { 0x0000, 0x0000, 0x0000 }, /* R688 */ - { 0x0000, 0x0000, 0x0000 }, /* R689 */ - { 0x0000, 0x0000, 0x0000 }, /* R690 */ - { 0x0000, 0x0000, 0x0000 }, /* R691 */ - { 0x0000, 0x0000, 0x0000 }, /* R692 */ - { 0x0000, 0x0000, 0x0000 }, /* R693 */ - { 0x0000, 0x0000, 0x0000 }, /* R694 */ - { 0x0000, 0x0000, 0x0000 }, /* R695 */ - { 0x0000, 0x0000, 0x0000 }, /* R696 */ - { 0x0000, 0x0000, 0x0000 }, /* R697 */ - { 0x0000, 0x0000, 0x0000 }, /* R698 */ - { 0x0000, 0x0000, 0x0000 }, /* R699 */ - { 0x0000, 0x0000, 0x0000 }, /* R700 */ - { 0x0000, 0x0000, 0x0000 }, /* R701 */ - { 0x0000, 0x0000, 0x0000 }, /* R702 */ - { 0x0000, 0x0000, 0x0000 }, /* R703 */ - { 0x0000, 0x0000, 0x0000 }, /* R704 */ - { 0x0000, 0x0000, 0x0000 }, /* R705 */ - { 0x0000, 0x0000, 0x0000 }, /* R706 */ - { 0x0000, 0x0000, 0x0000 }, /* R707 */ - { 0x0000, 0x0000, 0x0000 }, /* R708 */ - { 0x0000, 0x0000, 0x0000 }, /* R709 */ - { 0x0000, 0x0000, 0x0000 }, /* R710 */ - { 0x0000, 0x0000, 0x0000 }, /* R711 */ - { 0x0000, 0x0000, 0x0000 }, /* R712 */ - { 0x0000, 0x0000, 0x0000 }, /* R713 */ - { 0x0000, 0x0000, 0x0000 }, /* R714 */ - { 0x0000, 0x0000, 0x0000 }, /* R715 */ - { 0x0000, 0x0000, 0x0000 }, /* R716 */ - { 0x0000, 0x0000, 0x0000 }, /* R717 */ - { 0x0000, 0x0000, 0x0000 }, /* R718 */ - { 0x0000, 0x0000, 0x0000 }, /* R719 */ - { 0x0000, 0x0000, 0x0000 }, /* R720 */ - { 0x0000, 0x0000, 0x0000 }, /* R721 */ - { 0x0000, 0x0000, 0x0000 }, /* R722 */ - { 0x0000, 0x0000, 0x0000 }, /* R723 */ - { 0x0000, 0x0000, 0x0000 }, /* R724 */ - { 0x0000, 0x0000, 0x0000 }, /* R725 */ - { 0x0000, 0x0000, 0x0000 }, /* R726 */ - { 0x0000, 0x0000, 0x0000 }, /* R727 */ - { 0x0000, 0x0000, 0x0000 }, /* R728 */ - { 0x0000, 0x0000, 0x0000 }, /* R729 */ - { 0x0000, 0x0000, 0x0000 }, /* R730 */ - { 0x0000, 0x0000, 0x0000 }, /* R731 */ - { 0x0000, 0x0000, 0x0000 }, /* R732 */ - { 0x0000, 0x0000, 0x0000 }, /* R733 */ - { 0x0000, 0x0000, 0x0000 }, /* R734 */ - { 0x0000, 0x0000, 0x0000 }, /* R735 */ - { 0x0000, 0x0000, 0x0000 }, /* R736 */ - { 0x0000, 0x0000, 0x0000 }, /* R737 */ - { 0x0000, 0x0000, 0x0000 }, /* R738 */ - { 0x0000, 0x0000, 0x0000 }, /* R739 */ - { 0x0000, 0x0000, 0x0000 }, /* R740 */ - { 0x0000, 0x0000, 0x0000 }, /* R741 */ - { 0x0000, 0x0000, 0x0000 }, /* R742 */ - { 0x0000, 0x0000, 0x0000 }, /* R743 */ - { 0x0000, 0x0000, 0x0000 }, /* R744 */ - { 0x0000, 0x0000, 0x0000 }, /* R745 */ - { 0x0000, 0x0000, 0x0000 }, /* R746 */ - { 0x0000, 0x0000, 0x0000 }, /* R747 */ - { 0x0000, 0x0000, 0x0000 }, /* R748 */ - { 0x0000, 0x0000, 0x0000 }, /* R749 */ - { 0x0000, 0x0000, 0x0000 }, /* R750 */ - { 0x0000, 0x0000, 0x0000 }, /* R751 */ - { 0x0000, 0x0000, 0x0000 }, /* R752 */ - { 0x0000, 0x0000, 0x0000 }, /* R753 */ - { 0x0000, 0x0000, 0x0000 }, /* R754 */ - { 0x0000, 0x0000, 0x0000 }, /* R755 */ - { 0x0000, 0x0000, 0x0000 }, /* R756 */ - { 0x0000, 0x0000, 0x0000 }, /* R757 */ - { 0x0000, 0x0000, 0x0000 }, /* R758 */ - { 0x0000, 0x0000, 0x0000 }, /* R759 */ - { 0x0000, 0x0000, 0x0000 }, /* R760 */ - { 0x0000, 0x0000, 0x0000 }, /* R761 */ - { 0x0000, 0x0000, 0x0000 }, /* R762 */ - { 0x0000, 0x0000, 0x0000 }, /* R763 */ - { 0x0000, 0x0000, 0x0000 }, /* R764 */ - { 0x0000, 0x0000, 0x0000 }, /* R765 */ - { 0x0000, 0x0000, 0x0000 }, /* R766 */ - { 0x0000, 0x0000, 0x0000 }, /* R767 */ - { 0x0001, 0x0001, 0x0000 }, /* R768 - DSP2 Power Management */ - { 0x0000, 0x0000, 0x0000 }, /* R769 */ - { 0x0000, 0x0000, 0x0000 }, /* R770 */ - { 0x0000, 0x0000, 0x0000 }, /* R771 */ - { 0x0000, 0x0000, 0x0000 }, /* R772 */ - { 0x0000, 0x0000, 0x0000 }, /* R773 */ - { 0x0000, 0x0000, 0x0000 }, /* R774 */ - { 0x0000, 0x0000, 0x0000 }, /* R775 */ - { 0x0000, 0x0000, 0x0000 }, /* R776 */ - { 0x0000, 0x0000, 0x0000 }, /* R777 */ - { 0x0000, 0x0000, 0x0000 }, /* R778 */ - { 0x0000, 0x0000, 0x0000 }, /* R779 */ - { 0x0000, 0x0000, 0x0000 }, /* R780 */ - { 0x0000, 0x0000, 0x0000 }, /* R781 */ - { 0x0000, 0x0000, 0x0000 }, /* R782 */ - { 0x0000, 0x0000, 0x0000 }, /* R783 */ - { 0x0000, 0x0000, 0x0000 }, /* R784 */ - { 0x0000, 0x0000, 0x0000 }, /* R785 */ - { 0x0000, 0x0000, 0x0000 }, /* R786 */ - { 0x0000, 0x0000, 0x0000 }, /* R787 */ - { 0x0000, 0x0000, 0x0000 }, /* R788 */ - { 0x0000, 0x0000, 0x0000 }, /* R789 */ - { 0x0000, 0x0000, 0x0000 }, /* R790 */ - { 0x0000, 0x0000, 0x0000 }, /* R791 */ - { 0x0000, 0x0000, 0x0000 }, /* R792 */ - { 0x0000, 0x0000, 0x0000 }, /* R793 */ - { 0x0000, 0x0000, 0x0000 }, /* R794 */ - { 0x0000, 0x0000, 0x0000 }, /* R795 */ - { 0x0000, 0x0000, 0x0000 }, /* R796 */ - { 0x0000, 0x0000, 0x0000 }, /* R797 */ - { 0x0000, 0x0000, 0x0000 }, /* R798 */ - { 0x0000, 0x0000, 0x0000 }, /* R799 */ - { 0x0000, 0x0000, 0x0000 }, /* R800 */ - { 0x0000, 0x0000, 0x0000 }, /* R801 */ - { 0x0000, 0x0000, 0x0000 }, /* R802 */ - { 0x0000, 0x0000, 0x0000 }, /* R803 */ - { 0x0000, 0x0000, 0x0000 }, /* R804 */ - { 0x0000, 0x0000, 0x0000 }, /* R805 */ - { 0x0000, 0x0000, 0x0000 }, /* R806 */ - { 0x0000, 0x0000, 0x0000 }, /* R807 */ - { 0x0000, 0x0000, 0x0000 }, /* R808 */ - { 0x0000, 0x0000, 0x0000 }, /* R809 */ - { 0x0000, 0x0000, 0x0000 }, /* R810 */ - { 0x0000, 0x0000, 0x0000 }, /* R811 */ - { 0x0000, 0x0000, 0x0000 }, /* R812 */ - { 0x0000, 0x0000, 0x0000 }, /* R813 */ - { 0x0000, 0x0000, 0x0000 }, /* R814 */ - { 0x0000, 0x0000, 0x0000 }, /* R815 */ - { 0x0000, 0x0000, 0x0000 }, /* R816 */ - { 0x0000, 0x0000, 0x0000 }, /* R817 */ - { 0x0000, 0x0000, 0x0000 }, /* R818 */ - { 0x0000, 0x0000, 0x0000 }, /* R819 */ - { 0x0000, 0x0000, 0x0000 }, /* R820 */ - { 0x0000, 0x0000, 0x0000 }, /* R821 */ - { 0x0000, 0x0000, 0x0000 }, /* R822 */ - { 0x0000, 0x0000, 0x0000 }, /* R823 */ - { 0x0000, 0x0000, 0x0000 }, /* R824 */ - { 0x0000, 0x0000, 0x0000 }, /* R825 */ - { 0x0000, 0x0000, 0x0000 }, /* R826 */ - { 0x0000, 0x0000, 0x0000 }, /* R827 */ - { 0x0000, 0x0000, 0x0000 }, /* R828 */ - { 0x0000, 0x0000, 0x0000 }, /* R829 */ - { 0x0000, 0x0000, 0x0000 }, /* R830 */ - { 0x0000, 0x0000, 0x0000 }, /* R831 */ - { 0x0000, 0x0000, 0x0000 }, /* R832 */ - { 0x0000, 0x0000, 0x0000 }, /* R833 */ - { 0x0000, 0x0000, 0x0000 }, /* R834 */ - { 0x0000, 0x0000, 0x0000 }, /* R835 */ - { 0x0000, 0x0000, 0x0000 }, /* R836 */ - { 0x0000, 0x0000, 0x0000 }, /* R837 */ - { 0x0000, 0x0000, 0x0000 }, /* R838 */ - { 0x0000, 0x0000, 0x0000 }, /* R839 */ - { 0x0000, 0x0000, 0x0000 }, /* R840 */ - { 0x0000, 0x0000, 0x0000 }, /* R841 */ - { 0x0000, 0x0000, 0x0000 }, /* R842 */ - { 0x0000, 0x0000, 0x0000 }, /* R843 */ - { 0x0000, 0x0000, 0x0000 }, /* R844 */ - { 0x0000, 0x0000, 0x0000 }, /* R845 */ - { 0x0000, 0x0000, 0x0000 }, /* R846 */ - { 0x0000, 0x0000, 0x0000 }, /* R847 */ - { 0x0000, 0x0000, 0x0000 }, /* R848 */ - { 0x0000, 0x0000, 0x0000 }, /* R849 */ - { 0x0000, 0x0000, 0x0000 }, /* R850 */ - { 0x0000, 0x0000, 0x0000 }, /* R851 */ - { 0x0000, 0x0000, 0x0000 }, /* R852 */ - { 0x0000, 0x0000, 0x0000 }, /* R853 */ - { 0x0000, 0x0000, 0x0000 }, /* R854 */ - { 0x0000, 0x0000, 0x0000 }, /* R855 */ - { 0x0000, 0x0000, 0x0000 }, /* R856 */ - { 0x0000, 0x0000, 0x0000 }, /* R857 */ - { 0x0000, 0x0000, 0x0000 }, /* R858 */ - { 0x0000, 0x0000, 0x0000 }, /* R859 */ - { 0x0000, 0x0000, 0x0000 }, /* R860 */ - { 0x0000, 0x0000, 0x0000 }, /* R861 */ - { 0x0000, 0x0000, 0x0000 }, /* R862 */ - { 0x0000, 0x0000, 0x0000 }, /* R863 */ - { 0x0000, 0x0000, 0x0000 }, /* R864 */ - { 0x0000, 0x0000, 0x0000 }, /* R865 */ - { 0x0000, 0x0000, 0x0000 }, /* R866 */ - { 0x0000, 0x0000, 0x0000 }, /* R867 */ - { 0x0000, 0x0000, 0x0000 }, /* R868 */ - { 0x0000, 0x0000, 0x0000 }, /* R869 */ - { 0x0000, 0x0000, 0x0000 }, /* R870 */ - { 0x0000, 0x0000, 0x0000 }, /* R871 */ - { 0x0000, 0x0000, 0x0000 }, /* R872 */ - { 0x0000, 0x0000, 0x0000 }, /* R873 */ - { 0x0000, 0x0000, 0x0000 }, /* R874 */ - { 0x0000, 0x0000, 0x0000 }, /* R875 */ - { 0x0000, 0x0000, 0x0000 }, /* R876 */ - { 0x0000, 0x0000, 0x0000 }, /* R877 */ - { 0x0000, 0x0000, 0x0000 }, /* R878 */ - { 0x0000, 0x0000, 0x0000 }, /* R879 */ - { 0x0000, 0x0000, 0x0000 }, /* R880 */ - { 0x0000, 0x0000, 0x0000 }, /* R881 */ - { 0x0000, 0x0000, 0x0000 }, /* R882 */ - { 0x0000, 0x0000, 0x0000 }, /* R883 */ - { 0x0000, 0x0000, 0x0000 }, /* R884 */ - { 0x0000, 0x0000, 0x0000 }, /* R885 */ - { 0x0000, 0x0000, 0x0000 }, /* R886 */ - { 0x0000, 0x0000, 0x0000 }, /* R887 */ - { 0x0000, 0x0000, 0x0000 }, /* R888 */ - { 0x0000, 0x0000, 0x0000 }, /* R889 */ - { 0x0000, 0x0000, 0x0000 }, /* R890 */ - { 0x0000, 0x0000, 0x0000 }, /* R891 */ - { 0x0000, 0x0000, 0x0000 }, /* R892 */ - { 0x0000, 0x0000, 0x0000 }, /* R893 */ - { 0x0000, 0x0000, 0x0000 }, /* R894 */ - { 0x0000, 0x0000, 0x0000 }, /* R895 */ - { 0x0000, 0x0000, 0x0000 }, /* R896 */ - { 0x0000, 0x0000, 0x0000 }, /* R897 */ - { 0x0000, 0x0000, 0x0000 }, /* R898 */ - { 0x0000, 0x0000, 0x0000 }, /* R899 */ - { 0x0000, 0x0000, 0x0000 }, /* R900 */ - { 0x0000, 0x0000, 0x0000 }, /* R901 */ - { 0x0000, 0x0000, 0x0000 }, /* R902 */ - { 0x0000, 0x0000, 0x0000 }, /* R903 */ - { 0x0000, 0x0000, 0x0000 }, /* R904 */ - { 0x0000, 0x0000, 0x0000 }, /* R905 */ - { 0x0000, 0x0000, 0x0000 }, /* R906 */ - { 0x0000, 0x0000, 0x0000 }, /* R907 */ - { 0x0000, 0x0000, 0x0000 }, /* R908 */ - { 0x0000, 0x0000, 0x0000 }, /* R909 */ - { 0x0000, 0x0000, 0x0000 }, /* R910 */ - { 0x0000, 0x0000, 0x0000 }, /* R911 */ - { 0x0000, 0x0000, 0x0000 }, /* R912 */ - { 0x0000, 0x0000, 0x0000 }, /* R913 */ - { 0x0000, 0x0000, 0x0000 }, /* R914 */ - { 0x0000, 0x0000, 0x0000 }, /* R915 */ - { 0x0000, 0x0000, 0x0000 }, /* R916 */ - { 0x0000, 0x0000, 0x0000 }, /* R917 */ - { 0x0000, 0x0000, 0x0000 }, /* R918 */ - { 0x0000, 0x0000, 0x0000 }, /* R919 */ - { 0x0000, 0x0000, 0x0000 }, /* R920 */ - { 0x0000, 0x0000, 0x0000 }, /* R921 */ - { 0x0000, 0x0000, 0x0000 }, /* R922 */ - { 0x0000, 0x0000, 0x0000 }, /* R923 */ - { 0x0000, 0x0000, 0x0000 }, /* R924 */ - { 0x0000, 0x0000, 0x0000 }, /* R925 */ - { 0x0000, 0x0000, 0x0000 }, /* R926 */ - { 0x0000, 0x0000, 0x0000 }, /* R927 */ - { 0x0000, 0x0000, 0x0000 }, /* R928 */ - { 0x0000, 0x0000, 0x0000 }, /* R929 */ - { 0x0000, 0x0000, 0x0000 }, /* R930 */ - { 0x0000, 0x0000, 0x0000 }, /* R931 */ - { 0x0000, 0x0000, 0x0000 }, /* R932 */ - { 0x0000, 0x0000, 0x0000 }, /* R933 */ - { 0x0000, 0x0000, 0x0000 }, /* R934 */ - { 0x0000, 0x0000, 0x0000 }, /* R935 */ - { 0x0000, 0x0000, 0x0000 }, /* R936 */ - { 0x0000, 0x0000, 0x0000 }, /* R937 */ - { 0x0000, 0x0000, 0x0000 }, /* R938 */ - { 0x0000, 0x0000, 0x0000 }, /* R939 */ - { 0x0000, 0x0000, 0x0000 }, /* R940 */ - { 0x0000, 0x0000, 0x0000 }, /* R941 */ - { 0x0000, 0x0000, 0x0000 }, /* R942 */ - { 0x0000, 0x0000, 0x0000 }, /* R943 */ - { 0x0000, 0x0000, 0x0000 }, /* R944 */ - { 0x0000, 0x0000, 0x0000 }, /* R945 */ - { 0x0000, 0x0000, 0x0000 }, /* R946 */ - { 0x0000, 0x0000, 0x0000 }, /* R947 */ - { 0x0000, 0x0000, 0x0000 }, /* R948 */ - { 0x0000, 0x0000, 0x0000 }, /* R949 */ - { 0x0000, 0x0000, 0x0000 }, /* R950 */ - { 0x0000, 0x0000, 0x0000 }, /* R951 */ - { 0x0000, 0x0000, 0x0000 }, /* R952 */ - { 0x0000, 0x0000, 0x0000 }, /* R953 */ - { 0x0000, 0x0000, 0x0000 }, /* R954 */ - { 0x0000, 0x0000, 0x0000 }, /* R955 */ - { 0x0000, 0x0000, 0x0000 }, /* R956 */ - { 0x0000, 0x0000, 0x0000 }, /* R957 */ - { 0x0000, 0x0000, 0x0000 }, /* R958 */ - { 0x0000, 0x0000, 0x0000 }, /* R959 */ - { 0x0000, 0x0000, 0x0000 }, /* R960 */ - { 0x0000, 0x0000, 0x0000 }, /* R961 */ - { 0x0000, 0x0000, 0x0000 }, /* R962 */ - { 0x0000, 0x0000, 0x0000 }, /* R963 */ - { 0x0000, 0x0000, 0x0000 }, /* R964 */ - { 0x0000, 0x0000, 0x0000 }, /* R965 */ - { 0x0000, 0x0000, 0x0000 }, /* R966 */ - { 0x0000, 0x0000, 0x0000 }, /* R967 */ - { 0x0000, 0x0000, 0x0000 }, /* R968 */ - { 0x0000, 0x0000, 0x0000 }, /* R969 */ - { 0x0000, 0x0000, 0x0000 }, /* R970 */ - { 0x0000, 0x0000, 0x0000 }, /* R971 */ - { 0x0000, 0x0000, 0x0000 }, /* R972 */ - { 0x0000, 0x0000, 0x0000 }, /* R973 */ - { 0x0000, 0x0000, 0x0000 }, /* R974 */ - { 0x0000, 0x0000, 0x0000 }, /* R975 */ - { 0x0000, 0x0000, 0x0000 }, /* R976 */ - { 0x0000, 0x0000, 0x0000 }, /* R977 */ - { 0x0000, 0x0000, 0x0000 }, /* R978 */ - { 0x0000, 0x0000, 0x0000 }, /* R979 */ - { 0x0000, 0x0000, 0x0000 }, /* R980 */ - { 0x0000, 0x0000, 0x0000 }, /* R981 */ - { 0x0000, 0x0000, 0x0000 }, /* R982 */ - { 0x0000, 0x0000, 0x0000 }, /* R983 */ - { 0x0000, 0x0000, 0x0000 }, /* R984 */ - { 0x0000, 0x0000, 0x0000 }, /* R985 */ - { 0x0000, 0x0000, 0x0000 }, /* R986 */ - { 0x0000, 0x0000, 0x0000 }, /* R987 */ - { 0x0000, 0x0000, 0x0000 }, /* R988 */ - { 0x0000, 0x0000, 0x0000 }, /* R989 */ - { 0x0000, 0x0000, 0x0000 }, /* R990 */ - { 0x0000, 0x0000, 0x0000 }, /* R991 */ - { 0x0000, 0x0000, 0x0000 }, /* R992 */ - { 0x0000, 0x0000, 0x0000 }, /* R993 */ - { 0x0000, 0x0000, 0x0000 }, /* R994 */ - { 0x0000, 0x0000, 0x0000 }, /* R995 */ - { 0x0000, 0x0000, 0x0000 }, /* R996 */ - { 0x0000, 0x0000, 0x0000 }, /* R997 */ - { 0x0000, 0x0000, 0x0000 }, /* R998 */ - { 0x0000, 0x0000, 0x0000 }, /* R999 */ - { 0x0000, 0x0000, 0x0000 }, /* R1000 */ - { 0x0000, 0x0000, 0x0000 }, /* R1001 */ - { 0x0000, 0x0000, 0x0000 }, /* R1002 */ - { 0x0000, 0x0000, 0x0000 }, /* R1003 */ - { 0x0000, 0x0000, 0x0000 }, /* R1004 */ - { 0x0000, 0x0000, 0x0000 }, /* R1005 */ - { 0x0000, 0x0000, 0x0000 }, /* R1006 */ - { 0x0000, 0x0000, 0x0000 }, /* R1007 */ - { 0x0000, 0x0000, 0x0000 }, /* R1008 */ - { 0x0000, 0x0000, 0x0000 }, /* R1009 */ - { 0x0000, 0x0000, 0x0000 }, /* R1010 */ - { 0x0000, 0x0000, 0x0000 }, /* R1011 */ - { 0x0000, 0x0000, 0x0000 }, /* R1012 */ - { 0x0000, 0x0000, 0x0000 }, /* R1013 */ - { 0x0000, 0x0000, 0x0000 }, /* R1014 */ - { 0x0000, 0x0000, 0x0000 }, /* R1015 */ - { 0x0000, 0x0000, 0x0000 }, /* R1016 */ - { 0x0000, 0x0000, 0x0000 }, /* R1017 */ - { 0x0000, 0x0000, 0x0000 }, /* R1018 */ - { 0x0000, 0x0000, 0x0000 }, /* R1019 */ - { 0x0000, 0x0000, 0x0000 }, /* R1020 */ - { 0x0000, 0x0000, 0x0000 }, /* R1021 */ - { 0x0000, 0x0000, 0x0000 }, /* R1022 */ - { 0x0000, 0x0000, 0x0000 }, /* R1023 */ - { 0x0000, 0x0000, 0x0000 }, /* R1024 */ - { 0x0000, 0x0000, 0x0000 }, /* R1025 */ - { 0x0000, 0x0000, 0x0000 }, /* R1026 */ - { 0x0000, 0x0000, 0x0000 }, /* R1027 */ - { 0x0000, 0x0000, 0x0000 }, /* R1028 */ - { 0x0000, 0x0000, 0x0000 }, /* R1029 */ - { 0x0000, 0x0000, 0x0000 }, /* R1030 */ - { 0x0000, 0x0000, 0x0000 }, /* R1031 */ - { 0x0000, 0x0000, 0x0000 }, /* R1032 */ - { 0x0000, 0x0000, 0x0000 }, /* R1033 */ - { 0x0000, 0x0000, 0x0000 }, /* R1034 */ - { 0x0000, 0x0000, 0x0000 }, /* R1035 */ - { 0x0000, 0x0000, 0x0000 }, /* R1036 */ - { 0x0000, 0x003F, 0x0000 }, /* R1037 - DSP2_ExecControl */ - { 0x0000, 0x0000, 0x0000 }, /* R1038 */ - { 0x0000, 0x0000, 0x0000 }, /* R1039 */ - { 0x0000, 0x0000, 0x0000 }, /* R1040 */ - { 0x0000, 0x0000, 0x0000 }, /* R1041 */ - { 0x0000, 0x0000, 0x0000 }, /* R1042 */ - { 0x0000, 0x0000, 0x0000 }, /* R1043 */ - { 0x0000, 0x0000, 0x0000 }, /* R1044 */ - { 0x0000, 0x0000, 0x0000 }, /* R1045 */ - { 0x0000, 0x0000, 0x0000 }, /* R1046 */ - { 0x0000, 0x0000, 0x0000 }, /* R1047 */ - { 0x0000, 0x0000, 0x0000 }, /* R1048 */ - { 0x0000, 0x0000, 0x0000 }, /* R1049 */ - { 0x0000, 0x0000, 0x0000 }, /* R1050 */ - { 0x0000, 0x0000, 0x0000 }, /* R1051 */ - { 0x0000, 0x0000, 0x0000 }, /* R1052 */ - { 0x0000, 0x0000, 0x0000 }, /* R1053 */ - { 0x0000, 0x0000, 0x0000 }, /* R1054 */ - { 0x0000, 0x0000, 0x0000 }, /* R1055 */ - { 0x0000, 0x0000, 0x0000 }, /* R1056 */ - { 0x0000, 0x0000, 0x0000 }, /* R1057 */ - { 0x0000, 0x0000, 0x0000 }, /* R1058 */ - { 0x0000, 0x0000, 0x0000 }, /* R1059 */ - { 0x0000, 0x0000, 0x0000 }, /* R1060 */ - { 0x0000, 0x0000, 0x0000 }, /* R1061 */ - { 0x0000, 0x0000, 0x0000 }, /* R1062 */ - { 0x0000, 0x0000, 0x0000 }, /* R1063 */ - { 0x0000, 0x0000, 0x0000 }, /* R1064 */ - { 0x0000, 0x0000, 0x0000 }, /* R1065 */ - { 0x0000, 0x0000, 0x0000 }, /* R1066 */ - { 0x0000, 0x0000, 0x0000 }, /* R1067 */ - { 0x0000, 0x0000, 0x0000 }, /* R1068 */ - { 0x0000, 0x0000, 0x0000 }, /* R1069 */ - { 0x0000, 0x0000, 0x0000 }, /* R1070 */ - { 0x0000, 0x0000, 0x0000 }, /* R1071 */ - { 0x0000, 0x0000, 0x0000 }, /* R1072 */ - { 0x0000, 0x0000, 0x0000 }, /* R1073 */ - { 0x0000, 0x0000, 0x0000 }, /* R1074 */ - { 0x0000, 0x0000, 0x0000 }, /* R1075 */ - { 0x0000, 0x0000, 0x0000 }, /* R1076 */ - { 0x0000, 0x0000, 0x0000 }, /* R1077 */ - { 0x0000, 0x0000, 0x0000 }, /* R1078 */ - { 0x0000, 0x0000, 0x0000 }, /* R1079 */ - { 0x0000, 0x0000, 0x0000 }, /* R1080 */ - { 0x0000, 0x0000, 0x0000 }, /* R1081 */ - { 0x0000, 0x0000, 0x0000 }, /* R1082 */ - { 0x0000, 0x0000, 0x0000 }, /* R1083 */ - { 0x0000, 0x0000, 0x0000 }, /* R1084 */ - { 0x0000, 0x0000, 0x0000 }, /* R1085 */ - { 0x0000, 0x0000, 0x0000 }, /* R1086 */ - { 0x0000, 0x0000, 0x0000 }, /* R1087 */ - { 0x0000, 0x0000, 0x0000 }, /* R1088 */ - { 0x0000, 0x0000, 0x0000 }, /* R1089 */ - { 0x0000, 0x0000, 0x0000 }, /* R1090 */ - { 0x0000, 0x0000, 0x0000 }, /* R1091 */ - { 0x0000, 0x0000, 0x0000 }, /* R1092 */ - { 0x0000, 0x0000, 0x0000 }, /* R1093 */ - { 0x0000, 0x0000, 0x0000 }, /* R1094 */ - { 0x0000, 0x0000, 0x0000 }, /* R1095 */ - { 0x0000, 0x0000, 0x0000 }, /* R1096 */ - { 0x0000, 0x0000, 0x0000 }, /* R1097 */ - { 0x0000, 0x0000, 0x0000 }, /* R1098 */ - { 0x0000, 0x0000, 0x0000 }, /* R1099 */ - { 0x0000, 0x0000, 0x0000 }, /* R1100 */ - { 0x0000, 0x0000, 0x0000 }, /* R1101 */ - { 0x0000, 0x0000, 0x0000 }, /* R1102 */ - { 0x0000, 0x0000, 0x0000 }, /* R1103 */ - { 0x0000, 0x0000, 0x0000 }, /* R1104 */ - { 0x0000, 0x0000, 0x0000 }, /* R1105 */ - { 0x0000, 0x0000, 0x0000 }, /* R1106 */ - { 0x0000, 0x0000, 0x0000 }, /* R1107 */ - { 0x0000, 0x0000, 0x0000 }, /* R1108 */ - { 0x0000, 0x0000, 0x0000 }, /* R1109 */ - { 0x0000, 0x0000, 0x0000 }, /* R1110 */ - { 0x0000, 0x0000, 0x0000 }, /* R1111 */ - { 0x0000, 0x0000, 0x0000 }, /* R1112 */ - { 0x0000, 0x0000, 0x0000 }, /* R1113 */ - { 0x0000, 0x0000, 0x0000 }, /* R1114 */ - { 0x0000, 0x0000, 0x0000 }, /* R1115 */ - { 0x0000, 0x0000, 0x0000 }, /* R1116 */ - { 0x0000, 0x0000, 0x0000 }, /* R1117 */ - { 0x0000, 0x0000, 0x0000 }, /* R1118 */ - { 0x0000, 0x0000, 0x0000 }, /* R1119 */ - { 0x0000, 0x0000, 0x0000 }, /* R1120 */ - { 0x0000, 0x0000, 0x0000 }, /* R1121 */ - { 0x0000, 0x0000, 0x0000 }, /* R1122 */ - { 0x0000, 0x0000, 0x0000 }, /* R1123 */ - { 0x0000, 0x0000, 0x0000 }, /* R1124 */ - { 0x0000, 0x0000, 0x0000 }, /* R1125 */ - { 0x0000, 0x0000, 0x0000 }, /* R1126 */ - { 0x0000, 0x0000, 0x0000 }, /* R1127 */ - { 0x0000, 0x0000, 0x0000 }, /* R1128 */ - { 0x0000, 0x0000, 0x0000 }, /* R1129 */ - { 0x0000, 0x0000, 0x0000 }, /* R1130 */ - { 0x0000, 0x0000, 0x0000 }, /* R1131 */ - { 0x0000, 0x0000, 0x0000 }, /* R1132 */ - { 0x0000, 0x0000, 0x0000 }, /* R1133 */ - { 0x0000, 0x0000, 0x0000 }, /* R1134 */ - { 0x0000, 0x0000, 0x0000 }, /* R1135 */ - { 0x0000, 0x0000, 0x0000 }, /* R1136 */ - { 0x0000, 0x0000, 0x0000 }, /* R1137 */ - { 0x0000, 0x0000, 0x0000 }, /* R1138 */ - { 0x0000, 0x0000, 0x0000 }, /* R1139 */ - { 0x0000, 0x0000, 0x0000 }, /* R1140 */ - { 0x0000, 0x0000, 0x0000 }, /* R1141 */ - { 0x0000, 0x0000, 0x0000 }, /* R1142 */ - { 0x0000, 0x0000, 0x0000 }, /* R1143 */ - { 0x0000, 0x0000, 0x0000 }, /* R1144 */ - { 0x0000, 0x0000, 0x0000 }, /* R1145 */ - { 0x0000, 0x0000, 0x0000 }, /* R1146 */ - { 0x0000, 0x0000, 0x0000 }, /* R1147 */ - { 0x0000, 0x0000, 0x0000 }, /* R1148 */ - { 0x0000, 0x0000, 0x0000 }, /* R1149 */ - { 0x0000, 0x0000, 0x0000 }, /* R1150 */ - { 0x0000, 0x0000, 0x0000 }, /* R1151 */ - { 0x0000, 0x0000, 0x0000 }, /* R1152 */ - { 0x0000, 0x0000, 0x0000 }, /* R1153 */ - { 0x0000, 0x0000, 0x0000 }, /* R1154 */ - { 0x0000, 0x0000, 0x0000 }, /* R1155 */ - { 0x0000, 0x0000, 0x0000 }, /* R1156 */ - { 0x0000, 0x0000, 0x0000 }, /* R1157 */ - { 0x0000, 0x0000, 0x0000 }, /* R1158 */ - { 0x0000, 0x0000, 0x0000 }, /* R1159 */ - { 0x0000, 0x0000, 0x0000 }, /* R1160 */ - { 0x0000, 0x0000, 0x0000 }, /* R1161 */ - { 0x0000, 0x0000, 0x0000 }, /* R1162 */ - { 0x0000, 0x0000, 0x0000 }, /* R1163 */ - { 0x0000, 0x0000, 0x0000 }, /* R1164 */ - { 0x0000, 0x0000, 0x0000 }, /* R1165 */ - { 0x0000, 0x0000, 0x0000 }, /* R1166 */ - { 0x0000, 0x0000, 0x0000 }, /* R1167 */ - { 0x0000, 0x0000, 0x0000 }, /* R1168 */ - { 0x0000, 0x0000, 0x0000 }, /* R1169 */ - { 0x0000, 0x0000, 0x0000 }, /* R1170 */ - { 0x0000, 0x0000, 0x0000 }, /* R1171 */ - { 0x0000, 0x0000, 0x0000 }, /* R1172 */ - { 0x0000, 0x0000, 0x0000 }, /* R1173 */ - { 0x0000, 0x0000, 0x0000 }, /* R1174 */ - { 0x0000, 0x0000, 0x0000 }, /* R1175 */ - { 0x0000, 0x0000, 0x0000 }, /* R1176 */ - { 0x0000, 0x0000, 0x0000 }, /* R1177 */ - { 0x0000, 0x0000, 0x0000 }, /* R1178 */ - { 0x0000, 0x0000, 0x0000 }, /* R1179 */ - { 0x0000, 0x0000, 0x0000 }, /* R1180 */ - { 0x0000, 0x0000, 0x0000 }, /* R1181 */ - { 0x0000, 0x0000, 0x0000 }, /* R1182 */ - { 0x0000, 0x0000, 0x0000 }, /* R1183 */ - { 0x0000, 0x0000, 0x0000 }, /* R1184 */ - { 0x0000, 0x0000, 0x0000 }, /* R1185 */ - { 0x0000, 0x0000, 0x0000 }, /* R1186 */ - { 0x0000, 0x0000, 0x0000 }, /* R1187 */ - { 0x0000, 0x0000, 0x0000 }, /* R1188 */ - { 0x0000, 0x0000, 0x0000 }, /* R1189 */ - { 0x0000, 0x0000, 0x0000 }, /* R1190 */ - { 0x0000, 0x0000, 0x0000 }, /* R1191 */ - { 0x0000, 0x0000, 0x0000 }, /* R1192 */ - { 0x0000, 0x0000, 0x0000 }, /* R1193 */ - { 0x0000, 0x0000, 0x0000 }, /* R1194 */ - { 0x0000, 0x0000, 0x0000 }, /* R1195 */ - { 0x0000, 0x0000, 0x0000 }, /* R1196 */ - { 0x0000, 0x0000, 0x0000 }, /* R1197 */ - { 0x0000, 0x0000, 0x0000 }, /* R1198 */ - { 0x0000, 0x0000, 0x0000 }, /* R1199 */ - { 0x0000, 0x0000, 0x0000 }, /* R1200 */ - { 0x0000, 0x0000, 0x0000 }, /* R1201 */ - { 0x0000, 0x0000, 0x0000 }, /* R1202 */ - { 0x0000, 0x0000, 0x0000 }, /* R1203 */ - { 0x0000, 0x0000, 0x0000 }, /* R1204 */ - { 0x0000, 0x0000, 0x0000 }, /* R1205 */ - { 0x0000, 0x0000, 0x0000 }, /* R1206 */ - { 0x0000, 0x0000, 0x0000 }, /* R1207 */ - { 0x0000, 0x0000, 0x0000 }, /* R1208 */ - { 0x0000, 0x0000, 0x0000 }, /* R1209 */ - { 0x0000, 0x0000, 0x0000 }, /* R1210 */ - { 0x0000, 0x0000, 0x0000 }, /* R1211 */ - { 0x0000, 0x0000, 0x0000 }, /* R1212 */ - { 0x0000, 0x0000, 0x0000 }, /* R1213 */ - { 0x0000, 0x0000, 0x0000 }, /* R1214 */ - { 0x0000, 0x0000, 0x0000 }, /* R1215 */ - { 0x0000, 0x0000, 0x0000 }, /* R1216 */ - { 0x0000, 0x0000, 0x0000 }, /* R1217 */ - { 0x0000, 0x0000, 0x0000 }, /* R1218 */ - { 0x0000, 0x0000, 0x0000 }, /* R1219 */ - { 0x0000, 0x0000, 0x0000 }, /* R1220 */ - { 0x0000, 0x0000, 0x0000 }, /* R1221 */ - { 0x0000, 0x0000, 0x0000 }, /* R1222 */ - { 0x0000, 0x0000, 0x0000 }, /* R1223 */ - { 0x0000, 0x0000, 0x0000 }, /* R1224 */ - { 0x0000, 0x0000, 0x0000 }, /* R1225 */ - { 0x0000, 0x0000, 0x0000 }, /* R1226 */ - { 0x0000, 0x0000, 0x0000 }, /* R1227 */ - { 0x0000, 0x0000, 0x0000 }, /* R1228 */ - { 0x0000, 0x0000, 0x0000 }, /* R1229 */ - { 0x0000, 0x0000, 0x0000 }, /* R1230 */ - { 0x0000, 0x0000, 0x0000 }, /* R1231 */ - { 0x0000, 0x0000, 0x0000 }, /* R1232 */ - { 0x0000, 0x0000, 0x0000 }, /* R1233 */ - { 0x0000, 0x0000, 0x0000 }, /* R1234 */ - { 0x0000, 0x0000, 0x0000 }, /* R1235 */ - { 0x0000, 0x0000, 0x0000 }, /* R1236 */ - { 0x0000, 0x0000, 0x0000 }, /* R1237 */ - { 0x0000, 0x0000, 0x0000 }, /* R1238 */ - { 0x0000, 0x0000, 0x0000 }, /* R1239 */ - { 0x0000, 0x0000, 0x0000 }, /* R1240 */ - { 0x0000, 0x0000, 0x0000 }, /* R1241 */ - { 0x0000, 0x0000, 0x0000 }, /* R1242 */ - { 0x0000, 0x0000, 0x0000 }, /* R1243 */ - { 0x0000, 0x0000, 0x0000 }, /* R1244 */ - { 0x0000, 0x0000, 0x0000 }, /* R1245 */ - { 0x0000, 0x0000, 0x0000 }, /* R1246 */ - { 0x0000, 0x0000, 0x0000 }, /* R1247 */ - { 0x0000, 0x0000, 0x0000 }, /* R1248 */ - { 0x0000, 0x0000, 0x0000 }, /* R1249 */ - { 0x0000, 0x0000, 0x0000 }, /* R1250 */ - { 0x0000, 0x0000, 0x0000 }, /* R1251 */ - { 0x0000, 0x0000, 0x0000 }, /* R1252 */ - { 0x0000, 0x0000, 0x0000 }, /* R1253 */ - { 0x0000, 0x0000, 0x0000 }, /* R1254 */ - { 0x0000, 0x0000, 0x0000 }, /* R1255 */ - { 0x0000, 0x0000, 0x0000 }, /* R1256 */ - { 0x0000, 0x0000, 0x0000 }, /* R1257 */ - { 0x0000, 0x0000, 0x0000 }, /* R1258 */ - { 0x0000, 0x0000, 0x0000 }, /* R1259 */ - { 0x0000, 0x0000, 0x0000 }, /* R1260 */ - { 0x0000, 0x0000, 0x0000 }, /* R1261 */ - { 0x0000, 0x0000, 0x0000 }, /* R1262 */ - { 0x0000, 0x0000, 0x0000 }, /* R1263 */ - { 0x0000, 0x0000, 0x0000 }, /* R1264 */ - { 0x0000, 0x0000, 0x0000 }, /* R1265 */ - { 0x0000, 0x0000, 0x0000 }, /* R1266 */ - { 0x0000, 0x0000, 0x0000 }, /* R1267 */ - { 0x0000, 0x0000, 0x0000 }, /* R1268 */ - { 0x0000, 0x0000, 0x0000 }, /* R1269 */ - { 0x0000, 0x0000, 0x0000 }, /* R1270 */ - { 0x0000, 0x0000, 0x0000 }, /* R1271 */ - { 0x0000, 0x0000, 0x0000 }, /* R1272 */ - { 0x0000, 0x0000, 0x0000 }, /* R1273 */ - { 0x0000, 0x0000, 0x0000 }, /* R1274 */ - { 0x0000, 0x0000, 0x0000 }, /* R1275 */ - { 0x0000, 0x0000, 0x0000 }, /* R1276 */ - { 0x0000, 0x0000, 0x0000 }, /* R1277 */ - { 0x0000, 0x0000, 0x0000 }, /* R1278 */ - { 0x0000, 0x0000, 0x0000 }, /* R1279 */ - { 0x0000, 0x0000, 0x0000 }, /* R1280 */ - { 0x0000, 0x0000, 0x0000 }, /* R1281 */ - { 0x0000, 0x0000, 0x0000 }, /* R1282 */ - { 0x0000, 0x0000, 0x0000 }, /* R1283 */ - { 0x0000, 0x0000, 0x0000 }, /* R1284 */ - { 0x0000, 0x0000, 0x0000 }, /* R1285 */ - { 0x0000, 0x0000, 0x0000 }, /* R1286 */ - { 0x0000, 0x0000, 0x0000 }, /* R1287 */ - { 0x0000, 0x0000, 0x0000 }, /* R1288 */ - { 0x0000, 0x0000, 0x0000 }, /* R1289 */ - { 0x0000, 0x0000, 0x0000 }, /* R1290 */ - { 0x0000, 0x0000, 0x0000 }, /* R1291 */ - { 0x0000, 0x0000, 0x0000 }, /* R1292 */ - { 0x0000, 0x0000, 0x0000 }, /* R1293 */ - { 0x0000, 0x0000, 0x0000 }, /* R1294 */ - { 0x0000, 0x0000, 0x0000 }, /* R1295 */ - { 0x0000, 0x0000, 0x0000 }, /* R1296 */ - { 0x0000, 0x0000, 0x0000 }, /* R1297 */ - { 0x0000, 0x0000, 0x0000 }, /* R1298 */ - { 0x0000, 0x0000, 0x0000 }, /* R1299 */ - { 0x0000, 0x0000, 0x0000 }, /* R1300 */ - { 0x0000, 0x0000, 0x0000 }, /* R1301 */ - { 0x0000, 0x0000, 0x0000 }, /* R1302 */ - { 0x0000, 0x0000, 0x0000 }, /* R1303 */ - { 0x0000, 0x0000, 0x0000 }, /* R1304 */ - { 0x0000, 0x0000, 0x0000 }, /* R1305 */ - { 0x0000, 0x0000, 0x0000 }, /* R1306 */ - { 0x0000, 0x0000, 0x0000 }, /* R1307 */ - { 0x0000, 0x0000, 0x0000 }, /* R1308 */ - { 0x0000, 0x0000, 0x0000 }, /* R1309 */ - { 0x0000, 0x0000, 0x0000 }, /* R1310 */ - { 0x0000, 0x0000, 0x0000 }, /* R1311 */ - { 0x0000, 0x0000, 0x0000 }, /* R1312 */ - { 0x0000, 0x0000, 0x0000 }, /* R1313 */ - { 0x0000, 0x0000, 0x0000 }, /* R1314 */ - { 0x0000, 0x0000, 0x0000 }, /* R1315 */ - { 0x0000, 0x0000, 0x0000 }, /* R1316 */ - { 0x0000, 0x0000, 0x0000 }, /* R1317 */ - { 0x0000, 0x0000, 0x0000 }, /* R1318 */ - { 0x0000, 0x0000, 0x0000 }, /* R1319 */ - { 0x0000, 0x0000, 0x0000 }, /* R1320 */ - { 0x0000, 0x0000, 0x0000 }, /* R1321 */ - { 0x0000, 0x0000, 0x0000 }, /* R1322 */ - { 0x0000, 0x0000, 0x0000 }, /* R1323 */ - { 0x0000, 0x0000, 0x0000 }, /* R1324 */ - { 0x0000, 0x0000, 0x0000 }, /* R1325 */ - { 0x0000, 0x0000, 0x0000 }, /* R1326 */ - { 0x0000, 0x0000, 0x0000 }, /* R1327 */ - { 0x0000, 0x0000, 0x0000 }, /* R1328 */ - { 0x0000, 0x0000, 0x0000 }, /* R1329 */ - { 0x0000, 0x0000, 0x0000 }, /* R1330 */ - { 0x0000, 0x0000, 0x0000 }, /* R1331 */ - { 0x0000, 0x0000, 0x0000 }, /* R1332 */ - { 0x0000, 0x0000, 0x0000 }, /* R1333 */ - { 0x0000, 0x0000, 0x0000 }, /* R1334 */ - { 0x0000, 0x0000, 0x0000 }, /* R1335 */ - { 0x0000, 0x0000, 0x0000 }, /* R1336 */ - { 0x0000, 0x0000, 0x0000 }, /* R1337 */ - { 0x0000, 0x0000, 0x0000 }, /* R1338 */ - { 0x0000, 0x0000, 0x0000 }, /* R1339 */ - { 0x0000, 0x0000, 0x0000 }, /* R1340 */ - { 0x0000, 0x0000, 0x0000 }, /* R1341 */ - { 0x0000, 0x0000, 0x0000 }, /* R1342 */ - { 0x0000, 0x0000, 0x0000 }, /* R1343 */ - { 0x0000, 0x0000, 0x0000 }, /* R1344 */ - { 0x0000, 0x0000, 0x0000 }, /* R1345 */ - { 0x0000, 0x0000, 0x0000 }, /* R1346 */ - { 0x0000, 0x0000, 0x0000 }, /* R1347 */ - { 0x0000, 0x0000, 0x0000 }, /* R1348 */ - { 0x0000, 0x0000, 0x0000 }, /* R1349 */ - { 0x0000, 0x0000, 0x0000 }, /* R1350 */ - { 0x0000, 0x0000, 0x0000 }, /* R1351 */ - { 0x0000, 0x0000, 0x0000 }, /* R1352 */ - { 0x0000, 0x0000, 0x0000 }, /* R1353 */ - { 0x0000, 0x0000, 0x0000 }, /* R1354 */ - { 0x0000, 0x0000, 0x0000 }, /* R1355 */ - { 0x0000, 0x0000, 0x0000 }, /* R1356 */ - { 0x0000, 0x0000, 0x0000 }, /* R1357 */ - { 0x0000, 0x0000, 0x0000 }, /* R1358 */ - { 0x0000, 0x0000, 0x0000 }, /* R1359 */ - { 0x0000, 0x0000, 0x0000 }, /* R1360 */ - { 0x0000, 0x0000, 0x0000 }, /* R1361 */ - { 0x0000, 0x0000, 0x0000 }, /* R1362 */ - { 0x0000, 0x0000, 0x0000 }, /* R1363 */ - { 0x0000, 0x0000, 0x0000 }, /* R1364 */ - { 0x0000, 0x0000, 0x0000 }, /* R1365 */ - { 0x0000, 0x0000, 0x0000 }, /* R1366 */ - { 0x0000, 0x0000, 0x0000 }, /* R1367 */ - { 0x0000, 0x0000, 0x0000 }, /* R1368 */ - { 0x0000, 0x0000, 0x0000 }, /* R1369 */ - { 0x0000, 0x0000, 0x0000 }, /* R1370 */ - { 0x0000, 0x0000, 0x0000 }, /* R1371 */ - { 0x0000, 0x0000, 0x0000 }, /* R1372 */ - { 0x0000, 0x0000, 0x0000 }, /* R1373 */ - { 0x0000, 0x0000, 0x0000 }, /* R1374 */ - { 0x0000, 0x0000, 0x0000 }, /* R1375 */ - { 0x0000, 0x0000, 0x0000 }, /* R1376 */ - { 0x0000, 0x0000, 0x0000 }, /* R1377 */ - { 0x0000, 0x0000, 0x0000 }, /* R1378 */ - { 0x0000, 0x0000, 0x0000 }, /* R1379 */ - { 0x0000, 0x0000, 0x0000 }, /* R1380 */ - { 0x0000, 0x0000, 0x0000 }, /* R1381 */ - { 0x0000, 0x0000, 0x0000 }, /* R1382 */ - { 0x0000, 0x0000, 0x0000 }, /* R1383 */ - { 0x0000, 0x0000, 0x0000 }, /* R1384 */ - { 0x0000, 0x0000, 0x0000 }, /* R1385 */ - { 0x0000, 0x0000, 0x0000 }, /* R1386 */ - { 0x0000, 0x0000, 0x0000 }, /* R1387 */ - { 0x0000, 0x0000, 0x0000 }, /* R1388 */ - { 0x0000, 0x0000, 0x0000 }, /* R1389 */ - { 0x0000, 0x0000, 0x0000 }, /* R1390 */ - { 0x0000, 0x0000, 0x0000 }, /* R1391 */ - { 0x0000, 0x0000, 0x0000 }, /* R1392 */ - { 0x0000, 0x0000, 0x0000 }, /* R1393 */ - { 0x0000, 0x0000, 0x0000 }, /* R1394 */ - { 0x0000, 0x0000, 0x0000 }, /* R1395 */ - { 0x0000, 0x0000, 0x0000 }, /* R1396 */ - { 0x0000, 0x0000, 0x0000 }, /* R1397 */ - { 0x0000, 0x0000, 0x0000 }, /* R1398 */ - { 0x0000, 0x0000, 0x0000 }, /* R1399 */ - { 0x0000, 0x0000, 0x0000 }, /* R1400 */ - { 0x0000, 0x0000, 0x0000 }, /* R1401 */ - { 0x0000, 0x0000, 0x0000 }, /* R1402 */ - { 0x0000, 0x0000, 0x0000 }, /* R1403 */ - { 0x0000, 0x0000, 0x0000 }, /* R1404 */ - { 0x0000, 0x0000, 0x0000 }, /* R1405 */ - { 0x0000, 0x0000, 0x0000 }, /* R1406 */ - { 0x0000, 0x0000, 0x0000 }, /* R1407 */ - { 0x0000, 0x0000, 0x0000 }, /* R1408 */ - { 0x0000, 0x0000, 0x0000 }, /* R1409 */ - { 0x0000, 0x0000, 0x0000 }, /* R1410 */ - { 0x0000, 0x0000, 0x0000 }, /* R1411 */ - { 0x0000, 0x0000, 0x0000 }, /* R1412 */ - { 0x0000, 0x0000, 0x0000 }, /* R1413 */ - { 0x0000, 0x0000, 0x0000 }, /* R1414 */ - { 0x0000, 0x0000, 0x0000 }, /* R1415 */ - { 0x0000, 0x0000, 0x0000 }, /* R1416 */ - { 0x0000, 0x0000, 0x0000 }, /* R1417 */ - { 0x0000, 0x0000, 0x0000 }, /* R1418 */ - { 0x0000, 0x0000, 0x0000 }, /* R1419 */ - { 0x0000, 0x0000, 0x0000 }, /* R1420 */ - { 0x0000, 0x0000, 0x0000 }, /* R1421 */ - { 0x0000, 0x0000, 0x0000 }, /* R1422 */ - { 0x0000, 0x0000, 0x0000 }, /* R1423 */ - { 0x0000, 0x0000, 0x0000 }, /* R1424 */ - { 0x0000, 0x0000, 0x0000 }, /* R1425 */ - { 0x0000, 0x0000, 0x0000 }, /* R1426 */ - { 0x0000, 0x0000, 0x0000 }, /* R1427 */ - { 0x0000, 0x0000, 0x0000 }, /* R1428 */ - { 0x0000, 0x0000, 0x0000 }, /* R1429 */ - { 0x0000, 0x0000, 0x0000 }, /* R1430 */ - { 0x0000, 0x0000, 0x0000 }, /* R1431 */ - { 0x0000, 0x0000, 0x0000 }, /* R1432 */ - { 0x0000, 0x0000, 0x0000 }, /* R1433 */ - { 0x0000, 0x0000, 0x0000 }, /* R1434 */ - { 0x0000, 0x0000, 0x0000 }, /* R1435 */ - { 0x0000, 0x0000, 0x0000 }, /* R1436 */ - { 0x0000, 0x0000, 0x0000 }, /* R1437 */ - { 0x0000, 0x0000, 0x0000 }, /* R1438 */ - { 0x0000, 0x0000, 0x0000 }, /* R1439 */ - { 0x0000, 0x0000, 0x0000 }, /* R1440 */ - { 0x0000, 0x0000, 0x0000 }, /* R1441 */ - { 0x0000, 0x0000, 0x0000 }, /* R1442 */ - { 0x0000, 0x0000, 0x0000 }, /* R1443 */ - { 0x0000, 0x0000, 0x0000 }, /* R1444 */ - { 0x0000, 0x0000, 0x0000 }, /* R1445 */ - { 0x0000, 0x0000, 0x0000 }, /* R1446 */ - { 0x0000, 0x0000, 0x0000 }, /* R1447 */ - { 0x0000, 0x0000, 0x0000 }, /* R1448 */ - { 0x0000, 0x0000, 0x0000 }, /* R1449 */ - { 0x0000, 0x0000, 0x0000 }, /* R1450 */ - { 0x0000, 0x0000, 0x0000 }, /* R1451 */ - { 0x0000, 0x0000, 0x0000 }, /* R1452 */ - { 0x0000, 0x0000, 0x0000 }, /* R1453 */ - { 0x0000, 0x0000, 0x0000 }, /* R1454 */ - { 0x0000, 0x0000, 0x0000 }, /* R1455 */ - { 0x0000, 0x0000, 0x0000 }, /* R1456 */ - { 0x0000, 0x0000, 0x0000 }, /* R1457 */ - { 0x0000, 0x0000, 0x0000 }, /* R1458 */ - { 0x0000, 0x0000, 0x0000 }, /* R1459 */ - { 0x0000, 0x0000, 0x0000 }, /* R1460 */ - { 0x0000, 0x0000, 0x0000 }, /* R1461 */ - { 0x0000, 0x0000, 0x0000 }, /* R1462 */ - { 0x0000, 0x0000, 0x0000 }, /* R1463 */ - { 0x0000, 0x0000, 0x0000 }, /* R1464 */ - { 0x0000, 0x0000, 0x0000 }, /* R1465 */ - { 0x0000, 0x0000, 0x0000 }, /* R1466 */ - { 0x0000, 0x0000, 0x0000 }, /* R1467 */ - { 0x0000, 0x0000, 0x0000 }, /* R1468 */ - { 0x0000, 0x0000, 0x0000 }, /* R1469 */ - { 0x0000, 0x0000, 0x0000 }, /* R1470 */ - { 0x0000, 0x0000, 0x0000 }, /* R1471 */ - { 0x0000, 0x0000, 0x0000 }, /* R1472 */ - { 0x0000, 0x0000, 0x0000 }, /* R1473 */ - { 0x0000, 0x0000, 0x0000 }, /* R1474 */ - { 0x0000, 0x0000, 0x0000 }, /* R1475 */ - { 0x0000, 0x0000, 0x0000 }, /* R1476 */ - { 0x0000, 0x0000, 0x0000 }, /* R1477 */ - { 0x0000, 0x0000, 0x0000 }, /* R1478 */ - { 0x0000, 0x0000, 0x0000 }, /* R1479 */ - { 0x0000, 0x0000, 0x0000 }, /* R1480 */ - { 0x0000, 0x0000, 0x0000 }, /* R1481 */ - { 0x0000, 0x0000, 0x0000 }, /* R1482 */ - { 0x0000, 0x0000, 0x0000 }, /* R1483 */ - { 0x0000, 0x0000, 0x0000 }, /* R1484 */ - { 0x0000, 0x0000, 0x0000 }, /* R1485 */ - { 0x0000, 0x0000, 0x0000 }, /* R1486 */ - { 0x0000, 0x0000, 0x0000 }, /* R1487 */ - { 0x0000, 0x0000, 0x0000 }, /* R1488 */ - { 0x0000, 0x0000, 0x0000 }, /* R1489 */ - { 0x0000, 0x0000, 0x0000 }, /* R1490 */ - { 0x0000, 0x0000, 0x0000 }, /* R1491 */ - { 0x0000, 0x0000, 0x0000 }, /* R1492 */ - { 0x0000, 0x0000, 0x0000 }, /* R1493 */ - { 0x0000, 0x0000, 0x0000 }, /* R1494 */ - { 0x0000, 0x0000, 0x0000 }, /* R1495 */ - { 0x0000, 0x0000, 0x0000 }, /* R1496 */ - { 0x0000, 0x0000, 0x0000 }, /* R1497 */ - { 0x0000, 0x0000, 0x0000 }, /* R1498 */ - { 0x0000, 0x0000, 0x0000 }, /* R1499 */ - { 0x0000, 0x0000, 0x0000 }, /* R1500 */ - { 0x0000, 0x0000, 0x0000 }, /* R1501 */ - { 0x0000, 0x0000, 0x0000 }, /* R1502 */ - { 0x0000, 0x0000, 0x0000 }, /* R1503 */ - { 0x0000, 0x0000, 0x0000 }, /* R1504 */ - { 0x0000, 0x0000, 0x0000 }, /* R1505 */ - { 0x0000, 0x0000, 0x0000 }, /* R1506 */ - { 0x0000, 0x0000, 0x0000 }, /* R1507 */ - { 0x0000, 0x0000, 0x0000 }, /* R1508 */ - { 0x0000, 0x0000, 0x0000 }, /* R1509 */ - { 0x0000, 0x0000, 0x0000 }, /* R1510 */ - { 0x0000, 0x0000, 0x0000 }, /* R1511 */ - { 0x0000, 0x0000, 0x0000 }, /* R1512 */ - { 0x0000, 0x0000, 0x0000 }, /* R1513 */ - { 0x0000, 0x0000, 0x0000 }, /* R1514 */ - { 0x0000, 0x0000, 0x0000 }, /* R1515 */ - { 0x0000, 0x0000, 0x0000 }, /* R1516 */ - { 0x0000, 0x0000, 0x0000 }, /* R1517 */ - { 0x0000, 0x0000, 0x0000 }, /* R1518 */ - { 0x0000, 0x0000, 0x0000 }, /* R1519 */ - { 0x0000, 0x0000, 0x0000 }, /* R1520 */ - { 0x0000, 0x0000, 0x0000 }, /* R1521 */ - { 0x0000, 0x0000, 0x0000 }, /* R1522 */ - { 0x0000, 0x0000, 0x0000 }, /* R1523 */ - { 0x0000, 0x0000, 0x0000 }, /* R1524 */ - { 0x0000, 0x0000, 0x0000 }, /* R1525 */ - { 0x0000, 0x0000, 0x0000 }, /* R1526 */ - { 0x0000, 0x0000, 0x0000 }, /* R1527 */ - { 0x0000, 0x0000, 0x0000 }, /* R1528 */ - { 0x0000, 0x0000, 0x0000 }, /* R1529 */ - { 0x0000, 0x0000, 0x0000 }, /* R1530 */ - { 0x0000, 0x0000, 0x0000 }, /* R1531 */ - { 0x0000, 0x0000, 0x0000 }, /* R1532 */ - { 0x0000, 0x0000, 0x0000 }, /* R1533 */ - { 0x0000, 0x0000, 0x0000 }, /* R1534 */ - { 0x0000, 0x0000, 0x0000 }, /* R1535 */ - { 0x0000, 0x0000, 0x0000 }, /* R1536 */ - { 0x0000, 0x0000, 0x0000 }, /* R1537 */ - { 0x0000, 0x0000, 0x0000 }, /* R1538 */ - { 0x0000, 0x0000, 0x0000 }, /* R1539 */ - { 0x0000, 0x0000, 0x0000 }, /* R1540 */ - { 0x0000, 0x0000, 0x0000 }, /* R1541 */ - { 0x0000, 0x0000, 0x0000 }, /* R1542 */ - { 0x0000, 0x0000, 0x0000 }, /* R1543 */ - { 0x0000, 0x0000, 0x0000 }, /* R1544 */ - { 0x0000, 0x0000, 0x0000 }, /* R1545 */ - { 0x0000, 0x0000, 0x0000 }, /* R1546 */ - { 0x0000, 0x0000, 0x0000 }, /* R1547 */ - { 0x0000, 0x0000, 0x0000 }, /* R1548 */ - { 0x0000, 0x0000, 0x0000 }, /* R1549 */ - { 0x0000, 0x0000, 0x0000 }, /* R1550 */ - { 0x0000, 0x0000, 0x0000 }, /* R1551 */ - { 0x0000, 0x0000, 0x0000 }, /* R1552 */ - { 0x0000, 0x0000, 0x0000 }, /* R1553 */ - { 0x0000, 0x0000, 0x0000 }, /* R1554 */ - { 0x0000, 0x0000, 0x0000 }, /* R1555 */ - { 0x0000, 0x0000, 0x0000 }, /* R1556 */ - { 0x0000, 0x0000, 0x0000 }, /* R1557 */ - { 0x0000, 0x0000, 0x0000 }, /* R1558 */ - { 0x0000, 0x0000, 0x0000 }, /* R1559 */ - { 0x0000, 0x0000, 0x0000 }, /* R1560 */ - { 0x0000, 0x0000, 0x0000 }, /* R1561 */ - { 0x0000, 0x0000, 0x0000 }, /* R1562 */ - { 0x0000, 0x0000, 0x0000 }, /* R1563 */ - { 0x0000, 0x0000, 0x0000 }, /* R1564 */ - { 0x0000, 0x0000, 0x0000 }, /* R1565 */ - { 0x0000, 0x0000, 0x0000 }, /* R1566 */ - { 0x0000, 0x0000, 0x0000 }, /* R1567 */ - { 0x0000, 0x0000, 0x0000 }, /* R1568 */ - { 0x0000, 0x0000, 0x0000 }, /* R1569 */ - { 0x0000, 0x0000, 0x0000 }, /* R1570 */ - { 0x0000, 0x0000, 0x0000 }, /* R1571 */ - { 0x0000, 0x0000, 0x0000 }, /* R1572 */ - { 0x0000, 0x0000, 0x0000 }, /* R1573 */ - { 0x0000, 0x0000, 0x0000 }, /* R1574 */ - { 0x0000, 0x0000, 0x0000 }, /* R1575 */ - { 0x0000, 0x0000, 0x0000 }, /* R1576 */ - { 0x0000, 0x0000, 0x0000 }, /* R1577 */ - { 0x0000, 0x0000, 0x0000 }, /* R1578 */ - { 0x0000, 0x0000, 0x0000 }, /* R1579 */ - { 0x0000, 0x0000, 0x0000 }, /* R1580 */ - { 0x0000, 0x0000, 0x0000 }, /* R1581 */ - { 0x0000, 0x0000, 0x0000 }, /* R1582 */ - { 0x0000, 0x0000, 0x0000 }, /* R1583 */ - { 0x0000, 0x0000, 0x0000 }, /* R1584 */ - { 0x0000, 0x0000, 0x0000 }, /* R1585 */ - { 0x0000, 0x0000, 0x0000 }, /* R1586 */ - { 0x0000, 0x0000, 0x0000 }, /* R1587 */ - { 0x0000, 0x0000, 0x0000 }, /* R1588 */ - { 0x0000, 0x0000, 0x0000 }, /* R1589 */ - { 0x0000, 0x0000, 0x0000 }, /* R1590 */ - { 0x0000, 0x0000, 0x0000 }, /* R1591 */ - { 0x0000, 0x0000, 0x0000 }, /* R1592 */ - { 0x0000, 0x0000, 0x0000 }, /* R1593 */ - { 0x0000, 0x0000, 0x0000 }, /* R1594 */ - { 0x0000, 0x0000, 0x0000 }, /* R1595 */ - { 0x0000, 0x0000, 0x0000 }, /* R1596 */ - { 0x0000, 0x0000, 0x0000 }, /* R1597 */ - { 0x0000, 0x0000, 0x0000 }, /* R1598 */ - { 0x0000, 0x0000, 0x0000 }, /* R1599 */ - { 0x0000, 0x0000, 0x0000 }, /* R1600 */ - { 0x0000, 0x0000, 0x0000 }, /* R1601 */ - { 0x0000, 0x0000, 0x0000 }, /* R1602 */ - { 0x0000, 0x0000, 0x0000 }, /* R1603 */ - { 0x0000, 0x0000, 0x0000 }, /* R1604 */ - { 0x0000, 0x0000, 0x0000 }, /* R1605 */ - { 0x0000, 0x0000, 0x0000 }, /* R1606 */ - { 0x0000, 0x0000, 0x0000 }, /* R1607 */ - { 0x0000, 0x0000, 0x0000 }, /* R1608 */ - { 0x0000, 0x0000, 0x0000 }, /* R1609 */ - { 0x0000, 0x0000, 0x0000 }, /* R1610 */ - { 0x0000, 0x0000, 0x0000 }, /* R1611 */ - { 0x0000, 0x0000, 0x0000 }, /* R1612 */ - { 0x0000, 0x0000, 0x0000 }, /* R1613 */ - { 0x0000, 0x0000, 0x0000 }, /* R1614 */ - { 0x0000, 0x0000, 0x0000 }, /* R1615 */ - { 0x0000, 0x0000, 0x0000 }, /* R1616 */ - { 0x0000, 0x0000, 0x0000 }, /* R1617 */ - { 0x0000, 0x0000, 0x0000 }, /* R1618 */ - { 0x0000, 0x0000, 0x0000 }, /* R1619 */ - { 0x0000, 0x0000, 0x0000 }, /* R1620 */ - { 0x0000, 0x0000, 0x0000 }, /* R1621 */ - { 0x0000, 0x0000, 0x0000 }, /* R1622 */ - { 0x0000, 0x0000, 0x0000 }, /* R1623 */ - { 0x0000, 0x0000, 0x0000 }, /* R1624 */ - { 0x0000, 0x0000, 0x0000 }, /* R1625 */ - { 0x0000, 0x0000, 0x0000 }, /* R1626 */ - { 0x0000, 0x0000, 0x0000 }, /* R1627 */ - { 0x0000, 0x0000, 0x0000 }, /* R1628 */ - { 0x0000, 0x0000, 0x0000 }, /* R1629 */ - { 0x0000, 0x0000, 0x0000 }, /* R1630 */ - { 0x0000, 0x0000, 0x0000 }, /* R1631 */ - { 0x0000, 0x0000, 0x0000 }, /* R1632 */ - { 0x0000, 0x0000, 0x0000 }, /* R1633 */ - { 0x0000, 0x0000, 0x0000 }, /* R1634 */ - { 0x0000, 0x0000, 0x0000 }, /* R1635 */ - { 0x0000, 0x0000, 0x0000 }, /* R1636 */ - { 0x0000, 0x0000, 0x0000 }, /* R1637 */ - { 0x0000, 0x0000, 0x0000 }, /* R1638 */ - { 0x0000, 0x0000, 0x0000 }, /* R1639 */ - { 0x0000, 0x0000, 0x0000 }, /* R1640 */ - { 0x0000, 0x0000, 0x0000 }, /* R1641 */ - { 0x0000, 0x0000, 0x0000 }, /* R1642 */ - { 0x0000, 0x0000, 0x0000 }, /* R1643 */ - { 0x0000, 0x0000, 0x0000 }, /* R1644 */ - { 0x0000, 0x0000, 0x0000 }, /* R1645 */ - { 0x0000, 0x0000, 0x0000 }, /* R1646 */ - { 0x0000, 0x0000, 0x0000 }, /* R1647 */ - { 0x0000, 0x0000, 0x0000 }, /* R1648 */ - { 0x0000, 0x0000, 0x0000 }, /* R1649 */ - { 0x0000, 0x0000, 0x0000 }, /* R1650 */ - { 0x0000, 0x0000, 0x0000 }, /* R1651 */ - { 0x0000, 0x0000, 0x0000 }, /* R1652 */ - { 0x0000, 0x0000, 0x0000 }, /* R1653 */ - { 0x0000, 0x0000, 0x0000 }, /* R1654 */ - { 0x0000, 0x0000, 0x0000 }, /* R1655 */ - { 0x0000, 0x0000, 0x0000 }, /* R1656 */ - { 0x0000, 0x0000, 0x0000 }, /* R1657 */ - { 0x0000, 0x0000, 0x0000 }, /* R1658 */ - { 0x0000, 0x0000, 0x0000 }, /* R1659 */ - { 0x0000, 0x0000, 0x0000 }, /* R1660 */ - { 0x0000, 0x0000, 0x0000 }, /* R1661 */ - { 0x0000, 0x0000, 0x0000 }, /* R1662 */ - { 0x0000, 0x0000, 0x0000 }, /* R1663 */ - { 0x0000, 0x0000, 0x0000 }, /* R1664 */ - { 0x0000, 0x0000, 0x0000 }, /* R1665 */ - { 0x0000, 0x0000, 0x0000 }, /* R1666 */ - { 0x0000, 0x0000, 0x0000 }, /* R1667 */ - { 0x0000, 0x0000, 0x0000 }, /* R1668 */ - { 0x0000, 0x0000, 0x0000 }, /* R1669 */ - { 0x0000, 0x0000, 0x0000 }, /* R1670 */ - { 0x0000, 0x0000, 0x0000 }, /* R1671 */ - { 0x0000, 0x0000, 0x0000 }, /* R1672 */ - { 0x0000, 0x0000, 0x0000 }, /* R1673 */ - { 0x0000, 0x0000, 0x0000 }, /* R1674 */ - { 0x0000, 0x0000, 0x0000 }, /* R1675 */ - { 0x0000, 0x0000, 0x0000 }, /* R1676 */ - { 0x0000, 0x0000, 0x0000 }, /* R1677 */ - { 0x0000, 0x0000, 0x0000 }, /* R1678 */ - { 0x0000, 0x0000, 0x0000 }, /* R1679 */ - { 0x0000, 0x0000, 0x0000 }, /* R1680 */ - { 0x0000, 0x0000, 0x0000 }, /* R1681 */ - { 0x0000, 0x0000, 0x0000 }, /* R1682 */ - { 0x0000, 0x0000, 0x0000 }, /* R1683 */ - { 0x0000, 0x0000, 0x0000 }, /* R1684 */ - { 0x0000, 0x0000, 0x0000 }, /* R1685 */ - { 0x0000, 0x0000, 0x0000 }, /* R1686 */ - { 0x0000, 0x0000, 0x0000 }, /* R1687 */ - { 0x0000, 0x0000, 0x0000 }, /* R1688 */ - { 0x0000, 0x0000, 0x0000 }, /* R1689 */ - { 0x0000, 0x0000, 0x0000 }, /* R1690 */ - { 0x0000, 0x0000, 0x0000 }, /* R1691 */ - { 0x0000, 0x0000, 0x0000 }, /* R1692 */ - { 0x0000, 0x0000, 0x0000 }, /* R1693 */ - { 0x0000, 0x0000, 0x0000 }, /* R1694 */ - { 0x0000, 0x0000, 0x0000 }, /* R1695 */ - { 0x0000, 0x0000, 0x0000 }, /* R1696 */ - { 0x0000, 0x0000, 0x0000 }, /* R1697 */ - { 0x0000, 0x0000, 0x0000 }, /* R1698 */ - { 0x0000, 0x0000, 0x0000 }, /* R1699 */ - { 0x0000, 0x0000, 0x0000 }, /* R1700 */ - { 0x0000, 0x0000, 0x0000 }, /* R1701 */ - { 0x0000, 0x0000, 0x0000 }, /* R1702 */ - { 0x0000, 0x0000, 0x0000 }, /* R1703 */ - { 0x0000, 0x0000, 0x0000 }, /* R1704 */ - { 0x0000, 0x0000, 0x0000 }, /* R1705 */ - { 0x0000, 0x0000, 0x0000 }, /* R1706 */ - { 0x0000, 0x0000, 0x0000 }, /* R1707 */ - { 0x0000, 0x0000, 0x0000 }, /* R1708 */ - { 0x0000, 0x0000, 0x0000 }, /* R1709 */ - { 0x0000, 0x0000, 0x0000 }, /* R1710 */ - { 0x0000, 0x0000, 0x0000 }, /* R1711 */ - { 0x0000, 0x0000, 0x0000 }, /* R1712 */ - { 0x0000, 0x0000, 0x0000 }, /* R1713 */ - { 0x0000, 0x0000, 0x0000 }, /* R1714 */ - { 0x0000, 0x0000, 0x0000 }, /* R1715 */ - { 0x0000, 0x0000, 0x0000 }, /* R1716 */ - { 0x0000, 0x0000, 0x0000 }, /* R1717 */ - { 0x0000, 0x0000, 0x0000 }, /* R1718 */ - { 0x0000, 0x0000, 0x0000 }, /* R1719 */ - { 0x0000, 0x0000, 0x0000 }, /* R1720 */ - { 0x0000, 0x0000, 0x0000 }, /* R1721 */ - { 0x0000, 0x0000, 0x0000 }, /* R1722 */ - { 0x0000, 0x0000, 0x0000 }, /* R1723 */ - { 0x0000, 0x0000, 0x0000 }, /* R1724 */ - { 0x0000, 0x0000, 0x0000 }, /* R1725 */ - { 0x0000, 0x0000, 0x0000 }, /* R1726 */ - { 0x0000, 0x0000, 0x0000 }, /* R1727 */ - { 0x0000, 0x0000, 0x0000 }, /* R1728 */ - { 0x0000, 0x0000, 0x0000 }, /* R1729 */ - { 0x0000, 0x0000, 0x0000 }, /* R1730 */ - { 0x0000, 0x0000, 0x0000 }, /* R1731 */ - { 0x0000, 0x0000, 0x0000 }, /* R1732 */ - { 0x0000, 0x0000, 0x0000 }, /* R1733 */ - { 0x0000, 0x0000, 0x0000 }, /* R1734 */ - { 0x0000, 0x0000, 0x0000 }, /* R1735 */ - { 0x0000, 0x0000, 0x0000 }, /* R1736 */ - { 0x0000, 0x0000, 0x0000 }, /* R1737 */ - { 0x0000, 0x0000, 0x0000 }, /* R1738 */ - { 0x0000, 0x0000, 0x0000 }, /* R1739 */ - { 0x0000, 0x0000, 0x0000 }, /* R1740 */ - { 0x0000, 0x0000, 0x0000 }, /* R1741 */ - { 0x0000, 0x0000, 0x0000 }, /* R1742 */ - { 0x0000, 0x0000, 0x0000 }, /* R1743 */ - { 0x0000, 0x0000, 0x0000 }, /* R1744 */ - { 0x0000, 0x0000, 0x0000 }, /* R1745 */ - { 0x0000, 0x0000, 0x0000 }, /* R1746 */ - { 0x0000, 0x0000, 0x0000 }, /* R1747 */ - { 0x0000, 0x0000, 0x0000 }, /* R1748 */ - { 0x0000, 0x0000, 0x0000 }, /* R1749 */ - { 0x0000, 0x0000, 0x0000 }, /* R1750 */ - { 0x0000, 0x0000, 0x0000 }, /* R1751 */ - { 0x0000, 0x0000, 0x0000 }, /* R1752 */ - { 0x0000, 0x0000, 0x0000 }, /* R1753 */ - { 0x0000, 0x0000, 0x0000 }, /* R1754 */ - { 0x0000, 0x0000, 0x0000 }, /* R1755 */ - { 0x0000, 0x0000, 0x0000 }, /* R1756 */ - { 0x0000, 0x0000, 0x0000 }, /* R1757 */ - { 0x0000, 0x0000, 0x0000 }, /* R1758 */ - { 0x0000, 0x0000, 0x0000 }, /* R1759 */ - { 0x0000, 0x0000, 0x0000 }, /* R1760 */ - { 0x0000, 0x0000, 0x0000 }, /* R1761 */ - { 0x0000, 0x0000, 0x0000 }, /* R1762 */ - { 0x0000, 0x0000, 0x0000 }, /* R1763 */ - { 0x0000, 0x0000, 0x0000 }, /* R1764 */ - { 0x0000, 0x0000, 0x0000 }, /* R1765 */ - { 0x0000, 0x0000, 0x0000 }, /* R1766 */ - { 0x0000, 0x0000, 0x0000 }, /* R1767 */ - { 0x0000, 0x0000, 0x0000 }, /* R1768 */ - { 0x0000, 0x0000, 0x0000 }, /* R1769 */ - { 0x0000, 0x0000, 0x0000 }, /* R1770 */ - { 0x0000, 0x0000, 0x0000 }, /* R1771 */ - { 0x0000, 0x0000, 0x0000 }, /* R1772 */ - { 0x0000, 0x0000, 0x0000 }, /* R1773 */ - { 0x0000, 0x0000, 0x0000 }, /* R1774 */ - { 0x0000, 0x0000, 0x0000 }, /* R1775 */ - { 0x0000, 0x0000, 0x0000 }, /* R1776 */ - { 0x0000, 0x0000, 0x0000 }, /* R1777 */ - { 0x0000, 0x0000, 0x0000 }, /* R1778 */ - { 0x0000, 0x0000, 0x0000 }, /* R1779 */ - { 0x0000, 0x0000, 0x0000 }, /* R1780 */ - { 0x0000, 0x0000, 0x0000 }, /* R1781 */ - { 0x0000, 0x0000, 0x0000 }, /* R1782 */ - { 0x0000, 0x0000, 0x0000 }, /* R1783 */ - { 0x0000, 0x0000, 0x0000 }, /* R1784 */ - { 0x0000, 0x0000, 0x0000 }, /* R1785 */ - { 0x0000, 0x0000, 0x0000 }, /* R1786 */ - { 0x0000, 0x0000, 0x0000 }, /* R1787 */ - { 0x0000, 0x0000, 0x0000 }, /* R1788 */ - { 0x0000, 0x0000, 0x0000 }, /* R1789 */ - { 0x0000, 0x0000, 0x0000 }, /* R1790 */ - { 0x0000, 0x0000, 0x0000 }, /* R1791 */ - { 0x0000, 0x0000, 0x0000 }, /* R1792 */ - { 0x0000, 0x0000, 0x0000 }, /* R1793 */ - { 0x0000, 0x0000, 0x0000 }, /* R1794 */ - { 0x0000, 0x0000, 0x0000 }, /* R1795 */ - { 0x0000, 0x0000, 0x0000 }, /* R1796 */ - { 0x0000, 0x0000, 0x0000 }, /* R1797 */ - { 0x0000, 0x0000, 0x0000 }, /* R1798 */ - { 0x0000, 0x0000, 0x0000 }, /* R1799 */ - { 0x0000, 0x0000, 0x0000 }, /* R1800 */ - { 0x0000, 0x0000, 0x0000 }, /* R1801 */ - { 0x0000, 0x0000, 0x0000 }, /* R1802 */ - { 0x0000, 0x0000, 0x0000 }, /* R1803 */ - { 0x0000, 0x0000, 0x0000 }, /* R1804 */ - { 0x0000, 0x0000, 0x0000 }, /* R1805 */ - { 0x0000, 0x0000, 0x0000 }, /* R1806 */ - { 0x0000, 0x0000, 0x0000 }, /* R1807 */ - { 0x0000, 0x0000, 0x0000 }, /* R1808 */ - { 0x0000, 0x0000, 0x0000 }, /* R1809 */ - { 0x0000, 0x0000, 0x0000 }, /* R1810 */ - { 0x0000, 0x0000, 0x0000 }, /* R1811 */ - { 0x0000, 0x0000, 0x0000 }, /* R1812 */ - { 0x0000, 0x0000, 0x0000 }, /* R1813 */ - { 0x0000, 0x0000, 0x0000 }, /* R1814 */ - { 0x0000, 0x0000, 0x0000 }, /* R1815 */ - { 0x0000, 0x0000, 0x0000 }, /* R1816 */ - { 0x0000, 0x0000, 0x0000 }, /* R1817 */ - { 0x0000, 0x0000, 0x0000 }, /* R1818 */ - { 0x0000, 0x0000, 0x0000 }, /* R1819 */ - { 0x0000, 0x0000, 0x0000 }, /* R1820 */ - { 0x0000, 0x0000, 0x0000 }, /* R1821 */ - { 0x0000, 0x0000, 0x0000 }, /* R1822 */ - { 0x0000, 0x0000, 0x0000 }, /* R1823 */ - { 0x0000, 0x0000, 0x0000 }, /* R1824 */ - { 0x0000, 0x0000, 0x0000 }, /* R1825 */ - { 0x0000, 0x0000, 0x0000 }, /* R1826 */ - { 0x0000, 0x0000, 0x0000 }, /* R1827 */ - { 0x0000, 0x0000, 0x0000 }, /* R1828 */ - { 0x0000, 0x0000, 0x0000 }, /* R1829 */ - { 0x0000, 0x0000, 0x0000 }, /* R1830 */ - { 0x0000, 0x0000, 0x0000 }, /* R1831 */ - { 0x0000, 0x0000, 0x0000 }, /* R1832 */ - { 0x0000, 0x0000, 0x0000 }, /* R1833 */ - { 0x0000, 0x0000, 0x0000 }, /* R1834 */ - { 0x0000, 0x0000, 0x0000 }, /* R1835 */ - { 0x0000, 0x0000, 0x0000 }, /* R1836 */ - { 0x0000, 0x0000, 0x0000 }, /* R1837 */ - { 0x0000, 0x0000, 0x0000 }, /* R1838 */ - { 0x0000, 0x0000, 0x0000 }, /* R1839 */ - { 0x0000, 0x0000, 0x0000 }, /* R1840 */ - { 0x0000, 0x0000, 0x0000 }, /* R1841 */ - { 0x0000, 0x0000, 0x0000 }, /* R1842 */ - { 0x0000, 0x0000, 0x0000 }, /* R1843 */ - { 0x0000, 0x0000, 0x0000 }, /* R1844 */ - { 0x0000, 0x0000, 0x0000 }, /* R1845 */ - { 0x0000, 0x0000, 0x0000 }, /* R1846 */ - { 0x0000, 0x0000, 0x0000 }, /* R1847 */ - { 0x0000, 0x0000, 0x0000 }, /* R1848 */ - { 0x0000, 0x0000, 0x0000 }, /* R1849 */ - { 0x0000, 0x0000, 0x0000 }, /* R1850 */ - { 0x0000, 0x0000, 0x0000 }, /* R1851 */ - { 0x0000, 0x0000, 0x0000 }, /* R1852 */ - { 0x0000, 0x0000, 0x0000 }, /* R1853 */ - { 0x0000, 0x0000, 0x0000 }, /* R1854 */ - { 0x0000, 0x0000, 0x0000 }, /* R1855 */ - { 0x0000, 0x0000, 0x0000 }, /* R1856 */ - { 0x0000, 0x0000, 0x0000 }, /* R1857 */ - { 0x0000, 0x0000, 0x0000 }, /* R1858 */ - { 0x0000, 0x0000, 0x0000 }, /* R1859 */ - { 0x0000, 0x0000, 0x0000 }, /* R1860 */ - { 0x0000, 0x0000, 0x0000 }, /* R1861 */ - { 0x0000, 0x0000, 0x0000 }, /* R1862 */ - { 0x0000, 0x0000, 0x0000 }, /* R1863 */ - { 0x0000, 0x0000, 0x0000 }, /* R1864 */ - { 0x0000, 0x0000, 0x0000 }, /* R1865 */ - { 0x0000, 0x0000, 0x0000 }, /* R1866 */ - { 0x0000, 0x0000, 0x0000 }, /* R1867 */ - { 0x0000, 0x0000, 0x0000 }, /* R1868 */ - { 0x0000, 0x0000, 0x0000 }, /* R1869 */ - { 0x0000, 0x0000, 0x0000 }, /* R1870 */ - { 0x0000, 0x0000, 0x0000 }, /* R1871 */ - { 0x0000, 0x0000, 0x0000 }, /* R1872 */ - { 0x0000, 0x0000, 0x0000 }, /* R1873 */ - { 0x0000, 0x0000, 0x0000 }, /* R1874 */ - { 0x0000, 0x0000, 0x0000 }, /* R1875 */ - { 0x0000, 0x0000, 0x0000 }, /* R1876 */ - { 0x0000, 0x0000, 0x0000 }, /* R1877 */ - { 0x0000, 0x0000, 0x0000 }, /* R1878 */ - { 0x0000, 0x0000, 0x0000 }, /* R1879 */ - { 0x0000, 0x0000, 0x0000 }, /* R1880 */ - { 0x0000, 0x0000, 0x0000 }, /* R1881 */ - { 0x0000, 0x0000, 0x0000 }, /* R1882 */ - { 0x0000, 0x0000, 0x0000 }, /* R1883 */ - { 0x0000, 0x0000, 0x0000 }, /* R1884 */ - { 0x0000, 0x0000, 0x0000 }, /* R1885 */ - { 0x0000, 0x0000, 0x0000 }, /* R1886 */ - { 0x0000, 0x0000, 0x0000 }, /* R1887 */ - { 0x0000, 0x0000, 0x0000 }, /* R1888 */ - { 0x0000, 0x0000, 0x0000 }, /* R1889 */ - { 0x0000, 0x0000, 0x0000 }, /* R1890 */ - { 0x0000, 0x0000, 0x0000 }, /* R1891 */ - { 0x0000, 0x0000, 0x0000 }, /* R1892 */ - { 0x0000, 0x0000, 0x0000 }, /* R1893 */ - { 0x0000, 0x0000, 0x0000 }, /* R1894 */ - { 0x0000, 0x0000, 0x0000 }, /* R1895 */ - { 0x0000, 0x0000, 0x0000 }, /* R1896 */ - { 0x0000, 0x0000, 0x0000 }, /* R1897 */ - { 0x0000, 0x0000, 0x0000 }, /* R1898 */ - { 0x0000, 0x0000, 0x0000 }, /* R1899 */ - { 0x0000, 0x0000, 0x0000 }, /* R1900 */ - { 0x0000, 0x0000, 0x0000 }, /* R1901 */ - { 0x0000, 0x0000, 0x0000 }, /* R1902 */ - { 0x0000, 0x0000, 0x0000 }, /* R1903 */ - { 0x0000, 0x0000, 0x0000 }, /* R1904 */ - { 0x0000, 0x0000, 0x0000 }, /* R1905 */ - { 0x0000, 0x0000, 0x0000 }, /* R1906 */ - { 0x0000, 0x0000, 0x0000 }, /* R1907 */ - { 0x0000, 0x0000, 0x0000 }, /* R1908 */ - { 0x0000, 0x0000, 0x0000 }, /* R1909 */ - { 0x0000, 0x0000, 0x0000 }, /* R1910 */ - { 0x0000, 0x0000, 0x0000 }, /* R1911 */ - { 0x0000, 0x0000, 0x0000 }, /* R1912 */ - { 0x0000, 0x0000, 0x0000 }, /* R1913 */ - { 0x0000, 0x0000, 0x0000 }, /* R1914 */ - { 0x0000, 0x0000, 0x0000 }, /* R1915 */ - { 0x0000, 0x0000, 0x0000 }, /* R1916 */ - { 0x0000, 0x0000, 0x0000 }, /* R1917 */ - { 0x0000, 0x0000, 0x0000 }, /* R1918 */ - { 0x0000, 0x0000, 0x0000 }, /* R1919 */ - { 0x0000, 0x0000, 0x0000 }, /* R1920 */ - { 0x0000, 0x0000, 0x0000 }, /* R1921 */ - { 0x0000, 0x0000, 0x0000 }, /* R1922 */ - { 0x0000, 0x0000, 0x0000 }, /* R1923 */ - { 0x0000, 0x0000, 0x0000 }, /* R1924 */ - { 0x0000, 0x0000, 0x0000 }, /* R1925 */ - { 0x0000, 0x0000, 0x0000 }, /* R1926 */ - { 0x0000, 0x0000, 0x0000 }, /* R1927 */ - { 0x0000, 0x0000, 0x0000 }, /* R1928 */ - { 0x0000, 0x0000, 0x0000 }, /* R1929 */ - { 0x0000, 0x0000, 0x0000 }, /* R1930 */ - { 0x0000, 0x0000, 0x0000 }, /* R1931 */ - { 0x0000, 0x0000, 0x0000 }, /* R1932 */ - { 0x0000, 0x0000, 0x0000 }, /* R1933 */ - { 0x0000, 0x0000, 0x0000 }, /* R1934 */ - { 0x0000, 0x0000, 0x0000 }, /* R1935 */ - { 0x0000, 0x0000, 0x0000 }, /* R1936 */ - { 0x0000, 0x0000, 0x0000 }, /* R1937 */ - { 0x0000, 0x0000, 0x0000 }, /* R1938 */ - { 0x0000, 0x0000, 0x0000 }, /* R1939 */ - { 0x0000, 0x0000, 0x0000 }, /* R1940 */ - { 0x0000, 0x0000, 0x0000 }, /* R1941 */ - { 0x0000, 0x0000, 0x0000 }, /* R1942 */ - { 0x0000, 0x0000, 0x0000 }, /* R1943 */ - { 0x0000, 0x0000, 0x0000 }, /* R1944 */ - { 0x0000, 0x0000, 0x0000 }, /* R1945 */ - { 0x0000, 0x0000, 0x0000 }, /* R1946 */ - { 0x0000, 0x0000, 0x0000 }, /* R1947 */ - { 0x0000, 0x0000, 0x0000 }, /* R1948 */ - { 0x0000, 0x0000, 0x0000 }, /* R1949 */ - { 0x0000, 0x0000, 0x0000 }, /* R1950 */ - { 0x0000, 0x0000, 0x0000 }, /* R1951 */ - { 0x0000, 0x0000, 0x0000 }, /* R1952 */ - { 0x0000, 0x0000, 0x0000 }, /* R1953 */ - { 0x0000, 0x0000, 0x0000 }, /* R1954 */ - { 0x0000, 0x0000, 0x0000 }, /* R1955 */ - { 0x0000, 0x0000, 0x0000 }, /* R1956 */ - { 0x0000, 0x0000, 0x0000 }, /* R1957 */ - { 0x0000, 0x0000, 0x0000 }, /* R1958 */ - { 0x0000, 0x0000, 0x0000 }, /* R1959 */ - { 0x0000, 0x0000, 0x0000 }, /* R1960 */ - { 0x0000, 0x0000, 0x0000 }, /* R1961 */ - { 0x0000, 0x0000, 0x0000 }, /* R1962 */ - { 0x0000, 0x0000, 0x0000 }, /* R1963 */ - { 0x0000, 0x0000, 0x0000 }, /* R1964 */ - { 0x0000, 0x0000, 0x0000 }, /* R1965 */ - { 0x0000, 0x0000, 0x0000 }, /* R1966 */ - { 0x0000, 0x0000, 0x0000 }, /* R1967 */ - { 0x0000, 0x0000, 0x0000 }, /* R1968 */ - { 0x0000, 0x0000, 0x0000 }, /* R1969 */ - { 0x0000, 0x0000, 0x0000 }, /* R1970 */ - { 0x0000, 0x0000, 0x0000 }, /* R1971 */ - { 0x0000, 0x0000, 0x0000 }, /* R1972 */ - { 0x0000, 0x0000, 0x0000 }, /* R1973 */ - { 0x0000, 0x0000, 0x0000 }, /* R1974 */ - { 0x0000, 0x0000, 0x0000 }, /* R1975 */ - { 0x0000, 0x0000, 0x0000 }, /* R1976 */ - { 0x0000, 0x0000, 0x0000 }, /* R1977 */ - { 0x0000, 0x0000, 0x0000 }, /* R1978 */ - { 0x0000, 0x0000, 0x0000 }, /* R1979 */ - { 0x0000, 0x0000, 0x0000 }, /* R1980 */ - { 0x0000, 0x0000, 0x0000 }, /* R1981 */ - { 0x0000, 0x0000, 0x0000 }, /* R1982 */ - { 0x0000, 0x0000, 0x0000 }, /* R1983 */ - { 0x0000, 0x0000, 0x0000 }, /* R1984 */ - { 0x0000, 0x0000, 0x0000 }, /* R1985 */ - { 0x0000, 0x0000, 0x0000 }, /* R1986 */ - { 0x0000, 0x0000, 0x0000 }, /* R1987 */ - { 0x0000, 0x0000, 0x0000 }, /* R1988 */ - { 0x0000, 0x0000, 0x0000 }, /* R1989 */ - { 0x0000, 0x0000, 0x0000 }, /* R1990 */ - { 0x0000, 0x0000, 0x0000 }, /* R1991 */ - { 0x0000, 0x0000, 0x0000 }, /* R1992 */ - { 0x0000, 0x0000, 0x0000 }, /* R1993 */ - { 0x0000, 0x0000, 0x0000 }, /* R1994 */ - { 0x0000, 0x0000, 0x0000 }, /* R1995 */ - { 0x0000, 0x0000, 0x0000 }, /* R1996 */ - { 0x0000, 0x0000, 0x0000 }, /* R1997 */ - { 0x0000, 0x0000, 0x0000 }, /* R1998 */ - { 0x0000, 0x0000, 0x0000 }, /* R1999 */ - { 0x0000, 0x0000, 0x0000 }, /* R2000 */ - { 0x0000, 0x0000, 0x0000 }, /* R2001 */ - { 0x0000, 0x0000, 0x0000 }, /* R2002 */ - { 0x0000, 0x0000, 0x0000 }, /* R2003 */ - { 0x0000, 0x0000, 0x0000 }, /* R2004 */ - { 0x0000, 0x0000, 0x0000 }, /* R2005 */ - { 0x0000, 0x0000, 0x0000 }, /* R2006 */ - { 0x0000, 0x0000, 0x0000 }, /* R2007 */ - { 0x0000, 0x0000, 0x0000 }, /* R2008 */ - { 0x0000, 0x0000, 0x0000 }, /* R2009 */ - { 0x0000, 0x0000, 0x0000 }, /* R2010 */ - { 0x0000, 0x0000, 0x0000 }, /* R2011 */ - { 0x0000, 0x0000, 0x0000 }, /* R2012 */ - { 0x0000, 0x0000, 0x0000 }, /* R2013 */ - { 0x0000, 0x0000, 0x0000 }, /* R2014 */ - { 0x0000, 0x0000, 0x0000 }, /* R2015 */ - { 0x0000, 0x0000, 0x0000 }, /* R2016 */ - { 0x0000, 0x0000, 0x0000 }, /* R2017 */ - { 0x0000, 0x0000, 0x0000 }, /* R2018 */ - { 0x0000, 0x0000, 0x0000 }, /* R2019 */ - { 0x0000, 0x0000, 0x0000 }, /* R2020 */ - { 0x0000, 0x0000, 0x0000 }, /* R2021 */ - { 0x0000, 0x0000, 0x0000 }, /* R2022 */ - { 0x0000, 0x0000, 0x0000 }, /* R2023 */ - { 0x0000, 0x0000, 0x0000 }, /* R2024 */ - { 0x0000, 0x0000, 0x0000 }, /* R2025 */ - { 0x0000, 0x0000, 0x0000 }, /* R2026 */ - { 0x0000, 0x0000, 0x0000 }, /* R2027 */ - { 0x0000, 0x0000, 0x0000 }, /* R2028 */ - { 0x0000, 0x0000, 0x0000 }, /* R2029 */ - { 0x0000, 0x0000, 0x0000 }, /* R2030 */ - { 0x0000, 0x0000, 0x0000 }, /* R2031 */ - { 0x0000, 0x0000, 0x0000 }, /* R2032 */ - { 0x0000, 0x0000, 0x0000 }, /* R2033 */ - { 0x0000, 0x0000, 0x0000 }, /* R2034 */ - { 0x0000, 0x0000, 0x0000 }, /* R2035 */ - { 0x0000, 0x0000, 0x0000 }, /* R2036 */ - { 0x0000, 0x0000, 0x0000 }, /* R2037 */ - { 0x0000, 0x0000, 0x0000 }, /* R2038 */ - { 0x0000, 0x0000, 0x0000 }, /* R2039 */ - { 0x0000, 0x0000, 0x0000 }, /* R2040 */ - { 0x0000, 0x0000, 0x0000 }, /* R2041 */ - { 0x0000, 0x0000, 0x0000 }, /* R2042 */ - { 0x0000, 0x0000, 0x0000 }, /* R2043 */ - { 0x0000, 0x0000, 0x0000 }, /* R2044 */ - { 0x0000, 0x0000, 0x0000 }, /* R2045 */ - { 0x0000, 0x0000, 0x0000 }, /* R2046 */ - { 0x0000, 0x0000, 0x0000 }, /* R2047 */ - { 0x0000, 0x0000, 0x0000 }, /* R2048 */ - { 0x0000, 0x0000, 0x0000 }, /* R2049 */ - { 0x0000, 0x0000, 0x0000 }, /* R2050 */ - { 0x0000, 0x0000, 0x0000 }, /* R2051 */ - { 0x0000, 0x0000, 0x0000 }, /* R2052 */ - { 0x0000, 0x0000, 0x0000 }, /* R2053 */ - { 0x0000, 0x0000, 0x0000 }, /* R2054 */ - { 0x0000, 0x0000, 0x0000 }, /* R2055 */ - { 0x0000, 0x0000, 0x0000 }, /* R2056 */ - { 0x0000, 0x0000, 0x0000 }, /* R2057 */ - { 0x0000, 0x0000, 0x0000 }, /* R2058 */ - { 0x0000, 0x0000, 0x0000 }, /* R2059 */ - { 0x0000, 0x0000, 0x0000 }, /* R2060 */ - { 0x0000, 0x0000, 0x0000 }, /* R2061 */ - { 0x0000, 0x0000, 0x0000 }, /* R2062 */ - { 0x0000, 0x0000, 0x0000 }, /* R2063 */ - { 0x0000, 0x0000, 0x0000 }, /* R2064 */ - { 0x0000, 0x0000, 0x0000 }, /* R2065 */ - { 0x0000, 0x0000, 0x0000 }, /* R2066 */ - { 0x0000, 0x0000, 0x0000 }, /* R2067 */ - { 0x0000, 0x0000, 0x0000 }, /* R2068 */ - { 0x0000, 0x0000, 0x0000 }, /* R2069 */ - { 0x0000, 0x0000, 0x0000 }, /* R2070 */ - { 0x0000, 0x0000, 0x0000 }, /* R2071 */ - { 0x0000, 0x0000, 0x0000 }, /* R2072 */ - { 0x0000, 0x0000, 0x0000 }, /* R2073 */ - { 0x0000, 0x0000, 0x0000 }, /* R2074 */ - { 0x0000, 0x0000, 0x0000 }, /* R2075 */ - { 0x0000, 0x0000, 0x0000 }, /* R2076 */ - { 0x0000, 0x0000, 0x0000 }, /* R2077 */ - { 0x0000, 0x0000, 0x0000 }, /* R2078 */ - { 0x0000, 0x0000, 0x0000 }, /* R2079 */ - { 0x0000, 0x0000, 0x0000 }, /* R2080 */ - { 0x0000, 0x0000, 0x0000 }, /* R2081 */ - { 0x0000, 0x0000, 0x0000 }, /* R2082 */ - { 0x0000, 0x0000, 0x0000 }, /* R2083 */ - { 0x0000, 0x0000, 0x0000 }, /* R2084 */ - { 0x0000, 0x0000, 0x0000 }, /* R2085 */ - { 0x0000, 0x0000, 0x0000 }, /* R2086 */ - { 0x0000, 0x0000, 0x0000 }, /* R2087 */ - { 0x0000, 0x0000, 0x0000 }, /* R2088 */ - { 0x0000, 0x0000, 0x0000 }, /* R2089 */ - { 0x0000, 0x0000, 0x0000 }, /* R2090 */ - { 0x0000, 0x0000, 0x0000 }, /* R2091 */ - { 0x0000, 0x0000, 0x0000 }, /* R2092 */ - { 0x0000, 0x0000, 0x0000 }, /* R2093 */ - { 0x0000, 0x0000, 0x0000 }, /* R2094 */ - { 0x0000, 0x0000, 0x0000 }, /* R2095 */ - { 0x0000, 0x0000, 0x0000 }, /* R2096 */ - { 0x0000, 0x0000, 0x0000 }, /* R2097 */ - { 0x0000, 0x0000, 0x0000 }, /* R2098 */ - { 0x0000, 0x0000, 0x0000 }, /* R2099 */ - { 0x0000, 0x0000, 0x0000 }, /* R2100 */ - { 0x0000, 0x0000, 0x0000 }, /* R2101 */ - { 0x0000, 0x0000, 0x0000 }, /* R2102 */ - { 0x0000, 0x0000, 0x0000 }, /* R2103 */ - { 0x0000, 0x0000, 0x0000 }, /* R2104 */ - { 0x0000, 0x0000, 0x0000 }, /* R2105 */ - { 0x0000, 0x0000, 0x0000 }, /* R2106 */ - { 0x0000, 0x0000, 0x0000 }, /* R2107 */ - { 0x0000, 0x0000, 0x0000 }, /* R2108 */ - { 0x0000, 0x0000, 0x0000 }, /* R2109 */ - { 0x0000, 0x0000, 0x0000 }, /* R2110 */ - { 0x0000, 0x0000, 0x0000 }, /* R2111 */ - { 0x0000, 0x0000, 0x0000 }, /* R2112 */ - { 0x0000, 0x0000, 0x0000 }, /* R2113 */ - { 0x0000, 0x0000, 0x0000 }, /* R2114 */ - { 0x0000, 0x0000, 0x0000 }, /* R2115 */ - { 0x0000, 0x0000, 0x0000 }, /* R2116 */ - { 0x0000, 0x0000, 0x0000 }, /* R2117 */ - { 0x0000, 0x0000, 0x0000 }, /* R2118 */ - { 0x0000, 0x0000, 0x0000 }, /* R2119 */ - { 0x0000, 0x0000, 0x0000 }, /* R2120 */ - { 0x0000, 0x0000, 0x0000 }, /* R2121 */ - { 0x0000, 0x0000, 0x0000 }, /* R2122 */ - { 0x0000, 0x0000, 0x0000 }, /* R2123 */ - { 0x0000, 0x0000, 0x0000 }, /* R2124 */ - { 0x0000, 0x0000, 0x0000 }, /* R2125 */ - { 0x0000, 0x0000, 0x0000 }, /* R2126 */ - { 0x0000, 0x0000, 0x0000 }, /* R2127 */ - { 0x0000, 0x0000, 0x0000 }, /* R2128 */ - { 0x0000, 0x0000, 0x0000 }, /* R2129 */ - { 0x0000, 0x0000, 0x0000 }, /* R2130 */ - { 0x0000, 0x0000, 0x0000 }, /* R2131 */ - { 0x0000, 0x0000, 0x0000 }, /* R2132 */ - { 0x0000, 0x0000, 0x0000 }, /* R2133 */ - { 0x0000, 0x0000, 0x0000 }, /* R2134 */ - { 0x0000, 0x0000, 0x0000 }, /* R2135 */ - { 0x0000, 0x0000, 0x0000 }, /* R2136 */ - { 0x0000, 0x0000, 0x0000 }, /* R2137 */ - { 0x0000, 0x0000, 0x0000 }, /* R2138 */ - { 0x0000, 0x0000, 0x0000 }, /* R2139 */ - { 0x0000, 0x0000, 0x0000 }, /* R2140 */ - { 0x0000, 0x0000, 0x0000 }, /* R2141 */ - { 0x0000, 0x0000, 0x0000 }, /* R2142 */ - { 0x0000, 0x0000, 0x0000 }, /* R2143 */ - { 0x0000, 0x0000, 0x0000 }, /* R2144 */ - { 0x0000, 0x0000, 0x0000 }, /* R2145 */ - { 0x0000, 0x0000, 0x0000 }, /* R2146 */ - { 0x0000, 0x0000, 0x0000 }, /* R2147 */ - { 0x0000, 0x0000, 0x0000 }, /* R2148 */ - { 0x0000, 0x0000, 0x0000 }, /* R2149 */ - { 0x0000, 0x0000, 0x0000 }, /* R2150 */ - { 0x0000, 0x0000, 0x0000 }, /* R2151 */ - { 0x0000, 0x0000, 0x0000 }, /* R2152 */ - { 0x0000, 0x0000, 0x0000 }, /* R2153 */ - { 0x0000, 0x0000, 0x0000 }, /* R2154 */ - { 0x0000, 0x0000, 0x0000 }, /* R2155 */ - { 0x0000, 0x0000, 0x0000 }, /* R2156 */ - { 0x0000, 0x0000, 0x0000 }, /* R2157 */ - { 0x0000, 0x0000, 0x0000 }, /* R2158 */ - { 0x0000, 0x0000, 0x0000 }, /* R2159 */ - { 0x0000, 0x0000, 0x0000 }, /* R2160 */ - { 0x0000, 0x0000, 0x0000 }, /* R2161 */ - { 0x0000, 0x0000, 0x0000 }, /* R2162 */ - { 0x0000, 0x0000, 0x0000 }, /* R2163 */ - { 0x0000, 0x0000, 0x0000 }, /* R2164 */ - { 0x0000, 0x0000, 0x0000 }, /* R2165 */ - { 0x0000, 0x0000, 0x0000 }, /* R2166 */ - { 0x0000, 0x0000, 0x0000 }, /* R2167 */ - { 0x0000, 0x0000, 0x0000 }, /* R2168 */ - { 0x0000, 0x0000, 0x0000 }, /* R2169 */ - { 0x0000, 0x0000, 0x0000 }, /* R2170 */ - { 0x0000, 0x0000, 0x0000 }, /* R2171 */ - { 0x0000, 0x0000, 0x0000 }, /* R2172 */ - { 0x0000, 0x0000, 0x0000 }, /* R2173 */ - { 0x0000, 0x0000, 0x0000 }, /* R2174 */ - { 0x0000, 0x0000, 0x0000 }, /* R2175 */ - { 0x0000, 0x0000, 0x0000 }, /* R2176 */ - { 0x0000, 0x0000, 0x0000 }, /* R2177 */ - { 0x0000, 0x0000, 0x0000 }, /* R2178 */ - { 0x0000, 0x0000, 0x0000 }, /* R2179 */ - { 0x0000, 0x0000, 0x0000 }, /* R2180 */ - { 0x0000, 0x0000, 0x0000 }, /* R2181 */ - { 0x0000, 0x0000, 0x0000 }, /* R2182 */ - { 0x0000, 0x0000, 0x0000 }, /* R2183 */ - { 0x0000, 0x0000, 0x0000 }, /* R2184 */ - { 0x0000, 0x0000, 0x0000 }, /* R2185 */ - { 0x0000, 0x0000, 0x0000 }, /* R2186 */ - { 0x0000, 0x0000, 0x0000 }, /* R2187 */ - { 0x0000, 0x0000, 0x0000 }, /* R2188 */ - { 0x0000, 0x0000, 0x0000 }, /* R2189 */ - { 0x0000, 0x0000, 0x0000 }, /* R2190 */ - { 0x0000, 0x0000, 0x0000 }, /* R2191 */ - { 0x0000, 0x0000, 0x0000 }, /* R2192 */ - { 0x0000, 0x0000, 0x0000 }, /* R2193 */ - { 0x0000, 0x0000, 0x0000 }, /* R2194 */ - { 0x0000, 0x0000, 0x0000 }, /* R2195 */ - { 0x0000, 0x0000, 0x0000 }, /* R2196 */ - { 0x0000, 0x0000, 0x0000 }, /* R2197 */ - { 0x0000, 0x0000, 0x0000 }, /* R2198 */ - { 0x0000, 0x0000, 0x0000 }, /* R2199 */ - { 0x0000, 0x0000, 0x0000 }, /* R2200 */ - { 0x0000, 0x0000, 0x0000 }, /* R2201 */ - { 0x0000, 0x0000, 0x0000 }, /* R2202 */ - { 0x0000, 0x0000, 0x0000 }, /* R2203 */ - { 0x0000, 0x0000, 0x0000 }, /* R2204 */ - { 0x0000, 0x0000, 0x0000 }, /* R2205 */ - { 0x0000, 0x0000, 0x0000 }, /* R2206 */ - { 0x0000, 0x0000, 0x0000 }, /* R2207 */ - { 0x0000, 0x0000, 0x0000 }, /* R2208 */ - { 0x0000, 0x0000, 0x0000 }, /* R2209 */ - { 0x0000, 0x0000, 0x0000 }, /* R2210 */ - { 0x0000, 0x0000, 0x0000 }, /* R2211 */ - { 0x0000, 0x0000, 0x0000 }, /* R2212 */ - { 0x0000, 0x0000, 0x0000 }, /* R2213 */ - { 0x0000, 0x0000, 0x0000 }, /* R2214 */ - { 0x0000, 0x0000, 0x0000 }, /* R2215 */ - { 0x0000, 0x0000, 0x0000 }, /* R2216 */ - { 0x0000, 0x0000, 0x0000 }, /* R2217 */ - { 0x0000, 0x0000, 0x0000 }, /* R2218 */ - { 0x0000, 0x0000, 0x0000 }, /* R2219 */ - { 0x0000, 0x0000, 0x0000 }, /* R2220 */ - { 0x0000, 0x0000, 0x0000 }, /* R2221 */ - { 0x0000, 0x0000, 0x0000 }, /* R2222 */ - { 0x0000, 0x0000, 0x0000 }, /* R2223 */ - { 0x0000, 0x0000, 0x0000 }, /* R2224 */ - { 0x0000, 0x0000, 0x0000 }, /* R2225 */ - { 0x0000, 0x0000, 0x0000 }, /* R2226 */ - { 0x0000, 0x0000, 0x0000 }, /* R2227 */ - { 0x0000, 0x0000, 0x0000 }, /* R2228 */ - { 0x0000, 0x0000, 0x0000 }, /* R2229 */ - { 0x0000, 0x0000, 0x0000 }, /* R2230 */ - { 0x0000, 0x0000, 0x0000 }, /* R2231 */ - { 0x0000, 0x0000, 0x0000 }, /* R2232 */ - { 0x0000, 0x0000, 0x0000 }, /* R2233 */ - { 0x0000, 0x0000, 0x0000 }, /* R2234 */ - { 0x0000, 0x0000, 0x0000 }, /* R2235 */ - { 0x0000, 0x0000, 0x0000 }, /* R2236 */ - { 0x0000, 0x0000, 0x0000 }, /* R2237 */ - { 0x0000, 0x0000, 0x0000 }, /* R2238 */ - { 0x0000, 0x0000, 0x0000 }, /* R2239 */ - { 0x0000, 0x0000, 0x0000 }, /* R2240 */ - { 0x0000, 0x0000, 0x0000 }, /* R2241 */ - { 0x0000, 0x0000, 0x0000 }, /* R2242 */ - { 0x0000, 0x0000, 0x0000 }, /* R2243 */ - { 0x0000, 0x0000, 0x0000 }, /* R2244 */ - { 0x0000, 0x0000, 0x0000 }, /* R2245 */ - { 0x0000, 0x0000, 0x0000 }, /* R2246 */ - { 0x0000, 0x0000, 0x0000 }, /* R2247 */ - { 0x0000, 0x0000, 0x0000 }, /* R2248 */ - { 0x0000, 0x0000, 0x0000 }, /* R2249 */ - { 0x0000, 0x0000, 0x0000 }, /* R2250 */ - { 0x0000, 0x0000, 0x0000 }, /* R2251 */ - { 0x0000, 0x0000, 0x0000 }, /* R2252 */ - { 0x0000, 0x0000, 0x0000 }, /* R2253 */ - { 0x0000, 0x0000, 0x0000 }, /* R2254 */ - { 0x0000, 0x0000, 0x0000 }, /* R2255 */ - { 0x0000, 0x0000, 0x0000 }, /* R2256 */ - { 0x0000, 0x0000, 0x0000 }, /* R2257 */ - { 0x0000, 0x0000, 0x0000 }, /* R2258 */ - { 0x0000, 0x0000, 0x0000 }, /* R2259 */ - { 0x0000, 0x0000, 0x0000 }, /* R2260 */ - { 0x0000, 0x0000, 0x0000 }, /* R2261 */ - { 0x0000, 0x0000, 0x0000 }, /* R2262 */ - { 0x0000, 0x0000, 0x0000 }, /* R2263 */ - { 0x0000, 0x0000, 0x0000 }, /* R2264 */ - { 0x0000, 0x0000, 0x0000 }, /* R2265 */ - { 0x0000, 0x0000, 0x0000 }, /* R2266 */ - { 0x0000, 0x0000, 0x0000 }, /* R2267 */ - { 0x0000, 0x0000, 0x0000 }, /* R2268 */ - { 0x0000, 0x0000, 0x0000 }, /* R2269 */ - { 0x0000, 0x0000, 0x0000 }, /* R2270 */ - { 0x0000, 0x0000, 0x0000 }, /* R2271 */ - { 0x0000, 0x0000, 0x0000 }, /* R2272 */ - { 0x0000, 0x0000, 0x0000 }, /* R2273 */ - { 0x0000, 0x0000, 0x0000 }, /* R2274 */ - { 0x0000, 0x0000, 0x0000 }, /* R2275 */ - { 0x0000, 0x0000, 0x0000 }, /* R2276 */ - { 0x0000, 0x0000, 0x0000 }, /* R2277 */ - { 0x0000, 0x0000, 0x0000 }, /* R2278 */ - { 0x0000, 0x0000, 0x0000 }, /* R2279 */ - { 0x0000, 0x0000, 0x0000 }, /* R2280 */ - { 0x0000, 0x0000, 0x0000 }, /* R2281 */ - { 0x0000, 0x0000, 0x0000 }, /* R2282 */ - { 0x0000, 0x0000, 0x0000 }, /* R2283 */ - { 0x0000, 0x0000, 0x0000 }, /* R2284 */ - { 0x0000, 0x0000, 0x0000 }, /* R2285 */ - { 0x0000, 0x0000, 0x0000 }, /* R2286 */ - { 0x0000, 0x0000, 0x0000 }, /* R2287 */ - { 0x0000, 0x0000, 0x0000 }, /* R2288 */ - { 0x0000, 0x0000, 0x0000 }, /* R2289 */ - { 0x0000, 0x0000, 0x0000 }, /* R2290 */ - { 0x0000, 0x0000, 0x0000 }, /* R2291 */ - { 0x0000, 0x0000, 0x0000 }, /* R2292 */ - { 0x0000, 0x0000, 0x0000 }, /* R2293 */ - { 0x0000, 0x0000, 0x0000 }, /* R2294 */ - { 0x0000, 0x0000, 0x0000 }, /* R2295 */ - { 0x0000, 0x0000, 0x0000 }, /* R2296 */ - { 0x0000, 0x0000, 0x0000 }, /* R2297 */ - { 0x0000, 0x0000, 0x0000 }, /* R2298 */ - { 0x0000, 0x0000, 0x0000 }, /* R2299 */ - { 0x0000, 0x0000, 0x0000 }, /* R2300 */ - { 0x0000, 0x0000, 0x0000 }, /* R2301 */ - { 0x0000, 0x0000, 0x0000 }, /* R2302 */ - { 0x0000, 0x0000, 0x0000 }, /* R2303 */ - { 0x0000, 0x0000, 0x0000 }, /* R2304 */ - { 0x0000, 0x0000, 0x0000 }, /* R2305 */ - { 0x0000, 0x0000, 0x0000 }, /* R2306 */ - { 0x0000, 0x0000, 0x0000 }, /* R2307 */ - { 0x0000, 0x0000, 0x0000 }, /* R2308 */ - { 0x0000, 0x0000, 0x0000 }, /* R2309 */ - { 0x0000, 0x0000, 0x0000 }, /* R2310 */ - { 0x0000, 0x0000, 0x0000 }, /* R2311 */ - { 0x0000, 0x0000, 0x0000 }, /* R2312 */ - { 0x0000, 0x0000, 0x0000 }, /* R2313 */ - { 0x0000, 0x0000, 0x0000 }, /* R2314 */ - { 0x0000, 0x0000, 0x0000 }, /* R2315 */ - { 0x0000, 0x0000, 0x0000 }, /* R2316 */ - { 0x0000, 0x0000, 0x0000 }, /* R2317 */ - { 0x0000, 0x0000, 0x0000 }, /* R2318 */ - { 0x0000, 0x0000, 0x0000 }, /* R2319 */ - { 0x0000, 0x0000, 0x0000 }, /* R2320 */ - { 0x0000, 0x0000, 0x0000 }, /* R2321 */ - { 0x0000, 0x0000, 0x0000 }, /* R2322 */ - { 0x0000, 0x0000, 0x0000 }, /* R2323 */ - { 0x0000, 0x0000, 0x0000 }, /* R2324 */ - { 0x0000, 0x0000, 0x0000 }, /* R2325 */ - { 0x0000, 0x0000, 0x0000 }, /* R2326 */ - { 0x0000, 0x0000, 0x0000 }, /* R2327 */ - { 0x0000, 0x0000, 0x0000 }, /* R2328 */ - { 0x0000, 0x0000, 0x0000 }, /* R2329 */ - { 0x0000, 0x0000, 0x0000 }, /* R2330 */ - { 0x0000, 0x0000, 0x0000 }, /* R2331 */ - { 0x0000, 0x0000, 0x0000 }, /* R2332 */ - { 0x0000, 0x0000, 0x0000 }, /* R2333 */ - { 0x0000, 0x0000, 0x0000 }, /* R2334 */ - { 0x0000, 0x0000, 0x0000 }, /* R2335 */ - { 0x0000, 0x0000, 0x0000 }, /* R2336 */ - { 0x0000, 0x0000, 0x0000 }, /* R2337 */ - { 0x0000, 0x0000, 0x0000 }, /* R2338 */ - { 0x0000, 0x0000, 0x0000 }, /* R2339 */ - { 0x0000, 0x0000, 0x0000 }, /* R2340 */ - { 0x0000, 0x0000, 0x0000 }, /* R2341 */ - { 0x0000, 0x0000, 0x0000 }, /* R2342 */ - { 0x0000, 0x0000, 0x0000 }, /* R2343 */ - { 0x0000, 0x0000, 0x0000 }, /* R2344 */ - { 0x0000, 0x0000, 0x0000 }, /* R2345 */ - { 0x0000, 0x0000, 0x0000 }, /* R2346 */ - { 0x0000, 0x0000, 0x0000 }, /* R2347 */ - { 0x0000, 0x0000, 0x0000 }, /* R2348 */ - { 0x0000, 0x0000, 0x0000 }, /* R2349 */ - { 0x0000, 0x0000, 0x0000 }, /* R2350 */ - { 0x0000, 0x0000, 0x0000 }, /* R2351 */ - { 0x0000, 0x0000, 0x0000 }, /* R2352 */ - { 0x0000, 0x0000, 0x0000 }, /* R2353 */ - { 0x0000, 0x0000, 0x0000 }, /* R2354 */ - { 0x0000, 0x0000, 0x0000 }, /* R2355 */ - { 0x0000, 0x0000, 0x0000 }, /* R2356 */ - { 0x0000, 0x0000, 0x0000 }, /* R2357 */ - { 0x0000, 0x0000, 0x0000 }, /* R2358 */ - { 0x0000, 0x0000, 0x0000 }, /* R2359 */ - { 0x0000, 0x0000, 0x0000 }, /* R2360 */ - { 0x0000, 0x0000, 0x0000 }, /* R2361 */ - { 0x0000, 0x0000, 0x0000 }, /* R2362 */ - { 0x0000, 0x0000, 0x0000 }, /* R2363 */ - { 0x0000, 0x0000, 0x0000 }, /* R2364 */ - { 0x0000, 0x0000, 0x0000 }, /* R2365 */ - { 0x0000, 0x0000, 0x0000 }, /* R2366 */ - { 0x0000, 0x0000, 0x0000 }, /* R2367 */ - { 0x0000, 0x0000, 0x0000 }, /* R2368 */ - { 0x0000, 0x0000, 0x0000 }, /* R2369 */ - { 0x0000, 0x0000, 0x0000 }, /* R2370 */ - { 0x0000, 0x0000, 0x0000 }, /* R2371 */ - { 0x0000, 0x0000, 0x0000 }, /* R2372 */ - { 0x0000, 0x0000, 0x0000 }, /* R2373 */ - { 0x0000, 0x0000, 0x0000 }, /* R2374 */ - { 0x0000, 0x0000, 0x0000 }, /* R2375 */ - { 0x0000, 0x0000, 0x0000 }, /* R2376 */ - { 0x0000, 0x0000, 0x0000 }, /* R2377 */ - { 0x0000, 0x0000, 0x0000 }, /* R2378 */ - { 0x0000, 0x0000, 0x0000 }, /* R2379 */ - { 0x0000, 0x0000, 0x0000 }, /* R2380 */ - { 0x0000, 0x0000, 0x0000 }, /* R2381 */ - { 0x0000, 0x0000, 0x0000 }, /* R2382 */ - { 0x0000, 0x0000, 0x0000 }, /* R2383 */ - { 0x0000, 0x0000, 0x0000 }, /* R2384 */ - { 0x0000, 0x0000, 0x0000 }, /* R2385 */ - { 0x0000, 0x0000, 0x0000 }, /* R2386 */ - { 0x0000, 0x0000, 0x0000 }, /* R2387 */ - { 0x0000, 0x0000, 0x0000 }, /* R2388 */ - { 0x0000, 0x0000, 0x0000 }, /* R2389 */ - { 0x0000, 0x0000, 0x0000 }, /* R2390 */ - { 0x0000, 0x0000, 0x0000 }, /* R2391 */ - { 0x0000, 0x0000, 0x0000 }, /* R2392 */ - { 0x0000, 0x0000, 0x0000 }, /* R2393 */ - { 0x0000, 0x0000, 0x0000 }, /* R2394 */ - { 0x0000, 0x0000, 0x0000 }, /* R2395 */ - { 0x0000, 0x0000, 0x0000 }, /* R2396 */ - { 0x0000, 0x0000, 0x0000 }, /* R2397 */ - { 0x0000, 0x0000, 0x0000 }, /* R2398 */ - { 0x0000, 0x0000, 0x0000 }, /* R2399 */ - { 0x0000, 0x0000, 0x0000 }, /* R2400 */ - { 0x0000, 0x0000, 0x0000 }, /* R2401 */ - { 0x0000, 0x0000, 0x0000 }, /* R2402 */ - { 0x0000, 0x0000, 0x0000 }, /* R2403 */ - { 0x0000, 0x0000, 0x0000 }, /* R2404 */ - { 0x0000, 0x0000, 0x0000 }, /* R2405 */ - { 0x0000, 0x0000, 0x0000 }, /* R2406 */ - { 0x0000, 0x0000, 0x0000 }, /* R2407 */ - { 0x0000, 0x0000, 0x0000 }, /* R2408 */ - { 0x0000, 0x0000, 0x0000 }, /* R2409 */ - { 0x0000, 0x0000, 0x0000 }, /* R2410 */ - { 0x0000, 0x0000, 0x0000 }, /* R2411 */ - { 0x0000, 0x0000, 0x0000 }, /* R2412 */ - { 0x0000, 0x0000, 0x0000 }, /* R2413 */ - { 0x0000, 0x0000, 0x0000 }, /* R2414 */ - { 0x0000, 0x0000, 0x0000 }, /* R2415 */ - { 0x0000, 0x0000, 0x0000 }, /* R2416 */ - { 0x0000, 0x0000, 0x0000 }, /* R2417 */ - { 0x0000, 0x0000, 0x0000 }, /* R2418 */ - { 0x0000, 0x0000, 0x0000 }, /* R2419 */ - { 0x0000, 0x0000, 0x0000 }, /* R2420 */ - { 0x0000, 0x0000, 0x0000 }, /* R2421 */ - { 0x0000, 0x0000, 0x0000 }, /* R2422 */ - { 0x0000, 0x0000, 0x0000 }, /* R2423 */ - { 0x0000, 0x0000, 0x0000 }, /* R2424 */ - { 0x0000, 0x0000, 0x0000 }, /* R2425 */ - { 0x0000, 0x0000, 0x0000 }, /* R2426 */ - { 0x0000, 0x0000, 0x0000 }, /* R2427 */ - { 0x0000, 0x0000, 0x0000 }, /* R2428 */ - { 0x0000, 0x0000, 0x0000 }, /* R2429 */ - { 0x0000, 0x0000, 0x0000 }, /* R2430 */ - { 0x0000, 0x0000, 0x0000 }, /* R2431 */ - { 0x0000, 0x0000, 0x0000 }, /* R2432 */ - { 0x0000, 0x0000, 0x0000 }, /* R2433 */ - { 0x0000, 0x0000, 0x0000 }, /* R2434 */ - { 0x0000, 0x0000, 0x0000 }, /* R2435 */ - { 0x0000, 0x0000, 0x0000 }, /* R2436 */ - { 0x0000, 0x0000, 0x0000 }, /* R2437 */ - { 0x0000, 0x0000, 0x0000 }, /* R2438 */ - { 0x0000, 0x0000, 0x0000 }, /* R2439 */ - { 0x0000, 0x0000, 0x0000 }, /* R2440 */ - { 0x0000, 0x0000, 0x0000 }, /* R2441 */ - { 0x0000, 0x0000, 0x0000 }, /* R2442 */ - { 0x0000, 0x0000, 0x0000 }, /* R2443 */ - { 0x0000, 0x0000, 0x0000 }, /* R2444 */ - { 0x0000, 0x0000, 0x0000 }, /* R2445 */ - { 0x0000, 0x0000, 0x0000 }, /* R2446 */ - { 0x0000, 0x0000, 0x0000 }, /* R2447 */ - { 0x0000, 0x0000, 0x0000 }, /* R2448 */ - { 0x0000, 0x0000, 0x0000 }, /* R2449 */ - { 0x0000, 0x0000, 0x0000 }, /* R2450 */ - { 0x0000, 0x0000, 0x0000 }, /* R2451 */ - { 0x0000, 0x0000, 0x0000 }, /* R2452 */ - { 0x0000, 0x0000, 0x0000 }, /* R2453 */ - { 0x0000, 0x0000, 0x0000 }, /* R2454 */ - { 0x0000, 0x0000, 0x0000 }, /* R2455 */ - { 0x0000, 0x0000, 0x0000 }, /* R2456 */ - { 0x0000, 0x0000, 0x0000 }, /* R2457 */ - { 0x0000, 0x0000, 0x0000 }, /* R2458 */ - { 0x0000, 0x0000, 0x0000 }, /* R2459 */ - { 0x0000, 0x0000, 0x0000 }, /* R2460 */ - { 0x0000, 0x0000, 0x0000 }, /* R2461 */ - { 0x0000, 0x0000, 0x0000 }, /* R2462 */ - { 0x0000, 0x0000, 0x0000 }, /* R2463 */ - { 0x0000, 0x0000, 0x0000 }, /* R2464 */ - { 0x0000, 0x0000, 0x0000 }, /* R2465 */ - { 0x0000, 0x0000, 0x0000 }, /* R2466 */ - { 0x0000, 0x0000, 0x0000 }, /* R2467 */ - { 0x0000, 0x0000, 0x0000 }, /* R2468 */ - { 0x0000, 0x0000, 0x0000 }, /* R2469 */ - { 0x0000, 0x0000, 0x0000 }, /* R2470 */ - { 0x0000, 0x0000, 0x0000 }, /* R2471 */ - { 0x0000, 0x0000, 0x0000 }, /* R2472 */ - { 0x0000, 0x0000, 0x0000 }, /* R2473 */ - { 0x0000, 0x0000, 0x0000 }, /* R2474 */ - { 0x0000, 0x0000, 0x0000 }, /* R2475 */ - { 0x0000, 0x0000, 0x0000 }, /* R2476 */ - { 0x0000, 0x0000, 0x0000 }, /* R2477 */ - { 0x0000, 0x0000, 0x0000 }, /* R2478 */ - { 0x0000, 0x0000, 0x0000 }, /* R2479 */ - { 0x0000, 0x0000, 0x0000 }, /* R2480 */ - { 0x0000, 0x0000, 0x0000 }, /* R2481 */ - { 0x0000, 0x0000, 0x0000 }, /* R2482 */ - { 0x0000, 0x0000, 0x0000 }, /* R2483 */ - { 0x0000, 0x0000, 0x0000 }, /* R2484 */ - { 0x0000, 0x0000, 0x0000 }, /* R2485 */ - { 0x0000, 0x0000, 0x0000 }, /* R2486 */ - { 0x0000, 0x0000, 0x0000 }, /* R2487 */ - { 0x0000, 0x0000, 0x0000 }, /* R2488 */ - { 0x0000, 0x0000, 0x0000 }, /* R2489 */ - { 0x0000, 0x0000, 0x0000 }, /* R2490 */ - { 0x0000, 0x0000, 0x0000 }, /* R2491 */ - { 0x0000, 0x0000, 0x0000 }, /* R2492 */ - { 0x0000, 0x0000, 0x0000 }, /* R2493 */ - { 0x0000, 0x0000, 0x0000 }, /* R2494 */ - { 0x0000, 0x0000, 0x0000 }, /* R2495 */ - { 0x0000, 0x0000, 0x0000 }, /* R2496 */ - { 0x0000, 0x0000, 0x0000 }, /* R2497 */ - { 0x0000, 0x0000, 0x0000 }, /* R2498 */ - { 0x0000, 0x0000, 0x0000 }, /* R2499 */ - { 0x0000, 0x0000, 0x0000 }, /* R2500 */ - { 0x0000, 0x0000, 0x0000 }, /* R2501 */ - { 0x0000, 0x0000, 0x0000 }, /* R2502 */ - { 0x0000, 0x0000, 0x0000 }, /* R2503 */ - { 0x0000, 0x0000, 0x0000 }, /* R2504 */ - { 0x0000, 0x0000, 0x0000 }, /* R2505 */ - { 0x0000, 0x0000, 0x0000 }, /* R2506 */ - { 0x0000, 0x0000, 0x0000 }, /* R2507 */ - { 0x0000, 0x0000, 0x0000 }, /* R2508 */ - { 0x0000, 0x0000, 0x0000 }, /* R2509 */ - { 0x0000, 0x0000, 0x0000 }, /* R2510 */ - { 0x0000, 0x0000, 0x0000 }, /* R2511 */ - { 0x0000, 0x0000, 0x0000 }, /* R2512 */ - { 0x0000, 0x0000, 0x0000 }, /* R2513 */ - { 0x0000, 0x0000, 0x0000 }, /* R2514 */ - { 0x0000, 0x0000, 0x0000 }, /* R2515 */ - { 0x0000, 0x0000, 0x0000 }, /* R2516 */ - { 0x0000, 0x0000, 0x0000 }, /* R2517 */ - { 0x0000, 0x0000, 0x0000 }, /* R2518 */ - { 0x0000, 0x0000, 0x0000 }, /* R2519 */ - { 0x0000, 0x0000, 0x0000 }, /* R2520 */ - { 0x0000, 0x0000, 0x0000 }, /* R2521 */ - { 0x0000, 0x0000, 0x0000 }, /* R2522 */ - { 0x0000, 0x0000, 0x0000 }, /* R2523 */ - { 0x0000, 0x0000, 0x0000 }, /* R2524 */ - { 0x0000, 0x0000, 0x0000 }, /* R2525 */ - { 0x0000, 0x0000, 0x0000 }, /* R2526 */ - { 0x0000, 0x0000, 0x0000 }, /* R2527 */ - { 0x0000, 0x0000, 0x0000 }, /* R2528 */ - { 0x0000, 0x0000, 0x0000 }, /* R2529 */ - { 0x0000, 0x0000, 0x0000 }, /* R2530 */ - { 0x0000, 0x0000, 0x0000 }, /* R2531 */ - { 0x0000, 0x0000, 0x0000 }, /* R2532 */ - { 0x0000, 0x0000, 0x0000 }, /* R2533 */ - { 0x0000, 0x0000, 0x0000 }, /* R2534 */ - { 0x0000, 0x0000, 0x0000 }, /* R2535 */ - { 0x0000, 0x0000, 0x0000 }, /* R2536 */ - { 0x0000, 0x0000, 0x0000 }, /* R2537 */ - { 0x0000, 0x0000, 0x0000 }, /* R2538 */ - { 0x0000, 0x0000, 0x0000 }, /* R2539 */ - { 0x0000, 0x0000, 0x0000 }, /* R2540 */ - { 0x0000, 0x0000, 0x0000 }, /* R2541 */ - { 0x0000, 0x0000, 0x0000 }, /* R2542 */ - { 0x0000, 0x0000, 0x0000 }, /* R2543 */ - { 0x0000, 0x0000, 0x0000 }, /* R2544 */ - { 0x0000, 0x0000, 0x0000 }, /* R2545 */ - { 0x0000, 0x0000, 0x0000 }, /* R2546 */ - { 0x0000, 0x0000, 0x0000 }, /* R2547 */ - { 0x0000, 0x0000, 0x0000 }, /* R2548 */ - { 0x0000, 0x0000, 0x0000 }, /* R2549 */ - { 0x0000, 0x0000, 0x0000 }, /* R2550 */ - { 0x0000, 0x0000, 0x0000 }, /* R2551 */ - { 0x0000, 0x0000, 0x0000 }, /* R2552 */ - { 0x0000, 0x0000, 0x0000 }, /* R2553 */ - { 0x0000, 0x0000, 0x0000 }, /* R2554 */ - { 0x0000, 0x0000, 0x0000 }, /* R2555 */ - { 0x0000, 0x0000, 0x0000 }, /* R2556 */ - { 0x0000, 0x0000, 0x0000 }, /* R2557 */ - { 0x0000, 0x0000, 0x0000 }, /* R2558 */ - { 0x0000, 0x0000, 0x0000 }, /* R2559 */ - { 0x0000, 0x0000, 0x0000 }, /* R2560 */ - { 0x0000, 0x0000, 0x0000 }, /* R2561 */ - { 0x0000, 0x0000, 0x0000 }, /* R2562 */ - { 0x0000, 0x0000, 0x0000 }, /* R2563 */ - { 0x0000, 0x0000, 0x0000 }, /* R2564 */ - { 0x0000, 0x0000, 0x0000 }, /* R2565 */ - { 0x0000, 0x0000, 0x0000 }, /* R2566 */ - { 0x0000, 0x0000, 0x0000 }, /* R2567 */ - { 0x0000, 0x0000, 0x0000 }, /* R2568 */ - { 0x0000, 0x0000, 0x0000 }, /* R2569 */ - { 0x0000, 0x0000, 0x0000 }, /* R2570 */ - { 0x0000, 0x0000, 0x0000 }, /* R2571 */ - { 0x0000, 0x0000, 0x0000 }, /* R2572 */ - { 0x0000, 0x0000, 0x0000 }, /* R2573 */ - { 0x0000, 0x0000, 0x0000 }, /* R2574 */ - { 0x0000, 0x0000, 0x0000 }, /* R2575 */ - { 0x0000, 0x0000, 0x0000 }, /* R2576 */ - { 0x0000, 0x0000, 0x0000 }, /* R2577 */ - { 0x0000, 0x0000, 0x0000 }, /* R2578 */ - { 0x0000, 0x0000, 0x0000 }, /* R2579 */ - { 0x0000, 0x0000, 0x0000 }, /* R2580 */ - { 0x0000, 0x0000, 0x0000 }, /* R2581 */ - { 0x0000, 0x0000, 0x0000 }, /* R2582 */ - { 0x0000, 0x0000, 0x0000 }, /* R2583 */ - { 0x0000, 0x0000, 0x0000 }, /* R2584 */ - { 0x0000, 0x0000, 0x0000 }, /* R2585 */ - { 0x0000, 0x0000, 0x0000 }, /* R2586 */ - { 0x0000, 0x0000, 0x0000 }, /* R2587 */ - { 0x0000, 0x0000, 0x0000 }, /* R2588 */ - { 0x0000, 0x0000, 0x0000 }, /* R2589 */ - { 0x0000, 0x0000, 0x0000 }, /* R2590 */ - { 0x0000, 0x0000, 0x0000 }, /* R2591 */ - { 0x0000, 0x0000, 0x0000 }, /* R2592 */ - { 0x0000, 0x0000, 0x0000 }, /* R2593 */ - { 0x0000, 0x0000, 0x0000 }, /* R2594 */ - { 0x0000, 0x0000, 0x0000 }, /* R2595 */ - { 0x0000, 0x0000, 0x0000 }, /* R2596 */ - { 0x0000, 0x0000, 0x0000 }, /* R2597 */ - { 0x0000, 0x0000, 0x0000 }, /* R2598 */ - { 0x0000, 0x0000, 0x0000 }, /* R2599 */ - { 0x0000, 0x0000, 0x0000 }, /* R2600 */ - { 0x0000, 0x0000, 0x0000 }, /* R2601 */ - { 0x0000, 0x0000, 0x0000 }, /* R2602 */ - { 0x0000, 0x0000, 0x0000 }, /* R2603 */ - { 0x0000, 0x0000, 0x0000 }, /* R2604 */ - { 0x0000, 0x0000, 0x0000 }, /* R2605 */ - { 0x0000, 0x0000, 0x0000 }, /* R2606 */ - { 0x0000, 0x0000, 0x0000 }, /* R2607 */ - { 0x0000, 0x0000, 0x0000 }, /* R2608 */ - { 0x0000, 0x0000, 0x0000 }, /* R2609 */ - { 0x0000, 0x0000, 0x0000 }, /* R2610 */ - { 0x0000, 0x0000, 0x0000 }, /* R2611 */ - { 0x0000, 0x0000, 0x0000 }, /* R2612 */ - { 0x0000, 0x0000, 0x0000 }, /* R2613 */ - { 0x0000, 0x0000, 0x0000 }, /* R2614 */ - { 0x0000, 0x0000, 0x0000 }, /* R2615 */ - { 0x0000, 0x0000, 0x0000 }, /* R2616 */ - { 0x0000, 0x0000, 0x0000 }, /* R2617 */ - { 0x0000, 0x0000, 0x0000 }, /* R2618 */ - { 0x0000, 0x0000, 0x0000 }, /* R2619 */ - { 0x0000, 0x0000, 0x0000 }, /* R2620 */ - { 0x0000, 0x0000, 0x0000 }, /* R2621 */ - { 0x0000, 0x0000, 0x0000 }, /* R2622 */ - { 0x0000, 0x0000, 0x0000 }, /* R2623 */ - { 0x0000, 0x0000, 0x0000 }, /* R2624 */ - { 0x0000, 0x0000, 0x0000 }, /* R2625 */ - { 0x0000, 0x0000, 0x0000 }, /* R2626 */ - { 0x0000, 0x0000, 0x0000 }, /* R2627 */ - { 0x0000, 0x0000, 0x0000 }, /* R2628 */ - { 0x0000, 0x0000, 0x0000 }, /* R2629 */ - { 0x0000, 0x0000, 0x0000 }, /* R2630 */ - { 0x0000, 0x0000, 0x0000 }, /* R2631 */ - { 0x0000, 0x0000, 0x0000 }, /* R2632 */ - { 0x0000, 0x0000, 0x0000 }, /* R2633 */ - { 0x0000, 0x0000, 0x0000 }, /* R2634 */ - { 0x0000, 0x0000, 0x0000 }, /* R2635 */ - { 0x0000, 0x0000, 0x0000 }, /* R2636 */ - { 0x0000, 0x0000, 0x0000 }, /* R2637 */ - { 0x0000, 0x0000, 0x0000 }, /* R2638 */ - { 0x0000, 0x0000, 0x0000 }, /* R2639 */ - { 0x0000, 0x0000, 0x0000 }, /* R2640 */ - { 0x0000, 0x0000, 0x0000 }, /* R2641 */ - { 0x0000, 0x0000, 0x0000 }, /* R2642 */ - { 0x0000, 0x0000, 0x0000 }, /* R2643 */ - { 0x0000, 0x0000, 0x0000 }, /* R2644 */ - { 0x0000, 0x0000, 0x0000 }, /* R2645 */ - { 0x0000, 0x0000, 0x0000 }, /* R2646 */ - { 0x0000, 0x0000, 0x0000 }, /* R2647 */ - { 0x0000, 0x0000, 0x0000 }, /* R2648 */ - { 0x0000, 0x0000, 0x0000 }, /* R2649 */ - { 0x0000, 0x0000, 0x0000 }, /* R2650 */ - { 0x0000, 0x0000, 0x0000 }, /* R2651 */ - { 0x0000, 0x0000, 0x0000 }, /* R2652 */ - { 0x0000, 0x0000, 0x0000 }, /* R2653 */ - { 0x0000, 0x0000, 0x0000 }, /* R2654 */ - { 0x0000, 0x0000, 0x0000 }, /* R2655 */ - { 0x0000, 0x0000, 0x0000 }, /* R2656 */ - { 0x0000, 0x0000, 0x0000 }, /* R2657 */ - { 0x0000, 0x0000, 0x0000 }, /* R2658 */ - { 0x0000, 0x0000, 0x0000 }, /* R2659 */ - { 0x0000, 0x0000, 0x0000 }, /* R2660 */ - { 0x0000, 0x0000, 0x0000 }, /* R2661 */ - { 0x0000, 0x0000, 0x0000 }, /* R2662 */ - { 0x0000, 0x0000, 0x0000 }, /* R2663 */ - { 0x0000, 0x0000, 0x0000 }, /* R2664 */ - { 0x0000, 0x0000, 0x0000 }, /* R2665 */ - { 0x0000, 0x0000, 0x0000 }, /* R2666 */ - { 0x0000, 0x0000, 0x0000 }, /* R2667 */ - { 0x0000, 0x0000, 0x0000 }, /* R2668 */ - { 0x0000, 0x0000, 0x0000 }, /* R2669 */ - { 0x0000, 0x0000, 0x0000 }, /* R2670 */ - { 0x0000, 0x0000, 0x0000 }, /* R2671 */ - { 0x0000, 0x0000, 0x0000 }, /* R2672 */ - { 0x0000, 0x0000, 0x0000 }, /* R2673 */ - { 0x0000, 0x0000, 0x0000 }, /* R2674 */ - { 0x0000, 0x0000, 0x0000 }, /* R2675 */ - { 0x0000, 0x0000, 0x0000 }, /* R2676 */ - { 0x0000, 0x0000, 0x0000 }, /* R2677 */ - { 0x0000, 0x0000, 0x0000 }, /* R2678 */ - { 0x0000, 0x0000, 0x0000 }, /* R2679 */ - { 0x0000, 0x0000, 0x0000 }, /* R2680 */ - { 0x0000, 0x0000, 0x0000 }, /* R2681 */ - { 0x0000, 0x0000, 0x0000 }, /* R2682 */ - { 0x0000, 0x0000, 0x0000 }, /* R2683 */ - { 0x0000, 0x0000, 0x0000 }, /* R2684 */ - { 0x0000, 0x0000, 0x0000 }, /* R2685 */ - { 0x0000, 0x0000, 0x0000 }, /* R2686 */ - { 0x0000, 0x0000, 0x0000 }, /* R2687 */ - { 0x0000, 0x0000, 0x0000 }, /* R2688 */ - { 0x0000, 0x0000, 0x0000 }, /* R2689 */ - { 0x0000, 0x0000, 0x0000 }, /* R2690 */ - { 0x0000, 0x0000, 0x0000 }, /* R2691 */ - { 0x0000, 0x0000, 0x0000 }, /* R2692 */ - { 0x0000, 0x0000, 0x0000 }, /* R2693 */ - { 0x0000, 0x0000, 0x0000 }, /* R2694 */ - { 0x0000, 0x0000, 0x0000 }, /* R2695 */ - { 0x0000, 0x0000, 0x0000 }, /* R2696 */ - { 0x0000, 0x0000, 0x0000 }, /* R2697 */ - { 0x0000, 0x0000, 0x0000 }, /* R2698 */ - { 0x0000, 0x0000, 0x0000 }, /* R2699 */ - { 0x0000, 0x0000, 0x0000 }, /* R2700 */ - { 0x0000, 0x0000, 0x0000 }, /* R2701 */ - { 0x0000, 0x0000, 0x0000 }, /* R2702 */ - { 0x0000, 0x0000, 0x0000 }, /* R2703 */ - { 0x0000, 0x0000, 0x0000 }, /* R2704 */ - { 0x0000, 0x0000, 0x0000 }, /* R2705 */ - { 0x0000, 0x0000, 0x0000 }, /* R2706 */ - { 0x0000, 0x0000, 0x0000 }, /* R2707 */ - { 0x0000, 0x0000, 0x0000 }, /* R2708 */ - { 0x0000, 0x0000, 0x0000 }, /* R2709 */ - { 0x0000, 0x0000, 0x0000 }, /* R2710 */ - { 0x0000, 0x0000, 0x0000 }, /* R2711 */ - { 0x0000, 0x0000, 0x0000 }, /* R2712 */ - { 0x0000, 0x0000, 0x0000 }, /* R2713 */ - { 0x0000, 0x0000, 0x0000 }, /* R2714 */ - { 0x0000, 0x0000, 0x0000 }, /* R2715 */ - { 0x0000, 0x0000, 0x0000 }, /* R2716 */ - { 0x0000, 0x0000, 0x0000 }, /* R2717 */ - { 0x0000, 0x0000, 0x0000 }, /* R2718 */ - { 0x0000, 0x0000, 0x0000 }, /* R2719 */ - { 0x0000, 0x0000, 0x0000 }, /* R2720 */ - { 0x0000, 0x0000, 0x0000 }, /* R2721 */ - { 0x0000, 0x0000, 0x0000 }, /* R2722 */ - { 0x0000, 0x0000, 0x0000 }, /* R2723 */ - { 0x0000, 0x0000, 0x0000 }, /* R2724 */ - { 0x0000, 0x0000, 0x0000 }, /* R2725 */ - { 0x0000, 0x0000, 0x0000 }, /* R2726 */ - { 0x0000, 0x0000, 0x0000 }, /* R2727 */ - { 0x0000, 0x0000, 0x0000 }, /* R2728 */ - { 0x0000, 0x0000, 0x0000 }, /* R2729 */ - { 0x0000, 0x0000, 0x0000 }, /* R2730 */ - { 0x0000, 0x0000, 0x0000 }, /* R2731 */ - { 0x0000, 0x0000, 0x0000 }, /* R2732 */ - { 0x0000, 0x0000, 0x0000 }, /* R2733 */ - { 0x0000, 0x0000, 0x0000 }, /* R2734 */ - { 0x0000, 0x0000, 0x0000 }, /* R2735 */ - { 0x0000, 0x0000, 0x0000 }, /* R2736 */ - { 0x0000, 0x0000, 0x0000 }, /* R2737 */ - { 0x0000, 0x0000, 0x0000 }, /* R2738 */ - { 0x0000, 0x0000, 0x0000 }, /* R2739 */ - { 0x0000, 0x0000, 0x0000 }, /* R2740 */ - { 0x0000, 0x0000, 0x0000 }, /* R2741 */ - { 0x0000, 0x0000, 0x0000 }, /* R2742 */ - { 0x0000, 0x0000, 0x0000 }, /* R2743 */ - { 0x0000, 0x0000, 0x0000 }, /* R2744 */ - { 0x0000, 0x0000, 0x0000 }, /* R2745 */ - { 0x0000, 0x0000, 0x0000 }, /* R2746 */ - { 0x0000, 0x0000, 0x0000 }, /* R2747 */ - { 0x0000, 0x0000, 0x0000 }, /* R2748 */ - { 0x0000, 0x0000, 0x0000 }, /* R2749 */ - { 0x0000, 0x0000, 0x0000 }, /* R2750 */ - { 0x0000, 0x0000, 0x0000 }, /* R2751 */ - { 0x0000, 0x0000, 0x0000 }, /* R2752 */ - { 0x0000, 0x0000, 0x0000 }, /* R2753 */ - { 0x0000, 0x0000, 0x0000 }, /* R2754 */ - { 0x0000, 0x0000, 0x0000 }, /* R2755 */ - { 0x0000, 0x0000, 0x0000 }, /* R2756 */ - { 0x0000, 0x0000, 0x0000 }, /* R2757 */ - { 0x0000, 0x0000, 0x0000 }, /* R2758 */ - { 0x0000, 0x0000, 0x0000 }, /* R2759 */ - { 0x0000, 0x0000, 0x0000 }, /* R2760 */ - { 0x0000, 0x0000, 0x0000 }, /* R2761 */ - { 0x0000, 0x0000, 0x0000 }, /* R2762 */ - { 0x0000, 0x0000, 0x0000 }, /* R2763 */ - { 0x0000, 0x0000, 0x0000 }, /* R2764 */ - { 0x0000, 0x0000, 0x0000 }, /* R2765 */ - { 0x0000, 0x0000, 0x0000 }, /* R2766 */ - { 0x0000, 0x0000, 0x0000 }, /* R2767 */ - { 0x0000, 0x0000, 0x0000 }, /* R2768 */ - { 0x0000, 0x0000, 0x0000 }, /* R2769 */ - { 0x0000, 0x0000, 0x0000 }, /* R2770 */ - { 0x0000, 0x0000, 0x0000 }, /* R2771 */ - { 0x0000, 0x0000, 0x0000 }, /* R2772 */ - { 0x0000, 0x0000, 0x0000 }, /* R2773 */ - { 0x0000, 0x0000, 0x0000 }, /* R2774 */ - { 0x0000, 0x0000, 0x0000 }, /* R2775 */ - { 0x0000, 0x0000, 0x0000 }, /* R2776 */ - { 0x0000, 0x0000, 0x0000 }, /* R2777 */ - { 0x0000, 0x0000, 0x0000 }, /* R2778 */ - { 0x0000, 0x0000, 0x0000 }, /* R2779 */ - { 0x0000, 0x0000, 0x0000 }, /* R2780 */ - { 0x0000, 0x0000, 0x0000 }, /* R2781 */ - { 0x0000, 0x0000, 0x0000 }, /* R2782 */ - { 0x0000, 0x0000, 0x0000 }, /* R2783 */ - { 0x0000, 0x0000, 0x0000 }, /* R2784 */ - { 0x0000, 0x0000, 0x0000 }, /* R2785 */ - { 0x0000, 0x0000, 0x0000 }, /* R2786 */ - { 0x0000, 0x0000, 0x0000 }, /* R2787 */ - { 0x0000, 0x0000, 0x0000 }, /* R2788 */ - { 0x0000, 0x0000, 0x0000 }, /* R2789 */ - { 0x0000, 0x0000, 0x0000 }, /* R2790 */ - { 0x0000, 0x0000, 0x0000 }, /* R2791 */ - { 0x0000, 0x0000, 0x0000 }, /* R2792 */ - { 0x0000, 0x0000, 0x0000 }, /* R2793 */ - { 0x0000, 0x0000, 0x0000 }, /* R2794 */ - { 0x0000, 0x0000, 0x0000 }, /* R2795 */ - { 0x0000, 0x0000, 0x0000 }, /* R2796 */ - { 0x0000, 0x0000, 0x0000 }, /* R2797 */ - { 0x0000, 0x0000, 0x0000 }, /* R2798 */ - { 0x0000, 0x0000, 0x0000 }, /* R2799 */ - { 0x0000, 0x0000, 0x0000 }, /* R2800 */ - { 0x0000, 0x0000, 0x0000 }, /* R2801 */ - { 0x0000, 0x0000, 0x0000 }, /* R2802 */ - { 0x0000, 0x0000, 0x0000 }, /* R2803 */ - { 0x0000, 0x0000, 0x0000 }, /* R2804 */ - { 0x0000, 0x0000, 0x0000 }, /* R2805 */ - { 0x0000, 0x0000, 0x0000 }, /* R2806 */ - { 0x0000, 0x0000, 0x0000 }, /* R2807 */ - { 0x0000, 0x0000, 0x0000 }, /* R2808 */ - { 0x0000, 0x0000, 0x0000 }, /* R2809 */ - { 0x0000, 0x0000, 0x0000 }, /* R2810 */ - { 0x0000, 0x0000, 0x0000 }, /* R2811 */ - { 0x0000, 0x0000, 0x0000 }, /* R2812 */ - { 0x0000, 0x0000, 0x0000 }, /* R2813 */ - { 0x0000, 0x0000, 0x0000 }, /* R2814 */ - { 0x0000, 0x0000, 0x0000 }, /* R2815 */ - { 0x0000, 0x0000, 0x0000 }, /* R2816 */ - { 0x0000, 0x0000, 0x0000 }, /* R2817 */ - { 0x0000, 0x0000, 0x0000 }, /* R2818 */ - { 0x0000, 0x0000, 0x0000 }, /* R2819 */ - { 0x0000, 0x0000, 0x0000 }, /* R2820 */ - { 0x0000, 0x0000, 0x0000 }, /* R2821 */ - { 0x0000, 0x0000, 0x0000 }, /* R2822 */ - { 0x0000, 0x0000, 0x0000 }, /* R2823 */ - { 0x0000, 0x0000, 0x0000 }, /* R2824 */ - { 0x0000, 0x0000, 0x0000 }, /* R2825 */ - { 0x0000, 0x0000, 0x0000 }, /* R2826 */ - { 0x0000, 0x0000, 0x0000 }, /* R2827 */ - { 0x0000, 0x0000, 0x0000 }, /* R2828 */ - { 0x0000, 0x0000, 0x0000 }, /* R2829 */ - { 0x0000, 0x0000, 0x0000 }, /* R2830 */ - { 0x0000, 0x0000, 0x0000 }, /* R2831 */ - { 0x0000, 0x0000, 0x0000 }, /* R2832 */ - { 0x0000, 0x0000, 0x0000 }, /* R2833 */ - { 0x0000, 0x0000, 0x0000 }, /* R2834 */ - { 0x0000, 0x0000, 0x0000 }, /* R2835 */ - { 0x0000, 0x0000, 0x0000 }, /* R2836 */ - { 0x0000, 0x0000, 0x0000 }, /* R2837 */ - { 0x0000, 0x0000, 0x0000 }, /* R2838 */ - { 0x0000, 0x0000, 0x0000 }, /* R2839 */ - { 0x0000, 0x0000, 0x0000 }, /* R2840 */ - { 0x0000, 0x0000, 0x0000 }, /* R2841 */ - { 0x0000, 0x0000, 0x0000 }, /* R2842 */ - { 0x0000, 0x0000, 0x0000 }, /* R2843 */ - { 0x0000, 0x0000, 0x0000 }, /* R2844 */ - { 0x0000, 0x0000, 0x0000 }, /* R2845 */ - { 0x0000, 0x0000, 0x0000 }, /* R2846 */ - { 0x0000, 0x0000, 0x0000 }, /* R2847 */ - { 0x0000, 0x0000, 0x0000 }, /* R2848 */ - { 0x0000, 0x0000, 0x0000 }, /* R2849 */ - { 0x0000, 0x0000, 0x0000 }, /* R2850 */ - { 0x0000, 0x0000, 0x0000 }, /* R2851 */ - { 0x0000, 0x0000, 0x0000 }, /* R2852 */ - { 0x0000, 0x0000, 0x0000 }, /* R2853 */ - { 0x0000, 0x0000, 0x0000 }, /* R2854 */ - { 0x0000, 0x0000, 0x0000 }, /* R2855 */ - { 0x0000, 0x0000, 0x0000 }, /* R2856 */ - { 0x0000, 0x0000, 0x0000 }, /* R2857 */ - { 0x0000, 0x0000, 0x0000 }, /* R2858 */ - { 0x0000, 0x0000, 0x0000 }, /* R2859 */ - { 0x0000, 0x0000, 0x0000 }, /* R2860 */ - { 0x0000, 0x0000, 0x0000 }, /* R2861 */ - { 0x0000, 0x0000, 0x0000 }, /* R2862 */ - { 0x0000, 0x0000, 0x0000 }, /* R2863 */ - { 0x0000, 0x0000, 0x0000 }, /* R2864 */ - { 0x0000, 0x0000, 0x0000 }, /* R2865 */ - { 0x0000, 0x0000, 0x0000 }, /* R2866 */ - { 0x0000, 0x0000, 0x0000 }, /* R2867 */ - { 0x0000, 0x0000, 0x0000 }, /* R2868 */ - { 0x0000, 0x0000, 0x0000 }, /* R2869 */ - { 0x0000, 0x0000, 0x0000 }, /* R2870 */ - { 0x0000, 0x0000, 0x0000 }, /* R2871 */ - { 0x0000, 0x0000, 0x0000 }, /* R2872 */ - { 0x0000, 0x0000, 0x0000 }, /* R2873 */ - { 0x0000, 0x0000, 0x0000 }, /* R2874 */ - { 0x0000, 0x0000, 0x0000 }, /* R2875 */ - { 0x0000, 0x0000, 0x0000 }, /* R2876 */ - { 0x0000, 0x0000, 0x0000 }, /* R2877 */ - { 0x0000, 0x0000, 0x0000 }, /* R2878 */ - { 0x0000, 0x0000, 0x0000 }, /* R2879 */ - { 0x0000, 0x0000, 0x0000 }, /* R2880 */ - { 0x0000, 0x0000, 0x0000 }, /* R2881 */ - { 0x0000, 0x0000, 0x0000 }, /* R2882 */ - { 0x0000, 0x0000, 0x0000 }, /* R2883 */ - { 0x0000, 0x0000, 0x0000 }, /* R2884 */ - { 0x0000, 0x0000, 0x0000 }, /* R2885 */ - { 0x0000, 0x0000, 0x0000 }, /* R2886 */ - { 0x0000, 0x0000, 0x0000 }, /* R2887 */ - { 0x0000, 0x0000, 0x0000 }, /* R2888 */ - { 0x0000, 0x0000, 0x0000 }, /* R2889 */ - { 0x0000, 0x0000, 0x0000 }, /* R2890 */ - { 0x0000, 0x0000, 0x0000 }, /* R2891 */ - { 0x0000, 0x0000, 0x0000 }, /* R2892 */ - { 0x0000, 0x0000, 0x0000 }, /* R2893 */ - { 0x0000, 0x0000, 0x0000 }, /* R2894 */ - { 0x0000, 0x0000, 0x0000 }, /* R2895 */ - { 0x0000, 0x0000, 0x0000 }, /* R2896 */ - { 0x0000, 0x0000, 0x0000 }, /* R2897 */ - { 0x0000, 0x0000, 0x0000 }, /* R2898 */ - { 0x0000, 0x0000, 0x0000 }, /* R2899 */ - { 0x0000, 0x0000, 0x0000 }, /* R2900 */ - { 0x0000, 0x0000, 0x0000 }, /* R2901 */ - { 0x0000, 0x0000, 0x0000 }, /* R2902 */ - { 0x0000, 0x0000, 0x0000 }, /* R2903 */ - { 0x0000, 0x0000, 0x0000 }, /* R2904 */ - { 0x0000, 0x0000, 0x0000 }, /* R2905 */ - { 0x0000, 0x0000, 0x0000 }, /* R2906 */ - { 0x0000, 0x0000, 0x0000 }, /* R2907 */ - { 0x0000, 0x0000, 0x0000 }, /* R2908 */ - { 0x0000, 0x0000, 0x0000 }, /* R2909 */ - { 0x0000, 0x0000, 0x0000 }, /* R2910 */ - { 0x0000, 0x0000, 0x0000 }, /* R2911 */ - { 0x0000, 0x0000, 0x0000 }, /* R2912 */ - { 0x0000, 0x0000, 0x0000 }, /* R2913 */ - { 0x0000, 0x0000, 0x0000 }, /* R2914 */ - { 0x0000, 0x0000, 0x0000 }, /* R2915 */ - { 0x0000, 0x0000, 0x0000 }, /* R2916 */ - { 0x0000, 0x0000, 0x0000 }, /* R2917 */ - { 0x0000, 0x0000, 0x0000 }, /* R2918 */ - { 0x0000, 0x0000, 0x0000 }, /* R2919 */ - { 0x0000, 0x0000, 0x0000 }, /* R2920 */ - { 0x0000, 0x0000, 0x0000 }, /* R2921 */ - { 0x0000, 0x0000, 0x0000 }, /* R2922 */ - { 0x0000, 0x0000, 0x0000 }, /* R2923 */ - { 0x0000, 0x0000, 0x0000 }, /* R2924 */ - { 0x0000, 0x0000, 0x0000 }, /* R2925 */ - { 0x0000, 0x0000, 0x0000 }, /* R2926 */ - { 0x0000, 0x0000, 0x0000 }, /* R2927 */ - { 0x0000, 0x0000, 0x0000 }, /* R2928 */ - { 0x0000, 0x0000, 0x0000 }, /* R2929 */ - { 0x0000, 0x0000, 0x0000 }, /* R2930 */ - { 0x0000, 0x0000, 0x0000 }, /* R2931 */ - { 0x0000, 0x0000, 0x0000 }, /* R2932 */ - { 0x0000, 0x0000, 0x0000 }, /* R2933 */ - { 0x0000, 0x0000, 0x0000 }, /* R2934 */ - { 0x0000, 0x0000, 0x0000 }, /* R2935 */ - { 0x0000, 0x0000, 0x0000 }, /* R2936 */ - { 0x0000, 0x0000, 0x0000 }, /* R2937 */ - { 0x0000, 0x0000, 0x0000 }, /* R2938 */ - { 0x0000, 0x0000, 0x0000 }, /* R2939 */ - { 0x0000, 0x0000, 0x0000 }, /* R2940 */ - { 0x0000, 0x0000, 0x0000 }, /* R2941 */ - { 0x0000, 0x0000, 0x0000 }, /* R2942 */ - { 0x0000, 0x0000, 0x0000 }, /* R2943 */ - { 0x0000, 0x0000, 0x0000 }, /* R2944 */ - { 0x0000, 0x0000, 0x0000 }, /* R2945 */ - { 0x0000, 0x0000, 0x0000 }, /* R2946 */ - { 0x0000, 0x0000, 0x0000 }, /* R2947 */ - { 0x0000, 0x0000, 0x0000 }, /* R2948 */ - { 0x0000, 0x0000, 0x0000 }, /* R2949 */ - { 0x0000, 0x0000, 0x0000 }, /* R2950 */ - { 0x0000, 0x0000, 0x0000 }, /* R2951 */ - { 0x0000, 0x0000, 0x0000 }, /* R2952 */ - { 0x0000, 0x0000, 0x0000 }, /* R2953 */ - { 0x0000, 0x0000, 0x0000 }, /* R2954 */ - { 0x0000, 0x0000, 0x0000 }, /* R2955 */ - { 0x0000, 0x0000, 0x0000 }, /* R2956 */ - { 0x0000, 0x0000, 0x0000 }, /* R2957 */ - { 0x0000, 0x0000, 0x0000 }, /* R2958 */ - { 0x0000, 0x0000, 0x0000 }, /* R2959 */ - { 0x0000, 0x0000, 0x0000 }, /* R2960 */ - { 0x0000, 0x0000, 0x0000 }, /* R2961 */ - { 0x0000, 0x0000, 0x0000 }, /* R2962 */ - { 0x0000, 0x0000, 0x0000 }, /* R2963 */ - { 0x0000, 0x0000, 0x0000 }, /* R2964 */ - { 0x0000, 0x0000, 0x0000 }, /* R2965 */ - { 0x0000, 0x0000, 0x0000 }, /* R2966 */ - { 0x0000, 0x0000, 0x0000 }, /* R2967 */ - { 0x0000, 0x0000, 0x0000 }, /* R2968 */ - { 0x0000, 0x0000, 0x0000 }, /* R2969 */ - { 0x0000, 0x0000, 0x0000 }, /* R2970 */ - { 0x0000, 0x0000, 0x0000 }, /* R2971 */ - { 0x0000, 0x0000, 0x0000 }, /* R2972 */ - { 0x0000, 0x0000, 0x0000 }, /* R2973 */ - { 0x0000, 0x0000, 0x0000 }, /* R2974 */ - { 0x0000, 0x0000, 0x0000 }, /* R2975 */ - { 0x0000, 0x0000, 0x0000 }, /* R2976 */ - { 0x0000, 0x0000, 0x0000 }, /* R2977 */ - { 0x0000, 0x0000, 0x0000 }, /* R2978 */ - { 0x0000, 0x0000, 0x0000 }, /* R2979 */ - { 0x0000, 0x0000, 0x0000 }, /* R2980 */ - { 0x0000, 0x0000, 0x0000 }, /* R2981 */ - { 0x0000, 0x0000, 0x0000 }, /* R2982 */ - { 0x0000, 0x0000, 0x0000 }, /* R2983 */ - { 0x0000, 0x0000, 0x0000 }, /* R2984 */ - { 0x0000, 0x0000, 0x0000 }, /* R2985 */ - { 0x0000, 0x0000, 0x0000 }, /* R2986 */ - { 0x0000, 0x0000, 0x0000 }, /* R2987 */ - { 0x0000, 0x0000, 0x0000 }, /* R2988 */ - { 0x0000, 0x0000, 0x0000 }, /* R2989 */ - { 0x0000, 0x0000, 0x0000 }, /* R2990 */ - { 0x0000, 0x0000, 0x0000 }, /* R2991 */ - { 0x0000, 0x0000, 0x0000 }, /* R2992 */ - { 0x0000, 0x0000, 0x0000 }, /* R2993 */ - { 0x0000, 0x0000, 0x0000 }, /* R2994 */ - { 0x0000, 0x0000, 0x0000 }, /* R2995 */ - { 0x0000, 0x0000, 0x0000 }, /* R2996 */ - { 0x0000, 0x0000, 0x0000 }, /* R2997 */ - { 0x0000, 0x0000, 0x0000 }, /* R2998 */ - { 0x0000, 0x0000, 0x0000 }, /* R2999 */ - { 0x0000, 0x0000, 0x0000 }, /* R3000 */ - { 0x0000, 0x0000, 0x0000 }, /* R3001 */ - { 0x0000, 0x0000, 0x0000 }, /* R3002 */ - { 0x0000, 0x0000, 0x0000 }, /* R3003 */ - { 0x0000, 0x0000, 0x0000 }, /* R3004 */ - { 0x0000, 0x0000, 0x0000 }, /* R3005 */ - { 0x0000, 0x0000, 0x0000 }, /* R3006 */ - { 0x0000, 0x0000, 0x0000 }, /* R3007 */ - { 0x0000, 0x0000, 0x0000 }, /* R3008 */ - { 0x0000, 0x0000, 0x0000 }, /* R3009 */ - { 0x0000, 0x0000, 0x0000 }, /* R3010 */ - { 0x0000, 0x0000, 0x0000 }, /* R3011 */ - { 0x0000, 0x0000, 0x0000 }, /* R3012 */ - { 0x0000, 0x0000, 0x0000 }, /* R3013 */ - { 0x0000, 0x0000, 0x0000 }, /* R3014 */ - { 0x0000, 0x0000, 0x0000 }, /* R3015 */ - { 0x0000, 0x0000, 0x0000 }, /* R3016 */ - { 0x0000, 0x0000, 0x0000 }, /* R3017 */ - { 0x0000, 0x0000, 0x0000 }, /* R3018 */ - { 0x0000, 0x0000, 0x0000 }, /* R3019 */ - { 0x0000, 0x0000, 0x0000 }, /* R3020 */ - { 0x0000, 0x0000, 0x0000 }, /* R3021 */ - { 0x0000, 0x0000, 0x0000 }, /* R3022 */ - { 0x0000, 0x0000, 0x0000 }, /* R3023 */ - { 0x0000, 0x0000, 0x0000 }, /* R3024 */ - { 0x0000, 0x0000, 0x0000 }, /* R3025 */ - { 0x0000, 0x0000, 0x0000 }, /* R3026 */ - { 0x0000, 0x0000, 0x0000 }, /* R3027 */ - { 0x0000, 0x0000, 0x0000 }, /* R3028 */ - { 0x0000, 0x0000, 0x0000 }, /* R3029 */ - { 0x0000, 0x0000, 0x0000 }, /* R3030 */ - { 0x0000, 0x0000, 0x0000 }, /* R3031 */ - { 0x0000, 0x0000, 0x0000 }, /* R3032 */ - { 0x0000, 0x0000, 0x0000 }, /* R3033 */ - { 0x0000, 0x0000, 0x0000 }, /* R3034 */ - { 0x0000, 0x0000, 0x0000 }, /* R3035 */ - { 0x0000, 0x0000, 0x0000 }, /* R3036 */ - { 0x0000, 0x0000, 0x0000 }, /* R3037 */ - { 0x0000, 0x0000, 0x0000 }, /* R3038 */ - { 0x0000, 0x0000, 0x0000 }, /* R3039 */ - { 0x0000, 0x0000, 0x0000 }, /* R3040 */ - { 0x0000, 0x0000, 0x0000 }, /* R3041 */ - { 0x0000, 0x0000, 0x0000 }, /* R3042 */ - { 0x0000, 0x0000, 0x0000 }, /* R3043 */ - { 0x0000, 0x0000, 0x0000 }, /* R3044 */ - { 0x0000, 0x0000, 0x0000 }, /* R3045 */ - { 0x0000, 0x0000, 0x0000 }, /* R3046 */ - { 0x0000, 0x0000, 0x0000 }, /* R3047 */ - { 0x0000, 0x0000, 0x0000 }, /* R3048 */ - { 0x0000, 0x0000, 0x0000 }, /* R3049 */ - { 0x0000, 0x0000, 0x0000 }, /* R3050 */ - { 0x0000, 0x0000, 0x0000 }, /* R3051 */ - { 0x0000, 0x0000, 0x0000 }, /* R3052 */ - { 0x0000, 0x0000, 0x0000 }, /* R3053 */ - { 0x0000, 0x0000, 0x0000 }, /* R3054 */ - { 0x0000, 0x0000, 0x0000 }, /* R3055 */ - { 0x0000, 0x0000, 0x0000 }, /* R3056 */ - { 0x0000, 0x0000, 0x0000 }, /* R3057 */ - { 0x0000, 0x0000, 0x0000 }, /* R3058 */ - { 0x0000, 0x0000, 0x0000 }, /* R3059 */ - { 0x0000, 0x0000, 0x0000 }, /* R3060 */ - { 0x0000, 0x0000, 0x0000 }, /* R3061 */ - { 0x0000, 0x0000, 0x0000 }, /* R3062 */ - { 0x0000, 0x0000, 0x0000 }, /* R3063 */ - { 0x0000, 0x0000, 0x0000 }, /* R3064 */ - { 0x0000, 0x0000, 0x0000 }, /* R3065 */ - { 0x0000, 0x0000, 0x0000 }, /* R3066 */ - { 0x0000, 0x0000, 0x0000 }, /* R3067 */ - { 0x0000, 0x0000, 0x0000 }, /* R3068 */ - { 0x0000, 0x0000, 0x0000 }, /* R3069 */ - { 0x0000, 0x0000, 0x0000 }, /* R3070 */ - { 0x0000, 0x0000, 0x0000 }, /* R3071 */ - { 0x0000, 0x0000, 0x0000 }, /* R3072 */ - { 0x0000, 0x0000, 0x0000 }, /* R3073 */ - { 0x0000, 0x0000, 0x0000 }, /* R3074 */ - { 0x0000, 0x0000, 0x0000 }, /* R3075 */ - { 0x0000, 0x0000, 0x0000 }, /* R3076 */ - { 0x0000, 0x0000, 0x0000 }, /* R3077 */ - { 0x0000, 0x0000, 0x0000 }, /* R3078 */ - { 0x0000, 0x0000, 0x0000 }, /* R3079 */ - { 0x0000, 0x0000, 0x0000 }, /* R3080 */ - { 0x0000, 0x0000, 0x0000 }, /* R3081 */ - { 0x0000, 0x0000, 0x0000 }, /* R3082 */ - { 0x0000, 0x0000, 0x0000 }, /* R3083 */ - { 0x0000, 0x0000, 0x0000 }, /* R3084 */ - { 0x0000, 0x0000, 0x0000 }, /* R3085 */ - { 0x0000, 0x0000, 0x0000 }, /* R3086 */ - { 0x0000, 0x0000, 0x0000 }, /* R3087 */ - { 0x0000, 0x0000, 0x0000 }, /* R3088 */ - { 0x0000, 0x0000, 0x0000 }, /* R3089 */ - { 0x0000, 0x0000, 0x0000 }, /* R3090 */ - { 0x0000, 0x0000, 0x0000 }, /* R3091 */ - { 0x0000, 0x0000, 0x0000 }, /* R3092 */ - { 0x0000, 0x0000, 0x0000 }, /* R3093 */ - { 0x0000, 0x0000, 0x0000 }, /* R3094 */ - { 0x0000, 0x0000, 0x0000 }, /* R3095 */ - { 0x0000, 0x0000, 0x0000 }, /* R3096 */ - { 0x0000, 0x0000, 0x0000 }, /* R3097 */ - { 0x0000, 0x0000, 0x0000 }, /* R3098 */ - { 0x0000, 0x0000, 0x0000 }, /* R3099 */ - { 0x0000, 0x0000, 0x0000 }, /* R3100 */ - { 0x0000, 0x0000, 0x0000 }, /* R3101 */ - { 0x0000, 0x0000, 0x0000 }, /* R3102 */ - { 0x0000, 0x0000, 0x0000 }, /* R3103 */ - { 0x0000, 0x0000, 0x0000 }, /* R3104 */ - { 0x0000, 0x0000, 0x0000 }, /* R3105 */ - { 0x0000, 0x0000, 0x0000 }, /* R3106 */ - { 0x0000, 0x0000, 0x0000 }, /* R3107 */ - { 0x0000, 0x0000, 0x0000 }, /* R3108 */ - { 0x0000, 0x0000, 0x0000 }, /* R3109 */ - { 0x0000, 0x0000, 0x0000 }, /* R3110 */ - { 0x0000, 0x0000, 0x0000 }, /* R3111 */ - { 0x0000, 0x0000, 0x0000 }, /* R3112 */ - { 0x0000, 0x0000, 0x0000 }, /* R3113 */ - { 0x0000, 0x0000, 0x0000 }, /* R3114 */ - { 0x0000, 0x0000, 0x0000 }, /* R3115 */ - { 0x0000, 0x0000, 0x0000 }, /* R3116 */ - { 0x0000, 0x0000, 0x0000 }, /* R3117 */ - { 0x0000, 0x0000, 0x0000 }, /* R3118 */ - { 0x0000, 0x0000, 0x0000 }, /* R3119 */ - { 0x0000, 0x0000, 0x0000 }, /* R3120 */ - { 0x0000, 0x0000, 0x0000 }, /* R3121 */ - { 0x0000, 0x0000, 0x0000 }, /* R3122 */ - { 0x0000, 0x0000, 0x0000 }, /* R3123 */ - { 0x0000, 0x0000, 0x0000 }, /* R3124 */ - { 0x0000, 0x0000, 0x0000 }, /* R3125 */ - { 0x0000, 0x0000, 0x0000 }, /* R3126 */ - { 0x0000, 0x0000, 0x0000 }, /* R3127 */ - { 0x0000, 0x0000, 0x0000 }, /* R3128 */ - { 0x0000, 0x0000, 0x0000 }, /* R3129 */ - { 0x0000, 0x0000, 0x0000 }, /* R3130 */ - { 0x0000, 0x0000, 0x0000 }, /* R3131 */ - { 0x0000, 0x0000, 0x0000 }, /* R3132 */ - { 0x0000, 0x0000, 0x0000 }, /* R3133 */ - { 0x0000, 0x0000, 0x0000 }, /* R3134 */ - { 0x0000, 0x0000, 0x0000 }, /* R3135 */ - { 0x0000, 0x0000, 0x0000 }, /* R3136 */ - { 0x0000, 0x0000, 0x0000 }, /* R3137 */ - { 0x0000, 0x0000, 0x0000 }, /* R3138 */ - { 0x0000, 0x0000, 0x0000 }, /* R3139 */ - { 0x0000, 0x0000, 0x0000 }, /* R3140 */ - { 0x0000, 0x0000, 0x0000 }, /* R3141 */ - { 0x0000, 0x0000, 0x0000 }, /* R3142 */ - { 0x0000, 0x0000, 0x0000 }, /* R3143 */ - { 0x0000, 0x0000, 0x0000 }, /* R3144 */ - { 0x0000, 0x0000, 0x0000 }, /* R3145 */ - { 0x0000, 0x0000, 0x0000 }, /* R3146 */ - { 0x0000, 0x0000, 0x0000 }, /* R3147 */ - { 0x0000, 0x0000, 0x0000 }, /* R3148 */ - { 0x0000, 0x0000, 0x0000 }, /* R3149 */ - { 0x0000, 0x0000, 0x0000 }, /* R3150 */ - { 0x0000, 0x0000, 0x0000 }, /* R3151 */ - { 0x0000, 0x0000, 0x0000 }, /* R3152 */ - { 0x0000, 0x0000, 0x0000 }, /* R3153 */ - { 0x0000, 0x0000, 0x0000 }, /* R3154 */ - { 0x0000, 0x0000, 0x0000 }, /* R3155 */ - { 0x0000, 0x0000, 0x0000 }, /* R3156 */ - { 0x0000, 0x0000, 0x0000 }, /* R3157 */ - { 0x0000, 0x0000, 0x0000 }, /* R3158 */ - { 0x0000, 0x0000, 0x0000 }, /* R3159 */ - { 0x0000, 0x0000, 0x0000 }, /* R3160 */ - { 0x0000, 0x0000, 0x0000 }, /* R3161 */ - { 0x0000, 0x0000, 0x0000 }, /* R3162 */ - { 0x0000, 0x0000, 0x0000 }, /* R3163 */ - { 0x0000, 0x0000, 0x0000 }, /* R3164 */ - { 0x0000, 0x0000, 0x0000 }, /* R3165 */ - { 0x0000, 0x0000, 0x0000 }, /* R3166 */ - { 0x0000, 0x0000, 0x0000 }, /* R3167 */ - { 0x0000, 0x0000, 0x0000 }, /* R3168 */ - { 0x0000, 0x0000, 0x0000 }, /* R3169 */ - { 0x0000, 0x0000, 0x0000 }, /* R3170 */ - { 0x0000, 0x0000, 0x0000 }, /* R3171 */ - { 0x0000, 0x0000, 0x0000 }, /* R3172 */ - { 0x0000, 0x0000, 0x0000 }, /* R3173 */ - { 0x0000, 0x0000, 0x0000 }, /* R3174 */ - { 0x0000, 0x0000, 0x0000 }, /* R3175 */ - { 0x0000, 0x0000, 0x0000 }, /* R3176 */ - { 0x0000, 0x0000, 0x0000 }, /* R3177 */ - { 0x0000, 0x0000, 0x0000 }, /* R3178 */ - { 0x0000, 0x0000, 0x0000 }, /* R3179 */ - { 0x0000, 0x0000, 0x0000 }, /* R3180 */ - { 0x0000, 0x0000, 0x0000 }, /* R3181 */ - { 0x0000, 0x0000, 0x0000 }, /* R3182 */ - { 0x0000, 0x0000, 0x0000 }, /* R3183 */ - { 0x0000, 0x0000, 0x0000 }, /* R3184 */ - { 0x0000, 0x0000, 0x0000 }, /* R3185 */ - { 0x0000, 0x0000, 0x0000 }, /* R3186 */ - { 0x0000, 0x0000, 0x0000 }, /* R3187 */ - { 0x0000, 0x0000, 0x0000 }, /* R3188 */ - { 0x0000, 0x0000, 0x0000 }, /* R3189 */ - { 0x0000, 0x0000, 0x0000 }, /* R3190 */ - { 0x0000, 0x0000, 0x0000 }, /* R3191 */ - { 0x0000, 0x0000, 0x0000 }, /* R3192 */ - { 0x0000, 0x0000, 0x0000 }, /* R3193 */ - { 0x0000, 0x0000, 0x0000 }, /* R3194 */ - { 0x0000, 0x0000, 0x0000 }, /* R3195 */ - { 0x0000, 0x0000, 0x0000 }, /* R3196 */ - { 0x0000, 0x0000, 0x0000 }, /* R3197 */ - { 0x0000, 0x0000, 0x0000 }, /* R3198 */ - { 0x0000, 0x0000, 0x0000 }, /* R3199 */ - { 0x0000, 0x0000, 0x0000 }, /* R3200 */ - { 0x0000, 0x0000, 0x0000 }, /* R3201 */ - { 0x0000, 0x0000, 0x0000 }, /* R3202 */ - { 0x0000, 0x0000, 0x0000 }, /* R3203 */ - { 0x0000, 0x0000, 0x0000 }, /* R3204 */ - { 0x0000, 0x0000, 0x0000 }, /* R3205 */ - { 0x0000, 0x0000, 0x0000 }, /* R3206 */ - { 0x0000, 0x0000, 0x0000 }, /* R3207 */ - { 0x0000, 0x0000, 0x0000 }, /* R3208 */ - { 0x0000, 0x0000, 0x0000 }, /* R3209 */ - { 0x0000, 0x0000, 0x0000 }, /* R3210 */ - { 0x0000, 0x0000, 0x0000 }, /* R3211 */ - { 0x0000, 0x0000, 0x0000 }, /* R3212 */ - { 0x0000, 0x0000, 0x0000 }, /* R3213 */ - { 0x0000, 0x0000, 0x0000 }, /* R3214 */ - { 0x0000, 0x0000, 0x0000 }, /* R3215 */ - { 0x0000, 0x0000, 0x0000 }, /* R3216 */ - { 0x0000, 0x0000, 0x0000 }, /* R3217 */ - { 0x0000, 0x0000, 0x0000 }, /* R3218 */ - { 0x0000, 0x0000, 0x0000 }, /* R3219 */ - { 0x0000, 0x0000, 0x0000 }, /* R3220 */ - { 0x0000, 0x0000, 0x0000 }, /* R3221 */ - { 0x0000, 0x0000, 0x0000 }, /* R3222 */ - { 0x0000, 0x0000, 0x0000 }, /* R3223 */ - { 0x0000, 0x0000, 0x0000 }, /* R3224 */ - { 0x0000, 0x0000, 0x0000 }, /* R3225 */ - { 0x0000, 0x0000, 0x0000 }, /* R3226 */ - { 0x0000, 0x0000, 0x0000 }, /* R3227 */ - { 0x0000, 0x0000, 0x0000 }, /* R3228 */ - { 0x0000, 0x0000, 0x0000 }, /* R3229 */ - { 0x0000, 0x0000, 0x0000 }, /* R3230 */ - { 0x0000, 0x0000, 0x0000 }, /* R3231 */ - { 0x0000, 0x0000, 0x0000 }, /* R3232 */ - { 0x0000, 0x0000, 0x0000 }, /* R3233 */ - { 0x0000, 0x0000, 0x0000 }, /* R3234 */ - { 0x0000, 0x0000, 0x0000 }, /* R3235 */ - { 0x0000, 0x0000, 0x0000 }, /* R3236 */ - { 0x0000, 0x0000, 0x0000 }, /* R3237 */ - { 0x0000, 0x0000, 0x0000 }, /* R3238 */ - { 0x0000, 0x0000, 0x0000 }, /* R3239 */ - { 0x0000, 0x0000, 0x0000 }, /* R3240 */ - { 0x0000, 0x0000, 0x0000 }, /* R3241 */ - { 0x0000, 0x0000, 0x0000 }, /* R3242 */ - { 0x0000, 0x0000, 0x0000 }, /* R3243 */ - { 0x0000, 0x0000, 0x0000 }, /* R3244 */ - { 0x0000, 0x0000, 0x0000 }, /* R3245 */ - { 0x0000, 0x0000, 0x0000 }, /* R3246 */ - { 0x0000, 0x0000, 0x0000 }, /* R3247 */ - { 0x0000, 0x0000, 0x0000 }, /* R3248 */ - { 0x0000, 0x0000, 0x0000 }, /* R3249 */ - { 0x0000, 0x0000, 0x0000 }, /* R3250 */ - { 0x0000, 0x0000, 0x0000 }, /* R3251 */ - { 0x0000, 0x0000, 0x0000 }, /* R3252 */ - { 0x0000, 0x0000, 0x0000 }, /* R3253 */ - { 0x0000, 0x0000, 0x0000 }, /* R3254 */ - { 0x0000, 0x0000, 0x0000 }, /* R3255 */ - { 0x0000, 0x0000, 0x0000 }, /* R3256 */ - { 0x0000, 0x0000, 0x0000 }, /* R3257 */ - { 0x0000, 0x0000, 0x0000 }, /* R3258 */ - { 0x0000, 0x0000, 0x0000 }, /* R3259 */ - { 0x0000, 0x0000, 0x0000 }, /* R3260 */ - { 0x0000, 0x0000, 0x0000 }, /* R3261 */ - { 0x0000, 0x0000, 0x0000 }, /* R3262 */ - { 0x0000, 0x0000, 0x0000 }, /* R3263 */ - { 0x0000, 0x0000, 0x0000 }, /* R3264 */ - { 0x0000, 0x0000, 0x0000 }, /* R3265 */ - { 0x0000, 0x0000, 0x0000 }, /* R3266 */ - { 0x0000, 0x0000, 0x0000 }, /* R3267 */ - { 0x0000, 0x0000, 0x0000 }, /* R3268 */ - { 0x0000, 0x0000, 0x0000 }, /* R3269 */ - { 0x0000, 0x0000, 0x0000 }, /* R3270 */ - { 0x0000, 0x0000, 0x0000 }, /* R3271 */ - { 0x0000, 0x0000, 0x0000 }, /* R3272 */ - { 0x0000, 0x0000, 0x0000 }, /* R3273 */ - { 0x0000, 0x0000, 0x0000 }, /* R3274 */ - { 0x0000, 0x0000, 0x0000 }, /* R3275 */ - { 0x0000, 0x0000, 0x0000 }, /* R3276 */ - { 0x0000, 0x0000, 0x0000 }, /* R3277 */ - { 0x0000, 0x0000, 0x0000 }, /* R3278 */ - { 0x0000, 0x0000, 0x0000 }, /* R3279 */ - { 0x0000, 0x0000, 0x0000 }, /* R3280 */ - { 0x0000, 0x0000, 0x0000 }, /* R3281 */ - { 0x0000, 0x0000, 0x0000 }, /* R3282 */ - { 0x0000, 0x0000, 0x0000 }, /* R3283 */ - { 0x0000, 0x0000, 0x0000 }, /* R3284 */ - { 0x0000, 0x0000, 0x0000 }, /* R3285 */ - { 0x0000, 0x0000, 0x0000 }, /* R3286 */ - { 0x0000, 0x0000, 0x0000 }, /* R3287 */ - { 0x0000, 0x0000, 0x0000 }, /* R3288 */ - { 0x0000, 0x0000, 0x0000 }, /* R3289 */ - { 0x0000, 0x0000, 0x0000 }, /* R3290 */ - { 0x0000, 0x0000, 0x0000 }, /* R3291 */ - { 0x0000, 0x0000, 0x0000 }, /* R3292 */ - { 0x0000, 0x0000, 0x0000 }, /* R3293 */ - { 0x0000, 0x0000, 0x0000 }, /* R3294 */ - { 0x0000, 0x0000, 0x0000 }, /* R3295 */ - { 0x0000, 0x0000, 0x0000 }, /* R3296 */ - { 0x0000, 0x0000, 0x0000 }, /* R3297 */ - { 0x0000, 0x0000, 0x0000 }, /* R3298 */ - { 0x0000, 0x0000, 0x0000 }, /* R3299 */ - { 0x0000, 0x0000, 0x0000 }, /* R3300 */ - { 0x0000, 0x0000, 0x0000 }, /* R3301 */ - { 0x0000, 0x0000, 0x0000 }, /* R3302 */ - { 0x0000, 0x0000, 0x0000 }, /* R3303 */ - { 0x0000, 0x0000, 0x0000 }, /* R3304 */ - { 0x0000, 0x0000, 0x0000 }, /* R3305 */ - { 0x0000, 0x0000, 0x0000 }, /* R3306 */ - { 0x0000, 0x0000, 0x0000 }, /* R3307 */ - { 0x0000, 0x0000, 0x0000 }, /* R3308 */ - { 0x0000, 0x0000, 0x0000 }, /* R3309 */ - { 0x0000, 0x0000, 0x0000 }, /* R3310 */ - { 0x0000, 0x0000, 0x0000 }, /* R3311 */ - { 0x0000, 0x0000, 0x0000 }, /* R3312 */ - { 0x0000, 0x0000, 0x0000 }, /* R3313 */ - { 0x0000, 0x0000, 0x0000 }, /* R3314 */ - { 0x0000, 0x0000, 0x0000 }, /* R3315 */ - { 0x0000, 0x0000, 0x0000 }, /* R3316 */ - { 0x0000, 0x0000, 0x0000 }, /* R3317 */ - { 0x0000, 0x0000, 0x0000 }, /* R3318 */ - { 0x0000, 0x0000, 0x0000 }, /* R3319 */ - { 0x0000, 0x0000, 0x0000 }, /* R3320 */ - { 0x0000, 0x0000, 0x0000 }, /* R3321 */ - { 0x0000, 0x0000, 0x0000 }, /* R3322 */ - { 0x0000, 0x0000, 0x0000 }, /* R3323 */ - { 0x0000, 0x0000, 0x0000 }, /* R3324 */ - { 0x0000, 0x0000, 0x0000 }, /* R3325 */ - { 0x0000, 0x0000, 0x0000 }, /* R3326 */ - { 0x0000, 0x0000, 0x0000 }, /* R3327 */ - { 0x0000, 0x0000, 0x0000 }, /* R3328 */ - { 0x0000, 0x0000, 0x0000 }, /* R3329 */ - { 0x0000, 0x0000, 0x0000 }, /* R3330 */ - { 0x0000, 0x0000, 0x0000 }, /* R3331 */ - { 0x0000, 0x0000, 0x0000 }, /* R3332 */ - { 0x0000, 0x0000, 0x0000 }, /* R3333 */ - { 0x0000, 0x0000, 0x0000 }, /* R3334 */ - { 0x0000, 0x0000, 0x0000 }, /* R3335 */ - { 0x0000, 0x0000, 0x0000 }, /* R3336 */ - { 0x0000, 0x0000, 0x0000 }, /* R3337 */ - { 0x0000, 0x0000, 0x0000 }, /* R3338 */ - { 0x0000, 0x0000, 0x0000 }, /* R3339 */ - { 0x0000, 0x0000, 0x0000 }, /* R3340 */ - { 0x0000, 0x0000, 0x0000 }, /* R3341 */ - { 0x0000, 0x0000, 0x0000 }, /* R3342 */ - { 0x0000, 0x0000, 0x0000 }, /* R3343 */ - { 0x0000, 0x0000, 0x0000 }, /* R3344 */ - { 0x0000, 0x0000, 0x0000 }, /* R3345 */ - { 0x0000, 0x0000, 0x0000 }, /* R3346 */ - { 0x0000, 0x0000, 0x0000 }, /* R3347 */ - { 0x0000, 0x0000, 0x0000 }, /* R3348 */ - { 0x0000, 0x0000, 0x0000 }, /* R3349 */ - { 0x0000, 0x0000, 0x0000 }, /* R3350 */ - { 0x0000, 0x0000, 0x0000 }, /* R3351 */ - { 0x0000, 0x0000, 0x0000 }, /* R3352 */ - { 0x0000, 0x0000, 0x0000 }, /* R3353 */ - { 0x0000, 0x0000, 0x0000 }, /* R3354 */ - { 0x0000, 0x0000, 0x0000 }, /* R3355 */ - { 0x0000, 0x0000, 0x0000 }, /* R3356 */ - { 0x0000, 0x0000, 0x0000 }, /* R3357 */ - { 0x0000, 0x0000, 0x0000 }, /* R3358 */ - { 0x0000, 0x0000, 0x0000 }, /* R3359 */ - { 0x0000, 0x0000, 0x0000 }, /* R3360 */ - { 0x0000, 0x0000, 0x0000 }, /* R3361 */ - { 0x0000, 0x0000, 0x0000 }, /* R3362 */ - { 0x0000, 0x0000, 0x0000 }, /* R3363 */ - { 0x0000, 0x0000, 0x0000 }, /* R3364 */ - { 0x0000, 0x0000, 0x0000 }, /* R3365 */ - { 0x0000, 0x0000, 0x0000 }, /* R3366 */ - { 0x0000, 0x0000, 0x0000 }, /* R3367 */ - { 0x0000, 0x0000, 0x0000 }, /* R3368 */ - { 0x0000, 0x0000, 0x0000 }, /* R3369 */ - { 0x0000, 0x0000, 0x0000 }, /* R3370 */ - { 0x0000, 0x0000, 0x0000 }, /* R3371 */ - { 0x0000, 0x0000, 0x0000 }, /* R3372 */ - { 0x0000, 0x0000, 0x0000 }, /* R3373 */ - { 0x0000, 0x0000, 0x0000 }, /* R3374 */ - { 0x0000, 0x0000, 0x0000 }, /* R3375 */ - { 0x0000, 0x0000, 0x0000 }, /* R3376 */ - { 0x0000, 0x0000, 0x0000 }, /* R3377 */ - { 0x0000, 0x0000, 0x0000 }, /* R3378 */ - { 0x0000, 0x0000, 0x0000 }, /* R3379 */ - { 0x0000, 0x0000, 0x0000 }, /* R3380 */ - { 0x0000, 0x0000, 0x0000 }, /* R3381 */ - { 0x0000, 0x0000, 0x0000 }, /* R3382 */ - { 0x0000, 0x0000, 0x0000 }, /* R3383 */ - { 0x0000, 0x0000, 0x0000 }, /* R3384 */ - { 0x0000, 0x0000, 0x0000 }, /* R3385 */ - { 0x0000, 0x0000, 0x0000 }, /* R3386 */ - { 0x0000, 0x0000, 0x0000 }, /* R3387 */ - { 0x0000, 0x0000, 0x0000 }, /* R3388 */ - { 0x0000, 0x0000, 0x0000 }, /* R3389 */ - { 0x0000, 0x0000, 0x0000 }, /* R3390 */ - { 0x0000, 0x0000, 0x0000 }, /* R3391 */ - { 0x0000, 0x0000, 0x0000 }, /* R3392 */ - { 0x0000, 0x0000, 0x0000 }, /* R3393 */ - { 0x0000, 0x0000, 0x0000 }, /* R3394 */ - { 0x0000, 0x0000, 0x0000 }, /* R3395 */ - { 0x0000, 0x0000, 0x0000 }, /* R3396 */ - { 0x0000, 0x0000, 0x0000 }, /* R3397 */ - { 0x0000, 0x0000, 0x0000 }, /* R3398 */ - { 0x0000, 0x0000, 0x0000 }, /* R3399 */ - { 0x0000, 0x0000, 0x0000 }, /* R3400 */ - { 0x0000, 0x0000, 0x0000 }, /* R3401 */ - { 0x0000, 0x0000, 0x0000 }, /* R3402 */ - { 0x0000, 0x0000, 0x0000 }, /* R3403 */ - { 0x0000, 0x0000, 0x0000 }, /* R3404 */ - { 0x0000, 0x0000, 0x0000 }, /* R3405 */ - { 0x0000, 0x0000, 0x0000 }, /* R3406 */ - { 0x0000, 0x0000, 0x0000 }, /* R3407 */ - { 0x0000, 0x0000, 0x0000 }, /* R3408 */ - { 0x0000, 0x0000, 0x0000 }, /* R3409 */ - { 0x0000, 0x0000, 0x0000 }, /* R3410 */ - { 0x0000, 0x0000, 0x0000 }, /* R3411 */ - { 0x0000, 0x0000, 0x0000 }, /* R3412 */ - { 0x0000, 0x0000, 0x0000 }, /* R3413 */ - { 0x0000, 0x0000, 0x0000 }, /* R3414 */ - { 0x0000, 0x0000, 0x0000 }, /* R3415 */ - { 0x0000, 0x0000, 0x0000 }, /* R3416 */ - { 0x0000, 0x0000, 0x0000 }, /* R3417 */ - { 0x0000, 0x0000, 0x0000 }, /* R3418 */ - { 0x0000, 0x0000, 0x0000 }, /* R3419 */ - { 0x0000, 0x0000, 0x0000 }, /* R3420 */ - { 0x0000, 0x0000, 0x0000 }, /* R3421 */ - { 0x0000, 0x0000, 0x0000 }, /* R3422 */ - { 0x0000, 0x0000, 0x0000 }, /* R3423 */ - { 0x0000, 0x0000, 0x0000 }, /* R3424 */ - { 0x0000, 0x0000, 0x0000 }, /* R3425 */ - { 0x0000, 0x0000, 0x0000 }, /* R3426 */ - { 0x0000, 0x0000, 0x0000 }, /* R3427 */ - { 0x0000, 0x0000, 0x0000 }, /* R3428 */ - { 0x0000, 0x0000, 0x0000 }, /* R3429 */ - { 0x0000, 0x0000, 0x0000 }, /* R3430 */ - { 0x0000, 0x0000, 0x0000 }, /* R3431 */ - { 0x0000, 0x0000, 0x0000 }, /* R3432 */ - { 0x0000, 0x0000, 0x0000 }, /* R3433 */ - { 0x0000, 0x0000, 0x0000 }, /* R3434 */ - { 0x0000, 0x0000, 0x0000 }, /* R3435 */ - { 0x0000, 0x0000, 0x0000 }, /* R3436 */ - { 0x0000, 0x0000, 0x0000 }, /* R3437 */ - { 0x0000, 0x0000, 0x0000 }, /* R3438 */ - { 0x0000, 0x0000, 0x0000 }, /* R3439 */ - { 0x0000, 0x0000, 0x0000 }, /* R3440 */ - { 0x0000, 0x0000, 0x0000 }, /* R3441 */ - { 0x0000, 0x0000, 0x0000 }, /* R3442 */ - { 0x0000, 0x0000, 0x0000 }, /* R3443 */ - { 0x0000, 0x0000, 0x0000 }, /* R3444 */ - { 0x0000, 0x0000, 0x0000 }, /* R3445 */ - { 0x0000, 0x0000, 0x0000 }, /* R3446 */ - { 0x0000, 0x0000, 0x0000 }, /* R3447 */ - { 0x0000, 0x0000, 0x0000 }, /* R3448 */ - { 0x0000, 0x0000, 0x0000 }, /* R3449 */ - { 0x0000, 0x0000, 0x0000 }, /* R3450 */ - { 0x0000, 0x0000, 0x0000 }, /* R3451 */ - { 0x0000, 0x0000, 0x0000 }, /* R3452 */ - { 0x0000, 0x0000, 0x0000 }, /* R3453 */ - { 0x0000, 0x0000, 0x0000 }, /* R3454 */ - { 0x0000, 0x0000, 0x0000 }, /* R3455 */ - { 0x0000, 0x0000, 0x0000 }, /* R3456 */ - { 0x0000, 0x0000, 0x0000 }, /* R3457 */ - { 0x0000, 0x0000, 0x0000 }, /* R3458 */ - { 0x0000, 0x0000, 0x0000 }, /* R3459 */ - { 0x0000, 0x0000, 0x0000 }, /* R3460 */ - { 0x0000, 0x0000, 0x0000 }, /* R3461 */ - { 0x0000, 0x0000, 0x0000 }, /* R3462 */ - { 0x0000, 0x0000, 0x0000 }, /* R3463 */ - { 0x0000, 0x0000, 0x0000 }, /* R3464 */ - { 0x0000, 0x0000, 0x0000 }, /* R3465 */ - { 0x0000, 0x0000, 0x0000 }, /* R3466 */ - { 0x0000, 0x0000, 0x0000 }, /* R3467 */ - { 0x0000, 0x0000, 0x0000 }, /* R3468 */ - { 0x0000, 0x0000, 0x0000 }, /* R3469 */ - { 0x0000, 0x0000, 0x0000 }, /* R3470 */ - { 0x0000, 0x0000, 0x0000 }, /* R3471 */ - { 0x0000, 0x0000, 0x0000 }, /* R3472 */ - { 0x0000, 0x0000, 0x0000 }, /* R3473 */ - { 0x0000, 0x0000, 0x0000 }, /* R3474 */ - { 0x0000, 0x0000, 0x0000 }, /* R3475 */ - { 0x0000, 0x0000, 0x0000 }, /* R3476 */ - { 0x0000, 0x0000, 0x0000 }, /* R3477 */ - { 0x0000, 0x0000, 0x0000 }, /* R3478 */ - { 0x0000, 0x0000, 0x0000 }, /* R3479 */ - { 0x0000, 0x0000, 0x0000 }, /* R3480 */ - { 0x0000, 0x0000, 0x0000 }, /* R3481 */ - { 0x0000, 0x0000, 0x0000 }, /* R3482 */ - { 0x0000, 0x0000, 0x0000 }, /* R3483 */ - { 0x0000, 0x0000, 0x0000 }, /* R3484 */ - { 0x0000, 0x0000, 0x0000 }, /* R3485 */ - { 0x0000, 0x0000, 0x0000 }, /* R3486 */ - { 0x0000, 0x0000, 0x0000 }, /* R3487 */ - { 0x0000, 0x0000, 0x0000 }, /* R3488 */ - { 0x0000, 0x0000, 0x0000 }, /* R3489 */ - { 0x0000, 0x0000, 0x0000 }, /* R3490 */ - { 0x0000, 0x0000, 0x0000 }, /* R3491 */ - { 0x0000, 0x0000, 0x0000 }, /* R3492 */ - { 0x0000, 0x0000, 0x0000 }, /* R3493 */ - { 0x0000, 0x0000, 0x0000 }, /* R3494 */ - { 0x0000, 0x0000, 0x0000 }, /* R3495 */ - { 0x0000, 0x0000, 0x0000 }, /* R3496 */ - { 0x0000, 0x0000, 0x0000 }, /* R3497 */ - { 0x0000, 0x0000, 0x0000 }, /* R3498 */ - { 0x0000, 0x0000, 0x0000 }, /* R3499 */ - { 0x0000, 0x0000, 0x0000 }, /* R3500 */ - { 0x0000, 0x0000, 0x0000 }, /* R3501 */ - { 0x0000, 0x0000, 0x0000 }, /* R3502 */ - { 0x0000, 0x0000, 0x0000 }, /* R3503 */ - { 0x0000, 0x0000, 0x0000 }, /* R3504 */ - { 0x0000, 0x0000, 0x0000 }, /* R3505 */ - { 0x0000, 0x0000, 0x0000 }, /* R3506 */ - { 0x0000, 0x0000, 0x0000 }, /* R3507 */ - { 0x0000, 0x0000, 0x0000 }, /* R3508 */ - { 0x0000, 0x0000, 0x0000 }, /* R3509 */ - { 0x0000, 0x0000, 0x0000 }, /* R3510 */ - { 0x0000, 0x0000, 0x0000 }, /* R3511 */ - { 0x0000, 0x0000, 0x0000 }, /* R3512 */ - { 0x0000, 0x0000, 0x0000 }, /* R3513 */ - { 0x0000, 0x0000, 0x0000 }, /* R3514 */ - { 0x0000, 0x0000, 0x0000 }, /* R3515 */ - { 0x0000, 0x0000, 0x0000 }, /* R3516 */ - { 0x0000, 0x0000, 0x0000 }, /* R3517 */ - { 0x0000, 0x0000, 0x0000 }, /* R3518 */ - { 0x0000, 0x0000, 0x0000 }, /* R3519 */ - { 0x0000, 0x0000, 0x0000 }, /* R3520 */ - { 0x0000, 0x0000, 0x0000 }, /* R3521 */ - { 0x0000, 0x0000, 0x0000 }, /* R3522 */ - { 0x0000, 0x0000, 0x0000 }, /* R3523 */ - { 0x0000, 0x0000, 0x0000 }, /* R3524 */ - { 0x0000, 0x0000, 0x0000 }, /* R3525 */ - { 0x0000, 0x0000, 0x0000 }, /* R3526 */ - { 0x0000, 0x0000, 0x0000 }, /* R3527 */ - { 0x0000, 0x0000, 0x0000 }, /* R3528 */ - { 0x0000, 0x0000, 0x0000 }, /* R3529 */ - { 0x0000, 0x0000, 0x0000 }, /* R3530 */ - { 0x0000, 0x0000, 0x0000 }, /* R3531 */ - { 0x0000, 0x0000, 0x0000 }, /* R3532 */ - { 0x0000, 0x0000, 0x0000 }, /* R3533 */ - { 0x0000, 0x0000, 0x0000 }, /* R3534 */ - { 0x0000, 0x0000, 0x0000 }, /* R3535 */ - { 0x0000, 0x0000, 0x0000 }, /* R3536 */ - { 0x0000, 0x0000, 0x0000 }, /* R3537 */ - { 0x0000, 0x0000, 0x0000 }, /* R3538 */ - { 0x0000, 0x0000, 0x0000 }, /* R3539 */ - { 0x0000, 0x0000, 0x0000 }, /* R3540 */ - { 0x0000, 0x0000, 0x0000 }, /* R3541 */ - { 0x0000, 0x0000, 0x0000 }, /* R3542 */ - { 0x0000, 0x0000, 0x0000 }, /* R3543 */ - { 0x0000, 0x0000, 0x0000 }, /* R3544 */ - { 0x0000, 0x0000, 0x0000 }, /* R3545 */ - { 0x0000, 0x0000, 0x0000 }, /* R3546 */ - { 0x0000, 0x0000, 0x0000 }, /* R3547 */ - { 0x0000, 0x0000, 0x0000 }, /* R3548 */ - { 0x0000, 0x0000, 0x0000 }, /* R3549 */ - { 0x0000, 0x0000, 0x0000 }, /* R3550 */ - { 0x0000, 0x0000, 0x0000 }, /* R3551 */ - { 0x0000, 0x0000, 0x0000 }, /* R3552 */ - { 0x0000, 0x0000, 0x0000 }, /* R3553 */ - { 0x0000, 0x0000, 0x0000 }, /* R3554 */ - { 0x0000, 0x0000, 0x0000 }, /* R3555 */ - { 0x0000, 0x0000, 0x0000 }, /* R3556 */ - { 0x0000, 0x0000, 0x0000 }, /* R3557 */ - { 0x0000, 0x0000, 0x0000 }, /* R3558 */ - { 0x0000, 0x0000, 0x0000 }, /* R3559 */ - { 0x0000, 0x0000, 0x0000 }, /* R3560 */ - { 0x0000, 0x0000, 0x0000 }, /* R3561 */ - { 0x0000, 0x0000, 0x0000 }, /* R3562 */ - { 0x0000, 0x0000, 0x0000 }, /* R3563 */ - { 0x0000, 0x0000, 0x0000 }, /* R3564 */ - { 0x0000, 0x0000, 0x0000 }, /* R3565 */ - { 0x0000, 0x0000, 0x0000 }, /* R3566 */ - { 0x0000, 0x0000, 0x0000 }, /* R3567 */ - { 0x0000, 0x0000, 0x0000 }, /* R3568 */ - { 0x0000, 0x0000, 0x0000 }, /* R3569 */ - { 0x0000, 0x0000, 0x0000 }, /* R3570 */ - { 0x0000, 0x0000, 0x0000 }, /* R3571 */ - { 0x0000, 0x0000, 0x0000 }, /* R3572 */ - { 0x0000, 0x0000, 0x0000 }, /* R3573 */ - { 0x0000, 0x0000, 0x0000 }, /* R3574 */ - { 0x0000, 0x0000, 0x0000 }, /* R3575 */ - { 0x0000, 0x0000, 0x0000 }, /* R3576 */ - { 0x0000, 0x0000, 0x0000 }, /* R3577 */ - { 0x0000, 0x0000, 0x0000 }, /* R3578 */ - { 0x0000, 0x0000, 0x0000 }, /* R3579 */ - { 0x0000, 0x0000, 0x0000 }, /* R3580 */ - { 0x0000, 0x0000, 0x0000 }, /* R3581 */ - { 0x0000, 0x0000, 0x0000 }, /* R3582 */ - { 0x0000, 0x0000, 0x0000 }, /* R3583 */ - { 0x0000, 0x0000, 0x0000 }, /* R3584 */ - { 0x0000, 0x0000, 0x0000 }, /* R3585 */ - { 0x0000, 0x0000, 0x0000 }, /* R3586 */ - { 0x0000, 0x0000, 0x0000 }, /* R3587 */ - { 0x0000, 0x0000, 0x0000 }, /* R3588 */ - { 0x0000, 0x0000, 0x0000 }, /* R3589 */ - { 0x0000, 0x0000, 0x0000 }, /* R3590 */ - { 0x0000, 0x0000, 0x0000 }, /* R3591 */ - { 0x0000, 0x0000, 0x0000 }, /* R3592 */ - { 0x0000, 0x0000, 0x0000 }, /* R3593 */ - { 0x0000, 0x0000, 0x0000 }, /* R3594 */ - { 0x0000, 0x0000, 0x0000 }, /* R3595 */ - { 0x0000, 0x0000, 0x0000 }, /* R3596 */ - { 0x0000, 0x0000, 0x0000 }, /* R3597 */ - { 0x0000, 0x0000, 0x0000 }, /* R3598 */ - { 0x0000, 0x0000, 0x0000 }, /* R3599 */ - { 0x0000, 0x0000, 0x0000 }, /* R3600 */ - { 0x0000, 0x0000, 0x0000 }, /* R3601 */ - { 0x0000, 0x0000, 0x0000 }, /* R3602 */ - { 0x0000, 0x0000, 0x0000 }, /* R3603 */ - { 0x0000, 0x0000, 0x0000 }, /* R3604 */ - { 0x0000, 0x0000, 0x0000 }, /* R3605 */ - { 0x0000, 0x0000, 0x0000 }, /* R3606 */ - { 0x0000, 0x0000, 0x0000 }, /* R3607 */ - { 0x0000, 0x0000, 0x0000 }, /* R3608 */ - { 0x0000, 0x0000, 0x0000 }, /* R3609 */ - { 0x0000, 0x0000, 0x0000 }, /* R3610 */ - { 0x0000, 0x0000, 0x0000 }, /* R3611 */ - { 0x0000, 0x0000, 0x0000 }, /* R3612 */ - { 0x0000, 0x0000, 0x0000 }, /* R3613 */ - { 0x0000, 0x0000, 0x0000 }, /* R3614 */ - { 0x0000, 0x0000, 0x0000 }, /* R3615 */ - { 0x0000, 0x0000, 0x0000 }, /* R3616 */ - { 0x0000, 0x0000, 0x0000 }, /* R3617 */ - { 0x0000, 0x0000, 0x0000 }, /* R3618 */ - { 0x0000, 0x0000, 0x0000 }, /* R3619 */ - { 0x0000, 0x0000, 0x0000 }, /* R3620 */ - { 0x0000, 0x0000, 0x0000 }, /* R3621 */ - { 0x0000, 0x0000, 0x0000 }, /* R3622 */ - { 0x0000, 0x0000, 0x0000 }, /* R3623 */ - { 0x0000, 0x0000, 0x0000 }, /* R3624 */ - { 0x0000, 0x0000, 0x0000 }, /* R3625 */ - { 0x0000, 0x0000, 0x0000 }, /* R3626 */ - { 0x0000, 0x0000, 0x0000 }, /* R3627 */ - { 0x0000, 0x0000, 0x0000 }, /* R3628 */ - { 0x0000, 0x0000, 0x0000 }, /* R3629 */ - { 0x0000, 0x0000, 0x0000 }, /* R3630 */ - { 0x0000, 0x0000, 0x0000 }, /* R3631 */ - { 0x0000, 0x0000, 0x0000 }, /* R3632 */ - { 0x0000, 0x0000, 0x0000 }, /* R3633 */ - { 0x0000, 0x0000, 0x0000 }, /* R3634 */ - { 0x0000, 0x0000, 0x0000 }, /* R3635 */ - { 0x0000, 0x0000, 0x0000 }, /* R3636 */ - { 0x0000, 0x0000, 0x0000 }, /* R3637 */ - { 0x0000, 0x0000, 0x0000 }, /* R3638 */ - { 0x0000, 0x0000, 0x0000 }, /* R3639 */ - { 0x0000, 0x0000, 0x0000 }, /* R3640 */ - { 0x0000, 0x0000, 0x0000 }, /* R3641 */ - { 0x0000, 0x0000, 0x0000 }, /* R3642 */ - { 0x0000, 0x0000, 0x0000 }, /* R3643 */ - { 0x0000, 0x0000, 0x0000 }, /* R3644 */ - { 0x0000, 0x0000, 0x0000 }, /* R3645 */ - { 0x0000, 0x0000, 0x0000 }, /* R3646 */ - { 0x0000, 0x0000, 0x0000 }, /* R3647 */ - { 0x0000, 0x0000, 0x0000 }, /* R3648 */ - { 0x0000, 0x0000, 0x0000 }, /* R3649 */ - { 0x0000, 0x0000, 0x0000 }, /* R3650 */ - { 0x0000, 0x0000, 0x0000 }, /* R3651 */ - { 0x0000, 0x0000, 0x0000 }, /* R3652 */ - { 0x0000, 0x0000, 0x0000 }, /* R3653 */ - { 0x0000, 0x0000, 0x0000 }, /* R3654 */ - { 0x0000, 0x0000, 0x0000 }, /* R3655 */ - { 0x0000, 0x0000, 0x0000 }, /* R3656 */ - { 0x0000, 0x0000, 0x0000 }, /* R3657 */ - { 0x0000, 0x0000, 0x0000 }, /* R3658 */ - { 0x0000, 0x0000, 0x0000 }, /* R3659 */ - { 0x0000, 0x0000, 0x0000 }, /* R3660 */ - { 0x0000, 0x0000, 0x0000 }, /* R3661 */ - { 0x0000, 0x0000, 0x0000 }, /* R3662 */ - { 0x0000, 0x0000, 0x0000 }, /* R3663 */ - { 0x0000, 0x0000, 0x0000 }, /* R3664 */ - { 0x0000, 0x0000, 0x0000 }, /* R3665 */ - { 0x0000, 0x0000, 0x0000 }, /* R3666 */ - { 0x0000, 0x0000, 0x0000 }, /* R3667 */ - { 0x0000, 0x0000, 0x0000 }, /* R3668 */ - { 0x0000, 0x0000, 0x0000 }, /* R3669 */ - { 0x0000, 0x0000, 0x0000 }, /* R3670 */ - { 0x0000, 0x0000, 0x0000 }, /* R3671 */ - { 0x0000, 0x0000, 0x0000 }, /* R3672 */ - { 0x0000, 0x0000, 0x0000 }, /* R3673 */ - { 0x0000, 0x0000, 0x0000 }, /* R3674 */ - { 0x0000, 0x0000, 0x0000 }, /* R3675 */ - { 0x0000, 0x0000, 0x0000 }, /* R3676 */ - { 0x0000, 0x0000, 0x0000 }, /* R3677 */ - { 0x0000, 0x0000, 0x0000 }, /* R3678 */ - { 0x0000, 0x0000, 0x0000 }, /* R3679 */ - { 0x0000, 0x0000, 0x0000 }, /* R3680 */ - { 0x0000, 0x0000, 0x0000 }, /* R3681 */ - { 0x0000, 0x0000, 0x0000 }, /* R3682 */ - { 0x0000, 0x0000, 0x0000 }, /* R3683 */ - { 0x0000, 0x0000, 0x0000 }, /* R3684 */ - { 0x0000, 0x0000, 0x0000 }, /* R3685 */ - { 0x0000, 0x0000, 0x0000 }, /* R3686 */ - { 0x0000, 0x0000, 0x0000 }, /* R3687 */ - { 0x0000, 0x0000, 0x0000 }, /* R3688 */ - { 0x0000, 0x0000, 0x0000 }, /* R3689 */ - { 0x0000, 0x0000, 0x0000 }, /* R3690 */ - { 0x0000, 0x0000, 0x0000 }, /* R3691 */ - { 0x0000, 0x0000, 0x0000 }, /* R3692 */ - { 0x0000, 0x0000, 0x0000 }, /* R3693 */ - { 0x0000, 0x0000, 0x0000 }, /* R3694 */ - { 0x0000, 0x0000, 0x0000 }, /* R3695 */ - { 0x0000, 0x0000, 0x0000 }, /* R3696 */ - { 0x0000, 0x0000, 0x0000 }, /* R3697 */ - { 0x0000, 0x0000, 0x0000 }, /* R3698 */ - { 0x0000, 0x0000, 0x0000 }, /* R3699 */ - { 0x0000, 0x0000, 0x0000 }, /* R3700 */ - { 0x0000, 0x0000, 0x0000 }, /* R3701 */ - { 0x0000, 0x0000, 0x0000 }, /* R3702 */ - { 0x0000, 0x0000, 0x0000 }, /* R3703 */ - { 0x0000, 0x0000, 0x0000 }, /* R3704 */ - { 0x0000, 0x0000, 0x0000 }, /* R3705 */ - { 0x0000, 0x0000, 0x0000 }, /* R3706 */ - { 0x0000, 0x0000, 0x0000 }, /* R3707 */ - { 0x0000, 0x0000, 0x0000 }, /* R3708 */ - { 0x0000, 0x0000, 0x0000 }, /* R3709 */ - { 0x0000, 0x0000, 0x0000 }, /* R3710 */ - { 0x0000, 0x0000, 0x0000 }, /* R3711 */ - { 0x0000, 0x0000, 0x0000 }, /* R3712 */ - { 0x0000, 0x0000, 0x0000 }, /* R3713 */ - { 0x0000, 0x0000, 0x0000 }, /* R3714 */ - { 0x0000, 0x0000, 0x0000 }, /* R3715 */ - { 0x0000, 0x0000, 0x0000 }, /* R3716 */ - { 0x0000, 0x0000, 0x0000 }, /* R3717 */ - { 0x0000, 0x0000, 0x0000 }, /* R3718 */ - { 0x0000, 0x0000, 0x0000 }, /* R3719 */ - { 0x0000, 0x0000, 0x0000 }, /* R3720 */ - { 0x0000, 0x0000, 0x0000 }, /* R3721 */ - { 0x0000, 0x0000, 0x0000 }, /* R3722 */ - { 0x0000, 0x0000, 0x0000 }, /* R3723 */ - { 0x0000, 0x0000, 0x0000 }, /* R3724 */ - { 0x0000, 0x0000, 0x0000 }, /* R3725 */ - { 0x0000, 0x0000, 0x0000 }, /* R3726 */ - { 0x0000, 0x0000, 0x0000 }, /* R3727 */ - { 0x0000, 0x0000, 0x0000 }, /* R3728 */ - { 0x0000, 0x0000, 0x0000 }, /* R3729 */ - { 0x0000, 0x0000, 0x0000 }, /* R3730 */ - { 0x0000, 0x0000, 0x0000 }, /* R3731 */ - { 0x0000, 0x0000, 0x0000 }, /* R3732 */ - { 0x0000, 0x0000, 0x0000 }, /* R3733 */ - { 0x0000, 0x0000, 0x0000 }, /* R3734 */ - { 0x0000, 0x0000, 0x0000 }, /* R3735 */ - { 0x0000, 0x0000, 0x0000 }, /* R3736 */ - { 0x0000, 0x0000, 0x0000 }, /* R3737 */ - { 0x0000, 0x0000, 0x0000 }, /* R3738 */ - { 0x0000, 0x0000, 0x0000 }, /* R3739 */ - { 0x0000, 0x0000, 0x0000 }, /* R3740 */ - { 0x0000, 0x0000, 0x0000 }, /* R3741 */ - { 0x0000, 0x0000, 0x0000 }, /* R3742 */ - { 0x0000, 0x0000, 0x0000 }, /* R3743 */ - { 0x0000, 0x0000, 0x0000 }, /* R3744 */ - { 0x0000, 0x0000, 0x0000 }, /* R3745 */ - { 0x0000, 0x0000, 0x0000 }, /* R3746 */ - { 0x0000, 0x0000, 0x0000 }, /* R3747 */ - { 0x0000, 0x0000, 0x0000 }, /* R3748 */ - { 0x0000, 0x0000, 0x0000 }, /* R3749 */ - { 0x0000, 0x0000, 0x0000 }, /* R3750 */ - { 0x0000, 0x0000, 0x0000 }, /* R3751 */ - { 0x0000, 0x0000, 0x0000 }, /* R3752 */ - { 0x0000, 0x0000, 0x0000 }, /* R3753 */ - { 0x0000, 0x0000, 0x0000 }, /* R3754 */ - { 0x0000, 0x0000, 0x0000 }, /* R3755 */ - { 0x0000, 0x0000, 0x0000 }, /* R3756 */ - { 0x0000, 0x0000, 0x0000 }, /* R3757 */ - { 0x0000, 0x0000, 0x0000 }, /* R3758 */ - { 0x0000, 0x0000, 0x0000 }, /* R3759 */ - { 0x0000, 0x0000, 0x0000 }, /* R3760 */ - { 0x0000, 0x0000, 0x0000 }, /* R3761 */ - { 0x0000, 0x0000, 0x0000 }, /* R3762 */ - { 0x0000, 0x0000, 0x0000 }, /* R3763 */ - { 0x0000, 0x0000, 0x0000 }, /* R3764 */ - { 0x0000, 0x0000, 0x0000 }, /* R3765 */ - { 0x0000, 0x0000, 0x0000 }, /* R3766 */ - { 0x0000, 0x0000, 0x0000 }, /* R3767 */ - { 0x0000, 0x0000, 0x0000 }, /* R3768 */ - { 0x0000, 0x0000, 0x0000 }, /* R3769 */ - { 0x0000, 0x0000, 0x0000 }, /* R3770 */ - { 0x0000, 0x0000, 0x0000 }, /* R3771 */ - { 0x0000, 0x0000, 0x0000 }, /* R3772 */ - { 0x0000, 0x0000, 0x0000 }, /* R3773 */ - { 0x0000, 0x0000, 0x0000 }, /* R3774 */ - { 0x0000, 0x0000, 0x0000 }, /* R3775 */ - { 0x0000, 0x0000, 0x0000 }, /* R3776 */ - { 0x0000, 0x0000, 0x0000 }, /* R3777 */ - { 0x0000, 0x0000, 0x0000 }, /* R3778 */ - { 0x0000, 0x0000, 0x0000 }, /* R3779 */ - { 0x0000, 0x0000, 0x0000 }, /* R3780 */ - { 0x0000, 0x0000, 0x0000 }, /* R3781 */ - { 0x0000, 0x0000, 0x0000 }, /* R3782 */ - { 0x0000, 0x0000, 0x0000 }, /* R3783 */ - { 0x0000, 0x0000, 0x0000 }, /* R3784 */ - { 0x0000, 0x0000, 0x0000 }, /* R3785 */ - { 0x0000, 0x0000, 0x0000 }, /* R3786 */ - { 0x0000, 0x0000, 0x0000 }, /* R3787 */ - { 0x0000, 0x0000, 0x0000 }, /* R3788 */ - { 0x0000, 0x0000, 0x0000 }, /* R3789 */ - { 0x0000, 0x0000, 0x0000 }, /* R3790 */ - { 0x0000, 0x0000, 0x0000 }, /* R3791 */ - { 0x0000, 0x0000, 0x0000 }, /* R3792 */ - { 0x0000, 0x0000, 0x0000 }, /* R3793 */ - { 0x0000, 0x0000, 0x0000 }, /* R3794 */ - { 0x0000, 0x0000, 0x0000 }, /* R3795 */ - { 0x0000, 0x0000, 0x0000 }, /* R3796 */ - { 0x0000, 0x0000, 0x0000 }, /* R3797 */ - { 0x0000, 0x0000, 0x0000 }, /* R3798 */ - { 0x0000, 0x0000, 0x0000 }, /* R3799 */ - { 0x0000, 0x0000, 0x0000 }, /* R3800 */ - { 0x0000, 0x0000, 0x0000 }, /* R3801 */ - { 0x0000, 0x0000, 0x0000 }, /* R3802 */ - { 0x0000, 0x0000, 0x0000 }, /* R3803 */ - { 0x0000, 0x0000, 0x0000 }, /* R3804 */ - { 0x0000, 0x0000, 0x0000 }, /* R3805 */ - { 0x0000, 0x0000, 0x0000 }, /* R3806 */ - { 0x0000, 0x0000, 0x0000 }, /* R3807 */ - { 0x0000, 0x0000, 0x0000 }, /* R3808 */ - { 0x0000, 0x0000, 0x0000 }, /* R3809 */ - { 0x0000, 0x0000, 0x0000 }, /* R3810 */ - { 0x0000, 0x0000, 0x0000 }, /* R3811 */ - { 0x0000, 0x0000, 0x0000 }, /* R3812 */ - { 0x0000, 0x0000, 0x0000 }, /* R3813 */ - { 0x0000, 0x0000, 0x0000 }, /* R3814 */ - { 0x0000, 0x0000, 0x0000 }, /* R3815 */ - { 0x0000, 0x0000, 0x0000 }, /* R3816 */ - { 0x0000, 0x0000, 0x0000 }, /* R3817 */ - { 0x0000, 0x0000, 0x0000 }, /* R3818 */ - { 0x0000, 0x0000, 0x0000 }, /* R3819 */ - { 0x0000, 0x0000, 0x0000 }, /* R3820 */ - { 0x0000, 0x0000, 0x0000 }, /* R3821 */ - { 0x0000, 0x0000, 0x0000 }, /* R3822 */ - { 0x0000, 0x0000, 0x0000 }, /* R3823 */ - { 0x0000, 0x0000, 0x0000 }, /* R3824 */ - { 0x0000, 0x0000, 0x0000 }, /* R3825 */ - { 0x0000, 0x0000, 0x0000 }, /* R3826 */ - { 0x0000, 0x0000, 0x0000 }, /* R3827 */ - { 0x0000, 0x0000, 0x0000 }, /* R3828 */ - { 0x0000, 0x0000, 0x0000 }, /* R3829 */ - { 0x0000, 0x0000, 0x0000 }, /* R3830 */ - { 0x0000, 0x0000, 0x0000 }, /* R3831 */ - { 0x0000, 0x0000, 0x0000 }, /* R3832 */ - { 0x0000, 0x0000, 0x0000 }, /* R3833 */ - { 0x0000, 0x0000, 0x0000 }, /* R3834 */ - { 0x0000, 0x0000, 0x0000 }, /* R3835 */ - { 0x0000, 0x0000, 0x0000 }, /* R3836 */ - { 0x0000, 0x0000, 0x0000 }, /* R3837 */ - { 0x0000, 0x0000, 0x0000 }, /* R3838 */ - { 0x0000, 0x0000, 0x0000 }, /* R3839 */ - { 0x0000, 0x0000, 0x0000 }, /* R3840 */ - { 0x0000, 0x0000, 0x0000 }, /* R3841 */ - { 0x0000, 0x0000, 0x0000 }, /* R3842 */ - { 0x0000, 0x0000, 0x0000 }, /* R3843 */ - { 0x0000, 0x0000, 0x0000 }, /* R3844 */ - { 0x0000, 0x0000, 0x0000 }, /* R3845 */ - { 0x0000, 0x0000, 0x0000 }, /* R3846 */ - { 0x0000, 0x0000, 0x0000 }, /* R3847 */ - { 0x0000, 0x0000, 0x0000 }, /* R3848 */ - { 0x0000, 0x0000, 0x0000 }, /* R3849 */ - { 0x0000, 0x0000, 0x0000 }, /* R3850 */ - { 0x0000, 0x0000, 0x0000 }, /* R3851 */ - { 0x0000, 0x0000, 0x0000 }, /* R3852 */ - { 0x0000, 0x0000, 0x0000 }, /* R3853 */ - { 0x0000, 0x0000, 0x0000 }, /* R3854 */ - { 0x0000, 0x0000, 0x0000 }, /* R3855 */ - { 0x0000, 0x0000, 0x0000 }, /* R3856 */ - { 0x0000, 0x0000, 0x0000 }, /* R3857 */ - { 0x0000, 0x0000, 0x0000 }, /* R3858 */ - { 0x0000, 0x0000, 0x0000 }, /* R3859 */ - { 0x0000, 0x0000, 0x0000 }, /* R3860 */ - { 0x0000, 0x0000, 0x0000 }, /* R3861 */ - { 0x0000, 0x0000, 0x0000 }, /* R3862 */ - { 0x0000, 0x0000, 0x0000 }, /* R3863 */ - { 0x0000, 0x0000, 0x0000 }, /* R3864 */ - { 0x0000, 0x0000, 0x0000 }, /* R3865 */ - { 0x0000, 0x0000, 0x0000 }, /* R3866 */ - { 0x0000, 0x0000, 0x0000 }, /* R3867 */ - { 0x0000, 0x0000, 0x0000 }, /* R3868 */ - { 0x0000, 0x0000, 0x0000 }, /* R3869 */ - { 0x0000, 0x0000, 0x0000 }, /* R3870 */ - { 0x0000, 0x0000, 0x0000 }, /* R3871 */ - { 0x0000, 0x0000, 0x0000 }, /* R3872 */ - { 0x0000, 0x0000, 0x0000 }, /* R3873 */ - { 0x0000, 0x0000, 0x0000 }, /* R3874 */ - { 0x0000, 0x0000, 0x0000 }, /* R3875 */ - { 0x0000, 0x0000, 0x0000 }, /* R3876 */ - { 0x0000, 0x0000, 0x0000 }, /* R3877 */ - { 0x0000, 0x0000, 0x0000 }, /* R3878 */ - { 0x0000, 0x0000, 0x0000 }, /* R3879 */ - { 0x0000, 0x0000, 0x0000 }, /* R3880 */ - { 0x0000, 0x0000, 0x0000 }, /* R3881 */ - { 0x0000, 0x0000, 0x0000 }, /* R3882 */ - { 0x0000, 0x0000, 0x0000 }, /* R3883 */ - { 0x0000, 0x0000, 0x0000 }, /* R3884 */ - { 0x0000, 0x0000, 0x0000 }, /* R3885 */ - { 0x0000, 0x0000, 0x0000 }, /* R3886 */ - { 0x0000, 0x0000, 0x0000 }, /* R3887 */ - { 0x0000, 0x0000, 0x0000 }, /* R3888 */ - { 0x0000, 0x0000, 0x0000 }, /* R3889 */ - { 0x0000, 0x0000, 0x0000 }, /* R3890 */ - { 0x0000, 0x0000, 0x0000 }, /* R3891 */ - { 0x0000, 0x0000, 0x0000 }, /* R3892 */ - { 0x0000, 0x0000, 0x0000 }, /* R3893 */ - { 0x0000, 0x0000, 0x0000 }, /* R3894 */ - { 0x0000, 0x0000, 0x0000 }, /* R3895 */ - { 0x0000, 0x0000, 0x0000 }, /* R3896 */ - { 0x0000, 0x0000, 0x0000 }, /* R3897 */ - { 0x0000, 0x0000, 0x0000 }, /* R3898 */ - { 0x0000, 0x0000, 0x0000 }, /* R3899 */ - { 0x0000, 0x0000, 0x0000 }, /* R3900 */ - { 0x0000, 0x0000, 0x0000 }, /* R3901 */ - { 0x0000, 0x0000, 0x0000 }, /* R3902 */ - { 0x0000, 0x0000, 0x0000 }, /* R3903 */ - { 0x0000, 0x0000, 0x0000 }, /* R3904 */ - { 0x0000, 0x0000, 0x0000 }, /* R3905 */ - { 0x0000, 0x0000, 0x0000 }, /* R3906 */ - { 0x0000, 0x0000, 0x0000 }, /* R3907 */ - { 0x0000, 0x0000, 0x0000 }, /* R3908 */ - { 0x0000, 0x0000, 0x0000 }, /* R3909 */ - { 0x0000, 0x0000, 0x0000 }, /* R3910 */ - { 0x0000, 0x0000, 0x0000 }, /* R3911 */ - { 0x0000, 0x0000, 0x0000 }, /* R3912 */ - { 0x0000, 0x0000, 0x0000 }, /* R3913 */ - { 0x0000, 0x0000, 0x0000 }, /* R3914 */ - { 0x0000, 0x0000, 0x0000 }, /* R3915 */ - { 0x0000, 0x0000, 0x0000 }, /* R3916 */ - { 0x0000, 0x0000, 0x0000 }, /* R3917 */ - { 0x0000, 0x0000, 0x0000 }, /* R3918 */ - { 0x0000, 0x0000, 0x0000 }, /* R3919 */ - { 0x0000, 0x0000, 0x0000 }, /* R3920 */ - { 0x0000, 0x0000, 0x0000 }, /* R3921 */ - { 0x0000, 0x0000, 0x0000 }, /* R3922 */ - { 0x0000, 0x0000, 0x0000 }, /* R3923 */ - { 0x0000, 0x0000, 0x0000 }, /* R3924 */ - { 0x0000, 0x0000, 0x0000 }, /* R3925 */ - { 0x0000, 0x0000, 0x0000 }, /* R3926 */ - { 0x0000, 0x0000, 0x0000 }, /* R3927 */ - { 0x0000, 0x0000, 0x0000 }, /* R3928 */ - { 0x0000, 0x0000, 0x0000 }, /* R3929 */ - { 0x0000, 0x0000, 0x0000 }, /* R3930 */ - { 0x0000, 0x0000, 0x0000 }, /* R3931 */ - { 0x0000, 0x0000, 0x0000 }, /* R3932 */ - { 0x0000, 0x0000, 0x0000 }, /* R3933 */ - { 0x0000, 0x0000, 0x0000 }, /* R3934 */ - { 0x0000, 0x0000, 0x0000 }, /* R3935 */ - { 0x0000, 0x0000, 0x0000 }, /* R3936 */ - { 0x0000, 0x0000, 0x0000 }, /* R3937 */ - { 0x0000, 0x0000, 0x0000 }, /* R3938 */ - { 0x0000, 0x0000, 0x0000 }, /* R3939 */ - { 0x0000, 0x0000, 0x0000 }, /* R3940 */ - { 0x0000, 0x0000, 0x0000 }, /* R3941 */ - { 0x0000, 0x0000, 0x0000 }, /* R3942 */ - { 0x0000, 0x0000, 0x0000 }, /* R3943 */ - { 0x0000, 0x0000, 0x0000 }, /* R3944 */ - { 0x0000, 0x0000, 0x0000 }, /* R3945 */ - { 0x0000, 0x0000, 0x0000 }, /* R3946 */ - { 0x0000, 0x0000, 0x0000 }, /* R3947 */ - { 0x0000, 0x0000, 0x0000 }, /* R3948 */ - { 0x0000, 0x0000, 0x0000 }, /* R3949 */ - { 0x0000, 0x0000, 0x0000 }, /* R3950 */ - { 0x0000, 0x0000, 0x0000 }, /* R3951 */ - { 0x0000, 0x0000, 0x0000 }, /* R3952 */ - { 0x0000, 0x0000, 0x0000 }, /* R3953 */ - { 0x0000, 0x0000, 0x0000 }, /* R3954 */ - { 0x0000, 0x0000, 0x0000 }, /* R3955 */ - { 0x0000, 0x0000, 0x0000 }, /* R3956 */ - { 0x0000, 0x0000, 0x0000 }, /* R3957 */ - { 0x0000, 0x0000, 0x0000 }, /* R3958 */ - { 0x0000, 0x0000, 0x0000 }, /* R3959 */ - { 0x0000, 0x0000, 0x0000 }, /* R3960 */ - { 0x0000, 0x0000, 0x0000 }, /* R3961 */ - { 0x0000, 0x0000, 0x0000 }, /* R3962 */ - { 0x0000, 0x0000, 0x0000 }, /* R3963 */ - { 0x0000, 0x0000, 0x0000 }, /* R3964 */ - { 0x0000, 0x0000, 0x0000 }, /* R3965 */ - { 0x0000, 0x0000, 0x0000 }, /* R3966 */ - { 0x0000, 0x0000, 0x0000 }, /* R3967 */ - { 0x0000, 0x0000, 0x0000 }, /* R3968 */ - { 0x0000, 0x0000, 0x0000 }, /* R3969 */ - { 0x0000, 0x0000, 0x0000 }, /* R3970 */ - { 0x0000, 0x0000, 0x0000 }, /* R3971 */ - { 0x0000, 0x0000, 0x0000 }, /* R3972 */ - { 0x0000, 0x0000, 0x0000 }, /* R3973 */ - { 0x0000, 0x0000, 0x0000 }, /* R3974 */ - { 0x0000, 0x0000, 0x0000 }, /* R3975 */ - { 0x0000, 0x0000, 0x0000 }, /* R3976 */ - { 0x0000, 0x0000, 0x0000 }, /* R3977 */ - { 0x0000, 0x0000, 0x0000 }, /* R3978 */ - { 0x0000, 0x0000, 0x0000 }, /* R3979 */ - { 0x0000, 0x0000, 0x0000 }, /* R3980 */ - { 0x0000, 0x0000, 0x0000 }, /* R3981 */ - { 0x0000, 0x0000, 0x0000 }, /* R3982 */ - { 0x0000, 0x0000, 0x0000 }, /* R3983 */ - { 0x0000, 0x0000, 0x0000 }, /* R3984 */ - { 0x0000, 0x0000, 0x0000 }, /* R3985 */ - { 0x0000, 0x0000, 0x0000 }, /* R3986 */ - { 0x0000, 0x0000, 0x0000 }, /* R3987 */ - { 0x0000, 0x0000, 0x0000 }, /* R3988 */ - { 0x0000, 0x0000, 0x0000 }, /* R3989 */ - { 0x0000, 0x0000, 0x0000 }, /* R3990 */ - { 0x0000, 0x0000, 0x0000 }, /* R3991 */ - { 0x0000, 0x0000, 0x0000 }, /* R3992 */ - { 0x0000, 0x0000, 0x0000 }, /* R3993 */ - { 0x0000, 0x0000, 0x0000 }, /* R3994 */ - { 0x0000, 0x0000, 0x0000 }, /* R3995 */ - { 0x0000, 0x0000, 0x0000 }, /* R3996 */ - { 0x0000, 0x0000, 0x0000 }, /* R3997 */ - { 0x0000, 0x0000, 0x0000 }, /* R3998 */ - { 0x0000, 0x0000, 0x0000 }, /* R3999 */ - { 0x0000, 0x0000, 0x0000 }, /* R4000 */ - { 0x0000, 0x0000, 0x0000 }, /* R4001 */ - { 0x0000, 0x0000, 0x0000 }, /* R4002 */ - { 0x0000, 0x0000, 0x0000 }, /* R4003 */ - { 0x0000, 0x0000, 0x0000 }, /* R4004 */ - { 0x0000, 0x0000, 0x0000 }, /* R4005 */ - { 0x0000, 0x0000, 0x0000 }, /* R4006 */ - { 0x0000, 0x0000, 0x0000 }, /* R4007 */ - { 0x0000, 0x0000, 0x0000 }, /* R4008 */ - { 0x0000, 0x0000, 0x0000 }, /* R4009 */ - { 0x0000, 0x0000, 0x0000 }, /* R4010 */ - { 0x0000, 0x0000, 0x0000 }, /* R4011 */ - { 0x0000, 0x0000, 0x0000 }, /* R4012 */ - { 0x0000, 0x0000, 0x0000 }, /* R4013 */ - { 0x0000, 0x0000, 0x0000 }, /* R4014 */ - { 0x0000, 0x0000, 0x0000 }, /* R4015 */ - { 0x0000, 0x0000, 0x0000 }, /* R4016 */ - { 0x0000, 0x0000, 0x0000 }, /* R4017 */ - { 0x0000, 0x0000, 0x0000 }, /* R4018 */ - { 0x0000, 0x0000, 0x0000 }, /* R4019 */ - { 0x0000, 0x0000, 0x0000 }, /* R4020 */ - { 0x0000, 0x0000, 0x0000 }, /* R4021 */ - { 0x0000, 0x0000, 0x0000 }, /* R4022 */ - { 0x0000, 0x0000, 0x0000 }, /* R4023 */ - { 0x0000, 0x0000, 0x0000 }, /* R4024 */ - { 0x0000, 0x0000, 0x0000 }, /* R4025 */ - { 0x0000, 0x0000, 0x0000 }, /* R4026 */ - { 0x0000, 0x0000, 0x0000 }, /* R4027 */ - { 0x0000, 0x0000, 0x0000 }, /* R4028 */ - { 0x0000, 0x0000, 0x0000 }, /* R4029 */ - { 0x0000, 0x0000, 0x0000 }, /* R4030 */ - { 0x0000, 0x0000, 0x0000 }, /* R4031 */ - { 0x0000, 0x0000, 0x0000 }, /* R4032 */ - { 0x0000, 0x0000, 0x0000 }, /* R4033 */ - { 0x0000, 0x0000, 0x0000 }, /* R4034 */ - { 0x0000, 0x0000, 0x0000 }, /* R4035 */ - { 0x0000, 0x0000, 0x0000 }, /* R4036 */ - { 0x0000, 0x0000, 0x0000 }, /* R4037 */ - { 0x0000, 0x0000, 0x0000 }, /* R4038 */ - { 0x0000, 0x0000, 0x0000 }, /* R4039 */ - { 0x0000, 0x0000, 0x0000 }, /* R4040 */ - { 0x0000, 0x0000, 0x0000 }, /* R4041 */ - { 0x0000, 0x0000, 0x0000 }, /* R4042 */ - { 0x0000, 0x0000, 0x0000 }, /* R4043 */ - { 0x0000, 0x0000, 0x0000 }, /* R4044 */ - { 0x0000, 0x0000, 0x0000 }, /* R4045 */ - { 0x0000, 0x0000, 0x0000 }, /* R4046 */ - { 0x0000, 0x0000, 0x0000 }, /* R4047 */ - { 0x0000, 0x0000, 0x0000 }, /* R4048 */ - { 0x0000, 0x0000, 0x0000 }, /* R4049 */ - { 0x0000, 0x0000, 0x0000 }, /* R4050 */ - { 0x0000, 0x0000, 0x0000 }, /* R4051 */ - { 0x0000, 0x0000, 0x0000 }, /* R4052 */ - { 0x0000, 0x0000, 0x0000 }, /* R4053 */ - { 0x0000, 0x0000, 0x0000 }, /* R4054 */ - { 0x0000, 0x0000, 0x0000 }, /* R4055 */ - { 0x0000, 0x0000, 0x0000 }, /* R4056 */ - { 0x0000, 0x0000, 0x0000 }, /* R4057 */ - { 0x0000, 0x0000, 0x0000 }, /* R4058 */ - { 0x0000, 0x0000, 0x0000 }, /* R4059 */ - { 0x0000, 0x0000, 0x0000 }, /* R4060 */ - { 0x0000, 0x0000, 0x0000 }, /* R4061 */ - { 0x0000, 0x0000, 0x0000 }, /* R4062 */ - { 0x0000, 0x0000, 0x0000 }, /* R4063 */ - { 0x0000, 0x0000, 0x0000 }, /* R4064 */ - { 0x0000, 0x0000, 0x0000 }, /* R4065 */ - { 0x0000, 0x0000, 0x0000 }, /* R4066 */ - { 0x0000, 0x0000, 0x0000 }, /* R4067 */ - { 0x0000, 0x0000, 0x0000 }, /* R4068 */ - { 0x0000, 0x0000, 0x0000 }, /* R4069 */ - { 0x0000, 0x0000, 0x0000 }, /* R4070 */ - { 0x0000, 0x0000, 0x0000 }, /* R4071 */ - { 0x0000, 0x0000, 0x0000 }, /* R4072 */ - { 0x0000, 0x0000, 0x0000 }, /* R4073 */ - { 0x0000, 0x0000, 0x0000 }, /* R4074 */ - { 0x0000, 0x0000, 0x0000 }, /* R4075 */ - { 0x0000, 0x0000, 0x0000 }, /* R4076 */ - { 0x0000, 0x0000, 0x0000 }, /* R4077 */ - { 0x0000, 0x0000, 0x0000 }, /* R4078 */ - { 0x0000, 0x0000, 0x0000 }, /* R4079 */ - { 0x0000, 0x0000, 0x0000 }, /* R4080 */ - { 0x0000, 0x0000, 0x0000 }, /* R4081 */ - { 0x0000, 0x0000, 0x0000 }, /* R4082 */ - { 0x0000, 0x0000, 0x0000 }, /* R4083 */ - { 0x0000, 0x0000, 0x0000 }, /* R4084 */ - { 0x0000, 0x0000, 0x0000 }, /* R4085 */ - { 0x0000, 0x0000, 0x0000 }, /* R4086 */ - { 0x0000, 0x0000, 0x0000 }, /* R4087 */ - { 0x0000, 0x0000, 0x0000 }, /* R4088 */ - { 0x0000, 0x0000, 0x0000 }, /* R4089 */ - { 0x0000, 0x0000, 0x0000 }, /* R4090 */ - { 0x0000, 0x0000, 0x0000 }, /* R4091 */ - { 0x0000, 0x0000, 0x0000 }, /* R4092 */ - { 0x0000, 0x0000, 0x0000 }, /* R4093 */ - { 0x0000, 0x0000, 0x0000 }, /* R4094 */ - { 0x0000, 0x0000, 0x0000 }, /* R4095 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4096 - Write Sequencer 0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4097 - Write Sequencer 1 */ - { 0x070F, 0x070F, 0x0000 }, /* R4098 - Write Sequencer 2 */ - { 0x010F, 0x010F, 0x0000 }, /* R4099 - Write Sequencer 3 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4100 - Write Sequencer 4 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4101 - Write Sequencer 5 */ - { 0x070F, 0x070F, 0x0000 }, /* R4102 - Write Sequencer 6 */ - { 0x010F, 0x010F, 0x0000 }, /* R4103 - Write Sequencer 7 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4104 - Write Sequencer 8 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4105 - Write Sequencer 9 */ - { 0x070F, 0x070F, 0x0000 }, /* R4106 - Write Sequencer 10 */ - { 0x010F, 0x010F, 0x0000 }, /* R4107 - Write Sequencer 11 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4108 - Write Sequencer 12 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4109 - Write Sequencer 13 */ - { 0x070F, 0x070F, 0x0000 }, /* R4110 - Write Sequencer 14 */ - { 0x010F, 0x010F, 0x0000 }, /* R4111 - Write Sequencer 15 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4112 - Write Sequencer 16 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4113 - Write Sequencer 17 */ - { 0x070F, 0x070F, 0x0000 }, /* R4114 - Write Sequencer 18 */ - { 0x010F, 0x010F, 0x0000 }, /* R4115 - Write Sequencer 19 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4116 - Write Sequencer 20 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4117 - Write Sequencer 21 */ - { 0x070F, 0x070F, 0x0000 }, /* R4118 - Write Sequencer 22 */ - { 0x010F, 0x010F, 0x0000 }, /* R4119 - Write Sequencer 23 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4120 - Write Sequencer 24 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4121 - Write Sequencer 25 */ - { 0x070F, 0x070F, 0x0000 }, /* R4122 - Write Sequencer 26 */ - { 0x010F, 0x010F, 0x0000 }, /* R4123 - Write Sequencer 27 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4124 - Write Sequencer 28 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4125 - Write Sequencer 29 */ - { 0x070F, 0x070F, 0x0000 }, /* R4126 - Write Sequencer 30 */ - { 0x010F, 0x010F, 0x0000 }, /* R4127 - Write Sequencer 31 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4128 - Write Sequencer 32 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4129 - Write Sequencer 33 */ - { 0x070F, 0x070F, 0x0000 }, /* R4130 - Write Sequencer 34 */ - { 0x010F, 0x010F, 0x0000 }, /* R4131 - Write Sequencer 35 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4132 - Write Sequencer 36 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4133 - Write Sequencer 37 */ - { 0x070F, 0x070F, 0x0000 }, /* R4134 - Write Sequencer 38 */ - { 0x010F, 0x010F, 0x0000 }, /* R4135 - Write Sequencer 39 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4136 - Write Sequencer 40 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4137 - Write Sequencer 41 */ - { 0x070F, 0x070F, 0x0000 }, /* R4138 - Write Sequencer 42 */ - { 0x010F, 0x010F, 0x0000 }, /* R4139 - Write Sequencer 43 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4140 - Write Sequencer 44 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4141 - Write Sequencer 45 */ - { 0x070F, 0x070F, 0x0000 }, /* R4142 - Write Sequencer 46 */ - { 0x010F, 0x010F, 0x0000 }, /* R4143 - Write Sequencer 47 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4144 - Write Sequencer 48 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4145 - Write Sequencer 49 */ - { 0x070F, 0x070F, 0x0000 }, /* R4146 - Write Sequencer 50 */ - { 0x010F, 0x010F, 0x0000 }, /* R4147 - Write Sequencer 51 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4148 - Write Sequencer 52 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4149 - Write Sequencer 53 */ - { 0x070F, 0x070F, 0x0000 }, /* R4150 - Write Sequencer 54 */ - { 0x010F, 0x010F, 0x0000 }, /* R4151 - Write Sequencer 55 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4152 - Write Sequencer 56 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4153 - Write Sequencer 57 */ - { 0x070F, 0x070F, 0x0000 }, /* R4154 - Write Sequencer 58 */ - { 0x010F, 0x010F, 0x0000 }, /* R4155 - Write Sequencer 59 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4156 - Write Sequencer 60 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4157 - Write Sequencer 61 */ - { 0x070F, 0x070F, 0x0000 }, /* R4158 - Write Sequencer 62 */ - { 0x010F, 0x010F, 0x0000 }, /* R4159 - Write Sequencer 63 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4160 - Write Sequencer 64 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4161 - Write Sequencer 65 */ - { 0x070F, 0x070F, 0x0000 }, /* R4162 - Write Sequencer 66 */ - { 0x010F, 0x010F, 0x0000 }, /* R4163 - Write Sequencer 67 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4164 - Write Sequencer 68 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4165 - Write Sequencer 69 */ - { 0x070F, 0x070F, 0x0000 }, /* R4166 - Write Sequencer 70 */ - { 0x010F, 0x010F, 0x0000 }, /* R4167 - Write Sequencer 71 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4168 - Write Sequencer 72 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4169 - Write Sequencer 73 */ - { 0x070F, 0x070F, 0x0000 }, /* R4170 - Write Sequencer 74 */ - { 0x010F, 0x010F, 0x0000 }, /* R4171 - Write Sequencer 75 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4172 - Write Sequencer 76 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4173 - Write Sequencer 77 */ - { 0x070F, 0x070F, 0x0000 }, /* R4174 - Write Sequencer 78 */ - { 0x010F, 0x010F, 0x0000 }, /* R4175 - Write Sequencer 79 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4176 - Write Sequencer 80 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4177 - Write Sequencer 81 */ - { 0x070F, 0x070F, 0x0000 }, /* R4178 - Write Sequencer 82 */ - { 0x010F, 0x010F, 0x0000 }, /* R4179 - Write Sequencer 83 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4180 - Write Sequencer 84 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4181 - Write Sequencer 85 */ - { 0x070F, 0x070F, 0x0000 }, /* R4182 - Write Sequencer 86 */ - { 0x010F, 0x010F, 0x0000 }, /* R4183 - Write Sequencer 87 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4184 - Write Sequencer 88 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4185 - Write Sequencer 89 */ - { 0x070F, 0x070F, 0x0000 }, /* R4186 - Write Sequencer 90 */ - { 0x010F, 0x010F, 0x0000 }, /* R4187 - Write Sequencer 91 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4188 - Write Sequencer 92 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4189 - Write Sequencer 93 */ - { 0x070F, 0x070F, 0x0000 }, /* R4190 - Write Sequencer 94 */ - { 0x010F, 0x010F, 0x0000 }, /* R4191 - Write Sequencer 95 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4192 - Write Sequencer 96 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4193 - Write Sequencer 97 */ - { 0x070F, 0x070F, 0x0000 }, /* R4194 - Write Sequencer 98 */ - { 0x010F, 0x010F, 0x0000 }, /* R4195 - Write Sequencer 99 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4196 - Write Sequencer 100 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4197 - Write Sequencer 101 */ - { 0x070F, 0x070F, 0x0000 }, /* R4198 - Write Sequencer 102 */ - { 0x010F, 0x010F, 0x0000 }, /* R4199 - Write Sequencer 103 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4200 - Write Sequencer 104 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4201 - Write Sequencer 105 */ - { 0x070F, 0x070F, 0x0000 }, /* R4202 - Write Sequencer 106 */ - { 0x010F, 0x010F, 0x0000 }, /* R4203 - Write Sequencer 107 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4204 - Write Sequencer 108 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4205 - Write Sequencer 109 */ - { 0x070F, 0x070F, 0x0000 }, /* R4206 - Write Sequencer 110 */ - { 0x010F, 0x010F, 0x0000 }, /* R4207 - Write Sequencer 111 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4208 - Write Sequencer 112 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4209 - Write Sequencer 113 */ - { 0x070F, 0x070F, 0x0000 }, /* R4210 - Write Sequencer 114 */ - { 0x010F, 0x010F, 0x0000 }, /* R4211 - Write Sequencer 115 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4212 - Write Sequencer 116 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4213 - Write Sequencer 117 */ - { 0x070F, 0x070F, 0x0000 }, /* R4214 - Write Sequencer 118 */ - { 0x010F, 0x010F, 0x0000 }, /* R4215 - Write Sequencer 119 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4216 - Write Sequencer 120 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4217 - Write Sequencer 121 */ - { 0x070F, 0x070F, 0x0000 }, /* R4218 - Write Sequencer 122 */ - { 0x010F, 0x010F, 0x0000 }, /* R4219 - Write Sequencer 123 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4220 - Write Sequencer 124 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4221 - Write Sequencer 125 */ - { 0x070F, 0x070F, 0x0000 }, /* R4222 - Write Sequencer 126 */ - { 0x010F, 0x010F, 0x0000 }, /* R4223 - Write Sequencer 127 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4224 - Write Sequencer 128 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4225 - Write Sequencer 129 */ - { 0x070F, 0x070F, 0x0000 }, /* R4226 - Write Sequencer 130 */ - { 0x010F, 0x010F, 0x0000 }, /* R4227 - Write Sequencer 131 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4228 - Write Sequencer 132 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4229 - Write Sequencer 133 */ - { 0x070F, 0x070F, 0x0000 }, /* R4230 - Write Sequencer 134 */ - { 0x010F, 0x010F, 0x0000 }, /* R4231 - Write Sequencer 135 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4232 - Write Sequencer 136 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4233 - Write Sequencer 137 */ - { 0x070F, 0x070F, 0x0000 }, /* R4234 - Write Sequencer 138 */ - { 0x010F, 0x010F, 0x0000 }, /* R4235 - Write Sequencer 139 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4236 - Write Sequencer 140 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4237 - Write Sequencer 141 */ - { 0x070F, 0x070F, 0x0000 }, /* R4238 - Write Sequencer 142 */ - { 0x010F, 0x010F, 0x0000 }, /* R4239 - Write Sequencer 143 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4240 - Write Sequencer 144 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4241 - Write Sequencer 145 */ - { 0x070F, 0x070F, 0x0000 }, /* R4242 - Write Sequencer 146 */ - { 0x010F, 0x010F, 0x0000 }, /* R4243 - Write Sequencer 147 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4244 - Write Sequencer 148 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4245 - Write Sequencer 149 */ - { 0x070F, 0x070F, 0x0000 }, /* R4246 - Write Sequencer 150 */ - { 0x010F, 0x010F, 0x0000 }, /* R4247 - Write Sequencer 151 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4248 - Write Sequencer 152 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4249 - Write Sequencer 153 */ - { 0x070F, 0x070F, 0x0000 }, /* R4250 - Write Sequencer 154 */ - { 0x010F, 0x010F, 0x0000 }, /* R4251 - Write Sequencer 155 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4252 - Write Sequencer 156 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4253 - Write Sequencer 157 */ - { 0x070F, 0x070F, 0x0000 }, /* R4254 - Write Sequencer 158 */ - { 0x010F, 0x010F, 0x0000 }, /* R4255 - Write Sequencer 159 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4256 - Write Sequencer 160 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4257 - Write Sequencer 161 */ - { 0x070F, 0x070F, 0x0000 }, /* R4258 - Write Sequencer 162 */ - { 0x010F, 0x010F, 0x0000 }, /* R4259 - Write Sequencer 163 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4260 - Write Sequencer 164 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4261 - Write Sequencer 165 */ - { 0x070F, 0x070F, 0x0000 }, /* R4262 - Write Sequencer 166 */ - { 0x010F, 0x010F, 0x0000 }, /* R4263 - Write Sequencer 167 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4264 - Write Sequencer 168 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4265 - Write Sequencer 169 */ - { 0x070F, 0x070F, 0x0000 }, /* R4266 - Write Sequencer 170 */ - { 0x010F, 0x010F, 0x0000 }, /* R4267 - Write Sequencer 171 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4268 - Write Sequencer 172 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4269 - Write Sequencer 173 */ - { 0x070F, 0x070F, 0x0000 }, /* R4270 - Write Sequencer 174 */ - { 0x010F, 0x010F, 0x0000 }, /* R4271 - Write Sequencer 175 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4272 - Write Sequencer 176 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4273 - Write Sequencer 177 */ - { 0x070F, 0x070F, 0x0000 }, /* R4274 - Write Sequencer 178 */ - { 0x010F, 0x010F, 0x0000 }, /* R4275 - Write Sequencer 179 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4276 - Write Sequencer 180 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4277 - Write Sequencer 181 */ - { 0x070F, 0x070F, 0x0000 }, /* R4278 - Write Sequencer 182 */ - { 0x010F, 0x010F, 0x0000 }, /* R4279 - Write Sequencer 183 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4280 - Write Sequencer 184 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4281 - Write Sequencer 185 */ - { 0x070F, 0x070F, 0x0000 }, /* R4282 - Write Sequencer 186 */ - { 0x010F, 0x010F, 0x0000 }, /* R4283 - Write Sequencer 187 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4284 - Write Sequencer 188 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4285 - Write Sequencer 189 */ - { 0x070F, 0x070F, 0x0000 }, /* R4286 - Write Sequencer 190 */ - { 0x010F, 0x010F, 0x0000 }, /* R4287 - Write Sequencer 191 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4288 - Write Sequencer 192 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4289 - Write Sequencer 193 */ - { 0x070F, 0x070F, 0x0000 }, /* R4290 - Write Sequencer 194 */ - { 0x010F, 0x010F, 0x0000 }, /* R4291 - Write Sequencer 195 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4292 - Write Sequencer 196 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4293 - Write Sequencer 197 */ - { 0x070F, 0x070F, 0x0000 }, /* R4294 - Write Sequencer 198 */ - { 0x010F, 0x010F, 0x0000 }, /* R4295 - Write Sequencer 199 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4296 - Write Sequencer 200 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4297 - Write Sequencer 201 */ - { 0x070F, 0x070F, 0x0000 }, /* R4298 - Write Sequencer 202 */ - { 0x010F, 0x010F, 0x0000 }, /* R4299 - Write Sequencer 203 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4300 - Write Sequencer 204 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4301 - Write Sequencer 205 */ - { 0x070F, 0x070F, 0x0000 }, /* R4302 - Write Sequencer 206 */ - { 0x010F, 0x010F, 0x0000 }, /* R4303 - Write Sequencer 207 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4304 - Write Sequencer 208 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4305 - Write Sequencer 209 */ - { 0x070F, 0x070F, 0x0000 }, /* R4306 - Write Sequencer 210 */ - { 0x010F, 0x010F, 0x0000 }, /* R4307 - Write Sequencer 211 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4308 - Write Sequencer 212 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4309 - Write Sequencer 213 */ - { 0x070F, 0x070F, 0x0000 }, /* R4310 - Write Sequencer 214 */ - { 0x010F, 0x010F, 0x0000 }, /* R4311 - Write Sequencer 215 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4312 - Write Sequencer 216 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4313 - Write Sequencer 217 */ - { 0x070F, 0x070F, 0x0000 }, /* R4314 - Write Sequencer 218 */ - { 0x010F, 0x010F, 0x0000 }, /* R4315 - Write Sequencer 219 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4316 - Write Sequencer 220 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4317 - Write Sequencer 221 */ - { 0x070F, 0x070F, 0x0000 }, /* R4318 - Write Sequencer 222 */ - { 0x010F, 0x010F, 0x0000 }, /* R4319 - Write Sequencer 223 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4320 - Write Sequencer 224 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4321 - Write Sequencer 225 */ - { 0x070F, 0x070F, 0x0000 }, /* R4322 - Write Sequencer 226 */ - { 0x010F, 0x010F, 0x0000 }, /* R4323 - Write Sequencer 227 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4324 - Write Sequencer 228 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4325 - Write Sequencer 229 */ - { 0x070F, 0x070F, 0x0000 }, /* R4326 - Write Sequencer 230 */ - { 0x010F, 0x010F, 0x0000 }, /* R4327 - Write Sequencer 231 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4328 - Write Sequencer 232 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4329 - Write Sequencer 233 */ - { 0x070F, 0x070F, 0x0000 }, /* R4330 - Write Sequencer 234 */ - { 0x010F, 0x010F, 0x0000 }, /* R4331 - Write Sequencer 235 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4332 - Write Sequencer 236 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4333 - Write Sequencer 237 */ - { 0x070F, 0x070F, 0x0000 }, /* R4334 - Write Sequencer 238 */ - { 0x010F, 0x010F, 0x0000 }, /* R4335 - Write Sequencer 239 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4336 - Write Sequencer 240 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4337 - Write Sequencer 241 */ - { 0x070F, 0x070F, 0x0000 }, /* R4338 - Write Sequencer 242 */ - { 0x010F, 0x010F, 0x0000 }, /* R4339 - Write Sequencer 243 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4340 - Write Sequencer 244 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4341 - Write Sequencer 245 */ - { 0x070F, 0x070F, 0x0000 }, /* R4342 - Write Sequencer 246 */ - { 0x010F, 0x010F, 0x0000 }, /* R4343 - Write Sequencer 247 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4344 - Write Sequencer 248 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4345 - Write Sequencer 249 */ - { 0x070F, 0x070F, 0x0000 }, /* R4346 - Write Sequencer 250 */ - { 0x010F, 0x010F, 0x0000 }, /* R4347 - Write Sequencer 251 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4348 - Write Sequencer 252 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4349 - Write Sequencer 253 */ - { 0x070F, 0x070F, 0x0000 }, /* R4350 - Write Sequencer 254 */ - { 0x010F, 0x010F, 0x0000 }, /* R4351 - Write Sequencer 255 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4352 - Write Sequencer 256 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4353 - Write Sequencer 257 */ - { 0x070F, 0x070F, 0x0000 }, /* R4354 - Write Sequencer 258 */ - { 0x010F, 0x010F, 0x0000 }, /* R4355 - Write Sequencer 259 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4356 - Write Sequencer 260 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4357 - Write Sequencer 261 */ - { 0x070F, 0x070F, 0x0000 }, /* R4358 - Write Sequencer 262 */ - { 0x010F, 0x010F, 0x0000 }, /* R4359 - Write Sequencer 263 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4360 - Write Sequencer 264 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4361 - Write Sequencer 265 */ - { 0x070F, 0x070F, 0x0000 }, /* R4362 - Write Sequencer 266 */ - { 0x010F, 0x010F, 0x0000 }, /* R4363 - Write Sequencer 267 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4364 - Write Sequencer 268 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4365 - Write Sequencer 269 */ - { 0x070F, 0x070F, 0x0000 }, /* R4366 - Write Sequencer 270 */ - { 0x010F, 0x010F, 0x0000 }, /* R4367 - Write Sequencer 271 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4368 - Write Sequencer 272 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4369 - Write Sequencer 273 */ - { 0x070F, 0x070F, 0x0000 }, /* R4370 - Write Sequencer 274 */ - { 0x010F, 0x010F, 0x0000 }, /* R4371 - Write Sequencer 275 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4372 - Write Sequencer 276 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4373 - Write Sequencer 277 */ - { 0x070F, 0x070F, 0x0000 }, /* R4374 - Write Sequencer 278 */ - { 0x010F, 0x010F, 0x0000 }, /* R4375 - Write Sequencer 279 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4376 - Write Sequencer 280 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4377 - Write Sequencer 281 */ - { 0x070F, 0x070F, 0x0000 }, /* R4378 - Write Sequencer 282 */ - { 0x010F, 0x010F, 0x0000 }, /* R4379 - Write Sequencer 283 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4380 - Write Sequencer 284 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4381 - Write Sequencer 285 */ - { 0x070F, 0x070F, 0x0000 }, /* R4382 - Write Sequencer 286 */ - { 0x010F, 0x010F, 0x0000 }, /* R4383 - Write Sequencer 287 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4384 - Write Sequencer 288 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4385 - Write Sequencer 289 */ - { 0x070F, 0x070F, 0x0000 }, /* R4386 - Write Sequencer 290 */ - { 0x010F, 0x010F, 0x0000 }, /* R4387 - Write Sequencer 291 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4388 - Write Sequencer 292 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4389 - Write Sequencer 293 */ - { 0x070F, 0x070F, 0x0000 }, /* R4390 - Write Sequencer 294 */ - { 0x010F, 0x010F, 0x0000 }, /* R4391 - Write Sequencer 295 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4392 - Write Sequencer 296 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4393 - Write Sequencer 297 */ - { 0x070F, 0x070F, 0x0000 }, /* R4394 - Write Sequencer 298 */ - { 0x010F, 0x010F, 0x0000 }, /* R4395 - Write Sequencer 299 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4396 - Write Sequencer 300 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4397 - Write Sequencer 301 */ - { 0x070F, 0x070F, 0x0000 }, /* R4398 - Write Sequencer 302 */ - { 0x010F, 0x010F, 0x0000 }, /* R4399 - Write Sequencer 303 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4400 - Write Sequencer 304 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4401 - Write Sequencer 305 */ - { 0x070F, 0x070F, 0x0000 }, /* R4402 - Write Sequencer 306 */ - { 0x010F, 0x010F, 0x0000 }, /* R4403 - Write Sequencer 307 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4404 - Write Sequencer 308 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4405 - Write Sequencer 309 */ - { 0x070F, 0x070F, 0x0000 }, /* R4406 - Write Sequencer 310 */ - { 0x010F, 0x010F, 0x0000 }, /* R4407 - Write Sequencer 311 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4408 - Write Sequencer 312 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4409 - Write Sequencer 313 */ - { 0x070F, 0x070F, 0x0000 }, /* R4410 - Write Sequencer 314 */ - { 0x010F, 0x010F, 0x0000 }, /* R4411 - Write Sequencer 315 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4412 - Write Sequencer 316 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4413 - Write Sequencer 317 */ - { 0x070F, 0x070F, 0x0000 }, /* R4414 - Write Sequencer 318 */ - { 0x010F, 0x010F, 0x0000 }, /* R4415 - Write Sequencer 319 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4416 - Write Sequencer 320 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4417 - Write Sequencer 321 */ - { 0x070F, 0x070F, 0x0000 }, /* R4418 - Write Sequencer 322 */ - { 0x010F, 0x010F, 0x0000 }, /* R4419 - Write Sequencer 323 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4420 - Write Sequencer 324 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4421 - Write Sequencer 325 */ - { 0x070F, 0x070F, 0x0000 }, /* R4422 - Write Sequencer 326 */ - { 0x010F, 0x010F, 0x0000 }, /* R4423 - Write Sequencer 327 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4424 - Write Sequencer 328 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4425 - Write Sequencer 329 */ - { 0x070F, 0x070F, 0x0000 }, /* R4426 - Write Sequencer 330 */ - { 0x010F, 0x010F, 0x0000 }, /* R4427 - Write Sequencer 331 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4428 - Write Sequencer 332 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4429 - Write Sequencer 333 */ - { 0x070F, 0x070F, 0x0000 }, /* R4430 - Write Sequencer 334 */ - { 0x010F, 0x010F, 0x0000 }, /* R4431 - Write Sequencer 335 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4432 - Write Sequencer 336 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4433 - Write Sequencer 337 */ - { 0x070F, 0x070F, 0x0000 }, /* R4434 - Write Sequencer 338 */ - { 0x010F, 0x010F, 0x0000 }, /* R4435 - Write Sequencer 339 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4436 - Write Sequencer 340 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4437 - Write Sequencer 341 */ - { 0x070F, 0x070F, 0x0000 }, /* R4438 - Write Sequencer 342 */ - { 0x010F, 0x010F, 0x0000 }, /* R4439 - Write Sequencer 343 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4440 - Write Sequencer 344 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4441 - Write Sequencer 345 */ - { 0x070F, 0x070F, 0x0000 }, /* R4442 - Write Sequencer 346 */ - { 0x010F, 0x010F, 0x0000 }, /* R4443 - Write Sequencer 347 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4444 - Write Sequencer 348 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4445 - Write Sequencer 349 */ - { 0x070F, 0x070F, 0x0000 }, /* R4446 - Write Sequencer 350 */ - { 0x010F, 0x010F, 0x0000 }, /* R4447 - Write Sequencer 351 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4448 - Write Sequencer 352 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4449 - Write Sequencer 353 */ - { 0x070F, 0x070F, 0x0000 }, /* R4450 - Write Sequencer 354 */ - { 0x010F, 0x010F, 0x0000 }, /* R4451 - Write Sequencer 355 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4452 - Write Sequencer 356 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4453 - Write Sequencer 357 */ - { 0x070F, 0x070F, 0x0000 }, /* R4454 - Write Sequencer 358 */ - { 0x010F, 0x010F, 0x0000 }, /* R4455 - Write Sequencer 359 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4456 - Write Sequencer 360 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4457 - Write Sequencer 361 */ - { 0x070F, 0x070F, 0x0000 }, /* R4458 - Write Sequencer 362 */ - { 0x010F, 0x010F, 0x0000 }, /* R4459 - Write Sequencer 363 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4460 - Write Sequencer 364 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4461 - Write Sequencer 365 */ - { 0x070F, 0x070F, 0x0000 }, /* R4462 - Write Sequencer 366 */ - { 0x010F, 0x010F, 0x0000 }, /* R4463 - Write Sequencer 367 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4464 - Write Sequencer 368 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4465 - Write Sequencer 369 */ - { 0x070F, 0x070F, 0x0000 }, /* R4466 - Write Sequencer 370 */ - { 0x010F, 0x010F, 0x0000 }, /* R4467 - Write Sequencer 371 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4468 - Write Sequencer 372 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4469 - Write Sequencer 373 */ - { 0x070F, 0x070F, 0x0000 }, /* R4470 - Write Sequencer 374 */ - { 0x010F, 0x010F, 0x0000 }, /* R4471 - Write Sequencer 375 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4472 - Write Sequencer 376 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4473 - Write Sequencer 377 */ - { 0x070F, 0x070F, 0x0000 }, /* R4474 - Write Sequencer 378 */ - { 0x010F, 0x010F, 0x0000 }, /* R4475 - Write Sequencer 379 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4476 - Write Sequencer 380 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4477 - Write Sequencer 381 */ - { 0x070F, 0x070F, 0x0000 }, /* R4478 - Write Sequencer 382 */ - { 0x010F, 0x010F, 0x0000 }, /* R4479 - Write Sequencer 383 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4480 - Write Sequencer 384 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4481 - Write Sequencer 385 */ - { 0x070F, 0x070F, 0x0000 }, /* R4482 - Write Sequencer 386 */ - { 0x010F, 0x010F, 0x0000 }, /* R4483 - Write Sequencer 387 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4484 - Write Sequencer 388 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4485 - Write Sequencer 389 */ - { 0x070F, 0x070F, 0x0000 }, /* R4486 - Write Sequencer 390 */ - { 0x010F, 0x010F, 0x0000 }, /* R4487 - Write Sequencer 391 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4488 - Write Sequencer 392 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4489 - Write Sequencer 393 */ - { 0x070F, 0x070F, 0x0000 }, /* R4490 - Write Sequencer 394 */ - { 0x010F, 0x010F, 0x0000 }, /* R4491 - Write Sequencer 395 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4492 - Write Sequencer 396 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4493 - Write Sequencer 397 */ - { 0x070F, 0x070F, 0x0000 }, /* R4494 - Write Sequencer 398 */ - { 0x010F, 0x010F, 0x0000 }, /* R4495 - Write Sequencer 399 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4496 - Write Sequencer 400 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4497 - Write Sequencer 401 */ - { 0x070F, 0x070F, 0x0000 }, /* R4498 - Write Sequencer 402 */ - { 0x010F, 0x010F, 0x0000 }, /* R4499 - Write Sequencer 403 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4500 - Write Sequencer 404 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4501 - Write Sequencer 405 */ - { 0x070F, 0x070F, 0x0000 }, /* R4502 - Write Sequencer 406 */ - { 0x010F, 0x010F, 0x0000 }, /* R4503 - Write Sequencer 407 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4504 - Write Sequencer 408 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4505 - Write Sequencer 409 */ - { 0x070F, 0x070F, 0x0000 }, /* R4506 - Write Sequencer 410 */ - { 0x010F, 0x010F, 0x0000 }, /* R4507 - Write Sequencer 411 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4508 - Write Sequencer 412 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4509 - Write Sequencer 413 */ - { 0x070F, 0x070F, 0x0000 }, /* R4510 - Write Sequencer 414 */ - { 0x010F, 0x010F, 0x0000 }, /* R4511 - Write Sequencer 415 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4512 - Write Sequencer 416 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4513 - Write Sequencer 417 */ - { 0x070F, 0x070F, 0x0000 }, /* R4514 - Write Sequencer 418 */ - { 0x010F, 0x010F, 0x0000 }, /* R4515 - Write Sequencer 419 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4516 - Write Sequencer 420 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4517 - Write Sequencer 421 */ - { 0x070F, 0x070F, 0x0000 }, /* R4518 - Write Sequencer 422 */ - { 0x010F, 0x010F, 0x0000 }, /* R4519 - Write Sequencer 423 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4520 - Write Sequencer 424 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4521 - Write Sequencer 425 */ - { 0x070F, 0x070F, 0x0000 }, /* R4522 - Write Sequencer 426 */ - { 0x010F, 0x010F, 0x0000 }, /* R4523 - Write Sequencer 427 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4524 - Write Sequencer 428 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4525 - Write Sequencer 429 */ - { 0x070F, 0x070F, 0x0000 }, /* R4526 - Write Sequencer 430 */ - { 0x010F, 0x010F, 0x0000 }, /* R4527 - Write Sequencer 431 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4528 - Write Sequencer 432 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4529 - Write Sequencer 433 */ - { 0x070F, 0x070F, 0x0000 }, /* R4530 - Write Sequencer 434 */ - { 0x010F, 0x010F, 0x0000 }, /* R4531 - Write Sequencer 435 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4532 - Write Sequencer 436 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4533 - Write Sequencer 437 */ - { 0x070F, 0x070F, 0x0000 }, /* R4534 - Write Sequencer 438 */ - { 0x010F, 0x010F, 0x0000 }, /* R4535 - Write Sequencer 439 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4536 - Write Sequencer 440 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4537 - Write Sequencer 441 */ - { 0x070F, 0x070F, 0x0000 }, /* R4538 - Write Sequencer 442 */ - { 0x010F, 0x010F, 0x0000 }, /* R4539 - Write Sequencer 443 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4540 - Write Sequencer 444 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4541 - Write Sequencer 445 */ - { 0x070F, 0x070F, 0x0000 }, /* R4542 - Write Sequencer 446 */ - { 0x010F, 0x010F, 0x0000 }, /* R4543 - Write Sequencer 447 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4544 - Write Sequencer 448 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4545 - Write Sequencer 449 */ - { 0x070F, 0x070F, 0x0000 }, /* R4546 - Write Sequencer 450 */ - { 0x010F, 0x010F, 0x0000 }, /* R4547 - Write Sequencer 451 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4548 - Write Sequencer 452 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4549 - Write Sequencer 453 */ - { 0x070F, 0x070F, 0x0000 }, /* R4550 - Write Sequencer 454 */ - { 0x010F, 0x010F, 0x0000 }, /* R4551 - Write Sequencer 455 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4552 - Write Sequencer 456 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4553 - Write Sequencer 457 */ - { 0x070F, 0x070F, 0x0000 }, /* R4554 - Write Sequencer 458 */ - { 0x010F, 0x010F, 0x0000 }, /* R4555 - Write Sequencer 459 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4556 - Write Sequencer 460 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4557 - Write Sequencer 461 */ - { 0x070F, 0x070F, 0x0000 }, /* R4558 - Write Sequencer 462 */ - { 0x010F, 0x010F, 0x0000 }, /* R4559 - Write Sequencer 463 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4560 - Write Sequencer 464 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4561 - Write Sequencer 465 */ - { 0x070F, 0x070F, 0x0000 }, /* R4562 - Write Sequencer 466 */ - { 0x010F, 0x010F, 0x0000 }, /* R4563 - Write Sequencer 467 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4564 - Write Sequencer 468 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4565 - Write Sequencer 469 */ - { 0x070F, 0x070F, 0x0000 }, /* R4566 - Write Sequencer 470 */ - { 0x010F, 0x010F, 0x0000 }, /* R4567 - Write Sequencer 471 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4568 - Write Sequencer 472 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4569 - Write Sequencer 473 */ - { 0x070F, 0x070F, 0x0000 }, /* R4570 - Write Sequencer 474 */ - { 0x010F, 0x010F, 0x0000 }, /* R4571 - Write Sequencer 475 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4572 - Write Sequencer 476 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4573 - Write Sequencer 477 */ - { 0x070F, 0x070F, 0x0000 }, /* R4574 - Write Sequencer 478 */ - { 0x010F, 0x010F, 0x0000 }, /* R4575 - Write Sequencer 479 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4576 - Write Sequencer 480 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4577 - Write Sequencer 481 */ - { 0x070F, 0x070F, 0x0000 }, /* R4578 - Write Sequencer 482 */ - { 0x010F, 0x010F, 0x0000 }, /* R4579 - Write Sequencer 483 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4580 - Write Sequencer 484 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4581 - Write Sequencer 485 */ - { 0x070F, 0x070F, 0x0000 }, /* R4582 - Write Sequencer 486 */ - { 0x010F, 0x010F, 0x0000 }, /* R4583 - Write Sequencer 487 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4584 - Write Sequencer 488 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4585 - Write Sequencer 489 */ - { 0x070F, 0x070F, 0x0000 }, /* R4586 - Write Sequencer 490 */ - { 0x010F, 0x010F, 0x0000 }, /* R4587 - Write Sequencer 491 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4588 - Write Sequencer 492 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4589 - Write Sequencer 493 */ - { 0x070F, 0x070F, 0x0000 }, /* R4590 - Write Sequencer 494 */ - { 0x010F, 0x010F, 0x0000 }, /* R4591 - Write Sequencer 495 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4592 - Write Sequencer 496 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4593 - Write Sequencer 497 */ - { 0x070F, 0x070F, 0x0000 }, /* R4594 - Write Sequencer 498 */ - { 0x010F, 0x010F, 0x0000 }, /* R4595 - Write Sequencer 499 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4596 - Write Sequencer 500 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4597 - Write Sequencer 501 */ - { 0x070F, 0x070F, 0x0000 }, /* R4598 - Write Sequencer 502 */ - { 0x010F, 0x010F, 0x0000 }, /* R4599 - Write Sequencer 503 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4600 - Write Sequencer 504 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4601 - Write Sequencer 505 */ - { 0x070F, 0x070F, 0x0000 }, /* R4602 - Write Sequencer 506 */ - { 0x010F, 0x010F, 0x0000 }, /* R4603 - Write Sequencer 507 */ - { 0x3FFF, 0x3FFF, 0x0000 }, /* R4604 - Write Sequencer 508 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R4605 - Write Sequencer 509 */ - { 0x070F, 0x070F, 0x0000 }, /* R4606 - Write Sequencer 510 */ - { 0x010F, 0x010F, 0x0000 }, /* R4607 - Write Sequencer 511 */ - { 0x0000, 0x0000, 0x0000 }, /* R4608 */ - { 0x0000, 0x0000, 0x0000 }, /* R4609 */ - { 0x0000, 0x0000, 0x0000 }, /* R4610 */ - { 0x0000, 0x0000, 0x0000 }, /* R4611 */ - { 0x0000, 0x0000, 0x0000 }, /* R4612 */ - { 0x0000, 0x0000, 0x0000 }, /* R4613 */ - { 0x0000, 0x0000, 0x0000 }, /* R4614 */ - { 0x0000, 0x0000, 0x0000 }, /* R4615 */ - { 0x0000, 0x0000, 0x0000 }, /* R4616 */ - { 0x0000, 0x0000, 0x0000 }, /* R4617 */ - { 0x0000, 0x0000, 0x0000 }, /* R4618 */ - { 0x0000, 0x0000, 0x0000 }, /* R4619 */ - { 0x0000, 0x0000, 0x0000 }, /* R4620 */ - { 0x0000, 0x0000, 0x0000 }, /* R4621 */ - { 0x0000, 0x0000, 0x0000 }, /* R4622 */ - { 0x0000, 0x0000, 0x0000 }, /* R4623 */ - { 0x0000, 0x0000, 0x0000 }, /* R4624 */ - { 0x0000, 0x0000, 0x0000 }, /* R4625 */ - { 0x0000, 0x0000, 0x0000 }, /* R4626 */ - { 0x0000, 0x0000, 0x0000 }, /* R4627 */ - { 0x0000, 0x0000, 0x0000 }, /* R4628 */ - { 0x0000, 0x0000, 0x0000 }, /* R4629 */ - { 0x0000, 0x0000, 0x0000 }, /* R4630 */ - { 0x0000, 0x0000, 0x0000 }, /* R4631 */ - { 0x0000, 0x0000, 0x0000 }, /* R4632 */ - { 0x0000, 0x0000, 0x0000 }, /* R4633 */ - { 0x0000, 0x0000, 0x0000 }, /* R4634 */ - { 0x0000, 0x0000, 0x0000 }, /* R4635 */ - { 0x0000, 0x0000, 0x0000 }, /* R4636 */ - { 0x0000, 0x0000, 0x0000 }, /* R4637 */ - { 0x0000, 0x0000, 0x0000 }, /* R4638 */ - { 0x0000, 0x0000, 0x0000 }, /* R4639 */ - { 0x0000, 0x0000, 0x0000 }, /* R4640 */ - { 0x0000, 0x0000, 0x0000 }, /* R4641 */ - { 0x0000, 0x0000, 0x0000 }, /* R4642 */ - { 0x0000, 0x0000, 0x0000 }, /* R4643 */ - { 0x0000, 0x0000, 0x0000 }, /* R4644 */ - { 0x0000, 0x0000, 0x0000 }, /* R4645 */ - { 0x0000, 0x0000, 0x0000 }, /* R4646 */ - { 0x0000, 0x0000, 0x0000 }, /* R4647 */ - { 0x0000, 0x0000, 0x0000 }, /* R4648 */ - { 0x0000, 0x0000, 0x0000 }, /* R4649 */ - { 0x0000, 0x0000, 0x0000 }, /* R4650 */ - { 0x0000, 0x0000, 0x0000 }, /* R4651 */ - { 0x0000, 0x0000, 0x0000 }, /* R4652 */ - { 0x0000, 0x0000, 0x0000 }, /* R4653 */ - { 0x0000, 0x0000, 0x0000 }, /* R4654 */ - { 0x0000, 0x0000, 0x0000 }, /* R4655 */ - { 0x0000, 0x0000, 0x0000 }, /* R4656 */ - { 0x0000, 0x0000, 0x0000 }, /* R4657 */ - { 0x0000, 0x0000, 0x0000 }, /* R4658 */ - { 0x0000, 0x0000, 0x0000 }, /* R4659 */ - { 0x0000, 0x0000, 0x0000 }, /* R4660 */ - { 0x0000, 0x0000, 0x0000 }, /* R4661 */ - { 0x0000, 0x0000, 0x0000 }, /* R4662 */ - { 0x0000, 0x0000, 0x0000 }, /* R4663 */ - { 0x0000, 0x0000, 0x0000 }, /* R4664 */ - { 0x0000, 0x0000, 0x0000 }, /* R4665 */ - { 0x0000, 0x0000, 0x0000 }, /* R4666 */ - { 0x0000, 0x0000, 0x0000 }, /* R4667 */ - { 0x0000, 0x0000, 0x0000 }, /* R4668 */ - { 0x0000, 0x0000, 0x0000 }, /* R4669 */ - { 0x0000, 0x0000, 0x0000 }, /* R4670 */ - { 0x0000, 0x0000, 0x0000 }, /* R4671 */ - { 0x0000, 0x0000, 0x0000 }, /* R4672 */ - { 0x0000, 0x0000, 0x0000 }, /* R4673 */ - { 0x0000, 0x0000, 0x0000 }, /* R4674 */ - { 0x0000, 0x0000, 0x0000 }, /* R4675 */ - { 0x0000, 0x0000, 0x0000 }, /* R4676 */ - { 0x0000, 0x0000, 0x0000 }, /* R4677 */ - { 0x0000, 0x0000, 0x0000 }, /* R4678 */ - { 0x0000, 0x0000, 0x0000 }, /* R4679 */ - { 0x0000, 0x0000, 0x0000 }, /* R4680 */ - { 0x0000, 0x0000, 0x0000 }, /* R4681 */ - { 0x0000, 0x0000, 0x0000 }, /* R4682 */ - { 0x0000, 0x0000, 0x0000 }, /* R4683 */ - { 0x0000, 0x0000, 0x0000 }, /* R4684 */ - { 0x0000, 0x0000, 0x0000 }, /* R4685 */ - { 0x0000, 0x0000, 0x0000 }, /* R4686 */ - { 0x0000, 0x0000, 0x0000 }, /* R4687 */ - { 0x0000, 0x0000, 0x0000 }, /* R4688 */ - { 0x0000, 0x0000, 0x0000 }, /* R4689 */ - { 0x0000, 0x0000, 0x0000 }, /* R4690 */ - { 0x0000, 0x0000, 0x0000 }, /* R4691 */ - { 0x0000, 0x0000, 0x0000 }, /* R4692 */ - { 0x0000, 0x0000, 0x0000 }, /* R4693 */ - { 0x0000, 0x0000, 0x0000 }, /* R4694 */ - { 0x0000, 0x0000, 0x0000 }, /* R4695 */ - { 0x0000, 0x0000, 0x0000 }, /* R4696 */ - { 0x0000, 0x0000, 0x0000 }, /* R4697 */ - { 0x0000, 0x0000, 0x0000 }, /* R4698 */ - { 0x0000, 0x0000, 0x0000 }, /* R4699 */ - { 0x0000, 0x0000, 0x0000 }, /* R4700 */ - { 0x0000, 0x0000, 0x0000 }, /* R4701 */ - { 0x0000, 0x0000, 0x0000 }, /* R4702 */ - { 0x0000, 0x0000, 0x0000 }, /* R4703 */ - { 0x0000, 0x0000, 0x0000 }, /* R4704 */ - { 0x0000, 0x0000, 0x0000 }, /* R4705 */ - { 0x0000, 0x0000, 0x0000 }, /* R4706 */ - { 0x0000, 0x0000, 0x0000 }, /* R4707 */ - { 0x0000, 0x0000, 0x0000 }, /* R4708 */ - { 0x0000, 0x0000, 0x0000 }, /* R4709 */ - { 0x0000, 0x0000, 0x0000 }, /* R4710 */ - { 0x0000, 0x0000, 0x0000 }, /* R4711 */ - { 0x0000, 0x0000, 0x0000 }, /* R4712 */ - { 0x0000, 0x0000, 0x0000 }, /* R4713 */ - { 0x0000, 0x0000, 0x0000 }, /* R4714 */ - { 0x0000, 0x0000, 0x0000 }, /* R4715 */ - { 0x0000, 0x0000, 0x0000 }, /* R4716 */ - { 0x0000, 0x0000, 0x0000 }, /* R4717 */ - { 0x0000, 0x0000, 0x0000 }, /* R4718 */ - { 0x0000, 0x0000, 0x0000 }, /* R4719 */ - { 0x0000, 0x0000, 0x0000 }, /* R4720 */ - { 0x0000, 0x0000, 0x0000 }, /* R4721 */ - { 0x0000, 0x0000, 0x0000 }, /* R4722 */ - { 0x0000, 0x0000, 0x0000 }, /* R4723 */ - { 0x0000, 0x0000, 0x0000 }, /* R4724 */ - { 0x0000, 0x0000, 0x0000 }, /* R4725 */ - { 0x0000, 0x0000, 0x0000 }, /* R4726 */ - { 0x0000, 0x0000, 0x0000 }, /* R4727 */ - { 0x0000, 0x0000, 0x0000 }, /* R4728 */ - { 0x0000, 0x0000, 0x0000 }, /* R4729 */ - { 0x0000, 0x0000, 0x0000 }, /* R4730 */ - { 0x0000, 0x0000, 0x0000 }, /* R4731 */ - { 0x0000, 0x0000, 0x0000 }, /* R4732 */ - { 0x0000, 0x0000, 0x0000 }, /* R4733 */ - { 0x0000, 0x0000, 0x0000 }, /* R4734 */ - { 0x0000, 0x0000, 0x0000 }, /* R4735 */ - { 0x0000, 0x0000, 0x0000 }, /* R4736 */ - { 0x0000, 0x0000, 0x0000 }, /* R4737 */ - { 0x0000, 0x0000, 0x0000 }, /* R4738 */ - { 0x0000, 0x0000, 0x0000 }, /* R4739 */ - { 0x0000, 0x0000, 0x0000 }, /* R4740 */ - { 0x0000, 0x0000, 0x0000 }, /* R4741 */ - { 0x0000, 0x0000, 0x0000 }, /* R4742 */ - { 0x0000, 0x0000, 0x0000 }, /* R4743 */ - { 0x0000, 0x0000, 0x0000 }, /* R4744 */ - { 0x0000, 0x0000, 0x0000 }, /* R4745 */ - { 0x0000, 0x0000, 0x0000 }, /* R4746 */ - { 0x0000, 0x0000, 0x0000 }, /* R4747 */ - { 0x0000, 0x0000, 0x0000 }, /* R4748 */ - { 0x0000, 0x0000, 0x0000 }, /* R4749 */ - { 0x0000, 0x0000, 0x0000 }, /* R4750 */ - { 0x0000, 0x0000, 0x0000 }, /* R4751 */ - { 0x0000, 0x0000, 0x0000 }, /* R4752 */ - { 0x0000, 0x0000, 0x0000 }, /* R4753 */ - { 0x0000, 0x0000, 0x0000 }, /* R4754 */ - { 0x0000, 0x0000, 0x0000 }, /* R4755 */ - { 0x0000, 0x0000, 0x0000 }, /* R4756 */ - { 0x0000, 0x0000, 0x0000 }, /* R4757 */ - { 0x0000, 0x0000, 0x0000 }, /* R4758 */ - { 0x0000, 0x0000, 0x0000 }, /* R4759 */ - { 0x0000, 0x0000, 0x0000 }, /* R4760 */ - { 0x0000, 0x0000, 0x0000 }, /* R4761 */ - { 0x0000, 0x0000, 0x0000 }, /* R4762 */ - { 0x0000, 0x0000, 0x0000 }, /* R4763 */ - { 0x0000, 0x0000, 0x0000 }, /* R4764 */ - { 0x0000, 0x0000, 0x0000 }, /* R4765 */ - { 0x0000, 0x0000, 0x0000 }, /* R4766 */ - { 0x0000, 0x0000, 0x0000 }, /* R4767 */ - { 0x0000, 0x0000, 0x0000 }, /* R4768 */ - { 0x0000, 0x0000, 0x0000 }, /* R4769 */ - { 0x0000, 0x0000, 0x0000 }, /* R4770 */ - { 0x0000, 0x0000, 0x0000 }, /* R4771 */ - { 0x0000, 0x0000, 0x0000 }, /* R4772 */ - { 0x0000, 0x0000, 0x0000 }, /* R4773 */ - { 0x0000, 0x0000, 0x0000 }, /* R4774 */ - { 0x0000, 0x0000, 0x0000 }, /* R4775 */ - { 0x0000, 0x0000, 0x0000 }, /* R4776 */ - { 0x0000, 0x0000, 0x0000 }, /* R4777 */ - { 0x0000, 0x0000, 0x0000 }, /* R4778 */ - { 0x0000, 0x0000, 0x0000 }, /* R4779 */ - { 0x0000, 0x0000, 0x0000 }, /* R4780 */ - { 0x0000, 0x0000, 0x0000 }, /* R4781 */ - { 0x0000, 0x0000, 0x0000 }, /* R4782 */ - { 0x0000, 0x0000, 0x0000 }, /* R4783 */ - { 0x0000, 0x0000, 0x0000 }, /* R4784 */ - { 0x0000, 0x0000, 0x0000 }, /* R4785 */ - { 0x0000, 0x0000, 0x0000 }, /* R4786 */ - { 0x0000, 0x0000, 0x0000 }, /* R4787 */ - { 0x0000, 0x0000, 0x0000 }, /* R4788 */ - { 0x0000, 0x0000, 0x0000 }, /* R4789 */ - { 0x0000, 0x0000, 0x0000 }, /* R4790 */ - { 0x0000, 0x0000, 0x0000 }, /* R4791 */ - { 0x0000, 0x0000, 0x0000 }, /* R4792 */ - { 0x0000, 0x0000, 0x0000 }, /* R4793 */ - { 0x0000, 0x0000, 0x0000 }, /* R4794 */ - { 0x0000, 0x0000, 0x0000 }, /* R4795 */ - { 0x0000, 0x0000, 0x0000 }, /* R4796 */ - { 0x0000, 0x0000, 0x0000 }, /* R4797 */ - { 0x0000, 0x0000, 0x0000 }, /* R4798 */ - { 0x0000, 0x0000, 0x0000 }, /* R4799 */ - { 0x0000, 0x0000, 0x0000 }, /* R4800 */ - { 0x0000, 0x0000, 0x0000 }, /* R4801 */ - { 0x0000, 0x0000, 0x0000 }, /* R4802 */ - { 0x0000, 0x0000, 0x0000 }, /* R4803 */ - { 0x0000, 0x0000, 0x0000 }, /* R4804 */ - { 0x0000, 0x0000, 0x0000 }, /* R4805 */ - { 0x0000, 0x0000, 0x0000 }, /* R4806 */ - { 0x0000, 0x0000, 0x0000 }, /* R4807 */ - { 0x0000, 0x0000, 0x0000 }, /* R4808 */ - { 0x0000, 0x0000, 0x0000 }, /* R4809 */ - { 0x0000, 0x0000, 0x0000 }, /* R4810 */ - { 0x0000, 0x0000, 0x0000 }, /* R4811 */ - { 0x0000, 0x0000, 0x0000 }, /* R4812 */ - { 0x0000, 0x0000, 0x0000 }, /* R4813 */ - { 0x0000, 0x0000, 0x0000 }, /* R4814 */ - { 0x0000, 0x0000, 0x0000 }, /* R4815 */ - { 0x0000, 0x0000, 0x0000 }, /* R4816 */ - { 0x0000, 0x0000, 0x0000 }, /* R4817 */ - { 0x0000, 0x0000, 0x0000 }, /* R4818 */ - { 0x0000, 0x0000, 0x0000 }, /* R4819 */ - { 0x0000, 0x0000, 0x0000 }, /* R4820 */ - { 0x0000, 0x0000, 0x0000 }, /* R4821 */ - { 0x0000, 0x0000, 0x0000 }, /* R4822 */ - { 0x0000, 0x0000, 0x0000 }, /* R4823 */ - { 0x0000, 0x0000, 0x0000 }, /* R4824 */ - { 0x0000, 0x0000, 0x0000 }, /* R4825 */ - { 0x0000, 0x0000, 0x0000 }, /* R4826 */ - { 0x0000, 0x0000, 0x0000 }, /* R4827 */ - { 0x0000, 0x0000, 0x0000 }, /* R4828 */ - { 0x0000, 0x0000, 0x0000 }, /* R4829 */ - { 0x0000, 0x0000, 0x0000 }, /* R4830 */ - { 0x0000, 0x0000, 0x0000 }, /* R4831 */ - { 0x0000, 0x0000, 0x0000 }, /* R4832 */ - { 0x0000, 0x0000, 0x0000 }, /* R4833 */ - { 0x0000, 0x0000, 0x0000 }, /* R4834 */ - { 0x0000, 0x0000, 0x0000 }, /* R4835 */ - { 0x0000, 0x0000, 0x0000 }, /* R4836 */ - { 0x0000, 0x0000, 0x0000 }, /* R4837 */ - { 0x0000, 0x0000, 0x0000 }, /* R4838 */ - { 0x0000, 0x0000, 0x0000 }, /* R4839 */ - { 0x0000, 0x0000, 0x0000 }, /* R4840 */ - { 0x0000, 0x0000, 0x0000 }, /* R4841 */ - { 0x0000, 0x0000, 0x0000 }, /* R4842 */ - { 0x0000, 0x0000, 0x0000 }, /* R4843 */ - { 0x0000, 0x0000, 0x0000 }, /* R4844 */ - { 0x0000, 0x0000, 0x0000 }, /* R4845 */ - { 0x0000, 0x0000, 0x0000 }, /* R4846 */ - { 0x0000, 0x0000, 0x0000 }, /* R4847 */ - { 0x0000, 0x0000, 0x0000 }, /* R4848 */ - { 0x0000, 0x0000, 0x0000 }, /* R4849 */ - { 0x0000, 0x0000, 0x0000 }, /* R4850 */ - { 0x0000, 0x0000, 0x0000 }, /* R4851 */ - { 0x0000, 0x0000, 0x0000 }, /* R4852 */ - { 0x0000, 0x0000, 0x0000 }, /* R4853 */ - { 0x0000, 0x0000, 0x0000 }, /* R4854 */ - { 0x0000, 0x0000, 0x0000 }, /* R4855 */ - { 0x0000, 0x0000, 0x0000 }, /* R4856 */ - { 0x0000, 0x0000, 0x0000 }, /* R4857 */ - { 0x0000, 0x0000, 0x0000 }, /* R4858 */ - { 0x0000, 0x0000, 0x0000 }, /* R4859 */ - { 0x0000, 0x0000, 0x0000 }, /* R4860 */ - { 0x0000, 0x0000, 0x0000 }, /* R4861 */ - { 0x0000, 0x0000, 0x0000 }, /* R4862 */ - { 0x0000, 0x0000, 0x0000 }, /* R4863 */ - { 0x0000, 0x0000, 0x0000 }, /* R4864 */ - { 0x0000, 0x0000, 0x0000 }, /* R4865 */ - { 0x0000, 0x0000, 0x0000 }, /* R4866 */ - { 0x0000, 0x0000, 0x0000 }, /* R4867 */ - { 0x0000, 0x0000, 0x0000 }, /* R4868 */ - { 0x0000, 0x0000, 0x0000 }, /* R4869 */ - { 0x0000, 0x0000, 0x0000 }, /* R4870 */ - { 0x0000, 0x0000, 0x0000 }, /* R4871 */ - { 0x0000, 0x0000, 0x0000 }, /* R4872 */ - { 0x0000, 0x0000, 0x0000 }, /* R4873 */ - { 0x0000, 0x0000, 0x0000 }, /* R4874 */ - { 0x0000, 0x0000, 0x0000 }, /* R4875 */ - { 0x0000, 0x0000, 0x0000 }, /* R4876 */ - { 0x0000, 0x0000, 0x0000 }, /* R4877 */ - { 0x0000, 0x0000, 0x0000 }, /* R4878 */ - { 0x0000, 0x0000, 0x0000 }, /* R4879 */ - { 0x0000, 0x0000, 0x0000 }, /* R4880 */ - { 0x0000, 0x0000, 0x0000 }, /* R4881 */ - { 0x0000, 0x0000, 0x0000 }, /* R4882 */ - { 0x0000, 0x0000, 0x0000 }, /* R4883 */ - { 0x0000, 0x0000, 0x0000 }, /* R4884 */ - { 0x0000, 0x0000, 0x0000 }, /* R4885 */ - { 0x0000, 0x0000, 0x0000 }, /* R4886 */ - { 0x0000, 0x0000, 0x0000 }, /* R4887 */ - { 0x0000, 0x0000, 0x0000 }, /* R4888 */ - { 0x0000, 0x0000, 0x0000 }, /* R4889 */ - { 0x0000, 0x0000, 0x0000 }, /* R4890 */ - { 0x0000, 0x0000, 0x0000 }, /* R4891 */ - { 0x0000, 0x0000, 0x0000 }, /* R4892 */ - { 0x0000, 0x0000, 0x0000 }, /* R4893 */ - { 0x0000, 0x0000, 0x0000 }, /* R4894 */ - { 0x0000, 0x0000, 0x0000 }, /* R4895 */ - { 0x0000, 0x0000, 0x0000 }, /* R4896 */ - { 0x0000, 0x0000, 0x0000 }, /* R4897 */ - { 0x0000, 0x0000, 0x0000 }, /* R4898 */ - { 0x0000, 0x0000, 0x0000 }, /* R4899 */ - { 0x0000, 0x0000, 0x0000 }, /* R4900 */ - { 0x0000, 0x0000, 0x0000 }, /* R4901 */ - { 0x0000, 0x0000, 0x0000 }, /* R4902 */ - { 0x0000, 0x0000, 0x0000 }, /* R4903 */ - { 0x0000, 0x0000, 0x0000 }, /* R4904 */ - { 0x0000, 0x0000, 0x0000 }, /* R4905 */ - { 0x0000, 0x0000, 0x0000 }, /* R4906 */ - { 0x0000, 0x0000, 0x0000 }, /* R4907 */ - { 0x0000, 0x0000, 0x0000 }, /* R4908 */ - { 0x0000, 0x0000, 0x0000 }, /* R4909 */ - { 0x0000, 0x0000, 0x0000 }, /* R4910 */ - { 0x0000, 0x0000, 0x0000 }, /* R4911 */ - { 0x0000, 0x0000, 0x0000 }, /* R4912 */ - { 0x0000, 0x0000, 0x0000 }, /* R4913 */ - { 0x0000, 0x0000, 0x0000 }, /* R4914 */ - { 0x0000, 0x0000, 0x0000 }, /* R4915 */ - { 0x0000, 0x0000, 0x0000 }, /* R4916 */ - { 0x0000, 0x0000, 0x0000 }, /* R4917 */ - { 0x0000, 0x0000, 0x0000 }, /* R4918 */ - { 0x0000, 0x0000, 0x0000 }, /* R4919 */ - { 0x0000, 0x0000, 0x0000 }, /* R4920 */ - { 0x0000, 0x0000, 0x0000 }, /* R4921 */ - { 0x0000, 0x0000, 0x0000 }, /* R4922 */ - { 0x0000, 0x0000, 0x0000 }, /* R4923 */ - { 0x0000, 0x0000, 0x0000 }, /* R4924 */ - { 0x0000, 0x0000, 0x0000 }, /* R4925 */ - { 0x0000, 0x0000, 0x0000 }, /* R4926 */ - { 0x0000, 0x0000, 0x0000 }, /* R4927 */ - { 0x0000, 0x0000, 0x0000 }, /* R4928 */ - { 0x0000, 0x0000, 0x0000 }, /* R4929 */ - { 0x0000, 0x0000, 0x0000 }, /* R4930 */ - { 0x0000, 0x0000, 0x0000 }, /* R4931 */ - { 0x0000, 0x0000, 0x0000 }, /* R4932 */ - { 0x0000, 0x0000, 0x0000 }, /* R4933 */ - { 0x0000, 0x0000, 0x0000 }, /* R4934 */ - { 0x0000, 0x0000, 0x0000 }, /* R4935 */ - { 0x0000, 0x0000, 0x0000 }, /* R4936 */ - { 0x0000, 0x0000, 0x0000 }, /* R4937 */ - { 0x0000, 0x0000, 0x0000 }, /* R4938 */ - { 0x0000, 0x0000, 0x0000 }, /* R4939 */ - { 0x0000, 0x0000, 0x0000 }, /* R4940 */ - { 0x0000, 0x0000, 0x0000 }, /* R4941 */ - { 0x0000, 0x0000, 0x0000 }, /* R4942 */ - { 0x0000, 0x0000, 0x0000 }, /* R4943 */ - { 0x0000, 0x0000, 0x0000 }, /* R4944 */ - { 0x0000, 0x0000, 0x0000 }, /* R4945 */ - { 0x0000, 0x0000, 0x0000 }, /* R4946 */ - { 0x0000, 0x0000, 0x0000 }, /* R4947 */ - { 0x0000, 0x0000, 0x0000 }, /* R4948 */ - { 0x0000, 0x0000, 0x0000 }, /* R4949 */ - { 0x0000, 0x0000, 0x0000 }, /* R4950 */ - { 0x0000, 0x0000, 0x0000 }, /* R4951 */ - { 0x0000, 0x0000, 0x0000 }, /* R4952 */ - { 0x0000, 0x0000, 0x0000 }, /* R4953 */ - { 0x0000, 0x0000, 0x0000 }, /* R4954 */ - { 0x0000, 0x0000, 0x0000 }, /* R4955 */ - { 0x0000, 0x0000, 0x0000 }, /* R4956 */ - { 0x0000, 0x0000, 0x0000 }, /* R4957 */ - { 0x0000, 0x0000, 0x0000 }, /* R4958 */ - { 0x0000, 0x0000, 0x0000 }, /* R4959 */ - { 0x0000, 0x0000, 0x0000 }, /* R4960 */ - { 0x0000, 0x0000, 0x0000 }, /* R4961 */ - { 0x0000, 0x0000, 0x0000 }, /* R4962 */ - { 0x0000, 0x0000, 0x0000 }, /* R4963 */ - { 0x0000, 0x0000, 0x0000 }, /* R4964 */ - { 0x0000, 0x0000, 0x0000 }, /* R4965 */ - { 0x0000, 0x0000, 0x0000 }, /* R4966 */ - { 0x0000, 0x0000, 0x0000 }, /* R4967 */ - { 0x0000, 0x0000, 0x0000 }, /* R4968 */ - { 0x0000, 0x0000, 0x0000 }, /* R4969 */ - { 0x0000, 0x0000, 0x0000 }, /* R4970 */ - { 0x0000, 0x0000, 0x0000 }, /* R4971 */ - { 0x0000, 0x0000, 0x0000 }, /* R4972 */ - { 0x0000, 0x0000, 0x0000 }, /* R4973 */ - { 0x0000, 0x0000, 0x0000 }, /* R4974 */ - { 0x0000, 0x0000, 0x0000 }, /* R4975 */ - { 0x0000, 0x0000, 0x0000 }, /* R4976 */ - { 0x0000, 0x0000, 0x0000 }, /* R4977 */ - { 0x0000, 0x0000, 0x0000 }, /* R4978 */ - { 0x0000, 0x0000, 0x0000 }, /* R4979 */ - { 0x0000, 0x0000, 0x0000 }, /* R4980 */ - { 0x0000, 0x0000, 0x0000 }, /* R4981 */ - { 0x0000, 0x0000, 0x0000 }, /* R4982 */ - { 0x0000, 0x0000, 0x0000 }, /* R4983 */ - { 0x0000, 0x0000, 0x0000 }, /* R4984 */ - { 0x0000, 0x0000, 0x0000 }, /* R4985 */ - { 0x0000, 0x0000, 0x0000 }, /* R4986 */ - { 0x0000, 0x0000, 0x0000 }, /* R4987 */ - { 0x0000, 0x0000, 0x0000 }, /* R4988 */ - { 0x0000, 0x0000, 0x0000 }, /* R4989 */ - { 0x0000, 0x0000, 0x0000 }, /* R4990 */ - { 0x0000, 0x0000, 0x0000 }, /* R4991 */ - { 0x0000, 0x0000, 0x0000 }, /* R4992 */ - { 0x0000, 0x0000, 0x0000 }, /* R4993 */ - { 0x0000, 0x0000, 0x0000 }, /* R4994 */ - { 0x0000, 0x0000, 0x0000 }, /* R4995 */ - { 0x0000, 0x0000, 0x0000 }, /* R4996 */ - { 0x0000, 0x0000, 0x0000 }, /* R4997 */ - { 0x0000, 0x0000, 0x0000 }, /* R4998 */ - { 0x0000, 0x0000, 0x0000 }, /* R4999 */ - { 0x0000, 0x0000, 0x0000 }, /* R5000 */ - { 0x0000, 0x0000, 0x0000 }, /* R5001 */ - { 0x0000, 0x0000, 0x0000 }, /* R5002 */ - { 0x0000, 0x0000, 0x0000 }, /* R5003 */ - { 0x0000, 0x0000, 0x0000 }, /* R5004 */ - { 0x0000, 0x0000, 0x0000 }, /* R5005 */ - { 0x0000, 0x0000, 0x0000 }, /* R5006 */ - { 0x0000, 0x0000, 0x0000 }, /* R5007 */ - { 0x0000, 0x0000, 0x0000 }, /* R5008 */ - { 0x0000, 0x0000, 0x0000 }, /* R5009 */ - { 0x0000, 0x0000, 0x0000 }, /* R5010 */ - { 0x0000, 0x0000, 0x0000 }, /* R5011 */ - { 0x0000, 0x0000, 0x0000 }, /* R5012 */ - { 0x0000, 0x0000, 0x0000 }, /* R5013 */ - { 0x0000, 0x0000, 0x0000 }, /* R5014 */ - { 0x0000, 0x0000, 0x0000 }, /* R5015 */ - { 0x0000, 0x0000, 0x0000 }, /* R5016 */ - { 0x0000, 0x0000, 0x0000 }, /* R5017 */ - { 0x0000, 0x0000, 0x0000 }, /* R5018 */ - { 0x0000, 0x0000, 0x0000 }, /* R5019 */ - { 0x0000, 0x0000, 0x0000 }, /* R5020 */ - { 0x0000, 0x0000, 0x0000 }, /* R5021 */ - { 0x0000, 0x0000, 0x0000 }, /* R5022 */ - { 0x0000, 0x0000, 0x0000 }, /* R5023 */ - { 0x0000, 0x0000, 0x0000 }, /* R5024 */ - { 0x0000, 0x0000, 0x0000 }, /* R5025 */ - { 0x0000, 0x0000, 0x0000 }, /* R5026 */ - { 0x0000, 0x0000, 0x0000 }, /* R5027 */ - { 0x0000, 0x0000, 0x0000 }, /* R5028 */ - { 0x0000, 0x0000, 0x0000 }, /* R5029 */ - { 0x0000, 0x0000, 0x0000 }, /* R5030 */ - { 0x0000, 0x0000, 0x0000 }, /* R5031 */ - { 0x0000, 0x0000, 0x0000 }, /* R5032 */ - { 0x0000, 0x0000, 0x0000 }, /* R5033 */ - { 0x0000, 0x0000, 0x0000 }, /* R5034 */ - { 0x0000, 0x0000, 0x0000 }, /* R5035 */ - { 0x0000, 0x0000, 0x0000 }, /* R5036 */ - { 0x0000, 0x0000, 0x0000 }, /* R5037 */ - { 0x0000, 0x0000, 0x0000 }, /* R5038 */ - { 0x0000, 0x0000, 0x0000 }, /* R5039 */ - { 0x0000, 0x0000, 0x0000 }, /* R5040 */ - { 0x0000, 0x0000, 0x0000 }, /* R5041 */ - { 0x0000, 0x0000, 0x0000 }, /* R5042 */ - { 0x0000, 0x0000, 0x0000 }, /* R5043 */ - { 0x0000, 0x0000, 0x0000 }, /* R5044 */ - { 0x0000, 0x0000, 0x0000 }, /* R5045 */ - { 0x0000, 0x0000, 0x0000 }, /* R5046 */ - { 0x0000, 0x0000, 0x0000 }, /* R5047 */ - { 0x0000, 0x0000, 0x0000 }, /* R5048 */ - { 0x0000, 0x0000, 0x0000 }, /* R5049 */ - { 0x0000, 0x0000, 0x0000 }, /* R5050 */ - { 0x0000, 0x0000, 0x0000 }, /* R5051 */ - { 0x0000, 0x0000, 0x0000 }, /* R5052 */ - { 0x0000, 0x0000, 0x0000 }, /* R5053 */ - { 0x0000, 0x0000, 0x0000 }, /* R5054 */ - { 0x0000, 0x0000, 0x0000 }, /* R5055 */ - { 0x0000, 0x0000, 0x0000 }, /* R5056 */ - { 0x0000, 0x0000, 0x0000 }, /* R5057 */ - { 0x0000, 0x0000, 0x0000 }, /* R5058 */ - { 0x0000, 0x0000, 0x0000 }, /* R5059 */ - { 0x0000, 0x0000, 0x0000 }, /* R5060 */ - { 0x0000, 0x0000, 0x0000 }, /* R5061 */ - { 0x0000, 0x0000, 0x0000 }, /* R5062 */ - { 0x0000, 0x0000, 0x0000 }, /* R5063 */ - { 0x0000, 0x0000, 0x0000 }, /* R5064 */ - { 0x0000, 0x0000, 0x0000 }, /* R5065 */ - { 0x0000, 0x0000, 0x0000 }, /* R5066 */ - { 0x0000, 0x0000, 0x0000 }, /* R5067 */ - { 0x0000, 0x0000, 0x0000 }, /* R5068 */ - { 0x0000, 0x0000, 0x0000 }, /* R5069 */ - { 0x0000, 0x0000, 0x0000 }, /* R5070 */ - { 0x0000, 0x0000, 0x0000 }, /* R5071 */ - { 0x0000, 0x0000, 0x0000 }, /* R5072 */ - { 0x0000, 0x0000, 0x0000 }, /* R5073 */ - { 0x0000, 0x0000, 0x0000 }, /* R5074 */ - { 0x0000, 0x0000, 0x0000 }, /* R5075 */ - { 0x0000, 0x0000, 0x0000 }, /* R5076 */ - { 0x0000, 0x0000, 0x0000 }, /* R5077 */ - { 0x0000, 0x0000, 0x0000 }, /* R5078 */ - { 0x0000, 0x0000, 0x0000 }, /* R5079 */ - { 0x0000, 0x0000, 0x0000 }, /* R5080 */ - { 0x0000, 0x0000, 0x0000 }, /* R5081 */ - { 0x0000, 0x0000, 0x0000 }, /* R5082 */ - { 0x0000, 0x0000, 0x0000 }, /* R5083 */ - { 0x0000, 0x0000, 0x0000 }, /* R5084 */ - { 0x0000, 0x0000, 0x0000 }, /* R5085 */ - { 0x0000, 0x0000, 0x0000 }, /* R5086 */ - { 0x0000, 0x0000, 0x0000 }, /* R5087 */ - { 0x0000, 0x0000, 0x0000 }, /* R5088 */ - { 0x0000, 0x0000, 0x0000 }, /* R5089 */ - { 0x0000, 0x0000, 0x0000 }, /* R5090 */ - { 0x0000, 0x0000, 0x0000 }, /* R5091 */ - { 0x0000, 0x0000, 0x0000 }, /* R5092 */ - { 0x0000, 0x0000, 0x0000 }, /* R5093 */ - { 0x0000, 0x0000, 0x0000 }, /* R5094 */ - { 0x0000, 0x0000, 0x0000 }, /* R5095 */ - { 0x0000, 0x0000, 0x0000 }, /* R5096 */ - { 0x0000, 0x0000, 0x0000 }, /* R5097 */ - { 0x0000, 0x0000, 0x0000 }, /* R5098 */ - { 0x0000, 0x0000, 0x0000 }, /* R5099 */ - { 0x0000, 0x0000, 0x0000 }, /* R5100 */ - { 0x0000, 0x0000, 0x0000 }, /* R5101 */ - { 0x0000, 0x0000, 0x0000 }, /* R5102 */ - { 0x0000, 0x0000, 0x0000 }, /* R5103 */ - { 0x0000, 0x0000, 0x0000 }, /* R5104 */ - { 0x0000, 0x0000, 0x0000 }, /* R5105 */ - { 0x0000, 0x0000, 0x0000 }, /* R5106 */ - { 0x0000, 0x0000, 0x0000 }, /* R5107 */ - { 0x0000, 0x0000, 0x0000 }, /* R5108 */ - { 0x0000, 0x0000, 0x0000 }, /* R5109 */ - { 0x0000, 0x0000, 0x0000 }, /* R5110 */ - { 0x0000, 0x0000, 0x0000 }, /* R5111 */ - { 0x0000, 0x0000, 0x0000 }, /* R5112 */ - { 0x0000, 0x0000, 0x0000 }, /* R5113 */ - { 0x0000, 0x0000, 0x0000 }, /* R5114 */ - { 0x0000, 0x0000, 0x0000 }, /* R5115 */ - { 0x0000, 0x0000, 0x0000 }, /* R5116 */ - { 0x0000, 0x0000, 0x0000 }, /* R5117 */ - { 0x0000, 0x0000, 0x0000 }, /* R5118 */ - { 0x0000, 0x0000, 0x0000 }, /* R5119 */ - { 0x0000, 0x0000, 0x0000 }, /* R5120 */ - { 0x0000, 0x0000, 0x0000 }, /* R5121 */ - { 0x0000, 0x0000, 0x0000 }, /* R5122 */ - { 0x0000, 0x0000, 0x0000 }, /* R5123 */ - { 0x0000, 0x0000, 0x0000 }, /* R5124 */ - { 0x0000, 0x0000, 0x0000 }, /* R5125 */ - { 0x0000, 0x0000, 0x0000 }, /* R5126 */ - { 0x0000, 0x0000, 0x0000 }, /* R5127 */ - { 0x0000, 0x0000, 0x0000 }, /* R5128 */ - { 0x0000, 0x0000, 0x0000 }, /* R5129 */ - { 0x0000, 0x0000, 0x0000 }, /* R5130 */ - { 0x0000, 0x0000, 0x0000 }, /* R5131 */ - { 0x0000, 0x0000, 0x0000 }, /* R5132 */ - { 0x0000, 0x0000, 0x0000 }, /* R5133 */ - { 0x0000, 0x0000, 0x0000 }, /* R5134 */ - { 0x0000, 0x0000, 0x0000 }, /* R5135 */ - { 0x0000, 0x0000, 0x0000 }, /* R5136 */ - { 0x0000, 0x0000, 0x0000 }, /* R5137 */ - { 0x0000, 0x0000, 0x0000 }, /* R5138 */ - { 0x0000, 0x0000, 0x0000 }, /* R5139 */ - { 0x0000, 0x0000, 0x0000 }, /* R5140 */ - { 0x0000, 0x0000, 0x0000 }, /* R5141 */ - { 0x0000, 0x0000, 0x0000 }, /* R5142 */ - { 0x0000, 0x0000, 0x0000 }, /* R5143 */ - { 0x0000, 0x0000, 0x0000 }, /* R5144 */ - { 0x0000, 0x0000, 0x0000 }, /* R5145 */ - { 0x0000, 0x0000, 0x0000 }, /* R5146 */ - { 0x0000, 0x0000, 0x0000 }, /* R5147 */ - { 0x0000, 0x0000, 0x0000 }, /* R5148 */ - { 0x0000, 0x0000, 0x0000 }, /* R5149 */ - { 0x0000, 0x0000, 0x0000 }, /* R5150 */ - { 0x0000, 0x0000, 0x0000 }, /* R5151 */ - { 0x0000, 0x0000, 0x0000 }, /* R5152 */ - { 0x0000, 0x0000, 0x0000 }, /* R5153 */ - { 0x0000, 0x0000, 0x0000 }, /* R5154 */ - { 0x0000, 0x0000, 0x0000 }, /* R5155 */ - { 0x0000, 0x0000, 0x0000 }, /* R5156 */ - { 0x0000, 0x0000, 0x0000 }, /* R5157 */ - { 0x0000, 0x0000, 0x0000 }, /* R5158 */ - { 0x0000, 0x0000, 0x0000 }, /* R5159 */ - { 0x0000, 0x0000, 0x0000 }, /* R5160 */ - { 0x0000, 0x0000, 0x0000 }, /* R5161 */ - { 0x0000, 0x0000, 0x0000 }, /* R5162 */ - { 0x0000, 0x0000, 0x0000 }, /* R5163 */ - { 0x0000, 0x0000, 0x0000 }, /* R5164 */ - { 0x0000, 0x0000, 0x0000 }, /* R5165 */ - { 0x0000, 0x0000, 0x0000 }, /* R5166 */ - { 0x0000, 0x0000, 0x0000 }, /* R5167 */ - { 0x0000, 0x0000, 0x0000 }, /* R5168 */ - { 0x0000, 0x0000, 0x0000 }, /* R5169 */ - { 0x0000, 0x0000, 0x0000 }, /* R5170 */ - { 0x0000, 0x0000, 0x0000 }, /* R5171 */ - { 0x0000, 0x0000, 0x0000 }, /* R5172 */ - { 0x0000, 0x0000, 0x0000 }, /* R5173 */ - { 0x0000, 0x0000, 0x0000 }, /* R5174 */ - { 0x0000, 0x0000, 0x0000 }, /* R5175 */ - { 0x0000, 0x0000, 0x0000 }, /* R5176 */ - { 0x0000, 0x0000, 0x0000 }, /* R5177 */ - { 0x0000, 0x0000, 0x0000 }, /* R5178 */ - { 0x0000, 0x0000, 0x0000 }, /* R5179 */ - { 0x0000, 0x0000, 0x0000 }, /* R5180 */ - { 0x0000, 0x0000, 0x0000 }, /* R5181 */ - { 0x0000, 0x0000, 0x0000 }, /* R5182 */ - { 0x0000, 0x0000, 0x0000 }, /* R5183 */ - { 0x0000, 0x0000, 0x0000 }, /* R5184 */ - { 0x0000, 0x0000, 0x0000 }, /* R5185 */ - { 0x0000, 0x0000, 0x0000 }, /* R5186 */ - { 0x0000, 0x0000, 0x0000 }, /* R5187 */ - { 0x0000, 0x0000, 0x0000 }, /* R5188 */ - { 0x0000, 0x0000, 0x0000 }, /* R5189 */ - { 0x0000, 0x0000, 0x0000 }, /* R5190 */ - { 0x0000, 0x0000, 0x0000 }, /* R5191 */ - { 0x0000, 0x0000, 0x0000 }, /* R5192 */ - { 0x0000, 0x0000, 0x0000 }, /* R5193 */ - { 0x0000, 0x0000, 0x0000 }, /* R5194 */ - { 0x0000, 0x0000, 0x0000 }, /* R5195 */ - { 0x0000, 0x0000, 0x0000 }, /* R5196 */ - { 0x0000, 0x0000, 0x0000 }, /* R5197 */ - { 0x0000, 0x0000, 0x0000 }, /* R5198 */ - { 0x0000, 0x0000, 0x0000 }, /* R5199 */ - { 0x0000, 0x0000, 0x0000 }, /* R5200 */ - { 0x0000, 0x0000, 0x0000 }, /* R5201 */ - { 0x0000, 0x0000, 0x0000 }, /* R5202 */ - { 0x0000, 0x0000, 0x0000 }, /* R5203 */ - { 0x0000, 0x0000, 0x0000 }, /* R5204 */ - { 0x0000, 0x0000, 0x0000 }, /* R5205 */ - { 0x0000, 0x0000, 0x0000 }, /* R5206 */ - { 0x0000, 0x0000, 0x0000 }, /* R5207 */ - { 0x0000, 0x0000, 0x0000 }, /* R5208 */ - { 0x0000, 0x0000, 0x0000 }, /* R5209 */ - { 0x0000, 0x0000, 0x0000 }, /* R5210 */ - { 0x0000, 0x0000, 0x0000 }, /* R5211 */ - { 0x0000, 0x0000, 0x0000 }, /* R5212 */ - { 0x0000, 0x0000, 0x0000 }, /* R5213 */ - { 0x0000, 0x0000, 0x0000 }, /* R5214 */ - { 0x0000, 0x0000, 0x0000 }, /* R5215 */ - { 0x0000, 0x0000, 0x0000 }, /* R5216 */ - { 0x0000, 0x0000, 0x0000 }, /* R5217 */ - { 0x0000, 0x0000, 0x0000 }, /* R5218 */ - { 0x0000, 0x0000, 0x0000 }, /* R5219 */ - { 0x0000, 0x0000, 0x0000 }, /* R5220 */ - { 0x0000, 0x0000, 0x0000 }, /* R5221 */ - { 0x0000, 0x0000, 0x0000 }, /* R5222 */ - { 0x0000, 0x0000, 0x0000 }, /* R5223 */ - { 0x0000, 0x0000, 0x0000 }, /* R5224 */ - { 0x0000, 0x0000, 0x0000 }, /* R5225 */ - { 0x0000, 0x0000, 0x0000 }, /* R5226 */ - { 0x0000, 0x0000, 0x0000 }, /* R5227 */ - { 0x0000, 0x0000, 0x0000 }, /* R5228 */ - { 0x0000, 0x0000, 0x0000 }, /* R5229 */ - { 0x0000, 0x0000, 0x0000 }, /* R5230 */ - { 0x0000, 0x0000, 0x0000 }, /* R5231 */ - { 0x0000, 0x0000, 0x0000 }, /* R5232 */ - { 0x0000, 0x0000, 0x0000 }, /* R5233 */ - { 0x0000, 0x0000, 0x0000 }, /* R5234 */ - { 0x0000, 0x0000, 0x0000 }, /* R5235 */ - { 0x0000, 0x0000, 0x0000 }, /* R5236 */ - { 0x0000, 0x0000, 0x0000 }, /* R5237 */ - { 0x0000, 0x0000, 0x0000 }, /* R5238 */ - { 0x0000, 0x0000, 0x0000 }, /* R5239 */ - { 0x0000, 0x0000, 0x0000 }, /* R5240 */ - { 0x0000, 0x0000, 0x0000 }, /* R5241 */ - { 0x0000, 0x0000, 0x0000 }, /* R5242 */ - { 0x0000, 0x0000, 0x0000 }, /* R5243 */ - { 0x0000, 0x0000, 0x0000 }, /* R5244 */ - { 0x0000, 0x0000, 0x0000 }, /* R5245 */ - { 0x0000, 0x0000, 0x0000 }, /* R5246 */ - { 0x0000, 0x0000, 0x0000 }, /* R5247 */ - { 0x0000, 0x0000, 0x0000 }, /* R5248 */ - { 0x0000, 0x0000, 0x0000 }, /* R5249 */ - { 0x0000, 0x0000, 0x0000 }, /* R5250 */ - { 0x0000, 0x0000, 0x0000 }, /* R5251 */ - { 0x0000, 0x0000, 0x0000 }, /* R5252 */ - { 0x0000, 0x0000, 0x0000 }, /* R5253 */ - { 0x0000, 0x0000, 0x0000 }, /* R5254 */ - { 0x0000, 0x0000, 0x0000 }, /* R5255 */ - { 0x0000, 0x0000, 0x0000 }, /* R5256 */ - { 0x0000, 0x0000, 0x0000 }, /* R5257 */ - { 0x0000, 0x0000, 0x0000 }, /* R5258 */ - { 0x0000, 0x0000, 0x0000 }, /* R5259 */ - { 0x0000, 0x0000, 0x0000 }, /* R5260 */ - { 0x0000, 0x0000, 0x0000 }, /* R5261 */ - { 0x0000, 0x0000, 0x0000 }, /* R5262 */ - { 0x0000, 0x0000, 0x0000 }, /* R5263 */ - { 0x0000, 0x0000, 0x0000 }, /* R5264 */ - { 0x0000, 0x0000, 0x0000 }, /* R5265 */ - { 0x0000, 0x0000, 0x0000 }, /* R5266 */ - { 0x0000, 0x0000, 0x0000 }, /* R5267 */ - { 0x0000, 0x0000, 0x0000 }, /* R5268 */ - { 0x0000, 0x0000, 0x0000 }, /* R5269 */ - { 0x0000, 0x0000, 0x0000 }, /* R5270 */ - { 0x0000, 0x0000, 0x0000 }, /* R5271 */ - { 0x0000, 0x0000, 0x0000 }, /* R5272 */ - { 0x0000, 0x0000, 0x0000 }, /* R5273 */ - { 0x0000, 0x0000, 0x0000 }, /* R5274 */ - { 0x0000, 0x0000, 0x0000 }, /* R5275 */ - { 0x0000, 0x0000, 0x0000 }, /* R5276 */ - { 0x0000, 0x0000, 0x0000 }, /* R5277 */ - { 0x0000, 0x0000, 0x0000 }, /* R5278 */ - { 0x0000, 0x0000, 0x0000 }, /* R5279 */ - { 0x0000, 0x0000, 0x0000 }, /* R5280 */ - { 0x0000, 0x0000, 0x0000 }, /* R5281 */ - { 0x0000, 0x0000, 0x0000 }, /* R5282 */ - { 0x0000, 0x0000, 0x0000 }, /* R5283 */ - { 0x0000, 0x0000, 0x0000 }, /* R5284 */ - { 0x0000, 0x0000, 0x0000 }, /* R5285 */ - { 0x0000, 0x0000, 0x0000 }, /* R5286 */ - { 0x0000, 0x0000, 0x0000 }, /* R5287 */ - { 0x0000, 0x0000, 0x0000 }, /* R5288 */ - { 0x0000, 0x0000, 0x0000 }, /* R5289 */ - { 0x0000, 0x0000, 0x0000 }, /* R5290 */ - { 0x0000, 0x0000, 0x0000 }, /* R5291 */ - { 0x0000, 0x0000, 0x0000 }, /* R5292 */ - { 0x0000, 0x0000, 0x0000 }, /* R5293 */ - { 0x0000, 0x0000, 0x0000 }, /* R5294 */ - { 0x0000, 0x0000, 0x0000 }, /* R5295 */ - { 0x0000, 0x0000, 0x0000 }, /* R5296 */ - { 0x0000, 0x0000, 0x0000 }, /* R5297 */ - { 0x0000, 0x0000, 0x0000 }, /* R5298 */ - { 0x0000, 0x0000, 0x0000 }, /* R5299 */ - { 0x0000, 0x0000, 0x0000 }, /* R5300 */ - { 0x0000, 0x0000, 0x0000 }, /* R5301 */ - { 0x0000, 0x0000, 0x0000 }, /* R5302 */ - { 0x0000, 0x0000, 0x0000 }, /* R5303 */ - { 0x0000, 0x0000, 0x0000 }, /* R5304 */ - { 0x0000, 0x0000, 0x0000 }, /* R5305 */ - { 0x0000, 0x0000, 0x0000 }, /* R5306 */ - { 0x0000, 0x0000, 0x0000 }, /* R5307 */ - { 0x0000, 0x0000, 0x0000 }, /* R5308 */ - { 0x0000, 0x0000, 0x0000 }, /* R5309 */ - { 0x0000, 0x0000, 0x0000 }, /* R5310 */ - { 0x0000, 0x0000, 0x0000 }, /* R5311 */ - { 0x0000, 0x0000, 0x0000 }, /* R5312 */ - { 0x0000, 0x0000, 0x0000 }, /* R5313 */ - { 0x0000, 0x0000, 0x0000 }, /* R5314 */ - { 0x0000, 0x0000, 0x0000 }, /* R5315 */ - { 0x0000, 0x0000, 0x0000 }, /* R5316 */ - { 0x0000, 0x0000, 0x0000 }, /* R5317 */ - { 0x0000, 0x0000, 0x0000 }, /* R5318 */ - { 0x0000, 0x0000, 0x0000 }, /* R5319 */ - { 0x0000, 0x0000, 0x0000 }, /* R5320 */ - { 0x0000, 0x0000, 0x0000 }, /* R5321 */ - { 0x0000, 0x0000, 0x0000 }, /* R5322 */ - { 0x0000, 0x0000, 0x0000 }, /* R5323 */ - { 0x0000, 0x0000, 0x0000 }, /* R5324 */ - { 0x0000, 0x0000, 0x0000 }, /* R5325 */ - { 0x0000, 0x0000, 0x0000 }, /* R5326 */ - { 0x0000, 0x0000, 0x0000 }, /* R5327 */ - { 0x0000, 0x0000, 0x0000 }, /* R5328 */ - { 0x0000, 0x0000, 0x0000 }, /* R5329 */ - { 0x0000, 0x0000, 0x0000 }, /* R5330 */ - { 0x0000, 0x0000, 0x0000 }, /* R5331 */ - { 0x0000, 0x0000, 0x0000 }, /* R5332 */ - { 0x0000, 0x0000, 0x0000 }, /* R5333 */ - { 0x0000, 0x0000, 0x0000 }, /* R5334 */ - { 0x0000, 0x0000, 0x0000 }, /* R5335 */ - { 0x0000, 0x0000, 0x0000 }, /* R5336 */ - { 0x0000, 0x0000, 0x0000 }, /* R5337 */ - { 0x0000, 0x0000, 0x0000 }, /* R5338 */ - { 0x0000, 0x0000, 0x0000 }, /* R5339 */ - { 0x0000, 0x0000, 0x0000 }, /* R5340 */ - { 0x0000, 0x0000, 0x0000 }, /* R5341 */ - { 0x0000, 0x0000, 0x0000 }, /* R5342 */ - { 0x0000, 0x0000, 0x0000 }, /* R5343 */ - { 0x0000, 0x0000, 0x0000 }, /* R5344 */ - { 0x0000, 0x0000, 0x0000 }, /* R5345 */ - { 0x0000, 0x0000, 0x0000 }, /* R5346 */ - { 0x0000, 0x0000, 0x0000 }, /* R5347 */ - { 0x0000, 0x0000, 0x0000 }, /* R5348 */ - { 0x0000, 0x0000, 0x0000 }, /* R5349 */ - { 0x0000, 0x0000, 0x0000 }, /* R5350 */ - { 0x0000, 0x0000, 0x0000 }, /* R5351 */ - { 0x0000, 0x0000, 0x0000 }, /* R5352 */ - { 0x0000, 0x0000, 0x0000 }, /* R5353 */ - { 0x0000, 0x0000, 0x0000 }, /* R5354 */ - { 0x0000, 0x0000, 0x0000 }, /* R5355 */ - { 0x0000, 0x0000, 0x0000 }, /* R5356 */ - { 0x0000, 0x0000, 0x0000 }, /* R5357 */ - { 0x0000, 0x0000, 0x0000 }, /* R5358 */ - { 0x0000, 0x0000, 0x0000 }, /* R5359 */ - { 0x0000, 0x0000, 0x0000 }, /* R5360 */ - { 0x0000, 0x0000, 0x0000 }, /* R5361 */ - { 0x0000, 0x0000, 0x0000 }, /* R5362 */ - { 0x0000, 0x0000, 0x0000 }, /* R5363 */ - { 0x0000, 0x0000, 0x0000 }, /* R5364 */ - { 0x0000, 0x0000, 0x0000 }, /* R5365 */ - { 0x0000, 0x0000, 0x0000 }, /* R5366 */ - { 0x0000, 0x0000, 0x0000 }, /* R5367 */ - { 0x0000, 0x0000, 0x0000 }, /* R5368 */ - { 0x0000, 0x0000, 0x0000 }, /* R5369 */ - { 0x0000, 0x0000, 0x0000 }, /* R5370 */ - { 0x0000, 0x0000, 0x0000 }, /* R5371 */ - { 0x0000, 0x0000, 0x0000 }, /* R5372 */ - { 0x0000, 0x0000, 0x0000 }, /* R5373 */ - { 0x0000, 0x0000, 0x0000 }, /* R5374 */ - { 0x0000, 0x0000, 0x0000 }, /* R5375 */ - { 0x0000, 0x0000, 0x0000 }, /* R5376 */ - { 0x0000, 0x0000, 0x0000 }, /* R5377 */ - { 0x0000, 0x0000, 0x0000 }, /* R5378 */ - { 0x0000, 0x0000, 0x0000 }, /* R5379 */ - { 0x0000, 0x0000, 0x0000 }, /* R5380 */ - { 0x0000, 0x0000, 0x0000 }, /* R5381 */ - { 0x0000, 0x0000, 0x0000 }, /* R5382 */ - { 0x0000, 0x0000, 0x0000 }, /* R5383 */ - { 0x0000, 0x0000, 0x0000 }, /* R5384 */ - { 0x0000, 0x0000, 0x0000 }, /* R5385 */ - { 0x0000, 0x0000, 0x0000 }, /* R5386 */ - { 0x0000, 0x0000, 0x0000 }, /* R5387 */ - { 0x0000, 0x0000, 0x0000 }, /* R5388 */ - { 0x0000, 0x0000, 0x0000 }, /* R5389 */ - { 0x0000, 0x0000, 0x0000 }, /* R5390 */ - { 0x0000, 0x0000, 0x0000 }, /* R5391 */ - { 0x0000, 0x0000, 0x0000 }, /* R5392 */ - { 0x0000, 0x0000, 0x0000 }, /* R5393 */ - { 0x0000, 0x0000, 0x0000 }, /* R5394 */ - { 0x0000, 0x0000, 0x0000 }, /* R5395 */ - { 0x0000, 0x0000, 0x0000 }, /* R5396 */ - { 0x0000, 0x0000, 0x0000 }, /* R5397 */ - { 0x0000, 0x0000, 0x0000 }, /* R5398 */ - { 0x0000, 0x0000, 0x0000 }, /* R5399 */ - { 0x0000, 0x0000, 0x0000 }, /* R5400 */ - { 0x0000, 0x0000, 0x0000 }, /* R5401 */ - { 0x0000, 0x0000, 0x0000 }, /* R5402 */ - { 0x0000, 0x0000, 0x0000 }, /* R5403 */ - { 0x0000, 0x0000, 0x0000 }, /* R5404 */ - { 0x0000, 0x0000, 0x0000 }, /* R5405 */ - { 0x0000, 0x0000, 0x0000 }, /* R5406 */ - { 0x0000, 0x0000, 0x0000 }, /* R5407 */ - { 0x0000, 0x0000, 0x0000 }, /* R5408 */ - { 0x0000, 0x0000, 0x0000 }, /* R5409 */ - { 0x0000, 0x0000, 0x0000 }, /* R5410 */ - { 0x0000, 0x0000, 0x0000 }, /* R5411 */ - { 0x0000, 0x0000, 0x0000 }, /* R5412 */ - { 0x0000, 0x0000, 0x0000 }, /* R5413 */ - { 0x0000, 0x0000, 0x0000 }, /* R5414 */ - { 0x0000, 0x0000, 0x0000 }, /* R5415 */ - { 0x0000, 0x0000, 0x0000 }, /* R5416 */ - { 0x0000, 0x0000, 0x0000 }, /* R5417 */ - { 0x0000, 0x0000, 0x0000 }, /* R5418 */ - { 0x0000, 0x0000, 0x0000 }, /* R5419 */ - { 0x0000, 0x0000, 0x0000 }, /* R5420 */ - { 0x0000, 0x0000, 0x0000 }, /* R5421 */ - { 0x0000, 0x0000, 0x0000 }, /* R5422 */ - { 0x0000, 0x0000, 0x0000 }, /* R5423 */ - { 0x0000, 0x0000, 0x0000 }, /* R5424 */ - { 0x0000, 0x0000, 0x0000 }, /* R5425 */ - { 0x0000, 0x0000, 0x0000 }, /* R5426 */ - { 0x0000, 0x0000, 0x0000 }, /* R5427 */ - { 0x0000, 0x0000, 0x0000 }, /* R5428 */ - { 0x0000, 0x0000, 0x0000 }, /* R5429 */ - { 0x0000, 0x0000, 0x0000 }, /* R5430 */ - { 0x0000, 0x0000, 0x0000 }, /* R5431 */ - { 0x0000, 0x0000, 0x0000 }, /* R5432 */ - { 0x0000, 0x0000, 0x0000 }, /* R5433 */ - { 0x0000, 0x0000, 0x0000 }, /* R5434 */ - { 0x0000, 0x0000, 0x0000 }, /* R5435 */ - { 0x0000, 0x0000, 0x0000 }, /* R5436 */ - { 0x0000, 0x0000, 0x0000 }, /* R5437 */ - { 0x0000, 0x0000, 0x0000 }, /* R5438 */ - { 0x0000, 0x0000, 0x0000 }, /* R5439 */ - { 0x0000, 0x0000, 0x0000 }, /* R5440 */ - { 0x0000, 0x0000, 0x0000 }, /* R5441 */ - { 0x0000, 0x0000, 0x0000 }, /* R5442 */ - { 0x0000, 0x0000, 0x0000 }, /* R5443 */ - { 0x0000, 0x0000, 0x0000 }, /* R5444 */ - { 0x0000, 0x0000, 0x0000 }, /* R5445 */ - { 0x0000, 0x0000, 0x0000 }, /* R5446 */ - { 0x0000, 0x0000, 0x0000 }, /* R5447 */ - { 0x0000, 0x0000, 0x0000 }, /* R5448 */ - { 0x0000, 0x0000, 0x0000 }, /* R5449 */ - { 0x0000, 0x0000, 0x0000 }, /* R5450 */ - { 0x0000, 0x0000, 0x0000 }, /* R5451 */ - { 0x0000, 0x0000, 0x0000 }, /* R5452 */ - { 0x0000, 0x0000, 0x0000 }, /* R5453 */ - { 0x0000, 0x0000, 0x0000 }, /* R5454 */ - { 0x0000, 0x0000, 0x0000 }, /* R5455 */ - { 0x0000, 0x0000, 0x0000 }, /* R5456 */ - { 0x0000, 0x0000, 0x0000 }, /* R5457 */ - { 0x0000, 0x0000, 0x0000 }, /* R5458 */ - { 0x0000, 0x0000, 0x0000 }, /* R5459 */ - { 0x0000, 0x0000, 0x0000 }, /* R5460 */ - { 0x0000, 0x0000, 0x0000 }, /* R5461 */ - { 0x0000, 0x0000, 0x0000 }, /* R5462 */ - { 0x0000, 0x0000, 0x0000 }, /* R5463 */ - { 0x0000, 0x0000, 0x0000 }, /* R5464 */ - { 0x0000, 0x0000, 0x0000 }, /* R5465 */ - { 0x0000, 0x0000, 0x0000 }, /* R5466 */ - { 0x0000, 0x0000, 0x0000 }, /* R5467 */ - { 0x0000, 0x0000, 0x0000 }, /* R5468 */ - { 0x0000, 0x0000, 0x0000 }, /* R5469 */ - { 0x0000, 0x0000, 0x0000 }, /* R5470 */ - { 0x0000, 0x0000, 0x0000 }, /* R5471 */ - { 0x0000, 0x0000, 0x0000 }, /* R5472 */ - { 0x0000, 0x0000, 0x0000 }, /* R5473 */ - { 0x0000, 0x0000, 0x0000 }, /* R5474 */ - { 0x0000, 0x0000, 0x0000 }, /* R5475 */ - { 0x0000, 0x0000, 0x0000 }, /* R5476 */ - { 0x0000, 0x0000, 0x0000 }, /* R5477 */ - { 0x0000, 0x0000, 0x0000 }, /* R5478 */ - { 0x0000, 0x0000, 0x0000 }, /* R5479 */ - { 0x0000, 0x0000, 0x0000 }, /* R5480 */ - { 0x0000, 0x0000, 0x0000 }, /* R5481 */ - { 0x0000, 0x0000, 0x0000 }, /* R5482 */ - { 0x0000, 0x0000, 0x0000 }, /* R5483 */ - { 0x0000, 0x0000, 0x0000 }, /* R5484 */ - { 0x0000, 0x0000, 0x0000 }, /* R5485 */ - { 0x0000, 0x0000, 0x0000 }, /* R5486 */ - { 0x0000, 0x0000, 0x0000 }, /* R5487 */ - { 0x0000, 0x0000, 0x0000 }, /* R5488 */ - { 0x0000, 0x0000, 0x0000 }, /* R5489 */ - { 0x0000, 0x0000, 0x0000 }, /* R5490 */ - { 0x0000, 0x0000, 0x0000 }, /* R5491 */ - { 0x0000, 0x0000, 0x0000 }, /* R5492 */ - { 0x0000, 0x0000, 0x0000 }, /* R5493 */ - { 0x0000, 0x0000, 0x0000 }, /* R5494 */ - { 0x0000, 0x0000, 0x0000 }, /* R5495 */ - { 0x0000, 0x0000, 0x0000 }, /* R5496 */ - { 0x0000, 0x0000, 0x0000 }, /* R5497 */ - { 0x0000, 0x0000, 0x0000 }, /* R5498 */ - { 0x0000, 0x0000, 0x0000 }, /* R5499 */ - { 0x0000, 0x0000, 0x0000 }, /* R5500 */ - { 0x0000, 0x0000, 0x0000 }, /* R5501 */ - { 0x0000, 0x0000, 0x0000 }, /* R5502 */ - { 0x0000, 0x0000, 0x0000 }, /* R5503 */ - { 0x0000, 0x0000, 0x0000 }, /* R5504 */ - { 0x0000, 0x0000, 0x0000 }, /* R5505 */ - { 0x0000, 0x0000, 0x0000 }, /* R5506 */ - { 0x0000, 0x0000, 0x0000 }, /* R5507 */ - { 0x0000, 0x0000, 0x0000 }, /* R5508 */ - { 0x0000, 0x0000, 0x0000 }, /* R5509 */ - { 0x0000, 0x0000, 0x0000 }, /* R5510 */ - { 0x0000, 0x0000, 0x0000 }, /* R5511 */ - { 0x0000, 0x0000, 0x0000 }, /* R5512 */ - { 0x0000, 0x0000, 0x0000 }, /* R5513 */ - { 0x0000, 0x0000, 0x0000 }, /* R5514 */ - { 0x0000, 0x0000, 0x0000 }, /* R5515 */ - { 0x0000, 0x0000, 0x0000 }, /* R5516 */ - { 0x0000, 0x0000, 0x0000 }, /* R5517 */ - { 0x0000, 0x0000, 0x0000 }, /* R5518 */ - { 0x0000, 0x0000, 0x0000 }, /* R5519 */ - { 0x0000, 0x0000, 0x0000 }, /* R5520 */ - { 0x0000, 0x0000, 0x0000 }, /* R5521 */ - { 0x0000, 0x0000, 0x0000 }, /* R5522 */ - { 0x0000, 0x0000, 0x0000 }, /* R5523 */ - { 0x0000, 0x0000, 0x0000 }, /* R5524 */ - { 0x0000, 0x0000, 0x0000 }, /* R5525 */ - { 0x0000, 0x0000, 0x0000 }, /* R5526 */ - { 0x0000, 0x0000, 0x0000 }, /* R5527 */ - { 0x0000, 0x0000, 0x0000 }, /* R5528 */ - { 0x0000, 0x0000, 0x0000 }, /* R5529 */ - { 0x0000, 0x0000, 0x0000 }, /* R5530 */ - { 0x0000, 0x0000, 0x0000 }, /* R5531 */ - { 0x0000, 0x0000, 0x0000 }, /* R5532 */ - { 0x0000, 0x0000, 0x0000 }, /* R5533 */ - { 0x0000, 0x0000, 0x0000 }, /* R5534 */ - { 0x0000, 0x0000, 0x0000 }, /* R5535 */ - { 0x0000, 0x0000, 0x0000 }, /* R5536 */ - { 0x0000, 0x0000, 0x0000 }, /* R5537 */ - { 0x0000, 0x0000, 0x0000 }, /* R5538 */ - { 0x0000, 0x0000, 0x0000 }, /* R5539 */ - { 0x0000, 0x0000, 0x0000 }, /* R5540 */ - { 0x0000, 0x0000, 0x0000 }, /* R5541 */ - { 0x0000, 0x0000, 0x0000 }, /* R5542 */ - { 0x0000, 0x0000, 0x0000 }, /* R5543 */ - { 0x0000, 0x0000, 0x0000 }, /* R5544 */ - { 0x0000, 0x0000, 0x0000 }, /* R5545 */ - { 0x0000, 0x0000, 0x0000 }, /* R5546 */ - { 0x0000, 0x0000, 0x0000 }, /* R5547 */ - { 0x0000, 0x0000, 0x0000 }, /* R5548 */ - { 0x0000, 0x0000, 0x0000 }, /* R5549 */ - { 0x0000, 0x0000, 0x0000 }, /* R5550 */ - { 0x0000, 0x0000, 0x0000 }, /* R5551 */ - { 0x0000, 0x0000, 0x0000 }, /* R5552 */ - { 0x0000, 0x0000, 0x0000 }, /* R5553 */ - { 0x0000, 0x0000, 0x0000 }, /* R5554 */ - { 0x0000, 0x0000, 0x0000 }, /* R5555 */ - { 0x0000, 0x0000, 0x0000 }, /* R5556 */ - { 0x0000, 0x0000, 0x0000 }, /* R5557 */ - { 0x0000, 0x0000, 0x0000 }, /* R5558 */ - { 0x0000, 0x0000, 0x0000 }, /* R5559 */ - { 0x0000, 0x0000, 0x0000 }, /* R5560 */ - { 0x0000, 0x0000, 0x0000 }, /* R5561 */ - { 0x0000, 0x0000, 0x0000 }, /* R5562 */ - { 0x0000, 0x0000, 0x0000 }, /* R5563 */ - { 0x0000, 0x0000, 0x0000 }, /* R5564 */ - { 0x0000, 0x0000, 0x0000 }, /* R5565 */ - { 0x0000, 0x0000, 0x0000 }, /* R5566 */ - { 0x0000, 0x0000, 0x0000 }, /* R5567 */ - { 0x0000, 0x0000, 0x0000 }, /* R5568 */ - { 0x0000, 0x0000, 0x0000 }, /* R5569 */ - { 0x0000, 0x0000, 0x0000 }, /* R5570 */ - { 0x0000, 0x0000, 0x0000 }, /* R5571 */ - { 0x0000, 0x0000, 0x0000 }, /* R5572 */ - { 0x0000, 0x0000, 0x0000 }, /* R5573 */ - { 0x0000, 0x0000, 0x0000 }, /* R5574 */ - { 0x0000, 0x0000, 0x0000 }, /* R5575 */ - { 0x0000, 0x0000, 0x0000 }, /* R5576 */ - { 0x0000, 0x0000, 0x0000 }, /* R5577 */ - { 0x0000, 0x0000, 0x0000 }, /* R5578 */ - { 0x0000, 0x0000, 0x0000 }, /* R5579 */ - { 0x0000, 0x0000, 0x0000 }, /* R5580 */ - { 0x0000, 0x0000, 0x0000 }, /* R5581 */ - { 0x0000, 0x0000, 0x0000 }, /* R5582 */ - { 0x0000, 0x0000, 0x0000 }, /* R5583 */ - { 0x0000, 0x0000, 0x0000 }, /* R5584 */ - { 0x0000, 0x0000, 0x0000 }, /* R5585 */ - { 0x0000, 0x0000, 0x0000 }, /* R5586 */ - { 0x0000, 0x0000, 0x0000 }, /* R5587 */ - { 0x0000, 0x0000, 0x0000 }, /* R5588 */ - { 0x0000, 0x0000, 0x0000 }, /* R5589 */ - { 0x0000, 0x0000, 0x0000 }, /* R5590 */ - { 0x0000, 0x0000, 0x0000 }, /* R5591 */ - { 0x0000, 0x0000, 0x0000 }, /* R5592 */ - { 0x0000, 0x0000, 0x0000 }, /* R5593 */ - { 0x0000, 0x0000, 0x0000 }, /* R5594 */ - { 0x0000, 0x0000, 0x0000 }, /* R5595 */ - { 0x0000, 0x0000, 0x0000 }, /* R5596 */ - { 0x0000, 0x0000, 0x0000 }, /* R5597 */ - { 0x0000, 0x0000, 0x0000 }, /* R5598 */ - { 0x0000, 0x0000, 0x0000 }, /* R5599 */ - { 0x0000, 0x0000, 0x0000 }, /* R5600 */ - { 0x0000, 0x0000, 0x0000 }, /* R5601 */ - { 0x0000, 0x0000, 0x0000 }, /* R5602 */ - { 0x0000, 0x0000, 0x0000 }, /* R5603 */ - { 0x0000, 0x0000, 0x0000 }, /* R5604 */ - { 0x0000, 0x0000, 0x0000 }, /* R5605 */ - { 0x0000, 0x0000, 0x0000 }, /* R5606 */ - { 0x0000, 0x0000, 0x0000 }, /* R5607 */ - { 0x0000, 0x0000, 0x0000 }, /* R5608 */ - { 0x0000, 0x0000, 0x0000 }, /* R5609 */ - { 0x0000, 0x0000, 0x0000 }, /* R5610 */ - { 0x0000, 0x0000, 0x0000 }, /* R5611 */ - { 0x0000, 0x0000, 0x0000 }, /* R5612 */ - { 0x0000, 0x0000, 0x0000 }, /* R5613 */ - { 0x0000, 0x0000, 0x0000 }, /* R5614 */ - { 0x0000, 0x0000, 0x0000 }, /* R5615 */ - { 0x0000, 0x0000, 0x0000 }, /* R5616 */ - { 0x0000, 0x0000, 0x0000 }, /* R5617 */ - { 0x0000, 0x0000, 0x0000 }, /* R5618 */ - { 0x0000, 0x0000, 0x0000 }, /* R5619 */ - { 0x0000, 0x0000, 0x0000 }, /* R5620 */ - { 0x0000, 0x0000, 0x0000 }, /* R5621 */ - { 0x0000, 0x0000, 0x0000 }, /* R5622 */ - { 0x0000, 0x0000, 0x0000 }, /* R5623 */ - { 0x0000, 0x0000, 0x0000 }, /* R5624 */ - { 0x0000, 0x0000, 0x0000 }, /* R5625 */ - { 0x0000, 0x0000, 0x0000 }, /* R5626 */ - { 0x0000, 0x0000, 0x0000 }, /* R5627 */ - { 0x0000, 0x0000, 0x0000 }, /* R5628 */ - { 0x0000, 0x0000, 0x0000 }, /* R5629 */ - { 0x0000, 0x0000, 0x0000 }, /* R5630 */ - { 0x0000, 0x0000, 0x0000 }, /* R5631 */ - { 0x0000, 0x0000, 0x0000 }, /* R5632 */ - { 0x0000, 0x0000, 0x0000 }, /* R5633 */ - { 0x0000, 0x0000, 0x0000 }, /* R5634 */ - { 0x0000, 0x0000, 0x0000 }, /* R5635 */ - { 0x0000, 0x0000, 0x0000 }, /* R5636 */ - { 0x0000, 0x0000, 0x0000 }, /* R5637 */ - { 0x0000, 0x0000, 0x0000 }, /* R5638 */ - { 0x0000, 0x0000, 0x0000 }, /* R5639 */ - { 0x0000, 0x0000, 0x0000 }, /* R5640 */ - { 0x0000, 0x0000, 0x0000 }, /* R5641 */ - { 0x0000, 0x0000, 0x0000 }, /* R5642 */ - { 0x0000, 0x0000, 0x0000 }, /* R5643 */ - { 0x0000, 0x0000, 0x0000 }, /* R5644 */ - { 0x0000, 0x0000, 0x0000 }, /* R5645 */ - { 0x0000, 0x0000, 0x0000 }, /* R5646 */ - { 0x0000, 0x0000, 0x0000 }, /* R5647 */ - { 0x0000, 0x0000, 0x0000 }, /* R5648 */ - { 0x0000, 0x0000, 0x0000 }, /* R5649 */ - { 0x0000, 0x0000, 0x0000 }, /* R5650 */ - { 0x0000, 0x0000, 0x0000 }, /* R5651 */ - { 0x0000, 0x0000, 0x0000 }, /* R5652 */ - { 0x0000, 0x0000, 0x0000 }, /* R5653 */ - { 0x0000, 0x0000, 0x0000 }, /* R5654 */ - { 0x0000, 0x0000, 0x0000 }, /* R5655 */ - { 0x0000, 0x0000, 0x0000 }, /* R5656 */ - { 0x0000, 0x0000, 0x0000 }, /* R5657 */ - { 0x0000, 0x0000, 0x0000 }, /* R5658 */ - { 0x0000, 0x0000, 0x0000 }, /* R5659 */ - { 0x0000, 0x0000, 0x0000 }, /* R5660 */ - { 0x0000, 0x0000, 0x0000 }, /* R5661 */ - { 0x0000, 0x0000, 0x0000 }, /* R5662 */ - { 0x0000, 0x0000, 0x0000 }, /* R5663 */ - { 0x0000, 0x0000, 0x0000 }, /* R5664 */ - { 0x0000, 0x0000, 0x0000 }, /* R5665 */ - { 0x0000, 0x0000, 0x0000 }, /* R5666 */ - { 0x0000, 0x0000, 0x0000 }, /* R5667 */ - { 0x0000, 0x0000, 0x0000 }, /* R5668 */ - { 0x0000, 0x0000, 0x0000 }, /* R5669 */ - { 0x0000, 0x0000, 0x0000 }, /* R5670 */ - { 0x0000, 0x0000, 0x0000 }, /* R5671 */ - { 0x0000, 0x0000, 0x0000 }, /* R5672 */ - { 0x0000, 0x0000, 0x0000 }, /* R5673 */ - { 0x0000, 0x0000, 0x0000 }, /* R5674 */ - { 0x0000, 0x0000, 0x0000 }, /* R5675 */ - { 0x0000, 0x0000, 0x0000 }, /* R5676 */ - { 0x0000, 0x0000, 0x0000 }, /* R5677 */ - { 0x0000, 0x0000, 0x0000 }, /* R5678 */ - { 0x0000, 0x0000, 0x0000 }, /* R5679 */ - { 0x0000, 0x0000, 0x0000 }, /* R5680 */ - { 0x0000, 0x0000, 0x0000 }, /* R5681 */ - { 0x0000, 0x0000, 0x0000 }, /* R5682 */ - { 0x0000, 0x0000, 0x0000 }, /* R5683 */ - { 0x0000, 0x0000, 0x0000 }, /* R5684 */ - { 0x0000, 0x0000, 0x0000 }, /* R5685 */ - { 0x0000, 0x0000, 0x0000 }, /* R5686 */ - { 0x0000, 0x0000, 0x0000 }, /* R5687 */ - { 0x0000, 0x0000, 0x0000 }, /* R5688 */ - { 0x0000, 0x0000, 0x0000 }, /* R5689 */ - { 0x0000, 0x0000, 0x0000 }, /* R5690 */ - { 0x0000, 0x0000, 0x0000 }, /* R5691 */ - { 0x0000, 0x0000, 0x0000 }, /* R5692 */ - { 0x0000, 0x0000, 0x0000 }, /* R5693 */ - { 0x0000, 0x0000, 0x0000 }, /* R5694 */ - { 0x0000, 0x0000, 0x0000 }, /* R5695 */ - { 0x0000, 0x0000, 0x0000 }, /* R5696 */ - { 0x0000, 0x0000, 0x0000 }, /* R5697 */ - { 0x0000, 0x0000, 0x0000 }, /* R5698 */ - { 0x0000, 0x0000, 0x0000 }, /* R5699 */ - { 0x0000, 0x0000, 0x0000 }, /* R5700 */ - { 0x0000, 0x0000, 0x0000 }, /* R5701 */ - { 0x0000, 0x0000, 0x0000 }, /* R5702 */ - { 0x0000, 0x0000, 0x0000 }, /* R5703 */ - { 0x0000, 0x0000, 0x0000 }, /* R5704 */ - { 0x0000, 0x0000, 0x0000 }, /* R5705 */ - { 0x0000, 0x0000, 0x0000 }, /* R5706 */ - { 0x0000, 0x0000, 0x0000 }, /* R5707 */ - { 0x0000, 0x0000, 0x0000 }, /* R5708 */ - { 0x0000, 0x0000, 0x0000 }, /* R5709 */ - { 0x0000, 0x0000, 0x0000 }, /* R5710 */ - { 0x0000, 0x0000, 0x0000 }, /* R5711 */ - { 0x0000, 0x0000, 0x0000 }, /* R5712 */ - { 0x0000, 0x0000, 0x0000 }, /* R5713 */ - { 0x0000, 0x0000, 0x0000 }, /* R5714 */ - { 0x0000, 0x0000, 0x0000 }, /* R5715 */ - { 0x0000, 0x0000, 0x0000 }, /* R5716 */ - { 0x0000, 0x0000, 0x0000 }, /* R5717 */ - { 0x0000, 0x0000, 0x0000 }, /* R5718 */ - { 0x0000, 0x0000, 0x0000 }, /* R5719 */ - { 0x0000, 0x0000, 0x0000 }, /* R5720 */ - { 0x0000, 0x0000, 0x0000 }, /* R5721 */ - { 0x0000, 0x0000, 0x0000 }, /* R5722 */ - { 0x0000, 0x0000, 0x0000 }, /* R5723 */ - { 0x0000, 0x0000, 0x0000 }, /* R5724 */ - { 0x0000, 0x0000, 0x0000 }, /* R5725 */ - { 0x0000, 0x0000, 0x0000 }, /* R5726 */ - { 0x0000, 0x0000, 0x0000 }, /* R5727 */ - { 0x0000, 0x0000, 0x0000 }, /* R5728 */ - { 0x0000, 0x0000, 0x0000 }, /* R5729 */ - { 0x0000, 0x0000, 0x0000 }, /* R5730 */ - { 0x0000, 0x0000, 0x0000 }, /* R5731 */ - { 0x0000, 0x0000, 0x0000 }, /* R5732 */ - { 0x0000, 0x0000, 0x0000 }, /* R5733 */ - { 0x0000, 0x0000, 0x0000 }, /* R5734 */ - { 0x0000, 0x0000, 0x0000 }, /* R5735 */ - { 0x0000, 0x0000, 0x0000 }, /* R5736 */ - { 0x0000, 0x0000, 0x0000 }, /* R5737 */ - { 0x0000, 0x0000, 0x0000 }, /* R5738 */ - { 0x0000, 0x0000, 0x0000 }, /* R5739 */ - { 0x0000, 0x0000, 0x0000 }, /* R5740 */ - { 0x0000, 0x0000, 0x0000 }, /* R5741 */ - { 0x0000, 0x0000, 0x0000 }, /* R5742 */ - { 0x0000, 0x0000, 0x0000 }, /* R5743 */ - { 0x0000, 0x0000, 0x0000 }, /* R5744 */ - { 0x0000, 0x0000, 0x0000 }, /* R5745 */ - { 0x0000, 0x0000, 0x0000 }, /* R5746 */ - { 0x0000, 0x0000, 0x0000 }, /* R5747 */ - { 0x0000, 0x0000, 0x0000 }, /* R5748 */ - { 0x0000, 0x0000, 0x0000 }, /* R5749 */ - { 0x0000, 0x0000, 0x0000 }, /* R5750 */ - { 0x0000, 0x0000, 0x0000 }, /* R5751 */ - { 0x0000, 0x0000, 0x0000 }, /* R5752 */ - { 0x0000, 0x0000, 0x0000 }, /* R5753 */ - { 0x0000, 0x0000, 0x0000 }, /* R5754 */ - { 0x0000, 0x0000, 0x0000 }, /* R5755 */ - { 0x0000, 0x0000, 0x0000 }, /* R5756 */ - { 0x0000, 0x0000, 0x0000 }, /* R5757 */ - { 0x0000, 0x0000, 0x0000 }, /* R5758 */ - { 0x0000, 0x0000, 0x0000 }, /* R5759 */ - { 0x0000, 0x0000, 0x0000 }, /* R5760 */ - { 0x0000, 0x0000, 0x0000 }, /* R5761 */ - { 0x0000, 0x0000, 0x0000 }, /* R5762 */ - { 0x0000, 0x0000, 0x0000 }, /* R5763 */ - { 0x0000, 0x0000, 0x0000 }, /* R5764 */ - { 0x0000, 0x0000, 0x0000 }, /* R5765 */ - { 0x0000, 0x0000, 0x0000 }, /* R5766 */ - { 0x0000, 0x0000, 0x0000 }, /* R5767 */ - { 0x0000, 0x0000, 0x0000 }, /* R5768 */ - { 0x0000, 0x0000, 0x0000 }, /* R5769 */ - { 0x0000, 0x0000, 0x0000 }, /* R5770 */ - { 0x0000, 0x0000, 0x0000 }, /* R5771 */ - { 0x0000, 0x0000, 0x0000 }, /* R5772 */ - { 0x0000, 0x0000, 0x0000 }, /* R5773 */ - { 0x0000, 0x0000, 0x0000 }, /* R5774 */ - { 0x0000, 0x0000, 0x0000 }, /* R5775 */ - { 0x0000, 0x0000, 0x0000 }, /* R5776 */ - { 0x0000, 0x0000, 0x0000 }, /* R5777 */ - { 0x0000, 0x0000, 0x0000 }, /* R5778 */ - { 0x0000, 0x0000, 0x0000 }, /* R5779 */ - { 0x0000, 0x0000, 0x0000 }, /* R5780 */ - { 0x0000, 0x0000, 0x0000 }, /* R5781 */ - { 0x0000, 0x0000, 0x0000 }, /* R5782 */ - { 0x0000, 0x0000, 0x0000 }, /* R5783 */ - { 0x0000, 0x0000, 0x0000 }, /* R5784 */ - { 0x0000, 0x0000, 0x0000 }, /* R5785 */ - { 0x0000, 0x0000, 0x0000 }, /* R5786 */ - { 0x0000, 0x0000, 0x0000 }, /* R5787 */ - { 0x0000, 0x0000, 0x0000 }, /* R5788 */ - { 0x0000, 0x0000, 0x0000 }, /* R5789 */ - { 0x0000, 0x0000, 0x0000 }, /* R5790 */ - { 0x0000, 0x0000, 0x0000 }, /* R5791 */ - { 0x0000, 0x0000, 0x0000 }, /* R5792 */ - { 0x0000, 0x0000, 0x0000 }, /* R5793 */ - { 0x0000, 0x0000, 0x0000 }, /* R5794 */ - { 0x0000, 0x0000, 0x0000 }, /* R5795 */ - { 0x0000, 0x0000, 0x0000 }, /* R5796 */ - { 0x0000, 0x0000, 0x0000 }, /* R5797 */ - { 0x0000, 0x0000, 0x0000 }, /* R5798 */ - { 0x0000, 0x0000, 0x0000 }, /* R5799 */ - { 0x0000, 0x0000, 0x0000 }, /* R5800 */ - { 0x0000, 0x0000, 0x0000 }, /* R5801 */ - { 0x0000, 0x0000, 0x0000 }, /* R5802 */ - { 0x0000, 0x0000, 0x0000 }, /* R5803 */ - { 0x0000, 0x0000, 0x0000 }, /* R5804 */ - { 0x0000, 0x0000, 0x0000 }, /* R5805 */ - { 0x0000, 0x0000, 0x0000 }, /* R5806 */ - { 0x0000, 0x0000, 0x0000 }, /* R5807 */ - { 0x0000, 0x0000, 0x0000 }, /* R5808 */ - { 0x0000, 0x0000, 0x0000 }, /* R5809 */ - { 0x0000, 0x0000, 0x0000 }, /* R5810 */ - { 0x0000, 0x0000, 0x0000 }, /* R5811 */ - { 0x0000, 0x0000, 0x0000 }, /* R5812 */ - { 0x0000, 0x0000, 0x0000 }, /* R5813 */ - { 0x0000, 0x0000, 0x0000 }, /* R5814 */ - { 0x0000, 0x0000, 0x0000 }, /* R5815 */ - { 0x0000, 0x0000, 0x0000 }, /* R5816 */ - { 0x0000, 0x0000, 0x0000 }, /* R5817 */ - { 0x0000, 0x0000, 0x0000 }, /* R5818 */ - { 0x0000, 0x0000, 0x0000 }, /* R5819 */ - { 0x0000, 0x0000, 0x0000 }, /* R5820 */ - { 0x0000, 0x0000, 0x0000 }, /* R5821 */ - { 0x0000, 0x0000, 0x0000 }, /* R5822 */ - { 0x0000, 0x0000, 0x0000 }, /* R5823 */ - { 0x0000, 0x0000, 0x0000 }, /* R5824 */ - { 0x0000, 0x0000, 0x0000 }, /* R5825 */ - { 0x0000, 0x0000, 0x0000 }, /* R5826 */ - { 0x0000, 0x0000, 0x0000 }, /* R5827 */ - { 0x0000, 0x0000, 0x0000 }, /* R5828 */ - { 0x0000, 0x0000, 0x0000 }, /* R5829 */ - { 0x0000, 0x0000, 0x0000 }, /* R5830 */ - { 0x0000, 0x0000, 0x0000 }, /* R5831 */ - { 0x0000, 0x0000, 0x0000 }, /* R5832 */ - { 0x0000, 0x0000, 0x0000 }, /* R5833 */ - { 0x0000, 0x0000, 0x0000 }, /* R5834 */ - { 0x0000, 0x0000, 0x0000 }, /* R5835 */ - { 0x0000, 0x0000, 0x0000 }, /* R5836 */ - { 0x0000, 0x0000, 0x0000 }, /* R5837 */ - { 0x0000, 0x0000, 0x0000 }, /* R5838 */ - { 0x0000, 0x0000, 0x0000 }, /* R5839 */ - { 0x0000, 0x0000, 0x0000 }, /* R5840 */ - { 0x0000, 0x0000, 0x0000 }, /* R5841 */ - { 0x0000, 0x0000, 0x0000 }, /* R5842 */ - { 0x0000, 0x0000, 0x0000 }, /* R5843 */ - { 0x0000, 0x0000, 0x0000 }, /* R5844 */ - { 0x0000, 0x0000, 0x0000 }, /* R5845 */ - { 0x0000, 0x0000, 0x0000 }, /* R5846 */ - { 0x0000, 0x0000, 0x0000 }, /* R5847 */ - { 0x0000, 0x0000, 0x0000 }, /* R5848 */ - { 0x0000, 0x0000, 0x0000 }, /* R5849 */ - { 0x0000, 0x0000, 0x0000 }, /* R5850 */ - { 0x0000, 0x0000, 0x0000 }, /* R5851 */ - { 0x0000, 0x0000, 0x0000 }, /* R5852 */ - { 0x0000, 0x0000, 0x0000 }, /* R5853 */ - { 0x0000, 0x0000, 0x0000 }, /* R5854 */ - { 0x0000, 0x0000, 0x0000 }, /* R5855 */ - { 0x0000, 0x0000, 0x0000 }, /* R5856 */ - { 0x0000, 0x0000, 0x0000 }, /* R5857 */ - { 0x0000, 0x0000, 0x0000 }, /* R5858 */ - { 0x0000, 0x0000, 0x0000 }, /* R5859 */ - { 0x0000, 0x0000, 0x0000 }, /* R5860 */ - { 0x0000, 0x0000, 0x0000 }, /* R5861 */ - { 0x0000, 0x0000, 0x0000 }, /* R5862 */ - { 0x0000, 0x0000, 0x0000 }, /* R5863 */ - { 0x0000, 0x0000, 0x0000 }, /* R5864 */ - { 0x0000, 0x0000, 0x0000 }, /* R5865 */ - { 0x0000, 0x0000, 0x0000 }, /* R5866 */ - { 0x0000, 0x0000, 0x0000 }, /* R5867 */ - { 0x0000, 0x0000, 0x0000 }, /* R5868 */ - { 0x0000, 0x0000, 0x0000 }, /* R5869 */ - { 0x0000, 0x0000, 0x0000 }, /* R5870 */ - { 0x0000, 0x0000, 0x0000 }, /* R5871 */ - { 0x0000, 0x0000, 0x0000 }, /* R5872 */ - { 0x0000, 0x0000, 0x0000 }, /* R5873 */ - { 0x0000, 0x0000, 0x0000 }, /* R5874 */ - { 0x0000, 0x0000, 0x0000 }, /* R5875 */ - { 0x0000, 0x0000, 0x0000 }, /* R5876 */ - { 0x0000, 0x0000, 0x0000 }, /* R5877 */ - { 0x0000, 0x0000, 0x0000 }, /* R5878 */ - { 0x0000, 0x0000, 0x0000 }, /* R5879 */ - { 0x0000, 0x0000, 0x0000 }, /* R5880 */ - { 0x0000, 0x0000, 0x0000 }, /* R5881 */ - { 0x0000, 0x0000, 0x0000 }, /* R5882 */ - { 0x0000, 0x0000, 0x0000 }, /* R5883 */ - { 0x0000, 0x0000, 0x0000 }, /* R5884 */ - { 0x0000, 0x0000, 0x0000 }, /* R5885 */ - { 0x0000, 0x0000, 0x0000 }, /* R5886 */ - { 0x0000, 0x0000, 0x0000 }, /* R5887 */ - { 0x0000, 0x0000, 0x0000 }, /* R5888 */ - { 0x0000, 0x0000, 0x0000 }, /* R5889 */ - { 0x0000, 0x0000, 0x0000 }, /* R5890 */ - { 0x0000, 0x0000, 0x0000 }, /* R5891 */ - { 0x0000, 0x0000, 0x0000 }, /* R5892 */ - { 0x0000, 0x0000, 0x0000 }, /* R5893 */ - { 0x0000, 0x0000, 0x0000 }, /* R5894 */ - { 0x0000, 0x0000, 0x0000 }, /* R5895 */ - { 0x0000, 0x0000, 0x0000 }, /* R5896 */ - { 0x0000, 0x0000, 0x0000 }, /* R5897 */ - { 0x0000, 0x0000, 0x0000 }, /* R5898 */ - { 0x0000, 0x0000, 0x0000 }, /* R5899 */ - { 0x0000, 0x0000, 0x0000 }, /* R5900 */ - { 0x0000, 0x0000, 0x0000 }, /* R5901 */ - { 0x0000, 0x0000, 0x0000 }, /* R5902 */ - { 0x0000, 0x0000, 0x0000 }, /* R5903 */ - { 0x0000, 0x0000, 0x0000 }, /* R5904 */ - { 0x0000, 0x0000, 0x0000 }, /* R5905 */ - { 0x0000, 0x0000, 0x0000 }, /* R5906 */ - { 0x0000, 0x0000, 0x0000 }, /* R5907 */ - { 0x0000, 0x0000, 0x0000 }, /* R5908 */ - { 0x0000, 0x0000, 0x0000 }, /* R5909 */ - { 0x0000, 0x0000, 0x0000 }, /* R5910 */ - { 0x0000, 0x0000, 0x0000 }, /* R5911 */ - { 0x0000, 0x0000, 0x0000 }, /* R5912 */ - { 0x0000, 0x0000, 0x0000 }, /* R5913 */ - { 0x0000, 0x0000, 0x0000 }, /* R5914 */ - { 0x0000, 0x0000, 0x0000 }, /* R5915 */ - { 0x0000, 0x0000, 0x0000 }, /* R5916 */ - { 0x0000, 0x0000, 0x0000 }, /* R5917 */ - { 0x0000, 0x0000, 0x0000 }, /* R5918 */ - { 0x0000, 0x0000, 0x0000 }, /* R5919 */ - { 0x0000, 0x0000, 0x0000 }, /* R5920 */ - { 0x0000, 0x0000, 0x0000 }, /* R5921 */ - { 0x0000, 0x0000, 0x0000 }, /* R5922 */ - { 0x0000, 0x0000, 0x0000 }, /* R5923 */ - { 0x0000, 0x0000, 0x0000 }, /* R5924 */ - { 0x0000, 0x0000, 0x0000 }, /* R5925 */ - { 0x0000, 0x0000, 0x0000 }, /* R5926 */ - { 0x0000, 0x0000, 0x0000 }, /* R5927 */ - { 0x0000, 0x0000, 0x0000 }, /* R5928 */ - { 0x0000, 0x0000, 0x0000 }, /* R5929 */ - { 0x0000, 0x0000, 0x0000 }, /* R5930 */ - { 0x0000, 0x0000, 0x0000 }, /* R5931 */ - { 0x0000, 0x0000, 0x0000 }, /* R5932 */ - { 0x0000, 0x0000, 0x0000 }, /* R5933 */ - { 0x0000, 0x0000, 0x0000 }, /* R5934 */ - { 0x0000, 0x0000, 0x0000 }, /* R5935 */ - { 0x0000, 0x0000, 0x0000 }, /* R5936 */ - { 0x0000, 0x0000, 0x0000 }, /* R5937 */ - { 0x0000, 0x0000, 0x0000 }, /* R5938 */ - { 0x0000, 0x0000, 0x0000 }, /* R5939 */ - { 0x0000, 0x0000, 0x0000 }, /* R5940 */ - { 0x0000, 0x0000, 0x0000 }, /* R5941 */ - { 0x0000, 0x0000, 0x0000 }, /* R5942 */ - { 0x0000, 0x0000, 0x0000 }, /* R5943 */ - { 0x0000, 0x0000, 0x0000 }, /* R5944 */ - { 0x0000, 0x0000, 0x0000 }, /* R5945 */ - { 0x0000, 0x0000, 0x0000 }, /* R5946 */ - { 0x0000, 0x0000, 0x0000 }, /* R5947 */ - { 0x0000, 0x0000, 0x0000 }, /* R5948 */ - { 0x0000, 0x0000, 0x0000 }, /* R5949 */ - { 0x0000, 0x0000, 0x0000 }, /* R5950 */ - { 0x0000, 0x0000, 0x0000 }, /* R5951 */ - { 0x0000, 0x0000, 0x0000 }, /* R5952 */ - { 0x0000, 0x0000, 0x0000 }, /* R5953 */ - { 0x0000, 0x0000, 0x0000 }, /* R5954 */ - { 0x0000, 0x0000, 0x0000 }, /* R5955 */ - { 0x0000, 0x0000, 0x0000 }, /* R5956 */ - { 0x0000, 0x0000, 0x0000 }, /* R5957 */ - { 0x0000, 0x0000, 0x0000 }, /* R5958 */ - { 0x0000, 0x0000, 0x0000 }, /* R5959 */ - { 0x0000, 0x0000, 0x0000 }, /* R5960 */ - { 0x0000, 0x0000, 0x0000 }, /* R5961 */ - { 0x0000, 0x0000, 0x0000 }, /* R5962 */ - { 0x0000, 0x0000, 0x0000 }, /* R5963 */ - { 0x0000, 0x0000, 0x0000 }, /* R5964 */ - { 0x0000, 0x0000, 0x0000 }, /* R5965 */ - { 0x0000, 0x0000, 0x0000 }, /* R5966 */ - { 0x0000, 0x0000, 0x0000 }, /* R5967 */ - { 0x0000, 0x0000, 0x0000 }, /* R5968 */ - { 0x0000, 0x0000, 0x0000 }, /* R5969 */ - { 0x0000, 0x0000, 0x0000 }, /* R5970 */ - { 0x0000, 0x0000, 0x0000 }, /* R5971 */ - { 0x0000, 0x0000, 0x0000 }, /* R5972 */ - { 0x0000, 0x0000, 0x0000 }, /* R5973 */ - { 0x0000, 0x0000, 0x0000 }, /* R5974 */ - { 0x0000, 0x0000, 0x0000 }, /* R5975 */ - { 0x0000, 0x0000, 0x0000 }, /* R5976 */ - { 0x0000, 0x0000, 0x0000 }, /* R5977 */ - { 0x0000, 0x0000, 0x0000 }, /* R5978 */ - { 0x0000, 0x0000, 0x0000 }, /* R5979 */ - { 0x0000, 0x0000, 0x0000 }, /* R5980 */ - { 0x0000, 0x0000, 0x0000 }, /* R5981 */ - { 0x0000, 0x0000, 0x0000 }, /* R5982 */ - { 0x0000, 0x0000, 0x0000 }, /* R5983 */ - { 0x0000, 0x0000, 0x0000 }, /* R5984 */ - { 0x0000, 0x0000, 0x0000 }, /* R5985 */ - { 0x0000, 0x0000, 0x0000 }, /* R5986 */ - { 0x0000, 0x0000, 0x0000 }, /* R5987 */ - { 0x0000, 0x0000, 0x0000 }, /* R5988 */ - { 0x0000, 0x0000, 0x0000 }, /* R5989 */ - { 0x0000, 0x0000, 0x0000 }, /* R5990 */ - { 0x0000, 0x0000, 0x0000 }, /* R5991 */ - { 0x0000, 0x0000, 0x0000 }, /* R5992 */ - { 0x0000, 0x0000, 0x0000 }, /* R5993 */ - { 0x0000, 0x0000, 0x0000 }, /* R5994 */ - { 0x0000, 0x0000, 0x0000 }, /* R5995 */ - { 0x0000, 0x0000, 0x0000 }, /* R5996 */ - { 0x0000, 0x0000, 0x0000 }, /* R5997 */ - { 0x0000, 0x0000, 0x0000 }, /* R5998 */ - { 0x0000, 0x0000, 0x0000 }, /* R5999 */ - { 0x0000, 0x0000, 0x0000 }, /* R6000 */ - { 0x0000, 0x0000, 0x0000 }, /* R6001 */ - { 0x0000, 0x0000, 0x0000 }, /* R6002 */ - { 0x0000, 0x0000, 0x0000 }, /* R6003 */ - { 0x0000, 0x0000, 0x0000 }, /* R6004 */ - { 0x0000, 0x0000, 0x0000 }, /* R6005 */ - { 0x0000, 0x0000, 0x0000 }, /* R6006 */ - { 0x0000, 0x0000, 0x0000 }, /* R6007 */ - { 0x0000, 0x0000, 0x0000 }, /* R6008 */ - { 0x0000, 0x0000, 0x0000 }, /* R6009 */ - { 0x0000, 0x0000, 0x0000 }, /* R6010 */ - { 0x0000, 0x0000, 0x0000 }, /* R6011 */ - { 0x0000, 0x0000, 0x0000 }, /* R6012 */ - { 0x0000, 0x0000, 0x0000 }, /* R6013 */ - { 0x0000, 0x0000, 0x0000 }, /* R6014 */ - { 0x0000, 0x0000, 0x0000 }, /* R6015 */ - { 0x0000, 0x0000, 0x0000 }, /* R6016 */ - { 0x0000, 0x0000, 0x0000 }, /* R6017 */ - { 0x0000, 0x0000, 0x0000 }, /* R6018 */ - { 0x0000, 0x0000, 0x0000 }, /* R6019 */ - { 0x0000, 0x0000, 0x0000 }, /* R6020 */ - { 0x0000, 0x0000, 0x0000 }, /* R6021 */ - { 0x0000, 0x0000, 0x0000 }, /* R6022 */ - { 0x0000, 0x0000, 0x0000 }, /* R6023 */ - { 0x0000, 0x0000, 0x0000 }, /* R6024 */ - { 0x0000, 0x0000, 0x0000 }, /* R6025 */ - { 0x0000, 0x0000, 0x0000 }, /* R6026 */ - { 0x0000, 0x0000, 0x0000 }, /* R6027 */ - { 0x0000, 0x0000, 0x0000 }, /* R6028 */ - { 0x0000, 0x0000, 0x0000 }, /* R6029 */ - { 0x0000, 0x0000, 0x0000 }, /* R6030 */ - { 0x0000, 0x0000, 0x0000 }, /* R6031 */ - { 0x0000, 0x0000, 0x0000 }, /* R6032 */ - { 0x0000, 0x0000, 0x0000 }, /* R6033 */ - { 0x0000, 0x0000, 0x0000 }, /* R6034 */ - { 0x0000, 0x0000, 0x0000 }, /* R6035 */ - { 0x0000, 0x0000, 0x0000 }, /* R6036 */ - { 0x0000, 0x0000, 0x0000 }, /* R6037 */ - { 0x0000, 0x0000, 0x0000 }, /* R6038 */ - { 0x0000, 0x0000, 0x0000 }, /* R6039 */ - { 0x0000, 0x0000, 0x0000 }, /* R6040 */ - { 0x0000, 0x0000, 0x0000 }, /* R6041 */ - { 0x0000, 0x0000, 0x0000 }, /* R6042 */ - { 0x0000, 0x0000, 0x0000 }, /* R6043 */ - { 0x0000, 0x0000, 0x0000 }, /* R6044 */ - { 0x0000, 0x0000, 0x0000 }, /* R6045 */ - { 0x0000, 0x0000, 0x0000 }, /* R6046 */ - { 0x0000, 0x0000, 0x0000 }, /* R6047 */ - { 0x0000, 0x0000, 0x0000 }, /* R6048 */ - { 0x0000, 0x0000, 0x0000 }, /* R6049 */ - { 0x0000, 0x0000, 0x0000 }, /* R6050 */ - { 0x0000, 0x0000, 0x0000 }, /* R6051 */ - { 0x0000, 0x0000, 0x0000 }, /* R6052 */ - { 0x0000, 0x0000, 0x0000 }, /* R6053 */ - { 0x0000, 0x0000, 0x0000 }, /* R6054 */ - { 0x0000, 0x0000, 0x0000 }, /* R6055 */ - { 0x0000, 0x0000, 0x0000 }, /* R6056 */ - { 0x0000, 0x0000, 0x0000 }, /* R6057 */ - { 0x0000, 0x0000, 0x0000 }, /* R6058 */ - { 0x0000, 0x0000, 0x0000 }, /* R6059 */ - { 0x0000, 0x0000, 0x0000 }, /* R6060 */ - { 0x0000, 0x0000, 0x0000 }, /* R6061 */ - { 0x0000, 0x0000, 0x0000 }, /* R6062 */ - { 0x0000, 0x0000, 0x0000 }, /* R6063 */ - { 0x0000, 0x0000, 0x0000 }, /* R6064 */ - { 0x0000, 0x0000, 0x0000 }, /* R6065 */ - { 0x0000, 0x0000, 0x0000 }, /* R6066 */ - { 0x0000, 0x0000, 0x0000 }, /* R6067 */ - { 0x0000, 0x0000, 0x0000 }, /* R6068 */ - { 0x0000, 0x0000, 0x0000 }, /* R6069 */ - { 0x0000, 0x0000, 0x0000 }, /* R6070 */ - { 0x0000, 0x0000, 0x0000 }, /* R6071 */ - { 0x0000, 0x0000, 0x0000 }, /* R6072 */ - { 0x0000, 0x0000, 0x0000 }, /* R6073 */ - { 0x0000, 0x0000, 0x0000 }, /* R6074 */ - { 0x0000, 0x0000, 0x0000 }, /* R6075 */ - { 0x0000, 0x0000, 0x0000 }, /* R6076 */ - { 0x0000, 0x0000, 0x0000 }, /* R6077 */ - { 0x0000, 0x0000, 0x0000 }, /* R6078 */ - { 0x0000, 0x0000, 0x0000 }, /* R6079 */ - { 0x0000, 0x0000, 0x0000 }, /* R6080 */ - { 0x0000, 0x0000, 0x0000 }, /* R6081 */ - { 0x0000, 0x0000, 0x0000 }, /* R6082 */ - { 0x0000, 0x0000, 0x0000 }, /* R6083 */ - { 0x0000, 0x0000, 0x0000 }, /* R6084 */ - { 0x0000, 0x0000, 0x0000 }, /* R6085 */ - { 0x0000, 0x0000, 0x0000 }, /* R6086 */ - { 0x0000, 0x0000, 0x0000 }, /* R6087 */ - { 0x0000, 0x0000, 0x0000 }, /* R6088 */ - { 0x0000, 0x0000, 0x0000 }, /* R6089 */ - { 0x0000, 0x0000, 0x0000 }, /* R6090 */ - { 0x0000, 0x0000, 0x0000 }, /* R6091 */ - { 0x0000, 0x0000, 0x0000 }, /* R6092 */ - { 0x0000, 0x0000, 0x0000 }, /* R6093 */ - { 0x0000, 0x0000, 0x0000 }, /* R6094 */ - { 0x0000, 0x0000, 0x0000 }, /* R6095 */ - { 0x0000, 0x0000, 0x0000 }, /* R6096 */ - { 0x0000, 0x0000, 0x0000 }, /* R6097 */ - { 0x0000, 0x0000, 0x0000 }, /* R6098 */ - { 0x0000, 0x0000, 0x0000 }, /* R6099 */ - { 0x0000, 0x0000, 0x0000 }, /* R6100 */ - { 0x0000, 0x0000, 0x0000 }, /* R6101 */ - { 0x0000, 0x0000, 0x0000 }, /* R6102 */ - { 0x0000, 0x0000, 0x0000 }, /* R6103 */ - { 0x0000, 0x0000, 0x0000 }, /* R6104 */ - { 0x0000, 0x0000, 0x0000 }, /* R6105 */ - { 0x0000, 0x0000, 0x0000 }, /* R6106 */ - { 0x0000, 0x0000, 0x0000 }, /* R6107 */ - { 0x0000, 0x0000, 0x0000 }, /* R6108 */ - { 0x0000, 0x0000, 0x0000 }, /* R6109 */ - { 0x0000, 0x0000, 0x0000 }, /* R6110 */ - { 0x0000, 0x0000, 0x0000 }, /* R6111 */ - { 0x0000, 0x0000, 0x0000 }, /* R6112 */ - { 0x0000, 0x0000, 0x0000 }, /* R6113 */ - { 0x0000, 0x0000, 0x0000 }, /* R6114 */ - { 0x0000, 0x0000, 0x0000 }, /* R6115 */ - { 0x0000, 0x0000, 0x0000 }, /* R6116 */ - { 0x0000, 0x0000, 0x0000 }, /* R6117 */ - { 0x0000, 0x0000, 0x0000 }, /* R6118 */ - { 0x0000, 0x0000, 0x0000 }, /* R6119 */ - { 0x0000, 0x0000, 0x0000 }, /* R6120 */ - { 0x0000, 0x0000, 0x0000 }, /* R6121 */ - { 0x0000, 0x0000, 0x0000 }, /* R6122 */ - { 0x0000, 0x0000, 0x0000 }, /* R6123 */ - { 0x0000, 0x0000, 0x0000 }, /* R6124 */ - { 0x0000, 0x0000, 0x0000 }, /* R6125 */ - { 0x0000, 0x0000, 0x0000 }, /* R6126 */ - { 0x0000, 0x0000, 0x0000 }, /* R6127 */ - { 0x0000, 0x0000, 0x0000 }, /* R6128 */ - { 0x0000, 0x0000, 0x0000 }, /* R6129 */ - { 0x0000, 0x0000, 0x0000 }, /* R6130 */ - { 0x0000, 0x0000, 0x0000 }, /* R6131 */ - { 0x0000, 0x0000, 0x0000 }, /* R6132 */ - { 0x0000, 0x0000, 0x0000 }, /* R6133 */ - { 0x0000, 0x0000, 0x0000 }, /* R6134 */ - { 0x0000, 0x0000, 0x0000 }, /* R6135 */ - { 0x0000, 0x0000, 0x0000 }, /* R6136 */ - { 0x0000, 0x0000, 0x0000 }, /* R6137 */ - { 0x0000, 0x0000, 0x0000 }, /* R6138 */ - { 0x0000, 0x0000, 0x0000 }, /* R6139 */ - { 0x0000, 0x0000, 0x0000 }, /* R6140 */ - { 0x0000, 0x0000, 0x0000 }, /* R6141 */ - { 0x0000, 0x0000, 0x0000 }, /* R6142 */ - { 0x0000, 0x0000, 0x0000 }, /* R6143 */ - { 0x0000, 0x0000, 0x0000 }, /* R6144 */ - { 0x0000, 0x0000, 0x0000 }, /* R6145 */ - { 0x0000, 0x0000, 0x0000 }, /* R6146 */ - { 0x0000, 0x0000, 0x0000 }, /* R6147 */ - { 0x0000, 0x0000, 0x0000 }, /* R6148 */ - { 0x0000, 0x0000, 0x0000 }, /* R6149 */ - { 0x0000, 0x0000, 0x0000 }, /* R6150 */ - { 0x0000, 0x0000, 0x0000 }, /* R6151 */ - { 0x0000, 0x0000, 0x0000 }, /* R6152 */ - { 0x0000, 0x0000, 0x0000 }, /* R6153 */ - { 0x0000, 0x0000, 0x0000 }, /* R6154 */ - { 0x0000, 0x0000, 0x0000 }, /* R6155 */ - { 0x0000, 0x0000, 0x0000 }, /* R6156 */ - { 0x0000, 0x0000, 0x0000 }, /* R6157 */ - { 0x0000, 0x0000, 0x0000 }, /* R6158 */ - { 0x0000, 0x0000, 0x0000 }, /* R6159 */ - { 0x0000, 0x0000, 0x0000 }, /* R6160 */ - { 0x0000, 0x0000, 0x0000 }, /* R6161 */ - { 0x0000, 0x0000, 0x0000 }, /* R6162 */ - { 0x0000, 0x0000, 0x0000 }, /* R6163 */ - { 0x0000, 0x0000, 0x0000 }, /* R6164 */ - { 0x0000, 0x0000, 0x0000 }, /* R6165 */ - { 0x0000, 0x0000, 0x0000 }, /* R6166 */ - { 0x0000, 0x0000, 0x0000 }, /* R6167 */ - { 0x0000, 0x0000, 0x0000 }, /* R6168 */ - { 0x0000, 0x0000, 0x0000 }, /* R6169 */ - { 0x0000, 0x0000, 0x0000 }, /* R6170 */ - { 0x0000, 0x0000, 0x0000 }, /* R6171 */ - { 0x0000, 0x0000, 0x0000 }, /* R6172 */ - { 0x0000, 0x0000, 0x0000 }, /* R6173 */ - { 0x0000, 0x0000, 0x0000 }, /* R6174 */ - { 0x0000, 0x0000, 0x0000 }, /* R6175 */ - { 0x0000, 0x0000, 0x0000 }, /* R6176 */ - { 0x0000, 0x0000, 0x0000 }, /* R6177 */ - { 0x0000, 0x0000, 0x0000 }, /* R6178 */ - { 0x0000, 0x0000, 0x0000 }, /* R6179 */ - { 0x0000, 0x0000, 0x0000 }, /* R6180 */ - { 0x0000, 0x0000, 0x0000 }, /* R6181 */ - { 0x0000, 0x0000, 0x0000 }, /* R6182 */ - { 0x0000, 0x0000, 0x0000 }, /* R6183 */ - { 0x0000, 0x0000, 0x0000 }, /* R6184 */ - { 0x0000, 0x0000, 0x0000 }, /* R6185 */ - { 0x0000, 0x0000, 0x0000 }, /* R6186 */ - { 0x0000, 0x0000, 0x0000 }, /* R6187 */ - { 0x0000, 0x0000, 0x0000 }, /* R6188 */ - { 0x0000, 0x0000, 0x0000 }, /* R6189 */ - { 0x0000, 0x0000, 0x0000 }, /* R6190 */ - { 0x0000, 0x0000, 0x0000 }, /* R6191 */ - { 0x0000, 0x0000, 0x0000 }, /* R6192 */ - { 0x0000, 0x0000, 0x0000 }, /* R6193 */ - { 0x0000, 0x0000, 0x0000 }, /* R6194 */ - { 0x0000, 0x0000, 0x0000 }, /* R6195 */ - { 0x0000, 0x0000, 0x0000 }, /* R6196 */ - { 0x0000, 0x0000, 0x0000 }, /* R6197 */ - { 0x0000, 0x0000, 0x0000 }, /* R6198 */ - { 0x0000, 0x0000, 0x0000 }, /* R6199 */ - { 0x0000, 0x0000, 0x0000 }, /* R6200 */ - { 0x0000, 0x0000, 0x0000 }, /* R6201 */ - { 0x0000, 0x0000, 0x0000 }, /* R6202 */ - { 0x0000, 0x0000, 0x0000 }, /* R6203 */ - { 0x0000, 0x0000, 0x0000 }, /* R6204 */ - { 0x0000, 0x0000, 0x0000 }, /* R6205 */ - { 0x0000, 0x0000, 0x0000 }, /* R6206 */ - { 0x0000, 0x0000, 0x0000 }, /* R6207 */ - { 0x0000, 0x0000, 0x0000 }, /* R6208 */ - { 0x0000, 0x0000, 0x0000 }, /* R6209 */ - { 0x0000, 0x0000, 0x0000 }, /* R6210 */ - { 0x0000, 0x0000, 0x0000 }, /* R6211 */ - { 0x0000, 0x0000, 0x0000 }, /* R6212 */ - { 0x0000, 0x0000, 0x0000 }, /* R6213 */ - { 0x0000, 0x0000, 0x0000 }, /* R6214 */ - { 0x0000, 0x0000, 0x0000 }, /* R6215 */ - { 0x0000, 0x0000, 0x0000 }, /* R6216 */ - { 0x0000, 0x0000, 0x0000 }, /* R6217 */ - { 0x0000, 0x0000, 0x0000 }, /* R6218 */ - { 0x0000, 0x0000, 0x0000 }, /* R6219 */ - { 0x0000, 0x0000, 0x0000 }, /* R6220 */ - { 0x0000, 0x0000, 0x0000 }, /* R6221 */ - { 0x0000, 0x0000, 0x0000 }, /* R6222 */ - { 0x0000, 0x0000, 0x0000 }, /* R6223 */ - { 0x0000, 0x0000, 0x0000 }, /* R6224 */ - { 0x0000, 0x0000, 0x0000 }, /* R6225 */ - { 0x0000, 0x0000, 0x0000 }, /* R6226 */ - { 0x0000, 0x0000, 0x0000 }, /* R6227 */ - { 0x0000, 0x0000, 0x0000 }, /* R6228 */ - { 0x0000, 0x0000, 0x0000 }, /* R6229 */ - { 0x0000, 0x0000, 0x0000 }, /* R6230 */ - { 0x0000, 0x0000, 0x0000 }, /* R6231 */ - { 0x0000, 0x0000, 0x0000 }, /* R6232 */ - { 0x0000, 0x0000, 0x0000 }, /* R6233 */ - { 0x0000, 0x0000, 0x0000 }, /* R6234 */ - { 0x0000, 0x0000, 0x0000 }, /* R6235 */ - { 0x0000, 0x0000, 0x0000 }, /* R6236 */ - { 0x0000, 0x0000, 0x0000 }, /* R6237 */ - { 0x0000, 0x0000, 0x0000 }, /* R6238 */ - { 0x0000, 0x0000, 0x0000 }, /* R6239 */ - { 0x0000, 0x0000, 0x0000 }, /* R6240 */ - { 0x0000, 0x0000, 0x0000 }, /* R6241 */ - { 0x0000, 0x0000, 0x0000 }, /* R6242 */ - { 0x0000, 0x0000, 0x0000 }, /* R6243 */ - { 0x0000, 0x0000, 0x0000 }, /* R6244 */ - { 0x0000, 0x0000, 0x0000 }, /* R6245 */ - { 0x0000, 0x0000, 0x0000 }, /* R6246 */ - { 0x0000, 0x0000, 0x0000 }, /* R6247 */ - { 0x0000, 0x0000, 0x0000 }, /* R6248 */ - { 0x0000, 0x0000, 0x0000 }, /* R6249 */ - { 0x0000, 0x0000, 0x0000 }, /* R6250 */ - { 0x0000, 0x0000, 0x0000 }, /* R6251 */ - { 0x0000, 0x0000, 0x0000 }, /* R6252 */ - { 0x0000, 0x0000, 0x0000 }, /* R6253 */ - { 0x0000, 0x0000, 0x0000 }, /* R6254 */ - { 0x0000, 0x0000, 0x0000 }, /* R6255 */ - { 0x0000, 0x0000, 0x0000 }, /* R6256 */ - { 0x0000, 0x0000, 0x0000 }, /* R6257 */ - { 0x0000, 0x0000, 0x0000 }, /* R6258 */ - { 0x0000, 0x0000, 0x0000 }, /* R6259 */ - { 0x0000, 0x0000, 0x0000 }, /* R6260 */ - { 0x0000, 0x0000, 0x0000 }, /* R6261 */ - { 0x0000, 0x0000, 0x0000 }, /* R6262 */ - { 0x0000, 0x0000, 0x0000 }, /* R6263 */ - { 0x0000, 0x0000, 0x0000 }, /* R6264 */ - { 0x0000, 0x0000, 0x0000 }, /* R6265 */ - { 0x0000, 0x0000, 0x0000 }, /* R6266 */ - { 0x0000, 0x0000, 0x0000 }, /* R6267 */ - { 0x0000, 0x0000, 0x0000 }, /* R6268 */ - { 0x0000, 0x0000, 0x0000 }, /* R6269 */ - { 0x0000, 0x0000, 0x0000 }, /* R6270 */ - { 0x0000, 0x0000, 0x0000 }, /* R6271 */ - { 0x0000, 0x0000, 0x0000 }, /* R6272 */ - { 0x0000, 0x0000, 0x0000 }, /* R6273 */ - { 0x0000, 0x0000, 0x0000 }, /* R6274 */ - { 0x0000, 0x0000, 0x0000 }, /* R6275 */ - { 0x0000, 0x0000, 0x0000 }, /* R6276 */ - { 0x0000, 0x0000, 0x0000 }, /* R6277 */ - { 0x0000, 0x0000, 0x0000 }, /* R6278 */ - { 0x0000, 0x0000, 0x0000 }, /* R6279 */ - { 0x0000, 0x0000, 0x0000 }, /* R6280 */ - { 0x0000, 0x0000, 0x0000 }, /* R6281 */ - { 0x0000, 0x0000, 0x0000 }, /* R6282 */ - { 0x0000, 0x0000, 0x0000 }, /* R6283 */ - { 0x0000, 0x0000, 0x0000 }, /* R6284 */ - { 0x0000, 0x0000, 0x0000 }, /* R6285 */ - { 0x0000, 0x0000, 0x0000 }, /* R6286 */ - { 0x0000, 0x0000, 0x0000 }, /* R6287 */ - { 0x0000, 0x0000, 0x0000 }, /* R6288 */ - { 0x0000, 0x0000, 0x0000 }, /* R6289 */ - { 0x0000, 0x0000, 0x0000 }, /* R6290 */ - { 0x0000, 0x0000, 0x0000 }, /* R6291 */ - { 0x0000, 0x0000, 0x0000 }, /* R6292 */ - { 0x0000, 0x0000, 0x0000 }, /* R6293 */ - { 0x0000, 0x0000, 0x0000 }, /* R6294 */ - { 0x0000, 0x0000, 0x0000 }, /* R6295 */ - { 0x0000, 0x0000, 0x0000 }, /* R6296 */ - { 0x0000, 0x0000, 0x0000 }, /* R6297 */ - { 0x0000, 0x0000, 0x0000 }, /* R6298 */ - { 0x0000, 0x0000, 0x0000 }, /* R6299 */ - { 0x0000, 0x0000, 0x0000 }, /* R6300 */ - { 0x0000, 0x0000, 0x0000 }, /* R6301 */ - { 0x0000, 0x0000, 0x0000 }, /* R6302 */ - { 0x0000, 0x0000, 0x0000 }, /* R6303 */ - { 0x0000, 0x0000, 0x0000 }, /* R6304 */ - { 0x0000, 0x0000, 0x0000 }, /* R6305 */ - { 0x0000, 0x0000, 0x0000 }, /* R6306 */ - { 0x0000, 0x0000, 0x0000 }, /* R6307 */ - { 0x0000, 0x0000, 0x0000 }, /* R6308 */ - { 0x0000, 0x0000, 0x0000 }, /* R6309 */ - { 0x0000, 0x0000, 0x0000 }, /* R6310 */ - { 0x0000, 0x0000, 0x0000 }, /* R6311 */ - { 0x0000, 0x0000, 0x0000 }, /* R6312 */ - { 0x0000, 0x0000, 0x0000 }, /* R6313 */ - { 0x0000, 0x0000, 0x0000 }, /* R6314 */ - { 0x0000, 0x0000, 0x0000 }, /* R6315 */ - { 0x0000, 0x0000, 0x0000 }, /* R6316 */ - { 0x0000, 0x0000, 0x0000 }, /* R6317 */ - { 0x0000, 0x0000, 0x0000 }, /* R6318 */ - { 0x0000, 0x0000, 0x0000 }, /* R6319 */ - { 0x0000, 0x0000, 0x0000 }, /* R6320 */ - { 0x0000, 0x0000, 0x0000 }, /* R6321 */ - { 0x0000, 0x0000, 0x0000 }, /* R6322 */ - { 0x0000, 0x0000, 0x0000 }, /* R6323 */ - { 0x0000, 0x0000, 0x0000 }, /* R6324 */ - { 0x0000, 0x0000, 0x0000 }, /* R6325 */ - { 0x0000, 0x0000, 0x0000 }, /* R6326 */ - { 0x0000, 0x0000, 0x0000 }, /* R6327 */ - { 0x0000, 0x0000, 0x0000 }, /* R6328 */ - { 0x0000, 0x0000, 0x0000 }, /* R6329 */ - { 0x0000, 0x0000, 0x0000 }, /* R6330 */ - { 0x0000, 0x0000, 0x0000 }, /* R6331 */ - { 0x0000, 0x0000, 0x0000 }, /* R6332 */ - { 0x0000, 0x0000, 0x0000 }, /* R6333 */ - { 0x0000, 0x0000, 0x0000 }, /* R6334 */ - { 0x0000, 0x0000, 0x0000 }, /* R6335 */ - { 0x0000, 0x0000, 0x0000 }, /* R6336 */ - { 0x0000, 0x0000, 0x0000 }, /* R6337 */ - { 0x0000, 0x0000, 0x0000 }, /* R6338 */ - { 0x0000, 0x0000, 0x0000 }, /* R6339 */ - { 0x0000, 0x0000, 0x0000 }, /* R6340 */ - { 0x0000, 0x0000, 0x0000 }, /* R6341 */ - { 0x0000, 0x0000, 0x0000 }, /* R6342 */ - { 0x0000, 0x0000, 0x0000 }, /* R6343 */ - { 0x0000, 0x0000, 0x0000 }, /* R6344 */ - { 0x0000, 0x0000, 0x0000 }, /* R6345 */ - { 0x0000, 0x0000, 0x0000 }, /* R6346 */ - { 0x0000, 0x0000, 0x0000 }, /* R6347 */ - { 0x0000, 0x0000, 0x0000 }, /* R6348 */ - { 0x0000, 0x0000, 0x0000 }, /* R6349 */ - { 0x0000, 0x0000, 0x0000 }, /* R6350 */ - { 0x0000, 0x0000, 0x0000 }, /* R6351 */ - { 0x0000, 0x0000, 0x0000 }, /* R6352 */ - { 0x0000, 0x0000, 0x0000 }, /* R6353 */ - { 0x0000, 0x0000, 0x0000 }, /* R6354 */ - { 0x0000, 0x0000, 0x0000 }, /* R6355 */ - { 0x0000, 0x0000, 0x0000 }, /* R6356 */ - { 0x0000, 0x0000, 0x0000 }, /* R6357 */ - { 0x0000, 0x0000, 0x0000 }, /* R6358 */ - { 0x0000, 0x0000, 0x0000 }, /* R6359 */ - { 0x0000, 0x0000, 0x0000 }, /* R6360 */ - { 0x0000, 0x0000, 0x0000 }, /* R6361 */ - { 0x0000, 0x0000, 0x0000 }, /* R6362 */ - { 0x0000, 0x0000, 0x0000 }, /* R6363 */ - { 0x0000, 0x0000, 0x0000 }, /* R6364 */ - { 0x0000, 0x0000, 0x0000 }, /* R6365 */ - { 0x0000, 0x0000, 0x0000 }, /* R6366 */ - { 0x0000, 0x0000, 0x0000 }, /* R6367 */ - { 0x0000, 0x0000, 0x0000 }, /* R6368 */ - { 0x0000, 0x0000, 0x0000 }, /* R6369 */ - { 0x0000, 0x0000, 0x0000 }, /* R6370 */ - { 0x0000, 0x0000, 0x0000 }, /* R6371 */ - { 0x0000, 0x0000, 0x0000 }, /* R6372 */ - { 0x0000, 0x0000, 0x0000 }, /* R6373 */ - { 0x0000, 0x0000, 0x0000 }, /* R6374 */ - { 0x0000, 0x0000, 0x0000 }, /* R6375 */ - { 0x0000, 0x0000, 0x0000 }, /* R6376 */ - { 0x0000, 0x0000, 0x0000 }, /* R6377 */ - { 0x0000, 0x0000, 0x0000 }, /* R6378 */ - { 0x0000, 0x0000, 0x0000 }, /* R6379 */ - { 0x0000, 0x0000, 0x0000 }, /* R6380 */ - { 0x0000, 0x0000, 0x0000 }, /* R6381 */ - { 0x0000, 0x0000, 0x0000 }, /* R6382 */ - { 0x0000, 0x0000, 0x0000 }, /* R6383 */ - { 0x0000, 0x0000, 0x0000 }, /* R6384 */ - { 0x0000, 0x0000, 0x0000 }, /* R6385 */ - { 0x0000, 0x0000, 0x0000 }, /* R6386 */ - { 0x0000, 0x0000, 0x0000 }, /* R6387 */ - { 0x0000, 0x0000, 0x0000 }, /* R6388 */ - { 0x0000, 0x0000, 0x0000 }, /* R6389 */ - { 0x0000, 0x0000, 0x0000 }, /* R6390 */ - { 0x0000, 0x0000, 0x0000 }, /* R6391 */ - { 0x0000, 0x0000, 0x0000 }, /* R6392 */ - { 0x0000, 0x0000, 0x0000 }, /* R6393 */ - { 0x0000, 0x0000, 0x0000 }, /* R6394 */ - { 0x0000, 0x0000, 0x0000 }, /* R6395 */ - { 0x0000, 0x0000, 0x0000 }, /* R6396 */ - { 0x0000, 0x0000, 0x0000 }, /* R6397 */ - { 0x0000, 0x0000, 0x0000 }, /* R6398 */ - { 0x0000, 0x0000, 0x0000 }, /* R6399 */ - { 0x0000, 0x0000, 0x0000 }, /* R6400 */ - { 0x0000, 0x0000, 0x0000 }, /* R6401 */ - { 0x0000, 0x0000, 0x0000 }, /* R6402 */ - { 0x0000, 0x0000, 0x0000 }, /* R6403 */ - { 0x0000, 0x0000, 0x0000 }, /* R6404 */ - { 0x0000, 0x0000, 0x0000 }, /* R6405 */ - { 0x0000, 0x0000, 0x0000 }, /* R6406 */ - { 0x0000, 0x0000, 0x0000 }, /* R6407 */ - { 0x0000, 0x0000, 0x0000 }, /* R6408 */ - { 0x0000, 0x0000, 0x0000 }, /* R6409 */ - { 0x0000, 0x0000, 0x0000 }, /* R6410 */ - { 0x0000, 0x0000, 0x0000 }, /* R6411 */ - { 0x0000, 0x0000, 0x0000 }, /* R6412 */ - { 0x0000, 0x0000, 0x0000 }, /* R6413 */ - { 0x0000, 0x0000, 0x0000 }, /* R6414 */ - { 0x0000, 0x0000, 0x0000 }, /* R6415 */ - { 0x0000, 0x0000, 0x0000 }, /* R6416 */ - { 0x0000, 0x0000, 0x0000 }, /* R6417 */ - { 0x0000, 0x0000, 0x0000 }, /* R6418 */ - { 0x0000, 0x0000, 0x0000 }, /* R6419 */ - { 0x0000, 0x0000, 0x0000 }, /* R6420 */ - { 0x0000, 0x0000, 0x0000 }, /* R6421 */ - { 0x0000, 0x0000, 0x0000 }, /* R6422 */ - { 0x0000, 0x0000, 0x0000 }, /* R6423 */ - { 0x0000, 0x0000, 0x0000 }, /* R6424 */ - { 0x0000, 0x0000, 0x0000 }, /* R6425 */ - { 0x0000, 0x0000, 0x0000 }, /* R6426 */ - { 0x0000, 0x0000, 0x0000 }, /* R6427 */ - { 0x0000, 0x0000, 0x0000 }, /* R6428 */ - { 0x0000, 0x0000, 0x0000 }, /* R6429 */ - { 0x0000, 0x0000, 0x0000 }, /* R6430 */ - { 0x0000, 0x0000, 0x0000 }, /* R6431 */ - { 0x0000, 0x0000, 0x0000 }, /* R6432 */ - { 0x0000, 0x0000, 0x0000 }, /* R6433 */ - { 0x0000, 0x0000, 0x0000 }, /* R6434 */ - { 0x0000, 0x0000, 0x0000 }, /* R6435 */ - { 0x0000, 0x0000, 0x0000 }, /* R6436 */ - { 0x0000, 0x0000, 0x0000 }, /* R6437 */ - { 0x0000, 0x0000, 0x0000 }, /* R6438 */ - { 0x0000, 0x0000, 0x0000 }, /* R6439 */ - { 0x0000, 0x0000, 0x0000 }, /* R6440 */ - { 0x0000, 0x0000, 0x0000 }, /* R6441 */ - { 0x0000, 0x0000, 0x0000 }, /* R6442 */ - { 0x0000, 0x0000, 0x0000 }, /* R6443 */ - { 0x0000, 0x0000, 0x0000 }, /* R6444 */ - { 0x0000, 0x0000, 0x0000 }, /* R6445 */ - { 0x0000, 0x0000, 0x0000 }, /* R6446 */ - { 0x0000, 0x0000, 0x0000 }, /* R6447 */ - { 0x0000, 0x0000, 0x0000 }, /* R6448 */ - { 0x0000, 0x0000, 0x0000 }, /* R6449 */ - { 0x0000, 0x0000, 0x0000 }, /* R6450 */ - { 0x0000, 0x0000, 0x0000 }, /* R6451 */ - { 0x0000, 0x0000, 0x0000 }, /* R6452 */ - { 0x0000, 0x0000, 0x0000 }, /* R6453 */ - { 0x0000, 0x0000, 0x0000 }, /* R6454 */ - { 0x0000, 0x0000, 0x0000 }, /* R6455 */ - { 0x0000, 0x0000, 0x0000 }, /* R6456 */ - { 0x0000, 0x0000, 0x0000 }, /* R6457 */ - { 0x0000, 0x0000, 0x0000 }, /* R6458 */ - { 0x0000, 0x0000, 0x0000 }, /* R6459 */ - { 0x0000, 0x0000, 0x0000 }, /* R6460 */ - { 0x0000, 0x0000, 0x0000 }, /* R6461 */ - { 0x0000, 0x0000, 0x0000 }, /* R6462 */ - { 0x0000, 0x0000, 0x0000 }, /* R6463 */ - { 0x0000, 0x0000, 0x0000 }, /* R6464 */ - { 0x0000, 0x0000, 0x0000 }, /* R6465 */ - { 0x0000, 0x0000, 0x0000 }, /* R6466 */ - { 0x0000, 0x0000, 0x0000 }, /* R6467 */ - { 0x0000, 0x0000, 0x0000 }, /* R6468 */ - { 0x0000, 0x0000, 0x0000 }, /* R6469 */ - { 0x0000, 0x0000, 0x0000 }, /* R6470 */ - { 0x0000, 0x0000, 0x0000 }, /* R6471 */ - { 0x0000, 0x0000, 0x0000 }, /* R6472 */ - { 0x0000, 0x0000, 0x0000 }, /* R6473 */ - { 0x0000, 0x0000, 0x0000 }, /* R6474 */ - { 0x0000, 0x0000, 0x0000 }, /* R6475 */ - { 0x0000, 0x0000, 0x0000 }, /* R6476 */ - { 0x0000, 0x0000, 0x0000 }, /* R6477 */ - { 0x0000, 0x0000, 0x0000 }, /* R6478 */ - { 0x0000, 0x0000, 0x0000 }, /* R6479 */ - { 0x0000, 0x0000, 0x0000 }, /* R6480 */ - { 0x0000, 0x0000, 0x0000 }, /* R6481 */ - { 0x0000, 0x0000, 0x0000 }, /* R6482 */ - { 0x0000, 0x0000, 0x0000 }, /* R6483 */ - { 0x0000, 0x0000, 0x0000 }, /* R6484 */ - { 0x0000, 0x0000, 0x0000 }, /* R6485 */ - { 0x0000, 0x0000, 0x0000 }, /* R6486 */ - { 0x0000, 0x0000, 0x0000 }, /* R6487 */ - { 0x0000, 0x0000, 0x0000 }, /* R6488 */ - { 0x0000, 0x0000, 0x0000 }, /* R6489 */ - { 0x0000, 0x0000, 0x0000 }, /* R6490 */ - { 0x0000, 0x0000, 0x0000 }, /* R6491 */ - { 0x0000, 0x0000, 0x0000 }, /* R6492 */ - { 0x0000, 0x0000, 0x0000 }, /* R6493 */ - { 0x0000, 0x0000, 0x0000 }, /* R6494 */ - { 0x0000, 0x0000, 0x0000 }, /* R6495 */ - { 0x0000, 0x0000, 0x0000 }, /* R6496 */ - { 0x0000, 0x0000, 0x0000 }, /* R6497 */ - { 0x0000, 0x0000, 0x0000 }, /* R6498 */ - { 0x0000, 0x0000, 0x0000 }, /* R6499 */ - { 0x0000, 0x0000, 0x0000 }, /* R6500 */ - { 0x0000, 0x0000, 0x0000 }, /* R6501 */ - { 0x0000, 0x0000, 0x0000 }, /* R6502 */ - { 0x0000, 0x0000, 0x0000 }, /* R6503 */ - { 0x0000, 0x0000, 0x0000 }, /* R6504 */ - { 0x0000, 0x0000, 0x0000 }, /* R6505 */ - { 0x0000, 0x0000, 0x0000 }, /* R6506 */ - { 0x0000, 0x0000, 0x0000 }, /* R6507 */ - { 0x0000, 0x0000, 0x0000 }, /* R6508 */ - { 0x0000, 0x0000, 0x0000 }, /* R6509 */ - { 0x0000, 0x0000, 0x0000 }, /* R6510 */ - { 0x0000, 0x0000, 0x0000 }, /* R6511 */ - { 0x0000, 0x0000, 0x0000 }, /* R6512 */ - { 0x0000, 0x0000, 0x0000 }, /* R6513 */ - { 0x0000, 0x0000, 0x0000 }, /* R6514 */ - { 0x0000, 0x0000, 0x0000 }, /* R6515 */ - { 0x0000, 0x0000, 0x0000 }, /* R6516 */ - { 0x0000, 0x0000, 0x0000 }, /* R6517 */ - { 0x0000, 0x0000, 0x0000 }, /* R6518 */ - { 0x0000, 0x0000, 0x0000 }, /* R6519 */ - { 0x0000, 0x0000, 0x0000 }, /* R6520 */ - { 0x0000, 0x0000, 0x0000 }, /* R6521 */ - { 0x0000, 0x0000, 0x0000 }, /* R6522 */ - { 0x0000, 0x0000, 0x0000 }, /* R6523 */ - { 0x0000, 0x0000, 0x0000 }, /* R6524 */ - { 0x0000, 0x0000, 0x0000 }, /* R6525 */ - { 0x0000, 0x0000, 0x0000 }, /* R6526 */ - { 0x0000, 0x0000, 0x0000 }, /* R6527 */ - { 0x0000, 0x0000, 0x0000 }, /* R6528 */ - { 0x0000, 0x0000, 0x0000 }, /* R6529 */ - { 0x0000, 0x0000, 0x0000 }, /* R6530 */ - { 0x0000, 0x0000, 0x0000 }, /* R6531 */ - { 0x0000, 0x0000, 0x0000 }, /* R6532 */ - { 0x0000, 0x0000, 0x0000 }, /* R6533 */ - { 0x0000, 0x0000, 0x0000 }, /* R6534 */ - { 0x0000, 0x0000, 0x0000 }, /* R6535 */ - { 0x0000, 0x0000, 0x0000 }, /* R6536 */ - { 0x0000, 0x0000, 0x0000 }, /* R6537 */ - { 0x0000, 0x0000, 0x0000 }, /* R6538 */ - { 0x0000, 0x0000, 0x0000 }, /* R6539 */ - { 0x0000, 0x0000, 0x0000 }, /* R6540 */ - { 0x0000, 0x0000, 0x0000 }, /* R6541 */ - { 0x0000, 0x0000, 0x0000 }, /* R6542 */ - { 0x0000, 0x0000, 0x0000 }, /* R6543 */ - { 0x0000, 0x0000, 0x0000 }, /* R6544 */ - { 0x0000, 0x0000, 0x0000 }, /* R6545 */ - { 0x0000, 0x0000, 0x0000 }, /* R6546 */ - { 0x0000, 0x0000, 0x0000 }, /* R6547 */ - { 0x0000, 0x0000, 0x0000 }, /* R6548 */ - { 0x0000, 0x0000, 0x0000 }, /* R6549 */ - { 0x0000, 0x0000, 0x0000 }, /* R6550 */ - { 0x0000, 0x0000, 0x0000 }, /* R6551 */ - { 0x0000, 0x0000, 0x0000 }, /* R6552 */ - { 0x0000, 0x0000, 0x0000 }, /* R6553 */ - { 0x0000, 0x0000, 0x0000 }, /* R6554 */ - { 0x0000, 0x0000, 0x0000 }, /* R6555 */ - { 0x0000, 0x0000, 0x0000 }, /* R6556 */ - { 0x0000, 0x0000, 0x0000 }, /* R6557 */ - { 0x0000, 0x0000, 0x0000 }, /* R6558 */ - { 0x0000, 0x0000, 0x0000 }, /* R6559 */ - { 0x0000, 0x0000, 0x0000 }, /* R6560 */ - { 0x0000, 0x0000, 0x0000 }, /* R6561 */ - { 0x0000, 0x0000, 0x0000 }, /* R6562 */ - { 0x0000, 0x0000, 0x0000 }, /* R6563 */ - { 0x0000, 0x0000, 0x0000 }, /* R6564 */ - { 0x0000, 0x0000, 0x0000 }, /* R6565 */ - { 0x0000, 0x0000, 0x0000 }, /* R6566 */ - { 0x0000, 0x0000, 0x0000 }, /* R6567 */ - { 0x0000, 0x0000, 0x0000 }, /* R6568 */ - { 0x0000, 0x0000, 0x0000 }, /* R6569 */ - { 0x0000, 0x0000, 0x0000 }, /* R6570 */ - { 0x0000, 0x0000, 0x0000 }, /* R6571 */ - { 0x0000, 0x0000, 0x0000 }, /* R6572 */ - { 0x0000, 0x0000, 0x0000 }, /* R6573 */ - { 0x0000, 0x0000, 0x0000 }, /* R6574 */ - { 0x0000, 0x0000, 0x0000 }, /* R6575 */ - { 0x0000, 0x0000, 0x0000 }, /* R6576 */ - { 0x0000, 0x0000, 0x0000 }, /* R6577 */ - { 0x0000, 0x0000, 0x0000 }, /* R6578 */ - { 0x0000, 0x0000, 0x0000 }, /* R6579 */ - { 0x0000, 0x0000, 0x0000 }, /* R6580 */ - { 0x0000, 0x0000, 0x0000 }, /* R6581 */ - { 0x0000, 0x0000, 0x0000 }, /* R6582 */ - { 0x0000, 0x0000, 0x0000 }, /* R6583 */ - { 0x0000, 0x0000, 0x0000 }, /* R6584 */ - { 0x0000, 0x0000, 0x0000 }, /* R6585 */ - { 0x0000, 0x0000, 0x0000 }, /* R6586 */ - { 0x0000, 0x0000, 0x0000 }, /* R6587 */ - { 0x0000, 0x0000, 0x0000 }, /* R6588 */ - { 0x0000, 0x0000, 0x0000 }, /* R6589 */ - { 0x0000, 0x0000, 0x0000 }, /* R6590 */ - { 0x0000, 0x0000, 0x0000 }, /* R6591 */ - { 0x0000, 0x0000, 0x0000 }, /* R6592 */ - { 0x0000, 0x0000, 0x0000 }, /* R6593 */ - { 0x0000, 0x0000, 0x0000 }, /* R6594 */ - { 0x0000, 0x0000, 0x0000 }, /* R6595 */ - { 0x0000, 0x0000, 0x0000 }, /* R6596 */ - { 0x0000, 0x0000, 0x0000 }, /* R6597 */ - { 0x0000, 0x0000, 0x0000 }, /* R6598 */ - { 0x0000, 0x0000, 0x0000 }, /* R6599 */ - { 0x0000, 0x0000, 0x0000 }, /* R6600 */ - { 0x0000, 0x0000, 0x0000 }, /* R6601 */ - { 0x0000, 0x0000, 0x0000 }, /* R6602 */ - { 0x0000, 0x0000, 0x0000 }, /* R6603 */ - { 0x0000, 0x0000, 0x0000 }, /* R6604 */ - { 0x0000, 0x0000, 0x0000 }, /* R6605 */ - { 0x0000, 0x0000, 0x0000 }, /* R6606 */ - { 0x0000, 0x0000, 0x0000 }, /* R6607 */ - { 0x0000, 0x0000, 0x0000 }, /* R6608 */ - { 0x0000, 0x0000, 0x0000 }, /* R6609 */ - { 0x0000, 0x0000, 0x0000 }, /* R6610 */ - { 0x0000, 0x0000, 0x0000 }, /* R6611 */ - { 0x0000, 0x0000, 0x0000 }, /* R6612 */ - { 0x0000, 0x0000, 0x0000 }, /* R6613 */ - { 0x0000, 0x0000, 0x0000 }, /* R6614 */ - { 0x0000, 0x0000, 0x0000 }, /* R6615 */ - { 0x0000, 0x0000, 0x0000 }, /* R6616 */ - { 0x0000, 0x0000, 0x0000 }, /* R6617 */ - { 0x0000, 0x0000, 0x0000 }, /* R6618 */ - { 0x0000, 0x0000, 0x0000 }, /* R6619 */ - { 0x0000, 0x0000, 0x0000 }, /* R6620 */ - { 0x0000, 0x0000, 0x0000 }, /* R6621 */ - { 0x0000, 0x0000, 0x0000 }, /* R6622 */ - { 0x0000, 0x0000, 0x0000 }, /* R6623 */ - { 0x0000, 0x0000, 0x0000 }, /* R6624 */ - { 0x0000, 0x0000, 0x0000 }, /* R6625 */ - { 0x0000, 0x0000, 0x0000 }, /* R6626 */ - { 0x0000, 0x0000, 0x0000 }, /* R6627 */ - { 0x0000, 0x0000, 0x0000 }, /* R6628 */ - { 0x0000, 0x0000, 0x0000 }, /* R6629 */ - { 0x0000, 0x0000, 0x0000 }, /* R6630 */ - { 0x0000, 0x0000, 0x0000 }, /* R6631 */ - { 0x0000, 0x0000, 0x0000 }, /* R6632 */ - { 0x0000, 0x0000, 0x0000 }, /* R6633 */ - { 0x0000, 0x0000, 0x0000 }, /* R6634 */ - { 0x0000, 0x0000, 0x0000 }, /* R6635 */ - { 0x0000, 0x0000, 0x0000 }, /* R6636 */ - { 0x0000, 0x0000, 0x0000 }, /* R6637 */ - { 0x0000, 0x0000, 0x0000 }, /* R6638 */ - { 0x0000, 0x0000, 0x0000 }, /* R6639 */ - { 0x0000, 0x0000, 0x0000 }, /* R6640 */ - { 0x0000, 0x0000, 0x0000 }, /* R6641 */ - { 0x0000, 0x0000, 0x0000 }, /* R6642 */ - { 0x0000, 0x0000, 0x0000 }, /* R6643 */ - { 0x0000, 0x0000, 0x0000 }, /* R6644 */ - { 0x0000, 0x0000, 0x0000 }, /* R6645 */ - { 0x0000, 0x0000, 0x0000 }, /* R6646 */ - { 0x0000, 0x0000, 0x0000 }, /* R6647 */ - { 0x0000, 0x0000, 0x0000 }, /* R6648 */ - { 0x0000, 0x0000, 0x0000 }, /* R6649 */ - { 0x0000, 0x0000, 0x0000 }, /* R6650 */ - { 0x0000, 0x0000, 0x0000 }, /* R6651 */ - { 0x0000, 0x0000, 0x0000 }, /* R6652 */ - { 0x0000, 0x0000, 0x0000 }, /* R6653 */ - { 0x0000, 0x0000, 0x0000 }, /* R6654 */ - { 0x0000, 0x0000, 0x0000 }, /* R6655 */ - { 0x0000, 0x0000, 0x0000 }, /* R6656 */ - { 0x0000, 0x0000, 0x0000 }, /* R6657 */ - { 0x0000, 0x0000, 0x0000 }, /* R6658 */ - { 0x0000, 0x0000, 0x0000 }, /* R6659 */ - { 0x0000, 0x0000, 0x0000 }, /* R6660 */ - { 0x0000, 0x0000, 0x0000 }, /* R6661 */ - { 0x0000, 0x0000, 0x0000 }, /* R6662 */ - { 0x0000, 0x0000, 0x0000 }, /* R6663 */ - { 0x0000, 0x0000, 0x0000 }, /* R6664 */ - { 0x0000, 0x0000, 0x0000 }, /* R6665 */ - { 0x0000, 0x0000, 0x0000 }, /* R6666 */ - { 0x0000, 0x0000, 0x0000 }, /* R6667 */ - { 0x0000, 0x0000, 0x0000 }, /* R6668 */ - { 0x0000, 0x0000, 0x0000 }, /* R6669 */ - { 0x0000, 0x0000, 0x0000 }, /* R6670 */ - { 0x0000, 0x0000, 0x0000 }, /* R6671 */ - { 0x0000, 0x0000, 0x0000 }, /* R6672 */ - { 0x0000, 0x0000, 0x0000 }, /* R6673 */ - { 0x0000, 0x0000, 0x0000 }, /* R6674 */ - { 0x0000, 0x0000, 0x0000 }, /* R6675 */ - { 0x0000, 0x0000, 0x0000 }, /* R6676 */ - { 0x0000, 0x0000, 0x0000 }, /* R6677 */ - { 0x0000, 0x0000, 0x0000 }, /* R6678 */ - { 0x0000, 0x0000, 0x0000 }, /* R6679 */ - { 0x0000, 0x0000, 0x0000 }, /* R6680 */ - { 0x0000, 0x0000, 0x0000 }, /* R6681 */ - { 0x0000, 0x0000, 0x0000 }, /* R6682 */ - { 0x0000, 0x0000, 0x0000 }, /* R6683 */ - { 0x0000, 0x0000, 0x0000 }, /* R6684 */ - { 0x0000, 0x0000, 0x0000 }, /* R6685 */ - { 0x0000, 0x0000, 0x0000 }, /* R6686 */ - { 0x0000, 0x0000, 0x0000 }, /* R6687 */ - { 0x0000, 0x0000, 0x0000 }, /* R6688 */ - { 0x0000, 0x0000, 0x0000 }, /* R6689 */ - { 0x0000, 0x0000, 0x0000 }, /* R6690 */ - { 0x0000, 0x0000, 0x0000 }, /* R6691 */ - { 0x0000, 0x0000, 0x0000 }, /* R6692 */ - { 0x0000, 0x0000, 0x0000 }, /* R6693 */ - { 0x0000, 0x0000, 0x0000 }, /* R6694 */ - { 0x0000, 0x0000, 0x0000 }, /* R6695 */ - { 0x0000, 0x0000, 0x0000 }, /* R6696 */ - { 0x0000, 0x0000, 0x0000 }, /* R6697 */ - { 0x0000, 0x0000, 0x0000 }, /* R6698 */ - { 0x0000, 0x0000, 0x0000 }, /* R6699 */ - { 0x0000, 0x0000, 0x0000 }, /* R6700 */ - { 0x0000, 0x0000, 0x0000 }, /* R6701 */ - { 0x0000, 0x0000, 0x0000 }, /* R6702 */ - { 0x0000, 0x0000, 0x0000 }, /* R6703 */ - { 0x0000, 0x0000, 0x0000 }, /* R6704 */ - { 0x0000, 0x0000, 0x0000 }, /* R6705 */ - { 0x0000, 0x0000, 0x0000 }, /* R6706 */ - { 0x0000, 0x0000, 0x0000 }, /* R6707 */ - { 0x0000, 0x0000, 0x0000 }, /* R6708 */ - { 0x0000, 0x0000, 0x0000 }, /* R6709 */ - { 0x0000, 0x0000, 0x0000 }, /* R6710 */ - { 0x0000, 0x0000, 0x0000 }, /* R6711 */ - { 0x0000, 0x0000, 0x0000 }, /* R6712 */ - { 0x0000, 0x0000, 0x0000 }, /* R6713 */ - { 0x0000, 0x0000, 0x0000 }, /* R6714 */ - { 0x0000, 0x0000, 0x0000 }, /* R6715 */ - { 0x0000, 0x0000, 0x0000 }, /* R6716 */ - { 0x0000, 0x0000, 0x0000 }, /* R6717 */ - { 0x0000, 0x0000, 0x0000 }, /* R6718 */ - { 0x0000, 0x0000, 0x0000 }, /* R6719 */ - { 0x0000, 0x0000, 0x0000 }, /* R6720 */ - { 0x0000, 0x0000, 0x0000 }, /* R6721 */ - { 0x0000, 0x0000, 0x0000 }, /* R6722 */ - { 0x0000, 0x0000, 0x0000 }, /* R6723 */ - { 0x0000, 0x0000, 0x0000 }, /* R6724 */ - { 0x0000, 0x0000, 0x0000 }, /* R6725 */ - { 0x0000, 0x0000, 0x0000 }, /* R6726 */ - { 0x0000, 0x0000, 0x0000 }, /* R6727 */ - { 0x0000, 0x0000, 0x0000 }, /* R6728 */ - { 0x0000, 0x0000, 0x0000 }, /* R6729 */ - { 0x0000, 0x0000, 0x0000 }, /* R6730 */ - { 0x0000, 0x0000, 0x0000 }, /* R6731 */ - { 0x0000, 0x0000, 0x0000 }, /* R6732 */ - { 0x0000, 0x0000, 0x0000 }, /* R6733 */ - { 0x0000, 0x0000, 0x0000 }, /* R6734 */ - { 0x0000, 0x0000, 0x0000 }, /* R6735 */ - { 0x0000, 0x0000, 0x0000 }, /* R6736 */ - { 0x0000, 0x0000, 0x0000 }, /* R6737 */ - { 0x0000, 0x0000, 0x0000 }, /* R6738 */ - { 0x0000, 0x0000, 0x0000 }, /* R6739 */ - { 0x0000, 0x0000, 0x0000 }, /* R6740 */ - { 0x0000, 0x0000, 0x0000 }, /* R6741 */ - { 0x0000, 0x0000, 0x0000 }, /* R6742 */ - { 0x0000, 0x0000, 0x0000 }, /* R6743 */ - { 0x0000, 0x0000, 0x0000 }, /* R6744 */ - { 0x0000, 0x0000, 0x0000 }, /* R6745 */ - { 0x0000, 0x0000, 0x0000 }, /* R6746 */ - { 0x0000, 0x0000, 0x0000 }, /* R6747 */ - { 0x0000, 0x0000, 0x0000 }, /* R6748 */ - { 0x0000, 0x0000, 0x0000 }, /* R6749 */ - { 0x0000, 0x0000, 0x0000 }, /* R6750 */ - { 0x0000, 0x0000, 0x0000 }, /* R6751 */ - { 0x0000, 0x0000, 0x0000 }, /* R6752 */ - { 0x0000, 0x0000, 0x0000 }, /* R6753 */ - { 0x0000, 0x0000, 0x0000 }, /* R6754 */ - { 0x0000, 0x0000, 0x0000 }, /* R6755 */ - { 0x0000, 0x0000, 0x0000 }, /* R6756 */ - { 0x0000, 0x0000, 0x0000 }, /* R6757 */ - { 0x0000, 0x0000, 0x0000 }, /* R6758 */ - { 0x0000, 0x0000, 0x0000 }, /* R6759 */ - { 0x0000, 0x0000, 0x0000 }, /* R6760 */ - { 0x0000, 0x0000, 0x0000 }, /* R6761 */ - { 0x0000, 0x0000, 0x0000 }, /* R6762 */ - { 0x0000, 0x0000, 0x0000 }, /* R6763 */ - { 0x0000, 0x0000, 0x0000 }, /* R6764 */ - { 0x0000, 0x0000, 0x0000 }, /* R6765 */ - { 0x0000, 0x0000, 0x0000 }, /* R6766 */ - { 0x0000, 0x0000, 0x0000 }, /* R6767 */ - { 0x0000, 0x0000, 0x0000 }, /* R6768 */ - { 0x0000, 0x0000, 0x0000 }, /* R6769 */ - { 0x0000, 0x0000, 0x0000 }, /* R6770 */ - { 0x0000, 0x0000, 0x0000 }, /* R6771 */ - { 0x0000, 0x0000, 0x0000 }, /* R6772 */ - { 0x0000, 0x0000, 0x0000 }, /* R6773 */ - { 0x0000, 0x0000, 0x0000 }, /* R6774 */ - { 0x0000, 0x0000, 0x0000 }, /* R6775 */ - { 0x0000, 0x0000, 0x0000 }, /* R6776 */ - { 0x0000, 0x0000, 0x0000 }, /* R6777 */ - { 0x0000, 0x0000, 0x0000 }, /* R6778 */ - { 0x0000, 0x0000, 0x0000 }, /* R6779 */ - { 0x0000, 0x0000, 0x0000 }, /* R6780 */ - { 0x0000, 0x0000, 0x0000 }, /* R6781 */ - { 0x0000, 0x0000, 0x0000 }, /* R6782 */ - { 0x0000, 0x0000, 0x0000 }, /* R6783 */ - { 0x0000, 0x0000, 0x0000 }, /* R6784 */ - { 0x0000, 0x0000, 0x0000 }, /* R6785 */ - { 0x0000, 0x0000, 0x0000 }, /* R6786 */ - { 0x0000, 0x0000, 0x0000 }, /* R6787 */ - { 0x0000, 0x0000, 0x0000 }, /* R6788 */ - { 0x0000, 0x0000, 0x0000 }, /* R6789 */ - { 0x0000, 0x0000, 0x0000 }, /* R6790 */ - { 0x0000, 0x0000, 0x0000 }, /* R6791 */ - { 0x0000, 0x0000, 0x0000 }, /* R6792 */ - { 0x0000, 0x0000, 0x0000 }, /* R6793 */ - { 0x0000, 0x0000, 0x0000 }, /* R6794 */ - { 0x0000, 0x0000, 0x0000 }, /* R6795 */ - { 0x0000, 0x0000, 0x0000 }, /* R6796 */ - { 0x0000, 0x0000, 0x0000 }, /* R6797 */ - { 0x0000, 0x0000, 0x0000 }, /* R6798 */ - { 0x0000, 0x0000, 0x0000 }, /* R6799 */ - { 0x0000, 0x0000, 0x0000 }, /* R6800 */ - { 0x0000, 0x0000, 0x0000 }, /* R6801 */ - { 0x0000, 0x0000, 0x0000 }, /* R6802 */ - { 0x0000, 0x0000, 0x0000 }, /* R6803 */ - { 0x0000, 0x0000, 0x0000 }, /* R6804 */ - { 0x0000, 0x0000, 0x0000 }, /* R6805 */ - { 0x0000, 0x0000, 0x0000 }, /* R6806 */ - { 0x0000, 0x0000, 0x0000 }, /* R6807 */ - { 0x0000, 0x0000, 0x0000 }, /* R6808 */ - { 0x0000, 0x0000, 0x0000 }, /* R6809 */ - { 0x0000, 0x0000, 0x0000 }, /* R6810 */ - { 0x0000, 0x0000, 0x0000 }, /* R6811 */ - { 0x0000, 0x0000, 0x0000 }, /* R6812 */ - { 0x0000, 0x0000, 0x0000 }, /* R6813 */ - { 0x0000, 0x0000, 0x0000 }, /* R6814 */ - { 0x0000, 0x0000, 0x0000 }, /* R6815 */ - { 0x0000, 0x0000, 0x0000 }, /* R6816 */ - { 0x0000, 0x0000, 0x0000 }, /* R6817 */ - { 0x0000, 0x0000, 0x0000 }, /* R6818 */ - { 0x0000, 0x0000, 0x0000 }, /* R6819 */ - { 0x0000, 0x0000, 0x0000 }, /* R6820 */ - { 0x0000, 0x0000, 0x0000 }, /* R6821 */ - { 0x0000, 0x0000, 0x0000 }, /* R6822 */ - { 0x0000, 0x0000, 0x0000 }, /* R6823 */ - { 0x0000, 0x0000, 0x0000 }, /* R6824 */ - { 0x0000, 0x0000, 0x0000 }, /* R6825 */ - { 0x0000, 0x0000, 0x0000 }, /* R6826 */ - { 0x0000, 0x0000, 0x0000 }, /* R6827 */ - { 0x0000, 0x0000, 0x0000 }, /* R6828 */ - { 0x0000, 0x0000, 0x0000 }, /* R6829 */ - { 0x0000, 0x0000, 0x0000 }, /* R6830 */ - { 0x0000, 0x0000, 0x0000 }, /* R6831 */ - { 0x0000, 0x0000, 0x0000 }, /* R6832 */ - { 0x0000, 0x0000, 0x0000 }, /* R6833 */ - { 0x0000, 0x0000, 0x0000 }, /* R6834 */ - { 0x0000, 0x0000, 0x0000 }, /* R6835 */ - { 0x0000, 0x0000, 0x0000 }, /* R6836 */ - { 0x0000, 0x0000, 0x0000 }, /* R6837 */ - { 0x0000, 0x0000, 0x0000 }, /* R6838 */ - { 0x0000, 0x0000, 0x0000 }, /* R6839 */ - { 0x0000, 0x0000, 0x0000 }, /* R6840 */ - { 0x0000, 0x0000, 0x0000 }, /* R6841 */ - { 0x0000, 0x0000, 0x0000 }, /* R6842 */ - { 0x0000, 0x0000, 0x0000 }, /* R6843 */ - { 0x0000, 0x0000, 0x0000 }, /* R6844 */ - { 0x0000, 0x0000, 0x0000 }, /* R6845 */ - { 0x0000, 0x0000, 0x0000 }, /* R6846 */ - { 0x0000, 0x0000, 0x0000 }, /* R6847 */ - { 0x0000, 0x0000, 0x0000 }, /* R6848 */ - { 0x0000, 0x0000, 0x0000 }, /* R6849 */ - { 0x0000, 0x0000, 0x0000 }, /* R6850 */ - { 0x0000, 0x0000, 0x0000 }, /* R6851 */ - { 0x0000, 0x0000, 0x0000 }, /* R6852 */ - { 0x0000, 0x0000, 0x0000 }, /* R6853 */ - { 0x0000, 0x0000, 0x0000 }, /* R6854 */ - { 0x0000, 0x0000, 0x0000 }, /* R6855 */ - { 0x0000, 0x0000, 0x0000 }, /* R6856 */ - { 0x0000, 0x0000, 0x0000 }, /* R6857 */ - { 0x0000, 0x0000, 0x0000 }, /* R6858 */ - { 0x0000, 0x0000, 0x0000 }, /* R6859 */ - { 0x0000, 0x0000, 0x0000 }, /* R6860 */ - { 0x0000, 0x0000, 0x0000 }, /* R6861 */ - { 0x0000, 0x0000, 0x0000 }, /* R6862 */ - { 0x0000, 0x0000, 0x0000 }, /* R6863 */ - { 0x0000, 0x0000, 0x0000 }, /* R6864 */ - { 0x0000, 0x0000, 0x0000 }, /* R6865 */ - { 0x0000, 0x0000, 0x0000 }, /* R6866 */ - { 0x0000, 0x0000, 0x0000 }, /* R6867 */ - { 0x0000, 0x0000, 0x0000 }, /* R6868 */ - { 0x0000, 0x0000, 0x0000 }, /* R6869 */ - { 0x0000, 0x0000, 0x0000 }, /* R6870 */ - { 0x0000, 0x0000, 0x0000 }, /* R6871 */ - { 0x0000, 0x0000, 0x0000 }, /* R6872 */ - { 0x0000, 0x0000, 0x0000 }, /* R6873 */ - { 0x0000, 0x0000, 0x0000 }, /* R6874 */ - { 0x0000, 0x0000, 0x0000 }, /* R6875 */ - { 0x0000, 0x0000, 0x0000 }, /* R6876 */ - { 0x0000, 0x0000, 0x0000 }, /* R6877 */ - { 0x0000, 0x0000, 0x0000 }, /* R6878 */ - { 0x0000, 0x0000, 0x0000 }, /* R6879 */ - { 0x0000, 0x0000, 0x0000 }, /* R6880 */ - { 0x0000, 0x0000, 0x0000 }, /* R6881 */ - { 0x0000, 0x0000, 0x0000 }, /* R6882 */ - { 0x0000, 0x0000, 0x0000 }, /* R6883 */ - { 0x0000, 0x0000, 0x0000 }, /* R6884 */ - { 0x0000, 0x0000, 0x0000 }, /* R6885 */ - { 0x0000, 0x0000, 0x0000 }, /* R6886 */ - { 0x0000, 0x0000, 0x0000 }, /* R6887 */ - { 0x0000, 0x0000, 0x0000 }, /* R6888 */ - { 0x0000, 0x0000, 0x0000 }, /* R6889 */ - { 0x0000, 0x0000, 0x0000 }, /* R6890 */ - { 0x0000, 0x0000, 0x0000 }, /* R6891 */ - { 0x0000, 0x0000, 0x0000 }, /* R6892 */ - { 0x0000, 0x0000, 0x0000 }, /* R6893 */ - { 0x0000, 0x0000, 0x0000 }, /* R6894 */ - { 0x0000, 0x0000, 0x0000 }, /* R6895 */ - { 0x0000, 0x0000, 0x0000 }, /* R6896 */ - { 0x0000, 0x0000, 0x0000 }, /* R6897 */ - { 0x0000, 0x0000, 0x0000 }, /* R6898 */ - { 0x0000, 0x0000, 0x0000 }, /* R6899 */ - { 0x0000, 0x0000, 0x0000 }, /* R6900 */ - { 0x0000, 0x0000, 0x0000 }, /* R6901 */ - { 0x0000, 0x0000, 0x0000 }, /* R6902 */ - { 0x0000, 0x0000, 0x0000 }, /* R6903 */ - { 0x0000, 0x0000, 0x0000 }, /* R6904 */ - { 0x0000, 0x0000, 0x0000 }, /* R6905 */ - { 0x0000, 0x0000, 0x0000 }, /* R6906 */ - { 0x0000, 0x0000, 0x0000 }, /* R6907 */ - { 0x0000, 0x0000, 0x0000 }, /* R6908 */ - { 0x0000, 0x0000, 0x0000 }, /* R6909 */ - { 0x0000, 0x0000, 0x0000 }, /* R6910 */ - { 0x0000, 0x0000, 0x0000 }, /* R6911 */ - { 0x0000, 0x0000, 0x0000 }, /* R6912 */ - { 0x0000, 0x0000, 0x0000 }, /* R6913 */ - { 0x0000, 0x0000, 0x0000 }, /* R6914 */ - { 0x0000, 0x0000, 0x0000 }, /* R6915 */ - { 0x0000, 0x0000, 0x0000 }, /* R6916 */ - { 0x0000, 0x0000, 0x0000 }, /* R6917 */ - { 0x0000, 0x0000, 0x0000 }, /* R6918 */ - { 0x0000, 0x0000, 0x0000 }, /* R6919 */ - { 0x0000, 0x0000, 0x0000 }, /* R6920 */ - { 0x0000, 0x0000, 0x0000 }, /* R6921 */ - { 0x0000, 0x0000, 0x0000 }, /* R6922 */ - { 0x0000, 0x0000, 0x0000 }, /* R6923 */ - { 0x0000, 0x0000, 0x0000 }, /* R6924 */ - { 0x0000, 0x0000, 0x0000 }, /* R6925 */ - { 0x0000, 0x0000, 0x0000 }, /* R6926 */ - { 0x0000, 0x0000, 0x0000 }, /* R6927 */ - { 0x0000, 0x0000, 0x0000 }, /* R6928 */ - { 0x0000, 0x0000, 0x0000 }, /* R6929 */ - { 0x0000, 0x0000, 0x0000 }, /* R6930 */ - { 0x0000, 0x0000, 0x0000 }, /* R6931 */ - { 0x0000, 0x0000, 0x0000 }, /* R6932 */ - { 0x0000, 0x0000, 0x0000 }, /* R6933 */ - { 0x0000, 0x0000, 0x0000 }, /* R6934 */ - { 0x0000, 0x0000, 0x0000 }, /* R6935 */ - { 0x0000, 0x0000, 0x0000 }, /* R6936 */ - { 0x0000, 0x0000, 0x0000 }, /* R6937 */ - { 0x0000, 0x0000, 0x0000 }, /* R6938 */ - { 0x0000, 0x0000, 0x0000 }, /* R6939 */ - { 0x0000, 0x0000, 0x0000 }, /* R6940 */ - { 0x0000, 0x0000, 0x0000 }, /* R6941 */ - { 0x0000, 0x0000, 0x0000 }, /* R6942 */ - { 0x0000, 0x0000, 0x0000 }, /* R6943 */ - { 0x0000, 0x0000, 0x0000 }, /* R6944 */ - { 0x0000, 0x0000, 0x0000 }, /* R6945 */ - { 0x0000, 0x0000, 0x0000 }, /* R6946 */ - { 0x0000, 0x0000, 0x0000 }, /* R6947 */ - { 0x0000, 0x0000, 0x0000 }, /* R6948 */ - { 0x0000, 0x0000, 0x0000 }, /* R6949 */ - { 0x0000, 0x0000, 0x0000 }, /* R6950 */ - { 0x0000, 0x0000, 0x0000 }, /* R6951 */ - { 0x0000, 0x0000, 0x0000 }, /* R6952 */ - { 0x0000, 0x0000, 0x0000 }, /* R6953 */ - { 0x0000, 0x0000, 0x0000 }, /* R6954 */ - { 0x0000, 0x0000, 0x0000 }, /* R6955 */ - { 0x0000, 0x0000, 0x0000 }, /* R6956 */ - { 0x0000, 0x0000, 0x0000 }, /* R6957 */ - { 0x0000, 0x0000, 0x0000 }, /* R6958 */ - { 0x0000, 0x0000, 0x0000 }, /* R6959 */ - { 0x0000, 0x0000, 0x0000 }, /* R6960 */ - { 0x0000, 0x0000, 0x0000 }, /* R6961 */ - { 0x0000, 0x0000, 0x0000 }, /* R6962 */ - { 0x0000, 0x0000, 0x0000 }, /* R6963 */ - { 0x0000, 0x0000, 0x0000 }, /* R6964 */ - { 0x0000, 0x0000, 0x0000 }, /* R6965 */ - { 0x0000, 0x0000, 0x0000 }, /* R6966 */ - { 0x0000, 0x0000, 0x0000 }, /* R6967 */ - { 0x0000, 0x0000, 0x0000 }, /* R6968 */ - { 0x0000, 0x0000, 0x0000 }, /* R6969 */ - { 0x0000, 0x0000, 0x0000 }, /* R6970 */ - { 0x0000, 0x0000, 0x0000 }, /* R6971 */ - { 0x0000, 0x0000, 0x0000 }, /* R6972 */ - { 0x0000, 0x0000, 0x0000 }, /* R6973 */ - { 0x0000, 0x0000, 0x0000 }, /* R6974 */ - { 0x0000, 0x0000, 0x0000 }, /* R6975 */ - { 0x0000, 0x0000, 0x0000 }, /* R6976 */ - { 0x0000, 0x0000, 0x0000 }, /* R6977 */ - { 0x0000, 0x0000, 0x0000 }, /* R6978 */ - { 0x0000, 0x0000, 0x0000 }, /* R6979 */ - { 0x0000, 0x0000, 0x0000 }, /* R6980 */ - { 0x0000, 0x0000, 0x0000 }, /* R6981 */ - { 0x0000, 0x0000, 0x0000 }, /* R6982 */ - { 0x0000, 0x0000, 0x0000 }, /* R6983 */ - { 0x0000, 0x0000, 0x0000 }, /* R6984 */ - { 0x0000, 0x0000, 0x0000 }, /* R6985 */ - { 0x0000, 0x0000, 0x0000 }, /* R6986 */ - { 0x0000, 0x0000, 0x0000 }, /* R6987 */ - { 0x0000, 0x0000, 0x0000 }, /* R6988 */ - { 0x0000, 0x0000, 0x0000 }, /* R6989 */ - { 0x0000, 0x0000, 0x0000 }, /* R6990 */ - { 0x0000, 0x0000, 0x0000 }, /* R6991 */ - { 0x0000, 0x0000, 0x0000 }, /* R6992 */ - { 0x0000, 0x0000, 0x0000 }, /* R6993 */ - { 0x0000, 0x0000, 0x0000 }, /* R6994 */ - { 0x0000, 0x0000, 0x0000 }, /* R6995 */ - { 0x0000, 0x0000, 0x0000 }, /* R6996 */ - { 0x0000, 0x0000, 0x0000 }, /* R6997 */ - { 0x0000, 0x0000, 0x0000 }, /* R6998 */ - { 0x0000, 0x0000, 0x0000 }, /* R6999 */ - { 0x0000, 0x0000, 0x0000 }, /* R7000 */ - { 0x0000, 0x0000, 0x0000 }, /* R7001 */ - { 0x0000, 0x0000, 0x0000 }, /* R7002 */ - { 0x0000, 0x0000, 0x0000 }, /* R7003 */ - { 0x0000, 0x0000, 0x0000 }, /* R7004 */ - { 0x0000, 0x0000, 0x0000 }, /* R7005 */ - { 0x0000, 0x0000, 0x0000 }, /* R7006 */ - { 0x0000, 0x0000, 0x0000 }, /* R7007 */ - { 0x0000, 0x0000, 0x0000 }, /* R7008 */ - { 0x0000, 0x0000, 0x0000 }, /* R7009 */ - { 0x0000, 0x0000, 0x0000 }, /* R7010 */ - { 0x0000, 0x0000, 0x0000 }, /* R7011 */ - { 0x0000, 0x0000, 0x0000 }, /* R7012 */ - { 0x0000, 0x0000, 0x0000 }, /* R7013 */ - { 0x0000, 0x0000, 0x0000 }, /* R7014 */ - { 0x0000, 0x0000, 0x0000 }, /* R7015 */ - { 0x0000, 0x0000, 0x0000 }, /* R7016 */ - { 0x0000, 0x0000, 0x0000 }, /* R7017 */ - { 0x0000, 0x0000, 0x0000 }, /* R7018 */ - { 0x0000, 0x0000, 0x0000 }, /* R7019 */ - { 0x0000, 0x0000, 0x0000 }, /* R7020 */ - { 0x0000, 0x0000, 0x0000 }, /* R7021 */ - { 0x0000, 0x0000, 0x0000 }, /* R7022 */ - { 0x0000, 0x0000, 0x0000 }, /* R7023 */ - { 0x0000, 0x0000, 0x0000 }, /* R7024 */ - { 0x0000, 0x0000, 0x0000 }, /* R7025 */ - { 0x0000, 0x0000, 0x0000 }, /* R7026 */ - { 0x0000, 0x0000, 0x0000 }, /* R7027 */ - { 0x0000, 0x0000, 0x0000 }, /* R7028 */ - { 0x0000, 0x0000, 0x0000 }, /* R7029 */ - { 0x0000, 0x0000, 0x0000 }, /* R7030 */ - { 0x0000, 0x0000, 0x0000 }, /* R7031 */ - { 0x0000, 0x0000, 0x0000 }, /* R7032 */ - { 0x0000, 0x0000, 0x0000 }, /* R7033 */ - { 0x0000, 0x0000, 0x0000 }, /* R7034 */ - { 0x0000, 0x0000, 0x0000 }, /* R7035 */ - { 0x0000, 0x0000, 0x0000 }, /* R7036 */ - { 0x0000, 0x0000, 0x0000 }, /* R7037 */ - { 0x0000, 0x0000, 0x0000 }, /* R7038 */ - { 0x0000, 0x0000, 0x0000 }, /* R7039 */ - { 0x0000, 0x0000, 0x0000 }, /* R7040 */ - { 0x0000, 0x0000, 0x0000 }, /* R7041 */ - { 0x0000, 0x0000, 0x0000 }, /* R7042 */ - { 0x0000, 0x0000, 0x0000 }, /* R7043 */ - { 0x0000, 0x0000, 0x0000 }, /* R7044 */ - { 0x0000, 0x0000, 0x0000 }, /* R7045 */ - { 0x0000, 0x0000, 0x0000 }, /* R7046 */ - { 0x0000, 0x0000, 0x0000 }, /* R7047 */ - { 0x0000, 0x0000, 0x0000 }, /* R7048 */ - { 0x0000, 0x0000, 0x0000 }, /* R7049 */ - { 0x0000, 0x0000, 0x0000 }, /* R7050 */ - { 0x0000, 0x0000, 0x0000 }, /* R7051 */ - { 0x0000, 0x0000, 0x0000 }, /* R7052 */ - { 0x0000, 0x0000, 0x0000 }, /* R7053 */ - { 0x0000, 0x0000, 0x0000 }, /* R7054 */ - { 0x0000, 0x0000, 0x0000 }, /* R7055 */ - { 0x0000, 0x0000, 0x0000 }, /* R7056 */ - { 0x0000, 0x0000, 0x0000 }, /* R7057 */ - { 0x0000, 0x0000, 0x0000 }, /* R7058 */ - { 0x0000, 0x0000, 0x0000 }, /* R7059 */ - { 0x0000, 0x0000, 0x0000 }, /* R7060 */ - { 0x0000, 0x0000, 0x0000 }, /* R7061 */ - { 0x0000, 0x0000, 0x0000 }, /* R7062 */ - { 0x0000, 0x0000, 0x0000 }, /* R7063 */ - { 0x0000, 0x0000, 0x0000 }, /* R7064 */ - { 0x0000, 0x0000, 0x0000 }, /* R7065 */ - { 0x0000, 0x0000, 0x0000 }, /* R7066 */ - { 0x0000, 0x0000, 0x0000 }, /* R7067 */ - { 0x0000, 0x0000, 0x0000 }, /* R7068 */ - { 0x0000, 0x0000, 0x0000 }, /* R7069 */ - { 0x0000, 0x0000, 0x0000 }, /* R7070 */ - { 0x0000, 0x0000, 0x0000 }, /* R7071 */ - { 0x0000, 0x0000, 0x0000 }, /* R7072 */ - { 0x0000, 0x0000, 0x0000 }, /* R7073 */ - { 0x0000, 0x0000, 0x0000 }, /* R7074 */ - { 0x0000, 0x0000, 0x0000 }, /* R7075 */ - { 0x0000, 0x0000, 0x0000 }, /* R7076 */ - { 0x0000, 0x0000, 0x0000 }, /* R7077 */ - { 0x0000, 0x0000, 0x0000 }, /* R7078 */ - { 0x0000, 0x0000, 0x0000 }, /* R7079 */ - { 0x0000, 0x0000, 0x0000 }, /* R7080 */ - { 0x0000, 0x0000, 0x0000 }, /* R7081 */ - { 0x0000, 0x0000, 0x0000 }, /* R7082 */ - { 0x0000, 0x0000, 0x0000 }, /* R7083 */ - { 0x0000, 0x0000, 0x0000 }, /* R7084 */ - { 0x0000, 0x0000, 0x0000 }, /* R7085 */ - { 0x0000, 0x0000, 0x0000 }, /* R7086 */ - { 0x0000, 0x0000, 0x0000 }, /* R7087 */ - { 0x0000, 0x0000, 0x0000 }, /* R7088 */ - { 0x0000, 0x0000, 0x0000 }, /* R7089 */ - { 0x0000, 0x0000, 0x0000 }, /* R7090 */ - { 0x0000, 0x0000, 0x0000 }, /* R7091 */ - { 0x0000, 0x0000, 0x0000 }, /* R7092 */ - { 0x0000, 0x0000, 0x0000 }, /* R7093 */ - { 0x0000, 0x0000, 0x0000 }, /* R7094 */ - { 0x0000, 0x0000, 0x0000 }, /* R7095 */ - { 0x0000, 0x0000, 0x0000 }, /* R7096 */ - { 0x0000, 0x0000, 0x0000 }, /* R7097 */ - { 0x0000, 0x0000, 0x0000 }, /* R7098 */ - { 0x0000, 0x0000, 0x0000 }, /* R7099 */ - { 0x0000, 0x0000, 0x0000 }, /* R7100 */ - { 0x0000, 0x0000, 0x0000 }, /* R7101 */ - { 0x0000, 0x0000, 0x0000 }, /* R7102 */ - { 0x0000, 0x0000, 0x0000 }, /* R7103 */ - { 0x0000, 0x0000, 0x0000 }, /* R7104 */ - { 0x0000, 0x0000, 0x0000 }, /* R7105 */ - { 0x0000, 0x0000, 0x0000 }, /* R7106 */ - { 0x0000, 0x0000, 0x0000 }, /* R7107 */ - { 0x0000, 0x0000, 0x0000 }, /* R7108 */ - { 0x0000, 0x0000, 0x0000 }, /* R7109 */ - { 0x0000, 0x0000, 0x0000 }, /* R7110 */ - { 0x0000, 0x0000, 0x0000 }, /* R7111 */ - { 0x0000, 0x0000, 0x0000 }, /* R7112 */ - { 0x0000, 0x0000, 0x0000 }, /* R7113 */ - { 0x0000, 0x0000, 0x0000 }, /* R7114 */ - { 0x0000, 0x0000, 0x0000 }, /* R7115 */ - { 0x0000, 0x0000, 0x0000 }, /* R7116 */ - { 0x0000, 0x0000, 0x0000 }, /* R7117 */ - { 0x0000, 0x0000, 0x0000 }, /* R7118 */ - { 0x0000, 0x0000, 0x0000 }, /* R7119 */ - { 0x0000, 0x0000, 0x0000 }, /* R7120 */ - { 0x0000, 0x0000, 0x0000 }, /* R7121 */ - { 0x0000, 0x0000, 0x0000 }, /* R7122 */ - { 0x0000, 0x0000, 0x0000 }, /* R7123 */ - { 0x0000, 0x0000, 0x0000 }, /* R7124 */ - { 0x0000, 0x0000, 0x0000 }, /* R7125 */ - { 0x0000, 0x0000, 0x0000 }, /* R7126 */ - { 0x0000, 0x0000, 0x0000 }, /* R7127 */ - { 0x0000, 0x0000, 0x0000 }, /* R7128 */ - { 0x0000, 0x0000, 0x0000 }, /* R7129 */ - { 0x0000, 0x0000, 0x0000 }, /* R7130 */ - { 0x0000, 0x0000, 0x0000 }, /* R7131 */ - { 0x0000, 0x0000, 0x0000 }, /* R7132 */ - { 0x0000, 0x0000, 0x0000 }, /* R7133 */ - { 0x0000, 0x0000, 0x0000 }, /* R7134 */ - { 0x0000, 0x0000, 0x0000 }, /* R7135 */ - { 0x0000, 0x0000, 0x0000 }, /* R7136 */ - { 0x0000, 0x0000, 0x0000 }, /* R7137 */ - { 0x0000, 0x0000, 0x0000 }, /* R7138 */ - { 0x0000, 0x0000, 0x0000 }, /* R7139 */ - { 0x0000, 0x0000, 0x0000 }, /* R7140 */ - { 0x0000, 0x0000, 0x0000 }, /* R7141 */ - { 0x0000, 0x0000, 0x0000 }, /* R7142 */ - { 0x0000, 0x0000, 0x0000 }, /* R7143 */ - { 0x0000, 0x0000, 0x0000 }, /* R7144 */ - { 0x0000, 0x0000, 0x0000 }, /* R7145 */ - { 0x0000, 0x0000, 0x0000 }, /* R7146 */ - { 0x0000, 0x0000, 0x0000 }, /* R7147 */ - { 0x0000, 0x0000, 0x0000 }, /* R7148 */ - { 0x0000, 0x0000, 0x0000 }, /* R7149 */ - { 0x0000, 0x0000, 0x0000 }, /* R7150 */ - { 0x0000, 0x0000, 0x0000 }, /* R7151 */ - { 0x0000, 0x0000, 0x0000 }, /* R7152 */ - { 0x0000, 0x0000, 0x0000 }, /* R7153 */ - { 0x0000, 0x0000, 0x0000 }, /* R7154 */ - { 0x0000, 0x0000, 0x0000 }, /* R7155 */ - { 0x0000, 0x0000, 0x0000 }, /* R7156 */ - { 0x0000, 0x0000, 0x0000 }, /* R7157 */ - { 0x0000, 0x0000, 0x0000 }, /* R7158 */ - { 0x0000, 0x0000, 0x0000 }, /* R7159 */ - { 0x0000, 0x0000, 0x0000 }, /* R7160 */ - { 0x0000, 0x0000, 0x0000 }, /* R7161 */ - { 0x0000, 0x0000, 0x0000 }, /* R7162 */ - { 0x0000, 0x0000, 0x0000 }, /* R7163 */ - { 0x0000, 0x0000, 0x0000 }, /* R7164 */ - { 0x0000, 0x0000, 0x0000 }, /* R7165 */ - { 0x0000, 0x0000, 0x0000 }, /* R7166 */ - { 0x0000, 0x0000, 0x0000 }, /* R7167 */ - { 0x0000, 0x0000, 0x0000 }, /* R7168 */ - { 0x0000, 0x0000, 0x0000 }, /* R7169 */ - { 0x0000, 0x0000, 0x0000 }, /* R7170 */ - { 0x0000, 0x0000, 0x0000 }, /* R7171 */ - { 0x0000, 0x0000, 0x0000 }, /* R7172 */ - { 0x0000, 0x0000, 0x0000 }, /* R7173 */ - { 0x0000, 0x0000, 0x0000 }, /* R7174 */ - { 0x0000, 0x0000, 0x0000 }, /* R7175 */ - { 0x0000, 0x0000, 0x0000 }, /* R7176 */ - { 0x0000, 0x0000, 0x0000 }, /* R7177 */ - { 0x0000, 0x0000, 0x0000 }, /* R7178 */ - { 0x0000, 0x0000, 0x0000 }, /* R7179 */ - { 0x0000, 0x0000, 0x0000 }, /* R7180 */ - { 0x0000, 0x0000, 0x0000 }, /* R7181 */ - { 0x0000, 0x0000, 0x0000 }, /* R7182 */ - { 0x0000, 0x0000, 0x0000 }, /* R7183 */ - { 0x0000, 0x0000, 0x0000 }, /* R7184 */ - { 0x0000, 0x0000, 0x0000 }, /* R7185 */ - { 0x0000, 0x0000, 0x0000 }, /* R7186 */ - { 0x0000, 0x0000, 0x0000 }, /* R7187 */ - { 0x0000, 0x0000, 0x0000 }, /* R7188 */ - { 0x0000, 0x0000, 0x0000 }, /* R7189 */ - { 0x0000, 0x0000, 0x0000 }, /* R7190 */ - { 0x0000, 0x0000, 0x0000 }, /* R7191 */ - { 0x0000, 0x0000, 0x0000 }, /* R7192 */ - { 0x0000, 0x0000, 0x0000 }, /* R7193 */ - { 0x0000, 0x0000, 0x0000 }, /* R7194 */ - { 0x0000, 0x0000, 0x0000 }, /* R7195 */ - { 0x0000, 0x0000, 0x0000 }, /* R7196 */ - { 0x0000, 0x0000, 0x0000 }, /* R7197 */ - { 0x0000, 0x0000, 0x0000 }, /* R7198 */ - { 0x0000, 0x0000, 0x0000 }, /* R7199 */ - { 0x0000, 0x0000, 0x0000 }, /* R7200 */ - { 0x0000, 0x0000, 0x0000 }, /* R7201 */ - { 0x0000, 0x0000, 0x0000 }, /* R7202 */ - { 0x0000, 0x0000, 0x0000 }, /* R7203 */ - { 0x0000, 0x0000, 0x0000 }, /* R7204 */ - { 0x0000, 0x0000, 0x0000 }, /* R7205 */ - { 0x0000, 0x0000, 0x0000 }, /* R7206 */ - { 0x0000, 0x0000, 0x0000 }, /* R7207 */ - { 0x0000, 0x0000, 0x0000 }, /* R7208 */ - { 0x0000, 0x0000, 0x0000 }, /* R7209 */ - { 0x0000, 0x0000, 0x0000 }, /* R7210 */ - { 0x0000, 0x0000, 0x0000 }, /* R7211 */ - { 0x0000, 0x0000, 0x0000 }, /* R7212 */ - { 0x0000, 0x0000, 0x0000 }, /* R7213 */ - { 0x0000, 0x0000, 0x0000 }, /* R7214 */ - { 0x0000, 0x0000, 0x0000 }, /* R7215 */ - { 0x0000, 0x0000, 0x0000 }, /* R7216 */ - { 0x0000, 0x0000, 0x0000 }, /* R7217 */ - { 0x0000, 0x0000, 0x0000 }, /* R7218 */ - { 0x0000, 0x0000, 0x0000 }, /* R7219 */ - { 0x0000, 0x0000, 0x0000 }, /* R7220 */ - { 0x0000, 0x0000, 0x0000 }, /* R7221 */ - { 0x0000, 0x0000, 0x0000 }, /* R7222 */ - { 0x0000, 0x0000, 0x0000 }, /* R7223 */ - { 0x0000, 0x0000, 0x0000 }, /* R7224 */ - { 0x0000, 0x0000, 0x0000 }, /* R7225 */ - { 0x0000, 0x0000, 0x0000 }, /* R7226 */ - { 0x0000, 0x0000, 0x0000 }, /* R7227 */ - { 0x0000, 0x0000, 0x0000 }, /* R7228 */ - { 0x0000, 0x0000, 0x0000 }, /* R7229 */ - { 0x0000, 0x0000, 0x0000 }, /* R7230 */ - { 0x0000, 0x0000, 0x0000 }, /* R7231 */ - { 0x0000, 0x0000, 0x0000 }, /* R7232 */ - { 0x0000, 0x0000, 0x0000 }, /* R7233 */ - { 0x0000, 0x0000, 0x0000 }, /* R7234 */ - { 0x0000, 0x0000, 0x0000 }, /* R7235 */ - { 0x0000, 0x0000, 0x0000 }, /* R7236 */ - { 0x0000, 0x0000, 0x0000 }, /* R7237 */ - { 0x0000, 0x0000, 0x0000 }, /* R7238 */ - { 0x0000, 0x0000, 0x0000 }, /* R7239 */ - { 0x0000, 0x0000, 0x0000 }, /* R7240 */ - { 0x0000, 0x0000, 0x0000 }, /* R7241 */ - { 0x0000, 0x0000, 0x0000 }, /* R7242 */ - { 0x0000, 0x0000, 0x0000 }, /* R7243 */ - { 0x0000, 0x0000, 0x0000 }, /* R7244 */ - { 0x0000, 0x0000, 0x0000 }, /* R7245 */ - { 0x0000, 0x0000, 0x0000 }, /* R7246 */ - { 0x0000, 0x0000, 0x0000 }, /* R7247 */ - { 0x0000, 0x0000, 0x0000 }, /* R7248 */ - { 0x0000, 0x0000, 0x0000 }, /* R7249 */ - { 0x0000, 0x0000, 0x0000 }, /* R7250 */ - { 0x0000, 0x0000, 0x0000 }, /* R7251 */ - { 0x0000, 0x0000, 0x0000 }, /* R7252 */ - { 0x0000, 0x0000, 0x0000 }, /* R7253 */ - { 0x0000, 0x0000, 0x0000 }, /* R7254 */ - { 0x0000, 0x0000, 0x0000 }, /* R7255 */ - { 0x0000, 0x0000, 0x0000 }, /* R7256 */ - { 0x0000, 0x0000, 0x0000 }, /* R7257 */ - { 0x0000, 0x0000, 0x0000 }, /* R7258 */ - { 0x0000, 0x0000, 0x0000 }, /* R7259 */ - { 0x0000, 0x0000, 0x0000 }, /* R7260 */ - { 0x0000, 0x0000, 0x0000 }, /* R7261 */ - { 0x0000, 0x0000, 0x0000 }, /* R7262 */ - { 0x0000, 0x0000, 0x0000 }, /* R7263 */ - { 0x0000, 0x0000, 0x0000 }, /* R7264 */ - { 0x0000, 0x0000, 0x0000 }, /* R7265 */ - { 0x0000, 0x0000, 0x0000 }, /* R7266 */ - { 0x0000, 0x0000, 0x0000 }, /* R7267 */ - { 0x0000, 0x0000, 0x0000 }, /* R7268 */ - { 0x0000, 0x0000, 0x0000 }, /* R7269 */ - { 0x0000, 0x0000, 0x0000 }, /* R7270 */ - { 0x0000, 0x0000, 0x0000 }, /* R7271 */ - { 0x0000, 0x0000, 0x0000 }, /* R7272 */ - { 0x0000, 0x0000, 0x0000 }, /* R7273 */ - { 0x0000, 0x0000, 0x0000 }, /* R7274 */ - { 0x0000, 0x0000, 0x0000 }, /* R7275 */ - { 0x0000, 0x0000, 0x0000 }, /* R7276 */ - { 0x0000, 0x0000, 0x0000 }, /* R7277 */ - { 0x0000, 0x0000, 0x0000 }, /* R7278 */ - { 0x0000, 0x0000, 0x0000 }, /* R7279 */ - { 0x0000, 0x0000, 0x0000 }, /* R7280 */ - { 0x0000, 0x0000, 0x0000 }, /* R7281 */ - { 0x0000, 0x0000, 0x0000 }, /* R7282 */ - { 0x0000, 0x0000, 0x0000 }, /* R7283 */ - { 0x0000, 0x0000, 0x0000 }, /* R7284 */ - { 0x0000, 0x0000, 0x0000 }, /* R7285 */ - { 0x0000, 0x0000, 0x0000 }, /* R7286 */ - { 0x0000, 0x0000, 0x0000 }, /* R7287 */ - { 0x0000, 0x0000, 0x0000 }, /* R7288 */ - { 0x0000, 0x0000, 0x0000 }, /* R7289 */ - { 0x0000, 0x0000, 0x0000 }, /* R7290 */ - { 0x0000, 0x0000, 0x0000 }, /* R7291 */ - { 0x0000, 0x0000, 0x0000 }, /* R7292 */ - { 0x0000, 0x0000, 0x0000 }, /* R7293 */ - { 0x0000, 0x0000, 0x0000 }, /* R7294 */ - { 0x0000, 0x0000, 0x0000 }, /* R7295 */ - { 0x0000, 0x0000, 0x0000 }, /* R7296 */ - { 0x0000, 0x0000, 0x0000 }, /* R7297 */ - { 0x0000, 0x0000, 0x0000 }, /* R7298 */ - { 0x0000, 0x0000, 0x0000 }, /* R7299 */ - { 0x0000, 0x0000, 0x0000 }, /* R7300 */ - { 0x0000, 0x0000, 0x0000 }, /* R7301 */ - { 0x0000, 0x0000, 0x0000 }, /* R7302 */ - { 0x0000, 0x0000, 0x0000 }, /* R7303 */ - { 0x0000, 0x0000, 0x0000 }, /* R7304 */ - { 0x0000, 0x0000, 0x0000 }, /* R7305 */ - { 0x0000, 0x0000, 0x0000 }, /* R7306 */ - { 0x0000, 0x0000, 0x0000 }, /* R7307 */ - { 0x0000, 0x0000, 0x0000 }, /* R7308 */ - { 0x0000, 0x0000, 0x0000 }, /* R7309 */ - { 0x0000, 0x0000, 0x0000 }, /* R7310 */ - { 0x0000, 0x0000, 0x0000 }, /* R7311 */ - { 0x0000, 0x0000, 0x0000 }, /* R7312 */ - { 0x0000, 0x0000, 0x0000 }, /* R7313 */ - { 0x0000, 0x0000, 0x0000 }, /* R7314 */ - { 0x0000, 0x0000, 0x0000 }, /* R7315 */ - { 0x0000, 0x0000, 0x0000 }, /* R7316 */ - { 0x0000, 0x0000, 0x0000 }, /* R7317 */ - { 0x0000, 0x0000, 0x0000 }, /* R7318 */ - { 0x0000, 0x0000, 0x0000 }, /* R7319 */ - { 0x0000, 0x0000, 0x0000 }, /* R7320 */ - { 0x0000, 0x0000, 0x0000 }, /* R7321 */ - { 0x0000, 0x0000, 0x0000 }, /* R7322 */ - { 0x0000, 0x0000, 0x0000 }, /* R7323 */ - { 0x0000, 0x0000, 0x0000 }, /* R7324 */ - { 0x0000, 0x0000, 0x0000 }, /* R7325 */ - { 0x0000, 0x0000, 0x0000 }, /* R7326 */ - { 0x0000, 0x0000, 0x0000 }, /* R7327 */ - { 0x0000, 0x0000, 0x0000 }, /* R7328 */ - { 0x0000, 0x0000, 0x0000 }, /* R7329 */ - { 0x0000, 0x0000, 0x0000 }, /* R7330 */ - { 0x0000, 0x0000, 0x0000 }, /* R7331 */ - { 0x0000, 0x0000, 0x0000 }, /* R7332 */ - { 0x0000, 0x0000, 0x0000 }, /* R7333 */ - { 0x0000, 0x0000, 0x0000 }, /* R7334 */ - { 0x0000, 0x0000, 0x0000 }, /* R7335 */ - { 0x0000, 0x0000, 0x0000 }, /* R7336 */ - { 0x0000, 0x0000, 0x0000 }, /* R7337 */ - { 0x0000, 0x0000, 0x0000 }, /* R7338 */ - { 0x0000, 0x0000, 0x0000 }, /* R7339 */ - { 0x0000, 0x0000, 0x0000 }, /* R7340 */ - { 0x0000, 0x0000, 0x0000 }, /* R7341 */ - { 0x0000, 0x0000, 0x0000 }, /* R7342 */ - { 0x0000, 0x0000, 0x0000 }, /* R7343 */ - { 0x0000, 0x0000, 0x0000 }, /* R7344 */ - { 0x0000, 0x0000, 0x0000 }, /* R7345 */ - { 0x0000, 0x0000, 0x0000 }, /* R7346 */ - { 0x0000, 0x0000, 0x0000 }, /* R7347 */ - { 0x0000, 0x0000, 0x0000 }, /* R7348 */ - { 0x0000, 0x0000, 0x0000 }, /* R7349 */ - { 0x0000, 0x0000, 0x0000 }, /* R7350 */ - { 0x0000, 0x0000, 0x0000 }, /* R7351 */ - { 0x0000, 0x0000, 0x0000 }, /* R7352 */ - { 0x0000, 0x0000, 0x0000 }, /* R7353 */ - { 0x0000, 0x0000, 0x0000 }, /* R7354 */ - { 0x0000, 0x0000, 0x0000 }, /* R7355 */ - { 0x0000, 0x0000, 0x0000 }, /* R7356 */ - { 0x0000, 0x0000, 0x0000 }, /* R7357 */ - { 0x0000, 0x0000, 0x0000 }, /* R7358 */ - { 0x0000, 0x0000, 0x0000 }, /* R7359 */ - { 0x0000, 0x0000, 0x0000 }, /* R7360 */ - { 0x0000, 0x0000, 0x0000 }, /* R7361 */ - { 0x0000, 0x0000, 0x0000 }, /* R7362 */ - { 0x0000, 0x0000, 0x0000 }, /* R7363 */ - { 0x0000, 0x0000, 0x0000 }, /* R7364 */ - { 0x0000, 0x0000, 0x0000 }, /* R7365 */ - { 0x0000, 0x0000, 0x0000 }, /* R7366 */ - { 0x0000, 0x0000, 0x0000 }, /* R7367 */ - { 0x0000, 0x0000, 0x0000 }, /* R7368 */ - { 0x0000, 0x0000, 0x0000 }, /* R7369 */ - { 0x0000, 0x0000, 0x0000 }, /* R7370 */ - { 0x0000, 0x0000, 0x0000 }, /* R7371 */ - { 0x0000, 0x0000, 0x0000 }, /* R7372 */ - { 0x0000, 0x0000, 0x0000 }, /* R7373 */ - { 0x0000, 0x0000, 0x0000 }, /* R7374 */ - { 0x0000, 0x0000, 0x0000 }, /* R7375 */ - { 0x0000, 0x0000, 0x0000 }, /* R7376 */ - { 0x0000, 0x0000, 0x0000 }, /* R7377 */ - { 0x0000, 0x0000, 0x0000 }, /* R7378 */ - { 0x0000, 0x0000, 0x0000 }, /* R7379 */ - { 0x0000, 0x0000, 0x0000 }, /* R7380 */ - { 0x0000, 0x0000, 0x0000 }, /* R7381 */ - { 0x0000, 0x0000, 0x0000 }, /* R7382 */ - { 0x0000, 0x0000, 0x0000 }, /* R7383 */ - { 0x0000, 0x0000, 0x0000 }, /* R7384 */ - { 0x0000, 0x0000, 0x0000 }, /* R7385 */ - { 0x0000, 0x0000, 0x0000 }, /* R7386 */ - { 0x0000, 0x0000, 0x0000 }, /* R7387 */ - { 0x0000, 0x0000, 0x0000 }, /* R7388 */ - { 0x0000, 0x0000, 0x0000 }, /* R7389 */ - { 0x0000, 0x0000, 0x0000 }, /* R7390 */ - { 0x0000, 0x0000, 0x0000 }, /* R7391 */ - { 0x0000, 0x0000, 0x0000 }, /* R7392 */ - { 0x0000, 0x0000, 0x0000 }, /* R7393 */ - { 0x0000, 0x0000, 0x0000 }, /* R7394 */ - { 0x0000, 0x0000, 0x0000 }, /* R7395 */ - { 0x0000, 0x0000, 0x0000 }, /* R7396 */ - { 0x0000, 0x0000, 0x0000 }, /* R7397 */ - { 0x0000, 0x0000, 0x0000 }, /* R7398 */ - { 0x0000, 0x0000, 0x0000 }, /* R7399 */ - { 0x0000, 0x0000, 0x0000 }, /* R7400 */ - { 0x0000, 0x0000, 0x0000 }, /* R7401 */ - { 0x0000, 0x0000, 0x0000 }, /* R7402 */ - { 0x0000, 0x0000, 0x0000 }, /* R7403 */ - { 0x0000, 0x0000, 0x0000 }, /* R7404 */ - { 0x0000, 0x0000, 0x0000 }, /* R7405 */ - { 0x0000, 0x0000, 0x0000 }, /* R7406 */ - { 0x0000, 0x0000, 0x0000 }, /* R7407 */ - { 0x0000, 0x0000, 0x0000 }, /* R7408 */ - { 0x0000, 0x0000, 0x0000 }, /* R7409 */ - { 0x0000, 0x0000, 0x0000 }, /* R7410 */ - { 0x0000, 0x0000, 0x0000 }, /* R7411 */ - { 0x0000, 0x0000, 0x0000 }, /* R7412 */ - { 0x0000, 0x0000, 0x0000 }, /* R7413 */ - { 0x0000, 0x0000, 0x0000 }, /* R7414 */ - { 0x0000, 0x0000, 0x0000 }, /* R7415 */ - { 0x0000, 0x0000, 0x0000 }, /* R7416 */ - { 0x0000, 0x0000, 0x0000 }, /* R7417 */ - { 0x0000, 0x0000, 0x0000 }, /* R7418 */ - { 0x0000, 0x0000, 0x0000 }, /* R7419 */ - { 0x0000, 0x0000, 0x0000 }, /* R7420 */ - { 0x0000, 0x0000, 0x0000 }, /* R7421 */ - { 0x0000, 0x0000, 0x0000 }, /* R7422 */ - { 0x0000, 0x0000, 0x0000 }, /* R7423 */ - { 0x0000, 0x0000, 0x0000 }, /* R7424 */ - { 0x0000, 0x0000, 0x0000 }, /* R7425 */ - { 0x0000, 0x0000, 0x0000 }, /* R7426 */ - { 0x0000, 0x0000, 0x0000 }, /* R7427 */ - { 0x0000, 0x0000, 0x0000 }, /* R7428 */ - { 0x0000, 0x0000, 0x0000 }, /* R7429 */ - { 0x0000, 0x0000, 0x0000 }, /* R7430 */ - { 0x0000, 0x0000, 0x0000 }, /* R7431 */ - { 0x0000, 0x0000, 0x0000 }, /* R7432 */ - { 0x0000, 0x0000, 0x0000 }, /* R7433 */ - { 0x0000, 0x0000, 0x0000 }, /* R7434 */ - { 0x0000, 0x0000, 0x0000 }, /* R7435 */ - { 0x0000, 0x0000, 0x0000 }, /* R7436 */ - { 0x0000, 0x0000, 0x0000 }, /* R7437 */ - { 0x0000, 0x0000, 0x0000 }, /* R7438 */ - { 0x0000, 0x0000, 0x0000 }, /* R7439 */ - { 0x0000, 0x0000, 0x0000 }, /* R7440 */ - { 0x0000, 0x0000, 0x0000 }, /* R7441 */ - { 0x0000, 0x0000, 0x0000 }, /* R7442 */ - { 0x0000, 0x0000, 0x0000 }, /* R7443 */ - { 0x0000, 0x0000, 0x0000 }, /* R7444 */ - { 0x0000, 0x0000, 0x0000 }, /* R7445 */ - { 0x0000, 0x0000, 0x0000 }, /* R7446 */ - { 0x0000, 0x0000, 0x0000 }, /* R7447 */ - { 0x0000, 0x0000, 0x0000 }, /* R7448 */ - { 0x0000, 0x0000, 0x0000 }, /* R7449 */ - { 0x0000, 0x0000, 0x0000 }, /* R7450 */ - { 0x0000, 0x0000, 0x0000 }, /* R7451 */ - { 0x0000, 0x0000, 0x0000 }, /* R7452 */ - { 0x0000, 0x0000, 0x0000 }, /* R7453 */ - { 0x0000, 0x0000, 0x0000 }, /* R7454 */ - { 0x0000, 0x0000, 0x0000 }, /* R7455 */ - { 0x0000, 0x0000, 0x0000 }, /* R7456 */ - { 0x0000, 0x0000, 0x0000 }, /* R7457 */ - { 0x0000, 0x0000, 0x0000 }, /* R7458 */ - { 0x0000, 0x0000, 0x0000 }, /* R7459 */ - { 0x0000, 0x0000, 0x0000 }, /* R7460 */ - { 0x0000, 0x0000, 0x0000 }, /* R7461 */ - { 0x0000, 0x0000, 0x0000 }, /* R7462 */ - { 0x0000, 0x0000, 0x0000 }, /* R7463 */ - { 0x0000, 0x0000, 0x0000 }, /* R7464 */ - { 0x0000, 0x0000, 0x0000 }, /* R7465 */ - { 0x0000, 0x0000, 0x0000 }, /* R7466 */ - { 0x0000, 0x0000, 0x0000 }, /* R7467 */ - { 0x0000, 0x0000, 0x0000 }, /* R7468 */ - { 0x0000, 0x0000, 0x0000 }, /* R7469 */ - { 0x0000, 0x0000, 0x0000 }, /* R7470 */ - { 0x0000, 0x0000, 0x0000 }, /* R7471 */ - { 0x0000, 0x0000, 0x0000 }, /* R7472 */ - { 0x0000, 0x0000, 0x0000 }, /* R7473 */ - { 0x0000, 0x0000, 0x0000 }, /* R7474 */ - { 0x0000, 0x0000, 0x0000 }, /* R7475 */ - { 0x0000, 0x0000, 0x0000 }, /* R7476 */ - { 0x0000, 0x0000, 0x0000 }, /* R7477 */ - { 0x0000, 0x0000, 0x0000 }, /* R7478 */ - { 0x0000, 0x0000, 0x0000 }, /* R7479 */ - { 0x0000, 0x0000, 0x0000 }, /* R7480 */ - { 0x0000, 0x0000, 0x0000 }, /* R7481 */ - { 0x0000, 0x0000, 0x0000 }, /* R7482 */ - { 0x0000, 0x0000, 0x0000 }, /* R7483 */ - { 0x0000, 0x0000, 0x0000 }, /* R7484 */ - { 0x0000, 0x0000, 0x0000 }, /* R7485 */ - { 0x0000, 0x0000, 0x0000 }, /* R7486 */ - { 0x0000, 0x0000, 0x0000 }, /* R7487 */ - { 0x0000, 0x0000, 0x0000 }, /* R7488 */ - { 0x0000, 0x0000, 0x0000 }, /* R7489 */ - { 0x0000, 0x0000, 0x0000 }, /* R7490 */ - { 0x0000, 0x0000, 0x0000 }, /* R7491 */ - { 0x0000, 0x0000, 0x0000 }, /* R7492 */ - { 0x0000, 0x0000, 0x0000 }, /* R7493 */ - { 0x0000, 0x0000, 0x0000 }, /* R7494 */ - { 0x0000, 0x0000, 0x0000 }, /* R7495 */ - { 0x0000, 0x0000, 0x0000 }, /* R7496 */ - { 0x0000, 0x0000, 0x0000 }, /* R7497 */ - { 0x0000, 0x0000, 0x0000 }, /* R7498 */ - { 0x0000, 0x0000, 0x0000 }, /* R7499 */ - { 0x0000, 0x0000, 0x0000 }, /* R7500 */ - { 0x0000, 0x0000, 0x0000 }, /* R7501 */ - { 0x0000, 0x0000, 0x0000 }, /* R7502 */ - { 0x0000, 0x0000, 0x0000 }, /* R7503 */ - { 0x0000, 0x0000, 0x0000 }, /* R7504 */ - { 0x0000, 0x0000, 0x0000 }, /* R7505 */ - { 0x0000, 0x0000, 0x0000 }, /* R7506 */ - { 0x0000, 0x0000, 0x0000 }, /* R7507 */ - { 0x0000, 0x0000, 0x0000 }, /* R7508 */ - { 0x0000, 0x0000, 0x0000 }, /* R7509 */ - { 0x0000, 0x0000, 0x0000 }, /* R7510 */ - { 0x0000, 0x0000, 0x0000 }, /* R7511 */ - { 0x0000, 0x0000, 0x0000 }, /* R7512 */ - { 0x0000, 0x0000, 0x0000 }, /* R7513 */ - { 0x0000, 0x0000, 0x0000 }, /* R7514 */ - { 0x0000, 0x0000, 0x0000 }, /* R7515 */ - { 0x0000, 0x0000, 0x0000 }, /* R7516 */ - { 0x0000, 0x0000, 0x0000 }, /* R7517 */ - { 0x0000, 0x0000, 0x0000 }, /* R7518 */ - { 0x0000, 0x0000, 0x0000 }, /* R7519 */ - { 0x0000, 0x0000, 0x0000 }, /* R7520 */ - { 0x0000, 0x0000, 0x0000 }, /* R7521 */ - { 0x0000, 0x0000, 0x0000 }, /* R7522 */ - { 0x0000, 0x0000, 0x0000 }, /* R7523 */ - { 0x0000, 0x0000, 0x0000 }, /* R7524 */ - { 0x0000, 0x0000, 0x0000 }, /* R7525 */ - { 0x0000, 0x0000, 0x0000 }, /* R7526 */ - { 0x0000, 0x0000, 0x0000 }, /* R7527 */ - { 0x0000, 0x0000, 0x0000 }, /* R7528 */ - { 0x0000, 0x0000, 0x0000 }, /* R7529 */ - { 0x0000, 0x0000, 0x0000 }, /* R7530 */ - { 0x0000, 0x0000, 0x0000 }, /* R7531 */ - { 0x0000, 0x0000, 0x0000 }, /* R7532 */ - { 0x0000, 0x0000, 0x0000 }, /* R7533 */ - { 0x0000, 0x0000, 0x0000 }, /* R7534 */ - { 0x0000, 0x0000, 0x0000 }, /* R7535 */ - { 0x0000, 0x0000, 0x0000 }, /* R7536 */ - { 0x0000, 0x0000, 0x0000 }, /* R7537 */ - { 0x0000, 0x0000, 0x0000 }, /* R7538 */ - { 0x0000, 0x0000, 0x0000 }, /* R7539 */ - { 0x0000, 0x0000, 0x0000 }, /* R7540 */ - { 0x0000, 0x0000, 0x0000 }, /* R7541 */ - { 0x0000, 0x0000, 0x0000 }, /* R7542 */ - { 0x0000, 0x0000, 0x0000 }, /* R7543 */ - { 0x0000, 0x0000, 0x0000 }, /* R7544 */ - { 0x0000, 0x0000, 0x0000 }, /* R7545 */ - { 0x0000, 0x0000, 0x0000 }, /* R7546 */ - { 0x0000, 0x0000, 0x0000 }, /* R7547 */ - { 0x0000, 0x0000, 0x0000 }, /* R7548 */ - { 0x0000, 0x0000, 0x0000 }, /* R7549 */ - { 0x0000, 0x0000, 0x0000 }, /* R7550 */ - { 0x0000, 0x0000, 0x0000 }, /* R7551 */ - { 0x0000, 0x0000, 0x0000 }, /* R7552 */ - { 0x0000, 0x0000, 0x0000 }, /* R7553 */ - { 0x0000, 0x0000, 0x0000 }, /* R7554 */ - { 0x0000, 0x0000, 0x0000 }, /* R7555 */ - { 0x0000, 0x0000, 0x0000 }, /* R7556 */ - { 0x0000, 0x0000, 0x0000 }, /* R7557 */ - { 0x0000, 0x0000, 0x0000 }, /* R7558 */ - { 0x0000, 0x0000, 0x0000 }, /* R7559 */ - { 0x0000, 0x0000, 0x0000 }, /* R7560 */ - { 0x0000, 0x0000, 0x0000 }, /* R7561 */ - { 0x0000, 0x0000, 0x0000 }, /* R7562 */ - { 0x0000, 0x0000, 0x0000 }, /* R7563 */ - { 0x0000, 0x0000, 0x0000 }, /* R7564 */ - { 0x0000, 0x0000, 0x0000 }, /* R7565 */ - { 0x0000, 0x0000, 0x0000 }, /* R7566 */ - { 0x0000, 0x0000, 0x0000 }, /* R7567 */ - { 0x0000, 0x0000, 0x0000 }, /* R7568 */ - { 0x0000, 0x0000, 0x0000 }, /* R7569 */ - { 0x0000, 0x0000, 0x0000 }, /* R7570 */ - { 0x0000, 0x0000, 0x0000 }, /* R7571 */ - { 0x0000, 0x0000, 0x0000 }, /* R7572 */ - { 0x0000, 0x0000, 0x0000 }, /* R7573 */ - { 0x0000, 0x0000, 0x0000 }, /* R7574 */ - { 0x0000, 0x0000, 0x0000 }, /* R7575 */ - { 0x0000, 0x0000, 0x0000 }, /* R7576 */ - { 0x0000, 0x0000, 0x0000 }, /* R7577 */ - { 0x0000, 0x0000, 0x0000 }, /* R7578 */ - { 0x0000, 0x0000, 0x0000 }, /* R7579 */ - { 0x0000, 0x0000, 0x0000 }, /* R7580 */ - { 0x0000, 0x0000, 0x0000 }, /* R7581 */ - { 0x0000, 0x0000, 0x0000 }, /* R7582 */ - { 0x0000, 0x0000, 0x0000 }, /* R7583 */ - { 0x0000, 0x0000, 0x0000 }, /* R7584 */ - { 0x0000, 0x0000, 0x0000 }, /* R7585 */ - { 0x0000, 0x0000, 0x0000 }, /* R7586 */ - { 0x0000, 0x0000, 0x0000 }, /* R7587 */ - { 0x0000, 0x0000, 0x0000 }, /* R7588 */ - { 0x0000, 0x0000, 0x0000 }, /* R7589 */ - { 0x0000, 0x0000, 0x0000 }, /* R7590 */ - { 0x0000, 0x0000, 0x0000 }, /* R7591 */ - { 0x0000, 0x0000, 0x0000 }, /* R7592 */ - { 0x0000, 0x0000, 0x0000 }, /* R7593 */ - { 0x0000, 0x0000, 0x0000 }, /* R7594 */ - { 0x0000, 0x0000, 0x0000 }, /* R7595 */ - { 0x0000, 0x0000, 0x0000 }, /* R7596 */ - { 0x0000, 0x0000, 0x0000 }, /* R7597 */ - { 0x0000, 0x0000, 0x0000 }, /* R7598 */ - { 0x0000, 0x0000, 0x0000 }, /* R7599 */ - { 0x0000, 0x0000, 0x0000 }, /* R7600 */ - { 0x0000, 0x0000, 0x0000 }, /* R7601 */ - { 0x0000, 0x0000, 0x0000 }, /* R7602 */ - { 0x0000, 0x0000, 0x0000 }, /* R7603 */ - { 0x0000, 0x0000, 0x0000 }, /* R7604 */ - { 0x0000, 0x0000, 0x0000 }, /* R7605 */ - { 0x0000, 0x0000, 0x0000 }, /* R7606 */ - { 0x0000, 0x0000, 0x0000 }, /* R7607 */ - { 0x0000, 0x0000, 0x0000 }, /* R7608 */ - { 0x0000, 0x0000, 0x0000 }, /* R7609 */ - { 0x0000, 0x0000, 0x0000 }, /* R7610 */ - { 0x0000, 0x0000, 0x0000 }, /* R7611 */ - { 0x0000, 0x0000, 0x0000 }, /* R7612 */ - { 0x0000, 0x0000, 0x0000 }, /* R7613 */ - { 0x0000, 0x0000, 0x0000 }, /* R7614 */ - { 0x0000, 0x0000, 0x0000 }, /* R7615 */ - { 0x0000, 0x0000, 0x0000 }, /* R7616 */ - { 0x0000, 0x0000, 0x0000 }, /* R7617 */ - { 0x0000, 0x0000, 0x0000 }, /* R7618 */ - { 0x0000, 0x0000, 0x0000 }, /* R7619 */ - { 0x0000, 0x0000, 0x0000 }, /* R7620 */ - { 0x0000, 0x0000, 0x0000 }, /* R7621 */ - { 0x0000, 0x0000, 0x0000 }, /* R7622 */ - { 0x0000, 0x0000, 0x0000 }, /* R7623 */ - { 0x0000, 0x0000, 0x0000 }, /* R7624 */ - { 0x0000, 0x0000, 0x0000 }, /* R7625 */ - { 0x0000, 0x0000, 0x0000 }, /* R7626 */ - { 0x0000, 0x0000, 0x0000 }, /* R7627 */ - { 0x0000, 0x0000, 0x0000 }, /* R7628 */ - { 0x0000, 0x0000, 0x0000 }, /* R7629 */ - { 0x0000, 0x0000, 0x0000 }, /* R7630 */ - { 0x0000, 0x0000, 0x0000 }, /* R7631 */ - { 0x0000, 0x0000, 0x0000 }, /* R7632 */ - { 0x0000, 0x0000, 0x0000 }, /* R7633 */ - { 0x0000, 0x0000, 0x0000 }, /* R7634 */ - { 0x0000, 0x0000, 0x0000 }, /* R7635 */ - { 0x0000, 0x0000, 0x0000 }, /* R7636 */ - { 0x0000, 0x0000, 0x0000 }, /* R7637 */ - { 0x0000, 0x0000, 0x0000 }, /* R7638 */ - { 0x0000, 0x0000, 0x0000 }, /* R7639 */ - { 0x0000, 0x0000, 0x0000 }, /* R7640 */ - { 0x0000, 0x0000, 0x0000 }, /* R7641 */ - { 0x0000, 0x0000, 0x0000 }, /* R7642 */ - { 0x0000, 0x0000, 0x0000 }, /* R7643 */ - { 0x0000, 0x0000, 0x0000 }, /* R7644 */ - { 0x0000, 0x0000, 0x0000 }, /* R7645 */ - { 0x0000, 0x0000, 0x0000 }, /* R7646 */ - { 0x0000, 0x0000, 0x0000 }, /* R7647 */ - { 0x0000, 0x0000, 0x0000 }, /* R7648 */ - { 0x0000, 0x0000, 0x0000 }, /* R7649 */ - { 0x0000, 0x0000, 0x0000 }, /* R7650 */ - { 0x0000, 0x0000, 0x0000 }, /* R7651 */ - { 0x0000, 0x0000, 0x0000 }, /* R7652 */ - { 0x0000, 0x0000, 0x0000 }, /* R7653 */ - { 0x0000, 0x0000, 0x0000 }, /* R7654 */ - { 0x0000, 0x0000, 0x0000 }, /* R7655 */ - { 0x0000, 0x0000, 0x0000 }, /* R7656 */ - { 0x0000, 0x0000, 0x0000 }, /* R7657 */ - { 0x0000, 0x0000, 0x0000 }, /* R7658 */ - { 0x0000, 0x0000, 0x0000 }, /* R7659 */ - { 0x0000, 0x0000, 0x0000 }, /* R7660 */ - { 0x0000, 0x0000, 0x0000 }, /* R7661 */ - { 0x0000, 0x0000, 0x0000 }, /* R7662 */ - { 0x0000, 0x0000, 0x0000 }, /* R7663 */ - { 0x0000, 0x0000, 0x0000 }, /* R7664 */ - { 0x0000, 0x0000, 0x0000 }, /* R7665 */ - { 0x0000, 0x0000, 0x0000 }, /* R7666 */ - { 0x0000, 0x0000, 0x0000 }, /* R7667 */ - { 0x0000, 0x0000, 0x0000 }, /* R7668 */ - { 0x0000, 0x0000, 0x0000 }, /* R7669 */ - { 0x0000, 0x0000, 0x0000 }, /* R7670 */ - { 0x0000, 0x0000, 0x0000 }, /* R7671 */ - { 0x0000, 0x0000, 0x0000 }, /* R7672 */ - { 0x0000, 0x0000, 0x0000 }, /* R7673 */ - { 0x0000, 0x0000, 0x0000 }, /* R7674 */ - { 0x0000, 0x0000, 0x0000 }, /* R7675 */ - { 0x0000, 0x0000, 0x0000 }, /* R7676 */ - { 0x0000, 0x0000, 0x0000 }, /* R7677 */ - { 0x0000, 0x0000, 0x0000 }, /* R7678 */ - { 0x0000, 0x0000, 0x0000 }, /* R7679 */ - { 0x0000, 0x0000, 0x0000 }, /* R7680 */ - { 0x0000, 0x0000, 0x0000 }, /* R7681 */ - { 0x0000, 0x0000, 0x0000 }, /* R7682 */ - { 0x0000, 0x0000, 0x0000 }, /* R7683 */ - { 0x0000, 0x0000, 0x0000 }, /* R7684 */ - { 0x0000, 0x0000, 0x0000 }, /* R7685 */ - { 0x0000, 0x0000, 0x0000 }, /* R7686 */ - { 0x0000, 0x0000, 0x0000 }, /* R7687 */ - { 0x0000, 0x0000, 0x0000 }, /* R7688 */ - { 0x0000, 0x0000, 0x0000 }, /* R7689 */ - { 0x0000, 0x0000, 0x0000 }, /* R7690 */ - { 0x0000, 0x0000, 0x0000 }, /* R7691 */ - { 0x0000, 0x0000, 0x0000 }, /* R7692 */ - { 0x0000, 0x0000, 0x0000 }, /* R7693 */ - { 0x0000, 0x0000, 0x0000 }, /* R7694 */ - { 0x0000, 0x0000, 0x0000 }, /* R7695 */ - { 0x0000, 0x0000, 0x0000 }, /* R7696 */ - { 0x0000, 0x0000, 0x0000 }, /* R7697 */ - { 0x0000, 0x0000, 0x0000 }, /* R7698 */ - { 0x0000, 0x0000, 0x0000 }, /* R7699 */ - { 0x0000, 0x0000, 0x0000 }, /* R7700 */ - { 0x0000, 0x0000, 0x0000 }, /* R7701 */ - { 0x0000, 0x0000, 0x0000 }, /* R7702 */ - { 0x0000, 0x0000, 0x0000 }, /* R7703 */ - { 0x0000, 0x0000, 0x0000 }, /* R7704 */ - { 0x0000, 0x0000, 0x0000 }, /* R7705 */ - { 0x0000, 0x0000, 0x0000 }, /* R7706 */ - { 0x0000, 0x0000, 0x0000 }, /* R7707 */ - { 0x0000, 0x0000, 0x0000 }, /* R7708 */ - { 0x0000, 0x0000, 0x0000 }, /* R7709 */ - { 0x0000, 0x0000, 0x0000 }, /* R7710 */ - { 0x0000, 0x0000, 0x0000 }, /* R7711 */ - { 0x0000, 0x0000, 0x0000 }, /* R7712 */ - { 0x0000, 0x0000, 0x0000 }, /* R7713 */ - { 0x0000, 0x0000, 0x0000 }, /* R7714 */ - { 0x0000, 0x0000, 0x0000 }, /* R7715 */ - { 0x0000, 0x0000, 0x0000 }, /* R7716 */ - { 0x0000, 0x0000, 0x0000 }, /* R7717 */ - { 0x0000, 0x0000, 0x0000 }, /* R7718 */ - { 0x0000, 0x0000, 0x0000 }, /* R7719 */ - { 0x0000, 0x0000, 0x0000 }, /* R7720 */ - { 0x0000, 0x0000, 0x0000 }, /* R7721 */ - { 0x0000, 0x0000, 0x0000 }, /* R7722 */ - { 0x0000, 0x0000, 0x0000 }, /* R7723 */ - { 0x0000, 0x0000, 0x0000 }, /* R7724 */ - { 0x0000, 0x0000, 0x0000 }, /* R7725 */ - { 0x0000, 0x0000, 0x0000 }, /* R7726 */ - { 0x0000, 0x0000, 0x0000 }, /* R7727 */ - { 0x0000, 0x0000, 0x0000 }, /* R7728 */ - { 0x0000, 0x0000, 0x0000 }, /* R7729 */ - { 0x0000, 0x0000, 0x0000 }, /* R7730 */ - { 0x0000, 0x0000, 0x0000 }, /* R7731 */ - { 0x0000, 0x0000, 0x0000 }, /* R7732 */ - { 0x0000, 0x0000, 0x0000 }, /* R7733 */ - { 0x0000, 0x0000, 0x0000 }, /* R7734 */ - { 0x0000, 0x0000, 0x0000 }, /* R7735 */ - { 0x0000, 0x0000, 0x0000 }, /* R7736 */ - { 0x0000, 0x0000, 0x0000 }, /* R7737 */ - { 0x0000, 0x0000, 0x0000 }, /* R7738 */ - { 0x0000, 0x0000, 0x0000 }, /* R7739 */ - { 0x0000, 0x0000, 0x0000 }, /* R7740 */ - { 0x0000, 0x0000, 0x0000 }, /* R7741 */ - { 0x0000, 0x0000, 0x0000 }, /* R7742 */ - { 0x0000, 0x0000, 0x0000 }, /* R7743 */ - { 0x0000, 0x0000, 0x0000 }, /* R7744 */ - { 0x0000, 0x0000, 0x0000 }, /* R7745 */ - { 0x0000, 0x0000, 0x0000 }, /* R7746 */ - { 0x0000, 0x0000, 0x0000 }, /* R7747 */ - { 0x0000, 0x0000, 0x0000 }, /* R7748 */ - { 0x0000, 0x0000, 0x0000 }, /* R7749 */ - { 0x0000, 0x0000, 0x0000 }, /* R7750 */ - { 0x0000, 0x0000, 0x0000 }, /* R7751 */ - { 0x0000, 0x0000, 0x0000 }, /* R7752 */ - { 0x0000, 0x0000, 0x0000 }, /* R7753 */ - { 0x0000, 0x0000, 0x0000 }, /* R7754 */ - { 0x0000, 0x0000, 0x0000 }, /* R7755 */ - { 0x0000, 0x0000, 0x0000 }, /* R7756 */ - { 0x0000, 0x0000, 0x0000 }, /* R7757 */ - { 0x0000, 0x0000, 0x0000 }, /* R7758 */ - { 0x0000, 0x0000, 0x0000 }, /* R7759 */ - { 0x0000, 0x0000, 0x0000 }, /* R7760 */ - { 0x0000, 0x0000, 0x0000 }, /* R7761 */ - { 0x0000, 0x0000, 0x0000 }, /* R7762 */ - { 0x0000, 0x0000, 0x0000 }, /* R7763 */ - { 0x0000, 0x0000, 0x0000 }, /* R7764 */ - { 0x0000, 0x0000, 0x0000 }, /* R7765 */ - { 0x0000, 0x0000, 0x0000 }, /* R7766 */ - { 0x0000, 0x0000, 0x0000 }, /* R7767 */ - { 0x0000, 0x0000, 0x0000 }, /* R7768 */ - { 0x0000, 0x0000, 0x0000 }, /* R7769 */ - { 0x0000, 0x0000, 0x0000 }, /* R7770 */ - { 0x0000, 0x0000, 0x0000 }, /* R7771 */ - { 0x0000, 0x0000, 0x0000 }, /* R7772 */ - { 0x0000, 0x0000, 0x0000 }, /* R7773 */ - { 0x0000, 0x0000, 0x0000 }, /* R7774 */ - { 0x0000, 0x0000, 0x0000 }, /* R7775 */ - { 0x0000, 0x0000, 0x0000 }, /* R7776 */ - { 0x0000, 0x0000, 0x0000 }, /* R7777 */ - { 0x0000, 0x0000, 0x0000 }, /* R7778 */ - { 0x0000, 0x0000, 0x0000 }, /* R7779 */ - { 0x0000, 0x0000, 0x0000 }, /* R7780 */ - { 0x0000, 0x0000, 0x0000 }, /* R7781 */ - { 0x0000, 0x0000, 0x0000 }, /* R7782 */ - { 0x0000, 0x0000, 0x0000 }, /* R7783 */ - { 0x0000, 0x0000, 0x0000 }, /* R7784 */ - { 0x0000, 0x0000, 0x0000 }, /* R7785 */ - { 0x0000, 0x0000, 0x0000 }, /* R7786 */ - { 0x0000, 0x0000, 0x0000 }, /* R7787 */ - { 0x0000, 0x0000, 0x0000 }, /* R7788 */ - { 0x0000, 0x0000, 0x0000 }, /* R7789 */ - { 0x0000, 0x0000, 0x0000 }, /* R7790 */ - { 0x0000, 0x0000, 0x0000 }, /* R7791 */ - { 0x0000, 0x0000, 0x0000 }, /* R7792 */ - { 0x0000, 0x0000, 0x0000 }, /* R7793 */ - { 0x0000, 0x0000, 0x0000 }, /* R7794 */ - { 0x0000, 0x0000, 0x0000 }, /* R7795 */ - { 0x0000, 0x0000, 0x0000 }, /* R7796 */ - { 0x0000, 0x0000, 0x0000 }, /* R7797 */ - { 0x0000, 0x0000, 0x0000 }, /* R7798 */ - { 0x0000, 0x0000, 0x0000 }, /* R7799 */ - { 0x0000, 0x0000, 0x0000 }, /* R7800 */ - { 0x0000, 0x0000, 0x0000 }, /* R7801 */ - { 0x0000, 0x0000, 0x0000 }, /* R7802 */ - { 0x0000, 0x0000, 0x0000 }, /* R7803 */ - { 0x0000, 0x0000, 0x0000 }, /* R7804 */ - { 0x0000, 0x0000, 0x0000 }, /* R7805 */ - { 0x0000, 0x0000, 0x0000 }, /* R7806 */ - { 0x0000, 0x0000, 0x0000 }, /* R7807 */ - { 0x0000, 0x0000, 0x0000 }, /* R7808 */ - { 0x0000, 0x0000, 0x0000 }, /* R7809 */ - { 0x0000, 0x0000, 0x0000 }, /* R7810 */ - { 0x0000, 0x0000, 0x0000 }, /* R7811 */ - { 0x0000, 0x0000, 0x0000 }, /* R7812 */ - { 0x0000, 0x0000, 0x0000 }, /* R7813 */ - { 0x0000, 0x0000, 0x0000 }, /* R7814 */ - { 0x0000, 0x0000, 0x0000 }, /* R7815 */ - { 0x0000, 0x0000, 0x0000 }, /* R7816 */ - { 0x0000, 0x0000, 0x0000 }, /* R7817 */ - { 0x0000, 0x0000, 0x0000 }, /* R7818 */ - { 0x0000, 0x0000, 0x0000 }, /* R7819 */ - { 0x0000, 0x0000, 0x0000 }, /* R7820 */ - { 0x0000, 0x0000, 0x0000 }, /* R7821 */ - { 0x0000, 0x0000, 0x0000 }, /* R7822 */ - { 0x0000, 0x0000, 0x0000 }, /* R7823 */ - { 0x0000, 0x0000, 0x0000 }, /* R7824 */ - { 0x0000, 0x0000, 0x0000 }, /* R7825 */ - { 0x0000, 0x0000, 0x0000 }, /* R7826 */ - { 0x0000, 0x0000, 0x0000 }, /* R7827 */ - { 0x0000, 0x0000, 0x0000 }, /* R7828 */ - { 0x0000, 0x0000, 0x0000 }, /* R7829 */ - { 0x0000, 0x0000, 0x0000 }, /* R7830 */ - { 0x0000, 0x0000, 0x0000 }, /* R7831 */ - { 0x0000, 0x0000, 0x0000 }, /* R7832 */ - { 0x0000, 0x0000, 0x0000 }, /* R7833 */ - { 0x0000, 0x0000, 0x0000 }, /* R7834 */ - { 0x0000, 0x0000, 0x0000 }, /* R7835 */ - { 0x0000, 0x0000, 0x0000 }, /* R7836 */ - { 0x0000, 0x0000, 0x0000 }, /* R7837 */ - { 0x0000, 0x0000, 0x0000 }, /* R7838 */ - { 0x0000, 0x0000, 0x0000 }, /* R7839 */ - { 0x0000, 0x0000, 0x0000 }, /* R7840 */ - { 0x0000, 0x0000, 0x0000 }, /* R7841 */ - { 0x0000, 0x0000, 0x0000 }, /* R7842 */ - { 0x0000, 0x0000, 0x0000 }, /* R7843 */ - { 0x0000, 0x0000, 0x0000 }, /* R7844 */ - { 0x0000, 0x0000, 0x0000 }, /* R7845 */ - { 0x0000, 0x0000, 0x0000 }, /* R7846 */ - { 0x0000, 0x0000, 0x0000 }, /* R7847 */ - { 0x0000, 0x0000, 0x0000 }, /* R7848 */ - { 0x0000, 0x0000, 0x0000 }, /* R7849 */ - { 0x0000, 0x0000, 0x0000 }, /* R7850 */ - { 0x0000, 0x0000, 0x0000 }, /* R7851 */ - { 0x0000, 0x0000, 0x0000 }, /* R7852 */ - { 0x0000, 0x0000, 0x0000 }, /* R7853 */ - { 0x0000, 0x0000, 0x0000 }, /* R7854 */ - { 0x0000, 0x0000, 0x0000 }, /* R7855 */ - { 0x0000, 0x0000, 0x0000 }, /* R7856 */ - { 0x0000, 0x0000, 0x0000 }, /* R7857 */ - { 0x0000, 0x0000, 0x0000 }, /* R7858 */ - { 0x0000, 0x0000, 0x0000 }, /* R7859 */ - { 0x0000, 0x0000, 0x0000 }, /* R7860 */ - { 0x0000, 0x0000, 0x0000 }, /* R7861 */ - { 0x0000, 0x0000, 0x0000 }, /* R7862 */ - { 0x0000, 0x0000, 0x0000 }, /* R7863 */ - { 0x0000, 0x0000, 0x0000 }, /* R7864 */ - { 0x0000, 0x0000, 0x0000 }, /* R7865 */ - { 0x0000, 0x0000, 0x0000 }, /* R7866 */ - { 0x0000, 0x0000, 0x0000 }, /* R7867 */ - { 0x0000, 0x0000, 0x0000 }, /* R7868 */ - { 0x0000, 0x0000, 0x0000 }, /* R7869 */ - { 0x0000, 0x0000, 0x0000 }, /* R7870 */ - { 0x0000, 0x0000, 0x0000 }, /* R7871 */ - { 0x0000, 0x0000, 0x0000 }, /* R7872 */ - { 0x0000, 0x0000, 0x0000 }, /* R7873 */ - { 0x0000, 0x0000, 0x0000 }, /* R7874 */ - { 0x0000, 0x0000, 0x0000 }, /* R7875 */ - { 0x0000, 0x0000, 0x0000 }, /* R7876 */ - { 0x0000, 0x0000, 0x0000 }, /* R7877 */ - { 0x0000, 0x0000, 0x0000 }, /* R7878 */ - { 0x0000, 0x0000, 0x0000 }, /* R7879 */ - { 0x0000, 0x0000, 0x0000 }, /* R7880 */ - { 0x0000, 0x0000, 0x0000 }, /* R7881 */ - { 0x0000, 0x0000, 0x0000 }, /* R7882 */ - { 0x0000, 0x0000, 0x0000 }, /* R7883 */ - { 0x0000, 0x0000, 0x0000 }, /* R7884 */ - { 0x0000, 0x0000, 0x0000 }, /* R7885 */ - { 0x0000, 0x0000, 0x0000 }, /* R7886 */ - { 0x0000, 0x0000, 0x0000 }, /* R7887 */ - { 0x0000, 0x0000, 0x0000 }, /* R7888 */ - { 0x0000, 0x0000, 0x0000 }, /* R7889 */ - { 0x0000, 0x0000, 0x0000 }, /* R7890 */ - { 0x0000, 0x0000, 0x0000 }, /* R7891 */ - { 0x0000, 0x0000, 0x0000 }, /* R7892 */ - { 0x0000, 0x0000, 0x0000 }, /* R7893 */ - { 0x0000, 0x0000, 0x0000 }, /* R7894 */ - { 0x0000, 0x0000, 0x0000 }, /* R7895 */ - { 0x0000, 0x0000, 0x0000 }, /* R7896 */ - { 0x0000, 0x0000, 0x0000 }, /* R7897 */ - { 0x0000, 0x0000, 0x0000 }, /* R7898 */ - { 0x0000, 0x0000, 0x0000 }, /* R7899 */ - { 0x0000, 0x0000, 0x0000 }, /* R7900 */ - { 0x0000, 0x0000, 0x0000 }, /* R7901 */ - { 0x0000, 0x0000, 0x0000 }, /* R7902 */ - { 0x0000, 0x0000, 0x0000 }, /* R7903 */ - { 0x0000, 0x0000, 0x0000 }, /* R7904 */ - { 0x0000, 0x0000, 0x0000 }, /* R7905 */ - { 0x0000, 0x0000, 0x0000 }, /* R7906 */ - { 0x0000, 0x0000, 0x0000 }, /* R7907 */ - { 0x0000, 0x0000, 0x0000 }, /* R7908 */ - { 0x0000, 0x0000, 0x0000 }, /* R7909 */ - { 0x0000, 0x0000, 0x0000 }, /* R7910 */ - { 0x0000, 0x0000, 0x0000 }, /* R7911 */ - { 0x0000, 0x0000, 0x0000 }, /* R7912 */ - { 0x0000, 0x0000, 0x0000 }, /* R7913 */ - { 0x0000, 0x0000, 0x0000 }, /* R7914 */ - { 0x0000, 0x0000, 0x0000 }, /* R7915 */ - { 0x0000, 0x0000, 0x0000 }, /* R7916 */ - { 0x0000, 0x0000, 0x0000 }, /* R7917 */ - { 0x0000, 0x0000, 0x0000 }, /* R7918 */ - { 0x0000, 0x0000, 0x0000 }, /* R7919 */ - { 0x0000, 0x0000, 0x0000 }, /* R7920 */ - { 0x0000, 0x0000, 0x0000 }, /* R7921 */ - { 0x0000, 0x0000, 0x0000 }, /* R7922 */ - { 0x0000, 0x0000, 0x0000 }, /* R7923 */ - { 0x0000, 0x0000, 0x0000 }, /* R7924 */ - { 0x0000, 0x0000, 0x0000 }, /* R7925 */ - { 0x0000, 0x0000, 0x0000 }, /* R7926 */ - { 0x0000, 0x0000, 0x0000 }, /* R7927 */ - { 0x0000, 0x0000, 0x0000 }, /* R7928 */ - { 0x0000, 0x0000, 0x0000 }, /* R7929 */ - { 0x0000, 0x0000, 0x0000 }, /* R7930 */ - { 0x0000, 0x0000, 0x0000 }, /* R7931 */ - { 0x0000, 0x0000, 0x0000 }, /* R7932 */ - { 0x0000, 0x0000, 0x0000 }, /* R7933 */ - { 0x0000, 0x0000, 0x0000 }, /* R7934 */ - { 0x0000, 0x0000, 0x0000 }, /* R7935 */ - { 0x0000, 0x0000, 0x0000 }, /* R7936 */ - { 0x0000, 0x0000, 0x0000 }, /* R7937 */ - { 0x0000, 0x0000, 0x0000 }, /* R7938 */ - { 0x0000, 0x0000, 0x0000 }, /* R7939 */ - { 0x0000, 0x0000, 0x0000 }, /* R7940 */ - { 0x0000, 0x0000, 0x0000 }, /* R7941 */ - { 0x0000, 0x0000, 0x0000 }, /* R7942 */ - { 0x0000, 0x0000, 0x0000 }, /* R7943 */ - { 0x0000, 0x0000, 0x0000 }, /* R7944 */ - { 0x0000, 0x0000, 0x0000 }, /* R7945 */ - { 0x0000, 0x0000, 0x0000 }, /* R7946 */ - { 0x0000, 0x0000, 0x0000 }, /* R7947 */ - { 0x0000, 0x0000, 0x0000 }, /* R7948 */ - { 0x0000, 0x0000, 0x0000 }, /* R7949 */ - { 0x0000, 0x0000, 0x0000 }, /* R7950 */ - { 0x0000, 0x0000, 0x0000 }, /* R7951 */ - { 0x0000, 0x0000, 0x0000 }, /* R7952 */ - { 0x0000, 0x0000, 0x0000 }, /* R7953 */ - { 0x0000, 0x0000, 0x0000 }, /* R7954 */ - { 0x0000, 0x0000, 0x0000 }, /* R7955 */ - { 0x0000, 0x0000, 0x0000 }, /* R7956 */ - { 0x0000, 0x0000, 0x0000 }, /* R7957 */ - { 0x0000, 0x0000, 0x0000 }, /* R7958 */ - { 0x0000, 0x0000, 0x0000 }, /* R7959 */ - { 0x0000, 0x0000, 0x0000 }, /* R7960 */ - { 0x0000, 0x0000, 0x0000 }, /* R7961 */ - { 0x0000, 0x0000, 0x0000 }, /* R7962 */ - { 0x0000, 0x0000, 0x0000 }, /* R7963 */ - { 0x0000, 0x0000, 0x0000 }, /* R7964 */ - { 0x0000, 0x0000, 0x0000 }, /* R7965 */ - { 0x0000, 0x0000, 0x0000 }, /* R7966 */ - { 0x0000, 0x0000, 0x0000 }, /* R7967 */ - { 0x0000, 0x0000, 0x0000 }, /* R7968 */ - { 0x0000, 0x0000, 0x0000 }, /* R7969 */ - { 0x0000, 0x0000, 0x0000 }, /* R7970 */ - { 0x0000, 0x0000, 0x0000 }, /* R7971 */ - { 0x0000, 0x0000, 0x0000 }, /* R7972 */ - { 0x0000, 0x0000, 0x0000 }, /* R7973 */ - { 0x0000, 0x0000, 0x0000 }, /* R7974 */ - { 0x0000, 0x0000, 0x0000 }, /* R7975 */ - { 0x0000, 0x0000, 0x0000 }, /* R7976 */ - { 0x0000, 0x0000, 0x0000 }, /* R7977 */ - { 0x0000, 0x0000, 0x0000 }, /* R7978 */ - { 0x0000, 0x0000, 0x0000 }, /* R7979 */ - { 0x0000, 0x0000, 0x0000 }, /* R7980 */ - { 0x0000, 0x0000, 0x0000 }, /* R7981 */ - { 0x0000, 0x0000, 0x0000 }, /* R7982 */ - { 0x0000, 0x0000, 0x0000 }, /* R7983 */ - { 0x0000, 0x0000, 0x0000 }, /* R7984 */ - { 0x0000, 0x0000, 0x0000 }, /* R7985 */ - { 0x0000, 0x0000, 0x0000 }, /* R7986 */ - { 0x0000, 0x0000, 0x0000 }, /* R7987 */ - { 0x0000, 0x0000, 0x0000 }, /* R7988 */ - { 0x0000, 0x0000, 0x0000 }, /* R7989 */ - { 0x0000, 0x0000, 0x0000 }, /* R7990 */ - { 0x0000, 0x0000, 0x0000 }, /* R7991 */ - { 0x0000, 0x0000, 0x0000 }, /* R7992 */ - { 0x0000, 0x0000, 0x0000 }, /* R7993 */ - { 0x0000, 0x0000, 0x0000 }, /* R7994 */ - { 0x0000, 0x0000, 0x0000 }, /* R7995 */ - { 0x0000, 0x0000, 0x0000 }, /* R7996 */ - { 0x0000, 0x0000, 0x0000 }, /* R7997 */ - { 0x0000, 0x0000, 0x0000 }, /* R7998 */ - { 0x0000, 0x0000, 0x0000 }, /* R7999 */ - { 0x0000, 0x0000, 0x0000 }, /* R8000 */ - { 0x0000, 0x0000, 0x0000 }, /* R8001 */ - { 0x0000, 0x0000, 0x0000 }, /* R8002 */ - { 0x0000, 0x0000, 0x0000 }, /* R8003 */ - { 0x0000, 0x0000, 0x0000 }, /* R8004 */ - { 0x0000, 0x0000, 0x0000 }, /* R8005 */ - { 0x0000, 0x0000, 0x0000 }, /* R8006 */ - { 0x0000, 0x0000, 0x0000 }, /* R8007 */ - { 0x0000, 0x0000, 0x0000 }, /* R8008 */ - { 0x0000, 0x0000, 0x0000 }, /* R8009 */ - { 0x0000, 0x0000, 0x0000 }, /* R8010 */ - { 0x0000, 0x0000, 0x0000 }, /* R8011 */ - { 0x0000, 0x0000, 0x0000 }, /* R8012 */ - { 0x0000, 0x0000, 0x0000 }, /* R8013 */ - { 0x0000, 0x0000, 0x0000 }, /* R8014 */ - { 0x0000, 0x0000, 0x0000 }, /* R8015 */ - { 0x0000, 0x0000, 0x0000 }, /* R8016 */ - { 0x0000, 0x0000, 0x0000 }, /* R8017 */ - { 0x0000, 0x0000, 0x0000 }, /* R8018 */ - { 0x0000, 0x0000, 0x0000 }, /* R8019 */ - { 0x0000, 0x0000, 0x0000 }, /* R8020 */ - { 0x0000, 0x0000, 0x0000 }, /* R8021 */ - { 0x0000, 0x0000, 0x0000 }, /* R8022 */ - { 0x0000, 0x0000, 0x0000 }, /* R8023 */ - { 0x0000, 0x0000, 0x0000 }, /* R8024 */ - { 0x0000, 0x0000, 0x0000 }, /* R8025 */ - { 0x0000, 0x0000, 0x0000 }, /* R8026 */ - { 0x0000, 0x0000, 0x0000 }, /* R8027 */ - { 0x0000, 0x0000, 0x0000 }, /* R8028 */ - { 0x0000, 0x0000, 0x0000 }, /* R8029 */ - { 0x0000, 0x0000, 0x0000 }, /* R8030 */ - { 0x0000, 0x0000, 0x0000 }, /* R8031 */ - { 0x0000, 0x0000, 0x0000 }, /* R8032 */ - { 0x0000, 0x0000, 0x0000 }, /* R8033 */ - { 0x0000, 0x0000, 0x0000 }, /* R8034 */ - { 0x0000, 0x0000, 0x0000 }, /* R8035 */ - { 0x0000, 0x0000, 0x0000 }, /* R8036 */ - { 0x0000, 0x0000, 0x0000 }, /* R8037 */ - { 0x0000, 0x0000, 0x0000 }, /* R8038 */ - { 0x0000, 0x0000, 0x0000 }, /* R8039 */ - { 0x0000, 0x0000, 0x0000 }, /* R8040 */ - { 0x0000, 0x0000, 0x0000 }, /* R8041 */ - { 0x0000, 0x0000, 0x0000 }, /* R8042 */ - { 0x0000, 0x0000, 0x0000 }, /* R8043 */ - { 0x0000, 0x0000, 0x0000 }, /* R8044 */ - { 0x0000, 0x0000, 0x0000 }, /* R8045 */ - { 0x0000, 0x0000, 0x0000 }, /* R8046 */ - { 0x0000, 0x0000, 0x0000 }, /* R8047 */ - { 0x0000, 0x0000, 0x0000 }, /* R8048 */ - { 0x0000, 0x0000, 0x0000 }, /* R8049 */ - { 0x0000, 0x0000, 0x0000 }, /* R8050 */ - { 0x0000, 0x0000, 0x0000 }, /* R8051 */ - { 0x0000, 0x0000, 0x0000 }, /* R8052 */ - { 0x0000, 0x0000, 0x0000 }, /* R8053 */ - { 0x0000, 0x0000, 0x0000 }, /* R8054 */ - { 0x0000, 0x0000, 0x0000 }, /* R8055 */ - { 0x0000, 0x0000, 0x0000 }, /* R8056 */ - { 0x0000, 0x0000, 0x0000 }, /* R8057 */ - { 0x0000, 0x0000, 0x0000 }, /* R8058 */ - { 0x0000, 0x0000, 0x0000 }, /* R8059 */ - { 0x0000, 0x0000, 0x0000 }, /* R8060 */ - { 0x0000, 0x0000, 0x0000 }, /* R8061 */ - { 0x0000, 0x0000, 0x0000 }, /* R8062 */ - { 0x0000, 0x0000, 0x0000 }, /* R8063 */ - { 0x0000, 0x0000, 0x0000 }, /* R8064 */ - { 0x0000, 0x0000, 0x0000 }, /* R8065 */ - { 0x0000, 0x0000, 0x0000 }, /* R8066 */ - { 0x0000, 0x0000, 0x0000 }, /* R8067 */ - { 0x0000, 0x0000, 0x0000 }, /* R8068 */ - { 0x0000, 0x0000, 0x0000 }, /* R8069 */ - { 0x0000, 0x0000, 0x0000 }, /* R8070 */ - { 0x0000, 0x0000, 0x0000 }, /* R8071 */ - { 0x0000, 0x0000, 0x0000 }, /* R8072 */ - { 0x0000, 0x0000, 0x0000 }, /* R8073 */ - { 0x0000, 0x0000, 0x0000 }, /* R8074 */ - { 0x0000, 0x0000, 0x0000 }, /* R8075 */ - { 0x0000, 0x0000, 0x0000 }, /* R8076 */ - { 0x0000, 0x0000, 0x0000 }, /* R8077 */ - { 0x0000, 0x0000, 0x0000 }, /* R8078 */ - { 0x0000, 0x0000, 0x0000 }, /* R8079 */ - { 0x0000, 0x0000, 0x0000 }, /* R8080 */ - { 0x0000, 0x0000, 0x0000 }, /* R8081 */ - { 0x0000, 0x0000, 0x0000 }, /* R8082 */ - { 0x0000, 0x0000, 0x0000 }, /* R8083 */ - { 0x0000, 0x0000, 0x0000 }, /* R8084 */ - { 0x0000, 0x0000, 0x0000 }, /* R8085 */ - { 0x0000, 0x0000, 0x0000 }, /* R8086 */ - { 0x0000, 0x0000, 0x0000 }, /* R8087 */ - { 0x0000, 0x0000, 0x0000 }, /* R8088 */ - { 0x0000, 0x0000, 0x0000 }, /* R8089 */ - { 0x0000, 0x0000, 0x0000 }, /* R8090 */ - { 0x0000, 0x0000, 0x0000 }, /* R8091 */ - { 0x0000, 0x0000, 0x0000 }, /* R8092 */ - { 0x0000, 0x0000, 0x0000 }, /* R8093 */ - { 0x0000, 0x0000, 0x0000 }, /* R8094 */ - { 0x0000, 0x0000, 0x0000 }, /* R8095 */ - { 0x0000, 0x0000, 0x0000 }, /* R8096 */ - { 0x0000, 0x0000, 0x0000 }, /* R8097 */ - { 0x0000, 0x0000, 0x0000 }, /* R8098 */ - { 0x0000, 0x0000, 0x0000 }, /* R8099 */ - { 0x0000, 0x0000, 0x0000 }, /* R8100 */ - { 0x0000, 0x0000, 0x0000 }, /* R8101 */ - { 0x0000, 0x0000, 0x0000 }, /* R8102 */ - { 0x0000, 0x0000, 0x0000 }, /* R8103 */ - { 0x0000, 0x0000, 0x0000 }, /* R8104 */ - { 0x0000, 0x0000, 0x0000 }, /* R8105 */ - { 0x0000, 0x0000, 0x0000 }, /* R8106 */ - { 0x0000, 0x0000, 0x0000 }, /* R8107 */ - { 0x0000, 0x0000, 0x0000 }, /* R8108 */ - { 0x0000, 0x0000, 0x0000 }, /* R8109 */ - { 0x0000, 0x0000, 0x0000 }, /* R8110 */ - { 0x0000, 0x0000, 0x0000 }, /* R8111 */ - { 0x0000, 0x0000, 0x0000 }, /* R8112 */ - { 0x0000, 0x0000, 0x0000 }, /* R8113 */ - { 0x0000, 0x0000, 0x0000 }, /* R8114 */ - { 0x0000, 0x0000, 0x0000 }, /* R8115 */ - { 0x0000, 0x0000, 0x0000 }, /* R8116 */ - { 0x0000, 0x0000, 0x0000 }, /* R8117 */ - { 0x0000, 0x0000, 0x0000 }, /* R8118 */ - { 0x0000, 0x0000, 0x0000 }, /* R8119 */ - { 0x0000, 0x0000, 0x0000 }, /* R8120 */ - { 0x0000, 0x0000, 0x0000 }, /* R8121 */ - { 0x0000, 0x0000, 0x0000 }, /* R8122 */ - { 0x0000, 0x0000, 0x0000 }, /* R8123 */ - { 0x0000, 0x0000, 0x0000 }, /* R8124 */ - { 0x0000, 0x0000, 0x0000 }, /* R8125 */ - { 0x0000, 0x0000, 0x0000 }, /* R8126 */ - { 0x0000, 0x0000, 0x0000 }, /* R8127 */ - { 0x0000, 0x0000, 0x0000 }, /* R8128 */ - { 0x0000, 0x0000, 0x0000 }, /* R8129 */ - { 0x0000, 0x0000, 0x0000 }, /* R8130 */ - { 0x0000, 0x0000, 0x0000 }, /* R8131 */ - { 0x0000, 0x0000, 0x0000 }, /* R8132 */ - { 0x0000, 0x0000, 0x0000 }, /* R8133 */ - { 0x0000, 0x0000, 0x0000 }, /* R8134 */ - { 0x0000, 0x0000, 0x0000 }, /* R8135 */ - { 0x0000, 0x0000, 0x0000 }, /* R8136 */ - { 0x0000, 0x0000, 0x0000 }, /* R8137 */ - { 0x0000, 0x0000, 0x0000 }, /* R8138 */ - { 0x0000, 0x0000, 0x0000 }, /* R8139 */ - { 0x0000, 0x0000, 0x0000 }, /* R8140 */ - { 0x0000, 0x0000, 0x0000 }, /* R8141 */ - { 0x0000, 0x0000, 0x0000 }, /* R8142 */ - { 0x0000, 0x0000, 0x0000 }, /* R8143 */ - { 0x0000, 0x0000, 0x0000 }, /* R8144 */ - { 0x0000, 0x0000, 0x0000 }, /* R8145 */ - { 0x0000, 0x0000, 0x0000 }, /* R8146 */ - { 0x0000, 0x0000, 0x0000 }, /* R8147 */ - { 0x0000, 0x0000, 0x0000 }, /* R8148 */ - { 0x0000, 0x0000, 0x0000 }, /* R8149 */ - { 0x0000, 0x0000, 0x0000 }, /* R8150 */ - { 0x0000, 0x0000, 0x0000 }, /* R8151 */ - { 0x0000, 0x0000, 0x0000 }, /* R8152 */ - { 0x0000, 0x0000, 0x0000 }, /* R8153 */ - { 0x0000, 0x0000, 0x0000 }, /* R8154 */ - { 0x0000, 0x0000, 0x0000 }, /* R8155 */ - { 0x0000, 0x0000, 0x0000 }, /* R8156 */ - { 0x0000, 0x0000, 0x0000 }, /* R8157 */ - { 0x0000, 0x0000, 0x0000 }, /* R8158 */ - { 0x0000, 0x0000, 0x0000 }, /* R8159 */ - { 0x0000, 0x0000, 0x0000 }, /* R8160 */ - { 0x0000, 0x0000, 0x0000 }, /* R8161 */ - { 0x0000, 0x0000, 0x0000 }, /* R8162 */ - { 0x0000, 0x0000, 0x0000 }, /* R8163 */ - { 0x0000, 0x0000, 0x0000 }, /* R8164 */ - { 0x0000, 0x0000, 0x0000 }, /* R8165 */ - { 0x0000, 0x0000, 0x0000 }, /* R8166 */ - { 0x0000, 0x0000, 0x0000 }, /* R8167 */ - { 0x0000, 0x0000, 0x0000 }, /* R8168 */ - { 0x0000, 0x0000, 0x0000 }, /* R8169 */ - { 0x0000, 0x0000, 0x0000 }, /* R8170 */ - { 0x0000, 0x0000, 0x0000 }, /* R8171 */ - { 0x0000, 0x0000, 0x0000 }, /* R8172 */ - { 0x0000, 0x0000, 0x0000 }, /* R8173 */ - { 0x0000, 0x0000, 0x0000 }, /* R8174 */ - { 0x0000, 0x0000, 0x0000 }, /* R8175 */ - { 0x0000, 0x0000, 0x0000 }, /* R8176 */ - { 0x0000, 0x0000, 0x0000 }, /* R8177 */ - { 0x0000, 0x0000, 0x0000 }, /* R8178 */ - { 0x0000, 0x0000, 0x0000 }, /* R8179 */ - { 0x0000, 0x0000, 0x0000 }, /* R8180 */ - { 0x0000, 0x0000, 0x0000 }, /* R8181 */ - { 0x0000, 0x0000, 0x0000 }, /* R8182 */ - { 0x0000, 0x0000, 0x0000 }, /* R8183 */ - { 0x0000, 0x0000, 0x0000 }, /* R8184 */ - { 0x0000, 0x0000, 0x0000 }, /* R8185 */ - { 0x0000, 0x0000, 0x0000 }, /* R8186 */ - { 0x0000, 0x0000, 0x0000 }, /* R8187 */ - { 0x0000, 0x0000, 0x0000 }, /* R8188 */ - { 0x0000, 0x0000, 0x0000 }, /* R8189 */ - { 0x0000, 0x0000, 0x0000 }, /* R8190 */ - { 0x0000, 0x0000, 0x0000 }, /* R8191 */ - { 0x03FF, 0x03FF, 0x0000 }, /* R8192 - DSP2 Instruction RAM 0 */ - { 0x0000, 0x0000, 0x0000 }, /* R8193 */ - { 0x0000, 0x0000, 0x0000 }, /* R8194 */ - { 0x0000, 0x0000, 0x0000 }, /* R8195 */ - { 0x0000, 0x0000, 0x0000 }, /* R8196 */ - { 0x0000, 0x0000, 0x0000 }, /* R8197 */ - { 0x0000, 0x0000, 0x0000 }, /* R8198 */ - { 0x0000, 0x0000, 0x0000 }, /* R8199 */ - { 0x0000, 0x0000, 0x0000 }, /* R8200 */ - { 0x0000, 0x0000, 0x0000 }, /* R8201 */ - { 0x0000, 0x0000, 0x0000 }, /* R8202 */ - { 0x0000, 0x0000, 0x0000 }, /* R8203 */ - { 0x0000, 0x0000, 0x0000 }, /* R8204 */ - { 0x0000, 0x0000, 0x0000 }, /* R8205 */ - { 0x0000, 0x0000, 0x0000 }, /* R8206 */ - { 0x0000, 0x0000, 0x0000 }, /* R8207 */ - { 0x0000, 0x0000, 0x0000 }, /* R8208 */ - { 0x0000, 0x0000, 0x0000 }, /* R8209 */ - { 0x0000, 0x0000, 0x0000 }, /* R8210 */ - { 0x0000, 0x0000, 0x0000 }, /* R8211 */ - { 0x0000, 0x0000, 0x0000 }, /* R8212 */ - { 0x0000, 0x0000, 0x0000 }, /* R8213 */ - { 0x0000, 0x0000, 0x0000 }, /* R8214 */ - { 0x0000, 0x0000, 0x0000 }, /* R8215 */ - { 0x0000, 0x0000, 0x0000 }, /* R8216 */ - { 0x0000, 0x0000, 0x0000 }, /* R8217 */ - { 0x0000, 0x0000, 0x0000 }, /* R8218 */ - { 0x0000, 0x0000, 0x0000 }, /* R8219 */ - { 0x0000, 0x0000, 0x0000 }, /* R8220 */ - { 0x0000, 0x0000, 0x0000 }, /* R8221 */ - { 0x0000, 0x0000, 0x0000 }, /* R8222 */ - { 0x0000, 0x0000, 0x0000 }, /* R8223 */ - { 0x0000, 0x0000, 0x0000 }, /* R8224 */ - { 0x0000, 0x0000, 0x0000 }, /* R8225 */ - { 0x0000, 0x0000, 0x0000 }, /* R8226 */ - { 0x0000, 0x0000, 0x0000 }, /* R8227 */ - { 0x0000, 0x0000, 0x0000 }, /* R8228 */ - { 0x0000, 0x0000, 0x0000 }, /* R8229 */ - { 0x0000, 0x0000, 0x0000 }, /* R8230 */ - { 0x0000, 0x0000, 0x0000 }, /* R8231 */ - { 0x0000, 0x0000, 0x0000 }, /* R8232 */ - { 0x0000, 0x0000, 0x0000 }, /* R8233 */ - { 0x0000, 0x0000, 0x0000 }, /* R8234 */ - { 0x0000, 0x0000, 0x0000 }, /* R8235 */ - { 0x0000, 0x0000, 0x0000 }, /* R8236 */ - { 0x0000, 0x0000, 0x0000 }, /* R8237 */ - { 0x0000, 0x0000, 0x0000 }, /* R8238 */ - { 0x0000, 0x0000, 0x0000 }, /* R8239 */ - { 0x0000, 0x0000, 0x0000 }, /* R8240 */ - { 0x0000, 0x0000, 0x0000 }, /* R8241 */ - { 0x0000, 0x0000, 0x0000 }, /* R8242 */ - { 0x0000, 0x0000, 0x0000 }, /* R8243 */ - { 0x0000, 0x0000, 0x0000 }, /* R8244 */ - { 0x0000, 0x0000, 0x0000 }, /* R8245 */ - { 0x0000, 0x0000, 0x0000 }, /* R8246 */ - { 0x0000, 0x0000, 0x0000 }, /* R8247 */ - { 0x0000, 0x0000, 0x0000 }, /* R8248 */ - { 0x0000, 0x0000, 0x0000 }, /* R8249 */ - { 0x0000, 0x0000, 0x0000 }, /* R8250 */ - { 0x0000, 0x0000, 0x0000 }, /* R8251 */ - { 0x0000, 0x0000, 0x0000 }, /* R8252 */ - { 0x0000, 0x0000, 0x0000 }, /* R8253 */ - { 0x0000, 0x0000, 0x0000 }, /* R8254 */ - { 0x0000, 0x0000, 0x0000 }, /* R8255 */ - { 0x0000, 0x0000, 0x0000 }, /* R8256 */ - { 0x0000, 0x0000, 0x0000 }, /* R8257 */ - { 0x0000, 0x0000, 0x0000 }, /* R8258 */ - { 0x0000, 0x0000, 0x0000 }, /* R8259 */ - { 0x0000, 0x0000, 0x0000 }, /* R8260 */ - { 0x0000, 0x0000, 0x0000 }, /* R8261 */ - { 0x0000, 0x0000, 0x0000 }, /* R8262 */ - { 0x0000, 0x0000, 0x0000 }, /* R8263 */ - { 0x0000, 0x0000, 0x0000 }, /* R8264 */ - { 0x0000, 0x0000, 0x0000 }, /* R8265 */ - { 0x0000, 0x0000, 0x0000 }, /* R8266 */ - { 0x0000, 0x0000, 0x0000 }, /* R8267 */ - { 0x0000, 0x0000, 0x0000 }, /* R8268 */ - { 0x0000, 0x0000, 0x0000 }, /* R8269 */ - { 0x0000, 0x0000, 0x0000 }, /* R8270 */ - { 0x0000, 0x0000, 0x0000 }, /* R8271 */ - { 0x0000, 0x0000, 0x0000 }, /* R8272 */ - { 0x0000, 0x0000, 0x0000 }, /* R8273 */ - { 0x0000, 0x0000, 0x0000 }, /* R8274 */ - { 0x0000, 0x0000, 0x0000 }, /* R8275 */ - { 0x0000, 0x0000, 0x0000 }, /* R8276 */ - { 0x0000, 0x0000, 0x0000 }, /* R8277 */ - { 0x0000, 0x0000, 0x0000 }, /* R8278 */ - { 0x0000, 0x0000, 0x0000 }, /* R8279 */ - { 0x0000, 0x0000, 0x0000 }, /* R8280 */ - { 0x0000, 0x0000, 0x0000 }, /* R8281 */ - { 0x0000, 0x0000, 0x0000 }, /* R8282 */ - { 0x0000, 0x0000, 0x0000 }, /* R8283 */ - { 0x0000, 0x0000, 0x0000 }, /* R8284 */ - { 0x0000, 0x0000, 0x0000 }, /* R8285 */ - { 0x0000, 0x0000, 0x0000 }, /* R8286 */ - { 0x0000, 0x0000, 0x0000 }, /* R8287 */ - { 0x0000, 0x0000, 0x0000 }, /* R8288 */ - { 0x0000, 0x0000, 0x0000 }, /* R8289 */ - { 0x0000, 0x0000, 0x0000 }, /* R8290 */ - { 0x0000, 0x0000, 0x0000 }, /* R8291 */ - { 0x0000, 0x0000, 0x0000 }, /* R8292 */ - { 0x0000, 0x0000, 0x0000 }, /* R8293 */ - { 0x0000, 0x0000, 0x0000 }, /* R8294 */ - { 0x0000, 0x0000, 0x0000 }, /* R8295 */ - { 0x0000, 0x0000, 0x0000 }, /* R8296 */ - { 0x0000, 0x0000, 0x0000 }, /* R8297 */ - { 0x0000, 0x0000, 0x0000 }, /* R8298 */ - { 0x0000, 0x0000, 0x0000 }, /* R8299 */ - { 0x0000, 0x0000, 0x0000 }, /* R8300 */ - { 0x0000, 0x0000, 0x0000 }, /* R8301 */ - { 0x0000, 0x0000, 0x0000 }, /* R8302 */ - { 0x0000, 0x0000, 0x0000 }, /* R8303 */ - { 0x0000, 0x0000, 0x0000 }, /* R8304 */ - { 0x0000, 0x0000, 0x0000 }, /* R8305 */ - { 0x0000, 0x0000, 0x0000 }, /* R8306 */ - { 0x0000, 0x0000, 0x0000 }, /* R8307 */ - { 0x0000, 0x0000, 0x0000 }, /* R8308 */ - { 0x0000, 0x0000, 0x0000 }, /* R8309 */ - { 0x0000, 0x0000, 0x0000 }, /* R8310 */ - { 0x0000, 0x0000, 0x0000 }, /* R8311 */ - { 0x0000, 0x0000, 0x0000 }, /* R8312 */ - { 0x0000, 0x0000, 0x0000 }, /* R8313 */ - { 0x0000, 0x0000, 0x0000 }, /* R8314 */ - { 0x0000, 0x0000, 0x0000 }, /* R8315 */ - { 0x0000, 0x0000, 0x0000 }, /* R8316 */ - { 0x0000, 0x0000, 0x0000 }, /* R8317 */ - { 0x0000, 0x0000, 0x0000 }, /* R8318 */ - { 0x0000, 0x0000, 0x0000 }, /* R8319 */ - { 0x0000, 0x0000, 0x0000 }, /* R8320 */ - { 0x0000, 0x0000, 0x0000 }, /* R8321 */ - { 0x0000, 0x0000, 0x0000 }, /* R8322 */ - { 0x0000, 0x0000, 0x0000 }, /* R8323 */ - { 0x0000, 0x0000, 0x0000 }, /* R8324 */ - { 0x0000, 0x0000, 0x0000 }, /* R8325 */ - { 0x0000, 0x0000, 0x0000 }, /* R8326 */ - { 0x0000, 0x0000, 0x0000 }, /* R8327 */ - { 0x0000, 0x0000, 0x0000 }, /* R8328 */ - { 0x0000, 0x0000, 0x0000 }, /* R8329 */ - { 0x0000, 0x0000, 0x0000 }, /* R8330 */ - { 0x0000, 0x0000, 0x0000 }, /* R8331 */ - { 0x0000, 0x0000, 0x0000 }, /* R8332 */ - { 0x0000, 0x0000, 0x0000 }, /* R8333 */ - { 0x0000, 0x0000, 0x0000 }, /* R8334 */ - { 0x0000, 0x0000, 0x0000 }, /* R8335 */ - { 0x0000, 0x0000, 0x0000 }, /* R8336 */ - { 0x0000, 0x0000, 0x0000 }, /* R8337 */ - { 0x0000, 0x0000, 0x0000 }, /* R8338 */ - { 0x0000, 0x0000, 0x0000 }, /* R8339 */ - { 0x0000, 0x0000, 0x0000 }, /* R8340 */ - { 0x0000, 0x0000, 0x0000 }, /* R8341 */ - { 0x0000, 0x0000, 0x0000 }, /* R8342 */ - { 0x0000, 0x0000, 0x0000 }, /* R8343 */ - { 0x0000, 0x0000, 0x0000 }, /* R8344 */ - { 0x0000, 0x0000, 0x0000 }, /* R8345 */ - { 0x0000, 0x0000, 0x0000 }, /* R8346 */ - { 0x0000, 0x0000, 0x0000 }, /* R8347 */ - { 0x0000, 0x0000, 0x0000 }, /* R8348 */ - { 0x0000, 0x0000, 0x0000 }, /* R8349 */ - { 0x0000, 0x0000, 0x0000 }, /* R8350 */ - { 0x0000, 0x0000, 0x0000 }, /* R8351 */ - { 0x0000, 0x0000, 0x0000 }, /* R8352 */ - { 0x0000, 0x0000, 0x0000 }, /* R8353 */ - { 0x0000, 0x0000, 0x0000 }, /* R8354 */ - { 0x0000, 0x0000, 0x0000 }, /* R8355 */ - { 0x0000, 0x0000, 0x0000 }, /* R8356 */ - { 0x0000, 0x0000, 0x0000 }, /* R8357 */ - { 0x0000, 0x0000, 0x0000 }, /* R8358 */ - { 0x0000, 0x0000, 0x0000 }, /* R8359 */ - { 0x0000, 0x0000, 0x0000 }, /* R8360 */ - { 0x0000, 0x0000, 0x0000 }, /* R8361 */ - { 0x0000, 0x0000, 0x0000 }, /* R8362 */ - { 0x0000, 0x0000, 0x0000 }, /* R8363 */ - { 0x0000, 0x0000, 0x0000 }, /* R8364 */ - { 0x0000, 0x0000, 0x0000 }, /* R8365 */ - { 0x0000, 0x0000, 0x0000 }, /* R8366 */ - { 0x0000, 0x0000, 0x0000 }, /* R8367 */ - { 0x0000, 0x0000, 0x0000 }, /* R8368 */ - { 0x0000, 0x0000, 0x0000 }, /* R8369 */ - { 0x0000, 0x0000, 0x0000 }, /* R8370 */ - { 0x0000, 0x0000, 0x0000 }, /* R8371 */ - { 0x0000, 0x0000, 0x0000 }, /* R8372 */ - { 0x0000, 0x0000, 0x0000 }, /* R8373 */ - { 0x0000, 0x0000, 0x0000 }, /* R8374 */ - { 0x0000, 0x0000, 0x0000 }, /* R8375 */ - { 0x0000, 0x0000, 0x0000 }, /* R8376 */ - { 0x0000, 0x0000, 0x0000 }, /* R8377 */ - { 0x0000, 0x0000, 0x0000 }, /* R8378 */ - { 0x0000, 0x0000, 0x0000 }, /* R8379 */ - { 0x0000, 0x0000, 0x0000 }, /* R8380 */ - { 0x0000, 0x0000, 0x0000 }, /* R8381 */ - { 0x0000, 0x0000, 0x0000 }, /* R8382 */ - { 0x0000, 0x0000, 0x0000 }, /* R8383 */ - { 0x0000, 0x0000, 0x0000 }, /* R8384 */ - { 0x0000, 0x0000, 0x0000 }, /* R8385 */ - { 0x0000, 0x0000, 0x0000 }, /* R8386 */ - { 0x0000, 0x0000, 0x0000 }, /* R8387 */ - { 0x0000, 0x0000, 0x0000 }, /* R8388 */ - { 0x0000, 0x0000, 0x0000 }, /* R8389 */ - { 0x0000, 0x0000, 0x0000 }, /* R8390 */ - { 0x0000, 0x0000, 0x0000 }, /* R8391 */ - { 0x0000, 0x0000, 0x0000 }, /* R8392 */ - { 0x0000, 0x0000, 0x0000 }, /* R8393 */ - { 0x0000, 0x0000, 0x0000 }, /* R8394 */ - { 0x0000, 0x0000, 0x0000 }, /* R8395 */ - { 0x0000, 0x0000, 0x0000 }, /* R8396 */ - { 0x0000, 0x0000, 0x0000 }, /* R8397 */ - { 0x0000, 0x0000, 0x0000 }, /* R8398 */ - { 0x0000, 0x0000, 0x0000 }, /* R8399 */ - { 0x0000, 0x0000, 0x0000 }, /* R8400 */ - { 0x0000, 0x0000, 0x0000 }, /* R8401 */ - { 0x0000, 0x0000, 0x0000 }, /* R8402 */ - { 0x0000, 0x0000, 0x0000 }, /* R8403 */ - { 0x0000, 0x0000, 0x0000 }, /* R8404 */ - { 0x0000, 0x0000, 0x0000 }, /* R8405 */ - { 0x0000, 0x0000, 0x0000 }, /* R8406 */ - { 0x0000, 0x0000, 0x0000 }, /* R8407 */ - { 0x0000, 0x0000, 0x0000 }, /* R8408 */ - { 0x0000, 0x0000, 0x0000 }, /* R8409 */ - { 0x0000, 0x0000, 0x0000 }, /* R8410 */ - { 0x0000, 0x0000, 0x0000 }, /* R8411 */ - { 0x0000, 0x0000, 0x0000 }, /* R8412 */ - { 0x0000, 0x0000, 0x0000 }, /* R8413 */ - { 0x0000, 0x0000, 0x0000 }, /* R8414 */ - { 0x0000, 0x0000, 0x0000 }, /* R8415 */ - { 0x0000, 0x0000, 0x0000 }, /* R8416 */ - { 0x0000, 0x0000, 0x0000 }, /* R8417 */ - { 0x0000, 0x0000, 0x0000 }, /* R8418 */ - { 0x0000, 0x0000, 0x0000 }, /* R8419 */ - { 0x0000, 0x0000, 0x0000 }, /* R8420 */ - { 0x0000, 0x0000, 0x0000 }, /* R8421 */ - { 0x0000, 0x0000, 0x0000 }, /* R8422 */ - { 0x0000, 0x0000, 0x0000 }, /* R8423 */ - { 0x0000, 0x0000, 0x0000 }, /* R8424 */ - { 0x0000, 0x0000, 0x0000 }, /* R8425 */ - { 0x0000, 0x0000, 0x0000 }, /* R8426 */ - { 0x0000, 0x0000, 0x0000 }, /* R8427 */ - { 0x0000, 0x0000, 0x0000 }, /* R8428 */ - { 0x0000, 0x0000, 0x0000 }, /* R8429 */ - { 0x0000, 0x0000, 0x0000 }, /* R8430 */ - { 0x0000, 0x0000, 0x0000 }, /* R8431 */ - { 0x0000, 0x0000, 0x0000 }, /* R8432 */ - { 0x0000, 0x0000, 0x0000 }, /* R8433 */ - { 0x0000, 0x0000, 0x0000 }, /* R8434 */ - { 0x0000, 0x0000, 0x0000 }, /* R8435 */ - { 0x0000, 0x0000, 0x0000 }, /* R8436 */ - { 0x0000, 0x0000, 0x0000 }, /* R8437 */ - { 0x0000, 0x0000, 0x0000 }, /* R8438 */ - { 0x0000, 0x0000, 0x0000 }, /* R8439 */ - { 0x0000, 0x0000, 0x0000 }, /* R8440 */ - { 0x0000, 0x0000, 0x0000 }, /* R8441 */ - { 0x0000, 0x0000, 0x0000 }, /* R8442 */ - { 0x0000, 0x0000, 0x0000 }, /* R8443 */ - { 0x0000, 0x0000, 0x0000 }, /* R8444 */ - { 0x0000, 0x0000, 0x0000 }, /* R8445 */ - { 0x0000, 0x0000, 0x0000 }, /* R8446 */ - { 0x0000, 0x0000, 0x0000 }, /* R8447 */ - { 0x0000, 0x0000, 0x0000 }, /* R8448 */ - { 0x0000, 0x0000, 0x0000 }, /* R8449 */ - { 0x0000, 0x0000, 0x0000 }, /* R8450 */ - { 0x0000, 0x0000, 0x0000 }, /* R8451 */ - { 0x0000, 0x0000, 0x0000 }, /* R8452 */ - { 0x0000, 0x0000, 0x0000 }, /* R8453 */ - { 0x0000, 0x0000, 0x0000 }, /* R8454 */ - { 0x0000, 0x0000, 0x0000 }, /* R8455 */ - { 0x0000, 0x0000, 0x0000 }, /* R8456 */ - { 0x0000, 0x0000, 0x0000 }, /* R8457 */ - { 0x0000, 0x0000, 0x0000 }, /* R8458 */ - { 0x0000, 0x0000, 0x0000 }, /* R8459 */ - { 0x0000, 0x0000, 0x0000 }, /* R8460 */ - { 0x0000, 0x0000, 0x0000 }, /* R8461 */ - { 0x0000, 0x0000, 0x0000 }, /* R8462 */ - { 0x0000, 0x0000, 0x0000 }, /* R8463 */ - { 0x0000, 0x0000, 0x0000 }, /* R8464 */ - { 0x0000, 0x0000, 0x0000 }, /* R8465 */ - { 0x0000, 0x0000, 0x0000 }, /* R8466 */ - { 0x0000, 0x0000, 0x0000 }, /* R8467 */ - { 0x0000, 0x0000, 0x0000 }, /* R8468 */ - { 0x0000, 0x0000, 0x0000 }, /* R8469 */ - { 0x0000, 0x0000, 0x0000 }, /* R8470 */ - { 0x0000, 0x0000, 0x0000 }, /* R8471 */ - { 0x0000, 0x0000, 0x0000 }, /* R8472 */ - { 0x0000, 0x0000, 0x0000 }, /* R8473 */ - { 0x0000, 0x0000, 0x0000 }, /* R8474 */ - { 0x0000, 0x0000, 0x0000 }, /* R8475 */ - { 0x0000, 0x0000, 0x0000 }, /* R8476 */ - { 0x0000, 0x0000, 0x0000 }, /* R8477 */ - { 0x0000, 0x0000, 0x0000 }, /* R8478 */ - { 0x0000, 0x0000, 0x0000 }, /* R8479 */ - { 0x0000, 0x0000, 0x0000 }, /* R8480 */ - { 0x0000, 0x0000, 0x0000 }, /* R8481 */ - { 0x0000, 0x0000, 0x0000 }, /* R8482 */ - { 0x0000, 0x0000, 0x0000 }, /* R8483 */ - { 0x0000, 0x0000, 0x0000 }, /* R8484 */ - { 0x0000, 0x0000, 0x0000 }, /* R8485 */ - { 0x0000, 0x0000, 0x0000 }, /* R8486 */ - { 0x0000, 0x0000, 0x0000 }, /* R8487 */ - { 0x0000, 0x0000, 0x0000 }, /* R8488 */ - { 0x0000, 0x0000, 0x0000 }, /* R8489 */ - { 0x0000, 0x0000, 0x0000 }, /* R8490 */ - { 0x0000, 0x0000, 0x0000 }, /* R8491 */ - { 0x0000, 0x0000, 0x0000 }, /* R8492 */ - { 0x0000, 0x0000, 0x0000 }, /* R8493 */ - { 0x0000, 0x0000, 0x0000 }, /* R8494 */ - { 0x0000, 0x0000, 0x0000 }, /* R8495 */ - { 0x0000, 0x0000, 0x0000 }, /* R8496 */ - { 0x0000, 0x0000, 0x0000 }, /* R8497 */ - { 0x0000, 0x0000, 0x0000 }, /* R8498 */ - { 0x0000, 0x0000, 0x0000 }, /* R8499 */ - { 0x0000, 0x0000, 0x0000 }, /* R8500 */ - { 0x0000, 0x0000, 0x0000 }, /* R8501 */ - { 0x0000, 0x0000, 0x0000 }, /* R8502 */ - { 0x0000, 0x0000, 0x0000 }, /* R8503 */ - { 0x0000, 0x0000, 0x0000 }, /* R8504 */ - { 0x0000, 0x0000, 0x0000 }, /* R8505 */ - { 0x0000, 0x0000, 0x0000 }, /* R8506 */ - { 0x0000, 0x0000, 0x0000 }, /* R8507 */ - { 0x0000, 0x0000, 0x0000 }, /* R8508 */ - { 0x0000, 0x0000, 0x0000 }, /* R8509 */ - { 0x0000, 0x0000, 0x0000 }, /* R8510 */ - { 0x0000, 0x0000, 0x0000 }, /* R8511 */ - { 0x0000, 0x0000, 0x0000 }, /* R8512 */ - { 0x0000, 0x0000, 0x0000 }, /* R8513 */ - { 0x0000, 0x0000, 0x0000 }, /* R8514 */ - { 0x0000, 0x0000, 0x0000 }, /* R8515 */ - { 0x0000, 0x0000, 0x0000 }, /* R8516 */ - { 0x0000, 0x0000, 0x0000 }, /* R8517 */ - { 0x0000, 0x0000, 0x0000 }, /* R8518 */ - { 0x0000, 0x0000, 0x0000 }, /* R8519 */ - { 0x0000, 0x0000, 0x0000 }, /* R8520 */ - { 0x0000, 0x0000, 0x0000 }, /* R8521 */ - { 0x0000, 0x0000, 0x0000 }, /* R8522 */ - { 0x0000, 0x0000, 0x0000 }, /* R8523 */ - { 0x0000, 0x0000, 0x0000 }, /* R8524 */ - { 0x0000, 0x0000, 0x0000 }, /* R8525 */ - { 0x0000, 0x0000, 0x0000 }, /* R8526 */ - { 0x0000, 0x0000, 0x0000 }, /* R8527 */ - { 0x0000, 0x0000, 0x0000 }, /* R8528 */ - { 0x0000, 0x0000, 0x0000 }, /* R8529 */ - { 0x0000, 0x0000, 0x0000 }, /* R8530 */ - { 0x0000, 0x0000, 0x0000 }, /* R8531 */ - { 0x0000, 0x0000, 0x0000 }, /* R8532 */ - { 0x0000, 0x0000, 0x0000 }, /* R8533 */ - { 0x0000, 0x0000, 0x0000 }, /* R8534 */ - { 0x0000, 0x0000, 0x0000 }, /* R8535 */ - { 0x0000, 0x0000, 0x0000 }, /* R8536 */ - { 0x0000, 0x0000, 0x0000 }, /* R8537 */ - { 0x0000, 0x0000, 0x0000 }, /* R8538 */ - { 0x0000, 0x0000, 0x0000 }, /* R8539 */ - { 0x0000, 0x0000, 0x0000 }, /* R8540 */ - { 0x0000, 0x0000, 0x0000 }, /* R8541 */ - { 0x0000, 0x0000, 0x0000 }, /* R8542 */ - { 0x0000, 0x0000, 0x0000 }, /* R8543 */ - { 0x0000, 0x0000, 0x0000 }, /* R8544 */ - { 0x0000, 0x0000, 0x0000 }, /* R8545 */ - { 0x0000, 0x0000, 0x0000 }, /* R8546 */ - { 0x0000, 0x0000, 0x0000 }, /* R8547 */ - { 0x0000, 0x0000, 0x0000 }, /* R8548 */ - { 0x0000, 0x0000, 0x0000 }, /* R8549 */ - { 0x0000, 0x0000, 0x0000 }, /* R8550 */ - { 0x0000, 0x0000, 0x0000 }, /* R8551 */ - { 0x0000, 0x0000, 0x0000 }, /* R8552 */ - { 0x0000, 0x0000, 0x0000 }, /* R8553 */ - { 0x0000, 0x0000, 0x0000 }, /* R8554 */ - { 0x0000, 0x0000, 0x0000 }, /* R8555 */ - { 0x0000, 0x0000, 0x0000 }, /* R8556 */ - { 0x0000, 0x0000, 0x0000 }, /* R8557 */ - { 0x0000, 0x0000, 0x0000 }, /* R8558 */ - { 0x0000, 0x0000, 0x0000 }, /* R8559 */ - { 0x0000, 0x0000, 0x0000 }, /* R8560 */ - { 0x0000, 0x0000, 0x0000 }, /* R8561 */ - { 0x0000, 0x0000, 0x0000 }, /* R8562 */ - { 0x0000, 0x0000, 0x0000 }, /* R8563 */ - { 0x0000, 0x0000, 0x0000 }, /* R8564 */ - { 0x0000, 0x0000, 0x0000 }, /* R8565 */ - { 0x0000, 0x0000, 0x0000 }, /* R8566 */ - { 0x0000, 0x0000, 0x0000 }, /* R8567 */ - { 0x0000, 0x0000, 0x0000 }, /* R8568 */ - { 0x0000, 0x0000, 0x0000 }, /* R8569 */ - { 0x0000, 0x0000, 0x0000 }, /* R8570 */ - { 0x0000, 0x0000, 0x0000 }, /* R8571 */ - { 0x0000, 0x0000, 0x0000 }, /* R8572 */ - { 0x0000, 0x0000, 0x0000 }, /* R8573 */ - { 0x0000, 0x0000, 0x0000 }, /* R8574 */ - { 0x0000, 0x0000, 0x0000 }, /* R8575 */ - { 0x0000, 0x0000, 0x0000 }, /* R8576 */ - { 0x0000, 0x0000, 0x0000 }, /* R8577 */ - { 0x0000, 0x0000, 0x0000 }, /* R8578 */ - { 0x0000, 0x0000, 0x0000 }, /* R8579 */ - { 0x0000, 0x0000, 0x0000 }, /* R8580 */ - { 0x0000, 0x0000, 0x0000 }, /* R8581 */ - { 0x0000, 0x0000, 0x0000 }, /* R8582 */ - { 0x0000, 0x0000, 0x0000 }, /* R8583 */ - { 0x0000, 0x0000, 0x0000 }, /* R8584 */ - { 0x0000, 0x0000, 0x0000 }, /* R8585 */ - { 0x0000, 0x0000, 0x0000 }, /* R8586 */ - { 0x0000, 0x0000, 0x0000 }, /* R8587 */ - { 0x0000, 0x0000, 0x0000 }, /* R8588 */ - { 0x0000, 0x0000, 0x0000 }, /* R8589 */ - { 0x0000, 0x0000, 0x0000 }, /* R8590 */ - { 0x0000, 0x0000, 0x0000 }, /* R8591 */ - { 0x0000, 0x0000, 0x0000 }, /* R8592 */ - { 0x0000, 0x0000, 0x0000 }, /* R8593 */ - { 0x0000, 0x0000, 0x0000 }, /* R8594 */ - { 0x0000, 0x0000, 0x0000 }, /* R8595 */ - { 0x0000, 0x0000, 0x0000 }, /* R8596 */ - { 0x0000, 0x0000, 0x0000 }, /* R8597 */ - { 0x0000, 0x0000, 0x0000 }, /* R8598 */ - { 0x0000, 0x0000, 0x0000 }, /* R8599 */ - { 0x0000, 0x0000, 0x0000 }, /* R8600 */ - { 0x0000, 0x0000, 0x0000 }, /* R8601 */ - { 0x0000, 0x0000, 0x0000 }, /* R8602 */ - { 0x0000, 0x0000, 0x0000 }, /* R8603 */ - { 0x0000, 0x0000, 0x0000 }, /* R8604 */ - { 0x0000, 0x0000, 0x0000 }, /* R8605 */ - { 0x0000, 0x0000, 0x0000 }, /* R8606 */ - { 0x0000, 0x0000, 0x0000 }, /* R8607 */ - { 0x0000, 0x0000, 0x0000 }, /* R8608 */ - { 0x0000, 0x0000, 0x0000 }, /* R8609 */ - { 0x0000, 0x0000, 0x0000 }, /* R8610 */ - { 0x0000, 0x0000, 0x0000 }, /* R8611 */ - { 0x0000, 0x0000, 0x0000 }, /* R8612 */ - { 0x0000, 0x0000, 0x0000 }, /* R8613 */ - { 0x0000, 0x0000, 0x0000 }, /* R8614 */ - { 0x0000, 0x0000, 0x0000 }, /* R8615 */ - { 0x0000, 0x0000, 0x0000 }, /* R8616 */ - { 0x0000, 0x0000, 0x0000 }, /* R8617 */ - { 0x0000, 0x0000, 0x0000 }, /* R8618 */ - { 0x0000, 0x0000, 0x0000 }, /* R8619 */ - { 0x0000, 0x0000, 0x0000 }, /* R8620 */ - { 0x0000, 0x0000, 0x0000 }, /* R8621 */ - { 0x0000, 0x0000, 0x0000 }, /* R8622 */ - { 0x0000, 0x0000, 0x0000 }, /* R8623 */ - { 0x0000, 0x0000, 0x0000 }, /* R8624 */ - { 0x0000, 0x0000, 0x0000 }, /* R8625 */ - { 0x0000, 0x0000, 0x0000 }, /* R8626 */ - { 0x0000, 0x0000, 0x0000 }, /* R8627 */ - { 0x0000, 0x0000, 0x0000 }, /* R8628 */ - { 0x0000, 0x0000, 0x0000 }, /* R8629 */ - { 0x0000, 0x0000, 0x0000 }, /* R8630 */ - { 0x0000, 0x0000, 0x0000 }, /* R8631 */ - { 0x0000, 0x0000, 0x0000 }, /* R8632 */ - { 0x0000, 0x0000, 0x0000 }, /* R8633 */ - { 0x0000, 0x0000, 0x0000 }, /* R8634 */ - { 0x0000, 0x0000, 0x0000 }, /* R8635 */ - { 0x0000, 0x0000, 0x0000 }, /* R8636 */ - { 0x0000, 0x0000, 0x0000 }, /* R8637 */ - { 0x0000, 0x0000, 0x0000 }, /* R8638 */ - { 0x0000, 0x0000, 0x0000 }, /* R8639 */ - { 0x0000, 0x0000, 0x0000 }, /* R8640 */ - { 0x0000, 0x0000, 0x0000 }, /* R8641 */ - { 0x0000, 0x0000, 0x0000 }, /* R8642 */ - { 0x0000, 0x0000, 0x0000 }, /* R8643 */ - { 0x0000, 0x0000, 0x0000 }, /* R8644 */ - { 0x0000, 0x0000, 0x0000 }, /* R8645 */ - { 0x0000, 0x0000, 0x0000 }, /* R8646 */ - { 0x0000, 0x0000, 0x0000 }, /* R8647 */ - { 0x0000, 0x0000, 0x0000 }, /* R8648 */ - { 0x0000, 0x0000, 0x0000 }, /* R8649 */ - { 0x0000, 0x0000, 0x0000 }, /* R8650 */ - { 0x0000, 0x0000, 0x0000 }, /* R8651 */ - { 0x0000, 0x0000, 0x0000 }, /* R8652 */ - { 0x0000, 0x0000, 0x0000 }, /* R8653 */ - { 0x0000, 0x0000, 0x0000 }, /* R8654 */ - { 0x0000, 0x0000, 0x0000 }, /* R8655 */ - { 0x0000, 0x0000, 0x0000 }, /* R8656 */ - { 0x0000, 0x0000, 0x0000 }, /* R8657 */ - { 0x0000, 0x0000, 0x0000 }, /* R8658 */ - { 0x0000, 0x0000, 0x0000 }, /* R8659 */ - { 0x0000, 0x0000, 0x0000 }, /* R8660 */ - { 0x0000, 0x0000, 0x0000 }, /* R8661 */ - { 0x0000, 0x0000, 0x0000 }, /* R8662 */ - { 0x0000, 0x0000, 0x0000 }, /* R8663 */ - { 0x0000, 0x0000, 0x0000 }, /* R8664 */ - { 0x0000, 0x0000, 0x0000 }, /* R8665 */ - { 0x0000, 0x0000, 0x0000 }, /* R8666 */ - { 0x0000, 0x0000, 0x0000 }, /* R8667 */ - { 0x0000, 0x0000, 0x0000 }, /* R8668 */ - { 0x0000, 0x0000, 0x0000 }, /* R8669 */ - { 0x0000, 0x0000, 0x0000 }, /* R8670 */ - { 0x0000, 0x0000, 0x0000 }, /* R8671 */ - { 0x0000, 0x0000, 0x0000 }, /* R8672 */ - { 0x0000, 0x0000, 0x0000 }, /* R8673 */ - { 0x0000, 0x0000, 0x0000 }, /* R8674 */ - { 0x0000, 0x0000, 0x0000 }, /* R8675 */ - { 0x0000, 0x0000, 0x0000 }, /* R8676 */ - { 0x0000, 0x0000, 0x0000 }, /* R8677 */ - { 0x0000, 0x0000, 0x0000 }, /* R8678 */ - { 0x0000, 0x0000, 0x0000 }, /* R8679 */ - { 0x0000, 0x0000, 0x0000 }, /* R8680 */ - { 0x0000, 0x0000, 0x0000 }, /* R8681 */ - { 0x0000, 0x0000, 0x0000 }, /* R8682 */ - { 0x0000, 0x0000, 0x0000 }, /* R8683 */ - { 0x0000, 0x0000, 0x0000 }, /* R8684 */ - { 0x0000, 0x0000, 0x0000 }, /* R8685 */ - { 0x0000, 0x0000, 0x0000 }, /* R8686 */ - { 0x0000, 0x0000, 0x0000 }, /* R8687 */ - { 0x0000, 0x0000, 0x0000 }, /* R8688 */ - { 0x0000, 0x0000, 0x0000 }, /* R8689 */ - { 0x0000, 0x0000, 0x0000 }, /* R8690 */ - { 0x0000, 0x0000, 0x0000 }, /* R8691 */ - { 0x0000, 0x0000, 0x0000 }, /* R8692 */ - { 0x0000, 0x0000, 0x0000 }, /* R8693 */ - { 0x0000, 0x0000, 0x0000 }, /* R8694 */ - { 0x0000, 0x0000, 0x0000 }, /* R8695 */ - { 0x0000, 0x0000, 0x0000 }, /* R8696 */ - { 0x0000, 0x0000, 0x0000 }, /* R8697 */ - { 0x0000, 0x0000, 0x0000 }, /* R8698 */ - { 0x0000, 0x0000, 0x0000 }, /* R8699 */ - { 0x0000, 0x0000, 0x0000 }, /* R8700 */ - { 0x0000, 0x0000, 0x0000 }, /* R8701 */ - { 0x0000, 0x0000, 0x0000 }, /* R8702 */ - { 0x0000, 0x0000, 0x0000 }, /* R8703 */ - { 0x0000, 0x0000, 0x0000 }, /* R8704 */ - { 0x0000, 0x0000, 0x0000 }, /* R8705 */ - { 0x0000, 0x0000, 0x0000 }, /* R8706 */ - { 0x0000, 0x0000, 0x0000 }, /* R8707 */ - { 0x0000, 0x0000, 0x0000 }, /* R8708 */ - { 0x0000, 0x0000, 0x0000 }, /* R8709 */ - { 0x0000, 0x0000, 0x0000 }, /* R8710 */ - { 0x0000, 0x0000, 0x0000 }, /* R8711 */ - { 0x0000, 0x0000, 0x0000 }, /* R8712 */ - { 0x0000, 0x0000, 0x0000 }, /* R8713 */ - { 0x0000, 0x0000, 0x0000 }, /* R8714 */ - { 0x0000, 0x0000, 0x0000 }, /* R8715 */ - { 0x0000, 0x0000, 0x0000 }, /* R8716 */ - { 0x0000, 0x0000, 0x0000 }, /* R8717 */ - { 0x0000, 0x0000, 0x0000 }, /* R8718 */ - { 0x0000, 0x0000, 0x0000 }, /* R8719 */ - { 0x0000, 0x0000, 0x0000 }, /* R8720 */ - { 0x0000, 0x0000, 0x0000 }, /* R8721 */ - { 0x0000, 0x0000, 0x0000 }, /* R8722 */ - { 0x0000, 0x0000, 0x0000 }, /* R8723 */ - { 0x0000, 0x0000, 0x0000 }, /* R8724 */ - { 0x0000, 0x0000, 0x0000 }, /* R8725 */ - { 0x0000, 0x0000, 0x0000 }, /* R8726 */ - { 0x0000, 0x0000, 0x0000 }, /* R8727 */ - { 0x0000, 0x0000, 0x0000 }, /* R8728 */ - { 0x0000, 0x0000, 0x0000 }, /* R8729 */ - { 0x0000, 0x0000, 0x0000 }, /* R8730 */ - { 0x0000, 0x0000, 0x0000 }, /* R8731 */ - { 0x0000, 0x0000, 0x0000 }, /* R8732 */ - { 0x0000, 0x0000, 0x0000 }, /* R8733 */ - { 0x0000, 0x0000, 0x0000 }, /* R8734 */ - { 0x0000, 0x0000, 0x0000 }, /* R8735 */ - { 0x0000, 0x0000, 0x0000 }, /* R8736 */ - { 0x0000, 0x0000, 0x0000 }, /* R8737 */ - { 0x0000, 0x0000, 0x0000 }, /* R8738 */ - { 0x0000, 0x0000, 0x0000 }, /* R8739 */ - { 0x0000, 0x0000, 0x0000 }, /* R8740 */ - { 0x0000, 0x0000, 0x0000 }, /* R8741 */ - { 0x0000, 0x0000, 0x0000 }, /* R8742 */ - { 0x0000, 0x0000, 0x0000 }, /* R8743 */ - { 0x0000, 0x0000, 0x0000 }, /* R8744 */ - { 0x0000, 0x0000, 0x0000 }, /* R8745 */ - { 0x0000, 0x0000, 0x0000 }, /* R8746 */ - { 0x0000, 0x0000, 0x0000 }, /* R8747 */ - { 0x0000, 0x0000, 0x0000 }, /* R8748 */ - { 0x0000, 0x0000, 0x0000 }, /* R8749 */ - { 0x0000, 0x0000, 0x0000 }, /* R8750 */ - { 0x0000, 0x0000, 0x0000 }, /* R8751 */ - { 0x0000, 0x0000, 0x0000 }, /* R8752 */ - { 0x0000, 0x0000, 0x0000 }, /* R8753 */ - { 0x0000, 0x0000, 0x0000 }, /* R8754 */ - { 0x0000, 0x0000, 0x0000 }, /* R8755 */ - { 0x0000, 0x0000, 0x0000 }, /* R8756 */ - { 0x0000, 0x0000, 0x0000 }, /* R8757 */ - { 0x0000, 0x0000, 0x0000 }, /* R8758 */ - { 0x0000, 0x0000, 0x0000 }, /* R8759 */ - { 0x0000, 0x0000, 0x0000 }, /* R8760 */ - { 0x0000, 0x0000, 0x0000 }, /* R8761 */ - { 0x0000, 0x0000, 0x0000 }, /* R8762 */ - { 0x0000, 0x0000, 0x0000 }, /* R8763 */ - { 0x0000, 0x0000, 0x0000 }, /* R8764 */ - { 0x0000, 0x0000, 0x0000 }, /* R8765 */ - { 0x0000, 0x0000, 0x0000 }, /* R8766 */ - { 0x0000, 0x0000, 0x0000 }, /* R8767 */ - { 0x0000, 0x0000, 0x0000 }, /* R8768 */ - { 0x0000, 0x0000, 0x0000 }, /* R8769 */ - { 0x0000, 0x0000, 0x0000 }, /* R8770 */ - { 0x0000, 0x0000, 0x0000 }, /* R8771 */ - { 0x0000, 0x0000, 0x0000 }, /* R8772 */ - { 0x0000, 0x0000, 0x0000 }, /* R8773 */ - { 0x0000, 0x0000, 0x0000 }, /* R8774 */ - { 0x0000, 0x0000, 0x0000 }, /* R8775 */ - { 0x0000, 0x0000, 0x0000 }, /* R8776 */ - { 0x0000, 0x0000, 0x0000 }, /* R8777 */ - { 0x0000, 0x0000, 0x0000 }, /* R8778 */ - { 0x0000, 0x0000, 0x0000 }, /* R8779 */ - { 0x0000, 0x0000, 0x0000 }, /* R8780 */ - { 0x0000, 0x0000, 0x0000 }, /* R8781 */ - { 0x0000, 0x0000, 0x0000 }, /* R8782 */ - { 0x0000, 0x0000, 0x0000 }, /* R8783 */ - { 0x0000, 0x0000, 0x0000 }, /* R8784 */ - { 0x0000, 0x0000, 0x0000 }, /* R8785 */ - { 0x0000, 0x0000, 0x0000 }, /* R8786 */ - { 0x0000, 0x0000, 0x0000 }, /* R8787 */ - { 0x0000, 0x0000, 0x0000 }, /* R8788 */ - { 0x0000, 0x0000, 0x0000 }, /* R8789 */ - { 0x0000, 0x0000, 0x0000 }, /* R8790 */ - { 0x0000, 0x0000, 0x0000 }, /* R8791 */ - { 0x0000, 0x0000, 0x0000 }, /* R8792 */ - { 0x0000, 0x0000, 0x0000 }, /* R8793 */ - { 0x0000, 0x0000, 0x0000 }, /* R8794 */ - { 0x0000, 0x0000, 0x0000 }, /* R8795 */ - { 0x0000, 0x0000, 0x0000 }, /* R8796 */ - { 0x0000, 0x0000, 0x0000 }, /* R8797 */ - { 0x0000, 0x0000, 0x0000 }, /* R8798 */ - { 0x0000, 0x0000, 0x0000 }, /* R8799 */ - { 0x0000, 0x0000, 0x0000 }, /* R8800 */ - { 0x0000, 0x0000, 0x0000 }, /* R8801 */ - { 0x0000, 0x0000, 0x0000 }, /* R8802 */ - { 0x0000, 0x0000, 0x0000 }, /* R8803 */ - { 0x0000, 0x0000, 0x0000 }, /* R8804 */ - { 0x0000, 0x0000, 0x0000 }, /* R8805 */ - { 0x0000, 0x0000, 0x0000 }, /* R8806 */ - { 0x0000, 0x0000, 0x0000 }, /* R8807 */ - { 0x0000, 0x0000, 0x0000 }, /* R8808 */ - { 0x0000, 0x0000, 0x0000 }, /* R8809 */ - { 0x0000, 0x0000, 0x0000 }, /* R8810 */ - { 0x0000, 0x0000, 0x0000 }, /* R8811 */ - { 0x0000, 0x0000, 0x0000 }, /* R8812 */ - { 0x0000, 0x0000, 0x0000 }, /* R8813 */ - { 0x0000, 0x0000, 0x0000 }, /* R8814 */ - { 0x0000, 0x0000, 0x0000 }, /* R8815 */ - { 0x0000, 0x0000, 0x0000 }, /* R8816 */ - { 0x0000, 0x0000, 0x0000 }, /* R8817 */ - { 0x0000, 0x0000, 0x0000 }, /* R8818 */ - { 0x0000, 0x0000, 0x0000 }, /* R8819 */ - { 0x0000, 0x0000, 0x0000 }, /* R8820 */ - { 0x0000, 0x0000, 0x0000 }, /* R8821 */ - { 0x0000, 0x0000, 0x0000 }, /* R8822 */ - { 0x0000, 0x0000, 0x0000 }, /* R8823 */ - { 0x0000, 0x0000, 0x0000 }, /* R8824 */ - { 0x0000, 0x0000, 0x0000 }, /* R8825 */ - { 0x0000, 0x0000, 0x0000 }, /* R8826 */ - { 0x0000, 0x0000, 0x0000 }, /* R8827 */ - { 0x0000, 0x0000, 0x0000 }, /* R8828 */ - { 0x0000, 0x0000, 0x0000 }, /* R8829 */ - { 0x0000, 0x0000, 0x0000 }, /* R8830 */ - { 0x0000, 0x0000, 0x0000 }, /* R8831 */ - { 0x0000, 0x0000, 0x0000 }, /* R8832 */ - { 0x0000, 0x0000, 0x0000 }, /* R8833 */ - { 0x0000, 0x0000, 0x0000 }, /* R8834 */ - { 0x0000, 0x0000, 0x0000 }, /* R8835 */ - { 0x0000, 0x0000, 0x0000 }, /* R8836 */ - { 0x0000, 0x0000, 0x0000 }, /* R8837 */ - { 0x0000, 0x0000, 0x0000 }, /* R8838 */ - { 0x0000, 0x0000, 0x0000 }, /* R8839 */ - { 0x0000, 0x0000, 0x0000 }, /* R8840 */ - { 0x0000, 0x0000, 0x0000 }, /* R8841 */ - { 0x0000, 0x0000, 0x0000 }, /* R8842 */ - { 0x0000, 0x0000, 0x0000 }, /* R8843 */ - { 0x0000, 0x0000, 0x0000 }, /* R8844 */ - { 0x0000, 0x0000, 0x0000 }, /* R8845 */ - { 0x0000, 0x0000, 0x0000 }, /* R8846 */ - { 0x0000, 0x0000, 0x0000 }, /* R8847 */ - { 0x0000, 0x0000, 0x0000 }, /* R8848 */ - { 0x0000, 0x0000, 0x0000 }, /* R8849 */ - { 0x0000, 0x0000, 0x0000 }, /* R8850 */ - { 0x0000, 0x0000, 0x0000 }, /* R8851 */ - { 0x0000, 0x0000, 0x0000 }, /* R8852 */ - { 0x0000, 0x0000, 0x0000 }, /* R8853 */ - { 0x0000, 0x0000, 0x0000 }, /* R8854 */ - { 0x0000, 0x0000, 0x0000 }, /* R8855 */ - { 0x0000, 0x0000, 0x0000 }, /* R8856 */ - { 0x0000, 0x0000, 0x0000 }, /* R8857 */ - { 0x0000, 0x0000, 0x0000 }, /* R8858 */ - { 0x0000, 0x0000, 0x0000 }, /* R8859 */ - { 0x0000, 0x0000, 0x0000 }, /* R8860 */ - { 0x0000, 0x0000, 0x0000 }, /* R8861 */ - { 0x0000, 0x0000, 0x0000 }, /* R8862 */ - { 0x0000, 0x0000, 0x0000 }, /* R8863 */ - { 0x0000, 0x0000, 0x0000 }, /* R8864 */ - { 0x0000, 0x0000, 0x0000 }, /* R8865 */ - { 0x0000, 0x0000, 0x0000 }, /* R8866 */ - { 0x0000, 0x0000, 0x0000 }, /* R8867 */ - { 0x0000, 0x0000, 0x0000 }, /* R8868 */ - { 0x0000, 0x0000, 0x0000 }, /* R8869 */ - { 0x0000, 0x0000, 0x0000 }, /* R8870 */ - { 0x0000, 0x0000, 0x0000 }, /* R8871 */ - { 0x0000, 0x0000, 0x0000 }, /* R8872 */ - { 0x0000, 0x0000, 0x0000 }, /* R8873 */ - { 0x0000, 0x0000, 0x0000 }, /* R8874 */ - { 0x0000, 0x0000, 0x0000 }, /* R8875 */ - { 0x0000, 0x0000, 0x0000 }, /* R8876 */ - { 0x0000, 0x0000, 0x0000 }, /* R8877 */ - { 0x0000, 0x0000, 0x0000 }, /* R8878 */ - { 0x0000, 0x0000, 0x0000 }, /* R8879 */ - { 0x0000, 0x0000, 0x0000 }, /* R8880 */ - { 0x0000, 0x0000, 0x0000 }, /* R8881 */ - { 0x0000, 0x0000, 0x0000 }, /* R8882 */ - { 0x0000, 0x0000, 0x0000 }, /* R8883 */ - { 0x0000, 0x0000, 0x0000 }, /* R8884 */ - { 0x0000, 0x0000, 0x0000 }, /* R8885 */ - { 0x0000, 0x0000, 0x0000 }, /* R8886 */ - { 0x0000, 0x0000, 0x0000 }, /* R8887 */ - { 0x0000, 0x0000, 0x0000 }, /* R8888 */ - { 0x0000, 0x0000, 0x0000 }, /* R8889 */ - { 0x0000, 0x0000, 0x0000 }, /* R8890 */ - { 0x0000, 0x0000, 0x0000 }, /* R8891 */ - { 0x0000, 0x0000, 0x0000 }, /* R8892 */ - { 0x0000, 0x0000, 0x0000 }, /* R8893 */ - { 0x0000, 0x0000, 0x0000 }, /* R8894 */ - { 0x0000, 0x0000, 0x0000 }, /* R8895 */ - { 0x0000, 0x0000, 0x0000 }, /* R8896 */ - { 0x0000, 0x0000, 0x0000 }, /* R8897 */ - { 0x0000, 0x0000, 0x0000 }, /* R8898 */ - { 0x0000, 0x0000, 0x0000 }, /* R8899 */ - { 0x0000, 0x0000, 0x0000 }, /* R8900 */ - { 0x0000, 0x0000, 0x0000 }, /* R8901 */ - { 0x0000, 0x0000, 0x0000 }, /* R8902 */ - { 0x0000, 0x0000, 0x0000 }, /* R8903 */ - { 0x0000, 0x0000, 0x0000 }, /* R8904 */ - { 0x0000, 0x0000, 0x0000 }, /* R8905 */ - { 0x0000, 0x0000, 0x0000 }, /* R8906 */ - { 0x0000, 0x0000, 0x0000 }, /* R8907 */ - { 0x0000, 0x0000, 0x0000 }, /* R8908 */ - { 0x0000, 0x0000, 0x0000 }, /* R8909 */ - { 0x0000, 0x0000, 0x0000 }, /* R8910 */ - { 0x0000, 0x0000, 0x0000 }, /* R8911 */ - { 0x0000, 0x0000, 0x0000 }, /* R8912 */ - { 0x0000, 0x0000, 0x0000 }, /* R8913 */ - { 0x0000, 0x0000, 0x0000 }, /* R8914 */ - { 0x0000, 0x0000, 0x0000 }, /* R8915 */ - { 0x0000, 0x0000, 0x0000 }, /* R8916 */ - { 0x0000, 0x0000, 0x0000 }, /* R8917 */ - { 0x0000, 0x0000, 0x0000 }, /* R8918 */ - { 0x0000, 0x0000, 0x0000 }, /* R8919 */ - { 0x0000, 0x0000, 0x0000 }, /* R8920 */ - { 0x0000, 0x0000, 0x0000 }, /* R8921 */ - { 0x0000, 0x0000, 0x0000 }, /* R8922 */ - { 0x0000, 0x0000, 0x0000 }, /* R8923 */ - { 0x0000, 0x0000, 0x0000 }, /* R8924 */ - { 0x0000, 0x0000, 0x0000 }, /* R8925 */ - { 0x0000, 0x0000, 0x0000 }, /* R8926 */ - { 0x0000, 0x0000, 0x0000 }, /* R8927 */ - { 0x0000, 0x0000, 0x0000 }, /* R8928 */ - { 0x0000, 0x0000, 0x0000 }, /* R8929 */ - { 0x0000, 0x0000, 0x0000 }, /* R8930 */ - { 0x0000, 0x0000, 0x0000 }, /* R8931 */ - { 0x0000, 0x0000, 0x0000 }, /* R8932 */ - { 0x0000, 0x0000, 0x0000 }, /* R8933 */ - { 0x0000, 0x0000, 0x0000 }, /* R8934 */ - { 0x0000, 0x0000, 0x0000 }, /* R8935 */ - { 0x0000, 0x0000, 0x0000 }, /* R8936 */ - { 0x0000, 0x0000, 0x0000 }, /* R8937 */ - { 0x0000, 0x0000, 0x0000 }, /* R8938 */ - { 0x0000, 0x0000, 0x0000 }, /* R8939 */ - { 0x0000, 0x0000, 0x0000 }, /* R8940 */ - { 0x0000, 0x0000, 0x0000 }, /* R8941 */ - { 0x0000, 0x0000, 0x0000 }, /* R8942 */ - { 0x0000, 0x0000, 0x0000 }, /* R8943 */ - { 0x0000, 0x0000, 0x0000 }, /* R8944 */ - { 0x0000, 0x0000, 0x0000 }, /* R8945 */ - { 0x0000, 0x0000, 0x0000 }, /* R8946 */ - { 0x0000, 0x0000, 0x0000 }, /* R8947 */ - { 0x0000, 0x0000, 0x0000 }, /* R8948 */ - { 0x0000, 0x0000, 0x0000 }, /* R8949 */ - { 0x0000, 0x0000, 0x0000 }, /* R8950 */ - { 0x0000, 0x0000, 0x0000 }, /* R8951 */ - { 0x0000, 0x0000, 0x0000 }, /* R8952 */ - { 0x0000, 0x0000, 0x0000 }, /* R8953 */ - { 0x0000, 0x0000, 0x0000 }, /* R8954 */ - { 0x0000, 0x0000, 0x0000 }, /* R8955 */ - { 0x0000, 0x0000, 0x0000 }, /* R8956 */ - { 0x0000, 0x0000, 0x0000 }, /* R8957 */ - { 0x0000, 0x0000, 0x0000 }, /* R8958 */ - { 0x0000, 0x0000, 0x0000 }, /* R8959 */ - { 0x0000, 0x0000, 0x0000 }, /* R8960 */ - { 0x0000, 0x0000, 0x0000 }, /* R8961 */ - { 0x0000, 0x0000, 0x0000 }, /* R8962 */ - { 0x0000, 0x0000, 0x0000 }, /* R8963 */ - { 0x0000, 0x0000, 0x0000 }, /* R8964 */ - { 0x0000, 0x0000, 0x0000 }, /* R8965 */ - { 0x0000, 0x0000, 0x0000 }, /* R8966 */ - { 0x0000, 0x0000, 0x0000 }, /* R8967 */ - { 0x0000, 0x0000, 0x0000 }, /* R8968 */ - { 0x0000, 0x0000, 0x0000 }, /* R8969 */ - { 0x0000, 0x0000, 0x0000 }, /* R8970 */ - { 0x0000, 0x0000, 0x0000 }, /* R8971 */ - { 0x0000, 0x0000, 0x0000 }, /* R8972 */ - { 0x0000, 0x0000, 0x0000 }, /* R8973 */ - { 0x0000, 0x0000, 0x0000 }, /* R8974 */ - { 0x0000, 0x0000, 0x0000 }, /* R8975 */ - { 0x0000, 0x0000, 0x0000 }, /* R8976 */ - { 0x0000, 0x0000, 0x0000 }, /* R8977 */ - { 0x0000, 0x0000, 0x0000 }, /* R8978 */ - { 0x0000, 0x0000, 0x0000 }, /* R8979 */ - { 0x0000, 0x0000, 0x0000 }, /* R8980 */ - { 0x0000, 0x0000, 0x0000 }, /* R8981 */ - { 0x0000, 0x0000, 0x0000 }, /* R8982 */ - { 0x0000, 0x0000, 0x0000 }, /* R8983 */ - { 0x0000, 0x0000, 0x0000 }, /* R8984 */ - { 0x0000, 0x0000, 0x0000 }, /* R8985 */ - { 0x0000, 0x0000, 0x0000 }, /* R8986 */ - { 0x0000, 0x0000, 0x0000 }, /* R8987 */ - { 0x0000, 0x0000, 0x0000 }, /* R8988 */ - { 0x0000, 0x0000, 0x0000 }, /* R8989 */ - { 0x0000, 0x0000, 0x0000 }, /* R8990 */ - { 0x0000, 0x0000, 0x0000 }, /* R8991 */ - { 0x0000, 0x0000, 0x0000 }, /* R8992 */ - { 0x0000, 0x0000, 0x0000 }, /* R8993 */ - { 0x0000, 0x0000, 0x0000 }, /* R8994 */ - { 0x0000, 0x0000, 0x0000 }, /* R8995 */ - { 0x0000, 0x0000, 0x0000 }, /* R8996 */ - { 0x0000, 0x0000, 0x0000 }, /* R8997 */ - { 0x0000, 0x0000, 0x0000 }, /* R8998 */ - { 0x0000, 0x0000, 0x0000 }, /* R8999 */ - { 0x0000, 0x0000, 0x0000 }, /* R9000 */ - { 0x0000, 0x0000, 0x0000 }, /* R9001 */ - { 0x0000, 0x0000, 0x0000 }, /* R9002 */ - { 0x0000, 0x0000, 0x0000 }, /* R9003 */ - { 0x0000, 0x0000, 0x0000 }, /* R9004 */ - { 0x0000, 0x0000, 0x0000 }, /* R9005 */ - { 0x0000, 0x0000, 0x0000 }, /* R9006 */ - { 0x0000, 0x0000, 0x0000 }, /* R9007 */ - { 0x0000, 0x0000, 0x0000 }, /* R9008 */ - { 0x0000, 0x0000, 0x0000 }, /* R9009 */ - { 0x0000, 0x0000, 0x0000 }, /* R9010 */ - { 0x0000, 0x0000, 0x0000 }, /* R9011 */ - { 0x0000, 0x0000, 0x0000 }, /* R9012 */ - { 0x0000, 0x0000, 0x0000 }, /* R9013 */ - { 0x0000, 0x0000, 0x0000 }, /* R9014 */ - { 0x0000, 0x0000, 0x0000 }, /* R9015 */ - { 0x0000, 0x0000, 0x0000 }, /* R9016 */ - { 0x0000, 0x0000, 0x0000 }, /* R9017 */ - { 0x0000, 0x0000, 0x0000 }, /* R9018 */ - { 0x0000, 0x0000, 0x0000 }, /* R9019 */ - { 0x0000, 0x0000, 0x0000 }, /* R9020 */ - { 0x0000, 0x0000, 0x0000 }, /* R9021 */ - { 0x0000, 0x0000, 0x0000 }, /* R9022 */ - { 0x0000, 0x0000, 0x0000 }, /* R9023 */ - { 0x0000, 0x0000, 0x0000 }, /* R9024 */ - { 0x0000, 0x0000, 0x0000 }, /* R9025 */ - { 0x0000, 0x0000, 0x0000 }, /* R9026 */ - { 0x0000, 0x0000, 0x0000 }, /* R9027 */ - { 0x0000, 0x0000, 0x0000 }, /* R9028 */ - { 0x0000, 0x0000, 0x0000 }, /* R9029 */ - { 0x0000, 0x0000, 0x0000 }, /* R9030 */ - { 0x0000, 0x0000, 0x0000 }, /* R9031 */ - { 0x0000, 0x0000, 0x0000 }, /* R9032 */ - { 0x0000, 0x0000, 0x0000 }, /* R9033 */ - { 0x0000, 0x0000, 0x0000 }, /* R9034 */ - { 0x0000, 0x0000, 0x0000 }, /* R9035 */ - { 0x0000, 0x0000, 0x0000 }, /* R9036 */ - { 0x0000, 0x0000, 0x0000 }, /* R9037 */ - { 0x0000, 0x0000, 0x0000 }, /* R9038 */ - { 0x0000, 0x0000, 0x0000 }, /* R9039 */ - { 0x0000, 0x0000, 0x0000 }, /* R9040 */ - { 0x0000, 0x0000, 0x0000 }, /* R9041 */ - { 0x0000, 0x0000, 0x0000 }, /* R9042 */ - { 0x0000, 0x0000, 0x0000 }, /* R9043 */ - { 0x0000, 0x0000, 0x0000 }, /* R9044 */ - { 0x0000, 0x0000, 0x0000 }, /* R9045 */ - { 0x0000, 0x0000, 0x0000 }, /* R9046 */ - { 0x0000, 0x0000, 0x0000 }, /* R9047 */ - { 0x0000, 0x0000, 0x0000 }, /* R9048 */ - { 0x0000, 0x0000, 0x0000 }, /* R9049 */ - { 0x0000, 0x0000, 0x0000 }, /* R9050 */ - { 0x0000, 0x0000, 0x0000 }, /* R9051 */ - { 0x0000, 0x0000, 0x0000 }, /* R9052 */ - { 0x0000, 0x0000, 0x0000 }, /* R9053 */ - { 0x0000, 0x0000, 0x0000 }, /* R9054 */ - { 0x0000, 0x0000, 0x0000 }, /* R9055 */ - { 0x0000, 0x0000, 0x0000 }, /* R9056 */ - { 0x0000, 0x0000, 0x0000 }, /* R9057 */ - { 0x0000, 0x0000, 0x0000 }, /* R9058 */ - { 0x0000, 0x0000, 0x0000 }, /* R9059 */ - { 0x0000, 0x0000, 0x0000 }, /* R9060 */ - { 0x0000, 0x0000, 0x0000 }, /* R9061 */ - { 0x0000, 0x0000, 0x0000 }, /* R9062 */ - { 0x0000, 0x0000, 0x0000 }, /* R9063 */ - { 0x0000, 0x0000, 0x0000 }, /* R9064 */ - { 0x0000, 0x0000, 0x0000 }, /* R9065 */ - { 0x0000, 0x0000, 0x0000 }, /* R9066 */ - { 0x0000, 0x0000, 0x0000 }, /* R9067 */ - { 0x0000, 0x0000, 0x0000 }, /* R9068 */ - { 0x0000, 0x0000, 0x0000 }, /* R9069 */ - { 0x0000, 0x0000, 0x0000 }, /* R9070 */ - { 0x0000, 0x0000, 0x0000 }, /* R9071 */ - { 0x0000, 0x0000, 0x0000 }, /* R9072 */ - { 0x0000, 0x0000, 0x0000 }, /* R9073 */ - { 0x0000, 0x0000, 0x0000 }, /* R9074 */ - { 0x0000, 0x0000, 0x0000 }, /* R9075 */ - { 0x0000, 0x0000, 0x0000 }, /* R9076 */ - { 0x0000, 0x0000, 0x0000 }, /* R9077 */ - { 0x0000, 0x0000, 0x0000 }, /* R9078 */ - { 0x0000, 0x0000, 0x0000 }, /* R9079 */ - { 0x0000, 0x0000, 0x0000 }, /* R9080 */ - { 0x0000, 0x0000, 0x0000 }, /* R9081 */ - { 0x0000, 0x0000, 0x0000 }, /* R9082 */ - { 0x0000, 0x0000, 0x0000 }, /* R9083 */ - { 0x0000, 0x0000, 0x0000 }, /* R9084 */ - { 0x0000, 0x0000, 0x0000 }, /* R9085 */ - { 0x0000, 0x0000, 0x0000 }, /* R9086 */ - { 0x0000, 0x0000, 0x0000 }, /* R9087 */ - { 0x0000, 0x0000, 0x0000 }, /* R9088 */ - { 0x0000, 0x0000, 0x0000 }, /* R9089 */ - { 0x0000, 0x0000, 0x0000 }, /* R9090 */ - { 0x0000, 0x0000, 0x0000 }, /* R9091 */ - { 0x0000, 0x0000, 0x0000 }, /* R9092 */ - { 0x0000, 0x0000, 0x0000 }, /* R9093 */ - { 0x0000, 0x0000, 0x0000 }, /* R9094 */ - { 0x0000, 0x0000, 0x0000 }, /* R9095 */ - { 0x0000, 0x0000, 0x0000 }, /* R9096 */ - { 0x0000, 0x0000, 0x0000 }, /* R9097 */ - { 0x0000, 0x0000, 0x0000 }, /* R9098 */ - { 0x0000, 0x0000, 0x0000 }, /* R9099 */ - { 0x0000, 0x0000, 0x0000 }, /* R9100 */ - { 0x0000, 0x0000, 0x0000 }, /* R9101 */ - { 0x0000, 0x0000, 0x0000 }, /* R9102 */ - { 0x0000, 0x0000, 0x0000 }, /* R9103 */ - { 0x0000, 0x0000, 0x0000 }, /* R9104 */ - { 0x0000, 0x0000, 0x0000 }, /* R9105 */ - { 0x0000, 0x0000, 0x0000 }, /* R9106 */ - { 0x0000, 0x0000, 0x0000 }, /* R9107 */ - { 0x0000, 0x0000, 0x0000 }, /* R9108 */ - { 0x0000, 0x0000, 0x0000 }, /* R9109 */ - { 0x0000, 0x0000, 0x0000 }, /* R9110 */ - { 0x0000, 0x0000, 0x0000 }, /* R9111 */ - { 0x0000, 0x0000, 0x0000 }, /* R9112 */ - { 0x0000, 0x0000, 0x0000 }, /* R9113 */ - { 0x0000, 0x0000, 0x0000 }, /* R9114 */ - { 0x0000, 0x0000, 0x0000 }, /* R9115 */ - { 0x0000, 0x0000, 0x0000 }, /* R9116 */ - { 0x0000, 0x0000, 0x0000 }, /* R9117 */ - { 0x0000, 0x0000, 0x0000 }, /* R9118 */ - { 0x0000, 0x0000, 0x0000 }, /* R9119 */ - { 0x0000, 0x0000, 0x0000 }, /* R9120 */ - { 0x0000, 0x0000, 0x0000 }, /* R9121 */ - { 0x0000, 0x0000, 0x0000 }, /* R9122 */ - { 0x0000, 0x0000, 0x0000 }, /* R9123 */ - { 0x0000, 0x0000, 0x0000 }, /* R9124 */ - { 0x0000, 0x0000, 0x0000 }, /* R9125 */ - { 0x0000, 0x0000, 0x0000 }, /* R9126 */ - { 0x0000, 0x0000, 0x0000 }, /* R9127 */ - { 0x0000, 0x0000, 0x0000 }, /* R9128 */ - { 0x0000, 0x0000, 0x0000 }, /* R9129 */ - { 0x0000, 0x0000, 0x0000 }, /* R9130 */ - { 0x0000, 0x0000, 0x0000 }, /* R9131 */ - { 0x0000, 0x0000, 0x0000 }, /* R9132 */ - { 0x0000, 0x0000, 0x0000 }, /* R9133 */ - { 0x0000, 0x0000, 0x0000 }, /* R9134 */ - { 0x0000, 0x0000, 0x0000 }, /* R9135 */ - { 0x0000, 0x0000, 0x0000 }, /* R9136 */ - { 0x0000, 0x0000, 0x0000 }, /* R9137 */ - { 0x0000, 0x0000, 0x0000 }, /* R9138 */ - { 0x0000, 0x0000, 0x0000 }, /* R9139 */ - { 0x0000, 0x0000, 0x0000 }, /* R9140 */ - { 0x0000, 0x0000, 0x0000 }, /* R9141 */ - { 0x0000, 0x0000, 0x0000 }, /* R9142 */ - { 0x0000, 0x0000, 0x0000 }, /* R9143 */ - { 0x0000, 0x0000, 0x0000 }, /* R9144 */ - { 0x0000, 0x0000, 0x0000 }, /* R9145 */ - { 0x0000, 0x0000, 0x0000 }, /* R9146 */ - { 0x0000, 0x0000, 0x0000 }, /* R9147 */ - { 0x0000, 0x0000, 0x0000 }, /* R9148 */ - { 0x0000, 0x0000, 0x0000 }, /* R9149 */ - { 0x0000, 0x0000, 0x0000 }, /* R9150 */ - { 0x0000, 0x0000, 0x0000 }, /* R9151 */ - { 0x0000, 0x0000, 0x0000 }, /* R9152 */ - { 0x0000, 0x0000, 0x0000 }, /* R9153 */ - { 0x0000, 0x0000, 0x0000 }, /* R9154 */ - { 0x0000, 0x0000, 0x0000 }, /* R9155 */ - { 0x0000, 0x0000, 0x0000 }, /* R9156 */ - { 0x0000, 0x0000, 0x0000 }, /* R9157 */ - { 0x0000, 0x0000, 0x0000 }, /* R9158 */ - { 0x0000, 0x0000, 0x0000 }, /* R9159 */ - { 0x0000, 0x0000, 0x0000 }, /* R9160 */ - { 0x0000, 0x0000, 0x0000 }, /* R9161 */ - { 0x0000, 0x0000, 0x0000 }, /* R9162 */ - { 0x0000, 0x0000, 0x0000 }, /* R9163 */ - { 0x0000, 0x0000, 0x0000 }, /* R9164 */ - { 0x0000, 0x0000, 0x0000 }, /* R9165 */ - { 0x0000, 0x0000, 0x0000 }, /* R9166 */ - { 0x0000, 0x0000, 0x0000 }, /* R9167 */ - { 0x0000, 0x0000, 0x0000 }, /* R9168 */ - { 0x0000, 0x0000, 0x0000 }, /* R9169 */ - { 0x0000, 0x0000, 0x0000 }, /* R9170 */ - { 0x0000, 0x0000, 0x0000 }, /* R9171 */ - { 0x0000, 0x0000, 0x0000 }, /* R9172 */ - { 0x0000, 0x0000, 0x0000 }, /* R9173 */ - { 0x0000, 0x0000, 0x0000 }, /* R9174 */ - { 0x0000, 0x0000, 0x0000 }, /* R9175 */ - { 0x0000, 0x0000, 0x0000 }, /* R9176 */ - { 0x0000, 0x0000, 0x0000 }, /* R9177 */ - { 0x0000, 0x0000, 0x0000 }, /* R9178 */ - { 0x0000, 0x0000, 0x0000 }, /* R9179 */ - { 0x0000, 0x0000, 0x0000 }, /* R9180 */ - { 0x0000, 0x0000, 0x0000 }, /* R9181 */ - { 0x0000, 0x0000, 0x0000 }, /* R9182 */ - { 0x0000, 0x0000, 0x0000 }, /* R9183 */ - { 0x0000, 0x0000, 0x0000 }, /* R9184 */ - { 0x0000, 0x0000, 0x0000 }, /* R9185 */ - { 0x0000, 0x0000, 0x0000 }, /* R9186 */ - { 0x0000, 0x0000, 0x0000 }, /* R9187 */ - { 0x0000, 0x0000, 0x0000 }, /* R9188 */ - { 0x0000, 0x0000, 0x0000 }, /* R9189 */ - { 0x0000, 0x0000, 0x0000 }, /* R9190 */ - { 0x0000, 0x0000, 0x0000 }, /* R9191 */ - { 0x0000, 0x0000, 0x0000 }, /* R9192 */ - { 0x0000, 0x0000, 0x0000 }, /* R9193 */ - { 0x0000, 0x0000, 0x0000 }, /* R9194 */ - { 0x0000, 0x0000, 0x0000 }, /* R9195 */ - { 0x0000, 0x0000, 0x0000 }, /* R9196 */ - { 0x0000, 0x0000, 0x0000 }, /* R9197 */ - { 0x0000, 0x0000, 0x0000 }, /* R9198 */ - { 0x0000, 0x0000, 0x0000 }, /* R9199 */ - { 0x0000, 0x0000, 0x0000 }, /* R9200 */ - { 0x0000, 0x0000, 0x0000 }, /* R9201 */ - { 0x0000, 0x0000, 0x0000 }, /* R9202 */ - { 0x0000, 0x0000, 0x0000 }, /* R9203 */ - { 0x0000, 0x0000, 0x0000 }, /* R9204 */ - { 0x0000, 0x0000, 0x0000 }, /* R9205 */ - { 0x0000, 0x0000, 0x0000 }, /* R9206 */ - { 0x0000, 0x0000, 0x0000 }, /* R9207 */ - { 0x0000, 0x0000, 0x0000 }, /* R9208 */ - { 0x0000, 0x0000, 0x0000 }, /* R9209 */ - { 0x0000, 0x0000, 0x0000 }, /* R9210 */ - { 0x0000, 0x0000, 0x0000 }, /* R9211 */ - { 0x0000, 0x0000, 0x0000 }, /* R9212 */ - { 0x0000, 0x0000, 0x0000 }, /* R9213 */ - { 0x0000, 0x0000, 0x0000 }, /* R9214 */ - { 0x0000, 0x0000, 0x0000 }, /* R9215 */ - { 0x003F, 0x003F, 0x0000 }, /* R9216 - DSP2 Address RAM 2 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R9217 - DSP2 Address RAM 1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R9218 - DSP2 Address RAM 0 */ - { 0x0000, 0x0000, 0x0000 }, /* R9219 */ - { 0x0000, 0x0000, 0x0000 }, /* R9220 */ - { 0x0000, 0x0000, 0x0000 }, /* R9221 */ - { 0x0000, 0x0000, 0x0000 }, /* R9222 */ - { 0x0000, 0x0000, 0x0000 }, /* R9223 */ - { 0x0000, 0x0000, 0x0000 }, /* R9224 */ - { 0x0000, 0x0000, 0x0000 }, /* R9225 */ - { 0x0000, 0x0000, 0x0000 }, /* R9226 */ - { 0x0000, 0x0000, 0x0000 }, /* R9227 */ - { 0x0000, 0x0000, 0x0000 }, /* R9228 */ - { 0x0000, 0x0000, 0x0000 }, /* R9229 */ - { 0x0000, 0x0000, 0x0000 }, /* R9230 */ - { 0x0000, 0x0000, 0x0000 }, /* R9231 */ - { 0x0000, 0x0000, 0x0000 }, /* R9232 */ - { 0x0000, 0x0000, 0x0000 }, /* R9233 */ - { 0x0000, 0x0000, 0x0000 }, /* R9234 */ - { 0x0000, 0x0000, 0x0000 }, /* R9235 */ - { 0x0000, 0x0000, 0x0000 }, /* R9236 */ - { 0x0000, 0x0000, 0x0000 }, /* R9237 */ - { 0x0000, 0x0000, 0x0000 }, /* R9238 */ - { 0x0000, 0x0000, 0x0000 }, /* R9239 */ - { 0x0000, 0x0000, 0x0000 }, /* R9240 */ - { 0x0000, 0x0000, 0x0000 }, /* R9241 */ - { 0x0000, 0x0000, 0x0000 }, /* R9242 */ - { 0x0000, 0x0000, 0x0000 }, /* R9243 */ - { 0x0000, 0x0000, 0x0000 }, /* R9244 */ - { 0x0000, 0x0000, 0x0000 }, /* R9245 */ - { 0x0000, 0x0000, 0x0000 }, /* R9246 */ - { 0x0000, 0x0000, 0x0000 }, /* R9247 */ - { 0x0000, 0x0000, 0x0000 }, /* R9248 */ - { 0x0000, 0x0000, 0x0000 }, /* R9249 */ - { 0x0000, 0x0000, 0x0000 }, /* R9250 */ - { 0x0000, 0x0000, 0x0000 }, /* R9251 */ - { 0x0000, 0x0000, 0x0000 }, /* R9252 */ - { 0x0000, 0x0000, 0x0000 }, /* R9253 */ - { 0x0000, 0x0000, 0x0000 }, /* R9254 */ - { 0x0000, 0x0000, 0x0000 }, /* R9255 */ - { 0x0000, 0x0000, 0x0000 }, /* R9256 */ - { 0x0000, 0x0000, 0x0000 }, /* R9257 */ - { 0x0000, 0x0000, 0x0000 }, /* R9258 */ - { 0x0000, 0x0000, 0x0000 }, /* R9259 */ - { 0x0000, 0x0000, 0x0000 }, /* R9260 */ - { 0x0000, 0x0000, 0x0000 }, /* R9261 */ - { 0x0000, 0x0000, 0x0000 }, /* R9262 */ - { 0x0000, 0x0000, 0x0000 }, /* R9263 */ - { 0x0000, 0x0000, 0x0000 }, /* R9264 */ - { 0x0000, 0x0000, 0x0000 }, /* R9265 */ - { 0x0000, 0x0000, 0x0000 }, /* R9266 */ - { 0x0000, 0x0000, 0x0000 }, /* R9267 */ - { 0x0000, 0x0000, 0x0000 }, /* R9268 */ - { 0x0000, 0x0000, 0x0000 }, /* R9269 */ - { 0x0000, 0x0000, 0x0000 }, /* R9270 */ - { 0x0000, 0x0000, 0x0000 }, /* R9271 */ - { 0x0000, 0x0000, 0x0000 }, /* R9272 */ - { 0x0000, 0x0000, 0x0000 }, /* R9273 */ - { 0x0000, 0x0000, 0x0000 }, /* R9274 */ - { 0x0000, 0x0000, 0x0000 }, /* R9275 */ - { 0x0000, 0x0000, 0x0000 }, /* R9276 */ - { 0x0000, 0x0000, 0x0000 }, /* R9277 */ - { 0x0000, 0x0000, 0x0000 }, /* R9278 */ - { 0x0000, 0x0000, 0x0000 }, /* R9279 */ - { 0x0000, 0x0000, 0x0000 }, /* R9280 */ - { 0x0000, 0x0000, 0x0000 }, /* R9281 */ - { 0x0000, 0x0000, 0x0000 }, /* R9282 */ - { 0x0000, 0x0000, 0x0000 }, /* R9283 */ - { 0x0000, 0x0000, 0x0000 }, /* R9284 */ - { 0x0000, 0x0000, 0x0000 }, /* R9285 */ - { 0x0000, 0x0000, 0x0000 }, /* R9286 */ - { 0x0000, 0x0000, 0x0000 }, /* R9287 */ - { 0x0000, 0x0000, 0x0000 }, /* R9288 */ - { 0x0000, 0x0000, 0x0000 }, /* R9289 */ - { 0x0000, 0x0000, 0x0000 }, /* R9290 */ - { 0x0000, 0x0000, 0x0000 }, /* R9291 */ - { 0x0000, 0x0000, 0x0000 }, /* R9292 */ - { 0x0000, 0x0000, 0x0000 }, /* R9293 */ - { 0x0000, 0x0000, 0x0000 }, /* R9294 */ - { 0x0000, 0x0000, 0x0000 }, /* R9295 */ - { 0x0000, 0x0000, 0x0000 }, /* R9296 */ - { 0x0000, 0x0000, 0x0000 }, /* R9297 */ - { 0x0000, 0x0000, 0x0000 }, /* R9298 */ - { 0x0000, 0x0000, 0x0000 }, /* R9299 */ - { 0x0000, 0x0000, 0x0000 }, /* R9300 */ - { 0x0000, 0x0000, 0x0000 }, /* R9301 */ - { 0x0000, 0x0000, 0x0000 }, /* R9302 */ - { 0x0000, 0x0000, 0x0000 }, /* R9303 */ - { 0x0000, 0x0000, 0x0000 }, /* R9304 */ - { 0x0000, 0x0000, 0x0000 }, /* R9305 */ - { 0x0000, 0x0000, 0x0000 }, /* R9306 */ - { 0x0000, 0x0000, 0x0000 }, /* R9307 */ - { 0x0000, 0x0000, 0x0000 }, /* R9308 */ - { 0x0000, 0x0000, 0x0000 }, /* R9309 */ - { 0x0000, 0x0000, 0x0000 }, /* R9310 */ - { 0x0000, 0x0000, 0x0000 }, /* R9311 */ - { 0x0000, 0x0000, 0x0000 }, /* R9312 */ - { 0x0000, 0x0000, 0x0000 }, /* R9313 */ - { 0x0000, 0x0000, 0x0000 }, /* R9314 */ - { 0x0000, 0x0000, 0x0000 }, /* R9315 */ - { 0x0000, 0x0000, 0x0000 }, /* R9316 */ - { 0x0000, 0x0000, 0x0000 }, /* R9317 */ - { 0x0000, 0x0000, 0x0000 }, /* R9318 */ - { 0x0000, 0x0000, 0x0000 }, /* R9319 */ - { 0x0000, 0x0000, 0x0000 }, /* R9320 */ - { 0x0000, 0x0000, 0x0000 }, /* R9321 */ - { 0x0000, 0x0000, 0x0000 }, /* R9322 */ - { 0x0000, 0x0000, 0x0000 }, /* R9323 */ - { 0x0000, 0x0000, 0x0000 }, /* R9324 */ - { 0x0000, 0x0000, 0x0000 }, /* R9325 */ - { 0x0000, 0x0000, 0x0000 }, /* R9326 */ - { 0x0000, 0x0000, 0x0000 }, /* R9327 */ - { 0x0000, 0x0000, 0x0000 }, /* R9328 */ - { 0x0000, 0x0000, 0x0000 }, /* R9329 */ - { 0x0000, 0x0000, 0x0000 }, /* R9330 */ - { 0x0000, 0x0000, 0x0000 }, /* R9331 */ - { 0x0000, 0x0000, 0x0000 }, /* R9332 */ - { 0x0000, 0x0000, 0x0000 }, /* R9333 */ - { 0x0000, 0x0000, 0x0000 }, /* R9334 */ - { 0x0000, 0x0000, 0x0000 }, /* R9335 */ - { 0x0000, 0x0000, 0x0000 }, /* R9336 */ - { 0x0000, 0x0000, 0x0000 }, /* R9337 */ - { 0x0000, 0x0000, 0x0000 }, /* R9338 */ - { 0x0000, 0x0000, 0x0000 }, /* R9339 */ - { 0x0000, 0x0000, 0x0000 }, /* R9340 */ - { 0x0000, 0x0000, 0x0000 }, /* R9341 */ - { 0x0000, 0x0000, 0x0000 }, /* R9342 */ - { 0x0000, 0x0000, 0x0000 }, /* R9343 */ - { 0x0000, 0x0000, 0x0000 }, /* R9344 */ - { 0x0000, 0x0000, 0x0000 }, /* R9345 */ - { 0x0000, 0x0000, 0x0000 }, /* R9346 */ - { 0x0000, 0x0000, 0x0000 }, /* R9347 */ - { 0x0000, 0x0000, 0x0000 }, /* R9348 */ - { 0x0000, 0x0000, 0x0000 }, /* R9349 */ - { 0x0000, 0x0000, 0x0000 }, /* R9350 */ - { 0x0000, 0x0000, 0x0000 }, /* R9351 */ - { 0x0000, 0x0000, 0x0000 }, /* R9352 */ - { 0x0000, 0x0000, 0x0000 }, /* R9353 */ - { 0x0000, 0x0000, 0x0000 }, /* R9354 */ - { 0x0000, 0x0000, 0x0000 }, /* R9355 */ - { 0x0000, 0x0000, 0x0000 }, /* R9356 */ - { 0x0000, 0x0000, 0x0000 }, /* R9357 */ - { 0x0000, 0x0000, 0x0000 }, /* R9358 */ - { 0x0000, 0x0000, 0x0000 }, /* R9359 */ - { 0x0000, 0x0000, 0x0000 }, /* R9360 */ - { 0x0000, 0x0000, 0x0000 }, /* R9361 */ - { 0x0000, 0x0000, 0x0000 }, /* R9362 */ - { 0x0000, 0x0000, 0x0000 }, /* R9363 */ - { 0x0000, 0x0000, 0x0000 }, /* R9364 */ - { 0x0000, 0x0000, 0x0000 }, /* R9365 */ - { 0x0000, 0x0000, 0x0000 }, /* R9366 */ - { 0x0000, 0x0000, 0x0000 }, /* R9367 */ - { 0x0000, 0x0000, 0x0000 }, /* R9368 */ - { 0x0000, 0x0000, 0x0000 }, /* R9369 */ - { 0x0000, 0x0000, 0x0000 }, /* R9370 */ - { 0x0000, 0x0000, 0x0000 }, /* R9371 */ - { 0x0000, 0x0000, 0x0000 }, /* R9372 */ - { 0x0000, 0x0000, 0x0000 }, /* R9373 */ - { 0x0000, 0x0000, 0x0000 }, /* R9374 */ - { 0x0000, 0x0000, 0x0000 }, /* R9375 */ - { 0x0000, 0x0000, 0x0000 }, /* R9376 */ - { 0x0000, 0x0000, 0x0000 }, /* R9377 */ - { 0x0000, 0x0000, 0x0000 }, /* R9378 */ - { 0x0000, 0x0000, 0x0000 }, /* R9379 */ - { 0x0000, 0x0000, 0x0000 }, /* R9380 */ - { 0x0000, 0x0000, 0x0000 }, /* R9381 */ - { 0x0000, 0x0000, 0x0000 }, /* R9382 */ - { 0x0000, 0x0000, 0x0000 }, /* R9383 */ - { 0x0000, 0x0000, 0x0000 }, /* R9384 */ - { 0x0000, 0x0000, 0x0000 }, /* R9385 */ - { 0x0000, 0x0000, 0x0000 }, /* R9386 */ - { 0x0000, 0x0000, 0x0000 }, /* R9387 */ - { 0x0000, 0x0000, 0x0000 }, /* R9388 */ - { 0x0000, 0x0000, 0x0000 }, /* R9389 */ - { 0x0000, 0x0000, 0x0000 }, /* R9390 */ - { 0x0000, 0x0000, 0x0000 }, /* R9391 */ - { 0x0000, 0x0000, 0x0000 }, /* R9392 */ - { 0x0000, 0x0000, 0x0000 }, /* R9393 */ - { 0x0000, 0x0000, 0x0000 }, /* R9394 */ - { 0x0000, 0x0000, 0x0000 }, /* R9395 */ - { 0x0000, 0x0000, 0x0000 }, /* R9396 */ - { 0x0000, 0x0000, 0x0000 }, /* R9397 */ - { 0x0000, 0x0000, 0x0000 }, /* R9398 */ - { 0x0000, 0x0000, 0x0000 }, /* R9399 */ - { 0x0000, 0x0000, 0x0000 }, /* R9400 */ - { 0x0000, 0x0000, 0x0000 }, /* R9401 */ - { 0x0000, 0x0000, 0x0000 }, /* R9402 */ - { 0x0000, 0x0000, 0x0000 }, /* R9403 */ - { 0x0000, 0x0000, 0x0000 }, /* R9404 */ - { 0x0000, 0x0000, 0x0000 }, /* R9405 */ - { 0x0000, 0x0000, 0x0000 }, /* R9406 */ - { 0x0000, 0x0000, 0x0000 }, /* R9407 */ - { 0x0000, 0x0000, 0x0000 }, /* R9408 */ - { 0x0000, 0x0000, 0x0000 }, /* R9409 */ - { 0x0000, 0x0000, 0x0000 }, /* R9410 */ - { 0x0000, 0x0000, 0x0000 }, /* R9411 */ - { 0x0000, 0x0000, 0x0000 }, /* R9412 */ - { 0x0000, 0x0000, 0x0000 }, /* R9413 */ - { 0x0000, 0x0000, 0x0000 }, /* R9414 */ - { 0x0000, 0x0000, 0x0000 }, /* R9415 */ - { 0x0000, 0x0000, 0x0000 }, /* R9416 */ - { 0x0000, 0x0000, 0x0000 }, /* R9417 */ - { 0x0000, 0x0000, 0x0000 }, /* R9418 */ - { 0x0000, 0x0000, 0x0000 }, /* R9419 */ - { 0x0000, 0x0000, 0x0000 }, /* R9420 */ - { 0x0000, 0x0000, 0x0000 }, /* R9421 */ - { 0x0000, 0x0000, 0x0000 }, /* R9422 */ - { 0x0000, 0x0000, 0x0000 }, /* R9423 */ - { 0x0000, 0x0000, 0x0000 }, /* R9424 */ - { 0x0000, 0x0000, 0x0000 }, /* R9425 */ - { 0x0000, 0x0000, 0x0000 }, /* R9426 */ - { 0x0000, 0x0000, 0x0000 }, /* R9427 */ - { 0x0000, 0x0000, 0x0000 }, /* R9428 */ - { 0x0000, 0x0000, 0x0000 }, /* R9429 */ - { 0x0000, 0x0000, 0x0000 }, /* R9430 */ - { 0x0000, 0x0000, 0x0000 }, /* R9431 */ - { 0x0000, 0x0000, 0x0000 }, /* R9432 */ - { 0x0000, 0x0000, 0x0000 }, /* R9433 */ - { 0x0000, 0x0000, 0x0000 }, /* R9434 */ - { 0x0000, 0x0000, 0x0000 }, /* R9435 */ - { 0x0000, 0x0000, 0x0000 }, /* R9436 */ - { 0x0000, 0x0000, 0x0000 }, /* R9437 */ - { 0x0000, 0x0000, 0x0000 }, /* R9438 */ - { 0x0000, 0x0000, 0x0000 }, /* R9439 */ - { 0x0000, 0x0000, 0x0000 }, /* R9440 */ - { 0x0000, 0x0000, 0x0000 }, /* R9441 */ - { 0x0000, 0x0000, 0x0000 }, /* R9442 */ - { 0x0000, 0x0000, 0x0000 }, /* R9443 */ - { 0x0000, 0x0000, 0x0000 }, /* R9444 */ - { 0x0000, 0x0000, 0x0000 }, /* R9445 */ - { 0x0000, 0x0000, 0x0000 }, /* R9446 */ - { 0x0000, 0x0000, 0x0000 }, /* R9447 */ - { 0x0000, 0x0000, 0x0000 }, /* R9448 */ - { 0x0000, 0x0000, 0x0000 }, /* R9449 */ - { 0x0000, 0x0000, 0x0000 }, /* R9450 */ - { 0x0000, 0x0000, 0x0000 }, /* R9451 */ - { 0x0000, 0x0000, 0x0000 }, /* R9452 */ - { 0x0000, 0x0000, 0x0000 }, /* R9453 */ - { 0x0000, 0x0000, 0x0000 }, /* R9454 */ - { 0x0000, 0x0000, 0x0000 }, /* R9455 */ - { 0x0000, 0x0000, 0x0000 }, /* R9456 */ - { 0x0000, 0x0000, 0x0000 }, /* R9457 */ - { 0x0000, 0x0000, 0x0000 }, /* R9458 */ - { 0x0000, 0x0000, 0x0000 }, /* R9459 */ - { 0x0000, 0x0000, 0x0000 }, /* R9460 */ - { 0x0000, 0x0000, 0x0000 }, /* R9461 */ - { 0x0000, 0x0000, 0x0000 }, /* R9462 */ - { 0x0000, 0x0000, 0x0000 }, /* R9463 */ - { 0x0000, 0x0000, 0x0000 }, /* R9464 */ - { 0x0000, 0x0000, 0x0000 }, /* R9465 */ - { 0x0000, 0x0000, 0x0000 }, /* R9466 */ - { 0x0000, 0x0000, 0x0000 }, /* R9467 */ - { 0x0000, 0x0000, 0x0000 }, /* R9468 */ - { 0x0000, 0x0000, 0x0000 }, /* R9469 */ - { 0x0000, 0x0000, 0x0000 }, /* R9470 */ - { 0x0000, 0x0000, 0x0000 }, /* R9471 */ - { 0x0000, 0x0000, 0x0000 }, /* R9472 */ - { 0x0000, 0x0000, 0x0000 }, /* R9473 */ - { 0x0000, 0x0000, 0x0000 }, /* R9474 */ - { 0x0000, 0x0000, 0x0000 }, /* R9475 */ - { 0x0000, 0x0000, 0x0000 }, /* R9476 */ - { 0x0000, 0x0000, 0x0000 }, /* R9477 */ - { 0x0000, 0x0000, 0x0000 }, /* R9478 */ - { 0x0000, 0x0000, 0x0000 }, /* R9479 */ - { 0x0000, 0x0000, 0x0000 }, /* R9480 */ - { 0x0000, 0x0000, 0x0000 }, /* R9481 */ - { 0x0000, 0x0000, 0x0000 }, /* R9482 */ - { 0x0000, 0x0000, 0x0000 }, /* R9483 */ - { 0x0000, 0x0000, 0x0000 }, /* R9484 */ - { 0x0000, 0x0000, 0x0000 }, /* R9485 */ - { 0x0000, 0x0000, 0x0000 }, /* R9486 */ - { 0x0000, 0x0000, 0x0000 }, /* R9487 */ - { 0x0000, 0x0000, 0x0000 }, /* R9488 */ - { 0x0000, 0x0000, 0x0000 }, /* R9489 */ - { 0x0000, 0x0000, 0x0000 }, /* R9490 */ - { 0x0000, 0x0000, 0x0000 }, /* R9491 */ - { 0x0000, 0x0000, 0x0000 }, /* R9492 */ - { 0x0000, 0x0000, 0x0000 }, /* R9493 */ - { 0x0000, 0x0000, 0x0000 }, /* R9494 */ - { 0x0000, 0x0000, 0x0000 }, /* R9495 */ - { 0x0000, 0x0000, 0x0000 }, /* R9496 */ - { 0x0000, 0x0000, 0x0000 }, /* R9497 */ - { 0x0000, 0x0000, 0x0000 }, /* R9498 */ - { 0x0000, 0x0000, 0x0000 }, /* R9499 */ - { 0x0000, 0x0000, 0x0000 }, /* R9500 */ - { 0x0000, 0x0000, 0x0000 }, /* R9501 */ - { 0x0000, 0x0000, 0x0000 }, /* R9502 */ - { 0x0000, 0x0000, 0x0000 }, /* R9503 */ - { 0x0000, 0x0000, 0x0000 }, /* R9504 */ - { 0x0000, 0x0000, 0x0000 }, /* R9505 */ - { 0x0000, 0x0000, 0x0000 }, /* R9506 */ - { 0x0000, 0x0000, 0x0000 }, /* R9507 */ - { 0x0000, 0x0000, 0x0000 }, /* R9508 */ - { 0x0000, 0x0000, 0x0000 }, /* R9509 */ - { 0x0000, 0x0000, 0x0000 }, /* R9510 */ - { 0x0000, 0x0000, 0x0000 }, /* R9511 */ - { 0x0000, 0x0000, 0x0000 }, /* R9512 */ - { 0x0000, 0x0000, 0x0000 }, /* R9513 */ - { 0x0000, 0x0000, 0x0000 }, /* R9514 */ - { 0x0000, 0x0000, 0x0000 }, /* R9515 */ - { 0x0000, 0x0000, 0x0000 }, /* R9516 */ - { 0x0000, 0x0000, 0x0000 }, /* R9517 */ - { 0x0000, 0x0000, 0x0000 }, /* R9518 */ - { 0x0000, 0x0000, 0x0000 }, /* R9519 */ - { 0x0000, 0x0000, 0x0000 }, /* R9520 */ - { 0x0000, 0x0000, 0x0000 }, /* R9521 */ - { 0x0000, 0x0000, 0x0000 }, /* R9522 */ - { 0x0000, 0x0000, 0x0000 }, /* R9523 */ - { 0x0000, 0x0000, 0x0000 }, /* R9524 */ - { 0x0000, 0x0000, 0x0000 }, /* R9525 */ - { 0x0000, 0x0000, 0x0000 }, /* R9526 */ - { 0x0000, 0x0000, 0x0000 }, /* R9527 */ - { 0x0000, 0x0000, 0x0000 }, /* R9528 */ - { 0x0000, 0x0000, 0x0000 }, /* R9529 */ - { 0x0000, 0x0000, 0x0000 }, /* R9530 */ - { 0x0000, 0x0000, 0x0000 }, /* R9531 */ - { 0x0000, 0x0000, 0x0000 }, /* R9532 */ - { 0x0000, 0x0000, 0x0000 }, /* R9533 */ - { 0x0000, 0x0000, 0x0000 }, /* R9534 */ - { 0x0000, 0x0000, 0x0000 }, /* R9535 */ - { 0x0000, 0x0000, 0x0000 }, /* R9536 */ - { 0x0000, 0x0000, 0x0000 }, /* R9537 */ - { 0x0000, 0x0000, 0x0000 }, /* R9538 */ - { 0x0000, 0x0000, 0x0000 }, /* R9539 */ - { 0x0000, 0x0000, 0x0000 }, /* R9540 */ - { 0x0000, 0x0000, 0x0000 }, /* R9541 */ - { 0x0000, 0x0000, 0x0000 }, /* R9542 */ - { 0x0000, 0x0000, 0x0000 }, /* R9543 */ - { 0x0000, 0x0000, 0x0000 }, /* R9544 */ - { 0x0000, 0x0000, 0x0000 }, /* R9545 */ - { 0x0000, 0x0000, 0x0000 }, /* R9546 */ - { 0x0000, 0x0000, 0x0000 }, /* R9547 */ - { 0x0000, 0x0000, 0x0000 }, /* R9548 */ - { 0x0000, 0x0000, 0x0000 }, /* R9549 */ - { 0x0000, 0x0000, 0x0000 }, /* R9550 */ - { 0x0000, 0x0000, 0x0000 }, /* R9551 */ - { 0x0000, 0x0000, 0x0000 }, /* R9552 */ - { 0x0000, 0x0000, 0x0000 }, /* R9553 */ - { 0x0000, 0x0000, 0x0000 }, /* R9554 */ - { 0x0000, 0x0000, 0x0000 }, /* R9555 */ - { 0x0000, 0x0000, 0x0000 }, /* R9556 */ - { 0x0000, 0x0000, 0x0000 }, /* R9557 */ - { 0x0000, 0x0000, 0x0000 }, /* R9558 */ - { 0x0000, 0x0000, 0x0000 }, /* R9559 */ - { 0x0000, 0x0000, 0x0000 }, /* R9560 */ - { 0x0000, 0x0000, 0x0000 }, /* R9561 */ - { 0x0000, 0x0000, 0x0000 }, /* R9562 */ - { 0x0000, 0x0000, 0x0000 }, /* R9563 */ - { 0x0000, 0x0000, 0x0000 }, /* R9564 */ - { 0x0000, 0x0000, 0x0000 }, /* R9565 */ - { 0x0000, 0x0000, 0x0000 }, /* R9566 */ - { 0x0000, 0x0000, 0x0000 }, /* R9567 */ - { 0x0000, 0x0000, 0x0000 }, /* R9568 */ - { 0x0000, 0x0000, 0x0000 }, /* R9569 */ - { 0x0000, 0x0000, 0x0000 }, /* R9570 */ - { 0x0000, 0x0000, 0x0000 }, /* R9571 */ - { 0x0000, 0x0000, 0x0000 }, /* R9572 */ - { 0x0000, 0x0000, 0x0000 }, /* R9573 */ - { 0x0000, 0x0000, 0x0000 }, /* R9574 */ - { 0x0000, 0x0000, 0x0000 }, /* R9575 */ - { 0x0000, 0x0000, 0x0000 }, /* R9576 */ - { 0x0000, 0x0000, 0x0000 }, /* R9577 */ - { 0x0000, 0x0000, 0x0000 }, /* R9578 */ - { 0x0000, 0x0000, 0x0000 }, /* R9579 */ - { 0x0000, 0x0000, 0x0000 }, /* R9580 */ - { 0x0000, 0x0000, 0x0000 }, /* R9581 */ - { 0x0000, 0x0000, 0x0000 }, /* R9582 */ - { 0x0000, 0x0000, 0x0000 }, /* R9583 */ - { 0x0000, 0x0000, 0x0000 }, /* R9584 */ - { 0x0000, 0x0000, 0x0000 }, /* R9585 */ - { 0x0000, 0x0000, 0x0000 }, /* R9586 */ - { 0x0000, 0x0000, 0x0000 }, /* R9587 */ - { 0x0000, 0x0000, 0x0000 }, /* R9588 */ - { 0x0000, 0x0000, 0x0000 }, /* R9589 */ - { 0x0000, 0x0000, 0x0000 }, /* R9590 */ - { 0x0000, 0x0000, 0x0000 }, /* R9591 */ - { 0x0000, 0x0000, 0x0000 }, /* R9592 */ - { 0x0000, 0x0000, 0x0000 }, /* R9593 */ - { 0x0000, 0x0000, 0x0000 }, /* R9594 */ - { 0x0000, 0x0000, 0x0000 }, /* R9595 */ - { 0x0000, 0x0000, 0x0000 }, /* R9596 */ - { 0x0000, 0x0000, 0x0000 }, /* R9597 */ - { 0x0000, 0x0000, 0x0000 }, /* R9598 */ - { 0x0000, 0x0000, 0x0000 }, /* R9599 */ - { 0x0000, 0x0000, 0x0000 }, /* R9600 */ - { 0x0000, 0x0000, 0x0000 }, /* R9601 */ - { 0x0000, 0x0000, 0x0000 }, /* R9602 */ - { 0x0000, 0x0000, 0x0000 }, /* R9603 */ - { 0x0000, 0x0000, 0x0000 }, /* R9604 */ - { 0x0000, 0x0000, 0x0000 }, /* R9605 */ - { 0x0000, 0x0000, 0x0000 }, /* R9606 */ - { 0x0000, 0x0000, 0x0000 }, /* R9607 */ - { 0x0000, 0x0000, 0x0000 }, /* R9608 */ - { 0x0000, 0x0000, 0x0000 }, /* R9609 */ - { 0x0000, 0x0000, 0x0000 }, /* R9610 */ - { 0x0000, 0x0000, 0x0000 }, /* R9611 */ - { 0x0000, 0x0000, 0x0000 }, /* R9612 */ - { 0x0000, 0x0000, 0x0000 }, /* R9613 */ - { 0x0000, 0x0000, 0x0000 }, /* R9614 */ - { 0x0000, 0x0000, 0x0000 }, /* R9615 */ - { 0x0000, 0x0000, 0x0000 }, /* R9616 */ - { 0x0000, 0x0000, 0x0000 }, /* R9617 */ - { 0x0000, 0x0000, 0x0000 }, /* R9618 */ - { 0x0000, 0x0000, 0x0000 }, /* R9619 */ - { 0x0000, 0x0000, 0x0000 }, /* R9620 */ - { 0x0000, 0x0000, 0x0000 }, /* R9621 */ - { 0x0000, 0x0000, 0x0000 }, /* R9622 */ - { 0x0000, 0x0000, 0x0000 }, /* R9623 */ - { 0x0000, 0x0000, 0x0000 }, /* R9624 */ - { 0x0000, 0x0000, 0x0000 }, /* R9625 */ - { 0x0000, 0x0000, 0x0000 }, /* R9626 */ - { 0x0000, 0x0000, 0x0000 }, /* R9627 */ - { 0x0000, 0x0000, 0x0000 }, /* R9628 */ - { 0x0000, 0x0000, 0x0000 }, /* R9629 */ - { 0x0000, 0x0000, 0x0000 }, /* R9630 */ - { 0x0000, 0x0000, 0x0000 }, /* R9631 */ - { 0x0000, 0x0000, 0x0000 }, /* R9632 */ - { 0x0000, 0x0000, 0x0000 }, /* R9633 */ - { 0x0000, 0x0000, 0x0000 }, /* R9634 */ - { 0x0000, 0x0000, 0x0000 }, /* R9635 */ - { 0x0000, 0x0000, 0x0000 }, /* R9636 */ - { 0x0000, 0x0000, 0x0000 }, /* R9637 */ - { 0x0000, 0x0000, 0x0000 }, /* R9638 */ - { 0x0000, 0x0000, 0x0000 }, /* R9639 */ - { 0x0000, 0x0000, 0x0000 }, /* R9640 */ - { 0x0000, 0x0000, 0x0000 }, /* R9641 */ - { 0x0000, 0x0000, 0x0000 }, /* R9642 */ - { 0x0000, 0x0000, 0x0000 }, /* R9643 */ - { 0x0000, 0x0000, 0x0000 }, /* R9644 */ - { 0x0000, 0x0000, 0x0000 }, /* R9645 */ - { 0x0000, 0x0000, 0x0000 }, /* R9646 */ - { 0x0000, 0x0000, 0x0000 }, /* R9647 */ - { 0x0000, 0x0000, 0x0000 }, /* R9648 */ - { 0x0000, 0x0000, 0x0000 }, /* R9649 */ - { 0x0000, 0x0000, 0x0000 }, /* R9650 */ - { 0x0000, 0x0000, 0x0000 }, /* R9651 */ - { 0x0000, 0x0000, 0x0000 }, /* R9652 */ - { 0x0000, 0x0000, 0x0000 }, /* R9653 */ - { 0x0000, 0x0000, 0x0000 }, /* R9654 */ - { 0x0000, 0x0000, 0x0000 }, /* R9655 */ - { 0x0000, 0x0000, 0x0000 }, /* R9656 */ - { 0x0000, 0x0000, 0x0000 }, /* R9657 */ - { 0x0000, 0x0000, 0x0000 }, /* R9658 */ - { 0x0000, 0x0000, 0x0000 }, /* R9659 */ - { 0x0000, 0x0000, 0x0000 }, /* R9660 */ - { 0x0000, 0x0000, 0x0000 }, /* R9661 */ - { 0x0000, 0x0000, 0x0000 }, /* R9662 */ - { 0x0000, 0x0000, 0x0000 }, /* R9663 */ - { 0x0000, 0x0000, 0x0000 }, /* R9664 */ - { 0x0000, 0x0000, 0x0000 }, /* R9665 */ - { 0x0000, 0x0000, 0x0000 }, /* R9666 */ - { 0x0000, 0x0000, 0x0000 }, /* R9667 */ - { 0x0000, 0x0000, 0x0000 }, /* R9668 */ - { 0x0000, 0x0000, 0x0000 }, /* R9669 */ - { 0x0000, 0x0000, 0x0000 }, /* R9670 */ - { 0x0000, 0x0000, 0x0000 }, /* R9671 */ - { 0x0000, 0x0000, 0x0000 }, /* R9672 */ - { 0x0000, 0x0000, 0x0000 }, /* R9673 */ - { 0x0000, 0x0000, 0x0000 }, /* R9674 */ - { 0x0000, 0x0000, 0x0000 }, /* R9675 */ - { 0x0000, 0x0000, 0x0000 }, /* R9676 */ - { 0x0000, 0x0000, 0x0000 }, /* R9677 */ - { 0x0000, 0x0000, 0x0000 }, /* R9678 */ - { 0x0000, 0x0000, 0x0000 }, /* R9679 */ - { 0x0000, 0x0000, 0x0000 }, /* R9680 */ - { 0x0000, 0x0000, 0x0000 }, /* R9681 */ - { 0x0000, 0x0000, 0x0000 }, /* R9682 */ - { 0x0000, 0x0000, 0x0000 }, /* R9683 */ - { 0x0000, 0x0000, 0x0000 }, /* R9684 */ - { 0x0000, 0x0000, 0x0000 }, /* R9685 */ - { 0x0000, 0x0000, 0x0000 }, /* R9686 */ - { 0x0000, 0x0000, 0x0000 }, /* R9687 */ - { 0x0000, 0x0000, 0x0000 }, /* R9688 */ - { 0x0000, 0x0000, 0x0000 }, /* R9689 */ - { 0x0000, 0x0000, 0x0000 }, /* R9690 */ - { 0x0000, 0x0000, 0x0000 }, /* R9691 */ - { 0x0000, 0x0000, 0x0000 }, /* R9692 */ - { 0x0000, 0x0000, 0x0000 }, /* R9693 */ - { 0x0000, 0x0000, 0x0000 }, /* R9694 */ - { 0x0000, 0x0000, 0x0000 }, /* R9695 */ - { 0x0000, 0x0000, 0x0000 }, /* R9696 */ - { 0x0000, 0x0000, 0x0000 }, /* R9697 */ - { 0x0000, 0x0000, 0x0000 }, /* R9698 */ - { 0x0000, 0x0000, 0x0000 }, /* R9699 */ - { 0x0000, 0x0000, 0x0000 }, /* R9700 */ - { 0x0000, 0x0000, 0x0000 }, /* R9701 */ - { 0x0000, 0x0000, 0x0000 }, /* R9702 */ - { 0x0000, 0x0000, 0x0000 }, /* R9703 */ - { 0x0000, 0x0000, 0x0000 }, /* R9704 */ - { 0x0000, 0x0000, 0x0000 }, /* R9705 */ - { 0x0000, 0x0000, 0x0000 }, /* R9706 */ - { 0x0000, 0x0000, 0x0000 }, /* R9707 */ - { 0x0000, 0x0000, 0x0000 }, /* R9708 */ - { 0x0000, 0x0000, 0x0000 }, /* R9709 */ - { 0x0000, 0x0000, 0x0000 }, /* R9710 */ - { 0x0000, 0x0000, 0x0000 }, /* R9711 */ - { 0x0000, 0x0000, 0x0000 }, /* R9712 */ - { 0x0000, 0x0000, 0x0000 }, /* R9713 */ - { 0x0000, 0x0000, 0x0000 }, /* R9714 */ - { 0x0000, 0x0000, 0x0000 }, /* R9715 */ - { 0x0000, 0x0000, 0x0000 }, /* R9716 */ - { 0x0000, 0x0000, 0x0000 }, /* R9717 */ - { 0x0000, 0x0000, 0x0000 }, /* R9718 */ - { 0x0000, 0x0000, 0x0000 }, /* R9719 */ - { 0x0000, 0x0000, 0x0000 }, /* R9720 */ - { 0x0000, 0x0000, 0x0000 }, /* R9721 */ - { 0x0000, 0x0000, 0x0000 }, /* R9722 */ - { 0x0000, 0x0000, 0x0000 }, /* R9723 */ - { 0x0000, 0x0000, 0x0000 }, /* R9724 */ - { 0x0000, 0x0000, 0x0000 }, /* R9725 */ - { 0x0000, 0x0000, 0x0000 }, /* R9726 */ - { 0x0000, 0x0000, 0x0000 }, /* R9727 */ - { 0x0000, 0x0000, 0x0000 }, /* R9728 */ - { 0x0000, 0x0000, 0x0000 }, /* R9729 */ - { 0x0000, 0x0000, 0x0000 }, /* R9730 */ - { 0x0000, 0x0000, 0x0000 }, /* R9731 */ - { 0x0000, 0x0000, 0x0000 }, /* R9732 */ - { 0x0000, 0x0000, 0x0000 }, /* R9733 */ - { 0x0000, 0x0000, 0x0000 }, /* R9734 */ - { 0x0000, 0x0000, 0x0000 }, /* R9735 */ - { 0x0000, 0x0000, 0x0000 }, /* R9736 */ - { 0x0000, 0x0000, 0x0000 }, /* R9737 */ - { 0x0000, 0x0000, 0x0000 }, /* R9738 */ - { 0x0000, 0x0000, 0x0000 }, /* R9739 */ - { 0x0000, 0x0000, 0x0000 }, /* R9740 */ - { 0x0000, 0x0000, 0x0000 }, /* R9741 */ - { 0x0000, 0x0000, 0x0000 }, /* R9742 */ - { 0x0000, 0x0000, 0x0000 }, /* R9743 */ - { 0x0000, 0x0000, 0x0000 }, /* R9744 */ - { 0x0000, 0x0000, 0x0000 }, /* R9745 */ - { 0x0000, 0x0000, 0x0000 }, /* R9746 */ - { 0x0000, 0x0000, 0x0000 }, /* R9747 */ - { 0x0000, 0x0000, 0x0000 }, /* R9748 */ - { 0x0000, 0x0000, 0x0000 }, /* R9749 */ - { 0x0000, 0x0000, 0x0000 }, /* R9750 */ - { 0x0000, 0x0000, 0x0000 }, /* R9751 */ - { 0x0000, 0x0000, 0x0000 }, /* R9752 */ - { 0x0000, 0x0000, 0x0000 }, /* R9753 */ - { 0x0000, 0x0000, 0x0000 }, /* R9754 */ - { 0x0000, 0x0000, 0x0000 }, /* R9755 */ - { 0x0000, 0x0000, 0x0000 }, /* R9756 */ - { 0x0000, 0x0000, 0x0000 }, /* R9757 */ - { 0x0000, 0x0000, 0x0000 }, /* R9758 */ - { 0x0000, 0x0000, 0x0000 }, /* R9759 */ - { 0x0000, 0x0000, 0x0000 }, /* R9760 */ - { 0x0000, 0x0000, 0x0000 }, /* R9761 */ - { 0x0000, 0x0000, 0x0000 }, /* R9762 */ - { 0x0000, 0x0000, 0x0000 }, /* R9763 */ - { 0x0000, 0x0000, 0x0000 }, /* R9764 */ - { 0x0000, 0x0000, 0x0000 }, /* R9765 */ - { 0x0000, 0x0000, 0x0000 }, /* R9766 */ - { 0x0000, 0x0000, 0x0000 }, /* R9767 */ - { 0x0000, 0x0000, 0x0000 }, /* R9768 */ - { 0x0000, 0x0000, 0x0000 }, /* R9769 */ - { 0x0000, 0x0000, 0x0000 }, /* R9770 */ - { 0x0000, 0x0000, 0x0000 }, /* R9771 */ - { 0x0000, 0x0000, 0x0000 }, /* R9772 */ - { 0x0000, 0x0000, 0x0000 }, /* R9773 */ - { 0x0000, 0x0000, 0x0000 }, /* R9774 */ - { 0x0000, 0x0000, 0x0000 }, /* R9775 */ - { 0x0000, 0x0000, 0x0000 }, /* R9776 */ - { 0x0000, 0x0000, 0x0000 }, /* R9777 */ - { 0x0000, 0x0000, 0x0000 }, /* R9778 */ - { 0x0000, 0x0000, 0x0000 }, /* R9779 */ - { 0x0000, 0x0000, 0x0000 }, /* R9780 */ - { 0x0000, 0x0000, 0x0000 }, /* R9781 */ - { 0x0000, 0x0000, 0x0000 }, /* R9782 */ - { 0x0000, 0x0000, 0x0000 }, /* R9783 */ - { 0x0000, 0x0000, 0x0000 }, /* R9784 */ - { 0x0000, 0x0000, 0x0000 }, /* R9785 */ - { 0x0000, 0x0000, 0x0000 }, /* R9786 */ - { 0x0000, 0x0000, 0x0000 }, /* R9787 */ - { 0x0000, 0x0000, 0x0000 }, /* R9788 */ - { 0x0000, 0x0000, 0x0000 }, /* R9789 */ - { 0x0000, 0x0000, 0x0000 }, /* R9790 */ - { 0x0000, 0x0000, 0x0000 }, /* R9791 */ - { 0x0000, 0x0000, 0x0000 }, /* R9792 */ - { 0x0000, 0x0000, 0x0000 }, /* R9793 */ - { 0x0000, 0x0000, 0x0000 }, /* R9794 */ - { 0x0000, 0x0000, 0x0000 }, /* R9795 */ - { 0x0000, 0x0000, 0x0000 }, /* R9796 */ - { 0x0000, 0x0000, 0x0000 }, /* R9797 */ - { 0x0000, 0x0000, 0x0000 }, /* R9798 */ - { 0x0000, 0x0000, 0x0000 }, /* R9799 */ - { 0x0000, 0x0000, 0x0000 }, /* R9800 */ - { 0x0000, 0x0000, 0x0000 }, /* R9801 */ - { 0x0000, 0x0000, 0x0000 }, /* R9802 */ - { 0x0000, 0x0000, 0x0000 }, /* R9803 */ - { 0x0000, 0x0000, 0x0000 }, /* R9804 */ - { 0x0000, 0x0000, 0x0000 }, /* R9805 */ - { 0x0000, 0x0000, 0x0000 }, /* R9806 */ - { 0x0000, 0x0000, 0x0000 }, /* R9807 */ - { 0x0000, 0x0000, 0x0000 }, /* R9808 */ - { 0x0000, 0x0000, 0x0000 }, /* R9809 */ - { 0x0000, 0x0000, 0x0000 }, /* R9810 */ - { 0x0000, 0x0000, 0x0000 }, /* R9811 */ - { 0x0000, 0x0000, 0x0000 }, /* R9812 */ - { 0x0000, 0x0000, 0x0000 }, /* R9813 */ - { 0x0000, 0x0000, 0x0000 }, /* R9814 */ - { 0x0000, 0x0000, 0x0000 }, /* R9815 */ - { 0x0000, 0x0000, 0x0000 }, /* R9816 */ - { 0x0000, 0x0000, 0x0000 }, /* R9817 */ - { 0x0000, 0x0000, 0x0000 }, /* R9818 */ - { 0x0000, 0x0000, 0x0000 }, /* R9819 */ - { 0x0000, 0x0000, 0x0000 }, /* R9820 */ - { 0x0000, 0x0000, 0x0000 }, /* R9821 */ - { 0x0000, 0x0000, 0x0000 }, /* R9822 */ - { 0x0000, 0x0000, 0x0000 }, /* R9823 */ - { 0x0000, 0x0000, 0x0000 }, /* R9824 */ - { 0x0000, 0x0000, 0x0000 }, /* R9825 */ - { 0x0000, 0x0000, 0x0000 }, /* R9826 */ - { 0x0000, 0x0000, 0x0000 }, /* R9827 */ - { 0x0000, 0x0000, 0x0000 }, /* R9828 */ - { 0x0000, 0x0000, 0x0000 }, /* R9829 */ - { 0x0000, 0x0000, 0x0000 }, /* R9830 */ - { 0x0000, 0x0000, 0x0000 }, /* R9831 */ - { 0x0000, 0x0000, 0x0000 }, /* R9832 */ - { 0x0000, 0x0000, 0x0000 }, /* R9833 */ - { 0x0000, 0x0000, 0x0000 }, /* R9834 */ - { 0x0000, 0x0000, 0x0000 }, /* R9835 */ - { 0x0000, 0x0000, 0x0000 }, /* R9836 */ - { 0x0000, 0x0000, 0x0000 }, /* R9837 */ - { 0x0000, 0x0000, 0x0000 }, /* R9838 */ - { 0x0000, 0x0000, 0x0000 }, /* R9839 */ - { 0x0000, 0x0000, 0x0000 }, /* R9840 */ - { 0x0000, 0x0000, 0x0000 }, /* R9841 */ - { 0x0000, 0x0000, 0x0000 }, /* R9842 */ - { 0x0000, 0x0000, 0x0000 }, /* R9843 */ - { 0x0000, 0x0000, 0x0000 }, /* R9844 */ - { 0x0000, 0x0000, 0x0000 }, /* R9845 */ - { 0x0000, 0x0000, 0x0000 }, /* R9846 */ - { 0x0000, 0x0000, 0x0000 }, /* R9847 */ - { 0x0000, 0x0000, 0x0000 }, /* R9848 */ - { 0x0000, 0x0000, 0x0000 }, /* R9849 */ - { 0x0000, 0x0000, 0x0000 }, /* R9850 */ - { 0x0000, 0x0000, 0x0000 }, /* R9851 */ - { 0x0000, 0x0000, 0x0000 }, /* R9852 */ - { 0x0000, 0x0000, 0x0000 }, /* R9853 */ - { 0x0000, 0x0000, 0x0000 }, /* R9854 */ - { 0x0000, 0x0000, 0x0000 }, /* R9855 */ - { 0x0000, 0x0000, 0x0000 }, /* R9856 */ - { 0x0000, 0x0000, 0x0000 }, /* R9857 */ - { 0x0000, 0x0000, 0x0000 }, /* R9858 */ - { 0x0000, 0x0000, 0x0000 }, /* R9859 */ - { 0x0000, 0x0000, 0x0000 }, /* R9860 */ - { 0x0000, 0x0000, 0x0000 }, /* R9861 */ - { 0x0000, 0x0000, 0x0000 }, /* R9862 */ - { 0x0000, 0x0000, 0x0000 }, /* R9863 */ - { 0x0000, 0x0000, 0x0000 }, /* R9864 */ - { 0x0000, 0x0000, 0x0000 }, /* R9865 */ - { 0x0000, 0x0000, 0x0000 }, /* R9866 */ - { 0x0000, 0x0000, 0x0000 }, /* R9867 */ - { 0x0000, 0x0000, 0x0000 }, /* R9868 */ - { 0x0000, 0x0000, 0x0000 }, /* R9869 */ - { 0x0000, 0x0000, 0x0000 }, /* R9870 */ - { 0x0000, 0x0000, 0x0000 }, /* R9871 */ - { 0x0000, 0x0000, 0x0000 }, /* R9872 */ - { 0x0000, 0x0000, 0x0000 }, /* R9873 */ - { 0x0000, 0x0000, 0x0000 }, /* R9874 */ - { 0x0000, 0x0000, 0x0000 }, /* R9875 */ - { 0x0000, 0x0000, 0x0000 }, /* R9876 */ - { 0x0000, 0x0000, 0x0000 }, /* R9877 */ - { 0x0000, 0x0000, 0x0000 }, /* R9878 */ - { 0x0000, 0x0000, 0x0000 }, /* R9879 */ - { 0x0000, 0x0000, 0x0000 }, /* R9880 */ - { 0x0000, 0x0000, 0x0000 }, /* R9881 */ - { 0x0000, 0x0000, 0x0000 }, /* R9882 */ - { 0x0000, 0x0000, 0x0000 }, /* R9883 */ - { 0x0000, 0x0000, 0x0000 }, /* R9884 */ - { 0x0000, 0x0000, 0x0000 }, /* R9885 */ - { 0x0000, 0x0000, 0x0000 }, /* R9886 */ - { 0x0000, 0x0000, 0x0000 }, /* R9887 */ - { 0x0000, 0x0000, 0x0000 }, /* R9888 */ - { 0x0000, 0x0000, 0x0000 }, /* R9889 */ - { 0x0000, 0x0000, 0x0000 }, /* R9890 */ - { 0x0000, 0x0000, 0x0000 }, /* R9891 */ - { 0x0000, 0x0000, 0x0000 }, /* R9892 */ - { 0x0000, 0x0000, 0x0000 }, /* R9893 */ - { 0x0000, 0x0000, 0x0000 }, /* R9894 */ - { 0x0000, 0x0000, 0x0000 }, /* R9895 */ - { 0x0000, 0x0000, 0x0000 }, /* R9896 */ - { 0x0000, 0x0000, 0x0000 }, /* R9897 */ - { 0x0000, 0x0000, 0x0000 }, /* R9898 */ - { 0x0000, 0x0000, 0x0000 }, /* R9899 */ - { 0x0000, 0x0000, 0x0000 }, /* R9900 */ - { 0x0000, 0x0000, 0x0000 }, /* R9901 */ - { 0x0000, 0x0000, 0x0000 }, /* R9902 */ - { 0x0000, 0x0000, 0x0000 }, /* R9903 */ - { 0x0000, 0x0000, 0x0000 }, /* R9904 */ - { 0x0000, 0x0000, 0x0000 }, /* R9905 */ - { 0x0000, 0x0000, 0x0000 }, /* R9906 */ - { 0x0000, 0x0000, 0x0000 }, /* R9907 */ - { 0x0000, 0x0000, 0x0000 }, /* R9908 */ - { 0x0000, 0x0000, 0x0000 }, /* R9909 */ - { 0x0000, 0x0000, 0x0000 }, /* R9910 */ - { 0x0000, 0x0000, 0x0000 }, /* R9911 */ - { 0x0000, 0x0000, 0x0000 }, /* R9912 */ - { 0x0000, 0x0000, 0x0000 }, /* R9913 */ - { 0x0000, 0x0000, 0x0000 }, /* R9914 */ - { 0x0000, 0x0000, 0x0000 }, /* R9915 */ - { 0x0000, 0x0000, 0x0000 }, /* R9916 */ - { 0x0000, 0x0000, 0x0000 }, /* R9917 */ - { 0x0000, 0x0000, 0x0000 }, /* R9918 */ - { 0x0000, 0x0000, 0x0000 }, /* R9919 */ - { 0x0000, 0x0000, 0x0000 }, /* R9920 */ - { 0x0000, 0x0000, 0x0000 }, /* R9921 */ - { 0x0000, 0x0000, 0x0000 }, /* R9922 */ - { 0x0000, 0x0000, 0x0000 }, /* R9923 */ - { 0x0000, 0x0000, 0x0000 }, /* R9924 */ - { 0x0000, 0x0000, 0x0000 }, /* R9925 */ - { 0x0000, 0x0000, 0x0000 }, /* R9926 */ - { 0x0000, 0x0000, 0x0000 }, /* R9927 */ - { 0x0000, 0x0000, 0x0000 }, /* R9928 */ - { 0x0000, 0x0000, 0x0000 }, /* R9929 */ - { 0x0000, 0x0000, 0x0000 }, /* R9930 */ - { 0x0000, 0x0000, 0x0000 }, /* R9931 */ - { 0x0000, 0x0000, 0x0000 }, /* R9932 */ - { 0x0000, 0x0000, 0x0000 }, /* R9933 */ - { 0x0000, 0x0000, 0x0000 }, /* R9934 */ - { 0x0000, 0x0000, 0x0000 }, /* R9935 */ - { 0x0000, 0x0000, 0x0000 }, /* R9936 */ - { 0x0000, 0x0000, 0x0000 }, /* R9937 */ - { 0x0000, 0x0000, 0x0000 }, /* R9938 */ - { 0x0000, 0x0000, 0x0000 }, /* R9939 */ - { 0x0000, 0x0000, 0x0000 }, /* R9940 */ - { 0x0000, 0x0000, 0x0000 }, /* R9941 */ - { 0x0000, 0x0000, 0x0000 }, /* R9942 */ - { 0x0000, 0x0000, 0x0000 }, /* R9943 */ - { 0x0000, 0x0000, 0x0000 }, /* R9944 */ - { 0x0000, 0x0000, 0x0000 }, /* R9945 */ - { 0x0000, 0x0000, 0x0000 }, /* R9946 */ - { 0x0000, 0x0000, 0x0000 }, /* R9947 */ - { 0x0000, 0x0000, 0x0000 }, /* R9948 */ - { 0x0000, 0x0000, 0x0000 }, /* R9949 */ - { 0x0000, 0x0000, 0x0000 }, /* R9950 */ - { 0x0000, 0x0000, 0x0000 }, /* R9951 */ - { 0x0000, 0x0000, 0x0000 }, /* R9952 */ - { 0x0000, 0x0000, 0x0000 }, /* R9953 */ - { 0x0000, 0x0000, 0x0000 }, /* R9954 */ - { 0x0000, 0x0000, 0x0000 }, /* R9955 */ - { 0x0000, 0x0000, 0x0000 }, /* R9956 */ - { 0x0000, 0x0000, 0x0000 }, /* R9957 */ - { 0x0000, 0x0000, 0x0000 }, /* R9958 */ - { 0x0000, 0x0000, 0x0000 }, /* R9959 */ - { 0x0000, 0x0000, 0x0000 }, /* R9960 */ - { 0x0000, 0x0000, 0x0000 }, /* R9961 */ - { 0x0000, 0x0000, 0x0000 }, /* R9962 */ - { 0x0000, 0x0000, 0x0000 }, /* R9963 */ - { 0x0000, 0x0000, 0x0000 }, /* R9964 */ - { 0x0000, 0x0000, 0x0000 }, /* R9965 */ - { 0x0000, 0x0000, 0x0000 }, /* R9966 */ - { 0x0000, 0x0000, 0x0000 }, /* R9967 */ - { 0x0000, 0x0000, 0x0000 }, /* R9968 */ - { 0x0000, 0x0000, 0x0000 }, /* R9969 */ - { 0x0000, 0x0000, 0x0000 }, /* R9970 */ - { 0x0000, 0x0000, 0x0000 }, /* R9971 */ - { 0x0000, 0x0000, 0x0000 }, /* R9972 */ - { 0x0000, 0x0000, 0x0000 }, /* R9973 */ - { 0x0000, 0x0000, 0x0000 }, /* R9974 */ - { 0x0000, 0x0000, 0x0000 }, /* R9975 */ - { 0x0000, 0x0000, 0x0000 }, /* R9976 */ - { 0x0000, 0x0000, 0x0000 }, /* R9977 */ - { 0x0000, 0x0000, 0x0000 }, /* R9978 */ - { 0x0000, 0x0000, 0x0000 }, /* R9979 */ - { 0x0000, 0x0000, 0x0000 }, /* R9980 */ - { 0x0000, 0x0000, 0x0000 }, /* R9981 */ - { 0x0000, 0x0000, 0x0000 }, /* R9982 */ - { 0x0000, 0x0000, 0x0000 }, /* R9983 */ - { 0x0000, 0x0000, 0x0000 }, /* R9984 */ - { 0x0000, 0x0000, 0x0000 }, /* R9985 */ - { 0x0000, 0x0000, 0x0000 }, /* R9986 */ - { 0x0000, 0x0000, 0x0000 }, /* R9987 */ - { 0x0000, 0x0000, 0x0000 }, /* R9988 */ - { 0x0000, 0x0000, 0x0000 }, /* R9989 */ - { 0x0000, 0x0000, 0x0000 }, /* R9990 */ - { 0x0000, 0x0000, 0x0000 }, /* R9991 */ - { 0x0000, 0x0000, 0x0000 }, /* R9992 */ - { 0x0000, 0x0000, 0x0000 }, /* R9993 */ - { 0x0000, 0x0000, 0x0000 }, /* R9994 */ - { 0x0000, 0x0000, 0x0000 }, /* R9995 */ - { 0x0000, 0x0000, 0x0000 }, /* R9996 */ - { 0x0000, 0x0000, 0x0000 }, /* R9997 */ - { 0x0000, 0x0000, 0x0000 }, /* R9998 */ - { 0x0000, 0x0000, 0x0000 }, /* R9999 */ - { 0x0000, 0x0000, 0x0000 }, /* R10000 */ - { 0x0000, 0x0000, 0x0000 }, /* R10001 */ - { 0x0000, 0x0000, 0x0000 }, /* R10002 */ - { 0x0000, 0x0000, 0x0000 }, /* R10003 */ - { 0x0000, 0x0000, 0x0000 }, /* R10004 */ - { 0x0000, 0x0000, 0x0000 }, /* R10005 */ - { 0x0000, 0x0000, 0x0000 }, /* R10006 */ - { 0x0000, 0x0000, 0x0000 }, /* R10007 */ - { 0x0000, 0x0000, 0x0000 }, /* R10008 */ - { 0x0000, 0x0000, 0x0000 }, /* R10009 */ - { 0x0000, 0x0000, 0x0000 }, /* R10010 */ - { 0x0000, 0x0000, 0x0000 }, /* R10011 */ - { 0x0000, 0x0000, 0x0000 }, /* R10012 */ - { 0x0000, 0x0000, 0x0000 }, /* R10013 */ - { 0x0000, 0x0000, 0x0000 }, /* R10014 */ - { 0x0000, 0x0000, 0x0000 }, /* R10015 */ - { 0x0000, 0x0000, 0x0000 }, /* R10016 */ - { 0x0000, 0x0000, 0x0000 }, /* R10017 */ - { 0x0000, 0x0000, 0x0000 }, /* R10018 */ - { 0x0000, 0x0000, 0x0000 }, /* R10019 */ - { 0x0000, 0x0000, 0x0000 }, /* R10020 */ - { 0x0000, 0x0000, 0x0000 }, /* R10021 */ - { 0x0000, 0x0000, 0x0000 }, /* R10022 */ - { 0x0000, 0x0000, 0x0000 }, /* R10023 */ - { 0x0000, 0x0000, 0x0000 }, /* R10024 */ - { 0x0000, 0x0000, 0x0000 }, /* R10025 */ - { 0x0000, 0x0000, 0x0000 }, /* R10026 */ - { 0x0000, 0x0000, 0x0000 }, /* R10027 */ - { 0x0000, 0x0000, 0x0000 }, /* R10028 */ - { 0x0000, 0x0000, 0x0000 }, /* R10029 */ - { 0x0000, 0x0000, 0x0000 }, /* R10030 */ - { 0x0000, 0x0000, 0x0000 }, /* R10031 */ - { 0x0000, 0x0000, 0x0000 }, /* R10032 */ - { 0x0000, 0x0000, 0x0000 }, /* R10033 */ - { 0x0000, 0x0000, 0x0000 }, /* R10034 */ - { 0x0000, 0x0000, 0x0000 }, /* R10035 */ - { 0x0000, 0x0000, 0x0000 }, /* R10036 */ - { 0x0000, 0x0000, 0x0000 }, /* R10037 */ - { 0x0000, 0x0000, 0x0000 }, /* R10038 */ - { 0x0000, 0x0000, 0x0000 }, /* R10039 */ - { 0x0000, 0x0000, 0x0000 }, /* R10040 */ - { 0x0000, 0x0000, 0x0000 }, /* R10041 */ - { 0x0000, 0x0000, 0x0000 }, /* R10042 */ - { 0x0000, 0x0000, 0x0000 }, /* R10043 */ - { 0x0000, 0x0000, 0x0000 }, /* R10044 */ - { 0x0000, 0x0000, 0x0000 }, /* R10045 */ - { 0x0000, 0x0000, 0x0000 }, /* R10046 */ - { 0x0000, 0x0000, 0x0000 }, /* R10047 */ - { 0x0000, 0x0000, 0x0000 }, /* R10048 */ - { 0x0000, 0x0000, 0x0000 }, /* R10049 */ - { 0x0000, 0x0000, 0x0000 }, /* R10050 */ - { 0x0000, 0x0000, 0x0000 }, /* R10051 */ - { 0x0000, 0x0000, 0x0000 }, /* R10052 */ - { 0x0000, 0x0000, 0x0000 }, /* R10053 */ - { 0x0000, 0x0000, 0x0000 }, /* R10054 */ - { 0x0000, 0x0000, 0x0000 }, /* R10055 */ - { 0x0000, 0x0000, 0x0000 }, /* R10056 */ - { 0x0000, 0x0000, 0x0000 }, /* R10057 */ - { 0x0000, 0x0000, 0x0000 }, /* R10058 */ - { 0x0000, 0x0000, 0x0000 }, /* R10059 */ - { 0x0000, 0x0000, 0x0000 }, /* R10060 */ - { 0x0000, 0x0000, 0x0000 }, /* R10061 */ - { 0x0000, 0x0000, 0x0000 }, /* R10062 */ - { 0x0000, 0x0000, 0x0000 }, /* R10063 */ - { 0x0000, 0x0000, 0x0000 }, /* R10064 */ - { 0x0000, 0x0000, 0x0000 }, /* R10065 */ - { 0x0000, 0x0000, 0x0000 }, /* R10066 */ - { 0x0000, 0x0000, 0x0000 }, /* R10067 */ - { 0x0000, 0x0000, 0x0000 }, /* R10068 */ - { 0x0000, 0x0000, 0x0000 }, /* R10069 */ - { 0x0000, 0x0000, 0x0000 }, /* R10070 */ - { 0x0000, 0x0000, 0x0000 }, /* R10071 */ - { 0x0000, 0x0000, 0x0000 }, /* R10072 */ - { 0x0000, 0x0000, 0x0000 }, /* R10073 */ - { 0x0000, 0x0000, 0x0000 }, /* R10074 */ - { 0x0000, 0x0000, 0x0000 }, /* R10075 */ - { 0x0000, 0x0000, 0x0000 }, /* R10076 */ - { 0x0000, 0x0000, 0x0000 }, /* R10077 */ - { 0x0000, 0x0000, 0x0000 }, /* R10078 */ - { 0x0000, 0x0000, 0x0000 }, /* R10079 */ - { 0x0000, 0x0000, 0x0000 }, /* R10080 */ - { 0x0000, 0x0000, 0x0000 }, /* R10081 */ - { 0x0000, 0x0000, 0x0000 }, /* R10082 */ - { 0x0000, 0x0000, 0x0000 }, /* R10083 */ - { 0x0000, 0x0000, 0x0000 }, /* R10084 */ - { 0x0000, 0x0000, 0x0000 }, /* R10085 */ - { 0x0000, 0x0000, 0x0000 }, /* R10086 */ - { 0x0000, 0x0000, 0x0000 }, /* R10087 */ - { 0x0000, 0x0000, 0x0000 }, /* R10088 */ - { 0x0000, 0x0000, 0x0000 }, /* R10089 */ - { 0x0000, 0x0000, 0x0000 }, /* R10090 */ - { 0x0000, 0x0000, 0x0000 }, /* R10091 */ - { 0x0000, 0x0000, 0x0000 }, /* R10092 */ - { 0x0000, 0x0000, 0x0000 }, /* R10093 */ - { 0x0000, 0x0000, 0x0000 }, /* R10094 */ - { 0x0000, 0x0000, 0x0000 }, /* R10095 */ - { 0x0000, 0x0000, 0x0000 }, /* R10096 */ - { 0x0000, 0x0000, 0x0000 }, /* R10097 */ - { 0x0000, 0x0000, 0x0000 }, /* R10098 */ - { 0x0000, 0x0000, 0x0000 }, /* R10099 */ - { 0x0000, 0x0000, 0x0000 }, /* R10100 */ - { 0x0000, 0x0000, 0x0000 }, /* R10101 */ - { 0x0000, 0x0000, 0x0000 }, /* R10102 */ - { 0x0000, 0x0000, 0x0000 }, /* R10103 */ - { 0x0000, 0x0000, 0x0000 }, /* R10104 */ - { 0x0000, 0x0000, 0x0000 }, /* R10105 */ - { 0x0000, 0x0000, 0x0000 }, /* R10106 */ - { 0x0000, 0x0000, 0x0000 }, /* R10107 */ - { 0x0000, 0x0000, 0x0000 }, /* R10108 */ - { 0x0000, 0x0000, 0x0000 }, /* R10109 */ - { 0x0000, 0x0000, 0x0000 }, /* R10110 */ - { 0x0000, 0x0000, 0x0000 }, /* R10111 */ - { 0x0000, 0x0000, 0x0000 }, /* R10112 */ - { 0x0000, 0x0000, 0x0000 }, /* R10113 */ - { 0x0000, 0x0000, 0x0000 }, /* R10114 */ - { 0x0000, 0x0000, 0x0000 }, /* R10115 */ - { 0x0000, 0x0000, 0x0000 }, /* R10116 */ - { 0x0000, 0x0000, 0x0000 }, /* R10117 */ - { 0x0000, 0x0000, 0x0000 }, /* R10118 */ - { 0x0000, 0x0000, 0x0000 }, /* R10119 */ - { 0x0000, 0x0000, 0x0000 }, /* R10120 */ - { 0x0000, 0x0000, 0x0000 }, /* R10121 */ - { 0x0000, 0x0000, 0x0000 }, /* R10122 */ - { 0x0000, 0x0000, 0x0000 }, /* R10123 */ - { 0x0000, 0x0000, 0x0000 }, /* R10124 */ - { 0x0000, 0x0000, 0x0000 }, /* R10125 */ - { 0x0000, 0x0000, 0x0000 }, /* R10126 */ - { 0x0000, 0x0000, 0x0000 }, /* R10127 */ - { 0x0000, 0x0000, 0x0000 }, /* R10128 */ - { 0x0000, 0x0000, 0x0000 }, /* R10129 */ - { 0x0000, 0x0000, 0x0000 }, /* R10130 */ - { 0x0000, 0x0000, 0x0000 }, /* R10131 */ - { 0x0000, 0x0000, 0x0000 }, /* R10132 */ - { 0x0000, 0x0000, 0x0000 }, /* R10133 */ - { 0x0000, 0x0000, 0x0000 }, /* R10134 */ - { 0x0000, 0x0000, 0x0000 }, /* R10135 */ - { 0x0000, 0x0000, 0x0000 }, /* R10136 */ - { 0x0000, 0x0000, 0x0000 }, /* R10137 */ - { 0x0000, 0x0000, 0x0000 }, /* R10138 */ - { 0x0000, 0x0000, 0x0000 }, /* R10139 */ - { 0x0000, 0x0000, 0x0000 }, /* R10140 */ - { 0x0000, 0x0000, 0x0000 }, /* R10141 */ - { 0x0000, 0x0000, 0x0000 }, /* R10142 */ - { 0x0000, 0x0000, 0x0000 }, /* R10143 */ - { 0x0000, 0x0000, 0x0000 }, /* R10144 */ - { 0x0000, 0x0000, 0x0000 }, /* R10145 */ - { 0x0000, 0x0000, 0x0000 }, /* R10146 */ - { 0x0000, 0x0000, 0x0000 }, /* R10147 */ - { 0x0000, 0x0000, 0x0000 }, /* R10148 */ - { 0x0000, 0x0000, 0x0000 }, /* R10149 */ - { 0x0000, 0x0000, 0x0000 }, /* R10150 */ - { 0x0000, 0x0000, 0x0000 }, /* R10151 */ - { 0x0000, 0x0000, 0x0000 }, /* R10152 */ - { 0x0000, 0x0000, 0x0000 }, /* R10153 */ - { 0x0000, 0x0000, 0x0000 }, /* R10154 */ - { 0x0000, 0x0000, 0x0000 }, /* R10155 */ - { 0x0000, 0x0000, 0x0000 }, /* R10156 */ - { 0x0000, 0x0000, 0x0000 }, /* R10157 */ - { 0x0000, 0x0000, 0x0000 }, /* R10158 */ - { 0x0000, 0x0000, 0x0000 }, /* R10159 */ - { 0x0000, 0x0000, 0x0000 }, /* R10160 */ - { 0x0000, 0x0000, 0x0000 }, /* R10161 */ - { 0x0000, 0x0000, 0x0000 }, /* R10162 */ - { 0x0000, 0x0000, 0x0000 }, /* R10163 */ - { 0x0000, 0x0000, 0x0000 }, /* R10164 */ - { 0x0000, 0x0000, 0x0000 }, /* R10165 */ - { 0x0000, 0x0000, 0x0000 }, /* R10166 */ - { 0x0000, 0x0000, 0x0000 }, /* R10167 */ - { 0x0000, 0x0000, 0x0000 }, /* R10168 */ - { 0x0000, 0x0000, 0x0000 }, /* R10169 */ - { 0x0000, 0x0000, 0x0000 }, /* R10170 */ - { 0x0000, 0x0000, 0x0000 }, /* R10171 */ - { 0x0000, 0x0000, 0x0000 }, /* R10172 */ - { 0x0000, 0x0000, 0x0000 }, /* R10173 */ - { 0x0000, 0x0000, 0x0000 }, /* R10174 */ - { 0x0000, 0x0000, 0x0000 }, /* R10175 */ - { 0x0000, 0x0000, 0x0000 }, /* R10176 */ - { 0x0000, 0x0000, 0x0000 }, /* R10177 */ - { 0x0000, 0x0000, 0x0000 }, /* R10178 */ - { 0x0000, 0x0000, 0x0000 }, /* R10179 */ - { 0x0000, 0x0000, 0x0000 }, /* R10180 */ - { 0x0000, 0x0000, 0x0000 }, /* R10181 */ - { 0x0000, 0x0000, 0x0000 }, /* R10182 */ - { 0x0000, 0x0000, 0x0000 }, /* R10183 */ - { 0x0000, 0x0000, 0x0000 }, /* R10184 */ - { 0x0000, 0x0000, 0x0000 }, /* R10185 */ - { 0x0000, 0x0000, 0x0000 }, /* R10186 */ - { 0x0000, 0x0000, 0x0000 }, /* R10187 */ - { 0x0000, 0x0000, 0x0000 }, /* R10188 */ - { 0x0000, 0x0000, 0x0000 }, /* R10189 */ - { 0x0000, 0x0000, 0x0000 }, /* R10190 */ - { 0x0000, 0x0000, 0x0000 }, /* R10191 */ - { 0x0000, 0x0000, 0x0000 }, /* R10192 */ - { 0x0000, 0x0000, 0x0000 }, /* R10193 */ - { 0x0000, 0x0000, 0x0000 }, /* R10194 */ - { 0x0000, 0x0000, 0x0000 }, /* R10195 */ - { 0x0000, 0x0000, 0x0000 }, /* R10196 */ - { 0x0000, 0x0000, 0x0000 }, /* R10197 */ - { 0x0000, 0x0000, 0x0000 }, /* R10198 */ - { 0x0000, 0x0000, 0x0000 }, /* R10199 */ - { 0x0000, 0x0000, 0x0000 }, /* R10200 */ - { 0x0000, 0x0000, 0x0000 }, /* R10201 */ - { 0x0000, 0x0000, 0x0000 }, /* R10202 */ - { 0x0000, 0x0000, 0x0000 }, /* R10203 */ - { 0x0000, 0x0000, 0x0000 }, /* R10204 */ - { 0x0000, 0x0000, 0x0000 }, /* R10205 */ - { 0x0000, 0x0000, 0x0000 }, /* R10206 */ - { 0x0000, 0x0000, 0x0000 }, /* R10207 */ - { 0x0000, 0x0000, 0x0000 }, /* R10208 */ - { 0x0000, 0x0000, 0x0000 }, /* R10209 */ - { 0x0000, 0x0000, 0x0000 }, /* R10210 */ - { 0x0000, 0x0000, 0x0000 }, /* R10211 */ - { 0x0000, 0x0000, 0x0000 }, /* R10212 */ - { 0x0000, 0x0000, 0x0000 }, /* R10213 */ - { 0x0000, 0x0000, 0x0000 }, /* R10214 */ - { 0x0000, 0x0000, 0x0000 }, /* R10215 */ - { 0x0000, 0x0000, 0x0000 }, /* R10216 */ - { 0x0000, 0x0000, 0x0000 }, /* R10217 */ - { 0x0000, 0x0000, 0x0000 }, /* R10218 */ - { 0x0000, 0x0000, 0x0000 }, /* R10219 */ - { 0x0000, 0x0000, 0x0000 }, /* R10220 */ - { 0x0000, 0x0000, 0x0000 }, /* R10221 */ - { 0x0000, 0x0000, 0x0000 }, /* R10222 */ - { 0x0000, 0x0000, 0x0000 }, /* R10223 */ - { 0x0000, 0x0000, 0x0000 }, /* R10224 */ - { 0x0000, 0x0000, 0x0000 }, /* R10225 */ - { 0x0000, 0x0000, 0x0000 }, /* R10226 */ - { 0x0000, 0x0000, 0x0000 }, /* R10227 */ - { 0x0000, 0x0000, 0x0000 }, /* R10228 */ - { 0x0000, 0x0000, 0x0000 }, /* R10229 */ - { 0x0000, 0x0000, 0x0000 }, /* R10230 */ - { 0x0000, 0x0000, 0x0000 }, /* R10231 */ - { 0x0000, 0x0000, 0x0000 }, /* R10232 */ - { 0x0000, 0x0000, 0x0000 }, /* R10233 */ - { 0x0000, 0x0000, 0x0000 }, /* R10234 */ - { 0x0000, 0x0000, 0x0000 }, /* R10235 */ - { 0x0000, 0x0000, 0x0000 }, /* R10236 */ - { 0x0000, 0x0000, 0x0000 }, /* R10237 */ - { 0x0000, 0x0000, 0x0000 }, /* R10238 */ - { 0x0000, 0x0000, 0x0000 }, /* R10239 */ - { 0x0000, 0x0000, 0x0000 }, /* R10240 */ - { 0x0000, 0x0000, 0x0000 }, /* R10241 */ - { 0x0000, 0x0000, 0x0000 }, /* R10242 */ - { 0x0000, 0x0000, 0x0000 }, /* R10243 */ - { 0x0000, 0x0000, 0x0000 }, /* R10244 */ - { 0x0000, 0x0000, 0x0000 }, /* R10245 */ - { 0x0000, 0x0000, 0x0000 }, /* R10246 */ - { 0x0000, 0x0000, 0x0000 }, /* R10247 */ - { 0x0000, 0x0000, 0x0000 }, /* R10248 */ - { 0x0000, 0x0000, 0x0000 }, /* R10249 */ - { 0x0000, 0x0000, 0x0000 }, /* R10250 */ - { 0x0000, 0x0000, 0x0000 }, /* R10251 */ - { 0x0000, 0x0000, 0x0000 }, /* R10252 */ - { 0x0000, 0x0000, 0x0000 }, /* R10253 */ - { 0x0000, 0x0000, 0x0000 }, /* R10254 */ - { 0x0000, 0x0000, 0x0000 }, /* R10255 */ - { 0x0000, 0x0000, 0x0000 }, /* R10256 */ - { 0x0000, 0x0000, 0x0000 }, /* R10257 */ - { 0x0000, 0x0000, 0x0000 }, /* R10258 */ - { 0x0000, 0x0000, 0x0000 }, /* R10259 */ - { 0x0000, 0x0000, 0x0000 }, /* R10260 */ - { 0x0000, 0x0000, 0x0000 }, /* R10261 */ - { 0x0000, 0x0000, 0x0000 }, /* R10262 */ - { 0x0000, 0x0000, 0x0000 }, /* R10263 */ - { 0x0000, 0x0000, 0x0000 }, /* R10264 */ - { 0x0000, 0x0000, 0x0000 }, /* R10265 */ - { 0x0000, 0x0000, 0x0000 }, /* R10266 */ - { 0x0000, 0x0000, 0x0000 }, /* R10267 */ - { 0x0000, 0x0000, 0x0000 }, /* R10268 */ - { 0x0000, 0x0000, 0x0000 }, /* R10269 */ - { 0x0000, 0x0000, 0x0000 }, /* R10270 */ - { 0x0000, 0x0000, 0x0000 }, /* R10271 */ - { 0x0000, 0x0000, 0x0000 }, /* R10272 */ - { 0x0000, 0x0000, 0x0000 }, /* R10273 */ - { 0x0000, 0x0000, 0x0000 }, /* R10274 */ - { 0x0000, 0x0000, 0x0000 }, /* R10275 */ - { 0x0000, 0x0000, 0x0000 }, /* R10276 */ - { 0x0000, 0x0000, 0x0000 }, /* R10277 */ - { 0x0000, 0x0000, 0x0000 }, /* R10278 */ - { 0x0000, 0x0000, 0x0000 }, /* R10279 */ - { 0x0000, 0x0000, 0x0000 }, /* R10280 */ - { 0x0000, 0x0000, 0x0000 }, /* R10281 */ - { 0x0000, 0x0000, 0x0000 }, /* R10282 */ - { 0x0000, 0x0000, 0x0000 }, /* R10283 */ - { 0x0000, 0x0000, 0x0000 }, /* R10284 */ - { 0x0000, 0x0000, 0x0000 }, /* R10285 */ - { 0x0000, 0x0000, 0x0000 }, /* R10286 */ - { 0x0000, 0x0000, 0x0000 }, /* R10287 */ - { 0x0000, 0x0000, 0x0000 }, /* R10288 */ - { 0x0000, 0x0000, 0x0000 }, /* R10289 */ - { 0x0000, 0x0000, 0x0000 }, /* R10290 */ - { 0x0000, 0x0000, 0x0000 }, /* R10291 */ - { 0x0000, 0x0000, 0x0000 }, /* R10292 */ - { 0x0000, 0x0000, 0x0000 }, /* R10293 */ - { 0x0000, 0x0000, 0x0000 }, /* R10294 */ - { 0x0000, 0x0000, 0x0000 }, /* R10295 */ - { 0x0000, 0x0000, 0x0000 }, /* R10296 */ - { 0x0000, 0x0000, 0x0000 }, /* R10297 */ - { 0x0000, 0x0000, 0x0000 }, /* R10298 */ - { 0x0000, 0x0000, 0x0000 }, /* R10299 */ - { 0x0000, 0x0000, 0x0000 }, /* R10300 */ - { 0x0000, 0x0000, 0x0000 }, /* R10301 */ - { 0x0000, 0x0000, 0x0000 }, /* R10302 */ - { 0x0000, 0x0000, 0x0000 }, /* R10303 */ - { 0x0000, 0x0000, 0x0000 }, /* R10304 */ - { 0x0000, 0x0000, 0x0000 }, /* R10305 */ - { 0x0000, 0x0000, 0x0000 }, /* R10306 */ - { 0x0000, 0x0000, 0x0000 }, /* R10307 */ - { 0x0000, 0x0000, 0x0000 }, /* R10308 */ - { 0x0000, 0x0000, 0x0000 }, /* R10309 */ - { 0x0000, 0x0000, 0x0000 }, /* R10310 */ - { 0x0000, 0x0000, 0x0000 }, /* R10311 */ - { 0x0000, 0x0000, 0x0000 }, /* R10312 */ - { 0x0000, 0x0000, 0x0000 }, /* R10313 */ - { 0x0000, 0x0000, 0x0000 }, /* R10314 */ - { 0x0000, 0x0000, 0x0000 }, /* R10315 */ - { 0x0000, 0x0000, 0x0000 }, /* R10316 */ - { 0x0000, 0x0000, 0x0000 }, /* R10317 */ - { 0x0000, 0x0000, 0x0000 }, /* R10318 */ - { 0x0000, 0x0000, 0x0000 }, /* R10319 */ - { 0x0000, 0x0000, 0x0000 }, /* R10320 */ - { 0x0000, 0x0000, 0x0000 }, /* R10321 */ - { 0x0000, 0x0000, 0x0000 }, /* R10322 */ - { 0x0000, 0x0000, 0x0000 }, /* R10323 */ - { 0x0000, 0x0000, 0x0000 }, /* R10324 */ - { 0x0000, 0x0000, 0x0000 }, /* R10325 */ - { 0x0000, 0x0000, 0x0000 }, /* R10326 */ - { 0x0000, 0x0000, 0x0000 }, /* R10327 */ - { 0x0000, 0x0000, 0x0000 }, /* R10328 */ - { 0x0000, 0x0000, 0x0000 }, /* R10329 */ - { 0x0000, 0x0000, 0x0000 }, /* R10330 */ - { 0x0000, 0x0000, 0x0000 }, /* R10331 */ - { 0x0000, 0x0000, 0x0000 }, /* R10332 */ - { 0x0000, 0x0000, 0x0000 }, /* R10333 */ - { 0x0000, 0x0000, 0x0000 }, /* R10334 */ - { 0x0000, 0x0000, 0x0000 }, /* R10335 */ - { 0x0000, 0x0000, 0x0000 }, /* R10336 */ - { 0x0000, 0x0000, 0x0000 }, /* R10337 */ - { 0x0000, 0x0000, 0x0000 }, /* R10338 */ - { 0x0000, 0x0000, 0x0000 }, /* R10339 */ - { 0x0000, 0x0000, 0x0000 }, /* R10340 */ - { 0x0000, 0x0000, 0x0000 }, /* R10341 */ - { 0x0000, 0x0000, 0x0000 }, /* R10342 */ - { 0x0000, 0x0000, 0x0000 }, /* R10343 */ - { 0x0000, 0x0000, 0x0000 }, /* R10344 */ - { 0x0000, 0x0000, 0x0000 }, /* R10345 */ - { 0x0000, 0x0000, 0x0000 }, /* R10346 */ - { 0x0000, 0x0000, 0x0000 }, /* R10347 */ - { 0x0000, 0x0000, 0x0000 }, /* R10348 */ - { 0x0000, 0x0000, 0x0000 }, /* R10349 */ - { 0x0000, 0x0000, 0x0000 }, /* R10350 */ - { 0x0000, 0x0000, 0x0000 }, /* R10351 */ - { 0x0000, 0x0000, 0x0000 }, /* R10352 */ - { 0x0000, 0x0000, 0x0000 }, /* R10353 */ - { 0x0000, 0x0000, 0x0000 }, /* R10354 */ - { 0x0000, 0x0000, 0x0000 }, /* R10355 */ - { 0x0000, 0x0000, 0x0000 }, /* R10356 */ - { 0x0000, 0x0000, 0x0000 }, /* R10357 */ - { 0x0000, 0x0000, 0x0000 }, /* R10358 */ - { 0x0000, 0x0000, 0x0000 }, /* R10359 */ - { 0x0000, 0x0000, 0x0000 }, /* R10360 */ - { 0x0000, 0x0000, 0x0000 }, /* R10361 */ - { 0x0000, 0x0000, 0x0000 }, /* R10362 */ - { 0x0000, 0x0000, 0x0000 }, /* R10363 */ - { 0x0000, 0x0000, 0x0000 }, /* R10364 */ - { 0x0000, 0x0000, 0x0000 }, /* R10365 */ - { 0x0000, 0x0000, 0x0000 }, /* R10366 */ - { 0x0000, 0x0000, 0x0000 }, /* R10367 */ - { 0x0000, 0x0000, 0x0000 }, /* R10368 */ - { 0x0000, 0x0000, 0x0000 }, /* R10369 */ - { 0x0000, 0x0000, 0x0000 }, /* R10370 */ - { 0x0000, 0x0000, 0x0000 }, /* R10371 */ - { 0x0000, 0x0000, 0x0000 }, /* R10372 */ - { 0x0000, 0x0000, 0x0000 }, /* R10373 */ - { 0x0000, 0x0000, 0x0000 }, /* R10374 */ - { 0x0000, 0x0000, 0x0000 }, /* R10375 */ - { 0x0000, 0x0000, 0x0000 }, /* R10376 */ - { 0x0000, 0x0000, 0x0000 }, /* R10377 */ - { 0x0000, 0x0000, 0x0000 }, /* R10378 */ - { 0x0000, 0x0000, 0x0000 }, /* R10379 */ - { 0x0000, 0x0000, 0x0000 }, /* R10380 */ - { 0x0000, 0x0000, 0x0000 }, /* R10381 */ - { 0x0000, 0x0000, 0x0000 }, /* R10382 */ - { 0x0000, 0x0000, 0x0000 }, /* R10383 */ - { 0x0000, 0x0000, 0x0000 }, /* R10384 */ - { 0x0000, 0x0000, 0x0000 }, /* R10385 */ - { 0x0000, 0x0000, 0x0000 }, /* R10386 */ - { 0x0000, 0x0000, 0x0000 }, /* R10387 */ - { 0x0000, 0x0000, 0x0000 }, /* R10388 */ - { 0x0000, 0x0000, 0x0000 }, /* R10389 */ - { 0x0000, 0x0000, 0x0000 }, /* R10390 */ - { 0x0000, 0x0000, 0x0000 }, /* R10391 */ - { 0x0000, 0x0000, 0x0000 }, /* R10392 */ - { 0x0000, 0x0000, 0x0000 }, /* R10393 */ - { 0x0000, 0x0000, 0x0000 }, /* R10394 */ - { 0x0000, 0x0000, 0x0000 }, /* R10395 */ - { 0x0000, 0x0000, 0x0000 }, /* R10396 */ - { 0x0000, 0x0000, 0x0000 }, /* R10397 */ - { 0x0000, 0x0000, 0x0000 }, /* R10398 */ - { 0x0000, 0x0000, 0x0000 }, /* R10399 */ - { 0x0000, 0x0000, 0x0000 }, /* R10400 */ - { 0x0000, 0x0000, 0x0000 }, /* R10401 */ - { 0x0000, 0x0000, 0x0000 }, /* R10402 */ - { 0x0000, 0x0000, 0x0000 }, /* R10403 */ - { 0x0000, 0x0000, 0x0000 }, /* R10404 */ - { 0x0000, 0x0000, 0x0000 }, /* R10405 */ - { 0x0000, 0x0000, 0x0000 }, /* R10406 */ - { 0x0000, 0x0000, 0x0000 }, /* R10407 */ - { 0x0000, 0x0000, 0x0000 }, /* R10408 */ - { 0x0000, 0x0000, 0x0000 }, /* R10409 */ - { 0x0000, 0x0000, 0x0000 }, /* R10410 */ - { 0x0000, 0x0000, 0x0000 }, /* R10411 */ - { 0x0000, 0x0000, 0x0000 }, /* R10412 */ - { 0x0000, 0x0000, 0x0000 }, /* R10413 */ - { 0x0000, 0x0000, 0x0000 }, /* R10414 */ - { 0x0000, 0x0000, 0x0000 }, /* R10415 */ - { 0x0000, 0x0000, 0x0000 }, /* R10416 */ - { 0x0000, 0x0000, 0x0000 }, /* R10417 */ - { 0x0000, 0x0000, 0x0000 }, /* R10418 */ - { 0x0000, 0x0000, 0x0000 }, /* R10419 */ - { 0x0000, 0x0000, 0x0000 }, /* R10420 */ - { 0x0000, 0x0000, 0x0000 }, /* R10421 */ - { 0x0000, 0x0000, 0x0000 }, /* R10422 */ - { 0x0000, 0x0000, 0x0000 }, /* R10423 */ - { 0x0000, 0x0000, 0x0000 }, /* R10424 */ - { 0x0000, 0x0000, 0x0000 }, /* R10425 */ - { 0x0000, 0x0000, 0x0000 }, /* R10426 */ - { 0x0000, 0x0000, 0x0000 }, /* R10427 */ - { 0x0000, 0x0000, 0x0000 }, /* R10428 */ - { 0x0000, 0x0000, 0x0000 }, /* R10429 */ - { 0x0000, 0x0000, 0x0000 }, /* R10430 */ - { 0x0000, 0x0000, 0x0000 }, /* R10431 */ - { 0x0000, 0x0000, 0x0000 }, /* R10432 */ - { 0x0000, 0x0000, 0x0000 }, /* R10433 */ - { 0x0000, 0x0000, 0x0000 }, /* R10434 */ - { 0x0000, 0x0000, 0x0000 }, /* R10435 */ - { 0x0000, 0x0000, 0x0000 }, /* R10436 */ - { 0x0000, 0x0000, 0x0000 }, /* R10437 */ - { 0x0000, 0x0000, 0x0000 }, /* R10438 */ - { 0x0000, 0x0000, 0x0000 }, /* R10439 */ - { 0x0000, 0x0000, 0x0000 }, /* R10440 */ - { 0x0000, 0x0000, 0x0000 }, /* R10441 */ - { 0x0000, 0x0000, 0x0000 }, /* R10442 */ - { 0x0000, 0x0000, 0x0000 }, /* R10443 */ - { 0x0000, 0x0000, 0x0000 }, /* R10444 */ - { 0x0000, 0x0000, 0x0000 }, /* R10445 */ - { 0x0000, 0x0000, 0x0000 }, /* R10446 */ - { 0x0000, 0x0000, 0x0000 }, /* R10447 */ - { 0x0000, 0x0000, 0x0000 }, /* R10448 */ - { 0x0000, 0x0000, 0x0000 }, /* R10449 */ - { 0x0000, 0x0000, 0x0000 }, /* R10450 */ - { 0x0000, 0x0000, 0x0000 }, /* R10451 */ - { 0x0000, 0x0000, 0x0000 }, /* R10452 */ - { 0x0000, 0x0000, 0x0000 }, /* R10453 */ - { 0x0000, 0x0000, 0x0000 }, /* R10454 */ - { 0x0000, 0x0000, 0x0000 }, /* R10455 */ - { 0x0000, 0x0000, 0x0000 }, /* R10456 */ - { 0x0000, 0x0000, 0x0000 }, /* R10457 */ - { 0x0000, 0x0000, 0x0000 }, /* R10458 */ - { 0x0000, 0x0000, 0x0000 }, /* R10459 */ - { 0x0000, 0x0000, 0x0000 }, /* R10460 */ - { 0x0000, 0x0000, 0x0000 }, /* R10461 */ - { 0x0000, 0x0000, 0x0000 }, /* R10462 */ - { 0x0000, 0x0000, 0x0000 }, /* R10463 */ - { 0x0000, 0x0000, 0x0000 }, /* R10464 */ - { 0x0000, 0x0000, 0x0000 }, /* R10465 */ - { 0x0000, 0x0000, 0x0000 }, /* R10466 */ - { 0x0000, 0x0000, 0x0000 }, /* R10467 */ - { 0x0000, 0x0000, 0x0000 }, /* R10468 */ - { 0x0000, 0x0000, 0x0000 }, /* R10469 */ - { 0x0000, 0x0000, 0x0000 }, /* R10470 */ - { 0x0000, 0x0000, 0x0000 }, /* R10471 */ - { 0x0000, 0x0000, 0x0000 }, /* R10472 */ - { 0x0000, 0x0000, 0x0000 }, /* R10473 */ - { 0x0000, 0x0000, 0x0000 }, /* R10474 */ - { 0x0000, 0x0000, 0x0000 }, /* R10475 */ - { 0x0000, 0x0000, 0x0000 }, /* R10476 */ - { 0x0000, 0x0000, 0x0000 }, /* R10477 */ - { 0x0000, 0x0000, 0x0000 }, /* R10478 */ - { 0x0000, 0x0000, 0x0000 }, /* R10479 */ - { 0x0000, 0x0000, 0x0000 }, /* R10480 */ - { 0x0000, 0x0000, 0x0000 }, /* R10481 */ - { 0x0000, 0x0000, 0x0000 }, /* R10482 */ - { 0x0000, 0x0000, 0x0000 }, /* R10483 */ - { 0x0000, 0x0000, 0x0000 }, /* R10484 */ - { 0x0000, 0x0000, 0x0000 }, /* R10485 */ - { 0x0000, 0x0000, 0x0000 }, /* R10486 */ - { 0x0000, 0x0000, 0x0000 }, /* R10487 */ - { 0x0000, 0x0000, 0x0000 }, /* R10488 */ - { 0x0000, 0x0000, 0x0000 }, /* R10489 */ - { 0x0000, 0x0000, 0x0000 }, /* R10490 */ - { 0x0000, 0x0000, 0x0000 }, /* R10491 */ - { 0x0000, 0x0000, 0x0000 }, /* R10492 */ - { 0x0000, 0x0000, 0x0000 }, /* R10493 */ - { 0x0000, 0x0000, 0x0000 }, /* R10494 */ - { 0x0000, 0x0000, 0x0000 }, /* R10495 */ - { 0x0000, 0x0000, 0x0000 }, /* R10496 */ - { 0x0000, 0x0000, 0x0000 }, /* R10497 */ - { 0x0000, 0x0000, 0x0000 }, /* R10498 */ - { 0x0000, 0x0000, 0x0000 }, /* R10499 */ - { 0x0000, 0x0000, 0x0000 }, /* R10500 */ - { 0x0000, 0x0000, 0x0000 }, /* R10501 */ - { 0x0000, 0x0000, 0x0000 }, /* R10502 */ - { 0x0000, 0x0000, 0x0000 }, /* R10503 */ - { 0x0000, 0x0000, 0x0000 }, /* R10504 */ - { 0x0000, 0x0000, 0x0000 }, /* R10505 */ - { 0x0000, 0x0000, 0x0000 }, /* R10506 */ - { 0x0000, 0x0000, 0x0000 }, /* R10507 */ - { 0x0000, 0x0000, 0x0000 }, /* R10508 */ - { 0x0000, 0x0000, 0x0000 }, /* R10509 */ - { 0x0000, 0x0000, 0x0000 }, /* R10510 */ - { 0x0000, 0x0000, 0x0000 }, /* R10511 */ - { 0x0000, 0x0000, 0x0000 }, /* R10512 */ - { 0x0000, 0x0000, 0x0000 }, /* R10513 */ - { 0x0000, 0x0000, 0x0000 }, /* R10514 */ - { 0x0000, 0x0000, 0x0000 }, /* R10515 */ - { 0x0000, 0x0000, 0x0000 }, /* R10516 */ - { 0x0000, 0x0000, 0x0000 }, /* R10517 */ - { 0x0000, 0x0000, 0x0000 }, /* R10518 */ - { 0x0000, 0x0000, 0x0000 }, /* R10519 */ - { 0x0000, 0x0000, 0x0000 }, /* R10520 */ - { 0x0000, 0x0000, 0x0000 }, /* R10521 */ - { 0x0000, 0x0000, 0x0000 }, /* R10522 */ - { 0x0000, 0x0000, 0x0000 }, /* R10523 */ - { 0x0000, 0x0000, 0x0000 }, /* R10524 */ - { 0x0000, 0x0000, 0x0000 }, /* R10525 */ - { 0x0000, 0x0000, 0x0000 }, /* R10526 */ - { 0x0000, 0x0000, 0x0000 }, /* R10527 */ - { 0x0000, 0x0000, 0x0000 }, /* R10528 */ - { 0x0000, 0x0000, 0x0000 }, /* R10529 */ - { 0x0000, 0x0000, 0x0000 }, /* R10530 */ - { 0x0000, 0x0000, 0x0000 }, /* R10531 */ - { 0x0000, 0x0000, 0x0000 }, /* R10532 */ - { 0x0000, 0x0000, 0x0000 }, /* R10533 */ - { 0x0000, 0x0000, 0x0000 }, /* R10534 */ - { 0x0000, 0x0000, 0x0000 }, /* R10535 */ - { 0x0000, 0x0000, 0x0000 }, /* R10536 */ - { 0x0000, 0x0000, 0x0000 }, /* R10537 */ - { 0x0000, 0x0000, 0x0000 }, /* R10538 */ - { 0x0000, 0x0000, 0x0000 }, /* R10539 */ - { 0x0000, 0x0000, 0x0000 }, /* R10540 */ - { 0x0000, 0x0000, 0x0000 }, /* R10541 */ - { 0x0000, 0x0000, 0x0000 }, /* R10542 */ - { 0x0000, 0x0000, 0x0000 }, /* R10543 */ - { 0x0000, 0x0000, 0x0000 }, /* R10544 */ - { 0x0000, 0x0000, 0x0000 }, /* R10545 */ - { 0x0000, 0x0000, 0x0000 }, /* R10546 */ - { 0x0000, 0x0000, 0x0000 }, /* R10547 */ - { 0x0000, 0x0000, 0x0000 }, /* R10548 */ - { 0x0000, 0x0000, 0x0000 }, /* R10549 */ - { 0x0000, 0x0000, 0x0000 }, /* R10550 */ - { 0x0000, 0x0000, 0x0000 }, /* R10551 */ - { 0x0000, 0x0000, 0x0000 }, /* R10552 */ - { 0x0000, 0x0000, 0x0000 }, /* R10553 */ - { 0x0000, 0x0000, 0x0000 }, /* R10554 */ - { 0x0000, 0x0000, 0x0000 }, /* R10555 */ - { 0x0000, 0x0000, 0x0000 }, /* R10556 */ - { 0x0000, 0x0000, 0x0000 }, /* R10557 */ - { 0x0000, 0x0000, 0x0000 }, /* R10558 */ - { 0x0000, 0x0000, 0x0000 }, /* R10559 */ - { 0x0000, 0x0000, 0x0000 }, /* R10560 */ - { 0x0000, 0x0000, 0x0000 }, /* R10561 */ - { 0x0000, 0x0000, 0x0000 }, /* R10562 */ - { 0x0000, 0x0000, 0x0000 }, /* R10563 */ - { 0x0000, 0x0000, 0x0000 }, /* R10564 */ - { 0x0000, 0x0000, 0x0000 }, /* R10565 */ - { 0x0000, 0x0000, 0x0000 }, /* R10566 */ - { 0x0000, 0x0000, 0x0000 }, /* R10567 */ - { 0x0000, 0x0000, 0x0000 }, /* R10568 */ - { 0x0000, 0x0000, 0x0000 }, /* R10569 */ - { 0x0000, 0x0000, 0x0000 }, /* R10570 */ - { 0x0000, 0x0000, 0x0000 }, /* R10571 */ - { 0x0000, 0x0000, 0x0000 }, /* R10572 */ - { 0x0000, 0x0000, 0x0000 }, /* R10573 */ - { 0x0000, 0x0000, 0x0000 }, /* R10574 */ - { 0x0000, 0x0000, 0x0000 }, /* R10575 */ - { 0x0000, 0x0000, 0x0000 }, /* R10576 */ - { 0x0000, 0x0000, 0x0000 }, /* R10577 */ - { 0x0000, 0x0000, 0x0000 }, /* R10578 */ - { 0x0000, 0x0000, 0x0000 }, /* R10579 */ - { 0x0000, 0x0000, 0x0000 }, /* R10580 */ - { 0x0000, 0x0000, 0x0000 }, /* R10581 */ - { 0x0000, 0x0000, 0x0000 }, /* R10582 */ - { 0x0000, 0x0000, 0x0000 }, /* R10583 */ - { 0x0000, 0x0000, 0x0000 }, /* R10584 */ - { 0x0000, 0x0000, 0x0000 }, /* R10585 */ - { 0x0000, 0x0000, 0x0000 }, /* R10586 */ - { 0x0000, 0x0000, 0x0000 }, /* R10587 */ - { 0x0000, 0x0000, 0x0000 }, /* R10588 */ - { 0x0000, 0x0000, 0x0000 }, /* R10589 */ - { 0x0000, 0x0000, 0x0000 }, /* R10590 */ - { 0x0000, 0x0000, 0x0000 }, /* R10591 */ - { 0x0000, 0x0000, 0x0000 }, /* R10592 */ - { 0x0000, 0x0000, 0x0000 }, /* R10593 */ - { 0x0000, 0x0000, 0x0000 }, /* R10594 */ - { 0x0000, 0x0000, 0x0000 }, /* R10595 */ - { 0x0000, 0x0000, 0x0000 }, /* R10596 */ - { 0x0000, 0x0000, 0x0000 }, /* R10597 */ - { 0x0000, 0x0000, 0x0000 }, /* R10598 */ - { 0x0000, 0x0000, 0x0000 }, /* R10599 */ - { 0x0000, 0x0000, 0x0000 }, /* R10600 */ - { 0x0000, 0x0000, 0x0000 }, /* R10601 */ - { 0x0000, 0x0000, 0x0000 }, /* R10602 */ - { 0x0000, 0x0000, 0x0000 }, /* R10603 */ - { 0x0000, 0x0000, 0x0000 }, /* R10604 */ - { 0x0000, 0x0000, 0x0000 }, /* R10605 */ - { 0x0000, 0x0000, 0x0000 }, /* R10606 */ - { 0x0000, 0x0000, 0x0000 }, /* R10607 */ - { 0x0000, 0x0000, 0x0000 }, /* R10608 */ - { 0x0000, 0x0000, 0x0000 }, /* R10609 */ - { 0x0000, 0x0000, 0x0000 }, /* R10610 */ - { 0x0000, 0x0000, 0x0000 }, /* R10611 */ - { 0x0000, 0x0000, 0x0000 }, /* R10612 */ - { 0x0000, 0x0000, 0x0000 }, /* R10613 */ - { 0x0000, 0x0000, 0x0000 }, /* R10614 */ - { 0x0000, 0x0000, 0x0000 }, /* R10615 */ - { 0x0000, 0x0000, 0x0000 }, /* R10616 */ - { 0x0000, 0x0000, 0x0000 }, /* R10617 */ - { 0x0000, 0x0000, 0x0000 }, /* R10618 */ - { 0x0000, 0x0000, 0x0000 }, /* R10619 */ - { 0x0000, 0x0000, 0x0000 }, /* R10620 */ - { 0x0000, 0x0000, 0x0000 }, /* R10621 */ - { 0x0000, 0x0000, 0x0000 }, /* R10622 */ - { 0x0000, 0x0000, 0x0000 }, /* R10623 */ - { 0x0000, 0x0000, 0x0000 }, /* R10624 */ - { 0x0000, 0x0000, 0x0000 }, /* R10625 */ - { 0x0000, 0x0000, 0x0000 }, /* R10626 */ - { 0x0000, 0x0000, 0x0000 }, /* R10627 */ - { 0x0000, 0x0000, 0x0000 }, /* R10628 */ - { 0x0000, 0x0000, 0x0000 }, /* R10629 */ - { 0x0000, 0x0000, 0x0000 }, /* R10630 */ - { 0x0000, 0x0000, 0x0000 }, /* R10631 */ - { 0x0000, 0x0000, 0x0000 }, /* R10632 */ - { 0x0000, 0x0000, 0x0000 }, /* R10633 */ - { 0x0000, 0x0000, 0x0000 }, /* R10634 */ - { 0x0000, 0x0000, 0x0000 }, /* R10635 */ - { 0x0000, 0x0000, 0x0000 }, /* R10636 */ - { 0x0000, 0x0000, 0x0000 }, /* R10637 */ - { 0x0000, 0x0000, 0x0000 }, /* R10638 */ - { 0x0000, 0x0000, 0x0000 }, /* R10639 */ - { 0x0000, 0x0000, 0x0000 }, /* R10640 */ - { 0x0000, 0x0000, 0x0000 }, /* R10641 */ - { 0x0000, 0x0000, 0x0000 }, /* R10642 */ - { 0x0000, 0x0000, 0x0000 }, /* R10643 */ - { 0x0000, 0x0000, 0x0000 }, /* R10644 */ - { 0x0000, 0x0000, 0x0000 }, /* R10645 */ - { 0x0000, 0x0000, 0x0000 }, /* R10646 */ - { 0x0000, 0x0000, 0x0000 }, /* R10647 */ - { 0x0000, 0x0000, 0x0000 }, /* R10648 */ - { 0x0000, 0x0000, 0x0000 }, /* R10649 */ - { 0x0000, 0x0000, 0x0000 }, /* R10650 */ - { 0x0000, 0x0000, 0x0000 }, /* R10651 */ - { 0x0000, 0x0000, 0x0000 }, /* R10652 */ - { 0x0000, 0x0000, 0x0000 }, /* R10653 */ - { 0x0000, 0x0000, 0x0000 }, /* R10654 */ - { 0x0000, 0x0000, 0x0000 }, /* R10655 */ - { 0x0000, 0x0000, 0x0000 }, /* R10656 */ - { 0x0000, 0x0000, 0x0000 }, /* R10657 */ - { 0x0000, 0x0000, 0x0000 }, /* R10658 */ - { 0x0000, 0x0000, 0x0000 }, /* R10659 */ - { 0x0000, 0x0000, 0x0000 }, /* R10660 */ - { 0x0000, 0x0000, 0x0000 }, /* R10661 */ - { 0x0000, 0x0000, 0x0000 }, /* R10662 */ - { 0x0000, 0x0000, 0x0000 }, /* R10663 */ - { 0x0000, 0x0000, 0x0000 }, /* R10664 */ - { 0x0000, 0x0000, 0x0000 }, /* R10665 */ - { 0x0000, 0x0000, 0x0000 }, /* R10666 */ - { 0x0000, 0x0000, 0x0000 }, /* R10667 */ - { 0x0000, 0x0000, 0x0000 }, /* R10668 */ - { 0x0000, 0x0000, 0x0000 }, /* R10669 */ - { 0x0000, 0x0000, 0x0000 }, /* R10670 */ - { 0x0000, 0x0000, 0x0000 }, /* R10671 */ - { 0x0000, 0x0000, 0x0000 }, /* R10672 */ - { 0x0000, 0x0000, 0x0000 }, /* R10673 */ - { 0x0000, 0x0000, 0x0000 }, /* R10674 */ - { 0x0000, 0x0000, 0x0000 }, /* R10675 */ - { 0x0000, 0x0000, 0x0000 }, /* R10676 */ - { 0x0000, 0x0000, 0x0000 }, /* R10677 */ - { 0x0000, 0x0000, 0x0000 }, /* R10678 */ - { 0x0000, 0x0000, 0x0000 }, /* R10679 */ - { 0x0000, 0x0000, 0x0000 }, /* R10680 */ - { 0x0000, 0x0000, 0x0000 }, /* R10681 */ - { 0x0000, 0x0000, 0x0000 }, /* R10682 */ - { 0x0000, 0x0000, 0x0000 }, /* R10683 */ - { 0x0000, 0x0000, 0x0000 }, /* R10684 */ - { 0x0000, 0x0000, 0x0000 }, /* R10685 */ - { 0x0000, 0x0000, 0x0000 }, /* R10686 */ - { 0x0000, 0x0000, 0x0000 }, /* R10687 */ - { 0x0000, 0x0000, 0x0000 }, /* R10688 */ - { 0x0000, 0x0000, 0x0000 }, /* R10689 */ - { 0x0000, 0x0000, 0x0000 }, /* R10690 */ - { 0x0000, 0x0000, 0x0000 }, /* R10691 */ - { 0x0000, 0x0000, 0x0000 }, /* R10692 */ - { 0x0000, 0x0000, 0x0000 }, /* R10693 */ - { 0x0000, 0x0000, 0x0000 }, /* R10694 */ - { 0x0000, 0x0000, 0x0000 }, /* R10695 */ - { 0x0000, 0x0000, 0x0000 }, /* R10696 */ - { 0x0000, 0x0000, 0x0000 }, /* R10697 */ - { 0x0000, 0x0000, 0x0000 }, /* R10698 */ - { 0x0000, 0x0000, 0x0000 }, /* R10699 */ - { 0x0000, 0x0000, 0x0000 }, /* R10700 */ - { 0x0000, 0x0000, 0x0000 }, /* R10701 */ - { 0x0000, 0x0000, 0x0000 }, /* R10702 */ - { 0x0000, 0x0000, 0x0000 }, /* R10703 */ - { 0x0000, 0x0000, 0x0000 }, /* R10704 */ - { 0x0000, 0x0000, 0x0000 }, /* R10705 */ - { 0x0000, 0x0000, 0x0000 }, /* R10706 */ - { 0x0000, 0x0000, 0x0000 }, /* R10707 */ - { 0x0000, 0x0000, 0x0000 }, /* R10708 */ - { 0x0000, 0x0000, 0x0000 }, /* R10709 */ - { 0x0000, 0x0000, 0x0000 }, /* R10710 */ - { 0x0000, 0x0000, 0x0000 }, /* R10711 */ - { 0x0000, 0x0000, 0x0000 }, /* R10712 */ - { 0x0000, 0x0000, 0x0000 }, /* R10713 */ - { 0x0000, 0x0000, 0x0000 }, /* R10714 */ - { 0x0000, 0x0000, 0x0000 }, /* R10715 */ - { 0x0000, 0x0000, 0x0000 }, /* R10716 */ - { 0x0000, 0x0000, 0x0000 }, /* R10717 */ - { 0x0000, 0x0000, 0x0000 }, /* R10718 */ - { 0x0000, 0x0000, 0x0000 }, /* R10719 */ - { 0x0000, 0x0000, 0x0000 }, /* R10720 */ - { 0x0000, 0x0000, 0x0000 }, /* R10721 */ - { 0x0000, 0x0000, 0x0000 }, /* R10722 */ - { 0x0000, 0x0000, 0x0000 }, /* R10723 */ - { 0x0000, 0x0000, 0x0000 }, /* R10724 */ - { 0x0000, 0x0000, 0x0000 }, /* R10725 */ - { 0x0000, 0x0000, 0x0000 }, /* R10726 */ - { 0x0000, 0x0000, 0x0000 }, /* R10727 */ - { 0x0000, 0x0000, 0x0000 }, /* R10728 */ - { 0x0000, 0x0000, 0x0000 }, /* R10729 */ - { 0x0000, 0x0000, 0x0000 }, /* R10730 */ - { 0x0000, 0x0000, 0x0000 }, /* R10731 */ - { 0x0000, 0x0000, 0x0000 }, /* R10732 */ - { 0x0000, 0x0000, 0x0000 }, /* R10733 */ - { 0x0000, 0x0000, 0x0000 }, /* R10734 */ - { 0x0000, 0x0000, 0x0000 }, /* R10735 */ - { 0x0000, 0x0000, 0x0000 }, /* R10736 */ - { 0x0000, 0x0000, 0x0000 }, /* R10737 */ - { 0x0000, 0x0000, 0x0000 }, /* R10738 */ - { 0x0000, 0x0000, 0x0000 }, /* R10739 */ - { 0x0000, 0x0000, 0x0000 }, /* R10740 */ - { 0x0000, 0x0000, 0x0000 }, /* R10741 */ - { 0x0000, 0x0000, 0x0000 }, /* R10742 */ - { 0x0000, 0x0000, 0x0000 }, /* R10743 */ - { 0x0000, 0x0000, 0x0000 }, /* R10744 */ - { 0x0000, 0x0000, 0x0000 }, /* R10745 */ - { 0x0000, 0x0000, 0x0000 }, /* R10746 */ - { 0x0000, 0x0000, 0x0000 }, /* R10747 */ - { 0x0000, 0x0000, 0x0000 }, /* R10748 */ - { 0x0000, 0x0000, 0x0000 }, /* R10749 */ - { 0x0000, 0x0000, 0x0000 }, /* R10750 */ - { 0x0000, 0x0000, 0x0000 }, /* R10751 */ - { 0x0000, 0x0000, 0x0000 }, /* R10752 */ - { 0x0000, 0x0000, 0x0000 }, /* R10753 */ - { 0x0000, 0x0000, 0x0000 }, /* R10754 */ - { 0x0000, 0x0000, 0x0000 }, /* R10755 */ - { 0x0000, 0x0000, 0x0000 }, /* R10756 */ - { 0x0000, 0x0000, 0x0000 }, /* R10757 */ - { 0x0000, 0x0000, 0x0000 }, /* R10758 */ - { 0x0000, 0x0000, 0x0000 }, /* R10759 */ - { 0x0000, 0x0000, 0x0000 }, /* R10760 */ - { 0x0000, 0x0000, 0x0000 }, /* R10761 */ - { 0x0000, 0x0000, 0x0000 }, /* R10762 */ - { 0x0000, 0x0000, 0x0000 }, /* R10763 */ - { 0x0000, 0x0000, 0x0000 }, /* R10764 */ - { 0x0000, 0x0000, 0x0000 }, /* R10765 */ - { 0x0000, 0x0000, 0x0000 }, /* R10766 */ - { 0x0000, 0x0000, 0x0000 }, /* R10767 */ - { 0x0000, 0x0000, 0x0000 }, /* R10768 */ - { 0x0000, 0x0000, 0x0000 }, /* R10769 */ - { 0x0000, 0x0000, 0x0000 }, /* R10770 */ - { 0x0000, 0x0000, 0x0000 }, /* R10771 */ - { 0x0000, 0x0000, 0x0000 }, /* R10772 */ - { 0x0000, 0x0000, 0x0000 }, /* R10773 */ - { 0x0000, 0x0000, 0x0000 }, /* R10774 */ - { 0x0000, 0x0000, 0x0000 }, /* R10775 */ - { 0x0000, 0x0000, 0x0000 }, /* R10776 */ - { 0x0000, 0x0000, 0x0000 }, /* R10777 */ - { 0x0000, 0x0000, 0x0000 }, /* R10778 */ - { 0x0000, 0x0000, 0x0000 }, /* R10779 */ - { 0x0000, 0x0000, 0x0000 }, /* R10780 */ - { 0x0000, 0x0000, 0x0000 }, /* R10781 */ - { 0x0000, 0x0000, 0x0000 }, /* R10782 */ - { 0x0000, 0x0000, 0x0000 }, /* R10783 */ - { 0x0000, 0x0000, 0x0000 }, /* R10784 */ - { 0x0000, 0x0000, 0x0000 }, /* R10785 */ - { 0x0000, 0x0000, 0x0000 }, /* R10786 */ - { 0x0000, 0x0000, 0x0000 }, /* R10787 */ - { 0x0000, 0x0000, 0x0000 }, /* R10788 */ - { 0x0000, 0x0000, 0x0000 }, /* R10789 */ - { 0x0000, 0x0000, 0x0000 }, /* R10790 */ - { 0x0000, 0x0000, 0x0000 }, /* R10791 */ - { 0x0000, 0x0000, 0x0000 }, /* R10792 */ - { 0x0000, 0x0000, 0x0000 }, /* R10793 */ - { 0x0000, 0x0000, 0x0000 }, /* R10794 */ - { 0x0000, 0x0000, 0x0000 }, /* R10795 */ - { 0x0000, 0x0000, 0x0000 }, /* R10796 */ - { 0x0000, 0x0000, 0x0000 }, /* R10797 */ - { 0x0000, 0x0000, 0x0000 }, /* R10798 */ - { 0x0000, 0x0000, 0x0000 }, /* R10799 */ - { 0x0000, 0x0000, 0x0000 }, /* R10800 */ - { 0x0000, 0x0000, 0x0000 }, /* R10801 */ - { 0x0000, 0x0000, 0x0000 }, /* R10802 */ - { 0x0000, 0x0000, 0x0000 }, /* R10803 */ - { 0x0000, 0x0000, 0x0000 }, /* R10804 */ - { 0x0000, 0x0000, 0x0000 }, /* R10805 */ - { 0x0000, 0x0000, 0x0000 }, /* R10806 */ - { 0x0000, 0x0000, 0x0000 }, /* R10807 */ - { 0x0000, 0x0000, 0x0000 }, /* R10808 */ - { 0x0000, 0x0000, 0x0000 }, /* R10809 */ - { 0x0000, 0x0000, 0x0000 }, /* R10810 */ - { 0x0000, 0x0000, 0x0000 }, /* R10811 */ - { 0x0000, 0x0000, 0x0000 }, /* R10812 */ - { 0x0000, 0x0000, 0x0000 }, /* R10813 */ - { 0x0000, 0x0000, 0x0000 }, /* R10814 */ - { 0x0000, 0x0000, 0x0000 }, /* R10815 */ - { 0x0000, 0x0000, 0x0000 }, /* R10816 */ - { 0x0000, 0x0000, 0x0000 }, /* R10817 */ - { 0x0000, 0x0000, 0x0000 }, /* R10818 */ - { 0x0000, 0x0000, 0x0000 }, /* R10819 */ - { 0x0000, 0x0000, 0x0000 }, /* R10820 */ - { 0x0000, 0x0000, 0x0000 }, /* R10821 */ - { 0x0000, 0x0000, 0x0000 }, /* R10822 */ - { 0x0000, 0x0000, 0x0000 }, /* R10823 */ - { 0x0000, 0x0000, 0x0000 }, /* R10824 */ - { 0x0000, 0x0000, 0x0000 }, /* R10825 */ - { 0x0000, 0x0000, 0x0000 }, /* R10826 */ - { 0x0000, 0x0000, 0x0000 }, /* R10827 */ - { 0x0000, 0x0000, 0x0000 }, /* R10828 */ - { 0x0000, 0x0000, 0x0000 }, /* R10829 */ - { 0x0000, 0x0000, 0x0000 }, /* R10830 */ - { 0x0000, 0x0000, 0x0000 }, /* R10831 */ - { 0x0000, 0x0000, 0x0000 }, /* R10832 */ - { 0x0000, 0x0000, 0x0000 }, /* R10833 */ - { 0x0000, 0x0000, 0x0000 }, /* R10834 */ - { 0x0000, 0x0000, 0x0000 }, /* R10835 */ - { 0x0000, 0x0000, 0x0000 }, /* R10836 */ - { 0x0000, 0x0000, 0x0000 }, /* R10837 */ - { 0x0000, 0x0000, 0x0000 }, /* R10838 */ - { 0x0000, 0x0000, 0x0000 }, /* R10839 */ - { 0x0000, 0x0000, 0x0000 }, /* R10840 */ - { 0x0000, 0x0000, 0x0000 }, /* R10841 */ - { 0x0000, 0x0000, 0x0000 }, /* R10842 */ - { 0x0000, 0x0000, 0x0000 }, /* R10843 */ - { 0x0000, 0x0000, 0x0000 }, /* R10844 */ - { 0x0000, 0x0000, 0x0000 }, /* R10845 */ - { 0x0000, 0x0000, 0x0000 }, /* R10846 */ - { 0x0000, 0x0000, 0x0000 }, /* R10847 */ - { 0x0000, 0x0000, 0x0000 }, /* R10848 */ - { 0x0000, 0x0000, 0x0000 }, /* R10849 */ - { 0x0000, 0x0000, 0x0000 }, /* R10850 */ - { 0x0000, 0x0000, 0x0000 }, /* R10851 */ - { 0x0000, 0x0000, 0x0000 }, /* R10852 */ - { 0x0000, 0x0000, 0x0000 }, /* R10853 */ - { 0x0000, 0x0000, 0x0000 }, /* R10854 */ - { 0x0000, 0x0000, 0x0000 }, /* R10855 */ - { 0x0000, 0x0000, 0x0000 }, /* R10856 */ - { 0x0000, 0x0000, 0x0000 }, /* R10857 */ - { 0x0000, 0x0000, 0x0000 }, /* R10858 */ - { 0x0000, 0x0000, 0x0000 }, /* R10859 */ - { 0x0000, 0x0000, 0x0000 }, /* R10860 */ - { 0x0000, 0x0000, 0x0000 }, /* R10861 */ - { 0x0000, 0x0000, 0x0000 }, /* R10862 */ - { 0x0000, 0x0000, 0x0000 }, /* R10863 */ - { 0x0000, 0x0000, 0x0000 }, /* R10864 */ - { 0x0000, 0x0000, 0x0000 }, /* R10865 */ - { 0x0000, 0x0000, 0x0000 }, /* R10866 */ - { 0x0000, 0x0000, 0x0000 }, /* R10867 */ - { 0x0000, 0x0000, 0x0000 }, /* R10868 */ - { 0x0000, 0x0000, 0x0000 }, /* R10869 */ - { 0x0000, 0x0000, 0x0000 }, /* R10870 */ - { 0x0000, 0x0000, 0x0000 }, /* R10871 */ - { 0x0000, 0x0000, 0x0000 }, /* R10872 */ - { 0x0000, 0x0000, 0x0000 }, /* R10873 */ - { 0x0000, 0x0000, 0x0000 }, /* R10874 */ - { 0x0000, 0x0000, 0x0000 }, /* R10875 */ - { 0x0000, 0x0000, 0x0000 }, /* R10876 */ - { 0x0000, 0x0000, 0x0000 }, /* R10877 */ - { 0x0000, 0x0000, 0x0000 }, /* R10878 */ - { 0x0000, 0x0000, 0x0000 }, /* R10879 */ - { 0x0000, 0x0000, 0x0000 }, /* R10880 */ - { 0x0000, 0x0000, 0x0000 }, /* R10881 */ - { 0x0000, 0x0000, 0x0000 }, /* R10882 */ - { 0x0000, 0x0000, 0x0000 }, /* R10883 */ - { 0x0000, 0x0000, 0x0000 }, /* R10884 */ - { 0x0000, 0x0000, 0x0000 }, /* R10885 */ - { 0x0000, 0x0000, 0x0000 }, /* R10886 */ - { 0x0000, 0x0000, 0x0000 }, /* R10887 */ - { 0x0000, 0x0000, 0x0000 }, /* R10888 */ - { 0x0000, 0x0000, 0x0000 }, /* R10889 */ - { 0x0000, 0x0000, 0x0000 }, /* R10890 */ - { 0x0000, 0x0000, 0x0000 }, /* R10891 */ - { 0x0000, 0x0000, 0x0000 }, /* R10892 */ - { 0x0000, 0x0000, 0x0000 }, /* R10893 */ - { 0x0000, 0x0000, 0x0000 }, /* R10894 */ - { 0x0000, 0x0000, 0x0000 }, /* R10895 */ - { 0x0000, 0x0000, 0x0000 }, /* R10896 */ - { 0x0000, 0x0000, 0x0000 }, /* R10897 */ - { 0x0000, 0x0000, 0x0000 }, /* R10898 */ - { 0x0000, 0x0000, 0x0000 }, /* R10899 */ - { 0x0000, 0x0000, 0x0000 }, /* R10900 */ - { 0x0000, 0x0000, 0x0000 }, /* R10901 */ - { 0x0000, 0x0000, 0x0000 }, /* R10902 */ - { 0x0000, 0x0000, 0x0000 }, /* R10903 */ - { 0x0000, 0x0000, 0x0000 }, /* R10904 */ - { 0x0000, 0x0000, 0x0000 }, /* R10905 */ - { 0x0000, 0x0000, 0x0000 }, /* R10906 */ - { 0x0000, 0x0000, 0x0000 }, /* R10907 */ - { 0x0000, 0x0000, 0x0000 }, /* R10908 */ - { 0x0000, 0x0000, 0x0000 }, /* R10909 */ - { 0x0000, 0x0000, 0x0000 }, /* R10910 */ - { 0x0000, 0x0000, 0x0000 }, /* R10911 */ - { 0x0000, 0x0000, 0x0000 }, /* R10912 */ - { 0x0000, 0x0000, 0x0000 }, /* R10913 */ - { 0x0000, 0x0000, 0x0000 }, /* R10914 */ - { 0x0000, 0x0000, 0x0000 }, /* R10915 */ - { 0x0000, 0x0000, 0x0000 }, /* R10916 */ - { 0x0000, 0x0000, 0x0000 }, /* R10917 */ - { 0x0000, 0x0000, 0x0000 }, /* R10918 */ - { 0x0000, 0x0000, 0x0000 }, /* R10919 */ - { 0x0000, 0x0000, 0x0000 }, /* R10920 */ - { 0x0000, 0x0000, 0x0000 }, /* R10921 */ - { 0x0000, 0x0000, 0x0000 }, /* R10922 */ - { 0x0000, 0x0000, 0x0000 }, /* R10923 */ - { 0x0000, 0x0000, 0x0000 }, /* R10924 */ - { 0x0000, 0x0000, 0x0000 }, /* R10925 */ - { 0x0000, 0x0000, 0x0000 }, /* R10926 */ - { 0x0000, 0x0000, 0x0000 }, /* R10927 */ - { 0x0000, 0x0000, 0x0000 }, /* R10928 */ - { 0x0000, 0x0000, 0x0000 }, /* R10929 */ - { 0x0000, 0x0000, 0x0000 }, /* R10930 */ - { 0x0000, 0x0000, 0x0000 }, /* R10931 */ - { 0x0000, 0x0000, 0x0000 }, /* R10932 */ - { 0x0000, 0x0000, 0x0000 }, /* R10933 */ - { 0x0000, 0x0000, 0x0000 }, /* R10934 */ - { 0x0000, 0x0000, 0x0000 }, /* R10935 */ - { 0x0000, 0x0000, 0x0000 }, /* R10936 */ - { 0x0000, 0x0000, 0x0000 }, /* R10937 */ - { 0x0000, 0x0000, 0x0000 }, /* R10938 */ - { 0x0000, 0x0000, 0x0000 }, /* R10939 */ - { 0x0000, 0x0000, 0x0000 }, /* R10940 */ - { 0x0000, 0x0000, 0x0000 }, /* R10941 */ - { 0x0000, 0x0000, 0x0000 }, /* R10942 */ - { 0x0000, 0x0000, 0x0000 }, /* R10943 */ - { 0x0000, 0x0000, 0x0000 }, /* R10944 */ - { 0x0000, 0x0000, 0x0000 }, /* R10945 */ - { 0x0000, 0x0000, 0x0000 }, /* R10946 */ - { 0x0000, 0x0000, 0x0000 }, /* R10947 */ - { 0x0000, 0x0000, 0x0000 }, /* R10948 */ - { 0x0000, 0x0000, 0x0000 }, /* R10949 */ - { 0x0000, 0x0000, 0x0000 }, /* R10950 */ - { 0x0000, 0x0000, 0x0000 }, /* R10951 */ - { 0x0000, 0x0000, 0x0000 }, /* R10952 */ - { 0x0000, 0x0000, 0x0000 }, /* R10953 */ - { 0x0000, 0x0000, 0x0000 }, /* R10954 */ - { 0x0000, 0x0000, 0x0000 }, /* R10955 */ - { 0x0000, 0x0000, 0x0000 }, /* R10956 */ - { 0x0000, 0x0000, 0x0000 }, /* R10957 */ - { 0x0000, 0x0000, 0x0000 }, /* R10958 */ - { 0x0000, 0x0000, 0x0000 }, /* R10959 */ - { 0x0000, 0x0000, 0x0000 }, /* R10960 */ - { 0x0000, 0x0000, 0x0000 }, /* R10961 */ - { 0x0000, 0x0000, 0x0000 }, /* R10962 */ - { 0x0000, 0x0000, 0x0000 }, /* R10963 */ - { 0x0000, 0x0000, 0x0000 }, /* R10964 */ - { 0x0000, 0x0000, 0x0000 }, /* R10965 */ - { 0x0000, 0x0000, 0x0000 }, /* R10966 */ - { 0x0000, 0x0000, 0x0000 }, /* R10967 */ - { 0x0000, 0x0000, 0x0000 }, /* R10968 */ - { 0x0000, 0x0000, 0x0000 }, /* R10969 */ - { 0x0000, 0x0000, 0x0000 }, /* R10970 */ - { 0x0000, 0x0000, 0x0000 }, /* R10971 */ - { 0x0000, 0x0000, 0x0000 }, /* R10972 */ - { 0x0000, 0x0000, 0x0000 }, /* R10973 */ - { 0x0000, 0x0000, 0x0000 }, /* R10974 */ - { 0x0000, 0x0000, 0x0000 }, /* R10975 */ - { 0x0000, 0x0000, 0x0000 }, /* R10976 */ - { 0x0000, 0x0000, 0x0000 }, /* R10977 */ - { 0x0000, 0x0000, 0x0000 }, /* R10978 */ - { 0x0000, 0x0000, 0x0000 }, /* R10979 */ - { 0x0000, 0x0000, 0x0000 }, /* R10980 */ - { 0x0000, 0x0000, 0x0000 }, /* R10981 */ - { 0x0000, 0x0000, 0x0000 }, /* R10982 */ - { 0x0000, 0x0000, 0x0000 }, /* R10983 */ - { 0x0000, 0x0000, 0x0000 }, /* R10984 */ - { 0x0000, 0x0000, 0x0000 }, /* R10985 */ - { 0x0000, 0x0000, 0x0000 }, /* R10986 */ - { 0x0000, 0x0000, 0x0000 }, /* R10987 */ - { 0x0000, 0x0000, 0x0000 }, /* R10988 */ - { 0x0000, 0x0000, 0x0000 }, /* R10989 */ - { 0x0000, 0x0000, 0x0000 }, /* R10990 */ - { 0x0000, 0x0000, 0x0000 }, /* R10991 */ - { 0x0000, 0x0000, 0x0000 }, /* R10992 */ - { 0x0000, 0x0000, 0x0000 }, /* R10993 */ - { 0x0000, 0x0000, 0x0000 }, /* R10994 */ - { 0x0000, 0x0000, 0x0000 }, /* R10995 */ - { 0x0000, 0x0000, 0x0000 }, /* R10996 */ - { 0x0000, 0x0000, 0x0000 }, /* R10997 */ - { 0x0000, 0x0000, 0x0000 }, /* R10998 */ - { 0x0000, 0x0000, 0x0000 }, /* R10999 */ - { 0x0000, 0x0000, 0x0000 }, /* R11000 */ - { 0x0000, 0x0000, 0x0000 }, /* R11001 */ - { 0x0000, 0x0000, 0x0000 }, /* R11002 */ - { 0x0000, 0x0000, 0x0000 }, /* R11003 */ - { 0x0000, 0x0000, 0x0000 }, /* R11004 */ - { 0x0000, 0x0000, 0x0000 }, /* R11005 */ - { 0x0000, 0x0000, 0x0000 }, /* R11006 */ - { 0x0000, 0x0000, 0x0000 }, /* R11007 */ - { 0x0000, 0x0000, 0x0000 }, /* R11008 */ - { 0x0000, 0x0000, 0x0000 }, /* R11009 */ - { 0x0000, 0x0000, 0x0000 }, /* R11010 */ - { 0x0000, 0x0000, 0x0000 }, /* R11011 */ - { 0x0000, 0x0000, 0x0000 }, /* R11012 */ - { 0x0000, 0x0000, 0x0000 }, /* R11013 */ - { 0x0000, 0x0000, 0x0000 }, /* R11014 */ - { 0x0000, 0x0000, 0x0000 }, /* R11015 */ - { 0x0000, 0x0000, 0x0000 }, /* R11016 */ - { 0x0000, 0x0000, 0x0000 }, /* R11017 */ - { 0x0000, 0x0000, 0x0000 }, /* R11018 */ - { 0x0000, 0x0000, 0x0000 }, /* R11019 */ - { 0x0000, 0x0000, 0x0000 }, /* R11020 */ - { 0x0000, 0x0000, 0x0000 }, /* R11021 */ - { 0x0000, 0x0000, 0x0000 }, /* R11022 */ - { 0x0000, 0x0000, 0x0000 }, /* R11023 */ - { 0x0000, 0x0000, 0x0000 }, /* R11024 */ - { 0x0000, 0x0000, 0x0000 }, /* R11025 */ - { 0x0000, 0x0000, 0x0000 }, /* R11026 */ - { 0x0000, 0x0000, 0x0000 }, /* R11027 */ - { 0x0000, 0x0000, 0x0000 }, /* R11028 */ - { 0x0000, 0x0000, 0x0000 }, /* R11029 */ - { 0x0000, 0x0000, 0x0000 }, /* R11030 */ - { 0x0000, 0x0000, 0x0000 }, /* R11031 */ - { 0x0000, 0x0000, 0x0000 }, /* R11032 */ - { 0x0000, 0x0000, 0x0000 }, /* R11033 */ - { 0x0000, 0x0000, 0x0000 }, /* R11034 */ - { 0x0000, 0x0000, 0x0000 }, /* R11035 */ - { 0x0000, 0x0000, 0x0000 }, /* R11036 */ - { 0x0000, 0x0000, 0x0000 }, /* R11037 */ - { 0x0000, 0x0000, 0x0000 }, /* R11038 */ - { 0x0000, 0x0000, 0x0000 }, /* R11039 */ - { 0x0000, 0x0000, 0x0000 }, /* R11040 */ - { 0x0000, 0x0000, 0x0000 }, /* R11041 */ - { 0x0000, 0x0000, 0x0000 }, /* R11042 */ - { 0x0000, 0x0000, 0x0000 }, /* R11043 */ - { 0x0000, 0x0000, 0x0000 }, /* R11044 */ - { 0x0000, 0x0000, 0x0000 }, /* R11045 */ - { 0x0000, 0x0000, 0x0000 }, /* R11046 */ - { 0x0000, 0x0000, 0x0000 }, /* R11047 */ - { 0x0000, 0x0000, 0x0000 }, /* R11048 */ - { 0x0000, 0x0000, 0x0000 }, /* R11049 */ - { 0x0000, 0x0000, 0x0000 }, /* R11050 */ - { 0x0000, 0x0000, 0x0000 }, /* R11051 */ - { 0x0000, 0x0000, 0x0000 }, /* R11052 */ - { 0x0000, 0x0000, 0x0000 }, /* R11053 */ - { 0x0000, 0x0000, 0x0000 }, /* R11054 */ - { 0x0000, 0x0000, 0x0000 }, /* R11055 */ - { 0x0000, 0x0000, 0x0000 }, /* R11056 */ - { 0x0000, 0x0000, 0x0000 }, /* R11057 */ - { 0x0000, 0x0000, 0x0000 }, /* R11058 */ - { 0x0000, 0x0000, 0x0000 }, /* R11059 */ - { 0x0000, 0x0000, 0x0000 }, /* R11060 */ - { 0x0000, 0x0000, 0x0000 }, /* R11061 */ - { 0x0000, 0x0000, 0x0000 }, /* R11062 */ - { 0x0000, 0x0000, 0x0000 }, /* R11063 */ - { 0x0000, 0x0000, 0x0000 }, /* R11064 */ - { 0x0000, 0x0000, 0x0000 }, /* R11065 */ - { 0x0000, 0x0000, 0x0000 }, /* R11066 */ - { 0x0000, 0x0000, 0x0000 }, /* R11067 */ - { 0x0000, 0x0000, 0x0000 }, /* R11068 */ - { 0x0000, 0x0000, 0x0000 }, /* R11069 */ - { 0x0000, 0x0000, 0x0000 }, /* R11070 */ - { 0x0000, 0x0000, 0x0000 }, /* R11071 */ - { 0x0000, 0x0000, 0x0000 }, /* R11072 */ - { 0x0000, 0x0000, 0x0000 }, /* R11073 */ - { 0x0000, 0x0000, 0x0000 }, /* R11074 */ - { 0x0000, 0x0000, 0x0000 }, /* R11075 */ - { 0x0000, 0x0000, 0x0000 }, /* R11076 */ - { 0x0000, 0x0000, 0x0000 }, /* R11077 */ - { 0x0000, 0x0000, 0x0000 }, /* R11078 */ - { 0x0000, 0x0000, 0x0000 }, /* R11079 */ - { 0x0000, 0x0000, 0x0000 }, /* R11080 */ - { 0x0000, 0x0000, 0x0000 }, /* R11081 */ - { 0x0000, 0x0000, 0x0000 }, /* R11082 */ - { 0x0000, 0x0000, 0x0000 }, /* R11083 */ - { 0x0000, 0x0000, 0x0000 }, /* R11084 */ - { 0x0000, 0x0000, 0x0000 }, /* R11085 */ - { 0x0000, 0x0000, 0x0000 }, /* R11086 */ - { 0x0000, 0x0000, 0x0000 }, /* R11087 */ - { 0x0000, 0x0000, 0x0000 }, /* R11088 */ - { 0x0000, 0x0000, 0x0000 }, /* R11089 */ - { 0x0000, 0x0000, 0x0000 }, /* R11090 */ - { 0x0000, 0x0000, 0x0000 }, /* R11091 */ - { 0x0000, 0x0000, 0x0000 }, /* R11092 */ - { 0x0000, 0x0000, 0x0000 }, /* R11093 */ - { 0x0000, 0x0000, 0x0000 }, /* R11094 */ - { 0x0000, 0x0000, 0x0000 }, /* R11095 */ - { 0x0000, 0x0000, 0x0000 }, /* R11096 */ - { 0x0000, 0x0000, 0x0000 }, /* R11097 */ - { 0x0000, 0x0000, 0x0000 }, /* R11098 */ - { 0x0000, 0x0000, 0x0000 }, /* R11099 */ - { 0x0000, 0x0000, 0x0000 }, /* R11100 */ - { 0x0000, 0x0000, 0x0000 }, /* R11101 */ - { 0x0000, 0x0000, 0x0000 }, /* R11102 */ - { 0x0000, 0x0000, 0x0000 }, /* R11103 */ - { 0x0000, 0x0000, 0x0000 }, /* R11104 */ - { 0x0000, 0x0000, 0x0000 }, /* R11105 */ - { 0x0000, 0x0000, 0x0000 }, /* R11106 */ - { 0x0000, 0x0000, 0x0000 }, /* R11107 */ - { 0x0000, 0x0000, 0x0000 }, /* R11108 */ - { 0x0000, 0x0000, 0x0000 }, /* R11109 */ - { 0x0000, 0x0000, 0x0000 }, /* R11110 */ - { 0x0000, 0x0000, 0x0000 }, /* R11111 */ - { 0x0000, 0x0000, 0x0000 }, /* R11112 */ - { 0x0000, 0x0000, 0x0000 }, /* R11113 */ - { 0x0000, 0x0000, 0x0000 }, /* R11114 */ - { 0x0000, 0x0000, 0x0000 }, /* R11115 */ - { 0x0000, 0x0000, 0x0000 }, /* R11116 */ - { 0x0000, 0x0000, 0x0000 }, /* R11117 */ - { 0x0000, 0x0000, 0x0000 }, /* R11118 */ - { 0x0000, 0x0000, 0x0000 }, /* R11119 */ - { 0x0000, 0x0000, 0x0000 }, /* R11120 */ - { 0x0000, 0x0000, 0x0000 }, /* R11121 */ - { 0x0000, 0x0000, 0x0000 }, /* R11122 */ - { 0x0000, 0x0000, 0x0000 }, /* R11123 */ - { 0x0000, 0x0000, 0x0000 }, /* R11124 */ - { 0x0000, 0x0000, 0x0000 }, /* R11125 */ - { 0x0000, 0x0000, 0x0000 }, /* R11126 */ - { 0x0000, 0x0000, 0x0000 }, /* R11127 */ - { 0x0000, 0x0000, 0x0000 }, /* R11128 */ - { 0x0000, 0x0000, 0x0000 }, /* R11129 */ - { 0x0000, 0x0000, 0x0000 }, /* R11130 */ - { 0x0000, 0x0000, 0x0000 }, /* R11131 */ - { 0x0000, 0x0000, 0x0000 }, /* R11132 */ - { 0x0000, 0x0000, 0x0000 }, /* R11133 */ - { 0x0000, 0x0000, 0x0000 }, /* R11134 */ - { 0x0000, 0x0000, 0x0000 }, /* R11135 */ - { 0x0000, 0x0000, 0x0000 }, /* R11136 */ - { 0x0000, 0x0000, 0x0000 }, /* R11137 */ - { 0x0000, 0x0000, 0x0000 }, /* R11138 */ - { 0x0000, 0x0000, 0x0000 }, /* R11139 */ - { 0x0000, 0x0000, 0x0000 }, /* R11140 */ - { 0x0000, 0x0000, 0x0000 }, /* R11141 */ - { 0x0000, 0x0000, 0x0000 }, /* R11142 */ - { 0x0000, 0x0000, 0x0000 }, /* R11143 */ - { 0x0000, 0x0000, 0x0000 }, /* R11144 */ - { 0x0000, 0x0000, 0x0000 }, /* R11145 */ - { 0x0000, 0x0000, 0x0000 }, /* R11146 */ - { 0x0000, 0x0000, 0x0000 }, /* R11147 */ - { 0x0000, 0x0000, 0x0000 }, /* R11148 */ - { 0x0000, 0x0000, 0x0000 }, /* R11149 */ - { 0x0000, 0x0000, 0x0000 }, /* R11150 */ - { 0x0000, 0x0000, 0x0000 }, /* R11151 */ - { 0x0000, 0x0000, 0x0000 }, /* R11152 */ - { 0x0000, 0x0000, 0x0000 }, /* R11153 */ - { 0x0000, 0x0000, 0x0000 }, /* R11154 */ - { 0x0000, 0x0000, 0x0000 }, /* R11155 */ - { 0x0000, 0x0000, 0x0000 }, /* R11156 */ - { 0x0000, 0x0000, 0x0000 }, /* R11157 */ - { 0x0000, 0x0000, 0x0000 }, /* R11158 */ - { 0x0000, 0x0000, 0x0000 }, /* R11159 */ - { 0x0000, 0x0000, 0x0000 }, /* R11160 */ - { 0x0000, 0x0000, 0x0000 }, /* R11161 */ - { 0x0000, 0x0000, 0x0000 }, /* R11162 */ - { 0x0000, 0x0000, 0x0000 }, /* R11163 */ - { 0x0000, 0x0000, 0x0000 }, /* R11164 */ - { 0x0000, 0x0000, 0x0000 }, /* R11165 */ - { 0x0000, 0x0000, 0x0000 }, /* R11166 */ - { 0x0000, 0x0000, 0x0000 }, /* R11167 */ - { 0x0000, 0x0000, 0x0000 }, /* R11168 */ - { 0x0000, 0x0000, 0x0000 }, /* R11169 */ - { 0x0000, 0x0000, 0x0000 }, /* R11170 */ - { 0x0000, 0x0000, 0x0000 }, /* R11171 */ - { 0x0000, 0x0000, 0x0000 }, /* R11172 */ - { 0x0000, 0x0000, 0x0000 }, /* R11173 */ - { 0x0000, 0x0000, 0x0000 }, /* R11174 */ - { 0x0000, 0x0000, 0x0000 }, /* R11175 */ - { 0x0000, 0x0000, 0x0000 }, /* R11176 */ - { 0x0000, 0x0000, 0x0000 }, /* R11177 */ - { 0x0000, 0x0000, 0x0000 }, /* R11178 */ - { 0x0000, 0x0000, 0x0000 }, /* R11179 */ - { 0x0000, 0x0000, 0x0000 }, /* R11180 */ - { 0x0000, 0x0000, 0x0000 }, /* R11181 */ - { 0x0000, 0x0000, 0x0000 }, /* R11182 */ - { 0x0000, 0x0000, 0x0000 }, /* R11183 */ - { 0x0000, 0x0000, 0x0000 }, /* R11184 */ - { 0x0000, 0x0000, 0x0000 }, /* R11185 */ - { 0x0000, 0x0000, 0x0000 }, /* R11186 */ - { 0x0000, 0x0000, 0x0000 }, /* R11187 */ - { 0x0000, 0x0000, 0x0000 }, /* R11188 */ - { 0x0000, 0x0000, 0x0000 }, /* R11189 */ - { 0x0000, 0x0000, 0x0000 }, /* R11190 */ - { 0x0000, 0x0000, 0x0000 }, /* R11191 */ - { 0x0000, 0x0000, 0x0000 }, /* R11192 */ - { 0x0000, 0x0000, 0x0000 }, /* R11193 */ - { 0x0000, 0x0000, 0x0000 }, /* R11194 */ - { 0x0000, 0x0000, 0x0000 }, /* R11195 */ - { 0x0000, 0x0000, 0x0000 }, /* R11196 */ - { 0x0000, 0x0000, 0x0000 }, /* R11197 */ - { 0x0000, 0x0000, 0x0000 }, /* R11198 */ - { 0x0000, 0x0000, 0x0000 }, /* R11199 */ - { 0x0000, 0x0000, 0x0000 }, /* R11200 */ - { 0x0000, 0x0000, 0x0000 }, /* R11201 */ - { 0x0000, 0x0000, 0x0000 }, /* R11202 */ - { 0x0000, 0x0000, 0x0000 }, /* R11203 */ - { 0x0000, 0x0000, 0x0000 }, /* R11204 */ - { 0x0000, 0x0000, 0x0000 }, /* R11205 */ - { 0x0000, 0x0000, 0x0000 }, /* R11206 */ - { 0x0000, 0x0000, 0x0000 }, /* R11207 */ - { 0x0000, 0x0000, 0x0000 }, /* R11208 */ - { 0x0000, 0x0000, 0x0000 }, /* R11209 */ - { 0x0000, 0x0000, 0x0000 }, /* R11210 */ - { 0x0000, 0x0000, 0x0000 }, /* R11211 */ - { 0x0000, 0x0000, 0x0000 }, /* R11212 */ - { 0x0000, 0x0000, 0x0000 }, /* R11213 */ - { 0x0000, 0x0000, 0x0000 }, /* R11214 */ - { 0x0000, 0x0000, 0x0000 }, /* R11215 */ - { 0x0000, 0x0000, 0x0000 }, /* R11216 */ - { 0x0000, 0x0000, 0x0000 }, /* R11217 */ - { 0x0000, 0x0000, 0x0000 }, /* R11218 */ - { 0x0000, 0x0000, 0x0000 }, /* R11219 */ - { 0x0000, 0x0000, 0x0000 }, /* R11220 */ - { 0x0000, 0x0000, 0x0000 }, /* R11221 */ - { 0x0000, 0x0000, 0x0000 }, /* R11222 */ - { 0x0000, 0x0000, 0x0000 }, /* R11223 */ - { 0x0000, 0x0000, 0x0000 }, /* R11224 */ - { 0x0000, 0x0000, 0x0000 }, /* R11225 */ - { 0x0000, 0x0000, 0x0000 }, /* R11226 */ - { 0x0000, 0x0000, 0x0000 }, /* R11227 */ - { 0x0000, 0x0000, 0x0000 }, /* R11228 */ - { 0x0000, 0x0000, 0x0000 }, /* R11229 */ - { 0x0000, 0x0000, 0x0000 }, /* R11230 */ - { 0x0000, 0x0000, 0x0000 }, /* R11231 */ - { 0x0000, 0x0000, 0x0000 }, /* R11232 */ - { 0x0000, 0x0000, 0x0000 }, /* R11233 */ - { 0x0000, 0x0000, 0x0000 }, /* R11234 */ - { 0x0000, 0x0000, 0x0000 }, /* R11235 */ - { 0x0000, 0x0000, 0x0000 }, /* R11236 */ - { 0x0000, 0x0000, 0x0000 }, /* R11237 */ - { 0x0000, 0x0000, 0x0000 }, /* R11238 */ - { 0x0000, 0x0000, 0x0000 }, /* R11239 */ - { 0x0000, 0x0000, 0x0000 }, /* R11240 */ - { 0x0000, 0x0000, 0x0000 }, /* R11241 */ - { 0x0000, 0x0000, 0x0000 }, /* R11242 */ - { 0x0000, 0x0000, 0x0000 }, /* R11243 */ - { 0x0000, 0x0000, 0x0000 }, /* R11244 */ - { 0x0000, 0x0000, 0x0000 }, /* R11245 */ - { 0x0000, 0x0000, 0x0000 }, /* R11246 */ - { 0x0000, 0x0000, 0x0000 }, /* R11247 */ - { 0x0000, 0x0000, 0x0000 }, /* R11248 */ - { 0x0000, 0x0000, 0x0000 }, /* R11249 */ - { 0x0000, 0x0000, 0x0000 }, /* R11250 */ - { 0x0000, 0x0000, 0x0000 }, /* R11251 */ - { 0x0000, 0x0000, 0x0000 }, /* R11252 */ - { 0x0000, 0x0000, 0x0000 }, /* R11253 */ - { 0x0000, 0x0000, 0x0000 }, /* R11254 */ - { 0x0000, 0x0000, 0x0000 }, /* R11255 */ - { 0x0000, 0x0000, 0x0000 }, /* R11256 */ - { 0x0000, 0x0000, 0x0000 }, /* R11257 */ - { 0x0000, 0x0000, 0x0000 }, /* R11258 */ - { 0x0000, 0x0000, 0x0000 }, /* R11259 */ - { 0x0000, 0x0000, 0x0000 }, /* R11260 */ - { 0x0000, 0x0000, 0x0000 }, /* R11261 */ - { 0x0000, 0x0000, 0x0000 }, /* R11262 */ - { 0x0000, 0x0000, 0x0000 }, /* R11263 */ - { 0x0000, 0x0000, 0x0000 }, /* R11264 */ - { 0x0000, 0x0000, 0x0000 }, /* R11265 */ - { 0x0000, 0x0000, 0x0000 }, /* R11266 */ - { 0x0000, 0x0000, 0x0000 }, /* R11267 */ - { 0x0000, 0x0000, 0x0000 }, /* R11268 */ - { 0x0000, 0x0000, 0x0000 }, /* R11269 */ - { 0x0000, 0x0000, 0x0000 }, /* R11270 */ - { 0x0000, 0x0000, 0x0000 }, /* R11271 */ - { 0x0000, 0x0000, 0x0000 }, /* R11272 */ - { 0x0000, 0x0000, 0x0000 }, /* R11273 */ - { 0x0000, 0x0000, 0x0000 }, /* R11274 */ - { 0x0000, 0x0000, 0x0000 }, /* R11275 */ - { 0x0000, 0x0000, 0x0000 }, /* R11276 */ - { 0x0000, 0x0000, 0x0000 }, /* R11277 */ - { 0x0000, 0x0000, 0x0000 }, /* R11278 */ - { 0x0000, 0x0000, 0x0000 }, /* R11279 */ - { 0x0000, 0x0000, 0x0000 }, /* R11280 */ - { 0x0000, 0x0000, 0x0000 }, /* R11281 */ - { 0x0000, 0x0000, 0x0000 }, /* R11282 */ - { 0x0000, 0x0000, 0x0000 }, /* R11283 */ - { 0x0000, 0x0000, 0x0000 }, /* R11284 */ - { 0x0000, 0x0000, 0x0000 }, /* R11285 */ - { 0x0000, 0x0000, 0x0000 }, /* R11286 */ - { 0x0000, 0x0000, 0x0000 }, /* R11287 */ - { 0x0000, 0x0000, 0x0000 }, /* R11288 */ - { 0x0000, 0x0000, 0x0000 }, /* R11289 */ - { 0x0000, 0x0000, 0x0000 }, /* R11290 */ - { 0x0000, 0x0000, 0x0000 }, /* R11291 */ - { 0x0000, 0x0000, 0x0000 }, /* R11292 */ - { 0x0000, 0x0000, 0x0000 }, /* R11293 */ - { 0x0000, 0x0000, 0x0000 }, /* R11294 */ - { 0x0000, 0x0000, 0x0000 }, /* R11295 */ - { 0x0000, 0x0000, 0x0000 }, /* R11296 */ - { 0x0000, 0x0000, 0x0000 }, /* R11297 */ - { 0x0000, 0x0000, 0x0000 }, /* R11298 */ - { 0x0000, 0x0000, 0x0000 }, /* R11299 */ - { 0x0000, 0x0000, 0x0000 }, /* R11300 */ - { 0x0000, 0x0000, 0x0000 }, /* R11301 */ - { 0x0000, 0x0000, 0x0000 }, /* R11302 */ - { 0x0000, 0x0000, 0x0000 }, /* R11303 */ - { 0x0000, 0x0000, 0x0000 }, /* R11304 */ - { 0x0000, 0x0000, 0x0000 }, /* R11305 */ - { 0x0000, 0x0000, 0x0000 }, /* R11306 */ - { 0x0000, 0x0000, 0x0000 }, /* R11307 */ - { 0x0000, 0x0000, 0x0000 }, /* R11308 */ - { 0x0000, 0x0000, 0x0000 }, /* R11309 */ - { 0x0000, 0x0000, 0x0000 }, /* R11310 */ - { 0x0000, 0x0000, 0x0000 }, /* R11311 */ - { 0x0000, 0x0000, 0x0000 }, /* R11312 */ - { 0x0000, 0x0000, 0x0000 }, /* R11313 */ - { 0x0000, 0x0000, 0x0000 }, /* R11314 */ - { 0x0000, 0x0000, 0x0000 }, /* R11315 */ - { 0x0000, 0x0000, 0x0000 }, /* R11316 */ - { 0x0000, 0x0000, 0x0000 }, /* R11317 */ - { 0x0000, 0x0000, 0x0000 }, /* R11318 */ - { 0x0000, 0x0000, 0x0000 }, /* R11319 */ - { 0x0000, 0x0000, 0x0000 }, /* R11320 */ - { 0x0000, 0x0000, 0x0000 }, /* R11321 */ - { 0x0000, 0x0000, 0x0000 }, /* R11322 */ - { 0x0000, 0x0000, 0x0000 }, /* R11323 */ - { 0x0000, 0x0000, 0x0000 }, /* R11324 */ - { 0x0000, 0x0000, 0x0000 }, /* R11325 */ - { 0x0000, 0x0000, 0x0000 }, /* R11326 */ - { 0x0000, 0x0000, 0x0000 }, /* R11327 */ - { 0x0000, 0x0000, 0x0000 }, /* R11328 */ - { 0x0000, 0x0000, 0x0000 }, /* R11329 */ - { 0x0000, 0x0000, 0x0000 }, /* R11330 */ - { 0x0000, 0x0000, 0x0000 }, /* R11331 */ - { 0x0000, 0x0000, 0x0000 }, /* R11332 */ - { 0x0000, 0x0000, 0x0000 }, /* R11333 */ - { 0x0000, 0x0000, 0x0000 }, /* R11334 */ - { 0x0000, 0x0000, 0x0000 }, /* R11335 */ - { 0x0000, 0x0000, 0x0000 }, /* R11336 */ - { 0x0000, 0x0000, 0x0000 }, /* R11337 */ - { 0x0000, 0x0000, 0x0000 }, /* R11338 */ - { 0x0000, 0x0000, 0x0000 }, /* R11339 */ - { 0x0000, 0x0000, 0x0000 }, /* R11340 */ - { 0x0000, 0x0000, 0x0000 }, /* R11341 */ - { 0x0000, 0x0000, 0x0000 }, /* R11342 */ - { 0x0000, 0x0000, 0x0000 }, /* R11343 */ - { 0x0000, 0x0000, 0x0000 }, /* R11344 */ - { 0x0000, 0x0000, 0x0000 }, /* R11345 */ - { 0x0000, 0x0000, 0x0000 }, /* R11346 */ - { 0x0000, 0x0000, 0x0000 }, /* R11347 */ - { 0x0000, 0x0000, 0x0000 }, /* R11348 */ - { 0x0000, 0x0000, 0x0000 }, /* R11349 */ - { 0x0000, 0x0000, 0x0000 }, /* R11350 */ - { 0x0000, 0x0000, 0x0000 }, /* R11351 */ - { 0x0000, 0x0000, 0x0000 }, /* R11352 */ - { 0x0000, 0x0000, 0x0000 }, /* R11353 */ - { 0x0000, 0x0000, 0x0000 }, /* R11354 */ - { 0x0000, 0x0000, 0x0000 }, /* R11355 */ - { 0x0000, 0x0000, 0x0000 }, /* R11356 */ - { 0x0000, 0x0000, 0x0000 }, /* R11357 */ - { 0x0000, 0x0000, 0x0000 }, /* R11358 */ - { 0x0000, 0x0000, 0x0000 }, /* R11359 */ - { 0x0000, 0x0000, 0x0000 }, /* R11360 */ - { 0x0000, 0x0000, 0x0000 }, /* R11361 */ - { 0x0000, 0x0000, 0x0000 }, /* R11362 */ - { 0x0000, 0x0000, 0x0000 }, /* R11363 */ - { 0x0000, 0x0000, 0x0000 }, /* R11364 */ - { 0x0000, 0x0000, 0x0000 }, /* R11365 */ - { 0x0000, 0x0000, 0x0000 }, /* R11366 */ - { 0x0000, 0x0000, 0x0000 }, /* R11367 */ - { 0x0000, 0x0000, 0x0000 }, /* R11368 */ - { 0x0000, 0x0000, 0x0000 }, /* R11369 */ - { 0x0000, 0x0000, 0x0000 }, /* R11370 */ - { 0x0000, 0x0000, 0x0000 }, /* R11371 */ - { 0x0000, 0x0000, 0x0000 }, /* R11372 */ - { 0x0000, 0x0000, 0x0000 }, /* R11373 */ - { 0x0000, 0x0000, 0x0000 }, /* R11374 */ - { 0x0000, 0x0000, 0x0000 }, /* R11375 */ - { 0x0000, 0x0000, 0x0000 }, /* R11376 */ - { 0x0000, 0x0000, 0x0000 }, /* R11377 */ - { 0x0000, 0x0000, 0x0000 }, /* R11378 */ - { 0x0000, 0x0000, 0x0000 }, /* R11379 */ - { 0x0000, 0x0000, 0x0000 }, /* R11380 */ - { 0x0000, 0x0000, 0x0000 }, /* R11381 */ - { 0x0000, 0x0000, 0x0000 }, /* R11382 */ - { 0x0000, 0x0000, 0x0000 }, /* R11383 */ - { 0x0000, 0x0000, 0x0000 }, /* R11384 */ - { 0x0000, 0x0000, 0x0000 }, /* R11385 */ - { 0x0000, 0x0000, 0x0000 }, /* R11386 */ - { 0x0000, 0x0000, 0x0000 }, /* R11387 */ - { 0x0000, 0x0000, 0x0000 }, /* R11388 */ - { 0x0000, 0x0000, 0x0000 }, /* R11389 */ - { 0x0000, 0x0000, 0x0000 }, /* R11390 */ - { 0x0000, 0x0000, 0x0000 }, /* R11391 */ - { 0x0000, 0x0000, 0x0000 }, /* R11392 */ - { 0x0000, 0x0000, 0x0000 }, /* R11393 */ - { 0x0000, 0x0000, 0x0000 }, /* R11394 */ - { 0x0000, 0x0000, 0x0000 }, /* R11395 */ - { 0x0000, 0x0000, 0x0000 }, /* R11396 */ - { 0x0000, 0x0000, 0x0000 }, /* R11397 */ - { 0x0000, 0x0000, 0x0000 }, /* R11398 */ - { 0x0000, 0x0000, 0x0000 }, /* R11399 */ - { 0x0000, 0x0000, 0x0000 }, /* R11400 */ - { 0x0000, 0x0000, 0x0000 }, /* R11401 */ - { 0x0000, 0x0000, 0x0000 }, /* R11402 */ - { 0x0000, 0x0000, 0x0000 }, /* R11403 */ - { 0x0000, 0x0000, 0x0000 }, /* R11404 */ - { 0x0000, 0x0000, 0x0000 }, /* R11405 */ - { 0x0000, 0x0000, 0x0000 }, /* R11406 */ - { 0x0000, 0x0000, 0x0000 }, /* R11407 */ - { 0x0000, 0x0000, 0x0000 }, /* R11408 */ - { 0x0000, 0x0000, 0x0000 }, /* R11409 */ - { 0x0000, 0x0000, 0x0000 }, /* R11410 */ - { 0x0000, 0x0000, 0x0000 }, /* R11411 */ - { 0x0000, 0x0000, 0x0000 }, /* R11412 */ - { 0x0000, 0x0000, 0x0000 }, /* R11413 */ - { 0x0000, 0x0000, 0x0000 }, /* R11414 */ - { 0x0000, 0x0000, 0x0000 }, /* R11415 */ - { 0x0000, 0x0000, 0x0000 }, /* R11416 */ - { 0x0000, 0x0000, 0x0000 }, /* R11417 */ - { 0x0000, 0x0000, 0x0000 }, /* R11418 */ - { 0x0000, 0x0000, 0x0000 }, /* R11419 */ - { 0x0000, 0x0000, 0x0000 }, /* R11420 */ - { 0x0000, 0x0000, 0x0000 }, /* R11421 */ - { 0x0000, 0x0000, 0x0000 }, /* R11422 */ - { 0x0000, 0x0000, 0x0000 }, /* R11423 */ - { 0x0000, 0x0000, 0x0000 }, /* R11424 */ - { 0x0000, 0x0000, 0x0000 }, /* R11425 */ - { 0x0000, 0x0000, 0x0000 }, /* R11426 */ - { 0x0000, 0x0000, 0x0000 }, /* R11427 */ - { 0x0000, 0x0000, 0x0000 }, /* R11428 */ - { 0x0000, 0x0000, 0x0000 }, /* R11429 */ - { 0x0000, 0x0000, 0x0000 }, /* R11430 */ - { 0x0000, 0x0000, 0x0000 }, /* R11431 */ - { 0x0000, 0x0000, 0x0000 }, /* R11432 */ - { 0x0000, 0x0000, 0x0000 }, /* R11433 */ - { 0x0000, 0x0000, 0x0000 }, /* R11434 */ - { 0x0000, 0x0000, 0x0000 }, /* R11435 */ - { 0x0000, 0x0000, 0x0000 }, /* R11436 */ - { 0x0000, 0x0000, 0x0000 }, /* R11437 */ - { 0x0000, 0x0000, 0x0000 }, /* R11438 */ - { 0x0000, 0x0000, 0x0000 }, /* R11439 */ - { 0x0000, 0x0000, 0x0000 }, /* R11440 */ - { 0x0000, 0x0000, 0x0000 }, /* R11441 */ - { 0x0000, 0x0000, 0x0000 }, /* R11442 */ - { 0x0000, 0x0000, 0x0000 }, /* R11443 */ - { 0x0000, 0x0000, 0x0000 }, /* R11444 */ - { 0x0000, 0x0000, 0x0000 }, /* R11445 */ - { 0x0000, 0x0000, 0x0000 }, /* R11446 */ - { 0x0000, 0x0000, 0x0000 }, /* R11447 */ - { 0x0000, 0x0000, 0x0000 }, /* R11448 */ - { 0x0000, 0x0000, 0x0000 }, /* R11449 */ - { 0x0000, 0x0000, 0x0000 }, /* R11450 */ - { 0x0000, 0x0000, 0x0000 }, /* R11451 */ - { 0x0000, 0x0000, 0x0000 }, /* R11452 */ - { 0x0000, 0x0000, 0x0000 }, /* R11453 */ - { 0x0000, 0x0000, 0x0000 }, /* R11454 */ - { 0x0000, 0x0000, 0x0000 }, /* R11455 */ - { 0x0000, 0x0000, 0x0000 }, /* R11456 */ - { 0x0000, 0x0000, 0x0000 }, /* R11457 */ - { 0x0000, 0x0000, 0x0000 }, /* R11458 */ - { 0x0000, 0x0000, 0x0000 }, /* R11459 */ - { 0x0000, 0x0000, 0x0000 }, /* R11460 */ - { 0x0000, 0x0000, 0x0000 }, /* R11461 */ - { 0x0000, 0x0000, 0x0000 }, /* R11462 */ - { 0x0000, 0x0000, 0x0000 }, /* R11463 */ - { 0x0000, 0x0000, 0x0000 }, /* R11464 */ - { 0x0000, 0x0000, 0x0000 }, /* R11465 */ - { 0x0000, 0x0000, 0x0000 }, /* R11466 */ - { 0x0000, 0x0000, 0x0000 }, /* R11467 */ - { 0x0000, 0x0000, 0x0000 }, /* R11468 */ - { 0x0000, 0x0000, 0x0000 }, /* R11469 */ - { 0x0000, 0x0000, 0x0000 }, /* R11470 */ - { 0x0000, 0x0000, 0x0000 }, /* R11471 */ - { 0x0000, 0x0000, 0x0000 }, /* R11472 */ - { 0x0000, 0x0000, 0x0000 }, /* R11473 */ - { 0x0000, 0x0000, 0x0000 }, /* R11474 */ - { 0x0000, 0x0000, 0x0000 }, /* R11475 */ - { 0x0000, 0x0000, 0x0000 }, /* R11476 */ - { 0x0000, 0x0000, 0x0000 }, /* R11477 */ - { 0x0000, 0x0000, 0x0000 }, /* R11478 */ - { 0x0000, 0x0000, 0x0000 }, /* R11479 */ - { 0x0000, 0x0000, 0x0000 }, /* R11480 */ - { 0x0000, 0x0000, 0x0000 }, /* R11481 */ - { 0x0000, 0x0000, 0x0000 }, /* R11482 */ - { 0x0000, 0x0000, 0x0000 }, /* R11483 */ - { 0x0000, 0x0000, 0x0000 }, /* R11484 */ - { 0x0000, 0x0000, 0x0000 }, /* R11485 */ - { 0x0000, 0x0000, 0x0000 }, /* R11486 */ - { 0x0000, 0x0000, 0x0000 }, /* R11487 */ - { 0x0000, 0x0000, 0x0000 }, /* R11488 */ - { 0x0000, 0x0000, 0x0000 }, /* R11489 */ - { 0x0000, 0x0000, 0x0000 }, /* R11490 */ - { 0x0000, 0x0000, 0x0000 }, /* R11491 */ - { 0x0000, 0x0000, 0x0000 }, /* R11492 */ - { 0x0000, 0x0000, 0x0000 }, /* R11493 */ - { 0x0000, 0x0000, 0x0000 }, /* R11494 */ - { 0x0000, 0x0000, 0x0000 }, /* R11495 */ - { 0x0000, 0x0000, 0x0000 }, /* R11496 */ - { 0x0000, 0x0000, 0x0000 }, /* R11497 */ - { 0x0000, 0x0000, 0x0000 }, /* R11498 */ - { 0x0000, 0x0000, 0x0000 }, /* R11499 */ - { 0x0000, 0x0000, 0x0000 }, /* R11500 */ - { 0x0000, 0x0000, 0x0000 }, /* R11501 */ - { 0x0000, 0x0000, 0x0000 }, /* R11502 */ - { 0x0000, 0x0000, 0x0000 }, /* R11503 */ - { 0x0000, 0x0000, 0x0000 }, /* R11504 */ - { 0x0000, 0x0000, 0x0000 }, /* R11505 */ - { 0x0000, 0x0000, 0x0000 }, /* R11506 */ - { 0x0000, 0x0000, 0x0000 }, /* R11507 */ - { 0x0000, 0x0000, 0x0000 }, /* R11508 */ - { 0x0000, 0x0000, 0x0000 }, /* R11509 */ - { 0x0000, 0x0000, 0x0000 }, /* R11510 */ - { 0x0000, 0x0000, 0x0000 }, /* R11511 */ - { 0x0000, 0x0000, 0x0000 }, /* R11512 */ - { 0x0000, 0x0000, 0x0000 }, /* R11513 */ - { 0x0000, 0x0000, 0x0000 }, /* R11514 */ - { 0x0000, 0x0000, 0x0000 }, /* R11515 */ - { 0x0000, 0x0000, 0x0000 }, /* R11516 */ - { 0x0000, 0x0000, 0x0000 }, /* R11517 */ - { 0x0000, 0x0000, 0x0000 }, /* R11518 */ - { 0x0000, 0x0000, 0x0000 }, /* R11519 */ - { 0x0000, 0x0000, 0x0000 }, /* R11520 */ - { 0x0000, 0x0000, 0x0000 }, /* R11521 */ - { 0x0000, 0x0000, 0x0000 }, /* R11522 */ - { 0x0000, 0x0000, 0x0000 }, /* R11523 */ - { 0x0000, 0x0000, 0x0000 }, /* R11524 */ - { 0x0000, 0x0000, 0x0000 }, /* R11525 */ - { 0x0000, 0x0000, 0x0000 }, /* R11526 */ - { 0x0000, 0x0000, 0x0000 }, /* R11527 */ - { 0x0000, 0x0000, 0x0000 }, /* R11528 */ - { 0x0000, 0x0000, 0x0000 }, /* R11529 */ - { 0x0000, 0x0000, 0x0000 }, /* R11530 */ - { 0x0000, 0x0000, 0x0000 }, /* R11531 */ - { 0x0000, 0x0000, 0x0000 }, /* R11532 */ - { 0x0000, 0x0000, 0x0000 }, /* R11533 */ - { 0x0000, 0x0000, 0x0000 }, /* R11534 */ - { 0x0000, 0x0000, 0x0000 }, /* R11535 */ - { 0x0000, 0x0000, 0x0000 }, /* R11536 */ - { 0x0000, 0x0000, 0x0000 }, /* R11537 */ - { 0x0000, 0x0000, 0x0000 }, /* R11538 */ - { 0x0000, 0x0000, 0x0000 }, /* R11539 */ - { 0x0000, 0x0000, 0x0000 }, /* R11540 */ - { 0x0000, 0x0000, 0x0000 }, /* R11541 */ - { 0x0000, 0x0000, 0x0000 }, /* R11542 */ - { 0x0000, 0x0000, 0x0000 }, /* R11543 */ - { 0x0000, 0x0000, 0x0000 }, /* R11544 */ - { 0x0000, 0x0000, 0x0000 }, /* R11545 */ - { 0x0000, 0x0000, 0x0000 }, /* R11546 */ - { 0x0000, 0x0000, 0x0000 }, /* R11547 */ - { 0x0000, 0x0000, 0x0000 }, /* R11548 */ - { 0x0000, 0x0000, 0x0000 }, /* R11549 */ - { 0x0000, 0x0000, 0x0000 }, /* R11550 */ - { 0x0000, 0x0000, 0x0000 }, /* R11551 */ - { 0x0000, 0x0000, 0x0000 }, /* R11552 */ - { 0x0000, 0x0000, 0x0000 }, /* R11553 */ - { 0x0000, 0x0000, 0x0000 }, /* R11554 */ - { 0x0000, 0x0000, 0x0000 }, /* R11555 */ - { 0x0000, 0x0000, 0x0000 }, /* R11556 */ - { 0x0000, 0x0000, 0x0000 }, /* R11557 */ - { 0x0000, 0x0000, 0x0000 }, /* R11558 */ - { 0x0000, 0x0000, 0x0000 }, /* R11559 */ - { 0x0000, 0x0000, 0x0000 }, /* R11560 */ - { 0x0000, 0x0000, 0x0000 }, /* R11561 */ - { 0x0000, 0x0000, 0x0000 }, /* R11562 */ - { 0x0000, 0x0000, 0x0000 }, /* R11563 */ - { 0x0000, 0x0000, 0x0000 }, /* R11564 */ - { 0x0000, 0x0000, 0x0000 }, /* R11565 */ - { 0x0000, 0x0000, 0x0000 }, /* R11566 */ - { 0x0000, 0x0000, 0x0000 }, /* R11567 */ - { 0x0000, 0x0000, 0x0000 }, /* R11568 */ - { 0x0000, 0x0000, 0x0000 }, /* R11569 */ - { 0x0000, 0x0000, 0x0000 }, /* R11570 */ - { 0x0000, 0x0000, 0x0000 }, /* R11571 */ - { 0x0000, 0x0000, 0x0000 }, /* R11572 */ - { 0x0000, 0x0000, 0x0000 }, /* R11573 */ - { 0x0000, 0x0000, 0x0000 }, /* R11574 */ - { 0x0000, 0x0000, 0x0000 }, /* R11575 */ - { 0x0000, 0x0000, 0x0000 }, /* R11576 */ - { 0x0000, 0x0000, 0x0000 }, /* R11577 */ - { 0x0000, 0x0000, 0x0000 }, /* R11578 */ - { 0x0000, 0x0000, 0x0000 }, /* R11579 */ - { 0x0000, 0x0000, 0x0000 }, /* R11580 */ - { 0x0000, 0x0000, 0x0000 }, /* R11581 */ - { 0x0000, 0x0000, 0x0000 }, /* R11582 */ - { 0x0000, 0x0000, 0x0000 }, /* R11583 */ - { 0x0000, 0x0000, 0x0000 }, /* R11584 */ - { 0x0000, 0x0000, 0x0000 }, /* R11585 */ - { 0x0000, 0x0000, 0x0000 }, /* R11586 */ - { 0x0000, 0x0000, 0x0000 }, /* R11587 */ - { 0x0000, 0x0000, 0x0000 }, /* R11588 */ - { 0x0000, 0x0000, 0x0000 }, /* R11589 */ - { 0x0000, 0x0000, 0x0000 }, /* R11590 */ - { 0x0000, 0x0000, 0x0000 }, /* R11591 */ - { 0x0000, 0x0000, 0x0000 }, /* R11592 */ - { 0x0000, 0x0000, 0x0000 }, /* R11593 */ - { 0x0000, 0x0000, 0x0000 }, /* R11594 */ - { 0x0000, 0x0000, 0x0000 }, /* R11595 */ - { 0x0000, 0x0000, 0x0000 }, /* R11596 */ - { 0x0000, 0x0000, 0x0000 }, /* R11597 */ - { 0x0000, 0x0000, 0x0000 }, /* R11598 */ - { 0x0000, 0x0000, 0x0000 }, /* R11599 */ - { 0x0000, 0x0000, 0x0000 }, /* R11600 */ - { 0x0000, 0x0000, 0x0000 }, /* R11601 */ - { 0x0000, 0x0000, 0x0000 }, /* R11602 */ - { 0x0000, 0x0000, 0x0000 }, /* R11603 */ - { 0x0000, 0x0000, 0x0000 }, /* R11604 */ - { 0x0000, 0x0000, 0x0000 }, /* R11605 */ - { 0x0000, 0x0000, 0x0000 }, /* R11606 */ - { 0x0000, 0x0000, 0x0000 }, /* R11607 */ - { 0x0000, 0x0000, 0x0000 }, /* R11608 */ - { 0x0000, 0x0000, 0x0000 }, /* R11609 */ - { 0x0000, 0x0000, 0x0000 }, /* R11610 */ - { 0x0000, 0x0000, 0x0000 }, /* R11611 */ - { 0x0000, 0x0000, 0x0000 }, /* R11612 */ - { 0x0000, 0x0000, 0x0000 }, /* R11613 */ - { 0x0000, 0x0000, 0x0000 }, /* R11614 */ - { 0x0000, 0x0000, 0x0000 }, /* R11615 */ - { 0x0000, 0x0000, 0x0000 }, /* R11616 */ - { 0x0000, 0x0000, 0x0000 }, /* R11617 */ - { 0x0000, 0x0000, 0x0000 }, /* R11618 */ - { 0x0000, 0x0000, 0x0000 }, /* R11619 */ - { 0x0000, 0x0000, 0x0000 }, /* R11620 */ - { 0x0000, 0x0000, 0x0000 }, /* R11621 */ - { 0x0000, 0x0000, 0x0000 }, /* R11622 */ - { 0x0000, 0x0000, 0x0000 }, /* R11623 */ - { 0x0000, 0x0000, 0x0000 }, /* R11624 */ - { 0x0000, 0x0000, 0x0000 }, /* R11625 */ - { 0x0000, 0x0000, 0x0000 }, /* R11626 */ - { 0x0000, 0x0000, 0x0000 }, /* R11627 */ - { 0x0000, 0x0000, 0x0000 }, /* R11628 */ - { 0x0000, 0x0000, 0x0000 }, /* R11629 */ - { 0x0000, 0x0000, 0x0000 }, /* R11630 */ - { 0x0000, 0x0000, 0x0000 }, /* R11631 */ - { 0x0000, 0x0000, 0x0000 }, /* R11632 */ - { 0x0000, 0x0000, 0x0000 }, /* R11633 */ - { 0x0000, 0x0000, 0x0000 }, /* R11634 */ - { 0x0000, 0x0000, 0x0000 }, /* R11635 */ - { 0x0000, 0x0000, 0x0000 }, /* R11636 */ - { 0x0000, 0x0000, 0x0000 }, /* R11637 */ - { 0x0000, 0x0000, 0x0000 }, /* R11638 */ - { 0x0000, 0x0000, 0x0000 }, /* R11639 */ - { 0x0000, 0x0000, 0x0000 }, /* R11640 */ - { 0x0000, 0x0000, 0x0000 }, /* R11641 */ - { 0x0000, 0x0000, 0x0000 }, /* R11642 */ - { 0x0000, 0x0000, 0x0000 }, /* R11643 */ - { 0x0000, 0x0000, 0x0000 }, /* R11644 */ - { 0x0000, 0x0000, 0x0000 }, /* R11645 */ - { 0x0000, 0x0000, 0x0000 }, /* R11646 */ - { 0x0000, 0x0000, 0x0000 }, /* R11647 */ - { 0x0000, 0x0000, 0x0000 }, /* R11648 */ - { 0x0000, 0x0000, 0x0000 }, /* R11649 */ - { 0x0000, 0x0000, 0x0000 }, /* R11650 */ - { 0x0000, 0x0000, 0x0000 }, /* R11651 */ - { 0x0000, 0x0000, 0x0000 }, /* R11652 */ - { 0x0000, 0x0000, 0x0000 }, /* R11653 */ - { 0x0000, 0x0000, 0x0000 }, /* R11654 */ - { 0x0000, 0x0000, 0x0000 }, /* R11655 */ - { 0x0000, 0x0000, 0x0000 }, /* R11656 */ - { 0x0000, 0x0000, 0x0000 }, /* R11657 */ - { 0x0000, 0x0000, 0x0000 }, /* R11658 */ - { 0x0000, 0x0000, 0x0000 }, /* R11659 */ - { 0x0000, 0x0000, 0x0000 }, /* R11660 */ - { 0x0000, 0x0000, 0x0000 }, /* R11661 */ - { 0x0000, 0x0000, 0x0000 }, /* R11662 */ - { 0x0000, 0x0000, 0x0000 }, /* R11663 */ - { 0x0000, 0x0000, 0x0000 }, /* R11664 */ - { 0x0000, 0x0000, 0x0000 }, /* R11665 */ - { 0x0000, 0x0000, 0x0000 }, /* R11666 */ - { 0x0000, 0x0000, 0x0000 }, /* R11667 */ - { 0x0000, 0x0000, 0x0000 }, /* R11668 */ - { 0x0000, 0x0000, 0x0000 }, /* R11669 */ - { 0x0000, 0x0000, 0x0000 }, /* R11670 */ - { 0x0000, 0x0000, 0x0000 }, /* R11671 */ - { 0x0000, 0x0000, 0x0000 }, /* R11672 */ - { 0x0000, 0x0000, 0x0000 }, /* R11673 */ - { 0x0000, 0x0000, 0x0000 }, /* R11674 */ - { 0x0000, 0x0000, 0x0000 }, /* R11675 */ - { 0x0000, 0x0000, 0x0000 }, /* R11676 */ - { 0x0000, 0x0000, 0x0000 }, /* R11677 */ - { 0x0000, 0x0000, 0x0000 }, /* R11678 */ - { 0x0000, 0x0000, 0x0000 }, /* R11679 */ - { 0x0000, 0x0000, 0x0000 }, /* R11680 */ - { 0x0000, 0x0000, 0x0000 }, /* R11681 */ - { 0x0000, 0x0000, 0x0000 }, /* R11682 */ - { 0x0000, 0x0000, 0x0000 }, /* R11683 */ - { 0x0000, 0x0000, 0x0000 }, /* R11684 */ - { 0x0000, 0x0000, 0x0000 }, /* R11685 */ - { 0x0000, 0x0000, 0x0000 }, /* R11686 */ - { 0x0000, 0x0000, 0x0000 }, /* R11687 */ - { 0x0000, 0x0000, 0x0000 }, /* R11688 */ - { 0x0000, 0x0000, 0x0000 }, /* R11689 */ - { 0x0000, 0x0000, 0x0000 }, /* R11690 */ - { 0x0000, 0x0000, 0x0000 }, /* R11691 */ - { 0x0000, 0x0000, 0x0000 }, /* R11692 */ - { 0x0000, 0x0000, 0x0000 }, /* R11693 */ - { 0x0000, 0x0000, 0x0000 }, /* R11694 */ - { 0x0000, 0x0000, 0x0000 }, /* R11695 */ - { 0x0000, 0x0000, 0x0000 }, /* R11696 */ - { 0x0000, 0x0000, 0x0000 }, /* R11697 */ - { 0x0000, 0x0000, 0x0000 }, /* R11698 */ - { 0x0000, 0x0000, 0x0000 }, /* R11699 */ - { 0x0000, 0x0000, 0x0000 }, /* R11700 */ - { 0x0000, 0x0000, 0x0000 }, /* R11701 */ - { 0x0000, 0x0000, 0x0000 }, /* R11702 */ - { 0x0000, 0x0000, 0x0000 }, /* R11703 */ - { 0x0000, 0x0000, 0x0000 }, /* R11704 */ - { 0x0000, 0x0000, 0x0000 }, /* R11705 */ - { 0x0000, 0x0000, 0x0000 }, /* R11706 */ - { 0x0000, 0x0000, 0x0000 }, /* R11707 */ - { 0x0000, 0x0000, 0x0000 }, /* R11708 */ - { 0x0000, 0x0000, 0x0000 }, /* R11709 */ - { 0x0000, 0x0000, 0x0000 }, /* R11710 */ - { 0x0000, 0x0000, 0x0000 }, /* R11711 */ - { 0x0000, 0x0000, 0x0000 }, /* R11712 */ - { 0x0000, 0x0000, 0x0000 }, /* R11713 */ - { 0x0000, 0x0000, 0x0000 }, /* R11714 */ - { 0x0000, 0x0000, 0x0000 }, /* R11715 */ - { 0x0000, 0x0000, 0x0000 }, /* R11716 */ - { 0x0000, 0x0000, 0x0000 }, /* R11717 */ - { 0x0000, 0x0000, 0x0000 }, /* R11718 */ - { 0x0000, 0x0000, 0x0000 }, /* R11719 */ - { 0x0000, 0x0000, 0x0000 }, /* R11720 */ - { 0x0000, 0x0000, 0x0000 }, /* R11721 */ - { 0x0000, 0x0000, 0x0000 }, /* R11722 */ - { 0x0000, 0x0000, 0x0000 }, /* R11723 */ - { 0x0000, 0x0000, 0x0000 }, /* R11724 */ - { 0x0000, 0x0000, 0x0000 }, /* R11725 */ - { 0x0000, 0x0000, 0x0000 }, /* R11726 */ - { 0x0000, 0x0000, 0x0000 }, /* R11727 */ - { 0x0000, 0x0000, 0x0000 }, /* R11728 */ - { 0x0000, 0x0000, 0x0000 }, /* R11729 */ - { 0x0000, 0x0000, 0x0000 }, /* R11730 */ - { 0x0000, 0x0000, 0x0000 }, /* R11731 */ - { 0x0000, 0x0000, 0x0000 }, /* R11732 */ - { 0x0000, 0x0000, 0x0000 }, /* R11733 */ - { 0x0000, 0x0000, 0x0000 }, /* R11734 */ - { 0x0000, 0x0000, 0x0000 }, /* R11735 */ - { 0x0000, 0x0000, 0x0000 }, /* R11736 */ - { 0x0000, 0x0000, 0x0000 }, /* R11737 */ - { 0x0000, 0x0000, 0x0000 }, /* R11738 */ - { 0x0000, 0x0000, 0x0000 }, /* R11739 */ - { 0x0000, 0x0000, 0x0000 }, /* R11740 */ - { 0x0000, 0x0000, 0x0000 }, /* R11741 */ - { 0x0000, 0x0000, 0x0000 }, /* R11742 */ - { 0x0000, 0x0000, 0x0000 }, /* R11743 */ - { 0x0000, 0x0000, 0x0000 }, /* R11744 */ - { 0x0000, 0x0000, 0x0000 }, /* R11745 */ - { 0x0000, 0x0000, 0x0000 }, /* R11746 */ - { 0x0000, 0x0000, 0x0000 }, /* R11747 */ - { 0x0000, 0x0000, 0x0000 }, /* R11748 */ - { 0x0000, 0x0000, 0x0000 }, /* R11749 */ - { 0x0000, 0x0000, 0x0000 }, /* R11750 */ - { 0x0000, 0x0000, 0x0000 }, /* R11751 */ - { 0x0000, 0x0000, 0x0000 }, /* R11752 */ - { 0x0000, 0x0000, 0x0000 }, /* R11753 */ - { 0x0000, 0x0000, 0x0000 }, /* R11754 */ - { 0x0000, 0x0000, 0x0000 }, /* R11755 */ - { 0x0000, 0x0000, 0x0000 }, /* R11756 */ - { 0x0000, 0x0000, 0x0000 }, /* R11757 */ - { 0x0000, 0x0000, 0x0000 }, /* R11758 */ - { 0x0000, 0x0000, 0x0000 }, /* R11759 */ - { 0x0000, 0x0000, 0x0000 }, /* R11760 */ - { 0x0000, 0x0000, 0x0000 }, /* R11761 */ - { 0x0000, 0x0000, 0x0000 }, /* R11762 */ - { 0x0000, 0x0000, 0x0000 }, /* R11763 */ - { 0x0000, 0x0000, 0x0000 }, /* R11764 */ - { 0x0000, 0x0000, 0x0000 }, /* R11765 */ - { 0x0000, 0x0000, 0x0000 }, /* R11766 */ - { 0x0000, 0x0000, 0x0000 }, /* R11767 */ - { 0x0000, 0x0000, 0x0000 }, /* R11768 */ - { 0x0000, 0x0000, 0x0000 }, /* R11769 */ - { 0x0000, 0x0000, 0x0000 }, /* R11770 */ - { 0x0000, 0x0000, 0x0000 }, /* R11771 */ - { 0x0000, 0x0000, 0x0000 }, /* R11772 */ - { 0x0000, 0x0000, 0x0000 }, /* R11773 */ - { 0x0000, 0x0000, 0x0000 }, /* R11774 */ - { 0x0000, 0x0000, 0x0000 }, /* R11775 */ - { 0x0000, 0x0000, 0x0000 }, /* R11776 */ - { 0x0000, 0x0000, 0x0000 }, /* R11777 */ - { 0x0000, 0x0000, 0x0000 }, /* R11778 */ - { 0x0000, 0x0000, 0x0000 }, /* R11779 */ - { 0x0000, 0x0000, 0x0000 }, /* R11780 */ - { 0x0000, 0x0000, 0x0000 }, /* R11781 */ - { 0x0000, 0x0000, 0x0000 }, /* R11782 */ - { 0x0000, 0x0000, 0x0000 }, /* R11783 */ - { 0x0000, 0x0000, 0x0000 }, /* R11784 */ - { 0x0000, 0x0000, 0x0000 }, /* R11785 */ - { 0x0000, 0x0000, 0x0000 }, /* R11786 */ - { 0x0000, 0x0000, 0x0000 }, /* R11787 */ - { 0x0000, 0x0000, 0x0000 }, /* R11788 */ - { 0x0000, 0x0000, 0x0000 }, /* R11789 */ - { 0x0000, 0x0000, 0x0000 }, /* R11790 */ - { 0x0000, 0x0000, 0x0000 }, /* R11791 */ - { 0x0000, 0x0000, 0x0000 }, /* R11792 */ - { 0x0000, 0x0000, 0x0000 }, /* R11793 */ - { 0x0000, 0x0000, 0x0000 }, /* R11794 */ - { 0x0000, 0x0000, 0x0000 }, /* R11795 */ - { 0x0000, 0x0000, 0x0000 }, /* R11796 */ - { 0x0000, 0x0000, 0x0000 }, /* R11797 */ - { 0x0000, 0x0000, 0x0000 }, /* R11798 */ - { 0x0000, 0x0000, 0x0000 }, /* R11799 */ - { 0x0000, 0x0000, 0x0000 }, /* R11800 */ - { 0x0000, 0x0000, 0x0000 }, /* R11801 */ - { 0x0000, 0x0000, 0x0000 }, /* R11802 */ - { 0x0000, 0x0000, 0x0000 }, /* R11803 */ - { 0x0000, 0x0000, 0x0000 }, /* R11804 */ - { 0x0000, 0x0000, 0x0000 }, /* R11805 */ - { 0x0000, 0x0000, 0x0000 }, /* R11806 */ - { 0x0000, 0x0000, 0x0000 }, /* R11807 */ - { 0x0000, 0x0000, 0x0000 }, /* R11808 */ - { 0x0000, 0x0000, 0x0000 }, /* R11809 */ - { 0x0000, 0x0000, 0x0000 }, /* R11810 */ - { 0x0000, 0x0000, 0x0000 }, /* R11811 */ - { 0x0000, 0x0000, 0x0000 }, /* R11812 */ - { 0x0000, 0x0000, 0x0000 }, /* R11813 */ - { 0x0000, 0x0000, 0x0000 }, /* R11814 */ - { 0x0000, 0x0000, 0x0000 }, /* R11815 */ - { 0x0000, 0x0000, 0x0000 }, /* R11816 */ - { 0x0000, 0x0000, 0x0000 }, /* R11817 */ - { 0x0000, 0x0000, 0x0000 }, /* R11818 */ - { 0x0000, 0x0000, 0x0000 }, /* R11819 */ - { 0x0000, 0x0000, 0x0000 }, /* R11820 */ - { 0x0000, 0x0000, 0x0000 }, /* R11821 */ - { 0x0000, 0x0000, 0x0000 }, /* R11822 */ - { 0x0000, 0x0000, 0x0000 }, /* R11823 */ - { 0x0000, 0x0000, 0x0000 }, /* R11824 */ - { 0x0000, 0x0000, 0x0000 }, /* R11825 */ - { 0x0000, 0x0000, 0x0000 }, /* R11826 */ - { 0x0000, 0x0000, 0x0000 }, /* R11827 */ - { 0x0000, 0x0000, 0x0000 }, /* R11828 */ - { 0x0000, 0x0000, 0x0000 }, /* R11829 */ - { 0x0000, 0x0000, 0x0000 }, /* R11830 */ - { 0x0000, 0x0000, 0x0000 }, /* R11831 */ - { 0x0000, 0x0000, 0x0000 }, /* R11832 */ - { 0x0000, 0x0000, 0x0000 }, /* R11833 */ - { 0x0000, 0x0000, 0x0000 }, /* R11834 */ - { 0x0000, 0x0000, 0x0000 }, /* R11835 */ - { 0x0000, 0x0000, 0x0000 }, /* R11836 */ - { 0x0000, 0x0000, 0x0000 }, /* R11837 */ - { 0x0000, 0x0000, 0x0000 }, /* R11838 */ - { 0x0000, 0x0000, 0x0000 }, /* R11839 */ - { 0x0000, 0x0000, 0x0000 }, /* R11840 */ - { 0x0000, 0x0000, 0x0000 }, /* R11841 */ - { 0x0000, 0x0000, 0x0000 }, /* R11842 */ - { 0x0000, 0x0000, 0x0000 }, /* R11843 */ - { 0x0000, 0x0000, 0x0000 }, /* R11844 */ - { 0x0000, 0x0000, 0x0000 }, /* R11845 */ - { 0x0000, 0x0000, 0x0000 }, /* R11846 */ - { 0x0000, 0x0000, 0x0000 }, /* R11847 */ - { 0x0000, 0x0000, 0x0000 }, /* R11848 */ - { 0x0000, 0x0000, 0x0000 }, /* R11849 */ - { 0x0000, 0x0000, 0x0000 }, /* R11850 */ - { 0x0000, 0x0000, 0x0000 }, /* R11851 */ - { 0x0000, 0x0000, 0x0000 }, /* R11852 */ - { 0x0000, 0x0000, 0x0000 }, /* R11853 */ - { 0x0000, 0x0000, 0x0000 }, /* R11854 */ - { 0x0000, 0x0000, 0x0000 }, /* R11855 */ - { 0x0000, 0x0000, 0x0000 }, /* R11856 */ - { 0x0000, 0x0000, 0x0000 }, /* R11857 */ - { 0x0000, 0x0000, 0x0000 }, /* R11858 */ - { 0x0000, 0x0000, 0x0000 }, /* R11859 */ - { 0x0000, 0x0000, 0x0000 }, /* R11860 */ - { 0x0000, 0x0000, 0x0000 }, /* R11861 */ - { 0x0000, 0x0000, 0x0000 }, /* R11862 */ - { 0x0000, 0x0000, 0x0000 }, /* R11863 */ - { 0x0000, 0x0000, 0x0000 }, /* R11864 */ - { 0x0000, 0x0000, 0x0000 }, /* R11865 */ - { 0x0000, 0x0000, 0x0000 }, /* R11866 */ - { 0x0000, 0x0000, 0x0000 }, /* R11867 */ - { 0x0000, 0x0000, 0x0000 }, /* R11868 */ - { 0x0000, 0x0000, 0x0000 }, /* R11869 */ - { 0x0000, 0x0000, 0x0000 }, /* R11870 */ - { 0x0000, 0x0000, 0x0000 }, /* R11871 */ - { 0x0000, 0x0000, 0x0000 }, /* R11872 */ - { 0x0000, 0x0000, 0x0000 }, /* R11873 */ - { 0x0000, 0x0000, 0x0000 }, /* R11874 */ - { 0x0000, 0x0000, 0x0000 }, /* R11875 */ - { 0x0000, 0x0000, 0x0000 }, /* R11876 */ - { 0x0000, 0x0000, 0x0000 }, /* R11877 */ - { 0x0000, 0x0000, 0x0000 }, /* R11878 */ - { 0x0000, 0x0000, 0x0000 }, /* R11879 */ - { 0x0000, 0x0000, 0x0000 }, /* R11880 */ - { 0x0000, 0x0000, 0x0000 }, /* R11881 */ - { 0x0000, 0x0000, 0x0000 }, /* R11882 */ - { 0x0000, 0x0000, 0x0000 }, /* R11883 */ - { 0x0000, 0x0000, 0x0000 }, /* R11884 */ - { 0x0000, 0x0000, 0x0000 }, /* R11885 */ - { 0x0000, 0x0000, 0x0000 }, /* R11886 */ - { 0x0000, 0x0000, 0x0000 }, /* R11887 */ - { 0x0000, 0x0000, 0x0000 }, /* R11888 */ - { 0x0000, 0x0000, 0x0000 }, /* R11889 */ - { 0x0000, 0x0000, 0x0000 }, /* R11890 */ - { 0x0000, 0x0000, 0x0000 }, /* R11891 */ - { 0x0000, 0x0000, 0x0000 }, /* R11892 */ - { 0x0000, 0x0000, 0x0000 }, /* R11893 */ - { 0x0000, 0x0000, 0x0000 }, /* R11894 */ - { 0x0000, 0x0000, 0x0000 }, /* R11895 */ - { 0x0000, 0x0000, 0x0000 }, /* R11896 */ - { 0x0000, 0x0000, 0x0000 }, /* R11897 */ - { 0x0000, 0x0000, 0x0000 }, /* R11898 */ - { 0x0000, 0x0000, 0x0000 }, /* R11899 */ - { 0x0000, 0x0000, 0x0000 }, /* R11900 */ - { 0x0000, 0x0000, 0x0000 }, /* R11901 */ - { 0x0000, 0x0000, 0x0000 }, /* R11902 */ - { 0x0000, 0x0000, 0x0000 }, /* R11903 */ - { 0x0000, 0x0000, 0x0000 }, /* R11904 */ - { 0x0000, 0x0000, 0x0000 }, /* R11905 */ - { 0x0000, 0x0000, 0x0000 }, /* R11906 */ - { 0x0000, 0x0000, 0x0000 }, /* R11907 */ - { 0x0000, 0x0000, 0x0000 }, /* R11908 */ - { 0x0000, 0x0000, 0x0000 }, /* R11909 */ - { 0x0000, 0x0000, 0x0000 }, /* R11910 */ - { 0x0000, 0x0000, 0x0000 }, /* R11911 */ - { 0x0000, 0x0000, 0x0000 }, /* R11912 */ - { 0x0000, 0x0000, 0x0000 }, /* R11913 */ - { 0x0000, 0x0000, 0x0000 }, /* R11914 */ - { 0x0000, 0x0000, 0x0000 }, /* R11915 */ - { 0x0000, 0x0000, 0x0000 }, /* R11916 */ - { 0x0000, 0x0000, 0x0000 }, /* R11917 */ - { 0x0000, 0x0000, 0x0000 }, /* R11918 */ - { 0x0000, 0x0000, 0x0000 }, /* R11919 */ - { 0x0000, 0x0000, 0x0000 }, /* R11920 */ - { 0x0000, 0x0000, 0x0000 }, /* R11921 */ - { 0x0000, 0x0000, 0x0000 }, /* R11922 */ - { 0x0000, 0x0000, 0x0000 }, /* R11923 */ - { 0x0000, 0x0000, 0x0000 }, /* R11924 */ - { 0x0000, 0x0000, 0x0000 }, /* R11925 */ - { 0x0000, 0x0000, 0x0000 }, /* R11926 */ - { 0x0000, 0x0000, 0x0000 }, /* R11927 */ - { 0x0000, 0x0000, 0x0000 }, /* R11928 */ - { 0x0000, 0x0000, 0x0000 }, /* R11929 */ - { 0x0000, 0x0000, 0x0000 }, /* R11930 */ - { 0x0000, 0x0000, 0x0000 }, /* R11931 */ - { 0x0000, 0x0000, 0x0000 }, /* R11932 */ - { 0x0000, 0x0000, 0x0000 }, /* R11933 */ - { 0x0000, 0x0000, 0x0000 }, /* R11934 */ - { 0x0000, 0x0000, 0x0000 }, /* R11935 */ - { 0x0000, 0x0000, 0x0000 }, /* R11936 */ - { 0x0000, 0x0000, 0x0000 }, /* R11937 */ - { 0x0000, 0x0000, 0x0000 }, /* R11938 */ - { 0x0000, 0x0000, 0x0000 }, /* R11939 */ - { 0x0000, 0x0000, 0x0000 }, /* R11940 */ - { 0x0000, 0x0000, 0x0000 }, /* R11941 */ - { 0x0000, 0x0000, 0x0000 }, /* R11942 */ - { 0x0000, 0x0000, 0x0000 }, /* R11943 */ - { 0x0000, 0x0000, 0x0000 }, /* R11944 */ - { 0x0000, 0x0000, 0x0000 }, /* R11945 */ - { 0x0000, 0x0000, 0x0000 }, /* R11946 */ - { 0x0000, 0x0000, 0x0000 }, /* R11947 */ - { 0x0000, 0x0000, 0x0000 }, /* R11948 */ - { 0x0000, 0x0000, 0x0000 }, /* R11949 */ - { 0x0000, 0x0000, 0x0000 }, /* R11950 */ - { 0x0000, 0x0000, 0x0000 }, /* R11951 */ - { 0x0000, 0x0000, 0x0000 }, /* R11952 */ - { 0x0000, 0x0000, 0x0000 }, /* R11953 */ - { 0x0000, 0x0000, 0x0000 }, /* R11954 */ - { 0x0000, 0x0000, 0x0000 }, /* R11955 */ - { 0x0000, 0x0000, 0x0000 }, /* R11956 */ - { 0x0000, 0x0000, 0x0000 }, /* R11957 */ - { 0x0000, 0x0000, 0x0000 }, /* R11958 */ - { 0x0000, 0x0000, 0x0000 }, /* R11959 */ - { 0x0000, 0x0000, 0x0000 }, /* R11960 */ - { 0x0000, 0x0000, 0x0000 }, /* R11961 */ - { 0x0000, 0x0000, 0x0000 }, /* R11962 */ - { 0x0000, 0x0000, 0x0000 }, /* R11963 */ - { 0x0000, 0x0000, 0x0000 }, /* R11964 */ - { 0x0000, 0x0000, 0x0000 }, /* R11965 */ - { 0x0000, 0x0000, 0x0000 }, /* R11966 */ - { 0x0000, 0x0000, 0x0000 }, /* R11967 */ - { 0x0000, 0x0000, 0x0000 }, /* R11968 */ - { 0x0000, 0x0000, 0x0000 }, /* R11969 */ - { 0x0000, 0x0000, 0x0000 }, /* R11970 */ - { 0x0000, 0x0000, 0x0000 }, /* R11971 */ - { 0x0000, 0x0000, 0x0000 }, /* R11972 */ - { 0x0000, 0x0000, 0x0000 }, /* R11973 */ - { 0x0000, 0x0000, 0x0000 }, /* R11974 */ - { 0x0000, 0x0000, 0x0000 }, /* R11975 */ - { 0x0000, 0x0000, 0x0000 }, /* R11976 */ - { 0x0000, 0x0000, 0x0000 }, /* R11977 */ - { 0x0000, 0x0000, 0x0000 }, /* R11978 */ - { 0x0000, 0x0000, 0x0000 }, /* R11979 */ - { 0x0000, 0x0000, 0x0000 }, /* R11980 */ - { 0x0000, 0x0000, 0x0000 }, /* R11981 */ - { 0x0000, 0x0000, 0x0000 }, /* R11982 */ - { 0x0000, 0x0000, 0x0000 }, /* R11983 */ - { 0x0000, 0x0000, 0x0000 }, /* R11984 */ - { 0x0000, 0x0000, 0x0000 }, /* R11985 */ - { 0x0000, 0x0000, 0x0000 }, /* R11986 */ - { 0x0000, 0x0000, 0x0000 }, /* R11987 */ - { 0x0000, 0x0000, 0x0000 }, /* R11988 */ - { 0x0000, 0x0000, 0x0000 }, /* R11989 */ - { 0x0000, 0x0000, 0x0000 }, /* R11990 */ - { 0x0000, 0x0000, 0x0000 }, /* R11991 */ - { 0x0000, 0x0000, 0x0000 }, /* R11992 */ - { 0x0000, 0x0000, 0x0000 }, /* R11993 */ - { 0x0000, 0x0000, 0x0000 }, /* R11994 */ - { 0x0000, 0x0000, 0x0000 }, /* R11995 */ - { 0x0000, 0x0000, 0x0000 }, /* R11996 */ - { 0x0000, 0x0000, 0x0000 }, /* R11997 */ - { 0x0000, 0x0000, 0x0000 }, /* R11998 */ - { 0x0000, 0x0000, 0x0000 }, /* R11999 */ - { 0x0000, 0x0000, 0x0000 }, /* R12000 */ - { 0x0000, 0x0000, 0x0000 }, /* R12001 */ - { 0x0000, 0x0000, 0x0000 }, /* R12002 */ - { 0x0000, 0x0000, 0x0000 }, /* R12003 */ - { 0x0000, 0x0000, 0x0000 }, /* R12004 */ - { 0x0000, 0x0000, 0x0000 }, /* R12005 */ - { 0x0000, 0x0000, 0x0000 }, /* R12006 */ - { 0x0000, 0x0000, 0x0000 }, /* R12007 */ - { 0x0000, 0x0000, 0x0000 }, /* R12008 */ - { 0x0000, 0x0000, 0x0000 }, /* R12009 */ - { 0x0000, 0x0000, 0x0000 }, /* R12010 */ - { 0x0000, 0x0000, 0x0000 }, /* R12011 */ - { 0x0000, 0x0000, 0x0000 }, /* R12012 */ - { 0x0000, 0x0000, 0x0000 }, /* R12013 */ - { 0x0000, 0x0000, 0x0000 }, /* R12014 */ - { 0x0000, 0x0000, 0x0000 }, /* R12015 */ - { 0x0000, 0x0000, 0x0000 }, /* R12016 */ - { 0x0000, 0x0000, 0x0000 }, /* R12017 */ - { 0x0000, 0x0000, 0x0000 }, /* R12018 */ - { 0x0000, 0x0000, 0x0000 }, /* R12019 */ - { 0x0000, 0x0000, 0x0000 }, /* R12020 */ - { 0x0000, 0x0000, 0x0000 }, /* R12021 */ - { 0x0000, 0x0000, 0x0000 }, /* R12022 */ - { 0x0000, 0x0000, 0x0000 }, /* R12023 */ - { 0x0000, 0x0000, 0x0000 }, /* R12024 */ - { 0x0000, 0x0000, 0x0000 }, /* R12025 */ - { 0x0000, 0x0000, 0x0000 }, /* R12026 */ - { 0x0000, 0x0000, 0x0000 }, /* R12027 */ - { 0x0000, 0x0000, 0x0000 }, /* R12028 */ - { 0x0000, 0x0000, 0x0000 }, /* R12029 */ - { 0x0000, 0x0000, 0x0000 }, /* R12030 */ - { 0x0000, 0x0000, 0x0000 }, /* R12031 */ - { 0x0000, 0x0000, 0x0000 }, /* R12032 */ - { 0x0000, 0x0000, 0x0000 }, /* R12033 */ - { 0x0000, 0x0000, 0x0000 }, /* R12034 */ - { 0x0000, 0x0000, 0x0000 }, /* R12035 */ - { 0x0000, 0x0000, 0x0000 }, /* R12036 */ - { 0x0000, 0x0000, 0x0000 }, /* R12037 */ - { 0x0000, 0x0000, 0x0000 }, /* R12038 */ - { 0x0000, 0x0000, 0x0000 }, /* R12039 */ - { 0x0000, 0x0000, 0x0000 }, /* R12040 */ - { 0x0000, 0x0000, 0x0000 }, /* R12041 */ - { 0x0000, 0x0000, 0x0000 }, /* R12042 */ - { 0x0000, 0x0000, 0x0000 }, /* R12043 */ - { 0x0000, 0x0000, 0x0000 }, /* R12044 */ - { 0x0000, 0x0000, 0x0000 }, /* R12045 */ - { 0x0000, 0x0000, 0x0000 }, /* R12046 */ - { 0x0000, 0x0000, 0x0000 }, /* R12047 */ - { 0x0000, 0x0000, 0x0000 }, /* R12048 */ - { 0x0000, 0x0000, 0x0000 }, /* R12049 */ - { 0x0000, 0x0000, 0x0000 }, /* R12050 */ - { 0x0000, 0x0000, 0x0000 }, /* R12051 */ - { 0x0000, 0x0000, 0x0000 }, /* R12052 */ - { 0x0000, 0x0000, 0x0000 }, /* R12053 */ - { 0x0000, 0x0000, 0x0000 }, /* R12054 */ - { 0x0000, 0x0000, 0x0000 }, /* R12055 */ - { 0x0000, 0x0000, 0x0000 }, /* R12056 */ - { 0x0000, 0x0000, 0x0000 }, /* R12057 */ - { 0x0000, 0x0000, 0x0000 }, /* R12058 */ - { 0x0000, 0x0000, 0x0000 }, /* R12059 */ - { 0x0000, 0x0000, 0x0000 }, /* R12060 */ - { 0x0000, 0x0000, 0x0000 }, /* R12061 */ - { 0x0000, 0x0000, 0x0000 }, /* R12062 */ - { 0x0000, 0x0000, 0x0000 }, /* R12063 */ - { 0x0000, 0x0000, 0x0000 }, /* R12064 */ - { 0x0000, 0x0000, 0x0000 }, /* R12065 */ - { 0x0000, 0x0000, 0x0000 }, /* R12066 */ - { 0x0000, 0x0000, 0x0000 }, /* R12067 */ - { 0x0000, 0x0000, 0x0000 }, /* R12068 */ - { 0x0000, 0x0000, 0x0000 }, /* R12069 */ - { 0x0000, 0x0000, 0x0000 }, /* R12070 */ - { 0x0000, 0x0000, 0x0000 }, /* R12071 */ - { 0x0000, 0x0000, 0x0000 }, /* R12072 */ - { 0x0000, 0x0000, 0x0000 }, /* R12073 */ - { 0x0000, 0x0000, 0x0000 }, /* R12074 */ - { 0x0000, 0x0000, 0x0000 }, /* R12075 */ - { 0x0000, 0x0000, 0x0000 }, /* R12076 */ - { 0x0000, 0x0000, 0x0000 }, /* R12077 */ - { 0x0000, 0x0000, 0x0000 }, /* R12078 */ - { 0x0000, 0x0000, 0x0000 }, /* R12079 */ - { 0x0000, 0x0000, 0x0000 }, /* R12080 */ - { 0x0000, 0x0000, 0x0000 }, /* R12081 */ - { 0x0000, 0x0000, 0x0000 }, /* R12082 */ - { 0x0000, 0x0000, 0x0000 }, /* R12083 */ - { 0x0000, 0x0000, 0x0000 }, /* R12084 */ - { 0x0000, 0x0000, 0x0000 }, /* R12085 */ - { 0x0000, 0x0000, 0x0000 }, /* R12086 */ - { 0x0000, 0x0000, 0x0000 }, /* R12087 */ - { 0x0000, 0x0000, 0x0000 }, /* R12088 */ - { 0x0000, 0x0000, 0x0000 }, /* R12089 */ - { 0x0000, 0x0000, 0x0000 }, /* R12090 */ - { 0x0000, 0x0000, 0x0000 }, /* R12091 */ - { 0x0000, 0x0000, 0x0000 }, /* R12092 */ - { 0x0000, 0x0000, 0x0000 }, /* R12093 */ - { 0x0000, 0x0000, 0x0000 }, /* R12094 */ - { 0x0000, 0x0000, 0x0000 }, /* R12095 */ - { 0x0000, 0x0000, 0x0000 }, /* R12096 */ - { 0x0000, 0x0000, 0x0000 }, /* R12097 */ - { 0x0000, 0x0000, 0x0000 }, /* R12098 */ - { 0x0000, 0x0000, 0x0000 }, /* R12099 */ - { 0x0000, 0x0000, 0x0000 }, /* R12100 */ - { 0x0000, 0x0000, 0x0000 }, /* R12101 */ - { 0x0000, 0x0000, 0x0000 }, /* R12102 */ - { 0x0000, 0x0000, 0x0000 }, /* R12103 */ - { 0x0000, 0x0000, 0x0000 }, /* R12104 */ - { 0x0000, 0x0000, 0x0000 }, /* R12105 */ - { 0x0000, 0x0000, 0x0000 }, /* R12106 */ - { 0x0000, 0x0000, 0x0000 }, /* R12107 */ - { 0x0000, 0x0000, 0x0000 }, /* R12108 */ - { 0x0000, 0x0000, 0x0000 }, /* R12109 */ - { 0x0000, 0x0000, 0x0000 }, /* R12110 */ - { 0x0000, 0x0000, 0x0000 }, /* R12111 */ - { 0x0000, 0x0000, 0x0000 }, /* R12112 */ - { 0x0000, 0x0000, 0x0000 }, /* R12113 */ - { 0x0000, 0x0000, 0x0000 }, /* R12114 */ - { 0x0000, 0x0000, 0x0000 }, /* R12115 */ - { 0x0000, 0x0000, 0x0000 }, /* R12116 */ - { 0x0000, 0x0000, 0x0000 }, /* R12117 */ - { 0x0000, 0x0000, 0x0000 }, /* R12118 */ - { 0x0000, 0x0000, 0x0000 }, /* R12119 */ - { 0x0000, 0x0000, 0x0000 }, /* R12120 */ - { 0x0000, 0x0000, 0x0000 }, /* R12121 */ - { 0x0000, 0x0000, 0x0000 }, /* R12122 */ - { 0x0000, 0x0000, 0x0000 }, /* R12123 */ - { 0x0000, 0x0000, 0x0000 }, /* R12124 */ - { 0x0000, 0x0000, 0x0000 }, /* R12125 */ - { 0x0000, 0x0000, 0x0000 }, /* R12126 */ - { 0x0000, 0x0000, 0x0000 }, /* R12127 */ - { 0x0000, 0x0000, 0x0000 }, /* R12128 */ - { 0x0000, 0x0000, 0x0000 }, /* R12129 */ - { 0x0000, 0x0000, 0x0000 }, /* R12130 */ - { 0x0000, 0x0000, 0x0000 }, /* R12131 */ - { 0x0000, 0x0000, 0x0000 }, /* R12132 */ - { 0x0000, 0x0000, 0x0000 }, /* R12133 */ - { 0x0000, 0x0000, 0x0000 }, /* R12134 */ - { 0x0000, 0x0000, 0x0000 }, /* R12135 */ - { 0x0000, 0x0000, 0x0000 }, /* R12136 */ - { 0x0000, 0x0000, 0x0000 }, /* R12137 */ - { 0x0000, 0x0000, 0x0000 }, /* R12138 */ - { 0x0000, 0x0000, 0x0000 }, /* R12139 */ - { 0x0000, 0x0000, 0x0000 }, /* R12140 */ - { 0x0000, 0x0000, 0x0000 }, /* R12141 */ - { 0x0000, 0x0000, 0x0000 }, /* R12142 */ - { 0x0000, 0x0000, 0x0000 }, /* R12143 */ - { 0x0000, 0x0000, 0x0000 }, /* R12144 */ - { 0x0000, 0x0000, 0x0000 }, /* R12145 */ - { 0x0000, 0x0000, 0x0000 }, /* R12146 */ - { 0x0000, 0x0000, 0x0000 }, /* R12147 */ - { 0x0000, 0x0000, 0x0000 }, /* R12148 */ - { 0x0000, 0x0000, 0x0000 }, /* R12149 */ - { 0x0000, 0x0000, 0x0000 }, /* R12150 */ - { 0x0000, 0x0000, 0x0000 }, /* R12151 */ - { 0x0000, 0x0000, 0x0000 }, /* R12152 */ - { 0x0000, 0x0000, 0x0000 }, /* R12153 */ - { 0x0000, 0x0000, 0x0000 }, /* R12154 */ - { 0x0000, 0x0000, 0x0000 }, /* R12155 */ - { 0x0000, 0x0000, 0x0000 }, /* R12156 */ - { 0x0000, 0x0000, 0x0000 }, /* R12157 */ - { 0x0000, 0x0000, 0x0000 }, /* R12158 */ - { 0x0000, 0x0000, 0x0000 }, /* R12159 */ - { 0x0000, 0x0000, 0x0000 }, /* R12160 */ - { 0x0000, 0x0000, 0x0000 }, /* R12161 */ - { 0x0000, 0x0000, 0x0000 }, /* R12162 */ - { 0x0000, 0x0000, 0x0000 }, /* R12163 */ - { 0x0000, 0x0000, 0x0000 }, /* R12164 */ - { 0x0000, 0x0000, 0x0000 }, /* R12165 */ - { 0x0000, 0x0000, 0x0000 }, /* R12166 */ - { 0x0000, 0x0000, 0x0000 }, /* R12167 */ - { 0x0000, 0x0000, 0x0000 }, /* R12168 */ - { 0x0000, 0x0000, 0x0000 }, /* R12169 */ - { 0x0000, 0x0000, 0x0000 }, /* R12170 */ - { 0x0000, 0x0000, 0x0000 }, /* R12171 */ - { 0x0000, 0x0000, 0x0000 }, /* R12172 */ - { 0x0000, 0x0000, 0x0000 }, /* R12173 */ - { 0x0000, 0x0000, 0x0000 }, /* R12174 */ - { 0x0000, 0x0000, 0x0000 }, /* R12175 */ - { 0x0000, 0x0000, 0x0000 }, /* R12176 */ - { 0x0000, 0x0000, 0x0000 }, /* R12177 */ - { 0x0000, 0x0000, 0x0000 }, /* R12178 */ - { 0x0000, 0x0000, 0x0000 }, /* R12179 */ - { 0x0000, 0x0000, 0x0000 }, /* R12180 */ - { 0x0000, 0x0000, 0x0000 }, /* R12181 */ - { 0x0000, 0x0000, 0x0000 }, /* R12182 */ - { 0x0000, 0x0000, 0x0000 }, /* R12183 */ - { 0x0000, 0x0000, 0x0000 }, /* R12184 */ - { 0x0000, 0x0000, 0x0000 }, /* R12185 */ - { 0x0000, 0x0000, 0x0000 }, /* R12186 */ - { 0x0000, 0x0000, 0x0000 }, /* R12187 */ - { 0x0000, 0x0000, 0x0000 }, /* R12188 */ - { 0x0000, 0x0000, 0x0000 }, /* R12189 */ - { 0x0000, 0x0000, 0x0000 }, /* R12190 */ - { 0x0000, 0x0000, 0x0000 }, /* R12191 */ - { 0x0000, 0x0000, 0x0000 }, /* R12192 */ - { 0x0000, 0x0000, 0x0000 }, /* R12193 */ - { 0x0000, 0x0000, 0x0000 }, /* R12194 */ - { 0x0000, 0x0000, 0x0000 }, /* R12195 */ - { 0x0000, 0x0000, 0x0000 }, /* R12196 */ - { 0x0000, 0x0000, 0x0000 }, /* R12197 */ - { 0x0000, 0x0000, 0x0000 }, /* R12198 */ - { 0x0000, 0x0000, 0x0000 }, /* R12199 */ - { 0x0000, 0x0000, 0x0000 }, /* R12200 */ - { 0x0000, 0x0000, 0x0000 }, /* R12201 */ - { 0x0000, 0x0000, 0x0000 }, /* R12202 */ - { 0x0000, 0x0000, 0x0000 }, /* R12203 */ - { 0x0000, 0x0000, 0x0000 }, /* R12204 */ - { 0x0000, 0x0000, 0x0000 }, /* R12205 */ - { 0x0000, 0x0000, 0x0000 }, /* R12206 */ - { 0x0000, 0x0000, 0x0000 }, /* R12207 */ - { 0x0000, 0x0000, 0x0000 }, /* R12208 */ - { 0x0000, 0x0000, 0x0000 }, /* R12209 */ - { 0x0000, 0x0000, 0x0000 }, /* R12210 */ - { 0x0000, 0x0000, 0x0000 }, /* R12211 */ - { 0x0000, 0x0000, 0x0000 }, /* R12212 */ - { 0x0000, 0x0000, 0x0000 }, /* R12213 */ - { 0x0000, 0x0000, 0x0000 }, /* R12214 */ - { 0x0000, 0x0000, 0x0000 }, /* R12215 */ - { 0x0000, 0x0000, 0x0000 }, /* R12216 */ - { 0x0000, 0x0000, 0x0000 }, /* R12217 */ - { 0x0000, 0x0000, 0x0000 }, /* R12218 */ - { 0x0000, 0x0000, 0x0000 }, /* R12219 */ - { 0x0000, 0x0000, 0x0000 }, /* R12220 */ - { 0x0000, 0x0000, 0x0000 }, /* R12221 */ - { 0x0000, 0x0000, 0x0000 }, /* R12222 */ - { 0x0000, 0x0000, 0x0000 }, /* R12223 */ - { 0x0000, 0x0000, 0x0000 }, /* R12224 */ - { 0x0000, 0x0000, 0x0000 }, /* R12225 */ - { 0x0000, 0x0000, 0x0000 }, /* R12226 */ - { 0x0000, 0x0000, 0x0000 }, /* R12227 */ - { 0x0000, 0x0000, 0x0000 }, /* R12228 */ - { 0x0000, 0x0000, 0x0000 }, /* R12229 */ - { 0x0000, 0x0000, 0x0000 }, /* R12230 */ - { 0x0000, 0x0000, 0x0000 }, /* R12231 */ - { 0x0000, 0x0000, 0x0000 }, /* R12232 */ - { 0x0000, 0x0000, 0x0000 }, /* R12233 */ - { 0x0000, 0x0000, 0x0000 }, /* R12234 */ - { 0x0000, 0x0000, 0x0000 }, /* R12235 */ - { 0x0000, 0x0000, 0x0000 }, /* R12236 */ - { 0x0000, 0x0000, 0x0000 }, /* R12237 */ - { 0x0000, 0x0000, 0x0000 }, /* R12238 */ - { 0x0000, 0x0000, 0x0000 }, /* R12239 */ - { 0x0000, 0x0000, 0x0000 }, /* R12240 */ - { 0x0000, 0x0000, 0x0000 }, /* R12241 */ - { 0x0000, 0x0000, 0x0000 }, /* R12242 */ - { 0x0000, 0x0000, 0x0000 }, /* R12243 */ - { 0x0000, 0x0000, 0x0000 }, /* R12244 */ - { 0x0000, 0x0000, 0x0000 }, /* R12245 */ - { 0x0000, 0x0000, 0x0000 }, /* R12246 */ - { 0x0000, 0x0000, 0x0000 }, /* R12247 */ - { 0x0000, 0x0000, 0x0000 }, /* R12248 */ - { 0x0000, 0x0000, 0x0000 }, /* R12249 */ - { 0x0000, 0x0000, 0x0000 }, /* R12250 */ - { 0x0000, 0x0000, 0x0000 }, /* R12251 */ - { 0x0000, 0x0000, 0x0000 }, /* R12252 */ - { 0x0000, 0x0000, 0x0000 }, /* R12253 */ - { 0x0000, 0x0000, 0x0000 }, /* R12254 */ - { 0x0000, 0x0000, 0x0000 }, /* R12255 */ - { 0x0000, 0x0000, 0x0000 }, /* R12256 */ - { 0x0000, 0x0000, 0x0000 }, /* R12257 */ - { 0x0000, 0x0000, 0x0000 }, /* R12258 */ - { 0x0000, 0x0000, 0x0000 }, /* R12259 */ - { 0x0000, 0x0000, 0x0000 }, /* R12260 */ - { 0x0000, 0x0000, 0x0000 }, /* R12261 */ - { 0x0000, 0x0000, 0x0000 }, /* R12262 */ - { 0x0000, 0x0000, 0x0000 }, /* R12263 */ - { 0x0000, 0x0000, 0x0000 }, /* R12264 */ - { 0x0000, 0x0000, 0x0000 }, /* R12265 */ - { 0x0000, 0x0000, 0x0000 }, /* R12266 */ - { 0x0000, 0x0000, 0x0000 }, /* R12267 */ - { 0x0000, 0x0000, 0x0000 }, /* R12268 */ - { 0x0000, 0x0000, 0x0000 }, /* R12269 */ - { 0x0000, 0x0000, 0x0000 }, /* R12270 */ - { 0x0000, 0x0000, 0x0000 }, /* R12271 */ - { 0x0000, 0x0000, 0x0000 }, /* R12272 */ - { 0x0000, 0x0000, 0x0000 }, /* R12273 */ - { 0x0000, 0x0000, 0x0000 }, /* R12274 */ - { 0x0000, 0x0000, 0x0000 }, /* R12275 */ - { 0x0000, 0x0000, 0x0000 }, /* R12276 */ - { 0x0000, 0x0000, 0x0000 }, /* R12277 */ - { 0x0000, 0x0000, 0x0000 }, /* R12278 */ - { 0x0000, 0x0000, 0x0000 }, /* R12279 */ - { 0x0000, 0x0000, 0x0000 }, /* R12280 */ - { 0x0000, 0x0000, 0x0000 }, /* R12281 */ - { 0x0000, 0x0000, 0x0000 }, /* R12282 */ - { 0x0000, 0x0000, 0x0000 }, /* R12283 */ - { 0x0000, 0x0000, 0x0000 }, /* R12284 */ - { 0x0000, 0x0000, 0x0000 }, /* R12285 */ - { 0x0000, 0x0000, 0x0000 }, /* R12286 */ - { 0x0000, 0x0000, 0x0000 }, /* R12287 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R12288 - DSP2 Data1 RAM 1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R12289 - DSP2 Data1 RAM 0 */ - { 0x0000, 0x0000, 0x0000 }, /* R12290 */ - { 0x0000, 0x0000, 0x0000 }, /* R12291 */ - { 0x0000, 0x0000, 0x0000 }, /* R12292 */ - { 0x0000, 0x0000, 0x0000 }, /* R12293 */ - { 0x0000, 0x0000, 0x0000 }, /* R12294 */ - { 0x0000, 0x0000, 0x0000 }, /* R12295 */ - { 0x0000, 0x0000, 0x0000 }, /* R12296 */ - { 0x0000, 0x0000, 0x0000 }, /* R12297 */ - { 0x0000, 0x0000, 0x0000 }, /* R12298 */ - { 0x0000, 0x0000, 0x0000 }, /* R12299 */ - { 0x0000, 0x0000, 0x0000 }, /* R12300 */ - { 0x0000, 0x0000, 0x0000 }, /* R12301 */ - { 0x0000, 0x0000, 0x0000 }, /* R12302 */ - { 0x0000, 0x0000, 0x0000 }, /* R12303 */ - { 0x0000, 0x0000, 0x0000 }, /* R12304 */ - { 0x0000, 0x0000, 0x0000 }, /* R12305 */ - { 0x0000, 0x0000, 0x0000 }, /* R12306 */ - { 0x0000, 0x0000, 0x0000 }, /* R12307 */ - { 0x0000, 0x0000, 0x0000 }, /* R12308 */ - { 0x0000, 0x0000, 0x0000 }, /* R12309 */ - { 0x0000, 0x0000, 0x0000 }, /* R12310 */ - { 0x0000, 0x0000, 0x0000 }, /* R12311 */ - { 0x0000, 0x0000, 0x0000 }, /* R12312 */ - { 0x0000, 0x0000, 0x0000 }, /* R12313 */ - { 0x0000, 0x0000, 0x0000 }, /* R12314 */ - { 0x0000, 0x0000, 0x0000 }, /* R12315 */ - { 0x0000, 0x0000, 0x0000 }, /* R12316 */ - { 0x0000, 0x0000, 0x0000 }, /* R12317 */ - { 0x0000, 0x0000, 0x0000 }, /* R12318 */ - { 0x0000, 0x0000, 0x0000 }, /* R12319 */ - { 0x0000, 0x0000, 0x0000 }, /* R12320 */ - { 0x0000, 0x0000, 0x0000 }, /* R12321 */ - { 0x0000, 0x0000, 0x0000 }, /* R12322 */ - { 0x0000, 0x0000, 0x0000 }, /* R12323 */ - { 0x0000, 0x0000, 0x0000 }, /* R12324 */ - { 0x0000, 0x0000, 0x0000 }, /* R12325 */ - { 0x0000, 0x0000, 0x0000 }, /* R12326 */ - { 0x0000, 0x0000, 0x0000 }, /* R12327 */ - { 0x0000, 0x0000, 0x0000 }, /* R12328 */ - { 0x0000, 0x0000, 0x0000 }, /* R12329 */ - { 0x0000, 0x0000, 0x0000 }, /* R12330 */ - { 0x0000, 0x0000, 0x0000 }, /* R12331 */ - { 0x0000, 0x0000, 0x0000 }, /* R12332 */ - { 0x0000, 0x0000, 0x0000 }, /* R12333 */ - { 0x0000, 0x0000, 0x0000 }, /* R12334 */ - { 0x0000, 0x0000, 0x0000 }, /* R12335 */ - { 0x0000, 0x0000, 0x0000 }, /* R12336 */ - { 0x0000, 0x0000, 0x0000 }, /* R12337 */ - { 0x0000, 0x0000, 0x0000 }, /* R12338 */ - { 0x0000, 0x0000, 0x0000 }, /* R12339 */ - { 0x0000, 0x0000, 0x0000 }, /* R12340 */ - { 0x0000, 0x0000, 0x0000 }, /* R12341 */ - { 0x0000, 0x0000, 0x0000 }, /* R12342 */ - { 0x0000, 0x0000, 0x0000 }, /* R12343 */ - { 0x0000, 0x0000, 0x0000 }, /* R12344 */ - { 0x0000, 0x0000, 0x0000 }, /* R12345 */ - { 0x0000, 0x0000, 0x0000 }, /* R12346 */ - { 0x0000, 0x0000, 0x0000 }, /* R12347 */ - { 0x0000, 0x0000, 0x0000 }, /* R12348 */ - { 0x0000, 0x0000, 0x0000 }, /* R12349 */ - { 0x0000, 0x0000, 0x0000 }, /* R12350 */ - { 0x0000, 0x0000, 0x0000 }, /* R12351 */ - { 0x0000, 0x0000, 0x0000 }, /* R12352 */ - { 0x0000, 0x0000, 0x0000 }, /* R12353 */ - { 0x0000, 0x0000, 0x0000 }, /* R12354 */ - { 0x0000, 0x0000, 0x0000 }, /* R12355 */ - { 0x0000, 0x0000, 0x0000 }, /* R12356 */ - { 0x0000, 0x0000, 0x0000 }, /* R12357 */ - { 0x0000, 0x0000, 0x0000 }, /* R12358 */ - { 0x0000, 0x0000, 0x0000 }, /* R12359 */ - { 0x0000, 0x0000, 0x0000 }, /* R12360 */ - { 0x0000, 0x0000, 0x0000 }, /* R12361 */ - { 0x0000, 0x0000, 0x0000 }, /* R12362 */ - { 0x0000, 0x0000, 0x0000 }, /* R12363 */ - { 0x0000, 0x0000, 0x0000 }, /* R12364 */ - { 0x0000, 0x0000, 0x0000 }, /* R12365 */ - { 0x0000, 0x0000, 0x0000 }, /* R12366 */ - { 0x0000, 0x0000, 0x0000 }, /* R12367 */ - { 0x0000, 0x0000, 0x0000 }, /* R12368 */ - { 0x0000, 0x0000, 0x0000 }, /* R12369 */ - { 0x0000, 0x0000, 0x0000 }, /* R12370 */ - { 0x0000, 0x0000, 0x0000 }, /* R12371 */ - { 0x0000, 0x0000, 0x0000 }, /* R12372 */ - { 0x0000, 0x0000, 0x0000 }, /* R12373 */ - { 0x0000, 0x0000, 0x0000 }, /* R12374 */ - { 0x0000, 0x0000, 0x0000 }, /* R12375 */ - { 0x0000, 0x0000, 0x0000 }, /* R12376 */ - { 0x0000, 0x0000, 0x0000 }, /* R12377 */ - { 0x0000, 0x0000, 0x0000 }, /* R12378 */ - { 0x0000, 0x0000, 0x0000 }, /* R12379 */ - { 0x0000, 0x0000, 0x0000 }, /* R12380 */ - { 0x0000, 0x0000, 0x0000 }, /* R12381 */ - { 0x0000, 0x0000, 0x0000 }, /* R12382 */ - { 0x0000, 0x0000, 0x0000 }, /* R12383 */ - { 0x0000, 0x0000, 0x0000 }, /* R12384 */ - { 0x0000, 0x0000, 0x0000 }, /* R12385 */ - { 0x0000, 0x0000, 0x0000 }, /* R12386 */ - { 0x0000, 0x0000, 0x0000 }, /* R12387 */ - { 0x0000, 0x0000, 0x0000 }, /* R12388 */ - { 0x0000, 0x0000, 0x0000 }, /* R12389 */ - { 0x0000, 0x0000, 0x0000 }, /* R12390 */ - { 0x0000, 0x0000, 0x0000 }, /* R12391 */ - { 0x0000, 0x0000, 0x0000 }, /* R12392 */ - { 0x0000, 0x0000, 0x0000 }, /* R12393 */ - { 0x0000, 0x0000, 0x0000 }, /* R12394 */ - { 0x0000, 0x0000, 0x0000 }, /* R12395 */ - { 0x0000, 0x0000, 0x0000 }, /* R12396 */ - { 0x0000, 0x0000, 0x0000 }, /* R12397 */ - { 0x0000, 0x0000, 0x0000 }, /* R12398 */ - { 0x0000, 0x0000, 0x0000 }, /* R12399 */ - { 0x0000, 0x0000, 0x0000 }, /* R12400 */ - { 0x0000, 0x0000, 0x0000 }, /* R12401 */ - { 0x0000, 0x0000, 0x0000 }, /* R12402 */ - { 0x0000, 0x0000, 0x0000 }, /* R12403 */ - { 0x0000, 0x0000, 0x0000 }, /* R12404 */ - { 0x0000, 0x0000, 0x0000 }, /* R12405 */ - { 0x0000, 0x0000, 0x0000 }, /* R12406 */ - { 0x0000, 0x0000, 0x0000 }, /* R12407 */ - { 0x0000, 0x0000, 0x0000 }, /* R12408 */ - { 0x0000, 0x0000, 0x0000 }, /* R12409 */ - { 0x0000, 0x0000, 0x0000 }, /* R12410 */ - { 0x0000, 0x0000, 0x0000 }, /* R12411 */ - { 0x0000, 0x0000, 0x0000 }, /* R12412 */ - { 0x0000, 0x0000, 0x0000 }, /* R12413 */ - { 0x0000, 0x0000, 0x0000 }, /* R12414 */ - { 0x0000, 0x0000, 0x0000 }, /* R12415 */ - { 0x0000, 0x0000, 0x0000 }, /* R12416 */ - { 0x0000, 0x0000, 0x0000 }, /* R12417 */ - { 0x0000, 0x0000, 0x0000 }, /* R12418 */ - { 0x0000, 0x0000, 0x0000 }, /* R12419 */ - { 0x0000, 0x0000, 0x0000 }, /* R12420 */ - { 0x0000, 0x0000, 0x0000 }, /* R12421 */ - { 0x0000, 0x0000, 0x0000 }, /* R12422 */ - { 0x0000, 0x0000, 0x0000 }, /* R12423 */ - { 0x0000, 0x0000, 0x0000 }, /* R12424 */ - { 0x0000, 0x0000, 0x0000 }, /* R12425 */ - { 0x0000, 0x0000, 0x0000 }, /* R12426 */ - { 0x0000, 0x0000, 0x0000 }, /* R12427 */ - { 0x0000, 0x0000, 0x0000 }, /* R12428 */ - { 0x0000, 0x0000, 0x0000 }, /* R12429 */ - { 0x0000, 0x0000, 0x0000 }, /* R12430 */ - { 0x0000, 0x0000, 0x0000 }, /* R12431 */ - { 0x0000, 0x0000, 0x0000 }, /* R12432 */ - { 0x0000, 0x0000, 0x0000 }, /* R12433 */ - { 0x0000, 0x0000, 0x0000 }, /* R12434 */ - { 0x0000, 0x0000, 0x0000 }, /* R12435 */ - { 0x0000, 0x0000, 0x0000 }, /* R12436 */ - { 0x0000, 0x0000, 0x0000 }, /* R12437 */ - { 0x0000, 0x0000, 0x0000 }, /* R12438 */ - { 0x0000, 0x0000, 0x0000 }, /* R12439 */ - { 0x0000, 0x0000, 0x0000 }, /* R12440 */ - { 0x0000, 0x0000, 0x0000 }, /* R12441 */ - { 0x0000, 0x0000, 0x0000 }, /* R12442 */ - { 0x0000, 0x0000, 0x0000 }, /* R12443 */ - { 0x0000, 0x0000, 0x0000 }, /* R12444 */ - { 0x0000, 0x0000, 0x0000 }, /* R12445 */ - { 0x0000, 0x0000, 0x0000 }, /* R12446 */ - { 0x0000, 0x0000, 0x0000 }, /* R12447 */ - { 0x0000, 0x0000, 0x0000 }, /* R12448 */ - { 0x0000, 0x0000, 0x0000 }, /* R12449 */ - { 0x0000, 0x0000, 0x0000 }, /* R12450 */ - { 0x0000, 0x0000, 0x0000 }, /* R12451 */ - { 0x0000, 0x0000, 0x0000 }, /* R12452 */ - { 0x0000, 0x0000, 0x0000 }, /* R12453 */ - { 0x0000, 0x0000, 0x0000 }, /* R12454 */ - { 0x0000, 0x0000, 0x0000 }, /* R12455 */ - { 0x0000, 0x0000, 0x0000 }, /* R12456 */ - { 0x0000, 0x0000, 0x0000 }, /* R12457 */ - { 0x0000, 0x0000, 0x0000 }, /* R12458 */ - { 0x0000, 0x0000, 0x0000 }, /* R12459 */ - { 0x0000, 0x0000, 0x0000 }, /* R12460 */ - { 0x0000, 0x0000, 0x0000 }, /* R12461 */ - { 0x0000, 0x0000, 0x0000 }, /* R12462 */ - { 0x0000, 0x0000, 0x0000 }, /* R12463 */ - { 0x0000, 0x0000, 0x0000 }, /* R12464 */ - { 0x0000, 0x0000, 0x0000 }, /* R12465 */ - { 0x0000, 0x0000, 0x0000 }, /* R12466 */ - { 0x0000, 0x0000, 0x0000 }, /* R12467 */ - { 0x0000, 0x0000, 0x0000 }, /* R12468 */ - { 0x0000, 0x0000, 0x0000 }, /* R12469 */ - { 0x0000, 0x0000, 0x0000 }, /* R12470 */ - { 0x0000, 0x0000, 0x0000 }, /* R12471 */ - { 0x0000, 0x0000, 0x0000 }, /* R12472 */ - { 0x0000, 0x0000, 0x0000 }, /* R12473 */ - { 0x0000, 0x0000, 0x0000 }, /* R12474 */ - { 0x0000, 0x0000, 0x0000 }, /* R12475 */ - { 0x0000, 0x0000, 0x0000 }, /* R12476 */ - { 0x0000, 0x0000, 0x0000 }, /* R12477 */ - { 0x0000, 0x0000, 0x0000 }, /* R12478 */ - { 0x0000, 0x0000, 0x0000 }, /* R12479 */ - { 0x0000, 0x0000, 0x0000 }, /* R12480 */ - { 0x0000, 0x0000, 0x0000 }, /* R12481 */ - { 0x0000, 0x0000, 0x0000 }, /* R12482 */ - { 0x0000, 0x0000, 0x0000 }, /* R12483 */ - { 0x0000, 0x0000, 0x0000 }, /* R12484 */ - { 0x0000, 0x0000, 0x0000 }, /* R12485 */ - { 0x0000, 0x0000, 0x0000 }, /* R12486 */ - { 0x0000, 0x0000, 0x0000 }, /* R12487 */ - { 0x0000, 0x0000, 0x0000 }, /* R12488 */ - { 0x0000, 0x0000, 0x0000 }, /* R12489 */ - { 0x0000, 0x0000, 0x0000 }, /* R12490 */ - { 0x0000, 0x0000, 0x0000 }, /* R12491 */ - { 0x0000, 0x0000, 0x0000 }, /* R12492 */ - { 0x0000, 0x0000, 0x0000 }, /* R12493 */ - { 0x0000, 0x0000, 0x0000 }, /* R12494 */ - { 0x0000, 0x0000, 0x0000 }, /* R12495 */ - { 0x0000, 0x0000, 0x0000 }, /* R12496 */ - { 0x0000, 0x0000, 0x0000 }, /* R12497 */ - { 0x0000, 0x0000, 0x0000 }, /* R12498 */ - { 0x0000, 0x0000, 0x0000 }, /* R12499 */ - { 0x0000, 0x0000, 0x0000 }, /* R12500 */ - { 0x0000, 0x0000, 0x0000 }, /* R12501 */ - { 0x0000, 0x0000, 0x0000 }, /* R12502 */ - { 0x0000, 0x0000, 0x0000 }, /* R12503 */ - { 0x0000, 0x0000, 0x0000 }, /* R12504 */ - { 0x0000, 0x0000, 0x0000 }, /* R12505 */ - { 0x0000, 0x0000, 0x0000 }, /* R12506 */ - { 0x0000, 0x0000, 0x0000 }, /* R12507 */ - { 0x0000, 0x0000, 0x0000 }, /* R12508 */ - { 0x0000, 0x0000, 0x0000 }, /* R12509 */ - { 0x0000, 0x0000, 0x0000 }, /* R12510 */ - { 0x0000, 0x0000, 0x0000 }, /* R12511 */ - { 0x0000, 0x0000, 0x0000 }, /* R12512 */ - { 0x0000, 0x0000, 0x0000 }, /* R12513 */ - { 0x0000, 0x0000, 0x0000 }, /* R12514 */ - { 0x0000, 0x0000, 0x0000 }, /* R12515 */ - { 0x0000, 0x0000, 0x0000 }, /* R12516 */ - { 0x0000, 0x0000, 0x0000 }, /* R12517 */ - { 0x0000, 0x0000, 0x0000 }, /* R12518 */ - { 0x0000, 0x0000, 0x0000 }, /* R12519 */ - { 0x0000, 0x0000, 0x0000 }, /* R12520 */ - { 0x0000, 0x0000, 0x0000 }, /* R12521 */ - { 0x0000, 0x0000, 0x0000 }, /* R12522 */ - { 0x0000, 0x0000, 0x0000 }, /* R12523 */ - { 0x0000, 0x0000, 0x0000 }, /* R12524 */ - { 0x0000, 0x0000, 0x0000 }, /* R12525 */ - { 0x0000, 0x0000, 0x0000 }, /* R12526 */ - { 0x0000, 0x0000, 0x0000 }, /* R12527 */ - { 0x0000, 0x0000, 0x0000 }, /* R12528 */ - { 0x0000, 0x0000, 0x0000 }, /* R12529 */ - { 0x0000, 0x0000, 0x0000 }, /* R12530 */ - { 0x0000, 0x0000, 0x0000 }, /* R12531 */ - { 0x0000, 0x0000, 0x0000 }, /* R12532 */ - { 0x0000, 0x0000, 0x0000 }, /* R12533 */ - { 0x0000, 0x0000, 0x0000 }, /* R12534 */ - { 0x0000, 0x0000, 0x0000 }, /* R12535 */ - { 0x0000, 0x0000, 0x0000 }, /* R12536 */ - { 0x0000, 0x0000, 0x0000 }, /* R12537 */ - { 0x0000, 0x0000, 0x0000 }, /* R12538 */ - { 0x0000, 0x0000, 0x0000 }, /* R12539 */ - { 0x0000, 0x0000, 0x0000 }, /* R12540 */ - { 0x0000, 0x0000, 0x0000 }, /* R12541 */ - { 0x0000, 0x0000, 0x0000 }, /* R12542 */ - { 0x0000, 0x0000, 0x0000 }, /* R12543 */ - { 0x0000, 0x0000, 0x0000 }, /* R12544 */ - { 0x0000, 0x0000, 0x0000 }, /* R12545 */ - { 0x0000, 0x0000, 0x0000 }, /* R12546 */ - { 0x0000, 0x0000, 0x0000 }, /* R12547 */ - { 0x0000, 0x0000, 0x0000 }, /* R12548 */ - { 0x0000, 0x0000, 0x0000 }, /* R12549 */ - { 0x0000, 0x0000, 0x0000 }, /* R12550 */ - { 0x0000, 0x0000, 0x0000 }, /* R12551 */ - { 0x0000, 0x0000, 0x0000 }, /* R12552 */ - { 0x0000, 0x0000, 0x0000 }, /* R12553 */ - { 0x0000, 0x0000, 0x0000 }, /* R12554 */ - { 0x0000, 0x0000, 0x0000 }, /* R12555 */ - { 0x0000, 0x0000, 0x0000 }, /* R12556 */ - { 0x0000, 0x0000, 0x0000 }, /* R12557 */ - { 0x0000, 0x0000, 0x0000 }, /* R12558 */ - { 0x0000, 0x0000, 0x0000 }, /* R12559 */ - { 0x0000, 0x0000, 0x0000 }, /* R12560 */ - { 0x0000, 0x0000, 0x0000 }, /* R12561 */ - { 0x0000, 0x0000, 0x0000 }, /* R12562 */ - { 0x0000, 0x0000, 0x0000 }, /* R12563 */ - { 0x0000, 0x0000, 0x0000 }, /* R12564 */ - { 0x0000, 0x0000, 0x0000 }, /* R12565 */ - { 0x0000, 0x0000, 0x0000 }, /* R12566 */ - { 0x0000, 0x0000, 0x0000 }, /* R12567 */ - { 0x0000, 0x0000, 0x0000 }, /* R12568 */ - { 0x0000, 0x0000, 0x0000 }, /* R12569 */ - { 0x0000, 0x0000, 0x0000 }, /* R12570 */ - { 0x0000, 0x0000, 0x0000 }, /* R12571 */ - { 0x0000, 0x0000, 0x0000 }, /* R12572 */ - { 0x0000, 0x0000, 0x0000 }, /* R12573 */ - { 0x0000, 0x0000, 0x0000 }, /* R12574 */ - { 0x0000, 0x0000, 0x0000 }, /* R12575 */ - { 0x0000, 0x0000, 0x0000 }, /* R12576 */ - { 0x0000, 0x0000, 0x0000 }, /* R12577 */ - { 0x0000, 0x0000, 0x0000 }, /* R12578 */ - { 0x0000, 0x0000, 0x0000 }, /* R12579 */ - { 0x0000, 0x0000, 0x0000 }, /* R12580 */ - { 0x0000, 0x0000, 0x0000 }, /* R12581 */ - { 0x0000, 0x0000, 0x0000 }, /* R12582 */ - { 0x0000, 0x0000, 0x0000 }, /* R12583 */ - { 0x0000, 0x0000, 0x0000 }, /* R12584 */ - { 0x0000, 0x0000, 0x0000 }, /* R12585 */ - { 0x0000, 0x0000, 0x0000 }, /* R12586 */ - { 0x0000, 0x0000, 0x0000 }, /* R12587 */ - { 0x0000, 0x0000, 0x0000 }, /* R12588 */ - { 0x0000, 0x0000, 0x0000 }, /* R12589 */ - { 0x0000, 0x0000, 0x0000 }, /* R12590 */ - { 0x0000, 0x0000, 0x0000 }, /* R12591 */ - { 0x0000, 0x0000, 0x0000 }, /* R12592 */ - { 0x0000, 0x0000, 0x0000 }, /* R12593 */ - { 0x0000, 0x0000, 0x0000 }, /* R12594 */ - { 0x0000, 0x0000, 0x0000 }, /* R12595 */ - { 0x0000, 0x0000, 0x0000 }, /* R12596 */ - { 0x0000, 0x0000, 0x0000 }, /* R12597 */ - { 0x0000, 0x0000, 0x0000 }, /* R12598 */ - { 0x0000, 0x0000, 0x0000 }, /* R12599 */ - { 0x0000, 0x0000, 0x0000 }, /* R12600 */ - { 0x0000, 0x0000, 0x0000 }, /* R12601 */ - { 0x0000, 0x0000, 0x0000 }, /* R12602 */ - { 0x0000, 0x0000, 0x0000 }, /* R12603 */ - { 0x0000, 0x0000, 0x0000 }, /* R12604 */ - { 0x0000, 0x0000, 0x0000 }, /* R12605 */ - { 0x0000, 0x0000, 0x0000 }, /* R12606 */ - { 0x0000, 0x0000, 0x0000 }, /* R12607 */ - { 0x0000, 0x0000, 0x0000 }, /* R12608 */ - { 0x0000, 0x0000, 0x0000 }, /* R12609 */ - { 0x0000, 0x0000, 0x0000 }, /* R12610 */ - { 0x0000, 0x0000, 0x0000 }, /* R12611 */ - { 0x0000, 0x0000, 0x0000 }, /* R12612 */ - { 0x0000, 0x0000, 0x0000 }, /* R12613 */ - { 0x0000, 0x0000, 0x0000 }, /* R12614 */ - { 0x0000, 0x0000, 0x0000 }, /* R12615 */ - { 0x0000, 0x0000, 0x0000 }, /* R12616 */ - { 0x0000, 0x0000, 0x0000 }, /* R12617 */ - { 0x0000, 0x0000, 0x0000 }, /* R12618 */ - { 0x0000, 0x0000, 0x0000 }, /* R12619 */ - { 0x0000, 0x0000, 0x0000 }, /* R12620 */ - { 0x0000, 0x0000, 0x0000 }, /* R12621 */ - { 0x0000, 0x0000, 0x0000 }, /* R12622 */ - { 0x0000, 0x0000, 0x0000 }, /* R12623 */ - { 0x0000, 0x0000, 0x0000 }, /* R12624 */ - { 0x0000, 0x0000, 0x0000 }, /* R12625 */ - { 0x0000, 0x0000, 0x0000 }, /* R12626 */ - { 0x0000, 0x0000, 0x0000 }, /* R12627 */ - { 0x0000, 0x0000, 0x0000 }, /* R12628 */ - { 0x0000, 0x0000, 0x0000 }, /* R12629 */ - { 0x0000, 0x0000, 0x0000 }, /* R12630 */ - { 0x0000, 0x0000, 0x0000 }, /* R12631 */ - { 0x0000, 0x0000, 0x0000 }, /* R12632 */ - { 0x0000, 0x0000, 0x0000 }, /* R12633 */ - { 0x0000, 0x0000, 0x0000 }, /* R12634 */ - { 0x0000, 0x0000, 0x0000 }, /* R12635 */ - { 0x0000, 0x0000, 0x0000 }, /* R12636 */ - { 0x0000, 0x0000, 0x0000 }, /* R12637 */ - { 0x0000, 0x0000, 0x0000 }, /* R12638 */ - { 0x0000, 0x0000, 0x0000 }, /* R12639 */ - { 0x0000, 0x0000, 0x0000 }, /* R12640 */ - { 0x0000, 0x0000, 0x0000 }, /* R12641 */ - { 0x0000, 0x0000, 0x0000 }, /* R12642 */ - { 0x0000, 0x0000, 0x0000 }, /* R12643 */ - { 0x0000, 0x0000, 0x0000 }, /* R12644 */ - { 0x0000, 0x0000, 0x0000 }, /* R12645 */ - { 0x0000, 0x0000, 0x0000 }, /* R12646 */ - { 0x0000, 0x0000, 0x0000 }, /* R12647 */ - { 0x0000, 0x0000, 0x0000 }, /* R12648 */ - { 0x0000, 0x0000, 0x0000 }, /* R12649 */ - { 0x0000, 0x0000, 0x0000 }, /* R12650 */ - { 0x0000, 0x0000, 0x0000 }, /* R12651 */ - { 0x0000, 0x0000, 0x0000 }, /* R12652 */ - { 0x0000, 0x0000, 0x0000 }, /* R12653 */ - { 0x0000, 0x0000, 0x0000 }, /* R12654 */ - { 0x0000, 0x0000, 0x0000 }, /* R12655 */ - { 0x0000, 0x0000, 0x0000 }, /* R12656 */ - { 0x0000, 0x0000, 0x0000 }, /* R12657 */ - { 0x0000, 0x0000, 0x0000 }, /* R12658 */ - { 0x0000, 0x0000, 0x0000 }, /* R12659 */ - { 0x0000, 0x0000, 0x0000 }, /* R12660 */ - { 0x0000, 0x0000, 0x0000 }, /* R12661 */ - { 0x0000, 0x0000, 0x0000 }, /* R12662 */ - { 0x0000, 0x0000, 0x0000 }, /* R12663 */ - { 0x0000, 0x0000, 0x0000 }, /* R12664 */ - { 0x0000, 0x0000, 0x0000 }, /* R12665 */ - { 0x0000, 0x0000, 0x0000 }, /* R12666 */ - { 0x0000, 0x0000, 0x0000 }, /* R12667 */ - { 0x0000, 0x0000, 0x0000 }, /* R12668 */ - { 0x0000, 0x0000, 0x0000 }, /* R12669 */ - { 0x0000, 0x0000, 0x0000 }, /* R12670 */ - { 0x0000, 0x0000, 0x0000 }, /* R12671 */ - { 0x0000, 0x0000, 0x0000 }, /* R12672 */ - { 0x0000, 0x0000, 0x0000 }, /* R12673 */ - { 0x0000, 0x0000, 0x0000 }, /* R12674 */ - { 0x0000, 0x0000, 0x0000 }, /* R12675 */ - { 0x0000, 0x0000, 0x0000 }, /* R12676 */ - { 0x0000, 0x0000, 0x0000 }, /* R12677 */ - { 0x0000, 0x0000, 0x0000 }, /* R12678 */ - { 0x0000, 0x0000, 0x0000 }, /* R12679 */ - { 0x0000, 0x0000, 0x0000 }, /* R12680 */ - { 0x0000, 0x0000, 0x0000 }, /* R12681 */ - { 0x0000, 0x0000, 0x0000 }, /* R12682 */ - { 0x0000, 0x0000, 0x0000 }, /* R12683 */ - { 0x0000, 0x0000, 0x0000 }, /* R12684 */ - { 0x0000, 0x0000, 0x0000 }, /* R12685 */ - { 0x0000, 0x0000, 0x0000 }, /* R12686 */ - { 0x0000, 0x0000, 0x0000 }, /* R12687 */ - { 0x0000, 0x0000, 0x0000 }, /* R12688 */ - { 0x0000, 0x0000, 0x0000 }, /* R12689 */ - { 0x0000, 0x0000, 0x0000 }, /* R12690 */ - { 0x0000, 0x0000, 0x0000 }, /* R12691 */ - { 0x0000, 0x0000, 0x0000 }, /* R12692 */ - { 0x0000, 0x0000, 0x0000 }, /* R12693 */ - { 0x0000, 0x0000, 0x0000 }, /* R12694 */ - { 0x0000, 0x0000, 0x0000 }, /* R12695 */ - { 0x0000, 0x0000, 0x0000 }, /* R12696 */ - { 0x0000, 0x0000, 0x0000 }, /* R12697 */ - { 0x0000, 0x0000, 0x0000 }, /* R12698 */ - { 0x0000, 0x0000, 0x0000 }, /* R12699 */ - { 0x0000, 0x0000, 0x0000 }, /* R12700 */ - { 0x0000, 0x0000, 0x0000 }, /* R12701 */ - { 0x0000, 0x0000, 0x0000 }, /* R12702 */ - { 0x0000, 0x0000, 0x0000 }, /* R12703 */ - { 0x0000, 0x0000, 0x0000 }, /* R12704 */ - { 0x0000, 0x0000, 0x0000 }, /* R12705 */ - { 0x0000, 0x0000, 0x0000 }, /* R12706 */ - { 0x0000, 0x0000, 0x0000 }, /* R12707 */ - { 0x0000, 0x0000, 0x0000 }, /* R12708 */ - { 0x0000, 0x0000, 0x0000 }, /* R12709 */ - { 0x0000, 0x0000, 0x0000 }, /* R12710 */ - { 0x0000, 0x0000, 0x0000 }, /* R12711 */ - { 0x0000, 0x0000, 0x0000 }, /* R12712 */ - { 0x0000, 0x0000, 0x0000 }, /* R12713 */ - { 0x0000, 0x0000, 0x0000 }, /* R12714 */ - { 0x0000, 0x0000, 0x0000 }, /* R12715 */ - { 0x0000, 0x0000, 0x0000 }, /* R12716 */ - { 0x0000, 0x0000, 0x0000 }, /* R12717 */ - { 0x0000, 0x0000, 0x0000 }, /* R12718 */ - { 0x0000, 0x0000, 0x0000 }, /* R12719 */ - { 0x0000, 0x0000, 0x0000 }, /* R12720 */ - { 0x0000, 0x0000, 0x0000 }, /* R12721 */ - { 0x0000, 0x0000, 0x0000 }, /* R12722 */ - { 0x0000, 0x0000, 0x0000 }, /* R12723 */ - { 0x0000, 0x0000, 0x0000 }, /* R12724 */ - { 0x0000, 0x0000, 0x0000 }, /* R12725 */ - { 0x0000, 0x0000, 0x0000 }, /* R12726 */ - { 0x0000, 0x0000, 0x0000 }, /* R12727 */ - { 0x0000, 0x0000, 0x0000 }, /* R12728 */ - { 0x0000, 0x0000, 0x0000 }, /* R12729 */ - { 0x0000, 0x0000, 0x0000 }, /* R12730 */ - { 0x0000, 0x0000, 0x0000 }, /* R12731 */ - { 0x0000, 0x0000, 0x0000 }, /* R12732 */ - { 0x0000, 0x0000, 0x0000 }, /* R12733 */ - { 0x0000, 0x0000, 0x0000 }, /* R12734 */ - { 0x0000, 0x0000, 0x0000 }, /* R12735 */ - { 0x0000, 0x0000, 0x0000 }, /* R12736 */ - { 0x0000, 0x0000, 0x0000 }, /* R12737 */ - { 0x0000, 0x0000, 0x0000 }, /* R12738 */ - { 0x0000, 0x0000, 0x0000 }, /* R12739 */ - { 0x0000, 0x0000, 0x0000 }, /* R12740 */ - { 0x0000, 0x0000, 0x0000 }, /* R12741 */ - { 0x0000, 0x0000, 0x0000 }, /* R12742 */ - { 0x0000, 0x0000, 0x0000 }, /* R12743 */ - { 0x0000, 0x0000, 0x0000 }, /* R12744 */ - { 0x0000, 0x0000, 0x0000 }, /* R12745 */ - { 0x0000, 0x0000, 0x0000 }, /* R12746 */ - { 0x0000, 0x0000, 0x0000 }, /* R12747 */ - { 0x0000, 0x0000, 0x0000 }, /* R12748 */ - { 0x0000, 0x0000, 0x0000 }, /* R12749 */ - { 0x0000, 0x0000, 0x0000 }, /* R12750 */ - { 0x0000, 0x0000, 0x0000 }, /* R12751 */ - { 0x0000, 0x0000, 0x0000 }, /* R12752 */ - { 0x0000, 0x0000, 0x0000 }, /* R12753 */ - { 0x0000, 0x0000, 0x0000 }, /* R12754 */ - { 0x0000, 0x0000, 0x0000 }, /* R12755 */ - { 0x0000, 0x0000, 0x0000 }, /* R12756 */ - { 0x0000, 0x0000, 0x0000 }, /* R12757 */ - { 0x0000, 0x0000, 0x0000 }, /* R12758 */ - { 0x0000, 0x0000, 0x0000 }, /* R12759 */ - { 0x0000, 0x0000, 0x0000 }, /* R12760 */ - { 0x0000, 0x0000, 0x0000 }, /* R12761 */ - { 0x0000, 0x0000, 0x0000 }, /* R12762 */ - { 0x0000, 0x0000, 0x0000 }, /* R12763 */ - { 0x0000, 0x0000, 0x0000 }, /* R12764 */ - { 0x0000, 0x0000, 0x0000 }, /* R12765 */ - { 0x0000, 0x0000, 0x0000 }, /* R12766 */ - { 0x0000, 0x0000, 0x0000 }, /* R12767 */ - { 0x0000, 0x0000, 0x0000 }, /* R12768 */ - { 0x0000, 0x0000, 0x0000 }, /* R12769 */ - { 0x0000, 0x0000, 0x0000 }, /* R12770 */ - { 0x0000, 0x0000, 0x0000 }, /* R12771 */ - { 0x0000, 0x0000, 0x0000 }, /* R12772 */ - { 0x0000, 0x0000, 0x0000 }, /* R12773 */ - { 0x0000, 0x0000, 0x0000 }, /* R12774 */ - { 0x0000, 0x0000, 0x0000 }, /* R12775 */ - { 0x0000, 0x0000, 0x0000 }, /* R12776 */ - { 0x0000, 0x0000, 0x0000 }, /* R12777 */ - { 0x0000, 0x0000, 0x0000 }, /* R12778 */ - { 0x0000, 0x0000, 0x0000 }, /* R12779 */ - { 0x0000, 0x0000, 0x0000 }, /* R12780 */ - { 0x0000, 0x0000, 0x0000 }, /* R12781 */ - { 0x0000, 0x0000, 0x0000 }, /* R12782 */ - { 0x0000, 0x0000, 0x0000 }, /* R12783 */ - { 0x0000, 0x0000, 0x0000 }, /* R12784 */ - { 0x0000, 0x0000, 0x0000 }, /* R12785 */ - { 0x0000, 0x0000, 0x0000 }, /* R12786 */ - { 0x0000, 0x0000, 0x0000 }, /* R12787 */ - { 0x0000, 0x0000, 0x0000 }, /* R12788 */ - { 0x0000, 0x0000, 0x0000 }, /* R12789 */ - { 0x0000, 0x0000, 0x0000 }, /* R12790 */ - { 0x0000, 0x0000, 0x0000 }, /* R12791 */ - { 0x0000, 0x0000, 0x0000 }, /* R12792 */ - { 0x0000, 0x0000, 0x0000 }, /* R12793 */ - { 0x0000, 0x0000, 0x0000 }, /* R12794 */ - { 0x0000, 0x0000, 0x0000 }, /* R12795 */ - { 0x0000, 0x0000, 0x0000 }, /* R12796 */ - { 0x0000, 0x0000, 0x0000 }, /* R12797 */ - { 0x0000, 0x0000, 0x0000 }, /* R12798 */ - { 0x0000, 0x0000, 0x0000 }, /* R12799 */ - { 0x0000, 0x0000, 0x0000 }, /* R12800 */ - { 0x0000, 0x0000, 0x0000 }, /* R12801 */ - { 0x0000, 0x0000, 0x0000 }, /* R12802 */ - { 0x0000, 0x0000, 0x0000 }, /* R12803 */ - { 0x0000, 0x0000, 0x0000 }, /* R12804 */ - { 0x0000, 0x0000, 0x0000 }, /* R12805 */ - { 0x0000, 0x0000, 0x0000 }, /* R12806 */ - { 0x0000, 0x0000, 0x0000 }, /* R12807 */ - { 0x0000, 0x0000, 0x0000 }, /* R12808 */ - { 0x0000, 0x0000, 0x0000 }, /* R12809 */ - { 0x0000, 0x0000, 0x0000 }, /* R12810 */ - { 0x0000, 0x0000, 0x0000 }, /* R12811 */ - { 0x0000, 0x0000, 0x0000 }, /* R12812 */ - { 0x0000, 0x0000, 0x0000 }, /* R12813 */ - { 0x0000, 0x0000, 0x0000 }, /* R12814 */ - { 0x0000, 0x0000, 0x0000 }, /* R12815 */ - { 0x0000, 0x0000, 0x0000 }, /* R12816 */ - { 0x0000, 0x0000, 0x0000 }, /* R12817 */ - { 0x0000, 0x0000, 0x0000 }, /* R12818 */ - { 0x0000, 0x0000, 0x0000 }, /* R12819 */ - { 0x0000, 0x0000, 0x0000 }, /* R12820 */ - { 0x0000, 0x0000, 0x0000 }, /* R12821 */ - { 0x0000, 0x0000, 0x0000 }, /* R12822 */ - { 0x0000, 0x0000, 0x0000 }, /* R12823 */ - { 0x0000, 0x0000, 0x0000 }, /* R12824 */ - { 0x0000, 0x0000, 0x0000 }, /* R12825 */ - { 0x0000, 0x0000, 0x0000 }, /* R12826 */ - { 0x0000, 0x0000, 0x0000 }, /* R12827 */ - { 0x0000, 0x0000, 0x0000 }, /* R12828 */ - { 0x0000, 0x0000, 0x0000 }, /* R12829 */ - { 0x0000, 0x0000, 0x0000 }, /* R12830 */ - { 0x0000, 0x0000, 0x0000 }, /* R12831 */ - { 0x0000, 0x0000, 0x0000 }, /* R12832 */ - { 0x0000, 0x0000, 0x0000 }, /* R12833 */ - { 0x0000, 0x0000, 0x0000 }, /* R12834 */ - { 0x0000, 0x0000, 0x0000 }, /* R12835 */ - { 0x0000, 0x0000, 0x0000 }, /* R12836 */ - { 0x0000, 0x0000, 0x0000 }, /* R12837 */ - { 0x0000, 0x0000, 0x0000 }, /* R12838 */ - { 0x0000, 0x0000, 0x0000 }, /* R12839 */ - { 0x0000, 0x0000, 0x0000 }, /* R12840 */ - { 0x0000, 0x0000, 0x0000 }, /* R12841 */ - { 0x0000, 0x0000, 0x0000 }, /* R12842 */ - { 0x0000, 0x0000, 0x0000 }, /* R12843 */ - { 0x0000, 0x0000, 0x0000 }, /* R12844 */ - { 0x0000, 0x0000, 0x0000 }, /* R12845 */ - { 0x0000, 0x0000, 0x0000 }, /* R12846 */ - { 0x0000, 0x0000, 0x0000 }, /* R12847 */ - { 0x0000, 0x0000, 0x0000 }, /* R12848 */ - { 0x0000, 0x0000, 0x0000 }, /* R12849 */ - { 0x0000, 0x0000, 0x0000 }, /* R12850 */ - { 0x0000, 0x0000, 0x0000 }, /* R12851 */ - { 0x0000, 0x0000, 0x0000 }, /* R12852 */ - { 0x0000, 0x0000, 0x0000 }, /* R12853 */ - { 0x0000, 0x0000, 0x0000 }, /* R12854 */ - { 0x0000, 0x0000, 0x0000 }, /* R12855 */ - { 0x0000, 0x0000, 0x0000 }, /* R12856 */ - { 0x0000, 0x0000, 0x0000 }, /* R12857 */ - { 0x0000, 0x0000, 0x0000 }, /* R12858 */ - { 0x0000, 0x0000, 0x0000 }, /* R12859 */ - { 0x0000, 0x0000, 0x0000 }, /* R12860 */ - { 0x0000, 0x0000, 0x0000 }, /* R12861 */ - { 0x0000, 0x0000, 0x0000 }, /* R12862 */ - { 0x0000, 0x0000, 0x0000 }, /* R12863 */ - { 0x0000, 0x0000, 0x0000 }, /* R12864 */ - { 0x0000, 0x0000, 0x0000 }, /* R12865 */ - { 0x0000, 0x0000, 0x0000 }, /* R12866 */ - { 0x0000, 0x0000, 0x0000 }, /* R12867 */ - { 0x0000, 0x0000, 0x0000 }, /* R12868 */ - { 0x0000, 0x0000, 0x0000 }, /* R12869 */ - { 0x0000, 0x0000, 0x0000 }, /* R12870 */ - { 0x0000, 0x0000, 0x0000 }, /* R12871 */ - { 0x0000, 0x0000, 0x0000 }, /* R12872 */ - { 0x0000, 0x0000, 0x0000 }, /* R12873 */ - { 0x0000, 0x0000, 0x0000 }, /* R12874 */ - { 0x0000, 0x0000, 0x0000 }, /* R12875 */ - { 0x0000, 0x0000, 0x0000 }, /* R12876 */ - { 0x0000, 0x0000, 0x0000 }, /* R12877 */ - { 0x0000, 0x0000, 0x0000 }, /* R12878 */ - { 0x0000, 0x0000, 0x0000 }, /* R12879 */ - { 0x0000, 0x0000, 0x0000 }, /* R12880 */ - { 0x0000, 0x0000, 0x0000 }, /* R12881 */ - { 0x0000, 0x0000, 0x0000 }, /* R12882 */ - { 0x0000, 0x0000, 0x0000 }, /* R12883 */ - { 0x0000, 0x0000, 0x0000 }, /* R12884 */ - { 0x0000, 0x0000, 0x0000 }, /* R12885 */ - { 0x0000, 0x0000, 0x0000 }, /* R12886 */ - { 0x0000, 0x0000, 0x0000 }, /* R12887 */ - { 0x0000, 0x0000, 0x0000 }, /* R12888 */ - { 0x0000, 0x0000, 0x0000 }, /* R12889 */ - { 0x0000, 0x0000, 0x0000 }, /* R12890 */ - { 0x0000, 0x0000, 0x0000 }, /* R12891 */ - { 0x0000, 0x0000, 0x0000 }, /* R12892 */ - { 0x0000, 0x0000, 0x0000 }, /* R12893 */ - { 0x0000, 0x0000, 0x0000 }, /* R12894 */ - { 0x0000, 0x0000, 0x0000 }, /* R12895 */ - { 0x0000, 0x0000, 0x0000 }, /* R12896 */ - { 0x0000, 0x0000, 0x0000 }, /* R12897 */ - { 0x0000, 0x0000, 0x0000 }, /* R12898 */ - { 0x0000, 0x0000, 0x0000 }, /* R12899 */ - { 0x0000, 0x0000, 0x0000 }, /* R12900 */ - { 0x0000, 0x0000, 0x0000 }, /* R12901 */ - { 0x0000, 0x0000, 0x0000 }, /* R12902 */ - { 0x0000, 0x0000, 0x0000 }, /* R12903 */ - { 0x0000, 0x0000, 0x0000 }, /* R12904 */ - { 0x0000, 0x0000, 0x0000 }, /* R12905 */ - { 0x0000, 0x0000, 0x0000 }, /* R12906 */ - { 0x0000, 0x0000, 0x0000 }, /* R12907 */ - { 0x0000, 0x0000, 0x0000 }, /* R12908 */ - { 0x0000, 0x0000, 0x0000 }, /* R12909 */ - { 0x0000, 0x0000, 0x0000 }, /* R12910 */ - { 0x0000, 0x0000, 0x0000 }, /* R12911 */ - { 0x0000, 0x0000, 0x0000 }, /* R12912 */ - { 0x0000, 0x0000, 0x0000 }, /* R12913 */ - { 0x0000, 0x0000, 0x0000 }, /* R12914 */ - { 0x0000, 0x0000, 0x0000 }, /* R12915 */ - { 0x0000, 0x0000, 0x0000 }, /* R12916 */ - { 0x0000, 0x0000, 0x0000 }, /* R12917 */ - { 0x0000, 0x0000, 0x0000 }, /* R12918 */ - { 0x0000, 0x0000, 0x0000 }, /* R12919 */ - { 0x0000, 0x0000, 0x0000 }, /* R12920 */ - { 0x0000, 0x0000, 0x0000 }, /* R12921 */ - { 0x0000, 0x0000, 0x0000 }, /* R12922 */ - { 0x0000, 0x0000, 0x0000 }, /* R12923 */ - { 0x0000, 0x0000, 0x0000 }, /* R12924 */ - { 0x0000, 0x0000, 0x0000 }, /* R12925 */ - { 0x0000, 0x0000, 0x0000 }, /* R12926 */ - { 0x0000, 0x0000, 0x0000 }, /* R12927 */ - { 0x0000, 0x0000, 0x0000 }, /* R12928 */ - { 0x0000, 0x0000, 0x0000 }, /* R12929 */ - { 0x0000, 0x0000, 0x0000 }, /* R12930 */ - { 0x0000, 0x0000, 0x0000 }, /* R12931 */ - { 0x0000, 0x0000, 0x0000 }, /* R12932 */ - { 0x0000, 0x0000, 0x0000 }, /* R12933 */ - { 0x0000, 0x0000, 0x0000 }, /* R12934 */ - { 0x0000, 0x0000, 0x0000 }, /* R12935 */ - { 0x0000, 0x0000, 0x0000 }, /* R12936 */ - { 0x0000, 0x0000, 0x0000 }, /* R12937 */ - { 0x0000, 0x0000, 0x0000 }, /* R12938 */ - { 0x0000, 0x0000, 0x0000 }, /* R12939 */ - { 0x0000, 0x0000, 0x0000 }, /* R12940 */ - { 0x0000, 0x0000, 0x0000 }, /* R12941 */ - { 0x0000, 0x0000, 0x0000 }, /* R12942 */ - { 0x0000, 0x0000, 0x0000 }, /* R12943 */ - { 0x0000, 0x0000, 0x0000 }, /* R12944 */ - { 0x0000, 0x0000, 0x0000 }, /* R12945 */ - { 0x0000, 0x0000, 0x0000 }, /* R12946 */ - { 0x0000, 0x0000, 0x0000 }, /* R12947 */ - { 0x0000, 0x0000, 0x0000 }, /* R12948 */ - { 0x0000, 0x0000, 0x0000 }, /* R12949 */ - { 0x0000, 0x0000, 0x0000 }, /* R12950 */ - { 0x0000, 0x0000, 0x0000 }, /* R12951 */ - { 0x0000, 0x0000, 0x0000 }, /* R12952 */ - { 0x0000, 0x0000, 0x0000 }, /* R12953 */ - { 0x0000, 0x0000, 0x0000 }, /* R12954 */ - { 0x0000, 0x0000, 0x0000 }, /* R12955 */ - { 0x0000, 0x0000, 0x0000 }, /* R12956 */ - { 0x0000, 0x0000, 0x0000 }, /* R12957 */ - { 0x0000, 0x0000, 0x0000 }, /* R12958 */ - { 0x0000, 0x0000, 0x0000 }, /* R12959 */ - { 0x0000, 0x0000, 0x0000 }, /* R12960 */ - { 0x0000, 0x0000, 0x0000 }, /* R12961 */ - { 0x0000, 0x0000, 0x0000 }, /* R12962 */ - { 0x0000, 0x0000, 0x0000 }, /* R12963 */ - { 0x0000, 0x0000, 0x0000 }, /* R12964 */ - { 0x0000, 0x0000, 0x0000 }, /* R12965 */ - { 0x0000, 0x0000, 0x0000 }, /* R12966 */ - { 0x0000, 0x0000, 0x0000 }, /* R12967 */ - { 0x0000, 0x0000, 0x0000 }, /* R12968 */ - { 0x0000, 0x0000, 0x0000 }, /* R12969 */ - { 0x0000, 0x0000, 0x0000 }, /* R12970 */ - { 0x0000, 0x0000, 0x0000 }, /* R12971 */ - { 0x0000, 0x0000, 0x0000 }, /* R12972 */ - { 0x0000, 0x0000, 0x0000 }, /* R12973 */ - { 0x0000, 0x0000, 0x0000 }, /* R12974 */ - { 0x0000, 0x0000, 0x0000 }, /* R12975 */ - { 0x0000, 0x0000, 0x0000 }, /* R12976 */ - { 0x0000, 0x0000, 0x0000 }, /* R12977 */ - { 0x0000, 0x0000, 0x0000 }, /* R12978 */ - { 0x0000, 0x0000, 0x0000 }, /* R12979 */ - { 0x0000, 0x0000, 0x0000 }, /* R12980 */ - { 0x0000, 0x0000, 0x0000 }, /* R12981 */ - { 0x0000, 0x0000, 0x0000 }, /* R12982 */ - { 0x0000, 0x0000, 0x0000 }, /* R12983 */ - { 0x0000, 0x0000, 0x0000 }, /* R12984 */ - { 0x0000, 0x0000, 0x0000 }, /* R12985 */ - { 0x0000, 0x0000, 0x0000 }, /* R12986 */ - { 0x0000, 0x0000, 0x0000 }, /* R12987 */ - { 0x0000, 0x0000, 0x0000 }, /* R12988 */ - { 0x0000, 0x0000, 0x0000 }, /* R12989 */ - { 0x0000, 0x0000, 0x0000 }, /* R12990 */ - { 0x0000, 0x0000, 0x0000 }, /* R12991 */ - { 0x0000, 0x0000, 0x0000 }, /* R12992 */ - { 0x0000, 0x0000, 0x0000 }, /* R12993 */ - { 0x0000, 0x0000, 0x0000 }, /* R12994 */ - { 0x0000, 0x0000, 0x0000 }, /* R12995 */ - { 0x0000, 0x0000, 0x0000 }, /* R12996 */ - { 0x0000, 0x0000, 0x0000 }, /* R12997 */ - { 0x0000, 0x0000, 0x0000 }, /* R12998 */ - { 0x0000, 0x0000, 0x0000 }, /* R12999 */ - { 0x0000, 0x0000, 0x0000 }, /* R13000 */ - { 0x0000, 0x0000, 0x0000 }, /* R13001 */ - { 0x0000, 0x0000, 0x0000 }, /* R13002 */ - { 0x0000, 0x0000, 0x0000 }, /* R13003 */ - { 0x0000, 0x0000, 0x0000 }, /* R13004 */ - { 0x0000, 0x0000, 0x0000 }, /* R13005 */ - { 0x0000, 0x0000, 0x0000 }, /* R13006 */ - { 0x0000, 0x0000, 0x0000 }, /* R13007 */ - { 0x0000, 0x0000, 0x0000 }, /* R13008 */ - { 0x0000, 0x0000, 0x0000 }, /* R13009 */ - { 0x0000, 0x0000, 0x0000 }, /* R13010 */ - { 0x0000, 0x0000, 0x0000 }, /* R13011 */ - { 0x0000, 0x0000, 0x0000 }, /* R13012 */ - { 0x0000, 0x0000, 0x0000 }, /* R13013 */ - { 0x0000, 0x0000, 0x0000 }, /* R13014 */ - { 0x0000, 0x0000, 0x0000 }, /* R13015 */ - { 0x0000, 0x0000, 0x0000 }, /* R13016 */ - { 0x0000, 0x0000, 0x0000 }, /* R13017 */ - { 0x0000, 0x0000, 0x0000 }, /* R13018 */ - { 0x0000, 0x0000, 0x0000 }, /* R13019 */ - { 0x0000, 0x0000, 0x0000 }, /* R13020 */ - { 0x0000, 0x0000, 0x0000 }, /* R13021 */ - { 0x0000, 0x0000, 0x0000 }, /* R13022 */ - { 0x0000, 0x0000, 0x0000 }, /* R13023 */ - { 0x0000, 0x0000, 0x0000 }, /* R13024 */ - { 0x0000, 0x0000, 0x0000 }, /* R13025 */ - { 0x0000, 0x0000, 0x0000 }, /* R13026 */ - { 0x0000, 0x0000, 0x0000 }, /* R13027 */ - { 0x0000, 0x0000, 0x0000 }, /* R13028 */ - { 0x0000, 0x0000, 0x0000 }, /* R13029 */ - { 0x0000, 0x0000, 0x0000 }, /* R13030 */ - { 0x0000, 0x0000, 0x0000 }, /* R13031 */ - { 0x0000, 0x0000, 0x0000 }, /* R13032 */ - { 0x0000, 0x0000, 0x0000 }, /* R13033 */ - { 0x0000, 0x0000, 0x0000 }, /* R13034 */ - { 0x0000, 0x0000, 0x0000 }, /* R13035 */ - { 0x0000, 0x0000, 0x0000 }, /* R13036 */ - { 0x0000, 0x0000, 0x0000 }, /* R13037 */ - { 0x0000, 0x0000, 0x0000 }, /* R13038 */ - { 0x0000, 0x0000, 0x0000 }, /* R13039 */ - { 0x0000, 0x0000, 0x0000 }, /* R13040 */ - { 0x0000, 0x0000, 0x0000 }, /* R13041 */ - { 0x0000, 0x0000, 0x0000 }, /* R13042 */ - { 0x0000, 0x0000, 0x0000 }, /* R13043 */ - { 0x0000, 0x0000, 0x0000 }, /* R13044 */ - { 0x0000, 0x0000, 0x0000 }, /* R13045 */ - { 0x0000, 0x0000, 0x0000 }, /* R13046 */ - { 0x0000, 0x0000, 0x0000 }, /* R13047 */ - { 0x0000, 0x0000, 0x0000 }, /* R13048 */ - { 0x0000, 0x0000, 0x0000 }, /* R13049 */ - { 0x0000, 0x0000, 0x0000 }, /* R13050 */ - { 0x0000, 0x0000, 0x0000 }, /* R13051 */ - { 0x0000, 0x0000, 0x0000 }, /* R13052 */ - { 0x0000, 0x0000, 0x0000 }, /* R13053 */ - { 0x0000, 0x0000, 0x0000 }, /* R13054 */ - { 0x0000, 0x0000, 0x0000 }, /* R13055 */ - { 0x0000, 0x0000, 0x0000 }, /* R13056 */ - { 0x0000, 0x0000, 0x0000 }, /* R13057 */ - { 0x0000, 0x0000, 0x0000 }, /* R13058 */ - { 0x0000, 0x0000, 0x0000 }, /* R13059 */ - { 0x0000, 0x0000, 0x0000 }, /* R13060 */ - { 0x0000, 0x0000, 0x0000 }, /* R13061 */ - { 0x0000, 0x0000, 0x0000 }, /* R13062 */ - { 0x0000, 0x0000, 0x0000 }, /* R13063 */ - { 0x0000, 0x0000, 0x0000 }, /* R13064 */ - { 0x0000, 0x0000, 0x0000 }, /* R13065 */ - { 0x0000, 0x0000, 0x0000 }, /* R13066 */ - { 0x0000, 0x0000, 0x0000 }, /* R13067 */ - { 0x0000, 0x0000, 0x0000 }, /* R13068 */ - { 0x0000, 0x0000, 0x0000 }, /* R13069 */ - { 0x0000, 0x0000, 0x0000 }, /* R13070 */ - { 0x0000, 0x0000, 0x0000 }, /* R13071 */ - { 0x0000, 0x0000, 0x0000 }, /* R13072 */ - { 0x0000, 0x0000, 0x0000 }, /* R13073 */ - { 0x0000, 0x0000, 0x0000 }, /* R13074 */ - { 0x0000, 0x0000, 0x0000 }, /* R13075 */ - { 0x0000, 0x0000, 0x0000 }, /* R13076 */ - { 0x0000, 0x0000, 0x0000 }, /* R13077 */ - { 0x0000, 0x0000, 0x0000 }, /* R13078 */ - { 0x0000, 0x0000, 0x0000 }, /* R13079 */ - { 0x0000, 0x0000, 0x0000 }, /* R13080 */ - { 0x0000, 0x0000, 0x0000 }, /* R13081 */ - { 0x0000, 0x0000, 0x0000 }, /* R13082 */ - { 0x0000, 0x0000, 0x0000 }, /* R13083 */ - { 0x0000, 0x0000, 0x0000 }, /* R13084 */ - { 0x0000, 0x0000, 0x0000 }, /* R13085 */ - { 0x0000, 0x0000, 0x0000 }, /* R13086 */ - { 0x0000, 0x0000, 0x0000 }, /* R13087 */ - { 0x0000, 0x0000, 0x0000 }, /* R13088 */ - { 0x0000, 0x0000, 0x0000 }, /* R13089 */ - { 0x0000, 0x0000, 0x0000 }, /* R13090 */ - { 0x0000, 0x0000, 0x0000 }, /* R13091 */ - { 0x0000, 0x0000, 0x0000 }, /* R13092 */ - { 0x0000, 0x0000, 0x0000 }, /* R13093 */ - { 0x0000, 0x0000, 0x0000 }, /* R13094 */ - { 0x0000, 0x0000, 0x0000 }, /* R13095 */ - { 0x0000, 0x0000, 0x0000 }, /* R13096 */ - { 0x0000, 0x0000, 0x0000 }, /* R13097 */ - { 0x0000, 0x0000, 0x0000 }, /* R13098 */ - { 0x0000, 0x0000, 0x0000 }, /* R13099 */ - { 0x0000, 0x0000, 0x0000 }, /* R13100 */ - { 0x0000, 0x0000, 0x0000 }, /* R13101 */ - { 0x0000, 0x0000, 0x0000 }, /* R13102 */ - { 0x0000, 0x0000, 0x0000 }, /* R13103 */ - { 0x0000, 0x0000, 0x0000 }, /* R13104 */ - { 0x0000, 0x0000, 0x0000 }, /* R13105 */ - { 0x0000, 0x0000, 0x0000 }, /* R13106 */ - { 0x0000, 0x0000, 0x0000 }, /* R13107 */ - { 0x0000, 0x0000, 0x0000 }, /* R13108 */ - { 0x0000, 0x0000, 0x0000 }, /* R13109 */ - { 0x0000, 0x0000, 0x0000 }, /* R13110 */ - { 0x0000, 0x0000, 0x0000 }, /* R13111 */ - { 0x0000, 0x0000, 0x0000 }, /* R13112 */ - { 0x0000, 0x0000, 0x0000 }, /* R13113 */ - { 0x0000, 0x0000, 0x0000 }, /* R13114 */ - { 0x0000, 0x0000, 0x0000 }, /* R13115 */ - { 0x0000, 0x0000, 0x0000 }, /* R13116 */ - { 0x0000, 0x0000, 0x0000 }, /* R13117 */ - { 0x0000, 0x0000, 0x0000 }, /* R13118 */ - { 0x0000, 0x0000, 0x0000 }, /* R13119 */ - { 0x0000, 0x0000, 0x0000 }, /* R13120 */ - { 0x0000, 0x0000, 0x0000 }, /* R13121 */ - { 0x0000, 0x0000, 0x0000 }, /* R13122 */ - { 0x0000, 0x0000, 0x0000 }, /* R13123 */ - { 0x0000, 0x0000, 0x0000 }, /* R13124 */ - { 0x0000, 0x0000, 0x0000 }, /* R13125 */ - { 0x0000, 0x0000, 0x0000 }, /* R13126 */ - { 0x0000, 0x0000, 0x0000 }, /* R13127 */ - { 0x0000, 0x0000, 0x0000 }, /* R13128 */ - { 0x0000, 0x0000, 0x0000 }, /* R13129 */ - { 0x0000, 0x0000, 0x0000 }, /* R13130 */ - { 0x0000, 0x0000, 0x0000 }, /* R13131 */ - { 0x0000, 0x0000, 0x0000 }, /* R13132 */ - { 0x0000, 0x0000, 0x0000 }, /* R13133 */ - { 0x0000, 0x0000, 0x0000 }, /* R13134 */ - { 0x0000, 0x0000, 0x0000 }, /* R13135 */ - { 0x0000, 0x0000, 0x0000 }, /* R13136 */ - { 0x0000, 0x0000, 0x0000 }, /* R13137 */ - { 0x0000, 0x0000, 0x0000 }, /* R13138 */ - { 0x0000, 0x0000, 0x0000 }, /* R13139 */ - { 0x0000, 0x0000, 0x0000 }, /* R13140 */ - { 0x0000, 0x0000, 0x0000 }, /* R13141 */ - { 0x0000, 0x0000, 0x0000 }, /* R13142 */ - { 0x0000, 0x0000, 0x0000 }, /* R13143 */ - { 0x0000, 0x0000, 0x0000 }, /* R13144 */ - { 0x0000, 0x0000, 0x0000 }, /* R13145 */ - { 0x0000, 0x0000, 0x0000 }, /* R13146 */ - { 0x0000, 0x0000, 0x0000 }, /* R13147 */ - { 0x0000, 0x0000, 0x0000 }, /* R13148 */ - { 0x0000, 0x0000, 0x0000 }, /* R13149 */ - { 0x0000, 0x0000, 0x0000 }, /* R13150 */ - { 0x0000, 0x0000, 0x0000 }, /* R13151 */ - { 0x0000, 0x0000, 0x0000 }, /* R13152 */ - { 0x0000, 0x0000, 0x0000 }, /* R13153 */ - { 0x0000, 0x0000, 0x0000 }, /* R13154 */ - { 0x0000, 0x0000, 0x0000 }, /* R13155 */ - { 0x0000, 0x0000, 0x0000 }, /* R13156 */ - { 0x0000, 0x0000, 0x0000 }, /* R13157 */ - { 0x0000, 0x0000, 0x0000 }, /* R13158 */ - { 0x0000, 0x0000, 0x0000 }, /* R13159 */ - { 0x0000, 0x0000, 0x0000 }, /* R13160 */ - { 0x0000, 0x0000, 0x0000 }, /* R13161 */ - { 0x0000, 0x0000, 0x0000 }, /* R13162 */ - { 0x0000, 0x0000, 0x0000 }, /* R13163 */ - { 0x0000, 0x0000, 0x0000 }, /* R13164 */ - { 0x0000, 0x0000, 0x0000 }, /* R13165 */ - { 0x0000, 0x0000, 0x0000 }, /* R13166 */ - { 0x0000, 0x0000, 0x0000 }, /* R13167 */ - { 0x0000, 0x0000, 0x0000 }, /* R13168 */ - { 0x0000, 0x0000, 0x0000 }, /* R13169 */ - { 0x0000, 0x0000, 0x0000 }, /* R13170 */ - { 0x0000, 0x0000, 0x0000 }, /* R13171 */ - { 0x0000, 0x0000, 0x0000 }, /* R13172 */ - { 0x0000, 0x0000, 0x0000 }, /* R13173 */ - { 0x0000, 0x0000, 0x0000 }, /* R13174 */ - { 0x0000, 0x0000, 0x0000 }, /* R13175 */ - { 0x0000, 0x0000, 0x0000 }, /* R13176 */ - { 0x0000, 0x0000, 0x0000 }, /* R13177 */ - { 0x0000, 0x0000, 0x0000 }, /* R13178 */ - { 0x0000, 0x0000, 0x0000 }, /* R13179 */ - { 0x0000, 0x0000, 0x0000 }, /* R13180 */ - { 0x0000, 0x0000, 0x0000 }, /* R13181 */ - { 0x0000, 0x0000, 0x0000 }, /* R13182 */ - { 0x0000, 0x0000, 0x0000 }, /* R13183 */ - { 0x0000, 0x0000, 0x0000 }, /* R13184 */ - { 0x0000, 0x0000, 0x0000 }, /* R13185 */ - { 0x0000, 0x0000, 0x0000 }, /* R13186 */ - { 0x0000, 0x0000, 0x0000 }, /* R13187 */ - { 0x0000, 0x0000, 0x0000 }, /* R13188 */ - { 0x0000, 0x0000, 0x0000 }, /* R13189 */ - { 0x0000, 0x0000, 0x0000 }, /* R13190 */ - { 0x0000, 0x0000, 0x0000 }, /* R13191 */ - { 0x0000, 0x0000, 0x0000 }, /* R13192 */ - { 0x0000, 0x0000, 0x0000 }, /* R13193 */ - { 0x0000, 0x0000, 0x0000 }, /* R13194 */ - { 0x0000, 0x0000, 0x0000 }, /* R13195 */ - { 0x0000, 0x0000, 0x0000 }, /* R13196 */ - { 0x0000, 0x0000, 0x0000 }, /* R13197 */ - { 0x0000, 0x0000, 0x0000 }, /* R13198 */ - { 0x0000, 0x0000, 0x0000 }, /* R13199 */ - { 0x0000, 0x0000, 0x0000 }, /* R13200 */ - { 0x0000, 0x0000, 0x0000 }, /* R13201 */ - { 0x0000, 0x0000, 0x0000 }, /* R13202 */ - { 0x0000, 0x0000, 0x0000 }, /* R13203 */ - { 0x0000, 0x0000, 0x0000 }, /* R13204 */ - { 0x0000, 0x0000, 0x0000 }, /* R13205 */ - { 0x0000, 0x0000, 0x0000 }, /* R13206 */ - { 0x0000, 0x0000, 0x0000 }, /* R13207 */ - { 0x0000, 0x0000, 0x0000 }, /* R13208 */ - { 0x0000, 0x0000, 0x0000 }, /* R13209 */ - { 0x0000, 0x0000, 0x0000 }, /* R13210 */ - { 0x0000, 0x0000, 0x0000 }, /* R13211 */ - { 0x0000, 0x0000, 0x0000 }, /* R13212 */ - { 0x0000, 0x0000, 0x0000 }, /* R13213 */ - { 0x0000, 0x0000, 0x0000 }, /* R13214 */ - { 0x0000, 0x0000, 0x0000 }, /* R13215 */ - { 0x0000, 0x0000, 0x0000 }, /* R13216 */ - { 0x0000, 0x0000, 0x0000 }, /* R13217 */ - { 0x0000, 0x0000, 0x0000 }, /* R13218 */ - { 0x0000, 0x0000, 0x0000 }, /* R13219 */ - { 0x0000, 0x0000, 0x0000 }, /* R13220 */ - { 0x0000, 0x0000, 0x0000 }, /* R13221 */ - { 0x0000, 0x0000, 0x0000 }, /* R13222 */ - { 0x0000, 0x0000, 0x0000 }, /* R13223 */ - { 0x0000, 0x0000, 0x0000 }, /* R13224 */ - { 0x0000, 0x0000, 0x0000 }, /* R13225 */ - { 0x0000, 0x0000, 0x0000 }, /* R13226 */ - { 0x0000, 0x0000, 0x0000 }, /* R13227 */ - { 0x0000, 0x0000, 0x0000 }, /* R13228 */ - { 0x0000, 0x0000, 0x0000 }, /* R13229 */ - { 0x0000, 0x0000, 0x0000 }, /* R13230 */ - { 0x0000, 0x0000, 0x0000 }, /* R13231 */ - { 0x0000, 0x0000, 0x0000 }, /* R13232 */ - { 0x0000, 0x0000, 0x0000 }, /* R13233 */ - { 0x0000, 0x0000, 0x0000 }, /* R13234 */ - { 0x0000, 0x0000, 0x0000 }, /* R13235 */ - { 0x0000, 0x0000, 0x0000 }, /* R13236 */ - { 0x0000, 0x0000, 0x0000 }, /* R13237 */ - { 0x0000, 0x0000, 0x0000 }, /* R13238 */ - { 0x0000, 0x0000, 0x0000 }, /* R13239 */ - { 0x0000, 0x0000, 0x0000 }, /* R13240 */ - { 0x0000, 0x0000, 0x0000 }, /* R13241 */ - { 0x0000, 0x0000, 0x0000 }, /* R13242 */ - { 0x0000, 0x0000, 0x0000 }, /* R13243 */ - { 0x0000, 0x0000, 0x0000 }, /* R13244 */ - { 0x0000, 0x0000, 0x0000 }, /* R13245 */ - { 0x0000, 0x0000, 0x0000 }, /* R13246 */ - { 0x0000, 0x0000, 0x0000 }, /* R13247 */ - { 0x0000, 0x0000, 0x0000 }, /* R13248 */ - { 0x0000, 0x0000, 0x0000 }, /* R13249 */ - { 0x0000, 0x0000, 0x0000 }, /* R13250 */ - { 0x0000, 0x0000, 0x0000 }, /* R13251 */ - { 0x0000, 0x0000, 0x0000 }, /* R13252 */ - { 0x0000, 0x0000, 0x0000 }, /* R13253 */ - { 0x0000, 0x0000, 0x0000 }, /* R13254 */ - { 0x0000, 0x0000, 0x0000 }, /* R13255 */ - { 0x0000, 0x0000, 0x0000 }, /* R13256 */ - { 0x0000, 0x0000, 0x0000 }, /* R13257 */ - { 0x0000, 0x0000, 0x0000 }, /* R13258 */ - { 0x0000, 0x0000, 0x0000 }, /* R13259 */ - { 0x0000, 0x0000, 0x0000 }, /* R13260 */ - { 0x0000, 0x0000, 0x0000 }, /* R13261 */ - { 0x0000, 0x0000, 0x0000 }, /* R13262 */ - { 0x0000, 0x0000, 0x0000 }, /* R13263 */ - { 0x0000, 0x0000, 0x0000 }, /* R13264 */ - { 0x0000, 0x0000, 0x0000 }, /* R13265 */ - { 0x0000, 0x0000, 0x0000 }, /* R13266 */ - { 0x0000, 0x0000, 0x0000 }, /* R13267 */ - { 0x0000, 0x0000, 0x0000 }, /* R13268 */ - { 0x0000, 0x0000, 0x0000 }, /* R13269 */ - { 0x0000, 0x0000, 0x0000 }, /* R13270 */ - { 0x0000, 0x0000, 0x0000 }, /* R13271 */ - { 0x0000, 0x0000, 0x0000 }, /* R13272 */ - { 0x0000, 0x0000, 0x0000 }, /* R13273 */ - { 0x0000, 0x0000, 0x0000 }, /* R13274 */ - { 0x0000, 0x0000, 0x0000 }, /* R13275 */ - { 0x0000, 0x0000, 0x0000 }, /* R13276 */ - { 0x0000, 0x0000, 0x0000 }, /* R13277 */ - { 0x0000, 0x0000, 0x0000 }, /* R13278 */ - { 0x0000, 0x0000, 0x0000 }, /* R13279 */ - { 0x0000, 0x0000, 0x0000 }, /* R13280 */ - { 0x0000, 0x0000, 0x0000 }, /* R13281 */ - { 0x0000, 0x0000, 0x0000 }, /* R13282 */ - { 0x0000, 0x0000, 0x0000 }, /* R13283 */ - { 0x0000, 0x0000, 0x0000 }, /* R13284 */ - { 0x0000, 0x0000, 0x0000 }, /* R13285 */ - { 0x0000, 0x0000, 0x0000 }, /* R13286 */ - { 0x0000, 0x0000, 0x0000 }, /* R13287 */ - { 0x0000, 0x0000, 0x0000 }, /* R13288 */ - { 0x0000, 0x0000, 0x0000 }, /* R13289 */ - { 0x0000, 0x0000, 0x0000 }, /* R13290 */ - { 0x0000, 0x0000, 0x0000 }, /* R13291 */ - { 0x0000, 0x0000, 0x0000 }, /* R13292 */ - { 0x0000, 0x0000, 0x0000 }, /* R13293 */ - { 0x0000, 0x0000, 0x0000 }, /* R13294 */ - { 0x0000, 0x0000, 0x0000 }, /* R13295 */ - { 0x0000, 0x0000, 0x0000 }, /* R13296 */ - { 0x0000, 0x0000, 0x0000 }, /* R13297 */ - { 0x0000, 0x0000, 0x0000 }, /* R13298 */ - { 0x0000, 0x0000, 0x0000 }, /* R13299 */ - { 0x0000, 0x0000, 0x0000 }, /* R13300 */ - { 0x0000, 0x0000, 0x0000 }, /* R13301 */ - { 0x0000, 0x0000, 0x0000 }, /* R13302 */ - { 0x0000, 0x0000, 0x0000 }, /* R13303 */ - { 0x0000, 0x0000, 0x0000 }, /* R13304 */ - { 0x0000, 0x0000, 0x0000 }, /* R13305 */ - { 0x0000, 0x0000, 0x0000 }, /* R13306 */ - { 0x0000, 0x0000, 0x0000 }, /* R13307 */ - { 0x0000, 0x0000, 0x0000 }, /* R13308 */ - { 0x0000, 0x0000, 0x0000 }, /* R13309 */ - { 0x0000, 0x0000, 0x0000 }, /* R13310 */ - { 0x0000, 0x0000, 0x0000 }, /* R13311 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R13312 - DSP2 Data2 RAM 1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R13313 - DSP2 Data2 RAM 0 */ - { 0x0000, 0x0000, 0x0000 }, /* R13314 */ - { 0x0000, 0x0000, 0x0000 }, /* R13315 */ - { 0x0000, 0x0000, 0x0000 }, /* R13316 */ - { 0x0000, 0x0000, 0x0000 }, /* R13317 */ - { 0x0000, 0x0000, 0x0000 }, /* R13318 */ - { 0x0000, 0x0000, 0x0000 }, /* R13319 */ - { 0x0000, 0x0000, 0x0000 }, /* R13320 */ - { 0x0000, 0x0000, 0x0000 }, /* R13321 */ - { 0x0000, 0x0000, 0x0000 }, /* R13322 */ - { 0x0000, 0x0000, 0x0000 }, /* R13323 */ - { 0x0000, 0x0000, 0x0000 }, /* R13324 */ - { 0x0000, 0x0000, 0x0000 }, /* R13325 */ - { 0x0000, 0x0000, 0x0000 }, /* R13326 */ - { 0x0000, 0x0000, 0x0000 }, /* R13327 */ - { 0x0000, 0x0000, 0x0000 }, /* R13328 */ - { 0x0000, 0x0000, 0x0000 }, /* R13329 */ - { 0x0000, 0x0000, 0x0000 }, /* R13330 */ - { 0x0000, 0x0000, 0x0000 }, /* R13331 */ - { 0x0000, 0x0000, 0x0000 }, /* R13332 */ - { 0x0000, 0x0000, 0x0000 }, /* R13333 */ - { 0x0000, 0x0000, 0x0000 }, /* R13334 */ - { 0x0000, 0x0000, 0x0000 }, /* R13335 */ - { 0x0000, 0x0000, 0x0000 }, /* R13336 */ - { 0x0000, 0x0000, 0x0000 }, /* R13337 */ - { 0x0000, 0x0000, 0x0000 }, /* R13338 */ - { 0x0000, 0x0000, 0x0000 }, /* R13339 */ - { 0x0000, 0x0000, 0x0000 }, /* R13340 */ - { 0x0000, 0x0000, 0x0000 }, /* R13341 */ - { 0x0000, 0x0000, 0x0000 }, /* R13342 */ - { 0x0000, 0x0000, 0x0000 }, /* R13343 */ - { 0x0000, 0x0000, 0x0000 }, /* R13344 */ - { 0x0000, 0x0000, 0x0000 }, /* R13345 */ - { 0x0000, 0x0000, 0x0000 }, /* R13346 */ - { 0x0000, 0x0000, 0x0000 }, /* R13347 */ - { 0x0000, 0x0000, 0x0000 }, /* R13348 */ - { 0x0000, 0x0000, 0x0000 }, /* R13349 */ - { 0x0000, 0x0000, 0x0000 }, /* R13350 */ - { 0x0000, 0x0000, 0x0000 }, /* R13351 */ - { 0x0000, 0x0000, 0x0000 }, /* R13352 */ - { 0x0000, 0x0000, 0x0000 }, /* R13353 */ - { 0x0000, 0x0000, 0x0000 }, /* R13354 */ - { 0x0000, 0x0000, 0x0000 }, /* R13355 */ - { 0x0000, 0x0000, 0x0000 }, /* R13356 */ - { 0x0000, 0x0000, 0x0000 }, /* R13357 */ - { 0x0000, 0x0000, 0x0000 }, /* R13358 */ - { 0x0000, 0x0000, 0x0000 }, /* R13359 */ - { 0x0000, 0x0000, 0x0000 }, /* R13360 */ - { 0x0000, 0x0000, 0x0000 }, /* R13361 */ - { 0x0000, 0x0000, 0x0000 }, /* R13362 */ - { 0x0000, 0x0000, 0x0000 }, /* R13363 */ - { 0x0000, 0x0000, 0x0000 }, /* R13364 */ - { 0x0000, 0x0000, 0x0000 }, /* R13365 */ - { 0x0000, 0x0000, 0x0000 }, /* R13366 */ - { 0x0000, 0x0000, 0x0000 }, /* R13367 */ - { 0x0000, 0x0000, 0x0000 }, /* R13368 */ - { 0x0000, 0x0000, 0x0000 }, /* R13369 */ - { 0x0000, 0x0000, 0x0000 }, /* R13370 */ - { 0x0000, 0x0000, 0x0000 }, /* R13371 */ - { 0x0000, 0x0000, 0x0000 }, /* R13372 */ - { 0x0000, 0x0000, 0x0000 }, /* R13373 */ - { 0x0000, 0x0000, 0x0000 }, /* R13374 */ - { 0x0000, 0x0000, 0x0000 }, /* R13375 */ - { 0x0000, 0x0000, 0x0000 }, /* R13376 */ - { 0x0000, 0x0000, 0x0000 }, /* R13377 */ - { 0x0000, 0x0000, 0x0000 }, /* R13378 */ - { 0x0000, 0x0000, 0x0000 }, /* R13379 */ - { 0x0000, 0x0000, 0x0000 }, /* R13380 */ - { 0x0000, 0x0000, 0x0000 }, /* R13381 */ - { 0x0000, 0x0000, 0x0000 }, /* R13382 */ - { 0x0000, 0x0000, 0x0000 }, /* R13383 */ - { 0x0000, 0x0000, 0x0000 }, /* R13384 */ - { 0x0000, 0x0000, 0x0000 }, /* R13385 */ - { 0x0000, 0x0000, 0x0000 }, /* R13386 */ - { 0x0000, 0x0000, 0x0000 }, /* R13387 */ - { 0x0000, 0x0000, 0x0000 }, /* R13388 */ - { 0x0000, 0x0000, 0x0000 }, /* R13389 */ - { 0x0000, 0x0000, 0x0000 }, /* R13390 */ - { 0x0000, 0x0000, 0x0000 }, /* R13391 */ - { 0x0000, 0x0000, 0x0000 }, /* R13392 */ - { 0x0000, 0x0000, 0x0000 }, /* R13393 */ - { 0x0000, 0x0000, 0x0000 }, /* R13394 */ - { 0x0000, 0x0000, 0x0000 }, /* R13395 */ - { 0x0000, 0x0000, 0x0000 }, /* R13396 */ - { 0x0000, 0x0000, 0x0000 }, /* R13397 */ - { 0x0000, 0x0000, 0x0000 }, /* R13398 */ - { 0x0000, 0x0000, 0x0000 }, /* R13399 */ - { 0x0000, 0x0000, 0x0000 }, /* R13400 */ - { 0x0000, 0x0000, 0x0000 }, /* R13401 */ - { 0x0000, 0x0000, 0x0000 }, /* R13402 */ - { 0x0000, 0x0000, 0x0000 }, /* R13403 */ - { 0x0000, 0x0000, 0x0000 }, /* R13404 */ - { 0x0000, 0x0000, 0x0000 }, /* R13405 */ - { 0x0000, 0x0000, 0x0000 }, /* R13406 */ - { 0x0000, 0x0000, 0x0000 }, /* R13407 */ - { 0x0000, 0x0000, 0x0000 }, /* R13408 */ - { 0x0000, 0x0000, 0x0000 }, /* R13409 */ - { 0x0000, 0x0000, 0x0000 }, /* R13410 */ - { 0x0000, 0x0000, 0x0000 }, /* R13411 */ - { 0x0000, 0x0000, 0x0000 }, /* R13412 */ - { 0x0000, 0x0000, 0x0000 }, /* R13413 */ - { 0x0000, 0x0000, 0x0000 }, /* R13414 */ - { 0x0000, 0x0000, 0x0000 }, /* R13415 */ - { 0x0000, 0x0000, 0x0000 }, /* R13416 */ - { 0x0000, 0x0000, 0x0000 }, /* R13417 */ - { 0x0000, 0x0000, 0x0000 }, /* R13418 */ - { 0x0000, 0x0000, 0x0000 }, /* R13419 */ - { 0x0000, 0x0000, 0x0000 }, /* R13420 */ - { 0x0000, 0x0000, 0x0000 }, /* R13421 */ - { 0x0000, 0x0000, 0x0000 }, /* R13422 */ - { 0x0000, 0x0000, 0x0000 }, /* R13423 */ - { 0x0000, 0x0000, 0x0000 }, /* R13424 */ - { 0x0000, 0x0000, 0x0000 }, /* R13425 */ - { 0x0000, 0x0000, 0x0000 }, /* R13426 */ - { 0x0000, 0x0000, 0x0000 }, /* R13427 */ - { 0x0000, 0x0000, 0x0000 }, /* R13428 */ - { 0x0000, 0x0000, 0x0000 }, /* R13429 */ - { 0x0000, 0x0000, 0x0000 }, /* R13430 */ - { 0x0000, 0x0000, 0x0000 }, /* R13431 */ - { 0x0000, 0x0000, 0x0000 }, /* R13432 */ - { 0x0000, 0x0000, 0x0000 }, /* R13433 */ - { 0x0000, 0x0000, 0x0000 }, /* R13434 */ - { 0x0000, 0x0000, 0x0000 }, /* R13435 */ - { 0x0000, 0x0000, 0x0000 }, /* R13436 */ - { 0x0000, 0x0000, 0x0000 }, /* R13437 */ - { 0x0000, 0x0000, 0x0000 }, /* R13438 */ - { 0x0000, 0x0000, 0x0000 }, /* R13439 */ - { 0x0000, 0x0000, 0x0000 }, /* R13440 */ - { 0x0000, 0x0000, 0x0000 }, /* R13441 */ - { 0x0000, 0x0000, 0x0000 }, /* R13442 */ - { 0x0000, 0x0000, 0x0000 }, /* R13443 */ - { 0x0000, 0x0000, 0x0000 }, /* R13444 */ - { 0x0000, 0x0000, 0x0000 }, /* R13445 */ - { 0x0000, 0x0000, 0x0000 }, /* R13446 */ - { 0x0000, 0x0000, 0x0000 }, /* R13447 */ - { 0x0000, 0x0000, 0x0000 }, /* R13448 */ - { 0x0000, 0x0000, 0x0000 }, /* R13449 */ - { 0x0000, 0x0000, 0x0000 }, /* R13450 */ - { 0x0000, 0x0000, 0x0000 }, /* R13451 */ - { 0x0000, 0x0000, 0x0000 }, /* R13452 */ - { 0x0000, 0x0000, 0x0000 }, /* R13453 */ - { 0x0000, 0x0000, 0x0000 }, /* R13454 */ - { 0x0000, 0x0000, 0x0000 }, /* R13455 */ - { 0x0000, 0x0000, 0x0000 }, /* R13456 */ - { 0x0000, 0x0000, 0x0000 }, /* R13457 */ - { 0x0000, 0x0000, 0x0000 }, /* R13458 */ - { 0x0000, 0x0000, 0x0000 }, /* R13459 */ - { 0x0000, 0x0000, 0x0000 }, /* R13460 */ - { 0x0000, 0x0000, 0x0000 }, /* R13461 */ - { 0x0000, 0x0000, 0x0000 }, /* R13462 */ - { 0x0000, 0x0000, 0x0000 }, /* R13463 */ - { 0x0000, 0x0000, 0x0000 }, /* R13464 */ - { 0x0000, 0x0000, 0x0000 }, /* R13465 */ - { 0x0000, 0x0000, 0x0000 }, /* R13466 */ - { 0x0000, 0x0000, 0x0000 }, /* R13467 */ - { 0x0000, 0x0000, 0x0000 }, /* R13468 */ - { 0x0000, 0x0000, 0x0000 }, /* R13469 */ - { 0x0000, 0x0000, 0x0000 }, /* R13470 */ - { 0x0000, 0x0000, 0x0000 }, /* R13471 */ - { 0x0000, 0x0000, 0x0000 }, /* R13472 */ - { 0x0000, 0x0000, 0x0000 }, /* R13473 */ - { 0x0000, 0x0000, 0x0000 }, /* R13474 */ - { 0x0000, 0x0000, 0x0000 }, /* R13475 */ - { 0x0000, 0x0000, 0x0000 }, /* R13476 */ - { 0x0000, 0x0000, 0x0000 }, /* R13477 */ - { 0x0000, 0x0000, 0x0000 }, /* R13478 */ - { 0x0000, 0x0000, 0x0000 }, /* R13479 */ - { 0x0000, 0x0000, 0x0000 }, /* R13480 */ - { 0x0000, 0x0000, 0x0000 }, /* R13481 */ - { 0x0000, 0x0000, 0x0000 }, /* R13482 */ - { 0x0000, 0x0000, 0x0000 }, /* R13483 */ - { 0x0000, 0x0000, 0x0000 }, /* R13484 */ - { 0x0000, 0x0000, 0x0000 }, /* R13485 */ - { 0x0000, 0x0000, 0x0000 }, /* R13486 */ - { 0x0000, 0x0000, 0x0000 }, /* R13487 */ - { 0x0000, 0x0000, 0x0000 }, /* R13488 */ - { 0x0000, 0x0000, 0x0000 }, /* R13489 */ - { 0x0000, 0x0000, 0x0000 }, /* R13490 */ - { 0x0000, 0x0000, 0x0000 }, /* R13491 */ - { 0x0000, 0x0000, 0x0000 }, /* R13492 */ - { 0x0000, 0x0000, 0x0000 }, /* R13493 */ - { 0x0000, 0x0000, 0x0000 }, /* R13494 */ - { 0x0000, 0x0000, 0x0000 }, /* R13495 */ - { 0x0000, 0x0000, 0x0000 }, /* R13496 */ - { 0x0000, 0x0000, 0x0000 }, /* R13497 */ - { 0x0000, 0x0000, 0x0000 }, /* R13498 */ - { 0x0000, 0x0000, 0x0000 }, /* R13499 */ - { 0x0000, 0x0000, 0x0000 }, /* R13500 */ - { 0x0000, 0x0000, 0x0000 }, /* R13501 */ - { 0x0000, 0x0000, 0x0000 }, /* R13502 */ - { 0x0000, 0x0000, 0x0000 }, /* R13503 */ - { 0x0000, 0x0000, 0x0000 }, /* R13504 */ - { 0x0000, 0x0000, 0x0000 }, /* R13505 */ - { 0x0000, 0x0000, 0x0000 }, /* R13506 */ - { 0x0000, 0x0000, 0x0000 }, /* R13507 */ - { 0x0000, 0x0000, 0x0000 }, /* R13508 */ - { 0x0000, 0x0000, 0x0000 }, /* R13509 */ - { 0x0000, 0x0000, 0x0000 }, /* R13510 */ - { 0x0000, 0x0000, 0x0000 }, /* R13511 */ - { 0x0000, 0x0000, 0x0000 }, /* R13512 */ - { 0x0000, 0x0000, 0x0000 }, /* R13513 */ - { 0x0000, 0x0000, 0x0000 }, /* R13514 */ - { 0x0000, 0x0000, 0x0000 }, /* R13515 */ - { 0x0000, 0x0000, 0x0000 }, /* R13516 */ - { 0x0000, 0x0000, 0x0000 }, /* R13517 */ - { 0x0000, 0x0000, 0x0000 }, /* R13518 */ - { 0x0000, 0x0000, 0x0000 }, /* R13519 */ - { 0x0000, 0x0000, 0x0000 }, /* R13520 */ - { 0x0000, 0x0000, 0x0000 }, /* R13521 */ - { 0x0000, 0x0000, 0x0000 }, /* R13522 */ - { 0x0000, 0x0000, 0x0000 }, /* R13523 */ - { 0x0000, 0x0000, 0x0000 }, /* R13524 */ - { 0x0000, 0x0000, 0x0000 }, /* R13525 */ - { 0x0000, 0x0000, 0x0000 }, /* R13526 */ - { 0x0000, 0x0000, 0x0000 }, /* R13527 */ - { 0x0000, 0x0000, 0x0000 }, /* R13528 */ - { 0x0000, 0x0000, 0x0000 }, /* R13529 */ - { 0x0000, 0x0000, 0x0000 }, /* R13530 */ - { 0x0000, 0x0000, 0x0000 }, /* R13531 */ - { 0x0000, 0x0000, 0x0000 }, /* R13532 */ - { 0x0000, 0x0000, 0x0000 }, /* R13533 */ - { 0x0000, 0x0000, 0x0000 }, /* R13534 */ - { 0x0000, 0x0000, 0x0000 }, /* R13535 */ - { 0x0000, 0x0000, 0x0000 }, /* R13536 */ - { 0x0000, 0x0000, 0x0000 }, /* R13537 */ - { 0x0000, 0x0000, 0x0000 }, /* R13538 */ - { 0x0000, 0x0000, 0x0000 }, /* R13539 */ - { 0x0000, 0x0000, 0x0000 }, /* R13540 */ - { 0x0000, 0x0000, 0x0000 }, /* R13541 */ - { 0x0000, 0x0000, 0x0000 }, /* R13542 */ - { 0x0000, 0x0000, 0x0000 }, /* R13543 */ - { 0x0000, 0x0000, 0x0000 }, /* R13544 */ - { 0x0000, 0x0000, 0x0000 }, /* R13545 */ - { 0x0000, 0x0000, 0x0000 }, /* R13546 */ - { 0x0000, 0x0000, 0x0000 }, /* R13547 */ - { 0x0000, 0x0000, 0x0000 }, /* R13548 */ - { 0x0000, 0x0000, 0x0000 }, /* R13549 */ - { 0x0000, 0x0000, 0x0000 }, /* R13550 */ - { 0x0000, 0x0000, 0x0000 }, /* R13551 */ - { 0x0000, 0x0000, 0x0000 }, /* R13552 */ - { 0x0000, 0x0000, 0x0000 }, /* R13553 */ - { 0x0000, 0x0000, 0x0000 }, /* R13554 */ - { 0x0000, 0x0000, 0x0000 }, /* R13555 */ - { 0x0000, 0x0000, 0x0000 }, /* R13556 */ - { 0x0000, 0x0000, 0x0000 }, /* R13557 */ - { 0x0000, 0x0000, 0x0000 }, /* R13558 */ - { 0x0000, 0x0000, 0x0000 }, /* R13559 */ - { 0x0000, 0x0000, 0x0000 }, /* R13560 */ - { 0x0000, 0x0000, 0x0000 }, /* R13561 */ - { 0x0000, 0x0000, 0x0000 }, /* R13562 */ - { 0x0000, 0x0000, 0x0000 }, /* R13563 */ - { 0x0000, 0x0000, 0x0000 }, /* R13564 */ - { 0x0000, 0x0000, 0x0000 }, /* R13565 */ - { 0x0000, 0x0000, 0x0000 }, /* R13566 */ - { 0x0000, 0x0000, 0x0000 }, /* R13567 */ - { 0x0000, 0x0000, 0x0000 }, /* R13568 */ - { 0x0000, 0x0000, 0x0000 }, /* R13569 */ - { 0x0000, 0x0000, 0x0000 }, /* R13570 */ - { 0x0000, 0x0000, 0x0000 }, /* R13571 */ - { 0x0000, 0x0000, 0x0000 }, /* R13572 */ - { 0x0000, 0x0000, 0x0000 }, /* R13573 */ - { 0x0000, 0x0000, 0x0000 }, /* R13574 */ - { 0x0000, 0x0000, 0x0000 }, /* R13575 */ - { 0x0000, 0x0000, 0x0000 }, /* R13576 */ - { 0x0000, 0x0000, 0x0000 }, /* R13577 */ - { 0x0000, 0x0000, 0x0000 }, /* R13578 */ - { 0x0000, 0x0000, 0x0000 }, /* R13579 */ - { 0x0000, 0x0000, 0x0000 }, /* R13580 */ - { 0x0000, 0x0000, 0x0000 }, /* R13581 */ - { 0x0000, 0x0000, 0x0000 }, /* R13582 */ - { 0x0000, 0x0000, 0x0000 }, /* R13583 */ - { 0x0000, 0x0000, 0x0000 }, /* R13584 */ - { 0x0000, 0x0000, 0x0000 }, /* R13585 */ - { 0x0000, 0x0000, 0x0000 }, /* R13586 */ - { 0x0000, 0x0000, 0x0000 }, /* R13587 */ - { 0x0000, 0x0000, 0x0000 }, /* R13588 */ - { 0x0000, 0x0000, 0x0000 }, /* R13589 */ - { 0x0000, 0x0000, 0x0000 }, /* R13590 */ - { 0x0000, 0x0000, 0x0000 }, /* R13591 */ - { 0x0000, 0x0000, 0x0000 }, /* R13592 */ - { 0x0000, 0x0000, 0x0000 }, /* R13593 */ - { 0x0000, 0x0000, 0x0000 }, /* R13594 */ - { 0x0000, 0x0000, 0x0000 }, /* R13595 */ - { 0x0000, 0x0000, 0x0000 }, /* R13596 */ - { 0x0000, 0x0000, 0x0000 }, /* R13597 */ - { 0x0000, 0x0000, 0x0000 }, /* R13598 */ - { 0x0000, 0x0000, 0x0000 }, /* R13599 */ - { 0x0000, 0x0000, 0x0000 }, /* R13600 */ - { 0x0000, 0x0000, 0x0000 }, /* R13601 */ - { 0x0000, 0x0000, 0x0000 }, /* R13602 */ - { 0x0000, 0x0000, 0x0000 }, /* R13603 */ - { 0x0000, 0x0000, 0x0000 }, /* R13604 */ - { 0x0000, 0x0000, 0x0000 }, /* R13605 */ - { 0x0000, 0x0000, 0x0000 }, /* R13606 */ - { 0x0000, 0x0000, 0x0000 }, /* R13607 */ - { 0x0000, 0x0000, 0x0000 }, /* R13608 */ - { 0x0000, 0x0000, 0x0000 }, /* R13609 */ - { 0x0000, 0x0000, 0x0000 }, /* R13610 */ - { 0x0000, 0x0000, 0x0000 }, /* R13611 */ - { 0x0000, 0x0000, 0x0000 }, /* R13612 */ - { 0x0000, 0x0000, 0x0000 }, /* R13613 */ - { 0x0000, 0x0000, 0x0000 }, /* R13614 */ - { 0x0000, 0x0000, 0x0000 }, /* R13615 */ - { 0x0000, 0x0000, 0x0000 }, /* R13616 */ - { 0x0000, 0x0000, 0x0000 }, /* R13617 */ - { 0x0000, 0x0000, 0x0000 }, /* R13618 */ - { 0x0000, 0x0000, 0x0000 }, /* R13619 */ - { 0x0000, 0x0000, 0x0000 }, /* R13620 */ - { 0x0000, 0x0000, 0x0000 }, /* R13621 */ - { 0x0000, 0x0000, 0x0000 }, /* R13622 */ - { 0x0000, 0x0000, 0x0000 }, /* R13623 */ - { 0x0000, 0x0000, 0x0000 }, /* R13624 */ - { 0x0000, 0x0000, 0x0000 }, /* R13625 */ - { 0x0000, 0x0000, 0x0000 }, /* R13626 */ - { 0x0000, 0x0000, 0x0000 }, /* R13627 */ - { 0x0000, 0x0000, 0x0000 }, /* R13628 */ - { 0x0000, 0x0000, 0x0000 }, /* R13629 */ - { 0x0000, 0x0000, 0x0000 }, /* R13630 */ - { 0x0000, 0x0000, 0x0000 }, /* R13631 */ - { 0x0000, 0x0000, 0x0000 }, /* R13632 */ - { 0x0000, 0x0000, 0x0000 }, /* R13633 */ - { 0x0000, 0x0000, 0x0000 }, /* R13634 */ - { 0x0000, 0x0000, 0x0000 }, /* R13635 */ - { 0x0000, 0x0000, 0x0000 }, /* R13636 */ - { 0x0000, 0x0000, 0x0000 }, /* R13637 */ - { 0x0000, 0x0000, 0x0000 }, /* R13638 */ - { 0x0000, 0x0000, 0x0000 }, /* R13639 */ - { 0x0000, 0x0000, 0x0000 }, /* R13640 */ - { 0x0000, 0x0000, 0x0000 }, /* R13641 */ - { 0x0000, 0x0000, 0x0000 }, /* R13642 */ - { 0x0000, 0x0000, 0x0000 }, /* R13643 */ - { 0x0000, 0x0000, 0x0000 }, /* R13644 */ - { 0x0000, 0x0000, 0x0000 }, /* R13645 */ - { 0x0000, 0x0000, 0x0000 }, /* R13646 */ - { 0x0000, 0x0000, 0x0000 }, /* R13647 */ - { 0x0000, 0x0000, 0x0000 }, /* R13648 */ - { 0x0000, 0x0000, 0x0000 }, /* R13649 */ - { 0x0000, 0x0000, 0x0000 }, /* R13650 */ - { 0x0000, 0x0000, 0x0000 }, /* R13651 */ - { 0x0000, 0x0000, 0x0000 }, /* R13652 */ - { 0x0000, 0x0000, 0x0000 }, /* R13653 */ - { 0x0000, 0x0000, 0x0000 }, /* R13654 */ - { 0x0000, 0x0000, 0x0000 }, /* R13655 */ - { 0x0000, 0x0000, 0x0000 }, /* R13656 */ - { 0x0000, 0x0000, 0x0000 }, /* R13657 */ - { 0x0000, 0x0000, 0x0000 }, /* R13658 */ - { 0x0000, 0x0000, 0x0000 }, /* R13659 */ - { 0x0000, 0x0000, 0x0000 }, /* R13660 */ - { 0x0000, 0x0000, 0x0000 }, /* R13661 */ - { 0x0000, 0x0000, 0x0000 }, /* R13662 */ - { 0x0000, 0x0000, 0x0000 }, /* R13663 */ - { 0x0000, 0x0000, 0x0000 }, /* R13664 */ - { 0x0000, 0x0000, 0x0000 }, /* R13665 */ - { 0x0000, 0x0000, 0x0000 }, /* R13666 */ - { 0x0000, 0x0000, 0x0000 }, /* R13667 */ - { 0x0000, 0x0000, 0x0000 }, /* R13668 */ - { 0x0000, 0x0000, 0x0000 }, /* R13669 */ - { 0x0000, 0x0000, 0x0000 }, /* R13670 */ - { 0x0000, 0x0000, 0x0000 }, /* R13671 */ - { 0x0000, 0x0000, 0x0000 }, /* R13672 */ - { 0x0000, 0x0000, 0x0000 }, /* R13673 */ - { 0x0000, 0x0000, 0x0000 }, /* R13674 */ - { 0x0000, 0x0000, 0x0000 }, /* R13675 */ - { 0x0000, 0x0000, 0x0000 }, /* R13676 */ - { 0x0000, 0x0000, 0x0000 }, /* R13677 */ - { 0x0000, 0x0000, 0x0000 }, /* R13678 */ - { 0x0000, 0x0000, 0x0000 }, /* R13679 */ - { 0x0000, 0x0000, 0x0000 }, /* R13680 */ - { 0x0000, 0x0000, 0x0000 }, /* R13681 */ - { 0x0000, 0x0000, 0x0000 }, /* R13682 */ - { 0x0000, 0x0000, 0x0000 }, /* R13683 */ - { 0x0000, 0x0000, 0x0000 }, /* R13684 */ - { 0x0000, 0x0000, 0x0000 }, /* R13685 */ - { 0x0000, 0x0000, 0x0000 }, /* R13686 */ - { 0x0000, 0x0000, 0x0000 }, /* R13687 */ - { 0x0000, 0x0000, 0x0000 }, /* R13688 */ - { 0x0000, 0x0000, 0x0000 }, /* R13689 */ - { 0x0000, 0x0000, 0x0000 }, /* R13690 */ - { 0x0000, 0x0000, 0x0000 }, /* R13691 */ - { 0x0000, 0x0000, 0x0000 }, /* R13692 */ - { 0x0000, 0x0000, 0x0000 }, /* R13693 */ - { 0x0000, 0x0000, 0x0000 }, /* R13694 */ - { 0x0000, 0x0000, 0x0000 }, /* R13695 */ - { 0x0000, 0x0000, 0x0000 }, /* R13696 */ - { 0x0000, 0x0000, 0x0000 }, /* R13697 */ - { 0x0000, 0x0000, 0x0000 }, /* R13698 */ - { 0x0000, 0x0000, 0x0000 }, /* R13699 */ - { 0x0000, 0x0000, 0x0000 }, /* R13700 */ - { 0x0000, 0x0000, 0x0000 }, /* R13701 */ - { 0x0000, 0x0000, 0x0000 }, /* R13702 */ - { 0x0000, 0x0000, 0x0000 }, /* R13703 */ - { 0x0000, 0x0000, 0x0000 }, /* R13704 */ - { 0x0000, 0x0000, 0x0000 }, /* R13705 */ - { 0x0000, 0x0000, 0x0000 }, /* R13706 */ - { 0x0000, 0x0000, 0x0000 }, /* R13707 */ - { 0x0000, 0x0000, 0x0000 }, /* R13708 */ - { 0x0000, 0x0000, 0x0000 }, /* R13709 */ - { 0x0000, 0x0000, 0x0000 }, /* R13710 */ - { 0x0000, 0x0000, 0x0000 }, /* R13711 */ - { 0x0000, 0x0000, 0x0000 }, /* R13712 */ - { 0x0000, 0x0000, 0x0000 }, /* R13713 */ - { 0x0000, 0x0000, 0x0000 }, /* R13714 */ - { 0x0000, 0x0000, 0x0000 }, /* R13715 */ - { 0x0000, 0x0000, 0x0000 }, /* R13716 */ - { 0x0000, 0x0000, 0x0000 }, /* R13717 */ - { 0x0000, 0x0000, 0x0000 }, /* R13718 */ - { 0x0000, 0x0000, 0x0000 }, /* R13719 */ - { 0x0000, 0x0000, 0x0000 }, /* R13720 */ - { 0x0000, 0x0000, 0x0000 }, /* R13721 */ - { 0x0000, 0x0000, 0x0000 }, /* R13722 */ - { 0x0000, 0x0000, 0x0000 }, /* R13723 */ - { 0x0000, 0x0000, 0x0000 }, /* R13724 */ - { 0x0000, 0x0000, 0x0000 }, /* R13725 */ - { 0x0000, 0x0000, 0x0000 }, /* R13726 */ - { 0x0000, 0x0000, 0x0000 }, /* R13727 */ - { 0x0000, 0x0000, 0x0000 }, /* R13728 */ - { 0x0000, 0x0000, 0x0000 }, /* R13729 */ - { 0x0000, 0x0000, 0x0000 }, /* R13730 */ - { 0x0000, 0x0000, 0x0000 }, /* R13731 */ - { 0x0000, 0x0000, 0x0000 }, /* R13732 */ - { 0x0000, 0x0000, 0x0000 }, /* R13733 */ - { 0x0000, 0x0000, 0x0000 }, /* R13734 */ - { 0x0000, 0x0000, 0x0000 }, /* R13735 */ - { 0x0000, 0x0000, 0x0000 }, /* R13736 */ - { 0x0000, 0x0000, 0x0000 }, /* R13737 */ - { 0x0000, 0x0000, 0x0000 }, /* R13738 */ - { 0x0000, 0x0000, 0x0000 }, /* R13739 */ - { 0x0000, 0x0000, 0x0000 }, /* R13740 */ - { 0x0000, 0x0000, 0x0000 }, /* R13741 */ - { 0x0000, 0x0000, 0x0000 }, /* R13742 */ - { 0x0000, 0x0000, 0x0000 }, /* R13743 */ - { 0x0000, 0x0000, 0x0000 }, /* R13744 */ - { 0x0000, 0x0000, 0x0000 }, /* R13745 */ - { 0x0000, 0x0000, 0x0000 }, /* R13746 */ - { 0x0000, 0x0000, 0x0000 }, /* R13747 */ - { 0x0000, 0x0000, 0x0000 }, /* R13748 */ - { 0x0000, 0x0000, 0x0000 }, /* R13749 */ - { 0x0000, 0x0000, 0x0000 }, /* R13750 */ - { 0x0000, 0x0000, 0x0000 }, /* R13751 */ - { 0x0000, 0x0000, 0x0000 }, /* R13752 */ - { 0x0000, 0x0000, 0x0000 }, /* R13753 */ - { 0x0000, 0x0000, 0x0000 }, /* R13754 */ - { 0x0000, 0x0000, 0x0000 }, /* R13755 */ - { 0x0000, 0x0000, 0x0000 }, /* R13756 */ - { 0x0000, 0x0000, 0x0000 }, /* R13757 */ - { 0x0000, 0x0000, 0x0000 }, /* R13758 */ - { 0x0000, 0x0000, 0x0000 }, /* R13759 */ - { 0x0000, 0x0000, 0x0000 }, /* R13760 */ - { 0x0000, 0x0000, 0x0000 }, /* R13761 */ - { 0x0000, 0x0000, 0x0000 }, /* R13762 */ - { 0x0000, 0x0000, 0x0000 }, /* R13763 */ - { 0x0000, 0x0000, 0x0000 }, /* R13764 */ - { 0x0000, 0x0000, 0x0000 }, /* R13765 */ - { 0x0000, 0x0000, 0x0000 }, /* R13766 */ - { 0x0000, 0x0000, 0x0000 }, /* R13767 */ - { 0x0000, 0x0000, 0x0000 }, /* R13768 */ - { 0x0000, 0x0000, 0x0000 }, /* R13769 */ - { 0x0000, 0x0000, 0x0000 }, /* R13770 */ - { 0x0000, 0x0000, 0x0000 }, /* R13771 */ - { 0x0000, 0x0000, 0x0000 }, /* R13772 */ - { 0x0000, 0x0000, 0x0000 }, /* R13773 */ - { 0x0000, 0x0000, 0x0000 }, /* R13774 */ - { 0x0000, 0x0000, 0x0000 }, /* R13775 */ - { 0x0000, 0x0000, 0x0000 }, /* R13776 */ - { 0x0000, 0x0000, 0x0000 }, /* R13777 */ - { 0x0000, 0x0000, 0x0000 }, /* R13778 */ - { 0x0000, 0x0000, 0x0000 }, /* R13779 */ - { 0x0000, 0x0000, 0x0000 }, /* R13780 */ - { 0x0000, 0x0000, 0x0000 }, /* R13781 */ - { 0x0000, 0x0000, 0x0000 }, /* R13782 */ - { 0x0000, 0x0000, 0x0000 }, /* R13783 */ - { 0x0000, 0x0000, 0x0000 }, /* R13784 */ - { 0x0000, 0x0000, 0x0000 }, /* R13785 */ - { 0x0000, 0x0000, 0x0000 }, /* R13786 */ - { 0x0000, 0x0000, 0x0000 }, /* R13787 */ - { 0x0000, 0x0000, 0x0000 }, /* R13788 */ - { 0x0000, 0x0000, 0x0000 }, /* R13789 */ - { 0x0000, 0x0000, 0x0000 }, /* R13790 */ - { 0x0000, 0x0000, 0x0000 }, /* R13791 */ - { 0x0000, 0x0000, 0x0000 }, /* R13792 */ - { 0x0000, 0x0000, 0x0000 }, /* R13793 */ - { 0x0000, 0x0000, 0x0000 }, /* R13794 */ - { 0x0000, 0x0000, 0x0000 }, /* R13795 */ - { 0x0000, 0x0000, 0x0000 }, /* R13796 */ - { 0x0000, 0x0000, 0x0000 }, /* R13797 */ - { 0x0000, 0x0000, 0x0000 }, /* R13798 */ - { 0x0000, 0x0000, 0x0000 }, /* R13799 */ - { 0x0000, 0x0000, 0x0000 }, /* R13800 */ - { 0x0000, 0x0000, 0x0000 }, /* R13801 */ - { 0x0000, 0x0000, 0x0000 }, /* R13802 */ - { 0x0000, 0x0000, 0x0000 }, /* R13803 */ - { 0x0000, 0x0000, 0x0000 }, /* R13804 */ - { 0x0000, 0x0000, 0x0000 }, /* R13805 */ - { 0x0000, 0x0000, 0x0000 }, /* R13806 */ - { 0x0000, 0x0000, 0x0000 }, /* R13807 */ - { 0x0000, 0x0000, 0x0000 }, /* R13808 */ - { 0x0000, 0x0000, 0x0000 }, /* R13809 */ - { 0x0000, 0x0000, 0x0000 }, /* R13810 */ - { 0x0000, 0x0000, 0x0000 }, /* R13811 */ - { 0x0000, 0x0000, 0x0000 }, /* R13812 */ - { 0x0000, 0x0000, 0x0000 }, /* R13813 */ - { 0x0000, 0x0000, 0x0000 }, /* R13814 */ - { 0x0000, 0x0000, 0x0000 }, /* R13815 */ - { 0x0000, 0x0000, 0x0000 }, /* R13816 */ - { 0x0000, 0x0000, 0x0000 }, /* R13817 */ - { 0x0000, 0x0000, 0x0000 }, /* R13818 */ - { 0x0000, 0x0000, 0x0000 }, /* R13819 */ - { 0x0000, 0x0000, 0x0000 }, /* R13820 */ - { 0x0000, 0x0000, 0x0000 }, /* R13821 */ - { 0x0000, 0x0000, 0x0000 }, /* R13822 */ - { 0x0000, 0x0000, 0x0000 }, /* R13823 */ - { 0x0000, 0x0000, 0x0000 }, /* R13824 */ - { 0x0000, 0x0000, 0x0000 }, /* R13825 */ - { 0x0000, 0x0000, 0x0000 }, /* R13826 */ - { 0x0000, 0x0000, 0x0000 }, /* R13827 */ - { 0x0000, 0x0000, 0x0000 }, /* R13828 */ - { 0x0000, 0x0000, 0x0000 }, /* R13829 */ - { 0x0000, 0x0000, 0x0000 }, /* R13830 */ - { 0x0000, 0x0000, 0x0000 }, /* R13831 */ - { 0x0000, 0x0000, 0x0000 }, /* R13832 */ - { 0x0000, 0x0000, 0x0000 }, /* R13833 */ - { 0x0000, 0x0000, 0x0000 }, /* R13834 */ - { 0x0000, 0x0000, 0x0000 }, /* R13835 */ - { 0x0000, 0x0000, 0x0000 }, /* R13836 */ - { 0x0000, 0x0000, 0x0000 }, /* R13837 */ - { 0x0000, 0x0000, 0x0000 }, /* R13838 */ - { 0x0000, 0x0000, 0x0000 }, /* R13839 */ - { 0x0000, 0x0000, 0x0000 }, /* R13840 */ - { 0x0000, 0x0000, 0x0000 }, /* R13841 */ - { 0x0000, 0x0000, 0x0000 }, /* R13842 */ - { 0x0000, 0x0000, 0x0000 }, /* R13843 */ - { 0x0000, 0x0000, 0x0000 }, /* R13844 */ - { 0x0000, 0x0000, 0x0000 }, /* R13845 */ - { 0x0000, 0x0000, 0x0000 }, /* R13846 */ - { 0x0000, 0x0000, 0x0000 }, /* R13847 */ - { 0x0000, 0x0000, 0x0000 }, /* R13848 */ - { 0x0000, 0x0000, 0x0000 }, /* R13849 */ - { 0x0000, 0x0000, 0x0000 }, /* R13850 */ - { 0x0000, 0x0000, 0x0000 }, /* R13851 */ - { 0x0000, 0x0000, 0x0000 }, /* R13852 */ - { 0x0000, 0x0000, 0x0000 }, /* R13853 */ - { 0x0000, 0x0000, 0x0000 }, /* R13854 */ - { 0x0000, 0x0000, 0x0000 }, /* R13855 */ - { 0x0000, 0x0000, 0x0000 }, /* R13856 */ - { 0x0000, 0x0000, 0x0000 }, /* R13857 */ - { 0x0000, 0x0000, 0x0000 }, /* R13858 */ - { 0x0000, 0x0000, 0x0000 }, /* R13859 */ - { 0x0000, 0x0000, 0x0000 }, /* R13860 */ - { 0x0000, 0x0000, 0x0000 }, /* R13861 */ - { 0x0000, 0x0000, 0x0000 }, /* R13862 */ - { 0x0000, 0x0000, 0x0000 }, /* R13863 */ - { 0x0000, 0x0000, 0x0000 }, /* R13864 */ - { 0x0000, 0x0000, 0x0000 }, /* R13865 */ - { 0x0000, 0x0000, 0x0000 }, /* R13866 */ - { 0x0000, 0x0000, 0x0000 }, /* R13867 */ - { 0x0000, 0x0000, 0x0000 }, /* R13868 */ - { 0x0000, 0x0000, 0x0000 }, /* R13869 */ - { 0x0000, 0x0000, 0x0000 }, /* R13870 */ - { 0x0000, 0x0000, 0x0000 }, /* R13871 */ - { 0x0000, 0x0000, 0x0000 }, /* R13872 */ - { 0x0000, 0x0000, 0x0000 }, /* R13873 */ - { 0x0000, 0x0000, 0x0000 }, /* R13874 */ - { 0x0000, 0x0000, 0x0000 }, /* R13875 */ - { 0x0000, 0x0000, 0x0000 }, /* R13876 */ - { 0x0000, 0x0000, 0x0000 }, /* R13877 */ - { 0x0000, 0x0000, 0x0000 }, /* R13878 */ - { 0x0000, 0x0000, 0x0000 }, /* R13879 */ - { 0x0000, 0x0000, 0x0000 }, /* R13880 */ - { 0x0000, 0x0000, 0x0000 }, /* R13881 */ - { 0x0000, 0x0000, 0x0000 }, /* R13882 */ - { 0x0000, 0x0000, 0x0000 }, /* R13883 */ - { 0x0000, 0x0000, 0x0000 }, /* R13884 */ - { 0x0000, 0x0000, 0x0000 }, /* R13885 */ - { 0x0000, 0x0000, 0x0000 }, /* R13886 */ - { 0x0000, 0x0000, 0x0000 }, /* R13887 */ - { 0x0000, 0x0000, 0x0000 }, /* R13888 */ - { 0x0000, 0x0000, 0x0000 }, /* R13889 */ - { 0x0000, 0x0000, 0x0000 }, /* R13890 */ - { 0x0000, 0x0000, 0x0000 }, /* R13891 */ - { 0x0000, 0x0000, 0x0000 }, /* R13892 */ - { 0x0000, 0x0000, 0x0000 }, /* R13893 */ - { 0x0000, 0x0000, 0x0000 }, /* R13894 */ - { 0x0000, 0x0000, 0x0000 }, /* R13895 */ - { 0x0000, 0x0000, 0x0000 }, /* R13896 */ - { 0x0000, 0x0000, 0x0000 }, /* R13897 */ - { 0x0000, 0x0000, 0x0000 }, /* R13898 */ - { 0x0000, 0x0000, 0x0000 }, /* R13899 */ - { 0x0000, 0x0000, 0x0000 }, /* R13900 */ - { 0x0000, 0x0000, 0x0000 }, /* R13901 */ - { 0x0000, 0x0000, 0x0000 }, /* R13902 */ - { 0x0000, 0x0000, 0x0000 }, /* R13903 */ - { 0x0000, 0x0000, 0x0000 }, /* R13904 */ - { 0x0000, 0x0000, 0x0000 }, /* R13905 */ - { 0x0000, 0x0000, 0x0000 }, /* R13906 */ - { 0x0000, 0x0000, 0x0000 }, /* R13907 */ - { 0x0000, 0x0000, 0x0000 }, /* R13908 */ - { 0x0000, 0x0000, 0x0000 }, /* R13909 */ - { 0x0000, 0x0000, 0x0000 }, /* R13910 */ - { 0x0000, 0x0000, 0x0000 }, /* R13911 */ - { 0x0000, 0x0000, 0x0000 }, /* R13912 */ - { 0x0000, 0x0000, 0x0000 }, /* R13913 */ - { 0x0000, 0x0000, 0x0000 }, /* R13914 */ - { 0x0000, 0x0000, 0x0000 }, /* R13915 */ - { 0x0000, 0x0000, 0x0000 }, /* R13916 */ - { 0x0000, 0x0000, 0x0000 }, /* R13917 */ - { 0x0000, 0x0000, 0x0000 }, /* R13918 */ - { 0x0000, 0x0000, 0x0000 }, /* R13919 */ - { 0x0000, 0x0000, 0x0000 }, /* R13920 */ - { 0x0000, 0x0000, 0x0000 }, /* R13921 */ - { 0x0000, 0x0000, 0x0000 }, /* R13922 */ - { 0x0000, 0x0000, 0x0000 }, /* R13923 */ - { 0x0000, 0x0000, 0x0000 }, /* R13924 */ - { 0x0000, 0x0000, 0x0000 }, /* R13925 */ - { 0x0000, 0x0000, 0x0000 }, /* R13926 */ - { 0x0000, 0x0000, 0x0000 }, /* R13927 */ - { 0x0000, 0x0000, 0x0000 }, /* R13928 */ - { 0x0000, 0x0000, 0x0000 }, /* R13929 */ - { 0x0000, 0x0000, 0x0000 }, /* R13930 */ - { 0x0000, 0x0000, 0x0000 }, /* R13931 */ - { 0x0000, 0x0000, 0x0000 }, /* R13932 */ - { 0x0000, 0x0000, 0x0000 }, /* R13933 */ - { 0x0000, 0x0000, 0x0000 }, /* R13934 */ - { 0x0000, 0x0000, 0x0000 }, /* R13935 */ - { 0x0000, 0x0000, 0x0000 }, /* R13936 */ - { 0x0000, 0x0000, 0x0000 }, /* R13937 */ - { 0x0000, 0x0000, 0x0000 }, /* R13938 */ - { 0x0000, 0x0000, 0x0000 }, /* R13939 */ - { 0x0000, 0x0000, 0x0000 }, /* R13940 */ - { 0x0000, 0x0000, 0x0000 }, /* R13941 */ - { 0x0000, 0x0000, 0x0000 }, /* R13942 */ - { 0x0000, 0x0000, 0x0000 }, /* R13943 */ - { 0x0000, 0x0000, 0x0000 }, /* R13944 */ - { 0x0000, 0x0000, 0x0000 }, /* R13945 */ - { 0x0000, 0x0000, 0x0000 }, /* R13946 */ - { 0x0000, 0x0000, 0x0000 }, /* R13947 */ - { 0x0000, 0x0000, 0x0000 }, /* R13948 */ - { 0x0000, 0x0000, 0x0000 }, /* R13949 */ - { 0x0000, 0x0000, 0x0000 }, /* R13950 */ - { 0x0000, 0x0000, 0x0000 }, /* R13951 */ - { 0x0000, 0x0000, 0x0000 }, /* R13952 */ - { 0x0000, 0x0000, 0x0000 }, /* R13953 */ - { 0x0000, 0x0000, 0x0000 }, /* R13954 */ - { 0x0000, 0x0000, 0x0000 }, /* R13955 */ - { 0x0000, 0x0000, 0x0000 }, /* R13956 */ - { 0x0000, 0x0000, 0x0000 }, /* R13957 */ - { 0x0000, 0x0000, 0x0000 }, /* R13958 */ - { 0x0000, 0x0000, 0x0000 }, /* R13959 */ - { 0x0000, 0x0000, 0x0000 }, /* R13960 */ - { 0x0000, 0x0000, 0x0000 }, /* R13961 */ - { 0x0000, 0x0000, 0x0000 }, /* R13962 */ - { 0x0000, 0x0000, 0x0000 }, /* R13963 */ - { 0x0000, 0x0000, 0x0000 }, /* R13964 */ - { 0x0000, 0x0000, 0x0000 }, /* R13965 */ - { 0x0000, 0x0000, 0x0000 }, /* R13966 */ - { 0x0000, 0x0000, 0x0000 }, /* R13967 */ - { 0x0000, 0x0000, 0x0000 }, /* R13968 */ - { 0x0000, 0x0000, 0x0000 }, /* R13969 */ - { 0x0000, 0x0000, 0x0000 }, /* R13970 */ - { 0x0000, 0x0000, 0x0000 }, /* R13971 */ - { 0x0000, 0x0000, 0x0000 }, /* R13972 */ - { 0x0000, 0x0000, 0x0000 }, /* R13973 */ - { 0x0000, 0x0000, 0x0000 }, /* R13974 */ - { 0x0000, 0x0000, 0x0000 }, /* R13975 */ - { 0x0000, 0x0000, 0x0000 }, /* R13976 */ - { 0x0000, 0x0000, 0x0000 }, /* R13977 */ - { 0x0000, 0x0000, 0x0000 }, /* R13978 */ - { 0x0000, 0x0000, 0x0000 }, /* R13979 */ - { 0x0000, 0x0000, 0x0000 }, /* R13980 */ - { 0x0000, 0x0000, 0x0000 }, /* R13981 */ - { 0x0000, 0x0000, 0x0000 }, /* R13982 */ - { 0x0000, 0x0000, 0x0000 }, /* R13983 */ - { 0x0000, 0x0000, 0x0000 }, /* R13984 */ - { 0x0000, 0x0000, 0x0000 }, /* R13985 */ - { 0x0000, 0x0000, 0x0000 }, /* R13986 */ - { 0x0000, 0x0000, 0x0000 }, /* R13987 */ - { 0x0000, 0x0000, 0x0000 }, /* R13988 */ - { 0x0000, 0x0000, 0x0000 }, /* R13989 */ - { 0x0000, 0x0000, 0x0000 }, /* R13990 */ - { 0x0000, 0x0000, 0x0000 }, /* R13991 */ - { 0x0000, 0x0000, 0x0000 }, /* R13992 */ - { 0x0000, 0x0000, 0x0000 }, /* R13993 */ - { 0x0000, 0x0000, 0x0000 }, /* R13994 */ - { 0x0000, 0x0000, 0x0000 }, /* R13995 */ - { 0x0000, 0x0000, 0x0000 }, /* R13996 */ - { 0x0000, 0x0000, 0x0000 }, /* R13997 */ - { 0x0000, 0x0000, 0x0000 }, /* R13998 */ - { 0x0000, 0x0000, 0x0000 }, /* R13999 */ - { 0x0000, 0x0000, 0x0000 }, /* R14000 */ - { 0x0000, 0x0000, 0x0000 }, /* R14001 */ - { 0x0000, 0x0000, 0x0000 }, /* R14002 */ - { 0x0000, 0x0000, 0x0000 }, /* R14003 */ - { 0x0000, 0x0000, 0x0000 }, /* R14004 */ - { 0x0000, 0x0000, 0x0000 }, /* R14005 */ - { 0x0000, 0x0000, 0x0000 }, /* R14006 */ - { 0x0000, 0x0000, 0x0000 }, /* R14007 */ - { 0x0000, 0x0000, 0x0000 }, /* R14008 */ - { 0x0000, 0x0000, 0x0000 }, /* R14009 */ - { 0x0000, 0x0000, 0x0000 }, /* R14010 */ - { 0x0000, 0x0000, 0x0000 }, /* R14011 */ - { 0x0000, 0x0000, 0x0000 }, /* R14012 */ - { 0x0000, 0x0000, 0x0000 }, /* R14013 */ - { 0x0000, 0x0000, 0x0000 }, /* R14014 */ - { 0x0000, 0x0000, 0x0000 }, /* R14015 */ - { 0x0000, 0x0000, 0x0000 }, /* R14016 */ - { 0x0000, 0x0000, 0x0000 }, /* R14017 */ - { 0x0000, 0x0000, 0x0000 }, /* R14018 */ - { 0x0000, 0x0000, 0x0000 }, /* R14019 */ - { 0x0000, 0x0000, 0x0000 }, /* R14020 */ - { 0x0000, 0x0000, 0x0000 }, /* R14021 */ - { 0x0000, 0x0000, 0x0000 }, /* R14022 */ - { 0x0000, 0x0000, 0x0000 }, /* R14023 */ - { 0x0000, 0x0000, 0x0000 }, /* R14024 */ - { 0x0000, 0x0000, 0x0000 }, /* R14025 */ - { 0x0000, 0x0000, 0x0000 }, /* R14026 */ - { 0x0000, 0x0000, 0x0000 }, /* R14027 */ - { 0x0000, 0x0000, 0x0000 }, /* R14028 */ - { 0x0000, 0x0000, 0x0000 }, /* R14029 */ - { 0x0000, 0x0000, 0x0000 }, /* R14030 */ - { 0x0000, 0x0000, 0x0000 }, /* R14031 */ - { 0x0000, 0x0000, 0x0000 }, /* R14032 */ - { 0x0000, 0x0000, 0x0000 }, /* R14033 */ - { 0x0000, 0x0000, 0x0000 }, /* R14034 */ - { 0x0000, 0x0000, 0x0000 }, /* R14035 */ - { 0x0000, 0x0000, 0x0000 }, /* R14036 */ - { 0x0000, 0x0000, 0x0000 }, /* R14037 */ - { 0x0000, 0x0000, 0x0000 }, /* R14038 */ - { 0x0000, 0x0000, 0x0000 }, /* R14039 */ - { 0x0000, 0x0000, 0x0000 }, /* R14040 */ - { 0x0000, 0x0000, 0x0000 }, /* R14041 */ - { 0x0000, 0x0000, 0x0000 }, /* R14042 */ - { 0x0000, 0x0000, 0x0000 }, /* R14043 */ - { 0x0000, 0x0000, 0x0000 }, /* R14044 */ - { 0x0000, 0x0000, 0x0000 }, /* R14045 */ - { 0x0000, 0x0000, 0x0000 }, /* R14046 */ - { 0x0000, 0x0000, 0x0000 }, /* R14047 */ - { 0x0000, 0x0000, 0x0000 }, /* R14048 */ - { 0x0000, 0x0000, 0x0000 }, /* R14049 */ - { 0x0000, 0x0000, 0x0000 }, /* R14050 */ - { 0x0000, 0x0000, 0x0000 }, /* R14051 */ - { 0x0000, 0x0000, 0x0000 }, /* R14052 */ - { 0x0000, 0x0000, 0x0000 }, /* R14053 */ - { 0x0000, 0x0000, 0x0000 }, /* R14054 */ - { 0x0000, 0x0000, 0x0000 }, /* R14055 */ - { 0x0000, 0x0000, 0x0000 }, /* R14056 */ - { 0x0000, 0x0000, 0x0000 }, /* R14057 */ - { 0x0000, 0x0000, 0x0000 }, /* R14058 */ - { 0x0000, 0x0000, 0x0000 }, /* R14059 */ - { 0x0000, 0x0000, 0x0000 }, /* R14060 */ - { 0x0000, 0x0000, 0x0000 }, /* R14061 */ - { 0x0000, 0x0000, 0x0000 }, /* R14062 */ - { 0x0000, 0x0000, 0x0000 }, /* R14063 */ - { 0x0000, 0x0000, 0x0000 }, /* R14064 */ - { 0x0000, 0x0000, 0x0000 }, /* R14065 */ - { 0x0000, 0x0000, 0x0000 }, /* R14066 */ - { 0x0000, 0x0000, 0x0000 }, /* R14067 */ - { 0x0000, 0x0000, 0x0000 }, /* R14068 */ - { 0x0000, 0x0000, 0x0000 }, /* R14069 */ - { 0x0000, 0x0000, 0x0000 }, /* R14070 */ - { 0x0000, 0x0000, 0x0000 }, /* R14071 */ - { 0x0000, 0x0000, 0x0000 }, /* R14072 */ - { 0x0000, 0x0000, 0x0000 }, /* R14073 */ - { 0x0000, 0x0000, 0x0000 }, /* R14074 */ - { 0x0000, 0x0000, 0x0000 }, /* R14075 */ - { 0x0000, 0x0000, 0x0000 }, /* R14076 */ - { 0x0000, 0x0000, 0x0000 }, /* R14077 */ - { 0x0000, 0x0000, 0x0000 }, /* R14078 */ - { 0x0000, 0x0000, 0x0000 }, /* R14079 */ - { 0x0000, 0x0000, 0x0000 }, /* R14080 */ - { 0x0000, 0x0000, 0x0000 }, /* R14081 */ - { 0x0000, 0x0000, 0x0000 }, /* R14082 */ - { 0x0000, 0x0000, 0x0000 }, /* R14083 */ - { 0x0000, 0x0000, 0x0000 }, /* R14084 */ - { 0x0000, 0x0000, 0x0000 }, /* R14085 */ - { 0x0000, 0x0000, 0x0000 }, /* R14086 */ - { 0x0000, 0x0000, 0x0000 }, /* R14087 */ - { 0x0000, 0x0000, 0x0000 }, /* R14088 */ - { 0x0000, 0x0000, 0x0000 }, /* R14089 */ - { 0x0000, 0x0000, 0x0000 }, /* R14090 */ - { 0x0000, 0x0000, 0x0000 }, /* R14091 */ - { 0x0000, 0x0000, 0x0000 }, /* R14092 */ - { 0x0000, 0x0000, 0x0000 }, /* R14093 */ - { 0x0000, 0x0000, 0x0000 }, /* R14094 */ - { 0x0000, 0x0000, 0x0000 }, /* R14095 */ - { 0x0000, 0x0000, 0x0000 }, /* R14096 */ - { 0x0000, 0x0000, 0x0000 }, /* R14097 */ - { 0x0000, 0x0000, 0x0000 }, /* R14098 */ - { 0x0000, 0x0000, 0x0000 }, /* R14099 */ - { 0x0000, 0x0000, 0x0000 }, /* R14100 */ - { 0x0000, 0x0000, 0x0000 }, /* R14101 */ - { 0x0000, 0x0000, 0x0000 }, /* R14102 */ - { 0x0000, 0x0000, 0x0000 }, /* R14103 */ - { 0x0000, 0x0000, 0x0000 }, /* R14104 */ - { 0x0000, 0x0000, 0x0000 }, /* R14105 */ - { 0x0000, 0x0000, 0x0000 }, /* R14106 */ - { 0x0000, 0x0000, 0x0000 }, /* R14107 */ - { 0x0000, 0x0000, 0x0000 }, /* R14108 */ - { 0x0000, 0x0000, 0x0000 }, /* R14109 */ - { 0x0000, 0x0000, 0x0000 }, /* R14110 */ - { 0x0000, 0x0000, 0x0000 }, /* R14111 */ - { 0x0000, 0x0000, 0x0000 }, /* R14112 */ - { 0x0000, 0x0000, 0x0000 }, /* R14113 */ - { 0x0000, 0x0000, 0x0000 }, /* R14114 */ - { 0x0000, 0x0000, 0x0000 }, /* R14115 */ - { 0x0000, 0x0000, 0x0000 }, /* R14116 */ - { 0x0000, 0x0000, 0x0000 }, /* R14117 */ - { 0x0000, 0x0000, 0x0000 }, /* R14118 */ - { 0x0000, 0x0000, 0x0000 }, /* R14119 */ - { 0x0000, 0x0000, 0x0000 }, /* R14120 */ - { 0x0000, 0x0000, 0x0000 }, /* R14121 */ - { 0x0000, 0x0000, 0x0000 }, /* R14122 */ - { 0x0000, 0x0000, 0x0000 }, /* R14123 */ - { 0x0000, 0x0000, 0x0000 }, /* R14124 */ - { 0x0000, 0x0000, 0x0000 }, /* R14125 */ - { 0x0000, 0x0000, 0x0000 }, /* R14126 */ - { 0x0000, 0x0000, 0x0000 }, /* R14127 */ - { 0x0000, 0x0000, 0x0000 }, /* R14128 */ - { 0x0000, 0x0000, 0x0000 }, /* R14129 */ - { 0x0000, 0x0000, 0x0000 }, /* R14130 */ - { 0x0000, 0x0000, 0x0000 }, /* R14131 */ - { 0x0000, 0x0000, 0x0000 }, /* R14132 */ - { 0x0000, 0x0000, 0x0000 }, /* R14133 */ - { 0x0000, 0x0000, 0x0000 }, /* R14134 */ - { 0x0000, 0x0000, 0x0000 }, /* R14135 */ - { 0x0000, 0x0000, 0x0000 }, /* R14136 */ - { 0x0000, 0x0000, 0x0000 }, /* R14137 */ - { 0x0000, 0x0000, 0x0000 }, /* R14138 */ - { 0x0000, 0x0000, 0x0000 }, /* R14139 */ - { 0x0000, 0x0000, 0x0000 }, /* R14140 */ - { 0x0000, 0x0000, 0x0000 }, /* R14141 */ - { 0x0000, 0x0000, 0x0000 }, /* R14142 */ - { 0x0000, 0x0000, 0x0000 }, /* R14143 */ - { 0x0000, 0x0000, 0x0000 }, /* R14144 */ - { 0x0000, 0x0000, 0x0000 }, /* R14145 */ - { 0x0000, 0x0000, 0x0000 }, /* R14146 */ - { 0x0000, 0x0000, 0x0000 }, /* R14147 */ - { 0x0000, 0x0000, 0x0000 }, /* R14148 */ - { 0x0000, 0x0000, 0x0000 }, /* R14149 */ - { 0x0000, 0x0000, 0x0000 }, /* R14150 */ - { 0x0000, 0x0000, 0x0000 }, /* R14151 */ - { 0x0000, 0x0000, 0x0000 }, /* R14152 */ - { 0x0000, 0x0000, 0x0000 }, /* R14153 */ - { 0x0000, 0x0000, 0x0000 }, /* R14154 */ - { 0x0000, 0x0000, 0x0000 }, /* R14155 */ - { 0x0000, 0x0000, 0x0000 }, /* R14156 */ - { 0x0000, 0x0000, 0x0000 }, /* R14157 */ - { 0x0000, 0x0000, 0x0000 }, /* R14158 */ - { 0x0000, 0x0000, 0x0000 }, /* R14159 */ - { 0x0000, 0x0000, 0x0000 }, /* R14160 */ - { 0x0000, 0x0000, 0x0000 }, /* R14161 */ - { 0x0000, 0x0000, 0x0000 }, /* R14162 */ - { 0x0000, 0x0000, 0x0000 }, /* R14163 */ - { 0x0000, 0x0000, 0x0000 }, /* R14164 */ - { 0x0000, 0x0000, 0x0000 }, /* R14165 */ - { 0x0000, 0x0000, 0x0000 }, /* R14166 */ - { 0x0000, 0x0000, 0x0000 }, /* R14167 */ - { 0x0000, 0x0000, 0x0000 }, /* R14168 */ - { 0x0000, 0x0000, 0x0000 }, /* R14169 */ - { 0x0000, 0x0000, 0x0000 }, /* R14170 */ - { 0x0000, 0x0000, 0x0000 }, /* R14171 */ - { 0x0000, 0x0000, 0x0000 }, /* R14172 */ - { 0x0000, 0x0000, 0x0000 }, /* R14173 */ - { 0x0000, 0x0000, 0x0000 }, /* R14174 */ - { 0x0000, 0x0000, 0x0000 }, /* R14175 */ - { 0x0000, 0x0000, 0x0000 }, /* R14176 */ - { 0x0000, 0x0000, 0x0000 }, /* R14177 */ - { 0x0000, 0x0000, 0x0000 }, /* R14178 */ - { 0x0000, 0x0000, 0x0000 }, /* R14179 */ - { 0x0000, 0x0000, 0x0000 }, /* R14180 */ - { 0x0000, 0x0000, 0x0000 }, /* R14181 */ - { 0x0000, 0x0000, 0x0000 }, /* R14182 */ - { 0x0000, 0x0000, 0x0000 }, /* R14183 */ - { 0x0000, 0x0000, 0x0000 }, /* R14184 */ - { 0x0000, 0x0000, 0x0000 }, /* R14185 */ - { 0x0000, 0x0000, 0x0000 }, /* R14186 */ - { 0x0000, 0x0000, 0x0000 }, /* R14187 */ - { 0x0000, 0x0000, 0x0000 }, /* R14188 */ - { 0x0000, 0x0000, 0x0000 }, /* R14189 */ - { 0x0000, 0x0000, 0x0000 }, /* R14190 */ - { 0x0000, 0x0000, 0x0000 }, /* R14191 */ - { 0x0000, 0x0000, 0x0000 }, /* R14192 */ - { 0x0000, 0x0000, 0x0000 }, /* R14193 */ - { 0x0000, 0x0000, 0x0000 }, /* R14194 */ - { 0x0000, 0x0000, 0x0000 }, /* R14195 */ - { 0x0000, 0x0000, 0x0000 }, /* R14196 */ - { 0x0000, 0x0000, 0x0000 }, /* R14197 */ - { 0x0000, 0x0000, 0x0000 }, /* R14198 */ - { 0x0000, 0x0000, 0x0000 }, /* R14199 */ - { 0x0000, 0x0000, 0x0000 }, /* R14200 */ - { 0x0000, 0x0000, 0x0000 }, /* R14201 */ - { 0x0000, 0x0000, 0x0000 }, /* R14202 */ - { 0x0000, 0x0000, 0x0000 }, /* R14203 */ - { 0x0000, 0x0000, 0x0000 }, /* R14204 */ - { 0x0000, 0x0000, 0x0000 }, /* R14205 */ - { 0x0000, 0x0000, 0x0000 }, /* R14206 */ - { 0x0000, 0x0000, 0x0000 }, /* R14207 */ - { 0x0000, 0x0000, 0x0000 }, /* R14208 */ - { 0x0000, 0x0000, 0x0000 }, /* R14209 */ - { 0x0000, 0x0000, 0x0000 }, /* R14210 */ - { 0x0000, 0x0000, 0x0000 }, /* R14211 */ - { 0x0000, 0x0000, 0x0000 }, /* R14212 */ - { 0x0000, 0x0000, 0x0000 }, /* R14213 */ - { 0x0000, 0x0000, 0x0000 }, /* R14214 */ - { 0x0000, 0x0000, 0x0000 }, /* R14215 */ - { 0x0000, 0x0000, 0x0000 }, /* R14216 */ - { 0x0000, 0x0000, 0x0000 }, /* R14217 */ - { 0x0000, 0x0000, 0x0000 }, /* R14218 */ - { 0x0000, 0x0000, 0x0000 }, /* R14219 */ - { 0x0000, 0x0000, 0x0000 }, /* R14220 */ - { 0x0000, 0x0000, 0x0000 }, /* R14221 */ - { 0x0000, 0x0000, 0x0000 }, /* R14222 */ - { 0x0000, 0x0000, 0x0000 }, /* R14223 */ - { 0x0000, 0x0000, 0x0000 }, /* R14224 */ - { 0x0000, 0x0000, 0x0000 }, /* R14225 */ - { 0x0000, 0x0000, 0x0000 }, /* R14226 */ - { 0x0000, 0x0000, 0x0000 }, /* R14227 */ - { 0x0000, 0x0000, 0x0000 }, /* R14228 */ - { 0x0000, 0x0000, 0x0000 }, /* R14229 */ - { 0x0000, 0x0000, 0x0000 }, /* R14230 */ - { 0x0000, 0x0000, 0x0000 }, /* R14231 */ - { 0x0000, 0x0000, 0x0000 }, /* R14232 */ - { 0x0000, 0x0000, 0x0000 }, /* R14233 */ - { 0x0000, 0x0000, 0x0000 }, /* R14234 */ - { 0x0000, 0x0000, 0x0000 }, /* R14235 */ - { 0x0000, 0x0000, 0x0000 }, /* R14236 */ - { 0x0000, 0x0000, 0x0000 }, /* R14237 */ - { 0x0000, 0x0000, 0x0000 }, /* R14238 */ - { 0x0000, 0x0000, 0x0000 }, /* R14239 */ - { 0x0000, 0x0000, 0x0000 }, /* R14240 */ - { 0x0000, 0x0000, 0x0000 }, /* R14241 */ - { 0x0000, 0x0000, 0x0000 }, /* R14242 */ - { 0x0000, 0x0000, 0x0000 }, /* R14243 */ - { 0x0000, 0x0000, 0x0000 }, /* R14244 */ - { 0x0000, 0x0000, 0x0000 }, /* R14245 */ - { 0x0000, 0x0000, 0x0000 }, /* R14246 */ - { 0x0000, 0x0000, 0x0000 }, /* R14247 */ - { 0x0000, 0x0000, 0x0000 }, /* R14248 */ - { 0x0000, 0x0000, 0x0000 }, /* R14249 */ - { 0x0000, 0x0000, 0x0000 }, /* R14250 */ - { 0x0000, 0x0000, 0x0000 }, /* R14251 */ - { 0x0000, 0x0000, 0x0000 }, /* R14252 */ - { 0x0000, 0x0000, 0x0000 }, /* R14253 */ - { 0x0000, 0x0000, 0x0000 }, /* R14254 */ - { 0x0000, 0x0000, 0x0000 }, /* R14255 */ - { 0x0000, 0x0000, 0x0000 }, /* R14256 */ - { 0x0000, 0x0000, 0x0000 }, /* R14257 */ - { 0x0000, 0x0000, 0x0000 }, /* R14258 */ - { 0x0000, 0x0000, 0x0000 }, /* R14259 */ - { 0x0000, 0x0000, 0x0000 }, /* R14260 */ - { 0x0000, 0x0000, 0x0000 }, /* R14261 */ - { 0x0000, 0x0000, 0x0000 }, /* R14262 */ - { 0x0000, 0x0000, 0x0000 }, /* R14263 */ - { 0x0000, 0x0000, 0x0000 }, /* R14264 */ - { 0x0000, 0x0000, 0x0000 }, /* R14265 */ - { 0x0000, 0x0000, 0x0000 }, /* R14266 */ - { 0x0000, 0x0000, 0x0000 }, /* R14267 */ - { 0x0000, 0x0000, 0x0000 }, /* R14268 */ - { 0x0000, 0x0000, 0x0000 }, /* R14269 */ - { 0x0000, 0x0000, 0x0000 }, /* R14270 */ - { 0x0000, 0x0000, 0x0000 }, /* R14271 */ - { 0x0000, 0x0000, 0x0000 }, /* R14272 */ - { 0x0000, 0x0000, 0x0000 }, /* R14273 */ - { 0x0000, 0x0000, 0x0000 }, /* R14274 */ - { 0x0000, 0x0000, 0x0000 }, /* R14275 */ - { 0x0000, 0x0000, 0x0000 }, /* R14276 */ - { 0x0000, 0x0000, 0x0000 }, /* R14277 */ - { 0x0000, 0x0000, 0x0000 }, /* R14278 */ - { 0x0000, 0x0000, 0x0000 }, /* R14279 */ - { 0x0000, 0x0000, 0x0000 }, /* R14280 */ - { 0x0000, 0x0000, 0x0000 }, /* R14281 */ - { 0x0000, 0x0000, 0x0000 }, /* R14282 */ - { 0x0000, 0x0000, 0x0000 }, /* R14283 */ - { 0x0000, 0x0000, 0x0000 }, /* R14284 */ - { 0x0000, 0x0000, 0x0000 }, /* R14285 */ - { 0x0000, 0x0000, 0x0000 }, /* R14286 */ - { 0x0000, 0x0000, 0x0000 }, /* R14287 */ - { 0x0000, 0x0000, 0x0000 }, /* R14288 */ - { 0x0000, 0x0000, 0x0000 }, /* R14289 */ - { 0x0000, 0x0000, 0x0000 }, /* R14290 */ - { 0x0000, 0x0000, 0x0000 }, /* R14291 */ - { 0x0000, 0x0000, 0x0000 }, /* R14292 */ - { 0x0000, 0x0000, 0x0000 }, /* R14293 */ - { 0x0000, 0x0000, 0x0000 }, /* R14294 */ - { 0x0000, 0x0000, 0x0000 }, /* R14295 */ - { 0x0000, 0x0000, 0x0000 }, /* R14296 */ - { 0x0000, 0x0000, 0x0000 }, /* R14297 */ - { 0x0000, 0x0000, 0x0000 }, /* R14298 */ - { 0x0000, 0x0000, 0x0000 }, /* R14299 */ - { 0x0000, 0x0000, 0x0000 }, /* R14300 */ - { 0x0000, 0x0000, 0x0000 }, /* R14301 */ - { 0x0000, 0x0000, 0x0000 }, /* R14302 */ - { 0x0000, 0x0000, 0x0000 }, /* R14303 */ - { 0x0000, 0x0000, 0x0000 }, /* R14304 */ - { 0x0000, 0x0000, 0x0000 }, /* R14305 */ - { 0x0000, 0x0000, 0x0000 }, /* R14306 */ - { 0x0000, 0x0000, 0x0000 }, /* R14307 */ - { 0x0000, 0x0000, 0x0000 }, /* R14308 */ - { 0x0000, 0x0000, 0x0000 }, /* R14309 */ - { 0x0000, 0x0000, 0x0000 }, /* R14310 */ - { 0x0000, 0x0000, 0x0000 }, /* R14311 */ - { 0x0000, 0x0000, 0x0000 }, /* R14312 */ - { 0x0000, 0x0000, 0x0000 }, /* R14313 */ - { 0x0000, 0x0000, 0x0000 }, /* R14314 */ - { 0x0000, 0x0000, 0x0000 }, /* R14315 */ - { 0x0000, 0x0000, 0x0000 }, /* R14316 */ - { 0x0000, 0x0000, 0x0000 }, /* R14317 */ - { 0x0000, 0x0000, 0x0000 }, /* R14318 */ - { 0x0000, 0x0000, 0x0000 }, /* R14319 */ - { 0x0000, 0x0000, 0x0000 }, /* R14320 */ - { 0x0000, 0x0000, 0x0000 }, /* R14321 */ - { 0x0000, 0x0000, 0x0000 }, /* R14322 */ - { 0x0000, 0x0000, 0x0000 }, /* R14323 */ - { 0x0000, 0x0000, 0x0000 }, /* R14324 */ - { 0x0000, 0x0000, 0x0000 }, /* R14325 */ - { 0x0000, 0x0000, 0x0000 }, /* R14326 */ - { 0x0000, 0x0000, 0x0000 }, /* R14327 */ - { 0x0000, 0x0000, 0x0000 }, /* R14328 */ - { 0x0000, 0x0000, 0x0000 }, /* R14329 */ - { 0x0000, 0x0000, 0x0000 }, /* R14330 */ - { 0x0000, 0x0000, 0x0000 }, /* R14331 */ - { 0x0000, 0x0000, 0x0000 }, /* R14332 */ - { 0x0000, 0x0000, 0x0000 }, /* R14333 */ - { 0x0000, 0x0000, 0x0000 }, /* R14334 */ - { 0x0000, 0x0000, 0x0000 }, /* R14335 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R14336 - DSP2 Data3 RAM 1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R14337 - DSP2 Data3 RAM 0 */ - { 0x0000, 0x0000, 0x0000 }, /* R14338 */ - { 0x0000, 0x0000, 0x0000 }, /* R14339 */ - { 0x0000, 0x0000, 0x0000 }, /* R14340 */ - { 0x0000, 0x0000, 0x0000 }, /* R14341 */ - { 0x0000, 0x0000, 0x0000 }, /* R14342 */ - { 0x0000, 0x0000, 0x0000 }, /* R14343 */ - { 0x0000, 0x0000, 0x0000 }, /* R14344 */ - { 0x0000, 0x0000, 0x0000 }, /* R14345 */ - { 0x0000, 0x0000, 0x0000 }, /* R14346 */ - { 0x0000, 0x0000, 0x0000 }, /* R14347 */ - { 0x0000, 0x0000, 0x0000 }, /* R14348 */ - { 0x0000, 0x0000, 0x0000 }, /* R14349 */ - { 0x0000, 0x0000, 0x0000 }, /* R14350 */ - { 0x0000, 0x0000, 0x0000 }, /* R14351 */ - { 0x0000, 0x0000, 0x0000 }, /* R14352 */ - { 0x0000, 0x0000, 0x0000 }, /* R14353 */ - { 0x0000, 0x0000, 0x0000 }, /* R14354 */ - { 0x0000, 0x0000, 0x0000 }, /* R14355 */ - { 0x0000, 0x0000, 0x0000 }, /* R14356 */ - { 0x0000, 0x0000, 0x0000 }, /* R14357 */ - { 0x0000, 0x0000, 0x0000 }, /* R14358 */ - { 0x0000, 0x0000, 0x0000 }, /* R14359 */ - { 0x0000, 0x0000, 0x0000 }, /* R14360 */ - { 0x0000, 0x0000, 0x0000 }, /* R14361 */ - { 0x0000, 0x0000, 0x0000 }, /* R14362 */ - { 0x0000, 0x0000, 0x0000 }, /* R14363 */ - { 0x0000, 0x0000, 0x0000 }, /* R14364 */ - { 0x0000, 0x0000, 0x0000 }, /* R14365 */ - { 0x0000, 0x0000, 0x0000 }, /* R14366 */ - { 0x0000, 0x0000, 0x0000 }, /* R14367 */ - { 0x0000, 0x0000, 0x0000 }, /* R14368 */ - { 0x0000, 0x0000, 0x0000 }, /* R14369 */ - { 0x0000, 0x0000, 0x0000 }, /* R14370 */ - { 0x0000, 0x0000, 0x0000 }, /* R14371 */ - { 0x0000, 0x0000, 0x0000 }, /* R14372 */ - { 0x0000, 0x0000, 0x0000 }, /* R14373 */ - { 0x0000, 0x0000, 0x0000 }, /* R14374 */ - { 0x0000, 0x0000, 0x0000 }, /* R14375 */ - { 0x0000, 0x0000, 0x0000 }, /* R14376 */ - { 0x0000, 0x0000, 0x0000 }, /* R14377 */ - { 0x0000, 0x0000, 0x0000 }, /* R14378 */ - { 0x0000, 0x0000, 0x0000 }, /* R14379 */ - { 0x0000, 0x0000, 0x0000 }, /* R14380 */ - { 0x0000, 0x0000, 0x0000 }, /* R14381 */ - { 0x0000, 0x0000, 0x0000 }, /* R14382 */ - { 0x0000, 0x0000, 0x0000 }, /* R14383 */ - { 0x0000, 0x0000, 0x0000 }, /* R14384 */ - { 0x0000, 0x0000, 0x0000 }, /* R14385 */ - { 0x0000, 0x0000, 0x0000 }, /* R14386 */ - { 0x0000, 0x0000, 0x0000 }, /* R14387 */ - { 0x0000, 0x0000, 0x0000 }, /* R14388 */ - { 0x0000, 0x0000, 0x0000 }, /* R14389 */ - { 0x0000, 0x0000, 0x0000 }, /* R14390 */ - { 0x0000, 0x0000, 0x0000 }, /* R14391 */ - { 0x0000, 0x0000, 0x0000 }, /* R14392 */ - { 0x0000, 0x0000, 0x0000 }, /* R14393 */ - { 0x0000, 0x0000, 0x0000 }, /* R14394 */ - { 0x0000, 0x0000, 0x0000 }, /* R14395 */ - { 0x0000, 0x0000, 0x0000 }, /* R14396 */ - { 0x0000, 0x0000, 0x0000 }, /* R14397 */ - { 0x0000, 0x0000, 0x0000 }, /* R14398 */ - { 0x0000, 0x0000, 0x0000 }, /* R14399 */ - { 0x0000, 0x0000, 0x0000 }, /* R14400 */ - { 0x0000, 0x0000, 0x0000 }, /* R14401 */ - { 0x0000, 0x0000, 0x0000 }, /* R14402 */ - { 0x0000, 0x0000, 0x0000 }, /* R14403 */ - { 0x0000, 0x0000, 0x0000 }, /* R14404 */ - { 0x0000, 0x0000, 0x0000 }, /* R14405 */ - { 0x0000, 0x0000, 0x0000 }, /* R14406 */ - { 0x0000, 0x0000, 0x0000 }, /* R14407 */ - { 0x0000, 0x0000, 0x0000 }, /* R14408 */ - { 0x0000, 0x0000, 0x0000 }, /* R14409 */ - { 0x0000, 0x0000, 0x0000 }, /* R14410 */ - { 0x0000, 0x0000, 0x0000 }, /* R14411 */ - { 0x0000, 0x0000, 0x0000 }, /* R14412 */ - { 0x0000, 0x0000, 0x0000 }, /* R14413 */ - { 0x0000, 0x0000, 0x0000 }, /* R14414 */ - { 0x0000, 0x0000, 0x0000 }, /* R14415 */ - { 0x0000, 0x0000, 0x0000 }, /* R14416 */ - { 0x0000, 0x0000, 0x0000 }, /* R14417 */ - { 0x0000, 0x0000, 0x0000 }, /* R14418 */ - { 0x0000, 0x0000, 0x0000 }, /* R14419 */ - { 0x0000, 0x0000, 0x0000 }, /* R14420 */ - { 0x0000, 0x0000, 0x0000 }, /* R14421 */ - { 0x0000, 0x0000, 0x0000 }, /* R14422 */ - { 0x0000, 0x0000, 0x0000 }, /* R14423 */ - { 0x0000, 0x0000, 0x0000 }, /* R14424 */ - { 0x0000, 0x0000, 0x0000 }, /* R14425 */ - { 0x0000, 0x0000, 0x0000 }, /* R14426 */ - { 0x0000, 0x0000, 0x0000 }, /* R14427 */ - { 0x0000, 0x0000, 0x0000 }, /* R14428 */ - { 0x0000, 0x0000, 0x0000 }, /* R14429 */ - { 0x0000, 0x0000, 0x0000 }, /* R14430 */ - { 0x0000, 0x0000, 0x0000 }, /* R14431 */ - { 0x0000, 0x0000, 0x0000 }, /* R14432 */ - { 0x0000, 0x0000, 0x0000 }, /* R14433 */ - { 0x0000, 0x0000, 0x0000 }, /* R14434 */ - { 0x0000, 0x0000, 0x0000 }, /* R14435 */ - { 0x0000, 0x0000, 0x0000 }, /* R14436 */ - { 0x0000, 0x0000, 0x0000 }, /* R14437 */ - { 0x0000, 0x0000, 0x0000 }, /* R14438 */ - { 0x0000, 0x0000, 0x0000 }, /* R14439 */ - { 0x0000, 0x0000, 0x0000 }, /* R14440 */ - { 0x0000, 0x0000, 0x0000 }, /* R14441 */ - { 0x0000, 0x0000, 0x0000 }, /* R14442 */ - { 0x0000, 0x0000, 0x0000 }, /* R14443 */ - { 0x0000, 0x0000, 0x0000 }, /* R14444 */ - { 0x0000, 0x0000, 0x0000 }, /* R14445 */ - { 0x0000, 0x0000, 0x0000 }, /* R14446 */ - { 0x0000, 0x0000, 0x0000 }, /* R14447 */ - { 0x0000, 0x0000, 0x0000 }, /* R14448 */ - { 0x0000, 0x0000, 0x0000 }, /* R14449 */ - { 0x0000, 0x0000, 0x0000 }, /* R14450 */ - { 0x0000, 0x0000, 0x0000 }, /* R14451 */ - { 0x0000, 0x0000, 0x0000 }, /* R14452 */ - { 0x0000, 0x0000, 0x0000 }, /* R14453 */ - { 0x0000, 0x0000, 0x0000 }, /* R14454 */ - { 0x0000, 0x0000, 0x0000 }, /* R14455 */ - { 0x0000, 0x0000, 0x0000 }, /* R14456 */ - { 0x0000, 0x0000, 0x0000 }, /* R14457 */ - { 0x0000, 0x0000, 0x0000 }, /* R14458 */ - { 0x0000, 0x0000, 0x0000 }, /* R14459 */ - { 0x0000, 0x0000, 0x0000 }, /* R14460 */ - { 0x0000, 0x0000, 0x0000 }, /* R14461 */ - { 0x0000, 0x0000, 0x0000 }, /* R14462 */ - { 0x0000, 0x0000, 0x0000 }, /* R14463 */ - { 0x0000, 0x0000, 0x0000 }, /* R14464 */ - { 0x0000, 0x0000, 0x0000 }, /* R14465 */ - { 0x0000, 0x0000, 0x0000 }, /* R14466 */ - { 0x0000, 0x0000, 0x0000 }, /* R14467 */ - { 0x0000, 0x0000, 0x0000 }, /* R14468 */ - { 0x0000, 0x0000, 0x0000 }, /* R14469 */ - { 0x0000, 0x0000, 0x0000 }, /* R14470 */ - { 0x0000, 0x0000, 0x0000 }, /* R14471 */ - { 0x0000, 0x0000, 0x0000 }, /* R14472 */ - { 0x0000, 0x0000, 0x0000 }, /* R14473 */ - { 0x0000, 0x0000, 0x0000 }, /* R14474 */ - { 0x0000, 0x0000, 0x0000 }, /* R14475 */ - { 0x0000, 0x0000, 0x0000 }, /* R14476 */ - { 0x0000, 0x0000, 0x0000 }, /* R14477 */ - { 0x0000, 0x0000, 0x0000 }, /* R14478 */ - { 0x0000, 0x0000, 0x0000 }, /* R14479 */ - { 0x0000, 0x0000, 0x0000 }, /* R14480 */ - { 0x0000, 0x0000, 0x0000 }, /* R14481 */ - { 0x0000, 0x0000, 0x0000 }, /* R14482 */ - { 0x0000, 0x0000, 0x0000 }, /* R14483 */ - { 0x0000, 0x0000, 0x0000 }, /* R14484 */ - { 0x0000, 0x0000, 0x0000 }, /* R14485 */ - { 0x0000, 0x0000, 0x0000 }, /* R14486 */ - { 0x0000, 0x0000, 0x0000 }, /* R14487 */ - { 0x0000, 0x0000, 0x0000 }, /* R14488 */ - { 0x0000, 0x0000, 0x0000 }, /* R14489 */ - { 0x0000, 0x0000, 0x0000 }, /* R14490 */ - { 0x0000, 0x0000, 0x0000 }, /* R14491 */ - { 0x0000, 0x0000, 0x0000 }, /* R14492 */ - { 0x0000, 0x0000, 0x0000 }, /* R14493 */ - { 0x0000, 0x0000, 0x0000 }, /* R14494 */ - { 0x0000, 0x0000, 0x0000 }, /* R14495 */ - { 0x0000, 0x0000, 0x0000 }, /* R14496 */ - { 0x0000, 0x0000, 0x0000 }, /* R14497 */ - { 0x0000, 0x0000, 0x0000 }, /* R14498 */ - { 0x0000, 0x0000, 0x0000 }, /* R14499 */ - { 0x0000, 0x0000, 0x0000 }, /* R14500 */ - { 0x0000, 0x0000, 0x0000 }, /* R14501 */ - { 0x0000, 0x0000, 0x0000 }, /* R14502 */ - { 0x0000, 0x0000, 0x0000 }, /* R14503 */ - { 0x0000, 0x0000, 0x0000 }, /* R14504 */ - { 0x0000, 0x0000, 0x0000 }, /* R14505 */ - { 0x0000, 0x0000, 0x0000 }, /* R14506 */ - { 0x0000, 0x0000, 0x0000 }, /* R14507 */ - { 0x0000, 0x0000, 0x0000 }, /* R14508 */ - { 0x0000, 0x0000, 0x0000 }, /* R14509 */ - { 0x0000, 0x0000, 0x0000 }, /* R14510 */ - { 0x0000, 0x0000, 0x0000 }, /* R14511 */ - { 0x0000, 0x0000, 0x0000 }, /* R14512 */ - { 0x0000, 0x0000, 0x0000 }, /* R14513 */ - { 0x0000, 0x0000, 0x0000 }, /* R14514 */ - { 0x0000, 0x0000, 0x0000 }, /* R14515 */ - { 0x0000, 0x0000, 0x0000 }, /* R14516 */ - { 0x0000, 0x0000, 0x0000 }, /* R14517 */ - { 0x0000, 0x0000, 0x0000 }, /* R14518 */ - { 0x0000, 0x0000, 0x0000 }, /* R14519 */ - { 0x0000, 0x0000, 0x0000 }, /* R14520 */ - { 0x0000, 0x0000, 0x0000 }, /* R14521 */ - { 0x0000, 0x0000, 0x0000 }, /* R14522 */ - { 0x0000, 0x0000, 0x0000 }, /* R14523 */ - { 0x0000, 0x0000, 0x0000 }, /* R14524 */ - { 0x0000, 0x0000, 0x0000 }, /* R14525 */ - { 0x0000, 0x0000, 0x0000 }, /* R14526 */ - { 0x0000, 0x0000, 0x0000 }, /* R14527 */ - { 0x0000, 0x0000, 0x0000 }, /* R14528 */ - { 0x0000, 0x0000, 0x0000 }, /* R14529 */ - { 0x0000, 0x0000, 0x0000 }, /* R14530 */ - { 0x0000, 0x0000, 0x0000 }, /* R14531 */ - { 0x0000, 0x0000, 0x0000 }, /* R14532 */ - { 0x0000, 0x0000, 0x0000 }, /* R14533 */ - { 0x0000, 0x0000, 0x0000 }, /* R14534 */ - { 0x0000, 0x0000, 0x0000 }, /* R14535 */ - { 0x0000, 0x0000, 0x0000 }, /* R14536 */ - { 0x0000, 0x0000, 0x0000 }, /* R14537 */ - { 0x0000, 0x0000, 0x0000 }, /* R14538 */ - { 0x0000, 0x0000, 0x0000 }, /* R14539 */ - { 0x0000, 0x0000, 0x0000 }, /* R14540 */ - { 0x0000, 0x0000, 0x0000 }, /* R14541 */ - { 0x0000, 0x0000, 0x0000 }, /* R14542 */ - { 0x0000, 0x0000, 0x0000 }, /* R14543 */ - { 0x0000, 0x0000, 0x0000 }, /* R14544 */ - { 0x0000, 0x0000, 0x0000 }, /* R14545 */ - { 0x0000, 0x0000, 0x0000 }, /* R14546 */ - { 0x0000, 0x0000, 0x0000 }, /* R14547 */ - { 0x0000, 0x0000, 0x0000 }, /* R14548 */ - { 0x0000, 0x0000, 0x0000 }, /* R14549 */ - { 0x0000, 0x0000, 0x0000 }, /* R14550 */ - { 0x0000, 0x0000, 0x0000 }, /* R14551 */ - { 0x0000, 0x0000, 0x0000 }, /* R14552 */ - { 0x0000, 0x0000, 0x0000 }, /* R14553 */ - { 0x0000, 0x0000, 0x0000 }, /* R14554 */ - { 0x0000, 0x0000, 0x0000 }, /* R14555 */ - { 0x0000, 0x0000, 0x0000 }, /* R14556 */ - { 0x0000, 0x0000, 0x0000 }, /* R14557 */ - { 0x0000, 0x0000, 0x0000 }, /* R14558 */ - { 0x0000, 0x0000, 0x0000 }, /* R14559 */ - { 0x0000, 0x0000, 0x0000 }, /* R14560 */ - { 0x0000, 0x0000, 0x0000 }, /* R14561 */ - { 0x0000, 0x0000, 0x0000 }, /* R14562 */ - { 0x0000, 0x0000, 0x0000 }, /* R14563 */ - { 0x0000, 0x0000, 0x0000 }, /* R14564 */ - { 0x0000, 0x0000, 0x0000 }, /* R14565 */ - { 0x0000, 0x0000, 0x0000 }, /* R14566 */ - { 0x0000, 0x0000, 0x0000 }, /* R14567 */ - { 0x0000, 0x0000, 0x0000 }, /* R14568 */ - { 0x0000, 0x0000, 0x0000 }, /* R14569 */ - { 0x0000, 0x0000, 0x0000 }, /* R14570 */ - { 0x0000, 0x0000, 0x0000 }, /* R14571 */ - { 0x0000, 0x0000, 0x0000 }, /* R14572 */ - { 0x0000, 0x0000, 0x0000 }, /* R14573 */ - { 0x0000, 0x0000, 0x0000 }, /* R14574 */ - { 0x0000, 0x0000, 0x0000 }, /* R14575 */ - { 0x0000, 0x0000, 0x0000 }, /* R14576 */ - { 0x0000, 0x0000, 0x0000 }, /* R14577 */ - { 0x0000, 0x0000, 0x0000 }, /* R14578 */ - { 0x0000, 0x0000, 0x0000 }, /* R14579 */ - { 0x0000, 0x0000, 0x0000 }, /* R14580 */ - { 0x0000, 0x0000, 0x0000 }, /* R14581 */ - { 0x0000, 0x0000, 0x0000 }, /* R14582 */ - { 0x0000, 0x0000, 0x0000 }, /* R14583 */ - { 0x0000, 0x0000, 0x0000 }, /* R14584 */ - { 0x0000, 0x0000, 0x0000 }, /* R14585 */ - { 0x0000, 0x0000, 0x0000 }, /* R14586 */ - { 0x0000, 0x0000, 0x0000 }, /* R14587 */ - { 0x0000, 0x0000, 0x0000 }, /* R14588 */ - { 0x0000, 0x0000, 0x0000 }, /* R14589 */ - { 0x0000, 0x0000, 0x0000 }, /* R14590 */ - { 0x0000, 0x0000, 0x0000 }, /* R14591 */ - { 0x0000, 0x0000, 0x0000 }, /* R14592 */ - { 0x0000, 0x0000, 0x0000 }, /* R14593 */ - { 0x0000, 0x0000, 0x0000 }, /* R14594 */ - { 0x0000, 0x0000, 0x0000 }, /* R14595 */ - { 0x0000, 0x0000, 0x0000 }, /* R14596 */ - { 0x0000, 0x0000, 0x0000 }, /* R14597 */ - { 0x0000, 0x0000, 0x0000 }, /* R14598 */ - { 0x0000, 0x0000, 0x0000 }, /* R14599 */ - { 0x0000, 0x0000, 0x0000 }, /* R14600 */ - { 0x0000, 0x0000, 0x0000 }, /* R14601 */ - { 0x0000, 0x0000, 0x0000 }, /* R14602 */ - { 0x0000, 0x0000, 0x0000 }, /* R14603 */ - { 0x0000, 0x0000, 0x0000 }, /* R14604 */ - { 0x0000, 0x0000, 0x0000 }, /* R14605 */ - { 0x0000, 0x0000, 0x0000 }, /* R14606 */ - { 0x0000, 0x0000, 0x0000 }, /* R14607 */ - { 0x0000, 0x0000, 0x0000 }, /* R14608 */ - { 0x0000, 0x0000, 0x0000 }, /* R14609 */ - { 0x0000, 0x0000, 0x0000 }, /* R14610 */ - { 0x0000, 0x0000, 0x0000 }, /* R14611 */ - { 0x0000, 0x0000, 0x0000 }, /* R14612 */ - { 0x0000, 0x0000, 0x0000 }, /* R14613 */ - { 0x0000, 0x0000, 0x0000 }, /* R14614 */ - { 0x0000, 0x0000, 0x0000 }, /* R14615 */ - { 0x0000, 0x0000, 0x0000 }, /* R14616 */ - { 0x0000, 0x0000, 0x0000 }, /* R14617 */ - { 0x0000, 0x0000, 0x0000 }, /* R14618 */ - { 0x0000, 0x0000, 0x0000 }, /* R14619 */ - { 0x0000, 0x0000, 0x0000 }, /* R14620 */ - { 0x0000, 0x0000, 0x0000 }, /* R14621 */ - { 0x0000, 0x0000, 0x0000 }, /* R14622 */ - { 0x0000, 0x0000, 0x0000 }, /* R14623 */ - { 0x0000, 0x0000, 0x0000 }, /* R14624 */ - { 0x0000, 0x0000, 0x0000 }, /* R14625 */ - { 0x0000, 0x0000, 0x0000 }, /* R14626 */ - { 0x0000, 0x0000, 0x0000 }, /* R14627 */ - { 0x0000, 0x0000, 0x0000 }, /* R14628 */ - { 0x0000, 0x0000, 0x0000 }, /* R14629 */ - { 0x0000, 0x0000, 0x0000 }, /* R14630 */ - { 0x0000, 0x0000, 0x0000 }, /* R14631 */ - { 0x0000, 0x0000, 0x0000 }, /* R14632 */ - { 0x0000, 0x0000, 0x0000 }, /* R14633 */ - { 0x0000, 0x0000, 0x0000 }, /* R14634 */ - { 0x0000, 0x0000, 0x0000 }, /* R14635 */ - { 0x0000, 0x0000, 0x0000 }, /* R14636 */ - { 0x0000, 0x0000, 0x0000 }, /* R14637 */ - { 0x0000, 0x0000, 0x0000 }, /* R14638 */ - { 0x0000, 0x0000, 0x0000 }, /* R14639 */ - { 0x0000, 0x0000, 0x0000 }, /* R14640 */ - { 0x0000, 0x0000, 0x0000 }, /* R14641 */ - { 0x0000, 0x0000, 0x0000 }, /* R14642 */ - { 0x0000, 0x0000, 0x0000 }, /* R14643 */ - { 0x0000, 0x0000, 0x0000 }, /* R14644 */ - { 0x0000, 0x0000, 0x0000 }, /* R14645 */ - { 0x0000, 0x0000, 0x0000 }, /* R14646 */ - { 0x0000, 0x0000, 0x0000 }, /* R14647 */ - { 0x0000, 0x0000, 0x0000 }, /* R14648 */ - { 0x0000, 0x0000, 0x0000 }, /* R14649 */ - { 0x0000, 0x0000, 0x0000 }, /* R14650 */ - { 0x0000, 0x0000, 0x0000 }, /* R14651 */ - { 0x0000, 0x0000, 0x0000 }, /* R14652 */ - { 0x0000, 0x0000, 0x0000 }, /* R14653 */ - { 0x0000, 0x0000, 0x0000 }, /* R14654 */ - { 0x0000, 0x0000, 0x0000 }, /* R14655 */ - { 0x0000, 0x0000, 0x0000 }, /* R14656 */ - { 0x0000, 0x0000, 0x0000 }, /* R14657 */ - { 0x0000, 0x0000, 0x0000 }, /* R14658 */ - { 0x0000, 0x0000, 0x0000 }, /* R14659 */ - { 0x0000, 0x0000, 0x0000 }, /* R14660 */ - { 0x0000, 0x0000, 0x0000 }, /* R14661 */ - { 0x0000, 0x0000, 0x0000 }, /* R14662 */ - { 0x0000, 0x0000, 0x0000 }, /* R14663 */ - { 0x0000, 0x0000, 0x0000 }, /* R14664 */ - { 0x0000, 0x0000, 0x0000 }, /* R14665 */ - { 0x0000, 0x0000, 0x0000 }, /* R14666 */ - { 0x0000, 0x0000, 0x0000 }, /* R14667 */ - { 0x0000, 0x0000, 0x0000 }, /* R14668 */ - { 0x0000, 0x0000, 0x0000 }, /* R14669 */ - { 0x0000, 0x0000, 0x0000 }, /* R14670 */ - { 0x0000, 0x0000, 0x0000 }, /* R14671 */ - { 0x0000, 0x0000, 0x0000 }, /* R14672 */ - { 0x0000, 0x0000, 0x0000 }, /* R14673 */ - { 0x0000, 0x0000, 0x0000 }, /* R14674 */ - { 0x0000, 0x0000, 0x0000 }, /* R14675 */ - { 0x0000, 0x0000, 0x0000 }, /* R14676 */ - { 0x0000, 0x0000, 0x0000 }, /* R14677 */ - { 0x0000, 0x0000, 0x0000 }, /* R14678 */ - { 0x0000, 0x0000, 0x0000 }, /* R14679 */ - { 0x0000, 0x0000, 0x0000 }, /* R14680 */ - { 0x0000, 0x0000, 0x0000 }, /* R14681 */ - { 0x0000, 0x0000, 0x0000 }, /* R14682 */ - { 0x0000, 0x0000, 0x0000 }, /* R14683 */ - { 0x0000, 0x0000, 0x0000 }, /* R14684 */ - { 0x0000, 0x0000, 0x0000 }, /* R14685 */ - { 0x0000, 0x0000, 0x0000 }, /* R14686 */ - { 0x0000, 0x0000, 0x0000 }, /* R14687 */ - { 0x0000, 0x0000, 0x0000 }, /* R14688 */ - { 0x0000, 0x0000, 0x0000 }, /* R14689 */ - { 0x0000, 0x0000, 0x0000 }, /* R14690 */ - { 0x0000, 0x0000, 0x0000 }, /* R14691 */ - { 0x0000, 0x0000, 0x0000 }, /* R14692 */ - { 0x0000, 0x0000, 0x0000 }, /* R14693 */ - { 0x0000, 0x0000, 0x0000 }, /* R14694 */ - { 0x0000, 0x0000, 0x0000 }, /* R14695 */ - { 0x0000, 0x0000, 0x0000 }, /* R14696 */ - { 0x0000, 0x0000, 0x0000 }, /* R14697 */ - { 0x0000, 0x0000, 0x0000 }, /* R14698 */ - { 0x0000, 0x0000, 0x0000 }, /* R14699 */ - { 0x0000, 0x0000, 0x0000 }, /* R14700 */ - { 0x0000, 0x0000, 0x0000 }, /* R14701 */ - { 0x0000, 0x0000, 0x0000 }, /* R14702 */ - { 0x0000, 0x0000, 0x0000 }, /* R14703 */ - { 0x0000, 0x0000, 0x0000 }, /* R14704 */ - { 0x0000, 0x0000, 0x0000 }, /* R14705 */ - { 0x0000, 0x0000, 0x0000 }, /* R14706 */ - { 0x0000, 0x0000, 0x0000 }, /* R14707 */ - { 0x0000, 0x0000, 0x0000 }, /* R14708 */ - { 0x0000, 0x0000, 0x0000 }, /* R14709 */ - { 0x0000, 0x0000, 0x0000 }, /* R14710 */ - { 0x0000, 0x0000, 0x0000 }, /* R14711 */ - { 0x0000, 0x0000, 0x0000 }, /* R14712 */ - { 0x0000, 0x0000, 0x0000 }, /* R14713 */ - { 0x0000, 0x0000, 0x0000 }, /* R14714 */ - { 0x0000, 0x0000, 0x0000 }, /* R14715 */ - { 0x0000, 0x0000, 0x0000 }, /* R14716 */ - { 0x0000, 0x0000, 0x0000 }, /* R14717 */ - { 0x0000, 0x0000, 0x0000 }, /* R14718 */ - { 0x0000, 0x0000, 0x0000 }, /* R14719 */ - { 0x0000, 0x0000, 0x0000 }, /* R14720 */ - { 0x0000, 0x0000, 0x0000 }, /* R14721 */ - { 0x0000, 0x0000, 0x0000 }, /* R14722 */ - { 0x0000, 0x0000, 0x0000 }, /* R14723 */ - { 0x0000, 0x0000, 0x0000 }, /* R14724 */ - { 0x0000, 0x0000, 0x0000 }, /* R14725 */ - { 0x0000, 0x0000, 0x0000 }, /* R14726 */ - { 0x0000, 0x0000, 0x0000 }, /* R14727 */ - { 0x0000, 0x0000, 0x0000 }, /* R14728 */ - { 0x0000, 0x0000, 0x0000 }, /* R14729 */ - { 0x0000, 0x0000, 0x0000 }, /* R14730 */ - { 0x0000, 0x0000, 0x0000 }, /* R14731 */ - { 0x0000, 0x0000, 0x0000 }, /* R14732 */ - { 0x0000, 0x0000, 0x0000 }, /* R14733 */ - { 0x0000, 0x0000, 0x0000 }, /* R14734 */ - { 0x0000, 0x0000, 0x0000 }, /* R14735 */ - { 0x0000, 0x0000, 0x0000 }, /* R14736 */ - { 0x0000, 0x0000, 0x0000 }, /* R14737 */ - { 0x0000, 0x0000, 0x0000 }, /* R14738 */ - { 0x0000, 0x0000, 0x0000 }, /* R14739 */ - { 0x0000, 0x0000, 0x0000 }, /* R14740 */ - { 0x0000, 0x0000, 0x0000 }, /* R14741 */ - { 0x0000, 0x0000, 0x0000 }, /* R14742 */ - { 0x0000, 0x0000, 0x0000 }, /* R14743 */ - { 0x0000, 0x0000, 0x0000 }, /* R14744 */ - { 0x0000, 0x0000, 0x0000 }, /* R14745 */ - { 0x0000, 0x0000, 0x0000 }, /* R14746 */ - { 0x0000, 0x0000, 0x0000 }, /* R14747 */ - { 0x0000, 0x0000, 0x0000 }, /* R14748 */ - { 0x0000, 0x0000, 0x0000 }, /* R14749 */ - { 0x0000, 0x0000, 0x0000 }, /* R14750 */ - { 0x0000, 0x0000, 0x0000 }, /* R14751 */ - { 0x0000, 0x0000, 0x0000 }, /* R14752 */ - { 0x0000, 0x0000, 0x0000 }, /* R14753 */ - { 0x0000, 0x0000, 0x0000 }, /* R14754 */ - { 0x0000, 0x0000, 0x0000 }, /* R14755 */ - { 0x0000, 0x0000, 0x0000 }, /* R14756 */ - { 0x0000, 0x0000, 0x0000 }, /* R14757 */ - { 0x0000, 0x0000, 0x0000 }, /* R14758 */ - { 0x0000, 0x0000, 0x0000 }, /* R14759 */ - { 0x0000, 0x0000, 0x0000 }, /* R14760 */ - { 0x0000, 0x0000, 0x0000 }, /* R14761 */ - { 0x0000, 0x0000, 0x0000 }, /* R14762 */ - { 0x0000, 0x0000, 0x0000 }, /* R14763 */ - { 0x0000, 0x0000, 0x0000 }, /* R14764 */ - { 0x0000, 0x0000, 0x0000 }, /* R14765 */ - { 0x0000, 0x0000, 0x0000 }, /* R14766 */ - { 0x0000, 0x0000, 0x0000 }, /* R14767 */ - { 0x0000, 0x0000, 0x0000 }, /* R14768 */ - { 0x0000, 0x0000, 0x0000 }, /* R14769 */ - { 0x0000, 0x0000, 0x0000 }, /* R14770 */ - { 0x0000, 0x0000, 0x0000 }, /* R14771 */ - { 0x0000, 0x0000, 0x0000 }, /* R14772 */ - { 0x0000, 0x0000, 0x0000 }, /* R14773 */ - { 0x0000, 0x0000, 0x0000 }, /* R14774 */ - { 0x0000, 0x0000, 0x0000 }, /* R14775 */ - { 0x0000, 0x0000, 0x0000 }, /* R14776 */ - { 0x0000, 0x0000, 0x0000 }, /* R14777 */ - { 0x0000, 0x0000, 0x0000 }, /* R14778 */ - { 0x0000, 0x0000, 0x0000 }, /* R14779 */ - { 0x0000, 0x0000, 0x0000 }, /* R14780 */ - { 0x0000, 0x0000, 0x0000 }, /* R14781 */ - { 0x0000, 0x0000, 0x0000 }, /* R14782 */ - { 0x0000, 0x0000, 0x0000 }, /* R14783 */ - { 0x0000, 0x0000, 0x0000 }, /* R14784 */ - { 0x0000, 0x0000, 0x0000 }, /* R14785 */ - { 0x0000, 0x0000, 0x0000 }, /* R14786 */ - { 0x0000, 0x0000, 0x0000 }, /* R14787 */ - { 0x0000, 0x0000, 0x0000 }, /* R14788 */ - { 0x0000, 0x0000, 0x0000 }, /* R14789 */ - { 0x0000, 0x0000, 0x0000 }, /* R14790 */ - { 0x0000, 0x0000, 0x0000 }, /* R14791 */ - { 0x0000, 0x0000, 0x0000 }, /* R14792 */ - { 0x0000, 0x0000, 0x0000 }, /* R14793 */ - { 0x0000, 0x0000, 0x0000 }, /* R14794 */ - { 0x0000, 0x0000, 0x0000 }, /* R14795 */ - { 0x0000, 0x0000, 0x0000 }, /* R14796 */ - { 0x0000, 0x0000, 0x0000 }, /* R14797 */ - { 0x0000, 0x0000, 0x0000 }, /* R14798 */ - { 0x0000, 0x0000, 0x0000 }, /* R14799 */ - { 0x0000, 0x0000, 0x0000 }, /* R14800 */ - { 0x0000, 0x0000, 0x0000 }, /* R14801 */ - { 0x0000, 0x0000, 0x0000 }, /* R14802 */ - { 0x0000, 0x0000, 0x0000 }, /* R14803 */ - { 0x0000, 0x0000, 0x0000 }, /* R14804 */ - { 0x0000, 0x0000, 0x0000 }, /* R14805 */ - { 0x0000, 0x0000, 0x0000 }, /* R14806 */ - { 0x0000, 0x0000, 0x0000 }, /* R14807 */ - { 0x0000, 0x0000, 0x0000 }, /* R14808 */ - { 0x0000, 0x0000, 0x0000 }, /* R14809 */ - { 0x0000, 0x0000, 0x0000 }, /* R14810 */ - { 0x0000, 0x0000, 0x0000 }, /* R14811 */ - { 0x0000, 0x0000, 0x0000 }, /* R14812 */ - { 0x0000, 0x0000, 0x0000 }, /* R14813 */ - { 0x0000, 0x0000, 0x0000 }, /* R14814 */ - { 0x0000, 0x0000, 0x0000 }, /* R14815 */ - { 0x0000, 0x0000, 0x0000 }, /* R14816 */ - { 0x0000, 0x0000, 0x0000 }, /* R14817 */ - { 0x0000, 0x0000, 0x0000 }, /* R14818 */ - { 0x0000, 0x0000, 0x0000 }, /* R14819 */ - { 0x0000, 0x0000, 0x0000 }, /* R14820 */ - { 0x0000, 0x0000, 0x0000 }, /* R14821 */ - { 0x0000, 0x0000, 0x0000 }, /* R14822 */ - { 0x0000, 0x0000, 0x0000 }, /* R14823 */ - { 0x0000, 0x0000, 0x0000 }, /* R14824 */ - { 0x0000, 0x0000, 0x0000 }, /* R14825 */ - { 0x0000, 0x0000, 0x0000 }, /* R14826 */ - { 0x0000, 0x0000, 0x0000 }, /* R14827 */ - { 0x0000, 0x0000, 0x0000 }, /* R14828 */ - { 0x0000, 0x0000, 0x0000 }, /* R14829 */ - { 0x0000, 0x0000, 0x0000 }, /* R14830 */ - { 0x0000, 0x0000, 0x0000 }, /* R14831 */ - { 0x0000, 0x0000, 0x0000 }, /* R14832 */ - { 0x0000, 0x0000, 0x0000 }, /* R14833 */ - { 0x0000, 0x0000, 0x0000 }, /* R14834 */ - { 0x0000, 0x0000, 0x0000 }, /* R14835 */ - { 0x0000, 0x0000, 0x0000 }, /* R14836 */ - { 0x0000, 0x0000, 0x0000 }, /* R14837 */ - { 0x0000, 0x0000, 0x0000 }, /* R14838 */ - { 0x0000, 0x0000, 0x0000 }, /* R14839 */ - { 0x0000, 0x0000, 0x0000 }, /* R14840 */ - { 0x0000, 0x0000, 0x0000 }, /* R14841 */ - { 0x0000, 0x0000, 0x0000 }, /* R14842 */ - { 0x0000, 0x0000, 0x0000 }, /* R14843 */ - { 0x0000, 0x0000, 0x0000 }, /* R14844 */ - { 0x0000, 0x0000, 0x0000 }, /* R14845 */ - { 0x0000, 0x0000, 0x0000 }, /* R14846 */ - { 0x0000, 0x0000, 0x0000 }, /* R14847 */ - { 0x0000, 0x0000, 0x0000 }, /* R14848 */ - { 0x0000, 0x0000, 0x0000 }, /* R14849 */ - { 0x0000, 0x0000, 0x0000 }, /* R14850 */ - { 0x0000, 0x0000, 0x0000 }, /* R14851 */ - { 0x0000, 0x0000, 0x0000 }, /* R14852 */ - { 0x0000, 0x0000, 0x0000 }, /* R14853 */ - { 0x0000, 0x0000, 0x0000 }, /* R14854 */ - { 0x0000, 0x0000, 0x0000 }, /* R14855 */ - { 0x0000, 0x0000, 0x0000 }, /* R14856 */ - { 0x0000, 0x0000, 0x0000 }, /* R14857 */ - { 0x0000, 0x0000, 0x0000 }, /* R14858 */ - { 0x0000, 0x0000, 0x0000 }, /* R14859 */ - { 0x0000, 0x0000, 0x0000 }, /* R14860 */ - { 0x0000, 0x0000, 0x0000 }, /* R14861 */ - { 0x0000, 0x0000, 0x0000 }, /* R14862 */ - { 0x0000, 0x0000, 0x0000 }, /* R14863 */ - { 0x0000, 0x0000, 0x0000 }, /* R14864 */ - { 0x0000, 0x0000, 0x0000 }, /* R14865 */ - { 0x0000, 0x0000, 0x0000 }, /* R14866 */ - { 0x0000, 0x0000, 0x0000 }, /* R14867 */ - { 0x0000, 0x0000, 0x0000 }, /* R14868 */ - { 0x0000, 0x0000, 0x0000 }, /* R14869 */ - { 0x0000, 0x0000, 0x0000 }, /* R14870 */ - { 0x0000, 0x0000, 0x0000 }, /* R14871 */ - { 0x0000, 0x0000, 0x0000 }, /* R14872 */ - { 0x0000, 0x0000, 0x0000 }, /* R14873 */ - { 0x0000, 0x0000, 0x0000 }, /* R14874 */ - { 0x0000, 0x0000, 0x0000 }, /* R14875 */ - { 0x0000, 0x0000, 0x0000 }, /* R14876 */ - { 0x0000, 0x0000, 0x0000 }, /* R14877 */ - { 0x0000, 0x0000, 0x0000 }, /* R14878 */ - { 0x0000, 0x0000, 0x0000 }, /* R14879 */ - { 0x0000, 0x0000, 0x0000 }, /* R14880 */ - { 0x0000, 0x0000, 0x0000 }, /* R14881 */ - { 0x0000, 0x0000, 0x0000 }, /* R14882 */ - { 0x0000, 0x0000, 0x0000 }, /* R14883 */ - { 0x0000, 0x0000, 0x0000 }, /* R14884 */ - { 0x0000, 0x0000, 0x0000 }, /* R14885 */ - { 0x0000, 0x0000, 0x0000 }, /* R14886 */ - { 0x0000, 0x0000, 0x0000 }, /* R14887 */ - { 0x0000, 0x0000, 0x0000 }, /* R14888 */ - { 0x0000, 0x0000, 0x0000 }, /* R14889 */ - { 0x0000, 0x0000, 0x0000 }, /* R14890 */ - { 0x0000, 0x0000, 0x0000 }, /* R14891 */ - { 0x0000, 0x0000, 0x0000 }, /* R14892 */ - { 0x0000, 0x0000, 0x0000 }, /* R14893 */ - { 0x0000, 0x0000, 0x0000 }, /* R14894 */ - { 0x0000, 0x0000, 0x0000 }, /* R14895 */ - { 0x0000, 0x0000, 0x0000 }, /* R14896 */ - { 0x0000, 0x0000, 0x0000 }, /* R14897 */ - { 0x0000, 0x0000, 0x0000 }, /* R14898 */ - { 0x0000, 0x0000, 0x0000 }, /* R14899 */ - { 0x0000, 0x0000, 0x0000 }, /* R14900 */ - { 0x0000, 0x0000, 0x0000 }, /* R14901 */ - { 0x0000, 0x0000, 0x0000 }, /* R14902 */ - { 0x0000, 0x0000, 0x0000 }, /* R14903 */ - { 0x0000, 0x0000, 0x0000 }, /* R14904 */ - { 0x0000, 0x0000, 0x0000 }, /* R14905 */ - { 0x0000, 0x0000, 0x0000 }, /* R14906 */ - { 0x0000, 0x0000, 0x0000 }, /* R14907 */ - { 0x0000, 0x0000, 0x0000 }, /* R14908 */ - { 0x0000, 0x0000, 0x0000 }, /* R14909 */ - { 0x0000, 0x0000, 0x0000 }, /* R14910 */ - { 0x0000, 0x0000, 0x0000 }, /* R14911 */ - { 0x0000, 0x0000, 0x0000 }, /* R14912 */ - { 0x0000, 0x0000, 0x0000 }, /* R14913 */ - { 0x0000, 0x0000, 0x0000 }, /* R14914 */ - { 0x0000, 0x0000, 0x0000 }, /* R14915 */ - { 0x0000, 0x0000, 0x0000 }, /* R14916 */ - { 0x0000, 0x0000, 0x0000 }, /* R14917 */ - { 0x0000, 0x0000, 0x0000 }, /* R14918 */ - { 0x0000, 0x0000, 0x0000 }, /* R14919 */ - { 0x0000, 0x0000, 0x0000 }, /* R14920 */ - { 0x0000, 0x0000, 0x0000 }, /* R14921 */ - { 0x0000, 0x0000, 0x0000 }, /* R14922 */ - { 0x0000, 0x0000, 0x0000 }, /* R14923 */ - { 0x0000, 0x0000, 0x0000 }, /* R14924 */ - { 0x0000, 0x0000, 0x0000 }, /* R14925 */ - { 0x0000, 0x0000, 0x0000 }, /* R14926 */ - { 0x0000, 0x0000, 0x0000 }, /* R14927 */ - { 0x0000, 0x0000, 0x0000 }, /* R14928 */ - { 0x0000, 0x0000, 0x0000 }, /* R14929 */ - { 0x0000, 0x0000, 0x0000 }, /* R14930 */ - { 0x0000, 0x0000, 0x0000 }, /* R14931 */ - { 0x0000, 0x0000, 0x0000 }, /* R14932 */ - { 0x0000, 0x0000, 0x0000 }, /* R14933 */ - { 0x0000, 0x0000, 0x0000 }, /* R14934 */ - { 0x0000, 0x0000, 0x0000 }, /* R14935 */ - { 0x0000, 0x0000, 0x0000 }, /* R14936 */ - { 0x0000, 0x0000, 0x0000 }, /* R14937 */ - { 0x0000, 0x0000, 0x0000 }, /* R14938 */ - { 0x0000, 0x0000, 0x0000 }, /* R14939 */ - { 0x0000, 0x0000, 0x0000 }, /* R14940 */ - { 0x0000, 0x0000, 0x0000 }, /* R14941 */ - { 0x0000, 0x0000, 0x0000 }, /* R14942 */ - { 0x0000, 0x0000, 0x0000 }, /* R14943 */ - { 0x0000, 0x0000, 0x0000 }, /* R14944 */ - { 0x0000, 0x0000, 0x0000 }, /* R14945 */ - { 0x0000, 0x0000, 0x0000 }, /* R14946 */ - { 0x0000, 0x0000, 0x0000 }, /* R14947 */ - { 0x0000, 0x0000, 0x0000 }, /* R14948 */ - { 0x0000, 0x0000, 0x0000 }, /* R14949 */ - { 0x0000, 0x0000, 0x0000 }, /* R14950 */ - { 0x0000, 0x0000, 0x0000 }, /* R14951 */ - { 0x0000, 0x0000, 0x0000 }, /* R14952 */ - { 0x0000, 0x0000, 0x0000 }, /* R14953 */ - { 0x0000, 0x0000, 0x0000 }, /* R14954 */ - { 0x0000, 0x0000, 0x0000 }, /* R14955 */ - { 0x0000, 0x0000, 0x0000 }, /* R14956 */ - { 0x0000, 0x0000, 0x0000 }, /* R14957 */ - { 0x0000, 0x0000, 0x0000 }, /* R14958 */ - { 0x0000, 0x0000, 0x0000 }, /* R14959 */ - { 0x0000, 0x0000, 0x0000 }, /* R14960 */ - { 0x0000, 0x0000, 0x0000 }, /* R14961 */ - { 0x0000, 0x0000, 0x0000 }, /* R14962 */ - { 0x0000, 0x0000, 0x0000 }, /* R14963 */ - { 0x0000, 0x0000, 0x0000 }, /* R14964 */ - { 0x0000, 0x0000, 0x0000 }, /* R14965 */ - { 0x0000, 0x0000, 0x0000 }, /* R14966 */ - { 0x0000, 0x0000, 0x0000 }, /* R14967 */ - { 0x0000, 0x0000, 0x0000 }, /* R14968 */ - { 0x0000, 0x0000, 0x0000 }, /* R14969 */ - { 0x0000, 0x0000, 0x0000 }, /* R14970 */ - { 0x0000, 0x0000, 0x0000 }, /* R14971 */ - { 0x0000, 0x0000, 0x0000 }, /* R14972 */ - { 0x0000, 0x0000, 0x0000 }, /* R14973 */ - { 0x0000, 0x0000, 0x0000 }, /* R14974 */ - { 0x0000, 0x0000, 0x0000 }, /* R14975 */ - { 0x0000, 0x0000, 0x0000 }, /* R14976 */ - { 0x0000, 0x0000, 0x0000 }, /* R14977 */ - { 0x0000, 0x0000, 0x0000 }, /* R14978 */ - { 0x0000, 0x0000, 0x0000 }, /* R14979 */ - { 0x0000, 0x0000, 0x0000 }, /* R14980 */ - { 0x0000, 0x0000, 0x0000 }, /* R14981 */ - { 0x0000, 0x0000, 0x0000 }, /* R14982 */ - { 0x0000, 0x0000, 0x0000 }, /* R14983 */ - { 0x0000, 0x0000, 0x0000 }, /* R14984 */ - { 0x0000, 0x0000, 0x0000 }, /* R14985 */ - { 0x0000, 0x0000, 0x0000 }, /* R14986 */ - { 0x0000, 0x0000, 0x0000 }, /* R14987 */ - { 0x0000, 0x0000, 0x0000 }, /* R14988 */ - { 0x0000, 0x0000, 0x0000 }, /* R14989 */ - { 0x0000, 0x0000, 0x0000 }, /* R14990 */ - { 0x0000, 0x0000, 0x0000 }, /* R14991 */ - { 0x0000, 0x0000, 0x0000 }, /* R14992 */ - { 0x0000, 0x0000, 0x0000 }, /* R14993 */ - { 0x0000, 0x0000, 0x0000 }, /* R14994 */ - { 0x0000, 0x0000, 0x0000 }, /* R14995 */ - { 0x0000, 0x0000, 0x0000 }, /* R14996 */ - { 0x0000, 0x0000, 0x0000 }, /* R14997 */ - { 0x0000, 0x0000, 0x0000 }, /* R14998 */ - { 0x0000, 0x0000, 0x0000 }, /* R14999 */ - { 0x0000, 0x0000, 0x0000 }, /* R15000 */ - { 0x0000, 0x0000, 0x0000 }, /* R15001 */ - { 0x0000, 0x0000, 0x0000 }, /* R15002 */ - { 0x0000, 0x0000, 0x0000 }, /* R15003 */ - { 0x0000, 0x0000, 0x0000 }, /* R15004 */ - { 0x0000, 0x0000, 0x0000 }, /* R15005 */ - { 0x0000, 0x0000, 0x0000 }, /* R15006 */ - { 0x0000, 0x0000, 0x0000 }, /* R15007 */ - { 0x0000, 0x0000, 0x0000 }, /* R15008 */ - { 0x0000, 0x0000, 0x0000 }, /* R15009 */ - { 0x0000, 0x0000, 0x0000 }, /* R15010 */ - { 0x0000, 0x0000, 0x0000 }, /* R15011 */ - { 0x0000, 0x0000, 0x0000 }, /* R15012 */ - { 0x0000, 0x0000, 0x0000 }, /* R15013 */ - { 0x0000, 0x0000, 0x0000 }, /* R15014 */ - { 0x0000, 0x0000, 0x0000 }, /* R15015 */ - { 0x0000, 0x0000, 0x0000 }, /* R15016 */ - { 0x0000, 0x0000, 0x0000 }, /* R15017 */ - { 0x0000, 0x0000, 0x0000 }, /* R15018 */ - { 0x0000, 0x0000, 0x0000 }, /* R15019 */ - { 0x0000, 0x0000, 0x0000 }, /* R15020 */ - { 0x0000, 0x0000, 0x0000 }, /* R15021 */ - { 0x0000, 0x0000, 0x0000 }, /* R15022 */ - { 0x0000, 0x0000, 0x0000 }, /* R15023 */ - { 0x0000, 0x0000, 0x0000 }, /* R15024 */ - { 0x0000, 0x0000, 0x0000 }, /* R15025 */ - { 0x0000, 0x0000, 0x0000 }, /* R15026 */ - { 0x0000, 0x0000, 0x0000 }, /* R15027 */ - { 0x0000, 0x0000, 0x0000 }, /* R15028 */ - { 0x0000, 0x0000, 0x0000 }, /* R15029 */ - { 0x0000, 0x0000, 0x0000 }, /* R15030 */ - { 0x0000, 0x0000, 0x0000 }, /* R15031 */ - { 0x0000, 0x0000, 0x0000 }, /* R15032 */ - { 0x0000, 0x0000, 0x0000 }, /* R15033 */ - { 0x0000, 0x0000, 0x0000 }, /* R15034 */ - { 0x0000, 0x0000, 0x0000 }, /* R15035 */ - { 0x0000, 0x0000, 0x0000 }, /* R15036 */ - { 0x0000, 0x0000, 0x0000 }, /* R15037 */ - { 0x0000, 0x0000, 0x0000 }, /* R15038 */ - { 0x0000, 0x0000, 0x0000 }, /* R15039 */ - { 0x0000, 0x0000, 0x0000 }, /* R15040 */ - { 0x0000, 0x0000, 0x0000 }, /* R15041 */ - { 0x0000, 0x0000, 0x0000 }, /* R15042 */ - { 0x0000, 0x0000, 0x0000 }, /* R15043 */ - { 0x0000, 0x0000, 0x0000 }, /* R15044 */ - { 0x0000, 0x0000, 0x0000 }, /* R15045 */ - { 0x0000, 0x0000, 0x0000 }, /* R15046 */ - { 0x0000, 0x0000, 0x0000 }, /* R15047 */ - { 0x0000, 0x0000, 0x0000 }, /* R15048 */ - { 0x0000, 0x0000, 0x0000 }, /* R15049 */ - { 0x0000, 0x0000, 0x0000 }, /* R15050 */ - { 0x0000, 0x0000, 0x0000 }, /* R15051 */ - { 0x0000, 0x0000, 0x0000 }, /* R15052 */ - { 0x0000, 0x0000, 0x0000 }, /* R15053 */ - { 0x0000, 0x0000, 0x0000 }, /* R15054 */ - { 0x0000, 0x0000, 0x0000 }, /* R15055 */ - { 0x0000, 0x0000, 0x0000 }, /* R15056 */ - { 0x0000, 0x0000, 0x0000 }, /* R15057 */ - { 0x0000, 0x0000, 0x0000 }, /* R15058 */ - { 0x0000, 0x0000, 0x0000 }, /* R15059 */ - { 0x0000, 0x0000, 0x0000 }, /* R15060 */ - { 0x0000, 0x0000, 0x0000 }, /* R15061 */ - { 0x0000, 0x0000, 0x0000 }, /* R15062 */ - { 0x0000, 0x0000, 0x0000 }, /* R15063 */ - { 0x0000, 0x0000, 0x0000 }, /* R15064 */ - { 0x0000, 0x0000, 0x0000 }, /* R15065 */ - { 0x0000, 0x0000, 0x0000 }, /* R15066 */ - { 0x0000, 0x0000, 0x0000 }, /* R15067 */ - { 0x0000, 0x0000, 0x0000 }, /* R15068 */ - { 0x0000, 0x0000, 0x0000 }, /* R15069 */ - { 0x0000, 0x0000, 0x0000 }, /* R15070 */ - { 0x0000, 0x0000, 0x0000 }, /* R15071 */ - { 0x0000, 0x0000, 0x0000 }, /* R15072 */ - { 0x0000, 0x0000, 0x0000 }, /* R15073 */ - { 0x0000, 0x0000, 0x0000 }, /* R15074 */ - { 0x0000, 0x0000, 0x0000 }, /* R15075 */ - { 0x0000, 0x0000, 0x0000 }, /* R15076 */ - { 0x0000, 0x0000, 0x0000 }, /* R15077 */ - { 0x0000, 0x0000, 0x0000 }, /* R15078 */ - { 0x0000, 0x0000, 0x0000 }, /* R15079 */ - { 0x0000, 0x0000, 0x0000 }, /* R15080 */ - { 0x0000, 0x0000, 0x0000 }, /* R15081 */ - { 0x0000, 0x0000, 0x0000 }, /* R15082 */ - { 0x0000, 0x0000, 0x0000 }, /* R15083 */ - { 0x0000, 0x0000, 0x0000 }, /* R15084 */ - { 0x0000, 0x0000, 0x0000 }, /* R15085 */ - { 0x0000, 0x0000, 0x0000 }, /* R15086 */ - { 0x0000, 0x0000, 0x0000 }, /* R15087 */ - { 0x0000, 0x0000, 0x0000 }, /* R15088 */ - { 0x0000, 0x0000, 0x0000 }, /* R15089 */ - { 0x0000, 0x0000, 0x0000 }, /* R15090 */ - { 0x0000, 0x0000, 0x0000 }, /* R15091 */ - { 0x0000, 0x0000, 0x0000 }, /* R15092 */ - { 0x0000, 0x0000, 0x0000 }, /* R15093 */ - { 0x0000, 0x0000, 0x0000 }, /* R15094 */ - { 0x0000, 0x0000, 0x0000 }, /* R15095 */ - { 0x0000, 0x0000, 0x0000 }, /* R15096 */ - { 0x0000, 0x0000, 0x0000 }, /* R15097 */ - { 0x0000, 0x0000, 0x0000 }, /* R15098 */ - { 0x0000, 0x0000, 0x0000 }, /* R15099 */ - { 0x0000, 0x0000, 0x0000 }, /* R15100 */ - { 0x0000, 0x0000, 0x0000 }, /* R15101 */ - { 0x0000, 0x0000, 0x0000 }, /* R15102 */ - { 0x0000, 0x0000, 0x0000 }, /* R15103 */ - { 0x0000, 0x0000, 0x0000 }, /* R15104 */ - { 0x0000, 0x0000, 0x0000 }, /* R15105 */ - { 0x0000, 0x0000, 0x0000 }, /* R15106 */ - { 0x0000, 0x0000, 0x0000 }, /* R15107 */ - { 0x0000, 0x0000, 0x0000 }, /* R15108 */ - { 0x0000, 0x0000, 0x0000 }, /* R15109 */ - { 0x0000, 0x0000, 0x0000 }, /* R15110 */ - { 0x0000, 0x0000, 0x0000 }, /* R15111 */ - { 0x0000, 0x0000, 0x0000 }, /* R15112 */ - { 0x0000, 0x0000, 0x0000 }, /* R15113 */ - { 0x0000, 0x0000, 0x0000 }, /* R15114 */ - { 0x0000, 0x0000, 0x0000 }, /* R15115 */ - { 0x0000, 0x0000, 0x0000 }, /* R15116 */ - { 0x0000, 0x0000, 0x0000 }, /* R15117 */ - { 0x0000, 0x0000, 0x0000 }, /* R15118 */ - { 0x0000, 0x0000, 0x0000 }, /* R15119 */ - { 0x0000, 0x0000, 0x0000 }, /* R15120 */ - { 0x0000, 0x0000, 0x0000 }, /* R15121 */ - { 0x0000, 0x0000, 0x0000 }, /* R15122 */ - { 0x0000, 0x0000, 0x0000 }, /* R15123 */ - { 0x0000, 0x0000, 0x0000 }, /* R15124 */ - { 0x0000, 0x0000, 0x0000 }, /* R15125 */ - { 0x0000, 0x0000, 0x0000 }, /* R15126 */ - { 0x0000, 0x0000, 0x0000 }, /* R15127 */ - { 0x0000, 0x0000, 0x0000 }, /* R15128 */ - { 0x0000, 0x0000, 0x0000 }, /* R15129 */ - { 0x0000, 0x0000, 0x0000 }, /* R15130 */ - { 0x0000, 0x0000, 0x0000 }, /* R15131 */ - { 0x0000, 0x0000, 0x0000 }, /* R15132 */ - { 0x0000, 0x0000, 0x0000 }, /* R15133 */ - { 0x0000, 0x0000, 0x0000 }, /* R15134 */ - { 0x0000, 0x0000, 0x0000 }, /* R15135 */ - { 0x0000, 0x0000, 0x0000 }, /* R15136 */ - { 0x0000, 0x0000, 0x0000 }, /* R15137 */ - { 0x0000, 0x0000, 0x0000 }, /* R15138 */ - { 0x0000, 0x0000, 0x0000 }, /* R15139 */ - { 0x0000, 0x0000, 0x0000 }, /* R15140 */ - { 0x0000, 0x0000, 0x0000 }, /* R15141 */ - { 0x0000, 0x0000, 0x0000 }, /* R15142 */ - { 0x0000, 0x0000, 0x0000 }, /* R15143 */ - { 0x0000, 0x0000, 0x0000 }, /* R15144 */ - { 0x0000, 0x0000, 0x0000 }, /* R15145 */ - { 0x0000, 0x0000, 0x0000 }, /* R15146 */ - { 0x0000, 0x0000, 0x0000 }, /* R15147 */ - { 0x0000, 0x0000, 0x0000 }, /* R15148 */ - { 0x0000, 0x0000, 0x0000 }, /* R15149 */ - { 0x0000, 0x0000, 0x0000 }, /* R15150 */ - { 0x0000, 0x0000, 0x0000 }, /* R15151 */ - { 0x0000, 0x0000, 0x0000 }, /* R15152 */ - { 0x0000, 0x0000, 0x0000 }, /* R15153 */ - { 0x0000, 0x0000, 0x0000 }, /* R15154 */ - { 0x0000, 0x0000, 0x0000 }, /* R15155 */ - { 0x0000, 0x0000, 0x0000 }, /* R15156 */ - { 0x0000, 0x0000, 0x0000 }, /* R15157 */ - { 0x0000, 0x0000, 0x0000 }, /* R15158 */ - { 0x0000, 0x0000, 0x0000 }, /* R15159 */ - { 0x0000, 0x0000, 0x0000 }, /* R15160 */ - { 0x0000, 0x0000, 0x0000 }, /* R15161 */ - { 0x0000, 0x0000, 0x0000 }, /* R15162 */ - { 0x0000, 0x0000, 0x0000 }, /* R15163 */ - { 0x0000, 0x0000, 0x0000 }, /* R15164 */ - { 0x0000, 0x0000, 0x0000 }, /* R15165 */ - { 0x0000, 0x0000, 0x0000 }, /* R15166 */ - { 0x0000, 0x0000, 0x0000 }, /* R15167 */ - { 0x0000, 0x0000, 0x0000 }, /* R15168 */ - { 0x0000, 0x0000, 0x0000 }, /* R15169 */ - { 0x0000, 0x0000, 0x0000 }, /* R15170 */ - { 0x0000, 0x0000, 0x0000 }, /* R15171 */ - { 0x0000, 0x0000, 0x0000 }, /* R15172 */ - { 0x0000, 0x0000, 0x0000 }, /* R15173 */ - { 0x0000, 0x0000, 0x0000 }, /* R15174 */ - { 0x0000, 0x0000, 0x0000 }, /* R15175 */ - { 0x0000, 0x0000, 0x0000 }, /* R15176 */ - { 0x0000, 0x0000, 0x0000 }, /* R15177 */ - { 0x0000, 0x0000, 0x0000 }, /* R15178 */ - { 0x0000, 0x0000, 0x0000 }, /* R15179 */ - { 0x0000, 0x0000, 0x0000 }, /* R15180 */ - { 0x0000, 0x0000, 0x0000 }, /* R15181 */ - { 0x0000, 0x0000, 0x0000 }, /* R15182 */ - { 0x0000, 0x0000, 0x0000 }, /* R15183 */ - { 0x0000, 0x0000, 0x0000 }, /* R15184 */ - { 0x0000, 0x0000, 0x0000 }, /* R15185 */ - { 0x0000, 0x0000, 0x0000 }, /* R15186 */ - { 0x0000, 0x0000, 0x0000 }, /* R15187 */ - { 0x0000, 0x0000, 0x0000 }, /* R15188 */ - { 0x0000, 0x0000, 0x0000 }, /* R15189 */ - { 0x0000, 0x0000, 0x0000 }, /* R15190 */ - { 0x0000, 0x0000, 0x0000 }, /* R15191 */ - { 0x0000, 0x0000, 0x0000 }, /* R15192 */ - { 0x0000, 0x0000, 0x0000 }, /* R15193 */ - { 0x0000, 0x0000, 0x0000 }, /* R15194 */ - { 0x0000, 0x0000, 0x0000 }, /* R15195 */ - { 0x0000, 0x0000, 0x0000 }, /* R15196 */ - { 0x0000, 0x0000, 0x0000 }, /* R15197 */ - { 0x0000, 0x0000, 0x0000 }, /* R15198 */ - { 0x0000, 0x0000, 0x0000 }, /* R15199 */ - { 0x0000, 0x0000, 0x0000 }, /* R15200 */ - { 0x0000, 0x0000, 0x0000 }, /* R15201 */ - { 0x0000, 0x0000, 0x0000 }, /* R15202 */ - { 0x0000, 0x0000, 0x0000 }, /* R15203 */ - { 0x0000, 0x0000, 0x0000 }, /* R15204 */ - { 0x0000, 0x0000, 0x0000 }, /* R15205 */ - { 0x0000, 0x0000, 0x0000 }, /* R15206 */ - { 0x0000, 0x0000, 0x0000 }, /* R15207 */ - { 0x0000, 0x0000, 0x0000 }, /* R15208 */ - { 0x0000, 0x0000, 0x0000 }, /* R15209 */ - { 0x0000, 0x0000, 0x0000 }, /* R15210 */ - { 0x0000, 0x0000, 0x0000 }, /* R15211 */ - { 0x0000, 0x0000, 0x0000 }, /* R15212 */ - { 0x0000, 0x0000, 0x0000 }, /* R15213 */ - { 0x0000, 0x0000, 0x0000 }, /* R15214 */ - { 0x0000, 0x0000, 0x0000 }, /* R15215 */ - { 0x0000, 0x0000, 0x0000 }, /* R15216 */ - { 0x0000, 0x0000, 0x0000 }, /* R15217 */ - { 0x0000, 0x0000, 0x0000 }, /* R15218 */ - { 0x0000, 0x0000, 0x0000 }, /* R15219 */ - { 0x0000, 0x0000, 0x0000 }, /* R15220 */ - { 0x0000, 0x0000, 0x0000 }, /* R15221 */ - { 0x0000, 0x0000, 0x0000 }, /* R15222 */ - { 0x0000, 0x0000, 0x0000 }, /* R15223 */ - { 0x0000, 0x0000, 0x0000 }, /* R15224 */ - { 0x0000, 0x0000, 0x0000 }, /* R15225 */ - { 0x0000, 0x0000, 0x0000 }, /* R15226 */ - { 0x0000, 0x0000, 0x0000 }, /* R15227 */ - { 0x0000, 0x0000, 0x0000 }, /* R15228 */ - { 0x0000, 0x0000, 0x0000 }, /* R15229 */ - { 0x0000, 0x0000, 0x0000 }, /* R15230 */ - { 0x0000, 0x0000, 0x0000 }, /* R15231 */ - { 0x0000, 0x0000, 0x0000 }, /* R15232 */ - { 0x0000, 0x0000, 0x0000 }, /* R15233 */ - { 0x0000, 0x0000, 0x0000 }, /* R15234 */ - { 0x0000, 0x0000, 0x0000 }, /* R15235 */ - { 0x0000, 0x0000, 0x0000 }, /* R15236 */ - { 0x0000, 0x0000, 0x0000 }, /* R15237 */ - { 0x0000, 0x0000, 0x0000 }, /* R15238 */ - { 0x0000, 0x0000, 0x0000 }, /* R15239 */ - { 0x0000, 0x0000, 0x0000 }, /* R15240 */ - { 0x0000, 0x0000, 0x0000 }, /* R15241 */ - { 0x0000, 0x0000, 0x0000 }, /* R15242 */ - { 0x0000, 0x0000, 0x0000 }, /* R15243 */ - { 0x0000, 0x0000, 0x0000 }, /* R15244 */ - { 0x0000, 0x0000, 0x0000 }, /* R15245 */ - { 0x0000, 0x0000, 0x0000 }, /* R15246 */ - { 0x0000, 0x0000, 0x0000 }, /* R15247 */ - { 0x0000, 0x0000, 0x0000 }, /* R15248 */ - { 0x0000, 0x0000, 0x0000 }, /* R15249 */ - { 0x0000, 0x0000, 0x0000 }, /* R15250 */ - { 0x0000, 0x0000, 0x0000 }, /* R15251 */ - { 0x0000, 0x0000, 0x0000 }, /* R15252 */ - { 0x0000, 0x0000, 0x0000 }, /* R15253 */ - { 0x0000, 0x0000, 0x0000 }, /* R15254 */ - { 0x0000, 0x0000, 0x0000 }, /* R15255 */ - { 0x0000, 0x0000, 0x0000 }, /* R15256 */ - { 0x0000, 0x0000, 0x0000 }, /* R15257 */ - { 0x0000, 0x0000, 0x0000 }, /* R15258 */ - { 0x0000, 0x0000, 0x0000 }, /* R15259 */ - { 0x0000, 0x0000, 0x0000 }, /* R15260 */ - { 0x0000, 0x0000, 0x0000 }, /* R15261 */ - { 0x0000, 0x0000, 0x0000 }, /* R15262 */ - { 0x0000, 0x0000, 0x0000 }, /* R15263 */ - { 0x0000, 0x0000, 0x0000 }, /* R15264 */ - { 0x0000, 0x0000, 0x0000 }, /* R15265 */ - { 0x0000, 0x0000, 0x0000 }, /* R15266 */ - { 0x0000, 0x0000, 0x0000 }, /* R15267 */ - { 0x0000, 0x0000, 0x0000 }, /* R15268 */ - { 0x0000, 0x0000, 0x0000 }, /* R15269 */ - { 0x0000, 0x0000, 0x0000 }, /* R15270 */ - { 0x0000, 0x0000, 0x0000 }, /* R15271 */ - { 0x0000, 0x0000, 0x0000 }, /* R15272 */ - { 0x0000, 0x0000, 0x0000 }, /* R15273 */ - { 0x0000, 0x0000, 0x0000 }, /* R15274 */ - { 0x0000, 0x0000, 0x0000 }, /* R15275 */ - { 0x0000, 0x0000, 0x0000 }, /* R15276 */ - { 0x0000, 0x0000, 0x0000 }, /* R15277 */ - { 0x0000, 0x0000, 0x0000 }, /* R15278 */ - { 0x0000, 0x0000, 0x0000 }, /* R15279 */ - { 0x0000, 0x0000, 0x0000 }, /* R15280 */ - { 0x0000, 0x0000, 0x0000 }, /* R15281 */ - { 0x0000, 0x0000, 0x0000 }, /* R15282 */ - { 0x0000, 0x0000, 0x0000 }, /* R15283 */ - { 0x0000, 0x0000, 0x0000 }, /* R15284 */ - { 0x0000, 0x0000, 0x0000 }, /* R15285 */ - { 0x0000, 0x0000, 0x0000 }, /* R15286 */ - { 0x0000, 0x0000, 0x0000 }, /* R15287 */ - { 0x0000, 0x0000, 0x0000 }, /* R15288 */ - { 0x0000, 0x0000, 0x0000 }, /* R15289 */ - { 0x0000, 0x0000, 0x0000 }, /* R15290 */ - { 0x0000, 0x0000, 0x0000 }, /* R15291 */ - { 0x0000, 0x0000, 0x0000 }, /* R15292 */ - { 0x0000, 0x0000, 0x0000 }, /* R15293 */ - { 0x0000, 0x0000, 0x0000 }, /* R15294 */ - { 0x0000, 0x0000, 0x0000 }, /* R15295 */ - { 0x0000, 0x0000, 0x0000 }, /* R15296 */ - { 0x0000, 0x0000, 0x0000 }, /* R15297 */ - { 0x0000, 0x0000, 0x0000 }, /* R15298 */ - { 0x0000, 0x0000, 0x0000 }, /* R15299 */ - { 0x0000, 0x0000, 0x0000 }, /* R15300 */ - { 0x0000, 0x0000, 0x0000 }, /* R15301 */ - { 0x0000, 0x0000, 0x0000 }, /* R15302 */ - { 0x0000, 0x0000, 0x0000 }, /* R15303 */ - { 0x0000, 0x0000, 0x0000 }, /* R15304 */ - { 0x0000, 0x0000, 0x0000 }, /* R15305 */ - { 0x0000, 0x0000, 0x0000 }, /* R15306 */ - { 0x0000, 0x0000, 0x0000 }, /* R15307 */ - { 0x0000, 0x0000, 0x0000 }, /* R15308 */ - { 0x0000, 0x0000, 0x0000 }, /* R15309 */ - { 0x0000, 0x0000, 0x0000 }, /* R15310 */ - { 0x0000, 0x0000, 0x0000 }, /* R15311 */ - { 0x0000, 0x0000, 0x0000 }, /* R15312 */ - { 0x0000, 0x0000, 0x0000 }, /* R15313 */ - { 0x0000, 0x0000, 0x0000 }, /* R15314 */ - { 0x0000, 0x0000, 0x0000 }, /* R15315 */ - { 0x0000, 0x0000, 0x0000 }, /* R15316 */ - { 0x0000, 0x0000, 0x0000 }, /* R15317 */ - { 0x0000, 0x0000, 0x0000 }, /* R15318 */ - { 0x0000, 0x0000, 0x0000 }, /* R15319 */ - { 0x0000, 0x0000, 0x0000 }, /* R15320 */ - { 0x0000, 0x0000, 0x0000 }, /* R15321 */ - { 0x0000, 0x0000, 0x0000 }, /* R15322 */ - { 0x0000, 0x0000, 0x0000 }, /* R15323 */ - { 0x0000, 0x0000, 0x0000 }, /* R15324 */ - { 0x0000, 0x0000, 0x0000 }, /* R15325 */ - { 0x0000, 0x0000, 0x0000 }, /* R15326 */ - { 0x0000, 0x0000, 0x0000 }, /* R15327 */ - { 0x0000, 0x0000, 0x0000 }, /* R15328 */ - { 0x0000, 0x0000, 0x0000 }, /* R15329 */ - { 0x0000, 0x0000, 0x0000 }, /* R15330 */ - { 0x0000, 0x0000, 0x0000 }, /* R15331 */ - { 0x0000, 0x0000, 0x0000 }, /* R15332 */ - { 0x0000, 0x0000, 0x0000 }, /* R15333 */ - { 0x0000, 0x0000, 0x0000 }, /* R15334 */ - { 0x0000, 0x0000, 0x0000 }, /* R15335 */ - { 0x0000, 0x0000, 0x0000 }, /* R15336 */ - { 0x0000, 0x0000, 0x0000 }, /* R15337 */ - { 0x0000, 0x0000, 0x0000 }, /* R15338 */ - { 0x0000, 0x0000, 0x0000 }, /* R15339 */ - { 0x0000, 0x0000, 0x0000 }, /* R15340 */ - { 0x0000, 0x0000, 0x0000 }, /* R15341 */ - { 0x0000, 0x0000, 0x0000 }, /* R15342 */ - { 0x0000, 0x0000, 0x0000 }, /* R15343 */ - { 0x0000, 0x0000, 0x0000 }, /* R15344 */ - { 0x0000, 0x0000, 0x0000 }, /* R15345 */ - { 0x0000, 0x0000, 0x0000 }, /* R15346 */ - { 0x0000, 0x0000, 0x0000 }, /* R15347 */ - { 0x0000, 0x0000, 0x0000 }, /* R15348 */ - { 0x0000, 0x0000, 0x0000 }, /* R15349 */ - { 0x0000, 0x0000, 0x0000 }, /* R15350 */ - { 0x0000, 0x0000, 0x0000 }, /* R15351 */ - { 0x0000, 0x0000, 0x0000 }, /* R15352 */ - { 0x0000, 0x0000, 0x0000 }, /* R15353 */ - { 0x0000, 0x0000, 0x0000 }, /* R15354 */ - { 0x0000, 0x0000, 0x0000 }, /* R15355 */ - { 0x0000, 0x0000, 0x0000 }, /* R15356 */ - { 0x0000, 0x0000, 0x0000 }, /* R15357 */ - { 0x0000, 0x0000, 0x0000 }, /* R15358 */ - { 0x0000, 0x0000, 0x0000 }, /* R15359 */ - { 0x07FF, 0x07FF, 0x0000 }, /* R15360 - DSP2 Coeff RAM 0 */ - { 0x0000, 0x0000, 0x0000 }, /* R15361 */ - { 0x0000, 0x0000, 0x0000 }, /* R15362 */ - { 0x0000, 0x0000, 0x0000 }, /* R15363 */ - { 0x0000, 0x0000, 0x0000 }, /* R15364 */ - { 0x0000, 0x0000, 0x0000 }, /* R15365 */ - { 0x0000, 0x0000, 0x0000 }, /* R15366 */ - { 0x0000, 0x0000, 0x0000 }, /* R15367 */ - { 0x0000, 0x0000, 0x0000 }, /* R15368 */ - { 0x0000, 0x0000, 0x0000 }, /* R15369 */ - { 0x0000, 0x0000, 0x0000 }, /* R15370 */ - { 0x0000, 0x0000, 0x0000 }, /* R15371 */ - { 0x0000, 0x0000, 0x0000 }, /* R15372 */ - { 0x0000, 0x0000, 0x0000 }, /* R15373 */ - { 0x0000, 0x0000, 0x0000 }, /* R15374 */ - { 0x0000, 0x0000, 0x0000 }, /* R15375 */ - { 0x0000, 0x0000, 0x0000 }, /* R15376 */ - { 0x0000, 0x0000, 0x0000 }, /* R15377 */ - { 0x0000, 0x0000, 0x0000 }, /* R15378 */ - { 0x0000, 0x0000, 0x0000 }, /* R15379 */ - { 0x0000, 0x0000, 0x0000 }, /* R15380 */ - { 0x0000, 0x0000, 0x0000 }, /* R15381 */ - { 0x0000, 0x0000, 0x0000 }, /* R15382 */ - { 0x0000, 0x0000, 0x0000 }, /* R15383 */ - { 0x0000, 0x0000, 0x0000 }, /* R15384 */ - { 0x0000, 0x0000, 0x0000 }, /* R15385 */ - { 0x0000, 0x0000, 0x0000 }, /* R15386 */ - { 0x0000, 0x0000, 0x0000 }, /* R15387 */ - { 0x0000, 0x0000, 0x0000 }, /* R15388 */ - { 0x0000, 0x0000, 0x0000 }, /* R15389 */ - { 0x0000, 0x0000, 0x0000 }, /* R15390 */ - { 0x0000, 0x0000, 0x0000 }, /* R15391 */ - { 0x0000, 0x0000, 0x0000 }, /* R15392 */ - { 0x0000, 0x0000, 0x0000 }, /* R15393 */ - { 0x0000, 0x0000, 0x0000 }, /* R15394 */ - { 0x0000, 0x0000, 0x0000 }, /* R15395 */ - { 0x0000, 0x0000, 0x0000 }, /* R15396 */ - { 0x0000, 0x0000, 0x0000 }, /* R15397 */ - { 0x0000, 0x0000, 0x0000 }, /* R15398 */ - { 0x0000, 0x0000, 0x0000 }, /* R15399 */ - { 0x0000, 0x0000, 0x0000 }, /* R15400 */ - { 0x0000, 0x0000, 0x0000 }, /* R15401 */ - { 0x0000, 0x0000, 0x0000 }, /* R15402 */ - { 0x0000, 0x0000, 0x0000 }, /* R15403 */ - { 0x0000, 0x0000, 0x0000 }, /* R15404 */ - { 0x0000, 0x0000, 0x0000 }, /* R15405 */ - { 0x0000, 0x0000, 0x0000 }, /* R15406 */ - { 0x0000, 0x0000, 0x0000 }, /* R15407 */ - { 0x0000, 0x0000, 0x0000 }, /* R15408 */ - { 0x0000, 0x0000, 0x0000 }, /* R15409 */ - { 0x0000, 0x0000, 0x0000 }, /* R15410 */ - { 0x0000, 0x0000, 0x0000 }, /* R15411 */ - { 0x0000, 0x0000, 0x0000 }, /* R15412 */ - { 0x0000, 0x0000, 0x0000 }, /* R15413 */ - { 0x0000, 0x0000, 0x0000 }, /* R15414 */ - { 0x0000, 0x0000, 0x0000 }, /* R15415 */ - { 0x0000, 0x0000, 0x0000 }, /* R15416 */ - { 0x0000, 0x0000, 0x0000 }, /* R15417 */ - { 0x0000, 0x0000, 0x0000 }, /* R15418 */ - { 0x0000, 0x0000, 0x0000 }, /* R15419 */ - { 0x0000, 0x0000, 0x0000 }, /* R15420 */ - { 0x0000, 0x0000, 0x0000 }, /* R15421 */ - { 0x0000, 0x0000, 0x0000 }, /* R15422 */ - { 0x0000, 0x0000, 0x0000 }, /* R15423 */ - { 0x0000, 0x0000, 0x0000 }, /* R15424 */ - { 0x0000, 0x0000, 0x0000 }, /* R15425 */ - { 0x0000, 0x0000, 0x0000 }, /* R15426 */ - { 0x0000, 0x0000, 0x0000 }, /* R15427 */ - { 0x0000, 0x0000, 0x0000 }, /* R15428 */ - { 0x0000, 0x0000, 0x0000 }, /* R15429 */ - { 0x0000, 0x0000, 0x0000 }, /* R15430 */ - { 0x0000, 0x0000, 0x0000 }, /* R15431 */ - { 0x0000, 0x0000, 0x0000 }, /* R15432 */ - { 0x0000, 0x0000, 0x0000 }, /* R15433 */ - { 0x0000, 0x0000, 0x0000 }, /* R15434 */ - { 0x0000, 0x0000, 0x0000 }, /* R15435 */ - { 0x0000, 0x0000, 0x0000 }, /* R15436 */ - { 0x0000, 0x0000, 0x0000 }, /* R15437 */ - { 0x0000, 0x0000, 0x0000 }, /* R15438 */ - { 0x0000, 0x0000, 0x0000 }, /* R15439 */ - { 0x0000, 0x0000, 0x0000 }, /* R15440 */ - { 0x0000, 0x0000, 0x0000 }, /* R15441 */ - { 0x0000, 0x0000, 0x0000 }, /* R15442 */ - { 0x0000, 0x0000, 0x0000 }, /* R15443 */ - { 0x0000, 0x0000, 0x0000 }, /* R15444 */ - { 0x0000, 0x0000, 0x0000 }, /* R15445 */ - { 0x0000, 0x0000, 0x0000 }, /* R15446 */ - { 0x0000, 0x0000, 0x0000 }, /* R15447 */ - { 0x0000, 0x0000, 0x0000 }, /* R15448 */ - { 0x0000, 0x0000, 0x0000 }, /* R15449 */ - { 0x0000, 0x0000, 0x0000 }, /* R15450 */ - { 0x0000, 0x0000, 0x0000 }, /* R15451 */ - { 0x0000, 0x0000, 0x0000 }, /* R15452 */ - { 0x0000, 0x0000, 0x0000 }, /* R15453 */ - { 0x0000, 0x0000, 0x0000 }, /* R15454 */ - { 0x0000, 0x0000, 0x0000 }, /* R15455 */ - { 0x0000, 0x0000, 0x0000 }, /* R15456 */ - { 0x0000, 0x0000, 0x0000 }, /* R15457 */ - { 0x0000, 0x0000, 0x0000 }, /* R15458 */ - { 0x0000, 0x0000, 0x0000 }, /* R15459 */ - { 0x0000, 0x0000, 0x0000 }, /* R15460 */ - { 0x0000, 0x0000, 0x0000 }, /* R15461 */ - { 0x0000, 0x0000, 0x0000 }, /* R15462 */ - { 0x0000, 0x0000, 0x0000 }, /* R15463 */ - { 0x0000, 0x0000, 0x0000 }, /* R15464 */ - { 0x0000, 0x0000, 0x0000 }, /* R15465 */ - { 0x0000, 0x0000, 0x0000 }, /* R15466 */ - { 0x0000, 0x0000, 0x0000 }, /* R15467 */ - { 0x0000, 0x0000, 0x0000 }, /* R15468 */ - { 0x0000, 0x0000, 0x0000 }, /* R15469 */ - { 0x0000, 0x0000, 0x0000 }, /* R15470 */ - { 0x0000, 0x0000, 0x0000 }, /* R15471 */ - { 0x0000, 0x0000, 0x0000 }, /* R15472 */ - { 0x0000, 0x0000, 0x0000 }, /* R15473 */ - { 0x0000, 0x0000, 0x0000 }, /* R15474 */ - { 0x0000, 0x0000, 0x0000 }, /* R15475 */ - { 0x0000, 0x0000, 0x0000 }, /* R15476 */ - { 0x0000, 0x0000, 0x0000 }, /* R15477 */ - { 0x0000, 0x0000, 0x0000 }, /* R15478 */ - { 0x0000, 0x0000, 0x0000 }, /* R15479 */ - { 0x0000, 0x0000, 0x0000 }, /* R15480 */ - { 0x0000, 0x0000, 0x0000 }, /* R15481 */ - { 0x0000, 0x0000, 0x0000 }, /* R15482 */ - { 0x0000, 0x0000, 0x0000 }, /* R15483 */ - { 0x0000, 0x0000, 0x0000 }, /* R15484 */ - { 0x0000, 0x0000, 0x0000 }, /* R15485 */ - { 0x0000, 0x0000, 0x0000 }, /* R15486 */ - { 0x0000, 0x0000, 0x0000 }, /* R15487 */ - { 0x0000, 0x0000, 0x0000 }, /* R15488 */ - { 0x0000, 0x0000, 0x0000 }, /* R15489 */ - { 0x0000, 0x0000, 0x0000 }, /* R15490 */ - { 0x0000, 0x0000, 0x0000 }, /* R15491 */ - { 0x0000, 0x0000, 0x0000 }, /* R15492 */ - { 0x0000, 0x0000, 0x0000 }, /* R15493 */ - { 0x0000, 0x0000, 0x0000 }, /* R15494 */ - { 0x0000, 0x0000, 0x0000 }, /* R15495 */ - { 0x0000, 0x0000, 0x0000 }, /* R15496 */ - { 0x0000, 0x0000, 0x0000 }, /* R15497 */ - { 0x0000, 0x0000, 0x0000 }, /* R15498 */ - { 0x0000, 0x0000, 0x0000 }, /* R15499 */ - { 0x0000, 0x0000, 0x0000 }, /* R15500 */ - { 0x0000, 0x0000, 0x0000 }, /* R15501 */ - { 0x0000, 0x0000, 0x0000 }, /* R15502 */ - { 0x0000, 0x0000, 0x0000 }, /* R15503 */ - { 0x0000, 0x0000, 0x0000 }, /* R15504 */ - { 0x0000, 0x0000, 0x0000 }, /* R15505 */ - { 0x0000, 0x0000, 0x0000 }, /* R15506 */ - { 0x0000, 0x0000, 0x0000 }, /* R15507 */ - { 0x0000, 0x0000, 0x0000 }, /* R15508 */ - { 0x0000, 0x0000, 0x0000 }, /* R15509 */ - { 0x0000, 0x0000, 0x0000 }, /* R15510 */ - { 0x0000, 0x0000, 0x0000 }, /* R15511 */ - { 0x0000, 0x0000, 0x0000 }, /* R15512 */ - { 0x0000, 0x0000, 0x0000 }, /* R15513 */ - { 0x0000, 0x0000, 0x0000 }, /* R15514 */ - { 0x0000, 0x0000, 0x0000 }, /* R15515 */ - { 0x0000, 0x0000, 0x0000 }, /* R15516 */ - { 0x0000, 0x0000, 0x0000 }, /* R15517 */ - { 0x0000, 0x0000, 0x0000 }, /* R15518 */ - { 0x0000, 0x0000, 0x0000 }, /* R15519 */ - { 0x0000, 0x0000, 0x0000 }, /* R15520 */ - { 0x0000, 0x0000, 0x0000 }, /* R15521 */ - { 0x0000, 0x0000, 0x0000 }, /* R15522 */ - { 0x0000, 0x0000, 0x0000 }, /* R15523 */ - { 0x0000, 0x0000, 0x0000 }, /* R15524 */ - { 0x0000, 0x0000, 0x0000 }, /* R15525 */ - { 0x0000, 0x0000, 0x0000 }, /* R15526 */ - { 0x0000, 0x0000, 0x0000 }, /* R15527 */ - { 0x0000, 0x0000, 0x0000 }, /* R15528 */ - { 0x0000, 0x0000, 0x0000 }, /* R15529 */ - { 0x0000, 0x0000, 0x0000 }, /* R15530 */ - { 0x0000, 0x0000, 0x0000 }, /* R15531 */ - { 0x0000, 0x0000, 0x0000 }, /* R15532 */ - { 0x0000, 0x0000, 0x0000 }, /* R15533 */ - { 0x0000, 0x0000, 0x0000 }, /* R15534 */ - { 0x0000, 0x0000, 0x0000 }, /* R15535 */ - { 0x0000, 0x0000, 0x0000 }, /* R15536 */ - { 0x0000, 0x0000, 0x0000 }, /* R15537 */ - { 0x0000, 0x0000, 0x0000 }, /* R15538 */ - { 0x0000, 0x0000, 0x0000 }, /* R15539 */ - { 0x0000, 0x0000, 0x0000 }, /* R15540 */ - { 0x0000, 0x0000, 0x0000 }, /* R15541 */ - { 0x0000, 0x0000, 0x0000 }, /* R15542 */ - { 0x0000, 0x0000, 0x0000 }, /* R15543 */ - { 0x0000, 0x0000, 0x0000 }, /* R15544 */ - { 0x0000, 0x0000, 0x0000 }, /* R15545 */ - { 0x0000, 0x0000, 0x0000 }, /* R15546 */ - { 0x0000, 0x0000, 0x0000 }, /* R15547 */ - { 0x0000, 0x0000, 0x0000 }, /* R15548 */ - { 0x0000, 0x0000, 0x0000 }, /* R15549 */ - { 0x0000, 0x0000, 0x0000 }, /* R15550 */ - { 0x0000, 0x0000, 0x0000 }, /* R15551 */ - { 0x0000, 0x0000, 0x0000 }, /* R15552 */ - { 0x0000, 0x0000, 0x0000 }, /* R15553 */ - { 0x0000, 0x0000, 0x0000 }, /* R15554 */ - { 0x0000, 0x0000, 0x0000 }, /* R15555 */ - { 0x0000, 0x0000, 0x0000 }, /* R15556 */ - { 0x0000, 0x0000, 0x0000 }, /* R15557 */ - { 0x0000, 0x0000, 0x0000 }, /* R15558 */ - { 0x0000, 0x0000, 0x0000 }, /* R15559 */ - { 0x0000, 0x0000, 0x0000 }, /* R15560 */ - { 0x0000, 0x0000, 0x0000 }, /* R15561 */ - { 0x0000, 0x0000, 0x0000 }, /* R15562 */ - { 0x0000, 0x0000, 0x0000 }, /* R15563 */ - { 0x0000, 0x0000, 0x0000 }, /* R15564 */ - { 0x0000, 0x0000, 0x0000 }, /* R15565 */ - { 0x0000, 0x0000, 0x0000 }, /* R15566 */ - { 0x0000, 0x0000, 0x0000 }, /* R15567 */ - { 0x0000, 0x0000, 0x0000 }, /* R15568 */ - { 0x0000, 0x0000, 0x0000 }, /* R15569 */ - { 0x0000, 0x0000, 0x0000 }, /* R15570 */ - { 0x0000, 0x0000, 0x0000 }, /* R15571 */ - { 0x0000, 0x0000, 0x0000 }, /* R15572 */ - { 0x0000, 0x0000, 0x0000 }, /* R15573 */ - { 0x0000, 0x0000, 0x0000 }, /* R15574 */ - { 0x0000, 0x0000, 0x0000 }, /* R15575 */ - { 0x0000, 0x0000, 0x0000 }, /* R15576 */ - { 0x0000, 0x0000, 0x0000 }, /* R15577 */ - { 0x0000, 0x0000, 0x0000 }, /* R15578 */ - { 0x0000, 0x0000, 0x0000 }, /* R15579 */ - { 0x0000, 0x0000, 0x0000 }, /* R15580 */ - { 0x0000, 0x0000, 0x0000 }, /* R15581 */ - { 0x0000, 0x0000, 0x0000 }, /* R15582 */ - { 0x0000, 0x0000, 0x0000 }, /* R15583 */ - { 0x0000, 0x0000, 0x0000 }, /* R15584 */ - { 0x0000, 0x0000, 0x0000 }, /* R15585 */ - { 0x0000, 0x0000, 0x0000 }, /* R15586 */ - { 0x0000, 0x0000, 0x0000 }, /* R15587 */ - { 0x0000, 0x0000, 0x0000 }, /* R15588 */ - { 0x0000, 0x0000, 0x0000 }, /* R15589 */ - { 0x0000, 0x0000, 0x0000 }, /* R15590 */ - { 0x0000, 0x0000, 0x0000 }, /* R15591 */ - { 0x0000, 0x0000, 0x0000 }, /* R15592 */ - { 0x0000, 0x0000, 0x0000 }, /* R15593 */ - { 0x0000, 0x0000, 0x0000 }, /* R15594 */ - { 0x0000, 0x0000, 0x0000 }, /* R15595 */ - { 0x0000, 0x0000, 0x0000 }, /* R15596 */ - { 0x0000, 0x0000, 0x0000 }, /* R15597 */ - { 0x0000, 0x0000, 0x0000 }, /* R15598 */ - { 0x0000, 0x0000, 0x0000 }, /* R15599 */ - { 0x0000, 0x0000, 0x0000 }, /* R15600 */ - { 0x0000, 0x0000, 0x0000 }, /* R15601 */ - { 0x0000, 0x0000, 0x0000 }, /* R15602 */ - { 0x0000, 0x0000, 0x0000 }, /* R15603 */ - { 0x0000, 0x0000, 0x0000 }, /* R15604 */ - { 0x0000, 0x0000, 0x0000 }, /* R15605 */ - { 0x0000, 0x0000, 0x0000 }, /* R15606 */ - { 0x0000, 0x0000, 0x0000 }, /* R15607 */ - { 0x0000, 0x0000, 0x0000 }, /* R15608 */ - { 0x0000, 0x0000, 0x0000 }, /* R15609 */ - { 0x0000, 0x0000, 0x0000 }, /* R15610 */ - { 0x0000, 0x0000, 0x0000 }, /* R15611 */ - { 0x0000, 0x0000, 0x0000 }, /* R15612 */ - { 0x0000, 0x0000, 0x0000 }, /* R15613 */ - { 0x0000, 0x0000, 0x0000 }, /* R15614 */ - { 0x0000, 0x0000, 0x0000 }, /* R15615 */ - { 0x0000, 0x0000, 0x0000 }, /* R15616 */ - { 0x0000, 0x0000, 0x0000 }, /* R15617 */ - { 0x0000, 0x0000, 0x0000 }, /* R15618 */ - { 0x0000, 0x0000, 0x0000 }, /* R15619 */ - { 0x0000, 0x0000, 0x0000 }, /* R15620 */ - { 0x0000, 0x0000, 0x0000 }, /* R15621 */ - { 0x0000, 0x0000, 0x0000 }, /* R15622 */ - { 0x0000, 0x0000, 0x0000 }, /* R15623 */ - { 0x0000, 0x0000, 0x0000 }, /* R15624 */ - { 0x0000, 0x0000, 0x0000 }, /* R15625 */ - { 0x0000, 0x0000, 0x0000 }, /* R15626 */ - { 0x0000, 0x0000, 0x0000 }, /* R15627 */ - { 0x0000, 0x0000, 0x0000 }, /* R15628 */ - { 0x0000, 0x0000, 0x0000 }, /* R15629 */ - { 0x0000, 0x0000, 0x0000 }, /* R15630 */ - { 0x0000, 0x0000, 0x0000 }, /* R15631 */ - { 0x0000, 0x0000, 0x0000 }, /* R15632 */ - { 0x0000, 0x0000, 0x0000 }, /* R15633 */ - { 0x0000, 0x0000, 0x0000 }, /* R15634 */ - { 0x0000, 0x0000, 0x0000 }, /* R15635 */ - { 0x0000, 0x0000, 0x0000 }, /* R15636 */ - { 0x0000, 0x0000, 0x0000 }, /* R15637 */ - { 0x0000, 0x0000, 0x0000 }, /* R15638 */ - { 0x0000, 0x0000, 0x0000 }, /* R15639 */ - { 0x0000, 0x0000, 0x0000 }, /* R15640 */ - { 0x0000, 0x0000, 0x0000 }, /* R15641 */ - { 0x0000, 0x0000, 0x0000 }, /* R15642 */ - { 0x0000, 0x0000, 0x0000 }, /* R15643 */ - { 0x0000, 0x0000, 0x0000 }, /* R15644 */ - { 0x0000, 0x0000, 0x0000 }, /* R15645 */ - { 0x0000, 0x0000, 0x0000 }, /* R15646 */ - { 0x0000, 0x0000, 0x0000 }, /* R15647 */ - { 0x0000, 0x0000, 0x0000 }, /* R15648 */ - { 0x0000, 0x0000, 0x0000 }, /* R15649 */ - { 0x0000, 0x0000, 0x0000 }, /* R15650 */ - { 0x0000, 0x0000, 0x0000 }, /* R15651 */ - { 0x0000, 0x0000, 0x0000 }, /* R15652 */ - { 0x0000, 0x0000, 0x0000 }, /* R15653 */ - { 0x0000, 0x0000, 0x0000 }, /* R15654 */ - { 0x0000, 0x0000, 0x0000 }, /* R15655 */ - { 0x0000, 0x0000, 0x0000 }, /* R15656 */ - { 0x0000, 0x0000, 0x0000 }, /* R15657 */ - { 0x0000, 0x0000, 0x0000 }, /* R15658 */ - { 0x0000, 0x0000, 0x0000 }, /* R15659 */ - { 0x0000, 0x0000, 0x0000 }, /* R15660 */ - { 0x0000, 0x0000, 0x0000 }, /* R15661 */ - { 0x0000, 0x0000, 0x0000 }, /* R15662 */ - { 0x0000, 0x0000, 0x0000 }, /* R15663 */ - { 0x0000, 0x0000, 0x0000 }, /* R15664 */ - { 0x0000, 0x0000, 0x0000 }, /* R15665 */ - { 0x0000, 0x0000, 0x0000 }, /* R15666 */ - { 0x0000, 0x0000, 0x0000 }, /* R15667 */ - { 0x0000, 0x0000, 0x0000 }, /* R15668 */ - { 0x0000, 0x0000, 0x0000 }, /* R15669 */ - { 0x0000, 0x0000, 0x0000 }, /* R15670 */ - { 0x0000, 0x0000, 0x0000 }, /* R15671 */ - { 0x0000, 0x0000, 0x0000 }, /* R15672 */ - { 0x0000, 0x0000, 0x0000 }, /* R15673 */ - { 0x0000, 0x0000, 0x0000 }, /* R15674 */ - { 0x0000, 0x0000, 0x0000 }, /* R15675 */ - { 0x0000, 0x0000, 0x0000 }, /* R15676 */ - { 0x0000, 0x0000, 0x0000 }, /* R15677 */ - { 0x0000, 0x0000, 0x0000 }, /* R15678 */ - { 0x0000, 0x0000, 0x0000 }, /* R15679 */ - { 0x0000, 0x0000, 0x0000 }, /* R15680 */ - { 0x0000, 0x0000, 0x0000 }, /* R15681 */ - { 0x0000, 0x0000, 0x0000 }, /* R15682 */ - { 0x0000, 0x0000, 0x0000 }, /* R15683 */ - { 0x0000, 0x0000, 0x0000 }, /* R15684 */ - { 0x0000, 0x0000, 0x0000 }, /* R15685 */ - { 0x0000, 0x0000, 0x0000 }, /* R15686 */ - { 0x0000, 0x0000, 0x0000 }, /* R15687 */ - { 0x0000, 0x0000, 0x0000 }, /* R15688 */ - { 0x0000, 0x0000, 0x0000 }, /* R15689 */ - { 0x0000, 0x0000, 0x0000 }, /* R15690 */ - { 0x0000, 0x0000, 0x0000 }, /* R15691 */ - { 0x0000, 0x0000, 0x0000 }, /* R15692 */ - { 0x0000, 0x0000, 0x0000 }, /* R15693 */ - { 0x0000, 0x0000, 0x0000 }, /* R15694 */ - { 0x0000, 0x0000, 0x0000 }, /* R15695 */ - { 0x0000, 0x0000, 0x0000 }, /* R15696 */ - { 0x0000, 0x0000, 0x0000 }, /* R15697 */ - { 0x0000, 0x0000, 0x0000 }, /* R15698 */ - { 0x0000, 0x0000, 0x0000 }, /* R15699 */ - { 0x0000, 0x0000, 0x0000 }, /* R15700 */ - { 0x0000, 0x0000, 0x0000 }, /* R15701 */ - { 0x0000, 0x0000, 0x0000 }, /* R15702 */ - { 0x0000, 0x0000, 0x0000 }, /* R15703 */ - { 0x0000, 0x0000, 0x0000 }, /* R15704 */ - { 0x0000, 0x0000, 0x0000 }, /* R15705 */ - { 0x0000, 0x0000, 0x0000 }, /* R15706 */ - { 0x0000, 0x0000, 0x0000 }, /* R15707 */ - { 0x0000, 0x0000, 0x0000 }, /* R15708 */ - { 0x0000, 0x0000, 0x0000 }, /* R15709 */ - { 0x0000, 0x0000, 0x0000 }, /* R15710 */ - { 0x0000, 0x0000, 0x0000 }, /* R15711 */ - { 0x0000, 0x0000, 0x0000 }, /* R15712 */ - { 0x0000, 0x0000, 0x0000 }, /* R15713 */ - { 0x0000, 0x0000, 0x0000 }, /* R15714 */ - { 0x0000, 0x0000, 0x0000 }, /* R15715 */ - { 0x0000, 0x0000, 0x0000 }, /* R15716 */ - { 0x0000, 0x0000, 0x0000 }, /* R15717 */ - { 0x0000, 0x0000, 0x0000 }, /* R15718 */ - { 0x0000, 0x0000, 0x0000 }, /* R15719 */ - { 0x0000, 0x0000, 0x0000 }, /* R15720 */ - { 0x0000, 0x0000, 0x0000 }, /* R15721 */ - { 0x0000, 0x0000, 0x0000 }, /* R15722 */ - { 0x0000, 0x0000, 0x0000 }, /* R15723 */ - { 0x0000, 0x0000, 0x0000 }, /* R15724 */ - { 0x0000, 0x0000, 0x0000 }, /* R15725 */ - { 0x0000, 0x0000, 0x0000 }, /* R15726 */ - { 0x0000, 0x0000, 0x0000 }, /* R15727 */ - { 0x0000, 0x0000, 0x0000 }, /* R15728 */ - { 0x0000, 0x0000, 0x0000 }, /* R15729 */ - { 0x0000, 0x0000, 0x0000 }, /* R15730 */ - { 0x0000, 0x0000, 0x0000 }, /* R15731 */ - { 0x0000, 0x0000, 0x0000 }, /* R15732 */ - { 0x0000, 0x0000, 0x0000 }, /* R15733 */ - { 0x0000, 0x0000, 0x0000 }, /* R15734 */ - { 0x0000, 0x0000, 0x0000 }, /* R15735 */ - { 0x0000, 0x0000, 0x0000 }, /* R15736 */ - { 0x0000, 0x0000, 0x0000 }, /* R15737 */ - { 0x0000, 0x0000, 0x0000 }, /* R15738 */ - { 0x0000, 0x0000, 0x0000 }, /* R15739 */ - { 0x0000, 0x0000, 0x0000 }, /* R15740 */ - { 0x0000, 0x0000, 0x0000 }, /* R15741 */ - { 0x0000, 0x0000, 0x0000 }, /* R15742 */ - { 0x0000, 0x0000, 0x0000 }, /* R15743 */ - { 0x0000, 0x0000, 0x0000 }, /* R15744 */ - { 0x0000, 0x0000, 0x0000 }, /* R15745 */ - { 0x0000, 0x0000, 0x0000 }, /* R15746 */ - { 0x0000, 0x0000, 0x0000 }, /* R15747 */ - { 0x0000, 0x0000, 0x0000 }, /* R15748 */ - { 0x0000, 0x0000, 0x0000 }, /* R15749 */ - { 0x0000, 0x0000, 0x0000 }, /* R15750 */ - { 0x0000, 0x0000, 0x0000 }, /* R15751 */ - { 0x0000, 0x0000, 0x0000 }, /* R15752 */ - { 0x0000, 0x0000, 0x0000 }, /* R15753 */ - { 0x0000, 0x0000, 0x0000 }, /* R15754 */ - { 0x0000, 0x0000, 0x0000 }, /* R15755 */ - { 0x0000, 0x0000, 0x0000 }, /* R15756 */ - { 0x0000, 0x0000, 0x0000 }, /* R15757 */ - { 0x0000, 0x0000, 0x0000 }, /* R15758 */ - { 0x0000, 0x0000, 0x0000 }, /* R15759 */ - { 0x0000, 0x0000, 0x0000 }, /* R15760 */ - { 0x0000, 0x0000, 0x0000 }, /* R15761 */ - { 0x0000, 0x0000, 0x0000 }, /* R15762 */ - { 0x0000, 0x0000, 0x0000 }, /* R15763 */ - { 0x0000, 0x0000, 0x0000 }, /* R15764 */ - { 0x0000, 0x0000, 0x0000 }, /* R15765 */ - { 0x0000, 0x0000, 0x0000 }, /* R15766 */ - { 0x0000, 0x0000, 0x0000 }, /* R15767 */ - { 0x0000, 0x0000, 0x0000 }, /* R15768 */ - { 0x0000, 0x0000, 0x0000 }, /* R15769 */ - { 0x0000, 0x0000, 0x0000 }, /* R15770 */ - { 0x0000, 0x0000, 0x0000 }, /* R15771 */ - { 0x0000, 0x0000, 0x0000 }, /* R15772 */ - { 0x0000, 0x0000, 0x0000 }, /* R15773 */ - { 0x0000, 0x0000, 0x0000 }, /* R15774 */ - { 0x0000, 0x0000, 0x0000 }, /* R15775 */ - { 0x0000, 0x0000, 0x0000 }, /* R15776 */ - { 0x0000, 0x0000, 0x0000 }, /* R15777 */ - { 0x0000, 0x0000, 0x0000 }, /* R15778 */ - { 0x0000, 0x0000, 0x0000 }, /* R15779 */ - { 0x0000, 0x0000, 0x0000 }, /* R15780 */ - { 0x0000, 0x0000, 0x0000 }, /* R15781 */ - { 0x0000, 0x0000, 0x0000 }, /* R15782 */ - { 0x0000, 0x0000, 0x0000 }, /* R15783 */ - { 0x0000, 0x0000, 0x0000 }, /* R15784 */ - { 0x0000, 0x0000, 0x0000 }, /* R15785 */ - { 0x0000, 0x0000, 0x0000 }, /* R15786 */ - { 0x0000, 0x0000, 0x0000 }, /* R15787 */ - { 0x0000, 0x0000, 0x0000 }, /* R15788 */ - { 0x0000, 0x0000, 0x0000 }, /* R15789 */ - { 0x0000, 0x0000, 0x0000 }, /* R15790 */ - { 0x0000, 0x0000, 0x0000 }, /* R15791 */ - { 0x0000, 0x0000, 0x0000 }, /* R15792 */ - { 0x0000, 0x0000, 0x0000 }, /* R15793 */ - { 0x0000, 0x0000, 0x0000 }, /* R15794 */ - { 0x0000, 0x0000, 0x0000 }, /* R15795 */ - { 0x0000, 0x0000, 0x0000 }, /* R15796 */ - { 0x0000, 0x0000, 0x0000 }, /* R15797 */ - { 0x0000, 0x0000, 0x0000 }, /* R15798 */ - { 0x0000, 0x0000, 0x0000 }, /* R15799 */ - { 0x0000, 0x0000, 0x0000 }, /* R15800 */ - { 0x0000, 0x0000, 0x0000 }, /* R15801 */ - { 0x0000, 0x0000, 0x0000 }, /* R15802 */ - { 0x0000, 0x0000, 0x0000 }, /* R15803 */ - { 0x0000, 0x0000, 0x0000 }, /* R15804 */ - { 0x0000, 0x0000, 0x0000 }, /* R15805 */ - { 0x0000, 0x0000, 0x0000 }, /* R15806 */ - { 0x0000, 0x0000, 0x0000 }, /* R15807 */ - { 0x0000, 0x0000, 0x0000 }, /* R15808 */ - { 0x0000, 0x0000, 0x0000 }, /* R15809 */ - { 0x0000, 0x0000, 0x0000 }, /* R15810 */ - { 0x0000, 0x0000, 0x0000 }, /* R15811 */ - { 0x0000, 0x0000, 0x0000 }, /* R15812 */ - { 0x0000, 0x0000, 0x0000 }, /* R15813 */ - { 0x0000, 0x0000, 0x0000 }, /* R15814 */ - { 0x0000, 0x0000, 0x0000 }, /* R15815 */ - { 0x0000, 0x0000, 0x0000 }, /* R15816 */ - { 0x0000, 0x0000, 0x0000 }, /* R15817 */ - { 0x0000, 0x0000, 0x0000 }, /* R15818 */ - { 0x0000, 0x0000, 0x0000 }, /* R15819 */ - { 0x0000, 0x0000, 0x0000 }, /* R15820 */ - { 0x0000, 0x0000, 0x0000 }, /* R15821 */ - { 0x0000, 0x0000, 0x0000 }, /* R15822 */ - { 0x0000, 0x0000, 0x0000 }, /* R15823 */ - { 0x0000, 0x0000, 0x0000 }, /* R15824 */ - { 0x0000, 0x0000, 0x0000 }, /* R15825 */ - { 0x0000, 0x0000, 0x0000 }, /* R15826 */ - { 0x0000, 0x0000, 0x0000 }, /* R15827 */ - { 0x0000, 0x0000, 0x0000 }, /* R15828 */ - { 0x0000, 0x0000, 0x0000 }, /* R15829 */ - { 0x0000, 0x0000, 0x0000 }, /* R15830 */ - { 0x0000, 0x0000, 0x0000 }, /* R15831 */ - { 0x0000, 0x0000, 0x0000 }, /* R15832 */ - { 0x0000, 0x0000, 0x0000 }, /* R15833 */ - { 0x0000, 0x0000, 0x0000 }, /* R15834 */ - { 0x0000, 0x0000, 0x0000 }, /* R15835 */ - { 0x0000, 0x0000, 0x0000 }, /* R15836 */ - { 0x0000, 0x0000, 0x0000 }, /* R15837 */ - { 0x0000, 0x0000, 0x0000 }, /* R15838 */ - { 0x0000, 0x0000, 0x0000 }, /* R15839 */ - { 0x0000, 0x0000, 0x0000 }, /* R15840 */ - { 0x0000, 0x0000, 0x0000 }, /* R15841 */ - { 0x0000, 0x0000, 0x0000 }, /* R15842 */ - { 0x0000, 0x0000, 0x0000 }, /* R15843 */ - { 0x0000, 0x0000, 0x0000 }, /* R15844 */ - { 0x0000, 0x0000, 0x0000 }, /* R15845 */ - { 0x0000, 0x0000, 0x0000 }, /* R15846 */ - { 0x0000, 0x0000, 0x0000 }, /* R15847 */ - { 0x0000, 0x0000, 0x0000 }, /* R15848 */ - { 0x0000, 0x0000, 0x0000 }, /* R15849 */ - { 0x0000, 0x0000, 0x0000 }, /* R15850 */ - { 0x0000, 0x0000, 0x0000 }, /* R15851 */ - { 0x0000, 0x0000, 0x0000 }, /* R15852 */ - { 0x0000, 0x0000, 0x0000 }, /* R15853 */ - { 0x0000, 0x0000, 0x0000 }, /* R15854 */ - { 0x0000, 0x0000, 0x0000 }, /* R15855 */ - { 0x0000, 0x0000, 0x0000 }, /* R15856 */ - { 0x0000, 0x0000, 0x0000 }, /* R15857 */ - { 0x0000, 0x0000, 0x0000 }, /* R15858 */ - { 0x0000, 0x0000, 0x0000 }, /* R15859 */ - { 0x0000, 0x0000, 0x0000 }, /* R15860 */ - { 0x0000, 0x0000, 0x0000 }, /* R15861 */ - { 0x0000, 0x0000, 0x0000 }, /* R15862 */ - { 0x0000, 0x0000, 0x0000 }, /* R15863 */ - { 0x0000, 0x0000, 0x0000 }, /* R15864 */ - { 0x0000, 0x0000, 0x0000 }, /* R15865 */ - { 0x0000, 0x0000, 0x0000 }, /* R15866 */ - { 0x0000, 0x0000, 0x0000 }, /* R15867 */ - { 0x0000, 0x0000, 0x0000 }, /* R15868 */ - { 0x0000, 0x0000, 0x0000 }, /* R15869 */ - { 0x0000, 0x0000, 0x0000 }, /* R15870 */ - { 0x0000, 0x0000, 0x0000 }, /* R15871 */ - { 0x0000, 0x0000, 0x0000 }, /* R15872 */ - { 0x0000, 0x0000, 0x0000 }, /* R15873 */ - { 0x0000, 0x0000, 0x0000 }, /* R15874 */ - { 0x0000, 0x0000, 0x0000 }, /* R15875 */ - { 0x0000, 0x0000, 0x0000 }, /* R15876 */ - { 0x0000, 0x0000, 0x0000 }, /* R15877 */ - { 0x0000, 0x0000, 0x0000 }, /* R15878 */ - { 0x0000, 0x0000, 0x0000 }, /* R15879 */ - { 0x0000, 0x0000, 0x0000 }, /* R15880 */ - { 0x0000, 0x0000, 0x0000 }, /* R15881 */ - { 0x0000, 0x0000, 0x0000 }, /* R15882 */ - { 0x0000, 0x0000, 0x0000 }, /* R15883 */ - { 0x0000, 0x0000, 0x0000 }, /* R15884 */ - { 0x0000, 0x0000, 0x0000 }, /* R15885 */ - { 0x0000, 0x0000, 0x0000 }, /* R15886 */ - { 0x0000, 0x0000, 0x0000 }, /* R15887 */ - { 0x0000, 0x0000, 0x0000 }, /* R15888 */ - { 0x0000, 0x0000, 0x0000 }, /* R15889 */ - { 0x0000, 0x0000, 0x0000 }, /* R15890 */ - { 0x0000, 0x0000, 0x0000 }, /* R15891 */ - { 0x0000, 0x0000, 0x0000 }, /* R15892 */ - { 0x0000, 0x0000, 0x0000 }, /* R15893 */ - { 0x0000, 0x0000, 0x0000 }, /* R15894 */ - { 0x0000, 0x0000, 0x0000 }, /* R15895 */ - { 0x0000, 0x0000, 0x0000 }, /* R15896 */ - { 0x0000, 0x0000, 0x0000 }, /* R15897 */ - { 0x0000, 0x0000, 0x0000 }, /* R15898 */ - { 0x0000, 0x0000, 0x0000 }, /* R15899 */ - { 0x0000, 0x0000, 0x0000 }, /* R15900 */ - { 0x0000, 0x0000, 0x0000 }, /* R15901 */ - { 0x0000, 0x0000, 0x0000 }, /* R15902 */ - { 0x0000, 0x0000, 0x0000 }, /* R15903 */ - { 0x0000, 0x0000, 0x0000 }, /* R15904 */ - { 0x0000, 0x0000, 0x0000 }, /* R15905 */ - { 0x0000, 0x0000, 0x0000 }, /* R15906 */ - { 0x0000, 0x0000, 0x0000 }, /* R15907 */ - { 0x0000, 0x0000, 0x0000 }, /* R15908 */ - { 0x0000, 0x0000, 0x0000 }, /* R15909 */ - { 0x0000, 0x0000, 0x0000 }, /* R15910 */ - { 0x0000, 0x0000, 0x0000 }, /* R15911 */ - { 0x0000, 0x0000, 0x0000 }, /* R15912 */ - { 0x0000, 0x0000, 0x0000 }, /* R15913 */ - { 0x0000, 0x0000, 0x0000 }, /* R15914 */ - { 0x0000, 0x0000, 0x0000 }, /* R15915 */ - { 0x0000, 0x0000, 0x0000 }, /* R15916 */ - { 0x0000, 0x0000, 0x0000 }, /* R15917 */ - { 0x0000, 0x0000, 0x0000 }, /* R15918 */ - { 0x0000, 0x0000, 0x0000 }, /* R15919 */ - { 0x0000, 0x0000, 0x0000 }, /* R15920 */ - { 0x0000, 0x0000, 0x0000 }, /* R15921 */ - { 0x0000, 0x0000, 0x0000 }, /* R15922 */ - { 0x0000, 0x0000, 0x0000 }, /* R15923 */ - { 0x0000, 0x0000, 0x0000 }, /* R15924 */ - { 0x0000, 0x0000, 0x0000 }, /* R15925 */ - { 0x0000, 0x0000, 0x0000 }, /* R15926 */ - { 0x0000, 0x0000, 0x0000 }, /* R15927 */ - { 0x0000, 0x0000, 0x0000 }, /* R15928 */ - { 0x0000, 0x0000, 0x0000 }, /* R15929 */ - { 0x0000, 0x0000, 0x0000 }, /* R15930 */ - { 0x0000, 0x0000, 0x0000 }, /* R15931 */ - { 0x0000, 0x0000, 0x0000 }, /* R15932 */ - { 0x0000, 0x0000, 0x0000 }, /* R15933 */ - { 0x0000, 0x0000, 0x0000 }, /* R15934 */ - { 0x0000, 0x0000, 0x0000 }, /* R15935 */ - { 0x0000, 0x0000, 0x0000 }, /* R15936 */ - { 0x0000, 0x0000, 0x0000 }, /* R15937 */ - { 0x0000, 0x0000, 0x0000 }, /* R15938 */ - { 0x0000, 0x0000, 0x0000 }, /* R15939 */ - { 0x0000, 0x0000, 0x0000 }, /* R15940 */ - { 0x0000, 0x0000, 0x0000 }, /* R15941 */ - { 0x0000, 0x0000, 0x0000 }, /* R15942 */ - { 0x0000, 0x0000, 0x0000 }, /* R15943 */ - { 0x0000, 0x0000, 0x0000 }, /* R15944 */ - { 0x0000, 0x0000, 0x0000 }, /* R15945 */ - { 0x0000, 0x0000, 0x0000 }, /* R15946 */ - { 0x0000, 0x0000, 0x0000 }, /* R15947 */ - { 0x0000, 0x0000, 0x0000 }, /* R15948 */ - { 0x0000, 0x0000, 0x0000 }, /* R15949 */ - { 0x0000, 0x0000, 0x0000 }, /* R15950 */ - { 0x0000, 0x0000, 0x0000 }, /* R15951 */ - { 0x0000, 0x0000, 0x0000 }, /* R15952 */ - { 0x0000, 0x0000, 0x0000 }, /* R15953 */ - { 0x0000, 0x0000, 0x0000 }, /* R15954 */ - { 0x0000, 0x0000, 0x0000 }, /* R15955 */ - { 0x0000, 0x0000, 0x0000 }, /* R15956 */ - { 0x0000, 0x0000, 0x0000 }, /* R15957 */ - { 0x0000, 0x0000, 0x0000 }, /* R15958 */ - { 0x0000, 0x0000, 0x0000 }, /* R15959 */ - { 0x0000, 0x0000, 0x0000 }, /* R15960 */ - { 0x0000, 0x0000, 0x0000 }, /* R15961 */ - { 0x0000, 0x0000, 0x0000 }, /* R15962 */ - { 0x0000, 0x0000, 0x0000 }, /* R15963 */ - { 0x0000, 0x0000, 0x0000 }, /* R15964 */ - { 0x0000, 0x0000, 0x0000 }, /* R15965 */ - { 0x0000, 0x0000, 0x0000 }, /* R15966 */ - { 0x0000, 0x0000, 0x0000 }, /* R15967 */ - { 0x0000, 0x0000, 0x0000 }, /* R15968 */ - { 0x0000, 0x0000, 0x0000 }, /* R15969 */ - { 0x0000, 0x0000, 0x0000 }, /* R15970 */ - { 0x0000, 0x0000, 0x0000 }, /* R15971 */ - { 0x0000, 0x0000, 0x0000 }, /* R15972 */ - { 0x0000, 0x0000, 0x0000 }, /* R15973 */ - { 0x0000, 0x0000, 0x0000 }, /* R15974 */ - { 0x0000, 0x0000, 0x0000 }, /* R15975 */ - { 0x0000, 0x0000, 0x0000 }, /* R15976 */ - { 0x0000, 0x0000, 0x0000 }, /* R15977 */ - { 0x0000, 0x0000, 0x0000 }, /* R15978 */ - { 0x0000, 0x0000, 0x0000 }, /* R15979 */ - { 0x0000, 0x0000, 0x0000 }, /* R15980 */ - { 0x0000, 0x0000, 0x0000 }, /* R15981 */ - { 0x0000, 0x0000, 0x0000 }, /* R15982 */ - { 0x0000, 0x0000, 0x0000 }, /* R15983 */ - { 0x0000, 0x0000, 0x0000 }, /* R15984 */ - { 0x0000, 0x0000, 0x0000 }, /* R15985 */ - { 0x0000, 0x0000, 0x0000 }, /* R15986 */ - { 0x0000, 0x0000, 0x0000 }, /* R15987 */ - { 0x0000, 0x0000, 0x0000 }, /* R15988 */ - { 0x0000, 0x0000, 0x0000 }, /* R15989 */ - { 0x0000, 0x0000, 0x0000 }, /* R15990 */ - { 0x0000, 0x0000, 0x0000 }, /* R15991 */ - { 0x0000, 0x0000, 0x0000 }, /* R15992 */ - { 0x0000, 0x0000, 0x0000 }, /* R15993 */ - { 0x0000, 0x0000, 0x0000 }, /* R15994 */ - { 0x0000, 0x0000, 0x0000 }, /* R15995 */ - { 0x0000, 0x0000, 0x0000 }, /* R15996 */ - { 0x0000, 0x0000, 0x0000 }, /* R15997 */ - { 0x0000, 0x0000, 0x0000 }, /* R15998 */ - { 0x0000, 0x0000, 0x0000 }, /* R15999 */ - { 0x0000, 0x0000, 0x0000 }, /* R16000 */ - { 0x0000, 0x0000, 0x0000 }, /* R16001 */ - { 0x0000, 0x0000, 0x0000 }, /* R16002 */ - { 0x0000, 0x0000, 0x0000 }, /* R16003 */ - { 0x0000, 0x0000, 0x0000 }, /* R16004 */ - { 0x0000, 0x0000, 0x0000 }, /* R16005 */ - { 0x0000, 0x0000, 0x0000 }, /* R16006 */ - { 0x0000, 0x0000, 0x0000 }, /* R16007 */ - { 0x0000, 0x0000, 0x0000 }, /* R16008 */ - { 0x0000, 0x0000, 0x0000 }, /* R16009 */ - { 0x0000, 0x0000, 0x0000 }, /* R16010 */ - { 0x0000, 0x0000, 0x0000 }, /* R16011 */ - { 0x0000, 0x0000, 0x0000 }, /* R16012 */ - { 0x0000, 0x0000, 0x0000 }, /* R16013 */ - { 0x0000, 0x0000, 0x0000 }, /* R16014 */ - { 0x0000, 0x0000, 0x0000 }, /* R16015 */ - { 0x0000, 0x0000, 0x0000 }, /* R16016 */ - { 0x0000, 0x0000, 0x0000 }, /* R16017 */ - { 0x0000, 0x0000, 0x0000 }, /* R16018 */ - { 0x0000, 0x0000, 0x0000 }, /* R16019 */ - { 0x0000, 0x0000, 0x0000 }, /* R16020 */ - { 0x0000, 0x0000, 0x0000 }, /* R16021 */ - { 0x0000, 0x0000, 0x0000 }, /* R16022 */ - { 0x0000, 0x0000, 0x0000 }, /* R16023 */ - { 0x0000, 0x0000, 0x0000 }, /* R16024 */ - { 0x0000, 0x0000, 0x0000 }, /* R16025 */ - { 0x0000, 0x0000, 0x0000 }, /* R16026 */ - { 0x0000, 0x0000, 0x0000 }, /* R16027 */ - { 0x0000, 0x0000, 0x0000 }, /* R16028 */ - { 0x0000, 0x0000, 0x0000 }, /* R16029 */ - { 0x0000, 0x0000, 0x0000 }, /* R16030 */ - { 0x0000, 0x0000, 0x0000 }, /* R16031 */ - { 0x0000, 0x0000, 0x0000 }, /* R16032 */ - { 0x0000, 0x0000, 0x0000 }, /* R16033 */ - { 0x0000, 0x0000, 0x0000 }, /* R16034 */ - { 0x0000, 0x0000, 0x0000 }, /* R16035 */ - { 0x0000, 0x0000, 0x0000 }, /* R16036 */ - { 0x0000, 0x0000, 0x0000 }, /* R16037 */ - { 0x0000, 0x0000, 0x0000 }, /* R16038 */ - { 0x0000, 0x0000, 0x0000 }, /* R16039 */ - { 0x0000, 0x0000, 0x0000 }, /* R16040 */ - { 0x0000, 0x0000, 0x0000 }, /* R16041 */ - { 0x0000, 0x0000, 0x0000 }, /* R16042 */ - { 0x0000, 0x0000, 0x0000 }, /* R16043 */ - { 0x0000, 0x0000, 0x0000 }, /* R16044 */ - { 0x0000, 0x0000, 0x0000 }, /* R16045 */ - { 0x0000, 0x0000, 0x0000 }, /* R16046 */ - { 0x0000, 0x0000, 0x0000 }, /* R16047 */ - { 0x0000, 0x0000, 0x0000 }, /* R16048 */ - { 0x0000, 0x0000, 0x0000 }, /* R16049 */ - { 0x0000, 0x0000, 0x0000 }, /* R16050 */ - { 0x0000, 0x0000, 0x0000 }, /* R16051 */ - { 0x0000, 0x0000, 0x0000 }, /* R16052 */ - { 0x0000, 0x0000, 0x0000 }, /* R16053 */ - { 0x0000, 0x0000, 0x0000 }, /* R16054 */ - { 0x0000, 0x0000, 0x0000 }, /* R16055 */ - { 0x0000, 0x0000, 0x0000 }, /* R16056 */ - { 0x0000, 0x0000, 0x0000 }, /* R16057 */ - { 0x0000, 0x0000, 0x0000 }, /* R16058 */ - { 0x0000, 0x0000, 0x0000 }, /* R16059 */ - { 0x0000, 0x0000, 0x0000 }, /* R16060 */ - { 0x0000, 0x0000, 0x0000 }, /* R16061 */ - { 0x0000, 0x0000, 0x0000 }, /* R16062 */ - { 0x0000, 0x0000, 0x0000 }, /* R16063 */ - { 0x0000, 0x0000, 0x0000 }, /* R16064 */ - { 0x0000, 0x0000, 0x0000 }, /* R16065 */ - { 0x0000, 0x0000, 0x0000 }, /* R16066 */ - { 0x0000, 0x0000, 0x0000 }, /* R16067 */ - { 0x0000, 0x0000, 0x0000 }, /* R16068 */ - { 0x0000, 0x0000, 0x0000 }, /* R16069 */ - { 0x0000, 0x0000, 0x0000 }, /* R16070 */ - { 0x0000, 0x0000, 0x0000 }, /* R16071 */ - { 0x0000, 0x0000, 0x0000 }, /* R16072 */ - { 0x0000, 0x0000, 0x0000 }, /* R16073 */ - { 0x0000, 0x0000, 0x0000 }, /* R16074 */ - { 0x0000, 0x0000, 0x0000 }, /* R16075 */ - { 0x0000, 0x0000, 0x0000 }, /* R16076 */ - { 0x0000, 0x0000, 0x0000 }, /* R16077 */ - { 0x0000, 0x0000, 0x0000 }, /* R16078 */ - { 0x0000, 0x0000, 0x0000 }, /* R16079 */ - { 0x0000, 0x0000, 0x0000 }, /* R16080 */ - { 0x0000, 0x0000, 0x0000 }, /* R16081 */ - { 0x0000, 0x0000, 0x0000 }, /* R16082 */ - { 0x0000, 0x0000, 0x0000 }, /* R16083 */ - { 0x0000, 0x0000, 0x0000 }, /* R16084 */ - { 0x0000, 0x0000, 0x0000 }, /* R16085 */ - { 0x0000, 0x0000, 0x0000 }, /* R16086 */ - { 0x0000, 0x0000, 0x0000 }, /* R16087 */ - { 0x0000, 0x0000, 0x0000 }, /* R16088 */ - { 0x0000, 0x0000, 0x0000 }, /* R16089 */ - { 0x0000, 0x0000, 0x0000 }, /* R16090 */ - { 0x0000, 0x0000, 0x0000 }, /* R16091 */ - { 0x0000, 0x0000, 0x0000 }, /* R16092 */ - { 0x0000, 0x0000, 0x0000 }, /* R16093 */ - { 0x0000, 0x0000, 0x0000 }, /* R16094 */ - { 0x0000, 0x0000, 0x0000 }, /* R16095 */ - { 0x0000, 0x0000, 0x0000 }, /* R16096 */ - { 0x0000, 0x0000, 0x0000 }, /* R16097 */ - { 0x0000, 0x0000, 0x0000 }, /* R16098 */ - { 0x0000, 0x0000, 0x0000 }, /* R16099 */ - { 0x0000, 0x0000, 0x0000 }, /* R16100 */ - { 0x0000, 0x0000, 0x0000 }, /* R16101 */ - { 0x0000, 0x0000, 0x0000 }, /* R16102 */ - { 0x0000, 0x0000, 0x0000 }, /* R16103 */ - { 0x0000, 0x0000, 0x0000 }, /* R16104 */ - { 0x0000, 0x0000, 0x0000 }, /* R16105 */ - { 0x0000, 0x0000, 0x0000 }, /* R16106 */ - { 0x0000, 0x0000, 0x0000 }, /* R16107 */ - { 0x0000, 0x0000, 0x0000 }, /* R16108 */ - { 0x0000, 0x0000, 0x0000 }, /* R16109 */ - { 0x0000, 0x0000, 0x0000 }, /* R16110 */ - { 0x0000, 0x0000, 0x0000 }, /* R16111 */ - { 0x0000, 0x0000, 0x0000 }, /* R16112 */ - { 0x0000, 0x0000, 0x0000 }, /* R16113 */ - { 0x0000, 0x0000, 0x0000 }, /* R16114 */ - { 0x0000, 0x0000, 0x0000 }, /* R16115 */ - { 0x0000, 0x0000, 0x0000 }, /* R16116 */ - { 0x0000, 0x0000, 0x0000 }, /* R16117 */ - { 0x0000, 0x0000, 0x0000 }, /* R16118 */ - { 0x0000, 0x0000, 0x0000 }, /* R16119 */ - { 0x0000, 0x0000, 0x0000 }, /* R16120 */ - { 0x0000, 0x0000, 0x0000 }, /* R16121 */ - { 0x0000, 0x0000, 0x0000 }, /* R16122 */ - { 0x0000, 0x0000, 0x0000 }, /* R16123 */ - { 0x0000, 0x0000, 0x0000 }, /* R16124 */ - { 0x0000, 0x0000, 0x0000 }, /* R16125 */ - { 0x0000, 0x0000, 0x0000 }, /* R16126 */ - { 0x0000, 0x0000, 0x0000 }, /* R16127 */ - { 0x0000, 0x0000, 0x0000 }, /* R16128 */ - { 0x0000, 0x0000, 0x0000 }, /* R16129 */ - { 0x0000, 0x0000, 0x0000 }, /* R16130 */ - { 0x0000, 0x0000, 0x0000 }, /* R16131 */ - { 0x0000, 0x0000, 0x0000 }, /* R16132 */ - { 0x0000, 0x0000, 0x0000 }, /* R16133 */ - { 0x0000, 0x0000, 0x0000 }, /* R16134 */ - { 0x0000, 0x0000, 0x0000 }, /* R16135 */ - { 0x0000, 0x0000, 0x0000 }, /* R16136 */ - { 0x0000, 0x0000, 0x0000 }, /* R16137 */ - { 0x0000, 0x0000, 0x0000 }, /* R16138 */ - { 0x0000, 0x0000, 0x0000 }, /* R16139 */ - { 0x0000, 0x0000, 0x0000 }, /* R16140 */ - { 0x0000, 0x0000, 0x0000 }, /* R16141 */ - { 0x0000, 0x0000, 0x0000 }, /* R16142 */ - { 0x0000, 0x0000, 0x0000 }, /* R16143 */ - { 0x0000, 0x0000, 0x0000 }, /* R16144 */ - { 0x0000, 0x0000, 0x0000 }, /* R16145 */ - { 0x0000, 0x0000, 0x0000 }, /* R16146 */ - { 0x0000, 0x0000, 0x0000 }, /* R16147 */ - { 0x0000, 0x0000, 0x0000 }, /* R16148 */ - { 0x0000, 0x0000, 0x0000 }, /* R16149 */ - { 0x0000, 0x0000, 0x0000 }, /* R16150 */ - { 0x0000, 0x0000, 0x0000 }, /* R16151 */ - { 0x0000, 0x0000, 0x0000 }, /* R16152 */ - { 0x0000, 0x0000, 0x0000 }, /* R16153 */ - { 0x0000, 0x0000, 0x0000 }, /* R16154 */ - { 0x0000, 0x0000, 0x0000 }, /* R16155 */ - { 0x0000, 0x0000, 0x0000 }, /* R16156 */ - { 0x0000, 0x0000, 0x0000 }, /* R16157 */ - { 0x0000, 0x0000, 0x0000 }, /* R16158 */ - { 0x0000, 0x0000, 0x0000 }, /* R16159 */ - { 0x0000, 0x0000, 0x0000 }, /* R16160 */ - { 0x0000, 0x0000, 0x0000 }, /* R16161 */ - { 0x0000, 0x0000, 0x0000 }, /* R16162 */ - { 0x0000, 0x0000, 0x0000 }, /* R16163 */ - { 0x0000, 0x0000, 0x0000 }, /* R16164 */ - { 0x0000, 0x0000, 0x0000 }, /* R16165 */ - { 0x0000, 0x0000, 0x0000 }, /* R16166 */ - { 0x0000, 0x0000, 0x0000 }, /* R16167 */ - { 0x0000, 0x0000, 0x0000 }, /* R16168 */ - { 0x0000, 0x0000, 0x0000 }, /* R16169 */ - { 0x0000, 0x0000, 0x0000 }, /* R16170 */ - { 0x0000, 0x0000, 0x0000 }, /* R16171 */ - { 0x0000, 0x0000, 0x0000 }, /* R16172 */ - { 0x0000, 0x0000, 0x0000 }, /* R16173 */ - { 0x0000, 0x0000, 0x0000 }, /* R16174 */ - { 0x0000, 0x0000, 0x0000 }, /* R16175 */ - { 0x0000, 0x0000, 0x0000 }, /* R16176 */ - { 0x0000, 0x0000, 0x0000 }, /* R16177 */ - { 0x0000, 0x0000, 0x0000 }, /* R16178 */ - { 0x0000, 0x0000, 0x0000 }, /* R16179 */ - { 0x0000, 0x0000, 0x0000 }, /* R16180 */ - { 0x0000, 0x0000, 0x0000 }, /* R16181 */ - { 0x0000, 0x0000, 0x0000 }, /* R16182 */ - { 0x0000, 0x0000, 0x0000 }, /* R16183 */ - { 0x0000, 0x0000, 0x0000 }, /* R16184 */ - { 0x0000, 0x0000, 0x0000 }, /* R16185 */ - { 0x0000, 0x0000, 0x0000 }, /* R16186 */ - { 0x0000, 0x0000, 0x0000 }, /* R16187 */ - { 0x0000, 0x0000, 0x0000 }, /* R16188 */ - { 0x0000, 0x0000, 0x0000 }, /* R16189 */ - { 0x0000, 0x0000, 0x0000 }, /* R16190 */ - { 0x0000, 0x0000, 0x0000 }, /* R16191 */ - { 0x0000, 0x0000, 0x0000 }, /* R16192 */ - { 0x0000, 0x0000, 0x0000 }, /* R16193 */ - { 0x0000, 0x0000, 0x0000 }, /* R16194 */ - { 0x0000, 0x0000, 0x0000 }, /* R16195 */ - { 0x0000, 0x0000, 0x0000 }, /* R16196 */ - { 0x0000, 0x0000, 0x0000 }, /* R16197 */ - { 0x0000, 0x0000, 0x0000 }, /* R16198 */ - { 0x0000, 0x0000, 0x0000 }, /* R16199 */ - { 0x0000, 0x0000, 0x0000 }, /* R16200 */ - { 0x0000, 0x0000, 0x0000 }, /* R16201 */ - { 0x0000, 0x0000, 0x0000 }, /* R16202 */ - { 0x0000, 0x0000, 0x0000 }, /* R16203 */ - { 0x0000, 0x0000, 0x0000 }, /* R16204 */ - { 0x0000, 0x0000, 0x0000 }, /* R16205 */ - { 0x0000, 0x0000, 0x0000 }, /* R16206 */ - { 0x0000, 0x0000, 0x0000 }, /* R16207 */ - { 0x0000, 0x0000, 0x0000 }, /* R16208 */ - { 0x0000, 0x0000, 0x0000 }, /* R16209 */ - { 0x0000, 0x0000, 0x0000 }, /* R16210 */ - { 0x0000, 0x0000, 0x0000 }, /* R16211 */ - { 0x0000, 0x0000, 0x0000 }, /* R16212 */ - { 0x0000, 0x0000, 0x0000 }, /* R16213 */ - { 0x0000, 0x0000, 0x0000 }, /* R16214 */ - { 0x0000, 0x0000, 0x0000 }, /* R16215 */ - { 0x0000, 0x0000, 0x0000 }, /* R16216 */ - { 0x0000, 0x0000, 0x0000 }, /* R16217 */ - { 0x0000, 0x0000, 0x0000 }, /* R16218 */ - { 0x0000, 0x0000, 0x0000 }, /* R16219 */ - { 0x0000, 0x0000, 0x0000 }, /* R16220 */ - { 0x0000, 0x0000, 0x0000 }, /* R16221 */ - { 0x0000, 0x0000, 0x0000 }, /* R16222 */ - { 0x0000, 0x0000, 0x0000 }, /* R16223 */ - { 0x0000, 0x0000, 0x0000 }, /* R16224 */ - { 0x0000, 0x0000, 0x0000 }, /* R16225 */ - { 0x0000, 0x0000, 0x0000 }, /* R16226 */ - { 0x0000, 0x0000, 0x0000 }, /* R16227 */ - { 0x0000, 0x0000, 0x0000 }, /* R16228 */ - { 0x0000, 0x0000, 0x0000 }, /* R16229 */ - { 0x0000, 0x0000, 0x0000 }, /* R16230 */ - { 0x0000, 0x0000, 0x0000 }, /* R16231 */ - { 0x0000, 0x0000, 0x0000 }, /* R16232 */ - { 0x0000, 0x0000, 0x0000 }, /* R16233 */ - { 0x0000, 0x0000, 0x0000 }, /* R16234 */ - { 0x0000, 0x0000, 0x0000 }, /* R16235 */ - { 0x0000, 0x0000, 0x0000 }, /* R16236 */ - { 0x0000, 0x0000, 0x0000 }, /* R16237 */ - { 0x0000, 0x0000, 0x0000 }, /* R16238 */ - { 0x0000, 0x0000, 0x0000 }, /* R16239 */ - { 0x0000, 0x0000, 0x0000 }, /* R16240 */ - { 0x0000, 0x0000, 0x0000 }, /* R16241 */ - { 0x0000, 0x0000, 0x0000 }, /* R16242 */ - { 0x0000, 0x0000, 0x0000 }, /* R16243 */ - { 0x0000, 0x0000, 0x0000 }, /* R16244 */ - { 0x0000, 0x0000, 0x0000 }, /* R16245 */ - { 0x0000, 0x0000, 0x0000 }, /* R16246 */ - { 0x0000, 0x0000, 0x0000 }, /* R16247 */ - { 0x0000, 0x0000, 0x0000 }, /* R16248 */ - { 0x0000, 0x0000, 0x0000 }, /* R16249 */ - { 0x0000, 0x0000, 0x0000 }, /* R16250 */ - { 0x0000, 0x0000, 0x0000 }, /* R16251 */ - { 0x0000, 0x0000, 0x0000 }, /* R16252 */ - { 0x0000, 0x0000, 0x0000 }, /* R16253 */ - { 0x0000, 0x0000, 0x0000 }, /* R16254 */ - { 0x0000, 0x0000, 0x0000 }, /* R16255 */ - { 0x0000, 0x0000, 0x0000 }, /* R16256 */ - { 0x0000, 0x0000, 0x0000 }, /* R16257 */ - { 0x0000, 0x0000, 0x0000 }, /* R16258 */ - { 0x0000, 0x0000, 0x0000 }, /* R16259 */ - { 0x0000, 0x0000, 0x0000 }, /* R16260 */ - { 0x0000, 0x0000, 0x0000 }, /* R16261 */ - { 0x0000, 0x0000, 0x0000 }, /* R16262 */ - { 0x0000, 0x0000, 0x0000 }, /* R16263 */ - { 0x0000, 0x0000, 0x0000 }, /* R16264 */ - { 0x0000, 0x0000, 0x0000 }, /* R16265 */ - { 0x0000, 0x0000, 0x0000 }, /* R16266 */ - { 0x0000, 0x0000, 0x0000 }, /* R16267 */ - { 0x0000, 0x0000, 0x0000 }, /* R16268 */ - { 0x0000, 0x0000, 0x0000 }, /* R16269 */ - { 0x0000, 0x0000, 0x0000 }, /* R16270 */ - { 0x0000, 0x0000, 0x0000 }, /* R16271 */ - { 0x0000, 0x0000, 0x0000 }, /* R16272 */ - { 0x0000, 0x0000, 0x0000 }, /* R16273 */ - { 0x0000, 0x0000, 0x0000 }, /* R16274 */ - { 0x0000, 0x0000, 0x0000 }, /* R16275 */ - { 0x0000, 0x0000, 0x0000 }, /* R16276 */ - { 0x0000, 0x0000, 0x0000 }, /* R16277 */ - { 0x0000, 0x0000, 0x0000 }, /* R16278 */ - { 0x0000, 0x0000, 0x0000 }, /* R16279 */ - { 0x0000, 0x0000, 0x0000 }, /* R16280 */ - { 0x0000, 0x0000, 0x0000 }, /* R16281 */ - { 0x0000, 0x0000, 0x0000 }, /* R16282 */ - { 0x0000, 0x0000, 0x0000 }, /* R16283 */ - { 0x0000, 0x0000, 0x0000 }, /* R16284 */ - { 0x0000, 0x0000, 0x0000 }, /* R16285 */ - { 0x0000, 0x0000, 0x0000 }, /* R16286 */ - { 0x0000, 0x0000, 0x0000 }, /* R16287 */ - { 0x0000, 0x0000, 0x0000 }, /* R16288 */ - { 0x0000, 0x0000, 0x0000 }, /* R16289 */ - { 0x0000, 0x0000, 0x0000 }, /* R16290 */ - { 0x0000, 0x0000, 0x0000 }, /* R16291 */ - { 0x0000, 0x0000, 0x0000 }, /* R16292 */ - { 0x0000, 0x0000, 0x0000 }, /* R16293 */ - { 0x0000, 0x0000, 0x0000 }, /* R16294 */ - { 0x0000, 0x0000, 0x0000 }, /* R16295 */ - { 0x0000, 0x0000, 0x0000 }, /* R16296 */ - { 0x0000, 0x0000, 0x0000 }, /* R16297 */ - { 0x0000, 0x0000, 0x0000 }, /* R16298 */ - { 0x0000, 0x0000, 0x0000 }, /* R16299 */ - { 0x0000, 0x0000, 0x0000 }, /* R16300 */ - { 0x0000, 0x0000, 0x0000 }, /* R16301 */ - { 0x0000, 0x0000, 0x0000 }, /* R16302 */ - { 0x0000, 0x0000, 0x0000 }, /* R16303 */ - { 0x0000, 0x0000, 0x0000 }, /* R16304 */ - { 0x0000, 0x0000, 0x0000 }, /* R16305 */ - { 0x0000, 0x0000, 0x0000 }, /* R16306 */ - { 0x0000, 0x0000, 0x0000 }, /* R16307 */ - { 0x0000, 0x0000, 0x0000 }, /* R16308 */ - { 0x0000, 0x0000, 0x0000 }, /* R16309 */ - { 0x0000, 0x0000, 0x0000 }, /* R16310 */ - { 0x0000, 0x0000, 0x0000 }, /* R16311 */ - { 0x0000, 0x0000, 0x0000 }, /* R16312 */ - { 0x0000, 0x0000, 0x0000 }, /* R16313 */ - { 0x0000, 0x0000, 0x0000 }, /* R16314 */ - { 0x0000, 0x0000, 0x0000 }, /* R16315 */ - { 0x0000, 0x0000, 0x0000 }, /* R16316 */ - { 0x0000, 0x0000, 0x0000 }, /* R16317 */ - { 0x0000, 0x0000, 0x0000 }, /* R16318 */ - { 0x0000, 0x0000, 0x0000 }, /* R16319 */ - { 0x0000, 0x0000, 0x0000 }, /* R16320 */ - { 0x0000, 0x0000, 0x0000 }, /* R16321 */ - { 0x0000, 0x0000, 0x0000 }, /* R16322 */ - { 0x0000, 0x0000, 0x0000 }, /* R16323 */ - { 0x0000, 0x0000, 0x0000 }, /* R16324 */ - { 0x0000, 0x0000, 0x0000 }, /* R16325 */ - { 0x0000, 0x0000, 0x0000 }, /* R16326 */ - { 0x0000, 0x0000, 0x0000 }, /* R16327 */ - { 0x0000, 0x0000, 0x0000 }, /* R16328 */ - { 0x0000, 0x0000, 0x0000 }, /* R16329 */ - { 0x0000, 0x0000, 0x0000 }, /* R16330 */ - { 0x0000, 0x0000, 0x0000 }, /* R16331 */ - { 0x0000, 0x0000, 0x0000 }, /* R16332 */ - { 0x0000, 0x0000, 0x0000 }, /* R16333 */ - { 0x0000, 0x0000, 0x0000 }, /* R16334 */ - { 0x0000, 0x0000, 0x0000 }, /* R16335 */ - { 0x0000, 0x0000, 0x0000 }, /* R16336 */ - { 0x0000, 0x0000, 0x0000 }, /* R16337 */ - { 0x0000, 0x0000, 0x0000 }, /* R16338 */ - { 0x0000, 0x0000, 0x0000 }, /* R16339 */ - { 0x0000, 0x0000, 0x0000 }, /* R16340 */ - { 0x0000, 0x0000, 0x0000 }, /* R16341 */ - { 0x0000, 0x0000, 0x0000 }, /* R16342 */ - { 0x0000, 0x0000, 0x0000 }, /* R16343 */ - { 0x0000, 0x0000, 0x0000 }, /* R16344 */ - { 0x0000, 0x0000, 0x0000 }, /* R16345 */ - { 0x0000, 0x0000, 0x0000 }, /* R16346 */ - { 0x0000, 0x0000, 0x0000 }, /* R16347 */ - { 0x0000, 0x0000, 0x0000 }, /* R16348 */ - { 0x0000, 0x0000, 0x0000 }, /* R16349 */ - { 0x0000, 0x0000, 0x0000 }, /* R16350 */ - { 0x0000, 0x0000, 0x0000 }, /* R16351 */ - { 0x0000, 0x0000, 0x0000 }, /* R16352 */ - { 0x0000, 0x0000, 0x0000 }, /* R16353 */ - { 0x0000, 0x0000, 0x0000 }, /* R16354 */ - { 0x0000, 0x0000, 0x0000 }, /* R16355 */ - { 0x0000, 0x0000, 0x0000 }, /* R16356 */ - { 0x0000, 0x0000, 0x0000 }, /* R16357 */ - { 0x0000, 0x0000, 0x0000 }, /* R16358 */ - { 0x0000, 0x0000, 0x0000 }, /* R16359 */ - { 0x0000, 0x0000, 0x0000 }, /* R16360 */ - { 0x0000, 0x0000, 0x0000 }, /* R16361 */ - { 0x0000, 0x0000, 0x0000 }, /* R16362 */ - { 0x0000, 0x0000, 0x0000 }, /* R16363 */ - { 0x0000, 0x0000, 0x0000 }, /* R16364 */ - { 0x0000, 0x0000, 0x0000 }, /* R16365 */ - { 0x0000, 0x0000, 0x0000 }, /* R16366 */ - { 0x0000, 0x0000, 0x0000 }, /* R16367 */ - { 0x0000, 0x0000, 0x0000 }, /* R16368 */ - { 0x0000, 0x0000, 0x0000 }, /* R16369 */ - { 0x0000, 0x0000, 0x0000 }, /* R16370 */ - { 0x0000, 0x0000, 0x0000 }, /* R16371 */ - { 0x0000, 0x0000, 0x0000 }, /* R16372 */ - { 0x0000, 0x0000, 0x0000 }, /* R16373 */ - { 0x0000, 0x0000, 0x0000 }, /* R16374 */ - { 0x0000, 0x0000, 0x0000 }, /* R16375 */ - { 0x0000, 0x0000, 0x0000 }, /* R16376 */ - { 0x0000, 0x0000, 0x0000 }, /* R16377 */ - { 0x0000, 0x0000, 0x0000 }, /* R16378 */ - { 0x0000, 0x0000, 0x0000 }, /* R16379 */ - { 0x0000, 0x0000, 0x0000 }, /* R16380 */ - { 0x0000, 0x0000, 0x0000 }, /* R16381 */ - { 0x0000, 0x0000, 0x0000 }, /* R16382 */ - { 0x0000, 0x0000, 0x0000 }, /* R16383 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R16384 - RETUNEADC_SHARED_COEFF_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R16385 - RETUNEADC_SHARED_COEFF_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R16386 - RETUNEDAC_SHARED_COEFF_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R16387 - RETUNEDAC_SHARED_COEFF_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R16388 - SOUNDSTAGE_ENABLES_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R16389 - SOUNDSTAGE_ENABLES_0 */ - { 0x0000, 0x0000, 0x0000 }, /* R16390 */ - { 0x0000, 0x0000, 0x0000 }, /* R16391 */ - { 0x0000, 0x0000, 0x0000 }, /* R16392 */ - { 0x0000, 0x0000, 0x0000 }, /* R16393 */ - { 0x0000, 0x0000, 0x0000 }, /* R16394 */ - { 0x0000, 0x0000, 0x0000 }, /* R16395 */ - { 0x0000, 0x0000, 0x0000 }, /* R16396 */ - { 0x0000, 0x0000, 0x0000 }, /* R16397 */ - { 0x0000, 0x0000, 0x0000 }, /* R16398 */ - { 0x0000, 0x0000, 0x0000 }, /* R16399 */ - { 0x0000, 0x0000, 0x0000 }, /* R16400 */ - { 0x0000, 0x0000, 0x0000 }, /* R16401 */ - { 0x0000, 0x0000, 0x0000 }, /* R16402 */ - { 0x0000, 0x0000, 0x0000 }, /* R16403 */ - { 0x0000, 0x0000, 0x0000 }, /* R16404 */ - { 0x0000, 0x0000, 0x0000 }, /* R16405 */ - { 0x0000, 0x0000, 0x0000 }, /* R16406 */ - { 0x0000, 0x0000, 0x0000 }, /* R16407 */ - { 0x0000, 0x0000, 0x0000 }, /* R16408 */ - { 0x0000, 0x0000, 0x0000 }, /* R16409 */ - { 0x0000, 0x0000, 0x0000 }, /* R16410 */ - { 0x0000, 0x0000, 0x0000 }, /* R16411 */ - { 0x0000, 0x0000, 0x0000 }, /* R16412 */ - { 0x0000, 0x0000, 0x0000 }, /* R16413 */ - { 0x0000, 0x0000, 0x0000 }, /* R16414 */ - { 0x0000, 0x0000, 0x0000 }, /* R16415 */ - { 0x0000, 0x0000, 0x0000 }, /* R16416 */ - { 0x0000, 0x0000, 0x0000 }, /* R16417 */ - { 0x0000, 0x0000, 0x0000 }, /* R16418 */ - { 0x0000, 0x0000, 0x0000 }, /* R16419 */ - { 0x0000, 0x0000, 0x0000 }, /* R16420 */ - { 0x0000, 0x0000, 0x0000 }, /* R16421 */ - { 0x0000, 0x0000, 0x0000 }, /* R16422 */ - { 0x0000, 0x0000, 0x0000 }, /* R16423 */ - { 0x0000, 0x0000, 0x0000 }, /* R16424 */ - { 0x0000, 0x0000, 0x0000 }, /* R16425 */ - { 0x0000, 0x0000, 0x0000 }, /* R16426 */ - { 0x0000, 0x0000, 0x0000 }, /* R16427 */ - { 0x0000, 0x0000, 0x0000 }, /* R16428 */ - { 0x0000, 0x0000, 0x0000 }, /* R16429 */ - { 0x0000, 0x0000, 0x0000 }, /* R16430 */ - { 0x0000, 0x0000, 0x0000 }, /* R16431 */ - { 0x0000, 0x0000, 0x0000 }, /* R16432 */ - { 0x0000, 0x0000, 0x0000 }, /* R16433 */ - { 0x0000, 0x0000, 0x0000 }, /* R16434 */ - { 0x0000, 0x0000, 0x0000 }, /* R16435 */ - { 0x0000, 0x0000, 0x0000 }, /* R16436 */ - { 0x0000, 0x0000, 0x0000 }, /* R16437 */ - { 0x0000, 0x0000, 0x0000 }, /* R16438 */ - { 0x0000, 0x0000, 0x0000 }, /* R16439 */ - { 0x0000, 0x0000, 0x0000 }, /* R16440 */ - { 0x0000, 0x0000, 0x0000 }, /* R16441 */ - { 0x0000, 0x0000, 0x0000 }, /* R16442 */ - { 0x0000, 0x0000, 0x0000 }, /* R16443 */ - { 0x0000, 0x0000, 0x0000 }, /* R16444 */ - { 0x0000, 0x0000, 0x0000 }, /* R16445 */ - { 0x0000, 0x0000, 0x0000 }, /* R16446 */ - { 0x0000, 0x0000, 0x0000 }, /* R16447 */ - { 0x0000, 0x0000, 0x0000 }, /* R16448 */ - { 0x0000, 0x0000, 0x0000 }, /* R16449 */ - { 0x0000, 0x0000, 0x0000 }, /* R16450 */ - { 0x0000, 0x0000, 0x0000 }, /* R16451 */ - { 0x0000, 0x0000, 0x0000 }, /* R16452 */ - { 0x0000, 0x0000, 0x0000 }, /* R16453 */ - { 0x0000, 0x0000, 0x0000 }, /* R16454 */ - { 0x0000, 0x0000, 0x0000 }, /* R16455 */ - { 0x0000, 0x0000, 0x0000 }, /* R16456 */ - { 0x0000, 0x0000, 0x0000 }, /* R16457 */ - { 0x0000, 0x0000, 0x0000 }, /* R16458 */ - { 0x0000, 0x0000, 0x0000 }, /* R16459 */ - { 0x0000, 0x0000, 0x0000 }, /* R16460 */ - { 0x0000, 0x0000, 0x0000 }, /* R16461 */ - { 0x0000, 0x0000, 0x0000 }, /* R16462 */ - { 0x0000, 0x0000, 0x0000 }, /* R16463 */ - { 0x0000, 0x0000, 0x0000 }, /* R16464 */ - { 0x0000, 0x0000, 0x0000 }, /* R16465 */ - { 0x0000, 0x0000, 0x0000 }, /* R16466 */ - { 0x0000, 0x0000, 0x0000 }, /* R16467 */ - { 0x0000, 0x0000, 0x0000 }, /* R16468 */ - { 0x0000, 0x0000, 0x0000 }, /* R16469 */ - { 0x0000, 0x0000, 0x0000 }, /* R16470 */ - { 0x0000, 0x0000, 0x0000 }, /* R16471 */ - { 0x0000, 0x0000, 0x0000 }, /* R16472 */ - { 0x0000, 0x0000, 0x0000 }, /* R16473 */ - { 0x0000, 0x0000, 0x0000 }, /* R16474 */ - { 0x0000, 0x0000, 0x0000 }, /* R16475 */ - { 0x0000, 0x0000, 0x0000 }, /* R16476 */ - { 0x0000, 0x0000, 0x0000 }, /* R16477 */ - { 0x0000, 0x0000, 0x0000 }, /* R16478 */ - { 0x0000, 0x0000, 0x0000 }, /* R16479 */ - { 0x0000, 0x0000, 0x0000 }, /* R16480 */ - { 0x0000, 0x0000, 0x0000 }, /* R16481 */ - { 0x0000, 0x0000, 0x0000 }, /* R16482 */ - { 0x0000, 0x0000, 0x0000 }, /* R16483 */ - { 0x0000, 0x0000, 0x0000 }, /* R16484 */ - { 0x0000, 0x0000, 0x0000 }, /* R16485 */ - { 0x0000, 0x0000, 0x0000 }, /* R16486 */ - { 0x0000, 0x0000, 0x0000 }, /* R16487 */ - { 0x0000, 0x0000, 0x0000 }, /* R16488 */ - { 0x0000, 0x0000, 0x0000 }, /* R16489 */ - { 0x0000, 0x0000, 0x0000 }, /* R16490 */ - { 0x0000, 0x0000, 0x0000 }, /* R16491 */ - { 0x0000, 0x0000, 0x0000 }, /* R16492 */ - { 0x0000, 0x0000, 0x0000 }, /* R16493 */ - { 0x0000, 0x0000, 0x0000 }, /* R16494 */ - { 0x0000, 0x0000, 0x0000 }, /* R16495 */ - { 0x0000, 0x0000, 0x0000 }, /* R16496 */ - { 0x0000, 0x0000, 0x0000 }, /* R16497 */ - { 0x0000, 0x0000, 0x0000 }, /* R16498 */ - { 0x0000, 0x0000, 0x0000 }, /* R16499 */ - { 0x0000, 0x0000, 0x0000 }, /* R16500 */ - { 0x0000, 0x0000, 0x0000 }, /* R16501 */ - { 0x0000, 0x0000, 0x0000 }, /* R16502 */ - { 0x0000, 0x0000, 0x0000 }, /* R16503 */ - { 0x0000, 0x0000, 0x0000 }, /* R16504 */ - { 0x0000, 0x0000, 0x0000 }, /* R16505 */ - { 0x0000, 0x0000, 0x0000 }, /* R16506 */ - { 0x0000, 0x0000, 0x0000 }, /* R16507 */ - { 0x0000, 0x0000, 0x0000 }, /* R16508 */ - { 0x0000, 0x0000, 0x0000 }, /* R16509 */ - { 0x0000, 0x0000, 0x0000 }, /* R16510 */ - { 0x0000, 0x0000, 0x0000 }, /* R16511 */ - { 0x0000, 0x0000, 0x0000 }, /* R16512 */ - { 0x0000, 0x0000, 0x0000 }, /* R16513 */ - { 0x0000, 0x0000, 0x0000 }, /* R16514 */ - { 0x0000, 0x0000, 0x0000 }, /* R16515 */ - { 0x0000, 0x0000, 0x0000 }, /* R16516 */ - { 0x0000, 0x0000, 0x0000 }, /* R16517 */ - { 0x0000, 0x0000, 0x0000 }, /* R16518 */ - { 0x0000, 0x0000, 0x0000 }, /* R16519 */ - { 0x0000, 0x0000, 0x0000 }, /* R16520 */ - { 0x0000, 0x0000, 0x0000 }, /* R16521 */ - { 0x0000, 0x0000, 0x0000 }, /* R16522 */ - { 0x0000, 0x0000, 0x0000 }, /* R16523 */ - { 0x0000, 0x0000, 0x0000 }, /* R16524 */ - { 0x0000, 0x0000, 0x0000 }, /* R16525 */ - { 0x0000, 0x0000, 0x0000 }, /* R16526 */ - { 0x0000, 0x0000, 0x0000 }, /* R16527 */ - { 0x0000, 0x0000, 0x0000 }, /* R16528 */ - { 0x0000, 0x0000, 0x0000 }, /* R16529 */ - { 0x0000, 0x0000, 0x0000 }, /* R16530 */ - { 0x0000, 0x0000, 0x0000 }, /* R16531 */ - { 0x0000, 0x0000, 0x0000 }, /* R16532 */ - { 0x0000, 0x0000, 0x0000 }, /* R16533 */ - { 0x0000, 0x0000, 0x0000 }, /* R16534 */ - { 0x0000, 0x0000, 0x0000 }, /* R16535 */ - { 0x0000, 0x0000, 0x0000 }, /* R16536 */ - { 0x0000, 0x0000, 0x0000 }, /* R16537 */ - { 0x0000, 0x0000, 0x0000 }, /* R16538 */ - { 0x0000, 0x0000, 0x0000 }, /* R16539 */ - { 0x0000, 0x0000, 0x0000 }, /* R16540 */ - { 0x0000, 0x0000, 0x0000 }, /* R16541 */ - { 0x0000, 0x0000, 0x0000 }, /* R16542 */ - { 0x0000, 0x0000, 0x0000 }, /* R16543 */ - { 0x0000, 0x0000, 0x0000 }, /* R16544 */ - { 0x0000, 0x0000, 0x0000 }, /* R16545 */ - { 0x0000, 0x0000, 0x0000 }, /* R16546 */ - { 0x0000, 0x0000, 0x0000 }, /* R16547 */ - { 0x0000, 0x0000, 0x0000 }, /* R16548 */ - { 0x0000, 0x0000, 0x0000 }, /* R16549 */ - { 0x0000, 0x0000, 0x0000 }, /* R16550 */ - { 0x0000, 0x0000, 0x0000 }, /* R16551 */ - { 0x0000, 0x0000, 0x0000 }, /* R16552 */ - { 0x0000, 0x0000, 0x0000 }, /* R16553 */ - { 0x0000, 0x0000, 0x0000 }, /* R16554 */ - { 0x0000, 0x0000, 0x0000 }, /* R16555 */ - { 0x0000, 0x0000, 0x0000 }, /* R16556 */ - { 0x0000, 0x0000, 0x0000 }, /* R16557 */ - { 0x0000, 0x0000, 0x0000 }, /* R16558 */ - { 0x0000, 0x0000, 0x0000 }, /* R16559 */ - { 0x0000, 0x0000, 0x0000 }, /* R16560 */ - { 0x0000, 0x0000, 0x0000 }, /* R16561 */ - { 0x0000, 0x0000, 0x0000 }, /* R16562 */ - { 0x0000, 0x0000, 0x0000 }, /* R16563 */ - { 0x0000, 0x0000, 0x0000 }, /* R16564 */ - { 0x0000, 0x0000, 0x0000 }, /* R16565 */ - { 0x0000, 0x0000, 0x0000 }, /* R16566 */ - { 0x0000, 0x0000, 0x0000 }, /* R16567 */ - { 0x0000, 0x0000, 0x0000 }, /* R16568 */ - { 0x0000, 0x0000, 0x0000 }, /* R16569 */ - { 0x0000, 0x0000, 0x0000 }, /* R16570 */ - { 0x0000, 0x0000, 0x0000 }, /* R16571 */ - { 0x0000, 0x0000, 0x0000 }, /* R16572 */ - { 0x0000, 0x0000, 0x0000 }, /* R16573 */ - { 0x0000, 0x0000, 0x0000 }, /* R16574 */ - { 0x0000, 0x0000, 0x0000 }, /* R16575 */ - { 0x0000, 0x0000, 0x0000 }, /* R16576 */ - { 0x0000, 0x0000, 0x0000 }, /* R16577 */ - { 0x0000, 0x0000, 0x0000 }, /* R16578 */ - { 0x0000, 0x0000, 0x0000 }, /* R16579 */ - { 0x0000, 0x0000, 0x0000 }, /* R16580 */ - { 0x0000, 0x0000, 0x0000 }, /* R16581 */ - { 0x0000, 0x0000, 0x0000 }, /* R16582 */ - { 0x0000, 0x0000, 0x0000 }, /* R16583 */ - { 0x0000, 0x0000, 0x0000 }, /* R16584 */ - { 0x0000, 0x0000, 0x0000 }, /* R16585 */ - { 0x0000, 0x0000, 0x0000 }, /* R16586 */ - { 0x0000, 0x0000, 0x0000 }, /* R16587 */ - { 0x0000, 0x0000, 0x0000 }, /* R16588 */ - { 0x0000, 0x0000, 0x0000 }, /* R16589 */ - { 0x0000, 0x0000, 0x0000 }, /* R16590 */ - { 0x0000, 0x0000, 0x0000 }, /* R16591 */ - { 0x0000, 0x0000, 0x0000 }, /* R16592 */ - { 0x0000, 0x0000, 0x0000 }, /* R16593 */ - { 0x0000, 0x0000, 0x0000 }, /* R16594 */ - { 0x0000, 0x0000, 0x0000 }, /* R16595 */ - { 0x0000, 0x0000, 0x0000 }, /* R16596 */ - { 0x0000, 0x0000, 0x0000 }, /* R16597 */ - { 0x0000, 0x0000, 0x0000 }, /* R16598 */ - { 0x0000, 0x0000, 0x0000 }, /* R16599 */ - { 0x0000, 0x0000, 0x0000 }, /* R16600 */ - { 0x0000, 0x0000, 0x0000 }, /* R16601 */ - { 0x0000, 0x0000, 0x0000 }, /* R16602 */ - { 0x0000, 0x0000, 0x0000 }, /* R16603 */ - { 0x0000, 0x0000, 0x0000 }, /* R16604 */ - { 0x0000, 0x0000, 0x0000 }, /* R16605 */ - { 0x0000, 0x0000, 0x0000 }, /* R16606 */ - { 0x0000, 0x0000, 0x0000 }, /* R16607 */ - { 0x0000, 0x0000, 0x0000 }, /* R16608 */ - { 0x0000, 0x0000, 0x0000 }, /* R16609 */ - { 0x0000, 0x0000, 0x0000 }, /* R16610 */ - { 0x0000, 0x0000, 0x0000 }, /* R16611 */ - { 0x0000, 0x0000, 0x0000 }, /* R16612 */ - { 0x0000, 0x0000, 0x0000 }, /* R16613 */ - { 0x0000, 0x0000, 0x0000 }, /* R16614 */ - { 0x0000, 0x0000, 0x0000 }, /* R16615 */ - { 0x0000, 0x0000, 0x0000 }, /* R16616 */ - { 0x0000, 0x0000, 0x0000 }, /* R16617 */ - { 0x0000, 0x0000, 0x0000 }, /* R16618 */ - { 0x0000, 0x0000, 0x0000 }, /* R16619 */ - { 0x0000, 0x0000, 0x0000 }, /* R16620 */ - { 0x0000, 0x0000, 0x0000 }, /* R16621 */ - { 0x0000, 0x0000, 0x0000 }, /* R16622 */ - { 0x0000, 0x0000, 0x0000 }, /* R16623 */ - { 0x0000, 0x0000, 0x0000 }, /* R16624 */ - { 0x0000, 0x0000, 0x0000 }, /* R16625 */ - { 0x0000, 0x0000, 0x0000 }, /* R16626 */ - { 0x0000, 0x0000, 0x0000 }, /* R16627 */ - { 0x0000, 0x0000, 0x0000 }, /* R16628 */ - { 0x0000, 0x0000, 0x0000 }, /* R16629 */ - { 0x0000, 0x0000, 0x0000 }, /* R16630 */ - { 0x0000, 0x0000, 0x0000 }, /* R16631 */ - { 0x0000, 0x0000, 0x0000 }, /* R16632 */ - { 0x0000, 0x0000, 0x0000 }, /* R16633 */ - { 0x0000, 0x0000, 0x0000 }, /* R16634 */ - { 0x0000, 0x0000, 0x0000 }, /* R16635 */ - { 0x0000, 0x0000, 0x0000 }, /* R16636 */ - { 0x0000, 0x0000, 0x0000 }, /* R16637 */ - { 0x0000, 0x0000, 0x0000 }, /* R16638 */ - { 0x0000, 0x0000, 0x0000 }, /* R16639 */ - { 0x0000, 0x0000, 0x0000 }, /* R16640 */ - { 0x0000, 0x0000, 0x0000 }, /* R16641 */ - { 0x0000, 0x0000, 0x0000 }, /* R16642 */ - { 0x0000, 0x0000, 0x0000 }, /* R16643 */ - { 0x0000, 0x0000, 0x0000 }, /* R16644 */ - { 0x0000, 0x0000, 0x0000 }, /* R16645 */ - { 0x0000, 0x0000, 0x0000 }, /* R16646 */ - { 0x0000, 0x0000, 0x0000 }, /* R16647 */ - { 0x0000, 0x0000, 0x0000 }, /* R16648 */ - { 0x0000, 0x0000, 0x0000 }, /* R16649 */ - { 0x0000, 0x0000, 0x0000 }, /* R16650 */ - { 0x0000, 0x0000, 0x0000 }, /* R16651 */ - { 0x0000, 0x0000, 0x0000 }, /* R16652 */ - { 0x0000, 0x0000, 0x0000 }, /* R16653 */ - { 0x0000, 0x0000, 0x0000 }, /* R16654 */ - { 0x0000, 0x0000, 0x0000 }, /* R16655 */ - { 0x0000, 0x0000, 0x0000 }, /* R16656 */ - { 0x0000, 0x0000, 0x0000 }, /* R16657 */ - { 0x0000, 0x0000, 0x0000 }, /* R16658 */ - { 0x0000, 0x0000, 0x0000 }, /* R16659 */ - { 0x0000, 0x0000, 0x0000 }, /* R16660 */ - { 0x0000, 0x0000, 0x0000 }, /* R16661 */ - { 0x0000, 0x0000, 0x0000 }, /* R16662 */ - { 0x0000, 0x0000, 0x0000 }, /* R16663 */ - { 0x0000, 0x0000, 0x0000 }, /* R16664 */ - { 0x0000, 0x0000, 0x0000 }, /* R16665 */ - { 0x0000, 0x0000, 0x0000 }, /* R16666 */ - { 0x0000, 0x0000, 0x0000 }, /* R16667 */ - { 0x0000, 0x0000, 0x0000 }, /* R16668 */ - { 0x0000, 0x0000, 0x0000 }, /* R16669 */ - { 0x0000, 0x0000, 0x0000 }, /* R16670 */ - { 0x0000, 0x0000, 0x0000 }, /* R16671 */ - { 0x0000, 0x0000, 0x0000 }, /* R16672 */ - { 0x0000, 0x0000, 0x0000 }, /* R16673 */ - { 0x0000, 0x0000, 0x0000 }, /* R16674 */ - { 0x0000, 0x0000, 0x0000 }, /* R16675 */ - { 0x0000, 0x0000, 0x0000 }, /* R16676 */ - { 0x0000, 0x0000, 0x0000 }, /* R16677 */ - { 0x0000, 0x0000, 0x0000 }, /* R16678 */ - { 0x0000, 0x0000, 0x0000 }, /* R16679 */ - { 0x0000, 0x0000, 0x0000 }, /* R16680 */ - { 0x0000, 0x0000, 0x0000 }, /* R16681 */ - { 0x0000, 0x0000, 0x0000 }, /* R16682 */ - { 0x0000, 0x0000, 0x0000 }, /* R16683 */ - { 0x0000, 0x0000, 0x0000 }, /* R16684 */ - { 0x0000, 0x0000, 0x0000 }, /* R16685 */ - { 0x0000, 0x0000, 0x0000 }, /* R16686 */ - { 0x0000, 0x0000, 0x0000 }, /* R16687 */ - { 0x0000, 0x0000, 0x0000 }, /* R16688 */ - { 0x0000, 0x0000, 0x0000 }, /* R16689 */ - { 0x0000, 0x0000, 0x0000 }, /* R16690 */ - { 0x0000, 0x0000, 0x0000 }, /* R16691 */ - { 0x0000, 0x0000, 0x0000 }, /* R16692 */ - { 0x0000, 0x0000, 0x0000 }, /* R16693 */ - { 0x0000, 0x0000, 0x0000 }, /* R16694 */ - { 0x0000, 0x0000, 0x0000 }, /* R16695 */ - { 0x0000, 0x0000, 0x0000 }, /* R16696 */ - { 0x0000, 0x0000, 0x0000 }, /* R16697 */ - { 0x0000, 0x0000, 0x0000 }, /* R16698 */ - { 0x0000, 0x0000, 0x0000 }, /* R16699 */ - { 0x0000, 0x0000, 0x0000 }, /* R16700 */ - { 0x0000, 0x0000, 0x0000 }, /* R16701 */ - { 0x0000, 0x0000, 0x0000 }, /* R16702 */ - { 0x0000, 0x0000, 0x0000 }, /* R16703 */ - { 0x0000, 0x0000, 0x0000 }, /* R16704 */ - { 0x0000, 0x0000, 0x0000 }, /* R16705 */ - { 0x0000, 0x0000, 0x0000 }, /* R16706 */ - { 0x0000, 0x0000, 0x0000 }, /* R16707 */ - { 0x0000, 0x0000, 0x0000 }, /* R16708 */ - { 0x0000, 0x0000, 0x0000 }, /* R16709 */ - { 0x0000, 0x0000, 0x0000 }, /* R16710 */ - { 0x0000, 0x0000, 0x0000 }, /* R16711 */ - { 0x0000, 0x0000, 0x0000 }, /* R16712 */ - { 0x0000, 0x0000, 0x0000 }, /* R16713 */ - { 0x0000, 0x0000, 0x0000 }, /* R16714 */ - { 0x0000, 0x0000, 0x0000 }, /* R16715 */ - { 0x0000, 0x0000, 0x0000 }, /* R16716 */ - { 0x0000, 0x0000, 0x0000 }, /* R16717 */ - { 0x0000, 0x0000, 0x0000 }, /* R16718 */ - { 0x0000, 0x0000, 0x0000 }, /* R16719 */ - { 0x0000, 0x0000, 0x0000 }, /* R16720 */ - { 0x0000, 0x0000, 0x0000 }, /* R16721 */ - { 0x0000, 0x0000, 0x0000 }, /* R16722 */ - { 0x0000, 0x0000, 0x0000 }, /* R16723 */ - { 0x0000, 0x0000, 0x0000 }, /* R16724 */ - { 0x0000, 0x0000, 0x0000 }, /* R16725 */ - { 0x0000, 0x0000, 0x0000 }, /* R16726 */ - { 0x0000, 0x0000, 0x0000 }, /* R16727 */ - { 0x0000, 0x0000, 0x0000 }, /* R16728 */ - { 0x0000, 0x0000, 0x0000 }, /* R16729 */ - { 0x0000, 0x0000, 0x0000 }, /* R16730 */ - { 0x0000, 0x0000, 0x0000 }, /* R16731 */ - { 0x0000, 0x0000, 0x0000 }, /* R16732 */ - { 0x0000, 0x0000, 0x0000 }, /* R16733 */ - { 0x0000, 0x0000, 0x0000 }, /* R16734 */ - { 0x0000, 0x0000, 0x0000 }, /* R16735 */ - { 0x0000, 0x0000, 0x0000 }, /* R16736 */ - { 0x0000, 0x0000, 0x0000 }, /* R16737 */ - { 0x0000, 0x0000, 0x0000 }, /* R16738 */ - { 0x0000, 0x0000, 0x0000 }, /* R16739 */ - { 0x0000, 0x0000, 0x0000 }, /* R16740 */ - { 0x0000, 0x0000, 0x0000 }, /* R16741 */ - { 0x0000, 0x0000, 0x0000 }, /* R16742 */ - { 0x0000, 0x0000, 0x0000 }, /* R16743 */ - { 0x0000, 0x0000, 0x0000 }, /* R16744 */ - { 0x0000, 0x0000, 0x0000 }, /* R16745 */ - { 0x0000, 0x0000, 0x0000 }, /* R16746 */ - { 0x0000, 0x0000, 0x0000 }, /* R16747 */ - { 0x0000, 0x0000, 0x0000 }, /* R16748 */ - { 0x0000, 0x0000, 0x0000 }, /* R16749 */ - { 0x0000, 0x0000, 0x0000 }, /* R16750 */ - { 0x0000, 0x0000, 0x0000 }, /* R16751 */ - { 0x0000, 0x0000, 0x0000 }, /* R16752 */ - { 0x0000, 0x0000, 0x0000 }, /* R16753 */ - { 0x0000, 0x0000, 0x0000 }, /* R16754 */ - { 0x0000, 0x0000, 0x0000 }, /* R16755 */ - { 0x0000, 0x0000, 0x0000 }, /* R16756 */ - { 0x0000, 0x0000, 0x0000 }, /* R16757 */ - { 0x0000, 0x0000, 0x0000 }, /* R16758 */ - { 0x0000, 0x0000, 0x0000 }, /* R16759 */ - { 0x0000, 0x0000, 0x0000 }, /* R16760 */ - { 0x0000, 0x0000, 0x0000 }, /* R16761 */ - { 0x0000, 0x0000, 0x0000 }, /* R16762 */ - { 0x0000, 0x0000, 0x0000 }, /* R16763 */ - { 0x0000, 0x0000, 0x0000 }, /* R16764 */ - { 0x0000, 0x0000, 0x0000 }, /* R16765 */ - { 0x0000, 0x0000, 0x0000 }, /* R16766 */ - { 0x0000, 0x0000, 0x0000 }, /* R16767 */ - { 0x0000, 0x0000, 0x0000 }, /* R16768 */ - { 0x0000, 0x0000, 0x0000 }, /* R16769 */ - { 0x0000, 0x0000, 0x0000 }, /* R16770 */ - { 0x0000, 0x0000, 0x0000 }, /* R16771 */ - { 0x0000, 0x0000, 0x0000 }, /* R16772 */ - { 0x0000, 0x0000, 0x0000 }, /* R16773 */ - { 0x0000, 0x0000, 0x0000 }, /* R16774 */ - { 0x0000, 0x0000, 0x0000 }, /* R16775 */ - { 0x0000, 0x0000, 0x0000 }, /* R16776 */ - { 0x0000, 0x0000, 0x0000 }, /* R16777 */ - { 0x0000, 0x0000, 0x0000 }, /* R16778 */ - { 0x0000, 0x0000, 0x0000 }, /* R16779 */ - { 0x0000, 0x0000, 0x0000 }, /* R16780 */ - { 0x0000, 0x0000, 0x0000 }, /* R16781 */ - { 0x0000, 0x0000, 0x0000 }, /* R16782 */ - { 0x0000, 0x0000, 0x0000 }, /* R16783 */ - { 0x0000, 0x0000, 0x0000 }, /* R16784 */ - { 0x0000, 0x0000, 0x0000 }, /* R16785 */ - { 0x0000, 0x0000, 0x0000 }, /* R16786 */ - { 0x0000, 0x0000, 0x0000 }, /* R16787 */ - { 0x0000, 0x0000, 0x0000 }, /* R16788 */ - { 0x0000, 0x0000, 0x0000 }, /* R16789 */ - { 0x0000, 0x0000, 0x0000 }, /* R16790 */ - { 0x0000, 0x0000, 0x0000 }, /* R16791 */ - { 0x0000, 0x0000, 0x0000 }, /* R16792 */ - { 0x0000, 0x0000, 0x0000 }, /* R16793 */ - { 0x0000, 0x0000, 0x0000 }, /* R16794 */ - { 0x0000, 0x0000, 0x0000 }, /* R16795 */ - { 0x0000, 0x0000, 0x0000 }, /* R16796 */ - { 0x0000, 0x0000, 0x0000 }, /* R16797 */ - { 0x0000, 0x0000, 0x0000 }, /* R16798 */ - { 0x0000, 0x0000, 0x0000 }, /* R16799 */ - { 0x0000, 0x0000, 0x0000 }, /* R16800 */ - { 0x0000, 0x0000, 0x0000 }, /* R16801 */ - { 0x0000, 0x0000, 0x0000 }, /* R16802 */ - { 0x0000, 0x0000, 0x0000 }, /* R16803 */ - { 0x0000, 0x0000, 0x0000 }, /* R16804 */ - { 0x0000, 0x0000, 0x0000 }, /* R16805 */ - { 0x0000, 0x0000, 0x0000 }, /* R16806 */ - { 0x0000, 0x0000, 0x0000 }, /* R16807 */ - { 0x0000, 0x0000, 0x0000 }, /* R16808 */ - { 0x0000, 0x0000, 0x0000 }, /* R16809 */ - { 0x0000, 0x0000, 0x0000 }, /* R16810 */ - { 0x0000, 0x0000, 0x0000 }, /* R16811 */ - { 0x0000, 0x0000, 0x0000 }, /* R16812 */ - { 0x0000, 0x0000, 0x0000 }, /* R16813 */ - { 0x0000, 0x0000, 0x0000 }, /* R16814 */ - { 0x0000, 0x0000, 0x0000 }, /* R16815 */ - { 0x0000, 0x0000, 0x0000 }, /* R16816 */ - { 0x0000, 0x0000, 0x0000 }, /* R16817 */ - { 0x0000, 0x0000, 0x0000 }, /* R16818 */ - { 0x0000, 0x0000, 0x0000 }, /* R16819 */ - { 0x0000, 0x0000, 0x0000 }, /* R16820 */ - { 0x0000, 0x0000, 0x0000 }, /* R16821 */ - { 0x0000, 0x0000, 0x0000 }, /* R16822 */ - { 0x0000, 0x0000, 0x0000 }, /* R16823 */ - { 0x0000, 0x0000, 0x0000 }, /* R16824 */ - { 0x0000, 0x0000, 0x0000 }, /* R16825 */ - { 0x0000, 0x0000, 0x0000 }, /* R16826 */ - { 0x0000, 0x0000, 0x0000 }, /* R16827 */ - { 0x0000, 0x0000, 0x0000 }, /* R16828 */ - { 0x0000, 0x0000, 0x0000 }, /* R16829 */ - { 0x0000, 0x0000, 0x0000 }, /* R16830 */ - { 0x0000, 0x0000, 0x0000 }, /* R16831 */ - { 0x0000, 0x0000, 0x0000 }, /* R16832 */ - { 0x0000, 0x0000, 0x0000 }, /* R16833 */ - { 0x0000, 0x0000, 0x0000 }, /* R16834 */ - { 0x0000, 0x0000, 0x0000 }, /* R16835 */ - { 0x0000, 0x0000, 0x0000 }, /* R16836 */ - { 0x0000, 0x0000, 0x0000 }, /* R16837 */ - { 0x0000, 0x0000, 0x0000 }, /* R16838 */ - { 0x0000, 0x0000, 0x0000 }, /* R16839 */ - { 0x0000, 0x0000, 0x0000 }, /* R16840 */ - { 0x0000, 0x0000, 0x0000 }, /* R16841 */ - { 0x0000, 0x0000, 0x0000 }, /* R16842 */ - { 0x0000, 0x0000, 0x0000 }, /* R16843 */ - { 0x0000, 0x0000, 0x0000 }, /* R16844 */ - { 0x0000, 0x0000, 0x0000 }, /* R16845 */ - { 0x0000, 0x0000, 0x0000 }, /* R16846 */ - { 0x0000, 0x0000, 0x0000 }, /* R16847 */ - { 0x0000, 0x0000, 0x0000 }, /* R16848 */ - { 0x0000, 0x0000, 0x0000 }, /* R16849 */ - { 0x0000, 0x0000, 0x0000 }, /* R16850 */ - { 0x0000, 0x0000, 0x0000 }, /* R16851 */ - { 0x0000, 0x0000, 0x0000 }, /* R16852 */ - { 0x0000, 0x0000, 0x0000 }, /* R16853 */ - { 0x0000, 0x0000, 0x0000 }, /* R16854 */ - { 0x0000, 0x0000, 0x0000 }, /* R16855 */ - { 0x0000, 0x0000, 0x0000 }, /* R16856 */ - { 0x0000, 0x0000, 0x0000 }, /* R16857 */ - { 0x0000, 0x0000, 0x0000 }, /* R16858 */ - { 0x0000, 0x0000, 0x0000 }, /* R16859 */ - { 0x0000, 0x0000, 0x0000 }, /* R16860 */ - { 0x0000, 0x0000, 0x0000 }, /* R16861 */ - { 0x0000, 0x0000, 0x0000 }, /* R16862 */ - { 0x0000, 0x0000, 0x0000 }, /* R16863 */ - { 0x0000, 0x0000, 0x0000 }, /* R16864 */ - { 0x0000, 0x0000, 0x0000 }, /* R16865 */ - { 0x0000, 0x0000, 0x0000 }, /* R16866 */ - { 0x0000, 0x0000, 0x0000 }, /* R16867 */ - { 0x0000, 0x0000, 0x0000 }, /* R16868 */ - { 0x0000, 0x0000, 0x0000 }, /* R16869 */ - { 0x0000, 0x0000, 0x0000 }, /* R16870 */ - { 0x0000, 0x0000, 0x0000 }, /* R16871 */ - { 0x0000, 0x0000, 0x0000 }, /* R16872 */ - { 0x0000, 0x0000, 0x0000 }, /* R16873 */ - { 0x0000, 0x0000, 0x0000 }, /* R16874 */ - { 0x0000, 0x0000, 0x0000 }, /* R16875 */ - { 0x0000, 0x0000, 0x0000 }, /* R16876 */ - { 0x0000, 0x0000, 0x0000 }, /* R16877 */ - { 0x0000, 0x0000, 0x0000 }, /* R16878 */ - { 0x0000, 0x0000, 0x0000 }, /* R16879 */ - { 0x0000, 0x0000, 0x0000 }, /* R16880 */ - { 0x0000, 0x0000, 0x0000 }, /* R16881 */ - { 0x0000, 0x0000, 0x0000 }, /* R16882 */ - { 0x0000, 0x0000, 0x0000 }, /* R16883 */ - { 0x0000, 0x0000, 0x0000 }, /* R16884 */ - { 0x0000, 0x0000, 0x0000 }, /* R16885 */ - { 0x0000, 0x0000, 0x0000 }, /* R16886 */ - { 0x0000, 0x0000, 0x0000 }, /* R16887 */ - { 0x0000, 0x0000, 0x0000 }, /* R16888 */ - { 0x0000, 0x0000, 0x0000 }, /* R16889 */ - { 0x0000, 0x0000, 0x0000 }, /* R16890 */ - { 0x0000, 0x0000, 0x0000 }, /* R16891 */ - { 0x0000, 0x0000, 0x0000 }, /* R16892 */ - { 0x0000, 0x0000, 0x0000 }, /* R16893 */ - { 0x0000, 0x0000, 0x0000 }, /* R16894 */ - { 0x0000, 0x0000, 0x0000 }, /* R16895 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R16896 - HDBASS_AI_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R16897 - HDBASS_AI_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R16898 - HDBASS_AR_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R16899 - HDBASS_AR_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R16900 - HDBASS_B_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R16901 - HDBASS_B_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R16902 - HDBASS_K_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R16903 - HDBASS_K_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R16904 - HDBASS_N1_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R16905 - HDBASS_N1_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R16906 - HDBASS_N2_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R16907 - HDBASS_N2_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R16908 - HDBASS_N3_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R16909 - HDBASS_N3_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R16910 - HDBASS_N4_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R16911 - HDBASS_N4_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R16912 - HDBASS_N5_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R16913 - HDBASS_N5_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R16914 - HDBASS_X1_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R16915 - HDBASS_X1_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R16916 - HDBASS_X2_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R16917 - HDBASS_X2_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R16918 - HDBASS_X3_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R16919 - HDBASS_X3_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R16920 - HDBASS_ATK_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R16921 - HDBASS_ATK_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R16922 - HDBASS_DCY_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R16923 - HDBASS_DCY_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R16924 - HDBASS_PG_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R16925 - HDBASS_PG_0 */ - { 0x0000, 0x0000, 0x0000 }, /* R16926 */ - { 0x0000, 0x0000, 0x0000 }, /* R16927 */ - { 0x0000, 0x0000, 0x0000 }, /* R16928 */ - { 0x0000, 0x0000, 0x0000 }, /* R16929 */ - { 0x0000, 0x0000, 0x0000 }, /* R16930 */ - { 0x0000, 0x0000, 0x0000 }, /* R16931 */ - { 0x0000, 0x0000, 0x0000 }, /* R16932 */ - { 0x0000, 0x0000, 0x0000 }, /* R16933 */ - { 0x0000, 0x0000, 0x0000 }, /* R16934 */ - { 0x0000, 0x0000, 0x0000 }, /* R16935 */ - { 0x0000, 0x0000, 0x0000 }, /* R16936 */ - { 0x0000, 0x0000, 0x0000 }, /* R16937 */ - { 0x0000, 0x0000, 0x0000 }, /* R16938 */ - { 0x0000, 0x0000, 0x0000 }, /* R16939 */ - { 0x0000, 0x0000, 0x0000 }, /* R16940 */ - { 0x0000, 0x0000, 0x0000 }, /* R16941 */ - { 0x0000, 0x0000, 0x0000 }, /* R16942 */ - { 0x0000, 0x0000, 0x0000 }, /* R16943 */ - { 0x0000, 0x0000, 0x0000 }, /* R16944 */ - { 0x0000, 0x0000, 0x0000 }, /* R16945 */ - { 0x0000, 0x0000, 0x0000 }, /* R16946 */ - { 0x0000, 0x0000, 0x0000 }, /* R16947 */ - { 0x0000, 0x0000, 0x0000 }, /* R16948 */ - { 0x0000, 0x0000, 0x0000 }, /* R16949 */ - { 0x0000, 0x0000, 0x0000 }, /* R16950 */ - { 0x0000, 0x0000, 0x0000 }, /* R16951 */ - { 0x0000, 0x0000, 0x0000 }, /* R16952 */ - { 0x0000, 0x0000, 0x0000 }, /* R16953 */ - { 0x0000, 0x0000, 0x0000 }, /* R16954 */ - { 0x0000, 0x0000, 0x0000 }, /* R16955 */ - { 0x0000, 0x0000, 0x0000 }, /* R16956 */ - { 0x0000, 0x0000, 0x0000 }, /* R16957 */ - { 0x0000, 0x0000, 0x0000 }, /* R16958 */ - { 0x0000, 0x0000, 0x0000 }, /* R16959 */ - { 0x0000, 0x0000, 0x0000 }, /* R16960 */ - { 0x0000, 0x0000, 0x0000 }, /* R16961 */ - { 0x0000, 0x0000, 0x0000 }, /* R16962 */ - { 0x0000, 0x0000, 0x0000 }, /* R16963 */ - { 0x0000, 0x0000, 0x0000 }, /* R16964 */ - { 0x0000, 0x0000, 0x0000 }, /* R16965 */ - { 0x0000, 0x0000, 0x0000 }, /* R16966 */ - { 0x0000, 0x0000, 0x0000 }, /* R16967 */ - { 0x0000, 0x0000, 0x0000 }, /* R16968 */ - { 0x0000, 0x0000, 0x0000 }, /* R16969 */ - { 0x0000, 0x0000, 0x0000 }, /* R16970 */ - { 0x0000, 0x0000, 0x0000 }, /* R16971 */ - { 0x0000, 0x0000, 0x0000 }, /* R16972 */ - { 0x0000, 0x0000, 0x0000 }, /* R16973 */ - { 0x0000, 0x0000, 0x0000 }, /* R16974 */ - { 0x0000, 0x0000, 0x0000 }, /* R16975 */ - { 0x0000, 0x0000, 0x0000 }, /* R16976 */ - { 0x0000, 0x0000, 0x0000 }, /* R16977 */ - { 0x0000, 0x0000, 0x0000 }, /* R16978 */ - { 0x0000, 0x0000, 0x0000 }, /* R16979 */ - { 0x0000, 0x0000, 0x0000 }, /* R16980 */ - { 0x0000, 0x0000, 0x0000 }, /* R16981 */ - { 0x0000, 0x0000, 0x0000 }, /* R16982 */ - { 0x0000, 0x0000, 0x0000 }, /* R16983 */ - { 0x0000, 0x0000, 0x0000 }, /* R16984 */ - { 0x0000, 0x0000, 0x0000 }, /* R16985 */ - { 0x0000, 0x0000, 0x0000 }, /* R16986 */ - { 0x0000, 0x0000, 0x0000 }, /* R16987 */ - { 0x0000, 0x0000, 0x0000 }, /* R16988 */ - { 0x0000, 0x0000, 0x0000 }, /* R16989 */ - { 0x0000, 0x0000, 0x0000 }, /* R16990 */ - { 0x0000, 0x0000, 0x0000 }, /* R16991 */ - { 0x0000, 0x0000, 0x0000 }, /* R16992 */ - { 0x0000, 0x0000, 0x0000 }, /* R16993 */ - { 0x0000, 0x0000, 0x0000 }, /* R16994 */ - { 0x0000, 0x0000, 0x0000 }, /* R16995 */ - { 0x0000, 0x0000, 0x0000 }, /* R16996 */ - { 0x0000, 0x0000, 0x0000 }, /* R16997 */ - { 0x0000, 0x0000, 0x0000 }, /* R16998 */ - { 0x0000, 0x0000, 0x0000 }, /* R16999 */ - { 0x0000, 0x0000, 0x0000 }, /* R17000 */ - { 0x0000, 0x0000, 0x0000 }, /* R17001 */ - { 0x0000, 0x0000, 0x0000 }, /* R17002 */ - { 0x0000, 0x0000, 0x0000 }, /* R17003 */ - { 0x0000, 0x0000, 0x0000 }, /* R17004 */ - { 0x0000, 0x0000, 0x0000 }, /* R17005 */ - { 0x0000, 0x0000, 0x0000 }, /* R17006 */ - { 0x0000, 0x0000, 0x0000 }, /* R17007 */ - { 0x0000, 0x0000, 0x0000 }, /* R17008 */ - { 0x0000, 0x0000, 0x0000 }, /* R17009 */ - { 0x0000, 0x0000, 0x0000 }, /* R17010 */ - { 0x0000, 0x0000, 0x0000 }, /* R17011 */ - { 0x0000, 0x0000, 0x0000 }, /* R17012 */ - { 0x0000, 0x0000, 0x0000 }, /* R17013 */ - { 0x0000, 0x0000, 0x0000 }, /* R17014 */ - { 0x0000, 0x0000, 0x0000 }, /* R17015 */ - { 0x0000, 0x0000, 0x0000 }, /* R17016 */ - { 0x0000, 0x0000, 0x0000 }, /* R17017 */ - { 0x0000, 0x0000, 0x0000 }, /* R17018 */ - { 0x0000, 0x0000, 0x0000 }, /* R17019 */ - { 0x0000, 0x0000, 0x0000 }, /* R17020 */ - { 0x0000, 0x0000, 0x0000 }, /* R17021 */ - { 0x0000, 0x0000, 0x0000 }, /* R17022 */ - { 0x0000, 0x0000, 0x0000 }, /* R17023 */ - { 0x0000, 0x0000, 0x0000 }, /* R17024 */ - { 0x0000, 0x0000, 0x0000 }, /* R17025 */ - { 0x0000, 0x0000, 0x0000 }, /* R17026 */ - { 0x0000, 0x0000, 0x0000 }, /* R17027 */ - { 0x0000, 0x0000, 0x0000 }, /* R17028 */ - { 0x0000, 0x0000, 0x0000 }, /* R17029 */ - { 0x0000, 0x0000, 0x0000 }, /* R17030 */ - { 0x0000, 0x0000, 0x0000 }, /* R17031 */ - { 0x0000, 0x0000, 0x0000 }, /* R17032 */ - { 0x0000, 0x0000, 0x0000 }, /* R17033 */ - { 0x0000, 0x0000, 0x0000 }, /* R17034 */ - { 0x0000, 0x0000, 0x0000 }, /* R17035 */ - { 0x0000, 0x0000, 0x0000 }, /* R17036 */ - { 0x0000, 0x0000, 0x0000 }, /* R17037 */ - { 0x0000, 0x0000, 0x0000 }, /* R17038 */ - { 0x0000, 0x0000, 0x0000 }, /* R17039 */ - { 0x0000, 0x0000, 0x0000 }, /* R17040 */ - { 0x0000, 0x0000, 0x0000 }, /* R17041 */ - { 0x0000, 0x0000, 0x0000 }, /* R17042 */ - { 0x0000, 0x0000, 0x0000 }, /* R17043 */ - { 0x0000, 0x0000, 0x0000 }, /* R17044 */ - { 0x0000, 0x0000, 0x0000 }, /* R17045 */ - { 0x0000, 0x0000, 0x0000 }, /* R17046 */ - { 0x0000, 0x0000, 0x0000 }, /* R17047 */ - { 0x0000, 0x0000, 0x0000 }, /* R17048 */ - { 0x0000, 0x0000, 0x0000 }, /* R17049 */ - { 0x0000, 0x0000, 0x0000 }, /* R17050 */ - { 0x0000, 0x0000, 0x0000 }, /* R17051 */ - { 0x0000, 0x0000, 0x0000 }, /* R17052 */ - { 0x0000, 0x0000, 0x0000 }, /* R17053 */ - { 0x0000, 0x0000, 0x0000 }, /* R17054 */ - { 0x0000, 0x0000, 0x0000 }, /* R17055 */ - { 0x0000, 0x0000, 0x0000 }, /* R17056 */ - { 0x0000, 0x0000, 0x0000 }, /* R17057 */ - { 0x0000, 0x0000, 0x0000 }, /* R17058 */ - { 0x0000, 0x0000, 0x0000 }, /* R17059 */ - { 0x0000, 0x0000, 0x0000 }, /* R17060 */ - { 0x0000, 0x0000, 0x0000 }, /* R17061 */ - { 0x0000, 0x0000, 0x0000 }, /* R17062 */ - { 0x0000, 0x0000, 0x0000 }, /* R17063 */ - { 0x0000, 0x0000, 0x0000 }, /* R17064 */ - { 0x0000, 0x0000, 0x0000 }, /* R17065 */ - { 0x0000, 0x0000, 0x0000 }, /* R17066 */ - { 0x0000, 0x0000, 0x0000 }, /* R17067 */ - { 0x0000, 0x0000, 0x0000 }, /* R17068 */ - { 0x0000, 0x0000, 0x0000 }, /* R17069 */ - { 0x0000, 0x0000, 0x0000 }, /* R17070 */ - { 0x0000, 0x0000, 0x0000 }, /* R17071 */ - { 0x0000, 0x0000, 0x0000 }, /* R17072 */ - { 0x0000, 0x0000, 0x0000 }, /* R17073 */ - { 0x0000, 0x0000, 0x0000 }, /* R17074 */ - { 0x0000, 0x0000, 0x0000 }, /* R17075 */ - { 0x0000, 0x0000, 0x0000 }, /* R17076 */ - { 0x0000, 0x0000, 0x0000 }, /* R17077 */ - { 0x0000, 0x0000, 0x0000 }, /* R17078 */ - { 0x0000, 0x0000, 0x0000 }, /* R17079 */ - { 0x0000, 0x0000, 0x0000 }, /* R17080 */ - { 0x0000, 0x0000, 0x0000 }, /* R17081 */ - { 0x0000, 0x0000, 0x0000 }, /* R17082 */ - { 0x0000, 0x0000, 0x0000 }, /* R17083 */ - { 0x0000, 0x0000, 0x0000 }, /* R17084 */ - { 0x0000, 0x0000, 0x0000 }, /* R17085 */ - { 0x0000, 0x0000, 0x0000 }, /* R17086 */ - { 0x0000, 0x0000, 0x0000 }, /* R17087 */ - { 0x0000, 0x0000, 0x0000 }, /* R17088 */ - { 0x0000, 0x0000, 0x0000 }, /* R17089 */ - { 0x0000, 0x0000, 0x0000 }, /* R17090 */ - { 0x0000, 0x0000, 0x0000 }, /* R17091 */ - { 0x0000, 0x0000, 0x0000 }, /* R17092 */ - { 0x0000, 0x0000, 0x0000 }, /* R17093 */ - { 0x0000, 0x0000, 0x0000 }, /* R17094 */ - { 0x0000, 0x0000, 0x0000 }, /* R17095 */ - { 0x0000, 0x0000, 0x0000 }, /* R17096 */ - { 0x0000, 0x0000, 0x0000 }, /* R17097 */ - { 0x0000, 0x0000, 0x0000 }, /* R17098 */ - { 0x0000, 0x0000, 0x0000 }, /* R17099 */ - { 0x0000, 0x0000, 0x0000 }, /* R17100 */ - { 0x0000, 0x0000, 0x0000 }, /* R17101 */ - { 0x0000, 0x0000, 0x0000 }, /* R17102 */ - { 0x0000, 0x0000, 0x0000 }, /* R17103 */ - { 0x0000, 0x0000, 0x0000 }, /* R17104 */ - { 0x0000, 0x0000, 0x0000 }, /* R17105 */ - { 0x0000, 0x0000, 0x0000 }, /* R17106 */ - { 0x0000, 0x0000, 0x0000 }, /* R17107 */ - { 0x0000, 0x0000, 0x0000 }, /* R17108 */ - { 0x0000, 0x0000, 0x0000 }, /* R17109 */ - { 0x0000, 0x0000, 0x0000 }, /* R17110 */ - { 0x0000, 0x0000, 0x0000 }, /* R17111 */ - { 0x0000, 0x0000, 0x0000 }, /* R17112 */ - { 0x0000, 0x0000, 0x0000 }, /* R17113 */ - { 0x0000, 0x0000, 0x0000 }, /* R17114 */ - { 0x0000, 0x0000, 0x0000 }, /* R17115 */ - { 0x0000, 0x0000, 0x0000 }, /* R17116 */ - { 0x0000, 0x0000, 0x0000 }, /* R17117 */ - { 0x0000, 0x0000, 0x0000 }, /* R17118 */ - { 0x0000, 0x0000, 0x0000 }, /* R17119 */ - { 0x0000, 0x0000, 0x0000 }, /* R17120 */ - { 0x0000, 0x0000, 0x0000 }, /* R17121 */ - { 0x0000, 0x0000, 0x0000 }, /* R17122 */ - { 0x0000, 0x0000, 0x0000 }, /* R17123 */ - { 0x0000, 0x0000, 0x0000 }, /* R17124 */ - { 0x0000, 0x0000, 0x0000 }, /* R17125 */ - { 0x0000, 0x0000, 0x0000 }, /* R17126 */ - { 0x0000, 0x0000, 0x0000 }, /* R17127 */ - { 0x0000, 0x0000, 0x0000 }, /* R17128 */ - { 0x0000, 0x0000, 0x0000 }, /* R17129 */ - { 0x0000, 0x0000, 0x0000 }, /* R17130 */ - { 0x0000, 0x0000, 0x0000 }, /* R17131 */ - { 0x0000, 0x0000, 0x0000 }, /* R17132 */ - { 0x0000, 0x0000, 0x0000 }, /* R17133 */ - { 0x0000, 0x0000, 0x0000 }, /* R17134 */ - { 0x0000, 0x0000, 0x0000 }, /* R17135 */ - { 0x0000, 0x0000, 0x0000 }, /* R17136 */ - { 0x0000, 0x0000, 0x0000 }, /* R17137 */ - { 0x0000, 0x0000, 0x0000 }, /* R17138 */ - { 0x0000, 0x0000, 0x0000 }, /* R17139 */ - { 0x0000, 0x0000, 0x0000 }, /* R17140 */ - { 0x0000, 0x0000, 0x0000 }, /* R17141 */ - { 0x0000, 0x0000, 0x0000 }, /* R17142 */ - { 0x0000, 0x0000, 0x0000 }, /* R17143 */ - { 0x0000, 0x0000, 0x0000 }, /* R17144 */ - { 0x0000, 0x0000, 0x0000 }, /* R17145 */ - { 0x0000, 0x0000, 0x0000 }, /* R17146 */ - { 0x0000, 0x0000, 0x0000 }, /* R17147 */ - { 0x0000, 0x0000, 0x0000 }, /* R17148 */ - { 0x0000, 0x0000, 0x0000 }, /* R17149 */ - { 0x0000, 0x0000, 0x0000 }, /* R17150 */ - { 0x0000, 0x0000, 0x0000 }, /* R17151 */ - { 0x0000, 0x0000, 0x0000 }, /* R17152 */ - { 0x0000, 0x0000, 0x0000 }, /* R17153 */ - { 0x0000, 0x0000, 0x0000 }, /* R17154 */ - { 0x0000, 0x0000, 0x0000 }, /* R17155 */ - { 0x0000, 0x0000, 0x0000 }, /* R17156 */ - { 0x0000, 0x0000, 0x0000 }, /* R17157 */ - { 0x0000, 0x0000, 0x0000 }, /* R17158 */ - { 0x0000, 0x0000, 0x0000 }, /* R17159 */ - { 0x0000, 0x0000, 0x0000 }, /* R17160 */ - { 0x0000, 0x0000, 0x0000 }, /* R17161 */ - { 0x0000, 0x0000, 0x0000 }, /* R17162 */ - { 0x0000, 0x0000, 0x0000 }, /* R17163 */ - { 0x0000, 0x0000, 0x0000 }, /* R17164 */ - { 0x0000, 0x0000, 0x0000 }, /* R17165 */ - { 0x0000, 0x0000, 0x0000 }, /* R17166 */ - { 0x0000, 0x0000, 0x0000 }, /* R17167 */ - { 0x0000, 0x0000, 0x0000 }, /* R17168 */ - { 0x0000, 0x0000, 0x0000 }, /* R17169 */ - { 0x0000, 0x0000, 0x0000 }, /* R17170 */ - { 0x0000, 0x0000, 0x0000 }, /* R17171 */ - { 0x0000, 0x0000, 0x0000 }, /* R17172 */ - { 0x0000, 0x0000, 0x0000 }, /* R17173 */ - { 0x0000, 0x0000, 0x0000 }, /* R17174 */ - { 0x0000, 0x0000, 0x0000 }, /* R17175 */ - { 0x0000, 0x0000, 0x0000 }, /* R17176 */ - { 0x0000, 0x0000, 0x0000 }, /* R17177 */ - { 0x0000, 0x0000, 0x0000 }, /* R17178 */ - { 0x0000, 0x0000, 0x0000 }, /* R17179 */ - { 0x0000, 0x0000, 0x0000 }, /* R17180 */ - { 0x0000, 0x0000, 0x0000 }, /* R17181 */ - { 0x0000, 0x0000, 0x0000 }, /* R17182 */ - { 0x0000, 0x0000, 0x0000 }, /* R17183 */ - { 0x0000, 0x0000, 0x0000 }, /* R17184 */ - { 0x0000, 0x0000, 0x0000 }, /* R17185 */ - { 0x0000, 0x0000, 0x0000 }, /* R17186 */ - { 0x0000, 0x0000, 0x0000 }, /* R17187 */ - { 0x0000, 0x0000, 0x0000 }, /* R17188 */ - { 0x0000, 0x0000, 0x0000 }, /* R17189 */ - { 0x0000, 0x0000, 0x0000 }, /* R17190 */ - { 0x0000, 0x0000, 0x0000 }, /* R17191 */ - { 0x0000, 0x0000, 0x0000 }, /* R17192 */ - { 0x0000, 0x0000, 0x0000 }, /* R17193 */ - { 0x0000, 0x0000, 0x0000 }, /* R17194 */ - { 0x0000, 0x0000, 0x0000 }, /* R17195 */ - { 0x0000, 0x0000, 0x0000 }, /* R17196 */ - { 0x0000, 0x0000, 0x0000 }, /* R17197 */ - { 0x0000, 0x0000, 0x0000 }, /* R17198 */ - { 0x0000, 0x0000, 0x0000 }, /* R17199 */ - { 0x0000, 0x0000, 0x0000 }, /* R17200 */ - { 0x0000, 0x0000, 0x0000 }, /* R17201 */ - { 0x0000, 0x0000, 0x0000 }, /* R17202 */ - { 0x0000, 0x0000, 0x0000 }, /* R17203 */ - { 0x0000, 0x0000, 0x0000 }, /* R17204 */ - { 0x0000, 0x0000, 0x0000 }, /* R17205 */ - { 0x0000, 0x0000, 0x0000 }, /* R17206 */ - { 0x0000, 0x0000, 0x0000 }, /* R17207 */ - { 0x0000, 0x0000, 0x0000 }, /* R17208 */ - { 0x0000, 0x0000, 0x0000 }, /* R17209 */ - { 0x0000, 0x0000, 0x0000 }, /* R17210 */ - { 0x0000, 0x0000, 0x0000 }, /* R17211 */ - { 0x0000, 0x0000, 0x0000 }, /* R17212 */ - { 0x0000, 0x0000, 0x0000 }, /* R17213 */ - { 0x0000, 0x0000, 0x0000 }, /* R17214 */ - { 0x0000, 0x0000, 0x0000 }, /* R17215 */ - { 0x0000, 0x0000, 0x0000 }, /* R17216 */ - { 0x0000, 0x0000, 0x0000 }, /* R17217 */ - { 0x0000, 0x0000, 0x0000 }, /* R17218 */ - { 0x0000, 0x0000, 0x0000 }, /* R17219 */ - { 0x0000, 0x0000, 0x0000 }, /* R17220 */ - { 0x0000, 0x0000, 0x0000 }, /* R17221 */ - { 0x0000, 0x0000, 0x0000 }, /* R17222 */ - { 0x0000, 0x0000, 0x0000 }, /* R17223 */ - { 0x0000, 0x0000, 0x0000 }, /* R17224 */ - { 0x0000, 0x0000, 0x0000 }, /* R17225 */ - { 0x0000, 0x0000, 0x0000 }, /* R17226 */ - { 0x0000, 0x0000, 0x0000 }, /* R17227 */ - { 0x0000, 0x0000, 0x0000 }, /* R17228 */ - { 0x0000, 0x0000, 0x0000 }, /* R17229 */ - { 0x0000, 0x0000, 0x0000 }, /* R17230 */ - { 0x0000, 0x0000, 0x0000 }, /* R17231 */ - { 0x0000, 0x0000, 0x0000 }, /* R17232 */ - { 0x0000, 0x0000, 0x0000 }, /* R17233 */ - { 0x0000, 0x0000, 0x0000 }, /* R17234 */ - { 0x0000, 0x0000, 0x0000 }, /* R17235 */ - { 0x0000, 0x0000, 0x0000 }, /* R17236 */ - { 0x0000, 0x0000, 0x0000 }, /* R17237 */ - { 0x0000, 0x0000, 0x0000 }, /* R17238 */ - { 0x0000, 0x0000, 0x0000 }, /* R17239 */ - { 0x0000, 0x0000, 0x0000 }, /* R17240 */ - { 0x0000, 0x0000, 0x0000 }, /* R17241 */ - { 0x0000, 0x0000, 0x0000 }, /* R17242 */ - { 0x0000, 0x0000, 0x0000 }, /* R17243 */ - { 0x0000, 0x0000, 0x0000 }, /* R17244 */ - { 0x0000, 0x0000, 0x0000 }, /* R17245 */ - { 0x0000, 0x0000, 0x0000 }, /* R17246 */ - { 0x0000, 0x0000, 0x0000 }, /* R17247 */ - { 0x0000, 0x0000, 0x0000 }, /* R17248 */ - { 0x0000, 0x0000, 0x0000 }, /* R17249 */ - { 0x0000, 0x0000, 0x0000 }, /* R17250 */ - { 0x0000, 0x0000, 0x0000 }, /* R17251 */ - { 0x0000, 0x0000, 0x0000 }, /* R17252 */ - { 0x0000, 0x0000, 0x0000 }, /* R17253 */ - { 0x0000, 0x0000, 0x0000 }, /* R17254 */ - { 0x0000, 0x0000, 0x0000 }, /* R17255 */ - { 0x0000, 0x0000, 0x0000 }, /* R17256 */ - { 0x0000, 0x0000, 0x0000 }, /* R17257 */ - { 0x0000, 0x0000, 0x0000 }, /* R17258 */ - { 0x0000, 0x0000, 0x0000 }, /* R17259 */ - { 0x0000, 0x0000, 0x0000 }, /* R17260 */ - { 0x0000, 0x0000, 0x0000 }, /* R17261 */ - { 0x0000, 0x0000, 0x0000 }, /* R17262 */ - { 0x0000, 0x0000, 0x0000 }, /* R17263 */ - { 0x0000, 0x0000, 0x0000 }, /* R17264 */ - { 0x0000, 0x0000, 0x0000 }, /* R17265 */ - { 0x0000, 0x0000, 0x0000 }, /* R17266 */ - { 0x0000, 0x0000, 0x0000 }, /* R17267 */ - { 0x0000, 0x0000, 0x0000 }, /* R17268 */ - { 0x0000, 0x0000, 0x0000 }, /* R17269 */ - { 0x0000, 0x0000, 0x0000 }, /* R17270 */ - { 0x0000, 0x0000, 0x0000 }, /* R17271 */ - { 0x0000, 0x0000, 0x0000 }, /* R17272 */ - { 0x0000, 0x0000, 0x0000 }, /* R17273 */ - { 0x0000, 0x0000, 0x0000 }, /* R17274 */ - { 0x0000, 0x0000, 0x0000 }, /* R17275 */ - { 0x0000, 0x0000, 0x0000 }, /* R17276 */ - { 0x0000, 0x0000, 0x0000 }, /* R17277 */ - { 0x0000, 0x0000, 0x0000 }, /* R17278 */ - { 0x0000, 0x0000, 0x0000 }, /* R17279 */ - { 0x0000, 0x0000, 0x0000 }, /* R17280 */ - { 0x0000, 0x0000, 0x0000 }, /* R17281 */ - { 0x0000, 0x0000, 0x0000 }, /* R17282 */ - { 0x0000, 0x0000, 0x0000 }, /* R17283 */ - { 0x0000, 0x0000, 0x0000 }, /* R17284 */ - { 0x0000, 0x0000, 0x0000 }, /* R17285 */ - { 0x0000, 0x0000, 0x0000 }, /* R17286 */ - { 0x0000, 0x0000, 0x0000 }, /* R17287 */ - { 0x0000, 0x0000, 0x0000 }, /* R17288 */ - { 0x0000, 0x0000, 0x0000 }, /* R17289 */ - { 0x0000, 0x0000, 0x0000 }, /* R17290 */ - { 0x0000, 0x0000, 0x0000 }, /* R17291 */ - { 0x0000, 0x0000, 0x0000 }, /* R17292 */ - { 0x0000, 0x0000, 0x0000 }, /* R17293 */ - { 0x0000, 0x0000, 0x0000 }, /* R17294 */ - { 0x0000, 0x0000, 0x0000 }, /* R17295 */ - { 0x0000, 0x0000, 0x0000 }, /* R17296 */ - { 0x0000, 0x0000, 0x0000 }, /* R17297 */ - { 0x0000, 0x0000, 0x0000 }, /* R17298 */ - { 0x0000, 0x0000, 0x0000 }, /* R17299 */ - { 0x0000, 0x0000, 0x0000 }, /* R17300 */ - { 0x0000, 0x0000, 0x0000 }, /* R17301 */ - { 0x0000, 0x0000, 0x0000 }, /* R17302 */ - { 0x0000, 0x0000, 0x0000 }, /* R17303 */ - { 0x0000, 0x0000, 0x0000 }, /* R17304 */ - { 0x0000, 0x0000, 0x0000 }, /* R17305 */ - { 0x0000, 0x0000, 0x0000 }, /* R17306 */ - { 0x0000, 0x0000, 0x0000 }, /* R17307 */ - { 0x0000, 0x0000, 0x0000 }, /* R17308 */ - { 0x0000, 0x0000, 0x0000 }, /* R17309 */ - { 0x0000, 0x0000, 0x0000 }, /* R17310 */ - { 0x0000, 0x0000, 0x0000 }, /* R17311 */ - { 0x0000, 0x0000, 0x0000 }, /* R17312 */ - { 0x0000, 0x0000, 0x0000 }, /* R17313 */ - { 0x0000, 0x0000, 0x0000 }, /* R17314 */ - { 0x0000, 0x0000, 0x0000 }, /* R17315 */ - { 0x0000, 0x0000, 0x0000 }, /* R17316 */ - { 0x0000, 0x0000, 0x0000 }, /* R17317 */ - { 0x0000, 0x0000, 0x0000 }, /* R17318 */ - { 0x0000, 0x0000, 0x0000 }, /* R17319 */ - { 0x0000, 0x0000, 0x0000 }, /* R17320 */ - { 0x0000, 0x0000, 0x0000 }, /* R17321 */ - { 0x0000, 0x0000, 0x0000 }, /* R17322 */ - { 0x0000, 0x0000, 0x0000 }, /* R17323 */ - { 0x0000, 0x0000, 0x0000 }, /* R17324 */ - { 0x0000, 0x0000, 0x0000 }, /* R17325 */ - { 0x0000, 0x0000, 0x0000 }, /* R17326 */ - { 0x0000, 0x0000, 0x0000 }, /* R17327 */ - { 0x0000, 0x0000, 0x0000 }, /* R17328 */ - { 0x0000, 0x0000, 0x0000 }, /* R17329 */ - { 0x0000, 0x0000, 0x0000 }, /* R17330 */ - { 0x0000, 0x0000, 0x0000 }, /* R17331 */ - { 0x0000, 0x0000, 0x0000 }, /* R17332 */ - { 0x0000, 0x0000, 0x0000 }, /* R17333 */ - { 0x0000, 0x0000, 0x0000 }, /* R17334 */ - { 0x0000, 0x0000, 0x0000 }, /* R17335 */ - { 0x0000, 0x0000, 0x0000 }, /* R17336 */ - { 0x0000, 0x0000, 0x0000 }, /* R17337 */ - { 0x0000, 0x0000, 0x0000 }, /* R17338 */ - { 0x0000, 0x0000, 0x0000 }, /* R17339 */ - { 0x0000, 0x0000, 0x0000 }, /* R17340 */ - { 0x0000, 0x0000, 0x0000 }, /* R17341 */ - { 0x0000, 0x0000, 0x0000 }, /* R17342 */ - { 0x0000, 0x0000, 0x0000 }, /* R17343 */ - { 0x0000, 0x0000, 0x0000 }, /* R17344 */ - { 0x0000, 0x0000, 0x0000 }, /* R17345 */ - { 0x0000, 0x0000, 0x0000 }, /* R17346 */ - { 0x0000, 0x0000, 0x0000 }, /* R17347 */ - { 0x0000, 0x0000, 0x0000 }, /* R17348 */ - { 0x0000, 0x0000, 0x0000 }, /* R17349 */ - { 0x0000, 0x0000, 0x0000 }, /* R17350 */ - { 0x0000, 0x0000, 0x0000 }, /* R17351 */ - { 0x0000, 0x0000, 0x0000 }, /* R17352 */ - { 0x0000, 0x0000, 0x0000 }, /* R17353 */ - { 0x0000, 0x0000, 0x0000 }, /* R17354 */ - { 0x0000, 0x0000, 0x0000 }, /* R17355 */ - { 0x0000, 0x0000, 0x0000 }, /* R17356 */ - { 0x0000, 0x0000, 0x0000 }, /* R17357 */ - { 0x0000, 0x0000, 0x0000 }, /* R17358 */ - { 0x0000, 0x0000, 0x0000 }, /* R17359 */ - { 0x0000, 0x0000, 0x0000 }, /* R17360 */ - { 0x0000, 0x0000, 0x0000 }, /* R17361 */ - { 0x0000, 0x0000, 0x0000 }, /* R17362 */ - { 0x0000, 0x0000, 0x0000 }, /* R17363 */ - { 0x0000, 0x0000, 0x0000 }, /* R17364 */ - { 0x0000, 0x0000, 0x0000 }, /* R17365 */ - { 0x0000, 0x0000, 0x0000 }, /* R17366 */ - { 0x0000, 0x0000, 0x0000 }, /* R17367 */ - { 0x0000, 0x0000, 0x0000 }, /* R17368 */ - { 0x0000, 0x0000, 0x0000 }, /* R17369 */ - { 0x0000, 0x0000, 0x0000 }, /* R17370 */ - { 0x0000, 0x0000, 0x0000 }, /* R17371 */ - { 0x0000, 0x0000, 0x0000 }, /* R17372 */ - { 0x0000, 0x0000, 0x0000 }, /* R17373 */ - { 0x0000, 0x0000, 0x0000 }, /* R17374 */ - { 0x0000, 0x0000, 0x0000 }, /* R17375 */ - { 0x0000, 0x0000, 0x0000 }, /* R17376 */ - { 0x0000, 0x0000, 0x0000 }, /* R17377 */ - { 0x0000, 0x0000, 0x0000 }, /* R17378 */ - { 0x0000, 0x0000, 0x0000 }, /* R17379 */ - { 0x0000, 0x0000, 0x0000 }, /* R17380 */ - { 0x0000, 0x0000, 0x0000 }, /* R17381 */ - { 0x0000, 0x0000, 0x0000 }, /* R17382 */ - { 0x0000, 0x0000, 0x0000 }, /* R17383 */ - { 0x0000, 0x0000, 0x0000 }, /* R17384 */ - { 0x0000, 0x0000, 0x0000 }, /* R17385 */ - { 0x0000, 0x0000, 0x0000 }, /* R17386 */ - { 0x0000, 0x0000, 0x0000 }, /* R17387 */ - { 0x0000, 0x0000, 0x0000 }, /* R17388 */ - { 0x0000, 0x0000, 0x0000 }, /* R17389 */ - { 0x0000, 0x0000, 0x0000 }, /* R17390 */ - { 0x0000, 0x0000, 0x0000 }, /* R17391 */ - { 0x0000, 0x0000, 0x0000 }, /* R17392 */ - { 0x0000, 0x0000, 0x0000 }, /* R17393 */ - { 0x0000, 0x0000, 0x0000 }, /* R17394 */ - { 0x0000, 0x0000, 0x0000 }, /* R17395 */ - { 0x0000, 0x0000, 0x0000 }, /* R17396 */ - { 0x0000, 0x0000, 0x0000 }, /* R17397 */ - { 0x0000, 0x0000, 0x0000 }, /* R17398 */ - { 0x0000, 0x0000, 0x0000 }, /* R17399 */ - { 0x0000, 0x0000, 0x0000 }, /* R17400 */ - { 0x0000, 0x0000, 0x0000 }, /* R17401 */ - { 0x0000, 0x0000, 0x0000 }, /* R17402 */ - { 0x0000, 0x0000, 0x0000 }, /* R17403 */ - { 0x0000, 0x0000, 0x0000 }, /* R17404 */ - { 0x0000, 0x0000, 0x0000 }, /* R17405 */ - { 0x0000, 0x0000, 0x0000 }, /* R17406 */ - { 0x0000, 0x0000, 0x0000 }, /* R17407 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17408 - HPF_C_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17409 - HPF_C_0 */ - { 0x0000, 0x0000, 0x0000 }, /* R17410 */ - { 0x0000, 0x0000, 0x0000 }, /* R17411 */ - { 0x0000, 0x0000, 0x0000 }, /* R17412 */ - { 0x0000, 0x0000, 0x0000 }, /* R17413 */ - { 0x0000, 0x0000, 0x0000 }, /* R17414 */ - { 0x0000, 0x0000, 0x0000 }, /* R17415 */ - { 0x0000, 0x0000, 0x0000 }, /* R17416 */ - { 0x0000, 0x0000, 0x0000 }, /* R17417 */ - { 0x0000, 0x0000, 0x0000 }, /* R17418 */ - { 0x0000, 0x0000, 0x0000 }, /* R17419 */ - { 0x0000, 0x0000, 0x0000 }, /* R17420 */ - { 0x0000, 0x0000, 0x0000 }, /* R17421 */ - { 0x0000, 0x0000, 0x0000 }, /* R17422 */ - { 0x0000, 0x0000, 0x0000 }, /* R17423 */ - { 0x0000, 0x0000, 0x0000 }, /* R17424 */ - { 0x0000, 0x0000, 0x0000 }, /* R17425 */ - { 0x0000, 0x0000, 0x0000 }, /* R17426 */ - { 0x0000, 0x0000, 0x0000 }, /* R17427 */ - { 0x0000, 0x0000, 0x0000 }, /* R17428 */ - { 0x0000, 0x0000, 0x0000 }, /* R17429 */ - { 0x0000, 0x0000, 0x0000 }, /* R17430 */ - { 0x0000, 0x0000, 0x0000 }, /* R17431 */ - { 0x0000, 0x0000, 0x0000 }, /* R17432 */ - { 0x0000, 0x0000, 0x0000 }, /* R17433 */ - { 0x0000, 0x0000, 0x0000 }, /* R17434 */ - { 0x0000, 0x0000, 0x0000 }, /* R17435 */ - { 0x0000, 0x0000, 0x0000 }, /* R17436 */ - { 0x0000, 0x0000, 0x0000 }, /* R17437 */ - { 0x0000, 0x0000, 0x0000 }, /* R17438 */ - { 0x0000, 0x0000, 0x0000 }, /* R17439 */ - { 0x0000, 0x0000, 0x0000 }, /* R17440 */ - { 0x0000, 0x0000, 0x0000 }, /* R17441 */ - { 0x0000, 0x0000, 0x0000 }, /* R17442 */ - { 0x0000, 0x0000, 0x0000 }, /* R17443 */ - { 0x0000, 0x0000, 0x0000 }, /* R17444 */ - { 0x0000, 0x0000, 0x0000 }, /* R17445 */ - { 0x0000, 0x0000, 0x0000 }, /* R17446 */ - { 0x0000, 0x0000, 0x0000 }, /* R17447 */ - { 0x0000, 0x0000, 0x0000 }, /* R17448 */ - { 0x0000, 0x0000, 0x0000 }, /* R17449 */ - { 0x0000, 0x0000, 0x0000 }, /* R17450 */ - { 0x0000, 0x0000, 0x0000 }, /* R17451 */ - { 0x0000, 0x0000, 0x0000 }, /* R17452 */ - { 0x0000, 0x0000, 0x0000 }, /* R17453 */ - { 0x0000, 0x0000, 0x0000 }, /* R17454 */ - { 0x0000, 0x0000, 0x0000 }, /* R17455 */ - { 0x0000, 0x0000, 0x0000 }, /* R17456 */ - { 0x0000, 0x0000, 0x0000 }, /* R17457 */ - { 0x0000, 0x0000, 0x0000 }, /* R17458 */ - { 0x0000, 0x0000, 0x0000 }, /* R17459 */ - { 0x0000, 0x0000, 0x0000 }, /* R17460 */ - { 0x0000, 0x0000, 0x0000 }, /* R17461 */ - { 0x0000, 0x0000, 0x0000 }, /* R17462 */ - { 0x0000, 0x0000, 0x0000 }, /* R17463 */ - { 0x0000, 0x0000, 0x0000 }, /* R17464 */ - { 0x0000, 0x0000, 0x0000 }, /* R17465 */ - { 0x0000, 0x0000, 0x0000 }, /* R17466 */ - { 0x0000, 0x0000, 0x0000 }, /* R17467 */ - { 0x0000, 0x0000, 0x0000 }, /* R17468 */ - { 0x0000, 0x0000, 0x0000 }, /* R17469 */ - { 0x0000, 0x0000, 0x0000 }, /* R17470 */ - { 0x0000, 0x0000, 0x0000 }, /* R17471 */ - { 0x0000, 0x0000, 0x0000 }, /* R17472 */ - { 0x0000, 0x0000, 0x0000 }, /* R17473 */ - { 0x0000, 0x0000, 0x0000 }, /* R17474 */ - { 0x0000, 0x0000, 0x0000 }, /* R17475 */ - { 0x0000, 0x0000, 0x0000 }, /* R17476 */ - { 0x0000, 0x0000, 0x0000 }, /* R17477 */ - { 0x0000, 0x0000, 0x0000 }, /* R17478 */ - { 0x0000, 0x0000, 0x0000 }, /* R17479 */ - { 0x0000, 0x0000, 0x0000 }, /* R17480 */ - { 0x0000, 0x0000, 0x0000 }, /* R17481 */ - { 0x0000, 0x0000, 0x0000 }, /* R17482 */ - { 0x0000, 0x0000, 0x0000 }, /* R17483 */ - { 0x0000, 0x0000, 0x0000 }, /* R17484 */ - { 0x0000, 0x0000, 0x0000 }, /* R17485 */ - { 0x0000, 0x0000, 0x0000 }, /* R17486 */ - { 0x0000, 0x0000, 0x0000 }, /* R17487 */ - { 0x0000, 0x0000, 0x0000 }, /* R17488 */ - { 0x0000, 0x0000, 0x0000 }, /* R17489 */ - { 0x0000, 0x0000, 0x0000 }, /* R17490 */ - { 0x0000, 0x0000, 0x0000 }, /* R17491 */ - { 0x0000, 0x0000, 0x0000 }, /* R17492 */ - { 0x0000, 0x0000, 0x0000 }, /* R17493 */ - { 0x0000, 0x0000, 0x0000 }, /* R17494 */ - { 0x0000, 0x0000, 0x0000 }, /* R17495 */ - { 0x0000, 0x0000, 0x0000 }, /* R17496 */ - { 0x0000, 0x0000, 0x0000 }, /* R17497 */ - { 0x0000, 0x0000, 0x0000 }, /* R17498 */ - { 0x0000, 0x0000, 0x0000 }, /* R17499 */ - { 0x0000, 0x0000, 0x0000 }, /* R17500 */ - { 0x0000, 0x0000, 0x0000 }, /* R17501 */ - { 0x0000, 0x0000, 0x0000 }, /* R17502 */ - { 0x0000, 0x0000, 0x0000 }, /* R17503 */ - { 0x0000, 0x0000, 0x0000 }, /* R17504 */ - { 0x0000, 0x0000, 0x0000 }, /* R17505 */ - { 0x0000, 0x0000, 0x0000 }, /* R17506 */ - { 0x0000, 0x0000, 0x0000 }, /* R17507 */ - { 0x0000, 0x0000, 0x0000 }, /* R17508 */ - { 0x0000, 0x0000, 0x0000 }, /* R17509 */ - { 0x0000, 0x0000, 0x0000 }, /* R17510 */ - { 0x0000, 0x0000, 0x0000 }, /* R17511 */ - { 0x0000, 0x0000, 0x0000 }, /* R17512 */ - { 0x0000, 0x0000, 0x0000 }, /* R17513 */ - { 0x0000, 0x0000, 0x0000 }, /* R17514 */ - { 0x0000, 0x0000, 0x0000 }, /* R17515 */ - { 0x0000, 0x0000, 0x0000 }, /* R17516 */ - { 0x0000, 0x0000, 0x0000 }, /* R17517 */ - { 0x0000, 0x0000, 0x0000 }, /* R17518 */ - { 0x0000, 0x0000, 0x0000 }, /* R17519 */ - { 0x0000, 0x0000, 0x0000 }, /* R17520 */ - { 0x0000, 0x0000, 0x0000 }, /* R17521 */ - { 0x0000, 0x0000, 0x0000 }, /* R17522 */ - { 0x0000, 0x0000, 0x0000 }, /* R17523 */ - { 0x0000, 0x0000, 0x0000 }, /* R17524 */ - { 0x0000, 0x0000, 0x0000 }, /* R17525 */ - { 0x0000, 0x0000, 0x0000 }, /* R17526 */ - { 0x0000, 0x0000, 0x0000 }, /* R17527 */ - { 0x0000, 0x0000, 0x0000 }, /* R17528 */ - { 0x0000, 0x0000, 0x0000 }, /* R17529 */ - { 0x0000, 0x0000, 0x0000 }, /* R17530 */ - { 0x0000, 0x0000, 0x0000 }, /* R17531 */ - { 0x0000, 0x0000, 0x0000 }, /* R17532 */ - { 0x0000, 0x0000, 0x0000 }, /* R17533 */ - { 0x0000, 0x0000, 0x0000 }, /* R17534 */ - { 0x0000, 0x0000, 0x0000 }, /* R17535 */ - { 0x0000, 0x0000, 0x0000 }, /* R17536 */ - { 0x0000, 0x0000, 0x0000 }, /* R17537 */ - { 0x0000, 0x0000, 0x0000 }, /* R17538 */ - { 0x0000, 0x0000, 0x0000 }, /* R17539 */ - { 0x0000, 0x0000, 0x0000 }, /* R17540 */ - { 0x0000, 0x0000, 0x0000 }, /* R17541 */ - { 0x0000, 0x0000, 0x0000 }, /* R17542 */ - { 0x0000, 0x0000, 0x0000 }, /* R17543 */ - { 0x0000, 0x0000, 0x0000 }, /* R17544 */ - { 0x0000, 0x0000, 0x0000 }, /* R17545 */ - { 0x0000, 0x0000, 0x0000 }, /* R17546 */ - { 0x0000, 0x0000, 0x0000 }, /* R17547 */ - { 0x0000, 0x0000, 0x0000 }, /* R17548 */ - { 0x0000, 0x0000, 0x0000 }, /* R17549 */ - { 0x0000, 0x0000, 0x0000 }, /* R17550 */ - { 0x0000, 0x0000, 0x0000 }, /* R17551 */ - { 0x0000, 0x0000, 0x0000 }, /* R17552 */ - { 0x0000, 0x0000, 0x0000 }, /* R17553 */ - { 0x0000, 0x0000, 0x0000 }, /* R17554 */ - { 0x0000, 0x0000, 0x0000 }, /* R17555 */ - { 0x0000, 0x0000, 0x0000 }, /* R17556 */ - { 0x0000, 0x0000, 0x0000 }, /* R17557 */ - { 0x0000, 0x0000, 0x0000 }, /* R17558 */ - { 0x0000, 0x0000, 0x0000 }, /* R17559 */ - { 0x0000, 0x0000, 0x0000 }, /* R17560 */ - { 0x0000, 0x0000, 0x0000 }, /* R17561 */ - { 0x0000, 0x0000, 0x0000 }, /* R17562 */ - { 0x0000, 0x0000, 0x0000 }, /* R17563 */ - { 0x0000, 0x0000, 0x0000 }, /* R17564 */ - { 0x0000, 0x0000, 0x0000 }, /* R17565 */ - { 0x0000, 0x0000, 0x0000 }, /* R17566 */ - { 0x0000, 0x0000, 0x0000 }, /* R17567 */ - { 0x0000, 0x0000, 0x0000 }, /* R17568 */ - { 0x0000, 0x0000, 0x0000 }, /* R17569 */ - { 0x0000, 0x0000, 0x0000 }, /* R17570 */ - { 0x0000, 0x0000, 0x0000 }, /* R17571 */ - { 0x0000, 0x0000, 0x0000 }, /* R17572 */ - { 0x0000, 0x0000, 0x0000 }, /* R17573 */ - { 0x0000, 0x0000, 0x0000 }, /* R17574 */ - { 0x0000, 0x0000, 0x0000 }, /* R17575 */ - { 0x0000, 0x0000, 0x0000 }, /* R17576 */ - { 0x0000, 0x0000, 0x0000 }, /* R17577 */ - { 0x0000, 0x0000, 0x0000 }, /* R17578 */ - { 0x0000, 0x0000, 0x0000 }, /* R17579 */ - { 0x0000, 0x0000, 0x0000 }, /* R17580 */ - { 0x0000, 0x0000, 0x0000 }, /* R17581 */ - { 0x0000, 0x0000, 0x0000 }, /* R17582 */ - { 0x0000, 0x0000, 0x0000 }, /* R17583 */ - { 0x0000, 0x0000, 0x0000 }, /* R17584 */ - { 0x0000, 0x0000, 0x0000 }, /* R17585 */ - { 0x0000, 0x0000, 0x0000 }, /* R17586 */ - { 0x0000, 0x0000, 0x0000 }, /* R17587 */ - { 0x0000, 0x0000, 0x0000 }, /* R17588 */ - { 0x0000, 0x0000, 0x0000 }, /* R17589 */ - { 0x0000, 0x0000, 0x0000 }, /* R17590 */ - { 0x0000, 0x0000, 0x0000 }, /* R17591 */ - { 0x0000, 0x0000, 0x0000 }, /* R17592 */ - { 0x0000, 0x0000, 0x0000 }, /* R17593 */ - { 0x0000, 0x0000, 0x0000 }, /* R17594 */ - { 0x0000, 0x0000, 0x0000 }, /* R17595 */ - { 0x0000, 0x0000, 0x0000 }, /* R17596 */ - { 0x0000, 0x0000, 0x0000 }, /* R17597 */ - { 0x0000, 0x0000, 0x0000 }, /* R17598 */ - { 0x0000, 0x0000, 0x0000 }, /* R17599 */ - { 0x0000, 0x0000, 0x0000 }, /* R17600 */ - { 0x0000, 0x0000, 0x0000 }, /* R17601 */ - { 0x0000, 0x0000, 0x0000 }, /* R17602 */ - { 0x0000, 0x0000, 0x0000 }, /* R17603 */ - { 0x0000, 0x0000, 0x0000 }, /* R17604 */ - { 0x0000, 0x0000, 0x0000 }, /* R17605 */ - { 0x0000, 0x0000, 0x0000 }, /* R17606 */ - { 0x0000, 0x0000, 0x0000 }, /* R17607 */ - { 0x0000, 0x0000, 0x0000 }, /* R17608 */ - { 0x0000, 0x0000, 0x0000 }, /* R17609 */ - { 0x0000, 0x0000, 0x0000 }, /* R17610 */ - { 0x0000, 0x0000, 0x0000 }, /* R17611 */ - { 0x0000, 0x0000, 0x0000 }, /* R17612 */ - { 0x0000, 0x0000, 0x0000 }, /* R17613 */ - { 0x0000, 0x0000, 0x0000 }, /* R17614 */ - { 0x0000, 0x0000, 0x0000 }, /* R17615 */ - { 0x0000, 0x0000, 0x0000 }, /* R17616 */ - { 0x0000, 0x0000, 0x0000 }, /* R17617 */ - { 0x0000, 0x0000, 0x0000 }, /* R17618 */ - { 0x0000, 0x0000, 0x0000 }, /* R17619 */ - { 0x0000, 0x0000, 0x0000 }, /* R17620 */ - { 0x0000, 0x0000, 0x0000 }, /* R17621 */ - { 0x0000, 0x0000, 0x0000 }, /* R17622 */ - { 0x0000, 0x0000, 0x0000 }, /* R17623 */ - { 0x0000, 0x0000, 0x0000 }, /* R17624 */ - { 0x0000, 0x0000, 0x0000 }, /* R17625 */ - { 0x0000, 0x0000, 0x0000 }, /* R17626 */ - { 0x0000, 0x0000, 0x0000 }, /* R17627 */ - { 0x0000, 0x0000, 0x0000 }, /* R17628 */ - { 0x0000, 0x0000, 0x0000 }, /* R17629 */ - { 0x0000, 0x0000, 0x0000 }, /* R17630 */ - { 0x0000, 0x0000, 0x0000 }, /* R17631 */ - { 0x0000, 0x0000, 0x0000 }, /* R17632 */ - { 0x0000, 0x0000, 0x0000 }, /* R17633 */ - { 0x0000, 0x0000, 0x0000 }, /* R17634 */ - { 0x0000, 0x0000, 0x0000 }, /* R17635 */ - { 0x0000, 0x0000, 0x0000 }, /* R17636 */ - { 0x0000, 0x0000, 0x0000 }, /* R17637 */ - { 0x0000, 0x0000, 0x0000 }, /* R17638 */ - { 0x0000, 0x0000, 0x0000 }, /* R17639 */ - { 0x0000, 0x0000, 0x0000 }, /* R17640 */ - { 0x0000, 0x0000, 0x0000 }, /* R17641 */ - { 0x0000, 0x0000, 0x0000 }, /* R17642 */ - { 0x0000, 0x0000, 0x0000 }, /* R17643 */ - { 0x0000, 0x0000, 0x0000 }, /* R17644 */ - { 0x0000, 0x0000, 0x0000 }, /* R17645 */ - { 0x0000, 0x0000, 0x0000 }, /* R17646 */ - { 0x0000, 0x0000, 0x0000 }, /* R17647 */ - { 0x0000, 0x0000, 0x0000 }, /* R17648 */ - { 0x0000, 0x0000, 0x0000 }, /* R17649 */ - { 0x0000, 0x0000, 0x0000 }, /* R17650 */ - { 0x0000, 0x0000, 0x0000 }, /* R17651 */ - { 0x0000, 0x0000, 0x0000 }, /* R17652 */ - { 0x0000, 0x0000, 0x0000 }, /* R17653 */ - { 0x0000, 0x0000, 0x0000 }, /* R17654 */ - { 0x0000, 0x0000, 0x0000 }, /* R17655 */ - { 0x0000, 0x0000, 0x0000 }, /* R17656 */ - { 0x0000, 0x0000, 0x0000 }, /* R17657 */ - { 0x0000, 0x0000, 0x0000 }, /* R17658 */ - { 0x0000, 0x0000, 0x0000 }, /* R17659 */ - { 0x0000, 0x0000, 0x0000 }, /* R17660 */ - { 0x0000, 0x0000, 0x0000 }, /* R17661 */ - { 0x0000, 0x0000, 0x0000 }, /* R17662 */ - { 0x0000, 0x0000, 0x0000 }, /* R17663 */ - { 0x0000, 0x0000, 0x0000 }, /* R17664 */ - { 0x0000, 0x0000, 0x0000 }, /* R17665 */ - { 0x0000, 0x0000, 0x0000 }, /* R17666 */ - { 0x0000, 0x0000, 0x0000 }, /* R17667 */ - { 0x0000, 0x0000, 0x0000 }, /* R17668 */ - { 0x0000, 0x0000, 0x0000 }, /* R17669 */ - { 0x0000, 0x0000, 0x0000 }, /* R17670 */ - { 0x0000, 0x0000, 0x0000 }, /* R17671 */ - { 0x0000, 0x0000, 0x0000 }, /* R17672 */ - { 0x0000, 0x0000, 0x0000 }, /* R17673 */ - { 0x0000, 0x0000, 0x0000 }, /* R17674 */ - { 0x0000, 0x0000, 0x0000 }, /* R17675 */ - { 0x0000, 0x0000, 0x0000 }, /* R17676 */ - { 0x0000, 0x0000, 0x0000 }, /* R17677 */ - { 0x0000, 0x0000, 0x0000 }, /* R17678 */ - { 0x0000, 0x0000, 0x0000 }, /* R17679 */ - { 0x0000, 0x0000, 0x0000 }, /* R17680 */ - { 0x0000, 0x0000, 0x0000 }, /* R17681 */ - { 0x0000, 0x0000, 0x0000 }, /* R17682 */ - { 0x0000, 0x0000, 0x0000 }, /* R17683 */ - { 0x0000, 0x0000, 0x0000 }, /* R17684 */ - { 0x0000, 0x0000, 0x0000 }, /* R17685 */ - { 0x0000, 0x0000, 0x0000 }, /* R17686 */ - { 0x0000, 0x0000, 0x0000 }, /* R17687 */ - { 0x0000, 0x0000, 0x0000 }, /* R17688 */ - { 0x0000, 0x0000, 0x0000 }, /* R17689 */ - { 0x0000, 0x0000, 0x0000 }, /* R17690 */ - { 0x0000, 0x0000, 0x0000 }, /* R17691 */ - { 0x0000, 0x0000, 0x0000 }, /* R17692 */ - { 0x0000, 0x0000, 0x0000 }, /* R17693 */ - { 0x0000, 0x0000, 0x0000 }, /* R17694 */ - { 0x0000, 0x0000, 0x0000 }, /* R17695 */ - { 0x0000, 0x0000, 0x0000 }, /* R17696 */ - { 0x0000, 0x0000, 0x0000 }, /* R17697 */ - { 0x0000, 0x0000, 0x0000 }, /* R17698 */ - { 0x0000, 0x0000, 0x0000 }, /* R17699 */ - { 0x0000, 0x0000, 0x0000 }, /* R17700 */ - { 0x0000, 0x0000, 0x0000 }, /* R17701 */ - { 0x0000, 0x0000, 0x0000 }, /* R17702 */ - { 0x0000, 0x0000, 0x0000 }, /* R17703 */ - { 0x0000, 0x0000, 0x0000 }, /* R17704 */ - { 0x0000, 0x0000, 0x0000 }, /* R17705 */ - { 0x0000, 0x0000, 0x0000 }, /* R17706 */ - { 0x0000, 0x0000, 0x0000 }, /* R17707 */ - { 0x0000, 0x0000, 0x0000 }, /* R17708 */ - { 0x0000, 0x0000, 0x0000 }, /* R17709 */ - { 0x0000, 0x0000, 0x0000 }, /* R17710 */ - { 0x0000, 0x0000, 0x0000 }, /* R17711 */ - { 0x0000, 0x0000, 0x0000 }, /* R17712 */ - { 0x0000, 0x0000, 0x0000 }, /* R17713 */ - { 0x0000, 0x0000, 0x0000 }, /* R17714 */ - { 0x0000, 0x0000, 0x0000 }, /* R17715 */ - { 0x0000, 0x0000, 0x0000 }, /* R17716 */ - { 0x0000, 0x0000, 0x0000 }, /* R17717 */ - { 0x0000, 0x0000, 0x0000 }, /* R17718 */ - { 0x0000, 0x0000, 0x0000 }, /* R17719 */ - { 0x0000, 0x0000, 0x0000 }, /* R17720 */ - { 0x0000, 0x0000, 0x0000 }, /* R17721 */ - { 0x0000, 0x0000, 0x0000 }, /* R17722 */ - { 0x0000, 0x0000, 0x0000 }, /* R17723 */ - { 0x0000, 0x0000, 0x0000 }, /* R17724 */ - { 0x0000, 0x0000, 0x0000 }, /* R17725 */ - { 0x0000, 0x0000, 0x0000 }, /* R17726 */ - { 0x0000, 0x0000, 0x0000 }, /* R17727 */ - { 0x0000, 0x0000, 0x0000 }, /* R17728 */ - { 0x0000, 0x0000, 0x0000 }, /* R17729 */ - { 0x0000, 0x0000, 0x0000 }, /* R17730 */ - { 0x0000, 0x0000, 0x0000 }, /* R17731 */ - { 0x0000, 0x0000, 0x0000 }, /* R17732 */ - { 0x0000, 0x0000, 0x0000 }, /* R17733 */ - { 0x0000, 0x0000, 0x0000 }, /* R17734 */ - { 0x0000, 0x0000, 0x0000 }, /* R17735 */ - { 0x0000, 0x0000, 0x0000 }, /* R17736 */ - { 0x0000, 0x0000, 0x0000 }, /* R17737 */ - { 0x0000, 0x0000, 0x0000 }, /* R17738 */ - { 0x0000, 0x0000, 0x0000 }, /* R17739 */ - { 0x0000, 0x0000, 0x0000 }, /* R17740 */ - { 0x0000, 0x0000, 0x0000 }, /* R17741 */ - { 0x0000, 0x0000, 0x0000 }, /* R17742 */ - { 0x0000, 0x0000, 0x0000 }, /* R17743 */ - { 0x0000, 0x0000, 0x0000 }, /* R17744 */ - { 0x0000, 0x0000, 0x0000 }, /* R17745 */ - { 0x0000, 0x0000, 0x0000 }, /* R17746 */ - { 0x0000, 0x0000, 0x0000 }, /* R17747 */ - { 0x0000, 0x0000, 0x0000 }, /* R17748 */ - { 0x0000, 0x0000, 0x0000 }, /* R17749 */ - { 0x0000, 0x0000, 0x0000 }, /* R17750 */ - { 0x0000, 0x0000, 0x0000 }, /* R17751 */ - { 0x0000, 0x0000, 0x0000 }, /* R17752 */ - { 0x0000, 0x0000, 0x0000 }, /* R17753 */ - { 0x0000, 0x0000, 0x0000 }, /* R17754 */ - { 0x0000, 0x0000, 0x0000 }, /* R17755 */ - { 0x0000, 0x0000, 0x0000 }, /* R17756 */ - { 0x0000, 0x0000, 0x0000 }, /* R17757 */ - { 0x0000, 0x0000, 0x0000 }, /* R17758 */ - { 0x0000, 0x0000, 0x0000 }, /* R17759 */ - { 0x0000, 0x0000, 0x0000 }, /* R17760 */ - { 0x0000, 0x0000, 0x0000 }, /* R17761 */ - { 0x0000, 0x0000, 0x0000 }, /* R17762 */ - { 0x0000, 0x0000, 0x0000 }, /* R17763 */ - { 0x0000, 0x0000, 0x0000 }, /* R17764 */ - { 0x0000, 0x0000, 0x0000 }, /* R17765 */ - { 0x0000, 0x0000, 0x0000 }, /* R17766 */ - { 0x0000, 0x0000, 0x0000 }, /* R17767 */ - { 0x0000, 0x0000, 0x0000 }, /* R17768 */ - { 0x0000, 0x0000, 0x0000 }, /* R17769 */ - { 0x0000, 0x0000, 0x0000 }, /* R17770 */ - { 0x0000, 0x0000, 0x0000 }, /* R17771 */ - { 0x0000, 0x0000, 0x0000 }, /* R17772 */ - { 0x0000, 0x0000, 0x0000 }, /* R17773 */ - { 0x0000, 0x0000, 0x0000 }, /* R17774 */ - { 0x0000, 0x0000, 0x0000 }, /* R17775 */ - { 0x0000, 0x0000, 0x0000 }, /* R17776 */ - { 0x0000, 0x0000, 0x0000 }, /* R17777 */ - { 0x0000, 0x0000, 0x0000 }, /* R17778 */ - { 0x0000, 0x0000, 0x0000 }, /* R17779 */ - { 0x0000, 0x0000, 0x0000 }, /* R17780 */ - { 0x0000, 0x0000, 0x0000 }, /* R17781 */ - { 0x0000, 0x0000, 0x0000 }, /* R17782 */ - { 0x0000, 0x0000, 0x0000 }, /* R17783 */ - { 0x0000, 0x0000, 0x0000 }, /* R17784 */ - { 0x0000, 0x0000, 0x0000 }, /* R17785 */ - { 0x0000, 0x0000, 0x0000 }, /* R17786 */ - { 0x0000, 0x0000, 0x0000 }, /* R17787 */ - { 0x0000, 0x0000, 0x0000 }, /* R17788 */ - { 0x0000, 0x0000, 0x0000 }, /* R17789 */ - { 0x0000, 0x0000, 0x0000 }, /* R17790 */ - { 0x0000, 0x0000, 0x0000 }, /* R17791 */ - { 0x0000, 0x0000, 0x0000 }, /* R17792 */ - { 0x0000, 0x0000, 0x0000 }, /* R17793 */ - { 0x0000, 0x0000, 0x0000 }, /* R17794 */ - { 0x0000, 0x0000, 0x0000 }, /* R17795 */ - { 0x0000, 0x0000, 0x0000 }, /* R17796 */ - { 0x0000, 0x0000, 0x0000 }, /* R17797 */ - { 0x0000, 0x0000, 0x0000 }, /* R17798 */ - { 0x0000, 0x0000, 0x0000 }, /* R17799 */ - { 0x0000, 0x0000, 0x0000 }, /* R17800 */ - { 0x0000, 0x0000, 0x0000 }, /* R17801 */ - { 0x0000, 0x0000, 0x0000 }, /* R17802 */ - { 0x0000, 0x0000, 0x0000 }, /* R17803 */ - { 0x0000, 0x0000, 0x0000 }, /* R17804 */ - { 0x0000, 0x0000, 0x0000 }, /* R17805 */ - { 0x0000, 0x0000, 0x0000 }, /* R17806 */ - { 0x0000, 0x0000, 0x0000 }, /* R17807 */ - { 0x0000, 0x0000, 0x0000 }, /* R17808 */ - { 0x0000, 0x0000, 0x0000 }, /* R17809 */ - { 0x0000, 0x0000, 0x0000 }, /* R17810 */ - { 0x0000, 0x0000, 0x0000 }, /* R17811 */ - { 0x0000, 0x0000, 0x0000 }, /* R17812 */ - { 0x0000, 0x0000, 0x0000 }, /* R17813 */ - { 0x0000, 0x0000, 0x0000 }, /* R17814 */ - { 0x0000, 0x0000, 0x0000 }, /* R17815 */ - { 0x0000, 0x0000, 0x0000 }, /* R17816 */ - { 0x0000, 0x0000, 0x0000 }, /* R17817 */ - { 0x0000, 0x0000, 0x0000 }, /* R17818 */ - { 0x0000, 0x0000, 0x0000 }, /* R17819 */ - { 0x0000, 0x0000, 0x0000 }, /* R17820 */ - { 0x0000, 0x0000, 0x0000 }, /* R17821 */ - { 0x0000, 0x0000, 0x0000 }, /* R17822 */ - { 0x0000, 0x0000, 0x0000 }, /* R17823 */ - { 0x0000, 0x0000, 0x0000 }, /* R17824 */ - { 0x0000, 0x0000, 0x0000 }, /* R17825 */ - { 0x0000, 0x0000, 0x0000 }, /* R17826 */ - { 0x0000, 0x0000, 0x0000 }, /* R17827 */ - { 0x0000, 0x0000, 0x0000 }, /* R17828 */ - { 0x0000, 0x0000, 0x0000 }, /* R17829 */ - { 0x0000, 0x0000, 0x0000 }, /* R17830 */ - { 0x0000, 0x0000, 0x0000 }, /* R17831 */ - { 0x0000, 0x0000, 0x0000 }, /* R17832 */ - { 0x0000, 0x0000, 0x0000 }, /* R17833 */ - { 0x0000, 0x0000, 0x0000 }, /* R17834 */ - { 0x0000, 0x0000, 0x0000 }, /* R17835 */ - { 0x0000, 0x0000, 0x0000 }, /* R17836 */ - { 0x0000, 0x0000, 0x0000 }, /* R17837 */ - { 0x0000, 0x0000, 0x0000 }, /* R17838 */ - { 0x0000, 0x0000, 0x0000 }, /* R17839 */ - { 0x0000, 0x0000, 0x0000 }, /* R17840 */ - { 0x0000, 0x0000, 0x0000 }, /* R17841 */ - { 0x0000, 0x0000, 0x0000 }, /* R17842 */ - { 0x0000, 0x0000, 0x0000 }, /* R17843 */ - { 0x0000, 0x0000, 0x0000 }, /* R17844 */ - { 0x0000, 0x0000, 0x0000 }, /* R17845 */ - { 0x0000, 0x0000, 0x0000 }, /* R17846 */ - { 0x0000, 0x0000, 0x0000 }, /* R17847 */ - { 0x0000, 0x0000, 0x0000 }, /* R17848 */ - { 0x0000, 0x0000, 0x0000 }, /* R17849 */ - { 0x0000, 0x0000, 0x0000 }, /* R17850 */ - { 0x0000, 0x0000, 0x0000 }, /* R17851 */ - { 0x0000, 0x0000, 0x0000 }, /* R17852 */ - { 0x0000, 0x0000, 0x0000 }, /* R17853 */ - { 0x0000, 0x0000, 0x0000 }, /* R17854 */ - { 0x0000, 0x0000, 0x0000 }, /* R17855 */ - { 0x0000, 0x0000, 0x0000 }, /* R17856 */ - { 0x0000, 0x0000, 0x0000 }, /* R17857 */ - { 0x0000, 0x0000, 0x0000 }, /* R17858 */ - { 0x0000, 0x0000, 0x0000 }, /* R17859 */ - { 0x0000, 0x0000, 0x0000 }, /* R17860 */ - { 0x0000, 0x0000, 0x0000 }, /* R17861 */ - { 0x0000, 0x0000, 0x0000 }, /* R17862 */ - { 0x0000, 0x0000, 0x0000 }, /* R17863 */ - { 0x0000, 0x0000, 0x0000 }, /* R17864 */ - { 0x0000, 0x0000, 0x0000 }, /* R17865 */ - { 0x0000, 0x0000, 0x0000 }, /* R17866 */ - { 0x0000, 0x0000, 0x0000 }, /* R17867 */ - { 0x0000, 0x0000, 0x0000 }, /* R17868 */ - { 0x0000, 0x0000, 0x0000 }, /* R17869 */ - { 0x0000, 0x0000, 0x0000 }, /* R17870 */ - { 0x0000, 0x0000, 0x0000 }, /* R17871 */ - { 0x0000, 0x0000, 0x0000 }, /* R17872 */ - { 0x0000, 0x0000, 0x0000 }, /* R17873 */ - { 0x0000, 0x0000, 0x0000 }, /* R17874 */ - { 0x0000, 0x0000, 0x0000 }, /* R17875 */ - { 0x0000, 0x0000, 0x0000 }, /* R17876 */ - { 0x0000, 0x0000, 0x0000 }, /* R17877 */ - { 0x0000, 0x0000, 0x0000 }, /* R17878 */ - { 0x0000, 0x0000, 0x0000 }, /* R17879 */ - { 0x0000, 0x0000, 0x0000 }, /* R17880 */ - { 0x0000, 0x0000, 0x0000 }, /* R17881 */ - { 0x0000, 0x0000, 0x0000 }, /* R17882 */ - { 0x0000, 0x0000, 0x0000 }, /* R17883 */ - { 0x0000, 0x0000, 0x0000 }, /* R17884 */ - { 0x0000, 0x0000, 0x0000 }, /* R17885 */ - { 0x0000, 0x0000, 0x0000 }, /* R17886 */ - { 0x0000, 0x0000, 0x0000 }, /* R17887 */ - { 0x0000, 0x0000, 0x0000 }, /* R17888 */ - { 0x0000, 0x0000, 0x0000 }, /* R17889 */ - { 0x0000, 0x0000, 0x0000 }, /* R17890 */ - { 0x0000, 0x0000, 0x0000 }, /* R17891 */ - { 0x0000, 0x0000, 0x0000 }, /* R17892 */ - { 0x0000, 0x0000, 0x0000 }, /* R17893 */ - { 0x0000, 0x0000, 0x0000 }, /* R17894 */ - { 0x0000, 0x0000, 0x0000 }, /* R17895 */ - { 0x0000, 0x0000, 0x0000 }, /* R17896 */ - { 0x0000, 0x0000, 0x0000 }, /* R17897 */ - { 0x0000, 0x0000, 0x0000 }, /* R17898 */ - { 0x0000, 0x0000, 0x0000 }, /* R17899 */ - { 0x0000, 0x0000, 0x0000 }, /* R17900 */ - { 0x0000, 0x0000, 0x0000 }, /* R17901 */ - { 0x0000, 0x0000, 0x0000 }, /* R17902 */ - { 0x0000, 0x0000, 0x0000 }, /* R17903 */ - { 0x0000, 0x0000, 0x0000 }, /* R17904 */ - { 0x0000, 0x0000, 0x0000 }, /* R17905 */ - { 0x0000, 0x0000, 0x0000 }, /* R17906 */ - { 0x0000, 0x0000, 0x0000 }, /* R17907 */ - { 0x0000, 0x0000, 0x0000 }, /* R17908 */ - { 0x0000, 0x0000, 0x0000 }, /* R17909 */ - { 0x0000, 0x0000, 0x0000 }, /* R17910 */ - { 0x0000, 0x0000, 0x0000 }, /* R17911 */ - { 0x0000, 0x0000, 0x0000 }, /* R17912 */ - { 0x0000, 0x0000, 0x0000 }, /* R17913 */ - { 0x0000, 0x0000, 0x0000 }, /* R17914 */ - { 0x0000, 0x0000, 0x0000 }, /* R17915 */ - { 0x0000, 0x0000, 0x0000 }, /* R17916 */ - { 0x0000, 0x0000, 0x0000 }, /* R17917 */ - { 0x0000, 0x0000, 0x0000 }, /* R17918 */ - { 0x0000, 0x0000, 0x0000 }, /* R17919 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17920 - ADCL_RETUNE_C1_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17921 - ADCL_RETUNE_C1_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17922 - ADCL_RETUNE_C2_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17923 - ADCL_RETUNE_C2_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17924 - ADCL_RETUNE_C3_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17925 - ADCL_RETUNE_C3_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17926 - ADCL_RETUNE_C4_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17927 - ADCL_RETUNE_C4_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17928 - ADCL_RETUNE_C5_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17929 - ADCL_RETUNE_C5_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17930 - ADCL_RETUNE_C6_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17931 - ADCL_RETUNE_C6_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17932 - ADCL_RETUNE_C7_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17933 - ADCL_RETUNE_C7_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17934 - ADCL_RETUNE_C8_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17935 - ADCL_RETUNE_C8_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17936 - ADCL_RETUNE_C9_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17937 - ADCL_RETUNE_C9_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17938 - ADCL_RETUNE_C10_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17939 - ADCL_RETUNE_C10_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17940 - ADCL_RETUNE_C11_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17941 - ADCL_RETUNE_C11_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17942 - ADCL_RETUNE_C12_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17943 - ADCL_RETUNE_C12_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17944 - ADCL_RETUNE_C13_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17945 - ADCL_RETUNE_C13_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17946 - ADCL_RETUNE_C14_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17947 - ADCL_RETUNE_C14_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17948 - ADCL_RETUNE_C15_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17949 - ADCL_RETUNE_C15_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17950 - ADCL_RETUNE_C16_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17951 - ADCL_RETUNE_C16_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17952 - ADCL_RETUNE_C17_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17953 - ADCL_RETUNE_C17_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17954 - ADCL_RETUNE_C18_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17955 - ADCL_RETUNE_C18_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17956 - ADCL_RETUNE_C19_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17957 - ADCL_RETUNE_C19_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17958 - ADCL_RETUNE_C20_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17959 - ADCL_RETUNE_C20_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17960 - ADCL_RETUNE_C21_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17961 - ADCL_RETUNE_C21_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17962 - ADCL_RETUNE_C22_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17963 - ADCL_RETUNE_C22_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17964 - ADCL_RETUNE_C23_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17965 - ADCL_RETUNE_C23_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17966 - ADCL_RETUNE_C24_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17967 - ADCL_RETUNE_C24_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17968 - ADCL_RETUNE_C25_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17969 - ADCL_RETUNE_C25_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17970 - ADCL_RETUNE_C26_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17971 - ADCL_RETUNE_C26_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17972 - ADCL_RETUNE_C27_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17973 - ADCL_RETUNE_C27_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17974 - ADCL_RETUNE_C28_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17975 - ADCL_RETUNE_C28_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17976 - ADCL_RETUNE_C29_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17977 - ADCL_RETUNE_C29_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17978 - ADCL_RETUNE_C30_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17979 - ADCL_RETUNE_C30_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17980 - ADCL_RETUNE_C31_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17981 - ADCL_RETUNE_C31_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R17982 - ADCL_RETUNE_C32_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R17983 - ADCL_RETUNE_C32_0 */ - { 0x0000, 0x0000, 0x0000 }, /* R17984 */ - { 0x0000, 0x0000, 0x0000 }, /* R17985 */ - { 0x0000, 0x0000, 0x0000 }, /* R17986 */ - { 0x0000, 0x0000, 0x0000 }, /* R17987 */ - { 0x0000, 0x0000, 0x0000 }, /* R17988 */ - { 0x0000, 0x0000, 0x0000 }, /* R17989 */ - { 0x0000, 0x0000, 0x0000 }, /* R17990 */ - { 0x0000, 0x0000, 0x0000 }, /* R17991 */ - { 0x0000, 0x0000, 0x0000 }, /* R17992 */ - { 0x0000, 0x0000, 0x0000 }, /* R17993 */ - { 0x0000, 0x0000, 0x0000 }, /* R17994 */ - { 0x0000, 0x0000, 0x0000 }, /* R17995 */ - { 0x0000, 0x0000, 0x0000 }, /* R17996 */ - { 0x0000, 0x0000, 0x0000 }, /* R17997 */ - { 0x0000, 0x0000, 0x0000 }, /* R17998 */ - { 0x0000, 0x0000, 0x0000 }, /* R17999 */ - { 0x0000, 0x0000, 0x0000 }, /* R18000 */ - { 0x0000, 0x0000, 0x0000 }, /* R18001 */ - { 0x0000, 0x0000, 0x0000 }, /* R18002 */ - { 0x0000, 0x0000, 0x0000 }, /* R18003 */ - { 0x0000, 0x0000, 0x0000 }, /* R18004 */ - { 0x0000, 0x0000, 0x0000 }, /* R18005 */ - { 0x0000, 0x0000, 0x0000 }, /* R18006 */ - { 0x0000, 0x0000, 0x0000 }, /* R18007 */ - { 0x0000, 0x0000, 0x0000 }, /* R18008 */ - { 0x0000, 0x0000, 0x0000 }, /* R18009 */ - { 0x0000, 0x0000, 0x0000 }, /* R18010 */ - { 0x0000, 0x0000, 0x0000 }, /* R18011 */ - { 0x0000, 0x0000, 0x0000 }, /* R18012 */ - { 0x0000, 0x0000, 0x0000 }, /* R18013 */ - { 0x0000, 0x0000, 0x0000 }, /* R18014 */ - { 0x0000, 0x0000, 0x0000 }, /* R18015 */ - { 0x0000, 0x0000, 0x0000 }, /* R18016 */ - { 0x0000, 0x0000, 0x0000 }, /* R18017 */ - { 0x0000, 0x0000, 0x0000 }, /* R18018 */ - { 0x0000, 0x0000, 0x0000 }, /* R18019 */ - { 0x0000, 0x0000, 0x0000 }, /* R18020 */ - { 0x0000, 0x0000, 0x0000 }, /* R18021 */ - { 0x0000, 0x0000, 0x0000 }, /* R18022 */ - { 0x0000, 0x0000, 0x0000 }, /* R18023 */ - { 0x0000, 0x0000, 0x0000 }, /* R18024 */ - { 0x0000, 0x0000, 0x0000 }, /* R18025 */ - { 0x0000, 0x0000, 0x0000 }, /* R18026 */ - { 0x0000, 0x0000, 0x0000 }, /* R18027 */ - { 0x0000, 0x0000, 0x0000 }, /* R18028 */ - { 0x0000, 0x0000, 0x0000 }, /* R18029 */ - { 0x0000, 0x0000, 0x0000 }, /* R18030 */ - { 0x0000, 0x0000, 0x0000 }, /* R18031 */ - { 0x0000, 0x0000, 0x0000 }, /* R18032 */ - { 0x0000, 0x0000, 0x0000 }, /* R18033 */ - { 0x0000, 0x0000, 0x0000 }, /* R18034 */ - { 0x0000, 0x0000, 0x0000 }, /* R18035 */ - { 0x0000, 0x0000, 0x0000 }, /* R18036 */ - { 0x0000, 0x0000, 0x0000 }, /* R18037 */ - { 0x0000, 0x0000, 0x0000 }, /* R18038 */ - { 0x0000, 0x0000, 0x0000 }, /* R18039 */ - { 0x0000, 0x0000, 0x0000 }, /* R18040 */ - { 0x0000, 0x0000, 0x0000 }, /* R18041 */ - { 0x0000, 0x0000, 0x0000 }, /* R18042 */ - { 0x0000, 0x0000, 0x0000 }, /* R18043 */ - { 0x0000, 0x0000, 0x0000 }, /* R18044 */ - { 0x0000, 0x0000, 0x0000 }, /* R18045 */ - { 0x0000, 0x0000, 0x0000 }, /* R18046 */ - { 0x0000, 0x0000, 0x0000 }, /* R18047 */ - { 0x0000, 0x0000, 0x0000 }, /* R18048 */ - { 0x0000, 0x0000, 0x0000 }, /* R18049 */ - { 0x0000, 0x0000, 0x0000 }, /* R18050 */ - { 0x0000, 0x0000, 0x0000 }, /* R18051 */ - { 0x0000, 0x0000, 0x0000 }, /* R18052 */ - { 0x0000, 0x0000, 0x0000 }, /* R18053 */ - { 0x0000, 0x0000, 0x0000 }, /* R18054 */ - { 0x0000, 0x0000, 0x0000 }, /* R18055 */ - { 0x0000, 0x0000, 0x0000 }, /* R18056 */ - { 0x0000, 0x0000, 0x0000 }, /* R18057 */ - { 0x0000, 0x0000, 0x0000 }, /* R18058 */ - { 0x0000, 0x0000, 0x0000 }, /* R18059 */ - { 0x0000, 0x0000, 0x0000 }, /* R18060 */ - { 0x0000, 0x0000, 0x0000 }, /* R18061 */ - { 0x0000, 0x0000, 0x0000 }, /* R18062 */ - { 0x0000, 0x0000, 0x0000 }, /* R18063 */ - { 0x0000, 0x0000, 0x0000 }, /* R18064 */ - { 0x0000, 0x0000, 0x0000 }, /* R18065 */ - { 0x0000, 0x0000, 0x0000 }, /* R18066 */ - { 0x0000, 0x0000, 0x0000 }, /* R18067 */ - { 0x0000, 0x0000, 0x0000 }, /* R18068 */ - { 0x0000, 0x0000, 0x0000 }, /* R18069 */ - { 0x0000, 0x0000, 0x0000 }, /* R18070 */ - { 0x0000, 0x0000, 0x0000 }, /* R18071 */ - { 0x0000, 0x0000, 0x0000 }, /* R18072 */ - { 0x0000, 0x0000, 0x0000 }, /* R18073 */ - { 0x0000, 0x0000, 0x0000 }, /* R18074 */ - { 0x0000, 0x0000, 0x0000 }, /* R18075 */ - { 0x0000, 0x0000, 0x0000 }, /* R18076 */ - { 0x0000, 0x0000, 0x0000 }, /* R18077 */ - { 0x0000, 0x0000, 0x0000 }, /* R18078 */ - { 0x0000, 0x0000, 0x0000 }, /* R18079 */ - { 0x0000, 0x0000, 0x0000 }, /* R18080 */ - { 0x0000, 0x0000, 0x0000 }, /* R18081 */ - { 0x0000, 0x0000, 0x0000 }, /* R18082 */ - { 0x0000, 0x0000, 0x0000 }, /* R18083 */ - { 0x0000, 0x0000, 0x0000 }, /* R18084 */ - { 0x0000, 0x0000, 0x0000 }, /* R18085 */ - { 0x0000, 0x0000, 0x0000 }, /* R18086 */ - { 0x0000, 0x0000, 0x0000 }, /* R18087 */ - { 0x0000, 0x0000, 0x0000 }, /* R18088 */ - { 0x0000, 0x0000, 0x0000 }, /* R18089 */ - { 0x0000, 0x0000, 0x0000 }, /* R18090 */ - { 0x0000, 0x0000, 0x0000 }, /* R18091 */ - { 0x0000, 0x0000, 0x0000 }, /* R18092 */ - { 0x0000, 0x0000, 0x0000 }, /* R18093 */ - { 0x0000, 0x0000, 0x0000 }, /* R18094 */ - { 0x0000, 0x0000, 0x0000 }, /* R18095 */ - { 0x0000, 0x0000, 0x0000 }, /* R18096 */ - { 0x0000, 0x0000, 0x0000 }, /* R18097 */ - { 0x0000, 0x0000, 0x0000 }, /* R18098 */ - { 0x0000, 0x0000, 0x0000 }, /* R18099 */ - { 0x0000, 0x0000, 0x0000 }, /* R18100 */ - { 0x0000, 0x0000, 0x0000 }, /* R18101 */ - { 0x0000, 0x0000, 0x0000 }, /* R18102 */ - { 0x0000, 0x0000, 0x0000 }, /* R18103 */ - { 0x0000, 0x0000, 0x0000 }, /* R18104 */ - { 0x0000, 0x0000, 0x0000 }, /* R18105 */ - { 0x0000, 0x0000, 0x0000 }, /* R18106 */ - { 0x0000, 0x0000, 0x0000 }, /* R18107 */ - { 0x0000, 0x0000, 0x0000 }, /* R18108 */ - { 0x0000, 0x0000, 0x0000 }, /* R18109 */ - { 0x0000, 0x0000, 0x0000 }, /* R18110 */ - { 0x0000, 0x0000, 0x0000 }, /* R18111 */ - { 0x0000, 0x0000, 0x0000 }, /* R18112 */ - { 0x0000, 0x0000, 0x0000 }, /* R18113 */ - { 0x0000, 0x0000, 0x0000 }, /* R18114 */ - { 0x0000, 0x0000, 0x0000 }, /* R18115 */ - { 0x0000, 0x0000, 0x0000 }, /* R18116 */ - { 0x0000, 0x0000, 0x0000 }, /* R18117 */ - { 0x0000, 0x0000, 0x0000 }, /* R18118 */ - { 0x0000, 0x0000, 0x0000 }, /* R18119 */ - { 0x0000, 0x0000, 0x0000 }, /* R18120 */ - { 0x0000, 0x0000, 0x0000 }, /* R18121 */ - { 0x0000, 0x0000, 0x0000 }, /* R18122 */ - { 0x0000, 0x0000, 0x0000 }, /* R18123 */ - { 0x0000, 0x0000, 0x0000 }, /* R18124 */ - { 0x0000, 0x0000, 0x0000 }, /* R18125 */ - { 0x0000, 0x0000, 0x0000 }, /* R18126 */ - { 0x0000, 0x0000, 0x0000 }, /* R18127 */ - { 0x0000, 0x0000, 0x0000 }, /* R18128 */ - { 0x0000, 0x0000, 0x0000 }, /* R18129 */ - { 0x0000, 0x0000, 0x0000 }, /* R18130 */ - { 0x0000, 0x0000, 0x0000 }, /* R18131 */ - { 0x0000, 0x0000, 0x0000 }, /* R18132 */ - { 0x0000, 0x0000, 0x0000 }, /* R18133 */ - { 0x0000, 0x0000, 0x0000 }, /* R18134 */ - { 0x0000, 0x0000, 0x0000 }, /* R18135 */ - { 0x0000, 0x0000, 0x0000 }, /* R18136 */ - { 0x0000, 0x0000, 0x0000 }, /* R18137 */ - { 0x0000, 0x0000, 0x0000 }, /* R18138 */ - { 0x0000, 0x0000, 0x0000 }, /* R18139 */ - { 0x0000, 0x0000, 0x0000 }, /* R18140 */ - { 0x0000, 0x0000, 0x0000 }, /* R18141 */ - { 0x0000, 0x0000, 0x0000 }, /* R18142 */ - { 0x0000, 0x0000, 0x0000 }, /* R18143 */ - { 0x0000, 0x0000, 0x0000 }, /* R18144 */ - { 0x0000, 0x0000, 0x0000 }, /* R18145 */ - { 0x0000, 0x0000, 0x0000 }, /* R18146 */ - { 0x0000, 0x0000, 0x0000 }, /* R18147 */ - { 0x0000, 0x0000, 0x0000 }, /* R18148 */ - { 0x0000, 0x0000, 0x0000 }, /* R18149 */ - { 0x0000, 0x0000, 0x0000 }, /* R18150 */ - { 0x0000, 0x0000, 0x0000 }, /* R18151 */ - { 0x0000, 0x0000, 0x0000 }, /* R18152 */ - { 0x0000, 0x0000, 0x0000 }, /* R18153 */ - { 0x0000, 0x0000, 0x0000 }, /* R18154 */ - { 0x0000, 0x0000, 0x0000 }, /* R18155 */ - { 0x0000, 0x0000, 0x0000 }, /* R18156 */ - { 0x0000, 0x0000, 0x0000 }, /* R18157 */ - { 0x0000, 0x0000, 0x0000 }, /* R18158 */ - { 0x0000, 0x0000, 0x0000 }, /* R18159 */ - { 0x0000, 0x0000, 0x0000 }, /* R18160 */ - { 0x0000, 0x0000, 0x0000 }, /* R18161 */ - { 0x0000, 0x0000, 0x0000 }, /* R18162 */ - { 0x0000, 0x0000, 0x0000 }, /* R18163 */ - { 0x0000, 0x0000, 0x0000 }, /* R18164 */ - { 0x0000, 0x0000, 0x0000 }, /* R18165 */ - { 0x0000, 0x0000, 0x0000 }, /* R18166 */ - { 0x0000, 0x0000, 0x0000 }, /* R18167 */ - { 0x0000, 0x0000, 0x0000 }, /* R18168 */ - { 0x0000, 0x0000, 0x0000 }, /* R18169 */ - { 0x0000, 0x0000, 0x0000 }, /* R18170 */ - { 0x0000, 0x0000, 0x0000 }, /* R18171 */ - { 0x0000, 0x0000, 0x0000 }, /* R18172 */ - { 0x0000, 0x0000, 0x0000 }, /* R18173 */ - { 0x0000, 0x0000, 0x0000 }, /* R18174 */ - { 0x0000, 0x0000, 0x0000 }, /* R18175 */ - { 0x0000, 0x0000, 0x0000 }, /* R18176 */ - { 0x0000, 0x0000, 0x0000 }, /* R18177 */ - { 0x0000, 0x0000, 0x0000 }, /* R18178 */ - { 0x0000, 0x0000, 0x0000 }, /* R18179 */ - { 0x0000, 0x0000, 0x0000 }, /* R18180 */ - { 0x0000, 0x0000, 0x0000 }, /* R18181 */ - { 0x0000, 0x0000, 0x0000 }, /* R18182 */ - { 0x0000, 0x0000, 0x0000 }, /* R18183 */ - { 0x0000, 0x0000, 0x0000 }, /* R18184 */ - { 0x0000, 0x0000, 0x0000 }, /* R18185 */ - { 0x0000, 0x0000, 0x0000 }, /* R18186 */ - { 0x0000, 0x0000, 0x0000 }, /* R18187 */ - { 0x0000, 0x0000, 0x0000 }, /* R18188 */ - { 0x0000, 0x0000, 0x0000 }, /* R18189 */ - { 0x0000, 0x0000, 0x0000 }, /* R18190 */ - { 0x0000, 0x0000, 0x0000 }, /* R18191 */ - { 0x0000, 0x0000, 0x0000 }, /* R18192 */ - { 0x0000, 0x0000, 0x0000 }, /* R18193 */ - { 0x0000, 0x0000, 0x0000 }, /* R18194 */ - { 0x0000, 0x0000, 0x0000 }, /* R18195 */ - { 0x0000, 0x0000, 0x0000 }, /* R18196 */ - { 0x0000, 0x0000, 0x0000 }, /* R18197 */ - { 0x0000, 0x0000, 0x0000 }, /* R18198 */ - { 0x0000, 0x0000, 0x0000 }, /* R18199 */ - { 0x0000, 0x0000, 0x0000 }, /* R18200 */ - { 0x0000, 0x0000, 0x0000 }, /* R18201 */ - { 0x0000, 0x0000, 0x0000 }, /* R18202 */ - { 0x0000, 0x0000, 0x0000 }, /* R18203 */ - { 0x0000, 0x0000, 0x0000 }, /* R18204 */ - { 0x0000, 0x0000, 0x0000 }, /* R18205 */ - { 0x0000, 0x0000, 0x0000 }, /* R18206 */ - { 0x0000, 0x0000, 0x0000 }, /* R18207 */ - { 0x0000, 0x0000, 0x0000 }, /* R18208 */ - { 0x0000, 0x0000, 0x0000 }, /* R18209 */ - { 0x0000, 0x0000, 0x0000 }, /* R18210 */ - { 0x0000, 0x0000, 0x0000 }, /* R18211 */ - { 0x0000, 0x0000, 0x0000 }, /* R18212 */ - { 0x0000, 0x0000, 0x0000 }, /* R18213 */ - { 0x0000, 0x0000, 0x0000 }, /* R18214 */ - { 0x0000, 0x0000, 0x0000 }, /* R18215 */ - { 0x0000, 0x0000, 0x0000 }, /* R18216 */ - { 0x0000, 0x0000, 0x0000 }, /* R18217 */ - { 0x0000, 0x0000, 0x0000 }, /* R18218 */ - { 0x0000, 0x0000, 0x0000 }, /* R18219 */ - { 0x0000, 0x0000, 0x0000 }, /* R18220 */ - { 0x0000, 0x0000, 0x0000 }, /* R18221 */ - { 0x0000, 0x0000, 0x0000 }, /* R18222 */ - { 0x0000, 0x0000, 0x0000 }, /* R18223 */ - { 0x0000, 0x0000, 0x0000 }, /* R18224 */ - { 0x0000, 0x0000, 0x0000 }, /* R18225 */ - { 0x0000, 0x0000, 0x0000 }, /* R18226 */ - { 0x0000, 0x0000, 0x0000 }, /* R18227 */ - { 0x0000, 0x0000, 0x0000 }, /* R18228 */ - { 0x0000, 0x0000, 0x0000 }, /* R18229 */ - { 0x0000, 0x0000, 0x0000 }, /* R18230 */ - { 0x0000, 0x0000, 0x0000 }, /* R18231 */ - { 0x0000, 0x0000, 0x0000 }, /* R18232 */ - { 0x0000, 0x0000, 0x0000 }, /* R18233 */ - { 0x0000, 0x0000, 0x0000 }, /* R18234 */ - { 0x0000, 0x0000, 0x0000 }, /* R18235 */ - { 0x0000, 0x0000, 0x0000 }, /* R18236 */ - { 0x0000, 0x0000, 0x0000 }, /* R18237 */ - { 0x0000, 0x0000, 0x0000 }, /* R18238 */ - { 0x0000, 0x0000, 0x0000 }, /* R18239 */ - { 0x0000, 0x0000, 0x0000 }, /* R18240 */ - { 0x0000, 0x0000, 0x0000 }, /* R18241 */ - { 0x0000, 0x0000, 0x0000 }, /* R18242 */ - { 0x0000, 0x0000, 0x0000 }, /* R18243 */ - { 0x0000, 0x0000, 0x0000 }, /* R18244 */ - { 0x0000, 0x0000, 0x0000 }, /* R18245 */ - { 0x0000, 0x0000, 0x0000 }, /* R18246 */ - { 0x0000, 0x0000, 0x0000 }, /* R18247 */ - { 0x0000, 0x0000, 0x0000 }, /* R18248 */ - { 0x0000, 0x0000, 0x0000 }, /* R18249 */ - { 0x0000, 0x0000, 0x0000 }, /* R18250 */ - { 0x0000, 0x0000, 0x0000 }, /* R18251 */ - { 0x0000, 0x0000, 0x0000 }, /* R18252 */ - { 0x0000, 0x0000, 0x0000 }, /* R18253 */ - { 0x0000, 0x0000, 0x0000 }, /* R18254 */ - { 0x0000, 0x0000, 0x0000 }, /* R18255 */ - { 0x0000, 0x0000, 0x0000 }, /* R18256 */ - { 0x0000, 0x0000, 0x0000 }, /* R18257 */ - { 0x0000, 0x0000, 0x0000 }, /* R18258 */ - { 0x0000, 0x0000, 0x0000 }, /* R18259 */ - { 0x0000, 0x0000, 0x0000 }, /* R18260 */ - { 0x0000, 0x0000, 0x0000 }, /* R18261 */ - { 0x0000, 0x0000, 0x0000 }, /* R18262 */ - { 0x0000, 0x0000, 0x0000 }, /* R18263 */ - { 0x0000, 0x0000, 0x0000 }, /* R18264 */ - { 0x0000, 0x0000, 0x0000 }, /* R18265 */ - { 0x0000, 0x0000, 0x0000 }, /* R18266 */ - { 0x0000, 0x0000, 0x0000 }, /* R18267 */ - { 0x0000, 0x0000, 0x0000 }, /* R18268 */ - { 0x0000, 0x0000, 0x0000 }, /* R18269 */ - { 0x0000, 0x0000, 0x0000 }, /* R18270 */ - { 0x0000, 0x0000, 0x0000 }, /* R18271 */ - { 0x0000, 0x0000, 0x0000 }, /* R18272 */ - { 0x0000, 0x0000, 0x0000 }, /* R18273 */ - { 0x0000, 0x0000, 0x0000 }, /* R18274 */ - { 0x0000, 0x0000, 0x0000 }, /* R18275 */ - { 0x0000, 0x0000, 0x0000 }, /* R18276 */ - { 0x0000, 0x0000, 0x0000 }, /* R18277 */ - { 0x0000, 0x0000, 0x0000 }, /* R18278 */ - { 0x0000, 0x0000, 0x0000 }, /* R18279 */ - { 0x0000, 0x0000, 0x0000 }, /* R18280 */ - { 0x0000, 0x0000, 0x0000 }, /* R18281 */ - { 0x0000, 0x0000, 0x0000 }, /* R18282 */ - { 0x0000, 0x0000, 0x0000 }, /* R18283 */ - { 0x0000, 0x0000, 0x0000 }, /* R18284 */ - { 0x0000, 0x0000, 0x0000 }, /* R18285 */ - { 0x0000, 0x0000, 0x0000 }, /* R18286 */ - { 0x0000, 0x0000, 0x0000 }, /* R18287 */ - { 0x0000, 0x0000, 0x0000 }, /* R18288 */ - { 0x0000, 0x0000, 0x0000 }, /* R18289 */ - { 0x0000, 0x0000, 0x0000 }, /* R18290 */ - { 0x0000, 0x0000, 0x0000 }, /* R18291 */ - { 0x0000, 0x0000, 0x0000 }, /* R18292 */ - { 0x0000, 0x0000, 0x0000 }, /* R18293 */ - { 0x0000, 0x0000, 0x0000 }, /* R18294 */ - { 0x0000, 0x0000, 0x0000 }, /* R18295 */ - { 0x0000, 0x0000, 0x0000 }, /* R18296 */ - { 0x0000, 0x0000, 0x0000 }, /* R18297 */ - { 0x0000, 0x0000, 0x0000 }, /* R18298 */ - { 0x0000, 0x0000, 0x0000 }, /* R18299 */ - { 0x0000, 0x0000, 0x0000 }, /* R18300 */ - { 0x0000, 0x0000, 0x0000 }, /* R18301 */ - { 0x0000, 0x0000, 0x0000 }, /* R18302 */ - { 0x0000, 0x0000, 0x0000 }, /* R18303 */ - { 0x0000, 0x0000, 0x0000 }, /* R18304 */ - { 0x0000, 0x0000, 0x0000 }, /* R18305 */ - { 0x0000, 0x0000, 0x0000 }, /* R18306 */ - { 0x0000, 0x0000, 0x0000 }, /* R18307 */ - { 0x0000, 0x0000, 0x0000 }, /* R18308 */ - { 0x0000, 0x0000, 0x0000 }, /* R18309 */ - { 0x0000, 0x0000, 0x0000 }, /* R18310 */ - { 0x0000, 0x0000, 0x0000 }, /* R18311 */ - { 0x0000, 0x0000, 0x0000 }, /* R18312 */ - { 0x0000, 0x0000, 0x0000 }, /* R18313 */ - { 0x0000, 0x0000, 0x0000 }, /* R18314 */ - { 0x0000, 0x0000, 0x0000 }, /* R18315 */ - { 0x0000, 0x0000, 0x0000 }, /* R18316 */ - { 0x0000, 0x0000, 0x0000 }, /* R18317 */ - { 0x0000, 0x0000, 0x0000 }, /* R18318 */ - { 0x0000, 0x0000, 0x0000 }, /* R18319 */ - { 0x0000, 0x0000, 0x0000 }, /* R18320 */ - { 0x0000, 0x0000, 0x0000 }, /* R18321 */ - { 0x0000, 0x0000, 0x0000 }, /* R18322 */ - { 0x0000, 0x0000, 0x0000 }, /* R18323 */ - { 0x0000, 0x0000, 0x0000 }, /* R18324 */ - { 0x0000, 0x0000, 0x0000 }, /* R18325 */ - { 0x0000, 0x0000, 0x0000 }, /* R18326 */ - { 0x0000, 0x0000, 0x0000 }, /* R18327 */ - { 0x0000, 0x0000, 0x0000 }, /* R18328 */ - { 0x0000, 0x0000, 0x0000 }, /* R18329 */ - { 0x0000, 0x0000, 0x0000 }, /* R18330 */ - { 0x0000, 0x0000, 0x0000 }, /* R18331 */ - { 0x0000, 0x0000, 0x0000 }, /* R18332 */ - { 0x0000, 0x0000, 0x0000 }, /* R18333 */ - { 0x0000, 0x0000, 0x0000 }, /* R18334 */ - { 0x0000, 0x0000, 0x0000 }, /* R18335 */ - { 0x0000, 0x0000, 0x0000 }, /* R18336 */ - { 0x0000, 0x0000, 0x0000 }, /* R18337 */ - { 0x0000, 0x0000, 0x0000 }, /* R18338 */ - { 0x0000, 0x0000, 0x0000 }, /* R18339 */ - { 0x0000, 0x0000, 0x0000 }, /* R18340 */ - { 0x0000, 0x0000, 0x0000 }, /* R18341 */ - { 0x0000, 0x0000, 0x0000 }, /* R18342 */ - { 0x0000, 0x0000, 0x0000 }, /* R18343 */ - { 0x0000, 0x0000, 0x0000 }, /* R18344 */ - { 0x0000, 0x0000, 0x0000 }, /* R18345 */ - { 0x0000, 0x0000, 0x0000 }, /* R18346 */ - { 0x0000, 0x0000, 0x0000 }, /* R18347 */ - { 0x0000, 0x0000, 0x0000 }, /* R18348 */ - { 0x0000, 0x0000, 0x0000 }, /* R18349 */ - { 0x0000, 0x0000, 0x0000 }, /* R18350 */ - { 0x0000, 0x0000, 0x0000 }, /* R18351 */ - { 0x0000, 0x0000, 0x0000 }, /* R18352 */ - { 0x0000, 0x0000, 0x0000 }, /* R18353 */ - { 0x0000, 0x0000, 0x0000 }, /* R18354 */ - { 0x0000, 0x0000, 0x0000 }, /* R18355 */ - { 0x0000, 0x0000, 0x0000 }, /* R18356 */ - { 0x0000, 0x0000, 0x0000 }, /* R18357 */ - { 0x0000, 0x0000, 0x0000 }, /* R18358 */ - { 0x0000, 0x0000, 0x0000 }, /* R18359 */ - { 0x0000, 0x0000, 0x0000 }, /* R18360 */ - { 0x0000, 0x0000, 0x0000 }, /* R18361 */ - { 0x0000, 0x0000, 0x0000 }, /* R18362 */ - { 0x0000, 0x0000, 0x0000 }, /* R18363 */ - { 0x0000, 0x0000, 0x0000 }, /* R18364 */ - { 0x0000, 0x0000, 0x0000 }, /* R18365 */ - { 0x0000, 0x0000, 0x0000 }, /* R18366 */ - { 0x0000, 0x0000, 0x0000 }, /* R18367 */ - { 0x0000, 0x0000, 0x0000 }, /* R18368 */ - { 0x0000, 0x0000, 0x0000 }, /* R18369 */ - { 0x0000, 0x0000, 0x0000 }, /* R18370 */ - { 0x0000, 0x0000, 0x0000 }, /* R18371 */ - { 0x0000, 0x0000, 0x0000 }, /* R18372 */ - { 0x0000, 0x0000, 0x0000 }, /* R18373 */ - { 0x0000, 0x0000, 0x0000 }, /* R18374 */ - { 0x0000, 0x0000, 0x0000 }, /* R18375 */ - { 0x0000, 0x0000, 0x0000 }, /* R18376 */ - { 0x0000, 0x0000, 0x0000 }, /* R18377 */ - { 0x0000, 0x0000, 0x0000 }, /* R18378 */ - { 0x0000, 0x0000, 0x0000 }, /* R18379 */ - { 0x0000, 0x0000, 0x0000 }, /* R18380 */ - { 0x0000, 0x0000, 0x0000 }, /* R18381 */ - { 0x0000, 0x0000, 0x0000 }, /* R18382 */ - { 0x0000, 0x0000, 0x0000 }, /* R18383 */ - { 0x0000, 0x0000, 0x0000 }, /* R18384 */ - { 0x0000, 0x0000, 0x0000 }, /* R18385 */ - { 0x0000, 0x0000, 0x0000 }, /* R18386 */ - { 0x0000, 0x0000, 0x0000 }, /* R18387 */ - { 0x0000, 0x0000, 0x0000 }, /* R18388 */ - { 0x0000, 0x0000, 0x0000 }, /* R18389 */ - { 0x0000, 0x0000, 0x0000 }, /* R18390 */ - { 0x0000, 0x0000, 0x0000 }, /* R18391 */ - { 0x0000, 0x0000, 0x0000 }, /* R18392 */ - { 0x0000, 0x0000, 0x0000 }, /* R18393 */ - { 0x0000, 0x0000, 0x0000 }, /* R18394 */ - { 0x0000, 0x0000, 0x0000 }, /* R18395 */ - { 0x0000, 0x0000, 0x0000 }, /* R18396 */ - { 0x0000, 0x0000, 0x0000 }, /* R18397 */ - { 0x0000, 0x0000, 0x0000 }, /* R18398 */ - { 0x0000, 0x0000, 0x0000 }, /* R18399 */ - { 0x0000, 0x0000, 0x0000 }, /* R18400 */ - { 0x0000, 0x0000, 0x0000 }, /* R18401 */ - { 0x0000, 0x0000, 0x0000 }, /* R18402 */ - { 0x0000, 0x0000, 0x0000 }, /* R18403 */ - { 0x0000, 0x0000, 0x0000 }, /* R18404 */ - { 0x0000, 0x0000, 0x0000 }, /* R18405 */ - { 0x0000, 0x0000, 0x0000 }, /* R18406 */ - { 0x0000, 0x0000, 0x0000 }, /* R18407 */ - { 0x0000, 0x0000, 0x0000 }, /* R18408 */ - { 0x0000, 0x0000, 0x0000 }, /* R18409 */ - { 0x0000, 0x0000, 0x0000 }, /* R18410 */ - { 0x0000, 0x0000, 0x0000 }, /* R18411 */ - { 0x0000, 0x0000, 0x0000 }, /* R18412 */ - { 0x0000, 0x0000, 0x0000 }, /* R18413 */ - { 0x0000, 0x0000, 0x0000 }, /* R18414 */ - { 0x0000, 0x0000, 0x0000 }, /* R18415 */ - { 0x0000, 0x0000, 0x0000 }, /* R18416 */ - { 0x0000, 0x0000, 0x0000 }, /* R18417 */ - { 0x0000, 0x0000, 0x0000 }, /* R18418 */ - { 0x0000, 0x0000, 0x0000 }, /* R18419 */ - { 0x0000, 0x0000, 0x0000 }, /* R18420 */ - { 0x0000, 0x0000, 0x0000 }, /* R18421 */ - { 0x0000, 0x0000, 0x0000 }, /* R18422 */ - { 0x0000, 0x0000, 0x0000 }, /* R18423 */ - { 0x0000, 0x0000, 0x0000 }, /* R18424 */ - { 0x0000, 0x0000, 0x0000 }, /* R18425 */ - { 0x0000, 0x0000, 0x0000 }, /* R18426 */ - { 0x0000, 0x0000, 0x0000 }, /* R18427 */ - { 0x0000, 0x0000, 0x0000 }, /* R18428 */ - { 0x0000, 0x0000, 0x0000 }, /* R18429 */ - { 0x0000, 0x0000, 0x0000 }, /* R18430 */ - { 0x0000, 0x0000, 0x0000 }, /* R18431 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18432 - RETUNEADC_PG2_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18433 - RETUNEADC_PG2_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18434 - RETUNEADC_PG_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18435 - RETUNEADC_PG_0 */ - { 0x0000, 0x0000, 0x0000 }, /* R18436 */ - { 0x0000, 0x0000, 0x0000 }, /* R18437 */ - { 0x0000, 0x0000, 0x0000 }, /* R18438 */ - { 0x0000, 0x0000, 0x0000 }, /* R18439 */ - { 0x0000, 0x0000, 0x0000 }, /* R18440 */ - { 0x0000, 0x0000, 0x0000 }, /* R18441 */ - { 0x0000, 0x0000, 0x0000 }, /* R18442 */ - { 0x0000, 0x0000, 0x0000 }, /* R18443 */ - { 0x0000, 0x0000, 0x0000 }, /* R18444 */ - { 0x0000, 0x0000, 0x0000 }, /* R18445 */ - { 0x0000, 0x0000, 0x0000 }, /* R18446 */ - { 0x0000, 0x0000, 0x0000 }, /* R18447 */ - { 0x0000, 0x0000, 0x0000 }, /* R18448 */ - { 0x0000, 0x0000, 0x0000 }, /* R18449 */ - { 0x0000, 0x0000, 0x0000 }, /* R18450 */ - { 0x0000, 0x0000, 0x0000 }, /* R18451 */ - { 0x0000, 0x0000, 0x0000 }, /* R18452 */ - { 0x0000, 0x0000, 0x0000 }, /* R18453 */ - { 0x0000, 0x0000, 0x0000 }, /* R18454 */ - { 0x0000, 0x0000, 0x0000 }, /* R18455 */ - { 0x0000, 0x0000, 0x0000 }, /* R18456 */ - { 0x0000, 0x0000, 0x0000 }, /* R18457 */ - { 0x0000, 0x0000, 0x0000 }, /* R18458 */ - { 0x0000, 0x0000, 0x0000 }, /* R18459 */ - { 0x0000, 0x0000, 0x0000 }, /* R18460 */ - { 0x0000, 0x0000, 0x0000 }, /* R18461 */ - { 0x0000, 0x0000, 0x0000 }, /* R18462 */ - { 0x0000, 0x0000, 0x0000 }, /* R18463 */ - { 0x0000, 0x0000, 0x0000 }, /* R18464 */ - { 0x0000, 0x0000, 0x0000 }, /* R18465 */ - { 0x0000, 0x0000, 0x0000 }, /* R18466 */ - { 0x0000, 0x0000, 0x0000 }, /* R18467 */ - { 0x0000, 0x0000, 0x0000 }, /* R18468 */ - { 0x0000, 0x0000, 0x0000 }, /* R18469 */ - { 0x0000, 0x0000, 0x0000 }, /* R18470 */ - { 0x0000, 0x0000, 0x0000 }, /* R18471 */ - { 0x0000, 0x0000, 0x0000 }, /* R18472 */ - { 0x0000, 0x0000, 0x0000 }, /* R18473 */ - { 0x0000, 0x0000, 0x0000 }, /* R18474 */ - { 0x0000, 0x0000, 0x0000 }, /* R18475 */ - { 0x0000, 0x0000, 0x0000 }, /* R18476 */ - { 0x0000, 0x0000, 0x0000 }, /* R18477 */ - { 0x0000, 0x0000, 0x0000 }, /* R18478 */ - { 0x0000, 0x0000, 0x0000 }, /* R18479 */ - { 0x0000, 0x0000, 0x0000 }, /* R18480 */ - { 0x0000, 0x0000, 0x0000 }, /* R18481 */ - { 0x0000, 0x0000, 0x0000 }, /* R18482 */ - { 0x0000, 0x0000, 0x0000 }, /* R18483 */ - { 0x0000, 0x0000, 0x0000 }, /* R18484 */ - { 0x0000, 0x0000, 0x0000 }, /* R18485 */ - { 0x0000, 0x0000, 0x0000 }, /* R18486 */ - { 0x0000, 0x0000, 0x0000 }, /* R18487 */ - { 0x0000, 0x0000, 0x0000 }, /* R18488 */ - { 0x0000, 0x0000, 0x0000 }, /* R18489 */ - { 0x0000, 0x0000, 0x0000 }, /* R18490 */ - { 0x0000, 0x0000, 0x0000 }, /* R18491 */ - { 0x0000, 0x0000, 0x0000 }, /* R18492 */ - { 0x0000, 0x0000, 0x0000 }, /* R18493 */ - { 0x0000, 0x0000, 0x0000 }, /* R18494 */ - { 0x0000, 0x0000, 0x0000 }, /* R18495 */ - { 0x0000, 0x0000, 0x0000 }, /* R18496 */ - { 0x0000, 0x0000, 0x0000 }, /* R18497 */ - { 0x0000, 0x0000, 0x0000 }, /* R18498 */ - { 0x0000, 0x0000, 0x0000 }, /* R18499 */ - { 0x0000, 0x0000, 0x0000 }, /* R18500 */ - { 0x0000, 0x0000, 0x0000 }, /* R18501 */ - { 0x0000, 0x0000, 0x0000 }, /* R18502 */ - { 0x0000, 0x0000, 0x0000 }, /* R18503 */ - { 0x0000, 0x0000, 0x0000 }, /* R18504 */ - { 0x0000, 0x0000, 0x0000 }, /* R18505 */ - { 0x0000, 0x0000, 0x0000 }, /* R18506 */ - { 0x0000, 0x0000, 0x0000 }, /* R18507 */ - { 0x0000, 0x0000, 0x0000 }, /* R18508 */ - { 0x0000, 0x0000, 0x0000 }, /* R18509 */ - { 0x0000, 0x0000, 0x0000 }, /* R18510 */ - { 0x0000, 0x0000, 0x0000 }, /* R18511 */ - { 0x0000, 0x0000, 0x0000 }, /* R18512 */ - { 0x0000, 0x0000, 0x0000 }, /* R18513 */ - { 0x0000, 0x0000, 0x0000 }, /* R18514 */ - { 0x0000, 0x0000, 0x0000 }, /* R18515 */ - { 0x0000, 0x0000, 0x0000 }, /* R18516 */ - { 0x0000, 0x0000, 0x0000 }, /* R18517 */ - { 0x0000, 0x0000, 0x0000 }, /* R18518 */ - { 0x0000, 0x0000, 0x0000 }, /* R18519 */ - { 0x0000, 0x0000, 0x0000 }, /* R18520 */ - { 0x0000, 0x0000, 0x0000 }, /* R18521 */ - { 0x0000, 0x0000, 0x0000 }, /* R18522 */ - { 0x0000, 0x0000, 0x0000 }, /* R18523 */ - { 0x0000, 0x0000, 0x0000 }, /* R18524 */ - { 0x0000, 0x0000, 0x0000 }, /* R18525 */ - { 0x0000, 0x0000, 0x0000 }, /* R18526 */ - { 0x0000, 0x0000, 0x0000 }, /* R18527 */ - { 0x0000, 0x0000, 0x0000 }, /* R18528 */ - { 0x0000, 0x0000, 0x0000 }, /* R18529 */ - { 0x0000, 0x0000, 0x0000 }, /* R18530 */ - { 0x0000, 0x0000, 0x0000 }, /* R18531 */ - { 0x0000, 0x0000, 0x0000 }, /* R18532 */ - { 0x0000, 0x0000, 0x0000 }, /* R18533 */ - { 0x0000, 0x0000, 0x0000 }, /* R18534 */ - { 0x0000, 0x0000, 0x0000 }, /* R18535 */ - { 0x0000, 0x0000, 0x0000 }, /* R18536 */ - { 0x0000, 0x0000, 0x0000 }, /* R18537 */ - { 0x0000, 0x0000, 0x0000 }, /* R18538 */ - { 0x0000, 0x0000, 0x0000 }, /* R18539 */ - { 0x0000, 0x0000, 0x0000 }, /* R18540 */ - { 0x0000, 0x0000, 0x0000 }, /* R18541 */ - { 0x0000, 0x0000, 0x0000 }, /* R18542 */ - { 0x0000, 0x0000, 0x0000 }, /* R18543 */ - { 0x0000, 0x0000, 0x0000 }, /* R18544 */ - { 0x0000, 0x0000, 0x0000 }, /* R18545 */ - { 0x0000, 0x0000, 0x0000 }, /* R18546 */ - { 0x0000, 0x0000, 0x0000 }, /* R18547 */ - { 0x0000, 0x0000, 0x0000 }, /* R18548 */ - { 0x0000, 0x0000, 0x0000 }, /* R18549 */ - { 0x0000, 0x0000, 0x0000 }, /* R18550 */ - { 0x0000, 0x0000, 0x0000 }, /* R18551 */ - { 0x0000, 0x0000, 0x0000 }, /* R18552 */ - { 0x0000, 0x0000, 0x0000 }, /* R18553 */ - { 0x0000, 0x0000, 0x0000 }, /* R18554 */ - { 0x0000, 0x0000, 0x0000 }, /* R18555 */ - { 0x0000, 0x0000, 0x0000 }, /* R18556 */ - { 0x0000, 0x0000, 0x0000 }, /* R18557 */ - { 0x0000, 0x0000, 0x0000 }, /* R18558 */ - { 0x0000, 0x0000, 0x0000 }, /* R18559 */ - { 0x0000, 0x0000, 0x0000 }, /* R18560 */ - { 0x0000, 0x0000, 0x0000 }, /* R18561 */ - { 0x0000, 0x0000, 0x0000 }, /* R18562 */ - { 0x0000, 0x0000, 0x0000 }, /* R18563 */ - { 0x0000, 0x0000, 0x0000 }, /* R18564 */ - { 0x0000, 0x0000, 0x0000 }, /* R18565 */ - { 0x0000, 0x0000, 0x0000 }, /* R18566 */ - { 0x0000, 0x0000, 0x0000 }, /* R18567 */ - { 0x0000, 0x0000, 0x0000 }, /* R18568 */ - { 0x0000, 0x0000, 0x0000 }, /* R18569 */ - { 0x0000, 0x0000, 0x0000 }, /* R18570 */ - { 0x0000, 0x0000, 0x0000 }, /* R18571 */ - { 0x0000, 0x0000, 0x0000 }, /* R18572 */ - { 0x0000, 0x0000, 0x0000 }, /* R18573 */ - { 0x0000, 0x0000, 0x0000 }, /* R18574 */ - { 0x0000, 0x0000, 0x0000 }, /* R18575 */ - { 0x0000, 0x0000, 0x0000 }, /* R18576 */ - { 0x0000, 0x0000, 0x0000 }, /* R18577 */ - { 0x0000, 0x0000, 0x0000 }, /* R18578 */ - { 0x0000, 0x0000, 0x0000 }, /* R18579 */ - { 0x0000, 0x0000, 0x0000 }, /* R18580 */ - { 0x0000, 0x0000, 0x0000 }, /* R18581 */ - { 0x0000, 0x0000, 0x0000 }, /* R18582 */ - { 0x0000, 0x0000, 0x0000 }, /* R18583 */ - { 0x0000, 0x0000, 0x0000 }, /* R18584 */ - { 0x0000, 0x0000, 0x0000 }, /* R18585 */ - { 0x0000, 0x0000, 0x0000 }, /* R18586 */ - { 0x0000, 0x0000, 0x0000 }, /* R18587 */ - { 0x0000, 0x0000, 0x0000 }, /* R18588 */ - { 0x0000, 0x0000, 0x0000 }, /* R18589 */ - { 0x0000, 0x0000, 0x0000 }, /* R18590 */ - { 0x0000, 0x0000, 0x0000 }, /* R18591 */ - { 0x0000, 0x0000, 0x0000 }, /* R18592 */ - { 0x0000, 0x0000, 0x0000 }, /* R18593 */ - { 0x0000, 0x0000, 0x0000 }, /* R18594 */ - { 0x0000, 0x0000, 0x0000 }, /* R18595 */ - { 0x0000, 0x0000, 0x0000 }, /* R18596 */ - { 0x0000, 0x0000, 0x0000 }, /* R18597 */ - { 0x0000, 0x0000, 0x0000 }, /* R18598 */ - { 0x0000, 0x0000, 0x0000 }, /* R18599 */ - { 0x0000, 0x0000, 0x0000 }, /* R18600 */ - { 0x0000, 0x0000, 0x0000 }, /* R18601 */ - { 0x0000, 0x0000, 0x0000 }, /* R18602 */ - { 0x0000, 0x0000, 0x0000 }, /* R18603 */ - { 0x0000, 0x0000, 0x0000 }, /* R18604 */ - { 0x0000, 0x0000, 0x0000 }, /* R18605 */ - { 0x0000, 0x0000, 0x0000 }, /* R18606 */ - { 0x0000, 0x0000, 0x0000 }, /* R18607 */ - { 0x0000, 0x0000, 0x0000 }, /* R18608 */ - { 0x0000, 0x0000, 0x0000 }, /* R18609 */ - { 0x0000, 0x0000, 0x0000 }, /* R18610 */ - { 0x0000, 0x0000, 0x0000 }, /* R18611 */ - { 0x0000, 0x0000, 0x0000 }, /* R18612 */ - { 0x0000, 0x0000, 0x0000 }, /* R18613 */ - { 0x0000, 0x0000, 0x0000 }, /* R18614 */ - { 0x0000, 0x0000, 0x0000 }, /* R18615 */ - { 0x0000, 0x0000, 0x0000 }, /* R18616 */ - { 0x0000, 0x0000, 0x0000 }, /* R18617 */ - { 0x0000, 0x0000, 0x0000 }, /* R18618 */ - { 0x0000, 0x0000, 0x0000 }, /* R18619 */ - { 0x0000, 0x0000, 0x0000 }, /* R18620 */ - { 0x0000, 0x0000, 0x0000 }, /* R18621 */ - { 0x0000, 0x0000, 0x0000 }, /* R18622 */ - { 0x0000, 0x0000, 0x0000 }, /* R18623 */ - { 0x0000, 0x0000, 0x0000 }, /* R18624 */ - { 0x0000, 0x0000, 0x0000 }, /* R18625 */ - { 0x0000, 0x0000, 0x0000 }, /* R18626 */ - { 0x0000, 0x0000, 0x0000 }, /* R18627 */ - { 0x0000, 0x0000, 0x0000 }, /* R18628 */ - { 0x0000, 0x0000, 0x0000 }, /* R18629 */ - { 0x0000, 0x0000, 0x0000 }, /* R18630 */ - { 0x0000, 0x0000, 0x0000 }, /* R18631 */ - { 0x0000, 0x0000, 0x0000 }, /* R18632 */ - { 0x0000, 0x0000, 0x0000 }, /* R18633 */ - { 0x0000, 0x0000, 0x0000 }, /* R18634 */ - { 0x0000, 0x0000, 0x0000 }, /* R18635 */ - { 0x0000, 0x0000, 0x0000 }, /* R18636 */ - { 0x0000, 0x0000, 0x0000 }, /* R18637 */ - { 0x0000, 0x0000, 0x0000 }, /* R18638 */ - { 0x0000, 0x0000, 0x0000 }, /* R18639 */ - { 0x0000, 0x0000, 0x0000 }, /* R18640 */ - { 0x0000, 0x0000, 0x0000 }, /* R18641 */ - { 0x0000, 0x0000, 0x0000 }, /* R18642 */ - { 0x0000, 0x0000, 0x0000 }, /* R18643 */ - { 0x0000, 0x0000, 0x0000 }, /* R18644 */ - { 0x0000, 0x0000, 0x0000 }, /* R18645 */ - { 0x0000, 0x0000, 0x0000 }, /* R18646 */ - { 0x0000, 0x0000, 0x0000 }, /* R18647 */ - { 0x0000, 0x0000, 0x0000 }, /* R18648 */ - { 0x0000, 0x0000, 0x0000 }, /* R18649 */ - { 0x0000, 0x0000, 0x0000 }, /* R18650 */ - { 0x0000, 0x0000, 0x0000 }, /* R18651 */ - { 0x0000, 0x0000, 0x0000 }, /* R18652 */ - { 0x0000, 0x0000, 0x0000 }, /* R18653 */ - { 0x0000, 0x0000, 0x0000 }, /* R18654 */ - { 0x0000, 0x0000, 0x0000 }, /* R18655 */ - { 0x0000, 0x0000, 0x0000 }, /* R18656 */ - { 0x0000, 0x0000, 0x0000 }, /* R18657 */ - { 0x0000, 0x0000, 0x0000 }, /* R18658 */ - { 0x0000, 0x0000, 0x0000 }, /* R18659 */ - { 0x0000, 0x0000, 0x0000 }, /* R18660 */ - { 0x0000, 0x0000, 0x0000 }, /* R18661 */ - { 0x0000, 0x0000, 0x0000 }, /* R18662 */ - { 0x0000, 0x0000, 0x0000 }, /* R18663 */ - { 0x0000, 0x0000, 0x0000 }, /* R18664 */ - { 0x0000, 0x0000, 0x0000 }, /* R18665 */ - { 0x0000, 0x0000, 0x0000 }, /* R18666 */ - { 0x0000, 0x0000, 0x0000 }, /* R18667 */ - { 0x0000, 0x0000, 0x0000 }, /* R18668 */ - { 0x0000, 0x0000, 0x0000 }, /* R18669 */ - { 0x0000, 0x0000, 0x0000 }, /* R18670 */ - { 0x0000, 0x0000, 0x0000 }, /* R18671 */ - { 0x0000, 0x0000, 0x0000 }, /* R18672 */ - { 0x0000, 0x0000, 0x0000 }, /* R18673 */ - { 0x0000, 0x0000, 0x0000 }, /* R18674 */ - { 0x0000, 0x0000, 0x0000 }, /* R18675 */ - { 0x0000, 0x0000, 0x0000 }, /* R18676 */ - { 0x0000, 0x0000, 0x0000 }, /* R18677 */ - { 0x0000, 0x0000, 0x0000 }, /* R18678 */ - { 0x0000, 0x0000, 0x0000 }, /* R18679 */ - { 0x0000, 0x0000, 0x0000 }, /* R18680 */ - { 0x0000, 0x0000, 0x0000 }, /* R18681 */ - { 0x0000, 0x0000, 0x0000 }, /* R18682 */ - { 0x0000, 0x0000, 0x0000 }, /* R18683 */ - { 0x0000, 0x0000, 0x0000 }, /* R18684 */ - { 0x0000, 0x0000, 0x0000 }, /* R18685 */ - { 0x0000, 0x0000, 0x0000 }, /* R18686 */ - { 0x0000, 0x0000, 0x0000 }, /* R18687 */ - { 0x0000, 0x0000, 0x0000 }, /* R18688 */ - { 0x0000, 0x0000, 0x0000 }, /* R18689 */ - { 0x0000, 0x0000, 0x0000 }, /* R18690 */ - { 0x0000, 0x0000, 0x0000 }, /* R18691 */ - { 0x0000, 0x0000, 0x0000 }, /* R18692 */ - { 0x0000, 0x0000, 0x0000 }, /* R18693 */ - { 0x0000, 0x0000, 0x0000 }, /* R18694 */ - { 0x0000, 0x0000, 0x0000 }, /* R18695 */ - { 0x0000, 0x0000, 0x0000 }, /* R18696 */ - { 0x0000, 0x0000, 0x0000 }, /* R18697 */ - { 0x0000, 0x0000, 0x0000 }, /* R18698 */ - { 0x0000, 0x0000, 0x0000 }, /* R18699 */ - { 0x0000, 0x0000, 0x0000 }, /* R18700 */ - { 0x0000, 0x0000, 0x0000 }, /* R18701 */ - { 0x0000, 0x0000, 0x0000 }, /* R18702 */ - { 0x0000, 0x0000, 0x0000 }, /* R18703 */ - { 0x0000, 0x0000, 0x0000 }, /* R18704 */ - { 0x0000, 0x0000, 0x0000 }, /* R18705 */ - { 0x0000, 0x0000, 0x0000 }, /* R18706 */ - { 0x0000, 0x0000, 0x0000 }, /* R18707 */ - { 0x0000, 0x0000, 0x0000 }, /* R18708 */ - { 0x0000, 0x0000, 0x0000 }, /* R18709 */ - { 0x0000, 0x0000, 0x0000 }, /* R18710 */ - { 0x0000, 0x0000, 0x0000 }, /* R18711 */ - { 0x0000, 0x0000, 0x0000 }, /* R18712 */ - { 0x0000, 0x0000, 0x0000 }, /* R18713 */ - { 0x0000, 0x0000, 0x0000 }, /* R18714 */ - { 0x0000, 0x0000, 0x0000 }, /* R18715 */ - { 0x0000, 0x0000, 0x0000 }, /* R18716 */ - { 0x0000, 0x0000, 0x0000 }, /* R18717 */ - { 0x0000, 0x0000, 0x0000 }, /* R18718 */ - { 0x0000, 0x0000, 0x0000 }, /* R18719 */ - { 0x0000, 0x0000, 0x0000 }, /* R18720 */ - { 0x0000, 0x0000, 0x0000 }, /* R18721 */ - { 0x0000, 0x0000, 0x0000 }, /* R18722 */ - { 0x0000, 0x0000, 0x0000 }, /* R18723 */ - { 0x0000, 0x0000, 0x0000 }, /* R18724 */ - { 0x0000, 0x0000, 0x0000 }, /* R18725 */ - { 0x0000, 0x0000, 0x0000 }, /* R18726 */ - { 0x0000, 0x0000, 0x0000 }, /* R18727 */ - { 0x0000, 0x0000, 0x0000 }, /* R18728 */ - { 0x0000, 0x0000, 0x0000 }, /* R18729 */ - { 0x0000, 0x0000, 0x0000 }, /* R18730 */ - { 0x0000, 0x0000, 0x0000 }, /* R18731 */ - { 0x0000, 0x0000, 0x0000 }, /* R18732 */ - { 0x0000, 0x0000, 0x0000 }, /* R18733 */ - { 0x0000, 0x0000, 0x0000 }, /* R18734 */ - { 0x0000, 0x0000, 0x0000 }, /* R18735 */ - { 0x0000, 0x0000, 0x0000 }, /* R18736 */ - { 0x0000, 0x0000, 0x0000 }, /* R18737 */ - { 0x0000, 0x0000, 0x0000 }, /* R18738 */ - { 0x0000, 0x0000, 0x0000 }, /* R18739 */ - { 0x0000, 0x0000, 0x0000 }, /* R18740 */ - { 0x0000, 0x0000, 0x0000 }, /* R18741 */ - { 0x0000, 0x0000, 0x0000 }, /* R18742 */ - { 0x0000, 0x0000, 0x0000 }, /* R18743 */ - { 0x0000, 0x0000, 0x0000 }, /* R18744 */ - { 0x0000, 0x0000, 0x0000 }, /* R18745 */ - { 0x0000, 0x0000, 0x0000 }, /* R18746 */ - { 0x0000, 0x0000, 0x0000 }, /* R18747 */ - { 0x0000, 0x0000, 0x0000 }, /* R18748 */ - { 0x0000, 0x0000, 0x0000 }, /* R18749 */ - { 0x0000, 0x0000, 0x0000 }, /* R18750 */ - { 0x0000, 0x0000, 0x0000 }, /* R18751 */ - { 0x0000, 0x0000, 0x0000 }, /* R18752 */ - { 0x0000, 0x0000, 0x0000 }, /* R18753 */ - { 0x0000, 0x0000, 0x0000 }, /* R18754 */ - { 0x0000, 0x0000, 0x0000 }, /* R18755 */ - { 0x0000, 0x0000, 0x0000 }, /* R18756 */ - { 0x0000, 0x0000, 0x0000 }, /* R18757 */ - { 0x0000, 0x0000, 0x0000 }, /* R18758 */ - { 0x0000, 0x0000, 0x0000 }, /* R18759 */ - { 0x0000, 0x0000, 0x0000 }, /* R18760 */ - { 0x0000, 0x0000, 0x0000 }, /* R18761 */ - { 0x0000, 0x0000, 0x0000 }, /* R18762 */ - { 0x0000, 0x0000, 0x0000 }, /* R18763 */ - { 0x0000, 0x0000, 0x0000 }, /* R18764 */ - { 0x0000, 0x0000, 0x0000 }, /* R18765 */ - { 0x0000, 0x0000, 0x0000 }, /* R18766 */ - { 0x0000, 0x0000, 0x0000 }, /* R18767 */ - { 0x0000, 0x0000, 0x0000 }, /* R18768 */ - { 0x0000, 0x0000, 0x0000 }, /* R18769 */ - { 0x0000, 0x0000, 0x0000 }, /* R18770 */ - { 0x0000, 0x0000, 0x0000 }, /* R18771 */ - { 0x0000, 0x0000, 0x0000 }, /* R18772 */ - { 0x0000, 0x0000, 0x0000 }, /* R18773 */ - { 0x0000, 0x0000, 0x0000 }, /* R18774 */ - { 0x0000, 0x0000, 0x0000 }, /* R18775 */ - { 0x0000, 0x0000, 0x0000 }, /* R18776 */ - { 0x0000, 0x0000, 0x0000 }, /* R18777 */ - { 0x0000, 0x0000, 0x0000 }, /* R18778 */ - { 0x0000, 0x0000, 0x0000 }, /* R18779 */ - { 0x0000, 0x0000, 0x0000 }, /* R18780 */ - { 0x0000, 0x0000, 0x0000 }, /* R18781 */ - { 0x0000, 0x0000, 0x0000 }, /* R18782 */ - { 0x0000, 0x0000, 0x0000 }, /* R18783 */ - { 0x0000, 0x0000, 0x0000 }, /* R18784 */ - { 0x0000, 0x0000, 0x0000 }, /* R18785 */ - { 0x0000, 0x0000, 0x0000 }, /* R18786 */ - { 0x0000, 0x0000, 0x0000 }, /* R18787 */ - { 0x0000, 0x0000, 0x0000 }, /* R18788 */ - { 0x0000, 0x0000, 0x0000 }, /* R18789 */ - { 0x0000, 0x0000, 0x0000 }, /* R18790 */ - { 0x0000, 0x0000, 0x0000 }, /* R18791 */ - { 0x0000, 0x0000, 0x0000 }, /* R18792 */ - { 0x0000, 0x0000, 0x0000 }, /* R18793 */ - { 0x0000, 0x0000, 0x0000 }, /* R18794 */ - { 0x0000, 0x0000, 0x0000 }, /* R18795 */ - { 0x0000, 0x0000, 0x0000 }, /* R18796 */ - { 0x0000, 0x0000, 0x0000 }, /* R18797 */ - { 0x0000, 0x0000, 0x0000 }, /* R18798 */ - { 0x0000, 0x0000, 0x0000 }, /* R18799 */ - { 0x0000, 0x0000, 0x0000 }, /* R18800 */ - { 0x0000, 0x0000, 0x0000 }, /* R18801 */ - { 0x0000, 0x0000, 0x0000 }, /* R18802 */ - { 0x0000, 0x0000, 0x0000 }, /* R18803 */ - { 0x0000, 0x0000, 0x0000 }, /* R18804 */ - { 0x0000, 0x0000, 0x0000 }, /* R18805 */ - { 0x0000, 0x0000, 0x0000 }, /* R18806 */ - { 0x0000, 0x0000, 0x0000 }, /* R18807 */ - { 0x0000, 0x0000, 0x0000 }, /* R18808 */ - { 0x0000, 0x0000, 0x0000 }, /* R18809 */ - { 0x0000, 0x0000, 0x0000 }, /* R18810 */ - { 0x0000, 0x0000, 0x0000 }, /* R18811 */ - { 0x0000, 0x0000, 0x0000 }, /* R18812 */ - { 0x0000, 0x0000, 0x0000 }, /* R18813 */ - { 0x0000, 0x0000, 0x0000 }, /* R18814 */ - { 0x0000, 0x0000, 0x0000 }, /* R18815 */ - { 0x0000, 0x0000, 0x0000 }, /* R18816 */ - { 0x0000, 0x0000, 0x0000 }, /* R18817 */ - { 0x0000, 0x0000, 0x0000 }, /* R18818 */ - { 0x0000, 0x0000, 0x0000 }, /* R18819 */ - { 0x0000, 0x0000, 0x0000 }, /* R18820 */ - { 0x0000, 0x0000, 0x0000 }, /* R18821 */ - { 0x0000, 0x0000, 0x0000 }, /* R18822 */ - { 0x0000, 0x0000, 0x0000 }, /* R18823 */ - { 0x0000, 0x0000, 0x0000 }, /* R18824 */ - { 0x0000, 0x0000, 0x0000 }, /* R18825 */ - { 0x0000, 0x0000, 0x0000 }, /* R18826 */ - { 0x0000, 0x0000, 0x0000 }, /* R18827 */ - { 0x0000, 0x0000, 0x0000 }, /* R18828 */ - { 0x0000, 0x0000, 0x0000 }, /* R18829 */ - { 0x0000, 0x0000, 0x0000 }, /* R18830 */ - { 0x0000, 0x0000, 0x0000 }, /* R18831 */ - { 0x0000, 0x0000, 0x0000 }, /* R18832 */ - { 0x0000, 0x0000, 0x0000 }, /* R18833 */ - { 0x0000, 0x0000, 0x0000 }, /* R18834 */ - { 0x0000, 0x0000, 0x0000 }, /* R18835 */ - { 0x0000, 0x0000, 0x0000 }, /* R18836 */ - { 0x0000, 0x0000, 0x0000 }, /* R18837 */ - { 0x0000, 0x0000, 0x0000 }, /* R18838 */ - { 0x0000, 0x0000, 0x0000 }, /* R18839 */ - { 0x0000, 0x0000, 0x0000 }, /* R18840 */ - { 0x0000, 0x0000, 0x0000 }, /* R18841 */ - { 0x0000, 0x0000, 0x0000 }, /* R18842 */ - { 0x0000, 0x0000, 0x0000 }, /* R18843 */ - { 0x0000, 0x0000, 0x0000 }, /* R18844 */ - { 0x0000, 0x0000, 0x0000 }, /* R18845 */ - { 0x0000, 0x0000, 0x0000 }, /* R18846 */ - { 0x0000, 0x0000, 0x0000 }, /* R18847 */ - { 0x0000, 0x0000, 0x0000 }, /* R18848 */ - { 0x0000, 0x0000, 0x0000 }, /* R18849 */ - { 0x0000, 0x0000, 0x0000 }, /* R18850 */ - { 0x0000, 0x0000, 0x0000 }, /* R18851 */ - { 0x0000, 0x0000, 0x0000 }, /* R18852 */ - { 0x0000, 0x0000, 0x0000 }, /* R18853 */ - { 0x0000, 0x0000, 0x0000 }, /* R18854 */ - { 0x0000, 0x0000, 0x0000 }, /* R18855 */ - { 0x0000, 0x0000, 0x0000 }, /* R18856 */ - { 0x0000, 0x0000, 0x0000 }, /* R18857 */ - { 0x0000, 0x0000, 0x0000 }, /* R18858 */ - { 0x0000, 0x0000, 0x0000 }, /* R18859 */ - { 0x0000, 0x0000, 0x0000 }, /* R18860 */ - { 0x0000, 0x0000, 0x0000 }, /* R18861 */ - { 0x0000, 0x0000, 0x0000 }, /* R18862 */ - { 0x0000, 0x0000, 0x0000 }, /* R18863 */ - { 0x0000, 0x0000, 0x0000 }, /* R18864 */ - { 0x0000, 0x0000, 0x0000 }, /* R18865 */ - { 0x0000, 0x0000, 0x0000 }, /* R18866 */ - { 0x0000, 0x0000, 0x0000 }, /* R18867 */ - { 0x0000, 0x0000, 0x0000 }, /* R18868 */ - { 0x0000, 0x0000, 0x0000 }, /* R18869 */ - { 0x0000, 0x0000, 0x0000 }, /* R18870 */ - { 0x0000, 0x0000, 0x0000 }, /* R18871 */ - { 0x0000, 0x0000, 0x0000 }, /* R18872 */ - { 0x0000, 0x0000, 0x0000 }, /* R18873 */ - { 0x0000, 0x0000, 0x0000 }, /* R18874 */ - { 0x0000, 0x0000, 0x0000 }, /* R18875 */ - { 0x0000, 0x0000, 0x0000 }, /* R18876 */ - { 0x0000, 0x0000, 0x0000 }, /* R18877 */ - { 0x0000, 0x0000, 0x0000 }, /* R18878 */ - { 0x0000, 0x0000, 0x0000 }, /* R18879 */ - { 0x0000, 0x0000, 0x0000 }, /* R18880 */ - { 0x0000, 0x0000, 0x0000 }, /* R18881 */ - { 0x0000, 0x0000, 0x0000 }, /* R18882 */ - { 0x0000, 0x0000, 0x0000 }, /* R18883 */ - { 0x0000, 0x0000, 0x0000 }, /* R18884 */ - { 0x0000, 0x0000, 0x0000 }, /* R18885 */ - { 0x0000, 0x0000, 0x0000 }, /* R18886 */ - { 0x0000, 0x0000, 0x0000 }, /* R18887 */ - { 0x0000, 0x0000, 0x0000 }, /* R18888 */ - { 0x0000, 0x0000, 0x0000 }, /* R18889 */ - { 0x0000, 0x0000, 0x0000 }, /* R18890 */ - { 0x0000, 0x0000, 0x0000 }, /* R18891 */ - { 0x0000, 0x0000, 0x0000 }, /* R18892 */ - { 0x0000, 0x0000, 0x0000 }, /* R18893 */ - { 0x0000, 0x0000, 0x0000 }, /* R18894 */ - { 0x0000, 0x0000, 0x0000 }, /* R18895 */ - { 0x0000, 0x0000, 0x0000 }, /* R18896 */ - { 0x0000, 0x0000, 0x0000 }, /* R18897 */ - { 0x0000, 0x0000, 0x0000 }, /* R18898 */ - { 0x0000, 0x0000, 0x0000 }, /* R18899 */ - { 0x0000, 0x0000, 0x0000 }, /* R18900 */ - { 0x0000, 0x0000, 0x0000 }, /* R18901 */ - { 0x0000, 0x0000, 0x0000 }, /* R18902 */ - { 0x0000, 0x0000, 0x0000 }, /* R18903 */ - { 0x0000, 0x0000, 0x0000 }, /* R18904 */ - { 0x0000, 0x0000, 0x0000 }, /* R18905 */ - { 0x0000, 0x0000, 0x0000 }, /* R18906 */ - { 0x0000, 0x0000, 0x0000 }, /* R18907 */ - { 0x0000, 0x0000, 0x0000 }, /* R18908 */ - { 0x0000, 0x0000, 0x0000 }, /* R18909 */ - { 0x0000, 0x0000, 0x0000 }, /* R18910 */ - { 0x0000, 0x0000, 0x0000 }, /* R18911 */ - { 0x0000, 0x0000, 0x0000 }, /* R18912 */ - { 0x0000, 0x0000, 0x0000 }, /* R18913 */ - { 0x0000, 0x0000, 0x0000 }, /* R18914 */ - { 0x0000, 0x0000, 0x0000 }, /* R18915 */ - { 0x0000, 0x0000, 0x0000 }, /* R18916 */ - { 0x0000, 0x0000, 0x0000 }, /* R18917 */ - { 0x0000, 0x0000, 0x0000 }, /* R18918 */ - { 0x0000, 0x0000, 0x0000 }, /* R18919 */ - { 0x0000, 0x0000, 0x0000 }, /* R18920 */ - { 0x0000, 0x0000, 0x0000 }, /* R18921 */ - { 0x0000, 0x0000, 0x0000 }, /* R18922 */ - { 0x0000, 0x0000, 0x0000 }, /* R18923 */ - { 0x0000, 0x0000, 0x0000 }, /* R18924 */ - { 0x0000, 0x0000, 0x0000 }, /* R18925 */ - { 0x0000, 0x0000, 0x0000 }, /* R18926 */ - { 0x0000, 0x0000, 0x0000 }, /* R18927 */ - { 0x0000, 0x0000, 0x0000 }, /* R18928 */ - { 0x0000, 0x0000, 0x0000 }, /* R18929 */ - { 0x0000, 0x0000, 0x0000 }, /* R18930 */ - { 0x0000, 0x0000, 0x0000 }, /* R18931 */ - { 0x0000, 0x0000, 0x0000 }, /* R18932 */ - { 0x0000, 0x0000, 0x0000 }, /* R18933 */ - { 0x0000, 0x0000, 0x0000 }, /* R18934 */ - { 0x0000, 0x0000, 0x0000 }, /* R18935 */ - { 0x0000, 0x0000, 0x0000 }, /* R18936 */ - { 0x0000, 0x0000, 0x0000 }, /* R18937 */ - { 0x0000, 0x0000, 0x0000 }, /* R18938 */ - { 0x0000, 0x0000, 0x0000 }, /* R18939 */ - { 0x0000, 0x0000, 0x0000 }, /* R18940 */ - { 0x0000, 0x0000, 0x0000 }, /* R18941 */ - { 0x0000, 0x0000, 0x0000 }, /* R18942 */ - { 0x0000, 0x0000, 0x0000 }, /* R18943 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18944 - ADCR_RETUNE_C1_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18945 - ADCR_RETUNE_C1_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18946 - ADCR_RETUNE_C2_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18947 - ADCR_RETUNE_C2_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18948 - ADCR_RETUNE_C3_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18949 - ADCR_RETUNE_C3_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18950 - ADCR_RETUNE_C4_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18951 - ADCR_RETUNE_C4_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18952 - ADCR_RETUNE_C5_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18953 - ADCR_RETUNE_C5_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18954 - ADCR_RETUNE_C6_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18955 - ADCR_RETUNE_C6_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18956 - ADCR_RETUNE_C7_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18957 - ADCR_RETUNE_C7_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18958 - ADCR_RETUNE_C8_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18959 - ADCR_RETUNE_C8_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18960 - ADCR_RETUNE_C9_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18961 - ADCR_RETUNE_C9_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18962 - ADCR_RETUNE_C10_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18963 - ADCR_RETUNE_C10_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18964 - ADCR_RETUNE_C11_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18965 - ADCR_RETUNE_C11_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18966 - ADCR_RETUNE_C12_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18967 - ADCR_RETUNE_C12_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18968 - ADCR_RETUNE_C13_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18969 - ADCR_RETUNE_C13_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18970 - ADCR_RETUNE_C14_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18971 - ADCR_RETUNE_C14_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18972 - ADCR_RETUNE_C15_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18973 - ADCR_RETUNE_C15_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18974 - ADCR_RETUNE_C16_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18975 - ADCR_RETUNE_C16_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18976 - ADCR_RETUNE_C17_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18977 - ADCR_RETUNE_C17_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18978 - ADCR_RETUNE_C18_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18979 - ADCR_RETUNE_C18_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18980 - ADCR_RETUNE_C19_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18981 - ADCR_RETUNE_C19_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18982 - ADCR_RETUNE_C20_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18983 - ADCR_RETUNE_C20_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18984 - ADCR_RETUNE_C21_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18985 - ADCR_RETUNE_C21_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18986 - ADCR_RETUNE_C22_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18987 - ADCR_RETUNE_C22_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18988 - ADCR_RETUNE_C23_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18989 - ADCR_RETUNE_C23_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18990 - ADCR_RETUNE_C24_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18991 - ADCR_RETUNE_C24_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18992 - ADCR_RETUNE_C25_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18993 - ADCR_RETUNE_C25_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18994 - ADCR_RETUNE_C26_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18995 - ADCR_RETUNE_C26_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18996 - ADCR_RETUNE_C27_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18997 - ADCR_RETUNE_C27_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R18998 - ADCR_RETUNE_C28_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R18999 - ADCR_RETUNE_C28_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19000 - ADCR_RETUNE_C29_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19001 - ADCR_RETUNE_C29_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19002 - ADCR_RETUNE_C30_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19003 - ADCR_RETUNE_C30_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19004 - ADCR_RETUNE_C31_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19005 - ADCR_RETUNE_C31_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19006 - ADCR_RETUNE_C32_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19007 - ADCR_RETUNE_C32_0 */ - { 0x0000, 0x0000, 0x0000 }, /* R19008 */ - { 0x0000, 0x0000, 0x0000 }, /* R19009 */ - { 0x0000, 0x0000, 0x0000 }, /* R19010 */ - { 0x0000, 0x0000, 0x0000 }, /* R19011 */ - { 0x0000, 0x0000, 0x0000 }, /* R19012 */ - { 0x0000, 0x0000, 0x0000 }, /* R19013 */ - { 0x0000, 0x0000, 0x0000 }, /* R19014 */ - { 0x0000, 0x0000, 0x0000 }, /* R19015 */ - { 0x0000, 0x0000, 0x0000 }, /* R19016 */ - { 0x0000, 0x0000, 0x0000 }, /* R19017 */ - { 0x0000, 0x0000, 0x0000 }, /* R19018 */ - { 0x0000, 0x0000, 0x0000 }, /* R19019 */ - { 0x0000, 0x0000, 0x0000 }, /* R19020 */ - { 0x0000, 0x0000, 0x0000 }, /* R19021 */ - { 0x0000, 0x0000, 0x0000 }, /* R19022 */ - { 0x0000, 0x0000, 0x0000 }, /* R19023 */ - { 0x0000, 0x0000, 0x0000 }, /* R19024 */ - { 0x0000, 0x0000, 0x0000 }, /* R19025 */ - { 0x0000, 0x0000, 0x0000 }, /* R19026 */ - { 0x0000, 0x0000, 0x0000 }, /* R19027 */ - { 0x0000, 0x0000, 0x0000 }, /* R19028 */ - { 0x0000, 0x0000, 0x0000 }, /* R19029 */ - { 0x0000, 0x0000, 0x0000 }, /* R19030 */ - { 0x0000, 0x0000, 0x0000 }, /* R19031 */ - { 0x0000, 0x0000, 0x0000 }, /* R19032 */ - { 0x0000, 0x0000, 0x0000 }, /* R19033 */ - { 0x0000, 0x0000, 0x0000 }, /* R19034 */ - { 0x0000, 0x0000, 0x0000 }, /* R19035 */ - { 0x0000, 0x0000, 0x0000 }, /* R19036 */ - { 0x0000, 0x0000, 0x0000 }, /* R19037 */ - { 0x0000, 0x0000, 0x0000 }, /* R19038 */ - { 0x0000, 0x0000, 0x0000 }, /* R19039 */ - { 0x0000, 0x0000, 0x0000 }, /* R19040 */ - { 0x0000, 0x0000, 0x0000 }, /* R19041 */ - { 0x0000, 0x0000, 0x0000 }, /* R19042 */ - { 0x0000, 0x0000, 0x0000 }, /* R19043 */ - { 0x0000, 0x0000, 0x0000 }, /* R19044 */ - { 0x0000, 0x0000, 0x0000 }, /* R19045 */ - { 0x0000, 0x0000, 0x0000 }, /* R19046 */ - { 0x0000, 0x0000, 0x0000 }, /* R19047 */ - { 0x0000, 0x0000, 0x0000 }, /* R19048 */ - { 0x0000, 0x0000, 0x0000 }, /* R19049 */ - { 0x0000, 0x0000, 0x0000 }, /* R19050 */ - { 0x0000, 0x0000, 0x0000 }, /* R19051 */ - { 0x0000, 0x0000, 0x0000 }, /* R19052 */ - { 0x0000, 0x0000, 0x0000 }, /* R19053 */ - { 0x0000, 0x0000, 0x0000 }, /* R19054 */ - { 0x0000, 0x0000, 0x0000 }, /* R19055 */ - { 0x0000, 0x0000, 0x0000 }, /* R19056 */ - { 0x0000, 0x0000, 0x0000 }, /* R19057 */ - { 0x0000, 0x0000, 0x0000 }, /* R19058 */ - { 0x0000, 0x0000, 0x0000 }, /* R19059 */ - { 0x0000, 0x0000, 0x0000 }, /* R19060 */ - { 0x0000, 0x0000, 0x0000 }, /* R19061 */ - { 0x0000, 0x0000, 0x0000 }, /* R19062 */ - { 0x0000, 0x0000, 0x0000 }, /* R19063 */ - { 0x0000, 0x0000, 0x0000 }, /* R19064 */ - { 0x0000, 0x0000, 0x0000 }, /* R19065 */ - { 0x0000, 0x0000, 0x0000 }, /* R19066 */ - { 0x0000, 0x0000, 0x0000 }, /* R19067 */ - { 0x0000, 0x0000, 0x0000 }, /* R19068 */ - { 0x0000, 0x0000, 0x0000 }, /* R19069 */ - { 0x0000, 0x0000, 0x0000 }, /* R19070 */ - { 0x0000, 0x0000, 0x0000 }, /* R19071 */ - { 0x0000, 0x0000, 0x0000 }, /* R19072 */ - { 0x0000, 0x0000, 0x0000 }, /* R19073 */ - { 0x0000, 0x0000, 0x0000 }, /* R19074 */ - { 0x0000, 0x0000, 0x0000 }, /* R19075 */ - { 0x0000, 0x0000, 0x0000 }, /* R19076 */ - { 0x0000, 0x0000, 0x0000 }, /* R19077 */ - { 0x0000, 0x0000, 0x0000 }, /* R19078 */ - { 0x0000, 0x0000, 0x0000 }, /* R19079 */ - { 0x0000, 0x0000, 0x0000 }, /* R19080 */ - { 0x0000, 0x0000, 0x0000 }, /* R19081 */ - { 0x0000, 0x0000, 0x0000 }, /* R19082 */ - { 0x0000, 0x0000, 0x0000 }, /* R19083 */ - { 0x0000, 0x0000, 0x0000 }, /* R19084 */ - { 0x0000, 0x0000, 0x0000 }, /* R19085 */ - { 0x0000, 0x0000, 0x0000 }, /* R19086 */ - { 0x0000, 0x0000, 0x0000 }, /* R19087 */ - { 0x0000, 0x0000, 0x0000 }, /* R19088 */ - { 0x0000, 0x0000, 0x0000 }, /* R19089 */ - { 0x0000, 0x0000, 0x0000 }, /* R19090 */ - { 0x0000, 0x0000, 0x0000 }, /* R19091 */ - { 0x0000, 0x0000, 0x0000 }, /* R19092 */ - { 0x0000, 0x0000, 0x0000 }, /* R19093 */ - { 0x0000, 0x0000, 0x0000 }, /* R19094 */ - { 0x0000, 0x0000, 0x0000 }, /* R19095 */ - { 0x0000, 0x0000, 0x0000 }, /* R19096 */ - { 0x0000, 0x0000, 0x0000 }, /* R19097 */ - { 0x0000, 0x0000, 0x0000 }, /* R19098 */ - { 0x0000, 0x0000, 0x0000 }, /* R19099 */ - { 0x0000, 0x0000, 0x0000 }, /* R19100 */ - { 0x0000, 0x0000, 0x0000 }, /* R19101 */ - { 0x0000, 0x0000, 0x0000 }, /* R19102 */ - { 0x0000, 0x0000, 0x0000 }, /* R19103 */ - { 0x0000, 0x0000, 0x0000 }, /* R19104 */ - { 0x0000, 0x0000, 0x0000 }, /* R19105 */ - { 0x0000, 0x0000, 0x0000 }, /* R19106 */ - { 0x0000, 0x0000, 0x0000 }, /* R19107 */ - { 0x0000, 0x0000, 0x0000 }, /* R19108 */ - { 0x0000, 0x0000, 0x0000 }, /* R19109 */ - { 0x0000, 0x0000, 0x0000 }, /* R19110 */ - { 0x0000, 0x0000, 0x0000 }, /* R19111 */ - { 0x0000, 0x0000, 0x0000 }, /* R19112 */ - { 0x0000, 0x0000, 0x0000 }, /* R19113 */ - { 0x0000, 0x0000, 0x0000 }, /* R19114 */ - { 0x0000, 0x0000, 0x0000 }, /* R19115 */ - { 0x0000, 0x0000, 0x0000 }, /* R19116 */ - { 0x0000, 0x0000, 0x0000 }, /* R19117 */ - { 0x0000, 0x0000, 0x0000 }, /* R19118 */ - { 0x0000, 0x0000, 0x0000 }, /* R19119 */ - { 0x0000, 0x0000, 0x0000 }, /* R19120 */ - { 0x0000, 0x0000, 0x0000 }, /* R19121 */ - { 0x0000, 0x0000, 0x0000 }, /* R19122 */ - { 0x0000, 0x0000, 0x0000 }, /* R19123 */ - { 0x0000, 0x0000, 0x0000 }, /* R19124 */ - { 0x0000, 0x0000, 0x0000 }, /* R19125 */ - { 0x0000, 0x0000, 0x0000 }, /* R19126 */ - { 0x0000, 0x0000, 0x0000 }, /* R19127 */ - { 0x0000, 0x0000, 0x0000 }, /* R19128 */ - { 0x0000, 0x0000, 0x0000 }, /* R19129 */ - { 0x0000, 0x0000, 0x0000 }, /* R19130 */ - { 0x0000, 0x0000, 0x0000 }, /* R19131 */ - { 0x0000, 0x0000, 0x0000 }, /* R19132 */ - { 0x0000, 0x0000, 0x0000 }, /* R19133 */ - { 0x0000, 0x0000, 0x0000 }, /* R19134 */ - { 0x0000, 0x0000, 0x0000 }, /* R19135 */ - { 0x0000, 0x0000, 0x0000 }, /* R19136 */ - { 0x0000, 0x0000, 0x0000 }, /* R19137 */ - { 0x0000, 0x0000, 0x0000 }, /* R19138 */ - { 0x0000, 0x0000, 0x0000 }, /* R19139 */ - { 0x0000, 0x0000, 0x0000 }, /* R19140 */ - { 0x0000, 0x0000, 0x0000 }, /* R19141 */ - { 0x0000, 0x0000, 0x0000 }, /* R19142 */ - { 0x0000, 0x0000, 0x0000 }, /* R19143 */ - { 0x0000, 0x0000, 0x0000 }, /* R19144 */ - { 0x0000, 0x0000, 0x0000 }, /* R19145 */ - { 0x0000, 0x0000, 0x0000 }, /* R19146 */ - { 0x0000, 0x0000, 0x0000 }, /* R19147 */ - { 0x0000, 0x0000, 0x0000 }, /* R19148 */ - { 0x0000, 0x0000, 0x0000 }, /* R19149 */ - { 0x0000, 0x0000, 0x0000 }, /* R19150 */ - { 0x0000, 0x0000, 0x0000 }, /* R19151 */ - { 0x0000, 0x0000, 0x0000 }, /* R19152 */ - { 0x0000, 0x0000, 0x0000 }, /* R19153 */ - { 0x0000, 0x0000, 0x0000 }, /* R19154 */ - { 0x0000, 0x0000, 0x0000 }, /* R19155 */ - { 0x0000, 0x0000, 0x0000 }, /* R19156 */ - { 0x0000, 0x0000, 0x0000 }, /* R19157 */ - { 0x0000, 0x0000, 0x0000 }, /* R19158 */ - { 0x0000, 0x0000, 0x0000 }, /* R19159 */ - { 0x0000, 0x0000, 0x0000 }, /* R19160 */ - { 0x0000, 0x0000, 0x0000 }, /* R19161 */ - { 0x0000, 0x0000, 0x0000 }, /* R19162 */ - { 0x0000, 0x0000, 0x0000 }, /* R19163 */ - { 0x0000, 0x0000, 0x0000 }, /* R19164 */ - { 0x0000, 0x0000, 0x0000 }, /* R19165 */ - { 0x0000, 0x0000, 0x0000 }, /* R19166 */ - { 0x0000, 0x0000, 0x0000 }, /* R19167 */ - { 0x0000, 0x0000, 0x0000 }, /* R19168 */ - { 0x0000, 0x0000, 0x0000 }, /* R19169 */ - { 0x0000, 0x0000, 0x0000 }, /* R19170 */ - { 0x0000, 0x0000, 0x0000 }, /* R19171 */ - { 0x0000, 0x0000, 0x0000 }, /* R19172 */ - { 0x0000, 0x0000, 0x0000 }, /* R19173 */ - { 0x0000, 0x0000, 0x0000 }, /* R19174 */ - { 0x0000, 0x0000, 0x0000 }, /* R19175 */ - { 0x0000, 0x0000, 0x0000 }, /* R19176 */ - { 0x0000, 0x0000, 0x0000 }, /* R19177 */ - { 0x0000, 0x0000, 0x0000 }, /* R19178 */ - { 0x0000, 0x0000, 0x0000 }, /* R19179 */ - { 0x0000, 0x0000, 0x0000 }, /* R19180 */ - { 0x0000, 0x0000, 0x0000 }, /* R19181 */ - { 0x0000, 0x0000, 0x0000 }, /* R19182 */ - { 0x0000, 0x0000, 0x0000 }, /* R19183 */ - { 0x0000, 0x0000, 0x0000 }, /* R19184 */ - { 0x0000, 0x0000, 0x0000 }, /* R19185 */ - { 0x0000, 0x0000, 0x0000 }, /* R19186 */ - { 0x0000, 0x0000, 0x0000 }, /* R19187 */ - { 0x0000, 0x0000, 0x0000 }, /* R19188 */ - { 0x0000, 0x0000, 0x0000 }, /* R19189 */ - { 0x0000, 0x0000, 0x0000 }, /* R19190 */ - { 0x0000, 0x0000, 0x0000 }, /* R19191 */ - { 0x0000, 0x0000, 0x0000 }, /* R19192 */ - { 0x0000, 0x0000, 0x0000 }, /* R19193 */ - { 0x0000, 0x0000, 0x0000 }, /* R19194 */ - { 0x0000, 0x0000, 0x0000 }, /* R19195 */ - { 0x0000, 0x0000, 0x0000 }, /* R19196 */ - { 0x0000, 0x0000, 0x0000 }, /* R19197 */ - { 0x0000, 0x0000, 0x0000 }, /* R19198 */ - { 0x0000, 0x0000, 0x0000 }, /* R19199 */ - { 0x0000, 0x0000, 0x0000 }, /* R19200 */ - { 0x0000, 0x0000, 0x0000 }, /* R19201 */ - { 0x0000, 0x0000, 0x0000 }, /* R19202 */ - { 0x0000, 0x0000, 0x0000 }, /* R19203 */ - { 0x0000, 0x0000, 0x0000 }, /* R19204 */ - { 0x0000, 0x0000, 0x0000 }, /* R19205 */ - { 0x0000, 0x0000, 0x0000 }, /* R19206 */ - { 0x0000, 0x0000, 0x0000 }, /* R19207 */ - { 0x0000, 0x0000, 0x0000 }, /* R19208 */ - { 0x0000, 0x0000, 0x0000 }, /* R19209 */ - { 0x0000, 0x0000, 0x0000 }, /* R19210 */ - { 0x0000, 0x0000, 0x0000 }, /* R19211 */ - { 0x0000, 0x0000, 0x0000 }, /* R19212 */ - { 0x0000, 0x0000, 0x0000 }, /* R19213 */ - { 0x0000, 0x0000, 0x0000 }, /* R19214 */ - { 0x0000, 0x0000, 0x0000 }, /* R19215 */ - { 0x0000, 0x0000, 0x0000 }, /* R19216 */ - { 0x0000, 0x0000, 0x0000 }, /* R19217 */ - { 0x0000, 0x0000, 0x0000 }, /* R19218 */ - { 0x0000, 0x0000, 0x0000 }, /* R19219 */ - { 0x0000, 0x0000, 0x0000 }, /* R19220 */ - { 0x0000, 0x0000, 0x0000 }, /* R19221 */ - { 0x0000, 0x0000, 0x0000 }, /* R19222 */ - { 0x0000, 0x0000, 0x0000 }, /* R19223 */ - { 0x0000, 0x0000, 0x0000 }, /* R19224 */ - { 0x0000, 0x0000, 0x0000 }, /* R19225 */ - { 0x0000, 0x0000, 0x0000 }, /* R19226 */ - { 0x0000, 0x0000, 0x0000 }, /* R19227 */ - { 0x0000, 0x0000, 0x0000 }, /* R19228 */ - { 0x0000, 0x0000, 0x0000 }, /* R19229 */ - { 0x0000, 0x0000, 0x0000 }, /* R19230 */ - { 0x0000, 0x0000, 0x0000 }, /* R19231 */ - { 0x0000, 0x0000, 0x0000 }, /* R19232 */ - { 0x0000, 0x0000, 0x0000 }, /* R19233 */ - { 0x0000, 0x0000, 0x0000 }, /* R19234 */ - { 0x0000, 0x0000, 0x0000 }, /* R19235 */ - { 0x0000, 0x0000, 0x0000 }, /* R19236 */ - { 0x0000, 0x0000, 0x0000 }, /* R19237 */ - { 0x0000, 0x0000, 0x0000 }, /* R19238 */ - { 0x0000, 0x0000, 0x0000 }, /* R19239 */ - { 0x0000, 0x0000, 0x0000 }, /* R19240 */ - { 0x0000, 0x0000, 0x0000 }, /* R19241 */ - { 0x0000, 0x0000, 0x0000 }, /* R19242 */ - { 0x0000, 0x0000, 0x0000 }, /* R19243 */ - { 0x0000, 0x0000, 0x0000 }, /* R19244 */ - { 0x0000, 0x0000, 0x0000 }, /* R19245 */ - { 0x0000, 0x0000, 0x0000 }, /* R19246 */ - { 0x0000, 0x0000, 0x0000 }, /* R19247 */ - { 0x0000, 0x0000, 0x0000 }, /* R19248 */ - { 0x0000, 0x0000, 0x0000 }, /* R19249 */ - { 0x0000, 0x0000, 0x0000 }, /* R19250 */ - { 0x0000, 0x0000, 0x0000 }, /* R19251 */ - { 0x0000, 0x0000, 0x0000 }, /* R19252 */ - { 0x0000, 0x0000, 0x0000 }, /* R19253 */ - { 0x0000, 0x0000, 0x0000 }, /* R19254 */ - { 0x0000, 0x0000, 0x0000 }, /* R19255 */ - { 0x0000, 0x0000, 0x0000 }, /* R19256 */ - { 0x0000, 0x0000, 0x0000 }, /* R19257 */ - { 0x0000, 0x0000, 0x0000 }, /* R19258 */ - { 0x0000, 0x0000, 0x0000 }, /* R19259 */ - { 0x0000, 0x0000, 0x0000 }, /* R19260 */ - { 0x0000, 0x0000, 0x0000 }, /* R19261 */ - { 0x0000, 0x0000, 0x0000 }, /* R19262 */ - { 0x0000, 0x0000, 0x0000 }, /* R19263 */ - { 0x0000, 0x0000, 0x0000 }, /* R19264 */ - { 0x0000, 0x0000, 0x0000 }, /* R19265 */ - { 0x0000, 0x0000, 0x0000 }, /* R19266 */ - { 0x0000, 0x0000, 0x0000 }, /* R19267 */ - { 0x0000, 0x0000, 0x0000 }, /* R19268 */ - { 0x0000, 0x0000, 0x0000 }, /* R19269 */ - { 0x0000, 0x0000, 0x0000 }, /* R19270 */ - { 0x0000, 0x0000, 0x0000 }, /* R19271 */ - { 0x0000, 0x0000, 0x0000 }, /* R19272 */ - { 0x0000, 0x0000, 0x0000 }, /* R19273 */ - { 0x0000, 0x0000, 0x0000 }, /* R19274 */ - { 0x0000, 0x0000, 0x0000 }, /* R19275 */ - { 0x0000, 0x0000, 0x0000 }, /* R19276 */ - { 0x0000, 0x0000, 0x0000 }, /* R19277 */ - { 0x0000, 0x0000, 0x0000 }, /* R19278 */ - { 0x0000, 0x0000, 0x0000 }, /* R19279 */ - { 0x0000, 0x0000, 0x0000 }, /* R19280 */ - { 0x0000, 0x0000, 0x0000 }, /* R19281 */ - { 0x0000, 0x0000, 0x0000 }, /* R19282 */ - { 0x0000, 0x0000, 0x0000 }, /* R19283 */ - { 0x0000, 0x0000, 0x0000 }, /* R19284 */ - { 0x0000, 0x0000, 0x0000 }, /* R19285 */ - { 0x0000, 0x0000, 0x0000 }, /* R19286 */ - { 0x0000, 0x0000, 0x0000 }, /* R19287 */ - { 0x0000, 0x0000, 0x0000 }, /* R19288 */ - { 0x0000, 0x0000, 0x0000 }, /* R19289 */ - { 0x0000, 0x0000, 0x0000 }, /* R19290 */ - { 0x0000, 0x0000, 0x0000 }, /* R19291 */ - { 0x0000, 0x0000, 0x0000 }, /* R19292 */ - { 0x0000, 0x0000, 0x0000 }, /* R19293 */ - { 0x0000, 0x0000, 0x0000 }, /* R19294 */ - { 0x0000, 0x0000, 0x0000 }, /* R19295 */ - { 0x0000, 0x0000, 0x0000 }, /* R19296 */ - { 0x0000, 0x0000, 0x0000 }, /* R19297 */ - { 0x0000, 0x0000, 0x0000 }, /* R19298 */ - { 0x0000, 0x0000, 0x0000 }, /* R19299 */ - { 0x0000, 0x0000, 0x0000 }, /* R19300 */ - { 0x0000, 0x0000, 0x0000 }, /* R19301 */ - { 0x0000, 0x0000, 0x0000 }, /* R19302 */ - { 0x0000, 0x0000, 0x0000 }, /* R19303 */ - { 0x0000, 0x0000, 0x0000 }, /* R19304 */ - { 0x0000, 0x0000, 0x0000 }, /* R19305 */ - { 0x0000, 0x0000, 0x0000 }, /* R19306 */ - { 0x0000, 0x0000, 0x0000 }, /* R19307 */ - { 0x0000, 0x0000, 0x0000 }, /* R19308 */ - { 0x0000, 0x0000, 0x0000 }, /* R19309 */ - { 0x0000, 0x0000, 0x0000 }, /* R19310 */ - { 0x0000, 0x0000, 0x0000 }, /* R19311 */ - { 0x0000, 0x0000, 0x0000 }, /* R19312 */ - { 0x0000, 0x0000, 0x0000 }, /* R19313 */ - { 0x0000, 0x0000, 0x0000 }, /* R19314 */ - { 0x0000, 0x0000, 0x0000 }, /* R19315 */ - { 0x0000, 0x0000, 0x0000 }, /* R19316 */ - { 0x0000, 0x0000, 0x0000 }, /* R19317 */ - { 0x0000, 0x0000, 0x0000 }, /* R19318 */ - { 0x0000, 0x0000, 0x0000 }, /* R19319 */ - { 0x0000, 0x0000, 0x0000 }, /* R19320 */ - { 0x0000, 0x0000, 0x0000 }, /* R19321 */ - { 0x0000, 0x0000, 0x0000 }, /* R19322 */ - { 0x0000, 0x0000, 0x0000 }, /* R19323 */ - { 0x0000, 0x0000, 0x0000 }, /* R19324 */ - { 0x0000, 0x0000, 0x0000 }, /* R19325 */ - { 0x0000, 0x0000, 0x0000 }, /* R19326 */ - { 0x0000, 0x0000, 0x0000 }, /* R19327 */ - { 0x0000, 0x0000, 0x0000 }, /* R19328 */ - { 0x0000, 0x0000, 0x0000 }, /* R19329 */ - { 0x0000, 0x0000, 0x0000 }, /* R19330 */ - { 0x0000, 0x0000, 0x0000 }, /* R19331 */ - { 0x0000, 0x0000, 0x0000 }, /* R19332 */ - { 0x0000, 0x0000, 0x0000 }, /* R19333 */ - { 0x0000, 0x0000, 0x0000 }, /* R19334 */ - { 0x0000, 0x0000, 0x0000 }, /* R19335 */ - { 0x0000, 0x0000, 0x0000 }, /* R19336 */ - { 0x0000, 0x0000, 0x0000 }, /* R19337 */ - { 0x0000, 0x0000, 0x0000 }, /* R19338 */ - { 0x0000, 0x0000, 0x0000 }, /* R19339 */ - { 0x0000, 0x0000, 0x0000 }, /* R19340 */ - { 0x0000, 0x0000, 0x0000 }, /* R19341 */ - { 0x0000, 0x0000, 0x0000 }, /* R19342 */ - { 0x0000, 0x0000, 0x0000 }, /* R19343 */ - { 0x0000, 0x0000, 0x0000 }, /* R19344 */ - { 0x0000, 0x0000, 0x0000 }, /* R19345 */ - { 0x0000, 0x0000, 0x0000 }, /* R19346 */ - { 0x0000, 0x0000, 0x0000 }, /* R19347 */ - { 0x0000, 0x0000, 0x0000 }, /* R19348 */ - { 0x0000, 0x0000, 0x0000 }, /* R19349 */ - { 0x0000, 0x0000, 0x0000 }, /* R19350 */ - { 0x0000, 0x0000, 0x0000 }, /* R19351 */ - { 0x0000, 0x0000, 0x0000 }, /* R19352 */ - { 0x0000, 0x0000, 0x0000 }, /* R19353 */ - { 0x0000, 0x0000, 0x0000 }, /* R19354 */ - { 0x0000, 0x0000, 0x0000 }, /* R19355 */ - { 0x0000, 0x0000, 0x0000 }, /* R19356 */ - { 0x0000, 0x0000, 0x0000 }, /* R19357 */ - { 0x0000, 0x0000, 0x0000 }, /* R19358 */ - { 0x0000, 0x0000, 0x0000 }, /* R19359 */ - { 0x0000, 0x0000, 0x0000 }, /* R19360 */ - { 0x0000, 0x0000, 0x0000 }, /* R19361 */ - { 0x0000, 0x0000, 0x0000 }, /* R19362 */ - { 0x0000, 0x0000, 0x0000 }, /* R19363 */ - { 0x0000, 0x0000, 0x0000 }, /* R19364 */ - { 0x0000, 0x0000, 0x0000 }, /* R19365 */ - { 0x0000, 0x0000, 0x0000 }, /* R19366 */ - { 0x0000, 0x0000, 0x0000 }, /* R19367 */ - { 0x0000, 0x0000, 0x0000 }, /* R19368 */ - { 0x0000, 0x0000, 0x0000 }, /* R19369 */ - { 0x0000, 0x0000, 0x0000 }, /* R19370 */ - { 0x0000, 0x0000, 0x0000 }, /* R19371 */ - { 0x0000, 0x0000, 0x0000 }, /* R19372 */ - { 0x0000, 0x0000, 0x0000 }, /* R19373 */ - { 0x0000, 0x0000, 0x0000 }, /* R19374 */ - { 0x0000, 0x0000, 0x0000 }, /* R19375 */ - { 0x0000, 0x0000, 0x0000 }, /* R19376 */ - { 0x0000, 0x0000, 0x0000 }, /* R19377 */ - { 0x0000, 0x0000, 0x0000 }, /* R19378 */ - { 0x0000, 0x0000, 0x0000 }, /* R19379 */ - { 0x0000, 0x0000, 0x0000 }, /* R19380 */ - { 0x0000, 0x0000, 0x0000 }, /* R19381 */ - { 0x0000, 0x0000, 0x0000 }, /* R19382 */ - { 0x0000, 0x0000, 0x0000 }, /* R19383 */ - { 0x0000, 0x0000, 0x0000 }, /* R19384 */ - { 0x0000, 0x0000, 0x0000 }, /* R19385 */ - { 0x0000, 0x0000, 0x0000 }, /* R19386 */ - { 0x0000, 0x0000, 0x0000 }, /* R19387 */ - { 0x0000, 0x0000, 0x0000 }, /* R19388 */ - { 0x0000, 0x0000, 0x0000 }, /* R19389 */ - { 0x0000, 0x0000, 0x0000 }, /* R19390 */ - { 0x0000, 0x0000, 0x0000 }, /* R19391 */ - { 0x0000, 0x0000, 0x0000 }, /* R19392 */ - { 0x0000, 0x0000, 0x0000 }, /* R19393 */ - { 0x0000, 0x0000, 0x0000 }, /* R19394 */ - { 0x0000, 0x0000, 0x0000 }, /* R19395 */ - { 0x0000, 0x0000, 0x0000 }, /* R19396 */ - { 0x0000, 0x0000, 0x0000 }, /* R19397 */ - { 0x0000, 0x0000, 0x0000 }, /* R19398 */ - { 0x0000, 0x0000, 0x0000 }, /* R19399 */ - { 0x0000, 0x0000, 0x0000 }, /* R19400 */ - { 0x0000, 0x0000, 0x0000 }, /* R19401 */ - { 0x0000, 0x0000, 0x0000 }, /* R19402 */ - { 0x0000, 0x0000, 0x0000 }, /* R19403 */ - { 0x0000, 0x0000, 0x0000 }, /* R19404 */ - { 0x0000, 0x0000, 0x0000 }, /* R19405 */ - { 0x0000, 0x0000, 0x0000 }, /* R19406 */ - { 0x0000, 0x0000, 0x0000 }, /* R19407 */ - { 0x0000, 0x0000, 0x0000 }, /* R19408 */ - { 0x0000, 0x0000, 0x0000 }, /* R19409 */ - { 0x0000, 0x0000, 0x0000 }, /* R19410 */ - { 0x0000, 0x0000, 0x0000 }, /* R19411 */ - { 0x0000, 0x0000, 0x0000 }, /* R19412 */ - { 0x0000, 0x0000, 0x0000 }, /* R19413 */ - { 0x0000, 0x0000, 0x0000 }, /* R19414 */ - { 0x0000, 0x0000, 0x0000 }, /* R19415 */ - { 0x0000, 0x0000, 0x0000 }, /* R19416 */ - { 0x0000, 0x0000, 0x0000 }, /* R19417 */ - { 0x0000, 0x0000, 0x0000 }, /* R19418 */ - { 0x0000, 0x0000, 0x0000 }, /* R19419 */ - { 0x0000, 0x0000, 0x0000 }, /* R19420 */ - { 0x0000, 0x0000, 0x0000 }, /* R19421 */ - { 0x0000, 0x0000, 0x0000 }, /* R19422 */ - { 0x0000, 0x0000, 0x0000 }, /* R19423 */ - { 0x0000, 0x0000, 0x0000 }, /* R19424 */ - { 0x0000, 0x0000, 0x0000 }, /* R19425 */ - { 0x0000, 0x0000, 0x0000 }, /* R19426 */ - { 0x0000, 0x0000, 0x0000 }, /* R19427 */ - { 0x0000, 0x0000, 0x0000 }, /* R19428 */ - { 0x0000, 0x0000, 0x0000 }, /* R19429 */ - { 0x0000, 0x0000, 0x0000 }, /* R19430 */ - { 0x0000, 0x0000, 0x0000 }, /* R19431 */ - { 0x0000, 0x0000, 0x0000 }, /* R19432 */ - { 0x0000, 0x0000, 0x0000 }, /* R19433 */ - { 0x0000, 0x0000, 0x0000 }, /* R19434 */ - { 0x0000, 0x0000, 0x0000 }, /* R19435 */ - { 0x0000, 0x0000, 0x0000 }, /* R19436 */ - { 0x0000, 0x0000, 0x0000 }, /* R19437 */ - { 0x0000, 0x0000, 0x0000 }, /* R19438 */ - { 0x0000, 0x0000, 0x0000 }, /* R19439 */ - { 0x0000, 0x0000, 0x0000 }, /* R19440 */ - { 0x0000, 0x0000, 0x0000 }, /* R19441 */ - { 0x0000, 0x0000, 0x0000 }, /* R19442 */ - { 0x0000, 0x0000, 0x0000 }, /* R19443 */ - { 0x0000, 0x0000, 0x0000 }, /* R19444 */ - { 0x0000, 0x0000, 0x0000 }, /* R19445 */ - { 0x0000, 0x0000, 0x0000 }, /* R19446 */ - { 0x0000, 0x0000, 0x0000 }, /* R19447 */ - { 0x0000, 0x0000, 0x0000 }, /* R19448 */ - { 0x0000, 0x0000, 0x0000 }, /* R19449 */ - { 0x0000, 0x0000, 0x0000 }, /* R19450 */ - { 0x0000, 0x0000, 0x0000 }, /* R19451 */ - { 0x0000, 0x0000, 0x0000 }, /* R19452 */ - { 0x0000, 0x0000, 0x0000 }, /* R19453 */ - { 0x0000, 0x0000, 0x0000 }, /* R19454 */ - { 0x0000, 0x0000, 0x0000 }, /* R19455 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19456 - DACL_RETUNE_C1_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19457 - DACL_RETUNE_C1_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19458 - DACL_RETUNE_C2_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19459 - DACL_RETUNE_C2_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19460 - DACL_RETUNE_C3_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19461 - DACL_RETUNE_C3_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19462 - DACL_RETUNE_C4_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19463 - DACL_RETUNE_C4_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19464 - DACL_RETUNE_C5_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19465 - DACL_RETUNE_C5_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19466 - DACL_RETUNE_C6_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19467 - DACL_RETUNE_C6_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19468 - DACL_RETUNE_C7_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19469 - DACL_RETUNE_C7_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19470 - DACL_RETUNE_C8_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19471 - DACL_RETUNE_C8_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19472 - DACL_RETUNE_C9_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19473 - DACL_RETUNE_C9_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19474 - DACL_RETUNE_C10_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19475 - DACL_RETUNE_C10_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19476 - DACL_RETUNE_C11_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19477 - DACL_RETUNE_C11_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19478 - DACL_RETUNE_C12_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19479 - DACL_RETUNE_C12_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19480 - DACL_RETUNE_C13_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19481 - DACL_RETUNE_C13_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19482 - DACL_RETUNE_C14_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19483 - DACL_RETUNE_C14_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19484 - DACL_RETUNE_C15_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19485 - DACL_RETUNE_C15_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19486 - DACL_RETUNE_C16_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19487 - DACL_RETUNE_C16_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19488 - DACL_RETUNE_C17_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19489 - DACL_RETUNE_C17_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19490 - DACL_RETUNE_C18_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19491 - DACL_RETUNE_C18_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19492 - DACL_RETUNE_C19_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19493 - DACL_RETUNE_C19_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19494 - DACL_RETUNE_C20_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19495 - DACL_RETUNE_C20_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19496 - DACL_RETUNE_C21_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19497 - DACL_RETUNE_C21_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19498 - DACL_RETUNE_C22_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19499 - DACL_RETUNE_C22_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19500 - DACL_RETUNE_C23_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19501 - DACL_RETUNE_C23_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19502 - DACL_RETUNE_C24_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19503 - DACL_RETUNE_C24_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19504 - DACL_RETUNE_C25_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19505 - DACL_RETUNE_C25_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19506 - DACL_RETUNE_C26_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19507 - DACL_RETUNE_C26_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19508 - DACL_RETUNE_C27_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19509 - DACL_RETUNE_C27_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19510 - DACL_RETUNE_C28_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19511 - DACL_RETUNE_C28_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19512 - DACL_RETUNE_C29_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19513 - DACL_RETUNE_C29_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19514 - DACL_RETUNE_C30_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19515 - DACL_RETUNE_C30_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19516 - DACL_RETUNE_C31_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19517 - DACL_RETUNE_C31_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19518 - DACL_RETUNE_C32_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19519 - DACL_RETUNE_C32_0 */ - { 0x0000, 0x0000, 0x0000 }, /* R19520 */ - { 0x0000, 0x0000, 0x0000 }, /* R19521 */ - { 0x0000, 0x0000, 0x0000 }, /* R19522 */ - { 0x0000, 0x0000, 0x0000 }, /* R19523 */ - { 0x0000, 0x0000, 0x0000 }, /* R19524 */ - { 0x0000, 0x0000, 0x0000 }, /* R19525 */ - { 0x0000, 0x0000, 0x0000 }, /* R19526 */ - { 0x0000, 0x0000, 0x0000 }, /* R19527 */ - { 0x0000, 0x0000, 0x0000 }, /* R19528 */ - { 0x0000, 0x0000, 0x0000 }, /* R19529 */ - { 0x0000, 0x0000, 0x0000 }, /* R19530 */ - { 0x0000, 0x0000, 0x0000 }, /* R19531 */ - { 0x0000, 0x0000, 0x0000 }, /* R19532 */ - { 0x0000, 0x0000, 0x0000 }, /* R19533 */ - { 0x0000, 0x0000, 0x0000 }, /* R19534 */ - { 0x0000, 0x0000, 0x0000 }, /* R19535 */ - { 0x0000, 0x0000, 0x0000 }, /* R19536 */ - { 0x0000, 0x0000, 0x0000 }, /* R19537 */ - { 0x0000, 0x0000, 0x0000 }, /* R19538 */ - { 0x0000, 0x0000, 0x0000 }, /* R19539 */ - { 0x0000, 0x0000, 0x0000 }, /* R19540 */ - { 0x0000, 0x0000, 0x0000 }, /* R19541 */ - { 0x0000, 0x0000, 0x0000 }, /* R19542 */ - { 0x0000, 0x0000, 0x0000 }, /* R19543 */ - { 0x0000, 0x0000, 0x0000 }, /* R19544 */ - { 0x0000, 0x0000, 0x0000 }, /* R19545 */ - { 0x0000, 0x0000, 0x0000 }, /* R19546 */ - { 0x0000, 0x0000, 0x0000 }, /* R19547 */ - { 0x0000, 0x0000, 0x0000 }, /* R19548 */ - { 0x0000, 0x0000, 0x0000 }, /* R19549 */ - { 0x0000, 0x0000, 0x0000 }, /* R19550 */ - { 0x0000, 0x0000, 0x0000 }, /* R19551 */ - { 0x0000, 0x0000, 0x0000 }, /* R19552 */ - { 0x0000, 0x0000, 0x0000 }, /* R19553 */ - { 0x0000, 0x0000, 0x0000 }, /* R19554 */ - { 0x0000, 0x0000, 0x0000 }, /* R19555 */ - { 0x0000, 0x0000, 0x0000 }, /* R19556 */ - { 0x0000, 0x0000, 0x0000 }, /* R19557 */ - { 0x0000, 0x0000, 0x0000 }, /* R19558 */ - { 0x0000, 0x0000, 0x0000 }, /* R19559 */ - { 0x0000, 0x0000, 0x0000 }, /* R19560 */ - { 0x0000, 0x0000, 0x0000 }, /* R19561 */ - { 0x0000, 0x0000, 0x0000 }, /* R19562 */ - { 0x0000, 0x0000, 0x0000 }, /* R19563 */ - { 0x0000, 0x0000, 0x0000 }, /* R19564 */ - { 0x0000, 0x0000, 0x0000 }, /* R19565 */ - { 0x0000, 0x0000, 0x0000 }, /* R19566 */ - { 0x0000, 0x0000, 0x0000 }, /* R19567 */ - { 0x0000, 0x0000, 0x0000 }, /* R19568 */ - { 0x0000, 0x0000, 0x0000 }, /* R19569 */ - { 0x0000, 0x0000, 0x0000 }, /* R19570 */ - { 0x0000, 0x0000, 0x0000 }, /* R19571 */ - { 0x0000, 0x0000, 0x0000 }, /* R19572 */ - { 0x0000, 0x0000, 0x0000 }, /* R19573 */ - { 0x0000, 0x0000, 0x0000 }, /* R19574 */ - { 0x0000, 0x0000, 0x0000 }, /* R19575 */ - { 0x0000, 0x0000, 0x0000 }, /* R19576 */ - { 0x0000, 0x0000, 0x0000 }, /* R19577 */ - { 0x0000, 0x0000, 0x0000 }, /* R19578 */ - { 0x0000, 0x0000, 0x0000 }, /* R19579 */ - { 0x0000, 0x0000, 0x0000 }, /* R19580 */ - { 0x0000, 0x0000, 0x0000 }, /* R19581 */ - { 0x0000, 0x0000, 0x0000 }, /* R19582 */ - { 0x0000, 0x0000, 0x0000 }, /* R19583 */ - { 0x0000, 0x0000, 0x0000 }, /* R19584 */ - { 0x0000, 0x0000, 0x0000 }, /* R19585 */ - { 0x0000, 0x0000, 0x0000 }, /* R19586 */ - { 0x0000, 0x0000, 0x0000 }, /* R19587 */ - { 0x0000, 0x0000, 0x0000 }, /* R19588 */ - { 0x0000, 0x0000, 0x0000 }, /* R19589 */ - { 0x0000, 0x0000, 0x0000 }, /* R19590 */ - { 0x0000, 0x0000, 0x0000 }, /* R19591 */ - { 0x0000, 0x0000, 0x0000 }, /* R19592 */ - { 0x0000, 0x0000, 0x0000 }, /* R19593 */ - { 0x0000, 0x0000, 0x0000 }, /* R19594 */ - { 0x0000, 0x0000, 0x0000 }, /* R19595 */ - { 0x0000, 0x0000, 0x0000 }, /* R19596 */ - { 0x0000, 0x0000, 0x0000 }, /* R19597 */ - { 0x0000, 0x0000, 0x0000 }, /* R19598 */ - { 0x0000, 0x0000, 0x0000 }, /* R19599 */ - { 0x0000, 0x0000, 0x0000 }, /* R19600 */ - { 0x0000, 0x0000, 0x0000 }, /* R19601 */ - { 0x0000, 0x0000, 0x0000 }, /* R19602 */ - { 0x0000, 0x0000, 0x0000 }, /* R19603 */ - { 0x0000, 0x0000, 0x0000 }, /* R19604 */ - { 0x0000, 0x0000, 0x0000 }, /* R19605 */ - { 0x0000, 0x0000, 0x0000 }, /* R19606 */ - { 0x0000, 0x0000, 0x0000 }, /* R19607 */ - { 0x0000, 0x0000, 0x0000 }, /* R19608 */ - { 0x0000, 0x0000, 0x0000 }, /* R19609 */ - { 0x0000, 0x0000, 0x0000 }, /* R19610 */ - { 0x0000, 0x0000, 0x0000 }, /* R19611 */ - { 0x0000, 0x0000, 0x0000 }, /* R19612 */ - { 0x0000, 0x0000, 0x0000 }, /* R19613 */ - { 0x0000, 0x0000, 0x0000 }, /* R19614 */ - { 0x0000, 0x0000, 0x0000 }, /* R19615 */ - { 0x0000, 0x0000, 0x0000 }, /* R19616 */ - { 0x0000, 0x0000, 0x0000 }, /* R19617 */ - { 0x0000, 0x0000, 0x0000 }, /* R19618 */ - { 0x0000, 0x0000, 0x0000 }, /* R19619 */ - { 0x0000, 0x0000, 0x0000 }, /* R19620 */ - { 0x0000, 0x0000, 0x0000 }, /* R19621 */ - { 0x0000, 0x0000, 0x0000 }, /* R19622 */ - { 0x0000, 0x0000, 0x0000 }, /* R19623 */ - { 0x0000, 0x0000, 0x0000 }, /* R19624 */ - { 0x0000, 0x0000, 0x0000 }, /* R19625 */ - { 0x0000, 0x0000, 0x0000 }, /* R19626 */ - { 0x0000, 0x0000, 0x0000 }, /* R19627 */ - { 0x0000, 0x0000, 0x0000 }, /* R19628 */ - { 0x0000, 0x0000, 0x0000 }, /* R19629 */ - { 0x0000, 0x0000, 0x0000 }, /* R19630 */ - { 0x0000, 0x0000, 0x0000 }, /* R19631 */ - { 0x0000, 0x0000, 0x0000 }, /* R19632 */ - { 0x0000, 0x0000, 0x0000 }, /* R19633 */ - { 0x0000, 0x0000, 0x0000 }, /* R19634 */ - { 0x0000, 0x0000, 0x0000 }, /* R19635 */ - { 0x0000, 0x0000, 0x0000 }, /* R19636 */ - { 0x0000, 0x0000, 0x0000 }, /* R19637 */ - { 0x0000, 0x0000, 0x0000 }, /* R19638 */ - { 0x0000, 0x0000, 0x0000 }, /* R19639 */ - { 0x0000, 0x0000, 0x0000 }, /* R19640 */ - { 0x0000, 0x0000, 0x0000 }, /* R19641 */ - { 0x0000, 0x0000, 0x0000 }, /* R19642 */ - { 0x0000, 0x0000, 0x0000 }, /* R19643 */ - { 0x0000, 0x0000, 0x0000 }, /* R19644 */ - { 0x0000, 0x0000, 0x0000 }, /* R19645 */ - { 0x0000, 0x0000, 0x0000 }, /* R19646 */ - { 0x0000, 0x0000, 0x0000 }, /* R19647 */ - { 0x0000, 0x0000, 0x0000 }, /* R19648 */ - { 0x0000, 0x0000, 0x0000 }, /* R19649 */ - { 0x0000, 0x0000, 0x0000 }, /* R19650 */ - { 0x0000, 0x0000, 0x0000 }, /* R19651 */ - { 0x0000, 0x0000, 0x0000 }, /* R19652 */ - { 0x0000, 0x0000, 0x0000 }, /* R19653 */ - { 0x0000, 0x0000, 0x0000 }, /* R19654 */ - { 0x0000, 0x0000, 0x0000 }, /* R19655 */ - { 0x0000, 0x0000, 0x0000 }, /* R19656 */ - { 0x0000, 0x0000, 0x0000 }, /* R19657 */ - { 0x0000, 0x0000, 0x0000 }, /* R19658 */ - { 0x0000, 0x0000, 0x0000 }, /* R19659 */ - { 0x0000, 0x0000, 0x0000 }, /* R19660 */ - { 0x0000, 0x0000, 0x0000 }, /* R19661 */ - { 0x0000, 0x0000, 0x0000 }, /* R19662 */ - { 0x0000, 0x0000, 0x0000 }, /* R19663 */ - { 0x0000, 0x0000, 0x0000 }, /* R19664 */ - { 0x0000, 0x0000, 0x0000 }, /* R19665 */ - { 0x0000, 0x0000, 0x0000 }, /* R19666 */ - { 0x0000, 0x0000, 0x0000 }, /* R19667 */ - { 0x0000, 0x0000, 0x0000 }, /* R19668 */ - { 0x0000, 0x0000, 0x0000 }, /* R19669 */ - { 0x0000, 0x0000, 0x0000 }, /* R19670 */ - { 0x0000, 0x0000, 0x0000 }, /* R19671 */ - { 0x0000, 0x0000, 0x0000 }, /* R19672 */ - { 0x0000, 0x0000, 0x0000 }, /* R19673 */ - { 0x0000, 0x0000, 0x0000 }, /* R19674 */ - { 0x0000, 0x0000, 0x0000 }, /* R19675 */ - { 0x0000, 0x0000, 0x0000 }, /* R19676 */ - { 0x0000, 0x0000, 0x0000 }, /* R19677 */ - { 0x0000, 0x0000, 0x0000 }, /* R19678 */ - { 0x0000, 0x0000, 0x0000 }, /* R19679 */ - { 0x0000, 0x0000, 0x0000 }, /* R19680 */ - { 0x0000, 0x0000, 0x0000 }, /* R19681 */ - { 0x0000, 0x0000, 0x0000 }, /* R19682 */ - { 0x0000, 0x0000, 0x0000 }, /* R19683 */ - { 0x0000, 0x0000, 0x0000 }, /* R19684 */ - { 0x0000, 0x0000, 0x0000 }, /* R19685 */ - { 0x0000, 0x0000, 0x0000 }, /* R19686 */ - { 0x0000, 0x0000, 0x0000 }, /* R19687 */ - { 0x0000, 0x0000, 0x0000 }, /* R19688 */ - { 0x0000, 0x0000, 0x0000 }, /* R19689 */ - { 0x0000, 0x0000, 0x0000 }, /* R19690 */ - { 0x0000, 0x0000, 0x0000 }, /* R19691 */ - { 0x0000, 0x0000, 0x0000 }, /* R19692 */ - { 0x0000, 0x0000, 0x0000 }, /* R19693 */ - { 0x0000, 0x0000, 0x0000 }, /* R19694 */ - { 0x0000, 0x0000, 0x0000 }, /* R19695 */ - { 0x0000, 0x0000, 0x0000 }, /* R19696 */ - { 0x0000, 0x0000, 0x0000 }, /* R19697 */ - { 0x0000, 0x0000, 0x0000 }, /* R19698 */ - { 0x0000, 0x0000, 0x0000 }, /* R19699 */ - { 0x0000, 0x0000, 0x0000 }, /* R19700 */ - { 0x0000, 0x0000, 0x0000 }, /* R19701 */ - { 0x0000, 0x0000, 0x0000 }, /* R19702 */ - { 0x0000, 0x0000, 0x0000 }, /* R19703 */ - { 0x0000, 0x0000, 0x0000 }, /* R19704 */ - { 0x0000, 0x0000, 0x0000 }, /* R19705 */ - { 0x0000, 0x0000, 0x0000 }, /* R19706 */ - { 0x0000, 0x0000, 0x0000 }, /* R19707 */ - { 0x0000, 0x0000, 0x0000 }, /* R19708 */ - { 0x0000, 0x0000, 0x0000 }, /* R19709 */ - { 0x0000, 0x0000, 0x0000 }, /* R19710 */ - { 0x0000, 0x0000, 0x0000 }, /* R19711 */ - { 0x0000, 0x0000, 0x0000 }, /* R19712 */ - { 0x0000, 0x0000, 0x0000 }, /* R19713 */ - { 0x0000, 0x0000, 0x0000 }, /* R19714 */ - { 0x0000, 0x0000, 0x0000 }, /* R19715 */ - { 0x0000, 0x0000, 0x0000 }, /* R19716 */ - { 0x0000, 0x0000, 0x0000 }, /* R19717 */ - { 0x0000, 0x0000, 0x0000 }, /* R19718 */ - { 0x0000, 0x0000, 0x0000 }, /* R19719 */ - { 0x0000, 0x0000, 0x0000 }, /* R19720 */ - { 0x0000, 0x0000, 0x0000 }, /* R19721 */ - { 0x0000, 0x0000, 0x0000 }, /* R19722 */ - { 0x0000, 0x0000, 0x0000 }, /* R19723 */ - { 0x0000, 0x0000, 0x0000 }, /* R19724 */ - { 0x0000, 0x0000, 0x0000 }, /* R19725 */ - { 0x0000, 0x0000, 0x0000 }, /* R19726 */ - { 0x0000, 0x0000, 0x0000 }, /* R19727 */ - { 0x0000, 0x0000, 0x0000 }, /* R19728 */ - { 0x0000, 0x0000, 0x0000 }, /* R19729 */ - { 0x0000, 0x0000, 0x0000 }, /* R19730 */ - { 0x0000, 0x0000, 0x0000 }, /* R19731 */ - { 0x0000, 0x0000, 0x0000 }, /* R19732 */ - { 0x0000, 0x0000, 0x0000 }, /* R19733 */ - { 0x0000, 0x0000, 0x0000 }, /* R19734 */ - { 0x0000, 0x0000, 0x0000 }, /* R19735 */ - { 0x0000, 0x0000, 0x0000 }, /* R19736 */ - { 0x0000, 0x0000, 0x0000 }, /* R19737 */ - { 0x0000, 0x0000, 0x0000 }, /* R19738 */ - { 0x0000, 0x0000, 0x0000 }, /* R19739 */ - { 0x0000, 0x0000, 0x0000 }, /* R19740 */ - { 0x0000, 0x0000, 0x0000 }, /* R19741 */ - { 0x0000, 0x0000, 0x0000 }, /* R19742 */ - { 0x0000, 0x0000, 0x0000 }, /* R19743 */ - { 0x0000, 0x0000, 0x0000 }, /* R19744 */ - { 0x0000, 0x0000, 0x0000 }, /* R19745 */ - { 0x0000, 0x0000, 0x0000 }, /* R19746 */ - { 0x0000, 0x0000, 0x0000 }, /* R19747 */ - { 0x0000, 0x0000, 0x0000 }, /* R19748 */ - { 0x0000, 0x0000, 0x0000 }, /* R19749 */ - { 0x0000, 0x0000, 0x0000 }, /* R19750 */ - { 0x0000, 0x0000, 0x0000 }, /* R19751 */ - { 0x0000, 0x0000, 0x0000 }, /* R19752 */ - { 0x0000, 0x0000, 0x0000 }, /* R19753 */ - { 0x0000, 0x0000, 0x0000 }, /* R19754 */ - { 0x0000, 0x0000, 0x0000 }, /* R19755 */ - { 0x0000, 0x0000, 0x0000 }, /* R19756 */ - { 0x0000, 0x0000, 0x0000 }, /* R19757 */ - { 0x0000, 0x0000, 0x0000 }, /* R19758 */ - { 0x0000, 0x0000, 0x0000 }, /* R19759 */ - { 0x0000, 0x0000, 0x0000 }, /* R19760 */ - { 0x0000, 0x0000, 0x0000 }, /* R19761 */ - { 0x0000, 0x0000, 0x0000 }, /* R19762 */ - { 0x0000, 0x0000, 0x0000 }, /* R19763 */ - { 0x0000, 0x0000, 0x0000 }, /* R19764 */ - { 0x0000, 0x0000, 0x0000 }, /* R19765 */ - { 0x0000, 0x0000, 0x0000 }, /* R19766 */ - { 0x0000, 0x0000, 0x0000 }, /* R19767 */ - { 0x0000, 0x0000, 0x0000 }, /* R19768 */ - { 0x0000, 0x0000, 0x0000 }, /* R19769 */ - { 0x0000, 0x0000, 0x0000 }, /* R19770 */ - { 0x0000, 0x0000, 0x0000 }, /* R19771 */ - { 0x0000, 0x0000, 0x0000 }, /* R19772 */ - { 0x0000, 0x0000, 0x0000 }, /* R19773 */ - { 0x0000, 0x0000, 0x0000 }, /* R19774 */ - { 0x0000, 0x0000, 0x0000 }, /* R19775 */ - { 0x0000, 0x0000, 0x0000 }, /* R19776 */ - { 0x0000, 0x0000, 0x0000 }, /* R19777 */ - { 0x0000, 0x0000, 0x0000 }, /* R19778 */ - { 0x0000, 0x0000, 0x0000 }, /* R19779 */ - { 0x0000, 0x0000, 0x0000 }, /* R19780 */ - { 0x0000, 0x0000, 0x0000 }, /* R19781 */ - { 0x0000, 0x0000, 0x0000 }, /* R19782 */ - { 0x0000, 0x0000, 0x0000 }, /* R19783 */ - { 0x0000, 0x0000, 0x0000 }, /* R19784 */ - { 0x0000, 0x0000, 0x0000 }, /* R19785 */ - { 0x0000, 0x0000, 0x0000 }, /* R19786 */ - { 0x0000, 0x0000, 0x0000 }, /* R19787 */ - { 0x0000, 0x0000, 0x0000 }, /* R19788 */ - { 0x0000, 0x0000, 0x0000 }, /* R19789 */ - { 0x0000, 0x0000, 0x0000 }, /* R19790 */ - { 0x0000, 0x0000, 0x0000 }, /* R19791 */ - { 0x0000, 0x0000, 0x0000 }, /* R19792 */ - { 0x0000, 0x0000, 0x0000 }, /* R19793 */ - { 0x0000, 0x0000, 0x0000 }, /* R19794 */ - { 0x0000, 0x0000, 0x0000 }, /* R19795 */ - { 0x0000, 0x0000, 0x0000 }, /* R19796 */ - { 0x0000, 0x0000, 0x0000 }, /* R19797 */ - { 0x0000, 0x0000, 0x0000 }, /* R19798 */ - { 0x0000, 0x0000, 0x0000 }, /* R19799 */ - { 0x0000, 0x0000, 0x0000 }, /* R19800 */ - { 0x0000, 0x0000, 0x0000 }, /* R19801 */ - { 0x0000, 0x0000, 0x0000 }, /* R19802 */ - { 0x0000, 0x0000, 0x0000 }, /* R19803 */ - { 0x0000, 0x0000, 0x0000 }, /* R19804 */ - { 0x0000, 0x0000, 0x0000 }, /* R19805 */ - { 0x0000, 0x0000, 0x0000 }, /* R19806 */ - { 0x0000, 0x0000, 0x0000 }, /* R19807 */ - { 0x0000, 0x0000, 0x0000 }, /* R19808 */ - { 0x0000, 0x0000, 0x0000 }, /* R19809 */ - { 0x0000, 0x0000, 0x0000 }, /* R19810 */ - { 0x0000, 0x0000, 0x0000 }, /* R19811 */ - { 0x0000, 0x0000, 0x0000 }, /* R19812 */ - { 0x0000, 0x0000, 0x0000 }, /* R19813 */ - { 0x0000, 0x0000, 0x0000 }, /* R19814 */ - { 0x0000, 0x0000, 0x0000 }, /* R19815 */ - { 0x0000, 0x0000, 0x0000 }, /* R19816 */ - { 0x0000, 0x0000, 0x0000 }, /* R19817 */ - { 0x0000, 0x0000, 0x0000 }, /* R19818 */ - { 0x0000, 0x0000, 0x0000 }, /* R19819 */ - { 0x0000, 0x0000, 0x0000 }, /* R19820 */ - { 0x0000, 0x0000, 0x0000 }, /* R19821 */ - { 0x0000, 0x0000, 0x0000 }, /* R19822 */ - { 0x0000, 0x0000, 0x0000 }, /* R19823 */ - { 0x0000, 0x0000, 0x0000 }, /* R19824 */ - { 0x0000, 0x0000, 0x0000 }, /* R19825 */ - { 0x0000, 0x0000, 0x0000 }, /* R19826 */ - { 0x0000, 0x0000, 0x0000 }, /* R19827 */ - { 0x0000, 0x0000, 0x0000 }, /* R19828 */ - { 0x0000, 0x0000, 0x0000 }, /* R19829 */ - { 0x0000, 0x0000, 0x0000 }, /* R19830 */ - { 0x0000, 0x0000, 0x0000 }, /* R19831 */ - { 0x0000, 0x0000, 0x0000 }, /* R19832 */ - { 0x0000, 0x0000, 0x0000 }, /* R19833 */ - { 0x0000, 0x0000, 0x0000 }, /* R19834 */ - { 0x0000, 0x0000, 0x0000 }, /* R19835 */ - { 0x0000, 0x0000, 0x0000 }, /* R19836 */ - { 0x0000, 0x0000, 0x0000 }, /* R19837 */ - { 0x0000, 0x0000, 0x0000 }, /* R19838 */ - { 0x0000, 0x0000, 0x0000 }, /* R19839 */ - { 0x0000, 0x0000, 0x0000 }, /* R19840 */ - { 0x0000, 0x0000, 0x0000 }, /* R19841 */ - { 0x0000, 0x0000, 0x0000 }, /* R19842 */ - { 0x0000, 0x0000, 0x0000 }, /* R19843 */ - { 0x0000, 0x0000, 0x0000 }, /* R19844 */ - { 0x0000, 0x0000, 0x0000 }, /* R19845 */ - { 0x0000, 0x0000, 0x0000 }, /* R19846 */ - { 0x0000, 0x0000, 0x0000 }, /* R19847 */ - { 0x0000, 0x0000, 0x0000 }, /* R19848 */ - { 0x0000, 0x0000, 0x0000 }, /* R19849 */ - { 0x0000, 0x0000, 0x0000 }, /* R19850 */ - { 0x0000, 0x0000, 0x0000 }, /* R19851 */ - { 0x0000, 0x0000, 0x0000 }, /* R19852 */ - { 0x0000, 0x0000, 0x0000 }, /* R19853 */ - { 0x0000, 0x0000, 0x0000 }, /* R19854 */ - { 0x0000, 0x0000, 0x0000 }, /* R19855 */ - { 0x0000, 0x0000, 0x0000 }, /* R19856 */ - { 0x0000, 0x0000, 0x0000 }, /* R19857 */ - { 0x0000, 0x0000, 0x0000 }, /* R19858 */ - { 0x0000, 0x0000, 0x0000 }, /* R19859 */ - { 0x0000, 0x0000, 0x0000 }, /* R19860 */ - { 0x0000, 0x0000, 0x0000 }, /* R19861 */ - { 0x0000, 0x0000, 0x0000 }, /* R19862 */ - { 0x0000, 0x0000, 0x0000 }, /* R19863 */ - { 0x0000, 0x0000, 0x0000 }, /* R19864 */ - { 0x0000, 0x0000, 0x0000 }, /* R19865 */ - { 0x0000, 0x0000, 0x0000 }, /* R19866 */ - { 0x0000, 0x0000, 0x0000 }, /* R19867 */ - { 0x0000, 0x0000, 0x0000 }, /* R19868 */ - { 0x0000, 0x0000, 0x0000 }, /* R19869 */ - { 0x0000, 0x0000, 0x0000 }, /* R19870 */ - { 0x0000, 0x0000, 0x0000 }, /* R19871 */ - { 0x0000, 0x0000, 0x0000 }, /* R19872 */ - { 0x0000, 0x0000, 0x0000 }, /* R19873 */ - { 0x0000, 0x0000, 0x0000 }, /* R19874 */ - { 0x0000, 0x0000, 0x0000 }, /* R19875 */ - { 0x0000, 0x0000, 0x0000 }, /* R19876 */ - { 0x0000, 0x0000, 0x0000 }, /* R19877 */ - { 0x0000, 0x0000, 0x0000 }, /* R19878 */ - { 0x0000, 0x0000, 0x0000 }, /* R19879 */ - { 0x0000, 0x0000, 0x0000 }, /* R19880 */ - { 0x0000, 0x0000, 0x0000 }, /* R19881 */ - { 0x0000, 0x0000, 0x0000 }, /* R19882 */ - { 0x0000, 0x0000, 0x0000 }, /* R19883 */ - { 0x0000, 0x0000, 0x0000 }, /* R19884 */ - { 0x0000, 0x0000, 0x0000 }, /* R19885 */ - { 0x0000, 0x0000, 0x0000 }, /* R19886 */ - { 0x0000, 0x0000, 0x0000 }, /* R19887 */ - { 0x0000, 0x0000, 0x0000 }, /* R19888 */ - { 0x0000, 0x0000, 0x0000 }, /* R19889 */ - { 0x0000, 0x0000, 0x0000 }, /* R19890 */ - { 0x0000, 0x0000, 0x0000 }, /* R19891 */ - { 0x0000, 0x0000, 0x0000 }, /* R19892 */ - { 0x0000, 0x0000, 0x0000 }, /* R19893 */ - { 0x0000, 0x0000, 0x0000 }, /* R19894 */ - { 0x0000, 0x0000, 0x0000 }, /* R19895 */ - { 0x0000, 0x0000, 0x0000 }, /* R19896 */ - { 0x0000, 0x0000, 0x0000 }, /* R19897 */ - { 0x0000, 0x0000, 0x0000 }, /* R19898 */ - { 0x0000, 0x0000, 0x0000 }, /* R19899 */ - { 0x0000, 0x0000, 0x0000 }, /* R19900 */ - { 0x0000, 0x0000, 0x0000 }, /* R19901 */ - { 0x0000, 0x0000, 0x0000 }, /* R19902 */ - { 0x0000, 0x0000, 0x0000 }, /* R19903 */ - { 0x0000, 0x0000, 0x0000 }, /* R19904 */ - { 0x0000, 0x0000, 0x0000 }, /* R19905 */ - { 0x0000, 0x0000, 0x0000 }, /* R19906 */ - { 0x0000, 0x0000, 0x0000 }, /* R19907 */ - { 0x0000, 0x0000, 0x0000 }, /* R19908 */ - { 0x0000, 0x0000, 0x0000 }, /* R19909 */ - { 0x0000, 0x0000, 0x0000 }, /* R19910 */ - { 0x0000, 0x0000, 0x0000 }, /* R19911 */ - { 0x0000, 0x0000, 0x0000 }, /* R19912 */ - { 0x0000, 0x0000, 0x0000 }, /* R19913 */ - { 0x0000, 0x0000, 0x0000 }, /* R19914 */ - { 0x0000, 0x0000, 0x0000 }, /* R19915 */ - { 0x0000, 0x0000, 0x0000 }, /* R19916 */ - { 0x0000, 0x0000, 0x0000 }, /* R19917 */ - { 0x0000, 0x0000, 0x0000 }, /* R19918 */ - { 0x0000, 0x0000, 0x0000 }, /* R19919 */ - { 0x0000, 0x0000, 0x0000 }, /* R19920 */ - { 0x0000, 0x0000, 0x0000 }, /* R19921 */ - { 0x0000, 0x0000, 0x0000 }, /* R19922 */ - { 0x0000, 0x0000, 0x0000 }, /* R19923 */ - { 0x0000, 0x0000, 0x0000 }, /* R19924 */ - { 0x0000, 0x0000, 0x0000 }, /* R19925 */ - { 0x0000, 0x0000, 0x0000 }, /* R19926 */ - { 0x0000, 0x0000, 0x0000 }, /* R19927 */ - { 0x0000, 0x0000, 0x0000 }, /* R19928 */ - { 0x0000, 0x0000, 0x0000 }, /* R19929 */ - { 0x0000, 0x0000, 0x0000 }, /* R19930 */ - { 0x0000, 0x0000, 0x0000 }, /* R19931 */ - { 0x0000, 0x0000, 0x0000 }, /* R19932 */ - { 0x0000, 0x0000, 0x0000 }, /* R19933 */ - { 0x0000, 0x0000, 0x0000 }, /* R19934 */ - { 0x0000, 0x0000, 0x0000 }, /* R19935 */ - { 0x0000, 0x0000, 0x0000 }, /* R19936 */ - { 0x0000, 0x0000, 0x0000 }, /* R19937 */ - { 0x0000, 0x0000, 0x0000 }, /* R19938 */ - { 0x0000, 0x0000, 0x0000 }, /* R19939 */ - { 0x0000, 0x0000, 0x0000 }, /* R19940 */ - { 0x0000, 0x0000, 0x0000 }, /* R19941 */ - { 0x0000, 0x0000, 0x0000 }, /* R19942 */ - { 0x0000, 0x0000, 0x0000 }, /* R19943 */ - { 0x0000, 0x0000, 0x0000 }, /* R19944 */ - { 0x0000, 0x0000, 0x0000 }, /* R19945 */ - { 0x0000, 0x0000, 0x0000 }, /* R19946 */ - { 0x0000, 0x0000, 0x0000 }, /* R19947 */ - { 0x0000, 0x0000, 0x0000 }, /* R19948 */ - { 0x0000, 0x0000, 0x0000 }, /* R19949 */ - { 0x0000, 0x0000, 0x0000 }, /* R19950 */ - { 0x0000, 0x0000, 0x0000 }, /* R19951 */ - { 0x0000, 0x0000, 0x0000 }, /* R19952 */ - { 0x0000, 0x0000, 0x0000 }, /* R19953 */ - { 0x0000, 0x0000, 0x0000 }, /* R19954 */ - { 0x0000, 0x0000, 0x0000 }, /* R19955 */ - { 0x0000, 0x0000, 0x0000 }, /* R19956 */ - { 0x0000, 0x0000, 0x0000 }, /* R19957 */ - { 0x0000, 0x0000, 0x0000 }, /* R19958 */ - { 0x0000, 0x0000, 0x0000 }, /* R19959 */ - { 0x0000, 0x0000, 0x0000 }, /* R19960 */ - { 0x0000, 0x0000, 0x0000 }, /* R19961 */ - { 0x0000, 0x0000, 0x0000 }, /* R19962 */ - { 0x0000, 0x0000, 0x0000 }, /* R19963 */ - { 0x0000, 0x0000, 0x0000 }, /* R19964 */ - { 0x0000, 0x0000, 0x0000 }, /* R19965 */ - { 0x0000, 0x0000, 0x0000 }, /* R19966 */ - { 0x0000, 0x0000, 0x0000 }, /* R19967 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19968 - RETUNEDAC_PG2_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19969 - RETUNEDAC_PG2_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R19970 - RETUNEDAC_PG_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R19971 - RETUNEDAC_PG_0 */ - { 0x0000, 0x0000, 0x0000 }, /* R19972 */ - { 0x0000, 0x0000, 0x0000 }, /* R19973 */ - { 0x0000, 0x0000, 0x0000 }, /* R19974 */ - { 0x0000, 0x0000, 0x0000 }, /* R19975 */ - { 0x0000, 0x0000, 0x0000 }, /* R19976 */ - { 0x0000, 0x0000, 0x0000 }, /* R19977 */ - { 0x0000, 0x0000, 0x0000 }, /* R19978 */ - { 0x0000, 0x0000, 0x0000 }, /* R19979 */ - { 0x0000, 0x0000, 0x0000 }, /* R19980 */ - { 0x0000, 0x0000, 0x0000 }, /* R19981 */ - { 0x0000, 0x0000, 0x0000 }, /* R19982 */ - { 0x0000, 0x0000, 0x0000 }, /* R19983 */ - { 0x0000, 0x0000, 0x0000 }, /* R19984 */ - { 0x0000, 0x0000, 0x0000 }, /* R19985 */ - { 0x0000, 0x0000, 0x0000 }, /* R19986 */ - { 0x0000, 0x0000, 0x0000 }, /* R19987 */ - { 0x0000, 0x0000, 0x0000 }, /* R19988 */ - { 0x0000, 0x0000, 0x0000 }, /* R19989 */ - { 0x0000, 0x0000, 0x0000 }, /* R19990 */ - { 0x0000, 0x0000, 0x0000 }, /* R19991 */ - { 0x0000, 0x0000, 0x0000 }, /* R19992 */ - { 0x0000, 0x0000, 0x0000 }, /* R19993 */ - { 0x0000, 0x0000, 0x0000 }, /* R19994 */ - { 0x0000, 0x0000, 0x0000 }, /* R19995 */ - { 0x0000, 0x0000, 0x0000 }, /* R19996 */ - { 0x0000, 0x0000, 0x0000 }, /* R19997 */ - { 0x0000, 0x0000, 0x0000 }, /* R19998 */ - { 0x0000, 0x0000, 0x0000 }, /* R19999 */ - { 0x0000, 0x0000, 0x0000 }, /* R20000 */ - { 0x0000, 0x0000, 0x0000 }, /* R20001 */ - { 0x0000, 0x0000, 0x0000 }, /* R20002 */ - { 0x0000, 0x0000, 0x0000 }, /* R20003 */ - { 0x0000, 0x0000, 0x0000 }, /* R20004 */ - { 0x0000, 0x0000, 0x0000 }, /* R20005 */ - { 0x0000, 0x0000, 0x0000 }, /* R20006 */ - { 0x0000, 0x0000, 0x0000 }, /* R20007 */ - { 0x0000, 0x0000, 0x0000 }, /* R20008 */ - { 0x0000, 0x0000, 0x0000 }, /* R20009 */ - { 0x0000, 0x0000, 0x0000 }, /* R20010 */ - { 0x0000, 0x0000, 0x0000 }, /* R20011 */ - { 0x0000, 0x0000, 0x0000 }, /* R20012 */ - { 0x0000, 0x0000, 0x0000 }, /* R20013 */ - { 0x0000, 0x0000, 0x0000 }, /* R20014 */ - { 0x0000, 0x0000, 0x0000 }, /* R20015 */ - { 0x0000, 0x0000, 0x0000 }, /* R20016 */ - { 0x0000, 0x0000, 0x0000 }, /* R20017 */ - { 0x0000, 0x0000, 0x0000 }, /* R20018 */ - { 0x0000, 0x0000, 0x0000 }, /* R20019 */ - { 0x0000, 0x0000, 0x0000 }, /* R20020 */ - { 0x0000, 0x0000, 0x0000 }, /* R20021 */ - { 0x0000, 0x0000, 0x0000 }, /* R20022 */ - { 0x0000, 0x0000, 0x0000 }, /* R20023 */ - { 0x0000, 0x0000, 0x0000 }, /* R20024 */ - { 0x0000, 0x0000, 0x0000 }, /* R20025 */ - { 0x0000, 0x0000, 0x0000 }, /* R20026 */ - { 0x0000, 0x0000, 0x0000 }, /* R20027 */ - { 0x0000, 0x0000, 0x0000 }, /* R20028 */ - { 0x0000, 0x0000, 0x0000 }, /* R20029 */ - { 0x0000, 0x0000, 0x0000 }, /* R20030 */ - { 0x0000, 0x0000, 0x0000 }, /* R20031 */ - { 0x0000, 0x0000, 0x0000 }, /* R20032 */ - { 0x0000, 0x0000, 0x0000 }, /* R20033 */ - { 0x0000, 0x0000, 0x0000 }, /* R20034 */ - { 0x0000, 0x0000, 0x0000 }, /* R20035 */ - { 0x0000, 0x0000, 0x0000 }, /* R20036 */ - { 0x0000, 0x0000, 0x0000 }, /* R20037 */ - { 0x0000, 0x0000, 0x0000 }, /* R20038 */ - { 0x0000, 0x0000, 0x0000 }, /* R20039 */ - { 0x0000, 0x0000, 0x0000 }, /* R20040 */ - { 0x0000, 0x0000, 0x0000 }, /* R20041 */ - { 0x0000, 0x0000, 0x0000 }, /* R20042 */ - { 0x0000, 0x0000, 0x0000 }, /* R20043 */ - { 0x0000, 0x0000, 0x0000 }, /* R20044 */ - { 0x0000, 0x0000, 0x0000 }, /* R20045 */ - { 0x0000, 0x0000, 0x0000 }, /* R20046 */ - { 0x0000, 0x0000, 0x0000 }, /* R20047 */ - { 0x0000, 0x0000, 0x0000 }, /* R20048 */ - { 0x0000, 0x0000, 0x0000 }, /* R20049 */ - { 0x0000, 0x0000, 0x0000 }, /* R20050 */ - { 0x0000, 0x0000, 0x0000 }, /* R20051 */ - { 0x0000, 0x0000, 0x0000 }, /* R20052 */ - { 0x0000, 0x0000, 0x0000 }, /* R20053 */ - { 0x0000, 0x0000, 0x0000 }, /* R20054 */ - { 0x0000, 0x0000, 0x0000 }, /* R20055 */ - { 0x0000, 0x0000, 0x0000 }, /* R20056 */ - { 0x0000, 0x0000, 0x0000 }, /* R20057 */ - { 0x0000, 0x0000, 0x0000 }, /* R20058 */ - { 0x0000, 0x0000, 0x0000 }, /* R20059 */ - { 0x0000, 0x0000, 0x0000 }, /* R20060 */ - { 0x0000, 0x0000, 0x0000 }, /* R20061 */ - { 0x0000, 0x0000, 0x0000 }, /* R20062 */ - { 0x0000, 0x0000, 0x0000 }, /* R20063 */ - { 0x0000, 0x0000, 0x0000 }, /* R20064 */ - { 0x0000, 0x0000, 0x0000 }, /* R20065 */ - { 0x0000, 0x0000, 0x0000 }, /* R20066 */ - { 0x0000, 0x0000, 0x0000 }, /* R20067 */ - { 0x0000, 0x0000, 0x0000 }, /* R20068 */ - { 0x0000, 0x0000, 0x0000 }, /* R20069 */ - { 0x0000, 0x0000, 0x0000 }, /* R20070 */ - { 0x0000, 0x0000, 0x0000 }, /* R20071 */ - { 0x0000, 0x0000, 0x0000 }, /* R20072 */ - { 0x0000, 0x0000, 0x0000 }, /* R20073 */ - { 0x0000, 0x0000, 0x0000 }, /* R20074 */ - { 0x0000, 0x0000, 0x0000 }, /* R20075 */ - { 0x0000, 0x0000, 0x0000 }, /* R20076 */ - { 0x0000, 0x0000, 0x0000 }, /* R20077 */ - { 0x0000, 0x0000, 0x0000 }, /* R20078 */ - { 0x0000, 0x0000, 0x0000 }, /* R20079 */ - { 0x0000, 0x0000, 0x0000 }, /* R20080 */ - { 0x0000, 0x0000, 0x0000 }, /* R20081 */ - { 0x0000, 0x0000, 0x0000 }, /* R20082 */ - { 0x0000, 0x0000, 0x0000 }, /* R20083 */ - { 0x0000, 0x0000, 0x0000 }, /* R20084 */ - { 0x0000, 0x0000, 0x0000 }, /* R20085 */ - { 0x0000, 0x0000, 0x0000 }, /* R20086 */ - { 0x0000, 0x0000, 0x0000 }, /* R20087 */ - { 0x0000, 0x0000, 0x0000 }, /* R20088 */ - { 0x0000, 0x0000, 0x0000 }, /* R20089 */ - { 0x0000, 0x0000, 0x0000 }, /* R20090 */ - { 0x0000, 0x0000, 0x0000 }, /* R20091 */ - { 0x0000, 0x0000, 0x0000 }, /* R20092 */ - { 0x0000, 0x0000, 0x0000 }, /* R20093 */ - { 0x0000, 0x0000, 0x0000 }, /* R20094 */ - { 0x0000, 0x0000, 0x0000 }, /* R20095 */ - { 0x0000, 0x0000, 0x0000 }, /* R20096 */ - { 0x0000, 0x0000, 0x0000 }, /* R20097 */ - { 0x0000, 0x0000, 0x0000 }, /* R20098 */ - { 0x0000, 0x0000, 0x0000 }, /* R20099 */ - { 0x0000, 0x0000, 0x0000 }, /* R20100 */ - { 0x0000, 0x0000, 0x0000 }, /* R20101 */ - { 0x0000, 0x0000, 0x0000 }, /* R20102 */ - { 0x0000, 0x0000, 0x0000 }, /* R20103 */ - { 0x0000, 0x0000, 0x0000 }, /* R20104 */ - { 0x0000, 0x0000, 0x0000 }, /* R20105 */ - { 0x0000, 0x0000, 0x0000 }, /* R20106 */ - { 0x0000, 0x0000, 0x0000 }, /* R20107 */ - { 0x0000, 0x0000, 0x0000 }, /* R20108 */ - { 0x0000, 0x0000, 0x0000 }, /* R20109 */ - { 0x0000, 0x0000, 0x0000 }, /* R20110 */ - { 0x0000, 0x0000, 0x0000 }, /* R20111 */ - { 0x0000, 0x0000, 0x0000 }, /* R20112 */ - { 0x0000, 0x0000, 0x0000 }, /* R20113 */ - { 0x0000, 0x0000, 0x0000 }, /* R20114 */ - { 0x0000, 0x0000, 0x0000 }, /* R20115 */ - { 0x0000, 0x0000, 0x0000 }, /* R20116 */ - { 0x0000, 0x0000, 0x0000 }, /* R20117 */ - { 0x0000, 0x0000, 0x0000 }, /* R20118 */ - { 0x0000, 0x0000, 0x0000 }, /* R20119 */ - { 0x0000, 0x0000, 0x0000 }, /* R20120 */ - { 0x0000, 0x0000, 0x0000 }, /* R20121 */ - { 0x0000, 0x0000, 0x0000 }, /* R20122 */ - { 0x0000, 0x0000, 0x0000 }, /* R20123 */ - { 0x0000, 0x0000, 0x0000 }, /* R20124 */ - { 0x0000, 0x0000, 0x0000 }, /* R20125 */ - { 0x0000, 0x0000, 0x0000 }, /* R20126 */ - { 0x0000, 0x0000, 0x0000 }, /* R20127 */ - { 0x0000, 0x0000, 0x0000 }, /* R20128 */ - { 0x0000, 0x0000, 0x0000 }, /* R20129 */ - { 0x0000, 0x0000, 0x0000 }, /* R20130 */ - { 0x0000, 0x0000, 0x0000 }, /* R20131 */ - { 0x0000, 0x0000, 0x0000 }, /* R20132 */ - { 0x0000, 0x0000, 0x0000 }, /* R20133 */ - { 0x0000, 0x0000, 0x0000 }, /* R20134 */ - { 0x0000, 0x0000, 0x0000 }, /* R20135 */ - { 0x0000, 0x0000, 0x0000 }, /* R20136 */ - { 0x0000, 0x0000, 0x0000 }, /* R20137 */ - { 0x0000, 0x0000, 0x0000 }, /* R20138 */ - { 0x0000, 0x0000, 0x0000 }, /* R20139 */ - { 0x0000, 0x0000, 0x0000 }, /* R20140 */ - { 0x0000, 0x0000, 0x0000 }, /* R20141 */ - { 0x0000, 0x0000, 0x0000 }, /* R20142 */ - { 0x0000, 0x0000, 0x0000 }, /* R20143 */ - { 0x0000, 0x0000, 0x0000 }, /* R20144 */ - { 0x0000, 0x0000, 0x0000 }, /* R20145 */ - { 0x0000, 0x0000, 0x0000 }, /* R20146 */ - { 0x0000, 0x0000, 0x0000 }, /* R20147 */ - { 0x0000, 0x0000, 0x0000 }, /* R20148 */ - { 0x0000, 0x0000, 0x0000 }, /* R20149 */ - { 0x0000, 0x0000, 0x0000 }, /* R20150 */ - { 0x0000, 0x0000, 0x0000 }, /* R20151 */ - { 0x0000, 0x0000, 0x0000 }, /* R20152 */ - { 0x0000, 0x0000, 0x0000 }, /* R20153 */ - { 0x0000, 0x0000, 0x0000 }, /* R20154 */ - { 0x0000, 0x0000, 0x0000 }, /* R20155 */ - { 0x0000, 0x0000, 0x0000 }, /* R20156 */ - { 0x0000, 0x0000, 0x0000 }, /* R20157 */ - { 0x0000, 0x0000, 0x0000 }, /* R20158 */ - { 0x0000, 0x0000, 0x0000 }, /* R20159 */ - { 0x0000, 0x0000, 0x0000 }, /* R20160 */ - { 0x0000, 0x0000, 0x0000 }, /* R20161 */ - { 0x0000, 0x0000, 0x0000 }, /* R20162 */ - { 0x0000, 0x0000, 0x0000 }, /* R20163 */ - { 0x0000, 0x0000, 0x0000 }, /* R20164 */ - { 0x0000, 0x0000, 0x0000 }, /* R20165 */ - { 0x0000, 0x0000, 0x0000 }, /* R20166 */ - { 0x0000, 0x0000, 0x0000 }, /* R20167 */ - { 0x0000, 0x0000, 0x0000 }, /* R20168 */ - { 0x0000, 0x0000, 0x0000 }, /* R20169 */ - { 0x0000, 0x0000, 0x0000 }, /* R20170 */ - { 0x0000, 0x0000, 0x0000 }, /* R20171 */ - { 0x0000, 0x0000, 0x0000 }, /* R20172 */ - { 0x0000, 0x0000, 0x0000 }, /* R20173 */ - { 0x0000, 0x0000, 0x0000 }, /* R20174 */ - { 0x0000, 0x0000, 0x0000 }, /* R20175 */ - { 0x0000, 0x0000, 0x0000 }, /* R20176 */ - { 0x0000, 0x0000, 0x0000 }, /* R20177 */ - { 0x0000, 0x0000, 0x0000 }, /* R20178 */ - { 0x0000, 0x0000, 0x0000 }, /* R20179 */ - { 0x0000, 0x0000, 0x0000 }, /* R20180 */ - { 0x0000, 0x0000, 0x0000 }, /* R20181 */ - { 0x0000, 0x0000, 0x0000 }, /* R20182 */ - { 0x0000, 0x0000, 0x0000 }, /* R20183 */ - { 0x0000, 0x0000, 0x0000 }, /* R20184 */ - { 0x0000, 0x0000, 0x0000 }, /* R20185 */ - { 0x0000, 0x0000, 0x0000 }, /* R20186 */ - { 0x0000, 0x0000, 0x0000 }, /* R20187 */ - { 0x0000, 0x0000, 0x0000 }, /* R20188 */ - { 0x0000, 0x0000, 0x0000 }, /* R20189 */ - { 0x0000, 0x0000, 0x0000 }, /* R20190 */ - { 0x0000, 0x0000, 0x0000 }, /* R20191 */ - { 0x0000, 0x0000, 0x0000 }, /* R20192 */ - { 0x0000, 0x0000, 0x0000 }, /* R20193 */ - { 0x0000, 0x0000, 0x0000 }, /* R20194 */ - { 0x0000, 0x0000, 0x0000 }, /* R20195 */ - { 0x0000, 0x0000, 0x0000 }, /* R20196 */ - { 0x0000, 0x0000, 0x0000 }, /* R20197 */ - { 0x0000, 0x0000, 0x0000 }, /* R20198 */ - { 0x0000, 0x0000, 0x0000 }, /* R20199 */ - { 0x0000, 0x0000, 0x0000 }, /* R20200 */ - { 0x0000, 0x0000, 0x0000 }, /* R20201 */ - { 0x0000, 0x0000, 0x0000 }, /* R20202 */ - { 0x0000, 0x0000, 0x0000 }, /* R20203 */ - { 0x0000, 0x0000, 0x0000 }, /* R20204 */ - { 0x0000, 0x0000, 0x0000 }, /* R20205 */ - { 0x0000, 0x0000, 0x0000 }, /* R20206 */ - { 0x0000, 0x0000, 0x0000 }, /* R20207 */ - { 0x0000, 0x0000, 0x0000 }, /* R20208 */ - { 0x0000, 0x0000, 0x0000 }, /* R20209 */ - { 0x0000, 0x0000, 0x0000 }, /* R20210 */ - { 0x0000, 0x0000, 0x0000 }, /* R20211 */ - { 0x0000, 0x0000, 0x0000 }, /* R20212 */ - { 0x0000, 0x0000, 0x0000 }, /* R20213 */ - { 0x0000, 0x0000, 0x0000 }, /* R20214 */ - { 0x0000, 0x0000, 0x0000 }, /* R20215 */ - { 0x0000, 0x0000, 0x0000 }, /* R20216 */ - { 0x0000, 0x0000, 0x0000 }, /* R20217 */ - { 0x0000, 0x0000, 0x0000 }, /* R20218 */ - { 0x0000, 0x0000, 0x0000 }, /* R20219 */ - { 0x0000, 0x0000, 0x0000 }, /* R20220 */ - { 0x0000, 0x0000, 0x0000 }, /* R20221 */ - { 0x0000, 0x0000, 0x0000 }, /* R20222 */ - { 0x0000, 0x0000, 0x0000 }, /* R20223 */ - { 0x0000, 0x0000, 0x0000 }, /* R20224 */ - { 0x0000, 0x0000, 0x0000 }, /* R20225 */ - { 0x0000, 0x0000, 0x0000 }, /* R20226 */ - { 0x0000, 0x0000, 0x0000 }, /* R20227 */ - { 0x0000, 0x0000, 0x0000 }, /* R20228 */ - { 0x0000, 0x0000, 0x0000 }, /* R20229 */ - { 0x0000, 0x0000, 0x0000 }, /* R20230 */ - { 0x0000, 0x0000, 0x0000 }, /* R20231 */ - { 0x0000, 0x0000, 0x0000 }, /* R20232 */ - { 0x0000, 0x0000, 0x0000 }, /* R20233 */ - { 0x0000, 0x0000, 0x0000 }, /* R20234 */ - { 0x0000, 0x0000, 0x0000 }, /* R20235 */ - { 0x0000, 0x0000, 0x0000 }, /* R20236 */ - { 0x0000, 0x0000, 0x0000 }, /* R20237 */ - { 0x0000, 0x0000, 0x0000 }, /* R20238 */ - { 0x0000, 0x0000, 0x0000 }, /* R20239 */ - { 0x0000, 0x0000, 0x0000 }, /* R20240 */ - { 0x0000, 0x0000, 0x0000 }, /* R20241 */ - { 0x0000, 0x0000, 0x0000 }, /* R20242 */ - { 0x0000, 0x0000, 0x0000 }, /* R20243 */ - { 0x0000, 0x0000, 0x0000 }, /* R20244 */ - { 0x0000, 0x0000, 0x0000 }, /* R20245 */ - { 0x0000, 0x0000, 0x0000 }, /* R20246 */ - { 0x0000, 0x0000, 0x0000 }, /* R20247 */ - { 0x0000, 0x0000, 0x0000 }, /* R20248 */ - { 0x0000, 0x0000, 0x0000 }, /* R20249 */ - { 0x0000, 0x0000, 0x0000 }, /* R20250 */ - { 0x0000, 0x0000, 0x0000 }, /* R20251 */ - { 0x0000, 0x0000, 0x0000 }, /* R20252 */ - { 0x0000, 0x0000, 0x0000 }, /* R20253 */ - { 0x0000, 0x0000, 0x0000 }, /* R20254 */ - { 0x0000, 0x0000, 0x0000 }, /* R20255 */ - { 0x0000, 0x0000, 0x0000 }, /* R20256 */ - { 0x0000, 0x0000, 0x0000 }, /* R20257 */ - { 0x0000, 0x0000, 0x0000 }, /* R20258 */ - { 0x0000, 0x0000, 0x0000 }, /* R20259 */ - { 0x0000, 0x0000, 0x0000 }, /* R20260 */ - { 0x0000, 0x0000, 0x0000 }, /* R20261 */ - { 0x0000, 0x0000, 0x0000 }, /* R20262 */ - { 0x0000, 0x0000, 0x0000 }, /* R20263 */ - { 0x0000, 0x0000, 0x0000 }, /* R20264 */ - { 0x0000, 0x0000, 0x0000 }, /* R20265 */ - { 0x0000, 0x0000, 0x0000 }, /* R20266 */ - { 0x0000, 0x0000, 0x0000 }, /* R20267 */ - { 0x0000, 0x0000, 0x0000 }, /* R20268 */ - { 0x0000, 0x0000, 0x0000 }, /* R20269 */ - { 0x0000, 0x0000, 0x0000 }, /* R20270 */ - { 0x0000, 0x0000, 0x0000 }, /* R20271 */ - { 0x0000, 0x0000, 0x0000 }, /* R20272 */ - { 0x0000, 0x0000, 0x0000 }, /* R20273 */ - { 0x0000, 0x0000, 0x0000 }, /* R20274 */ - { 0x0000, 0x0000, 0x0000 }, /* R20275 */ - { 0x0000, 0x0000, 0x0000 }, /* R20276 */ - { 0x0000, 0x0000, 0x0000 }, /* R20277 */ - { 0x0000, 0x0000, 0x0000 }, /* R20278 */ - { 0x0000, 0x0000, 0x0000 }, /* R20279 */ - { 0x0000, 0x0000, 0x0000 }, /* R20280 */ - { 0x0000, 0x0000, 0x0000 }, /* R20281 */ - { 0x0000, 0x0000, 0x0000 }, /* R20282 */ - { 0x0000, 0x0000, 0x0000 }, /* R20283 */ - { 0x0000, 0x0000, 0x0000 }, /* R20284 */ - { 0x0000, 0x0000, 0x0000 }, /* R20285 */ - { 0x0000, 0x0000, 0x0000 }, /* R20286 */ - { 0x0000, 0x0000, 0x0000 }, /* R20287 */ - { 0x0000, 0x0000, 0x0000 }, /* R20288 */ - { 0x0000, 0x0000, 0x0000 }, /* R20289 */ - { 0x0000, 0x0000, 0x0000 }, /* R20290 */ - { 0x0000, 0x0000, 0x0000 }, /* R20291 */ - { 0x0000, 0x0000, 0x0000 }, /* R20292 */ - { 0x0000, 0x0000, 0x0000 }, /* R20293 */ - { 0x0000, 0x0000, 0x0000 }, /* R20294 */ - { 0x0000, 0x0000, 0x0000 }, /* R20295 */ - { 0x0000, 0x0000, 0x0000 }, /* R20296 */ - { 0x0000, 0x0000, 0x0000 }, /* R20297 */ - { 0x0000, 0x0000, 0x0000 }, /* R20298 */ - { 0x0000, 0x0000, 0x0000 }, /* R20299 */ - { 0x0000, 0x0000, 0x0000 }, /* R20300 */ - { 0x0000, 0x0000, 0x0000 }, /* R20301 */ - { 0x0000, 0x0000, 0x0000 }, /* R20302 */ - { 0x0000, 0x0000, 0x0000 }, /* R20303 */ - { 0x0000, 0x0000, 0x0000 }, /* R20304 */ - { 0x0000, 0x0000, 0x0000 }, /* R20305 */ - { 0x0000, 0x0000, 0x0000 }, /* R20306 */ - { 0x0000, 0x0000, 0x0000 }, /* R20307 */ - { 0x0000, 0x0000, 0x0000 }, /* R20308 */ - { 0x0000, 0x0000, 0x0000 }, /* R20309 */ - { 0x0000, 0x0000, 0x0000 }, /* R20310 */ - { 0x0000, 0x0000, 0x0000 }, /* R20311 */ - { 0x0000, 0x0000, 0x0000 }, /* R20312 */ - { 0x0000, 0x0000, 0x0000 }, /* R20313 */ - { 0x0000, 0x0000, 0x0000 }, /* R20314 */ - { 0x0000, 0x0000, 0x0000 }, /* R20315 */ - { 0x0000, 0x0000, 0x0000 }, /* R20316 */ - { 0x0000, 0x0000, 0x0000 }, /* R20317 */ - { 0x0000, 0x0000, 0x0000 }, /* R20318 */ - { 0x0000, 0x0000, 0x0000 }, /* R20319 */ - { 0x0000, 0x0000, 0x0000 }, /* R20320 */ - { 0x0000, 0x0000, 0x0000 }, /* R20321 */ - { 0x0000, 0x0000, 0x0000 }, /* R20322 */ - { 0x0000, 0x0000, 0x0000 }, /* R20323 */ - { 0x0000, 0x0000, 0x0000 }, /* R20324 */ - { 0x0000, 0x0000, 0x0000 }, /* R20325 */ - { 0x0000, 0x0000, 0x0000 }, /* R20326 */ - { 0x0000, 0x0000, 0x0000 }, /* R20327 */ - { 0x0000, 0x0000, 0x0000 }, /* R20328 */ - { 0x0000, 0x0000, 0x0000 }, /* R20329 */ - { 0x0000, 0x0000, 0x0000 }, /* R20330 */ - { 0x0000, 0x0000, 0x0000 }, /* R20331 */ - { 0x0000, 0x0000, 0x0000 }, /* R20332 */ - { 0x0000, 0x0000, 0x0000 }, /* R20333 */ - { 0x0000, 0x0000, 0x0000 }, /* R20334 */ - { 0x0000, 0x0000, 0x0000 }, /* R20335 */ - { 0x0000, 0x0000, 0x0000 }, /* R20336 */ - { 0x0000, 0x0000, 0x0000 }, /* R20337 */ - { 0x0000, 0x0000, 0x0000 }, /* R20338 */ - { 0x0000, 0x0000, 0x0000 }, /* R20339 */ - { 0x0000, 0x0000, 0x0000 }, /* R20340 */ - { 0x0000, 0x0000, 0x0000 }, /* R20341 */ - { 0x0000, 0x0000, 0x0000 }, /* R20342 */ - { 0x0000, 0x0000, 0x0000 }, /* R20343 */ - { 0x0000, 0x0000, 0x0000 }, /* R20344 */ - { 0x0000, 0x0000, 0x0000 }, /* R20345 */ - { 0x0000, 0x0000, 0x0000 }, /* R20346 */ - { 0x0000, 0x0000, 0x0000 }, /* R20347 */ - { 0x0000, 0x0000, 0x0000 }, /* R20348 */ - { 0x0000, 0x0000, 0x0000 }, /* R20349 */ - { 0x0000, 0x0000, 0x0000 }, /* R20350 */ - { 0x0000, 0x0000, 0x0000 }, /* R20351 */ - { 0x0000, 0x0000, 0x0000 }, /* R20352 */ - { 0x0000, 0x0000, 0x0000 }, /* R20353 */ - { 0x0000, 0x0000, 0x0000 }, /* R20354 */ - { 0x0000, 0x0000, 0x0000 }, /* R20355 */ - { 0x0000, 0x0000, 0x0000 }, /* R20356 */ - { 0x0000, 0x0000, 0x0000 }, /* R20357 */ - { 0x0000, 0x0000, 0x0000 }, /* R20358 */ - { 0x0000, 0x0000, 0x0000 }, /* R20359 */ - { 0x0000, 0x0000, 0x0000 }, /* R20360 */ - { 0x0000, 0x0000, 0x0000 }, /* R20361 */ - { 0x0000, 0x0000, 0x0000 }, /* R20362 */ - { 0x0000, 0x0000, 0x0000 }, /* R20363 */ - { 0x0000, 0x0000, 0x0000 }, /* R20364 */ - { 0x0000, 0x0000, 0x0000 }, /* R20365 */ - { 0x0000, 0x0000, 0x0000 }, /* R20366 */ - { 0x0000, 0x0000, 0x0000 }, /* R20367 */ - { 0x0000, 0x0000, 0x0000 }, /* R20368 */ - { 0x0000, 0x0000, 0x0000 }, /* R20369 */ - { 0x0000, 0x0000, 0x0000 }, /* R20370 */ - { 0x0000, 0x0000, 0x0000 }, /* R20371 */ - { 0x0000, 0x0000, 0x0000 }, /* R20372 */ - { 0x0000, 0x0000, 0x0000 }, /* R20373 */ - { 0x0000, 0x0000, 0x0000 }, /* R20374 */ - { 0x0000, 0x0000, 0x0000 }, /* R20375 */ - { 0x0000, 0x0000, 0x0000 }, /* R20376 */ - { 0x0000, 0x0000, 0x0000 }, /* R20377 */ - { 0x0000, 0x0000, 0x0000 }, /* R20378 */ - { 0x0000, 0x0000, 0x0000 }, /* R20379 */ - { 0x0000, 0x0000, 0x0000 }, /* R20380 */ - { 0x0000, 0x0000, 0x0000 }, /* R20381 */ - { 0x0000, 0x0000, 0x0000 }, /* R20382 */ - { 0x0000, 0x0000, 0x0000 }, /* R20383 */ - { 0x0000, 0x0000, 0x0000 }, /* R20384 */ - { 0x0000, 0x0000, 0x0000 }, /* R20385 */ - { 0x0000, 0x0000, 0x0000 }, /* R20386 */ - { 0x0000, 0x0000, 0x0000 }, /* R20387 */ - { 0x0000, 0x0000, 0x0000 }, /* R20388 */ - { 0x0000, 0x0000, 0x0000 }, /* R20389 */ - { 0x0000, 0x0000, 0x0000 }, /* R20390 */ - { 0x0000, 0x0000, 0x0000 }, /* R20391 */ - { 0x0000, 0x0000, 0x0000 }, /* R20392 */ - { 0x0000, 0x0000, 0x0000 }, /* R20393 */ - { 0x0000, 0x0000, 0x0000 }, /* R20394 */ - { 0x0000, 0x0000, 0x0000 }, /* R20395 */ - { 0x0000, 0x0000, 0x0000 }, /* R20396 */ - { 0x0000, 0x0000, 0x0000 }, /* R20397 */ - { 0x0000, 0x0000, 0x0000 }, /* R20398 */ - { 0x0000, 0x0000, 0x0000 }, /* R20399 */ - { 0x0000, 0x0000, 0x0000 }, /* R20400 */ - { 0x0000, 0x0000, 0x0000 }, /* R20401 */ - { 0x0000, 0x0000, 0x0000 }, /* R20402 */ - { 0x0000, 0x0000, 0x0000 }, /* R20403 */ - { 0x0000, 0x0000, 0x0000 }, /* R20404 */ - { 0x0000, 0x0000, 0x0000 }, /* R20405 */ - { 0x0000, 0x0000, 0x0000 }, /* R20406 */ - { 0x0000, 0x0000, 0x0000 }, /* R20407 */ - { 0x0000, 0x0000, 0x0000 }, /* R20408 */ - { 0x0000, 0x0000, 0x0000 }, /* R20409 */ - { 0x0000, 0x0000, 0x0000 }, /* R20410 */ - { 0x0000, 0x0000, 0x0000 }, /* R20411 */ - { 0x0000, 0x0000, 0x0000 }, /* R20412 */ - { 0x0000, 0x0000, 0x0000 }, /* R20413 */ - { 0x0000, 0x0000, 0x0000 }, /* R20414 */ - { 0x0000, 0x0000, 0x0000 }, /* R20415 */ - { 0x0000, 0x0000, 0x0000 }, /* R20416 */ - { 0x0000, 0x0000, 0x0000 }, /* R20417 */ - { 0x0000, 0x0000, 0x0000 }, /* R20418 */ - { 0x0000, 0x0000, 0x0000 }, /* R20419 */ - { 0x0000, 0x0000, 0x0000 }, /* R20420 */ - { 0x0000, 0x0000, 0x0000 }, /* R20421 */ - { 0x0000, 0x0000, 0x0000 }, /* R20422 */ - { 0x0000, 0x0000, 0x0000 }, /* R20423 */ - { 0x0000, 0x0000, 0x0000 }, /* R20424 */ - { 0x0000, 0x0000, 0x0000 }, /* R20425 */ - { 0x0000, 0x0000, 0x0000 }, /* R20426 */ - { 0x0000, 0x0000, 0x0000 }, /* R20427 */ - { 0x0000, 0x0000, 0x0000 }, /* R20428 */ - { 0x0000, 0x0000, 0x0000 }, /* R20429 */ - { 0x0000, 0x0000, 0x0000 }, /* R20430 */ - { 0x0000, 0x0000, 0x0000 }, /* R20431 */ - { 0x0000, 0x0000, 0x0000 }, /* R20432 */ - { 0x0000, 0x0000, 0x0000 }, /* R20433 */ - { 0x0000, 0x0000, 0x0000 }, /* R20434 */ - { 0x0000, 0x0000, 0x0000 }, /* R20435 */ - { 0x0000, 0x0000, 0x0000 }, /* R20436 */ - { 0x0000, 0x0000, 0x0000 }, /* R20437 */ - { 0x0000, 0x0000, 0x0000 }, /* R20438 */ - { 0x0000, 0x0000, 0x0000 }, /* R20439 */ - { 0x0000, 0x0000, 0x0000 }, /* R20440 */ - { 0x0000, 0x0000, 0x0000 }, /* R20441 */ - { 0x0000, 0x0000, 0x0000 }, /* R20442 */ - { 0x0000, 0x0000, 0x0000 }, /* R20443 */ - { 0x0000, 0x0000, 0x0000 }, /* R20444 */ - { 0x0000, 0x0000, 0x0000 }, /* R20445 */ - { 0x0000, 0x0000, 0x0000 }, /* R20446 */ - { 0x0000, 0x0000, 0x0000 }, /* R20447 */ - { 0x0000, 0x0000, 0x0000 }, /* R20448 */ - { 0x0000, 0x0000, 0x0000 }, /* R20449 */ - { 0x0000, 0x0000, 0x0000 }, /* R20450 */ - { 0x0000, 0x0000, 0x0000 }, /* R20451 */ - { 0x0000, 0x0000, 0x0000 }, /* R20452 */ - { 0x0000, 0x0000, 0x0000 }, /* R20453 */ - { 0x0000, 0x0000, 0x0000 }, /* R20454 */ - { 0x0000, 0x0000, 0x0000 }, /* R20455 */ - { 0x0000, 0x0000, 0x0000 }, /* R20456 */ - { 0x0000, 0x0000, 0x0000 }, /* R20457 */ - { 0x0000, 0x0000, 0x0000 }, /* R20458 */ - { 0x0000, 0x0000, 0x0000 }, /* R20459 */ - { 0x0000, 0x0000, 0x0000 }, /* R20460 */ - { 0x0000, 0x0000, 0x0000 }, /* R20461 */ - { 0x0000, 0x0000, 0x0000 }, /* R20462 */ - { 0x0000, 0x0000, 0x0000 }, /* R20463 */ - { 0x0000, 0x0000, 0x0000 }, /* R20464 */ - { 0x0000, 0x0000, 0x0000 }, /* R20465 */ - { 0x0000, 0x0000, 0x0000 }, /* R20466 */ - { 0x0000, 0x0000, 0x0000 }, /* R20467 */ - { 0x0000, 0x0000, 0x0000 }, /* R20468 */ - { 0x0000, 0x0000, 0x0000 }, /* R20469 */ - { 0x0000, 0x0000, 0x0000 }, /* R20470 */ - { 0x0000, 0x0000, 0x0000 }, /* R20471 */ - { 0x0000, 0x0000, 0x0000 }, /* R20472 */ - { 0x0000, 0x0000, 0x0000 }, /* R20473 */ - { 0x0000, 0x0000, 0x0000 }, /* R20474 */ - { 0x0000, 0x0000, 0x0000 }, /* R20475 */ - { 0x0000, 0x0000, 0x0000 }, /* R20476 */ - { 0x0000, 0x0000, 0x0000 }, /* R20477 */ - { 0x0000, 0x0000, 0x0000 }, /* R20478 */ - { 0x0000, 0x0000, 0x0000 }, /* R20479 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20480 - DACR_RETUNE_C1_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20481 - DACR_RETUNE_C1_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20482 - DACR_RETUNE_C2_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20483 - DACR_RETUNE_C2_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20484 - DACR_RETUNE_C3_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20485 - DACR_RETUNE_C3_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20486 - DACR_RETUNE_C4_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20487 - DACR_RETUNE_C4_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20488 - DACR_RETUNE_C5_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20489 - DACR_RETUNE_C5_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20490 - DACR_RETUNE_C6_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20491 - DACR_RETUNE_C6_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20492 - DACR_RETUNE_C7_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20493 - DACR_RETUNE_C7_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20494 - DACR_RETUNE_C8_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20495 - DACR_RETUNE_C8_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20496 - DACR_RETUNE_C9_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20497 - DACR_RETUNE_C9_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20498 - DACR_RETUNE_C10_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20499 - DACR_RETUNE_C10_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20500 - DACR_RETUNE_C11_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20501 - DACR_RETUNE_C11_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20502 - DACR_RETUNE_C12_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20503 - DACR_RETUNE_C12_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20504 - DACR_RETUNE_C13_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20505 - DACR_RETUNE_C13_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20506 - DACR_RETUNE_C14_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20507 - DACR_RETUNE_C14_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20508 - DACR_RETUNE_C15_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20509 - DACR_RETUNE_C15_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20510 - DACR_RETUNE_C16_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20511 - DACR_RETUNE_C16_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20512 - DACR_RETUNE_C17_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20513 - DACR_RETUNE_C17_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20514 - DACR_RETUNE_C18_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20515 - DACR_RETUNE_C18_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20516 - DACR_RETUNE_C19_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20517 - DACR_RETUNE_C19_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20518 - DACR_RETUNE_C20_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20519 - DACR_RETUNE_C20_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20520 - DACR_RETUNE_C21_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20521 - DACR_RETUNE_C21_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20522 - DACR_RETUNE_C22_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20523 - DACR_RETUNE_C22_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20524 - DACR_RETUNE_C23_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20525 - DACR_RETUNE_C23_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20526 - DACR_RETUNE_C24_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20527 - DACR_RETUNE_C24_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20528 - DACR_RETUNE_C25_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20529 - DACR_RETUNE_C25_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20530 - DACR_RETUNE_C26_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20531 - DACR_RETUNE_C26_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20532 - DACR_RETUNE_C27_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20533 - DACR_RETUNE_C27_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20534 - DACR_RETUNE_C28_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20535 - DACR_RETUNE_C28_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20536 - DACR_RETUNE_C29_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20537 - DACR_RETUNE_C29_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20538 - DACR_RETUNE_C30_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20539 - DACR_RETUNE_C30_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20540 - DACR_RETUNE_C31_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20541 - DACR_RETUNE_C31_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20542 - DACR_RETUNE_C32_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20543 - DACR_RETUNE_C32_0 */ - { 0x0000, 0x0000, 0x0000 }, /* R20544 */ - { 0x0000, 0x0000, 0x0000 }, /* R20545 */ - { 0x0000, 0x0000, 0x0000 }, /* R20546 */ - { 0x0000, 0x0000, 0x0000 }, /* R20547 */ - { 0x0000, 0x0000, 0x0000 }, /* R20548 */ - { 0x0000, 0x0000, 0x0000 }, /* R20549 */ - { 0x0000, 0x0000, 0x0000 }, /* R20550 */ - { 0x0000, 0x0000, 0x0000 }, /* R20551 */ - { 0x0000, 0x0000, 0x0000 }, /* R20552 */ - { 0x0000, 0x0000, 0x0000 }, /* R20553 */ - { 0x0000, 0x0000, 0x0000 }, /* R20554 */ - { 0x0000, 0x0000, 0x0000 }, /* R20555 */ - { 0x0000, 0x0000, 0x0000 }, /* R20556 */ - { 0x0000, 0x0000, 0x0000 }, /* R20557 */ - { 0x0000, 0x0000, 0x0000 }, /* R20558 */ - { 0x0000, 0x0000, 0x0000 }, /* R20559 */ - { 0x0000, 0x0000, 0x0000 }, /* R20560 */ - { 0x0000, 0x0000, 0x0000 }, /* R20561 */ - { 0x0000, 0x0000, 0x0000 }, /* R20562 */ - { 0x0000, 0x0000, 0x0000 }, /* R20563 */ - { 0x0000, 0x0000, 0x0000 }, /* R20564 */ - { 0x0000, 0x0000, 0x0000 }, /* R20565 */ - { 0x0000, 0x0000, 0x0000 }, /* R20566 */ - { 0x0000, 0x0000, 0x0000 }, /* R20567 */ - { 0x0000, 0x0000, 0x0000 }, /* R20568 */ - { 0x0000, 0x0000, 0x0000 }, /* R20569 */ - { 0x0000, 0x0000, 0x0000 }, /* R20570 */ - { 0x0000, 0x0000, 0x0000 }, /* R20571 */ - { 0x0000, 0x0000, 0x0000 }, /* R20572 */ - { 0x0000, 0x0000, 0x0000 }, /* R20573 */ - { 0x0000, 0x0000, 0x0000 }, /* R20574 */ - { 0x0000, 0x0000, 0x0000 }, /* R20575 */ - { 0x0000, 0x0000, 0x0000 }, /* R20576 */ - { 0x0000, 0x0000, 0x0000 }, /* R20577 */ - { 0x0000, 0x0000, 0x0000 }, /* R20578 */ - { 0x0000, 0x0000, 0x0000 }, /* R20579 */ - { 0x0000, 0x0000, 0x0000 }, /* R20580 */ - { 0x0000, 0x0000, 0x0000 }, /* R20581 */ - { 0x0000, 0x0000, 0x0000 }, /* R20582 */ - { 0x0000, 0x0000, 0x0000 }, /* R20583 */ - { 0x0000, 0x0000, 0x0000 }, /* R20584 */ - { 0x0000, 0x0000, 0x0000 }, /* R20585 */ - { 0x0000, 0x0000, 0x0000 }, /* R20586 */ - { 0x0000, 0x0000, 0x0000 }, /* R20587 */ - { 0x0000, 0x0000, 0x0000 }, /* R20588 */ - { 0x0000, 0x0000, 0x0000 }, /* R20589 */ - { 0x0000, 0x0000, 0x0000 }, /* R20590 */ - { 0x0000, 0x0000, 0x0000 }, /* R20591 */ - { 0x0000, 0x0000, 0x0000 }, /* R20592 */ - { 0x0000, 0x0000, 0x0000 }, /* R20593 */ - { 0x0000, 0x0000, 0x0000 }, /* R20594 */ - { 0x0000, 0x0000, 0x0000 }, /* R20595 */ - { 0x0000, 0x0000, 0x0000 }, /* R20596 */ - { 0x0000, 0x0000, 0x0000 }, /* R20597 */ - { 0x0000, 0x0000, 0x0000 }, /* R20598 */ - { 0x0000, 0x0000, 0x0000 }, /* R20599 */ - { 0x0000, 0x0000, 0x0000 }, /* R20600 */ - { 0x0000, 0x0000, 0x0000 }, /* R20601 */ - { 0x0000, 0x0000, 0x0000 }, /* R20602 */ - { 0x0000, 0x0000, 0x0000 }, /* R20603 */ - { 0x0000, 0x0000, 0x0000 }, /* R20604 */ - { 0x0000, 0x0000, 0x0000 }, /* R20605 */ - { 0x0000, 0x0000, 0x0000 }, /* R20606 */ - { 0x0000, 0x0000, 0x0000 }, /* R20607 */ - { 0x0000, 0x0000, 0x0000 }, /* R20608 */ - { 0x0000, 0x0000, 0x0000 }, /* R20609 */ - { 0x0000, 0x0000, 0x0000 }, /* R20610 */ - { 0x0000, 0x0000, 0x0000 }, /* R20611 */ - { 0x0000, 0x0000, 0x0000 }, /* R20612 */ - { 0x0000, 0x0000, 0x0000 }, /* R20613 */ - { 0x0000, 0x0000, 0x0000 }, /* R20614 */ - { 0x0000, 0x0000, 0x0000 }, /* R20615 */ - { 0x0000, 0x0000, 0x0000 }, /* R20616 */ - { 0x0000, 0x0000, 0x0000 }, /* R20617 */ - { 0x0000, 0x0000, 0x0000 }, /* R20618 */ - { 0x0000, 0x0000, 0x0000 }, /* R20619 */ - { 0x0000, 0x0000, 0x0000 }, /* R20620 */ - { 0x0000, 0x0000, 0x0000 }, /* R20621 */ - { 0x0000, 0x0000, 0x0000 }, /* R20622 */ - { 0x0000, 0x0000, 0x0000 }, /* R20623 */ - { 0x0000, 0x0000, 0x0000 }, /* R20624 */ - { 0x0000, 0x0000, 0x0000 }, /* R20625 */ - { 0x0000, 0x0000, 0x0000 }, /* R20626 */ - { 0x0000, 0x0000, 0x0000 }, /* R20627 */ - { 0x0000, 0x0000, 0x0000 }, /* R20628 */ - { 0x0000, 0x0000, 0x0000 }, /* R20629 */ - { 0x0000, 0x0000, 0x0000 }, /* R20630 */ - { 0x0000, 0x0000, 0x0000 }, /* R20631 */ - { 0x0000, 0x0000, 0x0000 }, /* R20632 */ - { 0x0000, 0x0000, 0x0000 }, /* R20633 */ - { 0x0000, 0x0000, 0x0000 }, /* R20634 */ - { 0x0000, 0x0000, 0x0000 }, /* R20635 */ - { 0x0000, 0x0000, 0x0000 }, /* R20636 */ - { 0x0000, 0x0000, 0x0000 }, /* R20637 */ - { 0x0000, 0x0000, 0x0000 }, /* R20638 */ - { 0x0000, 0x0000, 0x0000 }, /* R20639 */ - { 0x0000, 0x0000, 0x0000 }, /* R20640 */ - { 0x0000, 0x0000, 0x0000 }, /* R20641 */ - { 0x0000, 0x0000, 0x0000 }, /* R20642 */ - { 0x0000, 0x0000, 0x0000 }, /* R20643 */ - { 0x0000, 0x0000, 0x0000 }, /* R20644 */ - { 0x0000, 0x0000, 0x0000 }, /* R20645 */ - { 0x0000, 0x0000, 0x0000 }, /* R20646 */ - { 0x0000, 0x0000, 0x0000 }, /* R20647 */ - { 0x0000, 0x0000, 0x0000 }, /* R20648 */ - { 0x0000, 0x0000, 0x0000 }, /* R20649 */ - { 0x0000, 0x0000, 0x0000 }, /* R20650 */ - { 0x0000, 0x0000, 0x0000 }, /* R20651 */ - { 0x0000, 0x0000, 0x0000 }, /* R20652 */ - { 0x0000, 0x0000, 0x0000 }, /* R20653 */ - { 0x0000, 0x0000, 0x0000 }, /* R20654 */ - { 0x0000, 0x0000, 0x0000 }, /* R20655 */ - { 0x0000, 0x0000, 0x0000 }, /* R20656 */ - { 0x0000, 0x0000, 0x0000 }, /* R20657 */ - { 0x0000, 0x0000, 0x0000 }, /* R20658 */ - { 0x0000, 0x0000, 0x0000 }, /* R20659 */ - { 0x0000, 0x0000, 0x0000 }, /* R20660 */ - { 0x0000, 0x0000, 0x0000 }, /* R20661 */ - { 0x0000, 0x0000, 0x0000 }, /* R20662 */ - { 0x0000, 0x0000, 0x0000 }, /* R20663 */ - { 0x0000, 0x0000, 0x0000 }, /* R20664 */ - { 0x0000, 0x0000, 0x0000 }, /* R20665 */ - { 0x0000, 0x0000, 0x0000 }, /* R20666 */ - { 0x0000, 0x0000, 0x0000 }, /* R20667 */ - { 0x0000, 0x0000, 0x0000 }, /* R20668 */ - { 0x0000, 0x0000, 0x0000 }, /* R20669 */ - { 0x0000, 0x0000, 0x0000 }, /* R20670 */ - { 0x0000, 0x0000, 0x0000 }, /* R20671 */ - { 0x0000, 0x0000, 0x0000 }, /* R20672 */ - { 0x0000, 0x0000, 0x0000 }, /* R20673 */ - { 0x0000, 0x0000, 0x0000 }, /* R20674 */ - { 0x0000, 0x0000, 0x0000 }, /* R20675 */ - { 0x0000, 0x0000, 0x0000 }, /* R20676 */ - { 0x0000, 0x0000, 0x0000 }, /* R20677 */ - { 0x0000, 0x0000, 0x0000 }, /* R20678 */ - { 0x0000, 0x0000, 0x0000 }, /* R20679 */ - { 0x0000, 0x0000, 0x0000 }, /* R20680 */ - { 0x0000, 0x0000, 0x0000 }, /* R20681 */ - { 0x0000, 0x0000, 0x0000 }, /* R20682 */ - { 0x0000, 0x0000, 0x0000 }, /* R20683 */ - { 0x0000, 0x0000, 0x0000 }, /* R20684 */ - { 0x0000, 0x0000, 0x0000 }, /* R20685 */ - { 0x0000, 0x0000, 0x0000 }, /* R20686 */ - { 0x0000, 0x0000, 0x0000 }, /* R20687 */ - { 0x0000, 0x0000, 0x0000 }, /* R20688 */ - { 0x0000, 0x0000, 0x0000 }, /* R20689 */ - { 0x0000, 0x0000, 0x0000 }, /* R20690 */ - { 0x0000, 0x0000, 0x0000 }, /* R20691 */ - { 0x0000, 0x0000, 0x0000 }, /* R20692 */ - { 0x0000, 0x0000, 0x0000 }, /* R20693 */ - { 0x0000, 0x0000, 0x0000 }, /* R20694 */ - { 0x0000, 0x0000, 0x0000 }, /* R20695 */ - { 0x0000, 0x0000, 0x0000 }, /* R20696 */ - { 0x0000, 0x0000, 0x0000 }, /* R20697 */ - { 0x0000, 0x0000, 0x0000 }, /* R20698 */ - { 0x0000, 0x0000, 0x0000 }, /* R20699 */ - { 0x0000, 0x0000, 0x0000 }, /* R20700 */ - { 0x0000, 0x0000, 0x0000 }, /* R20701 */ - { 0x0000, 0x0000, 0x0000 }, /* R20702 */ - { 0x0000, 0x0000, 0x0000 }, /* R20703 */ - { 0x0000, 0x0000, 0x0000 }, /* R20704 */ - { 0x0000, 0x0000, 0x0000 }, /* R20705 */ - { 0x0000, 0x0000, 0x0000 }, /* R20706 */ - { 0x0000, 0x0000, 0x0000 }, /* R20707 */ - { 0x0000, 0x0000, 0x0000 }, /* R20708 */ - { 0x0000, 0x0000, 0x0000 }, /* R20709 */ - { 0x0000, 0x0000, 0x0000 }, /* R20710 */ - { 0x0000, 0x0000, 0x0000 }, /* R20711 */ - { 0x0000, 0x0000, 0x0000 }, /* R20712 */ - { 0x0000, 0x0000, 0x0000 }, /* R20713 */ - { 0x0000, 0x0000, 0x0000 }, /* R20714 */ - { 0x0000, 0x0000, 0x0000 }, /* R20715 */ - { 0x0000, 0x0000, 0x0000 }, /* R20716 */ - { 0x0000, 0x0000, 0x0000 }, /* R20717 */ - { 0x0000, 0x0000, 0x0000 }, /* R20718 */ - { 0x0000, 0x0000, 0x0000 }, /* R20719 */ - { 0x0000, 0x0000, 0x0000 }, /* R20720 */ - { 0x0000, 0x0000, 0x0000 }, /* R20721 */ - { 0x0000, 0x0000, 0x0000 }, /* R20722 */ - { 0x0000, 0x0000, 0x0000 }, /* R20723 */ - { 0x0000, 0x0000, 0x0000 }, /* R20724 */ - { 0x0000, 0x0000, 0x0000 }, /* R20725 */ - { 0x0000, 0x0000, 0x0000 }, /* R20726 */ - { 0x0000, 0x0000, 0x0000 }, /* R20727 */ - { 0x0000, 0x0000, 0x0000 }, /* R20728 */ - { 0x0000, 0x0000, 0x0000 }, /* R20729 */ - { 0x0000, 0x0000, 0x0000 }, /* R20730 */ - { 0x0000, 0x0000, 0x0000 }, /* R20731 */ - { 0x0000, 0x0000, 0x0000 }, /* R20732 */ - { 0x0000, 0x0000, 0x0000 }, /* R20733 */ - { 0x0000, 0x0000, 0x0000 }, /* R20734 */ - { 0x0000, 0x0000, 0x0000 }, /* R20735 */ - { 0x0000, 0x0000, 0x0000 }, /* R20736 */ - { 0x0000, 0x0000, 0x0000 }, /* R20737 */ - { 0x0000, 0x0000, 0x0000 }, /* R20738 */ - { 0x0000, 0x0000, 0x0000 }, /* R20739 */ - { 0x0000, 0x0000, 0x0000 }, /* R20740 */ - { 0x0000, 0x0000, 0x0000 }, /* R20741 */ - { 0x0000, 0x0000, 0x0000 }, /* R20742 */ - { 0x0000, 0x0000, 0x0000 }, /* R20743 */ - { 0x0000, 0x0000, 0x0000 }, /* R20744 */ - { 0x0000, 0x0000, 0x0000 }, /* R20745 */ - { 0x0000, 0x0000, 0x0000 }, /* R20746 */ - { 0x0000, 0x0000, 0x0000 }, /* R20747 */ - { 0x0000, 0x0000, 0x0000 }, /* R20748 */ - { 0x0000, 0x0000, 0x0000 }, /* R20749 */ - { 0x0000, 0x0000, 0x0000 }, /* R20750 */ - { 0x0000, 0x0000, 0x0000 }, /* R20751 */ - { 0x0000, 0x0000, 0x0000 }, /* R20752 */ - { 0x0000, 0x0000, 0x0000 }, /* R20753 */ - { 0x0000, 0x0000, 0x0000 }, /* R20754 */ - { 0x0000, 0x0000, 0x0000 }, /* R20755 */ - { 0x0000, 0x0000, 0x0000 }, /* R20756 */ - { 0x0000, 0x0000, 0x0000 }, /* R20757 */ - { 0x0000, 0x0000, 0x0000 }, /* R20758 */ - { 0x0000, 0x0000, 0x0000 }, /* R20759 */ - { 0x0000, 0x0000, 0x0000 }, /* R20760 */ - { 0x0000, 0x0000, 0x0000 }, /* R20761 */ - { 0x0000, 0x0000, 0x0000 }, /* R20762 */ - { 0x0000, 0x0000, 0x0000 }, /* R20763 */ - { 0x0000, 0x0000, 0x0000 }, /* R20764 */ - { 0x0000, 0x0000, 0x0000 }, /* R20765 */ - { 0x0000, 0x0000, 0x0000 }, /* R20766 */ - { 0x0000, 0x0000, 0x0000 }, /* R20767 */ - { 0x0000, 0x0000, 0x0000 }, /* R20768 */ - { 0x0000, 0x0000, 0x0000 }, /* R20769 */ - { 0x0000, 0x0000, 0x0000 }, /* R20770 */ - { 0x0000, 0x0000, 0x0000 }, /* R20771 */ - { 0x0000, 0x0000, 0x0000 }, /* R20772 */ - { 0x0000, 0x0000, 0x0000 }, /* R20773 */ - { 0x0000, 0x0000, 0x0000 }, /* R20774 */ - { 0x0000, 0x0000, 0x0000 }, /* R20775 */ - { 0x0000, 0x0000, 0x0000 }, /* R20776 */ - { 0x0000, 0x0000, 0x0000 }, /* R20777 */ - { 0x0000, 0x0000, 0x0000 }, /* R20778 */ - { 0x0000, 0x0000, 0x0000 }, /* R20779 */ - { 0x0000, 0x0000, 0x0000 }, /* R20780 */ - { 0x0000, 0x0000, 0x0000 }, /* R20781 */ - { 0x0000, 0x0000, 0x0000 }, /* R20782 */ - { 0x0000, 0x0000, 0x0000 }, /* R20783 */ - { 0x0000, 0x0000, 0x0000 }, /* R20784 */ - { 0x0000, 0x0000, 0x0000 }, /* R20785 */ - { 0x0000, 0x0000, 0x0000 }, /* R20786 */ - { 0x0000, 0x0000, 0x0000 }, /* R20787 */ - { 0x0000, 0x0000, 0x0000 }, /* R20788 */ - { 0x0000, 0x0000, 0x0000 }, /* R20789 */ - { 0x0000, 0x0000, 0x0000 }, /* R20790 */ - { 0x0000, 0x0000, 0x0000 }, /* R20791 */ - { 0x0000, 0x0000, 0x0000 }, /* R20792 */ - { 0x0000, 0x0000, 0x0000 }, /* R20793 */ - { 0x0000, 0x0000, 0x0000 }, /* R20794 */ - { 0x0000, 0x0000, 0x0000 }, /* R20795 */ - { 0x0000, 0x0000, 0x0000 }, /* R20796 */ - { 0x0000, 0x0000, 0x0000 }, /* R20797 */ - { 0x0000, 0x0000, 0x0000 }, /* R20798 */ - { 0x0000, 0x0000, 0x0000 }, /* R20799 */ - { 0x0000, 0x0000, 0x0000 }, /* R20800 */ - { 0x0000, 0x0000, 0x0000 }, /* R20801 */ - { 0x0000, 0x0000, 0x0000 }, /* R20802 */ - { 0x0000, 0x0000, 0x0000 }, /* R20803 */ - { 0x0000, 0x0000, 0x0000 }, /* R20804 */ - { 0x0000, 0x0000, 0x0000 }, /* R20805 */ - { 0x0000, 0x0000, 0x0000 }, /* R20806 */ - { 0x0000, 0x0000, 0x0000 }, /* R20807 */ - { 0x0000, 0x0000, 0x0000 }, /* R20808 */ - { 0x0000, 0x0000, 0x0000 }, /* R20809 */ - { 0x0000, 0x0000, 0x0000 }, /* R20810 */ - { 0x0000, 0x0000, 0x0000 }, /* R20811 */ - { 0x0000, 0x0000, 0x0000 }, /* R20812 */ - { 0x0000, 0x0000, 0x0000 }, /* R20813 */ - { 0x0000, 0x0000, 0x0000 }, /* R20814 */ - { 0x0000, 0x0000, 0x0000 }, /* R20815 */ - { 0x0000, 0x0000, 0x0000 }, /* R20816 */ - { 0x0000, 0x0000, 0x0000 }, /* R20817 */ - { 0x0000, 0x0000, 0x0000 }, /* R20818 */ - { 0x0000, 0x0000, 0x0000 }, /* R20819 */ - { 0x0000, 0x0000, 0x0000 }, /* R20820 */ - { 0x0000, 0x0000, 0x0000 }, /* R20821 */ - { 0x0000, 0x0000, 0x0000 }, /* R20822 */ - { 0x0000, 0x0000, 0x0000 }, /* R20823 */ - { 0x0000, 0x0000, 0x0000 }, /* R20824 */ - { 0x0000, 0x0000, 0x0000 }, /* R20825 */ - { 0x0000, 0x0000, 0x0000 }, /* R20826 */ - { 0x0000, 0x0000, 0x0000 }, /* R20827 */ - { 0x0000, 0x0000, 0x0000 }, /* R20828 */ - { 0x0000, 0x0000, 0x0000 }, /* R20829 */ - { 0x0000, 0x0000, 0x0000 }, /* R20830 */ - { 0x0000, 0x0000, 0x0000 }, /* R20831 */ - { 0x0000, 0x0000, 0x0000 }, /* R20832 */ - { 0x0000, 0x0000, 0x0000 }, /* R20833 */ - { 0x0000, 0x0000, 0x0000 }, /* R20834 */ - { 0x0000, 0x0000, 0x0000 }, /* R20835 */ - { 0x0000, 0x0000, 0x0000 }, /* R20836 */ - { 0x0000, 0x0000, 0x0000 }, /* R20837 */ - { 0x0000, 0x0000, 0x0000 }, /* R20838 */ - { 0x0000, 0x0000, 0x0000 }, /* R20839 */ - { 0x0000, 0x0000, 0x0000 }, /* R20840 */ - { 0x0000, 0x0000, 0x0000 }, /* R20841 */ - { 0x0000, 0x0000, 0x0000 }, /* R20842 */ - { 0x0000, 0x0000, 0x0000 }, /* R20843 */ - { 0x0000, 0x0000, 0x0000 }, /* R20844 */ - { 0x0000, 0x0000, 0x0000 }, /* R20845 */ - { 0x0000, 0x0000, 0x0000 }, /* R20846 */ - { 0x0000, 0x0000, 0x0000 }, /* R20847 */ - { 0x0000, 0x0000, 0x0000 }, /* R20848 */ - { 0x0000, 0x0000, 0x0000 }, /* R20849 */ - { 0x0000, 0x0000, 0x0000 }, /* R20850 */ - { 0x0000, 0x0000, 0x0000 }, /* R20851 */ - { 0x0000, 0x0000, 0x0000 }, /* R20852 */ - { 0x0000, 0x0000, 0x0000 }, /* R20853 */ - { 0x0000, 0x0000, 0x0000 }, /* R20854 */ - { 0x0000, 0x0000, 0x0000 }, /* R20855 */ - { 0x0000, 0x0000, 0x0000 }, /* R20856 */ - { 0x0000, 0x0000, 0x0000 }, /* R20857 */ - { 0x0000, 0x0000, 0x0000 }, /* R20858 */ - { 0x0000, 0x0000, 0x0000 }, /* R20859 */ - { 0x0000, 0x0000, 0x0000 }, /* R20860 */ - { 0x0000, 0x0000, 0x0000 }, /* R20861 */ - { 0x0000, 0x0000, 0x0000 }, /* R20862 */ - { 0x0000, 0x0000, 0x0000 }, /* R20863 */ - { 0x0000, 0x0000, 0x0000 }, /* R20864 */ - { 0x0000, 0x0000, 0x0000 }, /* R20865 */ - { 0x0000, 0x0000, 0x0000 }, /* R20866 */ - { 0x0000, 0x0000, 0x0000 }, /* R20867 */ - { 0x0000, 0x0000, 0x0000 }, /* R20868 */ - { 0x0000, 0x0000, 0x0000 }, /* R20869 */ - { 0x0000, 0x0000, 0x0000 }, /* R20870 */ - { 0x0000, 0x0000, 0x0000 }, /* R20871 */ - { 0x0000, 0x0000, 0x0000 }, /* R20872 */ - { 0x0000, 0x0000, 0x0000 }, /* R20873 */ - { 0x0000, 0x0000, 0x0000 }, /* R20874 */ - { 0x0000, 0x0000, 0x0000 }, /* R20875 */ - { 0x0000, 0x0000, 0x0000 }, /* R20876 */ - { 0x0000, 0x0000, 0x0000 }, /* R20877 */ - { 0x0000, 0x0000, 0x0000 }, /* R20878 */ - { 0x0000, 0x0000, 0x0000 }, /* R20879 */ - { 0x0000, 0x0000, 0x0000 }, /* R20880 */ - { 0x0000, 0x0000, 0x0000 }, /* R20881 */ - { 0x0000, 0x0000, 0x0000 }, /* R20882 */ - { 0x0000, 0x0000, 0x0000 }, /* R20883 */ - { 0x0000, 0x0000, 0x0000 }, /* R20884 */ - { 0x0000, 0x0000, 0x0000 }, /* R20885 */ - { 0x0000, 0x0000, 0x0000 }, /* R20886 */ - { 0x0000, 0x0000, 0x0000 }, /* R20887 */ - { 0x0000, 0x0000, 0x0000 }, /* R20888 */ - { 0x0000, 0x0000, 0x0000 }, /* R20889 */ - { 0x0000, 0x0000, 0x0000 }, /* R20890 */ - { 0x0000, 0x0000, 0x0000 }, /* R20891 */ - { 0x0000, 0x0000, 0x0000 }, /* R20892 */ - { 0x0000, 0x0000, 0x0000 }, /* R20893 */ - { 0x0000, 0x0000, 0x0000 }, /* R20894 */ - { 0x0000, 0x0000, 0x0000 }, /* R20895 */ - { 0x0000, 0x0000, 0x0000 }, /* R20896 */ - { 0x0000, 0x0000, 0x0000 }, /* R20897 */ - { 0x0000, 0x0000, 0x0000 }, /* R20898 */ - { 0x0000, 0x0000, 0x0000 }, /* R20899 */ - { 0x0000, 0x0000, 0x0000 }, /* R20900 */ - { 0x0000, 0x0000, 0x0000 }, /* R20901 */ - { 0x0000, 0x0000, 0x0000 }, /* R20902 */ - { 0x0000, 0x0000, 0x0000 }, /* R20903 */ - { 0x0000, 0x0000, 0x0000 }, /* R20904 */ - { 0x0000, 0x0000, 0x0000 }, /* R20905 */ - { 0x0000, 0x0000, 0x0000 }, /* R20906 */ - { 0x0000, 0x0000, 0x0000 }, /* R20907 */ - { 0x0000, 0x0000, 0x0000 }, /* R20908 */ - { 0x0000, 0x0000, 0x0000 }, /* R20909 */ - { 0x0000, 0x0000, 0x0000 }, /* R20910 */ - { 0x0000, 0x0000, 0x0000 }, /* R20911 */ - { 0x0000, 0x0000, 0x0000 }, /* R20912 */ - { 0x0000, 0x0000, 0x0000 }, /* R20913 */ - { 0x0000, 0x0000, 0x0000 }, /* R20914 */ - { 0x0000, 0x0000, 0x0000 }, /* R20915 */ - { 0x0000, 0x0000, 0x0000 }, /* R20916 */ - { 0x0000, 0x0000, 0x0000 }, /* R20917 */ - { 0x0000, 0x0000, 0x0000 }, /* R20918 */ - { 0x0000, 0x0000, 0x0000 }, /* R20919 */ - { 0x0000, 0x0000, 0x0000 }, /* R20920 */ - { 0x0000, 0x0000, 0x0000 }, /* R20921 */ - { 0x0000, 0x0000, 0x0000 }, /* R20922 */ - { 0x0000, 0x0000, 0x0000 }, /* R20923 */ - { 0x0000, 0x0000, 0x0000 }, /* R20924 */ - { 0x0000, 0x0000, 0x0000 }, /* R20925 */ - { 0x0000, 0x0000, 0x0000 }, /* R20926 */ - { 0x0000, 0x0000, 0x0000 }, /* R20927 */ - { 0x0000, 0x0000, 0x0000 }, /* R20928 */ - { 0x0000, 0x0000, 0x0000 }, /* R20929 */ - { 0x0000, 0x0000, 0x0000 }, /* R20930 */ - { 0x0000, 0x0000, 0x0000 }, /* R20931 */ - { 0x0000, 0x0000, 0x0000 }, /* R20932 */ - { 0x0000, 0x0000, 0x0000 }, /* R20933 */ - { 0x0000, 0x0000, 0x0000 }, /* R20934 */ - { 0x0000, 0x0000, 0x0000 }, /* R20935 */ - { 0x0000, 0x0000, 0x0000 }, /* R20936 */ - { 0x0000, 0x0000, 0x0000 }, /* R20937 */ - { 0x0000, 0x0000, 0x0000 }, /* R20938 */ - { 0x0000, 0x0000, 0x0000 }, /* R20939 */ - { 0x0000, 0x0000, 0x0000 }, /* R20940 */ - { 0x0000, 0x0000, 0x0000 }, /* R20941 */ - { 0x0000, 0x0000, 0x0000 }, /* R20942 */ - { 0x0000, 0x0000, 0x0000 }, /* R20943 */ - { 0x0000, 0x0000, 0x0000 }, /* R20944 */ - { 0x0000, 0x0000, 0x0000 }, /* R20945 */ - { 0x0000, 0x0000, 0x0000 }, /* R20946 */ - { 0x0000, 0x0000, 0x0000 }, /* R20947 */ - { 0x0000, 0x0000, 0x0000 }, /* R20948 */ - { 0x0000, 0x0000, 0x0000 }, /* R20949 */ - { 0x0000, 0x0000, 0x0000 }, /* R20950 */ - { 0x0000, 0x0000, 0x0000 }, /* R20951 */ - { 0x0000, 0x0000, 0x0000 }, /* R20952 */ - { 0x0000, 0x0000, 0x0000 }, /* R20953 */ - { 0x0000, 0x0000, 0x0000 }, /* R20954 */ - { 0x0000, 0x0000, 0x0000 }, /* R20955 */ - { 0x0000, 0x0000, 0x0000 }, /* R20956 */ - { 0x0000, 0x0000, 0x0000 }, /* R20957 */ - { 0x0000, 0x0000, 0x0000 }, /* R20958 */ - { 0x0000, 0x0000, 0x0000 }, /* R20959 */ - { 0x0000, 0x0000, 0x0000 }, /* R20960 */ - { 0x0000, 0x0000, 0x0000 }, /* R20961 */ - { 0x0000, 0x0000, 0x0000 }, /* R20962 */ - { 0x0000, 0x0000, 0x0000 }, /* R20963 */ - { 0x0000, 0x0000, 0x0000 }, /* R20964 */ - { 0x0000, 0x0000, 0x0000 }, /* R20965 */ - { 0x0000, 0x0000, 0x0000 }, /* R20966 */ - { 0x0000, 0x0000, 0x0000 }, /* R20967 */ - { 0x0000, 0x0000, 0x0000 }, /* R20968 */ - { 0x0000, 0x0000, 0x0000 }, /* R20969 */ - { 0x0000, 0x0000, 0x0000 }, /* R20970 */ - { 0x0000, 0x0000, 0x0000 }, /* R20971 */ - { 0x0000, 0x0000, 0x0000 }, /* R20972 */ - { 0x0000, 0x0000, 0x0000 }, /* R20973 */ - { 0x0000, 0x0000, 0x0000 }, /* R20974 */ - { 0x0000, 0x0000, 0x0000 }, /* R20975 */ - { 0x0000, 0x0000, 0x0000 }, /* R20976 */ - { 0x0000, 0x0000, 0x0000 }, /* R20977 */ - { 0x0000, 0x0000, 0x0000 }, /* R20978 */ - { 0x0000, 0x0000, 0x0000 }, /* R20979 */ - { 0x0000, 0x0000, 0x0000 }, /* R20980 */ - { 0x0000, 0x0000, 0x0000 }, /* R20981 */ - { 0x0000, 0x0000, 0x0000 }, /* R20982 */ - { 0x0000, 0x0000, 0x0000 }, /* R20983 */ - { 0x0000, 0x0000, 0x0000 }, /* R20984 */ - { 0x0000, 0x0000, 0x0000 }, /* R20985 */ - { 0x0000, 0x0000, 0x0000 }, /* R20986 */ - { 0x0000, 0x0000, 0x0000 }, /* R20987 */ - { 0x0000, 0x0000, 0x0000 }, /* R20988 */ - { 0x0000, 0x0000, 0x0000 }, /* R20989 */ - { 0x0000, 0x0000, 0x0000 }, /* R20990 */ - { 0x0000, 0x0000, 0x0000 }, /* R20991 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20992 - VSS_XHD2_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20993 - VSS_XHD2_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20994 - VSS_XHD3_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20995 - VSS_XHD3_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20996 - VSS_XHN1_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20997 - VSS_XHN1_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R20998 - VSS_XHN2_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R20999 - VSS_XHN2_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21000 - VSS_XHN3_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21001 - VSS_XHN3_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21002 - VSS_XLA_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21003 - VSS_XLA_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21004 - VSS_XLB_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21005 - VSS_XLB_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21006 - VSS_XLG_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21007 - VSS_XLG_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21008 - VSS_PG2_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21009 - VSS_PG2_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21010 - VSS_PG_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21011 - VSS_PG_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21012 - VSS_XTD1_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21013 - VSS_XTD1_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21014 - VSS_XTD2_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21015 - VSS_XTD2_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21016 - VSS_XTD3_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21017 - VSS_XTD3_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21018 - VSS_XTD4_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21019 - VSS_XTD4_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21020 - VSS_XTD5_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21021 - VSS_XTD5_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21022 - VSS_XTD6_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21023 - VSS_XTD6_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21024 - VSS_XTD7_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21025 - VSS_XTD7_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21026 - VSS_XTD8_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21027 - VSS_XTD8_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21028 - VSS_XTD9_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21029 - VSS_XTD9_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21030 - VSS_XTD10_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21031 - VSS_XTD10_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21032 - VSS_XTD11_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21033 - VSS_XTD11_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21034 - VSS_XTD12_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21035 - VSS_XTD12_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21036 - VSS_XTD13_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21037 - VSS_XTD13_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21038 - VSS_XTD14_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21039 - VSS_XTD14_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21040 - VSS_XTD15_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21041 - VSS_XTD15_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21042 - VSS_XTD16_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21043 - VSS_XTD16_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21044 - VSS_XTD17_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21045 - VSS_XTD17_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21046 - VSS_XTD18_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21047 - VSS_XTD18_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21048 - VSS_XTD19_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21049 - VSS_XTD19_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21050 - VSS_XTD20_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21051 - VSS_XTD20_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21052 - VSS_XTD21_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21053 - VSS_XTD21_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21054 - VSS_XTD22_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21055 - VSS_XTD22_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21056 - VSS_XTD23_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21057 - VSS_XTD23_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21058 - VSS_XTD24_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21059 - VSS_XTD24_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21060 - VSS_XTD25_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21061 - VSS_XTD25_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21062 - VSS_XTD26_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21063 - VSS_XTD26_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21064 - VSS_XTD27_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21065 - VSS_XTD27_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21066 - VSS_XTD28_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21067 - VSS_XTD28_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21068 - VSS_XTD29_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21069 - VSS_XTD29_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21070 - VSS_XTD30_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21071 - VSS_XTD30_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21072 - VSS_XTD31_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21073 - VSS_XTD31_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21074 - VSS_XTD32_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21075 - VSS_XTD32_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21076 - VSS_XTS1_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21077 - VSS_XTS1_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21078 - VSS_XTS2_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21079 - VSS_XTS2_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21080 - VSS_XTS3_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21081 - VSS_XTS3_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21082 - VSS_XTS4_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21083 - VSS_XTS4_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21084 - VSS_XTS5_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21085 - VSS_XTS5_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21086 - VSS_XTS6_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21087 - VSS_XTS6_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21088 - VSS_XTS7_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21089 - VSS_XTS7_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21090 - VSS_XTS8_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21091 - VSS_XTS8_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21092 - VSS_XTS9_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21093 - VSS_XTS9_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21094 - VSS_XTS10_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21095 - VSS_XTS10_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21096 - VSS_XTS11_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21097 - VSS_XTS11_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21098 - VSS_XTS12_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21099 - VSS_XTS12_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21100 - VSS_XTS13_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21101 - VSS_XTS13_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21102 - VSS_XTS14_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21103 - VSS_XTS14_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21104 - VSS_XTS15_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21105 - VSS_XTS15_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21106 - VSS_XTS16_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21107 - VSS_XTS16_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21108 - VSS_XTS17_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21109 - VSS_XTS17_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21110 - VSS_XTS18_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21111 - VSS_XTS18_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21112 - VSS_XTS19_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21113 - VSS_XTS19_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21114 - VSS_XTS20_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21115 - VSS_XTS20_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21116 - VSS_XTS21_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21117 - VSS_XTS21_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21118 - VSS_XTS22_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21119 - VSS_XTS22_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21120 - VSS_XTS23_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21121 - VSS_XTS23_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21122 - VSS_XTS24_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21123 - VSS_XTS24_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21124 - VSS_XTS25_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21125 - VSS_XTS25_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21126 - VSS_XTS26_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21127 - VSS_XTS26_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21128 - VSS_XTS27_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21129 - VSS_XTS27_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21130 - VSS_XTS28_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21131 - VSS_XTS28_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21132 - VSS_XTS29_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21133 - VSS_XTS29_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21134 - VSS_XTS30_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21135 - VSS_XTS30_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21136 - VSS_XTS31_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21137 - VSS_XTS31_0 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R21138 - VSS_XTS32_1 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R21139 - VSS_XTS32_0 */ -}; diff --git a/sound/soc/codecs/wm8962.c b/sound/soc/codecs/wm8962.c index d817ac9..e5009d0 100644 --- a/sound/soc/codecs/wm8962.c +++ b/sound/soc/codecs/wm8962.c @@ -793,6 +793,1153 @@ static const u16 wm8962_reg[WM8962_MAX_REGISTER + 1] = { [21139] = 0x8580, /* R21139 - VSS_XTS32_0 */ }; +static const struct wm8962_reg_access { + u16 read; + u16 write; + u16 vol; +} wm8962_reg_access[WM8962_MAX_REGISTER + 1] = { + [0] = { 0x00FF, 0x01FF, 0x0000 }, /* R0 - Left Input volume */ + [1] = { 0xFEFF, 0x01FF, 0xFFFF }, /* R1 - Right Input volume */ + [2] = { 0x00FF, 0x01FF, 0x0000 }, /* R2 - HPOUTL volume */ + [3] = { 0x00FF, 0x01FF, 0x0000 }, /* R3 - HPOUTR volume */ + [4] = { 0x07FE, 0x07FE, 0xFFFF }, /* R4 - Clocking1 */ + [5] = { 0x007F, 0x007F, 0x0000 }, /* R5 - ADC & DAC Control 1 */ + [6] = { 0x37ED, 0x37ED, 0x0000 }, /* R6 - ADC & DAC Control 2 */ + [7] = { 0x1FFF, 0x1FFF, 0x0000 }, /* R7 - Audio Interface 0 */ + [8] = { 0x0FEF, 0x0FEF, 0xFFFF }, /* R8 - Clocking2 */ + [9] = { 0x0B9F, 0x039F, 0x0000 }, /* R9 - Audio Interface 1 */ + [10] = { 0x00FF, 0x01FF, 0x0000 }, /* R10 - Left DAC volume */ + [11] = { 0x00FF, 0x01FF, 0x0000 }, /* R11 - Right DAC volume */ + [14] = { 0x07FF, 0x07FF, 0x0000 }, /* R14 - Audio Interface 2 */ + [15] = { 0xFFFF, 0xFFFF, 0xFFFF }, /* R15 - Software Reset */ + [17] = { 0x07FF, 0x07FF, 0x0000 }, /* R17 - ALC1 */ + [18] = { 0xF8FF, 0x00FF, 0xFFFF }, /* R18 - ALC2 */ + [19] = { 0x1DFF, 0x1DFF, 0x0000 }, /* R19 - ALC3 */ + [20] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20 - Noise Gate */ + [21] = { 0x00FF, 0x01FF, 0x0000 }, /* R21 - Left ADC volume */ + [22] = { 0x00FF, 0x01FF, 0x0000 }, /* R22 - Right ADC volume */ + [23] = { 0x0161, 0x0161, 0x0000 }, /* R23 - Additional control(1) */ + [24] = { 0x0008, 0x0008, 0x0000 }, /* R24 - Additional control(2) */ + [25] = { 0x07FE, 0x07FE, 0x0000 }, /* R25 - Pwr Mgmt (1) */ + [26] = { 0x01FB, 0x01FB, 0x0000 }, /* R26 - Pwr Mgmt (2) */ + [27] = { 0x0017, 0x0017, 0x0000 }, /* R27 - Additional Control (3) */ + [28] = { 0x001C, 0x001C, 0x0000 }, /* R28 - Anti-pop */ + + [30] = { 0xFFFE, 0xFFFE, 0x0000 }, /* R30 - Clocking 3 */ + [31] = { 0x000F, 0x000F, 0x0000 }, /* R31 - Input mixer control (1) */ + [32] = { 0x01FF, 0x01FF, 0x0000 }, /* R32 - Left input mixer volume */ + [33] = { 0x01FF, 0x01FF, 0x0000 }, /* R33 - Right input mixer volume */ + [34] = { 0x003F, 0x003F, 0x0000 }, /* R34 - Input mixer control (2) */ + [35] = { 0x003F, 0x003F, 0x0000 }, /* R35 - Input bias control */ + [37] = { 0x001F, 0x001F, 0x0000 }, /* R37 - Left input PGA control */ + [38] = { 0x001F, 0x001F, 0x0000 }, /* R38 - Right input PGA control */ + [40] = { 0x00FF, 0x01FF, 0x0000 }, /* R40 - SPKOUTL volume */ + [41] = { 0x00FF, 0x01FF, 0x0000 }, /* R41 - SPKOUTR volume */ + + [47] = { 0x000F, 0x0000, 0x0000 }, /* R47 - Thermal Shutdown Status */ + [48] = { 0x7EC7, 0x7E07, 0xFFFF }, /* R48 - Additional Control (4) */ + [49] = { 0x00D3, 0x00D7, 0xFFFF }, /* R49 - Class D Control 1 */ + [51] = { 0x0047, 0x0047, 0x0000 }, /* R51 - Class D Control 2 */ + [56] = { 0x001E, 0x001E, 0x0000 }, /* R56 - Clocking 4 */ + [57] = { 0x02FC, 0x02FC, 0x0000 }, /* R57 - DAC DSP Mixing (1) */ + [58] = { 0x00FC, 0x00FC, 0x0000 }, /* R58 - DAC DSP Mixing (2) */ + [60] = { 0x00CC, 0x00CC, 0x0000 }, /* R60 - DC Servo 0 */ + [61] = { 0x00DD, 0x00DD, 0x0000 }, /* R61 - DC Servo 1 */ + [64] = { 0x3F80, 0x3F80, 0x0000 }, /* R64 - DC Servo 4 */ + [66] = { 0x0780, 0x0000, 0xFFFF }, /* R66 - DC Servo 6 */ + [68] = { 0x0007, 0x0007, 0x0000 }, /* R68 - Analogue PGA Bias */ + [69] = { 0x00FF, 0x00FF, 0x0000 }, /* R69 - Analogue HP 0 */ + [71] = { 0x01FF, 0x01FF, 0x0000 }, /* R71 - Analogue HP 2 */ + [72] = { 0x0001, 0x0001, 0x0000 }, /* R72 - Charge Pump 1 */ + [82] = { 0x0001, 0x0001, 0x0000 }, /* R82 - Charge Pump B */ + [87] = { 0x00A0, 0x00A0, 0x0000 }, /* R87 - Write Sequencer Control 1 */ + [90] = { 0x007F, 0x01FF, 0x0000 }, /* R90 - Write Sequencer Control 2 */ + [93] = { 0x03F9, 0x0000, 0x0000 }, /* R93 - Write Sequencer Control 3 */ + [94] = { 0x0070, 0x0070, 0x0000 }, /* R94 - Control Interface */ + [99] = { 0x000F, 0x000F, 0x0000 }, /* R99 - Mixer Enables */ + [100] = { 0x00BF, 0x00BF, 0x0000 }, /* R100 - Headphone Mixer (1) */ + [101] = { 0x00BF, 0x00BF, 0x0000 }, /* R101 - Headphone Mixer (2) */ + [102] = { 0x01FF, 0x01FF, 0x0000 }, /* R102 - Headphone Mixer (3) */ + [103] = { 0x01FF, 0x01FF, 0x0000 }, /* R103 - Headphone Mixer (4) */ + [105] = { 0x00BF, 0x00BF, 0x0000 }, /* R105 - Speaker Mixer (1) */ + [106] = { 0x00BF, 0x00BF, 0x0000 }, /* R106 - Speaker Mixer (2) */ + [107] = { 0x01FF, 0x01FF, 0x0000 }, /* R107 - Speaker Mixer (3) */ + [108] = { 0x01FF, 0x01FF, 0x0000 }, /* R108 - Speaker Mixer (4) */ + [109] = { 0x00F0, 0x00F0, 0x0000 }, /* R109 - Speaker Mixer (5) */ + [110] = { 0x00F7, 0x00F7, 0x0000 }, /* R110 - Beep Generator (1) */ + [115] = { 0x001F, 0x001F, 0x0000 }, /* R115 - Oscillator Trim (3) */ + [116] = { 0x001F, 0x001F, 0x0000 }, /* R116 - Oscillator Trim (4) */ + [119] = { 0x00FF, 0x00FF, 0x0000 }, /* R119 - Oscillator Trim (7) */ + [124] = { 0x0079, 0x0079, 0x0000 }, /* R124 - Analogue Clocking1 */ + [125] = { 0x00DF, 0x00DF, 0x0000 }, /* R125 - Analogue Clocking2 */ + [126] = { 0x000D, 0x000D, 0x0000 }, /* R126 - Analogue Clocking3 */ + [127] = { 0x0000, 0xFFFF, 0x0000 }, /* R127 - PLL Software Reset */ + [129] = { 0x00B0, 0x00B0, 0x0000 }, /* R129 - PLL2 */ + [131] = { 0x0003, 0x0003, 0x0000 }, /* R131 - PLL 4 */ + [136] = { 0x005F, 0x005F, 0x0000 }, /* R136 - PLL 9 */ + [137] = { 0x00FF, 0x00FF, 0x0000 }, /* R137 - PLL 10 */ + [138] = { 0x00FF, 0x00FF, 0x0000 }, /* R138 - PLL 11 */ + [139] = { 0x00FF, 0x00FF, 0x0000 }, /* R139 - PLL 12 */ + [140] = { 0x005F, 0x005F, 0x0000 }, /* R140 - PLL 13 */ + [141] = { 0x00FF, 0x00FF, 0x0000 }, /* R141 - PLL 14 */ + [142] = { 0x00FF, 0x00FF, 0x0000 }, /* R142 - PLL 15 */ + [143] = { 0x00FF, 0x00FF, 0x0000 }, /* R143 - PLL 16 */ + [155] = { 0x0067, 0x0067, 0x0000 }, /* R155 - FLL Control (1) */ + [156] = { 0x01FB, 0x01FB, 0x0000 }, /* R156 - FLL Control (2) */ + [157] = { 0x0007, 0x0007, 0x0000 }, /* R157 - FLL Control (3) */ + [159] = { 0x007F, 0x007F, 0x0000 }, /* R159 - FLL Control (5) */ + [160] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R160 - FLL Control (6) */ + [161] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R161 - FLL Control (7) */ + [162] = { 0x03FF, 0x03FF, 0x0000 }, /* R162 - FLL Control (8) */ + [252] = { 0x0005, 0x0005, 0x0000 }, /* R252 - General test 1 */ + [256] = { 0x000F, 0x000F, 0x0000 }, /* R256 - DF1 */ + [257] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R257 - DF2 */ + [258] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R258 - DF3 */ + [259] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R259 - DF4 */ + [260] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R260 - DF5 */ + [261] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R261 - DF6 */ + [262] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R262 - DF7 */ + [264] = { 0x0003, 0x0003, 0x0000 }, /* R264 - LHPF1 */ + [265] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R265 - LHPF2 */ + [268] = { 0x0077, 0x0077, 0x0000 }, /* R268 - THREED1 */ + [269] = { 0xFFFC, 0xFFFC, 0x0000 }, /* R269 - THREED2 */ + [270] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R270 - THREED3 */ + [271] = { 0xFFFC, 0xFFFC, 0x0000 }, /* R271 - THREED4 */ + [276] = { 0x7FFF, 0x7FFF, 0x0000 }, /* R276 - DRC 1 */ + [277] = { 0x1FFF, 0x1FFF, 0x0000 }, /* R277 - DRC 2 */ + [278] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R278 - DRC 3 */ + [279] = { 0x07FF, 0x07FF, 0x0000 }, /* R279 - DRC 4 */ + [280] = { 0x03FF, 0x03FF, 0x0000 }, /* R280 - DRC 5 */ + [285] = { 0x0003, 0x0003, 0x0000 }, /* R285 - Tloopback */ + [335] = { 0x0007, 0x0007, 0x0000 }, /* R335 - EQ1 */ + [336] = { 0xFFFE, 0xFFFE, 0x0000 }, /* R336 - EQ2 */ + [337] = { 0xFFC0, 0xFFC0, 0x0000 }, /* R337 - EQ3 */ + [338] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R338 - EQ4 */ + [339] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R339 - EQ5 */ + [340] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R340 - EQ6 */ + [341] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R341 - EQ7 */ + [342] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R342 - EQ8 */ + [343] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R343 - EQ9 */ + [344] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R344 - EQ10 */ + [345] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R345 - EQ11 */ + [346] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R346 - EQ12 */ + [347] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R347 - EQ13 */ + [348] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R348 - EQ14 */ + [349] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R349 - EQ15 */ + [350] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R350 - EQ16 */ + [351] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R351 - EQ17 */ + [352] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R352 - EQ18 */ + [353] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R353 - EQ19 */ + [354] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R354 - EQ20 */ + [355] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R355 - EQ21 */ + [356] = { 0xFFFE, 0xFFFE, 0x0000 }, /* R356 - EQ22 */ + [357] = { 0xFFC0, 0xFFC0, 0x0000 }, /* R357 - EQ23 */ + [358] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R358 - EQ24 */ + [359] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R359 - EQ25 */ + [360] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R360 - EQ26 */ + [361] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R361 - EQ27 */ + [362] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R362 - EQ28 */ + [363] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R363 - EQ29 */ + [364] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R364 - EQ30 */ + [365] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R365 - EQ31 */ + [366] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R366 - EQ32 */ + [367] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R367 - EQ33 */ + [368] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R368 - EQ34 */ + [369] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R369 - EQ35 */ + [370] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R370 - EQ36 */ + [371] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R371 - EQ37 */ + [372] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R372 - EQ38 */ + [373] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R373 - EQ39 */ + [374] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R374 - EQ40 */ + [375] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R375 - EQ41 */ + [513] = { 0x045F, 0x045F, 0x0000 }, /* R513 - GPIO 2 */ + [514] = { 0x045F, 0x045F, 0x0000 }, /* R514 - GPIO 3 */ + [516] = { 0xE75F, 0xE75F, 0x0000 }, /* R516 - GPIO 5 */ + [517] = { 0xE75F, 0xE75F, 0x0000 }, /* R517 - GPIO 6 */ + [560] = { 0x0030, 0x0030, 0xFFFF }, /* R560 - Interrupt Status 1 */ + [561] = { 0xFFED, 0xFFED, 0xFFFF }, /* R561 - Interrupt Status 2 */ + [568] = { 0x0030, 0x0030, 0x0000 }, /* R568 - Interrupt Status 1 Mask */ + [569] = { 0xFFED, 0xFFED, 0x0000 }, /* R569 - Interrupt Status 2 Mask */ + [576] = { 0x0001, 0x0001, 0x0000 }, /* R576 - Interrupt Control */ + [584] = { 0x002D, 0x002D, 0x0000 }, /* R584 - IRQ Debounce */ + [586] = { 0xC000, 0xC000, 0x0000 }, /* R586 - MICINT Source Pol */ + [768] = { 0x0001, 0x0001, 0x0000 }, /* R768 - DSP2 Power Management */ + [1037] = { 0x0000, 0x003F, 0x0000 }, /* R1037 - DSP2_ExecControl */ + [4096] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4096 - Write Sequencer 0 */ + [4097] = { 0x00FF, 0x00FF, 0x0000 }, /* R4097 - Write Sequencer 1 */ + [4098] = { 0x070F, 0x070F, 0x0000 }, /* R4098 - Write Sequencer 2 */ + [4099] = { 0x010F, 0x010F, 0x0000 }, /* R4099 - Write Sequencer 3 */ + [4100] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4100 - Write Sequencer 4 */ + [4101] = { 0x00FF, 0x00FF, 0x0000 }, /* R4101 - Write Sequencer 5 */ + [4102] = { 0x070F, 0x070F, 0x0000 }, /* R4102 - Write Sequencer 6 */ + [4103] = { 0x010F, 0x010F, 0x0000 }, /* R4103 - Write Sequencer 7 */ + [4104] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4104 - Write Sequencer 8 */ + [4105] = { 0x00FF, 0x00FF, 0x0000 }, /* R4105 - Write Sequencer 9 */ + [4106] = { 0x070F, 0x070F, 0x0000 }, /* R4106 - Write Sequencer 10 */ + [4107] = { 0x010F, 0x010F, 0x0000 }, /* R4107 - Write Sequencer 11 */ + [4108] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4108 - Write Sequencer 12 */ + [4109] = { 0x00FF, 0x00FF, 0x0000 }, /* R4109 - Write Sequencer 13 */ + [4110] = { 0x070F, 0x070F, 0x0000 }, /* R4110 - Write Sequencer 14 */ + [4111] = { 0x010F, 0x010F, 0x0000 }, /* R4111 - Write Sequencer 15 */ + [4112] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4112 - Write Sequencer 16 */ + [4113] = { 0x00FF, 0x00FF, 0x0000 }, /* R4113 - Write Sequencer 17 */ + [4114] = { 0x070F, 0x070F, 0x0000 }, /* R4114 - Write Sequencer 18 */ + [4115] = { 0x010F, 0x010F, 0x0000 }, /* R4115 - Write Sequencer 19 */ + [4116] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4116 - Write Sequencer 20 */ + [4117] = { 0x00FF, 0x00FF, 0x0000 }, /* R4117 - Write Sequencer 21 */ + [4118] = { 0x070F, 0x070F, 0x0000 }, /* R4118 - Write Sequencer 22 */ + [4119] = { 0x010F, 0x010F, 0x0000 }, /* R4119 - Write Sequencer 23 */ + [4120] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4120 - Write Sequencer 24 */ + [4121] = { 0x00FF, 0x00FF, 0x0000 }, /* R4121 - Write Sequencer 25 */ + [4122] = { 0x070F, 0x070F, 0x0000 }, /* R4122 - Write Sequencer 26 */ + [4123] = { 0x010F, 0x010F, 0x0000 }, /* R4123 - Write Sequencer 27 */ + [4124] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4124 - Write Sequencer 28 */ + [4125] = { 0x00FF, 0x00FF, 0x0000 }, /* R4125 - Write Sequencer 29 */ + [4126] = { 0x070F, 0x070F, 0x0000 }, /* R4126 - Write Sequencer 30 */ + [4127] = { 0x010F, 0x010F, 0x0000 }, /* R4127 - Write Sequencer 31 */ + [4128] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4128 - Write Sequencer 32 */ + [4129] = { 0x00FF, 0x00FF, 0x0000 }, /* R4129 - Write Sequencer 33 */ + [4130] = { 0x070F, 0x070F, 0x0000 }, /* R4130 - Write Sequencer 34 */ + [4131] = { 0x010F, 0x010F, 0x0000 }, /* R4131 - Write Sequencer 35 */ + [4132] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4132 - Write Sequencer 36 */ + [4133] = { 0x00FF, 0x00FF, 0x0000 }, /* R4133 - Write Sequencer 37 */ + [4134] = { 0x070F, 0x070F, 0x0000 }, /* R4134 - Write Sequencer 38 */ + [4135] = { 0x010F, 0x010F, 0x0000 }, /* R4135 - Write Sequencer 39 */ + [4136] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4136 - Write Sequencer 40 */ + [4137] = { 0x00FF, 0x00FF, 0x0000 }, /* R4137 - Write Sequencer 41 */ + [4138] = { 0x070F, 0x070F, 0x0000 }, /* R4138 - Write Sequencer 42 */ + [4139] = { 0x010F, 0x010F, 0x0000 }, /* R4139 - Write Sequencer 43 */ + [4140] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4140 - Write Sequencer 44 */ + [4141] = { 0x00FF, 0x00FF, 0x0000 }, /* R4141 - Write Sequencer 45 */ + [4142] = { 0x070F, 0x070F, 0x0000 }, /* R4142 - Write Sequencer 46 */ + [4143] = { 0x010F, 0x010F, 0x0000 }, /* R4143 - Write Sequencer 47 */ + [4144] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4144 - Write Sequencer 48 */ + [4145] = { 0x00FF, 0x00FF, 0x0000 }, /* R4145 - Write Sequencer 49 */ + [4146] = { 0x070F, 0x070F, 0x0000 }, /* R4146 - Write Sequencer 50 */ + [4147] = { 0x010F, 0x010F, 0x0000 }, /* R4147 - Write Sequencer 51 */ + [4148] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4148 - Write Sequencer 52 */ + [4149] = { 0x00FF, 0x00FF, 0x0000 }, /* R4149 - Write Sequencer 53 */ + [4150] = { 0x070F, 0x070F, 0x0000 }, /* R4150 - Write Sequencer 54 */ + [4151] = { 0x010F, 0x010F, 0x0000 }, /* R4151 - Write Sequencer 55 */ + [4152] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4152 - Write Sequencer 56 */ + [4153] = { 0x00FF, 0x00FF, 0x0000 }, /* R4153 - Write Sequencer 57 */ + [4154] = { 0x070F, 0x070F, 0x0000 }, /* R4154 - Write Sequencer 58 */ + [4155] = { 0x010F, 0x010F, 0x0000 }, /* R4155 - Write Sequencer 59 */ + [4156] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4156 - Write Sequencer 60 */ + [4157] = { 0x00FF, 0x00FF, 0x0000 }, /* R4157 - Write Sequencer 61 */ + [4158] = { 0x070F, 0x070F, 0x0000 }, /* R4158 - Write Sequencer 62 */ + [4159] = { 0x010F, 0x010F, 0x0000 }, /* R4159 - Write Sequencer 63 */ + [4160] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4160 - Write Sequencer 64 */ + [4161] = { 0x00FF, 0x00FF, 0x0000 }, /* R4161 - Write Sequencer 65 */ + [4162] = { 0x070F, 0x070F, 0x0000 }, /* R4162 - Write Sequencer 66 */ + [4163] = { 0x010F, 0x010F, 0x0000 }, /* R4163 - Write Sequencer 67 */ + [4164] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4164 - Write Sequencer 68 */ + [4165] = { 0x00FF, 0x00FF, 0x0000 }, /* R4165 - Write Sequencer 69 */ + [4166] = { 0x070F, 0x070F, 0x0000 }, /* R4166 - Write Sequencer 70 */ + [4167] = { 0x010F, 0x010F, 0x0000 }, /* R4167 - Write Sequencer 71 */ + [4168] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4168 - Write Sequencer 72 */ + [4169] = { 0x00FF, 0x00FF, 0x0000 }, /* R4169 - Write Sequencer 73 */ + [4170] = { 0x070F, 0x070F, 0x0000 }, /* R4170 - Write Sequencer 74 */ + [4171] = { 0x010F, 0x010F, 0x0000 }, /* R4171 - Write Sequencer 75 */ + [4172] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4172 - Write Sequencer 76 */ + [4173] = { 0x00FF, 0x00FF, 0x0000 }, /* R4173 - Write Sequencer 77 */ + [4174] = { 0x070F, 0x070F, 0x0000 }, /* R4174 - Write Sequencer 78 */ + [4175] = { 0x010F, 0x010F, 0x0000 }, /* R4175 - Write Sequencer 79 */ + [4176] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4176 - Write Sequencer 80 */ + [4177] = { 0x00FF, 0x00FF, 0x0000 }, /* R4177 - Write Sequencer 81 */ + [4178] = { 0x070F, 0x070F, 0x0000 }, /* R4178 - Write Sequencer 82 */ + [4179] = { 0x010F, 0x010F, 0x0000 }, /* R4179 - Write Sequencer 83 */ + [4180] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4180 - Write Sequencer 84 */ + [4181] = { 0x00FF, 0x00FF, 0x0000 }, /* R4181 - Write Sequencer 85 */ + [4182] = { 0x070F, 0x070F, 0x0000 }, /* R4182 - Write Sequencer 86 */ + [4183] = { 0x010F, 0x010F, 0x0000 }, /* R4183 - Write Sequencer 87 */ + [4184] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4184 - Write Sequencer 88 */ + [4185] = { 0x00FF, 0x00FF, 0x0000 }, /* R4185 - Write Sequencer 89 */ + [4186] = { 0x070F, 0x070F, 0x0000 }, /* R4186 - Write Sequencer 90 */ + [4187] = { 0x010F, 0x010F, 0x0000 }, /* R4187 - Write Sequencer 91 */ + [4188] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4188 - Write Sequencer 92 */ + [4189] = { 0x00FF, 0x00FF, 0x0000 }, /* R4189 - Write Sequencer 93 */ + [4190] = { 0x070F, 0x070F, 0x0000 }, /* R4190 - Write Sequencer 94 */ + [4191] = { 0x010F, 0x010F, 0x0000 }, /* R4191 - Write Sequencer 95 */ + [4192] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4192 - Write Sequencer 96 */ + [4193] = { 0x00FF, 0x00FF, 0x0000 }, /* R4193 - Write Sequencer 97 */ + [4194] = { 0x070F, 0x070F, 0x0000 }, /* R4194 - Write Sequencer 98 */ + [4195] = { 0x010F, 0x010F, 0x0000 }, /* R4195 - Write Sequencer 99 */ + [4196] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4196 - Write Sequencer 100 */ + [4197] = { 0x00FF, 0x00FF, 0x0000 }, /* R4197 - Write Sequencer 101 */ + [4198] = { 0x070F, 0x070F, 0x0000 }, /* R4198 - Write Sequencer 102 */ + [4199] = { 0x010F, 0x010F, 0x0000 }, /* R4199 - Write Sequencer 103 */ + [4200] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4200 - Write Sequencer 104 */ + [4201] = { 0x00FF, 0x00FF, 0x0000 }, /* R4201 - Write Sequencer 105 */ + [4202] = { 0x070F, 0x070F, 0x0000 }, /* R4202 - Write Sequencer 106 */ + [4203] = { 0x010F, 0x010F, 0x0000 }, /* R4203 - Write Sequencer 107 */ + [4204] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4204 - Write Sequencer 108 */ + [4205] = { 0x00FF, 0x00FF, 0x0000 }, /* R4205 - Write Sequencer 109 */ + [4206] = { 0x070F, 0x070F, 0x0000 }, /* R4206 - Write Sequencer 110 */ + [4207] = { 0x010F, 0x010F, 0x0000 }, /* R4207 - Write Sequencer 111 */ + [4208] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4208 - Write Sequencer 112 */ + [4209] = { 0x00FF, 0x00FF, 0x0000 }, /* R4209 - Write Sequencer 113 */ + [4210] = { 0x070F, 0x070F, 0x0000 }, /* R4210 - Write Sequencer 114 */ + [4211] = { 0x010F, 0x010F, 0x0000 }, /* R4211 - Write Sequencer 115 */ + [4212] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4212 - Write Sequencer 116 */ + [4213] = { 0x00FF, 0x00FF, 0x0000 }, /* R4213 - Write Sequencer 117 */ + [4214] = { 0x070F, 0x070F, 0x0000 }, /* R4214 - Write Sequencer 118 */ + [4215] = { 0x010F, 0x010F, 0x0000 }, /* R4215 - Write Sequencer 119 */ + [4216] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4216 - Write Sequencer 120 */ + [4217] = { 0x00FF, 0x00FF, 0x0000 }, /* R4217 - Write Sequencer 121 */ + [4218] = { 0x070F, 0x070F, 0x0000 }, /* R4218 - Write Sequencer 122 */ + [4219] = { 0x010F, 0x010F, 0x0000 }, /* R4219 - Write Sequencer 123 */ + [4220] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4220 - Write Sequencer 124 */ + [4221] = { 0x00FF, 0x00FF, 0x0000 }, /* R4221 - Write Sequencer 125 */ + [4222] = { 0x070F, 0x070F, 0x0000 }, /* R4222 - Write Sequencer 126 */ + [4223] = { 0x010F, 0x010F, 0x0000 }, /* R4223 - Write Sequencer 127 */ + [4224] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4224 - Write Sequencer 128 */ + [4225] = { 0x00FF, 0x00FF, 0x0000 }, /* R4225 - Write Sequencer 129 */ + [4226] = { 0x070F, 0x070F, 0x0000 }, /* R4226 - Write Sequencer 130 */ + [4227] = { 0x010F, 0x010F, 0x0000 }, /* R4227 - Write Sequencer 131 */ + [4228] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4228 - Write Sequencer 132 */ + [4229] = { 0x00FF, 0x00FF, 0x0000 }, /* R4229 - Write Sequencer 133 */ + [4230] = { 0x070F, 0x070F, 0x0000 }, /* R4230 - Write Sequencer 134 */ + [4231] = { 0x010F, 0x010F, 0x0000 }, /* R4231 - Write Sequencer 135 */ + [4232] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4232 - Write Sequencer 136 */ + [4233] = { 0x00FF, 0x00FF, 0x0000 }, /* R4233 - Write Sequencer 137 */ + [4234] = { 0x070F, 0x070F, 0x0000 }, /* R4234 - Write Sequencer 138 */ + [4235] = { 0x010F, 0x010F, 0x0000 }, /* R4235 - Write Sequencer 139 */ + [4236] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4236 - Write Sequencer 140 */ + [4237] = { 0x00FF, 0x00FF, 0x0000 }, /* R4237 - Write Sequencer 141 */ + [4238] = { 0x070F, 0x070F, 0x0000 }, /* R4238 - Write Sequencer 142 */ + [4239] = { 0x010F, 0x010F, 0x0000 }, /* R4239 - Write Sequencer 143 */ + [4240] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4240 - Write Sequencer 144 */ + [4241] = { 0x00FF, 0x00FF, 0x0000 }, /* R4241 - Write Sequencer 145 */ + [4242] = { 0x070F, 0x070F, 0x0000 }, /* R4242 - Write Sequencer 146 */ + [4243] = { 0x010F, 0x010F, 0x0000 }, /* R4243 - Write Sequencer 147 */ + [4244] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4244 - Write Sequencer 148 */ + [4245] = { 0x00FF, 0x00FF, 0x0000 }, /* R4245 - Write Sequencer 149 */ + [4246] = { 0x070F, 0x070F, 0x0000 }, /* R4246 - Write Sequencer 150 */ + [4247] = { 0x010F, 0x010F, 0x0000 }, /* R4247 - Write Sequencer 151 */ + [4248] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4248 - Write Sequencer 152 */ + [4249] = { 0x00FF, 0x00FF, 0x0000 }, /* R4249 - Write Sequencer 153 */ + [4250] = { 0x070F, 0x070F, 0x0000 }, /* R4250 - Write Sequencer 154 */ + [4251] = { 0x010F, 0x010F, 0x0000 }, /* R4251 - Write Sequencer 155 */ + [4252] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4252 - Write Sequencer 156 */ + [4253] = { 0x00FF, 0x00FF, 0x0000 }, /* R4253 - Write Sequencer 157 */ + [4254] = { 0x070F, 0x070F, 0x0000 }, /* R4254 - Write Sequencer 158 */ + [4255] = { 0x010F, 0x010F, 0x0000 }, /* R4255 - Write Sequencer 159 */ + [4256] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4256 - Write Sequencer 160 */ + [4257] = { 0x00FF, 0x00FF, 0x0000 }, /* R4257 - Write Sequencer 161 */ + [4258] = { 0x070F, 0x070F, 0x0000 }, /* R4258 - Write Sequencer 162 */ + [4259] = { 0x010F, 0x010F, 0x0000 }, /* R4259 - Write Sequencer 163 */ + [4260] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4260 - Write Sequencer 164 */ + [4261] = { 0x00FF, 0x00FF, 0x0000 }, /* R4261 - Write Sequencer 165 */ + [4262] = { 0x070F, 0x070F, 0x0000 }, /* R4262 - Write Sequencer 166 */ + [4263] = { 0x010F, 0x010F, 0x0000 }, /* R4263 - Write Sequencer 167 */ + [4264] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4264 - Write Sequencer 168 */ + [4265] = { 0x00FF, 0x00FF, 0x0000 }, /* R4265 - Write Sequencer 169 */ + [4266] = { 0x070F, 0x070F, 0x0000 }, /* R4266 - Write Sequencer 170 */ + [4267] = { 0x010F, 0x010F, 0x0000 }, /* R4267 - Write Sequencer 171 */ + [4268] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4268 - Write Sequencer 172 */ + [4269] = { 0x00FF, 0x00FF, 0x0000 }, /* R4269 - Write Sequencer 173 */ + [4270] = { 0x070F, 0x070F, 0x0000 }, /* R4270 - Write Sequencer 174 */ + [4271] = { 0x010F, 0x010F, 0x0000 }, /* R4271 - Write Sequencer 175 */ + [4272] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4272 - Write Sequencer 176 */ + [4273] = { 0x00FF, 0x00FF, 0x0000 }, /* R4273 - Write Sequencer 177 */ + [4274] = { 0x070F, 0x070F, 0x0000 }, /* R4274 - Write Sequencer 178 */ + [4275] = { 0x010F, 0x010F, 0x0000 }, /* R4275 - Write Sequencer 179 */ + [4276] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4276 - Write Sequencer 180 */ + [4277] = { 0x00FF, 0x00FF, 0x0000 }, /* R4277 - Write Sequencer 181 */ + [4278] = { 0x070F, 0x070F, 0x0000 }, /* R4278 - Write Sequencer 182 */ + [4279] = { 0x010F, 0x010F, 0x0000 }, /* R4279 - Write Sequencer 183 */ + [4280] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4280 - Write Sequencer 184 */ + [4281] = { 0x00FF, 0x00FF, 0x0000 }, /* R4281 - Write Sequencer 185 */ + [4282] = { 0x070F, 0x070F, 0x0000 }, /* R4282 - Write Sequencer 186 */ + [4283] = { 0x010F, 0x010F, 0x0000 }, /* R4283 - Write Sequencer 187 */ + [4284] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4284 - Write Sequencer 188 */ + [4285] = { 0x00FF, 0x00FF, 0x0000 }, /* R4285 - Write Sequencer 189 */ + [4286] = { 0x070F, 0x070F, 0x0000 }, /* R4286 - Write Sequencer 190 */ + [4287] = { 0x010F, 0x010F, 0x0000 }, /* R4287 - Write Sequencer 191 */ + [4288] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4288 - Write Sequencer 192 */ + [4289] = { 0x00FF, 0x00FF, 0x0000 }, /* R4289 - Write Sequencer 193 */ + [4290] = { 0x070F, 0x070F, 0x0000 }, /* R4290 - Write Sequencer 194 */ + [4291] = { 0x010F, 0x010F, 0x0000 }, /* R4291 - Write Sequencer 195 */ + [4292] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4292 - Write Sequencer 196 */ + [4293] = { 0x00FF, 0x00FF, 0x0000 }, /* R4293 - Write Sequencer 197 */ + [4294] = { 0x070F, 0x070F, 0x0000 }, /* R4294 - Write Sequencer 198 */ + [4295] = { 0x010F, 0x010F, 0x0000 }, /* R4295 - Write Sequencer 199 */ + [4296] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4296 - Write Sequencer 200 */ + [4297] = { 0x00FF, 0x00FF, 0x0000 }, /* R4297 - Write Sequencer 201 */ + [4298] = { 0x070F, 0x070F, 0x0000 }, /* R4298 - Write Sequencer 202 */ + [4299] = { 0x010F, 0x010F, 0x0000 }, /* R4299 - Write Sequencer 203 */ + [4300] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4300 - Write Sequencer 204 */ + [4301] = { 0x00FF, 0x00FF, 0x0000 }, /* R4301 - Write Sequencer 205 */ + [4302] = { 0x070F, 0x070F, 0x0000 }, /* R4302 - Write Sequencer 206 */ + [4303] = { 0x010F, 0x010F, 0x0000 }, /* R4303 - Write Sequencer 207 */ + [4304] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4304 - Write Sequencer 208 */ + [4305] = { 0x00FF, 0x00FF, 0x0000 }, /* R4305 - Write Sequencer 209 */ + [4306] = { 0x070F, 0x070F, 0x0000 }, /* R4306 - Write Sequencer 210 */ + [4307] = { 0x010F, 0x010F, 0x0000 }, /* R4307 - Write Sequencer 211 */ + [4308] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4308 - Write Sequencer 212 */ + [4309] = { 0x00FF, 0x00FF, 0x0000 }, /* R4309 - Write Sequencer 213 */ + [4310] = { 0x070F, 0x070F, 0x0000 }, /* R4310 - Write Sequencer 214 */ + [4311] = { 0x010F, 0x010F, 0x0000 }, /* R4311 - Write Sequencer 215 */ + [4312] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4312 - Write Sequencer 216 */ + [4313] = { 0x00FF, 0x00FF, 0x0000 }, /* R4313 - Write Sequencer 217 */ + [4314] = { 0x070F, 0x070F, 0x0000 }, /* R4314 - Write Sequencer 218 */ + [4315] = { 0x010F, 0x010F, 0x0000 }, /* R4315 - Write Sequencer 219 */ + [4316] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4316 - Write Sequencer 220 */ + [4317] = { 0x00FF, 0x00FF, 0x0000 }, /* R4317 - Write Sequencer 221 */ + [4318] = { 0x070F, 0x070F, 0x0000 }, /* R4318 - Write Sequencer 222 */ + [4319] = { 0x010F, 0x010F, 0x0000 }, /* R4319 - Write Sequencer 223 */ + [4320] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4320 - Write Sequencer 224 */ + [4321] = { 0x00FF, 0x00FF, 0x0000 }, /* R4321 - Write Sequencer 225 */ + [4322] = { 0x070F, 0x070F, 0x0000 }, /* R4322 - Write Sequencer 226 */ + [4323] = { 0x010F, 0x010F, 0x0000 }, /* R4323 - Write Sequencer 227 */ + [4324] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4324 - Write Sequencer 228 */ + [4325] = { 0x00FF, 0x00FF, 0x0000 }, /* R4325 - Write Sequencer 229 */ + [4326] = { 0x070F, 0x070F, 0x0000 }, /* R4326 - Write Sequencer 230 */ + [4327] = { 0x010F, 0x010F, 0x0000 }, /* R4327 - Write Sequencer 231 */ + [4328] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4328 - Write Sequencer 232 */ + [4329] = { 0x00FF, 0x00FF, 0x0000 }, /* R4329 - Write Sequencer 233 */ + [4330] = { 0x070F, 0x070F, 0x0000 }, /* R4330 - Write Sequencer 234 */ + [4331] = { 0x010F, 0x010F, 0x0000 }, /* R4331 - Write Sequencer 235 */ + [4332] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4332 - Write Sequencer 236 */ + [4333] = { 0x00FF, 0x00FF, 0x0000 }, /* R4333 - Write Sequencer 237 */ + [4334] = { 0x070F, 0x070F, 0x0000 }, /* R4334 - Write Sequencer 238 */ + [4335] = { 0x010F, 0x010F, 0x0000 }, /* R4335 - Write Sequencer 239 */ + [4336] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4336 - Write Sequencer 240 */ + [4337] = { 0x00FF, 0x00FF, 0x0000 }, /* R4337 - Write Sequencer 241 */ + [4338] = { 0x070F, 0x070F, 0x0000 }, /* R4338 - Write Sequencer 242 */ + [4339] = { 0x010F, 0x010F, 0x0000 }, /* R4339 - Write Sequencer 243 */ + [4340] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4340 - Write Sequencer 244 */ + [4341] = { 0x00FF, 0x00FF, 0x0000 }, /* R4341 - Write Sequencer 245 */ + [4342] = { 0x070F, 0x070F, 0x0000 }, /* R4342 - Write Sequencer 246 */ + [4343] = { 0x010F, 0x010F, 0x0000 }, /* R4343 - Write Sequencer 247 */ + [4344] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4344 - Write Sequencer 248 */ + [4345] = { 0x00FF, 0x00FF, 0x0000 }, /* R4345 - Write Sequencer 249 */ + [4346] = { 0x070F, 0x070F, 0x0000 }, /* R4346 - Write Sequencer 250 */ + [4347] = { 0x010F, 0x010F, 0x0000 }, /* R4347 - Write Sequencer 251 */ + [4348] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4348 - Write Sequencer 252 */ + [4349] = { 0x00FF, 0x00FF, 0x0000 }, /* R4349 - Write Sequencer 253 */ + [4350] = { 0x070F, 0x070F, 0x0000 }, /* R4350 - Write Sequencer 254 */ + [4351] = { 0x010F, 0x010F, 0x0000 }, /* R4351 - Write Sequencer 255 */ + [4352] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4352 - Write Sequencer 256 */ + [4353] = { 0x00FF, 0x00FF, 0x0000 }, /* R4353 - Write Sequencer 257 */ + [4354] = { 0x070F, 0x070F, 0x0000 }, /* R4354 - Write Sequencer 258 */ + [4355] = { 0x010F, 0x010F, 0x0000 }, /* R4355 - Write Sequencer 259 */ + [4356] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4356 - Write Sequencer 260 */ + [4357] = { 0x00FF, 0x00FF, 0x0000 }, /* R4357 - Write Sequencer 261 */ + [4358] = { 0x070F, 0x070F, 0x0000 }, /* R4358 - Write Sequencer 262 */ + [4359] = { 0x010F, 0x010F, 0x0000 }, /* R4359 - Write Sequencer 263 */ + [4360] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4360 - Write Sequencer 264 */ + [4361] = { 0x00FF, 0x00FF, 0x0000 }, /* R4361 - Write Sequencer 265 */ + [4362] = { 0x070F, 0x070F, 0x0000 }, /* R4362 - Write Sequencer 266 */ + [4363] = { 0x010F, 0x010F, 0x0000 }, /* R4363 - Write Sequencer 267 */ + [4364] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4364 - Write Sequencer 268 */ + [4365] = { 0x00FF, 0x00FF, 0x0000 }, /* R4365 - Write Sequencer 269 */ + [4366] = { 0x070F, 0x070F, 0x0000 }, /* R4366 - Write Sequencer 270 */ + [4367] = { 0x010F, 0x010F, 0x0000 }, /* R4367 - Write Sequencer 271 */ + [4368] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4368 - Write Sequencer 272 */ + [4369] = { 0x00FF, 0x00FF, 0x0000 }, /* R4369 - Write Sequencer 273 */ + [4370] = { 0x070F, 0x070F, 0x0000 }, /* R4370 - Write Sequencer 274 */ + [4371] = { 0x010F, 0x010F, 0x0000 }, /* R4371 - Write Sequencer 275 */ + [4372] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4372 - Write Sequencer 276 */ + [4373] = { 0x00FF, 0x00FF, 0x0000 }, /* R4373 - Write Sequencer 277 */ + [4374] = { 0x070F, 0x070F, 0x0000 }, /* R4374 - Write Sequencer 278 */ + [4375] = { 0x010F, 0x010F, 0x0000 }, /* R4375 - Write Sequencer 279 */ + [4376] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4376 - Write Sequencer 280 */ + [4377] = { 0x00FF, 0x00FF, 0x0000 }, /* R4377 - Write Sequencer 281 */ + [4378] = { 0x070F, 0x070F, 0x0000 }, /* R4378 - Write Sequencer 282 */ + [4379] = { 0x010F, 0x010F, 0x0000 }, /* R4379 - Write Sequencer 283 */ + [4380] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4380 - Write Sequencer 284 */ + [4381] = { 0x00FF, 0x00FF, 0x0000 }, /* R4381 - Write Sequencer 285 */ + [4382] = { 0x070F, 0x070F, 0x0000 }, /* R4382 - Write Sequencer 286 */ + [4383] = { 0x010F, 0x010F, 0x0000 }, /* R4383 - Write Sequencer 287 */ + [4384] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4384 - Write Sequencer 288 */ + [4385] = { 0x00FF, 0x00FF, 0x0000 }, /* R4385 - Write Sequencer 289 */ + [4386] = { 0x070F, 0x070F, 0x0000 }, /* R4386 - Write Sequencer 290 */ + [4387] = { 0x010F, 0x010F, 0x0000 }, /* R4387 - Write Sequencer 291 */ + [4388] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4388 - Write Sequencer 292 */ + [4389] = { 0x00FF, 0x00FF, 0x0000 }, /* R4389 - Write Sequencer 293 */ + [4390] = { 0x070F, 0x070F, 0x0000 }, /* R4390 - Write Sequencer 294 */ + [4391] = { 0x010F, 0x010F, 0x0000 }, /* R4391 - Write Sequencer 295 */ + [4392] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4392 - Write Sequencer 296 */ + [4393] = { 0x00FF, 0x00FF, 0x0000 }, /* R4393 - Write Sequencer 297 */ + [4394] = { 0x070F, 0x070F, 0x0000 }, /* R4394 - Write Sequencer 298 */ + [4395] = { 0x010F, 0x010F, 0x0000 }, /* R4395 - Write Sequencer 299 */ + [4396] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4396 - Write Sequencer 300 */ + [4397] = { 0x00FF, 0x00FF, 0x0000 }, /* R4397 - Write Sequencer 301 */ + [4398] = { 0x070F, 0x070F, 0x0000 }, /* R4398 - Write Sequencer 302 */ + [4399] = { 0x010F, 0x010F, 0x0000 }, /* R4399 - Write Sequencer 303 */ + [4400] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4400 - Write Sequencer 304 */ + [4401] = { 0x00FF, 0x00FF, 0x0000 }, /* R4401 - Write Sequencer 305 */ + [4402] = { 0x070F, 0x070F, 0x0000 }, /* R4402 - Write Sequencer 306 */ + [4403] = { 0x010F, 0x010F, 0x0000 }, /* R4403 - Write Sequencer 307 */ + [4404] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4404 - Write Sequencer 308 */ + [4405] = { 0x00FF, 0x00FF, 0x0000 }, /* R4405 - Write Sequencer 309 */ + [4406] = { 0x070F, 0x070F, 0x0000 }, /* R4406 - Write Sequencer 310 */ + [4407] = { 0x010F, 0x010F, 0x0000 }, /* R4407 - Write Sequencer 311 */ + [4408] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4408 - Write Sequencer 312 */ + [4409] = { 0x00FF, 0x00FF, 0x0000 }, /* R4409 - Write Sequencer 313 */ + [4410] = { 0x070F, 0x070F, 0x0000 }, /* R4410 - Write Sequencer 314 */ + [4411] = { 0x010F, 0x010F, 0x0000 }, /* R4411 - Write Sequencer 315 */ + [4412] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4412 - Write Sequencer 316 */ + [4413] = { 0x00FF, 0x00FF, 0x0000 }, /* R4413 - Write Sequencer 317 */ + [4414] = { 0x070F, 0x070F, 0x0000 }, /* R4414 - Write Sequencer 318 */ + [4415] = { 0x010F, 0x010F, 0x0000 }, /* R4415 - Write Sequencer 319 */ + [4416] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4416 - Write Sequencer 320 */ + [4417] = { 0x00FF, 0x00FF, 0x0000 }, /* R4417 - Write Sequencer 321 */ + [4418] = { 0x070F, 0x070F, 0x0000 }, /* R4418 - Write Sequencer 322 */ + [4419] = { 0x010F, 0x010F, 0x0000 }, /* R4419 - Write Sequencer 323 */ + [4420] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4420 - Write Sequencer 324 */ + [4421] = { 0x00FF, 0x00FF, 0x0000 }, /* R4421 - Write Sequencer 325 */ + [4422] = { 0x070F, 0x070F, 0x0000 }, /* R4422 - Write Sequencer 326 */ + [4423] = { 0x010F, 0x010F, 0x0000 }, /* R4423 - Write Sequencer 327 */ + [4424] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4424 - Write Sequencer 328 */ + [4425] = { 0x00FF, 0x00FF, 0x0000 }, /* R4425 - Write Sequencer 329 */ + [4426] = { 0x070F, 0x070F, 0x0000 }, /* R4426 - Write Sequencer 330 */ + [4427] = { 0x010F, 0x010F, 0x0000 }, /* R4427 - Write Sequencer 331 */ + [4428] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4428 - Write Sequencer 332 */ + [4429] = { 0x00FF, 0x00FF, 0x0000 }, /* R4429 - Write Sequencer 333 */ + [4430] = { 0x070F, 0x070F, 0x0000 }, /* R4430 - Write Sequencer 334 */ + [4431] = { 0x010F, 0x010F, 0x0000 }, /* R4431 - Write Sequencer 335 */ + [4432] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4432 - Write Sequencer 336 */ + [4433] = { 0x00FF, 0x00FF, 0x0000 }, /* R4433 - Write Sequencer 337 */ + [4434] = { 0x070F, 0x070F, 0x0000 }, /* R4434 - Write Sequencer 338 */ + [4435] = { 0x010F, 0x010F, 0x0000 }, /* R4435 - Write Sequencer 339 */ + [4436] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4436 - Write Sequencer 340 */ + [4437] = { 0x00FF, 0x00FF, 0x0000 }, /* R4437 - Write Sequencer 341 */ + [4438] = { 0x070F, 0x070F, 0x0000 }, /* R4438 - Write Sequencer 342 */ + [4439] = { 0x010F, 0x010F, 0x0000 }, /* R4439 - Write Sequencer 343 */ + [4440] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4440 - Write Sequencer 344 */ + [4441] = { 0x00FF, 0x00FF, 0x0000 }, /* R4441 - Write Sequencer 345 */ + [4442] = { 0x070F, 0x070F, 0x0000 }, /* R4442 - Write Sequencer 346 */ + [4443] = { 0x010F, 0x010F, 0x0000 }, /* R4443 - Write Sequencer 347 */ + [4444] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4444 - Write Sequencer 348 */ + [4445] = { 0x00FF, 0x00FF, 0x0000 }, /* R4445 - Write Sequencer 349 */ + [4446] = { 0x070F, 0x070F, 0x0000 }, /* R4446 - Write Sequencer 350 */ + [4447] = { 0x010F, 0x010F, 0x0000 }, /* R4447 - Write Sequencer 351 */ + [4448] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4448 - Write Sequencer 352 */ + [4449] = { 0x00FF, 0x00FF, 0x0000 }, /* R4449 - Write Sequencer 353 */ + [4450] = { 0x070F, 0x070F, 0x0000 }, /* R4450 - Write Sequencer 354 */ + [4451] = { 0x010F, 0x010F, 0x0000 }, /* R4451 - Write Sequencer 355 */ + [4452] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4452 - Write Sequencer 356 */ + [4453] = { 0x00FF, 0x00FF, 0x0000 }, /* R4453 - Write Sequencer 357 */ + [4454] = { 0x070F, 0x070F, 0x0000 }, /* R4454 - Write Sequencer 358 */ + [4455] = { 0x010F, 0x010F, 0x0000 }, /* R4455 - Write Sequencer 359 */ + [4456] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4456 - Write Sequencer 360 */ + [4457] = { 0x00FF, 0x00FF, 0x0000 }, /* R4457 - Write Sequencer 361 */ + [4458] = { 0x070F, 0x070F, 0x0000 }, /* R4458 - Write Sequencer 362 */ + [4459] = { 0x010F, 0x010F, 0x0000 }, /* R4459 - Write Sequencer 363 */ + [4460] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4460 - Write Sequencer 364 */ + [4461] = { 0x00FF, 0x00FF, 0x0000 }, /* R4461 - Write Sequencer 365 */ + [4462] = { 0x070F, 0x070F, 0x0000 }, /* R4462 - Write Sequencer 366 */ + [4463] = { 0x010F, 0x010F, 0x0000 }, /* R4463 - Write Sequencer 367 */ + [4464] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4464 - Write Sequencer 368 */ + [4465] = { 0x00FF, 0x00FF, 0x0000 }, /* R4465 - Write Sequencer 369 */ + [4466] = { 0x070F, 0x070F, 0x0000 }, /* R4466 - Write Sequencer 370 */ + [4467] = { 0x010F, 0x010F, 0x0000 }, /* R4467 - Write Sequencer 371 */ + [4468] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4468 - Write Sequencer 372 */ + [4469] = { 0x00FF, 0x00FF, 0x0000 }, /* R4469 - Write Sequencer 373 */ + [4470] = { 0x070F, 0x070F, 0x0000 }, /* R4470 - Write Sequencer 374 */ + [4471] = { 0x010F, 0x010F, 0x0000 }, /* R4471 - Write Sequencer 375 */ + [4472] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4472 - Write Sequencer 376 */ + [4473] = { 0x00FF, 0x00FF, 0x0000 }, /* R4473 - Write Sequencer 377 */ + [4474] = { 0x070F, 0x070F, 0x0000 }, /* R4474 - Write Sequencer 378 */ + [4475] = { 0x010F, 0x010F, 0x0000 }, /* R4475 - Write Sequencer 379 */ + [4476] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4476 - Write Sequencer 380 */ + [4477] = { 0x00FF, 0x00FF, 0x0000 }, /* R4477 - Write Sequencer 381 */ + [4478] = { 0x070F, 0x070F, 0x0000 }, /* R4478 - Write Sequencer 382 */ + [4479] = { 0x010F, 0x010F, 0x0000 }, /* R4479 - Write Sequencer 383 */ + [4480] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4480 - Write Sequencer 384 */ + [4481] = { 0x00FF, 0x00FF, 0x0000 }, /* R4481 - Write Sequencer 385 */ + [4482] = { 0x070F, 0x070F, 0x0000 }, /* R4482 - Write Sequencer 386 */ + [4483] = { 0x010F, 0x010F, 0x0000 }, /* R4483 - Write Sequencer 387 */ + [4484] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4484 - Write Sequencer 388 */ + [4485] = { 0x00FF, 0x00FF, 0x0000 }, /* R4485 - Write Sequencer 389 */ + [4486] = { 0x070F, 0x070F, 0x0000 }, /* R4486 - Write Sequencer 390 */ + [4487] = { 0x010F, 0x010F, 0x0000 }, /* R4487 - Write Sequencer 391 */ + [4488] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4488 - Write Sequencer 392 */ + [4489] = { 0x00FF, 0x00FF, 0x0000 }, /* R4489 - Write Sequencer 393 */ + [4490] = { 0x070F, 0x070F, 0x0000 }, /* R4490 - Write Sequencer 394 */ + [4491] = { 0x010F, 0x010F, 0x0000 }, /* R4491 - Write Sequencer 395 */ + [4492] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4492 - Write Sequencer 396 */ + [4493] = { 0x00FF, 0x00FF, 0x0000 }, /* R4493 - Write Sequencer 397 */ + [4494] = { 0x070F, 0x070F, 0x0000 }, /* R4494 - Write Sequencer 398 */ + [4495] = { 0x010F, 0x010F, 0x0000 }, /* R4495 - Write Sequencer 399 */ + [4496] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4496 - Write Sequencer 400 */ + [4497] = { 0x00FF, 0x00FF, 0x0000 }, /* R4497 - Write Sequencer 401 */ + [4498] = { 0x070F, 0x070F, 0x0000 }, /* R4498 - Write Sequencer 402 */ + [4499] = { 0x010F, 0x010F, 0x0000 }, /* R4499 - Write Sequencer 403 */ + [4500] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4500 - Write Sequencer 404 */ + [4501] = { 0x00FF, 0x00FF, 0x0000 }, /* R4501 - Write Sequencer 405 */ + [4502] = { 0x070F, 0x070F, 0x0000 }, /* R4502 - Write Sequencer 406 */ + [4503] = { 0x010F, 0x010F, 0x0000 }, /* R4503 - Write Sequencer 407 */ + [4504] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4504 - Write Sequencer 408 */ + [4505] = { 0x00FF, 0x00FF, 0x0000 }, /* R4505 - Write Sequencer 409 */ + [4506] = { 0x070F, 0x070F, 0x0000 }, /* R4506 - Write Sequencer 410 */ + [4507] = { 0x010F, 0x010F, 0x0000 }, /* R4507 - Write Sequencer 411 */ + [4508] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4508 - Write Sequencer 412 */ + [4509] = { 0x00FF, 0x00FF, 0x0000 }, /* R4509 - Write Sequencer 413 */ + [4510] = { 0x070F, 0x070F, 0x0000 }, /* R4510 - Write Sequencer 414 */ + [4511] = { 0x010F, 0x010F, 0x0000 }, /* R4511 - Write Sequencer 415 */ + [4512] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4512 - Write Sequencer 416 */ + [4513] = { 0x00FF, 0x00FF, 0x0000 }, /* R4513 - Write Sequencer 417 */ + [4514] = { 0x070F, 0x070F, 0x0000 }, /* R4514 - Write Sequencer 418 */ + [4515] = { 0x010F, 0x010F, 0x0000 }, /* R4515 - Write Sequencer 419 */ + [4516] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4516 - Write Sequencer 420 */ + [4517] = { 0x00FF, 0x00FF, 0x0000 }, /* R4517 - Write Sequencer 421 */ + [4518] = { 0x070F, 0x070F, 0x0000 }, /* R4518 - Write Sequencer 422 */ + [4519] = { 0x010F, 0x010F, 0x0000 }, /* R4519 - Write Sequencer 423 */ + [4520] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4520 - Write Sequencer 424 */ + [4521] = { 0x00FF, 0x00FF, 0x0000 }, /* R4521 - Write Sequencer 425 */ + [4522] = { 0x070F, 0x070F, 0x0000 }, /* R4522 - Write Sequencer 426 */ + [4523] = { 0x010F, 0x010F, 0x0000 }, /* R4523 - Write Sequencer 427 */ + [4524] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4524 - Write Sequencer 428 */ + [4525] = { 0x00FF, 0x00FF, 0x0000 }, /* R4525 - Write Sequencer 429 */ + [4526] = { 0x070F, 0x070F, 0x0000 }, /* R4526 - Write Sequencer 430 */ + [4527] = { 0x010F, 0x010F, 0x0000 }, /* R4527 - Write Sequencer 431 */ + [4528] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4528 - Write Sequencer 432 */ + [4529] = { 0x00FF, 0x00FF, 0x0000 }, /* R4529 - Write Sequencer 433 */ + [4530] = { 0x070F, 0x070F, 0x0000 }, /* R4530 - Write Sequencer 434 */ + [4531] = { 0x010F, 0x010F, 0x0000 }, /* R4531 - Write Sequencer 435 */ + [4532] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4532 - Write Sequencer 436 */ + [4533] = { 0x00FF, 0x00FF, 0x0000 }, /* R4533 - Write Sequencer 437 */ + [4534] = { 0x070F, 0x070F, 0x0000 }, /* R4534 - Write Sequencer 438 */ + [4535] = { 0x010F, 0x010F, 0x0000 }, /* R4535 - Write Sequencer 439 */ + [4536] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4536 - Write Sequencer 440 */ + [4537] = { 0x00FF, 0x00FF, 0x0000 }, /* R4537 - Write Sequencer 441 */ + [4538] = { 0x070F, 0x070F, 0x0000 }, /* R4538 - Write Sequencer 442 */ + [4539] = { 0x010F, 0x010F, 0x0000 }, /* R4539 - Write Sequencer 443 */ + [4540] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4540 - Write Sequencer 444 */ + [4541] = { 0x00FF, 0x00FF, 0x0000 }, /* R4541 - Write Sequencer 445 */ + [4542] = { 0x070F, 0x070F, 0x0000 }, /* R4542 - Write Sequencer 446 */ + [4543] = { 0x010F, 0x010F, 0x0000 }, /* R4543 - Write Sequencer 447 */ + [4544] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4544 - Write Sequencer 448 */ + [4545] = { 0x00FF, 0x00FF, 0x0000 }, /* R4545 - Write Sequencer 449 */ + [4546] = { 0x070F, 0x070F, 0x0000 }, /* R4546 - Write Sequencer 450 */ + [4547] = { 0x010F, 0x010F, 0x0000 }, /* R4547 - Write Sequencer 451 */ + [4548] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4548 - Write Sequencer 452 */ + [4549] = { 0x00FF, 0x00FF, 0x0000 }, /* R4549 - Write Sequencer 453 */ + [4550] = { 0x070F, 0x070F, 0x0000 }, /* R4550 - Write Sequencer 454 */ + [4551] = { 0x010F, 0x010F, 0x0000 }, /* R4551 - Write Sequencer 455 */ + [4552] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4552 - Write Sequencer 456 */ + [4553] = { 0x00FF, 0x00FF, 0x0000 }, /* R4553 - Write Sequencer 457 */ + [4554] = { 0x070F, 0x070F, 0x0000 }, /* R4554 - Write Sequencer 458 */ + [4555] = { 0x010F, 0x010F, 0x0000 }, /* R4555 - Write Sequencer 459 */ + [4556] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4556 - Write Sequencer 460 */ + [4557] = { 0x00FF, 0x00FF, 0x0000 }, /* R4557 - Write Sequencer 461 */ + [4558] = { 0x070F, 0x070F, 0x0000 }, /* R4558 - Write Sequencer 462 */ + [4559] = { 0x010F, 0x010F, 0x0000 }, /* R4559 - Write Sequencer 463 */ + [4560] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4560 - Write Sequencer 464 */ + [4561] = { 0x00FF, 0x00FF, 0x0000 }, /* R4561 - Write Sequencer 465 */ + [4562] = { 0x070F, 0x070F, 0x0000 }, /* R4562 - Write Sequencer 466 */ + [4563] = { 0x010F, 0x010F, 0x0000 }, /* R4563 - Write Sequencer 467 */ + [4564] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4564 - Write Sequencer 468 */ + [4565] = { 0x00FF, 0x00FF, 0x0000 }, /* R4565 - Write Sequencer 469 */ + [4566] = { 0x070F, 0x070F, 0x0000 }, /* R4566 - Write Sequencer 470 */ + [4567] = { 0x010F, 0x010F, 0x0000 }, /* R4567 - Write Sequencer 471 */ + [4568] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4568 - Write Sequencer 472 */ + [4569] = { 0x00FF, 0x00FF, 0x0000 }, /* R4569 - Write Sequencer 473 */ + [4570] = { 0x070F, 0x070F, 0x0000 }, /* R4570 - Write Sequencer 474 */ + [4571] = { 0x010F, 0x010F, 0x0000 }, /* R4571 - Write Sequencer 475 */ + [4572] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4572 - Write Sequencer 476 */ + [4573] = { 0x00FF, 0x00FF, 0x0000 }, /* R4573 - Write Sequencer 477 */ + [4574] = { 0x070F, 0x070F, 0x0000 }, /* R4574 - Write Sequencer 478 */ + [4575] = { 0x010F, 0x010F, 0x0000 }, /* R4575 - Write Sequencer 479 */ + [4576] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4576 - Write Sequencer 480 */ + [4577] = { 0x00FF, 0x00FF, 0x0000 }, /* R4577 - Write Sequencer 481 */ + [4578] = { 0x070F, 0x070F, 0x0000 }, /* R4578 - Write Sequencer 482 */ + [4579] = { 0x010F, 0x010F, 0x0000 }, /* R4579 - Write Sequencer 483 */ + [4580] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4580 - Write Sequencer 484 */ + [4581] = { 0x00FF, 0x00FF, 0x0000 }, /* R4581 - Write Sequencer 485 */ + [4582] = { 0x070F, 0x070F, 0x0000 }, /* R4582 - Write Sequencer 486 */ + [4583] = { 0x010F, 0x010F, 0x0000 }, /* R4583 - Write Sequencer 487 */ + [4584] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4584 - Write Sequencer 488 */ + [4585] = { 0x00FF, 0x00FF, 0x0000 }, /* R4585 - Write Sequencer 489 */ + [4586] = { 0x070F, 0x070F, 0x0000 }, /* R4586 - Write Sequencer 490 */ + [4587] = { 0x010F, 0x010F, 0x0000 }, /* R4587 - Write Sequencer 491 */ + [4588] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4588 - Write Sequencer 492 */ + [4589] = { 0x00FF, 0x00FF, 0x0000 }, /* R4589 - Write Sequencer 493 */ + [4590] = { 0x070F, 0x070F, 0x0000 }, /* R4590 - Write Sequencer 494 */ + [4591] = { 0x010F, 0x010F, 0x0000 }, /* R4591 - Write Sequencer 495 */ + [4592] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4592 - Write Sequencer 496 */ + [4593] = { 0x00FF, 0x00FF, 0x0000 }, /* R4593 - Write Sequencer 497 */ + [4594] = { 0x070F, 0x070F, 0x0000 }, /* R4594 - Write Sequencer 498 */ + [4595] = { 0x010F, 0x010F, 0x0000 }, /* R4595 - Write Sequencer 499 */ + [4596] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4596 - Write Sequencer 500 */ + [4597] = { 0x00FF, 0x00FF, 0x0000 }, /* R4597 - Write Sequencer 501 */ + [4598] = { 0x070F, 0x070F, 0x0000 }, /* R4598 - Write Sequencer 502 */ + [4599] = { 0x010F, 0x010F, 0x0000 }, /* R4599 - Write Sequencer 503 */ + [4600] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4600 - Write Sequencer 504 */ + [4601] = { 0x00FF, 0x00FF, 0x0000 }, /* R4601 - Write Sequencer 505 */ + [4602] = { 0x070F, 0x070F, 0x0000 }, /* R4602 - Write Sequencer 506 */ + [4603] = { 0x010F, 0x010F, 0x0000 }, /* R4603 - Write Sequencer 507 */ + [4604] = { 0x3FFF, 0x3FFF, 0x0000 }, /* R4604 - Write Sequencer 508 */ + [4605] = { 0x00FF, 0x00FF, 0x0000 }, /* R4605 - Write Sequencer 509 */ + [4606] = { 0x070F, 0x070F, 0x0000 }, /* R4606 - Write Sequencer 510 */ + [4607] = { 0x010F, 0x010F, 0x0000 }, /* R4607 - Write Sequencer 511 */ + [8192] = { 0x03FF, 0x03FF, 0x0000 }, /* R8192 - DSP2 Instruction RAM 0 */ + [9216] = { 0x003F, 0x003F, 0x0000 }, /* R9216 - DSP2 Address RAM 2 */ + [9217] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R9217 - DSP2 Address RAM 1 */ + [9218] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R9218 - DSP2 Address RAM 0 */ + [12288] = { 0x00FF, 0x00FF, 0x0000 }, /* R12288 - DSP2 Data1 RAM 1 */ + [12289] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R12289 - DSP2 Data1 RAM 0 */ + [13312] = { 0x00FF, 0x00FF, 0x0000 }, /* R13312 - DSP2 Data2 RAM 1 */ + [13313] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R13313 - DSP2 Data2 RAM 0 */ + [14336] = { 0x00FF, 0x00FF, 0x0000 }, /* R14336 - DSP2 Data3 RAM 1 */ + [14337] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R14337 - DSP2 Data3 RAM 0 */ + [15360] = { 0x07FF, 0x07FF, 0x0000 }, /* R15360 - DSP2 Coeff RAM 0 */ + [16384] = { 0x00FF, 0x00FF, 0x0000 }, /* R16384 - RETUNEADC_SHARED_COEFF_1 */ + [16385] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R16385 - RETUNEADC_SHARED_COEFF_0 */ + [16386] = { 0x00FF, 0x00FF, 0x0000 }, /* R16386 - RETUNEDAC_SHARED_COEFF_1 */ + [16387] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R16387 - RETUNEDAC_SHARED_COEFF_0 */ + [16388] = { 0x00FF, 0x00FF, 0x0000 }, /* R16388 - SOUNDSTAGE_ENABLES_1 */ + [16389] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R16389 - SOUNDSTAGE_ENABLES_0 */ + [16896] = { 0x00FF, 0x00FF, 0x0000 }, /* R16896 - HDBASS_AI_1 */ + [16897] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R16897 - HDBASS_AI_0 */ + [16898] = { 0x00FF, 0x00FF, 0x0000 }, /* R16898 - HDBASS_AR_1 */ + [16899] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R16899 - HDBASS_AR_0 */ + [16900] = { 0x00FF, 0x00FF, 0x0000 }, /* R16900 - HDBASS_B_1 */ + [16901] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R16901 - HDBASS_B_0 */ + [16902] = { 0x00FF, 0x00FF, 0x0000 }, /* R16902 - HDBASS_K_1 */ + [16903] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R16903 - HDBASS_K_0 */ + [16904] = { 0x00FF, 0x00FF, 0x0000 }, /* R16904 - HDBASS_N1_1 */ + [16905] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R16905 - HDBASS_N1_0 */ + [16906] = { 0x00FF, 0x00FF, 0x0000 }, /* R16906 - HDBASS_N2_1 */ + [16907] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R16907 - HDBASS_N2_0 */ + [16908] = { 0x00FF, 0x00FF, 0x0000 }, /* R16908 - HDBASS_N3_1 */ + [16909] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R16909 - HDBASS_N3_0 */ + [16910] = { 0x00FF, 0x00FF, 0x0000 }, /* R16910 - HDBASS_N4_1 */ + [16911] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R16911 - HDBASS_N4_0 */ + [16912] = { 0x00FF, 0x00FF, 0x0000 }, /* R16912 - HDBASS_N5_1 */ + [16913] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R16913 - HDBASS_N5_0 */ + [16914] = { 0x00FF, 0x00FF, 0x0000 }, /* R16914 - HDBASS_X1_1 */ + [16915] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R16915 - HDBASS_X1_0 */ + [16916] = { 0x00FF, 0x00FF, 0x0000 }, /* R16916 - HDBASS_X2_1 */ + [16917] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R16917 - HDBASS_X2_0 */ + [16918] = { 0x00FF, 0x00FF, 0x0000 }, /* R16918 - HDBASS_X3_1 */ + [16919] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R16919 - HDBASS_X3_0 */ + [16920] = { 0x00FF, 0x00FF, 0x0000 }, /* R16920 - HDBASS_ATK_1 */ + [16921] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R16921 - HDBASS_ATK_0 */ + [16922] = { 0x00FF, 0x00FF, 0x0000 }, /* R16922 - HDBASS_DCY_1 */ + [16923] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R16923 - HDBASS_DCY_0 */ + [16924] = { 0x00FF, 0x00FF, 0x0000 }, /* R16924 - HDBASS_PG_1 */ + [16925] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R16925 - HDBASS_PG_0 */ + [17408] = { 0x00FF, 0x00FF, 0x0000 }, /* R17408 - HPF_C_1 */ + [17409] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17409 - HPF_C_0 */ + [17920] = { 0x00FF, 0x00FF, 0x0000 }, /* R17920 - ADCL_RETUNE_C1_1 */ + [17921] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17921 - ADCL_RETUNE_C1_0 */ + [17922] = { 0x00FF, 0x00FF, 0x0000 }, /* R17922 - ADCL_RETUNE_C2_1 */ + [17923] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17923 - ADCL_RETUNE_C2_0 */ + [17924] = { 0x00FF, 0x00FF, 0x0000 }, /* R17924 - ADCL_RETUNE_C3_1 */ + [17925] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17925 - ADCL_RETUNE_C3_0 */ + [17926] = { 0x00FF, 0x00FF, 0x0000 }, /* R17926 - ADCL_RETUNE_C4_1 */ + [17927] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17927 - ADCL_RETUNE_C4_0 */ + [17928] = { 0x00FF, 0x00FF, 0x0000 }, /* R17928 - ADCL_RETUNE_C5_1 */ + [17929] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17929 - ADCL_RETUNE_C5_0 */ + [17930] = { 0x00FF, 0x00FF, 0x0000 }, /* R17930 - ADCL_RETUNE_C6_1 */ + [17931] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17931 - ADCL_RETUNE_C6_0 */ + [17932] = { 0x00FF, 0x00FF, 0x0000 }, /* R17932 - ADCL_RETUNE_C7_1 */ + [17933] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17933 - ADCL_RETUNE_C7_0 */ + [17934] = { 0x00FF, 0x00FF, 0x0000 }, /* R17934 - ADCL_RETUNE_C8_1 */ + [17935] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17935 - ADCL_RETUNE_C8_0 */ + [17936] = { 0x00FF, 0x00FF, 0x0000 }, /* R17936 - ADCL_RETUNE_C9_1 */ + [17937] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17937 - ADCL_RETUNE_C9_0 */ + [17938] = { 0x00FF, 0x00FF, 0x0000 }, /* R17938 - ADCL_RETUNE_C10_1 */ + [17939] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17939 - ADCL_RETUNE_C10_0 */ + [17940] = { 0x00FF, 0x00FF, 0x0000 }, /* R17940 - ADCL_RETUNE_C11_1 */ + [17941] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17941 - ADCL_RETUNE_C11_0 */ + [17942] = { 0x00FF, 0x00FF, 0x0000 }, /* R17942 - ADCL_RETUNE_C12_1 */ + [17943] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17943 - ADCL_RETUNE_C12_0 */ + [17944] = { 0x00FF, 0x00FF, 0x0000 }, /* R17944 - ADCL_RETUNE_C13_1 */ + [17945] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17945 - ADCL_RETUNE_C13_0 */ + [17946] = { 0x00FF, 0x00FF, 0x0000 }, /* R17946 - ADCL_RETUNE_C14_1 */ + [17947] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17947 - ADCL_RETUNE_C14_0 */ + [17948] = { 0x00FF, 0x00FF, 0x0000 }, /* R17948 - ADCL_RETUNE_C15_1 */ + [17949] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17949 - ADCL_RETUNE_C15_0 */ + [17950] = { 0x00FF, 0x00FF, 0x0000 }, /* R17950 - ADCL_RETUNE_C16_1 */ + [17951] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17951 - ADCL_RETUNE_C16_0 */ + [17952] = { 0x00FF, 0x00FF, 0x0000 }, /* R17952 - ADCL_RETUNE_C17_1 */ + [17953] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17953 - ADCL_RETUNE_C17_0 */ + [17954] = { 0x00FF, 0x00FF, 0x0000 }, /* R17954 - ADCL_RETUNE_C18_1 */ + [17955] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17955 - ADCL_RETUNE_C18_0 */ + [17956] = { 0x00FF, 0x00FF, 0x0000 }, /* R17956 - ADCL_RETUNE_C19_1 */ + [17957] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17957 - ADCL_RETUNE_C19_0 */ + [17958] = { 0x00FF, 0x00FF, 0x0000 }, /* R17958 - ADCL_RETUNE_C20_1 */ + [17959] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17959 - ADCL_RETUNE_C20_0 */ + [17960] = { 0x00FF, 0x00FF, 0x0000 }, /* R17960 - ADCL_RETUNE_C21_1 */ + [17961] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17961 - ADCL_RETUNE_C21_0 */ + [17962] = { 0x00FF, 0x00FF, 0x0000 }, /* R17962 - ADCL_RETUNE_C22_1 */ + [17963] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17963 - ADCL_RETUNE_C22_0 */ + [17964] = { 0x00FF, 0x00FF, 0x0000 }, /* R17964 - ADCL_RETUNE_C23_1 */ + [17965] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17965 - ADCL_RETUNE_C23_0 */ + [17966] = { 0x00FF, 0x00FF, 0x0000 }, /* R17966 - ADCL_RETUNE_C24_1 */ + [17967] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17967 - ADCL_RETUNE_C24_0 */ + [17968] = { 0x00FF, 0x00FF, 0x0000 }, /* R17968 - ADCL_RETUNE_C25_1 */ + [17969] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17969 - ADCL_RETUNE_C25_0 */ + [17970] = { 0x00FF, 0x00FF, 0x0000 }, /* R17970 - ADCL_RETUNE_C26_1 */ + [17971] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17971 - ADCL_RETUNE_C26_0 */ + [17972] = { 0x00FF, 0x00FF, 0x0000 }, /* R17972 - ADCL_RETUNE_C27_1 */ + [17973] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17973 - ADCL_RETUNE_C27_0 */ + [17974] = { 0x00FF, 0x00FF, 0x0000 }, /* R17974 - ADCL_RETUNE_C28_1 */ + [17975] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17975 - ADCL_RETUNE_C28_0 */ + [17976] = { 0x00FF, 0x00FF, 0x0000 }, /* R17976 - ADCL_RETUNE_C29_1 */ + [17977] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17977 - ADCL_RETUNE_C29_0 */ + [17978] = { 0x00FF, 0x00FF, 0x0000 }, /* R17978 - ADCL_RETUNE_C30_1 */ + [17979] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17979 - ADCL_RETUNE_C30_0 */ + [17980] = { 0x00FF, 0x00FF, 0x0000 }, /* R17980 - ADCL_RETUNE_C31_1 */ + [17981] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17981 - ADCL_RETUNE_C31_0 */ + [17982] = { 0x00FF, 0x00FF, 0x0000 }, /* R17982 - ADCL_RETUNE_C32_1 */ + [17983] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R17983 - ADCL_RETUNE_C32_0 */ + [18432] = { 0x00FF, 0x00FF, 0x0000 }, /* R18432 - RETUNEADC_PG2_1 */ + [18433] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18433 - RETUNEADC_PG2_0 */ + [18434] = { 0x00FF, 0x00FF, 0x0000 }, /* R18434 - RETUNEADC_PG_1 */ + [18435] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18435 - RETUNEADC_PG_0 */ + [18944] = { 0x00FF, 0x00FF, 0x0000 }, /* R18944 - ADCR_RETUNE_C1_1 */ + [18945] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18945 - ADCR_RETUNE_C1_0 */ + [18946] = { 0x00FF, 0x00FF, 0x0000 }, /* R18946 - ADCR_RETUNE_C2_1 */ + [18947] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18947 - ADCR_RETUNE_C2_0 */ + [18948] = { 0x00FF, 0x00FF, 0x0000 }, /* R18948 - ADCR_RETUNE_C3_1 */ + [18949] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18949 - ADCR_RETUNE_C3_0 */ + [18950] = { 0x00FF, 0x00FF, 0x0000 }, /* R18950 - ADCR_RETUNE_C4_1 */ + [18951] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18951 - ADCR_RETUNE_C4_0 */ + [18952] = { 0x00FF, 0x00FF, 0x0000 }, /* R18952 - ADCR_RETUNE_C5_1 */ + [18953] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18953 - ADCR_RETUNE_C5_0 */ + [18954] = { 0x00FF, 0x00FF, 0x0000 }, /* R18954 - ADCR_RETUNE_C6_1 */ + [18955] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18955 - ADCR_RETUNE_C6_0 */ + [18956] = { 0x00FF, 0x00FF, 0x0000 }, /* R18956 - ADCR_RETUNE_C7_1 */ + [18957] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18957 - ADCR_RETUNE_C7_0 */ + [18958] = { 0x00FF, 0x00FF, 0x0000 }, /* R18958 - ADCR_RETUNE_C8_1 */ + [18959] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18959 - ADCR_RETUNE_C8_0 */ + [18960] = { 0x00FF, 0x00FF, 0x0000 }, /* R18960 - ADCR_RETUNE_C9_1 */ + [18961] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18961 - ADCR_RETUNE_C9_0 */ + [18962] = { 0x00FF, 0x00FF, 0x0000 }, /* R18962 - ADCR_RETUNE_C10_1 */ + [18963] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18963 - ADCR_RETUNE_C10_0 */ + [18964] = { 0x00FF, 0x00FF, 0x0000 }, /* R18964 - ADCR_RETUNE_C11_1 */ + [18965] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18965 - ADCR_RETUNE_C11_0 */ + [18966] = { 0x00FF, 0x00FF, 0x0000 }, /* R18966 - ADCR_RETUNE_C12_1 */ + [18967] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18967 - ADCR_RETUNE_C12_0 */ + [18968] = { 0x00FF, 0x00FF, 0x0000 }, /* R18968 - ADCR_RETUNE_C13_1 */ + [18969] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18969 - ADCR_RETUNE_C13_0 */ + [18970] = { 0x00FF, 0x00FF, 0x0000 }, /* R18970 - ADCR_RETUNE_C14_1 */ + [18971] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18971 - ADCR_RETUNE_C14_0 */ + [18972] = { 0x00FF, 0x00FF, 0x0000 }, /* R18972 - ADCR_RETUNE_C15_1 */ + [18973] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18973 - ADCR_RETUNE_C15_0 */ + [18974] = { 0x00FF, 0x00FF, 0x0000 }, /* R18974 - ADCR_RETUNE_C16_1 */ + [18975] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18975 - ADCR_RETUNE_C16_0 */ + [18976] = { 0x00FF, 0x00FF, 0x0000 }, /* R18976 - ADCR_RETUNE_C17_1 */ + [18977] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18977 - ADCR_RETUNE_C17_0 */ + [18978] = { 0x00FF, 0x00FF, 0x0000 }, /* R18978 - ADCR_RETUNE_C18_1 */ + [18979] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18979 - ADCR_RETUNE_C18_0 */ + [18980] = { 0x00FF, 0x00FF, 0x0000 }, /* R18980 - ADCR_RETUNE_C19_1 */ + [18981] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18981 - ADCR_RETUNE_C19_0 */ + [18982] = { 0x00FF, 0x00FF, 0x0000 }, /* R18982 - ADCR_RETUNE_C20_1 */ + [18983] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18983 - ADCR_RETUNE_C20_0 */ + [18984] = { 0x00FF, 0x00FF, 0x0000 }, /* R18984 - ADCR_RETUNE_C21_1 */ + [18985] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18985 - ADCR_RETUNE_C21_0 */ + [18986] = { 0x00FF, 0x00FF, 0x0000 }, /* R18986 - ADCR_RETUNE_C22_1 */ + [18987] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18987 - ADCR_RETUNE_C22_0 */ + [18988] = { 0x00FF, 0x00FF, 0x0000 }, /* R18988 - ADCR_RETUNE_C23_1 */ + [18989] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18989 - ADCR_RETUNE_C23_0 */ + [18990] = { 0x00FF, 0x00FF, 0x0000 }, /* R18990 - ADCR_RETUNE_C24_1 */ + [18991] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18991 - ADCR_RETUNE_C24_0 */ + [18992] = { 0x00FF, 0x00FF, 0x0000 }, /* R18992 - ADCR_RETUNE_C25_1 */ + [18993] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18993 - ADCR_RETUNE_C25_0 */ + [18994] = { 0x00FF, 0x00FF, 0x0000 }, /* R18994 - ADCR_RETUNE_C26_1 */ + [18995] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18995 - ADCR_RETUNE_C26_0 */ + [18996] = { 0x00FF, 0x00FF, 0x0000 }, /* R18996 - ADCR_RETUNE_C27_1 */ + [18997] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18997 - ADCR_RETUNE_C27_0 */ + [18998] = { 0x00FF, 0x00FF, 0x0000 }, /* R18998 - ADCR_RETUNE_C28_1 */ + [18999] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R18999 - ADCR_RETUNE_C28_0 */ + [19000] = { 0x00FF, 0x00FF, 0x0000 }, /* R19000 - ADCR_RETUNE_C29_1 */ + [19001] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19001 - ADCR_RETUNE_C29_0 */ + [19002] = { 0x00FF, 0x00FF, 0x0000 }, /* R19002 - ADCR_RETUNE_C30_1 */ + [19003] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19003 - ADCR_RETUNE_C30_0 */ + [19004] = { 0x00FF, 0x00FF, 0x0000 }, /* R19004 - ADCR_RETUNE_C31_1 */ + [19005] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19005 - ADCR_RETUNE_C31_0 */ + [19006] = { 0x00FF, 0x00FF, 0x0000 }, /* R19006 - ADCR_RETUNE_C32_1 */ + [19007] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19007 - ADCR_RETUNE_C32_0 */ + [19456] = { 0x00FF, 0x00FF, 0x0000 }, /* R19456 - DACL_RETUNE_C1_1 */ + [19457] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19457 - DACL_RETUNE_C1_0 */ + [19458] = { 0x00FF, 0x00FF, 0x0000 }, /* R19458 - DACL_RETUNE_C2_1 */ + [19459] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19459 - DACL_RETUNE_C2_0 */ + [19460] = { 0x00FF, 0x00FF, 0x0000 }, /* R19460 - DACL_RETUNE_C3_1 */ + [19461] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19461 - DACL_RETUNE_C3_0 */ + [19462] = { 0x00FF, 0x00FF, 0x0000 }, /* R19462 - DACL_RETUNE_C4_1 */ + [19463] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19463 - DACL_RETUNE_C4_0 */ + [19464] = { 0x00FF, 0x00FF, 0x0000 }, /* R19464 - DACL_RETUNE_C5_1 */ + [19465] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19465 - DACL_RETUNE_C5_0 */ + [19466] = { 0x00FF, 0x00FF, 0x0000 }, /* R19466 - DACL_RETUNE_C6_1 */ + [19467] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19467 - DACL_RETUNE_C6_0 */ + [19468] = { 0x00FF, 0x00FF, 0x0000 }, /* R19468 - DACL_RETUNE_C7_1 */ + [19469] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19469 - DACL_RETUNE_C7_0 */ + [19470] = { 0x00FF, 0x00FF, 0x0000 }, /* R19470 - DACL_RETUNE_C8_1 */ + [19471] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19471 - DACL_RETUNE_C8_0 */ + [19472] = { 0x00FF, 0x00FF, 0x0000 }, /* R19472 - DACL_RETUNE_C9_1 */ + [19473] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19473 - DACL_RETUNE_C9_0 */ + [19474] = { 0x00FF, 0x00FF, 0x0000 }, /* R19474 - DACL_RETUNE_C10_1 */ + [19475] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19475 - DACL_RETUNE_C10_0 */ + [19476] = { 0x00FF, 0x00FF, 0x0000 }, /* R19476 - DACL_RETUNE_C11_1 */ + [19477] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19477 - DACL_RETUNE_C11_0 */ + [19478] = { 0x00FF, 0x00FF, 0x0000 }, /* R19478 - DACL_RETUNE_C12_1 */ + [19479] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19479 - DACL_RETUNE_C12_0 */ + [19480] = { 0x00FF, 0x00FF, 0x0000 }, /* R19480 - DACL_RETUNE_C13_1 */ + [19481] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19481 - DACL_RETUNE_C13_0 */ + [19482] = { 0x00FF, 0x00FF, 0x0000 }, /* R19482 - DACL_RETUNE_C14_1 */ + [19483] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19483 - DACL_RETUNE_C14_0 */ + [19484] = { 0x00FF, 0x00FF, 0x0000 }, /* R19484 - DACL_RETUNE_C15_1 */ + [19485] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19485 - DACL_RETUNE_C15_0 */ + [19486] = { 0x00FF, 0x00FF, 0x0000 }, /* R19486 - DACL_RETUNE_C16_1 */ + [19487] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19487 - DACL_RETUNE_C16_0 */ + [19488] = { 0x00FF, 0x00FF, 0x0000 }, /* R19488 - DACL_RETUNE_C17_1 */ + [19489] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19489 - DACL_RETUNE_C17_0 */ + [19490] = { 0x00FF, 0x00FF, 0x0000 }, /* R19490 - DACL_RETUNE_C18_1 */ + [19491] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19491 - DACL_RETUNE_C18_0 */ + [19492] = { 0x00FF, 0x00FF, 0x0000 }, /* R19492 - DACL_RETUNE_C19_1 */ + [19493] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19493 - DACL_RETUNE_C19_0 */ + [19494] = { 0x00FF, 0x00FF, 0x0000 }, /* R19494 - DACL_RETUNE_C20_1 */ + [19495] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19495 - DACL_RETUNE_C20_0 */ + [19496] = { 0x00FF, 0x00FF, 0x0000 }, /* R19496 - DACL_RETUNE_C21_1 */ + [19497] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19497 - DACL_RETUNE_C21_0 */ + [19498] = { 0x00FF, 0x00FF, 0x0000 }, /* R19498 - DACL_RETUNE_C22_1 */ + [19499] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19499 - DACL_RETUNE_C22_0 */ + [19500] = { 0x00FF, 0x00FF, 0x0000 }, /* R19500 - DACL_RETUNE_C23_1 */ + [19501] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19501 - DACL_RETUNE_C23_0 */ + [19502] = { 0x00FF, 0x00FF, 0x0000 }, /* R19502 - DACL_RETUNE_C24_1 */ + [19503] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19503 - DACL_RETUNE_C24_0 */ + [19504] = { 0x00FF, 0x00FF, 0x0000 }, /* R19504 - DACL_RETUNE_C25_1 */ + [19505] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19505 - DACL_RETUNE_C25_0 */ + [19506] = { 0x00FF, 0x00FF, 0x0000 }, /* R19506 - DACL_RETUNE_C26_1 */ + [19507] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19507 - DACL_RETUNE_C26_0 */ + [19508] = { 0x00FF, 0x00FF, 0x0000 }, /* R19508 - DACL_RETUNE_C27_1 */ + [19509] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19509 - DACL_RETUNE_C27_0 */ + [19510] = { 0x00FF, 0x00FF, 0x0000 }, /* R19510 - DACL_RETUNE_C28_1 */ + [19511] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19511 - DACL_RETUNE_C28_0 */ + [19512] = { 0x00FF, 0x00FF, 0x0000 }, /* R19512 - DACL_RETUNE_C29_1 */ + [19513] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19513 - DACL_RETUNE_C29_0 */ + [19514] = { 0x00FF, 0x00FF, 0x0000 }, /* R19514 - DACL_RETUNE_C30_1 */ + [19515] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19515 - DACL_RETUNE_C30_0 */ + [19516] = { 0x00FF, 0x00FF, 0x0000 }, /* R19516 - DACL_RETUNE_C31_1 */ + [19517] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19517 - DACL_RETUNE_C31_0 */ + [19518] = { 0x00FF, 0x00FF, 0x0000 }, /* R19518 - DACL_RETUNE_C32_1 */ + [19519] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19519 - DACL_RETUNE_C32_0 */ + [19968] = { 0x00FF, 0x00FF, 0x0000 }, /* R19968 - RETUNEDAC_PG2_1 */ + [19969] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19969 - RETUNEDAC_PG2_0 */ + [19970] = { 0x00FF, 0x00FF, 0x0000 }, /* R19970 - RETUNEDAC_PG_1 */ + [19971] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R19971 - RETUNEDAC_PG_0 */ + [20480] = { 0x00FF, 0x00FF, 0x0000 }, /* R20480 - DACR_RETUNE_C1_1 */ + [20481] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20481 - DACR_RETUNE_C1_0 */ + [20482] = { 0x00FF, 0x00FF, 0x0000 }, /* R20482 - DACR_RETUNE_C2_1 */ + [20483] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20483 - DACR_RETUNE_C2_0 */ + [20484] = { 0x00FF, 0x00FF, 0x0000 }, /* R20484 - DACR_RETUNE_C3_1 */ + [20485] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20485 - DACR_RETUNE_C3_0 */ + [20486] = { 0x00FF, 0x00FF, 0x0000 }, /* R20486 - DACR_RETUNE_C4_1 */ + [20487] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20487 - DACR_RETUNE_C4_0 */ + [20488] = { 0x00FF, 0x00FF, 0x0000 }, /* R20488 - DACR_RETUNE_C5_1 */ + [20489] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20489 - DACR_RETUNE_C5_0 */ + [20490] = { 0x00FF, 0x00FF, 0x0000 }, /* R20490 - DACR_RETUNE_C6_1 */ + [20491] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20491 - DACR_RETUNE_C6_0 */ + [20492] = { 0x00FF, 0x00FF, 0x0000 }, /* R20492 - DACR_RETUNE_C7_1 */ + [20493] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20493 - DACR_RETUNE_C7_0 */ + [20494] = { 0x00FF, 0x00FF, 0x0000 }, /* R20494 - DACR_RETUNE_C8_1 */ + [20495] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20495 - DACR_RETUNE_C8_0 */ + [20496] = { 0x00FF, 0x00FF, 0x0000 }, /* R20496 - DACR_RETUNE_C9_1 */ + [20497] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20497 - DACR_RETUNE_C9_0 */ + [20498] = { 0x00FF, 0x00FF, 0x0000 }, /* R20498 - DACR_RETUNE_C10_1 */ + [20499] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20499 - DACR_RETUNE_C10_0 */ + [20500] = { 0x00FF, 0x00FF, 0x0000 }, /* R20500 - DACR_RETUNE_C11_1 */ + [20501] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20501 - DACR_RETUNE_C11_0 */ + [20502] = { 0x00FF, 0x00FF, 0x0000 }, /* R20502 - DACR_RETUNE_C12_1 */ + [20503] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20503 - DACR_RETUNE_C12_0 */ + [20504] = { 0x00FF, 0x00FF, 0x0000 }, /* R20504 - DACR_RETUNE_C13_1 */ + [20505] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20505 - DACR_RETUNE_C13_0 */ + [20506] = { 0x00FF, 0x00FF, 0x0000 }, /* R20506 - DACR_RETUNE_C14_1 */ + [20507] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20507 - DACR_RETUNE_C14_0 */ + [20508] = { 0x00FF, 0x00FF, 0x0000 }, /* R20508 - DACR_RETUNE_C15_1 */ + [20509] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20509 - DACR_RETUNE_C15_0 */ + [20510] = { 0x00FF, 0x00FF, 0x0000 }, /* R20510 - DACR_RETUNE_C16_1 */ + [20511] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20511 - DACR_RETUNE_C16_0 */ + [20512] = { 0x00FF, 0x00FF, 0x0000 }, /* R20512 - DACR_RETUNE_C17_1 */ + [20513] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20513 - DACR_RETUNE_C17_0 */ + [20514] = { 0x00FF, 0x00FF, 0x0000 }, /* R20514 - DACR_RETUNE_C18_1 */ + [20515] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20515 - DACR_RETUNE_C18_0 */ + [20516] = { 0x00FF, 0x00FF, 0x0000 }, /* R20516 - DACR_RETUNE_C19_1 */ + [20517] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20517 - DACR_RETUNE_C19_0 */ + [20518] = { 0x00FF, 0x00FF, 0x0000 }, /* R20518 - DACR_RETUNE_C20_1 */ + [20519] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20519 - DACR_RETUNE_C20_0 */ + [20520] = { 0x00FF, 0x00FF, 0x0000 }, /* R20520 - DACR_RETUNE_C21_1 */ + [20521] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20521 - DACR_RETUNE_C21_0 */ + [20522] = { 0x00FF, 0x00FF, 0x0000 }, /* R20522 - DACR_RETUNE_C22_1 */ + [20523] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20523 - DACR_RETUNE_C22_0 */ + [20524] = { 0x00FF, 0x00FF, 0x0000 }, /* R20524 - DACR_RETUNE_C23_1 */ + [20525] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20525 - DACR_RETUNE_C23_0 */ + [20526] = { 0x00FF, 0x00FF, 0x0000 }, /* R20526 - DACR_RETUNE_C24_1 */ + [20527] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20527 - DACR_RETUNE_C24_0 */ + [20528] = { 0x00FF, 0x00FF, 0x0000 }, /* R20528 - DACR_RETUNE_C25_1 */ + [20529] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20529 - DACR_RETUNE_C25_0 */ + [20530] = { 0x00FF, 0x00FF, 0x0000 }, /* R20530 - DACR_RETUNE_C26_1 */ + [20531] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20531 - DACR_RETUNE_C26_0 */ + [20532] = { 0x00FF, 0x00FF, 0x0000 }, /* R20532 - DACR_RETUNE_C27_1 */ + [20533] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20533 - DACR_RETUNE_C27_0 */ + [20534] = { 0x00FF, 0x00FF, 0x0000 }, /* R20534 - DACR_RETUNE_C28_1 */ + [20535] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20535 - DACR_RETUNE_C28_0 */ + [20536] = { 0x00FF, 0x00FF, 0x0000 }, /* R20536 - DACR_RETUNE_C29_1 */ + [20537] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20537 - DACR_RETUNE_C29_0 */ + [20538] = { 0x00FF, 0x00FF, 0x0000 }, /* R20538 - DACR_RETUNE_C30_1 */ + [20539] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20539 - DACR_RETUNE_C30_0 */ + [20540] = { 0x00FF, 0x00FF, 0x0000 }, /* R20540 - DACR_RETUNE_C31_1 */ + [20541] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20541 - DACR_RETUNE_C31_0 */ + [20542] = { 0x00FF, 0x00FF, 0x0000 }, /* R20542 - DACR_RETUNE_C32_1 */ + [20543] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20543 - DACR_RETUNE_C32_0 */ + [20992] = { 0x00FF, 0x00FF, 0x0000 }, /* R20992 - VSS_XHD2_1 */ + [20993] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20993 - VSS_XHD2_0 */ + [20994] = { 0x00FF, 0x00FF, 0x0000 }, /* R20994 - VSS_XHD3_1 */ + [20995] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20995 - VSS_XHD3_0 */ + [20996] = { 0x00FF, 0x00FF, 0x0000 }, /* R20996 - VSS_XHN1_1 */ + [20997] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20997 - VSS_XHN1_0 */ + [20998] = { 0x00FF, 0x00FF, 0x0000 }, /* R20998 - VSS_XHN2_1 */ + [20999] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R20999 - VSS_XHN2_0 */ + [21000] = { 0x00FF, 0x00FF, 0x0000 }, /* R21000 - VSS_XHN3_1 */ + [21001] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21001 - VSS_XHN3_0 */ + [21002] = { 0x00FF, 0x00FF, 0x0000 }, /* R21002 - VSS_XLA_1 */ + [21003] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21003 - VSS_XLA_0 */ + [21004] = { 0x00FF, 0x00FF, 0x0000 }, /* R21004 - VSS_XLB_1 */ + [21005] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21005 - VSS_XLB_0 */ + [21006] = { 0x00FF, 0x00FF, 0x0000 }, /* R21006 - VSS_XLG_1 */ + [21007] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21007 - VSS_XLG_0 */ + [21008] = { 0x00FF, 0x00FF, 0x0000 }, /* R21008 - VSS_PG2_1 */ + [21009] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21009 - VSS_PG2_0 */ + [21010] = { 0x00FF, 0x00FF, 0x0000 }, /* R21010 - VSS_PG_1 */ + [21011] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21011 - VSS_PG_0 */ + [21012] = { 0x00FF, 0x00FF, 0x0000 }, /* R21012 - VSS_XTD1_1 */ + [21013] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21013 - VSS_XTD1_0 */ + [21014] = { 0x00FF, 0x00FF, 0x0000 }, /* R21014 - VSS_XTD2_1 */ + [21015] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21015 - VSS_XTD2_0 */ + [21016] = { 0x00FF, 0x00FF, 0x0000 }, /* R21016 - VSS_XTD3_1 */ + [21017] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21017 - VSS_XTD3_0 */ + [21018] = { 0x00FF, 0x00FF, 0x0000 }, /* R21018 - VSS_XTD4_1 */ + [21019] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21019 - VSS_XTD4_0 */ + [21020] = { 0x00FF, 0x00FF, 0x0000 }, /* R21020 - VSS_XTD5_1 */ + [21021] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21021 - VSS_XTD5_0 */ + [21022] = { 0x00FF, 0x00FF, 0x0000 }, /* R21022 - VSS_XTD6_1 */ + [21023] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21023 - VSS_XTD6_0 */ + [21024] = { 0x00FF, 0x00FF, 0x0000 }, /* R21024 - VSS_XTD7_1 */ + [21025] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21025 - VSS_XTD7_0 */ + [21026] = { 0x00FF, 0x00FF, 0x0000 }, /* R21026 - VSS_XTD8_1 */ + [21027] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21027 - VSS_XTD8_0 */ + [21028] = { 0x00FF, 0x00FF, 0x0000 }, /* R21028 - VSS_XTD9_1 */ + [21029] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21029 - VSS_XTD9_0 */ + [21030] = { 0x00FF, 0x00FF, 0x0000 }, /* R21030 - VSS_XTD10_1 */ + [21031] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21031 - VSS_XTD10_0 */ + [21032] = { 0x00FF, 0x00FF, 0x0000 }, /* R21032 - VSS_XTD11_1 */ + [21033] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21033 - VSS_XTD11_0 */ + [21034] = { 0x00FF, 0x00FF, 0x0000 }, /* R21034 - VSS_XTD12_1 */ + [21035] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21035 - VSS_XTD12_0 */ + [21036] = { 0x00FF, 0x00FF, 0x0000 }, /* R21036 - VSS_XTD13_1 */ + [21037] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21037 - VSS_XTD13_0 */ + [21038] = { 0x00FF, 0x00FF, 0x0000 }, /* R21038 - VSS_XTD14_1 */ + [21039] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21039 - VSS_XTD14_0 */ + [21040] = { 0x00FF, 0x00FF, 0x0000 }, /* R21040 - VSS_XTD15_1 */ + [21041] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21041 - VSS_XTD15_0 */ + [21042] = { 0x00FF, 0x00FF, 0x0000 }, /* R21042 - VSS_XTD16_1 */ + [21043] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21043 - VSS_XTD16_0 */ + [21044] = { 0x00FF, 0x00FF, 0x0000 }, /* R21044 - VSS_XTD17_1 */ + [21045] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21045 - VSS_XTD17_0 */ + [21046] = { 0x00FF, 0x00FF, 0x0000 }, /* R21046 - VSS_XTD18_1 */ + [21047] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21047 - VSS_XTD18_0 */ + [21048] = { 0x00FF, 0x00FF, 0x0000 }, /* R21048 - VSS_XTD19_1 */ + [21049] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21049 - VSS_XTD19_0 */ + [21050] = { 0x00FF, 0x00FF, 0x0000 }, /* R21050 - VSS_XTD20_1 */ + [21051] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21051 - VSS_XTD20_0 */ + [21052] = { 0x00FF, 0x00FF, 0x0000 }, /* R21052 - VSS_XTD21_1 */ + [21053] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21053 - VSS_XTD21_0 */ + [21054] = { 0x00FF, 0x00FF, 0x0000 }, /* R21054 - VSS_XTD22_1 */ + [21055] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21055 - VSS_XTD22_0 */ + [21056] = { 0x00FF, 0x00FF, 0x0000 }, /* R21056 - VSS_XTD23_1 */ + [21057] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21057 - VSS_XTD23_0 */ + [21058] = { 0x00FF, 0x00FF, 0x0000 }, /* R21058 - VSS_XTD24_1 */ + [21059] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21059 - VSS_XTD24_0 */ + [21060] = { 0x00FF, 0x00FF, 0x0000 }, /* R21060 - VSS_XTD25_1 */ + [21061] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21061 - VSS_XTD25_0 */ + [21062] = { 0x00FF, 0x00FF, 0x0000 }, /* R21062 - VSS_XTD26_1 */ + [21063] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21063 - VSS_XTD26_0 */ + [21064] = { 0x00FF, 0x00FF, 0x0000 }, /* R21064 - VSS_XTD27_1 */ + [21065] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21065 - VSS_XTD27_0 */ + [21066] = { 0x00FF, 0x00FF, 0x0000 }, /* R21066 - VSS_XTD28_1 */ + [21067] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21067 - VSS_XTD28_0 */ + [21068] = { 0x00FF, 0x00FF, 0x0000 }, /* R21068 - VSS_XTD29_1 */ + [21069] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21069 - VSS_XTD29_0 */ + [21070] = { 0x00FF, 0x00FF, 0x0000 }, /* R21070 - VSS_XTD30_1 */ + [21071] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21071 - VSS_XTD30_0 */ + [21072] = { 0x00FF, 0x00FF, 0x0000 }, /* R21072 - VSS_XTD31_1 */ + [21073] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21073 - VSS_XTD31_0 */ + [21074] = { 0x00FF, 0x00FF, 0x0000 }, /* R21074 - VSS_XTD32_1 */ + [21075] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21075 - VSS_XTD32_0 */ + [21076] = { 0x00FF, 0x00FF, 0x0000 }, /* R21076 - VSS_XTS1_1 */ + [21077] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21077 - VSS_XTS1_0 */ + [21078] = { 0x00FF, 0x00FF, 0x0000 }, /* R21078 - VSS_XTS2_1 */ + [21079] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21079 - VSS_XTS2_0 */ + [21080] = { 0x00FF, 0x00FF, 0x0000 }, /* R21080 - VSS_XTS3_1 */ + [21081] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21081 - VSS_XTS3_0 */ + [21082] = { 0x00FF, 0x00FF, 0x0000 }, /* R21082 - VSS_XTS4_1 */ + [21083] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21083 - VSS_XTS4_0 */ + [21084] = { 0x00FF, 0x00FF, 0x0000 }, /* R21084 - VSS_XTS5_1 */ + [21085] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21085 - VSS_XTS5_0 */ + [21086] = { 0x00FF, 0x00FF, 0x0000 }, /* R21086 - VSS_XTS6_1 */ + [21087] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21087 - VSS_XTS6_0 */ + [21088] = { 0x00FF, 0x00FF, 0x0000 }, /* R21088 - VSS_XTS7_1 */ + [21089] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21089 - VSS_XTS7_0 */ + [21090] = { 0x00FF, 0x00FF, 0x0000 }, /* R21090 - VSS_XTS8_1 */ + [21091] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21091 - VSS_XTS8_0 */ + [21092] = { 0x00FF, 0x00FF, 0x0000 }, /* R21092 - VSS_XTS9_1 */ + [21093] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21093 - VSS_XTS9_0 */ + [21094] = { 0x00FF, 0x00FF, 0x0000 }, /* R21094 - VSS_XTS10_1 */ + [21095] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21095 - VSS_XTS10_0 */ + [21096] = { 0x00FF, 0x00FF, 0x0000 }, /* R21096 - VSS_XTS11_1 */ + [21097] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21097 - VSS_XTS11_0 */ + [21098] = { 0x00FF, 0x00FF, 0x0000 }, /* R21098 - VSS_XTS12_1 */ + [21099] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21099 - VSS_XTS12_0 */ + [21100] = { 0x00FF, 0x00FF, 0x0000 }, /* R21100 - VSS_XTS13_1 */ + [21101] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21101 - VSS_XTS13_0 */ + [21102] = { 0x00FF, 0x00FF, 0x0000 }, /* R21102 - VSS_XTS14_1 */ + [21103] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21103 - VSS_XTS14_0 */ + [21104] = { 0x00FF, 0x00FF, 0x0000 }, /* R21104 - VSS_XTS15_1 */ + [21105] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21105 - VSS_XTS15_0 */ + [21106] = { 0x00FF, 0x00FF, 0x0000 }, /* R21106 - VSS_XTS16_1 */ + [21107] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21107 - VSS_XTS16_0 */ + [21108] = { 0x00FF, 0x00FF, 0x0000 }, /* R21108 - VSS_XTS17_1 */ + [21109] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21109 - VSS_XTS17_0 */ + [21110] = { 0x00FF, 0x00FF, 0x0000 }, /* R21110 - VSS_XTS18_1 */ + [21111] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21111 - VSS_XTS18_0 */ + [21112] = { 0x00FF, 0x00FF, 0x0000 }, /* R21112 - VSS_XTS19_1 */ + [21113] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21113 - VSS_XTS19_0 */ + [21114] = { 0x00FF, 0x00FF, 0x0000 }, /* R21114 - VSS_XTS20_1 */ + [21115] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21115 - VSS_XTS20_0 */ + [21116] = { 0x00FF, 0x00FF, 0x0000 }, /* R21116 - VSS_XTS21_1 */ + [21117] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21117 - VSS_XTS21_0 */ + [21118] = { 0x00FF, 0x00FF, 0x0000 }, /* R21118 - VSS_XTS22_1 */ + [21119] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21119 - VSS_XTS22_0 */ + [21120] = { 0x00FF, 0x00FF, 0x0000 }, /* R21120 - VSS_XTS23_1 */ + [21121] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21121 - VSS_XTS23_0 */ + [21122] = { 0x00FF, 0x00FF, 0x0000 }, /* R21122 - VSS_XTS24_1 */ + [21123] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21123 - VSS_XTS24_0 */ + [21124] = { 0x00FF, 0x00FF, 0x0000 }, /* R21124 - VSS_XTS25_1 */ + [21125] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21125 - VSS_XTS25_0 */ + [21126] = { 0x00FF, 0x00FF, 0x0000 }, /* R21126 - VSS_XTS26_1 */ + [21127] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21127 - VSS_XTS26_0 */ + [21128] = { 0x00FF, 0x00FF, 0x0000 }, /* R21128 - VSS_XTS27_1 */ + [21129] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21129 - VSS_XTS27_0 */ + [21130] = { 0x00FF, 0x00FF, 0x0000 }, /* R21130 - VSS_XTS28_1 */ + [21131] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21131 - VSS_XTS28_0 */ + [21132] = { 0x00FF, 0x00FF, 0x0000 }, /* R21132 - VSS_XTS29_1 */ + [21133] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21133 - VSS_XTS29_0 */ + [21134] = { 0x00FF, 0x00FF, 0x0000 }, /* R21134 - VSS_XTS30_1 */ + [21135] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21135 - VSS_XTS30_0 */ + [21136] = { 0x00FF, 0x00FF, 0x0000 }, /* R21136 - VSS_XTS31_1 */ + [21137] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21137 - VSS_XTS31_0 */ + [21138] = { 0x00FF, 0x00FF, 0x0000 }, /* R21138 - VSS_XTS32_1 */ + [21139] = { 0xFFFF, 0xFFFF, 0x0000 }, /* R21139 - VSS_XTS32_0 */ +}; + static int wm8962_volatile_register(unsigned int reg) { if (wm8962_reg_access[reg].vol) diff --git a/sound/soc/codecs/wm8962.h b/sound/soc/codecs/wm8962.h index 588726df..a1a5d52 100644 --- a/sound/soc/codecs/wm8962.h +++ b/sound/soc/codecs/wm8962.h @@ -3775,15 +3775,6 @@ #define WM8962_VSS_ENA_SHIFT 0 /* VSS_ENA */ #define WM8962_VSS_ENA_WIDTH 1 /* VSS_ENA */ -struct wm8962_reg_access { - u16 read; - u16 write; - u16 vol; -}; - -extern -const struct wm8962_reg_access wm8962_reg_access[WM8962_MAX_REGISTER + 1]; - int wm8962_mic_detect(struct snd_soc_codec *codec, struct snd_soc_jack *jack); #endif -- cgit v1.1 From fe3e2e7ff2da41bd7a985c4c206e05a95ebe7a6b Mon Sep 17 00:00:00 2001 From: Dan Carpenter Date: Sat, 9 Oct 2010 21:31:31 +0200 Subject: ASoC: checking kzalloc() for IS_ERR() instead of NULL There is a typo here that got copy and pasted to several probe functions. kzalloc() returns NULL on allocation failures and not an ERR_PTR. Signed-off-by: Dan Carpenter Acked-by: Dimitris Papastamos Signed-off-by: Mark Brown --- sound/soc/codecs/wm8804.c | 8 ++++---- sound/soc/codecs/wm8985.c | 8 ++++---- 2 files changed, 8 insertions(+), 8 deletions(-) (limited to 'sound') diff --git a/sound/soc/codecs/wm8804.c b/sound/soc/codecs/wm8804.c index 642b07c..4599e8e 100644 --- a/sound/soc/codecs/wm8804.c +++ b/sound/soc/codecs/wm8804.c @@ -720,8 +720,8 @@ static int __devinit wm8804_spi_probe(struct spi_device *spi) int ret; wm8804 = kzalloc(sizeof *wm8804, GFP_KERNEL); - if (IS_ERR(wm8804)) - return PTR_ERR(wm8804); + if (!wm8804) + return -ENOMEM; wm8804->control_type = SND_SOC_SPI; spi_set_drvdata(spi, wm8804); @@ -758,8 +758,8 @@ static __devinit int wm8804_i2c_probe(struct i2c_client *i2c, int ret; wm8804 = kzalloc(sizeof *wm8804, GFP_KERNEL); - if (IS_ERR(wm8804)) - return PTR_ERR(wm8804); + if (!wm8804) + return -ENOMEM; wm8804->control_type = SND_SOC_I2C; i2c_set_clientdata(i2c, wm8804); diff --git a/sound/soc/codecs/wm8985.c b/sound/soc/codecs/wm8985.c index ae9020a..fd2e7cc 100644 --- a/sound/soc/codecs/wm8985.c +++ b/sound/soc/codecs/wm8985.c @@ -1079,8 +1079,8 @@ static int __devinit wm8985_spi_probe(struct spi_device *spi) int ret; wm8985 = kzalloc(sizeof *wm8985, GFP_KERNEL); - if (IS_ERR(wm8985)) - return PTR_ERR(wm8985); + if (!wm8985) + return -ENOMEM; wm8985->control_type = SND_SOC_SPI; spi_set_drvdata(spi, wm8985); @@ -1117,8 +1117,8 @@ static __devinit int wm8985_i2c_probe(struct i2c_client *i2c, int ret; wm8985 = kzalloc(sizeof *wm8985, GFP_KERNEL); - if (IS_ERR(wm8985)) - return PTR_ERR(wm8985); + if (!wm8985) + return -ENOMEM; wm8985->control_type = SND_SOC_I2C; i2c_set_clientdata(i2c, wm8985); -- cgit v1.1 From d4cfa4d12f46e2520f4c1d1a92e891ce068b7464 Mon Sep 17 00:00:00 2001 From: Dan Carpenter Date: Sun, 10 Oct 2010 19:33:52 +0200 Subject: OSS: soundcard: locking bug in sound_ioctl() We shouldn't return directly here because we're still holding the &soundcard_mutex. This bug goes all the way back to the start of git. It's strange that no one has complained about it as a runtime bug. CC: stable@kernel.org Signed-off-by: Dan Carpenter Acked-by: Arnd Bergmann Signed-off-by: Takashi Iwai --- sound/oss/soundcard.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'sound') diff --git a/sound/oss/soundcard.c b/sound/oss/soundcard.c index 92aa762..07f803e 100644 --- a/sound/oss/soundcard.c +++ b/sound/oss/soundcard.c @@ -391,11 +391,11 @@ static long sound_ioctl(struct file *file, unsigned int cmd, unsigned long arg) case SND_DEV_DSP: case SND_DEV_DSP16: case SND_DEV_AUDIO: - return audio_ioctl(dev, file, cmd, p); + ret = audio_ioctl(dev, file, cmd, p); break; case SND_DEV_MIDIN: - return MIDIbuf_ioctl(dev, file, cmd, p); + ret = MIDIbuf_ioctl(dev, file, cmd, p); break; } -- cgit v1.1 From b7d22ccf08d67d13f77a9580d07e7f72e6241213 Mon Sep 17 00:00:00 2001 From: Dan Carpenter Date: Sun, 10 Oct 2010 19:34:22 +0200 Subject: OSS: soundcard: fix return value of sound_open() Signed-off-by: Dan Carpenter Signed-off-by: Takashi Iwai --- sound/oss/soundcard.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/oss/soundcard.c b/sound/oss/soundcard.c index a5ab61e..46c0d03 100644 --- a/sound/oss/soundcard.c +++ b/sound/oss/soundcard.c @@ -249,7 +249,7 @@ static int sound_open(struct inode *inode, struct file *file) } mutex_unlock(&soundcard_mutex); - return 0; + return retval; } static int sound_release(struct inode *inode, struct file *file) -- cgit v1.1 From 9b2167d59f38691b86430ce559c7fa9d4f973b1f Mon Sep 17 00:00:00 2001 From: Luke Yelavich Date: Wed, 6 Oct 2010 15:45:46 +1100 Subject: ALSA: hda - Add another HP DV6 quirk BugLink: https://bugs.launchpad.net/bugs/653420 Add another HP DV6 notebook (103c:363e) to use STAC_HP_DV5. Signed-off-by: Luke Yelavich Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_sigmatel.c | 2 ++ 1 file changed, 2 insertions(+) (limited to 'sound') diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c index 95148e5..c16c5ba 100644 --- a/sound/pci/hda/patch_sigmatel.c +++ b/sound/pci/hda/patch_sigmatel.c @@ -1747,6 +1747,8 @@ static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = { "HP dv6", STAC_HP_DV5), SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3061, "HP dv6", STAC_HP_DV5), /* HP dv6-1110ax */ + SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x363e, + "HP DV6", STAC_HP_DV5), SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x7010, "HP", STAC_HP_DV5), SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233, -- cgit v1.1 From 1d2019fb6be2f318f0aa85be5f224f47a5f006fe Mon Sep 17 00:00:00 2001 From: Nicolas Kaiser Date: Tue, 5 Oct 2010 17:38:12 +0200 Subject: ALSA: sound/usb/usx2y: simplify conditional Simplify conditional: (a || (!a && b)) => (a || b) Signed-off-by: Nicolas Kaiser Signed-off-by: Takashi Iwai --- sound/usb/usx2y/usx2yhwdeppcm.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/usb/usx2y/usx2yhwdeppcm.c b/sound/usb/usx2y/usx2yhwdeppcm.c index 2a528e5..3146a81 100644 --- a/sound/usb/usx2y/usx2yhwdeppcm.c +++ b/sound/usb/usx2y/usx2yhwdeppcm.c @@ -54,7 +54,7 @@ #include #include "usbusx2yaudio.c" -#if defined(USX2Y_NRPACKS_VARIABLE) || (!defined(USX2Y_NRPACKS_VARIABLE) && USX2Y_NRPACKS == 1) +#if defined(USX2Y_NRPACKS_VARIABLE) || USX2Y_NRPACKS == 1 #include -- cgit v1.1 From f46119b73425df9d1e05c5d5e909a993d95b0218 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Mon, 11 Oct 2010 14:46:35 +0200 Subject: ALSA: hda - Add model=mbp55 entry for MacBookPro 7,1 Reference: Novell bnc#645066 https://bugzilla.novell.com/show_bug.cgi?id=645066 Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_cirrus.c | 1 + 1 file changed, 1 insertion(+) (limited to 'sound') diff --git a/sound/pci/hda/patch_cirrus.c b/sound/pci/hda/patch_cirrus.c index 5c00106..d9a3dbc 100644 --- a/sound/pci/hda/patch_cirrus.c +++ b/sound/pci/hda/patch_cirrus.c @@ -1140,6 +1140,7 @@ static const char *cs420x_models[CS420X_MODELS] = { static struct snd_pci_quirk cs420x_cfg_tbl[] = { SND_PCI_QUIRK(0x10de, 0x0ac0, "MacBookPro 5,3", CS420X_MBP53), SND_PCI_QUIRK(0x10de, 0xcb79, "MacBookPro 5,5", CS420X_MBP55), + SND_PCI_QUIRK(0x10de, 0xcb89, "MacBookPro 7,1", CS420X_MBP55), SND_PCI_QUIRK(0x8086, 0x7270, "IMac 27 Inch", CS420X_IMAC27), {} /* terminator */ }; -- cgit v1.1 From 6a92934d9e987b6363db3e6a08e17bc0f2078c5d Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Mon, 11 Oct 2010 15:16:20 +0200 Subject: ALSA: hda - Add input volume control for each mic/line-in pin The input pins on cirrus codecs have also input amps. Let's make control elemetns for them. Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_cirrus.c | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) (limited to 'sound') diff --git a/sound/pci/hda/patch_cirrus.c b/sound/pci/hda/patch_cirrus.c index d9a3dbc..460fb2e 100644 --- a/sound/pci/hda/patch_cirrus.c +++ b/sound/pci/hda/patch_cirrus.c @@ -742,6 +742,27 @@ static struct hda_bind_ctls *make_bind_capture(struct hda_codec *codec, return bind; } +/* add a (input-boost) volume control to the given input pin */ +static int add_input_volume_control(struct hda_codec *codec, + struct auto_pin_cfg *cfg, + int item) +{ + hda_nid_t pin = cfg->inputs[item].pin; + u32 caps; + const char *label; + struct snd_kcontrol *kctl; + + if (!(get_wcaps(codec, pin) & AC_WCAP_IN_AMP)) + return 0; + caps = query_amp_caps(codec, pin, HDA_INPUT); + caps = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT; + if (caps <= 1) + return 0; + label = hda_get_autocfg_input_label(codec, cfg, item); + return add_volume(codec, label, 0, + HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_INPUT), 1, &kctl); +} + static int build_input(struct hda_codec *codec) { struct cs_spec *spec = codec->spec; @@ -781,6 +802,12 @@ static int build_input(struct hda_codec *codec) return err; } + for (i = 0; i < spec->num_inputs; i++) { + err = add_input_volume_control(codec, &spec->autocfg, i); + if (err < 0) + return err; + } + return 0; } -- cgit v1.1 From 1422408b34fd27ac7ab4a42e72d4b61553b6f631 Mon Sep 17 00:00:00 2001 From: Kuninori Morimoto Date: Tue, 12 Oct 2010 13:39:25 +0900 Subject: ASoC: ak4642: simultaneous playback/recorde support Signed-off-by: Kuninori Morimoto Acked-by: Liam Girdwood Signed-off-by: Mark Brown --- sound/soc/codecs/ak4642.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'sound') diff --git a/sound/soc/codecs/ak4642.c b/sound/soc/codecs/ak4642.c index a95ff4f..009068f 100644 --- a/sound/soc/codecs/ak4642.c +++ b/sound/soc/codecs/ak4642.c @@ -220,7 +220,7 @@ static int ak4642_dai_startup(struct snd_pcm_substream *substream, ak4642_write(codec, 0x0e, 0x19); ak4642_write(codec, 0x09, 0x91); ak4642_write(codec, 0x0c, 0x91); - ak4642_write(codec, 0x00, 0x64); + snd_soc_update_bits(codec, 0x00, 0x64, 0x64); snd_soc_update_bits(codec, PW_MGMT2, PMHP_MASK, PMHP); snd_soc_update_bits(codec, PW_MGMT2, HPMTN, HPMTN); } else { @@ -242,7 +242,7 @@ static int ak4642_dai_startup(struct snd_pcm_substream *substream, ak4642_write(codec, 0x08, 0xe1); ak4642_write(codec, 0x0b, 0x00); ak4642_write(codec, 0x07, 0x21); - ak4642_write(codec, 0x00, 0x41); + snd_soc_update_bits(codec, 0x00, 0x41, 0x41); ak4642_write(codec, 0x10, 0x01); } @@ -259,12 +259,12 @@ static void ak4642_dai_shutdown(struct snd_pcm_substream *substream, /* stop headphone output */ snd_soc_update_bits(codec, PW_MGMT2, HPMTN, 0); snd_soc_update_bits(codec, PW_MGMT2, PMHP_MASK, 0); - ak4642_write(codec, 0x00, 0x40); + snd_soc_update_bits(codec, 0x00, 0x64, 0x40); ak4642_write(codec, 0x0e, 0x11); ak4642_write(codec, 0x0f, 0x08); } else { /* stop stereo input */ - ak4642_write(codec, 0x00, 0x40); + snd_soc_update_bits(codec, 0x00, 0x41, 0x40); ak4642_write(codec, 0x10, 0x00); ak4642_write(codec, 0x07, 0x01); } -- cgit v1.1 From cca1b2353a364fd51619d0f304dd9681282b864c Mon Sep 17 00:00:00 2001 From: Kuninori Morimoto Date: Tue, 12 Oct 2010 11:39:25 +0900 Subject: ASoC: fsi: Add fsi_get_frame_width function It is not so important for now. But will be used in future. Signed-off-by: Kuninori Morimoto Acked-by: Liam Girdwood Signed-off-by: Mark Brown --- sound/soc/sh/fsi.c | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/soc/sh/fsi.c b/sound/soc/sh/fsi.c index dd99633..aa2cbb1 100644 --- a/sound/soc/sh/fsi.c +++ b/sound/soc/sh/fsi.c @@ -368,6 +368,14 @@ static int fsi_num2len(int num, int width) return num * width; } +static int fsi_get_frame_width(struct fsi_priv *fsi) +{ + struct snd_pcm_substream *substream = fsi->substream; + struct snd_pcm_runtime *runtime = substream->runtime; + + return frames_to_bytes(runtime, 1) / fsi->chan_num; +} + /* * dma function */ @@ -596,7 +604,7 @@ static int fsi_fifo_data_ctrl(struct fsi_priv *fsi, int startup, int is_play) } /* get 1 channel data width */ - ch_width = frames_to_bytes(runtime, 1) / fsi->chan_num; + ch_width = fsi_get_frame_width(fsi); /* get residue data number of alsa */ data_residue_num = fsi_len2num(fsi->buff_len - fsi->buff_offset, -- cgit v1.1 From a68a3b4ed4ecafcf80f4272e8e1f0670b387041e Mon Sep 17 00:00:00 2001 From: Kuninori Morimoto Date: Tue, 12 Oct 2010 11:39:50 +0900 Subject: ASoC: fsi: remove un-necessary variable from fsi_dai_startup Signed-off-by: Kuninori Morimoto Acked-by: Liam Girdwood Signed-off-by: Mark Brown --- sound/soc/sh/fsi.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'sound') diff --git a/sound/soc/sh/fsi.c b/sound/soc/sh/fsi.c index aa2cbb1..d68dcbb 100644 --- a/sound/soc/sh/fsi.c +++ b/sound/soc/sh/fsi.c @@ -730,7 +730,6 @@ static int fsi_dai_startup(struct snd_pcm_substream *substream, u32 data; int is_play = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK); int is_master; - int ret = 0; pm_runtime_get_sync(dai->dev); @@ -809,7 +808,7 @@ static int fsi_dai_startup(struct snd_pcm_substream *substream, /* fifo init */ fsi_fifo_init(fsi, is_play, dai); - return ret; + return 0; } static void fsi_dai_shutdown(struct snd_pcm_substream *substream, -- cgit v1.1 From 75eda968e4db79bda95e9a5f90aead952c273839 Mon Sep 17 00:00:00 2001 From: Kuninori Morimoto Date: Tue, 12 Oct 2010 11:40:14 +0900 Subject: ASoC: fsi: avoid un-necessary status read Signed-off-by: Kuninori Morimoto Acked-by: Liam Girdwood Signed-off-by: Mark Brown --- sound/soc/sh/fsi.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'sound') diff --git a/sound/soc/sh/fsi.c b/sound/soc/sh/fsi.c index d68dcbb..2b3a50d 100644 --- a/sound/soc/sh/fsi.c +++ b/sound/soc/sh/fsi.c @@ -572,7 +572,6 @@ static int fsi_fifo_data_ctrl(struct fsi_priv *fsi, int startup, int is_play) { struct snd_pcm_runtime *runtime; struct snd_pcm_substream *substream = NULL; - u32 status; u32 status_reg = is_play ? DOFF_ST : DIFF_ST; int data_residue_num; int data_num; @@ -662,9 +661,9 @@ static int fsi_fifo_data_ctrl(struct fsi_priv *fsi, int startup, int is_play) fsi->buff_offset += fsi_num2offset(data_num, ch_width); /* check fifo status */ - status = fsi_reg_read(fsi, status_reg); if (!startup) { struct snd_soc_dai *dai = fsi_get_dai(substream); + u32 status = fsi_reg_read(fsi, status_reg); if (status & ERR_OVER) dev_err(dai->dev, "over run\n"); -- cgit v1.1 From cf6edd007b6c371613a2f48e58f3a4238d9775c8 Mon Sep 17 00:00:00 2001 From: Kuninori Morimoto Date: Tue, 12 Oct 2010 11:40:53 +0900 Subject: ASoC: fsi: Add new macro and shift for PortA/B In/Out Some FSI register have similar bit array for PortA/B and In/Out. This patch add new macro and shift for it Signed-off-by: Kuninori Morimoto Acked-by: Liam Girdwood Signed-off-by: Mark Brown --- sound/soc/sh/fsi.c | 45 ++++++++++++++++++++++----------------------- 1 file changed, 22 insertions(+), 23 deletions(-) (limited to 'sound') diff --git a/sound/soc/sh/fsi.c b/sound/soc/sh/fsi.c index 2b3a50d..685bb7c 100644 --- a/sound/soc/sh/fsi.c +++ b/sound/soc/sh/fsi.c @@ -80,11 +80,12 @@ #define B_CLK 0x00000010 #define A_CLK 0x00000001 -/* INT_ST */ -#define INT_B_IN (1 << 12) -#define INT_B_OUT (1 << 8) -#define INT_A_IN (1 << 4) -#define INT_A_OUT (1 << 0) +/* IO SHIFT / MACRO */ +#define BI_SHIFT 12 +#define BO_SHIFT 8 +#define AI_SHIFT 4 +#define AO_SHIFT 0 +#define AB_IO(param, shift) (param << shift) /* SOFT_RST */ #define PBSR (1 << 12) /* Port B Software Reset */ @@ -93,9 +94,7 @@ #define FSISR (1 << 0) /* Software Reset */ /* FIFO_SZ */ -#define OUT_SZ_MASK 0x7 -#define BO_SZ_SHIFT 8 -#define AO_SZ_SHIFT 0 +#define FIFO_SZ_MASK 0x7 #define FSI_RATES SNDRV_PCM_RATE_8000_96000 @@ -310,17 +309,17 @@ static int fsi_is_master_mode(struct fsi_priv *fsi, int is_play) return (mode & flags) != mode; } -static u32 fsi_port_ab_io_bit(struct fsi_priv *fsi, int is_play) +static u32 fsi_get_port_shift(struct fsi_priv *fsi, int is_play) { int is_porta = fsi_is_port_a(fsi); - u32 data; + u32 shift; if (is_porta) - data = is_play ? (1 << 0) : (1 << 4); + shift = is_play ? AO_SHIFT : AI_SHIFT; else - data = is_play ? (1 << 8) : (1 << 12); + shift = is_play ? BO_SHIFT : BI_SHIFT; - return data; + return shift; } static void fsi_stream_push(struct fsi_priv *fsi, @@ -435,7 +434,7 @@ static void fsi_dma_soft_pop32(struct fsi_priv *fsi, int num) static void fsi_irq_enable(struct fsi_priv *fsi, int is_play) { - u32 data = fsi_port_ab_io_bit(fsi, is_play); + u32 data = AB_IO(1, fsi_get_port_shift(fsi, is_play)); struct fsi_master *master = fsi_get_master(fsi); fsi_master_mask_set(master, master->core->imsk, data, data); @@ -444,7 +443,7 @@ static void fsi_irq_enable(struct fsi_priv *fsi, int is_play) static void fsi_irq_disable(struct fsi_priv *fsi, int is_play) { - u32 data = fsi_port_ab_io_bit(fsi, is_play); + u32 data = AB_IO(1, fsi_get_port_shift(fsi, is_play)); struct fsi_master *master = fsi_get_master(fsi); fsi_master_mask_set(master, master->core->imsk, data, 0); @@ -466,8 +465,8 @@ static void fsi_irq_clear_status(struct fsi_priv *fsi) u32 data = 0; struct fsi_master *master = fsi_get_master(fsi); - data |= fsi_port_ab_io_bit(fsi, 0); - data |= fsi_port_ab_io_bit(fsi, 1); + data |= AB_IO(1, fsi_get_port_shift(fsi, 0)); + data |= AB_IO(1, fsi_get_port_shift(fsi, 1)); /* clear interrupt factor */ fsi_master_mask_set(master, master->core->int_st, data, 0); @@ -518,8 +517,8 @@ static void fsi_fifo_init(struct fsi_priv *fsi, /* get on-chip RAM capacity */ shift = fsi_master_read(master, FIFO_SZ); - shift >>= fsi_is_port_a(fsi) ? AO_SZ_SHIFT : BO_SZ_SHIFT; - shift &= OUT_SZ_MASK; + shift >>= fsi_get_port_shift(fsi, is_play); + shift &= FIFO_SZ_MASK; fsi->fifo_max_num = 256 << shift; dev_dbg(dai->dev, "fifo = %d words\n", fsi->fifo_max_num); @@ -700,13 +699,13 @@ static irqreturn_t fsi_interrupt(int irq, void *data) fsi_master_mask_set(master, SOFT_RST, IR, 0); fsi_master_mask_set(master, SOFT_RST, IR, IR); - if (int_st & INT_A_OUT) + if (int_st & AB_IO(1, AO_SHIFT)) fsi_data_push(&master->fsia, 0); - if (int_st & INT_B_OUT) + if (int_st & AB_IO(1, BO_SHIFT)) fsi_data_push(&master->fsib, 0); - if (int_st & INT_A_IN) + if (int_st & AB_IO(1, AI_SHIFT)) fsi_data_pop(&master->fsia, 0); - if (int_st & INT_B_IN) + if (int_st & AB_IO(1, BI_SHIFT)) fsi_data_pop(&master->fsib, 0); fsi_irq_clear_all_status(master); -- cgit v1.1 From 00545785d7e355b0b1b9fb820ec70cb2ae51b409 Mon Sep 17 00:00:00 2001 From: Kuninori Morimoto Date: Tue, 12 Oct 2010 18:30:14 +0900 Subject: ASoC: Add fsi_is_play function Signed-off-by: Kuninori Morimoto Acked-by: Liam Girdwood Signed-off-by: Mark Brown --- sound/soc/sh/fsi.c | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) (limited to 'sound') diff --git a/sound/soc/sh/fsi.c b/sound/soc/sh/fsi.c index 685bb7c..dfc04bc 100644 --- a/sound/soc/sh/fsi.c +++ b/sound/soc/sh/fsi.c @@ -294,6 +294,11 @@ static u32 fsi_get_info_flags(struct fsi_priv *fsi) master->info->portb_flags; } +static inline int fsi_is_play(struct snd_pcm_substream *substream) +{ + return substream->stream == SNDRV_PCM_STREAM_PLAYBACK; +} + static int fsi_is_master_mode(struct fsi_priv *fsi, int is_play) { u32 mode; @@ -726,7 +731,7 @@ static int fsi_dai_startup(struct snd_pcm_substream *substream, u32 fmt; u32 reg; u32 data; - int is_play = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK); + int is_play = fsi_is_play(substream); int is_master; pm_runtime_get_sync(dai->dev); @@ -813,7 +818,7 @@ static void fsi_dai_shutdown(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { struct fsi_priv *fsi = fsi_get_priv(substream); - int is_play = substream->stream == SNDRV_PCM_STREAM_PLAYBACK; + int is_play = fsi_is_play(substream); fsi_irq_disable(fsi, is_play); fsi_clk_ctrl(fsi, 0); @@ -826,7 +831,7 @@ static int fsi_dai_trigger(struct snd_pcm_substream *substream, int cmd, { struct fsi_priv *fsi = fsi_get_priv(substream); struct snd_pcm_runtime *runtime = substream->runtime; - int is_play = substream->stream == SNDRV_PCM_STREAM_PLAYBACK; + int is_play = fsi_is_play(substream); int ret = 0; switch (cmd) { @@ -853,7 +858,7 @@ static int fsi_dai_hw_params(struct snd_pcm_substream *substream, struct fsi_master *master = fsi_get_master(fsi); int (*set_rate)(int is_porta, int rate) = master->info->set_rate; int fsi_ver = master->core->ver; - int is_play = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK); + int is_play = fsi_is_play(substream); int ret; /* if slave mode, set_rate is not needed */ -- cgit v1.1 From bdd9ef24cd343c508ed93f1e08f30d4db595b754 Mon Sep 17 00:00:00 2001 From: David Henningsson Date: Mon, 4 Oct 2010 12:02:14 +0200 Subject: ALSA: HDA: Correctly apply position_fix quirks for ATI and VIA controllers Position_fix quirks for specific machines now override the default position_fix behavior for all HDA controllers. BugLink: http://launchpad.net/bugs/465942 BugLink: http://launchpad.net/bugs/580749 BugLink: http://launchpad.net/bugs/587546 Signed-off-by: David Henningsson Signed-off-by: Takashi Iwai --- sound/pci/hda/hda_intel.c | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c index 38b063e..5cbea85 100644 --- a/sound/pci/hda/hda_intel.c +++ b/sound/pci/hda/hda_intel.c @@ -2315,14 +2315,6 @@ static int __devinit check_position_fix(struct azx *chip, int fix) return fix; } - /* Check VIA/ATI HD Audio Controller exist */ - switch (chip->driver_type) { - case AZX_DRIVER_VIA: - case AZX_DRIVER_ATI: - /* Use link position directly, avoid any transfer problem. */ - return POS_FIX_VIACOMBO; - } - q = snd_pci_quirk_lookup(chip->pci, position_fix_list); if (q) { printk(KERN_INFO @@ -2331,6 +2323,15 @@ static int __devinit check_position_fix(struct azx *chip, int fix) q->value, q->subvendor, q->subdevice); return q->value; } + + /* Check VIA/ATI HD Audio Controller exist */ + switch (chip->driver_type) { + case AZX_DRIVER_VIA: + case AZX_DRIVER_ATI: + /* Use link position directly, avoid any transfer problem. */ + return POS_FIX_VIACOMBO; + } + return POS_FIX_AUTO; } -- cgit v1.1 From 4de43a6b4cf002e343cf39fa27a3f46c5dc19411 Mon Sep 17 00:00:00 2001 From: Anand Gadiyar Date: Tue, 12 Oct 2010 13:27:58 +0000 Subject: ASoC: OMAP4: MCPDM: Remove unnecessary include of plat/control.h Commit 346a5c890 (OMAP: control: move plat-omap/control.h to mach-omap2/control.h) in the linux-omap tree removed plat/control.h and most of its callers. This one slipped through - breaking the build as below when CONFIG_SND_OMAP_SOC_MCPDM is defined. Fix this. CC sound/soc/omap/omap-mcpdm.o sound/soc/omap/omap-mcpdm.c:35: fatal error: plat/control.h: No such file or directory compilation terminated. make[3]: *** [sound/soc/omap/omap-mcpdm.o] Error 1 make[2]: *** [sound/soc/omap] Error 2 make[1]: *** [sound/soc] Error 2 make: *** [sound] Error 2 Signed-off-by: Anand Gadiyar Cc: Misael Lopez Cruz Cc: Liam Girdwood Cc: Mark Brown Cc: Paul Walmsley Acked-by: Mark Brown Acked-by: Jarkko Nikula Acked-by: Paul Walmsley Signed-off-by: Tony Lindgren --- sound/soc/omap/omap-mcpdm.c | 1 - 1 file changed, 1 deletion(-) (limited to 'sound') diff --git a/sound/soc/omap/omap-mcpdm.c b/sound/soc/omap/omap-mcpdm.c index b7f4f7e..b1be6f3 100644 --- a/sound/soc/omap/omap-mcpdm.c +++ b/sound/soc/omap/omap-mcpdm.c @@ -32,7 +32,6 @@ #include #include -#include #include #include #include "mcpdm.h" -- cgit v1.1 From 7750752a22cbf7760f0073d218c737f5a03bff4a Mon Sep 17 00:00:00 2001 From: Mika Westerberg Date: Wed, 13 Oct 2010 11:30:31 +0300 Subject: ASoC: ac97: don't call snd_soc_new_ac97_codec at probe It is not needed since snd_ac97_mixer() will create a new ac97 object for us. Removing the call also fixes a memory leak since codec->ac97 is set to NULL at the beginning of snd_ac97_mixer(). Signed-off-by: Mika Westerberg Acked-by: Liam Girdwood Signed-off-by: Mark Brown --- sound/soc/codecs/ac97.c | 6 ------ 1 file changed, 6 deletions(-) (limited to 'sound') diff --git a/sound/soc/codecs/ac97.c b/sound/soc/codecs/ac97.c index 2c824a5..f5139ae 100644 --- a/sound/soc/codecs/ac97.c +++ b/sound/soc/codecs/ac97.c @@ -79,12 +79,6 @@ static int ac97_soc_probe(struct snd_soc_codec *codec) struct snd_ac97_template ac97_template; int ret; - ret = snd_soc_new_ac97_codec(codec, &soc_ac97_ops, 0); - if (ret < 0) { - printk(KERN_ERR "ASoC: failed to init generic ac97 glue\n"); - return ret; - } - /* add codec as bus device for standard ac97 */ ret = snd_ac97_bus(codec->card->snd_card, 0, &soc_ac97_ops, NULL, &ac97_bus); if (ret < 0) -- cgit v1.1 From 0562f7882d968463119bb63d47ef4bdaba7d6631 Mon Sep 17 00:00:00 2001 From: Mika Westerberg Date: Wed, 13 Oct 2010 11:30:32 +0300 Subject: ASoC: don't register AC97 devices twice With generic AC97 ASoC glue driver (codec/ac97.c), we get following warning when the device is registered (slightly stripped the backtrace): kobject (c5a863e8): tried to init an initialized object, something is seriously wrong. [] (unwind_backtrace+0x0/0xec) [] (kobject_init+0x38/0x70) [] (device_initialize+0x20/0x70) [] (device_register+0xc/0x18) [] (snd_soc_instantiate_cards+0x924/0xacc [snd_soc_core]) [] (snd_soc_register_platform+0x16c/0x198 [snd_soc_core]) [] (platform_drv_probe+0x18/0x1c) [] (driver_probe_device+0xb0/0x16c) [] (__driver_attach+0x5c/0x7c) [] (bus_for_each_dev+0x48/0x78) [] (bus_add_driver+0x98/0x214) [] (driver_register+0xa4/0x130) [] (do_one_initcall+0xd0/0x1a4) [] (sys_init_module+0x12b0/0x1454) This happens because the generic AC97 glue driver creates its codec->ac97 via calling snd_ac97_mixer(). snd_ac97_mixer() provides own version of snd_device.register which handles the device registration when snd_card_register() is called. To avoid registering the AC97 device twice, we add a new flag to the snd_soc_codec: ac97_created which tells whether the AC97 device was created by SoC subsystem. Signed-off-by: Mika Westerberg Acked-by: Liam Girdwood Signed-off-by: Mark Brown --- sound/soc/soc-core.c | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) (limited to 'sound') diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c index 8751efd..7d22b5d 100644 --- a/sound/soc/soc-core.c +++ b/sound/soc/soc-core.c @@ -1497,6 +1497,16 @@ static int soc_register_ac97_dai_link(struct snd_soc_pcm_runtime *rtd) * for the generic AC97 subsystem. */ if (rtd->codec_dai->driver->ac97_control && !rtd->codec->ac97_registered) { + /* + * It is possible that the AC97 device is already registered to + * the device subsystem. This happens when the device is created + * via snd_ac97_mixer(). Currently only SoC codec that does so + * is the generic AC97 glue but others migh emerge. + * + * In those cases we don't try to register the device again. + */ + if (!rtd->codec->ac97_created) + return 0; ret = soc_ac97_dev_register(rtd->codec); if (ret < 0) { @@ -1812,6 +1822,13 @@ int snd_soc_new_ac97_codec(struct snd_soc_codec *codec, codec->ac97->bus->ops = ops; codec->ac97->num = num; + + /* + * Mark the AC97 device to be created by us. This way we ensure that the + * device will be registered with the device subsystem later on. + */ + codec->ac97_created = 1; + mutex_unlock(&codec->mutex); return 0; } @@ -1832,6 +1849,7 @@ void snd_soc_free_ac97_codec(struct snd_soc_codec *codec) kfree(codec->ac97->bus); kfree(codec->ac97); codec->ac97 = NULL; + codec->ac97_created = 0; mutex_unlock(&codec->mutex); } EXPORT_SYMBOL_GPL(snd_soc_free_ac97_codec); -- cgit v1.1 From 0afe6b901e432bfd93eca9aefdd2ec537b27d1d3 Mon Sep 17 00:00:00 2001 From: Mika Westerberg Date: Wed, 13 Oct 2010 11:30:33 +0300 Subject: ASoC: ac97: add MODULE_ALIAS for the platform driver So that modprobe can load the driver automatically when the platform device appears. Signed-off-by: Mika Westerberg Acked-by: Liam Girdwood Signed-off-by: Mark Brown --- sound/soc/codecs/ac97.c | 1 + 1 file changed, 1 insertion(+) (limited to 'sound') diff --git a/sound/soc/codecs/ac97.c b/sound/soc/codecs/ac97.c index f5139ae..3c08793 100644 --- a/sound/soc/codecs/ac97.c +++ b/sound/soc/codecs/ac97.c @@ -162,3 +162,4 @@ module_exit(ac97_exit); MODULE_DESCRIPTION("Soc Generic AC97 driver"); MODULE_AUTHOR("Liam Girdwood"); MODULE_LICENSE("GPL"); +MODULE_ALIAS("platform:ac97-codec"); -- cgit v1.1 From 821f4206c4f568bf43e30f1ae5619868fa76413a Mon Sep 17 00:00:00 2001 From: Mark Brown Date: Tue, 21 Sep 2010 17:53:38 +0100 Subject: ASoC: Add WM8962 microphone bias control We unconditionally require SYSCLK since while only microphone detection specifically requires SYSCLK any actual use case would enable it via some other means but microphone detection may have nothing active other than the bias itself. Signed-off-by: Mark Brown Acked-by: Liam Girdwood --- sound/soc/codecs/wm8962.c | 2 ++ 1 file changed, 2 insertions(+) (limited to 'sound') diff --git a/sound/soc/codecs/wm8962.c b/sound/soc/codecs/wm8962.c index e5009d0..894d0cd 100644 --- a/sound/soc/codecs/wm8962.c +++ b/sound/soc/codecs/wm8962.c @@ -2566,6 +2566,8 @@ static const struct snd_soc_dapm_route wm8962_intercon[] = { { "MIXINR", "IN3R Switch", "IN3R" }, { "MIXINR", "PGA Switch", "INPGAR" }, + { "MICBIAS", NULL, "SYSCLK" }, + { "ADCL", NULL, "SYSCLK" }, { "ADCL", NULL, "TOCLK" }, { "ADCL", NULL, "MIXINL" }, -- cgit v1.1 From 8c7f78b3c3f3132a36b4747b2e1283a7ca015edb Mon Sep 17 00:00:00 2001 From: Mark Brown Date: Tue, 12 Oct 2010 15:56:09 +0100 Subject: ASoC: Restore DAI ID specification for WM8994 WM8994 relies on the DAIs having IDs that match the AIF numbers. Signed-off-by: Mark Brown Acked-by: Liam Girdwood --- sound/soc/codecs/wm8994.c | 3 +++ 1 file changed, 3 insertions(+) (limited to 'sound') diff --git a/sound/soc/codecs/wm8994.c b/sound/soc/codecs/wm8994.c index 218bcd2..749d70f 100644 --- a/sound/soc/codecs/wm8994.c +++ b/sound/soc/codecs/wm8994.c @@ -3546,6 +3546,7 @@ static struct snd_soc_dai_ops wm8994_aif3_dai_ops = { static struct snd_soc_dai_driver wm8994_dai[] = { { .name = "wm8994-aif1", + .id = 1, .playback = { .stream_name = "AIF1 Playback", .channels_min = 2, @@ -3564,6 +3565,7 @@ static struct snd_soc_dai_driver wm8994_dai[] = { }, { .name = "wm8994-aif2", + .id = 2, .playback = { .stream_name = "AIF2 Playback", .channels_min = 2, @@ -3582,6 +3584,7 @@ static struct snd_soc_dai_driver wm8994_dai[] = { }, { .name = "wm8994-aif3", + .id = 3, .playback = { .stream_name = "AIF3 Playback", .channels_min = 2, -- cgit v1.1 From 4abe8e16a8ad879027de3a0a088f281577ad24a9 Mon Sep 17 00:00:00 2001 From: Mark Brown Date: Tue, 12 Oct 2010 17:41:03 +0100 Subject: ASoC: Move soc-core module init next to functon definition Signed-off-by: Mark Brown Acked-by: Liam Girdwood --- sound/soc/soc-core.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'sound') diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c index 7d22b5d..225b5bd 100644 --- a/sound/soc/soc-core.c +++ b/sound/soc/soc-core.c @@ -3306,6 +3306,7 @@ static int __init snd_soc_init(void) return platform_driver_register(&soc_driver); } +module_init(snd_soc_init); static void __exit snd_soc_exit(void) { @@ -3314,8 +3315,6 @@ static void __exit snd_soc_exit(void) #endif platform_driver_unregister(&soc_driver); } - -module_init(snd_soc_init); module_exit(snd_soc_exit); /* Module information */ -- cgit v1.1 From 2b194f9db444875b4509e6dc92c949c57437c826 Mon Sep 17 00:00:00 2001 From: Mark Brown Date: Wed, 13 Oct 2010 10:52:16 +0100 Subject: ASoC: Check list debugfs files for PAGE_SIZE overflow Signed-off-by: Mark Brown Acked-by: Liam Girdwood --- sound/soc/soc-core.c | 49 ++++++++++++++++++++++++++++++++++--------------- 1 file changed, 34 insertions(+), 15 deletions(-) (limited to 'sound') diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c index 225b5bd..6cee97e 100644 --- a/sound/soc/soc-core.c +++ b/sound/soc/soc-core.c @@ -274,15 +274,22 @@ static ssize_t codec_list_read_file(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) { char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL); - ssize_t ret = 0; + ssize_t len, ret = 0; struct snd_soc_codec *codec; if (!buf) return -ENOMEM; - list_for_each_entry(codec, &codec_list, list) - ret += snprintf(buf + ret, PAGE_SIZE - ret, "%s\n", - codec->name); + list_for_each_entry(codec, &codec_list, list) { + len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n", + codec->name); + if (len >= 0) + ret += len; + if (ret > PAGE_SIZE) { + ret = PAGE_SIZE; + break; + } + } if (ret >= 0) ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret); @@ -301,17 +308,23 @@ static ssize_t dai_list_read_file(struct file *file, char __user *user_buf, size_t count, loff_t *ppos) { char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL); - ssize_t ret = 0; + ssize_t len, ret = 0; struct snd_soc_dai *dai; if (!buf) return -ENOMEM; - list_for_each_entry(dai, &dai_list, list) - ret += snprintf(buf + ret, PAGE_SIZE - ret, "%s\n", dai->name); + list_for_each_entry(dai, &dai_list, list) { + len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n", dai->name); + if (len >= 0) + ret += len; + if (ret > PAGE_SIZE) { + ret = PAGE_SIZE; + break; + } + } - if (ret >= 0) - ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret); + ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret); kfree(buf); @@ -328,18 +341,24 @@ static ssize_t platform_list_read_file(struct file *file, size_t count, loff_t *ppos) { char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL); - ssize_t ret = 0; + ssize_t len, ret = 0; struct snd_soc_platform *platform; if (!buf) return -ENOMEM; - list_for_each_entry(platform, &platform_list, list) - ret += snprintf(buf + ret, PAGE_SIZE - ret, "%s\n", - platform->name); + list_for_each_entry(platform, &platform_list, list) { + len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n", + platform->name); + if (len >= 0) + ret += len; + if (ret > PAGE_SIZE) { + ret = PAGE_SIZE; + break; + } + } - if (ret >= 0) - ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret); + ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret); kfree(buf); -- cgit v1.1 From 0f9141c974b2dc29b7d1cf245bbf4685350521be Mon Sep 17 00:00:00 2001 From: Mark Brown Date: Tue, 12 Oct 2010 15:43:21 +0100 Subject: ASoC: Pay attention to driver supplied DAI IDs The driver can specify a DAI ID number so use that. Signed-off-by: Mark Brown Acked-by: Liam Girdwood --- sound/soc/soc-core.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c index 6cee97e..63c80e6 100644 --- a/sound/soc/soc-core.c +++ b/sound/soc/soc-core.c @@ -3051,8 +3051,11 @@ int snd_soc_register_dais(struct device *dev, } dai->dev = dev; - dai->id = i; dai->driver = &dai_drv[i]; + if (dai->driver->id) + dai->id = dai->driver->id; + else + dai->id = i; if (!dai->driver->ops) dai->driver->ops = &null_dai_ops; -- cgit v1.1 From 2df03514de41f3bbb5623f2e7f2bf594e49cb2ec Mon Sep 17 00:00:00 2001 From: Daniel T Chen Date: Sun, 10 Oct 2010 22:39:28 -0400 Subject: ALSA: hda: Add speaker pin to automute Acer Aspire 8943G BugLink: https://bugs.launchpad.net/bugs/656625 Add clause for handling Acer Aspire 8943G's subwoofer as additional speaker pin for automuting. Reported-by: RussianNeuroMancer Cc: stable@kernel.org Signed-off-by: Daniel T Chen Signed-off-by: David Henningsson Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 8 ++++++++ 1 file changed, 8 insertions(+) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index b4e0959..c41ac30 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -19233,10 +19233,17 @@ static void alc662_auto_init(struct hda_codec *codec) } enum { + ALC662_FIXUP_ASPIRE, ALC662_FIXUP_IDEAPAD, }; static const struct alc_fixup alc662_fixups[] = { + [ALC662_FIXUP_ASPIRE] = { + .pins = (const struct alc_pincfg[]) { + { 0x15, 0x99130112 }, /* subwoofer */ + { } + } + }, [ALC662_FIXUP_IDEAPAD] = { .pins = (const struct alc_pincfg[]) { { 0x17, 0x99130112 }, /* subwoofer */ @@ -19246,6 +19253,7 @@ static const struct alc_fixup alc662_fixups[] = { }; static struct snd_pci_quirk alc662_fixup_tbl[] = { + SND_PCI_QUIRK(0x1025, 0x038b, "Acer Aspire 8943G", ALC662_FIXUP_ASPIRE), SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD), SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD), {} -- cgit v1.1 From 0db710230589b5571c23f59250eabc9504b17c98 Mon Sep 17 00:00:00 2001 From: Jaroslav Kysela Date: Thu, 14 Oct 2010 21:46:12 +0200 Subject: ALSA: snd-aloop - fix issue in the timer start function In some circumstances (the rate shift value was changed), the irq_pos value may be higher than the fraction value in the timer start function. Check for it. Also, to avoid value overflow, decrease maximum period size. Signed-off-by: Jaroslav Kysela --- sound/drivers/aloop.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/drivers/aloop.c b/sound/drivers/aloop.c index 3c00882..838ad863 100644 --- a/sound/drivers/aloop.c +++ b/sound/drivers/aloop.c @@ -171,6 +171,10 @@ static void loopback_timer_start(struct loopback_pcm *dpcm) dpcm->pcm_rate_shift = rate_shift; dpcm->period_size_frac = frac_pos(dpcm, dpcm->pcm_period_size); } + if (dpcm->period_size_frac <= dpcm->irq_pos) { + dpcm->irq_pos %= dpcm->period_size_frac; + dpcm->period_update_pending = 1; + } tick = dpcm->period_size_frac - dpcm->irq_pos; tick = (tick + dpcm->pcm_bps - 1) / dpcm->pcm_bps; dpcm->timer.expires = jiffies + tick; @@ -531,7 +535,9 @@ static struct snd_pcm_hardware loopback_pcm_hardware = .channels_max = 32, .buffer_bytes_max = 2 * 1024 * 1024, .period_bytes_min = 64, - .period_bytes_max = 2 * 1024 * 1024, + /* note check overflow in frac_pos() using pcm_rate_shift before + changing period_bytes_max value */ + .period_bytes_max = 1024 * 1024, .periods_min = 1, .periods_max = 1024, .fifo_size = 0, -- cgit v1.1 From fc127ccccc5de164d490e8a55a1c2c126293e96f Mon Sep 17 00:00:00 2001 From: Seungwhan Youn Date: Tue, 12 Oct 2010 20:51:23 +0900 Subject: ASoC: SAMSUNG: Add S/PDIF CPU driver This patch adds S/PDIF CPU driver for various Samsung SoCs. Signed-off-by: Seungwhan Youn Acked-by: Liam Girdwood Signed-off-by: Mark Brown --- sound/soc/s3c24xx/Kconfig | 4 + sound/soc/s3c24xx/Makefile | 2 + sound/soc/s3c24xx/spdif.c | 501 +++++++++++++++++++++++++++++++++++++++++++++ sound/soc/s3c24xx/spdif.h | 19 ++ 4 files changed, 526 insertions(+) create mode 100644 sound/soc/s3c24xx/spdif.c create mode 100644 sound/soc/s3c24xx/spdif.h (limited to 'sound') diff --git a/sound/soc/s3c24xx/Kconfig b/sound/soc/s3c24xx/Kconfig index 7d8235d..e2cba93 100644 --- a/sound/soc/s3c24xx/Kconfig +++ b/sound/soc/s3c24xx/Kconfig @@ -36,6 +36,10 @@ config SND_S3C_SOC_AC97 tristate select SND_SOC_AC97_BUS +config SND_S5P_SOC_SPDIF + tristate + select SND_SOC_SPDIF + config SND_S3C24XX_SOC_NEO1973_WM8753 tristate "SoC I2S Audio support for NEO1973 - WM8753" depends on SND_S3C24XX_SOC && MACH_NEO1973_GTA01 diff --git a/sound/soc/s3c24xx/Makefile b/sound/soc/s3c24xx/Makefile index dd412a9..0a02735 100644 --- a/sound/soc/s3c24xx/Makefile +++ b/sound/soc/s3c24xx/Makefile @@ -7,6 +7,7 @@ snd-soc-s3c-ac97-objs := s3c-ac97.o snd-soc-s3c64xx-i2s-v4-objs := s3c64xx-i2s-v4.o snd-soc-s3c-i2s-v2-objs := s3c-i2s-v2.o snd-soc-s3c-pcm-objs := s3c-pcm.o +snd-soc-samsung-spdif-objs := spdif.o obj-$(CONFIG_SND_S3C24XX_SOC) += snd-soc-s3c24xx.o obj-$(CONFIG_SND_S3C24XX_SOC_I2S) += snd-soc-s3c24xx-i2s.o @@ -16,6 +17,7 @@ obj-$(CONFIG_SND_S3C64XX_SOC_I2S) += snd-soc-s3c64xx-i2s.o obj-$(CONFIG_SND_S3C64XX_SOC_I2S_V4) += snd-soc-s3c64xx-i2s-v4.o obj-$(CONFIG_SND_S3C_I2SV2_SOC) += snd-soc-s3c-i2s-v2.o obj-$(CONFIG_SND_S3C_SOC_PCM) += snd-soc-s3c-pcm.o +obj-$(CONFIG_SND_S5P_SOC_SPDIF) += snd-soc-samsung-spdif.o # S3C24XX Machine Support snd-soc-jive-wm8750-objs := jive_wm8750.o diff --git a/sound/soc/s3c24xx/spdif.c b/sound/soc/s3c24xx/spdif.c new file mode 100644 index 0000000..ce554e9 --- /dev/null +++ b/sound/soc/s3c24xx/spdif.c @@ -0,0 +1,501 @@ +/* sound/soc/s3c24xx/spdif.c + * + * ALSA SoC Audio Layer - Samsung S/PDIF Controller driver + * + * Copyright (c) 2010 Samsung Electronics Co. Ltd + * http://www.samsung.com/ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#include +#include + +#include +#include +#include + +#include +#include + +#include "s3c-dma.h" +#include "spdif.h" + +/* Registers */ +#define CLKCON 0x00 +#define CON 0x04 +#define BSTAS 0x08 +#define CSTAS 0x0C +#define DATA_OUTBUF 0x10 +#define DCNT 0x14 +#define BSTAS_S 0x18 +#define DCNT_S 0x1C + +#define CLKCTL_MASK 0x7 +#define CLKCTL_MCLK_EXT (0x1 << 2) +#define CLKCTL_PWR_ON (0x1 << 0) + +#define CON_MASK 0x3ffffff +#define CON_FIFO_TH_SHIFT 19 +#define CON_FIFO_TH_MASK (0x7 << 19) +#define CON_USERDATA_23RDBIT (0x1 << 12) + +#define CON_SW_RESET (0x1 << 5) + +#define CON_MCLKDIV_MASK (0x3 << 3) +#define CON_MCLKDIV_256FS (0x0 << 3) +#define CON_MCLKDIV_384FS (0x1 << 3) +#define CON_MCLKDIV_512FS (0x2 << 3) + +#define CON_PCM_MASK (0x3 << 1) +#define CON_PCM_16BIT (0x0 << 1) +#define CON_PCM_20BIT (0x1 << 1) +#define CON_PCM_24BIT (0x2 << 1) + +#define CON_PCM_DATA (0x1 << 0) + +#define CSTAS_MASK 0x3fffffff +#define CSTAS_SAMP_FREQ_MASK (0xF << 24) +#define CSTAS_SAMP_FREQ_44 (0x0 << 24) +#define CSTAS_SAMP_FREQ_48 (0x2 << 24) +#define CSTAS_SAMP_FREQ_32 (0x3 << 24) +#define CSTAS_SAMP_FREQ_96 (0xA << 24) + +#define CSTAS_CATEGORY_MASK (0xFF << 8) +#define CSTAS_CATEGORY_CODE_CDP (0x01 << 8) + +#define CSTAS_NO_COPYRIGHT (0x1 << 2) + +/** + * struct samsung_spdif_info - Samsung S/PDIF Controller information + * @lock: Spin lock for S/PDIF. + * @dev: The parent device passed to use from the probe. + * @regs: The pointer to the device register block. + * @clk_rate: Current clock rate for calcurate ratio. + * @pclk: The peri-clock pointer for spdif master operation. + * @sclk: The source clock pointer for making sync signals. + * @save_clkcon: Backup clkcon reg. in suspend. + * @save_con: Backup con reg. in suspend. + * @save_cstas: Backup cstas reg. in suspend. + * @dma_playback: DMA information for playback channel. + */ +struct samsung_spdif_info { + spinlock_t lock; + struct device *dev; + void __iomem *regs; + unsigned long clk_rate; + struct clk *pclk; + struct clk *sclk; + u32 saved_clkcon; + u32 saved_con; + u32 saved_cstas; + struct s3c_dma_params *dma_playback; +}; + +static struct s3c2410_dma_client spdif_dma_client_out = { + .name = "S/PDIF Stereo out", +}; + +static struct s3c_dma_params spdif_stereo_out; +static struct samsung_spdif_info spdif_info; + +static inline struct samsung_spdif_info *to_info(struct snd_soc_dai *cpu_dai) +{ + return snd_soc_dai_get_drvdata(cpu_dai); +} + +static void spdif_snd_txctrl(struct samsung_spdif_info *spdif, int on) +{ + void __iomem *regs = spdif->regs; + u32 clkcon; + + dev_dbg(spdif->dev, "Entered %s\n", __func__); + + clkcon = readl(regs + CLKCON) & CLKCTL_MASK; + if (on) + writel(clkcon | CLKCTL_PWR_ON, regs + CLKCON); + else + writel(clkcon & ~CLKCTL_PWR_ON, regs + CLKCON); +} + +static int spdif_set_sysclk(struct snd_soc_dai *cpu_dai, + int clk_id, unsigned int freq, int dir) +{ + struct samsung_spdif_info *spdif = to_info(cpu_dai); + u32 clkcon; + + dev_dbg(spdif->dev, "Entered %s\n", __func__); + + clkcon = readl(spdif->regs + CLKCON); + + if (clk_id == SND_SOC_SPDIF_INT_MCLK) + clkcon &= ~CLKCTL_MCLK_EXT; + else + clkcon |= CLKCTL_MCLK_EXT; + + writel(clkcon, spdif->regs + CLKCON); + + spdif->clk_rate = freq; + + return 0; +} + +static int spdif_trigger(struct snd_pcm_substream *substream, int cmd, + struct snd_soc_dai *dai) +{ + struct snd_soc_pcm_runtime *rtd = substream->private_data; + struct samsung_spdif_info *spdif = to_info(rtd->cpu_dai); + unsigned long flags; + + dev_dbg(spdif->dev, "Entered %s\n", __func__); + + switch (cmd) { + case SNDRV_PCM_TRIGGER_START: + case SNDRV_PCM_TRIGGER_RESUME: + case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: + spin_lock_irqsave(&spdif->lock, flags); + spdif_snd_txctrl(spdif, 1); + spin_unlock_irqrestore(&spdif->lock, flags); + break; + case SNDRV_PCM_TRIGGER_STOP: + case SNDRV_PCM_TRIGGER_SUSPEND: + case SNDRV_PCM_TRIGGER_PAUSE_PUSH: + spin_lock_irqsave(&spdif->lock, flags); + spdif_snd_txctrl(spdif, 0); + spin_unlock_irqrestore(&spdif->lock, flags); + break; + default: + return -EINVAL; + } + + return 0; +} + +static int spdif_sysclk_ratios[] = { + 512, 384, 256, +}; + +static int spdif_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params, + struct snd_soc_dai *socdai) +{ + struct snd_soc_pcm_runtime *rtd = substream->private_data; + struct samsung_spdif_info *spdif = to_info(rtd->cpu_dai); + void __iomem *regs = spdif->regs; + struct s3c_dma_params *dma_data; + u32 con, clkcon, cstas; + unsigned long flags; + int i, ratio; + + dev_dbg(spdif->dev, "Entered %s\n", __func__); + + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) + dma_data = spdif->dma_playback; + else { + dev_err(spdif->dev, "Capture is not supported\n"); + return -EINVAL; + } + + snd_soc_dai_set_dma_data(rtd->cpu_dai, substream, dma_data); + + spin_lock_irqsave(&spdif->lock, flags); + + con = readl(regs + CON) & CON_MASK; + cstas = readl(regs + CSTAS) & CSTAS_MASK; + clkcon = readl(regs + CLKCON) & CLKCTL_MASK; + + con &= ~CON_FIFO_TH_MASK; + con |= (0x7 << CON_FIFO_TH_SHIFT); + con |= CON_USERDATA_23RDBIT; + con |= CON_PCM_DATA; + + con &= ~CON_PCM_MASK; + switch (params_format(params)) { + case SNDRV_PCM_FORMAT_S16_LE: + con |= CON_PCM_16BIT; + break; + default: + dev_err(spdif->dev, "Unsupported data size.\n"); + goto err; + } + + ratio = spdif->clk_rate / params_rate(params); + for (i = 0; i < ARRAY_SIZE(spdif_sysclk_ratios); i++) + if (ratio == spdif_sysclk_ratios[i]) + break; + if (i == ARRAY_SIZE(spdif_sysclk_ratios)) { + dev_err(spdif->dev, "Invalid clock ratio %ld/%d\n", + spdif->clk_rate, params_rate(params)); + goto err; + } + + con &= ~CON_MCLKDIV_MASK; + switch (ratio) { + case 256: + con |= CON_MCLKDIV_256FS; + break; + case 384: + con |= CON_MCLKDIV_384FS; + break; + case 512: + con |= CON_MCLKDIV_512FS; + break; + } + + cstas &= ~CSTAS_SAMP_FREQ_MASK; + switch (params_rate(params)) { + case 44100: + cstas |= CSTAS_SAMP_FREQ_44; + break; + case 48000: + cstas |= CSTAS_SAMP_FREQ_48; + break; + case 32000: + cstas |= CSTAS_SAMP_FREQ_32; + break; + case 96000: + cstas |= CSTAS_SAMP_FREQ_96; + break; + default: + dev_err(spdif->dev, "Invalid sampling rate %d\n", + params_rate(params)); + goto err; + } + + cstas &= ~CSTAS_CATEGORY_MASK; + cstas |= CSTAS_CATEGORY_CODE_CDP; + cstas |= CSTAS_NO_COPYRIGHT; + + writel(con, regs + CON); + writel(cstas, regs + CSTAS); + writel(clkcon, regs + CLKCON); + + spin_unlock_irqrestore(&spdif->lock, flags); + + return 0; +err: + spin_unlock_irqrestore(&spdif->lock, flags); + return -EINVAL; +} + +static void spdif_shutdown(struct snd_pcm_substream *substream, + struct snd_soc_dai *dai) +{ + struct snd_soc_pcm_runtime *rtd = substream->private_data; + struct samsung_spdif_info *spdif = to_info(rtd->cpu_dai); + void __iomem *regs = spdif->regs; + u32 con, clkcon; + + dev_dbg(spdif->dev, "Entered %s\n", __func__); + + con = readl(regs + CON) & CON_MASK; + clkcon = readl(regs + CLKCON) & CLKCTL_MASK; + + writel(con | CON_SW_RESET, regs + CON); + cpu_relax(); + + writel(clkcon & ~CLKCTL_PWR_ON, regs + CLKCON); +} + +#ifdef CONFIG_PM +static int spdif_suspend(struct snd_soc_dai *cpu_dai) +{ + struct samsung_spdif_info *spdif = to_info(cpu_dai); + u32 con = spdif->saved_con; + + dev_dbg(spdif->dev, "Entered %s\n", __func__); + + spdif->saved_clkcon = readl(spdif->regs + CLKCON) & CLKCTL_MASK; + spdif->saved_con = readl(spdif->regs + CON) & CON_MASK; + spdif->saved_cstas = readl(spdif->regs + CSTAS) & CSTAS_MASK; + + writel(con | CON_SW_RESET, spdif->regs + CON); + cpu_relax(); + + return 0; +} + +static int spdif_resume(struct snd_soc_dai *cpu_dai) +{ + struct samsung_spdif_info *spdif = to_info(cpu_dai); + + dev_dbg(spdif->dev, "Entered %s\n", __func__); + + writel(spdif->saved_clkcon, spdif->regs + CLKCON); + writel(spdif->saved_con, spdif->regs + CON); + writel(spdif->saved_cstas, spdif->regs + CSTAS); + + return 0; +} +#else +#define spdif_suspend NULL +#define spdif_resume NULL +#endif + +static struct snd_soc_dai_ops spdif_dai_ops = { + .set_sysclk = spdif_set_sysclk, + .trigger = spdif_trigger, + .hw_params = spdif_hw_params, + .shutdown = spdif_shutdown, +}; + +struct snd_soc_dai_driver samsung_spdif_dai = { + .name = "samsung-spdif", + .playback = { + .stream_name = "S/PDIF Playback", + .channels_min = 2, + .channels_max = 2, + .rates = (SNDRV_PCM_RATE_32000 | + SNDRV_PCM_RATE_44100 | + SNDRV_PCM_RATE_48000 | + SNDRV_PCM_RATE_96000), + .formats = SNDRV_PCM_FMTBIT_S16_LE, }, + .ops = &spdif_dai_ops, + .suspend = spdif_suspend, + .resume = spdif_resume, +}; + +static __devinit int spdif_probe(struct platform_device *pdev) +{ + struct s3c_audio_pdata *spdif_pdata; + struct resource *mem_res, *dma_res; + struct samsung_spdif_info *spdif; + int ret; + + spdif_pdata = pdev->dev.platform_data; + + dev_dbg(&pdev->dev, "Entered %s\n", __func__); + + dma_res = platform_get_resource(pdev, IORESOURCE_DMA, 0); + if (!dma_res) { + dev_err(&pdev->dev, "Unable to get dma resource.\n"); + return -ENXIO; + } + + mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + if (!mem_res) { + dev_err(&pdev->dev, "Unable to get register resource.\n"); + return -ENXIO; + } + + if (spdif_pdata && spdif_pdata->cfg_gpio + && spdif_pdata->cfg_gpio(pdev)) { + dev_err(&pdev->dev, "Unable to configure GPIO pins\n"); + return -EINVAL; + } + + spdif = &spdif_info; + spdif->dev = &pdev->dev; + + spin_lock_init(&spdif->lock); + + spdif->pclk = clk_get(&pdev->dev, "spdif"); + if (IS_ERR(spdif->pclk)) { + dev_err(&pdev->dev, "failed to get peri-clock\n"); + ret = -ENOENT; + goto err0; + } + clk_enable(spdif->pclk); + + spdif->sclk = clk_get(&pdev->dev, "sclk_spdif"); + if (IS_ERR(spdif->sclk)) { + dev_err(&pdev->dev, "failed to get internal source clock\n"); + ret = -ENOENT; + goto err1; + } + clk_enable(spdif->sclk); + + /* Request S/PDIF Register's memory region */ + if (!request_mem_region(mem_res->start, + resource_size(mem_res), "samsung-spdif")) { + dev_err(&pdev->dev, "Unable to request register region\n"); + ret = -EBUSY; + goto err2; + } + + spdif->regs = ioremap(mem_res->start, 0x100); + if (spdif->regs == NULL) { + dev_err(&pdev->dev, "Cannot ioremap registers\n"); + ret = -ENXIO; + goto err3; + } + + dev_set_drvdata(&pdev->dev, spdif); + + ret = snd_soc_register_dai(&pdev->dev, &samsung_spdif_dai); + if (ret != 0) { + dev_err(&pdev->dev, "fail to register dai\n"); + goto err4; + } + + spdif_stereo_out.dma_size = 2; + spdif_stereo_out.client = &spdif_dma_client_out; + spdif_stereo_out.dma_addr = mem_res->start + DATA_OUTBUF; + spdif_stereo_out.channel = dma_res->start; + + spdif->dma_playback = &spdif_stereo_out; + + return 0; + +err4: + iounmap(spdif->regs); +err3: + release_mem_region(mem_res->start, resource_size(mem_res)); +err2: + clk_disable(spdif->sclk); + clk_put(spdif->sclk); +err1: + clk_disable(spdif->pclk); + clk_put(spdif->pclk); +err0: + return ret; +} + +static __devexit int spdif_remove(struct platform_device *pdev) +{ + struct samsung_spdif_info *spdif = &spdif_info; + struct resource *mem_res; + + snd_soc_unregister_dai(&pdev->dev); + + iounmap(spdif->regs); + + mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0); + if (mem_res) + release_mem_region(mem_res->start, resource_size(mem_res)); + + clk_disable(spdif->sclk); + clk_put(spdif->sclk); + clk_disable(spdif->pclk); + clk_put(spdif->pclk); + + return 0; +} + +static struct platform_driver samsung_spdif_driver = { + .probe = spdif_probe, + .remove = spdif_remove, + .driver = { + .name = "samsung-spdif", + .owner = THIS_MODULE, + }, +}; + +static int __init spdif_init(void) +{ + return platform_driver_register(&samsung_spdif_driver); +} +module_init(spdif_init); + +static void __exit spdif_exit(void) +{ + platform_driver_unregister(&samsung_spdif_driver); +} +module_exit(spdif_exit); + +MODULE_AUTHOR("Seungwhan Youn, "); +MODULE_DESCRIPTION("Samsung S/PDIF Controller Driver"); +MODULE_LICENSE("GPL"); +MODULE_ALIAS("platform:samsung-spdif"); diff --git a/sound/soc/s3c24xx/spdif.h b/sound/soc/s3c24xx/spdif.h new file mode 100644 index 0000000..3ed5559 --- /dev/null +++ b/sound/soc/s3c24xx/spdif.h @@ -0,0 +1,19 @@ +/* sound/soc/s3c24xx/spdif.h + * + * ALSA SoC Audio Layer - Samsung S/PDIF Controller driver + * + * Copyright (c) 2010 Samsung Electronics Co. Ltd + * http://www.samsung.com/ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#ifndef __SND_SOC_SAMSUNG_SPDIF_H +#define __SND_SOC_SAMSUNG_SPDIF_H __FILE__ + +#define SND_SOC_SPDIF_INT_MCLK 0 +#define SND_SOC_SPDIF_EXT_MCLK 1 + +#endif /* __SND_SOC_SAMSUNG_SPDIF_H */ -- cgit v1.1 From b67089e4c258a3a4ea8e23ceea4a5b7f8c3099d7 Mon Sep 17 00:00:00 2001 From: Seungwhan Youn Date: Tue, 12 Oct 2010 20:58:52 +0900 Subject: ASoC: SAMSUNG: Add Machine driver for S/PDIF PCM audio This patch add S/PDIF machine driver to support S/PDIF PCM audio on SMDKC100, SMDKC110 and SMDKV210 boards. Signed-off-by: Seungwhan Youn Acked-by: Liam Girdwood Signed-off-by: Mark Brown --- sound/soc/s3c24xx/Kconfig | 7 ++ sound/soc/s3c24xx/Makefile | 2 + sound/soc/s3c24xx/smdk_spdif.c | 223 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 232 insertions(+) create mode 100644 sound/soc/s3c24xx/smdk_spdif.c (limited to 'sound') diff --git a/sound/soc/s3c24xx/Kconfig b/sound/soc/s3c24xx/Kconfig index e2cba93..8a6b53c 100644 --- a/sound/soc/s3c24xx/Kconfig +++ b/sound/soc/s3c24xx/Kconfig @@ -161,3 +161,10 @@ config SND_S5PV210_SOC_GONI_WM8994 help Say Y if you want to add support for SoC audio on goni with the WM8994. + +config SND_SOC_SMDK_SPDIF + tristate "SoC S/PDIF Audio support for SMDK" + depends on SND_S3C24XX_SOC && (MACH_SMDKC100 || MACH_SMDKC110 || MACH_SMDKV210) + select SND_S5P_SOC_SPDIF + help + Say Y if you want to add support for SoC S/PDIF audio on the SMDK. diff --git a/sound/soc/s3c24xx/Makefile b/sound/soc/s3c24xx/Makefile index 0a02735..ee8f41d 100644 --- a/sound/soc/s3c24xx/Makefile +++ b/sound/soc/s3c24xx/Makefile @@ -35,6 +35,7 @@ snd-soc-smdk-wm9713-objs := smdk_wm9713.o snd-soc-s3c64xx-smartq-wm8987-objs := smartq_wm8987.o snd-soc-aquila-wm8994-objs := aquila_wm8994.o snd-soc-goni-wm8994-objs := goni_wm8994.o +snd-soc-smdk-spdif-objs := smdk_spdif.o obj-$(CONFIG_SND_S3C24XX_SOC_JIVE_WM8750) += snd-soc-jive-wm8750.o obj-$(CONFIG_SND_S3C24XX_SOC_NEO1973_WM8753) += snd-soc-neo1973-wm8753.o @@ -51,3 +52,4 @@ obj-$(CONFIG_SND_SOC_SMDK_WM9713) += snd-soc-smdk-wm9713.o obj-$(CONFIG_SND_S3C64XX_SOC_SMARTQ) += snd-soc-s3c64xx-smartq-wm8987.o obj-$(CONFIG_SND_S5PC110_SOC_AQUILA_WM8994) += snd-soc-aquila-wm8994.o obj-$(CONFIG_SND_S5PV210_SOC_GONI_WM8994) += snd-soc-goni-wm8994.o +obj-$(CONFIG_SND_SOC_SMDK_SPDIF) += snd-soc-smdk-spdif.o diff --git a/sound/soc/s3c24xx/smdk_spdif.c b/sound/soc/s3c24xx/smdk_spdif.c new file mode 100644 index 0000000..f31d22a --- /dev/null +++ b/sound/soc/s3c24xx/smdk_spdif.c @@ -0,0 +1,223 @@ +/* + * smdk_spdif.c -- S/PDIF audio for SMDK + * + * Copyright 2010 Samsung Electronics Co. Ltd. + * + * 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. + * + */ + +#include +#include +#include + +#include + +#include + +#include "s3c-dma.h" +#include "spdif.h" + +/* Audio clock settings are belonged to board specific part. Every + * board can set audio source clock setting which is matched with H/W + * like this function-'set_audio_clock_heirachy'. + */ +static int set_audio_clock_heirachy(struct platform_device *pdev) +{ + struct clk *fout_epll, *mout_epll, *sclk_audio0, *sclk_spdif; + int ret; + + fout_epll = clk_get(NULL, "fout_epll"); + if (IS_ERR(fout_epll)) { + printk(KERN_WARNING "%s: Cannot find fout_epll.\n", + __func__); + return -EINVAL; + } + + mout_epll = clk_get(NULL, "mout_epll"); + if (IS_ERR(fout_epll)) { + printk(KERN_WARNING "%s: Cannot find mout_epll.\n", + __func__); + ret = -EINVAL; + goto out1; + } + + sclk_audio0 = clk_get(&pdev->dev, "sclk_audio"); + if (IS_ERR(sclk_audio0)) { + printk(KERN_WARNING "%s: Cannot find sclk_audio.\n", + __func__); + ret = -EINVAL; + goto out2; + } + + sclk_spdif = clk_get(NULL, "sclk_spdif"); + if (IS_ERR(fout_epll)) { + printk(KERN_WARNING "%s: Cannot find sclk_spdif.\n", + __func__); + ret = -EINVAL; + goto out3; + } + + /* Set audio clock heirachy for S/PDIF */ + clk_set_parent(mout_epll, fout_epll); + clk_set_parent(sclk_audio0, mout_epll); + clk_set_parent(sclk_spdif, sclk_audio0); + + clk_put(sclk_spdif); +out3: + clk_put(sclk_audio0); +out2: + clk_put(mout_epll); +out1: + clk_put(fout_epll); + + return ret; +} + +/* We should haved to set clock directly on this part because of clock + * scheme of Samsudng SoCs did not support to set rates from abstrct + * clock of it's heirachy. + */ +static int set_audio_clock_rate(unsigned long epll_rate, + unsigned long audio_rate) +{ + struct clk *fout_epll, *sclk_spdif; + + fout_epll = clk_get(NULL, "fout_epll"); + if (IS_ERR(fout_epll)) { + printk(KERN_ERR "%s: failed to get fout_epll\n", __func__); + return -ENOENT; + } + + clk_set_rate(fout_epll, epll_rate); + clk_put(fout_epll); + + sclk_spdif = clk_get(NULL, "sclk_spdif"); + if (IS_ERR(sclk_spdif)) { + printk(KERN_ERR "%s: failed to get sclk_spdif\n", __func__); + return -ENOENT; + } + + clk_set_rate(sclk_spdif, audio_rate); + clk_put(sclk_spdif); + + return 0; +} + +static int smdk_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params) +{ + struct snd_soc_pcm_runtime *rtd = substream->private_data; + struct snd_soc_dai *cpu_dai = rtd->cpu_dai; + unsigned long pll_out, rclk_rate; + int ret, ratio; + + switch (params_rate(params)) { + case 44100: + pll_out = 45158400; + break; + case 32000: + case 48000: + case 96000: + pll_out = 49152000; + break; + default: + return -EINVAL; + } + + /* Setting ratio to 512fs helps to use S/PDIF with HDMI without + * modify S/PDIF ASoC machine driver. + */ + ratio = 512; + rclk_rate = params_rate(params) * ratio; + + /* Set audio source clock rates */ + ret = set_audio_clock_rate(pll_out, rclk_rate); + if (ret < 0) + return ret; + + /* Set S/PDIF uses internal source clock */ + ret = snd_soc_dai_set_sysclk(cpu_dai, SND_SOC_SPDIF_INT_MCLK, + rclk_rate, SND_SOC_CLOCK_IN); + if (ret < 0) + return ret; + + return ret; +} + +static struct snd_soc_ops smdk_spdif_ops = { + .hw_params = smdk_hw_params, +}; + +static struct snd_soc_card smdk; + +static struct snd_soc_dai_link smdk_dai = { + .name = "S/PDIF", + .stream_name = "S/PDIF PCM Playback", + .platform_name = "s3c24xx-pcm-audio", + .cpu_dai_name = "samsung-spdif", + .codec_dai_name = "dit-hifi", + .codec_name = "spdif-dit", + .ops = &smdk_spdif_ops, +}; + +static struct snd_soc_card smdk = { + .name = "SMDK-S/PDIF", + .dai_link = &smdk_dai, + .num_links = 1, +}; + +static struct platform_device *smdk_snd_spdif_dit_device; +static struct platform_device *smdk_snd_spdif_device; + +static int __init smdk_init(void) +{ + int ret; + + smdk_snd_spdif_dit_device = platform_device_alloc("spdif-dit", -1); + if (!smdk_snd_spdif_dit_device) + return -ENOMEM; + + ret = platform_device_add(smdk_snd_spdif_dit_device); + if (ret) + goto err2; + + smdk_snd_spdif_device = platform_device_alloc("soc-audio", -1); + if (!smdk_snd_spdif_device) { + ret = -ENOMEM; + goto err2; + } + + platform_set_drvdata(smdk_snd_spdif_device, &smdk); + + ret = platform_device_add(smdk_snd_spdif_device); + if (ret) + goto err1; + + /* Set audio clock heirachy manually */ + ret = set_audio_clock_heirachy(smdk_snd_spdif_device); + if (ret) + goto err1; + + return 0; +err1: + platform_device_put(smdk_snd_spdif_device); +err2: + platform_device_put(smdk_snd_spdif_dit_device); + return ret; +} + +static void __exit smdk_exit(void) +{ + platform_device_unregister(smdk_snd_spdif_device); +} + +module_init(smdk_init); +module_exit(smdk_exit); + +MODULE_AUTHOR("Seungwhan Youn, "); +MODULE_DESCRIPTION("ALSA SoC SMDK+S/PDIF"); +MODULE_LICENSE("GPL"); -- cgit v1.1 From 93193c2bbcd83bf8bf43433cfb1868d4ca0ac351 Mon Sep 17 00:00:00 2001 From: Kuninori Morimoto Date: Tue, 12 Oct 2010 19:19:28 +0900 Subject: ASoC: fsi: simultaneous playback/recorde support Current FSI driver had not cared about simultaneous playback/capture on same port. This patch add new fsi_stream struct to care it, Signed-off-by: Kuninori Morimoto Acked-by: Liam Girdwood Signed-off-by: Mark Brown --- sound/soc/sh/fsi.c | 152 +++++++++++++++++++++++++++++++++-------------------- 1 file changed, 94 insertions(+), 58 deletions(-) (limited to 'sound') diff --git a/sound/soc/sh/fsi.c b/sound/soc/sh/fsi.c index dfc04bc..507e709 100644 --- a/sound/soc/sh/fsi.c +++ b/sound/soc/sh/fsi.c @@ -113,10 +113,8 @@ * struct */ -struct fsi_priv { - void __iomem *base; +struct fsi_stream { struct snd_pcm_substream *substream; - struct fsi_master *master; int fifo_max_num; int chan_num; @@ -125,6 +123,14 @@ struct fsi_priv { int buff_len; int period_len; int period_num; +}; + +struct fsi_priv { + void __iomem *base; + struct fsi_master *master; + + struct fsi_stream playback; + struct fsi_stream capture; u32 mst_ctrl; }; @@ -294,9 +300,20 @@ static u32 fsi_get_info_flags(struct fsi_priv *fsi) master->info->portb_flags; } +static inline int fsi_stream_is_play(int stream) +{ + return stream == SNDRV_PCM_STREAM_PLAYBACK; +} + static inline int fsi_is_play(struct snd_pcm_substream *substream) { - return substream->stream == SNDRV_PCM_STREAM_PLAYBACK; + return fsi_stream_is_play(substream->stream); +} + +static inline struct fsi_stream *fsi_get_stream(struct fsi_priv *fsi, + int is_play) +{ + return is_play ? &fsi->playback : &fsi->capture; } static int fsi_is_master_mode(struct fsi_priv *fsi, int is_play) @@ -328,35 +345,41 @@ static u32 fsi_get_port_shift(struct fsi_priv *fsi, int is_play) } static void fsi_stream_push(struct fsi_priv *fsi, + int is_play, struct snd_pcm_substream *substream, u32 buffer_len, u32 period_len) { - fsi->substream = substream; - fsi->buff_len = buffer_len; - fsi->buff_offset = 0; - fsi->period_len = period_len; - fsi->period_num = 0; + struct fsi_stream *io = fsi_get_stream(fsi, is_play); + + io->substream = substream; + io->buff_len = buffer_len; + io->buff_offset = 0; + io->period_len = period_len; + io->period_num = 0; } -static void fsi_stream_pop(struct fsi_priv *fsi) +static void fsi_stream_pop(struct fsi_priv *fsi, int is_play) { - fsi->substream = NULL; - fsi->buff_len = 0; - fsi->buff_offset = 0; - fsi->period_len = 0; - fsi->period_num = 0; + struct fsi_stream *io = fsi_get_stream(fsi, is_play); + + io->substream = NULL; + io->buff_len = 0; + io->buff_offset = 0; + io->period_len = 0; + io->period_num = 0; } static int fsi_get_fifo_data_num(struct fsi_priv *fsi, int is_play) { u32 status; u32 reg = is_play ? DOFF_ST : DIFF_ST; + struct fsi_stream *io = fsi_get_stream(fsi, is_play); int data_num; status = fsi_reg_read(fsi, reg); data_num = 0x1ff & (status >> 8); - data_num *= fsi->chan_num; + data_num *= io->chan_num; return data_num; } @@ -372,21 +395,25 @@ static int fsi_num2len(int num, int width) return num * width; } -static int fsi_get_frame_width(struct fsi_priv *fsi) +static int fsi_get_frame_width(struct fsi_priv *fsi, int is_play) { - struct snd_pcm_substream *substream = fsi->substream; + struct fsi_stream *io = fsi_get_stream(fsi, is_play); + struct snd_pcm_substream *substream = io->substream; struct snd_pcm_runtime *runtime = substream->runtime; - return frames_to_bytes(runtime, 1) / fsi->chan_num; + return frames_to_bytes(runtime, 1) / io->chan_num; } /* * dma function */ -static u8 *fsi_dma_get_area(struct fsi_priv *fsi) +static u8 *fsi_dma_get_area(struct fsi_priv *fsi, int stream) { - return fsi->substream->runtime->dma_area + fsi->buff_offset; + int is_play = fsi_stream_is_play(stream); + struct fsi_stream *io = fsi_get_stream(fsi, is_play); + + return io->substream->runtime->dma_area + io->buff_offset; } static void fsi_dma_soft_push16(struct fsi_priv *fsi, int num) @@ -394,7 +421,7 @@ static void fsi_dma_soft_push16(struct fsi_priv *fsi, int num) u16 *start; int i; - start = (u16 *)fsi_dma_get_area(fsi); + start = (u16 *)fsi_dma_get_area(fsi, SNDRV_PCM_STREAM_PLAYBACK); for (i = 0; i < num; i++) fsi_reg_write(fsi, DODT, ((u32)*(start + i) << 8)); @@ -405,7 +432,8 @@ static void fsi_dma_soft_pop16(struct fsi_priv *fsi, int num) u16 *start; int i; - start = (u16 *)fsi_dma_get_area(fsi); + start = (u16 *)fsi_dma_get_area(fsi, SNDRV_PCM_STREAM_CAPTURE); + for (i = 0; i < num; i++) *(start + i) = (u16)(fsi_reg_read(fsi, DIDT) >> 8); @@ -416,7 +444,8 @@ static void fsi_dma_soft_push32(struct fsi_priv *fsi, int num) u32 *start; int i; - start = (u32 *)fsi_dma_get_area(fsi); + start = (u32 *)fsi_dma_get_area(fsi, SNDRV_PCM_STREAM_PLAYBACK); + for (i = 0; i < num; i++) fsi_reg_write(fsi, DODT, *(start + i)); @@ -427,7 +456,7 @@ static void fsi_dma_soft_pop32(struct fsi_priv *fsi, int num) u32 *start; int i; - start = (u32 *)fsi_dma_get_area(fsi); + start = (u32 *)fsi_dma_get_area(fsi, SNDRV_PCM_STREAM_CAPTURE); for (i = 0; i < num; i++) *(start + i) = fsi_reg_read(fsi, DIDT); @@ -518,14 +547,15 @@ static void fsi_fifo_init(struct fsi_priv *fsi, struct snd_soc_dai *dai) { struct fsi_master *master = fsi_get_master(fsi); + struct fsi_stream *io = fsi_get_stream(fsi, is_play); u32 ctrl, shift, i; /* get on-chip RAM capacity */ shift = fsi_master_read(master, FIFO_SZ); shift >>= fsi_get_port_shift(fsi, is_play); shift &= FIFO_SZ_MASK; - fsi->fifo_max_num = 256 << shift; - dev_dbg(dai->dev, "fifo = %d words\n", fsi->fifo_max_num); + io->fifo_max_num = 256 << shift; + dev_dbg(dai->dev, "fifo = %d words\n", io->fifo_max_num); /* * The maximum number of sample data varies depending @@ -546,10 +576,10 @@ static void fsi_fifo_init(struct fsi_priv *fsi, * 7 channels: 32 ( 32 x 7 = 224) * 8 channels: 32 ( 32 x 8 = 256) */ - for (i = 1; i < fsi->chan_num; i <<= 1) - fsi->fifo_max_num >>= 1; + for (i = 1; i < io->chan_num; i <<= 1) + io->fifo_max_num >>= 1; dev_dbg(dai->dev, "%d channel %d store\n", - fsi->chan_num, fsi->fifo_max_num); + io->chan_num, io->fifo_max_num); ctrl = is_play ? DOFF_CTL : DIFF_CTL; @@ -572,10 +602,12 @@ static void fsi_soft_all_reset(struct fsi_master *master) mdelay(10); } -static int fsi_fifo_data_ctrl(struct fsi_priv *fsi, int startup, int is_play) +static int fsi_fifo_data_ctrl(struct fsi_priv *fsi, int startup, int stream) { struct snd_pcm_runtime *runtime; struct snd_pcm_substream *substream = NULL; + int is_play = fsi_stream_is_play(stream); + struct fsi_stream *io = fsi_get_stream(fsi, is_play); u32 status_reg = is_play ? DOFF_ST : DIFF_ST; int data_residue_num; int data_num; @@ -585,32 +617,32 @@ static int fsi_fifo_data_ctrl(struct fsi_priv *fsi, int startup, int is_play) void (*fn)(struct fsi_priv *fsi, int size); if (!fsi || - !fsi->substream || - !fsi->substream->runtime) + !io->substream || + !io->substream->runtime) return -EINVAL; over_period = 0; - substream = fsi->substream; + substream = io->substream; runtime = substream->runtime; /* FSI FIFO has limit. * So, this driver can not send periods data at a time */ - if (fsi->buff_offset >= - fsi_num2offset(fsi->period_num + 1, fsi->period_len)) { + if (io->buff_offset >= + fsi_num2offset(io->period_num + 1, io->period_len)) { over_period = 1; - fsi->period_num = (fsi->period_num + 1) % runtime->periods; + io->period_num = (io->period_num + 1) % runtime->periods; - if (0 == fsi->period_num) - fsi->buff_offset = 0; + if (0 == io->period_num) + io->buff_offset = 0; } /* get 1 channel data width */ - ch_width = fsi_get_frame_width(fsi); + ch_width = fsi_get_frame_width(fsi, is_play); /* get residue data number of alsa */ - data_residue_num = fsi_len2num(fsi->buff_len - fsi->buff_offset, + data_residue_num = fsi_len2num(io->buff_len - io->buff_offset, ch_width); if (is_play) { @@ -620,7 +652,7 @@ static int fsi_fifo_data_ctrl(struct fsi_priv *fsi, int startup, int is_play) * data_num_max : number of FSI fifo free space * data_num : number of ALSA residue data */ - data_num_max = fsi->fifo_max_num * fsi->chan_num; + data_num_max = io->fifo_max_num * io->chan_num; data_num_max -= fsi_get_fifo_data_num(fsi, is_play); data_num = data_residue_num; @@ -662,7 +694,7 @@ static int fsi_fifo_data_ctrl(struct fsi_priv *fsi, int startup, int is_play) fn(fsi, data_num); /* update buff_offset */ - fsi->buff_offset += fsi_num2offset(data_num, ch_width); + io->buff_offset += fsi_num2offset(data_num, ch_width); /* check fifo status */ if (!startup) { @@ -687,12 +719,12 @@ static int fsi_fifo_data_ctrl(struct fsi_priv *fsi, int startup, int is_play) static int fsi_data_pop(struct fsi_priv *fsi, int startup) { - return fsi_fifo_data_ctrl(fsi, startup, 0); + return fsi_fifo_data_ctrl(fsi, startup, SNDRV_PCM_STREAM_CAPTURE); } static int fsi_data_push(struct fsi_priv *fsi, int startup) { - return fsi_fifo_data_ctrl(fsi, startup, 1); + return fsi_fifo_data_ctrl(fsi, startup, SNDRV_PCM_STREAM_PLAYBACK); } static irqreturn_t fsi_interrupt(int irq, void *data) @@ -726,14 +758,17 @@ static int fsi_dai_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { struct fsi_priv *fsi = fsi_get_priv(substream); - u32 flags = fsi_get_info_flags(fsi); struct fsi_master *master = fsi_get_master(fsi); + struct fsi_stream *io; + u32 flags = fsi_get_info_flags(fsi); u32 fmt; u32 reg; u32 data; int is_play = fsi_is_play(substream); int is_master; + io = fsi_get_stream(fsi, is_play); + pm_runtime_get_sync(dai->dev); /* CKG1 */ @@ -764,29 +799,29 @@ static int fsi_dai_startup(struct snd_pcm_substream *substream, switch (fmt) { case SH_FSI_FMT_MONO: data = CR_MONO; - fsi->chan_num = 1; + io->chan_num = 1; break; case SH_FSI_FMT_MONO_DELAY: data = CR_MONO_D; - fsi->chan_num = 1; + io->chan_num = 1; break; case SH_FSI_FMT_PCM: data = CR_PCM; - fsi->chan_num = 2; + io->chan_num = 2; break; case SH_FSI_FMT_I2S: data = CR_I2S; - fsi->chan_num = 2; + io->chan_num = 2; break; case SH_FSI_FMT_TDM: - fsi->chan_num = is_play ? + io->chan_num = is_play ? SH_FSI_GET_CH_O(flags) : SH_FSI_GET_CH_I(flags); - data = CR_TDM | (fsi->chan_num - 1); + data = CR_TDM | (io->chan_num - 1); break; case SH_FSI_FMT_TDM_DELAY: - fsi->chan_num = is_play ? + io->chan_num = is_play ? SH_FSI_GET_CH_O(flags) : SH_FSI_GET_CH_I(flags); - data = CR_TDM_D | (fsi->chan_num - 1); + data = CR_TDM_D | (io->chan_num - 1); break; case SH_FSI_FMT_SPDIF: if (master->core->ver < 2) { @@ -794,7 +829,7 @@ static int fsi_dai_startup(struct snd_pcm_substream *substream, return -EINVAL; } data = CR_SPDIF; - fsi->chan_num = 2; + io->chan_num = 2; fsi_spdif_clk_ctrl(fsi, 1); fsi_reg_mask_set(fsi, OUT_SEL, 0x0010, 0x0010); break; @@ -836,14 +871,14 @@ static int fsi_dai_trigger(struct snd_pcm_substream *substream, int cmd, switch (cmd) { case SNDRV_PCM_TRIGGER_START: - fsi_stream_push(fsi, substream, + fsi_stream_push(fsi, is_play, substream, frames_to_bytes(runtime, runtime->buffer_size), frames_to_bytes(runtime, runtime->period_size)); ret = is_play ? fsi_data_push(fsi, 1) : fsi_data_pop(fsi, 1); break; case SNDRV_PCM_TRIGGER_STOP: fsi_irq_disable(fsi, is_play); - fsi_stream_pop(fsi); + fsi_stream_pop(fsi, is_play); break; } @@ -991,9 +1026,10 @@ static snd_pcm_uframes_t fsi_pointer(struct snd_pcm_substream *substream) { struct snd_pcm_runtime *runtime = substream->runtime; struct fsi_priv *fsi = fsi_get_priv(substream); + struct fsi_stream *io = fsi_get_stream(fsi, fsi_is_play(substream)); long location; - location = (fsi->buff_offset - 1); + location = (io->buff_offset - 1); if (location < 0) location = 0; -- cgit v1.1 From c14c05c19f2a2ab87b8ebabd245f53945a97695b Mon Sep 17 00:00:00 2001 From: Joe Perches Date: Wed, 13 Oct 2010 08:19:51 -0700 Subject: ASoC: Remove unused vol field from WM8994 access mask table Remove unused vol from struct access_mask Reduces object size ~3kb. $ size sound/soc/codecs/wm8994.o* text data bss dec hex filename 40727 4384 4480 49591 c1b7 sound/soc/codecs/wm8994.o.new 43879 4384 4480 52743 ce07 sound/soc/codecs/wm8994.o.old Signed-off-by: Joe Perches Acked-by: Liam Girdwood Signed-off-by: Mark Brown --- sound/soc/codecs/wm8994.c | 3147 ++++++++++++++++++++++----------------------- 1 file changed, 1573 insertions(+), 1574 deletions(-) (limited to 'sound') diff --git a/sound/soc/codecs/wm8994.c b/sound/soc/codecs/wm8994.c index 749d70f..0db59c3 100644 --- a/sound/soc/codecs/wm8994.c +++ b/sound/soc/codecs/wm8994.c @@ -98,1581 +98,1580 @@ struct wm8994_priv { struct wm8994_pdata *pdata; }; -static struct { - unsigned short readable; /* Mask of readable bits */ - unsigned short writable; /* Mask of writable bits */ - unsigned short vol; /* Mask of volatile bits */ +static const struct { + unsigned short readable; /* Mask of readable bits */ + unsigned short writable; /* Mask of writable bits */ } access_masks[] = { - { 0xFFFF, 0xFFFF, 0x0000 }, /* R0 - Software Reset */ - { 0x3B37, 0x3B37, 0x0000 }, /* R1 - Power Management (1) */ - { 0x6BF0, 0x6BF0, 0x0000 }, /* R2 - Power Management (2) */ - { 0x3FF0, 0x3FF0, 0x0000 }, /* R3 - Power Management (3) */ - { 0x3F3F, 0x3F3F, 0x0000 }, /* R4 - Power Management (4) */ - { 0x3F0F, 0x3F0F, 0x0000 }, /* R5 - Power Management (5) */ - { 0x003F, 0x003F, 0x0000 }, /* R6 - Power Management (6) */ - { 0x0000, 0x0000, 0x0000 }, /* R7 */ - { 0x0000, 0x0000, 0x0000 }, /* R8 */ - { 0x0000, 0x0000, 0x0000 }, /* R9 */ - { 0x0000, 0x0000, 0x0000 }, /* R10 */ - { 0x0000, 0x0000, 0x0000 }, /* R11 */ - { 0x0000, 0x0000, 0x0000 }, /* R12 */ - { 0x0000, 0x0000, 0x0000 }, /* R13 */ - { 0x0000, 0x0000, 0x0000 }, /* R14 */ - { 0x0000, 0x0000, 0x0000 }, /* R15 */ - { 0x0000, 0x0000, 0x0000 }, /* R16 */ - { 0x0000, 0x0000, 0x0000 }, /* R17 */ - { 0x0000, 0x0000, 0x0000 }, /* R18 */ - { 0x0000, 0x0000, 0x0000 }, /* R19 */ - { 0x0000, 0x0000, 0x0000 }, /* R20 */ - { 0x01C0, 0x01C0, 0x0000 }, /* R21 - Input Mixer (1) */ - { 0x0000, 0x0000, 0x0000 }, /* R22 */ - { 0x0000, 0x0000, 0x0000 }, /* R23 */ - { 0x00DF, 0x01DF, 0x0000 }, /* R24 - Left Line Input 1&2 Volume */ - { 0x00DF, 0x01DF, 0x0000 }, /* R25 - Left Line Input 3&4 Volume */ - { 0x00DF, 0x01DF, 0x0000 }, /* R26 - Right Line Input 1&2 Volume */ - { 0x00DF, 0x01DF, 0x0000 }, /* R27 - Right Line Input 3&4 Volume */ - { 0x00FF, 0x01FF, 0x0000 }, /* R28 - Left Output Volume */ - { 0x00FF, 0x01FF, 0x0000 }, /* R29 - Right Output Volume */ - { 0x0077, 0x0077, 0x0000 }, /* R30 - Line Outputs Volume */ - { 0x0030, 0x0030, 0x0000 }, /* R31 - HPOUT2 Volume */ - { 0x00FF, 0x01FF, 0x0000 }, /* R32 - Left OPGA Volume */ - { 0x00FF, 0x01FF, 0x0000 }, /* R33 - Right OPGA Volume */ - { 0x007F, 0x007F, 0x0000 }, /* R34 - SPKMIXL Attenuation */ - { 0x017F, 0x017F, 0x0000 }, /* R35 - SPKMIXR Attenuation */ - { 0x003F, 0x003F, 0x0000 }, /* R36 - SPKOUT Mixers */ - { 0x003F, 0x003F, 0x0000 }, /* R37 - ClassD */ - { 0x00FF, 0x01FF, 0x0000 }, /* R38 - Speaker Volume Left */ - { 0x00FF, 0x01FF, 0x0000 }, /* R39 - Speaker Volume Right */ - { 0x00FF, 0x00FF, 0x0000 }, /* R40 - Input Mixer (2) */ - { 0x01B7, 0x01B7, 0x0000 }, /* R41 - Input Mixer (3) */ - { 0x01B7, 0x01B7, 0x0000 }, /* R42 - Input Mixer (4) */ - { 0x01C7, 0x01C7, 0x0000 }, /* R43 - Input Mixer (5) */ - { 0x01C7, 0x01C7, 0x0000 }, /* R44 - Input Mixer (6) */ - { 0x01FF, 0x01FF, 0x0000 }, /* R45 - Output Mixer (1) */ - { 0x01FF, 0x01FF, 0x0000 }, /* R46 - Output Mixer (2) */ - { 0x0FFF, 0x0FFF, 0x0000 }, /* R47 - Output Mixer (3) */ - { 0x0FFF, 0x0FFF, 0x0000 }, /* R48 - Output Mixer (4) */ - { 0x0FFF, 0x0FFF, 0x0000 }, /* R49 - Output Mixer (5) */ - { 0x0FFF, 0x0FFF, 0x0000 }, /* R50 - Output Mixer (6) */ - { 0x0038, 0x0038, 0x0000 }, /* R51 - HPOUT2 Mixer */ - { 0x0077, 0x0077, 0x0000 }, /* R52 - Line Mixer (1) */ - { 0x0077, 0x0077, 0x0000 }, /* R53 - Line Mixer (2) */ - { 0x03FF, 0x03FF, 0x0000 }, /* R54 - Speaker Mixer */ - { 0x00C1, 0x00C1, 0x0000 }, /* R55 - Additional Control */ - { 0x00F0, 0x00F0, 0x0000 }, /* R56 - AntiPOP (1) */ - { 0x01EF, 0x01EF, 0x0000 }, /* R57 - AntiPOP (2) */ - { 0x00FF, 0x00FF, 0x0000 }, /* R58 - MICBIAS */ - { 0x000F, 0x000F, 0x0000 }, /* R59 - LDO 1 */ - { 0x0007, 0x0007, 0x0000 }, /* R60 - LDO 2 */ - { 0x0000, 0x0000, 0x0000 }, /* R61 */ - { 0x0000, 0x0000, 0x0000 }, /* R62 */ - { 0x0000, 0x0000, 0x0000 }, /* R63 */ - { 0x0000, 0x0000, 0x0000 }, /* R64 */ - { 0x0000, 0x0000, 0x0000 }, /* R65 */ - { 0x0000, 0x0000, 0x0000 }, /* R66 */ - { 0x0000, 0x0000, 0x0000 }, /* R67 */ - { 0x0000, 0x0000, 0x0000 }, /* R68 */ - { 0x0000, 0x0000, 0x0000 }, /* R69 */ - { 0x0000, 0x0000, 0x0000 }, /* R70 */ - { 0x0000, 0x0000, 0x0000 }, /* R71 */ - { 0x0000, 0x0000, 0x0000 }, /* R72 */ - { 0x0000, 0x0000, 0x0000 }, /* R73 */ - { 0x0000, 0x0000, 0x0000 }, /* R74 */ - { 0x0000, 0x0000, 0x0000 }, /* R75 */ - { 0x8000, 0x8000, 0x0000 }, /* R76 - Charge Pump (1) */ - { 0x0000, 0x0000, 0x0000 }, /* R77 */ - { 0x0000, 0x0000, 0x0000 }, /* R78 */ - { 0x0000, 0x0000, 0x0000 }, /* R79 */ - { 0x0000, 0x0000, 0x0000 }, /* R80 */ - { 0x0301, 0x0301, 0x0000 }, /* R81 - Class W (1) */ - { 0x0000, 0x0000, 0x0000 }, /* R82 */ - { 0x0000, 0x0000, 0x0000 }, /* R83 */ - { 0x333F, 0x333F, 0x0000 }, /* R84 - DC Servo (1) */ - { 0x0FEF, 0x0FEF, 0x0000 }, /* R85 - DC Servo (2) */ - { 0x0000, 0x0000, 0x0000 }, /* R86 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R87 - DC Servo (4) */ - { 0x0333, 0x0000, 0x0000 }, /* R88 - DC Servo Readback */ - { 0x0000, 0x0000, 0x0000 }, /* R89 */ - { 0x0000, 0x0000, 0x0000 }, /* R90 */ - { 0x0000, 0x0000, 0x0000 }, /* R91 */ - { 0x0000, 0x0000, 0x0000 }, /* R92 */ - { 0x0000, 0x0000, 0x0000 }, /* R93 */ - { 0x0000, 0x0000, 0x0000 }, /* R94 */ - { 0x0000, 0x0000, 0x0000 }, /* R95 */ - { 0x00EE, 0x00EE, 0x0000 }, /* R96 - Analogue HP (1) */ - { 0x0000, 0x0000, 0x0000 }, /* R97 */ - { 0x0000, 0x0000, 0x0000 }, /* R98 */ - { 0x0000, 0x0000, 0x0000 }, /* R99 */ - { 0x0000, 0x0000, 0x0000 }, /* R100 */ - { 0x0000, 0x0000, 0x0000 }, /* R101 */ - { 0x0000, 0x0000, 0x0000 }, /* R102 */ - { 0x0000, 0x0000, 0x0000 }, /* R103 */ - { 0x0000, 0x0000, 0x0000 }, /* R104 */ - { 0x0000, 0x0000, 0x0000 }, /* R105 */ - { 0x0000, 0x0000, 0x0000 }, /* R106 */ - { 0x0000, 0x0000, 0x0000 }, /* R107 */ - { 0x0000, 0x0000, 0x0000 }, /* R108 */ - { 0x0000, 0x0000, 0x0000 }, /* R109 */ - { 0x0000, 0x0000, 0x0000 }, /* R110 */ - { 0x0000, 0x0000, 0x0000 }, /* R111 */ - { 0x0000, 0x0000, 0x0000 }, /* R112 */ - { 0x0000, 0x0000, 0x0000 }, /* R113 */ - { 0x0000, 0x0000, 0x0000 }, /* R114 */ - { 0x0000, 0x0000, 0x0000 }, /* R115 */ - { 0x0000, 0x0000, 0x0000 }, /* R116 */ - { 0x0000, 0x0000, 0x0000 }, /* R117 */ - { 0x0000, 0x0000, 0x0000 }, /* R118 */ - { 0x0000, 0x0000, 0x0000 }, /* R119 */ - { 0x0000, 0x0000, 0x0000 }, /* R120 */ - { 0x0000, 0x0000, 0x0000 }, /* R121 */ - { 0x0000, 0x0000, 0x0000 }, /* R122 */ - { 0x0000, 0x0000, 0x0000 }, /* R123 */ - { 0x0000, 0x0000, 0x0000 }, /* R124 */ - { 0x0000, 0x0000, 0x0000 }, /* R125 */ - { 0x0000, 0x0000, 0x0000 }, /* R126 */ - { 0x0000, 0x0000, 0x0000 }, /* R127 */ - { 0x0000, 0x0000, 0x0000 }, /* R128 */ - { 0x0000, 0x0000, 0x0000 }, /* R129 */ - { 0x0000, 0x0000, 0x0000 }, /* R130 */ - { 0x0000, 0x0000, 0x0000 }, /* R131 */ - { 0x0000, 0x0000, 0x0000 }, /* R132 */ - { 0x0000, 0x0000, 0x0000 }, /* R133 */ - { 0x0000, 0x0000, 0x0000 }, /* R134 */ - { 0x0000, 0x0000, 0x0000 }, /* R135 */ - { 0x0000, 0x0000, 0x0000 }, /* R136 */ - { 0x0000, 0x0000, 0x0000 }, /* R137 */ - { 0x0000, 0x0000, 0x0000 }, /* R138 */ - { 0x0000, 0x0000, 0x0000 }, /* R139 */ - { 0x0000, 0x0000, 0x0000 }, /* R140 */ - { 0x0000, 0x0000, 0x0000 }, /* R141 */ - { 0x0000, 0x0000, 0x0000 }, /* R142 */ - { 0x0000, 0x0000, 0x0000 }, /* R143 */ - { 0x0000, 0x0000, 0x0000 }, /* R144 */ - { 0x0000, 0x0000, 0x0000 }, /* R145 */ - { 0x0000, 0x0000, 0x0000 }, /* R146 */ - { 0x0000, 0x0000, 0x0000 }, /* R147 */ - { 0x0000, 0x0000, 0x0000 }, /* R148 */ - { 0x0000, 0x0000, 0x0000 }, /* R149 */ - { 0x0000, 0x0000, 0x0000 }, /* R150 */ - { 0x0000, 0x0000, 0x0000 }, /* R151 */ - { 0x0000, 0x0000, 0x0000 }, /* R152 */ - { 0x0000, 0x0000, 0x0000 }, /* R153 */ - { 0x0000, 0x0000, 0x0000 }, /* R154 */ - { 0x0000, 0x0000, 0x0000 }, /* R155 */ - { 0x0000, 0x0000, 0x0000 }, /* R156 */ - { 0x0000, 0x0000, 0x0000 }, /* R157 */ - { 0x0000, 0x0000, 0x0000 }, /* R158 */ - { 0x0000, 0x0000, 0x0000 }, /* R159 */ - { 0x0000, 0x0000, 0x0000 }, /* R160 */ - { 0x0000, 0x0000, 0x0000 }, /* R161 */ - { 0x0000, 0x0000, 0x0000 }, /* R162 */ - { 0x0000, 0x0000, 0x0000 }, /* R163 */ - { 0x0000, 0x0000, 0x0000 }, /* R164 */ - { 0x0000, 0x0000, 0x0000 }, /* R165 */ - { 0x0000, 0x0000, 0x0000 }, /* R166 */ - { 0x0000, 0x0000, 0x0000 }, /* R167 */ - { 0x0000, 0x0000, 0x0000 }, /* R168 */ - { 0x0000, 0x0000, 0x0000 }, /* R169 */ - { 0x0000, 0x0000, 0x0000 }, /* R170 */ - { 0x0000, 0x0000, 0x0000 }, /* R171 */ - { 0x0000, 0x0000, 0x0000 }, /* R172 */ - { 0x0000, 0x0000, 0x0000 }, /* R173 */ - { 0x0000, 0x0000, 0x0000 }, /* R174 */ - { 0x0000, 0x0000, 0x0000 }, /* R175 */ - { 0x0000, 0x0000, 0x0000 }, /* R176 */ - { 0x0000, 0x0000, 0x0000 }, /* R177 */ - { 0x0000, 0x0000, 0x0000 }, /* R178 */ - { 0x0000, 0x0000, 0x0000 }, /* R179 */ - { 0x0000, 0x0000, 0x0000 }, /* R180 */ - { 0x0000, 0x0000, 0x0000 }, /* R181 */ - { 0x0000, 0x0000, 0x0000 }, /* R182 */ - { 0x0000, 0x0000, 0x0000 }, /* R183 */ - { 0x0000, 0x0000, 0x0000 }, /* R184 */ - { 0x0000, 0x0000, 0x0000 }, /* R185 */ - { 0x0000, 0x0000, 0x0000 }, /* R186 */ - { 0x0000, 0x0000, 0x0000 }, /* R187 */ - { 0x0000, 0x0000, 0x0000 }, /* R188 */ - { 0x0000, 0x0000, 0x0000 }, /* R189 */ - { 0x0000, 0x0000, 0x0000 }, /* R190 */ - { 0x0000, 0x0000, 0x0000 }, /* R191 */ - { 0x0000, 0x0000, 0x0000 }, /* R192 */ - { 0x0000, 0x0000, 0x0000 }, /* R193 */ - { 0x0000, 0x0000, 0x0000 }, /* R194 */ - { 0x0000, 0x0000, 0x0000 }, /* R195 */ - { 0x0000, 0x0000, 0x0000 }, /* R196 */ - { 0x0000, 0x0000, 0x0000 }, /* R197 */ - { 0x0000, 0x0000, 0x0000 }, /* R198 */ - { 0x0000, 0x0000, 0x0000 }, /* R199 */ - { 0x0000, 0x0000, 0x0000 }, /* R200 */ - { 0x0000, 0x0000, 0x0000 }, /* R201 */ - { 0x0000, 0x0000, 0x0000 }, /* R202 */ - { 0x0000, 0x0000, 0x0000 }, /* R203 */ - { 0x0000, 0x0000, 0x0000 }, /* R204 */ - { 0x0000, 0x0000, 0x0000 }, /* R205 */ - { 0x0000, 0x0000, 0x0000 }, /* R206 */ - { 0x0000, 0x0000, 0x0000 }, /* R207 */ - { 0x0000, 0x0000, 0x0000 }, /* R208 */ - { 0x0000, 0x0000, 0x0000 }, /* R209 */ - { 0x0000, 0x0000, 0x0000 }, /* R210 */ - { 0x0000, 0x0000, 0x0000 }, /* R211 */ - { 0x0000, 0x0000, 0x0000 }, /* R212 */ - { 0x0000, 0x0000, 0x0000 }, /* R213 */ - { 0x0000, 0x0000, 0x0000 }, /* R214 */ - { 0x0000, 0x0000, 0x0000 }, /* R215 */ - { 0x0000, 0x0000, 0x0000 }, /* R216 */ - { 0x0000, 0x0000, 0x0000 }, /* R217 */ - { 0x0000, 0x0000, 0x0000 }, /* R218 */ - { 0x0000, 0x0000, 0x0000 }, /* R219 */ - { 0x0000, 0x0000, 0x0000 }, /* R220 */ - { 0x0000, 0x0000, 0x0000 }, /* R221 */ - { 0x0000, 0x0000, 0x0000 }, /* R222 */ - { 0x0000, 0x0000, 0x0000 }, /* R223 */ - { 0x0000, 0x0000, 0x0000 }, /* R224 */ - { 0x0000, 0x0000, 0x0000 }, /* R225 */ - { 0x0000, 0x0000, 0x0000 }, /* R226 */ - { 0x0000, 0x0000, 0x0000 }, /* R227 */ - { 0x0000, 0x0000, 0x0000 }, /* R228 */ - { 0x0000, 0x0000, 0x0000 }, /* R229 */ - { 0x0000, 0x0000, 0x0000 }, /* R230 */ - { 0x0000, 0x0000, 0x0000 }, /* R231 */ - { 0x0000, 0x0000, 0x0000 }, /* R232 */ - { 0x0000, 0x0000, 0x0000 }, /* R233 */ - { 0x0000, 0x0000, 0x0000 }, /* R234 */ - { 0x0000, 0x0000, 0x0000 }, /* R235 */ - { 0x0000, 0x0000, 0x0000 }, /* R236 */ - { 0x0000, 0x0000, 0x0000 }, /* R237 */ - { 0x0000, 0x0000, 0x0000 }, /* R238 */ - { 0x0000, 0x0000, 0x0000 }, /* R239 */ - { 0x0000, 0x0000, 0x0000 }, /* R240 */ - { 0x0000, 0x0000, 0x0000 }, /* R241 */ - { 0x0000, 0x0000, 0x0000 }, /* R242 */ - { 0x0000, 0x0000, 0x0000 }, /* R243 */ - { 0x0000, 0x0000, 0x0000 }, /* R244 */ - { 0x0000, 0x0000, 0x0000 }, /* R245 */ - { 0x0000, 0x0000, 0x0000 }, /* R246 */ - { 0x0000, 0x0000, 0x0000 }, /* R247 */ - { 0x0000, 0x0000, 0x0000 }, /* R248 */ - { 0x0000, 0x0000, 0x0000 }, /* R249 */ - { 0x0000, 0x0000, 0x0000 }, /* R250 */ - { 0x0000, 0x0000, 0x0000 }, /* R251 */ - { 0x0000, 0x0000, 0x0000 }, /* R252 */ - { 0x0000, 0x0000, 0x0000 }, /* R253 */ - { 0x0000, 0x0000, 0x0000 }, /* R254 */ - { 0x0000, 0x0000, 0x0000 }, /* R255 */ - { 0x000F, 0x0000, 0x0000 }, /* R256 - Chip Revision */ - { 0x0074, 0x0074, 0x0000 }, /* R257 - Control Interface */ - { 0x0000, 0x0000, 0x0000 }, /* R258 */ - { 0x0000, 0x0000, 0x0000 }, /* R259 */ - { 0x0000, 0x0000, 0x0000 }, /* R260 */ - { 0x0000, 0x0000, 0x0000 }, /* R261 */ - { 0x0000, 0x0000, 0x0000 }, /* R262 */ - { 0x0000, 0x0000, 0x0000 }, /* R263 */ - { 0x0000, 0x0000, 0x0000 }, /* R264 */ - { 0x0000, 0x0000, 0x0000 }, /* R265 */ - { 0x0000, 0x0000, 0x0000 }, /* R266 */ - { 0x0000, 0x0000, 0x0000 }, /* R267 */ - { 0x0000, 0x0000, 0x0000 }, /* R268 */ - { 0x0000, 0x0000, 0x0000 }, /* R269 */ - { 0x0000, 0x0000, 0x0000 }, /* R270 */ - { 0x0000, 0x0000, 0x0000 }, /* R271 */ - { 0x807F, 0x837F, 0x0000 }, /* R272 - Write Sequencer Ctrl (1) */ - { 0x017F, 0x0000, 0x0000 }, /* R273 - Write Sequencer Ctrl (2) */ - { 0x0000, 0x0000, 0x0000 }, /* R274 */ - { 0x0000, 0x0000, 0x0000 }, /* R275 */ - { 0x0000, 0x0000, 0x0000 }, /* R276 */ - { 0x0000, 0x0000, 0x0000 }, /* R277 */ - { 0x0000, 0x0000, 0x0000 }, /* R278 */ - { 0x0000, 0x0000, 0x0000 }, /* R279 */ - { 0x0000, 0x0000, 0x0000 }, /* R280 */ - { 0x0000, 0x0000, 0x0000 }, /* R281 */ - { 0x0000, 0x0000, 0x0000 }, /* R282 */ - { 0x0000, 0x0000, 0x0000 }, /* R283 */ - { 0x0000, 0x0000, 0x0000 }, /* R284 */ - { 0x0000, 0x0000, 0x0000 }, /* R285 */ - { 0x0000, 0x0000, 0x0000 }, /* R286 */ - { 0x0000, 0x0000, 0x0000 }, /* R287 */ - { 0x0000, 0x0000, 0x0000 }, /* R288 */ - { 0x0000, 0x0000, 0x0000 }, /* R289 */ - { 0x0000, 0x0000, 0x0000 }, /* R290 */ - { 0x0000, 0x0000, 0x0000 }, /* R291 */ - { 0x0000, 0x0000, 0x0000 }, /* R292 */ - { 0x0000, 0x0000, 0x0000 }, /* R293 */ - { 0x0000, 0x0000, 0x0000 }, /* R294 */ - { 0x0000, 0x0000, 0x0000 }, /* R295 */ - { 0x0000, 0x0000, 0x0000 }, /* R296 */ - { 0x0000, 0x0000, 0x0000 }, /* R297 */ - { 0x0000, 0x0000, 0x0000 }, /* R298 */ - { 0x0000, 0x0000, 0x0000 }, /* R299 */ - { 0x0000, 0x0000, 0x0000 }, /* R300 */ - { 0x0000, 0x0000, 0x0000 }, /* R301 */ - { 0x0000, 0x0000, 0x0000 }, /* R302 */ - { 0x0000, 0x0000, 0x0000 }, /* R303 */ - { 0x0000, 0x0000, 0x0000 }, /* R304 */ - { 0x0000, 0x0000, 0x0000 }, /* R305 */ - { 0x0000, 0x0000, 0x0000 }, /* R306 */ - { 0x0000, 0x0000, 0x0000 }, /* R307 */ - { 0x0000, 0x0000, 0x0000 }, /* R308 */ - { 0x0000, 0x0000, 0x0000 }, /* R309 */ - { 0x0000, 0x0000, 0x0000 }, /* R310 */ - { 0x0000, 0x0000, 0x0000 }, /* R311 */ - { 0x0000, 0x0000, 0x0000 }, /* R312 */ - { 0x0000, 0x0000, 0x0000 }, /* R313 */ - { 0x0000, 0x0000, 0x0000 }, /* R314 */ - { 0x0000, 0x0000, 0x0000 }, /* R315 */ - { 0x0000, 0x0000, 0x0000 }, /* R316 */ - { 0x0000, 0x0000, 0x0000 }, /* R317 */ - { 0x0000, 0x0000, 0x0000 }, /* R318 */ - { 0x0000, 0x0000, 0x0000 }, /* R319 */ - { 0x0000, 0x0000, 0x0000 }, /* R320 */ - { 0x0000, 0x0000, 0x0000 }, /* R321 */ - { 0x0000, 0x0000, 0x0000 }, /* R322 */ - { 0x0000, 0x0000, 0x0000 }, /* R323 */ - { 0x0000, 0x0000, 0x0000 }, /* R324 */ - { 0x0000, 0x0000, 0x0000 }, /* R325 */ - { 0x0000, 0x0000, 0x0000 }, /* R326 */ - { 0x0000, 0x0000, 0x0000 }, /* R327 */ - { 0x0000, 0x0000, 0x0000 }, /* R328 */ - { 0x0000, 0x0000, 0x0000 }, /* R329 */ - { 0x0000, 0x0000, 0x0000 }, /* R330 */ - { 0x0000, 0x0000, 0x0000 }, /* R331 */ - { 0x0000, 0x0000, 0x0000 }, /* R332 */ - { 0x0000, 0x0000, 0x0000 }, /* R333 */ - { 0x0000, 0x0000, 0x0000 }, /* R334 */ - { 0x0000, 0x0000, 0x0000 }, /* R335 */ - { 0x0000, 0x0000, 0x0000 }, /* R336 */ - { 0x0000, 0x0000, 0x0000 }, /* R337 */ - { 0x0000, 0x0000, 0x0000 }, /* R338 */ - { 0x0000, 0x0000, 0x0000 }, /* R339 */ - { 0x0000, 0x0000, 0x0000 }, /* R340 */ - { 0x0000, 0x0000, 0x0000 }, /* R341 */ - { 0x0000, 0x0000, 0x0000 }, /* R342 */ - { 0x0000, 0x0000, 0x0000 }, /* R343 */ - { 0x0000, 0x0000, 0x0000 }, /* R344 */ - { 0x0000, 0x0000, 0x0000 }, /* R345 */ - { 0x0000, 0x0000, 0x0000 }, /* R346 */ - { 0x0000, 0x0000, 0x0000 }, /* R347 */ - { 0x0000, 0x0000, 0x0000 }, /* R348 */ - { 0x0000, 0x0000, 0x0000 }, /* R349 */ - { 0x0000, 0x0000, 0x0000 }, /* R350 */ - { 0x0000, 0x0000, 0x0000 }, /* R351 */ - { 0x0000, 0x0000, 0x0000 }, /* R352 */ - { 0x0000, 0x0000, 0x0000 }, /* R353 */ - { 0x0000, 0x0000, 0x0000 }, /* R354 */ - { 0x0000, 0x0000, 0x0000 }, /* R355 */ - { 0x0000, 0x0000, 0x0000 }, /* R356 */ - { 0x0000, 0x0000, 0x0000 }, /* R357 */ - { 0x0000, 0x0000, 0x0000 }, /* R358 */ - { 0x0000, 0x0000, 0x0000 }, /* R359 */ - { 0x0000, 0x0000, 0x0000 }, /* R360 */ - { 0x0000, 0x0000, 0x0000 }, /* R361 */ - { 0x0000, 0x0000, 0x0000 }, /* R362 */ - { 0x0000, 0x0000, 0x0000 }, /* R363 */ - { 0x0000, 0x0000, 0x0000 }, /* R364 */ - { 0x0000, 0x0000, 0x0000 }, /* R365 */ - { 0x0000, 0x0000, 0x0000 }, /* R366 */ - { 0x0000, 0x0000, 0x0000 }, /* R367 */ - { 0x0000, 0x0000, 0x0000 }, /* R368 */ - { 0x0000, 0x0000, 0x0000 }, /* R369 */ - { 0x0000, 0x0000, 0x0000 }, /* R370 */ - { 0x0000, 0x0000, 0x0000 }, /* R371 */ - { 0x0000, 0x0000, 0x0000 }, /* R372 */ - { 0x0000, 0x0000, 0x0000 }, /* R373 */ - { 0x0000, 0x0000, 0x0000 }, /* R374 */ - { 0x0000, 0x0000, 0x0000 }, /* R375 */ - { 0x0000, 0x0000, 0x0000 }, /* R376 */ - { 0x0000, 0x0000, 0x0000 }, /* R377 */ - { 0x0000, 0x0000, 0x0000 }, /* R378 */ - { 0x0000, 0x0000, 0x0000 }, /* R379 */ - { 0x0000, 0x0000, 0x0000 }, /* R380 */ - { 0x0000, 0x0000, 0x0000 }, /* R381 */ - { 0x0000, 0x0000, 0x0000 }, /* R382 */ - { 0x0000, 0x0000, 0x0000 }, /* R383 */ - { 0x0000, 0x0000, 0x0000 }, /* R384 */ - { 0x0000, 0x0000, 0x0000 }, /* R385 */ - { 0x0000, 0x0000, 0x0000 }, /* R386 */ - { 0x0000, 0x0000, 0x0000 }, /* R387 */ - { 0x0000, 0x0000, 0x0000 }, /* R388 */ - { 0x0000, 0x0000, 0x0000 }, /* R389 */ - { 0x0000, 0x0000, 0x0000 }, /* R390 */ - { 0x0000, 0x0000, 0x0000 }, /* R391 */ - { 0x0000, 0x0000, 0x0000 }, /* R392 */ - { 0x0000, 0x0000, 0x0000 }, /* R393 */ - { 0x0000, 0x0000, 0x0000 }, /* R394 */ - { 0x0000, 0x0000, 0x0000 }, /* R395 */ - { 0x0000, 0x0000, 0x0000 }, /* R396 */ - { 0x0000, 0x0000, 0x0000 }, /* R397 */ - { 0x0000, 0x0000, 0x0000 }, /* R398 */ - { 0x0000, 0x0000, 0x0000 }, /* R399 */ - { 0x0000, 0x0000, 0x0000 }, /* R400 */ - { 0x0000, 0x0000, 0x0000 }, /* R401 */ - { 0x0000, 0x0000, 0x0000 }, /* R402 */ - { 0x0000, 0x0000, 0x0000 }, /* R403 */ - { 0x0000, 0x0000, 0x0000 }, /* R404 */ - { 0x0000, 0x0000, 0x0000 }, /* R405 */ - { 0x0000, 0x0000, 0x0000 }, /* R406 */ - { 0x0000, 0x0000, 0x0000 }, /* R407 */ - { 0x0000, 0x0000, 0x0000 }, /* R408 */ - { 0x0000, 0x0000, 0x0000 }, /* R409 */ - { 0x0000, 0x0000, 0x0000 }, /* R410 */ - { 0x0000, 0x0000, 0x0000 }, /* R411 */ - { 0x0000, 0x0000, 0x0000 }, /* R412 */ - { 0x0000, 0x0000, 0x0000 }, /* R413 */ - { 0x0000, 0x0000, 0x0000 }, /* R414 */ - { 0x0000, 0x0000, 0x0000 }, /* R415 */ - { 0x0000, 0x0000, 0x0000 }, /* R416 */ - { 0x0000, 0x0000, 0x0000 }, /* R417 */ - { 0x0000, 0x0000, 0x0000 }, /* R418 */ - { 0x0000, 0x0000, 0x0000 }, /* R419 */ - { 0x0000, 0x0000, 0x0000 }, /* R420 */ - { 0x0000, 0x0000, 0x0000 }, /* R421 */ - { 0x0000, 0x0000, 0x0000 }, /* R422 */ - { 0x0000, 0x0000, 0x0000 }, /* R423 */ - { 0x0000, 0x0000, 0x0000 }, /* R424 */ - { 0x0000, 0x0000, 0x0000 }, /* R425 */ - { 0x0000, 0x0000, 0x0000 }, /* R426 */ - { 0x0000, 0x0000, 0x0000 }, /* R427 */ - { 0x0000, 0x0000, 0x0000 }, /* R428 */ - { 0x0000, 0x0000, 0x0000 }, /* R429 */ - { 0x0000, 0x0000, 0x0000 }, /* R430 */ - { 0x0000, 0x0000, 0x0000 }, /* R431 */ - { 0x0000, 0x0000, 0x0000 }, /* R432 */ - { 0x0000, 0x0000, 0x0000 }, /* R433 */ - { 0x0000, 0x0000, 0x0000 }, /* R434 */ - { 0x0000, 0x0000, 0x0000 }, /* R435 */ - { 0x0000, 0x0000, 0x0000 }, /* R436 */ - { 0x0000, 0x0000, 0x0000 }, /* R437 */ - { 0x0000, 0x0000, 0x0000 }, /* R438 */ - { 0x0000, 0x0000, 0x0000 }, /* R439 */ - { 0x0000, 0x0000, 0x0000 }, /* R440 */ - { 0x0000, 0x0000, 0x0000 }, /* R441 */ - { 0x0000, 0x0000, 0x0000 }, /* R442 */ - { 0x0000, 0x0000, 0x0000 }, /* R443 */ - { 0x0000, 0x0000, 0x0000 }, /* R444 */ - { 0x0000, 0x0000, 0x0000 }, /* R445 */ - { 0x0000, 0x0000, 0x0000 }, /* R446 */ - { 0x0000, 0x0000, 0x0000 }, /* R447 */ - { 0x0000, 0x0000, 0x0000 }, /* R448 */ - { 0x0000, 0x0000, 0x0000 }, /* R449 */ - { 0x0000, 0x0000, 0x0000 }, /* R450 */ - { 0x0000, 0x0000, 0x0000 }, /* R451 */ - { 0x0000, 0x0000, 0x0000 }, /* R452 */ - { 0x0000, 0x0000, 0x0000 }, /* R453 */ - { 0x0000, 0x0000, 0x0000 }, /* R454 */ - { 0x0000, 0x0000, 0x0000 }, /* R455 */ - { 0x0000, 0x0000, 0x0000 }, /* R456 */ - { 0x0000, 0x0000, 0x0000 }, /* R457 */ - { 0x0000, 0x0000, 0x0000 }, /* R458 */ - { 0x0000, 0x0000, 0x0000 }, /* R459 */ - { 0x0000, 0x0000, 0x0000 }, /* R460 */ - { 0x0000, 0x0000, 0x0000 }, /* R461 */ - { 0x0000, 0x0000, 0x0000 }, /* R462 */ - { 0x0000, 0x0000, 0x0000 }, /* R463 */ - { 0x0000, 0x0000, 0x0000 }, /* R464 */ - { 0x0000, 0x0000, 0x0000 }, /* R465 */ - { 0x0000, 0x0000, 0x0000 }, /* R466 */ - { 0x0000, 0x0000, 0x0000 }, /* R467 */ - { 0x0000, 0x0000, 0x0000 }, /* R468 */ - { 0x0000, 0x0000, 0x0000 }, /* R469 */ - { 0x0000, 0x0000, 0x0000 }, /* R470 */ - { 0x0000, 0x0000, 0x0000 }, /* R471 */ - { 0x0000, 0x0000, 0x0000 }, /* R472 */ - { 0x0000, 0x0000, 0x0000 }, /* R473 */ - { 0x0000, 0x0000, 0x0000 }, /* R474 */ - { 0x0000, 0x0000, 0x0000 }, /* R475 */ - { 0x0000, 0x0000, 0x0000 }, /* R476 */ - { 0x0000, 0x0000, 0x0000 }, /* R477 */ - { 0x0000, 0x0000, 0x0000 }, /* R478 */ - { 0x0000, 0x0000, 0x0000 }, /* R479 */ - { 0x0000, 0x0000, 0x0000 }, /* R480 */ - { 0x0000, 0x0000, 0x0000 }, /* R481 */ - { 0x0000, 0x0000, 0x0000 }, /* R482 */ - { 0x0000, 0x0000, 0x0000 }, /* R483 */ - { 0x0000, 0x0000, 0x0000 }, /* R484 */ - { 0x0000, 0x0000, 0x0000 }, /* R485 */ - { 0x0000, 0x0000, 0x0000 }, /* R486 */ - { 0x0000, 0x0000, 0x0000 }, /* R487 */ - { 0x0000, 0x0000, 0x0000 }, /* R488 */ - { 0x0000, 0x0000, 0x0000 }, /* R489 */ - { 0x0000, 0x0000, 0x0000 }, /* R490 */ - { 0x0000, 0x0000, 0x0000 }, /* R491 */ - { 0x0000, 0x0000, 0x0000 }, /* R492 */ - { 0x0000, 0x0000, 0x0000 }, /* R493 */ - { 0x0000, 0x0000, 0x0000 }, /* R494 */ - { 0x0000, 0x0000, 0x0000 }, /* R495 */ - { 0x0000, 0x0000, 0x0000 }, /* R496 */ - { 0x0000, 0x0000, 0x0000 }, /* R497 */ - { 0x0000, 0x0000, 0x0000 }, /* R498 */ - { 0x0000, 0x0000, 0x0000 }, /* R499 */ - { 0x0000, 0x0000, 0x0000 }, /* R500 */ - { 0x0000, 0x0000, 0x0000 }, /* R501 */ - { 0x0000, 0x0000, 0x0000 }, /* R502 */ - { 0x0000, 0x0000, 0x0000 }, /* R503 */ - { 0x0000, 0x0000, 0x0000 }, /* R504 */ - { 0x0000, 0x0000, 0x0000 }, /* R505 */ - { 0x0000, 0x0000, 0x0000 }, /* R506 */ - { 0x0000, 0x0000, 0x0000 }, /* R507 */ - { 0x0000, 0x0000, 0x0000 }, /* R508 */ - { 0x0000, 0x0000, 0x0000 }, /* R509 */ - { 0x0000, 0x0000, 0x0000 }, /* R510 */ - { 0x0000, 0x0000, 0x0000 }, /* R511 */ - { 0x001F, 0x001F, 0x0000 }, /* R512 - AIF1 Clocking (1) */ - { 0x003F, 0x003F, 0x0000 }, /* R513 - AIF1 Clocking (2) */ - { 0x0000, 0x0000, 0x0000 }, /* R514 */ - { 0x0000, 0x0000, 0x0000 }, /* R515 */ - { 0x001F, 0x001F, 0x0000 }, /* R516 - AIF2 Clocking (1) */ - { 0x003F, 0x003F, 0x0000 }, /* R517 - AIF2 Clocking (2) */ - { 0x0000, 0x0000, 0x0000 }, /* R518 */ - { 0x0000, 0x0000, 0x0000 }, /* R519 */ - { 0x001F, 0x001F, 0x0000 }, /* R520 - Clocking (1) */ - { 0x0777, 0x0777, 0x0000 }, /* R521 - Clocking (2) */ - { 0x0000, 0x0000, 0x0000 }, /* R522 */ - { 0x0000, 0x0000, 0x0000 }, /* R523 */ - { 0x0000, 0x0000, 0x0000 }, /* R524 */ - { 0x0000, 0x0000, 0x0000 }, /* R525 */ - { 0x0000, 0x0000, 0x0000 }, /* R526 */ - { 0x0000, 0x0000, 0x0000 }, /* R527 */ - { 0x00FF, 0x00FF, 0x0000 }, /* R528 - AIF1 Rate */ - { 0x00FF, 0x00FF, 0x0000 }, /* R529 - AIF2 Rate */ - { 0x000F, 0x0000, 0x0000 }, /* R530 - Rate Status */ - { 0x0000, 0x0000, 0x0000 }, /* R531 */ - { 0x0000, 0x0000, 0x0000 }, /* R532 */ - { 0x0000, 0x0000, 0x0000 }, /* R533 */ - { 0x0000, 0x0000, 0x0000 }, /* R534 */ - { 0x0000, 0x0000, 0x0000 }, /* R535 */ - { 0x0000, 0x0000, 0x0000 }, /* R536 */ - { 0x0000, 0x0000, 0x0000 }, /* R537 */ - { 0x0000, 0x0000, 0x0000 }, /* R538 */ - { 0x0000, 0x0000, 0x0000 }, /* R539 */ - { 0x0000, 0x0000, 0x0000 }, /* R540 */ - { 0x0000, 0x0000, 0x0000 }, /* R541 */ - { 0x0000, 0x0000, 0x0000 }, /* R542 */ - { 0x0000, 0x0000, 0x0000 }, /* R543 */ - { 0x0007, 0x0007, 0x0000 }, /* R544 - FLL1 Control (1) */ - { 0x3F77, 0x3F77, 0x0000 }, /* R545 - FLL1 Control (2) */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R546 - FLL1 Control (3) */ - { 0x7FEF, 0x7FEF, 0x0000 }, /* R547 - FLL1 Control (4) */ - { 0x1FDB, 0x1FDB, 0x0000 }, /* R548 - FLL1 Control (5) */ - { 0x0000, 0x0000, 0x0000 }, /* R549 */ - { 0x0000, 0x0000, 0x0000 }, /* R550 */ - { 0x0000, 0x0000, 0x0000 }, /* R551 */ - { 0x0000, 0x0000, 0x0000 }, /* R552 */ - { 0x0000, 0x0000, 0x0000 }, /* R553 */ - { 0x0000, 0x0000, 0x0000 }, /* R554 */ - { 0x0000, 0x0000, 0x0000 }, /* R555 */ - { 0x0000, 0x0000, 0x0000 }, /* R556 */ - { 0x0000, 0x0000, 0x0000 }, /* R557 */ - { 0x0000, 0x0000, 0x0000 }, /* R558 */ - { 0x0000, 0x0000, 0x0000 }, /* R559 */ - { 0x0000, 0x0000, 0x0000 }, /* R560 */ - { 0x0000, 0x0000, 0x0000 }, /* R561 */ - { 0x0000, 0x0000, 0x0000 }, /* R562 */ - { 0x0000, 0x0000, 0x0000 }, /* R563 */ - { 0x0000, 0x0000, 0x0000 }, /* R564 */ - { 0x0000, 0x0000, 0x0000 }, /* R565 */ - { 0x0000, 0x0000, 0x0000 }, /* R566 */ - { 0x0000, 0x0000, 0x0000 }, /* R567 */ - { 0x0000, 0x0000, 0x0000 }, /* R568 */ - { 0x0000, 0x0000, 0x0000 }, /* R569 */ - { 0x0000, 0x0000, 0x0000 }, /* R570 */ - { 0x0000, 0x0000, 0x0000 }, /* R571 */ - { 0x0000, 0x0000, 0x0000 }, /* R572 */ - { 0x0000, 0x0000, 0x0000 }, /* R573 */ - { 0x0000, 0x0000, 0x0000 }, /* R574 */ - { 0x0000, 0x0000, 0x0000 }, /* R575 */ - { 0x0007, 0x0007, 0x0000 }, /* R576 - FLL2 Control (1) */ - { 0x3F77, 0x3F77, 0x0000 }, /* R577 - FLL2 Control (2) */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R578 - FLL2 Control (3) */ - { 0x7FEF, 0x7FEF, 0x0000 }, /* R579 - FLL2 Control (4) */ - { 0x1FDB, 0x1FDB, 0x0000 }, /* R580 - FLL2 Control (5) */ - { 0x0000, 0x0000, 0x0000 }, /* R581 */ - { 0x0000, 0x0000, 0x0000 }, /* R582 */ - { 0x0000, 0x0000, 0x0000 }, /* R583 */ - { 0x0000, 0x0000, 0x0000 }, /* R584 */ - { 0x0000, 0x0000, 0x0000 }, /* R585 */ - { 0x0000, 0x0000, 0x0000 }, /* R586 */ - { 0x0000, 0x0000, 0x0000 }, /* R587 */ - { 0x0000, 0x0000, 0x0000 }, /* R588 */ - { 0x0000, 0x0000, 0x0000 }, /* R589 */ - { 0x0000, 0x0000, 0x0000 }, /* R590 */ - { 0x0000, 0x0000, 0x0000 }, /* R591 */ - { 0x0000, 0x0000, 0x0000 }, /* R592 */ - { 0x0000, 0x0000, 0x0000 }, /* R593 */ - { 0x0000, 0x0000, 0x0000 }, /* R594 */ - { 0x0000, 0x0000, 0x0000 }, /* R595 */ - { 0x0000, 0x0000, 0x0000 }, /* R596 */ - { 0x0000, 0x0000, 0x0000 }, /* R597 */ - { 0x0000, 0x0000, 0x0000 }, /* R598 */ - { 0x0000, 0x0000, 0x0000 }, /* R599 */ - { 0x0000, 0x0000, 0x0000 }, /* R600 */ - { 0x0000, 0x0000, 0x0000 }, /* R601 */ - { 0x0000, 0x0000, 0x0000 }, /* R602 */ - { 0x0000, 0x0000, 0x0000 }, /* R603 */ - { 0x0000, 0x0000, 0x0000 }, /* R604 */ - { 0x0000, 0x0000, 0x0000 }, /* R605 */ - { 0x0000, 0x0000, 0x0000 }, /* R606 */ - { 0x0000, 0x0000, 0x0000 }, /* R607 */ - { 0x0000, 0x0000, 0x0000 }, /* R608 */ - { 0x0000, 0x0000, 0x0000 }, /* R609 */ - { 0x0000, 0x0000, 0x0000 }, /* R610 */ - { 0x0000, 0x0000, 0x0000 }, /* R611 */ - { 0x0000, 0x0000, 0x0000 }, /* R612 */ - { 0x0000, 0x0000, 0x0000 }, /* R613 */ - { 0x0000, 0x0000, 0x0000 }, /* R614 */ - { 0x0000, 0x0000, 0x0000 }, /* R615 */ - { 0x0000, 0x0000, 0x0000 }, /* R616 */ - { 0x0000, 0x0000, 0x0000 }, /* R617 */ - { 0x0000, 0x0000, 0x0000 }, /* R618 */ - { 0x0000, 0x0000, 0x0000 }, /* R619 */ - { 0x0000, 0x0000, 0x0000 }, /* R620 */ - { 0x0000, 0x0000, 0x0000 }, /* R621 */ - { 0x0000, 0x0000, 0x0000 }, /* R622 */ - { 0x0000, 0x0000, 0x0000 }, /* R623 */ - { 0x0000, 0x0000, 0x0000 }, /* R624 */ - { 0x0000, 0x0000, 0x0000 }, /* R625 */ - { 0x0000, 0x0000, 0x0000 }, /* R626 */ - { 0x0000, 0x0000, 0x0000 }, /* R627 */ - { 0x0000, 0x0000, 0x0000 }, /* R628 */ - { 0x0000, 0x0000, 0x0000 }, /* R629 */ - { 0x0000, 0x0000, 0x0000 }, /* R630 */ - { 0x0000, 0x0000, 0x0000 }, /* R631 */ - { 0x0000, 0x0000, 0x0000 }, /* R632 */ - { 0x0000, 0x0000, 0x0000 }, /* R633 */ - { 0x0000, 0x0000, 0x0000 }, /* R634 */ - { 0x0000, 0x0000, 0x0000 }, /* R635 */ - { 0x0000, 0x0000, 0x0000 }, /* R636 */ - { 0x0000, 0x0000, 0x0000 }, /* R637 */ - { 0x0000, 0x0000, 0x0000 }, /* R638 */ - { 0x0000, 0x0000, 0x0000 }, /* R639 */ - { 0x0000, 0x0000, 0x0000 }, /* R640 */ - { 0x0000, 0x0000, 0x0000 }, /* R641 */ - { 0x0000, 0x0000, 0x0000 }, /* R642 */ - { 0x0000, 0x0000, 0x0000 }, /* R643 */ - { 0x0000, 0x0000, 0x0000 }, /* R644 */ - { 0x0000, 0x0000, 0x0000 }, /* R645 */ - { 0x0000, 0x0000, 0x0000 }, /* R646 */ - { 0x0000, 0x0000, 0x0000 }, /* R647 */ - { 0x0000, 0x0000, 0x0000 }, /* R648 */ - { 0x0000, 0x0000, 0x0000 }, /* R649 */ - { 0x0000, 0x0000, 0x0000 }, /* R650 */ - { 0x0000, 0x0000, 0x0000 }, /* R651 */ - { 0x0000, 0x0000, 0x0000 }, /* R652 */ - { 0x0000, 0x0000, 0x0000 }, /* R653 */ - { 0x0000, 0x0000, 0x0000 }, /* R654 */ - { 0x0000, 0x0000, 0x0000 }, /* R655 */ - { 0x0000, 0x0000, 0x0000 }, /* R656 */ - { 0x0000, 0x0000, 0x0000 }, /* R657 */ - { 0x0000, 0x0000, 0x0000 }, /* R658 */ - { 0x0000, 0x0000, 0x0000 }, /* R659 */ - { 0x0000, 0x0000, 0x0000 }, /* R660 */ - { 0x0000, 0x0000, 0x0000 }, /* R661 */ - { 0x0000, 0x0000, 0x0000 }, /* R662 */ - { 0x0000, 0x0000, 0x0000 }, /* R663 */ - { 0x0000, 0x0000, 0x0000 }, /* R664 */ - { 0x0000, 0x0000, 0x0000 }, /* R665 */ - { 0x0000, 0x0000, 0x0000 }, /* R666 */ - { 0x0000, 0x0000, 0x0000 }, /* R667 */ - { 0x0000, 0x0000, 0x0000 }, /* R668 */ - { 0x0000, 0x0000, 0x0000 }, /* R669 */ - { 0x0000, 0x0000, 0x0000 }, /* R670 */ - { 0x0000, 0x0000, 0x0000 }, /* R671 */ - { 0x0000, 0x0000, 0x0000 }, /* R672 */ - { 0x0000, 0x0000, 0x0000 }, /* R673 */ - { 0x0000, 0x0000, 0x0000 }, /* R674 */ - { 0x0000, 0x0000, 0x0000 }, /* R675 */ - { 0x0000, 0x0000, 0x0000 }, /* R676 */ - { 0x0000, 0x0000, 0x0000 }, /* R677 */ - { 0x0000, 0x0000, 0x0000 }, /* R678 */ - { 0x0000, 0x0000, 0x0000 }, /* R679 */ - { 0x0000, 0x0000, 0x0000 }, /* R680 */ - { 0x0000, 0x0000, 0x0000 }, /* R681 */ - { 0x0000, 0x0000, 0x0000 }, /* R682 */ - { 0x0000, 0x0000, 0x0000 }, /* R683 */ - { 0x0000, 0x0000, 0x0000 }, /* R684 */ - { 0x0000, 0x0000, 0x0000 }, /* R685 */ - { 0x0000, 0x0000, 0x0000 }, /* R686 */ - { 0x0000, 0x0000, 0x0000 }, /* R687 */ - { 0x0000, 0x0000, 0x0000 }, /* R688 */ - { 0x0000, 0x0000, 0x0000 }, /* R689 */ - { 0x0000, 0x0000, 0x0000 }, /* R690 */ - { 0x0000, 0x0000, 0x0000 }, /* R691 */ - { 0x0000, 0x0000, 0x0000 }, /* R692 */ - { 0x0000, 0x0000, 0x0000 }, /* R693 */ - { 0x0000, 0x0000, 0x0000 }, /* R694 */ - { 0x0000, 0x0000, 0x0000 }, /* R695 */ - { 0x0000, 0x0000, 0x0000 }, /* R696 */ - { 0x0000, 0x0000, 0x0000 }, /* R697 */ - { 0x0000, 0x0000, 0x0000 }, /* R698 */ - { 0x0000, 0x0000, 0x0000 }, /* R699 */ - { 0x0000, 0x0000, 0x0000 }, /* R700 */ - { 0x0000, 0x0000, 0x0000 }, /* R701 */ - { 0x0000, 0x0000, 0x0000 }, /* R702 */ - { 0x0000, 0x0000, 0x0000 }, /* R703 */ - { 0x0000, 0x0000, 0x0000 }, /* R704 */ - { 0x0000, 0x0000, 0x0000 }, /* R705 */ - { 0x0000, 0x0000, 0x0000 }, /* R706 */ - { 0x0000, 0x0000, 0x0000 }, /* R707 */ - { 0x0000, 0x0000, 0x0000 }, /* R708 */ - { 0x0000, 0x0000, 0x0000 }, /* R709 */ - { 0x0000, 0x0000, 0x0000 }, /* R710 */ - { 0x0000, 0x0000, 0x0000 }, /* R711 */ - { 0x0000, 0x0000, 0x0000 }, /* R712 */ - { 0x0000, 0x0000, 0x0000 }, /* R713 */ - { 0x0000, 0x0000, 0x0000 }, /* R714 */ - { 0x0000, 0x0000, 0x0000 }, /* R715 */ - { 0x0000, 0x0000, 0x0000 }, /* R716 */ - { 0x0000, 0x0000, 0x0000 }, /* R717 */ - { 0x0000, 0x0000, 0x0000 }, /* R718 */ - { 0x0000, 0x0000, 0x0000 }, /* R719 */ - { 0x0000, 0x0000, 0x0000 }, /* R720 */ - { 0x0000, 0x0000, 0x0000 }, /* R721 */ - { 0x0000, 0x0000, 0x0000 }, /* R722 */ - { 0x0000, 0x0000, 0x0000 }, /* R723 */ - { 0x0000, 0x0000, 0x0000 }, /* R724 */ - { 0x0000, 0x0000, 0x0000 }, /* R725 */ - { 0x0000, 0x0000, 0x0000 }, /* R726 */ - { 0x0000, 0x0000, 0x0000 }, /* R727 */ - { 0x0000, 0x0000, 0x0000 }, /* R728 */ - { 0x0000, 0x0000, 0x0000 }, /* R729 */ - { 0x0000, 0x0000, 0x0000 }, /* R730 */ - { 0x0000, 0x0000, 0x0000 }, /* R731 */ - { 0x0000, 0x0000, 0x0000 }, /* R732 */ - { 0x0000, 0x0000, 0x0000 }, /* R733 */ - { 0x0000, 0x0000, 0x0000 }, /* R734 */ - { 0x0000, 0x0000, 0x0000 }, /* R735 */ - { 0x0000, 0x0000, 0x0000 }, /* R736 */ - { 0x0000, 0x0000, 0x0000 }, /* R737 */ - { 0x0000, 0x0000, 0x0000 }, /* R738 */ - { 0x0000, 0x0000, 0x0000 }, /* R739 */ - { 0x0000, 0x0000, 0x0000 }, /* R740 */ - { 0x0000, 0x0000, 0x0000 }, /* R741 */ - { 0x0000, 0x0000, 0x0000 }, /* R742 */ - { 0x0000, 0x0000, 0x0000 }, /* R743 */ - { 0x0000, 0x0000, 0x0000 }, /* R744 */ - { 0x0000, 0x0000, 0x0000 }, /* R745 */ - { 0x0000, 0x0000, 0x0000 }, /* R746 */ - { 0x0000, 0x0000, 0x0000 }, /* R747 */ - { 0x0000, 0x0000, 0x0000 }, /* R748 */ - { 0x0000, 0x0000, 0x0000 }, /* R749 */ - { 0x0000, 0x0000, 0x0000 }, /* R750 */ - { 0x0000, 0x0000, 0x0000 }, /* R751 */ - { 0x0000, 0x0000, 0x0000 }, /* R752 */ - { 0x0000, 0x0000, 0x0000 }, /* R753 */ - { 0x0000, 0x0000, 0x0000 }, /* R754 */ - { 0x0000, 0x0000, 0x0000 }, /* R755 */ - { 0x0000, 0x0000, 0x0000 }, /* R756 */ - { 0x0000, 0x0000, 0x0000 }, /* R757 */ - { 0x0000, 0x0000, 0x0000 }, /* R758 */ - { 0x0000, 0x0000, 0x0000 }, /* R759 */ - { 0x0000, 0x0000, 0x0000 }, /* R760 */ - { 0x0000, 0x0000, 0x0000 }, /* R761 */ - { 0x0000, 0x0000, 0x0000 }, /* R762 */ - { 0x0000, 0x0000, 0x0000 }, /* R763 */ - { 0x0000, 0x0000, 0x0000 }, /* R764 */ - { 0x0000, 0x0000, 0x0000 }, /* R765 */ - { 0x0000, 0x0000, 0x0000 }, /* R766 */ - { 0x0000, 0x0000, 0x0000 }, /* R767 */ - { 0xE1F8, 0xE1F8, 0x0000 }, /* R768 - AIF1 Control (1) */ - { 0xCD1F, 0xCD1F, 0x0000 }, /* R769 - AIF1 Control (2) */ - { 0xF000, 0xF000, 0x0000 }, /* R770 - AIF1 Master/Slave */ - { 0x01F0, 0x01F0, 0x0000 }, /* R771 - AIF1 BCLK */ - { 0x0FFF, 0x0FFF, 0x0000 }, /* R772 - AIF1ADC LRCLK */ - { 0x0FFF, 0x0FFF, 0x0000 }, /* R773 - AIF1DAC LRCLK */ - { 0x0003, 0x0003, 0x0000 }, /* R774 - AIF1DAC Data */ - { 0x0003, 0x0003, 0x0000 }, /* R775 - AIF1ADC Data */ - { 0x0000, 0x0000, 0x0000 }, /* R776 */ - { 0x0000, 0x0000, 0x0000 }, /* R777 */ - { 0x0000, 0x0000, 0x0000 }, /* R778 */ - { 0x0000, 0x0000, 0x0000 }, /* R779 */ - { 0x0000, 0x0000, 0x0000 }, /* R780 */ - { 0x0000, 0x0000, 0x0000 }, /* R781 */ - { 0x0000, 0x0000, 0x0000 }, /* R782 */ - { 0x0000, 0x0000, 0x0000 }, /* R783 */ - { 0xF1F8, 0xF1F8, 0x0000 }, /* R784 - AIF2 Control (1) */ - { 0xFD1F, 0xFD1F, 0x0000 }, /* R785 - AIF2 Control (2) */ - { 0xF000, 0xF000, 0x0000 }, /* R786 - AIF2 Master/Slave */ - { 0x01F0, 0x01F0, 0x0000 }, /* R787 - AIF2 BCLK */ - { 0x0FFF, 0x0FFF, 0x0000 }, /* R788 - AIF2ADC LRCLK */ - { 0x0FFF, 0x0FFF, 0x0000 }, /* R789 - AIF2DAC LRCLK */ - { 0x0003, 0x0003, 0x0000 }, /* R790 - AIF2DAC Data */ - { 0x0003, 0x0003, 0x0000 }, /* R791 - AIF2ADC Data */ - { 0x0000, 0x0000, 0x0000 }, /* R792 */ - { 0x0000, 0x0000, 0x0000 }, /* R793 */ - { 0x0000, 0x0000, 0x0000 }, /* R794 */ - { 0x0000, 0x0000, 0x0000 }, /* R795 */ - { 0x0000, 0x0000, 0x0000 }, /* R796 */ - { 0x0000, 0x0000, 0x0000 }, /* R797 */ - { 0x0000, 0x0000, 0x0000 }, /* R798 */ - { 0x0000, 0x0000, 0x0000 }, /* R799 */ - { 0x0000, 0x0000, 0x0000 }, /* R800 */ - { 0x0000, 0x0000, 0x0000 }, /* R801 */ - { 0x0000, 0x0000, 0x0000 }, /* R802 */ - { 0x0000, 0x0000, 0x0000 }, /* R803 */ - { 0x0000, 0x0000, 0x0000 }, /* R804 */ - { 0x0000, 0x0000, 0x0000 }, /* R805 */ - { 0x0000, 0x0000, 0x0000 }, /* R806 */ - { 0x0000, 0x0000, 0x0000 }, /* R807 */ - { 0x0000, 0x0000, 0x0000 }, /* R808 */ - { 0x0000, 0x0000, 0x0000 }, /* R809 */ - { 0x0000, 0x0000, 0x0000 }, /* R810 */ - { 0x0000, 0x0000, 0x0000 }, /* R811 */ - { 0x0000, 0x0000, 0x0000 }, /* R812 */ - { 0x0000, 0x0000, 0x0000 }, /* R813 */ - { 0x0000, 0x0000, 0x0000 }, /* R814 */ - { 0x0000, 0x0000, 0x0000 }, /* R815 */ - { 0x0000, 0x0000, 0x0000 }, /* R816 */ - { 0x0000, 0x0000, 0x0000 }, /* R817 */ - { 0x0000, 0x0000, 0x0000 }, /* R818 */ - { 0x0000, 0x0000, 0x0000 }, /* R819 */ - { 0x0000, 0x0000, 0x0000 }, /* R820 */ - { 0x0000, 0x0000, 0x0000 }, /* R821 */ - { 0x0000, 0x0000, 0x0000 }, /* R822 */ - { 0x0000, 0x0000, 0x0000 }, /* R823 */ - { 0x0000, 0x0000, 0x0000 }, /* R824 */ - { 0x0000, 0x0000, 0x0000 }, /* R825 */ - { 0x0000, 0x0000, 0x0000 }, /* R826 */ - { 0x0000, 0x0000, 0x0000 }, /* R827 */ - { 0x0000, 0x0000, 0x0000 }, /* R828 */ - { 0x0000, 0x0000, 0x0000 }, /* R829 */ - { 0x0000, 0x0000, 0x0000 }, /* R830 */ - { 0x0000, 0x0000, 0x0000 }, /* R831 */ - { 0x0000, 0x0000, 0x0000 }, /* R832 */ - { 0x0000, 0x0000, 0x0000 }, /* R833 */ - { 0x0000, 0x0000, 0x0000 }, /* R834 */ - { 0x0000, 0x0000, 0x0000 }, /* R835 */ - { 0x0000, 0x0000, 0x0000 }, /* R836 */ - { 0x0000, 0x0000, 0x0000 }, /* R837 */ - { 0x0000, 0x0000, 0x0000 }, /* R838 */ - { 0x0000, 0x0000, 0x0000 }, /* R839 */ - { 0x0000, 0x0000, 0x0000 }, /* R840 */ - { 0x0000, 0x0000, 0x0000 }, /* R841 */ - { 0x0000, 0x0000, 0x0000 }, /* R842 */ - { 0x0000, 0x0000, 0x0000 }, /* R843 */ - { 0x0000, 0x0000, 0x0000 }, /* R844 */ - { 0x0000, 0x0000, 0x0000 }, /* R845 */ - { 0x0000, 0x0000, 0x0000 }, /* R846 */ - { 0x0000, 0x0000, 0x0000 }, /* R847 */ - { 0x0000, 0x0000, 0x0000 }, /* R848 */ - { 0x0000, 0x0000, 0x0000 }, /* R849 */ - { 0x0000, 0x0000, 0x0000 }, /* R850 */ - { 0x0000, 0x0000, 0x0000 }, /* R851 */ - { 0x0000, 0x0000, 0x0000 }, /* R852 */ - { 0x0000, 0x0000, 0x0000 }, /* R853 */ - { 0x0000, 0x0000, 0x0000 }, /* R854 */ - { 0x0000, 0x0000, 0x0000 }, /* R855 */ - { 0x0000, 0x0000, 0x0000 }, /* R856 */ - { 0x0000, 0x0000, 0x0000 }, /* R857 */ - { 0x0000, 0x0000, 0x0000 }, /* R858 */ - { 0x0000, 0x0000, 0x0000 }, /* R859 */ - { 0x0000, 0x0000, 0x0000 }, /* R860 */ - { 0x0000, 0x0000, 0x0000 }, /* R861 */ - { 0x0000, 0x0000, 0x0000 }, /* R862 */ - { 0x0000, 0x0000, 0x0000 }, /* R863 */ - { 0x0000, 0x0000, 0x0000 }, /* R864 */ - { 0x0000, 0x0000, 0x0000 }, /* R865 */ - { 0x0000, 0x0000, 0x0000 }, /* R866 */ - { 0x0000, 0x0000, 0x0000 }, /* R867 */ - { 0x0000, 0x0000, 0x0000 }, /* R868 */ - { 0x0000, 0x0000, 0x0000 }, /* R869 */ - { 0x0000, 0x0000, 0x0000 }, /* R870 */ - { 0x0000, 0x0000, 0x0000 }, /* R871 */ - { 0x0000, 0x0000, 0x0000 }, /* R872 */ - { 0x0000, 0x0000, 0x0000 }, /* R873 */ - { 0x0000, 0x0000, 0x0000 }, /* R874 */ - { 0x0000, 0x0000, 0x0000 }, /* R875 */ - { 0x0000, 0x0000, 0x0000 }, /* R876 */ - { 0x0000, 0x0000, 0x0000 }, /* R877 */ - { 0x0000, 0x0000, 0x0000 }, /* R878 */ - { 0x0000, 0x0000, 0x0000 }, /* R879 */ - { 0x0000, 0x0000, 0x0000 }, /* R880 */ - { 0x0000, 0x0000, 0x0000 }, /* R881 */ - { 0x0000, 0x0000, 0x0000 }, /* R882 */ - { 0x0000, 0x0000, 0x0000 }, /* R883 */ - { 0x0000, 0x0000, 0x0000 }, /* R884 */ - { 0x0000, 0x0000, 0x0000 }, /* R885 */ - { 0x0000, 0x0000, 0x0000 }, /* R886 */ - { 0x0000, 0x0000, 0x0000 }, /* R887 */ - { 0x0000, 0x0000, 0x0000 }, /* R888 */ - { 0x0000, 0x0000, 0x0000 }, /* R889 */ - { 0x0000, 0x0000, 0x0000 }, /* R890 */ - { 0x0000, 0x0000, 0x0000 }, /* R891 */ - { 0x0000, 0x0000, 0x0000 }, /* R892 */ - { 0x0000, 0x0000, 0x0000 }, /* R893 */ - { 0x0000, 0x0000, 0x0000 }, /* R894 */ - { 0x0000, 0x0000, 0x0000 }, /* R895 */ - { 0x0000, 0x0000, 0x0000 }, /* R896 */ - { 0x0000, 0x0000, 0x0000 }, /* R897 */ - { 0x0000, 0x0000, 0x0000 }, /* R898 */ - { 0x0000, 0x0000, 0x0000 }, /* R899 */ - { 0x0000, 0x0000, 0x0000 }, /* R900 */ - { 0x0000, 0x0000, 0x0000 }, /* R901 */ - { 0x0000, 0x0000, 0x0000 }, /* R902 */ - { 0x0000, 0x0000, 0x0000 }, /* R903 */ - { 0x0000, 0x0000, 0x0000 }, /* R904 */ - { 0x0000, 0x0000, 0x0000 }, /* R905 */ - { 0x0000, 0x0000, 0x0000 }, /* R906 */ - { 0x0000, 0x0000, 0x0000 }, /* R907 */ - { 0x0000, 0x0000, 0x0000 }, /* R908 */ - { 0x0000, 0x0000, 0x0000 }, /* R909 */ - { 0x0000, 0x0000, 0x0000 }, /* R910 */ - { 0x0000, 0x0000, 0x0000 }, /* R911 */ - { 0x0000, 0x0000, 0x0000 }, /* R912 */ - { 0x0000, 0x0000, 0x0000 }, /* R913 */ - { 0x0000, 0x0000, 0x0000 }, /* R914 */ - { 0x0000, 0x0000, 0x0000 }, /* R915 */ - { 0x0000, 0x0000, 0x0000 }, /* R916 */ - { 0x0000, 0x0000, 0x0000 }, /* R917 */ - { 0x0000, 0x0000, 0x0000 }, /* R918 */ - { 0x0000, 0x0000, 0x0000 }, /* R919 */ - { 0x0000, 0x0000, 0x0000 }, /* R920 */ - { 0x0000, 0x0000, 0x0000 }, /* R921 */ - { 0x0000, 0x0000, 0x0000 }, /* R922 */ - { 0x0000, 0x0000, 0x0000 }, /* R923 */ - { 0x0000, 0x0000, 0x0000 }, /* R924 */ - { 0x0000, 0x0000, 0x0000 }, /* R925 */ - { 0x0000, 0x0000, 0x0000 }, /* R926 */ - { 0x0000, 0x0000, 0x0000 }, /* R927 */ - { 0x0000, 0x0000, 0x0000 }, /* R928 */ - { 0x0000, 0x0000, 0x0000 }, /* R929 */ - { 0x0000, 0x0000, 0x0000 }, /* R930 */ - { 0x0000, 0x0000, 0x0000 }, /* R931 */ - { 0x0000, 0x0000, 0x0000 }, /* R932 */ - { 0x0000, 0x0000, 0x0000 }, /* R933 */ - { 0x0000, 0x0000, 0x0000 }, /* R934 */ - { 0x0000, 0x0000, 0x0000 }, /* R935 */ - { 0x0000, 0x0000, 0x0000 }, /* R936 */ - { 0x0000, 0x0000, 0x0000 }, /* R937 */ - { 0x0000, 0x0000, 0x0000 }, /* R938 */ - { 0x0000, 0x0000, 0x0000 }, /* R939 */ - { 0x0000, 0x0000, 0x0000 }, /* R940 */ - { 0x0000, 0x0000, 0x0000 }, /* R941 */ - { 0x0000, 0x0000, 0x0000 }, /* R942 */ - { 0x0000, 0x0000, 0x0000 }, /* R943 */ - { 0x0000, 0x0000, 0x0000 }, /* R944 */ - { 0x0000, 0x0000, 0x0000 }, /* R945 */ - { 0x0000, 0x0000, 0x0000 }, /* R946 */ - { 0x0000, 0x0000, 0x0000 }, /* R947 */ - { 0x0000, 0x0000, 0x0000 }, /* R948 */ - { 0x0000, 0x0000, 0x0000 }, /* R949 */ - { 0x0000, 0x0000, 0x0000 }, /* R950 */ - { 0x0000, 0x0000, 0x0000 }, /* R951 */ - { 0x0000, 0x0000, 0x0000 }, /* R952 */ - { 0x0000, 0x0000, 0x0000 }, /* R953 */ - { 0x0000, 0x0000, 0x0000 }, /* R954 */ - { 0x0000, 0x0000, 0x0000 }, /* R955 */ - { 0x0000, 0x0000, 0x0000 }, /* R956 */ - { 0x0000, 0x0000, 0x0000 }, /* R957 */ - { 0x0000, 0x0000, 0x0000 }, /* R958 */ - { 0x0000, 0x0000, 0x0000 }, /* R959 */ - { 0x0000, 0x0000, 0x0000 }, /* R960 */ - { 0x0000, 0x0000, 0x0000 }, /* R961 */ - { 0x0000, 0x0000, 0x0000 }, /* R962 */ - { 0x0000, 0x0000, 0x0000 }, /* R963 */ - { 0x0000, 0x0000, 0x0000 }, /* R964 */ - { 0x0000, 0x0000, 0x0000 }, /* R965 */ - { 0x0000, 0x0000, 0x0000 }, /* R966 */ - { 0x0000, 0x0000, 0x0000 }, /* R967 */ - { 0x0000, 0x0000, 0x0000 }, /* R968 */ - { 0x0000, 0x0000, 0x0000 }, /* R969 */ - { 0x0000, 0x0000, 0x0000 }, /* R970 */ - { 0x0000, 0x0000, 0x0000 }, /* R971 */ - { 0x0000, 0x0000, 0x0000 }, /* R972 */ - { 0x0000, 0x0000, 0x0000 }, /* R973 */ - { 0x0000, 0x0000, 0x0000 }, /* R974 */ - { 0x0000, 0x0000, 0x0000 }, /* R975 */ - { 0x0000, 0x0000, 0x0000 }, /* R976 */ - { 0x0000, 0x0000, 0x0000 }, /* R977 */ - { 0x0000, 0x0000, 0x0000 }, /* R978 */ - { 0x0000, 0x0000, 0x0000 }, /* R979 */ - { 0x0000, 0x0000, 0x0000 }, /* R980 */ - { 0x0000, 0x0000, 0x0000 }, /* R981 */ - { 0x0000, 0x0000, 0x0000 }, /* R982 */ - { 0x0000, 0x0000, 0x0000 }, /* R983 */ - { 0x0000, 0x0000, 0x0000 }, /* R984 */ - { 0x0000, 0x0000, 0x0000 }, /* R985 */ - { 0x0000, 0x0000, 0x0000 }, /* R986 */ - { 0x0000, 0x0000, 0x0000 }, /* R987 */ - { 0x0000, 0x0000, 0x0000 }, /* R988 */ - { 0x0000, 0x0000, 0x0000 }, /* R989 */ - { 0x0000, 0x0000, 0x0000 }, /* R990 */ - { 0x0000, 0x0000, 0x0000 }, /* R991 */ - { 0x0000, 0x0000, 0x0000 }, /* R992 */ - { 0x0000, 0x0000, 0x0000 }, /* R993 */ - { 0x0000, 0x0000, 0x0000 }, /* R994 */ - { 0x0000, 0x0000, 0x0000 }, /* R995 */ - { 0x0000, 0x0000, 0x0000 }, /* R996 */ - { 0x0000, 0x0000, 0x0000 }, /* R997 */ - { 0x0000, 0x0000, 0x0000 }, /* R998 */ - { 0x0000, 0x0000, 0x0000 }, /* R999 */ - { 0x0000, 0x0000, 0x0000 }, /* R1000 */ - { 0x0000, 0x0000, 0x0000 }, /* R1001 */ - { 0x0000, 0x0000, 0x0000 }, /* R1002 */ - { 0x0000, 0x0000, 0x0000 }, /* R1003 */ - { 0x0000, 0x0000, 0x0000 }, /* R1004 */ - { 0x0000, 0x0000, 0x0000 }, /* R1005 */ - { 0x0000, 0x0000, 0x0000 }, /* R1006 */ - { 0x0000, 0x0000, 0x0000 }, /* R1007 */ - { 0x0000, 0x0000, 0x0000 }, /* R1008 */ - { 0x0000, 0x0000, 0x0000 }, /* R1009 */ - { 0x0000, 0x0000, 0x0000 }, /* R1010 */ - { 0x0000, 0x0000, 0x0000 }, /* R1011 */ - { 0x0000, 0x0000, 0x0000 }, /* R1012 */ - { 0x0000, 0x0000, 0x0000 }, /* R1013 */ - { 0x0000, 0x0000, 0x0000 }, /* R1014 */ - { 0x0000, 0x0000, 0x0000 }, /* R1015 */ - { 0x0000, 0x0000, 0x0000 }, /* R1016 */ - { 0x0000, 0x0000, 0x0000 }, /* R1017 */ - { 0x0000, 0x0000, 0x0000 }, /* R1018 */ - { 0x0000, 0x0000, 0x0000 }, /* R1019 */ - { 0x0000, 0x0000, 0x0000 }, /* R1020 */ - { 0x0000, 0x0000, 0x0000 }, /* R1021 */ - { 0x0000, 0x0000, 0x0000 }, /* R1022 */ - { 0x0000, 0x0000, 0x0000 }, /* R1023 */ - { 0x00FF, 0x01FF, 0x0000 }, /* R1024 - AIF1 ADC1 Left Volume */ - { 0x00FF, 0x01FF, 0x0000 }, /* R1025 - AIF1 ADC1 Right Volume */ - { 0x00FF, 0x01FF, 0x0000 }, /* R1026 - AIF1 DAC1 Left Volume */ - { 0x00FF, 0x01FF, 0x0000 }, /* R1027 - AIF1 DAC1 Right Volume */ - { 0x00FF, 0x01FF, 0x0000 }, /* R1028 - AIF1 ADC2 Left Volume */ - { 0x00FF, 0x01FF, 0x0000 }, /* R1029 - AIF1 ADC2 Right Volume */ - { 0x00FF, 0x01FF, 0x0000 }, /* R1030 - AIF1 DAC2 Left Volume */ - { 0x00FF, 0x01FF, 0x0000 }, /* R1031 - AIF1 DAC2 Right Volume */ - { 0x0000, 0x0000, 0x0000 }, /* R1032 */ - { 0x0000, 0x0000, 0x0000 }, /* R1033 */ - { 0x0000, 0x0000, 0x0000 }, /* R1034 */ - { 0x0000, 0x0000, 0x0000 }, /* R1035 */ - { 0x0000, 0x0000, 0x0000 }, /* R1036 */ - { 0x0000, 0x0000, 0x0000 }, /* R1037 */ - { 0x0000, 0x0000, 0x0000 }, /* R1038 */ - { 0x0000, 0x0000, 0x0000 }, /* R1039 */ - { 0xF800, 0xF800, 0x0000 }, /* R1040 - AIF1 ADC1 Filters */ - { 0x7800, 0x7800, 0x0000 }, /* R1041 - AIF1 ADC2 Filters */ - { 0x0000, 0x0000, 0x0000 }, /* R1042 */ - { 0x0000, 0x0000, 0x0000 }, /* R1043 */ - { 0x0000, 0x0000, 0x0000 }, /* R1044 */ - { 0x0000, 0x0000, 0x0000 }, /* R1045 */ - { 0x0000, 0x0000, 0x0000 }, /* R1046 */ - { 0x0000, 0x0000, 0x0000 }, /* R1047 */ - { 0x0000, 0x0000, 0x0000 }, /* R1048 */ - { 0x0000, 0x0000, 0x0000 }, /* R1049 */ - { 0x0000, 0x0000, 0x0000 }, /* R1050 */ - { 0x0000, 0x0000, 0x0000 }, /* R1051 */ - { 0x0000, 0x0000, 0x0000 }, /* R1052 */ - { 0x0000, 0x0000, 0x0000 }, /* R1053 */ - { 0x0000, 0x0000, 0x0000 }, /* R1054 */ - { 0x0000, 0x0000, 0x0000 }, /* R1055 */ - { 0x02B6, 0x02B6, 0x0000 }, /* R1056 - AIF1 DAC1 Filters (1) */ - { 0x3F00, 0x3F00, 0x0000 }, /* R1057 - AIF1 DAC1 Filters (2) */ - { 0x02B6, 0x02B6, 0x0000 }, /* R1058 - AIF1 DAC2 Filters (1) */ - { 0x3F00, 0x3F00, 0x0000 }, /* R1059 - AIF1 DAC2 Filters (2) */ - { 0x0000, 0x0000, 0x0000 }, /* R1060 */ - { 0x0000, 0x0000, 0x0000 }, /* R1061 */ - { 0x0000, 0x0000, 0x0000 }, /* R1062 */ - { 0x0000, 0x0000, 0x0000 }, /* R1063 */ - { 0x0000, 0x0000, 0x0000 }, /* R1064 */ - { 0x0000, 0x0000, 0x0000 }, /* R1065 */ - { 0x0000, 0x0000, 0x0000 }, /* R1066 */ - { 0x0000, 0x0000, 0x0000 }, /* R1067 */ - { 0x0000, 0x0000, 0x0000 }, /* R1068 */ - { 0x0000, 0x0000, 0x0000 }, /* R1069 */ - { 0x0000, 0x0000, 0x0000 }, /* R1070 */ - { 0x0000, 0x0000, 0x0000 }, /* R1071 */ - { 0x0000, 0x0000, 0x0000 }, /* R1072 */ - { 0x0000, 0x0000, 0x0000 }, /* R1073 */ - { 0x0000, 0x0000, 0x0000 }, /* R1074 */ - { 0x0000, 0x0000, 0x0000 }, /* R1075 */ - { 0x0000, 0x0000, 0x0000 }, /* R1076 */ - { 0x0000, 0x0000, 0x0000 }, /* R1077 */ - { 0x0000, 0x0000, 0x0000 }, /* R1078 */ - { 0x0000, 0x0000, 0x0000 }, /* R1079 */ - { 0x0000, 0x0000, 0x0000 }, /* R1080 */ - { 0x0000, 0x0000, 0x0000 }, /* R1081 */ - { 0x0000, 0x0000, 0x0000 }, /* R1082 */ - { 0x0000, 0x0000, 0x0000 }, /* R1083 */ - { 0x0000, 0x0000, 0x0000 }, /* R1084 */ - { 0x0000, 0x0000, 0x0000 }, /* R1085 */ - { 0x0000, 0x0000, 0x0000 }, /* R1086 */ - { 0x0000, 0x0000, 0x0000 }, /* R1087 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1088 - AIF1 DRC1 (1) */ - { 0x1FFF, 0x1FFF, 0x0000 }, /* R1089 - AIF1 DRC1 (2) */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1090 - AIF1 DRC1 (3) */ - { 0x07FF, 0x07FF, 0x0000 }, /* R1091 - AIF1 DRC1 (4) */ - { 0x03FF, 0x03FF, 0x0000 }, /* R1092 - AIF1 DRC1 (5) */ - { 0x0000, 0x0000, 0x0000 }, /* R1093 */ - { 0x0000, 0x0000, 0x0000 }, /* R1094 */ - { 0x0000, 0x0000, 0x0000 }, /* R1095 */ - { 0x0000, 0x0000, 0x0000 }, /* R1096 */ - { 0x0000, 0x0000, 0x0000 }, /* R1097 */ - { 0x0000, 0x0000, 0x0000 }, /* R1098 */ - { 0x0000, 0x0000, 0x0000 }, /* R1099 */ - { 0x0000, 0x0000, 0x0000 }, /* R1100 */ - { 0x0000, 0x0000, 0x0000 }, /* R1101 */ - { 0x0000, 0x0000, 0x0000 }, /* R1102 */ - { 0x0000, 0x0000, 0x0000 }, /* R1103 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1104 - AIF1 DRC2 (1) */ - { 0x1FFF, 0x1FFF, 0x0000 }, /* R1105 - AIF1 DRC2 (2) */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1106 - AIF1 DRC2 (3) */ - { 0x07FF, 0x07FF, 0x0000 }, /* R1107 - AIF1 DRC2 (4) */ - { 0x03FF, 0x03FF, 0x0000 }, /* R1108 - AIF1 DRC2 (5) */ - { 0x0000, 0x0000, 0x0000 }, /* R1109 */ - { 0x0000, 0x0000, 0x0000 }, /* R1110 */ - { 0x0000, 0x0000, 0x0000 }, /* R1111 */ - { 0x0000, 0x0000, 0x0000 }, /* R1112 */ - { 0x0000, 0x0000, 0x0000 }, /* R1113 */ - { 0x0000, 0x0000, 0x0000 }, /* R1114 */ - { 0x0000, 0x0000, 0x0000 }, /* R1115 */ - { 0x0000, 0x0000, 0x0000 }, /* R1116 */ - { 0x0000, 0x0000, 0x0000 }, /* R1117 */ - { 0x0000, 0x0000, 0x0000 }, /* R1118 */ - { 0x0000, 0x0000, 0x0000 }, /* R1119 */ - { 0x0000, 0x0000, 0x0000 }, /* R1120 */ - { 0x0000, 0x0000, 0x0000 }, /* R1121 */ - { 0x0000, 0x0000, 0x0000 }, /* R1122 */ - { 0x0000, 0x0000, 0x0000 }, /* R1123 */ - { 0x0000, 0x0000, 0x0000 }, /* R1124 */ - { 0x0000, 0x0000, 0x0000 }, /* R1125 */ - { 0x0000, 0x0000, 0x0000 }, /* R1126 */ - { 0x0000, 0x0000, 0x0000 }, /* R1127 */ - { 0x0000, 0x0000, 0x0000 }, /* R1128 */ - { 0x0000, 0x0000, 0x0000 }, /* R1129 */ - { 0x0000, 0x0000, 0x0000 }, /* R1130 */ - { 0x0000, 0x0000, 0x0000 }, /* R1131 */ - { 0x0000, 0x0000, 0x0000 }, /* R1132 */ - { 0x0000, 0x0000, 0x0000 }, /* R1133 */ - { 0x0000, 0x0000, 0x0000 }, /* R1134 */ - { 0x0000, 0x0000, 0x0000 }, /* R1135 */ - { 0x0000, 0x0000, 0x0000 }, /* R1136 */ - { 0x0000, 0x0000, 0x0000 }, /* R1137 */ - { 0x0000, 0x0000, 0x0000 }, /* R1138 */ - { 0x0000, 0x0000, 0x0000 }, /* R1139 */ - { 0x0000, 0x0000, 0x0000 }, /* R1140 */ - { 0x0000, 0x0000, 0x0000 }, /* R1141 */ - { 0x0000, 0x0000, 0x0000 }, /* R1142 */ - { 0x0000, 0x0000, 0x0000 }, /* R1143 */ - { 0x0000, 0x0000, 0x0000 }, /* R1144 */ - { 0x0000, 0x0000, 0x0000 }, /* R1145 */ - { 0x0000, 0x0000, 0x0000 }, /* R1146 */ - { 0x0000, 0x0000, 0x0000 }, /* R1147 */ - { 0x0000, 0x0000, 0x0000 }, /* R1148 */ - { 0x0000, 0x0000, 0x0000 }, /* R1149 */ - { 0x0000, 0x0000, 0x0000 }, /* R1150 */ - { 0x0000, 0x0000, 0x0000 }, /* R1151 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1152 - AIF1 DAC1 EQ Gains (1) */ - { 0xFFC0, 0xFFC0, 0x0000 }, /* R1153 - AIF1 DAC1 EQ Gains (2) */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1154 - AIF1 DAC1 EQ Band 1 A */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1155 - AIF1 DAC1 EQ Band 1 B */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1156 - AIF1 DAC1 EQ Band 1 PG */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1157 - AIF1 DAC1 EQ Band 2 A */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1158 - AIF1 DAC1 EQ Band 2 B */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1159 - AIF1 DAC1 EQ Band 2 C */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1160 - AIF1 DAC1 EQ Band 2 PG */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1161 - AIF1 DAC1 EQ Band 3 A */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1162 - AIF1 DAC1 EQ Band 3 B */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1163 - AIF1 DAC1 EQ Band 3 C */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1164 - AIF1 DAC1 EQ Band 3 PG */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1165 - AIF1 DAC1 EQ Band 4 A */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1166 - AIF1 DAC1 EQ Band 4 B */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1167 - AIF1 DAC1 EQ Band 4 C */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1168 - AIF1 DAC1 EQ Band 4 PG */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1169 - AIF1 DAC1 EQ Band 5 A */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1170 - AIF1 DAC1 EQ Band 5 B */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1171 - AIF1 DAC1 EQ Band 5 PG */ - { 0x0000, 0x0000, 0x0000 }, /* R1172 */ - { 0x0000, 0x0000, 0x0000 }, /* R1173 */ - { 0x0000, 0x0000, 0x0000 }, /* R1174 */ - { 0x0000, 0x0000, 0x0000 }, /* R1175 */ - { 0x0000, 0x0000, 0x0000 }, /* R1176 */ - { 0x0000, 0x0000, 0x0000 }, /* R1177 */ - { 0x0000, 0x0000, 0x0000 }, /* R1178 */ - { 0x0000, 0x0000, 0x0000 }, /* R1179 */ - { 0x0000, 0x0000, 0x0000 }, /* R1180 */ - { 0x0000, 0x0000, 0x0000 }, /* R1181 */ - { 0x0000, 0x0000, 0x0000 }, /* R1182 */ - { 0x0000, 0x0000, 0x0000 }, /* R1183 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1184 - AIF1 DAC2 EQ Gains (1) */ - { 0xFFC0, 0xFFC0, 0x0000 }, /* R1185 - AIF1 DAC2 EQ Gains (2) */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1186 - AIF1 DAC2 EQ Band 1 A */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1187 - AIF1 DAC2 EQ Band 1 B */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1188 - AIF1 DAC2 EQ Band 1 PG */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1189 - AIF1 DAC2 EQ Band 2 A */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1190 - AIF1 DAC2 EQ Band 2 B */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1191 - AIF1 DAC2 EQ Band 2 C */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1192 - AIF1 DAC2 EQ Band 2 PG */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1193 - AIF1 DAC2 EQ Band 3 A */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1194 - AIF1 DAC2 EQ Band 3 B */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1195 - AIF1 DAC2 EQ Band 3 C */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1196 - AIF1 DAC2 EQ Band 3 PG */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1197 - AIF1 DAC2 EQ Band 4 A */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1198 - AIF1 DAC2 EQ Band 4 B */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1199 - AIF1 DAC2 EQ Band 4 C */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1200 - AIF1 DAC2 EQ Band 4 PG */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1201 - AIF1 DAC2 EQ Band 5 A */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1202 - AIF1 DAC2 EQ Band 5 B */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1203 - AIF1 DAC2 EQ Band 5 PG */ - { 0x0000, 0x0000, 0x0000 }, /* R1204 */ - { 0x0000, 0x0000, 0x0000 }, /* R1205 */ - { 0x0000, 0x0000, 0x0000 }, /* R1206 */ - { 0x0000, 0x0000, 0x0000 }, /* R1207 */ - { 0x0000, 0x0000, 0x0000 }, /* R1208 */ - { 0x0000, 0x0000, 0x0000 }, /* R1209 */ - { 0x0000, 0x0000, 0x0000 }, /* R1210 */ - { 0x0000, 0x0000, 0x0000 }, /* R1211 */ - { 0x0000, 0x0000, 0x0000 }, /* R1212 */ - { 0x0000, 0x0000, 0x0000 }, /* R1213 */ - { 0x0000, 0x0000, 0x0000 }, /* R1214 */ - { 0x0000, 0x0000, 0x0000 }, /* R1215 */ - { 0x0000, 0x0000, 0x0000 }, /* R1216 */ - { 0x0000, 0x0000, 0x0000 }, /* R1217 */ - { 0x0000, 0x0000, 0x0000 }, /* R1218 */ - { 0x0000, 0x0000, 0x0000 }, /* R1219 */ - { 0x0000, 0x0000, 0x0000 }, /* R1220 */ - { 0x0000, 0x0000, 0x0000 }, /* R1221 */ - { 0x0000, 0x0000, 0x0000 }, /* R1222 */ - { 0x0000, 0x0000, 0x0000 }, /* R1223 */ - { 0x0000, 0x0000, 0x0000 }, /* R1224 */ - { 0x0000, 0x0000, 0x0000 }, /* R1225 */ - { 0x0000, 0x0000, 0x0000 }, /* R1226 */ - { 0x0000, 0x0000, 0x0000 }, /* R1227 */ - { 0x0000, 0x0000, 0x0000 }, /* R1228 */ - { 0x0000, 0x0000, 0x0000 }, /* R1229 */ - { 0x0000, 0x0000, 0x0000 }, /* R1230 */ - { 0x0000, 0x0000, 0x0000 }, /* R1231 */ - { 0x0000, 0x0000, 0x0000 }, /* R1232 */ - { 0x0000, 0x0000, 0x0000 }, /* R1233 */ - { 0x0000, 0x0000, 0x0000 }, /* R1234 */ - { 0x0000, 0x0000, 0x0000 }, /* R1235 */ - { 0x0000, 0x0000, 0x0000 }, /* R1236 */ - { 0x0000, 0x0000, 0x0000 }, /* R1237 */ - { 0x0000, 0x0000, 0x0000 }, /* R1238 */ - { 0x0000, 0x0000, 0x0000 }, /* R1239 */ - { 0x0000, 0x0000, 0x0000 }, /* R1240 */ - { 0x0000, 0x0000, 0x0000 }, /* R1241 */ - { 0x0000, 0x0000, 0x0000 }, /* R1242 */ - { 0x0000, 0x0000, 0x0000 }, /* R1243 */ - { 0x0000, 0x0000, 0x0000 }, /* R1244 */ - { 0x0000, 0x0000, 0x0000 }, /* R1245 */ - { 0x0000, 0x0000, 0x0000 }, /* R1246 */ - { 0x0000, 0x0000, 0x0000 }, /* R1247 */ - { 0x0000, 0x0000, 0x0000 }, /* R1248 */ - { 0x0000, 0x0000, 0x0000 }, /* R1249 */ - { 0x0000, 0x0000, 0x0000 }, /* R1250 */ - { 0x0000, 0x0000, 0x0000 }, /* R1251 */ - { 0x0000, 0x0000, 0x0000 }, /* R1252 */ - { 0x0000, 0x0000, 0x0000 }, /* R1253 */ - { 0x0000, 0x0000, 0x0000 }, /* R1254 */ - { 0x0000, 0x0000, 0x0000 }, /* R1255 */ - { 0x0000, 0x0000, 0x0000 }, /* R1256 */ - { 0x0000, 0x0000, 0x0000 }, /* R1257 */ - { 0x0000, 0x0000, 0x0000 }, /* R1258 */ - { 0x0000, 0x0000, 0x0000 }, /* R1259 */ - { 0x0000, 0x0000, 0x0000 }, /* R1260 */ - { 0x0000, 0x0000, 0x0000 }, /* R1261 */ - { 0x0000, 0x0000, 0x0000 }, /* R1262 */ - { 0x0000, 0x0000, 0x0000 }, /* R1263 */ - { 0x0000, 0x0000, 0x0000 }, /* R1264 */ - { 0x0000, 0x0000, 0x0000 }, /* R1265 */ - { 0x0000, 0x0000, 0x0000 }, /* R1266 */ - { 0x0000, 0x0000, 0x0000 }, /* R1267 */ - { 0x0000, 0x0000, 0x0000 }, /* R1268 */ - { 0x0000, 0x0000, 0x0000 }, /* R1269 */ - { 0x0000, 0x0000, 0x0000 }, /* R1270 */ - { 0x0000, 0x0000, 0x0000 }, /* R1271 */ - { 0x0000, 0x0000, 0x0000 }, /* R1272 */ - { 0x0000, 0x0000, 0x0000 }, /* R1273 */ - { 0x0000, 0x0000, 0x0000 }, /* R1274 */ - { 0x0000, 0x0000, 0x0000 }, /* R1275 */ - { 0x0000, 0x0000, 0x0000 }, /* R1276 */ - { 0x0000, 0x0000, 0x0000 }, /* R1277 */ - { 0x0000, 0x0000, 0x0000 }, /* R1278 */ - { 0x0000, 0x0000, 0x0000 }, /* R1279 */ - { 0x00FF, 0x01FF, 0x0000 }, /* R1280 - AIF2 ADC Left Volume */ - { 0x00FF, 0x01FF, 0x0000 }, /* R1281 - AIF2 ADC Right Volume */ - { 0x00FF, 0x01FF, 0x0000 }, /* R1282 - AIF2 DAC Left Volume */ - { 0x00FF, 0x01FF, 0x0000 }, /* R1283 - AIF2 DAC Right Volume */ - { 0x0000, 0x0000, 0x0000 }, /* R1284 */ - { 0x0000, 0x0000, 0x0000 }, /* R1285 */ - { 0x0000, 0x0000, 0x0000 }, /* R1286 */ - { 0x0000, 0x0000, 0x0000 }, /* R1287 */ - { 0x0000, 0x0000, 0x0000 }, /* R1288 */ - { 0x0000, 0x0000, 0x0000 }, /* R1289 */ - { 0x0000, 0x0000, 0x0000 }, /* R1290 */ - { 0x0000, 0x0000, 0x0000 }, /* R1291 */ - { 0x0000, 0x0000, 0x0000 }, /* R1292 */ - { 0x0000, 0x0000, 0x0000 }, /* R1293 */ - { 0x0000, 0x0000, 0x0000 }, /* R1294 */ - { 0x0000, 0x0000, 0x0000 }, /* R1295 */ - { 0xF800, 0xF800, 0x0000 }, /* R1296 - AIF2 ADC Filters */ - { 0x0000, 0x0000, 0x0000 }, /* R1297 */ - { 0x0000, 0x0000, 0x0000 }, /* R1298 */ - { 0x0000, 0x0000, 0x0000 }, /* R1299 */ - { 0x0000, 0x0000, 0x0000 }, /* R1300 */ - { 0x0000, 0x0000, 0x0000 }, /* R1301 */ - { 0x0000, 0x0000, 0x0000 }, /* R1302 */ - { 0x0000, 0x0000, 0x0000 }, /* R1303 */ - { 0x0000, 0x0000, 0x0000 }, /* R1304 */ - { 0x0000, 0x0000, 0x0000 }, /* R1305 */ - { 0x0000, 0x0000, 0x0000 }, /* R1306 */ - { 0x0000, 0x0000, 0x0000 }, /* R1307 */ - { 0x0000, 0x0000, 0x0000 }, /* R1308 */ - { 0x0000, 0x0000, 0x0000 }, /* R1309 */ - { 0x0000, 0x0000, 0x0000 }, /* R1310 */ - { 0x0000, 0x0000, 0x0000 }, /* R1311 */ - { 0x02B6, 0x02B6, 0x0000 }, /* R1312 - AIF2 DAC Filters (1) */ - { 0x3F00, 0x3F00, 0x0000 }, /* R1313 - AIF2 DAC Filters (2) */ - { 0x0000, 0x0000, 0x0000 }, /* R1314 */ - { 0x0000, 0x0000, 0x0000 }, /* R1315 */ - { 0x0000, 0x0000, 0x0000 }, /* R1316 */ - { 0x0000, 0x0000, 0x0000 }, /* R1317 */ - { 0x0000, 0x0000, 0x0000 }, /* R1318 */ - { 0x0000, 0x0000, 0x0000 }, /* R1319 */ - { 0x0000, 0x0000, 0x0000 }, /* R1320 */ - { 0x0000, 0x0000, 0x0000 }, /* R1321 */ - { 0x0000, 0x0000, 0x0000 }, /* R1322 */ - { 0x0000, 0x0000, 0x0000 }, /* R1323 */ - { 0x0000, 0x0000, 0x0000 }, /* R1324 */ - { 0x0000, 0x0000, 0x0000 }, /* R1325 */ - { 0x0000, 0x0000, 0x0000 }, /* R1326 */ - { 0x0000, 0x0000, 0x0000 }, /* R1327 */ - { 0x0000, 0x0000, 0x0000 }, /* R1328 */ - { 0x0000, 0x0000, 0x0000 }, /* R1329 */ - { 0x0000, 0x0000, 0x0000 }, /* R1330 */ - { 0x0000, 0x0000, 0x0000 }, /* R1331 */ - { 0x0000, 0x0000, 0x0000 }, /* R1332 */ - { 0x0000, 0x0000, 0x0000 }, /* R1333 */ - { 0x0000, 0x0000, 0x0000 }, /* R1334 */ - { 0x0000, 0x0000, 0x0000 }, /* R1335 */ - { 0x0000, 0x0000, 0x0000 }, /* R1336 */ - { 0x0000, 0x0000, 0x0000 }, /* R1337 */ - { 0x0000, 0x0000, 0x0000 }, /* R1338 */ - { 0x0000, 0x0000, 0x0000 }, /* R1339 */ - { 0x0000, 0x0000, 0x0000 }, /* R1340 */ - { 0x0000, 0x0000, 0x0000 }, /* R1341 */ - { 0x0000, 0x0000, 0x0000 }, /* R1342 */ - { 0x0000, 0x0000, 0x0000 }, /* R1343 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1344 - AIF2 DRC (1) */ - { 0x1FFF, 0x1FFF, 0x0000 }, /* R1345 - AIF2 DRC (2) */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1346 - AIF2 DRC (3) */ - { 0x07FF, 0x07FF, 0x0000 }, /* R1347 - AIF2 DRC (4) */ - { 0x03FF, 0x03FF, 0x0000 }, /* R1348 - AIF2 DRC (5) */ - { 0x0000, 0x0000, 0x0000 }, /* R1349 */ - { 0x0000, 0x0000, 0x0000 }, /* R1350 */ - { 0x0000, 0x0000, 0x0000 }, /* R1351 */ - { 0x0000, 0x0000, 0x0000 }, /* R1352 */ - { 0x0000, 0x0000, 0x0000 }, /* R1353 */ - { 0x0000, 0x0000, 0x0000 }, /* R1354 */ - { 0x0000, 0x0000, 0x0000 }, /* R1355 */ - { 0x0000, 0x0000, 0x0000 }, /* R1356 */ - { 0x0000, 0x0000, 0x0000 }, /* R1357 */ - { 0x0000, 0x0000, 0x0000 }, /* R1358 */ - { 0x0000, 0x0000, 0x0000 }, /* R1359 */ - { 0x0000, 0x0000, 0x0000 }, /* R1360 */ - { 0x0000, 0x0000, 0x0000 }, /* R1361 */ - { 0x0000, 0x0000, 0x0000 }, /* R1362 */ - { 0x0000, 0x0000, 0x0000 }, /* R1363 */ - { 0x0000, 0x0000, 0x0000 }, /* R1364 */ - { 0x0000, 0x0000, 0x0000 }, /* R1365 */ - { 0x0000, 0x0000, 0x0000 }, /* R1366 */ - { 0x0000, 0x0000, 0x0000 }, /* R1367 */ - { 0x0000, 0x0000, 0x0000 }, /* R1368 */ - { 0x0000, 0x0000, 0x0000 }, /* R1369 */ - { 0x0000, 0x0000, 0x0000 }, /* R1370 */ - { 0x0000, 0x0000, 0x0000 }, /* R1371 */ - { 0x0000, 0x0000, 0x0000 }, /* R1372 */ - { 0x0000, 0x0000, 0x0000 }, /* R1373 */ - { 0x0000, 0x0000, 0x0000 }, /* R1374 */ - { 0x0000, 0x0000, 0x0000 }, /* R1375 */ - { 0x0000, 0x0000, 0x0000 }, /* R1376 */ - { 0x0000, 0x0000, 0x0000 }, /* R1377 */ - { 0x0000, 0x0000, 0x0000 }, /* R1378 */ - { 0x0000, 0x0000, 0x0000 }, /* R1379 */ - { 0x0000, 0x0000, 0x0000 }, /* R1380 */ - { 0x0000, 0x0000, 0x0000 }, /* R1381 */ - { 0x0000, 0x0000, 0x0000 }, /* R1382 */ - { 0x0000, 0x0000, 0x0000 }, /* R1383 */ - { 0x0000, 0x0000, 0x0000 }, /* R1384 */ - { 0x0000, 0x0000, 0x0000 }, /* R1385 */ - { 0x0000, 0x0000, 0x0000 }, /* R1386 */ - { 0x0000, 0x0000, 0x0000 }, /* R1387 */ - { 0x0000, 0x0000, 0x0000 }, /* R1388 */ - { 0x0000, 0x0000, 0x0000 }, /* R1389 */ - { 0x0000, 0x0000, 0x0000 }, /* R1390 */ - { 0x0000, 0x0000, 0x0000 }, /* R1391 */ - { 0x0000, 0x0000, 0x0000 }, /* R1392 */ - { 0x0000, 0x0000, 0x0000 }, /* R1393 */ - { 0x0000, 0x0000, 0x0000 }, /* R1394 */ - { 0x0000, 0x0000, 0x0000 }, /* R1395 */ - { 0x0000, 0x0000, 0x0000 }, /* R1396 */ - { 0x0000, 0x0000, 0x0000 }, /* R1397 */ - { 0x0000, 0x0000, 0x0000 }, /* R1398 */ - { 0x0000, 0x0000, 0x0000 }, /* R1399 */ - { 0x0000, 0x0000, 0x0000 }, /* R1400 */ - { 0x0000, 0x0000, 0x0000 }, /* R1401 */ - { 0x0000, 0x0000, 0x0000 }, /* R1402 */ - { 0x0000, 0x0000, 0x0000 }, /* R1403 */ - { 0x0000, 0x0000, 0x0000 }, /* R1404 */ - { 0x0000, 0x0000, 0x0000 }, /* R1405 */ - { 0x0000, 0x0000, 0x0000 }, /* R1406 */ - { 0x0000, 0x0000, 0x0000 }, /* R1407 */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1408 - AIF2 EQ Gains (1) */ - { 0xFFC0, 0xFFC0, 0x0000 }, /* R1409 - AIF2 EQ Gains (2) */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1410 - AIF2 EQ Band 1 A */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1411 - AIF2 EQ Band 1 B */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1412 - AIF2 EQ Band 1 PG */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1413 - AIF2 EQ Band 2 A */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1414 - AIF2 EQ Band 2 B */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1415 - AIF2 EQ Band 2 C */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1416 - AIF2 EQ Band 2 PG */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1417 - AIF2 EQ Band 3 A */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1418 - AIF2 EQ Band 3 B */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1419 - AIF2 EQ Band 3 C */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1420 - AIF2 EQ Band 3 PG */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1421 - AIF2 EQ Band 4 A */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1422 - AIF2 EQ Band 4 B */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1423 - AIF2 EQ Band 4 C */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1424 - AIF2 EQ Band 4 PG */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1425 - AIF2 EQ Band 5 A */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1426 - AIF2 EQ Band 5 B */ - { 0xFFFF, 0xFFFF, 0x0000 }, /* R1427 - AIF2 EQ Band 5 PG */ - { 0x0000, 0x0000, 0x0000 }, /* R1428 */ - { 0x0000, 0x0000, 0x0000 }, /* R1429 */ - { 0x0000, 0x0000, 0x0000 }, /* R1430 */ - { 0x0000, 0x0000, 0x0000 }, /* R1431 */ - { 0x0000, 0x0000, 0x0000 }, /* R1432 */ - { 0x0000, 0x0000, 0x0000 }, /* R1433 */ - { 0x0000, 0x0000, 0x0000 }, /* R1434 */ - { 0x0000, 0x0000, 0x0000 }, /* R1435 */ - { 0x0000, 0x0000, 0x0000 }, /* R1436 */ - { 0x0000, 0x0000, 0x0000 }, /* R1437 */ - { 0x0000, 0x0000, 0x0000 }, /* R1438 */ - { 0x0000, 0x0000, 0x0000 }, /* R1439 */ - { 0x0000, 0x0000, 0x0000 }, /* R1440 */ - { 0x0000, 0x0000, 0x0000 }, /* R1441 */ - { 0x0000, 0x0000, 0x0000 }, /* R1442 */ - { 0x0000, 0x0000, 0x0000 }, /* R1443 */ - { 0x0000, 0x0000, 0x0000 }, /* R1444 */ - { 0x0000, 0x0000, 0x0000 }, /* R1445 */ - { 0x0000, 0x0000, 0x0000 }, /* R1446 */ - { 0x0000, 0x0000, 0x0000 }, /* R1447 */ - { 0x0000, 0x0000, 0x0000 }, /* R1448 */ - { 0x0000, 0x0000, 0x0000 }, /* R1449 */ - { 0x0000, 0x0000, 0x0000 }, /* R1450 */ - { 0x0000, 0x0000, 0x0000 }, /* R1451 */ - { 0x0000, 0x0000, 0x0000 }, /* R1452 */ - { 0x0000, 0x0000, 0x0000 }, /* R1453 */ - { 0x0000, 0x0000, 0x0000 }, /* R1454 */ - { 0x0000, 0x0000, 0x0000 }, /* R1455 */ - { 0x0000, 0x0000, 0x0000 }, /* R1456 */ - { 0x0000, 0x0000, 0x0000 }, /* R1457 */ - { 0x0000, 0x0000, 0x0000 }, /* R1458 */ - { 0x0000, 0x0000, 0x0000 }, /* R1459 */ - { 0x0000, 0x0000, 0x0000 }, /* R1460 */ - { 0x0000, 0x0000, 0x0000 }, /* R1461 */ - { 0x0000, 0x0000, 0x0000 }, /* R1462 */ - { 0x0000, 0x0000, 0x0000 }, /* R1463 */ - { 0x0000, 0x0000, 0x0000 }, /* R1464 */ - { 0x0000, 0x0000, 0x0000 }, /* R1465 */ - { 0x0000, 0x0000, 0x0000 }, /* R1466 */ - { 0x0000, 0x0000, 0x0000 }, /* R1467 */ - { 0x0000, 0x0000, 0x0000 }, /* R1468 */ - { 0x0000, 0x0000, 0x0000 }, /* R1469 */ - { 0x0000, 0x0000, 0x0000 }, /* R1470 */ - { 0x0000, 0x0000, 0x0000 }, /* R1471 */ - { 0x0000, 0x0000, 0x0000 }, /* R1472 */ - { 0x0000, 0x0000, 0x0000 }, /* R1473 */ - { 0x0000, 0x0000, 0x0000 }, /* R1474 */ - { 0x0000, 0x0000, 0x0000 }, /* R1475 */ - { 0x0000, 0x0000, 0x0000 }, /* R1476 */ - { 0x0000, 0x0000, 0x0000 }, /* R1477 */ - { 0x0000, 0x0000, 0x0000 }, /* R1478 */ - { 0x0000, 0x0000, 0x0000 }, /* R1479 */ - { 0x0000, 0x0000, 0x0000 }, /* R1480 */ - { 0x0000, 0x0000, 0x0000 }, /* R1481 */ - { 0x0000, 0x0000, 0x0000 }, /* R1482 */ - { 0x0000, 0x0000, 0x0000 }, /* R1483 */ - { 0x0000, 0x0000, 0x0000 }, /* R1484 */ - { 0x0000, 0x0000, 0x0000 }, /* R1485 */ - { 0x0000, 0x0000, 0x0000 }, /* R1486 */ - { 0x0000, 0x0000, 0x0000 }, /* R1487 */ - { 0x0000, 0x0000, 0x0000 }, /* R1488 */ - { 0x0000, 0x0000, 0x0000 }, /* R1489 */ - { 0x0000, 0x0000, 0x0000 }, /* R1490 */ - { 0x0000, 0x0000, 0x0000 }, /* R1491 */ - { 0x0000, 0x0000, 0x0000 }, /* R1492 */ - { 0x0000, 0x0000, 0x0000 }, /* R1493 */ - { 0x0000, 0x0000, 0x0000 }, /* R1494 */ - { 0x0000, 0x0000, 0x0000 }, /* R1495 */ - { 0x0000, 0x0000, 0x0000 }, /* R1496 */ - { 0x0000, 0x0000, 0x0000 }, /* R1497 */ - { 0x0000, 0x0000, 0x0000 }, /* R1498 */ - { 0x0000, 0x0000, 0x0000 }, /* R1499 */ - { 0x0000, 0x0000, 0x0000 }, /* R1500 */ - { 0x0000, 0x0000, 0x0000 }, /* R1501 */ - { 0x0000, 0x0000, 0x0000 }, /* R1502 */ - { 0x0000, 0x0000, 0x0000 }, /* R1503 */ - { 0x0000, 0x0000, 0x0000 }, /* R1504 */ - { 0x0000, 0x0000, 0x0000 }, /* R1505 */ - { 0x0000, 0x0000, 0x0000 }, /* R1506 */ - { 0x0000, 0x0000, 0x0000 }, /* R1507 */ - { 0x0000, 0x0000, 0x0000 }, /* R1508 */ - { 0x0000, 0x0000, 0x0000 }, /* R1509 */ - { 0x0000, 0x0000, 0x0000 }, /* R1510 */ - { 0x0000, 0x0000, 0x0000 }, /* R1511 */ - { 0x0000, 0x0000, 0x0000 }, /* R1512 */ - { 0x0000, 0x0000, 0x0000 }, /* R1513 */ - { 0x0000, 0x0000, 0x0000 }, /* R1514 */ - { 0x0000, 0x0000, 0x0000 }, /* R1515 */ - { 0x0000, 0x0000, 0x0000 }, /* R1516 */ - { 0x0000, 0x0000, 0x0000 }, /* R1517 */ - { 0x0000, 0x0000, 0x0000 }, /* R1518 */ - { 0x0000, 0x0000, 0x0000 }, /* R1519 */ - { 0x0000, 0x0000, 0x0000 }, /* R1520 */ - { 0x0000, 0x0000, 0x0000 }, /* R1521 */ - { 0x0000, 0x0000, 0x0000 }, /* R1522 */ - { 0x0000, 0x0000, 0x0000 }, /* R1523 */ - { 0x0000, 0x0000, 0x0000 }, /* R1524 */ - { 0x0000, 0x0000, 0x0000 }, /* R1525 */ - { 0x0000, 0x0000, 0x0000 }, /* R1526 */ - { 0x0000, 0x0000, 0x0000 }, /* R1527 */ - { 0x0000, 0x0000, 0x0000 }, /* R1528 */ - { 0x0000, 0x0000, 0x0000 }, /* R1529 */ - { 0x0000, 0x0000, 0x0000 }, /* R1530 */ - { 0x0000, 0x0000, 0x0000 }, /* R1531 */ - { 0x0000, 0x0000, 0x0000 }, /* R1532 */ - { 0x0000, 0x0000, 0x0000 }, /* R1533 */ - { 0x0000, 0x0000, 0x0000 }, /* R1534 */ - { 0x0000, 0x0000, 0x0000 }, /* R1535 */ - { 0x01EF, 0x01EF, 0x0000 }, /* R1536 - DAC1 Mixer Volumes */ - { 0x0037, 0x0037, 0x0000 }, /* R1537 - DAC1 Left Mixer Routing */ - { 0x0037, 0x0037, 0x0000 }, /* R1538 - DAC1 Right Mixer Routing */ - { 0x01EF, 0x01EF, 0x0000 }, /* R1539 - DAC2 Mixer Volumes */ - { 0x0037, 0x0037, 0x0000 }, /* R1540 - DAC2 Left Mixer Routing */ - { 0x0037, 0x0037, 0x0000 }, /* R1541 - DAC2 Right Mixer Routing */ - { 0x0003, 0x0003, 0x0000 }, /* R1542 - AIF1 ADC1 Left Mixer Routing */ - { 0x0003, 0x0003, 0x0000 }, /* R1543 - AIF1 ADC1 Right Mixer Routing */ - { 0x0003, 0x0003, 0x0000 }, /* R1544 - AIF1 ADC2 Left Mixer Routing */ - { 0x0003, 0x0003, 0x0000 }, /* R1545 - AIF1 ADC2 Right mixer Routing */ - { 0x0000, 0x0000, 0x0000 }, /* R1546 */ - { 0x0000, 0x0000, 0x0000 }, /* R1547 */ - { 0x0000, 0x0000, 0x0000 }, /* R1548 */ - { 0x0000, 0x0000, 0x0000 }, /* R1549 */ - { 0x0000, 0x0000, 0x0000 }, /* R1550 */ - { 0x0000, 0x0000, 0x0000 }, /* R1551 */ - { 0x02FF, 0x03FF, 0x0000 }, /* R1552 - DAC1 Left Volume */ - { 0x02FF, 0x03FF, 0x0000 }, /* R1553 - DAC1 Right Volume */ - { 0x02FF, 0x03FF, 0x0000 }, /* R1554 - DAC2 Left Volume */ - { 0x02FF, 0x03FF, 0x0000 }, /* R1555 - DAC2 Right Volume */ - { 0x0003, 0x0003, 0x0000 }, /* R1556 - DAC Softmute */ - { 0x0000, 0x0000, 0x0000 }, /* R1557 */ - { 0x0000, 0x0000, 0x0000 }, /* R1558 */ - { 0x0000, 0x0000, 0x0000 }, /* R1559 */ - { 0x0000, 0x0000, 0x0000 }, /* R1560 */ - { 0x0000, 0x0000, 0x0000 }, /* R1561 */ - { 0x0000, 0x0000, 0x0000 }, /* R1562 */ - { 0x0000, 0x0000, 0x0000 }, /* R1563 */ - { 0x0000, 0x0000, 0x0000 }, /* R1564 */ - { 0x0000, 0x0000, 0x0000 }, /* R1565 */ - { 0x0000, 0x0000, 0x0000 }, /* R1566 */ - { 0x0000, 0x0000, 0x0000 }, /* R1567 */ - { 0x0003, 0x0003, 0x0000 }, /* R1568 - Oversampling */ - { 0x03C3, 0x03C3, 0x0000 }, /* R1569 - Sidetone */ + { 0xFFFF, 0xFFFF }, /* R0 - Software Reset */ + { 0x3B37, 0x3B37 }, /* R1 - Power Management (1) */ + { 0x6BF0, 0x6BF0 }, /* R2 - Power Management (2) */ + { 0x3FF0, 0x3FF0 }, /* R3 - Power Management (3) */ + { 0x3F3F, 0x3F3F }, /* R4 - Power Management (4) */ + { 0x3F0F, 0x3F0F }, /* R5 - Power Management (5) */ + { 0x003F, 0x003F }, /* R6 - Power Management (6) */ + { 0x0000, 0x0000 }, /* R7 */ + { 0x0000, 0x0000 }, /* R8 */ + { 0x0000, 0x0000 }, /* R9 */ + { 0x0000, 0x0000 }, /* R10 */ + { 0x0000, 0x0000 }, /* R11 */ + { 0x0000, 0x0000 }, /* R12 */ + { 0x0000, 0x0000 }, /* R13 */ + { 0x0000, 0x0000 }, /* R14 */ + { 0x0000, 0x0000 }, /* R15 */ + { 0x0000, 0x0000 }, /* R16 */ + { 0x0000, 0x0000 }, /* R17 */ + { 0x0000, 0x0000 }, /* R18 */ + { 0x0000, 0x0000 }, /* R19 */ + { 0x0000, 0x0000 }, /* R20 */ + { 0x01C0, 0x01C0 }, /* R21 - Input Mixer (1) */ + { 0x0000, 0x0000 }, /* R22 */ + { 0x0000, 0x0000 }, /* R23 */ + { 0x00DF, 0x01DF }, /* R24 - Left Line Input 1&2 Volume */ + { 0x00DF, 0x01DF }, /* R25 - Left Line Input 3&4 Volume */ + { 0x00DF, 0x01DF }, /* R26 - Right Line Input 1&2 Volume */ + { 0x00DF, 0x01DF }, /* R27 - Right Line Input 3&4 Volume */ + { 0x00FF, 0x01FF }, /* R28 - Left Output Volume */ + { 0x00FF, 0x01FF }, /* R29 - Right Output Volume */ + { 0x0077, 0x0077 }, /* R30 - Line Outputs Volume */ + { 0x0030, 0x0030 }, /* R31 - HPOUT2 Volume */ + { 0x00FF, 0x01FF }, /* R32 - Left OPGA Volume */ + { 0x00FF, 0x01FF }, /* R33 - Right OPGA Volume */ + { 0x007F, 0x007F }, /* R34 - SPKMIXL Attenuation */ + { 0x017F, 0x017F }, /* R35 - SPKMIXR Attenuation */ + { 0x003F, 0x003F }, /* R36 - SPKOUT Mixers */ + { 0x003F, 0x003F }, /* R37 - ClassD */ + { 0x00FF, 0x01FF }, /* R38 - Speaker Volume Left */ + { 0x00FF, 0x01FF }, /* R39 - Speaker Volume Right */ + { 0x00FF, 0x00FF }, /* R40 - Input Mixer (2) */ + { 0x01B7, 0x01B7 }, /* R41 - Input Mixer (3) */ + { 0x01B7, 0x01B7 }, /* R42 - Input Mixer (4) */ + { 0x01C7, 0x01C7 }, /* R43 - Input Mixer (5) */ + { 0x01C7, 0x01C7 }, /* R44 - Input Mixer (6) */ + { 0x01FF, 0x01FF }, /* R45 - Output Mixer (1) */ + { 0x01FF, 0x01FF }, /* R46 - Output Mixer (2) */ + { 0x0FFF, 0x0FFF }, /* R47 - Output Mixer (3) */ + { 0x0FFF, 0x0FFF }, /* R48 - Output Mixer (4) */ + { 0x0FFF, 0x0FFF }, /* R49 - Output Mixer (5) */ + { 0x0FFF, 0x0FFF }, /* R50 - Output Mixer (6) */ + { 0x0038, 0x0038 }, /* R51 - HPOUT2 Mixer */ + { 0x0077, 0x0077 }, /* R52 - Line Mixer (1) */ + { 0x0077, 0x0077 }, /* R53 - Line Mixer (2) */ + { 0x03FF, 0x03FF }, /* R54 - Speaker Mixer */ + { 0x00C1, 0x00C1 }, /* R55 - Additional Control */ + { 0x00F0, 0x00F0 }, /* R56 - AntiPOP (1) */ + { 0x01EF, 0x01EF }, /* R57 - AntiPOP (2) */ + { 0x00FF, 0x00FF }, /* R58 - MICBIAS */ + { 0x000F, 0x000F }, /* R59 - LDO 1 */ + { 0x0007, 0x0007 }, /* R60 - LDO 2 */ + { 0x0000, 0x0000 }, /* R61 */ + { 0x0000, 0x0000 }, /* R62 */ + { 0x0000, 0x0000 }, /* R63 */ + { 0x0000, 0x0000 }, /* R64 */ + { 0x0000, 0x0000 }, /* R65 */ + { 0x0000, 0x0000 }, /* R66 */ + { 0x0000, 0x0000 }, /* R67 */ + { 0x0000, 0x0000 }, /* R68 */ + { 0x0000, 0x0000 }, /* R69 */ + { 0x0000, 0x0000 }, /* R70 */ + { 0x0000, 0x0000 }, /* R71 */ + { 0x0000, 0x0000 }, /* R72 */ + { 0x0000, 0x0000 }, /* R73 */ + { 0x0000, 0x0000 }, /* R74 */ + { 0x0000, 0x0000 }, /* R75 */ + { 0x8000, 0x8000 }, /* R76 - Charge Pump (1) */ + { 0x0000, 0x0000 }, /* R77 */ + { 0x0000, 0x0000 }, /* R78 */ + { 0x0000, 0x0000 }, /* R79 */ + { 0x0000, 0x0000 }, /* R80 */ + { 0x0301, 0x0301 }, /* R81 - Class W (1) */ + { 0x0000, 0x0000 }, /* R82 */ + { 0x0000, 0x0000 }, /* R83 */ + { 0x333F, 0x333F }, /* R84 - DC Servo (1) */ + { 0x0FEF, 0x0FEF }, /* R85 - DC Servo (2) */ + { 0x0000, 0x0000 }, /* R86 */ + { 0xFFFF, 0xFFFF }, /* R87 - DC Servo (4) */ + { 0x0333, 0x0000 }, /* R88 - DC Servo Readback */ + { 0x0000, 0x0000 }, /* R89 */ + { 0x0000, 0x0000 }, /* R90 */ + { 0x0000, 0x0000 }, /* R91 */ + { 0x0000, 0x0000 }, /* R92 */ + { 0x0000, 0x0000 }, /* R93 */ + { 0x0000, 0x0000 }, /* R94 */ + { 0x0000, 0x0000 }, /* R95 */ + { 0x00EE, 0x00EE }, /* R96 - Analogue HP (1) */ + { 0x0000, 0x0000 }, /* R97 */ + { 0x0000, 0x0000 }, /* R98 */ + { 0x0000, 0x0000 }, /* R99 */ + { 0x0000, 0x0000 }, /* R100 */ + { 0x0000, 0x0000 }, /* R101 */ + { 0x0000, 0x0000 }, /* R102 */ + { 0x0000, 0x0000 }, /* R103 */ + { 0x0000, 0x0000 }, /* R104 */ + { 0x0000, 0x0000 }, /* R105 */ + { 0x0000, 0x0000 }, /* R106 */ + { 0x0000, 0x0000 }, /* R107 */ + { 0x0000, 0x0000 }, /* R108 */ + { 0x0000, 0x0000 }, /* R109 */ + { 0x0000, 0x0000 }, /* R110 */ + { 0x0000, 0x0000 }, /* R111 */ + { 0x0000, 0x0000 }, /* R112 */ + { 0x0000, 0x0000 }, /* R113 */ + { 0x0000, 0x0000 }, /* R114 */ + { 0x0000, 0x0000 }, /* R115 */ + { 0x0000, 0x0000 }, /* R116 */ + { 0x0000, 0x0000 }, /* R117 */ + { 0x0000, 0x0000 }, /* R118 */ + { 0x0000, 0x0000 }, /* R119 */ + { 0x0000, 0x0000 }, /* R120 */ + { 0x0000, 0x0000 }, /* R121 */ + { 0x0000, 0x0000 }, /* R122 */ + { 0x0000, 0x0000 }, /* R123 */ + { 0x0000, 0x0000 }, /* R124 */ + { 0x0000, 0x0000 }, /* R125 */ + { 0x0000, 0x0000 }, /* R126 */ + { 0x0000, 0x0000 }, /* R127 */ + { 0x0000, 0x0000 }, /* R128 */ + { 0x0000, 0x0000 }, /* R129 */ + { 0x0000, 0x0000 }, /* R130 */ + { 0x0000, 0x0000 }, /* R131 */ + { 0x0000, 0x0000 }, /* R132 */ + { 0x0000, 0x0000 }, /* R133 */ + { 0x0000, 0x0000 }, /* R134 */ + { 0x0000, 0x0000 }, /* R135 */ + { 0x0000, 0x0000 }, /* R136 */ + { 0x0000, 0x0000 }, /* R137 */ + { 0x0000, 0x0000 }, /* R138 */ + { 0x0000, 0x0000 }, /* R139 */ + { 0x0000, 0x0000 }, /* R140 */ + { 0x0000, 0x0000 }, /* R141 */ + { 0x0000, 0x0000 }, /* R142 */ + { 0x0000, 0x0000 }, /* R143 */ + { 0x0000, 0x0000 }, /* R144 */ + { 0x0000, 0x0000 }, /* R145 */ + { 0x0000, 0x0000 }, /* R146 */ + { 0x0000, 0x0000 }, /* R147 */ + { 0x0000, 0x0000 }, /* R148 */ + { 0x0000, 0x0000 }, /* R149 */ + { 0x0000, 0x0000 }, /* R150 */ + { 0x0000, 0x0000 }, /* R151 */ + { 0x0000, 0x0000 }, /* R152 */ + { 0x0000, 0x0000 }, /* R153 */ + { 0x0000, 0x0000 }, /* R154 */ + { 0x0000, 0x0000 }, /* R155 */ + { 0x0000, 0x0000 }, /* R156 */ + { 0x0000, 0x0000 }, /* R157 */ + { 0x0000, 0x0000 }, /* R158 */ + { 0x0000, 0x0000 }, /* R159 */ + { 0x0000, 0x0000 }, /* R160 */ + { 0x0000, 0x0000 }, /* R161 */ + { 0x0000, 0x0000 }, /* R162 */ + { 0x0000, 0x0000 }, /* R163 */ + { 0x0000, 0x0000 }, /* R164 */ + { 0x0000, 0x0000 }, /* R165 */ + { 0x0000, 0x0000 }, /* R166 */ + { 0x0000, 0x0000 }, /* R167 */ + { 0x0000, 0x0000 }, /* R168 */ + { 0x0000, 0x0000 }, /* R169 */ + { 0x0000, 0x0000 }, /* R170 */ + { 0x0000, 0x0000 }, /* R171 */ + { 0x0000, 0x0000 }, /* R172 */ + { 0x0000, 0x0000 }, /* R173 */ + { 0x0000, 0x0000 }, /* R174 */ + { 0x0000, 0x0000 }, /* R175 */ + { 0x0000, 0x0000 }, /* R176 */ + { 0x0000, 0x0000 }, /* R177 */ + { 0x0000, 0x0000 }, /* R178 */ + { 0x0000, 0x0000 }, /* R179 */ + { 0x0000, 0x0000 }, /* R180 */ + { 0x0000, 0x0000 }, /* R181 */ + { 0x0000, 0x0000 }, /* R182 */ + { 0x0000, 0x0000 }, /* R183 */ + { 0x0000, 0x0000 }, /* R184 */ + { 0x0000, 0x0000 }, /* R185 */ + { 0x0000, 0x0000 }, /* R186 */ + { 0x0000, 0x0000 }, /* R187 */ + { 0x0000, 0x0000 }, /* R188 */ + { 0x0000, 0x0000 }, /* R189 */ + { 0x0000, 0x0000 }, /* R190 */ + { 0x0000, 0x0000 }, /* R191 */ + { 0x0000, 0x0000 }, /* R192 */ + { 0x0000, 0x0000 }, /* R193 */ + { 0x0000, 0x0000 }, /* R194 */ + { 0x0000, 0x0000 }, /* R195 */ + { 0x0000, 0x0000 }, /* R196 */ + { 0x0000, 0x0000 }, /* R197 */ + { 0x0000, 0x0000 }, /* R198 */ + { 0x0000, 0x0000 }, /* R199 */ + { 0x0000, 0x0000 }, /* R200 */ + { 0x0000, 0x0000 }, /* R201 */ + { 0x0000, 0x0000 }, /* R202 */ + { 0x0000, 0x0000 }, /* R203 */ + { 0x0000, 0x0000 }, /* R204 */ + { 0x0000, 0x0000 }, /* R205 */ + { 0x0000, 0x0000 }, /* R206 */ + { 0x0000, 0x0000 }, /* R207 */ + { 0x0000, 0x0000 }, /* R208 */ + { 0x0000, 0x0000 }, /* R209 */ + { 0x0000, 0x0000 }, /* R210 */ + { 0x0000, 0x0000 }, /* R211 */ + { 0x0000, 0x0000 }, /* R212 */ + { 0x0000, 0x0000 }, /* R213 */ + { 0x0000, 0x0000 }, /* R214 */ + { 0x0000, 0x0000 }, /* R215 */ + { 0x0000, 0x0000 }, /* R216 */ + { 0x0000, 0x0000 }, /* R217 */ + { 0x0000, 0x0000 }, /* R218 */ + { 0x0000, 0x0000 }, /* R219 */ + { 0x0000, 0x0000 }, /* R220 */ + { 0x0000, 0x0000 }, /* R221 */ + { 0x0000, 0x0000 }, /* R222 */ + { 0x0000, 0x0000 }, /* R223 */ + { 0x0000, 0x0000 }, /* R224 */ + { 0x0000, 0x0000 }, /* R225 */ + { 0x0000, 0x0000 }, /* R226 */ + { 0x0000, 0x0000 }, /* R227 */ + { 0x0000, 0x0000 }, /* R228 */ + { 0x0000, 0x0000 }, /* R229 */ + { 0x0000, 0x0000 }, /* R230 */ + { 0x0000, 0x0000 }, /* R231 */ + { 0x0000, 0x0000 }, /* R232 */ + { 0x0000, 0x0000 }, /* R233 */ + { 0x0000, 0x0000 }, /* R234 */ + { 0x0000, 0x0000 }, /* R235 */ + { 0x0000, 0x0000 }, /* R236 */ + { 0x0000, 0x0000 }, /* R237 */ + { 0x0000, 0x0000 }, /* R238 */ + { 0x0000, 0x0000 }, /* R239 */ + { 0x0000, 0x0000 }, /* R240 */ + { 0x0000, 0x0000 }, /* R241 */ + { 0x0000, 0x0000 }, /* R242 */ + { 0x0000, 0x0000 }, /* R243 */ + { 0x0000, 0x0000 }, /* R244 */ + { 0x0000, 0x0000 }, /* R245 */ + { 0x0000, 0x0000 }, /* R246 */ + { 0x0000, 0x0000 }, /* R247 */ + { 0x0000, 0x0000 }, /* R248 */ + { 0x0000, 0x0000 }, /* R249 */ + { 0x0000, 0x0000 }, /* R250 */ + { 0x0000, 0x0000 }, /* R251 */ + { 0x0000, 0x0000 }, /* R252 */ + { 0x0000, 0x0000 }, /* R253 */ + { 0x0000, 0x0000 }, /* R254 */ + { 0x0000, 0x0000 }, /* R255 */ + { 0x000F, 0x0000 }, /* R256 - Chip Revision */ + { 0x0074, 0x0074 }, /* R257 - Control Interface */ + { 0x0000, 0x0000 }, /* R258 */ + { 0x0000, 0x0000 }, /* R259 */ + { 0x0000, 0x0000 }, /* R260 */ + { 0x0000, 0x0000 }, /* R261 */ + { 0x0000, 0x0000 }, /* R262 */ + { 0x0000, 0x0000 }, /* R263 */ + { 0x0000, 0x0000 }, /* R264 */ + { 0x0000, 0x0000 }, /* R265 */ + { 0x0000, 0x0000 }, /* R266 */ + { 0x0000, 0x0000 }, /* R267 */ + { 0x0000, 0x0000 }, /* R268 */ + { 0x0000, 0x0000 }, /* R269 */ + { 0x0000, 0x0000 }, /* R270 */ + { 0x0000, 0x0000 }, /* R271 */ + { 0x807F, 0x837F }, /* R272 - Write Sequencer Ctrl (1) */ + { 0x017F, 0x0000 }, /* R273 - Write Sequencer Ctrl (2) */ + { 0x0000, 0x0000 }, /* R274 */ + { 0x0000, 0x0000 }, /* R275 */ + { 0x0000, 0x0000 }, /* R276 */ + { 0x0000, 0x0000 }, /* R277 */ + { 0x0000, 0x0000 }, /* R278 */ + { 0x0000, 0x0000 }, /* R279 */ + { 0x0000, 0x0000 }, /* R280 */ + { 0x0000, 0x0000 }, /* R281 */ + { 0x0000, 0x0000 }, /* R282 */ + { 0x0000, 0x0000 }, /* R283 */ + { 0x0000, 0x0000 }, /* R284 */ + { 0x0000, 0x0000 }, /* R285 */ + { 0x0000, 0x0000 }, /* R286 */ + { 0x0000, 0x0000 }, /* R287 */ + { 0x0000, 0x0000 }, /* R288 */ + { 0x0000, 0x0000 }, /* R289 */ + { 0x0000, 0x0000 }, /* R290 */ + { 0x0000, 0x0000 }, /* R291 */ + { 0x0000, 0x0000 }, /* R292 */ + { 0x0000, 0x0000 }, /* R293 */ + { 0x0000, 0x0000 }, /* R294 */ + { 0x0000, 0x0000 }, /* R295 */ + { 0x0000, 0x0000 }, /* R296 */ + { 0x0000, 0x0000 }, /* R297 */ + { 0x0000, 0x0000 }, /* R298 */ + { 0x0000, 0x0000 }, /* R299 */ + { 0x0000, 0x0000 }, /* R300 */ + { 0x0000, 0x0000 }, /* R301 */ + { 0x0000, 0x0000 }, /* R302 */ + { 0x0000, 0x0000 }, /* R303 */ + { 0x0000, 0x0000 }, /* R304 */ + { 0x0000, 0x0000 }, /* R305 */ + { 0x0000, 0x0000 }, /* R306 */ + { 0x0000, 0x0000 }, /* R307 */ + { 0x0000, 0x0000 }, /* R308 */ + { 0x0000, 0x0000 }, /* R309 */ + { 0x0000, 0x0000 }, /* R310 */ + { 0x0000, 0x0000 }, /* R311 */ + { 0x0000, 0x0000 }, /* R312 */ + { 0x0000, 0x0000 }, /* R313 */ + { 0x0000, 0x0000 }, /* R314 */ + { 0x0000, 0x0000 }, /* R315 */ + { 0x0000, 0x0000 }, /* R316 */ + { 0x0000, 0x0000 }, /* R317 */ + { 0x0000, 0x0000 }, /* R318 */ + { 0x0000, 0x0000 }, /* R319 */ + { 0x0000, 0x0000 }, /* R320 */ + { 0x0000, 0x0000 }, /* R321 */ + { 0x0000, 0x0000 }, /* R322 */ + { 0x0000, 0x0000 }, /* R323 */ + { 0x0000, 0x0000 }, /* R324 */ + { 0x0000, 0x0000 }, /* R325 */ + { 0x0000, 0x0000 }, /* R326 */ + { 0x0000, 0x0000 }, /* R327 */ + { 0x0000, 0x0000 }, /* R328 */ + { 0x0000, 0x0000 }, /* R329 */ + { 0x0000, 0x0000 }, /* R330 */ + { 0x0000, 0x0000 }, /* R331 */ + { 0x0000, 0x0000 }, /* R332 */ + { 0x0000, 0x0000 }, /* R333 */ + { 0x0000, 0x0000 }, /* R334 */ + { 0x0000, 0x0000 }, /* R335 */ + { 0x0000, 0x0000 }, /* R336 */ + { 0x0000, 0x0000 }, /* R337 */ + { 0x0000, 0x0000 }, /* R338 */ + { 0x0000, 0x0000 }, /* R339 */ + { 0x0000, 0x0000 }, /* R340 */ + { 0x0000, 0x0000 }, /* R341 */ + { 0x0000, 0x0000 }, /* R342 */ + { 0x0000, 0x0000 }, /* R343 */ + { 0x0000, 0x0000 }, /* R344 */ + { 0x0000, 0x0000 }, /* R345 */ + { 0x0000, 0x0000 }, /* R346 */ + { 0x0000, 0x0000 }, /* R347 */ + { 0x0000, 0x0000 }, /* R348 */ + { 0x0000, 0x0000 }, /* R349 */ + { 0x0000, 0x0000 }, /* R350 */ + { 0x0000, 0x0000 }, /* R351 */ + { 0x0000, 0x0000 }, /* R352 */ + { 0x0000, 0x0000 }, /* R353 */ + { 0x0000, 0x0000 }, /* R354 */ + { 0x0000, 0x0000 }, /* R355 */ + { 0x0000, 0x0000 }, /* R356 */ + { 0x0000, 0x0000 }, /* R357 */ + { 0x0000, 0x0000 }, /* R358 */ + { 0x0000, 0x0000 }, /* R359 */ + { 0x0000, 0x0000 }, /* R360 */ + { 0x0000, 0x0000 }, /* R361 */ + { 0x0000, 0x0000 }, /* R362 */ + { 0x0000, 0x0000 }, /* R363 */ + { 0x0000, 0x0000 }, /* R364 */ + { 0x0000, 0x0000 }, /* R365 */ + { 0x0000, 0x0000 }, /* R366 */ + { 0x0000, 0x0000 }, /* R367 */ + { 0x0000, 0x0000 }, /* R368 */ + { 0x0000, 0x0000 }, /* R369 */ + { 0x0000, 0x0000 }, /* R370 */ + { 0x0000, 0x0000 }, /* R371 */ + { 0x0000, 0x0000 }, /* R372 */ + { 0x0000, 0x0000 }, /* R373 */ + { 0x0000, 0x0000 }, /* R374 */ + { 0x0000, 0x0000 }, /* R375 */ + { 0x0000, 0x0000 }, /* R376 */ + { 0x0000, 0x0000 }, /* R377 */ + { 0x0000, 0x0000 }, /* R378 */ + { 0x0000, 0x0000 }, /* R379 */ + { 0x0000, 0x0000 }, /* R380 */ + { 0x0000, 0x0000 }, /* R381 */ + { 0x0000, 0x0000 }, /* R382 */ + { 0x0000, 0x0000 }, /* R383 */ + { 0x0000, 0x0000 }, /* R384 */ + { 0x0000, 0x0000 }, /* R385 */ + { 0x0000, 0x0000 }, /* R386 */ + { 0x0000, 0x0000 }, /* R387 */ + { 0x0000, 0x0000 }, /* R388 */ + { 0x0000, 0x0000 }, /* R389 */ + { 0x0000, 0x0000 }, /* R390 */ + { 0x0000, 0x0000 }, /* R391 */ + { 0x0000, 0x0000 }, /* R392 */ + { 0x0000, 0x0000 }, /* R393 */ + { 0x0000, 0x0000 }, /* R394 */ + { 0x0000, 0x0000 }, /* R395 */ + { 0x0000, 0x0000 }, /* R396 */ + { 0x0000, 0x0000 }, /* R397 */ + { 0x0000, 0x0000 }, /* R398 */ + { 0x0000, 0x0000 }, /* R399 */ + { 0x0000, 0x0000 }, /* R400 */ + { 0x0000, 0x0000 }, /* R401 */ + { 0x0000, 0x0000 }, /* R402 */ + { 0x0000, 0x0000 }, /* R403 */ + { 0x0000, 0x0000 }, /* R404 */ + { 0x0000, 0x0000 }, /* R405 */ + { 0x0000, 0x0000 }, /* R406 */ + { 0x0000, 0x0000 }, /* R407 */ + { 0x0000, 0x0000 }, /* R408 */ + { 0x0000, 0x0000 }, /* R409 */ + { 0x0000, 0x0000 }, /* R410 */ + { 0x0000, 0x0000 }, /* R411 */ + { 0x0000, 0x0000 }, /* R412 */ + { 0x0000, 0x0000 }, /* R413 */ + { 0x0000, 0x0000 }, /* R414 */ + { 0x0000, 0x0000 }, /* R415 */ + { 0x0000, 0x0000 }, /* R416 */ + { 0x0000, 0x0000 }, /* R417 */ + { 0x0000, 0x0000 }, /* R418 */ + { 0x0000, 0x0000 }, /* R419 */ + { 0x0000, 0x0000 }, /* R420 */ + { 0x0000, 0x0000 }, /* R421 */ + { 0x0000, 0x0000 }, /* R422 */ + { 0x0000, 0x0000 }, /* R423 */ + { 0x0000, 0x0000 }, /* R424 */ + { 0x0000, 0x0000 }, /* R425 */ + { 0x0000, 0x0000 }, /* R426 */ + { 0x0000, 0x0000 }, /* R427 */ + { 0x0000, 0x0000 }, /* R428 */ + { 0x0000, 0x0000 }, /* R429 */ + { 0x0000, 0x0000 }, /* R430 */ + { 0x0000, 0x0000 }, /* R431 */ + { 0x0000, 0x0000 }, /* R432 */ + { 0x0000, 0x0000 }, /* R433 */ + { 0x0000, 0x0000 }, /* R434 */ + { 0x0000, 0x0000 }, /* R435 */ + { 0x0000, 0x0000 }, /* R436 */ + { 0x0000, 0x0000 }, /* R437 */ + { 0x0000, 0x0000 }, /* R438 */ + { 0x0000, 0x0000 }, /* R439 */ + { 0x0000, 0x0000 }, /* R440 */ + { 0x0000, 0x0000 }, /* R441 */ + { 0x0000, 0x0000 }, /* R442 */ + { 0x0000, 0x0000 }, /* R443 */ + { 0x0000, 0x0000 }, /* R444 */ + { 0x0000, 0x0000 }, /* R445 */ + { 0x0000, 0x0000 }, /* R446 */ + { 0x0000, 0x0000 }, /* R447 */ + { 0x0000, 0x0000 }, /* R448 */ + { 0x0000, 0x0000 }, /* R449 */ + { 0x0000, 0x0000 }, /* R450 */ + { 0x0000, 0x0000 }, /* R451 */ + { 0x0000, 0x0000 }, /* R452 */ + { 0x0000, 0x0000 }, /* R453 */ + { 0x0000, 0x0000 }, /* R454 */ + { 0x0000, 0x0000 }, /* R455 */ + { 0x0000, 0x0000 }, /* R456 */ + { 0x0000, 0x0000 }, /* R457 */ + { 0x0000, 0x0000 }, /* R458 */ + { 0x0000, 0x0000 }, /* R459 */ + { 0x0000, 0x0000 }, /* R460 */ + { 0x0000, 0x0000 }, /* R461 */ + { 0x0000, 0x0000 }, /* R462 */ + { 0x0000, 0x0000 }, /* R463 */ + { 0x0000, 0x0000 }, /* R464 */ + { 0x0000, 0x0000 }, /* R465 */ + { 0x0000, 0x0000 }, /* R466 */ + { 0x0000, 0x0000 }, /* R467 */ + { 0x0000, 0x0000 }, /* R468 */ + { 0x0000, 0x0000 }, /* R469 */ + { 0x0000, 0x0000 }, /* R470 */ + { 0x0000, 0x0000 }, /* R471 */ + { 0x0000, 0x0000 }, /* R472 */ + { 0x0000, 0x0000 }, /* R473 */ + { 0x0000, 0x0000 }, /* R474 */ + { 0x0000, 0x0000 }, /* R475 */ + { 0x0000, 0x0000 }, /* R476 */ + { 0x0000, 0x0000 }, /* R477 */ + { 0x0000, 0x0000 }, /* R478 */ + { 0x0000, 0x0000 }, /* R479 */ + { 0x0000, 0x0000 }, /* R480 */ + { 0x0000, 0x0000 }, /* R481 */ + { 0x0000, 0x0000 }, /* R482 */ + { 0x0000, 0x0000 }, /* R483 */ + { 0x0000, 0x0000 }, /* R484 */ + { 0x0000, 0x0000 }, /* R485 */ + { 0x0000, 0x0000 }, /* R486 */ + { 0x0000, 0x0000 }, /* R487 */ + { 0x0000, 0x0000 }, /* R488 */ + { 0x0000, 0x0000 }, /* R489 */ + { 0x0000, 0x0000 }, /* R490 */ + { 0x0000, 0x0000 }, /* R491 */ + { 0x0000, 0x0000 }, /* R492 */ + { 0x0000, 0x0000 }, /* R493 */ + { 0x0000, 0x0000 }, /* R494 */ + { 0x0000, 0x0000 }, /* R495 */ + { 0x0000, 0x0000 }, /* R496 */ + { 0x0000, 0x0000 }, /* R497 */ + { 0x0000, 0x0000 }, /* R498 */ + { 0x0000, 0x0000 }, /* R499 */ + { 0x0000, 0x0000 }, /* R500 */ + { 0x0000, 0x0000 }, /* R501 */ + { 0x0000, 0x0000 }, /* R502 */ + { 0x0000, 0x0000 }, /* R503 */ + { 0x0000, 0x0000 }, /* R504 */ + { 0x0000, 0x0000 }, /* R505 */ + { 0x0000, 0x0000 }, /* R506 */ + { 0x0000, 0x0000 }, /* R507 */ + { 0x0000, 0x0000 }, /* R508 */ + { 0x0000, 0x0000 }, /* R509 */ + { 0x0000, 0x0000 }, /* R510 */ + { 0x0000, 0x0000 }, /* R511 */ + { 0x001F, 0x001F }, /* R512 - AIF1 Clocking (1) */ + { 0x003F, 0x003F }, /* R513 - AIF1 Clocking (2) */ + { 0x0000, 0x0000 }, /* R514 */ + { 0x0000, 0x0000 }, /* R515 */ + { 0x001F, 0x001F }, /* R516 - AIF2 Clocking (1) */ + { 0x003F, 0x003F }, /* R517 - AIF2 Clocking (2) */ + { 0x0000, 0x0000 }, /* R518 */ + { 0x0000, 0x0000 }, /* R519 */ + { 0x001F, 0x001F }, /* R520 - Clocking (1) */ + { 0x0777, 0x0777 }, /* R521 - Clocking (2) */ + { 0x0000, 0x0000 }, /* R522 */ + { 0x0000, 0x0000 }, /* R523 */ + { 0x0000, 0x0000 }, /* R524 */ + { 0x0000, 0x0000 }, /* R525 */ + { 0x0000, 0x0000 }, /* R526 */ + { 0x0000, 0x0000 }, /* R527 */ + { 0x00FF, 0x00FF }, /* R528 - AIF1 Rate */ + { 0x00FF, 0x00FF }, /* R529 - AIF2 Rate */ + { 0x000F, 0x0000 }, /* R530 - Rate Status */ + { 0x0000, 0x0000 }, /* R531 */ + { 0x0000, 0x0000 }, /* R532 */ + { 0x0000, 0x0000 }, /* R533 */ + { 0x0000, 0x0000 }, /* R534 */ + { 0x0000, 0x0000 }, /* R535 */ + { 0x0000, 0x0000 }, /* R536 */ + { 0x0000, 0x0000 }, /* R537 */ + { 0x0000, 0x0000 }, /* R538 */ + { 0x0000, 0x0000 }, /* R539 */ + { 0x0000, 0x0000 }, /* R540 */ + { 0x0000, 0x0000 }, /* R541 */ + { 0x0000, 0x0000 }, /* R542 */ + { 0x0000, 0x0000 }, /* R543 */ + { 0x0007, 0x0007 }, /* R544 - FLL1 Control (1) */ + { 0x3F77, 0x3F77 }, /* R545 - FLL1 Control (2) */ + { 0xFFFF, 0xFFFF }, /* R546 - FLL1 Control (3) */ + { 0x7FEF, 0x7FEF }, /* R547 - FLL1 Control (4) */ + { 0x1FDB, 0x1FDB }, /* R548 - FLL1 Control (5) */ + { 0x0000, 0x0000 }, /* R549 */ + { 0x0000, 0x0000 }, /* R550 */ + { 0x0000, 0x0000 }, /* R551 */ + { 0x0000, 0x0000 }, /* R552 */ + { 0x0000, 0x0000 }, /* R553 */ + { 0x0000, 0x0000 }, /* R554 */ + { 0x0000, 0x0000 }, /* R555 */ + { 0x0000, 0x0000 }, /* R556 */ + { 0x0000, 0x0000 }, /* R557 */ + { 0x0000, 0x0000 }, /* R558 */ + { 0x0000, 0x0000 }, /* R559 */ + { 0x0000, 0x0000 }, /* R560 */ + { 0x0000, 0x0000 }, /* R561 */ + { 0x0000, 0x0000 }, /* R562 */ + { 0x0000, 0x0000 }, /* R563 */ + { 0x0000, 0x0000 }, /* R564 */ + { 0x0000, 0x0000 }, /* R565 */ + { 0x0000, 0x0000 }, /* R566 */ + { 0x0000, 0x0000 }, /* R567 */ + { 0x0000, 0x0000 }, /* R568 */ + { 0x0000, 0x0000 }, /* R569 */ + { 0x0000, 0x0000 }, /* R570 */ + { 0x0000, 0x0000 }, /* R571 */ + { 0x0000, 0x0000 }, /* R572 */ + { 0x0000, 0x0000 }, /* R573 */ + { 0x0000, 0x0000 }, /* R574 */ + { 0x0000, 0x0000 }, /* R575 */ + { 0x0007, 0x0007 }, /* R576 - FLL2 Control (1) */ + { 0x3F77, 0x3F77 }, /* R577 - FLL2 Control (2) */ + { 0xFFFF, 0xFFFF }, /* R578 - FLL2 Control (3) */ + { 0x7FEF, 0x7FEF }, /* R579 - FLL2 Control (4) */ + { 0x1FDB, 0x1FDB }, /* R580 - FLL2 Control (5) */ + { 0x0000, 0x0000 }, /* R581 */ + { 0x0000, 0x0000 }, /* R582 */ + { 0x0000, 0x0000 }, /* R583 */ + { 0x0000, 0x0000 }, /* R584 */ + { 0x0000, 0x0000 }, /* R585 */ + { 0x0000, 0x0000 }, /* R586 */ + { 0x0000, 0x0000 }, /* R587 */ + { 0x0000, 0x0000 }, /* R588 */ + { 0x0000, 0x0000 }, /* R589 */ + { 0x0000, 0x0000 }, /* R590 */ + { 0x0000, 0x0000 }, /* R591 */ + { 0x0000, 0x0000 }, /* R592 */ + { 0x0000, 0x0000 }, /* R593 */ + { 0x0000, 0x0000 }, /* R594 */ + { 0x0000, 0x0000 }, /* R595 */ + { 0x0000, 0x0000 }, /* R596 */ + { 0x0000, 0x0000 }, /* R597 */ + { 0x0000, 0x0000 }, /* R598 */ + { 0x0000, 0x0000 }, /* R599 */ + { 0x0000, 0x0000 }, /* R600 */ + { 0x0000, 0x0000 }, /* R601 */ + { 0x0000, 0x0000 }, /* R602 */ + { 0x0000, 0x0000 }, /* R603 */ + { 0x0000, 0x0000 }, /* R604 */ + { 0x0000, 0x0000 }, /* R605 */ + { 0x0000, 0x0000 }, /* R606 */ + { 0x0000, 0x0000 }, /* R607 */ + { 0x0000, 0x0000 }, /* R608 */ + { 0x0000, 0x0000 }, /* R609 */ + { 0x0000, 0x0000 }, /* R610 */ + { 0x0000, 0x0000 }, /* R611 */ + { 0x0000, 0x0000 }, /* R612 */ + { 0x0000, 0x0000 }, /* R613 */ + { 0x0000, 0x0000 }, /* R614 */ + { 0x0000, 0x0000 }, /* R615 */ + { 0x0000, 0x0000 }, /* R616 */ + { 0x0000, 0x0000 }, /* R617 */ + { 0x0000, 0x0000 }, /* R618 */ + { 0x0000, 0x0000 }, /* R619 */ + { 0x0000, 0x0000 }, /* R620 */ + { 0x0000, 0x0000 }, /* R621 */ + { 0x0000, 0x0000 }, /* R622 */ + { 0x0000, 0x0000 }, /* R623 */ + { 0x0000, 0x0000 }, /* R624 */ + { 0x0000, 0x0000 }, /* R625 */ + { 0x0000, 0x0000 }, /* R626 */ + { 0x0000, 0x0000 }, /* R627 */ + { 0x0000, 0x0000 }, /* R628 */ + { 0x0000, 0x0000 }, /* R629 */ + { 0x0000, 0x0000 }, /* R630 */ + { 0x0000, 0x0000 }, /* R631 */ + { 0x0000, 0x0000 }, /* R632 */ + { 0x0000, 0x0000 }, /* R633 */ + { 0x0000, 0x0000 }, /* R634 */ + { 0x0000, 0x0000 }, /* R635 */ + { 0x0000, 0x0000 }, /* R636 */ + { 0x0000, 0x0000 }, /* R637 */ + { 0x0000, 0x0000 }, /* R638 */ + { 0x0000, 0x0000 }, /* R639 */ + { 0x0000, 0x0000 }, /* R640 */ + { 0x0000, 0x0000 }, /* R641 */ + { 0x0000, 0x0000 }, /* R642 */ + { 0x0000, 0x0000 }, /* R643 */ + { 0x0000, 0x0000 }, /* R644 */ + { 0x0000, 0x0000 }, /* R645 */ + { 0x0000, 0x0000 }, /* R646 */ + { 0x0000, 0x0000 }, /* R647 */ + { 0x0000, 0x0000 }, /* R648 */ + { 0x0000, 0x0000 }, /* R649 */ + { 0x0000, 0x0000 }, /* R650 */ + { 0x0000, 0x0000 }, /* R651 */ + { 0x0000, 0x0000 }, /* R652 */ + { 0x0000, 0x0000 }, /* R653 */ + { 0x0000, 0x0000 }, /* R654 */ + { 0x0000, 0x0000 }, /* R655 */ + { 0x0000, 0x0000 }, /* R656 */ + { 0x0000, 0x0000 }, /* R657 */ + { 0x0000, 0x0000 }, /* R658 */ + { 0x0000, 0x0000 }, /* R659 */ + { 0x0000, 0x0000 }, /* R660 */ + { 0x0000, 0x0000 }, /* R661 */ + { 0x0000, 0x0000 }, /* R662 */ + { 0x0000, 0x0000 }, /* R663 */ + { 0x0000, 0x0000 }, /* R664 */ + { 0x0000, 0x0000 }, /* R665 */ + { 0x0000, 0x0000 }, /* R666 */ + { 0x0000, 0x0000 }, /* R667 */ + { 0x0000, 0x0000 }, /* R668 */ + { 0x0000, 0x0000 }, /* R669 */ + { 0x0000, 0x0000 }, /* R670 */ + { 0x0000, 0x0000 }, /* R671 */ + { 0x0000, 0x0000 }, /* R672 */ + { 0x0000, 0x0000 }, /* R673 */ + { 0x0000, 0x0000 }, /* R674 */ + { 0x0000, 0x0000 }, /* R675 */ + { 0x0000, 0x0000 }, /* R676 */ + { 0x0000, 0x0000 }, /* R677 */ + { 0x0000, 0x0000 }, /* R678 */ + { 0x0000, 0x0000 }, /* R679 */ + { 0x0000, 0x0000 }, /* R680 */ + { 0x0000, 0x0000 }, /* R681 */ + { 0x0000, 0x0000 }, /* R682 */ + { 0x0000, 0x0000 }, /* R683 */ + { 0x0000, 0x0000 }, /* R684 */ + { 0x0000, 0x0000 }, /* R685 */ + { 0x0000, 0x0000 }, /* R686 */ + { 0x0000, 0x0000 }, /* R687 */ + { 0x0000, 0x0000 }, /* R688 */ + { 0x0000, 0x0000 }, /* R689 */ + { 0x0000, 0x0000 }, /* R690 */ + { 0x0000, 0x0000 }, /* R691 */ + { 0x0000, 0x0000 }, /* R692 */ + { 0x0000, 0x0000 }, /* R693 */ + { 0x0000, 0x0000 }, /* R694 */ + { 0x0000, 0x0000 }, /* R695 */ + { 0x0000, 0x0000 }, /* R696 */ + { 0x0000, 0x0000 }, /* R697 */ + { 0x0000, 0x0000 }, /* R698 */ + { 0x0000, 0x0000 }, /* R699 */ + { 0x0000, 0x0000 }, /* R700 */ + { 0x0000, 0x0000 }, /* R701 */ + { 0x0000, 0x0000 }, /* R702 */ + { 0x0000, 0x0000 }, /* R703 */ + { 0x0000, 0x0000 }, /* R704 */ + { 0x0000, 0x0000 }, /* R705 */ + { 0x0000, 0x0000 }, /* R706 */ + { 0x0000, 0x0000 }, /* R707 */ + { 0x0000, 0x0000 }, /* R708 */ + { 0x0000, 0x0000 }, /* R709 */ + { 0x0000, 0x0000 }, /* R710 */ + { 0x0000, 0x0000 }, /* R711 */ + { 0x0000, 0x0000 }, /* R712 */ + { 0x0000, 0x0000 }, /* R713 */ + { 0x0000, 0x0000 }, /* R714 */ + { 0x0000, 0x0000 }, /* R715 */ + { 0x0000, 0x0000 }, /* R716 */ + { 0x0000, 0x0000 }, /* R717 */ + { 0x0000, 0x0000 }, /* R718 */ + { 0x0000, 0x0000 }, /* R719 */ + { 0x0000, 0x0000 }, /* R720 */ + { 0x0000, 0x0000 }, /* R721 */ + { 0x0000, 0x0000 }, /* R722 */ + { 0x0000, 0x0000 }, /* R723 */ + { 0x0000, 0x0000 }, /* R724 */ + { 0x0000, 0x0000 }, /* R725 */ + { 0x0000, 0x0000 }, /* R726 */ + { 0x0000, 0x0000 }, /* R727 */ + { 0x0000, 0x0000 }, /* R728 */ + { 0x0000, 0x0000 }, /* R729 */ + { 0x0000, 0x0000 }, /* R730 */ + { 0x0000, 0x0000 }, /* R731 */ + { 0x0000, 0x0000 }, /* R732 */ + { 0x0000, 0x0000 }, /* R733 */ + { 0x0000, 0x0000 }, /* R734 */ + { 0x0000, 0x0000 }, /* R735 */ + { 0x0000, 0x0000 }, /* R736 */ + { 0x0000, 0x0000 }, /* R737 */ + { 0x0000, 0x0000 }, /* R738 */ + { 0x0000, 0x0000 }, /* R739 */ + { 0x0000, 0x0000 }, /* R740 */ + { 0x0000, 0x0000 }, /* R741 */ + { 0x0000, 0x0000 }, /* R742 */ + { 0x0000, 0x0000 }, /* R743 */ + { 0x0000, 0x0000 }, /* R744 */ + { 0x0000, 0x0000 }, /* R745 */ + { 0x0000, 0x0000 }, /* R746 */ + { 0x0000, 0x0000 }, /* R747 */ + { 0x0000, 0x0000 }, /* R748 */ + { 0x0000, 0x0000 }, /* R749 */ + { 0x0000, 0x0000 }, /* R750 */ + { 0x0000, 0x0000 }, /* R751 */ + { 0x0000, 0x0000 }, /* R752 */ + { 0x0000, 0x0000 }, /* R753 */ + { 0x0000, 0x0000 }, /* R754 */ + { 0x0000, 0x0000 }, /* R755 */ + { 0x0000, 0x0000 }, /* R756 */ + { 0x0000, 0x0000 }, /* R757 */ + { 0x0000, 0x0000 }, /* R758 */ + { 0x0000, 0x0000 }, /* R759 */ + { 0x0000, 0x0000 }, /* R760 */ + { 0x0000, 0x0000 }, /* R761 */ + { 0x0000, 0x0000 }, /* R762 */ + { 0x0000, 0x0000 }, /* R763 */ + { 0x0000, 0x0000 }, /* R764 */ + { 0x0000, 0x0000 }, /* R765 */ + { 0x0000, 0x0000 }, /* R766 */ + { 0x0000, 0x0000 }, /* R767 */ + { 0xE1F8, 0xE1F8 }, /* R768 - AIF1 Control (1) */ + { 0xCD1F, 0xCD1F }, /* R769 - AIF1 Control (2) */ + { 0xF000, 0xF000 }, /* R770 - AIF1 Master/Slave */ + { 0x01F0, 0x01F0 }, /* R771 - AIF1 BCLK */ + { 0x0FFF, 0x0FFF }, /* R772 - AIF1ADC LRCLK */ + { 0x0FFF, 0x0FFF }, /* R773 - AIF1DAC LRCLK */ + { 0x0003, 0x0003 }, /* R774 - AIF1DAC Data */ + { 0x0003, 0x0003 }, /* R775 - AIF1ADC Data */ + { 0x0000, 0x0000 }, /* R776 */ + { 0x0000, 0x0000 }, /* R777 */ + { 0x0000, 0x0000 }, /* R778 */ + { 0x0000, 0x0000 }, /* R779 */ + { 0x0000, 0x0000 }, /* R780 */ + { 0x0000, 0x0000 }, /* R781 */ + { 0x0000, 0x0000 }, /* R782 */ + { 0x0000, 0x0000 }, /* R783 */ + { 0xF1F8, 0xF1F8 }, /* R784 - AIF2 Control (1) */ + { 0xFD1F, 0xFD1F }, /* R785 - AIF2 Control (2) */ + { 0xF000, 0xF000 }, /* R786 - AIF2 Master/Slave */ + { 0x01F0, 0x01F0 }, /* R787 - AIF2 BCLK */ + { 0x0FFF, 0x0FFF }, /* R788 - AIF2ADC LRCLK */ + { 0x0FFF, 0x0FFF }, /* R789 - AIF2DAC LRCLK */ + { 0x0003, 0x0003 }, /* R790 - AIF2DAC Data */ + { 0x0003, 0x0003 }, /* R791 - AIF2ADC Data */ + { 0x0000, 0x0000 }, /* R792 */ + { 0x0000, 0x0000 }, /* R793 */ + { 0x0000, 0x0000 }, /* R794 */ + { 0x0000, 0x0000 }, /* R795 */ + { 0x0000, 0x0000 }, /* R796 */ + { 0x0000, 0x0000 }, /* R797 */ + { 0x0000, 0x0000 }, /* R798 */ + { 0x0000, 0x0000 }, /* R799 */ + { 0x0000, 0x0000 }, /* R800 */ + { 0x0000, 0x0000 }, /* R801 */ + { 0x0000, 0x0000 }, /* R802 */ + { 0x0000, 0x0000 }, /* R803 */ + { 0x0000, 0x0000 }, /* R804 */ + { 0x0000, 0x0000 }, /* R805 */ + { 0x0000, 0x0000 }, /* R806 */ + { 0x0000, 0x0000 }, /* R807 */ + { 0x0000, 0x0000 }, /* R808 */ + { 0x0000, 0x0000 }, /* R809 */ + { 0x0000, 0x0000 }, /* R810 */ + { 0x0000, 0x0000 }, /* R811 */ + { 0x0000, 0x0000 }, /* R812 */ + { 0x0000, 0x0000 }, /* R813 */ + { 0x0000, 0x0000 }, /* R814 */ + { 0x0000, 0x0000 }, /* R815 */ + { 0x0000, 0x0000 }, /* R816 */ + { 0x0000, 0x0000 }, /* R817 */ + { 0x0000, 0x0000 }, /* R818 */ + { 0x0000, 0x0000 }, /* R819 */ + { 0x0000, 0x0000 }, /* R820 */ + { 0x0000, 0x0000 }, /* R821 */ + { 0x0000, 0x0000 }, /* R822 */ + { 0x0000, 0x0000 }, /* R823 */ + { 0x0000, 0x0000 }, /* R824 */ + { 0x0000, 0x0000 }, /* R825 */ + { 0x0000, 0x0000 }, /* R826 */ + { 0x0000, 0x0000 }, /* R827 */ + { 0x0000, 0x0000 }, /* R828 */ + { 0x0000, 0x0000 }, /* R829 */ + { 0x0000, 0x0000 }, /* R830 */ + { 0x0000, 0x0000 }, /* R831 */ + { 0x0000, 0x0000 }, /* R832 */ + { 0x0000, 0x0000 }, /* R833 */ + { 0x0000, 0x0000 }, /* R834 */ + { 0x0000, 0x0000 }, /* R835 */ + { 0x0000, 0x0000 }, /* R836 */ + { 0x0000, 0x0000 }, /* R837 */ + { 0x0000, 0x0000 }, /* R838 */ + { 0x0000, 0x0000 }, /* R839 */ + { 0x0000, 0x0000 }, /* R840 */ + { 0x0000, 0x0000 }, /* R841 */ + { 0x0000, 0x0000 }, /* R842 */ + { 0x0000, 0x0000 }, /* R843 */ + { 0x0000, 0x0000 }, /* R844 */ + { 0x0000, 0x0000 }, /* R845 */ + { 0x0000, 0x0000 }, /* R846 */ + { 0x0000, 0x0000 }, /* R847 */ + { 0x0000, 0x0000 }, /* R848 */ + { 0x0000, 0x0000 }, /* R849 */ + { 0x0000, 0x0000 }, /* R850 */ + { 0x0000, 0x0000 }, /* R851 */ + { 0x0000, 0x0000 }, /* R852 */ + { 0x0000, 0x0000 }, /* R853 */ + { 0x0000, 0x0000 }, /* R854 */ + { 0x0000, 0x0000 }, /* R855 */ + { 0x0000, 0x0000 }, /* R856 */ + { 0x0000, 0x0000 }, /* R857 */ + { 0x0000, 0x0000 }, /* R858 */ + { 0x0000, 0x0000 }, /* R859 */ + { 0x0000, 0x0000 }, /* R860 */ + { 0x0000, 0x0000 }, /* R861 */ + { 0x0000, 0x0000 }, /* R862 */ + { 0x0000, 0x0000 }, /* R863 */ + { 0x0000, 0x0000 }, /* R864 */ + { 0x0000, 0x0000 }, /* R865 */ + { 0x0000, 0x0000 }, /* R866 */ + { 0x0000, 0x0000 }, /* R867 */ + { 0x0000, 0x0000 }, /* R868 */ + { 0x0000, 0x0000 }, /* R869 */ + { 0x0000, 0x0000 }, /* R870 */ + { 0x0000, 0x0000 }, /* R871 */ + { 0x0000, 0x0000 }, /* R872 */ + { 0x0000, 0x0000 }, /* R873 */ + { 0x0000, 0x0000 }, /* R874 */ + { 0x0000, 0x0000 }, /* R875 */ + { 0x0000, 0x0000 }, /* R876 */ + { 0x0000, 0x0000 }, /* R877 */ + { 0x0000, 0x0000 }, /* R878 */ + { 0x0000, 0x0000 }, /* R879 */ + { 0x0000, 0x0000 }, /* R880 */ + { 0x0000, 0x0000 }, /* R881 */ + { 0x0000, 0x0000 }, /* R882 */ + { 0x0000, 0x0000 }, /* R883 */ + { 0x0000, 0x0000 }, /* R884 */ + { 0x0000, 0x0000 }, /* R885 */ + { 0x0000, 0x0000 }, /* R886 */ + { 0x0000, 0x0000 }, /* R887 */ + { 0x0000, 0x0000 }, /* R888 */ + { 0x0000, 0x0000 }, /* R889 */ + { 0x0000, 0x0000 }, /* R890 */ + { 0x0000, 0x0000 }, /* R891 */ + { 0x0000, 0x0000 }, /* R892 */ + { 0x0000, 0x0000 }, /* R893 */ + { 0x0000, 0x0000 }, /* R894 */ + { 0x0000, 0x0000 }, /* R895 */ + { 0x0000, 0x0000 }, /* R896 */ + { 0x0000, 0x0000 }, /* R897 */ + { 0x0000, 0x0000 }, /* R898 */ + { 0x0000, 0x0000 }, /* R899 */ + { 0x0000, 0x0000 }, /* R900 */ + { 0x0000, 0x0000 }, /* R901 */ + { 0x0000, 0x0000 }, /* R902 */ + { 0x0000, 0x0000 }, /* R903 */ + { 0x0000, 0x0000 }, /* R904 */ + { 0x0000, 0x0000 }, /* R905 */ + { 0x0000, 0x0000 }, /* R906 */ + { 0x0000, 0x0000 }, /* R907 */ + { 0x0000, 0x0000 }, /* R908 */ + { 0x0000, 0x0000 }, /* R909 */ + { 0x0000, 0x0000 }, /* R910 */ + { 0x0000, 0x0000 }, /* R911 */ + { 0x0000, 0x0000 }, /* R912 */ + { 0x0000, 0x0000 }, /* R913 */ + { 0x0000, 0x0000 }, /* R914 */ + { 0x0000, 0x0000 }, /* R915 */ + { 0x0000, 0x0000 }, /* R916 */ + { 0x0000, 0x0000 }, /* R917 */ + { 0x0000, 0x0000 }, /* R918 */ + { 0x0000, 0x0000 }, /* R919 */ + { 0x0000, 0x0000 }, /* R920 */ + { 0x0000, 0x0000 }, /* R921 */ + { 0x0000, 0x0000 }, /* R922 */ + { 0x0000, 0x0000 }, /* R923 */ + { 0x0000, 0x0000 }, /* R924 */ + { 0x0000, 0x0000 }, /* R925 */ + { 0x0000, 0x0000 }, /* R926 */ + { 0x0000, 0x0000 }, /* R927 */ + { 0x0000, 0x0000 }, /* R928 */ + { 0x0000, 0x0000 }, /* R929 */ + { 0x0000, 0x0000 }, /* R930 */ + { 0x0000, 0x0000 }, /* R931 */ + { 0x0000, 0x0000 }, /* R932 */ + { 0x0000, 0x0000 }, /* R933 */ + { 0x0000, 0x0000 }, /* R934 */ + { 0x0000, 0x0000 }, /* R935 */ + { 0x0000, 0x0000 }, /* R936 */ + { 0x0000, 0x0000 }, /* R937 */ + { 0x0000, 0x0000 }, /* R938 */ + { 0x0000, 0x0000 }, /* R939 */ + { 0x0000, 0x0000 }, /* R940 */ + { 0x0000, 0x0000 }, /* R941 */ + { 0x0000, 0x0000 }, /* R942 */ + { 0x0000, 0x0000 }, /* R943 */ + { 0x0000, 0x0000 }, /* R944 */ + { 0x0000, 0x0000 }, /* R945 */ + { 0x0000, 0x0000 }, /* R946 */ + { 0x0000, 0x0000 }, /* R947 */ + { 0x0000, 0x0000 }, /* R948 */ + { 0x0000, 0x0000 }, /* R949 */ + { 0x0000, 0x0000 }, /* R950 */ + { 0x0000, 0x0000 }, /* R951 */ + { 0x0000, 0x0000 }, /* R952 */ + { 0x0000, 0x0000 }, /* R953 */ + { 0x0000, 0x0000 }, /* R954 */ + { 0x0000, 0x0000 }, /* R955 */ + { 0x0000, 0x0000 }, /* R956 */ + { 0x0000, 0x0000 }, /* R957 */ + { 0x0000, 0x0000 }, /* R958 */ + { 0x0000, 0x0000 }, /* R959 */ + { 0x0000, 0x0000 }, /* R960 */ + { 0x0000, 0x0000 }, /* R961 */ + { 0x0000, 0x0000 }, /* R962 */ + { 0x0000, 0x0000 }, /* R963 */ + { 0x0000, 0x0000 }, /* R964 */ + { 0x0000, 0x0000 }, /* R965 */ + { 0x0000, 0x0000 }, /* R966 */ + { 0x0000, 0x0000 }, /* R967 */ + { 0x0000, 0x0000 }, /* R968 */ + { 0x0000, 0x0000 }, /* R969 */ + { 0x0000, 0x0000 }, /* R970 */ + { 0x0000, 0x0000 }, /* R971 */ + { 0x0000, 0x0000 }, /* R972 */ + { 0x0000, 0x0000 }, /* R973 */ + { 0x0000, 0x0000 }, /* R974 */ + { 0x0000, 0x0000 }, /* R975 */ + { 0x0000, 0x0000 }, /* R976 */ + { 0x0000, 0x0000 }, /* R977 */ + { 0x0000, 0x0000 }, /* R978 */ + { 0x0000, 0x0000 }, /* R979 */ + { 0x0000, 0x0000 }, /* R980 */ + { 0x0000, 0x0000 }, /* R981 */ + { 0x0000, 0x0000 }, /* R982 */ + { 0x0000, 0x0000 }, /* R983 */ + { 0x0000, 0x0000 }, /* R984 */ + { 0x0000, 0x0000 }, /* R985 */ + { 0x0000, 0x0000 }, /* R986 */ + { 0x0000, 0x0000 }, /* R987 */ + { 0x0000, 0x0000 }, /* R988 */ + { 0x0000, 0x0000 }, /* R989 */ + { 0x0000, 0x0000 }, /* R990 */ + { 0x0000, 0x0000 }, /* R991 */ + { 0x0000, 0x0000 }, /* R992 */ + { 0x0000, 0x0000 }, /* R993 */ + { 0x0000, 0x0000 }, /* R994 */ + { 0x0000, 0x0000 }, /* R995 */ + { 0x0000, 0x0000 }, /* R996 */ + { 0x0000, 0x0000 }, /* R997 */ + { 0x0000, 0x0000 }, /* R998 */ + { 0x0000, 0x0000 }, /* R999 */ + { 0x0000, 0x0000 }, /* R1000 */ + { 0x0000, 0x0000 }, /* R1001 */ + { 0x0000, 0x0000 }, /* R1002 */ + { 0x0000, 0x0000 }, /* R1003 */ + { 0x0000, 0x0000 }, /* R1004 */ + { 0x0000, 0x0000 }, /* R1005 */ + { 0x0000, 0x0000 }, /* R1006 */ + { 0x0000, 0x0000 }, /* R1007 */ + { 0x0000, 0x0000 }, /* R1008 */ + { 0x0000, 0x0000 }, /* R1009 */ + { 0x0000, 0x0000 }, /* R1010 */ + { 0x0000, 0x0000 }, /* R1011 */ + { 0x0000, 0x0000 }, /* R1012 */ + { 0x0000, 0x0000 }, /* R1013 */ + { 0x0000, 0x0000 }, /* R1014 */ + { 0x0000, 0x0000 }, /* R1015 */ + { 0x0000, 0x0000 }, /* R1016 */ + { 0x0000, 0x0000 }, /* R1017 */ + { 0x0000, 0x0000 }, /* R1018 */ + { 0x0000, 0x0000 }, /* R1019 */ + { 0x0000, 0x0000 }, /* R1020 */ + { 0x0000, 0x0000 }, /* R1021 */ + { 0x0000, 0x0000 }, /* R1022 */ + { 0x0000, 0x0000 }, /* R1023 */ + { 0x00FF, 0x01FF }, /* R1024 - AIF1 ADC1 Left Volume */ + { 0x00FF, 0x01FF }, /* R1025 - AIF1 ADC1 Right Volume */ + { 0x00FF, 0x01FF }, /* R1026 - AIF1 DAC1 Left Volume */ + { 0x00FF, 0x01FF }, /* R1027 - AIF1 DAC1 Right Volume */ + { 0x00FF, 0x01FF }, /* R1028 - AIF1 ADC2 Left Volume */ + { 0x00FF, 0x01FF }, /* R1029 - AIF1 ADC2 Right Volume */ + { 0x00FF, 0x01FF }, /* R1030 - AIF1 DAC2 Left Volume */ + { 0x00FF, 0x01FF }, /* R1031 - AIF1 DAC2 Right Volume */ + { 0x0000, 0x0000 }, /* R1032 */ + { 0x0000, 0x0000 }, /* R1033 */ + { 0x0000, 0x0000 }, /* R1034 */ + { 0x0000, 0x0000 }, /* R1035 */ + { 0x0000, 0x0000 }, /* R1036 */ + { 0x0000, 0x0000 }, /* R1037 */ + { 0x0000, 0x0000 }, /* R1038 */ + { 0x0000, 0x0000 }, /* R1039 */ + { 0xF800, 0xF800 }, /* R1040 - AIF1 ADC1 Filters */ + { 0x7800, 0x7800 }, /* R1041 - AIF1 ADC2 Filters */ + { 0x0000, 0x0000 }, /* R1042 */ + { 0x0000, 0x0000 }, /* R1043 */ + { 0x0000, 0x0000 }, /* R1044 */ + { 0x0000, 0x0000 }, /* R1045 */ + { 0x0000, 0x0000 }, /* R1046 */ + { 0x0000, 0x0000 }, /* R1047 */ + { 0x0000, 0x0000 }, /* R1048 */ + { 0x0000, 0x0000 }, /* R1049 */ + { 0x0000, 0x0000 }, /* R1050 */ + { 0x0000, 0x0000 }, /* R1051 */ + { 0x0000, 0x0000 }, /* R1052 */ + { 0x0000, 0x0000 }, /* R1053 */ + { 0x0000, 0x0000 }, /* R1054 */ + { 0x0000, 0x0000 }, /* R1055 */ + { 0x02B6, 0x02B6 }, /* R1056 - AIF1 DAC1 Filters (1) */ + { 0x3F00, 0x3F00 }, /* R1057 - AIF1 DAC1 Filters (2) */ + { 0x02B6, 0x02B6 }, /* R1058 - AIF1 DAC2 Filters (1) */ + { 0x3F00, 0x3F00 }, /* R1059 - AIF1 DAC2 Filters (2) */ + { 0x0000, 0x0000 }, /* R1060 */ + { 0x0000, 0x0000 }, /* R1061 */ + { 0x0000, 0x0000 }, /* R1062 */ + { 0x0000, 0x0000 }, /* R1063 */ + { 0x0000, 0x0000 }, /* R1064 */ + { 0x0000, 0x0000 }, /* R1065 */ + { 0x0000, 0x0000 }, /* R1066 */ + { 0x0000, 0x0000 }, /* R1067 */ + { 0x0000, 0x0000 }, /* R1068 */ + { 0x0000, 0x0000 }, /* R1069 */ + { 0x0000, 0x0000 }, /* R1070 */ + { 0x0000, 0x0000 }, /* R1071 */ + { 0x0000, 0x0000 }, /* R1072 */ + { 0x0000, 0x0000 }, /* R1073 */ + { 0x0000, 0x0000 }, /* R1074 */ + { 0x0000, 0x0000 }, /* R1075 */ + { 0x0000, 0x0000 }, /* R1076 */ + { 0x0000, 0x0000 }, /* R1077 */ + { 0x0000, 0x0000 }, /* R1078 */ + { 0x0000, 0x0000 }, /* R1079 */ + { 0x0000, 0x0000 }, /* R1080 */ + { 0x0000, 0x0000 }, /* R1081 */ + { 0x0000, 0x0000 }, /* R1082 */ + { 0x0000, 0x0000 }, /* R1083 */ + { 0x0000, 0x0000 }, /* R1084 */ + { 0x0000, 0x0000 }, /* R1085 */ + { 0x0000, 0x0000 }, /* R1086 */ + { 0x0000, 0x0000 }, /* R1087 */ + { 0xFFFF, 0xFFFF }, /* R1088 - AIF1 DRC1 (1) */ + { 0x1FFF, 0x1FFF }, /* R1089 - AIF1 DRC1 (2) */ + { 0xFFFF, 0xFFFF }, /* R1090 - AIF1 DRC1 (3) */ + { 0x07FF, 0x07FF }, /* R1091 - AIF1 DRC1 (4) */ + { 0x03FF, 0x03FF }, /* R1092 - AIF1 DRC1 (5) */ + { 0x0000, 0x0000 }, /* R1093 */ + { 0x0000, 0x0000 }, /* R1094 */ + { 0x0000, 0x0000 }, /* R1095 */ + { 0x0000, 0x0000 }, /* R1096 */ + { 0x0000, 0x0000 }, /* R1097 */ + { 0x0000, 0x0000 }, /* R1098 */ + { 0x0000, 0x0000 }, /* R1099 */ + { 0x0000, 0x0000 }, /* R1100 */ + { 0x0000, 0x0000 }, /* R1101 */ + { 0x0000, 0x0000 }, /* R1102 */ + { 0x0000, 0x0000 }, /* R1103 */ + { 0xFFFF, 0xFFFF }, /* R1104 - AIF1 DRC2 (1) */ + { 0x1FFF, 0x1FFF }, /* R1105 - AIF1 DRC2 (2) */ + { 0xFFFF, 0xFFFF }, /* R1106 - AIF1 DRC2 (3) */ + { 0x07FF, 0x07FF }, /* R1107 - AIF1 DRC2 (4) */ + { 0x03FF, 0x03FF }, /* R1108 - AIF1 DRC2 (5) */ + { 0x0000, 0x0000 }, /* R1109 */ + { 0x0000, 0x0000 }, /* R1110 */ + { 0x0000, 0x0000 }, /* R1111 */ + { 0x0000, 0x0000 }, /* R1112 */ + { 0x0000, 0x0000 }, /* R1113 */ + { 0x0000, 0x0000 }, /* R1114 */ + { 0x0000, 0x0000 }, /* R1115 */ + { 0x0000, 0x0000 }, /* R1116 */ + { 0x0000, 0x0000 }, /* R1117 */ + { 0x0000, 0x0000 }, /* R1118 */ + { 0x0000, 0x0000 }, /* R1119 */ + { 0x0000, 0x0000 }, /* R1120 */ + { 0x0000, 0x0000 }, /* R1121 */ + { 0x0000, 0x0000 }, /* R1122 */ + { 0x0000, 0x0000 }, /* R1123 */ + { 0x0000, 0x0000 }, /* R1124 */ + { 0x0000, 0x0000 }, /* R1125 */ + { 0x0000, 0x0000 }, /* R1126 */ + { 0x0000, 0x0000 }, /* R1127 */ + { 0x0000, 0x0000 }, /* R1128 */ + { 0x0000, 0x0000 }, /* R1129 */ + { 0x0000, 0x0000 }, /* R1130 */ + { 0x0000, 0x0000 }, /* R1131 */ + { 0x0000, 0x0000 }, /* R1132 */ + { 0x0000, 0x0000 }, /* R1133 */ + { 0x0000, 0x0000 }, /* R1134 */ + { 0x0000, 0x0000 }, /* R1135 */ + { 0x0000, 0x0000 }, /* R1136 */ + { 0x0000, 0x0000 }, /* R1137 */ + { 0x0000, 0x0000 }, /* R1138 */ + { 0x0000, 0x0000 }, /* R1139 */ + { 0x0000, 0x0000 }, /* R1140 */ + { 0x0000, 0x0000 }, /* R1141 */ + { 0x0000, 0x0000 }, /* R1142 */ + { 0x0000, 0x0000 }, /* R1143 */ + { 0x0000, 0x0000 }, /* R1144 */ + { 0x0000, 0x0000 }, /* R1145 */ + { 0x0000, 0x0000 }, /* R1146 */ + { 0x0000, 0x0000 }, /* R1147 */ + { 0x0000, 0x0000 }, /* R1148 */ + { 0x0000, 0x0000 }, /* R1149 */ + { 0x0000, 0x0000 }, /* R1150 */ + { 0x0000, 0x0000 }, /* R1151 */ + { 0xFFFF, 0xFFFF }, /* R1152 - AIF1 DAC1 EQ Gains (1) */ + { 0xFFC0, 0xFFC0 }, /* R1153 - AIF1 DAC1 EQ Gains (2) */ + { 0xFFFF, 0xFFFF }, /* R1154 - AIF1 DAC1 EQ Band 1 A */ + { 0xFFFF, 0xFFFF }, /* R1155 - AIF1 DAC1 EQ Band 1 B */ + { 0xFFFF, 0xFFFF }, /* R1156 - AIF1 DAC1 EQ Band 1 PG */ + { 0xFFFF, 0xFFFF }, /* R1157 - AIF1 DAC1 EQ Band 2 A */ + { 0xFFFF, 0xFFFF }, /* R1158 - AIF1 DAC1 EQ Band 2 B */ + { 0xFFFF, 0xFFFF }, /* R1159 - AIF1 DAC1 EQ Band 2 C */ + { 0xFFFF, 0xFFFF }, /* R1160 - AIF1 DAC1 EQ Band 2 PG */ + { 0xFFFF, 0xFFFF }, /* R1161 - AIF1 DAC1 EQ Band 3 A */ + { 0xFFFF, 0xFFFF }, /* R1162 - AIF1 DAC1 EQ Band 3 B */ + { 0xFFFF, 0xFFFF }, /* R1163 - AIF1 DAC1 EQ Band 3 C */ + { 0xFFFF, 0xFFFF }, /* R1164 - AIF1 DAC1 EQ Band 3 PG */ + { 0xFFFF, 0xFFFF }, /* R1165 - AIF1 DAC1 EQ Band 4 A */ + { 0xFFFF, 0xFFFF }, /* R1166 - AIF1 DAC1 EQ Band 4 B */ + { 0xFFFF, 0xFFFF }, /* R1167 - AIF1 DAC1 EQ Band 4 C */ + { 0xFFFF, 0xFFFF }, /* R1168 - AIF1 DAC1 EQ Band 4 PG */ + { 0xFFFF, 0xFFFF }, /* R1169 - AIF1 DAC1 EQ Band 5 A */ + { 0xFFFF, 0xFFFF }, /* R1170 - AIF1 DAC1 EQ Band 5 B */ + { 0xFFFF, 0xFFFF }, /* R1171 - AIF1 DAC1 EQ Band 5 PG */ + { 0x0000, 0x0000 }, /* R1172 */ + { 0x0000, 0x0000 }, /* R1173 */ + { 0x0000, 0x0000 }, /* R1174 */ + { 0x0000, 0x0000 }, /* R1175 */ + { 0x0000, 0x0000 }, /* R1176 */ + { 0x0000, 0x0000 }, /* R1177 */ + { 0x0000, 0x0000 }, /* R1178 */ + { 0x0000, 0x0000 }, /* R1179 */ + { 0x0000, 0x0000 }, /* R1180 */ + { 0x0000, 0x0000 }, /* R1181 */ + { 0x0000, 0x0000 }, /* R1182 */ + { 0x0000, 0x0000 }, /* R1183 */ + { 0xFFFF, 0xFFFF }, /* R1184 - AIF1 DAC2 EQ Gains (1) */ + { 0xFFC0, 0xFFC0 }, /* R1185 - AIF1 DAC2 EQ Gains (2) */ + { 0xFFFF, 0xFFFF }, /* R1186 - AIF1 DAC2 EQ Band 1 A */ + { 0xFFFF, 0xFFFF }, /* R1187 - AIF1 DAC2 EQ Band 1 B */ + { 0xFFFF, 0xFFFF }, /* R1188 - AIF1 DAC2 EQ Band 1 PG */ + { 0xFFFF, 0xFFFF }, /* R1189 - AIF1 DAC2 EQ Band 2 A */ + { 0xFFFF, 0xFFFF }, /* R1190 - AIF1 DAC2 EQ Band 2 B */ + { 0xFFFF, 0xFFFF }, /* R1191 - AIF1 DAC2 EQ Band 2 C */ + { 0xFFFF, 0xFFFF }, /* R1192 - AIF1 DAC2 EQ Band 2 PG */ + { 0xFFFF, 0xFFFF }, /* R1193 - AIF1 DAC2 EQ Band 3 A */ + { 0xFFFF, 0xFFFF }, /* R1194 - AIF1 DAC2 EQ Band 3 B */ + { 0xFFFF, 0xFFFF }, /* R1195 - AIF1 DAC2 EQ Band 3 C */ + { 0xFFFF, 0xFFFF }, /* R1196 - AIF1 DAC2 EQ Band 3 PG */ + { 0xFFFF, 0xFFFF }, /* R1197 - AIF1 DAC2 EQ Band 4 A */ + { 0xFFFF, 0xFFFF }, /* R1198 - AIF1 DAC2 EQ Band 4 B */ + { 0xFFFF, 0xFFFF }, /* R1199 - AIF1 DAC2 EQ Band 4 C */ + { 0xFFFF, 0xFFFF }, /* R1200 - AIF1 DAC2 EQ Band 4 PG */ + { 0xFFFF, 0xFFFF }, /* R1201 - AIF1 DAC2 EQ Band 5 A */ + { 0xFFFF, 0xFFFF }, /* R1202 - AIF1 DAC2 EQ Band 5 B */ + { 0xFFFF, 0xFFFF }, /* R1203 - AIF1 DAC2 EQ Band 5 PG */ + { 0x0000, 0x0000 }, /* R1204 */ + { 0x0000, 0x0000 }, /* R1205 */ + { 0x0000, 0x0000 }, /* R1206 */ + { 0x0000, 0x0000 }, /* R1207 */ + { 0x0000, 0x0000 }, /* R1208 */ + { 0x0000, 0x0000 }, /* R1209 */ + { 0x0000, 0x0000 }, /* R1210 */ + { 0x0000, 0x0000 }, /* R1211 */ + { 0x0000, 0x0000 }, /* R1212 */ + { 0x0000, 0x0000 }, /* R1213 */ + { 0x0000, 0x0000 }, /* R1214 */ + { 0x0000, 0x0000 }, /* R1215 */ + { 0x0000, 0x0000 }, /* R1216 */ + { 0x0000, 0x0000 }, /* R1217 */ + { 0x0000, 0x0000 }, /* R1218 */ + { 0x0000, 0x0000 }, /* R1219 */ + { 0x0000, 0x0000 }, /* R1220 */ + { 0x0000, 0x0000 }, /* R1221 */ + { 0x0000, 0x0000 }, /* R1222 */ + { 0x0000, 0x0000 }, /* R1223 */ + { 0x0000, 0x0000 }, /* R1224 */ + { 0x0000, 0x0000 }, /* R1225 */ + { 0x0000, 0x0000 }, /* R1226 */ + { 0x0000, 0x0000 }, /* R1227 */ + { 0x0000, 0x0000 }, /* R1228 */ + { 0x0000, 0x0000 }, /* R1229 */ + { 0x0000, 0x0000 }, /* R1230 */ + { 0x0000, 0x0000 }, /* R1231 */ + { 0x0000, 0x0000 }, /* R1232 */ + { 0x0000, 0x0000 }, /* R1233 */ + { 0x0000, 0x0000 }, /* R1234 */ + { 0x0000, 0x0000 }, /* R1235 */ + { 0x0000, 0x0000 }, /* R1236 */ + { 0x0000, 0x0000 }, /* R1237 */ + { 0x0000, 0x0000 }, /* R1238 */ + { 0x0000, 0x0000 }, /* R1239 */ + { 0x0000, 0x0000 }, /* R1240 */ + { 0x0000, 0x0000 }, /* R1241 */ + { 0x0000, 0x0000 }, /* R1242 */ + { 0x0000, 0x0000 }, /* R1243 */ + { 0x0000, 0x0000 }, /* R1244 */ + { 0x0000, 0x0000 }, /* R1245 */ + { 0x0000, 0x0000 }, /* R1246 */ + { 0x0000, 0x0000 }, /* R1247 */ + { 0x0000, 0x0000 }, /* R1248 */ + { 0x0000, 0x0000 }, /* R1249 */ + { 0x0000, 0x0000 }, /* R1250 */ + { 0x0000, 0x0000 }, /* R1251 */ + { 0x0000, 0x0000 }, /* R1252 */ + { 0x0000, 0x0000 }, /* R1253 */ + { 0x0000, 0x0000 }, /* R1254 */ + { 0x0000, 0x0000 }, /* R1255 */ + { 0x0000, 0x0000 }, /* R1256 */ + { 0x0000, 0x0000 }, /* R1257 */ + { 0x0000, 0x0000 }, /* R1258 */ + { 0x0000, 0x0000 }, /* R1259 */ + { 0x0000, 0x0000 }, /* R1260 */ + { 0x0000, 0x0000 }, /* R1261 */ + { 0x0000, 0x0000 }, /* R1262 */ + { 0x0000, 0x0000 }, /* R1263 */ + { 0x0000, 0x0000 }, /* R1264 */ + { 0x0000, 0x0000 }, /* R1265 */ + { 0x0000, 0x0000 }, /* R1266 */ + { 0x0000, 0x0000 }, /* R1267 */ + { 0x0000, 0x0000 }, /* R1268 */ + { 0x0000, 0x0000 }, /* R1269 */ + { 0x0000, 0x0000 }, /* R1270 */ + { 0x0000, 0x0000 }, /* R1271 */ + { 0x0000, 0x0000 }, /* R1272 */ + { 0x0000, 0x0000 }, /* R1273 */ + { 0x0000, 0x0000 }, /* R1274 */ + { 0x0000, 0x0000 }, /* R1275 */ + { 0x0000, 0x0000 }, /* R1276 */ + { 0x0000, 0x0000 }, /* R1277 */ + { 0x0000, 0x0000 }, /* R1278 */ + { 0x0000, 0x0000 }, /* R1279 */ + { 0x00FF, 0x01FF }, /* R1280 - AIF2 ADC Left Volume */ + { 0x00FF, 0x01FF }, /* R1281 - AIF2 ADC Right Volume */ + { 0x00FF, 0x01FF }, /* R1282 - AIF2 DAC Left Volume */ + { 0x00FF, 0x01FF }, /* R1283 - AIF2 DAC Right Volume */ + { 0x0000, 0x0000 }, /* R1284 */ + { 0x0000, 0x0000 }, /* R1285 */ + { 0x0000, 0x0000 }, /* R1286 */ + { 0x0000, 0x0000 }, /* R1287 */ + { 0x0000, 0x0000 }, /* R1288 */ + { 0x0000, 0x0000 }, /* R1289 */ + { 0x0000, 0x0000 }, /* R1290 */ + { 0x0000, 0x0000 }, /* R1291 */ + { 0x0000, 0x0000 }, /* R1292 */ + { 0x0000, 0x0000 }, /* R1293 */ + { 0x0000, 0x0000 }, /* R1294 */ + { 0x0000, 0x0000 }, /* R1295 */ + { 0xF800, 0xF800 }, /* R1296 - AIF2 ADC Filters */ + { 0x0000, 0x0000 }, /* R1297 */ + { 0x0000, 0x0000 }, /* R1298 */ + { 0x0000, 0x0000 }, /* R1299 */ + { 0x0000, 0x0000 }, /* R1300 */ + { 0x0000, 0x0000 }, /* R1301 */ + { 0x0000, 0x0000 }, /* R1302 */ + { 0x0000, 0x0000 }, /* R1303 */ + { 0x0000, 0x0000 }, /* R1304 */ + { 0x0000, 0x0000 }, /* R1305 */ + { 0x0000, 0x0000 }, /* R1306 */ + { 0x0000, 0x0000 }, /* R1307 */ + { 0x0000, 0x0000 }, /* R1308 */ + { 0x0000, 0x0000 }, /* R1309 */ + { 0x0000, 0x0000 }, /* R1310 */ + { 0x0000, 0x0000 }, /* R1311 */ + { 0x02B6, 0x02B6 }, /* R1312 - AIF2 DAC Filters (1) */ + { 0x3F00, 0x3F00 }, /* R1313 - AIF2 DAC Filters (2) */ + { 0x0000, 0x0000 }, /* R1314 */ + { 0x0000, 0x0000 }, /* R1315 */ + { 0x0000, 0x0000 }, /* R1316 */ + { 0x0000, 0x0000 }, /* R1317 */ + { 0x0000, 0x0000 }, /* R1318 */ + { 0x0000, 0x0000 }, /* R1319 */ + { 0x0000, 0x0000 }, /* R1320 */ + { 0x0000, 0x0000 }, /* R1321 */ + { 0x0000, 0x0000 }, /* R1322 */ + { 0x0000, 0x0000 }, /* R1323 */ + { 0x0000, 0x0000 }, /* R1324 */ + { 0x0000, 0x0000 }, /* R1325 */ + { 0x0000, 0x0000 }, /* R1326 */ + { 0x0000, 0x0000 }, /* R1327 */ + { 0x0000, 0x0000 }, /* R1328 */ + { 0x0000, 0x0000 }, /* R1329 */ + { 0x0000, 0x0000 }, /* R1330 */ + { 0x0000, 0x0000 }, /* R1331 */ + { 0x0000, 0x0000 }, /* R1332 */ + { 0x0000, 0x0000 }, /* R1333 */ + { 0x0000, 0x0000 }, /* R1334 */ + { 0x0000, 0x0000 }, /* R1335 */ + { 0x0000, 0x0000 }, /* R1336 */ + { 0x0000, 0x0000 }, /* R1337 */ + { 0x0000, 0x0000 }, /* R1338 */ + { 0x0000, 0x0000 }, /* R1339 */ + { 0x0000, 0x0000 }, /* R1340 */ + { 0x0000, 0x0000 }, /* R1341 */ + { 0x0000, 0x0000 }, /* R1342 */ + { 0x0000, 0x0000 }, /* R1343 */ + { 0xFFFF, 0xFFFF }, /* R1344 - AIF2 DRC (1) */ + { 0x1FFF, 0x1FFF }, /* R1345 - AIF2 DRC (2) */ + { 0xFFFF, 0xFFFF }, /* R1346 - AIF2 DRC (3) */ + { 0x07FF, 0x07FF }, /* R1347 - AIF2 DRC (4) */ + { 0x03FF, 0x03FF }, /* R1348 - AIF2 DRC (5) */ + { 0x0000, 0x0000 }, /* R1349 */ + { 0x0000, 0x0000 }, /* R1350 */ + { 0x0000, 0x0000 }, /* R1351 */ + { 0x0000, 0x0000 }, /* R1352 */ + { 0x0000, 0x0000 }, /* R1353 */ + { 0x0000, 0x0000 }, /* R1354 */ + { 0x0000, 0x0000 }, /* R1355 */ + { 0x0000, 0x0000 }, /* R1356 */ + { 0x0000, 0x0000 }, /* R1357 */ + { 0x0000, 0x0000 }, /* R1358 */ + { 0x0000, 0x0000 }, /* R1359 */ + { 0x0000, 0x0000 }, /* R1360 */ + { 0x0000, 0x0000 }, /* R1361 */ + { 0x0000, 0x0000 }, /* R1362 */ + { 0x0000, 0x0000 }, /* R1363 */ + { 0x0000, 0x0000 }, /* R1364 */ + { 0x0000, 0x0000 }, /* R1365 */ + { 0x0000, 0x0000 }, /* R1366 */ + { 0x0000, 0x0000 }, /* R1367 */ + { 0x0000, 0x0000 }, /* R1368 */ + { 0x0000, 0x0000 }, /* R1369 */ + { 0x0000, 0x0000 }, /* R1370 */ + { 0x0000, 0x0000 }, /* R1371 */ + { 0x0000, 0x0000 }, /* R1372 */ + { 0x0000, 0x0000 }, /* R1373 */ + { 0x0000, 0x0000 }, /* R1374 */ + { 0x0000, 0x0000 }, /* R1375 */ + { 0x0000, 0x0000 }, /* R1376 */ + { 0x0000, 0x0000 }, /* R1377 */ + { 0x0000, 0x0000 }, /* R1378 */ + { 0x0000, 0x0000 }, /* R1379 */ + { 0x0000, 0x0000 }, /* R1380 */ + { 0x0000, 0x0000 }, /* R1381 */ + { 0x0000, 0x0000 }, /* R1382 */ + { 0x0000, 0x0000 }, /* R1383 */ + { 0x0000, 0x0000 }, /* R1384 */ + { 0x0000, 0x0000 }, /* R1385 */ + { 0x0000, 0x0000 }, /* R1386 */ + { 0x0000, 0x0000 }, /* R1387 */ + { 0x0000, 0x0000 }, /* R1388 */ + { 0x0000, 0x0000 }, /* R1389 */ + { 0x0000, 0x0000 }, /* R1390 */ + { 0x0000, 0x0000 }, /* R1391 */ + { 0x0000, 0x0000 }, /* R1392 */ + { 0x0000, 0x0000 }, /* R1393 */ + { 0x0000, 0x0000 }, /* R1394 */ + { 0x0000, 0x0000 }, /* R1395 */ + { 0x0000, 0x0000 }, /* R1396 */ + { 0x0000, 0x0000 }, /* R1397 */ + { 0x0000, 0x0000 }, /* R1398 */ + { 0x0000, 0x0000 }, /* R1399 */ + { 0x0000, 0x0000 }, /* R1400 */ + { 0x0000, 0x0000 }, /* R1401 */ + { 0x0000, 0x0000 }, /* R1402 */ + { 0x0000, 0x0000 }, /* R1403 */ + { 0x0000, 0x0000 }, /* R1404 */ + { 0x0000, 0x0000 }, /* R1405 */ + { 0x0000, 0x0000 }, /* R1406 */ + { 0x0000, 0x0000 }, /* R1407 */ + { 0xFFFF, 0xFFFF }, /* R1408 - AIF2 EQ Gains (1) */ + { 0xFFC0, 0xFFC0 }, /* R1409 - AIF2 EQ Gains (2) */ + { 0xFFFF, 0xFFFF }, /* R1410 - AIF2 EQ Band 1 A */ + { 0xFFFF, 0xFFFF }, /* R1411 - AIF2 EQ Band 1 B */ + { 0xFFFF, 0xFFFF }, /* R1412 - AIF2 EQ Band 1 PG */ + { 0xFFFF, 0xFFFF }, /* R1413 - AIF2 EQ Band 2 A */ + { 0xFFFF, 0xFFFF }, /* R1414 - AIF2 EQ Band 2 B */ + { 0xFFFF, 0xFFFF }, /* R1415 - AIF2 EQ Band 2 C */ + { 0xFFFF, 0xFFFF }, /* R1416 - AIF2 EQ Band 2 PG */ + { 0xFFFF, 0xFFFF }, /* R1417 - AIF2 EQ Band 3 A */ + { 0xFFFF, 0xFFFF }, /* R1418 - AIF2 EQ Band 3 B */ + { 0xFFFF, 0xFFFF }, /* R1419 - AIF2 EQ Band 3 C */ + { 0xFFFF, 0xFFFF }, /* R1420 - AIF2 EQ Band 3 PG */ + { 0xFFFF, 0xFFFF }, /* R1421 - AIF2 EQ Band 4 A */ + { 0xFFFF, 0xFFFF }, /* R1422 - AIF2 EQ Band 4 B */ + { 0xFFFF, 0xFFFF }, /* R1423 - AIF2 EQ Band 4 C */ + { 0xFFFF, 0xFFFF }, /* R1424 - AIF2 EQ Band 4 PG */ + { 0xFFFF, 0xFFFF }, /* R1425 - AIF2 EQ Band 5 A */ + { 0xFFFF, 0xFFFF }, /* R1426 - AIF2 EQ Band 5 B */ + { 0xFFFF, 0xFFFF }, /* R1427 - AIF2 EQ Band 5 PG */ + { 0x0000, 0x0000 }, /* R1428 */ + { 0x0000, 0x0000 }, /* R1429 */ + { 0x0000, 0x0000 }, /* R1430 */ + { 0x0000, 0x0000 }, /* R1431 */ + { 0x0000, 0x0000 }, /* R1432 */ + { 0x0000, 0x0000 }, /* R1433 */ + { 0x0000, 0x0000 }, /* R1434 */ + { 0x0000, 0x0000 }, /* R1435 */ + { 0x0000, 0x0000 }, /* R1436 */ + { 0x0000, 0x0000 }, /* R1437 */ + { 0x0000, 0x0000 }, /* R1438 */ + { 0x0000, 0x0000 }, /* R1439 */ + { 0x0000, 0x0000 }, /* R1440 */ + { 0x0000, 0x0000 }, /* R1441 */ + { 0x0000, 0x0000 }, /* R1442 */ + { 0x0000, 0x0000 }, /* R1443 */ + { 0x0000, 0x0000 }, /* R1444 */ + { 0x0000, 0x0000 }, /* R1445 */ + { 0x0000, 0x0000 }, /* R1446 */ + { 0x0000, 0x0000 }, /* R1447 */ + { 0x0000, 0x0000 }, /* R1448 */ + { 0x0000, 0x0000 }, /* R1449 */ + { 0x0000, 0x0000 }, /* R1450 */ + { 0x0000, 0x0000 }, /* R1451 */ + { 0x0000, 0x0000 }, /* R1452 */ + { 0x0000, 0x0000 }, /* R1453 */ + { 0x0000, 0x0000 }, /* R1454 */ + { 0x0000, 0x0000 }, /* R1455 */ + { 0x0000, 0x0000 }, /* R1456 */ + { 0x0000, 0x0000 }, /* R1457 */ + { 0x0000, 0x0000 }, /* R1458 */ + { 0x0000, 0x0000 }, /* R1459 */ + { 0x0000, 0x0000 }, /* R1460 */ + { 0x0000, 0x0000 }, /* R1461 */ + { 0x0000, 0x0000 }, /* R1462 */ + { 0x0000, 0x0000 }, /* R1463 */ + { 0x0000, 0x0000 }, /* R1464 */ + { 0x0000, 0x0000 }, /* R1465 */ + { 0x0000, 0x0000 }, /* R1466 */ + { 0x0000, 0x0000 }, /* R1467 */ + { 0x0000, 0x0000 }, /* R1468 */ + { 0x0000, 0x0000 }, /* R1469 */ + { 0x0000, 0x0000 }, /* R1470 */ + { 0x0000, 0x0000 }, /* R1471 */ + { 0x0000, 0x0000 }, /* R1472 */ + { 0x0000, 0x0000 }, /* R1473 */ + { 0x0000, 0x0000 }, /* R1474 */ + { 0x0000, 0x0000 }, /* R1475 */ + { 0x0000, 0x0000 }, /* R1476 */ + { 0x0000, 0x0000 }, /* R1477 */ + { 0x0000, 0x0000 }, /* R1478 */ + { 0x0000, 0x0000 }, /* R1479 */ + { 0x0000, 0x0000 }, /* R1480 */ + { 0x0000, 0x0000 }, /* R1481 */ + { 0x0000, 0x0000 }, /* R1482 */ + { 0x0000, 0x0000 }, /* R1483 */ + { 0x0000, 0x0000 }, /* R1484 */ + { 0x0000, 0x0000 }, /* R1485 */ + { 0x0000, 0x0000 }, /* R1486 */ + { 0x0000, 0x0000 }, /* R1487 */ + { 0x0000, 0x0000 }, /* R1488 */ + { 0x0000, 0x0000 }, /* R1489 */ + { 0x0000, 0x0000 }, /* R1490 */ + { 0x0000, 0x0000 }, /* R1491 */ + { 0x0000, 0x0000 }, /* R1492 */ + { 0x0000, 0x0000 }, /* R1493 */ + { 0x0000, 0x0000 }, /* R1494 */ + { 0x0000, 0x0000 }, /* R1495 */ + { 0x0000, 0x0000 }, /* R1496 */ + { 0x0000, 0x0000 }, /* R1497 */ + { 0x0000, 0x0000 }, /* R1498 */ + { 0x0000, 0x0000 }, /* R1499 */ + { 0x0000, 0x0000 }, /* R1500 */ + { 0x0000, 0x0000 }, /* R1501 */ + { 0x0000, 0x0000 }, /* R1502 */ + { 0x0000, 0x0000 }, /* R1503 */ + { 0x0000, 0x0000 }, /* R1504 */ + { 0x0000, 0x0000 }, /* R1505 */ + { 0x0000, 0x0000 }, /* R1506 */ + { 0x0000, 0x0000 }, /* R1507 */ + { 0x0000, 0x0000 }, /* R1508 */ + { 0x0000, 0x0000 }, /* R1509 */ + { 0x0000, 0x0000 }, /* R1510 */ + { 0x0000, 0x0000 }, /* R1511 */ + { 0x0000, 0x0000 }, /* R1512 */ + { 0x0000, 0x0000 }, /* R1513 */ + { 0x0000, 0x0000 }, /* R1514 */ + { 0x0000, 0x0000 }, /* R1515 */ + { 0x0000, 0x0000 }, /* R1516 */ + { 0x0000, 0x0000 }, /* R1517 */ + { 0x0000, 0x0000 }, /* R1518 */ + { 0x0000, 0x0000 }, /* R1519 */ + { 0x0000, 0x0000 }, /* R1520 */ + { 0x0000, 0x0000 }, /* R1521 */ + { 0x0000, 0x0000 }, /* R1522 */ + { 0x0000, 0x0000 }, /* R1523 */ + { 0x0000, 0x0000 }, /* R1524 */ + { 0x0000, 0x0000 }, /* R1525 */ + { 0x0000, 0x0000 }, /* R1526 */ + { 0x0000, 0x0000 }, /* R1527 */ + { 0x0000, 0x0000 }, /* R1528 */ + { 0x0000, 0x0000 }, /* R1529 */ + { 0x0000, 0x0000 }, /* R1530 */ + { 0x0000, 0x0000 }, /* R1531 */ + { 0x0000, 0x0000 }, /* R1532 */ + { 0x0000, 0x0000 }, /* R1533 */ + { 0x0000, 0x0000 }, /* R1534 */ + { 0x0000, 0x0000 }, /* R1535 */ + { 0x01EF, 0x01EF }, /* R1536 - DAC1 Mixer Volumes */ + { 0x0037, 0x0037 }, /* R1537 - DAC1 Left Mixer Routing */ + { 0x0037, 0x0037 }, /* R1538 - DAC1 Right Mixer Routing */ + { 0x01EF, 0x01EF }, /* R1539 - DAC2 Mixer Volumes */ + { 0x0037, 0x0037 }, /* R1540 - DAC2 Left Mixer Routing */ + { 0x0037, 0x0037 }, /* R1541 - DAC2 Right Mixer Routing */ + { 0x0003, 0x0003 }, /* R1542 - AIF1 ADC1 Left Mixer Routing */ + { 0x0003, 0x0003 }, /* R1543 - AIF1 ADC1 Right Mixer Routing */ + { 0x0003, 0x0003 }, /* R1544 - AIF1 ADC2 Left Mixer Routing */ + { 0x0003, 0x0003 }, /* R1545 - AIF1 ADC2 Right mixer Routing */ + { 0x0000, 0x0000 }, /* R1546 */ + { 0x0000, 0x0000 }, /* R1547 */ + { 0x0000, 0x0000 }, /* R1548 */ + { 0x0000, 0x0000 }, /* R1549 */ + { 0x0000, 0x0000 }, /* R1550 */ + { 0x0000, 0x0000 }, /* R1551 */ + { 0x02FF, 0x03FF }, /* R1552 - DAC1 Left Volume */ + { 0x02FF, 0x03FF }, /* R1553 - DAC1 Right Volume */ + { 0x02FF, 0x03FF }, /* R1554 - DAC2 Left Volume */ + { 0x02FF, 0x03FF }, /* R1555 - DAC2 Right Volume */ + { 0x0003, 0x0003 }, /* R1556 - DAC Softmute */ + { 0x0000, 0x0000 }, /* R1557 */ + { 0x0000, 0x0000 }, /* R1558 */ + { 0x0000, 0x0000 }, /* R1559 */ + { 0x0000, 0x0000 }, /* R1560 */ + { 0x0000, 0x0000 }, /* R1561 */ + { 0x0000, 0x0000 }, /* R1562 */ + { 0x0000, 0x0000 }, /* R1563 */ + { 0x0000, 0x0000 }, /* R1564 */ + { 0x0000, 0x0000 }, /* R1565 */ + { 0x0000, 0x0000 }, /* R1566 */ + { 0x0000, 0x0000 }, /* R1567 */ + { 0x0003, 0x0003 }, /* R1568 - Oversampling */ + { 0x03C3, 0x03C3 }, /* R1569 - Sidetone */ }; static int wm8994_readable(unsigned int reg) -- cgit v1.1 From a34712391a66260e442a9ab1eb7edb22a2d0ca3c Mon Sep 17 00:00:00 2001 From: Kuninori Morimoto Date: Fri, 15 Oct 2010 14:23:18 +0900 Subject: ASoC: ak4642: make sure name of register/value This patch replace magic code with defined name, and remove unnecessary settings which set default value Signed-off-by: Kuninori Morimoto Acked-by: Liam Girdwood Signed-off-by: Mark Brown --- sound/soc/codecs/ak4642.c | 64 ++++++++++++++++++++++++++++++++++------------- 1 file changed, 46 insertions(+), 18 deletions(-) (limited to 'sound') diff --git a/sound/soc/codecs/ak4642.c b/sound/soc/codecs/ak4642.c index 009068f..90c90b7 100644 --- a/sound/soc/codecs/ak4642.c +++ b/sound/soc/codecs/ak4642.c @@ -72,6 +72,12 @@ #define AK4642_CACHEREGNUM 0x25 +/* PW_MGMT1*/ +#define PMVCM (1 << 6) /* VCOM Power Management */ +#define PMMIN (1 << 5) /* MIN Input Power Management */ +#define PMDAC (1 << 2) /* DAC Power Management */ +#define PMADL (1 << 0) /* MIC Amp Lch and ADC Lch Power Management */ + /* PW_MGMT2 */ #define HPMTN (1 << 6) #define PMHPL (1 << 5) @@ -83,6 +89,23 @@ #define PMHP_MASK (PMHPL | PMHPR) #define PMHP PMHP_MASK +/* PW_MGMT3 */ +#define PMADR (1 << 0) /* MIC L / ADC R Power Management */ + +/* SG_SL1 */ +#define MINS (1 << 6) /* Switch from MIN to Speaker */ +#define DACL (1 << 4) /* Switch from DAC to Stereo or Receiver */ +#define PMMP (1 << 2) /* MPWR pin Power Management */ +#define MGAIN0 (1 << 0) /* MIC amp gain*/ + +/* TIMER */ +#define ZTM(param) ((param & 0x3) << 4) /* ALC Zoro Crossing TimeOut */ +#define WTM(param) (((param & 0x4) << 4) | ((param & 0x3) << 2)) + +/* ALC_CTL1 */ +#define ALC (1 << 5) /* ALC Enable */ +#define LMTH0 (1 << 0) /* ALC Limiter / Recovery Level */ + /* MD_CTL1 */ #define PLL3 (1 << 7) #define PLL2 (1 << 6) @@ -100,6 +123,11 @@ #define FS3 (1 << 5) #define FS_MASK (FS0 | FS1 | FS2 | FS3) +/* MD_CTL3 */ +#define BST1 (1 << 3) + +/* MD_CTL4 */ +#define DACH (1 << 0) /* * Playback Volume (table 39) @@ -216,11 +244,12 @@ static int ak4642_dai_startup(struct snd_pcm_substream *substream, * This operation came from example code of * "ASAHI KASEI AK4642" (japanese) manual p97. */ - ak4642_write(codec, 0x0f, 0x09); - ak4642_write(codec, 0x0e, 0x19); - ak4642_write(codec, 0x09, 0x91); - ak4642_write(codec, 0x0c, 0x91); - snd_soc_update_bits(codec, 0x00, 0x64, 0x64); + snd_soc_update_bits(codec, MD_CTL4, DACH, DACH); + snd_soc_update_bits(codec, MD_CTL3, BST1, BST1); + ak4642_write(codec, L_IVC, 0x91); /* volume */ + ak4642_write(codec, R_IVC, 0x91); /* volume */ + snd_soc_update_bits(codec, PW_MGMT1, PMVCM | PMMIN | PMDAC, + PMVCM | PMMIN | PMDAC); snd_soc_update_bits(codec, PW_MGMT2, PMHP_MASK, PMHP); snd_soc_update_bits(codec, PW_MGMT2, HPMTN, HPMTN); } else { @@ -237,13 +266,12 @@ static int ak4642_dai_startup(struct snd_pcm_substream *substream, * This operation came from example code of * "ASAHI KASEI AK4642" (japanese) manual p94. */ - ak4642_write(codec, 0x02, 0x05); - ak4642_write(codec, 0x06, 0x3c); - ak4642_write(codec, 0x08, 0xe1); - ak4642_write(codec, 0x0b, 0x00); - ak4642_write(codec, 0x07, 0x21); - snd_soc_update_bits(codec, 0x00, 0x41, 0x41); - ak4642_write(codec, 0x10, 0x01); + ak4642_write(codec, SG_SL1, PMMP | MGAIN0); + ak4642_write(codec, TIMER, ZTM(0x3) | WTM(0x3)); + ak4642_write(codec, ALC_CTL1, ALC | LMTH0); + snd_soc_update_bits(codec, PW_MGMT1, PMVCM | PMADL, + PMVCM | PMADL); + snd_soc_update_bits(codec, PW_MGMT3, PMADR, PMADR); } return 0; @@ -259,14 +287,14 @@ static void ak4642_dai_shutdown(struct snd_pcm_substream *substream, /* stop headphone output */ snd_soc_update_bits(codec, PW_MGMT2, HPMTN, 0); snd_soc_update_bits(codec, PW_MGMT2, PMHP_MASK, 0); - snd_soc_update_bits(codec, 0x00, 0x64, 0x40); - ak4642_write(codec, 0x0e, 0x11); - ak4642_write(codec, 0x0f, 0x08); + snd_soc_update_bits(codec, PW_MGMT1, PMMIN | PMDAC, 0); + snd_soc_update_bits(codec, MD_CTL3, BST1, 0); + snd_soc_update_bits(codec, MD_CTL4, DACH, 0); } else { /* stop stereo input */ - snd_soc_update_bits(codec, 0x00, 0x41, 0x40); - ak4642_write(codec, 0x10, 0x00); - ak4642_write(codec, 0x07, 0x01); + snd_soc_update_bits(codec, PW_MGMT1, PMADL, 0); + snd_soc_update_bits(codec, PW_MGMT3, PMADR, 0); + snd_soc_update_bits(codec, ALC_CTL1, ALC, 0); } } -- cgit v1.1 From aa7e1b84c6d424264bab8c29b14ebbc906488853 Mon Sep 17 00:00:00 2001 From: Mika Westerberg Date: Thu, 14 Oct 2010 17:49:06 +0300 Subject: ASoC: add ep93xx AC97 audio driver Add support for AC97 controllers found in Cirrus Logic EP93xx family SoCs. Signed-off-by: Mika Westerberg Acked-by: Liam Girdwood Signed-off-by: Mark Brown --- sound/soc/ep93xx/Kconfig | 7 +- sound/soc/ep93xx/Makefile | 2 + sound/soc/ep93xx/ep93xx-ac97.c | 468 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 476 insertions(+), 1 deletion(-) create mode 100644 sound/soc/ep93xx/ep93xx-ac97.c (limited to 'sound') diff --git a/sound/soc/ep93xx/Kconfig b/sound/soc/ep93xx/Kconfig index f617f56..108e5ff 100644 --- a/sound/soc/ep93xx/Kconfig +++ b/sound/soc/ep93xx/Kconfig @@ -3,11 +3,16 @@ config SND_EP93XX_SOC depends on ARCH_EP93XX && SND_SOC help Say Y or M if you want to add support for codecs attached to - the EP93xx I2S interface. + the EP93xx I2S or AC97 interfaces. config SND_EP93XX_SOC_I2S tristate +config SND_EP93XX_SOC_AC97 + tristate + select AC97_BUS + select SND_SOC_AC97_BUS + config SND_EP93XX_SOC_SNAPPERCL15 tristate "SoC Audio support for Bluewater Systems Snapper CL15 module" depends on SND_EP93XX_SOC && MACH_SNAPPER_CL15 diff --git a/sound/soc/ep93xx/Makefile b/sound/soc/ep93xx/Makefile index 272e60f..ac06e00 100644 --- a/sound/soc/ep93xx/Makefile +++ b/sound/soc/ep93xx/Makefile @@ -1,9 +1,11 @@ # EP93xx Platform Support snd-soc-ep93xx-objs := ep93xx-pcm.o snd-soc-ep93xx-i2s-objs := ep93xx-i2s.o +snd-soc-ep93xx-ac97-objs := ep93xx-ac97.o obj-$(CONFIG_SND_EP93XX_SOC) += snd-soc-ep93xx.o obj-$(CONFIG_SND_EP93XX_SOC_I2S) += snd-soc-ep93xx-i2s.o +obj-$(CONFIG_SND_EP93XX_SOC_AC97) += snd-soc-ep93xx-ac97.o # EP93XX Machine Support snd-soc-snappercl15-objs := snappercl15.o diff --git a/sound/soc/ep93xx/ep93xx-ac97.c b/sound/soc/ep93xx/ep93xx-ac97.c new file mode 100644 index 0000000..68a0bae --- /dev/null +++ b/sound/soc/ep93xx/ep93xx-ac97.c @@ -0,0 +1,468 @@ +/* + * ASoC driver for Cirrus Logic EP93xx AC97 controller. + * + * Copyright (c) 2010 Mika Westerberg + * + * Based on s3c-ac97 ASoC driver by Jaswinder Singh. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include "ep93xx-pcm.h" + +/* + * Per channel (1-4) registers. + */ +#define AC97CH(n) (((n) - 1) * 0x20) + +#define AC97DR(n) (AC97CH(n) + 0x0000) + +#define AC97RXCR(n) (AC97CH(n) + 0x0004) +#define AC97RXCR_REN BIT(0) +#define AC97RXCR_RX3 BIT(3) +#define AC97RXCR_RX4 BIT(4) +#define AC97RXCR_CM BIT(15) + +#define AC97TXCR(n) (AC97CH(n) + 0x0008) +#define AC97TXCR_TEN BIT(0) +#define AC97TXCR_TX3 BIT(3) +#define AC97TXCR_TX4 BIT(4) +#define AC97TXCR_CM BIT(15) + +#define AC97SR(n) (AC97CH(n) + 0x000c) +#define AC97SR_TXFE BIT(1) +#define AC97SR_TXUE BIT(6) + +#define AC97RISR(n) (AC97CH(n) + 0x0010) +#define AC97ISR(n) (AC97CH(n) + 0x0014) +#define AC97IE(n) (AC97CH(n) + 0x0018) + +/* + * Global AC97 controller registers. + */ +#define AC97S1DATA 0x0080 +#define AC97S2DATA 0x0084 +#define AC97S12DATA 0x0088 + +#define AC97RGIS 0x008c +#define AC97GIS 0x0090 +#define AC97IM 0x0094 +/* + * Common bits for RGIS, GIS and IM registers. + */ +#define AC97_SLOT2RXVALID BIT(1) +#define AC97_CODECREADY BIT(5) +#define AC97_SLOT2TXCOMPLETE BIT(6) + +#define AC97EOI 0x0098 +#define AC97EOI_WINT BIT(0) +#define AC97EOI_CODECREADY BIT(1) + +#define AC97GCR 0x009c +#define AC97GCR_AC97IFE BIT(0) + +#define AC97RESET 0x00a0 +#define AC97RESET_TIMEDRESET BIT(0) + +#define AC97SYNC 0x00a4 +#define AC97SYNC_TIMEDSYNC BIT(0) + +#define AC97_TIMEOUT msecs_to_jiffies(5) + +/** + * struct ep93xx_ac97_info - EP93xx AC97 controller info structure + * @lock: mutex serializing access to the bus (slot 1 & 2 ops) + * @dev: pointer to the platform device dev structure + * @mem: physical memory resource for the registers + * @regs: mapped AC97 controller registers + * @irq: AC97 interrupt number + * @done: bus ops wait here for an interrupt + */ +struct ep93xx_ac97_info { + struct mutex lock; + struct device *dev; + struct resource *mem; + void __iomem *regs; + int irq; + struct completion done; +}; + +/* currently ALSA only supports a single AC97 device */ +static struct ep93xx_ac97_info *ep93xx_ac97_info; + +static struct ep93xx_pcm_dma_params ep93xx_ac97_pcm_out = { + .name = "ac97-pcm-out", + .dma_port = EP93XX_DMA_M2P_PORT_AAC1, +}; + +static struct ep93xx_pcm_dma_params ep93xx_ac97_pcm_in = { + .name = "ac97-pcm-in", + .dma_port = EP93XX_DMA_M2P_PORT_AAC1, +}; + +static inline unsigned ep93xx_ac97_read_reg(struct ep93xx_ac97_info *info, + unsigned reg) +{ + return __raw_readl(info->regs + reg); +} + +static inline void ep93xx_ac97_write_reg(struct ep93xx_ac97_info *info, + unsigned reg, unsigned val) +{ + __raw_writel(val, info->regs + reg); +} + +static unsigned short ep93xx_ac97_read(struct snd_ac97 *ac97, + unsigned short reg) +{ + struct ep93xx_ac97_info *info = ep93xx_ac97_info; + unsigned short val; + + mutex_lock(&info->lock); + + ep93xx_ac97_write_reg(info, AC97S1DATA, reg); + ep93xx_ac97_write_reg(info, AC97IM, AC97_SLOT2RXVALID); + if (!wait_for_completion_timeout(&info->done, AC97_TIMEOUT)) { + dev_warn(info->dev, "timeout reading register %x\n", reg); + mutex_unlock(&info->lock); + return -ETIMEDOUT; + } + val = (unsigned short)ep93xx_ac97_read_reg(info, AC97S2DATA); + + mutex_unlock(&info->lock); + return val; +} + +static void ep93xx_ac97_write(struct snd_ac97 *ac97, + unsigned short reg, + unsigned short val) +{ + struct ep93xx_ac97_info *info = ep93xx_ac97_info; + + mutex_lock(&info->lock); + + /* + * Writes to the codec need to be done so that slot 2 is filled in + * before slot 1. + */ + ep93xx_ac97_write_reg(info, AC97S2DATA, val); + ep93xx_ac97_write_reg(info, AC97S1DATA, reg); + + ep93xx_ac97_write_reg(info, AC97IM, AC97_SLOT2TXCOMPLETE); + if (!wait_for_completion_timeout(&info->done, AC97_TIMEOUT)) + dev_warn(info->dev, "timeout writing register %x\n", reg); + + mutex_unlock(&info->lock); +} + +static void ep93xx_ac97_warm_reset(struct snd_ac97 *ac97) +{ + struct ep93xx_ac97_info *info = ep93xx_ac97_info; + + mutex_lock(&info->lock); + + /* + * We are assuming that before this functions gets called, the codec + * BIT_CLK is stopped by forcing the codec into powerdown mode. We can + * control the SYNC signal directly via AC97SYNC register. Using + * TIMEDSYNC the controller will keep the SYNC high > 1us. + */ + ep93xx_ac97_write_reg(info, AC97SYNC, AC97SYNC_TIMEDSYNC); + ep93xx_ac97_write_reg(info, AC97IM, AC97_CODECREADY); + if (!wait_for_completion_timeout(&info->done, AC97_TIMEOUT)) + dev_warn(info->dev, "codec warm reset timeout\n"); + + mutex_unlock(&info->lock); +} + +static void ep93xx_ac97_cold_reset(struct snd_ac97 *ac97) +{ + struct ep93xx_ac97_info *info = ep93xx_ac97_info; + + mutex_lock(&info->lock); + + /* + * For doing cold reset, we disable the AC97 controller interface, clear + * WINT and CODECREADY bits, and finally enable the interface again. + */ + ep93xx_ac97_write_reg(info, AC97GCR, 0); + ep93xx_ac97_write_reg(info, AC97EOI, AC97EOI_CODECREADY | AC97EOI_WINT); + ep93xx_ac97_write_reg(info, AC97GCR, AC97GCR_AC97IFE); + + /* + * Now, assert the reset and wait for the codec to become ready. + */ + ep93xx_ac97_write_reg(info, AC97RESET, AC97RESET_TIMEDRESET); + ep93xx_ac97_write_reg(info, AC97IM, AC97_CODECREADY); + if (!wait_for_completion_timeout(&info->done, AC97_TIMEOUT)) + dev_warn(info->dev, "codec cold reset timeout\n"); + + /* + * Give the codec some time to come fully out from the reset. This way + * we ensure that the subsequent reads/writes will work. + */ + usleep_range(15000, 20000); + + mutex_unlock(&info->lock); +} + +static irqreturn_t ep93xx_ac97_interrupt(int irq, void *dev_id) +{ + struct ep93xx_ac97_info *info = dev_id; + unsigned status, mask; + + /* + * Just mask out the interrupt and wake up the waiting thread. + * Interrupts are cleared via reading/writing to slot 1 & 2 registers by + * the waiting thread. + */ + status = ep93xx_ac97_read_reg(info, AC97GIS); + mask = ep93xx_ac97_read_reg(info, AC97IM); + mask &= ~status; + ep93xx_ac97_write_reg(info, AC97IM, mask); + + complete(&info->done); + return IRQ_HANDLED; +} + +struct snd_ac97_bus_ops soc_ac97_ops = { + .read = ep93xx_ac97_read, + .write = ep93xx_ac97_write, + .reset = ep93xx_ac97_cold_reset, + .warm_reset = ep93xx_ac97_warm_reset, +}; +EXPORT_SYMBOL_GPL(soc_ac97_ops); + +static int ep93xx_ac97_trigger(struct snd_pcm_substream *substream, + int cmd, struct snd_soc_dai *dai) +{ + struct ep93xx_ac97_info *info = snd_soc_dai_get_drvdata(dai); + unsigned v = 0; + + + switch (cmd) { + case SNDRV_PCM_TRIGGER_START: + case SNDRV_PCM_TRIGGER_RESUME: + case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { + /* + * Enable compact mode, TX slots 3 & 4, and the TX FIFO + * itself. + */ + v |= AC97TXCR_CM; + v |= AC97TXCR_TX3 | AC97TXCR_TX4; + v |= AC97TXCR_TEN; + ep93xx_ac97_write_reg(info, AC97TXCR(1), v); + } else { + /* + * Enable compact mode, RX slots 3 & 4, and the RX FIFO + * itself. + */ + v |= AC97RXCR_CM; + v |= AC97RXCR_RX3 | AC97RXCR_RX4; + v |= AC97RXCR_REN; + ep93xx_ac97_write_reg(info, AC97RXCR(1), v); + } + break; + + case SNDRV_PCM_TRIGGER_STOP: + case SNDRV_PCM_TRIGGER_SUSPEND: + case SNDRV_PCM_TRIGGER_PAUSE_PUSH: + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { + /* + * As per Cirrus EP93xx errata described below: + * + * http://www.cirrus.com/en/pubs/errata/ER667E2B.pdf + * + * we will wait for the TX FIFO to be empty before + * clearing the TEN bit. + */ + unsigned long timeout = jiffies + AC97_TIMEOUT; + + do { + v = ep93xx_ac97_read_reg(info, AC97SR(1)); + if (time_after(jiffies, timeout)) { + dev_warn(info->dev, "TX timeout\n"); + break; + } + } while (!(v & (AC97SR_TXFE | AC97SR_TXUE))); + + /* disable the TX FIFO */ + ep93xx_ac97_write_reg(info, AC97TXCR(1), 0); + } else { + /* disable the RX FIFO */ + ep93xx_ac97_write_reg(info, AC97RXCR(1), 0); + } + break; + + default: + dev_warn(info->dev, "unknown command %d\n", cmd); + return -EINVAL; + } + + return 0; +} + +static int ep93xx_ac97_startup(struct snd_pcm_substream *substream, + struct snd_soc_dai *dai) +{ + struct ep93xx_pcm_dma_params *dma_data; + + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) + dma_data = &ep93xx_ac97_pcm_out; + else + dma_data = &ep93xx_ac97_pcm_in; + + snd_soc_dai_set_dma_data(dai, substream, dma_data); + return 0; +} + +static struct snd_soc_dai_ops ep93xx_ac97_dai_ops = { + .startup = ep93xx_ac97_startup, + .trigger = ep93xx_ac97_trigger, +}; + +struct snd_soc_dai_driver ep93xx_ac97_dai = { + .name = "ep93xx-ac97", + .id = 0, + .ac97_control = 1, + .playback = { + .stream_name = "AC97 Playback", + .channels_min = 2, + .channels_max = 2, + .rates = SNDRV_PCM_RATE_8000_48000, + .formats = SNDRV_PCM_FMTBIT_S16_LE, + }, + .capture = { + .stream_name = "AC97 Capture", + .channels_min = 2, + .channels_max = 2, + .rates = SNDRV_PCM_RATE_8000_48000, + .formats = SNDRV_PCM_FMTBIT_S16_LE, + }, + .ops = &ep93xx_ac97_dai_ops, +}; + +static int __devinit ep93xx_ac97_probe(struct platform_device *pdev) +{ + struct ep93xx_ac97_info *info; + int ret; + + info = kzalloc(sizeof(struct ep93xx_ac97_info), GFP_KERNEL); + if (!info) + return -ENOMEM; + + dev_set_drvdata(&pdev->dev, info); + + mutex_init(&info->lock); + init_completion(&info->done); + info->dev = &pdev->dev; + + info->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); + if (!info->mem) { + ret = -ENXIO; + goto fail_free_info; + } + + info->irq = platform_get_irq(pdev, 0); + if (!info->irq) { + ret = -ENXIO; + goto fail_free_info; + } + + if (!request_mem_region(info->mem->start, resource_size(info->mem), + pdev->name)) { + ret = -EBUSY; + goto fail_free_info; + } + + info->regs = ioremap(info->mem->start, resource_size(info->mem)); + if (!info->regs) { + ret = -ENOMEM; + goto fail_release_mem; + } + + ret = request_irq(info->irq, ep93xx_ac97_interrupt, IRQF_TRIGGER_HIGH, + pdev->name, info); + if (ret) + goto fail_unmap_mem; + + ep93xx_ac97_info = info; + platform_set_drvdata(pdev, info); + + ret = snd_soc_register_dai(&pdev->dev, &ep93xx_ac97_dai); + if (ret) + goto fail_free_irq; + + return 0; + +fail_free_irq: + platform_set_drvdata(pdev, NULL); + free_irq(info->irq, info); +fail_unmap_mem: + iounmap(info->regs); +fail_release_mem: + release_mem_region(info->mem->start, resource_size(info->mem)); +fail_free_info: + kfree(info); + + return ret; +} + +static int __devexit ep93xx_ac97_remove(struct platform_device *pdev) +{ + struct ep93xx_ac97_info *info = platform_get_drvdata(pdev); + + snd_soc_unregister_dai(&pdev->dev); + + /* disable the AC97 controller */ + ep93xx_ac97_write_reg(info, AC97GCR, 0); + + free_irq(info->irq, info); + iounmap(info->regs); + release_mem_region(info->mem->start, resource_size(info->mem)); + platform_set_drvdata(pdev, NULL); + kfree(info); + + return 0; +} + +static struct platform_driver ep93xx_ac97_driver = { + .probe = ep93xx_ac97_probe, + .remove = __devexit_p(ep93xx_ac97_remove), + .driver = { + .name = "ep93xx-ac97", + .owner = THIS_MODULE, + }, +}; + +static int __init ep93xx_ac97_init(void) +{ + return platform_driver_register(&ep93xx_ac97_driver); +} +module_init(ep93xx_ac97_init); + +static void __exit ep93xx_ac97_exit(void) +{ + platform_driver_unregister(&ep93xx_ac97_driver); +} +module_exit(ep93xx_ac97_exit); + +MODULE_DESCRIPTION("EP93xx AC97 ASoC Driver"); +MODULE_AUTHOR("Mika Westerberg "); +MODULE_LICENSE("GPL"); +MODULE_ALIAS("platform:ep93xx-ac97"); -- cgit v1.1 From d42a280dc76c04f39d1f9a374cf5c23318c49004 Mon Sep 17 00:00:00 2001 From: Mika Westerberg Date: Thu, 14 Oct 2010 17:49:08 +0300 Subject: ASoC: ep93xx: add Simplemachines Sim.One AC97 audio support Add AC97 audio support for Simplemachines Sim.One board. Signed-off-by: Mika Westerberg Acked-by: Liam Girdwood Signed-off-by: Mark Brown --- sound/soc/ep93xx/Kconfig | 9 +++++ sound/soc/ep93xx/Makefile | 2 ++ sound/soc/ep93xx/simone.c | 89 +++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 100 insertions(+) create mode 100644 sound/soc/ep93xx/simone.c (limited to 'sound') diff --git a/sound/soc/ep93xx/Kconfig b/sound/soc/ep93xx/Kconfig index 108e5ff..5742904 100644 --- a/sound/soc/ep93xx/Kconfig +++ b/sound/soc/ep93xx/Kconfig @@ -21,3 +21,12 @@ config SND_EP93XX_SOC_SNAPPERCL15 help Say Y or M here if you want to add support for I2S audio on the Bluewater Systems Snapper CL15 module. + +config SND_EP93XX_SOC_SIMONE + tristate "SoC Audio support for Simplemachines Sim.One board" + depends on SND_EP93XX_SOC && MACH_SIM_ONE + select SND_EP93XX_SOC_AC97 + select SND_SOC_AC97_CODEC + help + Say Y or M here if you want to add support for AC97 audio on the + Simplemachines Sim.One board. diff --git a/sound/soc/ep93xx/Makefile b/sound/soc/ep93xx/Makefile index ac06e00..8e7977f 100644 --- a/sound/soc/ep93xx/Makefile +++ b/sound/soc/ep93xx/Makefile @@ -9,5 +9,7 @@ obj-$(CONFIG_SND_EP93XX_SOC_AC97) += snd-soc-ep93xx-ac97.o # EP93XX Machine Support snd-soc-snappercl15-objs := snappercl15.o +snd-soc-simone-objs := simone.o obj-$(CONFIG_SND_EP93XX_SOC_SNAPPERCL15) += snd-soc-snappercl15.o +obj-$(CONFIG_SND_EP93XX_SOC_SIMONE) += snd-soc-simone.o diff --git a/sound/soc/ep93xx/simone.c b/sound/soc/ep93xx/simone.c new file mode 100644 index 0000000..4b0d199 --- /dev/null +++ b/sound/soc/ep93xx/simone.c @@ -0,0 +1,89 @@ +/* + * simone.c -- ASoC audio for Simplemachines Sim.One board + * + * Copyright (c) 2010 Mika Westerberg + * + * Based on snappercl15 machine driver by Ryan Mallon. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#include +#include +#include + +#include +#include +#include + +#include +#include + +#include "ep93xx-pcm.h" + +static struct snd_soc_dai_link simone_dai = { + .name = "AC97", + .stream_name = "AC97 HiFi", + .cpu_dai_name = "ep93xx-ac97", + .codec_dai_name = "ac97-hifi", + .codec_name = "ac97-codec", + .platform_name = "ep93xx-pcm-audio", +}; + +static struct snd_soc_card snd_soc_simone = { + .name = "Sim.One", + .dai_link = &simone_dai, + .num_links = 1, +}; + +static struct platform_device *simone_snd_ac97_device; +static struct platform_device *simone_snd_device; + +static int __init simone_init(void) +{ + int ret; + + if (!machine_is_sim_one()) + return -ENODEV; + + simone_snd_ac97_device = platform_device_alloc("ac97-codec", -1); + if (!simone_snd_ac97_device) + return -ENOMEM; + + ret = platform_device_add(simone_snd_ac97_device); + if (ret) + goto fail; + + simone_snd_device = platform_device_alloc("soc-audio", -1); + if (!simone_snd_device) { + ret = -ENOMEM; + goto fail; + } + + platform_set_drvdata(simone_snd_device, &snd_soc_simone); + ret = platform_device_add(simone_snd_device); + if (ret) { + platform_device_put(simone_snd_device); + goto fail; + } + + return ret; + +fail: + platform_device_put(simone_snd_ac97_device); + return ret; +} +module_init(simone_init); + +static void __exit simone_exit(void) +{ + platform_device_unregister(simone_snd_device); + platform_device_unregister(simone_snd_ac97_device); +} +module_exit(simone_exit); + +MODULE_DESCRIPTION("ALSA SoC Simplemachines Sim.One"); +MODULE_AUTHOR("Mika Westerberg "); +MODULE_LICENSE("GPL"); -- cgit v1.1 From e65d255a5a610ce9e185e0df855250706aca7c21 Mon Sep 17 00:00:00 2001 From: Peter Hsiang Date: Wed, 13 Oct 2010 20:30:43 -0700 Subject: ASoC: Add max98088 CODEC driver This patch adds the MAX98088 CODEC driver. Signed-off-by: Peter Hsiang Acked-by: Liam Girdwood Signed-off-by: Mark Brown --- sound/soc/codecs/Kconfig | 4 + sound/soc/codecs/Makefile | 2 + sound/soc/codecs/max98088.c | 2097 +++++++++++++++++++++++++++++++++++++++++++ sound/soc/codecs/max98088.h | 193 ++++ 4 files changed, 2296 insertions(+) create mode 100644 sound/soc/codecs/max98088.c create mode 100644 sound/soc/codecs/max98088.h (limited to 'sound') diff --git a/sound/soc/codecs/Kconfig b/sound/soc/codecs/Kconfig index ff7b922..94a9d06 100644 --- a/sound/soc/codecs/Kconfig +++ b/sound/soc/codecs/Kconfig @@ -27,6 +27,7 @@ config SND_SOC_ALL_CODECS select SND_SOC_CS4270 if I2C select SND_SOC_DA7210 if I2C select SND_SOC_JZ4740 if SOC_JZ4740 + select SND_SOC_MAX98088 if I2C select SND_SOC_MAX9877 if I2C select SND_SOC_PCM3008 select SND_SOC_SPDIF @@ -158,6 +159,9 @@ config SND_SOC_L3 config SND_SOC_DA7210 tristate +config SND_SOC_MAX98088 + tristate + config SND_SOC_PCM3008 tristate diff --git a/sound/soc/codecs/Makefile b/sound/soc/codecs/Makefile index af4d4c4..f67a2d6 100644 --- a/sound/soc/codecs/Makefile +++ b/sound/soc/codecs/Makefile @@ -15,6 +15,7 @@ snd-soc-cs4270-objs := cs4270.o snd-soc-cx20442-objs := cx20442.o snd-soc-da7210-objs := da7210.o snd-soc-l3-objs := l3.o +snd-soc-max98088-objs := max98088.o snd-soc-pcm3008-objs := pcm3008.o snd-soc-spdif-objs := spdif_transciever.o snd-soc-ssm2602-objs := ssm2602.o @@ -89,6 +90,7 @@ obj-$(CONFIG_SND_SOC_CX20442) += snd-soc-cx20442.o obj-$(CONFIG_SND_SOC_DA7210) += snd-soc-da7210.o obj-$(CONFIG_SND_SOC_L3) += snd-soc-l3.o obj-$(CONFIG_SND_SOC_JZ4740_CODEC) += snd-soc-jz4740-codec.o +obj-$(CONFIG_SND_SOC_MAX98088) += snd-soc-max98088.o obj-$(CONFIG_SND_SOC_PCM3008) += snd-soc-pcm3008.o obj-$(CONFIG_SND_SOC_SPDIF) += snd-soc-spdif.o obj-$(CONFIG_SND_SOC_SSM2602) += snd-soc-ssm2602.o diff --git a/sound/soc/codecs/max98088.c b/sound/soc/codecs/max98088.c new file mode 100644 index 0000000..4186b27 --- /dev/null +++ b/sound/soc/codecs/max98088.c @@ -0,0 +1,2097 @@ +/* + * max98088.c -- MAX98088 ALSA SoC Audio driver + * + * Copyright 2010 Maxim Integrated Products + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "max98088.h" + +struct max98088_cdata { + unsigned int rate; + unsigned int fmt; + int eq_sel; +}; + +struct max98088_priv { + u8 reg_cache[M98088_REG_CNT]; + void *control_data; + struct max98088_pdata *pdata; + unsigned int sysclk; + struct max98088_cdata dai[2]; + int eq_textcnt; + const char **eq_texts; + struct soc_enum eq_enum; + u8 ina_state; + u8 inb_state; + unsigned int ex_mode; + unsigned int digmic; + unsigned int mic1pre; + unsigned int mic2pre; + unsigned int extmic_mode; +}; + +static const u8 max98088_reg[M98088_REG_CNT] = { + 0x00, /* 00 IRQ status */ + 0x00, /* 01 MIC status */ + 0x00, /* 02 jack status */ + 0x00, /* 03 battery voltage */ + 0x00, /* 04 */ + 0x00, /* 05 */ + 0x00, /* 06 */ + 0x00, /* 07 */ + 0x00, /* 08 */ + 0x00, /* 09 */ + 0x00, /* 0A */ + 0x00, /* 0B */ + 0x00, /* 0C */ + 0x00, /* 0D */ + 0x00, /* 0E */ + 0x00, /* 0F interrupt enable */ + + 0x00, /* 10 master clock */ + 0x00, /* 11 DAI1 clock mode */ + 0x00, /* 12 DAI1 clock control */ + 0x00, /* 13 DAI1 clock control */ + 0x00, /* 14 DAI1 format */ + 0x00, /* 15 DAI1 clock */ + 0x00, /* 16 DAI1 config */ + 0x00, /* 17 DAI1 TDM */ + 0x00, /* 18 DAI1 filters */ + 0x00, /* 19 DAI2 clock mode */ + 0x00, /* 1A DAI2 clock control */ + 0x00, /* 1B DAI2 clock control */ + 0x00, /* 1C DAI2 format */ + 0x00, /* 1D DAI2 clock */ + 0x00, /* 1E DAI2 config */ + 0x00, /* 1F DAI2 TDM */ + + 0x00, /* 20 DAI2 filters */ + 0x00, /* 21 data config */ + 0x00, /* 22 DAC mixer */ + 0x00, /* 23 left ADC mixer */ + 0x00, /* 24 right ADC mixer */ + 0x00, /* 25 left HP mixer */ + 0x00, /* 26 right HP mixer */ + 0x00, /* 27 HP control */ + 0x00, /* 28 left REC mixer */ + 0x00, /* 29 right REC mixer */ + 0x00, /* 2A REC control */ + 0x00, /* 2B left SPK mixer */ + 0x00, /* 2C right SPK mixer */ + 0x00, /* 2D SPK control */ + 0x00, /* 2E sidetone */ + 0x00, /* 2F DAI1 playback level */ + + 0x00, /* 30 DAI1 playback level */ + 0x00, /* 31 DAI2 playback level */ + 0x00, /* 32 DAI2 playbakc level */ + 0x00, /* 33 left ADC level */ + 0x00, /* 34 right ADC level */ + 0x00, /* 35 MIC1 level */ + 0x00, /* 36 MIC2 level */ + 0x00, /* 37 INA level */ + 0x00, /* 38 INB level */ + 0x00, /* 39 left HP volume */ + 0x00, /* 3A right HP volume */ + 0x00, /* 3B left REC volume */ + 0x00, /* 3C right REC volume */ + 0x00, /* 3D left SPK volume */ + 0x00, /* 3E right SPK volume */ + 0x00, /* 3F MIC config */ + + 0x00, /* 40 MIC threshold */ + 0x00, /* 41 excursion limiter filter */ + 0x00, /* 42 excursion limiter threshold */ + 0x00, /* 43 ALC */ + 0x00, /* 44 power limiter threshold */ + 0x00, /* 45 power limiter config */ + 0x00, /* 46 distortion limiter config */ + 0x00, /* 47 audio input */ + 0x00, /* 48 microphone */ + 0x00, /* 49 level control */ + 0x00, /* 4A bypass switches */ + 0x00, /* 4B jack detect */ + 0x00, /* 4C input enable */ + 0x00, /* 4D output enable */ + 0xF0, /* 4E bias control */ + 0x00, /* 4F DAC power */ + + 0x0F, /* 50 DAC power */ + 0x00, /* 51 system */ + 0x00, /* 52 DAI1 EQ1 */ + 0x00, /* 53 DAI1 EQ1 */ + 0x00, /* 54 DAI1 EQ1 */ + 0x00, /* 55 DAI1 EQ1 */ + 0x00, /* 56 DAI1 EQ1 */ + 0x00, /* 57 DAI1 EQ1 */ + 0x00, /* 58 DAI1 EQ1 */ + 0x00, /* 59 DAI1 EQ1 */ + 0x00, /* 5A DAI1 EQ1 */ + 0x00, /* 5B DAI1 EQ1 */ + 0x00, /* 5C DAI1 EQ2 */ + 0x00, /* 5D DAI1 EQ2 */ + 0x00, /* 5E DAI1 EQ2 */ + 0x00, /* 5F DAI1 EQ2 */ + + 0x00, /* 60 DAI1 EQ2 */ + 0x00, /* 61 DAI1 EQ2 */ + 0x00, /* 62 DAI1 EQ2 */ + 0x00, /* 63 DAI1 EQ2 */ + 0x00, /* 64 DAI1 EQ2 */ + 0x00, /* 65 DAI1 EQ2 */ + 0x00, /* 66 DAI1 EQ3 */ + 0x00, /* 67 DAI1 EQ3 */ + 0x00, /* 68 DAI1 EQ3 */ + 0x00, /* 69 DAI1 EQ3 */ + 0x00, /* 6A DAI1 EQ3 */ + 0x00, /* 6B DAI1 EQ3 */ + 0x00, /* 6C DAI1 EQ3 */ + 0x00, /* 6D DAI1 EQ3 */ + 0x00, /* 6E DAI1 EQ3 */ + 0x00, /* 6F DAI1 EQ3 */ + + 0x00, /* 70 DAI1 EQ4 */ + 0x00, /* 71 DAI1 EQ4 */ + 0x00, /* 72 DAI1 EQ4 */ + 0x00, /* 73 DAI1 EQ4 */ + 0x00, /* 74 DAI1 EQ4 */ + 0x00, /* 75 DAI1 EQ4 */ + 0x00, /* 76 DAI1 EQ4 */ + 0x00, /* 77 DAI1 EQ4 */ + 0x00, /* 78 DAI1 EQ4 */ + 0x00, /* 79 DAI1 EQ4 */ + 0x00, /* 7A DAI1 EQ5 */ + 0x00, /* 7B DAI1 EQ5 */ + 0x00, /* 7C DAI1 EQ5 */ + 0x00, /* 7D DAI1 EQ5 */ + 0x00, /* 7E DAI1 EQ5 */ + 0x00, /* 7F DAI1 EQ5 */ + + 0x00, /* 80 DAI1 EQ5 */ + 0x00, /* 81 DAI1 EQ5 */ + 0x00, /* 82 DAI1 EQ5 */ + 0x00, /* 83 DAI1 EQ5 */ + 0x00, /* 84 DAI2 EQ1 */ + 0x00, /* 85 DAI2 EQ1 */ + 0x00, /* 86 DAI2 EQ1 */ + 0x00, /* 87 DAI2 EQ1 */ + 0x00, /* 88 DAI2 EQ1 */ + 0x00, /* 89 DAI2 EQ1 */ + 0x00, /* 8A DAI2 EQ1 */ + 0x00, /* 8B DAI2 EQ1 */ + 0x00, /* 8C DAI2 EQ1 */ + 0x00, /* 8D DAI2 EQ1 */ + 0x00, /* 8E DAI2 EQ2 */ + 0x00, /* 8F DAI2 EQ2 */ + + 0x00, /* 90 DAI2 EQ2 */ + 0x00, /* 91 DAI2 EQ2 */ + 0x00, /* 92 DAI2 EQ2 */ + 0x00, /* 93 DAI2 EQ2 */ + 0x00, /* 94 DAI2 EQ2 */ + 0x00, /* 95 DAI2 EQ2 */ + 0x00, /* 96 DAI2 EQ2 */ + 0x00, /* 97 DAI2 EQ2 */ + 0x00, /* 98 DAI2 EQ3 */ + 0x00, /* 99 DAI2 EQ3 */ + 0x00, /* 9A DAI2 EQ3 */ + 0x00, /* 9B DAI2 EQ3 */ + 0x00, /* 9C DAI2 EQ3 */ + 0x00, /* 9D DAI2 EQ3 */ + 0x00, /* 9E DAI2 EQ3 */ + 0x00, /* 9F DAI2 EQ3 */ + + 0x00, /* A0 DAI2 EQ3 */ + 0x00, /* A1 DAI2 EQ3 */ + 0x00, /* A2 DAI2 EQ4 */ + 0x00, /* A3 DAI2 EQ4 */ + 0x00, /* A4 DAI2 EQ4 */ + 0x00, /* A5 DAI2 EQ4 */ + 0x00, /* A6 DAI2 EQ4 */ + 0x00, /* A7 DAI2 EQ4 */ + 0x00, /* A8 DAI2 EQ4 */ + 0x00, /* A9 DAI2 EQ4 */ + 0x00, /* AA DAI2 EQ4 */ + 0x00, /* AB DAI2 EQ4 */ + 0x00, /* AC DAI2 EQ5 */ + 0x00, /* AD DAI2 EQ5 */ + 0x00, /* AE DAI2 EQ5 */ + 0x00, /* AF DAI2 EQ5 */ + + 0x00, /* B0 DAI2 EQ5 */ + 0x00, /* B1 DAI2 EQ5 */ + 0x00, /* B2 DAI2 EQ5 */ + 0x00, /* B3 DAI2 EQ5 */ + 0x00, /* B4 DAI2 EQ5 */ + 0x00, /* B5 DAI2 EQ5 */ + 0x00, /* B6 DAI1 biquad */ + 0x00, /* B7 DAI1 biquad */ + 0x00, /* B8 DAI1 biquad */ + 0x00, /* B9 DAI1 biquad */ + 0x00, /* BA DAI1 biquad */ + 0x00, /* BB DAI1 biquad */ + 0x00, /* BC DAI1 biquad */ + 0x00, /* BD DAI1 biquad */ + 0x00, /* BE DAI1 biquad */ + 0x00, /* BF DAI1 biquad */ + + 0x00, /* C0 DAI2 biquad */ + 0x00, /* C1 DAI2 biquad */ + 0x00, /* C2 DAI2 biquad */ + 0x00, /* C3 DAI2 biquad */ + 0x00, /* C4 DAI2 biquad */ + 0x00, /* C5 DAI2 biquad */ + 0x00, /* C6 DAI2 biquad */ + 0x00, /* C7 DAI2 biquad */ + 0x00, /* C8 DAI2 biquad */ + 0x00, /* C9 DAI2 biquad */ + 0x00, /* CA */ + 0x00, /* CB */ + 0x00, /* CC */ + 0x00, /* CD */ + 0x00, /* CE */ + 0x00, /* CF */ + + 0x00, /* D0 */ + 0x00, /* D1 */ + 0x00, /* D2 */ + 0x00, /* D3 */ + 0x00, /* D4 */ + 0x00, /* D5 */ + 0x00, /* D6 */ + 0x00, /* D7 */ + 0x00, /* D8 */ + 0x00, /* D9 */ + 0x00, /* DA */ + 0x70, /* DB */ + 0x00, /* DC */ + 0x00, /* DD */ + 0x00, /* DE */ + 0x00, /* DF */ + + 0x00, /* E0 */ + 0x00, /* E1 */ + 0x00, /* E2 */ + 0x00, /* E3 */ + 0x00, /* E4 */ + 0x00, /* E5 */ + 0x00, /* E6 */ + 0x00, /* E7 */ + 0x00, /* E8 */ + 0x00, /* E9 */ + 0x00, /* EA */ + 0x00, /* EB */ + 0x00, /* EC */ + 0x00, /* ED */ + 0x00, /* EE */ + 0x00, /* EF */ + + 0x00, /* F0 */ + 0x00, /* F1 */ + 0x00, /* F2 */ + 0x00, /* F3 */ + 0x00, /* F4 */ + 0x00, /* F5 */ + 0x00, /* F6 */ + 0x00, /* F7 */ + 0x00, /* F8 */ + 0x00, /* F9 */ + 0x00, /* FA */ + 0x00, /* FB */ + 0x00, /* FC */ + 0x00, /* FD */ + 0x00, /* FE */ + 0x00, /* FF */ +}; + +static struct { + int readable; + int writable; + int vol; +} max98088_access[M98088_REG_CNT] = { + { 0xFF, 0xFF, 1 }, /* 00 IRQ status */ + { 0xFF, 0x00, 1 }, /* 01 MIC status */ + { 0xFF, 0x00, 1 }, /* 02 jack status */ + { 0x1F, 0x1F, 1 }, /* 03 battery voltage */ + { 0xFF, 0xFF, 0 }, /* 04 */ + { 0xFF, 0xFF, 0 }, /* 05 */ + { 0xFF, 0xFF, 0 }, /* 06 */ + { 0xFF, 0xFF, 0 }, /* 07 */ + { 0xFF, 0xFF, 0 }, /* 08 */ + { 0xFF, 0xFF, 0 }, /* 09 */ + { 0xFF, 0xFF, 0 }, /* 0A */ + { 0xFF, 0xFF, 0 }, /* 0B */ + { 0xFF, 0xFF, 0 }, /* 0C */ + { 0xFF, 0xFF, 0 }, /* 0D */ + { 0xFF, 0xFF, 0 }, /* 0E */ + { 0xFF, 0xFF, 0 }, /* 0F interrupt enable */ + + { 0xFF, 0xFF, 0 }, /* 10 master clock */ + { 0xFF, 0xFF, 0 }, /* 11 DAI1 clock mode */ + { 0xFF, 0xFF, 0 }, /* 12 DAI1 clock control */ + { 0xFF, 0xFF, 0 }, /* 13 DAI1 clock control */ + { 0xFF, 0xFF, 0 }, /* 14 DAI1 format */ + { 0xFF, 0xFF, 0 }, /* 15 DAI1 clock */ + { 0xFF, 0xFF, 0 }, /* 16 DAI1 config */ + { 0xFF, 0xFF, 0 }, /* 17 DAI1 TDM */ + { 0xFF, 0xFF, 0 }, /* 18 DAI1 filters */ + { 0xFF, 0xFF, 0 }, /* 19 DAI2 clock mode */ + { 0xFF, 0xFF, 0 }, /* 1A DAI2 clock control */ + { 0xFF, 0xFF, 0 }, /* 1B DAI2 clock control */ + { 0xFF, 0xFF, 0 }, /* 1C DAI2 format */ + { 0xFF, 0xFF, 0 }, /* 1D DAI2 clock */ + { 0xFF, 0xFF, 0 }, /* 1E DAI2 config */ + { 0xFF, 0xFF, 0 }, /* 1F DAI2 TDM */ + + { 0xFF, 0xFF, 0 }, /* 20 DAI2 filters */ + { 0xFF, 0xFF, 0 }, /* 21 data config */ + { 0xFF, 0xFF, 0 }, /* 22 DAC mixer */ + { 0xFF, 0xFF, 0 }, /* 23 left ADC mixer */ + { 0xFF, 0xFF, 0 }, /* 24 right ADC mixer */ + { 0xFF, 0xFF, 0 }, /* 25 left HP mixer */ + { 0xFF, 0xFF, 0 }, /* 26 right HP mixer */ + { 0xFF, 0xFF, 0 }, /* 27 HP control */ + { 0xFF, 0xFF, 0 }, /* 28 left REC mixer */ + { 0xFF, 0xFF, 0 }, /* 29 right REC mixer */ + { 0xFF, 0xFF, 0 }, /* 2A REC control */ + { 0xFF, 0xFF, 0 }, /* 2B left SPK mixer */ + { 0xFF, 0xFF, 0 }, /* 2C right SPK mixer */ + { 0xFF, 0xFF, 0 }, /* 2D SPK control */ + { 0xFF, 0xFF, 0 }, /* 2E sidetone */ + { 0xFF, 0xFF, 0 }, /* 2F DAI1 playback level */ + + { 0xFF, 0xFF, 0 }, /* 30 DAI1 playback level */ + { 0xFF, 0xFF, 0 }, /* 31 DAI2 playback level */ + { 0xFF, 0xFF, 0 }, /* 32 DAI2 playbakc level */ + { 0xFF, 0xFF, 0 }, /* 33 left ADC level */ + { 0xFF, 0xFF, 0 }, /* 34 right ADC level */ + { 0xFF, 0xFF, 0 }, /* 35 MIC1 level */ + { 0xFF, 0xFF, 0 }, /* 36 MIC2 level */ + { 0xFF, 0xFF, 0 }, /* 37 INA level */ + { 0xFF, 0xFF, 0 }, /* 38 INB level */ + { 0xFF, 0xFF, 0 }, /* 39 left HP volume */ + { 0xFF, 0xFF, 0 }, /* 3A right HP volume */ + { 0xFF, 0xFF, 0 }, /* 3B left REC volume */ + { 0xFF, 0xFF, 0 }, /* 3C right REC volume */ + { 0xFF, 0xFF, 0 }, /* 3D left SPK volume */ + { 0xFF, 0xFF, 0 }, /* 3E right SPK volume */ + { 0xFF, 0xFF, 0 }, /* 3F MIC config */ + + { 0xFF, 0xFF, 0 }, /* 40 MIC threshold */ + { 0xFF, 0xFF, 0 }, /* 41 excursion limiter filter */ + { 0xFF, 0xFF, 0 }, /* 42 excursion limiter threshold */ + { 0xFF, 0xFF, 0 }, /* 43 ALC */ + { 0xFF, 0xFF, 0 }, /* 44 power limiter threshold */ + { 0xFF, 0xFF, 0 }, /* 45 power limiter config */ + { 0xFF, 0xFF, 0 }, /* 46 distortion limiter config */ + { 0xFF, 0xFF, 0 }, /* 47 audio input */ + { 0xFF, 0xFF, 0 }, /* 48 microphone */ + { 0xFF, 0xFF, 0 }, /* 49 level control */ + { 0xFF, 0xFF, 0 }, /* 4A bypass switches */ + { 0xFF, 0xFF, 0 }, /* 4B jack detect */ + { 0xFF, 0xFF, 0 }, /* 4C input enable */ + { 0xFF, 0xFF, 0 }, /* 4D output enable */ + { 0xFF, 0xFF, 0 }, /* 4E bias control */ + { 0xFF, 0xFF, 0 }, /* 4F DAC power */ + + { 0xFF, 0xFF, 0 }, /* 50 DAC power */ + { 0xFF, 0xFF, 0 }, /* 51 system */ + { 0xFF, 0xFF, 0 }, /* 52 DAI1 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 53 DAI1 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 54 DAI1 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 55 DAI1 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 56 DAI1 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 57 DAI1 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 58 DAI1 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 59 DAI1 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 5A DAI1 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 5B DAI1 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 5C DAI1 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 5D DAI1 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 5E DAI1 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 5F DAI1 EQ2 */ + + { 0xFF, 0xFF, 0 }, /* 60 DAI1 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 61 DAI1 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 62 DAI1 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 63 DAI1 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 64 DAI1 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 65 DAI1 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 66 DAI1 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 67 DAI1 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 68 DAI1 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 69 DAI1 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 6A DAI1 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 6B DAI1 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 6C DAI1 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 6D DAI1 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 6E DAI1 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 6F DAI1 EQ3 */ + + { 0xFF, 0xFF, 0 }, /* 70 DAI1 EQ4 */ + { 0xFF, 0xFF, 0 }, /* 71 DAI1 EQ4 */ + { 0xFF, 0xFF, 0 }, /* 72 DAI1 EQ4 */ + { 0xFF, 0xFF, 0 }, /* 73 DAI1 EQ4 */ + { 0xFF, 0xFF, 0 }, /* 74 DAI1 EQ4 */ + { 0xFF, 0xFF, 0 }, /* 75 DAI1 EQ4 */ + { 0xFF, 0xFF, 0 }, /* 76 DAI1 EQ4 */ + { 0xFF, 0xFF, 0 }, /* 77 DAI1 EQ4 */ + { 0xFF, 0xFF, 0 }, /* 78 DAI1 EQ4 */ + { 0xFF, 0xFF, 0 }, /* 79 DAI1 EQ4 */ + { 0xFF, 0xFF, 0 }, /* 7A DAI1 EQ5 */ + { 0xFF, 0xFF, 0 }, /* 7B DAI1 EQ5 */ + { 0xFF, 0xFF, 0 }, /* 7C DAI1 EQ5 */ + { 0xFF, 0xFF, 0 }, /* 7D DAI1 EQ5 */ + { 0xFF, 0xFF, 0 }, /* 7E DAI1 EQ5 */ + { 0xFF, 0xFF, 0 }, /* 7F DAI1 EQ5 */ + + { 0xFF, 0xFF, 0 }, /* 80 DAI1 EQ5 */ + { 0xFF, 0xFF, 0 }, /* 81 DAI1 EQ5 */ + { 0xFF, 0xFF, 0 }, /* 82 DAI1 EQ5 */ + { 0xFF, 0xFF, 0 }, /* 83 DAI1 EQ5 */ + { 0xFF, 0xFF, 0 }, /* 84 DAI2 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 85 DAI2 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 86 DAI2 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 87 DAI2 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 88 DAI2 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 89 DAI2 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 8A DAI2 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 8B DAI2 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 8C DAI2 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 8D DAI2 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 8E DAI2 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 8F DAI2 EQ2 */ + + { 0xFF, 0xFF, 0 }, /* 90 DAI2 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 91 DAI2 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 92 DAI2 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 93 DAI2 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 94 DAI2 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 95 DAI2 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 96 DAI2 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 97 DAI2 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 98 DAI2 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 99 DAI2 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 9A DAI2 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 9B DAI2 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 9C DAI2 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 9D DAI2 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 9E DAI2 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 9F DAI2 EQ3 */ + + { 0xFF, 0xFF, 0 }, /* A0 DAI2 EQ3 */ + { 0xFF, 0xFF, 0 }, /* A1 DAI2 EQ3 */ + { 0xFF, 0xFF, 0 }, /* A2 DAI2 EQ4 */ + { 0xFF, 0xFF, 0 }, /* A3 DAI2 EQ4 */ + { 0xFF, 0xFF, 0 }, /* A4 DAI2 EQ4 */ + { 0xFF, 0xFF, 0 }, /* A5 DAI2 EQ4 */ + { 0xFF, 0xFF, 0 }, /* A6 DAI2 EQ4 */ + { 0xFF, 0xFF, 0 }, /* A7 DAI2 EQ4 */ + { 0xFF, 0xFF, 0 }, /* A8 DAI2 EQ4 */ + { 0xFF, 0xFF, 0 }, /* A9 DAI2 EQ4 */ + { 0xFF, 0xFF, 0 }, /* AA DAI2 EQ4 */ + { 0xFF, 0xFF, 0 }, /* AB DAI2 EQ4 */ + { 0xFF, 0xFF, 0 }, /* AC DAI2 EQ5 */ + { 0xFF, 0xFF, 0 }, /* AD DAI2 EQ5 */ + { 0xFF, 0xFF, 0 }, /* AE DAI2 EQ5 */ + { 0xFF, 0xFF, 0 }, /* AF DAI2 EQ5 */ + + { 0xFF, 0xFF, 0 }, /* B0 DAI2 EQ5 */ + { 0xFF, 0xFF, 0 }, /* B1 DAI2 EQ5 */ + { 0xFF, 0xFF, 0 }, /* B2 DAI2 EQ5 */ + { 0xFF, 0xFF, 0 }, /* B3 DAI2 EQ5 */ + { 0xFF, 0xFF, 0 }, /* B4 DAI2 EQ5 */ + { 0xFF, 0xFF, 0 }, /* B5 DAI2 EQ5 */ + { 0xFF, 0xFF, 0 }, /* B6 DAI1 biquad */ + { 0xFF, 0xFF, 0 }, /* B7 DAI1 biquad */ + { 0xFF, 0xFF, 0 }, /* B8 DAI1 biquad */ + { 0xFF, 0xFF, 0 }, /* B9 DAI1 biquad */ + { 0xFF, 0xFF, 0 }, /* BA DAI1 biquad */ + { 0xFF, 0xFF, 0 }, /* BB DAI1 biquad */ + { 0xFF, 0xFF, 0 }, /* BC DAI1 biquad */ + { 0xFF, 0xFF, 0 }, /* BD DAI1 biquad */ + { 0xFF, 0xFF, 0 }, /* BE DAI1 biquad */ + { 0xFF, 0xFF, 0 }, /* BF DAI1 biquad */ + + { 0xFF, 0xFF, 0 }, /* C0 DAI2 biquad */ + { 0xFF, 0xFF, 0 }, /* C1 DAI2 biquad */ + { 0xFF, 0xFF, 0 }, /* C2 DAI2 biquad */ + { 0xFF, 0xFF, 0 }, /* C3 DAI2 biquad */ + { 0xFF, 0xFF, 0 }, /* C4 DAI2 biquad */ + { 0xFF, 0xFF, 0 }, /* C5 DAI2 biquad */ + { 0xFF, 0xFF, 0 }, /* C6 DAI2 biquad */ + { 0xFF, 0xFF, 0 }, /* C7 DAI2 biquad */ + { 0xFF, 0xFF, 0 }, /* C8 DAI2 biquad */ + { 0xFF, 0xFF, 0 }, /* C9 DAI2 biquad */ + { 0x00, 0x00, 0 }, /* CA */ + { 0x00, 0x00, 0 }, /* CB */ + { 0x00, 0x00, 0 }, /* CC */ + { 0x00, 0x00, 0 }, /* CD */ + { 0x00, 0x00, 0 }, /* CE */ + { 0x00, 0x00, 0 }, /* CF */ + + { 0x00, 0x00, 0 }, /* D0 */ + { 0x00, 0x00, 0 }, /* D1 */ + { 0x00, 0x00, 0 }, /* D2 */ + { 0x00, 0x00, 0 }, /* D3 */ + { 0x00, 0x00, 0 }, /* D4 */ + { 0x00, 0x00, 0 }, /* D5 */ + { 0x00, 0x00, 0 }, /* D6 */ + { 0x00, 0x00, 0 }, /* D7 */ + { 0x00, 0x00, 0 }, /* D8 */ + { 0x00, 0x00, 0 }, /* D9 */ + { 0x00, 0x00, 0 }, /* DA */ + { 0x00, 0x00, 0 }, /* DB */ + { 0x00, 0x00, 0 }, /* DC */ + { 0x00, 0x00, 0 }, /* DD */ + { 0x00, 0x00, 0 }, /* DE */ + { 0x00, 0x00, 0 }, /* DF */ + + { 0x00, 0x00, 0 }, /* E0 */ + { 0x00, 0x00, 0 }, /* E1 */ + { 0x00, 0x00, 0 }, /* E2 */ + { 0x00, 0x00, 0 }, /* E3 */ + { 0x00, 0x00, 0 }, /* E4 */ + { 0x00, 0x00, 0 }, /* E5 */ + { 0x00, 0x00, 0 }, /* E6 */ + { 0x00, 0x00, 0 }, /* E7 */ + { 0x00, 0x00, 0 }, /* E8 */ + { 0x00, 0x00, 0 }, /* E9 */ + { 0x00, 0x00, 0 }, /* EA */ + { 0x00, 0x00, 0 }, /* EB */ + { 0x00, 0x00, 0 }, /* EC */ + { 0x00, 0x00, 0 }, /* ED */ + { 0x00, 0x00, 0 }, /* EE */ + { 0x00, 0x00, 0 }, /* EF */ + + { 0x00, 0x00, 0 }, /* F0 */ + { 0x00, 0x00, 0 }, /* F1 */ + { 0x00, 0x00, 0 }, /* F2 */ + { 0x00, 0x00, 0 }, /* F3 */ + { 0x00, 0x00, 0 }, /* F4 */ + { 0x00, 0x00, 0 }, /* F5 */ + { 0x00, 0x00, 0 }, /* F6 */ + { 0x00, 0x00, 0 }, /* F7 */ + { 0x00, 0x00, 0 }, /* F8 */ + { 0x00, 0x00, 0 }, /* F9 */ + { 0x00, 0x00, 0 }, /* FA */ + { 0x00, 0x00, 0 }, /* FB */ + { 0x00, 0x00, 0 }, /* FC */ + { 0x00, 0x00, 0 }, /* FD */ + { 0x00, 0x00, 0 }, /* FE */ + { 0xFF, 0x00, 1 }, /* FF */ +}; + +static int max98088_volatile_register(unsigned int reg) +{ + return max98088_access[reg].vol; +} + + +/* + * Load equalizer DSP coefficient configurations registers + */ +void m98088_eq_band(struct snd_soc_codec *codec, unsigned int dai, + unsigned int band, u16 *coefs) +{ + unsigned int eq_reg; + unsigned int i; + + BUG_ON(band > 4); + BUG_ON(dai > 1); + + /* Load the base register address */ + eq_reg = dai ? M98088_REG_84_DAI2_EQ_BASE : M98088_REG_52_DAI1_EQ_BASE; + + /* Add the band address offset, note adjustment for word address */ + eq_reg += band * (M98088_COEFS_PER_BAND << 1); + + /* Step through the registers and coefs */ + for (i = 0; i < M98088_COEFS_PER_BAND; i++) { + snd_soc_write(codec, eq_reg++, M98088_BYTE1(coefs[i])); + snd_soc_write(codec, eq_reg++, M98088_BYTE0(coefs[i])); + } +} + +/* + * Excursion limiter modes + */ +static const char *max98088_exmode_texts[] = { + "Off", "100Hz", "400Hz", "600Hz", "800Hz", "1000Hz", "200-400Hz", + "400-600Hz", "400-800Hz", +}; + +static const unsigned int max98088_exmode_values[] = { + 0x00, 0x43, 0x10, 0x20, 0x30, 0x40, 0x11, 0x22, 0x32 +}; + +static const struct soc_enum max98088_exmode_enum = + SOC_VALUE_ENUM_SINGLE(M98088_REG_41_SPKDHP, 0, 127, + ARRAY_SIZE(max98088_exmode_texts), + max98088_exmode_texts, + max98088_exmode_values); +static const struct snd_kcontrol_new max98088_exmode_controls = + SOC_DAPM_VALUE_ENUM("Route", max98088_exmode_enum); + +static const char *max98088_ex_thresh[] = { /* volts PP */ + "0.6", "1.2", "1.8", "2.4", "3.0", "3.6", "4.2", "4.8"}; +static const struct soc_enum max98088_ex_thresh_enum[] = { + SOC_ENUM_SINGLE(M98088_REG_42_SPKDHP_THRESH, 0, 8, + max98088_ex_thresh), +}; + +static const char *max98088_fltr_mode[] = {"Voice", "Music" }; +static const struct soc_enum max98088_filter_mode_enum[] = { + SOC_ENUM_SINGLE(M98088_REG_18_DAI1_FILTERS, 7, 2, max98088_fltr_mode), +}; + +static const char *max98088_extmic_text[] = { "None", "MIC1", "MIC2" }; + +static const struct soc_enum max98088_extmic_enum = + SOC_ENUM_SINGLE(M98088_REG_48_CFG_MIC, 0, 3, max98088_extmic_text); + +static const struct snd_kcontrol_new max98088_extmic_mux = + SOC_DAPM_ENUM("External MIC Mux", max98088_extmic_enum); + +static const char *max98088_dai1_fltr[] = { + "Off", "fc=258/fs=16k", "fc=500/fs=16k", + "fc=258/fs=8k", "fc=500/fs=8k", "fc=200"}; +static const struct soc_enum max98088_dai1_dac_filter_enum[] = { + SOC_ENUM_SINGLE(M98088_REG_18_DAI1_FILTERS, 0, 6, max98088_dai1_fltr), +}; +static const struct soc_enum max98088_dai1_adc_filter_enum[] = { + SOC_ENUM_SINGLE(M98088_REG_18_DAI1_FILTERS, 4, 6, max98088_dai1_fltr), +}; + +static int max98088_mic1pre_set(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + unsigned int sel = ucontrol->value.integer.value[0]; + + max98088->mic1pre = sel; + snd_soc_update_bits(codec, M98088_REG_35_LVL_MIC1, M98088_MICPRE_MASK, + (1+sel)<value.integer.value[0] = max98088->mic1pre; + return 0; +} + +static int max98088_mic2pre_set(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + unsigned int sel = ucontrol->value.integer.value[0]; + + max98088->mic2pre = sel; + snd_soc_update_bits(codec, M98088_REG_36_LVL_MIC2, M98088_MICPRE_MASK, + (1+sel)<value.integer.value[0] = max98088->mic2pre; + return 0; +} + +static const unsigned int max98088_micboost_tlv[] = { + TLV_DB_RANGE_HEAD(2), + 0, 1, TLV_DB_SCALE_ITEM(0, 2000, 0), + 2, 2, TLV_DB_SCALE_ITEM(3000, 0, 0), +}; + +static const struct snd_kcontrol_new max98088_snd_controls[] = { + + SOC_DOUBLE_R("Headphone Volume", M98088_REG_39_LVL_HP_L, + M98088_REG_3A_LVL_HP_R, 0, 31, 0), + SOC_DOUBLE_R("Speaker Volume", M98088_REG_3D_LVL_SPK_L, + M98088_REG_3E_LVL_SPK_R, 0, 31, 0), + SOC_DOUBLE_R("Receiver Volume", M98088_REG_3B_LVL_REC_L, + M98088_REG_3C_LVL_REC_R, 0, 31, 0), + + SOC_DOUBLE_R("Headphone Switch", M98088_REG_39_LVL_HP_L, + M98088_REG_3A_LVL_HP_R, 7, 1, 1), + SOC_DOUBLE_R("Speaker Switch", M98088_REG_3D_LVL_SPK_L, + M98088_REG_3E_LVL_SPK_R, 7, 1, 1), + SOC_DOUBLE_R("Receiver Switch", M98088_REG_3B_LVL_REC_L, + M98088_REG_3C_LVL_REC_R, 7, 1, 1), + + SOC_SINGLE("MIC1 Volume", M98088_REG_35_LVL_MIC1, 0, 31, 1), + SOC_SINGLE("MIC2 Volume", M98088_REG_36_LVL_MIC2, 0, 31, 1), + + SOC_SINGLE_EXT_TLV("MIC1 Boost Volume", + M98088_REG_35_LVL_MIC1, 5, 2, 0, + max98088_mic1pre_get, max98088_mic1pre_set, + max98088_micboost_tlv), + SOC_SINGLE_EXT_TLV("MIC2 Boost Volume", + M98088_REG_36_LVL_MIC2, 5, 2, 0, + max98088_mic2pre_get, max98088_mic2pre_set, + max98088_micboost_tlv), + + SOC_SINGLE("INA Volume", M98088_REG_37_LVL_INA, 0, 7, 1), + SOC_SINGLE("INB Volume", M98088_REG_38_LVL_INB, 0, 7, 1), + + SOC_SINGLE("ADCL Volume", M98088_REG_33_LVL_ADC_L, 0, 15, 0), + SOC_SINGLE("ADCR Volume", M98088_REG_34_LVL_ADC_R, 0, 15, 0), + + SOC_SINGLE("ADCL Boost Volume", M98088_REG_33_LVL_ADC_L, 4, 3, 0), + SOC_SINGLE("ADCR Boost Volume", M98088_REG_34_LVL_ADC_R, 4, 3, 0), + + SOC_SINGLE("EQ1 Switch", M98088_REG_49_CFG_LEVEL, 0, 1, 0), + SOC_SINGLE("EQ2 Switch", M98088_REG_49_CFG_LEVEL, 1, 1, 0), + + SOC_ENUM("EX Limiter Threshold", max98088_ex_thresh_enum), + + SOC_ENUM("DAI1 Filter Mode", max98088_filter_mode_enum), + SOC_ENUM("DAI1 DAC Filter", max98088_dai1_dac_filter_enum), + SOC_ENUM("DAI1 ADC Filter", max98088_dai1_adc_filter_enum), + SOC_SINGLE("DAI2 DC Block Switch", M98088_REG_20_DAI2_FILTERS, + 0, 1, 0), + + SOC_SINGLE("ALC Switch", M98088_REG_43_SPKALC_COMP, 7, 1, 0), + SOC_SINGLE("ALC Threshold", M98088_REG_43_SPKALC_COMP, 0, 7, 0), + SOC_SINGLE("ALC Multiband", M98088_REG_43_SPKALC_COMP, 3, 1, 0), + SOC_SINGLE("ALC Release Time", M98088_REG_43_SPKALC_COMP, 4, 7, 0), + + SOC_SINGLE("PWR Limiter Threshold", M98088_REG_44_PWRLMT_CFG, + 4, 15, 0), + SOC_SINGLE("PWR Limiter Weight", M98088_REG_44_PWRLMT_CFG, 0, 7, 0), + SOC_SINGLE("PWR Limiter Time1", M98088_REG_45_PWRLMT_TIME, 0, 15, 0), + SOC_SINGLE("PWR Limiter Time2", M98088_REG_45_PWRLMT_TIME, 4, 15, 0), + + SOC_SINGLE("THD Limiter Threshold", M98088_REG_46_THDLMT_CFG, 4, 15, 0), + SOC_SINGLE("THD Limiter Time", M98088_REG_46_THDLMT_CFG, 0, 7, 0), +}; + +/* Left speaker mixer switch */ +static const struct snd_kcontrol_new max98088_left_speaker_mixer_controls[] = { + SOC_DAPM_SINGLE("Left DAC1 Switch", M98088_REG_2B_MIX_SPK_LEFT, 7, 1, 0), + SOC_DAPM_SINGLE("Right DAC1 Switch", M98088_REG_2B_MIX_SPK_LEFT, 0, 1, 0), + SOC_DAPM_SINGLE("Left DAC2 Switch", M98088_REG_2B_MIX_SPK_LEFT, 7, 1, 0), + SOC_DAPM_SINGLE("Right DAC2 Switch", M98088_REG_2B_MIX_SPK_LEFT, 0, 1, 0), + SOC_DAPM_SINGLE("MIC1 Switch", M98088_REG_2B_MIX_SPK_LEFT, 5, 1, 0), + SOC_DAPM_SINGLE("MIC2 Switch", M98088_REG_2B_MIX_SPK_LEFT, 6, 1, 0), + SOC_DAPM_SINGLE("INA1 Switch", M98088_REG_2B_MIX_SPK_LEFT, 1, 1, 0), + SOC_DAPM_SINGLE("INA2 Switch", M98088_REG_2B_MIX_SPK_LEFT, 2, 1, 0), + SOC_DAPM_SINGLE("INB1 Switch", M98088_REG_2B_MIX_SPK_LEFT, 3, 1, 0), + SOC_DAPM_SINGLE("INB2 Switch", M98088_REG_2B_MIX_SPK_LEFT, 4, 1, 0), +}; + +/* Right speaker mixer switch */ +static const struct snd_kcontrol_new max98088_right_speaker_mixer_controls[] = { + SOC_DAPM_SINGLE("Left DAC1 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 7, 1, 0), + SOC_DAPM_SINGLE("Right DAC1 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 0, 1, 0), + SOC_DAPM_SINGLE("Left DAC2 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 7, 1, 0), + SOC_DAPM_SINGLE("Right DAC2 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 0, 1, 0), + SOC_DAPM_SINGLE("MIC1 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 5, 1, 0), + SOC_DAPM_SINGLE("MIC2 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 6, 1, 0), + SOC_DAPM_SINGLE("INA1 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 1, 1, 0), + SOC_DAPM_SINGLE("INA2 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 2, 1, 0), + SOC_DAPM_SINGLE("INB1 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 3, 1, 0), + SOC_DAPM_SINGLE("INB2 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 4, 1, 0), +}; + +/* Left headphone mixer switch */ +static const struct snd_kcontrol_new max98088_left_hp_mixer_controls[] = { + SOC_DAPM_SINGLE("Left DAC1 Switch", M98088_REG_25_MIX_HP_LEFT, 7, 1, 0), + SOC_DAPM_SINGLE("Right DAC1 Switch", M98088_REG_25_MIX_HP_LEFT, 0, 1, 0), + SOC_DAPM_SINGLE("Left DAC2 Switch", M98088_REG_25_MIX_HP_LEFT, 7, 1, 0), + SOC_DAPM_SINGLE("Right DAC2 Switch", M98088_REG_25_MIX_HP_LEFT, 0, 1, 0), + SOC_DAPM_SINGLE("MIC1 Switch", M98088_REG_25_MIX_HP_LEFT, 5, 1, 0), + SOC_DAPM_SINGLE("MIC2 Switch", M98088_REG_25_MIX_HP_LEFT, 6, 1, 0), + SOC_DAPM_SINGLE("INA1 Switch", M98088_REG_25_MIX_HP_LEFT, 1, 1, 0), + SOC_DAPM_SINGLE("INA2 Switch", M98088_REG_25_MIX_HP_LEFT, 2, 1, 0), + SOC_DAPM_SINGLE("INB1 Switch", M98088_REG_25_MIX_HP_LEFT, 3, 1, 0), + SOC_DAPM_SINGLE("INB2 Switch", M98088_REG_25_MIX_HP_LEFT, 4, 1, 0), +}; + +/* Right headphone mixer switch */ +static const struct snd_kcontrol_new max98088_right_hp_mixer_controls[] = { + SOC_DAPM_SINGLE("Left DAC1 Switch", M98088_REG_26_MIX_HP_RIGHT, 7, 1, 0), + SOC_DAPM_SINGLE("Right DAC1 Switch", M98088_REG_26_MIX_HP_RIGHT, 0, 1, 0), + SOC_DAPM_SINGLE("Left DAC2 Switch", M98088_REG_26_MIX_HP_RIGHT, 7, 1, 0), + SOC_DAPM_SINGLE("Right DAC2 Switch", M98088_REG_26_MIX_HP_RIGHT, 0, 1, 0), + SOC_DAPM_SINGLE("MIC1 Switch", M98088_REG_26_MIX_HP_RIGHT, 5, 1, 0), + SOC_DAPM_SINGLE("MIC2 Switch", M98088_REG_26_MIX_HP_RIGHT, 6, 1, 0), + SOC_DAPM_SINGLE("INA1 Switch", M98088_REG_26_MIX_HP_RIGHT, 1, 1, 0), + SOC_DAPM_SINGLE("INA2 Switch", M98088_REG_26_MIX_HP_RIGHT, 2, 1, 0), + SOC_DAPM_SINGLE("INB1 Switch", M98088_REG_26_MIX_HP_RIGHT, 3, 1, 0), + SOC_DAPM_SINGLE("INB2 Switch", M98088_REG_26_MIX_HP_RIGHT, 4, 1, 0), +}; + +/* Left earpiece/receiver mixer switch */ +static const struct snd_kcontrol_new max98088_left_rec_mixer_controls[] = { + SOC_DAPM_SINGLE("Left DAC1 Switch", M98088_REG_28_MIX_REC_LEFT, 7, 1, 0), + SOC_DAPM_SINGLE("Right DAC1 Switch", M98088_REG_28_MIX_REC_LEFT, 0, 1, 0), + SOC_DAPM_SINGLE("Left DAC2 Switch", M98088_REG_28_MIX_REC_LEFT, 7, 1, 0), + SOC_DAPM_SINGLE("Right DAC2 Switch", M98088_REG_28_MIX_REC_LEFT, 0, 1, 0), + SOC_DAPM_SINGLE("MIC1 Switch", M98088_REG_28_MIX_REC_LEFT, 5, 1, 0), + SOC_DAPM_SINGLE("MIC2 Switch", M98088_REG_28_MIX_REC_LEFT, 6, 1, 0), + SOC_DAPM_SINGLE("INA1 Switch", M98088_REG_28_MIX_REC_LEFT, 1, 1, 0), + SOC_DAPM_SINGLE("INA2 Switch", M98088_REG_28_MIX_REC_LEFT, 2, 1, 0), + SOC_DAPM_SINGLE("INB1 Switch", M98088_REG_28_MIX_REC_LEFT, 3, 1, 0), + SOC_DAPM_SINGLE("INB2 Switch", M98088_REG_28_MIX_REC_LEFT, 4, 1, 0), +}; + +/* Right earpiece/receiver mixer switch */ +static const struct snd_kcontrol_new max98088_right_rec_mixer_controls[] = { + SOC_DAPM_SINGLE("Left DAC1 Switch", M98088_REG_29_MIX_REC_RIGHT, 7, 1, 0), + SOC_DAPM_SINGLE("Right DAC1 Switch", M98088_REG_29_MIX_REC_RIGHT, 0, 1, 0), + SOC_DAPM_SINGLE("Left DAC2 Switch", M98088_REG_29_MIX_REC_RIGHT, 7, 1, 0), + SOC_DAPM_SINGLE("Right DAC2 Switch", M98088_REG_29_MIX_REC_RIGHT, 0, 1, 0), + SOC_DAPM_SINGLE("MIC1 Switch", M98088_REG_29_MIX_REC_RIGHT, 5, 1, 0), + SOC_DAPM_SINGLE("MIC2 Switch", M98088_REG_29_MIX_REC_RIGHT, 6, 1, 0), + SOC_DAPM_SINGLE("INA1 Switch", M98088_REG_29_MIX_REC_RIGHT, 1, 1, 0), + SOC_DAPM_SINGLE("INA2 Switch", M98088_REG_29_MIX_REC_RIGHT, 2, 1, 0), + SOC_DAPM_SINGLE("INB1 Switch", M98088_REG_29_MIX_REC_RIGHT, 3, 1, 0), + SOC_DAPM_SINGLE("INB2 Switch", M98088_REG_29_MIX_REC_RIGHT, 4, 1, 0), +}; + +/* Left ADC mixer switch */ +static const struct snd_kcontrol_new max98088_left_ADC_mixer_controls[] = { + SOC_DAPM_SINGLE("MIC1 Switch", M98088_REG_23_MIX_ADC_LEFT, 7, 1, 0), + SOC_DAPM_SINGLE("MIC2 Switch", M98088_REG_23_MIX_ADC_LEFT, 6, 1, 0), + SOC_DAPM_SINGLE("INA1 Switch", M98088_REG_23_MIX_ADC_LEFT, 3, 1, 0), + SOC_DAPM_SINGLE("INA2 Switch", M98088_REG_23_MIX_ADC_LEFT, 2, 1, 0), + SOC_DAPM_SINGLE("INB1 Switch", M98088_REG_23_MIX_ADC_LEFT, 1, 1, 0), + SOC_DAPM_SINGLE("INB2 Switch", M98088_REG_23_MIX_ADC_LEFT, 0, 1, 0), +}; + +/* Right ADC mixer switch */ +static const struct snd_kcontrol_new max98088_right_ADC_mixer_controls[] = { + SOC_DAPM_SINGLE("MIC1 Switch", M98088_REG_24_MIX_ADC_RIGHT, 7, 1, 0), + SOC_DAPM_SINGLE("MIC2 Switch", M98088_REG_24_MIX_ADC_RIGHT, 6, 1, 0), + SOC_DAPM_SINGLE("INA1 Switch", M98088_REG_24_MIX_ADC_RIGHT, 3, 1, 0), + SOC_DAPM_SINGLE("INA2 Switch", M98088_REG_24_MIX_ADC_RIGHT, 2, 1, 0), + SOC_DAPM_SINGLE("INB1 Switch", M98088_REG_24_MIX_ADC_RIGHT, 1, 1, 0), + SOC_DAPM_SINGLE("INB2 Switch", M98088_REG_24_MIX_ADC_RIGHT, 0, 1, 0), +}; + +static int max98088_mic_event(struct snd_soc_dapm_widget *w, + struct snd_kcontrol *kcontrol, int event) +{ + struct snd_soc_codec *codec = w->codec; + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + + switch (event) { + case SND_SOC_DAPM_POST_PMU: + if (w->reg == M98088_REG_35_LVL_MIC1) { + snd_soc_update_bits(codec, w->reg, M98088_MICPRE_MASK, + (1+max98088->mic1pre)<reg, M98088_MICPRE_MASK, + (1+max98088->mic2pre)<reg, M98088_MICPRE_MASK, 0); + break; + default: + return -EINVAL; + } + + return 0; +} + +/* + * The line inputs are 2-channel stereo inputs with the left + * and right channels sharing a common PGA power control signal. + */ +static int max98088_line_pga(struct snd_soc_dapm_widget *w, + int event, int line, u8 channel) +{ + struct snd_soc_codec *codec = w->codec; + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + u8 *state; + + BUG_ON(!((channel == 1) || (channel == 2))); + + switch (line) { + case LINE_INA: + state = &max98088->ina_state; + break; + case LINE_INB: + state = &max98088->inb_state; + break; + default: + return -EINVAL; + } + + switch (event) { + case SND_SOC_DAPM_POST_PMU: + *state |= channel; + snd_soc_update_bits(codec, w->reg, + (1 << w->shift), (1 << w->shift)); + break; + case SND_SOC_DAPM_POST_PMD: + *state &= ~channel; + if (*state == 0) { + snd_soc_update_bits(codec, w->reg, + (1 << w->shift), 0); + } + break; + default: + return -EINVAL; + } + + return 0; +} + +static int max98088_pga_ina1_event(struct snd_soc_dapm_widget *w, + struct snd_kcontrol *k, int event) +{ + return max98088_line_pga(w, event, LINE_INA, 1); +} + +static int max98088_pga_ina2_event(struct snd_soc_dapm_widget *w, + struct snd_kcontrol *k, int event) +{ + return max98088_line_pga(w, event, LINE_INA, 2); +} + +static int max98088_pga_inb1_event(struct snd_soc_dapm_widget *w, + struct snd_kcontrol *k, int event) +{ + return max98088_line_pga(w, event, LINE_INB, 1); +} + +static int max98088_pga_inb2_event(struct snd_soc_dapm_widget *w, + struct snd_kcontrol *k, int event) +{ + return max98088_line_pga(w, event, LINE_INB, 2); +} + +static const struct snd_soc_dapm_widget max98088_dapm_widgets[] = { + + SND_SOC_DAPM_ADC("ADCL", "HiFi Capture", M98088_REG_4C_PWR_EN_IN, 1, 0), + SND_SOC_DAPM_ADC("ADCR", "HiFi Capture", M98088_REG_4C_PWR_EN_IN, 0, 0), + + SND_SOC_DAPM_DAC("DACL1", "HiFi Playback", + M98088_REG_4D_PWR_EN_OUT, 1, 0), + SND_SOC_DAPM_DAC("DACR1", "HiFi Playback", + M98088_REG_4D_PWR_EN_OUT, 0, 0), + SND_SOC_DAPM_DAC("DACL2", "Aux Playback", + M98088_REG_4D_PWR_EN_OUT, 1, 0), + SND_SOC_DAPM_DAC("DACR2", "Aux Playback", + M98088_REG_4D_PWR_EN_OUT, 0, 0), + + SND_SOC_DAPM_PGA("HP Left Out", M98088_REG_4D_PWR_EN_OUT, + 7, 0, NULL, 0), + SND_SOC_DAPM_PGA("HP Right Out", M98088_REG_4D_PWR_EN_OUT, + 6, 0, NULL, 0), + + SND_SOC_DAPM_PGA("SPK Left Out", M98088_REG_4D_PWR_EN_OUT, + 5, 0, NULL, 0), + SND_SOC_DAPM_PGA("SPK Right Out", M98088_REG_4D_PWR_EN_OUT, + 4, 0, NULL, 0), + + SND_SOC_DAPM_PGA("REC Left Out", M98088_REG_4D_PWR_EN_OUT, + 3, 0, NULL, 0), + SND_SOC_DAPM_PGA("REC Right Out", M98088_REG_4D_PWR_EN_OUT, + 2, 0, NULL, 0), + + SND_SOC_DAPM_MUX("External MIC", SND_SOC_NOPM, 0, 0, + &max98088_extmic_mux), + + SND_SOC_DAPM_MIXER("Left HP Mixer", SND_SOC_NOPM, 0, 0, + &max98088_left_hp_mixer_controls[0], + ARRAY_SIZE(max98088_left_hp_mixer_controls)), + + SND_SOC_DAPM_MIXER("Right HP Mixer", SND_SOC_NOPM, 0, 0, + &max98088_right_hp_mixer_controls[0], + ARRAY_SIZE(max98088_right_hp_mixer_controls)), + + SND_SOC_DAPM_MIXER("Left SPK Mixer", SND_SOC_NOPM, 0, 0, + &max98088_left_speaker_mixer_controls[0], + ARRAY_SIZE(max98088_left_speaker_mixer_controls)), + + SND_SOC_DAPM_MIXER("Right SPK Mixer", SND_SOC_NOPM, 0, 0, + &max98088_right_speaker_mixer_controls[0], + ARRAY_SIZE(max98088_right_speaker_mixer_controls)), + + SND_SOC_DAPM_MIXER("Left REC Mixer", SND_SOC_NOPM, 0, 0, + &max98088_left_rec_mixer_controls[0], + ARRAY_SIZE(max98088_left_rec_mixer_controls)), + + SND_SOC_DAPM_MIXER("Right REC Mixer", SND_SOC_NOPM, 0, 0, + &max98088_right_rec_mixer_controls[0], + ARRAY_SIZE(max98088_right_rec_mixer_controls)), + + SND_SOC_DAPM_MIXER("Left ADC Mixer", SND_SOC_NOPM, 0, 0, + &max98088_left_ADC_mixer_controls[0], + ARRAY_SIZE(max98088_left_ADC_mixer_controls)), + + SND_SOC_DAPM_MIXER("Right ADC Mixer", SND_SOC_NOPM, 0, 0, + &max98088_right_ADC_mixer_controls[0], + ARRAY_SIZE(max98088_right_ADC_mixer_controls)), + + SND_SOC_DAPM_PGA_E("MIC1 Input", M98088_REG_35_LVL_MIC1, + 5, 0, NULL, 0, max98088_mic_event, + SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), + + SND_SOC_DAPM_PGA_E("MIC2 Input", M98088_REG_36_LVL_MIC2, + 5, 0, NULL, 0, max98088_mic_event, + SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), + + SND_SOC_DAPM_PGA_E("INA1 Input", M98088_REG_4C_PWR_EN_IN, + 7, 0, NULL, 0, max98088_pga_ina1_event, + SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), + + SND_SOC_DAPM_PGA_E("INA2 Input", M98088_REG_4C_PWR_EN_IN, + 7, 0, NULL, 0, max98088_pga_ina2_event, + SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), + + SND_SOC_DAPM_PGA_E("INB1 Input", M98088_REG_4C_PWR_EN_IN, + 6, 0, NULL, 0, max98088_pga_inb1_event, + SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), + + SND_SOC_DAPM_PGA_E("INB2 Input", M98088_REG_4C_PWR_EN_IN, + 6, 0, NULL, 0, max98088_pga_inb2_event, + SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), + + SND_SOC_DAPM_MICBIAS("MICBIAS", M98088_REG_4C_PWR_EN_IN, 3, 0), + + SND_SOC_DAPM_MUX("EX Limiter Mode", SND_SOC_NOPM, 0, 0, + &max98088_exmode_controls), + + SND_SOC_DAPM_OUTPUT("HPL"), + SND_SOC_DAPM_OUTPUT("HPR"), + SND_SOC_DAPM_OUTPUT("SPKL"), + SND_SOC_DAPM_OUTPUT("SPKR"), + SND_SOC_DAPM_OUTPUT("RECL"), + SND_SOC_DAPM_OUTPUT("RECR"), + + SND_SOC_DAPM_INPUT("MIC1"), + SND_SOC_DAPM_INPUT("MIC2"), + SND_SOC_DAPM_INPUT("INA1"), + SND_SOC_DAPM_INPUT("INA2"), + SND_SOC_DAPM_INPUT("INB1"), + SND_SOC_DAPM_INPUT("INB2"), +}; + +static const struct snd_soc_dapm_route audio_map[] = { + /* Left headphone output mixer */ + {"Left HP Mixer", "Left DAC1 Switch", "DACL1"}, + {"Left HP Mixer", "Left DAC2 Switch", "DACL2"}, + {"Left HP Mixer", "Right DAC1 Switch", "DACR1"}, + {"Left HP Mixer", "Right DAC2 Switch", "DACR2"}, + {"Left HP Mixer", "MIC1 Switch", "MIC1 Input"}, + {"Left HP Mixer", "MIC2 Switch", "MIC2 Input"}, + {"Left HP Mixer", "INA1 Switch", "INA1 Input"}, + {"Left HP Mixer", "INA2 Switch", "INA2 Input"}, + {"Left HP Mixer", "INB1 Switch", "INB1 Input"}, + {"Left HP Mixer", "INB2 Switch", "INB2 Input"}, + + /* Right headphone output mixer */ + {"Right HP Mixer", "Left DAC1 Switch", "DACL1"}, + {"Right HP Mixer", "Left DAC2 Switch", "DACL2" }, + {"Right HP Mixer", "Right DAC1 Switch", "DACR1"}, + {"Right HP Mixer", "Right DAC2 Switch", "DACR2"}, + {"Right HP Mixer", "MIC1 Switch", "MIC1 Input"}, + {"Right HP Mixer", "MIC2 Switch", "MIC2 Input"}, + {"Right HP Mixer", "INA1 Switch", "INA1 Input"}, + {"Right HP Mixer", "INA2 Switch", "INA2 Input"}, + {"Right HP Mixer", "INB1 Switch", "INB1 Input"}, + {"Right HP Mixer", "INB2 Switch", "INB2 Input"}, + + /* Left speaker output mixer */ + {"Left SPK Mixer", "Left DAC1 Switch", "DACL1"}, + {"Left SPK Mixer", "Left DAC2 Switch", "DACL2"}, + {"Left SPK Mixer", "Right DAC1 Switch", "DACR1"}, + {"Left SPK Mixer", "Right DAC2 Switch", "DACR2"}, + {"Left SPK Mixer", "MIC1 Switch", "MIC1 Input"}, + {"Left SPK Mixer", "MIC2 Switch", "MIC2 Input"}, + {"Left SPK Mixer", "INA1 Switch", "INA1 Input"}, + {"Left SPK Mixer", "INA2 Switch", "INA2 Input"}, + {"Left SPK Mixer", "INB1 Switch", "INB1 Input"}, + {"Left SPK Mixer", "INB2 Switch", "INB2 Input"}, + + /* Right speaker output mixer */ + {"Right SPK Mixer", "Left DAC1 Switch", "DACL1"}, + {"Right SPK Mixer", "Left DAC2 Switch", "DACL2"}, + {"Right SPK Mixer", "Right DAC1 Switch", "DACR1"}, + {"Right SPK Mixer", "Right DAC2 Switch", "DACR2"}, + {"Right SPK Mixer", "MIC1 Switch", "MIC1 Input"}, + {"Right SPK Mixer", "MIC2 Switch", "MIC2 Input"}, + {"Right SPK Mixer", "INA1 Switch", "INA1 Input"}, + {"Right SPK Mixer", "INA2 Switch", "INA2 Input"}, + {"Right SPK Mixer", "INB1 Switch", "INB1 Input"}, + {"Right SPK Mixer", "INB2 Switch", "INB2 Input"}, + + /* Earpiece/Receiver output mixer */ + {"Left REC Mixer", "Left DAC1 Switch", "DACL1"}, + {"Left REC Mixer", "Left DAC2 Switch", "DACL2"}, + {"Left REC Mixer", "Right DAC1 Switch", "DACR1"}, + {"Left REC Mixer", "Right DAC2 Switch", "DACR2"}, + {"Left REC Mixer", "MIC1 Switch", "MIC1 Input"}, + {"Left REC Mixer", "MIC2 Switch", "MIC2 Input"}, + {"Left REC Mixer", "INA1 Switch", "INA1 Input"}, + {"Left REC Mixer", "INA2 Switch", "INA2 Input"}, + {"Left REC Mixer", "INB1 Switch", "INB1 Input"}, + {"Left REC Mixer", "INB2 Switch", "INB2 Input"}, + + /* Earpiece/Receiver output mixer */ + {"Right REC Mixer", "Left DAC1 Switch", "DACL1"}, + {"Right REC Mixer", "Left DAC2 Switch", "DACL2"}, + {"Right REC Mixer", "Right DAC1 Switch", "DACR1"}, + {"Right REC Mixer", "Right DAC2 Switch", "DACR2"}, + {"Right REC Mixer", "MIC1 Switch", "MIC1 Input"}, + {"Right REC Mixer", "MIC2 Switch", "MIC2 Input"}, + {"Right REC Mixer", "INA1 Switch", "INA1 Input"}, + {"Right REC Mixer", "INA2 Switch", "INA2 Input"}, + {"Right REC Mixer", "INB1 Switch", "INB1 Input"}, + {"Right REC Mixer", "INB2 Switch", "INB2 Input"}, + + {"HP Left Out", NULL, "Left HP Mixer"}, + {"HP Right Out", NULL, "Right HP Mixer"}, + {"SPK Left Out", NULL, "Left SPK Mixer"}, + {"SPK Right Out", NULL, "Right SPK Mixer"}, + {"REC Left Out", NULL, "Left REC Mixer"}, + {"REC Right Out", NULL, "Right REC Mixer"}, + + {"HPL", NULL, "HP Left Out"}, + {"HPR", NULL, "HP Right Out"}, + {"SPKL", NULL, "SPK Left Out"}, + {"SPKR", NULL, "SPK Right Out"}, + {"RECL", NULL, "REC Left Out"}, + {"RECR", NULL, "REC Right Out"}, + + /* Left ADC input mixer */ + {"Left ADC Mixer", "MIC1 Switch", "MIC1 Input"}, + {"Left ADC Mixer", "MIC2 Switch", "MIC2 Input"}, + {"Left ADC Mixer", "INA1 Switch", "INA1 Input"}, + {"Left ADC Mixer", "INA2 Switch", "INA2 Input"}, + {"Left ADC Mixer", "INB1 Switch", "INB1 Input"}, + {"Left ADC Mixer", "INB2 Switch", "INB2 Input"}, + + /* Right ADC input mixer */ + {"Right ADC Mixer", "MIC1 Switch", "MIC1 Input"}, + {"Right ADC Mixer", "MIC2 Switch", "MIC2 Input"}, + {"Right ADC Mixer", "INA1 Switch", "INA1 Input"}, + {"Right ADC Mixer", "INA2 Switch", "INA2 Input"}, + {"Right ADC Mixer", "INB1 Switch", "INB1 Input"}, + {"Right ADC Mixer", "INB2 Switch", "INB2 Input"}, + + /* Inputs */ + {"ADCL", NULL, "Left ADC Mixer"}, + {"ADCR", NULL, "Right ADC Mixer"}, + {"INA1 Input", NULL, "INA1"}, + {"INA2 Input", NULL, "INA2"}, + {"INB1 Input", NULL, "INB1"}, + {"INB2 Input", NULL, "INB2"}, + {"MIC1 Input", NULL, "MIC1"}, + {"MIC2 Input", NULL, "MIC2"}, +}; + +static int max98088_add_widgets(struct snd_soc_codec *codec) +{ + snd_soc_dapm_new_controls(codec, max98088_dapm_widgets, + ARRAY_SIZE(max98088_dapm_widgets)); + + snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map)); + + snd_soc_add_controls(codec, max98088_snd_controls, + ARRAY_SIZE(max98088_snd_controls)); + + snd_soc_dapm_new_widgets(codec); + return 0; +} + +/* codec mclk clock divider coefficients */ +static const struct { + u32 rate; + u8 sr; +} rate_table[] = { + {8000, 0x10}, + {11025, 0x20}, + {16000, 0x30}, + {22050, 0x40}, + {24000, 0x50}, + {32000, 0x60}, + {44100, 0x70}, + {48000, 0x80}, + {88200, 0x90}, + {96000, 0xA0}, +}; + +static inline int rate_value(int rate, u8 *value) +{ + int i; + + for (i = 0; i < ARRAY_SIZE(rate_table); i++) { + if (rate_table[i].rate >= rate) { + *value = rate_table[i].sr; + return 0; + } + } + *value = rate_table[0].sr; + return -EINVAL; +} + +static int max98088_dai1_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params, + struct snd_soc_dai *dai) +{ + struct snd_soc_codec *codec = dai->codec; + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + struct max98088_cdata *cdata; + unsigned long long ni; + unsigned int rate; + u8 regval; + + cdata = &max98088->dai[0]; + + rate = params_rate(params); + + switch (params_format(params)) { + case SNDRV_PCM_FORMAT_S16_LE: + snd_soc_update_bits(codec, M98088_REG_14_DAI1_FORMAT, + M98088_DAI_WS, 0); + break; + case SNDRV_PCM_FORMAT_S24_LE: + snd_soc_update_bits(codec, M98088_REG_14_DAI1_FORMAT, + M98088_DAI_WS, M98088_DAI_WS); + break; + default: + return -EINVAL; + } + + snd_soc_update_bits(codec, M98088_REG_51_PWR_SYS, M98088_SHDNRUN, 0); + + if (rate_value(rate, ®val)) + return -EINVAL; + + snd_soc_update_bits(codec, M98088_REG_11_DAI1_CLKMODE, + M98088_CLKMODE_MASK, regval); + cdata->rate = rate; + + /* Configure NI when operating as master */ + if (snd_soc_read(codec, M98088_REG_14_DAI1_FORMAT) + & M98088_DAI_MAS) { + if (max98088->sysclk == 0) { + dev_err(codec->dev, "Invalid system clock frequency\n"); + return -EINVAL; + } + ni = 65536ULL * (rate < 50000 ? 96ULL : 48ULL) + * (unsigned long long int)rate; + do_div(ni, (unsigned long long int)max98088->sysclk); + snd_soc_write(codec, M98088_REG_12_DAI1_CLKCFG_HI, + (ni >> 8) & 0x7F); + snd_soc_write(codec, M98088_REG_13_DAI1_CLKCFG_LO, + ni & 0xFF); + } + + /* Update sample rate mode */ + if (rate < 50000) + snd_soc_update_bits(codec, M98088_REG_18_DAI1_FILTERS, + M98088_DAI_DHF, 0); + else + snd_soc_update_bits(codec, M98088_REG_18_DAI1_FILTERS, + M98088_DAI_DHF, M98088_DAI_DHF); + + snd_soc_update_bits(codec, M98088_REG_51_PWR_SYS, M98088_SHDNRUN, + M98088_SHDNRUN); + + return 0; +} + +static int max98088_dai2_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params, + struct snd_soc_dai *dai) +{ + struct snd_soc_codec *codec = dai->codec; + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + struct max98088_cdata *cdata; + unsigned long long ni; + unsigned int rate; + u8 regval; + + cdata = &max98088->dai[1]; + + rate = params_rate(params); + + switch (params_format(params)) { + case SNDRV_PCM_FORMAT_S16_LE: + snd_soc_update_bits(codec, M98088_REG_1C_DAI2_FORMAT, + M98088_DAI_WS, 0); + break; + case SNDRV_PCM_FORMAT_S24_LE: + snd_soc_update_bits(codec, M98088_REG_1C_DAI2_FORMAT, + M98088_DAI_WS, M98088_DAI_WS); + break; + default: + return -EINVAL; + } + + snd_soc_update_bits(codec, M98088_REG_51_PWR_SYS, M98088_SHDNRUN, 0); + + if (rate_value(rate, ®val)) + return -EINVAL; + + snd_soc_update_bits(codec, M98088_REG_19_DAI2_CLKMODE, + M98088_CLKMODE_MASK, regval); + cdata->rate = rate; + + /* Configure NI when operating as master */ + if (snd_soc_read(codec, M98088_REG_1C_DAI2_FORMAT) + & M98088_DAI_MAS) { + if (max98088->sysclk == 0) { + dev_err(codec->dev, "Invalid system clock frequency\n"); + return -EINVAL; + } + ni = 65536ULL * (rate < 50000 ? 96ULL : 48ULL) + * (unsigned long long int)rate; + do_div(ni, (unsigned long long int)max98088->sysclk); + snd_soc_write(codec, M98088_REG_1A_DAI2_CLKCFG_HI, + (ni >> 8) & 0x7F); + snd_soc_write(codec, M98088_REG_1B_DAI2_CLKCFG_LO, + ni & 0xFF); + } + + /* Update sample rate mode */ + if (rate < 50000) + snd_soc_update_bits(codec, M98088_REG_20_DAI2_FILTERS, + M98088_DAI_DHF, 0); + else + snd_soc_update_bits(codec, M98088_REG_20_DAI2_FILTERS, + M98088_DAI_DHF, M98088_DAI_DHF); + + snd_soc_update_bits(codec, M98088_REG_51_PWR_SYS, M98088_SHDNRUN, + M98088_SHDNRUN); + + return 0; +} + +static int max98088_dai_set_sysclk(struct snd_soc_dai *dai, + int clk_id, unsigned int freq, int dir) +{ + struct snd_soc_codec *codec = dai->codec; + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + + /* Requested clock frequency is already setup */ + if (freq == max98088->sysclk) + return 0; + + max98088->sysclk = freq; /* remember current sysclk */ + + /* Setup clocks for slave mode, and using the PLL + * PSCLK = 0x01 (when master clk is 10MHz to 20MHz) + * 0x02 (when master clk is 20MHz to 30MHz).. + */ + if ((freq >= 10000000) && (freq < 20000000)) { + snd_soc_write(codec, M98088_REG_10_SYS_CLK, 0x10); + } else if ((freq >= 20000000) && (freq < 30000000)) { + snd_soc_write(codec, M98088_REG_10_SYS_CLK, 0x20); + } else { + dev_err(codec->dev, "Invalid master clock frequency\n"); + return -EINVAL; + } + + if (snd_soc_read(codec, M98088_REG_51_PWR_SYS) & M98088_SHDNRUN) { + snd_soc_update_bits(codec, M98088_REG_51_PWR_SYS, + M98088_SHDNRUN, 0); + snd_soc_update_bits(codec, M98088_REG_51_PWR_SYS, + M98088_SHDNRUN, M98088_SHDNRUN); + } + + dev_dbg(dai->dev, "Clock source is %d at %uHz\n", clk_id, freq); + + max98088->sysclk = freq; + return 0; +} + +static int max98088_dai1_set_fmt(struct snd_soc_dai *codec_dai, + unsigned int fmt) +{ + struct snd_soc_codec *codec = codec_dai->codec; + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + struct max98088_cdata *cdata; + u8 reg15val; + u8 reg14val = 0; + + cdata = &max98088->dai[0]; + + if (fmt != cdata->fmt) { + cdata->fmt = fmt; + + switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { + case SND_SOC_DAIFMT_CBS_CFS: + /* Slave mode PLL */ + snd_soc_write(codec, M98088_REG_12_DAI1_CLKCFG_HI, + 0x80); + snd_soc_write(codec, M98088_REG_13_DAI1_CLKCFG_LO, + 0x00); + break; + case SND_SOC_DAIFMT_CBM_CFM: + /* Set to master mode */ + reg14val |= M98088_DAI_MAS; + break; + case SND_SOC_DAIFMT_CBS_CFM: + case SND_SOC_DAIFMT_CBM_CFS: + default: + dev_err(codec->dev, "Clock mode unsupported"); + return -EINVAL; + } + + switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { + case SND_SOC_DAIFMT_I2S: + reg14val |= M98088_DAI_DLY; + break; + case SND_SOC_DAIFMT_LEFT_J: + break; + default: + return -EINVAL; + } + + switch (fmt & SND_SOC_DAIFMT_INV_MASK) { + case SND_SOC_DAIFMT_NB_NF: + break; + case SND_SOC_DAIFMT_NB_IF: + reg14val |= M98088_DAI_WCI; + break; + case SND_SOC_DAIFMT_IB_NF: + reg14val |= M98088_DAI_BCI; + break; + case SND_SOC_DAIFMT_IB_IF: + reg14val |= M98088_DAI_BCI|M98088_DAI_WCI; + break; + default: + return -EINVAL; + } + + snd_soc_update_bits(codec, M98088_REG_14_DAI1_FORMAT, + M98088_DAI_MAS | M98088_DAI_DLY | M98088_DAI_BCI | + M98088_DAI_WCI, reg14val); + + reg15val = M98088_DAI_BSEL64; + if (max98088->digmic) + reg15val |= M98088_DAI_OSR64; + snd_soc_write(codec, M98088_REG_15_DAI1_CLOCK, reg15val); + } + + return 0; +} + +static int max98088_dai2_set_fmt(struct snd_soc_dai *codec_dai, + unsigned int fmt) +{ + struct snd_soc_codec *codec = codec_dai->codec; + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + struct max98088_cdata *cdata; + u8 reg1Cval = 0; + + cdata = &max98088->dai[1]; + + if (fmt != cdata->fmt) { + cdata->fmt = fmt; + + switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { + case SND_SOC_DAIFMT_CBS_CFS: + /* Slave mode PLL */ + snd_soc_write(codec, M98088_REG_1A_DAI2_CLKCFG_HI, + 0x80); + snd_soc_write(codec, M98088_REG_1B_DAI2_CLKCFG_LO, + 0x00); + break; + case SND_SOC_DAIFMT_CBM_CFM: + /* Set to master mode */ + reg1Cval |= M98088_DAI_MAS; + break; + case SND_SOC_DAIFMT_CBS_CFM: + case SND_SOC_DAIFMT_CBM_CFS: + default: + dev_err(codec->dev, "Clock mode unsupported"); + return -EINVAL; + } + + switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { + case SND_SOC_DAIFMT_I2S: + reg1Cval |= M98088_DAI_DLY; + break; + case SND_SOC_DAIFMT_LEFT_J: + break; + default: + return -EINVAL; + } + + switch (fmt & SND_SOC_DAIFMT_INV_MASK) { + case SND_SOC_DAIFMT_NB_NF: + break; + case SND_SOC_DAIFMT_NB_IF: + reg1Cval |= M98088_DAI_WCI; + break; + case SND_SOC_DAIFMT_IB_NF: + reg1Cval |= M98088_DAI_BCI; + break; + case SND_SOC_DAIFMT_IB_IF: + reg1Cval |= M98088_DAI_BCI|M98088_DAI_WCI; + break; + default: + return -EINVAL; + } + + snd_soc_update_bits(codec, M98088_REG_1C_DAI2_FORMAT, + M98088_DAI_MAS | M98088_DAI_DLY | M98088_DAI_BCI | + M98088_DAI_WCI, reg1Cval); + + snd_soc_write(codec, M98088_REG_1D_DAI2_CLOCK, + M98088_DAI_BSEL64); + } + + return 0; +} + +static void max98088_sync_cache(struct snd_soc_codec *codec) +{ + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + int i; + + if (!codec->cache_sync) + return; + + codec->cache_only = 0; + + /* write back cached values if they're writeable and + * different from the hardware default. + */ + for (i = 1; i < ARRAY_SIZE(max98088->reg_cache); i++) { + if (!max98088_access[i].writable) + continue; + + if (max98088->reg_cache[i] == max98088_reg[i]) + continue; + + snd_soc_write(codec, i, max98088->reg_cache[i]); + } + + codec->cache_sync = 0; +} + +static int max98088_set_bias_level(struct snd_soc_codec *codec, + enum snd_soc_bias_level level) +{ + switch (level) { + case SND_SOC_BIAS_ON: + break; + + case SND_SOC_BIAS_PREPARE: + break; + + case SND_SOC_BIAS_STANDBY: + if (codec->bias_level == SND_SOC_BIAS_OFF) + max98088_sync_cache(codec); + + snd_soc_update_bits(codec, M98088_REG_4C_PWR_EN_IN, + M98088_MBEN, M98088_MBEN); + break; + + case SND_SOC_BIAS_OFF: + snd_soc_update_bits(codec, M98088_REG_4C_PWR_EN_IN, + M98088_MBEN, 0); + codec->cache_sync = 1; + break; + } + codec->bias_level = level; + return 0; +} + +#define MAX98088_RATES SNDRV_PCM_RATE_8000_96000 +#define MAX98088_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE) + +static struct snd_soc_dai_ops max98088_dai1_ops = { + .set_sysclk = max98088_dai_set_sysclk, + .set_fmt = max98088_dai1_set_fmt, + .hw_params = max98088_dai1_hw_params, +}; + +static struct snd_soc_dai_ops max98088_dai2_ops = { + .set_sysclk = max98088_dai_set_sysclk, + .set_fmt = max98088_dai2_set_fmt, + .hw_params = max98088_dai2_hw_params, +}; + +static struct snd_soc_dai_driver max98088_dai[] = { +{ + .name = "HiFi", + .playback = { + .stream_name = "HiFi Playback", + .channels_min = 1, + .channels_max = 2, + .rates = MAX98088_RATES, + .formats = MAX98088_FORMATS, + }, + .capture = { + .stream_name = "HiFi Capture", + .channels_min = 1, + .channels_max = 2, + .rates = MAX98088_RATES, + .formats = MAX98088_FORMATS, + }, + .ops = &max98088_dai1_ops, +}, +{ + .name = "Aux", + .playback = { + .stream_name = "Aux Playback", + .channels_min = 1, + .channels_max = 2, + .rates = MAX98088_RATES, + .formats = MAX98088_FORMATS, + }, + .ops = &max98088_dai2_ops, +} +}; + +static int max98088_get_channel(const char *name) +{ + if (strcmp(name, "EQ1 Mode") == 0) + return 0; + if (strcmp(name, "EQ2 Mode") == 0) + return 1; + return -EINVAL; +} + +static void max98088_setup_eq1(struct snd_soc_codec *codec) +{ + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + struct max98088_pdata *pdata = max98088->pdata; + struct max98088_eq_cfg *coef_set; + int best, best_val, save, i, sel, fs; + struct max98088_cdata *cdata; + + cdata = &max98088->dai[0]; + + if (!pdata || !max98088->eq_textcnt) + return; + + /* Find the selected configuration with nearest sample rate */ + fs = cdata->rate; + sel = cdata->eq_sel; + + best = 0; + best_val = INT_MAX; + for (i = 0; i < pdata->eq_cfgcnt; i++) { + if (strcmp(pdata->eq_cfg[i].name, max98088->eq_texts[sel]) == 0 && + abs(pdata->eq_cfg[i].rate - fs) < best_val) { + best = i; + best_val = abs(pdata->eq_cfg[i].rate - fs); + } + } + + dev_dbg(codec->dev, "Selected %s/%dHz for %dHz sample rate\n", + pdata->eq_cfg[best].name, + pdata->eq_cfg[best].rate, fs); + + /* Disable EQ while configuring, and save current on/off state */ + save = snd_soc_read(codec, M98088_REG_49_CFG_LEVEL); + snd_soc_update_bits(codec, M98088_REG_49_CFG_LEVEL, M98088_EQ1EN, 0); + + coef_set = &pdata->eq_cfg[sel]; + + m98088_eq_band(codec, 0, 0, coef_set->band1); + m98088_eq_band(codec, 0, 1, coef_set->band2); + m98088_eq_band(codec, 0, 2, coef_set->band3); + m98088_eq_band(codec, 0, 3, coef_set->band4); + m98088_eq_band(codec, 0, 4, coef_set->band5); + + /* Restore the original on/off state */ + snd_soc_update_bits(codec, M98088_REG_49_CFG_LEVEL, M98088_EQ1EN, save); +} + +static void max98088_setup_eq2(struct snd_soc_codec *codec) +{ + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + struct max98088_pdata *pdata = max98088->pdata; + struct max98088_eq_cfg *coef_set; + int best, best_val, save, i, sel, fs; + struct max98088_cdata *cdata; + + cdata = &max98088->dai[1]; + + if (!pdata || !max98088->eq_textcnt) + return; + + /* Find the selected configuration with nearest sample rate */ + fs = cdata->rate; + + sel = cdata->eq_sel; + best = 0; + best_val = INT_MAX; + for (i = 0; i < pdata->eq_cfgcnt; i++) { + if (strcmp(pdata->eq_cfg[i].name, max98088->eq_texts[sel]) == 0 && + abs(pdata->eq_cfg[i].rate - fs) < best_val) { + best = i; + best_val = abs(pdata->eq_cfg[i].rate - fs); + } + } + + dev_dbg(codec->dev, "Selected %s/%dHz for %dHz sample rate\n", + pdata->eq_cfg[best].name, + pdata->eq_cfg[best].rate, fs); + + /* Disable EQ while configuring, and save current on/off state */ + save = snd_soc_read(codec, M98088_REG_49_CFG_LEVEL); + snd_soc_update_bits(codec, M98088_REG_49_CFG_LEVEL, M98088_EQ2EN, 0); + + coef_set = &pdata->eq_cfg[sel]; + + m98088_eq_band(codec, 1, 0, coef_set->band1); + m98088_eq_band(codec, 1, 1, coef_set->band2); + m98088_eq_band(codec, 1, 2, coef_set->band3); + m98088_eq_band(codec, 1, 3, coef_set->band4); + m98088_eq_band(codec, 1, 4, coef_set->band5); + + /* Restore the original on/off state */ + snd_soc_update_bits(codec, M98088_REG_49_CFG_LEVEL, M98088_EQ2EN, + save); +} + +static int max98088_put_eq_enum(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + struct max98088_pdata *pdata = max98088->pdata; + int channel = max98088_get_channel(kcontrol->id.name); + struct max98088_cdata *cdata; + int sel = ucontrol->value.integer.value[0]; + + cdata = &max98088->dai[channel]; + + if (sel >= pdata->eq_cfgcnt) + return -EINVAL; + + cdata->eq_sel = sel; + + switch (channel) { + case 0: + max98088_setup_eq1(codec); + break; + case 1: + max98088_setup_eq2(codec); + break; + } + + return 0; +} + +static int max98088_get_eq_enum(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + int channel = max98088_get_channel(kcontrol->id.name); + struct max98088_cdata *cdata; + + cdata = &max98088->dai[channel]; + ucontrol->value.enumerated.item[0] = cdata->eq_sel; + return 0; +} + +static void max98088_handle_eq_pdata(struct snd_soc_codec *codec) +{ + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + struct max98088_pdata *pdata = max98088->pdata; + struct max98088_eq_cfg *cfg; + unsigned int cfgcnt; + int i, j; + const char **t; + int ret; + + struct snd_kcontrol_new controls[] = { + SOC_ENUM_EXT("EQ1 Mode", + max98088->eq_enum, + max98088_get_eq_enum, + max98088_put_eq_enum), + SOC_ENUM_EXT("EQ2 Mode", + max98088->eq_enum, + max98088_get_eq_enum, + max98088_put_eq_enum), + }; + + cfg = pdata->eq_cfg; + cfgcnt = pdata->eq_cfgcnt; + + /* Setup an array of texts for the equalizer enum. + * This is based on Mark Brown's equalizer driver code. + */ + max98088->eq_textcnt = 0; + max98088->eq_texts = NULL; + for (i = 0; i < cfgcnt; i++) { + for (j = 0; j < max98088->eq_textcnt; j++) { + if (strcmp(cfg[i].name, max98088->eq_texts[j]) == 0) + break; + } + + if (j != max98088->eq_textcnt) + continue; + + /* Expand the array */ + t = krealloc(max98088->eq_texts, + sizeof(char *) * (max98088->eq_textcnt + 1), + GFP_KERNEL); + if (t == NULL) + continue; + + /* Store the new entry */ + t[max98088->eq_textcnt] = cfg[i].name; + max98088->eq_textcnt++; + max98088->eq_texts = t; + } + + /* Now point the soc_enum to .texts array items */ + max98088->eq_enum.texts = max98088->eq_texts; + max98088->eq_enum.max = max98088->eq_textcnt; + + ret = snd_soc_add_controls(codec, controls, ARRAY_SIZE(controls)); + if (ret != 0) + dev_err(codec->dev, "Failed to add EQ control: %d\n", ret); +} + +static void max98088_handle_pdata(struct snd_soc_codec *codec) +{ + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + struct max98088_pdata *pdata = max98088->pdata; + u8 regval = 0; + + if (!pdata) { + dev_dbg(codec->dev, "No platform data\n"); + return; + } + + /* Configure mic for analog/digital mic mode */ + if (pdata->digmic_left_mode) + regval |= M98088_DIGMIC_L; + + if (pdata->digmic_right_mode) + regval |= M98088_DIGMIC_R; + + max98088->digmic = (regval ? 1 : 0); + + snd_soc_write(codec, M98088_REG_48_CFG_MIC, regval); + + /* Configure receiver output */ + regval = ((pdata->receiver_mode) ? M98088_REC_LINEMODE : 0); + snd_soc_update_bits(codec, M98088_REG_2A_MIC_REC_CNTL, + M98088_REC_LINEMODE_MASK, regval); + + /* Configure equalizers */ + if (pdata->eq_cfgcnt) + max98088_handle_eq_pdata(codec); +} + +#ifdef CONFIG_PM +static int max98088_suspend(struct snd_soc_codec *codec, pm_message_t state) +{ + max98088_set_bias_level(codec, SND_SOC_BIAS_OFF); + + return 0; +} + +static int max98088_resume(struct snd_soc_codec *codec) +{ + max98088_set_bias_level(codec, SND_SOC_BIAS_STANDBY); + + return 0; +} +#else +#define max98088_suspend NULL +#define max98088_resume NULL +#endif + +static int max98088_probe(struct snd_soc_codec *codec) +{ + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + struct max98088_cdata *cdata; + int ret = 0; + + codec->cache_sync = 1; + memcpy(codec->reg_cache, max98088_reg, sizeof(max98088_reg)); + + ret = snd_soc_codec_set_cache_io(codec, 8, 8, SND_SOC_I2C); + if (ret != 0) { + dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret); + return ret; + } + + /* initalize private data */ + + max98088->sysclk = (unsigned)-1; + max98088->eq_textcnt = 0; + + cdata = &max98088->dai[0]; + cdata->rate = (unsigned)-1; + cdata->fmt = (unsigned)-1; + cdata->eq_sel = 0; + + cdata = &max98088->dai[1]; + cdata->rate = (unsigned)-1; + cdata->fmt = (unsigned)-1; + cdata->eq_sel = 0; + + max98088->ina_state = 0; + max98088->inb_state = 0; + max98088->ex_mode = 0; + max98088->digmic = 0; + max98088->mic1pre = 0; + max98088->mic2pre = 0; + + ret = snd_soc_read(codec, M98088_REG_FF_REV_ID); + if (ret < 0) { + dev_err(codec->dev, "Failed to read device revision: %d\n", + ret); + goto err_access; + } + dev_info(codec->dev, "revision %c\n", ret + 'A'); + + snd_soc_write(codec, M98088_REG_51_PWR_SYS, M98088_PWRSV); + + /* initialize registers cache to hardware default */ + max98088_set_bias_level(codec, SND_SOC_BIAS_STANDBY); + + snd_soc_write(codec, M98088_REG_0F_IRQ_ENABLE, 0x00); + + snd_soc_write(codec, M98088_REG_22_MIX_DAC, + M98088_DAI1L_TO_DACL|M98088_DAI2L_TO_DACL| + M98088_DAI1R_TO_DACR|M98088_DAI2R_TO_DACR); + + snd_soc_write(codec, M98088_REG_4E_BIAS_CNTL, 0xF0); + snd_soc_write(codec, M98088_REG_50_DAC_BIAS2, 0x0F); + + snd_soc_write(codec, M98088_REG_16_DAI1_IOCFG, + M98088_S1NORMAL|M98088_SDATA); + + snd_soc_write(codec, M98088_REG_1E_DAI2_IOCFG, + M98088_S2NORMAL|M98088_SDATA); + + max98088_handle_pdata(codec); + + max98088_add_widgets(codec); + +err_access: + return ret; +} + +static int max98088_remove(struct snd_soc_codec *codec) +{ + max98088_set_bias_level(codec, SND_SOC_BIAS_OFF); + + return 0; +} + +static struct snd_soc_codec_driver soc_codec_dev_max98088 = { + .probe = max98088_probe, + .remove = max98088_remove, + .suspend = max98088_suspend, + .resume = max98088_resume, + .set_bias_level = max98088_set_bias_level, + .reg_cache_size = ARRAY_SIZE(max98088_reg), + .reg_word_size = sizeof(u8), + .reg_cache_default = max98088_reg, + .volatile_register = max98088_volatile_register, +}; + +static int max98088_i2c_probe(struct i2c_client *i2c, + const struct i2c_device_id *id) +{ + struct max98088_priv *max98088; + int ret; + + max98088 = kzalloc(sizeof(struct max98088_priv), GFP_KERNEL); + if (max98088 == NULL) + return -ENOMEM; + + i2c_set_clientdata(i2c, max98088); + max98088->control_data = i2c; + max98088->pdata = i2c->dev.platform_data; + + ret = snd_soc_register_codec(&i2c->dev, + &soc_codec_dev_max98088, &max98088_dai[0], 2); + if (ret < 0) + kfree(max98088); + return ret; +} + +static int max98088_i2c_remove(struct i2c_client *client) +{ + snd_soc_unregister_codec(&client->dev); + kfree(i2c_get_clientdata(client)); + return 0; +} + +static const struct i2c_device_id max98088_i2c_id[] = { + { "max98088", 0 }, + { } +}; +MODULE_DEVICE_TABLE(i2c, max98088_i2c_id); + +static struct i2c_driver max98088_i2c_driver = { + .driver = { + .name = "max98088", + .owner = THIS_MODULE, + }, + .probe = max98088_i2c_probe, + .remove = __devexit_p(max98088_i2c_remove), + .id_table = max98088_i2c_id, +}; + +static int __init max98088_init(void) +{ + int ret; + + ret = i2c_add_driver(&max98088_i2c_driver); + if (ret) + pr_err("Failed to register max98088 I2C driver: %d\n", ret); + + return ret; +} +module_init(max98088_init); + +static void __exit max98088_exit(void) +{ + i2c_del_driver(&max98088_i2c_driver); +} +module_exit(max98088_exit); + +MODULE_DESCRIPTION("ALSA SoC MAX98088 driver"); +MODULE_AUTHOR("Peter Hsiang, Jesse Marroquin"); +MODULE_LICENSE("GPL"); diff --git a/sound/soc/codecs/max98088.h b/sound/soc/codecs/max98088.h new file mode 100644 index 0000000..56554c7 --- /dev/null +++ b/sound/soc/codecs/max98088.h @@ -0,0 +1,193 @@ +/* + * max98088.h -- MAX98088 ALSA SoC Audio driver + * + * Copyright 2010 Maxim Integrated Products + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#ifndef _MAX98088_H +#define _MAX98088_H + +/* + * MAX98088 Registers Definition + */ +#define M98088_REG_00_IRQ_STATUS 0x00 +#define M98088_REG_01_MIC_STATUS 0x01 +#define M98088_REG_02_JACK_STAUS 0x02 +#define M98088_REG_03_BATTERY_VOLTAGE 0x03 +#define M98088_REG_0F_IRQ_ENABLE 0x0F +#define M98088_REG_10_SYS_CLK 0x10 +#define M98088_REG_11_DAI1_CLKMODE 0x11 +#define M98088_REG_12_DAI1_CLKCFG_HI 0x12 +#define M98088_REG_13_DAI1_CLKCFG_LO 0x13 +#define M98088_REG_14_DAI1_FORMAT 0x14 +#define M98088_REG_15_DAI1_CLOCK 0x15 +#define M98088_REG_16_DAI1_IOCFG 0x16 +#define M98088_REG_17_DAI1_TDM 0x17 +#define M98088_REG_18_DAI1_FILTERS 0x18 +#define M98088_REG_19_DAI2_CLKMODE 0x19 +#define M98088_REG_1A_DAI2_CLKCFG_HI 0x1A +#define M98088_REG_1B_DAI2_CLKCFG_LO 0x1B +#define M98088_REG_1C_DAI2_FORMAT 0x1C +#define M98088_REG_1D_DAI2_CLOCK 0x1D +#define M98088_REG_1E_DAI2_IOCFG 0x1E +#define M98088_REG_1F_DAI2_TDM 0x1F +#define M98088_REG_20_DAI2_FILTERS 0x20 +#define M98088_REG_21_SRC 0x21 +#define M98088_REG_22_MIX_DAC 0x22 +#define M98088_REG_23_MIX_ADC_LEFT 0x23 +#define M98088_REG_24_MIX_ADC_RIGHT 0x24 +#define M98088_REG_25_MIX_HP_LEFT 0x25 +#define M98088_REG_26_MIX_HP_RIGHT 0x26 +#define M98088_REG_27_MIX_HP_CNTL 0x27 +#define M98088_REG_28_MIX_REC_LEFT 0x28 +#define M98088_REG_29_MIX_REC_RIGHT 0x29 +#define M98088_REG_2A_MIC_REC_CNTL 0x2A +#define M98088_REG_2B_MIX_SPK_LEFT 0x2B +#define M98088_REG_2C_MIX_SPK_RIGHT 0x2C +#define M98088_REG_2D_MIX_SPK_CNTL 0x2D +#define M98088_REG_2E_LVL_SIDETONE 0x2E +#define M98088_REG_2F_LVL_DAI1_PLAY 0x2F +#define M98088_REG_30_LVL_DAI1_PLAY_EQ 0x30 +#define M98088_REG_31_LVL_DAI2_PLAY 0x31 +#define M98088_REG_32_LVL_DAI2_PLAY_EQ 0x32 +#define M98088_REG_33_LVL_ADC_L 0x33 +#define M98088_REG_34_LVL_ADC_R 0x34 +#define M98088_REG_35_LVL_MIC1 0x35 +#define M98088_REG_36_LVL_MIC2 0x36 +#define M98088_REG_37_LVL_INA 0x37 +#define M98088_REG_38_LVL_INB 0x38 +#define M98088_REG_39_LVL_HP_L 0x39 +#define M98088_REG_3A_LVL_HP_R 0x3A +#define M98088_REG_3B_LVL_REC_L 0x3B +#define M98088_REG_3C_LVL_REC_R 0x3C +#define M98088_REG_3D_LVL_SPK_L 0x3D +#define M98088_REG_3E_LVL_SPK_R 0x3E +#define M98088_REG_3F_MICAGC_CFG 0x3F +#define M98088_REG_40_MICAGC_THRESH 0x40 +#define M98088_REG_41_SPKDHP 0x41 +#define M98088_REG_42_SPKDHP_THRESH 0x42 +#define M98088_REG_43_SPKALC_COMP 0x43 +#define M98088_REG_44_PWRLMT_CFG 0x44 +#define M98088_REG_45_PWRLMT_TIME 0x45 +#define M98088_REG_46_THDLMT_CFG 0x46 +#define M98088_REG_47_CFG_AUDIO_IN 0x47 +#define M98088_REG_48_CFG_MIC 0x48 +#define M98088_REG_49_CFG_LEVEL 0x49 +#define M98088_REG_4A_CFG_BYPASS 0x4A +#define M98088_REG_4B_CFG_JACKDET 0x4B +#define M98088_REG_4C_PWR_EN_IN 0x4C +#define M98088_REG_4D_PWR_EN_OUT 0x4D +#define M98088_REG_4E_BIAS_CNTL 0x4E +#define M98088_REG_4F_DAC_BIAS1 0x4F +#define M98088_REG_50_DAC_BIAS2 0x50 +#define M98088_REG_51_PWR_SYS 0x51 +#define M98088_REG_52_DAI1_EQ_BASE 0x52 +#define M98088_REG_84_DAI2_EQ_BASE 0x84 +#define M98088_REG_B6_DAI1_BIQUAD_BASE 0xB6 +#define M98088_REG_C0_DAI2_BIQUAD_BASE 0xC0 +#define M98088_REG_FF_REV_ID 0xFF + +#define M98088_REG_CNT (0xFF+1) + +/* MAX98088 Registers Bit Fields */ + +/* M98088_REG_11_DAI1_CLKMODE, M98088_REG_19_DAI2_CLKMODE */ + #define M98088_CLKMODE_MASK 0xFF + +/* M98088_REG_14_DAI1_FORMAT, M98088_REG_1C_DAI2_FORMAT */ + #define M98088_DAI_MAS (1<<7) + #define M98088_DAI_WCI (1<<6) + #define M98088_DAI_BCI (1<<5) + #define M98088_DAI_DLY (1<<4) + #define M98088_DAI_TDM (1<<2) + #define M98088_DAI_FSW (1<<1) + #define M98088_DAI_WS (1<<0) + +/* M98088_REG_15_DAI1_CLOCK, M98088_REG_1D_DAI2_CLOCK */ + #define M98088_DAI_BSEL64 (1<<0) + #define M98088_DAI_OSR64 (1<<6) + +/* M98088_REG_16_DAI1_IOCFG, M98088_REG_1E_DAI2_IOCFG */ + #define M98088_S1NORMAL (1<<6) + #define M98088_S2NORMAL (2<<6) + #define M98088_SDATA (3<<0) + +/* M98088_REG_18_DAI1_FILTERS, M98088_REG_20_DAI2_FILTERS */ + #define M98088_DAI_DHF (1<<3) + +/* M98088_REG_22_MIX_DAC */ + #define M98088_DAI1L_TO_DACL (1<<7) + #define M98088_DAI1R_TO_DACL (1<<6) + #define M98088_DAI2L_TO_DACL (1<<5) + #define M98088_DAI2R_TO_DACL (1<<4) + #define M98088_DAI1L_TO_DACR (1<<3) + #define M98088_DAI1R_TO_DACR (1<<2) + #define M98088_DAI2L_TO_DACR (1<<1) + #define M98088_DAI2R_TO_DACR (1<<0) + +/* M98088_REG_2A_MIC_REC_CNTL */ + #define M98088_REC_LINEMODE (1<<7) + #define M98088_REC_LINEMODE_MASK (1<<7) + +/* M98088_REG_35_LVL_MIC1, M98088_REG_36_LVL_MIC2 */ + #define M98088_MICPRE_MASK (3<<5) + #define M98088_MICPRE_SHIFT 5 + +/* M98088_REG_3A_LVL_HP_R */ + #define M98088_HP_MUTE (1<<7) + +/* M98088_REG_3C_LVL_REC_R */ + #define M98088_REC_MUTE (1<<7) + +/* M98088_REG_3E_LVL_SPK_R */ + #define M98088_SP_MUTE (1<<7) + +/* M98088_REG_48_CFG_MIC */ + #define M98088_EXTMIC_MASK (3<<0) + #define M98088_DIGMIC_L (1<<5) + #define M98088_DIGMIC_R (1<<4) + +/* M98088_REG_49_CFG_LEVEL */ + #define M98088_VSEN (1<<6) + #define M98088_ZDEN (1<<5) + #define M98088_EQ2EN (1<<1) + #define M98088_EQ1EN (1<<0) + +/* M98088_REG_4C_PWR_EN_IN */ + #define M98088_INAEN (1<<7) + #define M98088_INBEN (1<<6) + #define M98088_MBEN (1<<3) + #define M98088_ADLEN (1<<1) + #define M98088_ADREN (1<<0) + +/* M98088_REG_4D_PWR_EN_OUT */ + #define M98088_HPLEN (1<<7) + #define M98088_HPREN (1<<6) + #define M98088_HPEN ((1<<7)|(1<<6)) + #define M98088_SPLEN (1<<5) + #define M98088_SPREN (1<<4) + #define M98088_RECEN (1<<3) + #define M98088_DALEN (1<<1) + #define M98088_DAREN (1<<0) + +/* M98088_REG_51_PWR_SYS */ + #define M98088_SHDNRUN (1<<7) + #define M98088_PERFMODE (1<<3) + #define M98088_HPPLYBACK (1<<2) + #define M98088_PWRSV8K (1<<1) + #define M98088_PWRSV (1<<0) + +/* Line inputs */ +#define LINE_INA 0 +#define LINE_INB 1 + +#define M98088_COEFS_PER_BAND 5 + +#define M98088_BYTE1(w) ((w >> 8) & 0xff) +#define M98088_BYTE0(w) (w & 0xff) + +#endif -- cgit v1.1 From 6038f373a3dc1f1c26496e60b6c40b164716f07e Mon Sep 17 00:00:00 2001 From: Arnd Bergmann Date: Sun, 15 Aug 2010 18:52:59 +0200 Subject: llseek: automatically add .llseek fop All file_operations should get a .llseek operation so we can make nonseekable_open the default for future file operations without a .llseek pointer. The three cases that we can automatically detect are no_llseek, seq_lseek and default_llseek. For cases where we can we can automatically prove that the file offset is always ignored, we use noop_llseek, which maintains the current behavior of not returning an error from a seek. New drivers should normally not use noop_llseek but instead use no_llseek and call nonseekable_open at open time. Existing drivers can be converted to do the same when the maintainer knows for certain that no user code relies on calling seek on the device file. The generated code is often incorrectly indented and right now contains comments that clarify for each added line why a specific variant was chosen. In the version that gets submitted upstream, the comments will be gone and I will manually fix the indentation, because there does not seem to be a way to do that using coccinelle. Some amount of new code is currently sitting in linux-next that should get the same modifications, which I will do at the end of the merge window. Many thanks to Julia Lawall for helping me learn to write a semantic patch that does all this. ===== begin semantic patch ===== // This adds an llseek= method to all file operations, // as a preparation for making no_llseek the default. // // The rules are // - use no_llseek explicitly if we do nonseekable_open // - use seq_lseek for sequential files // - use default_llseek if we know we access f_pos // - use noop_llseek if we know we don't access f_pos, // but we still want to allow users to call lseek // @ open1 exists @ identifier nested_open; @@ nested_open(...) { <+... nonseekable_open(...) ...+> } @ open exists@ identifier open_f; identifier i, f; identifier open1.nested_open; @@ int open_f(struct inode *i, struct file *f) { <+... ( nonseekable_open(...) | nested_open(...) ) ...+> } @ read disable optional_qualifier exists @ identifier read_f; identifier f, p, s, off; type ssize_t, size_t, loff_t; expression E; identifier func; @@ ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off) { <+... ( *off = E | *off += E | func(..., off, ...) | E = *off ) ...+> } @ read_no_fpos disable optional_qualifier exists @ identifier read_f; identifier f, p, s, off; type ssize_t, size_t, loff_t; @@ ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off) { ... when != off } @ write @ identifier write_f; identifier f, p, s, off; type ssize_t, size_t, loff_t; expression E; identifier func; @@ ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off) { <+... ( *off = E | *off += E | func(..., off, ...) | E = *off ) ...+> } @ write_no_fpos @ identifier write_f; identifier f, p, s, off; type ssize_t, size_t, loff_t; @@ ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off) { ... when != off } @ fops0 @ identifier fops; @@ struct file_operations fops = { ... }; @ has_llseek depends on fops0 @ identifier fops0.fops; identifier llseek_f; @@ struct file_operations fops = { ... .llseek = llseek_f, ... }; @ has_read depends on fops0 @ identifier fops0.fops; identifier read_f; @@ struct file_operations fops = { ... .read = read_f, ... }; @ has_write depends on fops0 @ identifier fops0.fops; identifier write_f; @@ struct file_operations fops = { ... .write = write_f, ... }; @ has_open depends on fops0 @ identifier fops0.fops; identifier open_f; @@ struct file_operations fops = { ... .open = open_f, ... }; // use no_llseek if we call nonseekable_open //////////////////////////////////////////// @ nonseekable1 depends on !has_llseek && has_open @ identifier fops0.fops; identifier nso ~= "nonseekable_open"; @@ struct file_operations fops = { ... .open = nso, ... +.llseek = no_llseek, /* nonseekable */ }; @ nonseekable2 depends on !has_llseek @ identifier fops0.fops; identifier open.open_f; @@ struct file_operations fops = { ... .open = open_f, ... +.llseek = no_llseek, /* open uses nonseekable */ }; // use seq_lseek for sequential files ///////////////////////////////////// @ seq depends on !has_llseek @ identifier fops0.fops; identifier sr ~= "seq_read"; @@ struct file_operations fops = { ... .read = sr, ... +.llseek = seq_lseek, /* we have seq_read */ }; // use default_llseek if there is a readdir /////////////////////////////////////////// @ fops1 depends on !has_llseek && !nonseekable1 && !nonseekable2 && !seq @ identifier fops0.fops; identifier readdir_e; @@ // any other fop is used that changes pos struct file_operations fops = { ... .readdir = readdir_e, ... +.llseek = default_llseek, /* readdir is present */ }; // use default_llseek if at least one of read/write touches f_pos ///////////////////////////////////////////////////////////////// @ fops2 depends on !fops1 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @ identifier fops0.fops; identifier read.read_f; @@ // read fops use offset struct file_operations fops = { ... .read = read_f, ... +.llseek = default_llseek, /* read accesses f_pos */ }; @ fops3 depends on !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @ identifier fops0.fops; identifier write.write_f; @@ // write fops use offset struct file_operations fops = { ... .write = write_f, ... + .llseek = default_llseek, /* write accesses f_pos */ }; // Use noop_llseek if neither read nor write accesses f_pos /////////////////////////////////////////////////////////// @ fops4 depends on !fops1 && !fops2 && !fops3 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @ identifier fops0.fops; identifier read_no_fpos.read_f; identifier write_no_fpos.write_f; @@ // write fops use offset struct file_operations fops = { ... .write = write_f, .read = read_f, ... +.llseek = noop_llseek, /* read and write both use no f_pos */ }; @ depends on has_write && !has_read && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @ identifier fops0.fops; identifier write_no_fpos.write_f; @@ struct file_operations fops = { ... .write = write_f, ... +.llseek = noop_llseek, /* write uses no f_pos */ }; @ depends on has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @ identifier fops0.fops; identifier read_no_fpos.read_f; @@ struct file_operations fops = { ... .read = read_f, ... +.llseek = noop_llseek, /* read uses no f_pos */ }; @ depends on !has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @ identifier fops0.fops; @@ struct file_operations fops = { ... +.llseek = noop_llseek, /* no read or write fn */ }; ===== End semantic patch ===== Signed-off-by: Arnd Bergmann Cc: Julia Lawall Cc: Christoph Hellwig --- sound/core/seq/oss/seq_oss.c | 1 + sound/core/sound.c | 3 ++- sound/oss/msnd_pinnacle.c | 1 + sound/soc/soc-core.c | 1 + sound/soc/soc-dapm.c | 1 + sound/sound_core.c | 1 + 6 files changed, 7 insertions(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/core/seq/oss/seq_oss.c b/sound/core/seq/oss/seq_oss.c index f25e3cc..a1f1a2f 100644 --- a/sound/core/seq/oss/seq_oss.c +++ b/sound/core/seq/oss/seq_oss.c @@ -220,6 +220,7 @@ static const struct file_operations seq_oss_f_ops = .poll = odev_poll, .unlocked_ioctl = odev_ioctl, .compat_ioctl = odev_ioctl_compat, + .llseek = noop_llseek, }; static int __init diff --git a/sound/core/sound.c b/sound/core/sound.c index ac42af4..62a093e 100644 --- a/sound/core/sound.c +++ b/sound/core/sound.c @@ -184,7 +184,8 @@ static int snd_open(struct inode *inode, struct file *file) static const struct file_operations snd_fops = { .owner = THIS_MODULE, - .open = snd_open + .open = snd_open, + .llseek = noop_llseek, }; #ifdef CONFIG_SND_DYNAMIC_MINORS diff --git a/sound/oss/msnd_pinnacle.c b/sound/oss/msnd_pinnacle.c index 2e48b17..ca942f7 100644 --- a/sound/oss/msnd_pinnacle.c +++ b/sound/oss/msnd_pinnacle.c @@ -1117,6 +1117,7 @@ static const struct file_operations dev_fileops = { .unlocked_ioctl = dev_ioctl, .open = dev_open, .release = dev_release, + .llseek = noop_llseek, }; static int reset_dsp(void) diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c index acc91da..4057d35 100644 --- a/sound/soc/soc-core.c +++ b/sound/soc/soc-core.c @@ -223,6 +223,7 @@ static const struct file_operations codec_reg_fops = { .open = codec_reg_open_file, .read = codec_reg_read_file, .write = codec_reg_write_file, + .llseek = default_llseek, }; static void soc_init_codec_debugfs(struct snd_soc_codec *codec) diff --git a/sound/soc/soc-dapm.c b/sound/soc/soc-dapm.c index 03cb7c0..72a53d0 100644 --- a/sound/soc/soc-dapm.c +++ b/sound/soc/soc-dapm.c @@ -1089,6 +1089,7 @@ static ssize_t dapm_widget_power_read_file(struct file *file, static const struct file_operations dapm_widget_power_fops = { .open = dapm_widget_power_open_file, .read = dapm_widget_power_read_file, + .llseek = default_llseek, }; void snd_soc_dapm_debugfs_init(struct snd_soc_codec *codec) diff --git a/sound/sound_core.c b/sound/sound_core.c index cb61317..c03bbae 100644 --- a/sound/sound_core.c +++ b/sound/sound_core.c @@ -165,6 +165,7 @@ static const struct file_operations soundcore_fops = /* We must have an owner or the module locking fails */ .owner = THIS_MODULE, .open = soundcore_open, + .llseek = noop_llseek, }; /* -- cgit v1.1 From fa2eb005ebcbac89745a1f9a9f0c8678ba63f61a Mon Sep 17 00:00:00 2001 From: Andrea Gelmini Date: Sat, 16 Oct 2010 15:19:20 +0200 Subject: sound: fixed typos Signed-off-by: Andrea Gelmini Signed-off-by: Takashi Iwai --- sound/pci/au88x0/au88x0_mixer.c | 2 +- sound/soc/davinci/davinci-sffsdr.c | 2 +- sound/soc/s3c24xx/neo1973_gta02_wm8753.c | 2 +- sound/soc/s3c24xx/neo1973_wm8753.c | 2 +- sound/usb/usx2y/usx2yhwdeppcm.c | 4 ++-- 5 files changed, 6 insertions(+), 6 deletions(-) (limited to 'sound') diff --git a/sound/pci/au88x0/au88x0_mixer.c b/sound/pci/au88x0/au88x0_mixer.c index c92f493..557c782 100644 --- a/sound/pci/au88x0/au88x0_mixer.c +++ b/sound/pci/au88x0/au88x0_mixer.c @@ -23,7 +23,7 @@ static int __devinit snd_vortex_mixer(vortex_t * vortex) if ((err = snd_ac97_bus(vortex->card, 0, &ops, NULL, &pbus)) < 0) return err; memset(&ac97, 0, sizeof(ac97)); - // Intialize AC97 codec stuff. + // Initialize AC97 codec stuff. ac97.private_data = vortex; ac97.scaps = AC97_SCAP_NO_SPDIF; err = snd_ac97_mixer(pbus, &ac97, &vortex->codec); diff --git a/sound/soc/davinci/davinci-sffsdr.c b/sound/soc/davinci/davinci-sffsdr.c index 40eccfe..4948a79 100644 --- a/sound/soc/davinci/davinci-sffsdr.c +++ b/sound/soc/davinci/davinci-sffsdr.c @@ -150,7 +150,7 @@ static int __init sffsdr_init(void) sffsdr_snd_resources, ARRAY_SIZE(sffsdr_snd_resources)); if (ret) { - printk(KERN_ERR "platform device add ressources failed\n"); + printk(KERN_ERR "platform device add resources failed\n"); goto error; } diff --git a/sound/soc/s3c24xx/neo1973_gta02_wm8753.c b/sound/soc/s3c24xx/neo1973_gta02_wm8753.c index 209c259..4719558 100644 --- a/sound/soc/s3c24xx/neo1973_gta02_wm8753.c +++ b/sound/soc/s3c24xx/neo1973_gta02_wm8753.c @@ -182,7 +182,7 @@ static int neo1973_gta02_voice_hw_params( if (ret < 0) return ret; - /* configue and enable PLL for 12.288MHz output */ + /* configure and enable PLL for 12.288MHz output */ ret = snd_soc_dai_set_pll(codec_dai, WM8753_PLL2, 0, iis_clkrate / 4, 12288000); if (ret < 0) diff --git a/sound/soc/s3c24xx/neo1973_wm8753.c b/sound/soc/s3c24xx/neo1973_wm8753.c index 0cb4f86..4ac6209 100644 --- a/sound/soc/s3c24xx/neo1973_wm8753.c +++ b/sound/soc/s3c24xx/neo1973_wm8753.c @@ -201,7 +201,7 @@ static int neo1973_voice_hw_params(struct snd_pcm_substream *substream, if (ret < 0) return ret; - /* configue and enable PLL for 12.288MHz output */ + /* configure and enable PLL for 12.288MHz output */ ret = snd_soc_dai_set_pll(codec_dai, WM8753_PLL2, 0, iis_clkrate / 4, 12288000); if (ret < 0) diff --git a/sound/usb/usx2y/usx2yhwdeppcm.c b/sound/usb/usx2y/usx2yhwdeppcm.c index 3146a81..287ef73 100644 --- a/sound/usb/usx2y/usx2yhwdeppcm.c +++ b/sound/usb/usx2y/usx2yhwdeppcm.c @@ -36,9 +36,9 @@ plain usx2y alsa mode is able to achieve 64frames, 4periods, but only at the cost of easier triggered i.e. aeolus xruns (128 or 256frames, 2periods works but is useless cause of crackling). - + This is a first "proof of concept" implementation. - Later, funcionalities should migrate to more apropriate places: + Later, functionalities should migrate to more apropriate places: Userland: - The jackd could mmap its float-pcm buffers directly from alsa-lib. - alsa-lib could provide power of 2 period sized shaping combined with int/float -- cgit v1.1 From aa73aec6c385e2c797ac25cc7ccf0318031de7c8 Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Fri, 15 Oct 2010 12:06:18 +0200 Subject: ALSA: rawmidi: fix oops (use after free) when unloading a driver module When a driver module is unloaded and the last still open file is a raw MIDI device, the card and its devices will be actually freed in the snd_card_file_remove() call when that file is closed. Afterwards, rmidi and rmidi->card point into freed memory, so the module pointer is likely to be garbage. (This was introduced by commit 9a1b64caac82aa02cb74587ffc798e6f42c6170a.) Signed-off-by: Clemens Ladisch Reported-by: Krzysztof Foltman Cc: 2.6.30-2.6.35 Signed-off-by: Takashi Iwai --- sound/core/rawmidi.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/core/rawmidi.c b/sound/core/rawmidi.c index a7868ad..cbbed0d 100644 --- a/sound/core/rawmidi.c +++ b/sound/core/rawmidi.c @@ -535,13 +535,15 @@ static int snd_rawmidi_release(struct inode *inode, struct file *file) { struct snd_rawmidi_file *rfile; struct snd_rawmidi *rmidi; + struct module *module; rfile = file->private_data; rmidi = rfile->rmidi; rawmidi_release_priv(rfile); kfree(rfile); + module = rmidi->card->module; snd_card_file_remove(rmidi->card, file); - module_put(rmidi->card->module); + module_put(module); return 0; } -- cgit v1.1 From 906229174c20e3d5cbda8da070af8f30196316c3 Mon Sep 17 00:00:00 2001 From: David Henningsson Date: Thu, 14 Oct 2010 14:50:18 +0200 Subject: ALSA: HDA: Enable SKU quirks for Realtek Realtek have ways of specifying external amps and more via a special nid or via the Codec's subsystem ID, this is called "SKU". The computer manufacturer sometimes gets this wrong, so we need to be able to override or ignore the SKU customization value. Signed-off-by: David Henningsson Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 35 +++++++++++++++++++++++++++++++++-- 1 file changed, 33 insertions(+), 2 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index c41ac30..7b24a2d 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -301,6 +301,7 @@ struct alc_customize_define { unsigned int platform_type:1; unsigned int swap:1; unsigned int override:1; + unsigned int fixup:1; /* Means that this sku is set by driver, not read from hw */ }; struct alc_spec { @@ -1464,6 +1465,11 @@ static void alc_init_auto_mic(struct hda_codec *codec) spec->unsol_event = alc_sku_unsol_event; } +/* Could be any non-zero and even value. When used as fixup, tells + * the driver to ignore any present sku defines. + */ +#define ALC_FIXUP_SKU_IGNORE (2) + static int alc_auto_parse_customize_define(struct hda_codec *codec) { unsigned int ass, tmp, i; @@ -1472,6 +1478,13 @@ static int alc_auto_parse_customize_define(struct hda_codec *codec) spec->cdefine.enable_pcbeep = 1; /* assume always enabled */ + if (spec->cdefine.fixup) { + ass = spec->cdefine.sku_cfg; + if (ass == ALC_FIXUP_SKU_IGNORE) + return -1; + goto do_sku; + } + ass = codec->subsystem_id & 0xffff; if (ass != codec->bus->pci->subsystem_device && (ass & 1)) goto do_sku; @@ -1539,6 +1552,13 @@ static int alc_subsystem_id(struct hda_codec *codec, unsigned nid; struct alc_spec *spec = codec->spec; + if (spec->cdefine.fixup) { + ass = spec->cdefine.sku_cfg; + if (ass == ALC_FIXUP_SKU_IGNORE) + return 0; + goto do_sku; + } + ass = codec->subsystem_id & 0xffff; if ((ass != codec->bus->pci->subsystem_device) && (ass & 1)) goto do_sku; @@ -1658,6 +1678,7 @@ struct alc_pincfg { }; struct alc_fixup { + unsigned int sku; const struct alc_pincfg *pins; const struct hda_verb *verbs; }; @@ -1668,12 +1689,22 @@ static void alc_pick_fixup(struct hda_codec *codec, int pre_init) { const struct alc_pincfg *cfg; + struct alc_spec *spec; quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk); if (!quirk) return; fix += quirk->value; cfg = fix->pins; + if (pre_init && fix->sku) { +#ifdef CONFIG_SND_DEBUG_VERBOSE + snd_printdd(KERN_INFO "hda_codec: %s: Apply sku override for %s\n", + codec->chip_name, quirk->name); +#endif + spec = codec->spec; + spec->cdefine.sku_cfg = fix->sku; + spec->cdefine.fixup = 1; + } if (pre_init && cfg) { #ifdef CONFIG_SND_DEBUG_VERBOSE snd_printdd(KERN_INFO "hda_codec: %s: Apply pincfg for %s\n", @@ -10861,8 +10892,6 @@ static int patch_alc882(struct hda_codec *codec) codec->spec = spec; - alc_auto_parse_customize_define(codec); - switch (codec->vendor_id) { case 0x10ec0882: case 0x10ec0885: @@ -10890,6 +10919,8 @@ static int patch_alc882(struct hda_codec *codec) if (board_config == ALC882_AUTO) alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups, 1); + alc_auto_parse_customize_define(codec); + if (board_config == ALC882_AUTO) { /* automatic parse from the BIOS config */ err = alc882_parse_auto_config(codec); -- cgit v1.1 From c3d226ab8b44fe31e5e6d5739eb353597cea4029 Mon Sep 17 00:00:00 2001 From: David Henningsson Date: Thu, 14 Oct 2010 15:42:08 +0200 Subject: ALSA: HDA: Apply SKU override for Acer aspire 7736z BugLink: http://launchpad.net/bugs/617647 The current SKU value disables playback, so ignore the SKU value. Signed-off-by: David Henningsson Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index 7b24a2d..788ac4b 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -10628,6 +10628,7 @@ static struct alc_config_preset alc882_presets[] = { enum { PINFIX_ABIT_AW9D_MAX, PINFIX_PB_M5210, + PINFIX_ACER_ASPIRE_7736, }; static const struct alc_fixup alc882_fixups[] = { @@ -10645,11 +10646,15 @@ static const struct alc_fixup alc882_fixups[] = { {} } }, + [PINFIX_ACER_ASPIRE_7736] = { + .sku = ALC_FIXUP_SKU_IGNORE, + }, }; static struct snd_pci_quirk alc882_fixup_tbl[] = { SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210), SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX), + SND_PCI_QUIRK(0x1025, 0x0296, "Acer Aspire 7736z", PINFIX_ACER_ASPIRE_7736), {} }; -- cgit v1.1 From de8c85f7840e5e29629de95f5af24297fb325e0b Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Fri, 15 Oct 2010 10:32:50 +0200 Subject: ALSA: HDA: Sigmatel: work around incorrect master muting The HDA specification does not allow for a codec to mute itself just because the volume is reduced, so _of course_ somebody had to go and do it. This wouldn'\''t hurt too much when the volume is adjusted by hand, but programs like PA that try to set the volume automatically could inadvertently mute the output. To work around this, change the TLV dB information for the Master volume on all Sigmatel HDA codecs to indicate the the minimal volume setting actually mutes. Reported-by: Colin Guthrie Reported-by: "Alexander E. Patrakov" Tested-by: Colin Guthrie Signed-off-by: Clemens Ladisch Signed-off-by: Takashi Iwai --- sound/pci/hda/hda_codec.c | 3 +++ sound/pci/hda/hda_local.h | 14 ++++++++++---- sound/pci/hda/patch_sigmatel.c | 6 ++++-- 3 files changed, 17 insertions(+), 6 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c index 053f827..8c933c8 100644 --- a/sound/pci/hda/hda_codec.c +++ b/sound/pci/hda/hda_codec.c @@ -1831,6 +1831,7 @@ int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag, hda_nid_t nid = get_amp_nid(kcontrol); int dir = get_amp_direction(kcontrol); unsigned int ofs = get_amp_offset(kcontrol); + bool min_mute = get_amp_min_mute(kcontrol); u32 caps, val1, val2; if (size < 4 * sizeof(unsigned int)) @@ -1841,6 +1842,8 @@ int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag, val1 = -((caps & AC_AMPCAP_OFFSET) >> AC_AMPCAP_OFFSET_SHIFT); val1 += ofs; val1 = ((int)val1) * ((int)val2); + if (min_mute) + val2 |= 0x10000; if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv)) return -EFAULT; if (put_user(2 * sizeof(unsigned int), _tlv + 1)) diff --git a/sound/pci/hda/hda_local.h b/sound/pci/hda/hda_local.h index d7dfa54..46bbefe 100644 --- a/sound/pci/hda/hda_local.h +++ b/sound/pci/hda/hda_local.h @@ -38,10 +38,11 @@ */ #define HDA_COMPOSE_AMP_VAL_OFS(nid,chs,idx,dir,ofs) \ ((nid) | ((chs)<<16) | ((dir)<<18) | ((idx)<<19) | ((ofs)<<23)) +#define HDA_AMP_VAL_MIN_MUTE (1<<29) #define HDA_COMPOSE_AMP_VAL(nid,chs,idx,dir) \ HDA_COMPOSE_AMP_VAL_OFS(nid, chs, idx, dir, 0) /* mono volume with index (index=0,1,...) (channel=1,2) */ -#define HDA_CODEC_VOLUME_MONO_IDX(xname, xcidx, nid, channel, xindex, direction) \ +#define HDA_CODEC_VOLUME_MONO_IDX(xname, xcidx, nid, channel, xindex, dir, flags) \ { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xcidx, \ .subdevice = HDA_SUBDEV_AMP_FLAG, \ .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | \ @@ -51,16 +52,20 @@ .get = snd_hda_mixer_amp_volume_get, \ .put = snd_hda_mixer_amp_volume_put, \ .tlv = { .c = snd_hda_mixer_amp_tlv }, \ - .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, xindex, direction) } + .private_value = HDA_COMPOSE_AMP_VAL(nid, channel, xindex, dir) | flags } /* stereo volume with index */ #define HDA_CODEC_VOLUME_IDX(xname, xcidx, nid, xindex, direction) \ - HDA_CODEC_VOLUME_MONO_IDX(xname, xcidx, nid, 3, xindex, direction) + HDA_CODEC_VOLUME_MONO_IDX(xname, xcidx, nid, 3, xindex, direction, 0) /* mono volume */ #define HDA_CODEC_VOLUME_MONO(xname, nid, channel, xindex, direction) \ - HDA_CODEC_VOLUME_MONO_IDX(xname, 0, nid, channel, xindex, direction) + HDA_CODEC_VOLUME_MONO_IDX(xname, 0, nid, channel, xindex, direction, 0) /* stereo volume */ #define HDA_CODEC_VOLUME(xname, nid, xindex, direction) \ HDA_CODEC_VOLUME_MONO(xname, nid, 3, xindex, direction) +/* stereo volume with min=mute */ +#define HDA_CODEC_VOLUME_MIN_MUTE(xname, nid, xindex, direction) \ + HDA_CODEC_VOLUME_MONO_IDX(xname, 0, nid, 3, xindex, direction, \ + HDA_AMP_VAL_MIN_MUTE) /* mono mute switch with index (index=0,1,...) (channel=1,2) */ #define HDA_CODEC_MUTE_MONO_IDX(xname, xcidx, nid, channel, xindex, direction) \ { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xcidx, \ @@ -581,6 +586,7 @@ int snd_hda_check_amp_list_power(struct hda_codec *codec, #define get_amp_direction(kc) (((kc)->private_value >> 18) & 0x1) #define get_amp_index(kc) (((kc)->private_value >> 19) & 0xf) #define get_amp_offset(kc) (((kc)->private_value >> 23) & 0x3f) +#define get_amp_min_mute(kc) (((kc)->private_value >> 29) & 0x1) /* * CEA Short Audio Descriptor data diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c index d8dfafea..1a563a2 100644 --- a/sound/pci/hda/patch_sigmatel.c +++ b/sound/pci/hda/patch_sigmatel.c @@ -992,7 +992,7 @@ static struct hda_verb stac9205_core_init[] = { } static struct snd_kcontrol_new stac9200_mixer[] = { - HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT), + HDA_CODEC_VOLUME_MIN_MUTE("Master Playback Volume", 0xb, 0, HDA_OUTPUT), HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT), HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT), HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT), @@ -1020,7 +1020,7 @@ static struct snd_kcontrol_new stac92hd71bxx_loopback[] = { }; static struct snd_kcontrol_new stac925x_mixer[] = { - HDA_CODEC_VOLUME("Master Playback Volume", 0x0e, 0, HDA_OUTPUT), + HDA_CODEC_VOLUME_MIN_MUTE("Master Playback Volume", 0xe, 0, HDA_OUTPUT), HDA_CODEC_MUTE("Master Playback Switch", 0x0e, 0, HDA_OUTPUT), { } /* end */ }; @@ -1144,6 +1144,8 @@ static int stac92xx_build_controls(struct hda_codec *codec) HDA_OUTPUT, vmaster_tlv); /* correct volume offset */ vmaster_tlv[2] += vmaster_tlv[3] * spec->volume_offset; + /* minimum value is actually mute */ + vmaster_tlv[3] |= 0x1000; err = snd_hda_add_vmaster(codec, "Master Playback Volume", vmaster_tlv, slave_vols); if (err < 0) -- cgit v1.1 From c08d91695b2a3349254a62b60f03f7971bd90fa0 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Sun, 17 Oct 2010 10:40:53 +0200 Subject: ALSA: tlv - Define numbers in sound/tlv.h Signed-off-by: Takashi Iwai --- sound/pci/hda/hda_codec.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c index 8c933c8..ee134a2 100644 --- a/sound/pci/hda/hda_codec.c +++ b/sound/pci/hda/hda_codec.c @@ -1843,7 +1843,7 @@ int snd_hda_mixer_amp_tlv(struct snd_kcontrol *kcontrol, int op_flag, val1 += ofs; val1 = ((int)val1) * ((int)val2); if (min_mute) - val2 |= 0x10000; + val2 |= TLV_DB_SCALE_MUTE; if (put_user(SNDRV_CTL_TLVT_DB_SCALE, _tlv)) return -EFAULT; if (put_user(2 * sizeof(unsigned int), _tlv + 1)) -- cgit v1.1 From f6765502f8daae3d237a394889276c8987f3e299 Mon Sep 17 00:00:00 2001 From: Mark Brown Date: Mon, 18 Oct 2010 06:01:33 +0100 Subject: Revert "ASoC: Add max98088 CODEC driver" This reverts commit e65d255a5a610ce9e185e0df855250706aca7c21 since it does not build. --- sound/soc/codecs/Kconfig | 4 - sound/soc/codecs/Makefile | 2 - sound/soc/codecs/max98088.c | 2097 ------------------------------------------- sound/soc/codecs/max98088.h | 193 ---- 4 files changed, 2296 deletions(-) delete mode 100644 sound/soc/codecs/max98088.c delete mode 100644 sound/soc/codecs/max98088.h (limited to 'sound') diff --git a/sound/soc/codecs/Kconfig b/sound/soc/codecs/Kconfig index 94a9d06..ff7b922 100644 --- a/sound/soc/codecs/Kconfig +++ b/sound/soc/codecs/Kconfig @@ -27,7 +27,6 @@ config SND_SOC_ALL_CODECS select SND_SOC_CS4270 if I2C select SND_SOC_DA7210 if I2C select SND_SOC_JZ4740 if SOC_JZ4740 - select SND_SOC_MAX98088 if I2C select SND_SOC_MAX9877 if I2C select SND_SOC_PCM3008 select SND_SOC_SPDIF @@ -159,9 +158,6 @@ config SND_SOC_L3 config SND_SOC_DA7210 tristate -config SND_SOC_MAX98088 - tristate - config SND_SOC_PCM3008 tristate diff --git a/sound/soc/codecs/Makefile b/sound/soc/codecs/Makefile index f67a2d6..af4d4c4 100644 --- a/sound/soc/codecs/Makefile +++ b/sound/soc/codecs/Makefile @@ -15,7 +15,6 @@ snd-soc-cs4270-objs := cs4270.o snd-soc-cx20442-objs := cx20442.o snd-soc-da7210-objs := da7210.o snd-soc-l3-objs := l3.o -snd-soc-max98088-objs := max98088.o snd-soc-pcm3008-objs := pcm3008.o snd-soc-spdif-objs := spdif_transciever.o snd-soc-ssm2602-objs := ssm2602.o @@ -90,7 +89,6 @@ obj-$(CONFIG_SND_SOC_CX20442) += snd-soc-cx20442.o obj-$(CONFIG_SND_SOC_DA7210) += snd-soc-da7210.o obj-$(CONFIG_SND_SOC_L3) += snd-soc-l3.o obj-$(CONFIG_SND_SOC_JZ4740_CODEC) += snd-soc-jz4740-codec.o -obj-$(CONFIG_SND_SOC_MAX98088) += snd-soc-max98088.o obj-$(CONFIG_SND_SOC_PCM3008) += snd-soc-pcm3008.o obj-$(CONFIG_SND_SOC_SPDIF) += snd-soc-spdif.o obj-$(CONFIG_SND_SOC_SSM2602) += snd-soc-ssm2602.o diff --git a/sound/soc/codecs/max98088.c b/sound/soc/codecs/max98088.c deleted file mode 100644 index 4186b27..0000000 --- a/sound/soc/codecs/max98088.c +++ /dev/null @@ -1,2097 +0,0 @@ -/* - * max98088.c -- MAX98088 ALSA SoC Audio driver - * - * Copyright 2010 Maxim Integrated Products - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. - */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "max98088.h" - -struct max98088_cdata { - unsigned int rate; - unsigned int fmt; - int eq_sel; -}; - -struct max98088_priv { - u8 reg_cache[M98088_REG_CNT]; - void *control_data; - struct max98088_pdata *pdata; - unsigned int sysclk; - struct max98088_cdata dai[2]; - int eq_textcnt; - const char **eq_texts; - struct soc_enum eq_enum; - u8 ina_state; - u8 inb_state; - unsigned int ex_mode; - unsigned int digmic; - unsigned int mic1pre; - unsigned int mic2pre; - unsigned int extmic_mode; -}; - -static const u8 max98088_reg[M98088_REG_CNT] = { - 0x00, /* 00 IRQ status */ - 0x00, /* 01 MIC status */ - 0x00, /* 02 jack status */ - 0x00, /* 03 battery voltage */ - 0x00, /* 04 */ - 0x00, /* 05 */ - 0x00, /* 06 */ - 0x00, /* 07 */ - 0x00, /* 08 */ - 0x00, /* 09 */ - 0x00, /* 0A */ - 0x00, /* 0B */ - 0x00, /* 0C */ - 0x00, /* 0D */ - 0x00, /* 0E */ - 0x00, /* 0F interrupt enable */ - - 0x00, /* 10 master clock */ - 0x00, /* 11 DAI1 clock mode */ - 0x00, /* 12 DAI1 clock control */ - 0x00, /* 13 DAI1 clock control */ - 0x00, /* 14 DAI1 format */ - 0x00, /* 15 DAI1 clock */ - 0x00, /* 16 DAI1 config */ - 0x00, /* 17 DAI1 TDM */ - 0x00, /* 18 DAI1 filters */ - 0x00, /* 19 DAI2 clock mode */ - 0x00, /* 1A DAI2 clock control */ - 0x00, /* 1B DAI2 clock control */ - 0x00, /* 1C DAI2 format */ - 0x00, /* 1D DAI2 clock */ - 0x00, /* 1E DAI2 config */ - 0x00, /* 1F DAI2 TDM */ - - 0x00, /* 20 DAI2 filters */ - 0x00, /* 21 data config */ - 0x00, /* 22 DAC mixer */ - 0x00, /* 23 left ADC mixer */ - 0x00, /* 24 right ADC mixer */ - 0x00, /* 25 left HP mixer */ - 0x00, /* 26 right HP mixer */ - 0x00, /* 27 HP control */ - 0x00, /* 28 left REC mixer */ - 0x00, /* 29 right REC mixer */ - 0x00, /* 2A REC control */ - 0x00, /* 2B left SPK mixer */ - 0x00, /* 2C right SPK mixer */ - 0x00, /* 2D SPK control */ - 0x00, /* 2E sidetone */ - 0x00, /* 2F DAI1 playback level */ - - 0x00, /* 30 DAI1 playback level */ - 0x00, /* 31 DAI2 playback level */ - 0x00, /* 32 DAI2 playbakc level */ - 0x00, /* 33 left ADC level */ - 0x00, /* 34 right ADC level */ - 0x00, /* 35 MIC1 level */ - 0x00, /* 36 MIC2 level */ - 0x00, /* 37 INA level */ - 0x00, /* 38 INB level */ - 0x00, /* 39 left HP volume */ - 0x00, /* 3A right HP volume */ - 0x00, /* 3B left REC volume */ - 0x00, /* 3C right REC volume */ - 0x00, /* 3D left SPK volume */ - 0x00, /* 3E right SPK volume */ - 0x00, /* 3F MIC config */ - - 0x00, /* 40 MIC threshold */ - 0x00, /* 41 excursion limiter filter */ - 0x00, /* 42 excursion limiter threshold */ - 0x00, /* 43 ALC */ - 0x00, /* 44 power limiter threshold */ - 0x00, /* 45 power limiter config */ - 0x00, /* 46 distortion limiter config */ - 0x00, /* 47 audio input */ - 0x00, /* 48 microphone */ - 0x00, /* 49 level control */ - 0x00, /* 4A bypass switches */ - 0x00, /* 4B jack detect */ - 0x00, /* 4C input enable */ - 0x00, /* 4D output enable */ - 0xF0, /* 4E bias control */ - 0x00, /* 4F DAC power */ - - 0x0F, /* 50 DAC power */ - 0x00, /* 51 system */ - 0x00, /* 52 DAI1 EQ1 */ - 0x00, /* 53 DAI1 EQ1 */ - 0x00, /* 54 DAI1 EQ1 */ - 0x00, /* 55 DAI1 EQ1 */ - 0x00, /* 56 DAI1 EQ1 */ - 0x00, /* 57 DAI1 EQ1 */ - 0x00, /* 58 DAI1 EQ1 */ - 0x00, /* 59 DAI1 EQ1 */ - 0x00, /* 5A DAI1 EQ1 */ - 0x00, /* 5B DAI1 EQ1 */ - 0x00, /* 5C DAI1 EQ2 */ - 0x00, /* 5D DAI1 EQ2 */ - 0x00, /* 5E DAI1 EQ2 */ - 0x00, /* 5F DAI1 EQ2 */ - - 0x00, /* 60 DAI1 EQ2 */ - 0x00, /* 61 DAI1 EQ2 */ - 0x00, /* 62 DAI1 EQ2 */ - 0x00, /* 63 DAI1 EQ2 */ - 0x00, /* 64 DAI1 EQ2 */ - 0x00, /* 65 DAI1 EQ2 */ - 0x00, /* 66 DAI1 EQ3 */ - 0x00, /* 67 DAI1 EQ3 */ - 0x00, /* 68 DAI1 EQ3 */ - 0x00, /* 69 DAI1 EQ3 */ - 0x00, /* 6A DAI1 EQ3 */ - 0x00, /* 6B DAI1 EQ3 */ - 0x00, /* 6C DAI1 EQ3 */ - 0x00, /* 6D DAI1 EQ3 */ - 0x00, /* 6E DAI1 EQ3 */ - 0x00, /* 6F DAI1 EQ3 */ - - 0x00, /* 70 DAI1 EQ4 */ - 0x00, /* 71 DAI1 EQ4 */ - 0x00, /* 72 DAI1 EQ4 */ - 0x00, /* 73 DAI1 EQ4 */ - 0x00, /* 74 DAI1 EQ4 */ - 0x00, /* 75 DAI1 EQ4 */ - 0x00, /* 76 DAI1 EQ4 */ - 0x00, /* 77 DAI1 EQ4 */ - 0x00, /* 78 DAI1 EQ4 */ - 0x00, /* 79 DAI1 EQ4 */ - 0x00, /* 7A DAI1 EQ5 */ - 0x00, /* 7B DAI1 EQ5 */ - 0x00, /* 7C DAI1 EQ5 */ - 0x00, /* 7D DAI1 EQ5 */ - 0x00, /* 7E DAI1 EQ5 */ - 0x00, /* 7F DAI1 EQ5 */ - - 0x00, /* 80 DAI1 EQ5 */ - 0x00, /* 81 DAI1 EQ5 */ - 0x00, /* 82 DAI1 EQ5 */ - 0x00, /* 83 DAI1 EQ5 */ - 0x00, /* 84 DAI2 EQ1 */ - 0x00, /* 85 DAI2 EQ1 */ - 0x00, /* 86 DAI2 EQ1 */ - 0x00, /* 87 DAI2 EQ1 */ - 0x00, /* 88 DAI2 EQ1 */ - 0x00, /* 89 DAI2 EQ1 */ - 0x00, /* 8A DAI2 EQ1 */ - 0x00, /* 8B DAI2 EQ1 */ - 0x00, /* 8C DAI2 EQ1 */ - 0x00, /* 8D DAI2 EQ1 */ - 0x00, /* 8E DAI2 EQ2 */ - 0x00, /* 8F DAI2 EQ2 */ - - 0x00, /* 90 DAI2 EQ2 */ - 0x00, /* 91 DAI2 EQ2 */ - 0x00, /* 92 DAI2 EQ2 */ - 0x00, /* 93 DAI2 EQ2 */ - 0x00, /* 94 DAI2 EQ2 */ - 0x00, /* 95 DAI2 EQ2 */ - 0x00, /* 96 DAI2 EQ2 */ - 0x00, /* 97 DAI2 EQ2 */ - 0x00, /* 98 DAI2 EQ3 */ - 0x00, /* 99 DAI2 EQ3 */ - 0x00, /* 9A DAI2 EQ3 */ - 0x00, /* 9B DAI2 EQ3 */ - 0x00, /* 9C DAI2 EQ3 */ - 0x00, /* 9D DAI2 EQ3 */ - 0x00, /* 9E DAI2 EQ3 */ - 0x00, /* 9F DAI2 EQ3 */ - - 0x00, /* A0 DAI2 EQ3 */ - 0x00, /* A1 DAI2 EQ3 */ - 0x00, /* A2 DAI2 EQ4 */ - 0x00, /* A3 DAI2 EQ4 */ - 0x00, /* A4 DAI2 EQ4 */ - 0x00, /* A5 DAI2 EQ4 */ - 0x00, /* A6 DAI2 EQ4 */ - 0x00, /* A7 DAI2 EQ4 */ - 0x00, /* A8 DAI2 EQ4 */ - 0x00, /* A9 DAI2 EQ4 */ - 0x00, /* AA DAI2 EQ4 */ - 0x00, /* AB DAI2 EQ4 */ - 0x00, /* AC DAI2 EQ5 */ - 0x00, /* AD DAI2 EQ5 */ - 0x00, /* AE DAI2 EQ5 */ - 0x00, /* AF DAI2 EQ5 */ - - 0x00, /* B0 DAI2 EQ5 */ - 0x00, /* B1 DAI2 EQ5 */ - 0x00, /* B2 DAI2 EQ5 */ - 0x00, /* B3 DAI2 EQ5 */ - 0x00, /* B4 DAI2 EQ5 */ - 0x00, /* B5 DAI2 EQ5 */ - 0x00, /* B6 DAI1 biquad */ - 0x00, /* B7 DAI1 biquad */ - 0x00, /* B8 DAI1 biquad */ - 0x00, /* B9 DAI1 biquad */ - 0x00, /* BA DAI1 biquad */ - 0x00, /* BB DAI1 biquad */ - 0x00, /* BC DAI1 biquad */ - 0x00, /* BD DAI1 biquad */ - 0x00, /* BE DAI1 biquad */ - 0x00, /* BF DAI1 biquad */ - - 0x00, /* C0 DAI2 biquad */ - 0x00, /* C1 DAI2 biquad */ - 0x00, /* C2 DAI2 biquad */ - 0x00, /* C3 DAI2 biquad */ - 0x00, /* C4 DAI2 biquad */ - 0x00, /* C5 DAI2 biquad */ - 0x00, /* C6 DAI2 biquad */ - 0x00, /* C7 DAI2 biquad */ - 0x00, /* C8 DAI2 biquad */ - 0x00, /* C9 DAI2 biquad */ - 0x00, /* CA */ - 0x00, /* CB */ - 0x00, /* CC */ - 0x00, /* CD */ - 0x00, /* CE */ - 0x00, /* CF */ - - 0x00, /* D0 */ - 0x00, /* D1 */ - 0x00, /* D2 */ - 0x00, /* D3 */ - 0x00, /* D4 */ - 0x00, /* D5 */ - 0x00, /* D6 */ - 0x00, /* D7 */ - 0x00, /* D8 */ - 0x00, /* D9 */ - 0x00, /* DA */ - 0x70, /* DB */ - 0x00, /* DC */ - 0x00, /* DD */ - 0x00, /* DE */ - 0x00, /* DF */ - - 0x00, /* E0 */ - 0x00, /* E1 */ - 0x00, /* E2 */ - 0x00, /* E3 */ - 0x00, /* E4 */ - 0x00, /* E5 */ - 0x00, /* E6 */ - 0x00, /* E7 */ - 0x00, /* E8 */ - 0x00, /* E9 */ - 0x00, /* EA */ - 0x00, /* EB */ - 0x00, /* EC */ - 0x00, /* ED */ - 0x00, /* EE */ - 0x00, /* EF */ - - 0x00, /* F0 */ - 0x00, /* F1 */ - 0x00, /* F2 */ - 0x00, /* F3 */ - 0x00, /* F4 */ - 0x00, /* F5 */ - 0x00, /* F6 */ - 0x00, /* F7 */ - 0x00, /* F8 */ - 0x00, /* F9 */ - 0x00, /* FA */ - 0x00, /* FB */ - 0x00, /* FC */ - 0x00, /* FD */ - 0x00, /* FE */ - 0x00, /* FF */ -}; - -static struct { - int readable; - int writable; - int vol; -} max98088_access[M98088_REG_CNT] = { - { 0xFF, 0xFF, 1 }, /* 00 IRQ status */ - { 0xFF, 0x00, 1 }, /* 01 MIC status */ - { 0xFF, 0x00, 1 }, /* 02 jack status */ - { 0x1F, 0x1F, 1 }, /* 03 battery voltage */ - { 0xFF, 0xFF, 0 }, /* 04 */ - { 0xFF, 0xFF, 0 }, /* 05 */ - { 0xFF, 0xFF, 0 }, /* 06 */ - { 0xFF, 0xFF, 0 }, /* 07 */ - { 0xFF, 0xFF, 0 }, /* 08 */ - { 0xFF, 0xFF, 0 }, /* 09 */ - { 0xFF, 0xFF, 0 }, /* 0A */ - { 0xFF, 0xFF, 0 }, /* 0B */ - { 0xFF, 0xFF, 0 }, /* 0C */ - { 0xFF, 0xFF, 0 }, /* 0D */ - { 0xFF, 0xFF, 0 }, /* 0E */ - { 0xFF, 0xFF, 0 }, /* 0F interrupt enable */ - - { 0xFF, 0xFF, 0 }, /* 10 master clock */ - { 0xFF, 0xFF, 0 }, /* 11 DAI1 clock mode */ - { 0xFF, 0xFF, 0 }, /* 12 DAI1 clock control */ - { 0xFF, 0xFF, 0 }, /* 13 DAI1 clock control */ - { 0xFF, 0xFF, 0 }, /* 14 DAI1 format */ - { 0xFF, 0xFF, 0 }, /* 15 DAI1 clock */ - { 0xFF, 0xFF, 0 }, /* 16 DAI1 config */ - { 0xFF, 0xFF, 0 }, /* 17 DAI1 TDM */ - { 0xFF, 0xFF, 0 }, /* 18 DAI1 filters */ - { 0xFF, 0xFF, 0 }, /* 19 DAI2 clock mode */ - { 0xFF, 0xFF, 0 }, /* 1A DAI2 clock control */ - { 0xFF, 0xFF, 0 }, /* 1B DAI2 clock control */ - { 0xFF, 0xFF, 0 }, /* 1C DAI2 format */ - { 0xFF, 0xFF, 0 }, /* 1D DAI2 clock */ - { 0xFF, 0xFF, 0 }, /* 1E DAI2 config */ - { 0xFF, 0xFF, 0 }, /* 1F DAI2 TDM */ - - { 0xFF, 0xFF, 0 }, /* 20 DAI2 filters */ - { 0xFF, 0xFF, 0 }, /* 21 data config */ - { 0xFF, 0xFF, 0 }, /* 22 DAC mixer */ - { 0xFF, 0xFF, 0 }, /* 23 left ADC mixer */ - { 0xFF, 0xFF, 0 }, /* 24 right ADC mixer */ - { 0xFF, 0xFF, 0 }, /* 25 left HP mixer */ - { 0xFF, 0xFF, 0 }, /* 26 right HP mixer */ - { 0xFF, 0xFF, 0 }, /* 27 HP control */ - { 0xFF, 0xFF, 0 }, /* 28 left REC mixer */ - { 0xFF, 0xFF, 0 }, /* 29 right REC mixer */ - { 0xFF, 0xFF, 0 }, /* 2A REC control */ - { 0xFF, 0xFF, 0 }, /* 2B left SPK mixer */ - { 0xFF, 0xFF, 0 }, /* 2C right SPK mixer */ - { 0xFF, 0xFF, 0 }, /* 2D SPK control */ - { 0xFF, 0xFF, 0 }, /* 2E sidetone */ - { 0xFF, 0xFF, 0 }, /* 2F DAI1 playback level */ - - { 0xFF, 0xFF, 0 }, /* 30 DAI1 playback level */ - { 0xFF, 0xFF, 0 }, /* 31 DAI2 playback level */ - { 0xFF, 0xFF, 0 }, /* 32 DAI2 playbakc level */ - { 0xFF, 0xFF, 0 }, /* 33 left ADC level */ - { 0xFF, 0xFF, 0 }, /* 34 right ADC level */ - { 0xFF, 0xFF, 0 }, /* 35 MIC1 level */ - { 0xFF, 0xFF, 0 }, /* 36 MIC2 level */ - { 0xFF, 0xFF, 0 }, /* 37 INA level */ - { 0xFF, 0xFF, 0 }, /* 38 INB level */ - { 0xFF, 0xFF, 0 }, /* 39 left HP volume */ - { 0xFF, 0xFF, 0 }, /* 3A right HP volume */ - { 0xFF, 0xFF, 0 }, /* 3B left REC volume */ - { 0xFF, 0xFF, 0 }, /* 3C right REC volume */ - { 0xFF, 0xFF, 0 }, /* 3D left SPK volume */ - { 0xFF, 0xFF, 0 }, /* 3E right SPK volume */ - { 0xFF, 0xFF, 0 }, /* 3F MIC config */ - - { 0xFF, 0xFF, 0 }, /* 40 MIC threshold */ - { 0xFF, 0xFF, 0 }, /* 41 excursion limiter filter */ - { 0xFF, 0xFF, 0 }, /* 42 excursion limiter threshold */ - { 0xFF, 0xFF, 0 }, /* 43 ALC */ - { 0xFF, 0xFF, 0 }, /* 44 power limiter threshold */ - { 0xFF, 0xFF, 0 }, /* 45 power limiter config */ - { 0xFF, 0xFF, 0 }, /* 46 distortion limiter config */ - { 0xFF, 0xFF, 0 }, /* 47 audio input */ - { 0xFF, 0xFF, 0 }, /* 48 microphone */ - { 0xFF, 0xFF, 0 }, /* 49 level control */ - { 0xFF, 0xFF, 0 }, /* 4A bypass switches */ - { 0xFF, 0xFF, 0 }, /* 4B jack detect */ - { 0xFF, 0xFF, 0 }, /* 4C input enable */ - { 0xFF, 0xFF, 0 }, /* 4D output enable */ - { 0xFF, 0xFF, 0 }, /* 4E bias control */ - { 0xFF, 0xFF, 0 }, /* 4F DAC power */ - - { 0xFF, 0xFF, 0 }, /* 50 DAC power */ - { 0xFF, 0xFF, 0 }, /* 51 system */ - { 0xFF, 0xFF, 0 }, /* 52 DAI1 EQ1 */ - { 0xFF, 0xFF, 0 }, /* 53 DAI1 EQ1 */ - { 0xFF, 0xFF, 0 }, /* 54 DAI1 EQ1 */ - { 0xFF, 0xFF, 0 }, /* 55 DAI1 EQ1 */ - { 0xFF, 0xFF, 0 }, /* 56 DAI1 EQ1 */ - { 0xFF, 0xFF, 0 }, /* 57 DAI1 EQ1 */ - { 0xFF, 0xFF, 0 }, /* 58 DAI1 EQ1 */ - { 0xFF, 0xFF, 0 }, /* 59 DAI1 EQ1 */ - { 0xFF, 0xFF, 0 }, /* 5A DAI1 EQ1 */ - { 0xFF, 0xFF, 0 }, /* 5B DAI1 EQ1 */ - { 0xFF, 0xFF, 0 }, /* 5C DAI1 EQ2 */ - { 0xFF, 0xFF, 0 }, /* 5D DAI1 EQ2 */ - { 0xFF, 0xFF, 0 }, /* 5E DAI1 EQ2 */ - { 0xFF, 0xFF, 0 }, /* 5F DAI1 EQ2 */ - - { 0xFF, 0xFF, 0 }, /* 60 DAI1 EQ2 */ - { 0xFF, 0xFF, 0 }, /* 61 DAI1 EQ2 */ - { 0xFF, 0xFF, 0 }, /* 62 DAI1 EQ2 */ - { 0xFF, 0xFF, 0 }, /* 63 DAI1 EQ2 */ - { 0xFF, 0xFF, 0 }, /* 64 DAI1 EQ2 */ - { 0xFF, 0xFF, 0 }, /* 65 DAI1 EQ2 */ - { 0xFF, 0xFF, 0 }, /* 66 DAI1 EQ3 */ - { 0xFF, 0xFF, 0 }, /* 67 DAI1 EQ3 */ - { 0xFF, 0xFF, 0 }, /* 68 DAI1 EQ3 */ - { 0xFF, 0xFF, 0 }, /* 69 DAI1 EQ3 */ - { 0xFF, 0xFF, 0 }, /* 6A DAI1 EQ3 */ - { 0xFF, 0xFF, 0 }, /* 6B DAI1 EQ3 */ - { 0xFF, 0xFF, 0 }, /* 6C DAI1 EQ3 */ - { 0xFF, 0xFF, 0 }, /* 6D DAI1 EQ3 */ - { 0xFF, 0xFF, 0 }, /* 6E DAI1 EQ3 */ - { 0xFF, 0xFF, 0 }, /* 6F DAI1 EQ3 */ - - { 0xFF, 0xFF, 0 }, /* 70 DAI1 EQ4 */ - { 0xFF, 0xFF, 0 }, /* 71 DAI1 EQ4 */ - { 0xFF, 0xFF, 0 }, /* 72 DAI1 EQ4 */ - { 0xFF, 0xFF, 0 }, /* 73 DAI1 EQ4 */ - { 0xFF, 0xFF, 0 }, /* 74 DAI1 EQ4 */ - { 0xFF, 0xFF, 0 }, /* 75 DAI1 EQ4 */ - { 0xFF, 0xFF, 0 }, /* 76 DAI1 EQ4 */ - { 0xFF, 0xFF, 0 }, /* 77 DAI1 EQ4 */ - { 0xFF, 0xFF, 0 }, /* 78 DAI1 EQ4 */ - { 0xFF, 0xFF, 0 }, /* 79 DAI1 EQ4 */ - { 0xFF, 0xFF, 0 }, /* 7A DAI1 EQ5 */ - { 0xFF, 0xFF, 0 }, /* 7B DAI1 EQ5 */ - { 0xFF, 0xFF, 0 }, /* 7C DAI1 EQ5 */ - { 0xFF, 0xFF, 0 }, /* 7D DAI1 EQ5 */ - { 0xFF, 0xFF, 0 }, /* 7E DAI1 EQ5 */ - { 0xFF, 0xFF, 0 }, /* 7F DAI1 EQ5 */ - - { 0xFF, 0xFF, 0 }, /* 80 DAI1 EQ5 */ - { 0xFF, 0xFF, 0 }, /* 81 DAI1 EQ5 */ - { 0xFF, 0xFF, 0 }, /* 82 DAI1 EQ5 */ - { 0xFF, 0xFF, 0 }, /* 83 DAI1 EQ5 */ - { 0xFF, 0xFF, 0 }, /* 84 DAI2 EQ1 */ - { 0xFF, 0xFF, 0 }, /* 85 DAI2 EQ1 */ - { 0xFF, 0xFF, 0 }, /* 86 DAI2 EQ1 */ - { 0xFF, 0xFF, 0 }, /* 87 DAI2 EQ1 */ - { 0xFF, 0xFF, 0 }, /* 88 DAI2 EQ1 */ - { 0xFF, 0xFF, 0 }, /* 89 DAI2 EQ1 */ - { 0xFF, 0xFF, 0 }, /* 8A DAI2 EQ1 */ - { 0xFF, 0xFF, 0 }, /* 8B DAI2 EQ1 */ - { 0xFF, 0xFF, 0 }, /* 8C DAI2 EQ1 */ - { 0xFF, 0xFF, 0 }, /* 8D DAI2 EQ1 */ - { 0xFF, 0xFF, 0 }, /* 8E DAI2 EQ2 */ - { 0xFF, 0xFF, 0 }, /* 8F DAI2 EQ2 */ - - { 0xFF, 0xFF, 0 }, /* 90 DAI2 EQ2 */ - { 0xFF, 0xFF, 0 }, /* 91 DAI2 EQ2 */ - { 0xFF, 0xFF, 0 }, /* 92 DAI2 EQ2 */ - { 0xFF, 0xFF, 0 }, /* 93 DAI2 EQ2 */ - { 0xFF, 0xFF, 0 }, /* 94 DAI2 EQ2 */ - { 0xFF, 0xFF, 0 }, /* 95 DAI2 EQ2 */ - { 0xFF, 0xFF, 0 }, /* 96 DAI2 EQ2 */ - { 0xFF, 0xFF, 0 }, /* 97 DAI2 EQ2 */ - { 0xFF, 0xFF, 0 }, /* 98 DAI2 EQ3 */ - { 0xFF, 0xFF, 0 }, /* 99 DAI2 EQ3 */ - { 0xFF, 0xFF, 0 }, /* 9A DAI2 EQ3 */ - { 0xFF, 0xFF, 0 }, /* 9B DAI2 EQ3 */ - { 0xFF, 0xFF, 0 }, /* 9C DAI2 EQ3 */ - { 0xFF, 0xFF, 0 }, /* 9D DAI2 EQ3 */ - { 0xFF, 0xFF, 0 }, /* 9E DAI2 EQ3 */ - { 0xFF, 0xFF, 0 }, /* 9F DAI2 EQ3 */ - - { 0xFF, 0xFF, 0 }, /* A0 DAI2 EQ3 */ - { 0xFF, 0xFF, 0 }, /* A1 DAI2 EQ3 */ - { 0xFF, 0xFF, 0 }, /* A2 DAI2 EQ4 */ - { 0xFF, 0xFF, 0 }, /* A3 DAI2 EQ4 */ - { 0xFF, 0xFF, 0 }, /* A4 DAI2 EQ4 */ - { 0xFF, 0xFF, 0 }, /* A5 DAI2 EQ4 */ - { 0xFF, 0xFF, 0 }, /* A6 DAI2 EQ4 */ - { 0xFF, 0xFF, 0 }, /* A7 DAI2 EQ4 */ - { 0xFF, 0xFF, 0 }, /* A8 DAI2 EQ4 */ - { 0xFF, 0xFF, 0 }, /* A9 DAI2 EQ4 */ - { 0xFF, 0xFF, 0 }, /* AA DAI2 EQ4 */ - { 0xFF, 0xFF, 0 }, /* AB DAI2 EQ4 */ - { 0xFF, 0xFF, 0 }, /* AC DAI2 EQ5 */ - { 0xFF, 0xFF, 0 }, /* AD DAI2 EQ5 */ - { 0xFF, 0xFF, 0 }, /* AE DAI2 EQ5 */ - { 0xFF, 0xFF, 0 }, /* AF DAI2 EQ5 */ - - { 0xFF, 0xFF, 0 }, /* B0 DAI2 EQ5 */ - { 0xFF, 0xFF, 0 }, /* B1 DAI2 EQ5 */ - { 0xFF, 0xFF, 0 }, /* B2 DAI2 EQ5 */ - { 0xFF, 0xFF, 0 }, /* B3 DAI2 EQ5 */ - { 0xFF, 0xFF, 0 }, /* B4 DAI2 EQ5 */ - { 0xFF, 0xFF, 0 }, /* B5 DAI2 EQ5 */ - { 0xFF, 0xFF, 0 }, /* B6 DAI1 biquad */ - { 0xFF, 0xFF, 0 }, /* B7 DAI1 biquad */ - { 0xFF, 0xFF, 0 }, /* B8 DAI1 biquad */ - { 0xFF, 0xFF, 0 }, /* B9 DAI1 biquad */ - { 0xFF, 0xFF, 0 }, /* BA DAI1 biquad */ - { 0xFF, 0xFF, 0 }, /* BB DAI1 biquad */ - { 0xFF, 0xFF, 0 }, /* BC DAI1 biquad */ - { 0xFF, 0xFF, 0 }, /* BD DAI1 biquad */ - { 0xFF, 0xFF, 0 }, /* BE DAI1 biquad */ - { 0xFF, 0xFF, 0 }, /* BF DAI1 biquad */ - - { 0xFF, 0xFF, 0 }, /* C0 DAI2 biquad */ - { 0xFF, 0xFF, 0 }, /* C1 DAI2 biquad */ - { 0xFF, 0xFF, 0 }, /* C2 DAI2 biquad */ - { 0xFF, 0xFF, 0 }, /* C3 DAI2 biquad */ - { 0xFF, 0xFF, 0 }, /* C4 DAI2 biquad */ - { 0xFF, 0xFF, 0 }, /* C5 DAI2 biquad */ - { 0xFF, 0xFF, 0 }, /* C6 DAI2 biquad */ - { 0xFF, 0xFF, 0 }, /* C7 DAI2 biquad */ - { 0xFF, 0xFF, 0 }, /* C8 DAI2 biquad */ - { 0xFF, 0xFF, 0 }, /* C9 DAI2 biquad */ - { 0x00, 0x00, 0 }, /* CA */ - { 0x00, 0x00, 0 }, /* CB */ - { 0x00, 0x00, 0 }, /* CC */ - { 0x00, 0x00, 0 }, /* CD */ - { 0x00, 0x00, 0 }, /* CE */ - { 0x00, 0x00, 0 }, /* CF */ - - { 0x00, 0x00, 0 }, /* D0 */ - { 0x00, 0x00, 0 }, /* D1 */ - { 0x00, 0x00, 0 }, /* D2 */ - { 0x00, 0x00, 0 }, /* D3 */ - { 0x00, 0x00, 0 }, /* D4 */ - { 0x00, 0x00, 0 }, /* D5 */ - { 0x00, 0x00, 0 }, /* D6 */ - { 0x00, 0x00, 0 }, /* D7 */ - { 0x00, 0x00, 0 }, /* D8 */ - { 0x00, 0x00, 0 }, /* D9 */ - { 0x00, 0x00, 0 }, /* DA */ - { 0x00, 0x00, 0 }, /* DB */ - { 0x00, 0x00, 0 }, /* DC */ - { 0x00, 0x00, 0 }, /* DD */ - { 0x00, 0x00, 0 }, /* DE */ - { 0x00, 0x00, 0 }, /* DF */ - - { 0x00, 0x00, 0 }, /* E0 */ - { 0x00, 0x00, 0 }, /* E1 */ - { 0x00, 0x00, 0 }, /* E2 */ - { 0x00, 0x00, 0 }, /* E3 */ - { 0x00, 0x00, 0 }, /* E4 */ - { 0x00, 0x00, 0 }, /* E5 */ - { 0x00, 0x00, 0 }, /* E6 */ - { 0x00, 0x00, 0 }, /* E7 */ - { 0x00, 0x00, 0 }, /* E8 */ - { 0x00, 0x00, 0 }, /* E9 */ - { 0x00, 0x00, 0 }, /* EA */ - { 0x00, 0x00, 0 }, /* EB */ - { 0x00, 0x00, 0 }, /* EC */ - { 0x00, 0x00, 0 }, /* ED */ - { 0x00, 0x00, 0 }, /* EE */ - { 0x00, 0x00, 0 }, /* EF */ - - { 0x00, 0x00, 0 }, /* F0 */ - { 0x00, 0x00, 0 }, /* F1 */ - { 0x00, 0x00, 0 }, /* F2 */ - { 0x00, 0x00, 0 }, /* F3 */ - { 0x00, 0x00, 0 }, /* F4 */ - { 0x00, 0x00, 0 }, /* F5 */ - { 0x00, 0x00, 0 }, /* F6 */ - { 0x00, 0x00, 0 }, /* F7 */ - { 0x00, 0x00, 0 }, /* F8 */ - { 0x00, 0x00, 0 }, /* F9 */ - { 0x00, 0x00, 0 }, /* FA */ - { 0x00, 0x00, 0 }, /* FB */ - { 0x00, 0x00, 0 }, /* FC */ - { 0x00, 0x00, 0 }, /* FD */ - { 0x00, 0x00, 0 }, /* FE */ - { 0xFF, 0x00, 1 }, /* FF */ -}; - -static int max98088_volatile_register(unsigned int reg) -{ - return max98088_access[reg].vol; -} - - -/* - * Load equalizer DSP coefficient configurations registers - */ -void m98088_eq_band(struct snd_soc_codec *codec, unsigned int dai, - unsigned int band, u16 *coefs) -{ - unsigned int eq_reg; - unsigned int i; - - BUG_ON(band > 4); - BUG_ON(dai > 1); - - /* Load the base register address */ - eq_reg = dai ? M98088_REG_84_DAI2_EQ_BASE : M98088_REG_52_DAI1_EQ_BASE; - - /* Add the band address offset, note adjustment for word address */ - eq_reg += band * (M98088_COEFS_PER_BAND << 1); - - /* Step through the registers and coefs */ - for (i = 0; i < M98088_COEFS_PER_BAND; i++) { - snd_soc_write(codec, eq_reg++, M98088_BYTE1(coefs[i])); - snd_soc_write(codec, eq_reg++, M98088_BYTE0(coefs[i])); - } -} - -/* - * Excursion limiter modes - */ -static const char *max98088_exmode_texts[] = { - "Off", "100Hz", "400Hz", "600Hz", "800Hz", "1000Hz", "200-400Hz", - "400-600Hz", "400-800Hz", -}; - -static const unsigned int max98088_exmode_values[] = { - 0x00, 0x43, 0x10, 0x20, 0x30, 0x40, 0x11, 0x22, 0x32 -}; - -static const struct soc_enum max98088_exmode_enum = - SOC_VALUE_ENUM_SINGLE(M98088_REG_41_SPKDHP, 0, 127, - ARRAY_SIZE(max98088_exmode_texts), - max98088_exmode_texts, - max98088_exmode_values); -static const struct snd_kcontrol_new max98088_exmode_controls = - SOC_DAPM_VALUE_ENUM("Route", max98088_exmode_enum); - -static const char *max98088_ex_thresh[] = { /* volts PP */ - "0.6", "1.2", "1.8", "2.4", "3.0", "3.6", "4.2", "4.8"}; -static const struct soc_enum max98088_ex_thresh_enum[] = { - SOC_ENUM_SINGLE(M98088_REG_42_SPKDHP_THRESH, 0, 8, - max98088_ex_thresh), -}; - -static const char *max98088_fltr_mode[] = {"Voice", "Music" }; -static const struct soc_enum max98088_filter_mode_enum[] = { - SOC_ENUM_SINGLE(M98088_REG_18_DAI1_FILTERS, 7, 2, max98088_fltr_mode), -}; - -static const char *max98088_extmic_text[] = { "None", "MIC1", "MIC2" }; - -static const struct soc_enum max98088_extmic_enum = - SOC_ENUM_SINGLE(M98088_REG_48_CFG_MIC, 0, 3, max98088_extmic_text); - -static const struct snd_kcontrol_new max98088_extmic_mux = - SOC_DAPM_ENUM("External MIC Mux", max98088_extmic_enum); - -static const char *max98088_dai1_fltr[] = { - "Off", "fc=258/fs=16k", "fc=500/fs=16k", - "fc=258/fs=8k", "fc=500/fs=8k", "fc=200"}; -static const struct soc_enum max98088_dai1_dac_filter_enum[] = { - SOC_ENUM_SINGLE(M98088_REG_18_DAI1_FILTERS, 0, 6, max98088_dai1_fltr), -}; -static const struct soc_enum max98088_dai1_adc_filter_enum[] = { - SOC_ENUM_SINGLE(M98088_REG_18_DAI1_FILTERS, 4, 6, max98088_dai1_fltr), -}; - -static int max98088_mic1pre_set(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); - struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); - unsigned int sel = ucontrol->value.integer.value[0]; - - max98088->mic1pre = sel; - snd_soc_update_bits(codec, M98088_REG_35_LVL_MIC1, M98088_MICPRE_MASK, - (1+sel)<value.integer.value[0] = max98088->mic1pre; - return 0; -} - -static int max98088_mic2pre_set(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); - struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); - unsigned int sel = ucontrol->value.integer.value[0]; - - max98088->mic2pre = sel; - snd_soc_update_bits(codec, M98088_REG_36_LVL_MIC2, M98088_MICPRE_MASK, - (1+sel)<value.integer.value[0] = max98088->mic2pre; - return 0; -} - -static const unsigned int max98088_micboost_tlv[] = { - TLV_DB_RANGE_HEAD(2), - 0, 1, TLV_DB_SCALE_ITEM(0, 2000, 0), - 2, 2, TLV_DB_SCALE_ITEM(3000, 0, 0), -}; - -static const struct snd_kcontrol_new max98088_snd_controls[] = { - - SOC_DOUBLE_R("Headphone Volume", M98088_REG_39_LVL_HP_L, - M98088_REG_3A_LVL_HP_R, 0, 31, 0), - SOC_DOUBLE_R("Speaker Volume", M98088_REG_3D_LVL_SPK_L, - M98088_REG_3E_LVL_SPK_R, 0, 31, 0), - SOC_DOUBLE_R("Receiver Volume", M98088_REG_3B_LVL_REC_L, - M98088_REG_3C_LVL_REC_R, 0, 31, 0), - - SOC_DOUBLE_R("Headphone Switch", M98088_REG_39_LVL_HP_L, - M98088_REG_3A_LVL_HP_R, 7, 1, 1), - SOC_DOUBLE_R("Speaker Switch", M98088_REG_3D_LVL_SPK_L, - M98088_REG_3E_LVL_SPK_R, 7, 1, 1), - SOC_DOUBLE_R("Receiver Switch", M98088_REG_3B_LVL_REC_L, - M98088_REG_3C_LVL_REC_R, 7, 1, 1), - - SOC_SINGLE("MIC1 Volume", M98088_REG_35_LVL_MIC1, 0, 31, 1), - SOC_SINGLE("MIC2 Volume", M98088_REG_36_LVL_MIC2, 0, 31, 1), - - SOC_SINGLE_EXT_TLV("MIC1 Boost Volume", - M98088_REG_35_LVL_MIC1, 5, 2, 0, - max98088_mic1pre_get, max98088_mic1pre_set, - max98088_micboost_tlv), - SOC_SINGLE_EXT_TLV("MIC2 Boost Volume", - M98088_REG_36_LVL_MIC2, 5, 2, 0, - max98088_mic2pre_get, max98088_mic2pre_set, - max98088_micboost_tlv), - - SOC_SINGLE("INA Volume", M98088_REG_37_LVL_INA, 0, 7, 1), - SOC_SINGLE("INB Volume", M98088_REG_38_LVL_INB, 0, 7, 1), - - SOC_SINGLE("ADCL Volume", M98088_REG_33_LVL_ADC_L, 0, 15, 0), - SOC_SINGLE("ADCR Volume", M98088_REG_34_LVL_ADC_R, 0, 15, 0), - - SOC_SINGLE("ADCL Boost Volume", M98088_REG_33_LVL_ADC_L, 4, 3, 0), - SOC_SINGLE("ADCR Boost Volume", M98088_REG_34_LVL_ADC_R, 4, 3, 0), - - SOC_SINGLE("EQ1 Switch", M98088_REG_49_CFG_LEVEL, 0, 1, 0), - SOC_SINGLE("EQ2 Switch", M98088_REG_49_CFG_LEVEL, 1, 1, 0), - - SOC_ENUM("EX Limiter Threshold", max98088_ex_thresh_enum), - - SOC_ENUM("DAI1 Filter Mode", max98088_filter_mode_enum), - SOC_ENUM("DAI1 DAC Filter", max98088_dai1_dac_filter_enum), - SOC_ENUM("DAI1 ADC Filter", max98088_dai1_adc_filter_enum), - SOC_SINGLE("DAI2 DC Block Switch", M98088_REG_20_DAI2_FILTERS, - 0, 1, 0), - - SOC_SINGLE("ALC Switch", M98088_REG_43_SPKALC_COMP, 7, 1, 0), - SOC_SINGLE("ALC Threshold", M98088_REG_43_SPKALC_COMP, 0, 7, 0), - SOC_SINGLE("ALC Multiband", M98088_REG_43_SPKALC_COMP, 3, 1, 0), - SOC_SINGLE("ALC Release Time", M98088_REG_43_SPKALC_COMP, 4, 7, 0), - - SOC_SINGLE("PWR Limiter Threshold", M98088_REG_44_PWRLMT_CFG, - 4, 15, 0), - SOC_SINGLE("PWR Limiter Weight", M98088_REG_44_PWRLMT_CFG, 0, 7, 0), - SOC_SINGLE("PWR Limiter Time1", M98088_REG_45_PWRLMT_TIME, 0, 15, 0), - SOC_SINGLE("PWR Limiter Time2", M98088_REG_45_PWRLMT_TIME, 4, 15, 0), - - SOC_SINGLE("THD Limiter Threshold", M98088_REG_46_THDLMT_CFG, 4, 15, 0), - SOC_SINGLE("THD Limiter Time", M98088_REG_46_THDLMT_CFG, 0, 7, 0), -}; - -/* Left speaker mixer switch */ -static const struct snd_kcontrol_new max98088_left_speaker_mixer_controls[] = { - SOC_DAPM_SINGLE("Left DAC1 Switch", M98088_REG_2B_MIX_SPK_LEFT, 7, 1, 0), - SOC_DAPM_SINGLE("Right DAC1 Switch", M98088_REG_2B_MIX_SPK_LEFT, 0, 1, 0), - SOC_DAPM_SINGLE("Left DAC2 Switch", M98088_REG_2B_MIX_SPK_LEFT, 7, 1, 0), - SOC_DAPM_SINGLE("Right DAC2 Switch", M98088_REG_2B_MIX_SPK_LEFT, 0, 1, 0), - SOC_DAPM_SINGLE("MIC1 Switch", M98088_REG_2B_MIX_SPK_LEFT, 5, 1, 0), - SOC_DAPM_SINGLE("MIC2 Switch", M98088_REG_2B_MIX_SPK_LEFT, 6, 1, 0), - SOC_DAPM_SINGLE("INA1 Switch", M98088_REG_2B_MIX_SPK_LEFT, 1, 1, 0), - SOC_DAPM_SINGLE("INA2 Switch", M98088_REG_2B_MIX_SPK_LEFT, 2, 1, 0), - SOC_DAPM_SINGLE("INB1 Switch", M98088_REG_2B_MIX_SPK_LEFT, 3, 1, 0), - SOC_DAPM_SINGLE("INB2 Switch", M98088_REG_2B_MIX_SPK_LEFT, 4, 1, 0), -}; - -/* Right speaker mixer switch */ -static const struct snd_kcontrol_new max98088_right_speaker_mixer_controls[] = { - SOC_DAPM_SINGLE("Left DAC1 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 7, 1, 0), - SOC_DAPM_SINGLE("Right DAC1 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 0, 1, 0), - SOC_DAPM_SINGLE("Left DAC2 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 7, 1, 0), - SOC_DAPM_SINGLE("Right DAC2 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 0, 1, 0), - SOC_DAPM_SINGLE("MIC1 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 5, 1, 0), - SOC_DAPM_SINGLE("MIC2 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 6, 1, 0), - SOC_DAPM_SINGLE("INA1 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 1, 1, 0), - SOC_DAPM_SINGLE("INA2 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 2, 1, 0), - SOC_DAPM_SINGLE("INB1 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 3, 1, 0), - SOC_DAPM_SINGLE("INB2 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 4, 1, 0), -}; - -/* Left headphone mixer switch */ -static const struct snd_kcontrol_new max98088_left_hp_mixer_controls[] = { - SOC_DAPM_SINGLE("Left DAC1 Switch", M98088_REG_25_MIX_HP_LEFT, 7, 1, 0), - SOC_DAPM_SINGLE("Right DAC1 Switch", M98088_REG_25_MIX_HP_LEFT, 0, 1, 0), - SOC_DAPM_SINGLE("Left DAC2 Switch", M98088_REG_25_MIX_HP_LEFT, 7, 1, 0), - SOC_DAPM_SINGLE("Right DAC2 Switch", M98088_REG_25_MIX_HP_LEFT, 0, 1, 0), - SOC_DAPM_SINGLE("MIC1 Switch", M98088_REG_25_MIX_HP_LEFT, 5, 1, 0), - SOC_DAPM_SINGLE("MIC2 Switch", M98088_REG_25_MIX_HP_LEFT, 6, 1, 0), - SOC_DAPM_SINGLE("INA1 Switch", M98088_REG_25_MIX_HP_LEFT, 1, 1, 0), - SOC_DAPM_SINGLE("INA2 Switch", M98088_REG_25_MIX_HP_LEFT, 2, 1, 0), - SOC_DAPM_SINGLE("INB1 Switch", M98088_REG_25_MIX_HP_LEFT, 3, 1, 0), - SOC_DAPM_SINGLE("INB2 Switch", M98088_REG_25_MIX_HP_LEFT, 4, 1, 0), -}; - -/* Right headphone mixer switch */ -static const struct snd_kcontrol_new max98088_right_hp_mixer_controls[] = { - SOC_DAPM_SINGLE("Left DAC1 Switch", M98088_REG_26_MIX_HP_RIGHT, 7, 1, 0), - SOC_DAPM_SINGLE("Right DAC1 Switch", M98088_REG_26_MIX_HP_RIGHT, 0, 1, 0), - SOC_DAPM_SINGLE("Left DAC2 Switch", M98088_REG_26_MIX_HP_RIGHT, 7, 1, 0), - SOC_DAPM_SINGLE("Right DAC2 Switch", M98088_REG_26_MIX_HP_RIGHT, 0, 1, 0), - SOC_DAPM_SINGLE("MIC1 Switch", M98088_REG_26_MIX_HP_RIGHT, 5, 1, 0), - SOC_DAPM_SINGLE("MIC2 Switch", M98088_REG_26_MIX_HP_RIGHT, 6, 1, 0), - SOC_DAPM_SINGLE("INA1 Switch", M98088_REG_26_MIX_HP_RIGHT, 1, 1, 0), - SOC_DAPM_SINGLE("INA2 Switch", M98088_REG_26_MIX_HP_RIGHT, 2, 1, 0), - SOC_DAPM_SINGLE("INB1 Switch", M98088_REG_26_MIX_HP_RIGHT, 3, 1, 0), - SOC_DAPM_SINGLE("INB2 Switch", M98088_REG_26_MIX_HP_RIGHT, 4, 1, 0), -}; - -/* Left earpiece/receiver mixer switch */ -static const struct snd_kcontrol_new max98088_left_rec_mixer_controls[] = { - SOC_DAPM_SINGLE("Left DAC1 Switch", M98088_REG_28_MIX_REC_LEFT, 7, 1, 0), - SOC_DAPM_SINGLE("Right DAC1 Switch", M98088_REG_28_MIX_REC_LEFT, 0, 1, 0), - SOC_DAPM_SINGLE("Left DAC2 Switch", M98088_REG_28_MIX_REC_LEFT, 7, 1, 0), - SOC_DAPM_SINGLE("Right DAC2 Switch", M98088_REG_28_MIX_REC_LEFT, 0, 1, 0), - SOC_DAPM_SINGLE("MIC1 Switch", M98088_REG_28_MIX_REC_LEFT, 5, 1, 0), - SOC_DAPM_SINGLE("MIC2 Switch", M98088_REG_28_MIX_REC_LEFT, 6, 1, 0), - SOC_DAPM_SINGLE("INA1 Switch", M98088_REG_28_MIX_REC_LEFT, 1, 1, 0), - SOC_DAPM_SINGLE("INA2 Switch", M98088_REG_28_MIX_REC_LEFT, 2, 1, 0), - SOC_DAPM_SINGLE("INB1 Switch", M98088_REG_28_MIX_REC_LEFT, 3, 1, 0), - SOC_DAPM_SINGLE("INB2 Switch", M98088_REG_28_MIX_REC_LEFT, 4, 1, 0), -}; - -/* Right earpiece/receiver mixer switch */ -static const struct snd_kcontrol_new max98088_right_rec_mixer_controls[] = { - SOC_DAPM_SINGLE("Left DAC1 Switch", M98088_REG_29_MIX_REC_RIGHT, 7, 1, 0), - SOC_DAPM_SINGLE("Right DAC1 Switch", M98088_REG_29_MIX_REC_RIGHT, 0, 1, 0), - SOC_DAPM_SINGLE("Left DAC2 Switch", M98088_REG_29_MIX_REC_RIGHT, 7, 1, 0), - SOC_DAPM_SINGLE("Right DAC2 Switch", M98088_REG_29_MIX_REC_RIGHT, 0, 1, 0), - SOC_DAPM_SINGLE("MIC1 Switch", M98088_REG_29_MIX_REC_RIGHT, 5, 1, 0), - SOC_DAPM_SINGLE("MIC2 Switch", M98088_REG_29_MIX_REC_RIGHT, 6, 1, 0), - SOC_DAPM_SINGLE("INA1 Switch", M98088_REG_29_MIX_REC_RIGHT, 1, 1, 0), - SOC_DAPM_SINGLE("INA2 Switch", M98088_REG_29_MIX_REC_RIGHT, 2, 1, 0), - SOC_DAPM_SINGLE("INB1 Switch", M98088_REG_29_MIX_REC_RIGHT, 3, 1, 0), - SOC_DAPM_SINGLE("INB2 Switch", M98088_REG_29_MIX_REC_RIGHT, 4, 1, 0), -}; - -/* Left ADC mixer switch */ -static const struct snd_kcontrol_new max98088_left_ADC_mixer_controls[] = { - SOC_DAPM_SINGLE("MIC1 Switch", M98088_REG_23_MIX_ADC_LEFT, 7, 1, 0), - SOC_DAPM_SINGLE("MIC2 Switch", M98088_REG_23_MIX_ADC_LEFT, 6, 1, 0), - SOC_DAPM_SINGLE("INA1 Switch", M98088_REG_23_MIX_ADC_LEFT, 3, 1, 0), - SOC_DAPM_SINGLE("INA2 Switch", M98088_REG_23_MIX_ADC_LEFT, 2, 1, 0), - SOC_DAPM_SINGLE("INB1 Switch", M98088_REG_23_MIX_ADC_LEFT, 1, 1, 0), - SOC_DAPM_SINGLE("INB2 Switch", M98088_REG_23_MIX_ADC_LEFT, 0, 1, 0), -}; - -/* Right ADC mixer switch */ -static const struct snd_kcontrol_new max98088_right_ADC_mixer_controls[] = { - SOC_DAPM_SINGLE("MIC1 Switch", M98088_REG_24_MIX_ADC_RIGHT, 7, 1, 0), - SOC_DAPM_SINGLE("MIC2 Switch", M98088_REG_24_MIX_ADC_RIGHT, 6, 1, 0), - SOC_DAPM_SINGLE("INA1 Switch", M98088_REG_24_MIX_ADC_RIGHT, 3, 1, 0), - SOC_DAPM_SINGLE("INA2 Switch", M98088_REG_24_MIX_ADC_RIGHT, 2, 1, 0), - SOC_DAPM_SINGLE("INB1 Switch", M98088_REG_24_MIX_ADC_RIGHT, 1, 1, 0), - SOC_DAPM_SINGLE("INB2 Switch", M98088_REG_24_MIX_ADC_RIGHT, 0, 1, 0), -}; - -static int max98088_mic_event(struct snd_soc_dapm_widget *w, - struct snd_kcontrol *kcontrol, int event) -{ - struct snd_soc_codec *codec = w->codec; - struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); - - switch (event) { - case SND_SOC_DAPM_POST_PMU: - if (w->reg == M98088_REG_35_LVL_MIC1) { - snd_soc_update_bits(codec, w->reg, M98088_MICPRE_MASK, - (1+max98088->mic1pre)<reg, M98088_MICPRE_MASK, - (1+max98088->mic2pre)<reg, M98088_MICPRE_MASK, 0); - break; - default: - return -EINVAL; - } - - return 0; -} - -/* - * The line inputs are 2-channel stereo inputs with the left - * and right channels sharing a common PGA power control signal. - */ -static int max98088_line_pga(struct snd_soc_dapm_widget *w, - int event, int line, u8 channel) -{ - struct snd_soc_codec *codec = w->codec; - struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); - u8 *state; - - BUG_ON(!((channel == 1) || (channel == 2))); - - switch (line) { - case LINE_INA: - state = &max98088->ina_state; - break; - case LINE_INB: - state = &max98088->inb_state; - break; - default: - return -EINVAL; - } - - switch (event) { - case SND_SOC_DAPM_POST_PMU: - *state |= channel; - snd_soc_update_bits(codec, w->reg, - (1 << w->shift), (1 << w->shift)); - break; - case SND_SOC_DAPM_POST_PMD: - *state &= ~channel; - if (*state == 0) { - snd_soc_update_bits(codec, w->reg, - (1 << w->shift), 0); - } - break; - default: - return -EINVAL; - } - - return 0; -} - -static int max98088_pga_ina1_event(struct snd_soc_dapm_widget *w, - struct snd_kcontrol *k, int event) -{ - return max98088_line_pga(w, event, LINE_INA, 1); -} - -static int max98088_pga_ina2_event(struct snd_soc_dapm_widget *w, - struct snd_kcontrol *k, int event) -{ - return max98088_line_pga(w, event, LINE_INA, 2); -} - -static int max98088_pga_inb1_event(struct snd_soc_dapm_widget *w, - struct snd_kcontrol *k, int event) -{ - return max98088_line_pga(w, event, LINE_INB, 1); -} - -static int max98088_pga_inb2_event(struct snd_soc_dapm_widget *w, - struct snd_kcontrol *k, int event) -{ - return max98088_line_pga(w, event, LINE_INB, 2); -} - -static const struct snd_soc_dapm_widget max98088_dapm_widgets[] = { - - SND_SOC_DAPM_ADC("ADCL", "HiFi Capture", M98088_REG_4C_PWR_EN_IN, 1, 0), - SND_SOC_DAPM_ADC("ADCR", "HiFi Capture", M98088_REG_4C_PWR_EN_IN, 0, 0), - - SND_SOC_DAPM_DAC("DACL1", "HiFi Playback", - M98088_REG_4D_PWR_EN_OUT, 1, 0), - SND_SOC_DAPM_DAC("DACR1", "HiFi Playback", - M98088_REG_4D_PWR_EN_OUT, 0, 0), - SND_SOC_DAPM_DAC("DACL2", "Aux Playback", - M98088_REG_4D_PWR_EN_OUT, 1, 0), - SND_SOC_DAPM_DAC("DACR2", "Aux Playback", - M98088_REG_4D_PWR_EN_OUT, 0, 0), - - SND_SOC_DAPM_PGA("HP Left Out", M98088_REG_4D_PWR_EN_OUT, - 7, 0, NULL, 0), - SND_SOC_DAPM_PGA("HP Right Out", M98088_REG_4D_PWR_EN_OUT, - 6, 0, NULL, 0), - - SND_SOC_DAPM_PGA("SPK Left Out", M98088_REG_4D_PWR_EN_OUT, - 5, 0, NULL, 0), - SND_SOC_DAPM_PGA("SPK Right Out", M98088_REG_4D_PWR_EN_OUT, - 4, 0, NULL, 0), - - SND_SOC_DAPM_PGA("REC Left Out", M98088_REG_4D_PWR_EN_OUT, - 3, 0, NULL, 0), - SND_SOC_DAPM_PGA("REC Right Out", M98088_REG_4D_PWR_EN_OUT, - 2, 0, NULL, 0), - - SND_SOC_DAPM_MUX("External MIC", SND_SOC_NOPM, 0, 0, - &max98088_extmic_mux), - - SND_SOC_DAPM_MIXER("Left HP Mixer", SND_SOC_NOPM, 0, 0, - &max98088_left_hp_mixer_controls[0], - ARRAY_SIZE(max98088_left_hp_mixer_controls)), - - SND_SOC_DAPM_MIXER("Right HP Mixer", SND_SOC_NOPM, 0, 0, - &max98088_right_hp_mixer_controls[0], - ARRAY_SIZE(max98088_right_hp_mixer_controls)), - - SND_SOC_DAPM_MIXER("Left SPK Mixer", SND_SOC_NOPM, 0, 0, - &max98088_left_speaker_mixer_controls[0], - ARRAY_SIZE(max98088_left_speaker_mixer_controls)), - - SND_SOC_DAPM_MIXER("Right SPK Mixer", SND_SOC_NOPM, 0, 0, - &max98088_right_speaker_mixer_controls[0], - ARRAY_SIZE(max98088_right_speaker_mixer_controls)), - - SND_SOC_DAPM_MIXER("Left REC Mixer", SND_SOC_NOPM, 0, 0, - &max98088_left_rec_mixer_controls[0], - ARRAY_SIZE(max98088_left_rec_mixer_controls)), - - SND_SOC_DAPM_MIXER("Right REC Mixer", SND_SOC_NOPM, 0, 0, - &max98088_right_rec_mixer_controls[0], - ARRAY_SIZE(max98088_right_rec_mixer_controls)), - - SND_SOC_DAPM_MIXER("Left ADC Mixer", SND_SOC_NOPM, 0, 0, - &max98088_left_ADC_mixer_controls[0], - ARRAY_SIZE(max98088_left_ADC_mixer_controls)), - - SND_SOC_DAPM_MIXER("Right ADC Mixer", SND_SOC_NOPM, 0, 0, - &max98088_right_ADC_mixer_controls[0], - ARRAY_SIZE(max98088_right_ADC_mixer_controls)), - - SND_SOC_DAPM_PGA_E("MIC1 Input", M98088_REG_35_LVL_MIC1, - 5, 0, NULL, 0, max98088_mic_event, - SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), - - SND_SOC_DAPM_PGA_E("MIC2 Input", M98088_REG_36_LVL_MIC2, - 5, 0, NULL, 0, max98088_mic_event, - SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), - - SND_SOC_DAPM_PGA_E("INA1 Input", M98088_REG_4C_PWR_EN_IN, - 7, 0, NULL, 0, max98088_pga_ina1_event, - SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), - - SND_SOC_DAPM_PGA_E("INA2 Input", M98088_REG_4C_PWR_EN_IN, - 7, 0, NULL, 0, max98088_pga_ina2_event, - SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), - - SND_SOC_DAPM_PGA_E("INB1 Input", M98088_REG_4C_PWR_EN_IN, - 6, 0, NULL, 0, max98088_pga_inb1_event, - SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), - - SND_SOC_DAPM_PGA_E("INB2 Input", M98088_REG_4C_PWR_EN_IN, - 6, 0, NULL, 0, max98088_pga_inb2_event, - SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), - - SND_SOC_DAPM_MICBIAS("MICBIAS", M98088_REG_4C_PWR_EN_IN, 3, 0), - - SND_SOC_DAPM_MUX("EX Limiter Mode", SND_SOC_NOPM, 0, 0, - &max98088_exmode_controls), - - SND_SOC_DAPM_OUTPUT("HPL"), - SND_SOC_DAPM_OUTPUT("HPR"), - SND_SOC_DAPM_OUTPUT("SPKL"), - SND_SOC_DAPM_OUTPUT("SPKR"), - SND_SOC_DAPM_OUTPUT("RECL"), - SND_SOC_DAPM_OUTPUT("RECR"), - - SND_SOC_DAPM_INPUT("MIC1"), - SND_SOC_DAPM_INPUT("MIC2"), - SND_SOC_DAPM_INPUT("INA1"), - SND_SOC_DAPM_INPUT("INA2"), - SND_SOC_DAPM_INPUT("INB1"), - SND_SOC_DAPM_INPUT("INB2"), -}; - -static const struct snd_soc_dapm_route audio_map[] = { - /* Left headphone output mixer */ - {"Left HP Mixer", "Left DAC1 Switch", "DACL1"}, - {"Left HP Mixer", "Left DAC2 Switch", "DACL2"}, - {"Left HP Mixer", "Right DAC1 Switch", "DACR1"}, - {"Left HP Mixer", "Right DAC2 Switch", "DACR2"}, - {"Left HP Mixer", "MIC1 Switch", "MIC1 Input"}, - {"Left HP Mixer", "MIC2 Switch", "MIC2 Input"}, - {"Left HP Mixer", "INA1 Switch", "INA1 Input"}, - {"Left HP Mixer", "INA2 Switch", "INA2 Input"}, - {"Left HP Mixer", "INB1 Switch", "INB1 Input"}, - {"Left HP Mixer", "INB2 Switch", "INB2 Input"}, - - /* Right headphone output mixer */ - {"Right HP Mixer", "Left DAC1 Switch", "DACL1"}, - {"Right HP Mixer", "Left DAC2 Switch", "DACL2" }, - {"Right HP Mixer", "Right DAC1 Switch", "DACR1"}, - {"Right HP Mixer", "Right DAC2 Switch", "DACR2"}, - {"Right HP Mixer", "MIC1 Switch", "MIC1 Input"}, - {"Right HP Mixer", "MIC2 Switch", "MIC2 Input"}, - {"Right HP Mixer", "INA1 Switch", "INA1 Input"}, - {"Right HP Mixer", "INA2 Switch", "INA2 Input"}, - {"Right HP Mixer", "INB1 Switch", "INB1 Input"}, - {"Right HP Mixer", "INB2 Switch", "INB2 Input"}, - - /* Left speaker output mixer */ - {"Left SPK Mixer", "Left DAC1 Switch", "DACL1"}, - {"Left SPK Mixer", "Left DAC2 Switch", "DACL2"}, - {"Left SPK Mixer", "Right DAC1 Switch", "DACR1"}, - {"Left SPK Mixer", "Right DAC2 Switch", "DACR2"}, - {"Left SPK Mixer", "MIC1 Switch", "MIC1 Input"}, - {"Left SPK Mixer", "MIC2 Switch", "MIC2 Input"}, - {"Left SPK Mixer", "INA1 Switch", "INA1 Input"}, - {"Left SPK Mixer", "INA2 Switch", "INA2 Input"}, - {"Left SPK Mixer", "INB1 Switch", "INB1 Input"}, - {"Left SPK Mixer", "INB2 Switch", "INB2 Input"}, - - /* Right speaker output mixer */ - {"Right SPK Mixer", "Left DAC1 Switch", "DACL1"}, - {"Right SPK Mixer", "Left DAC2 Switch", "DACL2"}, - {"Right SPK Mixer", "Right DAC1 Switch", "DACR1"}, - {"Right SPK Mixer", "Right DAC2 Switch", "DACR2"}, - {"Right SPK Mixer", "MIC1 Switch", "MIC1 Input"}, - {"Right SPK Mixer", "MIC2 Switch", "MIC2 Input"}, - {"Right SPK Mixer", "INA1 Switch", "INA1 Input"}, - {"Right SPK Mixer", "INA2 Switch", "INA2 Input"}, - {"Right SPK Mixer", "INB1 Switch", "INB1 Input"}, - {"Right SPK Mixer", "INB2 Switch", "INB2 Input"}, - - /* Earpiece/Receiver output mixer */ - {"Left REC Mixer", "Left DAC1 Switch", "DACL1"}, - {"Left REC Mixer", "Left DAC2 Switch", "DACL2"}, - {"Left REC Mixer", "Right DAC1 Switch", "DACR1"}, - {"Left REC Mixer", "Right DAC2 Switch", "DACR2"}, - {"Left REC Mixer", "MIC1 Switch", "MIC1 Input"}, - {"Left REC Mixer", "MIC2 Switch", "MIC2 Input"}, - {"Left REC Mixer", "INA1 Switch", "INA1 Input"}, - {"Left REC Mixer", "INA2 Switch", "INA2 Input"}, - {"Left REC Mixer", "INB1 Switch", "INB1 Input"}, - {"Left REC Mixer", "INB2 Switch", "INB2 Input"}, - - /* Earpiece/Receiver output mixer */ - {"Right REC Mixer", "Left DAC1 Switch", "DACL1"}, - {"Right REC Mixer", "Left DAC2 Switch", "DACL2"}, - {"Right REC Mixer", "Right DAC1 Switch", "DACR1"}, - {"Right REC Mixer", "Right DAC2 Switch", "DACR2"}, - {"Right REC Mixer", "MIC1 Switch", "MIC1 Input"}, - {"Right REC Mixer", "MIC2 Switch", "MIC2 Input"}, - {"Right REC Mixer", "INA1 Switch", "INA1 Input"}, - {"Right REC Mixer", "INA2 Switch", "INA2 Input"}, - {"Right REC Mixer", "INB1 Switch", "INB1 Input"}, - {"Right REC Mixer", "INB2 Switch", "INB2 Input"}, - - {"HP Left Out", NULL, "Left HP Mixer"}, - {"HP Right Out", NULL, "Right HP Mixer"}, - {"SPK Left Out", NULL, "Left SPK Mixer"}, - {"SPK Right Out", NULL, "Right SPK Mixer"}, - {"REC Left Out", NULL, "Left REC Mixer"}, - {"REC Right Out", NULL, "Right REC Mixer"}, - - {"HPL", NULL, "HP Left Out"}, - {"HPR", NULL, "HP Right Out"}, - {"SPKL", NULL, "SPK Left Out"}, - {"SPKR", NULL, "SPK Right Out"}, - {"RECL", NULL, "REC Left Out"}, - {"RECR", NULL, "REC Right Out"}, - - /* Left ADC input mixer */ - {"Left ADC Mixer", "MIC1 Switch", "MIC1 Input"}, - {"Left ADC Mixer", "MIC2 Switch", "MIC2 Input"}, - {"Left ADC Mixer", "INA1 Switch", "INA1 Input"}, - {"Left ADC Mixer", "INA2 Switch", "INA2 Input"}, - {"Left ADC Mixer", "INB1 Switch", "INB1 Input"}, - {"Left ADC Mixer", "INB2 Switch", "INB2 Input"}, - - /* Right ADC input mixer */ - {"Right ADC Mixer", "MIC1 Switch", "MIC1 Input"}, - {"Right ADC Mixer", "MIC2 Switch", "MIC2 Input"}, - {"Right ADC Mixer", "INA1 Switch", "INA1 Input"}, - {"Right ADC Mixer", "INA2 Switch", "INA2 Input"}, - {"Right ADC Mixer", "INB1 Switch", "INB1 Input"}, - {"Right ADC Mixer", "INB2 Switch", "INB2 Input"}, - - /* Inputs */ - {"ADCL", NULL, "Left ADC Mixer"}, - {"ADCR", NULL, "Right ADC Mixer"}, - {"INA1 Input", NULL, "INA1"}, - {"INA2 Input", NULL, "INA2"}, - {"INB1 Input", NULL, "INB1"}, - {"INB2 Input", NULL, "INB2"}, - {"MIC1 Input", NULL, "MIC1"}, - {"MIC2 Input", NULL, "MIC2"}, -}; - -static int max98088_add_widgets(struct snd_soc_codec *codec) -{ - snd_soc_dapm_new_controls(codec, max98088_dapm_widgets, - ARRAY_SIZE(max98088_dapm_widgets)); - - snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map)); - - snd_soc_add_controls(codec, max98088_snd_controls, - ARRAY_SIZE(max98088_snd_controls)); - - snd_soc_dapm_new_widgets(codec); - return 0; -} - -/* codec mclk clock divider coefficients */ -static const struct { - u32 rate; - u8 sr; -} rate_table[] = { - {8000, 0x10}, - {11025, 0x20}, - {16000, 0x30}, - {22050, 0x40}, - {24000, 0x50}, - {32000, 0x60}, - {44100, 0x70}, - {48000, 0x80}, - {88200, 0x90}, - {96000, 0xA0}, -}; - -static inline int rate_value(int rate, u8 *value) -{ - int i; - - for (i = 0; i < ARRAY_SIZE(rate_table); i++) { - if (rate_table[i].rate >= rate) { - *value = rate_table[i].sr; - return 0; - } - } - *value = rate_table[0].sr; - return -EINVAL; -} - -static int max98088_dai1_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *params, - struct snd_soc_dai *dai) -{ - struct snd_soc_codec *codec = dai->codec; - struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); - struct max98088_cdata *cdata; - unsigned long long ni; - unsigned int rate; - u8 regval; - - cdata = &max98088->dai[0]; - - rate = params_rate(params); - - switch (params_format(params)) { - case SNDRV_PCM_FORMAT_S16_LE: - snd_soc_update_bits(codec, M98088_REG_14_DAI1_FORMAT, - M98088_DAI_WS, 0); - break; - case SNDRV_PCM_FORMAT_S24_LE: - snd_soc_update_bits(codec, M98088_REG_14_DAI1_FORMAT, - M98088_DAI_WS, M98088_DAI_WS); - break; - default: - return -EINVAL; - } - - snd_soc_update_bits(codec, M98088_REG_51_PWR_SYS, M98088_SHDNRUN, 0); - - if (rate_value(rate, ®val)) - return -EINVAL; - - snd_soc_update_bits(codec, M98088_REG_11_DAI1_CLKMODE, - M98088_CLKMODE_MASK, regval); - cdata->rate = rate; - - /* Configure NI when operating as master */ - if (snd_soc_read(codec, M98088_REG_14_DAI1_FORMAT) - & M98088_DAI_MAS) { - if (max98088->sysclk == 0) { - dev_err(codec->dev, "Invalid system clock frequency\n"); - return -EINVAL; - } - ni = 65536ULL * (rate < 50000 ? 96ULL : 48ULL) - * (unsigned long long int)rate; - do_div(ni, (unsigned long long int)max98088->sysclk); - snd_soc_write(codec, M98088_REG_12_DAI1_CLKCFG_HI, - (ni >> 8) & 0x7F); - snd_soc_write(codec, M98088_REG_13_DAI1_CLKCFG_LO, - ni & 0xFF); - } - - /* Update sample rate mode */ - if (rate < 50000) - snd_soc_update_bits(codec, M98088_REG_18_DAI1_FILTERS, - M98088_DAI_DHF, 0); - else - snd_soc_update_bits(codec, M98088_REG_18_DAI1_FILTERS, - M98088_DAI_DHF, M98088_DAI_DHF); - - snd_soc_update_bits(codec, M98088_REG_51_PWR_SYS, M98088_SHDNRUN, - M98088_SHDNRUN); - - return 0; -} - -static int max98088_dai2_hw_params(struct snd_pcm_substream *substream, - struct snd_pcm_hw_params *params, - struct snd_soc_dai *dai) -{ - struct snd_soc_codec *codec = dai->codec; - struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); - struct max98088_cdata *cdata; - unsigned long long ni; - unsigned int rate; - u8 regval; - - cdata = &max98088->dai[1]; - - rate = params_rate(params); - - switch (params_format(params)) { - case SNDRV_PCM_FORMAT_S16_LE: - snd_soc_update_bits(codec, M98088_REG_1C_DAI2_FORMAT, - M98088_DAI_WS, 0); - break; - case SNDRV_PCM_FORMAT_S24_LE: - snd_soc_update_bits(codec, M98088_REG_1C_DAI2_FORMAT, - M98088_DAI_WS, M98088_DAI_WS); - break; - default: - return -EINVAL; - } - - snd_soc_update_bits(codec, M98088_REG_51_PWR_SYS, M98088_SHDNRUN, 0); - - if (rate_value(rate, ®val)) - return -EINVAL; - - snd_soc_update_bits(codec, M98088_REG_19_DAI2_CLKMODE, - M98088_CLKMODE_MASK, regval); - cdata->rate = rate; - - /* Configure NI when operating as master */ - if (snd_soc_read(codec, M98088_REG_1C_DAI2_FORMAT) - & M98088_DAI_MAS) { - if (max98088->sysclk == 0) { - dev_err(codec->dev, "Invalid system clock frequency\n"); - return -EINVAL; - } - ni = 65536ULL * (rate < 50000 ? 96ULL : 48ULL) - * (unsigned long long int)rate; - do_div(ni, (unsigned long long int)max98088->sysclk); - snd_soc_write(codec, M98088_REG_1A_DAI2_CLKCFG_HI, - (ni >> 8) & 0x7F); - snd_soc_write(codec, M98088_REG_1B_DAI2_CLKCFG_LO, - ni & 0xFF); - } - - /* Update sample rate mode */ - if (rate < 50000) - snd_soc_update_bits(codec, M98088_REG_20_DAI2_FILTERS, - M98088_DAI_DHF, 0); - else - snd_soc_update_bits(codec, M98088_REG_20_DAI2_FILTERS, - M98088_DAI_DHF, M98088_DAI_DHF); - - snd_soc_update_bits(codec, M98088_REG_51_PWR_SYS, M98088_SHDNRUN, - M98088_SHDNRUN); - - return 0; -} - -static int max98088_dai_set_sysclk(struct snd_soc_dai *dai, - int clk_id, unsigned int freq, int dir) -{ - struct snd_soc_codec *codec = dai->codec; - struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); - - /* Requested clock frequency is already setup */ - if (freq == max98088->sysclk) - return 0; - - max98088->sysclk = freq; /* remember current sysclk */ - - /* Setup clocks for slave mode, and using the PLL - * PSCLK = 0x01 (when master clk is 10MHz to 20MHz) - * 0x02 (when master clk is 20MHz to 30MHz).. - */ - if ((freq >= 10000000) && (freq < 20000000)) { - snd_soc_write(codec, M98088_REG_10_SYS_CLK, 0x10); - } else if ((freq >= 20000000) && (freq < 30000000)) { - snd_soc_write(codec, M98088_REG_10_SYS_CLK, 0x20); - } else { - dev_err(codec->dev, "Invalid master clock frequency\n"); - return -EINVAL; - } - - if (snd_soc_read(codec, M98088_REG_51_PWR_SYS) & M98088_SHDNRUN) { - snd_soc_update_bits(codec, M98088_REG_51_PWR_SYS, - M98088_SHDNRUN, 0); - snd_soc_update_bits(codec, M98088_REG_51_PWR_SYS, - M98088_SHDNRUN, M98088_SHDNRUN); - } - - dev_dbg(dai->dev, "Clock source is %d at %uHz\n", clk_id, freq); - - max98088->sysclk = freq; - return 0; -} - -static int max98088_dai1_set_fmt(struct snd_soc_dai *codec_dai, - unsigned int fmt) -{ - struct snd_soc_codec *codec = codec_dai->codec; - struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); - struct max98088_cdata *cdata; - u8 reg15val; - u8 reg14val = 0; - - cdata = &max98088->dai[0]; - - if (fmt != cdata->fmt) { - cdata->fmt = fmt; - - switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { - case SND_SOC_DAIFMT_CBS_CFS: - /* Slave mode PLL */ - snd_soc_write(codec, M98088_REG_12_DAI1_CLKCFG_HI, - 0x80); - snd_soc_write(codec, M98088_REG_13_DAI1_CLKCFG_LO, - 0x00); - break; - case SND_SOC_DAIFMT_CBM_CFM: - /* Set to master mode */ - reg14val |= M98088_DAI_MAS; - break; - case SND_SOC_DAIFMT_CBS_CFM: - case SND_SOC_DAIFMT_CBM_CFS: - default: - dev_err(codec->dev, "Clock mode unsupported"); - return -EINVAL; - } - - switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { - case SND_SOC_DAIFMT_I2S: - reg14val |= M98088_DAI_DLY; - break; - case SND_SOC_DAIFMT_LEFT_J: - break; - default: - return -EINVAL; - } - - switch (fmt & SND_SOC_DAIFMT_INV_MASK) { - case SND_SOC_DAIFMT_NB_NF: - break; - case SND_SOC_DAIFMT_NB_IF: - reg14val |= M98088_DAI_WCI; - break; - case SND_SOC_DAIFMT_IB_NF: - reg14val |= M98088_DAI_BCI; - break; - case SND_SOC_DAIFMT_IB_IF: - reg14val |= M98088_DAI_BCI|M98088_DAI_WCI; - break; - default: - return -EINVAL; - } - - snd_soc_update_bits(codec, M98088_REG_14_DAI1_FORMAT, - M98088_DAI_MAS | M98088_DAI_DLY | M98088_DAI_BCI | - M98088_DAI_WCI, reg14val); - - reg15val = M98088_DAI_BSEL64; - if (max98088->digmic) - reg15val |= M98088_DAI_OSR64; - snd_soc_write(codec, M98088_REG_15_DAI1_CLOCK, reg15val); - } - - return 0; -} - -static int max98088_dai2_set_fmt(struct snd_soc_dai *codec_dai, - unsigned int fmt) -{ - struct snd_soc_codec *codec = codec_dai->codec; - struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); - struct max98088_cdata *cdata; - u8 reg1Cval = 0; - - cdata = &max98088->dai[1]; - - if (fmt != cdata->fmt) { - cdata->fmt = fmt; - - switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { - case SND_SOC_DAIFMT_CBS_CFS: - /* Slave mode PLL */ - snd_soc_write(codec, M98088_REG_1A_DAI2_CLKCFG_HI, - 0x80); - snd_soc_write(codec, M98088_REG_1B_DAI2_CLKCFG_LO, - 0x00); - break; - case SND_SOC_DAIFMT_CBM_CFM: - /* Set to master mode */ - reg1Cval |= M98088_DAI_MAS; - break; - case SND_SOC_DAIFMT_CBS_CFM: - case SND_SOC_DAIFMT_CBM_CFS: - default: - dev_err(codec->dev, "Clock mode unsupported"); - return -EINVAL; - } - - switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { - case SND_SOC_DAIFMT_I2S: - reg1Cval |= M98088_DAI_DLY; - break; - case SND_SOC_DAIFMT_LEFT_J: - break; - default: - return -EINVAL; - } - - switch (fmt & SND_SOC_DAIFMT_INV_MASK) { - case SND_SOC_DAIFMT_NB_NF: - break; - case SND_SOC_DAIFMT_NB_IF: - reg1Cval |= M98088_DAI_WCI; - break; - case SND_SOC_DAIFMT_IB_NF: - reg1Cval |= M98088_DAI_BCI; - break; - case SND_SOC_DAIFMT_IB_IF: - reg1Cval |= M98088_DAI_BCI|M98088_DAI_WCI; - break; - default: - return -EINVAL; - } - - snd_soc_update_bits(codec, M98088_REG_1C_DAI2_FORMAT, - M98088_DAI_MAS | M98088_DAI_DLY | M98088_DAI_BCI | - M98088_DAI_WCI, reg1Cval); - - snd_soc_write(codec, M98088_REG_1D_DAI2_CLOCK, - M98088_DAI_BSEL64); - } - - return 0; -} - -static void max98088_sync_cache(struct snd_soc_codec *codec) -{ - struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); - int i; - - if (!codec->cache_sync) - return; - - codec->cache_only = 0; - - /* write back cached values if they're writeable and - * different from the hardware default. - */ - for (i = 1; i < ARRAY_SIZE(max98088->reg_cache); i++) { - if (!max98088_access[i].writable) - continue; - - if (max98088->reg_cache[i] == max98088_reg[i]) - continue; - - snd_soc_write(codec, i, max98088->reg_cache[i]); - } - - codec->cache_sync = 0; -} - -static int max98088_set_bias_level(struct snd_soc_codec *codec, - enum snd_soc_bias_level level) -{ - switch (level) { - case SND_SOC_BIAS_ON: - break; - - case SND_SOC_BIAS_PREPARE: - break; - - case SND_SOC_BIAS_STANDBY: - if (codec->bias_level == SND_SOC_BIAS_OFF) - max98088_sync_cache(codec); - - snd_soc_update_bits(codec, M98088_REG_4C_PWR_EN_IN, - M98088_MBEN, M98088_MBEN); - break; - - case SND_SOC_BIAS_OFF: - snd_soc_update_bits(codec, M98088_REG_4C_PWR_EN_IN, - M98088_MBEN, 0); - codec->cache_sync = 1; - break; - } - codec->bias_level = level; - return 0; -} - -#define MAX98088_RATES SNDRV_PCM_RATE_8000_96000 -#define MAX98088_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE) - -static struct snd_soc_dai_ops max98088_dai1_ops = { - .set_sysclk = max98088_dai_set_sysclk, - .set_fmt = max98088_dai1_set_fmt, - .hw_params = max98088_dai1_hw_params, -}; - -static struct snd_soc_dai_ops max98088_dai2_ops = { - .set_sysclk = max98088_dai_set_sysclk, - .set_fmt = max98088_dai2_set_fmt, - .hw_params = max98088_dai2_hw_params, -}; - -static struct snd_soc_dai_driver max98088_dai[] = { -{ - .name = "HiFi", - .playback = { - .stream_name = "HiFi Playback", - .channels_min = 1, - .channels_max = 2, - .rates = MAX98088_RATES, - .formats = MAX98088_FORMATS, - }, - .capture = { - .stream_name = "HiFi Capture", - .channels_min = 1, - .channels_max = 2, - .rates = MAX98088_RATES, - .formats = MAX98088_FORMATS, - }, - .ops = &max98088_dai1_ops, -}, -{ - .name = "Aux", - .playback = { - .stream_name = "Aux Playback", - .channels_min = 1, - .channels_max = 2, - .rates = MAX98088_RATES, - .formats = MAX98088_FORMATS, - }, - .ops = &max98088_dai2_ops, -} -}; - -static int max98088_get_channel(const char *name) -{ - if (strcmp(name, "EQ1 Mode") == 0) - return 0; - if (strcmp(name, "EQ2 Mode") == 0) - return 1; - return -EINVAL; -} - -static void max98088_setup_eq1(struct snd_soc_codec *codec) -{ - struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); - struct max98088_pdata *pdata = max98088->pdata; - struct max98088_eq_cfg *coef_set; - int best, best_val, save, i, sel, fs; - struct max98088_cdata *cdata; - - cdata = &max98088->dai[0]; - - if (!pdata || !max98088->eq_textcnt) - return; - - /* Find the selected configuration with nearest sample rate */ - fs = cdata->rate; - sel = cdata->eq_sel; - - best = 0; - best_val = INT_MAX; - for (i = 0; i < pdata->eq_cfgcnt; i++) { - if (strcmp(pdata->eq_cfg[i].name, max98088->eq_texts[sel]) == 0 && - abs(pdata->eq_cfg[i].rate - fs) < best_val) { - best = i; - best_val = abs(pdata->eq_cfg[i].rate - fs); - } - } - - dev_dbg(codec->dev, "Selected %s/%dHz for %dHz sample rate\n", - pdata->eq_cfg[best].name, - pdata->eq_cfg[best].rate, fs); - - /* Disable EQ while configuring, and save current on/off state */ - save = snd_soc_read(codec, M98088_REG_49_CFG_LEVEL); - snd_soc_update_bits(codec, M98088_REG_49_CFG_LEVEL, M98088_EQ1EN, 0); - - coef_set = &pdata->eq_cfg[sel]; - - m98088_eq_band(codec, 0, 0, coef_set->band1); - m98088_eq_band(codec, 0, 1, coef_set->band2); - m98088_eq_band(codec, 0, 2, coef_set->band3); - m98088_eq_band(codec, 0, 3, coef_set->band4); - m98088_eq_band(codec, 0, 4, coef_set->band5); - - /* Restore the original on/off state */ - snd_soc_update_bits(codec, M98088_REG_49_CFG_LEVEL, M98088_EQ1EN, save); -} - -static void max98088_setup_eq2(struct snd_soc_codec *codec) -{ - struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); - struct max98088_pdata *pdata = max98088->pdata; - struct max98088_eq_cfg *coef_set; - int best, best_val, save, i, sel, fs; - struct max98088_cdata *cdata; - - cdata = &max98088->dai[1]; - - if (!pdata || !max98088->eq_textcnt) - return; - - /* Find the selected configuration with nearest sample rate */ - fs = cdata->rate; - - sel = cdata->eq_sel; - best = 0; - best_val = INT_MAX; - for (i = 0; i < pdata->eq_cfgcnt; i++) { - if (strcmp(pdata->eq_cfg[i].name, max98088->eq_texts[sel]) == 0 && - abs(pdata->eq_cfg[i].rate - fs) < best_val) { - best = i; - best_val = abs(pdata->eq_cfg[i].rate - fs); - } - } - - dev_dbg(codec->dev, "Selected %s/%dHz for %dHz sample rate\n", - pdata->eq_cfg[best].name, - pdata->eq_cfg[best].rate, fs); - - /* Disable EQ while configuring, and save current on/off state */ - save = snd_soc_read(codec, M98088_REG_49_CFG_LEVEL); - snd_soc_update_bits(codec, M98088_REG_49_CFG_LEVEL, M98088_EQ2EN, 0); - - coef_set = &pdata->eq_cfg[sel]; - - m98088_eq_band(codec, 1, 0, coef_set->band1); - m98088_eq_band(codec, 1, 1, coef_set->band2); - m98088_eq_band(codec, 1, 2, coef_set->band3); - m98088_eq_band(codec, 1, 3, coef_set->band4); - m98088_eq_band(codec, 1, 4, coef_set->band5); - - /* Restore the original on/off state */ - snd_soc_update_bits(codec, M98088_REG_49_CFG_LEVEL, M98088_EQ2EN, - save); -} - -static int max98088_put_eq_enum(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); - struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); - struct max98088_pdata *pdata = max98088->pdata; - int channel = max98088_get_channel(kcontrol->id.name); - struct max98088_cdata *cdata; - int sel = ucontrol->value.integer.value[0]; - - cdata = &max98088->dai[channel]; - - if (sel >= pdata->eq_cfgcnt) - return -EINVAL; - - cdata->eq_sel = sel; - - switch (channel) { - case 0: - max98088_setup_eq1(codec); - break; - case 1: - max98088_setup_eq2(codec); - break; - } - - return 0; -} - -static int max98088_get_eq_enum(struct snd_kcontrol *kcontrol, - struct snd_ctl_elem_value *ucontrol) -{ - struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); - struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); - int channel = max98088_get_channel(kcontrol->id.name); - struct max98088_cdata *cdata; - - cdata = &max98088->dai[channel]; - ucontrol->value.enumerated.item[0] = cdata->eq_sel; - return 0; -} - -static void max98088_handle_eq_pdata(struct snd_soc_codec *codec) -{ - struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); - struct max98088_pdata *pdata = max98088->pdata; - struct max98088_eq_cfg *cfg; - unsigned int cfgcnt; - int i, j; - const char **t; - int ret; - - struct snd_kcontrol_new controls[] = { - SOC_ENUM_EXT("EQ1 Mode", - max98088->eq_enum, - max98088_get_eq_enum, - max98088_put_eq_enum), - SOC_ENUM_EXT("EQ2 Mode", - max98088->eq_enum, - max98088_get_eq_enum, - max98088_put_eq_enum), - }; - - cfg = pdata->eq_cfg; - cfgcnt = pdata->eq_cfgcnt; - - /* Setup an array of texts for the equalizer enum. - * This is based on Mark Brown's equalizer driver code. - */ - max98088->eq_textcnt = 0; - max98088->eq_texts = NULL; - for (i = 0; i < cfgcnt; i++) { - for (j = 0; j < max98088->eq_textcnt; j++) { - if (strcmp(cfg[i].name, max98088->eq_texts[j]) == 0) - break; - } - - if (j != max98088->eq_textcnt) - continue; - - /* Expand the array */ - t = krealloc(max98088->eq_texts, - sizeof(char *) * (max98088->eq_textcnt + 1), - GFP_KERNEL); - if (t == NULL) - continue; - - /* Store the new entry */ - t[max98088->eq_textcnt] = cfg[i].name; - max98088->eq_textcnt++; - max98088->eq_texts = t; - } - - /* Now point the soc_enum to .texts array items */ - max98088->eq_enum.texts = max98088->eq_texts; - max98088->eq_enum.max = max98088->eq_textcnt; - - ret = snd_soc_add_controls(codec, controls, ARRAY_SIZE(controls)); - if (ret != 0) - dev_err(codec->dev, "Failed to add EQ control: %d\n", ret); -} - -static void max98088_handle_pdata(struct snd_soc_codec *codec) -{ - struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); - struct max98088_pdata *pdata = max98088->pdata; - u8 regval = 0; - - if (!pdata) { - dev_dbg(codec->dev, "No platform data\n"); - return; - } - - /* Configure mic for analog/digital mic mode */ - if (pdata->digmic_left_mode) - regval |= M98088_DIGMIC_L; - - if (pdata->digmic_right_mode) - regval |= M98088_DIGMIC_R; - - max98088->digmic = (regval ? 1 : 0); - - snd_soc_write(codec, M98088_REG_48_CFG_MIC, regval); - - /* Configure receiver output */ - regval = ((pdata->receiver_mode) ? M98088_REC_LINEMODE : 0); - snd_soc_update_bits(codec, M98088_REG_2A_MIC_REC_CNTL, - M98088_REC_LINEMODE_MASK, regval); - - /* Configure equalizers */ - if (pdata->eq_cfgcnt) - max98088_handle_eq_pdata(codec); -} - -#ifdef CONFIG_PM -static int max98088_suspend(struct snd_soc_codec *codec, pm_message_t state) -{ - max98088_set_bias_level(codec, SND_SOC_BIAS_OFF); - - return 0; -} - -static int max98088_resume(struct snd_soc_codec *codec) -{ - max98088_set_bias_level(codec, SND_SOC_BIAS_STANDBY); - - return 0; -} -#else -#define max98088_suspend NULL -#define max98088_resume NULL -#endif - -static int max98088_probe(struct snd_soc_codec *codec) -{ - struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); - struct max98088_cdata *cdata; - int ret = 0; - - codec->cache_sync = 1; - memcpy(codec->reg_cache, max98088_reg, sizeof(max98088_reg)); - - ret = snd_soc_codec_set_cache_io(codec, 8, 8, SND_SOC_I2C); - if (ret != 0) { - dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret); - return ret; - } - - /* initalize private data */ - - max98088->sysclk = (unsigned)-1; - max98088->eq_textcnt = 0; - - cdata = &max98088->dai[0]; - cdata->rate = (unsigned)-1; - cdata->fmt = (unsigned)-1; - cdata->eq_sel = 0; - - cdata = &max98088->dai[1]; - cdata->rate = (unsigned)-1; - cdata->fmt = (unsigned)-1; - cdata->eq_sel = 0; - - max98088->ina_state = 0; - max98088->inb_state = 0; - max98088->ex_mode = 0; - max98088->digmic = 0; - max98088->mic1pre = 0; - max98088->mic2pre = 0; - - ret = snd_soc_read(codec, M98088_REG_FF_REV_ID); - if (ret < 0) { - dev_err(codec->dev, "Failed to read device revision: %d\n", - ret); - goto err_access; - } - dev_info(codec->dev, "revision %c\n", ret + 'A'); - - snd_soc_write(codec, M98088_REG_51_PWR_SYS, M98088_PWRSV); - - /* initialize registers cache to hardware default */ - max98088_set_bias_level(codec, SND_SOC_BIAS_STANDBY); - - snd_soc_write(codec, M98088_REG_0F_IRQ_ENABLE, 0x00); - - snd_soc_write(codec, M98088_REG_22_MIX_DAC, - M98088_DAI1L_TO_DACL|M98088_DAI2L_TO_DACL| - M98088_DAI1R_TO_DACR|M98088_DAI2R_TO_DACR); - - snd_soc_write(codec, M98088_REG_4E_BIAS_CNTL, 0xF0); - snd_soc_write(codec, M98088_REG_50_DAC_BIAS2, 0x0F); - - snd_soc_write(codec, M98088_REG_16_DAI1_IOCFG, - M98088_S1NORMAL|M98088_SDATA); - - snd_soc_write(codec, M98088_REG_1E_DAI2_IOCFG, - M98088_S2NORMAL|M98088_SDATA); - - max98088_handle_pdata(codec); - - max98088_add_widgets(codec); - -err_access: - return ret; -} - -static int max98088_remove(struct snd_soc_codec *codec) -{ - max98088_set_bias_level(codec, SND_SOC_BIAS_OFF); - - return 0; -} - -static struct snd_soc_codec_driver soc_codec_dev_max98088 = { - .probe = max98088_probe, - .remove = max98088_remove, - .suspend = max98088_suspend, - .resume = max98088_resume, - .set_bias_level = max98088_set_bias_level, - .reg_cache_size = ARRAY_SIZE(max98088_reg), - .reg_word_size = sizeof(u8), - .reg_cache_default = max98088_reg, - .volatile_register = max98088_volatile_register, -}; - -static int max98088_i2c_probe(struct i2c_client *i2c, - const struct i2c_device_id *id) -{ - struct max98088_priv *max98088; - int ret; - - max98088 = kzalloc(sizeof(struct max98088_priv), GFP_KERNEL); - if (max98088 == NULL) - return -ENOMEM; - - i2c_set_clientdata(i2c, max98088); - max98088->control_data = i2c; - max98088->pdata = i2c->dev.platform_data; - - ret = snd_soc_register_codec(&i2c->dev, - &soc_codec_dev_max98088, &max98088_dai[0], 2); - if (ret < 0) - kfree(max98088); - return ret; -} - -static int max98088_i2c_remove(struct i2c_client *client) -{ - snd_soc_unregister_codec(&client->dev); - kfree(i2c_get_clientdata(client)); - return 0; -} - -static const struct i2c_device_id max98088_i2c_id[] = { - { "max98088", 0 }, - { } -}; -MODULE_DEVICE_TABLE(i2c, max98088_i2c_id); - -static struct i2c_driver max98088_i2c_driver = { - .driver = { - .name = "max98088", - .owner = THIS_MODULE, - }, - .probe = max98088_i2c_probe, - .remove = __devexit_p(max98088_i2c_remove), - .id_table = max98088_i2c_id, -}; - -static int __init max98088_init(void) -{ - int ret; - - ret = i2c_add_driver(&max98088_i2c_driver); - if (ret) - pr_err("Failed to register max98088 I2C driver: %d\n", ret); - - return ret; -} -module_init(max98088_init); - -static void __exit max98088_exit(void) -{ - i2c_del_driver(&max98088_i2c_driver); -} -module_exit(max98088_exit); - -MODULE_DESCRIPTION("ALSA SoC MAX98088 driver"); -MODULE_AUTHOR("Peter Hsiang, Jesse Marroquin"); -MODULE_LICENSE("GPL"); diff --git a/sound/soc/codecs/max98088.h b/sound/soc/codecs/max98088.h deleted file mode 100644 index 56554c7..0000000 --- a/sound/soc/codecs/max98088.h +++ /dev/null @@ -1,193 +0,0 @@ -/* - * max98088.h -- MAX98088 ALSA SoC Audio driver - * - * Copyright 2010 Maxim Integrated Products - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License version 2 as - * published by the Free Software Foundation. - */ - -#ifndef _MAX98088_H -#define _MAX98088_H - -/* - * MAX98088 Registers Definition - */ -#define M98088_REG_00_IRQ_STATUS 0x00 -#define M98088_REG_01_MIC_STATUS 0x01 -#define M98088_REG_02_JACK_STAUS 0x02 -#define M98088_REG_03_BATTERY_VOLTAGE 0x03 -#define M98088_REG_0F_IRQ_ENABLE 0x0F -#define M98088_REG_10_SYS_CLK 0x10 -#define M98088_REG_11_DAI1_CLKMODE 0x11 -#define M98088_REG_12_DAI1_CLKCFG_HI 0x12 -#define M98088_REG_13_DAI1_CLKCFG_LO 0x13 -#define M98088_REG_14_DAI1_FORMAT 0x14 -#define M98088_REG_15_DAI1_CLOCK 0x15 -#define M98088_REG_16_DAI1_IOCFG 0x16 -#define M98088_REG_17_DAI1_TDM 0x17 -#define M98088_REG_18_DAI1_FILTERS 0x18 -#define M98088_REG_19_DAI2_CLKMODE 0x19 -#define M98088_REG_1A_DAI2_CLKCFG_HI 0x1A -#define M98088_REG_1B_DAI2_CLKCFG_LO 0x1B -#define M98088_REG_1C_DAI2_FORMAT 0x1C -#define M98088_REG_1D_DAI2_CLOCK 0x1D -#define M98088_REG_1E_DAI2_IOCFG 0x1E -#define M98088_REG_1F_DAI2_TDM 0x1F -#define M98088_REG_20_DAI2_FILTERS 0x20 -#define M98088_REG_21_SRC 0x21 -#define M98088_REG_22_MIX_DAC 0x22 -#define M98088_REG_23_MIX_ADC_LEFT 0x23 -#define M98088_REG_24_MIX_ADC_RIGHT 0x24 -#define M98088_REG_25_MIX_HP_LEFT 0x25 -#define M98088_REG_26_MIX_HP_RIGHT 0x26 -#define M98088_REG_27_MIX_HP_CNTL 0x27 -#define M98088_REG_28_MIX_REC_LEFT 0x28 -#define M98088_REG_29_MIX_REC_RIGHT 0x29 -#define M98088_REG_2A_MIC_REC_CNTL 0x2A -#define M98088_REG_2B_MIX_SPK_LEFT 0x2B -#define M98088_REG_2C_MIX_SPK_RIGHT 0x2C -#define M98088_REG_2D_MIX_SPK_CNTL 0x2D -#define M98088_REG_2E_LVL_SIDETONE 0x2E -#define M98088_REG_2F_LVL_DAI1_PLAY 0x2F -#define M98088_REG_30_LVL_DAI1_PLAY_EQ 0x30 -#define M98088_REG_31_LVL_DAI2_PLAY 0x31 -#define M98088_REG_32_LVL_DAI2_PLAY_EQ 0x32 -#define M98088_REG_33_LVL_ADC_L 0x33 -#define M98088_REG_34_LVL_ADC_R 0x34 -#define M98088_REG_35_LVL_MIC1 0x35 -#define M98088_REG_36_LVL_MIC2 0x36 -#define M98088_REG_37_LVL_INA 0x37 -#define M98088_REG_38_LVL_INB 0x38 -#define M98088_REG_39_LVL_HP_L 0x39 -#define M98088_REG_3A_LVL_HP_R 0x3A -#define M98088_REG_3B_LVL_REC_L 0x3B -#define M98088_REG_3C_LVL_REC_R 0x3C -#define M98088_REG_3D_LVL_SPK_L 0x3D -#define M98088_REG_3E_LVL_SPK_R 0x3E -#define M98088_REG_3F_MICAGC_CFG 0x3F -#define M98088_REG_40_MICAGC_THRESH 0x40 -#define M98088_REG_41_SPKDHP 0x41 -#define M98088_REG_42_SPKDHP_THRESH 0x42 -#define M98088_REG_43_SPKALC_COMP 0x43 -#define M98088_REG_44_PWRLMT_CFG 0x44 -#define M98088_REG_45_PWRLMT_TIME 0x45 -#define M98088_REG_46_THDLMT_CFG 0x46 -#define M98088_REG_47_CFG_AUDIO_IN 0x47 -#define M98088_REG_48_CFG_MIC 0x48 -#define M98088_REG_49_CFG_LEVEL 0x49 -#define M98088_REG_4A_CFG_BYPASS 0x4A -#define M98088_REG_4B_CFG_JACKDET 0x4B -#define M98088_REG_4C_PWR_EN_IN 0x4C -#define M98088_REG_4D_PWR_EN_OUT 0x4D -#define M98088_REG_4E_BIAS_CNTL 0x4E -#define M98088_REG_4F_DAC_BIAS1 0x4F -#define M98088_REG_50_DAC_BIAS2 0x50 -#define M98088_REG_51_PWR_SYS 0x51 -#define M98088_REG_52_DAI1_EQ_BASE 0x52 -#define M98088_REG_84_DAI2_EQ_BASE 0x84 -#define M98088_REG_B6_DAI1_BIQUAD_BASE 0xB6 -#define M98088_REG_C0_DAI2_BIQUAD_BASE 0xC0 -#define M98088_REG_FF_REV_ID 0xFF - -#define M98088_REG_CNT (0xFF+1) - -/* MAX98088 Registers Bit Fields */ - -/* M98088_REG_11_DAI1_CLKMODE, M98088_REG_19_DAI2_CLKMODE */ - #define M98088_CLKMODE_MASK 0xFF - -/* M98088_REG_14_DAI1_FORMAT, M98088_REG_1C_DAI2_FORMAT */ - #define M98088_DAI_MAS (1<<7) - #define M98088_DAI_WCI (1<<6) - #define M98088_DAI_BCI (1<<5) - #define M98088_DAI_DLY (1<<4) - #define M98088_DAI_TDM (1<<2) - #define M98088_DAI_FSW (1<<1) - #define M98088_DAI_WS (1<<0) - -/* M98088_REG_15_DAI1_CLOCK, M98088_REG_1D_DAI2_CLOCK */ - #define M98088_DAI_BSEL64 (1<<0) - #define M98088_DAI_OSR64 (1<<6) - -/* M98088_REG_16_DAI1_IOCFG, M98088_REG_1E_DAI2_IOCFG */ - #define M98088_S1NORMAL (1<<6) - #define M98088_S2NORMAL (2<<6) - #define M98088_SDATA (3<<0) - -/* M98088_REG_18_DAI1_FILTERS, M98088_REG_20_DAI2_FILTERS */ - #define M98088_DAI_DHF (1<<3) - -/* M98088_REG_22_MIX_DAC */ - #define M98088_DAI1L_TO_DACL (1<<7) - #define M98088_DAI1R_TO_DACL (1<<6) - #define M98088_DAI2L_TO_DACL (1<<5) - #define M98088_DAI2R_TO_DACL (1<<4) - #define M98088_DAI1L_TO_DACR (1<<3) - #define M98088_DAI1R_TO_DACR (1<<2) - #define M98088_DAI2L_TO_DACR (1<<1) - #define M98088_DAI2R_TO_DACR (1<<0) - -/* M98088_REG_2A_MIC_REC_CNTL */ - #define M98088_REC_LINEMODE (1<<7) - #define M98088_REC_LINEMODE_MASK (1<<7) - -/* M98088_REG_35_LVL_MIC1, M98088_REG_36_LVL_MIC2 */ - #define M98088_MICPRE_MASK (3<<5) - #define M98088_MICPRE_SHIFT 5 - -/* M98088_REG_3A_LVL_HP_R */ - #define M98088_HP_MUTE (1<<7) - -/* M98088_REG_3C_LVL_REC_R */ - #define M98088_REC_MUTE (1<<7) - -/* M98088_REG_3E_LVL_SPK_R */ - #define M98088_SP_MUTE (1<<7) - -/* M98088_REG_48_CFG_MIC */ - #define M98088_EXTMIC_MASK (3<<0) - #define M98088_DIGMIC_L (1<<5) - #define M98088_DIGMIC_R (1<<4) - -/* M98088_REG_49_CFG_LEVEL */ - #define M98088_VSEN (1<<6) - #define M98088_ZDEN (1<<5) - #define M98088_EQ2EN (1<<1) - #define M98088_EQ1EN (1<<0) - -/* M98088_REG_4C_PWR_EN_IN */ - #define M98088_INAEN (1<<7) - #define M98088_INBEN (1<<6) - #define M98088_MBEN (1<<3) - #define M98088_ADLEN (1<<1) - #define M98088_ADREN (1<<0) - -/* M98088_REG_4D_PWR_EN_OUT */ - #define M98088_HPLEN (1<<7) - #define M98088_HPREN (1<<6) - #define M98088_HPEN ((1<<7)|(1<<6)) - #define M98088_SPLEN (1<<5) - #define M98088_SPREN (1<<4) - #define M98088_RECEN (1<<3) - #define M98088_DALEN (1<<1) - #define M98088_DAREN (1<<0) - -/* M98088_REG_51_PWR_SYS */ - #define M98088_SHDNRUN (1<<7) - #define M98088_PERFMODE (1<<3) - #define M98088_HPPLYBACK (1<<2) - #define M98088_PWRSV8K (1<<1) - #define M98088_PWRSV (1<<0) - -/* Line inputs */ -#define LINE_INA 0 -#define LINE_INB 1 - -#define M98088_COEFS_PER_BAND 5 - -#define M98088_BYTE1(w) ((w >> 8) & 0xff) -#define M98088_BYTE0(w) (w & 0xff) - -#endif -- cgit v1.1 From 631dd1a885b6d7e9f6f51b4e5b311c2bb04c323c Mon Sep 17 00:00:00 2001 From: "Justin P. Mattock" Date: Mon, 18 Oct 2010 11:03:14 +0200 Subject: Update broken web addresses in the kernel. The patch below updates broken web addresses in the kernel Signed-off-by: Justin P. Mattock Cc: Maciej W. Rozycki Cc: Geert Uytterhoeven Cc: Finn Thain Cc: Randy Dunlap Cc: Matt Turner Cc: Dimitry Torokhov Cc: Mike Frysinger Acked-by: Ben Pfaff Acked-by: Hans J. Koch Reviewed-by: Finn Thain Signed-off-by: Jiri Kosina --- sound/oss/ac97_codec.c | 7 ++----- sound/pci/ens1370.c | 2 +- sound/pci/intel8x0.c | 2 +- 3 files changed, 4 insertions(+), 7 deletions(-) (limited to 'sound') diff --git a/sound/oss/ac97_codec.c b/sound/oss/ac97_codec.c index 456a1b4..854c303 100644 --- a/sound/oss/ac97_codec.c +++ b/sound/oss/ac97_codec.c @@ -21,11 +21,8 @@ * ************************************************************************** * - * The Intel Audio Codec '97 specification is available at the Intel - * audio homepage: http://developer.intel.com/ial/scalableplatforms/audio/ - * - * The specification itself is currently available at: - * ftp://download.intel.com/ial/scalableplatforms/ac97r22.pdf + * The Intel Audio Codec '97 specification is available at: + * http://download.intel.com/support/motherboards/desktop/sb/ac97_r23.pdf * ************************************************************************** * diff --git a/sound/pci/ens1370.c b/sound/pci/ens1370.c index c7fba53..537cfba 100644 --- a/sound/pci/ens1370.c +++ b/sound/pci/ens1370.c @@ -22,7 +22,7 @@ /* Power-Management-Code ( CONFIG_PM ) * for ens1371 only ( FIXME ) * derived from cs4281.c, atiixp.c and via82xx.c - * using http://www.alsa-project.org/~iwai/writing-an-alsa-driver/c1540.htm + * using http://www.alsa-project.org/~tiwai/writing-an-alsa-driver/ * by Kurt J. Bosch */ diff --git a/sound/pci/intel8x0.c b/sound/pci/intel8x0.c index 6433e65..a2999d6 100644 --- a/sound/pci/intel8x0.c +++ b/sound/pci/intel8x0.c @@ -716,7 +716,7 @@ static void snd_intel8x0_setup_periods(struct intel8x0 *chip, struct ichdev *ich * Intel 82443MX running a 100MHz processor system bus has a hardware bug, * which aborts PCI busmaster for audio transfer. A workaround is to set * the pages as non-cached. For details, see the errata in - * http://www.intel.com/design/chipsets/specupdt/245051.htm + * http://download.intel.com/design/chipsets/specupdt/24505108.pdf */ static void fill_nocache(void *buf, int size, int nocache) { -- cgit v1.1 From e74670b6fdc37b15ebee11825849d8983e52a74a Mon Sep 17 00:00:00 2001 From: Jaroslav Kysela Date: Mon, 18 Oct 2010 09:43:10 +0200 Subject: ALSA: snd-aloop: add cable#0 and cable#1 files to proc card tree Show some useful runtime information using procfs. Signed-off-by: Jaroslav Kysela --- sound/drivers/aloop.c | 84 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 84 insertions(+) (limited to 'sound') diff --git a/sound/drivers/aloop.c b/sound/drivers/aloop.c index 838ad863..66786ea 100644 --- a/sound/drivers/aloop.c +++ b/sound/drivers/aloop.c @@ -39,6 +39,7 @@ #include #include #include +#include #include MODULE_AUTHOR("Jaroslav Kysela "); @@ -184,6 +185,7 @@ static void loopback_timer_start(struct loopback_pcm *dpcm) static inline void loopback_timer_stop(struct loopback_pcm *dpcm) { del_timer(&dpcm->timer); + dpcm->timer.expires = 0; } #define CABLE_VALID_PLAYBACK (1 << SNDRV_PCM_STREAM_PLAYBACK) @@ -1011,6 +1013,86 @@ static int __devinit loopback_mixer_new(struct loopback *loopback, int notify) return 0; } +#ifdef CONFIG_PROC_FS + +static void print_dpcm_info(struct snd_info_buffer *buffer, + struct loopback_pcm *dpcm, + const char *id) +{ + snd_iprintf(buffer, " %s\n", id); + if (dpcm == NULL) { + snd_iprintf(buffer, " inactive\n"); + return; + } + snd_iprintf(buffer, " buffer_size:\t%u\n", dpcm->pcm_buffer_size); + snd_iprintf(buffer, " buffer_pos:\t\t%u\n", dpcm->buf_pos); + snd_iprintf(buffer, " silent_size:\t%u\n", dpcm->silent_size); + snd_iprintf(buffer, " period_size:\t%u\n", dpcm->pcm_period_size); + snd_iprintf(buffer, " bytes_per_sec:\t%u\n", dpcm->pcm_bps); + snd_iprintf(buffer, " sample_align:\t%u\n", dpcm->pcm_salign); + snd_iprintf(buffer, " rate_shift:\t\t%u\n", dpcm->pcm_rate_shift); + snd_iprintf(buffer, " update_pending:\t%u\n", + dpcm->period_update_pending); + snd_iprintf(buffer, " irq_pos:\t\t%u\n", dpcm->irq_pos); + snd_iprintf(buffer, " period_frac:\t%u\n", dpcm->period_size_frac); + snd_iprintf(buffer, " last_jiffies:\t%lu (%lu)\n", + dpcm->last_jiffies, jiffies); + snd_iprintf(buffer, " timer_expires:\t%lu\n", dpcm->timer.expires); +} + +static void print_substream_info(struct snd_info_buffer *buffer, + struct loopback *loopback, + int sub, + int num) +{ + struct loopback_cable *cable = loopback->cables[sub][num]; + + snd_iprintf(buffer, "Cable %i substream %i:\n", num, sub); + if (cable == NULL) { + snd_iprintf(buffer, " inactive\n"); + return; + } + snd_iprintf(buffer, " valid: %u\n", cable->valid); + snd_iprintf(buffer, " running: %u\n", cable->running); + print_dpcm_info(buffer, cable->streams[0], "Playback"); + print_dpcm_info(buffer, cable->streams[1], "Capture"); +} + +static void print_cable_info(struct snd_info_entry *entry, + struct snd_info_buffer *buffer) +{ + struct loopback *loopback = entry->private_data; + int sub, num; + + mutex_lock(&loopback->cable_lock); + num = entry->name[strlen(entry->name)-1]; + num = num == '0' ? 0 : 1; + for (sub = 0; sub < MAX_PCM_SUBSTREAMS; sub++) + print_substream_info(buffer, loopback, sub, num); + mutex_unlock(&loopback->cable_lock); +} + +static int __devinit loopback_proc_new(struct loopback *loopback, int cidx) +{ + char name[32]; + struct snd_info_entry *entry; + int err; + + snprintf(name, sizeof(name), "cable#%d", cidx); + err = snd_card_proc_new(loopback->card, name, &entry); + if (err < 0) + return err; + + snd_info_set_text_ops(entry, loopback, print_cable_info); + return 0; +} + +#else /* !CONFIG_PROC_FS */ + +#define loopback_proc_new(loopback, cidx) do { } while (0) + +#endif + static int __devinit loopback_probe(struct platform_device *devptr) { struct snd_card *card; @@ -1041,6 +1123,8 @@ static int __devinit loopback_probe(struct platform_device *devptr) err = loopback_mixer_new(loopback, pcm_notify[dev] ? 1 : 0); if (err < 0) goto __nodev; + loopback_proc_new(loopback, 0); + loopback_proc_new(loopback, 1); strcpy(card->driver, "Loopback"); strcpy(card->shortname, "Loopback"); sprintf(card->longname, "Loopback %i", dev + 1); -- cgit v1.1 From 02ffc5f3f91c265e110ddd1fdd7019a18426ebe5 Mon Sep 17 00:00:00 2001 From: Julia Lawall Date: Mon, 18 Oct 2010 16:11:13 +0200 Subject: ASoC: davinci-mcasp.c: Return error code in failure In this code, 0 is returned on failure, even though other failures return -ENOMEM or other similar values. A simplified version of the semantic match that finds this problem is as follows: (http://coccinelle.lip6.fr/) // @a@ identifier alloc; identifier ret; constant C; expression x; @@ x = alloc(...); if (x == NULL) { <+... \(ret = -C; \| return -C; \) ...+> } @@ identifier f, a.alloc; expression ret; expression x,e1,e2,e3; @@ ret = 0 ... when != ret = e1 *x = alloc(...) ... when != ret = e2 if (x == NULL) { ... when != ret = e3 return ret; } // Signed-off-by: Julia Lawall Acked-by: Liam Girdwood Signed-off-by: Mark Brown --- sound/soc/davinci/davinci-mcasp.c | 2 ++ 1 file changed, 2 insertions(+) (limited to 'sound') diff --git a/sound/soc/davinci/davinci-mcasp.c b/sound/soc/davinci/davinci-mcasp.c index c8e97dc..86918ee 100644 --- a/sound/soc/davinci/davinci-mcasp.c +++ b/sound/soc/davinci/davinci-mcasp.c @@ -898,6 +898,7 @@ static int davinci_mcasp_probe(struct platform_device *pdev) res = platform_get_resource(pdev, IORESOURCE_DMA, 0); if (!res) { dev_err(&pdev->dev, "no DMA resource\n"); + ret = -ENODEV; goto err_release_region; } @@ -912,6 +913,7 @@ static int davinci_mcasp_probe(struct platform_device *pdev) res = platform_get_resource(pdev, IORESOURCE_DMA, 1); if (!res) { dev_err(&pdev->dev, "no DMA resource\n"); + ret = -ENODEV; goto err_release_region; } -- cgit v1.1 From e86e1244a41352d1b78d32c10316fc4df2c86a8a Mon Sep 17 00:00:00 2001 From: Mark Brown Date: Mon, 18 Oct 2010 16:45:24 -0700 Subject: ASoC: Restore MAX98088 CODEC driver This reverts commit f6765502f8daae3d237a394889276c8987f3e299 and adds the missing include file. Signed-off-by: Peter Hsiang Signed-off-by: Mark Brown --- sound/soc/codecs/Kconfig | 4 + sound/soc/codecs/Makefile | 2 + sound/soc/codecs/max98088.c | 2097 +++++++++++++++++++++++++++++++++++++++++++ sound/soc/codecs/max98088.h | 193 ++++ 4 files changed, 2296 insertions(+) create mode 100644 sound/soc/codecs/max98088.c create mode 100644 sound/soc/codecs/max98088.h (limited to 'sound') diff --git a/sound/soc/codecs/Kconfig b/sound/soc/codecs/Kconfig index ff7b922..94a9d06 100644 --- a/sound/soc/codecs/Kconfig +++ b/sound/soc/codecs/Kconfig @@ -27,6 +27,7 @@ config SND_SOC_ALL_CODECS select SND_SOC_CS4270 if I2C select SND_SOC_DA7210 if I2C select SND_SOC_JZ4740 if SOC_JZ4740 + select SND_SOC_MAX98088 if I2C select SND_SOC_MAX9877 if I2C select SND_SOC_PCM3008 select SND_SOC_SPDIF @@ -158,6 +159,9 @@ config SND_SOC_L3 config SND_SOC_DA7210 tristate +config SND_SOC_MAX98088 + tristate + config SND_SOC_PCM3008 tristate diff --git a/sound/soc/codecs/Makefile b/sound/soc/codecs/Makefile index af4d4c4..f67a2d6 100644 --- a/sound/soc/codecs/Makefile +++ b/sound/soc/codecs/Makefile @@ -15,6 +15,7 @@ snd-soc-cs4270-objs := cs4270.o snd-soc-cx20442-objs := cx20442.o snd-soc-da7210-objs := da7210.o snd-soc-l3-objs := l3.o +snd-soc-max98088-objs := max98088.o snd-soc-pcm3008-objs := pcm3008.o snd-soc-spdif-objs := spdif_transciever.o snd-soc-ssm2602-objs := ssm2602.o @@ -89,6 +90,7 @@ obj-$(CONFIG_SND_SOC_CX20442) += snd-soc-cx20442.o obj-$(CONFIG_SND_SOC_DA7210) += snd-soc-da7210.o obj-$(CONFIG_SND_SOC_L3) += snd-soc-l3.o obj-$(CONFIG_SND_SOC_JZ4740_CODEC) += snd-soc-jz4740-codec.o +obj-$(CONFIG_SND_SOC_MAX98088) += snd-soc-max98088.o obj-$(CONFIG_SND_SOC_PCM3008) += snd-soc-pcm3008.o obj-$(CONFIG_SND_SOC_SPDIF) += snd-soc-spdif.o obj-$(CONFIG_SND_SOC_SSM2602) += snd-soc-ssm2602.o diff --git a/sound/soc/codecs/max98088.c b/sound/soc/codecs/max98088.c new file mode 100644 index 0000000..4186b27 --- /dev/null +++ b/sound/soc/codecs/max98088.c @@ -0,0 +1,2097 @@ +/* + * max98088.c -- MAX98088 ALSA SoC Audio driver + * + * Copyright 2010 Maxim Integrated Products + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "max98088.h" + +struct max98088_cdata { + unsigned int rate; + unsigned int fmt; + int eq_sel; +}; + +struct max98088_priv { + u8 reg_cache[M98088_REG_CNT]; + void *control_data; + struct max98088_pdata *pdata; + unsigned int sysclk; + struct max98088_cdata dai[2]; + int eq_textcnt; + const char **eq_texts; + struct soc_enum eq_enum; + u8 ina_state; + u8 inb_state; + unsigned int ex_mode; + unsigned int digmic; + unsigned int mic1pre; + unsigned int mic2pre; + unsigned int extmic_mode; +}; + +static const u8 max98088_reg[M98088_REG_CNT] = { + 0x00, /* 00 IRQ status */ + 0x00, /* 01 MIC status */ + 0x00, /* 02 jack status */ + 0x00, /* 03 battery voltage */ + 0x00, /* 04 */ + 0x00, /* 05 */ + 0x00, /* 06 */ + 0x00, /* 07 */ + 0x00, /* 08 */ + 0x00, /* 09 */ + 0x00, /* 0A */ + 0x00, /* 0B */ + 0x00, /* 0C */ + 0x00, /* 0D */ + 0x00, /* 0E */ + 0x00, /* 0F interrupt enable */ + + 0x00, /* 10 master clock */ + 0x00, /* 11 DAI1 clock mode */ + 0x00, /* 12 DAI1 clock control */ + 0x00, /* 13 DAI1 clock control */ + 0x00, /* 14 DAI1 format */ + 0x00, /* 15 DAI1 clock */ + 0x00, /* 16 DAI1 config */ + 0x00, /* 17 DAI1 TDM */ + 0x00, /* 18 DAI1 filters */ + 0x00, /* 19 DAI2 clock mode */ + 0x00, /* 1A DAI2 clock control */ + 0x00, /* 1B DAI2 clock control */ + 0x00, /* 1C DAI2 format */ + 0x00, /* 1D DAI2 clock */ + 0x00, /* 1E DAI2 config */ + 0x00, /* 1F DAI2 TDM */ + + 0x00, /* 20 DAI2 filters */ + 0x00, /* 21 data config */ + 0x00, /* 22 DAC mixer */ + 0x00, /* 23 left ADC mixer */ + 0x00, /* 24 right ADC mixer */ + 0x00, /* 25 left HP mixer */ + 0x00, /* 26 right HP mixer */ + 0x00, /* 27 HP control */ + 0x00, /* 28 left REC mixer */ + 0x00, /* 29 right REC mixer */ + 0x00, /* 2A REC control */ + 0x00, /* 2B left SPK mixer */ + 0x00, /* 2C right SPK mixer */ + 0x00, /* 2D SPK control */ + 0x00, /* 2E sidetone */ + 0x00, /* 2F DAI1 playback level */ + + 0x00, /* 30 DAI1 playback level */ + 0x00, /* 31 DAI2 playback level */ + 0x00, /* 32 DAI2 playbakc level */ + 0x00, /* 33 left ADC level */ + 0x00, /* 34 right ADC level */ + 0x00, /* 35 MIC1 level */ + 0x00, /* 36 MIC2 level */ + 0x00, /* 37 INA level */ + 0x00, /* 38 INB level */ + 0x00, /* 39 left HP volume */ + 0x00, /* 3A right HP volume */ + 0x00, /* 3B left REC volume */ + 0x00, /* 3C right REC volume */ + 0x00, /* 3D left SPK volume */ + 0x00, /* 3E right SPK volume */ + 0x00, /* 3F MIC config */ + + 0x00, /* 40 MIC threshold */ + 0x00, /* 41 excursion limiter filter */ + 0x00, /* 42 excursion limiter threshold */ + 0x00, /* 43 ALC */ + 0x00, /* 44 power limiter threshold */ + 0x00, /* 45 power limiter config */ + 0x00, /* 46 distortion limiter config */ + 0x00, /* 47 audio input */ + 0x00, /* 48 microphone */ + 0x00, /* 49 level control */ + 0x00, /* 4A bypass switches */ + 0x00, /* 4B jack detect */ + 0x00, /* 4C input enable */ + 0x00, /* 4D output enable */ + 0xF0, /* 4E bias control */ + 0x00, /* 4F DAC power */ + + 0x0F, /* 50 DAC power */ + 0x00, /* 51 system */ + 0x00, /* 52 DAI1 EQ1 */ + 0x00, /* 53 DAI1 EQ1 */ + 0x00, /* 54 DAI1 EQ1 */ + 0x00, /* 55 DAI1 EQ1 */ + 0x00, /* 56 DAI1 EQ1 */ + 0x00, /* 57 DAI1 EQ1 */ + 0x00, /* 58 DAI1 EQ1 */ + 0x00, /* 59 DAI1 EQ1 */ + 0x00, /* 5A DAI1 EQ1 */ + 0x00, /* 5B DAI1 EQ1 */ + 0x00, /* 5C DAI1 EQ2 */ + 0x00, /* 5D DAI1 EQ2 */ + 0x00, /* 5E DAI1 EQ2 */ + 0x00, /* 5F DAI1 EQ2 */ + + 0x00, /* 60 DAI1 EQ2 */ + 0x00, /* 61 DAI1 EQ2 */ + 0x00, /* 62 DAI1 EQ2 */ + 0x00, /* 63 DAI1 EQ2 */ + 0x00, /* 64 DAI1 EQ2 */ + 0x00, /* 65 DAI1 EQ2 */ + 0x00, /* 66 DAI1 EQ3 */ + 0x00, /* 67 DAI1 EQ3 */ + 0x00, /* 68 DAI1 EQ3 */ + 0x00, /* 69 DAI1 EQ3 */ + 0x00, /* 6A DAI1 EQ3 */ + 0x00, /* 6B DAI1 EQ3 */ + 0x00, /* 6C DAI1 EQ3 */ + 0x00, /* 6D DAI1 EQ3 */ + 0x00, /* 6E DAI1 EQ3 */ + 0x00, /* 6F DAI1 EQ3 */ + + 0x00, /* 70 DAI1 EQ4 */ + 0x00, /* 71 DAI1 EQ4 */ + 0x00, /* 72 DAI1 EQ4 */ + 0x00, /* 73 DAI1 EQ4 */ + 0x00, /* 74 DAI1 EQ4 */ + 0x00, /* 75 DAI1 EQ4 */ + 0x00, /* 76 DAI1 EQ4 */ + 0x00, /* 77 DAI1 EQ4 */ + 0x00, /* 78 DAI1 EQ4 */ + 0x00, /* 79 DAI1 EQ4 */ + 0x00, /* 7A DAI1 EQ5 */ + 0x00, /* 7B DAI1 EQ5 */ + 0x00, /* 7C DAI1 EQ5 */ + 0x00, /* 7D DAI1 EQ5 */ + 0x00, /* 7E DAI1 EQ5 */ + 0x00, /* 7F DAI1 EQ5 */ + + 0x00, /* 80 DAI1 EQ5 */ + 0x00, /* 81 DAI1 EQ5 */ + 0x00, /* 82 DAI1 EQ5 */ + 0x00, /* 83 DAI1 EQ5 */ + 0x00, /* 84 DAI2 EQ1 */ + 0x00, /* 85 DAI2 EQ1 */ + 0x00, /* 86 DAI2 EQ1 */ + 0x00, /* 87 DAI2 EQ1 */ + 0x00, /* 88 DAI2 EQ1 */ + 0x00, /* 89 DAI2 EQ1 */ + 0x00, /* 8A DAI2 EQ1 */ + 0x00, /* 8B DAI2 EQ1 */ + 0x00, /* 8C DAI2 EQ1 */ + 0x00, /* 8D DAI2 EQ1 */ + 0x00, /* 8E DAI2 EQ2 */ + 0x00, /* 8F DAI2 EQ2 */ + + 0x00, /* 90 DAI2 EQ2 */ + 0x00, /* 91 DAI2 EQ2 */ + 0x00, /* 92 DAI2 EQ2 */ + 0x00, /* 93 DAI2 EQ2 */ + 0x00, /* 94 DAI2 EQ2 */ + 0x00, /* 95 DAI2 EQ2 */ + 0x00, /* 96 DAI2 EQ2 */ + 0x00, /* 97 DAI2 EQ2 */ + 0x00, /* 98 DAI2 EQ3 */ + 0x00, /* 99 DAI2 EQ3 */ + 0x00, /* 9A DAI2 EQ3 */ + 0x00, /* 9B DAI2 EQ3 */ + 0x00, /* 9C DAI2 EQ3 */ + 0x00, /* 9D DAI2 EQ3 */ + 0x00, /* 9E DAI2 EQ3 */ + 0x00, /* 9F DAI2 EQ3 */ + + 0x00, /* A0 DAI2 EQ3 */ + 0x00, /* A1 DAI2 EQ3 */ + 0x00, /* A2 DAI2 EQ4 */ + 0x00, /* A3 DAI2 EQ4 */ + 0x00, /* A4 DAI2 EQ4 */ + 0x00, /* A5 DAI2 EQ4 */ + 0x00, /* A6 DAI2 EQ4 */ + 0x00, /* A7 DAI2 EQ4 */ + 0x00, /* A8 DAI2 EQ4 */ + 0x00, /* A9 DAI2 EQ4 */ + 0x00, /* AA DAI2 EQ4 */ + 0x00, /* AB DAI2 EQ4 */ + 0x00, /* AC DAI2 EQ5 */ + 0x00, /* AD DAI2 EQ5 */ + 0x00, /* AE DAI2 EQ5 */ + 0x00, /* AF DAI2 EQ5 */ + + 0x00, /* B0 DAI2 EQ5 */ + 0x00, /* B1 DAI2 EQ5 */ + 0x00, /* B2 DAI2 EQ5 */ + 0x00, /* B3 DAI2 EQ5 */ + 0x00, /* B4 DAI2 EQ5 */ + 0x00, /* B5 DAI2 EQ5 */ + 0x00, /* B6 DAI1 biquad */ + 0x00, /* B7 DAI1 biquad */ + 0x00, /* B8 DAI1 biquad */ + 0x00, /* B9 DAI1 biquad */ + 0x00, /* BA DAI1 biquad */ + 0x00, /* BB DAI1 biquad */ + 0x00, /* BC DAI1 biquad */ + 0x00, /* BD DAI1 biquad */ + 0x00, /* BE DAI1 biquad */ + 0x00, /* BF DAI1 biquad */ + + 0x00, /* C0 DAI2 biquad */ + 0x00, /* C1 DAI2 biquad */ + 0x00, /* C2 DAI2 biquad */ + 0x00, /* C3 DAI2 biquad */ + 0x00, /* C4 DAI2 biquad */ + 0x00, /* C5 DAI2 biquad */ + 0x00, /* C6 DAI2 biquad */ + 0x00, /* C7 DAI2 biquad */ + 0x00, /* C8 DAI2 biquad */ + 0x00, /* C9 DAI2 biquad */ + 0x00, /* CA */ + 0x00, /* CB */ + 0x00, /* CC */ + 0x00, /* CD */ + 0x00, /* CE */ + 0x00, /* CF */ + + 0x00, /* D0 */ + 0x00, /* D1 */ + 0x00, /* D2 */ + 0x00, /* D3 */ + 0x00, /* D4 */ + 0x00, /* D5 */ + 0x00, /* D6 */ + 0x00, /* D7 */ + 0x00, /* D8 */ + 0x00, /* D9 */ + 0x00, /* DA */ + 0x70, /* DB */ + 0x00, /* DC */ + 0x00, /* DD */ + 0x00, /* DE */ + 0x00, /* DF */ + + 0x00, /* E0 */ + 0x00, /* E1 */ + 0x00, /* E2 */ + 0x00, /* E3 */ + 0x00, /* E4 */ + 0x00, /* E5 */ + 0x00, /* E6 */ + 0x00, /* E7 */ + 0x00, /* E8 */ + 0x00, /* E9 */ + 0x00, /* EA */ + 0x00, /* EB */ + 0x00, /* EC */ + 0x00, /* ED */ + 0x00, /* EE */ + 0x00, /* EF */ + + 0x00, /* F0 */ + 0x00, /* F1 */ + 0x00, /* F2 */ + 0x00, /* F3 */ + 0x00, /* F4 */ + 0x00, /* F5 */ + 0x00, /* F6 */ + 0x00, /* F7 */ + 0x00, /* F8 */ + 0x00, /* F9 */ + 0x00, /* FA */ + 0x00, /* FB */ + 0x00, /* FC */ + 0x00, /* FD */ + 0x00, /* FE */ + 0x00, /* FF */ +}; + +static struct { + int readable; + int writable; + int vol; +} max98088_access[M98088_REG_CNT] = { + { 0xFF, 0xFF, 1 }, /* 00 IRQ status */ + { 0xFF, 0x00, 1 }, /* 01 MIC status */ + { 0xFF, 0x00, 1 }, /* 02 jack status */ + { 0x1F, 0x1F, 1 }, /* 03 battery voltage */ + { 0xFF, 0xFF, 0 }, /* 04 */ + { 0xFF, 0xFF, 0 }, /* 05 */ + { 0xFF, 0xFF, 0 }, /* 06 */ + { 0xFF, 0xFF, 0 }, /* 07 */ + { 0xFF, 0xFF, 0 }, /* 08 */ + { 0xFF, 0xFF, 0 }, /* 09 */ + { 0xFF, 0xFF, 0 }, /* 0A */ + { 0xFF, 0xFF, 0 }, /* 0B */ + { 0xFF, 0xFF, 0 }, /* 0C */ + { 0xFF, 0xFF, 0 }, /* 0D */ + { 0xFF, 0xFF, 0 }, /* 0E */ + { 0xFF, 0xFF, 0 }, /* 0F interrupt enable */ + + { 0xFF, 0xFF, 0 }, /* 10 master clock */ + { 0xFF, 0xFF, 0 }, /* 11 DAI1 clock mode */ + { 0xFF, 0xFF, 0 }, /* 12 DAI1 clock control */ + { 0xFF, 0xFF, 0 }, /* 13 DAI1 clock control */ + { 0xFF, 0xFF, 0 }, /* 14 DAI1 format */ + { 0xFF, 0xFF, 0 }, /* 15 DAI1 clock */ + { 0xFF, 0xFF, 0 }, /* 16 DAI1 config */ + { 0xFF, 0xFF, 0 }, /* 17 DAI1 TDM */ + { 0xFF, 0xFF, 0 }, /* 18 DAI1 filters */ + { 0xFF, 0xFF, 0 }, /* 19 DAI2 clock mode */ + { 0xFF, 0xFF, 0 }, /* 1A DAI2 clock control */ + { 0xFF, 0xFF, 0 }, /* 1B DAI2 clock control */ + { 0xFF, 0xFF, 0 }, /* 1C DAI2 format */ + { 0xFF, 0xFF, 0 }, /* 1D DAI2 clock */ + { 0xFF, 0xFF, 0 }, /* 1E DAI2 config */ + { 0xFF, 0xFF, 0 }, /* 1F DAI2 TDM */ + + { 0xFF, 0xFF, 0 }, /* 20 DAI2 filters */ + { 0xFF, 0xFF, 0 }, /* 21 data config */ + { 0xFF, 0xFF, 0 }, /* 22 DAC mixer */ + { 0xFF, 0xFF, 0 }, /* 23 left ADC mixer */ + { 0xFF, 0xFF, 0 }, /* 24 right ADC mixer */ + { 0xFF, 0xFF, 0 }, /* 25 left HP mixer */ + { 0xFF, 0xFF, 0 }, /* 26 right HP mixer */ + { 0xFF, 0xFF, 0 }, /* 27 HP control */ + { 0xFF, 0xFF, 0 }, /* 28 left REC mixer */ + { 0xFF, 0xFF, 0 }, /* 29 right REC mixer */ + { 0xFF, 0xFF, 0 }, /* 2A REC control */ + { 0xFF, 0xFF, 0 }, /* 2B left SPK mixer */ + { 0xFF, 0xFF, 0 }, /* 2C right SPK mixer */ + { 0xFF, 0xFF, 0 }, /* 2D SPK control */ + { 0xFF, 0xFF, 0 }, /* 2E sidetone */ + { 0xFF, 0xFF, 0 }, /* 2F DAI1 playback level */ + + { 0xFF, 0xFF, 0 }, /* 30 DAI1 playback level */ + { 0xFF, 0xFF, 0 }, /* 31 DAI2 playback level */ + { 0xFF, 0xFF, 0 }, /* 32 DAI2 playbakc level */ + { 0xFF, 0xFF, 0 }, /* 33 left ADC level */ + { 0xFF, 0xFF, 0 }, /* 34 right ADC level */ + { 0xFF, 0xFF, 0 }, /* 35 MIC1 level */ + { 0xFF, 0xFF, 0 }, /* 36 MIC2 level */ + { 0xFF, 0xFF, 0 }, /* 37 INA level */ + { 0xFF, 0xFF, 0 }, /* 38 INB level */ + { 0xFF, 0xFF, 0 }, /* 39 left HP volume */ + { 0xFF, 0xFF, 0 }, /* 3A right HP volume */ + { 0xFF, 0xFF, 0 }, /* 3B left REC volume */ + { 0xFF, 0xFF, 0 }, /* 3C right REC volume */ + { 0xFF, 0xFF, 0 }, /* 3D left SPK volume */ + { 0xFF, 0xFF, 0 }, /* 3E right SPK volume */ + { 0xFF, 0xFF, 0 }, /* 3F MIC config */ + + { 0xFF, 0xFF, 0 }, /* 40 MIC threshold */ + { 0xFF, 0xFF, 0 }, /* 41 excursion limiter filter */ + { 0xFF, 0xFF, 0 }, /* 42 excursion limiter threshold */ + { 0xFF, 0xFF, 0 }, /* 43 ALC */ + { 0xFF, 0xFF, 0 }, /* 44 power limiter threshold */ + { 0xFF, 0xFF, 0 }, /* 45 power limiter config */ + { 0xFF, 0xFF, 0 }, /* 46 distortion limiter config */ + { 0xFF, 0xFF, 0 }, /* 47 audio input */ + { 0xFF, 0xFF, 0 }, /* 48 microphone */ + { 0xFF, 0xFF, 0 }, /* 49 level control */ + { 0xFF, 0xFF, 0 }, /* 4A bypass switches */ + { 0xFF, 0xFF, 0 }, /* 4B jack detect */ + { 0xFF, 0xFF, 0 }, /* 4C input enable */ + { 0xFF, 0xFF, 0 }, /* 4D output enable */ + { 0xFF, 0xFF, 0 }, /* 4E bias control */ + { 0xFF, 0xFF, 0 }, /* 4F DAC power */ + + { 0xFF, 0xFF, 0 }, /* 50 DAC power */ + { 0xFF, 0xFF, 0 }, /* 51 system */ + { 0xFF, 0xFF, 0 }, /* 52 DAI1 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 53 DAI1 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 54 DAI1 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 55 DAI1 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 56 DAI1 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 57 DAI1 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 58 DAI1 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 59 DAI1 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 5A DAI1 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 5B DAI1 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 5C DAI1 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 5D DAI1 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 5E DAI1 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 5F DAI1 EQ2 */ + + { 0xFF, 0xFF, 0 }, /* 60 DAI1 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 61 DAI1 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 62 DAI1 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 63 DAI1 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 64 DAI1 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 65 DAI1 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 66 DAI1 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 67 DAI1 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 68 DAI1 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 69 DAI1 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 6A DAI1 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 6B DAI1 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 6C DAI1 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 6D DAI1 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 6E DAI1 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 6F DAI1 EQ3 */ + + { 0xFF, 0xFF, 0 }, /* 70 DAI1 EQ4 */ + { 0xFF, 0xFF, 0 }, /* 71 DAI1 EQ4 */ + { 0xFF, 0xFF, 0 }, /* 72 DAI1 EQ4 */ + { 0xFF, 0xFF, 0 }, /* 73 DAI1 EQ4 */ + { 0xFF, 0xFF, 0 }, /* 74 DAI1 EQ4 */ + { 0xFF, 0xFF, 0 }, /* 75 DAI1 EQ4 */ + { 0xFF, 0xFF, 0 }, /* 76 DAI1 EQ4 */ + { 0xFF, 0xFF, 0 }, /* 77 DAI1 EQ4 */ + { 0xFF, 0xFF, 0 }, /* 78 DAI1 EQ4 */ + { 0xFF, 0xFF, 0 }, /* 79 DAI1 EQ4 */ + { 0xFF, 0xFF, 0 }, /* 7A DAI1 EQ5 */ + { 0xFF, 0xFF, 0 }, /* 7B DAI1 EQ5 */ + { 0xFF, 0xFF, 0 }, /* 7C DAI1 EQ5 */ + { 0xFF, 0xFF, 0 }, /* 7D DAI1 EQ5 */ + { 0xFF, 0xFF, 0 }, /* 7E DAI1 EQ5 */ + { 0xFF, 0xFF, 0 }, /* 7F DAI1 EQ5 */ + + { 0xFF, 0xFF, 0 }, /* 80 DAI1 EQ5 */ + { 0xFF, 0xFF, 0 }, /* 81 DAI1 EQ5 */ + { 0xFF, 0xFF, 0 }, /* 82 DAI1 EQ5 */ + { 0xFF, 0xFF, 0 }, /* 83 DAI1 EQ5 */ + { 0xFF, 0xFF, 0 }, /* 84 DAI2 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 85 DAI2 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 86 DAI2 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 87 DAI2 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 88 DAI2 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 89 DAI2 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 8A DAI2 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 8B DAI2 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 8C DAI2 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 8D DAI2 EQ1 */ + { 0xFF, 0xFF, 0 }, /* 8E DAI2 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 8F DAI2 EQ2 */ + + { 0xFF, 0xFF, 0 }, /* 90 DAI2 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 91 DAI2 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 92 DAI2 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 93 DAI2 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 94 DAI2 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 95 DAI2 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 96 DAI2 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 97 DAI2 EQ2 */ + { 0xFF, 0xFF, 0 }, /* 98 DAI2 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 99 DAI2 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 9A DAI2 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 9B DAI2 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 9C DAI2 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 9D DAI2 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 9E DAI2 EQ3 */ + { 0xFF, 0xFF, 0 }, /* 9F DAI2 EQ3 */ + + { 0xFF, 0xFF, 0 }, /* A0 DAI2 EQ3 */ + { 0xFF, 0xFF, 0 }, /* A1 DAI2 EQ3 */ + { 0xFF, 0xFF, 0 }, /* A2 DAI2 EQ4 */ + { 0xFF, 0xFF, 0 }, /* A3 DAI2 EQ4 */ + { 0xFF, 0xFF, 0 }, /* A4 DAI2 EQ4 */ + { 0xFF, 0xFF, 0 }, /* A5 DAI2 EQ4 */ + { 0xFF, 0xFF, 0 }, /* A6 DAI2 EQ4 */ + { 0xFF, 0xFF, 0 }, /* A7 DAI2 EQ4 */ + { 0xFF, 0xFF, 0 }, /* A8 DAI2 EQ4 */ + { 0xFF, 0xFF, 0 }, /* A9 DAI2 EQ4 */ + { 0xFF, 0xFF, 0 }, /* AA DAI2 EQ4 */ + { 0xFF, 0xFF, 0 }, /* AB DAI2 EQ4 */ + { 0xFF, 0xFF, 0 }, /* AC DAI2 EQ5 */ + { 0xFF, 0xFF, 0 }, /* AD DAI2 EQ5 */ + { 0xFF, 0xFF, 0 }, /* AE DAI2 EQ5 */ + { 0xFF, 0xFF, 0 }, /* AF DAI2 EQ5 */ + + { 0xFF, 0xFF, 0 }, /* B0 DAI2 EQ5 */ + { 0xFF, 0xFF, 0 }, /* B1 DAI2 EQ5 */ + { 0xFF, 0xFF, 0 }, /* B2 DAI2 EQ5 */ + { 0xFF, 0xFF, 0 }, /* B3 DAI2 EQ5 */ + { 0xFF, 0xFF, 0 }, /* B4 DAI2 EQ5 */ + { 0xFF, 0xFF, 0 }, /* B5 DAI2 EQ5 */ + { 0xFF, 0xFF, 0 }, /* B6 DAI1 biquad */ + { 0xFF, 0xFF, 0 }, /* B7 DAI1 biquad */ + { 0xFF, 0xFF, 0 }, /* B8 DAI1 biquad */ + { 0xFF, 0xFF, 0 }, /* B9 DAI1 biquad */ + { 0xFF, 0xFF, 0 }, /* BA DAI1 biquad */ + { 0xFF, 0xFF, 0 }, /* BB DAI1 biquad */ + { 0xFF, 0xFF, 0 }, /* BC DAI1 biquad */ + { 0xFF, 0xFF, 0 }, /* BD DAI1 biquad */ + { 0xFF, 0xFF, 0 }, /* BE DAI1 biquad */ + { 0xFF, 0xFF, 0 }, /* BF DAI1 biquad */ + + { 0xFF, 0xFF, 0 }, /* C0 DAI2 biquad */ + { 0xFF, 0xFF, 0 }, /* C1 DAI2 biquad */ + { 0xFF, 0xFF, 0 }, /* C2 DAI2 biquad */ + { 0xFF, 0xFF, 0 }, /* C3 DAI2 biquad */ + { 0xFF, 0xFF, 0 }, /* C4 DAI2 biquad */ + { 0xFF, 0xFF, 0 }, /* C5 DAI2 biquad */ + { 0xFF, 0xFF, 0 }, /* C6 DAI2 biquad */ + { 0xFF, 0xFF, 0 }, /* C7 DAI2 biquad */ + { 0xFF, 0xFF, 0 }, /* C8 DAI2 biquad */ + { 0xFF, 0xFF, 0 }, /* C9 DAI2 biquad */ + { 0x00, 0x00, 0 }, /* CA */ + { 0x00, 0x00, 0 }, /* CB */ + { 0x00, 0x00, 0 }, /* CC */ + { 0x00, 0x00, 0 }, /* CD */ + { 0x00, 0x00, 0 }, /* CE */ + { 0x00, 0x00, 0 }, /* CF */ + + { 0x00, 0x00, 0 }, /* D0 */ + { 0x00, 0x00, 0 }, /* D1 */ + { 0x00, 0x00, 0 }, /* D2 */ + { 0x00, 0x00, 0 }, /* D3 */ + { 0x00, 0x00, 0 }, /* D4 */ + { 0x00, 0x00, 0 }, /* D5 */ + { 0x00, 0x00, 0 }, /* D6 */ + { 0x00, 0x00, 0 }, /* D7 */ + { 0x00, 0x00, 0 }, /* D8 */ + { 0x00, 0x00, 0 }, /* D9 */ + { 0x00, 0x00, 0 }, /* DA */ + { 0x00, 0x00, 0 }, /* DB */ + { 0x00, 0x00, 0 }, /* DC */ + { 0x00, 0x00, 0 }, /* DD */ + { 0x00, 0x00, 0 }, /* DE */ + { 0x00, 0x00, 0 }, /* DF */ + + { 0x00, 0x00, 0 }, /* E0 */ + { 0x00, 0x00, 0 }, /* E1 */ + { 0x00, 0x00, 0 }, /* E2 */ + { 0x00, 0x00, 0 }, /* E3 */ + { 0x00, 0x00, 0 }, /* E4 */ + { 0x00, 0x00, 0 }, /* E5 */ + { 0x00, 0x00, 0 }, /* E6 */ + { 0x00, 0x00, 0 }, /* E7 */ + { 0x00, 0x00, 0 }, /* E8 */ + { 0x00, 0x00, 0 }, /* E9 */ + { 0x00, 0x00, 0 }, /* EA */ + { 0x00, 0x00, 0 }, /* EB */ + { 0x00, 0x00, 0 }, /* EC */ + { 0x00, 0x00, 0 }, /* ED */ + { 0x00, 0x00, 0 }, /* EE */ + { 0x00, 0x00, 0 }, /* EF */ + + { 0x00, 0x00, 0 }, /* F0 */ + { 0x00, 0x00, 0 }, /* F1 */ + { 0x00, 0x00, 0 }, /* F2 */ + { 0x00, 0x00, 0 }, /* F3 */ + { 0x00, 0x00, 0 }, /* F4 */ + { 0x00, 0x00, 0 }, /* F5 */ + { 0x00, 0x00, 0 }, /* F6 */ + { 0x00, 0x00, 0 }, /* F7 */ + { 0x00, 0x00, 0 }, /* F8 */ + { 0x00, 0x00, 0 }, /* F9 */ + { 0x00, 0x00, 0 }, /* FA */ + { 0x00, 0x00, 0 }, /* FB */ + { 0x00, 0x00, 0 }, /* FC */ + { 0x00, 0x00, 0 }, /* FD */ + { 0x00, 0x00, 0 }, /* FE */ + { 0xFF, 0x00, 1 }, /* FF */ +}; + +static int max98088_volatile_register(unsigned int reg) +{ + return max98088_access[reg].vol; +} + + +/* + * Load equalizer DSP coefficient configurations registers + */ +void m98088_eq_band(struct snd_soc_codec *codec, unsigned int dai, + unsigned int band, u16 *coefs) +{ + unsigned int eq_reg; + unsigned int i; + + BUG_ON(band > 4); + BUG_ON(dai > 1); + + /* Load the base register address */ + eq_reg = dai ? M98088_REG_84_DAI2_EQ_BASE : M98088_REG_52_DAI1_EQ_BASE; + + /* Add the band address offset, note adjustment for word address */ + eq_reg += band * (M98088_COEFS_PER_BAND << 1); + + /* Step through the registers and coefs */ + for (i = 0; i < M98088_COEFS_PER_BAND; i++) { + snd_soc_write(codec, eq_reg++, M98088_BYTE1(coefs[i])); + snd_soc_write(codec, eq_reg++, M98088_BYTE0(coefs[i])); + } +} + +/* + * Excursion limiter modes + */ +static const char *max98088_exmode_texts[] = { + "Off", "100Hz", "400Hz", "600Hz", "800Hz", "1000Hz", "200-400Hz", + "400-600Hz", "400-800Hz", +}; + +static const unsigned int max98088_exmode_values[] = { + 0x00, 0x43, 0x10, 0x20, 0x30, 0x40, 0x11, 0x22, 0x32 +}; + +static const struct soc_enum max98088_exmode_enum = + SOC_VALUE_ENUM_SINGLE(M98088_REG_41_SPKDHP, 0, 127, + ARRAY_SIZE(max98088_exmode_texts), + max98088_exmode_texts, + max98088_exmode_values); +static const struct snd_kcontrol_new max98088_exmode_controls = + SOC_DAPM_VALUE_ENUM("Route", max98088_exmode_enum); + +static const char *max98088_ex_thresh[] = { /* volts PP */ + "0.6", "1.2", "1.8", "2.4", "3.0", "3.6", "4.2", "4.8"}; +static const struct soc_enum max98088_ex_thresh_enum[] = { + SOC_ENUM_SINGLE(M98088_REG_42_SPKDHP_THRESH, 0, 8, + max98088_ex_thresh), +}; + +static const char *max98088_fltr_mode[] = {"Voice", "Music" }; +static const struct soc_enum max98088_filter_mode_enum[] = { + SOC_ENUM_SINGLE(M98088_REG_18_DAI1_FILTERS, 7, 2, max98088_fltr_mode), +}; + +static const char *max98088_extmic_text[] = { "None", "MIC1", "MIC2" }; + +static const struct soc_enum max98088_extmic_enum = + SOC_ENUM_SINGLE(M98088_REG_48_CFG_MIC, 0, 3, max98088_extmic_text); + +static const struct snd_kcontrol_new max98088_extmic_mux = + SOC_DAPM_ENUM("External MIC Mux", max98088_extmic_enum); + +static const char *max98088_dai1_fltr[] = { + "Off", "fc=258/fs=16k", "fc=500/fs=16k", + "fc=258/fs=8k", "fc=500/fs=8k", "fc=200"}; +static const struct soc_enum max98088_dai1_dac_filter_enum[] = { + SOC_ENUM_SINGLE(M98088_REG_18_DAI1_FILTERS, 0, 6, max98088_dai1_fltr), +}; +static const struct soc_enum max98088_dai1_adc_filter_enum[] = { + SOC_ENUM_SINGLE(M98088_REG_18_DAI1_FILTERS, 4, 6, max98088_dai1_fltr), +}; + +static int max98088_mic1pre_set(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + unsigned int sel = ucontrol->value.integer.value[0]; + + max98088->mic1pre = sel; + snd_soc_update_bits(codec, M98088_REG_35_LVL_MIC1, M98088_MICPRE_MASK, + (1+sel)<value.integer.value[0] = max98088->mic1pre; + return 0; +} + +static int max98088_mic2pre_set(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + unsigned int sel = ucontrol->value.integer.value[0]; + + max98088->mic2pre = sel; + snd_soc_update_bits(codec, M98088_REG_36_LVL_MIC2, M98088_MICPRE_MASK, + (1+sel)<value.integer.value[0] = max98088->mic2pre; + return 0; +} + +static const unsigned int max98088_micboost_tlv[] = { + TLV_DB_RANGE_HEAD(2), + 0, 1, TLV_DB_SCALE_ITEM(0, 2000, 0), + 2, 2, TLV_DB_SCALE_ITEM(3000, 0, 0), +}; + +static const struct snd_kcontrol_new max98088_snd_controls[] = { + + SOC_DOUBLE_R("Headphone Volume", M98088_REG_39_LVL_HP_L, + M98088_REG_3A_LVL_HP_R, 0, 31, 0), + SOC_DOUBLE_R("Speaker Volume", M98088_REG_3D_LVL_SPK_L, + M98088_REG_3E_LVL_SPK_R, 0, 31, 0), + SOC_DOUBLE_R("Receiver Volume", M98088_REG_3B_LVL_REC_L, + M98088_REG_3C_LVL_REC_R, 0, 31, 0), + + SOC_DOUBLE_R("Headphone Switch", M98088_REG_39_LVL_HP_L, + M98088_REG_3A_LVL_HP_R, 7, 1, 1), + SOC_DOUBLE_R("Speaker Switch", M98088_REG_3D_LVL_SPK_L, + M98088_REG_3E_LVL_SPK_R, 7, 1, 1), + SOC_DOUBLE_R("Receiver Switch", M98088_REG_3B_LVL_REC_L, + M98088_REG_3C_LVL_REC_R, 7, 1, 1), + + SOC_SINGLE("MIC1 Volume", M98088_REG_35_LVL_MIC1, 0, 31, 1), + SOC_SINGLE("MIC2 Volume", M98088_REG_36_LVL_MIC2, 0, 31, 1), + + SOC_SINGLE_EXT_TLV("MIC1 Boost Volume", + M98088_REG_35_LVL_MIC1, 5, 2, 0, + max98088_mic1pre_get, max98088_mic1pre_set, + max98088_micboost_tlv), + SOC_SINGLE_EXT_TLV("MIC2 Boost Volume", + M98088_REG_36_LVL_MIC2, 5, 2, 0, + max98088_mic2pre_get, max98088_mic2pre_set, + max98088_micboost_tlv), + + SOC_SINGLE("INA Volume", M98088_REG_37_LVL_INA, 0, 7, 1), + SOC_SINGLE("INB Volume", M98088_REG_38_LVL_INB, 0, 7, 1), + + SOC_SINGLE("ADCL Volume", M98088_REG_33_LVL_ADC_L, 0, 15, 0), + SOC_SINGLE("ADCR Volume", M98088_REG_34_LVL_ADC_R, 0, 15, 0), + + SOC_SINGLE("ADCL Boost Volume", M98088_REG_33_LVL_ADC_L, 4, 3, 0), + SOC_SINGLE("ADCR Boost Volume", M98088_REG_34_LVL_ADC_R, 4, 3, 0), + + SOC_SINGLE("EQ1 Switch", M98088_REG_49_CFG_LEVEL, 0, 1, 0), + SOC_SINGLE("EQ2 Switch", M98088_REG_49_CFG_LEVEL, 1, 1, 0), + + SOC_ENUM("EX Limiter Threshold", max98088_ex_thresh_enum), + + SOC_ENUM("DAI1 Filter Mode", max98088_filter_mode_enum), + SOC_ENUM("DAI1 DAC Filter", max98088_dai1_dac_filter_enum), + SOC_ENUM("DAI1 ADC Filter", max98088_dai1_adc_filter_enum), + SOC_SINGLE("DAI2 DC Block Switch", M98088_REG_20_DAI2_FILTERS, + 0, 1, 0), + + SOC_SINGLE("ALC Switch", M98088_REG_43_SPKALC_COMP, 7, 1, 0), + SOC_SINGLE("ALC Threshold", M98088_REG_43_SPKALC_COMP, 0, 7, 0), + SOC_SINGLE("ALC Multiband", M98088_REG_43_SPKALC_COMP, 3, 1, 0), + SOC_SINGLE("ALC Release Time", M98088_REG_43_SPKALC_COMP, 4, 7, 0), + + SOC_SINGLE("PWR Limiter Threshold", M98088_REG_44_PWRLMT_CFG, + 4, 15, 0), + SOC_SINGLE("PWR Limiter Weight", M98088_REG_44_PWRLMT_CFG, 0, 7, 0), + SOC_SINGLE("PWR Limiter Time1", M98088_REG_45_PWRLMT_TIME, 0, 15, 0), + SOC_SINGLE("PWR Limiter Time2", M98088_REG_45_PWRLMT_TIME, 4, 15, 0), + + SOC_SINGLE("THD Limiter Threshold", M98088_REG_46_THDLMT_CFG, 4, 15, 0), + SOC_SINGLE("THD Limiter Time", M98088_REG_46_THDLMT_CFG, 0, 7, 0), +}; + +/* Left speaker mixer switch */ +static const struct snd_kcontrol_new max98088_left_speaker_mixer_controls[] = { + SOC_DAPM_SINGLE("Left DAC1 Switch", M98088_REG_2B_MIX_SPK_LEFT, 7, 1, 0), + SOC_DAPM_SINGLE("Right DAC1 Switch", M98088_REG_2B_MIX_SPK_LEFT, 0, 1, 0), + SOC_DAPM_SINGLE("Left DAC2 Switch", M98088_REG_2B_MIX_SPK_LEFT, 7, 1, 0), + SOC_DAPM_SINGLE("Right DAC2 Switch", M98088_REG_2B_MIX_SPK_LEFT, 0, 1, 0), + SOC_DAPM_SINGLE("MIC1 Switch", M98088_REG_2B_MIX_SPK_LEFT, 5, 1, 0), + SOC_DAPM_SINGLE("MIC2 Switch", M98088_REG_2B_MIX_SPK_LEFT, 6, 1, 0), + SOC_DAPM_SINGLE("INA1 Switch", M98088_REG_2B_MIX_SPK_LEFT, 1, 1, 0), + SOC_DAPM_SINGLE("INA2 Switch", M98088_REG_2B_MIX_SPK_LEFT, 2, 1, 0), + SOC_DAPM_SINGLE("INB1 Switch", M98088_REG_2B_MIX_SPK_LEFT, 3, 1, 0), + SOC_DAPM_SINGLE("INB2 Switch", M98088_REG_2B_MIX_SPK_LEFT, 4, 1, 0), +}; + +/* Right speaker mixer switch */ +static const struct snd_kcontrol_new max98088_right_speaker_mixer_controls[] = { + SOC_DAPM_SINGLE("Left DAC1 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 7, 1, 0), + SOC_DAPM_SINGLE("Right DAC1 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 0, 1, 0), + SOC_DAPM_SINGLE("Left DAC2 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 7, 1, 0), + SOC_DAPM_SINGLE("Right DAC2 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 0, 1, 0), + SOC_DAPM_SINGLE("MIC1 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 5, 1, 0), + SOC_DAPM_SINGLE("MIC2 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 6, 1, 0), + SOC_DAPM_SINGLE("INA1 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 1, 1, 0), + SOC_DAPM_SINGLE("INA2 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 2, 1, 0), + SOC_DAPM_SINGLE("INB1 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 3, 1, 0), + SOC_DAPM_SINGLE("INB2 Switch", M98088_REG_2C_MIX_SPK_RIGHT, 4, 1, 0), +}; + +/* Left headphone mixer switch */ +static const struct snd_kcontrol_new max98088_left_hp_mixer_controls[] = { + SOC_DAPM_SINGLE("Left DAC1 Switch", M98088_REG_25_MIX_HP_LEFT, 7, 1, 0), + SOC_DAPM_SINGLE("Right DAC1 Switch", M98088_REG_25_MIX_HP_LEFT, 0, 1, 0), + SOC_DAPM_SINGLE("Left DAC2 Switch", M98088_REG_25_MIX_HP_LEFT, 7, 1, 0), + SOC_DAPM_SINGLE("Right DAC2 Switch", M98088_REG_25_MIX_HP_LEFT, 0, 1, 0), + SOC_DAPM_SINGLE("MIC1 Switch", M98088_REG_25_MIX_HP_LEFT, 5, 1, 0), + SOC_DAPM_SINGLE("MIC2 Switch", M98088_REG_25_MIX_HP_LEFT, 6, 1, 0), + SOC_DAPM_SINGLE("INA1 Switch", M98088_REG_25_MIX_HP_LEFT, 1, 1, 0), + SOC_DAPM_SINGLE("INA2 Switch", M98088_REG_25_MIX_HP_LEFT, 2, 1, 0), + SOC_DAPM_SINGLE("INB1 Switch", M98088_REG_25_MIX_HP_LEFT, 3, 1, 0), + SOC_DAPM_SINGLE("INB2 Switch", M98088_REG_25_MIX_HP_LEFT, 4, 1, 0), +}; + +/* Right headphone mixer switch */ +static const struct snd_kcontrol_new max98088_right_hp_mixer_controls[] = { + SOC_DAPM_SINGLE("Left DAC1 Switch", M98088_REG_26_MIX_HP_RIGHT, 7, 1, 0), + SOC_DAPM_SINGLE("Right DAC1 Switch", M98088_REG_26_MIX_HP_RIGHT, 0, 1, 0), + SOC_DAPM_SINGLE("Left DAC2 Switch", M98088_REG_26_MIX_HP_RIGHT, 7, 1, 0), + SOC_DAPM_SINGLE("Right DAC2 Switch", M98088_REG_26_MIX_HP_RIGHT, 0, 1, 0), + SOC_DAPM_SINGLE("MIC1 Switch", M98088_REG_26_MIX_HP_RIGHT, 5, 1, 0), + SOC_DAPM_SINGLE("MIC2 Switch", M98088_REG_26_MIX_HP_RIGHT, 6, 1, 0), + SOC_DAPM_SINGLE("INA1 Switch", M98088_REG_26_MIX_HP_RIGHT, 1, 1, 0), + SOC_DAPM_SINGLE("INA2 Switch", M98088_REG_26_MIX_HP_RIGHT, 2, 1, 0), + SOC_DAPM_SINGLE("INB1 Switch", M98088_REG_26_MIX_HP_RIGHT, 3, 1, 0), + SOC_DAPM_SINGLE("INB2 Switch", M98088_REG_26_MIX_HP_RIGHT, 4, 1, 0), +}; + +/* Left earpiece/receiver mixer switch */ +static const struct snd_kcontrol_new max98088_left_rec_mixer_controls[] = { + SOC_DAPM_SINGLE("Left DAC1 Switch", M98088_REG_28_MIX_REC_LEFT, 7, 1, 0), + SOC_DAPM_SINGLE("Right DAC1 Switch", M98088_REG_28_MIX_REC_LEFT, 0, 1, 0), + SOC_DAPM_SINGLE("Left DAC2 Switch", M98088_REG_28_MIX_REC_LEFT, 7, 1, 0), + SOC_DAPM_SINGLE("Right DAC2 Switch", M98088_REG_28_MIX_REC_LEFT, 0, 1, 0), + SOC_DAPM_SINGLE("MIC1 Switch", M98088_REG_28_MIX_REC_LEFT, 5, 1, 0), + SOC_DAPM_SINGLE("MIC2 Switch", M98088_REG_28_MIX_REC_LEFT, 6, 1, 0), + SOC_DAPM_SINGLE("INA1 Switch", M98088_REG_28_MIX_REC_LEFT, 1, 1, 0), + SOC_DAPM_SINGLE("INA2 Switch", M98088_REG_28_MIX_REC_LEFT, 2, 1, 0), + SOC_DAPM_SINGLE("INB1 Switch", M98088_REG_28_MIX_REC_LEFT, 3, 1, 0), + SOC_DAPM_SINGLE("INB2 Switch", M98088_REG_28_MIX_REC_LEFT, 4, 1, 0), +}; + +/* Right earpiece/receiver mixer switch */ +static const struct snd_kcontrol_new max98088_right_rec_mixer_controls[] = { + SOC_DAPM_SINGLE("Left DAC1 Switch", M98088_REG_29_MIX_REC_RIGHT, 7, 1, 0), + SOC_DAPM_SINGLE("Right DAC1 Switch", M98088_REG_29_MIX_REC_RIGHT, 0, 1, 0), + SOC_DAPM_SINGLE("Left DAC2 Switch", M98088_REG_29_MIX_REC_RIGHT, 7, 1, 0), + SOC_DAPM_SINGLE("Right DAC2 Switch", M98088_REG_29_MIX_REC_RIGHT, 0, 1, 0), + SOC_DAPM_SINGLE("MIC1 Switch", M98088_REG_29_MIX_REC_RIGHT, 5, 1, 0), + SOC_DAPM_SINGLE("MIC2 Switch", M98088_REG_29_MIX_REC_RIGHT, 6, 1, 0), + SOC_DAPM_SINGLE("INA1 Switch", M98088_REG_29_MIX_REC_RIGHT, 1, 1, 0), + SOC_DAPM_SINGLE("INA2 Switch", M98088_REG_29_MIX_REC_RIGHT, 2, 1, 0), + SOC_DAPM_SINGLE("INB1 Switch", M98088_REG_29_MIX_REC_RIGHT, 3, 1, 0), + SOC_DAPM_SINGLE("INB2 Switch", M98088_REG_29_MIX_REC_RIGHT, 4, 1, 0), +}; + +/* Left ADC mixer switch */ +static const struct snd_kcontrol_new max98088_left_ADC_mixer_controls[] = { + SOC_DAPM_SINGLE("MIC1 Switch", M98088_REG_23_MIX_ADC_LEFT, 7, 1, 0), + SOC_DAPM_SINGLE("MIC2 Switch", M98088_REG_23_MIX_ADC_LEFT, 6, 1, 0), + SOC_DAPM_SINGLE("INA1 Switch", M98088_REG_23_MIX_ADC_LEFT, 3, 1, 0), + SOC_DAPM_SINGLE("INA2 Switch", M98088_REG_23_MIX_ADC_LEFT, 2, 1, 0), + SOC_DAPM_SINGLE("INB1 Switch", M98088_REG_23_MIX_ADC_LEFT, 1, 1, 0), + SOC_DAPM_SINGLE("INB2 Switch", M98088_REG_23_MIX_ADC_LEFT, 0, 1, 0), +}; + +/* Right ADC mixer switch */ +static const struct snd_kcontrol_new max98088_right_ADC_mixer_controls[] = { + SOC_DAPM_SINGLE("MIC1 Switch", M98088_REG_24_MIX_ADC_RIGHT, 7, 1, 0), + SOC_DAPM_SINGLE("MIC2 Switch", M98088_REG_24_MIX_ADC_RIGHT, 6, 1, 0), + SOC_DAPM_SINGLE("INA1 Switch", M98088_REG_24_MIX_ADC_RIGHT, 3, 1, 0), + SOC_DAPM_SINGLE("INA2 Switch", M98088_REG_24_MIX_ADC_RIGHT, 2, 1, 0), + SOC_DAPM_SINGLE("INB1 Switch", M98088_REG_24_MIX_ADC_RIGHT, 1, 1, 0), + SOC_DAPM_SINGLE("INB2 Switch", M98088_REG_24_MIX_ADC_RIGHT, 0, 1, 0), +}; + +static int max98088_mic_event(struct snd_soc_dapm_widget *w, + struct snd_kcontrol *kcontrol, int event) +{ + struct snd_soc_codec *codec = w->codec; + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + + switch (event) { + case SND_SOC_DAPM_POST_PMU: + if (w->reg == M98088_REG_35_LVL_MIC1) { + snd_soc_update_bits(codec, w->reg, M98088_MICPRE_MASK, + (1+max98088->mic1pre)<reg, M98088_MICPRE_MASK, + (1+max98088->mic2pre)<reg, M98088_MICPRE_MASK, 0); + break; + default: + return -EINVAL; + } + + return 0; +} + +/* + * The line inputs are 2-channel stereo inputs with the left + * and right channels sharing a common PGA power control signal. + */ +static int max98088_line_pga(struct snd_soc_dapm_widget *w, + int event, int line, u8 channel) +{ + struct snd_soc_codec *codec = w->codec; + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + u8 *state; + + BUG_ON(!((channel == 1) || (channel == 2))); + + switch (line) { + case LINE_INA: + state = &max98088->ina_state; + break; + case LINE_INB: + state = &max98088->inb_state; + break; + default: + return -EINVAL; + } + + switch (event) { + case SND_SOC_DAPM_POST_PMU: + *state |= channel; + snd_soc_update_bits(codec, w->reg, + (1 << w->shift), (1 << w->shift)); + break; + case SND_SOC_DAPM_POST_PMD: + *state &= ~channel; + if (*state == 0) { + snd_soc_update_bits(codec, w->reg, + (1 << w->shift), 0); + } + break; + default: + return -EINVAL; + } + + return 0; +} + +static int max98088_pga_ina1_event(struct snd_soc_dapm_widget *w, + struct snd_kcontrol *k, int event) +{ + return max98088_line_pga(w, event, LINE_INA, 1); +} + +static int max98088_pga_ina2_event(struct snd_soc_dapm_widget *w, + struct snd_kcontrol *k, int event) +{ + return max98088_line_pga(w, event, LINE_INA, 2); +} + +static int max98088_pga_inb1_event(struct snd_soc_dapm_widget *w, + struct snd_kcontrol *k, int event) +{ + return max98088_line_pga(w, event, LINE_INB, 1); +} + +static int max98088_pga_inb2_event(struct snd_soc_dapm_widget *w, + struct snd_kcontrol *k, int event) +{ + return max98088_line_pga(w, event, LINE_INB, 2); +} + +static const struct snd_soc_dapm_widget max98088_dapm_widgets[] = { + + SND_SOC_DAPM_ADC("ADCL", "HiFi Capture", M98088_REG_4C_PWR_EN_IN, 1, 0), + SND_SOC_DAPM_ADC("ADCR", "HiFi Capture", M98088_REG_4C_PWR_EN_IN, 0, 0), + + SND_SOC_DAPM_DAC("DACL1", "HiFi Playback", + M98088_REG_4D_PWR_EN_OUT, 1, 0), + SND_SOC_DAPM_DAC("DACR1", "HiFi Playback", + M98088_REG_4D_PWR_EN_OUT, 0, 0), + SND_SOC_DAPM_DAC("DACL2", "Aux Playback", + M98088_REG_4D_PWR_EN_OUT, 1, 0), + SND_SOC_DAPM_DAC("DACR2", "Aux Playback", + M98088_REG_4D_PWR_EN_OUT, 0, 0), + + SND_SOC_DAPM_PGA("HP Left Out", M98088_REG_4D_PWR_EN_OUT, + 7, 0, NULL, 0), + SND_SOC_DAPM_PGA("HP Right Out", M98088_REG_4D_PWR_EN_OUT, + 6, 0, NULL, 0), + + SND_SOC_DAPM_PGA("SPK Left Out", M98088_REG_4D_PWR_EN_OUT, + 5, 0, NULL, 0), + SND_SOC_DAPM_PGA("SPK Right Out", M98088_REG_4D_PWR_EN_OUT, + 4, 0, NULL, 0), + + SND_SOC_DAPM_PGA("REC Left Out", M98088_REG_4D_PWR_EN_OUT, + 3, 0, NULL, 0), + SND_SOC_DAPM_PGA("REC Right Out", M98088_REG_4D_PWR_EN_OUT, + 2, 0, NULL, 0), + + SND_SOC_DAPM_MUX("External MIC", SND_SOC_NOPM, 0, 0, + &max98088_extmic_mux), + + SND_SOC_DAPM_MIXER("Left HP Mixer", SND_SOC_NOPM, 0, 0, + &max98088_left_hp_mixer_controls[0], + ARRAY_SIZE(max98088_left_hp_mixer_controls)), + + SND_SOC_DAPM_MIXER("Right HP Mixer", SND_SOC_NOPM, 0, 0, + &max98088_right_hp_mixer_controls[0], + ARRAY_SIZE(max98088_right_hp_mixer_controls)), + + SND_SOC_DAPM_MIXER("Left SPK Mixer", SND_SOC_NOPM, 0, 0, + &max98088_left_speaker_mixer_controls[0], + ARRAY_SIZE(max98088_left_speaker_mixer_controls)), + + SND_SOC_DAPM_MIXER("Right SPK Mixer", SND_SOC_NOPM, 0, 0, + &max98088_right_speaker_mixer_controls[0], + ARRAY_SIZE(max98088_right_speaker_mixer_controls)), + + SND_SOC_DAPM_MIXER("Left REC Mixer", SND_SOC_NOPM, 0, 0, + &max98088_left_rec_mixer_controls[0], + ARRAY_SIZE(max98088_left_rec_mixer_controls)), + + SND_SOC_DAPM_MIXER("Right REC Mixer", SND_SOC_NOPM, 0, 0, + &max98088_right_rec_mixer_controls[0], + ARRAY_SIZE(max98088_right_rec_mixer_controls)), + + SND_SOC_DAPM_MIXER("Left ADC Mixer", SND_SOC_NOPM, 0, 0, + &max98088_left_ADC_mixer_controls[0], + ARRAY_SIZE(max98088_left_ADC_mixer_controls)), + + SND_SOC_DAPM_MIXER("Right ADC Mixer", SND_SOC_NOPM, 0, 0, + &max98088_right_ADC_mixer_controls[0], + ARRAY_SIZE(max98088_right_ADC_mixer_controls)), + + SND_SOC_DAPM_PGA_E("MIC1 Input", M98088_REG_35_LVL_MIC1, + 5, 0, NULL, 0, max98088_mic_event, + SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), + + SND_SOC_DAPM_PGA_E("MIC2 Input", M98088_REG_36_LVL_MIC2, + 5, 0, NULL, 0, max98088_mic_event, + SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), + + SND_SOC_DAPM_PGA_E("INA1 Input", M98088_REG_4C_PWR_EN_IN, + 7, 0, NULL, 0, max98088_pga_ina1_event, + SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), + + SND_SOC_DAPM_PGA_E("INA2 Input", M98088_REG_4C_PWR_EN_IN, + 7, 0, NULL, 0, max98088_pga_ina2_event, + SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), + + SND_SOC_DAPM_PGA_E("INB1 Input", M98088_REG_4C_PWR_EN_IN, + 6, 0, NULL, 0, max98088_pga_inb1_event, + SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), + + SND_SOC_DAPM_PGA_E("INB2 Input", M98088_REG_4C_PWR_EN_IN, + 6, 0, NULL, 0, max98088_pga_inb2_event, + SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), + + SND_SOC_DAPM_MICBIAS("MICBIAS", M98088_REG_4C_PWR_EN_IN, 3, 0), + + SND_SOC_DAPM_MUX("EX Limiter Mode", SND_SOC_NOPM, 0, 0, + &max98088_exmode_controls), + + SND_SOC_DAPM_OUTPUT("HPL"), + SND_SOC_DAPM_OUTPUT("HPR"), + SND_SOC_DAPM_OUTPUT("SPKL"), + SND_SOC_DAPM_OUTPUT("SPKR"), + SND_SOC_DAPM_OUTPUT("RECL"), + SND_SOC_DAPM_OUTPUT("RECR"), + + SND_SOC_DAPM_INPUT("MIC1"), + SND_SOC_DAPM_INPUT("MIC2"), + SND_SOC_DAPM_INPUT("INA1"), + SND_SOC_DAPM_INPUT("INA2"), + SND_SOC_DAPM_INPUT("INB1"), + SND_SOC_DAPM_INPUT("INB2"), +}; + +static const struct snd_soc_dapm_route audio_map[] = { + /* Left headphone output mixer */ + {"Left HP Mixer", "Left DAC1 Switch", "DACL1"}, + {"Left HP Mixer", "Left DAC2 Switch", "DACL2"}, + {"Left HP Mixer", "Right DAC1 Switch", "DACR1"}, + {"Left HP Mixer", "Right DAC2 Switch", "DACR2"}, + {"Left HP Mixer", "MIC1 Switch", "MIC1 Input"}, + {"Left HP Mixer", "MIC2 Switch", "MIC2 Input"}, + {"Left HP Mixer", "INA1 Switch", "INA1 Input"}, + {"Left HP Mixer", "INA2 Switch", "INA2 Input"}, + {"Left HP Mixer", "INB1 Switch", "INB1 Input"}, + {"Left HP Mixer", "INB2 Switch", "INB2 Input"}, + + /* Right headphone output mixer */ + {"Right HP Mixer", "Left DAC1 Switch", "DACL1"}, + {"Right HP Mixer", "Left DAC2 Switch", "DACL2" }, + {"Right HP Mixer", "Right DAC1 Switch", "DACR1"}, + {"Right HP Mixer", "Right DAC2 Switch", "DACR2"}, + {"Right HP Mixer", "MIC1 Switch", "MIC1 Input"}, + {"Right HP Mixer", "MIC2 Switch", "MIC2 Input"}, + {"Right HP Mixer", "INA1 Switch", "INA1 Input"}, + {"Right HP Mixer", "INA2 Switch", "INA2 Input"}, + {"Right HP Mixer", "INB1 Switch", "INB1 Input"}, + {"Right HP Mixer", "INB2 Switch", "INB2 Input"}, + + /* Left speaker output mixer */ + {"Left SPK Mixer", "Left DAC1 Switch", "DACL1"}, + {"Left SPK Mixer", "Left DAC2 Switch", "DACL2"}, + {"Left SPK Mixer", "Right DAC1 Switch", "DACR1"}, + {"Left SPK Mixer", "Right DAC2 Switch", "DACR2"}, + {"Left SPK Mixer", "MIC1 Switch", "MIC1 Input"}, + {"Left SPK Mixer", "MIC2 Switch", "MIC2 Input"}, + {"Left SPK Mixer", "INA1 Switch", "INA1 Input"}, + {"Left SPK Mixer", "INA2 Switch", "INA2 Input"}, + {"Left SPK Mixer", "INB1 Switch", "INB1 Input"}, + {"Left SPK Mixer", "INB2 Switch", "INB2 Input"}, + + /* Right speaker output mixer */ + {"Right SPK Mixer", "Left DAC1 Switch", "DACL1"}, + {"Right SPK Mixer", "Left DAC2 Switch", "DACL2"}, + {"Right SPK Mixer", "Right DAC1 Switch", "DACR1"}, + {"Right SPK Mixer", "Right DAC2 Switch", "DACR2"}, + {"Right SPK Mixer", "MIC1 Switch", "MIC1 Input"}, + {"Right SPK Mixer", "MIC2 Switch", "MIC2 Input"}, + {"Right SPK Mixer", "INA1 Switch", "INA1 Input"}, + {"Right SPK Mixer", "INA2 Switch", "INA2 Input"}, + {"Right SPK Mixer", "INB1 Switch", "INB1 Input"}, + {"Right SPK Mixer", "INB2 Switch", "INB2 Input"}, + + /* Earpiece/Receiver output mixer */ + {"Left REC Mixer", "Left DAC1 Switch", "DACL1"}, + {"Left REC Mixer", "Left DAC2 Switch", "DACL2"}, + {"Left REC Mixer", "Right DAC1 Switch", "DACR1"}, + {"Left REC Mixer", "Right DAC2 Switch", "DACR2"}, + {"Left REC Mixer", "MIC1 Switch", "MIC1 Input"}, + {"Left REC Mixer", "MIC2 Switch", "MIC2 Input"}, + {"Left REC Mixer", "INA1 Switch", "INA1 Input"}, + {"Left REC Mixer", "INA2 Switch", "INA2 Input"}, + {"Left REC Mixer", "INB1 Switch", "INB1 Input"}, + {"Left REC Mixer", "INB2 Switch", "INB2 Input"}, + + /* Earpiece/Receiver output mixer */ + {"Right REC Mixer", "Left DAC1 Switch", "DACL1"}, + {"Right REC Mixer", "Left DAC2 Switch", "DACL2"}, + {"Right REC Mixer", "Right DAC1 Switch", "DACR1"}, + {"Right REC Mixer", "Right DAC2 Switch", "DACR2"}, + {"Right REC Mixer", "MIC1 Switch", "MIC1 Input"}, + {"Right REC Mixer", "MIC2 Switch", "MIC2 Input"}, + {"Right REC Mixer", "INA1 Switch", "INA1 Input"}, + {"Right REC Mixer", "INA2 Switch", "INA2 Input"}, + {"Right REC Mixer", "INB1 Switch", "INB1 Input"}, + {"Right REC Mixer", "INB2 Switch", "INB2 Input"}, + + {"HP Left Out", NULL, "Left HP Mixer"}, + {"HP Right Out", NULL, "Right HP Mixer"}, + {"SPK Left Out", NULL, "Left SPK Mixer"}, + {"SPK Right Out", NULL, "Right SPK Mixer"}, + {"REC Left Out", NULL, "Left REC Mixer"}, + {"REC Right Out", NULL, "Right REC Mixer"}, + + {"HPL", NULL, "HP Left Out"}, + {"HPR", NULL, "HP Right Out"}, + {"SPKL", NULL, "SPK Left Out"}, + {"SPKR", NULL, "SPK Right Out"}, + {"RECL", NULL, "REC Left Out"}, + {"RECR", NULL, "REC Right Out"}, + + /* Left ADC input mixer */ + {"Left ADC Mixer", "MIC1 Switch", "MIC1 Input"}, + {"Left ADC Mixer", "MIC2 Switch", "MIC2 Input"}, + {"Left ADC Mixer", "INA1 Switch", "INA1 Input"}, + {"Left ADC Mixer", "INA2 Switch", "INA2 Input"}, + {"Left ADC Mixer", "INB1 Switch", "INB1 Input"}, + {"Left ADC Mixer", "INB2 Switch", "INB2 Input"}, + + /* Right ADC input mixer */ + {"Right ADC Mixer", "MIC1 Switch", "MIC1 Input"}, + {"Right ADC Mixer", "MIC2 Switch", "MIC2 Input"}, + {"Right ADC Mixer", "INA1 Switch", "INA1 Input"}, + {"Right ADC Mixer", "INA2 Switch", "INA2 Input"}, + {"Right ADC Mixer", "INB1 Switch", "INB1 Input"}, + {"Right ADC Mixer", "INB2 Switch", "INB2 Input"}, + + /* Inputs */ + {"ADCL", NULL, "Left ADC Mixer"}, + {"ADCR", NULL, "Right ADC Mixer"}, + {"INA1 Input", NULL, "INA1"}, + {"INA2 Input", NULL, "INA2"}, + {"INB1 Input", NULL, "INB1"}, + {"INB2 Input", NULL, "INB2"}, + {"MIC1 Input", NULL, "MIC1"}, + {"MIC2 Input", NULL, "MIC2"}, +}; + +static int max98088_add_widgets(struct snd_soc_codec *codec) +{ + snd_soc_dapm_new_controls(codec, max98088_dapm_widgets, + ARRAY_SIZE(max98088_dapm_widgets)); + + snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map)); + + snd_soc_add_controls(codec, max98088_snd_controls, + ARRAY_SIZE(max98088_snd_controls)); + + snd_soc_dapm_new_widgets(codec); + return 0; +} + +/* codec mclk clock divider coefficients */ +static const struct { + u32 rate; + u8 sr; +} rate_table[] = { + {8000, 0x10}, + {11025, 0x20}, + {16000, 0x30}, + {22050, 0x40}, + {24000, 0x50}, + {32000, 0x60}, + {44100, 0x70}, + {48000, 0x80}, + {88200, 0x90}, + {96000, 0xA0}, +}; + +static inline int rate_value(int rate, u8 *value) +{ + int i; + + for (i = 0; i < ARRAY_SIZE(rate_table); i++) { + if (rate_table[i].rate >= rate) { + *value = rate_table[i].sr; + return 0; + } + } + *value = rate_table[0].sr; + return -EINVAL; +} + +static int max98088_dai1_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params, + struct snd_soc_dai *dai) +{ + struct snd_soc_codec *codec = dai->codec; + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + struct max98088_cdata *cdata; + unsigned long long ni; + unsigned int rate; + u8 regval; + + cdata = &max98088->dai[0]; + + rate = params_rate(params); + + switch (params_format(params)) { + case SNDRV_PCM_FORMAT_S16_LE: + snd_soc_update_bits(codec, M98088_REG_14_DAI1_FORMAT, + M98088_DAI_WS, 0); + break; + case SNDRV_PCM_FORMAT_S24_LE: + snd_soc_update_bits(codec, M98088_REG_14_DAI1_FORMAT, + M98088_DAI_WS, M98088_DAI_WS); + break; + default: + return -EINVAL; + } + + snd_soc_update_bits(codec, M98088_REG_51_PWR_SYS, M98088_SHDNRUN, 0); + + if (rate_value(rate, ®val)) + return -EINVAL; + + snd_soc_update_bits(codec, M98088_REG_11_DAI1_CLKMODE, + M98088_CLKMODE_MASK, regval); + cdata->rate = rate; + + /* Configure NI when operating as master */ + if (snd_soc_read(codec, M98088_REG_14_DAI1_FORMAT) + & M98088_DAI_MAS) { + if (max98088->sysclk == 0) { + dev_err(codec->dev, "Invalid system clock frequency\n"); + return -EINVAL; + } + ni = 65536ULL * (rate < 50000 ? 96ULL : 48ULL) + * (unsigned long long int)rate; + do_div(ni, (unsigned long long int)max98088->sysclk); + snd_soc_write(codec, M98088_REG_12_DAI1_CLKCFG_HI, + (ni >> 8) & 0x7F); + snd_soc_write(codec, M98088_REG_13_DAI1_CLKCFG_LO, + ni & 0xFF); + } + + /* Update sample rate mode */ + if (rate < 50000) + snd_soc_update_bits(codec, M98088_REG_18_DAI1_FILTERS, + M98088_DAI_DHF, 0); + else + snd_soc_update_bits(codec, M98088_REG_18_DAI1_FILTERS, + M98088_DAI_DHF, M98088_DAI_DHF); + + snd_soc_update_bits(codec, M98088_REG_51_PWR_SYS, M98088_SHDNRUN, + M98088_SHDNRUN); + + return 0; +} + +static int max98088_dai2_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params, + struct snd_soc_dai *dai) +{ + struct snd_soc_codec *codec = dai->codec; + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + struct max98088_cdata *cdata; + unsigned long long ni; + unsigned int rate; + u8 regval; + + cdata = &max98088->dai[1]; + + rate = params_rate(params); + + switch (params_format(params)) { + case SNDRV_PCM_FORMAT_S16_LE: + snd_soc_update_bits(codec, M98088_REG_1C_DAI2_FORMAT, + M98088_DAI_WS, 0); + break; + case SNDRV_PCM_FORMAT_S24_LE: + snd_soc_update_bits(codec, M98088_REG_1C_DAI2_FORMAT, + M98088_DAI_WS, M98088_DAI_WS); + break; + default: + return -EINVAL; + } + + snd_soc_update_bits(codec, M98088_REG_51_PWR_SYS, M98088_SHDNRUN, 0); + + if (rate_value(rate, ®val)) + return -EINVAL; + + snd_soc_update_bits(codec, M98088_REG_19_DAI2_CLKMODE, + M98088_CLKMODE_MASK, regval); + cdata->rate = rate; + + /* Configure NI when operating as master */ + if (snd_soc_read(codec, M98088_REG_1C_DAI2_FORMAT) + & M98088_DAI_MAS) { + if (max98088->sysclk == 0) { + dev_err(codec->dev, "Invalid system clock frequency\n"); + return -EINVAL; + } + ni = 65536ULL * (rate < 50000 ? 96ULL : 48ULL) + * (unsigned long long int)rate; + do_div(ni, (unsigned long long int)max98088->sysclk); + snd_soc_write(codec, M98088_REG_1A_DAI2_CLKCFG_HI, + (ni >> 8) & 0x7F); + snd_soc_write(codec, M98088_REG_1B_DAI2_CLKCFG_LO, + ni & 0xFF); + } + + /* Update sample rate mode */ + if (rate < 50000) + snd_soc_update_bits(codec, M98088_REG_20_DAI2_FILTERS, + M98088_DAI_DHF, 0); + else + snd_soc_update_bits(codec, M98088_REG_20_DAI2_FILTERS, + M98088_DAI_DHF, M98088_DAI_DHF); + + snd_soc_update_bits(codec, M98088_REG_51_PWR_SYS, M98088_SHDNRUN, + M98088_SHDNRUN); + + return 0; +} + +static int max98088_dai_set_sysclk(struct snd_soc_dai *dai, + int clk_id, unsigned int freq, int dir) +{ + struct snd_soc_codec *codec = dai->codec; + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + + /* Requested clock frequency is already setup */ + if (freq == max98088->sysclk) + return 0; + + max98088->sysclk = freq; /* remember current sysclk */ + + /* Setup clocks for slave mode, and using the PLL + * PSCLK = 0x01 (when master clk is 10MHz to 20MHz) + * 0x02 (when master clk is 20MHz to 30MHz).. + */ + if ((freq >= 10000000) && (freq < 20000000)) { + snd_soc_write(codec, M98088_REG_10_SYS_CLK, 0x10); + } else if ((freq >= 20000000) && (freq < 30000000)) { + snd_soc_write(codec, M98088_REG_10_SYS_CLK, 0x20); + } else { + dev_err(codec->dev, "Invalid master clock frequency\n"); + return -EINVAL; + } + + if (snd_soc_read(codec, M98088_REG_51_PWR_SYS) & M98088_SHDNRUN) { + snd_soc_update_bits(codec, M98088_REG_51_PWR_SYS, + M98088_SHDNRUN, 0); + snd_soc_update_bits(codec, M98088_REG_51_PWR_SYS, + M98088_SHDNRUN, M98088_SHDNRUN); + } + + dev_dbg(dai->dev, "Clock source is %d at %uHz\n", clk_id, freq); + + max98088->sysclk = freq; + return 0; +} + +static int max98088_dai1_set_fmt(struct snd_soc_dai *codec_dai, + unsigned int fmt) +{ + struct snd_soc_codec *codec = codec_dai->codec; + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + struct max98088_cdata *cdata; + u8 reg15val; + u8 reg14val = 0; + + cdata = &max98088->dai[0]; + + if (fmt != cdata->fmt) { + cdata->fmt = fmt; + + switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { + case SND_SOC_DAIFMT_CBS_CFS: + /* Slave mode PLL */ + snd_soc_write(codec, M98088_REG_12_DAI1_CLKCFG_HI, + 0x80); + snd_soc_write(codec, M98088_REG_13_DAI1_CLKCFG_LO, + 0x00); + break; + case SND_SOC_DAIFMT_CBM_CFM: + /* Set to master mode */ + reg14val |= M98088_DAI_MAS; + break; + case SND_SOC_DAIFMT_CBS_CFM: + case SND_SOC_DAIFMT_CBM_CFS: + default: + dev_err(codec->dev, "Clock mode unsupported"); + return -EINVAL; + } + + switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { + case SND_SOC_DAIFMT_I2S: + reg14val |= M98088_DAI_DLY; + break; + case SND_SOC_DAIFMT_LEFT_J: + break; + default: + return -EINVAL; + } + + switch (fmt & SND_SOC_DAIFMT_INV_MASK) { + case SND_SOC_DAIFMT_NB_NF: + break; + case SND_SOC_DAIFMT_NB_IF: + reg14val |= M98088_DAI_WCI; + break; + case SND_SOC_DAIFMT_IB_NF: + reg14val |= M98088_DAI_BCI; + break; + case SND_SOC_DAIFMT_IB_IF: + reg14val |= M98088_DAI_BCI|M98088_DAI_WCI; + break; + default: + return -EINVAL; + } + + snd_soc_update_bits(codec, M98088_REG_14_DAI1_FORMAT, + M98088_DAI_MAS | M98088_DAI_DLY | M98088_DAI_BCI | + M98088_DAI_WCI, reg14val); + + reg15val = M98088_DAI_BSEL64; + if (max98088->digmic) + reg15val |= M98088_DAI_OSR64; + snd_soc_write(codec, M98088_REG_15_DAI1_CLOCK, reg15val); + } + + return 0; +} + +static int max98088_dai2_set_fmt(struct snd_soc_dai *codec_dai, + unsigned int fmt) +{ + struct snd_soc_codec *codec = codec_dai->codec; + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + struct max98088_cdata *cdata; + u8 reg1Cval = 0; + + cdata = &max98088->dai[1]; + + if (fmt != cdata->fmt) { + cdata->fmt = fmt; + + switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { + case SND_SOC_DAIFMT_CBS_CFS: + /* Slave mode PLL */ + snd_soc_write(codec, M98088_REG_1A_DAI2_CLKCFG_HI, + 0x80); + snd_soc_write(codec, M98088_REG_1B_DAI2_CLKCFG_LO, + 0x00); + break; + case SND_SOC_DAIFMT_CBM_CFM: + /* Set to master mode */ + reg1Cval |= M98088_DAI_MAS; + break; + case SND_SOC_DAIFMT_CBS_CFM: + case SND_SOC_DAIFMT_CBM_CFS: + default: + dev_err(codec->dev, "Clock mode unsupported"); + return -EINVAL; + } + + switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { + case SND_SOC_DAIFMT_I2S: + reg1Cval |= M98088_DAI_DLY; + break; + case SND_SOC_DAIFMT_LEFT_J: + break; + default: + return -EINVAL; + } + + switch (fmt & SND_SOC_DAIFMT_INV_MASK) { + case SND_SOC_DAIFMT_NB_NF: + break; + case SND_SOC_DAIFMT_NB_IF: + reg1Cval |= M98088_DAI_WCI; + break; + case SND_SOC_DAIFMT_IB_NF: + reg1Cval |= M98088_DAI_BCI; + break; + case SND_SOC_DAIFMT_IB_IF: + reg1Cval |= M98088_DAI_BCI|M98088_DAI_WCI; + break; + default: + return -EINVAL; + } + + snd_soc_update_bits(codec, M98088_REG_1C_DAI2_FORMAT, + M98088_DAI_MAS | M98088_DAI_DLY | M98088_DAI_BCI | + M98088_DAI_WCI, reg1Cval); + + snd_soc_write(codec, M98088_REG_1D_DAI2_CLOCK, + M98088_DAI_BSEL64); + } + + return 0; +} + +static void max98088_sync_cache(struct snd_soc_codec *codec) +{ + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + int i; + + if (!codec->cache_sync) + return; + + codec->cache_only = 0; + + /* write back cached values if they're writeable and + * different from the hardware default. + */ + for (i = 1; i < ARRAY_SIZE(max98088->reg_cache); i++) { + if (!max98088_access[i].writable) + continue; + + if (max98088->reg_cache[i] == max98088_reg[i]) + continue; + + snd_soc_write(codec, i, max98088->reg_cache[i]); + } + + codec->cache_sync = 0; +} + +static int max98088_set_bias_level(struct snd_soc_codec *codec, + enum snd_soc_bias_level level) +{ + switch (level) { + case SND_SOC_BIAS_ON: + break; + + case SND_SOC_BIAS_PREPARE: + break; + + case SND_SOC_BIAS_STANDBY: + if (codec->bias_level == SND_SOC_BIAS_OFF) + max98088_sync_cache(codec); + + snd_soc_update_bits(codec, M98088_REG_4C_PWR_EN_IN, + M98088_MBEN, M98088_MBEN); + break; + + case SND_SOC_BIAS_OFF: + snd_soc_update_bits(codec, M98088_REG_4C_PWR_EN_IN, + M98088_MBEN, 0); + codec->cache_sync = 1; + break; + } + codec->bias_level = level; + return 0; +} + +#define MAX98088_RATES SNDRV_PCM_RATE_8000_96000 +#define MAX98088_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE) + +static struct snd_soc_dai_ops max98088_dai1_ops = { + .set_sysclk = max98088_dai_set_sysclk, + .set_fmt = max98088_dai1_set_fmt, + .hw_params = max98088_dai1_hw_params, +}; + +static struct snd_soc_dai_ops max98088_dai2_ops = { + .set_sysclk = max98088_dai_set_sysclk, + .set_fmt = max98088_dai2_set_fmt, + .hw_params = max98088_dai2_hw_params, +}; + +static struct snd_soc_dai_driver max98088_dai[] = { +{ + .name = "HiFi", + .playback = { + .stream_name = "HiFi Playback", + .channels_min = 1, + .channels_max = 2, + .rates = MAX98088_RATES, + .formats = MAX98088_FORMATS, + }, + .capture = { + .stream_name = "HiFi Capture", + .channels_min = 1, + .channels_max = 2, + .rates = MAX98088_RATES, + .formats = MAX98088_FORMATS, + }, + .ops = &max98088_dai1_ops, +}, +{ + .name = "Aux", + .playback = { + .stream_name = "Aux Playback", + .channels_min = 1, + .channels_max = 2, + .rates = MAX98088_RATES, + .formats = MAX98088_FORMATS, + }, + .ops = &max98088_dai2_ops, +} +}; + +static int max98088_get_channel(const char *name) +{ + if (strcmp(name, "EQ1 Mode") == 0) + return 0; + if (strcmp(name, "EQ2 Mode") == 0) + return 1; + return -EINVAL; +} + +static void max98088_setup_eq1(struct snd_soc_codec *codec) +{ + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + struct max98088_pdata *pdata = max98088->pdata; + struct max98088_eq_cfg *coef_set; + int best, best_val, save, i, sel, fs; + struct max98088_cdata *cdata; + + cdata = &max98088->dai[0]; + + if (!pdata || !max98088->eq_textcnt) + return; + + /* Find the selected configuration with nearest sample rate */ + fs = cdata->rate; + sel = cdata->eq_sel; + + best = 0; + best_val = INT_MAX; + for (i = 0; i < pdata->eq_cfgcnt; i++) { + if (strcmp(pdata->eq_cfg[i].name, max98088->eq_texts[sel]) == 0 && + abs(pdata->eq_cfg[i].rate - fs) < best_val) { + best = i; + best_val = abs(pdata->eq_cfg[i].rate - fs); + } + } + + dev_dbg(codec->dev, "Selected %s/%dHz for %dHz sample rate\n", + pdata->eq_cfg[best].name, + pdata->eq_cfg[best].rate, fs); + + /* Disable EQ while configuring, and save current on/off state */ + save = snd_soc_read(codec, M98088_REG_49_CFG_LEVEL); + snd_soc_update_bits(codec, M98088_REG_49_CFG_LEVEL, M98088_EQ1EN, 0); + + coef_set = &pdata->eq_cfg[sel]; + + m98088_eq_band(codec, 0, 0, coef_set->band1); + m98088_eq_band(codec, 0, 1, coef_set->band2); + m98088_eq_band(codec, 0, 2, coef_set->band3); + m98088_eq_band(codec, 0, 3, coef_set->band4); + m98088_eq_band(codec, 0, 4, coef_set->band5); + + /* Restore the original on/off state */ + snd_soc_update_bits(codec, M98088_REG_49_CFG_LEVEL, M98088_EQ1EN, save); +} + +static void max98088_setup_eq2(struct snd_soc_codec *codec) +{ + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + struct max98088_pdata *pdata = max98088->pdata; + struct max98088_eq_cfg *coef_set; + int best, best_val, save, i, sel, fs; + struct max98088_cdata *cdata; + + cdata = &max98088->dai[1]; + + if (!pdata || !max98088->eq_textcnt) + return; + + /* Find the selected configuration with nearest sample rate */ + fs = cdata->rate; + + sel = cdata->eq_sel; + best = 0; + best_val = INT_MAX; + for (i = 0; i < pdata->eq_cfgcnt; i++) { + if (strcmp(pdata->eq_cfg[i].name, max98088->eq_texts[sel]) == 0 && + abs(pdata->eq_cfg[i].rate - fs) < best_val) { + best = i; + best_val = abs(pdata->eq_cfg[i].rate - fs); + } + } + + dev_dbg(codec->dev, "Selected %s/%dHz for %dHz sample rate\n", + pdata->eq_cfg[best].name, + pdata->eq_cfg[best].rate, fs); + + /* Disable EQ while configuring, and save current on/off state */ + save = snd_soc_read(codec, M98088_REG_49_CFG_LEVEL); + snd_soc_update_bits(codec, M98088_REG_49_CFG_LEVEL, M98088_EQ2EN, 0); + + coef_set = &pdata->eq_cfg[sel]; + + m98088_eq_band(codec, 1, 0, coef_set->band1); + m98088_eq_band(codec, 1, 1, coef_set->band2); + m98088_eq_band(codec, 1, 2, coef_set->band3); + m98088_eq_band(codec, 1, 3, coef_set->band4); + m98088_eq_band(codec, 1, 4, coef_set->band5); + + /* Restore the original on/off state */ + snd_soc_update_bits(codec, M98088_REG_49_CFG_LEVEL, M98088_EQ2EN, + save); +} + +static int max98088_put_eq_enum(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + struct max98088_pdata *pdata = max98088->pdata; + int channel = max98088_get_channel(kcontrol->id.name); + struct max98088_cdata *cdata; + int sel = ucontrol->value.integer.value[0]; + + cdata = &max98088->dai[channel]; + + if (sel >= pdata->eq_cfgcnt) + return -EINVAL; + + cdata->eq_sel = sel; + + switch (channel) { + case 0: + max98088_setup_eq1(codec); + break; + case 1: + max98088_setup_eq2(codec); + break; + } + + return 0; +} + +static int max98088_get_eq_enum(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + int channel = max98088_get_channel(kcontrol->id.name); + struct max98088_cdata *cdata; + + cdata = &max98088->dai[channel]; + ucontrol->value.enumerated.item[0] = cdata->eq_sel; + return 0; +} + +static void max98088_handle_eq_pdata(struct snd_soc_codec *codec) +{ + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + struct max98088_pdata *pdata = max98088->pdata; + struct max98088_eq_cfg *cfg; + unsigned int cfgcnt; + int i, j; + const char **t; + int ret; + + struct snd_kcontrol_new controls[] = { + SOC_ENUM_EXT("EQ1 Mode", + max98088->eq_enum, + max98088_get_eq_enum, + max98088_put_eq_enum), + SOC_ENUM_EXT("EQ2 Mode", + max98088->eq_enum, + max98088_get_eq_enum, + max98088_put_eq_enum), + }; + + cfg = pdata->eq_cfg; + cfgcnt = pdata->eq_cfgcnt; + + /* Setup an array of texts for the equalizer enum. + * This is based on Mark Brown's equalizer driver code. + */ + max98088->eq_textcnt = 0; + max98088->eq_texts = NULL; + for (i = 0; i < cfgcnt; i++) { + for (j = 0; j < max98088->eq_textcnt; j++) { + if (strcmp(cfg[i].name, max98088->eq_texts[j]) == 0) + break; + } + + if (j != max98088->eq_textcnt) + continue; + + /* Expand the array */ + t = krealloc(max98088->eq_texts, + sizeof(char *) * (max98088->eq_textcnt + 1), + GFP_KERNEL); + if (t == NULL) + continue; + + /* Store the new entry */ + t[max98088->eq_textcnt] = cfg[i].name; + max98088->eq_textcnt++; + max98088->eq_texts = t; + } + + /* Now point the soc_enum to .texts array items */ + max98088->eq_enum.texts = max98088->eq_texts; + max98088->eq_enum.max = max98088->eq_textcnt; + + ret = snd_soc_add_controls(codec, controls, ARRAY_SIZE(controls)); + if (ret != 0) + dev_err(codec->dev, "Failed to add EQ control: %d\n", ret); +} + +static void max98088_handle_pdata(struct snd_soc_codec *codec) +{ + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + struct max98088_pdata *pdata = max98088->pdata; + u8 regval = 0; + + if (!pdata) { + dev_dbg(codec->dev, "No platform data\n"); + return; + } + + /* Configure mic for analog/digital mic mode */ + if (pdata->digmic_left_mode) + regval |= M98088_DIGMIC_L; + + if (pdata->digmic_right_mode) + regval |= M98088_DIGMIC_R; + + max98088->digmic = (regval ? 1 : 0); + + snd_soc_write(codec, M98088_REG_48_CFG_MIC, regval); + + /* Configure receiver output */ + regval = ((pdata->receiver_mode) ? M98088_REC_LINEMODE : 0); + snd_soc_update_bits(codec, M98088_REG_2A_MIC_REC_CNTL, + M98088_REC_LINEMODE_MASK, regval); + + /* Configure equalizers */ + if (pdata->eq_cfgcnt) + max98088_handle_eq_pdata(codec); +} + +#ifdef CONFIG_PM +static int max98088_suspend(struct snd_soc_codec *codec, pm_message_t state) +{ + max98088_set_bias_level(codec, SND_SOC_BIAS_OFF); + + return 0; +} + +static int max98088_resume(struct snd_soc_codec *codec) +{ + max98088_set_bias_level(codec, SND_SOC_BIAS_STANDBY); + + return 0; +} +#else +#define max98088_suspend NULL +#define max98088_resume NULL +#endif + +static int max98088_probe(struct snd_soc_codec *codec) +{ + struct max98088_priv *max98088 = snd_soc_codec_get_drvdata(codec); + struct max98088_cdata *cdata; + int ret = 0; + + codec->cache_sync = 1; + memcpy(codec->reg_cache, max98088_reg, sizeof(max98088_reg)); + + ret = snd_soc_codec_set_cache_io(codec, 8, 8, SND_SOC_I2C); + if (ret != 0) { + dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret); + return ret; + } + + /* initalize private data */ + + max98088->sysclk = (unsigned)-1; + max98088->eq_textcnt = 0; + + cdata = &max98088->dai[0]; + cdata->rate = (unsigned)-1; + cdata->fmt = (unsigned)-1; + cdata->eq_sel = 0; + + cdata = &max98088->dai[1]; + cdata->rate = (unsigned)-1; + cdata->fmt = (unsigned)-1; + cdata->eq_sel = 0; + + max98088->ina_state = 0; + max98088->inb_state = 0; + max98088->ex_mode = 0; + max98088->digmic = 0; + max98088->mic1pre = 0; + max98088->mic2pre = 0; + + ret = snd_soc_read(codec, M98088_REG_FF_REV_ID); + if (ret < 0) { + dev_err(codec->dev, "Failed to read device revision: %d\n", + ret); + goto err_access; + } + dev_info(codec->dev, "revision %c\n", ret + 'A'); + + snd_soc_write(codec, M98088_REG_51_PWR_SYS, M98088_PWRSV); + + /* initialize registers cache to hardware default */ + max98088_set_bias_level(codec, SND_SOC_BIAS_STANDBY); + + snd_soc_write(codec, M98088_REG_0F_IRQ_ENABLE, 0x00); + + snd_soc_write(codec, M98088_REG_22_MIX_DAC, + M98088_DAI1L_TO_DACL|M98088_DAI2L_TO_DACL| + M98088_DAI1R_TO_DACR|M98088_DAI2R_TO_DACR); + + snd_soc_write(codec, M98088_REG_4E_BIAS_CNTL, 0xF0); + snd_soc_write(codec, M98088_REG_50_DAC_BIAS2, 0x0F); + + snd_soc_write(codec, M98088_REG_16_DAI1_IOCFG, + M98088_S1NORMAL|M98088_SDATA); + + snd_soc_write(codec, M98088_REG_1E_DAI2_IOCFG, + M98088_S2NORMAL|M98088_SDATA); + + max98088_handle_pdata(codec); + + max98088_add_widgets(codec); + +err_access: + return ret; +} + +static int max98088_remove(struct snd_soc_codec *codec) +{ + max98088_set_bias_level(codec, SND_SOC_BIAS_OFF); + + return 0; +} + +static struct snd_soc_codec_driver soc_codec_dev_max98088 = { + .probe = max98088_probe, + .remove = max98088_remove, + .suspend = max98088_suspend, + .resume = max98088_resume, + .set_bias_level = max98088_set_bias_level, + .reg_cache_size = ARRAY_SIZE(max98088_reg), + .reg_word_size = sizeof(u8), + .reg_cache_default = max98088_reg, + .volatile_register = max98088_volatile_register, +}; + +static int max98088_i2c_probe(struct i2c_client *i2c, + const struct i2c_device_id *id) +{ + struct max98088_priv *max98088; + int ret; + + max98088 = kzalloc(sizeof(struct max98088_priv), GFP_KERNEL); + if (max98088 == NULL) + return -ENOMEM; + + i2c_set_clientdata(i2c, max98088); + max98088->control_data = i2c; + max98088->pdata = i2c->dev.platform_data; + + ret = snd_soc_register_codec(&i2c->dev, + &soc_codec_dev_max98088, &max98088_dai[0], 2); + if (ret < 0) + kfree(max98088); + return ret; +} + +static int max98088_i2c_remove(struct i2c_client *client) +{ + snd_soc_unregister_codec(&client->dev); + kfree(i2c_get_clientdata(client)); + return 0; +} + +static const struct i2c_device_id max98088_i2c_id[] = { + { "max98088", 0 }, + { } +}; +MODULE_DEVICE_TABLE(i2c, max98088_i2c_id); + +static struct i2c_driver max98088_i2c_driver = { + .driver = { + .name = "max98088", + .owner = THIS_MODULE, + }, + .probe = max98088_i2c_probe, + .remove = __devexit_p(max98088_i2c_remove), + .id_table = max98088_i2c_id, +}; + +static int __init max98088_init(void) +{ + int ret; + + ret = i2c_add_driver(&max98088_i2c_driver); + if (ret) + pr_err("Failed to register max98088 I2C driver: %d\n", ret); + + return ret; +} +module_init(max98088_init); + +static void __exit max98088_exit(void) +{ + i2c_del_driver(&max98088_i2c_driver); +} +module_exit(max98088_exit); + +MODULE_DESCRIPTION("ALSA SoC MAX98088 driver"); +MODULE_AUTHOR("Peter Hsiang, Jesse Marroquin"); +MODULE_LICENSE("GPL"); diff --git a/sound/soc/codecs/max98088.h b/sound/soc/codecs/max98088.h new file mode 100644 index 0000000..56554c7 --- /dev/null +++ b/sound/soc/codecs/max98088.h @@ -0,0 +1,193 @@ +/* + * max98088.h -- MAX98088 ALSA SoC Audio driver + * + * Copyright 2010 Maxim Integrated Products + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#ifndef _MAX98088_H +#define _MAX98088_H + +/* + * MAX98088 Registers Definition + */ +#define M98088_REG_00_IRQ_STATUS 0x00 +#define M98088_REG_01_MIC_STATUS 0x01 +#define M98088_REG_02_JACK_STAUS 0x02 +#define M98088_REG_03_BATTERY_VOLTAGE 0x03 +#define M98088_REG_0F_IRQ_ENABLE 0x0F +#define M98088_REG_10_SYS_CLK 0x10 +#define M98088_REG_11_DAI1_CLKMODE 0x11 +#define M98088_REG_12_DAI1_CLKCFG_HI 0x12 +#define M98088_REG_13_DAI1_CLKCFG_LO 0x13 +#define M98088_REG_14_DAI1_FORMAT 0x14 +#define M98088_REG_15_DAI1_CLOCK 0x15 +#define M98088_REG_16_DAI1_IOCFG 0x16 +#define M98088_REG_17_DAI1_TDM 0x17 +#define M98088_REG_18_DAI1_FILTERS 0x18 +#define M98088_REG_19_DAI2_CLKMODE 0x19 +#define M98088_REG_1A_DAI2_CLKCFG_HI 0x1A +#define M98088_REG_1B_DAI2_CLKCFG_LO 0x1B +#define M98088_REG_1C_DAI2_FORMAT 0x1C +#define M98088_REG_1D_DAI2_CLOCK 0x1D +#define M98088_REG_1E_DAI2_IOCFG 0x1E +#define M98088_REG_1F_DAI2_TDM 0x1F +#define M98088_REG_20_DAI2_FILTERS 0x20 +#define M98088_REG_21_SRC 0x21 +#define M98088_REG_22_MIX_DAC 0x22 +#define M98088_REG_23_MIX_ADC_LEFT 0x23 +#define M98088_REG_24_MIX_ADC_RIGHT 0x24 +#define M98088_REG_25_MIX_HP_LEFT 0x25 +#define M98088_REG_26_MIX_HP_RIGHT 0x26 +#define M98088_REG_27_MIX_HP_CNTL 0x27 +#define M98088_REG_28_MIX_REC_LEFT 0x28 +#define M98088_REG_29_MIX_REC_RIGHT 0x29 +#define M98088_REG_2A_MIC_REC_CNTL 0x2A +#define M98088_REG_2B_MIX_SPK_LEFT 0x2B +#define M98088_REG_2C_MIX_SPK_RIGHT 0x2C +#define M98088_REG_2D_MIX_SPK_CNTL 0x2D +#define M98088_REG_2E_LVL_SIDETONE 0x2E +#define M98088_REG_2F_LVL_DAI1_PLAY 0x2F +#define M98088_REG_30_LVL_DAI1_PLAY_EQ 0x30 +#define M98088_REG_31_LVL_DAI2_PLAY 0x31 +#define M98088_REG_32_LVL_DAI2_PLAY_EQ 0x32 +#define M98088_REG_33_LVL_ADC_L 0x33 +#define M98088_REG_34_LVL_ADC_R 0x34 +#define M98088_REG_35_LVL_MIC1 0x35 +#define M98088_REG_36_LVL_MIC2 0x36 +#define M98088_REG_37_LVL_INA 0x37 +#define M98088_REG_38_LVL_INB 0x38 +#define M98088_REG_39_LVL_HP_L 0x39 +#define M98088_REG_3A_LVL_HP_R 0x3A +#define M98088_REG_3B_LVL_REC_L 0x3B +#define M98088_REG_3C_LVL_REC_R 0x3C +#define M98088_REG_3D_LVL_SPK_L 0x3D +#define M98088_REG_3E_LVL_SPK_R 0x3E +#define M98088_REG_3F_MICAGC_CFG 0x3F +#define M98088_REG_40_MICAGC_THRESH 0x40 +#define M98088_REG_41_SPKDHP 0x41 +#define M98088_REG_42_SPKDHP_THRESH 0x42 +#define M98088_REG_43_SPKALC_COMP 0x43 +#define M98088_REG_44_PWRLMT_CFG 0x44 +#define M98088_REG_45_PWRLMT_TIME 0x45 +#define M98088_REG_46_THDLMT_CFG 0x46 +#define M98088_REG_47_CFG_AUDIO_IN 0x47 +#define M98088_REG_48_CFG_MIC 0x48 +#define M98088_REG_49_CFG_LEVEL 0x49 +#define M98088_REG_4A_CFG_BYPASS 0x4A +#define M98088_REG_4B_CFG_JACKDET 0x4B +#define M98088_REG_4C_PWR_EN_IN 0x4C +#define M98088_REG_4D_PWR_EN_OUT 0x4D +#define M98088_REG_4E_BIAS_CNTL 0x4E +#define M98088_REG_4F_DAC_BIAS1 0x4F +#define M98088_REG_50_DAC_BIAS2 0x50 +#define M98088_REG_51_PWR_SYS 0x51 +#define M98088_REG_52_DAI1_EQ_BASE 0x52 +#define M98088_REG_84_DAI2_EQ_BASE 0x84 +#define M98088_REG_B6_DAI1_BIQUAD_BASE 0xB6 +#define M98088_REG_C0_DAI2_BIQUAD_BASE 0xC0 +#define M98088_REG_FF_REV_ID 0xFF + +#define M98088_REG_CNT (0xFF+1) + +/* MAX98088 Registers Bit Fields */ + +/* M98088_REG_11_DAI1_CLKMODE, M98088_REG_19_DAI2_CLKMODE */ + #define M98088_CLKMODE_MASK 0xFF + +/* M98088_REG_14_DAI1_FORMAT, M98088_REG_1C_DAI2_FORMAT */ + #define M98088_DAI_MAS (1<<7) + #define M98088_DAI_WCI (1<<6) + #define M98088_DAI_BCI (1<<5) + #define M98088_DAI_DLY (1<<4) + #define M98088_DAI_TDM (1<<2) + #define M98088_DAI_FSW (1<<1) + #define M98088_DAI_WS (1<<0) + +/* M98088_REG_15_DAI1_CLOCK, M98088_REG_1D_DAI2_CLOCK */ + #define M98088_DAI_BSEL64 (1<<0) + #define M98088_DAI_OSR64 (1<<6) + +/* M98088_REG_16_DAI1_IOCFG, M98088_REG_1E_DAI2_IOCFG */ + #define M98088_S1NORMAL (1<<6) + #define M98088_S2NORMAL (2<<6) + #define M98088_SDATA (3<<0) + +/* M98088_REG_18_DAI1_FILTERS, M98088_REG_20_DAI2_FILTERS */ + #define M98088_DAI_DHF (1<<3) + +/* M98088_REG_22_MIX_DAC */ + #define M98088_DAI1L_TO_DACL (1<<7) + #define M98088_DAI1R_TO_DACL (1<<6) + #define M98088_DAI2L_TO_DACL (1<<5) + #define M98088_DAI2R_TO_DACL (1<<4) + #define M98088_DAI1L_TO_DACR (1<<3) + #define M98088_DAI1R_TO_DACR (1<<2) + #define M98088_DAI2L_TO_DACR (1<<1) + #define M98088_DAI2R_TO_DACR (1<<0) + +/* M98088_REG_2A_MIC_REC_CNTL */ + #define M98088_REC_LINEMODE (1<<7) + #define M98088_REC_LINEMODE_MASK (1<<7) + +/* M98088_REG_35_LVL_MIC1, M98088_REG_36_LVL_MIC2 */ + #define M98088_MICPRE_MASK (3<<5) + #define M98088_MICPRE_SHIFT 5 + +/* M98088_REG_3A_LVL_HP_R */ + #define M98088_HP_MUTE (1<<7) + +/* M98088_REG_3C_LVL_REC_R */ + #define M98088_REC_MUTE (1<<7) + +/* M98088_REG_3E_LVL_SPK_R */ + #define M98088_SP_MUTE (1<<7) + +/* M98088_REG_48_CFG_MIC */ + #define M98088_EXTMIC_MASK (3<<0) + #define M98088_DIGMIC_L (1<<5) + #define M98088_DIGMIC_R (1<<4) + +/* M98088_REG_49_CFG_LEVEL */ + #define M98088_VSEN (1<<6) + #define M98088_ZDEN (1<<5) + #define M98088_EQ2EN (1<<1) + #define M98088_EQ1EN (1<<0) + +/* M98088_REG_4C_PWR_EN_IN */ + #define M98088_INAEN (1<<7) + #define M98088_INBEN (1<<6) + #define M98088_MBEN (1<<3) + #define M98088_ADLEN (1<<1) + #define M98088_ADREN (1<<0) + +/* M98088_REG_4D_PWR_EN_OUT */ + #define M98088_HPLEN (1<<7) + #define M98088_HPREN (1<<6) + #define M98088_HPEN ((1<<7)|(1<<6)) + #define M98088_SPLEN (1<<5) + #define M98088_SPREN (1<<4) + #define M98088_RECEN (1<<3) + #define M98088_DALEN (1<<1) + #define M98088_DAREN (1<<0) + +/* M98088_REG_51_PWR_SYS */ + #define M98088_SHDNRUN (1<<7) + #define M98088_PERFMODE (1<<3) + #define M98088_HPPLYBACK (1<<2) + #define M98088_PWRSV8K (1<<1) + #define M98088_PWRSV (1<<0) + +/* Line inputs */ +#define LINE_INA 0 +#define LINE_INB 1 + +#define M98088_COEFS_PER_BAND 5 + +#define M98088_BYTE1(w) ((w >> 8) & 0xff) +#define M98088_BYTE0(w) (w & 0xff) + +#endif -- cgit v1.1 From 1cc9e8f4c45999e6069f41521d9d391eeeccc3b3 Mon Sep 17 00:00:00 2001 From: Charles Date: Mon, 18 Oct 2010 16:22:00 +0800 Subject: ALSA: hda - Fix codec muted after rebooting from Windows Windows may leave pin power-down registers set after reboot, and this resulted in muted output on Linux. Reset these registers at initialization properly. Signed-off-by: Charles Chin Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_sigmatel.c | 3 +++ 1 file changed, 3 insertions(+) (limited to 'sound') diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c index 1a563a2..7d70f8c 100644 --- a/sound/pci/hda/patch_sigmatel.c +++ b/sound/pci/hda/patch_sigmatel.c @@ -5334,6 +5334,9 @@ static int patch_stac92hd83xxx(struct hda_codec *codec) if (spec == NULL) return -ENOMEM; + /* reset pin power-down; Windows may leave these bits after reboot */ + snd_hda_codec_write_cache(codec, codec->afg, 0, 0x7EC, 0); + snd_hda_codec_write_cache(codec, codec->afg, 0, 0x7ED, 0); codec->no_trigger_sense = 1; codec->spec = spec; spec->linear_tone_beep = 1; -- cgit v1.1 From 0589944661b9a9b9692f455fbbfce5eeda8fa7b6 Mon Sep 17 00:00:00 2001 From: Jarkko Nikula Date: Tue, 19 Oct 2010 11:10:45 +0300 Subject: ASoC: Fix I2C component device id number creation Use bitwise AND instead of logical AND when masking. Signed-off-by: Jarkko Nikula Acked-by: Liam Girdwood Signed-off-by: Mark Brown --- sound/soc/soc-core.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c index 63c80e6..862b1af 100644 --- a/sound/soc/soc-core.c +++ b/sound/soc/soc-core.c @@ -2929,7 +2929,7 @@ static inline char *fmt_single_name(struct device *dev, int *id) char tmp[NAME_SIZE]; /* create unique ID number from I2C addr and bus */ - *id = ((id1 && 0xffff) << 16) + id2; + *id = ((id1 & 0xffff) << 16) + id2; /* sanitize component name for DAI link creation */ snprintf(tmp, NAME_SIZE, "%s.%s", dev->driver->name, name); -- cgit v1.1 From c429ffbe038a649d121e6cecba5cf66777f39370 Mon Sep 17 00:00:00 2001 From: Jassi Brar Date: Tue, 19 Oct 2010 16:04:21 +0900 Subject: ASoC: WM8580: Remove useless assignment The variable is not used anyway. Signed-off-by: Jassi Brar Acked-by: Liam Girdwood Signed-off-by: Mark Brown --- sound/soc/codecs/wm8580.c | 4 ---- 1 file changed, 4 deletions(-) (limited to 'sound') diff --git a/sound/soc/codecs/wm8580.c b/sound/soc/codecs/wm8580.c index ad5987e..a2e0ed5 100644 --- a/sound/soc/codecs/wm8580.c +++ b/sound/soc/codecs/wm8580.c @@ -548,11 +548,9 @@ static int wm8580_set_paif_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt) { struct snd_soc_codec *codec = codec_dai->codec; - struct wm8580_priv *wm8580 = snd_soc_codec_get_drvdata(codec); unsigned int aifa; unsigned int aifb; int can_invert_lrclk; - int sysclk; aifa = snd_soc_read(codec, WM8580_PAIF1 + codec_dai->driver->id); aifb = snd_soc_read(codec, WM8580_PAIF3 + codec_dai->driver->id); @@ -621,8 +619,6 @@ static int wm8580_set_paif_dai_fmt(struct snd_soc_dai *codec_dai, return -EINVAL; } - sysclk = wm8580->sysclk[codec_dai->driver->id]; - snd_soc_write(codec, WM8580_PAIF1 + codec_dai->driver->id, aifa); snd_soc_write(codec, WM8580_PAIF3 + codec_dai->driver->id, aifb); -- cgit v1.1 From dd04bb12d047a4d4461772093472a40dbe171e5f Mon Sep 17 00:00:00 2001 From: Jaroslav Kysela Date: Wed, 20 Oct 2010 08:27:02 +0200 Subject: ALSA: snd-aloop - fix locking issues (running flag updates) On SMP machines, the cable->running update must be atomic, otherwise stream is not started correctly sometimes. Signed-off-by: Jaroslav Kysela --- sound/drivers/aloop.c | 32 +++++++++++++++++++------------- 1 file changed, 19 insertions(+), 13 deletions(-) (limited to 'sound') diff --git a/sound/drivers/aloop.c b/sound/drivers/aloop.c index 66786ea..38e8351 100644 --- a/sound/drivers/aloop.c +++ b/sound/drivers/aloop.c @@ -263,13 +263,17 @@ static int loopback_trigger(struct snd_pcm_substream *substream, int cmd) return err; dpcm->last_jiffies = jiffies; dpcm->pcm_rate_shift = 0; - loopback_timer_start(dpcm); + spin_lock(&cable->lock); cable->running |= (1 << substream->stream); + spin_unlock(&cable->lock); + loopback_timer_start(dpcm); if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) loopback_active_notify(dpcm); break; case SNDRV_PCM_TRIGGER_STOP: + spin_lock(&cable->lock); cable->running &= ~(1 << substream->stream); + spin_unlock(&cable->lock); loopback_timer_stop(dpcm); if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) loopback_active_notify(dpcm); @@ -454,28 +458,30 @@ static void loopback_bytepos_update(struct loopback_pcm *dpcm, } } -static void loopback_pos_update(struct loopback_cable *cable) +static unsigned int loopback_pos_update(struct loopback_cable *cable) { struct loopback_pcm *dpcm_play = cable->streams[SNDRV_PCM_STREAM_PLAYBACK]; struct loopback_pcm *dpcm_capt = cable->streams[SNDRV_PCM_STREAM_CAPTURE]; unsigned long delta_play = 0, delta_capt = 0; + unsigned int running; spin_lock(&cable->lock); - if (cable->running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) { + running = cable->running; + if (running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) { delta_play = jiffies - dpcm_play->last_jiffies; dpcm_play->last_jiffies += delta_play; } - if (cable->running & (1 << SNDRV_PCM_STREAM_CAPTURE)) { + if (running & (1 << SNDRV_PCM_STREAM_CAPTURE)) { delta_capt = jiffies - dpcm_capt->last_jiffies; dpcm_capt->last_jiffies += delta_capt; } if (delta_play == 0 && delta_capt == 0) { spin_unlock(&cable->lock); - return; + return running; } if (delta_play > delta_capt) { @@ -490,27 +496,27 @@ static void loopback_pos_update(struct loopback_cable *cable) if (delta_play == 0 && delta_capt == 0) { spin_unlock(&cable->lock); - return; + return running; } /* note delta_capt == delta_play at this moment */ loopback_bytepos_update(dpcm_capt, delta_capt, BYTEPOS_UPDATE_COPY); loopback_bytepos_update(dpcm_play, delta_play, BYTEPOS_UPDATE_POSONLY); spin_unlock(&cable->lock); + return running; } static void loopback_timer_function(unsigned long data) { struct loopback_pcm *dpcm = (struct loopback_pcm *)data; - int stream; + unsigned int running; - loopback_pos_update(dpcm->cable); - stream = dpcm->substream->stream; - if (dpcm->cable->running & (1 << stream)) + running = loopback_pos_update(dpcm->cable); + if (running & (1 << dpcm->substream->stream)) { loopback_timer_start(dpcm); - if (dpcm->period_update_pending) { - dpcm->period_update_pending = 0; - if (dpcm->cable->running & (1 << stream)) + if (dpcm->period_update_pending) { + dpcm->period_update_pending = 0; snd_pcm_period_elapsed(dpcm->substream); + } } } -- cgit v1.1 From 5de9e45fcfccdf8151a82fc1a521e7042cbe482a Mon Sep 17 00:00:00 2001 From: Jaroslav Kysela Date: Wed, 20 Oct 2010 09:33:03 +0200 Subject: ALSA: snd-aloop - add pause support Signed-off-by: Jaroslav Kysela --- sound/drivers/aloop.c | 27 ++++++++++++++++++++++----- 1 file changed, 22 insertions(+), 5 deletions(-) (limited to 'sound') diff --git a/sound/drivers/aloop.c b/sound/drivers/aloop.c index 38e8351..12b44b0 100644 --- a/sound/drivers/aloop.c +++ b/sound/drivers/aloop.c @@ -77,6 +77,7 @@ struct loopback_cable { /* flags */ unsigned int valid; unsigned int running; + unsigned int pause; }; struct loopback_setup { @@ -254,7 +255,7 @@ static int loopback_trigger(struct snd_pcm_substream *substream, int cmd) struct snd_pcm_runtime *runtime = substream->runtime; struct loopback_pcm *dpcm = runtime->private_data; struct loopback_cable *cable = dpcm->cable; - int err; + int err, stream = 1 << substream->stream; switch (cmd) { case SNDRV_PCM_TRIGGER_START: @@ -264,7 +265,8 @@ static int loopback_trigger(struct snd_pcm_substream *substream, int cmd) dpcm->last_jiffies = jiffies; dpcm->pcm_rate_shift = 0; spin_lock(&cable->lock); - cable->running |= (1 << substream->stream); + cable->running |= stream; + cable->pause &= ~stream; spin_unlock(&cable->lock); loopback_timer_start(dpcm); if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) @@ -272,12 +274,26 @@ static int loopback_trigger(struct snd_pcm_substream *substream, int cmd) break; case SNDRV_PCM_TRIGGER_STOP: spin_lock(&cable->lock); - cable->running &= ~(1 << substream->stream); + cable->running &= ~stream; + cable->pause &= ~stream; spin_unlock(&cable->lock); loopback_timer_stop(dpcm); if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) loopback_active_notify(dpcm); break; + case SNDRV_PCM_TRIGGER_PAUSE_PUSH: + spin_lock(&cable->lock); + cable->pause |= stream; + spin_unlock(&cable->lock); + loopback_timer_stop(dpcm); + break; + case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: + spin_lock(&cable->lock); + dpcm->last_jiffies = jiffies; + cable->pause &= ~stream; + spin_unlock(&cable->lock); + loopback_timer_start(dpcm); + break; default: return -EINVAL; } @@ -468,7 +484,7 @@ static unsigned int loopback_pos_update(struct loopback_cable *cable) unsigned int running; spin_lock(&cable->lock); - running = cable->running; + running = cable->running ^ cable->pause; if (running & (1 << SNDRV_PCM_STREAM_PLAYBACK)) { delta_play = jiffies - dpcm_play->last_jiffies; dpcm_play->last_jiffies += delta_play; @@ -532,7 +548,7 @@ static snd_pcm_uframes_t loopback_pointer(struct snd_pcm_substream *substream) static struct snd_pcm_hardware loopback_pcm_hardware = { .info = (SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_MMAP | - SNDRV_PCM_INFO_MMAP_VALID), + SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_PAUSE), .formats = (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE | SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE | SNDRV_PCM_FMTBIT_FLOAT_LE | SNDRV_PCM_FMTBIT_FLOAT_BE), @@ -1060,6 +1076,7 @@ static void print_substream_info(struct snd_info_buffer *buffer, } snd_iprintf(buffer, " valid: %u\n", cable->valid); snd_iprintf(buffer, " running: %u\n", cable->running); + snd_iprintf(buffer, " pause: %u\n", cable->pause); print_dpcm_info(buffer, cable->streams[0], "Playback"); print_dpcm_info(buffer, cable->streams[1], "Capture"); } -- cgit v1.1 From bf1b022588eba78c990fd58fd2471cd92c2c5683 Mon Sep 17 00:00:00 2001 From: Kailang Yang Date: Thu, 21 Oct 2010 08:49:56 +0200 Subject: ALSA: hda - Add alc_init_jacks() call to other codecs Signed-off-by: Kailang Yang Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index 788ac4b..2363f18 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -11006,6 +11006,8 @@ static int patch_alc882(struct hda_codec *codec) codec->patch_ops = alc_patch_ops; if (board_config == ALC882_AUTO) spec->init_hook = alc882_auto_init; + + alc_init_jacks(codec); #ifdef CONFIG_SND_HDA_POWER_SAVE if (!spec->loopback.amplist) spec->loopback.amplist = alc882_loopbacks; @@ -12914,6 +12916,8 @@ static int patch_alc262(struct hda_codec *codec) codec->patch_ops = alc_patch_ops; if (board_config == ALC262_AUTO) spec->init_hook = alc262_auto_init; + + alc_init_jacks(codec); #ifdef CONFIG_SND_HDA_POWER_SAVE if (!spec->loopback.amplist) spec->loopback.amplist = alc262_loopbacks; @@ -13993,6 +13997,8 @@ static int patch_alc268(struct hda_codec *codec) if (board_config == ALC268_AUTO) spec->init_hook = alc268_auto_init; + alc_init_jacks(codec); + return 0; } @@ -14359,6 +14365,7 @@ static void alc269_speaker_automute(struct hda_codec *codec) HDA_AMP_MUTE, bits); snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1, HDA_AMP_MUTE, bits); + alc_report_jack(codec, nid); } /* unsolicited event for HP jack sensing */ @@ -14695,7 +14702,6 @@ static void alc269_auto_init(struct hda_codec *codec) alc269_auto_init_hp_out(codec); alc269_auto_init_analog_input(codec); alc_auto_init_digital(codec); - alc_init_jacks(codec); if (spec->unsol_event) alc_inithook(codec); } @@ -15128,6 +15134,8 @@ static int patch_alc269(struct hda_codec *codec) #endif if (board_config == ALC269_AUTO) spec->init_hook = alc269_auto_init; + + alc_init_jacks(codec); #ifdef CONFIG_SND_HDA_POWER_SAVE if (!spec->loopback.amplist) spec->loopback.amplist = alc269_loopbacks; @@ -19393,6 +19401,8 @@ static int patch_alc662(struct hda_codec *codec) alc_pick_fixup(codec, alc662_fixup_tbl, alc662_fixups, 0); } + alc_init_jacks(codec); + #ifdef CONFIG_SND_HDA_POWER_SAVE if (!spec->loopback.amplist) spec->loopback.amplist = alc662_loopbacks; -- cgit v1.1 From 693194f3b8af349a510604dffad9bdbbcf1c7db8 Mon Sep 17 00:00:00 2001 From: Kailang Yang Date: Thu, 21 Oct 2010 08:51:48 +0200 Subject: ALSA: hda - Fix codec rename rules for ALC662-compatible codecs Signed-off-by: Kailang Yang Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_realtek.c | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c index 2363f18..5f00589 100644 --- a/sound/pci/hda/patch_realtek.c +++ b/sound/pci/hda/patch_realtek.c @@ -19309,6 +19309,7 @@ static int patch_alc662(struct hda_codec *codec) { struct alc_spec *spec; int err, board_config; + int coef; spec = kzalloc(sizeof(*spec), GFP_KERNEL); if (!spec) @@ -19320,12 +19321,15 @@ static int patch_alc662(struct hda_codec *codec) alc_fix_pll_init(codec, 0x20, 0x04, 15); - if (alc_read_coef_idx(codec, 0) == 0x8020) + coef = alc_read_coef_idx(codec, 0); + if (coef == 0x8020 || coef == 0x8011) alc_codec_rename(codec, "ALC661"); - else if ((alc_read_coef_idx(codec, 0) & (1 << 14)) && - codec->bus->pci->subsystem_vendor == 0x1025 && - spec->cdefine.platform_type == 1) + else if (coef & (1 << 14) && + codec->bus->pci->subsystem_vendor == 0x1025 && + spec->cdefine.platform_type == 1) alc_codec_rename(codec, "ALC272X"); + else if (coef == 0x4011) + alc_codec_rename(codec, "ALC656"); board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST, alc662_models, -- cgit v1.1 From 24b55c69b66eb2a122842820ec14ab215fc8572f Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Thu, 21 Oct 2010 08:55:13 +0200 Subject: ALSA: hda - Fix wrong SPDIF NID assignment for CA0110 The dig_out_nid field must take a digital-converter widget, but the current ca0110 parser passed the pin wrongly instead. Reported-by: Wai Yew CHAY Cc: Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_ca0110.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_ca0110.c b/sound/pci/hda/patch_ca0110.c index cca11fd..46c8bf4 100644 --- a/sound/pci/hda/patch_ca0110.c +++ b/sound/pci/hda/patch_ca0110.c @@ -489,7 +489,7 @@ static void parse_digital(struct hda_codec *codec) if (cfg->dig_outs && snd_hda_get_connections(codec, cfg->dig_out_pins[0], &spec->dig_out, 1) == 1) - spec->multiout.dig_out_nid = cfg->dig_out_pins[0]; + spec->multiout.dig_out_nid = spec->dig_out; } static int ca0110_parse_auto_config(struct hda_codec *codec) -- cgit v1.1 From 14d34f166c57e77e3d7f9bc8b43d349186d922c1 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Thu, 21 Oct 2010 09:03:25 +0200 Subject: ALSA: hda - Add some workarounds for Creative IBG Creative HD-audio controller chips require some workarounds: - Additional delay before RIRB response - Set the initial RIRB counter to 0xc0 The latter seems to be done in general in Windows driver, so we may use this value later for all types if it's confirmed to work better. Reported-by: Wai Yew CHAY Cc: Signed-off-by: Takashi Iwai --- sound/pci/hda/hda_intel.c | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c index 5cbea85..ee445bc 100644 --- a/sound/pci/hda/hda_intel.c +++ b/sound/pci/hda/hda_intel.c @@ -458,6 +458,7 @@ enum { AZX_DRIVER_ULI, AZX_DRIVER_NVIDIA, AZX_DRIVER_TERA, + AZX_DRIVER_CTX, AZX_DRIVER_GENERIC, AZX_NUM_DRIVERS, /* keep this as last entry */ }; @@ -473,6 +474,7 @@ static char *driver_short_names[] __devinitdata = { [AZX_DRIVER_ULI] = "HDA ULI M5461", [AZX_DRIVER_NVIDIA] = "HDA NVidia", [AZX_DRIVER_TERA] = "HDA Teradici", + [AZX_DRIVER_CTX] = "HDA Creative", [AZX_DRIVER_GENERIC] = "HD-Audio Generic", }; @@ -563,7 +565,10 @@ static void azx_init_cmd_io(struct azx *chip) /* reset the rirb hw write pointer */ azx_writew(chip, RIRBWP, ICH6_RIRBWP_RST); /* set N=1, get RIRB response interrupt for new entry */ - azx_writew(chip, RINTCNT, 1); + if (chip->driver_type == AZX_DRIVER_CTX) + azx_writew(chip, RINTCNT, 0xc0); + else + azx_writew(chip, RINTCNT, 1); /* enable rirb dma and response irq */ azx_writeb(chip, RIRBCTL, ICH6_RBCTL_DMA_EN | ICH6_RBCTL_IRQ_EN); spin_unlock_irq(&chip->reg_lock); @@ -1136,8 +1141,11 @@ static irqreturn_t azx_interrupt(int irq, void *dev_id) /* clear rirb int */ status = azx_readb(chip, RIRBSTS); if (status & RIRB_INT_MASK) { - if (status & RIRB_INT_RESPONSE) + if (status & RIRB_INT_RESPONSE) { + if (chip->driver_type == AZX_DRIVER_CTX) + udelay(80); azx_update_rirb(chip); + } azx_writeb(chip, RIRBSTS, RIRB_INT_MASK); } @@ -2784,10 +2792,10 @@ static DEFINE_PCI_DEVICE_TABLE(azx_ids) = { { PCI_DEVICE(PCI_VENDOR_ID_CREATIVE, PCI_ANY_ID), .class = PCI_CLASS_MULTIMEDIA_HD_AUDIO << 8, .class_mask = 0xffffff, - .driver_data = AZX_DRIVER_GENERIC }, + .driver_data = AZX_DRIVER_CTX }, #else /* this entry seems still valid -- i.e. without emu20kx chip */ - { PCI_DEVICE(0x1102, 0x0009), .driver_data = AZX_DRIVER_GENERIC }, + { PCI_DEVICE(0x1102, 0x0009), .driver_data = AZX_DRIVER_CTX }, #endif /* Vortex86MX */ { PCI_DEVICE(0x17f3, 0x3010), .driver_data = AZX_DRIVER_GENERIC }, -- cgit v1.1 From 00cd0bb7307970b745aefd2b3e1db929792b43bd Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Thu, 21 Oct 2010 09:57:40 +0200 Subject: ALSA: hda - Apply ideapad quirk to Acer laptops with Cxt5066 Multiple Acer laptops with the SSID 1025:04xx require the quirk mode=ideapad, so let's use mask to apply to all these. Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_conexant.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c index 80cc74b..6361f75 100644 --- a/sound/pci/hda/patch_conexant.c +++ b/sound/pci/hda/patch_conexant.c @@ -3093,8 +3093,7 @@ static const char *cxt5066_models[CXT5066_MODELS] = { }; static struct snd_pci_quirk cxt5066_cfg_tbl[] = { - SND_PCI_QUIRK(0x1025, 0x040a, "Acer", CXT5066_IDEAPAD), - SND_PCI_QUIRK(0x1025, 0x043d, "Acer", CXT5066_IDEAPAD), + SND_PCI_QUIRK_MASK(0x1025, 0xff00, 0x0400, "Acer", CXT5066_IDEAPAD), SND_PCI_QUIRK(0x1028, 0x02d8, "Dell Vostro", CXT5066_DELL_VOSTRO), SND_PCI_QUIRK(0x1028, 0x02f5, "Dell", CXT5066_DELL_LAPTOP), -- cgit v1.1 From 1aafcd4d6966453ab44587c6e1214d463f3e88e2 Mon Sep 17 00:00:00 2001 From: Dimitris Papastamos Date: Thu, 21 Oct 2010 13:19:45 +0100 Subject: ASoC: soc-core: Fix codec->name memory leak Ensure that the codec->name is freed when unregistering the codec. Signed-off-by: Dimitris Papastamos Acked-by: Liam Girdwood Signed-off-by: Mark Brown --- sound/soc/soc-core.c | 1 + 1 file changed, 1 insertion(+) (limited to 'sound') diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c index 862b1af..70d9a73 100644 --- a/sound/soc/soc-core.c +++ b/sound/soc/soc-core.c @@ -3299,6 +3299,7 @@ found: if (codec->reg_cache) kfree(codec->reg_cache); + kfree(codec->name); kfree(codec); } EXPORT_SYMBOL_GPL(snd_soc_unregister_codec); -- cgit v1.1 From 4428bc0990ba545e2ef0dea8ec1b90c256b22958 Mon Sep 17 00:00:00 2001 From: Dimitris Papastamos Date: Thu, 21 Oct 2010 12:15:56 +0100 Subject: ASoC: max98088: Staticise m98088_eq_band This function is not exported and it does not seem to be called from anywhere else therefore it should be static. Signed-off-by: Dimitris Papastamos Acked-by: Liam Girdwood Signed-off-by: Mark Brown --- sound/soc/codecs/max98088.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/soc/codecs/max98088.c b/sound/soc/codecs/max98088.c index 4186b27..e7a40d1 100644 --- a/sound/soc/codecs/max98088.c +++ b/sound/soc/codecs/max98088.c @@ -613,7 +613,7 @@ static int max98088_volatile_register(unsigned int reg) /* * Load equalizer DSP coefficient configurations registers */ -void m98088_eq_band(struct snd_soc_codec *codec, unsigned int dai, +static void m98088_eq_band(struct snd_soc_codec *codec, unsigned int dai, unsigned int band, u16 *coefs) { unsigned int eq_reg; -- cgit v1.1 From a74ccea51d4314632a81d568d59bf885e5b09d93 Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Fri, 22 Oct 2010 15:52:34 +0200 Subject: ALSA: hda - Fix wrong TLV mute bit for STAC/IDT codecs The bit value set for TLV mute was wrong in commit de8c85f7840e5e29629de95f5af24297fb325e0b, which resulted in bogus dB ranges that screw up PulseAudio. Corrected with the right constant. Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_sigmatel.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c index 7d70f8c..7f487ab 100644 --- a/sound/pci/hda/patch_sigmatel.c +++ b/sound/pci/hda/patch_sigmatel.c @@ -32,6 +32,7 @@ #include #include #include +#include #include "hda_codec.h" #include "hda_local.h" #include "hda_beep.h" @@ -1145,7 +1146,7 @@ static int stac92xx_build_controls(struct hda_codec *codec) /* correct volume offset */ vmaster_tlv[2] += vmaster_tlv[3] * spec->volume_offset; /* minimum value is actually mute */ - vmaster_tlv[3] |= 0x1000; + vmaster_tlv[3] |= TLV_DB_SCALE_MUTE; err = snd_hda_add_vmaster(codec, "Master Playback Volume", vmaster_tlv, slave_vols); if (err < 0) -- cgit v1.1 From 62b7e5e09bcb854ff05e6ee1aa161f8283dc36ee Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Fri, 22 Oct 2010 17:15:47 +0200 Subject: ALSA: hda - Add workarounds for CT-IBG controllers Creative IBG controllers require the playback stream-tags to be started from 1, instead of capture+1. Otherwise the stream stalls. Reported-by: Wai Yew CHAY Cc: Signed-off-by: Takashi Iwai --- sound/pci/hda/hda_codec.c | 5 ++++- sound/pci/hda/hda_intel.c | 9 +++++++-- 2 files changed, 11 insertions(+), 3 deletions(-) (limited to 'sound') diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c index ee134a2..13c1e77 100644 --- a/sound/pci/hda/hda_codec.c +++ b/sound/pci/hda/hda_codec.c @@ -1216,6 +1216,7 @@ void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid, struct hda_codec *c; struct hda_cvt_setup *p; unsigned int oldval, newval; + int type; int i; if (!nid) @@ -1254,10 +1255,12 @@ void snd_hda_codec_setup_stream(struct hda_codec *codec, hda_nid_t nid, p->dirty = 0; /* make other inactive cvts with the same stream-tag dirty */ + type = get_wcaps_type(get_wcaps(codec, nid)); list_for_each_entry(c, &codec->bus->codec_list, list) { for (i = 0; i < c->cvt_setups.used; i++) { p = snd_array_elem(&c->cvt_setups, i); - if (!p->active && p->stream_tag == stream_tag) + if (!p->active && p->stream_tag == stream_tag && + get_wcaps_type(get_wcaps(codec, p->nid)) == type) p->dirty = 1; } } diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c index ee445bc..21aa9b0 100644 --- a/sound/pci/hda/hda_intel.c +++ b/sound/pci/hda/hda_intel.c @@ -1652,7 +1652,7 @@ static int azx_pcm_prepare(struct snd_pcm_substream *substream) struct azx_dev *azx_dev = get_azx_dev(substream); struct hda_pcm_stream *hinfo = apcm->hinfo[substream->stream]; struct snd_pcm_runtime *runtime = substream->runtime; - unsigned int bufsize, period_bytes, format_val; + unsigned int bufsize, period_bytes, format_val, stream_tag; int err; azx_stream_reset(chip, azx_dev); @@ -1694,7 +1694,12 @@ static int azx_pcm_prepare(struct snd_pcm_substream *substream) else azx_dev->fifo_size = 0; - return snd_hda_codec_prepare(apcm->codec, hinfo, azx_dev->stream_tag, + stream_tag = azx_dev->stream_tag; + /* CA-IBG chips need the playback stream starting from 1 */ + if (chip->driver_type == AZX_DRIVER_CTX && + stream_tag > chip->capture_streams) + stream_tag -= chip->capture_streams; + return snd_hda_codec_prepare(apcm->codec, hinfo, stream_tag, azx_dev->format_val, substream); } -- cgit v1.1 From c7f572168fc4840727c9bda955b7f103922209cd Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Fri, 22 Oct 2010 18:20:48 +0200 Subject: ALSA: usb-audio: add Novation Launchpad support Add a quirk entry for the Novation Launchpad USB MIDI controller. QUIRK_MIDI_FASTLANE gets renamed to *_RAW_BYTES because this quirk type is now shared by different devices. Signed-off-by: Clemens Ladisch Tested-by: Jakob Flierl Signed-off-by: Takashi Iwai --- sound/usb/midi.c | 7 ++++--- sound/usb/quirks-table.h | 11 ++++++++++- sound/usb/quirks.c | 2 +- sound/usb/usbaudio.h | 2 +- 4 files changed, 16 insertions(+), 6 deletions(-) (limited to 'sound') diff --git a/sound/usb/midi.c b/sound/usb/midi.c index 156cd07..25bce7e 100644 --- a/sound/usb/midi.c +++ b/sound/usb/midi.c @@ -784,7 +784,7 @@ static struct usb_protocol_ops snd_usbmidi_novation_ops = { }; /* - * "raw" protocol: used by the MOTU FastLane. + * "raw" protocol: just move raw MIDI bytes from/to the endpoint */ static void snd_usbmidi_raw_input(struct snd_usb_midi_in_endpoint* ep, @@ -2122,7 +2122,7 @@ int snd_usbmidi_create(struct snd_card *card, umidi->usb_protocol_ops = &snd_usbmidi_novation_ops; err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints); break; - case QUIRK_MIDI_FASTLANE: + case QUIRK_MIDI_RAW_BYTES: umidi->usb_protocol_ops = &snd_usbmidi_raw_ops; /* * Interface 1 contains isochronous endpoints, but with the same @@ -2133,7 +2133,8 @@ int snd_usbmidi_create(struct snd_card *card, * interface 0, so we have to make sure that the USB core looks * again at interface 0 by calling usb_set_interface() on it. */ - usb_set_interface(umidi->dev, 0, 0); + if (umidi->usb_id == USB_ID(0x07fd, 0x0001)) /* MOTU Fastlane */ + usb_set_interface(umidi->dev, 0, 0); err = snd_usbmidi_detect_per_port_endpoints(umidi, endpoints); break; case QUIRK_MIDI_EMAGIC: diff --git a/sound/usb/quirks-table.h b/sound/usb/quirks-table.h index 682e3e0..ad7079d 100644 --- a/sound/usb/quirks-table.h +++ b/sound/usb/quirks-table.h @@ -2078,7 +2078,7 @@ YAMAHA_DEVICE(0x7010, "UB99"), .data = & (const struct snd_usb_audio_quirk[]) { { .ifnum = 0, - .type = QUIRK_MIDI_FASTLANE + .type = QUIRK_MIDI_RAW_BYTES }, { .ifnum = 1, @@ -2227,6 +2227,15 @@ YAMAHA_DEVICE(0x7010, "UB99"), } }, { + USB_DEVICE(0x1235, 0x000e), + .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { + /* .vendor_name = "Novation", */ + /* .product_name = "Launchpad", */ + .ifnum = 0, + .type = QUIRK_MIDI_RAW_BYTES + } +}, +{ USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661), .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { .vendor_name = "Novation", diff --git a/sound/usb/quirks.c b/sound/usb/quirks.c index 9a9da09..cf8bf08 100644 --- a/sound/usb/quirks.c +++ b/sound/usb/quirks.c @@ -287,7 +287,7 @@ int snd_usb_create_quirk(struct snd_usb_audio *chip, [QUIRK_MIDI_YAMAHA] = create_any_midi_quirk, [QUIRK_MIDI_MIDIMAN] = create_any_midi_quirk, [QUIRK_MIDI_NOVATION] = create_any_midi_quirk, - [QUIRK_MIDI_FASTLANE] = create_any_midi_quirk, + [QUIRK_MIDI_RAW_BYTES] = create_any_midi_quirk, [QUIRK_MIDI_EMAGIC] = create_any_midi_quirk, [QUIRK_MIDI_CME] = create_any_midi_quirk, [QUIRK_MIDI_AKAI] = create_any_midi_quirk, diff --git a/sound/usb/usbaudio.h b/sound/usb/usbaudio.h index 24d3319..db3eb21 100644 --- a/sound/usb/usbaudio.h +++ b/sound/usb/usbaudio.h @@ -70,7 +70,7 @@ enum quirk_type { QUIRK_MIDI_YAMAHA, QUIRK_MIDI_MIDIMAN, QUIRK_MIDI_NOVATION, - QUIRK_MIDI_FASTLANE, + QUIRK_MIDI_RAW_BYTES, QUIRK_MIDI_EMAGIC, QUIRK_MIDI_CME, QUIRK_MIDI_AKAI, -- cgit v1.1 From 39aba963d937edb20db7d9d93e6dda5d2adfdcdd Mon Sep 17 00:00:00 2001 From: Kay Sievers Date: Sat, 4 Sep 2010 22:33:14 -0700 Subject: driver core: remove CONFIG_SYSFS_DEPRECATED_V2 but keep it for block devices This patch removes the old CONFIG_SYSFS_DEPRECATED_V2 config option, but it keeps the logic around to handle block devices in the old manner as some people like to run new kernel versions on old (pre 2007/2008) distros. Signed-off-by: Kay Sievers Cc: Jens Axboe Cc: Stephen Hemminger Cc: "Eric W. Biederman" Cc: Alan Stern Cc: "James E.J. Bottomley" Cc: Andrew Morton Cc: Alexey Kuznetsov Cc: Randy Dunlap Cc: Tejun Heo Cc: "David S. Miller" Cc: Jaroslav Kysela Cc: Takashi Iwai Cc: Ingo Molnar Cc: Peter Zijlstra Cc: David Howells Signed-off-by: Greg Kroah-Hartman --- sound/core/init.c | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) (limited to 'sound') diff --git a/sound/core/init.c b/sound/core/init.c index ec4a50c..f7c3df8 100644 --- a/sound/core/init.c +++ b/sound/core/init.c @@ -395,12 +395,10 @@ int snd_card_disconnect(struct snd_card *card) snd_printk(KERN_ERR "not all devices for card %i can be disconnected\n", card->number); snd_info_card_disconnect(card); -#ifndef CONFIG_SYSFS_DEPRECATED if (card->card_dev) { device_unregister(card->card_dev); card->card_dev = NULL; } -#endif #ifdef CONFIG_PM wake_up(&card->power_sleep); #endif @@ -573,7 +571,6 @@ void snd_card_set_id(struct snd_card *card, const char *nid) } EXPORT_SYMBOL(snd_card_set_id); -#ifndef CONFIG_SYSFS_DEPRECATED static ssize_t card_id_show_attr(struct device *dev, struct device_attribute *attr, char *buf) @@ -630,7 +627,6 @@ card_number_show_attr(struct device *dev, static struct device_attribute card_number_attrs = __ATTR(number, S_IRUGO, card_number_show_attr, NULL); -#endif /* CONFIG_SYSFS_DEPRECATED */ /** * snd_card_register - register the soundcard @@ -649,7 +645,7 @@ int snd_card_register(struct snd_card *card) if (snd_BUG_ON(!card)) return -EINVAL; -#ifndef CONFIG_SYSFS_DEPRECATED + if (!card->card_dev) { card->card_dev = device_create(sound_class, card->dev, MKDEV(0, 0), card, @@ -657,7 +653,7 @@ int snd_card_register(struct snd_card *card) if (IS_ERR(card->card_dev)) card->card_dev = NULL; } -#endif + if ((err = snd_device_register_all(card)) < 0) return err; mutex_lock(&snd_card_mutex); @@ -674,7 +670,6 @@ int snd_card_register(struct snd_card *card) if (snd_mixer_oss_notify_callback) snd_mixer_oss_notify_callback(card, SND_MIXER_OSS_NOTIFY_REGISTER); #endif -#ifndef CONFIG_SYSFS_DEPRECATED if (card->card_dev) { err = device_create_file(card->card_dev, &card_id_attrs); if (err < 0) @@ -683,7 +678,7 @@ int snd_card_register(struct snd_card *card) if (err < 0) return err; } -#endif + return 0; } -- cgit v1.1 From 23156e8faed5df60364976bffea0711a4f38d88a Mon Sep 17 00:00:00 2001 From: Andy Owen Date: Sat, 23 Oct 2010 22:12:28 +1100 Subject: ALSA: ca0106 - add Sound Blaster 5.1vx info. Signed-off-by: Andy Owen Signed-off-by: Takashi Iwai --- sound/pci/ca0106/ca0106_main.c | 10 ++++++++++ 1 file changed, 10 insertions(+) (limited to 'sound') diff --git a/sound/pci/ca0106/ca0106_main.c b/sound/pci/ca0106/ca0106_main.c index 8e69620..6dc9a5d 100644 --- a/sound/pci/ca0106/ca0106_main.c +++ b/sound/pci/ca0106/ca0106_main.c @@ -239,6 +239,16 @@ static struct snd_ca0106_details ca0106_chip_details[] = { .gpio_type = 1, .i2c_adc = 1, .spi_dac = 1 } , + /* Sound Blaster 5.1vx + * Tested: Playback on front, rear, center/lfe speakers + * Not-Tested: Capture + */ + { .serial = 0x10041102, + .name = "Sound Blaster 5.1vx [SB1070]", + .gpio_type = 1, + .i2c_adc = 0, + .spi_dac = 1 + } , /* MSI K8N Diamond Motherboard with onboard SB Live 24bit without AC97 */ /* SB0438 * CTRL:CA0106-DAT -- cgit v1.1 From 51630142ed7da31618c0aca8f2767824834e18a8 Mon Sep 17 00:00:00 2001 From: Andy Owen Date: Sat, 23 Oct 2010 22:12:29 +1100 Subject: ALSA: ca0106: Pull out dac powering routine into separate function. This is ground work for a future commit where cards (such as the Sound Blaster 5.1vx) have different mappings between dacs and channels. Signed-off-by: Andy Owen Signed-off-by: Takashi Iwai --- sound/pci/ca0106/ca0106_main.c | 39 +++++++++++++++++++++++++++------------ 1 file changed, 27 insertions(+), 12 deletions(-) (limited to 'sound') diff --git a/sound/pci/ca0106/ca0106_main.c b/sound/pci/ca0106/ca0106_main.c index 6dc9a5d..22d2f6b 100644 --- a/sound/pci/ca0106/ca0106_main.c +++ b/sound/pci/ca0106/ca0106_main.c @@ -514,6 +514,23 @@ static void restore_spdif_bits(struct snd_ca0106 *chip, int idx) } } +static int snd_ca0106_pcm_power_dac(struct snd_ca0106 *chip, int channel_id, + int power) +{ + if (chip->details->spi_dac) { + const int reg = spi_dacd_reg[channel_id]; + + if (power) + /* Power up */ + chip->spi_dac_reg[reg] &= ~spi_dacd_bit[channel_id]; + else + /* Power down */ + chip->spi_dac_reg[reg] |= spi_dacd_bit[channel_id]; + return snd_ca0106_spi_write(chip, chip->spi_dac_reg[reg]); + } + return 0; +} + /* open_playback callback */ static int snd_ca0106_pcm_open_playback_channel(struct snd_pcm_substream *substream, int channel_id) @@ -553,12 +570,9 @@ static int snd_ca0106_pcm_open_playback_channel(struct snd_pcm_substream *substr return err; snd_pcm_set_sync(substream); - if (chip->details->spi_dac && channel_id != PCM_FRONT_CHANNEL) { - const int reg = spi_dacd_reg[channel_id]; - - /* Power up dac */ - chip->spi_dac_reg[reg] &= ~spi_dacd_bit[channel_id]; - err = snd_ca0106_spi_write(chip, chip->spi_dac_reg[reg]); + /* Front channel dac should already be on */ + if (channel_id != PCM_FRONT_CHANNEL) { + err = snd_ca0106_pcm_power_dac(chip, channel_id, 1); if (err < 0) return err; } @@ -578,13 +592,14 @@ static int snd_ca0106_pcm_close_playback(struct snd_pcm_substream *substream) restore_spdif_bits(chip, epcm->channel_id); - if (chip->details->spi_dac && epcm->channel_id != PCM_FRONT_CHANNEL) { - const int reg = spi_dacd_reg[epcm->channel_id]; - - /* Power down DAC */ - chip->spi_dac_reg[reg] |= spi_dacd_bit[epcm->channel_id]; - snd_ca0106_spi_write(chip, chip->spi_dac_reg[reg]); + /* Front channel dac should stay on */ + if (epcm->channel_id != PCM_FRONT_CHANNEL) { + int err; + err = snd_ca0106_pcm_power_dac(chip, epcm->channel_id, 0); + if (err < 0) + return err; } + /* FIXME: maybe zero others */ return 0; } -- cgit v1.1 From 9bfd94132dd97b76af41024eb7e980a5cb41afee Mon Sep 17 00:00:00 2001 From: Andy Owen Date: Sat, 23 Oct 2010 22:12:30 +1100 Subject: ALSA: ca0106: Move enabling of front dac out of hardcoded setup sequence. Signed-off-by: Andy Owen Signed-off-by: Takashi Iwai --- sound/pci/ca0106/ca0106_main.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/pci/ca0106/ca0106_main.c b/sound/pci/ca0106/ca0106_main.c index 22d2f6b..46ae98d 100644 --- a/sound/pci/ca0106/ca0106_main.c +++ b/sound/pci/ca0106/ca0106_main.c @@ -1385,7 +1385,7 @@ static unsigned int spi_dac_init[] = { SPI_REG(12, 0x00), SPI_REG(SPI_LDA4_REG, SPI_DA_BIT_0dB), SPI_REG(SPI_RDA4_REG, SPI_DA_BIT_0dB | SPI_DA_BIT_UPDATE), - SPI_REG(SPI_DACD4_REG, 0x00), + SPI_REG(SPI_DACD4_REG, SPI_DACD4_BIT), }; static unsigned int i2c_adc_init[][2] = { @@ -1576,6 +1576,9 @@ static void ca0106_init_chip(struct snd_ca0106 *chip, int resume) if (reg < ARRAY_SIZE(chip->spi_dac_reg)) chip->spi_dac_reg[reg] = spi_dac_init[n]; } + + /* Enable front dac only */ + snd_ca0106_pcm_power_dac(chip, PCM_FRONT_CHANNEL, 1); } } -- cgit v1.1 From 861391d3a037fab38020c741baffdb147e1c732a Mon Sep 17 00:00:00 2001 From: Andy Owen Date: Sat, 23 Oct 2010 22:12:31 +1100 Subject: ALSA: ca0106: Create a nice spot for mapping channels to dacs. This is to allow a future patch to have card specific mappings between dacs, which is required since the Sound Blaster 5.1vx seems to have a different mapping to what was previously used. Signed-off-by: Andy Owen Signed-off-by: Takashi Iwai --- sound/pci/ca0106/ca0106_main.c | 40 +++++++++++++++++++++++++++++----------- 1 file changed, 29 insertions(+), 11 deletions(-) (limited to 'sound') diff --git a/sound/pci/ca0106/ca0106_main.c b/sound/pci/ca0106/ca0106_main.c index 46ae98d..da91003 100644 --- a/sound/pci/ca0106/ca0106_main.c +++ b/sound/pci/ca0106/ca0106_main.c @@ -493,16 +493,18 @@ static void snd_ca0106_pcm_free_substream(struct snd_pcm_runtime *runtime) } static const int spi_dacd_reg[] = { - [PCM_FRONT_CHANNEL] = SPI_DACD4_REG, - [PCM_REAR_CHANNEL] = SPI_DACD0_REG, - [PCM_CENTER_LFE_CHANNEL]= SPI_DACD2_REG, - [PCM_UNKNOWN_CHANNEL] = SPI_DACD1_REG, + SPI_DACD0_REG, + SPI_DACD1_REG, + SPI_DACD2_REG, + 0, + SPI_DACD4_REG, }; static const int spi_dacd_bit[] = { - [PCM_FRONT_CHANNEL] = SPI_DACD4_BIT, - [PCM_REAR_CHANNEL] = SPI_DACD0_BIT, - [PCM_CENTER_LFE_CHANNEL]= SPI_DACD2_BIT, - [PCM_UNKNOWN_CHANNEL] = SPI_DACD1_BIT, + SPI_DACD0_BIT, + SPI_DACD1_BIT, + SPI_DACD2_BIT, + 0, + SPI_DACD4_BIT, }; static void restore_spdif_bits(struct snd_ca0106 *chip, int idx) @@ -514,18 +516,34 @@ static void restore_spdif_bits(struct snd_ca0106 *chip, int idx) } } +static int snd_ca0106_channel_dac(struct snd_ca0106_details *details, + int channel_id) +{ + switch (channel_id) { + case PCM_FRONT_CHANNEL: return 4; + case PCM_REAR_CHANNEL: return 0; + case PCM_CENTER_LFE_CHANNEL: return 2; + case PCM_UNKNOWN_CHANNEL: return 1; + } + snd_printk(KERN_DEBUG "ca0106: unknown channel_id %d\n", channel_id); + return 0; +} + static int snd_ca0106_pcm_power_dac(struct snd_ca0106 *chip, int channel_id, int power) { if (chip->details->spi_dac) { - const int reg = spi_dacd_reg[channel_id]; + const int dac = snd_ca0106_channel_dac(chip->details, + channel_id); + const int reg = spi_dacd_reg[dac]; + const int bit = spi_dacd_bit[dac]; if (power) /* Power up */ - chip->spi_dac_reg[reg] &= ~spi_dacd_bit[channel_id]; + chip->spi_dac_reg[reg] &= ~bit; else /* Power down */ - chip->spi_dac_reg[reg] |= spi_dacd_bit[channel_id]; + chip->spi_dac_reg[reg] |= bit; return snd_ca0106_spi_write(chip, chip->spi_dac_reg[reg]); } return 0; -- cgit v1.1 From 6fef153afa8b25f81417488150e04db7c6b0b229 Mon Sep 17 00:00:00 2001 From: Andy Owen Date: Sat, 23 Oct 2010 22:12:32 +1100 Subject: ALSA: ca0106: Allow different sound cards to use different SPI channel mappings. Signed-off-by: Andy Owen Signed-off-by: Takashi Iwai --- sound/pci/ca0106/ca0106.h | 5 +++-- sound/pci/ca0106/ca0106_main.c | 26 ++++++++++++++++---------- sound/pci/ca0106/ca0106_mixer.c | 4 ++-- 3 files changed, 21 insertions(+), 14 deletions(-) (limited to 'sound') diff --git a/sound/pci/ca0106/ca0106.h b/sound/pci/ca0106/ca0106.h index 14b8d9a..f19c110 100644 --- a/sound/pci/ca0106/ca0106.h +++ b/sound/pci/ca0106/ca0106.h @@ -670,8 +670,9 @@ struct snd_ca0106_details { gpio_type = 2 -> shared side-out/line-in. */ int i2c_adc; /* with i2c_adc=1, the driver adds some capture volume controls, phone, mic, line-in and aux. */ - int spi_dac; /* spi_dac=1 adds the mute switch for each analog - output, front, rear, etc. */ + u16 spi_dac; /* spi_dac = 0 -> no spi interface for DACs + spi_dac = 0x + -> specifies DAC id for each channel pair. */ }; // definition of the chip-specific record diff --git a/sound/pci/ca0106/ca0106_main.c b/sound/pci/ca0106/ca0106_main.c index da91003..d2d12c0 100644 --- a/sound/pci/ca0106/ca0106_main.c +++ b/sound/pci/ca0106/ca0106_main.c @@ -227,7 +227,7 @@ static struct snd_ca0106_details ca0106_chip_details[] = { .name = "Audigy SE [SB0570]", .gpio_type = 1, .i2c_adc = 1, - .spi_dac = 1 } , + .spi_dac = 0x4021 } , /* New Audigy LS. Has a different DAC. */ /* SB0570: * CTRL:CA0106-DAT @@ -238,7 +238,7 @@ static struct snd_ca0106_details ca0106_chip_details[] = { .name = "Audigy SE OEM [SB0570a]", .gpio_type = 1, .i2c_adc = 1, - .spi_dac = 1 } , + .spi_dac = 0x4021 } , /* Sound Blaster 5.1vx * Tested: Playback on front, rear, center/lfe speakers * Not-Tested: Capture @@ -247,7 +247,7 @@ static struct snd_ca0106_details ca0106_chip_details[] = { .name = "Sound Blaster 5.1vx [SB1070]", .gpio_type = 1, .i2c_adc = 0, - .spi_dac = 1 + .spi_dac = 0x0124 } , /* MSI K8N Diamond Motherboard with onboard SB Live 24bit without AC97 */ /* SB0438 @@ -264,7 +264,7 @@ static struct snd_ca0106_details ca0106_chip_details[] = { .name = "MSI K8N Diamond MB", .gpio_type = 2, .i2c_adc = 1, - .spi_dac = 1 } , + .spi_dac = 0x4021 } , /* Giga-byte GA-G1975X mobo * Novell bnc#395807 */ @@ -520,12 +520,18 @@ static int snd_ca0106_channel_dac(struct snd_ca0106_details *details, int channel_id) { switch (channel_id) { - case PCM_FRONT_CHANNEL: return 4; - case PCM_REAR_CHANNEL: return 0; - case PCM_CENTER_LFE_CHANNEL: return 2; - case PCM_UNKNOWN_CHANNEL: return 1; + case PCM_FRONT_CHANNEL: + return (details->spi_dac & 0xf000) >> (4 * 3); + case PCM_REAR_CHANNEL: + return (details->spi_dac & 0x0f00) >> (4 * 2); + case PCM_CENTER_LFE_CHANNEL: + return (details->spi_dac & 0x00f0) >> (4 * 1); + case PCM_UNKNOWN_CHANNEL: + return (details->spi_dac & 0x000f) >> (4 * 0); + default: + snd_printk(KERN_DEBUG "ca0106: unknown channel_id %d\n", + channel_id); } - snd_printk(KERN_DEBUG "ca0106: unknown channel_id %d\n", channel_id); return 0; } @@ -1582,7 +1588,7 @@ static void ca0106_init_chip(struct snd_ca0106 *chip, int resume) /* snd_ca0106_i2c_write(chip, ADC_MUX, ADC_MUX_LINEIN); */ } - if (chip->details->spi_dac == 1) { + if (chip->details->spi_dac) { /* The SB0570 use SPI to control DAC. */ int size, n; diff --git a/sound/pci/ca0106/ca0106_mixer.c b/sound/pci/ca0106/ca0106_mixer.c index 85fd315..b522401 100644 --- a/sound/pci/ca0106/ca0106_mixer.c +++ b/sound/pci/ca0106/ca0106_mixer.c @@ -832,7 +832,7 @@ int __devinit snd_ca0106_mixer(struct snd_ca0106 *emu) if (err < 0) return err; } - if (emu->details->spi_dac == 1) + if (emu->details->spi_dac) ADD_CTLS(emu, snd_ca0106_volume_spi_dac_ctls); /* Create virtual master controls */ @@ -845,7 +845,7 @@ int __devinit snd_ca0106_mixer(struct snd_ca0106 *emu) return err; add_slaves(card, vmaster, slave_vols); - if (emu->details->spi_dac == 1) { + if (emu->details->spi_dac) { vmaster = snd_ctl_make_virtual_master("Master Playback Switch", NULL); if (!vmaster) -- cgit v1.1 From 64e5310a249ba641ab6a00c6c1d61146d51b7984 Mon Sep 17 00:00:00 2001 From: Andy Owen Date: Sat, 23 Oct 2010 22:12:33 +1100 Subject: ALSA: ca0106: Use card specific dac id for mute controls. Signed-off-by: Andy Owen Signed-off-by: Takashi Iwai --- sound/pci/ca0106/ca0106_mixer.c | 91 +++++++++++++++++++++++++++++++---------- 1 file changed, 69 insertions(+), 22 deletions(-) (limited to 'sound') diff --git a/sound/pci/ca0106/ca0106_mixer.c b/sound/pci/ca0106/ca0106_mixer.c index b522401..630aa49 100644 --- a/sound/pci/ca0106/ca0106_mixer.c +++ b/sound/pci/ca0106/ca0106_mixer.c @@ -676,28 +676,65 @@ static struct snd_kcontrol_new snd_ca0106_volume_i2c_adc_ctls[] __devinitdata = I2C_VOLUME("Aux Capture Volume", 3), }; -#define SPI_SWITCH(xname,reg,bit) \ -{ \ - .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \ - .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \ - .info = spi_mute_info, \ - .get = spi_mute_get, \ - .put = spi_mute_put, \ - .private_value = (reg<spi_dac & 0xf000) >> (4 * 3); + break; + case PCM_REAR_CHANNEL: + spi_switch.name = "Analog Rear Playback Switch"; + dac_id = (details->spi_dac & 0x0f00) >> (4 * 2); + break; + case PCM_CENTER_LFE_CHANNEL: + spi_switch.name = "Analog Center/LFE Playback Switch"; + dac_id = (details->spi_dac & 0x00f0) >> (4 * 1); + break; + case PCM_UNKNOWN_CHANNEL: + spi_switch.name = "Analog Side Playback Switch"; + dac_id = (details->spi_dac & 0x000f) >> (4 * 0); + break; + default: + /* Unused channel */ + spi_switch.name = NULL; + dac_id = 0; + } + reg = spi_dmute_reg[dac_id]; + bit = spi_dmute_bit[dac_id]; + + spi_switch.private_value = (reg << SPI_REG_SHIFT) | bit; + + return spi_switch; +} + static int __devinit remove_ctl(struct snd_card *card, const char *name) { struct snd_ctl_elem_id id; @@ -832,8 +869,18 @@ int __devinit snd_ca0106_mixer(struct snd_ca0106 *emu) if (err < 0) return err; } - if (emu->details->spi_dac) - ADD_CTLS(emu, snd_ca0106_volume_spi_dac_ctls); + if (emu->details->spi_dac) { + int i; + for (i = 0;; i++) { + struct snd_kcontrol_new ctl; + ctl = snd_ca0106_volume_spi_dac_ctl(emu->details, i); + if (!ctl.name) + break; + err = snd_ctl_add(card, snd_ctl_new1(&ctl, emu)); + if (err < 0) + return err; + } + } /* Create virtual master controls */ vmaster = snd_ctl_make_virtual_master("Master Playback Volume", -- cgit v1.1 From 97c44b2dbd0060e2e6bd56236eb638ab02ec7f30 Mon Sep 17 00:00:00 2001 From: Mandar Joshi Date: Sun, 24 Oct 2010 04:07:00 +0000 Subject: ALSA: usb - Creative USB X-Fi volume knob support Adds an entry for Creative USB X-Fi to the rc_config array in mixer_quirks.c to allow use of volume knob on the device. The action of the volume knob is received by lirc when its using the alsa_usb driver. Signed-off-by: Mandar Joshi Signed-off-by: Takashi Iwai --- sound/usb/mixer_quirks.c | 1 + 1 file changed, 1 insertion(+) (limited to 'sound') diff --git a/sound/usb/mixer_quirks.c b/sound/usb/mixer_quirks.c index e7df1e5..7dae05d 100644 --- a/sound/usb/mixer_quirks.c +++ b/sound/usb/mixer_quirks.c @@ -60,6 +60,7 @@ static const struct rc_config { { USB_ID(0x041e, 0x3000), 0, 1, 2, 1, 18, 0x0013 }, /* Extigy */ { USB_ID(0x041e, 0x3020), 2, 1, 6, 6, 18, 0x0013 }, /* Audigy 2 NX */ { USB_ID(0x041e, 0x3040), 2, 2, 6, 6, 2, 0x6e91 }, /* Live! 24-bit */ + { USB_ID(0x041e, 0x3042), 0, 1, 1, 1, 1, 0x000d }, /* Usb X-Fi */ { USB_ID(0x041e, 0x3048), 2, 2, 6, 6, 2, 0x6e91 }, /* Toshiba SB0500 */ }; -- cgit v1.1 From 0e7adbe263f89ea2ef15b5af5e80a812b2a85025 Mon Sep 17 00:00:00 2001 From: Takashi Iwai Date: Mon, 25 Oct 2010 10:37:11 +0200 Subject: ALSA: hda - Disable sticky PCM stream assignment for AD codecs The sticky PCM stream assignment introduced in 2.6.36 kernel seems causing problems on AD codecs. At some time later, the streaming no longer works by unknown reason. A simple workaround is to disable sticky-assignment for these codecs. Tested-by: Vasily Khoruzhick Cc: Signed-off-by: Takashi Iwai --- sound/pci/hda/hda_codec.c | 3 +++ sound/pci/hda/hda_codec.h | 1 + sound/pci/hda/patch_analog.c | 7 +++++++ 3 files changed, 11 insertions(+) (limited to 'sound') diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c index 13c1e77..644e3f1 100644 --- a/sound/pci/hda/hda_codec.c +++ b/sound/pci/hda/hda_codec.c @@ -1284,6 +1284,9 @@ void __snd_hda_codec_cleanup_stream(struct hda_codec *codec, hda_nid_t nid, if (!nid) return; + if (codec->no_sticky_stream) + do_now = 1; + snd_printdd("hda_codec_cleanup_stream: NID=0x%x\n", nid); p = get_hda_cvt_setup(codec, nid); if (p) { diff --git a/sound/pci/hda/hda_codec.h b/sound/pci/hda/hda_codec.h index ebf8eb02..fdf8d44 100644 --- a/sound/pci/hda/hda_codec.h +++ b/sound/pci/hda/hda_codec.h @@ -850,6 +850,7 @@ struct hda_codec { unsigned int pin_amp_workaround:1; /* pin out-amp takes index * (e.g. Conexant codecs) */ + unsigned int no_sticky_stream:1; /* no sticky-PCM stream assignment */ unsigned int pins_shutup:1; /* pins are shut up */ unsigned int no_trigger_sense:1; /* don't trigger at pin-sensing */ #ifdef CONFIG_SND_HDA_POWER_SAVE diff --git a/sound/pci/hda/patch_analog.c b/sound/pci/hda/patch_analog.c index 507523d..f7ff3f7 100644 --- a/sound/pci/hda/patch_analog.c +++ b/sound/pci/hda/patch_analog.c @@ -1276,6 +1276,7 @@ static int patch_ad1986a(struct hda_codec *codec) spec->multiout.no_share_stream = 1; codec->no_trigger_sense = 1; + codec->no_sticky_stream = 1; return 0; } @@ -1463,6 +1464,7 @@ static int patch_ad1983(struct hda_codec *codec) codec->patch_ops = ad198x_patch_ops; codec->no_trigger_sense = 1; + codec->no_sticky_stream = 1; return 0; } @@ -1917,6 +1919,7 @@ static int patch_ad1981(struct hda_codec *codec) } codec->no_trigger_sense = 1; + codec->no_sticky_stream = 1; return 0; } @@ -3236,6 +3239,7 @@ static int patch_ad1988(struct hda_codec *codec) spec->vmaster_nid = 0x04; codec->no_trigger_sense = 1; + codec->no_sticky_stream = 1; return 0; } @@ -3450,6 +3454,7 @@ static int patch_ad1884(struct hda_codec *codec) codec->patch_ops = ad198x_patch_ops; codec->no_trigger_sense = 1; + codec->no_sticky_stream = 1; return 0; } @@ -4423,6 +4428,7 @@ static int patch_ad1884a(struct hda_codec *codec) } codec->no_trigger_sense = 1; + codec->no_sticky_stream = 1; return 0; } @@ -4762,6 +4768,7 @@ static int patch_ad1882(struct hda_codec *codec) } codec->no_trigger_sense = 1; + codec->no_sticky_stream = 1; return 0; } -- cgit v1.1 From 335e3b8687fa6832bd6a033f2c705786e4bfb92c Mon Sep 17 00:00:00 2001 From: Vitaliy Kulikov Date: Fri, 22 Oct 2010 18:38:31 -0500 Subject: ALSA: hda - Change BTL amp level on some HP notebooks Some HP laptops have lower amplifier levels for speakers in comparison with headphone outputs. This patch changes the BTL amp level for these machines to balance both the speaker and headphone output levels. Signed-off-by: Vitaliy Kulikov Signed-off-by: Takashi Iwai --- sound/pci/hda/patch_sigmatel.c | 78 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 78 insertions(+) (limited to 'sound') diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c index 82ebeb9..93fa59c 100644 --- a/sound/pci/hda/patch_sigmatel.c +++ b/sound/pci/hda/patch_sigmatel.c @@ -5326,6 +5326,82 @@ again: return 0; } +static int stac92hd83xxx_set_system_btl_amp(struct hda_codec *codec) +{ + if (codec->vendor_id != 0x111d7605 && + codec->vendor_id != 0x111d76d1) + return 0; + + switch (codec->subsystem_id) { + case 0x103c1618: + case 0x103c1619: + case 0x103c161a: + case 0x103c161b: + case 0x103c161c: + case 0x103c161d: + case 0x103c161e: + case 0x103c161f: + case 0x103c1620: + case 0x103c1621: + case 0x103c1622: + case 0x103c1623: + + case 0x103c162a: + case 0x103c162b: + + case 0x103c1630: + case 0x103c1631: + + case 0x103c1633: + + case 0x103c1635: + + case 0x103c164f: + + case 0x103c1676: + case 0x103c1677: + case 0x103c1678: + case 0x103c1679: + case 0x103c167a: + case 0x103c167b: + case 0x103c167c: + case 0x103c167d: + case 0x103c167e: + case 0x103c167f: + case 0x103c1680: + case 0x103c1681: + case 0x103c1682: + case 0x103c1683: + case 0x103c1684: + case 0x103c1685: + case 0x103c1686: + case 0x103c1687: + case 0x103c1688: + case 0x103c1689: + case 0x103c168a: + case 0x103c168b: + case 0x103c168c: + case 0x103c168d: + case 0x103c168e: + case 0x103c168f: + case 0x103c1690: + case 0x103c1691: + case 0x103c1692: + + case 0x103c3587: + case 0x103c3588: + case 0x103c3589: + case 0x103c358a: + + case 0x103c3667: + case 0x103c3668: + /* set BTL amp level to 13.43dB for louder speaker output */ + return snd_hda_codec_write_cache(codec, codec->afg, 0, + 0x7F4, 0x14); + } + return 0; +} + static int patch_stac92hd83xxx(struct hda_codec *codec) { struct sigmatel_spec *spec; @@ -5452,6 +5528,8 @@ again: AC_VERB_SET_CONNECT_SEL, num_dacs); } + stac92hd83xxx_set_system_btl_amp(codec); + codec->proc_widget_hook = stac92hd_proc_hook; return 0; -- cgit v1.1 From 3342b9680fbd6535f65148f5e95e581bc75be9cc Mon Sep 17 00:00:00 2001 From: Julia Lawall Date: Tue, 26 Oct 2010 12:25:38 +0200 Subject: sound/oss/sb_ess.c: delete double assignment Delete successive assignments to the same location. A simplified version of the semantic match that finds this problem is as follows: (http://coccinelle.lip6.fr/) // @@ expression i; @@ *i = ...; i = ...; // Signed-off-by: Julia Lawall Signed-off-by: Takashi Iwai --- sound/oss/sb_ess.c | 1 - 1 file changed, 1 deletion(-) (limited to 'sound') diff --git a/sound/oss/sb_ess.c b/sound/oss/sb_ess.c index 51a3d38..9890cf2 100644 --- a/sound/oss/sb_ess.c +++ b/sound/oss/sb_ess.c @@ -1722,7 +1722,6 @@ printk (KERN_INFO "FKS: es_rec_set_recmask mask = %x\n", mask); right = (value & 0x0000ff00) >> 8; } else { /* Turn it off (3) */ left = 0; - left = 0; right = 0; } sb_common_mixer_set(devc, i + ES_REC_MIXER_RECDIFF, left, right); -- cgit v1.1 From e94be5f3628565d0968d668341d9dd468700516d Mon Sep 17 00:00:00 2001 From: Liam Girdwood Date: Tue, 26 Oct 2010 20:07:43 +0100 Subject: ASoC: fsl - fix build error in pcm030-audio-fabric.c Fix build error:- sound/soc/fsl/pcm030-audio-fabric.c:27:33: fatal error: sound/soc-of-simple.h: No such file or directory Signed-off-by: Liam Girdwood Signed-off-by: Takashi Iwai --- sound/soc/fsl/pcm030-audio-fabric.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'sound') diff --git a/sound/soc/fsl/pcm030-audio-fabric.c b/sound/soc/fsl/pcm030-audio-fabric.c index fe15bb2..25f27ec 100644 --- a/sound/soc/fsl/pcm030-audio-fabric.c +++ b/sound/soc/fsl/pcm030-audio-fabric.c @@ -24,7 +24,6 @@ #include #include #include -#include #include "mpc5200_dma.h" #include "mpc5200_psc_ac97.h" @@ -49,7 +48,7 @@ static struct snd_soc_dai_link pcm030_fabric_dai[] = { .codec_dai_name = "wm9712-aux", .cpu_dai_name = "mpc5200-psc-ac97.1", .platform_name = "mpc5200-pcm-audio", - ..codec_name = "wm9712-codec", + .codec_name = "wm9712-codec", }, }; -- cgit v1.1 From 836f5394061830a9d1ece4aafc437c098774522f Mon Sep 17 00:00:00 2001 From: Arnaud Lacombe Date: Tue, 26 Oct 2010 16:04:34 -0400 Subject: ASoC: sound/ad73311: add missing __devexit marker This fixes the following warning: sound/soc/codecs/ad73311.c:50:12: warning: 'ad73311_remove' defined but not used Signed-off-by: Arnaud Lacombe Signed-off-by: Takashi Iwai --- sound/soc/codecs/ad73311.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/soc/codecs/ad73311.c b/sound/soc/codecs/ad73311.c index c53955f..de799cd 100644 --- a/sound/soc/codecs/ad73311.c +++ b/sound/soc/codecs/ad73311.c @@ -47,7 +47,7 @@ static int ad73311_probe(struct platform_device *pdev) &soc_codec_dev_ad73311, &ad73311_dai, 1); } -static int ad73311_remove(struct platform_device *pdev) +static int __devexit ad73311_remove(struct platform_device *pdev) { snd_soc_unregister_codec(&pdev->dev); return 0; -- cgit v1.1 From f3607aef0d3370ae9edbfecfc7182233397cb0aa Mon Sep 17 00:00:00 2001 From: Arnaud Lacombe Date: Tue, 26 Oct 2010 16:04:35 -0400 Subject: ASoC: sound/max98088: add missing __devexit marker This fixes the following warning: sound/soc/codecs/max98088.c:2054:12: warning: 'max98088_i2c_remove' defined but not used Signed-off-by: Arnaud Lacombe Signed-off-by: Takashi Iwai --- sound/soc/codecs/max98088.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/soc/codecs/max98088.c b/sound/soc/codecs/max98088.c index e7a40d1..bc22ee9 100644 --- a/sound/soc/codecs/max98088.c +++ b/sound/soc/codecs/max98088.c @@ -2051,7 +2051,7 @@ static int max98088_i2c_probe(struct i2c_client *i2c, return ret; } -static int max98088_i2c_remove(struct i2c_client *client) +static int __devexit max98088_i2c_remove(struct i2c_client *client) { snd_soc_unregister_codec(&client->dev); kfree(i2c_get_clientdata(client)); -- cgit v1.1 From 0d040df9984c8fcb6a777a8f6d5dc513eaefd2de Mon Sep 17 00:00:00 2001 From: Arnaud Lacombe Date: Tue, 26 Oct 2010 16:04:36 -0400 Subject: ASoC: sound/wm9090: add missing __devexit marker This fixes the following warning: sound/soc/codecs/wm9090.c:668:12: warning: 'wm9090_i2c_remove' defined but not used Signed-off-by: Arnaud Lacombe Signed-off-by: Takashi Iwai --- sound/soc/codecs/wm9090.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sound') diff --git a/sound/soc/codecs/wm9090.c b/sound/soc/codecs/wm9090.c index 7a18254..99c046b 100644 --- a/sound/soc/codecs/wm9090.c +++ b/sound/soc/codecs/wm9090.c @@ -665,7 +665,7 @@ static int wm9090_i2c_probe(struct i2c_client *i2c, return ret; } -static int wm9090_i2c_remove(struct i2c_client *i2c) +static int __devexit wm9090_i2c_remove(struct i2c_client *i2c) { struct wm9090_priv *wm9090 = i2c_get_clientdata(i2c); -- cgit v1.1 From 48ccb2ceec6fb1d46d1bc92dadc602d4341a0149 Mon Sep 17 00:00:00 2001 From: Paul Mundt Date: Wed, 27 Oct 2010 15:53:50 +0900 Subject: sound: sh: ctrl_in/outX to __raw_read/writeX conversion. The ctrl_xxx routines are deprecated, switch over to the __raw_xxx versions. Signed-off-by: Paul Mundt --- sound/sh/aica.c | 2 +- sound/soc/sh/sh7760-ac97.c | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) (limited to 'sound') diff --git a/sound/sh/aica.c b/sound/sh/aica.c index a0df401..94c6ea7 100644 --- a/sound/sh/aica.c +++ b/sound/sh/aica.c @@ -188,7 +188,7 @@ static void spu_reset(void) spu_memset(0, 0, 0x200000 / 4); /* Put ARM7 in endless loop */ local_irq_save(flags); - ctrl_outl(0xea000002, SPU_MEMORY_BASE); + __raw_writel(0xea000002, SPU_MEMORY_BASE); local_irq_restore(flags); spu_enable(); } diff --git a/sound/soc/sh/sh7760-ac97.c b/sound/soc/sh/sh7760-ac97.c index b897f7b..f8e0ab8 100644 --- a/sound/soc/sh/sh7760-ac97.c +++ b/sound/soc/sh/sh7760-ac97.c @@ -52,8 +52,8 @@ static int __init sh7760_ac97_init(void) unsigned short ipsel; /* enable both AC97 controllers in pinmux reg */ - ipsel = ctrl_inw(IPSEL); - ctrl_outw(ipsel | (3 << 10), IPSEL); + ipsel = __raw_readw(IPSEL); + __raw_writew(ipsel | (3 << 10), IPSEL); ret = -ENOMEM; sh7760_ac97_snd_device = platform_device_alloc("soc-audio", -1); -- cgit v1.1 From 89e1e66d6be8a520cdcd26043cda2cc870a34015 Mon Sep 17 00:00:00 2001 From: Clemens Ladisch Date: Tue, 26 Oct 2010 17:14:41 +0200 Subject: ALSA: usb-audio: automatically detect feedback format There are two USB Audio Class specifications (v1 and v2), but neither of them clearly defines the feedback format for high-speed UAC v1 devices. Add to this whatever the Creative and M-Audio firmware writers have been smoking, and it becomes impossible to predict the exact feedback format used by a particular device. Therefore, automatically detect the feedback format by looking at the magnitude of the first received feedback value. Also, this allows us to get rid of some special cases for E-Mu devices. Signed-off-by: Clemens Ladisch Signed-off-by: Takashi Iwai --- sound/usb/card.h | 2 + sound/usb/pcm.c | 2 + sound/usb/proc.c | 5 ++ sound/usb/urb.c | 170 +++++++++++++++++++------------------------------------ 4 files changed, 67 insertions(+), 112 deletions(-) (limited to 'sound') diff --git a/sound/usb/card.h b/sound/usb/card.h index 1febf2f..ae4251d 100644 --- a/sound/usb/card.h +++ b/sound/usb/card.h @@ -62,12 +62,14 @@ struct snd_usb_substream { unsigned int syncinterval; /* P for adaptive mode, 0 otherwise */ unsigned int freqn; /* nominal sampling rate in fs/fps in Q16.16 format */ unsigned int freqm; /* momentary sampling rate in fs/fps in Q16.16 format */ + int freqshift; /* how much to shift the feedback value to get Q16.16 */ unsigned int freqmax; /* maximum sampling rate, used for buffer management */ unsigned int phase; /* phase accumulator */ unsigned int maxpacksize; /* max packet size in bytes */ unsigned int maxframesize; /* max packet size in frames */ unsigned int curpacksize; /* current packet size in bytes (for capture) */ unsigned int curframesize; /* current packet size in frames (for capture) */ + unsigned int syncmaxsize; /* sync endpoint packet size */ unsigned int fill_max: 1; /* fill max packet size always */ unsigned int txfr_quirk:1; /* allow sub-frame alignment */ unsigned int fmt_type; /* USB audio format type (1-3) */ diff --git a/sound/usb/pcm.c b/sound/usb/pcm.c index f49756c..cff3a3c 100644 --- a/sound/usb/pcm.c +++ b/sound/usb/pcm.c @@ -237,6 +237,7 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt) subs->datainterval = fmt->datainterval; subs->syncpipe = subs->syncinterval = 0; subs->maxpacksize = fmt->maxpacksize; + subs->syncmaxsize = 0; subs->fill_max = 0; /* we need a sync pipe in async OUT or adaptive IN mode */ @@ -283,6 +284,7 @@ static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt) subs->syncinterval = get_endpoint(alts, 1)->bInterval - 1; else subs->syncinterval = 3; + subs->syncmaxsize = le16_to_cpu(get_endpoint(alts, 1)->wMaxPacketSize); } /* always fill max packet size */ diff --git a/sound/usb/proc.c b/sound/usb/proc.c index 3c650ab..961c9a2 100644 --- a/sound/usb/proc.c +++ b/sound/usb/proc.c @@ -132,6 +132,11 @@ static void proc_dump_substream_status(struct snd_usb_substream *subs, struct sn ? get_full_speed_hz(subs->freqm) : get_high_speed_hz(subs->freqm), subs->freqm >> 16, subs->freqm & 0xffff); + if (subs->freqshift != INT_MIN) + snd_iprintf(buffer, " Feedback Format = %d.%d\n", + (subs->syncmaxsize > 3 ? 32 : 24) + - (16 - subs->freqshift), + 16 - subs->freqshift); } else { snd_iprintf(buffer, " Status: Stop\n"); } diff --git a/sound/usb/urb.c b/sound/usb/urb.c index 8deeaad..e184349 100644 --- a/sound/usb/urb.c +++ b/sound/usb/urb.c @@ -225,6 +225,7 @@ int snd_usb_init_substream_urbs(struct snd_usb_substream *subs, else subs->freqn = get_usb_high_speed_rate(rate); subs->freqm = subs->freqn; + subs->freqshift = INT_MIN; /* calculate max. frequency */ if (subs->maxpacksize) { /* whatever fits into a max. size packet */ @@ -513,11 +514,10 @@ static int retire_paused_capture_urb(struct snd_usb_substream *subs, /* - * prepare urb for full speed playback sync pipe + * prepare urb for playback sync pipe * * set up the offset and length to receive the current frequency. */ - static int prepare_playback_sync_urb(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *urb) @@ -525,103 +525,78 @@ static int prepare_playback_sync_urb(struct snd_usb_substream *subs, struct snd_urb_ctx *ctx = urb->context; urb->dev = ctx->subs->dev; /* we need to set this at each time */ - urb->iso_frame_desc[0].length = 3; + urb->iso_frame_desc[0].length = min(4u, ctx->subs->syncmaxsize); urb->iso_frame_desc[0].offset = 0; return 0; } /* - * prepare urb for high speed playback sync pipe + * process after playback sync complete * - * set up the offset and length to receive the current frequency. - */ - -static int prepare_playback_sync_urb_hs(struct snd_usb_substream *subs, - struct snd_pcm_runtime *runtime, - struct urb *urb) -{ - struct snd_urb_ctx *ctx = urb->context; - - urb->dev = ctx->subs->dev; /* we need to set this at each time */ - urb->iso_frame_desc[0].length = 4; - urb->iso_frame_desc[0].offset = 0; - return 0; -} - -/* - * process after full speed playback sync complete - * - * retrieve the current 10.14 frequency from pipe, and set it. - * the value is referred in prepare_playback_urb(). + * Full speed devices report feedback values in 10.14 format as samples per + * frame, high speed devices in 16.16 format as samples per microframe. + * Because the Audio Class 1 spec was written before USB 2.0, many high speed + * devices use a wrong interpretation, some others use an entirely different + * format. Therefore, we cannot predict what format any particular device uses + * and must detect it automatically. */ static int retire_playback_sync_urb(struct snd_usb_substream *subs, struct snd_pcm_runtime *runtime, struct urb *urb) { unsigned int f; + int shift; unsigned long flags; - if (urb->iso_frame_desc[0].status == 0 && - urb->iso_frame_desc[0].actual_length == 3) { - f = combine_triple((u8*)urb->transfer_buffer) << 2; - if (f >= subs->freqn - subs->freqn / 8 && f <= subs->freqmax) { - spin_lock_irqsave(&subs->lock, flags); - subs->freqm = f; - spin_unlock_irqrestore(&subs->lock, flags); - } - } - - return 0; -} + if (urb->iso_frame_desc[0].status != 0 || + urb->iso_frame_desc[0].actual_length < 3) + return 0; -/* - * process after high speed playback sync complete - * - * retrieve the current 12.13 frequency from pipe, and set it. - * the value is referred in prepare_playback_urb(). - */ -static int retire_playback_sync_urb_hs(struct snd_usb_substream *subs, - struct snd_pcm_runtime *runtime, - struct urb *urb) -{ - unsigned int f; - unsigned long flags; + f = le32_to_cpup(urb->transfer_buffer); + if (urb->iso_frame_desc[0].actual_length == 3) + f &= 0x00ffffff; + else + f &= 0x0fffffff; + if (f == 0) + return 0; - if (urb->iso_frame_desc[0].status == 0 && - urb->iso_frame_desc[0].actual_length == 4) { - f = combine_quad((u8*)urb->transfer_buffer) & 0x0fffffff; - if (f >= subs->freqn - subs->freqn / 8 && f <= subs->freqmax) { - spin_lock_irqsave(&subs->lock, flags); - subs->freqm = f; - spin_unlock_irqrestore(&subs->lock, flags); + if (unlikely(subs->freqshift == INT_MIN)) { + /* + * The first time we see a feedback value, determine its format + * by shifting it left or right until it matches the nominal + * frequency value. This assumes that the feedback does not + * differ from the nominal value more than +50% or -25%. + */ + shift = 0; + while (f < subs->freqn - subs->freqn / 4) { + f <<= 1; + shift++; + } + while (f > subs->freqn + subs->freqn / 2) { + f >>= 1; + shift--; } + subs->freqshift = shift; } + else if (subs->freqshift >= 0) + f <<= subs->freqshift; + else + f >>= -subs->freqshift; - return 0; -} - -/* - * process after E-Mu 0202/0404/Tracker Pre high speed playback sync complete - * - * These devices return the number of samples per packet instead of the number - * of samples per microframe. - */ -static int retire_playback_sync_urb_hs_emu(struct snd_usb_substream *subs, - struct snd_pcm_runtime *runtime, - struct urb *urb) -{ - unsigned int f; - unsigned long flags; - - if (urb->iso_frame_desc[0].status == 0 && - urb->iso_frame_desc[0].actual_length == 4) { - f = combine_quad((u8*)urb->transfer_buffer) & 0x0fffffff; - f >>= subs->datainterval; - if (f >= subs->freqn - subs->freqn / 8 && f <= subs->freqmax) { - spin_lock_irqsave(&subs->lock, flags); - subs->freqm = f; - spin_unlock_irqrestore(&subs->lock, flags); - } + if (likely(f >= subs->freqn - subs->freqn / 8 && f <= subs->freqmax)) { + /* + * If the frequency looks valid, set it. + * This value is referred to in prepare_playback_urb(). + */ + spin_lock_irqsave(&subs->lock, flags); + subs->freqm = f; + spin_unlock_irqrestore(&subs->lock, flags); + } else { + /* + * Out of range; maybe the shift value is wrong. + * Reset it so that we autodetect again the next time. + */ + subs->freqshift = INT_MIN; } return 0; @@ -878,21 +853,6 @@ static struct snd_urb_ops audio_urb_ops[2] = { }, }; -static struct snd_urb_ops audio_urb_ops_high_speed[2] = { - { - .prepare = prepare_nodata_playback_urb, - .retire = retire_playback_urb, - .prepare_sync = prepare_playback_sync_urb_hs, - .retire_sync = retire_playback_sync_urb_hs, - }, - { - .prepare = prepare_capture_urb, - .retire = retire_capture_urb, - .prepare_sync = prepare_capture_sync_urb_hs, - .retire_sync = retire_capture_sync_urb, - }, -}; - /* * initialize the substream instance. */ @@ -909,23 +869,9 @@ void snd_usb_init_substream(struct snd_usb_stream *as, subs->direction = stream; subs->dev = as->chip->dev; subs->txfr_quirk = as->chip->txfr_quirk; - if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL) { - subs->ops = audio_urb_ops[stream]; - } else { - subs->ops = audio_urb_ops_high_speed[stream]; - switch (as->chip->usb_id) { - case USB_ID(0x041e, 0x3f02): /* E-Mu 0202 USB */ - case USB_ID(0x041e, 0x3f04): /* E-Mu 0404 USB */ - case USB_ID(0x041e, 0x3f0a): /* E-Mu Tracker Pre */ - subs->ops.retire_sync = retire_playback_sync_urb_hs_emu; - break; - case USB_ID(0x0763, 0x2080): /* M-Audio Fast Track Ultra 8 */ - case USB_ID(0x0763, 0x2081): /* M-Audio Fast Track Ultra 8R */ - subs->ops.prepare_sync = prepare_playback_sync_urb; - subs->ops.retire_sync = retire_playback_sync_urb; - break; - } - } + subs->ops = audio_urb_ops[stream]; + if (snd_usb_get_speed(subs->dev) >= USB_SPEED_HIGH) + subs->ops.prepare_sync = prepare_capture_sync_urb_hs; snd_usb_set_pcm_ops(as->pcm, stream); -- cgit v1.1