Root/target/linux/generic/files/crypto/ocf/kirkwood/mvHal/kw_family/boardEnv/mvBoardEnvLib.c

1/*******************************************************************************
2Copyright (C) Marvell International Ltd. and its affiliates
3
4This software file (the "File") is owned and distributed by Marvell
5International Ltd. and/or its affiliates ("Marvell") under the following
6alternative licensing terms. Once you have made an election to distribute the
7File under one of the following license alternatives, please (i) delete this
8introductory statement regarding license alternatives, (ii) delete the two
9license alternatives that you have not elected to use and (iii) preserve the
10Marvell copyright notice above.
11
12********************************************************************************
13Marvell Commercial License Option
14
15If you received this File from Marvell and you have entered into a commercial
16license agreement (a "Commercial License") with Marvell, the File is licensed
17to you under the terms of the applicable Commercial License.
18
19********************************************************************************
20Marvell GPL License Option
21
22If you received this File from Marvell, you may opt to use, redistribute and/or
23modify this File in accordance with the terms and conditions of the General
24Public License Version 2, June 1991 (the "GPL License"), a copy of which is
25available along with the File in the license.txt file or by writing to the Free
26Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 or
27on the worldwide web at http://www.gnu.org/licenses/gpl.txt.
28
29THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE IMPLIED
30WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY
31DISCLAIMED. The GPL License provides additional details about this warranty
32disclaimer.
33********************************************************************************
34Marvell BSD License Option
35
36If you received this File from Marvell, you may opt to use, redistribute and/or
37modify this File under the following licensing terms.
38Redistribution and use in source and binary forms, with or without modification,
39are permitted provided that the following conditions are met:
40
41    * Redistributions of source code must retain the above copyright notice,
42        this list of conditions and the following disclaimer.
43
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.
47
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.
51
52THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
53ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
54WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
55DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
56ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
57(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
58LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
59ANY 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
61SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
62
63*******************************************************************************/
64
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"
75
76/* defines */
77/* #define MV_DEBUG */
78#ifdef MV_DEBUG
79    #define DB(x) x
80#else
81    #define DB(x)
82#endif
83
84extern MV_CPU_ARM_CLK _cpuARMDDRCLK[];
85
86#define CODE_IN_ROM MV_FALSE
87#define CODE_IN_RAM MV_TRUE
88
89extern MV_BOARD_INFO* boardInfoTbl[];
90#define BOARD_INFO(boardId) boardInfoTbl[boardId - BOARD_ID_BASE]
91
92/* Locals */
93static MV_DEV_CS_INFO* boardGetDevEntry(MV_32 devNum, MV_BOARD_DEV_CLASS devClass);
94
95MV_U32 tClkRate = -1;
96
97
98/*******************************************************************************
99* mvBoardEnvInit - Init board
100*
101* DESCRIPTION:
102* In this function the board environment take care of device bank
103* initialization.
104*
105* INPUT:
106* None.
107*
108* OUTPUT:
109* None.
110*
111* RETURN:
112* None.
113*
114*******************************************************************************/
115MV_VOID mvBoardEnvInit(MV_VOID)
116{
117    MV_U32 boardId= mvBoardIdGet();
118
119    if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
120    {
121        mvOsPrintf("mvBoardEnvInit:Board unknown.\n");
122        return;
123
124    }
125
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);
129
130    /* set GPP polarity */
131    mvGppPolaritySet(0, 0xFFFFFFFF, BOARD_INFO(boardId)->gppPolarityValLow);
132    mvGppPolaritySet(1, 0xFFFFFFFF, BOARD_INFO(boardId)->gppPolarityValHigh);
133
134    /* Workaround for Erratum FE-MISC-70*/
135    if(mvCtrlRevGet()==MV_88F6XXX_A0_REV)
136    {
137        BOARD_INFO(boardId)->gppOutEnValLow &= 0xfffffffd;
138        BOARD_INFO(boardId)->gppOutEnValLow |= (BOARD_INFO(boardId)->gppOutEnValHigh) & 0x00000002;
139    } /*End of WA*/
140
141    /* Set GPP Out Enable*/
142    mvGppTypeSet(0, 0xFFFFFFFF, BOARD_INFO(boardId)->gppOutEnValLow);
143    mvGppTypeSet(1, 0xFFFFFFFF, BOARD_INFO(boardId)->gppOutEnValHigh);
144
145    /* Nand CE */
146    MV_REG_BIT_SET(NAND_CTRL_REG, NAND_ACTCEBOOT_BIT);
147}
148
149/*******************************************************************************
150* mvBoardModelGet - Get Board model
151*
152* DESCRIPTION:
153* This function returns 16bit describing board model.
154* Board model is constructed of one byte major and minor numbers in the
155* following manner:
156*
157* INPUT:
158* None.
159*
160* OUTPUT:
161* None.
162*
163* RETURN:
164* String describing board model.
165*
166*******************************************************************************/
167MV_U16 mvBoardModelGet(MV_VOID)
168{
169    return (mvBoardIdGet() >> 16);
170}
171
172/*******************************************************************************
173* mbBoardRevlGet - Get Board revision
174*
175* DESCRIPTION:
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
180* 0x00030004.
181*
182* INPUT:
183* None.
184*
185* OUTPUT:
186* None.
187*
188* RETURN:
189* String describing board model.
190*
191*******************************************************************************/
192MV_U16 mvBoardRevGet(MV_VOID)
193{
194    return (mvBoardIdGet() & 0xFFFF);
195}
196
197/*******************************************************************************
198* mvBoardNameGet - Get Board name
199*
200* DESCRIPTION:
201* This function returns a string describing the board model and revision.
202* String is extracted from board I2C EEPROM.
203*
204* INPUT:
205* None.
206*
207* OUTPUT:
208* pNameBuff - Buffer to contain board name string. Minimum size 32 chars.
209*
210* RETURN:
211*
212* MV_ERROR if informantion can not be read.
213*******************************************************************************/
214MV_STATUS mvBoardNameGet(char *pNameBuff)
215{
216    MV_U32 boardId= mvBoardIdGet();
217
218    if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
219    {
220        mvOsSPrintf (pNameBuff, "Board unknown.\n");
221        return MV_ERROR;
222
223    }
224
225    mvOsSPrintf (pNameBuff, "%s",BOARD_INFO(boardId)->boardName);
226
227    return MV_OK;
228}
229
230/*******************************************************************************
231* mvBoardIsPortInSgmii -
232*
233* DESCRIPTION:
234* This routine returns MV_TRUE for port number works in SGMII or MV_FALSE
235* For all other options.
236*
237* INPUT:
238* ethPortNum - Ethernet port number.
239*
240* OUTPUT:
241* None.
242*
243* RETURN:
244* MV_TRUE - port in SGMII.
245* MV_FALSE - other.
246*
247*******************************************************************************/
248MV_BOOL mvBoardIsPortInSgmii(MV_U32 ethPortNum)
249{
250    MV_BOOL ethPortSgmiiSupport[BOARD_ETH_PORT_NUM] = MV_ETH_PORT_SGMII;
251
252    if(ethPortNum >= BOARD_ETH_PORT_NUM)
253    {
254        mvOsPrintf ("Invalid portNo=%d\n", ethPortNum);
255        return MV_FALSE;
256    }
257    return ethPortSgmiiSupport[ethPortNum];
258}
259
260/*******************************************************************************
261* mvBoardIsPortInGmii -
262*
263* DESCRIPTION:
264* This routine returns MV_TRUE for port number works in GMII or MV_FALSE
265* For all other options.
266*
267* INPUT:
268*
269* OUTPUT:
270* None.
271*
272* RETURN:
273* MV_TRUE - port in GMII.
274* MV_FALSE - other.
275*
276*******************************************************************************/
277MV_BOOL mvBoardIsPortInGmii(MV_VOID)
278{
279    MV_U32 devClassId, devClass = 0;
280    if (mvBoardMppGroupTypeGet(devClass) == MV_BOARD_AUTO)
281    {
282        /* Get MPP module ID */
283        devClassId = mvBoarModuleTypeGet(devClass);
284        if (MV_BOARD_MODULE_GMII_ID == devClassId)
285            return MV_TRUE;
286    }
287    else if (mvBoardMppGroupTypeGet(devClass) == MV_BOARD_GMII)
288        return MV_TRUE;
289
290    return MV_FALSE;
291}
292/*******************************************************************************
293* mvBoardPhyAddrGet - Get the phy address
294*
295* DESCRIPTION:
296* This routine returns the Phy address of a given ethernet port.
297*
298* INPUT:
299* ethPortNum - Ethernet port number.
300*
301* OUTPUT:
302* None.
303*
304* RETURN:
305* 32bit describing Phy address, -1 if the port number is wrong.
306*
307*******************************************************************************/
308MV_32 mvBoardPhyAddrGet(MV_U32 ethPortNum)
309{
310    MV_U32 boardId= mvBoardIdGet();
311
312    if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
313    {
314        mvOsPrintf("mvBoardPhyAddrGet: Board unknown.\n");
315        return MV_ERROR;
316    }
317
318    return BOARD_INFO(boardId)->pBoardMacInfo[ethPortNum].boardEthSmiAddr;
319}
320
321/*******************************************************************************
322* mvBoardMacSpeedGet - Get the Mac speed
323*
324* DESCRIPTION:
325* This routine returns the Mac speed if pre define of a given ethernet port.
326*
327* INPUT:
328* ethPortNum - Ethernet port number.
329*
330* OUTPUT:
331* None.
332*
333* RETURN:
334* MV_BOARD_MAC_SPEED, -1 if the port number is wrong.
335*
336*******************************************************************************/
337MV_BOARD_MAC_SPEED mvBoardMacSpeedGet(MV_U32 ethPortNum)
338{
339    MV_U32 boardId= mvBoardIdGet();
340
341    if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
342    {
343        mvOsPrintf("mvBoardMacSpeedGet: Board unknown.\n");
344        return MV_ERROR;
345    }
346
347    return BOARD_INFO(boardId)->pBoardMacInfo[ethPortNum].boardMacSpeed;
348}
349
350/*******************************************************************************
351* mvBoardLinkStatusIrqGet - Get the IRQ number for the link status indication
352*
353* DESCRIPTION:
354* This routine returns the IRQ number for the link status indication.
355*
356* INPUT:
357* ethPortNum - Ethernet port number.
358*
359* OUTPUT:
360* None.
361*
362* RETURN:
363* the number of the IRQ for the link status indication, -1 if the port
364* number is wrong or if not relevant.
365*
366*******************************************************************************/
367MV_32 mvBoardLinkStatusIrqGet(MV_U32 ethPortNum)
368{
369    MV_U32 boardId = mvBoardIdGet();
370
371    if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
372    {
373        mvOsPrintf("mvBoardLinkStatusIrqGet: Board unknown.\n");
374        return MV_ERROR;
375    }
376
377    return BOARD_INFO(boardId)->pSwitchInfo[ethPortNum].linkStatusIrq;
378}
379
380/*******************************************************************************
381* mvBoardSwitchPortGet - Get the mapping between the board connector and the
382* Ethernet Switch port
383*
384* DESCRIPTION:
385* This routine returns the matching Switch port.
386*
387* INPUT:
388* ethPortNum - Ethernet port number.
389* boardPortNum - logical number of the connector on the board
390*
391* OUTPUT:
392* None.
393*
394* RETURN:
395* the matching Switch port, -1 if the port number is wrong or if not relevant.
396*
397*******************************************************************************/
398MV_32 mvBoardSwitchPortGet(MV_U32 ethPortNum, MV_U8 boardPortNum)
399{
400    MV_U32 boardId = mvBoardIdGet();
401
402    if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
403    {
404        mvOsPrintf("mvBoardSwitchPortGet: Board unknown.\n");
405        return MV_ERROR;
406    }
407    if (boardPortNum >= BOARD_ETH_SWITCH_PORT_NUM)
408    {
409        mvOsPrintf("mvBoardSwitchPortGet: Illegal board port number.\n");
410        return MV_ERROR;
411    }
412
413    return BOARD_INFO(boardId)->pSwitchInfo[ethPortNum].qdPort[boardPortNum];
414}
415
416/*******************************************************************************
417* mvBoardSwitchCpuPortGet - Get the the Ethernet Switch CPU port
418*
419* DESCRIPTION:
420* This routine returns the Switch CPU port.
421*
422* INPUT:
423* ethPortNum - Ethernet port number.
424*
425* OUTPUT:
426* None.
427*
428* RETURN:
429* the Switch CPU port, -1 if the port number is wrong or if not relevant.
430*
431*******************************************************************************/
432MV_32 mvBoardSwitchCpuPortGet(MV_U32 ethPortNum)
433{
434    MV_U32 boardId = mvBoardIdGet();
435
436    if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
437    {
438        mvOsPrintf("mvBoardSwitchCpuPortGet: Board unknown.\n");
439        return MV_ERROR;
440    }
441
442    return BOARD_INFO(boardId)->pSwitchInfo[ethPortNum].qdCpuPort;
443}
444
445/*******************************************************************************
446* mvBoardIsSwitchConnected - Get switch connection status
447* DESCRIPTION:
448* This routine returns port's connection status
449*
450* INPUT:
451* ethPortNum - Ethernet port number.
452*
453* OUTPUT:
454* None.
455*
456* RETURN:
457* 1 - if ethPortNum is connected to switch, 0 otherwise
458*
459*******************************************************************************/
460MV_32 mvBoardIsSwitchConnected(MV_U32 ethPortNum)
461{
462    MV_U32 boardId = mvBoardIdGet();
463
464    if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
465    {
466        mvOsPrintf("mvBoardIsSwitchConnected: Board unknown.\n");
467        return MV_ERROR;
468    }
469
470    if(ethPortNum >= BOARD_INFO(boardId)->numBoardMacInfo)
471    {
472        mvOsPrintf("mvBoardIsSwitchConnected: Illegal port number(%u)\n", ethPortNum);
473        return MV_ERROR;
474    }
475    
476    if((MV_32)(BOARD_INFO(boardId)->pSwitchInfo))
477    return (MV_32)(BOARD_INFO(boardId)->pSwitchInfo[ethPortNum].switchOnPort == ethPortNum);
478    else
479        return 0;
480}
481/*******************************************************************************
482* mvBoardSmiScanModeGet - Get Switch SMI scan mode
483*
484* DESCRIPTION:
485* This routine returns Switch SMI scan mode.
486*
487* INPUT:
488* ethPortNum - Ethernet port number.
489*
490* OUTPUT:
491* None.
492*
493* RETURN:
494* 1 for SMI_MANUAL_MODE, -1 if the port number is wrong or if not relevant.
495*
496*******************************************************************************/
497MV_32 mvBoardSmiScanModeGet(MV_U32 ethPortNum)
498{
499    MV_U32 boardId = mvBoardIdGet();
500
501    if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
502    {
503        mvOsPrintf("mvBoardSmiScanModeGet: Board unknown.\n");
504        return MV_ERROR;
505    }
506
507    return BOARD_INFO(boardId)->pSwitchInfo[ethPortNum].smiScanMode;
508}
509/*******************************************************************************
510* mvBoardSpecInitGet -
511*
512* DESCRIPTION:
513*
514* INPUT:
515*
516* OUTPUT:
517* None.
518*
519* RETURN: Return MV_TRUE and parameters in case board need spesific phy init,
520* otherwise return MV_FALSE.
521*
522*
523*******************************************************************************/
524
525MV_BOOL mvBoardSpecInitGet(MV_U32* regOff, MV_U32* data)
526{
527    return MV_FALSE;
528}
529
530/*******************************************************************************
531* mvBoardTclkGet - Get the board Tclk (Controller clock)
532*
533* DESCRIPTION:
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
538*
539* INPUT:
540* countNum - Counter number.
541*
542* OUTPUT:
543* None.
544*
545* RETURN:
546* 32bit clock cycles in Hertz.
547*
548*******************************************************************************/
549MV_U32 mvBoardTclkGet(MV_VOID)
550{
551    if(mvCtrlModelGet()==MV_6281_DEV_ID)
552    {
553#if defined(TCLK_AUTO_DETECT)
554    MV_U32 tmpTClkRate = MV_BOARD_TCLK_166MHZ;
555
556    tmpTClkRate = MV_REG_READ(MPP_SAMPLE_AT_RESET);
557    tmpTClkRate &= MSAR_TCLCK_MASK;
558
559    switch (tmpTClkRate)
560    {
561    case MSAR_TCLCK_166:
562            return MV_BOARD_TCLK_166MHZ;
563            break;
564    case MSAR_TCLCK_200:
565            return MV_BOARD_TCLK_200MHZ;
566            break;
567    }
568#else
569    return MV_BOARD_TCLK_200MHZ;
570#endif
571    }
572
573        return MV_BOARD_TCLK_166MHZ;
574
575}
576/*******************************************************************************
577* mvBoardSysClkGet - Get the board SysClk (CPU bus clock)
578*
579* DESCRIPTION:
580* This routine extract the CPU bus clock.
581*
582* INPUT:
583* countNum - Counter number.
584*
585* OUTPUT:
586* None.
587*
588* RETURN:
589* 32bit clock cycles in Hertz.
590*
591*******************************************************************************/
592static MV_U32 mvBoard6180SysClkGet(MV_VOID)
593{
594    MV_U32 sysClkRate=0;
595    MV_CPU_ARM_CLK _cpu6180_ddr_l2_CLK[] = MV_CPU6180_DDR_L2_CLCK_TBL;
596
597    sysClkRate = MV_REG_READ(MPP_SAMPLE_AT_RESET);
598    sysClkRate = sysClkRate & MSAR_CPUCLCK_MASK_6180;
599    sysClkRate = sysClkRate >> MSAR_CPUCLCK_OFFS_6180;
600            
601    sysClkRate = _cpu6180_ddr_l2_CLK[sysClkRate].ddrClk;
602
603    return sysClkRate;
604
605}
606
607MV_U32 mvBoardSysClkGet(MV_VOID)
608{
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;
613
614    if(mvCtrlModelGet() == MV_6180_DEV_ID)
615        return mvBoard6180SysClkGet();
616
617    tmp = MV_REG_READ(MPP_SAMPLE_AT_RESET);
618    pClkRate = MSAR_CPUCLCK_EXTRACT(tmp);
619    pClkRate = cpuCLK[pClkRate];
620
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]);
625    else
626        sysClkRate = 0;
627    return sysClkRate;
628#else
629    return MV_BOARD_DEFAULT_SYSCLK;
630#endif
631}
632
633
634/*******************************************************************************
635* mvBoardPexBridgeIntPinGet - Get PEX to PCI bridge interrupt pin number
636*
637* DESCRIPTION:
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:
648* PCI dev num
649* Interrupt pin 7, 8, 9
650* A -> A D C
651* B -> B A D
652* C -> C B A
653* D -> D C B
654*
655*
656* INPUT:
657* devNum - PCI/PCIX device number.
658* intPin - PCI Int pin
659*
660* OUTPUT:
661* None.
662*
663* RETURN:
664* Int pin connected to the Interrupt controller
665*
666*******************************************************************************/
667MV_U32 mvBoardPexBridgeIntPinGet(MV_U32 devNum, MV_U32 intPin)
668{
669    MV_U32 realIntPin = ((intPin + (3 - (devNum % 4))) %4 );
670
671    if (realIntPin == 0) return 4;
672        else return realIntPin;
673
674}
675
676/*******************************************************************************
677* mvBoardDebugLedNumGet - Get number of debug Leds
678*
679* DESCRIPTION:
680* INPUT:
681* boardId
682*
683* OUTPUT:
684* None.
685*
686* RETURN:
687* None.
688*
689*******************************************************************************/
690MV_U32 mvBoardDebugLedNumGet(MV_U32 boardId)
691{
692    return BOARD_INFO(boardId)->activeLedsNumber;
693}
694
695/*******************************************************************************
696* mvBoardDebugLeg - Set the board debug Leds
697*
698* DESCRIPTION: turn on/off status leds.
699* Note: assume MPP leds are part of group 0 only.
700*
701* INPUT:
702* hexNum - Number to be displied in hex by Leds.
703*
704* OUTPUT:
705* None.
706*
707* RETURN:
708* None.
709*
710*******************************************************************************/
711MV_VOID mvBoardDebugLed(MV_U32 hexNum)
712{
713    MV_U32 val = 0,totalMask, currentBitMask = 1,i;
714    MV_U32 boardId= mvBoardIdGet();
715
716    if (BOARD_INFO(boardId)->pLedGppPin == NULL)
717    return;
718
719    totalMask = (1 << BOARD_INFO(boardId)->activeLedsNumber) -1;
720    hexNum &= totalMask;
721    totalMask = 0;
722
723    for (i = 0 ; i < BOARD_INFO(boardId)->activeLedsNumber ; i++)
724    {
725    if (hexNum & currentBitMask)
726    {
727        val |= (1 << BOARD_INFO(boardId)->pLedGppPin[i]);
728    }
729
730    totalMask |= (1 << BOARD_INFO(boardId)->pLedGppPin[i]);
731
732    currentBitMask = (currentBitMask << 1);
733    }
734
735    if (BOARD_INFO(boardId)->ledsPolarity)
736    {
737    mvGppValueSet(0, totalMask, val);
738    }
739    else
740    {
741    mvGppValueSet(0, totalMask, ~val);
742    }
743}
744
745
746/*******************************************************************************
747* mvBoarGpioPinGet - mvBoarGpioPinGet
748*
749* DESCRIPTION:
750*
751* INPUT:
752* class - MV_BOARD_GPP_CLASS enum.
753*
754* OUTPUT:
755* None.
756*
757* RETURN:
758* GPIO pin number. The function return -1 for bad parameters.
759*
760*******************************************************************************/
761MV_32 mvBoarGpioPinNumGet(MV_BOARD_GPP_CLASS class, MV_U32 index)
762{
763    MV_U32 boardId, i;
764    MV_U32 indexFound = 0;
765
766    boardId = mvBoardIdGet();
767
768    if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
769    {
770        mvOsPrintf("mvBoardRTCGpioPinGet:Board unknown.\n");
771        return MV_ERROR;
772
773    }
774
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;
779            else
780                indexFound++;
781
782        }
783
784    return MV_ERROR;
785}
786
787
788/*******************************************************************************
789* mvBoardRTCGpioPinGet - mvBoardRTCGpioPinGet
790*
791* DESCRIPTION:
792*
793* INPUT:
794* None.
795*
796* OUTPUT:
797* None.
798*
799* RETURN:
800* GPIO pin number. The function return -1 for bad parameters.
801*
802*******************************************************************************/
803MV_32 mvBoardRTCGpioPinGet(MV_VOID)
804{
805    return mvBoarGpioPinNumGet(BOARD_GPP_RTC, 0);
806}
807
808
809/*******************************************************************************
810* mvBoardReset - mvBoardReset
811*
812* DESCRIPTION:
813* Reset the board
814* INPUT:
815* None.
816*
817* OUTPUT:
818* None.
819*
820* RETURN:
821* None
822*
823*******************************************************************************/
824MV_VOID mvBoardReset(MV_VOID)
825{
826    MV_32 resetPin;
827
828    /* Get gpp reset pin if define */
829    resetPin = mvBoardResetGpioPinGet();
830    if (resetPin != MV_ERROR)
831    {
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));
834
835    }
836    else
837    {
838        /* No gpp reset pin was found, try to reset ussing
839        system reset out */
840        MV_REG_BIT_SET( CPU_RSTOUTN_MASK_REG , BIT2);
841        MV_REG_BIT_SET( CPU_SYS_SOFT_RST_REG , BIT0);
842    }
843}
844
845/*******************************************************************************
846* mvBoardResetGpioPinGet - mvBoardResetGpioPinGet
847*
848* DESCRIPTION:
849*
850* INPUT:
851* None.
852*
853* OUTPUT:
854* None.
855*
856* RETURN:
857* GPIO pin number. The function return -1 for bad parameters.
858*
859*******************************************************************************/
860MV_32 mvBoardResetGpioPinGet(MV_VOID)
861{
862    return mvBoarGpioPinNumGet(BOARD_GPP_RESET, 0);
863}
864/*******************************************************************************
865* mvBoardSDIOGpioPinGet - mvBoardSDIOGpioPinGet
866*
867* DESCRIPTION:
868* used for hotswap detection
869* INPUT:
870* None.
871*
872* OUTPUT:
873* None.
874*
875* RETURN:
876* GPIO pin number. The function return -1 for bad parameters.
877*
878*******************************************************************************/
879MV_32 mvBoardSDIOGpioPinGet(MV_VOID)
880{
881    return mvBoarGpioPinNumGet(BOARD_GPP_SDIO_DETECT, 0);
882}
883
884/*******************************************************************************
885* mvBoardUSBVbusGpioPinGet - return Vbus input GPP
886*
887* DESCRIPTION:
888*
889* INPUT:
890* int devNo.
891*
892* OUTPUT:
893* None.
894*
895* RETURN:
896* GPIO pin number. The function return -1 for bad parameters.
897*
898*******************************************************************************/
899MV_32 mvBoardUSBVbusGpioPinGet(MV_32 devId)
900{
901    return mvBoarGpioPinNumGet(BOARD_GPP_USB_VBUS, devId);
902}
903
904/*******************************************************************************
905* mvBoardUSBVbusEnGpioPinGet - return Vbus Enable output GPP
906*
907* DESCRIPTION:
908*
909* INPUT:
910* int devNo.
911*
912* OUTPUT:
913* None.
914*
915* RETURN:
916* GPIO pin number. The function return -1 for bad parameters.
917*
918*******************************************************************************/
919MV_32 mvBoardUSBVbusEnGpioPinGet(MV_32 devId)
920{
921    return mvBoarGpioPinNumGet(BOARD_GPP_USB_VBUS_EN, devId);
922}
923
924
925/*******************************************************************************
926* mvBoardGpioIntMaskGet - Get GPIO mask for interrupt pins
927*
928* DESCRIPTION:
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
934*
935* INPUT:
936* None.
937*
938* OUTPUT:
939* None.
940*
941* RETURN:
942* See description. The function return -1 if board is not identified.
943*
944*******************************************************************************/
945MV_32 mvBoardGpioIntMaskLowGet(MV_VOID)
946{
947    MV_U32 boardId;
948
949    boardId = mvBoardIdGet();
950
951    if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
952    {
953        mvOsPrintf("mvBoardGpioIntMaskGet:Board unknown.\n");
954        return MV_ERROR;
955
956    }
957
958    return BOARD_INFO(boardId)->intsGppMaskLow;
959}
960MV_32 mvBoardGpioIntMaskHighGet(MV_VOID)
961{
962    MV_U32 boardId;
963
964    boardId = mvBoardIdGet();
965
966    if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
967    {
968        mvOsPrintf("mvBoardGpioIntMaskGet:Board unknown.\n");
969        return MV_ERROR;
970
971    }
972
973    return BOARD_INFO(boardId)->intsGppMaskHigh;
974}
975
976
977/*******************************************************************************
978* mvBoardMppGet - Get board dependent MPP register value
979*
980* DESCRIPTION:
981* MPP settings are derived from board design.
982* MPP group consist of 8 MPPs. An MPP group represent MPP
983* control register.
984* This function retrieves board dependend MPP register value.
985*
986* INPUT:
987* mppGroupNum - MPP group number.
988*
989* OUTPUT:
990* None.
991*
992* RETURN:
993* 32bit value describing MPP control register value.
994*
995*******************************************************************************/
996MV_32 mvBoardMppGet(MV_U32 mppGroupNum)
997{
998    MV_U32 boardId;
999
1000    boardId = mvBoardIdGet();
1001
1002    if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
1003    {
1004        mvOsPrintf("mvBoardMppGet:Board unknown.\n");
1005        return MV_ERROR;
1006
1007    }
1008
1009    return BOARD_INFO(boardId)->pBoardMppConfigValue[0].mppGroup[mppGroupNum];
1010}
1011
1012
1013/*******************************************************************************
1014* mvBoardMppGroupId - If MPP group type is AUTO then identify it using twsi
1015*
1016* DESCRIPTION:
1017*
1018* INPUT:
1019*
1020* OUTPUT:
1021* None.
1022*
1023* RETURN:
1024*
1025*******************************************************************************/
1026MV_VOID mvBoardMppGroupIdUpdate(MV_VOID)
1027{
1028
1029    MV_BOARD_MPP_GROUP_CLASS devClass;
1030    MV_BOARD_MODULE_ID_CLASS devClassId;
1031    MV_BOARD_MPP_TYPE_CLASS mppGroupType;
1032    MV_U32 devId;
1033    MV_U32 maxMppGrp = 1;
1034    
1035    devId = mvCtrlModelGet();
1036
1037    switch(devId){
1038        case MV_6281_DEV_ID:
1039            maxMppGrp = MV_6281_MPP_MAX_MODULE;
1040            break;
1041        case MV_6192_DEV_ID:
1042            maxMppGrp = MV_6192_MPP_MAX_MODULE;
1043            break;
1044        case MV_6190_DEV_ID:
1045            maxMppGrp = MV_6190_MPP_MAX_MODULE;
1046            break;
1047        case MV_6180_DEV_ID:
1048            maxMppGrp = MV_6180_MPP_MAX_MODULE;
1049            break;
1050    }
1051
1052    for (devClass = 0; devClass < maxMppGrp; devClass++)
1053    {
1054        /* If MPP group can be defined by the module connected to it */
1055        if (mvBoardMppGroupTypeGet(devClass) == MV_BOARD_AUTO)
1056        {
1057            /* Get MPP module ID */
1058            devClassId = mvBoarModuleTypeGet(devClass);
1059            if (MV_ERROR != devClassId)
1060            {
1061                switch(devClassId)
1062                {
1063                case MV_BOARD_MODULE_TDM_ID:
1064                case MV_BOARD_MODULE_TDM_5CHAN_ID:
1065                    mppGroupType = MV_BOARD_TDM;
1066                    break;
1067                case MV_BOARD_MODULE_AUDIO_ID:
1068                    mppGroupType = MV_BOARD_AUDIO;
1069                    break;
1070                case MV_BOARD_MODULE_RGMII_ID:
1071                    mppGroupType = MV_BOARD_RGMII;
1072                    break;
1073                case MV_BOARD_MODULE_GMII_ID:
1074                    mppGroupType = MV_BOARD_GMII;
1075                    break;
1076                case MV_BOARD_MODULE_TS_ID:
1077                    mppGroupType = MV_BOARD_TS;
1078                    break;
1079                case MV_BOARD_MODULE_MII_ID:
1080                    mppGroupType = MV_BOARD_MII;
1081                    break;
1082                default:
1083                    mppGroupType = MV_BOARD_OTHER;
1084                    break;
1085                }
1086            }
1087            else
1088                /* The module bay is empty */
1089                mppGroupType = MV_BOARD_OTHER;
1090            
1091            /* Update MPP group type */
1092            mvBoardMppGroupTypeSet(devClass, mppGroupType);
1093        }
1094
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);
1098            else
1099        {
1100            if ((mvBoardMppGroupTypeGet(devClass) == MV_BOARD_GMII))
1101                {
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);
1105                }
1106                else if ((mvBoardMppGroupTypeGet(devClass) == MV_BOARD_MII))
1107                {
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);
1112                }
1113        }
1114    }
1115}
1116
1117/*******************************************************************************
1118* mvBoardMppGroupTypeGet
1119*
1120* DESCRIPTION:
1121*
1122* INPUT:
1123* mppGroupClass - MPP group number 0 for MPP[35:20] or 1 for MPP[49:36].
1124*
1125* OUTPUT:
1126* None.
1127*
1128* RETURN:
1129*
1130*******************************************************************************/
1131MV_BOARD_MPP_TYPE_CLASS mvBoardMppGroupTypeGet(MV_BOARD_MPP_GROUP_CLASS mppGroupClass)
1132{
1133    MV_U32 boardId;
1134
1135    boardId = mvBoardIdGet();
1136
1137    if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
1138    {
1139        mvOsPrintf("mvBoardMppGet:Board unknown.\n");
1140        return MV_ERROR;
1141
1142    }
1143    
1144    if (mppGroupClass == MV_BOARD_MPP_GROUP_1)
1145        return BOARD_INFO(boardId)->pBoardMppTypeValue[0].boardMppGroup1;
1146    else
1147        return BOARD_INFO(boardId)->pBoardMppTypeValue[0].boardMppGroup2;
1148}
1149
1150/*******************************************************************************
1151* mvBoardMppGroupTypeSet
1152*
1153* DESCRIPTION:
1154*
1155* INPUT:
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].
1158*
1159* OUTPUT:
1160* None.
1161*
1162* RETURN:
1163*
1164*******************************************************************************/
1165MV_VOID mvBoardMppGroupTypeSet(MV_BOARD_MPP_GROUP_CLASS mppGroupClass,
1166                        MV_BOARD_MPP_TYPE_CLASS mppGroupType)
1167{
1168    MV_U32 boardId;
1169
1170    boardId = mvBoardIdGet();
1171
1172    if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
1173    {
1174        mvOsPrintf("mvBoardMppGet:Board unknown.\n");
1175    }
1176
1177    if (mppGroupClass == MV_BOARD_MPP_GROUP_1)
1178        BOARD_INFO(boardId)->pBoardMppTypeValue[0].boardMppGroup1 = mppGroupType;
1179    else
1180        BOARD_INFO(boardId)->pBoardMppTypeValue[0].boardMppGroup2 = mppGroupType;
1181
1182}
1183
1184/*******************************************************************************
1185* mvBoardMppMuxSet - Update MPP mux
1186*
1187* DESCRIPTION:
1188*
1189* INPUT:
1190*
1191* OUTPUT:
1192* None.
1193*
1194* RETURN:
1195*
1196*******************************************************************************/
1197MV_VOID mvBoardMppMuxSet(MV_VOID)
1198{
1199
1200    MV_BOARD_MPP_GROUP_CLASS devClass;
1201    MV_BOARD_MPP_TYPE_CLASS mppGroupType;
1202    MV_U32 devId;
1203    MV_U8 muxVal = 0xf;
1204    MV_U32 maxMppGrp = 1;
1205    MV_TWSI_SLAVE twsiSlave;
1206    MV_TWSI_ADDR slave;
1207    
1208    devId = mvCtrlModelGet();
1209
1210    switch(devId){
1211        case MV_6281_DEV_ID:
1212            maxMppGrp = MV_6281_MPP_MAX_MODULE;
1213            break;
1214        case MV_6192_DEV_ID:
1215            maxMppGrp = MV_6192_MPP_MAX_MODULE;
1216            break;
1217        case MV_6190_DEV_ID:
1218            maxMppGrp = MV_6190_MPP_MAX_MODULE;
1219            break;
1220        case MV_6180_DEV_ID:
1221            maxMppGrp = MV_6180_MPP_MAX_MODULE;
1222            break;
1223    }
1224
1225    for (devClass = 0; devClass < maxMppGrp; devClass++)
1226    {
1227        mppGroupType = mvBoardMppGroupTypeGet(devClass);
1228
1229        switch(mppGroupType)
1230        {
1231            case MV_BOARD_TDM:
1232                muxVal &= ~(devClass ? (0x2 << (devClass * 2)):0x0);
1233                break;
1234            case MV_BOARD_AUDIO:
1235                 muxVal &= ~(devClass ? 0x7 : 0x0); /*old Z0 value 0xd:0x0*/
1236                break;
1237            case MV_BOARD_TS:
1238                 muxVal &= ~(devClass ? (0x2 << (devClass * 2)):0x0);
1239                break;
1240            default:
1241                muxVal |= (devClass ? 0xf : 0);
1242                break;
1243        }
1244    }
1245
1246    /* TWSI init */
1247    slave.type = ADDR7_BIT;
1248    slave.address = 0;
1249    mvTwsiInit(0, TWSI_SPEED, mvBoardTclkGet(), &slave, 0);
1250
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;
1260
1261
1262
1263        if( MV_OK != mvTwsiWrite (0, &twsiSlave, &muxVal, 1) )
1264        {
1265            DB(mvOsPrintf("Board: twsi exp out val fail\n"));
1266            return;
1267        }
1268        DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
1269        
1270    /* Change twsi exp to output */
1271        twsiSlave.offset = 6;
1272    muxVal = 0;
1273    if( MV_OK != mvTwsiWrite (0, &twsiSlave, &muxVal, 1) )
1274        {
1275            DB(mvOsPrintf("Board: twsi exp change to out fail\n"));
1276            return;
1277        }
1278        DB(mvOsPrintf("Board: twsi exp change to out succeded\n"));
1279    
1280}
1281
1282/*******************************************************************************
1283* mvBoardTdmMppSet - set MPPs in TDM module
1284*
1285* DESCRIPTION:
1286*
1287* INPUT: type of second telephony device
1288*
1289* OUTPUT:
1290* None.
1291*
1292* RETURN:
1293*
1294*******************************************************************************/
1295MV_VOID mvBoardTdmMppSet(MV_32 chType)
1296{
1297
1298    MV_BOARD_MPP_GROUP_CLASS devClass;
1299    MV_BOARD_MPP_TYPE_CLASS mppGroupType;
1300    MV_U32 devId;
1301    MV_U8 muxVal = 1;
1302    MV_U8 muxValMask = 1;
1303    MV_U8 twsiVal;
1304    MV_U32 maxMppGrp = 1;
1305        MV_TWSI_SLAVE twsiSlave;
1306    MV_TWSI_ADDR slave;
1307    
1308    devId = mvCtrlModelGet();
1309
1310    switch(devId){
1311        case MV_6281_DEV_ID:
1312            maxMppGrp = MV_6281_MPP_MAX_MODULE;
1313            break;
1314        case MV_6192_DEV_ID:
1315            maxMppGrp = MV_6192_MPP_MAX_MODULE;
1316            break;
1317        case MV_6190_DEV_ID:
1318            maxMppGrp = MV_6190_MPP_MAX_MODULE;
1319            break;
1320        case MV_6180_DEV_ID:
1321            maxMppGrp = MV_6180_MPP_MAX_MODULE;
1322            break;
1323    }
1324
1325    for (devClass = 0; devClass < maxMppGrp; devClass++)
1326    {
1327        mppGroupType = mvBoardMppGroupTypeGet(devClass);
1328        if(mppGroupType == MV_BOARD_TDM)
1329            break;
1330    }
1331
1332    if(devClass == maxMppGrp)
1333        return; /* TDM module not found */
1334
1335    /* TWSI init */
1336    slave.type = ADDR7_BIT;
1337    slave.address = 0;
1338    mvTwsiInit(0, TWSI_SPEED, mvBoardTclkGet(), &slave, 0);
1339
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;
1349
1350    if(mvBoardIdGet() == RD_88F6281A_ID)
1351    {
1352        muxVal = 0xc;
1353        muxValMask = 0xf3;
1354    }
1355
1356    mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
1357        muxVal = (twsiVal & muxValMask) | muxVal;
1358
1359        if( MV_OK != mvTwsiWrite (0, &twsiSlave, &muxVal, 1) )
1360        {
1361            mvOsPrintf("Board: twsi exp out val fail\n");
1362            return;
1363        }
1364        DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
1365        
1366    /* Change twsi exp to output */
1367        twsiSlave.offset = 7;
1368    muxVal = 0xfe;
1369    if(mvBoardIdGet() == RD_88F6281A_ID)
1370        muxVal = 0xf3;
1371
1372    mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
1373    muxVal = (twsiVal & muxVal);
1374
1375    if( MV_OK != mvTwsiWrite (0, &twsiSlave, &muxVal, 1) )
1376        {
1377            mvOsPrintf("Board: twsi exp change to out fail\n");
1378            return;
1379        }
1380        DB(mvOsPrintf("Board: twsi exp change to out succeded\n"));
1381    /* reset the line to 0 */
1382        twsiSlave.offset = 3;
1383    muxVal = 0;
1384    muxValMask = 1;
1385
1386    if(mvBoardIdGet() == RD_88F6281A_ID) {
1387        muxVal = 0x0;
1388        muxValMask = 0xf3;
1389    }
1390
1391    mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
1392        muxVal = (twsiVal & muxValMask) | muxVal;
1393
1394        if( MV_OK != mvTwsiWrite (0, &twsiSlave, &muxVal, 1) )
1395        {
1396            mvOsPrintf("Board: twsi exp out val fail\n");
1397            return;
1398        }
1399        DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
1400
1401    mvOsDelay(20);
1402
1403    /* set the line to 1 */
1404        twsiSlave.offset = 3;
1405    muxVal = 1;
1406    muxValMask = 1;
1407
1408    if(mvBoardIdGet() == RD_88F6281A_ID)
1409    {
1410        muxVal = 0xc;
1411        muxValMask = 0xf3;
1412        if(chType) /* FXS - issue reset properly */
1413        {
1414            MV_REG_BIT_SET(GPP_DATA_OUT_REG(1), MV_GPP12);
1415            mvOsDelay(50);
1416            MV_REG_BIT_RESET(GPP_DATA_OUT_REG(1), MV_GPP12);
1417        }
1418        else /* FXO - issue reset via TDM_CODEC_RST*/
1419        {
1420           /* change MPP44 type to TDM_CODEC_RST(0x2) */
1421           MV_REG_WRITE(MPP_CONTROL_REG5, ((MV_REG_READ(MPP_CONTROL_REG5) & 0xFFF0FFFF) | BIT17));
1422        }
1423    }
1424
1425    mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
1426        muxVal = (twsiVal & muxValMask) | muxVal;
1427
1428        if( MV_OK != mvTwsiWrite (0, &twsiSlave, &muxVal, 1) )
1429        {
1430            mvOsPrintf("Board: twsi exp out val fail\n");
1431            return;
1432        }
1433
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);
1439    
1440    twsiSlave.offset = 6;
1441    twsiSlave.slaveAddr.address = mvBoardTwsiExpAddrGet(2);
1442
1443    mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
1444    muxVal = (twsiVal & ~BIT2);
1445
1446    if( MV_OK != mvTwsiWrite (0, &twsiSlave, &muxVal, 1) )
1447        {
1448            mvOsPrintf("Board: twsi exp change to out fail\n");
1449            return;
1450        }
1451
1452
1453    twsiSlave.offset = 2;
1454
1455    mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
1456    muxVal = (twsiVal & ~BIT2);
1457
1458    if( MV_OK != mvTwsiWrite (0, &twsiSlave, &muxVal, 1) )
1459        {
1460            mvOsPrintf("Board: twsi exp change to out fail\n");
1461            return;
1462        }
1463#endif
1464        DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
1465
1466    
1467}
1468/*******************************************************************************
1469* mvBoardVoiceConnModeGet - return SLIC/DAA connection & interrupt modes
1470*
1471* DESCRIPTION:
1472*
1473* INPUT:
1474*
1475* OUTPUT:
1476* None.
1477*
1478* RETURN:
1479*
1480*******************************************************************************/
1481
1482MV_VOID mvBoardVoiceConnModeGet(MV_32* connMode, MV_32* irqMode)
1483{
1484    switch(mvBoardIdGet())
1485    {
1486        case RD_88F6281A_ID:
1487            *connMode = DAISY_CHAIN_MODE;
1488            *irqMode = INTERRUPT_TO_TDM;
1489            break;
1490        case DB_88F6281A_BP_ID:
1491             *connMode = DUAL_CHIP_SELECT_MODE;
1492             *irqMode = INTERRUPT_TO_TDM;
1493            break;
1494        case RD_88F6192A_ID:
1495            *connMode = DUAL_CHIP_SELECT_MODE;
1496            *irqMode = INTERRUPT_TO_TDM;
1497            break;
1498        case DB_88F6192A_BP_ID:
1499             *connMode = DUAL_CHIP_SELECT_MODE;
1500             *irqMode = INTERRUPT_TO_TDM;
1501            break;
1502        default:
1503            *connMode = *irqMode = -1;
1504            mvOsPrintf("mvBoardVoiceAssembleModeGet: TDM not supported(boardId=0x%x)\n",mvBoardIdGet());
1505    }
1506        return;
1507    
1508}
1509
1510/*******************************************************************************
1511* mvBoardMppModuleTypePrint - print module detect
1512*
1513* DESCRIPTION:
1514*
1515* INPUT:
1516*
1517* OUTPUT:
1518* None.
1519*
1520* RETURN:
1521*
1522*******************************************************************************/
1523MV_VOID mvBoardMppModuleTypePrint(MV_VOID)
1524{
1525
1526    MV_BOARD_MPP_GROUP_CLASS devClass;
1527    MV_BOARD_MPP_TYPE_CLASS mppGroupType;
1528    MV_U32 devId;
1529    MV_U32 maxMppGrp = 1;
1530    
1531    devId = mvCtrlModelGet();
1532
1533    switch(devId){
1534        case MV_6281_DEV_ID:
1535            maxMppGrp = MV_6281_MPP_MAX_MODULE;
1536            break;
1537        case MV_6192_DEV_ID:
1538            maxMppGrp = MV_6192_MPP_MAX_MODULE;
1539            break;
1540        case MV_6190_DEV_ID:
1541            maxMppGrp = MV_6190_MPP_MAX_MODULE;
1542            break;
1543        case MV_6180_DEV_ID:
1544            maxMppGrp = MV_6180_MPP_MAX_MODULE;
1545            break;
1546    }
1547
1548    for (devClass = 0; devClass < maxMppGrp; devClass++)
1549    {
1550        mppGroupType = mvBoardMppGroupTypeGet(devClass);
1551
1552        switch(mppGroupType)
1553        {
1554            case MV_BOARD_TDM:
1555                if(devId != MV_6190_DEV_ID)
1556                    mvOsPrintf("Module %d is TDM\n", devClass);
1557                break;
1558            case MV_BOARD_AUDIO:
1559                if(devId != MV_6190_DEV_ID)
1560                    mvOsPrintf("Module %d is AUDIO\n", devClass);
1561                break;
1562            case MV_BOARD_RGMII:
1563                if(devId != MV_6190_DEV_ID)
1564                    mvOsPrintf("Module %d is RGMII\n", devClass);
1565                break;
1566            case MV_BOARD_GMII:
1567                if(devId != MV_6190_DEV_ID)
1568                    mvOsPrintf("Module %d is GMII\n", devClass);
1569                break;
1570            case MV_BOARD_TS:
1571                if(devId != MV_6190_DEV_ID)
1572                    mvOsPrintf("Module %d is TS\n", devClass);
1573                break;
1574            default:
1575                break;
1576        }
1577    }
1578}
1579
1580/* Board devices API managments */
1581
1582/*******************************************************************************
1583* mvBoardGetDeviceNumber - Get number of device of some type on the board
1584*
1585* DESCRIPTION:
1586*
1587* INPUT:
1588* devType - The device type ( Flash,RTC , etc .. )
1589*
1590* OUTPUT:
1591* None.
1592*
1593* RETURN:
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
1596*
1597*
1598*******************************************************************************/
1599MV_32 mvBoardGetDevicesNumber(MV_BOARD_DEV_CLASS devClass)
1600{
1601    MV_U32 foundIndex=0,devNum;
1602    MV_U32 boardId= mvBoardIdGet();
1603
1604    if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
1605    {
1606        mvOsPrintf("mvBoardGetDeviceNumber:Board unknown.\n");
1607        return 0xFFFFFFFF;
1608
1609    }
1610
1611    for (devNum = START_DEV_CS; devNum < BOARD_INFO(boardId)->numBoardDeviceIf; devNum++)
1612    {
1613        if (BOARD_INFO(boardId)->pDevCsInfo[devNum].devClass == devClass)
1614        {
1615            foundIndex++;
1616        }
1617    }
1618
1619    return foundIndex;
1620
1621}
1622
1623/*******************************************************************************
1624* mvBoardGetDeviceBaseAddr - Get base address of a device existing on the board
1625*
1626* DESCRIPTION:
1627*
1628* INPUT:
1629* devIndex - The device sequential number on the board
1630* devType - The device type ( Flash,RTC , etc .. )
1631*
1632* OUTPUT:
1633* None.
1634*
1635* RETURN:
1636* If the device is found on the board the then the functions returns the
1637* Base address else the function returns 0xffffffff
1638*
1639*
1640*******************************************************************************/
1641MV_32 mvBoardGetDeviceBaseAddr(MV_32 devNum, MV_BOARD_DEV_CLASS devClass)
1642{
1643    MV_DEV_CS_INFO* devEntry;
1644    devEntry = boardGetDevEntry(devNum,devClass);
1645    if (devEntry != NULL)
1646    {
1647        return mvCpuIfTargetWinBaseLowGet(DEV_TO_TARGET(devEntry->deviceCS));
1648
1649    }
1650
1651    return 0xFFFFFFFF;
1652}
1653
1654/*******************************************************************************
1655* mvBoardGetDeviceBusWidth - Get Bus width of a device existing on the board
1656*
1657* DESCRIPTION:
1658*
1659* INPUT:
1660* devIndex - The device sequential number on the board
1661* devType - The device type ( Flash,RTC , etc .. )
1662*
1663* OUTPUT:
1664* None.
1665*
1666* RETURN:
1667* If the device is found on the board the then the functions returns the
1668* Bus width else the function returns 0xffffffff
1669*
1670*
1671*******************************************************************************/
1672MV_32 mvBoardGetDeviceBusWidth(MV_32 devNum, MV_BOARD_DEV_CLASS devClass)
1673{
1674    MV_DEV_CS_INFO* devEntry;
1675
1676    devEntry = boardGetDevEntry(devNum,devClass);
1677    if (devEntry != NULL)
1678    {
1679        return 8;
1680    }
1681
1682    return 0xFFFFFFFF;
1683
1684}
1685
1686/*******************************************************************************
1687* mvBoardGetDeviceWidth - Get dev width of a device existing on the board
1688*
1689* DESCRIPTION:
1690*
1691* INPUT:
1692* devIndex - The device sequential number on the board
1693* devType - The device type ( Flash,RTC , etc .. )
1694*
1695* OUTPUT:
1696* None.
1697*
1698* RETURN:
1699* If the device is found on the board the then the functions returns the
1700* dev width else the function returns 0xffffffff
1701*
1702*
1703*******************************************************************************/
1704MV_32 mvBoardGetDeviceWidth(MV_32 devNum, MV_BOARD_DEV_CLASS devClass)
1705{
1706    MV_DEV_CS_INFO* devEntry;
1707    MV_U32 boardId= mvBoardIdGet();
1708
1709    if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
1710    {
1711        mvOsPrintf("Board unknown.\n");
1712        return 0xFFFFFFFF;
1713    }
1714
1715    devEntry = boardGetDevEntry(devNum,devClass);
1716    if (devEntry != NULL)
1717        return devEntry->devWidth;
1718
1719    return MV_ERROR;
1720
1721}
1722
1723/*******************************************************************************
1724* mvBoardGetDeviceWinSize - Get the window size of a device existing on the board
1725*
1726* DESCRIPTION:
1727*
1728* INPUT:
1729* devIndex - The device sequential number on the board
1730* devType - The device type ( Flash,RTC , etc .. )
1731*
1732* OUTPUT:
1733* None.
1734*
1735* RETURN:
1736* If the device is found on the board the then the functions returns the
1737* window size else the function returns 0xffffffff
1738*
1739*
1740*******************************************************************************/
1741MV_32 mvBoardGetDeviceWinSize(MV_32 devNum, MV_BOARD_DEV_CLASS devClass)
1742{
1743    MV_DEV_CS_INFO* devEntry;
1744    MV_U32 boardId = mvBoardIdGet();
1745
1746    if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
1747    {
1748        mvOsPrintf("Board unknown.\n");
1749        return 0xFFFFFFFF;
1750    }
1751
1752    devEntry = boardGetDevEntry(devNum,devClass);
1753    if (devEntry != NULL)
1754    {
1755        return mvCpuIfTargetWinSizeGet(DEV_TO_TARGET(devEntry->deviceCS));
1756    }
1757
1758    return 0xFFFFFFFF;
1759}
1760
1761
1762/*******************************************************************************
1763* boardGetDevEntry - returns the entry pointer of a device on the board
1764*
1765* DESCRIPTION:
1766*
1767* INPUT:
1768* devIndex - The device sequential number on the board
1769* devType - The device type ( Flash,RTC , etc .. )
1770*
1771* OUTPUT:
1772* None.
1773*
1774* RETURN:
1775* If the device is found on the board the then the functions returns the
1776* dev number else the function returns 0x0
1777*
1778*
1779*******************************************************************************/
1780static MV_DEV_CS_INFO* boardGetDevEntry(MV_32 devNum, MV_BOARD_DEV_CLASS devClass)
1781{
1782    MV_U32 foundIndex=0,devIndex;
1783    MV_U32 boardId= mvBoardIdGet();
1784
1785    if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
1786    {
1787        mvOsPrintf("boardGetDevEntry: Board unknown.\n");
1788        return NULL;
1789
1790    }
1791
1792    for (devIndex = START_DEV_CS; devIndex < BOARD_INFO(boardId)->numBoardDeviceIf; devIndex++)
1793    {
1794        /* TBR */
1795        /*if (BOARD_INFO(boardId)->pDevCsInfo[devIndex].deviceCS == MV_BOOTDEVICE_INDEX)
1796             continue;*/
1797
1798        if (BOARD_INFO(boardId)->pDevCsInfo[devIndex].devClass == devClass)
1799        {
1800                    if (foundIndex == devNum)
1801            {
1802                return &(BOARD_INFO(boardId)->pDevCsInfo[devIndex]);
1803            }
1804            foundIndex++;
1805        }
1806    }
1807
1808    /* device not found */
1809    return NULL;
1810}
1811
1812/* Get device CS number */
1813
1814MV_U32 boardGetDevCSNum(MV_32 devNum, MV_BOARD_DEV_CLASS devClass)
1815{
1816    MV_DEV_CS_INFO* devEntry;
1817    MV_U32 boardId= mvBoardIdGet();
1818
1819    if (!((boardId >= BOARD_ID_BASE)&&(boardId < MV_MAX_BOARD_ID)))
1820    {
1821        mvOsPrintf("Board unknown.\n");
1822        return 0xFFFFFFFF;
1823
1824    }
1825
1826
1827    devEntry = boardGetDevEntry(devNum,devClass);
1828    if (devEntry != NULL)
1829        return devEntry->deviceCS;
1830
1831    return 0xFFFFFFFF;
1832
1833}
1834
1835/*******************************************************************************
1836* mvBoardRtcTwsiAddrTypeGet -
1837*
1838* DESCRIPTION:
1839*
1840* INPUT:
1841*
1842* OUTPUT:
1843* None.
1844*
1845* RETURN:
1846*
1847*
1848*******************************************************************************/
1849MV_U8 mvBoardRtcTwsiAddrTypeGet()
1850{
1851    int i;
1852    MV_U32 boardId= mvBoardIdGet();
1853
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;
1857    return (MV_ERROR);
1858}
1859
1860/*******************************************************************************
1861* mvBoardRtcTwsiAddrGet -
1862*
1863* DESCRIPTION:
1864*
1865* INPUT:
1866*
1867* OUTPUT:
1868* None.
1869*
1870* RETURN:
1871*
1872*
1873*******************************************************************************/
1874MV_U8 mvBoardRtcTwsiAddrGet()
1875{
1876    int i;
1877    MV_U32 boardId= mvBoardIdGet();
1878
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;
1882    return (0xFF);
1883}
1884
1885/*******************************************************************************
1886* mvBoardA2DTwsiAddrTypeGet -
1887*
1888* DESCRIPTION:
1889*
1890* INPUT:
1891*
1892* OUTPUT:
1893* None.
1894*
1895* RETURN:
1896*
1897*
1898*******************************************************************************/
1899MV_U8 mvBoardA2DTwsiAddrTypeGet()
1900{
1901    int i;
1902    MV_U32 boardId= mvBoardIdGet();
1903
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;
1907    return (MV_ERROR);
1908}
1909
1910/*******************************************************************************
1911* mvBoardA2DTwsiAddrGet -
1912*
1913* DESCRIPTION:
1914*
1915* INPUT:
1916*
1917* OUTPUT:
1918* None.
1919*
1920* RETURN:
1921*
1922*
1923*******************************************************************************/
1924MV_U8 mvBoardA2DTwsiAddrGet()
1925{
1926    int i;
1927    MV_U32 boardId= mvBoardIdGet();
1928
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;
1932    return (0xFF);
1933}
1934
1935/*******************************************************************************
1936* mvBoardTwsiExpAddrTypeGet -
1937*
1938* DESCRIPTION:
1939*
1940* INPUT:
1941*
1942* OUTPUT:
1943* None.
1944*
1945* RETURN:
1946*
1947*
1948*******************************************************************************/
1949MV_U8 mvBoardTwsiExpAddrTypeGet(MV_U32 index)
1950{
1951    int i;
1952    MV_U32 indexFound = 0;
1953    MV_U32 boardId= mvBoardIdGet();
1954
1955    for (i = 0; i < BOARD_INFO(boardId)->numBoardTwsiDev; i++)
1956        if (BOARD_INFO(boardId)->pBoardTwsiDev[i].devClass == BOARD_DEV_TWSI_EXP)
1957        {
1958            if (indexFound == index)
1959                return BOARD_INFO(boardId)->pBoardTwsiDev[i].twsiDevAddrType;
1960            else
1961                indexFound++;
1962        }
1963
1964    return (MV_ERROR);
1965}
1966
1967/*******************************************************************************
1968* mvBoardTwsiExpAddrGet -
1969*
1970* DESCRIPTION:
1971*
1972* INPUT:
1973*
1974* OUTPUT:
1975* None.
1976*
1977* RETURN:
1978*
1979*
1980*******************************************************************************/
1981MV_U8 mvBoardTwsiExpAddrGet(MV_U32 index)
1982{
1983    int i;
1984    MV_U32 indexFound = 0;
1985    MV_U32 boardId= mvBoardIdGet();
1986
1987    for (i = 0; i < BOARD_INFO(boardId)->numBoardTwsiDev; i++)
1988        if (BOARD_INFO(boardId)->pBoardTwsiDev[i].devClass == BOARD_DEV_TWSI_EXP)
1989        {
1990            if (indexFound == index)
1991                return BOARD_INFO(boardId)->pBoardTwsiDev[i].twsiDevAddr;
1992            else
1993                indexFound++;
1994        }
1995
1996    return (0xFF);
1997}
1998
1999
2000/*******************************************************************************
2001* mvBoardTwsiSatRAddrTypeGet -
2002*
2003* DESCRIPTION:
2004*
2005* INPUT:
2006*
2007* OUTPUT:
2008* None.
2009*
2010* RETURN:
2011*
2012*
2013*******************************************************************************/
2014MV_U8 mvBoardTwsiSatRAddrTypeGet(MV_U32 index)
2015{
2016    int i;
2017    MV_U32 indexFound = 0;
2018    MV_U32 boardId= mvBoardIdGet();
2019
2020    for (i = 0; i < BOARD_INFO(boardId)->numBoardTwsiDev; i++)
2021        if (BOARD_INFO(boardId)->pBoardTwsiDev[i].devClass == BOARD_DEV_TWSI_SATR)
2022        {
2023            if (indexFound == index)
2024                return BOARD_INFO(boardId)->pBoardTwsiDev[i].twsiDevAddrType;
2025            else
2026                indexFound++;
2027        }
2028
2029    return (MV_ERROR);
2030}
2031
2032/*******************************************************************************
2033* mvBoardTwsiSatRAddrGet -
2034*
2035* DESCRIPTION:
2036*
2037* INPUT:
2038*
2039* OUTPUT:
2040* None.
2041*
2042* RETURN:
2043*
2044*
2045*******************************************************************************/
2046MV_U8 mvBoardTwsiSatRAddrGet(MV_U32 index)
2047{
2048    int i;
2049    MV_U32 indexFound = 0;
2050    MV_U32 boardId= mvBoardIdGet();
2051
2052    for (i = 0; i < BOARD_INFO(boardId)->numBoardTwsiDev; i++)
2053        if (BOARD_INFO(boardId)->pBoardTwsiDev[i].devClass == BOARD_DEV_TWSI_SATR)
2054        {
2055            if (indexFound == index)
2056                return BOARD_INFO(boardId)->pBoardTwsiDev[i].twsiDevAddr;
2057            else
2058                indexFound++;
2059        }
2060
2061    return (0xFF);
2062}
2063
2064/*******************************************************************************
2065* mvBoardNandWidthGet -
2066*
2067* DESCRIPTION: Get the width of the first NAND device in byte.
2068*
2069* INPUT:
2070*
2071* OUTPUT:
2072* None.
2073*
2074* RETURN: 1, 2, 4 or MV_ERROR
2075*
2076*
2077*******************************************************************************/
2078/* */
2079MV_32 mvBoardNandWidthGet(void)
2080{
2081    MV_U32 devNum;
2082    MV_U32 devWidth;
2083    MV_U32 boardId= mvBoardIdGet();
2084
2085    for (devNum = START_DEV_CS; devNum < BOARD_INFO(boardId)->numBoardDeviceIf; devNum++)
2086    {
2087        devWidth = mvBoardGetDeviceWidth(devNum, BOARD_DEV_NAND_FLASH);
2088        if (devWidth != MV_ERROR)
2089            return (devWidth / 8);
2090    }
2091        
2092    /* NAND wasn't found */
2093    return MV_ERROR;
2094}
2095
2096MV_U32 gBoardId = -1;
2097
2098/*******************************************************************************
2099* mvBoardIdGet - Get Board model
2100*
2101* DESCRIPTION:
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.
2105*
2106* INPUT:
2107* None.
2108*
2109* OUTPUT:
2110* None.
2111*
2112* RETURN:
2113* 32bit board ID number, '-1' if board is undefined.
2114*
2115*******************************************************************************/
2116MV_U32 mvBoardIdGet(MV_VOID)
2117{
2118    MV_U32 tmpBoardId = -1;
2119
2120    if(gBoardId == -1)
2121        {
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;
2142        #endif
2143        gBoardId = tmpBoardId;
2144    }
2145
2146    return gBoardId;
2147}
2148
2149
2150/*******************************************************************************
2151* mvBoarModuleTypeGet - mvBoarModuleTypeGet
2152*
2153* DESCRIPTION:
2154*
2155* INPUT:
2156* group num - MV_BOARD_MPP_GROUP_CLASS enum
2157*
2158* OUTPUT:
2159* None.
2160*
2161* RETURN:
2162* module num - MV_BOARD_MODULE_CLASS enum
2163*
2164*******************************************************************************/
2165MV_BOARD_MODULE_ID_CLASS mvBoarModuleTypeGet(MV_BOARD_MPP_GROUP_CLASS devClass)
2166{
2167        MV_TWSI_SLAVE twsiSlave;
2168    MV_TWSI_ADDR slave;
2169        MV_U8 data;
2170
2171    /* TWSI init */
2172    slave.type = ADDR7_BIT;
2173    slave.address = 0;
2174    mvTwsiInit(0, TWSI_SPEED, mvBoardTclkGet(), &slave, 0);
2175
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;
2185
2186
2187
2188        if( MV_OK != mvTwsiRead (0, &twsiSlave, &data, 1) )
2189        {
2190            DB(mvOsPrintf("Board: Read MPP module ID fail\n"));
2191            return MV_ERROR;
2192        }
2193        DB(mvOsPrintf("Board: Read MPP module ID succeded\n"));
2194    
2195    return data;
2196}
2197
2198/*******************************************************************************
2199* mvBoarTwsiSatRGet -
2200*
2201* DESCRIPTION:
2202*
2203* INPUT:
2204* device num - one of three devices
2205* reg num - 0 or 1
2206*
2207* OUTPUT:
2208* None.
2209*
2210* RETURN:
2211* reg value
2212*
2213*******************************************************************************/
2214MV_U8 mvBoarTwsiSatRGet(MV_U8 devNum, MV_U8 regNum)
2215{
2216        MV_TWSI_SLAVE twsiSlave;
2217    MV_TWSI_ADDR slave;
2218        MV_U8 data;
2219
2220    /* TWSI init */
2221    slave.type = ADDR7_BIT;
2222    slave.address = 0;
2223    mvTwsiInit(0, TWSI_SPEED, mvBoardTclkGet(), &slave, 0);
2224
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;
2233
2234        if( MV_OK != mvTwsiRead (0, &twsiSlave, &data, 1) )
2235        {
2236            DB(mvOsPrintf("Board: Read S@R fail\n"));
2237            return MV_ERROR;
2238        }
2239        DB(mvOsPrintf("Board: Read S@R succeded\n"));
2240    
2241    return data;
2242}
2243
2244/*******************************************************************************
2245* mvBoarTwsiSatRSet -
2246*
2247* DESCRIPTION:
2248*
2249* INPUT:
2250* devNum - one of three devices
2251* regNum - 0 or 1
2252* regVal - value
2253*
2254*
2255* OUTPUT:
2256* None.
2257*
2258* RETURN:
2259* reg value
2260*
2261*******************************************************************************/
2262MV_STATUS mvBoarTwsiSatRSet(MV_U8 devNum, MV_U8 regNum, MV_U8 regVal)
2263{
2264        MV_TWSI_SLAVE twsiSlave;
2265    MV_TWSI_ADDR slave;
2266    
2267    /* TWSI init */
2268    slave.type = ADDR7_BIT;
2269    slave.address = 0;
2270    mvTwsiInit(0, TWSI_SPEED, mvBoardTclkGet(), &slave, 0);
2271
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, &regVal, 1) )
2282        {
2283            DB(mvOsPrintf("Board: Write S@R fail\n"));
2284            return MV_ERROR;
2285        }
2286        DB(mvOsPrintf("Board: Write S@R succeded\n"));
2287    
2288    return MV_OK;
2289}
2290
2291/*******************************************************************************
2292* mvBoardSlicGpioPinGet -
2293*
2294* DESCRIPTION:
2295*
2296* INPUT:
2297*
2298* OUTPUT:
2299* None.
2300*
2301* RETURN:
2302*
2303*
2304*******************************************************************************/
2305MV_32 mvBoardSlicGpioPinGet(MV_U32 slicNum)
2306{
2307    MV_U32 boardId;
2308    boardId = mvBoardIdGet();
2309
2310    switch (boardId)
2311    {
2312    case DB_88F6281A_BP_ID:
2313    case RD_88F6281A_ID:
2314    default:
2315        return MV_ERROR;
2316        break;
2317
2318    }
2319}
2320
2321/*******************************************************************************
2322* mvBoardFanPowerControl - Turn on/off the fan power control on the RD-6281A
2323*
2324* DESCRIPTION:
2325*
2326* INPUT:
2327* mode - MV_TRUE = on ; MV_FALSE = off
2328*
2329* OUTPUT:
2330* MV_STATUS - MV_OK , MV_ERROR.
2331*
2332* RETURN:
2333*
2334*******************************************************************************/
2335MV_STATUS mvBoardFanPowerControl(MV_BOOL mode)
2336{
2337
2338    MV_U8 val = 1, twsiVal;
2339       MV_TWSI_SLAVE twsiSlave;
2340    MV_TWSI_ADDR slave;
2341    
2342    if(mvBoardIdGet() != RD_88F6281A_ID)
2343        return MV_ERROR;
2344
2345    /* TWSI init */
2346    slave.type = ADDR7_BIT;
2347    slave.address = 0;
2348    mvTwsiInit(0, TWSI_SPEED, mvBoardTclkGet(), &slave, 0);
2349
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;
2359        if(mode == MV_TRUE)
2360            val = 0x1;
2361        else
2362            val = 0;
2363        mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
2364        val = (twsiVal & 0xfe) | val;
2365
2366        if( MV_OK != mvTwsiWrite (0, &twsiSlave, &val, 1) )
2367        {
2368            DB(mvOsPrintf("Board: twsi exp out val fail\n"));
2369            return MV_ERROR;
2370        }
2371        DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
2372        
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) )
2378        {
2379            DB(mvOsPrintf("Board: twsi exp change to out fail\n"));
2380            return MV_ERROR;
2381        }
2382        DB(mvOsPrintf("Board: twsi exp change to out succeded\n"));
2383        return MV_OK;
2384}
2385
2386/*******************************************************************************
2387* mvBoardHDDPowerControl - Turn on/off the HDD power control on the RD-6281A
2388*
2389* DESCRIPTION:
2390*
2391* INPUT:
2392* mode - MV_TRUE = on ; MV_FALSE = off
2393*
2394* OUTPUT:
2395* MV_STATUS - MV_OK , MV_ERROR.
2396*
2397* RETURN:
2398*
2399*******************************************************************************/
2400MV_STATUS mvBoardHDDPowerControl(MV_BOOL mode)
2401{
2402
2403    MV_U8 val = 1, twsiVal;
2404       MV_TWSI_SLAVE twsiSlave;
2405    MV_TWSI_ADDR slave;
2406    
2407    if(mvBoardIdGet() != RD_88F6281A_ID)
2408        return MV_ERROR;
2409
2410    /* TWSI init */
2411    slave.type = ADDR7_BIT;
2412    slave.address = 0;
2413    mvTwsiInit(0, TWSI_SPEED, mvBoardTclkGet(), &slave, 0);
2414
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;
2424        if(mode == MV_TRUE)
2425            val = 0x2;
2426        else
2427            val = 0;
2428        mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
2429        val = (twsiVal & 0xfd) | val;
2430        if( MV_OK != mvTwsiWrite (0, &twsiSlave, &val, 1) )
2431        {
2432            DB(mvOsPrintf("Board: twsi exp out val fail\n"));
2433            return MV_ERROR;
2434        }
2435        DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
2436        
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) )
2442        {
2443            DB(mvOsPrintf("Board: twsi exp change to out fail\n"));
2444            return MV_ERROR;
2445        }
2446        DB(mvOsPrintf("Board: twsi exp change to out succeded\n"));
2447        return MV_OK;
2448}
2449
2450/*******************************************************************************
2451* mvBoardSDioWPControl - Turn on/off the SDIO WP on the RD-6281A
2452*
2453* DESCRIPTION:
2454*
2455* INPUT:
2456* mode - MV_TRUE = on ; MV_FALSE = off
2457*
2458* OUTPUT:
2459* MV_STATUS - MV_OK , MV_ERROR.
2460*
2461* RETURN:
2462*
2463*******************************************************************************/
2464MV_STATUS mvBoardSDioWPControl(MV_BOOL mode)
2465{
2466
2467    MV_U8 val = 1, twsiVal;
2468       MV_TWSI_SLAVE twsiSlave;
2469    MV_TWSI_ADDR slave;
2470    
2471    if(mvBoardIdGet() != RD_88F6281A_ID)
2472        return MV_ERROR;
2473
2474    /* TWSI init */
2475    slave.type = ADDR7_BIT;
2476    slave.address = 0;
2477    mvTwsiInit(0, TWSI_SPEED, mvBoardTclkGet(), &slave, 0);
2478
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;
2488        if(mode == MV_TRUE)
2489            val = 0x10;
2490        else
2491            val = 0;
2492        mvTwsiRead(0, &twsiSlave, &twsiVal, 1);
2493        val = (twsiVal & 0xef) | val;
2494        if( MV_OK != mvTwsiWrite (0, &twsiSlave, &val, 1) )
2495        {
2496            DB(mvOsPrintf("Board: twsi exp out val fail\n"));
2497            return MV_ERROR;
2498        }
2499        DB(mvOsPrintf("Board: twsi exp out val succeded\n"));
2500        
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) )
2506        {
2507            DB(mvOsPrintf("Board: twsi exp change to out fail\n"));
2508            return MV_ERROR;
2509        }
2510        DB(mvOsPrintf("Board: twsi exp change to out succeded\n"));
2511        return MV_OK;
2512}
2513
2514

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive