Context Navigation

bscd.c

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

Line
1	/***************************************************************************
2	* Copyright (c) 2003-2012, 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: bscd.c $
11	* $brcm_Revision: Hydra_Software_Devel/26 $
12	* $brcm_Date: 3/21/12 4:11p $
13	*
14	* Module Description:
15	*
16	* Revision History:
17	* $brcm_Log: /magnum/portinginterface/scd/7435/bscd.c $
18	*
19	* Hydra_Software_Devel/26 3/21/12 4:11p mward
20	* SW7435-18: Compile error / typo.
21	*
22	* Hydra_Software_Devel/25 3/20/12 2:52p qxie
23	* SW7435-18: add support to 7435
24	*
25	* Hydra_Software_Devel/24 2/10/12 2:32p qxie
26	* SW7346-23: add CustomerE
27	*
28	* Hydra_Software_Devel/23 12/1/11 4:09p qxie
29	* SW7346-23: add support to E* direct connect card
30	*
31	* Hydra_Software_Devel/22 10/13/11 5:19p qxie
32	* SW7346-23:Fix a bug in BSCD_Channel_Deactivate() which put IO line in
33	* an unknow state
34	*
35	* Hydra_Software_Devel/21 10/11/11 3:59p qxie
36	* SW7231-136: fix a bug for 3V/5V control in 7344
37	*
38	* Hydra_Software_Devel/20 9/9/11 11:09a qxie
39	* SW7231-136: fix a typo
40	*
41	* Hydra_Software_Devel/19 8/19/11 11:28a dlwin
42	* SW7346-461: Resolved Coverity: 35203 for 40nm chips.
43	*
44	* Hydra_Software_Devel/18 6/30/11 4:47p qxie
45	* SW7358-43: add smartcard support to 7358(chnagerst line initial state)
46	*
47	* Hydra_Software_Devel/17 6/20/11 6:05p qxie
48	* SW7552-39:add smartcard support for 7552
49	*
50	* Hydra_Software_Devel/16 5/31/11 6:10p qxie
51	* SW7358-43:add smartcard support to 7358
52	*
53	* Hydra_Software_Devel/15 5/24/11 11:48a qxie
54	* SW7346-218:Need to add support for the smartcard controller chips
55	* TDA803x
56	*
57	* Hydra_Software_Devel/14 5/23/11 10:03a qxie
58	* SW7344-54: add smartcard support to 7344
59	*
60	* Hydra_Software_Devel/13 5/20/11 4:56p qxie
61	* SW7344-54: add smartcard support to 7344
62	*
63	* Hydra_Software_Devel/12 5/10/11 1:47p gmohile
64	* SW7231-128 : Add power management support
65	*
66	* Hydra_Software_Devel/11 5/6/11 2:22p qxie
67	* SW7358-43: add smartcard support to 7358
68	*
69	* Hydra_Software_Devel/10 4/29/11 3:57p qxie
70	* SW7231-136:add smartcard support to 7231
71	*
72	* Hydra_Software_Devel/9 4/1/11 3:41p qxie
73	* sw7346-23: smartcard: add 3V/5V support and no TDA8024 support
74	*
75	* Hydra_Software_Devel/8 1/31/11 1:39p hongtaoz
76	* SW7346-23: fixed compile error for 7425;
77	*
78	* Hydra_Software_Devel/7 1/31/11 11:57a qxie
79	* SW7346-23:missing "#"
80	*
81	* Hydra_Software_Devel/6 1/28/11 5:04p qxie
82	* SW7346-23:add support to 7346
83	*
84	* Hydra_Software_Devel/5 1/12/11 12:02p katrep
85	* SW7231-2:fixed compiler warnings
86	*
87	*
88	************************************************************************/
89
90	#include "bstd.h"
91	#include "bkni.h"
92	#include "bchp_pm.h"
93	#include "bchp_sca.h"
94	#include "bchp_scb.h"
95
96	#include "bchp_scirq0.h"
97	#include "bchp_sun_top_ctrl.h"
98
99	#include "bscd.h"
100	#include "bscd_priv.h"
101	#include "bint.h"
102	#include "bchp_int_id_scirq0.h"
103	#include "bchp_gio.h"
104
105	#ifdef BCHP_PWR_SUPPORT
106	#include "bchp_pwr.h"
107	#endif
108
109	#if (BCHP_CHIP==7344)
110	#include "bchp_aon_pin_ctrl.h"
111	#include "bchp_gio_aon.h"
112	#endif
113
114	#define BCHP_SCA_SC_CLK_CMD_clk_en_MASK BCHP_SCA_SC_CLK_CMD_1_clk_en_MASK
115
116
117
118	#if 1
119	#undef BDBG_ENTER
120	#undef BDBG_LEAVE
121	#define BDBG_ENTER(x)
122	#define BDBG_LEAVE(x)
123	#endif
124
125	BDBG_MODULE(BSCD);
126
127
128	/*******************************************************************************
129	* Default Module and Channel Settings. Note that we could only modify
130	* Module settings during BSCD_Open.
131	*******************************************************************************/
132	static const BSCD_Settings BSCD_defScdSettings =
133	{
134	/* This attribute indicates the source of clock and the value */
135	{BSCD_ClockFreqSrc_eInternalClock, 27000000, false, false},
136
137	/* maximum SCD channels supported */
138	BSCD_MAX_SUPPOTED_CHANNELS,
139	NULL,
140	};
141
142	static const BSCD_ChannelSettings BSCD_defScdChannelSettings =
143	{
144	/* Smart Card Standard */
145	BSCD_Standard_eNDS,
146
147	/* Asynchronous Protocol Types. */
148	BSCD_AsyncProtocolType_e0,
149
150	/* This read-only attribute specifies the default
151	source clock frequency in Hz. */
152	BSCD_INTERNAL_CLOCK_FREQ,
153
154	/* ICC CLK frequency in Hz which is
155	source freq / SC_CLK_CMD[etu_clkdiv] / SC_CLK_CMD[sc_clkdiv] */
156	BSCD_INTERNAL_CLOCK_FREQ/BSCD_DEFAULT_ETU_CLKDIV/BSCD_DEFAULT_SC_CLKDIV,
157
158	/* ETU in microseconds which is source freq / SC_CLK_CMD[etu_clkdiv] */
159	/* (SC_PRESCALE * external_clock_div + (external_clock_div - 1)) */
160	BSCD_INTERNAL_CLOCK_FREQ/BSCD_DEFAULT_ETU_CLKDIV/(BSCD_DEFAULT_PRESCALE+1)/BSCD_DEFAULT_BAUD_DIV,
161
162	/* This read-only attribute specifies the maximum IFSD.
163	Should be 264. */
164	BSCD_MAX_TX_SIZE,
165
166	/* This attribute indicates the current IFSD */
167	BSCD_DEFAULT_EMV_INFORMATION_FIELD_SIZE,
168
169	/* Clock Rate Conversion Factor,
170	F in 1,2,3,4,5,6,9, 10, 11, 12 or 13.
171	Default is 1. */
172	BSCD_DEFAULT_F,
173
174	/* Baud Rate Adjustment Factor,
175	D in 1,2,3,4,5,6,8 or 9.
176	Default is 1. */
177	BSCD_DEFAULT_D,
178
179	/* ETU Clock Divider in
180	SC_CLK_CMD register. Valid value is
181	from 1 to 8. Default is 6. */
182	BSCD_DEFAULT_ETU_CLKDIV,
183
184	/* SC Clock Divider in
185	SC_CLK_CMD register. Valid value is
186	1,2,3,4,5,8,10,16. Default is 1. */
187	BSCD_DEFAULT_SC_CLKDIV,
188
189	/* Prescale Value */
190	BSCD_DEFAULT_PRESCALE,
191
192	/* external clock divisor */
193	BSCD_DEFAULT_EXTERNAL_CLOCK_DIVISOR,
194
195	/* Baud Divisor */
196	BSCD_DEFAULT_BAUD_DIV,
197
198	/* Number of transmit parity retries per character in
199	SC_UART_CMD_2 register. Default is 4 and max is 6.
200	7 indicates infinite retries */
201	BSCD_DEFAULT_TX_PARITY_RETRIES,
202
203	/* Number of receive parity retries per character in
204	SC_UART_CMD_2 register. Default is 4 and max is 6.
205	7 indicates infinite retries */
206	BSCD_DEFAULT_RX_PARITY_RETRIES,
207
208	/* work waiting time in SC_TIME_CMD register. Other than EMV
209	standard, only valid if current protocol is T=0. */
210	{BSCD_DEFAULT_WORK_WAITING_TIME, BSCD_TimerUnit_eETU},
211
212	/* block Wait time in SC_TIME_CMD register. Only valid if
213	current protocol is T=1. */
214	{BSCD_DEFAULT_BLOCK_WAITING_TIME, BSCD_TimerUnit_eETU},
215
216	/* Extra Guard Time in SC_TGUARD register. */
217	{BSCD_DEFAULT_EXTRA_GUARD_TIME, BSCD_TimerUnit_eETU},
218
219	/* block Guard time in SC_BGT register.Other than EMV
220	standard, only valid if current protocol is T=1. */
221	{BSCD_DEFAULT_BLOCK_GUARD_TIME, BSCD_TimerUnit_eETU},
222
223	/* character Wait time in SC_PROTO_CMD register. Only valid
224	if current protocol is T=1. */
225	BSCD_DEFAULT_CHARACTER_WAIT_TIME_INTEGER,
226
227	/* EDC encoding. Only valid if current protocol is T=1. */
228	{BSCD_EDCEncode_eLRC, false},
229
230	/* arbitrary Time Out value for any synchronous transaction. */
231	{BSCD_DEFAULT_TIME_OUT, BSCD_TimerUnit_eMilliSec},
232
233	/* Specify if we need auto deactivation sequence */
234	false,
235
236	/* True if we receive 0x60 in T=0, we will ignore it. Otherwise, we treat 0x60 as a valid data byte */
237	false,
238
239	/* Debounce info for IF_CMD_2 */
240	{BSCD_ScPresMode_eMask, true, BSCD_DEFAULT_DB_WIDTH},
241
242	BSCD_ResetCardAction_eReceiveAndDecode, /* Specify if we want the driver to read, decode and program registers */
243
244	{0, BSCD_TimerUnit_eETU} , /* block wait time extension */
245	true /* pres is low */ ,
246	{BSCD_MAX_ATR_START_IN_CLK_CYCLES, BSCD_TimerUnit_eCLK},
247	false , /* connect to TDA8024 */
248	true, /* pin setting */
249	true, /* VCC setting */
250	BSCD_VccLevel_e5V , /* 5 Volts */
251	BSCD_ClockFreq_e27MHZ,
252	BSCD_MAX_RESET_IN_CLK_CYCLES
253	};
254
255
256
257
258	/*******************************************************************************
259	* Public Module Functions
260	*******************************************************************************/
261	BERR_Code BSCD_GetDefaultSettings(
262	BSCD_Settings *outp_sSettings,
263	BCHP_Handle in_chipHandle
264	)
265	{
266	BERR_Code errCode = BERR_SUCCESS;
267
268	BDBG_ENTER(BSCD_GetDefaultSettings);
269	BDBG_ASSERT( in_chipHandle );
270
271	*outp_sSettings = BSCD_defScdSettings;
272
273	BSTD_UNUSED(in_chipHandle);
274
275	BDBG_LEAVE(BSCD_GetDefaultSettings);
276	return( errCode );
277	}
278
279
280	BERR_Code BSCD_Open(
281	BSCD_Handle *outp_handle,
282	BREG_Handle in_regHandle,
283	BCHP_Handle in_chipHandle,
284	BINT_Handle in_interruptHandle,
285	const BSCD_Settings *inp_sSettings
286	)
287	{
288	BERR_Code errCode = BERR_SUCCESS;
289	BSCD_Handle moduleHandle;
290	unsigned int channelNum;
291	uint32_t ulVal = 0;
292
293	BDBG_ENTER(BSCD_Open);
294	BDBG_ASSERT( in_chipHandle );
295	BDBG_ASSERT( in_regHandle );
296	BDBG_ASSERT( in_interruptHandle );
297
298	*outp_handle = NULL;
299
300	/* on many chips, ulVal is actually used, but having an unconditional BSTD_UNUSED makes it easier to maintain this code. */
301	BSTD_UNUSED(ulVal);
302
303	/* Alloc memory from the system heap */
304	if ((moduleHandle =
305	(BSCD_Handle) BKNI_Malloc( sizeof( BSCD_P_Handle)))
306	== NULL) {
307	/* wrap initially detected error code */
308	errCode = BERR_TRACE(BERR_OUT_OF_SYSTEM_MEMORY);
309	goto BSCD_P_DONE_LABEL;
310	}
311
312	BKNI_Memset(moduleHandle, 0, sizeof( BSCD_P_Handle ));
313
314	moduleHandle->ulMagicNumber = BSCD_P_HANDLE_MAGIC_NUMBER;
315	moduleHandle->chipHandle = in_chipHandle;
316	moduleHandle->regHandle = in_regHandle;
317	moduleHandle->interruptHandle = in_interruptHandle;
318
319	if (inp_sSettings == NULL)
320	moduleHandle->currentSettings = BSCD_defScdSettings;
321	else {
322	moduleHandle->currentSettings = *inp_sSettings;
323
324	}
325
326	/* Get the chip information for Bcm7038 */
327	BCHP_GetChipInfo( moduleHandle->chipHandle, &moduleHandle->chipId, &moduleHandle->chipRev );
328	BDBG_MSG(( "chipId=%d, chipRev=%d\n", moduleHandle->chipId, moduleHandle->chipRev ));
329	/*** move clock setting to channel OPen */
330
331	/***************************************************************
332	Warning: Note that we have to modify the board to use GPIO and connect it
333	to pin 3 (3V/5V) of TDA chip and run this function.
334	Make sure to disconnect your QAM or QPSK connection before
335	calling this function or your smartcard will be damaged.
336	***************************************************************/
337	/** move 3v?5V setting to channel Open */
338
339	/*
340	If inp_sSettings->maxChannels == 0, set it to
341	BSCD_MAX_SUPPOTED_CHANNELS
342	*/
343	if (moduleHandle->currentSettings.ucMaxChannels == 0)
344	moduleHandle->currentSettings.ucMaxChannels =
345	BSCD_MAX_SUPPOTED_CHANNELS;
346
347	for( channelNum = 0;
348	channelNum < moduleHandle->currentSettings.ucMaxChannels;
349	channelNum++ )
350	{
351	moduleHandle->channelHandles[channelNum] = NULL;
352	}
353
354	*outp_handle = moduleHandle;
355
356	BKNI_EnterCriticalSection();
357	moduleHandle->bIsOpen = true;
358	BKNI_LeaveCriticalSection();
359
360	BSCD_P_DONE_LABEL:
361
362	BDBG_LEAVE(BSCD_Open);
363	return( errCode );
364
365	}
366
367
368	BERR_Code BSCD_Close(
369	BSCD_Handle inout_handle
370	)
371	{
372	BERR_Code errCode = BERR_SUCCESS;
373	/* 12/02/2006 QX: add this to avoid crash during BKNI_Free */
374	void *pTemp;
375
376
377	BDBG_ENTER(BSCD_Close);
378	BDBG_ASSERT( inout_handle );
379
380	BKNI_EnterCriticalSection();
381	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED, (inout_handle == NULL) );
382	BKNI_LeaveCriticalSection();
383
384	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
385	(inout_handle->ulMagicNumber != BSCD_P_HANDLE_MAGIC_NUMBER ) );
386
387	BKNI_EnterCriticalSection();
388	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
389	(inout_handle->bIsOpen == false) );
390	BKNI_LeaveCriticalSection();
391
392	BSCD_P_DONE_LABEL:
393	BKNI_EnterCriticalSection();
394	inout_handle->bIsOpen = false;
395	BKNI_LeaveCriticalSection();
396
397	/* 12/02/2006 QX: add this to avoid crash during BKNI_Free */
398	BKNI_EnterCriticalSection();
399	pTemp = inout_handle;
400	inout_handle = NULL;
401	BKNI_LeaveCriticalSection();
402
403	BKNI_Free(pTemp);
404
405
406	BDBG_LEAVE(BSCD_Close);
407	return( errCode );
408	}
409
410
411	BERR_Code BSCD_GetTotalChannels(
412	BSCD_Handle in_handle,
413	unsigned char *outp_ucTotalChannels
414	)
415	{
416	BERR_Code errCode = BERR_SUCCESS;
417
418	BDBG_ENTER(BSCD_GetTotalChannels);
419	BDBG_ASSERT( in_handle );
420
421	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
422	(in_handle->ulMagicNumber != BSCD_P_HANDLE_MAGIC_NUMBER ) );
423
424	*outp_ucTotalChannels = in_handle->currentSettings.ucMaxChannels;
425
426	BSCD_P_DONE_LABEL:
427
428	BDBG_LEAVE(BSCD_GetTotalChannels);
429	return( errCode );
430	}
431
432
433	BERR_Code BSCD_GetChannelDefaultSettings(
434	BSCD_Handle in_handle,
435	unsigned int in_channelNo,
436	BSCD_ChannelSettings *outp_sSettings
437	)
438	{
439	BERR_Code errCode = BERR_SUCCESS;
440
441
442	BDBG_ENTER(BSCD_GetChannelDefaultSettings);
443	BDBG_ASSERT( in_handle );
444
445	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
446	(in_handle->ulMagicNumber != BSCD_P_HANDLE_MAGIC_NUMBER ) );
447
448	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BERR_INVALID_PARAMETER,
449	(in_channelNo >= in_handle->currentSettings.ucMaxChannels) );
450
451	*outp_sSettings = BSCD_defScdChannelSettings;
452
453	BSCD_P_DONE_LABEL:
454
455	BDBG_LEAVE(BSCD_GetChannelDefaultSettings);
456	return( errCode );
457	}
458
459
460	BERR_Code BSCD_Channel_Open(
461	BSCD_Handle in_handle,
462	BSCD_ChannelHandle *outp_channelHandle,
463	unsigned int in_channelNo,
464	const BSCD_ChannelSettings *inp_channelDefSettings
465	)
466	{
467	BERR_Code errCode = BERR_SUCCESS;
468	BSCD_ChannelHandle channelHandle = NULL;
469	uint32_t ulVal = 0;
470
471	#if (BCHP_CHIP == 3548) \|\| (BCHP_CHIP==3556)\|\| (BCHP_CHIP==35230)
472	BINT_Id intId = BCHP_INT_ID_CREATE(BCHP_SCIRQ0_SCIRQEN, BCHP_SCIRQ0_SCIRQEN_sca_irqen_SHIFT);
473
474	#else
475	BINT_Id intId = BCHP_INT_ID_sca_irqen;
476	#endif
477	#ifdef BCHP_PWR_RESOURCE_SMARTCARD0
478	BCHP_PWR_ResourceId resourceId = BCHP_PWR_RESOURCE_SMARTCARD0;
479	#ifdef BCHP_PWR_RESOURCE_SMARTCARD1
480	if(in_channelNo == 1) {
481	resourceId = BCHP_PWR_RESOURCE_SMARTCARD1;
482	}
483	#endif
484	#endif
485
486	BDBG_ENTER(BSCD_Channel_Open);
487	BDBG_ASSERT( in_handle );
488	BSTD_UNUSED(ulVal);
489
490	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
491	(in_handle->ulMagicNumber != BSCD_P_HANDLE_MAGIC_NUMBER ) );
492
493	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BERR_INVALID_PARAMETER,
494	(in_channelNo >= in_handle->currentSettings.ucMaxChannels) );
495
496	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
497	(in_handle->bIsOpen == false) );
498
499	/* channel handle must be NULL. */
500	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
501	(in_handle->channelHandles[in_channelNo] != NULL) );
502
503	*outp_channelHandle = NULL;
504
505	/* Alloc memory from the system heap */
506	if ((channelHandle =
507	(BSCD_ChannelHandle) BKNI_Malloc(sizeof(BSCD_P_ChannelHandle)))
508	== NULL) {
509	/* wrap initially detected error code */
510	errCode = BERR_TRACE(BERR_OUT_OF_SYSTEM_MEMORY);
511	goto BSCD_P_DONE_LABEL;
512	}
513
514	BKNI_Memset(channelHandle, 0, sizeof( BSCD_P_ChannelHandle ));
515
516	channelHandle->ulMagicNumber = BSCD_P_CHANNEL_HANDLE_MAGIC_NUMBER;
517	channelHandle->moduleHandle = in_handle;
518
519	channelHandle->ucChannelNumber = in_channelNo;
520
521	#ifdef BCHP_PWR_RESOURCE_SMARTCARD0
522	/* acquire power */
523	BCHP_PWR_AcquireResource(channelHandle->moduleHandle->chipHandle, resourceId);
524	#endif
525
526	#ifdef BSCD_EMV2000_CWT_PLUS_4
527	channelHandle->bIsReceive = false;
528	#endif
529	switch (in_channelNo) {
530	case 0:
531	channelHandle->ulRegStartAddr = BCHP_SCA_SC_UART_CMD_1;
532
533	break;
534	case 1:
535	channelHandle->ulRegStartAddr = BCHP_SCB_SC_UART_CMD_1;
536
537	break;
538	default:
539	channelHandle->ulRegStartAddr = BCHP_SCA_SC_UART_CMD_1;
540	break;
541	}
542	BKNI_EnterCriticalSection();
543	BREG_Write32(
544	channelHandle->moduleHandle->regHandle,
545	(channelHandle->ulRegStartAddr + BSCD_P_INTR_EN_1),
546	0);
547
548	BREG_Write32(
549	channelHandle->moduleHandle->regHandle,
550	(channelHandle->ulRegStartAddr + BSCD_P_INTR_EN_2),
551	0);
552	channelHandle->ulStatus1 = 0x00;
553	channelHandle->ulStatus2 = 0x00;
554	channelHandle->ulIntrStatus1 = 0x00;
555	channelHandle->ulIntrStatus2 = 0x00;
556	BKNI_LeaveCriticalSection();
557
558	/* Enable smartcard interrupt */
559	switch (in_channelNo) {
560	case 0:
561
562	intId = BCHP_INT_ID_sca_irqen;
563	BREG_Write32( in_handle->regHandle, BCHP_SCIRQ0_SCIRQEN,
564	(BCHP_SCIRQ0_SCIRQEN_sca_irqen_MASK \|
565	BREG_Read32(in_handle->regHandle, BCHP_SCIRQ0_SCIRQEN)) );
566	break;
567	case 1:
568	intId = BCHP_INT_ID_scb_irqen;
569	BREG_Write32( in_handle->regHandle, BCHP_SCIRQ0_SCIRQEN,
570	(BCHP_SCIRQ0_SCIRQEN_scb_irqen_MASK \|
571	BREG_Read32(in_handle->regHandle, BCHP_SCIRQ0_SCIRQEN)) );
572	break;
573
574	}
575
576
577	BSCD_P_CHECK_ERR_CODE_FUNC( errCode, BINT_CreateCallback(
578	&(channelHandle->channelIntCallback), in_handle->interruptHandle, intId,
579	BSCD_Channel_P_IntHandler_isr, (void *) channelHandle, 0x00 ) );
580	BSCD_P_CHECK_ERR_CODE_FUNC( errCode, BINT_EnableCallback(channelHandle->channelIntCallback) );
581
582
583	BDBG_MSG(("in_channelNo = %d\n", in_channelNo));
584	BDBG_MSG(("channelHandle->ulRegStartAddr = 0x%x\n", channelHandle->ulRegStartAddr));
585
586	if (inp_channelDefSettings != NULL){
587	BSCD_Channel_P_SetSrcClock(
588	channelHandle,
589	inp_channelDefSettings);
590	BSCD_Channel_SetParameters(
591	channelHandle,
592	inp_channelDefSettings);
593	}
594	else {
595	BSCD_Channel_P_SetSrcClock(
596	channelHandle,
597	&BSCD_defScdChannelSettings);
598	BSCD_Channel_SetParameters(
599	channelHandle,
600	&BSCD_defScdChannelSettings);
601	}
602	/* set pin muxing */
603	if( channelHandle->currentChannelSettings.setPinmux){
604
605	switch (in_channelNo) {
606	case 0:
607
608	/* Pin muxing */
609
610	#if (BCHP_CHIP==7422) \|\| (BCHP_CHIP==7425)
611	ulVal = BREG_Read32 (in_handle->regHandle,
612	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_16);
613	ulVal &= ~(BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_16_gpio_091_MASK \|
614	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_16_gpio_090_MASK\|
615	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_16_gpio_089_MASK);
616	BREG_Write32 (in_handle->regHandle, BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_16,
617	(ulVal \|
618	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_16_gpio_091_SHIFT) \|
619	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_16_gpio_090_SHIFT) \|
620
621	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_16_gpio_089_SHIFT) ));
622
623
624	ulVal = BREG_Read32 (in_handle->regHandle,
625	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17);
626	ulVal &= ~(BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_093_MASK \|
627	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_092_MASK );
628	BREG_Write32 (in_handle->regHandle, BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17,
629	(ulVal \|
630	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_093_SHIFT) \|
631	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_092_SHIFT)));
632	BDBG_MSG(( "7422, need to switch io pin\n" ));
633
634	#elif(BCHP_CHIP==7346)
635	ulVal = BREG_Read32 (in_handle->regHandle,
636	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_8);
637	ulVal &= ~(BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_8_gpio_012_MASK \|
638	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_8_gpio_011_MASK \|
639	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_8_gpio_010_MASK \|
640	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_8_gpio_009_MASK \|
641	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_8_gpio_008_MASK );
642	BREG_Write32 (in_handle->regHandle, BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_8,
643	(ulVal \|
644	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_8_gpio_012_SHIFT) \|
645	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_8_gpio_011_SHIFT) \|
646	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_8_gpio_010_SHIFT) \|
647	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_8_gpio_009_SHIFT) \|
648	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_8_gpio_008_SHIFT ) ));
649	BDBG_MSG(( "7346, need to switch io pin\n" ));
650	#elif(BCHP_CHIP==7231)
651	ulVal = BREG_Read32 (in_handle->regHandle,
652	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_9);
653	ulVal &= ~(BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_9_gpio_81_MASK \|
654	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_9_gpio_80_MASK \|
655	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_9_gpio_79_MASK );
656	BREG_Write32 (in_handle->regHandle, BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_9,
657	(ulVal \|
658	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_9_gpio_81_SHIFT) \|
659	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_9_gpio_80_SHIFT) \|
660	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_9_gpio_79_SHIFT) ));
661	ulVal = BREG_Read32 (in_handle->regHandle,
662	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10);
663	ulVal &= ~(BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10_gpio_83_MASK \|
664	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10_gpio_82_MASK );
665	BREG_Write32 (in_handle->regHandle, BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10,
666	(ulVal \|
667	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10_gpio_83_SHIFT) \|
668	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10_gpio_82_SHIFT) ));
669	BDBG_MSG(( "7231, need to switch io pin\n" ));
670	#elif(BCHP_CHIP==7358)\|\|(BCHP_CHIP==7552)
671	ulVal = BREG_Read32 (in_handle->regHandle,
672	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10);
673	ulVal &= ~(BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10_gpio_83_MASK \|
674	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10_gpio_82_MASK \|
675	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10_gpio_81_MASK \|
676	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10_gpio_80_MASK \|
677	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10_gpio_79_MASK );
678	BREG_Write32 (in_handle->regHandle, BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10,
679	(ulVal \|
680	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10_gpio_83_SHIFT) \|
681	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10_gpio_82_SHIFT) \|
682	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10_gpio_81_SHIFT) \|
683	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10_gpio_80_SHIFT) \|
684	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10_gpio_79_SHIFT ) ));
685	BDBG_MSG(( "7358, need to switch io pin\n" ));
686	#elif(BCHP_CHIP==7344)
687	ulVal = BREG_Read32 (in_handle->regHandle,
688	BCHP_AON_PIN_CTRL_PIN_MUX_CTRL_0);
689	ulVal &= ~(BCHP_AON_PIN_CTRL_PIN_MUX_CTRL_0_aon_gpio_02_MASK \|
690	BCHP_AON_PIN_CTRL_PIN_MUX_CTRL_0_aon_gpio_01_MASK \|
691	BCHP_AON_PIN_CTRL_PIN_MUX_CTRL_0_aon_gpio_00_MASK );
692	BREG_Write32 (in_handle->regHandle, BCHP_AON_PIN_CTRL_PIN_MUX_CTRL_0,
693	(ulVal \|
694	(0x00000004 << BCHP_AON_PIN_CTRL_PIN_MUX_CTRL_0_aon_gpio_02_SHIFT) \|
695	(0x00000004 << BCHP_AON_PIN_CTRL_PIN_MUX_CTRL_0_aon_gpio_01_SHIFT) \|
696	(0x00000004 << BCHP_AON_PIN_CTRL_PIN_MUX_CTRL_0_aon_gpio_00_SHIFT) ));
697	ulVal = BREG_Read32 (in_handle->regHandle,
698	BCHP_AON_PIN_CTRL_PIN_MUX_CTRL_1);
699	ulVal &= ~(BCHP_AON_PIN_CTRL_PIN_MUX_CTRL_1_aon_gpio_05_MASK \|
700	BCHP_AON_PIN_CTRL_PIN_MUX_CTRL_1_aon_gpio_04_MASK );
701	BREG_Write32 (in_handle->regHandle, BCHP_AON_PIN_CTRL_PIN_MUX_CTRL_1,
702	(ulVal \|
703	(0x00000004 << BCHP_AON_PIN_CTRL_PIN_MUX_CTRL_1_aon_gpio_05_SHIFT) \|
704	(0x00000004 << BCHP_AON_PIN_CTRL_PIN_MUX_CTRL_1_aon_gpio_04_SHIFT) ));
705	BDBG_MSG(( "7344, need to switch io pin\n" ));
706	#elif(BCHP_CHIP==7435)
707	ulVal = BREG_Read32 (in_handle->regHandle,
708	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_16);
709	ulVal &= ~(BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_16_gpio_091_MASK \|
710	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_16_gpio_090_MASK \|
711	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_16_gpio_089_MASK );
712	BREG_Write32 (in_handle->regHandle, BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_16,
713	(ulVal \|
714	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_16_gpio_091_SHIFT) \|
715	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_16_gpio_090_SHIFT) \|
716	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_16_gpio_089_SHIFT) ));
717	ulVal = BREG_Read32 (in_handle->regHandle,
718	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17);
719	ulVal &= ~(BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_092_MASK \|
720	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_093_MASK );
721	BREG_Write32 (in_handle->regHandle, BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17,
722	(ulVal \|
723	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_092_SHIFT) \|
724	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_093_SHIFT) ));
725	BDBG_MSG(( "7435, need to switch io pin\n" ));
726
727	#endif
728	break;
729	case 1:
730	intId = BCHP_INT_ID_scb_irqen;
731	BREG_Write32( in_handle->regHandle, BCHP_SCIRQ0_SCIRQEN,
732	(BCHP_SCIRQ0_SCIRQEN_scb_irqen_MASK \|
733	BREG_Read32(in_handle->regHandle, BCHP_SCIRQ0_SCIRQEN)) );
734
735	/* Pin muxing */
736	#if (BCHP_CHIP==7422) \|\| (BCHP_CHIP==7425)
737	ulVal = BREG_Read32 (in_handle->regHandle,
738	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17);
739	ulVal &= ~(BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_098_MASK \|
740	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_097_MASK \|
741	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_096_MASK \|
742	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_095_MASK \|
743	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_094_MASK );
744	BREG_Write32 (in_handle->regHandle, BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17,
745	(ulVal \|
746	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_098_SHIFT) \|
747	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_097_SHIFT) \|
748	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_096_SHIFT) \|
749	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_095_SHIFT) \|
750	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_094_SHIFT ) ));
751	BDBG_MSG(( "7422, need to switch io pin\n" ));
752	#elif (BCHP_CHIP==7346)
753	ulVal = BREG_Read32 (in_handle->regHandle,
754	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10);
755	ulVal &= ~(BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10_gpio_028_MASK \|
756	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10_gpio_027_MASK \|
757	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10_gpio_026_MASK \|
758	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10_gpio_025_MASK );
759	BREG_Write32 (in_handle->regHandle, BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10,
760	(ulVal \|
761	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10_gpio_028_SHIFT) \|
762	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10_gpio_027_SHIFT) \|
763	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10_gpio_026_SHIFT) \|
764	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10_gpio_025_SHIFT ) ));
765	ulVal = BREG_Read32 (in_handle->regHandle,
766	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_11);
767	ulVal &= ~(BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_11_gpio_029_MASK);
768	BREG_Write32 (in_handle->regHandle, BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_11,
769	(ulVal \|
770	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_11_gpio_029_SHIFT) ));
771	BDBG_MSG(( "7346, need to switch io pin\n" ));
772
773	#elif(BCHP_CHIP==7231)
774	ulVal = BREG_Read32 (in_handle->regHandle,
775	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_4);
776	ulVal &= ~(BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_4_gpio_37_MASK \|
777	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_4_gpio_36_MASK \|
778	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_4_gpio_35_MASK \|
779	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_4_gpio_34_MASK );
780	BREG_Write32 (in_handle->regHandle, BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_4,
781	(ulVal \|
782	(0x00000002 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_4_gpio_37_SHIFT) \|
783	(0x00000002 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_4_gpio_36_SHIFT) \|
784	(0x00000002 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_4_gpio_35_SHIFT) \|
785	(0x00000002 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_4_gpio_34_SHIFT) ));
786	ulVal = BREG_Read32 (in_handle->regHandle,
787	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_3);
788	ulVal &= ~(BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_3_gpio_33_MASK );
789	BREG_Write32 (in_handle->regHandle, BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_3,
790	(ulVal \|
791	(0x00000002 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_3_gpio_33_SHIFT) ));
792	BDBG_MSG(( "7231, need to switch io pin\n" ));
793	#elif(BCHP_CHIP==7358)\|\|(BCHP_CHIP==7552)
794	ulVal = BREG_Read32 (in_handle->regHandle,
795	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_4);
796	ulVal &= ~(BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_4_gpio_36_MASK \|
797	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_4_gpio_35_MASK \|
798	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_4_gpio_34_MASK \|
799	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_4_gpio_33_MASK );
800	BREG_Write32 (in_handle->regHandle, BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_4,
801	(ulVal \|
802	(0x00000002 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_4_gpio_33_SHIFT) \|
803	(0x00000002 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_4_gpio_36_SHIFT) \|
804	(0x00000002 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_4_gpio_35_SHIFT) \|
805	(0x00000002 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_4_gpio_34_SHIFT) ));
806	ulVal = BREG_Read32 (in_handle->regHandle,
807	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_5);
808	ulVal &= ~(BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_5_gpio_37_MASK );
809	BREG_Write32 (in_handle->regHandle, BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_5,
810	(ulVal \|
811	(0x00000002 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_5_gpio_37_SHIFT) ));
812	BDBG_MSG(( "7358, need to switch io pin\n" ));
813	#elif(BCHP_CHIP==7344)
814	ulVal = BREG_Read32 (in_handle->regHandle,
815	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_12);
816	ulVal &= ~(BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_12_gpio_56_MASK \|
817	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_12_gpio_55_MASK \|
818	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_12_gpio_54_MASK \|
819	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_12_gpio_53_MASK \|
820	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_12_gpio_52_MASK );
821	BREG_Write32 (in_handle->regHandle, BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_12,
822	(ulVal \|
823	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_12_gpio_56_SHIFT) \|
824	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_12_gpio_55_SHIFT) \|
825	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_12_gpio_54_SHIFT) \|
826	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_12_gpio_53_SHIFT) \|
827	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_12_gpio_52_SHIFT ) ));
828	BDBG_MSG(( "7344, need to switch io pin\n" ));
829	#elif(BCHP_CHIP==7435)
830	ulVal = BREG_Read32 (in_handle->regHandle,
831	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17);
832	ulVal &= ~(BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_094_MASK \|
833	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_095_MASK \|
834	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_096_MASK \|
835	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_097_MASK \|
836	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_098_MASK );
837	BREG_Write32 (in_handle->regHandle, BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17,
838	(ulVal \|
839	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_094_SHIFT) \|
840	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_095_SHIFT) \|
841	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_096_SHIFT) \|
842	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_097_SHIFT) \|
843	(0x00000001 << BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_17_gpio_098_SHIFT ) ));
844	BDBG_MSG(( "7358, need to switch io pin\n" ));
845
846	#endif
847
848	break;
849
850
851	default:
852	errCode = BERR_INVALID_PARAMETER;
853	goto BSCD_P_DONE_LABEL;
854	}
855	}
856
857
858
859	BSCD_P_CHECK_ERR_CODE_FUNC(errCode,
860	BKNI_CreateEvent( &(channelHandle->channelWaitEvent.cardWait)));
861	BSCD_P_CHECK_ERR_CODE_FUNC(errCode,
862	BKNI_CreateEvent( &(channelHandle->channelWaitEvent.tdoneWait)));
863	BSCD_P_CHECK_ERR_CODE_FUNC(errCode,
864	BKNI_CreateEvent( &(channelHandle->channelWaitEvent.rcvWait)));
865	BSCD_P_CHECK_ERR_CODE_FUNC(errCode,
866	BKNI_CreateEvent( &(channelHandle->channelWaitEvent.atrStart)));
867	BSCD_P_CHECK_ERR_CODE_FUNC(errCode,
868	BKNI_CreateEvent( &(channelHandle->channelWaitEvent.timerWait)));
869
870	#ifdef BSCD_EMV2000_CWT_PLUS_4_EVENT_INTR
871	BSCD_P_CHECK_ERR_CODE_FUNC(errCode,
872	BKNI_CreateEvent( &(channelHandle->channelWaitEvent.event1Wait)));
873	#endif
874
875	BSCD_P_CHECK_ERR_CODE_FUNC(errCode,
876	BKNI_CreateEvent( &(channelHandle->channelWaitEvent.event2Wait)));
877
878	BKNI_EnterCriticalSection();
879	BSCD_Channel_P_EnableInterrupts_isr(channelHandle); /* Todo: Only enable intr for ATR */
880	BKNI_LeaveCriticalSection();
881
882	/Set VCC level to inp_channelDefSettings->vcc/
883	if( channelHandle->currentChannelSettings.setVcc){
884	BSCD_Channel_SetVccLevel( channelHandle,channelHandle->currentChannelSettings.vcc);
885	}
886
887	in_handle->channelHandles[in_channelNo] = channelHandle;
888
889	*outp_channelHandle = channelHandle;
890	BKNI_EnterCriticalSection();
891	channelHandle->bIsOpen = true;
892	BKNI_LeaveCriticalSection();
893
894
895	ulVal = BREG_Read32(
896
897	in_handle->regHandle,
898	(channelHandle->ulRegStartAddr + BSCD_P_STATUS_1));
899
900	if(ulVal&BCHP_SCA_SC_STATUS_1_card_pres_MASK)
901	channelHandle->channelStatus.bCardPresent = true;
902	BSCD_P_DONE_LABEL:
903	if( errCode != BERR_SUCCESS )
904	{
905	if( channelHandle != NULL )
906	{
907	if (channelHandle->channelWaitEvent.cardWait != NULL)
908	BKNI_DestroyEvent( channelHandle->channelWaitEvent.cardWait );
909	if (channelHandle->channelWaitEvent.tdoneWait != NULL)
910	BKNI_DestroyEvent( channelHandle->channelWaitEvent.tdoneWait );
911	if (channelHandle->channelWaitEvent.rcvWait != NULL)
912	BKNI_DestroyEvent( channelHandle->channelWaitEvent.rcvWait );
913	if (channelHandle->channelWaitEvent.atrStart != NULL)
914	BKNI_DestroyEvent( channelHandle->channelWaitEvent.atrStart );
915	if (channelHandle->channelWaitEvent.timerWait != NULL)
916	BKNI_DestroyEvent( channelHandle->channelWaitEvent.timerWait );
917	#ifdef BSCD_EMV2000_CWT_PLUS_4_EVENT_INTR
918	if (channelHandle->channelWaitEvent.atrStart != NULL)
919	BKNI_DestroyEvent( channelHandle->channelWaitEvent.event1Wait );
920	#endif
921	if (channelHandle->channelWaitEvent.timerWait != NULL)
922	BKNI_DestroyEvent( channelHandle->channelWaitEvent.event2Wait );
923
924	#ifdef BCHP_PWR_RESOURCE_SMARTCARD0
925	/* a failed open releases power */
926	BCHP_PWR_ReleaseResource(channelHandle->moduleHandle->chipHandle, resourceId);
927	#endif
928
929	BKNI_Free( channelHandle );
930
931	}
932	}
933
934	BDBG_LEAVE(BSCD_Channel_Open);
935	return( errCode );
936	}
937
938	BERR_Code BSCD_Channel_Close(
939	BSCD_ChannelHandle inout_channelHandle
940	)
941	{
942	BERR_Code errCode = BERR_SUCCESS;
943	BSCD_Handle moduleHandle;
944	uint32_t ulValue = 0;
945	/* 12/02/2006 QX: add this to avoid crash during BKNI_Free */
946	void *pTemp;
947	#ifdef BCHP_PWR_RESOURCE_SMARTCARD0
948	BCHP_PWR_ResourceId resourceId = BCHP_PWR_RESOURCE_SMARTCARD0;
949	#ifdef BCHP_PWR_RESOURCE_SMARTCARD1
950	if(inout_channelHandle->ucChannelNumber == 1) {
951	resourceId = BCHP_PWR_RESOURCE_SMARTCARD1;
952	}
953	#endif
954	#endif
955
956	BDBG_ENTER(BSCD_Channel_Close);
957	BDBG_ASSERT( inout_channelHandle );
958
959	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
960	(inout_channelHandle->ulMagicNumber != BSCD_P_CHANNEL_HANDLE_MAGIC_NUMBER ) );
961
962	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
963	(inout_channelHandle->bIsOpen == false) );
964
965
966	BSCD_P_DONE_LABEL:
967
968	inout_channelHandle->bIsOpen = false;
969
970	ulValue = BREG_Read32(inout_channelHandle->moduleHandle->regHandle, BCHP_SCIRQ0_SCIRQEN);
971	/* Disable smartcard interrupt */
972	switch (inout_channelHandle->ucChannelNumber) {
973	case 0:
974	ulValue &= ~BCHP_SCIRQ0_SCIRQEN_sca_irqen_MASK;
975	break;
976
977	case 1:
978	ulValue &= ~BCHP_SCIRQ0_SCIRQEN_scb_irqen_MASK;
979	break;
980
981
982	default:
983	errCode = BERR_INVALID_PARAMETER;
984	break;
985	}
986
987
988	BREG_Write32(inout_channelHandle->moduleHandle->regHandle, BCHP_SCIRQ0_SCIRQEN,
989	ulValue);
990	BSCD_P_CHECK_ERR_CODE_FUNC( errCode, BINT_DisableCallback( inout_channelHandle->channelIntCallback));
991	BSCD_P_CHECK_ERR_CODE_FUNC( errCode, BINT_DestroyCallback( inout_channelHandle->channelIntCallback ) );
992
993	BKNI_DestroyEvent( inout_channelHandle->channelWaitEvent.cardWait );
994	BKNI_DestroyEvent( inout_channelHandle->channelWaitEvent.tdoneWait );
995	BKNI_DestroyEvent( inout_channelHandle->channelWaitEvent.rcvWait );
996	BKNI_DestroyEvent( inout_channelHandle->channelWaitEvent.atrStart );
997	BKNI_DestroyEvent( inout_channelHandle->channelWaitEvent.timerWait );
998	#ifdef BSCD_EMV2000_CWT_PLUS_4_EVENT_INTR
999	BKNI_DestroyEvent( inout_channelHandle->channelWaitEvent.event1Wait );
1000	#endif
1001	BKNI_DestroyEvent( inout_channelHandle->channelWaitEvent.event2Wait );
1002
1003	BSCD_Channel_Deactivate(inout_channelHandle);
1004
1005	moduleHandle = inout_channelHandle->moduleHandle;
1006	moduleHandle->channelHandles[inout_channelHandle->ucChannelNumber] = NULL;
1007
1008	#ifdef BCHP_PWR_RESOURCE_SMARTCARD0
1009	/* release power */
1010	BCHP_PWR_ReleaseResource(inout_channelHandle->moduleHandle->chipHandle, resourceId);
1011	#endif
1012
1013	/* 12/02/2006 QX: add this to avoid crash during BKNI_Free */
1014	BKNI_EnterCriticalSection();
1015	pTemp = inout_channelHandle;
1016	inout_channelHandle = NULL;
1017	BKNI_LeaveCriticalSection();
1018	BKNI_Free(pTemp);
1019
1020	BDBG_LEAVE(BSCD_Channel_Close);
1021	return( errCode );
1022	}
1023
1024	BERR_Code BSCD_Channel_GetDevice(
1025	BSCD_ChannelHandle in_channelHandle,
1026	BSCD_Handle *outp_handle
1027	)
1028	{
1029	BERR_Code errCode = BERR_SUCCESS;
1030
1031	BDBG_ENTER(BSCD_Channel_GetDevice);
1032	BDBG_ASSERT( in_channelHandle );
1033
1034	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
1035	(in_channelHandle->moduleHandle->bIsOpen == false) );
1036
1037	*outp_handle = NULL;
1038
1039	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
1040	(in_channelHandle->ulMagicNumber != BSCD_P_CHANNEL_HANDLE_MAGIC_NUMBER ) );
1041
1042	*outp_handle = in_channelHandle->moduleHandle;
1043
1044	BSCD_P_DONE_LABEL:
1045	BDBG_LEAVE(BSCD_Channel_GetDevice);
1046	return( errCode );
1047	}
1048
1049
1050	BERR_Code BSCD_GetChannel(
1051	BSCD_Handle in_handle,
1052	unsigned int in_channelNo,
1053	BSCD_ChannelHandle *outp_channelHandle
1054	)
1055	{
1056	BERR_Code errCode = BERR_SUCCESS;
1057	BSCD_ChannelHandle channelHandle = NULL;
1058
1059	BDBG_ENTER(BSCD_GetChannel);
1060	BDBG_ASSERT( in_handle );
1061
1062	*outp_channelHandle = NULL;
1063	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
1064	(in_handle->ulMagicNumber != BSCD_P_HANDLE_MAGIC_NUMBER ) );
1065
1066	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BERR_INVALID_PARAMETER,
1067	(in_channelNo >= in_handle->currentSettings.ucMaxChannels) );
1068
1069	channelHandle = in_handle->channelHandles[in_channelNo];
1070
1071	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
1072	(channelHandle == NULL ) );
1073
1074	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
1075	(channelHandle->ulMagicNumber != BSCD_P_CHANNEL_HANDLE_MAGIC_NUMBER ) );
1076
1077
1078	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
1079	(channelHandle->bIsOpen == false) );
1080
1081	*outp_channelHandle = channelHandle;
1082
1083	BSCD_P_DONE_LABEL:
1084
1085	BDBG_LEAVE(BSCD_GetChannel);
1086	return( errCode );
1087	}
1088
1089
1090	BERR_Code BSCD_Channel_DetectCard(
1091	BSCD_ChannelHandle in_channelHandle,
1092	BSCD_CardPresent in_eCardPresent
1093	)
1094	{
1095	BERR_Code errCode = BERR_SUCCESS;
1096
1097	BDBG_ENTER(BSCD_Channel_DetectCard);
1098	BDBG_ASSERT( in_channelHandle );
1099
1100	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
1101	(in_channelHandle->ulMagicNumber != BSCD_P_CHANNEL_HANDLE_MAGIC_NUMBER ) );
1102
1103	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
1104	(in_channelHandle->bIsOpen == false) );
1105
1106	switch (in_eCardPresent) {
1107	case BSCD_CardPresent_eInserted:
1108	{
1109	BKNI_EnterCriticalSection();
1110
1111	if ( in_channelHandle->ulStatus1 & BCHP_SCA_SC_STATUS_1_card_pres_MASK) {
1112	in_channelHandle->channelStatus.bCardPresent = true;
1113	BKNI_LeaveCriticalSection();
1114	goto BSCD_P_DONE_LABEL;
1115	}
1116	else {
1117	BDBG_MSG(("SmartCard Not Present"));
1118	BDBG_MSG(("Please insert the SmartCard"));
1119	}
1120	BKNI_LeaveCriticalSection();
1121
1122
1123	BSCD_P_CHECK_ERR_CODE_FUNC(errCode,
1124	BSCD_Channel_P_WaitForCardInsertion(in_channelHandle));
1125	}
1126	break;
1127
1128	case BSCD_CardPresent_eRemoved:
1129	{
1130	BKNI_EnterCriticalSection();
1131
1132	if ( !(in_channelHandle->ulStatus1 & BCHP_SCA_SC_STATUS_1_card_pres_MASK)) {
1133	in_channelHandle->channelStatus.bCardPresent = false;
1134	BKNI_LeaveCriticalSection();
1135	goto BSCD_P_DONE_LABEL;
1136	}
1137	else {
1138	BDBG_MSG(("SmartCard Present"));
1139	BDBG_MSG(("Please remove the SmartCard"));
1140	}
1141	BKNI_LeaveCriticalSection();
1142
1143	BSCD_P_CHECK_ERR_CODE_FUNC(errCode,
1144	BSCD_Channel_P_WaitForCardRemove(in_channelHandle));
1145	}
1146	break;
1147	}
1148
1149	BSCD_P_DONE_LABEL:
1150
1151	BDBG_LEAVE(BSCD_Channel_DetectCard);
1152	return( errCode );
1153
1154	}
1155
1156
1157
1158	BERR_Code BSCD_Channel_SetParameters(
1159	BSCD_ChannelHandle in_channelHandle,
1160	const BSCD_ChannelSettings *inp_sSettings
1161	)
1162	{
1163	BERR_Code errCode = BERR_SUCCESS;
1164	uint32_t ulValue = 0;
1165
1166	BDBG_ENTER(BSCD_Channel_SetParameters);
1167	BDBG_ASSERT( in_channelHandle );
1168
1169	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
1170	(in_channelHandle->ulMagicNumber != BSCD_P_CHANNEL_HANDLE_MAGIC_NUMBER ) );
1171
1172
1173	in_channelHandle->currentChannelSettings.bIsPresHigh = inp_sSettings->bIsPresHigh;
1174	in_channelHandle->currentChannelSettings.setPinmux = inp_sSettings->setPinmux;
1175	in_channelHandle->currentChannelSettings.setVcc = inp_sSettings->setVcc;
1176	in_channelHandle->currentChannelSettings.vcc = inp_sSettings->vcc;
1177	in_channelHandle->currentChannelSettings.srcClkFreqInHz = inp_sSettings->srcClkFreqInHz;
1178	in_channelHandle->currentChannelSettings.eResetCycles =inp_sSettings->eResetCycles;
1179	if(inp_sSettings->srcClkFreqInHz !=in_channelHandle->moduleHandle->currentSettings.moduleClkFreq.ulClkFreq){
1180	BDBG_MSG(("changing the clock frequency...\n"));
1181
1182	in_channelHandle->moduleHandle->currentSettings.moduleClkFreq.ulClkFreq = inp_sSettings->srcClkFreqInHz;
1183	switch(inp_sSettings->srcClkFreqInHz){
1184	case 27000000:
1185	in_channelHandle->currentChannelSettings.eSrcClkFreq = BSCD_ClockFreq_e27MHZ;
1186	break;
1187	case 36864000:
1188	in_channelHandle->currentChannelSettings.eSrcClkFreq = BSCD_ClockFreq_e36P864MHZ;
1189	break;
1190	case 36000000:
1191	in_channelHandle->currentChannelSettings.eSrcClkFreq = BSCD_ClockFreq_e36MHZ;
1192	break;
1193	case 24000000:
1194	in_channelHandle->currentChannelSettings.eSrcClkFreq = BSCD_ClockFreq_e24MHZ;
1195	break;
1196	default:
1197	BDBG_ERR(("Unknown SC clock freq %d!\n",inp_sSettings->srcClkFreqInHz ));
1198	break;
1199
1200	}
1201	BSCD_P_CHECK_ERR_CODE_FUNC(errCode, BSCD_Channel_P_SetSrcClock(
1202	in_channelHandle, inp_sSettings));
1203
1204
1205	}
1206
1207
1208	BDBG_MSG(("bIsPresHigh = %d", in_channelHandle->currentChannelSettings.bIsPresHigh));
1209
1210	if(in_channelHandle->currentChannelSettings.bIsPresHigh)
1211	{
1212	ulValue = BCHP_SCA_SC_IF_CMD_1_pres_pol_MASK \| BREG_Read32(
1213	in_channelHandle->moduleHandle->regHandle,
1214	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1)) ;
1215	BREG_Write32(
1216	in_channelHandle->moduleHandle->regHandle,
1217	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1),
1218	ulValue);
1219	}
1220
1221
1222	/* Smart Card Standard */
1223	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
1224	((inp_sSettings->scStandard <= BSCD_Standard_eUnknown) \|\| (inp_sSettings->scStandard > BSCD_Standard_eNDS_NO_FLOWCRTL)) );
1225	in_channelHandle->currentChannelSettings.scStandard = inp_sSettings->scStandard;
1226	BDBG_MSG(("scStandard = %d", in_channelHandle->currentChannelSettings.scStandard));
1227
1228	BSCD_P_CHECK_ERR_CODE_FUNC(errCode, BSCD_Channel_P_SetStandard(
1229	in_channelHandle, inp_sSettings));
1230
1231	BSCD_P_CHECK_ERR_CODE_FUNC(errCode, BSCD_Channel_P_SetFreq(
1232	in_channelHandle, inp_sSettings));
1233
1234	/* Set maximum IFSD */
1235	in_channelHandle->currentChannelSettings.unMaxIFSD = BSCD_MAX_TX_SIZE ;
1236	BDBG_MSG(("unMaxIFSD = %d", in_channelHandle->currentChannelSettings.unMaxIFSD));
1237
1238	/* Set current IFSD */
1239	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
1240	(inp_sSettings->unCurrentIFSD > BSCD_MAX_TX_SIZE));
1241	if (inp_sSettings->unMaxIFSD == 0) {
1242	in_channelHandle->currentChannelSettings.unCurrentIFSD = BSCD_MAX_TX_SIZE ;
1243	}
1244	else {
1245	in_channelHandle->currentChannelSettings.unCurrentIFSD = inp_sSettings->unCurrentIFSD ;
1246	}
1247	BDBG_MSG(("unCurrentIFSD = %d", in_channelHandle->currentChannelSettings.unCurrentIFSD));
1248
1249	BSCD_P_CHECK_ERR_CODE_FUNC(errCode, BSCD_Channel_P_SetEdcParity(
1250	in_channelHandle, inp_sSettings));
1251
1252	BSCD_P_CHECK_ERR_CODE_FUNC(errCode, BSCD_Channel_P_SetWaitTime(
1253	in_channelHandle, inp_sSettings));
1254
1255	BSCD_P_CHECK_ERR_CODE_FUNC(errCode, BSCD_Channel_P_SetGuardTime(
1256	in_channelHandle, inp_sSettings));
1257
1258	/* Set transaction time out */
1259	BSCD_P_CHECK_ERR_CODE_FUNC(errCode, BSCD_Channel_P_SetTransactionTimeout(
1260	in_channelHandle, inp_sSettings));
1261
1262	/* auto deactivation sequence */
1263	in_channelHandle->currentChannelSettings.bAutoDeactiveReq = inp_sSettings->bAutoDeactiveReq;
1264	BDBG_MSG(("bAutoDeactiveReq = %d", in_channelHandle->currentChannelSettings.bAutoDeactiveReq));
1265
1266	/* nullFilter */
1267	in_channelHandle->currentChannelSettings.bNullFilter = inp_sSettings->bNullFilter;
1268	BDBG_MSG(("bNullFilter = %d", in_channelHandle->currentChannelSettings.bNullFilter));
1269
1270	/* connectDirectly */
1271	in_channelHandle->currentChannelSettings.bConnectDirectly = inp_sSettings->bConnectDirectly;
1272	BDBG_MSG(("bConnectDirectly = %d", in_channelHandle->currentChannelSettings.bConnectDirectly));
1273
1274
1275	/* debounce info */
1276	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
1277	(inp_sSettings->scPresDbInfo.ucDbWidth > BSCD_MAX_DB_WIDTH ));
1278	in_channelHandle->currentChannelSettings.scPresDbInfo = inp_sSettings->scPresDbInfo;
1279	BDBG_MSG(("scPresDbInfo.bIsEnabled = %d", in_channelHandle->currentChannelSettings.scPresDbInfo.bIsEnabled));
1280	BDBG_MSG(("scPresDbInfo.ucDbWidth = %d", in_channelHandle->currentChannelSettings.scPresDbInfo.ucDbWidth));
1281	BDBG_MSG(("scPresDbInfo.scPresMode = %d", in_channelHandle->currentChannelSettings.scPresDbInfo.scPresMode));
1282
1283	/* Specify if we want the driver to read, decode and program registers */
1284	in_channelHandle->currentChannelSettings.resetCardAction = inp_sSettings->resetCardAction;
1285	BDBG_MSG(("resetCardAction = %d", in_channelHandle->currentChannelSettings.resetCardAction));
1286
1287
1288	in_channelHandle->currentChannelSettings.ATRRecvTimeInteger = inp_sSettings->ATRRecvTimeInteger;
1289
1290	/* Update the BSCD_P_PRESCALE */
1291	ulValue = BREG_Read32(
1292	in_channelHandle->moduleHandle->regHandle,
1293	(in_channelHandle->ulRegStartAddr + BSCD_P_PRESCALE));
1294	BDBG_MSG(("orig BSCD_P_PRESCALE = 0x%x\n", ulValue));
1295
1296
1297
1298	BREG_Write32(
1299	in_channelHandle->moduleHandle->regHandle,
1300	(in_channelHandle->ulRegStartAddr + BSCD_P_PRESCALE),
1301	in_channelHandle->currentChannelSettings.unPrescale);
1302	BDBG_MSG(("New BSCD_P_PRESCALE = 0x%x\n", in_channelHandle->currentChannelSettings.unPrescale));
1303
1304	#if 1
1305	/* Don't enable clock here since auto_clk need to be set first in ResetIFD before
1306	clock enabling for auto_deactivation */
1307	ulValue = BREG_Read32(
1308	in_channelHandle->moduleHandle->regHandle,
1309	(in_channelHandle->ulRegStartAddr + BSCD_P_CLK_CMD));
1310	BDBG_MSG(("orig ucClkCmd = 0x%x\n", ulValue));
1311
1312	/* If enabled before, change the the value. Otherwise leave it intact. */
1313	ulValue = ulValue & BCHP_SCA_SC_CLK_CMD_clk_en_MASK;
1314	if (ulValue == BCHP_SCA_SC_CLK_CMD_clk_en_MASK) {
1315
1316	ulValue = ulValue \| (BSCD_P_MapScClkDivToMaskValue(in_channelHandle->currentChannelSettings.ucScClkDiv)) \|
1317	((in_channelHandle->currentChannelSettings.ucEtuClkDiv - 1) << 1) \|
1318	((in_channelHandle->currentChannelSettings.ucBaudDiv == 31) ? 0 : 1);
1319
1320	BREG_Write32(
1321	in_channelHandle->moduleHandle->regHandle,
1322	(in_channelHandle->ulRegStartAddr + BSCD_P_CLK_CMD),
1323	ulValue);
1324	if(in_channelHandle->currentChannelSettings.ucBaudDiv == 25){
1325	ulValue = BREG_Read32(
1326	in_channelHandle->moduleHandle->regHandle,
1327	(in_channelHandle->ulRegStartAddr + BSCD_P_FLOW_CMD));
1328	ulValue = 0x80 \|ulValue;
1329	BREG_Write32(
1330	in_channelHandle->moduleHandle->regHandle,
1331	(in_channelHandle->ulRegStartAddr + BSCD_P_FLOW_CMD),
1332	ulValue);
1333	}
1334	BDBG_MSG(("New SC_CLK_CMD = 0x%x\n", ulValue));
1335	}
1336	#endif
1337
1338	BDBG_MSG(("address = 0x%x\n", in_channelHandle->ulRegStartAddr));
1339	BDBG_MSG(("BSCD_P_UART_CMD_2 address = 0x%x\n", (in_channelHandle->ulRegStartAddr + BSCD_P_UART_CMD_2)));
1340	/* Update the BSCD_P_UART_CMD_2 */
1341	ulValue = BREG_Read32(
1342	in_channelHandle->moduleHandle->regHandle,
1343	(in_channelHandle->ulRegStartAddr + BSCD_P_UART_CMD_2));
1344	BDBG_MSG(("orig BSCD_P_UART_CMD_2 = 0x%x\n", ulValue));
1345
1346	ulValue &= (BCHP_SCA_SC_UART_CMD_2_convention_MASK);
1347
1348	if (inp_sSettings->eProtocolType == BSCD_AsyncProtocolType_e0 ) {
1349
1350	ulValue \|= (in_channelHandle->currentChannelSettings.ucRxRetries << BCHP_SCA_SC_UART_CMD_2_rpar_retry_SHIFT) \|
1351	(in_channelHandle->currentChannelSettings.ucTxRetries);
1352	}
1353	else if ( (inp_sSettings->eProtocolType == BSCD_AsyncProtocolType_e1 ) \|\|
1354	(inp_sSettings->eProtocolType == BSCD_AsyncProtocolType_e14_IRDETO ) ) {
1355	/* No OP */ ;
1356	}
1357	BREG_Write32(
1358	in_channelHandle->moduleHandle->regHandle,
1359	(in_channelHandle->ulRegStartAddr + BSCD_P_UART_CMD_2),
1360	ulValue);
1361
1362	BDBG_MSG(("BSCD_P_UART_CMD_2 = 0x%x\n", ulValue));
1363
1364	/* Update the BSCD_P_PROTO_CMD */
1365	ulValue = BREG_Read32(
1366	in_channelHandle->moduleHandle->regHandle,
1367	(in_channelHandle->ulRegStartAddr + BSCD_P_PROTO_CMD));
1368	if ((inp_sSettings->eProtocolType == BSCD_AsyncProtocolType_e1 ) &&
1369	(in_channelHandle->currentChannelSettings.edcSetting.bIsEnabled)) {
1370	ulValue = BCHP_SCA_SC_PROTO_CMD_edc_en_MASK;
1371
1372	if (in_channelHandle->currentChannelSettings.edcSetting.edcEncode == BSCD_EDCEncode_eLRC ) {
1373	ulValue &= ~BCHP_SCA_SC_PROTO_CMD_crc_lrc_MASK;
1374	}
1375	else if (in_channelHandle->currentChannelSettings.edcSetting.edcEncode == BSCD_EDCEncode_eCRC) {
1376	ulValue \|= BCHP_SCA_SC_PROTO_CMD_crc_lrc_MASK;
1377	}
1378	}
1379	else {
1380	ulValue &= ~BCHP_SCA_SC_PROTO_CMD_edc_en_MASK;
1381	}
1382
1383	ulValue \|= in_channelHandle->currentChannelSettings.ulCharacterWaitTimeInteger;
1384
1385	BREG_Write32(
1386	in_channelHandle->moduleHandle->regHandle,
1387	(in_channelHandle->ulRegStartAddr + BSCD_P_PROTO_CMD),
1388	ulValue);
1389
1390	/* Update the BSCD_P_FLOW_CMD */
1391	ulValue = 0;
1392	if (in_channelHandle->currentChannelSettings.scStandard == BSCD_Standard_eNDS) {
1393	ulValue = BCHP_SCA_SC_FLOW_CMD_flow_en_MASK;
1394	}
1395	else {
1396	ulValue &= ~BCHP_SCA_SC_FLOW_CMD_flow_en_MASK;
1397	}
1398
1399	BREG_Write32(
1400	in_channelHandle->moduleHandle->regHandle,
1401	(in_channelHandle->ulRegStartAddr + BSCD_P_FLOW_CMD),
1402	ulValue);
1403
1404
1405	/* Update the BSCD_P_IF_CMD_2 */
1406	ulValue = 0;
1407	if (in_channelHandle->currentChannelSettings.scPresDbInfo.bIsEnabled == true) {
1408	ulValue = BCHP_SCA_SC_IF_CMD_2_db_en_MASK;
1409	}
1410	else {
1411	ulValue &= ~BCHP_SCA_SC_IF_CMD_2_db_en_MASK;
1412	}
1413
1414	if (in_channelHandle->currentChannelSettings.scPresDbInfo.scPresMode == BSCD_ScPresMode_eMask) {
1415	ulValue \|= BCHP_SCA_SC_IF_CMD_2_db_mask_MASK;
1416	}
1417	else if (in_channelHandle->currentChannelSettings.scPresDbInfo.scPresMode == BSCD_ScPresMode_eDebounce) {
1418	ulValue &= ~BCHP_SCA_SC_IF_CMD_2_db_mask_MASK;
1419	}
1420
1421	ulValue \|= in_channelHandle->currentChannelSettings.scPresDbInfo.ucDbWidth;
1422
1423	BREG_Write32(
1424	in_channelHandle->moduleHandle->regHandle,
1425	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_2),
1426	ulValue);
1427
1428	/* Update the BSCD_P_TGUARD */
1429	BREG_Write32(
1430	in_channelHandle->moduleHandle->regHandle,
1431	(in_channelHandle->ulRegStartAddr + BSCD_P_TGUARD),
1432	in_channelHandle->currentChannelSettings.extraGuardTime.ulValue);
1433
1434	if( inp_sSettings->setVcc){
1435	BSCD_Channel_SetVccLevel( in_channelHandle,inp_sSettings->vcc);
1436	}
1437
1438	BSCD_P_DONE_LABEL:
1439
1440	BDBG_LEAVE(BSCD_Channel_SetParameters);
1441	return( errCode );
1442	}
1443
1444
1445	BERR_Code BSCD_Channel_GetParameters(
1446	BSCD_ChannelHandle in_channelHandle,
1447	BSCD_ChannelSettings *outp_sSettings
1448	)
1449	{
1450	BERR_Code errCode = BERR_SUCCESS;
1451
1452	BDBG_ENTER(BSCD_Channel_GetParameters);
1453	BDBG_ASSERT( in_channelHandle );
1454
1455	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
1456	(in_channelHandle->ulMagicNumber != BSCD_P_CHANNEL_HANDLE_MAGIC_NUMBER ) );
1457
1458	*outp_sSettings = in_channelHandle->currentChannelSettings;
1459
1460	BSCD_P_DONE_LABEL:
1461
1462	BDBG_LEAVE(BSCD_Channel_GetParameters);
1463	return( errCode );
1464	}
1465
1466	char BSCD_Channel_GetChannelNumber(
1467	BSCD_ChannelHandle in_channelHandle
1468	)
1469	{
1470	BERR_Code errCode = BERR_SUCCESS;
1471
1472	BDBG_ENTER(BSCD_Channel_GetChannelNumber);
1473	BDBG_ASSERT( in_channelHandle );
1474
1475	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
1476	(in_channelHandle->ulMagicNumber != BSCD_P_CHANNEL_HANDLE_MAGIC_NUMBER ) );
1477
1478	BSCD_P_DONE_LABEL:
1479
1480	BDBG_LEAVE(BSCD_Channel_GetChannelNumber);
1481	if (errCode == BERR_SUCCESS)
1482	return( in_channelHandle->ucChannelNumber );
1483	else
1484	return -1;
1485	}
1486
1487
1488	BERR_Code BSCD_Channel_Deactivate(
1489	BSCD_ChannelHandle in_channelHandle
1490	)
1491	{
1492	BERR_Code errCode = BERR_SUCCESS;
1493	uint32_t ulValue;
1494
1495	BDBG_ENTER(BSCD_Channel_Deactivate);
1496	BDBG_ASSERT( in_channelHandle );
1497
1498	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
1499	(in_channelHandle->ulMagicNumber != BSCD_P_CHANNEL_HANDLE_MAGIC_NUMBER ) );
1500
1501	BDBG_MSG(("In BSCD_Channel_Deactivate\n"));
1502	/* Disable all interrupts */
1503	BREG_Write32(
1504	in_channelHandle->moduleHandle->regHandle,
1505	(in_channelHandle->ulRegStartAddr + BSCD_P_INTR_EN_1), 0);
1506
1507	BREG_Write32(
1508	in_channelHandle->moduleHandle->regHandle,
1509	(in_channelHandle->ulRegStartAddr + BSCD_P_INTR_EN_2), 0);
1510
1511
1512	if(in_channelHandle->currentChannelSettings.bConnectDirectly == true){
1513	/* Turn off VCC */
1514	ulValue = BREG_Read32(
1515	in_channelHandle->moduleHandle->regHandle,
1516	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1)) ;
1517	#ifdef BSCD_DIRECT_VCC_INVERTED
1518	ulValue &= ~BCHP_SCA_SC_IF_CMD_1_vcc_MASK;
1519	#else
1520	ulValue \|= BCHP_SCA_SC_IF_CMD_1_vcc_MASK;
1521	#endif
1522	}else{
1523	/* Turn off VCC */
1524	ulValue = BCHP_SCA_SC_IF_CMD_1_vcc_MASK \| BREG_Read32(
1525	in_channelHandle->moduleHandle->regHandle,
1526	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1)) ;
1527	}
1528	ulValue &= ~BCHP_SCA_SC_IF_CMD_1_auto_vcc_MASK;
1529	BREG_Write32(
1530	in_channelHandle->moduleHandle->regHandle,
1531	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1),
1532	ulValue);
1533
1534	#ifdef BSCD_DIRECT_RST_INVERTED
1535	if(in_channelHandle->currentChannelSettings.bConnectDirectly == true){
1536	/* Set RST = 0. */
1537	ulValue = BCHP_SCA_SC_IF_CMD_1_rst_MASK \| BREG_Read32(
1538	in_channelHandle->moduleHandle->regHandle,
1539	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1)) ;
1540	}
1541	else
1542	#else
1543	{
1544	/* Set RST = 0. */
1545	ulValue = (~BCHP_SCA_SC_IF_CMD_1_rst_MASK) & BREG_Read32(
1546	in_channelHandle->moduleHandle->regHandle,
1547	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1)) ;
1548	}
1549	#endif
1550	ulValue &= ~BCHP_SCA_SC_IF_CMD_1_auto_rst_MASK;
1551	BREG_Write32(
1552	in_channelHandle->moduleHandle->regHandle,
1553	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1),
1554	ulValue);
1555
1556	/* Set CLK = 0. */
1557	BREG_Write32(
1558	in_channelHandle->moduleHandle->regHandle,
1559	(in_channelHandle->ulRegStartAddr + BSCD_P_CLK_CMD),
1560	0);
1561	#if 0
1562	/* Set IO = 0. This will cause IO line in an unknown state in wamr reset, comment out temparily */
1563	ulValue = (BCHP_SCA_SC_IF_CMD_1_io_MASK) \| BREG_Read32(
1564	in_channelHandle->moduleHandle->regHandle,
1565	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1)) ;
1566	BREG_Write32(
1567	in_channelHandle->moduleHandle->regHandle,
1568	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1),
1569	ulValue);
1570	#endif
1571	/* Reset Tx & Rx buffers. */
1572	BREG_Write32(
1573	in_channelHandle->moduleHandle->regHandle,
1574	(in_channelHandle->ulRegStartAddr + BSCD_P_UART_CMD_1),
1575	~BCHP_SCA_SC_UART_CMD_1_io_en_MASK );
1576
1577	BREG_Write32(
1578	in_channelHandle->moduleHandle->regHandle,
1579	(in_channelHandle->ulRegStartAddr + BSCD_P_PROTO_CMD),
1580	BCHP_SCA_SC_PROTO_CMD_rbuf_rst_MASK \| BCHP_SCA_SC_PROTO_CMD_tbuf_rst_MASK);
1581
1582	BSCD_P_DONE_LABEL:
1583
1584	BDBG_LEAVE(BSCD_Channel_Deactivate);
1585	return( errCode );
1586	}
1587
1588
1589	BERR_Code BSCD_Channel_ResetIFD(
1590	BSCD_ChannelHandle in_channelHandle,
1591	BSCD_ResetType in_resetType
1592
1593	)
1594	{
1595	BERR_Code errCode = BERR_SUCCESS;
1596	uint32_t ulIFCmdVal = 0, ulValue;
1597	BSCD_Timer timer = {BSCD_TimerType_eGPTimer, {BSCD_GPTimerMode_eIMMEDIATE}, true, true};
1598	BSCD_TimerValue timeValue= {2, BSCD_TimerUnit_eETU};
1599
1600
1601	BDBG_ENTER(BSCD_Channel_ResetIFD);
1602	BDBG_ASSERT( in_channelHandle );
1603
1604	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
1605	(in_channelHandle->ulMagicNumber != BSCD_P_CHANNEL_HANDLE_MAGIC_NUMBER ) );
1606
1607	/* Reset all status */
1608	in_channelHandle->ulStatus1 = 0;
1609	in_channelHandle->ulStatus2 = 0;
1610	in_channelHandle->ulIntrStatus1= 0;
1611	in_channelHandle->ulIntrStatus2= 0;
1612
1613	in_channelHandle->channelStatus.ulStatus1 = 0;
1614
1615	if (in_resetType == BSCD_ResetType_eCold) {
1616
1617	in_channelHandle->channelStatus.bCardPresent = false;
1618
1619	/* 09/20/05,Allen.C, reset bIsCardRemoved after card removed and reinitialize*/
1620	in_channelHandle->bIsCardRemoved = false;
1621
1622	}
1623	/* Reset some critical registers */
1624	BREG_Write32(
1625	in_channelHandle->moduleHandle->regHandle,
1626	(in_channelHandle->ulRegStartAddr + BSCD_P_TIMER_CMD),
1627	0);
1628
1629	BREG_Write32(
1630	in_channelHandle->moduleHandle->regHandle,
1631	(in_channelHandle->ulRegStartAddr + BSCD_P_INTR_EN_1),
1632	0);
1633
1634	BREG_Write32(
1635	in_channelHandle->moduleHandle->regHandle,
1636	(in_channelHandle->ulRegStartAddr + BSCD_P_INTR_EN_2),
1637	0);
1638
1639	BREG_Write32(
1640	in_channelHandle->moduleHandle->regHandle,
1641	(in_channelHandle->ulRegStartAddr + BSCD_P_UART_CMD_1),
1642	0);
1643
1644	BREG_Write32(
1645	in_channelHandle->moduleHandle->regHandle,
1646	(in_channelHandle->ulRegStartAddr + BSCD_P_UART_CMD_2),
1647	0);
1648
1649	/* Set up debounce filter */
1650	if (in_channelHandle->currentChannelSettings.scPresDbInfo.bIsEnabled == true) {
1651
1652	ulValue = BCHP_SCA_SC_IF_CMD_2_db_en_MASK;
1653
1654	if (in_channelHandle->currentChannelSettings.scPresDbInfo.scPresMode == BSCD_ScPresMode_eMask) {
1655	ulValue \|= BCHP_SCA_SC_IF_CMD_2_db_mask_MASK;
1656	}
1657
1658	ulValue \|= in_channelHandle->currentChannelSettings.scPresDbInfo.ucDbWidth;
1659
1660	BREG_Write32(
1661	in_channelHandle->moduleHandle->regHandle,
1662	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_2), ulValue);
1663	}
1664	else {
1665	BREG_Write32(
1666	in_channelHandle->moduleHandle->regHandle,
1667	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_2), 0);
1668	}
1669
1670	BDBG_MSG(("Inside Reset: Before Cold Reset ulIFCmdVal = 0x%x\n", ulIFCmdVal));
1671	/* Cold Reset or Warm Reset */
1672	if (in_resetType == BSCD_ResetType_eCold) {
1673	BDBG_MSG(("Cold Reset\n"));
1674	in_channelHandle->resetType = BSCD_ResetType_eCold; /* Cold Reset */
1675
1676	/Disable CLK/
1677	BREG_Write32(
1678	in_channelHandle->moduleHandle->regHandle,
1679	(in_channelHandle->ulRegStartAddr + BSCD_P_CLK_CMD),
1680	0);
1681
1682	if(in_channelHandle->currentChannelSettings.bConnectDirectly == true){
1683	#ifdef BSCD_DSS_ICAM
1684	#ifdef BSCD_DIRECT_RST_INVERTED
1685	ulIFCmdVal = 0; //VCC L, RST H
1686	#else
1687	ulIFCmdVal = BCHP_SCA_SC_IF_CMD_1_rst_MASK; /VCC L, RST H/
1688	#endif
1689
1690	#else
1691
1692	#ifdef BSCD_DIRECT_RST_INVERTED
1693	ulIFCmdVal = BCHP_SCA_SC_IF_CMD_1_rst_MASK; /VCC L, RST L/
1694	#else
1695	ulIFCmdVal = 0; /VCC L, RST L/
1696	#endif
1697
1698	#endif
1699
1700	}
1701	else{
1702	#ifdef BSCD_DSS_ICAM
1703	ulIFCmdVal = BCHP_SCA_SC_IF_CMD_1_vcc_MASK \| BCHP_SCA_SC_IF_CMD_1_rst_MASK;
1704	#else
1705	ulIFCmdVal = BCHP_SCA_SC_IF_CMD_1_vcc_MASK;
1706	#endif
1707	}
1708	BREG_Write32(
1709	in_channelHandle->moduleHandle->regHandle,
1710	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1),
1711	ulIFCmdVal);
1712	/* 2007 12 13 Qiang Xie : for E* */
1713
1714	if(in_channelHandle->currentChannelSettings.bIsPresHigh){
1715	BDBG_MSG(("Change Presence Polarity\n"));
1716
1717	ulIFCmdVal \|= BCHP_SCA_SC_IF_CMD_1_pres_pol_MASK;
1718	BREG_Write32(
1719	in_channelHandle->moduleHandle->regHandle,
1720	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1),
1721	ulIFCmdVal);
1722	BDBG_MSG(("Finished Change Presence Polarity\n"));
1723	}
1724	#ifdef CUSTOMER_E
1725	else{
1726
1727	/* toggle polarity to trigger presence interrupt */
1728	ulIFCmdVal \|= BCHP_SCA_SC_IF_CMD_1_pres_pol_MASK;
1729	BREG_Write32( in_channelHandle->moduleHandle->regHandle, (in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1), ulIFCmdVal);
1730
1731	ulIFCmdVal &= ~BCHP_SCA_SC_IF_CMD_1_pres_pol_MASK;
1732	BREG_Write32( in_channelHandle->moduleHandle->regHandle, (in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1), ulIFCmdVal);
1733	}
1734	#endif
1735	}
1736	else {
1737	BDBG_MSG(("Warm Reset\n"));
1738	in_channelHandle->resetType = BSCD_ResetType_eWarm; /* Warm Reset */
1739
1740	ulIFCmdVal = BREG_Read32(
1741	in_channelHandle->moduleHandle->regHandle,
1742	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1));
1743	}
1744	BDBG_MSG(("Inside Reset: After Cold Reset ulIFCmdVal = 0x%x\n", ulIFCmdVal));
1745
1746	/* Use Auto Deactivation instead of TDA8004 */
1747	if (in_channelHandle->currentChannelSettings.bAutoDeactiveReq == true) {
1748
1749	BDBG_MSG(("Inside Reset: Before auto clk BSCD_P_CLK_CMD = 0x%x\n",
1750	BREG_Read32(
1751	in_channelHandle->moduleHandle->regHandle,
1752	(in_channelHandle->ulRegStartAddr + BSCD_P_CLK_CMD))));
1753
1754	ulIFCmdVal \|= BCHP_SCA_SC_IF_CMD_1_auto_clk_MASK;
1755	BREG_Write32(
1756	in_channelHandle->moduleHandle->regHandle,
1757	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1),
1758	ulIFCmdVal);
1759	}
1760
1761
1762	if(in_channelHandle->currentChannelSettings.bConnectDirectly == true){
1763	/* wait for voltage on Vcc to completely low */
1764	BKNI_Sleep(10);
1765
1766	ulIFCmdVal = BREG_Read32( in_channelHandle->moduleHandle->regHandle, (in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1));
1767	/* Pull high Vcc, and start activation sequence */
1768	#ifdef BSCD_DIRECT_VCC_INVERTED
1769	ulIFCmdVal &= ~BCHP_SCA_SC_IF_CMD_1_vcc_MASK;
1770	#else
1771	ulIFCmdVal \|= BCHP_SCA_SC_IF_CMD_1_vcc_MASK;
1772	#endif
1773	ulIFCmdVal &= ~BCHP_SCA_SC_IF_CMD_1_io_MASK;
1774	if(in_channelHandle->currentChannelSettings.bAutoDeactiveReq == true){
1775	ulIFCmdVal \|= BCHP_SCA_SC_IF_CMD_1_auto_vcc_MASK;
1776	}
1777	BREG_Write32( in_channelHandle->moduleHandle->regHandle, (in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1), ulIFCmdVal);
1778
1779	/* From Vcc goes high, TDA8024 expects 50-220 us for CLK start */
1780	BKNI_Delay(100);
1781	}
1782
1783
1784	/* Set Clk cmd */
1785	ulValue = BCHP_SCA_SC_CLK_CMD_clk_en_MASK \|
1786	(BSCD_P_MapScClkDivToMaskValue(in_channelHandle->currentChannelSettings.ucScClkDiv)) \|
1787	((in_channelHandle->currentChannelSettings.ucEtuClkDiv - 1) << 1) \|
1788	((in_channelHandle->currentChannelSettings.ucBaudDiv == 31) ? 0 : 1);
1789
1790	BDBG_MSG(("Reset: BCM_SC_CLK_CMD = 0x%lx\n", ulValue));
1791
1792	BREG_Write32(
1793	in_channelHandle->moduleHandle->regHandle,
1794	(in_channelHandle->ulRegStartAddr + BSCD_P_CLK_CMD),
1795	ulValue);
1796
1797	BREG_Write32(
1798	in_channelHandle->moduleHandle->regHandle,
1799	(in_channelHandle->ulRegStartAddr + BSCD_P_PRESCALE),
1800	in_channelHandle->currentChannelSettings.unPrescale);
1801	BDBG_MSG(("Reset: BSCD_P_PRESCALE = 0x%lx\n", in_channelHandle->currentChannelSettings.unPrescale));
1802
1803	/* Use Auto Deactivation instead of TDA8004 */
1804	if (in_channelHandle->currentChannelSettings.bAutoDeactiveReq == true) {
1805
1806	BDBG_MSG(("Inside Reset: Before auto io ulIFCmdVal = 0x%x\n", ulIFCmdVal));
1807	ulIFCmdVal \|= BCHP_SCA_SC_IF_CMD_1_auto_io_MASK;
1808	BREG_Write32(
1809	in_channelHandle->moduleHandle->regHandle,
1810	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1),
1811	ulIFCmdVal);
1812	BDBG_MSG(("Inside Reset: after auto io ulIFCmdVal = 0x%x\n", ulIFCmdVal));
1813	}
1814
1815	#if 0 /ndef BSCD_DSS_ICAM/
1816	if(in_channelHandle->currentChannelSettings.bConnectDirectly == false){
1817
1818	ulIFCmdVal \|= BCHP_SCA_SC_IF_CMD_1_rst_MASK;
1819	BREG_Write32(
1820	in_channelHandle->moduleHandle->regHandle,
1821	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1),
1822	ulIFCmdVal);
1823	}
1824	#endif
1825
1826
1827	ulValue = 0;
1828	BREG_Write32(
1829	in_channelHandle->moduleHandle->regHandle,
1830	(in_channelHandle->ulRegStartAddr + BSCD_P_UART_CMD_1),
1831	ulValue);
1832
1833	BDBG_MSG(("Inside Reset: Before SmartCardEnableInt\n"));
1834
1835	/* Enable 2 interrupts with callback */
1836	BSCD_P_CHECK_ERR_CODE_FUNC(errCode,
1837	BSCD_Channel_EnableIntrCallback_isr (
1838	in_channelHandle, BSCD_IntType_eCardInsertInt,
1839	BSCD_Channel_P_CardInsertCB_isr));
1840
1841	BSCD_P_CHECK_ERR_CODE_FUNC(errCode,
1842	BSCD_Channel_EnableIntrCallback_isr (
1843	in_channelHandle, BSCD_IntType_eCardRemoveInt,
1844	BSCD_Channel_P_CardRemoveCB_isr));
1845
1846	BREG_Write32(
1847	in_channelHandle->moduleHandle->regHandle,
1848	(in_channelHandle->ulRegStartAddr + BSCD_P_UART_CMD_1),
1849	BCHP_SCA_SC_UART_CMD_1_uart_rst_MASK);
1850
1851	/******************************************************************
1852	**
1853	** UART Reset should be set within 1 ETU (however, we are generous
1854	** to give it 2 etus.
1855	**
1856	*****************************************************************/
1857	BSCD_P_CHECK_ERR_CODE_FUNC(errCode,
1858	BSCD_Channel_ConfigTimer(in_channelHandle, &timer, &timeValue));
1859
1860	BSCD_P_CHECK_ERR_CODE_FUNC(errCode,
1861	BSCD_Channel_P_WaitForTimerEvent(in_channelHandle));
1862
1863	/* Disable timer */
1864	timer.bIsTimerInterruptEnable = false;
1865	timer.bIsTimerEnable = false;
1866	BSCD_P_CHECK_ERR_CODE_FUNC(errCode,
1867	BSCD_Channel_EnableDisableTimer_isr(in_channelHandle, &timer));
1868
1869	ulValue = BREG_Read32(
1870	in_channelHandle->moduleHandle->regHandle,
1871	(in_channelHandle->ulRegStartAddr + BSCD_P_UART_CMD_1));
1872
1873	/* If equal to zero, then UART reset has gone low, so return success */
1874	if ((ulValue & BCHP_SCA_SC_UART_CMD_1_uart_rst_MASK) == 0) {
1875	BDBG_MSG(("Reset Success\n"));
1876
1877	/*
1878	** INITIAL_CWI_SC_PROTO_CMD = 0x0f is required so that
1879	** CWI does not remain equal to zero, which causes an
1880	** erroneous timeout, the CWI is set correctly in the
1881	** SmartCardEMVATRDecode procedure
1882	*/
1883	BREG_Write32(
1884	in_channelHandle->moduleHandle->regHandle,
1885	(in_channelHandle->ulRegStartAddr + BSCD_P_PROTO_CMD),
1886	BCHP_SCA_SC_PROTO_CMD_tbuf_rst_MASK \| BCHP_SCA_SC_PROTO_CMD_rbuf_rst_MASK);
1887	}
1888
1889
1890	BSCD_P_DONE_LABEL:
1891
1892	BDBG_LEAVE(BSCD_Channel_ResetIFD);
1893	return( errCode );
1894	}
1895
1896
1897	BERR_Code BSCD_Channel_PowerICC(
1898	BSCD_ChannelHandle in_channelHandle,
1899	BSCD_PowerICC in_iccAction
1900	)
1901	{
1902	BERR_Code errCode = BERR_SUCCESS;
1903	uint32_t ulValue;
1904
1905	BDBG_ENTER(BSCD_Channel_PowerICC);
1906	BDBG_ASSERT( in_channelHandle );
1907
1908	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
1909	(in_channelHandle->ulMagicNumber != BSCD_P_CHANNEL_HANDLE_MAGIC_NUMBER ) );
1910
1911	if(in_channelHandle->currentChannelSettings.bConnectDirectly == false){
1912
1913	switch (in_iccAction) {
1914	case BSCD_PowerICC_ePowerDown:
1915	ulValue = BCHP_SCA_SC_IF_CMD_1_vcc_MASK \| BREG_Read32(
1916	in_channelHandle->moduleHandle->regHandle,
1917	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1)) ;
1918	ulValue &= ~BCHP_SCA_SC_IF_CMD_1_rst_MASK;
1919	BREG_Write32(
1920	in_channelHandle->moduleHandle->regHandle,
1921	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1),
1922	ulValue);
1923	break;
1924	case BSCD_PowerICC_ePowerUp:
1925	ulValue = BREG_Read32(
1926	in_channelHandle->moduleHandle->regHandle,
1927	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1)) ;
1928	BREG_Write32(
1929	in_channelHandle->moduleHandle->regHandle,
1930	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1),
1931	(ulValue & ~BCHP_SCA_SC_IF_CMD_1_vcc_MASK));
1932	break;
1933
1934	default:
1935	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED, true);
1936	break;
1937	}
1938	}else{
1939	switch (in_iccAction) {
1940	case BSCD_PowerICC_ePowerUp:
1941	ulValue = BCHP_SCA_SC_IF_CMD_1_vcc_MASK \| BREG_Read32(
1942	in_channelHandle->moduleHandle->regHandle,
1943	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1)) ;
1944	if(in_channelHandle->currentChannelSettings.bAutoDeactiveReq == true){
1945	ulValue \|= BCHP_SCA_SC_IF_CMD_1_auto_vcc_MASK;
1946	}
1947	BREG_Write32(
1948	in_channelHandle->moduleHandle->regHandle,
1949	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1),
1950	ulValue);
1951	break;
1952	case BSCD_PowerICC_ePowerDown:
1953	ulValue = BREG_Read32(
1954	in_channelHandle->moduleHandle->regHandle,
1955	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1)) ;
1956	ulValue &= ~BCHP_SCA_SC_IF_CMD_1_auto_vcc_MASK;
1957	BREG_Write32(
1958	in_channelHandle->moduleHandle->regHandle,
1959	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1),
1960	(ulValue & ~BCHP_SCA_SC_IF_CMD_1_vcc_MASK));
1961	break;
1962
1963	default:
1964	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED, true);
1965	break;
1966	}
1967
1968	}
1969
1970
1971	BSCD_P_DONE_LABEL:
1972
1973	BDBG_LEAVE(BSCD_Channel_ResetIFD);
1974	return( errCode );
1975	}
1976
1977	BERR_Code BSCD_Channel_SetVccLevel(
1978	BSCD_ChannelHandle in_channelHandle,
1979	BSCD_VccLevel in_vccLevel
1980	)
1981	{
1982	BERR_Code errCode = BERR_SUCCESS;
1983	uint32_t ulValue = 0;
1984
1985	BSTD_UNUSED(ulValue);
1986	BDBG_ENTER(BSCD_Channel_SetVccLevel);
1987	BDBG_ASSERT( in_channelHandle );
1988
1989	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
1990	(in_channelHandle->ulMagicNumber != BSCD_P_CHANNEL_HANDLE_MAGIC_NUMBER ) );
1991
1992
1993	/***************************************************************
1994	Warning: Note that we have to modify the board to use VPP pin of NDS
1995	ICAM smartcard and connect it to pin 3 (3V/5V) of TDA chip
1996	and run this function. Make sure to disconnect your QAM or
1997	QPSK connection before calling this function or your smartcard
1998	will be damaged.
1999	***************************************************************/
2000	BDBG_MSG(("BSCD_Channel_SetVccLevel: in_vccLevel = 0x%x\n", in_vccLevel));
2001
2002	BKNI_EnterCriticalSection();
2003
2004	#if (BCHP_CHIP==7422) \|\| (BCHP_CHIP==7425)
2005	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle,
2006	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_14);
2007	ulValue &= ~(BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_14_gpio_074_MASK);
2008
2009	BREG_Write32 (in_channelHandle->moduleHandle->regHandle, BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_14,ulValue );
2010
2011	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_IODIR_EXT);
2012	ulValue &= ~(1<<(74-64+6)); /* include sgpio */
2013	BREG_Write32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_IODIR_EXT, ulValue );
2014	#elif (BCHP_CHIP == 7346)
2015	switch( in_channelHandle->ucChannelNumber){
2016	case 0:
2017	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle,
2018	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_9);
2019	ulValue &= ~BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_9_gpio_015_MASK;
2020	BREG_Write32 (in_channelHandle->moduleHandle->regHandle,
2021	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_9, ulValue);
2022
2023	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_IODIR_LO);
2024	ulValue &= ~(1<<15);
2025
2026	BREG_Write32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_IODIR_LO, ulValue );
2027	break;
2028	case 1:
2029	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle,
2030	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_11);
2031	ulValue &= ~BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_11_gpio_032_MASK;
2032	BREG_Write32 (in_channelHandle->moduleHandle->regHandle,
2033	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_11, ulValue);
2034
2035	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_IODIR_HI);
2036	ulValue &= ~(1);
2037
2038	BREG_Write32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_IODIR_HI, ulValue );
2039	break;
2040	}
2041	#elif (BCHP_CHIP == 7231)
2042	switch( in_channelHandle->ucChannelNumber){
2043	case 0:
2044	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle,
2045	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10);
2046	ulValue &= ~BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10_gpio_86_MASK;
2047	BREG_Write32 (in_channelHandle->moduleHandle->regHandle,
2048	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_10, ulValue);
2049
2050	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_IODIR_EXT);
2051	ulValue &= ~(1<<(86-64+6));
2052	BREG_Write32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_IODIR_EXT, ulValue );
2053	break;
2054	case 1:
2055	BDBG_WRN(("Slot 1 not supported in BRCM reference board, please use customer callback function to set the correct voltage\n"));
2056	break;
2057	}
2058	#elif (BCHP_CHIP == 7358)\|\|(BCHP_CHIP==7552)
2059	switch( in_channelHandle->ucChannelNumber){
2060	case 0:
2061	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle,
2062	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_11);
2063	ulValue &= ~BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_11_gpio_86_MASK;
2064	BREG_Write32 (in_channelHandle->moduleHandle->regHandle,
2065	BCHP_SUN_TOP_CTRL_PIN_MUX_CTRL_11, ulValue);
2066
2067	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_IODIR_EXT);
2068	ulValue &= ~(1<<(86-64));
2069
2070	BREG_Write32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_IODIR_EXT, ulValue );
2071	break;
2072	case 1:
2073	BDBG_WRN(("Slot 1 not supported in BRCM reference board, please use customer callback function to set the correct voltage\n"));
2074	break;
2075	}
2076	#elif (BCHP_CHIP == 7344)
2077	switch( in_channelHandle->ucChannelNumber){
2078	case 0:
2079	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle,
2080	BCHP_AON_PIN_CTRL_PIN_MUX_CTRL_1);
2081	ulValue &= ~BCHP_AON_PIN_CTRL_PIN_MUX_CTRL_1_aon_gpio_08_MASK ;
2082
2083	BREG_Write32 (in_channelHandle->moduleHandle->regHandle, BCHP_AON_PIN_CTRL_PIN_MUX_CTRL_1,ulValue );
2084	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_AON_IODIR_LO);
2085	ulValue &= ~(1<<(8));
2086	BREG_Write32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_AON_IODIR_LO,ulValue );
2087	break;
2088	case 1:
2089	BDBG_WRN(("Slot 1 not supported in BRCM reference board, please use customer callback function to set the correct voltage\n"));
2090	break;
2091	}
2092
2093	#else
2094	BDBG_WRN(("Chip is not supported!\n"));
2095	#endif
2096
2097	switch (in_vccLevel) {
2098	case BSCD_VccLevel_e3V:
2099
2100	#if (BCHP_CHIP==7422) \|\| (BCHP_CHIP==7425)
2101	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_DATA_EXT);
2102	ulValue &= ~(1<<(74-64+6));
2103	BREG_Write32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_DATA_EXT, ulValue );
2104	#elif (BCHP_CHIP == 7346)
2105	switch( in_channelHandle->ucChannelNumber){
2106	case 0:
2107	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_DATA_LO);
2108	ulValue &= ~(1<<15);
2109
2110	BREG_Write32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_DATA_LO, ulValue );
2111	break;
2112	case 1:
2113	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_DATA_HI);
2114	ulValue &= ~(1);
2115
2116	BREG_Write32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_DATA_HI, ulValue );
2117	break;
2118	}
2119	#elif (BCHP_CHIP==7231)
2120	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_DATA_EXT);
2121	ulValue &= ~(1<<(86-64+6));
2122	BREG_Write32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_DATA_EXT, ulValue );
2123	#elif (BCHP_CHIP==7358) \|\|(BCHP_CHIP==7552)
2124	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_DATA_EXT);
2125	ulValue &= ~(1<<(86-64));
2126	BREG_Write32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_DATA_EXT, ulValue );
2127	#elif (BCHP_CHIP==7344)
2128	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_AON_DATA_LO);
2129	ulValue &= ~(1<<(8));
2130	BREG_Write32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_AON_DATA_LO, ulValue );
2131	#else
2132	BDBG_WRN(("Chip is not supported!\n"));
2133	#endif
2134	break;
2135
2136	case BSCD_VccLevel_e5V:
2137	#if (BCHP_CHIP==7422) \|\| (BCHP_CHIP==7425)
2138	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_DATA_EXT);
2139	ulValue \|= (1<<(74-64+6));
2140	BREG_Write32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_DATA_EXT, ulValue );
2141	#elif (BCHP_CHIP == 7346)
2142	switch( in_channelHandle->ucChannelNumber){
2143	case 0:
2144	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_DATA_LO);
2145	ulValue \|= 1<<15;
2146
2147	BREG_Write32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_DATA_LO, ulValue );
2148	break;
2149	case 1:
2150	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_DATA_HI);
2151	ulValue \|= 1;
2152
2153	BREG_Write32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_DATA_HI, ulValue );
2154	break;
2155	}
2156	#elif (BCHP_CHIP==7231)
2157	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_DATA_EXT);
2158	ulValue \|= 1<<(86-64+6);
2159	BREG_Write32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_DATA_EXT, ulValue );
2160	#elif (BCHP_CHIP==7358) \|\|(BCHP_CHIP==7552)
2161	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_DATA_EXT);
2162	ulValue \|= 1<<(86-64);
2163	BREG_Write32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_DATA_EXT, ulValue );
2164	#elif (BCHP_CHIP==7344)
2165	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_AON_DATA_LO);
2166	ulValue \|= (1<<(8));
2167	BREG_Write32 (in_channelHandle->moduleHandle->regHandle, BCHP_GIO_AON_DATA_LO, ulValue );
2168
2169	#else
2170	BDBG_WRN(("Chip is not supported!\n"));
2171
2172	#endif
2173	break;
2174
2175	default:
2176	errCode = BERR_TRACE(BSCD_STATUS_FAILED);
2177	BDBG_ERR(("BSCD_Channel_SetVccLevel: Do not support VCC Level switch = 0x%x, \n", in_vccLevel));
2178	goto BSCD_P_DONE_LABEL;
2179	}
2180
2181
2182
2183
2184
2185
2186	BSCD_P_DONE_LABEL:
2187	BKNI_LeaveCriticalSection();
2188	BDBG_LEAVE(BSCD_Channel_SetVccLevel);
2189	return( errCode );
2190
2191	}
2192
2193	BERR_Code BSCD_Channel_InsCardHwReset(
2194	BSCD_ChannelHandle in_channelHandle,
2195	bool in_enableHwRst
2196	)
2197	{
2198	BERR_Code errCode = BERR_SUCCESS;
2199	uint32_t ulValue = 0;
2200
2201	BDBG_ENTER(BSCD_Channel_InsCardHwReset);
2202	BDBG_ASSERT( in_channelHandle );
2203
2204	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
2205	(in_channelHandle->ulMagicNumber != BSCD_P_CHANNEL_HANDLE_MAGIC_NUMBER ) );
2206
2207	#if !defined(LINUX) && ((BCHP_CHIP==7400) )
2208	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle, BCHP_SUN_TOP_CTRL_RESET_CTRL);
2209
2210	switch (in_channelHandle->ucChannelNumber) {
2211	case 0:
2212	if ( in_enableHwRst ) /Enable Inser Card Hardware Reset/
2213	ulValue \|= ( 1 << BCHP_SUN_TOP_CTRL_RESET_CTRL_sc_insert_reset_en_SHIFT );
2214	else
2215	ulValue &= ~( 1 << BCHP_SUN_TOP_CTRL_RESET_CTRL_sc_insert_reset_en_SHIFT );
2216
2217	break;
2218
2219	case 1:
2220	if ( in_enableHwRst ) /Enable Inser Card Hardware Reset/
2221	ulValue \|= ( 2 << BCHP_SUN_TOP_CTRL_RESET_CTRL_sc_insert_reset_en_SHIFT );
2222	else
2223	ulValue &= ~( 2 << BCHP_SUN_TOP_CTRL_RESET_CTRL_sc_insert_reset_en_SHIFT );
2224
2225	break;
2226
2227	case 2:
2228	if ( in_enableHwRst ) /Enable Inser Card Hardware Reset/
2229	ulValue \|= ( 4 << BCHP_SUN_TOP_CTRL_RESET_CTRL_sc_insert_reset_en_SHIFT );
2230	else
2231	ulValue &= ~( 4 << BCHP_SUN_TOP_CTRL_RESET_CTRL_sc_insert_reset_en_SHIFT );
2232
2233	break;
2234
2235	default:
2236	return -1;
2237	}
2238
2239	BREG_Write32 (in_channelHandle->moduleHandle->regHandle, BCHP_SUN_TOP_CTRL_RESET_CTRL, ulValue);
2240
2241	#elif !defined(LINUX) && (BCHP_CHIP==7401)
2242	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle, BCHP_SUN_TOP_CTRL_RESET_CTRL);
2243
2244	switch (in_channelHandle->ucChannelNumber) {
2245	case 0:
2246	if ( in_enableHwRst ) /Enable Inser Card Hardware Reset/
2247	ulValue \|= ( 1 << BCHP_SUN_TOP_CTRL_RESET_CTRL_sc_insert_reset_en_SHIFT );
2248	else
2249	ulValue &= ~( 1 << BCHP_SUN_TOP_CTRL_RESET_CTRL_sc_insert_reset_en_SHIFT );
2250
2251	break;
2252
2253	case 1:
2254	if ( in_enableHwRst ) /Enable Inser Card Hardware Reset/
2255	ulValue \|= ( 2 << BCHP_SUN_TOP_CTRL_RESET_CTRL_sc_insert_reset_en_SHIFT );
2256	else
2257	ulValue &= ~( 2 << BCHP_SUN_TOP_CTRL_RESET_CTRL_sc_insert_reset_en_SHIFT );
2258
2259	break;
2260
2261	default:
2262	return -1;
2263	}
2264
2265	BREG_Write32 (in_channelHandle->moduleHandle->regHandle, BCHP_SUN_TOP_CTRL_RESET_CTRL, ulValue);
2266	/#elif !defined(LINUX) && (defined(BCM97038) \|\| defined(BCM7038)) /
2267	#elif !defined(LINUX) && ((BCHP_CHIP==7038) \|\| (BCHP_CHIP==7438) )
2268
2269	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle, BCHP_SUN_TOP_CTRL_RESET_CTRL);
2270
2271	switch (in_channelHandle->ucChannelNumber) {
2272	case 2:
2273	if ( in_enableHwRst ) /Enable Inser Card Hardware Reset/
2274	ulValue \|= BCHP_SUN_TOP_CTRL_RESET_CTRL_sc2_insert_reset_en_MASK;
2275	else
2276	ulValue &= ~(BCHP_SUN_TOP_CTRL_RESET_CTRL_sc2_insert_reset_en_MASK);
2277	break;
2278
2279	case 1:
2280	if ( in_enableHwRst ) /Enable Inser Card Hardware Reset/
2281	ulValue \|= BCHP_SUN_TOP_CTRL_RESET_CTRL_sc1_insert_reset_en_MASK;
2282	else
2283	ulValue &= ~(BCHP_SUN_TOP_CTRL_RESET_CTRL_sc1_insert_reset_en_MASK);
2284	break;
2285
2286	case 0:
2287	if ( in_enableHwRst ) /Enable Inser Card Hardware Reset/
2288	ulValue \|= BCHP_SUN_TOP_CTRL_RESET_CTRL_sc0_insert_reset_en_MASK;
2289	else
2290	ulValue &= ~(BCHP_SUN_TOP_CTRL_RESET_CTRL_sc0_insert_reset_en_MASK);
2291	break;
2292
2293	default:
2294	return -1;
2295	}
2296
2297	BREG_Write32 (in_channelHandle->moduleHandle->regHandle, BCHP_SUN_TOP_CTRL_RESET_CTRL, ulValue);
2298
2299	#elif !defined(LINUX) && (BCHP_CHIP==3560)
2300
2301	ulValue = BREG_Read32 (in_channelHandle->moduleHandle->regHandle, BCHP_SUN_TOP_CTRL_RESET_CTRL);
2302
2303	switch (in_channelHandle->ucChannelNumber) {
2304	case 0:
2305	if ( in_enableHwRst ) /Enable Inser Card Hardware Reset/
2306	ulValue \|= BCHP_SUN_TOP_CTRL_RESET_CTRL_sc0_insert_reset_en_MASK;
2307	else
2308	ulValue &= ~(BCHP_SUN_TOP_CTRL_RESET_CTRL_sc0_insert_reset_en_MASK);
2309	break;
2310
2311	default:
2312	return -1;
2313	}
2314
2315	BREG_Write32 (in_channelHandle->moduleHandle->regHandle, BCHP_SUN_TOP_CTRL_RESET_CTRL, ulValue);
2316	#else
2317	BSTD_UNUSED( ulValue );
2318	BSTD_UNUSED( in_enableHwRst);
2319
2320	#endif
2321
2322
2323	BSCD_P_DONE_LABEL:
2324
2325	BDBG_LEAVE(BSCD_Channel_InsCardHwReset);
2326	return( errCode );
2327
2328	}
2329
2330	BERR_Code BSCD_Channel_ResetCard(
2331	BSCD_ChannelHandle in_channelHandle,
2332	BSCD_ResetCardAction in_iccAction
2333	)
2334	{
2335	BERR_Code errCode = BERR_SUCCESS;
2336
2337	BDBG_ENTER(BSCD_Channel_ResetCard);
2338	BDBG_ASSERT( in_channelHandle );
2339
2340	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
2341	(in_channelHandle->ulMagicNumber != BSCD_P_CHANNEL_HANDLE_MAGIC_NUMBER ) );
2342
2343
2344	switch (in_iccAction) {
2345	case BSCD_ResetCardAction_eNoAction:
2346	if ( (errCode = BSCD_Channel_P_Activating(in_channelHandle)) != BERR_SUCCESS) {
2347	errCode = BERR_TRACE(errCode);
2348	goto BSCD_P_DONE_LABEL;
2349	}
2350	break;
2351	case BSCD_ResetCardAction_eReceiveAndDecode:
2352	BDBG_MSG(("BSCD_ResetCardAction_eReceiveAndDecode \n"));
2353	if ( ((errCode = BSCD_Channel_P_Activating(in_channelHandle)) != BERR_SUCCESS) \|\|
2354	((errCode = BSCD_Channel_P_ReceiveAndDecode(in_channelHandle)) != BERR_SUCCESS) ) {
2355	errCode = BERR_TRACE(errCode);
2356	goto BSCD_P_DONE_LABEL;
2357	}
2358	break;
2359
2360	default:
2361	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED, true);
2362	break;
2363	}
2364
2365
2366	BSCD_P_DONE_LABEL:
2367
2368	BDBG_LEAVE(BSCD_Channel_ResetCard);
2369	BDBG_MSG(("Leave ResetCard erroCode = 0x%x\n", errCode));
2370	return( errCode );
2371	}
2372
2373
2374	BERR_Code BSCD_Channel_GetStatus(
2375	BSCD_ChannelHandle in_channelHandle,
2376	BSCD_Status *outp_status
2377	)
2378	{
2379	BERR_Code errCode = BERR_SUCCESS;
2380
2381	BDBG_ENTER(BSCD_Channel_GetStatus);
2382	BDBG_ASSERT( in_channelHandle );
2383
2384	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
2385	(in_channelHandle->ulMagicNumber != BSCD_P_CHANNEL_HANDLE_MAGIC_NUMBER ) );
2386
2387	*outp_status = in_channelHandle->channelStatus;
2388
2389	BSCD_P_DONE_LABEL:
2390
2391	BDBG_LEAVE(BSCD_Channel_GetStatus);
2392	return( errCode );
2393	}
2394
2395	BERR_Code BSCD_Channel_Transmit(
2396	BSCD_ChannelHandle in_channelHandle,
2397	uint8_t *inp_ucXmitData,
2398	unsigned long in_ulNumXmitBytes
2399	)
2400	{
2401	if (in_channelHandle->currentChannelSettings.scStandard == BSCD_Standard_eIrdeto) {
2402	return (BSCD_Channel_P_T14IrdetoTransmit(
2403	in_channelHandle,
2404	inp_ucXmitData,
2405	in_ulNumXmitBytes));
2406	}
2407	else {
2408	return (BSCD_Channel_P_T0T1Transmit(
2409	in_channelHandle,
2410	inp_ucXmitData,
2411	in_ulNumXmitBytes));
2412	}
2413	}
2414
2415
2416	BERR_Code BSCD_Channel_Receive(
2417	BSCD_ChannelHandle in_channelHandle,
2418	uint8_t *outp_ucRcvData,
2419	unsigned long *outp_ulNumRcvBytes,
2420	unsigned long in_ulMaxReadBytes
2421	)
2422	{
2423	BERR_Code errCode = BSCD_STATUS_READ_SUCCESS;
2424	#ifndef BSCD_DSS_ICAM
2425	BSCD_Timer timer = {BSCD_TimerType_eWaitTimer, {BSCD_WaitTimerMode_eWorkWaitTime}, false, false};
2426	#endif
2427
2428	BDBG_ENTER(BSCD_Channel_Receive);
2429	BDBG_ASSERT( in_channelHandle );
2430
2431	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
2432	(in_channelHandle->ulMagicNumber != BSCD_P_CHANNEL_HANDLE_MAGIC_NUMBER ) );
2433
2434
2435
2436	*outp_ulNumRcvBytes = 0;
2437
2438	/* Coverity: 35203 */
2439	if(outp_ucRcvData == NULL) {
2440	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED, true);
2441	}
2442
2443	if ((in_channelHandle->currentChannelSettings.eProtocolType == BSCD_AsyncProtocolType_e0) \|\|
2444	(in_channelHandle->currentChannelSettings.eProtocolType == BSCD_AsyncProtocolType_e14_IRDETO) ) {
2445
2446	BSCD_P_CHECK_ERR_CODE_FUNC(errCode,
2447	BSCD_Channel_P_T0ReadData(in_channelHandle, outp_ucRcvData, outp_ulNumRcvBytes,
2448	in_ulMaxReadBytes));
2449
2450	/*
2451	The Work Wait Timer is enabled in BSCD_Channel_P_T0T1Transmit. We cannot disable
2452	it in BSCD_Channel_P_T0ReadData since BSCD_Channel_P_T0ReadData is also used
2453	by reading ATR, which is one byte at a time.
2454	*/
2455
2456	#ifndef BSCD_DSS_ICAM /* BSYT leave this WWT enabled. We only disable WWT in transmit. */
2457	/*
2458	I assume all standards, other than EMV, will read all the bytes in BSCD_Channel_P_T0ReadData,
2459	therefore we couold safely disable the WWT here. EMV only read 1 bytes at a time, therefore
2460	we have to disable WWT in the application
2461	*/
2462	if ((in_channelHandle->currentChannelSettings.scStandard != BSCD_Standard_eEMV1996) &&
2463	(in_channelHandle->currentChannelSettings.scStandard != BSCD_Standard_eEMV2000) )
2464	BSCD_P_CHECK_ERR_CODE_FUNC2(errCode, BSCD_STATUS_READ_FAILED,
2465	BSCD_Channel_EnableDisableTimer_isr(in_channelHandle, &timer));
2466	#endif
2467
2468
2469	}/* BSCD_AsyncProtocolType_e0 */
2470
2471	else { /* BSCD_AsyncProtocolType_e1 */
2472
2473	BSCD_P_CHECK_ERR_CODE_FUNC(errCode,
2474	BSCD_Channel_P_T1ReadData(in_channelHandle, outp_ucRcvData, outp_ulNumRcvBytes,
2475	in_ulMaxReadBytes));
2476
2477	} /* BSCD_AsyncProtocolType_e1 */
2478
2479	if (*outp_ulNumRcvBytes > 0) {
2480
2481	/* Ignore the ReadTimeOut error returned by SmartCardByteRead */
2482	/* BDBG_MSG (("success in SmartCardReadCmd\n")); */
2483	}
2484
2485	else {
2486	BDBG_MSG (("No Response detected...deactivating, scerr = %02x\n",errCode));
2487	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED, true);
2488	}
2489
2490
2491
2492	BSCD_P_DONE_LABEL:
2493
2494	BDBG_LEAVE(BSCD_Channel_Receive);
2495	/* BDBG_MSG(("Leave BSCD_Channel_Receive = 0x%x\n", errCode)); */
2496	return( errCode );
2497	}
2498
2499	BERR_Code BSCD_Channel_ReceiveATR(
2500	BSCD_ChannelHandle in_channelHandle,
2501	uint8_t *outp_ucRcvData,
2502	unsigned long *outp_ulNumRcvBytes,
2503	unsigned long in_ulMaxReadBytes
2504	)
2505	{
2506	BERR_Code errCode = BSCD_STATUS_READ_SUCCESS;
2507
2508	BDBG_ENTER(BSCD_Channel_ReceiveATR);
2509	BDBG_ASSERT( in_channelHandle );
2510
2511	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
2512	(in_channelHandle->ulMagicNumber != BSCD_P_CHANNEL_HANDLE_MAGIC_NUMBER ) );
2513
2514	*outp_ulNumRcvBytes = 0;
2515
2516	if(outp_ucRcvData == NULL) {
2517	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED, true);
2518	}
2519
2520	BSCD_P_CHECK_ERR_CODE_FUNC(errCode,
2521	BSCD_Channel_P_T0ReadData(in_channelHandle, outp_ucRcvData, outp_ulNumRcvBytes,
2522	in_ulMaxReadBytes));
2523
2524	if (*outp_ulNumRcvBytes > 0) {
2525
2526	/*
2527	For T=0, we depend on timeout to
2528	identify that there is no more byte to be received
2529	*/
2530
2531	/* Ignore the ReadTimeOut error returned by SmartCardByteRead */
2532	/* BDBG_MSG (("success in SmartCardReadCmd\n")); */
2533	}
2534
2535	else {
2536	BDBG_MSG (("No Response detected...deactivating, scerr = %02x\n",errCode));
2537	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED, true);
2538	}
2539
2540
2541
2542	BSCD_P_DONE_LABEL:
2543
2544	BDBG_LEAVE(BSCD_Channel_ReceiveATR);
2545	/* BDBG_MSG(("Leave BSCD_Channel_ReceiveATR = 0x%x\n", errCode)); */
2546	return( errCode );
2547	}
2548
2549	BERR_Code BSCD_Channel_ConfigTimer(
2550	BSCD_ChannelHandle in_channelHandle,
2551	BSCD_Timer *inp_timer,
2552	BSCD_TimerValue *inp_unCount
2553
2554	)
2555	{
2556	BERR_Code errCode = BERR_SUCCESS;
2557	uint32_t ulTimerCmdVal, ulTimerCmpVal;
2558
2559	BDBG_ENTER(BSCD_Channel_ConfigTimer);
2560	BDBG_ASSERT( in_channelHandle );
2561
2562	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
2563	(in_channelHandle->ulMagicNumber != BSCD_P_CHANNEL_HANDLE_MAGIC_NUMBER ) );
2564
2565	if (inp_timer->eTimerType == BSCD_TimerType_eGPTimer) {
2566
2567	/* Always disbale timer first before we change timer_cmd */
2568	ulTimerCmdVal = BREG_Read32(
2569	in_channelHandle->moduleHandle->regHandle,
2570	(in_channelHandle->ulRegStartAddr + BSCD_P_TIMER_CMD));
2571
2572	ulTimerCmdVal &= (~BCHP_SCA_SC_TIMER_CMD_timer_en_MASK);
2573
2574	BREG_Write32(
2575	in_channelHandle->moduleHandle->regHandle,
2576	(in_channelHandle->ulRegStartAddr + BSCD_P_TIMER_CMD),
2577	ulTimerCmdVal);
2578
2579	BKNI_EnterCriticalSection();
2580	in_channelHandle->ulIntrStatus1 &= ~BCHP_SCA_SC_INTR_STAT_1_timer_intr_MASK;
2581	BKNI_LeaveCriticalSection();
2582
2583	/* Set timer_cmp registers */
2584
2585	ulTimerCmpVal = ((inp_unCount->ulValue & 0xFF00) >> 8);
2586	BREG_Write32(
2587	in_channelHandle->moduleHandle->regHandle,
2588	(in_channelHandle->ulRegStartAddr + BSCD_P_TIMER_CMP_2),
2589	ulTimerCmpVal);
2590
2591	ulTimerCmpVal = inp_unCount->ulValue & 0x00FF;
2592	BREG_Write32(
2593	in_channelHandle->moduleHandle->regHandle,
2594	(in_channelHandle->ulRegStartAddr + BSCD_P_TIMER_CMP_1),
2595	ulTimerCmpVal);
2596
2597
2598	/* Set the timer unit and mode */
2599	if ( inp_unCount->unit == BSCD_TimerUnit_eCLK) {
2600	ulTimerCmdVal \|= BCHP_SCA_SC_TIMER_CMD_timer_src_MASK;
2601	}
2602	else if (inp_unCount->unit == BSCD_TimerUnit_eETU) {
2603	ulTimerCmdVal &= (~BCHP_SCA_SC_TIMER_CMD_timer_src_MASK);
2604	}
2605	else {
2606	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED, true);
2607	}
2608
2609	if (inp_timer->timerMode.eGPTimerMode == BSCD_GPTimerMode_eNEXT_START_BIT ) {
2610	ulTimerCmdVal \|= BCHP_SCA_SC_TIMER_CMD_timer_mode_MASK;
2611	}
2612	else { /* BSCD_GPTimerMode_eIMMEDIATE */
2613	ulTimerCmdVal &= (~BCHP_SCA_SC_TIMER_CMD_timer_mode_MASK);
2614	}
2615
2616	/* Check if we need to invoke an interrupt when the time expires */
2617	if (inp_timer->bIsTimerInterruptEnable == true) { /* inp_timer->bIsTimerInterruptEnable == true && BSCD_TimerType_eGPTimer */
2618	BSCD_P_CHECK_ERR_CODE_FUNC(errCode,
2619	BSCD_Channel_EnableIntrCallback_isr (
2620	in_channelHandle, BSCD_IntType_eTimerInt,
2621	BSCD_Channel_P_TimerCB_isr));
2622	}
2623	else { /* inp_timer->bIsTimerInterruptEnable == false && BSCD_TimerType_eGPTimer */
2624	BSCD_P_CHECK_ERR_CODE_FUNC(errCode,
2625	BSCD_Channel_DisableIntrCallback_isr (
2626	in_channelHandle, BSCD_IntType_eTimerInt));
2627	}
2628
2629	if (inp_timer->bIsTimerEnable == true) {
2630	ulTimerCmdVal \|= BCHP_SCA_SC_TIMER_CMD_timer_en_MASK;
2631	} /* inp_timer->bIsTimerEnable == true && BSCD_TimerType_eGPTimer */
2632
2633	else { /* inp_timer->bIsTimerEnable == false && BSCD_TimerType_eGPTimer */
2634	ulTimerCmdVal &= ~BCHP_SCA_SC_TIMER_CMD_timer_en_MASK;
2635
2636	}
2637
2638	} /* if (inp_timer->eTimerType == BSCD_TimerType_eGPTimer) */
2639
2640	else { /* BSCD_TimerType_eWaitTimer */
2641
2642	/* Always disable timer first before we change timer_cmd */
2643	ulTimerCmdVal = BREG_Read32(
2644	in_channelHandle->moduleHandle->regHandle,
2645	(in_channelHandle->ulRegStartAddr + BSCD_P_TIMER_CMD));
2646
2647	ulTimerCmdVal &= (~BCHP_SCA_SC_TIMER_CMD_wait_en_MASK);
2648
2649	BREG_Write32(
2650	in_channelHandle->moduleHandle->regHandle,
2651	(in_channelHandle->ulRegStartAddr + BSCD_P_TIMER_CMD),
2652	ulTimerCmdVal);
2653
2654	BKNI_EnterCriticalSection();
2655	in_channelHandle->ulIntrStatus2 &= ~BCHP_SCA_SC_INTR_STAT_2_wait_intr_MASK;
2656	BKNI_LeaveCriticalSection();
2657
2658	/* Set sc_wait registers */
2659	ulTimerCmpVal = ((inp_unCount->ulValue & 0xFF0000) >> 16);
2660	BREG_Write32(
2661	in_channelHandle->moduleHandle->regHandle,
2662	(in_channelHandle->ulRegStartAddr + BSCD_P_WAIT_3),
2663	ulTimerCmpVal);
2664
2665	ulTimerCmpVal = ((inp_unCount->ulValue & 0x00FF00) >> 8);
2666	BREG_Write32(
2667	in_channelHandle->moduleHandle->regHandle,
2668	(in_channelHandle->ulRegStartAddr + BSCD_P_WAIT_2),
2669	ulTimerCmpVal);
2670
2671	ulTimerCmpVal = (inp_unCount->ulValue & 0x0000FF);
2672	BREG_Write32(
2673	in_channelHandle->moduleHandle->regHandle,
2674	(in_channelHandle->ulRegStartAddr + BSCD_P_WAIT_1),
2675	ulTimerCmpVal);
2676
2677	/* Check if we need to invoke an interrupt when the time expires */
2678	if (inp_timer->bIsTimerInterruptEnable == true) {
2679	BSCD_P_CHECK_ERR_CODE_FUNC(errCode,
2680	BSCD_Channel_EnableIntrCallback_isr (
2681	in_channelHandle, BSCD_IntType_eWaitInt,
2682	BSCD_Channel_P_WaitCB_isr));
2683	}
2684	else {
2685	BSCD_P_CHECK_ERR_CODE_FUNC(errCode,
2686	BSCD_Channel_DisableIntrCallback_isr (
2687	in_channelHandle, BSCD_IntType_eWaitInt));
2688	}
2689
2690	if (inp_timer->bIsTimerEnable == true) {
2691
2692	/* Set the wait mode */
2693	if (inp_timer->eTimerType == BSCD_TimerType_eWaitTimer) {
2694	if (inp_timer->timerMode.eWaitTimerMode == BSCD_WaitTimerMode_eBlockWaitTime) {
2695	ulTimerCmdVal \|= BCHP_SCA_SC_TIMER_CMD_wait_mode_MASK;
2696	}
2697	else { /* BSCD_WaitTimerMode_eWorkWaitTime */
2698	ulTimerCmdVal &= ~ BCHP_SCA_SC_TIMER_CMD_wait_mode_MASK;
2699	}
2700
2701	ulTimerCmdVal \|= BCHP_SCA_SC_TIMER_CMD_wait_en_MASK;
2702	}
2703
2704	}/* BSCD_TimerType_eWaitTimer && inp_timer->bIsTimerEnable == true */
2705
2706	else { /* inp_timer->bIsTimerEnable == false && BSCD_TimerType_eWaitTimer */
2707	ulTimerCmdVal &= ~BCHP_SCA_SC_TIMER_CMD_wait_en_MASK;
2708	}
2709
2710
2711	} /* else BSCD_TimerType_eWaitTimer */
2712	BREG_Write32(
2713	in_channelHandle->moduleHandle->regHandle,
2714	(in_channelHandle->ulRegStartAddr + BSCD_P_TIMER_CMD),
2715	ulTimerCmdVal);
2716
2717	BDBG_MSG (("*** BSCD_Channel_ConfigTimer: Timer cmd = 0x%08x\n", ulTimerCmdVal));
2718
2719	BSCD_P_DONE_LABEL:
2720
2721	BDBG_LEAVE(BSCD_Channel_ConfigTimer);
2722	return( errCode );
2723	}
2724
2725	BERR_Code BSCD_Channel_EnableDisableTimer_isr(
2726	BSCD_ChannelHandle in_channelHandle,
2727	BSCD_Timer *inp_timer
2728	)
2729	{
2730	BERR_Code errCode = BERR_SUCCESS;
2731	uint32_t ulTimerCmdVal;
2732
2733	BDBG_ENTER(BSCD_Channel_EnableDisableTimer_isr);
2734	BDBG_ASSERT( in_channelHandle );
2735
2736	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED,
2737	(in_channelHandle->ulMagicNumber != BSCD_P_CHANNEL_HANDLE_MAGIC_NUMBER ) );
2738
2739
2740	ulTimerCmdVal = BREG_Read32(
2741	in_channelHandle->moduleHandle->regHandle,
2742	(in_channelHandle->ulRegStartAddr + BSCD_P_TIMER_CMD));
2743
2744	if (inp_timer->eTimerType == BSCD_TimerType_eGPTimer) {
2745
2746	in_channelHandle->ulIntrStatus1 &= ~BCHP_SCA_SC_INTR_STAT_1_timer_intr_MASK;
2747
2748	/* Check if we need to invoke an interrupt when the time expires */
2749	if (inp_timer->bIsTimerInterruptEnable == true) { /* inp_timer->bIsTimerInterruptEnable == true && BSCD_TimerType_eGPTimer */
2750	BSCD_P_CHECK_ERR_CODE_FUNC(errCode,
2751	BSCD_Channel_EnableIntrCallback_isr (
2752	in_channelHandle, BSCD_IntType_eTimerInt,
2753	BSCD_Channel_P_TimerCB_isr));
2754	}
2755	else { /* inp_timer->bIsTimerInterruptEnable == false && BSCD_TimerType_eGPTimer */
2756	BSCD_P_CHECK_ERR_CODE_FUNC(errCode,
2757	BSCD_Channel_DisableIntrCallback_isr (
2758	in_channelHandle, BSCD_IntType_eTimerInt));
2759	}
2760
2761	if (inp_timer->bIsTimerEnable == true) {
2762	ulTimerCmdVal \|= BCHP_SCA_SC_TIMER_CMD_timer_en_MASK;
2763	} /* inp_timer->bIsTimerEnable == true && BSCD_TimerType_eGPTimer */
2764
2765	else { /* inp_timer->bIsTimerEnable == false && BSCD_TimerType_eGPTimer */
2766	ulTimerCmdVal &= ~BCHP_SCA_SC_TIMER_CMD_timer_en_MASK;
2767	}
2768
2769
2770	} /* if (inp_timer->eTimerType == BSCD_TimerType_eGPTimer) */
2771
2772	else { /* BSCD_TimerType_eWaitTimer */
2773
2774	in_channelHandle->ulIntrStatus2 &= ~BCHP_SCA_SC_INTR_STAT_2_wait_intr_MASK;
2775
2776	/* Check if we need to invoke an interrupt when the time expires */
2777	if (inp_timer->bIsTimerInterruptEnable == true) {
2778	BSCD_P_CHECK_ERR_CODE_FUNC(errCode,
2779	BSCD_Channel_EnableIntrCallback_isr (
2780	in_channelHandle, BSCD_IntType_eWaitInt,
2781	BSCD_Channel_P_WaitCB_isr));
2782	}
2783	else {
2784	BSCD_P_CHECK_ERR_CODE_FUNC(errCode,
2785	BSCD_Channel_DisableIntrCallback_isr (
2786	in_channelHandle, BSCD_IntType_eWaitInt));
2787	}
2788
2789	if (inp_timer->bIsTimerEnable == true) {
2790
2791	/* Set the wait mode */
2792	if (inp_timer->eTimerType == BSCD_TimerType_eWaitTimer) {
2793	if (inp_timer->timerMode.eWaitTimerMode == BSCD_WaitTimerMode_eBlockWaitTime) {
2794	ulTimerCmdVal \|= BCHP_SCA_SC_TIMER_CMD_wait_mode_MASK;
2795	}
2796	else { /* BSCD_WaitTimerMode_eWorkWaitTime */
2797	ulTimerCmdVal &= ~ BCHP_SCA_SC_TIMER_CMD_wait_mode_MASK;
2798	}
2799
2800	ulTimerCmdVal \|= BCHP_SCA_SC_TIMER_CMD_wait_en_MASK;
2801	}
2802
2803	}/* BSCD_TimerType_eWaitTimer && inp_timer->bIsTimerEnable == true */
2804
2805	else { /* inp_timer->bIsTimerEnable == false && BSCD_TimerType_eWaitTimer */
2806	ulTimerCmdVal &= ~BCHP_SCA_SC_TIMER_CMD_wait_en_MASK;
2807	}
2808
2809
2810	} /* else BSCD_TimerType_eWaitTimer */
2811
2812	BREG_Write32(
2813	in_channelHandle->moduleHandle->regHandle,
2814	(in_channelHandle->ulRegStartAddr + BSCD_P_TIMER_CMD),
2815	ulTimerCmdVal);
2816
2817	BDBG_MSG (("*** BSCD_Channel_EnableDisableTimer_isr: Timer cmd = 0x%08x\n", ulTimerCmdVal));
2818
2819	BSCD_P_DONE_LABEL:
2820
2821	BDBG_LEAVE(BSCD_Channel_EnableDisableTimer_isr);
2822	return( errCode );
2823	}
2824
2825	BERR_Code BSCD_Channel_EnableIntrCallback_isr(
2826	BSCD_ChannelHandle in_channelHandle,
2827	BSCD_IntrType in_eIntType,
2828	BSCD_IsrCallbackFunc in_callback
2829	)
2830	{
2831	uint32_t ulVal;
2832	unsigned int unReg = BSCD_P_INTR_EN_1, i;
2833	BERR_Code errCode = BERR_SUCCESS;
2834
2835	if ( (in_eIntType == BSCD_IntType_eTParityInt) \|\|
2836	(in_eIntType == BSCD_IntType_eTimerInt) \|\|
2837	(in_eIntType == BSCD_IntType_eCardInsertInt) \|\|
2838	(in_eIntType == BSCD_IntType_eCardRemoveInt) \|\|
2839	(in_eIntType == BSCD_IntType_eBGTInt) \|\|
2840	(in_eIntType == BSCD_IntType_eTDoneInt) \|\|
2841	(in_eIntType == BSCD_IntType_eRetryInt) \|\|
2842	(in_eIntType == BSCD_IntType_eTEmptyInt) \|\|
2843	(in_eIntType == BSCD_IntType_eEvent1Int)) {
2844	unReg = BSCD_P_INTR_EN_1;
2845	/* BDBG_MSG(("BSCD_P_INTR_EN_1: ")); */
2846	}
2847	else if ( (in_eIntType == BSCD_IntType_eRParityInt) \|\|
2848	(in_eIntType == BSCD_IntType_eATRInt) \|\|
2849	(in_eIntType == BSCD_IntType_eCWTInt) \|\|
2850	(in_eIntType == BSCD_IntType_eRLenInt) \|\|
2851	(in_eIntType == BSCD_IntType_eWaitInt) \|\|
2852	(in_eIntType == BSCD_IntType_eRcvInt) \|\|
2853	(in_eIntType == BSCD_IntType_eRReadyInt) \|\|
2854	(in_eIntType == BSCD_IntType_eEvent2Int)) {
2855	unReg = BSCD_P_INTR_EN_2;
2856	/* BDBG_MSG(("BSCD_P_INTR_EN_2: ")); */
2857	}
2858	else if (in_eIntType == BSCD_IntType_eEDCInt) {
2859	unReg = BSCD_P_PROTO_CMD;
2860	}
2861	else {
2862	BDBG_ERR(("Interrupt not supported, in_eIntType = %d\n", in_eIntType));
2863	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED, true);
2864	}
2865
2866	ulVal = BREG_Read32(
2867	in_channelHandle->moduleHandle->regHandle,
2868	(in_channelHandle->ulRegStartAddr + unReg));
2869
2870	/* BDBG_MSG(("ulVal = 0x%x", ulVal)); */
2871
2872	switch (in_eIntType) {
2873
2874	case BSCD_IntType_eTParityInt:
2875	for (i=0; i< BSCD_MAX_NUM_CALLBACK_FUNC; i++) {
2876	if (in_channelHandle->callBack.tParityIsrCBFunc[i] == NULL) {
2877	in_channelHandle->callBack.tParityIsrCBFunc[i] = in_callback;
2878	break;
2879	}
2880	else if ((in_channelHandle->callBack.tParityIsrCBFunc[i] != NULL) &&
2881	(in_channelHandle->callBack.tParityIsrCBFunc[i] == in_callback) ) {
2882	break;
2883	}
2884	}
2885	ulVal \|= BCHP_SCA_SC_INTR_STAT_1_tpar_intr_MASK;
2886	break;
2887
2888	case BSCD_IntType_eTimerInt:
2889	for (i=0; i< BSCD_MAX_NUM_CALLBACK_FUNC; i++) {
2890	if (in_channelHandle->callBack.timerIsrCBFunc[i] == NULL) {
2891	in_channelHandle->callBack.timerIsrCBFunc[i] = in_callback;
2892	break;
2893	}
2894	else if ((in_channelHandle->callBack.timerIsrCBFunc[i] != NULL) &&
2895	(in_channelHandle->callBack.timerIsrCBFunc[i] == in_callback) ) {
2896	break;
2897	}
2898	}
2899	ulVal \|= BCHP_SCA_SC_INTR_STAT_1_timer_intr_MASK;
2900	break;
2901
2902	case BSCD_IntType_eCardInsertInt:
2903	for (i=0; i< BSCD_MAX_NUM_CALLBACK_FUNC; i++) {
2904	if (in_channelHandle->callBack.cardInsertIsrCBFunc[i] == NULL) {
2905	in_channelHandle->callBack.cardInsertIsrCBFunc[i] = in_callback;
2906	BDBG_MSG(("new BSCD_IntType_eCardInsertInt callback "));
2907	break;
2908	}
2909	else if ((in_channelHandle->callBack.cardInsertIsrCBFunc[i] != NULL) &&
2910	(in_channelHandle->callBack.cardInsertIsrCBFunc[i] == in_callback) ) {
2911	BDBG_MSG(("BSCD_IntType_eCardInsertInt same callback "));
2912	break;
2913	}
2914	}
2915	ulVal \|= BCHP_SCA_SC_INTR_STAT_1_pres_intr_MASK;
2916	break;
2917
2918	case BSCD_IntType_eCardRemoveInt:
2919	for (i=0; i< BSCD_MAX_NUM_CALLBACK_FUNC; i++) {
2920	if (in_channelHandle->callBack.cardRemoveIsrCBFunc[i] == NULL) {
2921	in_channelHandle->callBack.cardRemoveIsrCBFunc[i] = in_callback;
2922	BDBG_MSG(("new BSCD_IntType_eCardRemoveInt callback "));
2923	break;
2924	}
2925	else if ((in_channelHandle->callBack.cardRemoveIsrCBFunc[i] != NULL) &&
2926	(in_channelHandle->callBack.cardRemoveIsrCBFunc[i] == in_callback) ) {
2927	BDBG_MSG(("BSCD_IntType_eCardRemoveInt same callback "));
2928	break;
2929	}
2930	}
2931	ulVal \|= BCHP_SCA_SC_INTR_STAT_1_pres_intr_MASK;
2932	break;
2933
2934	case BSCD_IntType_eBGTInt:
2935	for (i=0; i< BSCD_MAX_NUM_CALLBACK_FUNC; i++) {
2936	if (in_channelHandle->callBack.bgtIsrCBFunc[i] == NULL) {
2937	in_channelHandle->callBack.bgtIsrCBFunc[i] = in_callback;
2938	break;
2939	}
2940	else if ((in_channelHandle->callBack.bgtIsrCBFunc[i] != NULL) &&
2941	(in_channelHandle->callBack.bgtIsrCBFunc[i] == in_callback) ) {
2942	break;
2943	}
2944	}
2945	ulVal \|= BCHP_SCA_SC_INTR_STAT_1_bgt_intr_MASK;
2946	break;
2947
2948	case BSCD_IntType_eTDoneInt:
2949	for (i=0; i< BSCD_MAX_NUM_CALLBACK_FUNC; i++) {
2950	if (in_channelHandle->callBack.tDoneIsrCBFunc[i] == NULL) {
2951	in_channelHandle->callBack.tDoneIsrCBFunc[i] = in_callback;
2952	break;
2953	}
2954	else if ((in_channelHandle->callBack.tDoneIsrCBFunc[i] != NULL) &&
2955	(in_channelHandle->callBack.tDoneIsrCBFunc[i] == in_callback) ) {
2956	break;
2957	}
2958	}
2959	ulVal \|= BCHP_SCA_SC_INTR_STAT_1_tdone_intr_MASK;
2960	break;
2961
2962	case BSCD_IntType_eRetryInt:
2963	for (i=0; i< BSCD_MAX_NUM_CALLBACK_FUNC; i++) {
2964	if (in_channelHandle->callBack.retryIsrCBFunc[i] == NULL) {
2965	in_channelHandle->callBack.retryIsrCBFunc[i] = in_callback;
2966	break;
2967	}
2968	else if ((in_channelHandle->callBack.retryIsrCBFunc[i] != NULL) &&
2969	(in_channelHandle->callBack.retryIsrCBFunc[i] == in_callback) ) {
2970	break;
2971	}
2972	}
2973	ulVal \|= BCHP_SCA_SC_INTR_STAT_1_retry_intr_MASK;
2974	break;
2975
2976	case BSCD_IntType_eTEmptyInt:
2977	for (i=0; i< BSCD_MAX_NUM_CALLBACK_FUNC; i++) {
2978	if (in_channelHandle->callBack.tEmptyIsrCBFunc[i] == NULL) {
2979	in_channelHandle->callBack.tEmptyIsrCBFunc[i] = in_callback;
2980	break;
2981	}
2982	else if ((in_channelHandle->callBack.tEmptyIsrCBFunc[i] != NULL) &&
2983	(in_channelHandle->callBack.tEmptyIsrCBFunc[i] == in_callback) ) {
2984	break;
2985	}
2986	}
2987	ulVal \|= BCHP_SCA_SC_INTR_STAT_1_tempty_intr_MASK;
2988	break;
2989
2990	case BSCD_IntType_eRParityInt:
2991	for (i=0; i< BSCD_MAX_NUM_CALLBACK_FUNC; i++) {
2992	if (in_channelHandle->callBack.rParityIsrCBFunc[i] == NULL) {
2993	in_channelHandle->callBack.rParityIsrCBFunc[i] = in_callback;
2994	break;
2995	}
2996	else if ((in_channelHandle->callBack.rParityIsrCBFunc[i] != NULL) &&
2997	(in_channelHandle->callBack.rParityIsrCBFunc[i] == in_callback) ) {
2998	break;
2999	}
3000	}
3001	ulVal \|= BCHP_SCA_SC_INTR_STAT_2_rpar_intr_MASK;
3002	break;
3003
3004	case BSCD_IntType_eATRInt:
3005	for (i=0; i< BSCD_MAX_NUM_CALLBACK_FUNC; i++) {
3006	if (in_channelHandle->callBack.atrIsrCBFunc[i] == NULL) {
3007	in_channelHandle->callBack.atrIsrCBFunc[i] = in_callback;
3008	break;
3009	}
3010	else if ((in_channelHandle->callBack.atrIsrCBFunc[i] != NULL) &&
3011	(in_channelHandle->callBack.atrIsrCBFunc[i] == in_callback) ) {
3012	break;
3013	}
3014	}
3015	ulVal \|= BCHP_SCA_SC_INTR_STAT_2_atrs_intr_MASK;
3016	break;
3017
3018	case BSCD_IntType_eCWTInt:
3019	for (i=0; i< BSCD_MAX_NUM_CALLBACK_FUNC; i++) {
3020	if (in_channelHandle->callBack.cwtIsrCBFunc[i] == NULL) {
3021	in_channelHandle->callBack.cwtIsrCBFunc[i] = in_callback;
3022	break;
3023	}
3024	else if ((in_channelHandle->callBack.cwtIsrCBFunc[i] != NULL) &&
3025	(in_channelHandle->callBack.cwtIsrCBFunc[i] == in_callback) ) {
3026	break;
3027	}
3028	}
3029	ulVal \|= BCHP_SCA_SC_INTR_STAT_2_cwt_intr_MASK;
3030	break;
3031
3032	case BSCD_IntType_eRLenInt:
3033	for (i=0; i< BSCD_MAX_NUM_CALLBACK_FUNC; i++) {
3034	if (in_channelHandle->callBack.rLenIsrCBFunc[i] == NULL) {
3035	in_channelHandle->callBack.rLenIsrCBFunc[i] = in_callback;
3036	break;
3037	}
3038	else if ((in_channelHandle->callBack.rLenIsrCBFunc[i] != NULL) &&
3039	(in_channelHandle->callBack.rLenIsrCBFunc[i] == in_callback) ) {
3040	break;
3041	}
3042	}
3043	ulVal \|= BCHP_SCA_SC_INTR_STAT_2_rlen_intr_MASK;
3044	break;
3045
3046	case BSCD_IntType_eWaitInt:
3047	for (i=0; i< BSCD_MAX_NUM_CALLBACK_FUNC; i++) {
3048	if (in_channelHandle->callBack.waitIsrCBFunc[i] == NULL) {
3049	in_channelHandle->callBack.waitIsrCBFunc[i] = in_callback;
3050	break;
3051	}
3052	else if ((in_channelHandle->callBack.waitIsrCBFunc[i] != NULL) &&
3053	(in_channelHandle->callBack.waitIsrCBFunc[i] == in_callback) ) {
3054	break;
3055	}
3056	}
3057	ulVal \|= BCHP_SCA_SC_INTR_STAT_2_wait_intr_MASK;
3058	break;
3059
3060	case BSCD_IntType_eRcvInt:
3061	for (i=0; i< BSCD_MAX_NUM_CALLBACK_FUNC; i++) {
3062	if (in_channelHandle->callBack.rcvIsrCBFunc[i] == NULL) {
3063	in_channelHandle->callBack.rcvIsrCBFunc[i] = in_callback;
3064	break;
3065	}
3066	else if ((in_channelHandle->callBack.rcvIsrCBFunc[i] != NULL) &&
3067	(in_channelHandle->callBack.rcvIsrCBFunc[i] == in_callback) ) {
3068	break;
3069	}
3070	}
3071	ulVal \|= BCHP_SCA_SC_INTR_STAT_2_rcv_intr_MASK;
3072	break;
3073
3074	case BSCD_IntType_eRReadyInt:
3075	for (i=0; i< BSCD_MAX_NUM_CALLBACK_FUNC; i++) {
3076	if (in_channelHandle->callBack.rReadyIsrCBFunc[i] == NULL) {
3077	in_channelHandle->callBack.rReadyIsrCBFunc[i] = in_callback;
3078	break;
3079	}
3080	else if ((in_channelHandle->callBack.rReadyIsrCBFunc[i] != NULL) &&
3081	(in_channelHandle->callBack.rReadyIsrCBFunc[i] == in_callback) ) {
3082	break;
3083	}
3084	}
3085	ulVal \|= BCHP_SCA_SC_INTR_STAT_2_rready_intr_MASK;
3086	break;
3087
3088	case BSCD_IntType_eEDCInt:
3089	if (in_channelHandle->currentChannelSettings.eProtocolType == BSCD_AsyncProtocolType_e0 ) {
3090	for (i=0; i< BSCD_MAX_NUM_CALLBACK_FUNC; i++) {
3091	if (in_channelHandle->callBack.edcIsrCBFunc[i] == NULL) {
3092	in_channelHandle->callBack.edcIsrCBFunc[i] = in_callback;
3093	break;
3094	}
3095	else if ((in_channelHandle->callBack.edcIsrCBFunc[i] != NULL) &&
3096	(in_channelHandle->callBack.edcIsrCBFunc[i] == in_callback) ) {
3097	break;
3098	}
3099	}
3100	ulVal \|= BCHP_SCA_SC_PROTO_CMD_edc_en_MASK;
3101	}
3102	break;
3103
3104	case BSCD_IntType_eEvent1Int:
3105	for (i=0; i< BSCD_MAX_NUM_CALLBACK_FUNC; i++) {
3106	if (in_channelHandle->callBack.event1IsrCBFunc[i] == NULL) {
3107	in_channelHandle->callBack.event1IsrCBFunc[i] = in_callback;
3108	break;
3109	}
3110	else if ((in_channelHandle->callBack.event1IsrCBFunc[i] != NULL) &&
3111	(in_channelHandle->callBack.event1IsrCBFunc[i] == in_callback) ) {
3112	break;
3113	}
3114	}
3115	ulVal \|= BCHP_SCA_SC_INTR_STAT_1_event1_intr_MASK;
3116	break;
3117
3118	case BSCD_IntType_eEvent2Int:
3119	for (i=0; i< BSCD_MAX_NUM_CALLBACK_FUNC; i++) {
3120	if (in_channelHandle->callBack.event2IsrCBFunc[i] == NULL) {
3121	in_channelHandle->callBack.event2IsrCBFunc[i] = in_callback;
3122	break;
3123	}
3124	else if ((in_channelHandle->callBack.event2IsrCBFunc[i] != NULL) &&
3125	(in_channelHandle->callBack.event2IsrCBFunc[i] == in_callback) ) {
3126	break;
3127	}
3128	}
3129	ulVal \|= BCHP_SCA_SC_INTR_STAT_2_event2_intr_MASK;
3130	break;
3131
3132	default:
3133	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED, true);
3134	}
3135
3136	BREG_Write32(
3137	in_channelHandle->moduleHandle->regHandle,
3138	(in_channelHandle->ulRegStartAddr + unReg),
3139	ulVal);
3140
3141
3142	/BDBG_MSG((", final ulVal = 0x%x\n ", ulVal)); /
3143
3144	BSCD_P_DONE_LABEL:
3145
3146	BDBG_LEAVE(BSCD_Channel_EnableIntrCallback_isr);
3147	return( errCode );
3148
3149	}
3150
3151	BERR_Code BSCD_Channel_DisableIntrCallback_isr(
3152	BSCD_ChannelHandle in_channelHandle,
3153	BSCD_IntrType in_eIntType
3154	)
3155	{
3156	uint32_t ulVal;
3157	unsigned int unReg = BSCD_P_INTR_EN_1;
3158	BERR_Code errCode = BERR_SUCCESS;
3159
3160	if ( (in_eIntType == BSCD_IntType_eTParityInt) \|\|
3161	(in_eIntType == BSCD_IntType_eTimerInt) \|\|
3162	(in_eIntType == BSCD_IntType_eCardInsertInt) \|\|
3163	(in_eIntType == BSCD_IntType_eCardRemoveInt) \|\|
3164	(in_eIntType == BSCD_IntType_eBGTInt) \|\|
3165	(in_eIntType == BSCD_IntType_eTDoneInt) \|\|
3166	(in_eIntType == BSCD_IntType_eRetryInt) \|\|
3167	(in_eIntType == BSCD_IntType_eTEmptyInt) \|\|
3168	(in_eIntType == BSCD_IntType_eEvent1Int)) {
3169	unReg = BSCD_P_INTR_EN_1;
3170	/* BDBG_MSG(("BSCD_P_INTR_EN_1: ")); */
3171	}
3172	else if ( (in_eIntType == BSCD_IntType_eRParityInt) \|\|
3173	(in_eIntType == BSCD_IntType_eATRInt) \|\|
3174	(in_eIntType == BSCD_IntType_eCWTInt) \|\|
3175	(in_eIntType == BSCD_IntType_eRLenInt) \|\|
3176	(in_eIntType == BSCD_IntType_eWaitInt) \|\|
3177	(in_eIntType == BSCD_IntType_eRcvInt) \|\|
3178	(in_eIntType == BSCD_IntType_eRReadyInt) \|\|
3179	(in_eIntType == BSCD_IntType_eEvent2Int)) {
3180	unReg = BSCD_P_INTR_EN_2;
3181	/* BDBG_MSG(("BSCD_P_INTR_EN_2: ")); */
3182	}
3183	else if (in_eIntType == BSCD_IntType_eEDCInt) {
3184	unReg = BSCD_P_PROTO_CMD;
3185	}
3186	else {
3187	BDBG_MSG(("Interrupt not supported\n"));
3188	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED, true);
3189	}
3190
3191	ulVal = BREG_Read32(
3192	in_channelHandle->moduleHandle->regHandle,
3193	(in_channelHandle->ulRegStartAddr + unReg));
3194
3195	/* BDBG_MSG(("ulVal = 0x%x", ulVal)); */
3196
3197	switch (in_eIntType) {
3198
3199
3200	case BSCD_IntType_eTParityInt:
3201	ulVal &= ~BCHP_SCA_SC_INTR_STAT_1_tpar_intr_MASK;
3202	break;
3203
3204	case BSCD_IntType_eTimerInt:
3205	ulVal &= ~BCHP_SCA_SC_INTR_STAT_1_timer_intr_MASK;
3206	break;
3207
3208	case BSCD_IntType_eCardInsertInt:
3209	ulVal &= ~BCHP_SCA_SC_INTR_STAT_1_pres_intr_MASK;
3210	break;
3211
3212	case BSCD_IntType_eCardRemoveInt:
3213	ulVal &= ~BCHP_SCA_SC_INTR_STAT_1_pres_intr_MASK;
3214	break;
3215
3216	case BSCD_IntType_eBGTInt:
3217	ulVal &= ~BCHP_SCA_SC_INTR_STAT_1_bgt_intr_MASK;
3218	break;
3219
3220	case BSCD_IntType_eTDoneInt:
3221	ulVal &= ~BCHP_SCA_SC_INTR_STAT_1_tdone_intr_MASK;
3222	break;
3223
3224	case BSCD_IntType_eRetryInt:
3225	ulVal &= ~BCHP_SCA_SC_INTR_STAT_1_retry_intr_MASK;
3226	break;
3227
3228	case BSCD_IntType_eTEmptyInt:
3229	ulVal &= ~BCHP_SCA_SC_INTR_STAT_1_tempty_intr_MASK;
3230	break;
3231
3232	case BSCD_IntType_eRParityInt:
3233	ulVal &= ~BCHP_SCA_SC_INTR_STAT_2_rpar_intr_MASK;
3234	break;
3235
3236	case BSCD_IntType_eATRInt:
3237	ulVal &= ~BCHP_SCA_SC_INTR_STAT_2_atrs_intr_MASK;
3238	break;
3239
3240	case BSCD_IntType_eCWTInt:
3241	ulVal &= ~BCHP_SCA_SC_INTR_STAT_2_cwt_intr_MASK;
3242	break;
3243
3244	case BSCD_IntType_eRLenInt:
3245	ulVal &= ~BCHP_SCA_SC_INTR_STAT_2_rlen_intr_MASK;
3246	break;
3247
3248	case BSCD_IntType_eWaitInt:
3249	ulVal &= ~BCHP_SCA_SC_INTR_STAT_2_wait_intr_MASK;
3250	break;
3251
3252	case BSCD_IntType_eRcvInt:
3253	ulVal &= ~BCHP_SCA_SC_INTR_STAT_2_rcv_intr_MASK;
3254	break;
3255
3256	case BSCD_IntType_eRReadyInt:
3257	ulVal &= ~BCHP_SCA_SC_INTR_STAT_2_rready_intr_MASK;
3258	break;
3259
3260	case BSCD_IntType_eEDCInt:
3261	ulVal &= ~BCHP_SCA_SC_PROTO_CMD_edc_en_MASK;
3262	break;
3263
3264	case BSCD_IntType_eEvent1Int:
3265	ulVal &= ~BCHP_SCA_SC_INTR_STAT_1_event1_intr_MASK;
3266	break;
3267
3268	case BSCD_IntType_eEvent2Int:
3269	ulVal &= ~BCHP_SCA_SC_INTR_STAT_2_event2_intr_MASK;
3270	break;
3271
3272	default:
3273	BSCD_P_CHECK_ERR_CODE_CONDITION( errCode, BSCD_STATUS_FAILED, true);
3274	}
3275
3276	BREG_Write32(
3277	in_channelHandle->moduleHandle->regHandle,
3278	(in_channelHandle->ulRegStartAddr + unReg),
3279	ulVal);
3280
3281	/* BDBG_MSG((", final ulVal = 0x%x\n ", ulVal)); */
3282	BSCD_P_DONE_LABEL:
3283
3284	BDBG_LEAVE(BSCD_Channel_DisableIntrCallback_isr);
3285	return( errCode );
3286	}
3287
3288	BERR_Code BSCD_Channel_EnableInterrupts(
3289	BSCD_ChannelHandle in_channelHandle
3290	)
3291	{
3292	BERR_Code errCode = BERR_SUCCESS;
3293
3294	BDBG_ENTER(BSCD_Channel_EnableInterrupts);
3295	BDBG_ASSERT( in_channelHandle );
3296
3297	BKNI_EnterCriticalSection();
3298	if ( (errCode = BSCD_Channel_P_EnableInterrupts_isr(in_channelHandle)) != BERR_SUCCESS) {
3299	errCode = BERR_TRACE(errCode);
3300	goto BSCD_P_DONE_LABEL;
3301	}
3302	BKNI_LeaveCriticalSection();
3303
3304	BSCD_P_DONE_LABEL:
3305
3306	BDBG_LEAVE(BSCD_Channel_EnableInterrupts);
3307	return( errCode );
3308	}
3309
3310	BERR_Code BSCD_Channel_ResetBlockWaitTimer(
3311	BSCD_ChannelHandle in_channelHandle
3312	)
3313	{
3314	BERR_Code errCode = BERR_SUCCESS;
3315	BSCD_Timer timer = {BSCD_TimerType_eWaitTimer, {BSCD_GPTimerMode_eIMMEDIATE},
3316	false, true};
3317	BSCD_TimerValue timeValue= {BSCD_DEFAULT_BLOCK_WAITING_TIME, BSCD_TimerUnit_eETU};
3318
3319	BDBG_ENTER(BSCD_Channel_ResetBlockWaitTimer);
3320	BDBG_ASSERT( in_channelHandle );
3321
3322	/* Need this for MetroWerks */
3323	timer.eTimerType = BSCD_TimerType_eWaitTimer;
3324	timer.timerMode.eWaitTimerMode = BSCD_WaitTimerMode_eBlockWaitTime;
3325
3326	timeValue.ulValue = in_channelHandle->currentChannelSettings.blockWaitTime.ulValue ;
3327	BSCD_P_CHECK_ERR_CODE_FUNC(errCode,
3328	BSCD_Channel_ConfigTimer(in_channelHandle, &timer, &timeValue));
3329
3330	in_channelHandle->currentChannelSettings.blockWaitTimeExt.ulValue = 0;
3331
3332	BSCD_P_DONE_LABEL:
3333
3334	BDBG_LEAVE(BSCD_Channel_ResetBlockWaitTimer);
3335	return( errCode );
3336	}
3337
3338
3339	BERR_Code BSCD_Channel_SetBlockWaitTimeExt(
3340	BSCD_ChannelHandle in_channelHandle,
3341	uint32_t in_ulBlockWaitTimeExtInETU
3342	)
3343	{
3344	BERR_Code errCode = BERR_SUCCESS;
3345
3346	BDBG_ENTER(BSCD_Channel_SetBlockWaitTimeExt);
3347	BDBG_ASSERT( in_channelHandle );
3348
3349	in_channelHandle->currentChannelSettings.blockWaitTimeExt.ulValue = in_ulBlockWaitTimeExtInETU;
3350
3351	BDBG_LEAVE(BSCD_Channel_SetBlockWaitTimeExt);
3352	return( errCode );
3353	}
3354
3355	void BSCD_Channel_DumpRegisters(
3356	BSCD_ChannelHandle in_channelHandle
3357	)
3358	{
3359	uint32_t ulVal;
3360
3361	ulVal = BREG_Read32(
3362	in_channelHandle->moduleHandle->regHandle,
3363	(in_channelHandle->ulRegStartAddr + BSCD_P_UART_CMD_1));
3364	BDBG_MSG(("UART_CMD_1 = %02x \n",ulVal));
3365
3366	ulVal = BREG_Read32(
3367	in_channelHandle->moduleHandle->regHandle,
3368	(in_channelHandle->ulRegStartAddr + BSCD_P_UART_CMD_2));
3369	BDBG_MSG(("UART_CMD_2 = %02x \n",ulVal));
3370
3371	ulVal = BREG_Read32(
3372	in_channelHandle->moduleHandle->regHandle,
3373	(in_channelHandle->ulRegStartAddr + BSCD_P_PROTO_CMD));
3374	BDBG_MSG(("PROTO = %02x \n",ulVal));
3375
3376	ulVal = BREG_Read32(
3377	in_channelHandle->moduleHandle->regHandle,
3378	(in_channelHandle->ulRegStartAddr + BSCD_P_FLOW_CMD));
3379	BDBG_MSG(("FLOW_CMD = %02x \n",ulVal));
3380
3381	ulVal = BREG_Read32(
3382	in_channelHandle->moduleHandle->regHandle,
3383	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_1));
3384	BDBG_MSG(("IF_CMD_1 = %02x \n",ulVal));
3385
3386	ulVal = BREG_Read32(
3387	in_channelHandle->moduleHandle->regHandle,
3388	(in_channelHandle->ulRegStartAddr + BSCD_P_IF_CMD_2));
3389	BDBG_MSG(("IF_CMD_2 = %02x \n",ulVal));
3390
3391	ulVal = BREG_Read32(
3392	in_channelHandle->moduleHandle->regHandle,
3393	(in_channelHandle->ulRegStartAddr + BSCD_P_INTR_STAT_1));
3394	BDBG_MSG(("INTR_STAT_1 = %02x \n",ulVal));
3395
3396	ulVal = BREG_Read32(
3397	in_channelHandle->moduleHandle->regHandle,
3398	(in_channelHandle->ulRegStartAddr + BSCD_P_INTR_STAT_2));
3399	BDBG_MSG(("INTR_STAT_2 = %02x \n",ulVal));
3400
3401	ulVal = BREG_Read32(
3402	in_channelHandle->moduleHandle->regHandle,
3403	(in_channelHandle->ulRegStartAddr + BSCD_P_INTR_EN_1));
3404	BDBG_MSG(("INTR_EN_1 = %02x \n",ulVal));
3405
3406	ulVal = BREG_Read32(
3407	in_channelHandle->moduleHandle->regHandle,
3408	(in_channelHandle->ulRegStartAddr + BSCD_P_INTR_EN_2));
3409	BDBG_MSG(("INTR_EN_2 = %02x \n",ulVal));
3410
3411	ulVal = BREG_Read32(
3412	in_channelHandle->moduleHandle->regHandle,
3413	(in_channelHandle->ulRegStartAddr + BSCD_P_CLK_CMD));
3414	BDBG_MSG(("CLK_CMD = %02x \n",ulVal));
3415
3416	ulVal = BREG_Read32(
3417	in_channelHandle->moduleHandle->regHandle,
3418	(in_channelHandle->ulRegStartAddr + BSCD_P_PRESCALE));
3419	BDBG_MSG(("PRESCALE = %02x \n",ulVal));
3420
3421	ulVal = BREG_Read32(
3422	in_channelHandle->moduleHandle->regHandle,
3423	(in_channelHandle->ulRegStartAddr + BSCD_P_TIMER_CMD));
3424	BDBG_MSG(("TIMER_CMD = %02x \n",ulVal));
3425
3426	ulVal = BREG_Read32(
3427	in_channelHandle->moduleHandle->regHandle,
3428	(in_channelHandle->ulRegStartAddr + BSCD_P_BGT));
3429	BDBG_MSG(("BGT = %02x \n",ulVal));
3430
3431	ulVal = BREG_Read32(
3432	in_channelHandle->moduleHandle->regHandle,
3433	(in_channelHandle->ulRegStartAddr + BSCD_P_TIMER_CNT_1));
3434	BDBG_MSG(("TIMER_CNT_1 = %02x \n",ulVal));
3435
3436	ulVal = BREG_Read32(
3437	in_channelHandle->moduleHandle->regHandle,
3438	(in_channelHandle->ulRegStartAddr + BSCD_P_TIMER_CNT_2));
3439	BDBG_MSG(("TIMER_CNT_2 = %02x \n",ulVal));
3440
3441	ulVal = BREG_Read32(
3442	in_channelHandle->moduleHandle->regHandle,
3443	(in_channelHandle->ulRegStartAddr + BSCD_P_TIMER_CMP_1));
3444	BDBG_MSG(("TIMER_CMP_1 = %02x \n",ulVal));
3445
3446	ulVal = BREG_Read32(
3447	in_channelHandle->moduleHandle->regHandle,
3448	(in_channelHandle->ulRegStartAddr + BSCD_P_TIMER_CMP_2));
3449	BDBG_MSG(("TIMER_CMP_2 = %02x \n",ulVal));
3450
3451	ulVal = BREG_Read32(
3452	in_channelHandle->moduleHandle->regHandle,
3453	(in_channelHandle->ulRegStartAddr + BSCD_P_WAIT_1));
3454	BDBG_MSG(("SC_WAIT_1 = %02x \n",ulVal));
3455
3456	ulVal = BREG_Read32(
3457	in_channelHandle->moduleHandle->regHandle,
3458	(in_channelHandle->ulRegStartAddr + BSCD_P_WAIT_2));
3459	BDBG_MSG(("SC_WAIT_2 = %02x \n",ulVal));
3460
3461	ulVal = BREG_Read32(
3462	in_channelHandle->moduleHandle->regHandle,
3463	(in_channelHandle->ulRegStartAddr + BSCD_P_WAIT_3));
3464	BDBG_MSG(("SC_WAIT_3 = %02x \n",ulVal));
3465
3466	ulVal = BREG_Read32(
3467	in_channelHandle->moduleHandle->regHandle,
3468	(in_channelHandle->ulRegStartAddr + BSCD_P_TGUARD));
3469	BDBG_MSG(("TGUARD = %02x \n",ulVal));
3470
3471	#ifdef BSCD_EMV2000_CWT_PLUS_4_EVENT_INTR
3472	ulVal = BREG_Read32(
3473	in_channelHandle->moduleHandle->regHandle,
3474	(in_channelHandle->ulRegStartAddr + BSCD_P_EVENT1_CMD_1));
3475	BDBG_MSG(("BSCD_P_EVENT1_CMD_1 = %02x \n",ulVal));
3476
3477	ulVal = BREG_Read32(
3478	in_channelHandle->moduleHandle->regHandle,
3479	(in_channelHandle->ulRegStartAddr + BSCD_P_EVENT1_CMD_2));
3480	BDBG_MSG(("BSCD_P_EVENT1_CMD_2 = %02x \n",ulVal));
3481
3482	ulVal = BREG_Read32(
3483	in_channelHandle->moduleHandle->regHandle,
3484	(in_channelHandle->ulRegStartAddr + BSCD_P_EVENT1_CMD_3));
3485	BDBG_MSG(("BSCD_P_EVENT1_CMD_3 = %02x \n",ulVal));
3486
3487	ulVal = BREG_Read32(
3488	in_channelHandle->moduleHandle->regHandle,
3489	(in_channelHandle->ulRegStartAddr + BSCD_P_EVENT1_CMD_4));
3490	BDBG_MSG(("BSCD_P_EVENT1_CMD_4 = %02x \n",ulVal));
3491
3492	ulVal = BREG_Read32(
3493	in_channelHandle->moduleHandle->regHandle,
3494	(in_channelHandle->ulRegStartAddr + BSCD_P_EVENT1_CMP));
3495	BDBG_MSG(("BSCD_P_EVENT1_CMP = %02x \n",ulVal));
3496
3497	ulVal = BREG_Read32(
3498	in_channelHandle->moduleHandle->regHandle,
3499	(in_channelHandle->ulRegStartAddr + BSCD_P_EVENT2_CMD_1));
3500	BDBG_MSG(("BSCD_P_EVENT2_CMD_1 = %02x \n",ulVal));
3501
3502	ulVal = BREG_Read32(
3503	in_channelHandle->moduleHandle->regHandle,
3504	(in_channelHandle->ulRegStartAddr + BSCD_P_EVENT2_CMD_2));
3505	BDBG_MSG(("BSCD_P_EVENT2_CMD_2 = %02x \n",ulVal));
3506
3507	ulVal = BREG_Read32(
3508	in_channelHandle->moduleHandle->regHandle,
3509	(in_channelHandle->ulRegStartAddr + BSCD_P_EVENT2_CMD_3));
3510	BDBG_MSG(("BSCD_P_EVENT2_CMD_3 = %02x \n",ulVal));
3511
3512	ulVal = BREG_Read32(
3513	in_channelHandle->moduleHandle->regHandle,
3514	(in_channelHandle->ulRegStartAddr + BSCD_P_EVENT2_CMD_4));
3515	BDBG_MSG(("BSCD_P_EVENT2_CMD_4 = %02x \n",ulVal));
3516
3517	ulVal = BREG_Read32(
3518	in_channelHandle->moduleHandle->regHandle,
3519	(in_channelHandle->ulRegStartAddr + BSCD_P_EVENT2_CMP));
3520	BDBG_MSG(("BSCD_P_EVENT2_CMP = %02x \n",ulVal));
3521
3522	#endif
3523	/*
3524	bcmDeviceRead(inp_device, eSize8, BCM_SC_TRANSMIT, (void *)&ulVal);
3525	BDBG_MSG(("TRANSMIT = %02x \n",ulVal));
3526	bcmDeviceRead(inp_device, eSize8, BCM_SC_RECEIVE, (void *)&ulVal);
3527	BDBG_MSG(("RECEIVE = %02x \n",ulVal));
3528
3529
3530	bcmDeviceRead(inp_device, eSize8, BCM_SC_TLEN_1, (void *)&ulVal);
3531	BDBG_MSG(("TLEN_1 = %02x \n",ulVal));
3532	bcmDeviceRead(inp_device, eSize8, BCM_SC_TLEN_2, (void *)&ulVal);
3533	BDBG_MSG(("TLEN_2 = %02x \n",ulVal));
3534	bcmDeviceRead(inp_device, eSize8, BCM_SC_RLEN_1, (void *)&ulVal);
3535	BDBG_MSG(("RLEN_1 = %02x \n",ulVal));
3536	bcmDeviceRead(inp_device, eSize8, BCM_SC_RLEN_2, (void *)&ulVal);
3537	BDBG_MSG(("RLEN_2 = %02x \n",ulVal));
3538
3539	*/
3540	}
3541
3542

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

Context Navigation

source: svn/trunk/newcon3bcm2_21bu/magnum/portinginterface/scd/7552/bscd.c

Download in other formats: