Context Navigation

brdc_blockout_priv.c

Last change on this file was 2, checked in by jglee, 11 years ago
first commit
Property svn:executable set to ``*
File size: 15.9 KB

Line
1	/***************************************************************************
2	* Copyright (c) 2005-2009, 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: brdc_blockout_priv.c $
11	* $brcm_Revision: Hydra_Software_Devel/6 $
12	* $brcm_Date: 6/9/09 6:21p $
13	*
14	* Module Description:
15	*
16	* Revision History:
17	*
18	* $brcm_Log: /magnum/commonutils/rdc/7038/brdc_blockout_priv.c $
19	*
20	* Hydra_Software_Devel/6 6/9/09 6:21p pntruong
21	* PR55861: Added support for hw blockout and timestamp.
22	*
23	* Hydra_Software_Devel/5 3/24/09 5:28p albertl
24	* PR52513: Moved RDC debug globals into hList structure.
25	*
26	* Hydra_Software_Devel/4 7/9/08 10:32a jessem
27	* PR 44647: Corrected bounds check on ulRegBlock parameter in
28	* BRDC_P_ValidateBlockOutRegisters.
29	*
30	* Hydra_Software_Devel/3 3/5/08 10:53a jessem
31	* PR 38623: Removed stdio.h and errno.h.
32	*
33	* Hydra_Software_Devel/2 2/28/08 5:55p jessem
34	* PR 38623: Changed register validation to support 3563 only.
35	*
36	* Hydra_Software_Devel/1 2/28/08 5:46p jessem
37	* PR 38623: Initial version
38	*
39	***************************************************************************/
40	#include "bstd.h"
41	#include "bdbg.h"
42	#include "bkni.h"
43
44	#include "bchp_common.h"
45	#include "brdc.h"
46	#include "brdc_dbg.h"
47	#include "brdc_private.h"
48	#include "brdc_blockout_priv.h"
49
50	BDBG_MODULE(BRDC_BLOCKOUT);
51
52	typedef struct
53	{
54	uint32_t ulOpcode;
55	uint32_t ulReadSize;
56	uint32_t ulWriteSize;
57	uint32_t ulArg;
58	uint32_t ulNumImmData;
59	uint32_t ulSrcReg;
60	uint32_t ulDstReg;
61	} BRDC_RulEntry;
62
63	typedef struct
64	{
65	uint32_t ulReg2BlockOutStart;
66	uint32_t ulReg2BlockOutEnd;
67	} BRDC_Reg2BlockOut;
68
69	/* Checks if register block is to blocked out andif so return start and end registers that are blocked. */
70	static bool BRDC_P_CheckAndGetBlockOutRegs
71	( BRDC_Handle hRdc,
72	uint32_t ulRegister,
73	uint32_t ulBlockSize,
74	BRDC_Reg2BlockOut *pstReg2BlockOut,
75	uint32_t *pNumRegRangesBlocked )
76	{
77	uint32_t i, j;
78	bool bGotStart = false, bGotEnd = false;
79	bool bBlockOut = false;
80	uint32_t ulReg2CheckStart;
81	uint32_t ulReg2CheckEnd;
82	BRDC_BlockOut *pstRegBlockOutList = hRdc->astBlockOut;
83
84	*pNumRegRangesBlocked = 0;
85
86	for (i=0; i<BRDC_MAX_RDC_BLOCKOUT_LIST_COUNT; i++)
87	{
88	uint32_t ulRegBlockOutListStart, ulRegBlockOutListEnd;
89	bGotStart = bGotEnd = false;
90
91	if (pstRegBlockOutList[i].bEnable)
92	{
93	ulRegBlockOutListStart = pstRegBlockOutList[i].ulStartRegAddr;
94	ulRegBlockOutListEnd = pstRegBlockOutList[i].ulStartRegAddr +
95	((pstRegBlockOutList[i].ulBlockSize-1) * sizeof(uint32_t));
96
97	ulReg2CheckStart = ulRegister;
98	ulReg2CheckEnd = ulRegister + ((ulBlockSize-1) * sizeof(uint32_t));
99
100	for (j=0; j<ulBlockSize; j++)
101	{
102	if ((ulReg2CheckStart >= ulRegBlockOutListStart) &&
103	(ulReg2CheckStart <= ulRegBlockOutListEnd))
104	{
105	if (!bGotStart)
106	{
107	bGotStart = true;
108	pstReg2BlockOut[*pNumRegRangesBlocked].ulReg2BlockOutStart =
109	(ulReg2CheckStart <= ulRegBlockOutListStart) ? ulRegBlockOutListStart : ulReg2CheckStart;
110	}
111	}
112
113	if (!bGotEnd && bGotStart)
114	{
115	bGotEnd = bBlockOut = true;
116	pstReg2BlockOut[*pNumRegRangesBlocked].ulReg2BlockOutEnd =
117	(ulReg2CheckEnd < ulRegBlockOutListEnd) ? ulReg2CheckEnd : ulRegBlockOutListEnd;
118	(*pNumRegRangesBlocked)++;
119	break;
120	}
121
122	ulReg2CheckStart += sizeof(uint32_t);
123
124	if (bBlockOut)
125	{
126	BDBG_MSG(("Register block 0x%x to 0x%x blocked",
127	pstReg2BlockOut[*pNumRegRangesBlocked].ulReg2BlockOutStart,
128	pstReg2BlockOut[*pNumRegRangesBlocked].ulReg2BlockOutEnd));
129	}
130	}
131	}
132	}
133
134	if (!bBlockOut)
135	{
136	BDBG_MSG(("Reg block 0x%x to 0x%x not blocked", ulRegister,
137	ulRegister + (ulBlockSize - 1) * 4));
138	}
139
140	return bBlockOut;
141	}
142
143
144	static bool BRDC_P_PopulateRevisedRul_isr
145	( BRDC_Handle hRdc,
146	BRDC_List_Handle hList,
147	uint32_t **pulOrigRulAddr,
148	uint32_t **pulRevisedRulAddr,
149	BRDC_RulEntry *pstRulEntry )
150	{
151	uint32_t ulOpcode;
152	uint32_t i;
153	BRDC_DBG_ListEntry eEntry;
154	uint32_t aulArgs[4];
155	bool bBlockOut;
156	uint32_t ulNumRegRangesBlocked;
157
158	BRDC_Reg2BlockOut astReg2BlockOut[BRDC_MAX_RDC_BLOCKOUT_LIST_COUNT];
159
160	BKNI_Memset((void *)astReg2BlockOut, 0x0,
161	sizeof(BRDC_Reg2BlockOut) * BRDC_MAX_RDC_BLOCKOUT_LIST_COUNT);
162
163	/* check if RUL has blocked out registers */
164	bBlockOut = BRDC_P_CheckAndGetBlockOutRegs(hRdc,
165	pstRulEntry->ulDstReg, pstRulEntry->ulWriteSize,
166	astReg2BlockOut, &ulNumRegRangesBlocked);
167
168	if (bBlockOut)
169	{
170	uint32_t ulWriteSize = 0;
171	uint32_t ulDstReg = pstRulEntry->ulDstReg;
172	uint32_t ulSrcReg = pstRulEntry->ulSrcReg;
173	uint32_t ulNumImmData;
174
175	if ((pstRulEntry->ulOpcode == BRDC_OP_IMMS_TO_REGS_OPCODE) \|\|
176	(pstRulEntry->ulOpcode == BRDC_OP_REGS_TO_REGS_OPCODE) \|\|
177	(pstRulEntry->ulOpcode == BRDC_OP_REG_TO_REGS_OPCODE))
178	{
179	for (i=0; i<ulNumRegRangesBlocked; i++)
180	{
181	/* get write size */
182	ulWriteSize = (astReg2BlockOut[i].ulReg2BlockOutStart - ulDstReg) / sizeof(uint32_t);
183
184	/* Check if the RUL is completely inside a blocked out range. If so, exclude it. */
185	if (ulWriteSize > 0)
186	{
187	ulOpcode = pstRulEntry->ulOpcode \| ((ulWriteSize & UINT32_C(0xFFF)) - 1);
188	(pulRevisedRulAddr) = ulOpcode;
189	(*pulRevisedRulAddr)++;
190
191	if ((pstRulEntry->ulOpcode == BRDC_OP_REGS_TO_REGS_OPCODE) \|\|
192	(pstRulEntry->ulOpcode == BRDC_OP_REG_TO_REGS_OPCODE))
193	{
194	(pulRevisedRulAddr) = BRDC_REGISTER(ulSrcReg);
195	(*pulRevisedRulAddr)++;
196	}
197
198	(pulRevisedRulAddr) = BRDC_REGISTER(ulDstReg);
199	(*pulRevisedRulAddr)++;
200	}
201
202	if (pstRulEntry->ulOpcode == BRDC_OP_IMMS_TO_REGS_OPCODE)
203	{
204	uint32_t j;
205
206	/* The number of imm data includes the inculded and excluded data.
207	The excluded data will be dropped. */
208	ulNumImmData = ulWriteSize + (((astReg2BlockOut[i].ulReg2BlockOutEnd -
209	astReg2BlockOut[i].ulReg2BlockOutStart) / sizeof(uint32_t)) + 1);
210
211	/* Get immediate data */
212	for (j=0; j<ulNumImmData; j++)
213	{
214	/* Increment original RUL list to keep in pace with the
215	RUL entry retrieval order and amount. */
216	(*pulOrigRulAddr)++;
217
218	if(BRDC_DBG_GetListEntry_isr(hList, &eEntry, aulArgs))
219	{
220	/* error */
221	BDBG_ERR(("ERROR parsing list %d", __LINE__));
222	}
223	else if (eEntry == BRDC_DBG_ListEntry_eEnd)
224	{
225	BDBG_ERR(("Incorrect number of RUL entries"));
226	}
227	else
228	{
229	/* ignore imm data after write size since the dest for these data are
230	blocked but continue to get it to set the RUL pointer
231	to the correct location */
232	if (j < ulWriteSize)
233	{
234	(pulRevisedRulAddr) = aulArgs[0];
235	(*pulRevisedRulAddr)++;
236	}
237	}
238	}
239	}
240
241	/* get next dest reg */
242	ulDstReg = astReg2BlockOut[i].ulReg2BlockOutEnd + (1 * sizeof(uint32_t));
243
244	/* get next src reg */
245	if (pstRulEntry->ulOpcode == BRDC_OP_REGS_TO_REGS_OPCODE)
246	{
247	ulSrcReg += (ulWriteSize * sizeof(uint32_t)) + (astReg2BlockOut[i].ulReg2BlockOutEnd -
248	astReg2BlockOut[i].ulReg2BlockOutStart);
249	}
250	}
251
252	/* Check if there are some remaining writes to be made */
253	if (ulDstReg < (pstRulEntry->ulDstReg + (pstRulEntry->ulWriteSize * sizeof(uint32_t))))
254	{
255	ulWriteSize = ((pstRulEntry->ulDstReg + (pstRulEntry->ulWriteSize * sizeof(uint32_t))) -
256	ulDstReg) / sizeof(uint32_t);
257
258	ulOpcode = pstRulEntry->ulOpcode \| ((ulWriteSize & UINT32_C(0xFFF)) - 1);
259	(pulRevisedRulAddr) = ulOpcode;
260	(*pulRevisedRulAddr)++;
261
262	if ((pstRulEntry->ulOpcode == BRDC_OP_REGS_TO_REGS_OPCODE) \|\|
263	(pstRulEntry->ulOpcode == BRDC_OP_REG_TO_REGS_OPCODE))
264	{
265	(pulRevisedRulAddr) = BRDC_REGISTER(ulSrcReg);
266	(*pulRevisedRulAddr)++;
267	}
268
269	(pulRevisedRulAddr) = BRDC_REGISTER(ulDstReg);
270	(*pulRevisedRulAddr)++;
271
272	if (pstRulEntry->ulOpcode == BRDC_OP_IMMS_TO_REGS_OPCODE)
273	{
274	/* Get immediate data */
275	for (i=0; i<ulWriteSize; i++)
276	{
277	/* Increment original RUL list to keep in pace with the
278	RUL entry retrieval order and amount. */
279	(*pulOrigRulAddr)++;
280
281	if (BRDC_DBG_GetListEntry_isr(hList, &eEntry, aulArgs))
282	{
283	/* error */
284	BDBG_ERR(("ERROR parsing list %d", __LINE__));
285	}
286	else if (eEntry == BRDC_DBG_ListEntry_eEnd)
287	{
288	BDBG_ERR(("Incorrect number of RUL entries"));
289	}
290	else
291	{
292	(pulRevisedRulAddr) = aulArgs[0];
293	(*pulRevisedRulAddr)++;
294	}
295	}
296	}
297	}
298	}
299	else
300	{
301	BDBG_MSG(("Register 0x%x blocked", pstRulEntry->ulDstReg));
302	}
303	}
304
305	return bBlockOut;
306	}
307
308
309	/* Searches a list and looks for the specified register blocks. If found, create a new list that
310	excludes these registers and replace the list with the new one. */
311	BERR_Code BRDC_P_ParseAndReplaceRul_isr
312	( BRDC_List_Handle hList)
313	{
314	BERR_Code err = BERR_SUCCESS;
315	BRDC_DBG_ListEntry eEntry;
316	uint32_t aulArgs[4];
317	bool bRegWrite = false;
318	bool bReg2RegWrite = false;
319	bool bGo = false;
320	uint32_t pulAddress, pulStartAddress, pulRevisedRulStartAddr, pulRevisedRulCurrAddr;
321	uint32_t ulOpcode = 0, ulSrcRegAddr = 0, ulDstRegAddr = 0;
322	uint32_t ulNumEntries;
323	BRDC_RulEntry stRulEntry;
324	BRDC_Handle hRdc;
325	BRDC_List_Handle hRdcBlockOutList;
326
327	BDBG_ASSERT(hList);
328
329	hRdc = hList->hRdc;
330	hRdcBlockOutList = hRdc->hRdcBlockOutList;
331
332	/* get address to list */
333	pulStartAddress = pulAddress = BRDC_List_GetStartAddress_isr(hList);
334	pulRevisedRulStartAddr = pulRevisedRulCurrAddr = BRDC_List_GetStartAddress_isr(hRdcBlockOutList);
335
336	/* prepare to traverse this list */
337	err = BRDC_DBG_SetList_isr(hList);
338	if (err != BERR_SUCCESS)
339	{
340	/* error */
341	BDBG_ERR(("ERROR parsing list %d", __LINE__));
342	goto done;
343	}
344
345	/* get first entry in list */
346	err = BRDC_DBG_GetListEntry_isr(hList, &eEntry, aulArgs);
347	if (err != BERR_SUCCESS)
348	{
349	/* error */
350	BDBG_ERR(("ERROR parsing list %d", __LINE__));
351	goto done;
352	}
353
354	/* traverse until finished */
355	while(eEntry != BRDC_DBG_ListEntry_eEnd)
356	{
357	/* command entry? */
358	if(eEntry == BRDC_DBG_ListEntry_eCommand)
359	{
360	/* init */
361	BKNI_Memset((void *)&stRulEntry, 0x0, sizeof(BRDC_RulEntry));
362	stRulEntry.ulReadSize = stRulEntry.ulWriteSize = 1;
363	ulOpcode = ulSrcRegAddr = ulDstRegAddr = 0;
364	bRegWrite = bReg2RegWrite = false;
365	bGo = false;
366
367	/* Get the opcode and its args */
368	stRulEntry.ulOpcode = aulArgs[0];
369
370	/* is this a write to register command? */
371	switch(stRulEntry.ulOpcode)
372	{
373	case BRDC_OP_VAR_TO_REG_OPCODE:
374	stRulEntry.ulArg = aulArgs[1];
375	bRegWrite = true;
376	break;
377	case BRDC_OP_IMM_TO_REG_OPCODE:
378	stRulEntry.ulNumImmData = 1;
379	bRegWrite = true;
380	break;
381	case BRDC_OP_IMMS_TO_REG_OPCODE:
382	stRulEntry.ulNumImmData = aulArgs[1];
383	bRegWrite = true;
384	break;
385	case BRDC_OP_IMMS_TO_REGS_OPCODE:
386	stRulEntry.ulReadSize = stRulEntry.ulWriteSize = stRulEntry.ulNumImmData = aulArgs[1];
387	bRegWrite = true;
388	break;
389	case BRDC_OP_REG_TO_REG_OPCODE:
390	stRulEntry.ulArg = aulArgs[1];
391	bReg2RegWrite = true;
392	break;
393	case BRDC_OP_REGS_TO_REG_OPCODE:
394	stRulEntry.ulReadSize = aulArgs[1];
395	bReg2RegWrite = true;
396	break;
397	case BRDC_OP_REGS_TO_REGS_OPCODE:
398	stRulEntry.ulReadSize = stRulEntry.ulWriteSize = aulArgs[1];
399	bReg2RegWrite = true;
400	break;
401	case BRDC_OP_REG_TO_REGS_OPCODE:
402	stRulEntry.ulWriteSize = aulArgs[1];
403	bReg2RegWrite = true;
404	break;
405	default:
406	break;
407	}
408
409	/* store opcode */
410	ulOpcode = *pulAddress;
411
412	}
413	else if (eEntry == BRDC_DBG_ListEntry_eRegister)
414	{
415	if (bRegWrite)
416	{
417	stRulEntry.ulDstReg = aulArgs[0];
418	ulDstRegAddr = *pulAddress;
419	bGo = true;
420	}
421	else if (bReg2RegWrite)
422	{
423	if (stRulEntry.ulSrcReg)
424	{
425	/* Got dest register block */
426	stRulEntry.ulDstReg = aulArgs[0];
427	ulDstRegAddr = *pulAddress;
428	bGo = true;
429	}
430	else
431	{
432	/* Got src register block */
433	stRulEntry.ulSrcReg = aulArgs[0];
434	ulSrcRegAddr = *pulAddress;
435	}
436	}
437	}
438	else /* eEntry == BRDC_DBG_ListEntry_eData */
439	{
440	bGo = false;
441	}
442
443	/* RUL doesn't write to any registers.
444	Or get the rest of the immediate data if opcode
445	involves a register write that is not blocked.
446	*/
447	if (!bRegWrite && !bReg2RegWrite)
448	{
449	/* Simply add the unrevised RUL entry */
450	pulRevisedRulCurrAddr = pulAddress;
451	pulRevisedRulCurrAddr++;
452	}
453	else
454	{
455	if (bGo)
456	{
457	/* Revise the RUL entries if dest register/s is/are blocked.
458	Any immeditate data will be grabbed inside the call.*/
459	if (BRDC_P_PopulateRevisedRul_isr(hRdc, hList,
460	&pulAddress, &pulRevisedRulCurrAddr, &stRulEntry) == false)
461	{
462	/* Dest register/s aren't blocked so restore original RUL entries */
463	*pulRevisedRulCurrAddr = ulOpcode;
464	pulRevisedRulCurrAddr++;
465
466	if (ulSrcRegAddr)
467	{
468	*pulRevisedRulCurrAddr = ulSrcRegAddr;
469	pulRevisedRulCurrAddr++;
470	}
471
472	*pulRevisedRulCurrAddr = ulDstRegAddr;
473	pulRevisedRulCurrAddr++;
474
475	/* this allows immediate data, if any, to get stored */
476	bRegWrite = bReg2RegWrite = false;
477	}
478	}
479	}
480
481	/* get next entry in list */
482	pulAddress++;
483
484	if(BRDC_DBG_GetListEntry_isr(hList, &eEntry, aulArgs))
485	{
486	/* error */
487	BDBG_ERR(("ERROR parsing list %d", __LINE__));
488	goto done;
489	}
490	}
491
492	/* Recopy to current RUL */
493	ulNumEntries = pulRevisedRulCurrAddr - pulRevisedRulStartAddr;
494
495	BDBG_MSG(("%d revised RUL entries", ulNumEntries));
496	BDBG_MSG(("%d orig RUL entries", (pulStartAddress - pulAddress)));
497
498	BDBG_ASSERT(ulNumEntries < BRDC_P_RDC_BLOCKOUT_RUL_MAX_ENTRY);
499	BKNI_Memcpy(pulStartAddress, pulRevisedRulStartAddr, sizeof(uint32_t) * ulNumEntries);
500	BRDC_List_SetNumEntries_isr(hList, ulNumEntries);
501
502	done:
503	return err;
504	}
505
506	BERR_Code BRDC_P_ValidateBlockOutRegisters
507	( const BRDC_BlockOut *pstBlockOut,
508	uint32_t ulRegBlock )
509	{
510	BERR_Code err = BERR_SUCCESS;
511
512	if (ulRegBlock >= BRDC_MAX_RDC_BLOCKOUT_LIST_COUNT)
513	{
514	BDBG_ERR(("Only %d register blocks are allowed",
515	BRDC_MAX_RDC_BLOCKOUT_LIST_COUNT));
516	err = BERR_INVALID_PARAMETER;
517	return err;
518	}
519	else
520	{
521	uint32_t ulStartAddr;
522	uint32_t ulEndAddr;
523
524	ulStartAddr = pstBlockOut->ulStartRegAddr;
525	ulEndAddr = pstBlockOut->ulStartRegAddr + (pstBlockOut->ulBlockSize * sizeof(uint32_t));
526
527	#ifdef BCHP_REGISTER_END
528	if ((ulStartAddr > BCHP_REGISTER_END) \|\| (ulEndAddr > BCHP_REGISTER_END))
529	{
530	BDBG_ERR(("Register block 0x%x to 0x%x is out of valid register range",
531	ulStartAddr, ulEndAddr));
532	err = BERR_INVALID_PARAMETER;
533	return err;
534	}
535	#endif
536	}
537	return err;
538	}
539
540	BERR_Code BRDC_P_RdcBlockOutInit
541	( BRDC_Handle hRdc )
542	{
543	BERR_Code err = BERR_SUCCESS;
544
545	BKNI_Memset((void )hRdc->astBlockOut, 0x0, sizeof(BRDC_BlockOut) BRDC_MAX_RDC_BLOCKOUT_LIST_COUNT);
546
547	err = BRDC_List_Create(hRdc, BRDC_P_RDC_BLOCKOUT_RUL_MAX_ENTRY, &hRdc->hRdcBlockOutList);
548	if (err != BERR_SUCCESS)
549	{
550	BDBG_ERR(("ERROR: BRDC_List_Create"));
551	}
552
553	hRdc->bRdcBlockOutEnabled = false;
554	return err;
555	}
556
557	BERR_Code BRDC_P_RdcBlockOutDestroy
558	( BRDC_Handle hRdc )
559	{
560	BERR_Code err = BERR_SUCCESS;
561
562	if (hRdc->hRdcBlockOutList)
563	{
564	/* deallocate RDC blockout list */
565	err = BRDC_List_Destroy(hRdc->hRdcBlockOutList);
566	if (err != BERR_SUCCESS)
567	{
568	BDBG_ERR(("ERROR: BRDC_List_Create"));
569	return err;
570	}
571	hRdc->hRdcBlockOutList = NULL;
572	}
573
574	hRdc->bRdcBlockOutEnabled = false;
575
576	return err;
577	}
578
579	bool BRDC_P_IsRdcBlockOutEnabled
580	( BRDC_Handle hRdc )
581	{
582	uint32_t i;
583	bool bEnabled = false;
584
585	/* Find a register block that is enabled for block out */
586	for(i=0; i<BRDC_MAX_RDC_BLOCKOUT_LIST_COUNT; i++)
587	{
588	if ((hRdc->astBlockOut[i].bEnable == true) && (hRdc->bRdcBlockOutEnabled))
589	{
590	bEnabled = true;
591	break;
592	}
593	}
594	return bEnabled;
595	}
596
597	/* End of file */

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: svn/trunk/newcon3bcm2_21bu/magnum/commonutils/rdc/7552/brdc_blockout_priv.c

Download in other formats: