source: svn/trunk/newcon3bcm2_21bu/magnum/commonutils/mrc/7552/bmrc.c @ 32

Last change on this file since 32 was 2, checked in by jglee, 11 years ago

first commit
  • Property svn:executable set to *
File size: 39.8 KB
Line 
1/***************************************************************************
2 *     Copyright (c) 2003-2011, Broadcom Corporation
3 *     All Rights Reserved
4 *     Confidential Property of Broadcom Corporation
5 *
6 *  THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
7 *  AGREEMENT  BETWEEN THE USER AND BROADCOM.  YOU HAVE NO RIGHT TO USE OR
8 *  EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
9 *
10 * $brcm_Workfile: bmrc.c $
11 * $brcm_Revision: Hydra_Software_Devel/57 $
12 * $brcm_Date: 6/22/11 2:54p $
13 *
14 * Module Description:
15 *
16 * Revision History:
17 *
18 * $brcm_Log: /magnum/commonutils/mrc/7038/bmrc.c $
19 *
20 * Hydra_Software_Devel/57   6/22/11 2:54p albertl
21 * SW7405-5349: Changed to prevent MRC from making unnecessary register
22 * writes if values have not changed.
23 *
24 * Hydra_Software_Devel/56   1/5/11 9:15p albertl
25 * SW7422-106, SW7422-168: Fixed macros for chips with less than 2 MEMCs.
26 *
27 * Hydra_Software_Devel/55   1/5/11 8:15p albertl
28 * SW7422-106, SW7422-168: Fixed MRC bugs pertaining to handling multiple
29 * MEMCs and rewrote portions of BMRC_Monitor logic.  Client masks now
30 * stored to match hardware.
31 *
32 * Hydra_Software_Devel/54   12/29/10 3:18p pntruong
33 * SW7422-168: Remove bogus warning msg.
34 *
35 * Hydra_Software_Devel/53   11/12/10 1:22p albertl
36 * SW7125-27: Rolled back wrong error checking change and moved assert
37 * after error checking.
38 *
39 * Hydra_Software_Devel/52   10/29/10 2:25p albertl
40 * SW7125-27: Fixed to check eClient against BMRC_Client_eInvalid instead
41 * of ulClientsIdx.
42 *
43 * Hydra_Software_Devel/51   3/2/10 1:23p erickson
44 * SW7405-3892: convert #if and stale 3563 comment. clean up
45 * BMRC_Checker_GetClientInfo failure.
46 *
47 * Hydra_Software_Devel/50   6/16/09 6:21p albertl
48 * PR55764, PR55875, PR55993: Refactored MRC to keep chip specific
49 * definitions in bmrc_priv.h and for maintainability.  Updated support
50 * for 7420 b0, 7430, 35130, and 7550.
51 *
52 * Hydra_Software_Devel/49   6/4/09 7:05p albertl
53 * PR55641: Allowed MRC to report maximum number of checkers and changed
54 * BMRC_Monitor to use that instead of hardcoded maximums.
55 *
56 * Hydra_Software_Devel/48   4/23/09 2:42p jhaberf
57 * PR53796: Added support for BCM35130 DTV chip
58 *
59 * Hydra_Software_Devel/47   4/16/09 2:54p nickh
60 * PR54264: Add mrc for 7420 - 4 arc checkers for MEMC0 and 4 arc checkers
61 * for MEMC1
62 *
63 * Hydra_Software_Devel/46   4/9/09 6:33p jrubio
64 * PR36876: 7335/7325/7336 have 4 MEMC1 checkers
65 *
66 * Hydra_Software_Devel/45   4/8/09 5:06p erickson
67 * PR53866: proper error recovery on BINT_CreateCallback and
68 * BINT_ClearCallback
69 *
70 * Hydra_Software_Devel/44   2/17/09 6:42p albertl
71 * PR51612: Updated to correct naming conventions.
72 *
73 * Hydra_Software_Devel/43   1/27/09 8:26p tdo
74 * PR51627: add VDC 7336 PI support
75 *
76 * Hydra_Software_Devel/42   12/2/08 7:14p albertl
77 * PR46761: Changed 7420 to use BCHP_INT_ID_MEMC_X_L2_ARC_X_INTR.
78 *
79 * Hydra_Software_Devel/41   7/23/08 1:44p katrep
80 * PR45074:Fixed the typo error in conditional code
81 *
82 * Hydra_Software_Devel/40   4/11/08 5:29p albertl
83 * PR17131:  Fixed missing XPT3 client id for 7401 and 7403.  Improved
84 * client stringname handling in BMRC_P_Checker_Violation_isr.
85 *
86 * Hydra_Software_Devel/39   3/5/08 10:19p pntruong
87 * PR34853: Added ifdef for 3556.
88 *
89 * Hydra_Software_Devel/38   2/26/08 12:20a albertl
90 * PR36876:  Fixed compile errors with 7401 and 7403 not supporting
91 * ARC_0_VIOLATION_INFO_CLEAR.
92 *
93 * Hydra_Software_Devel/37   2/25/08 7:04p albertl
94 * PR36876:  Rewrote MRC to abstract client names and streamline adding of
95 * future chips.  3548 support added.
96 *
97 * Hydra_Software_Devel/36   1/23/08 10:05p pntruong
98 * PR37978: Synced up with central rdb.
99 *
100 * Hydra_Software_Devel/35   12/7/07 3:38p pntruong
101 * PR37978: Add Intial support for 3563D0.
102 *
103 * Hydra_Software_Devel/35   12/7/07 3:35p pntruong
104 * PR37978: Add Intial support for 3563D0.
105 *
106 * Hydra_Software_Devel/34   12/6/07 10:06a erickson
107 * PR36876: convert NULL checks to BDBG_OBJECT which are more thorough.
108 * eliminate duplicate #if BCHP_CHIP logic to keep in sync with header
109 * file.
110 *
111 * Hydra_Software_Devel/33   11/19/07 3:22p tdo
112 * PR36876: Add mrc support for 7335
113 *
114 * Hydra_Software_Devel/32   11/14/07 1:53p albertl
115 * PR35322:  Updated mrc monitor to properly support 128 clients.
116 *
117 * Hydra_Software_Devel/31   10/19/07 4:14p jrubio
118 * PR35015: adding support for 7325
119 *
120 * Hydra_Software_Devel/30   5/2/07 7:01p albertl
121 * PR29633:  Fixed for 7400 a0.
122 *
123 * Hydra_Software_Devel/29   5/2/07 11:46a pntruong
124 * PR29633: Fixed build error and commented out debug printfs.
125 *
126 * Hydra_Software_Devel/29   5/2/07 11:45a pntruong
127 * PR29633: Fixed build error and commented out debug printfs.
128 *
129 * Hydra_Software_Devel/28   5/1/07 5:07p albertl
130 * PR29633:  Updated and changed MRC for 7405.
131 *
132 * Hydra_Software_Devel/27   3/9/07 7:18p albertl
133 * PR28182:  No longer programs ARC when aligned size is 0.  Memc id now
134 * reported on violations.
135 *
136 * Hydra_Software_Devel/26   3/1/07 8:16p albertl
137 * PR26116:  Fixed support for multiple memory modules for 7400 and 3563.
138 *
139 * Hydra_Software_Devel/25   1/17/07 6:38p albertl
140 * PR19101:  Updated violation messages to indicate exclusive mode for
141 * clarity.
142 *
143 * Hydra_Software_Devel/24   12/18/06 11:37p pntruong
144 * PR22577: Merged back to mainline.
145 *
146 * Hydra_Software_Devel/Refsw_Devel_3563/1   10/13/06 9:28p albertl
147 * PR23361:  Added multiple mrc support for 3563.
148 *
149 * Hydra_Software_Devel/22   9/13/06 10:06p pntruong
150 * PR24183, PR24184: Fixed 7118 build errors.
151 *
152 * Hydra_Software_Devel/21   9/12/06 4:12p pntruong
153 * PR24183, PR24184: compile erros in bmrc.c for 97038 build.
154 *
155 * Hydra_Software_Devel/20   8/9/06 3:47p albertl
156 * PR23361:  Fixed changes that broke 7401.
157 *
158 * Hydra_Software_Devel/19   8/8/06 6:19p albertl
159 * PR23361:  Changed to compile for 3563.
160 *
161 * Hydra_Software_Devel/18   6/13/06 6:07p syang
162 * PR 21689: add support for 7118
163 *
164 * Hydra_Software_Devel/17   3/8/06 5:30p albertl
165 * PR19101:  BMRC_Checker_SetRange now only accepts 8 byte alligned
166 * addresses and sizes, and returns error otherwise.
167 *
168 * Hydra_Software_Devel/16   3/7/06 6:32p albertl
169 * PR19101:  Fixed BMRC_Checker_SetRange so actual hardware range is only
170 * as large as needed to cover specified size.
171 *
172 * Hydra_Software_Devel/15   3/7/06 3:54p syang
173 * PR 19670: added 7438 support
174 *
175 * Hydra_Software_Devel/14   3/3/06 7:24p albertl
176 * PR18701:  Added functions to disable and enable a checker's callback.
177 *
178 * Hydra_Software_Devel/13   2/16/06 7:32p albertl
179 * PR19565: Added support for 7438.
180 *
181 * Hydra_Software_Devel/12   2/16/06 7:28p albertl
182 * PR19669:  Moved private defines from public bmrc.h file to bmrc.c.
183 *
184 * Hydra_Software_Devel/11   1/17/06 4:53p hongtaoz
185 * PR19082: support 7400;
186 *
187 * Hydra_Software_Devel/10   11/29/05 1:16p albertl
188 * PR18307:  usActiveCheckers now initialized properly in BMRC_Open.
189 * BMRC_Create_Checker now leaves critical section when an error occurs.
190 *
191 * Hydra_Software_Devel/9   10/7/05 4:33p hongtaoz
192 * PR17460: adapted to the new RDB header files;
193 *
194 * Hydra_Software_Devel/8   9/23/05 7:06p hongtaoz
195 * PR17131: added BMRC support for 7401;
196 *
197 * Hydra_Software_Devel/7   9/22/05 4:34p albertl
198 * PR17164:  Added missing write to ARC_0_CNTRL on disable and
199 * added missing offset to handle all checkers.
200 *
201 * Hydra_Software_Devel/6   8/9/05 3:05p pntruong
202 * PR13641:  Added BMRC error codes.
203 *
204 * Hydra_Software_Devel/5   8/8/05 9:49p albertl
205 * PR13641:  Added BMRC error codes.  Callback status cleared when
206 * enabling, disabling, and on violations.
207 *
208 * Hydra_Software_Devel/4   8/4/05 6:50p albertl
209 * PR13641:  Fixed incorrect PR numbers in chagelog.
210 *
211 * Hydra_Software_Devel/2   8/3/05 8:34p albertl
212 * PR13641:  Corrected addresses by shifting them the proper bits before
213 * reading from or writing to hardware.
214 *
215 * Hydra_Software_Devel/1   8/1/05 10:11p albertl
216 * PR13641:  Initial Revision.
217 *
218 ***************************************************************************/
219
220#include "bmrc.h"
221#include "bmrc_priv.h"
222#include "bstd.h"                /* standard types */
223#include "bkni.h"                /* Memory management */
224#include "bdbg.h"                /* Debug message */
225
226#if BMRC_P_CHECKER_USE_MEMC_GEN
227#if (BMRC_P_MEMC_NUM > 1)
228#include "bchp_memc_gen_1.h"
229#endif
230#include "bchp_memc_gen_0.h"
231
232#else
233#if (BMRC_P_MEMC_NUM > 2)
234#include "bchp_memc_2.h"
235#endif
236#if (BMRC_P_MEMC_NUM > 1)
237#include "bchp_memc_1.h"
238#endif
239#include "bchp_memc_0.h"
240#endif
241
242#if (BMRC_P_MEMC_NUM > 2)
243#define BMRC_P_BCHP_MEMC_REG(hMrc, reg) ((hMrc->usMemcId == 0) ? BMRC_P_BCHP_MEMC_0_REG(reg) : \
244                                         (hMrc->usMemcId == 1) ? BMRC_P_BCHP_MEMC_1_REG(reg) : \
245                                         BMRC_P_BCHP_MEMC_2_REG(reg))
246#elif (BMRC_P_MEMC_NUM > 1)
247#define BMRC_P_BCHP_MEMC_REG(hMrc, reg) ((hMrc->usMemcId == 0) ? BMRC_P_BCHP_MEMC_0_REG(reg) : \
248                                         BMRC_P_BCHP_MEMC_1_REG(reg))
249#else
250#define BMRC_P_BCHP_MEMC_REG(hMrc, reg) (BMRC_P_BCHP_MEMC_0_REG(reg))
251#endif
252
253#if BMRC_P_CHECKER_USE_MEMC_GEN
254#define BMRC_P_BCHP_MEMC_0_REG(reg) BCHP_MEMC_GEN_0##_##reg
255#define BMRC_P_BCHP_MEMC_1_REG(reg) BCHP_MEMC_GEN_1##_##reg
256#define BMRC_P_BCHP_MEMC_2_REG(reg) BCHP_MEMC_GEN_2##_##reg
257#define BMRC_P_GET_FIELD_DATA(mem, reg, field) BCHP_GET_FIELD_DATA(mem, MEMC_GEN_0##_##reg, field)
258#define BMRC_P_FIELD_DATA(reg, field, data)    BCHP_FIELD_DATA(MEMC_GEN_0##_##reg, field, data)
259#define BMRC_P_FIELD_ENUM(reg, field, name)    BCHP_FIELD_ENUM(MEMC_GEN_0##_##reg, field, name)
260
261#else
262#define BMRC_P_BCHP_MEMC_0_REG(reg) BCHP_MEMC_0##_##reg
263#define BMRC_P_BCHP_MEMC_1_REG(reg) BCHP_MEMC_1##_##reg
264#define BMRC_P_BCHP_MEMC_2_REG(reg) BCHP_MEMC_2##_##reg
265#define BMRC_P_GET_FIELD_DATA(mem, reg, field) BCHP_GET_FIELD_DATA(mem, MEMC_0##_##reg, field)
266#define BMRC_P_FIELD_DATA(reg, field, data)    BCHP_FIELD_DATA(MEMC_0##_##reg, field, data)
267#define BMRC_P_FIELD_ENUM(reg, field, name)    BCHP_FIELD_ENUM(MEMC_0##_##reg, field, name)
268
269/* workaround to build on chips where these fields are not symetrical across MRCs, like 7400 */
270#ifndef BCHP_MEMC_1_ARC_0_READ_RIGHTS_HIGH
271#define BCHP_MEMC_1_ARC_0_READ_RIGHTS_HIGH 0
272#endif
273#ifndef BCHP_MEMC_1_ARC_0_WRITE_RIGHTS_HIGH
274#define BCHP_MEMC_1_ARC_0_WRITE_RIGHTS_HIGH 0
275#endif
276#ifndef BCHP_MEMC_2_ARC_0_READ_RIGHTS_HIGH
277#define BCHP_MEMC_2_ARC_0_READ_RIGHTS_HIGH 0
278#endif
279#ifndef BCHP_MEMC_2_ARC_0_WRITE_RIGHTS_HIGH
280#define BCHP_MEMC_2_ARC_0_WRITE_RIGHTS_HIGH 0
281#endif
282
283#endif
284
285
286/* offsets */
287#define BMRC_P_CHECKER_REG_OFFSET(hMrc) (BMRC_P_BCHP_MEMC_REG(hMrc, ARC_1_CNTRL) - BMRC_P_BCHP_MEMC_REG(hMrc, ARC_0_CNTRL))
288#define BMRC_P_CHECKER_REG_IDX(hMrc, reg) ((BMRC_P_BCHP_MEMC_REG(hMrc, reg) - BMRC_P_BCHP_MEMC_REG(hMrc, ARC_0_CNTRL)) / sizeof(uint32_t))
289#define BMRC_P_CHECKER_REG_SIZE  (BMRC_P_BCHP_MEMC_0_REG(ARC_1_CNTRL) - BMRC_P_BCHP_MEMC_0_REG(ARC_0_CNTRL))
290
291#define BMRC_P_MEMC_0_REG_OFFSET 0
292
293#if (BMRC_P_MEMC_NUM > 1)
294    #define BMRC_P_MEMC_1_REG_OFFSET (BMRC_P_BCHP_MEMC_1_REG(ARC_0_CNTRL) - BMRC_P_BCHP_MEMC_0_REG(ARC_0_CNTRL))
295#else
296    #define BMRC_P_MEMC_1_REG_OFFSET 0
297#endif
298
299#if (BMRC_P_MEMC_NUM > 2)
300    #define BMRC_P_MEMC_2_REG_OFFSET (BMRC_P_BCHP_MEMC_2_REG(ARC_0_CNTRL) - BMRC_P_BCHP_MEMC_0_REG(ARC_0_CNTRL))
301#else
302    #define BMRC_P_MEMC_2_REG_OFFSET 0
303#endif
304
305#if !BMRC_P_CHECKER_USE_NEW_NAME_SUFFIX
306#define BMRC_P_NMBX_REG_OFFSET    (BCHP_MEMC_0_NMBX1 - BCHP_MEMC_0_NMBX0)
307#endif
308
309#define BMRC_P_Checker_Read32(hMrc, hChecker, reg)         BREG_Read32 (hMrc->hReg, BMRC_P_BCHP_MEMC_REG(hMrc, reg) + hChecker->ulRegOffset)
310#define BMRC_P_Checker_Write32(hMrc, hChecker, reg, data)  if(hChecker->aulPrevRegTbl[BMRC_P_CHECKER_REG_IDX(hMrc, reg)] != data)                        \
311                                                                                                                           BREG_Write32(hMrc->hReg, BMRC_P_BCHP_MEMC_REG(hMrc, reg) + hChecker->ulRegOffset, data);  \
312                                                               hChecker->aulPrevRegTbl[BMRC_P_CHECKER_REG_IDX(hMrc, reg)] = data
313
314
315#define BMRC_P_MEMC_ADRS_SHIFT 3
316#define BMRC_P_RANGE_ALIGNMENT_MASK ~0x00000007
317
318#define BMRC_P_CHECKER_COUNT_MAX 4
319
320
321BDBG_MODULE(BMRC);
322BDBG_OBJECT_ID(BMRC);
323BDBG_OBJECT_ID(BMRC_Checker);
324
325extern const BMRC_P_ClientEntry BMRC_P_astClientTbl[];
326
327typedef struct BMRC_P_CheckerContext
328{
329    BDBG_OBJECT(BMRC_Checker)
330    BMRC_Handle hMrc;
331    uint16_t usCheckerId;
332    uint32_t ulRegOffset;
333    uint32_t ulStart;
334    uint32_t ulSize;
335    BMRC_AccessType eCheckType;
336    BMRC_AccessType eBlockType;
337    bool bExclusive;
338    uint32_t aulReadClients[BMRC_P_CLIENTS_ARRAY_SIZE];
339    uint32_t aulWriteClients[BMRC_P_CLIENTS_ARRAY_SIZE];
340    bool bEnabled;
341    bool bActive;
342
343        /* previous register values */
344        uint32_t aulPrevRegTbl[BMRC_P_CHECKER_REG_SIZE];
345
346    /* callback data */
347    BINT_Id InterruptName;
348    BINT_CallbackHandle hCallback;
349    BMRC_CallbackFunc_isr pfCbFunc;
350    void *pvCbData1;
351    int iCbData2;
352    BMRC_CheckerInfo stCheckerInfo;
353
354} BMRC_P_CheckerContext;
355
356typedef struct BMRC_P_Context
357{
358    BDBG_OBJECT(BMRC)
359    BREG_Handle           hReg;
360    BINT_Handle           hInt;
361    BMRC_Settings         stSettings;
362    uint16_t              usMemcId;
363    int32_t               lRegOffset;
364    uint16_t              usMaxCheckers;
365    uint16_t              usActiveCheckers;
366    BMRC_P_CheckerContext aCheckers[BMRC_P_CHECKER_COUNT_MAX];
367
368} BMRC_P_Context;
369
370typedef struct BMRC_P_MemcInfo
371{
372    int32_t  lRegOffset;
373    uint16_t usMaxCheckers;
374
375} BMRC_P_MemcInfo;
376
377static const BMRC_Settings s_stDefaultSettings = {
378    0 /* Memc Module Id */
379};
380
381
382static const BINT_Id s_saIntIdTbl[][BMRC_P_CHECKER_COUNT_MAX] =
383{
384    /* memc 0 */
385    {
386        BMRC_P_MEMC_0_ARC_0_INTR,
387        BMRC_P_MEMC_0_ARC_1_INTR,
388        BMRC_P_MEMC_0_ARC_2_INTR,
389        BMRC_P_MEMC_0_ARC_3_INTR
390    },
391
392    /* memc 1 */
393    {
394        BMRC_P_MEMC_1_ARC_0_INTR,
395        BMRC_P_MEMC_1_ARC_1_INTR,
396        BMRC_P_MEMC_1_ARC_2_INTR,
397        BMRC_P_MEMC_1_ARC_3_INTR
398    },
399
400    /* memc 2 */
401    {
402        BMRC_P_MEMC_2_ARC_0_INTR,
403        BMRC_P_MEMC_2_ARC_1_INTR,
404        BMRC_P_MEMC_2_ARC_2_INTR,
405        BMRC_P_MEMC_2_ARC_3_INTR
406    }
407};
408
409static const BMRC_P_MemcInfo st_aMemcInfo[] = {
410    /* offset,                   max checker count */
411    {BMRC_P_MEMC_0_REG_OFFSET, BMRC_P_MEMC_0_CHECKER_COUNT_MAX},
412    {BMRC_P_MEMC_1_REG_OFFSET, BMRC_P_MEMC_1_CHECKER_COUNT_MAX},
413    {BMRC_P_MEMC_2_REG_OFFSET, BMRC_P_MEMC_2_CHECKER_COUNT_MAX}
414};
415
416/* set BMRC_STUB to 1 if you want to test without MRC code */
417#define BMRC_STUB 0
418
419#if !BMRC_STUB
420void BMRC_P_Checker_Violation_isr ( void *pvData1, int iData2 );
421BERR_Code BMRC_P_Checker_WriteRegs ( BMRC_Checker_Handle hChecker );
422
423/***************************************************************************
424 *
425 */
426BERR_Code
427BMRC_GetDefaultSettings
428    ( BMRC_Settings *pDefSettings )
429{
430    if (!pDefSettings)
431    {
432        return BERR_INVALID_PARAMETER;
433    }
434
435    *pDefSettings = s_stDefaultSettings;
436
437    return BERR_SUCCESS;
438}
439
440/***************************************************************************
441 *
442 */
443BERR_Code BMRC_Open
444    ( BMRC_Handle                     *phMrc,
445      BREG_Handle                      hRegister,
446      BINT_Handle                      hInterrupt,
447      const BMRC_Settings             *pDefSettings )
448{
449    BMRC_Handle hMrc = NULL;
450    BERR_Code err = BERR_SUCCESS;
451
452    hMrc = (BMRC_Handle) BKNI_Malloc(sizeof(BMRC_P_Context));
453
454    if (!hMrc)
455    {
456        BDBG_ERR(( "Out of System Memory" ));
457        return BERR_TRACE(BERR_OUT_OF_SYSTEM_MEMORY);
458    }
459
460    hMrc->hReg = hRegister;
461    hMrc->hInt = hInterrupt;
462
463    /* Take in default settings. */
464    hMrc->stSettings = (pDefSettings) ? *pDefSettings : s_stDefaultSettings;
465
466    if (hMrc->stSettings.usMemcId >= BMRC_P_MEMC_NUM)
467    {
468        BDBG_ERR(("MemcId %d not supported on this chipset", hMrc->stSettings.usMemcId));
469        err = BERR_NOT_SUPPORTED;
470        goto error;
471    }
472
473    hMrc->usMemcId = hMrc->stSettings.usMemcId;
474
475    /* BMRC_P_MRC_1_REG_OFFSET is actually negative for 3563,
476       hence signed long for lRegOffset */
477    hMrc->lRegOffset = st_aMemcInfo[hMrc->usMemcId].lRegOffset;
478
479    hMrc->usMaxCheckers = st_aMemcInfo[hMrc->usMemcId].usMaxCheckers;
480    hMrc->usActiveCheckers = 0;
481    BKNI_Memset(hMrc->aCheckers, 0, sizeof(BMRC_P_CheckerContext) * BMRC_P_CHECKER_COUNT_MAX);
482
483    *phMrc = hMrc;
484    BDBG_OBJECT_SET(hMrc, BMRC);
485
486    return BERR_SUCCESS;
487
488error:
489    BKNI_Free(hMrc);
490    return err;
491}
492
493/***************************************************************************
494 *
495 */
496BERR_Code BMRC_Close
497    ( BMRC_Handle hMrc )
498{
499    BDBG_OBJECT_ASSERT(hMrc, BMRC);
500
501    BDBG_OBJECT_UNSET(hMrc, BMRC);
502    BKNI_Free(hMrc);
503
504    return BERR_SUCCESS;
505}
506
507/***************************************************************************
508 *
509 */
510void BMRC_GetSettings ( BMRC_Handle hMrc, BMRC_Settings *pSettings )
511{
512    BDBG_OBJECT_ASSERT(hMrc, BMRC);
513    *pSettings = hMrc->stSettings;
514}
515
516/***************************************************************************
517 *
518 */
519BERR_Code BMRC_GetMaxCheckers
520    ( BMRC_Handle hMrc,
521      uint32_t *pulMaxChecker )
522{
523    BDBG_OBJECT_ASSERT(hMrc, BMRC);
524
525    *pulMaxChecker = hMrc->usMaxCheckers;
526
527    return BERR_SUCCESS;
528}
529
530/***************************************************************************
531 *
532 */
533BERR_Code BMRC_Checker_Create
534    ( BMRC_Handle hMrc,
535      BMRC_Checker_Handle *phChecker )
536{
537    int i = 0;
538    uint32_t ulReg = 0;
539    BMRC_P_CheckerContext *pCurChecker = NULL;
540    BERR_Code rc;
541
542    BDBG_OBJECT_ASSERT(hMrc, BMRC);
543
544    BKNI_EnterCriticalSection();
545    if (hMrc->usActiveCheckers >= hMrc->usMaxCheckers)
546    {
547        BDBG_ERR(("Maximum number of checkers reached.  Cannot create additional checkers."));
548        BKNI_LeaveCriticalSection();
549
550        return BERR_TRACE(BMRC_CHECKER_ERR_ALL_USED);
551    }
552
553    for (i = 0; i < hMrc->usMaxCheckers; i++)
554    {
555        pCurChecker = &(hMrc->aCheckers[i]);
556
557        if (!pCurChecker->bActive)
558        {
559            hMrc->usActiveCheckers++;
560            pCurChecker->hMrc = hMrc;
561            pCurChecker->usCheckerId = i;
562            pCurChecker->ulRegOffset = pCurChecker->usCheckerId * BMRC_P_CHECKER_REG_OFFSET(hMrc);
563            pCurChecker->ulStart = 0;
564            pCurChecker->ulSize = 0;
565            pCurChecker->bExclusive = false;
566            pCurChecker->eCheckType = BMRC_AccessType_eNone;
567            pCurChecker->eBlockType = BMRC_AccessType_eNone;
568            pCurChecker->bEnabled = false;
569            pCurChecker->bActive = true;
570
571            pCurChecker->InterruptName = s_saIntIdTbl[hMrc->usMemcId][i];
572            pCurChecker->hCallback = 0;
573            pCurChecker->pfCbFunc = NULL;
574            pCurChecker->pvCbData1 = NULL;
575            pCurChecker->iCbData2 = 0;
576
577            BKNI_Memset(pCurChecker->aulReadClients, 0, sizeof(pCurChecker->aulReadClients));
578            BKNI_Memset(pCurChecker->aulWriteClients, 0, sizeof(pCurChecker->aulWriteClients));
579            BKNI_Memset(pCurChecker->aulPrevRegTbl, 0, sizeof(pCurChecker->aulPrevRegTbl));
580
581            *phChecker = (BMRC_Checker_Handle)pCurChecker;
582
583            BDBG_OBJECT_SET(pCurChecker, BMRC_Checker);
584            break;
585        }
586    }
587    BKNI_LeaveCriticalSection();
588
589    BDBG_ASSERT(*phChecker);
590
591#if BMRC_P_CHECKER_USE_VIOLATION_INFO_CLEAR
592    /* clear out any previous violation */
593    ulReg = BMRC_P_FIELD_DATA(ARC_0_VIOLATION_INFO_CLEAR, WRITE_CLEAR, 1);
594    BMRC_P_Checker_Write32(hMrc, pCurChecker, ARC_0_VIOLATION_INFO_CLEAR, ulReg);
595
596    ulReg = BMRC_P_FIELD_DATA(ARC_0_VIOLATION_INFO_CLEAR, WRITE_CLEAR, 0);
597    BMRC_P_Checker_Write32(hMrc, pCurChecker, ARC_0_VIOLATION_INFO_CLEAR, ulReg);
598#else
599    BSTD_UNUSED(ulReg);
600#endif
601
602    rc = BINT_CreateCallback(&(pCurChecker->hCallback),
603        hMrc->hInt,
604        pCurChecker->InterruptName,
605        BMRC_P_Checker_Violation_isr,
606        (void*)pCurChecker, pCurChecker->usCheckerId);
607    if (rc) return BERR_TRACE(rc);
608
609    rc = BINT_ClearCallback(pCurChecker->hCallback);
610    if (rc) {
611        BINT_DestroyCallback(pCurChecker->hCallback);
612        return BERR_TRACE(rc);
613    }
614
615    return BERR_SUCCESS;
616}
617
618/***************************************************************************
619 *
620 */
621BERR_Code BMRC_Checker_Destroy
622    ( BMRC_Checker_Handle hChecker )
623{
624    BMRC_Handle hMrc;
625
626    BDBG_OBJECT_ASSERT(hChecker, BMRC_Checker);
627
628    hMrc = hChecker->hMrc;
629    BDBG_OBJECT_ASSERT(hMrc, BMRC);
630
631    BMRC_Checker_Disable(hChecker);
632    BMRC_Checker_DisableCallback(hChecker);
633    BINT_DestroyCallback(hChecker->hCallback);
634
635    hChecker->bActive = false;
636    hMrc->usActiveCheckers--;
637    BDBG_OBJECT_UNSET(hChecker, BMRC_Checker);
638
639    return BERR_SUCCESS;
640}
641
642/***************************************************************************
643 *
644 */
645BERR_Code BMRC_Checker_SetRange
646    ( BMRC_Checker_Handle hChecker,
647      uint32_t ulStart,
648      uint32_t ulSize )
649{
650    BDBG_OBJECT_ASSERT(hChecker, BMRC_Checker);
651
652    if (ulSize == 0)
653    {
654        return BERR_TRACE(BERR_INVALID_PARAMETER);
655    }
656
657    if ((ulSize != (ulSize & BMRC_P_RANGE_ALIGNMENT_MASK)) ||
658        (ulStart != (ulStart & BMRC_P_RANGE_ALIGNMENT_MASK)))
659    {
660        BDBG_ERR(( "ulStart address and ulSize must be 8 byte aligned." ));
661        return BERR_TRACE(BERR_INVALID_PARAMETER);
662    }
663
664    if (hChecker->bEnabled)
665    {
666        return BERR_TRACE(BMRC_CHECKER_ERR_ENABLED_CANT_SET);
667    }
668
669    hChecker->ulStart = ulStart;
670    hChecker->ulSize = ulSize;
671
672    return BERR_SUCCESS;
673}
674
675/***************************************************************************
676 *
677 */
678BERR_Code BMRC_Checker_SetAccessCheck
679    ( BMRC_Checker_Handle hChecker,
680      BMRC_AccessType eAccessType )
681{
682    BDBG_OBJECT_ASSERT(hChecker, BMRC_Checker);
683
684    if (hChecker->bEnabled)
685    {
686        return BERR_TRACE(BMRC_CHECKER_ERR_ENABLED_CANT_SET);
687    }
688
689    if (eAccessType == BMRC_AccessType_eNone)
690    {
691        return BERR_TRACE(BERR_INVALID_PARAMETER);
692    }
693
694    hChecker->eCheckType = eAccessType;
695
696    return BERR_SUCCESS;
697}
698
699/***************************************************************************
700 *
701 */
702BERR_Code BMRC_Checker_SetBlock
703    ( BMRC_Checker_Handle hChecker,
704      BMRC_AccessType eBlockType )
705{
706    BDBG_OBJECT_ASSERT(hChecker, BMRC_Checker);
707
708    if (hChecker->bEnabled)
709    {
710        return BERR_TRACE(BMRC_CHECKER_ERR_ENABLED_CANT_SET);
711    }
712
713    hChecker->eBlockType = eBlockType;
714
715    return BERR_SUCCESS;
716}
717
718/***************************************************************************
719 *
720 */
721BERR_Code BMRC_Checker_SetExclusive
722    ( BMRC_Checker_Handle hChecker,
723      bool bExclusive )
724{
725    BDBG_OBJECT_ASSERT(hChecker, BMRC_Checker);
726
727    if (hChecker->bEnabled)
728    {
729        return BERR_TRACE(BMRC_CHECKER_ERR_ENABLED_CANT_SET);
730    }
731
732    hChecker->bExclusive = bExclusive;
733
734    return BERR_SUCCESS;
735}
736
737/***************************************************************************
738 *
739 */
740BERR_Code BMRC_Checker_SetClient
741    ( BMRC_Checker_Handle hChecker,
742      BMRC_Client eClient,
743      BMRC_AccessType eAccessType )
744{
745    uint16_t usClientId = BMRC_P_GET_CLIENT_ID(hChecker->hMrc->usMemcId, eClient);
746    uint32_t ulClientsIdx = usClientId / BMRC_P_CLIENTS_ARRAY_ELEMENT_SIZE;
747    uint32_t ulClientsShift = (usClientId % BMRC_P_CLIENTS_ARRAY_ELEMENT_SIZE);
748    uint32_t ulClientsMask = 1 << ulClientsShift;
749
750    BDBG_OBJECT_ASSERT(hChecker, BMRC_Checker);
751    BDBG_ASSERT(BMRC_P_astClientTbl[eClient].eClient == eClient);
752
753    if (hChecker->bEnabled)
754    {
755        return BERR_TRACE(BMRC_CHECKER_ERR_ENABLED_CANT_SET);
756    }
757
758    if (usClientId >= BMRC_Client_eInvalid)
759    {
760        BDBG_ERR(( "Client %s not supported on this platform.",  BMRC_P_astClientTbl[eClient].pchClientName));
761        return BERR_TRACE(BERR_INVALID_PARAMETER);
762    }
763
764    BDBG_ASSERT(ulClientsIdx < BMRC_P_CLIENTS_ARRAY_SIZE);
765
766    if (eAccessType == BMRC_AccessType_eRead)
767    {
768        hChecker->aulReadClients[ulClientsIdx] |= ulClientsMask;
769        hChecker->aulWriteClients[ulClientsIdx] &= ~ulClientsMask;
770    }
771
772    if (eAccessType == BMRC_AccessType_eWrite)
773        {
774        hChecker->aulReadClients[ulClientsIdx] &= ~ulClientsMask;
775        hChecker->aulWriteClients[ulClientsIdx] |= ulClientsMask;
776        }
777               
778        if (eAccessType == BMRC_AccessType_eBoth)
779    {
780        hChecker->aulReadClients[ulClientsIdx] |= ulClientsMask;
781        hChecker->aulWriteClients[ulClientsIdx] |= ulClientsMask;
782    }
783
784        if (eAccessType == BMRC_AccessType_eNone)
785        {
786        hChecker->aulReadClients[ulClientsIdx] &= ~ulClientsMask;
787        hChecker->aulWriteClients[ulClientsIdx] &= ~ulClientsMask;
788        }
789
790    return BERR_SUCCESS;
791}
792
793/***************************************************************************
794 *
795 */
796BERR_Code BMRC_Checker_Enable
797    ( BMRC_Checker_Handle hChecker )
798{
799    BDBG_OBJECT_ASSERT(hChecker, BMRC_Checker);
800
801    hChecker->bEnabled = true;
802    BMRC_P_Checker_WriteRegs(hChecker);
803
804    return BERR_SUCCESS;
805}
806
807/***************************************************************************
808 *
809 */
810BERR_Code BMRC_Checker_Disable
811    ( BMRC_Checker_Handle hChecker )
812{
813    BDBG_OBJECT_ASSERT(hChecker, BMRC_Checker);
814
815    hChecker->bEnabled = false;
816    BMRC_P_Checker_WriteRegs(hChecker);
817
818    return BERR_SUCCESS;
819}
820
821/***************************************************************************
822 *
823 */
824BERR_Code BMRC_Checker_EnableCallback
825    ( BMRC_Checker_Handle hChecker )
826{
827    BDBG_OBJECT_ASSERT(hChecker, BMRC_Checker);
828
829    if (!hChecker->hCallback)
830    {
831        return BERR_TRACE(BMRC_CHECKER_ERR_NO_CALLBACK_SET);
832    }
833
834    BERR_TRACE(BINT_ClearCallback(hChecker->hCallback));
835    BERR_TRACE(BINT_EnableCallback(hChecker->hCallback));
836
837    return BERR_SUCCESS;
838}
839
840/***************************************************************************
841 *
842 */
843BERR_Code BMRC_Checker_DisableCallback
844    ( BMRC_Checker_Handle hChecker )
845{
846    BDBG_OBJECT_ASSERT(hChecker, BMRC_Checker);
847
848    BERR_TRACE(BINT_DisableCallback(hChecker->hCallback));
849    BERR_TRACE(BINT_ClearCallback(hChecker->hCallback));
850
851    return BERR_SUCCESS;
852}
853
854/***************************************************************************
855 *
856 */
857BERR_Code BMRC_Checker_EnableCallback_isr
858    ( BMRC_Checker_Handle hChecker )
859{
860    BDBG_OBJECT_ASSERT(hChecker, BMRC_Checker);
861
862    if (!hChecker->hCallback)
863    {
864        return BERR_TRACE(BMRC_CHECKER_ERR_NO_CALLBACK_SET);
865    }
866
867    BERR_TRACE(BINT_ClearCallback_isr(hChecker->hCallback));
868    BERR_TRACE(BINT_EnableCallback_isr(hChecker->hCallback));
869
870    return BERR_SUCCESS;
871}
872
873/***************************************************************************
874 *
875 */
876BERR_Code BMRC_Checker_DisableCallback_isr
877    ( BMRC_Checker_Handle hChecker )
878{
879    BDBG_OBJECT_ASSERT(hChecker, BMRC_Checker);
880
881    BERR_TRACE(BINT_DisableCallback_isr(hChecker->hCallback));
882    BERR_TRACE(BINT_ClearCallback_isr(hChecker->hCallback));
883
884    return BERR_SUCCESS;
885}
886
887/***************************************************************************
888 *
889 */
890BERR_Code BMRC_Checker_SetCallback
891    ( BMRC_Checker_Handle hChecker,
892      const BMRC_CallbackFunc_isr pfCbFunc,
893      void *pvCbData1,
894      int iCbData2)
895{
896    BDBG_OBJECT_ASSERT(hChecker, BMRC_Checker);
897
898    if (hChecker->bEnabled)
899    {
900        return BERR_TRACE(BMRC_CHECKER_ERR_ENABLED_CANT_SET);
901    }
902
903    hChecker->pfCbFunc = pfCbFunc;
904    hChecker->pvCbData1 = pvCbData1;
905    hChecker->iCbData2 = iCbData2;
906
907    return BERR_SUCCESS;
908}
909
910/***************************************************************************
911 *
912 */
913void BMRC_P_Checker_Violation_isr
914    ( void *pvData1,
915      int iData2 )
916{
917    uint32_t ulReg = 0;
918    BMRC_Checker_Handle hChecker = (BMRC_Checker_Handle)pvData1;
919    BMRC_CheckerInfo *pCheckerInfo = &(hChecker->stCheckerInfo);
920    BMRC_Handle hMrc = hChecker->hMrc;
921    BMRC_ClientInfo stClientInfo;
922
923    BSTD_UNUSED(iData2);
924    BDBG_OBJECT_ASSERT(hChecker, BMRC_Checker);
925    BDBG_OBJECT_ASSERT(hMrc, BMRC);
926
927    pCheckerInfo->usMemcId = hMrc->usMemcId;
928    pCheckerInfo->usCheckerId = hChecker->usCheckerId;
929    pCheckerInfo->ulStart = hChecker->ulStart;
930    pCheckerInfo->ulSize = hChecker->ulSize;
931    pCheckerInfo->bExclusive = hChecker->bExclusive;
932
933#if !BMRC_P_CHECKER_USE_NEW_NAME_SUFFIX
934    ulReg = BMRC_P_Checker_Read32(hMrc, hChecker, ARC_0_VIOLATION_INFO_LOW));
935    pCheckerInfo->ulAddress = BMRC_P_GET_FIELD_DATA(ulReg, ARC_0_VIOLATION_INFO_LOW, ADDRESS) << BMRC_P_MEMC_ADRS_SHIFT;
936
937    ulReg = BMRC_P_Checker_Read32(hMrc, hChecker, ARC_0_VIOLATION_INFO_HIGH));
938    pCheckerInfo->ulReqType = BMRC_P_GET_FIELD_DATA(ulReg, ARC_0_VIOLATION_INFO_HIGH, REQ_TYPE);
939
940#if BMRC_P_CHECKER_USE_NMBX_ID
941    pCheckerInfo->usClientId = BMRC_P_GET_FIELD_DATA(ulReg, ARC_0_VIOLATION_INFO_HIGH, CLIENT_ID);
942    pCheckerInfo->ulNmbxId = BMRC_P_GET_FIELD_DATA(ulReg, ARC_0_VIOLATION_INFO_HIGH, NMBX_ID);
943
944    ulReg = BREG_Read32(hMrc->hReg, BCHP_MEMC_0_NMBX0 + (pCheckerInfo->ulNmbxId * BMRC_P_NMBX_REG_OFFSET) + hMrc->lRegOffset + hChecker->ulRegOffset);
945    pCheckerInfo->ulNmbx = BMRC_P_GET_FIELD_DATA(ulReg, MEMC_0_NMBX0, NMBX);
946#else
947    pCheckerInfo->usClientId = BMRC_P_GET_FIELD_DATA(ulReg, ARC_0_VIOLATION_INFO_HIGH, CLIENTID);
948    pCheckerInfo->ulNmbx = BMRC_P_GET_FIELD_DATA(ulReg, ARC_0_VIOLATION_INFO_HIGH, NMBX);
949#endif
950
951#else
952    ulReg = BMRC_P_Checker_Read32(hMrc, hChecker, ARC_0_VIOLATION_INFO_START_ADDR);
953    pCheckerInfo->ulAddress = BMRC_P_GET_FIELD_DATA(ulReg, ARC_0_VIOLATION_INFO_START_ADDR, ADDRESS) << BMRC_P_MEMC_ADRS_SHIFT;
954
955    ulReg = BMRC_P_Checker_Read32(hMrc, hChecker, ARC_0_VIOLATION_INFO_END_ADDR);
956    pCheckerInfo->ulAddressEnd = BMRC_P_GET_FIELD_DATA(ulReg, ARC_0_VIOLATION_INFO_END_ADDR, ADDRESS) << BMRC_P_MEMC_ADRS_SHIFT;
957
958    ulReg = BMRC_P_Checker_Read32(hMrc, hChecker, ARC_0_VIOLATION_INFO_CMD);
959    pCheckerInfo->ulReqType = BMRC_P_GET_FIELD_DATA(ulReg, ARC_0_VIOLATION_INFO_CMD, REQ_TYPE);
960    pCheckerInfo->usClientId = BMRC_P_GET_FIELD_DATA(ulReg, ARC_0_VIOLATION_INFO_CMD, CLIENTID);
961    pCheckerInfo->ulNmbxId = BMRC_P_GET_FIELD_DATA(ulReg, ARC_0_VIOLATION_INFO_CMD, NMB);
962#endif
963
964    BMRC_Checker_GetClientInfo(hMrc, BMRC_P_GET_CLIENT_ENUM(hMrc->usMemcId, pCheckerInfo->usClientId), &stClientInfo);
965    pCheckerInfo->pchClientName = stClientInfo.pchClientName;
966
967#if BMRC_P_CHECKER_USE_VIOLATION_INFO_CLEAR
968    /* clear out violation */
969    ulReg = BMRC_P_FIELD_DATA(ARC_0_VIOLATION_INFO_CLEAR, WRITE_CLEAR, 1);
970    BMRC_P_Checker_Write32(hMrc, hChecker, ARC_0_VIOLATION_INFO_CLEAR, ulReg);
971
972    ulReg = BMRC_P_FIELD_DATA(ARC_0_VIOLATION_INFO_CLEAR, WRITE_CLEAR, 0);
973    BMRC_P_Checker_Write32(hMrc, hChecker, ARC_0_VIOLATION_INFO_CLEAR, ulReg);
974#endif
975
976    if (hChecker->pfCbFunc)
977    {
978        hChecker->pfCbFunc(hChecker->pvCbData1, hChecker->iCbData2, pCheckerInfo);
979    }
980
981    BERR_TRACE(BINT_ClearCallback_isr(hChecker->hCallback));
982    BDBG_MSG(("clear callback"));
983
984    return;
985}
986
987/***************************************************************************
988 *
989 */
990BERR_Code BMRC_P_Checker_WriteRegs
991    ( BMRC_Checker_Handle hChecker )
992{
993    BMRC_Handle hMrc;
994    uint32_t ulReg = 0;
995
996    BDBG_OBJECT_ASSERT(hChecker, BMRC_Checker);
997    hMrc = hChecker->hMrc;
998
999    if (!hChecker->bEnabled)
1000    {
1001        /* disable checker and exit */
1002        ulReg |= BMRC_P_FIELD_ENUM(ARC_0_CNTRL, WRITE_CHECK, DISABLED);
1003        ulReg |= BMRC_P_FIELD_ENUM(ARC_0_CNTRL, READ_CHECK, DISABLED);
1004
1005        BMRC_P_Checker_Write32(hMrc, hChecker, ARC_0_CNTRL, ulReg);
1006
1007        return BERR_SUCCESS;
1008    }
1009
1010    /* write clients */
1011#if BMRC_P_CLIENTS_MAX == 64
1012    ulReg = 0;
1013    ulReg |= hChecker->aulReadClients[0];
1014    BMRC_P_Checker_Write32(hMrc, hChecker, ARC_0_READ_RIGHTS_LOW, ulReg);
1015
1016    ulReg = 0;
1017    ulReg |= hChecker->aulWriteClients[0];
1018    BMRC_P_Checker_Write32(hMrc, hChecker, ARC_0_WRITE_RIGHTS_LOW, ulReg);
1019
1020        if (((hMrc->usMemcId == 0) && BCHP_MEMC_0_ARC_0_READ_RIGHTS_HIGH) ||
1021                ((hMrc->usMemcId == 1) && BCHP_MEMC_1_ARC_0_READ_RIGHTS_HIGH) ||
1022                ((hMrc->usMemcId == 2) && BCHP_MEMC_2_ARC_0_READ_RIGHTS_HIGH))
1023        {
1024                ulReg = 0;
1025                ulReg |= hChecker->aulReadClients[1];
1026                BMRC_P_Checker_Write32(hMrc, hChecker, ARC_0_READ_RIGHTS_HIGH, ulReg);
1027
1028                ulReg = 0;
1029                ulReg |= hChecker->aulWriteClients[1];
1030                BMRC_P_Checker_Write32(hMrc, hChecker, ARC_0_WRITE_RIGHTS_HIGH, ulReg);
1031        }
1032
1033#elif BMRC_P_CLIENTS_MAX == 128
1034    ulReg = 0;
1035    ulReg |= hChecker->aulReadClients[0];
1036    BMRC_P_Checker_Write32(hMrc, hChecker, ARC_0_READ_RIGHTS_0, ulReg);
1037
1038    ulReg = 0;
1039    ulReg |= hChecker->aulReadClients[1];
1040    BMRC_P_Checker_Write32(hMrc, hChecker, ARC_0_READ_RIGHTS_1, ulReg);
1041
1042    ulReg = 0;
1043    ulReg |= hChecker->aulReadClients[2];
1044    BMRC_P_Checker_Write32(hMrc, hChecker, ARC_0_READ_RIGHTS_2, ulReg);
1045
1046    ulReg = 0;
1047    ulReg |= hChecker->aulReadClients[3];
1048    BMRC_P_Checker_Write32(hMrc, hChecker, ARC_0_READ_RIGHTS_3, ulReg);
1049
1050    ulReg = 0;
1051    ulReg |= hChecker->aulWriteClients[0];
1052    BMRC_P_Checker_Write32(hMrc, hChecker, ARC_0_WRITE_RIGHTS_0, ulReg);
1053
1054    ulReg = 0;
1055    ulReg |= hChecker->aulWriteClients[1];
1056    BMRC_P_Checker_Write32(hMrc, hChecker, ARC_0_WRITE_RIGHTS_1, ulReg);
1057
1058    ulReg = 0;
1059    ulReg |= hChecker->aulWriteClients[2];
1060    BMRC_P_Checker_Write32(hMrc, hChecker, ARC_0_WRITE_RIGHTS_2, ulReg);
1061
1062    ulReg = 0;
1063    ulReg |= hChecker->aulWriteClients[3];
1064    BMRC_P_Checker_Write32(hMrc, hChecker, ARC_0_WRITE_RIGHTS_3, ulReg);
1065#else
1066#error not supported
1067#endif
1068
1069    /* write range */
1070    ulReg = 0;
1071    ulReg |= BMRC_P_FIELD_DATA(ARC_0_ADRS_RANGE_LOW, ADDRESS,
1072                             hChecker->ulStart >> BMRC_P_MEMC_ADRS_SHIFT);
1073    BMRC_P_Checker_Write32(hMrc, hChecker, ARC_0_ADRS_RANGE_LOW, ulReg);
1074
1075    /* subtract 1 from size to get correct end address offset */
1076    ulReg = 0;
1077    ulReg |= BMRC_P_FIELD_DATA(ARC_0_ADRS_RANGE_HIGH, ADDRESS,
1078                             (hChecker->ulStart + (hChecker->ulSize - 1)) >> BMRC_P_MEMC_ADRS_SHIFT);
1079    BMRC_P_Checker_Write32(hMrc, hChecker, ARC_0_ADRS_RANGE_HIGH, ulReg);
1080
1081    /* write exclusive mode */
1082    ulReg = 0;
1083    ulReg |= BMRC_P_FIELD_DATA(ARC_0_CNTRL, MODE, hChecker->bExclusive);
1084
1085    /* write access check settings */
1086    if (hChecker->eCheckType == BMRC_AccessType_eWrite)
1087    {
1088        ulReg |= BMRC_P_FIELD_ENUM(ARC_0_CNTRL, WRITE_CHECK, ENABLED);
1089        ulReg |= BMRC_P_FIELD_ENUM(ARC_0_CNTRL, READ_CHECK, DISABLED);
1090    }
1091    else if (hChecker->eCheckType == BMRC_AccessType_eRead)
1092    {
1093        ulReg |= BMRC_P_FIELD_ENUM(ARC_0_CNTRL, WRITE_CHECK, DISABLED);
1094        ulReg |= BMRC_P_FIELD_ENUM(ARC_0_CNTRL, READ_CHECK, ENABLED);
1095    }
1096    else if (hChecker->eCheckType == BMRC_AccessType_eBoth)
1097    {
1098        ulReg |= BMRC_P_FIELD_ENUM(ARC_0_CNTRL, WRITE_CHECK, ENABLED);
1099        ulReg |= BMRC_P_FIELD_ENUM(ARC_0_CNTRL, READ_CHECK, ENABLED);
1100    }
1101
1102    /* write block settings */
1103    if (hChecker->eBlockType == BMRC_AccessType_eWrite)
1104    {
1105        ulReg |= BMRC_P_FIELD_ENUM(ARC_0_CNTRL, WRITE_CMD_ABORT, ENABLED);
1106        ulReg |= BMRC_P_FIELD_ENUM(ARC_0_CNTRL, READ_CMD_ABORT, DISABLED);
1107    }
1108    else if (hChecker->eBlockType == BMRC_AccessType_eRead)
1109    {
1110        ulReg |= BMRC_P_FIELD_ENUM(ARC_0_CNTRL, WRITE_CMD_ABORT, DISABLED);
1111        ulReg |= BMRC_P_FIELD_ENUM(ARC_0_CNTRL, READ_CMD_ABORT, ENABLED);
1112    }
1113    else if (hChecker->eBlockType == BMRC_AccessType_eBoth)
1114    {
1115        ulReg |= BMRC_P_FIELD_ENUM(ARC_0_CNTRL, WRITE_CMD_ABORT, ENABLED);
1116        ulReg |= BMRC_P_FIELD_ENUM(ARC_0_CNTRL, READ_CMD_ABORT, ENABLED);
1117    }
1118    else if (hChecker->eBlockType == BMRC_AccessType_eNone)
1119    {
1120        ulReg |= BMRC_P_FIELD_ENUM(ARC_0_CNTRL, WRITE_CMD_ABORT, DISABLED);
1121        ulReg |= BMRC_P_FIELD_ENUM(ARC_0_CNTRL, READ_CMD_ABORT, DISABLED);
1122    }
1123
1124    BMRC_P_Checker_Write32(hMrc, hChecker, ARC_0_CNTRL, ulReg);
1125
1126    return BERR_SUCCESS;
1127}
1128
1129/***************************************************************************
1130 *
1131 */
1132BERR_Code BMRC_Checker_GetClientInfo(BMRC_Handle hMrc, BMRC_Client eClient, BMRC_ClientInfo *pClientInfo)
1133{
1134    BDBG_OBJECT_ASSERT(hMrc, BMRC);
1135
1136    if (eClient >= BMRC_Client_eInvalid)
1137    {
1138        pClientInfo->eClient = BMRC_Client_eInvalid;
1139        pClientInfo->pchClientName = "UNKNOWN";
1140        pClientInfo->usClientId = BMRC_Client_eInvalid; /* NOTE: this assumes that the max SW enum is > the max HW client id */
1141        return BERR_TRACE(BERR_INVALID_PARAMETER);
1142    }
1143    else
1144    {
1145        pClientInfo->eClient = eClient;
1146        pClientInfo->pchClientName = BMRC_P_astClientTbl[eClient].pchClientName;
1147        pClientInfo->usClientId = BMRC_P_GET_CLIENT_ID(hMrc->stSettings.usMemcId, eClient);
1148        return BERR_SUCCESS;
1149    }
1150}
1151
1152
1153#else /* BMRC_STUB */
1154BERR_Code BMRC_Open
1155    ( BMRC_Handle                     *phMrc,        /* [out] MRC handle to be returned */
1156      BREG_Handle                      hRegister,    /* [in] Register access handle */
1157      BINT_Handle                      hInterrupt,   /* [in] Interrupt handle */
1158      const BMRC_Settings             *pDefSettings  /* [in] Default settings */
1159    )
1160{
1161    BSTD_UNUSED(phMrc);
1162    BSTD_UNUSED(hRegister);
1163    BSTD_UNUSED(hInterrupt);
1164    BSTD_UNUSED(pDefSettings);
1165    return BERR_NOT_SUPPORTED;
1166}
1167
1168BERR_Code BMRC_Close
1169    ( BMRC_Handle hMrc )
1170{
1171    BSTD_UNUSED(hMrc);
1172    return BERR_NOT_SUPPORTED;
1173}
1174
1175BERR_Code BMRC_Checker_Create
1176    ( BMRC_Handle hMrc,               /* [in] MRC Module Handle */
1177      BMRC_Checker_Handle *phChecker  /* [out] Checker handle to be returned */
1178    )
1179{
1180    BSTD_UNUSED(hMrc);
1181    BSTD_UNUSED(phChecker);
1182    return BERR_NOT_SUPPORTED;
1183}
1184
1185BERR_Code BMRC_Checker_Destroy
1186    ( BMRC_Checker_Handle hChecker  /* [in] Checker handle to be destroyed */
1187    )
1188{
1189    BSTD_UNUSED(hChecker);
1190    return BERR_NOT_SUPPORTED;
1191}
1192
1193BERR_Code BMRC_Checker_SetRange
1194    ( BMRC_Checker_Handle hChecker,  /* [in] Checker handle */
1195      uint32_t ulStart,              /* [in] Memory range start address */
1196      uint32_t ulSize                /* [in] Memory range size */
1197    )
1198{
1199    BSTD_UNUSED(hChecker);
1200    BSTD_UNUSED(ulStart);
1201    BSTD_UNUSED(ulSize);
1202    return BERR_NOT_SUPPORTED;
1203}
1204
1205BERR_Code BMRC_Checker_SetAccessCheck
1206    ( BMRC_Checker_Handle hChecker,  /* [in] Checker handle */
1207      BMRC_AccessType eAccessType    /* [in] Access type to check */
1208    )
1209{
1210    BSTD_UNUSED(hChecker);
1211    BSTD_UNUSED(eAccessType);
1212    return BERR_NOT_SUPPORTED;
1213}
1214
1215BERR_Code BMRC_Checker_SetBlock
1216    ( BMRC_Checker_Handle hChecker,  /* [in] Checker handle */
1217      BMRC_AccessType eBlockType     /* [in] Access type to block on violations*/
1218    )
1219{
1220    BSTD_UNUSED(hChecker);
1221    BSTD_UNUSED(eBlockType);
1222    return BERR_NOT_SUPPORTED;
1223}
1224
1225BERR_Code BMRC_Checker_SetExclusive
1226    ( BMRC_Checker_Handle hChecker,  /* [in] Checker handle */
1227      bool bExclusive                /* [in] Enable/disable exclusive mode */
1228    )
1229{
1230    BSTD_UNUSED(hChecker);
1231    BSTD_UNUSED(bExclusive);
1232    return BERR_NOT_SUPPORTED;
1233}
1234
1235BERR_Code BMRC_Checker_SetClient
1236    ( BMRC_Checker_Handle hChecker,  /* [in] Checker handle */
1237      BMRC_Client eClient,           /* [in] The client to configure */
1238      BMRC_AccessType eAccessType    /* [in] The client's access rights */
1239    )
1240{
1241    BSTD_UNUSED(hChecker);
1242    BSTD_UNUSED(eClient);
1243    BSTD_UNUSED(eAccessType);
1244    return BERR_NOT_SUPPORTED;
1245}
1246
1247BERR_Code BMRC_Checker_Enable
1248    ( BMRC_Checker_Handle hChecker  /* [in] Checker handle */
1249    )
1250{
1251    BSTD_UNUSED(hChecker);
1252    return BERR_NOT_SUPPORTED;
1253}
1254
1255
1256BERR_Code BMRC_Checker_Disable
1257    ( BMRC_Checker_Handle hChecker  /* [in] Checker handle */
1258    )
1259{
1260    BSTD_UNUSED(hChecker);
1261    return BERR_NOT_SUPPORTED;
1262}
1263
1264BERR_Code BMRC_Checker_EnableCallback
1265    ( BMRC_Checker_Handle hChecker  /* [in] Checker handle */
1266    )
1267{
1268    BSTD_UNUSED(hChecker);
1269    return BERR_NOT_SUPPORTED;
1270}
1271
1272BERR_Code BMRC_Checker_DisableCallback
1273    ( BMRC_Checker_Handle hChecker  /* [in] Checker handle */
1274    )
1275{
1276    BSTD_UNUSED(hChecker);
1277    return BERR_NOT_SUPPORTED;
1278}
1279
1280BERR_Code BMRC_Checker_EnableCallback_isr
1281    ( BMRC_Checker_Handle hChecker  /* [in] Checker handle */
1282    )
1283{
1284    BSTD_UNUSED(hChecker);
1285    return BERR_NOT_SUPPORTED;
1286}
1287
1288BERR_Code BMRC_Checker_DisableCallback_isr
1289    ( BMRC_Checker_Handle hChecker  /* [in] Checker handle */
1290    )
1291{
1292    BSTD_UNUSED(hChecker);
1293    return BERR_NOT_SUPPORTED;
1294}
1295
1296BERR_Code BMRC_Checker_SetCallback
1297    ( BMRC_Checker_Handle hChecker,          /* [in] Checker handle */
1298      const BMRC_CallbackFunc_isr pfCbFunc,  /* [in] Pointer to the callback function */
1299      void *pvCbData1,                       /* [in] User defined callback data structure. */
1300      int iCbData2)                          /* [in] User defined callback value */
1301{
1302    BSTD_UNUSED(hChecker);
1303    BSTD_UNUSED(pfCbFunc);
1304    BSTD_UNUSED(pvCbData1);
1305    BSTD_UNUSED(iCbData2);
1306    return BERR_NOT_SUPPORTED;
1307}
1308#endif
1309
1310/* End of File */
Note: See TracBrowser for help on using the repository browser.