rvtr/twl_wrapsdk
1
Fork 0
mirror of https://github.com/rvtr/twl_wrapsdk.git synced 2025-10-31 06:11:10 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity

libraries/snd/ARM7/src/snd_mic.c で定義されていたマイク関数を削除し、新規にlibralies/mic 関数を追加。

Browse Source 
CODEC関連コードを更新。

git-svn-id: file:///Users/lillianskinner/Downloads/platinum/twl/twl_wrapsdk/trunk@287 4ee2a332-4b2b-5046-8439-1ba90f034370
This commit is contained in:
kamikawa 2007-09-28 10:35:18 +00:00
parent 2d80464f0b
commit bfc9350270
37 changed files with 1599 additions and 1204 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
build/buildtools/commondefs
View File

@ -188,6 +188,7 @@ TWL_LIBS_BASE ?= \
libcamera \ libcamera \
libdsp \ libdsp \
libspi \ libspi \
libtwlmic \
ifdef TWL_PROFILE_TYPE ifdef TWL_PROFILE_TYPE
TWL_LIBS_BASE += libos.$(TWL_PROFILE_TYPE) TWL_LIBS_BASE += libos.$(TWL_PROFILE_TYPE)
@ -208,6 +209,8 @@ TWL_LIBS_BASE ?= \
libcdc_sp \ libcdc_sp \
libsnd_sp \ libsnd_sp \
libcamera_sp \ libcamera_sp \
libtwlmic_sp \
libmic_sp \
ifdef TWL_PROFILE_TYPE ifdef TWL_PROFILE_TYPE
TWL_LIBS_BASE += libos_sp.$(TWL_PROFILE_TYPE) TWL_LIBS_BASE += libos_sp.$(TWL_PROFILE_TYPE)

1
build/libraries/Makefile
View File

@ -36,6 +36,7 @@ SUBDIRS = \
dsp \ dsp \
el \ el \
sample_dll \ sample_dll \
mic \
ifdef TWL_PRIVATE ifdef TWL_PRIVATE
SUBDIRS += \ SUBDIRS += \

7
build/libraries/cdc/ARM7/Makefile
View File

@ -37,13 +37,6 @@ TARGET_LIB = libcdc_sp$(TWL_LIBSUFFIX).a
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------
# DEBUG版ビルドの場合、RELEASE版でビルドして
# DEBUG版のライブラリを装います。
ifdef TWL_DEBUG
TWL_BUILD_TYPE = RELEASE
endif
include $(TWLSDK_ROOT)/build/buildtools/commondefs include $(TWLSDK_ROOT)/build/buildtools/commondefs
INSTALL_TARGETS = $(TARGETS) INSTALL_TARGETS = $(TARGETS)

373
build/libraries/cdc/ARM7/src/cdc.c
View File

@ -13,46 +13,93 @@
$Log: $ $Log: $
$NoKeywords: $ $NoKeywords: $
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
/*
このソースで定義されているSPIアクセス関数はCODECがTWLモードの時に
　　CODECにアクセスするために使用します。CODECがDSモードの時は
　　cdc_dsmode_access.c で定義されている関数を使用してください。
[CTRモード時]
ＳＰＩ最大速度　：　4MHz (CODEC側の制限）
チップセレクト　：　TCSN
Read/Write指定　：　LSB
*/
#include <twl.h> #include <twl.h>
#include <twl/i2c/ARM7/i2c.h>
#include <twl/cdc/ARM7/cdc_reg.h> #include <twl/cdc/ARM7/cdc_reg.h>
#include <twl/cdc/ARM7/cdc.h> #include <twl/cdc/ARM7/cdc.h>
#include "spi_sp.h" #include <spi_sp.h>
/* /*---------------------------------------------------------------------------*
このソースで定義されているSPIアクセス関数はTWLモード時に使用します。 定数定義
　　DSモード時は cdc_dsmode_access.c の関数を使用してください。 *---------------------------------------------------------------------------*/
*/
#define CDC_SPI_MODE_SETTING ((u16)((1 << REG_SPI_SPICNT_E_SHIFT) | \
SPIBaudRate cdcSPIBaudRate = CDC_SPI_BAUDRATE_DEFAULT;
BOOL cdcIsTwlMode = TRUE;
int cdcCurrentPage = 0;
int cdcRevisionID = 0;
/*
#define CDC_SPI_MODE_SETTING_REVISION_A ((u16)((1 << REG_SPI_SPICNT_E_SHIFT) | \
(0 << REG_SPI_SPICNT_I_SHIFT) | \
(SPI_SLAVE_RESERVED << REG_SPI_SPICNT_SEL_SHIFT) | \
(CDC_SPI_BAUDRATE_DEFAULT << REG_SPI_SPICNT_BAUDRATE_SHIFT)))
*/
#define CDC_SPI_MODE_SETTING_REVISION_B ((u16)((1 << REG_SPI_SPICNT_E_SHIFT) | \
(0 << REG_SPI_SPICNT_I_SHIFT) | \ (0 << REG_SPI_SPICNT_I_SHIFT) | \
(SPI_COMMPARTNER_TP << REG_SPI_SPICNT_SEL_SHIFT) | \ (SPI_COMMPARTNER_TP << REG_SPI_SPICNT_SEL_SHIFT) | \
(CDC_SPI_BAUDRATE_DEFAULT << REG_SPI_SPICNT_BAUDRATE_SHIFT))) (CDC_SPI_BAUDRATE_DEFAULT << REG_SPI_SPICNT_BAUDRATE_SHIFT)))
#define CDC_SPI_MODE_SETTING_REVISION_C CDC_SPI_MODE_SETTING_REVISION_B /*---------------------------------------------------------------------------*
内部変数定義
*---------------------------------------------------------------------------*/
u16 cdcSpiMode = CDC_SPI_MODE_SETTING_REVISION_B; static OSMutex cdcMutex;
/*---------------------------------------------------------------------------*
関数定義
*---------------------------------------------------------------------------*/
//================================================================================
static inline void CDCi_ChangeSpiMode( SPITransMode continuous ) static inline void CDCi_ChangeSpiMode( SPITransMode continuous )
{ {
reg_SPI_SPICNT = (u16)((continuous << REG_SPI_SPICNT_MODE_SHIFT) | cdcSpiMode ); reg_SPI_SPICNT = (u16)((continuous << REG_SPI_SPICNT_MODE_SHIFT) | CDC_SPI_MODE_SETTING );
} }
/*---------------------------------------------------------------------------*
Name: CDC_InitMutex
Description: Init CODEC Mutex
Arguments: None
Returns: None
*---------------------------------------------------------------------------*/
void CDC_InitMutex(void)
{
OS_InitMutex(&cdcMutex);
}
/*---------------------------------------------------------------------------*
Name: CDC_Lock
Description: Lock CODEC device
Arguments: None
Returns: TRUE if success
*---------------------------------------------------------------------------*/
void CDC_Lock( void ) // 外部スレッドから呼ばれ、CODECデバイスの操作権利を取得する
{
OS_LockMutex( &cdcMutex );
}
/*---------------------------------------------------------------------------*
Name: CDC_Unlock
Description: Unlock CODEC device
Arguments: None
Returns: TRUE if success
*---------------------------------------------------------------------------*/
void CDC_Unlock( void ) // 外部スレッドから呼ばれ、CODECデバイスの操作権利を解放する
{
OS_UnlockMutex( &cdcMutex );
}
//================================================================================ //================================================================================
// SPI BIT CONTROL // SPI BIT CONTROL
//================================================================================ //================================================================================
@ -76,6 +123,18 @@ void CDCi_SetSpiParams( u8 reg, u8 setBits, u8 maskBits )
tmp |= setBits; tmp |= setBits;
CDCi_WriteSpiRegister( reg, tmp ); CDCi_WriteSpiRegister( reg, tmp );
} }
/*---------------------------------------------------------------------------*
Name: CDC_SetSpiParams
Description: set control bit to device register
Arguments: reg : device register
setBits : bits to set
maskBits : bits to mask
Returns: None
*---------------------------------------------------------------------------*/
void CDC_SetSpiParams( u8 reg, u8 setBits, u8 maskBits ) void CDC_SetSpiParams( u8 reg, u8 setBits, u8 maskBits )
{ {
(void)SPI_Lock(123); (void)SPI_Lock(123);
@ -83,6 +142,41 @@ void CDC_SetSpiParams( u8 reg, u8 setBits, u8 maskBits )
(void)SPI_Unlock(123); (void)SPI_Unlock(123);
} }
/*---------------------------------------------------------------------------*
Name: CDCi_SetSpiParamsEx
Description: set control bit to device register
Arguments: reg : device register
setBits : bits to set
maskBits : bits to mask
Returns: None
*---------------------------------------------------------------------------*/
void CDCi_SetSpiParamsEx( u8 page, u8 reg, u8 setBits, u8 maskBits )
{
CDC_ChangePage( page );
CDC_SetSpiParams( reg, setBits, maskBits );
}
/*---------------------------------------------------------------------------*
Name: CDC_SetSpiParamsEx
Description: set control bit to device register
Arguments: reg : device register
setBits : bits to set
maskBits : bits to mask
Returns: None
*---------------------------------------------------------------------------*/
void CDC_SetSpiParamsEx( u8 page, u8 reg, u8 setBits, u8 maskBits )
{
CDC_Lock();
CDCi_SetSpiParamsEx( page, reg, setBits, maskBits );
CDC_Unlock();
}
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: CDCi_SetSpiFlags Name: CDCi_SetSpiFlags
@ -97,10 +191,6 @@ void CDCi_SetSpiFlags( u8 reg, u8 setBits )
{ {
CDCi_SetSpiParams( reg, setBits, setBits ); CDCi_SetSpiParams( reg, setBits, setBits );
} }
void CDC_SetSpiFlags( u8 reg, u8 setBits )
{
CDC_SetSpiParams( reg, setBits, setBits );
}
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: CDCi_ClearSpiFlags Name: CDCi_ClearSpiFlags
@ -116,14 +206,11 @@ void CDCi_ClearSpiFlags( u8 reg, u8 clrBits )
{ {
CDCi_SetSpiParams( reg, 0, clrBits ); CDCi_SetSpiParams( reg, 0, clrBits );
} }
void CDC_ClearSpiFlags( u8 reg, u8 clrBits )
{
CDC_SetSpiParams( reg, 0, clrBits );
}
//================================================================================ //================================================================================
// SPI ACCESS // SPI ACCESS
//================================================================================ //================================================================================
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: CDCi_WriteSpiRegister Name: CDCi_WriteSpiRegister
@ -145,6 +232,58 @@ void CDCi_WriteSpiRegister( u8 reg, u8 data )
SPI_Send( data ); SPI_Send( data );
} }
/*---------------------------------------------------------------------------*
Name: CDC_WriteSpiRegister
Description: set value to decive register through SPI.
Arguments: reg : decive register
data : value to be written
Returns: None
*---------------------------------------------------------------------------*/
void CDC_WriteSpiRegister( u8 reg, u8 data )
{
(void)SPI_Lock(123);
CDCi_WriteSpiRegister( reg, data );
(void)SPI_Unlock(123);
}
/*---------------------------------------------------------------------------*
Name: CDCi_WriteSpiRegisterEx
Description: set value to decive register through SPI.
Arguments: page
reg : decive register
data : value to be written
Returns: None
*---------------------------------------------------------------------------*/
void CDCi_WriteSpiRegisterEx( u8 page, u8 reg, u8 data )
{
CDC_ChangePage( page );
CDC_WriteSpiRegister( reg, data );
}
/*---------------------------------------------------------------------------*
Name: CDC_WriteSpiRegisterEx
Description: set value to decive register through SPI.
Arguments: page
reg : decive register
data : value to be written
Returns: None
*---------------------------------------------------------------------------*/
void CDC_WriteSpiRegisterEx( u8 page, u8 reg, u8 data )
{
CDC_Lock();
CDCi_WriteSpiRegisterEx( page, reg, data );
CDC_Unlock();
}
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: CDCi_ReadSpiRegister Name: CDCi_ReadSpiRegister
@ -168,6 +307,61 @@ u8 CDCi_ReadSpiRegister( u8 reg )
return data; return data;
} }
/*---------------------------------------------------------------------------*
Name: CDC_ReadSpiRegister
Description: get value from decive register through SPI.
Arguments: reg : decive register
Returns: value which is read from specified decive register
*---------------------------------------------------------------------------*/
u8 CDC_ReadSpiRegister( u8 reg )
{
u8 value;
(void)SPI_Lock(123);
value = CDCi_ReadSpiRegister( reg );
(void)SPI_Unlock(123);
return value;
}
/*---------------------------------------------------------------------------*
Name: CDCi_ReadSpiRegisterEx
Description: get value from decive register through SPI.
Arguments: reg : decive register
Returns: value which is read from specified decive register
*---------------------------------------------------------------------------*/
u8 CDCi_ReadSpiRegisterEx( u8 page, u8 reg )
{
u8 value;
CDC_ChangePage( page );
value = CDC_ReadSpiRegister( reg );
return value;
}
/*---------------------------------------------------------------------------*
Name: CDC_ReadSpiRegisterEx
Description: get value from decive register through SPI.
Arguments: reg : decive register
Returns: value which is read from specified decive register
*---------------------------------------------------------------------------*/
u8 CDC_ReadSpiRegisterEx( u8 page, u8 reg )
{
u8 value;
CDC_Lock();
value = CDCi_ReadSpiRegisterEx( page, reg );
CDC_Unlock();
return value;
}
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: CDCi_WriteSpiRegisters Name: CDCi_WriteSpiRegisters
@ -197,6 +391,56 @@ void CDCi_WriteSpiRegisters( u8 reg, const u8 *bufp, size_t size )
SPI_Send( *bufp++ ); SPI_Send( *bufp++ );
} }
/*---------------------------------------------------------------------------*
Name: CDC_WriteSpiRegisters
Description: set value to decive registers through SPI.
Arguments: reg : decive register
data : value to be written
Returns: None
*---------------------------------------------------------------------------*/
void CDC_WriteSpiRegisters( u8 reg, const u8 *bufp, size_t size )
{
(void)SPI_Lock(123);
CDCi_WriteSpiRegisters( reg, bufp, size );
(void)SPI_Unlock(123);
}
/*---------------------------------------------------------------------------*
Name: CDCi_WriteSpiRegistersEx
Description: set value to decive registers through SPI.
Arguments: reg : decive register
data : value to be written
Returns: None
*---------------------------------------------------------------------------*/
void CDCi_WriteSpiRegistersEx( u8 page, u8 reg, const u8 *bufp, size_t size )
{
CDC_ChangePage( page );
CDC_WriteSpiRegisters( reg, bufp, size );
}
/*---------------------------------------------------------------------------*
Name: CDC_WriteSpiRegistersEx
Description: set value to decive registers through SPI.
Arguments: reg : decive register
data : value to be written
Returns: None
*---------------------------------------------------------------------------*/
void CDC_WriteSpiRegistersEx( u8 page, u8 reg, const u8 *bufp, size_t size )
{
CDC_Lock();
CDCi_WriteSpiRegistersEx( page, reg, bufp, size );
CDC_Unlock();
}
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: CDCi_ReadSpiRegisters Name: CDCi_ReadSpiRegisters
@ -224,6 +468,53 @@ void CDCi_ReadSpiRegisters( u8 reg, u8 *bufp, size_t size )
*bufp++ = (u8)SPI_DummyWaitReceive(); *bufp++ = (u8)SPI_DummyWaitReceive();
} }
/*---------------------------------------------------------------------------*
Name: CDC_ReadSpiRegisters
Description: get value from decive registers through SPI.
Arguments: reg : decive register
Returns: value which is read from specified decive register
*---------------------------------------------------------------------------*/
void CDC_ReadSpiRegisters( u8 reg, u8 *bufp, size_t size )
{
(void)SPI_Lock(123);
CDCi_ReadSpiRegisters( reg, bufp, size );
(void)SPI_Unlock(123);
}
/*---------------------------------------------------------------------------*
Name: CDCi_ReadSpiRegistersEx
Description: get value from decive registers through SPI.
Arguments: reg : decive register
Returns: value which is read from specified decive register
*---------------------------------------------------------------------------*/
void CDCi_ReadSpiRegistersEx( u8 page, u8 reg, u8 *bufp, size_t size )
{
CDC_ChangePage( page );
CDC_ReadSpiRegisters( reg, bufp, size );
}
/*---------------------------------------------------------------------------*
Name: CDC_ReadSpiRegistersEx
Description: get value from decive registers through SPI.
Arguments: reg : decive register
Returns: value which is read from specified decive register
*---------------------------------------------------------------------------*/
void CDC_ReadSpiRegistersEx( u8 page, u8 reg, u8 *bufp, size_t size )
{
CDC_Lock();
CDCi_ReadSpiRegistersEx( page, reg, bufp, size );
CDC_Unlock();
}
//================================================================================ //================================================================================
// Utility Functions // Utility Functions
//================================================================================ //================================================================================
@ -236,8 +527,10 @@ void CDCi_ReadSpiRegisters( u8 reg, u8 *bufp, size_t size )
Returns: None Returns: None
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void CDCi_ChangePage( int page_no ) void CDCi_ChangePage( u8 page_no )
{ {
static u8 cdcCurrentPage = 0;
SDK_ASSERT( (page_no == 0) || (page_no == 1) || (page_no == 3) || (page_no == 4) || SDK_ASSERT( (page_no == 0) || (page_no == 1) || (page_no == 3) || (page_no == 4) ||
(page_no == 8) || (page_no == 9) || (page_no == 252) || (page_no == 255) ); (page_no == 8) || (page_no == 9) || (page_no == 252) || (page_no == 255) );
@ -248,21 +541,21 @@ void CDCi_ChangePage( int page_no )
// 255 ‚¾‚¯•Êˆµ‚¢ // 255 ‚¾‚¯•Êˆµ‚¢
if (cdcCurrentPage == 255) if (cdcCurrentPage == 255)
{ {
CDCi_WriteI2cRegister( REG_CDC255_PAGE_CTL_ADDR, (u8)page_no ); CDCi_WriteSpiRegister( REG_CDC255_PAGE_CTL_ADDR, (u8)page_no );
} }
else else
{ {
CDCi_WriteI2cRegister( REG_CDC_PAGE_CTL_ADDR, (u8)page_no ); CDCi_WriteSpiRegister( REG_CDC_PAGE_CTL_ADDR, (u8)page_no );
} }
cdcCurrentPage = page_no; cdcCurrentPage = page_no;
} }
// maybe change i2c to spi
void CDC_ChangePage( int page_no ) void CDC_ChangePage( u8 page_no )
{ {
(void)I2C_Lock(); (void)SPI_Lock(123);
CDCi_ChangePage( page_no ); CDCi_ChangePage( page_no );
(void)I2C_Unlock(); (void)SPI_Unlock(123);
} }

397
build/libraries/cdc/ARM7/src/cdc_api.c
View File

