1 /*******************************************************************************
2 Copyright (C) Marvell International Ltd. and its affiliates
4 This software file (the "File") is owned and distributed by Marvell
5 International Ltd. and/or its affiliates ("Marvell") under the following
6 alternative licensing terms. Once you have made an election to distribute the
7 File under one of the following license alternatives, please (i) delete this
8 introductory statement regarding license alternatives, (ii) delete the two
9 license alternatives that you have not elected to use and (iii) preserve the
10 Marvell copyright notice above.
12 ********************************************************************************
13 Marvell Commercial License Option
15 If you received this File from Marvell and you have entered into a commercial
16 license agreement (a "Commercial License") with Marvell, the File is licensed
17 to you under the terms of the applicable Commercial License.
19 ********************************************************************************
20 Marvell GPL License Option
22 If you received this File from Marvell, you may opt to use, redistribute and/or
23 modify this File in accordance with the terms and conditions of the General
24 Public License Version 2, June 1991 (the "GPL License"), a copy of which is
25 available along with the File in the license.txt file or by writing to the Free
26 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 or
27 on the worldwide web at http://www.gnu.org/licenses/gpl.txt.
29 THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE IMPLIED
30 WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY
31 DISCLAIMED. The GPL License provides additional details about this warranty
33 ********************************************************************************
34 Marvell BSD License Option
36 If you received this File from Marvell, you may opt to use, redistribute and/or
37 modify this File under the following licensing terms.
38 Redistribution and use in source and binary forms, with or without modification,
39 are permitted provided that the following conditions are met:
41 * Redistributions of source code must retain the above copyright notice,
42 this list of conditions and the following disclaimer.
44 * Redistributions in binary form must reproduce the above copyright
45 notice, this list of conditions and the following disclaimer in the
46 documentation and/or other materials provided with the distribution.
48 * Neither the name of Marvell nor the names of its contributors may be
49 used to endorse or promote products derived from this software without
50 specific prior written permission.
52 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
53 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
54 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
55 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
56 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
57 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
58 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
59 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
60 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
61 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
63 *******************************************************************************/
65 #include "boardEnv/mvBoardEnvLib.h"
66 #include "ctrlEnv/mvCtrlEnvLib.h"
67 #include "ctrlEnv/sys/mvCpuIf.h"
68 #include "cpu/mvCpu.h"
69 #include "cntmr/mvCntmr.h"
70 #include "gpp/mvGpp.h"
71 #include "twsi/mvTwsi.h"
72 #include "pex/mvPex.h"
73 #include "device/mvDevice.h"
74 #include "eth/gbe/mvEthRegs.h"
77 /* #define MV_DEBUG */
84 extern MV_CPU_ARM_CLK _cpuARMDDRCLK
[];
86 #define CODE_IN_ROM MV_FALSE
87 #define CODE_IN_RAM MV_TRUE
89 extern MV_BOARD_INFO
* boardInfoTbl
[];
90 #define BOARD_INFO(boardId) boardInfoTbl[boardId - BOARD_ID_BASE]
93 static MV_DEV_CS_INFO
* boardGetDevEntry(MV_32 devNum
, MV_BOARD_DEV_CLASS devClass
);
98 /*******************************************************************************
99 * mvBoardEnvInit - Init board
102 * In this function the board environment take care of device bank
114 *******************************************************************************/
115 MV_VOID
mvBoardEnvInit(MV_VOID
)
117 MV_U32 boardId
= mvBoardIdGet();
119 if (!((boardId
>= BOARD_ID_BASE
)&&(boardId
< MV_MAX_BOARD_ID
)))
121 mvOsPrintf("mvBoardEnvInit:Board unknown.\n");
126 /* Set GPP Out value */
127 MV_REG_WRITE(GPP_DATA_OUT_REG(0), BOARD_INFO(boardId
)->gppOutValLow
);
128 MV_REG_WRITE(GPP_DATA_OUT_REG(1), BOARD_INFO(boardId
)->gppOutValHigh
);
130 /* set GPP polarity */
131 mvGppPolaritySet(0, 0xFFFFFFFF, BOARD_INFO(boardId
)->gppPolarityValLow
);
132 mvGppPolaritySet(1, 0xFFFFFFFF, BOARD_INFO(boardId
)->gppPolarityValHigh
);
134 /* Workaround for Erratum FE-MISC-70*/
135 if(mvCtrlRevGet()==MV_88F6XXX_A0_REV
)
137 BOARD_INFO(boardId
)->gppOutEnValLow
&= 0xfffffffd;
138 BOARD_INFO(boardId
)->gppOutEnValLow
|= (BOARD_INFO(boardId
)->gppOutEnValHigh
) & 0x00000002;
141 /* Set GPP Out Enable*/
142 mvGppTypeSet(0, 0xFFFFFFFF, BOARD_INFO(boardId
)->gppOutEnValLow
);
143 mvGppTypeSet(1, 0xFFFFFFFF, BOARD_INFO(boardId
)->gppOutEnValHigh
);
146 MV_REG_BIT_SET(NAND_CTRL_REG
, NAND_ACTCEBOOT_BIT
);
149 /*******************************************************************************
150 * mvBoardModelGet - Get Board model
153 * This function returns 16bit describing board model.
154 * Board model is constructed of one byte major and minor numbers in the
164 * String describing board model.
166 *******************************************************************************/
167 MV_U16
mvBoardModelGet(MV_VOID
)
169 return (mvBoardIdGet() >> 16);
172 /*******************************************************************************
173 * mbBoardRevlGet - Get Board revision
176 * This function returns a 32bit describing the board revision.
177 * Board revision is constructed of 4bytes. 2bytes describes major number
178 * and the other 2bytes describes minor munber.
179 * For example for board revision 3.4 the function will return
189 * String describing board model.
191 *******************************************************************************/
192 MV_U16
mvBoardRevGet(MV_VOID
)
194 return (mvBoardIdGet() & 0xFFFF);
197 /*******************************************************************************
198 * mvBoardNameGet - Get Board name
201 * This function returns a string describing the board model and revision.
202 * String is extracted from board I2C EEPROM.
208 * pNameBuff - Buffer to contain board name string. Minimum size 32 chars.
212 * MV_ERROR if informantion can not be read.
213 *******************************************************************************/
214 MV_STATUS
mvBoardNameGet(char *pNameBuff
)
216 MV_U32 boardId
= mvBoardIdGet();
218 if (!((boardId
>= BOARD_ID_BASE
)&&(boardId
< MV_MAX_BOARD_ID
)))
220 mvOsSPrintf (pNameBuff
, "Board unknown.\n");
225 mvOsSPrintf (pNameBuff
, "%s",BOARD_INFO(boardId
)->boardName
);
230 /*******************************************************************************
231 * mvBoardIsPortInSgmii -
234 * This routine returns MV_TRUE for port number works in SGMII or MV_FALSE
235 * For all other options.
238 * ethPortNum - Ethernet port number.
244 * MV_TRUE - port in SGMII.
247 *******************************************************************************/
248 MV_BOOL
mvBoardIsPortInSgmii(MV_U32 ethPortNum
)
250 MV_BOOL ethPortSgmiiSupport
[BOARD_ETH_PORT_NUM
] = MV_ETH_PORT_SGMII
;
252 if(ethPortNum
>= BOARD_ETH_PORT_NUM
)
254 mvOsPrintf ("Invalid portNo=%d\n", ethPortNum
);
257 return ethPortSgmiiSupport
[ethPortNum
];
260 /*******************************************************************************
261 * mvBoardIsPortInGmii -
264 * This routine returns MV_TRUE for port number works in GMII or MV_FALSE
265 * For all other options.
273 * MV_TRUE - port in GMII.
276 *******************************************************************************/
277 MV_BOOL
mvBoardIsPortInGmii(MV_VOID
)
279 MV_U32 devClassId
, devClass
= 0;
280 if (mvBoardMppGroupTypeGet(devClass
) == MV_BOARD_AUTO
)
282 /* Get MPP module ID */
283 devClassId
= mvBoarModuleTypeGet(devClass
);
284 if (MV_BOARD_MODULE_GMII_ID
== devClassId
)
287 else if (mvBoardMppGroupTypeGet(devClass
) == MV_BOARD_GMII
)
292 /*******************************************************************************
293 * mvBoardPhyAddrGet - Get the phy address
296 * This routine returns the Phy address of a given ethernet port.
299 * ethPortNum - Ethernet port number.
305 * 32bit describing Phy address, -1 if the port number is wrong.
307 *******************************************************************************/
308 MV_32
mvBoardPhyAddrGet(MV_U32 ethPortNum
)
310 MV_U32 boardId
= mvBoardIdGet();
312 if (!((boardId
>= BOARD_ID_BASE
)&&(boardId
< MV_MAX_BOARD_ID
)))
314 mvOsPrintf("mvBoardPhyAddrGet: Board unknown.\n");
318 return BOARD_INFO(boardId
)->pBoardMacInfo
[ethPortNum
].boardEthSmiAddr
;
321 /*******************************************************************************
322 * mvBoardMacSpeedGet - Get the Mac speed
325 * This routine returns the Mac speed if pre define of a given ethernet port.
328 * ethPortNum - Ethernet port number.
334 * MV_BOARD_MAC_SPEED, -1 if the port number is wrong.
336 *******************************************************************************/
337 MV_BOARD_MAC_SPEED
mvBoardMacSpeedGet(MV_U32 ethPortNum
)
339 MV_U32 boardId
= mvBoardIdGet();
341 if (!((boardId
>= BOARD_ID_BASE
)&&(boardId
< MV_MAX_BOARD_ID
)))
343 mvOsPrintf("mvBoardMacSpeedGet: Board unknown.\n");
347 return BOARD_INFO(boardId
)->pBoardMacInfo
[ethPortNum
].boardMacSpeed
;
350 /*******************************************************************************
351 * mvBoardLinkStatusIrqGet - Get the IRQ number for the link status indication
354 * This routine returns the IRQ number for the link status indication.
357 * ethPortNum - Ethernet port number.
363 * the number of the IRQ for the link status indication, -1 if the port
364 * number is wrong or if not relevant.
366 *******************************************************************************/
367 MV_32
mvBoardLinkStatusIrqGet(MV_U32 ethPortNum
)
369 MV_U32 boardId
= mvBoardIdGet();
371 if (!((boardId
>= BOARD_ID_BASE
)&&(boardId
< MV_MAX_BOARD_ID
)))
373 mvOsPrintf("mvBoardLinkStatusIrqGet: Board unknown.\n");
377 return BOARD_INFO(boardId
)->pSwitchInfo
[ethPortNum
].linkStatusIrq
;
380 /*******************************************************************************
381 * mvBoardSwitchPortGet - Get the mapping between the board connector and the
382 * Ethernet Switch port
385 * This routine returns the matching Switch port.
388 * ethPortNum - Ethernet port number.
389 * boardPortNum - logical number of the connector on the board
395 * the matching Switch port, -1 if the port number is wrong or if not relevant.
397 *******************************************************************************/
398 MV_32
mvBoardSwitchPortGet(MV_U32 ethPortNum
, MV_U8 boardPortNum
)
400 MV_U32 boardId
= mvBoardIdGet();
402 if (!((boardId
>= BOARD_ID_BASE
)&&(boardId
< MV_MAX_BOARD_ID
)))
404 mvOsPrintf("mvBoardSwitchPortGet: Board unknown.\n");
407 if (boardPortNum
>= BOARD_ETH_SWITCH_PORT_NUM
)
409 mvOsPrintf("mvBoardSwitchPortGet: Illegal board port number.\n");
413 return BOARD_INFO(boardId
)->pSwitchInfo
[ethPortNum
].qdPort
[boardPortNum
];
416 /*******************************************************************************
417 * mvBoardSwitchCpuPortGet - Get the the Ethernet Switch CPU port
420 * This routine returns the Switch CPU port.
423 * ethPortNum - Ethernet port number.
429 * the Switch CPU port, -1 if the port number is wrong or if not relevant.
431 *******************************************************************************/
432 MV_32
mvBoardSwitchCpuPortGet(MV_U32 ethPortNum
)
434 MV_U32 boardId
= mvBoardIdGet();
436 if (!((boardId
>= BOARD_ID_BASE
)&&(boardId
< MV_MAX_BOARD_ID
)))
438 mvOsPrintf("mvBoardSwitchCpuPortGet: Board unknown.\n");
442 return BOARD_INFO(boardId
)->pSwitchInfo
[ethPortNum
].qdCpuPort
;
445 /*******************************************************************************
446 * mvBoardIsSwitchConnected - Get switch connection status
448 * This routine returns port's connection status
451 * ethPortNum - Ethernet port number.
457 * 1 - if ethPortNum is connected to switch, 0 otherwise
459 *******************************************************************************/
460 MV_32
mvBoardIsSwitchConnected(MV_U32 ethPortNum
)
462 MV_U32 boardId
= mvBoardIdGet();
464 if (!((boardId
>= BOARD_ID_BASE
)&&(boardId
< MV_MAX_BOARD_ID
)))
466 mvOsPrintf("mvBoardIsSwitchConnected: Board unknown.\n");
470 if(ethPortNum
>= BOARD_INFO(boardId
)->numBoardMacInfo
)
472 mvOsPrintf("mvBoardIsSwitchConnected: Illegal port number(%u)\n", ethPortNum
);
476 if((MV_32
)(BOARD_INFO(boardId
)->pSwitchInfo
))
477 return (MV_32
)(BOARD_INFO(boardId
)->pSwitchInfo
[ethPortNum
].switchOnPort
== ethPortNum
);
481 /*******************************************************************************
482 * mvBoardSmiScanModeGet - Get Switch SMI scan mode
485 * This routine returns Switch SMI scan mode.
488 * ethPortNum - Ethernet port number.
494 * 1 for SMI_MANUAL_MODE, -1 if the port number is wrong or if not relevant.
496 *******************************************************************************/
497 MV_32
mvBoardSmiScanModeGet(MV_U32 ethPortNum
)
499 MV_U32 boardId
= mvBoardIdGet();
501 if (!((boardId
>= BOARD_ID_BASE
)&&(boardId
< MV_MAX_BOARD_ID
)))
503 mvOsPrintf("mvBoardSmiScanModeGet: Board unknown.\n");
507 return BOARD_INFO(boardId
)->pSwitchInfo
[ethPortNum
].smiScanMode
;
509 /*******************************************************************************
510 * mvBoardSpecInitGet -
519 * RETURN: Return MV_TRUE and parameters in case board need spesific phy init,
520 * otherwise return MV_FALSE.
523 *******************************************************************************/
525 MV_BOOL
mvBoardSpecInitGet(MV_U32
* regOff
, MV_U32
* data
)
530 /*******************************************************************************
531 * mvBoardTclkGet - Get the board Tclk (Controller clock)
534 * This routine extract the controller core clock.
535 * This function uses the controller counters to make identification.
536 * Note: In order to avoid interference, make sure task context switch
537 * and interrupts will not occure during this function operation
540 * countNum - Counter number.
546 * 32bit clock cycles in Hertz.
548 *******************************************************************************/
549 MV_U32
mvBoardTclkGet(MV_VOID
)
551 if(mvCtrlModelGet()==MV_6281_DEV_ID
)
553 #if defined(TCLK_AUTO_DETECT)
554 MV_U32 tmpTClkRate
= MV_BOARD_TCLK_166MHZ
;
556 tmpTClkRate
= MV_REG_READ(MPP_SAMPLE_AT_RESET
);
557 tmpTClkRate
&= MSAR_TCLCK_MASK
;
562 return MV_BOARD_TCLK_166MHZ
;
565 return MV_BOARD_TCLK_200MHZ
;
569 return MV_BOARD_TCLK_200MHZ
;
573 return MV_BOARD_TCLK_166MHZ
;
576 /*******************************************************************************
577 * mvBoardSysClkGet - Get the board SysClk (CPU bus clock)
580 * This routine extract the CPU bus clock.
583 * countNum - Counter number.
589 * 32bit clock cycles in Hertz.
591 *******************************************************************************/
592 static MV_U32
mvBoard6180SysClkGet(MV_VOID
)
595 MV_CPU_ARM_CLK _cpu6180_ddr_l2_CLK
[] = MV_CPU6180_DDR_L2_CLCK_TBL
;
597 sysClkRate
= MV_REG_READ(MPP_SAMPLE_AT_RESET
);
598 sysClkRate
= sysClkRate
& MSAR_CPUCLCK_MASK_6180
;
599 sysClkRate
= sysClkRate
>> MSAR_CPUCLCK_OFFS_6180
;
601 sysClkRate
= _cpu6180_ddr_l2_CLK
[sysClkRate
].ddrClk
;
607 MV_U32
mvBoardSysClkGet(MV_VOID
)
609 #ifdef SYSCLK_AUTO_DETECT
610 MV_U32 sysClkRate
, tmp
, pClkRate
, indexDdrRtio
;
611 MV_U32 cpuCLK
[] = MV_CPU_CLCK_TBL
;
612 MV_U32 ddrRtio
[][2] = MV_DDR_CLCK_RTIO_TBL
;
614 if(mvCtrlModelGet() == MV_6180_DEV_ID
)
615 return mvBoard6180SysClkGet();
617 tmp
= MV_REG_READ(MPP_SAMPLE_AT_RESET
);
618 pClkRate
= MSAR_CPUCLCK_EXTRACT(tmp
);
619 pClkRate
= cpuCLK
[pClkRate
];
621 indexDdrRtio
= tmp
& MSAR_DDRCLCK_RTIO_MASK
;
622 indexDdrRtio
= indexDdrRtio
>> MSAR_DDRCLCK_RTIO_OFFS
;
623 if(ddrRtio
[indexDdrRtio
][0] != 0)
624 sysClkRate
= ((pClkRate
* ddrRtio
[indexDdrRtio
][1]) / ddrRtio
[indexDdrRtio
][0]);
629 return MV_BOARD_DEFAULT_SYSCLK
;
634 /*******************************************************************************
635 * mvBoardPexBridgeIntPinGet - Get PEX to PCI bridge interrupt pin number
638 * Multi-ported PCI Express bridges that is implemented on the board
639 * collapse interrupts across multiple conventional PCI/PCI-X buses.
640 * A dual-headed PCI Express bridge would map (or "swizzle") the
641 * interrupts per the following table (in accordance with the respective
642 * logical PCI/PCI-X bridge's Device Number), collapse the INTA#-INTD#
643 * signals from its two logical PCI/PCI-X bridges, collapse the
644 * INTA#-INTD# signals from any internal sources, and convert the
645 * signals to in-band PCI Express messages. 10
646 * This function returns the upstream interrupt as it was converted by
647 * the bridge, according to board configuration and the following table:
649 * Interrupt pin 7, 8, 9
657 * devNum - PCI/PCIX device number.
658 * intPin - PCI Int pin
664 * Int pin connected to the Interrupt controller
666 *******************************************************************************/
667 MV_U32
mvBoardPexBridgeIntPinGet(MV_U32 devNum
, MV_U32 intPin
)
669 MV_U32 realIntPin
= ((intPin
+ (3 - (devNum
% 4))) %4 );
671 if (realIntPin
== 0) return 4;
672 else return realIntPin
;
676 /*******************************************************************************
677 * mvBoardDebugLedNumGet - Get number of debug Leds
689 *******************************************************************************/
690 MV_U32
mvBoardDebugLedNumGet(MV_U32 boardId
)
692 return BOARD_INFO(boardId
)->activeLedsNumber
;
695 /*******************************************************************************
696 * mvBoardDebugLeg - Set the board debug Leds
698 * DESCRIPTION: turn on/off status leds.
699 * Note: assume MPP leds are part of group 0 only.
702 * hexNum - Number to be displied in hex by Leds.
710 *******************************************************************************/
711 MV_VOID
mvBoardDebugLed(MV_U32 hexNum
)
713 MV_U32 val
= 0,totalMask
, currentBitMask
= 1,i
;
714 MV_U32 boardId
= mvBoardIdGet();
716 if (BOARD_INFO(boardId
)->pLedGppPin
== NULL
)
719 totalMask
= (1 << BOARD_INFO(boardId
)->activeLedsNumber
) -1;
723 for (i
= 0 ; i
< BOARD_INFO(boardId
)->activeLedsNumber
; i
++)
725 if (hexNum
& currentBitMask
)
727 val
|= (1 << BOARD_INFO(boardId
)->pLedGppPin
[i
]);
730 totalMask
|= (1 << BOARD_INFO(boardId
)->pLedGppPin
[i
]);
732 currentBitMask
= (currentBitMask
<< 1);
735 if (BOARD_INFO(boardId
)->ledsPolarity
)
737 mvGppValueSet(0, totalMask
, val
);
741 mvGppValueSet(0, totalMask
, ~val
);
746 /*******************************************************************************
747 * mvBoarGpioPinGet - mvBoarGpioPinGet
752 * class - MV_BOARD_GPP_CLASS enum.
758 * GPIO pin number. The function return -1 for bad parameters.
760 *******************************************************************************/
761 MV_32
mvBoarGpioPinNumGet(MV_BOARD_GPP_CLASS
class, MV_U32 index
)
764 MV_U32 indexFound
= 0;
766 boardId
= mvBoardIdGet();
768 if (!((boardId
>= BOARD_ID_BASE
)&&(boardId
< MV_MAX_BOARD_ID
)))
770 mvOsPrintf("mvBoardRTCGpioPinGet:Board unknown.\n");
775 for (i
= 0; i
< BOARD_INFO(boardId
)->numBoardGppInfo
; i
++)
776 if (BOARD_INFO(boardId
)->pBoardGppInfo
[i
].devClass
== class) {
777 if (indexFound
== index
)
778 return (MV_U32
)BOARD_INFO(boardId
)->pBoardGppInfo
[i
].gppPinNum
;
788 /*******************************************************************************
789 * mvBoardRTCGpioPinGet - mvBoardRTCGpioPinGet
800 * GPIO pin number. The function return -1 for bad parameters.
802 *******************************************************************************/
803 MV_32
mvBoardRTCGpioPinGet(MV_VOID
)
805 return mvBoarGpioPinNumGet(BOARD_GPP_RTC
, 0);
809 /*******************************************************************************
810 * mvBoardReset - mvBoardReset
823 *******************************************************************************/
824 MV_VOID
mvBoardReset(MV_VOID
)
828 /* Get gpp reset pin if define */
829 resetPin
= mvBoardResetGpioPinGet();
830 if (resetPin
!= MV_ERROR
)
832 MV_REG_BIT_RESET( GPP_DATA_OUT_REG(0) ,(1 << resetPin
));
833 MV_REG_BIT_RESET( GPP_DATA_OUT_EN_REG(0) ,(1 << resetPin
));
838 /* No gpp reset pin was found, try to reset ussing
840 MV_REG_BIT_SET( CPU_RSTOUTN_MASK_REG
, BIT2
);
841 MV_REG_BIT_SET( CPU_SYS_SOFT_RST_REG
, BIT0
);
845 /*******************************************************************************
846 * mvBoardResetGpioPinGet - mvBoardResetGpioPinGet
857 * GPIO pin number. The function return -1 for bad parameters.
859 *******************************************************************************/
860 MV_32
mvBoardResetGpioPinGet(MV_VOID
)
862 return mvBoarGpioPinNumGet(BOARD_GPP_RESET
, 0);
864 /*******************************************************************************
865 * mvBoardSDIOGpioPinGet - mvBoardSDIOGpioPinGet
868 * used for hotswap detection
876 * GPIO pin number. The function return -1 for bad parameters.
878 *******************************************************************************/
879 MV_32
mvBoardSDIOGpioPinGet(MV_VOID
)
881 return mvBoarGpioPinNumGet(BOARD_GPP_SDIO_DETECT
, 0);
884 /*******************************************************************************
885 * mvBoardUSBVbusGpioPinGet - return Vbus input GPP
896 * GPIO pin number. The function return -1 for bad parameters.
898 *******************************************************************************/
899 MV_32
mvBoardUSBVbusGpioPinGet(MV_32 devId
)
901 return mvBoarGpioPinNumGet(BOARD_GPP_USB_VBUS
, devId
);
904 /*******************************************************************************
905 * mvBoardUSBVbusEnGpioPinGet - return Vbus Enable output GPP
916 * GPIO pin number. The function return -1 for bad parameters.
918 *******************************************************************************/
919 MV_32
mvBoardUSBVbusEnGpioPinGet(MV_32 devId
)
921 return mvBoarGpioPinNumGet(BOARD_GPP_USB_VBUS_EN
, devId
);
925 /*******************************************************************************
926 * mvBoardGpioIntMaskGet - Get GPIO mask for interrupt pins
929 * This function returns a 32-bit mask of GPP pins that connected to
930 * interrupt generating sources on board.
931 * For example if UART channel A is hardwired to GPP pin 8 and
932 * UART channel B is hardwired to GPP pin 4 the fuinction will return
933 * the value 0x000000110
942 * See description. The function return -1 if board is not identified.
944 *******************************************************************************/
945 MV_32
mvBoardGpioIntMaskLowGet(MV_VOID
)
949 boardId
= mvBoardIdGet();
951 if (!((boardId
>= BOARD_ID_BASE
)&&(boardId
< MV_MAX_BOARD_ID
)))
953 mvOsPrintf("mvBoardGpioIntMaskGet:Board unknown.\n");
958 return BOARD_INFO(boardId
)->intsGppMaskLow
;
960 MV_32
mvBoardGpioIntMaskHighGet(MV_VOID
)
964 boardId
= mvBoardIdGet();
966 if (!((boardId
>= BOARD_ID_BASE
)&&(boardId
< MV_MAX_BOARD_ID
)))
968 mvOsPrintf("mvBoardGpioIntMaskGet:Board unknown.\n");
973 return BOARD_INFO(boardId
)->intsGppMaskHigh
;
977 /*******************************************************************************
978 * mvBoardMppGet - Get board dependent MPP register value
981 * MPP settings are derived from board design.
982 * MPP group consist of 8 MPPs. An MPP group represent MPP
984 * This function retrieves board dependend MPP register value.
987 * mppGroupNum - MPP group number.
993 * 32bit value describing MPP control register value.
995 *******************************************************************************/
996 MV_32
mvBoardMppGet(MV_U32 mppGroupNum
)
1000 boardId
= mvBoardIdGet();
1002 if (!((boardId
>= BOARD_ID_BASE
)&&(boardId
< MV_MAX_BOARD_ID
)))
1004 mvOsPrintf("mvBoardMppGet:Board unknown.\n");
1009 return BOARD_INFO(boardId
)->pBoardMppConfigValue
[0].mppGroup
[mppGroupNum
];
1013 /*******************************************************************************
1014 * mvBoardMppGroupId - If MPP group type is AUTO then identify it using twsi
1025 *******************************************************************************/
1026 MV_VOID
mvBoardMppGroupIdUpdate(MV_VOID
)
1029 MV_BOARD_MPP_GROUP_CLASS devClass
;
1030 MV_BOARD_MODULE_ID_CLASS devClassId
;
1031 MV_BOARD_MPP_TYPE_CLASS mppGroupType
;
1033 MV_U32 maxMppGrp
= 1;
1035 devId
= mvCtrlModelGet();
1038 case MV_6281_DEV_ID
:
1039 maxMppGrp
= MV_6281_MPP_MAX_MODULE
;
1041 case MV_6192_DEV_ID
:
1042 maxMppGrp
= MV_6192_MPP_MAX_MODULE
;
1044 case MV_6190_DEV_ID
:
1045 maxMppGrp
= MV_6190_MPP_MAX_MODULE
;
1047 case MV_6180_DEV_ID
:
1048 maxMppGrp
= MV_6180_MPP_MAX_MODULE
;
1052 for (devClass
= 0; devClass
< maxMppGrp
; devClass
++)
1054 /* If MPP group can be defined by the module connected to it */
1055 if (mvBoardMppGroupTypeGet(devClass
) == MV_BOARD_AUTO
)
1057 /* Get MPP module ID */
1058 devClassId
= mvBoarModuleTypeGet(devClass
);
1059 if (MV_ERROR
!= devClassId
)
1063 case MV_BOARD_MODULE_TDM_ID
:
1064 case MV_BOARD_MODULE_TDM_5CHAN_ID
:
1065 mppGroupType
= MV_BOARD_TDM
;
1067 case MV_BOARD_MODULE_AUDIO_ID
:
1068 mppGroupType
= MV_BOARD_AUDIO
;
1070 case MV_BOARD_MODULE_RGMII_ID
:
1071 mppGroupType
= MV_BOARD_RGMII
;
1073 case MV_BOARD_MODULE_GMII_ID
:
1074 mppGroupType
= MV_BOARD_GMII
;
1076 case MV_BOARD_MODULE_TS_ID
:
1077 mppGroupType
= MV_BOARD_TS
;
1079 case MV_BOARD_MODULE_MII_ID
:
1080 mppGroupType
= MV_BOARD_MII
;
1083 mppGroupType
= MV_BOARD_OTHER
;
1088 /* The module bay is empty */
1089 mppGroupType
= MV_BOARD_OTHER
;
1091 /* Update MPP group type */
1092 mvBoardMppGroupTypeSet(devClass
, mppGroupType
);
1095 /* Update MPP output voltage for RGMII 1.8V. Set port to GMII for GMII module */
1096 if ((mvBoardMppGroupTypeGet(devClass
) == MV_BOARD_RGMII
))
1097 MV_REG_BIT_SET(MPP_OUTPUT_DRIVE_REG
,MPP_1_8_RGMII1_OUTPUT_DRIVE
| MPP_1_8_RGMII0_OUTPUT_DRIVE
);
1100 if ((mvBoardMppGroupTypeGet(devClass
) == MV_BOARD_GMII
))
1102 MV_REG_BIT_RESET(MPP_OUTPUT_DRIVE_REG
, BIT7
| BIT15
);
1103 MV_REG_BIT_RESET(ETH_PORT_SERIAL_CTRL_1_REG(0),BIT3
);
1104 MV_REG_BIT_RESET(ETH_PORT_SERIAL_CTRL_1_REG(1),BIT3
);
1106 else if ((mvBoardMppGroupTypeGet(devClass
) == MV_BOARD_MII
))
1108 /* Assumption that the MDC & MDIO should be 3.3V */
1109 MV_REG_BIT_RESET(MPP_OUTPUT_DRIVE_REG
, BIT7
| BIT15
);
1110 /* Assumption that only ETH1 can be MII when using modules on DB */
1111 MV_REG_BIT_RESET(ETH_PORT_SERIAL_CTRL_1_REG(1),BIT3
);
1117 /*******************************************************************************
1118 * mvBoardMppGroupTypeGet
1123 * mppGroupClass - MPP group number 0 for MPP[35:20] or 1 for MPP[49:36].
1130 *******************************************************************************/
1131 MV_BOARD_MPP_TYPE_CLASS
mvBoardMppGroupTypeGet(MV_BOARD_MPP_GROUP_CLASS mppGroupClass
)
1135 boardId
= mvBoardIdGet();
1137 if (!((boardId
>= BOARD_ID_BASE
)&&(boardId
< MV_MAX_BOARD_ID
)))
1139 mvOsPrintf("mvBoardMppGet:Board unknown.\n");
1144 if (mppGroupClass
== MV_BOARD_MPP_GROUP_1
)
1145 return BOARD_INFO(boardId
)->pBoardMppTypeValue
[0].boardMppGroup1
;
1147 return BOARD_INFO(boardId
)->pBoardMppTypeValue
[0].boardMppGroup2
;
1150 /*******************************************************************************
1151 * mvBoardMppGroupTypeSet
1156 * mppGroupClass - MPP group number 0 for MPP[35:20] or 1 for MPP[49:36].
1157 * mppGroupType - MPP group type for MPP[35:20] or for MPP[49:36].
1164 *******************************************************************************/
1165 MV_VOID
mvBoardMppGroupTypeSet(MV_BOARD_MPP_GROUP_CLASS mppGroupClass
,
1166 MV_BOARD_MPP_TYPE_CLASS mppGroupType
)
1170 boardId
= mvBoardIdGet();
1172 if (!((boardId
>= BOARD_ID_BASE
)&&(boardId
< MV_MAX_BOARD_ID
)))
1174 mvOsPrintf("mvBoardMppGet:Board unknown.\n");
1177 if (mppGroupClass
== MV_BOARD_MPP_GROUP_1
)
1178 BOARD_INFO(boardId
)->pBoardMppTypeValue
[0].boardMppGroup1
= mppGroupType
;
1180 BOARD_INFO(boardId
)->pBoardMppTypeValue
[0].boardMppGroup2
= mppGroupType
;
1184 /*******************************************************************************
1185 * mvBoardMppMuxSet - Update MPP mux
1196 *******************************************************************************/
1197 MV_VOID
mvBoardMppMuxSet(MV_VOID
)
1200 MV_BOARD_MPP_GROUP_CLASS devClass
;
1201 MV_BOARD_MPP_TYPE_CLASS mppGroupType
;
1204 MV_U32 maxMppGrp
= 1;
1205 MV_TWSI_SLAVE twsiSlave
;
1208 devId
= mvCtrlModelGet();
1211 case MV_6281_DEV_ID
:
1212 maxMppGrp
= MV_6281_MPP_MAX_MODULE
;
1214 case MV_6192_DEV_ID
:
1215 maxMppGrp
= MV_6192_MPP_MAX_MODULE
;
1217 case MV_6190_DEV_ID
:
1218 maxMppGrp
= MV_6190_MPP_MAX_MODULE
;
1220 case MV_6180_DEV_ID
:
1221 maxMppGrp
= MV_6180_MPP_MAX_MODULE
;
1225 for (devClass
= 0; devClass
< maxMppGrp
; devClass
++)
1227 mppGroupType
= mvBoardMppGroupTypeGet(devClass
);
1229 switch(mppGroupType
)
1232 muxVal
&= ~(devClass
? (0x2 << (devClass
* 2)):0x0);
1234 case MV_BOARD_AUDIO
:
1235 muxVal
&= ~(devClass
? 0x7 : 0x0); /*old Z0 value 0xd:0x0*/
1238 muxVal
&= ~(devClass
? (0x2 << (devClass
* 2)):0x0);
1241 muxVal
|= (devClass
? 0xf : 0);
1247 slave
.type
= ADDR7_BIT
;
1249 mvTwsiInit(0, TWSI_SPEED
, mvBoardTclkGet(), &slave
, 0);
1251 /* Read MPP module ID */
1252 DB(mvOsPrintf("Board: twsi exp set\n"));
1253 twsiSlave
.slaveAddr
.address
= mvBoardTwsiExpAddrGet(MV_BOARD_MUX_I2C_ADDR_ENTRY
);
1254 twsiSlave
.slaveAddr
.type
= mvBoardTwsiExpAddrTypeGet(MV_BOARD_MUX_I2C_ADDR_ENTRY
);
1255 twsiSlave
.validOffset
= MV_TRUE
;
1256 /* Offset is the first command after the address which indicate the register number to be read
1257 in next operation */
1258 twsiSlave
.offset
= 2;
1259 twsiSlave
.moreThen256
= MV_FALSE
;
1263 if( MV_OK
!= mvTwsiWrite (0, &twsiSlave
, &muxVal
, 1) )
1265 DB(mvOsPrintf("Board: twsi exp out val fail\n"));
1268 DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
1270 /* Change twsi exp to output */
1271 twsiSlave
.offset
= 6;
1273 if( MV_OK
!= mvTwsiWrite (0, &twsiSlave
, &muxVal
, 1) )
1275 DB(mvOsPrintf("Board: twsi exp change to out fail\n"));
1278 DB(mvOsPrintf("Board: twsi exp change to out succeded\n"));
1282 /*******************************************************************************
1283 * mvBoardTdmMppSet - set MPPs in TDM module
1287 * INPUT: type of second telephony device
1294 *******************************************************************************/
1295 MV_VOID
mvBoardTdmMppSet(MV_32 chType
)
1298 MV_BOARD_MPP_GROUP_CLASS devClass
;
1299 MV_BOARD_MPP_TYPE_CLASS mppGroupType
;
1302 MV_U8 muxValMask
= 1;
1304 MV_U32 maxMppGrp
= 1;
1305 MV_TWSI_SLAVE twsiSlave
;
1308 devId
= mvCtrlModelGet();
1311 case MV_6281_DEV_ID
:
1312 maxMppGrp
= MV_6281_MPP_MAX_MODULE
;
1314 case MV_6192_DEV_ID
:
1315 maxMppGrp
= MV_6192_MPP_MAX_MODULE
;
1317 case MV_6190_DEV_ID
:
1318 maxMppGrp
= MV_6190_MPP_MAX_MODULE
;
1320 case MV_6180_DEV_ID
:
1321 maxMppGrp
= MV_6180_MPP_MAX_MODULE
;
1325 for (devClass
= 0; devClass
< maxMppGrp
; devClass
++)
1327 mppGroupType
= mvBoardMppGroupTypeGet(devClass
);
1328 if(mppGroupType
== MV_BOARD_TDM
)
1332 if(devClass
== maxMppGrp
)
1333 return; /* TDM module not found */
1336 slave
.type
= ADDR7_BIT
;
1338 mvTwsiInit(0, TWSI_SPEED
, mvBoardTclkGet(), &slave
, 0);
1340 /* Read MPP module ID */
1341 DB(mvOsPrintf("Board: twsi exp set\n"));
1342 twsiSlave
.slaveAddr
.address
= mvBoardTwsiExpAddrGet(devClass
);
1343 twsiSlave
.slaveAddr
.type
= ADDR7_BIT
;
1344 twsiSlave
.validOffset
= MV_TRUE
;
1345 /* Offset is the first command after the address which indicate the register number to be read
1346 in next operation */
1347 twsiSlave
.offset
= 3;
1348 twsiSlave
.moreThen256
= MV_FALSE
;
1350 if(mvBoardIdGet() == RD_88F6281A_ID
)
1356 mvTwsiRead(0, &twsiSlave
, &twsiVal
, 1);
1357 muxVal
= (twsiVal
& muxValMask
) | muxVal
;
1359 if( MV_OK
!= mvTwsiWrite (0, &twsiSlave
, &muxVal
, 1) )
1361 mvOsPrintf("Board: twsi exp out val fail\n");
1364 DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
1366 /* Change twsi exp to output */
1367 twsiSlave
.offset
= 7;
1369 if(mvBoardIdGet() == RD_88F6281A_ID
)
1372 mvTwsiRead(0, &twsiSlave
, &twsiVal
, 1);
1373 muxVal
= (twsiVal
& muxVal
);
1375 if( MV_OK
!= mvTwsiWrite (0, &twsiSlave
, &muxVal
, 1) )
1377 mvOsPrintf("Board: twsi exp change to out fail\n");
1380 DB(mvOsPrintf("Board: twsi exp change to out succeded\n"));
1381 /* reset the line to 0 */
1382 twsiSlave
.offset
= 3;
1386 if(mvBoardIdGet() == RD_88F6281A_ID
) {
1391 mvTwsiRead(0, &twsiSlave
, &twsiVal
, 1);
1392 muxVal
= (twsiVal
& muxValMask
) | muxVal
;
1394 if( MV_OK
!= mvTwsiWrite (0, &twsiSlave
, &muxVal
, 1) )
1396 mvOsPrintf("Board: twsi exp out val fail\n");
1399 DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
1403 /* set the line to 1 */
1404 twsiSlave
.offset
= 3;
1408 if(mvBoardIdGet() == RD_88F6281A_ID
)
1412 if(chType
) /* FXS - issue reset properly */
1414 MV_REG_BIT_SET(GPP_DATA_OUT_REG(1), MV_GPP12
);
1416 MV_REG_BIT_RESET(GPP_DATA_OUT_REG(1), MV_GPP12
);
1418 else /* FXO - issue reset via TDM_CODEC_RST*/
1420 /* change MPP44 type to TDM_CODEC_RST(0x2) */
1421 MV_REG_WRITE(MPP_CONTROL_REG5
, ((MV_REG_READ(MPP_CONTROL_REG5
) & 0xFFF0FFFF) | BIT17
));
1425 mvTwsiRead(0, &twsiSlave
, &twsiVal
, 1);
1426 muxVal
= (twsiVal
& muxValMask
) | muxVal
;
1428 if( MV_OK
!= mvTwsiWrite (0, &twsiSlave
, &muxVal
, 1) )
1430 mvOsPrintf("Board: twsi exp out val fail\n");
1434 /* TBD - 5 channels */
1435 #if defined(MV_TDM_5CHANNELS)
1436 /* change MPP38 type to GPIO(0x0) & polarity for TDM_STROBE */
1437 MV_REG_WRITE(MPP_CONTROL_REG4
, (MV_REG_READ(MPP_CONTROL_REG4
) & 0xF0FFFFFF));
1438 mvGppPolaritySet(1, MV_GPP6
, 0);
1440 twsiSlave
.offset
= 6;
1441 twsiSlave
.slaveAddr
.address
= mvBoardTwsiExpAddrGet(2);
1443 mvTwsiRead(0, &twsiSlave
, &twsiVal
, 1);
1444 muxVal
= (twsiVal
& ~BIT2
);
1446 if( MV_OK
!= mvTwsiWrite (0, &twsiSlave
, &muxVal
, 1) )
1448 mvOsPrintf("Board: twsi exp change to out fail\n");
1453 twsiSlave
.offset
= 2;
1455 mvTwsiRead(0, &twsiSlave
, &twsiVal
, 1);
1456 muxVal
= (twsiVal
& ~BIT2
);
1458 if( MV_OK
!= mvTwsiWrite (0, &twsiSlave
, &muxVal
, 1) )
1460 mvOsPrintf("Board: twsi exp change to out fail\n");
1464 DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
1468 /*******************************************************************************
1469 * mvBoardVoiceConnModeGet - return SLIC/DAA connection & interrupt modes
1480 *******************************************************************************/
1482 MV_VOID
mvBoardVoiceConnModeGet(MV_32
* connMode
, MV_32
* irqMode
)
1484 switch(mvBoardIdGet())
1486 case RD_88F6281A_ID
:
1487 *connMode
= DAISY_CHAIN_MODE
;
1488 *irqMode
= INTERRUPT_TO_TDM
;
1490 case DB_88F6281A_BP_ID
:
1491 *connMode
= DUAL_CHIP_SELECT_MODE
;
1492 *irqMode
= INTERRUPT_TO_TDM
;
1494 case RD_88F6192A_ID
:
1495 *connMode
= DUAL_CHIP_SELECT_MODE
;
1496 *irqMode
= INTERRUPT_TO_TDM
;
1498 case DB_88F6192A_BP_ID
:
1499 *connMode
= DUAL_CHIP_SELECT_MODE
;
1500 *irqMode
= INTERRUPT_TO_TDM
;
1503 *connMode
= *irqMode
= -1;
1504 mvOsPrintf("mvBoardVoiceAssembleModeGet: TDM not supported(boardId=0x%x)\n",mvBoardIdGet());
1510 /*******************************************************************************
1511 * mvBoardMppModuleTypePrint - print module detect
1522 *******************************************************************************/
1523 MV_VOID
mvBoardMppModuleTypePrint(MV_VOID
)
1526 MV_BOARD_MPP_GROUP_CLASS devClass
;
1527 MV_BOARD_MPP_TYPE_CLASS mppGroupType
;
1529 MV_U32 maxMppGrp
= 1;
1531 devId
= mvCtrlModelGet();
1534 case MV_6281_DEV_ID
:
1535 maxMppGrp
= MV_6281_MPP_MAX_MODULE
;
1537 case MV_6192_DEV_ID
:
1538 maxMppGrp
= MV_6192_MPP_MAX_MODULE
;
1540 case MV_6190_DEV_ID
:
1541 maxMppGrp
= MV_6190_MPP_MAX_MODULE
;
1543 case MV_6180_DEV_ID
:
1544 maxMppGrp
= MV_6180_MPP_MAX_MODULE
;
1548 for (devClass
= 0; devClass
< maxMppGrp
; devClass
++)
1550 mppGroupType
= mvBoardMppGroupTypeGet(devClass
);
1552 switch(mppGroupType
)
1555 if(devId
!= MV_6190_DEV_ID
)
1556 mvOsPrintf("Module %d is TDM\n", devClass
);
1558 case MV_BOARD_AUDIO
:
1559 if(devId
!= MV_6190_DEV_ID
)
1560 mvOsPrintf("Module %d is AUDIO\n", devClass
);
1562 case MV_BOARD_RGMII
:
1563 if(devId
!= MV_6190_DEV_ID
)
1564 mvOsPrintf("Module %d is RGMII\n", devClass
);
1567 if(devId
!= MV_6190_DEV_ID
)
1568 mvOsPrintf("Module %d is GMII\n", devClass
);
1571 if(devId
!= MV_6190_DEV_ID
)
1572 mvOsPrintf("Module %d is TS\n", devClass
);
1580 /* Board devices API managments */
1582 /*******************************************************************************
1583 * mvBoardGetDeviceNumber - Get number of device of some type on the board
1588 * devType - The device type ( Flash,RTC , etc .. )
1594 * If the device is found on the board the then the functions returns the
1595 * number of those devices else the function returns 0
1598 *******************************************************************************/
1599 MV_32
mvBoardGetDevicesNumber(MV_BOARD_DEV_CLASS devClass
)
1601 MV_U32 foundIndex
=0,devNum
;
1602 MV_U32 boardId
= mvBoardIdGet();
1604 if (!((boardId
>= BOARD_ID_BASE
)&&(boardId
< MV_MAX_BOARD_ID
)))
1606 mvOsPrintf("mvBoardGetDeviceNumber:Board unknown.\n");
1611 for (devNum
= START_DEV_CS
; devNum
< BOARD_INFO(boardId
)->numBoardDeviceIf
; devNum
++)
1613 if (BOARD_INFO(boardId
)->pDevCsInfo
[devNum
].devClass
== devClass
)
1623 /*******************************************************************************
1624 * mvBoardGetDeviceBaseAddr - Get base address of a device existing on the board
1629 * devIndex - The device sequential number on the board
1630 * devType - The device type ( Flash,RTC , etc .. )
1636 * If the device is found on the board the then the functions returns the
1637 * Base address else the function returns 0xffffffff
1640 *******************************************************************************/
1641 MV_32
mvBoardGetDeviceBaseAddr(MV_32 devNum
, MV_BOARD_DEV_CLASS devClass
)
1643 MV_DEV_CS_INFO
* devEntry
;
1644 devEntry
= boardGetDevEntry(devNum
,devClass
);
1645 if (devEntry
!= NULL
)
1647 return mvCpuIfTargetWinBaseLowGet(DEV_TO_TARGET(devEntry
->deviceCS
));
1654 /*******************************************************************************
1655 * mvBoardGetDeviceBusWidth - Get Bus width of a device existing on the board
1660 * devIndex - The device sequential number on the board
1661 * devType - The device type ( Flash,RTC , etc .. )
1667 * If the device is found on the board the then the functions returns the
1668 * Bus width else the function returns 0xffffffff
1671 *******************************************************************************/
1672 MV_32
mvBoardGetDeviceBusWidth(MV_32 devNum
, MV_BOARD_DEV_CLASS devClass
)
1674 MV_DEV_CS_INFO
* devEntry
;
1676 devEntry
= boardGetDevEntry(devNum
,devClass
);
1677 if (devEntry
!= NULL
)
1686 /*******************************************************************************
1687 * mvBoardGetDeviceWidth - Get dev width of a device existing on the board
1692 * devIndex - The device sequential number on the board
1693 * devType - The device type ( Flash,RTC , etc .. )
1699 * If the device is found on the board the then the functions returns the
1700 * dev width else the function returns 0xffffffff
1703 *******************************************************************************/
1704 MV_32
mvBoardGetDeviceWidth(MV_32 devNum
, MV_BOARD_DEV_CLASS devClass
)
1706 MV_DEV_CS_INFO
* devEntry
;
1707 MV_U32 boardId
= mvBoardIdGet();
1709 if (!((boardId
>= BOARD_ID_BASE
)&&(boardId
< MV_MAX_BOARD_ID
)))
1711 mvOsPrintf("Board unknown.\n");
1715 devEntry
= boardGetDevEntry(devNum
,devClass
);
1716 if (devEntry
!= NULL
)
1717 return devEntry
->devWidth
;
1723 /*******************************************************************************
1724 * mvBoardGetDeviceWinSize - Get the window size of a device existing on the board
1729 * devIndex - The device sequential number on the board
1730 * devType - The device type ( Flash,RTC , etc .. )
1736 * If the device is found on the board the then the functions returns the
1737 * window size else the function returns 0xffffffff
1740 *******************************************************************************/
1741 MV_32
mvBoardGetDeviceWinSize(MV_32 devNum
, MV_BOARD_DEV_CLASS devClass
)
1743 MV_DEV_CS_INFO
* devEntry
;
1744 MV_U32 boardId
= mvBoardIdGet();
1746 if (!((boardId
>= BOARD_ID_BASE
)&&(boardId
< MV_MAX_BOARD_ID
)))
1748 mvOsPrintf("Board unknown.\n");
1752 devEntry
= boardGetDevEntry(devNum
,devClass
);
1753 if (devEntry
!= NULL
)
1755 return mvCpuIfTargetWinSizeGet(DEV_TO_TARGET(devEntry
->deviceCS
));
1762 /*******************************************************************************
1763 * boardGetDevEntry - returns the entry pointer of a device on the board
1768 * devIndex - The device sequential number on the board
1769 * devType - The device type ( Flash,RTC , etc .. )
1775 * If the device is found on the board the then the functions returns the
1776 * dev number else the function returns 0x0
1779 *******************************************************************************/
1780 static MV_DEV_CS_INFO
* boardGetDevEntry(MV_32 devNum
, MV_BOARD_DEV_CLASS devClass
)
1782 MV_U32 foundIndex
=0,devIndex
;
1783 MV_U32 boardId
= mvBoardIdGet();
1785 if (!((boardId
>= BOARD_ID_BASE
)&&(boardId
< MV_MAX_BOARD_ID
)))
1787 mvOsPrintf("boardGetDevEntry: Board unknown.\n");
1792 for (devIndex
= START_DEV_CS
; devIndex
< BOARD_INFO(boardId
)->numBoardDeviceIf
; devIndex
++)
1795 /*if (BOARD_INFO(boardId)->pDevCsInfo[devIndex].deviceCS == MV_BOOTDEVICE_INDEX)
1798 if (BOARD_INFO(boardId
)->pDevCsInfo
[devIndex
].devClass
== devClass
)
1800 if (foundIndex
== devNum
)
1802 return &(BOARD_INFO(boardId
)->pDevCsInfo
[devIndex
]);
1808 /* device not found */
1812 /* Get device CS number */
1814 MV_U32
boardGetDevCSNum(MV_32 devNum
, MV_BOARD_DEV_CLASS devClass
)
1816 MV_DEV_CS_INFO
* devEntry
;
1817 MV_U32 boardId
= mvBoardIdGet();
1819 if (!((boardId
>= BOARD_ID_BASE
)&&(boardId
< MV_MAX_BOARD_ID
)))
1821 mvOsPrintf("Board unknown.\n");
1827 devEntry
= boardGetDevEntry(devNum
,devClass
);
1828 if (devEntry
!= NULL
)
1829 return devEntry
->deviceCS
;
1835 /*******************************************************************************
1836 * mvBoardRtcTwsiAddrTypeGet -
1848 *******************************************************************************/
1849 MV_U8
mvBoardRtcTwsiAddrTypeGet()
1852 MV_U32 boardId
= mvBoardIdGet();
1854 for (i
= 0; i
< BOARD_INFO(boardId
)->numBoardTwsiDev
; i
++)
1855 if (BOARD_INFO(boardId
)->pBoardTwsiDev
[i
].devClass
== BOARD_TWSI_RTC
)
1856 return BOARD_INFO(boardId
)->pBoardTwsiDev
[i
].twsiDevAddrType
;
1860 /*******************************************************************************
1861 * mvBoardRtcTwsiAddrGet -
1873 *******************************************************************************/
1874 MV_U8
mvBoardRtcTwsiAddrGet()
1877 MV_U32 boardId
= mvBoardIdGet();
1879 for (i
= 0; i
< BOARD_INFO(boardId
)->numBoardTwsiDev
; i
++)
1880 if (BOARD_INFO(boardId
)->pBoardTwsiDev
[i
].devClass
== BOARD_TWSI_RTC
)
1881 return BOARD_INFO(boardId
)->pBoardTwsiDev
[i
].twsiDevAddr
;
1885 /*******************************************************************************
1886 * mvBoardA2DTwsiAddrTypeGet -
1898 *******************************************************************************/
1899 MV_U8
mvBoardA2DTwsiAddrTypeGet()
1902 MV_U32 boardId
= mvBoardIdGet();
1904 for (i
= 0; i
< BOARD_INFO(boardId
)->numBoardTwsiDev
; i
++)
1905 if (BOARD_INFO(boardId
)->pBoardTwsiDev
[i
].devClass
== BOARD_TWSI_AUDIO_DEC
)
1906 return BOARD_INFO(boardId
)->pBoardTwsiDev
[i
].twsiDevAddrType
;
1910 /*******************************************************************************
1911 * mvBoardA2DTwsiAddrGet -
1923 *******************************************************************************/
1924 MV_U8
mvBoardA2DTwsiAddrGet()
1927 MV_U32 boardId
= mvBoardIdGet();
1929 for (i
= 0; i
< BOARD_INFO(boardId
)->numBoardTwsiDev
; i
++)
1930 if (BOARD_INFO(boardId
)->pBoardTwsiDev
[i
].devClass
== BOARD_TWSI_AUDIO_DEC
)
1931 return BOARD_INFO(boardId
)->pBoardTwsiDev
[i
].twsiDevAddr
;
1935 /*******************************************************************************
1936 * mvBoardTwsiExpAddrTypeGet -
1948 *******************************************************************************/
1949 MV_U8
mvBoardTwsiExpAddrTypeGet(MV_U32 index
)
1952 MV_U32 indexFound
= 0;
1953 MV_U32 boardId
= mvBoardIdGet();
1955 for (i
= 0; i
< BOARD_INFO(boardId
)->numBoardTwsiDev
; i
++)
1956 if (BOARD_INFO(boardId
)->pBoardTwsiDev
[i
].devClass
== BOARD_DEV_TWSI_EXP
)
1958 if (indexFound
== index
)
1959 return BOARD_INFO(boardId
)->pBoardTwsiDev
[i
].twsiDevAddrType
;
1967 /*******************************************************************************
1968 * mvBoardTwsiExpAddrGet -
1980 *******************************************************************************/
1981 MV_U8
mvBoardTwsiExpAddrGet(MV_U32 index
)
1984 MV_U32 indexFound
= 0;
1985 MV_U32 boardId
= mvBoardIdGet();
1987 for (i
= 0; i
< BOARD_INFO(boardId
)->numBoardTwsiDev
; i
++)
1988 if (BOARD_INFO(boardId
)->pBoardTwsiDev
[i
].devClass
== BOARD_DEV_TWSI_EXP
)
1990 if (indexFound
== index
)
1991 return BOARD_INFO(boardId
)->pBoardTwsiDev
[i
].twsiDevAddr
;
2000 /*******************************************************************************
2001 * mvBoardTwsiSatRAddrTypeGet -
2013 *******************************************************************************/
2014 MV_U8
mvBoardTwsiSatRAddrTypeGet(MV_U32 index
)
2017 MV_U32 indexFound
= 0;
2018 MV_U32 boardId
= mvBoardIdGet();
2020 for (i
= 0; i
< BOARD_INFO(boardId
)->numBoardTwsiDev
; i
++)
2021 if (BOARD_INFO(boardId
)->pBoardTwsiDev
[i
].devClass
== BOARD_DEV_TWSI_SATR
)
2023 if (indexFound
== index
)
2024 return BOARD_INFO(boardId
)->pBoardTwsiDev
[i
].twsiDevAddrType
;
2032 /*******************************************************************************
2033 * mvBoardTwsiSatRAddrGet -
2045 *******************************************************************************/
2046 MV_U8
mvBoardTwsiSatRAddrGet(MV_U32 index
)
2049 MV_U32 indexFound
= 0;
2050 MV_U32 boardId
= mvBoardIdGet();
2052 for (i
= 0; i
< BOARD_INFO(boardId
)->numBoardTwsiDev
; i
++)
2053 if (BOARD_INFO(boardId
)->pBoardTwsiDev
[i
].devClass
== BOARD_DEV_TWSI_SATR
)
2055 if (indexFound
== index
)
2056 return BOARD_INFO(boardId
)->pBoardTwsiDev
[i
].twsiDevAddr
;
2064 /*******************************************************************************
2065 * mvBoardNandWidthGet -
2067 * DESCRIPTION: Get the width of the first NAND device in byte.
2074 * RETURN: 1, 2, 4 or MV_ERROR
2077 *******************************************************************************/
2079 MV_32
mvBoardNandWidthGet(void)
2083 MV_U32 boardId
= mvBoardIdGet();
2085 for (devNum
= START_DEV_CS
; devNum
< BOARD_INFO(boardId
)->numBoardDeviceIf
; devNum
++)
2087 devWidth
= mvBoardGetDeviceWidth(devNum
, BOARD_DEV_NAND_FLASH
);
2088 if (devWidth
!= MV_ERROR
)
2089 return (devWidth
/ 8);
2092 /* NAND wasn't found */
2096 MV_U32 gBoardId
= -1;
2098 /*******************************************************************************
2099 * mvBoardIdGet - Get Board model
2102 * This function returns board ID.
2103 * Board ID is 32bit word constructed of board model (16bit) and
2104 * board revision (16bit) in the following way: 0xMMMMRRRR.
2113 * 32bit board ID number, '-1' if board is undefined.
2115 *******************************************************************************/
2116 MV_U32
mvBoardIdGet(MV_VOID
)
2118 MV_U32 tmpBoardId
= -1;
2122 #if defined(DB_88F6281A)
2123 tmpBoardId
= DB_88F6281A_BP_ID
;
2124 #elif defined(RD_88F6281A)
2125 tmpBoardId
= RD_88F6281A_ID
;
2126 #elif defined(DB_88F6192A)
2127 tmpBoardId
= DB_88F6192A_BP_ID
;
2128 #elif defined(DB_88F6190A)
2129 tmpBoardId
= DB_88F6190A_BP_ID
;
2130 #elif defined(RD_88F6192A)
2131 tmpBoardId
= RD_88F6192A_ID
;
2132 #elif defined(RD_88F6190A)
2133 tmpBoardId
= RD_88F6190A_ID
;
2134 #elif defined(DB_88F6180A)
2135 tmpBoardId
= DB_88F6180A_BP_ID
;
2136 #elif defined(RD_88F6281A_PCAC)
2137 tmpBoardId
= RD_88F6281A_PCAC_ID
;
2138 #elif defined(RD_88F6281A_SHEEVA_PLUG)
2139 tmpBoardId
= SHEEVA_PLUG_ID
;
2140 #elif defined(DB_CUSTOMER)
2141 tmpBoardId
= DB_CUSTOMER_ID
;
2143 gBoardId
= tmpBoardId
;
2150 /*******************************************************************************
2151 * mvBoarModuleTypeGet - mvBoarModuleTypeGet
2156 * group num - MV_BOARD_MPP_GROUP_CLASS enum
2162 * module num - MV_BOARD_MODULE_CLASS enum
2164 *******************************************************************************/
2165 MV_BOARD_MODULE_ID_CLASS
mvBoarModuleTypeGet(MV_BOARD_MPP_GROUP_CLASS devClass
)
2167 MV_TWSI_SLAVE twsiSlave
;
2172 slave
.type
= ADDR7_BIT
;
2174 mvTwsiInit(0, TWSI_SPEED
, mvBoardTclkGet(), &slave
, 0);
2176 /* Read MPP module ID */
2177 DB(mvOsPrintf("Board: Read MPP module ID\n"));
2178 twsiSlave
.slaveAddr
.address
= mvBoardTwsiExpAddrGet(devClass
);
2179 twsiSlave
.slaveAddr
.type
= mvBoardTwsiExpAddrTypeGet(devClass
);
2180 twsiSlave
.validOffset
= MV_TRUE
;
2181 /* Offset is the first command after the address which indicate the register number to be read
2182 in next operation */
2183 twsiSlave
.offset
= 0;
2184 twsiSlave
.moreThen256
= MV_FALSE
;
2188 if( MV_OK
!= mvTwsiRead (0, &twsiSlave
, &data
, 1) )
2190 DB(mvOsPrintf("Board: Read MPP module ID fail\n"));
2193 DB(mvOsPrintf("Board: Read MPP module ID succeded\n"));
2198 /*******************************************************************************
2199 * mvBoarTwsiSatRGet -
2204 * device num - one of three devices
2213 *******************************************************************************/
2214 MV_U8
mvBoarTwsiSatRGet(MV_U8 devNum
, MV_U8 regNum
)
2216 MV_TWSI_SLAVE twsiSlave
;
2221 slave
.type
= ADDR7_BIT
;
2223 mvTwsiInit(0, TWSI_SPEED
, mvBoardTclkGet(), &slave
, 0);
2225 /* Read MPP module ID */
2226 DB(mvOsPrintf("Board: Read S@R device read\n"));
2227 twsiSlave
.slaveAddr
.address
= mvBoardTwsiSatRAddrGet(devNum
);
2228 twsiSlave
.slaveAddr
.type
= mvBoardTwsiSatRAddrTypeGet(devNum
);
2229 twsiSlave
.validOffset
= MV_TRUE
;
2230 /* Use offset as command */
2231 twsiSlave
.offset
= regNum
;
2232 twsiSlave
.moreThen256
= MV_FALSE
;
2234 if( MV_OK
!= mvTwsiRead (0, &twsiSlave
, &data
, 1) )
2236 DB(mvOsPrintf("Board: Read S@R fail\n"));
2239 DB(mvOsPrintf("Board: Read S@R succeded\n"));
2244 /*******************************************************************************
2245 * mvBoarTwsiSatRSet -
2250 * devNum - one of three devices
2261 *******************************************************************************/
2262 MV_STATUS
mvBoarTwsiSatRSet(MV_U8 devNum
, MV_U8 regNum
, MV_U8 regVal
)
2264 MV_TWSI_SLAVE twsiSlave
;
2268 slave
.type
= ADDR7_BIT
;
2270 mvTwsiInit(0, TWSI_SPEED
, mvBoardTclkGet(), &slave
, 0);
2272 /* Read MPP module ID */
2273 twsiSlave
.slaveAddr
.address
= mvBoardTwsiSatRAddrGet(devNum
);
2274 twsiSlave
.slaveAddr
.type
= mvBoardTwsiSatRAddrTypeGet(devNum
);
2275 twsiSlave
.validOffset
= MV_TRUE
;
2276 DB(mvOsPrintf("Board: Write S@R device addr %x, type %x, data %x\n", twsiSlave
.slaveAddr
.address
,\
2277 twsiSlave
.slaveAddr
.type
, regVal
));
2278 /* Use offset as command */
2279 twsiSlave
.offset
= regNum
;
2280 twsiSlave
.moreThen256
= MV_FALSE
;
2281 if( MV_OK
!= mvTwsiWrite (0, &twsiSlave
, ®Val
, 1) )
2283 DB(mvOsPrintf("Board: Write S@R fail\n"));
2286 DB(mvOsPrintf("Board: Write S@R succeded\n"));
2291 /*******************************************************************************
2292 * mvBoardSlicGpioPinGet -
2304 *******************************************************************************/
2305 MV_32
mvBoardSlicGpioPinGet(MV_U32 slicNum
)
2308 boardId
= mvBoardIdGet();
2312 case DB_88F6281A_BP_ID
:
2313 case RD_88F6281A_ID
:
2321 /*******************************************************************************
2322 * mvBoardFanPowerControl - Turn on/off the fan power control on the RD-6281A
2327 * mode - MV_TRUE = on ; MV_FALSE = off
2330 * MV_STATUS - MV_OK , MV_ERROR.
2334 *******************************************************************************/
2335 MV_STATUS
mvBoardFanPowerControl(MV_BOOL mode
)
2338 MV_U8 val
= 1, twsiVal
;
2339 MV_TWSI_SLAVE twsiSlave
;
2342 if(mvBoardIdGet() != RD_88F6281A_ID
)
2346 slave
.type
= ADDR7_BIT
;
2348 mvTwsiInit(0, TWSI_SPEED
, mvBoardTclkGet(), &slave
, 0);
2350 /* Read MPP module ID */
2351 DB(mvOsPrintf("Board: twsi exp set\n"));
2352 twsiSlave
.slaveAddr
.address
= mvBoardTwsiExpAddrGet(1);
2353 twsiSlave
.slaveAddr
.type
= ADDR7_BIT
;
2354 twsiSlave
.validOffset
= MV_TRUE
;
2355 /* Offset is the first command after the address which indicate the register number to be read
2356 in next operation */
2357 twsiSlave
.offset
= 3;
2358 twsiSlave
.moreThen256
= MV_FALSE
;
2363 mvTwsiRead(0, &twsiSlave
, &twsiVal
, 1);
2364 val
= (twsiVal
& 0xfe) | val
;
2366 if( MV_OK
!= mvTwsiWrite (0, &twsiSlave
, &val
, 1) )
2368 DB(mvOsPrintf("Board: twsi exp out val fail\n"));
2371 DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
2373 /* Change twsi exp to output */
2374 twsiSlave
.offset
= 7;
2375 mvTwsiRead(0, &twsiSlave
, &twsiVal
, 1);
2376 val
= (twsiVal
& 0xfe);
2377 if( MV_OK
!= mvTwsiWrite (0, &twsiSlave
, &val
, 1) )
2379 DB(mvOsPrintf("Board: twsi exp change to out fail\n"));
2382 DB(mvOsPrintf("Board: twsi exp change to out succeded\n"));
2386 /*******************************************************************************
2387 * mvBoardHDDPowerControl - Turn on/off the HDD power control on the RD-6281A
2392 * mode - MV_TRUE = on ; MV_FALSE = off
2395 * MV_STATUS - MV_OK , MV_ERROR.
2399 *******************************************************************************/
2400 MV_STATUS
mvBoardHDDPowerControl(MV_BOOL mode
)
2403 MV_U8 val
= 1, twsiVal
;
2404 MV_TWSI_SLAVE twsiSlave
;
2407 if(mvBoardIdGet() != RD_88F6281A_ID
)
2411 slave
.type
= ADDR7_BIT
;
2413 mvTwsiInit(0, TWSI_SPEED
, mvBoardTclkGet(), &slave
, 0);
2415 /* Read MPP module ID */
2416 DB(mvOsPrintf("Board: twsi exp set\n"));
2417 twsiSlave
.slaveAddr
.address
= mvBoardTwsiExpAddrGet(1);
2418 twsiSlave
.slaveAddr
.type
= ADDR7_BIT
;
2419 twsiSlave
.validOffset
= MV_TRUE
;
2420 /* Offset is the first command after the address which indicate the register number to be read
2421 in next operation */
2422 twsiSlave
.offset
= 3;
2423 twsiSlave
.moreThen256
= MV_FALSE
;
2428 mvTwsiRead(0, &twsiSlave
, &twsiVal
, 1);
2429 val
= (twsiVal
& 0xfd) | val
;
2430 if( MV_OK
!= mvTwsiWrite (0, &twsiSlave
, &val
, 1) )
2432 DB(mvOsPrintf("Board: twsi exp out val fail\n"));
2435 DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
2437 /* Change twsi exp to output */
2438 twsiSlave
.offset
= 7;
2439 mvTwsiRead(0, &twsiSlave
, &twsiVal
, 1);
2440 val
= (twsiVal
& 0xfd);
2441 if( MV_OK
!= mvTwsiWrite (0, &twsiSlave
, &val
, 1) )
2443 DB(mvOsPrintf("Board: twsi exp change to out fail\n"));
2446 DB(mvOsPrintf("Board: twsi exp change to out succeded\n"));
2450 /*******************************************************************************
2451 * mvBoardSDioWPControl - Turn on/off the SDIO WP on the RD-6281A
2456 * mode - MV_TRUE = on ; MV_FALSE = off
2459 * MV_STATUS - MV_OK , MV_ERROR.
2463 *******************************************************************************/
2464 MV_STATUS
mvBoardSDioWPControl(MV_BOOL mode
)
2467 MV_U8 val
= 1, twsiVal
;
2468 MV_TWSI_SLAVE twsiSlave
;
2471 if(mvBoardIdGet() != RD_88F6281A_ID
)
2475 slave
.type
= ADDR7_BIT
;
2477 mvTwsiInit(0, TWSI_SPEED
, mvBoardTclkGet(), &slave
, 0);
2479 /* Read MPP module ID */
2480 DB(mvOsPrintf("Board: twsi exp set\n"));
2481 twsiSlave
.slaveAddr
.address
= mvBoardTwsiExpAddrGet(0);
2482 twsiSlave
.slaveAddr
.type
= ADDR7_BIT
;
2483 twsiSlave
.validOffset
= MV_TRUE
;
2484 /* Offset is the first command after the address which indicate the register number to be read
2485 in next operation */
2486 twsiSlave
.offset
= 3;
2487 twsiSlave
.moreThen256
= MV_FALSE
;
2492 mvTwsiRead(0, &twsiSlave
, &twsiVal
, 1);
2493 val
= (twsiVal
& 0xef) | val
;
2494 if( MV_OK
!= mvTwsiWrite (0, &twsiSlave
, &val
, 1) )
2496 DB(mvOsPrintf("Board: twsi exp out val fail\n"));
2499 DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
2501 /* Change twsi exp to output */
2502 twsiSlave
.offset
= 7;
2503 mvTwsiRead(0, &twsiSlave
, &twsiVal
, 1);
2504 val
= (twsiVal
& 0xef);
2505 if( MV_OK
!= mvTwsiWrite (0, &twsiSlave
, &val
, 1) )
2507 DB(mvOsPrintf("Board: twsi exp change to out fail\n"));
2510 DB(mvOsPrintf("Board: twsi exp change to out succeded\n"));