misctbl.c

来自「ESS3890+SL原代码（1*16内存）」· C语言 代码 · 共 2,135 行 · 第 1/4 页

/* Copyright 1996, ESS Technology, Inc.                                 */
/* SCCSID @(#)misctbl.c	4.34 02/14/05 */

/*
 * $Log$
 */

#include "common.h"
#include "tdm.h"

#ifndef MEMORY_DEVICE
#include "servo.h"

/************************************************************************
 * For TDM.								*
 ************************************************************************/
#if 0
/* From tdm.h */

/*
 * Notice that endian settings for video data are just oppposit to the 
 * real data format since transport automaticaly flips the endian.
 * For CDDA, endian settings are the same as data format since we
 * flip it again at the output of the transport.
 */
typedef struct {
    unsigned short slot;	/* tdmslot  value			*/
    unsigned short delay;	/* tdmdelay value			*/
    unsigned short ctl;		/* tdmctl   value			*/
    unsigned short low;		/* Don't turn on TDM if lower than this */
} TDM_settings;

typedef struct {
    TDM_settings cd[2];
} TDM_SETTING;
#endif

TDM_SETTING tdmsettings[] = {
     /* CDROM */	      /* AUDIO CD */
    {{{0x0f, 0xd, 0x8060,  8}, {0x0f, 0xd, 0x8060, 24}}}, /* TOSHIBA TC9263F */
    {{{0x2d, 0xd, 0x8120, 16}, {0x1b, 0xd, 0x8060, 16}}}, /* SANYO   	     */
    {{{0x2d, 0xf, 0x8060, 16}, {0x2d, 0xf, 0x8060, 16}}}, /* PHILIPS	     */
    {{{0x1b, 0xd, 0x8060,  0}, {0x1b, 0xd, 0x8060,  0}}}, /* SONY	     */
    {{{0x66, 0xd, 0x8060,  0}, {0x66, 0xd, 0x8060,  0}}}, /* MATSUSHITA	     */

#if 0
    {{{0x2d, 0xf, 0x8060, 16}, {0x2d, 0xf, 0x8060, 40}}}, /* MITSUBISHI	     */
    {{{0x1b, 0xd, 0x8060,  0}, {0x2d, 0xd, 0x8060, 16}}}, /* THOMSON         */

    /* Technics MN6626. Outputs 32b SONY format */
    {{{0x33, 0xd, 0x8060,  0}, {0x33, 0xd, 0x8060,  0}}}, /* YAMAHA	     */
#endif
};
#endif /* MEMORY_DEVICE */

/************************************************************************
 * For IR.								*
 ************************************************************************/
/*
 * When DSC_IRQ is defined, we use internal 3881 counters to keep
 * track of time.
 *
 * The counter increments at .1517ms interval (2048/13.5MHz). It only
 * triggers on one edge (default is falling) as oppose to the old
 * style where we triggers on both edge.
 */

