Root/target/linux/generic/files/crypto/ocf/kirkwood/mvHal/kw_family/ctrlEnv/sys/mvSysXor.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 "xor/mvXor.h"
66#include "mvSysXor.h"
67
68/* defines */
69#ifdef MV_DEBUG
70    #define DB(x) x
71#else
72    #define DB(x)
73#endif
74
75
76static MV_STATUS xorWinOverlapDetect(MV_U32 unit,MV_U32 winNum, MV_ADDR_WIN *pAddrWin);
77
78MV_TARGET xorAddrDecPrioTap[] =
79{
80#if defined(MV_INCLUDE_DEVICE_CS0)
81    DEVICE_CS0,
82#endif
83#if defined(MV_INCLUDE_PEX)
84    PEX0_MEM,
85#endif
86#if defined(MV_INCLUDE_SDRAM_CS0)
87    SDRAM_CS0,
88#endif
89#if defined(MV_INCLUDE_SDRAM_CS1)
90    SDRAM_CS1,
91#endif
92#if defined(MV_INCLUDE_SDRAM_CS2)
93    SDRAM_CS2,
94#endif
95#if defined(MV_INCLUDE_SDRAM_CS3)
96    SDRAM_CS3,
97#endif
98#if defined(MV_INCLUDE_DEVICE_CS1)
99    DEVICE_CS1,
100#endif
101#if defined(MV_INCLUDE_CESA)
102   CRYPT_ENG,
103#endif
104    TBL_TERM
105};
106static MV_STATUS mvXorInitWinsUnit (MV_U32 unit)
107{
108    MV_U32 winNum;
109    MV_XOR_DEC_WIN addrDecWin;
110    MV_CPU_DEC_WIN cpuAddrDecWin;
111    MV_U32 status;
112    MV_U32 winPrioIndex=0;
113
114    /* Initiate XOR address decode */
115
116    /* First disable all address decode windows */
117    for(winNum = 0; winNum < XOR_MAX_ADDR_DEC_WIN; winNum++)
118    {
119        mvXorTargetWinEnable(unit,winNum, MV_FALSE);
120    }
121    
122    /* Go through all windows in user table until table terminator */
123    for (winNum = 0; ((xorAddrDecPrioTap[winPrioIndex] != TBL_TERM) &&
124                    (winNum < XOR_MAX_ADDR_DEC_WIN));)
125    {
126        /* first get attributes from CPU If */
127        status = mvCpuIfTargetWinGet(xorAddrDecPrioTap[winPrioIndex],
128                                     &cpuAddrDecWin);
129
130        if(MV_NO_SUCH == status)
131        {
132            winPrioIndex++;
133            continue;
134        }
135        if (MV_OK != status)
136        {
137            mvOsPrintf("%s: ERR. mvCpuIfTargetWinGet failed\n", __FUNCTION__);
138            return MV_ERROR;
139        }
140
141    
142        if (cpuAddrDecWin.enable == MV_TRUE)
143        {
144
145            addrDecWin.target = xorAddrDecPrioTap[winPrioIndex];
146            addrDecWin.addrWin.baseLow = cpuAddrDecWin.addrWin.baseLow;
147            addrDecWin.addrWin.baseHigh = cpuAddrDecWin.addrWin.baseHigh;
148            addrDecWin.addrWin.size = cpuAddrDecWin.addrWin.size;
149            addrDecWin.enable = MV_TRUE;
150    
151            if (MV_OK != mvXorTargetWinSet(unit,winNum, &addrDecWin))
152            {
153                DB(mvOsPrintf("mvXorInit: ERR. mvDmaTargetWinSet failed\n"));
154                return MV_ERROR;
155            }
156            winNum++;
157        }
158        winPrioIndex++;
159        
160    }
161    
162    return MV_OK;
163}
164
165
166/*******************************************************************************
167* mvXorInit - Initialize XOR engine
168*
169* DESCRIPTION:
170* This function initialize XOR unit. It set the default address decode
171* windows of the unit.
172* Note that if the address window is disabled in xorAddrDecMap, the
173* window parameters will be set but the window will remain disabled.
174*
175* INPUT:
176* None.
177*
178* OUTPUT:
179* None.
180*
181* RETURN:
182* MV_BAD_PARAM if parameters to function invalid, MV_OK otherwise.
183*******************************************************************************/
184MV_STATUS mvXorInit (MV_VOID)
185{
186    MV_U32 i;
187
188    /* Initiate XOR address decode */
189    for(i = 0; i < MV_XOR_MAX_UNIT; i++)
190        mvXorInitWinsUnit(i);
191
192    mvXorHalInit(MV_XOR_MAX_CHAN);
193    
194    return MV_OK;
195}
196
197/*******************************************************************************
198* mvXorTargetWinSet - Set XOR target address window
199*
200* DESCRIPTION:
201* This function sets a peripheral target (e.g. SDRAM bank0, PCI_MEM0)
202* address window. After setting this target window, the XOR will be
203* able to access the target within the address window.
204*
205* INPUT:
206* winNum - One of the possible XOR memory decode windows.
207* target - Peripheral target enumerator.
208* base - Window base address.
209* size - Window size.
210* enable - Window enable/disable.
211*
212* OUTPUT:
213* None.
214*
215* RETURN:
216* MV_BAD_PARAM if parameters to function invalid, MV_OK otherwise.
217*
218*******************************************************************************/
219MV_STATUS mvXorTargetWinSet(MV_U32 unit, MV_U32 winNum, MV_XOR_DEC_WIN *pAddrDecWin)
220{
221    MV_DEC_REGS xorDecRegs;
222    MV_TARGET_ATTRIB targetAttribs;
223    MV_U32 chan;
224    
225    /* Parameter checking */
226    if (winNum >= XOR_MAX_ADDR_DEC_WIN)
227    {
228        DB(mvOsPrintf("%s: ERR. Invalid win num %d\n",__FUNCTION__, winNum));
229        return MV_BAD_PARAM;
230    }
231    if (pAddrDecWin == NULL)
232    {
233        DB(mvOsPrintf("%s: ERR. pAddrDecWin is NULL pointer\n", __FUNCTION__ ));
234        return MV_BAD_PTR;
235    }
236    /* Check if the requested window overlaps with current windows */
237    if (MV_TRUE == xorWinOverlapDetect(unit, winNum, &pAddrDecWin->addrWin))
238    {
239    DB(mvOsPrintf("%s: ERR. Window %d overlap\n",__FUNCTION__,winNum));
240    return MV_ERROR;
241    }
242
243    xorDecRegs.baseReg = MV_REG_READ(XOR_BASE_ADDR_REG(unit,winNum));
244    xorDecRegs.sizeReg = MV_REG_READ(XOR_SIZE_MASK_REG(unit,winNum));
245
246    /* Get Base Address and size registers values */
247    if(MV_OK != mvCtrlAddrDecToReg(&pAddrDecWin->addrWin, &xorDecRegs))
248    {
249        DB(mvOsPrintf("%s: ERR. Invalid addr dec window\n",__FUNCTION__));
250        return MV_BAD_PARAM;
251    }
252    
253
254    mvCtrlAttribGet(pAddrDecWin->target,&targetAttribs);
255
256    /* set attributes */
257    xorDecRegs.baseReg &= ~XEBARX_ATTR_MASK;
258    xorDecRegs.baseReg |= targetAttribs.attrib << XEBARX_ATTR_OFFS;
259    /* set target ID */
260    xorDecRegs.baseReg &= ~XEBARX_TARGET_MASK;
261    xorDecRegs.baseReg |= targetAttribs.targetId << XEBARX_TARGET_OFFS;
262
263
264    /* Write to address decode Base Address Register */
265    MV_REG_WRITE(XOR_BASE_ADDR_REG(unit,winNum), xorDecRegs.baseReg);
266    
267    /* Write to Size Register */
268    MV_REG_WRITE(XOR_SIZE_MASK_REG(unit,winNum), xorDecRegs.sizeReg);
269    
270    for (chan = 0; chan < MV_XOR_MAX_CHAN_PER_UNIT; chan++)
271    {
272        if (pAddrDecWin->enable)
273        {
274            MV_REG_BIT_SET(XOR_WINDOW_CTRL_REG(unit,chan),
275                           XEXWCR_WIN_EN_MASK(winNum));
276        }
277        else
278        {
279            MV_REG_BIT_RESET(XOR_WINDOW_CTRL_REG(unit,chan),
280                             XEXWCR_WIN_EN_MASK(winNum));
281        }
282    }
283    return MV_OK;
284}
285
286/*******************************************************************************
287* mvXorTargetWinGet - Get xor peripheral target address window.
288*
289* DESCRIPTION:
290* Get xor peripheral target address window.
291*
292* INPUT:
293* winNum - One of the possible XOR memory decode windows.
294*
295* OUTPUT:
296* base - Window base address.
297* size - Window size.
298* enable - window enable/disable.
299*
300* RETURN:
301* MV_BAD_PARAM if parameters to function invalid, MV_OK otherwise.
302*
303*******************************************************************************/
304MV_STATUS mvXorTargetWinGet(MV_U32 unit,MV_U32 winNum, MV_XOR_DEC_WIN *pAddrDecWin)
305{
306    MV_DEC_REGS xorDecRegs;
307    MV_TARGET_ATTRIB targetAttrib;
308    MV_U32 chan=0,chanWinEn;
309    
310    /* Parameter checking */
311    if (winNum >= XOR_MAX_ADDR_DEC_WIN)
312    {
313        DB(mvOsPrintf("%s: ERR. Invalid win num %d\n",__FUNCTION__ , winNum));
314        return MV_ERROR;
315    }
316
317    if (NULL == pAddrDecWin)
318    {
319        DB(mvOsPrintf("%s: ERR. pAddrDecWin is NULL pointer\n", __FUNCTION__ ));
320        return MV_BAD_PTR;
321    }
322
323    chanWinEn = MV_REG_READ(XOR_WINDOW_CTRL_REG(unit,0)) & XEXWCR_WIN_EN_MASK(winNum);
324    
325    for (chan = 0; chan < MV_XOR_MAX_CHAN_PER_UNIT; chan++) /* we should scan here all channels per unit */
326    {
327        /* Check if enable bit is equal for all channels */
328        if ((MV_REG_READ(XOR_WINDOW_CTRL_REG(unit,chan)) &
329             XEXWCR_WIN_EN_MASK(winNum)) != chanWinEn)
330        {
331            mvOsPrintf("%s: ERR. Window enable field must be equal in "
332                              "all channels(chan=%d)\n",__FUNCTION__, chan);
333            return MV_ERROR;
334        }
335    }
336
337
338
339    xorDecRegs.baseReg = MV_REG_READ(XOR_BASE_ADDR_REG(unit,winNum));
340    xorDecRegs.sizeReg = MV_REG_READ(XOR_SIZE_MASK_REG(unit,winNum));
341
342    if (MV_OK != mvCtrlRegToAddrDec(&xorDecRegs, &pAddrDecWin->addrWin))
343    {
344        mvOsPrintf("%s: ERR. mvCtrlRegToAddrDec failed\n", __FUNCTION__);
345        return MV_ERROR;
346    }
347
348    /* attrib and targetId */
349    targetAttrib.attrib =
350        (xorDecRegs.baseReg & XEBARX_ATTR_MASK) >> XEBARX_ATTR_OFFS;
351    targetAttrib.targetId =
352        (xorDecRegs.baseReg & XEBARX_TARGET_MASK) >> XEBARX_TARGET_OFFS;
353
354
355    pAddrDecWin->target = mvCtrlTargetGet(&targetAttrib);
356
357    if(chanWinEn)
358    {
359        pAddrDecWin->enable = MV_TRUE;
360    }
361    else pAddrDecWin->enable = MV_FALSE;
362    
363    return MV_OK;
364}
365
366/*******************************************************************************
367* mvXorTargetWinEnable - Enable/disable a Xor address decode window
368*
369* DESCRIPTION:
370* This function enable/disable a XOR address decode window.
371* if parameter 'enable' == MV_TRUE the routine will enable the
372* window, thus enabling XOR accesses (before enabling the window it is
373* tested for overlapping). Otherwise, the window will be disabled.
374*
375* INPUT:
376* winNum - Decode window number.
377* enable - Enable/disable parameter.
378*
379* OUTPUT:
380* None.
381*
382* RETURN:
383* MV_BAD_PARAM if parameters to function invalid, MV_OK otherwise.
384*
385*******************************************************************************/
386MV_STATUS mvXorTargetWinEnable(MV_U32 unit,MV_U32 winNum, MV_BOOL enable)
387{
388    MV_XOR_DEC_WIN addrDecWin;
389    MV_U32 chan;
390    
391    /* Parameter checking */
392    if (winNum >= XOR_MAX_ADDR_DEC_WIN)
393    {
394        DB(mvOsPrintf("%s: ERR. Invalid winNum%d\n", __FUNCTION__, winNum));
395        return MV_ERROR;
396    }
397
398    if (enable == MV_TRUE)
399    {
400        /* Get current window */
401        if (MV_OK != mvXorTargetWinGet(unit,winNum, &addrDecWin))
402        {
403            DB(mvOsPrintf("%s: ERR. targetWinGet fail\n", __FUNCTION__));
404            return MV_ERROR;
405        }
406
407        /* Check for overlapping */
408        if (MV_TRUE == xorWinOverlapDetect(unit,winNum, &(addrDecWin.addrWin)))
409        {
410            /* Overlap detected */
411            DB(mvOsPrintf("%s: ERR. Overlap detected\n", __FUNCTION__));
412            return MV_ERROR;
413        }
414
415        /* No Overlap. Enable address decode target window */
416        for (chan = 0; chan < MV_XOR_MAX_CHAN_PER_UNIT; chan++)
417        {
418            MV_REG_BIT_SET(XOR_WINDOW_CTRL_REG(unit,chan),
419                           XEXWCR_WIN_EN_MASK(winNum));
420        }
421
422    }
423    else
424    {
425        /* Disable address decode target window */
426
427        for (chan = 0; chan < MV_XOR_MAX_CHAN_PER_UNIT; chan++)
428        {
429            MV_REG_BIT_RESET(XOR_WINDOW_CTRL_REG(unit,chan),
430                             XEXWCR_WIN_EN_MASK(winNum));
431        }
432
433    }
434
435    return MV_OK;
436}
437
438/*******************************************************************************
439* mvXorSetProtWinSet - Configure access attributes of a XOR engine
440* to one of the XOR memory windows.
441*
442* DESCRIPTION:
443* Each engine can be configured with access attributes for each of the
444* memory spaces. This function sets access attributes
445* to a given window for the given engine
446*
447* INPUTS:
448* chan - One of the possible engines.
449* winNum - One of the possible XOR memory spaces.
450* access - Protection access rights.
451* write - Write rights.
452*
453* OUTPUT:
454* None.
455*
456* RETURN:
457* MV_BAD_PARAM if parameters to function invalid, MV_OK otherwise.
458*
459*******************************************************************************/
460MV_STATUS mvXorProtWinSet (MV_U32 unit,MV_U32 chan, MV_U32 winNum, MV_BOOL access,
461                           MV_BOOL write)
462{
463    MV_U32 temp;
464    
465    /* Parameter checking */
466    if (chan >= MV_XOR_MAX_CHAN_PER_UNIT)
467    {
468        DB(mvOsPrintf("%s: ERR. Invalid chan num %d\n", __FUNCTION__ , chan));
469        return MV_BAD_PARAM;
470    }
471    if (winNum >= XOR_MAX_ADDR_DEC_WIN)
472    {
473        DB(mvOsPrintf("%s: ERR. Invalid win num %d\n", __FUNCTION__, winNum));
474        return MV_BAD_PARAM;
475    }
476
477    temp = MV_REG_READ(XOR_WINDOW_CTRL_REG(unit,chan)) &
478        (~XEXWCR_WIN_ACC_MASK(winNum));
479
480    /* if access is disable */
481    if (!access)
482    {
483        /* disable access */
484        temp |= XEXWCR_WIN_ACC_NO_ACC(winNum);
485    }
486    /* if access is enable */
487    else
488    {
489        /* if write is enable */
490        if (write)
491        {
492            /* enable write */
493            temp |= XEXWCR_WIN_ACC_RW(winNum);
494        }
495        /* if write is disable */
496        else
497        {
498            /* disable write */
499            temp |= XEXWCR_WIN_ACC_RO(winNum);
500        }
501    }
502    MV_REG_WRITE(XOR_WINDOW_CTRL_REG(unit,chan),temp);
503    return MV_OK;
504}
505
506/*******************************************************************************
507* mvXorPciRemap - Set XOR remap register for PCI address windows.
508*
509* DESCRIPTION:
510* only Windows 0-3 can be remapped.
511*
512* INPUT:
513* winNum - window number
514* pAddrDecWin - pointer to address space window structure
515* OUTPUT:
516* None.
517*
518* RETURN:
519* MV_BAD_PARAM if parameters to function invalid, MV_OK otherwise.
520*
521*******************************************************************************/
522MV_STATUS mvXorPciRemap(MV_U32 unit,MV_U32 winNum, MV_U32 addrHigh)
523{
524    /* Parameter checking */
525    if (winNum >= XOR_MAX_REMAP_WIN)
526    {
527        DB(mvOsPrintf("%s: ERR. Invalid win num %d\n", __FUNCTION__, winNum));
528        return MV_BAD_PARAM;
529    }
530
531    MV_REG_WRITE(XOR_HIGH_ADDR_REMAP_REG(unit,winNum), addrHigh);
532    
533    return MV_OK;
534}
535
536/*******************************************************************************
537* xorWinOverlapDetect - Detect XOR address windows overlaping
538*
539* DESCRIPTION:
540* An unpredicted behaviour is expected in case XOR address decode
541* windows overlaps.
542* This function detects XOR address decode windows overlaping of a
543* specified window. The function does not check the window itself for
544* overlaping. The function also skipps disabled address decode windows.
545*
546* INPUT:
547* winNum - address decode window number.
548* pAddrDecWin - An address decode window struct.
549*
550* OUTPUT:
551* None.
552*
553* RETURN:
554* MV_TRUE if the given address window overlap current address
555* decode map, MV_FALSE otherwise, MV_ERROR if reading invalid data
556* from registers.
557*
558*******************************************************************************/
559static MV_STATUS xorWinOverlapDetect(MV_U32 unit,MV_U32 winNum, MV_ADDR_WIN *pAddrWin)
560{
561    MV_U32 baseAddrEnableReg;
562    MV_U32 winNumIndex,chan;
563    MV_XOR_DEC_WIN addrDecWin;
564
565    if (pAddrWin == NULL)
566    {
567        DB(mvOsPrintf("%s: ERR. pAddrWin is NULL pointer\n", __FUNCTION__ ));
568        return MV_BAD_PTR;
569    }
570    
571    for (chan = 0; chan < MV_XOR_MAX_CHAN_PER_UNIT; chan++)
572    {
573        /* Read base address enable register. Do not check disabled windows */
574        baseAddrEnableReg = MV_REG_READ(XOR_WINDOW_CTRL_REG(unit,chan));
575
576        for (winNumIndex = 0; winNumIndex < XOR_MAX_ADDR_DEC_WIN; winNumIndex++)
577        {
578            /* Do not check window itself */
579            if (winNumIndex == winNum)
580            {
581                continue;
582            }
583    
584            /* Do not check disabled windows */
585            if ((baseAddrEnableReg & XEXWCR_WIN_EN_MASK(winNumIndex)) == 0)
586            {
587                continue;
588            }
589    
590            /* Get window parameters */
591            if (MV_OK != mvXorTargetWinGet(unit,winNumIndex, &addrDecWin))
592            {
593                DB(mvOsPrintf("%s: ERR. TargetWinGet failed\n", __FUNCTION__ ));
594                return MV_ERROR;
595            }
596            
597            if (MV_TRUE == ctrlWinOverlapTest(pAddrWin, &(addrDecWin.addrWin)))
598            {
599                return MV_TRUE;
600            }
601        }
602    }
603    
604    return MV_FALSE;
605}
606
607static MV_VOID mvXorAddrDecShowUnit(MV_U32 unit)
608{
609    MV_XOR_DEC_WIN win;
610    int i;
611
612    mvOsOutput( "\n" );
613    mvOsOutput( "XOR %d:\n", unit );
614    mvOsOutput( "----\n" );
615
616    for( i = 0; i < XOR_MAX_ADDR_DEC_WIN; i++ )
617    {
618        memset( &win, 0, sizeof(MV_XOR_DEC_WIN) );
619
620        mvOsOutput( "win%d - ", i );
621
622        if( mvXorTargetWinGet(unit, i, &win ) == MV_OK )
623        {
624            if( win.enable )
625            {
626                mvOsOutput( "%s base %x, ",
627                mvCtrlTargetNameGet(win.target), win.addrWin.baseLow );
628
629                mvSizePrint( win.addrWin.size );
630                
631                mvOsOutput( "\n" );
632            }
633            else
634                mvOsOutput( "disable\n" );
635        }
636    }
637}
638
639/*******************************************************************************
640* mvXorAddrDecShow - Print the XOR address decode map.
641*
642* DESCRIPTION:
643* This function print the XOR address decode map.
644*
645* INPUT:
646* None.
647*
648* OUTPUT:
649* None.
650*
651* RETURN:
652* None.
653*
654*******************************************************************************/
655MV_VOID mvXorAddrDecShow(MV_VOID)
656{
657    int i;
658
659    for( i = 0; i < MV_XOR_MAX_UNIT; i++ )
660        mvXorAddrDecShowUnit(i);
661    
662}
663

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