@ -13,15 +13,92 @@
$Log: $ $Log: $
$NoKeywords: $ $NoKeywords: $
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
/*
　CODECのレジスタアクセスにはページ切り替えが存在します。
　Page0,1,3,4,8,9,252,255 が存在し、各ページに異なる機能の
　レジスタが列挙されています。
　"現在のページ"が、割り込みハンドラや別スレッドによって処理の
　途中で変更されてしまうと困ったことになります。
　【問題となる例】
　 スレッドＡ
　（優先度低）
┏━━━━━━┓　　　 　　スレッドB
┃ページ０へ　┃　　　　　（優先度高）
┃　　　　　　┃→→→→┏━━━━━━┓
┃　　　　　　┃←←　　┃ページ１へ　┃
┃Access ┃ 　↑ 　┃　　　　　　┃
┃Page 0　 　┃ 　↑ 　┃Access　　　┃
┃Registers ┃ 　↑　 ┃Page 1　　　┃
┗━━━━━━┛ 　↑ 　┃Registers　 ┃
　 ←←┗━━━━━━┛
　そこで、Codecへのアクセスに関してMutexによる排他制御を行います。
　（短期間であれば割り込み禁止でもいいかも）
　【Mutexによる排他制御】
　 スレッドＡ
　（優先度低）
┏━━━━━━┓
┃Mutex Lock ┃
┃　　　　　　┃　　　 　　スレッドB
┃ページ０へ　┃　　　　　（優先度高）
┃　　　　　　┃→→→→┏━━━━━━┓
┃Access　　　┃←←←←┃Mutex Lock　┃
┃Page 0　　　┃　　→→┃　　　　　　┃
┃Registers ┃ 　↑ 　┃ページ１へ　┃
┃ 　 　┃ 　↑　 ┃　　　　　　┃
┃Mutex Unlock┃→→ ┃Access　　　┃
┗━━━━━━┛ 　　 　┃Page 1　 ┃
　 　 　┃Registers　 ┃
　 　　┗━━━━━━┛
　CodecへのアクセスにはSPI通信もしくはI2C通信を使用
　しますが、これらの関数においてもMutexによる排他制御
　が行われています。そのため、スレッドＡがCODEC用の
　Mutexを取得し、スレッドＢがSPI用のMutexを取得した
　場合に、いわゆるデッドロック状態となる場合があります。
　デッドロックを回避するセオリーは1つのスレッドにおいて
　複数のMutexを取得しないことですが、CODECに関してはそれが
　難しいため、Mutexを取得する順番を統一することでデッド
　ロックを回避します。
　【方針】
　① CODECへのアクセスに関してMutexによる排他制御を行う。
　　 I2C/SPI通信を行う場合、それらの関数内部でもMutexが使用
　　 されていることに注意する。デッドロックを回避するため、
　　 Mutexの取得順はCODECが先、I2C/SPIが後とする。
　② 割り込みハンドラ内では原則CODECアクセスは行わない。
　　（割り込みハンドラ内ではMutex取得待ちの際にスレッド切り替え
　　　が発生しないためMutexを永久に取得できない可能性がある）
　　 割り込みハンドラではスレッドを作成もしくは起床させ、
そのスレッドにおいてCODECアクセスを行う。
*/
#include <twl.h> #include <twl.h>
#include <twl/cdc.h> #include <twl/cdc.h>
#include <pm_pmic.h>
#include "pm_pmic.h" u8 isADCOn = FALSE;
u8 isDACOn = FALSE;
u8 cdcIsTwlMode = TRUE;
BOOL isADCOn = FALSE; #define CDC_PLL_STABLE_WAIT_TIME 20 // 約20msのウェイトが必要
BOOL isDACOn = FALSE;
#define CDC_PLL_STABLE_WAIT_TIME 18
#define CDC_SCAN_MODE_TIMER_CLOCK_DIVIDER_VALUE 24 #define CDC_SCAN_MODE_TIMER_CLOCK_DIVIDER_VALUE 24
static void CDCi_PowerUpPLL( void ); static void CDCi_PowerUpPLL( void );
@ -43,15 +120,17 @@ void CDC_Init( void )
{ {
reg_CFG_CLK |= REG_CFG_CLK_SND_MASK; reg_CFG_CLK |= REG_CFG_CLK_SND_MASK;
CDC_InitMutex();
CDC_Reset(); CDC_Reset();
cdcRevisionID = CDC_GetRevisionId(); CDC_SetPLL( CDC_PLL_PARAMETER_FOR_SAMPLING_RATE_47610 );
CDC_SetScanModeTimerClockDivider( CDC_SCAN_MODE_TIMER_CLOCK_DIVIDER_VALUE );
CDCi_PowerUpPLL(); CDCi_PowerUpPLL();
CDC_InitSound(); CDC_InitSound();
CDC_SetScanModeTimerClockDivider( CDC_SCAN_MODE_TIMER_CLOCK_DIVIDER_VALUE );
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
@ -65,8 +144,7 @@ void CDC_Init( void )
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void CDC_Reset( void ) void CDC_Reset( void )
{ {
CDC_ChangePage( 0 ); CDC_WriteSpiRegisterEx( 0, REG_CDC0_RST_ADDR, CDC0_RST_E );
CDC_WriteI2cRegister( REG_CDC0_RST_ADDR, CDC0_RST_E );
CDC_SetInputPinControl( TRUE, TRUE, TRUE ); // enable VCNT5,SP#HP,PMOFF pin CDC_SetInputPinControl( TRUE, TRUE, TRUE ); // enable VCNT5,SP#HP,PMOFF pin
OS_Sleep(1); OS_Sleep(1);
} }
@ -82,7 +160,7 @@ void CDC_Reset( void )
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void CDC_InitSound( void ) void CDC_InitSound( void )
{ {
#if 1 // このコードは本来、cdcInitSound呼び出しルーチンが記述すべきコード。 #if 1
// Enable I2S // Enable I2S
reg_SND_I2SCNT |= REG_SND_I2SCNT_E_MASK; reg_SND_I2SCNT |= REG_SND_I2SCNT_E_MASK;
#endif #endif
@ -120,8 +198,7 @@ void CDC_InitSound( void )
void CDC_InitMic( void ) void CDC_InitMic( void )
{ {
// setup Mic Bias // setup Mic Bias
CDC_ChangePage( 1 ); CDC_WriteSpiRegisterEx( 1, REG_CDC1_MIC_BIAS_ADDR, CDC1_MIC_BIAS_2_5V );
CDC_WriteI2cRegister( REG_CDC1_MIC_BIAS_ADDR, CDC1_MIC_BIAS_2_5V );
#if 1 // このコードは本来、cdcInitSound呼び出しルーチンが記述すべきコード。 #if 1 // このコードは本来、cdcInitSound呼び出しルーチンが記述すべきコード。
// Enable I2S // Enable I2S
@ -135,9 +212,15 @@ void CDC_InitMic( void )
CDC_PowerUpADC(); CDC_PowerUpADC();
CDC_UnmuteADC(); CDC_UnmuteADC();
CDC_EnableAGC( CDC0_AGC_CTL1_DEFAULT_GAIN ); // AGC(Automatic Gain Control)で取得値を調整されると
} // ライブラリの正常動作を確認しにくいため暫定的にdisableにしています。
// 最終的にAGCとPGAのどちらをデフォルトにするかは未定です。
// ゲイン設定
// CDC_EnableAGC( CDC0_AGC_CTL1_DEFAULT_GAIN );
CDC_DisableAGC();
CDC_SetPGAB( 40 );
}
//================================================================================ //================================================================================
// Query APIs // Query APIs
@ -167,8 +250,7 @@ BOOL CDC_IsTwlMode( void )
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
u8 CDC_GetVendorId( void ) u8 CDC_GetVendorId( void )
{ {
CDC_ChangePage( 0 ); return CDC_ReadSpiRegisterEx( 0, REG_CDC0_VEND_ID_ADDR );
return CDC_ReadI2cRegister( REG_CDC0_VEND_ID_ADDR );
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
@ -182,8 +264,7 @@ u8 CDC_GetVendorId( void )
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
u8 CDC_GetRevisionId( void ) u8 CDC_GetRevisionId( void )
{ {
CDC_ChangePage( 0 ); return (u8)(( CDC_ReadSpiRegisterEx( 0, REG_CDC0_REV_ID_ADDR ) & CDC0_REV_ID_MASK ) >> CDC0_REV_ID_SHIFT);
return (u8)(( CDC_ReadI2cRegister( REG_CDC0_REV_ID_ADDR ) & CDC0_REV_ID_MASK ) >> CDC0_REV_ID_SHIFT);
} }
//================================================================================ //================================================================================
@ -201,69 +282,52 @@ u8 CDC_GetRevisionId( void )
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void CDC_GoDsMode( void ) void CDC_GoDsMode( void )
{ {
CDC_ChangePage( 0 );
//#ifdef CDC_REVISION_A #ifdef CDC_REVISION_A
// CODEC-IC bug workaround // CODEC-IC bug workaround
CDC_PowerUpADC(); CDC_PowerUpADC();
CDC_UnmuteADC(); CDC_UnmuteADC();
//#endif // CDC_REVISION_A #endif // CDC_REVISION_A
///////////////// 箕輪君の要望により+7dB設定を試す（従来の2.5倍音圧相当） // デジタルボリューム設定 +7dB（従来の2.5倍音圧相当）
CDC_WriteI2cRegister( REG_CDC0_DIG_VOL_L_ADDR, 14 ); CDC_WriteSpiRegisterEx( 0, REG_CDC0_DIG_VOL_L_ADDR, 14 );
CDC_WriteI2cRegister( REG_CDC0_DIG_VOL_R_ADDR, 14 ); CDC_WriteSpiRegisterEx( 0, REG_CDC0_DIG_VOL_R_ADDR, 14 );
/////////////////
// マイクバイアスを設定しておく必要がある。DSモードに入ってからは // マイクバイアスを設定しておく必要がある。
// この設定を行う手段がない。 // DSモードに入ってからはこの設定を行う手段がない。
CDC_ChangePage( 1 ); CDC_WriteSpiRegisterEx( 1, REG_CDC1_MIC_BIAS_ADDR, CDC1_MIC_BIAS_2_5V );
CDC_WriteI2cRegister( REG_CDC1_MIC_BIAS_ADDR, CDC1_MIC_BIAS_2_5V );
// PGA 設定も同様（18.8k 設定でDSと同等のゲインが得られる）
CDC_WriteI2cRegister( REG_CDC1_MIC_PGA_P_ADDR, 1 << CDC1_MIC_PGA_P_I_SHIFT);
CDC_WriteI2cRegister( REG_CDC1_MIC_PGA_M_ADDR, 1 << CDC1_MIC_PGA_M_I_SHIFT);
// PGAインピーダンス 設定も同様（18.8k 設定でDSと同等のゲインが得られる）
CDC_WriteSpiRegisterEx( 1, REG_CDC1_MIC_PGA_P_ADDR, 1 << CDC1_MIC_PGA_P_I_SHIFT);
CDC_WriteSpiRegisterEx( 1, REG_CDC1_MIC_PGA_M_ADDR, 1 << CDC1_MIC_PGA_M_I_SHIFT);
// PLL 設定を DS 用に変更 // PLL 設定を DS 用に変更
CDC_WriteI2cRegister( REG_CDC0_PLL_J_ADDR, 21 ); CDC_WriteSpiRegisterEx( 0, REG_CDC0_PLL_J_ADDR, 21 );
CDC_WriteI2cRegister( REG_CDC0_NDAC_DIV_ADDR, CDC0_NDAC_DIV_PWR | 7 ); CDC_WriteSpiRegisterEx( 0, REG_CDC0_NDAC_DIV_ADDR, CDC0_NDAC_DIV_PWR | 7 );
CDC_WriteI2cRegister( REG_CDC0_NADC_DIV_ADDR, CDC0_NADC_DIV_PWR | 7 ); CDC_WriteSpiRegisterEx( 0, REG_CDC0_NADC_DIV_ADDR, CDC0_NADC_DIV_PWR | 7 );
CDC_ChangePage( 3 );
// READREADY 端子属性を TSC2046-PENINTERRUPT に変更 // READREADY 端子属性を TSC2046-PENINTERRUPT に変更
CDC_WriteI2cRegister( REG_CDC3_TP_CONV_MODE_ADDR, 0 ); CDC_WriteSpiRegisterEx( 3, REG_CDC3_TP_CONV_MODE_ADDR, 0 );
CDC_ChangePage( 255 );
// enable DS-Mode (via reg5 : current page=255) // enable DS-Mode (via reg5 : current page=255)
// //
// DS-mode default // DS-mode default
// Master Sound Power OFF, MicBias OFF, MicPGA x40 times // Master Sound Power OFF, MicBias OFF, MicPGA x40 times
CDC_WriteI2cRegister( REG_CDC255_BKCMPT_MODE_ADDR, CDC255_BKCMPT_MODE_DS ); CDC_WriteSpiRegisterEx( 255, REG_CDC255_BKCMPT_MODE_ADDR, CDC255_BKCMPT_MODE_DS );
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
// !! from now on, I2C cannot be used. Only DS-type PCSN,TCSN SPI can work. // !! from now on, I2C cannot be used. Only DS-type PCSN,TCSN SPI can work.
//------------------------------------------------------------------------- //-------------------------------------------------------------------------
{ // enable Master Sound Power (via reg0 : current page=255)
CDC_DsmodeSetSpiFlags( REG_CDC255_AUD_CTL_ADDR, CDC255_AUD_CTL_PWR );
// MicBias powered up // MicBias powered up
// In Rev-A, MicBias must be powered up before enabling Master Sound Power // In Rev-A, MicBias must be powered up before enabling Master Sound Power
CDC_DsmodeSetSpiFlags( REG_CDC255_DS_MIC_CTL_ADDR, CDC255_DS_MIC_CTL_BIAS_PWR ); CDC_DsmodeSetSpiFlags( REG_CDC255_DS_MIC_CTL_ADDR, CDC255_DS_MIC_CTL_BIAS_PWR );
// enable Master Sound Power (via reg0 : current page=255)
//
// note: In Rev-A, if Master Sound Power is off, touch-panel logic does
// not work.
//
// CODEC PCSN is connected to IO-board Analog Key CS.
// CODEC PCSN is associated with TouchPanel now (for revision A).
//
CDC_DsmodeSetSpiFlags( REG_CDC255_AUD_CTL_ADDR, CDC255_AUD_CTL_PWR );
}
// change CODEC status variable // change CODEC status variable
cdcIsTwlMode = FALSE; cdcIsTwlMode = FALSE;
} }
@ -284,15 +348,13 @@ void CDC_SetInputPinControl( BOOL enable_vcnt5, BOOL enable_sphp, BOOL enable
{ {
u8 work = 0; u8 work = 0;
CDC_ChangePage( 0 );
if (enable_vcnt5) work = CDC0_PIN_CTL1_VCNT5_E; if (enable_vcnt5) work = CDC0_PIN_CTL1_VCNT5_E;
if (enable_sphp) work |= CDC0_PIN_CTL1_SPHP_E; if (enable_sphp) work |= CDC0_PIN_CTL1_SPHP_E;
CDC_WriteI2cRegister( REG_CDC0_PIN_CTL1_ADDR, work ); CDC_WriteSpiRegisterEx( 0, REG_CDC0_PIN_CTL1_ADDR, work );
work = 0; work = 0;
if (enable_pmoff) work = CDC0_PIN_CTL2_PMOFF_E; if (enable_pmoff) work = CDC0_PIN_CTL2_PMOFF_E;
CDC_WriteI2cRegister( REG_CDC0_PIN_CTL2_ADDR, work ); CDC_WriteSpiRegisterEx( 0, REG_CDC0_PIN_CTL2_ADDR, work );
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
@ -314,20 +376,17 @@ void CDC_GetInputPinControl( BOOL *enable_vcnt5, BOOL *enable_sphp, BOOL *enable
*enable_sphp = FALSE; *enable_sphp = FALSE;
*enable_pmoff = FALSE; *enable_pmoff = FALSE;
CDC_ChangePage( 0 ); work = CDC_ReadSpiRegisterEx( 0, REG_CDC0_PIN_CTL1_ADDR );
work = CDC_ReadI2cRegister( REG_CDC0_PIN_CTL1_ADDR );
if ((work & CDC0_PIN_CTL1_VCNT5_MASK) == CDC0_PIN_CTL1_VCNT5_E) if ((work & CDC0_PIN_CTL1_VCNT5_MASK) == CDC0_PIN_CTL1_VCNT5_E)
*enable_vcnt5 = TRUE; *enable_vcnt5 = TRUE;
if ((work & CDC0_PIN_CTL1_SPHP_MASK) == CDC0_PIN_CTL1_SPHP_E) if ((work & CDC0_PIN_CTL1_SPHP_MASK) == CDC0_PIN_CTL1_SPHP_E)
*enable_sphp = TRUE; *enable_sphp = TRUE;
work = CDC_ReadI2cRegister( REG_CDC0_PIN_CTL2_ADDR ); work = CDC_ReadSpiRegisterEx( 0, REG_CDC0_PIN_CTL2_ADDR );
if ((work & CDC0_PIN_CTL2_PMOFF_MASK) == CDC0_PIN_CTL2_PMOFF_E) if ((work & CDC0_PIN_CTL2_PMOFF_MASK) == CDC0_PIN_CTL2_PMOFF_E)
*enable_pmoff = TRUE; *enable_pmoff = TRUE;
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: CDCi_PowerUpPLL Name: CDCi_PowerUpPLL
@ -340,8 +399,8 @@ void CDC_GetInputPinControl( BOOL *enable_vcnt5, BOOL *enable_sphp, BOOL *enable
static void CDCi_PowerUpPLL( void ) static void CDCi_PowerUpPLL( void )
{ {
// page 0, reg 5 で P=2,R=1,PLL on 設定 // page 0, reg 5 で P=2,R=1,PLL on 設定
CDC_ChangePage( 0 ); CDC_WriteSpiRegisterEx( 0,
CDC_WriteI2cRegister( REG_CDC0_PLL_P_R_ADDR, REG_CDC0_PLL_P_R_ADDR,
CDC0_PLL_P_R_PWR | CDC0_PLL_P_R_PWR |
(2 << CDC0_PLL_P_R_DIV_SHIFT) | (2 << CDC0_PLL_P_R_DIV_SHIFT) |
(1 << CDC0_PLL_P_R_MUL_SHIFT) ); (1 << CDC0_PLL_P_R_MUL_SHIFT) );
@ -359,37 +418,48 @@ static void CDCi_PowerUpPLL( void )
static void CDCi_PowerDownPLL( void ) static void CDCi_PowerDownPLL( void )
{ {
// page 0, reg 5 で PLL off 設定 // page 0, reg 5 で PLL off 設定
CDC_ChangePage( 0 ); CDC_WriteSpiRegisterEx( 0, REG_CDC0_PLL_P_R_ADDR, 0 );
CDC_WriteI2cRegister( REG_CDC0_PLL_P_R_ADDR, 0 );
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: CDC_SetParamPLL Name: CDC_SetPLL
Description: setup PLL parameter of the CODEC Description: setup PLL parameter of the CODEC
Note: PLLを安全に変更するためにはAD/DAを停止させなければならない。
Arguments: is48kHz : set 48 kHz if TRUE. set 32kHz if FALSE. Arguments: is48kHz : set 48 kHz if TRUE. set 32kHz if FALSE.
Returns: None Returns: None
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
// パラメータをいきなり変更しても問題ないか要確認 void
// Codec Off状態で変更すべき？ CDC_SetPLL( CDCPllParameter param )
void CDC_SetParamPLL( BOOL is48kHz )
{ {
if (is48kHz) CDC_Lock();
SPI_Lock(123);
CDCi_ChangePage( 0 );
switch ( param )
{ {
CDC_WriteI2cRegister( REG_CDC0_PLL_J_ADDR, 15 ); case CDC_PLL_PARAMETER_FOR_SAMPLING_RATE_32730:
CDC_WriteI2cRegister( REG_CDC0_NDAC_DIV_ADDR, CDC0_NDAC_DIV_PWR | 5 ); CDCi_WriteSpiRegister( REG_CDC0_PLL_J_ADDR, 21 );
CDC_WriteI2cRegister( REG_CDC0_NADC_DIV_ADDR, CDC0_NADC_DIV_PWR | 5 ); CDCi_WriteSpiRegister( REG_CDC0_NDAC_DIV_ADDR, CDC0_NDAC_DIV_PWR | 7 );
} CDCi_WriteSpiRegister( REG_CDC0_NADC_DIV_ADDR, CDC0_NADC_DIV_PWR | 7 );
else break;
{
CDC_WriteI2cRegister( REG_CDC0_PLL_J_ADDR, 21 ); case CDC_PLL_PARAMETER_FOR_SAMPLING_RATE_47610:
CDC_WriteI2cRegister( REG_CDC0_NDAC_DIV_ADDR, CDC0_NDAC_DIV_PWR | 7 ); CDCi_WriteSpiRegister( REG_CDC0_PLL_J_ADDR, 15 );
CDC_WriteI2cRegister( REG_CDC0_NADC_DIV_ADDR, CDC0_NADC_DIV_PWR | 7 ); CDCi_WriteSpiRegister( REG_CDC0_NDAC_DIV_ADDR, CDC0_NDAC_DIV_PWR | 5 );
CDCi_WriteSpiRegister( REG_CDC0_NADC_DIV_ADDR, CDC0_NADC_DIV_PWR | 5 );
break;
} }
SPI_Unlock(123);
CDC_Unlock();
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: CDC_PowerUpDAC Name: CDC_PowerUpDAC
@ -402,8 +472,8 @@ void CDC_SetParamPLL( BOOL is48kHz )
void CDC_PowerUpDAC( void ) void CDC_PowerUpDAC( void )
{ {
// page 0, reg 63 で Left/Right DAC On, datapath is straght-forward setting. // page 0, reg 63 で Left/Right DAC On, datapath is straght-forward setting.
CDC_ChangePage( 0 ); CDC_WriteSpiRegisterEx( 0,
CDC_WriteI2cRegister( REG_CDC0_DIG_PATH_ADDR, REG_CDC0_DIG_PATH_ADDR,
CDC0_DIG_PATH_CH_PWR_L | (1 << CDC0_DIG_PATH_L_SHIFT) | CDC0_DIG_PATH_CH_PWR_L | (1 << CDC0_DIG_PATH_L_SHIFT) |
CDC0_DIG_PATH_CH_PWR_R | (1 << CDC0_DIG_PATH_R_SHIFT) ); CDC0_DIG_PATH_CH_PWR_R | (1 << CDC0_DIG_PATH_R_SHIFT) );
@ -426,9 +496,7 @@ void CDC_PowerUpDAC( void )
void CDC_PowerDownDAC( void ) void CDC_PowerDownDAC( void )
{ {
// page 0, reg 63 で Left/Right DAC Off // page 0, reg 63 で Left/Right DAC Off
CDC_ChangePage( 0 ); CDC_WriteSpiRegisterEx( 0, REG_CDC0_DIG_PATH_ADDR, 0 );
CDC_WriteI2cRegister( REG_CDC0_DIG_PATH_ADDR, 0 );
isDACOn = FALSE; isDACOn = FALSE;
} }
@ -445,11 +513,17 @@ void CDC_PowerDownDAC( void )
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void CDC_SetupDAC( int hp_pwon_tm, int hp_rmpup_tm, int sphp_rmpdn_tm ) void CDC_SetupDAC( int hp_pwon_tm, int hp_rmpup_tm, int sphp_rmpdn_tm )
{ {
CDC_Lock();
SPI_Lock(123);
// page 1, reg 33--35 // page 1, reg 33--35
CDC_ChangePage( 1 ); CDCi_ChangePage( 1 );
CDC_WriteI2cRegister( REG_CDC1_HP_DRV_TM_ADDR, (u8)(hp_pwon_tm | hp_rmpup_tm) ); CDCi_WriteSpiRegister( REG_CDC1_HP_DRV_TM_ADDR, (u8)(hp_pwon_tm | hp_rmpup_tm) );
CDC_WriteI2cRegister( REG_CDC1_HPSP_RAMPDWN_ADDR, (u8)sphp_rmpdn_tm ); CDCi_WriteSpiRegister( REG_CDC1_HPSP_RAMPDWN_ADDR, (u8)sphp_rmpdn_tm );
CDC_WriteI2cRegister( REG_CDC1_DAC_OUTPUT_ADDR, CDC1_DAC_OUTPUT_E_R | CDC1_DAC_OUTPUT_E_L ); CDCi_WriteSpiRegister( REG_CDC1_DAC_OUTPUT_ADDR, CDC1_DAC_OUTPUT_E_R | CDC1_DAC_OUTPUT_E_L );
SPI_Unlock(123);
CDC_Unlock();
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
@ -463,24 +537,30 @@ void CDC_SetupDAC( int hp_pwon_tm, int hp_rmpup_tm, int sphp_rmpdn_tm )
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void CDC_EnableHeadphoneDriver( void ) void CDC_EnableHeadphoneDriver( void )
{ {
CDC_Lock();
SPI_Lock(123);
// page 1, reg 36--41 // page 1, reg 36--41
CDC_ChangePage( 1 ); CDCi_ChangePage( 1 );
// Mute Analog Volume // Mute Analog Volume
CDC_WriteI2cRegister( REG_CDC1_HP_ANGVOL_L_ADDR, CDC1_ANGVOL_E | CDC1_ANGVOL_GAIN_MUTE ); CDCi_WriteSpiRegister( REG_CDC1_HP_ANGVOL_L_ADDR, CDC1_ANGVOL_E | CDC1_ANGVOL_GAIN_MUTE );
CDC_WriteI2cRegister( REG_CDC1_HP_ANGVOL_R_ADDR, CDC1_ANGVOL_E | CDC1_ANGVOL_GAIN_MUTE ); CDCi_WriteSpiRegister( REG_CDC1_HP_ANGVOL_R_ADDR, CDC1_ANGVOL_E | CDC1_ANGVOL_GAIN_MUTE );
// Power Up Headphone Driver, with short-circuit protection // Power Up Headphone Driver, with short-circuit protection
CDC_WriteI2cRegister( REG_CDC1_HP_DRV_ADDR, CDC1_HP_DRV_PWR_L | CDC1_HP_DRV_PWR_R | CDCi_WriteSpiRegister( REG_CDC1_HP_DRV_ADDR, CDC1_HP_DRV_PWR_L | CDC1_HP_DRV_PWR_R |
CDC1_HP_CMN_MODE_VOL_1_65V | CDC1_HP_DRV_SHTC_PROTECT_E ); CDC1_HP_CMN_MODE_VOL_1_65V | CDC1_HP_DRV_SHTC_PROTECT_E );
// Un-mute Headphone // Un-mute Headphone
CDC_WriteI2cRegister( REG_CDC1_HP_DRV_L_ADDR, CDC1_HP_DRV_PDN_TRISTATE | CDC1_HP_DRV_MUTEN ); CDCi_WriteSpiRegister( REG_CDC1_HP_DRV_L_ADDR, CDC1_HP_DRV_PDN_TRISTATE | CDC1_HP_DRV_MUTEN );
CDC_WriteI2cRegister( REG_CDC1_HP_DRV_R_ADDR, CDC1_HP_DRV_PDN_TRISTATE | CDC1_HP_DRV_MUTEN ); CDCi_WriteSpiRegister( REG_CDC1_HP_DRV_R_ADDR, CDC1_HP_DRV_PDN_TRISTATE | CDC1_HP_DRV_MUTEN );
// Un-mute Analog Volume // Un-mute Analog Volume
CDC_WriteI2cRegister( REG_CDC1_HP_ANGVOL_L_ADDR, CDC1_ANGVOL_E | CDC1_ANGVOL_GAIN_MAX ); CDCi_WriteSpiRegister( REG_CDC1_HP_ANGVOL_L_ADDR, CDC1_ANGVOL_E | CDC1_ANGVOL_GAIN_MAX );
CDC_WriteI2cRegister( REG_CDC1_HP_ANGVOL_R_ADDR, CDC1_ANGVOL_E | CDC1_ANGVOL_GAIN_MAX ); CDCi_WriteSpiRegister( REG_CDC1_HP_ANGVOL_R_ADDR, CDC1_ANGVOL_E | CDC1_ANGVOL_GAIN_MAX );
SPI_Unlock(123);
CDC_Unlock();
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
@ -494,15 +574,21 @@ void CDC_EnableHeadphoneDriver( void )
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void CDC_DisableHeadphoneDriver( void ) void CDC_DisableHeadphoneDriver( void )
{ {
CDC_Lock();
SPI_Lock(123);
// page 1, reg 36--37,31 // page 1, reg 36--37,31
CDC_ChangePage( 1 ); CDCi_ChangePage( 1 );
// Mute Analog Volume // Mute Analog Volume
CDC_WriteI2cRegister( REG_CDC1_HP_ANGVOL_L_ADDR, CDC1_ANGVOL_E | CDC1_ANGVOL_GAIN_MUTE ); CDCi_WriteSpiRegister( REG_CDC1_HP_ANGVOL_L_ADDR, CDC1_ANGVOL_E | CDC1_ANGVOL_GAIN_MUTE );
CDC_WriteI2cRegister( REG_CDC1_HP_ANGVOL_R_ADDR, CDC1_ANGVOL_E | CDC1_ANGVOL_GAIN_MUTE ); CDCi_WriteSpiRegister( REG_CDC1_HP_ANGVOL_R_ADDR, CDC1_ANGVOL_E | CDC1_ANGVOL_GAIN_MUTE );
// Power Down Headphone Driver, with short-circuit protection // Power Down Headphone Driver, with short-circuit protection
CDC_WriteI2cRegister( REG_CDC1_HP_DRV_ADDR, CDC1_HP_DRV_SHTC_PROTECT_E ); CDCi_WriteSpiRegister( REG_CDC1_HP_DRV_ADDR, CDC1_HP_DRV_SHTC_PROTECT_E );
SPI_Unlock(123);
CDC_Unlock();
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
@ -516,24 +602,30 @@ void CDC_DisableHeadphoneDriver( void )
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void CDC_EnableSpeakerDriver( void ) void CDC_EnableSpeakerDriver( void )
{ {
CDC_Lock();
SPI_Lock(123);
// page 1, reg 38-39,32,42-43 // page 1, reg 38-39,32,42-43
CDC_ChangePage( 1 ); CDCi_ChangePage( 1 );
// Mute Analog Volume // Mute Analog Volume
CDC_WriteI2cRegister( REG_CDC1_SP_ANGVOL_L_ADDR, CDC1_ANGVOL_E | CDC1_ANGVOL_GAIN_MUTE ); CDCi_WriteSpiRegister( REG_CDC1_SP_ANGVOL_L_ADDR, CDC1_ANGVOL_E | CDC1_ANGVOL_GAIN_MUTE );
CDC_WriteI2cRegister( REG_CDC1_SP_ANGVOL_R_ADDR, CDC1_ANGVOL_E | CDC1_ANGVOL_GAIN_MUTE ); CDCi_WriteSpiRegister( REG_CDC1_SP_ANGVOL_R_ADDR, CDC1_ANGVOL_E | CDC1_ANGVOL_GAIN_MUTE );
// Power Up Speaker Driver, with short-circuit protection // Power Up Speaker Driver, with short-circuit protection
CDC_WriteI2cRegister( REG_CDC1_SP_DRV_ADDR, CDC1_SP_DRV_PWR_L | CDC1_SP_DRV_PWR_R | CDCi_WriteSpiRegister( REG_CDC1_SP_DRV_ADDR, CDC1_SP_DRV_PWR_L | CDC1_SP_DRV_PWR_R |
CDC1_SP_DRV_SHTC_PROTECT_E ); CDC1_SP_DRV_SHTC_PROTECT_E );
// Un-mute Speaker // Un-mute Speaker
CDC_WriteI2cRegister( REG_CDC1_SP_DRV_L_ADDR, CDC1_SP_DRV_MUTEN | CDC1_SP_DRV_GAIN_0DB ); CDCi_WriteSpiRegister( REG_CDC1_SP_DRV_L_ADDR, CDC1_SP_DRV_MUTEN | CDC1_SP_DRV_GAIN_0DB );
CDC_WriteI2cRegister( REG_CDC1_SP_DRV_R_ADDR, CDC1_SP_DRV_MUTEN | CDC1_SP_DRV_GAIN_0DB ); CDCi_WriteSpiRegister( REG_CDC1_SP_DRV_R_ADDR, CDC1_SP_DRV_MUTEN | CDC1_SP_DRV_GAIN_0DB );
// Un-mute Analog Volume // Un-mute Analog Volume
CDC_WriteI2cRegister( REG_CDC1_SP_ANGVOL_L_ADDR, CDC1_ANGVOL_E | CDC1_ANGVOL_GAIN_MAX ); CDCi_WriteSpiRegister( REG_CDC1_SP_ANGVOL_L_ADDR, CDC1_ANGVOL_E | CDC1_ANGVOL_GAIN_MAX );
CDC_WriteI2cRegister( REG_CDC1_SP_ANGVOL_R_ADDR, CDC1_ANGVOL_E | CDC1_ANGVOL_GAIN_MAX ); CDCi_WriteSpiRegister( REG_CDC1_SP_ANGVOL_R_ADDR, CDC1_ANGVOL_E | CDC1_ANGVOL_GAIN_MAX );
SPI_Unlock(123);
CDC_Unlock();
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
@ -547,17 +639,22 @@ void CDC_EnableSpeakerDriver( void )
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void CDC_DisableSpeakerDriver( void ) void CDC_DisableSpeakerDriver( void )
{ {
CDC_Lock();
SPI_Lock(123);
// page 1, reg 38-39,32 // page 1, reg 38-39,32
CDC_ChangePage( 1 ); CDCi_ChangePage( 1 );
// Mute Analog Volume // Mute Analog Volume
CDC_WriteI2cRegister( REG_CDC1_SP_ANGVOL_L_ADDR, CDC1_ANGVOL_E | CDC1_ANGVOL_GAIN_MUTE ); CDCi_WriteSpiRegister( REG_CDC1_SP_ANGVOL_L_ADDR, CDC1_ANGVOL_E | CDC1_ANGVOL_GAIN_MUTE );
CDC_WriteI2cRegister( REG_CDC1_SP_ANGVOL_R_ADDR, CDC1_ANGVOL_E | CDC1_ANGVOL_GAIN_MUTE ); CDCi_WriteSpiRegister( REG_CDC1_SP_ANGVOL_R_ADDR, CDC1_ANGVOL_E | CDC1_ANGVOL_GAIN_MUTE );
// Power Down Speaker Driver, with short-circuit protection // Power Down Speaker Driver, with short-circuit protection
CDC_WriteI2cRegister( REG_CDC1_SP_DRV_ADDR, CDC1_SP_DRV_SHTC_PROTECT_E ); CDCi_WriteSpiRegister( REG_CDC1_SP_DRV_ADDR, CDC1_SP_DRV_SHTC_PROTECT_E );
}
SPI_Unlock(123);
CDC_Unlock();
}
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: CDC_UnmuteDAC Name: CDC_UnmuteDAC
@ -571,8 +668,7 @@ void CDC_DisableSpeakerDriver( void )
void CDC_UnmuteDAC( void ) void CDC_UnmuteDAC( void )
{ {
// page 0, reg 64 で Un-mute // page 0, reg 64 で Un-mute
CDC_ChangePage( 0 ); CDC_WriteSpiRegisterEx( 0, REG_CDC0_DIG_VOL_M_ADDR, 0 );
CDC_WriteI2cRegister( REG_CDC0_DIG_VOL_M_ADDR, 0 );
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
@ -587,8 +683,7 @@ void CDC_UnmuteDAC( void )
void CDC_MuteDAC( void ) void CDC_MuteDAC( void )
{ {
// page 0, reg 64 で Mute // page 0, reg 64 で Mute
CDC_ChangePage( 0 ); CDC_WriteSpiRegisterEx( 0, REG_CDC0_DIG_VOL_M_ADDR, CDC0_DIG_VOL_M_MUTE_L | CDC0_DIG_VOL_M_MUTE_R );
CDC_WriteI2cRegister( REG_CDC0_DIG_VOL_M_ADDR, CDC0_DIG_VOL_M_MUTE_L | CDC0_DIG_VOL_M_MUTE_R );
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
@ -603,8 +698,7 @@ void CDC_MuteDAC( void )
void CDC_PowerUpADC( void ) void CDC_PowerUpADC( void )
{ {
// page 0, reg 81 で Power Up // page 0, reg 81 で Power Up
CDC_ChangePage( 0 ); CDC_WriteSpiRegisterEx( 0, REG_CDC0_ADC_PWR_STEP_ADDR, CDC0_ADC_PWR_STEP_PWRUP );
CDC_WriteI2cRegister( REG_CDC0_ADC_PWR_STEP_ADDR, CDC0_ADC_PWR_STEP_PWRUP );
// PLL は ADC, DAC が起動したときに動き出すらしいので、ここに PLL 安定のためのウェイトが必要 // PLL は ADC, DAC が起動したときに動き出すらしいので、ここに PLL 安定のためのウェイトが必要
if ((!isADCOn) && (!isDACOn)) if ((!isADCOn) && (!isDACOn))
@ -625,9 +719,7 @@ void CDC_PowerUpADC( void )
void CDC_PowerDownADC( void ) void CDC_PowerDownADC( void )
{ {
// page 0, reg 81 で Power Down // page 0, reg 81 で Power Down
CDC_ChangePage( 0 ); CDC_WriteSpiRegisterEx( 0, REG_CDC0_ADC_PWR_STEP_ADDR, CDC0_ADC_PWR_STEP_PWRDN );
CDC_WriteI2cRegister( REG_CDC0_ADC_PWR_STEP_ADDR, CDC0_ADC_PWR_STEP_PWRDN );
isADCOn = FALSE; isADCOn = FALSE;
} }
@ -643,8 +735,7 @@ void CDC_PowerDownADC( void )
void CDC_UnmuteADC( void ) void CDC_UnmuteADC( void )
{ {
// page 0, reg 82 で Un-mute // page 0, reg 82 で Un-mute
CDC_ChangePage( 0 ); CDC_WriteSpiRegisterEx( 0, REG_CDC0_ADC_MUTE_ADDR, CDC0_ADC_MUTE_D );
CDC_WriteI2cRegister( REG_CDC0_ADC_MUTE_ADDR, CDC0_ADC_MUTE_D );
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
@ -659,8 +750,7 @@ void CDC_UnmuteADC( void )
void CDC_MuteADC( void ) void CDC_MuteADC( void )
{ {
// page 0, reg 82 で Mute // page 0, reg 82 で Mute
CDC_ChangePage( 0 ); CDC_WriteSpiRegisterEx( 0, REG_CDC0_ADC_MUTE_ADDR, CDC0_ADC_MUTE_E );
CDC_WriteI2cRegister( REG_CDC0_ADC_MUTE_ADDR, CDC0_ADC_MUTE_E );
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
@ -675,8 +765,7 @@ void CDC_MuteADC( void )
void CDC_EnableAGC( int target_gain ) void CDC_EnableAGC( int target_gain )
{ {
// page 0, reg 86 で Enable // page 0, reg 86 で Enable
CDC_ChangePage( 0 ); CDC_WriteSpiRegisterEx( 0, REG_CDC0_AGC_CTL1_ADDR, (u8)(CDC0_AGC_CTL1_E | target_gain) );
CDC_WriteI2cRegister( REG_CDC0_AGC_CTL1_ADDR, (u8)(CDC0_AGC_CTL1_E | target_gain) );
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
@ -691,8 +780,36 @@ void CDC_EnableAGC( int target_gain )
void CDC_DisableAGC( void ) void CDC_DisableAGC( void )
{ {
// page 0, reg 86 で Disable // page 0, reg 86 で Disable
CDC_ChangePage( 0 ); CDC_WriteSpiRegisterEx( 0, REG_CDC0_AGC_CTL1_ADDR, CDC0_AGC_CTL1_D );
CDC_WriteI2cRegister( REG_CDC0_AGC_CTL1_ADDR, CDC0_AGC_CTL1_D ); }
/*---------------------------------------------------------------------------*
Name: CDC_SetPGAB
Description: Setup PGAB of the CODEC
PGAB is enabled when AGC is disabled.
Arguments: int target_gain : 0 ～ 119 (0dB ～ 59.5dB)
Returns: None
*---------------------------------------------------------------------------*/
void CDC_SetPGAB( u8 target_gain )
{
CDC_WriteSpiRegisterEx( 1, REG_CDC1_MIC_ADC_PGA_ADDR, target_gain );
}
/*---------------------------------------------------------------------------*
Name: CDC_GetPGAB
Description: Get PGA of the CODEC
Arguments: None
Returns: Gain
*---------------------------------------------------------------------------*/
u8 CDC_GetPGAB( void )
{
return CDC_ReadSpiRegisterEx( 1, REG_CDC1_MIC_ADC_PGA_ADDR );
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
@ -709,18 +826,15 @@ void CDC_Init1stOrderFilter( u8 *coef, int filter_target )
{ {
if (filter_target & CDC_FILTER_1ST_IIR_ADC) if (filter_target & CDC_FILTER_1ST_IIR_ADC)
{ {
CDC_ChangePage( 4 ); CDC_WriteSpiRegistersEx( 4, REG_CDC4_ADC_C4_MSB_ADDR, coef, 6 );
CDC_WriteI2cRegisters( REG_CDC4_ADC_C4_MSB_ADDR, coef, 6 );
} }
if (filter_target & CDC_FILTER_1ST_IIR_LDAC) if (filter_target & CDC_FILTER_1ST_IIR_LDAC)
{ {
CDC_ChangePage( 9 ); CDC_WriteSpiRegistersEx( 9, REG_CDC9_DAC_C65_MSB_ADDR, coef, 6 );
CDC_WriteI2cRegisters( REG_CDC9_DAC_C65_MSB_ADDR, coef, 6 );
} }
if (filter_target & CDC_FILTER_1ST_IIR_RDAC) if (filter_target & CDC_FILTER_1ST_IIR_RDAC)
{ {
CDC_ChangePage( 9 ); CDC_WriteSpiRegistersEx( 9, REG_CDC9_DAC_C68_MSB_ADDR, coef, 6 );
CDC_WriteI2cRegisters( REG_CDC9_DAC_C68_MSB_ADDR, coef, 6 );
} }
} }
@ -750,7 +864,6 @@ void CDC_Init1stOrderFilter( u8 *coef, int filter_target )
void CDC_SetScanModeTimerClockDivider( u8 value ) void CDC_SetScanModeTimerClockDivider( u8 value )
{ {
SDK_ASSERT( value < 128); SDK_ASSERT( value < 128);
CDC_ChangePage( 3 ); CDC_WriteSpiRegisterEx( 3, REG_CDC3_TP_DELAY_CLK_ADDR, value );
CDC_WriteI2cRegister( REG_CDC3_TP_DELAY_CLK_ADDR, value );
} }

35
build/libraries/cdc/ARM7/src/cdc_dsmode_access.c
View File

@ -13,17 +13,28 @@
$Log: $ $Log: $
$NoKeywords: $ $NoKeywords: $
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
#include <twl/cdc.h>
#include "spi_sp.h"
/* /*
このソースで定義されているSPIアクセス関数はDSモード時に使用します。
　　TWLモード時は cdc.c の関数を使用してください。 このソースで定義されているSPIアクセス関数はCODECがDSモードの時に
　　CODECにアクセスするために使用します。CODECがTWLモードの時は
cdc.c で定義されている関数を使用してください。
[DSモード時]
ＳＰＩ最大速度　：　2MHz (CODEC側の制限）
チップセレクト　：　PCSN
Read/Write指定　：　MSB
*/ */
#include <twl/cdc.h>
#include <spi_sp.h>
SPIBaudRate cdcDsmodeSPIBaudRate = DSMODE_SPI_BAUDRATE_DEFAULT; SPIBaudRate cdcDsmodeSPIBaudRate = DSMODE_SPI_BAUDRATE_DEFAULT;
//================================================================================ //================================================================================
// SPI BIT CONTROL // SPI BIT CONTROL
//================================================================================ //================================================================================
@ -47,12 +58,6 @@ void CDCi_DsmodeSetSpiParams( u8 reg, u8 setBits, u8 maskBits )
tmp |= setBits; tmp |= setBits;
CDCi_DsmodeWriteSpiRegister( reg, tmp ); CDCi_DsmodeWriteSpiRegister( reg, tmp );
} }
void CDC_DsmodeSetSpiParams( u8 reg, u8 setBits, u8 maskBits )
{
(void)SPI_Lock(123);
CDCi_DsmodeSetSpiParams( reg, setBits, maskBits );
(void)SPI_Unlock(123);
}
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: CDC_DsmodeSetSpiFlags Name: CDC_DsmodeSetSpiFlags
@ -68,10 +73,6 @@ void CDCi_DsmodeSetSpiFlags( u8 reg, u8 setBits )
{ {
CDCi_DsmodeSetSpiParams( reg, setBits, setBits ); CDCi_DsmodeSetSpiParams( reg, setBits, setBits );
} }
void CDC_DsmodeSetSpiFlags( u8 reg, u8 setBits )
{
CDC_DsmodeSetSpiParams( reg, setBits, setBits );
}
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: CDC_DsmodeClearSpiFlags Name: CDC_DsmodeClearSpiFlags
@ -87,10 +88,6 @@ void CDCi_DsmodeClearSpiFlags( u8 reg, u8 clrBits )
{ {
CDCi_DsmodeSetSpiParams( reg, 0, clrBits ); CDCi_DsmodeSetSpiParams( reg, 0, clrBits );
} }
void CDC_DsmodeClearSpiFlags( u8 reg, u8 clrBits )
{
CDC_DsmodeSetSpiParams( reg, 0, clrBits );
}
//================================================================================ //================================================================================
// SPI ACCESS // SPI ACCESS

2
build/libraries/pxi/ARM7/Makefile
View File

@ -24,7 +24,7 @@ TWL_CODEGEN_ALL ?= True
TWL_PROC = ARM7 TWL_PROC = ARM7
SRCDIR = ../common . SRCDIR = ../common/src .
SRCDIR += $(TWL_NITROSDK_ROOT)/build/libraries/pxi/common/src \ SRCDIR += $(TWL_NITROSDK_ROOT)/build/libraries/pxi/common/src \
$(TWL_NITROSDK_ROOT)/build/libraries/pxi/ARM7/src \ $(TWL_NITROSDK_ROOT)/build/libraries/pxi/ARM7/src \

1
build/libraries/snd/ARM7/Makefile
View File

@ -44,7 +44,6 @@ SRCS = \
snd_command.c \ snd_command.c \
snd_data.c \ snd_data.c \
snd_i2s.c \ snd_i2s.c \
snd_mic.c \
TARGET_LIB = libsnd_sp$(TWL_LIBSUFFIX).a TARGET_LIB = libsnd_sp$(TWL_LIBSUFFIX).a

64
build/libraries/snd/ARM7/src/snd_i2s.c
View File

@ -43,15 +43,6 @@ static void I2Si_Init(void)
isInitialized = TRUE; isInitialized = TRUE;
reg_SND_POWCNT |= REG_SND_POWCNT_SPE_MASK; reg_SND_POWCNT |= REG_SND_POWCNT_SPE_MASK;
/* CODEC“Æ—§‰^“®
if ((reg_CFG_CLK & REG_CFG_CLK_SND_MASK) == 0)
{
// initialize codec with enabling I2S
CDC_Init();
}
*/
reg_CFG_TWL_EX |= REG_CFG_TWL_EX_I2S_MASK; reg_CFG_TWL_EX |= REG_CFG_TWL_EX_I2S_MASK;
if (reg_CFG_TWL_EX & REG_CFG_TWL_EX_I2S_MASK) if (reg_CFG_TWL_EX & REG_CFG_TWL_EX_I2S_MASK)
{ {
@ -229,43 +220,72 @@ int I2S_GetMixingRatio(void)
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: I2S_SetSamplingRatio Name: I2S_SetSamplingRate
Description: Set I2S sampling ratio. Description: Set I2S sampling ratio.
It can be called while I2S is disabled. It can be called while I2S is disabled.
Arguments: is48kHz : set 48 kHz if TRUE. set 32kHz if FALSE. Note: この関数ではCODECのPLLの値を変更しますが、PLLの変更は
安全のためCODEC停止中に行うべきとの話をチップメーカー
　　　　　　　　から聞いています。
サンプリングレート変更の具体的なシーケンスは以下のとおり。
1.CPUがI2S出力を停止
2.Codec内部動作の停止【CODEC】
3.CPUがMCLK(例えば12MHz)停止
4.PLLの再設定【CODEC】
5.CPUがMCLK(例えば8MHz)出力
6.Codec内部動作の再開【CODEC】
7.CPUがI2S出力開始
サンプリングレートを変更する際には、少なくとも
　　　　　　　　サウンド/タッチパネル/マイクを停止させる必要があります。
　　　　　　　　AD/DAをOFFにする必要があるかについてメーカーに確認します。
現在の実装では何も対策を講じていません。
Arguments: rate : sampling rate
Returns: None Returns: None
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void I2S_SetSamplingRatio(BOOL is48kHz) void I2S_SetSamplingRate(I2SSamplingRate rate)
{ {
if (isTwl) if (isTwl)
{ {
if (is48kHz) switch (rate)
{
reg_SND_I2SCNT |= REG_SND_I2SCNT_CODEC_SMP_MASK;
}
else
{ {
case I2S_SAMPLING_RATE_32730:
reg_SND_I2SCNT &= ~REG_SND_I2SCNT_CODEC_SMP_MASK; reg_SND_I2SCNT &= ~REG_SND_I2SCNT_CODEC_SMP_MASK;
CDC_SetPLL( CDC_PLL_PARAMETER_FOR_SAMPLING_RATE_32730 );
break;
case I2S_SAMPLING_RATE_47610:
reg_SND_I2SCNT |= REG_SND_I2SCNT_CODEC_SMP_MASK;
CDC_SetPLL( CDC_PLL_PARAMETER_FOR_SAMPLING_RATE_47610 );
break;
} }
CDC_SetParamPLL(is48kHz);
} }
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: I2S_IsSamplingRatio48kHz Name: I2S_GetSamplingRate
Description: Get I2S sampling ratio. Description: Get I2S sampling ratio.
Arguments: None Arguments: None
Returns: TRUE if 48 kHz. otherwise FALSE Returns:
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
BOOL I2S_IsSamplingRatio48kHz(void) I2SSamplingRate I2S_GetSamplingRate( void )
{ {
return (BOOL)((reg_SND_I2SCNT & REG_SND_I2SCNT_CODEC_SMP_MASK) >> REG_SND_I2SCNT_CODEC_SMP_SHIFT); if (reg_SND_I2SCNT & REG_SND_I2SCNT_CODEC_SMP_MASK)
{
return I2S_SAMPLING_RATE_47610;
}
else
{
return I2S_SAMPLING_RATE_32730;
}
} }
/*====== End of snd_i2s.c ======*/ /*====== End of snd_i2s.c ======*/

217
build/libraries/snd/ARM7/src/snd_mic.c
View File

@ -1,217 +0,0 @@
/*---------------------------------------------------------------------------*
Project: TwlSDK - MIC
File: snd_mic.c
Copyright 2006 Nintendo. All rights reserved.
These coded instructions, statements, and computer programs contain
proprietary information of Nintendo of America Inc. and/or Nintendo
Company Ltd., and are protected by Federal copyright law. They may
not be disclosed to third parties or copied or duplicated in any form,
in whole or in part, without the prior written consent of Nintendo.
$Log: $
$NoKeywords: $
*---------------------------------------------------------------------------*/
#include <twl.h>
#include <twl/cdc.h>
#include <twl/snd/ARM7/snd_mic.h>
static void MICi_ExDmaRecvAsync( u32 dmaNo, void *dest, s32 size );
void MICi_ExDmaInterruptHandler( void );
void MICi_DmaInterruptHandler( void );
void MICi_FifoInterruptHandler( void );
static MICWork micWork;
/*---------------------------------------------------------------------------*
Name: MICi_Init
Description: initialize MIC
Arguments: None
Returns: None
*---------------------------------------------------------------------------*/
void MICi_Init( void )
{
CDC_InitMic();
}
/*---------------------------------------------------------------------------*
Name: MICi_Start
Description: start MIC
Arguments:
Returns: None
*---------------------------------------------------------------------------*/
void MICi_Start( MICSampleRate smp, u32 dmaNo, void *dest, s32 size )
{
MICWork *wp = &micWork;
OSIntrMode enabled;
wp->dmaNo = dmaNo;
wp->buf = dest;
wp->bufSize = size;
MICi_Stop();
enabled = OS_DisableInterrupts();
if ( dest != NULL )
{
if ( MI_EXDMA_CH_MIN <= dmaNo && dmaNo <= MI_EXDMA_CH_MAX )
{
u32 ch = dmaNo - MI_EXDMA_CH_MIN;
MIi_StopExDma( dmaNo );
MICi_ExDmaRecvAsync( dmaNo, dest, size );
OS_SetIrqFunction( OS_IE_DMA4 << ch, MICi_ExDmaInterruptHandler );
reg_OS_IF = (OS_IE_DMA4 << ch);
reg_OS_IE |= (OS_IE_DMA4 << ch); // enable mic dma interrupt
/*
OS_SetIrqFunction( OS_IE_MIC, MICi_FifoInterruptHandler );
reg_OS_IF2 = (OS_IE_MIC >> 32);
reg_OS_IE2 |= (OS_IE_MIC >> 32); // disable mic fifo interrupt
*/
}
}
SND_Enable();
// start monoral sampling
reg_SND_MICCNT = REG_SND_MICCNT_FIFO_CLR_MASK;
reg_SND_MICCNT = (u16)(REG_SND_MICCNT_E_MASK | REG_SND_MICCNT_NR_MASK | MIC_INTR_OVERFLOW
| smp);
(void)OS_RestoreInterrupts(enabled);
}
/*---------------------------------------------------------------------------*
Name: MICi_Stop
Description: stop MIC
Arguments: None
Returns: None
*---------------------------------------------------------------------------*/
void MICi_Stop( void )
{
MICWork *wp = &micWork;
OSIntrMode enabled = OS_DisableInterrupts();
if ( reg_SND_MICCNT & REG_SND_MICCNT_E_MASK )
{
u32 dmaNo = wp->dmaNo;
reg_SND_MICCNT &= ~REG_SND_MICCNT_E_MASK;
if ( MI_EXDMA_CH_MIN <= dmaNo && dmaNo <= MI_EXDMA_CH_MAX )
{
u32 ch = dmaNo - MI_EXDMA_CH_MIN;
MIi_StopExDma( dmaNo );
reg_OS_IE &= ~(OS_IE_DMA4 << ch); // disable mic dma interrupt
reg_OS_IF = (OS_IE_DMA4 << ch);
}
else if ( dmaNo > MI_EXDMA_CH_MAX )
{
reg_OS_IE2 &= ~(OS_IE_MIC >> 32); // disable mic fifo interrupt
reg_OS_IF2 = (OS_IE_MIC >> 32);
}
}
(void)OS_RestoreInterrupts(enabled);
}
/*---------------------------------------------------------------------------*
Name: MICi_ExDmaRecvAsync
Description: receive data with DMA
async version
Arguments: dmaNo : DMA channel No.
dest : destination address
size : size (byte)
Returns: None
*---------------------------------------------------------------------------*/
static void MICi_ExDmaRecvAsync( u32 dmaNo, void *dest, s32 size )
{
u32 interval = (0x2C0 * 16) - 16;
MIExDmaPrescaler prescale = MI_EXDMA_PRESCALER_1;
#ifdef TWL_PLATFORM_BB
interval /= 2;
#endif // TWL_PLATFORM_BB
MIi_ExDmaRecvAsyncCore( dmaNo, (void*)REG_MIC_FIFO_ADDR, dest,
(u32)size, (u32)size,
MI_EXDMA_BLOCK_32B, interval, prescale,
MI_EXDMA_CONTINUOUS_ON, MI_EXDMA_SRC_RLD_ON, MI_EXDMA_DEST_RLD_ON,
MI_EXDMA_TIMING_MIC );
}
/*---------------------------------------------------------------------------*
Name: MICi_ExDmaInterruptHandler
Description: interrupt handler
Arguments: None
Returns: None
*---------------------------------------------------------------------------*/
void MICi_ExDmaInterruptHandler( void )
{
// OS_TPrintf( "*" );
#if 0
MICWork *wp = &micWork;
MICi_ExDmaRecvAsync( wp->dmaNo, wp->buf, wp->bufSize );
#endif
}
/*---------------------------------------------------------------------------*
Name: MICi_FifoInterruptHandler
Description: interrupt handler
Arguments: None
Returns: None
*---------------------------------------------------------------------------*/
void MICi_FifoInterruptHandler( void )
{
/*
// 本当はDMAを停止してからFIFOをクリアした方がいいらしい
// マイクディゼーブル
reg_SND_MICCNT &= (u16)(~REG_SND_MICCNT_E_MASK);
// FIFO & エラーフラグクリア
reg_SND_MICCNT |= REG_SND_MICCNT_FIFO_CLR_MASK;
// マイクイネーブル
reg_SND_MICCNT |= (u16)(REG_SND_MICCNT_E_MASK);
*/
#if 0
MICWork *wp = &micWork;
MIi_CpuSend32( (void*)REG_MIC_FIFO_ADDR, wp->buf, (u32)wp->bufSize );
#endif
}

9
build/libraries/spi/ARM7/Makefile
View File

@ -15,7 +15,7 @@
# $NoKeywords: $ # $NoKeywords: $
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------
SUBDIRS = nvram pm tp # mic SUBDIRS = nvram pm tp mic
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------
@ -31,13 +31,6 @@ INCDIR = $(TWL_NITROSDK_ROOT)/build/libraries/spi/ARM7/include
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------
# DEBUG版ビルドの場合、RELEASE版でビルドして
# DEBUG版のライブラリを装います。
ifdef NITRO_DEBUG
NITRO_BUILD_TYPE = RELEASE
endif
include $(TWLSDK_ROOT)/build/buildtools/commondefs include $(TWLSDK_ROOT)/build/buildtools/commondefs
INSTALL_TARGETS = $(TARGETS) INSTALL_TARGETS = $(TARGETS)

86
build/libraries/spi/ARM7/include/tp_reg.h
View File

@ -39,31 +39,6 @@ extern "C" {
#define TP0_REV_ID_MASK 0x70 #define TP0_REV_ID_MASK 0x70
#define TP0_REV_ID_SHIFT 4 #define TP0_REV_ID_SHIFT 4
//================================================================================
// TP Data
//================================================================================
#define TP_DATA_SAMPLE_DEPTH_MAX 8
#define TP_DATA_SAMPLE_DEPTH_DEFAULT 8 // 8だとmix問題は発生しない
typedef struct
{
u16 xBuf[TP_DATA_SAMPLE_DEPTH_MAX * 2]; // ダブルバッファ
u16 yBuf[TP_DATA_SAMPLE_DEPTH_MAX * 2]; // ダブルバッファ
int tpIndex; // 有効データの先頭インデックス（ダブルバッファなので、0 か TP_DATA_SAMPLE_DEPTH_MAX）
u16 x; // page 3 での単発 read 時
u16 y; // page 3 での単発 rea d時
u16 in1;
u16 in2;
u16 in3;
int tpDepth; // タッチパネル・データ数
} tpData_t;
extern tpData_t tpData;
//================================================================================ //================================================================================
// Resolution / ADC Power // Resolution / ADC Power
//================================================================================ //================================================================================
@ -83,28 +58,45 @@ typedef enum
#define TP_ADC_PWRDN 0x80 #define TP_ADC_PWRDN 0x80
//================================================================================ //================================================================================
// Sampling Channel // Sampling Conversion Mode
//================================================================================ //================================================================================
#define REG_TP_CHANNEL 3 #define REG_TP_CONVERSION_MODE 3
#define TP_CONVERSION_CONTROL_MASK 0x80
#define TP_CONVERSION_MODE_MASK 0x3c
#define TP_CONVERSION_PIN_MASK 0x03
typedef enum typedef enum
{ {
TP_CHANNEL_NONE = 0x00, TP_CONVERSION_CONTROL_HOST = 0x00,
TP_CHANNEL_XY = 0x87, // Self, /READREADY = ReadReady TP_CONVERSION_CONTROL_SELF = 0x80
TP_CHANNEL_XYZ = 0x8b, } TpCnversionControl_t;
TP_CHANNEL_X = 0x8f,
TP_CHANNEL_Y = 0x93,
TP_CHANNEL_Z = 0x97,
TP_CHANNEL_AUX3 = 0x19,
TP_CHANNEL_AUX2 = 0x1d,
TP_CHANNEL_AUX1 = 0x21,
TP_CHANNEL_AUTO_AUX = 0xa5,
TP_CHANNEL_AUX123 = 0x2d,
TP_CHANNEL_XP_XM = 0x35,
TP_CHANNEL_YP_YM = 0x39,
TP_CHANNEL_YP_XM = 0x3d
} TpChannel_t; typedef enum
{
TP_CONVERSION_MODE_NONE = 0x00,
TP_CONVERSION_MODE_XY = 0x04, // Self, /READREADY = ReadReady
TP_CONVERSION_MODE_XYZ = 0x08,
TP_CONVERSION_MODE_X = 0x0c,
TP_CONVERSION_MODE_Y = 0x10,
TP_CONVERSION_MODE_Z = 0x14,
TP_CONVERSION_MODE_AUX3 = 0x18,
TP_CONVERSION_MODE_AUX2 = 0x1c,
TP_CONVERSION_MODE_AUX1 = 0x20,
TP_CONVERSION_MODE_AUTO_AUX = 0x24,
TP_CONVERSION_MODE_AUX123 = 0x2c,
TP_CONVERSION_MODE_XP_XM = 0x34,
TP_CONVERSION_MODE_YP_YM = 0x38,
TP_CONVERSION_MODE_YP_XM = 0x3c
} TpConversionMode_t;
typedef enum
{
TP_CONVERSION_PIN_INTERRUPT = 0x00,
TP_CONVERSION_PIN_DATA_AVAILABLE = 0x01,
TP_CONVERSION_PIN_INTERRUPT_DATA_AVAILABLE = 0x02,
TP_CONVERSION_PIN_NBM = 0x03
} TpCnversionPin_t;
//================================================================================ //================================================================================
// Precharge / Sense / Stability time // Precharge / Sense / Stability time
@ -173,9 +165,9 @@ typedef enum
#define TP_NEW_BUFFER_MODE_D 0x00 #define TP_NEW_BUFFER_MODE_D 0x00
#define TP_NEW_BUFFER_MODE_MASK 0x80 #define TP_NEW_BUFFER_MODE_MASK 0x80
#define TP_CONVERSION_MODE_CONTINUOUS 0x00 #define TP_NEW_BUFFER_CONVERSION_MODE_CONTINUOUS 0x00
#define TP_CONVERSION_MODE_SINGLESHOT 0x40 #define TP_NEW_BUFFER_CONVERSION_MODE_SINGLESHOT 0x40
#define TP_CONVERSION_MODE_MASK 0x40 #define TP_NEW_BUFFER_CONVERSION_MODE_MASK 0x40
#define TP_HOLDOFF_ENABLE 0x04 #define TP_HOLDOFF_ENABLE 0x04
#define TP_HOLDOFF_DISABLE 0x00 #define TP_HOLDOFF_DISABLE 0x00
@ -226,7 +218,9 @@ typedef enum
//================================================================================ //================================================================================
// Debounce // Debounce
//================================================================================ //================================================================================
#define REG_TP_DEBOUNCE 18 #define REG_TP_DEBOUNCE_TIME 18
#define TP_DEBOUNCE_TIME_SHIFT 0
#define TP_DEBOUNCE_TIME_MASK 0x07
typedef enum typedef enum
{ {

10
build/libraries/spi/ARM7/include/tp_sp.h
View File

@ -116,6 +116,9 @@ extern "C" {
#define TP_VALARM_DELAY_MAX 10 #define TP_VALARM_DELAY_MAX 10
#define TP_DATA_SAMPLE_DEPTH_MAX 8
#define TP_DATA_SAMPLE_DEPTH_DEFAULT 5
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
構造体定義 構造体定義
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
@ -142,7 +145,6 @@ typedef struct TPWork
} }
TPWork; TPWork;
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
関数定義 関数定義
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
@ -158,22 +160,24 @@ void TWL_TP_Init(void);
void TWL_TP_SetStabilizationTime( TpSetupTime_t time ); void TWL_TP_SetStabilizationTime( TpSetupTime_t time );
void TWL_TP_SetPrechargeTime( TpSetupTime_t time ); void TWL_TP_SetPrechargeTime( TpSetupTime_t time );
void TWL_TP_SetSenseTime( TpSetupTime_t time ); void TWL_TP_SetSenseTime( TpSetupTime_t time );
void TWL_TP_SetDebounceTime( tpDebounce_t time );
void TWL_TP_SetResolution( TpResolution_t res ); void TWL_TP_SetResolution( TpResolution_t res );
void TWL_TP_GetResolution( TpResolution_t *res ); void TWL_TP_GetResolution( TpResolution_t *res );
void TWL_TP_SetTouchPanelDataDepth(u8 depth); void TWL_TP_SetTouchPanelDataDepth(u8 depth);
void TWL_TP_SetConvertChannel( TpChannel_t ch ); void TWL_TP_SetConversionMode( TpCnversionControl_t control, TpConversionMode_t mode, TpCnversionPin_t pin );
void TWL_TP_SetInterval( tpInterval_t interval ); void TWL_TP_SetInterval( tpInterval_t interval );
void TWL_TP_EnableNewBufferMode( void ); void TWL_TP_EnableNewBufferMode( void );
void TWL_TP_DisableNewBufferMode( void ); void TWL_TP_DisableNewBufferMode( void );
BOOL TWL_TP_ReadBuffer( SPITpData *data );
//////////////////////////// ////////////////////////////
#define SDK_TP_AUTO_ADJUST_RANGE // range自動調整スイッチ #define SDK_TP_AUTO_ADJUST_RANGE // range自動調整スイッチ
#ifdef SDK_TP_AUTO_ADJUST_RANGE // range自動調整スイッチ #ifdef SDK_TP_AUTO_ADJUST_RANGE // range自動調整スイッチ
void TP_ExecSampling(SPITpData *data, s32 range, u16 *density); void TP_ExecSampling(SPITpData *data, s32 range, u16 *density);
BOOL TWL_TP_ReadBuffer( SPITpData *data, u8 range, u16* density );
#else #else
void TP_ExecSampling(SPITpData *data, s32 range); void TP_ExecSampling(SPITpData *data, s32 range);
BOOL TWL_TP_ReadBuffer( SPITpData *data, u8 range );
#endif #endif
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*

9
build/libraries/spi/ARM7/tp/Makefile
View File

@ -48,7 +48,7 @@ TWL_PROC = ARM7
SRCDIR = ./src SRCDIR = ./src
SRCDIR += $(TWL_NITROSDK_ROOT)/build/libraries/spi/ARM7/tp/src \ SRCDIR += $(TWL_NITROSDK_ROOT)/build/libraries/spi/ARM7/tp/src \
SRCS = tp_sp.c tp_sampling.c SRCS = tp_sp.c tp_sampling.c twl_tp_sampling.c
TARGET_LIB = libtp_sp$(TWL_LIBSUFFIX).a TARGET_LIB = libtp_sp$(TWL_LIBSUFFIX).a
INCDIR = ../include INCDIR = ../include
@ -56,13 +56,6 @@ INCDIR += $(TWL_NITROSDK_ROOT)/build/libraries/spi/ARM7/include
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------
# DEBUG版ビルドの場合、RELEASE版でビルドして
# DEBUG版のライブラリを装います。
ifdef NITRO_DEBUG
NITRO_BUILD_TYPE = RELEASE
endif
include $(TWLSDK_ROOT)/build/buildtools/commondefs include $(TWLSDK_ROOT)/build/buildtools/commondefs
INSTALL_TARGETS = $(TARGETS) INSTALL_TARGETS = $(TARGETS)

519
build/libraries/spi/ARM7/tp/src/tp_sp.c
View File

@ -66,32 +66,34 @@
$NoKeywords: $ $NoKeywords: $
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
/*
TP関連はCODECがDSモードとTWLモードのいずれであってもARM9から同じ関数が
　　使えるようにしてあります。というよりも、TWLモードだからといって特に良い
　　ことは増えてないといった方が正しいです。完全互換の方がよかったですね。
現時点では CDC_IsTwlMode() の結果によって
DS互換モードとTWLモードを分岐させています。
ご自由に料理してください。
*/
#include "tp_sp.h" #include "tp_sp.h"
#include <tp_reg.h> ////////////// #include <twl/cdc/ARM7/cdc_api.h>
#include <twl/cdc/ARM7/cdc.h> //////////////
#include <twl/cdc/ARM7/cdc_api.h> //////////////
//#define PRINT_DEBUG
#define PRINT_DEBUG
#ifdef PRINT_DEBUG #ifdef PRINT_DEBUG
#include <nitro/os/common/printf.h> #include <nitro/os/common/printf.h>
#define DBG_PRINTF OS_TPrintf #define DBG_PRINTF OS_TPrintf
#else #else
#define DBG_PRINTF( ... ) ((void)0) #define DBG_PRINTF( ... ) ((void)0)
#define DBG_CHAR( c ) ((void)0) #define DBG_modeAR( c ) ((void)0)
#endif #endif
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
内部変数定義 内部変数定義
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
static TPWork tpw; static TPWork tpw;
/////////////////////////// TWL
tpData_t tpData;
///////////////////////////
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
内部関数定義 内部関数定義
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
@ -112,17 +114,6 @@ static void SetStability(u16 range);
Returns: None. Returns: None.
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
// CODECの電源は現在SndInitでONになっていたはず。
// CDCInitでONにするようにするか？
// ここでCODECの状態がDSモードかTWLモードかによって
// 分岐させるという考えもある。
// スレッドを別にする。
// TPのスレッドはそういえばSPIスレッドとしてまとめられているんだった。
// TP_AnalyzeCommandwを別にするだけでいい？
// いやTP_ExecuteProcessでしょ。
void TP_Init(void) void TP_Init(void)
{ {
s32 i; s32 i;
@ -151,36 +142,17 @@ void TP_Init(void)
if (CDC_IsTwlMode()) if (CDC_IsTwlMode())
{ {
/* TWL_TP_DisableNewBufferMode(); // NewBufferModeは使用せずTSC2101モードを使用する
tpSetPrechargeTime( TP_SETUP_TIME_0_1US ); TWL_TP_SetResolution( TP_RESOLUTION_12 ); // タッチパネルデータの精度は12bit
tpSetSenseTime( TP_SETUP_TIME_0_1US ); TWL_TP_SetInterval(TP_INTERVAL_NONE); // TSC2101モードでは無効
tpSetStabilizationTime( TP_SETUP_TIME_0_1US ); // 済み TWL_TP_SetConversionMode(
TP_CONVERSION_CONTROL_SELF,
tpSetDebounceTime( TP_DEBOUNCE_16US ); TP_CONVERSION_MODE_XY,
TP_CONVERSION_PIN_DATA_AVAILABLE ); // 変換モードはXY座標
tpSetResolution( TP_RESOLUTION_12 ); // 済み TWL_TP_SetStabilizationTime( TP_SETUP_TIME_100US ); // 大きいと座標値の安定性が高まる代わりにサンプリング時間が増加
tpSetInterval( TP_INTERVAL_4MS ); // 済み TWL_TP_SetSenseTime( TP_SETUP_TIME_0_1US ); // sense time 中は Pen Touch が Low にマスクされるので注意
TWL_TP_SetPrechargeTime( TP_SETUP_TIME_0_1US ); // precharge time 中は Pen Touch が Low にマスクされるので注意
tpSetTouchPanelDataDepth( TP_DATA_SAMPLE_DEPTH_DEFAULT ); // 済み TWL_TP_SetDebounceTime( TP_DEBOUNCE_0US ); //
tpSetConvertChannel( TP_CHANNEL_XY ); // 済み
tpEnableNewBufferMode(); // 済み
*/
TWL_TP_DisableNewBufferMode(); // for TSC2101 mode
TWL_TP_SetResolution( TP_RESOLUTION_12 );
TWL_TP_SetInterval(TP_INTERVAL_NONE); // for TSC2101 mode
TWL_TP_SetTouchPanelDataDepth( 5 /*TP_DATA_SAMPLE_DEPTH_DEFAULT*/ );
TWL_TP_SetConvertChannel( TP_CHANNEL_XY );
TWL_TP_SetStabilizationTime( TP_SETUP_TIME_100US ); // Yの座標が全部同じになることがあったため0.1us->1us
TWL_TP_SetSenseTime( TP_SETUP_TIME_3US ); // Yの座標が全部同じになることがあったため0.1us->1us
TWL_TP_SetPrechargeTime( TP_SETUP_TIME_3US ); // Yの座標が全部同じになることがあったため0.1us->1us
// シングルショットモードに設定する
// CDC_ChangePage( 3 );
// CDC_SetI2cParams( REG_TP_NEW_BUFFER_MODE, TP_CONVERSION_MODE_SINGLESHOT, TP_CONVERSION_MODE_MASK );
} }
else else
{ {
@ -195,7 +167,6 @@ void TP_Init(void)
TP_SPIChangeMode(SPI_TRANSMODE_1BYTE); TP_SPIChangeMode(SPI_TRANSMODE_1BYTE);
SPI_DummyWait(); SPI_DummyWait();
} }
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
@ -311,8 +282,6 @@ void TP_AnalyzeCommand(u32 data)
} }
} }
#ifdef SDK_TP_AUTO_ADJUST_RANGE // rangeの自動調整スイッチ #ifdef SDK_TP_AUTO_ADJUST_RANGE // rangeの自動調整スイッチ
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: TP_AutoAdjustRange Name: TP_AutoAdjustRange
@ -404,8 +373,30 @@ void TP_ExecuteProcess(SPIEntry * entry)
// 単体サンプリング // 単体サンプリング
case SPI_PXI_COMMAND_TP_SAMPLING: case SPI_PXI_COMMAND_TP_SAMPLING:
// 排他はCDC_ReadSpiRegister(s)内部でのSPI_Lock()->SPIi_GetExceptionで実現する // サンプリングを実行
/* {
SPITpData temp;
#ifdef SDK_TP_AUTO_ADJUST_RANGE // rangeの自動調整スイッチ
u16 density;
#endif
// TWLモード
if (CDC_IsTwlMode())
{
#ifdef SDK_TP_AUTO_ADJUST_RANGE // rangeの自動調整スイッチ
if (TWL_TP_ReadBuffer(&temp, tpw.range, &density))
TP_AutoAdjustRange(&temp, density);
#else
if (TWL_TP_ReadBuffer(&temp, tpw.range))
#endif
{
// システム領域に書き出し( 2バイトアクセス )
*((u16 *)(&(OS_GetSystemWork()->touch_panel[0]))) = temp.halfs[0];
*((u16 *)(&(OS_GetSystemWork()->touch_panel[2]))) = temp.halfs[1];
}
}
// DSモード
else
{
// 排他制御開始 // 排他制御開始
{ {
OSIntrMode e; OSIntrMode e;
@ -421,30 +412,8 @@ void TP_ExecuteProcess(SPIEntry * entry)
SPIi_GetException(SPI_DEVICE_TYPE_TP); SPIi_GetException(SPI_DEVICE_TYPE_TP);
(void)OS_RestoreInterrupts(e); (void)OS_RestoreInterrupts(e);
} }
*/
// サンプリングを実行
{
SPITpData temp;
if (CDC_IsTwlMode())
{
// OSTick tick = OS_GetTick(); ///////////////////////
if (TWL_TP_ReadBuffer(&temp))
{
// システム領域に書き出し( 2バイトアクセス )
*((u16 *)(&(OS_GetSystemWork()->touch_panel[0]))) = temp.halfs[0];
*((u16 *)(&(OS_GetSystemWork()->touch_panel[2]))) = temp.halfs[1];
}
// DBG_PRINTF("TWL_TP_ReadBuffer = %6d us\n", OS_TicksToMicroSeconds(OS_GetTick() - tick)); /////////
}
else
{
// OSTick tick = OS_GetTick(); /////////////////
#ifdef SDK_TP_AUTO_ADJUST_RANGE // rangeの自動調整スイッチ #ifdef SDK_TP_AUTO_ADJUST_RANGE // rangeの自動調整スイッチ
u16 density;
TP_ExecSampling(&temp, tpw.range, &density); TP_ExecSampling(&temp, tpw.range, &density);
TP_AutoAdjustRange(&temp, density); TP_AutoAdjustRange(&temp, density);
#else #else
@ -453,9 +422,10 @@ void TP_ExecuteProcess(SPIEntry * entry)
// システム領域に書き出し( 2バイトアクセス ) // システム領域に書き出し( 2バイトアクセス )
*((u16 *)(&(OS_GetSystemWork()->touch_panel[0]))) = temp.halfs[0]; *((u16 *)(&(OS_GetSystemWork()->touch_panel[0]))) = temp.halfs[0];
*((u16 *)(&(OS_GetSystemWork()->touch_panel[2]))) = temp.halfs[1]; *((u16 *)(&(OS_GetSystemWork()->touch_panel[2]))) = temp.halfs[1];
// DBG_PRINTF("TP_ExecSampling = %6d us\n", OS_TicksToMicroSeconds(OS_GetTick() - tick)); /////////
} }
// 排他制御終了
SPIi_ReleaseException(SPI_DEVICE_TYPE_TP);
} }
// ARM9に処理の成功を通達 // ARM9に処理の成功を通達
if (entry->process == SPI_PXI_COMMAND_TP_SAMPLING) if (entry->process == SPI_PXI_COMMAND_TP_SAMPLING)
@ -468,8 +438,6 @@ void TP_ExecuteProcess(SPIEntry * entry)
// 自動サンプリングのインジケート // 自動サンプリングのインジケート
SPIi_ReturnResult((u16)(entry->process), (u16)(entry->arg[0] & 0x00ff)); SPIi_ReturnResult((u16)(entry->process), (u16)(entry->arg[0] & 0x00ff));
} }
// 排他制御終了
// SPIi_ReleaseException(SPI_DEVICE_TYPE_TP);
break; break;
// 自動サンプリング開始 // 自動サンプリング開始
@ -574,391 +542,6 @@ static void SetStability(u16 range)
return; return;
} }
/*---------------------------------------------------------------------------*
Name: TWL_TP_SetTouchPanelDataDepth
Description: set touch-panel data depth (1 <= depth <= 8)
Arguments: int depth : data depth (1<= depth <= 8)
Returns: None
*---------------------------------------------------------------------------*/ //TODO: depthの切り替えはPage3, Reg14, D7 is "0"の状態で行うように修正する
void TWL_TP_SetTouchPanelDataDepth( u8 depth )
{
u8 tmp;
SDK_ASSERT( (1 <= depth) && (depth <= 8) );
tmp = (u8)(depth << TP_DATA_DEPTH_SHIFT);
if (depth == 8) tmp = 0;
CDC_ChangePage( 3 );
CDC_SetI2cParams( REG_TP_DATA_DEPTH, tmp, TP_DATA_DEPTH_MASK );
tpData.tpDepth = depth;
}
/*---------------------------------------------------------------------------*
Name: TWL_TP_SetConvertChannel
Description: set ADC target channel
Arguments: TpChannel_t ch : Convert Channel
Returns: None
*---------------------------------------------------------------------------*/
void TWL_TP_SetConvertChannel( TpChannel_t ch )
{
SDK_ASSERT( (ch == TP_CHANNEL_NONE) || (ch == TP_CHANNEL_XY) ||
(ch == TP_CHANNEL_XYZ) || (ch == TP_CHANNEL_X) ||
(ch == TP_CHANNEL_Y) || (ch == TP_CHANNEL_Z) ||
(ch == TP_CHANNEL_AUX3) || (ch == TP_CHANNEL_AUX2) ||
(ch == TP_CHANNEL_AUX1) || (ch == TP_CHANNEL_AUTO_AUX) ||
(ch == TP_CHANNEL_AUX123) || (ch == TP_CHANNEL_XP_XM) ||
(ch == TP_CHANNEL_YP_YM) || (ch == TP_CHANNEL_YP_XM) );
CDC_ChangePage( 3 );
// i_tpWriteSpiRegister( REG_TP_CHANNEL, ch );
// cdcWriteI2cRegister( REG_TP_CHANNEL, ch );
// CDC_WriteI2cRegister( REG_TP_CHANNEL, ch ); // TODO: マスク書き換えに修正する
// CDC_WriteI2cRegister( REG_TP_CHANNEL, (ch & 0x7f) ); // 強引にホストコントロールモード
CDC_WriteI2cRegister( REG_TP_CHANNEL, (u8)(ch & 0xfd) ); // 2101 & self
}
/*---------------------------------------------------------------------------*
Name: TWL_TP_SetInterval
Description: set Touch-Panel / AUX Interval Time
Either Touch-Panel or AUX can be enabled, the last setting
is only valid. Normally, Touch-Panel is enabled.
Arguments: tpInterval_t interval : interval time between sampling
Returns: None
*---------------------------------------------------------------------------*/
void TWL_TP_SetInterval( tpInterval_t interval )
{
SDK_ASSERT( (interval == TP_INTERVAL_NONE) ||
(interval == TP_INTERVAL_8MS) || (interval == TP_AUX_INTERVAL_1_12M) ||
(interval == TP_INTERVAL_1MS) || (interval == TP_AUX_INTERVAL_3_36M) ||
(interval == TP_INTERVAL_2MS) || (interval == TP_AUX_INTERVAL_5_59M) ||
(interval == TP_INTERVAL_3MS) || (interval == TP_AUX_INTERVAL_7_83M) ||
(interval == TP_INTERVAL_4MS) || (interval == TP_AUX_INTERVAL_10_01M) ||
(interval == TP_INTERVAL_5MS) || (interval == TP_AUX_INTERVAL_12_30M) ||
(interval == TP_INTERVAL_6MS) || (interval == TP_AUX_INTERVAL_14_54M) ||
(interval == TP_INTERVAL_7MS) || (interval == TP_AUX_INTERVAL_16_78M)
);
// i_tpChangePage( 3 );
CDC_ChangePage( 3 );
// i_tpWriteSpiRegister( REG_TP_INTERVAL, interval );
// cdcWriteI2cRegister( REG_TP_INTERVAL, interval );
CDC_WriteI2cRegister( REG_TP_INTERVAL, interval );
}
/*---------------------------------------------------------------------------*
Name: tpEnableNewBufferMode
Description: enable new buffer mode
Arguments: None
Returns: None
*---------------------------------------------------------------------------*/
void TWL_TP_EnableNewBufferMode( void )
{
// i_tpChangePage( 3 );
CDC_ChangePage( 3 );
// i_tpSetSpiParams( REG_TP_NEW_BUFFER_MODE, TP_NEW_BUFFER_MODE_E, TP_NEW_BUFFER_MODE_MASK );
// i_tpSetI2cParams( REG_TP_NEW_BUFFER_MODE, TP_NEW_BUFFER_MODE_E, TP_NEW_BUFFER_MODE_MASK );
CDC_SetI2cParams( REG_TP_NEW_BUFFER_MODE, TP_NEW_BUFFER_MODE_E, TP_NEW_BUFFER_MODE_MASK );
}
/*---------------------------------------------------------------------------*
Name: tpDisableNewBufferMode
Description: disable new buffer mode
Arguments: None
Returns: None
*---------------------------------------------------------------------------*/
void TWL_TP_DisableNewBufferMode( void )
{
// i_tpChangePage( 3 );
CDC_ChangePage( 3 );
// i_tpSetSpiParams( REG_TP_NEW_BUFFER_MODE, TP_NEW_BUFFER_MODE_D, TP_NEW_BUFFER_MODE_MASK );
// i_tpSetI2cParams( REG_TP_NEW_BUFFER_MODE, TP_NEW_BUFFER_MODE_D, TP_NEW_BUFFER_MODE_MASK );
CDC_SetI2cParams( REG_TP_NEW_BUFFER_MODE, TP_NEW_BUFFER_MODE_D, TP_NEW_BUFFER_MODE_MASK );
}
/*---------------------------------------------------------------------------*
Name: TWL_TP_SetResolution
Description: set AD Converting Resolution (8, 10, or 12-bit)
Arguments: TpResolution_t res : Converting Resolution
Returns: None
*---------------------------------------------------------------------------*/
void TWL_TP_SetResolution( TpResolution_t res )
{
SDK_ASSERT( (res == TP_RESOLUTION_12) ||
(res == TP_RESOLUTION_8) ||
(res == TP_RESOLUTION_10) );
// i_tpChangePage( 3 );
CDC_ChangePage( 3 );
// i_tpSetSpiParams( REG_TP_RESOLUTION, res, TP_RESOLUTION_MASK );
// i_tpSetI2cParams( REG_TP_RESOLUTION, res, TP_RESOLUTION_MASK );
CDC_SetI2cParams( REG_TP_RESOLUTION, res, TP_RESOLUTION_MASK );
}
/*---------------------------------------------------------------------------*
Name: TWL_TP_GetResolution
Description: get AD Converting Resolution (8, 10, or 12-bit)
Arguments: TpResolution_t *res : Converting Resolution
Returns: None
*---------------------------------------------------------------------------*/
void TWL_TP_GetResolution( TpResolution_t *res )
{
// i_tpChangePage( 3 );
CDC_ChangePage( 3 );
// *res = (TpResolution_t)(i_tpReadSpiRegister( REG_TP_RESOLUTION ) & TP_RESOLUTION_MASK);
// *res = (TpResolution_t)( cdcReadI2cRegister( REG_TP_RESOLUTION ) & TP_RESOLUTION_MASK);
*res = (TpResolution_t)( CDC_ReadI2cRegister( REG_TP_RESOLUTION ) & TP_RESOLUTION_MASK);
}
/*---------------------------------------------------------------------------*
Name: TWL_TP_SetStabilizationTime
Description: set ADC stabilization time before touch detection
Arguments: TpSetupTime_t time : stabilization time
Returns: None
*---------------------------------------------------------------------------*/
void TWL_TP_SetStabilizationTime( TpSetupTime_t time )
{
SDK_ASSERT( (TP_SETUP_TIME_0_1US <= time) || (time <= TP_SETUP_TIME_1MS) );
CDC_ChangePage( 3 );
CDC_SetI2cParams( REG_TP_STABILIZATION_TIME, time, TP_STABILIZATION_TIME_MASK );
}
/*---------------------------------------------------------------------------*
Name: TWL_TP_SetPrechargeTime
Description: set ADC precharge time before touch detection
Arguments: TpSetupTime_t time : precharge time
Returns: None
*---------------------------------------------------------------------------*/
void TWL_TP_SetPrechargeTime( TpSetupTime_t time )
{
SDK_ASSERT( (TP_SETUP_TIME_0_1US <= time) || (time <= TP_SETUP_TIME_1MS) );
CDC_ChangePage( 3 );
CDC_SetI2cParams( REG_TP_PRECHARGE, (u8)(time << TP_PRECHARGE_SHIFT), TP_PRECHARGE_MASK );
}
/*---------------------------------------------------------------------------*
Name: TWL_TP_SetSenseTime
Description: set ADC sense time before touch detection
Arguments: TpSetupTime_t time : sense time
Returns: None
*---------------------------------------------------------------------------*/
void TWL_TP_SetSenseTime( TpSetupTime_t time )
{
SDK_ASSERT( (TP_SETUP_TIME_0_1US <= time) || (time <= TP_SETUP_TIME_1MS) );
CDC_ChangePage( 3 );
CDC_SetI2cParams( REG_TP_SENSE_TIME, time, TP_SENSE_TIME_MASK );
}
/*---------------------------------------------------------------------------*
Name: TWL_TP_IS_TOUCH
Description: タッチパネル接触判定
Arguments: none
Returns: BOOL : if touched, return TRUE. otherwise FALSE.
*---------------------------------------------------------------------------*/
static BOOL TWL_TP_IS_TOUCH( void )
{
vu8 penup = 0;
penup = CDC_ReadSpiRegister( 9 );
if ((penup & 0x80) == 0x00)
{
penup = CDC_ReadSpiRegister( 9 );
if ((penup & 0x80) == 0x00)
{
penup = CDC_ReadSpiRegister( 9 );
if ((penup & 0x80) == 0x00)
{
return FALSE;
}
}
}
return TRUE;
}
#define ABS(x) ( ( (x) >= 0 ) ? (x) : ( -(x) ) )
/*---------------------------------------------------------------------------*
Name: TWL_TP_ReadBuffer
Description: read Touch-Panel Buffer
Arguments: data : データ格納ポインタ
Returns: BOOL : if read success, return TRUE. otherwise FALSE.
*---------------------------------------------------------------------------*/
BOOL TWL_TP_ReadBuffer( SPITpData *data )
{
int i;
int target_index = 0; // 今からデータを格納する領域の先頭インデックス
u8 buf[32];
u8 not_readready;
// (void)cdcLock(); // CODECデバイスの操作権利を取得
CDC_ChangePage( 3 );
// ペンアップ判定
if (!TWL_TP_IS_TOUCH())
{
data->e.touch = FALSE;
data->e.validity = FALSE;
return TRUE; // ここはペンアップとしてシステム領域に書き出す
}
/*
//----- Availableチェック
not_readready = (u8)(CDC_ReadI2cRegister( 9 ));
if ((not_readready && 0x0c) == 0x0c)
{
(void)cdcUnlock(); // CODECデバイスの操作権利を解放 (忘れずに）
return FALSE;
}
*/
if (tpData.tpIndex == 0)
target_index = TP_DATA_SAMPLE_DEPTH_MAX;
for (i=0;i<tpData.tpDepth;i++)
{
// OS_SpinWait(100); // サンプリング時間が不足しているようなら追加も検討（ここは本来レディチェックするべき）
// XYサンプリング
CDC_ReadSpiRegisters( 42, &buf[i*4], 4 );
// サンプリング後のペンアップ判定 (サンプリング時間も稼げる）
if (!TWL_TP_IS_TOUCH())
{
return FALSE; // システム領域には書き出さない
}
}
for (i=0; i<tpData.tpDepth; i++)
{
tpData.xBuf[target_index+i] = (u16)((buf[i*4] << 8) | buf[i*4 + 1]);
tpData.yBuf[target_index+i] = (u16)((buf[i*4 + 2] << 8) | buf[i*4 + 3]);
}
tpData.tpIndex = target_index;
// (void)cdcUnlock(); // CODECデバイスの操作権利を解放
{
int i, j, index;
int xSum = 0;
int ySum = 0;
int same_required = (tpData.tpDepth >> 1) + 1;
int same_chance = tpData.tpDepth - same_required + 1;
int same_count = 0;
index = tpData.tpIndex;
/*
// ペンアップbitチェック
for (i=0; i<tpData.tpDepth; i++, index++)
{
if ((tpData.xBuf[index] & TP_NOT_TOUCH_MASK) || (tpData.yBuf[index] & TP_NOT_TOUCH_MASK))
{
data->e.touch = FALSE;
data->e.validity = FALSE;
return TRUE; // ここはペンアップとしてシステム領域に書き出す
}
// xSum += tpData.xBuf[index];
// ySum += tpData.yBuf[index];
}
*/
index = tpData.tpIndex;
// サンプリングした内の半数以上がrange以内であればvalidなデータとする。
for (i=0; i<same_chance; i++)
{
same_count = 0;
xSum = tpData.xBuf[index + i];
ySum = tpData.yBuf[index + i];
for (j=0; j<tpData.tpDepth; j++)
{
if (i==j) { continue; }
if ((ABS( tpData.xBuf[index + i] - tpData.xBuf[index + j] ) < 5) &&
(ABS( tpData.yBuf[index + i] - tpData.yBuf[index + j] ) < 5))
{
same_count++;
xSum += tpData.xBuf[index + j];
ySum += tpData.yBuf[index + j];
}
}
if (same_count >= same_required) { break; }
}
if (same_count < same_required)
{
return FALSE; // システム領域には書き出さない
}
data->e.x = xSum / (same_count+1);
data->e.y = ySum / (same_count+1);
data->e.touch = TRUE;
data->e.validity = TRUE;
//DBG_PRINTF("x : %4d %4d %4d %4d %4d %4d %4d %4d -> %4d\n", tpData.xBuf[index], tpData.xBuf[index + 1], tpData.xBuf[index + 2], tpData.xBuf[index + 3], tpData.xBuf[index + 4], tpData.xBuf[index + 5], tpData.xBuf[index + 6], tpData.xBuf[index + 7], data->e.x);
//DBG_PRINTF("y : %4d %4d %4d %4d %4d %4d %4d %4d -> %4d\n\n", tpData.yBuf[index], tpData.yBuf[index + 1], tpData.yBuf[index + 2], tpData.yBuf[index + 3], tpData.yBuf[index + 4], tpData.yBuf[index + 5], tpData.yBuf[index + 6], tpData.yBuf[index + 7], data->e.y);
}
return TRUE;
}
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
End of file End of file
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/

2
build/tests/snd/Makefile
View File

@ -26,7 +26,7 @@ SUBDIRS = channel \
ifneq ($(TWL_PLATFORM),DSTEG) ifneq ($(TWL_PLATFORM),DSTEG)
SUBDIRS += \ SUBDIRS += \
mic-2 \ # mic-2 \
endif # TWL_PLATFORM != DSTEG endif # TWL_PLATFORM != DSTEG

42
build/tests/snd/channel/ARM7/src/main.c
View File

@ -18,6 +18,16 @@
#include <twl/cdc.h> // for DS mode #include <twl/cdc.h> // for DS mode
#include <twl/snd/ARM7/i2s.h> #include <twl/snd/ARM7/i2s.h>
#define OSi_IDLE_CHECKNUM_SIZE ( sizeof(u32)*2 )
#define OSi_IDLE_SVC_SIZE ( sizeof(u32)*16 ) // arm7 svc stacks 14 words
#define OSi_IDLE_THREAD_STACK_SIZE ( OSi_IDLE_CHECKNUM_SIZE + OSi_IDLE_SVC_SIZE )
extern u32 OSi_IdleThreadStack[OSi_IDLE_THREAD_STACK_SIZE / sizeof(u32)];
extern OSThread OSi_IdleThread;
///////////////////
#define OS_TPrintf( ...) ((void)0)
///////////////////
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
定数定義 定数定義
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
@ -32,6 +42,25 @@
static OSHeapHandle InitializeAllocateSystem(void); static OSHeapHandle InitializeAllocateSystem(void);
static void VBlankIntr(void); static void VBlankIntr(void);
/*---------------------------------------------------------------------------*
Name: OSi_IdleThreadProc
Description: procedure of idle thread which system creates
Arguments: None
Returns: None (never return)
*---------------------------------------------------------------------------*/
static void OSi_IdleThreadProc(void *)
{
(void)OS_EnableInterrupts();
while (1)
{
OS_Halt();
}
// never return
}
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: TwlSpMain Name: TwlSpMain
@ -55,6 +84,16 @@ void TwlSpMain(void)
// ヒープ領域設定 // ヒープ領域設定
heapHandle = InitializeAllocateSystem(); heapHandle = InitializeAllocateSystem();
// create idle thread to sleep in main thread
OS_CreateThread(&OSi_IdleThread,
OSi_IdleThreadProc,
(void *)NULL,
OSi_IdleThreadStack + OSi_IDLE_THREAD_STACK_SIZE / sizeof(u32),
OSi_IDLE_THREAD_STACK_SIZE,
OS_THREAD_PRIORITY_MAX /*pseudo. change at next line. */ );
OSi_IdleThread.priority = OS_THREAD_PRIORITY_MAX + 1; // lower priority than the lowest (=OS_THREAD_PRIORITY_MAX)
OSi_IdleThread.state = OS_THREAD_STATE_READY;
// 割込み許可 // 割込み許可
(void)OS_SetIrqFunction(OS_IE_V_BLANK, VBlankIntr); (void)OS_SetIrqFunction(OS_IE_V_BLANK, VBlankIntr);
(void)OS_EnableIrqMask(OS_IE_V_BLANK); (void)OS_EnableIrqMask(OS_IE_V_BLANK);
@ -62,6 +101,9 @@ void TwlSpMain(void)
(void)OS_EnableIrq(); (void)OS_EnableIrq();
(void)OS_EnableInterrupts(); (void)OS_EnableInterrupts();
// CODEC<45>‰Šú‰»
CDC_Init();
// サウンド初期化 // サウンド初期化
SND_Init(THREAD_PRIO_SND); SND_Init(THREAD_PRIO_SND);

2
build/tests/snd/channel/ARM9/src/main.c
View File

@ -46,6 +46,8 @@ void VBlankIntr(void);
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void TwlMain() void TwlMain()
{ {
OS_InitPrintServer();
// <20>‰Šú‰» // <20>‰Šú‰»
OS_Init(); OS_Init();
GX_Init(); GX_Init();

211
build/tests/snd/mic-1/ARM7/src/main.c
View File

@ -16,24 +16,92 @@
#include <twl_sp.h> #include <twl_sp.h>
#include <twl/mic.h> #include <twl/mic.h>
#include <twl/cdc.h> // for DS mode
#include <twl/snd/ARM7/i2s.h>
#include <math.h> #include <math.h>
#define OSi_IDLE_CHECKNUM_SIZE ( sizeof(u32)*2 )
#define OSi_IDLE_SVC_SIZE ( sizeof(u32)*16 ) // arm7 svc stacks 14 words
#define OSi_IDLE_THREAD_STACK_SIZE ( OSi_IDLE_CHECKNUM_SIZE + OSi_IDLE_SVC_SIZE )
extern u32 OSi_IdleThreadStack[OSi_IDLE_THREAD_STACK_SIZE / sizeof(u32)];
extern OSThread OSi_IdleThread;
// ===== スレッド優先度 ===== // ===== スレッド優先度 =====
#define THREAD_PRIO_SPI 2
#define THREAD_PRIO_SND 6 #define THREAD_PRIO_SND 6
#define MY_MIC_BUF_LEN 0x100 //#define MY_MIC_BUF_LEN 33504
u16 micBuf[MY_MIC_BUF_LEN] __attribute__ ((aligned (32))); // 約１フレームのサンプル数
// 32バイト単位が望ましい
// 32.73kHz / 60 = 558.592 -> 576
#define FRAME_SAMPLES (576)
// 何フレーム分のバッファを用意するか
#define REC_FRAMES (300)
// サンプリングバッファサイズ
#define MY_MIC_BUF_LEN (FRAME_SAMPLES*REC_FRAMES)
//u16 micBuf[MY_MIC_BUF_LEN] __attribute__ ((aligned (32)));
u16* micBuf = (u16 *)0x0203AE40;
///////////////////
#define OS_TPrintf( ...) ((void)0)
///////////////////
/*---------------------------------------------------------------------------*
内部関数定義
*---------------------------------------------------------------------------*/
static OSHeapHandle InitializeAllocateSystem(void);
static void VBlankIntr(void);
/*---------------------------------------------------------------------------*
Name: OSi_IdleThreadProc
Description: procedure of idle thread which system creates
Arguments: None
Returns: None (never return)
*---------------------------------------------------------------------------*/
static void OSi_IdleThreadProc(void *)
{
(void)OS_EnableInterrupts();
while (1)
{
OS_Halt();
}
// never return
}
/*---------------------------------------------------------------------------*
Name: TwlSpMain
Description: Initialize and do main
Arguments: None.
Returns: None.
*---------------------------------------------------------------------------*/
void TwlSpMain(void) void TwlSpMain(void)
{ {
int i, ii; OSHeapHandle heapHandle;
OS_Init(); OS_Init();
OS_InitThread(); OS_InitThread();
// PXI初期化、ARM9と同期
PXI_Init();
// ヒープ領域設定
heapHandle = InitializeAllocateSystem();
// reg_CFG_DS_MDFY |= REG_CFG_DS_MDFY_SND_MASK; // SOUND回路バグ修正 (default: off) // reg_CFG_DS_MDFY |= REG_CFG_DS_MDFY_SND_MASK; // SOUND回路バグ修正 (default: off)
// reg_CFG_DS_MDFY |= REG_CFG_DS_MDFY_SDMA_MASK; // SOUND-DMAバグ修正 (default: off) // reg_CFG_DS_MDFY |= REG_CFG_DS_MDFY_SDMA_MASK; // SOUND-DMAバグ修正 (default: off)
// reg_CFG_DS_EX &= ~REG_CFG_DS_EX_SDMA2_MASK; // SOUND-DMA新回路 (default: on) // reg_CFG_DS_EX &= ~REG_CFG_DS_EX_SDMA2_MASK; // SOUND-DMA新回路 (default: on)
@ -41,38 +109,137 @@ void TwlSpMain(void)
// ボタン入力サーチ初期化 // ボタン入力サーチ初期化
(void)PAD_InitXYButton(); (void)PAD_InitXYButton();
// create idle thread to sleep in main thread
OS_CreateThread(&OSi_IdleThread,
OSi_IdleThreadProc,
(void *)NULL,
OSi_IdleThreadStack + OSi_IDLE_THREAD_STACK_SIZE / sizeof(u32),
OSi_IDLE_THREAD_STACK_SIZE,
OS_THREAD_PRIORITY_MAX /*pseudo. change at next line. */ );
OSi_IdleThread.priority = OS_THREAD_PRIORITY_MAX + 1; // lower priority than the lowest (=OS_THREAD_PRIORITY_MAX)
OSi_IdleThread.state = OS_THREAD_STATE_READY;
// 割込み許可 // 割込み許可
(void)OS_SetIrqFunction(OS_IE_V_BLANK, VBlankIntr);
(void)OS_EnableIrqMask(OS_IE_V_BLANK);
(void)GX_VBlankIntr(TRUE);
(void)OS_EnableIrq(); (void)OS_EnableIrq();
(void)OS_EnableInterrupts(); (void)OS_EnableInterrupts();
// CODEC初期化
CDC_Init();
// サウンド初期化 // サウンド初期化
SND_Init(THREAD_PRIO_SND); SND_Init(THREAD_PRIO_SND);
// マイク初期化 // マイク初期化
MICi_Init(); // MICi_Init();
CDC_InitMic();
///
TWL_MIC_InitServer(6);
///
// サンプリング周波数設定
SND_Disable();
// I2S_SetSamplingRate(I2S_SAMPLING_RATE_32730); // 32kHz
I2S_SetSamplingRate(I2S_SAMPLING_RATE_47610); // 48kHz
SND_Enable();
// SPI初期化
SPI_Init(THREAD_PRIO_SPI);
OS_TPrintf("\nARM7 starts.\n"); OS_TPrintf("\nARM7 starts.\n");
MICi_Start( MIC_SMP_ALL, MIC_DEFAULT_DMA_NO, micBuf, sizeof(micBuf) ); // MICi_Start( MIC_SMP_ALL, MIC_DEFAULT_DMA_NO, micBuf, MY_MIC_BUF_LEN );
OS_TPrintf( "\nMIC starts.\n");
OS_SpinWait( OS_MSEC_TO_CPUCYC( 60 ) ); while(1)
MICi_Stop();
OS_TPrintf( "\nMIC stops.\n");
OS_TPrintf( "\nDump mic buffer.\n" );
for (i=0; i<MY_MIC_BUF_LEN/16; i++)
{ {
for (ii=0; ii<16; ii++) // OS_Printf("0x%x\n", TWL_MIC_GetLastSamplingAddress());
{ OS_Sleep(16);
OS_TPrintf( "%4.4x ", micBuf[i*16+ii] );
} }
OS_TPrintf( "\n" );
}
OS_TPrintf( "\n" );
OS_TPrintf("\nARM7 ends.\n");
OS_Terminate();
} }
/*---------------------------------------------------------------------------*
Name: InitializeAllocateSystem
Description: メモリ割当てシステムを初期化する。
Arguments: None.
Returns: None.
*---------------------------------------------------------------------------*/
static OSHeapHandle InitializeAllocateSystem(void)
{
void *tempLo;
OSHeapHandle hh;
OS_TPrintf("OS_GetWramSubPrivArenaLo() = %p\n", OS_GetWramSubPrivArenaLo());
OS_TPrintf("OS_GetWramSubPrivArenaHi() = %p\n", OS_GetWramSubPrivArenaHi());
OS_TPrintf("OS_GetWramSubArenaLo() = %p\n", OS_GetWramSubArenaLo());
OS_TPrintf("OS_GetWramSubArenaHi() = %p\n", OS_GetWramSubArenaHi());
OS_TPrintf("OS_GetSubPrivArenaLo() = %p\n", OS_GetSubPrivArenaLo());
OS_TPrintf("OS_GetSubPrivArenaHi() = %p\n", OS_GetSubPrivArenaHi());
OS_TPrintf("call OS_SetWramSubPrivArenaHi(0x0380f980); to fix arena.\n");
OS_SetWramSubPrivArenaHi((void*)0x0380f980);
// メモリ割当て初期化
tempLo = OS_InitAlloc(OS_ARENA_WRAM_SUBPRIV,
OS_GetWramSubPrivArenaLo(), OS_GetWramSubPrivArenaHi(), 1);
// アリーナを0クリア
MI_CpuClear8(tempLo, (u32)OS_GetWramSubPrivArenaHi() - (u32)tempLo);
// アリーナ下位アドレスを設定
OS_SetArenaLo(OS_ARENA_WRAM_SUBPRIV, tempLo);
// ヒープ作成
hh = OS_CreateHeap(OS_ARENA_WRAM_SUBPRIV,
OS_GetWramSubPrivArenaLo(), OS_GetWramSubPrivArenaHi());
if (hh < 0)
{
OS_Panic("ARM7: Fail to create heap.\n");
}
// カレントヒープに設定
(void)OS_SetCurrentHeap(OS_ARENA_WRAM_SUBPRIV, hh);
return hh;
}
/*---------------------------------------------------------------------------*
Name: VBlankIntr
Description: VBlank interrupt handler
Arguments: None
Returns: None
*---------------------------------------------------------------------------*/
#ifndef SDK_TEG
extern BOOL PMi_Initialized;
void PM_SelfBlinkProc(void);
static void VBlankIntr(void)
{
//---- LED blink system
if (PMi_Initialized)
{
PM_SelfBlinkProc();
}
}
#else
static void VBlankIntr(void)
{
}
#endif
/*---------------------------------------------------------------------------*
End of file
*---------------------------------------------------------------------------*/

2
build/tests/snd/mic-1/ARM9/Makefile
View File

@ -24,7 +24,7 @@ SUBDIRS =
TARGET_BIN = mic9_1.axf TARGET_BIN = mic9_1.axf
SRCS = main.c SRCS = main.c organ_det.g3.pcm16.c wihaho.pcm16.c
#SRCDIR = # using default #SRCDIR = # using default
#LCFILE = # using default #LCFILE = # using default

351
build/tests/snd/mic-1/ARM9/src/main.c
View File

@ -14,6 +14,56 @@
$NoKeywords: $ $NoKeywords: $
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
#include <twl.h> #include <twl.h>
#include <twl/mic.h>
#include "organ_det.g3.pcm16.h"
#include "wihaho.pcm16.h"
// PSGの周波数を計算するマクロ
#define FreqToTimer(freq) (SND_TIMER_CLOCK / ( 8 * (freq) ))
#define KeyToTimer(key) (SND_CalcTimer(FreqToTimer(440), ((key)-69)*64))
#define PCM_PLAY_CHANNEL1 4
#define PCM_PLAY_CHANNEL2 5
#define PSG_PLAY_CHANNEL 8
#define NOISE_PLAY_CHANNEL 14
#define CENTER_PAN 64
u16 Cont;
u16 Trg;
u8 key = 60;
void VBlankIntr(void);
void DrawPos(int x, int y);
void Line(int x1, int y1, int x2, int y2);
//////////////
// 約１フレームのサンプル数
// 32バイト単位が望ましい
// 32.73kHz / 60 = 545.5 -> 544
// 47.61kHz / 60 = 793.5 -> 800
#define FRAME_SAMPLES (800)
// 何フレーム分のバッファを用意するか
#define REC_FRAMES (300)
// サンプリングバッファサイズ
#define MY_MIC_BUF_LEN (FRAME_SAMPLES*REC_FRAMES)
s16 wave[MY_MIC_BUF_LEN/2] __attribute__ ((aligned (32)));
int view_x[FRAME_SAMPLES];
int view_y[FRAME_SAMPLES];
s32 wave_index = 0;
//////////////
void FullCallback(TWLMICResult result, void* arg)
{
// OS_Printf("FullCallback was called.\n");
// OS_Printf("result = %d\n", result);
}
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: TwlMain Name: TwlMain
@ -26,10 +76,311 @@
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void TwlMain() void TwlMain()
{ {
int i;
TwlMicAutoParam param;
OS_InitPrintServer();
OS_Init(); OS_Init();
GX_Init();
SND_Init();
// Vブランク割り込み設定
OS_SetIrqFunction(OS_IE_V_BLANK, VBlankIntr);
(void)OS_EnableIrqMask(OS_IE_V_BLANK);
(void)OS_EnableIrq();
(void)GX_VBlankIntr(TRUE);
// print usage
OS_Printf("=================================\n");
OS_Printf("USAGE:\n");
OS_Printf(" A, B, X, Y : start sound\n");
OS_Printf(" START : stop sound\n");
OS_Printf("=================================\n");
// チャンネルをロックする
SND_LockChannel((1 << PCM_PLAY_CHANNEL1) | (1 << PCM_PLAY_CHANNEL2) | (1 << PSG_PLAY_CHANNEL) |
(1 << NOISE_PLAY_CHANNEL), 0);
GX_DispOff();
GXS_DispOff();
//---------------------------------------------------------------------------
// All VRAM banks to LCDC
//---------------------------------------------------------------------------
GX_SetBankForLCDC(GX_VRAM_LCDC_ALL);
//---------------------------------------------------------------------------
// Clear all LCDC space
//---------------------------------------------------------------------------
MI_CpuClearFast((void *)HW_LCDC_VRAM, HW_LCDC_VRAM_SIZE);
//---------------------------------------------------------------------------
// Set graphics mode VRAM display mode
//---------------------------------------------------------------------------
GX_SetGraphicsMode(GX_DISPMODE_VRAM_A, // display VRAM-A
(GXBGMode)0, // dummy
(GXBG0As)0); // dummy
GX_DispOn();
GXS_DispOn();
////////////////////////////////////
TWL_MIC_Init();
{
param.dmaNo = 6;
param.buffer = wave;
param.size = MY_MIC_BUF_LEN;
param.frequency = 0; //MIC_SMP_ALL;
param.loop_enable = 1;
param.full_callback = FullCallback;
param.full_arg = 0;
TWL_MIC_StartAutoSampling( &param );
}
////////////////////////////////////
while (1)
{
u16 ReadData;
OS_WaitVBlankIntr();
// ＡＲＭ７コマンド応答受信
while (SND_RecvCommandReply(SND_COMMAND_NOBLOCK) != NULL)
{
}
//////////////////////// 単発サンプリングテスト
/*
{
u16 buf;
TWLMICResult result = TWL_MIC_DoSampling(&buf);
if (result == TWL_MIC_RESULT_SUCCESS)
{
OS_Printf("%x\n", buf);
}
else
{
OS_Printf("fail\n");
}
}
*/
////////////////////////
{
static u8 gain;
u8 now;
if (Trg & PAD_KEY_UP)
{
TWL_MIC_SetAmpGain( ++gain );
TWL_MIC_GetAmpGain( &now );
OS_Printf("gain = %d", now);
}
else if (Trg & PAD_KEY_DOWN)
{
TWL_MIC_SetAmpGain( --gain );
TWL_MIC_GetAmpGain( &now );
OS_Printf("gain = %d", now);
}
}
if (Trg & PAD_KEY_RIGHT)
{
void* address;
TWL_MIC_GetLastSamplingAddress( &address );
OS_Printf("0x%x\n", address);
}
ReadData = PAD_Read();
Trg = (u16)(ReadData & (ReadData ^ Cont));
Cont = ReadData;
// PCM再生
if (Trg & PAD_BUTTON_A)
{
OS_Printf("A\n");
SND_SetupChannelPcm(PCM_PLAY_CHANNEL1,
ORGAN_DET_G3_PCM16_FORMAT,
organ_det_g3_pcm16,
ORGAN_DET_G3_PCM16_LOOPFLAG ? SND_CHANNEL_LOOP_REPEAT :
SND_CHANNEL_LOOP_1SHOT, ORGAN_DET_G3_PCM16_LOOPSTART,
ORGAN_DET_G3_PCM16_LOOPLEN, 127, SND_CHANNEL_DATASHIFT_NONE,
SND_CalcTimer(ORGAN_DET_G3_PCM16_TIMER, ((key) - 67) * 64),
CENTER_PAN);
SND_StartTimer(1 << PCM_PLAY_CHANNEL1, 0, 0, 0);
}
if (Trg & PAD_BUTTON_R)
{
OS_Printf("R\n");
///////////////////////////////////
TWL_MIC_StartAutoSampling( &param );
///////////////////////////////////
}
if (Trg & PAD_BUTTON_L)
{
OS_Printf("L\n");
///////////////////////////////////
TWL_MIC_StopAutoSampling();
///////////////////////////////////
}
if (Trg & PAD_BUTTON_B)
{
OS_Printf("B\n");
/*
SND_SetupChannelPcm(PCM_PLAY_CHANNEL2,
WIHAHO_PCM16_FORMAT,
wihaho_pcm16,
WIHAHO_PCM16_LOOPFLAG ? SND_CHANNEL_LOOP_REPEAT :
SND_CHANNEL_LOOP_1SHOT, WIHAHO_PCM16_LOOPSTART,
WIHAHO_PCM16_LOOPLEN, 127, SND_CHANNEL_DATASHIFT_NONE,
WIHAHO_PCM16_TIMER, CENTER_PAN);
*/
SND_SetupChannelPcm(PCM_PLAY_CHANNEL2,
SND_WAVE_FORMAT_PCM16,
(void *)wave,
SND_CHANNEL_LOOP_REPEAT, // SND_CHANNEL_LOOP_1SHOT,
0,
MY_MIC_BUF_LEN/4,
127,
SND_CHANNEL_DATASHIFT_NONE,
379, // 524, //379,
CENTER_PAN);
SND_StartTimer(1 << PCM_PLAY_CHANNEL2, 0, 0, 0);
}
// 停止
if (Trg & PAD_BUTTON_START)
{
SND_StopTimer((1 << PCM_PLAY_CHANNEL1) | (1 << PCM_PLAY_CHANNEL2) |
(1 << PSG_PLAY_CHANNEL) | (1 << NOISE_PLAY_CHANNEL), 0, 0, 0);
}
MI_CpuClearFast((void *)HW_LCDC_VRAM, 2*256*192);
DC_InvalidateRange( wave, MY_MIC_BUF_LEN );
/*
for (i=0;i<192;i++)
{
s16 x = *(s16 *)(wave + i*2);
DrawPos(128 + x , i);
}
*/
for (i=0;i<FRAME_SAMPLES;i++)
{
// 時間軸(0～255)
view_x[i] = i * 0.444;
// サンプリング値（±32768 → ±100）/327.68
// サンプリング値（±32768 → ±100）/327.68
view_y[i] = *(s16 *)((u32)wave + (wave_index + i)*2) / 32.768 + 96;
}
wave_index += FRAME_SAMPLES;
if (wave_index >= MY_MIC_BUF_LEN/2)
{
wave_index = 0;
}
for (i=0;i<FRAME_SAMPLES-1;i++)
{
Line(view_x[i], view_y[i], view_x[i+1], view_y[i+1]);
}
// コマンドフラッシュ
(void)SND_FlushCommand(SND_COMMAND_NOBLOCK);
}
OS_TPrintf("\nARM9 starts.\n"); OS_TPrintf("\nARM9 starts.\n");
OS_TPrintf("\nARM9 ends.\n"); OS_TPrintf("\nARM9 ends.\n");
OS_Terminate(); OS_Terminate();
} }
//--------------------------------------------------------------------------------
// Ｖブランク割り込み処理
//
void VBlankIntr(void)
{
OS_SetIrqCheckFlag(OS_IE_V_BLANK); // checking VBlank interrupt
}
//--------------------------------------------------------------------------------
// 画面座標描画
//
void DrawPos(int x, int y)
{
const int screen_width = 256;
const int screen_height = 191;
int address;
// if agc
// x >>= 10;
//
address = HW_LCDC_VRAM + screen_width*2*y + 2*x;
*(u16 *)(address) = 0x7fff;
}
int ABS(x){ return (x>=0)? (x) : (-x); }
void Line(int x1, int y1, int x2, int y2)
{
int dx, dy, s, step;
dx = ABS(x2 - x1);
dy = ABS(y2 - y1);
if (dx > dy)
{
if (x1 > x2)
{
step = (y1 > y2) ? 1 : -1;
s = x1; x1 = x2; x2 = s; y1 = y2;
} else step = (y1 < y2) ? 1 : -1;
DrawPos(x1, y1);
s = dx >> 1;
while (++x1 <= x2)
{
if ((s -= dy) < 0)
{
s += dx;
y1 += step;
}
DrawPos(x1, y1);
}
}
else
{
if (y1 > y2)
{
step = (x1 > x2) ? 1 : -1;
s = y1; y1 = y2; y2 = s; x1 = x2;
} else step = (x1 < x2) ? 1 : -1;
DrawPos(x1, y1);
s = dy >> 1;
while (++y1 <= y2)
{
if ((s -= dx) < 0)
{
s += dy; x1 += step;
}
DrawPos(x1, y1);
}
}
}

43
build/tests/spi/tp-auto-sampling-twl-mode/ARM7/src/main.c
View File

@ -29,6 +29,17 @@
#include <twl/cdc.h> // for DS mode #include <twl/cdc.h> // for DS mode
#include <twl/snd/ARM7/i2s.h> #include <twl/snd/ARM7/i2s.h>
#define OSi_IDLE_CHECKNUM_SIZE ( sizeof(u32)*2 )
#define OSi_IDLE_SVC_SIZE ( sizeof(u32)*16 ) // arm7 svc stacks 14 words
#define OSi_IDLE_THREAD_STACK_SIZE ( OSi_IDLE_CHECKNUM_SIZE + OSi_IDLE_SVC_SIZE )
extern u32 OSi_IdleThreadStack[OSi_IDLE_THREAD_STACK_SIZE / sizeof(u32)];
extern OSThread OSi_IdleThread;
///////////////////
#define OS_TPrintf( ...) ((void)0)
///////////////////
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
定数定義 定数定義
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
@ -43,6 +54,25 @@
static OSHeapHandle InitializeAllocateSystem(void); static OSHeapHandle InitializeAllocateSystem(void);
static void VBlankIntr(void); static void VBlankIntr(void);
/*---------------------------------------------------------------------------*
Name: OSi_IdleThreadProc
Description: procedure of idle thread which system creates
Arguments: None
Returns: None (never return)
*---------------------------------------------------------------------------*/
static void OSi_IdleThreadProc(void *)
{
(void)OS_EnableInterrupts();
while (1)
{
OS_Halt();
}
// never return
}
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: TwlSpMain Name: TwlSpMain
@ -66,6 +96,16 @@ void TwlSpMain(void)
// ヒープ領域設定 // ヒープ領域設定
heapHandle = InitializeAllocateSystem(); heapHandle = InitializeAllocateSystem();
// create idle thread to sleep in main thread
OS_CreateThread(&OSi_IdleThread,
OSi_IdleThreadProc,
(void *)NULL,
OSi_IdleThreadStack + OSi_IDLE_THREAD_STACK_SIZE / sizeof(u32),
OSi_IDLE_THREAD_STACK_SIZE,
OS_THREAD_PRIORITY_MAX /*pseudo. change at next line. */ );
OSi_IdleThread.priority = OS_THREAD_PRIORITY_MAX + 1; // lower priority than the lowest (=OS_THREAD_PRIORITY_MAX)
OSi_IdleThread.state = OS_THREAD_STATE_READY;
// 割込み許可 // 割込み許可
(void)OS_SetIrqFunction(OS_IE_V_BLANK, VBlankIntr); (void)OS_SetIrqFunction(OS_IE_V_BLANK, VBlankIntr);
(void)OS_EnableIrqMask(OS_IE_V_BLANK); (void)OS_EnableIrqMask(OS_IE_V_BLANK);
@ -73,6 +113,9 @@ void TwlSpMain(void)
(void)OS_EnableIrq(); (void)OS_EnableIrq();
(void)OS_EnableInterrupts(); (void)OS_EnableInterrupts();
// CODEC<45>‰Šú‰»
CDC_Init();
// サウンド初期化 // サウンド初期化
SND_Init(THREAD_PRIO_SND); SND_Init(THREAD_PRIO_SND);

7
build/tests/spi/tp-auto-sampling-twl-mode/ARM9/src/main.c
View File

@ -62,6 +62,8 @@ TPCalibrateParam calibrate;
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void TwlMain() void TwlMain()
{ {
OS_InitPrintServer();
// <20>‰Šú‰» // <20>‰Šú‰»
OS_Init(); OS_Init();
GX_Init(); GX_Init();
@ -74,10 +76,12 @@ void TwlMain()
(void)GX_VBlankIntr(TRUE); (void)GX_VBlankIntr(TRUE);
// Send parameter of revision noise. // Send parameter of revision noise.
/*
if (TP_RequestSetStability(3, 15) != 0) if (TP_RequestSetStability(3, 15) != 0)
{ {
OS_Panic("SetStability request err!\n"); OS_Panic("SetStability request err!\n");
} }
*/
GX_DispOff(); GX_DispOff();
GXS_DispOff(); GXS_DispOff();
@ -99,6 +103,7 @@ void TwlMain()
(GXBGMode)0, // dummy (GXBGMode)0, // dummy
(GXBG0As)0); // dummy (GXBG0As)0); // dummy
GX_SetDispSelect(GX_DISP_SELECT_SUB_MAIN);
GX_DispOn(); GX_DispOn();
GXS_DispOn(); GXS_DispOn();
@ -193,7 +198,7 @@ void* Sequence4(void)
{ {
s32 last_idx = TP_GetLatestIndexInAuto(); s32 last_idx = TP_GetLatestIndexInAuto();
if (gTpBuf[last_idx].touch) if (gTpBuf[last_idx].touch == TP_TOUCH_ON && gTpBuf[last_idx].validity == TP_VALIDITY_VALID )
{ {
/* /*
/////////// ///////////

11
build/tests/spi/tp-auto-sampling/ARM7/src/main.c
View File

@ -39,6 +39,11 @@
extern u32 OSi_IdleThreadStack[OSi_IDLE_THREAD_STACK_SIZE / sizeof(u32)]; extern u32 OSi_IdleThreadStack[OSi_IDLE_THREAD_STACK_SIZE / sizeof(u32)];
extern OSThread OSi_IdleThread; extern OSThread OSi_IdleThread;
///////////////////
#define OS_TPrintf( ...) ((void)0)
///////////////////
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
定数定義 定数定義
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
@ -112,6 +117,9 @@ void TwlSpMain(void)
OSi_IdleThread.priority = OS_THREAD_PRIORITY_MAX + 1; // lower priority than the lowest (=OS_THREAD_PRIORITY_MAX) OSi_IdleThread.priority = OS_THREAD_PRIORITY_MAX + 1; // lower priority than the lowest (=OS_THREAD_PRIORITY_MAX)
OSi_IdleThread.state = OS_THREAD_STATE_READY; OSi_IdleThread.state = OS_THREAD_STATE_READY;
// CODEC<45>‰Šú‰»
CDC_Init();
// サウンド初期化 // サウンド初期化
SND_Init(THREAD_PRIO_SND); SND_Init(THREAD_PRIO_SND);
@ -161,7 +169,7 @@ static OSHeapHandle InitializeAllocateSystem(void)
{ {
void *tempLo; void *tempLo;
OSHeapHandle hh; OSHeapHandle hh;
/*
OS_TPrintf("OS_GetWramSubPrivArenaLo() = %p\n", OS_GetWramSubPrivArenaLo()); OS_TPrintf("OS_GetWramSubPrivArenaLo() = %p\n", OS_GetWramSubPrivArenaLo());
OS_TPrintf("OS_GetWramSubPrivArenaHi() = %p\n", OS_GetWramSubPrivArenaHi()); OS_TPrintf("OS_GetWramSubPrivArenaHi() = %p\n", OS_GetWramSubPrivArenaHi());
OS_TPrintf("OS_GetWramSubArenaLo() = %p\n", OS_GetWramSubArenaLo()); OS_TPrintf("OS_GetWramSubArenaLo() = %p\n", OS_GetWramSubArenaLo());
@ -170,6 +178,7 @@ static OSHeapHandle InitializeAllocateSystem(void)
OS_TPrintf("OS_GetSubPrivArenaHi() = %p\n", OS_GetSubPrivArenaHi()); OS_TPrintf("OS_GetSubPrivArenaHi() = %p\n", OS_GetSubPrivArenaHi());
OS_TPrintf("call OS_SetWramSubPrivArenaHi(0x0380f980); to fix arena.\n"); OS_TPrintf("call OS_SetWramSubPrivArenaHi(0x0380f980); to fix arena.\n");
*/
OS_SetWramSubPrivArenaHi((void*)0x0380f980); OS_SetWramSubPrivArenaHi((void*)0x0380f980);
// メモリ割当て初期化 // メモリ割当て初期化

3
build/tests/spi/tp-auto-sampling/ARM9/src/main.c
View File

@ -62,6 +62,8 @@ TPCalibrateParam calibrate;
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void TwlMain() void TwlMain()
{ {
OS_InitPrintServer();
// <20>‰Šú‰» // <20>‰Šú‰»
OS_Init(); OS_Init();
GX_Init(); GX_Init();
@ -99,6 +101,7 @@ void TwlMain()
(GXBGMode)0, // dummy (GXBGMode)0, // dummy
(GXBG0As)0); // dummy (GXBG0As)0); // dummy
GX_SetDispSelect(GX_DISP_SELECT_SUB_MAIN);
GX_DispOn(); GX_DispOn();
GXS_DispOn(); GXS_DispOn();

43
build/tests/spi/tp-sampling-twl-mode/ARM7/src/main.c
View File

@ -26,6 +26,16 @@
#include <twl/cdc.h> // for DS mode #include <twl/cdc.h> // for DS mode
#include <twl/snd/ARM7/i2s.h> #include <twl/snd/ARM7/i2s.h>
#define OSi_IDLE_CHECKNUM_SIZE ( sizeof(u32)*2 )
#define OSi_IDLE_SVC_SIZE ( sizeof(u32)*16 ) // arm7 svc stacks 14 words
#define OSi_IDLE_THREAD_STACK_SIZE ( OSi_IDLE_CHECKNUM_SIZE + OSi_IDLE_SVC_SIZE )
extern u32 OSi_IdleThreadStack[OSi_IDLE_THREAD_STACK_SIZE / sizeof(u32)];
extern OSThread OSi_IdleThread;
///////////////////
#define OS_TPrintf( ...) ((void)0)
///////////////////
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
定数定義 定数定義
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
@ -40,6 +50,25 @@
static OSHeapHandle InitializeAllocateSystem(void); static OSHeapHandle InitializeAllocateSystem(void);
static void VBlankIntr(void); static void VBlankIntr(void);
/*---------------------------------------------------------------------------*
Name: OSi_IdleThreadProc
Description: procedure of idle thread which system creates
Arguments: None
Returns: None (never return)
*---------------------------------------------------------------------------*/
static void OSi_IdleThreadProc(void *)
{
(void)OS_EnableInterrupts();
while (1)
{
OS_Halt();
}
// never return
}
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: TwlSpMain Name: TwlSpMain
@ -63,6 +92,17 @@ void TwlSpMain(void)
// ヒープ領域設定 // ヒープ領域設定
heapHandle = InitializeAllocateSystem(); heapHandle = InitializeAllocateSystem();
// create idle thread to sleep in main thread
OS_CreateThread(&OSi_IdleThread,
OSi_IdleThreadProc,
(void *)NULL,
OSi_IdleThreadStack + OSi_IDLE_THREAD_STACK_SIZE / sizeof(u32),
OSi_IDLE_THREAD_STACK_SIZE,
OS_THREAD_PRIORITY_MAX /*pseudo. change at next line. */ );
OSi_IdleThread.priority = OS_THREAD_PRIORITY_MAX + 1; // lower priority than the lowest (=OS_THREAD_PRIORITY_MAX)
OSi_IdleThread.state = OS_THREAD_STATE_READY;
// 割込み許可 // 割込み許可
(void)OS_SetIrqFunction(OS_IE_V_BLANK, VBlankIntr); (void)OS_SetIrqFunction(OS_IE_V_BLANK, VBlankIntr);
(void)OS_EnableIrqMask(OS_IE_V_BLANK); (void)OS_EnableIrqMask(OS_IE_V_BLANK);
@ -70,6 +110,9 @@ void TwlSpMain(void)
(void)OS_EnableIrq(); (void)OS_EnableIrq();
(void)OS_EnableInterrupts(); (void)OS_EnableInterrupts();
// CODEC<45>‰Šú‰»
CDC_Init();
// サウンド初期化 // サウンド初期化
SND_Init(THREAD_PRIO_SND); SND_Init(THREAD_PRIO_SND);

3
build/tests/spi/tp-sampling-twl-mode/ARM9/src/main.c
View File

@ -33,6 +33,8 @@ void TwlMain()
{ {
TPData raw_point; TPData raw_point;
OS_InitPrintServer();
// <20>‰Šú‰» // <20>‰Šú‰»
OS_Init(); OS_Init();
GX_Init(); GX_Init();
@ -70,6 +72,7 @@ void TwlMain()
(GXBGMode)0, // dummy (GXBGMode)0, // dummy
(GXBG0As)0); // dummy (GXBG0As)0); // dummy
GX_SetDispSelect(GX_DISP_SELECT_SUB_MAIN);
GX_DispOn(); GX_DispOn();
GXS_DispOn(); GXS_DispOn();

7
build/tests/spi/tp-sampling/ARM7/src/main.c
View File

@ -36,6 +36,10 @@
extern u32 OSi_IdleThreadStack[OSi_IDLE_THREAD_STACK_SIZE / sizeof(u32)]; extern u32 OSi_IdleThreadStack[OSi_IDLE_THREAD_STACK_SIZE / sizeof(u32)];
extern OSThread OSi_IdleThread; extern OSThread OSi_IdleThread;
///////////////////
#define OS_TPrintf( ...) ((void)0)
///////////////////
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
定数定義 定数定義
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
@ -109,6 +113,9 @@ void TwlSpMain(void)
OSi_IdleThread.priority = OS_THREAD_PRIORITY_MAX + 1; // lower priority than the lowest (=OS_THREAD_PRIORITY_MAX) OSi_IdleThread.priority = OS_THREAD_PRIORITY_MAX + 1; // lower priority than the lowest (=OS_THREAD_PRIORITY_MAX)
OSi_IdleThread.state = OS_THREAD_STATE_READY; OSi_IdleThread.state = OS_THREAD_STATE_READY;
// CODEC<45>‰Šú‰»
CDC_Init();
// サウンド初期化 // サウンド初期化
SND_Init(THREAD_PRIO_SND); SND_Init(THREAD_PRIO_SND);

3
build/tests/spi/tp-sampling/ARM9/src/main.c
View File

@ -33,6 +33,8 @@ void TwlMain()
{ {
TPData raw_point; TPData raw_point;
OS_InitPrintServer();
// <20>‰Šú‰» // <20>‰Šú‰»
OS_Init(); OS_Init();
GX_Init(); GX_Init();
@ -70,6 +72,7 @@ void TwlMain()
(GXBGMode)0, // dummy (GXBGMode)0, // dummy
(GXBG0As)0); // dummy (GXBG0As)0); // dummy
GX_SetDispSelect(GX_DISP_SELECT_SUB_MAIN);
GX_DispOn(); GX_DispOn();
GXS_DispOn(); GXS_DispOn();

1
include/nitro/pxi/common/fifo.h
View File

@ -114,6 +114,7 @@ typedef enum
PXI_FIFO_TAG_AES, // AES PXI_FIFO_TAG_AES, // AES
PXI_FIFO_TAG_CAMERA, // Camera PXI_FIFO_TAG_CAMERA, // Camera
PXI_FIFO_TAG_GCD, // Card Ex PXI_FIFO_TAG_GCD, // Card Ex
PXI_FIFO_TAG_TWL_MIC, // TWL Microphone
PXI_MAX_FIFO_TAG = 32 // MAX FIFO TAG PXI_MAX_FIFO_TAG = 32 // MAX FIFO TAG
} }

123
include/twl/cdc/ARM7/cdc.h
View File

@ -29,19 +29,38 @@ extern "C" {
extern void SPI_Lock(u32 id); extern void SPI_Lock(u32 id);
extern void SPI_Unlock(u32 id); extern void SPI_Unlock(u32 id);
//================================================================ /*---------------------------------------------------------------------------*
// CODEC status variables Name: CDC_InitMutex
//================================================================
extern SPIBaudRate cdcSPIBaudRate;
extern BOOL cdcIsTwlMode;
extern int cdcCurrentPage;
#define CDC_REVISION_A 0 Description: Init CODEC Mutex
#define CDC_REVISION_B 1
#define CDC_REVISION_C 2
extern int cdcRevisionID;
extern u16 cdcSpiMode; Arguments: None
Returns: None
*---------------------------------------------------------------------------*/
void CDC_InitMutex(void);
/*---------------------------------------------------------------------------*
Name: CDC_Lock
Description: Lock CODEC device
Arguments: None
Returns: TRUE if success
*---------------------------------------------------------------------------*/
void CDC_Lock( void ); // 外部スレッドから呼ばれ、CODECデバイスの操作権利を取得する
/*---------------------------------------------------------------------------*
Name: CDC_Unlock
Description: Unlock CODEC device
Arguments: None
Returns: TRUE if success
*---------------------------------------------------------------------------*/
void CDC_Unlock( void ); // 外部スレッドから呼ばれ、CODECデバイスの操作権利を解放する
//================================================================ //================================================================
// BAUDRATE parameter // BAUDRATE parameter
@ -50,34 +69,6 @@ extern u16 cdcSpiMode;
// CODECの制限により4MHZを最大とする // CODECの制限により4MHZを最大とする
#define CDC_SPI_BAUDRATE_DEFAULT SPI_BAUDRATE_4MHZ #define CDC_SPI_BAUDRATE_DEFAULT SPI_BAUDRATE_4MHZ
/*---------------------------------------------------------------------------*
Name: CDCi_SetSPIBaudRate
Description: set SPI baud rate.
Arguments: baud rate.
Returns: None.
*---------------------------------------------------------------------------*/
static inline void CDCi_SetSPIBaudRate( SPIBaudRate rate )
{
cdcSPIBaudRate = rate;
}
/*---------------------------------------------------------------------------*
Name: CDCi_GetSPIBaudRate
Description: get SPI baud rate.
Arguments: None.
Returns: baud rate.
*---------------------------------------------------------------------------*/
static inline SPIBaudRate CDCi_GetSPIBaudRate( void )
{
return cdcSPIBaudRate;
}
//================================================================================ //================================================================================
// I2C BIT CONTROL // I2C BIT CONTROL
//================================================================================ //================================================================================
@ -232,6 +223,8 @@ static inline void CDC_ReadI2cRegisters( u8 reg, u8 *bufp, size_t size )
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void CDCi_SetSpiParams( u8 reg, u8 setBits, u8 maskBits ); void CDCi_SetSpiParams( u8 reg, u8 setBits, u8 maskBits );
void CDC_SetSpiParams( u8 reg, u8 setBits, u8 maskBits ); void CDC_SetSpiParams( u8 reg, u8 setBits, u8 maskBits );
void CDCi_SetSpiParamsEx( u8 page, u8 reg, u8 setBits, u8 maskBits );
void CDC_SetSpiParamsEx( u8 page, u8 reg, u8 setBits, u8 maskBits );
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: CDC_SetSpiFlags Name: CDC_SetSpiFlags
@ -244,7 +237,10 @@ void CDC_SetSpiParams( u8 reg, u8 setBits, u8 maskBits );
Returns: None Returns: None
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void CDCi_SetSpiFlags( u8 reg, u8 setBits ); void CDCi_SetSpiFlags( u8 reg, u8 setBits );
void CDC_SetSpiFlags( u8 reg, u8 setBits ); static inline void CDC_SetSpiFlags( u8 reg, u8 setBits )
{
CDC_SetSpiParams( reg, setBits, setBits );
}
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: CDC_ClearSpiFlags Name: CDC_ClearSpiFlags
@ -257,7 +253,10 @@ void CDC_SetSpiFlags( u8 reg, u8 setBits );
Returns: None Returns: None
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void CDCi_ClearSpiFlags( u8 reg, u8 clrBits ); void CDCi_ClearSpiFlags( u8 reg, u8 clrBits );
void CDC_ClearSpiFlags( u8 reg, u8 clrBits ); static inline void CDC_ClearSpiFlags( u8 reg, u8 clrBits )
{
CDC_SetSpiParams( reg, 0, clrBits );
}
//================================================================================ //================================================================================
// SPI ACCESS // SPI ACCESS
@ -273,12 +272,9 @@ void CDC_ClearSpiFlags( u8 reg, u8 clrBits );
Returns: None Returns: None
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void CDCi_WriteSpiRegister( u8 reg, u8 data ); void CDCi_WriteSpiRegister( u8 reg, u8 data );
static inline void CDC_WriteSpiRegister( u8 reg, u8 data ) void CDC_WriteSpiRegister( u8 reg, u8 data );
{ void CDCi_WriteSpiRegisterEx( u8 page, u8 reg, u8 data );
(void)SPI_Lock(123); void CDC_WriteSpiRegisterEx( u8 page, u8 reg, u8 data );
CDCi_WriteSpiRegister( reg, data );
(void)SPI_Unlock(123);
}
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: CDC_ReadSpiRegister Name: CDC_ReadSpiRegister
@ -290,14 +286,9 @@ static inline void CDC_WriteSpiRegister( u8 reg, u8 data )
Returns: value which is read from specified decive register Returns: value which is read from specified decive register
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
u8 CDCi_ReadSpiRegister( u8 reg ); u8 CDCi_ReadSpiRegister( u8 reg );
static inline u8 CDC_ReadSpiRegister( u8 reg ) u8 CDC_ReadSpiRegister( u8 reg );
{ u8 CDCi_ReadSpiRegisterEx( u8 page, u8 reg );
u8 value; u8 CDC_ReadSpiRegisterEx( u8 page, u8 reg );
(void)SPI_Lock(123);
value = CDCi_ReadSpiRegister( reg );
(void)SPI_Unlock(123);
return value;
}
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: CDC_WriteSpiRegisters Name: CDC_WriteSpiRegisters
@ -310,12 +301,9 @@ static inline u8 CDC_ReadSpiRegister( u8 reg )
Returns: None Returns: None
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void CDCi_WriteSpiRegisters( u8 reg, const u8 *bufp, size_t size ); void CDCi_WriteSpiRegisters( u8 reg, const u8 *bufp, size_t size );
static inline void CDC_WriteSpiRegisters( u8 reg, const u8 *bufp, size_t size ) void CDC_WriteSpiRegisters( u8 reg, const u8 *bufp, size_t size );
{ void CDCi_WriteSpiRegistersEx( u8 page, u8 reg, const u8 *bufp, size_t size );
(void)SPI_Lock(123); void CDC_WriteSpiRegistersEx( u8 page, u8 reg, const u8 *bufp, size_t size );
CDCi_WriteSpiRegisters( reg, bufp, size );
(void)SPI_Unlock(123);
}
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: CDC_ReadSpiRegisters Name: CDC_ReadSpiRegisters
@ -327,12 +315,9 @@ static inline void CDC_WriteSpiRegisters( u8 reg, const u8 *bufp, size_t size )
Returns: value which is read from specified decive register Returns: value which is read from specified decive register
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void CDCi_ReadSpiRegisters( u8 reg, u8 *bufp, size_t size ); void CDCi_ReadSpiRegisters( u8 reg, u8 *bufp, size_t size );
static inline void CDC_ReadSpiRegisters( u8 reg, u8 *bufp, size_t size ) void CDC_ReadSpiRegisters( u8 reg, u8 *bufp, size_t size );
{ void CDCi_ReadSpiRegistersEx( u8 page, u8 reg, u8 *bufp, size_t size );
(void)SPI_Lock(123); void CDC_ReadSpiRegistersEx( u8 page, u8 reg, u8 *bufp, size_t size );
CDCi_ReadSpiRegisters( reg, bufp, size );
(void)SPI_Unlock(123);
}
//================================================================================ //================================================================================
// Utility Functions // Utility Functions
@ -346,8 +331,8 @@ static inline void CDC_ReadSpiRegisters( u8 reg, u8 *bufp, size_t size )
Returns: None Returns: None
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void CDCi_ChangePage( int page_no ); void CDCi_ChangePage( u8 page_no );
void CDC_ChangePage( int page_no ); void CDC_ChangePage( u8 page_no );
#ifdef __cplusplus #ifdef __cplusplus
} /* extern "C" */ } /* extern "C" */

36
include/twl/cdc/ARM7/cdc_api.h
View File

@ -23,6 +23,12 @@
extern "C" { extern "C" {
#endif #endif
typedef enum _CDCPllParameter
{
CDC_PLL_PARAMETER_FOR_SAMPLING_RATE_32730,
CDC_PLL_PARAMETER_FOR_SAMPLING_RATE_47610
} CDCPllParameter;
//================================================================================ //================================================================================
// INIT APIs // INIT APIs
//================================================================================ //================================================================================
@ -70,7 +76,6 @@ void CDC_InitSound( void );
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void CDC_InitMic( void ); void CDC_InitMic( void );
//================================================================================ //================================================================================
// Query/Check APIs // Query/Check APIs
//================================================================================ //================================================================================
@ -151,15 +156,15 @@ void CDC_SetInputPinControl( BOOL enable_vcnt5, BOOL enable_sphp, BOOL enable
void CDC_GetInputPinControl( BOOL *enable_vcnt5, BOOL *enable_sphp, BOOL *enable_pmoff ); void CDC_GetInputPinControl( BOOL *enable_vcnt5, BOOL *enable_sphp, BOOL *enable_pmoff );
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: CDC_SetParamPLL Name: CDC_SetPLL
Description: setup PLL parameter of the CODEC Description: setup PLL parameter of the CODEC
Arguments: is48kHz : set 48 kHz if TRUE. set 32kHz if FALSE. Arguments: param: parameter type
Returns: None Returns: None
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void CDC_SetParamPLL( BOOL is48kHz ); void CDC_SetPLL( CDCPllParameter param );
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: CDC_PowerUpDAC Name: CDC_PowerUpDAC
@ -328,6 +333,29 @@ void CDC_EnableAGC( int target_gain );
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void CDC_DisableAGC( void ); void CDC_DisableAGC( void );
/*---------------------------------------------------------------------------*
Name: CDC_SetPGAB
Description: Setup PGA of the CODEC
PGA is enabled when AGC is disabled.
Arguments: int target_gain : 0 <EFBFBD>` 119 (0dB <EFBFBD>` 59.5dB)
Returns: None
*---------------------------------------------------------------------------*/
void CDC_SetPGAB( u8 target_gain );
/*---------------------------------------------------------------------------*
Name: CDC_GetPGAB
Description: Get PGA of the CODEC
Arguments: None
Returns: Gain
*---------------------------------------------------------------------------*/
u8 CDC_GetPGAB( void );
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: CDC_Init1stOrderFilter Name: CDC_Init1stOrderFilter

27
include/twl/cdc/ARM7/cdc_dsmode_access.h
View File

@ -70,10 +70,12 @@ static inline SPIBaudRate CDCi_DsmodeGetSPIBaudRate( void )
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: i_tpChangeSpiMode Name: CDCi_DsmodeChangeSpiMode
Description: change SPI mode.. Description: change SPI mode..
この関数はDSモードで、かつ、Codecにさわるときのみ使うはず
Arguments: continuous : SPI_TRANSMODE_CONTINUOUS or SPI_TRANSMODE_1BYTE Arguments: continuous : SPI_TRANSMODE_CONTINUOUS or SPI_TRANSMODE_1BYTE
Returns: None. Returns: None.
@ -103,7 +105,12 @@ static inline void CDCi_DsmodeChangeSpiMode( SPITransMode continuous )
Returns: None Returns: None
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void CDCi_DsmodeSetSpiParams( u8 reg, u8 setBits, u8 maskBits ); void CDCi_DsmodeSetSpiParams( u8 reg, u8 setBits, u8 maskBits );
void CDC_DsmodeSetSpiParams( u8 reg, u8 setBits, u8 maskBits ); static inline void CDC_DsmodeSetSpiParams( u8 reg, u8 setBits, u8 maskBits )
{
(void)SPI_Lock(123);
CDCi_DsmodeSetSpiParams( reg, setBits, maskBits );
(void)SPI_Unlock(123);
}
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: CDC_DsmodeSetSpiFlags Name: CDC_DsmodeSetSpiFlags
@ -116,7 +123,10 @@ void CDC_DsmodeSetSpiParams( u8 reg, u8 setBits, u8 maskBits );
Returns: None Returns: None
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void CDCi_DsmodeSetSpiFlags( u8 reg, u8 setBits ); void CDCi_DsmodeSetSpiFlags( u8 reg, u8 setBits );
void CDC_DsmodeSetSpiFlags( u8 reg, u8 setBits ); static inline void CDC_DsmodeSetSpiFlags( u8 reg, u8 setBits )
{
CDC_DsmodeSetSpiParams( reg, setBits, setBits );
}
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*
Name: CDC_DsmodeClearSpiFlags Name: CDC_DsmodeClearSpiFlags
@ -129,7 +139,10 @@ void CDC_DsmodeSetSpiFlags( u8 reg, u8 setBits );
Returns: None Returns: None
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void CDCi_DsmodeClearSpiFlags( u8 reg, u8 clrBits ); void CDCi_DsmodeClearSpiFlags( u8 reg, u8 clrBits );
void CDC_DsmodeClearSpiFlags( u8 reg, u8 clrBits ); static inline void CDC_DsmodeClearSpiFlags( u8 reg, u8 clrBits )
{
CDC_DsmodeSetSpiParams( reg, 0, clrBits );
}
//================================================================================ //================================================================================
// SPI ACCESS // SPI ACCESS
@ -162,11 +175,13 @@ static inline void CDC_DsmodeWriteSpiRegister( u8 reg, u8 data )
Returns: value which is read from specified TP register Returns: value which is read from specified TP register
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
u8 CDCi_DsmodeReadSpiRegister( u8 reg ); u8 CDCi_DsmodeReadSpiRegister( u8 reg );
static inline void CDC_DsmodeReadSpiRegister( u8 reg ) static inline u8 CDC_DsmodeReadSpiRegister( u8 reg )
{ {
u8 value;
(void)SPI_Lock(123); (void)SPI_Lock(123);
CDCi_DsmodeReadSpiRegister( reg ); value = CDCi_DsmodeReadSpiRegister( reg );
(void)SPI_Unlock(123); (void)SPI_Unlock(123);
return value;
} }
/*---------------------------------------------------------------------------* /*---------------------------------------------------------------------------*

4
include/twl/cdc/ARM7/cdc_reg.h
View File

@ -742,11 +742,11 @@ CDCBackCompatibleMode;
#define CDC1_MIC_ADC_PGA_MUTE (1<< 7) // default #define CDC1_MIC_ADC_PGA_MUTE (1<< 7) // default
//---- CDC1_MIC_PGA_P //---- CDC1_MIC_PGA_P
#define CDC1_MIC_PGA_P_I_SHIFT 0 #define CDC1_MIC_PGA_P_I_SHIFT 6
#define CDC1_MIC_PGA_P_I_MASK (0x3<< CDC1_MIC_PGA_P_I_SHIFT) #define CDC1_MIC_PGA_P_I_MASK (0x3<< CDC1_MIC_PGA_P_I_SHIFT)
//---- CDC1_MIC_PGA_M //---- CDC1_MIC_PGA_M
#define CDC1_MIC_PGA_M_I_SHIFT 0 #define CDC1_MIC_PGA_M_I_SHIFT 6
#define CDC1_MIC_PGA_M_I_MASK (0x3<< CDC1_MIC_PGA_M_I_SHIFT) #define CDC1_MIC_PGA_M_I_MASK (0x3<< CDC1_MIC_PGA_M_I_SHIFT)
//---- CDC1_MIC_INPUT //---- CDC1_MIC_INPUT

11
include/twl/mic.h
View File

@ -17,8 +17,17 @@
#ifndef TWL_MIC_H_ #ifndef TWL_MIC_H_
#define TWL_MIC_H_ #define TWL_MIC_H_
#include <twl/mic/common/fifo.h>
#ifdef SDK_ARM7 #ifdef SDK_ARM7
#include <twl/snd/ARM7/snd_mic.h>
#include <twl/mic/ARM7/twl_mic_api.h>
#include <twl/mic/ARM7/twl_mic_server.h>
#else
#include <twl/mic/ARM9/twl_mic_api.h>
#endif // SDK_ARM7 #endif // SDK_ARM7
/* TWL_MIC_H_ */ /* TWL_MIC_H_ */

11
include/twl/snd/ARM7/i2s.h
View File

@ -30,6 +30,13 @@ extern "C" {
#define I2S_MIXING_DSP_MAX 0 #define I2S_MIXING_DSP_MAX 0
#define I2S_MIXING_DSP_MIN 8 #define I2S_MIXING_DSP_MIN 8
typedef enum _I2SSamplingRate
{
I2S_SAMPLING_RATE_32730 = 0,
I2S_SAMPLING_RATE_47610 = 1,
I2S_SAMPLING_RATE_NUM = 2
} I2SSamplingRate;
/****************************************************************************** /******************************************************************************
public function declaration public function declaration
******************************************************************************/ ******************************************************************************/
@ -50,8 +57,8 @@ BOOL I2S_IsMute(void);
void I2S_SetMixingRatio(int nitroRatio); void I2S_SetMixingRatio(int nitroRatio);
int I2S_GetMixingRatio(void); int I2S_GetMixingRatio(void);
void I2S_SetSamplingRatio(BOOL is48kHz); void I2S_SetSamplingRate( I2SSamplingRate rate );
BOOL I2S_IsSamplingRatio48kHz( void ); I2SSamplingRate I2S_GetSamplingRate( void );
#endif /* SDK_ARM7 */ #endif /* SDK_ARM7 */

97
include/twl/snd/ARM7/snd_mic.h
View File

@ -1,97 +0,0 @@
/*---------------------------------------------------------------------------*
Project: CtrSDK - MIC - include
File: snd_mic.h
Copyright 2006 Nintendo. All rights reserved.
These coded instructions, statements, and computer programs contain
proprietary information of Nintendo of America Inc. and/or Nintendo
Company Ltd., and are protected by Federal copyright law. They may
not be disclosed to third parties or copied or duplicated in any form,
in whole or in part, without the prior written consent of Nintendo.
$Log: $
$NoKeywords: $
*---------------------------------------------------------------------------*/
#ifndef TWL_SND_MIC_H_
#define TWL_SND_MIC_H_
#include <twl/types.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef enum
{
MIC_INTR_DISABLE = (0x0UL << REG_SND_MICCNT_IM_SHIFT),
MIC_INTR_HALF = (0x1UL << REG_SND_MICCNT_IM_SHIFT),
MIC_INTR_OVERFLOW = (0x2UL << REG_SND_MICCNT_IM_SHIFT),
MIC_INTR_HALF_OVERFLOW = (0x3UL << REG_SND_MICCNT_IM_SHIFT)
}
MICIntrCond;
typedef enum
{
MIC_SMP_ALL = (0x0UL << REG_SND_MICCNT_FIFO_SMP_SHIFT),
MIC_SMP_1_2 = (0x1UL << REG_SND_MICCNT_FIFO_SMP_SHIFT),
MIC_SMP_1_3 = (0x2UL << REG_SND_MICCNT_FIFO_SMP_SHIFT),
MIC_SMP_1_4 = (0x3UL << REG_SND_MICCNT_FIFO_SMP_SHIFT)
}
MICSampleRate;
typedef struct
{
u32 dmaNo; // DMA No
void* buf;
s32 bufSize;
}
MICWork;
#define MIC_DEFAULT_DMA_NO 6
/*---------------------------------------------------------------------------*
Name: MICi_Init
Description: initialize MIC
Arguments: None
Returns: None
*---------------------------------------------------------------------------*/
void MICi_Init( void );
/*---------------------------------------------------------------------------*
Name: MICi_Start
Description: start MIC
Arguments: id : slave id
Returns: None
*---------------------------------------------------------------------------*/
void MICi_Start( MICSampleRate smp, u32 dmaNo, void *dest, s32 size );
/*---------------------------------------------------------------------------*
Name: MICi_Stop
Description: stop MIC
Arguments: None
Returns: None
*---------------------------------------------------------------------------*/
void MICi_Stop( void );
#ifdef __cplusplus
} /* extern "C" */
#endif
/* TWL_SND_MIC_H_ */
#endif