/* Timer values when CPU is running at full speed */
unsigned int IR_powerup_tbl[] = {
#if (defined DSC_IRQ || defined IO3898)
    /* Use 3881's internal counter to keep track of time		*/
#ifdef IR_PHILIPS
    /* For Philips format */
    3,
    8,
    9,
    16,
#else
    /* For NEC and SANYO formats */
    85,					/* Leader low+high min (12.89ms)*/
    93,					/* Leader low+high max (14.10ms)*/
    12,					/* Gap+data 1 minimum (1.82ms)	*/
    19,					/* Gap+data 1 maximum (2.88ms)	*/
    4,					/* Gap+data 0 minimum (0.61ms)	*/
    11,					/* Gap+data 0 maximum (1.67ms)	*/
#ifdef IRREP
    70,					/* Rep low+high min (10.62ms)	*/
    78,					/* Rep low+high max (11.83ms)	*/
#endif /* IRREP */
#ifdef IR_GAMEPAD
        25,             /* Leader minimum               */
        33,             /* Leader maximum               */
        3,              /* Data 1 minimum               */
        6,      /* Data 1 maximum       */
        7,              /* Data 0 minimum               */
        10,             /* Data 0 maximum               */
#endif
#endif /* else of IR_PHILIPS */

#else
    /* Use CPU's timer2 to keep track of time				*/
#ifdef IR_PHILIPS
    /* For Philips format */
    CPUCLK * 50,			/* minimum length of half bit	*/
    CPUCLK * 130,			/* maximum length of half bit	*/
    CPUCLK * 140,			/* minimum length of one bit	*/
    CPUCLK * 240,			/* maximum length of one bit	*/
#else
    /* For NEC and SANYO formats */
    CPUCLK * 880,			/* Leader low minimum		*/
    CPUCLK * 920,			/* Leader low maximum		*/
    CPUCLK * 430,			/* Leader high minimum		*/
    CPUCLK * 470,			/* Leader high maximum		*/
    CPUCLK * 205,			/* Data 1 minimum		*/
    CPUCLK * 245,			/* Data 1 maximum		*/
    CPUCLK * 92,			/* Data 0 minimum		*/
    CPUCLK * 132,            		/* Data 0 maximum       	*/
#ifdef IRREP
    CPUCLK * 205,           		/* Repeat high minimun      	*/
    CPUCLK * 245,			/* Repeat high mazimun		*/
    CPUCLK * 36,			/* Repeat data minimum		*/
    CPUCLK * 76             		/* Repeat data maxmun       	*/
#endif /* IRREP */
#ifdef IR_GAMEPAD
        CPUCLK * 380,           /* Leader minimum               */
        CPUCLK * 420,           /* Leader maximum               */
        CPUCLK * 64,            /* Data 1 minimum               */
        CPUCLK * 104,           /* Data 1 maximum               */
        CPUCLK * 110,           /* Data 0 minimum               */
        CPUCLK * 150,           /* Data 0 maximum               */
#endif
#endif /* else of IR_PHILIPS */
#endif /* else of DSC_IRQ */
};

#ifndef DSC_IRQ
/* 
 * Timer values when CPU is running at power-down speed. This table is
 * only needed only when we are not using 3881's internal counter.
 */
unsigned int IR_powerdn_tbl[] = {
#ifdef IR_PHILIPS
    /* For Philips format */
    IDLECLK * 50,			/* minimum length of half bit	*/
    IDLECLK * 130,			/* maximum length of half bit	*/
    IDLECLK * 140,			/* minimum length of one bit	*/
    IDLECLK * 240,			/* maximum length of one bit	*/
#else
    /* For NEC and SANYO formats */
    IDLECLK * 880,			/* Leader low minimum           */
    IDLECLK * 920,			/* Leader low maximum           */
    IDLECLK * 430,			/* Leader high minimum          */
    IDLECLK * 470,			/* Leader high maximum          */
    IDLECLK * 205,			/* Data 1 minimum               */
    IDLECLK * 245,			/* Data 1 maximum               */
    IDLECLK * 92,			/* Data 0 minimum               */
    IDLECLK * 132,          		/* Data 0 maximum               */
#ifdef IRREP
    IDLECLK * 205,			/* Repeat high minimun		*/
    IDLECLK * 245,			/* Repeat high mazimun		*/
    IDLECLK * 36,			/* Repeat data minimum		*/
    IDLECLK * 76            		/* Repeat data maxmun       	*/
#endif /* IRREP */
#ifdef IR_GAMEPAD
    CPUCLK * 380,       /* Leader minimum               */
    CPUCLK * 420,       /* Leader maximum               */
    CPUCLK * 64 ,       /* Data 1 minimum               */
    CPUCLK * 104,       /* Data 1 maximum       */
    CPUCLK * 110,       /* Data 0 minimum               */
    CPUCLK * 150,       /* Data 0 maximum               */
#endif
#endif /* else of IR_PHILIPS */
};
#endif

/************************************************************************
 * Display palette (fancy start-up screen).				*
 ************************************************************************/
struct {
    unsigned char component[3];
} palette_std[] = {
    {0x6b, 0x00, 0x00},	/*white*/
    {0x27, 0x0d, 0xb2},	/*yellow*/
    {0x0b, 0xb2, 0x1a},	/*cyan*/
    {0xfa, 0xbf, 0xcd},	/*green*/
    {0xdf, 0x41, 0x33},	/*magenta*/
    {0xce, 0x4e, 0xe6},	/*red*/
    {0xb2, 0xf3, 0x4e},	/*blue*/
    {0x80, 0x00, 0x00},	/*black*/
    {0xe4, 0xf3, 0x4e},	/*custom*/
    {0xa0, 0x00, 0x00},	/*custom*/
    {0xa0, 0x00, 0x00},	/*custom*/
    {0xa0, 0x00, 0x00}	/*custom*/
};

