2514 lines
63 KiB
C
2514 lines
63 KiB
C
/*******************************************************************************
|
|
Copyright (C) Marvell International Ltd. and its affiliates
|
|
|
|
This software file (the "File") is owned and distributed by Marvell
|
|
International Ltd. and/or its affiliates ("Marvell") under the following
|
|
alternative licensing terms. Once you have made an election to distribute the
|
|
File under one of the following license alternatives, please (i) delete this
|
|
introductory statement regarding license alternatives, (ii) delete the two
|
|
license alternatives that you have not elected to use and (iii) preserve the
|
|
Marvell copyright notice above.
|
|
|
|
********************************************************************************
|
|
Marvell Commercial License Option
|
|
|
|
If you received this File from Marvell and you have entered into a commercial
|
|
license agreement (a "Commercial License") with Marvell, the File is licensed
|
|
to you under the terms of the applicable Commercial License.
|
|
|
|
********************************************************************************
|
|
Marvell GPL License Option
|
|
|
|
If you received this File from Marvell, you may opt to use, redistribute and/or
|
|
modify this File in accordance with the terms and conditions of the General
|
|
Public License Version 2, June 1991 (the "GPL License"), a copy of which is
|
|
available along with the File in the license.txt file or by writing to the Free
|
|
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 or
|
|
on the worldwide web at http://www.gnu.org/licenses/gpl.txt.
|
|
|
|
THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE IMPLIED
|
|
WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY
|
|
DISCLAIMED. The GPL License provides additional details about this warranty
|
|
disclaimer.
|
|
********************************************************************************
|
|
Marvell BSD License Option
|
|
|
|
If you received this File from Marvell, you may opt to use, redistribute and/or
|
|
modify this File under the following licensing terms.
|
|
Redistribution and use in source and binary forms, with or without modification,
|
|
are permitted provided that the following conditions are met:
|
|
|
|
* Redistributions of source code must retain the above copyright notice,
|
|
this list of conditions and the following disclaimer.
|
|
|
|
* Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
|
|
* Neither the name of Marvell nor the names of its contributors may be
|
|
used to endorse or promote products derived from this software without
|
|
specific prior written permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
|
|
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
|
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*******************************************************************************/
|
|
|
|
#include "boardEnv/mvBoardEnvLib.h"
|
|
#include "ctrlEnv/mvCtrlEnvLib.h"
|
|
#include "ctrlEnv/sys/mvCpuIf.h"
|
|
#include "cpu/mvCpu.h"
|
|
#include "cntmr/mvCntmr.h"
|
|
#include "gpp/mvGpp.h"
|
|
#include "twsi/mvTwsi.h"
|
|
#include "pex/mvPex.h"
|
|
#include "device/mvDevice.h"
|
|
#include "eth/gbe/mvEthRegs.h"
|
|
|
|
/* defines */
|
|
/* #define MV_DEBUG */
|
|
#ifdef MV_DEBUG
|
|
#define DB(x) x
|
|
#else
|
|
#define DB(x)
|
|
#endif
|
|
|
|
extern MV_CPU_ARM_CLK _cpuARMDDRCLK[];
|
|
|
|
#define CODE_IN_ROM MV_FALSE
|
|
#define CODE_IN_RAM MV_TRUE
|
|
|
|
extern MV_BOARD_INFO* boardInfoTbl[];
|
|
#define BOARD_INFO(boardId) boardInfoTbl[boardId - BOARD_ID_BASE]
|
|
|
|
/* Locals */
|
|
static MV_DEV_CS_INFO* boardGetDevEntry(MV_32 devNum, MV_BOARD_DEV_CLASS devClass);
|
|
|
|
MV_U32 tClkRate = -1;
|
|
|
|
|
|
/*******************************************************************************
|
|
* mvBoardEnvInit - Init board
|
|
*
|
|
* DESCRIPTION:
|
|
* In this function the board environment take care of device bank
|
|
* initialization.
|
|
*
|
|
* INPUT:
|
|
* None.
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* None.
|
|
*
|
|
*******************************************************************************/
|
|
MV_VOID mvBoardEnvInit(MV_VOID)
|
|
{
|
|
MV_U32 boardId= mvBoardIdGet();
|
|
|
|
if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
|
|
{
|
|
mvOsPrintf("mvBoardEnvInit:Board unknown.\n");
|
|
return;
|
|
|
|
}
|
|
|
|
/* Set GPP Out value */
|
|
MV_REG_WRITE(GPP_DATA_OUT_REG(0), BOARD_INFO(boardId)->gppOutValLow);
|
|
MV_REG_WRITE(GPP_DATA_OUT_REG(1), BOARD_INFO(boardId)->gppOutValHigh);
|
|
|
|
/* set GPP polarity */
|
|
mvGppPolaritySet(0, 0xFFFFFFFF, BOARD_INFO(boardId)->gppPolarityValLow);
|
|
mvGppPolaritySet(1, 0xFFFFFFFF, BOARD_INFO(boardId)->gppPolarityValHigh);
|
|
|
|
/* Workaround for Erratum FE-MISC-70*/
|
|
if(mvCtrlRevGet()==MV_88F6XXX_A0_REV)
|
|
{
|
|
BOARD_INFO(boardId)->gppOutEnValLow &= 0xfffffffd;
|
|
BOARD_INFO(boardId)->gppOutEnValLow |= (BOARD_INFO(boardId)->gppOutEnValHigh) & 0x00000002;
|
|
} /*End of WA*/
|
|
|
|
/* Set GPP Out Enable*/
|
|
mvGppTypeSet(0, 0xFFFFFFFF, BOARD_INFO(boardId)->gppOutEnValLow);
|
|
mvGppTypeSet(1, 0xFFFFFFFF, BOARD_INFO(boardId)->gppOutEnValHigh);
|
|
|
|
/* Nand CE */
|
|
MV_REG_BIT_SET(NAND_CTRL_REG, NAND_ACTCEBOOT_BIT);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardModelGet - Get Board model
|
|
*
|
|
* DESCRIPTION:
|
|
* This function returns 16bit describing board model.
|
|
* Board model is constructed of one byte major and minor numbers in the
|
|
* following manner:
|
|
*
|
|
* INPUT:
|
|
* None.
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* String describing board model.
|
|
*
|
|
*******************************************************************************/
|
|
MV_U16 mvBoardModelGet(MV_VOID)
|
|
{
|
|
return (mvBoardIdGet() >> 16);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mbBoardRevlGet - Get Board revision
|
|
*
|
|
* DESCRIPTION:
|
|
* This function returns a 32bit describing the board revision.
|
|
* Board revision is constructed of 4bytes. 2bytes describes major number
|
|
* and the other 2bytes describes minor munber.
|
|
* For example for board revision 3.4 the function will return
|
|
* 0x00030004.
|
|
*
|
|
* INPUT:
|
|
* None.
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* String describing board model.
|
|
*
|
|
*******************************************************************************/
|
|
MV_U16 mvBoardRevGet(MV_VOID)
|
|
{
|
|
return (mvBoardIdGet() & 0xFFFF);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardNameGet - Get Board name
|
|
*
|
|
* DESCRIPTION:
|
|
* This function returns a string describing the board model and revision.
|
|
* String is extracted from board I2C EEPROM.
|
|
*
|
|
* INPUT:
|
|
* None.
|
|
*
|
|
* OUTPUT:
|
|
* pNameBuff - Buffer to contain board name string. Minimum size 32 chars.
|
|
*
|
|
* RETURN:
|
|
*
|
|
* MV_ERROR if informantion can not be read.
|
|
*******************************************************************************/
|
|
MV_STATUS mvBoardNameGet(char *pNameBuff)
|
|
{
|
|
MV_U32 boardId= mvBoardIdGet();
|
|
|
|
if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
|
|
{
|
|
mvOsSPrintf (pNameBuff, "Board unknown.\n");
|
|
return MV_ERROR;
|
|
|
|
}
|
|
|
|
mvOsSPrintf (pNameBuff, "%s",BOARD_INFO(boardId)->boardName);
|
|
|
|
return MV_OK;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardIsPortInSgmii -
|
|
*
|
|
* DESCRIPTION:
|
|
* This routine returns MV_TRUE for port number works in SGMII or MV_FALSE
|
|
* For all other options.
|
|
*
|
|
* INPUT:
|
|
* ethPortNum - Ethernet port number.
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* MV_TRUE - port in SGMII.
|
|
* MV_FALSE - other.
|
|
*
|
|
*******************************************************************************/
|
|
MV_BOOL mvBoardIsPortInSgmii(MV_U32 ethPortNum)
|
|
{
|
|
MV_BOOL ethPortSgmiiSupport[BOARD_ETH_PORT_NUM] = MV_ETH_PORT_SGMII;
|
|
|
|
if(ethPortNum >= BOARD_ETH_PORT_NUM)
|
|
{
|
|
mvOsPrintf ("Invalid portNo=%d\n", ethPortNum);
|
|
return MV_FALSE;
|
|
}
|
|
return ethPortSgmiiSupport[ethPortNum];
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardIsPortInGmii -
|
|
*
|
|
* DESCRIPTION:
|
|
* This routine returns MV_TRUE for port number works in GMII or MV_FALSE
|
|
* For all other options.
|
|
*
|
|
* INPUT:
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* MV_TRUE - port in GMII.
|
|
* MV_FALSE - other.
|
|
*
|
|
*******************************************************************************/
|
|
MV_BOOL mvBoardIsPortInGmii(MV_VOID)
|
|
{
|
|
MV_U32 devClassId, devClass = 0;
|
|
if (mvBoardMppGroupTypeGet(devClass) == MV_BOARD_AUTO)
|
|
{
|
|
/* Get MPP module ID */
|
|
devClassId = mvBoarModuleTypeGet(devClass);
|
|
if (MV_BOARD_MODULE_GMII_ID == devClassId)
|
|
return MV_TRUE;
|
|
}
|
|
else if (mvBoardMppGroupTypeGet(devClass) == MV_BOARD_GMII)
|
|
return MV_TRUE;
|
|
|
|
return MV_FALSE;
|
|
}
|
|
/*******************************************************************************
|
|
* mvBoardPhyAddrGet - Get the phy address
|
|
*
|
|
* DESCRIPTION:
|
|
* This routine returns the Phy address of a given ethernet port.
|
|
*
|
|
* INPUT:
|
|
* ethPortNum - Ethernet port number.
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* 32bit describing Phy address, -1 if the port number is wrong.
|
|
*
|
|
*******************************************************************************/
|
|
MV_32 mvBoardPhyAddrGet(MV_U32 ethPortNum)
|
|
{
|
|
MV_U32 boardId= mvBoardIdGet();
|
|
|
|
if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
|
|
{
|
|
mvOsPrintf("mvBoardPhyAddrGet: Board unknown.\n");
|
|
return MV_ERROR;
|
|
}
|
|
|
|
return BOARD_INFO(boardId)->pBoardMacInfo[ethPortNum].boardEthSmiAddr;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardMacSpeedGet - Get the Mac speed
|
|
*
|
|
* DESCRIPTION:
|
|
* This routine returns the Mac speed if pre define of a given ethernet port.
|
|
*
|
|
* INPUT:
|
|
* ethPortNum - Ethernet port number.
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* MV_BOARD_MAC_SPEED, -1 if the port number is wrong.
|
|
*
|
|
*******************************************************************************/
|
|
MV_BOARD_MAC_SPEED mvBoardMacSpeedGet(MV_U32 ethPortNum)
|
|
{
|
|
MV_U32 boardId= mvBoardIdGet();
|
|
|
|
if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
|
|
{
|
|
mvOsPrintf("mvBoardMacSpeedGet: Board unknown.\n");
|
|
return MV_ERROR;
|
|
}
|
|
|
|
return BOARD_INFO(boardId)->pBoardMacInfo[ethPortNum].boardMacSpeed;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardLinkStatusIrqGet - Get the IRQ number for the link status indication
|
|
*
|
|
* DESCRIPTION:
|
|
* This routine returns the IRQ number for the link status indication.
|
|
*
|
|
* INPUT:
|
|
* ethPortNum - Ethernet port number.
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* the number of the IRQ for the link status indication, -1 if the port
|
|
* number is wrong or if not relevant.
|
|
*
|
|
*******************************************************************************/
|
|
MV_32 mvBoardLinkStatusIrqGet(MV_U32 ethPortNum)
|
|
{
|
|
MV_U32 boardId = mvBoardIdGet();
|
|
|
|
if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
|
|
{
|
|
mvOsPrintf("mvBoardLinkStatusIrqGet: Board unknown.\n");
|
|
return MV_ERROR;
|
|
}
|
|
|
|
return BOARD_INFO(boardId)->pSwitchInfo[ethPortNum].linkStatusIrq;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardSwitchPortGet - Get the mapping between the board connector and the
|
|
* Ethernet Switch port
|
|
*
|
|
* DESCRIPTION:
|
|
* This routine returns the matching Switch port.
|
|
*
|
|
* INPUT:
|
|
* ethPortNum - Ethernet port number.
|
|
* boardPortNum - logical number of the connector on the board
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* the matching Switch port, -1 if the port number is wrong or if not relevant.
|
|
*
|
|
*******************************************************************************/
|
|
MV_32 mvBoardSwitchPortGet(MV_U32 ethPortNum, MV_U8 boardPortNum)
|
|
{
|
|
MV_U32 boardId = mvBoardIdGet();
|
|
|
|
if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
|
|
{
|
|
mvOsPrintf("mvBoardSwitchPortGet: Board unknown.\n");
|
|
return MV_ERROR;
|
|
}
|
|
if (boardPortNum >= BOARD_ETH_SWITCH_PORT_NUM)
|
|
{
|
|
mvOsPrintf("mvBoardSwitchPortGet: Illegal board port number.\n");
|
|
return MV_ERROR;
|
|
}
|
|
|
|
return BOARD_INFO(boardId)->pSwitchInfo[ethPortNum].qdPort[boardPortNum];
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardSwitchCpuPortGet - Get the the Ethernet Switch CPU port
|
|
*
|
|
* DESCRIPTION:
|
|
* This routine returns the Switch CPU port.
|
|
*
|
|
* INPUT:
|
|
* ethPortNum - Ethernet port number.
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* the Switch CPU port, -1 if the port number is wrong or if not relevant.
|
|
*
|
|
*******************************************************************************/
|
|
MV_32 mvBoardSwitchCpuPortGet(MV_U32 ethPortNum)
|
|
{
|
|
MV_U32 boardId = mvBoardIdGet();
|
|
|
|
if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
|
|
{
|
|
mvOsPrintf("mvBoardSwitchCpuPortGet: Board unknown.\n");
|
|
return MV_ERROR;
|
|
}
|
|
|
|
return BOARD_INFO(boardId)->pSwitchInfo[ethPortNum].qdCpuPort;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardIsSwitchConnected - Get switch connection status
|
|
* DESCRIPTION:
|
|
* This routine returns port's connection status
|
|
*
|
|
* INPUT:
|
|
* ethPortNum - Ethernet port number.
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* 1 - if ethPortNum is connected to switch, 0 otherwise
|
|
*
|
|
*******************************************************************************/
|
|
MV_32 mvBoardIsSwitchConnected(MV_U32 ethPortNum)
|
|
{
|
|
MV_U32 boardId = mvBoardIdGet();
|
|
|
|
if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
|
|
{
|
|
mvOsPrintf("mvBoardIsSwitchConnected: Board unknown.\n");
|
|
return MV_ERROR;
|
|
}
|
|
|
|
if(ethPortNum >= BOARD_INFO(boardId)->numBoardMacInfo)
|
|
{
|
|
mvOsPrintf("mvBoardIsSwitchConnected: Illegal port number(%u)\n", ethPortNum);
|
|
return MV_ERROR;
|
|
}
|
|
|
|
if((MV_32)(BOARD_INFO(boardId)->pSwitchInfo))
|
|
return (MV_32)(BOARD_INFO(boardId)->pSwitchInfo[ethPortNum].switchOnPort == ethPortNum);
|
|
else
|
|
return 0;
|
|
}
|
|
/*******************************************************************************
|
|
* mvBoardSmiScanModeGet - Get Switch SMI scan mode
|
|
*
|
|
* DESCRIPTION:
|
|
* This routine returns Switch SMI scan mode.
|
|
*
|
|
* INPUT:
|
|
* ethPortNum - Ethernet port number.
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* 1 for SMI_MANUAL_MODE, -1 if the port number is wrong or if not relevant.
|
|
*
|
|
*******************************************************************************/
|
|
MV_32 mvBoardSmiScanModeGet(MV_U32 ethPortNum)
|
|
{
|
|
MV_U32 boardId = mvBoardIdGet();
|
|
|
|
if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
|
|
{
|
|
mvOsPrintf("mvBoardSmiScanModeGet: Board unknown.\n");
|
|
return MV_ERROR;
|
|
}
|
|
|
|
return BOARD_INFO(boardId)->pSwitchInfo[ethPortNum].smiScanMode;
|
|
}
|
|
/*******************************************************************************
|
|
* mvBoardSpecInitGet -
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN: Return MV_TRUE and parameters in case board need spesific phy init,
|
|
* otherwise return MV_FALSE.
|
|
*
|
|
*
|
|
*******************************************************************************/
|
|
|
|
MV_BOOL mvBoardSpecInitGet(MV_U32* regOff, MV_U32* data)
|
|
{
|
|
return MV_FALSE;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardTclkGet - Get the board Tclk (Controller clock)
|
|
*
|
|
* DESCRIPTION:
|
|
* This routine extract the controller core clock.
|
|
* This function uses the controller counters to make identification.
|
|
* Note: In order to avoid interference, make sure task context switch
|
|
* and interrupts will not occure during this function operation
|
|
*
|
|
* INPUT:
|
|
* countNum - Counter number.
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* 32bit clock cycles in Hertz.
|
|
*
|
|
*******************************************************************************/
|
|
MV_U32 mvBoardTclkGet(MV_VOID)
|
|
{
|
|
if(mvCtrlModelGet()==MV_6281_DEV_ID)
|
|
{
|
|
#if defined(TCLK_AUTO_DETECT)
|
|
MV_U32 tmpTClkRate = MV_BOARD_TCLK_166MHZ;
|
|
|
|
tmpTClkRate = MV_REG_READ(MPP_SAMPLE_AT_RESET);
|
|
tmpTClkRate &= MSAR_TCLCK_MASK;
|
|
|
|
switch (tmpTClkRate)
|
|
{
|
|
case MSAR_TCLCK_166:
|
|
return MV_BOARD_TCLK_166MHZ;
|
|
break;
|
|
case MSAR_TCLCK_200:
|
|
return MV_BOARD_TCLK_200MHZ;
|
|
break;
|
|
}
|
|
#else
|
|
return MV_BOARD_TCLK_200MHZ;
|
|
#endif
|
|
}
|
|
|
|
return MV_BOARD_TCLK_166MHZ;
|
|
|
|
}
|
|
/*******************************************************************************
|
|
* mvBoardSysClkGet - Get the board SysClk (CPU bus clock)
|
|
*
|
|
* DESCRIPTION:
|
|
* This routine extract the CPU bus clock.
|
|
*
|
|
* INPUT:
|
|
* countNum - Counter number.
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* 32bit clock cycles in Hertz.
|
|
*
|
|
*******************************************************************************/
|
|
static MV_U32 mvBoard6180SysClkGet(MV_VOID)
|
|
{
|
|
MV_U32 sysClkRate=0;
|
|
MV_CPU_ARM_CLK _cpu6180_ddr_l2_CLK[] = MV_CPU6180_DDR_L2_CLCK_TBL;
|
|
|
|
sysClkRate = MV_REG_READ(MPP_SAMPLE_AT_RESET);
|
|
sysClkRate = sysClkRate & MSAR_CPUCLCK_MASK_6180;
|
|
sysClkRate = sysClkRate >> MSAR_CPUCLCK_OFFS_6180;
|
|
|
|
sysClkRate = _cpu6180_ddr_l2_CLK[sysClkRate].ddrClk;
|
|
|
|
return sysClkRate;
|
|
|
|
}
|
|
|
|
MV_U32 mvBoardSysClkGet(MV_VOID)
|
|
{
|
|
#ifdef SYSCLK_AUTO_DETECT
|
|
MV_U32 sysClkRate, tmp, pClkRate, indexDdrRtio;
|
|
MV_U32 cpuCLK[] = MV_CPU_CLCK_TBL;
|
|
MV_U32 ddrRtio[][2] = MV_DDR_CLCK_RTIO_TBL;
|
|
|
|
if(mvCtrlModelGet() == MV_6180_DEV_ID)
|
|
return mvBoard6180SysClkGet();
|
|
|
|
tmp = MV_REG_READ(MPP_SAMPLE_AT_RESET);
|
|
pClkRate = MSAR_CPUCLCK_EXTRACT(tmp);
|
|
pClkRate = cpuCLK[pClkRate];
|
|
|
|
indexDdrRtio = tmp & MSAR_DDRCLCK_RTIO_MASK;
|
|
indexDdrRtio = indexDdrRtio >> MSAR_DDRCLCK_RTIO_OFFS;
|
|
if(ddrRtio[indexDdrRtio][0] != 0)
|
|
sysClkRate = ((pClkRate * ddrRtio[indexDdrRtio][1]) / ddrRtio[indexDdrRtio][0]);
|
|
else
|
|
sysClkRate = 0;
|
|
return sysClkRate;
|
|
#else
|
|
return MV_BOARD_DEFAULT_SYSCLK;
|
|
#endif
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* mvBoardPexBridgeIntPinGet - Get PEX to PCI bridge interrupt pin number
|
|
*
|
|
* DESCRIPTION:
|
|
* Multi-ported PCI Express bridges that is implemented on the board
|
|
* collapse interrupts across multiple conventional PCI/PCI-X buses.
|
|
* A dual-headed PCI Express bridge would map (or "swizzle") the
|
|
* interrupts per the following table (in accordance with the respective
|
|
* logical PCI/PCI-X bridge's Device Number), collapse the INTA#-INTD#
|
|
* signals from its two logical PCI/PCI-X bridges, collapse the
|
|
* INTA#-INTD# signals from any internal sources, and convert the
|
|
* signals to in-band PCI Express messages. 10
|
|
* This function returns the upstream interrupt as it was converted by
|
|
* the bridge, according to board configuration and the following table:
|
|
* PCI dev num
|
|
* Interrupt pin 7, 8, 9
|
|
* A -> A D C
|
|
* B -> B A D
|
|
* C -> C B A
|
|
* D -> D C B
|
|
*
|
|
*
|
|
* INPUT:
|
|
* devNum - PCI/PCIX device number.
|
|
* intPin - PCI Int pin
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* Int pin connected to the Interrupt controller
|
|
*
|
|
*******************************************************************************/
|
|
MV_U32 mvBoardPexBridgeIntPinGet(MV_U32 devNum, MV_U32 intPin)
|
|
{
|
|
MV_U32 realIntPin = ((intPin + (3 - (devNum % 4))) %4 );
|
|
|
|
if (realIntPin == 0) return 4;
|
|
else return realIntPin;
|
|
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardDebugLedNumGet - Get number of debug Leds
|
|
*
|
|
* DESCRIPTION:
|
|
* INPUT:
|
|
* boardId
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* None.
|
|
*
|
|
*******************************************************************************/
|
|
MV_U32 mvBoardDebugLedNumGet(MV_U32 boardId)
|
|
{
|
|
return BOARD_INFO(boardId)->activeLedsNumber;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardDebugLeg - Set the board debug Leds
|
|
*
|
|
* DESCRIPTION: turn on/off status leds.
|
|
* Note: assume MPP leds are part of group 0 only.
|
|
*
|
|
* INPUT:
|
|
* hexNum - Number to be displied in hex by Leds.
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* None.
|
|
*
|
|
*******************************************************************************/
|
|
MV_VOID mvBoardDebugLed(MV_U32 hexNum)
|
|
{
|
|
MV_U32 val = 0,totalMask, currentBitMask = 1,i;
|
|
MV_U32 boardId= mvBoardIdGet();
|
|
|
|
if (BOARD_INFO(boardId)->pLedGppPin == NULL)
|
|
return;
|
|
|
|
totalMask = (1 << BOARD_INFO(boardId)->activeLedsNumber) -1;
|
|
hexNum &= totalMask;
|
|
totalMask = 0;
|
|
|
|
for (i = 0 ; i < BOARD_INFO(boardId)->activeLedsNumber ; i++)
|
|
{
|
|
if (hexNum & currentBitMask)
|
|
{
|
|
val |= (1 << BOARD_INFO(boardId)->pLedGppPin[i]);
|
|
}
|
|
|
|
totalMask |= (1 << BOARD_INFO(boardId)->pLedGppPin[i]);
|
|
|
|
currentBitMask = (currentBitMask << 1);
|
|
}
|
|
|
|
if (BOARD_INFO(boardId)->ledsPolarity)
|
|
{
|
|
mvGppValueSet(0, totalMask, val);
|
|
}
|
|
else
|
|
{
|
|
mvGppValueSet(0, totalMask, ~val);
|
|
}
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* mvBoarGpioPinGet - mvBoarGpioPinGet
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
* class - MV_BOARD_GPP_CLASS enum.
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* GPIO pin number. The function return -1 for bad parameters.
|
|
*
|
|
*******************************************************************************/
|
|
MV_32 mvBoarGpioPinNumGet(MV_BOARD_GPP_CLASS class, MV_U32 index)
|
|
{
|
|
MV_U32 boardId, i;
|
|
MV_U32 indexFound = 0;
|
|
|
|
boardId = mvBoardIdGet();
|
|
|
|
if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
|
|
{
|
|
mvOsPrintf("mvBoardRTCGpioPinGet:Board unknown.\n");
|
|
return MV_ERROR;
|
|
|
|
}
|
|
|
|
for (i = 0; i < BOARD_INFO(boardId)->numBoardGppInfo; i++)
|
|
if (BOARD_INFO(boardId)->pBoardGppInfo[i].devClass == class) {
|
|
if (indexFound == index)
|
|
return (MV_U32)BOARD_INFO(boardId)->pBoardGppInfo[i].gppPinNum;
|
|
else
|
|
indexFound++;
|
|
|
|
}
|
|
|
|
return MV_ERROR;
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* mvBoardRTCGpioPinGet - mvBoardRTCGpioPinGet
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
* None.
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* GPIO pin number. The function return -1 for bad parameters.
|
|
*
|
|
*******************************************************************************/
|
|
MV_32 mvBoardRTCGpioPinGet(MV_VOID)
|
|
{
|
|
return mvBoarGpioPinNumGet(BOARD_GPP_RTC, 0);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* mvBoardReset - mvBoardReset
|
|
*
|
|
* DESCRIPTION:
|
|
* Reset the board
|
|
* INPUT:
|
|
* None.
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* None
|
|
*
|
|
*******************************************************************************/
|
|
MV_VOID mvBoardReset(MV_VOID)
|
|
{
|
|
MV_32 resetPin;
|
|
|
|
/* Get gpp reset pin if define */
|
|
resetPin = mvBoardResetGpioPinGet();
|
|
if (resetPin != MV_ERROR)
|
|
{
|
|
MV_REG_BIT_RESET( GPP_DATA_OUT_REG(0) ,(1 << resetPin));
|
|
MV_REG_BIT_RESET( GPP_DATA_OUT_EN_REG(0) ,(1 << resetPin));
|
|
|
|
}
|
|
else
|
|
{
|
|
/* No gpp reset pin was found, try to reset ussing
|
|
system reset out */
|
|
MV_REG_BIT_SET( CPU_RSTOUTN_MASK_REG , BIT2);
|
|
MV_REG_BIT_SET( CPU_SYS_SOFT_RST_REG , BIT0);
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardResetGpioPinGet - mvBoardResetGpioPinGet
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
* None.
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* GPIO pin number. The function return -1 for bad parameters.
|
|
*
|
|
*******************************************************************************/
|
|
MV_32 mvBoardResetGpioPinGet(MV_VOID)
|
|
{
|
|
return mvBoarGpioPinNumGet(BOARD_GPP_RESET, 0);
|
|
}
|
|
/*******************************************************************************
|
|
* mvBoardSDIOGpioPinGet - mvBoardSDIOGpioPinGet
|
|
*
|
|
* DESCRIPTION:
|
|
* used for hotswap detection
|
|
* INPUT:
|
|
* None.
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* GPIO pin number. The function return -1 for bad parameters.
|
|
*
|
|
*******************************************************************************/
|
|
MV_32 mvBoardSDIOGpioPinGet(MV_VOID)
|
|
{
|
|
return mvBoarGpioPinNumGet(BOARD_GPP_SDIO_DETECT, 0);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardUSBVbusGpioPinGet - return Vbus input GPP
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
* int devNo.
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* GPIO pin number. The function return -1 for bad parameters.
|
|
*
|
|
*******************************************************************************/
|
|
MV_32 mvBoardUSBVbusGpioPinGet(MV_32 devId)
|
|
{
|
|
return mvBoarGpioPinNumGet(BOARD_GPP_USB_VBUS, devId);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardUSBVbusEnGpioPinGet - return Vbus Enable output GPP
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
* int devNo.
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* GPIO pin number. The function return -1 for bad parameters.
|
|
*
|
|
*******************************************************************************/
|
|
MV_32 mvBoardUSBVbusEnGpioPinGet(MV_32 devId)
|
|
{
|
|
return mvBoarGpioPinNumGet(BOARD_GPP_USB_VBUS_EN, devId);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* mvBoardGpioIntMaskGet - Get GPIO mask for interrupt pins
|
|
*
|
|
* DESCRIPTION:
|
|
* This function returns a 32-bit mask of GPP pins that connected to
|
|
* interrupt generating sources on board.
|
|
* For example if UART channel A is hardwired to GPP pin 8 and
|
|
* UART channel B is hardwired to GPP pin 4 the fuinction will return
|
|
* the value 0x000000110
|
|
*
|
|
* INPUT:
|
|
* None.
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* See description. The function return -1 if board is not identified.
|
|
*
|
|
*******************************************************************************/
|
|
MV_32 mvBoardGpioIntMaskLowGet(MV_VOID)
|
|
{
|
|
MV_U32 boardId;
|
|
|
|
boardId = mvBoardIdGet();
|
|
|
|
if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
|
|
{
|
|
mvOsPrintf("mvBoardGpioIntMaskGet:Board unknown.\n");
|
|
return MV_ERROR;
|
|
|
|
}
|
|
|
|
return BOARD_INFO(boardId)->intsGppMaskLow;
|
|
}
|
|
MV_32 mvBoardGpioIntMaskHighGet(MV_VOID)
|
|
{
|
|
MV_U32 boardId;
|
|
|
|
boardId = mvBoardIdGet();
|
|
|
|
if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
|
|
{
|
|
mvOsPrintf("mvBoardGpioIntMaskGet:Board unknown.\n");
|
|
return MV_ERROR;
|
|
|
|
}
|
|
|
|
return BOARD_INFO(boardId)->intsGppMaskHigh;
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* mvBoardMppGet - Get board dependent MPP register value
|
|
*
|
|
* DESCRIPTION:
|
|
* MPP settings are derived from board design.
|
|
* MPP group consist of 8 MPPs. An MPP group represent MPP
|
|
* control register.
|
|
* This function retrieves board dependend MPP register value.
|
|
*
|
|
* INPUT:
|
|
* mppGroupNum - MPP group number.
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* 32bit value describing MPP control register value.
|
|
*
|
|
*******************************************************************************/
|
|
MV_32 mvBoardMppGet(MV_U32 mppGroupNum)
|
|
{
|
|
MV_U32 boardId;
|
|
|
|
boardId = mvBoardIdGet();
|
|
|
|
if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
|
|
{
|
|
mvOsPrintf("mvBoardMppGet:Board unknown.\n");
|
|
return MV_ERROR;
|
|
|
|
}
|
|
|
|
return BOARD_INFO(boardId)->pBoardMppConfigValue[0].mppGroup[mppGroupNum];
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* mvBoardMppGroupId - If MPP group type is AUTO then identify it using twsi
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
*
|
|
*******************************************************************************/
|
|
MV_VOID mvBoardMppGroupIdUpdate(MV_VOID)
|
|
{
|
|
|
|
MV_BOARD_MPP_GROUP_CLASS devClass;
|
|
MV_BOARD_MODULE_ID_CLASS devClassId;
|
|
MV_BOARD_MPP_TYPE_CLASS mppGroupType;
|
|
MV_U32 devId;
|
|
MV_U32 maxMppGrp = 1;
|
|
|
|
devId = mvCtrlModelGet();
|
|
|
|
switch(devId){
|
|
case MV_6281_DEV_ID:
|
|
maxMppGrp = MV_6281_MPP_MAX_MODULE;
|
|
break;
|
|
case MV_6192_DEV_ID:
|
|
maxMppGrp = MV_6192_MPP_MAX_MODULE;
|
|
break;
|
|
case MV_6190_DEV_ID:
|
|
maxMppGrp = MV_6190_MPP_MAX_MODULE;
|
|
break;
|
|
case MV_6180_DEV_ID:
|
|
maxMppGrp = MV_6180_MPP_MAX_MODULE;
|
|
break;
|
|
}
|
|
|
|
for (devClass = 0; devClass < maxMppGrp; devClass++)
|
|
{
|
|
/* If MPP group can be defined by the module connected to it */
|
|
if (mvBoardMppGroupTypeGet(devClass) == MV_BOARD_AUTO)
|
|
{
|
|
/* Get MPP module ID */
|
|
devClassId = mvBoarModuleTypeGet(devClass);
|
|
if (MV_ERROR != devClassId)
|
|
{
|
|
switch(devClassId)
|
|
{
|
|
case MV_BOARD_MODULE_TDM_ID:
|
|
case MV_BOARD_MODULE_TDM_5CHAN_ID:
|
|
mppGroupType = MV_BOARD_TDM;
|
|
break;
|
|
case MV_BOARD_MODULE_AUDIO_ID:
|
|
mppGroupType = MV_BOARD_AUDIO;
|
|
break;
|
|
case MV_BOARD_MODULE_RGMII_ID:
|
|
mppGroupType = MV_BOARD_RGMII;
|
|
break;
|
|
case MV_BOARD_MODULE_GMII_ID:
|
|
mppGroupType = MV_BOARD_GMII;
|
|
break;
|
|
case MV_BOARD_MODULE_TS_ID:
|
|
mppGroupType = MV_BOARD_TS;
|
|
break;
|
|
case MV_BOARD_MODULE_MII_ID:
|
|
mppGroupType = MV_BOARD_MII;
|
|
break;
|
|
default:
|
|
mppGroupType = MV_BOARD_OTHER;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
/* The module bay is empty */
|
|
mppGroupType = MV_BOARD_OTHER;
|
|
|
|
/* Update MPP group type */
|
|
mvBoardMppGroupTypeSet(devClass, mppGroupType);
|
|
}
|
|
|
|
/* Update MPP output voltage for RGMII 1.8V. Set port to GMII for GMII module */
|
|
if ((mvBoardMppGroupTypeGet(devClass) == MV_BOARD_RGMII))
|
|
MV_REG_BIT_SET(MPP_OUTPUT_DRIVE_REG,MPP_1_8_RGMII1_OUTPUT_DRIVE | MPP_1_8_RGMII0_OUTPUT_DRIVE);
|
|
else
|
|
{
|
|
if ((mvBoardMppGroupTypeGet(devClass) == MV_BOARD_GMII))
|
|
{
|
|
MV_REG_BIT_RESET(MPP_OUTPUT_DRIVE_REG, BIT7 | BIT15);
|
|
MV_REG_BIT_RESET(ETH_PORT_SERIAL_CTRL_1_REG(0),BIT3);
|
|
MV_REG_BIT_RESET(ETH_PORT_SERIAL_CTRL_1_REG(1),BIT3);
|
|
}
|
|
else if ((mvBoardMppGroupTypeGet(devClass) == MV_BOARD_MII))
|
|
{
|
|
/* Assumption that the MDC & MDIO should be 3.3V */
|
|
MV_REG_BIT_RESET(MPP_OUTPUT_DRIVE_REG, BIT7 | BIT15);
|
|
/* Assumption that only ETH1 can be MII when using modules on DB */
|
|
MV_REG_BIT_RESET(ETH_PORT_SERIAL_CTRL_1_REG(1),BIT3);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardMppGroupTypeGet
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
* mppGroupClass - MPP group number 0 for MPP[35:20] or 1 for MPP[49:36].
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
*
|
|
*******************************************************************************/
|
|
MV_BOARD_MPP_TYPE_CLASS mvBoardMppGroupTypeGet(MV_BOARD_MPP_GROUP_CLASS mppGroupClass)
|
|
{
|
|
MV_U32 boardId;
|
|
|
|
boardId = mvBoardIdGet();
|
|
|
|
if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
|
|
{
|
|
mvOsPrintf("mvBoardMppGet:Board unknown.\n");
|
|
return MV_ERROR;
|
|
|
|
}
|
|
|
|
if (mppGroupClass == MV_BOARD_MPP_GROUP_1)
|
|
return BOARD_INFO(boardId)->pBoardMppTypeValue[0].boardMppGroup1;
|
|
else
|
|
return BOARD_INFO(boardId)->pBoardMppTypeValue[0].boardMppGroup2;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardMppGroupTypeSet
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
* mppGroupClass - MPP group number 0 for MPP[35:20] or 1 for MPP[49:36].
|
|
* mppGroupType - MPP group type for MPP[35:20] or for MPP[49:36].
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
*
|
|
*******************************************************************************/
|
|
MV_VOID mvBoardMppGroupTypeSet(MV_BOARD_MPP_GROUP_CLASS mppGroupClass,
|
|
MV_BOARD_MPP_TYPE_CLASS mppGroupType)
|
|
{
|
|
MV_U32 boardId;
|
|
|
|
boardId = mvBoardIdGet();
|
|
|
|
if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
|
|
{
|
|
mvOsPrintf("mvBoardMppGet:Board unknown.\n");
|
|
}
|
|
|
|
if (mppGroupClass == MV_BOARD_MPP_GROUP_1)
|
|
BOARD_INFO(boardId)->pBoardMppTypeValue[0].boardMppGroup1 = mppGroupType;
|
|
else
|
|
BOARD_INFO(boardId)->pBoardMppTypeValue[0].boardMppGroup2 = mppGroupType;
|
|
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardMppMuxSet - Update MPP mux
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
*
|
|
*******************************************************************************/
|
|
MV_VOID mvBoardMppMuxSet(MV_VOID)
|
|
{
|
|
|
|
MV_BOARD_MPP_GROUP_CLASS devClass;
|
|
MV_BOARD_MPP_TYPE_CLASS mppGroupType;
|
|
MV_U32 devId;
|
|
MV_U8 muxVal = 0xf;
|
|
MV_U32 maxMppGrp = 1;
|
|
MV_TWSI_SLAVE twsiSlave;
|
|
MV_TWSI_ADDR slave;
|
|
|
|
devId = mvCtrlModelGet();
|
|
|
|
switch(devId){
|
|
case MV_6281_DEV_ID:
|
|
maxMppGrp = MV_6281_MPP_MAX_MODULE;
|
|
break;
|
|
case MV_6192_DEV_ID:
|
|
maxMppGrp = MV_6192_MPP_MAX_MODULE;
|
|
break;
|
|
case MV_6190_DEV_ID:
|
|
maxMppGrp = MV_6190_MPP_MAX_MODULE;
|
|
break;
|
|
case MV_6180_DEV_ID:
|
|
maxMppGrp = MV_6180_MPP_MAX_MODULE;
|
|
break;
|
|
}
|
|
|
|
for (devClass = 0; devClass < maxMppGrp; devClass++)
|
|
{
|
|
mppGroupType = mvBoardMppGroupTypeGet(devClass);
|
|
|
|
switch(mppGroupType)
|
|
{
|
|
case MV_BOARD_TDM:
|
|
muxVal &= ~(devClass ? (0x2 << (devClass * 2)):0x0);
|
|
break;
|
|
case MV_BOARD_AUDIO:
|
|
muxVal &= ~(devClass ? 0x7 : 0x0); /*old Z0 value 0xd:0x0*/
|
|
break;
|
|
case MV_BOARD_TS:
|
|
muxVal &= ~(devClass ? (0x2 << (devClass * 2)):0x0);
|
|
break;
|
|
default:
|
|
muxVal |= (devClass ? 0xf : 0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* TWSI init */
|
|
slave.type = ADDR7_BIT;
|
|
slave.address = 0;
|
|
mvTwsiInit(0, TWSI_SPEED, mvBoardTclkGet(), &slave, 0);
|
|
|
|
/* Read MPP module ID */
|
|
DB(mvOsPrintf("Board: twsi exp set\n"));
|
|
twsiSlave.slaveAddr.address = mvBoardTwsiExpAddrGet(MV_BOARD_MUX_I2C_ADDR_ENTRY);
|
|
twsiSlave.slaveAddr.type = mvBoardTwsiExpAddrTypeGet(MV_BOARD_MUX_I2C_ADDR_ENTRY);
|
|
twsiSlave.validOffset = MV_TRUE;
|
|
/* Offset is the first command after the address which indicate the register number to be read
|
|
in next operation */
|
|
twsiSlave.offset = 2;
|
|
twsiSlave.moreThen256 = MV_FALSE;
|
|
|
|
|
|
|
|
if( MV_OK != mvTwsiWrite (0, &twsiSlave, &muxVal, 1) )
|
|
{
|
|
DB(mvOsPrintf("Board: twsi exp out val fail\n"));
|
|
return;
|
|
}
|
|
DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
|
|
|
|
/* Change twsi exp to output */
|
|
twsiSlave.offset = 6;
|
|
muxVal = 0;
|
|
if( MV_OK != mvTwsiWrite (0, &twsiSlave, &muxVal, 1) )
|
|
{
|
|
DB(mvOsPrintf("Board: twsi exp change to out fail\n"));
|
|
return;
|
|
}
|
|
DB(mvOsPrintf("Board: twsi exp change to out succeded\n"));
|
|
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardTdmMppSet - set MPPs in TDM module
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT: type of second telephony device
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
*
|
|
*******************************************************************************/
|
|
MV_VOID mvBoardTdmMppSet(MV_32 chType)
|
|
{
|
|
|
|
MV_BOARD_MPP_GROUP_CLASS devClass;
|
|
MV_BOARD_MPP_TYPE_CLASS mppGroupType;
|
|
MV_U32 devId;
|
|
MV_U8 muxVal = 1;
|
|
MV_U8 muxValMask = 1;
|
|
MV_U8 twsiVal;
|
|
MV_U32 maxMppGrp = 1;
|
|
MV_TWSI_SLAVE twsiSlave;
|
|
MV_TWSI_ADDR slave;
|
|
|
|
devId = mvCtrlModelGet();
|
|
|
|
switch(devId){
|
|
case MV_6281_DEV_ID:
|
|
maxMppGrp = MV_6281_MPP_MAX_MODULE;
|
|
break;
|
|
case MV_6192_DEV_ID:
|
|
maxMppGrp = MV_6192_MPP_MAX_MODULE;
|
|
break;
|
|
case MV_6190_DEV_ID:
|
|
maxMppGrp = MV_6190_MPP_MAX_MODULE;
|
|
break;
|
|
case MV_6180_DEV_ID:
|
|
maxMppGrp = MV_6180_MPP_MAX_MODULE;
|
|
break;
|
|
}
|
|
|
|
for (devClass = 0; devClass < maxMppGrp; devClass++)
|
|
{
|
|
mppGroupType = mvBoardMppGroupTypeGet(devClass);
|
|
if(mppGroupType == MV_BOARD_TDM)
|
|
break;
|
|
}
|
|
|
|
if(devClass == maxMppGrp)
|
|
return; /* TDM module not found */
|
|
|
|
/* TWSI init */
|
|
slave.type = ADDR7_BIT;
|
|
slave.address = 0;
|
|
mvTwsiInit(0, TWSI_SPEED, mvBoardTclkGet(), &slave, 0);
|
|
|
|
/* Read MPP module ID */
|
|
DB(mvOsPrintf("Board: twsi exp set\n"));
|
|
twsiSlave.slaveAddr.address = mvBoardTwsiExpAddrGet(devClass);
|
|
twsiSlave.slaveAddr.type = ADDR7_BIT;
|
|
twsiSlave.validOffset = MV_TRUE;
|
|
/* Offset is the first command after the address which indicate the register number to be read
|
|
in next operation */
|
|
twsiSlave.offset = 3;
|
|
twsiSlave.moreThen256 = MV_FALSE;
|
|
|
|
if(mvBoardIdGet() == RD_88F6281A_ID)
|
|
{
|
|
muxVal = 0xc;
|
|
muxValMask = 0xf3;
|
|
}
|
|
|
|
mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
|
|
muxVal = (twsiVal & muxValMask) | muxVal;
|
|
|
|
if( MV_OK != mvTwsiWrite (0, &twsiSlave, &muxVal, 1) )
|
|
{
|
|
mvOsPrintf("Board: twsi exp out val fail\n");
|
|
return;
|
|
}
|
|
DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
|
|
|
|
/* Change twsi exp to output */
|
|
twsiSlave.offset = 7;
|
|
muxVal = 0xfe;
|
|
if(mvBoardIdGet() == RD_88F6281A_ID)
|
|
muxVal = 0xf3;
|
|
|
|
mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
|
|
muxVal = (twsiVal & muxVal);
|
|
|
|
if( MV_OK != mvTwsiWrite (0, &twsiSlave, &muxVal, 1) )
|
|
{
|
|
mvOsPrintf("Board: twsi exp change to out fail\n");
|
|
return;
|
|
}
|
|
DB(mvOsPrintf("Board: twsi exp change to out succeded\n"));
|
|
/* reset the line to 0 */
|
|
twsiSlave.offset = 3;
|
|
muxVal = 0;
|
|
muxValMask = 1;
|
|
|
|
if(mvBoardIdGet() == RD_88F6281A_ID) {
|
|
muxVal = 0x0;
|
|
muxValMask = 0xf3;
|
|
}
|
|
|
|
mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
|
|
muxVal = (twsiVal & muxValMask) | muxVal;
|
|
|
|
if( MV_OK != mvTwsiWrite (0, &twsiSlave, &muxVal, 1) )
|
|
{
|
|
mvOsPrintf("Board: twsi exp out val fail\n");
|
|
return;
|
|
}
|
|
DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
|
|
|
|
mvOsDelay(20);
|
|
|
|
/* set the line to 1 */
|
|
twsiSlave.offset = 3;
|
|
muxVal = 1;
|
|
muxValMask = 1;
|
|
|
|
if(mvBoardIdGet() == RD_88F6281A_ID)
|
|
{
|
|
muxVal = 0xc;
|
|
muxValMask = 0xf3;
|
|
if(chType) /* FXS - issue reset properly */
|
|
{
|
|
MV_REG_BIT_SET(GPP_DATA_OUT_REG(1), MV_GPP12);
|
|
mvOsDelay(50);
|
|
MV_REG_BIT_RESET(GPP_DATA_OUT_REG(1), MV_GPP12);
|
|
}
|
|
else /* FXO - issue reset via TDM_CODEC_RST*/
|
|
{
|
|
/* change MPP44 type to TDM_CODEC_RST(0x2) */
|
|
MV_REG_WRITE(MPP_CONTROL_REG5, ((MV_REG_READ(MPP_CONTROL_REG5) & 0xFFF0FFFF) | BIT17));
|
|
}
|
|
}
|
|
|
|
mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
|
|
muxVal = (twsiVal & muxValMask) | muxVal;
|
|
|
|
if( MV_OK != mvTwsiWrite (0, &twsiSlave, &muxVal, 1) )
|
|
{
|
|
mvOsPrintf("Board: twsi exp out val fail\n");
|
|
return;
|
|
}
|
|
|
|
/* TBD - 5 channels */
|
|
#if defined(MV_TDM_5CHANNELS)
|
|
/* change MPP38 type to GPIO(0x0) & polarity for TDM_STROBE */
|
|
MV_REG_WRITE(MPP_CONTROL_REG4, (MV_REG_READ(MPP_CONTROL_REG4) & 0xF0FFFFFF));
|
|
mvGppPolaritySet(1, MV_GPP6, 0);
|
|
|
|
twsiSlave.offset = 6;
|
|
twsiSlave.slaveAddr.address = mvBoardTwsiExpAddrGet(2);
|
|
|
|
mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
|
|
muxVal = (twsiVal & ~BIT2);
|
|
|
|
if( MV_OK != mvTwsiWrite (0, &twsiSlave, &muxVal, 1) )
|
|
{
|
|
mvOsPrintf("Board: twsi exp change to out fail\n");
|
|
return;
|
|
}
|
|
|
|
|
|
twsiSlave.offset = 2;
|
|
|
|
mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
|
|
muxVal = (twsiVal & ~BIT2);
|
|
|
|
if( MV_OK != mvTwsiWrite (0, &twsiSlave, &muxVal, 1) )
|
|
{
|
|
mvOsPrintf("Board: twsi exp change to out fail\n");
|
|
return;
|
|
}
|
|
#endif
|
|
DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
|
|
|
|
|
|
}
|
|
/*******************************************************************************
|
|
* mvBoardVoiceConnModeGet - return SLIC/DAA connection & interrupt modes
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
MV_VOID mvBoardVoiceConnModeGet(MV_32* connMode, MV_32* irqMode)
|
|
{
|
|
switch(mvBoardIdGet())
|
|
{
|
|
case RD_88F6281A_ID:
|
|
*connMode = DAISY_CHAIN_MODE;
|
|
*irqMode = INTERRUPT_TO_TDM;
|
|
break;
|
|
case DB_88F6281A_BP_ID:
|
|
*connMode = DUAL_CHIP_SELECT_MODE;
|
|
*irqMode = INTERRUPT_TO_TDM;
|
|
break;
|
|
case RD_88F6192A_ID:
|
|
*connMode = DUAL_CHIP_SELECT_MODE;
|
|
*irqMode = INTERRUPT_TO_TDM;
|
|
break;
|
|
case DB_88F6192A_BP_ID:
|
|
*connMode = DUAL_CHIP_SELECT_MODE;
|
|
*irqMode = INTERRUPT_TO_TDM;
|
|
break;
|
|
default:
|
|
*connMode = *irqMode = -1;
|
|
mvOsPrintf("mvBoardVoiceAssembleModeGet: TDM not supported(boardId=0x%x)\n",mvBoardIdGet());
|
|
}
|
|
return;
|
|
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardMppModuleTypePrint - print module detect
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
*
|
|
*******************************************************************************/
|
|
MV_VOID mvBoardMppModuleTypePrint(MV_VOID)
|
|
{
|
|
|
|
MV_BOARD_MPP_GROUP_CLASS devClass;
|
|
MV_BOARD_MPP_TYPE_CLASS mppGroupType;
|
|
MV_U32 devId;
|
|
MV_U32 maxMppGrp = 1;
|
|
|
|
devId = mvCtrlModelGet();
|
|
|
|
switch(devId){
|
|
case MV_6281_DEV_ID:
|
|
maxMppGrp = MV_6281_MPP_MAX_MODULE;
|
|
break;
|
|
case MV_6192_DEV_ID:
|
|
maxMppGrp = MV_6192_MPP_MAX_MODULE;
|
|
break;
|
|
case MV_6190_DEV_ID:
|
|
maxMppGrp = MV_6190_MPP_MAX_MODULE;
|
|
break;
|
|
case MV_6180_DEV_ID:
|
|
maxMppGrp = MV_6180_MPP_MAX_MODULE;
|
|
break;
|
|
}
|
|
|
|
for (devClass = 0; devClass < maxMppGrp; devClass++)
|
|
{
|
|
mppGroupType = mvBoardMppGroupTypeGet(devClass);
|
|
|
|
switch(mppGroupType)
|
|
{
|
|
case MV_BOARD_TDM:
|
|
if(devId != MV_6190_DEV_ID)
|
|
mvOsPrintf("Module %d is TDM\n", devClass);
|
|
break;
|
|
case MV_BOARD_AUDIO:
|
|
if(devId != MV_6190_DEV_ID)
|
|
mvOsPrintf("Module %d is AUDIO\n", devClass);
|
|
break;
|
|
case MV_BOARD_RGMII:
|
|
if(devId != MV_6190_DEV_ID)
|
|
mvOsPrintf("Module %d is RGMII\n", devClass);
|
|
break;
|
|
case MV_BOARD_GMII:
|
|
if(devId != MV_6190_DEV_ID)
|
|
mvOsPrintf("Module %d is GMII\n", devClass);
|
|
break;
|
|
case MV_BOARD_TS:
|
|
if(devId != MV_6190_DEV_ID)
|
|
mvOsPrintf("Module %d is TS\n", devClass);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Board devices API managments */
|
|
|
|
/*******************************************************************************
|
|
* mvBoardGetDeviceNumber - Get number of device of some type on the board
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
* devType - The device type ( Flash,RTC , etc .. )
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* If the device is found on the board the then the functions returns the
|
|
* number of those devices else the function returns 0
|
|
*
|
|
*
|
|
*******************************************************************************/
|
|
MV_32 mvBoardGetDevicesNumber(MV_BOARD_DEV_CLASS devClass)
|
|
{
|
|
MV_U32 foundIndex=0,devNum;
|
|
MV_U32 boardId= mvBoardIdGet();
|
|
|
|
if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
|
|
{
|
|
mvOsPrintf("mvBoardGetDeviceNumber:Board unknown.\n");
|
|
return 0xFFFFFFFF;
|
|
|
|
}
|
|
|
|
for (devNum = START_DEV_CS; devNum < BOARD_INFO(boardId)->numBoardDeviceIf; devNum++)
|
|
{
|
|
if (BOARD_INFO(boardId)->pDevCsInfo[devNum].devClass == devClass)
|
|
{
|
|
foundIndex++;
|
|
}
|
|
}
|
|
|
|
return foundIndex;
|
|
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardGetDeviceBaseAddr - Get base address of a device existing on the board
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
* devIndex - The device sequential number on the board
|
|
* devType - The device type ( Flash,RTC , etc .. )
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* If the device is found on the board the then the functions returns the
|
|
* Base address else the function returns 0xffffffff
|
|
*
|
|
*
|
|
*******************************************************************************/
|
|
MV_32 mvBoardGetDeviceBaseAddr(MV_32 devNum, MV_BOARD_DEV_CLASS devClass)
|
|
{
|
|
MV_DEV_CS_INFO* devEntry;
|
|
devEntry = boardGetDevEntry(devNum,devClass);
|
|
if (devEntry != NULL)
|
|
{
|
|
return mvCpuIfTargetWinBaseLowGet(DEV_TO_TARGET(devEntry->deviceCS));
|
|
|
|
}
|
|
|
|
return 0xFFFFFFFF;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardGetDeviceBusWidth - Get Bus width of a device existing on the board
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
* devIndex - The device sequential number on the board
|
|
* devType - The device type ( Flash,RTC , etc .. )
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* If the device is found on the board the then the functions returns the
|
|
* Bus width else the function returns 0xffffffff
|
|
*
|
|
*
|
|
*******************************************************************************/
|
|
MV_32 mvBoardGetDeviceBusWidth(MV_32 devNum, MV_BOARD_DEV_CLASS devClass)
|
|
{
|
|
MV_DEV_CS_INFO* devEntry;
|
|
|
|
devEntry = boardGetDevEntry(devNum,devClass);
|
|
if (devEntry != NULL)
|
|
{
|
|
return 8;
|
|
}
|
|
|
|
return 0xFFFFFFFF;
|
|
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardGetDeviceWidth - Get dev width of a device existing on the board
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
* devIndex - The device sequential number on the board
|
|
* devType - The device type ( Flash,RTC , etc .. )
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* If the device is found on the board the then the functions returns the
|
|
* dev width else the function returns 0xffffffff
|
|
*
|
|
*
|
|
*******************************************************************************/
|
|
MV_32 mvBoardGetDeviceWidth(MV_32 devNum, MV_BOARD_DEV_CLASS devClass)
|
|
{
|
|
MV_DEV_CS_INFO* devEntry;
|
|
MV_U32 boardId= mvBoardIdGet();
|
|
|
|
if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
|
|
{
|
|
mvOsPrintf("Board unknown.\n");
|
|
return 0xFFFFFFFF;
|
|
}
|
|
|
|
devEntry = boardGetDevEntry(devNum,devClass);
|
|
if (devEntry != NULL)
|
|
return devEntry->devWidth;
|
|
|
|
return MV_ERROR;
|
|
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardGetDeviceWinSize - Get the window size of a device existing on the board
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
* devIndex - The device sequential number on the board
|
|
* devType - The device type ( Flash,RTC , etc .. )
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* If the device is found on the board the then the functions returns the
|
|
* window size else the function returns 0xffffffff
|
|
*
|
|
*
|
|
*******************************************************************************/
|
|
MV_32 mvBoardGetDeviceWinSize(MV_32 devNum, MV_BOARD_DEV_CLASS devClass)
|
|
{
|
|
MV_DEV_CS_INFO* devEntry;
|
|
MV_U32 boardId = mvBoardIdGet();
|
|
|
|
if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
|
|
{
|
|
mvOsPrintf("Board unknown.\n");
|
|
return 0xFFFFFFFF;
|
|
}
|
|
|
|
devEntry = boardGetDevEntry(devNum,devClass);
|
|
if (devEntry != NULL)
|
|
{
|
|
return mvCpuIfTargetWinSizeGet(DEV_TO_TARGET(devEntry->deviceCS));
|
|
}
|
|
|
|
return 0xFFFFFFFF;
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* boardGetDevEntry - returns the entry pointer of a device on the board
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
* devIndex - The device sequential number on the board
|
|
* devType - The device type ( Flash,RTC , etc .. )
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* If the device is found on the board the then the functions returns the
|
|
* dev number else the function returns 0x0
|
|
*
|
|
*
|
|
*******************************************************************************/
|
|
static MV_DEV_CS_INFO* boardGetDevEntry(MV_32 devNum, MV_BOARD_DEV_CLASS devClass)
|
|
{
|
|
MV_U32 foundIndex=0,devIndex;
|
|
MV_U32 boardId= mvBoardIdGet();
|
|
|
|
if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
|
|
{
|
|
mvOsPrintf("boardGetDevEntry: Board unknown.\n");
|
|
return NULL;
|
|
|
|
}
|
|
|
|
for (devIndex = START_DEV_CS; devIndex < BOARD_INFO(boardId)->numBoardDeviceIf; devIndex++)
|
|
{
|
|
/* TBR */
|
|
/*if (BOARD_INFO(boardId)->pDevCsInfo[devIndex].deviceCS == MV_BOOTDEVICE_INDEX)
|
|
continue;*/
|
|
|
|
if (BOARD_INFO(boardId)->pDevCsInfo[devIndex].devClass == devClass)
|
|
{
|
|
if (foundIndex == devNum)
|
|
{
|
|
return &(BOARD_INFO(boardId)->pDevCsInfo[devIndex]);
|
|
}
|
|
foundIndex++;
|
|
}
|
|
}
|
|
|
|
/* device not found */
|
|
return NULL;
|
|
}
|
|
|
|
/* Get device CS number */
|
|
|
|
MV_U32 boardGetDevCSNum(MV_32 devNum, MV_BOARD_DEV_CLASS devClass)
|
|
{
|
|
MV_DEV_CS_INFO* devEntry;
|
|
MV_U32 boardId= mvBoardIdGet();
|
|
|
|
if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
|
|
{
|
|
mvOsPrintf("Board unknown.\n");
|
|
return 0xFFFFFFFF;
|
|
|
|
}
|
|
|
|
|
|
devEntry = boardGetDevEntry(devNum,devClass);
|
|
if (devEntry != NULL)
|
|
return devEntry->deviceCS;
|
|
|
|
return 0xFFFFFFFF;
|
|
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardRtcTwsiAddrTypeGet -
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
*
|
|
*
|
|
*******************************************************************************/
|
|
MV_U8 mvBoardRtcTwsiAddrTypeGet()
|
|
{
|
|
int i;
|
|
MV_U32 boardId= mvBoardIdGet();
|
|
|
|
for (i = 0; i < BOARD_INFO(boardId)->numBoardTwsiDev; i++)
|
|
if (BOARD_INFO(boardId)->pBoardTwsiDev[i].devClass == BOARD_TWSI_RTC)
|
|
return BOARD_INFO(boardId)->pBoardTwsiDev[i].twsiDevAddrType;
|
|
return (MV_ERROR);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardRtcTwsiAddrGet -
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
*
|
|
*
|
|
*******************************************************************************/
|
|
MV_U8 mvBoardRtcTwsiAddrGet()
|
|
{
|
|
int i;
|
|
MV_U32 boardId= mvBoardIdGet();
|
|
|
|
for (i = 0; i < BOARD_INFO(boardId)->numBoardTwsiDev; i++)
|
|
if (BOARD_INFO(boardId)->pBoardTwsiDev[i].devClass == BOARD_TWSI_RTC)
|
|
return BOARD_INFO(boardId)->pBoardTwsiDev[i].twsiDevAddr;
|
|
return (0xFF);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardA2DTwsiAddrTypeGet -
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
*
|
|
*
|
|
*******************************************************************************/
|
|
MV_U8 mvBoardA2DTwsiAddrTypeGet()
|
|
{
|
|
int i;
|
|
MV_U32 boardId= mvBoardIdGet();
|
|
|
|
for (i = 0; i < BOARD_INFO(boardId)->numBoardTwsiDev; i++)
|
|
if (BOARD_INFO(boardId)->pBoardTwsiDev[i].devClass == BOARD_TWSI_AUDIO_DEC)
|
|
return BOARD_INFO(boardId)->pBoardTwsiDev[i].twsiDevAddrType;
|
|
return (MV_ERROR);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardA2DTwsiAddrGet -
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
*
|
|
*
|
|
*******************************************************************************/
|
|
MV_U8 mvBoardA2DTwsiAddrGet()
|
|
{
|
|
int i;
|
|
MV_U32 boardId= mvBoardIdGet();
|
|
|
|
for (i = 0; i < BOARD_INFO(boardId)->numBoardTwsiDev; i++)
|
|
if (BOARD_INFO(boardId)->pBoardTwsiDev[i].devClass == BOARD_TWSI_AUDIO_DEC)
|
|
return BOARD_INFO(boardId)->pBoardTwsiDev[i].twsiDevAddr;
|
|
return (0xFF);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardTwsiExpAddrTypeGet -
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
*
|
|
*
|
|
*******************************************************************************/
|
|
MV_U8 mvBoardTwsiExpAddrTypeGet(MV_U32 index)
|
|
{
|
|
int i;
|
|
MV_U32 indexFound = 0;
|
|
MV_U32 boardId= mvBoardIdGet();
|
|
|
|
for (i = 0; i < BOARD_INFO(boardId)->numBoardTwsiDev; i++)
|
|
if (BOARD_INFO(boardId)->pBoardTwsiDev[i].devClass == BOARD_DEV_TWSI_EXP)
|
|
{
|
|
if (indexFound == index)
|
|
return BOARD_INFO(boardId)->pBoardTwsiDev[i].twsiDevAddrType;
|
|
else
|
|
indexFound++;
|
|
}
|
|
|
|
return (MV_ERROR);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardTwsiExpAddrGet -
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
*
|
|
*
|
|
*******************************************************************************/
|
|
MV_U8 mvBoardTwsiExpAddrGet(MV_U32 index)
|
|
{
|
|
int i;
|
|
MV_U32 indexFound = 0;
|
|
MV_U32 boardId= mvBoardIdGet();
|
|
|
|
for (i = 0; i < BOARD_INFO(boardId)->numBoardTwsiDev; i++)
|
|
if (BOARD_INFO(boardId)->pBoardTwsiDev[i].devClass == BOARD_DEV_TWSI_EXP)
|
|
{
|
|
if (indexFound == index)
|
|
return BOARD_INFO(boardId)->pBoardTwsiDev[i].twsiDevAddr;
|
|
else
|
|
indexFound++;
|
|
}
|
|
|
|
return (0xFF);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* mvBoardTwsiSatRAddrTypeGet -
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
*
|
|
*
|
|
*******************************************************************************/
|
|
MV_U8 mvBoardTwsiSatRAddrTypeGet(MV_U32 index)
|
|
{
|
|
int i;
|
|
MV_U32 indexFound = 0;
|
|
MV_U32 boardId= mvBoardIdGet();
|
|
|
|
for (i = 0; i < BOARD_INFO(boardId)->numBoardTwsiDev; i++)
|
|
if (BOARD_INFO(boardId)->pBoardTwsiDev[i].devClass == BOARD_DEV_TWSI_SATR)
|
|
{
|
|
if (indexFound == index)
|
|
return BOARD_INFO(boardId)->pBoardTwsiDev[i].twsiDevAddrType;
|
|
else
|
|
indexFound++;
|
|
}
|
|
|
|
return (MV_ERROR);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardTwsiSatRAddrGet -
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
*
|
|
*
|
|
*******************************************************************************/
|
|
MV_U8 mvBoardTwsiSatRAddrGet(MV_U32 index)
|
|
{
|
|
int i;
|
|
MV_U32 indexFound = 0;
|
|
MV_U32 boardId= mvBoardIdGet();
|
|
|
|
for (i = 0; i < BOARD_INFO(boardId)->numBoardTwsiDev; i++)
|
|
if (BOARD_INFO(boardId)->pBoardTwsiDev[i].devClass == BOARD_DEV_TWSI_SATR)
|
|
{
|
|
if (indexFound == index)
|
|
return BOARD_INFO(boardId)->pBoardTwsiDev[i].twsiDevAddr;
|
|
else
|
|
indexFound++;
|
|
}
|
|
|
|
return (0xFF);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardNandWidthGet -
|
|
*
|
|
* DESCRIPTION: Get the width of the first NAND device in byte.
|
|
*
|
|
* INPUT:
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN: 1, 2, 4 or MV_ERROR
|
|
*
|
|
*
|
|
*******************************************************************************/
|
|
/* */
|
|
MV_32 mvBoardNandWidthGet(void)
|
|
{
|
|
MV_U32 devNum;
|
|
MV_U32 devWidth;
|
|
MV_U32 boardId= mvBoardIdGet();
|
|
|
|
for (devNum = START_DEV_CS; devNum < BOARD_INFO(boardId)->numBoardDeviceIf; devNum++)
|
|
{
|
|
devWidth = mvBoardGetDeviceWidth(devNum, BOARD_DEV_NAND_FLASH);
|
|
if (devWidth != MV_ERROR)
|
|
return (devWidth / 8);
|
|
}
|
|
|
|
/* NAND wasn't found */
|
|
return MV_ERROR;
|
|
}
|
|
|
|
MV_U32 gBoardId = -1;
|
|
|
|
/*******************************************************************************
|
|
* mvBoardIdGet - Get Board model
|
|
*
|
|
* DESCRIPTION:
|
|
* This function returns board ID.
|
|
* Board ID is 32bit word constructed of board model (16bit) and
|
|
* board revision (16bit) in the following way: 0xMMMMRRRR.
|
|
*
|
|
* INPUT:
|
|
* None.
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* 32bit board ID number, '-1' if board is undefined.
|
|
*
|
|
*******************************************************************************/
|
|
MV_U32 mvBoardIdGet(MV_VOID)
|
|
{
|
|
MV_U32 tmpBoardId = -1;
|
|
|
|
if(gBoardId == -1)
|
|
{
|
|
#if defined(DB_88F6281A)
|
|
tmpBoardId = DB_88F6281A_BP_ID;
|
|
#elif defined(RD_88F6281A)
|
|
tmpBoardId = RD_88F6281A_ID;
|
|
#elif defined(DB_88F6192A)
|
|
tmpBoardId = DB_88F6192A_BP_ID;
|
|
#elif defined(DB_88F6190A)
|
|
tmpBoardId = DB_88F6190A_BP_ID;
|
|
#elif defined(RD_88F6192A)
|
|
tmpBoardId = RD_88F6192A_ID;
|
|
#elif defined(RD_88F6190A)
|
|
tmpBoardId = RD_88F6190A_ID;
|
|
#elif defined(DB_88F6180A)
|
|
tmpBoardId = DB_88F6180A_BP_ID;
|
|
#elif defined(RD_88F6281A_PCAC)
|
|
tmpBoardId = RD_88F6281A_PCAC_ID;
|
|
#elif defined(RD_88F6281A_SHEEVA_PLUG)
|
|
tmpBoardId = SHEEVA_PLUG_ID;
|
|
#elif defined(DB_CUSTOMER)
|
|
tmpBoardId = DB_CUSTOMER_ID;
|
|
#endif
|
|
gBoardId = tmpBoardId;
|
|
}
|
|
|
|
return gBoardId;
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
* mvBoarModuleTypeGet - mvBoarModuleTypeGet
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
* group num - MV_BOARD_MPP_GROUP_CLASS enum
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* module num - MV_BOARD_MODULE_CLASS enum
|
|
*
|
|
*******************************************************************************/
|
|
MV_BOARD_MODULE_ID_CLASS mvBoarModuleTypeGet(MV_BOARD_MPP_GROUP_CLASS devClass)
|
|
{
|
|
MV_TWSI_SLAVE twsiSlave;
|
|
MV_TWSI_ADDR slave;
|
|
MV_U8 data;
|
|
|
|
/* TWSI init */
|
|
slave.type = ADDR7_BIT;
|
|
slave.address = 0;
|
|
mvTwsiInit(0, TWSI_SPEED, mvBoardTclkGet(), &slave, 0);
|
|
|
|
/* Read MPP module ID */
|
|
DB(mvOsPrintf("Board: Read MPP module ID\n"));
|
|
twsiSlave.slaveAddr.address = mvBoardTwsiExpAddrGet(devClass);
|
|
twsiSlave.slaveAddr.type = mvBoardTwsiExpAddrTypeGet(devClass);
|
|
twsiSlave.validOffset = MV_TRUE;
|
|
/* Offset is the first command after the address which indicate the register number to be read
|
|
in next operation */
|
|
twsiSlave.offset = 0;
|
|
twsiSlave.moreThen256 = MV_FALSE;
|
|
|
|
|
|
|
|
if( MV_OK != mvTwsiRead (0, &twsiSlave, &data, 1) )
|
|
{
|
|
DB(mvOsPrintf("Board: Read MPP module ID fail\n"));
|
|
return MV_ERROR;
|
|
}
|
|
DB(mvOsPrintf("Board: Read MPP module ID succeded\n"));
|
|
|
|
return data;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoarTwsiSatRGet -
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
* device num - one of three devices
|
|
* reg num - 0 or 1
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* reg value
|
|
*
|
|
*******************************************************************************/
|
|
MV_U8 mvBoarTwsiSatRGet(MV_U8 devNum, MV_U8 regNum)
|
|
{
|
|
MV_TWSI_SLAVE twsiSlave;
|
|
MV_TWSI_ADDR slave;
|
|
MV_U8 data;
|
|
|
|
/* TWSI init */
|
|
slave.type = ADDR7_BIT;
|
|
slave.address = 0;
|
|
mvTwsiInit(0, TWSI_SPEED, mvBoardTclkGet(), &slave, 0);
|
|
|
|
/* Read MPP module ID */
|
|
DB(mvOsPrintf("Board: Read S@R device read\n"));
|
|
twsiSlave.slaveAddr.address = mvBoardTwsiSatRAddrGet(devNum);
|
|
twsiSlave.slaveAddr.type = mvBoardTwsiSatRAddrTypeGet(devNum);
|
|
twsiSlave.validOffset = MV_TRUE;
|
|
/* Use offset as command */
|
|
twsiSlave.offset = regNum;
|
|
twsiSlave.moreThen256 = MV_FALSE;
|
|
|
|
if( MV_OK != mvTwsiRead (0, &twsiSlave, &data, 1) )
|
|
{
|
|
DB(mvOsPrintf("Board: Read S@R fail\n"));
|
|
return MV_ERROR;
|
|
}
|
|
DB(mvOsPrintf("Board: Read S@R succeded\n"));
|
|
|
|
return data;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoarTwsiSatRSet -
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
* devNum - one of three devices
|
|
* regNum - 0 or 1
|
|
* regVal - value
|
|
*
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
* reg value
|
|
*
|
|
*******************************************************************************/
|
|
MV_STATUS mvBoarTwsiSatRSet(MV_U8 devNum, MV_U8 regNum, MV_U8 regVal)
|
|
{
|
|
MV_TWSI_SLAVE twsiSlave;
|
|
MV_TWSI_ADDR slave;
|
|
|
|
/* TWSI init */
|
|
slave.type = ADDR7_BIT;
|
|
slave.address = 0;
|
|
mvTwsiInit(0, TWSI_SPEED, mvBoardTclkGet(), &slave, 0);
|
|
|
|
/* Read MPP module ID */
|
|
twsiSlave.slaveAddr.address = mvBoardTwsiSatRAddrGet(devNum);
|
|
twsiSlave.slaveAddr.type = mvBoardTwsiSatRAddrTypeGet(devNum);
|
|
twsiSlave.validOffset = MV_TRUE;
|
|
DB(mvOsPrintf("Board: Write S@R device addr %x, type %x, data %x\n", twsiSlave.slaveAddr.address,\
|
|
twsiSlave.slaveAddr.type, regVal));
|
|
/* Use offset as command */
|
|
twsiSlave.offset = regNum;
|
|
twsiSlave.moreThen256 = MV_FALSE;
|
|
if( MV_OK != mvTwsiWrite (0, &twsiSlave, ®Val, 1) )
|
|
{
|
|
DB(mvOsPrintf("Board: Write S@R fail\n"));
|
|
return MV_ERROR;
|
|
}
|
|
DB(mvOsPrintf("Board: Write S@R succeded\n"));
|
|
|
|
return MV_OK;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardSlicGpioPinGet -
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
*
|
|
* OUTPUT:
|
|
* None.
|
|
*
|
|
* RETURN:
|
|
*
|
|
*
|
|
*******************************************************************************/
|
|
MV_32 mvBoardSlicGpioPinGet(MV_U32 slicNum)
|
|
{
|
|
MV_U32 boardId;
|
|
boardId = mvBoardIdGet();
|
|
|
|
switch (boardId)
|
|
{
|
|
case DB_88F6281A_BP_ID:
|
|
case RD_88F6281A_ID:
|
|
default:
|
|
return MV_ERROR;
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardFanPowerControl - Turn on/off the fan power control on the RD-6281A
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
* mode - MV_TRUE = on ; MV_FALSE = off
|
|
*
|
|
* OUTPUT:
|
|
* MV_STATUS - MV_OK , MV_ERROR.
|
|
*
|
|
* RETURN:
|
|
*
|
|
*******************************************************************************/
|
|
MV_STATUS mvBoardFanPowerControl(MV_BOOL mode)
|
|
{
|
|
|
|
MV_U8 val = 1, twsiVal;
|
|
MV_TWSI_SLAVE twsiSlave;
|
|
MV_TWSI_ADDR slave;
|
|
|
|
if(mvBoardIdGet() != RD_88F6281A_ID)
|
|
return MV_ERROR;
|
|
|
|
/* TWSI init */
|
|
slave.type = ADDR7_BIT;
|
|
slave.address = 0;
|
|
mvTwsiInit(0, TWSI_SPEED, mvBoardTclkGet(), &slave, 0);
|
|
|
|
/* Read MPP module ID */
|
|
DB(mvOsPrintf("Board: twsi exp set\n"));
|
|
twsiSlave.slaveAddr.address = mvBoardTwsiExpAddrGet(1);
|
|
twsiSlave.slaveAddr.type = ADDR7_BIT;
|
|
twsiSlave.validOffset = MV_TRUE;
|
|
/* Offset is the first command after the address which indicate the register number to be read
|
|
in next operation */
|
|
twsiSlave.offset = 3;
|
|
twsiSlave.moreThen256 = MV_FALSE;
|
|
if(mode == MV_TRUE)
|
|
val = 0x1;
|
|
else
|
|
val = 0;
|
|
mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
|
|
val = (twsiVal & 0xfe) | val;
|
|
|
|
if( MV_OK != mvTwsiWrite (0, &twsiSlave, &val, 1) )
|
|
{
|
|
DB(mvOsPrintf("Board: twsi exp out val fail\n"));
|
|
return MV_ERROR;
|
|
}
|
|
DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
|
|
|
|
/* Change twsi exp to output */
|
|
twsiSlave.offset = 7;
|
|
mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
|
|
val = (twsiVal & 0xfe);
|
|
if( MV_OK != mvTwsiWrite (0, &twsiSlave, &val, 1) )
|
|
{
|
|
DB(mvOsPrintf("Board: twsi exp change to out fail\n"));
|
|
return MV_ERROR;
|
|
}
|
|
DB(mvOsPrintf("Board: twsi exp change to out succeded\n"));
|
|
return MV_OK;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardHDDPowerControl - Turn on/off the HDD power control on the RD-6281A
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
* mode - MV_TRUE = on ; MV_FALSE = off
|
|
*
|
|
* OUTPUT:
|
|
* MV_STATUS - MV_OK , MV_ERROR.
|
|
*
|
|
* RETURN:
|
|
*
|
|
*******************************************************************************/
|
|
MV_STATUS mvBoardHDDPowerControl(MV_BOOL mode)
|
|
{
|
|
|
|
MV_U8 val = 1, twsiVal;
|
|
MV_TWSI_SLAVE twsiSlave;
|
|
MV_TWSI_ADDR slave;
|
|
|
|
if(mvBoardIdGet() != RD_88F6281A_ID)
|
|
return MV_ERROR;
|
|
|
|
/* TWSI init */
|
|
slave.type = ADDR7_BIT;
|
|
slave.address = 0;
|
|
mvTwsiInit(0, TWSI_SPEED, mvBoardTclkGet(), &slave, 0);
|
|
|
|
/* Read MPP module ID */
|
|
DB(mvOsPrintf("Board: twsi exp set\n"));
|
|
twsiSlave.slaveAddr.address = mvBoardTwsiExpAddrGet(1);
|
|
twsiSlave.slaveAddr.type = ADDR7_BIT;
|
|
twsiSlave.validOffset = MV_TRUE;
|
|
/* Offset is the first command after the address which indicate the register number to be read
|
|
in next operation */
|
|
twsiSlave.offset = 3;
|
|
twsiSlave.moreThen256 = MV_FALSE;
|
|
if(mode == MV_TRUE)
|
|
val = 0x2;
|
|
else
|
|
val = 0;
|
|
mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
|
|
val = (twsiVal & 0xfd) | val;
|
|
if( MV_OK != mvTwsiWrite (0, &twsiSlave, &val, 1) )
|
|
{
|
|
DB(mvOsPrintf("Board: twsi exp out val fail\n"));
|
|
return MV_ERROR;
|
|
}
|
|
DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
|
|
|
|
/* Change twsi exp to output */
|
|
twsiSlave.offset = 7;
|
|
mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
|
|
val = (twsiVal & 0xfd);
|
|
if( MV_OK != mvTwsiWrite (0, &twsiSlave, &val, 1) )
|
|
{
|
|
DB(mvOsPrintf("Board: twsi exp change to out fail\n"));
|
|
return MV_ERROR;
|
|
}
|
|
DB(mvOsPrintf("Board: twsi exp change to out succeded\n"));
|
|
return MV_OK;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
* mvBoardSDioWPControl - Turn on/off the SDIO WP on the RD-6281A
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* INPUT:
|
|
* mode - MV_TRUE = on ; MV_FALSE = off
|
|
*
|
|
* OUTPUT:
|
|
* MV_STATUS - MV_OK , MV_ERROR.
|
|
*
|
|
* RETURN:
|
|
*
|
|
*******************************************************************************/
|
|
MV_STATUS mvBoardSDioWPControl(MV_BOOL mode)
|
|
{
|
|
|
|
MV_U8 val = 1, twsiVal;
|
|
MV_TWSI_SLAVE twsiSlave;
|
|
MV_TWSI_ADDR slave;
|
|
|
|
if(mvBoardIdGet() != RD_88F6281A_ID)
|
|
return MV_ERROR;
|
|
|
|
/* TWSI init */
|
|
slave.type = ADDR7_BIT;
|
|
slave.address = 0;
|
|
mvTwsiInit(0, TWSI_SPEED, mvBoardTclkGet(), &slave, 0);
|
|
|
|
/* Read MPP module ID */
|
|
DB(mvOsPrintf("Board: twsi exp set\n"));
|
|
twsiSlave.slaveAddr.address = mvBoardTwsiExpAddrGet(0);
|
|
twsiSlave.slaveAddr.type = ADDR7_BIT;
|
|
twsiSlave.validOffset = MV_TRUE;
|
|
/* Offset is the first command after the address which indicate the register number to be read
|
|
in next operation */
|
|
twsiSlave.offset = 3;
|
|
twsiSlave.moreThen256 = MV_FALSE;
|
|
if(mode == MV_TRUE)
|
|
val = 0x10;
|
|
else
|
|
val = 0;
|
|
mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
|
|
val = (twsiVal & 0xef) | val;
|
|
if( MV_OK != mvTwsiWrite (0, &twsiSlave, &val, 1) )
|
|
{
|
|
DB(mvOsPrintf("Board: twsi exp out val fail\n"));
|
|
return MV_ERROR;
|
|
}
|
|
DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
|
|
|
|
/* Change twsi exp to output */
|
|
twsiSlave.offset = 7;
|
|
mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
|
|
val = (twsiVal & 0xef);
|
|
if( MV_OK != mvTwsiWrite (0, &twsiSlave, &val, 1) )
|
|
{
|
|
DB(mvOsPrintf("Board: twsi exp change to out fail\n"));
|
|
return MV_ERROR;
|
|
}
|
|
DB(mvOsPrintf("Board: twsi exp change to out succeded\n"));
|
|
return MV_OK;
|
|
}
|
|
|