/************************************************************************
 * For echo (44.1K -> 48K)                                              *
 ************************************************************************/
#if 0
unsigned int up_samp[] = {
   0x40003a2e, 0x345d2e8b, 0x28ba22e8, 0x1d171745, 0x11740ba2, 0x05d10000,
   0x000005d1, 0x0ba21174, 0x17451d17, 0x22e828ba, 0x2e8b345d, 0x3a2e4000
};
#endif

/************************************************************************
 * For deemphasis.                                                      *
 ************************************************************************/
unsigned int bp_demp[] = {
#if 0
    /* 5KHz sin wave -5.28dB, 16KHz sin wave -10.63dB */
    0xffe10023, 0x0005001e, 0x00070030, 0xffec0001, 0xfff30010, 0x000b008c,
    0x00aa0167, 0x012004b5, 0x0e6a04b5, 0x01200167, 0x00aa008c, 0x000b0010,
    0xfff30001, 0xffec0030, 0x0007001e, 0x00050023, 0xffe10000, 0x00000000

    /* 5KHz sin wave -4.10dB, 16KHz sin wave -9.16dB */
    0xffe2fff8, 0xffe5001c, 0xffee000a, 0xffe9fffe, 0xffda0033, 0xffe80075,
    0x009d0148, 0x0151045f, 0x108e045f, 0x01510148, 0x009d0075, 0xffe80033,
    0xffdafffe, 0xffe9000a, 0xffee001c, 0xffe5fff8, 0xffe20000, 0x00000000
#else
    /* 5KHz sin wave -4.58dB, 16KHz sin wave -9.17dB */
   0xfff90027, 0xfffd0016, 0xffe40008, 0xffe3fff8, 0xffd8003e, 0xfff9007c,
   0x00a5014f, 0x0148041d, 0x1042041d, 0x0148014f, 0x00a5007c, 0xfff9003e,
   0xffd8fff8, 0xffe30008, 0xffe40016, 0xfffd0027, 0xfff90000, 0x00000000
#endif
};
 
/************************************************************************
 * For spatializer.							*
 ************************************************************************/
unsigned int bp_ham[] = {

#ifdef SPATIAL
    /* first */
    0x18c320f7, 0xf6a4eb88, 0xfd81fff8, 0x00190049, 0x00060037, 0xffff0027,
    0xffff0018, 0x00010009, 0x0000fff7, 0xffffffe8, 0x0001ffd9, 0x0001ffc9,
    0xfffaffb7, 0xffe70008, 0x027f1478, 0x095cdf09, 0xe73d0000, 0x00000000,
 
    /* second */
    0x1ddb1616, 0xdad90072, 0x0116fdce, 0x00e8fe69, 0x00b8fea4, 0x009ffecd,
    0x0087fef4, 0x006aff1e, 0x000000e2, 0xff96010c, 0xff790133, 0xff61015c,
    0xff480197, 0xff180232, 0xfeeaff8e, 0x2527e9ea, 0xe2250000, 0x00000000,
 
    /* Hall (widest) */
    0x1d07249e, 0x01dbf3c1, 0xfe05fda7, 0xffcdff10, 0xffebff6b, 0xfff0ff93,
    0xfff3ffa7, 0xfff4ffb1, 0x0000004f, 0x000c0059, 0x000d006d, 0x00100095, 
    0x001500f0, 0x00330259, 0x01fb0c3f, 0xfe25db62, 0xe2f90000, 0x00000000,

#endif
    /* Vocal cut */
    0xfccc0799, 0x0733f833, 0x02000e33, 0x0b33fbcc, 0xff000100, 0xf3ccfd99,
    0x05cc0233, 0x0b990933, 0x0b990933, 0x0b990233, 0x05ccfd99, 0xf3cc0100,
    0xff00fbcc, 0x0b330e33, 0x0200f833, 0x07330799, 0xfccc0000, 0x00000000

};



ushort e20log[25] = {
    0x0404, 0x0482, 0x050f, 0x05ad, 0x065e, 0x0725, 0x0804, 0x08ff,
    0x0a18, 0x0b53, 0x0cb5, 0x0e42, 0x1000, 0x11f3, 0x1424, 0x1699,
    0x195b, 0x1c73, 0x1fec, 0x23d1, 0x2830, 0x2d18, 0x3298, 0x38c5,
    0x3fb2};


ushort ecoeff_a[32] = {
     /* 44100Hz */
     0x7f96, 0x7ef4, 0x0034, 0x0082,
     0xc068, 0xc104, 0xffcc, 0xff7e,
     0x7d1e, 0x7846, 0x0156, 0x0340,
     0xc2ae, 0xc680, 0xfeaa, 0xfcc0,
     0x6ad2, 0x3f12, 0x0750, 0x0ff4,
     0xce9e, 0xdfe8, 0xf8b0, 0xf00c,
     0xde36, 0x0000, 0x2084, 0x0000,
     0x0106, 0x0000, 0xdf7c, 0x0000
};

/************************************************************************
 * For game sound filter                                                *
 ************************************************************************/
#ifdef GAMEBOY
unsigned int bp_gbsnd[] = {
#if 0
/* 1200 - 4096 */
     0x026c04bc, 0x07900aa0, 0x0d941008, 0x11a8123c,
     0x11a81008, 0x0d940aa0, 0x079004bc, 0x026c0000,
/* 6K - 8K */
     0x037cfe64, 0xf7f8f760, 0x020015f4, 0x29b431f4,
     0x29b415f4, 0x0200f760, 0xf7f8fe64, 0x037c0000,
#endif
/* 11K - 13K */
     0xfcecfb54, 0x06ac05b4, 0xf190f99c, 0x310054c0,
     0x3100f99c, 0xf19005b4, 0x06acfb54, 0xfcec0000,
#if 0
/* 15K - 18K */
     0xfd080580, 0xfa00ffc8, 0x0ad0e828, 0x22a4756c,
     0x22a4e828, 0x0ad0ffc8, 0xfad00580, 0xfd080000,
/* test full pass */
     0x00000000, 0x00000000, 0x00000000, 0x00007fff,
     0x00000000, 0x00000000, 0x00000000, 0x00000000
#endif

#if 0
/* 4K - 6K */
     0xfb10f9e8, 0xfc4c0300, 0x0d201810, 0x208423b4,
     0x20841810, 0x0d200300, 0xfc4cf9e8, 0xfb100000,
/* 6K - 8K */
     0x037cfe64, 0xf7f8f760, 0x020015f4, 0x29b431f4,
     0x29b415f4, 0x0200f760, 0xf7f8fe64, 0x037c0000,
/* 8K - 10K */
     0x02880660, 0x00b0f594, 0xf62c0d94, 0x2f443f58,
     0x2f440d94, 0xf62cf594, 0x00b00660, 0x02880000,
/* 10K - 12K */
     0xfad40050, 0x0884ffdc, 0xf04c0028, 0x31704df8,
     0x31700028, 0xf04cffdc, 0x08840050, 0xfad40000,
/* test full pass */
     0x00000000, 0x00000000, 0x00000000, 0x00004000,
     0x00000000, 0x00000000, 0x00000000, 0x00000000
/* 1200 - 4096 */
     0x07f30f87, 0x18c622ce, 0x2c783486, 0x39de3bbd,
     0x39de3486, 0x2c7822ce, 0x18c60f87, 0x07f30000,
/* 1200 - 6000 */
     0x006401f4, 0x04d008e4, 0x0dac1234, 0x157c16ac,
     0x157c1234, 0x0dac08e4, 0x04d001f4, 0x00640000,
/* test */
     0xfc8cffd8, 0x04ac0a74, 0x10601580, 0x18fc1a38,
     0x18fc1580, 0x10600a74, 0x04acffd8, 0xfc8c0000,
/* 8820 - 13230 */
     0xfd600000, 0x06480000, 0xf1d40000, 0x30e84e20,
     0x30e80000, 0xf1d40000, 0x06480000, 0xfd600000
#endif
};
#endif

#ifdef REVERB
unsigned short rvb_amp[] = {
    /* 0 ~ 32767 */
    /* A1   A2     A3     A4     B3     B4     A  */
    16384, 19961, 22938, 26214, 26214, 29491, 22938 /*  6553 */
};
unsigned short rvb_del[] = {
    /* 0 ~ 44 in multiple of 4 for D1 ~ D4, 0 ~ 528 in multiple of 48 for L */ 
    /* D1 D2  D3  D4    L */ 
        4, 8, 12, 24, 288
};
unsigned int rvb_vp_code [12][4] = {
    {0x50006104, 0x10e03400 ,0x80004714 ,0x00003000}, 
    {0x50006108, 0x10e03400 ,0x80004728 ,0x00003000}, 
    {0x5000610c, 0x10e03400 ,0x8000473c ,0x00003000}, 
    {0x50006100, 0x10e03410 ,0x80004700 ,0x00003110}, 
    {0x50006104, 0x10e03410 ,0x80004714 ,0x00003110}, 
    {0x50006108, 0x10e03410 ,0x80004728 ,0x00003110}, 
    {0x5000610c, 0x10e03410 ,0x8000473c ,0x00003110}, 
    {0x50006100, 0x10e03420 ,0x80004700 ,0x00003220}, 
    {0x50006104, 0x10e03420 ,0x80004714 ,0x00003220}, 
    {0x50006108, 0x10e03420 ,0x80004728 ,0x00003220}, 
    {0x5000610c, 0x10e03420 ,0x8000473c ,0x00003220}, 
    {0x50006100, 0x10e03430 ,0x80004700 ,0x00003330} 
};

unsigned short rvb_vp_offset [4][4] = {
    { 0x000e, 0x000f, 0x0012, 0x0013 },
    { 0x0025, 0x0026, 0x0029, 0x002a },
    { 0x0047, 0x0048, 0x004b, 0x004c },
    { 0x006f, 0x0070, 0x0073, 0x0074 }
};

#endif

/************************************************************************
 * Key shift related.							*
 ************************************************************************/
#define Quarter_Tone
#ifdef Quarter_Tone
int    vp_key_port[] = {
    0x004c0c43, 0x004e0483, 0x00510cc4, 0x005410c6,
    0x00560cc8, 0x0058094a, 0x005a05ce, 0x00000000,
    0x006685ef, 0x0068896b, 0x006c90e7, 0x006f8ce5,
    0x007284a4, 0x00759424, 0x0078a863};
#else
int    vp_key_port[] = {
    0x00403821, 0x00441481, 0x00482842, 0x004c0c43,
    0x00510cc4, 0x00560cc8, 0x005a05ce, 0x00000000,
    0x006685ef, 0x006c90e7, 0x007284a4, 0x0078a863,
    0x0080b842, 0x00888c61, 0x0090d821
};
#endif

#ifdef DSC
/************************************************************************
 * DSC audio clock frequencies                                          *
 ************************************************************************/
typedef struct {
    unsigned char cnt0l;
    unsigned char cnt0h;
    unsigned char cnt1l;
    unsigned char cnt1h;
    unsigned char pllm;
    unsigned char plln;
} DSC_AUDIO;

DSC_AUDIO DSC_audiosettings[] = {
  /* cnt0l cnt0h cnt1l cnt1h pllm  plln */
    {0x20, 0xe6, 0x7a, 0x07, 0x7c, 0x30},       /* 11.2896MHz (44.1K)   */
    {0x00, 0xe6, 0xd1, 0x08, 0x4a, 0x1f},       /* 12.2880MHZ (48.0K)   */
    {0x00, 0xe4, 0xd1, 0x06, 0xe0, 0x3f},       /*  8.1920MHz (32.0K)   */
};
#endif

#ifdef SERVO
unsigned short abs2trk[] = {
         0,    452,    891,   1319,   1737,
      2145,   2543,   2933,   3315,   3690,
      4057,   4418,   4772,   5120,   5462,
      5799,   6131,   6458,   6780,   7097,
      7410,   7719,   8024,   8325,   8622,
      8916,   9206,   9492,   9776,  10056,
     10334,  10608,  10880,  11149,  11415,
     11678,  11940,  12198,  12454,  12708,
     12960,  13209,  13457,  13702,  13945,
     14186,  14426,  14663,  14899,  15132,
     15364,  15595,  15823,  16050,  16275,
     16499,  16721,  16942,  17161,  17379, 
     17595,  17810,  18024,  18236,  18447,
     18656,  18864,  19071,  19277,  19482,
     19685,  19888,  20089,  20289,  20487,
     20685,  20882,  21078,  21272,  21466,
     21658,  21800,  21950,  22100,  22250,
     22350,  22450,  22550,  22650,  22700,
     22750,  22800,  22850,  22900,  22950,
     23000,  23000,  23000,  23000,  23000

    /* 
     * NOTE: only 100 entries needed,i.e. for 0-99 minutes (inclusive)
     */
};

#ifdef CXDSERVO
unsigned short filtertbl[] = {
    /* 0x34xxxx commands */
#ifdef CXD3059
    0x000c, 0x0510, 0x0e82, 0x105a,
    0x1128, 0x1330, 0x19f1, 0x2081,
    0x2153, 0x2232, 0x2330, 0x304a,
    0x3800, 0x3900, 0x3a00, 0x3b00,
    0x40fa, 0x436a, 0x4447, 0x456d,
    0x46e9, 0xb0a0, 0xc083,
#elif defined(CXD3068)
    0x0080, 0x0504, 0x1140, 0x400c,
    0x436a, 0x444A, 0x4572
#else /* default */
    0x0080, 0x0504, 0x1140, 0x400b,
    0x436a, 0x4447, 0x457d
#endif
};
#endif /* CXDSERVO */

#ifdef ESS3721	/* maor */

/* 
   don't go past CDinfo.leadout,
   keep lower jump level while near leadout (maor 04/03/2004)
*/
/* seek in     out  */
#ifdef LOAD_213C
ushort ab[16] = {0x100, 0x005,  0xa0, 0x003,
                 0x105, 0x008, 0x105, 0x008,
                 0x270, 0x00a, 0x240, 0x009,
                 0x220, 0x009, 0x200, 0x008
                 };
#else
#ifdef LOAD_SANYO
ushort ab[16] = {0x180, 0x030, 0x180, 0x030,
                 0x1b0, 0x060, 0x1b0, 0x060,
                 0x270, 0x0a0, 0x240, 0x090,
                 0x220, 0x090, 0x200, 0x080
                 };
#else   /* LOAD_B31 */
ushort ab[16] = {0x100, 0x005,  0xa0, 0x003,
                 0x105, 0x008, 0x105, 0x008,
                 0x270, 0x00a, 0x240, 0x009,
                 0x220, 0x009, 0x200, 0x008
                 };
#endif
#endif

unsigned short sled_parameter[]= {
#ifdef KA9258
    /* sled in parameter */
    0xfc0,
    /* sled normal parameter */
    0xfe0,
    /* M move max in parameter  direction value is 0 */
    0xfd0,
    /* M move min in parameter  direction value is 0 */
    0xfe0,
    /* M move max out parameter 1 */
    0xfc0,
    /* M move min out parameter 1 */
    0xfe0,
    /* Jump 2N in parameter */
    0xffa,
    /* Jump 2N out parameter */
    0xffa
#elif defined(KA9259)
	/* sled in parameter */
	0xf00,
	/* sled normal parameter */
	0xfe0,
	/* M move max in parameter  direction value is 0 */
	0xfa0,
	/* M move min in parameter  direction value is 0 */
	0xfb0,
	/* M move max out parameter 1 */
	0xfa0,
	/* M move min out parameter 1 */
	0xfb0,
	/* Jump 2N in parameter */
	0xfc0,
	/* Jump 2N out parameter */
	0xfd0
#else /* default */

#ifdef LOAD_SANYO
	/* sled in parameter */
	0xf00,
	/* sled normal parameter */
	0xfe0,
	/* M move max in parameter  direction value is 0 */
	0xfa0,
	/* M move min in parameter  direction value is 0 */
	0xfb0,
	/* M move max out parameter 1 */
	0xfa0,