Context Navigation

drv_dsl_cpe_api.c @ 18231

Last change on this file since 18231 was 18231, checked in by BrainSlayer, 17 months ago
missing dir
File size: 216.1 KB

Line
1	/******************************************************************************
2
3	Copyright (c) 2009
4	Infineon Technologies AG
5	Am Campeon 1-12; 81726 Munich, Germany
6
7	For licensing information, see the file 'LICENSE' in the root folder of
8	this software module.
9
10	******************************************************************************/
11
12	#define DSL_INTERN
13
14	#include "drv_dsl_cpe_api.h"
15	#include "drv_dsl_cpe_api_ioctl.h"
16
17	#ifdef __cplusplus
18	extern "C" {
19	#endif
20
21	#undef DSL_DBG_BLOCK
22	#define DSL_DBG_BLOCK DSL_DBG_CPE_API
23
24	/* handles to the low-level BSP driver */
25	DSL_devCtx_t ifxDevices[DSL_DRV_MAX_DEVICE_NUMBER] = { {DSL_NULL} };
26
27	#ifdef INCLUDE_DSL_DELT
28	#ifdef DSL_CPE_STATIC_DELT_DATA
29	DSL_G997_DeltData_t deltData;
30	#ifdef INCLUDE_DSL_CPE_API_VINAX
31	DSL_G997_DeltShowtimeData_t deltShowtimeData;
32	#endif /* INCLUDE_DSL_CPE_API_VINAX*/
33	#endif /* DSL_CPE_STATIC_DELT_DATA*/
34	#endif /* INCLUDE_DSL_DELT*/
35
36	DSL_OpenContext_t *pOpenContextList = DSL_NULL;
37
38	/* Possible XTSE configuration*/
39	#if (INCLUDE_DSL_CPE_API_VDSL_SUPPORT == 1)
40	DSL_uint8_t g_XTSEposs[DSL_G997_NUM_XTSE_OCTETS] =
41	{0x17, 0x01, 0x14, 0x51, 0x4C, 0x45, 0x05, 0x07};
42	#else
43	DSL_uint8_t g_XTSEposs[DSL_G997_NUM_XTSE_OCTETS] =
44	{0x17, 0x01, 0x14, 0x51, 0x4C, 0x45, 0x05, 0x00};
45	#endif /* (INCLUDE_DSL_CPE_API_VDSL_SUPPORT == 1)*/
46
47	/*
48	For a detailed description of the function, its arguments and return value
49	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
50	*/
51	DSL_Error_t DSL_DRV_EventGenerate(
52	DSL_Context_t *pContext,
53	DSL_uint8_t nChannel,
54	DSL_AccessDir_t nAccessDir,
55	DSL_XTUDir_t nXtuDir,
56	DSL_EventType_t nEventType,
57	DSL_EventData_Union_t *pData,
58	DSL_uint16_t nDataSize)
59	{
60	DSL_Error_t nErrCode = DSL_SUCCESS;
61	DSL_EventStatusData_t evData;
62
63	DSL_DEBUG( DSL_DBG_MSG,
64	(pContext, "DSL[%02d]: IN - DSL_DRV_EventGenerate"DSL_DRV_CRLF,
65	DSL_DEV_NUM(pContext)));
66
67	/* Generate event*/
68	DSL_DRV_MemSet(&evData, 0, sizeof(DSL_EventStatusData_t));
69	evData.nEventType = nEventType;
70	evData.nXtuDir = nXtuDir;
71	evData.nAccessDir = nAccessDir;
72	evData.nChannel = nChannel;
73
74	if( pData != DSL_NULL && nDataSize != 0)
75	{
76	evData.pData = (DSL_EventData_Union_t*)DSL_DRV_Malloc(nDataSize);
77
78	if( evData.pData != DSL_NULL)
79	{
80	memcpy( evData.pData, pData, nDataSize);
81	}
82	}
83	else
84	{
85	evData.pData = DSL_NULL;
86	}
87
88	/* Queue Event*/
89	nErrCode = DSL_DRV_EventQueue(pContext, &evData, nDataSize);
90
91	DSL_DEBUG( DSL_DBG_MSG,
92	(pContext, "DSL[%02d]: OUT - DSL_DRV_EventGenerate, retCode=%d"DSL_DRV_CRLF,
93	DSL_DEV_NUM(pContext), nErrCode));
94
95	return nErrCode;
96	}
97
98	#if defined(INCLUDE_DSL_G997_STATUS) \|\| defined(INCLUDE_DSL_G997_ALARM) \|\| defined(INCLUDE_DSL_CPE_API_VINAX)
99	/*
100	This function hadles an LINIT event.
101
102	\param pContext - Pointer to dsl cpe library context structure, [I]
103	\param nLinit - Specifies the LINIT failure definition, [I]
104
105	\return
106	Return values are defined within the DSL_Error_t definition
107	- DSL_SUCCESS in case of success
108	- DSL_ERROR if operation failed
109	*/
110	DSL_Error_t DSL_DRV_HandleLinitValue(
111	DSL_Context_t *pContext,
112	const DSL_G997_LineInit_t nLinit,
113	const DSL_G997_LineInitSubStatus_t nSub)
114	{
115	DSL_Error_t nErrCode = DSL_SUCCESS;
116	DSL_G997_LineInitStatusData_t lineInitStatus;
117	DSL_uint32_t nCount = 0;
118
119	lineInitStatus.nLineInitStatus = nLinit;
120	lineInitStatus.nLineInitSubStatus = nSub;
121
122	DSL_CTX_WRITE(pContext, nErrCode, lineInitStatus, lineInitStatus);
123
124	if (nLinit != LINIT_SUCCESSFUL)
125	{
126	/* Get LINIT Retry count*/
127	DSL_CTX_READ_SCALAR(pContext, nErrCode, lineInitRetryCount, nCount);
128
129	if( nCount < DSL_G997_LINIT_RETRIES )
130	{
131	nCount++;
132	}
133
134	#ifdef INCLUDE_DSL_G997_ALARM
135	if( (nCount >= DSL_G997_LINIT_RETRIES) \|\| (nLinit == LINIT_NO_PEER_XTU) )
136	{
137	nErrCode = DSL_DRV_EventGenerate(
138	pContext, 0, DSL_ACCESSDIR_NA, DSL_XTUDIR_NA,
139	DSL_EVENT_S_LINIT_FAILURE,
140	(DSL_EventData_Union_t*)&nLinit,
141	sizeof(DSL_G997_LineInit_t));
142
143	if( nErrCode != DSL_SUCCESS )
144	{
145	DSL_DEBUG( DSL_DBG_ERR,
146	(pContext, "DSL[%02d]: ERROR - Event(%d) generate failed!"DSL_DRV_CRLF,
147	DSL_DEV_NUM(pContext), DSL_EVENT_S_LINIT_FAILURE));
148	}
149	}
150	#endif /* INCLUDE_DSL_G997_ALARM*/
151	}
152	else
153	{
154	/* Reset LINIT retry counter in case of success */
155	nCount = 0;
156	}
157
158	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, lineInitRetryCount, nCount);
159
160	return nErrCode;
161	}
162	#endif /* defined(INCLUDE_DSL_G997_STATUS) \|\| defined(INCLUDE_DSL_G997_ALARM) \|\| defined(INCLUDE_DSL_CPE_API_VINAX)*/
163
164	/*
165	For a detailed description of the function, its arguments and return value
166	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
167	*/
168	#if defined(INCLUDE_DSL_CPE_API_VINAX) \|\| (defined(INCLUDE_DSL_CPE_API_DANUBE) && defined(INCLUDE_DSL_G997_LINE_INVENTORY))
169	DSL_Error_t DSL_DRV_OnTimeoutEvent(
170	DSL_Context_t *pContext,
171	DSL_int_t nEventType,
172	DSL_uint32_t nTimeoutID)
173	{
174	DSL_Error_t errorCode = DSL_SUCCESS;
175
176	DSL_DEBUG(DSL_DBG_MSG,(pContext, "DSL[%02d]: DSL_DRV_OnTimeoutEvent: "
177	"nEventType=%d, nTimeoutID=0x%08X" DSL_DRV_CRLF ,
178	DSL_DEV_NUM(pContext), nEventType, nTimeoutID));
179
180	errorCode = DSL_DRV_DEV_OnTimeoutEvent(pContext,nEventType,nTimeoutID);
181
182	return (errorCode);
183	}
184	#endif /* defined(INCLUDE_DSL_CPE_API_VINAX) \|\| (defined(INCLUDE_DSL_CPE_API_DANUBE) && defined(INCLUDE_DSL_G997_LINE_INVENTORY))*/
185
186	#ifndef INCLUDE_FW_REQUEST_SUPPORT
187	static DSL_Error_t DSL_DRV_FwCopy(
188	DSL_Context_t *pContext,
189	DSL_boolean_t bIsInKernel,
190	const DSL_uint8_t *pFirmware,
191	const DSL_uint32_t nFirmwareSize,
192	DSL_uint8_t **ppFirmware,
193	DSL_uint32_t *pFirmwareSize)
194	{
195	DSL_Error_t nErrCode = DSL_SUCCESS;
196
197	DSL_CHECK_POINTER(pContext, ppFirmware);
198	DSL_CHECK_POINTER(pContext, pFirmwareSize);
199	DSL_CHECK_ERR_CODE();
200
201	#ifdef INCLUDE_DSL_DRV_STATIC_LINKED_FIRMWARE
202	/* Statically linked FW supported only under the RTEMS OS build*/
203	*ppFirmware = pFirmware;
204	*pFirmwareSize = nFirmwareSize;
205	#else
206	if ( (pFirmware != DSL_NULL) && (nFirmwareSize != 0) )
207	{
208	if (*ppFirmware != DSL_NULL)
209	{
210	DSL_DRV_VFree(*ppFirmware);
211	}
212
213	ppFirmware = (DSL_uint8_t)DSL_DRV_VMalloc(nFirmwareSize);
214	if (*ppFirmware != DSL_NULL)
215	{
216	*pFirmwareSize = nFirmwareSize;
217	/* Copy FW binary*/
218	DSL_IoctlMemCpyFrom(bIsInKernel, ppFirmware, (DSL_void_t)pFirmware,
219	nFirmwareSize);
220	}
221	else
222	{
223	*pFirmwareSize = 0;
224	nErrCode = DSL_ERROR;
225	DSL_DEBUG( DSL_DBG_ERR, (pContext,
226	"DSL[%02d]: Memory allocation for firmware binary failed!" DSL_DRV_CRLF,
227	DSL_DEV_NUM(pContext)));
228	}
229	}
230	#endif /* INCLUDE_DSL_DRV_STATIC_LINKED_FIRMWARE*/
231
232	return (nErrCode);
233	}
234
235	/*
236	This function stores the FW binaries in the DSL CPE API internal memory
237
238	\param pContext Pointer to dsl library context structure, [I]
239	\param pFirmware1 1st firmware pointer, [I]
240	\param nSize1 Size of 1st firmware, [I]
241	\param pFirmware2 2nd firmware pointer, [I]
242	\param nSize2 Size of 2nd firmware, [I]
243
244	\return Return values are defined within the \ref DSL_Error_t definition
245	- DSL_SUCCESS in case of success
246	- DSL_ERROR if operation failed
247	- or any other defined specific error code
248	*/
249	static DSL_Error_t DSL_DRV_FwStore(
250	DSL_Context_t *pContext,
251	DSL_boolean_t bIsInKernel,
252	const DSL_char_t *pFirmware1,
253	DSL_uint32_t nSize1,
254	const DSL_char_t *pFirmware2,
255	DSL_uint32_t nSize2)
256	{
257	DSL_Error_t nErrCode = DSL_SUCCESS;
258
259	DSL_DEBUG(DSL_DBG_MSG,
260	(pContext, "DSL[%02d]: IN - DSL_DRV_FwStore"DSL_DRV_CRLF,
261	DSL_DEV_NUM(pContext)));
262
263	/* Proceed 1'st FW binary*/
264	if (DSL_DRV_FwCopy(pContext, bIsInKernel, (DSL_uint8_t*)pFirmware1, nSize1,
265	&pContext->pFirmware, &pContext->nFirmwareSize) != DSL_SUCCESS)
266	{
267	return DSL_ERROR;
268	}
269
270	#ifdef INCLUDE_DSL_CPE_API_VINAX
271	/* Proceed 2'nd FW binary*/
272	if( DSL_DRV_FwCopy(pContext, bIsInKernel, (DSL_uint8_t*)pFirmware2, nSize2,
273	&pContext->pFirmware2, &pContext->nFirmwareSize2) != DSL_SUCCESS)
274	{
275	return DSL_ERROR;
276	}
277	#endif /* #ifdef INCLUDE_DSL_CPE_API_VINAX*/
278
279
280	DSL_DEBUG(DSL_DBG_MSG,
281	(pContext, "DSL[%02d]: OUT - DSL_DRV_FwStore"DSL_DRV_CRLF,
282	DSL_DEV_NUM(pContext)));
283
284	return nErrCode;
285	}
286	#endif /* INCLUDE_FW_REQUEST_SUPPORT*/
287
288	static DSL_Error_t DSL_DRV_InstanceStatusGet(
289	DSL_OpenContext_t *pOpenCtx,
290	DSL_IN DSL_Context_t *pContext,
291	DSL_IN_OUT DSL_InstanceStatus_t *pData)
292	{
293	DSL_Error_t nErrCode = DSL_SUCCESS;
294
295	DSL_CHECK_CTX_POINTER(pContext);
296	DSL_CHECK_ERR_CODE();
297
298	DSL_DEBUG(DSL_DBG_MSG,
299	(pContext, "DSL[%02d]: IN - DSL_InstanceStatusGet"DSL_DRV_CRLF,
300	DSL_DEV_NUM(pContext)));
301
302	if(DSL_DRV_MUTEX_LOCK(pOpenCtx->eventMutex))
303	{
304	DSL_DEBUG( DSL_DBG_ERR,
305	(pContext, "DSL[%02d]:Couldn't lock event mutex"DSL_DRV_CRLF,
306	DSL_DEV_NUM(pContext)));
307	return DSL_ERROR;
308	}
309
310	/* Get status data from the instance specific context*/
311	pData->data.bEventActivation = pOpenCtx->bEventActivation;
312	pData->data.nResourceActivationMask = pOpenCtx->nResourceActivationMask;
313
314	DSL_DRV_MUTEX_UNLOCK(pOpenCtx->eventMutex);
315
316	DSL_DEBUG(DSL_DBG_MSG,
317	(pContext, "DSL[%02d]: OUT - DSL_InstanceStatusGet, retCode=%d"DSL_DRV_CRLF,
318	DSL_DEV_NUM(pContext), nErrCode));
319
320	return(nErrCode);
321	}
322
323	/*
324	For a detailed description of the function, its arguments and return value
325	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
326	*/
327	DSL_Error_t DSL_DRV_HandleInit(
328	DSL_IN DSL_int_t nNum,
329	DSL_IN_OUT DSL_OpenContext_t **pRefOpenContext)
330	{
331	if (nNum >= DSL_DRV_MAX_DEVICE_NUMBER \|\| pRefOpenContext == DSL_NULL)
332	{
333	return DSL_ERR_INVALID_PARAMETER;
334	}
335
336	/* the global context is NULL, initialize it */
337	if (ifxDevices[nNum].pContext == DSL_NULL)
338	{
339	ifxDevices[nNum].pContext = DSL_DRV_VMalloc(sizeof(DSL_Context_t));
340	if (ifxDevices[nNum].pContext == DSL_NULL)
341	{
342	return DSL_ERR_MEMORY;
343	}
344
345	DSL_DRV_MemSet(ifxDevices[nNum].pContext, 0, sizeof(DSL_Context_t));
346
347	if (ifxDevices[nNum].nUsageCount != 0)
348	{
349	DSL_DEBUG(DSL_DBG_ERR, (DSL_NULL, "DSL[%02d]: Internal error in the DSL "
350	"CPE API. Uninitialized device context has non-null "
351	"usage count."DSL_DRV_CRLF, nNum));
352	return DSL_ERR_INTERNAL;
353	}
354
355	ifxDevices[nNum].pContext->pDevCtx = &ifxDevices[nNum];
356
357	/* Set device number*/
358	ifxDevices[nNum].nNum = nNum;
359	/* init device mutex */
360	DSL_DRV_MUTEX_INIT(ifxDevices[nNum].pContext->bspMutex);
361
362	/* init data mutex */
363	DSL_DRV_MUTEX_INIT(ifxDevices[nNum].pContext->dataMutex);
364
365	/* init initialization mutex */
366	DSL_DRV_MUTEX_INIT(ifxDevices[nNum].pContext->initMutex);
367
368	/* init Open Context List mutex */
369	DSL_DRV_MUTEX_INIT(ifxDevices[nNum].openContextListMutex);
370
371	#if defined(INCLUDE_DSL_CPE_API_DANUBE)
372	/* init HDLC mutex */
373	DSL_DRV_MUTEX_INIT(ifxDevices[nNum].pContext->hdlcMutex);
374	#endif /* defined(INCLUDE_DSL_CPE_API_DANUBE)*/
375	#if defined(INCLUDE_DSL_CPE_API_VINAX) \|\| (defined(INCLUDE_DSL_CPE_API_DANUBE) && defined(INCLUDE_DSL_G997_LINE_INVENTORY))
376	if (DSL_DRV_Timeout_Init(ifxDevices[nNum].pContext, DSL_MAX_TIMEOUT_NUM,
377	DSL_FALSE) != DSL_SUCCESS)
378	{
379	DSL_DEBUG(DSL_DBG_ERR, (DSL_NULL, "DSL[%02d]: Internal error in the DSL "
380	"CPE API. Could not prepare timeout context."DSL_DRV_CRLF,
381	nNum));
382	return DSL_ERR_INTERNAL;
383	}
384	#endif /* defined(INCLUDE_DSL_CPE_API_VINAX) \|\| (defined(INCLUDE_DSL_CPE_API_DANUBE) && defined(INCLUDE_DSL_G997_LINE_INVENTORY))*/
385	}
386
387	if (ifxDevices[nNum].nUsageCount > 0 && ifxDevices[nNum].pContext == DSL_NULL)
388	{
389	DSL_DEBUG(DSL_DBG_ERR, (DSL_NULL, "DSL[%02d]: Internal error in the DSL "
390	"CPE API. Used device context has null pointer "
391	"to DSL Context."DSL_DRV_CRLF,
392	nNum));
393	return DSL_ERR_INTERNAL;
394	}
395
396	/* Lock Open Context List*/
397	if (DSL_DRV_MUTEX_LOCK(ifxDevices[nNum].openContextListMutex))
398	{
399	DSL_DEBUG( DSL_DBG_ERR,
400	(DSL_NULL, "DSL[%02d]: ERROR - Couldn't lock Context List mutex!"DSL_DRV_CRLF,
401	nNum));
402
403	return DSL_ERR_SEMAPHORE_GET;
404	}
405
406	*pRefOpenContext = DSL_DRV_VMalloc(sizeof(DSL_OpenContext_t));
407	if (*pRefOpenContext == DSL_NULL)
408	{
409	DSL_DEBUG(DSL_DBG_ERR, (DSL_NULL, "DSL[%02d]: Open failed, "
410	"could not allocate memory..."DSL_DRV_CRLF, nNum));
411
412	/* Unlock Open Context List*/
413	DSL_DRV_MUTEX_UNLOCK(ifxDevices[nNum].openContextListMutex);
414
415	return DSL_ERR_MEMORY;
416	}
417	else
418	{
419	DSL_DRV_MemSet(*pRefOpenContext, 0, sizeof(DSL_OpenContext_t));
420
421	/* init event queue */
422	DSL_DRV_INIT_WAKELIST("evntque", (*pRefOpenContext)->eventWaitQueue);
423
424	/* init event mutex */
425	DSL_DRV_MUTEX_INIT((*pRefOpenContext)->eventMutex);
426
427	#ifdef INCLUDE_DSL_CEOC
428	/* init Rx SNMP FIFO mutex*/
429	DSL_DRV_MUTEX_INIT((*pRefOpenContext)->rxSnmpFifoMutex);
430	#endif /* #ifdef INCLUDE_DSL_CEOC*/
431
432	/* Disable event handling*/
433	(*pRefOpenContext)->bEventActivation = DSL_FALSE;
434	/* Mask (disable) all events*/
435	(*pRefOpenContext)->nEventMask = 0xFFFFFFFF;
436	/* KAv: Unmask all indication threshold crossing events by default.
437	It not completely defined how to handle these events for instance specific
438	processing.*/
439	(*pRefOpenContext)->nEventMask &=
440	~(DSL_EVENT2MASK(DSL_EVENT_I_LINE_THRESHOLD_CROSSING) \|
441	DSL_EVENT2MASK(DSL_EVENT_I_CHANNEL_THRESHOLD_CROSSING) \|
442	DSL_EVENT2MASK(DSL_EVENT_I_DATA_PATH_THRESHOLD_CROSSING) \|
443	DSL_EVENT2MASK(DSL_EVENT_I_RETX_THRESHOLD_CROSSING) \|
444	DSL_EVENT2MASK(DSL_EVENT_I_CHANNEL_DATARATE_SHIFT_THRESHOLD_CROSSING));
445
446	(*pRefOpenContext)->nResourceActivationMask = (DSL_BF_ResourceActivationType_t)0xFFFFFFFF;
447
448	/* add to list */
449	if (pOpenContextList == DSL_NULL)
450	{
451	/* first element */
452	pOpenContextList = *pRefOpenContext;
453	}
454	else
455	{
456	/* add to head */
457	(*pRefOpenContext)->pNext = pOpenContextList;
458	pOpenContextList = *pRefOpenContext;
459	}
460
461	(*pRefOpenContext)->pDevCtx = &ifxDevices[nNum];
462
463	ifxDevices[nNum].nUsageCount++;
464	}
465
466	/* Unlock Open Context List*/
467	DSL_DRV_MUTEX_UNLOCK(ifxDevices[nNum].openContextListMutex);
468
469	DSL_DEBUG( DSL_DBG_MSG,
470	(DSL_NULL, "DSL[%02d]: Open: Use count: %d"DSL_DRV_CRLF,
471	nNum, ifxDevices[nNum].nUsageCount));
472
473	DSL_DRV_OS_ModUseCountIncrement();
474
475	return DSL_SUCCESS;
476	}
477
478	/*
479	For a detailed description of the function, its arguments and return value
480	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
481	*/
482	DSL_Error_t DSL_DRV_HandleCleanup(
483	DSL_IN DSL_devCtx_t *pDevContext,
484	DSL_IN DSL_boolean_t bForce)
485	{
486	if (pDevContext == DSL_NULL)
487	{
488	DSL_DEBUG( DSL_DBG_ERR,
489	(DSL_NULL, "DSL: DSL_DRV_HandleCleanup: "
490	"Device context is NULL"DSL_DRV_CRLF));
491	return DSL_ERROR;
492	}
493
494	if (pDevContext->nUsageCount > 1 && bForce == DSL_FALSE)
495	{
496	DSL_DEBUG( DSL_DBG_ERR,
497	(DSL_NULL, "DSL[%02d]: DSL_DRV_HandleCleanup: "
498	"device is still used by another process"DSL_DRV_CRLF,
499	pDevContext->nNum));
500	return DSL_ERROR;
501	}
502
503	if (pDevContext->nUsageCount > 1 && bForce == DSL_TRUE)
504	{
505	DSL_DEBUG( DSL_DBG_MSG,
506	(DSL_NULL, "DSL[%02d]: DSL_DRV_HandleCleanup: "
507	"clean up is forced"DSL_DRV_CRLF, pDevContext->nNum));
508	}
509
510	if (pDevContext->nUsageCount > 1 \|\| bForce == DSL_TRUE)
511	{
512
513	while (pDevContext->nUsageCount-- > 1)
514	{
515	DSL_DRV_OS_ModUseCountDecrement();
516	}
517
518	if (pDevContext->pContext != DSL_NULL)
519	{
520	DSL_DEBUG( DSL_DBG_MSG,
521	(DSL_NULL, "DSL[%02d]: DSL_DRV_HandleCleanup: "
522	"Autoboot thread stopping..."DSL_DRV_CRLF,
523	pDevContext->nNum));
524
525	DSL_DRV_AutobootThreadStop(pDevContext->pContext);
526
527	DSL_DEBUG( DSL_DBG_MSG,
528	(DSL_NULL, "DSL[%02d]: DSL_DRV_HandleCleanup: "
529	"Autoboot thread has been stopped..."DSL_DRV_CRLF,
530	pDevContext->nNum));
531
532	DSL_DRV_Free(pDevContext->pContext);
533	DSL_DRV_VFree(pDevContext->pContext);
534	pDevContext->pContext = DSL_NULL;
535	}
536	}
537
538	return DSL_SUCCESS;
539	}
540
541	/*
542	For a detailed description of the function, its arguments and return value
543	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
544	*/
545	DSL_Error_t DSL_DRV_HandleDelete(
546	DSL_IN DSL_OpenContext_t *pOpenContext)
547	{
548	DSL_devCtx_t *pDevContext;
549	DSL_EventStatusData_t event;
550	DSL_OpenContext_t pPrev, pCurr;
551	DSL_void_t *pPtr;
552	DSL_Error_t nErrCode = DSL_SUCCESS;
553
554	if (pOpenContext == DSL_NULL)
555	{
556	return DSL_ERR_INVALID_PARAMETER;
557	}
558	else
559	{
560	pDevContext = pOpenContext->pDevCtx;
561
562	if (pDevContext == DSL_NULL)
563	{
564	return DSL_ERROR;
565	}
566	else
567	{
568	if (pDevContext->nUsageCount > 0)
569	{
570	pDevContext->nUsageCount--;
571	}
572
573	/* Lock Open Context list mutex*/
574	if (DSL_DRV_MUTEX_LOCK(pDevContext->openContextListMutex))
575	{
576	DSL_DEBUG( DSL_DBG_ERR,
577	(DSL_NULL, "DSL[%02d]: ERROR - Couldn't lock Context List mutex!"DSL_DRV_CRLF,
578	pDevContext->nNum));
579
580	return DSL_ERR_SEMAPHORE_GET;
581	}
582
583	if ((pOpenContext->nEventMask & DSL_EVENT2MASK(DSL_EVENT_S_FIRMWARE_REQUEST)) == 0
584	&& pOpenContext->pDevCtx != DSL_NULL
585	&& pOpenContext->pDevCtx->pContext != DSL_NULL)
586	{
587	DSL_CTX_WRITE_SCALAR(pOpenContext->pDevCtx->pContext,
588	nErrCode, bFirmwareEventAssigned, DSL_FALSE);
589	}
590
591	if (pOpenContext->eventFifo != DSL_NULL
592	&& pOpenContext->eventFifoBuf != DSL_NULL)
593	{
594	while (!DSL_Fifo_isEmpty(pOpenContext->eventFifo))
595	{
596	if (DSL_DRV_EventUnqueue(pOpenContext, &event)
597	>= DSL_SUCCESS)
598	{
599	if (event.pData != DSL_NULL)
600	{
601	DSL_DRV_VFree(event.pData);
602	}
603	}
604	}
605	}
606
607	/* release event structures */
608	if (pOpenContext->eventFifo != DSL_NULL)
609	{
610	pPtr = pOpenContext->eventFifo;
611	pOpenContext->eventFifo = DSL_NULL;
612
613	DSL_DRV_VFree(pPtr);
614	}
615
616	/* release event structures */
617	if (pOpenContext->eventFifoBuf != DSL_NULL)
618	{
619	pPtr = pOpenContext->eventFifoBuf;
620	pOpenContext->eventFifoBuf = DSL_NULL;
621	DSL_DRV_VFree(pPtr);
622	}
623
624	/* remove from list */
625	if (pOpenContextList != DSL_NULL)
626	{
627	if (pOpenContext == pOpenContextList)
628	{
629	/* it is a head */
630	pOpenContextList = pOpenContext->pNext;
631	}
632	else
633	{
634	for ( pPrev = pOpenContextList,
635	pCurr = pOpenContextList->pNext;
636	pCurr != pOpenContext && pCurr != DSL_NULL;
637	pPrev = pCurr,
638	pCurr = pCurr->pNext) ;
639
640	if (pCurr != DSL_NULL)
641	{
642	pPrev->pNext = pCurr->pNext;
643	}
644	}
645	}
646
647	DSL_DRV_VFree(pOpenContext);
648
649	/* Unlock Open Context list mutex*/
650	DSL_DRV_MUTEX_UNLOCK(pDevContext->openContextListMutex);
651	}
652	}
653
654	DSL_DEBUG( DSL_DBG_MSG,
655	(DSL_NULL, "DSL[%02d]: Close: Use count: %d, retCode=%d"DSL_DRV_CRLF,
656	pDevContext->nNum, pDevContext->nUsageCount, nErrCode));
657
658	DSL_DRV_OS_ModUseCountDecrement();
659
660	return nErrCode;
661	}
662
663	DSL_void_t DSL_DRV_Cleanup(DSL_void_t)
664	{
665	DSL_int_t i;
666
667	for (i = 0; i < DSL_DRV_MAX_DEVICE_NUMBER; i++)
668	{
669	DSL_DRV_HandleCleanup(&ifxDevices[i], DSL_TRUE);
670
671	DSL_DRV_DEV_DriverHandleDelete(ifxDevices[i].lowHandle);
672
673	#ifdef INCLUDE_DSL_CPE_API_VINAX
674	DSL_DRV_DEV_DriverHandleDelete(ifxDevices[i].nfc_lowHandle);
675	#endif
676
677	/* this is redundant code but in case of some our
678	threads leave active it will prevent momentary fault */
679	ifxDevices[i].lowHandle = DSL_NULL;
680	#ifdef INCLUDE_DSL_CPE_API_VINAX
681	ifxDevices[i].nfc_lowHandle = DSL_NULL;
682	#endif
683	ifxDevices[i].nUsageCount = 0;
684	}
685
686	while (pOpenContextList != DSL_NULL)
687	{
688	DSL_DRV_HandleDelete(pOpenContextList);
689	}
690	}
691
692	/*
693	For a detailed description of the function, its arguments and return value
694	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
695	*/
696	DSL_Error_t DSL_DRV_LinkReset(
697	DSL_IN DSL_Context_t *pContext)
698	{
699	DSL_Error_t nErrCode = DSL_SUCCESS;
700
701	DSL_DEBUG( DSL_DBG_MSG,
702	(pContext, "DSL[%02d]: IN - DSL_LinkReset"DSL_DRV_CRLF,
703	DSL_DEV_NUM(pContext)));
704
705	nErrCode = DSL_DRV_DEV_LinkReset(pContext);
706	if (nErrCode != DSL_SUCCESS)
707	{
708	DSL_DEBUG( DSL_DBG_ERR,
709	(pContext, "DSL[%02d]: Modem couldn't be reset"DSL_DRV_CRLF,
710	DSL_DEV_NUM(pContext)));
711	}
712	else
713	{
714	DSL_DEBUG( DSL_DBG_MSG,
715	(pContext, "DSL[%02d]: Modem was reseted..."DSL_DRV_CRLF,
716	DSL_DEV_NUM(pContext)));
717
718	nErrCode = DSL_SUCCESS;
719	}
720
721	DSL_DEBUG( DSL_DBG_MSG,
722	(pContext, "DSL[%02d]: OUT - DSL_LinkReset"DSL_DRV_CRLF,
723	DSL_DEV_NUM(pContext)));
724
725	return nErrCode;
726	}
727
728	DSL_Error_t DSL_DRV_ModulesInit(
729	DSL_IN DSL_Context_t *pContext)
730	{
731	DSL_Error_t nErrCode = DSL_SUCCESS;
732	DSL_boolean_t bFirmwareReady = DSL_FALSE;
733
734	DSL_CHECK_CTX_POINTER(pContext);
735	DSL_CHECK_ERR_CODE();
736
737	DSL_DEBUG(DSL_DBG_MSG,
738	(pContext, "DSL[%02d]: IN - DSL_DRV_ModulesInit"DSL_DRV_CRLF,
739	DSL_DEV_NUM(pContext)));
740
741	DSL_CTX_READ_SCALAR(pContext, nErrCode, pDevCtx->bFirmwareReady, bFirmwareReady);
742
743	/* Check FW availability*/
744	if( !bFirmwareReady )
745	{
746	DSL_DEBUG( DSL_DBG_ERR,
747	(pContext, "DSL[%02d]: ERROR - FW not loaded yet!"DSL_DRV_CRLF,
748	DSL_DEV_NUM(pContext)));
749
750	return DSL_ERROR;
751	}
752
753	/* Lock DSL CPE API data mutex*/
754	if(DSL_DRV_MUTEX_LOCK(pContext->initMutex))
755	{
756	DSL_DEBUG( DSL_DBG_ERR,
757	(pContext, "DSL[%02d]: Couldn't lock data mutex"DSL_DRV_CRLF,
758	DSL_DEV_NUM(pContext)));
759
760	return DSL_ERROR;
761	}
762
763	#if defined(INCLUDE_ADSL_LED) && defined(INCLUDE_DSL_CPE_API_DANUBE)
764	if ( DSL_DRV_LED_ModuleInit(pContext) != DSL_SUCCESS )
765	{
766	DSL_DEBUG( DSL_DBG_ERR,
767	(pContext, "DSL[%02d]: ERROR - LED module initialization failed"DSL_DRV_CRLF,
768	DSL_DEV_NUM(pContext)));
769	}
770	#endif /* defined(INCLUDE_ADSL_LED) && defined(INCLUDE_DSL_CPE_API_DANUBE)*/
771
772	#if defined(INCLUDE_DSL_ADSL_MIB)
773	if ( DSL_DRV_MIB_ModuleInit(pContext) != DSL_SUCCESS )
774	{
775	DSL_DEBUG( DSL_DBG_ERR,
776	(pContext, "DSL[%02d]: ERROR - MIB module initialization failed"DSL_DRV_CRLF,
777	DSL_DEV_NUM(pContext)));
778
779	nErrCode = DSL_ERROR;
780	}
781	#endif /* defined(INCLUDE_DSL_ADSL_MIB)*/
782
783	#if defined(INCLUDE_DSL_CEOC)
784	if ( DSL_CEOC_Start(pContext) != DSL_SUCCESS )
785	{
786	DSL_DEBUG( DSL_DBG_ERR,
787	(pContext, "DSL[%02d]: ERROR - CEOC module initialization failed!"DSL_DRV_CRLF,
788	DSL_DEV_NUM(pContext)));
789
790	nErrCode = DSL_ERROR;
791	}
792	#endif /* defined(INCLUDE_DSL_CEOC)*/
793
794	#if defined(INCLUDE_DSL_PM)
795	if ( DSL_DRV_PM_Start(pContext) != DSL_SUCCESS )
796	{
797	DSL_DEBUG( DSL_DBG_ERR,
798	(pContext, "DSL[%02d]: ERROR - PM module initialization failed"DSL_DRV_CRLF,
799	DSL_DEV_NUM(pContext)));
800
801	nErrCode = DSL_ERROR;
802	}
803	#endif /* defined(INCLUDE_DSL_PM)*/
804
805	/* Unock DSL CPE API data mutex*/
806	DSL_DRV_MUTEX_UNLOCK(pContext->initMutex);
807
808	DSL_DEBUG(DSL_DBG_MSG,
809	(pContext, "DSL[%02d]: OUT - DSL_DRV_ModulesInit"DSL_DRV_CRLF,
810	DSL_DEV_NUM(pContext)));
811
812	return nErrCode;
813	}
814
815	/*
816	For a detailed description of the function, its arguments and return value
817	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
818	*/
819	DSL_Error_t DSL_DRV_XtseSettingsCheck(
820	DSL_IN DSL_Context_t *pContext,
821	DSL_IN DSL_uint8_t *pXTSE)
822	{
823	DSL_Error_t nErrCode = DSL_SUCCESS, nRet = DSL_SUCCESS;
824	DSL_int32_t i = 0, emptyXseCnt = 0;
825	DSL_uint8_t xtsePoss = 0;
826	DSL_boolean_t bXtseChanged = DSL_FALSE, bXtseUnsupported = DSL_FALSE;
827
828	DSL_CHECK_POINTER(pContext, pXTSE);
829	DSL_CHECK_ERR_CODE();
830
831	/* Validation checks for configuration data */
832	for (i = 0; i < DSL_G997_NUM_XTSE_OCTETS; i++)
833	{
834	DSL_CTX_READ(pContext, nErrCode, xtsePoss[i], xtsePoss);
835
836	/* Check for unsupported bits*/
837	if ( (~(xtsePoss) & pXTSE[i]) > 0)
838	{
839	/* Check if there is at least one valid bit*/
840	if ((pXTSE[i] & xtsePoss) > 0)
841	{
842	/* Change specified configuration*/
843	pXTSE[i] &= xtsePoss;
844
845	bXtseChanged = DSL_TRUE;
846	}
847	else
848	{
849	/* No valid bits found at all*/
850	bXtseUnsupported = DSL_TRUE;
851	}
852	}
853
854	if (!pXTSE[i])
855	{
856	emptyXseCnt++;
857	}
858	}
859
860	/* Check if no valid bits specified at all*/
861	if (emptyXseCnt >= DSL_G997_NUM_XTSE_OCTETS)
862	{
863	DSL_DEBUG(DSL_DBG_ERR,
864	(pContext, "DSL[%02d]: ERROR - Empty XTSE settings, emptyXseCnt=%d!"DSL_DRV_CRLF,
865	DSL_DEV_NUM(pContext), emptyXseCnt));
866
867	nErrCode = DSL_ERROR;
868	}
869	else
870	{
871	if (bXtseUnsupported && !bXtseChanged)
872	{
873	/* There are bits set within the configuration that are not supported
874	by G.997.1 or at least by this version of the DSL library */
875	DSL_DEBUG(DSL_DBG_ERR,
876	(pContext, "DSL[%02d]: ERROR - No valid XTSE settings!"DSL_DRV_CRLF,
877	DSL_DEV_NUM(pContext)));
878
879	nErrCode = DSL_ERROR;
880	}
881	else if (bXtseChanged)
882	{
883	DSL_DEBUG(DSL_DBG_WRN,
884	(pContext, "DSL[%02d]: WARNING - Unsupported bits removed from the current XTSE settings!"DSL_DRV_CRLF,
885	DSL_DEV_NUM(pContext)));
886
887	nErrCode = DSL_WRN_INCONSISTENT_XTSE_CONFIGURATION;
888	}
889	}
890
891	if (nErrCode >= DSL_SUCCESS)
892	{
893	/* Check device specific XTSE settings*/
894	nRet = DSL_DRV_DEV_XtseSettingsCheck(pContext, pXTSE);
895	if (nRet != DSL_SUCCESS)
896	{
897	nErrCode = nRet;
898	}
899	}
900
901	return nErrCode;
902	}
903
904	/*
905	For a detailed description of the function, its arguments and return value
906	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
907	*/
908	DSL_Error_t DSL_DRV_Init(
909	DSL_IN DSL_Context_t *pContext,
910	DSL_IN_OUT DSL_Init_t *pData)
911	{
912	DSL_Error_t nErrCode = DSL_SUCCESS;
913	DSL_int32_t nLoff = 0, nCurrOffset = 0;
914	DSL_boolean_t bFirmwareReady = DSL_FALSE;
915	#ifdef INCLUDE_FW_REQUEST_SUPPORT
916	DSL_FirmwareRequestData_t fwReqData = { DSL_FW_REQUEST_NA };
917	DSL_boolean_t bFwRequest = DSL_FALSE;
918	#endif /* INCLUDE_FW_REQUEST_SUPPORT*/
919	DSL_FirmwareRequestType_t nFwType = DSL_FW_REQUEST_NA;
920
921	DSL_DEBUG(DSL_DBG_MSG,
922	(pContext, "DSL[%02d]: IN - DSL_Init"DSL_DRV_CRLF,
923	DSL_DEV_NUM(pContext)));
924
925	DSL_CHECK_POINTER(pContext, pData);
926	DSL_CHECK_POINTER(pContext, pContext->pDevCtx);
927	DSL_CHECK_ERR_CODE();
928
929	if (pContext->bInitComplete == DSL_TRUE)
930	{
931	DSL_DEBUG( DSL_DBG_WRN,
932	(pContext, "DSL[%02d]: DSL CPE API is already initialized!"DSL_DRV_CRLF,
933	DSL_DEV_NUM(pContext)));
934
935	return DSL_WRN_ALREADY_INITIALIZED;
936	}
937
938	#ifdef INCLUDE_DSL_DELT
939	#ifdef DSL_CPE_STATIC_DELT_DATA
940	DSL_DRV_MemSet(&deltData, 0, sizeof(DSL_G997_DeltData_t));
941	pContext->DELT = &deltData;
942	#ifdef INCLUDE_DSL_CPE_API_VINAX
943	DSL_DRV_MemSet(&deltShowtimeData, 0, sizeof(DSL_G997_DeltShowtimeData_t));
944	pContext->DELT_SHOWTIME = &deltShowtimeData;
945	#endif
946	#else
947	pContext->DELT = DSL_NULL;
948	#ifdef INCLUDE_DSL_CPE_API_VINAX
949	pContext->DELT_SHOWTIME = DSL_NULL;
950	#endif
951	#endif
952	#endif /* #ifdef INCLUDE_DSL_DELT*/
953
954	if(DSL_DRV_MUTEX_LOCK(pContext->dataMutex))
955	{
956	DSL_DEBUG( DSL_DBG_ERR,
957	(pContext, "DSL[%02d]: Couldn't lock data mutex"DSL_DRV_CRLF,
958	DSL_DEV_NUM(pContext)));
959	return DSL_ERROR;
960	}
961
962	/* Set XTSE configuration*/
963	memcpy( pContext->xtseCfg, pData->data.nXtseCfg.XTSE, sizeof(pContext->xtseCfg) );
964
965	/* Initialize possible XTSE configurations*/
966	memcpy(pContext->xtsePoss, g_XTSEposs, DSL_G997_NUM_XTSE_OCTETS);
967
968	/* Get Test Mode Control options and copy them to the DSL CPE context*/
969	memcpy(&(pContext->nTestModeControl),
970	&(pData->data.nTestModeControl), sizeof(DSL_TestModeControlSet_t));
971
972	/* Get Line Activate Control options and copy them to the DSL CPE context*/
973	memcpy(&(pContext->lineActivateConfig),
974	&(pData->data.nLineActivateConfig), sizeof(DSL_G997_LineActivateData_t));
975
976	/* Set SerialNumber*/
977	memcpy(
978	pContext->lineInventoryNe.SerialNumber,
979	pData->data.pInventory->SerialNumber,
980	DSL_G997_LI_MAXLEN_SERIAL);
981
982	/* Set SystemVendorID*/
983	memcpy(
984	pContext->lineInventoryNe.SystemVendorID,
985	pData->data.pInventory->SystemVendorID,
986	DSL_G997_LI_MAXLEN_VENDOR_ID);
987
988	/* Set VersionNumber*/
989	memcpy(
990	pContext->lineInventoryNe.VersionNumber,
991	pData->data.pInventory->VersionNumber,
992	DSL_G997_LI_MAXLEN_VERSION);
993	#if (INCLUDE_DSL_CPE_API_VDSL_SUPPORT == 1)
994	/* Set VersionNumber*/
995	memcpy(
996	&pContext->auxInventoryNe,
997	&(pData->data.pInventory->Auxiliary),
998	sizeof(DSL_AuxInventoryNe_t));
999	#endif
1000
1001	/* Set Autoboot configuration options*/
1002	pContext->nAutobootStartupMode = pData->data.nAutobootStartupMode;
1003	memcpy(
1004	&(pContext->nAutobootConfig),
1005	&(pData->data.nAutobootConfig),
1006	sizeof(DSL_AutobootConfigData_t));
1007
1008	/* TODO: check these initialization parameters*/
1009	pContext->lineFeatureDataCfg[DSL_UPSTREAM].bTrellisEnable = DSL_TRUE;
1010	pContext->lineFeatureDataCfg[DSL_DOWNSTREAM].bTrellisEnable = DSL_TRUE;
1011	pContext->lineFeatureDataCfg[DSL_UPSTREAM].bBitswapEnable = DSL_TRUE;
1012	pContext->lineFeatureDataCfg[DSL_DOWNSTREAM].bBitswapEnable = DSL_TRUE;
1013	pContext->powerMgmtStatus.nPowerManagementStatus = DSL_G997_PMS_L3;
1014
1015	DSL_DRV_MUTEX_UNLOCK(pContext->dataMutex);
1016
1017	/* Check XTSE setings*/
1018	nErrCode = DSL_DRV_XtseSettingsCheck(pContext, pData->data.nXtseCfg.XTSE);
1019	if (nErrCode < DSL_SUCCESS)
1020	{
1021	DSL_DEBUG( DSL_DBG_ERR,
1022	(pContext, "DSL[%02d]: ERROR - Wrong XTSE settings!"DSL_DRV_CRLF,
1023	DSL_DEV_NUM(pContext)));
1024
1025	DSL_DRV_MemSet( pContext->xtseCfg, 0x0, sizeof(pContext->xtseCfg) );
1026
1027	return nErrCode;
1028	}
1029
1030	/* Initialize device specific parameters*/
1031	nErrCode = DSL_DRV_DEV_DeviceInit(pContext, pData);
1032	if( nErrCode != DSL_SUCCESS )
1033	{
1034	DSL_DEBUG( DSL_DBG_ERR,
1035	(pContext, "DSL[%02d]: ERROR - Device Init failed!"DSL_DRV_CRLF,
1036	DSL_DEV_NUM(pContext)));
1037
1038	return nErrCode;
1039	}
1040
1041	/* Download FW if available and Start Autoboot handling.
1042	If no FW specified, do it later with appropriate IOCTLs*/
1043	if( pData->data.pFirmware != DSL_NULL \|\| pData->data.pFirmware2 != DSL_NULL )
1044	{
1045	/* Load FW if available*/
1046	nErrCode = DSL_DRV_FwDownload(
1047	pContext,
1048	(DSL_char_t*)pData->data.pFirmware,
1049	pData->data.nFirmwareSize,
1050	(DSL_char_t*)pData->data.pFirmware2,
1051	pData->data.nFirmwareSize2,
1052	&nLoff, &nCurrOffset,
1053	DSL_TRUE);
1054
1055	if( nErrCode != DSL_SUCCESS )
1056	{
1057	DSL_DEBUG( DSL_DBG_ERR,
1058	(pContext, "DSL[%02d]: ERROR - FW Download failed!"DSL_DRV_CRLF,
1059	DSL_DEV_NUM(pContext)));
1060	return nErrCode;
1061	}
1062
1063	/* Get FW ready flag*/
1064	DSL_CTX_READ_SCALAR(pContext, nErrCode, pDevCtx->bFirmwareReady, bFirmwareReady);
1065
1066	/* Here the complete FW binary should be downloaded to the device, no chunks allowed*/
1067	if(!bFirmwareReady)
1068	{
1069	DSL_DEBUG( DSL_DBG_ERR,
1070	(pContext, "DSL[%02d]: ERROR - Expecting complete FW binary!"DSL_DRV_CRLF,
1071	DSL_DEV_NUM(pContext)));
1072
1073	return DSL_ERROR;
1074	}
1075
1076	/* Start Autoboot handling if allowed*/
1077	if( pData->data.nAutobootStartupMode != DSL_AUTOBOOT_CTRL_STOP )
1078	{
1079	if( DSL_DRV_AutobootThreadStart(pContext) != DSL_SUCCESS )
1080	{
1081	DSL_DEBUG( DSL_DBG_ERR,
1082	(pContext, "DSL[%02d]: ERROR - Autoboot thread start failed!"DSL_DRV_CRLF,
1083	DSL_DEV_NUM(pContext)));
1084
1085	return DSL_ERROR;
1086	}
1087	}
1088
1089	/* Initialize additional modules PM, CEOC,...*/
1090	nErrCode = DSL_DRV_ModulesInit(pContext);
1091	if( nErrCode != DSL_SUCCESS )
1092	{
1093	DSL_DEBUG( DSL_DBG_ERR,
1094	(pContext, "DSL[%02d]: ERROR - additional modules init failed!"DSL_DRV_CRLF,
1095	DSL_DEV_NUM(pContext)));
1096
1097	return nErrCode;
1098	}
1099	}
1100	else
1101	{
1102	#ifdef INCLUDE_DSL_CPE_API_VINAX
1103	DSL_CTX_READ(pContext, nErrCode, pDevCtx->data.deviceCfg.nFwType, nFwType);
1104	#else
1105	nFwType = DSL_FW_REQUEST_ADSL;
1106	#endif /* INCLUDE_DSL_CPE_API_VINAX*/
1107	#ifdef INCLUDE_FW_REQUEST_SUPPORT
1108	bFwRequest = DSL_TRUE;
1109	#endif /* INCLUDE_FW_REQUEST_SUPPORT*/
1110	/* Set pending flag to start automatically Autoboot handling if allowed*/
1111	if( pData->data.nAutobootStartupMode != DSL_AUTOBOOT_CTRL_STOP )
1112	{
1113	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, bAutobootStartPending, DSL_TRUE);
1114	}
1115
1116	/* Set Autoboot Status*/
1117	nErrCode = DSL_DRV_AutobootStatusSet(pContext, DSL_AUTOBOOT_STATUS_FW_WAIT, nFwType);
1118	if( nErrCode != DSL_SUCCESS )
1119	{
1120	DSL_DEBUG( DSL_DBG_ERR,
1121	(pContext, "DSL[%02d]: ERROR - Autoboot Status set failed!"DSL_DRV_CRLF,
1122	DSL_DEV_NUM(pContext)));
1123
1124	return nErrCode;
1125	}
1126	}
1127
1128	/* Set LINIT value to LINIT_UNKNOWN*/
1129	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, lineInitStatus.nLineInitStatus, LINIT_UNKNOWN);
1130
1131	pContext->bInitComplete = DSL_TRUE;
1132
1133	/* Generate DSL_EVENT_S_INIT_READY event*/
1134	DSL_DRV_EventGenerate(pContext, 0, DSL_ACCESSDIR_NA, DSL_XTUDIR_NA,
1135	DSL_EVENT_S_INIT_READY, DSL_NULL, 0);
1136
1137	#ifdef INCLUDE_FW_REQUEST_SUPPORT
1138	if (bFwRequest)
1139	{
1140	fwReqData.nFirmwareRequestType = nFwType;
1141	/* Generate DSL_EVENT_S_FIRMWARE_REQUEST event*/
1142	DSL_DRV_EventGenerate( pContext, 0, DSL_ACCESSDIR_NA,
1143	DSL_XTUDIR_NA, DSL_EVENT_S_FIRMWARE_REQUEST,
1144	(DSL_EventData_Union_t*)&fwReqData, sizeof(DSL_FirmwareRequestData_t));
1145	}
1146	#endif /* INCLUDE_FW_REQUEST_SUPPORT*/
1147
1148	DSL_DEBUG(DSL_DBG_MSG,
1149	(pContext, "DSL[%02d]: OUT - DSL_Init, retCode=%d"DSL_DRV_CRLF,
1150	DSL_DEV_NUM(pContext) ,nErrCode));
1151
1152	return nErrCode;
1153	}
1154
1155	/*
1156	For a detailed description of the function, its arguments and return value
1157	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
1158	*/
1159	DSL_void_t DSL_DRV_Free(
1160	DSL_IN DSL_Context_t *pContext)
1161	{
1162	if (pContext == DSL_NULL)
1163	{
1164	DSL_DEBUG_HDR(DSL_DBG_ERR, (pContext, "Invalid context pointer!"));
1165	return;
1166	}
1167
1168	if (pContext->pFirmware != DSL_NULL)
1169	{
1170	DSL_DRV_VFree(pContext->pFirmware);
1171	pContext->pFirmware = DSL_NULL;
1172	}
1173
1174	if (pContext->pFirmware2 != DSL_NULL)
1175	{
1176	DSL_DRV_VFree(pContext->pFirmware2);
1177	pContext->pFirmware2 = DSL_NULL;
1178	}
1179
1180	pContext->bInitComplete = DSL_FALSE;
1181
1182	#if defined(INCLUDE_DSL_CPE_API_VINAX) \|\| (defined(INCLUDE_DSL_CPE_API_DANUBE) && defined(INCLUDE_DSL_G997_LINE_INVENTORY))
1183	DSL_DRV_Timeout_Shutdown(pContext);
1184	#endif /* defined(INCLUDE_DSL_CPE_API_VINAX) \|\| (defined(INCLUDE_DSL_CPE_API_DANUBE) && defined(INCLUDE_DSL_G997_LINE_INVENTORY))*/
1185
1186	#if defined(INCLUDE_ADSL_LED)
1187	if (pContext->bLedInit)
1188	{
1189	stop_led_module = 1;
1190	DSL_DRV_WAKEUP_EVENT(pContext->ledPollingEvent);
1191	#ifdef INCLUDE_DSL_DATA_LED_SIMULATOR
1192	DSL_DRV_WAKEUP_EVENT(pContext->dataLedSimEvent);
1193	#endif /* INCLUDE_DSL_DATA_LED_SIMULATOR*/
1194	}
1195	#endif /* defined(INCLUDE_ADSL_LED)*/
1196
1197	#ifdef INCLUDE_DSL_PM
1198	/* Stop PM module processing*/
1199	if( DSL_DRV_PM_Stop(pContext) != DSL_SUCCESS )
1200	{
1201	DSL_DEBUG(DSL_DBG_ERR,
1202	(pContext, "DSL[%02d]: PM Module deinitialization failed"DSL_DRV_CRLF,
1203	DSL_DEV_NUM(pContext)));
1204	}
1205	#endif /* #ifdef INCLUDE_DSL_PM*/
1206
1207	#ifdef INCLUDE_DSL_CEOC
1208	/* Stop CEOC module processing*/
1209	if( DSL_CEOC_Stop(pContext) != DSL_SUCCESS )
1210	{
1211	DSL_DEBUG(DSL_DBG_ERR,
1212	(pContext, "DSL[%02d]: CEOC Module deinitialization failed"DSL_DRV_CRLF,
1213	DSL_DEV_NUM(pContext)));
1214	}
1215	#endif /* #ifdef INCLUDE_DSL_CEOC*/
1216
1217	#ifdef INCLUDE_DSL_DELT
1218	#ifndef DSL_CPE_STATIC_DELT_DATA
1219	/* Release DELT memory */
1220	if (pContext->DELT != DSL_NULL)
1221	{
1222	DSL_DRV_MemFree(pContext->DELT);
1223	}
1224	#ifdef INCLUDE_DSL_CPE_API_VINAX
1225	if (pContext->DELT_SHOWTIME != DSL_NULL)
1226	{
1227	DSL_DRV_MemFree(pContext->DELT_SHOWTIME);
1228	}
1229	#endif /* INCLUDE_DSL_CPE_API_VINAX*/
1230	#endif /* DSL_CPE_STATIC_DELT_DATA*/
1231	#endif /* INCLUDE_DSL_DELT*/
1232	}
1233
1234	/*
1235	For a detailed description of the function, its arguments and return value
1236	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
1237	*/
1238	DSL_Error_t DSL_DRV_AutobootLoadFirmware(
1239	DSL_IN DSL_Context_t *pContext,
1240	DSL_IN_OUT DSL_AutobootLoadFirmware_t *pData)
1241	{
1242	DSL_Error_t nErrCode = DSL_SUCCESS;
1243	DSL_int32_t nOffset = 0;
1244	DSL_boolean_t bFirmwareReady = DSL_FALSE;
1245	DSL_boolean_t bAutobootThreadStarted = DSL_FALSE,
1246	bAutobootFwLoadPending = DSL_FALSE,
1247	bAutobootStartPending = DSL_FALSE;
1248	DSL_AutobootControl_t AutobootCtrl;
1249	DSL_int32_t nWaitCount = 0;
1250	DSL_Autoboot_State_t nState = DSL_AUTOBOOTSTATE_UNKNOWN;
1251	DSL_uint8_t pFirmware = DSL_NULL, pFirmware2 = DSL_NULL;
1252
1253	DSL_CHECK_POINTER(pContext, pData);
1254	DSL_CHECK_POINTER(pContext, pContext->pDevCtx);
1255	DSL_CHECK_ERR_CODE();
1256
1257	DSL_CTX_READ_SCALAR(pContext, nErrCode, bAutobootThreadStarted, bAutobootThreadStarted);
1258	DSL_CTX_READ_SCALAR(pContext, nErrCode, bAutobootFwLoadPending, bAutobootFwLoadPending);
1259
1260	if( (pData->data.pFirmware != DSL_NULL && pData->data.nFirmwareSize) \|\|
1261	(pData->data.pFirmware2 != DSL_NULL && pData->data.nFirmwareSize2) )
1262	{
1263	DSL_DEBUG(DSL_DBG_MSG,
1264	(pContext, "DSL[%02d]: Preparing to download FW..."DSL_DRV_CRLF,
1265	DSL_DEV_NUM(pContext)));
1266	}
1267	else
1268	{
1269	DSL_DEBUG(DSL_DBG_ERR,
1270	(pContext, "DSL[%02d]: ERROR - No FW specified!"DSL_DRV_CRLF,
1271	DSL_DEV_NUM(pContext)));
1272
1273	return DSL_ERROR;
1274	}
1275
1276	if( bAutobootThreadStarted && !bAutobootFwLoadPending)
1277	{
1278	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, bAutobootFwLoadPending, DSL_TRUE);
1279
1280	/* Get Autoboot State*/
1281	DSL_CTX_READ_SCALAR(pContext, nErrCode, nAutobootState, nState);
1282
1283	if( nState != DSL_AUTOBOOTSTATE_FIRMWARE_WAIT )
1284	{
1285	/* Restart Autoboot*/
1286	AutobootCtrl.data.nCommand = DSL_AUTOBOOT_CTRL_RESTART;
1287	nErrCode = DSL_DRV_AutobootControlSet(pContext,&AutobootCtrl);
1288	if( nErrCode != DSL_SUCCESS )
1289	{
1290	/* Clear bAutobootFwLoadPending flag*/
1291	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, bAutobootFwLoadPending, DSL_FALSE);
1292
1293	DSL_DEBUG(DSL_DBG_ERR,
1294	(pContext, "DSL[%02d]: ERROR - Autoboot Control set failed!"DSL_DRV_CRLF,
1295	DSL_DEV_NUM(pContext)));
1296	return nErrCode;
1297	}
1298	}
1299
1300	/* wait for "DSL_AUTOBOOTSTATE_FIRMWARE_WAIT" max 4 sec */
1301	for (nWaitCount = 0; nWaitCount < 40; nWaitCount++)
1302	{
1303	/* Get Autoboot State*/
1304	DSL_CTX_READ_SCALAR(pContext, nErrCode, nAutobootState, nState);
1305	if( nErrCode != DSL_SUCCESS )
1306	{
1307	/* Clear bAutobootFwLoadPending flag*/
1308	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, bAutobootFwLoadPending, DSL_FALSE);
1309
1310	DSL_DEBUG(DSL_DBG_ERR,
1311	(pContext, "DSL[%02d]: ERROR - Autoboot State get failed!"DSL_DRV_CRLF,
1312	DSL_DEV_NUM(pContext)));
1313	return nErrCode;
1314	}
1315
1316	if( nState == DSL_AUTOBOOTSTATE_FIRMWARE_WAIT )
1317	{
1318	break;
1319	}
1320
1321	DSL_DRV_MSecSleep(100);
1322	}
1323
1324	if( nState != DSL_AUTOBOOTSTATE_FIRMWARE_WAIT )
1325	{
1326	/* Clear bAutobootFwLoadPending flag*/
1327	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, bAutobootFwLoadPending, DSL_FALSE);
1328	DSL_DEBUG(DSL_DBG_ERR,
1329	(pContext, "DSL[%02d]: ERROR - Timeout while waiting the "
1330	"DSL_AUTOBOOTSTATE_FIRMWARE_WAIT state!"DSL_DRV_CRLF,
1331	DSL_DEV_NUM(pContext)));
1332	return DSL_ERROR;
1333	}
1334	}
1335
1336	/* Deactivate Autoboot timeout for the Firmware Wait state*/
1337	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, nAutobootTimeoutLimit, 1800);
1338
1339	/* Copy FW binary to the kernel space*/
1340	if (pData->data.pFirmware != DSL_NULL)
1341	{
1342	pFirmware = (DSL_uint8_t*)DSL_DRV_VMalloc(pData->data.nFirmwareSize);
1343
1344	if (pFirmware != DSL_NULL)
1345	{
1346	DSL_IoctlMemCpyFrom(
1347	DSL_FALSE, pFirmware, pData->data.pFirmware, pData->data.nFirmwareSize);
1348	}
1349	else
1350	{
1351	pFirmware = DSL_NULL;
1352	nErrCode = DSL_ERROR;
1353	DSL_DEBUG( DSL_DBG_ERR, (pContext,
1354	"DSL[%02d]: ERROR - Memory allocation for firmware binary 1 failed!" DSL_DRV_CRLF,
1355	DSL_DEV_NUM(pContext)));
1356	}
1357	}
1358
1359	/* Copy FW binary 2 to the kernel space*/
1360	if ((pData->data.pFirmware2 != DSL_NULL) && (nErrCode == DSL_SUCCESS))
1361	{
1362	pFirmware2 = (DSL_uint8_t*)DSL_DRV_VMalloc(pData->data.nFirmwareSize2);
1363
1364	if (pFirmware2 != DSL_NULL)
1365	{
1366	DSL_IoctlMemCpyFrom(
1367	DSL_FALSE, pFirmware2, pData->data.pFirmware2, pData->data.nFirmwareSize2);
1368	}
1369	else
1370	{
1371	pFirmware2 = DSL_NULL;
1372	nErrCode = DSL_ERROR;
1373	DSL_DEBUG( DSL_DBG_ERR, (pContext,
1374	"DSL[%02d]: ERROR - Memory allocation for firmware binary 2 failed!" DSL_DRV_CRLF,
1375	DSL_DEV_NUM(pContext)));
1376	}
1377	}
1378
1379	if (nErrCode == DSL_SUCCESS)
1380	{
1381	#ifdef INCLUDE_DSL_CPE_API_VINAX
1382	/* Download FW*/
1383	nErrCode = DSL_DRV_FwDownload(
1384	pContext,
1385	(DSL_char_t*)pFirmware, pData->data.nFirmwareSize,
1386	(DSL_char_t*)pFirmware2, pData->data.nFirmwareSize2,
1387	(DSL_int32_t*)&pData->data.nFirmwareOffset, &nOffset,
1388	pData->data.bLastChunk);
1389	#else
1390	/*
1391	KAv: If FW binary data is in kernel space, the Amazon-Se driver FW
1392	sequence crashes. This issue needs further clarification.
1393	*/
1394	/* Download FW*/
1395	nErrCode = DSL_DRV_FwDownload(
1396	pContext,
1397	(DSL_char_t*)pData->data.pFirmware, pData->data.nFirmwareSize,
1398	(DSL_char_t*)pData->data.pFirmware2, pData->data.nFirmwareSize2,
1399	(DSL_int32_t*)&pData->data.nFirmwareOffset, &nOffset,
1400	pData->data.bLastChunk);
1401	#endif
1402	}
1403
1404	if (pFirmware != DSL_NULL)
1405	{
1406	/* Free allocated FW binary 1 resources*/
1407	DSL_DRV_VFree(pFirmware);
1408	}
1409
1410	if (pFirmware2 != DSL_NULL)
1411	{
1412	/* Free allocated FW binary 2 resources*/
1413	DSL_DRV_VFree(pFirmware2);
1414	}
1415
1416	if( nErrCode == DSL_SUCCESS )
1417	{
1418	/* Get bFirmwareReady flag*/
1419	DSL_CTX_READ_SCALAR(pContext, nErrCode, pDevCtx->bFirmwareReady, bFirmwareReady);
1420	if( bFirmwareReady )
1421	{
1422	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, bAutobootFwLoadPending, DSL_FALSE);
1423	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, bFwRequestHandled, DSL_TRUE);
1424
1425	#ifndef INCLUDE_FW_REQUEST_SUPPORT
1426	/* Check if the Chunk download is disabled*/
1427	if (!(pData->data.bChunkDonwloadEnabled))
1428	{
1429	/* Store FW binaries*/
1430	nErrCode = DSL_DRV_FwStore(
1431	pContext, DSL_FALSE,
1432	(DSL_char_t*)pData->data.pFirmware, pData->data.nFirmwareSize,
1433	(DSL_char_t*)pData->data.pFirmware2, pData->data.nFirmwareSize2);
1434	if (nErrCode != DSL_SUCCESS)
1435	{
1436	DSL_DEBUG(DSL_DBG_ERR,
1437	(pContext, "DSL[%02d]: ERROR - FW store failed!"DSL_DRV_CRLF,
1438	DSL_DEV_NUM(pContext)));
1439	}
1440	}
1441	#endif /* INCLUDE_FW_REQUEST_SUPPORT*/
1442
1443	/* Get Autoboot pending start flag*/
1444	DSL_CTX_READ(pContext, nErrCode, bAutobootStartPending, bAutobootStartPending);
1445
1446	/* Check if there is a pending Autoboot start*/
1447	if (bAutobootStartPending)
1448	{
1449	/* Reset Autoboot pending start flag*/
1450	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, bAutobootStartPending, DSL_FALSE);
1451
1452	nErrCode = DSL_DRV_AutobootThreadStart(pContext);
1453	if (nErrCode != DSL_SUCCESS)
1454	{
1455	DSL_DEBUG(DSL_DBG_ERR,
1456	(pContext, "DSL[%02d]: ERROR - Autoboot Thread pending start failed!"DSL_DRV_CRLF,
1457	DSL_DEV_NUM(pContext)));
1458
1459	return nErrCode;
1460	}
1461
1462	/* Initialize additional modules PM, CEOC,...*/
1463	nErrCode = DSL_DRV_ModulesInit(pContext);
1464	if (nErrCode != DSL_SUCCESS)
1465	{
1466	DSL_DEBUG( DSL_DBG_ERR,
1467	(pContext, "DSL[%02d]: ERROR - additional modules init failed!"DSL_DRV_CRLF,
1468	DSL_DEV_NUM(pContext)));
1469
1470	return nErrCode;
1471	}
1472	}
1473	}
1474	}
1475	else
1476	{
1477	DSL_DEBUG(DSL_DBG_ERR,
1478	(pContext, "DSL[%02d]: ERROR - FW download failed, "
1479	"Autoboot will stay in the DSL_AUTOBOOTSTATE_FIRMWARE_WAIT state!"DSL_DRV_CRLF,
1480	DSL_DEV_NUM(pContext)));
1481	}
1482
1483	return nErrCode;
1484	}
1485
1486	/*
1487	For a detailed description of the function, its arguments and return value
1488	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
1489	*/
1490	DSL_Error_t DSL_DRV_AutobootControlSet(
1491	DSL_IN DSL_Context_t *pContext,
1492	DSL_IN_OUT DSL_AutobootControl_t *pData)
1493	{
1494	DSL_Error_t nErrCode = DSL_SUCCESS;
1495	#ifdef INCLUDE_DSL_DELT
1496	DSL_G997_LDSF_t nLoopMode = DSL_G997_INHIBIT_LDSF;
1497	#endif /* INCLUDE_DSL_DELT*/
1498	DSL_boolean_t bFirmwareReady = DSL_FALSE, bInitComplete = DSL_FALSE;
1499	DSL_Autoboot_State_t nState = DSL_AUTOBOOTSTATE_UNKNOWN;
1500
1501	DSL_DEBUG(DSL_DBG_MSG,
1502	(pContext, "DSL[%02d]: IN - DSL_DRV_AutobootControlSet(%d)"DSL_DRV_CRLF,
1503	DSL_DEV_NUM(pContext), pData->data.nCommand));
1504
1505	DSL_CHECK_CTX_POINTER(pContext);
1506	DSL_CHECK_ERR_CODE();
1507
1508	DSL_CTX_READ_SCALAR(pContext, nErrCode, bInitComplete, bInitComplete);
1509	if (bInitComplete == DSL_FALSE)
1510	{
1511	DSL_DEBUG( DSL_DBG_ERR,
1512	(pContext, "DSL[%02d]: ERROR - DSL CPE API was not initialized yet!"DSL_DRV_CRLF,
1513	DSL_DEV_NUM(pContext)));
1514	nErrCode = DSL_ERR_NOT_INITIALIZED;
1515	}
1516
1517	if (nErrCode == DSL_SUCCESS)
1518	{
1519	switch (pData->data.nCommand)
1520	{
1521	case DSL_AUTOBOOT_CTRL_START:
1522	DSL_CTX_READ_SCALAR(pContext, nErrCode, pDevCtx->bFirmwareReady,
1523	bFirmwareReady);
1524
1525	if (bFirmwareReady == DSL_FALSE)
1526	{
1527	DSL_DEBUG(DSL_DBG_ERR,
1528	(pContext, "DSL[%02d]: ERROR - Autoboot Start failed, no FW loaded!"DSL_DRV_CRLF,
1529	DSL_DEV_NUM(pContext)));
1530	nErrCode = DSL_ERROR;
1531	break;
1532	}
1533
1534	nErrCode = DSL_DRV_AutobootThreadStart(pContext);
1535	if( nErrCode != DSL_SUCCESS )
1536	{
1537	DSL_DEBUG(DSL_DBG_ERR,
1538	(pContext, "DSL[%02d]: ERROR - Autoboot Thread start failed!"DSL_DRV_CRLF,
1539	DSL_DEV_NUM(pContext)));
1540	break;
1541	}
1542
1543	/* Initialize additional modules PM, CEOC,...*/
1544	nErrCode = DSL_DRV_ModulesInit(pContext);
1545	if( nErrCode != DSL_SUCCESS )
1546	{
1547	DSL_DEBUG( DSL_DBG_ERR,
1548	(pContext, "DSL[%02d]: ERROR - additional modules init failed!"DSL_DRV_CRLF,
1549	DSL_DEV_NUM(pContext)));
1550	break;
1551	}
1552	break;
1553
1554	case DSL_AUTOBOOT_CTRL_STOP:
1555	/* Stop Autoboot thread*/
1556	DSL_DRV_AutobootThreadStop(pContext);
1557	#ifdef INCLUDE_DSL_PM
1558	/* Suspend PM module*/
1559	nErrCode = DSL_DRV_PM_Suspend(pContext);
1560
1561	if (nErrCode != DSL_SUCCESS)
1562	{
1563	DSL_DEBUG( DSL_DBG_ERR,
1564	(pContext, "DSL[%02d]: ERROR - PM module suspend failed!"DSL_DRV_CRLF,
1565	DSL_DEV_NUM(pContext)));
1566
1567	return nErrCode;
1568	}
1569	#endif /* #ifdef INCLUDE_DSL_PM*/
1570	/* Trigger restart sequence*/
1571	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, bAutobootRestart, DSL_TRUE);
1572	break;
1573
1574	case DSL_AUTOBOOT_CTRL_RESTART:
1575	#ifdef INCLUDE_DSL_DELT
1576	DSL_CTX_READ_SCALAR(pContext, nErrCode, lineActivateConfig.nLDSF, nLoopMode);
1577
1578	if (nLoopMode == DSL_G997_AUTO_LDSF)
1579	{
1580	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, nLoopAutoCount, 1);
1581	}
1582	#endif /* INCLUDE_DSL_DELT*/
1583	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, bAutobootRestart, DSL_TRUE);
1584
1585	if (pContext->bAutobootThreadStarted)
1586	{
1587	/* Change Autoboot Status*/
1588	nErrCode = DSL_DRV_AutobootStatusSet(pContext,
1589	DSL_AUTOBOOT_STATUS_RUNNING, DSL_FW_REQUEST_NA);
1590	}
1591
1592	break;
1593
1594	case DSL_AUTOBOOT_CTRL_CONTINUE:
1595	DSL_CTX_READ_SCALAR(pContext, nErrCode, nAutobootState, nState);
1596	if ((nState != DSL_AUTOBOOTSTATE_LINK_ACTIVATE_WAIT) &&
1597	(nState != DSL_AUTOBOOTSTATE_CONFIG_WRITE_WAIT) &&
1598	(nState != DSL_AUTOBOOTSTATE_RESTART_WAIT))
1599	{
1600	nErrCode = DSL_WRN_NOT_ALLOWED_IN_CURRENT_STATE;
1601	}
1602	else
1603	{
1604	/* Trigger to continue Autoboot handling*/
1605	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, bAutobootContinue, DSL_TRUE);
1606	}
1607	break;
1608	default:
1609	nErrCode = DSL_ERR_INVALID_PARAMETER;
1610	break;
1611	}
1612	}
1613
1614	DSL_DEBUG(DSL_DBG_MSG,
1615	(pContext, "DSL[%02d]: OUT - DSL_AutobootControlSet, retCode=%d"DSL_DRV_CRLF,
1616	DSL_DEV_NUM(pContext), nErrCode));
1617
1618	return nErrCode;
1619	}
1620
1621	/*
1622	For a detailed description of the function, its arguments and return value
1623	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
1624	*/
1625	#ifdef INCLUDE_DSL_CONFIG_GET
1626	DSL_Error_t DSL_DRV_AutobootConfigGet(
1627	DSL_IN DSL_Context_t *pContext,
1628	DSL_OUT DSL_AutobootConfig_t *pData)
1629	{
1630	DSL_Error_t nErrCode = DSL_SUCCESS;
1631
1632	DSL_CHECK_POINTER(pContext, pData);
1633	DSL_CHECK_ERR_CODE();
1634
1635	DSL_DEBUG(DSL_DBG_MSG,
1636	(pContext, "DSL[%02d]: IN - DSL_AutobootConfigGet"DSL_DRV_CRLF,
1637	DSL_DEV_NUM(pContext)));
1638
1639	/* Get Autoboot Configuration from the DSL CPE context*/
1640	DSL_CTX_READ(pContext, nErrCode, nAutobootConfig, pData->data);
1641
1642	DSL_DEBUG(DSL_DBG_MSG,
1643	(pContext, "DSL[%02d]: OUT - DSL_AutobootConfigGet"DSL_DRV_CRLF,
1644	DSL_DEV_NUM(pContext)));
1645
1646	return nErrCode;
1647	}
1648	#endif /* INCLUDE_DSL_CONFIG_GET*/
1649
1650	/*
1651	For a detailed description of the function, its arguments and return value
1652	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
1653	*/
1654	DSL_Error_t DSL_DRV_AutobootConfigSet(
1655	DSL_IN DSL_Context_t *pContext,
1656	DSL_OUT DSL_AutobootConfig_t *pData)
1657	{
1658	DSL_Error_t nErrCode = DSL_SUCCESS;
1659
1660	DSL_CHECK_POINTER(pContext, pData);
1661	DSL_CHECK_ERR_CODE();
1662
1663	DSL_DEBUG(DSL_DBG_MSG,
1664	(pContext, "DSL[%02d]: IN - DSL_AutobootConfigSet"DSL_DRV_CRLF,
1665	DSL_DEV_NUM(pContext)));
1666
1667	/* Set Autoboot Configuration from the DSL CPE context*/
1668	DSL_CTX_WRITE(pContext, nErrCode, nAutobootConfig, pData->data);
1669
1670	DSL_DEBUG(DSL_DBG_MSG,
1671	(pContext, "DSL[%02d]: OUT - DSL_AutobootConfigSet"DSL_DRV_CRLF,
1672	DSL_DEV_NUM(pContext)));
1673
1674	return nErrCode;
1675	}
1676
1677	/*
1678	For a detailed description of the function, its arguments and return value
1679	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
1680	*/
1681	DSL_Error_t DSL_DRV_AutobootStatusGet(
1682	DSL_IN DSL_Context_t *pContext,
1683	DSL_OUT DSL_AutobootStatus_t *pData)
1684	{
1685	DSL_Error_t nErrCode = DSL_SUCCESS;
1686
1687	DSL_CHECK_POINTER(pContext, pData);
1688	DSL_CHECK_ERR_CODE();
1689
1690	DSL_DEBUG(DSL_DBG_MSG,
1691	(pContext, "DSL[%02d]: IN - DSL_AutobootStatusGet"DSL_DRV_CRLF,
1692	DSL_DEV_NUM(pContext)));
1693
1694	/* Get Autoboot Status from the DSL CPE context*/
1695	DSL_CTX_READ(pContext, nErrCode, nAutobootStatus.nStatus, pData->data.nStatus);
1696
1697	DSL_CTX_READ(pContext, nErrCode, nAutobootStatus.nFirmwareRequestType,
1698	pData->data.nFirmwareRequestType);
1699
1700	DSL_DEBUG(DSL_DBG_MSG,
1701	(pContext, "DSL[%02d]: OUT - DSL_AutobootStatusGet"DSL_DRV_CRLF,
1702	DSL_DEV_NUM(pContext)));
1703
1704	return nErrCode;
1705	}
1706
1707	/*
1708	For a detailed description of the function, its arguments and return value
1709	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
1710	*/
1711	DSL_Error_t DSL_DRV_AutobootStatusSet(
1712	DSL_IN DSL_Context_t *pContext,
1713	DSL_IN DSL_AutobootStatGet_t nStatus,
1714	DSL_IN DSL_FirmwareRequestType_t nFirmwareRequestType)
1715	{
1716	DSL_Error_t nErrCode = DSL_SUCCESS;
1717	DSL_AutobootStatGet_t nOldStatus = DSL_AUTOBOOT_STATUS_LAST;
1718	DSL_AutobootStatusData_t autobootStatus;
1719
1720	DSL_CHECK_CTX_POINTER(pContext);;
1721	DSL_CHECK_ERR_CODE();
1722
1723	DSL_DEBUG(DSL_DBG_MSG,
1724	(pContext, "DSL[%02d]: IN - DSL_AutobootStatusSet"DSL_DRV_CRLF,
1725	DSL_DEV_NUM(pContext)));
1726
1727	DSL_CTX_READ_SCALAR(pContext, nErrCode, nAutobootStatus.nStatus, nOldStatus);
1728
1729	if (nStatus != nOldStatus)
1730	{
1731	DSL_DEBUG(DSL_DBG_MSG, (pContext, "DSL[%02d]: Autoboot status has changed: "
1732	"%s(%d) -> %s(%d)" DSL_DRV_CRLF, DSL_DEV_NUM(pContext),
1733	DSL_DBG_PRN_AUTOBOOT_STATUS[nOldStatus], nOldStatus,
1734	DSL_DBG_PRN_AUTOBOOT_STATUS[nStatus], nStatus));
1735
1736	autobootStatus.nStatus = nStatus;
1737	autobootStatus.nFirmwareRequestType = nFirmwareRequestType;
1738
1739	/* Set Autoboot Status in the DSL CPE context*/
1740	DSL_CTX_WRITE(pContext, nErrCode, nAutobootStatus, autobootStatus);
1741
1742	nErrCode = DSL_DRV_EventGenerate(
1743	pContext, 0, DSL_ACCESSDIR_NA, DSL_XTUDIR_NA,
1744	DSL_EVENT_S_AUTOBOOT_STATUS,
1745	(DSL_EventData_Union_t*)&autobootStatus,
1746	sizeof(DSL_AutobootStatusData_t));
1747
1748	if( nErrCode != DSL_SUCCESS )
1749	{
1750	DSL_DEBUG( DSL_DBG_ERR,
1751	(pContext, "DSL[%02d]: ERROR - Event(%d) generate failed!"DSL_DRV_CRLF,
1752	DSL_DEV_NUM(pContext), DSL_EVENT_S_AUTOBOOT_STATUS));
1753	}
1754	}
1755
1756	DSL_DEBUG(DSL_DBG_MSG,
1757	(pContext, "DSL[%02d]: OUT - DSL_AutobootStatusSet"DSL_DRV_CRLF,
1758	DSL_DEV_NUM(pContext)));
1759
1760	return nErrCode;
1761	}
1762
1763	/*
1764	For a detailed description of the function, its arguments and return value
1765	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
1766	*/
1767	#ifdef INCLUDE_DSL_RESOURCE_STATISTICS
1768	DSL_Error_t DSL_DRV_ResourceUsageStatisticsGet(
1769	DSL_IN DSL_Context_t *pContext,
1770	DSL_OUT DSL_ResourceUsageStatistics_t *pData)
1771	{
1772	DSL_Error_t nErrCode = DSL_SUCCESS;
1773	DSL_uint32_t staticMemUsageTotal = 0, dynamicMemUsageTotal = 0,
1774	eventFifoTotal = 0, eventFifoBuffTotal = 0;
1775	#ifdef INCLUDE_DSL_CEOC
1776	DSL_uint32_t snmpFifoTotal = 0, snmpFifoBuffTotal = 0;
1777	#endif /* INCLUDE_DSL_CEOC*/
1778	DSL_OpenContext_t *pOpenContext = DSL_NULL;
1779	DSL_ResourceUsageStatisticsData_t devResourceUsageStatisticsData;
1780
1781	DSL_CHECK_POINTER(pContext, pData);
1782	DSL_CHECK_POINTER(pContext, pContext->pDevCtx);
1783	DSL_CHECK_ERR_CODE();
1784
1785	nErrCode = DSL_DRV_DEV_ResourceUsageStatisticsGet(
1786	pContext, &devResourceUsageStatisticsData);
1787
1788	if (nErrCode != DSL_SUCCESS)
1789	{
1790	DSL_DEBUG(DSL_DBG_ERR,
1791	(pContext, "DSL[%02d]: ERROR - Device resource usage statistics get failed!"DSL_DRV_CRLF,
1792	DSL_DEV_NUM(pContext)));
1793	return nErrCode;
1794	}
1795
1796	/* *********************************************************************** */
1797	/* * Print statistic on memory usage of DSL CPE API * */
1798	/* *********************************************************************** */
1799	DSL_DEBUG( DSL_DBG_PRN, (pContext, "DSL: " DSL_DRV_CRLF ));
1800	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1801	"DSL: *****************************************************" DSL_DRV_CRLF ));
1802	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1803	"DSL: DSL CPE library version: %s" DSL_DRV_CRLF, DSL_CPE_API_PACKAGE_VERSION));
1804	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1805	"DSL: *****************************************************" DSL_DRV_CRLF ));
1806	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1807	"DSL: Device number : %d" DSL_DRV_CRLF, pContext->pDevCtx->nNum));
1808	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1809	"DSL: Number of opened instances : %d" DSL_DRV_CRLF, pContext->pDevCtx->nUsageCount));
1810	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1811	"DSL: Number of channels/line : %d" DSL_DRV_CRLF , DSL_CHANNELS_PER_LINE));
1812	DSL_DEBUG( DSL_DBG_PRN, (pContext, "DSL: " DSL_DRV_CRLF ));
1813
1814	/*
1815	Global Context static memory usage
1816	*/
1817	DSL_DEBUG( DSL_DBG_PRN, (pContext, "DSL: Global Context static memory usage" DSL_DRV_CRLF ));
1818	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1819	"DSL: context structure : %10d bytes" DSL_DRV_CRLF, (int)sizeof(DSL_Context_t)));
1820	/* Update total static memory usage*/
1821	staticMemUsageTotal += sizeof(DSL_Context_t);
1822	#if defined(INCLUDE_DSL_CPE_API_VINAX) \|\| (defined(INCLUDE_DSL_CPE_API_DANUBE) && defined(INCLUDE_DSL_G997_LINE_INVENTORY))
1823	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1824	"DSL: timeout event lists : %10d bytes" DSL_DRV_CRLF,
1825	pContext->TimeoutListsContext.nNrOfElements * sizeof(DSL_TimeoutElement_t) * DSL_MAX_TIMEOUT_NUM));
1826	staticMemUsageTotal += pContext->TimeoutListsContext.nNrOfElements * sizeof(DSL_TimeoutElement_t) * DSL_MAX_TIMEOUT_NUM;
1827	#endif /* defined(INCLUDE_DSL_CPE_API_VINAX) \|\| (defined(INCLUDE_DSL_CPE_API_DANUBE) && defined(INCLUDE_DSL_G997_LINE_INVENTORY))*/
1828	#ifdef INCLUDE_DSL_DELT
1829	#ifdef DSL_CPE_STATIC_DELT_DATA
1830	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1831	"DSL: DELT diagnostic data : %10d bytes" DSL_DRV_CRLF, (int)sizeof(DSL_G997_DeltData_t)));
1832	staticMemUsageTotal += sizeof(DSL_G997_DeltData_t);
1833	#ifdef INCLUDE_DSL_CPE_API_VINAX
1834	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1835	"DSL: DELT showtime data : %10d bytes" DSL_DRV_CRLF, (int)sizeof(DSL_G997_DeltShowtimeData_t)));
1836	staticMemUsageTotal += sizeof(DSL_G997_DeltShowtimeData_t);
1837	#endif /* INCLUDE_DSL_CPE_API_VINAX*/
1838	#endif /* DSL_CPE_STATIC_DELT_DATA*/
1839	#endif /* INCLUDE_DSL_DELT*/
1840
1841	/*
1842	Device specific static memory usage
1843	*/
1844	DSL_DEBUG( DSL_DBG_PRN, (pContext, "DSL: Device specific static memory usage" DSL_DRV_CRLF ));
1845	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1846	"DSL: device context structure : %10d bytes" DSL_DRV_CRLF, (int)(sizeof(DSL_devCtx_t)*DSL_DRV_MAX_DEVICE_NUMBER)));
1847	staticMemUsageTotal += sizeof(DSL_devCtx_t);
1848	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1849	"DSL: device auxiliary data : %10d bytes" DSL_DRV_CRLF, devResourceUsageStatisticsData.staticMemUsage));
1850	staticMemUsageTotal += devResourceUsageStatisticsData.staticMemUsage;
1851	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1852	"DSL: --------------" DSL_DRV_CRLF ));
1853	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1854	"DSL: Total static memory usage : %10d bytes" DSL_DRV_CRLF, staticMemUsageTotal));
1855	DSL_DEBUG( DSL_DBG_PRN, (pContext, "DSL: " DSL_DRV_CRLF ));
1856	/*
1857	Global Context dynamic memory usage
1858	*/
1859	DSL_DEBUG( DSL_DBG_PRN, (pContext, "DSL: Global Context dynamic memory usage" DSL_DRV_CRLF ));
1860	#ifndef INCLUDE_FW_REQUEST_SUPPORT
1861	if( pContext->pFirmware != DSL_NULL && pContext->nFirmwareSize)
1862	{
1863	dynamicMemUsageTotal += pContext->nFirmwareSize;
1864	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1865	"DSL: 1st firmware : %10d bytes" DSL_DRV_CRLF,
1866	pContext->nFirmwareSize));
1867	}
1868
1869	if( pContext->pFirmware2 != DSL_NULL && pContext->nFirmwareSize2)
1870	{
1871	dynamicMemUsageTotal += pContext->nFirmwareSize2;
1872	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1873	"DSL: 2nd firmware : %10d bytes" DSL_DRV_CRLF,
1874	pContext->nFirmwareSize2));
1875	}
1876	#endif /* #ifdef INCLUDE_FW_REQUEST_SUPPORT*/
1877
1878	#ifdef INCLUDE_DSL_DELT
1879	#ifndef DSL_CPE_STATIC_DELT_DATA
1880	if (pContext->DELT)
1881	{
1882	dynamicMemUsageTotal += sizeof(DSL_G997_DeltData_t);
1883	}
1884	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1885	"DSL: DELT diagnostic data : %10d bytes" DSL_DRV_CRLF,
1886	pContext->DELT ? (int)sizeof(DSL_G997_DeltData_t) : 0));
1887	#ifdef INCLUDE_DSL_CPE_API_VINAX
1888	if (pContext->DELT_SHOWTIME)
1889	{
1890	dynamicMemUsageTotal += sizeof(DSL_G997_DeltShowtimeData_t);
1891	}
1892	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1893	"DSL: DELT showtime data : %10d bytes" DSL_DRV_CRLF,
1894	pContext->DELT_SHOWTIME ? (int)sizeof(DSL_G997_DeltShowtimeData_t) : 0));
1895	#endif /* INCLUDE_DSL_CPE_API_VINAX*/
1896	#endif /* DSL_CPE_STATIC_DELT_DATA*/
1897	#endif /* INCLUDE_DSL_DELT*/
1898
1899	#ifdef INCLUDE_DSL_PM
1900	if (pContext->PM)
1901	{
1902	dynamicMemUsageTotal += sizeof(DSL_PM_Context);
1903	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1904	"DSL: PM context structure : %10d bytes" DSL_DRV_CRLF,
1905	pContext->PM ? (int)sizeof(DSL_PM_Context) : 0));
1906
1907	if ( (((DSL_PM_Context*)pContext->PM)->pCounters))
1908	{
1909	dynamicMemUsageTotal += sizeof(DSL_PM_CountersData_t);
1910	}
1911
1912	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1913	"DSL: PM counters : %10d bytes" DSL_DRV_CRLF,
1914	((DSL_PM_Context*)pContext->PM)->pCounters ?
1915	(int)sizeof(DSL_PM_CountersData_t) : 0));
1916
1917	if (((DSL_PM_Context*)pContext->PM)->pCountersDump)
1918	{
1919	dynamicMemUsageTotal += sizeof(DSL_PM_CountersDump_t);
1920	}
1921	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1922	"DSL: PM counters dump : %10d bytes" DSL_DRV_CRLF,
1923	((DSL_PM_Context*)pContext->PM)->pCountersDump ?
1924	(int)sizeof(DSL_PM_CountersDump_t) : 0));
1925	}
1926	else
1927	{
1928	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1929	"DSL: PM context structure : %10d bytes" DSL_DRV_CRLF, 0));
1930	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1931	"DSL: PM counters : %10d bytes" DSL_DRV_CRLF, 0));
1932	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1933	"DSL: PM counters dump : %10d bytes" DSL_DRV_CRLF, 0));
1934	}
1935	#endif /* INCLUDE_DSL_PM*/
1936
1937	#ifdef INCLUDE_DSL_CEOC
1938	if (pContext->CEOC)
1939	{
1940	dynamicMemUsageTotal += sizeof(DSL_CEOC_Context_t);
1941	}
1942	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1943	"DSL: CEOC context structure : %10d bytes" DSL_DRV_CRLF,
1944	pContext->CEOC ? (int)sizeof(DSL_CEOC_Context_t) : 0));
1945	#endif /* INCLUDE_DSL_CEOC*/
1946	/*
1947	Instance(s) Context dynamic memory usage
1948	*/
1949	DSL_DEBUG( DSL_DBG_PRN, (pContext, "DSL: Instance(s) Context dynamic memory usage" DSL_DRV_CRLF ));
1950	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1951	"DSL: opened context structure : %10d bytes" DSL_DRV_CRLF,
1952	(int)(pContext->pDevCtx->nUsageCount * sizeof(DSL_OpenContext_t))));
1953	dynamicMemUsageTotal += (pContext->pDevCtx->nUsageCount * sizeof(DSL_OpenContext_t));
1954
1955	/* Lock Open Context list*/
1956	if (DSL_DRV_MUTEX_LOCK(pContext->pDevCtx->openContextListMutex))
1957	{
1958	DSL_DEBUG( DSL_DBG_ERR,
1959	(DSL_NULL, "DSL[%02d]: ERROR - Couldn't lock Context List mutex!"DSL_DRV_CRLF,
1960	DSL_DEV_NUM(pContext)));
1961
1962	return DSL_ERR_SEMAPHORE_GET;
1963	}
1964
1965	/* Proceess dynamic memory allocated by the opened instances*/
1966	if (pOpenContextList != DSL_NULL)
1967	{
1968	pOpenContext = pOpenContextList;
1969	while(pOpenContext != DSL_NULL)
1970	{
1971	eventFifoTotal += (pOpenContext->eventFifo ? sizeof(DSL_FIFO) : 0);
1972	eventFifoBuffTotal += (pOpenContext->eventFifoBuf ?
1973	DSL_EVENT_FIFO_ELEMENT_COUNT * sizeof(DSL_EventStatusData_t) : 0);
1974	#ifdef INCLUDE_DSL_CEOC
1975	snmpFifoTotal += (pOpenContext->rxSnmpFifo ? sizeof(DSL_FIFO) : 0);
1976	snmpFifoBuffTotal += (pOpenContext->rxSnmpFifoBuf ?
1977	DSL_CEOC_RX_FIFO_ELEMENT_COUNT * sizeof(DSL_G997_SnmpData_t) : 0);
1978	#endif /* INCLUDE_DSL_CEOC*/
1979	pOpenContext = (DSL_OpenContext_t*)pOpenContext->pNext;
1980	}
1981	}
1982
1983	/* Unlock Open Context list*/
1984	DSL_DRV_MUTEX_UNLOCK(pContext->pDevCtx->openContextListMutex);
1985
1986	dynamicMemUsageTotal += eventFifoTotal;
1987	dynamicMemUsageTotal += eventFifoBuffTotal;
1988	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1989	"DSL: event FIFO : %10d bytes" DSL_DRV_CRLF,
1990	(int)(eventFifoTotal)));
1991	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1992	"DSL: event FIFO buffer : %10d bytes" DSL_DRV_CRLF,
1993	(int)(eventFifoBuffTotal)));
1994	#ifdef INCLUDE_DSL_CEOC
1995	dynamicMemUsageTotal += snmpFifoTotal;
1996	dynamicMemUsageTotal += snmpFifoBuffTotal;
1997	DSL_DEBUG( DSL_DBG_PRN, (pContext,
1998	"DSL: SNMP FIFO : %10d bytes" DSL_DRV_CRLF,
1999	(int)(eventFifoTotal)));
2000	DSL_DEBUG( DSL_DBG_PRN, (pContext,
2001	"DSL: SNMP FIFO buffer : %10d bytes" DSL_DRV_CRLF,
2002	(int)(eventFifoBuffTotal)));
2003	#endif /* INCLUDE_DSL_CEOC*/
2004	DSL_DEBUG( DSL_DBG_PRN, (pContext,
2005	"DSL: --------------" DSL_DRV_CRLF ));
2006	DSL_DEBUG( DSL_DBG_PRN, (pContext,
2007	"DSL: Total dynamic memory usage : %10d bytes" DSL_DRV_CRLF, dynamicMemUsageTotal));
2008	DSL_DEBUG( DSL_DBG_PRN, (pContext, "DSL: " DSL_DRV_CRLF ));
2009
2010	/* Fill Output structure*/
2011	pData->data.staticMemUsage = staticMemUsageTotal;
2012	pData->data.dynamicMemUsage = dynamicMemUsageTotal;
2013
2014	return nErrCode;
2015	}
2016	#endif /* INCLUDE_DSL_RESOURCE_STATISTICS*/
2017
2018	/*
2019	For a detailed description of the function, its arguments and return value
2020	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
2021	*/
2022	DSL_Error_t DSL_DRV_VersionInformationGet(
2023	DSL_IN DSL_Context_t *pContext,
2024	DSL_IN_OUT DSL_VersionInformation_t *pData)
2025	{
2026	DSL_Error_t nErrCode = DSL_SUCCESS;
2027	DSL_boolean_t bFirmwareReady = DSL_FALSE;
2028
2029	DSL_CHECK_POINTER(pContext, pData);
2030	DSL_CHECK_ERR_CODE();
2031
2032	DSL_DRV_MemSet(pData, 0, sizeof(DSL_VersionInformation_t));
2033	strncpy(pData->data.DSL_DriverVersionApi, DSL_CPE_API_PACKAGE_VERSION,
2034	MAX_INFO_STRING_LEN);
2035
2036	nErrCode = DSL_DRV_DEV_DriverVersionGet(pContext, pData->data.DSL_DriverVersionMeiBsp);
2037	if (nErrCode == DSL_SUCCESS)
2038	{
2039	nErrCode = DSL_DRV_DEV_ChipSetTypeGet(pContext, pData->data.DSL_ChipSetType);
2040	}
2041
2042	if (nErrCode >= DSL_SUCCESS)
2043	{
2044	DSL_CTX_READ_SCALAR(pContext, nErrCode, pDevCtx->bFirmwareReady, bFirmwareReady);
2045
2046	if (bFirmwareReady != DSL_FALSE)
2047	{
2048	nErrCode = DSL_DRV_DEV_FirmwareVersionGet(pContext,
2049	pData->data.DSL_ChipSetFWVersion);
2050
2051	if (nErrCode >= DSL_SUCCESS)
2052	{
2053	nErrCode = DSL_DRV_DEV_ChipHardwareVersionGet(pContext,
2054	pData->data.DSL_ChipSetHWVersion);
2055	}
2056	}
2057	else
2058	{
2059	strcpy(pData->data.DSL_ChipSetFWVersion, "n/a");
2060	strcpy(pData->data.DSL_ChipSetHWVersion, "n/a");
2061	}
2062	}
2063
2064	return (nErrCode != DSL_SUCCESS ? DSL_WRN_INCOMPLETE_RETURN_VALUES : nErrCode);
2065	}
2066
2067	/*
2068	For a detailed description of the function, its arguments and return value
2069	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
2070	*/
2071	DSL_Error_t DSL_DRV_LineStateGet(
2072	DSL_IN DSL_Context_t *pContext,
2073	DSL_IN_OUT DSL_LineState_t *pData)
2074	{
2075	DSL_Error_t nErrCode = DSL_SUCCESS;
2076
2077	DSL_DEBUG(DSL_DBG_MSG,
2078	(pContext, "DSL[%02d]: IN - DSL_DRV_LineStateGet"DSL_DRV_CRLF,
2079	DSL_DEV_NUM(pContext)));
2080
2081	DSL_CHECK_POINTER(pContext, pData);
2082	DSL_CHECK_ERR_CODE();
2083
2084	DSL_CTX_READ_SCALAR(pContext, nErrCode, nLineState, pData->data.nLineState);
2085
2086	DSL_DEBUG(DSL_DBG_MSG, (pContext, "DSL[%02d]: OUT - DSL_DRV_LineStateGet,"
2087	" nLineState=%08X, retCode=%d"DSL_DRV_CRLF, DSL_DEV_NUM(pContext),
2088	pData->data.nLineState,nErrCode));
2089
2090	return nErrCode;
2091	}
2092
2093	/*
2094	For a detailed description of the function, its arguments and return value
2095	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
2096	*/
2097	DSL_Error_t DSL_DRV_LineFeatureConfigSet(
2098	DSL_IN DSL_Context_t *pContext,
2099	DSL_IN_OUT DSL_LineFeature_t *pData)
2100	{
2101	DSL_Error_t nErrCode = DSL_SUCCESS, nRet = DSL_SUCCESS;
2102
2103	DSL_DEBUG(DSL_DBG_MSG,
2104	(pContext, "DSL[%02d]: IN - DSL_DRV_LineFeatureConfigSet"DSL_DRV_CRLF,
2105	DSL_DEV_NUM(pContext)));
2106
2107	DSL_CHECK_POINTER(pContext, pData);
2108	DSL_CHECK_ERR_CODE();
2109	DSL_CHECK_DIRECTION(pData->nDirection);
2110	DSL_CHECK_ERR_CODE();
2111
2112	#ifdef INCLUDE_DSL_CPE_API_VINAX
2113	/* Retransmission mode not supported for Vinax yet */
2114	pData->data.bReTxEnable = DSL_FALSE;
2115	nRet = DSL_WRN_CONFIG_PARAM_IGNORED;
2116	#else
2117	if (pData->nDirection == DSL_UPSTREAM)
2118	{
2119	/* Retransmission mode not supported for US yet */
2120	pData->data.bReTxEnable = DSL_FALSE;
2121	nRet = DSL_WRN_CONFIG_PARAM_IGNORED;
2122	}
2123	#endif /* INCLUDE_DSL_CPE_API_VINAX*/
2124
2125	if (pData->nDirection == DSL_UPSTREAM)
2126	{
2127	/* Fixed default value for the US direction*/
2128	pData->data.bTrellisEnable = DSL_TRUE;
2129	nRet = DSL_WRN_CONFIG_PARAM_IGNORED;
2130	}
2131
2132	DSL_CTX_WRITE(pContext, nErrCode, lineFeatureDataCfg[pData->nDirection], pData->data);
2133
2134	#ifdef INCLUDE_DSL_CPE_API_VINAX
2135	if (pData->nDirection == DSL_UPSTREAM)
2136	{
2137	DSL_CTX_WRITE(
2138	pContext, nErrCode,
2139	pDevCtx->data.deviceCfg.cfg.bVirtualNoiseSupportUs,
2140	pData->data.bVirtualNoiseSupport);
2141	}
2142	else
2143	{
2144	DSL_CTX_WRITE(
2145	pContext, nErrCode,
2146	pDevCtx->data.deviceCfg.cfg.bVirtualNoiseSupportDs,
2147	pData->data.bVirtualNoiseSupport);
2148	}
2149	#endif /* INCLUDE_DSL_CPE_API_VINAX*/
2150
2151	DSL_DEBUG(DSL_DBG_MSG,
2152	(pContext, "DSL[%02d]: OUT - DSL_DRV_LineFeatureConfigSet"DSL_DRV_CRLF,
2153	DSL_DEV_NUM(pContext)));
2154
2155	return nRet;
2156	}
2157
2158	/*
2159	For a detailed description of the function, its arguments and return value
2160	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
2161	*/
2162	#ifdef INCLUDE_DSL_CONFIG_GET
2163	DSL_Error_t DSL_DRV_LineFeatureConfigGet(
2164	DSL_IN DSL_Context_t *pContext,
2165	DSL_IN_OUT DSL_LineFeature_t *pData)
2166	{
2167	DSL_Error_t nErrCode = DSL_SUCCESS;
2168
2169	DSL_DEBUG(DSL_DBG_MSG,
2170	(pContext, "DSL[%02d]: IN - DSL_DRV_LineFeatureConfigGet"DSL_DRV_CRLF,
2171	DSL_DEV_NUM(pContext)));
2172
2173	DSL_CHECK_POINTER(pContext, pData);
2174	DSL_CHECK_ERR_CODE();
2175	DSL_CHECK_DIRECTION(pData->nDirection);
2176	DSL_CHECK_ERR_CODE();
2177
2178	DSL_CTX_READ(pContext, nErrCode, lineFeatureDataCfg[pData->nDirection], pData->data);
2179
2180	#ifdef INCLUDE_DSL_CPE_API_VINAX
2181	if (pData->nDirection == DSL_UPSTREAM)
2182	{
2183	DSL_CTX_READ(
2184	pContext, nErrCode,
2185	pDevCtx->data.deviceCfg.cfg.bVirtualNoiseSupportUs,
2186	pData->data.bVirtualNoiseSupport);
2187	}
2188	else
2189	{
2190	DSL_CTX_READ(
2191	pContext, nErrCode,
2192	pDevCtx->data.deviceCfg.cfg.bVirtualNoiseSupportDs,
2193	pData->data.bVirtualNoiseSupport);
2194	}
2195	#endif /* INCLUDE_DSL_CPE_API_VINAX*/
2196
2197	DSL_DEBUG(DSL_DBG_MSG,
2198	(pContext, "DSL[%02d]: OUT - DSL_DRV_LineFeatureConfigGet"DSL_DRV_CRLF,
2199	DSL_DEV_NUM(pContext)));
2200
2201	return nErrCode;
2202	}
2203	#endif /* INCLUDE_DSL_CONFIG_GET*/
2204
2205	/*
2206	For a detailed description of the function, its arguments and return value
2207	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
2208	*/
2209	DSL_Error_t DSL_DRV_LineFeatureStatusGet(
2210	DSL_IN DSL_Context_t *pContext,
2211	DSL_IN_OUT DSL_LineFeature_t *pData)
2212	{
2213	DSL_Error_t nErrCode = DSL_SUCCESS;
2214
2215	DSL_DEBUG(DSL_DBG_MSG,
2216	(pContext, "DSL[%02d]: IN - DSL_DRV_LineFeatureStatusGet"DSL_DRV_CRLF,
2217	DSL_DEV_NUM(pContext)));
2218
2219	DSL_CHECK_POINTER(pContext, pData);
2220	DSL_CHECK_ERR_CODE();
2221	DSL_CHECK_DIRECTION(pData->nDirection);
2222	DSL_CHECK_ERR_CODE();
2223
2224	DSL_CTX_READ(pContext, nErrCode, lineFeatureDataSts[pData->nDirection], pData->data);
2225
2226	DSL_DEBUG(DSL_DBG_MSG,
2227	(pContext, "DSL[%02d]: OUT - DSL_DRV_LineFeatureStatusGet"DSL_DRV_CRLF,
2228	DSL_DEV_NUM(pContext)));
2229
2230	return nErrCode;
2231	}
2232
2233	#ifdef INCLUDE_DSL_CPE_API_DANUBE
2234	/*
2235	For a detailed description of the function, its arguments and return value
2236	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
2237	*/
2238	DSL_Error_t DSL_DRV_InteropFeatureConfigSet(
2239	DSL_IN DSL_Context_t *pContext,
2240	DSL_IN_OUT DSL_InteropFeatureConfig_t *pData)
2241	{
2242	DSL_Error_t nErrCode = DSL_SUCCESS;
2243
2244	DSL_DEBUG(DSL_DBG_MSG,
2245	(pContext, "DSL[%02d]: IN - DSL_DRV_InteropFeatureConfigSet"DSL_DRV_CRLF,
2246	DSL_DEV_NUM(pContext)));
2247
2248	DSL_CHECK_POINTER(pContext, pData);
2249	DSL_CHECK_ERR_CODE();
2250
2251	if ((pData->data.nSnrMarginRebootCfg.nSnrMarginRebootMode < DSL_SNRM_REBOOT_AUTOMODE_API) \|\|
2252	(pData->data.nSnrMarginRebootCfg.nSnrMarginRebootMode > DSL_SNRM_REBOOT_LAST) \|\|
2253	(pData->data.nSnrMarginRebootCfg.nUserMinSnrMargin < -320) \|\|
2254	(pData->data.nSnrMarginRebootCfg.nUserMinSnrMargin > 310))
2255	{
2256	nErrCode = DSL_ERROR;
2257	}
2258
2259	if (nErrCode != DSL_ERROR)
2260	{
2261	DSL_CTX_WRITE(pContext, nErrCode, interopFeatureConfigData, pData->data);
2262	}
2263
2264	DSL_DEBUG(DSL_DBG_MSG,
2265	(pContext, "DSL[%02d]: OUT - DSL_DRV_InteropFeatureConfigSet"DSL_DRV_CRLF,
2266	DSL_DEV_NUM(pContext)));
2267
2268	return nErrCode;
2269	}
2270
2271	/*
2272	For a detailed description of the function, its arguments and return value
2273	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
2274	*/
2275	#ifdef INCLUDE_DSL_CONFIG_GET
2276	DSL_Error_t DSL_DRV_InteropFeatureConfigGet(
2277	DSL_IN DSL_Context_t *pContext,
2278	DSL_IN_OUT DSL_InteropFeatureConfig_t *pData)
2279	{
2280	DSL_Error_t nErrCode = DSL_SUCCESS;
2281
2282	DSL_DEBUG(DSL_DBG_MSG,
2283	(pContext, "DSL[%02d]: IN - DSL_DRV_InteropFeatureConfigGet"DSL_DRV_CRLF,
2284	DSL_DEV_NUM(pContext)));
2285
2286	DSL_CHECK_POINTER(pContext, pData);
2287	DSL_CHECK_ERR_CODE();
2288
2289	DSL_CTX_READ(pContext, nErrCode, interopFeatureConfigData, pData->data);
2290
2291	DSL_DEBUG(DSL_DBG_MSG,
2292	(pContext, "DSL[%02d]: OUT - DSL_DRV_InteropFeatureConfigGet"DSL_DRV_CRLF,
2293	DSL_DEV_NUM(pContext)));
2294
2295	return nErrCode;
2296	}
2297	#endif /* INCLUDE_DSL_CONFIG_GET*/
2298	#endif /* INCLUDE_DSL_CPE_API_DANUBE*/
2299
2300	DSL_Error_t DSL_DRV_SystemInterfaceConfigCheck(
2301	DSL_Context_t *pContext,
2302	DSL_SystemInterfaceConfigData_t *pData)
2303	{
2304	DSL_Error_t nErrCode = DSL_SUCCESS;
2305	DSL_CHECK_POINTER(pContext, pData);
2306	DSL_CHECK_ERR_CODE();
2307
2308	#if defined(INCLUDE_DSL_CPE_API_VINAX)
2309	switch(pData->nTcLayer)
2310	{
2311	case DSL_TC_HDLC:
2312	case DSL_TC_EFM:
2313	case DSL_TC_ATM:
2314	break;
2315	default:
2316	nErrCode = DSL_ERR_PARAM_RANGE;
2317	break;
2318	}
2319	#else
2320	if ((pData->nTcLayer < DSL_TC_UNKNOWN) \|\|
2321	(pData->nTcLayer >= DSL_TC_LAST))
2322	{
2323	nErrCode = DSL_ERR_PARAM_RANGE;
2324	}
2325	#endif /* defined(INCLUDE_DSL_CPE_API_VINAX)*/
2326
2327	if ((pData->nEfmTcConfigUs < DSL_EMF_TC_CLEANED) \|\|
2328	(pData->nEfmTcConfigUs >= DSL_EMF_TC_SHORT_PACKETS))
2329	{
2330	nErrCode = DSL_ERR_PARAM_RANGE;
2331	}
2332
2333	if ((pData->nEfmTcConfigDs < DSL_EMF_TC_CLEANED) \|\|
2334	(pData->nEfmTcConfigDs >= DSL_EMF_TC_SHORT_PACKETS))
2335	{
2336	nErrCode = DSL_ERR_PARAM_RANGE;
2337	}
2338
2339	if ((pData->nSystemIf < DSL_SYSTEMIF_UNKNOWN) \|\|
2340	(pData->nSystemIf >= DSL_SYSTEMIF_LAST))
2341	{
2342	nErrCode = DSL_ERR_PARAM_RANGE;
2343	}
2344
2345	return (nErrCode);
2346	}
2347
2348	/*
2349	For a detailed description please refer to the equivalent ioctl
2350	\ref DSL_FIO_SYSTEM_INTERFACE_CONFIG_SET
2351	*/
2352	#ifdef INCLUDE_DSL_SYSTEM_INTERFACE
2353	DSL_Error_t DSL_DRV_SystemInterfaceConfigSet(
2354	DSL_Context_t *pContext,
2355	DSL_SystemInterfaceConfig_t *pData)
2356	{
2357	DSL_Error_t nErrCode = DSL_SUCCESS;
2358	DSL_CHECK_POINTER(pContext, pData);
2359	DSL_CHECK_ERR_CODE();
2360
2361	DSL_DEBUG( DSL_DBG_MSG,
2362	(pContext, "DSL[%02d]: IN - DSL_SystemInterfaceConfigSet(nSystemIf=%#x, nTcLayer=%#x)" DSL_DRV_CRLF,
2363	DSL_DEV_NUM(pContext), pData->data.nSystemIf, pData->data.nTcLayer));
2364
2365
2366	nErrCode = DSL_DRV_SystemInterfaceConfigCheck(pContext, &(pData->data));
2367
2368	if (nErrCode >= DSL_SUCCESS)
2369	{
2370	nErrCode = DSL_DRV_DEV_SystemInterfaceConfigSet(pContext, pData);
2371	}
2372
2373	DSL_DEBUG( DSL_DBG_MSG,
2374	(pContext, "DSL[%02d]: OUT - DSL_SystemInterfaceConfigSet, retCode=%d"DSL_DRV_CRLF,
2375	DSL_DEV_NUM(pContext), nErrCode));
2376
2377	return (nErrCode);
2378	}
2379	#endif /* INCLUDE_DSL_SYSTEM_INTERFACE*/
2380
2381	/*
2382	For a detailed description please refer to the equivalent ioctl
2383	\ref DSL_FIO_SYSTEM_INTERFACE_CONFIG_GET
2384	*/
2385	#ifdef INCLUDE_DSL_CONFIG_GET
2386	#ifdef INCLUDE_DSL_SYSTEM_INTERFACE
2387	DSL_Error_t DSL_DRV_SystemInterfaceConfigGet(
2388	DSL_Context_t *pContext,
2389	DSL_SystemInterfaceConfig_t *pData)
2390	{
2391	DSL_Error_t nErrCode = DSL_SUCCESS;
2392	DSL_CHECK_POINTER(pContext, pData);
2393	DSL_CHECK_ERR_CODE();
2394
2395	DSL_DEBUG( DSL_DBG_MSG,
2396	(pContext, "DSL[%02d]: IN - DSL_DRV_SystemInterfaceConfigGet" DSL_DRV_CRLF,
2397	DSL_DEV_NUM(pContext)));
2398
2399	nErrCode = DSL_DRV_DEV_SystemInterfaceConfigGet(pContext, pData);
2400
2401	DSL_DEBUG( DSL_DBG_MSG,
2402	(pContext, "DSL[%02d]: OUT - DSL_DRV_SystemInterfaceConfigGet, retCode=%d"DSL_DRV_CRLF,
2403	DSL_DEV_NUM(pContext), nErrCode));
2404
2405	return (nErrCode);
2406	}
2407	#endif /* INCLUDE_DSL_SYSTEM_INTERFACE*/
2408	#endif /* INCLUDE_DSL_CONFIG_GET*/
2409
2410	/*
2411	For a detailed description please refer to the equivalent ioctl
2412	\ref DSL_FIO_SYSTEM_INTERFACE_STATUS_GET
2413	*/
2414	#ifdef INCLUDE_DSL_SYSTEM_INTERFACE
2415	DSL_Error_t DSL_DRV_SystemInterfaceStatusGet(
2416	DSL_Context_t *pContext,
2417	DSL_SystemInterfaceStatus_t *pData)
2418	{
2419	DSL_Error_t nErrCode = DSL_SUCCESS;
2420	DSL_CHECK_POINTER(pContext, pData);
2421	DSL_CHECK_ERR_CODE();
2422
2423	DSL_DEBUG( DSL_DBG_MSG,
2424	(pContext, "DSL[%02d]: IN - DSL_DRV_SystemInterfaceStatusGet" DSL_DRV_CRLF,
2425	DSL_DEV_NUM(pContext)));
2426
2427	nErrCode = DSL_DRV_DEV_SystemInterfaceStatusGet(pContext, pData);
2428
2429	DSL_DEBUG( DSL_DBG_MSG,
2430	(pContext, "DSL[%02d]: OUT - DSL_DRV_SystemInterfaceStatusGet, retCode=%d"DSL_DRV_CRLF,
2431	DSL_DEV_NUM(pContext), nErrCode));
2432
2433	return (nErrCode);
2434	}
2435	#endif /* INCLUDE_DSL_SYSTEM_INTERFACE*/
2436
2437	#if defined(INCLUDE_DSL_CPE_MISC_LINE_STATUS) \|\| defined(INCLUDE_DSL_CPE_API_DANUBE)
2438	DSL_Error_t DSL_DRV_AdslBandLimitsGet(
2439	DSL_Context_t *pContext,
2440	DSL_AccessDir_t nDirection,
2441	DSL_Band_t *pData)
2442	{
2443	DSL_Error_t nErrCode = DSL_SUCCESS;
2444	DSL_uint8_t XTSE[DSL_G997_NUM_XTSE_OCTETS] = {0};
2445	DSL_uint16_t nFirstToneIndex = 0, nLastToneIndex = 0;
2446
2447	DSL_CHECK_POINTER(pContext, pData);
2448	DSL_CHECK_DIRECTION(nDirection);
2449	DSL_CHECK_ERR_CODE();
2450
2451	/Get current xTSE octets/
2452	DSL_CTX_READ(pContext, nErrCode, xtseCurr, XTSE);
2453
2454	if (nDirection == DSL_DOWNSTREAM)
2455	{
2456	if ((XTSE[1-1] & (XTSE_1_03_A_1_NO \| XTSE_1_01_A_T1_413)) \|\|
2457	(XTSE[4-1] & XTSE_4_05_I_3_NO))
2458	{
2459	nFirstToneIndex = 32;
2460	nLastToneIndex = 255;
2461	}
2462	else if ((XTSE[1-1] & (XTSE_1_05_B_1_NO \| XTSE_1_02_C_TS_101388)) \|\|
2463	(XTSE[3-1] & XTSE_3_05_B_3_NO) \|\| (XTSE[5-1] & XTSE_5_07_M_3_NO) \|\|
2464	(XTSE[4-1] & XTSE_4_07_J_3_NO))
2465	{
2466	nFirstToneIndex = 64;
2467	nLastToneIndex = 255;
2468	}
2469	else if ((XTSE[3-1] & XTSE_3_03_A_3_NO))
2470	{
2471	nFirstToneIndex = 32;
2472	nLastToneIndex = 255;
2473	}
2474	else if ((XTSE[6-1] & (XTSE_6_01_A_5_NO \| XTSE_6_07_I_5_NO)))
2475	{
2476	nFirstToneIndex = 32;
2477	nLastToneIndex = 511;
2478	}
2479	else if ((XTSE[6-1] & XTSE_6_03_B_5_NO) \|\|
2480	(XTSE[7-1] & (XTSE_7_03_M_5_NO \| XTSE_7_01_J_5_NO)))
2481	{
2482	nFirstToneIndex = 64;
2483	nLastToneIndex = 511;
2484	}
2485	else if ((XTSE[5-1] & (XTSE_5_03_L_3_NO \| XTSE_5_04_L_3_NO)) \|\|
2486	(XTSE[2-1] & XTSE_2_01_A_2_NO))
2487	{
2488	nFirstToneIndex = 32;
2489	nLastToneIndex = 128;
2490	}
2491	else
2492	{
2493	nErrCode = DSL_ERROR;
2494	}
2495	}
2496	else
2497	{
2498	if ((XTSE[1-1] & (XTSE_1_03_A_1_NO \| XTSE_1_01_A_T1_413)) \|\|
2499	(XTSE[6-1] & XTSE_6_01_A_5_NO) \|\| (XTSE[2-1] & XTSE_2_01_A_2_NO) \|\|
2500	(XTSE[3-1] & XTSE_3_03_A_3_NO))
2501	{
2502	nFirstToneIndex = 6;
2503	nLastToneIndex = 31;
2504	}
2505	else if ((XTSE[1-1] & (XTSE_1_05_B_1_NO \| XTSE_1_02_C_TS_101388)) \|\|
2506	(XTSE[3-1] & XTSE_3_05_B_3_NO) \|\| (XTSE[6-1] & XTSE_6_03_B_5_NO))
2507	{
2508	nFirstToneIndex = 28;
2509	nLastToneIndex = 63;
2510	}
2511	else if ((XTSE[4-1] & XTSE_4_05_I_3_NO) \|\| (XTSE[6-1] & XTSE_6_07_I_5_NO))
2512	{
2513	nFirstToneIndex = 1;
2514	nLastToneIndex = 31;
2515	}
2516	else if ((XTSE[5-1] & XTSE_5_03_L_3_NO))
2517	{
2518	/* Mask1: 6..24; Mask2: 6..14.*/
2519	nFirstToneIndex = 6;
2520	nLastToneIndex = 24;
2521	}
2522	else if ((XTSE[5-1] & XTSE_5_04_L_3_NO))
2523	{
2524	/* Mask2: 6..14.*/
2525	nFirstToneIndex = 6;
2526	nLastToneIndex = 14;
2527	}
2528	else if ((XTSE[5-1] & XTSE_5_07_M_3_NO) \|\| (XTSE[7-1] & XTSE_7_03_M_5_NO) \|\|
2529	(XTSE[4-1] & XTSE_4_07_J_3_NO) \|\| (XTSE[7-1] & XTSE_7_01_J_5_NO))
2530	{
2531	DSL_Band_t AnnexMJBandData;
2532
2533	/* Get Annex M/J mask specific Band Limits*/
2534	nErrCode = DSL_DRV_DEV_Annex_M_J_UsBandBordersStatusGet(
2535	pContext, &AnnexMJBandData);
2536
2537	if (nErrCode == DSL_SUCCESS)
2538	{
2539	nFirstToneIndex = AnnexMJBandData.nFirstToneIndex;
2540	nLastToneIndex = AnnexMJBandData.nLastToneIndex;
2541	}
2542	}
2543	else
2544	{
2545	nErrCode = DSL_ERROR;
2546	}
2547	}
2548
2549	pData->nFirstToneIndex = nFirstToneIndex;
2550	pData->nLastToneIndex = nLastToneIndex;
2551
2552	return nErrCode;
2553	}
2554	#endif /* defined(INCLUDE_DSL_CPE_MISC_LINE_STATUS) \|\| defined(INCLUDE_DSL_CPE_API_DANUBE)*/
2555
2556	#ifdef INCLUDE_DSL_CPE_MISC_LINE_STATUS
2557	/*
2558	For a detailed description of the function, its arguments and return value
2559	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
2560	*/
2561	DSL_Error_t DSL_DRV_BandBorderStatusGet(
2562	DSL_Context_t *pContext,
2563	DSL_BandBorderStatus_t *pData)
2564	{
2565	DSL_Error_t nErrCode = DSL_SUCCESS;
2566	DSL_CHECK_POINTER(pContext, pData);
2567	DSL_CHECK_ERR_CODE();
2568	DSL_CHECK_DIRECTION(pData->nDirection);
2569	DSL_CHECK_ERR_CODE();
2570
2571	DSL_DEBUG( DSL_DBG_MSG,
2572	(pContext, "DSL[%02d]: IN - DSL_DRV_BandBorderStatusGet" DSL_DRV_CRLF,
2573	DSL_DEV_NUM(pContext)));
2574
2575	/* Call device specific implementation*/
2576	nErrCode = DSL_DRV_DEV_BandBorderStatusGet(pContext, pData);
2577
2578	DSL_DEBUG( DSL_DBG_MSG,
2579	(pContext, "DSL[%02d]: OUT - DSL_DRV_BandBorderStatusGet, retCode=%d"DSL_DRV_CRLF,
2580	DSL_DEV_NUM(pContext), nErrCode));
2581
2582	return (nErrCode);
2583	}
2584
2585	/*
2586	For a detailed description of the function, its arguments and return value
2587	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
2588	*/
2589	DSL_Error_t DSL_DRV_MiscLineStatusGet(
2590	DSL_Context_t *pContext,
2591	DSL_MiscLineStatus_t *pData)
2592	{
2593	DSL_Error_t nErrCode = DSL_SUCCESS;
2594	DSL_CHECK_POINTER(pContext, pData);
2595	DSL_CHECK_ERR_CODE();
2596
2597	DSL_DEBUG( DSL_DBG_MSG,
2598	(pContext, "DSL[%02d]: IN - DSL_DRV_MiscLineStatusGet" DSL_DRV_CRLF,
2599	DSL_DEV_NUM(pContext)));
2600
2601	/* Call device specific implementation*/
2602	nErrCode = DSL_DRV_DEV_MiscLineStatusGet(pContext, pData);
2603
2604	DSL_DEBUG( DSL_DBG_MSG,
2605	(pContext, "DSL[%02d]: OUT - DSL_DRV_MiscLineStatusGet, retCode=%d"DSL_DRV_CRLF,
2606	DSL_DEV_NUM(pContext), nErrCode));
2607
2608	return (nErrCode);
2609	}
2610	#endif /* INCLUDE_DSL_CPE_MISC_LINE_STATUS*/
2611
2612	/*
2613	For a detailed description of the function, its arguments and return value
2614	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
2615	*/
2616	DSL_Error_t DSL_DRV_LineOptionsConfigSet(
2617	DSL_Context_t *pContext,
2618	DSL_LineOptionsConfig_t *pData)
2619	{
2620	DSL_Error_t nErrCode = DSL_SUCCESS;
2621	DSL_CHECK_POINTER(pContext, pData);
2622	DSL_CHECK_ERR_CODE();
2623
2624	DSL_DEBUG( DSL_DBG_MSG,
2625	(pContext, "DSL[%02d]: IN - DSL_DRV_LineOptionsConfigSet" DSL_DRV_CRLF,
2626	DSL_DEV_NUM(pContext)));
2627
2628	/* Check configuration option validity*/
2629	switch (pData->data.nConfigSelector)
2630	{
2631	case DSL_OPT_NOISE_MARGIN_DELTA_DS:
2632	#ifdef INCLUDE_DSL_CPE_API_VINAX
2633	if ((pData->data.nConfigValue < -50) \|\| (pData->data.nConfigValue > 50))
2634	{
2635	DSL_DEBUG( DSL_DBG_ERR,
2636	(pContext, "DSL[%02d]: ERROR - Noise Margin DS out of range [-50..50]!"
2637	DSL_DRV_CRLF, DSL_DEV_NUM(pContext)));
2638	nErrCode = DSL_ERR_INVALID_PARAMETER;
2639	}
2640	#else
2641	nErrCode = DSL_ERR_NOT_SUPPORTED_BY_DEVICE;
2642	#endif /* INCLUDE_DSL_CPE_API_VINAX*/
2643	break;
2644
2645	case DSL_ERASURE_DECODING_TYPE_DS:
2646	case DSL_TRUST_ME_BIT:
2647	case DSL_INBAND_SPECTRAL_SHAPING_US:
2648	#ifdef INCLUDE_DSL_CPE_API_DANUBE
2649	if (pData->data.nConfigValue & 0xFFFFFFFE)
2650	{
2651	nErrCode = DSL_ERR_INVALID_PARAMETER;
2652	}
2653	#else
2654	nErrCode = DSL_ERR_NOT_SUPPORTED_BY_DEVICE;
2655	#endif /* INCLUDE_DSL_CPE_API_DANUBE*/
2656	break;
2657
2658	default:
2659	DSL_DEBUG( DSL_DBG_ERR,
2660	(pContext, "DSL[%02d]: ERROR - Invalid nConfigSelector=%d specified!" DSL_DRV_CRLF,
2661	DSL_DEV_NUM(pContext), pData->data.nConfigSelector));
2662	nErrCode = DSL_ERR_INVALID_PARAMETER;
2663	break;
2664	}
2665
2666	if (nErrCode >= DSL_SUCCESS)
2667	{
2668	/* Set Line Configuration Option*/
2669	DSL_CTX_WRITE(pContext, nErrCode,
2670	lineOptionsConfig[pData->data.nConfigSelector],
2671	pData->data.nConfigValue);
2672	}
2673
2674	DSL_DEBUG( DSL_DBG_MSG,
2675	(pContext, "DSL[%02d]: OUT - DSL_DRV_LineOptionsConfigSet, retCode=%d"DSL_DRV_CRLF,
2676	DSL_DEV_NUM(pContext), nErrCode));
2677
2678	return nErrCode;
2679	}
2680
2681	/*
2682	For a detailed description of the function, its arguments and return value
2683	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
2684	*/
2685	#ifdef INCLUDE_DSL_CONFIG_GET
2686	DSL_Error_t DSL_DRV_LineOptionsConfigGet(
2687	DSL_Context_t *pContext,
2688	DSL_LineOptionsConfig_t *pData)
2689	{
2690	DSL_Error_t nErrCode = DSL_SUCCESS;
2691	DSL_CHECK_POINTER(pContext, pData);
2692	DSL_CHECK_ERR_CODE();
2693
2694	DSL_DEBUG( DSL_DBG_MSG,
2695	(pContext, "DSL[%02d]: IN - DSL_DRV_LineOptionsConfigGet" DSL_DRV_CRLF,
2696	DSL_DEV_NUM(pContext)));
2697
2698	switch (pData->data.nConfigSelector)
2699	{
2700	case DSL_OPT_NOISE_MARGIN_DELTA_DS:
2701	#ifndef INCLUDE_DSL_CPE_API_VINAX
2702	nErrCode = DSL_ERR_NOT_SUPPORTED_BY_DEVICE;
2703	#endif /* INCLUDE_DSL_CPE_API_VINAX*/
2704	break;
2705
2706	case DSL_ERASURE_DECODING_TYPE_DS:
2707	case DSL_TRUST_ME_BIT:
2708	case DSL_INBAND_SPECTRAL_SHAPING_US:
2709	#ifndef INCLUDE_DSL_CPE_API_DANUBE
2710	nErrCode = DSL_ERR_NOT_SUPPORTED_BY_DEVICE;
2711	#endif /* INCLUDE_DSL_CPE_API_DANUBE*/
2712	break;
2713
2714	default :
2715	DSL_DEBUG( DSL_DBG_ERR,
2716	(pContext, "DSL[%02d]: ERROR - Invalid nConfigSelector=%d specified!" DSL_DRV_CRLF,
2717	DSL_DEV_NUM(pContext), pData->data.nConfigSelector));
2718
2719	nErrCode = DSL_ERR_INVALID_PARAMETER;
2720	break;
2721	}
2722
2723	if (nErrCode >= DSL_SUCCESS)
2724	{
2725	/* Get Line Configuration Option*/
2726	DSL_CTX_READ(pContext, nErrCode,
2727	lineOptionsConfig[pData->data.nConfigSelector],
2728	pData->data.nConfigValue);
2729	}
2730
2731	DSL_DEBUG( DSL_DBG_MSG,
2732	(pContext, "DSL[%02d]: OUT - DSL_DRV_LineOptionsConfigGet, retCode=%d"DSL_DRV_CRLF,
2733	DSL_DEV_NUM(pContext), nErrCode));
2734
2735	return nErrCode;
2736	}
2737	#endif /* INCLUDE_DSL_CONFIG_GET*/
2738
2739	#ifdef INCLUDE_DSL_CPE_API_DANUBE
2740	#ifdef INCLUDE_DEVICE_EXCEPTION_CODES
2741	DSL_Error_t DSL_DBG_LastExceptionCodesGet(
2742	DSL_Context_t *pContext,
2743	DSL_DBG_LastExceptionCodes_t *pData)
2744	{
2745	DSL_Error_t nErrCode = DSL_SUCCESS;
2746	DSL_CHECK_POINTER(pContext, pData);
2747	DSL_CHECK_ERR_CODE();
2748
2749	DSL_DEBUG( DSL_DBG_MSG,
2750	(pContext, "DSL[%02d]: IN - DSL_DBG_LastExceptionCodesGet" DSL_DRV_CRLF,
2751	DSL_DEV_NUM(pContext)));
2752
2753	/* Get Last Exception Codes*/
2754	DSL_CTX_READ(pContext, nErrCode, LastExceptionCodes, pData->data);
2755
2756	DSL_DEBUG( DSL_DBG_MSG,
2757	(pContext, "DSL[%02d]: OUT - DSL_DBG_LastExceptionCodesGet, retCode=%d"DSL_DRV_CRLF,
2758	DSL_DEV_NUM(pContext), nErrCode));
2759
2760	return nErrCode;
2761	}
2762	#endif /* INCLUDE_DEVICE_EXCEPTION_CODES*/
2763	#endif /* INCLUDE_DSL_CPE_API_DANUBE*/
2764
2765	#if (INCLUDE_DSL_CPE_API_VDSL_SUPPORT == 1)
2766	/*
2767	For a detailed description of the function, its arguments and return value
2768	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
2769	*/
2770	DSL_Error_t DSL_DRV_LinePathCounterTotalGet(
2771	DSL_IN DSL_Context_t *pContext,
2772	DSL_IN_OUT DSL_LinePathCounterTotal_t *pData )
2773	{
2774	DSL_Error_t nErrCode = DSL_SUCCESS;
2775
2776	DSL_CHECK_POINTER(pContext, pData);
2777	DSL_CHECK_ERR_CODE();
2778	DSL_CHECK_CHANNEL_RANGE(pData->nChannel);
2779	DSL_CHECK_ERR_CODE();
2780
2781	DSL_DEBUG(DSL_DBG_MSG,
2782	(pContext, "DSL[%02d]: IN - DSL_DRV_LinePathCounterTotalGet"DSL_DRV_CRLF,
2783	DSL_DEV_NUM(pContext)));
2784
2785	/* Call device specific implementation*/
2786	nErrCode = DSL_DRV_DEV_LinePathCounterTotalGet(
2787	pContext, pData->nChannel, &(pData->data));
2788
2789	DSL_DEBUG(DSL_DBG_MSG,
2790	(pContext, "DSL[%02d]: OUT - DSL_DRV_LinePathCounterTotalGet"DSL_DRV_CRLF,
2791	DSL_DEV_NUM(pContext)));
2792
2793	return nErrCode;
2794	}
2795
2796	/*
2797	For a detailed description of the function, its arguments and return value
2798	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
2799	*/
2800	DSL_Error_t DSL_DRV_DataPathCounterTotalGet(
2801	DSL_IN DSL_Context_t *pContext,
2802	DSL_IN_OUT DSL_DataPathCounterTotal_t *pData )
2803	{
2804	DSL_Error_t nErrCode = DSL_SUCCESS;
2805
2806	DSL_CHECK_POINTER(pContext, pData);
2807	DSL_CHECK_ERR_CODE();
2808	DSL_CHECK_CHANNEL_RANGE(pData->nChannel);
2809	DSL_CHECK_ERR_CODE();
2810
2811	DSL_DEBUG(DSL_DBG_MSG,
2812	(pContext, "DSL[%02d]: IN - DSL_DRV_DataPathCounterTotalGet"DSL_DRV_CRLF,
2813	DSL_DEV_NUM(pContext)));
2814
2815	/* Call device specific implementation*/
2816	nErrCode = DSL_DRV_DEV_DataPathCounterTotalGet(
2817	pContext, pData->nChannel, &(pData->data));
2818
2819	DSL_DEBUG(DSL_DBG_MSG,
2820	(pContext, "DSL[%02d]: OUT - DSL_DRV_DataPathCounterTotalGet"DSL_DRV_CRLF,
2821	DSL_DEV_NUM(pContext)));
2822
2823	return nErrCode;
2824	}
2825
2826	/*
2827	For a detailed description please refer to the equivalent ioctl
2828	\ref DSL_FIO_LOW_LEVEL_CONFIGURATION_SET
2829	*/
2830	DSL_Error_t DSL_DRV_LowLevelConfigurationSet(
2831	DSL_Context_t *pContext,
2832	DSL_LowLevelConfiguration_t *pData)
2833	{
2834	DSL_Error_t nErrCode = DSL_SUCCESS;
2835	DSL_CHECK_POINTER(pContext, pData);
2836	DSL_CHECK_ERR_CODE();
2837
2838	DSL_DEBUG( DSL_DBG_MSG,
2839	(pContext, "DSL[%02d]: IN - DSL_DRV_LowLevelConfigurationSet" DSL_DRV_CRLF,
2840	DSL_DEV_NUM(pContext)));
2841
2842	/* Call device specific implementation*/
2843	nErrCode = DSL_DRV_DEV_LowLevelConfigurationSet(pContext, &(pData->data));
2844
2845	DSL_DEBUG( DSL_DBG_MSG,
2846	(pContext, "DSL[%02d]: OUT - DSL_DRV_LowLevelConfigurationSet, retCode=%d"DSL_DRV_CRLF,
2847	DSL_DEV_NUM(pContext), nErrCode));
2848
2849	return (nErrCode);
2850	}
2851
2852	/*
2853	For a detailed description please refer to the equivalent ioctl
2854	\ref DSL_FIO_LOW_LEVEL_CONFIGURATION_GET
2855	*/
2856	DSL_Error_t DSL_DRV_LowLevelConfigurationGet(
2857	DSL_Context_t *pContext,
2858	DSL_LowLevelConfiguration_t *pData)
2859	{
2860	DSL_Error_t nErrCode = DSL_SUCCESS;
2861	DSL_CHECK_POINTER(pContext, pData);
2862	DSL_CHECK_ERR_CODE();
2863
2864	DSL_DEBUG( DSL_DBG_MSG,
2865	(pContext, "DSL[%02d]: IN - DSL_DRV_LowLevelConfigurationGet" DSL_DRV_CRLF,
2866	DSL_DEV_NUM(pContext)));
2867
2868	/* Get Low Level Configuration from the VINAX device context*/
2869	DSL_CTX_READ(pContext, nErrCode, pDevCtx->data.deviceCfg.cfg, pData->data);
2870
2871	DSL_DEBUG( DSL_DBG_MSG,
2872	(pContext, "DSL[%02d]: OUT - DSL_DRV_LowLevelConfigurationGet, retCode=%d"DSL_DRV_CRLF,
2873	DSL_DEV_NUM(pContext), nErrCode));
2874
2875	return (nErrCode);
2876	}
2877
2878	/*
2879	For a detailed description of the function, its arguments and return value
2880	please refer to the description in the header file 'drv_dsl_cpe_api.h'
2881	*/
2882	#ifdef INCLUDE_DSL_G997_LINE_INVENTORY
2883	DSL_Error_t DSL_DRV_AuxLineInventoryGet(
2884	DSL_Context_t *pContext,
2885	DSL_AuxLineInventory_t *pData)
2886	{
2887	DSL_Error_t nErrCode = DSL_SUCCESS;
2888	DSL_CHECK_POINTER(pContext, pData);
2889	DSL_CHECK_ERR_CODE();
2890	DSL_CHECK_ATU_DIRECTION(pData->nDirection);
2891	DSL_CHECK_ERR_CODE();
2892
2893	DSL_DEBUG( DSL_DBG_MSG,
2894	(pContext, "DSL[%02d]: IN - DSL_DRV_AuxLineInventoryGet(nDirection=%s)" DSL_DRV_CRLF ,
2895	DSL_DEV_NUM(pContext), (pData->nDirection==DSL_NEAR_END?"NE":"FE")));
2896
2897	if (DSL_DRV_VNX_FwFeatureCheck(pContext, DSL_VNX_FW_VDSL2))
2898	{
2899	if (pData->nDirection == DSL_NEAR_END)
2900	{
2901	DSL_CTX_READ(pContext, nErrCode, auxInventoryNe, pData->data);
2902	}
2903	else
2904	{
2905	DSL_CTX_READ(pContext, nErrCode, auxInventoryFe, pData->data);
2906	}
2907	}
2908	else
2909	{
2910	nErrCode = DSL_ERR_NOT_SUPPORTED_BY_FIRMWARE;
2911	}
2912
2913	DSL_DEBUG( DSL_DBG_MSG,
2914	(pContext, "DSL[%02d]: OUT - DSL_DRV_AuxLineInventoryGet, retCode=%d"DSL_DRV_CRLF,
2915	DSL_DEV_NUM(pContext), nErrCode));
2916
2917	return (nErrCode);
2918	}
2919	#endif /* INCLUDE_DSL_G997_LINE_INVENTORY*/
2920
2921	/*
2922	For a detailed description please refer to the equivalent ioctl
2923	\ref DSL_FIO_BAND_PLAN_STATUS_GET
2924	*/
2925	DSL_Error_t DSL_DRV_BandPlanStatusGet(
2926	DSL_Context_t *pContext,
2927	DSL_BandPlanStatus_t *pData)
2928	{
2929	DSL_Error_t nErrCode = DSL_SUCCESS;
2930	DSL_CHECK_POINTER(pContext, pData);
2931	DSL_CHECK_ERR_CODE();
2932
2933	DSL_DEBUG( DSL_DBG_MSG,
2934	(pContext, "DSL[%02d]: IN - DSL_DRV_BandPlanStatusGet" DSL_DRV_CRLF,
2935	DSL_DEV_NUM(pContext)));
2936
2937	/* Call VINAX device specific implementation*/
2938	nErrCode = DSL_DRV_VNX_BandPlanStatusGet(pContext,&(pData->data));
2939
2940	DSL_DEBUG( DSL_DBG_MSG,
2941	(pContext, "DSL[%02d]: OUT - DSL_DRV_BandPlanStatusGet, retCode=%d"DSL_DRV_CRLF,
2942	DSL_DEV_NUM(pContext), nErrCode));
2943
2944	return (nErrCode);
2945	}
2946
2947	/*
2948	For a detailed description please refer to the equivalent ioctl
2949	\ref DSL_FIO_BAND_PLAN_SUPPORT_GET
2950	*/
2951	DSL_Error_t DSL_DRV_BandPlanSupportedGet(
2952	DSL_Context_t *pContext,
2953	DSL_BandPlanSupport_t *pData)
2954	{
2955	DSL_Error_t nErrCode = DSL_SUCCESS;
2956	DSL_CHECK_POINTER(pContext, pData);
2957	DSL_CHECK_ERR_CODE();
2958
2959	DSL_DEBUG( DSL_DBG_MSG,
2960	(pContext, "DSL[%02d]: IN - DSL_DRV_BandPlanSupportedGet" DSL_DRV_CRLF,
2961	DSL_DEV_NUM(pContext)));
2962
2963	/* Call VINAX device specific implementation*/
2964	nErrCode = DSL_DRV_VNX_BandPlanSupportedGet(pContext, &(pData->data));
2965
2966	DSL_DEBUG( DSL_DBG_MSG,
2967	(pContext, "DSL[%02d]: OUT - DSL_DRV_BandPlanSupportedGet, retCode=%d"DSL_DRV_CRLF,
2968	DSL_DEV_NUM(pContext), nErrCode));
2969
2970	return (nErrCode);
2971	}
2972
2973	DSL_Error_t DSL_DRV_EfmMacConfigCheck(
2974	DSL_Context_t *pContext,
2975	DSL_EFM_MacConfigData_t *pData)
2976	{
2977	DSL_Error_t nErrCode = DSL_SUCCESS;
2978	DSL_CHECK_POINTER(pContext, pData);
2979	DSL_CHECK_ERR_CODE();
2980
2981	/* Check nEfmSpeed parameter validity*/
2982	if (pData->nEfmSpeed < DSL_EFM_SPEED_100 \|\|
2983	pData->nEfmSpeed >= DSL_EFM_SPEED_LAST)
2984	{
2985	DSL_DEBUG( DSL_DBG_ERR,
2986	(pContext, "DSL[%02d]: ERROR - Wrong EfmSpeed=%d specified" DSL_DRV_CRLF,
2987	DSL_DEV_NUM(pContext), pData->nEfmSpeed));
2988	nErrCode = DSL_ERR_INVALID_PARAMETER;
2989	}
2990
2991	/* Check nEfmDuplex parameter validity*/
2992	if (pData->nEfmDuplex < DSL_EFM_DUPLEX_FULL \|\|
2993	pData->nEfmDuplex >= DSL_EFM_DUPLEX_LAST)
2994	{
2995	DSL_DEBUG( DSL_DBG_ERR,
2996	(pContext, "DSL[%02d]: ERROR - Wrong nEfmDuplex=%d specified" DSL_DRV_CRLF,
2997	DSL_DEV_NUM(pContext), pData->nEfmDuplex));
2998	nErrCode = DSL_ERR_INVALID_PARAMETER;
2999	}
3000
3001	/* Check nFlowControl parameter validity*/
3002	if (pData->nFlowControl < DSL_EFM_FLOWCTRL_OFF \|\|
3003	pData->nFlowControl >= DSL_EFM_FLOWCTRL_LAST)
3004	{
3005	DSL_DEBUG( DSL_DBG_ERR,
3006	(pContext, "DSL[%02d]: ERROR - Wrong nFlowControl=%d specified" DSL_DRV_CRLF,
3007	DSL_DEV_NUM(pContext), pData->nFlowControl));
3008	nErrCode = DSL_ERR_INVALID_PARAMETER;
3009	}
3010
3011	/* Check nAutoNegotiation parameter validity*/
3012	if (pData->nAutoNegotiation < DSL_EFM_AUTONEG_OFF \|\|
3013	pData->nAutoNegotiation >= DSL_EFM_AUTONEG_LAST)
3014	{
3015	DSL_DEBUG( DSL_DBG_ERR,
3016	(pContext, "DSL[%02d]: ERROR - Wrong nAutoNegotiation=%d specified" DSL_DRV_CRLF,
3017	DSL_DEV_NUM(pContext), pData->nAutoNegotiation));
3018	nErrCode = DSL_ERR_INVALID_PARAMETER;
3019	}
3020
3021	/* Check nMaxFrameSize parameter validity*/
3022	if (pData->nMaxFrameSize < 1518 \|\| pData->nMaxFrameSize > 1580)
3023	{
3024	DSL_DEBUG( DSL_DBG_ERR,
3025	(pContext, "DSL[%02d]: ERROR - Wrong nMaxFrameSize=%d specified" DSL_DRV_CRLF,
3026	DSL_DEV_NUM(pContext), pData->nMaxFrameSize));
3027	nErrCode = DSL_ERR_INVALID_PARAMETER;
3028	}
3029
3030	return nErrCode;
3031	}
3032
3033	/*
3034	For a detailed description please refer to the equivalent ioctl
3035	\ref DSL_FIO_EFM_MAC_CONFIG_SET
3036	*/
3037	DSL_Error_t DSL_DRV_EfmMacConfigSet(
3038	DSL_Context_t *pContext,
3039	DSL_EFM_MacConfig_t *pData)
3040	{
3041	DSL_Error_t nErrCode = DSL_SUCCESS;
3042	DSL_CHECK_POINTER(pContext, pData);
3043	DSL_CHECK_ERR_CODE();
3044	DSL_CHECK_ATU_DIRECTION(pData->nDirection);
3045	DSL_CHECK_ERR_CODE();
3046
3047	DSL_DEBUG( DSL_DBG_MSG,
3048	(pContext, "DSL[%02d]: IN - DSL_DRV_EfmMacConfigSet(nDirection=%d)" DSL_DRV_CRLF,
3049	DSL_DEV_NUM(pContext), pData->nDirection));
3050
3051	nErrCode = DSL_DRV_EfmMacConfigCheck(pContext, &(pData->data));
3052
3053	/* Copy EFM MAC Configuration data to internal VINAX device context*/
3054	if (nErrCode == DSL_SUCCESS)
3055	{
3056	DSL_CTX_WRITE(pContext, nErrCode, pDevCtx->data.deviceCfg.MacCfg, pData->data);
3057	}
3058
3059	DSL_DEBUG( DSL_DBG_MSG,
3060	(pContext, "DSL[%02d]: OUT - DSL_EfmMacConfigSet, retCode=%d"DSL_DRV_CRLF,
3061	DSL_DEV_NUM(pContext), nErrCode));
3062
3063	return (nErrCode);
3064	}
3065
3066	/*
3067	For a detailed description please refer to the equivalent ioctl
3068	\ref DSL_FIO_EFM_MAC_CONFIG_GET
3069	*/
3070	#ifdef INCLUDE_DSL_CONFIG_GET
3071	DSL_Error_t DSL_DRV_EfmMacConfigGet(
3072	DSL_Context_t *pContext,
3073	DSL_EFM_MacConfig_t *pData)
3074	{
3075	DSL_Error_t nErrCode = DSL_SUCCESS;
3076	DSL_CHECK_POINTER(pContext, pData);
3077	DSL_CHECK_ERR_CODE();
3078	DSL_CHECK_ATU_DIRECTION(pData->nDirection);
3079	DSL_CHECK_ERR_CODE();
3080
3081	DSL_DEBUG( DSL_DBG_MSG,
3082	(pContext, "DSL[%02d]: IN - DSL_DRV_EfmMacConfigGet(nDirection=%d)" DSL_DRV_CRLF,
3083	DSL_DEV_NUM(pContext), pData->nDirection));
3084
3085	/* Get EFM MAC Configuration data from the internal VINAX device context*/
3086	DSL_CTX_READ(pContext, nErrCode, pDevCtx->data.deviceCfg.MacCfg, pData->data);
3087
3088	DSL_DEBUG( DSL_DBG_MSG,
3089	(pContext, "DSL[%02d]: OUT - DSL_EfmMacConfigGet, retCode=%d"DSL_DRV_CRLF,
3090	DSL_DEV_NUM(pContext), nErrCode));
3091
3092	return (nErrCode);
3093	}
3094	#endif /* INCLUDE_DSL_CONFIG_GET*/
3095
3096	/*
3097	For a detailed description please refer to the equivalent ioctl
3098	\ref DSL_FIO_UTOPIA_BUS_WIDTH_CONFIG_SET
3099	*/
3100	DSL_Error_t DSL_DRV_UtopiaBusWidthConfigSet(
3101	DSL_Context_t *pContext,
3102	DSL_UtopiaBusWidthConfig_t *pData)
3103	{
3104	DSL_Error_t nErrCode = DSL_SUCCESS;
3105	DSL_CHECK_POINTER(pContext, pData);
3106	DSL_CHECK_ERR_CODE();
3107
3108	DSL_DEBUG( DSL_DBG_MSG,
3109	(pContext, "DSL[%02d]: IN - DSL_UtopiaBusWidthConfigSet" DSL_DRV_CRLF,
3110	DSL_DEV_NUM(pContext)));
3111
3112	/* Call device specific implementation*/
3113	nErrCode = DSL_DRV_DEV_UtopiaBusWidthConfigSet(pContext, &(pData->data));
3114
3115	DSL_DEBUG( DSL_DBG_MSG,
3116	(pContext, "DSL[%02d]: OUT - DSL_UtopiaBusWidthConfigSet, retCode=%d"DSL_DRV_CRLF,
3117	DSL_DEV_NUM(pContext), nErrCode));
3118
3119	return (nErrCode);
3120	}
3121
3122	/*
3123	For a detailed description please refer to the equivalent ioctl
3124	\ref DSL_FIO_UTOPIA_BUS_WIDTH_CONFIG_GET
3125	*/
3126	#ifdef INCLUDE_DSL_CONFIG_GET
3127	DSL_Error_t DSL_DRV_UtopiaBusWidthConfigGet(
3128	DSL_Context_t *pContext,
3129	DSL_UtopiaBusWidthConfig_t *pData)
3130	{
3131	DSL_Error_t nErrCode = DSL_SUCCESS;
3132	DSL_CHECK_POINTER(pContext, pData);
3133	DSL_CHECK_ERR_CODE();
3134
3135	DSL_DEBUG( DSL_DBG_MSG,
3136	(pContext, "DSL[%02d]: IN - DSL_UtopiaBusWidthConfigGet" DSL_DRV_CRLF,
3137	DSL_DEV_NUM(pContext)));
3138
3139	/* Call device specific implementation*/
3140	nErrCode = DSL_DRV_DEV_UtopiaBusWidthConfigGet(pContext, &(pData->data));
3141
3142	DSL_DEBUG( DSL_DBG_MSG,
3143	(pContext, "DSL[%02d]: OUT - DSL_UtopiaBusWidthConfigGet, retCode=%d"DSL_DRV_CRLF,
3144	DSL_DEV_NUM(pContext), nErrCode));
3145
3146	return (nErrCode);
3147	}
3148	#endif /* INCLUDE_DSL_CONFIG_GET*/
3149
3150	/*
3151	For a detailed description please refer to the equivalent ioctl
3152	\ref DSL_FIO_UTOPIA_ADDRESS_CONFIG_SET
3153	*/
3154	DSL_Error_t DSL_DRV_UtopiaAddressConfigSet(
3155	DSL_Context_t *pContext,
3156	DSL_PhyAddressConfig_t *pData)
3157	{
3158	DSL_Error_t nErrCode = DSL_SUCCESS;
3159	DSL_CHECK_POINTER(pContext, pData);
3160	DSL_CHECK_ERR_CODE();
3161
3162	DSL_DEBUG( DSL_DBG_MSG,
3163	(pContext, "DSL[%02d]: IN - DSL_UtopiaAddressConfigSet" DSL_DRV_CRLF,
3164	DSL_DEV_NUM(pContext)));
3165
3166	/* Call device specific implementation*/
3167	nErrCode = DSL_DRV_DEV_UtopiaAddressConfigSet(pContext,pData->nChannel,&(pData->data));
3168
3169	DSL_DEBUG( DSL_DBG_MSG,
3170	(pContext, "DSL[%02d]: OUT - DSL_UtopiaAddressConfigSet, retCode=%d"DSL_DRV_CRLF,
3171	DSL_DEV_NUM(pContext), nErrCode));
3172
3173	return (nErrCode);
3174	}
3175
3176	/*
3177	For a detailed description please refer to the equivalent ioctl
3178	\ref DSL_FIO_UTOPIA_ADDRESS_CONFIG_GET
3179	*/
3180	#ifdef INCLUDE_DSL_CONFIG_GET
3181	DSL_Error_t DSL_DRV_UtopiaAddressConfigGet(
3182	DSL_Context_t *pContext,
3183	DSL_PhyAddressConfig_t *pData)
3184	{
3185	DSL_Error_t nErrCode = DSL_SUCCESS;
3186	DSL_CHECK_POINTER(pContext, pData);
3187	DSL_CHECK_ERR_CODE();
3188
3189	DSL_DEBUG( DSL_DBG_MSG,
3190	(pContext, "DSL[%02d]: IN - DSL_UtopiaAddressConfigGet" DSL_DRV_CRLF,
3191	DSL_DEV_NUM(pContext)));
3192
3193	/* Call device specific implementation*/
3194	nErrCode = DSL_DRV_DEV_UtopiaAddressConfigGet(pContext,pData->nChannel,&(pData->data));
3195
3196	DSL_DEBUG( DSL_DBG_MSG,
3197	(pContext, "DSL[%02d]: OUT - DSL_UtopiaAddressConfigGet, retCode=%d"DSL_DRV_CRLF,
3198	DSL_DEV_NUM(pContext), nErrCode));
3199
3200	return (nErrCode);
3201	}
3202	#endif /* INCLUDE_DSL_CONFIG_GET*/
3203	#endif /* #if (INCLUDE_DSL_CPE_API_VDSL_SUPPORT == 1)*/
3204
3205	/*
3206	For a detailed description please refer to the equivalent ioctl
3207	\ref DSL_FIO_EVENT_STATUS_MASK_CONFIG_SET
3208	*/
3209	DSL_Error_t DSL_DRV_EventStatusMaskConfigSet(
3210	DSL_OpenContext_t *pOpenCtx,
3211	DSL_IN DSL_Context_t *pContext,
3212	DSL_IN_OUT DSL_EventStatusMask_t *pData)
3213	{
3214	DSL_Error_t nErrCode = DSL_SUCCESS, nRet = DSL_SUCCESS;
3215	DSL_uint32_t nEventMask;
3216	DSL_boolean_t bFwEv = DSL_FALSE;
3217
3218	DSL_CHECK_POINTER(pContext, pData);
3219	DSL_CHECK_ERR_CODE();
3220
3221	DSL_DEBUG(DSL_DBG_MSG,
3222	(pContext, "DSL[%02d]: IN - DSL_EventStatusMaskConfigSet"DSL_DRV_CRLF,
3223	DSL_DEV_NUM(pContext)));
3224
3225	if(DSL_DRV_MUTEX_LOCK(pOpenCtx->eventMutex))
3226	{
3227	DSL_DEBUG( DSL_DBG_ERR,
3228	(pContext, "DSL[%02d]: Couldn't lock event mutex"DSL_DRV_CRLF,
3229	DSL_DEV_NUM(pContext)));
3230	return DSL_ERROR;
3231	}
3232
3233	/* Check if the event handling is activated for this instance*/
3234	if (pOpenCtx->bEventActivation)
3235	{
3236	/* Get current event mask*/
3237	nEventMask = pOpenCtx->nEventMask;
3238
3239	switch(pData->data.nEventType)
3240	{
3241	case DSL_EVENT_S_FIRMWARE_REQUEST:
3242	DSL_CTX_READ_SCALAR(pContext, nErrCode, bFirmwareEventAssigned, bFwEv);
3243
3244	if (pData->data.bMask)
3245	{
3246	/* Mask (disable) DSL_EVENT_S_FIRMWARE_REQUEST event*/
3247	nEventMask \|= DSL_EVENT2MASK(DSL_EVENT_S_FIRMWARE_REQUEST);
3248	if (bFwEv != DSL_FALSE)
3249	{
3250	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, bFirmwareEventAssigned, DSL_FALSE);
3251	}
3252	}
3253	else
3254	{
3255	if (bFwEv != DSL_FALSE)
3256	{
3257	DSL_DEBUG(DSL_DBG_ERR,
3258	(DSL_NULL, "DSL[%02d]: Could not assign more than 1 applications "
3259	"which handle firmware request event! Event mask will "
3260	"be reduced"DSL_DRV_CRLF, DSL_DEV_NUM(pContext)));
3261	/* Mask (disable) DSL_EVENT_S_FIRMWARE_REQUEST event*/
3262	nEventMask \|= DSL_EVENT2MASK(DSL_EVENT_S_FIRMWARE_REQUEST);
3263	nRet = DSL_ERR_EVENTS_NOT_ACTIVE;
3264	}
3265	else
3266	{
3267	/* Unmask (enable) DSL_EVENT_S_FIRMWARE_REQUEST event*/
3268	nEventMask &= ~DSL_EVENT2MASK(DSL_EVENT_S_FIRMWARE_REQUEST);
3269
3270	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, bFirmwareEventAssigned, DSL_TRUE);
3271	}
3272	}
3273	break;
3274	case DSL_EVENT_S_LINIT_FAILURE:
3275	case DSL_EVENT_S_LINE_STATE:
3276	case DSL_EVENT_S_LINE_POWERMANAGEMENT_STATE:
3277	case DSL_EVENT_S_CHANNEL_DATARATE:
3278	case DSL_EVENT_S_FIRMWARE_ERROR:
3279	case DSL_EVENT_S_INIT_READY:
3280	case DSL_EVENT_S_FE_INVENTORY_AVAILABLE:
3281	case DSL_EVENT_S_SYSTEM_STATUS:
3282	case DSL_EVENT_S_PM_SYNC:
3283	case DSL_EVENT_S_LINE_TRANSMISSION_STATUS:
3284	case DSL_EVENT_S_SHOWTIME_LOGGING:
3285	case DSL_EVENT_S_SNMP_MESSAGE_AVAILABLE:
3286	case DSL_EVENT_S_SYSTEM_INTERFACE_STATUS:
3287	case DSL_EVENT_S_FIRMWARE_DOWNLOAD_STATUS:
3288	case DSL_EVENT_S_AUTOBOOT_STATUS:
3289	if (pData->data.bMask)
3290	{
3291	nEventMask \|= DSL_EVENT2MASK(pData->data.nEventType);
3292	}
3293	else
3294	{
3295	/* Unmask (enable) specified event*/
3296	nEventMask &= ~DSL_EVENT2MASK(pData->data.nEventType);
3297	}
3298	break;
3299	default:
3300	DSL_DEBUG(DSL_DBG_ERR,
3301	(pContext, "DSL[%02d]: ERROR - unknown status event(0x%x)"DSL_DRV_CRLF,
3302	DSL_DEV_NUM(pContext), pData->data.nEventType));
3303	nErrCode = DSL_ERROR;
3304	break;
3305	}
3306
3307	if (nErrCode != DSL_ERROR)
3308	{
3309	/* Update event mask*/
3310	pOpenCtx->nEventMask = nEventMask;
3311	}
3312	}
3313	else
3314	{
3315	nErrCode = DSL_ERR_EVENTS_NOT_ACTIVE;
3316	}
3317
3318	if (nErrCode == DSL_SUCCESS)
3319	{
3320	nErrCode = nRet;
3321	}
3322
3323	DSL_DRV_MUTEX_UNLOCK(pOpenCtx->eventMutex);
3324
3325	DSL_DEBUG(DSL_DBG_MSG,
3326	(pContext, "DSL[%02d]: OUT - DSL_EventStatusMaskConfigSet, "
3327	"retCode(%d)"DSL_DRV_CRLF, DSL_DEV_NUM(pContext), nErrCode));
3328
3329	return nErrCode;
3330	}
3331
3332	/*
3333	For a detailed description please refer to the equivalent ioctl
3334	\ref DSL_FIO_EVENT_STATUS_MASK_CONFIG_GET
3335	*/
3336	#ifdef INCLUDE_DSL_CONFIG_GET
3337	DSL_Error_t DSL_DRV_EventStatusMaskConfigGet(
3338	DSL_OpenContext_t *pOpenCtx,
3339	DSL_IN DSL_Context_t *pContext,
3340	DSL_IN_OUT DSL_EventStatusMask_t *pData)
3341	{
3342	DSL_Error_t nErrCode = DSL_SUCCESS;
3343	DSL_uint32_t nEventMask;
3344
3345	DSL_CHECK_POINTER(pContext, pData);
3346	DSL_CHECK_ERR_CODE();
3347
3348	DSL_DEBUG(DSL_DBG_MSG,
3349	(pContext, "DSL[%02d]: IN - DSL_EventStatusMaskConfigGet"DSL_DRV_CRLF,
3350	DSL_DEV_NUM(pContext)));
3351
3352	if(DSL_DRV_MUTEX_LOCK(pOpenCtx->eventMutex))
3353	{
3354	DSL_DEBUG( DSL_DBG_ERR,
3355	(pContext, "DSL[%02d]: Couldn't lock event mutex"DSL_DRV_CRLF,
3356	DSL_DEV_NUM(pContext)));
3357	return DSL_ERROR;
3358	}
3359
3360	/* Check if the event handling is activated for this instance*/
3361	if (pOpenCtx->bEventActivation)
3362	{
3363	/* Get current event mask*/
3364	nEventMask = pOpenCtx->nEventMask;
3365
3366	switch(pData->data.nEventType)
3367	{
3368	case DSL_EVENT_S_FIRMWARE_REQUEST:
3369	case DSL_EVENT_S_LINIT_FAILURE:
3370	case DSL_EVENT_S_LINE_STATE:
3371	case DSL_EVENT_S_LINE_POWERMANAGEMENT_STATE:
3372	case DSL_EVENT_S_CHANNEL_DATARATE:
3373	case DSL_EVENT_S_FIRMWARE_ERROR:
3374	case DSL_EVENT_S_INIT_READY:
3375	case DSL_EVENT_S_FE_INVENTORY_AVAILABLE:
3376	case DSL_EVENT_S_SYSTEM_STATUS:
3377	case DSL_EVENT_S_PM_SYNC:
3378	case DSL_EVENT_S_LINE_TRANSMISSION_STATUS:
3379	case DSL_EVENT_S_SHOWTIME_LOGGING:
3380	case DSL_EVENT_S_SNMP_MESSAGE_AVAILABLE:
3381	case DSL_EVENT_S_SYSTEM_INTERFACE_STATUS:
3382	case DSL_EVENT_S_FIRMWARE_DOWNLOAD_STATUS:
3383	case DSL_EVENT_S_AUTOBOOT_STATUS:
3384	pData->data.bMask = nEventMask & DSL_EVENT2MASK(pData->data.nEventType) ?
3385	DSL_TRUE : DSL_FALSE;
3386	break;
3387	default:
3388	DSL_DEBUG(DSL_DBG_ERR,
3389	(pContext, "DSL[%02d]: ERROR - unknown status event(0x%x)"DSL_DRV_CRLF,
3390	DSL_DEV_NUM(pContext), pData->data.nEventType));
3391	nErrCode = DSL_ERROR;
3392	break;
3393	}
3394	}
3395	else
3396	{
3397	nErrCode = DSL_ERR_EVENTS_NOT_ACTIVE;
3398	}
3399
3400	DSL_DRV_MUTEX_UNLOCK(pOpenCtx->eventMutex);
3401
3402	DSL_DEBUG(DSL_DBG_MSG,
3403	(pContext, "DSL[%02d]: OUT - DSL_EventStatusMaskConfigSet, "
3404	"retCode(%d)"DSL_DRV_CRLF, DSL_DEV_NUM(pContext), nErrCode));
3405
3406	return nErrCode;
3407	}
3408	#endif /* INCLUDE_DSL_CONFIG_GET*/
3409
3410	/*
3411	For a detailed description of the function, its arguments and return value
3412	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
3413	*/
3414	#ifdef INCLUDE_DSL_FRAMING_PARAMETERS
3415	DSL_Error_t DSL_DRV_FramingParameterStatusGet(
3416	DSL_IN DSL_Context_t *pContext,
3417	DSL_IN_OUT DSL_FramingParameterStatus_t *pData)
3418	{
3419	DSL_Error_t nErrCode = DSL_SUCCESS;
3420
3421	DSL_CHECK_POINTER(pContext, pData);
3422	DSL_CHECK_ERR_CODE();
3423
3424	DSL_DEBUG(DSL_DBG_MSG,
3425	(pContext, "DSL[%02d]: IN - DSL_DRV_FramingParameterStatusGet"DSL_DRV_CRLF,
3426	DSL_DEV_NUM(pContext)));
3427
3428	/* Call device specific stuff*/
3429	nErrCode = DSL_DRV_DEV_FramingParameterStatusGet(pContext, pData);
3430
3431	DSL_DEBUG(DSL_DBG_MSG,
3432	(pContext, "DSL[%02d]: OUT - DSL_DRV_FramingParameterStatusGet, "
3433	"retCode(%d)"DSL_DRV_CRLF, DSL_DEV_NUM(pContext), nErrCode));
3434
3435	return nErrCode;
3436	}
3437	#endif /* INCLUDE_DSL_FRAMING_PARAMETERS*/
3438
3439	/*
3440	For a detailed description of the function, its arguments and return value
3441	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
3442	*/
3443	#ifndef DSL_DEBUG_DISABLE
3444	DSL_Error_t DSL_DRV_DBG_ModuleLevelSet(
3445	DSL_IN DSL_Context_t *pContext,
3446	DSL_IN DSL_DBG_ModuleLevel_t *pData)
3447	{
3448	DSL_Error_t nErrCode = DSL_SUCCESS;
3449	DSL_int_t i = 0;
3450	DSL_boolean_t bModOk = DSL_FALSE, bLvlOk = DSL_FALSE;
3451	DSL_debugLevelEntry_t *pDbgEntry = DSL_NULL;
3452	DSL_debugLevelEntry_t *pDbgLvlNames = DSL_NULL;
3453
3454	DSL_CHECK_POINTER(pContext, pData);
3455	DSL_CHECK_ERR_CODE();
3456
3457	/* Check if debug module number is valid */
3458	pDbgEntry = &DSL_g_dbgLvl[1];
3459	if ( (pData->data.nDbgModule >= DSL_DBG_LAST_BLOCK) \|\|
3460	(pData->data.nDbgModule == DSL_DBG_NO_BLOCK) )
3461	{
3462	bModOk = DSL_FALSE;
3463	DSL_DEBUG_SET_ERROR(DSL_ERROR);
3464	DSL_DEBUG( DSL_DBG_ERR, (pContext,
3465	"DSL[%02d]: DSL_DRV_DBG_ModuleLevelSet - invalid debug module number specified:"
3466	DSL_DRV_CRLF, DSL_DEV_NUM(pContext)));
3467	DSL_DEBUG( DSL_DBG_PRN, (pContext,
3468	" nDbgModules:" DSL_DRV_CRLF ) );
3469
3470	for (i = 1; i < (DSL_int_t)DSL_DBG_LAST_BLOCK; i++, pDbgEntry++)
3471	{
3472	DSL_DEBUG( DSL_DBG_PRN,
3473	(pContext, " %d: %s" DSL_DRV_CRLF , i, pDbgEntry->pcName) );
3474	}
3475	}
3476	else
3477	{
3478	bModOk = DSL_TRUE;
3479	}
3480
3481	/* Check if debug level is valid */
3482	pDbgLvlNames = &DSL_g_dbgLvlNames[0];
3483	for (i = 0; i < DSL_g_dbgLvlNumber; i++, pDbgLvlNames++)
3484	{
3485	if (pDbgLvlNames->nDbgLvl == pData->data.nDbgLevel)
3486	{
3487	/* debug level found */
3488	bLvlOk = DSL_TRUE;
3489	break;
3490	}
3491	}
3492	if ( (bLvlOk == DSL_FALSE) && (i == DSL_g_dbgLvlNumber) )
3493	{
3494	/* debug level NOT valid */
3495	DSL_DEBUG_SET_ERROR(DSL_ERROR);
3496	DSL_DEBUG( DSL_DBG_ERR,
3497	(pContext, "DSL[%02d]: DSL_DRV_DBG_ModuleLevelSet - invalid debug level specified:" DSL_DRV_CRLF,
3498	DSL_DEV_NUM(pContext)));
3499	DSL_DEBUG( DSL_DBG_PRN,
3500	(pContext, " nDbgLevels:" DSL_DRV_CRLF ) );
3501	pDbgLvlNames = &DSL_g_dbgLvlNames[0];
3502	for (i = 0; i < DSL_g_dbgLvlNumber; i++, pDbgLvlNames++)
3503	{
3504	DSL_DEBUG( DSL_DBG_PRN,
3505	(pContext, " 0x%02X: %s" DSL_DRV_CRLF ,
3506	pDbgLvlNames->nDbgLvl, pDbgLvlNames->pcName) );
3507	}
3508	}
3509
3510	if ( (bModOk == DSL_TRUE) && (bLvlOk == DSL_TRUE) )
3511	{
3512	/* Set new debug level for specified module */
3513	DSL_g_dbgLvl[pData->data.nDbgModule].nDbgLvl = pData->data.nDbgLevel;
3514	DSL_DEBUG( DSL_DBG_LOCAL,
3515	(pContext, "DSL[%02d]: new debug level: %s = %s - 0x%02X" DSL_DRV_CRLF ,
3516	DSL_DEV_NUM(pContext), DSL_g_dbgLvl[pData->data.nDbgModule].pcName,
3517	pDbgLvlNames->pcName,
3518	pData->data.nDbgLevel) );
3519	}
3520	else
3521	{
3522	nErrCode = DSL_ERROR;
3523	}
3524
3525	return nErrCode;
3526	}
3527	#endif /* DSL_DEBUG_DISABLE */
3528
3529	/*
3530	For a detailed description of the function, its arguments and return value
3531	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
3532	*/
3533	#ifndef DSL_DEBUG_DISABLE
3534	DSL_Error_t DSL_DRV_DBG_ModuleLevelGet(
3535	DSL_IN DSL_Context_t *pContext,
3536	DSL_IN_OUT DSL_DBG_ModuleLevel_t *pData)
3537	{
3538	DSL_Error_t nErrCode = DSL_SUCCESS;
3539	DSL_boolean_t bLvlOk = DSL_FALSE;
3540	DSL_debugLevelEntry_t *pDbgEntry = DSL_NULL;
3541	DSL_debugLevelEntry_t *pDbgLvlNames = DSL_NULL;
3542	DSL_int_t i = 0;
3543
3544	DSL_CHECK_POINTER(pContext, pData);
3545	DSL_CHECK_ERR_CODE();
3546
3547	/* Check if debug module number is valid */
3548	pDbgEntry = &DSL_g_dbgLvl[1];
3549	if ( (pData->data.nDbgModule >= DSL_DBG_LAST_BLOCK) \|\|
3550	(pData->data.nDbgModule == DSL_DBG_NO_BLOCK) )
3551	{
3552	nErrCode = DSL_ERROR;
3553	DSL_DEBUG_SET_ERROR(nErrCode);
3554	DSL_DEBUG( DSL_DBG_ERR,
3555	(pContext, "DSL[%02d]: DSL_DRV_DBG_ModuleLevelGet - "
3556	"invalid debug module number specified:" DSL_DRV_CRLF,
3557	DSL_DEV_NUM(pContext)));
3558	DSL_DEBUG( DSL_DBG_PRN,
3559	(pContext, " nDbgModules:" DSL_DRV_CRLF ) );
3560	for (i = 1; i < (DSL_int_t)DSL_DBG_LAST_BLOCK; i++, pDbgEntry++)
3561	{
3562	DSL_DEBUG( DSL_DBG_PRN,
3563	(pContext, " %d: %s" DSL_DRV_CRLF , i, pDbgEntry->pcName) );
3564	}
3565	}
3566	else
3567	{
3568	pData->data.nDbgLevel = DSL_g_dbgLvl[pData->data.nDbgModule].nDbgLvl;
3569
3570	pDbgLvlNames = &DSL_g_dbgLvlNames[0];
3571	for (i = 0; i < DSL_g_dbgLvlNumber; i++, pDbgLvlNames++)
3572	{
3573	if (pDbgLvlNames->nDbgLvl == pData->data.nDbgLevel)
3574	{
3575	/* debug level found */
3576	bLvlOk = DSL_TRUE;
3577	DSL_DEBUG( DSL_DBG_LOCAL,
3578	(pContext, "DSL[%02d]: actual debug level: %s = %s - 0x%02X" DSL_DRV_CRLF,
3579	DSL_DEV_NUM(pContext), DSL_g_dbgLvl[pData->data.nDbgModule].pcName,
3580	pDbgLvlNames->pcName,
3581	pData->data.nDbgLevel) );
3582	break;
3583	}
3584	}
3585
3586	if (bLvlOk == DSL_FALSE)
3587	{
3588	DSL_DEBUG( DSL_DBG_LOCAL,
3589	(pContext, "DSL[%02d]: actual debug level: %s = 0x%02X" DSL_DRV_CRLF,
3590	DSL_DEV_NUM(pContext), DSL_g_dbgLvl[pData->data.nDbgModule].pcName,
3591	pData->data.nDbgLevel) );
3592	}
3593	}
3594
3595	return nErrCode;
3596	}
3597	#endif /* DSL_DEBUG_DISABLE*/
3598
3599	/*
3600	For a detailed description of the function, its arguments and return value
3601	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
3602	*/
3603	DSL_Error_t DSL_DRV_DBG_DeviceMessageSend(
3604	DSL_IN DSL_Context_t *pContext,
3605	DSL_IN_OUT DSL_DeviceMessage_t *pMsg)
3606	{
3607	DSL_Error_t nErrCode = DSL_SUCCESS;
3608
3609	DSL_CHECK_POINTER(pContext, pMsg);
3610	DSL_CHECK_ERR_CODE();
3611
3612	DSL_DEBUG( DSL_DBG_MSG,
3613	(pContext, "DSL[%02d]: IN - DSL_DRV_DBG_DeviceMessageSend"DSL_DRV_CRLF,
3614	DSL_DEV_NUM(pContext)));
3615
3616	nErrCode = DSL_DRV_DEV_DBG_DeviceMessageSend(pContext, &(pMsg->data));
3617
3618	DSL_DEBUG( DSL_DBG_MSG,
3619	(pContext, "DSL[%02d]: OUT - DSL_DRV_DBG_DeviceMessageSend, retCode(%d)"DSL_DRV_CRLF,
3620	DSL_DEV_NUM(pContext), nErrCode));
3621
3622	return nErrCode;
3623	}
3624
3625	#ifndef DSL_DEBUG_DISABLE
3626	#if defined(INCLUDE_DSL_CPE_API_DANUBE)
3627	DSL_Error_t DSL_DRV_DBG_DebugFeatureConfigSet(
3628	DSL_IN DSL_Context_t *pContext,
3629	DSL_IN DSL_DBG_DebugFeatureConfig_t *pData)
3630	{
3631	DSL_Error_t nErrCode = DSL_SUCCESS;
3632	#if defined(INCLUDE_DSL_DATA_LED_SIMULATOR)
3633	DSL_uint16_t nLedCtrl = 0;
3634	#endif /* defined(INCLUDE_DSL_DATA_LED_SIMULATOR)*/
3635	DSL_CHECK_POINTER(pContext, pData);
3636	DSL_CHECK_ERR_CODE();
3637
3638	switch (pData->data.nConfigSelector)
3639	{
3640	#if defined(INCLUDE_DSL_DATA_LED_SIMULATOR)
3641	case DSL_DFC_DATA_LED_BEHAVIOR:
3642	switch ((DSL_DataLedBehavior_t)pData->data.nFeatureValue)
3643	{
3644	case DSL_DATA_LED_OFF:
3645	case DSL_DATA_LED_ON:
3646	if (pContext->nDataLedSimControlData.nLedBehavior == DAL_DATA_LED_BLINK)
3647	{
3648	DSL_DEBUG( DSL_DBG_ERR,
3649	(pContext, "DSL[%02d]: ERROR - Stop blinking first!"DSL_DRV_CRLF,
3650	DSL_DEV_NUM(pContext)));
3651	nErrCode = DSL_ERROR;
3652	break;
3653	}
3654
3655	pContext->nDataLedSimControlData.nLedBehavior =
3656	(DSL_DataLedBehavior_t)pData->data.nFeatureValue == DSL_DATA_LED_OFF ?
3657	DSL_DATA_LED_OFF : DSL_DATA_LED_ON;
3658	DSL_DRV_WAKEUP_EVENT(pContext->dataLedSimEvent);
3659
3660	/* OFF/ON*/
3661	/* use GPIO9 for TR68 data led off. */
3662	nLedCtrl = (DSL_DataLedBehavior_t)pData->data.nFeatureValue == DSL_DATA_LED_OFF ? off : on;
3663	if (DSL_DRV_DANUBE_CmvWrite(pContext, DSL_CMV_GROUP_INFO,
3664	DSL_CMV_ADDRESS_INFO_GPIO_CONTROL, 5, 1, &nLedCtrl) != DSL_SUCCESS)
3665	{
3666	DSL_DEBUG( DSL_DBG_ERR,
3667	(pContext, "DSL[%02d]: ERROR - CMV INFO 91 5 write failed!"DSL_DRV_CRLF,
3668	DSL_DEV_NUM(pContext)));
3669	nErrCode = DSL_ERROR;
3670	}
3671	break;
3672
3673	case DAL_DATA_LED_BLINK:
3674	pContext->nDataLedSimControlData.nLedBehavior = DAL_DATA_LED_BLINK;
3675	DSL_DRV_WAKEUP_EVENT(pContext->dataLedSimEvent);
3676	break;
3677
3678	case DAL_DATA_LED_STOP_BLINK:
3679	pContext->nDataLedSimControlData.nLedBehavior = DAL_DATA_LED_STOP_BLINK;
3680	DSL_DRV_WAKEUP_EVENT(pContext->dataLedSimEvent);
3681	break;
3682
3683	default:
3684	DSL_DEBUG( DSL_DBG_ERR,
3685	(pContext, "DSL[%02d]: ERROR - Unsupported Data LED behavior (%d) specified!"DSL_DRV_CRLF,
3686	DSL_DEV_NUM(pContext), pData->data.nFeatureValue));
3687	nErrCode = DSL_ERROR;
3688
3689	break;
3690	}
3691	break;
3692
3693	case DSL_DFC_DATA_LED_BLINK_TIMEOUT:
3694	if (pData->data.nFeatureValue == 0)
3695	{
3696	pContext->nDataLedSimControlData.nBlinkTimeout = 1000;
3697	}
3698	else if (pData->data.nFeatureValue > 10000)
3699	{
3700	pContext->nDataLedSimControlData.nBlinkTimeout = 10000;
3701	DSL_DEBUG( DSL_DBG_WRN,
3702	(pContext, "DSL[%02d]: WARNING - nBlinkTimeout truncated to 10000 ms!"DSL_DRV_CRLF,
3703	DSL_DEV_NUM(pContext)));
3704
3705	nErrCode = DSL_WRN_CONFIG_PARAM_TRUNCATED;
3706	}
3707	else
3708	{
3709	pContext->nDataLedSimControlData.nBlinkTimeout =
3710	pData->data.nFeatureValue;
3711	}
3712	break;
3713	#endif /* defined(INCLUDE_DSL_DATA_LED_SIMULATOR)*/
3714	default:
3715	DSL_DEBUG( DSL_DBG_ERR,
3716	(pContext, "DSL[%02d]: ERROR - Unsupported Debug Feature selector (%d)!"DSL_DRV_CRLF,
3717	DSL_DEV_NUM(pContext), pData->data.nConfigSelector));
3718	nErrCode = DSL_ERROR;
3719	break;
3720	}
3721
3722	return (nErrCode);
3723	}
3724
3725	#ifdef INCLUDE_DSL_CONFIG_GET
3726	DSL_Error_t DSL_DRV_DBG_DebugFeatureConfigGet(
3727	DSL_IN DSL_Context_t *pContext,
3728	DSL_IN DSL_DBG_DebugFeatureConfig_t *pData)
3729	{
3730	DSL_Error_t nErrCode = DSL_SUCCESS;
3731	DSL_CHECK_POINTER(pContext, pData);
3732	DSL_CHECK_ERR_CODE();
3733
3734	switch (pData->data.nConfigSelector)
3735	{
3736	#if defined(INCLUDE_DSL_DATA_LED_SIMULATOR)
3737	case DSL_DFC_DATA_LED_BEHAVIOR:
3738	pData->data.nFeatureValue =
3739	(DSL_int32_t)pContext->nDataLedSimControlData.nLedBehavior;
3740	break;
3741
3742	case DSL_DFC_DATA_LED_BLINK_TIMEOUT:
3743	pData->data.nFeatureValue =
3744	(DSL_int32_t)pContext->nDataLedSimControlData.nBlinkTimeout;
3745	break;
3746	#endif /* defined(INCLUDE_DSL_DATA_LED_SIMULATOR)*/
3747
3748	default:
3749	DSL_DEBUG( DSL_DBG_ERR,
3750	(pContext, "DSL[%02d]: ERROR - Unsupported Debug Feature selector (%d)!"DSL_DRV_CRLF,
3751	DSL_DEV_NUM(pContext), pData->data.nConfigSelector));
3752	nErrCode = DSL_ERROR;
3753	break;
3754	}
3755
3756	return (nErrCode);
3757	}
3758	#endif /* INCLUDE_DSL_CONFIG_GET*/
3759	#endif /* defined(INCLUDE_DSL_CPE_API_DANUBE)*/
3760	#endif /* DSL_DEBUG_DISABLE*/
3761
3762	/*
3763	For a detailed description of the function, its arguments and return value
3764	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
3765	*/
3766	DSL_Error_t DSL_DRV_InitDataPrepare(
3767	DSL_Context_t *pContext,
3768	DSL_boolean_t bIsInKernel,
3769	DSL_Init_t *pInit)
3770	{
3771	DSL_G997_LineInventoryNeData_t *pInv = DSL_NULL;
3772	DSL_Error_t nErrCode = DSL_SUCCESS;
3773
3774	DSL_CHECK_POINTER(pContext, pInit);
3775	DSL_CHECK_ERR_CODE();
3776
3777	#ifndef INCLUDE_FW_REQUEST_SUPPORT
3778	/* Store FW in the DSL CPE internal memory*/
3779	nErrCode = DSL_DRV_FwStore(
3780	pContext, bIsInKernel,
3781	(DSL_char_t*)pInit->data.pFirmware, pInit->data.nFirmwareSize,
3782	(DSL_char_t*)pInit->data.pFirmware2, pInit->data.nFirmwareSize2);
3783
3784	if( nErrCode != DSL_SUCCESS)
3785	{
3786	return nErrCode;
3787	}
3788	#endif /* INCLUDE_FW_REQUEST_SUPPORT*/
3789
3790	if (pInit->data.pInventory != DSL_NULL)
3791	{
3792	pInv = DSL_DRV_PMalloc(sizeof(DSL_G997_LineInventoryNeData_t));
3793	if (pInv == DSL_NULL)
3794	{
3795	nErrCode = DSL_ERR_MEMORY;
3796	}
3797	else
3798	{
3799	DSL_IoctlMemCpyFrom(bIsInKernel, pInv, pInit->data.pInventory,
3800	sizeof(DSL_G997_LineInventoryNeData_t));
3801	pInit->data.pInventory = pInv;
3802	}
3803	}
3804
3805	#ifdef INCLUDE_DSL_CPE_API_VINAX
3806	if (nErrCode == DSL_SUCCESS)
3807	{
3808	nErrCode = DSL_DRV_DEV_InitDataPrepare(pContext, bIsInKernel, pInit);
3809	}
3810	#endif /* INCLUDE_DSL_CPE_API_VINAX*/
3811
3812	return nErrCode;
3813	}
3814
3815	/*
3816	For a detailed description of the function, its arguments and return value
3817	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
3818	*/
3819	DSL_void_t DSL_DRV_InitDataFree(
3820	DSL_Context_t *pContext,
3821	DSL_Init_t *pInit)
3822	{
3823	if (pInit == DSL_NULL)
3824	{
3825	return;
3826	}
3827
3828	if (pInit->data.pInventory != DSL_NULL)
3829	{
3830	DSL_DRV_PFree(pInit->data.pInventory);
3831	}
3832
3833	#ifdef INCLUDE_FW_REQUEST_SUPPORT
3834	#ifndef INCLUDE_DSL_DRV_STATIC_LINKED_FIRMWARE
3835	/* Remove stored FW from the DSL CPE context. The FW binary will
3836	be requested via the corresponding event further if necessary*/
3837	if( pContext->pFirmware != DSL_NULL )
3838	{
3839	DSL_DRV_VFree(pContext->pFirmware);
3840	pContext->pFirmware = DSL_NULL;
3841	pContext->nFirmwareSize = 0;
3842	}
3843
3844	if( pContext->pFirmware2 != DSL_NULL )
3845	{
3846	DSL_DRV_VFree(pContext->pFirmware2);
3847	pContext->pFirmware2 = DSL_NULL;
3848	pContext->nFirmwareSize2 = 0;
3849	}
3850	#endif /* INCLUDE_DSL_DRV_STATIC_LINKED_FIRMWARE*/
3851	#endif /* #ifdef INCLUDE_FW_REQUEST_SUPPORT*/
3852
3853	#ifdef INCLUDE_DSL_CPE_API_VINAX
3854	DSL_DRV_DEV_InitDataFree(pInit);
3855	#endif /* INCLUDE_DSL_CPE_API_VINAX*/
3856	}
3857
3858	DSL_Error_t DSL_DRV_IoctlHandleHelperCall(
3859	DSL_OpenContext_t *pOpenCtx,
3860	DSL_Context_t *pContext,
3861	DSL_boolean_t bIsInKernel,
3862	DSL_boolean_t bInstanceCall,
3863	DSL_IoctlHandlerHelperType_t nType,
3864	DSL_void_t *pFunc,
3865	DSL_void_t *pArg,
3866	DSL_uint32_t nArgSz)
3867	{
3868	DSL_Error_t nErrCode = DSL_ERR_MEMORY;
3869	DSL_IOCTL_arg_t *pIOCTL_arg = DSL_NULL;
3870
3871	if (nType != DSL_IOCTL_HELPER_GET && nType != DSL_IOCTL_HELPER_SET)
3872	{
3873	DSL_DEBUG(DSL_DBG_ERR,
3874	(pContext, "DSL[%02d]: ERROR - Invalid parameter was passed to "
3875	"the IOCTL helper!"DSL_DRV_CRLF, DSL_DEV_NUM(pContext)));
3876	return DSL_ERR_INVALID_PARAMETER;
3877	}
3878
3879	if (pArg == DSL_NULL \|\| nArgSz == 0)
3880	{
3881	nErrCode = DSL_ERR_INVALID_PARAMETER;
3882	}
3883	else
3884	{
3885	pIOCTL_arg = DSL_DRV_VMalloc(nArgSz);
3886	if(pIOCTL_arg == DSL_NULL)
3887	{
3888	DSL_IoctlMemCpyTo( bIsInKernel, pArg, &nErrCode, sizeof(DSL_Error_t));
3889	return nErrCode;
3890	}
3891
3892	DSL_IoctlMemCpyFrom(bIsInKernel, pIOCTL_arg, pArg,
3893	nArgSz);
3894
3895	if(bInstanceCall)
3896	{
3897	/* Lock Open Context list*/
3898	if (DSL_DRV_MUTEX_LOCK(pContext->pDevCtx->openContextListMutex))
3899	{
3900	DSL_DEBUG( DSL_DBG_ERR,
3901	(DSL_NULL, "DSL[%02d]: ERROR - Couldn't lock Context List mutex!"DSL_DRV_CRLF,
3902	DSL_DEV_NUM(pContext)));
3903
3904	nErrCode = DSL_ERR_SEMAPHORE_GET;
3905	}
3906	else
3907	{
3908	/* Call Instance specific IOCTL*/
3909	nErrCode = ((DSL_DRV_IoctlInstanceHandlerHelperFunc_t)pFunc)(pOpenCtx, pContext, pIOCTL_arg);
3910
3911	/* Unlock Open Context list*/
3912	DSL_DRV_MUTEX_UNLOCK(pContext->pDevCtx->openContextListMutex);
3913	}
3914	}
3915	else
3916	{
3917	nErrCode = ((DSL_DRV_IoctlHandlerHelperFunc_t)pFunc)(pContext, pIOCTL_arg);
3918	}
3919
3920	if (nErrCode >= DSL_SUCCESS)
3921	{
3922	if (nType == DSL_IOCTL_HELPER_GET)
3923	{
3924	pIOCTL_arg->accessCtl.nReturn = nErrCode;
3925
3926	DSL_IoctlMemCpyTo( bIsInKernel, pArg, pIOCTL_arg,
3927	nArgSz);
3928	}
3929	else
3930	{
3931	DSL_IoctlMemCpyTo( bIsInKernel, pArg, &nErrCode,
3932	sizeof(DSL_Error_t));
3933	}
3934	}
3935	else
3936	{
3937	DSL_IoctlMemCpyTo( bIsInKernel, pArg, &nErrCode, sizeof(DSL_Error_t));
3938	}
3939
3940	DSL_DRV_VFree(pIOCTL_arg);
3941	}
3942
3943	return nErrCode;
3944	}
3945
3946	/* DSL CPE API Ioctl Table */
3947	DSL_IOCTL_Table_t ioctlTable[] = {
3948	/* DSL_FIO_AUTOBOOT_LOAD_FIRMWARE */
3949	DSL_IOCTL_REGISTER(DSL_FIO_AUTOBOOT_LOAD_FIRMWARE, DSL_IOCTL_HELPER_SET,
3950	DSL_FALSE, DSL_DRV_AutobootLoadFirmware,
3951	sizeof(DSL_AutobootLoadFirmware_t)),
3952	/* DSL_FIO_AUTOBOOT_CONTROL_SET */
3953	DSL_IOCTL_REGISTER(DSL_FIO_AUTOBOOT_CONTROL_SET, DSL_IOCTL_HELPER_SET,
3954	DSL_FALSE, DSL_DRV_AutobootControlSet,
3955	sizeof(DSL_AutobootControl_t)),
3956	/* DSL_FIO_AUTOBOOT_STATUS_GET */
3957	DSL_IOCTL_REGISTER(DSL_FIO_AUTOBOOT_STATUS_GET, DSL_IOCTL_HELPER_GET,
3958	DSL_FALSE, DSL_DRV_AutobootStatusGet,
3959	sizeof(DSL_AutobootStatus_t)),
3960	/* DSL_FIO_LINE_STATE_GET */
3961	DSL_IOCTL_REGISTER(DSL_FIO_LINE_STATE_GET, DSL_IOCTL_HELPER_GET,
3962	DSL_FALSE, DSL_DRV_LineStateGet,
3963	sizeof(DSL_LineState_t)),
3964	/* DSL_FIO_AUTOBOOT_CONFIG_SET */
3965	DSL_IOCTL_REGISTER(DSL_FIO_AUTOBOOT_CONFIG_SET, DSL_IOCTL_HELPER_SET,
3966	DSL_FALSE, DSL_DRV_AutobootConfigSet,
3967	sizeof(DSL_AutobootConfig_t)),
3968	/* DSL_FIO_LINE_FEATURE_CONFIG_SET */
3969	DSL_IOCTL_REGISTER(DSL_FIO_LINE_FEATURE_CONFIG_SET, DSL_IOCTL_HELPER_SET,
3970	DSL_FALSE, DSL_DRV_LineFeatureConfigSet,
3971	sizeof(DSL_LineFeature_t)),
3972	/* DSL_FIO_G997_XTU_SYSTEM_ENABLING_CONFIG_SET */
3973	DSL_IOCTL_REGISTER(DSL_FIO_G997_XTU_SYSTEM_ENABLING_CONFIG_SET, DSL_IOCTL_HELPER_SET,
3974	DSL_FALSE, DSL_DRV_G997_XTUSystemEnablingConfigSet,
3975	sizeof(DSL_G997_XTUSystemEnabling_t)),
3976	/* DSL_FIO_G997_XTU_SYSTEM_ENABLING_STATUS_GET */
3977	DSL_IOCTL_REGISTER(DSL_FIO_G997_XTU_SYSTEM_ENABLING_STATUS_GET, DSL_IOCTL_HELPER_GET,
3978	DSL_FALSE, DSL_DRV_G997_XTUSystemEnablingStatusGet,
3979	sizeof(DSL_G997_XTUSystemEnabling_t)),
3980
3981	#ifdef INCLUDE_DSL_CONFIG_GET
3982	/* DSL_FIO_G997_XTU_SYSTEM_ENABLING_CONFIG_GET */
3983	DSL_IOCTL_REGISTER(DSL_FIO_G997_XTU_SYSTEM_ENABLING_CONFIG_GET, DSL_IOCTL_HELPER_GET,
3984	DSL_FALSE, DSL_DRV_G997_XTUSystemEnablingConfigGet,
3985	sizeof(DSL_G997_XTUSystemEnabling_t)),
3986	/* DSL_FIO_AUTOBOOT_CONFIG_GET */
3987	DSL_IOCTL_REGISTER(DSL_FIO_AUTOBOOT_CONFIG_GET, DSL_IOCTL_HELPER_GET,
3988	DSL_FALSE, DSL_DRV_AutobootConfigGet,
3989	sizeof(DSL_AutobootConfig_t)),
3990	/* DSL_FIO_LINE_FEATURE_CONFIG_GET */
3991	DSL_IOCTL_REGISTER(DSL_FIO_LINE_FEATURE_CONFIG_GET, DSL_IOCTL_HELPER_GET,
3992	DSL_FALSE, DSL_DRV_LineFeatureConfigGet,
3993	sizeof(DSL_LineFeature_t)),
3994	#ifdef INCLUDE_DSL_CPE_API_DANUBE
3995	/* DSL_FIO_INTEROP_FEATURE_CONFIG_GET */
3996	DSL_IOCTL_REGISTER(DSL_FIO_INTEROP_FEATURE_CONFIG_GET, DSL_IOCTL_HELPER_GET,
3997	DSL_FALSE, DSL_DRV_InteropFeatureConfigGet,
3998	sizeof(DSL_InteropFeatureConfig_t)),
3999	#endif /* INCLUDE_DSL_CPE_API_DANUBE*/
4000	/* DSL_FIO_EVENT_STATUS_MASK_CONFIG_GET */
4001	DSL_IOCTL_REGISTER(DSL_FIO_EVENT_STATUS_MASK_CONFIG_GET, DSL_IOCTL_HELPER_GET,
4002	DSL_TRUE, DSL_DRV_EventStatusMaskConfigGet,
4003	sizeof(DSL_EventStatusMask_t)),
4004	#endif /* INCLUDE_DSL_CONFIG_GET*/
4005	/* DSL_FIO_EVENT_STATUS_MASK_CONFIG_SET */
4006	DSL_IOCTL_REGISTER(DSL_FIO_EVENT_STATUS_MASK_CONFIG_SET, DSL_IOCTL_HELPER_SET,
4007	DSL_TRUE, DSL_DRV_EventStatusMaskConfigSet,
4008	sizeof(DSL_EventStatusMask_t)),
4009	#ifdef INCLUDE_DSL_SYSTEM_INTERFACE
4010
4011	/* DSL_FIO_SYSTEM_INTERFACE_CONFIG_SET */
4012	DSL_IOCTL_REGISTER(DSL_FIO_SYSTEM_INTERFACE_CONFIG_SET, DSL_IOCTL_HELPER_SET,
4013	DSL_FALSE, DSL_DRV_SystemInterfaceConfigSet,
4014	sizeof(DSL_SystemInterfaceConfig_t)),
4015	#ifdef INCLUDE_DSL_CONFIG_GET
4016	/* DSL_FIO_SYSTEM_INTERFACE_CONFIG_GET */
4017	DSL_IOCTL_REGISTER(DSL_FIO_SYSTEM_INTERFACE_CONFIG_GET, DSL_IOCTL_HELPER_GET,
4018	DSL_FALSE, DSL_DRV_SystemInterfaceConfigGet,
4019	sizeof(DSL_SystemInterfaceConfig_t)),
4020	#endif /* INCLUDE_DSL_CONFIG_GET*/
4021	/* DSL_FIO_SYSTEM_INTERFACE_STATUS_GET */
4022	DSL_IOCTL_REGISTER(DSL_FIO_SYSTEM_INTERFACE_STATUS_GET, DSL_IOCTL_HELPER_GET,
4023	DSL_FALSE, DSL_DRV_SystemInterfaceStatusGet,
4024	sizeof(DSL_SystemInterfaceStatus_t)),
4025	#endif /* INCLUDE_DSL_SYSTEM_INTERFACE*/
4026
4027	#ifdef INCLUDE_DSL_CPE_MISC_LINE_STATUS
4028	/* DSL_FIO_BAND_BORDER_STATUS_GET */
4029	DSL_IOCTL_REGISTER(DSL_FIO_BAND_BORDER_STATUS_GET, DSL_IOCTL_HELPER_GET,
4030	DSL_FALSE, DSL_DRV_BandBorderStatusGet,
4031	sizeof(DSL_BandBorderStatus_t)),
4032
4033	/* DSL_FIO_MISC_LINE_STATUS_GET */
4034	DSL_IOCTL_REGISTER(DSL_FIO_MISC_LINE_STATUS_GET, DSL_IOCTL_HELPER_GET,
4035	DSL_FALSE, DSL_DRV_MiscLineStatusGet,
4036	sizeof(DSL_MiscLineStatus_t)),
4037	#endif /* INCLUDE_DSL_CPE_MISC_LINE_STATUS*/
4038
4039	DSL_IOCTL_REGISTER(DSL_FIO_LINE_OPTIONS_CONFIG_SET, DSL_IOCTL_HELPER_SET,
4040	DSL_FALSE, DSL_DRV_LineOptionsConfigSet,
4041	sizeof(DSL_LineOptionsConfig_t)),
4042	#ifdef INCLUDE_DSL_CONFIG_GET
4043	DSL_IOCTL_REGISTER(DSL_FIO_LINE_OPTIONS_CONFIG_GET, DSL_IOCTL_HELPER_GET,
4044	DSL_FALSE, DSL_DRV_LineOptionsConfigGet,
4045	sizeof(DSL_LineOptionsConfig_t)),
4046	#endif /* INCLUDE_DSL_CONFIG_GET*/
4047
4048	#ifdef INCLUDE_DSL_CPE_API_DANUBE
4049	#ifdef INCLUDE_DEVICE_EXCEPTION_CODES
4050	DSL_IOCTL_REGISTER(DSL_FIO_DBG_LAST_EXCEPTION_CODES_GET, DSL_IOCTL_HELPER_GET,
4051	DSL_FALSE, DSL_DBG_LastExceptionCodesGet,
4052	sizeof(DSL_DBG_LastExceptionCodes_t)),
4053	#endif /* INCLUDE_DEVICE_EXCEPTION_CODES*/
4054	#ifndef DSL_DEBUG_DISABLE
4055	DSL_IOCTL_REGISTER(DSL_FIO_DBG_DEBUG_FEATURE_CONFIG_SET, DSL_IOCTL_HELPER_SET,
4056	DSL_FALSE, DSL_DRV_DBG_DebugFeatureConfigSet,
4057	sizeof(DSL_DBG_DebugFeatureConfig_t)),
4058
4059	#ifdef INCLUDE_DSL_CONFIG_GET
4060	DSL_IOCTL_REGISTER(DSL_FIO_DBG_DEBUG_FEATURE_CONFIG_GET, DSL_IOCTL_HELPER_GET,
4061	DSL_FALSE, DSL_DRV_DBG_DebugFeatureConfigGet,
4062	sizeof(DSL_DBG_DebugFeatureConfig_t)),
4063	#endif /* INCLUDE_DSL_CONFIG_GET*/
4064	#endif /* DSL_DEBUG_DISABLE*/
4065	#endif /* INCLUDE_DSL_CPE_API_DANUBE*/
4066
4067	#ifdef INCLUDE_DSL_PM
4068	#ifdef INCLUDE_DSL_CPE_PM_CONFIG
4069	DSL_IOCTL_REGISTER(DSL_FIO_PM_CONFIG_SET, DSL_IOCTL_HELPER_SET,
4070	DSL_FALSE, DSL_DRV_PM_ConfigSet,
4071	sizeof(DSL_PM_Config_t)),
4072	#ifdef INCLUDE_DSL_CONFIG_GET
4073	DSL_IOCTL_REGISTER(DSL_FIO_PM_CONFIG_GET, DSL_IOCTL_HELPER_GET,
4074	DSL_FALSE, DSL_DRV_PM_ConfigGet,
4075	sizeof(DSL_PM_Config_t)),
4076	#endif /* INCLUDE_DSL_CONFIG_GET*/
4077	#endif /* INCLUDE_DSL_CPE_PM_CONFIG*/
4078
4079	#ifdef INCLUDE_DSL_CPE_PM_HISTORY
4080	#ifdef INCLUDE_DSL_CPE_PM_OPTIONAL_PARAMETERS
4081	/* DSL_FIO_PM_ELAPSED_TIME_RESET */
4082	DSL_IOCTL_REGISTER(DSL_FIO_PM_ELAPSED_TIME_RESET, DSL_IOCTL_HELPER_SET,
4083	DSL_FALSE, DSL_DRV_PM_ElapsedTimeReset,
4084	sizeof(DSL_PM_ElapsedTimeReset_t)),
4085	/* DSL_FIO_PM_BURNIN_MODE_SET */
4086	DSL_IOCTL_REGISTER(DSL_FIO_PM_BURNIN_MODE_SET, DSL_IOCTL_HELPER_SET,
4087	DSL_FALSE, DSL_DRV_PM_BurninModeSet,
4088	sizeof(DSL_PM_BurninMode_t)),
4089	/* DSL_FIO_PM_SYNC_MODE_SET */
4090	DSL_IOCTL_REGISTER(DSL_FIO_PM_SYNC_MODE_SET, DSL_IOCTL_HELPER_SET,
4091	DSL_FALSE, DSL_DRV_PM_SyncModeSet,
4092	sizeof(DSL_PM_SyncMode_t)),
4093	#ifdef INCLUDE_DSL_CONFIG_GET
4094	/* DSL_FIO_PM_SYNC_MODE_GET */
4095	DSL_IOCTL_REGISTER(DSL_FIO_PM_SYNC_MODE_GET, DSL_IOCTL_HELPER_GET,
4096	DSL_FALSE, DSL_DRV_PM_SyncModeGet,
4097	sizeof(DSL_PM_SyncMode_t)),
4098	#endif /* INCLUDE_DSL_CONFIG_GET*/
4099	/* DSL_FIO_PM_15MIN_ELAPSED_EXT_TRIGGER */
4100	DSL_IOCTL_REGISTER(DSL_FIO_PM_15MIN_ELAPSED_EXT_TRIGGER, DSL_IOCTL_HELPER_SET,
4101	DSL_FALSE, DSL_DRV_PM_15MinElapsedExtTrigger,
4102	sizeof(DSL_PM_ElapsedExtTrigger_t)),
4103	#endif /* #ifdef INCLUDE_DSL_CPE_PM_OPTIONAL_PARAMETERS*/
4104	/* DSL_FIO_PM_RESET */
4105	DSL_IOCTL_REGISTER(DSL_FIO_PM_RESET, DSL_IOCTL_HELPER_SET,
4106	DSL_FALSE, DSL_DRV_PM_Reset,
4107	sizeof(DSL_PM_Reset_t)),
4108	#endif /* #ifdef INCLUDE_DSL_CPE_PM_HISTORY*/
4109
4110	#ifdef INCLUDE_DSL_CPE_PM_CHANNEL_COUNTERS
4111	#ifdef INCLUDE_DSL_CPE_PM_HISTORY
4112	/* DSL_FIO_PM_CHANNEL_COUNTERS_15MIN_GET */
4113	DSL_IOCTL_REGISTER(DSL_FIO_PM_CHANNEL_COUNTERS_15MIN_GET, DSL_IOCTL_HELPER_GET,
4114	DSL_FALSE, DSL_DRV_PM_ChannelCounters15MinGet,
4115	sizeof(DSL_PM_ChannelCounters_t)),
4116	/* DSL_FIO_PM_CHANNEL_COUNTERS_1DAY_GET */
4117	DSL_IOCTL_REGISTER(DSL_FIO_PM_CHANNEL_COUNTERS_1DAY_GET, DSL_IOCTL_HELPER_GET,
4118	DSL_FALSE, DSL_DRV_PM_ChannelCounters1DayGet,
4119	sizeof(DSL_PM_ChannelCounters_t)),
4120	#endif /* #ifdef INCLUDE_DSL_CPE_PM_HISTORY*/
4121	#ifdef INCLUDE_DSL_CPE_PM_TOTAL_COUNTERS
4122	/* DSL_FIO_PM_CHANNEL_COUNTERS_TOTAL_GET */
4123	DSL_IOCTL_REGISTER(DSL_FIO_PM_CHANNEL_COUNTERS_TOTAL_GET, DSL_IOCTL_HELPER_GET,
4124	DSL_FALSE, DSL_DRV_PM_ChannelCountersTotalGet,
4125	sizeof(DSL_PM_ChannelCountersTotal_t)),
4126	#endif /* #ifdef INCLUDE_DSL_CPE_PM_TOTAL_COUNTERS*/
4127
4128	#ifdef INCLUDE_DSL_CPE_PM_SHOWTIME_COUNTERS
4129	/* DSL_FIO_PM_CHANNEL_COUNTERS_SHOWTIME_GET */
4130	DSL_IOCTL_REGISTER(DSL_FIO_PM_CHANNEL_COUNTERS_SHOWTIME_GET, DSL_IOCTL_HELPER_GET,
4131	DSL_FALSE, DSL_DRV_PM_ChannelCountersShowtimeGet,
4132	sizeof(DSL_PM_ChannelCounters_t)),
4133	#ifdef INCLUDE_DSL_CPE_PM_CHANNEL_EXT_COUNTERS
4134	/* DSL_FIO_PM_CHANNEL_COUNTERS_SHOWTIME_EXT_GET */
4135	DSL_IOCTL_REGISTER(DSL_FIO_PM_CHANNEL_COUNTERS_SHOWTIME_EXT_GET, DSL_IOCTL_HELPER_GET,
4136	DSL_FALSE, DSL_DRV_PM_ChannelCountersExtShowtimeGet,
4137	sizeof(DSL_PM_ChannelCountersExt_t)),
4138	#endif /* INCLUDE_DSL_CPE_PM_CHANNEL_EXT_COUNTERS*/
4139	#endif /* #ifdef INCLUDE_DSL_CPE_PM_SHOWTIME_COUNTERS*/
4140	#ifdef INCLUDE_DSL_CPE_PM_HISTORY
4141	#ifdef INCLUDE_DSL_CPE_PM_OPTIONAL_PARAMETERS
4142	/* DSL_FIO_PM_CHANNEL_HISTORY_STATS_15MIN_GET */
4143	DSL_IOCTL_REGISTER(DSL_FIO_PM_CHANNEL_HISTORY_STATS_15MIN_GET, DSL_IOCTL_HELPER_GET,
4144	DSL_FALSE, DSL_DRV_PM_ChannelHistoryStats15MinGet,
4145	sizeof(DSL_PM_HistoryStatsChDir_t)),
4146	/* DSL_FIO_PM_CHANNEL_HISTORY_STATS_1DAY_GET */
4147	DSL_IOCTL_REGISTER(DSL_FIO_PM_CHANNEL_HISTORY_STATS_1DAY_GET, DSL_IOCTL_HELPER_GET,
4148	DSL_FALSE, DSL_DRV_PM_ChannelHistoryStats1DayGet,
4149	sizeof(DSL_PM_HistoryStatsChDir_t)),
4150	#endif /* #ifdef INCLUDE_DSL_CPE_PM_OPTIONAL_PARAMETERS*/
4151	#endif /* #ifdef INCLUDE_DSL_CPE_PM_HISTORY*/
4152	#ifdef INCLUDE_DSL_CPE_PM_CHANNEL_THRESHOLDS
4153	#ifdef INCLUDE_DSL_CPE_PM_HISTORY
4154	#ifdef INCLUDE_DSL_CPE_PM_OPTIONAL_PARAMETERS
4155	/* DSL_FIO_PM_CHANNEL_THRESHOLDS_15MIN_SET */
4156	DSL_IOCTL_REGISTER(DSL_FIO_PM_CHANNEL_THRESHOLDS_15MIN_SET, DSL_IOCTL_HELPER_SET,
4157	DSL_FALSE, DSL_DRV_PM_ChannelThresholds15MinSet,
4158	sizeof(DSL_PM_ChannelThreshold_t)),
4159	/* DSL_FIO_PM_CHANNEL_THRESHOLDS_1DAY_SET */
4160	DSL_IOCTL_REGISTER(DSL_FIO_PM_CHANNEL_THRESHOLDS_1DAY_SET, DSL_IOCTL_HELPER_SET,
4161	DSL_FALSE, DSL_DRV_PM_ChannelThresholds1DaySet,
4162	sizeof(DSL_PM_ChannelThreshold_t)),
4163	/* DSL_FIO_PM_CHANNEL_THRESHOLDS_15MIN_GET */
4164	DSL_IOCTL_REGISTER(DSL_FIO_PM_CHANNEL_THRESHOLDS_15MIN_GET, DSL_IOCTL_HELPER_GET,
4165	DSL_FALSE, DSL_DRV_PM_ChannelThresholds15MinGet,
4166	sizeof(DSL_PM_ChannelThreshold_t)),
4167	/* DSL_FIO_PM_CHANNEL_THRESHOLDS_1DAY_GET */
4168	DSL_IOCTL_REGISTER(DSL_FIO_PM_CHANNEL_THRESHOLDS_1DAY_GET, DSL_IOCTL_HELPER_GET,
4169	DSL_FALSE, DSL_DRV_PM_ChannelThresholds1DayGet,
4170	sizeof(DSL_PM_ChannelThreshold_t)),
4171	#endif /* INCLUDE_DSL_CPE_PM_OPTIONAL_PARAMETERS*/
4172	#endif /* INCLUDE_DSL_CPE_PM_HISTORY*/
4173	#endif /* INCLUDE_DSL_CPE_PM_CHANNEL_THRESHOLDS*/
4174	#endif /* INCLUDE_DSL_CPE_PM_CHANNEL_COUNTERS*/
4175
4176	#ifdef INCLUDE_DSL_CPE_PM_DATA_PATH_COUNTERS
4177	#ifdef INCLUDE_DSL_CPE_PM_HISTORY
4178	/* DSL_FIO_PM_DATA_PATH_COUNTERS_15MIN_GET */
4179	DSL_IOCTL_REGISTER(DSL_FIO_PM_DATA_PATH_COUNTERS_15MIN_GET, DSL_IOCTL_HELPER_GET,
4180	DSL_FALSE, DSL_DRV_PM_DataPathCounters15MinGet,
4181	sizeof(DSL_PM_DataPathCounters_t)),
4182	/* DSL_FIO_PM_DATA_PATH_COUNTERS_1DAY_GET */
4183	DSL_IOCTL_REGISTER(DSL_FIO_PM_DATA_PATH_COUNTERS_1DAY_GET, DSL_IOCTL_HELPER_GET,
4184	DSL_FALSE, DSL_DRV_PM_DataPathCounters1DayGet,
4185	sizeof(DSL_PM_DataPathCounters_t)),
4186	#endif /* INCLUDE_DSL_CPE_PM_HISTORY*/
4187	#ifdef INCLUDE_DSL_CPE_PM_TOTAL_COUNTERS
4188	/* DSL_FIO_PM_DATA_PATH_COUNTERS_TOTAL_GET */
4189	DSL_IOCTL_REGISTER(DSL_FIO_PM_DATA_PATH_COUNTERS_TOTAL_GET, DSL_IOCTL_HELPER_GET,
4190	DSL_FALSE, DSL_DRV_PM_DataPathCountersTotalGet,
4191	sizeof(DSL_PM_DataPathCountersTotal_t)),
4192	#endif /* INCLUDE_DSL_CPE_PM_TOTAL_COUNTERS*/
4193
4194	#ifdef INCLUDE_DSL_CPE_PM_SHOWTIME_COUNTERS
4195	/* DSL_FIO_PM_DATA_PATH_COUNTERS_SHOWTIME_GET */
4196	DSL_IOCTL_REGISTER(DSL_FIO_PM_DATA_PATH_COUNTERS_SHOWTIME_GET, DSL_IOCTL_HELPER_GET,
4197	DSL_FALSE, DSL_DRV_PM_DataPathCountersShowtimeGet,
4198	sizeof(DSL_PM_DataPathCounters_t)),
4199	#endif /* INCLUDE_DSL_CPE_PM_SHOWTIME_COUNTERS*/
4200
4201	#ifdef INCLUDE_DSL_CPE_PM_HISTORY
4202	#ifdef INCLUDE_DSL_CPE_PM_OPTIONAL_PARAMETERS
4203	/* DSL_FIO_PM_DATA_PATH_HISTORY_STATS_15MIN_GET */
4204	DSL_IOCTL_REGISTER(DSL_FIO_PM_DATA_PATH_HISTORY_STATS_15MIN_GET, DSL_IOCTL_HELPER_GET,
4205	DSL_FALSE, DSL_DRV_PM_DataPathHistoryStats15MinGet,
4206	sizeof(DSL_PM_HistoryStatsChDir_t)),
4207	/* DSL_FIO_PM_DATA_PATH_HISTORY_STATS_1DAY_GET */
4208	DSL_IOCTL_REGISTER(DSL_FIO_PM_DATA_PATH_HISTORY_STATS_1DAY_GET, DSL_IOCTL_HELPER_GET,
4209	DSL_FALSE, DSL_DRV_PM_DataPathHistoryStats1DayGet,
4210	sizeof(DSL_PM_HistoryStatsChDir_t)),
4211	#endif /* INCLUDE_DSL_CPE_PM_OPTIONAL_PARAMETERS*/
4212	#endif /* INCLUDE_DSL_CPE_PM_HISTORY*/
4213
4214	#ifdef INCLUDE_DSL_CPE_PM_DATA_PATH_THRESHOLDS
4215	#ifdef INCLUDE_DSL_CPE_PM_HISTORY
4216	#ifdef INCLUDE_DSL_CPE_PM_OPTIONAL_PARAMETERS
4217	/* DSL_FIO_PM_DATA_PATH_THRESHOLDS_15MIN_SET */
4218	DSL_IOCTL_REGISTER(DSL_FIO_PM_DATA_PATH_THRESHOLDS_15MIN_SET, DSL_IOCTL_HELPER_SET,
4219	DSL_FALSE, DSL_DRV_PM_DataPathThresholds15MinSet,
4220	sizeof(DSL_PM_DataPathThreshold_t)),
4221	/* DSL_FIO_PM_DATA_PATH_THRESHOLDS_1DAY_SET */
4222	DSL_IOCTL_REGISTER(DSL_FIO_PM_DATA_PATH_THRESHOLDS_1DAY_SET, DSL_IOCTL_HELPER_SET,
4223	DSL_FALSE, DSL_DRV_PM_DataPathThresholds1DaySet,
4224	sizeof(DSL_PM_DataPathThreshold_t)),
4225	/* DSL_FIO_PM_DATA_PATH_THRESHOLDS_15MIN_GET */
4226	DSL_IOCTL_REGISTER(DSL_FIO_PM_DATA_PATH_THRESHOLDS_15MIN_GET, DSL_IOCTL_HELPER_GET,
4227	DSL_FALSE, DSL_DRV_PM_DataPathThresholds15MinGet,
4228	sizeof(DSL_PM_DataPathThreshold_t)),
4229	/* DSL_FIO_PM_DATA_PATH_THRESHOLDS_1DAY_GET */
4230	DSL_IOCTL_REGISTER(DSL_FIO_PM_DATA_PATH_THRESHOLDS_1DAY_GET, DSL_IOCTL_HELPER_GET,
4231	DSL_FALSE, DSL_DRV_PM_DataPathThresholds1DayGet,
4232	sizeof(DSL_PM_DataPathThreshold_t)),
4233	#endif /* INCLUDE_DSL_CPE_PM_OPTIONAL_PARAMETERS*/
4234	#endif /* INCLUDE_DSL_CPE_PM_HISTORY*/
4235	#endif /* INCLUDE_DSL_CPE_PM_DATA_PATH_THRESHOLDS*/
4236	#endif /* INCLUDE_DSL_CPE_PM_DATA_PATH_COUNTERS*/
4237
4238	#ifdef INCLUDE_DSL_CPE_PM_RETX_COUNTERS
4239	#ifdef INCLUDE_DSL_CPE_PM_HISTORY
4240	/* DSL_FIO_PM_RETX_COUNTERS_15MIN_GET */
4241	DSL_IOCTL_REGISTER(DSL_FIO_PM_RETX_COUNTERS_15MIN_GET, DSL_IOCTL_HELPER_GET,
4242	DSL_FALSE, DSL_DRV_PM_ReTxCounters15MinGet,
4243	sizeof(DSL_PM_ReTxCounters_t)),
4244	/* DSL_FIO_PM_RETX_COUNTERS_1DAY_GET */
4245	DSL_IOCTL_REGISTER(DSL_FIO_PM_RETX_COUNTERS_1DAY_GET, DSL_IOCTL_HELPER_GET,
4246	DSL_FALSE, DSL_DRV_PM_ReTxCounters1DayGet,
4247	sizeof(DSL_PM_ReTxCounters_t)),
4248	#endif /* INCLUDE_DSL_CPE_PM_HISTORY*/
4249	#ifdef INCLUDE_DSL_CPE_PM_TOTAL_COUNTERS
4250	/* DSL_FIO_PM_RETX_COUNTERS_TOTAL_GET */
4251	DSL_IOCTL_REGISTER(DSL_FIO_PM_RETX_COUNTERS_TOTAL_GET, DSL_IOCTL_HELPER_GET,
4252	DSL_FALSE, DSL_DRV_PM_ReTxCountersTotalGet,
4253	sizeof(DSL_PM_ReTxCountersTotal_t)),
4254	#endif /* INCLUDE_DSL_CPE_PM_TOTAL_COUNTERS*/
4255
4256	#ifdef INCLUDE_DSL_CPE_PM_SHOWTIME_COUNTERS
4257	/* DSL_FIO_PM_RETX_COUNTERS_SHOWTIME_GET */
4258	DSL_IOCTL_REGISTER(DSL_FIO_PM_RETX_COUNTERS_SHOWTIME_GET, DSL_IOCTL_HELPER_GET,
4259	DSL_FALSE, DSL_DRV_PM_ReTxCountersShowtimeGet,
4260	sizeof(DSL_PM_ReTxCounters_t)),
4261	#endif /* INCLUDE_DSL_CPE_PM_SHOWTIME_COUNTERS*/
4262
4263	#ifdef INCLUDE_DSL_CPE_PM_HISTORY
4264	#ifdef INCLUDE_DSL_CPE_PM_OPTIONAL_PARAMETERS
4265	/* DSL_FIO_PM_RETX_HISTORY_STATS_15MIN_GET */
4266	DSL_IOCTL_REGISTER(DSL_FIO_PM_RETX_HISTORY_STATS_15MIN_GET, DSL_IOCTL_HELPER_GET,
4267	DSL_FALSE, DSL_DRV_PM_ReTxHistoryStats15MinGet,
4268	sizeof(DSL_PM_HistoryStatsChDir_t)),
4269	/* DSL_FIO_PM_RETX_HISTORY_STATS_1DAY_GET */
4270	DSL_IOCTL_REGISTER(DSL_FIO_PM_RETX_HISTORY_STATS_1DAY_GET, DSL_IOCTL_HELPER_GET,
4271	DSL_FALSE, DSL_DRV_PM_ReTxHistoryStats1DayGet,
4272	sizeof(DSL_PM_HistoryStatsChDir_t)),
4273	#endif /* INCLUDE_DSL_CPE_PM_OPTIONAL_PARAMETERS*/
4274	#endif /* INCLUDE_DSL_CPE_PM_HISTORY*/
4275
4276	#ifdef INCLUDE_DSL_CPE_PM_RETX_THRESHOLDS
4277	#ifdef INCLUDE_DSL_CPE_PM_HISTORY
4278	#ifdef INCLUDE_DSL_CPE_PM_OPTIONAL_PARAMETERS
4279	/* DSL_FIO_PM_RETX_THRESHOLDS_15MIN_SET */
4280	DSL_IOCTL_REGISTER(DSL_FIO_PM_RETX_THRESHOLDS_15MIN_SET, DSL_IOCTL_HELPER_SET,
4281	DSL_FALSE, DSL_DRV_PM_ReTxThresholds15MinSet,
4282	sizeof(DSL_PM_ReTxThreshold_t)),
4283	/* DSL_FIO_PM_RETX_THRESHOLDS_1DAY_SET */
4284	DSL_IOCTL_REGISTER(DSL_FIO_PM_RETX_THRESHOLDS_1DAY_SET, DSL_IOCTL_HELPER_SET,
4285	DSL_FALSE, DSL_DRV_PM_ReTxThresholds1DaySet,
4286	sizeof(DSL_PM_ReTxThreshold_t)),
4287	/* DSL_FIO_PM_RETX_THRESHOLDS_15MIN_GET */
4288	DSL_IOCTL_REGISTER(DSL_FIO_PM_RETX_THRESHOLDS_15MIN_GET, DSL_IOCTL_HELPER_GET,
4289	DSL_FALSE, DSL_DRV_PM_ReTxThresholds15MinGet,
4290	sizeof(DSL_PM_ReTxThreshold_t)),
4291	/* DSL_FIO_PM_RETX_THRESHOLDS_1DAY_GET */
4292	DSL_IOCTL_REGISTER(DSL_FIO_PM_RETX_THRESHOLDS_1DAY_GET, DSL_IOCTL_HELPER_GET,
4293	DSL_FALSE, DSL_DRV_PM_ReTxThresholds1DayGet,
4294	sizeof(DSL_PM_ReTxThreshold_t)),
4295	#endif /* INCLUDE_DSL_CPE_PM_OPTIONAL_PARAMETERS*/
4296	#endif /* INCLUDE_DSL_CPE_PM_HISTORY*/
4297	#endif /* INCLUDE_DSL_CPE_PM_RETX_THRESHOLDS*/
4298	#endif /* INCLUDE_DSL_CPE_PM_RETX_COUNTERS*/
4299
4300	#ifdef INCLUDE_DSL_CPE_PM_DATA_PATH_FAILURE_COUNTERS
4301	#ifdef INCLUDE_DSL_CPE_PM_HISTORY
4302	/* DSL_FIO_PM_DATA_PATH_FAILURE_COUNTERS_15MIN_GET */
4303	DSL_IOCTL_REGISTER(DSL_FIO_PM_DATA_PATH_FAILURE_COUNTERS_15MIN_GET, DSL_IOCTL_HELPER_GET,
4304	DSL_FALSE, DSL_DRV_PM_DataPathFailureCounters15MinGet,
4305	sizeof(DSL_PM_DataPathFailureCounters_t)),
4306	/* DSL_FIO_PM_DATA_PATH_FAILURE_COUNTERS_1DAY_GET */
4307	DSL_IOCTL_REGISTER(DSL_FIO_PM_DATA_PATH_FAILURE_COUNTERS_1DAY_GET, DSL_IOCTL_HELPER_GET,
4308	DSL_FALSE, DSL_DRV_PM_DataPathFailureCounters1DayGet,
4309	sizeof(DSL_PM_DataPathFailureCounters_t)),
4310	#endif /* INCLUDE_DSL_CPE_PM_HISTORY*/
4311	#ifdef INCLUDE_DSL_CPE_PM_TOTAL_COUNTERS
4312	/* DSL_FIO_PM_DATA_PATH_FAILURE_COUNTERS_TOTAL_GET */
4313	DSL_IOCTL_REGISTER(DSL_FIO_PM_DATA_PATH_FAILURE_COUNTERS_TOTAL_GET, DSL_IOCTL_HELPER_GET,
4314	DSL_FALSE, DSL_DRV_PM_DataPathFailureCountersTotalGet,
4315	sizeof(DSL_PM_DataPathFailureCountersTotal_t)),
4316	#endif /* INCLUDE_DSL_CPE_PM_TOTAL_COUNTERS*/
4317
4318	#ifdef INCLUDE_DSL_CPE_PM_SHOWTIME_COUNTERS
4319	/* DSL_FIO_PM_DATA_PATH_FAILURE_COUNTERS_SHOWTIME_GET */
4320	DSL_IOCTL_REGISTER(DSL_FIO_PM_DATA_PATH_FAILURE_COUNTERS_SHOWTIME_GET, DSL_IOCTL_HELPER_GET,
4321	DSL_FALSE, DSL_DRV_PM_DataPathFailureCountersShowtimeGet,
4322	sizeof(DSL_PM_DataPathFailureCounters_t)),
4323	#endif /* INCLUDE_DSL_CPE_PM_SHOWTIME_COUNTERS*/
4324
4325	#ifdef INCLUDE_DSL_CPE_PM_HISTORY
4326	#ifdef INCLUDE_DSL_CPE_PM_OPTIONAL_PARAMETERS
4327	/* DSL_FIO_PM_DATA_PATH_FAILURE_HISTORY_STATS_15MIN_GET */
4328	DSL_IOCTL_REGISTER(DSL_FIO_PM_DATA_PATH_FAILURE_HISTORY_STATS_15MIN_GET, DSL_IOCTL_HELPER_GET,
4329	DSL_FALSE, DSL_DRV_PM_DataPathFailureHistoryStats15MinGet,
4330	sizeof(DSL_PM_HistoryStatsChDir_t)),
4331	/* DSL_FIO_PM_DATA_PATH_FAILURE_HISTORY_STATS_1DAY_GET */
4332	DSL_IOCTL_REGISTER(DSL_FIO_PM_DATA_PATH_FAILURE_HISTORY_STATS_1DAY_GET, DSL_IOCTL_HELPER_GET,
4333	DSL_FALSE, DSL_DRV_PM_DataPathFailureHistoryStats1DayGet,
4334	sizeof(DSL_PM_HistoryStatsChDir_t)),
4335	#endif /* INCLUDE_DSL_CPE_PM_OPTIONAL_PARAMETERS*/
4336	#endif /* INCLUDE_DSL_CPE_PM_HISTORY*/
4337	#endif /* INCLUDE_DSL_CPE_PM_DATA_PATH_FAILURE_COUNTERS*/
4338
4339	#ifdef INCLUDE_DSL_CPE_PM_LINE_COUNTERS
4340	#ifdef INCLUDE_DSL_CPE_PM_HISTORY
4341	/* DSL_FIO_PM_LINE_SEC_COUNTERS_15MIN_GET */
4342	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_SEC_COUNTERS_15MIN_GET, DSL_IOCTL_HELPER_GET,
4343	DSL_FALSE, DSL_DRV_PM_LineSecCounters15MinGet,
4344	sizeof(DSL_PM_LineSecCounters_t)),
4345	/* DSL_FIO_PM_LINE_SEC_COUNTERS_1DAY_GET */
4346	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_SEC_COUNTERS_1DAY_GET, DSL_IOCTL_HELPER_GET,
4347	DSL_FALSE, DSL_DRV_PM_LineSecCounters1DayGet,
4348	sizeof(DSL_PM_LineSecCounters_t)),
4349	#ifdef INCLUDE_DSL_CPE_PM_OPTIONAL_PARAMETERS
4350	/* DSL_FIO_PM_LINE_INIT_HISTORY_STATS_15MIN_GET */
4351	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_INIT_HISTORY_STATS_15MIN_GET, DSL_IOCTL_HELPER_GET,
4352	DSL_FALSE, DSL_DRV_PM_LineInitHistoryStats15MinGet,
4353	sizeof(DSL_PM_HistoryStats_t)),
4354	/* DSL_FIO_PM_LINE_INIT_HISTORY_STATS_1DAY_GET */
4355	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_INIT_HISTORY_STATS_1DAY_GET, DSL_IOCTL_HELPER_GET,
4356	DSL_FALSE, DSL_DRV_PM_LineInitHistoryStats1DayGet,
4357	sizeof(DSL_PM_HistoryStats_t)),
4358	/* DSL_FIO_PM_LINE_SEC_HISTORY_STATS_15MIN_GET */
4359	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_SEC_HISTORY_STATS_15MIN_GET, DSL_IOCTL_HELPER_GET,
4360	DSL_FALSE, DSL_DRV_PM_LineSecHistoryStats15MinGet,
4361	sizeof(DSL_PM_HistoryStatsDir_t)),
4362	/* DSL_FIO_PM_LINE_SEC_HISTORY_STATS_1DAY_GET */
4363	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_SEC_HISTORY_STATS_1DAY_GET, DSL_IOCTL_HELPER_GET,
4364	DSL_FALSE, DSL_DRV_PM_LineSecHistoryStats1DayGet,
4365	sizeof(DSL_PM_HistoryStatsDir_t)),
4366	#endif /* INCLUDE_DSL_CPE_PM_OPTIONAL_PARAMETERS*/
4367	#endif /* INCLUDE_DSL_CPE_PM_HISTORY*/
4368
4369	#ifdef INCLUDE_DSL_CPE_PM_TOTAL_COUNTERS
4370	/* DSL_FIO_PM_LINE_SEC_COUNTERS_TOTAL_GET */
4371	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_SEC_COUNTERS_TOTAL_GET, DSL_IOCTL_HELPER_GET,
4372	DSL_FALSE, DSL_DRV_PM_LineSecCountersTotalGet,
4373	sizeof(DSL_PM_LineSecCountersTotal_t)),
4374	#endif /* INCLUDE_DSL_CPE_PM_TOTAL_COUNTERS*/
4375
4376	#ifdef INCLUDE_DSL_CPE_PM_SHOWTIME_COUNTERS
4377	/* DSL_FIO_PM_LINE_SEC_COUNTERS_SHOWTIME_GET */
4378	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_SEC_COUNTERS_SHOWTIME_GET, DSL_IOCTL_HELPER_GET,
4379	DSL_FALSE, DSL_DRV_PM_LineSecCountersShowtimeGet,
4380	sizeof(DSL_PM_LineSecCounters_t)),
4381	#endif /* INCLUDE_DSL_CPE_PM_SHOWTIME_COUNTERS*/
4382
4383	#ifdef INCLUDE_DSL_CPE_PM_LINE_THRESHOLDS
4384	#ifdef INCLUDE_DSL_CPE_PM_HISTORY
4385	#ifdef INCLUDE_DSL_CPE_PM_OPTIONAL_PARAMETERS
4386	/* DSL_FIO_PM_LINE_SEC_THRESHOLDS_15MIN_SET */
4387	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_SEC_THRESHOLDS_15MIN_SET, DSL_IOCTL_HELPER_SET,
4388	DSL_FALSE, DSL_DRV_PM_LineSecThresholds15MinSet,
4389	sizeof(DSL_PM_LineSecThreshold_t)),
4390	/* DSL_FIO_PM_LINE_SEC_THRESHOLDS_1DAY_SET */
4391	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_SEC_THRESHOLDS_1DAY_SET, DSL_IOCTL_HELPER_SET,
4392	DSL_FALSE, DSL_DRV_PM_LineSecThresholds1DaySet,
4393	sizeof(DSL_PM_LineSecThreshold_t)),
4394	/* DSL_FIO_PM_LINE_SEC_THRESHOLDS_15MIN_GET */
4395	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_SEC_THRESHOLDS_15MIN_GET, DSL_IOCTL_HELPER_GET,
4396	DSL_FALSE, DSL_DRV_PM_LineSecThresholds15MinGet,
4397	sizeof(DSL_PM_LineSecThreshold_t)),
4398	/* DSL_FIO_PM_LINE_SEC_THRESHOLDS_1DAY_GET */
4399	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_SEC_THRESHOLDS_1DAY_GET, DSL_IOCTL_HELPER_GET,
4400	DSL_FALSE, DSL_DRV_PM_LineSecThresholds1DayGet,
4401	sizeof(DSL_PM_LineSecThreshold_t)),
4402	#endif /* INCLUDE_DSL_CPE_PM_OPTIONAL_PARAMETERS*/
4403	#endif /* INCLUDE_DSL_CPE_PM_HISTORY*/
4404	#endif /* INCLUDE_DSL_CPE_PM_LINE_THRESHOLDS*/
4405
4406	#ifdef INCLUDE_DSL_CPE_PM_HISTORY
4407	/* DSL_FIO_PM_LINE_INIT_COUNTERS_15MIN_GET */
4408	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_INIT_COUNTERS_15MIN_GET, DSL_IOCTL_HELPER_GET,
4409	DSL_FALSE, DSL_DRV_PM_LineInitCounters15MinGet,
4410	sizeof(DSL_PM_LineInitCounters_t)),
4411	/* DSL_FIO_PM_LINE_INIT_COUNTERS_1DAY_GET */
4412	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_INIT_COUNTERS_1DAY_GET, DSL_IOCTL_HELPER_GET,
4413	DSL_FALSE, DSL_DRV_PM_LineInitCounters1DayGet,
4414	sizeof(DSL_PM_LineInitCounters_t)),
4415	#endif /* INCLUDE_DSL_CPE_PM_HISTORY*/
4416
4417	#ifdef INCLUDE_DSL_CPE_PM_TOTAL_COUNTERS
4418	/* DSL_FIO_PM_LINE_INIT_COUNTERS_TOTAL_GET */
4419	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_INIT_COUNTERS_TOTAL_GET, DSL_IOCTL_HELPER_GET,
4420	DSL_FALSE, DSL_DRV_PM_LineInitCountersTotalGet,
4421	sizeof(DSL_PM_LineInitCountersTotal_t)),
4422	#endif /* INCLUDE_DSL_CPE_PM_TOTAL_COUNTERS*/
4423
4424	#ifdef INCLUDE_DSL_CPE_PM_SHOWTIME_COUNTERS
4425	/* DSL_FIO_PM_LINE_INIT_COUNTERS_SHOWTIME_GET */
4426	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_INIT_COUNTERS_SHOWTIME_GET, DSL_IOCTL_HELPER_GET,
4427	DSL_FALSE, DSL_DRV_PM_LineInitCountersShowtimeGet,
4428	sizeof(DSL_PM_LineInitCounters_t)),
4429	#endif /* INCLUDE_DSL_CPE_PM_SHOWTIME_COUNTERS*/
4430
4431	#ifdef INCLUDE_DSL_CPE_PM_LINE_THRESHOLDS
4432	#ifdef INCLUDE_DSL_CPE_PM_HISTORY
4433	#ifdef INCLUDE_DSL_CPE_PM_OPTIONAL_PARAMETERS
4434	/* DSL_FIO_PM_LINE_INIT_THRESHOLDS_15MIN_SET */
4435	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_INIT_THRESHOLDS_15MIN_SET, DSL_IOCTL_HELPER_SET,
4436	DSL_FALSE, DSL_DRV_PM_LineInitThresholds15MinSet,
4437	sizeof(DSL_PM_LineInitThreshold_t)),
4438	/* DSL_FIO_PM_LINE_INIT_THRESHOLDS_1DAY_SET */
4439	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_INIT_THRESHOLDS_1DAY_SET, DSL_IOCTL_HELPER_SET,
4440	DSL_FALSE, DSL_DRV_PM_LineInitThresholds1DaySet,
4441	sizeof(DSL_PM_LineInitThreshold_t)),
4442	/* DSL_FIO_PM_LINE_INIT_THRESHOLDS_15MIN_GET */
4443	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_INIT_THRESHOLDS_15MIN_GET, DSL_IOCTL_HELPER_GET,
4444	DSL_FALSE, DSL_DRV_PM_LineInitThresholds15MinGet,
4445	sizeof(DSL_PM_LineInitThreshold_t)),
4446	/* DSL_FIO_PM_LINE_INIT_THRESHOLDS_1DAY_GET */
4447	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_INIT_THRESHOLDS_1DAY_GET, DSL_IOCTL_HELPER_GET,
4448	DSL_FALSE, DSL_DRV_PM_LineInitThresholds1DayGet,
4449	sizeof(DSL_PM_LineInitThreshold_t)),
4450	#endif /* INCLUDE_DSL_CPE_PM_OPTIONAL_PARAMETERS*/
4451	#endif /* INCLUDE_DSL_CPE_PM_HISTORY*/
4452	#endif /* INCLUDE_DSL_CPE_PM_LINE_THRESHOLDS*/
4453	#endif /* INCLUDE_DSL_CPE_PM_LINE_COUNTERS*/
4454
4455	#ifdef INCLUDE_DSL_CPE_PM_LINE_EVENT_SHOWTIME_COUNTERS
4456	#ifdef INCLUDE_DSL_CPE_PM_HISTORY
4457	/* DSL_FIO_PM_LINE_EVENT_SHOWTIME_COUNTERS_15MIN_GET */
4458	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_EVENT_SHOWTIME_COUNTERS_15MIN_GET, DSL_IOCTL_HELPER_GET,
4459	DSL_FALSE, DSL_DRV_PM_LineEventShowtimeCounters15MinGet,
4460	sizeof(DSL_PM_LineEventShowtimeCounters_t)),
4461	#ifdef INCLUDE_DEPRECATED
4462	#ifdef INCLUDE_DSL_CPE_PM_LINE_FAILURE_COUNTERS
4463	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_FAILURE_COUNTERS_15MIN_GET, DSL_IOCTL_HELPER_GET,
4464	DSL_FALSE, DSL_DRV_PM_LineFailureCounters15MinGet,
4465	sizeof(DSL_PM_LineFailureCounters_t)),
4466	#endif /* INCLUDE_DSL_CPE_PM_LINE_FAILURE_COUNTERS*/
4467	#endif /* INCLUDE_DEPRECATED */
4468	/* DSL_FIO_PM_LINE_EVENT_SHOWTIME_COUNTERS_1DAY_GET */
4469	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_EVENT_SHOWTIME_COUNTERS_1DAY_GET, DSL_IOCTL_HELPER_GET,
4470	DSL_FALSE, DSL_DRV_PM_LineEventShowtimeCounters1DayGet,
4471	sizeof(DSL_PM_LineEventShowtimeCounters_t)),
4472	#ifdef INCLUDE_DEPRECATED
4473	#ifdef INCLUDE_DSL_CPE_PM_LINE_FAILURE_COUNTERS
4474	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_FAILURE_COUNTERS_1DAY_GET, DSL_IOCTL_HELPER_GET,
4475	DSL_FALSE, DSL_DRV_PM_LineFailureCounters1DayGet,
4476	sizeof(DSL_PM_LineFailureCounters_t)),
4477	#endif /* INCLUDE_DSL_CPE_PM_LINE_FAILURE_COUNTERS*/
4478	#endif /* INCLUDE_DEPRECATED */
4479	#endif /* INCLUDE_DSL_CPE_PM_HISTORY*/
4480	#ifdef INCLUDE_DSL_CPE_PM_TOTAL_COUNTERS
4481	/* DSL_FIO_PM_LINE_EVENT_SHOWTIME_COUNTERS_TOTAL_GET */
4482	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_EVENT_SHOWTIME_COUNTERS_TOTAL_GET, DSL_IOCTL_HELPER_GET,
4483	DSL_FALSE, DSL_DRV_PM_LineEventShowtimeCountersTotalGet,
4484	sizeof(DSL_PM_LineEventShowtimeCountersTotal_t)),
4485	#ifdef INCLUDE_DEPRECATED
4486	#ifdef INCLUDE_DSL_CPE_PM_LINE_FAILURE_COUNTERS
4487	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_FAILURE_COUNTERS_TOTAL_GET, DSL_IOCTL_HELPER_GET,
4488	DSL_FALSE, DSL_DRV_PM_LineFailureCountersTotalGet,
4489	sizeof(DSL_PM_LineFailureCountersTotal_t)),
4490	#endif /* INCLUDE_DSL_CPE_PM_LINE_FAILURE_COUNTERS*/
4491	#endif /* INCLUDE_DEPRECATED */
4492	#endif /* INCLUDE_DSL_CPE_PM_TOTAL_COUNTERS*/
4493
4494	#ifdef INCLUDE_DSL_CPE_PM_SHOWTIME_COUNTERS
4495	/* DSL_FIO_PM_LINE_EVENT_SHOWTIME_COUNTERS_SHOWTIME_GET */
4496	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_EVENT_SHOWTIME_COUNTERS_SHOWTIME_GET, DSL_IOCTL_HELPER_GET,
4497	DSL_FALSE, DSL_DRV_PM_LineEventShowtimeCountersShowtimeGet,
4498	sizeof(DSL_PM_LineEventShowtimeCounters_t)),
4499	#ifdef INCLUDE_DEPRECATED
4500	#ifdef INCLUDE_DSL_CPE_PM_LINE_FAILURE_COUNTERS
4501	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_FAILURE_COUNTERS_SHOWTIME_GET, DSL_IOCTL_HELPER_GET,
4502	DSL_FALSE, DSL_DRV_PM_LineFailureCountersShowtimeGet,
4503	sizeof(DSL_PM_LineFailureCounters_t)),
4504	#endif /* INCLUDE_DSL_CPE_PM_LINE_FAILURE_COUNTERS*/
4505	#endif /* INCLUDE_DEPRECATED */
4506	#endif /* INCLUDE_DSL_CPE_PM_SHOWTIME_COUNTERS*/
4507
4508	#ifdef INCLUDE_DSL_CPE_PM_HISTORY
4509	#ifdef INCLUDE_DSL_CPE_PM_OPTIONAL_PARAMETERS
4510	/* DSL_FIO_PM_LINE_EVENT_SHOWTIME_HISTORY_STATS_15MIN_GET */
4511	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_EVENT_SHOWTIME_HISTORY_STATS_15MIN_GET, DSL_IOCTL_HELPER_GET,
4512	DSL_FALSE, DSL_DRV_PM_LineEventShowtimeHistoryStats15MinGet,
4513	sizeof(DSL_PM_HistoryStatsChDir_t)),
4514	#ifdef INCLUDE_DEPRECATED
4515	#ifdef INCLUDE_DSL_CPE_PM_LINE_FAILURE_COUNTERS
4516	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_FAILURE_HISTORY_STATS_15MIN_GET, DSL_IOCTL_HELPER_GET,
4517	DSL_FALSE, DSL_DRV_PM_LineFailureHistoryStats15MinGet,
4518	sizeof(DSL_PM_HistoryStatsChDir_t)),
4519	#endif /* INCLUDE_DSL_CPE_PM_LINE_FAILURE_COUNTERS*/
4520	#endif /* INCLUDE_DEPRECATED */
4521	/* DSL_FIO_PM_LINE_EVENT_SHOWTIME_HISTORY_STATS_1DAY_GET */
4522	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_EVENT_SHOWTIME_HISTORY_STATS_1DAY_GET, DSL_IOCTL_HELPER_GET,
4523	DSL_FALSE, DSL_DRV_PM_LineEventShowtimeHistoryStats1DayGet,
4524	sizeof(DSL_PM_HistoryStatsChDir_t)),
4525	#ifdef INCLUDE_DEPRECATED
4526	#ifdef INCLUDE_DSL_CPE_PM_LINE_FAILURE_COUNTERS
4527	DSL_IOCTL_REGISTER(DSL_FIO_PM_LINE_FAILURE_HISTORY_STATS_1DAY_GET, DSL_IOCTL_HELPER_GET,
4528	DSL_FALSE, DSL_DRV_PM_LineFailureHistoryStats1DayGet,
4529	sizeof(DSL_PM_HistoryStatsChDir_t)),
4530	#endif /* INCLUDE_DSL_CPE_PM_LINE_FAILURE_COUNTERS*/
4531	#endif /* INCLUDE_DEPRECATED */
4532	#endif /* INCLUDE_DSL_CPE_PM_OPTIONAL_PARAMETERS*/
4533	#endif /* INCLUDE_DSL_CPE_PM_HISTORY*/
4534	#endif /* INCLUDE_DSL_CPE_PM_LINE_EVENT_SHOWTIME_COUNTERS*/
4535	#endif /* INCLUDE_DSL_PM*/
4536
4537	#ifdef INCLUDE_DSL_CEOC
4538	/* DSL_FIO_G997_SNMP_MESSAGE_SEND */
4539	DSL_IOCTL_REGISTER(DSL_FIO_G997_SNMP_MESSAGE_SEND, DSL_IOCTL_HELPER_SET,
4540	DSL_FALSE, DSL_DRV_G997_SnmpMessageSend,
4541	sizeof(DSL_G997_Snmp_t)),
4542	/* DSL_FIO_G997_SNMP_MESSAGE_RECEIVE */
4543	DSL_IOCTL_REGISTER(DSL_FIO_G997_SNMP_MESSAGE_RECEIVE, DSL_IOCTL_HELPER_GET,
4544	DSL_TRUE, DSL_DRV_G997_SnmpMessageReceive,
4545	sizeof(DSL_G997_Snmp_t)),
4546	#endif /* INCLUDE_DSL_CEOC*/
4547
4548	/* DSL_FIO_G997_RATE_ADAPTATION_CONFIG_SET */
4549	DSL_IOCTL_REGISTER(DSL_FIO_G997_RATE_ADAPTATION_CONFIG_SET, DSL_IOCTL_HELPER_SET,
4550	DSL_FALSE, DSL_DRV_G997_RateAdaptationConfigSet,
4551	sizeof(DSL_G997_RateAdaptationConfig_t)),
4552	/* DSL_FIO_G997_LINE_ACTIVATE_CONFIG_SET */
4553	DSL_IOCTL_REGISTER(DSL_FIO_G997_LINE_ACTIVATE_CONFIG_SET, DSL_IOCTL_HELPER_SET,
4554	DSL_FALSE, DSL_DRV_G997_LineActivateConfigSet,
4555	sizeof(DSL_G997_LineActivate_t)),
4556	/* DSL_FIO_G997_POWER_MANAGEMENT_STATE_FORCED_TRIGGER */
4557	DSL_IOCTL_REGISTER(DSL_FIO_G997_POWER_MANAGEMENT_STATE_FORCED_TRIGGER, DSL_IOCTL_HELPER_SET,
4558	DSL_FALSE, DSL_DRV_G997_PowerManagementStateForcedTrigger,
4559	sizeof(DSL_G997_PowerManagementStateForcedTrigger_t)),
4560	/* DSL_FIO_G997_POWER_MANAGEMENT_STATUS_GET */
4561	DSL_IOCTL_REGISTER(DSL_FIO_G997_POWER_MANAGEMENT_STATUS_GET, DSL_IOCTL_HELPER_GET,
4562	DSL_FALSE, DSL_DRV_G997_PowerManagementStatusGet,
4563	sizeof(DSL_G997_PowerManagementStatus_t)),
4564	/* DSL_FIO_G997_LINE_STATUS_GET */
4565	DSL_IOCTL_REGISTER(DSL_FIO_G997_LINE_STATUS_GET, DSL_IOCTL_HELPER_GET,
4566	DSL_FALSE, DSL_DRV_G997_LineStatusGet,
4567	sizeof(DSL_G997_LineStatus_t)),
4568	/* DSL_FIO_G997_CHANNEL_STATUS_GET */
4569	DSL_IOCTL_REGISTER(DSL_FIO_G997_CHANNEL_STATUS_GET, DSL_IOCTL_HELPER_GET,
4570	DSL_FALSE, DSL_DRV_G997_ChannelStatusGet,
4571	sizeof(DSL_G997_ChannelStatus_t)),
4572
4573	#ifdef INCLUDE_DSL_G997_PER_TONE
4574	/* DSL_FIO_G997_BIT_ALLOCATION_NSC_GET */
4575	DSL_IOCTL_REGISTER(DSL_FIO_G997_BIT_ALLOCATION_NSC_GET, DSL_IOCTL_HELPER_GET,
4576	DSL_FALSE, DSL_DRV_G997_BitAllocationNSCGet,
4577	sizeof(DSL_G997_BitAllocationNsc_t)),
4578	/* DSL_FIO_G997_SNR_ALLOCATION_NSC_GET */
4579	DSL_IOCTL_REGISTER(DSL_FIO_G997_SNR_ALLOCATION_NSC_GET, DSL_IOCTL_HELPER_GET,
4580	DSL_FALSE, DSL_DRV_G997_SnrAllocationNscGet,
4581	sizeof(DSL_G997_SnrAllocationNsc_t)),
4582	/* DSL_FIO_G997_GAIN_ALLOCATION_NSC_GET */
4583	DSL_IOCTL_REGISTER(DSL_FIO_G997_GAIN_ALLOCATION_NSC_GET, DSL_IOCTL_HELPER_GET,
4584	DSL_FALSE, DSL_DRV_G997_GainAllocationNscGet,
4585	sizeof(DSL_G997_GainAllocationNsc_t)),
4586	#endif /* INCLUDE_DSL_G997_PER_TONE*/
4587
4588	#ifdef INCLUDE_DSL_DELT
4589	/* DSL_FIO_G997_DELT_HLIN_GET */
4590	DSL_IOCTL_REGISTER(DSL_FIO_G997_DELT_HLIN_GET, DSL_IOCTL_HELPER_GET,
4591	DSL_FALSE, DSL_DRV_G997_DeltHlinGet,
4592	sizeof(DSL_G997_DeltHlin_t)),
4593	/* DSL_FIO_G997_DELT_HLIN_SCALE_GET */
4594	DSL_IOCTL_REGISTER(DSL_FIO_G997_DELT_HLIN_SCALE_GET, DSL_IOCTL_HELPER_GET,
4595	DSL_FALSE, DSL_DRV_G997_DeltHlinScaleGet,
4596	sizeof(DSL_G997_DeltHlinScale_t)),
4597	/* DSL_FIO_G997_DELT_HLOG_GET */
4598	DSL_IOCTL_REGISTER(DSL_FIO_G997_DELT_HLOG_GET, DSL_IOCTL_HELPER_GET,
4599	DSL_FALSE, DSL_DRV_G997_DeltHlogGet,
4600	sizeof(DSL_G997_DeltHlog_t)),
4601	/* DSL_FIO_G997_DELT_QLN_GET */
4602	DSL_IOCTL_REGISTER(DSL_FIO_G997_DELT_QLN_GET, DSL_IOCTL_HELPER_GET,
4603	DSL_FALSE, DSL_DRV_G997_DeltQLNGet,
4604	sizeof(DSL_G997_DeltQln_t)),
4605	/* DSL_FIO_G997_DELT_SNR_GET */
4606	DSL_IOCTL_REGISTER(DSL_FIO_G997_DELT_SNR_GET, DSL_IOCTL_HELPER_GET,
4607	DSL_FALSE, DSL_DRV_G997_DeltSNRGet,
4608	sizeof(DSL_G997_DeltSnr_t)),
4609	/* DSL_FIO_G997_DELT_FREE_RESOURCES */
4610	DSL_IOCTL_REGISTER(DSL_FIO_G997_DELT_FREE_RESOURCES, DSL_IOCTL_HELPER_SET,
4611	DSL_FALSE, DSL_DRV_G997_DeltFreeResources,
4612	sizeof(DSL_G997_DeltFreeResources_t)),
4613	#endif /* INCLUDE_DSL_DELT*/
4614
4615	#if (INCLUDE_DSL_CPE_API_VDSL_SUPPORT == 1)
4616	/* DSL_FIO_G997_LINE_STATUS_PER_BAND_GET */
4617	DSL_IOCTL_REGISTER(DSL_FIO_G997_LINE_STATUS_PER_BAND_GET, DSL_IOCTL_HELPER_GET,
4618	DSL_FALSE, DSL_DRV_G997_LineStatusPerBandGet,
4619	sizeof(DSL_G997_LineStatusPerBand_t)),
4620	#endif /* (INCLUDE_DSL_CPE_API_VDSL_SUPPORT == 1) */
4621
4622	#ifdef INCLUDE_DSL_G997_FRAMING_PARAMETERS
4623	/* DSL_FIO_G997_FRAMING_PARAMETER_STATUS_GET */
4624	DSL_IOCTL_REGISTER(DSL_FIO_G997_FRAMING_PARAMETER_STATUS_GET, DSL_IOCTL_HELPER_GET,
4625	DSL_FALSE, DSL_DRV_G997_FramingParameterStatusGet,
4626	sizeof(DSL_G997_FramingParameterStatus_t)),
4627	#endif /* INCLUDE_DSL_G997_FRAMING_PARAMETERS*/
4628
4629	#ifdef INCLUDE_DSL_G997_ALARM
4630	/* DSL_FIO_G997_ALARM_MASK_DATA_PATH_FAILURES_CONFIG_SET */
4631	DSL_IOCTL_REGISTER(DSL_FIO_G997_ALARM_MASK_DATA_PATH_FAILURES_CONFIG_SET, DSL_IOCTL_HELPER_SET,
4632	DSL_TRUE, DSL_DRV_G997_AlarmMaskDataPathFailuresConfigSet,
4633	sizeof(DSL_G997_DataPathFailures_t)),
4634	/* DSL_FIO_G997_ALARM_MASK_LINE_FAILURES_CONFIG_SET */
4635	DSL_IOCTL_REGISTER(DSL_FIO_G997_ALARM_MASK_LINE_FAILURES_CONFIG_SET, DSL_IOCTL_HELPER_SET,
4636	DSL_TRUE, DSL_DRV_G997_AlarmMaskLineFailuresConfigSet,
4637	sizeof(DSL_G997_LineFailures_t)),
4638	/* DSL_FIO_G997_CHANNEL_DATA_RATE_THRESHOLD_CONFIG_SET */
4639	DSL_IOCTL_REGISTER(DSL_FIO_G997_CHANNEL_DATA_RATE_THRESHOLD_CONFIG_SET, DSL_IOCTL_HELPER_SET,
4640	DSL_FALSE, DSL_DRV_G997_ChannelDataRateThresholdConfigSet,
4641	sizeof(DSL_G997_ChannelDataRateThreshold_t)),
4642
4643	#ifdef INCLUDE_DSL_CONFIG_GET
4644	/* DSL_FIO_G997_ALARM_MASK_DATA_PATH_FAILURES_CONFIG_GET */
4645	DSL_IOCTL_REGISTER(DSL_FIO_G997_ALARM_MASK_DATA_PATH_FAILURES_CONFIG_GET, DSL_IOCTL_HELPER_GET,
4646	DSL_FALSE, DSL_DRV_G997_AlarmMaskDataPathFailuresConfigGet,
4647	sizeof(DSL_G997_DataPathFailures_t)),
4648	/* DSL_FIO_G997_ALARM_MASK_LINE_FAILURES_CONFIG_GET */
4649	DSL_IOCTL_REGISTER(DSL_FIO_G997_ALARM_MASK_LINE_FAILURES_CONFIG_GET, DSL_IOCTL_HELPER_GET,
4650	DSL_FALSE, DSL_DRV_G997_AlarmMaskLineFailuresConfigGet,
4651	sizeof(DSL_G997_LineFailures_t)),
4652	/* DSL_FIO_G997_CHANNEL_DATA_RATE_THRESHOLD_CONFIG_GET */
4653	DSL_IOCTL_REGISTER(DSL_FIO_G997_CHANNEL_DATA_RATE_THRESHOLD_CONFIG_GET, DSL_IOCTL_HELPER_GET,
4654	DSL_FALSE, DSL_DRV_G997_ChannelDataRateThresholdConfigGet,
4655	sizeof(DSL_G997_ChannelDataRateThreshold_t)),
4656	#endif /* INCLUDE_DSL_CONFIG_GET*/
4657	#endif /* INCLUDE_DSL_G997_ALARM*/
4658
4659	#ifdef INCLUDE_DSL_G997_STATUS
4660	/* DSL_FIO_G997_LINE_INIT_STATUS_GET */
4661	DSL_IOCTL_REGISTER(DSL_FIO_G997_LINE_INIT_STATUS_GET, DSL_IOCTL_HELPER_GET,
4662	DSL_FALSE, DSL_DRV_G997_LineInitStatusGet,
4663	sizeof(DSL_G997_LineInitStatus_t)),
4664	/* DSL_FIO_G997_LINE_FAILURES_STATUS_GET */
4665	DSL_IOCTL_REGISTER(DSL_FIO_G997_LINE_FAILURES_STATUS_GET, DSL_IOCTL_HELPER_GET,
4666	DSL_FALSE, DSL_DRV_G997_LineFailuresStatusGet,
4667	sizeof(DSL_G997_LineFailures_t)),
4668	/* DSL_FIO_G997_LINE_TRANSMISSION_STATUS_GET */
4669	DSL_IOCTL_REGISTER(DSL_FIO_G997_LINE_TRANSMISSION_STATUS_GET, DSL_IOCTL_HELPER_GET,
4670	DSL_FALSE, DSL_DRV_G997_LineTransmissionStatusGet,
4671	sizeof(DSL_G997_LineTransmissionStatus_t)),
4672	/* DSL_FIO_G997_LAST_STATE_TRANSMITTED_GET */
4673	DSL_IOCTL_REGISTER(DSL_FIO_G997_LAST_STATE_TRANSMITTED_GET, DSL_IOCTL_HELPER_GET,
4674	DSL_FALSE, DSL_DRV_G997_LastStateTransmittedGet,
4675	sizeof(DSL_G997_LastStateTransmitted_t)),
4676	/* DSL_FIO_G997_DATA_PATH_FAILURES_STATUS_GET */
4677	DSL_IOCTL_REGISTER(DSL_FIO_G997_DATA_PATH_FAILURES_STATUS_GET, DSL_IOCTL_HELPER_GET,
4678	DSL_FALSE, DSL_DRV_G997_DataPathFailuresStatusGet,
4679	sizeof(DSL_G997_DataPathFailures_t)),
4680	#endif /* INCLUDE_DSL_G997_STATUS*/
4681
4682	#ifdef INCLUDE_DSL_G997_LINE_INVENTORY
4683	/* DSL_FIO_G997_LINE_INVENTORY_GET */
4684	DSL_IOCTL_REGISTER(DSL_FIO_G997_LINE_INVENTORY_GET, DSL_IOCTL_HELPER_GET,
4685	DSL_FALSE, DSL_DRV_G997_LineInventoryGet,
4686	sizeof(DSL_G997_LineInventory_t)),
4687	/* DSL_FIO_G997_LINE_INVENTORY_SET */
4688	DSL_IOCTL_REGISTER(DSL_FIO_G997_LINE_INVENTORY_SET, DSL_IOCTL_HELPER_SET,
4689	DSL_FALSE, DSL_DRV_G997_LineInventorySet,
4690	sizeof(DSL_G997_LineInventoryNe_t)),
4691	#endif /* INCLUDE_DSL_G997_LINE_INVENTORY*/
4692
4693	#ifdef INCLUDE_DSL_CONFIG_GET
4694	/* DSL_FIO_G997_LINE_ACTIVATE_CONFIG_GET */
4695	DSL_IOCTL_REGISTER(DSL_FIO_G997_LINE_ACTIVATE_CONFIG_GET, DSL_IOCTL_HELPER_GET,
4696	DSL_FALSE, DSL_DRV_G997_LineActivateConfigGet,
4697	sizeof(DSL_G997_LineActivate_t)),
4698	/* DSL_FIO_G997_RATE_ADAPTATION_CONFIG_GET */
4699	DSL_IOCTL_REGISTER(DSL_FIO_G997_RATE_ADAPTATION_CONFIG_GET, DSL_IOCTL_HELPER_GET,
4700	DSL_FALSE, DSL_DRV_G997_RateAdaptationConfigGet,
4701	sizeof(DSL_G997_RateAdaptationConfig_t)),
4702	#endif /* INCLUDE_DSL_CONFIG_GET*/
4703
4704	#ifdef INCLUDE_DSL_BONDING
4705	/* DSL_FIO_BND_HW_INIT */
4706	DSL_IOCTL_REGISTER(DSL_FIO_BND_HW_INIT, DSL_IOCTL_HELPER_SET,
4707	DSL_FALSE, DSL_DRV_BND_HwInit,
4708	sizeof(DSL_BND_HwInit_t)),
4709	/* DSL_FIO_BND_SETUP */
4710	DSL_IOCTL_REGISTER(DSL_FIO_BND_SETUP, DSL_IOCTL_HELPER_SET,
4711	DSL_FALSE, DSL_DRV_BND_Setup,
4712	sizeof(DSL_BND_Setup_t)),
4713	/* DSL_FIO_BND_CONFIG_SET */
4714	DSL_IOCTL_REGISTER(DSL_FIO_BND_CONFIG_SET, DSL_IOCTL_HELPER_SET,
4715	DSL_FALSE, DSL_DRV_BND_ConfigSet,
4716	sizeof(DSL_BND_ConfigSet_t)),
4717	#ifdef INCLUDE_DSL_CONFIG_GET
4718	/* DSL_FIO_BND_CONFIG_GET */
4719	DSL_IOCTL_REGISTER(DSL_FIO_BND_CONFIG_GET, DSL_IOCTL_HELPER_GET,
4720	DSL_FALSE, DSL_DRV_BND_ConfigGet,
4721	sizeof(DSL_BND_ConfigGet_t)),
4722	#endif /* INCLUDE_DSL_CONFIG_GET*/
4723	/* DSL_FIO_BND_HS_STATUS_GET */
4724	DSL_IOCTL_REGISTER(DSL_FIO_BND_HS_STATUS_GET, DSL_IOCTL_HELPER_GET,
4725	DSL_FALSE, DSL_DRV_BND_HsStatusGet,
4726	sizeof(DSL_BND_HsStatusGet_t)),
4727	/* DSL_FIO_BND_HS_CONTINUE */
4728	DSL_IOCTL_REGISTER(DSL_FIO_BND_HS_CONTINUE, DSL_IOCTL_HELPER_SET,
4729	DSL_FALSE, DSL_DRV_BND_HsContinue,
4730	sizeof(DSL_BND_HsContinue_t)),
4731	/* DSL_FIO_BND_TEAR_DOWN */
4732	DSL_IOCTL_REGISTER(DSL_FIO_BND_TEAR_DOWN, DSL_IOCTL_HELPER_SET,
4733	DSL_FALSE, DSL_DRV_BND_TearDown,
4734	sizeof(DSL_BND_TearDown_t)),
4735	/* DSL_FIO_BND_ETH_DBG_COUNTERS_GET */
4736	DSL_IOCTL_REGISTER(DSL_FIO_BND_ETH_DBG_COUNTERS_GET, DSL_IOCTL_HELPER_GET,
4737	DSL_FALSE, DSL_DRV_BND_EthDbgCountersGet,
4738	sizeof(DSL_BND_EthDbgCounters_t)),
4739	/* DSL_FIO_BND_ETH_COUNTERS_GET */
4740	DSL_IOCTL_REGISTER(DSL_FIO_BND_ETH_COUNTERS_GET, DSL_IOCTL_HELPER_GET,
4741	DSL_FALSE, DSL_DRV_BND_EthCountersGet,
4742	sizeof(DSL_BND_EthCounters_t)),
4743	#endif /* INCLUDE_DSL_BONDING*/
4744
4745	/* DSL_FIO_VERSION_INFORMATION_GET */
4746	DSL_IOCTL_REGISTER(DSL_FIO_VERSION_INFORMATION_GET, DSL_IOCTL_HELPER_GET,
4747	DSL_FALSE, DSL_DRV_VersionInformationGet,
4748	sizeof(DSL_VersionInformation_t)),
4749	#ifdef INCLUDE_DSL_CPE_API_DANUBE
4750	/* DSL_FIO_INTEROP_FEATURE_CONFIG_SET */
4751	DSL_IOCTL_REGISTER(DSL_FIO_INTEROP_FEATURE_CONFIG_SET, DSL_IOCTL_HELPER_SET,
4752	DSL_FALSE, DSL_DRV_InteropFeatureConfigSet,
4753	sizeof(DSL_InteropFeatureConfig_t)),
4754	#endif /* INCLUDE_DSL_CPE_API_DANUBE*/
4755	/* DSL_FIO_INSTANCE_STATUS_GET */
4756	DSL_IOCTL_REGISTER(DSL_FIO_INSTANCE_STATUS_GET, DSL_IOCTL_HELPER_GET,
4757	DSL_TRUE, DSL_DRV_InstanceStatusGet,
4758	sizeof(DSL_InstanceStatus_t)),
4759
4760
4761	#if (INCLUDE_DSL_CPE_API_VDSL_SUPPORT == 1)
4762	/* DSL_FIO_LINE_PATH_COUNTER_TOTAL_GET */
4763	DSL_IOCTL_REGISTER(DSL_FIO_LINE_PATH_COUNTER_TOTAL_GET, DSL_IOCTL_HELPER_GET,
4764	DSL_FALSE, DSL_DRV_LinePathCounterTotalGet,
4765	sizeof(DSL_LinePathCounterTotal_t)),
4766	/* DSL_FIO_DATA_PATH_COUNTER_TOTAL_GET */
4767	DSL_IOCTL_REGISTER(DSL_FIO_DATA_PATH_COUNTER_TOTAL_GET, DSL_IOCTL_HELPER_GET,
4768	DSL_FALSE, DSL_DRV_DataPathCounterTotalGet,
4769	sizeof(DSL_DataPathCounterTotal_t)),
4770	/* DSL_FIO_LOW_LEVEL_CONFIGURATION_SET */
4771	DSL_IOCTL_REGISTER(DSL_FIO_LOW_LEVEL_CONFIGURATION_SET, DSL_IOCTL_HELPER_SET,
4772	DSL_FALSE, DSL_DRV_LowLevelConfigurationSet,
4773	sizeof(DSL_LowLevelConfiguration_t)),
4774	/* DSL_FIO_LOW_LEVEL_CONFIGURATION_GET */
4775	DSL_IOCTL_REGISTER(DSL_FIO_LOW_LEVEL_CONFIGURATION_GET, DSL_IOCTL_HELPER_GET,
4776	DSL_FALSE, DSL_DRV_LowLevelConfigurationGet,
4777	sizeof(DSL_LowLevelConfiguration_t)),
4778	#ifdef INCLUDE_DSL_G997_LINE_INVENTORY
4779	/* DSL_FIO_AUX_LINE_INVENTORY_GET */
4780	DSL_IOCTL_REGISTER(DSL_FIO_AUX_LINE_INVENTORY_GET, DSL_IOCTL_HELPER_GET,
4781	DSL_FALSE, DSL_DRV_AuxLineInventoryGet,
4782	sizeof(DSL_AuxLineInventory_t)),
4783	#endif /* INCLUDE_DSL_G997_LINE_INVENTORY*/
4784	/* DSL_FIO_BAND_PLAN_SUPPORT_GET */
4785	DSL_IOCTL_REGISTER(DSL_FIO_BAND_PLAN_SUPPORT_GET, DSL_IOCTL_HELPER_GET,
4786	DSL_FALSE, DSL_DRV_BandPlanSupportedGet,
4787	sizeof(DSL_BandPlanSupport_t)),
4788	/* DSL_FIO_BAND_PLAN_STATUS_GET */
4789	DSL_IOCTL_REGISTER(DSL_FIO_BAND_PLAN_STATUS_GET, DSL_IOCTL_HELPER_GET,
4790	DSL_FALSE, DSL_DRV_BandPlanStatusGet,
4791	sizeof(DSL_BandPlanStatus_t)),
4792	/* DSL_FIO_EFM_MAC_CONFIG_SET */
4793	DSL_IOCTL_REGISTER(DSL_FIO_EFM_MAC_CONFIG_SET, DSL_IOCTL_HELPER_SET,
4794	DSL_FALSE, DSL_DRV_EfmMacConfigSet,
4795	sizeof(DSL_EFM_MacConfig_t)),
4796	#ifdef INCLUDE_DSL_CONFIG_GET
4797	/* DSL_FIO_EFM_MAC_CONFIG_GET */
4798	DSL_IOCTL_REGISTER(DSL_FIO_EFM_MAC_CONFIG_GET, DSL_IOCTL_HELPER_GET,
4799	DSL_FALSE, DSL_DRV_EfmMacConfigGet,
4800	sizeof(DSL_EFM_MacConfig_t)),
4801	#endif /* INCLUDE_DSL_CONFIG_GET*/
4802	/* DSL_FIO_SAR_CONFIG_SET */
4803	DSL_IOCTL_REGISTER(DSL_FIO_SAR_CONFIG_SET, DSL_IOCTL_HELPER_SET,
4804	DSL_FALSE, DSL_DRV_SAR_ConfigSet,
4805	sizeof(DSL_SAR_Config_t)),
4806	#ifdef INCLUDE_DSL_CONFIG_GET
4807	/* DSL_FIO_SAR_CONFIG_GET */
4808	DSL_IOCTL_REGISTER(DSL_FIO_SAR_CONFIG_GET, DSL_IOCTL_HELPER_GET,
4809	DSL_FALSE, DSL_DRV_SAR_ConfigGet,
4810	sizeof(DSL_SAR_Config_t)),
4811	#endif /* INCLUDE_DSL_CONFIG_GET*/
4812	/* DSL_FIO_SAR_SEGMENTATION_TABLE_SET */
4813	DSL_IOCTL_REGISTER(DSL_FIO_SAR_SEGMENTATION_TABLE_SET, DSL_IOCTL_HELPER_SET,
4814	DSL_FALSE, DSL_DRV_SAR_SegmentationTableSet,
4815	sizeof(DSL_SAR_SegmentationTable_t)),
4816	/* DSL_FIO_SAR_SEGMENTATION_TABLE_GET */
4817	DSL_IOCTL_REGISTER(DSL_FIO_SAR_SEGMENTATION_TABLE_GET, DSL_IOCTL_HELPER_GET,
4818	DSL_FALSE, DSL_DRV_SAR_SegmentationTableGet,
4819	sizeof(DSL_SAR_SegmentationTable_t)),
4820	/* DSL_FIO_SAR_REASSEMBLY_TABLE_SET */
4821	DSL_IOCTL_REGISTER(DSL_FIO_SAR_REASSEMBLY_TABLE_SET, DSL_IOCTL_HELPER_SET,
4822	DSL_FALSE, DSL_DRV_SAR_ReassemblyTableSet,
4823	sizeof(DSL_SAR_ReassemblyTable_t)),
4824	/* DSL_FIO_SAR_REASSEMBLY_TABLE_GET */
4825	DSL_IOCTL_REGISTER(DSL_FIO_SAR_REASSEMBLY_TABLE_GET, DSL_IOCTL_HELPER_GET,
4826	DSL_FALSE, DSL_DRV_SAR_ReassemblyTableGet,
4827	sizeof(DSL_SAR_ReassemblyTable_t)),
4828	/* DSL_FIO_SAR_SEGMENTATION_COUNTERS_GET */
4829	DSL_IOCTL_REGISTER(DSL_FIO_SAR_SEGMENTATION_COUNTERS_GET, DSL_IOCTL_HELPER_GET,
4830	DSL_FALSE, DSL_DRV_SAR_SegmentationCountersGet,
4831	sizeof(DSL_SAR_SegmentationCounters_t)),
4832	/* DSL_FIO_SAR_REASSEMBLY_COUNTERS_GET */
4833	DSL_IOCTL_REGISTER(DSL_FIO_SAR_REASSEMBLY_COUNTERS_GET, DSL_IOCTL_HELPER_GET,
4834	DSL_FALSE, DSL_DRV_SAR_ReassemblyCountersGet,
4835	sizeof(DSL_SAR_ReassemblyCounters_t)),
4836	/* DSL_FIO_UTOPIA_BUS_WIDTH_CONFIG_SET */
4837	DSL_IOCTL_REGISTER(DSL_FIO_UTOPIA_BUS_WIDTH_CONFIG_SET, DSL_IOCTL_HELPER_SET,
4838	DSL_FALSE, DSL_DRV_UtopiaBusWidthConfigSet,
4839	sizeof(DSL_UtopiaBusWidthConfig_t)),
4840	#ifdef INCLUDE_DSL_CONFIG_GET
4841	/* DSL_FIO_UTOPIA_BUS_WIDTH_CONFIG_GET */
4842	DSL_IOCTL_REGISTER(DSL_FIO_UTOPIA_BUS_WIDTH_CONFIG_GET, DSL_IOCTL_HELPER_GET,
4843	DSL_FALSE, DSL_DRV_UtopiaBusWidthConfigGet,
4844	sizeof(DSL_UtopiaBusWidthConfig_t)),
4845	#endif /* INCLUDE_DSL_CONFIG_GET*/
4846
4847	/* DSL_FIO_UTOPIA_ADDRESS_CONFIG_SET */
4848	DSL_IOCTL_REGISTER(DSL_FIO_UTOPIA_ADDRESS_CONFIG_SET, DSL_IOCTL_HELPER_SET,
4849	DSL_FALSE, DSL_DRV_UtopiaAddressConfigSet,
4850	sizeof(DSL_PhyAddressConfig_t)),
4851	#ifdef INCLUDE_DSL_CONFIG_GET
4852	/* DSL_FIO_UTOPIA_ADDRESS_CONFIG_GET */
4853	DSL_IOCTL_REGISTER(DSL_FIO_UTOPIA_ADDRESS_CONFIG_GET, DSL_IOCTL_HELPER_GET,
4854	DSL_FALSE, DSL_DRV_UtopiaAddressConfigGet,
4855	sizeof(DSL_PhyAddressConfig_t)),
4856	#endif /* INCLUDE_DSL_CONFIG_GET*/
4857	#endif /* (INCLUDE_DSL_CPE_API_VDSL_SUPPORT == 1)*/
4858
4859	#ifdef INCLUDE_DSL_RESOURCE_STATISTICS
4860	/* DSL_FIO_RESOURCE_USAGE_STATISTICS_GET */
4861	DSL_IOCTL_REGISTER(DSL_FIO_RESOURCE_USAGE_STATISTICS_GET, DSL_IOCTL_HELPER_GET,
4862	DSL_FALSE, DSL_DRV_ResourceUsageStatisticsGet,
4863	sizeof(DSL_ResourceUsageStatistics_t)),
4864	#endif /* INCLUDE_DSL_RESOURCE_STATISTICS*/
4865
4866	#ifdef INCLUDE_DSL_FRAMING_PARAMETERS
4867	/* DSL_FIO_FRAMING_PARAMETER_STATUS_GET */
4868	DSL_IOCTL_REGISTER(DSL_FIO_FRAMING_PARAMETER_STATUS_GET, DSL_IOCTL_HELPER_GET,
4869	DSL_FALSE, DSL_DRV_FramingParameterStatusGet,
4870	sizeof(DSL_FramingParameterStatus_t)),
4871	#endif /* INCLUDE_DSL_FRAMING_PARAMETERS*/
4872
4873	/* DSL_FIO_TEST_MODE_CONTROL_SET */
4874	DSL_IOCTL_REGISTER(DSL_FIO_TEST_MODE_CONTROL_SET, DSL_IOCTL_HELPER_SET,
4875	DSL_FALSE, DSL_DRV_TestModeControlSet,
4876	sizeof(DSL_TestModeControl_t)),
4877	/* DSL_FIO_TEST_MODE_STATUS_GET */
4878	DSL_IOCTL_REGISTER(DSL_FIO_TEST_MODE_STATUS_GET, DSL_IOCTL_HELPER_GET,
4879	DSL_FALSE, DSL_DRV_TestModeStatusGet,
4880	sizeof(DSL_TestModeStatus_t)),
4881	/* DSL_FIO_LINE_FEATURE_STATUS_GET */
4882	DSL_IOCTL_REGISTER(DSL_FIO_LINE_FEATURE_STATUS_GET, DSL_IOCTL_HELPER_GET,
4883	DSL_FALSE, DSL_DRV_LineFeatureStatusGet,
4884	sizeof(DSL_LineFeature_t)),
4885	#ifndef DSL_DEBUG_DISABLE
4886	/* DSL_FIO_DBG_MODULE_LEVEL_SET */
4887	DSL_IOCTL_REGISTER(DSL_FIO_DBG_MODULE_LEVEL_SET, DSL_IOCTL_HELPER_SET,
4888	DSL_FALSE, DSL_DRV_DBG_ModuleLevelSet,
4889	sizeof(DSL_DBG_ModuleLevel_t)),
4890	/* DSL_FIO_DBG_MODULE_LEVEL_GET */
4891	DSL_IOCTL_REGISTER(DSL_FIO_DBG_MODULE_LEVEL_GET, DSL_IOCTL_HELPER_GET,
4892	DSL_FALSE, DSL_DRV_DBG_ModuleLevelGet,
4893	sizeof(DSL_DBG_ModuleLevel_t)),
4894	#endif /* DSL_DEBUG_DISABLE*/
4895	/* IOCTL: Dummy delimeter */
4896	DSL_IOCTL_REGISTER(0, DSL_IOCTL_HELPER_UNKNOWN, DSL_FALSE, DSL_NULL, 0)
4897	};
4898
4899	/*
4900	For a detailed description of the function, its arguments and return value
4901	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
4902	*/
4903	DSL_Error_t DSL_DRV_IoctlHandle(
4904	DSL_OpenContext_t *pOpenCtx,
4905	DSL_Context_t *pContext,
4906	DSL_boolean_t bIsInKernel,
4907	DSL_uint_t nCommand,
4908	DSL_uint32_t nArg)
4909	{
4910	DSL_Error_t nErrCode = DSL_ERROR;
4911	DSL_IOCTL_arg_t *pIOCTL_arg = DSL_NULL;
4912	DSL_EventData_Union_t *pEventData;
4913	DSL_uint8_t pMsgBuf, pOldMsgBuf;
4914	#ifdef INCLUDE_DSL_CPE_TRACE_BUFFER
4915	DSL_uint16_t i; /* FOR DEBUG */
4916	#endif
4917	DSL_boolean_t bEventActivation = DSL_FALSE;
4918	DSL_BF_ResourceActivationType_t nResourceActivationMask;
4919	DSL_EventStatusData_t event;
4920	DSL_IOCTL_Table_t *pIoctlTable = ioctlTable;
4921	DSL_boolean_t bIoctlFound = DSL_FALSE;
4922
4923	#ifndef DSL_DEBUG_DISABLE
4924	DSL_DEBUG(DSL_DBG_MSG,
4925	(pContext, "DSL[%02d]: IN - DSL_DRV_IoctlHandle, call %d - "
4926	"(%s)"DSL_DRV_CRLF, DSL_DEV_NUM(pContext),
4927	nCommand, DSL_DBG_IoctlName(nCommand)));
4928	#endif /* DSL_DEBUG_DISABLE*/
4929
4930	switch (nCommand)
4931	{
4932	case DSL_FIO_INIT:
4933	pIOCTL_arg = DSL_DRV_VMalloc(sizeof(DSL_Init_t));
4934
4935	if(pIOCTL_arg == DSL_NULL)
4936	{
4937	DSL_IoctlMemCpyTo( bIsInKernel, (DSL_void_t*)nArg, &nErrCode,
4938	sizeof(DSL_Error_t));
4939	break;
4940	}
4941
4942	if (nArg == 0)
4943	{
4944	nErrCode = DSL_ERR_INVALID_PARAMETER;
4945	}
4946	else
4947	{
4948	DSL_IoctlMemCpyFrom(bIsInKernel, pIOCTL_arg, (DSL_void_t*)nArg,
4949	sizeof(DSL_Init_t));
4950
4951	nErrCode = DSL_DRV_InitDataPrepare(pContext, bIsInKernel, &(pIOCTL_arg->init));
4952	if (nErrCode == DSL_SUCCESS)
4953	{
4954	nErrCode = DSL_DRV_Init(pContext, &(pIOCTL_arg->init));
4955	}
4956
4957	DSL_DRV_InitDataFree(pContext, &(pIOCTL_arg->init));
4958
4959	DSL_DEBUG(DSL_DBG_MSG,
4960	(pContext, "DSL[%02d]: DSL_DRV_IoctlHandle - return"
4961	"(from DSL_FIO_INIT) %d"DSL_DRV_CRLF, DSL_DEV_NUM(pContext), nErrCode));
4962	DSL_IoctlMemCpyTo( bIsInKernel, (DSL_void_t*)nArg, &nErrCode,
4963	sizeof(DSL_Error_t));
4964	}
4965	break;
4966
4967	#ifdef INCLUDE_DSL_CPE_TRACE_BUFFER
4968	case DSL_FIO_SHOWTIME_LOGGING_DATA_GET:
4969	pIOCTL_arg = DSL_DRV_VMalloc(sizeof(DSL_ShowtimeLogging_t));
4970
4971	if(pIOCTL_arg == DSL_NULL)
4972	{
4973	DSL_IoctlMemCpyTo( bIsInKernel, (DSL_void_t*)nArg, &nErrCode,
4974	sizeof(DSL_Error_t));
4975	break;
4976	}
4977
4978	if (nArg == 0)
4979	{
4980	nErrCode = DSL_ERR_INVALID_PARAMETER;
4981	}
4982	else
4983	{
4984	DSL_IoctlMemCpyFrom(bIsInKernel, pIOCTL_arg, (DSL_void_t*)nArg,
4985	sizeof(DSL_ShowtimeLogging_t));
4986
4987	DSL_DEBUG(DSL_DBG_MSG, (pContext,
4988	"DSL[%02d]: DEBUG:2:: showtime event logging data (in the kernel space):",
4989	DSL_DEV_NUM(pContext)));
4990	for (i = 0; i < DSL_DEV_SHOWTIME_EVENT_LOGGING_BUFFER_LENGTH; i++)
4991	{
4992	if (i % 10 == 0) DSL_DEBUG(DSL_DBG_MSG, (pContext, DSL_DRV_CRLF));
4993	DSL_DEBUG(DSL_DBG_MSG, (pContext, "0x%04X ", pContext->loggingBuffer[i]));
4994	}
4995	DSL_DEBUG(DSL_DBG_MSG, (pContext, DSL_DRV_CRLF DSL_DRV_CRLF));
4996
4997	if (pIOCTL_arg->showtimeLogging.data.pData == DSL_NULL)
4998	{
4999	/* in this case return data size only */
5000	pIOCTL_arg->showtimeLogging.data.nDataSize =
5001	DSL_DEV_SHOWTIME_EVENT_LOGGING_BUFFER_LENGTH * 2;
5002	nErrCode = DSL_SUCCESS;
5003	}
5004	else
5005	{
5006	if ((pIOCTL_arg->showtimeLogging.data.nDataOffset >=
5007	DSL_DEV_SHOWTIME_EVENT_LOGGING_BUFFER_LENGTH * 2) \|\|
5008	pIOCTL_arg->showtimeLogging.data.nDataSize == 0)
5009	{
5010	nErrCode = DSL_ERR_INVALID_PARAMETER;
5011	}
5012	else
5013	{
5014	if (pIOCTL_arg->showtimeLogging.data.nDataSize >=
5015	(DSL_DEV_SHOWTIME_EVENT_LOGGING_BUFFER_LENGTH * 2 -
5016	pIOCTL_arg->showtimeLogging.data.nDataOffset))
5017	{
5018	DSL_IoctlMemCpyTo(bIsInKernel,
5019	pIOCTL_arg->showtimeLogging.data.pData,
5020	pContext->loggingBuffer,
5021	DSL_DEV_SHOWTIME_EVENT_LOGGING_BUFFER_LENGTH * 2 -
5022	pIOCTL_arg->showtimeLogging.data.nDataOffset);
5023	pIOCTL_arg->showtimeLogging.data.nDataOffset = 0;
5024	pIOCTL_arg->showtimeLogging.data.nDataSize =
5025	DSL_DEV_SHOWTIME_EVENT_LOGGING_BUFFER_LENGTH * 2 -
5026	pIOCTL_arg->showtimeLogging.data.nDataOffset;
5027	}
5028	else
5029	{
5030	DSL_IoctlMemCpyTo(bIsInKernel,
5031	pIOCTL_arg->showtimeLogging.data.pData,
5032	pContext->loggingBuffer,
5033	pIOCTL_arg->showtimeLogging.data.nDataSize);
5034	pIOCTL_arg->showtimeLogging.data.nDataOffset +=
5035	pIOCTL_arg->showtimeLogging.data.nDataSize;
5036	}
5037	nErrCode = DSL_SUCCESS;
5038	}
5039	}
5040
5041	if (pIOCTL_arg->showtimeLogging.data.pData)
5042	{
5043	DSL_DEBUG(DSL_DBG_MSG, (pContext,
5044	"DSL[%02d]: DEBUG:3:: showtime event logging data (in the user space):",
5045	DSL_DEV_NUM(pContext)));
5046	for (i = 0; i < pIOCTL_arg->showtimeLogging.data.nDataSize / 2; i++)
5047	{
5048	if (i % 10 == 0) DSL_DEBUG(DSL_DBG_MSG, (pContext, DSL_DRV_CRLF));
5049	DSL_DEBUG(DSL_DBG_MSG, (pContext, "0x%04X ",
5050	((DSL_uint16_t*)(pIOCTL_arg->showtimeLogging.data.pData))[i]));
5051	}
5052	DSL_DEBUG(DSL_DBG_MSG, (pContext, DSL_DRV_CRLF DSL_DRV_CRLF));
5053	}
5054
5055	pIOCTL_arg->showtimeLogging.accessCtl.nReturn = nErrCode;
5056
5057	if (nErrCode == DSL_SUCCESS)
5058	{
5059	DSL_IoctlMemCpyTo( bIsInKernel, (DSL_void_t*)nArg, pIOCTL_arg,
5060	sizeof(DSL_ShowtimeLogging_t));
5061	}
5062	else
5063	{
5064	DSL_IoctlMemCpyTo( bIsInKernel, (DSL_void_t*)nArg, &nErrCode,
5065	sizeof(DSL_Error_t));
5066	}
5067	}
5068	break;
5069	#endif /* INCLUDE_DSL_CPE_TRACE_BUFFER*/
5070
5071	case DSL_FIO_DBG_DEVICE_MESSAGE_SEND:
5072	pIOCTL_arg = DSL_DRV_VMalloc(sizeof(DSL_DeviceMessage_t));
5073
5074	if(pIOCTL_arg == DSL_NULL)
5075	{
5076	DSL_IoctlMemCpyTo( bIsInKernel, (DSL_void_t*)nArg, &nErrCode,
5077	sizeof(DSL_Error_t));
5078	break;
5079	}
5080
5081	if (nArg == 0)
5082	{
5083	nErrCode = DSL_ERR_INVALID_PARAMETER;
5084	}
5085	else
5086	{
5087	DSL_IoctlMemCpyFrom(bIsInKernel, pIOCTL_arg, (DSL_void_t*)nArg,
5088	sizeof(DSL_DeviceMessage_t));
5089
5090	if ((pOldMsgBuf = pIOCTL_arg->dbgMsg.data.pMsg) == DSL_NULL)
5091	{
5092	nErrCode = DSL_ERR_INVALID_PARAMETER;
5093	}
5094	else
5095	{
5096	pMsgBuf = DSL_DRV_VMalloc(
5097	(pIOCTL_arg->dbgMsg.data.nSizeRx
5098	> pIOCTL_arg->dbgMsg.data.nSizeTx) ?
5099	pIOCTL_arg->dbgMsg.data.nSizeRx :
5100	pIOCTL_arg->dbgMsg.data.nSizeTx);
5101	if (pMsgBuf == DSL_NULL)
5102	{
5103	nErrCode = DSL_ERR_MEMORY;
5104	}
5105	else
5106	{
5107	DSL_IoctlMemCpyFrom(bIsInKernel, pMsgBuf, pOldMsgBuf,
5108	pIOCTL_arg->dbgMsg.data.nSizeTx);
5109
5110	pIOCTL_arg->dbgMsg.data.pMsg = pMsgBuf;
5111	nErrCode = DSL_DRV_DBG_DeviceMessageSend(pContext,
5112	&pIOCTL_arg->dbgMsg);
5113
5114	if (nErrCode == DSL_SUCCESS)
5115	{
5116	if (pIOCTL_arg->dbgMsg.data.nSizeRx != 0)
5117	{
5118	DSL_IoctlMemCpyTo(bIsInKernel, pOldMsgBuf, pMsgBuf,
5119	pIOCTL_arg->dbgMsg.data.nSizeRx);
5120	}
5121	pIOCTL_arg->dbgMsg.data.pMsg = pOldMsgBuf;
5122	DSL_IoctlMemCpyTo( bIsInKernel, (DSL_void_t*)nArg, pIOCTL_arg,
5123	sizeof(DSL_DeviceMessage_t));
5124	}
5125	DSL_DRV_VFree(pMsgBuf);
5126	}
5127	}
5128
5129	DSL_IoctlMemCpyTo( bIsInKernel, (DSL_void_t*)nArg, &nErrCode,
5130	sizeof(DSL_Error_t));
5131	}
5132	break;
5133
5134	case DSL_FIO_EVENT_STATUS_GET:
5135	pIOCTL_arg = DSL_DRV_VMalloc(sizeof(DSL_EventStatus_t));
5136
5137	if(pIOCTL_arg == DSL_NULL)
5138	{
5139	DSL_IoctlMemCpyTo( bIsInKernel, (DSL_void_t*)nArg, &nErrCode,
5140	sizeof(DSL_Error_t));
5141	break;
5142	}
5143
5144	if (nArg == 0)
5145	{
5146	nErrCode = DSL_ERR_INVALID_PARAMETER;
5147	}
5148	else
5149	{
5150	DSL_IoctlMemCpyFrom(bIsInKernel, pIOCTL_arg, (DSL_void_t*)nArg,
5151	sizeof(DSL_EventStatus_t));
5152
5153	pEventData = pIOCTL_arg->event.data.pData;
5154
5155	/* Lock Open Context list*/
5156	if (DSL_DRV_MUTEX_LOCK(pContext->pDevCtx->openContextListMutex))
5157	{
5158	DSL_DEBUG( DSL_DBG_ERR,
5159	(DSL_NULL, "DSL[%02d]: ERROR - Couldn't lock Context List mutex!"DSL_DRV_CRLF,
5160	DSL_DEV_NUM(pContext)));
5161
5162	nErrCode = DSL_ERR_SEMAPHORE_GET;
5163	break;
5164	}
5165
5166	nErrCode = DSL_DRV_EventUnqueue(pOpenCtx, &pIOCTL_arg->event.data);
5167
5168	/* Unlock Open Context list*/
5169	DSL_DRV_MUTEX_UNLOCK(pContext->pDevCtx->openContextListMutex);
5170
5171	pIOCTL_arg->event.accessCtl.nReturn = nErrCode;
5172
5173	if (nErrCode == DSL_SUCCESS)
5174	{
5175	if (pEventData != DSL_NULL && pIOCTL_arg->event.data.pData
5176	!= DSL_NULL)
5177	{
5178	DSL_IoctlMemCpyTo( bIsInKernel, (DSL_void_t*)pEventData,
5179	pIOCTL_arg->event.data.pData,
5180	sizeof(DSL_EventData_Union_t));
5181	}
5182
5183	if (pIOCTL_arg->event.data.pData != DSL_NULL)
5184	{
5185	DSL_DRV_VFree(pIOCTL_arg->event.data.pData);
5186	pIOCTL_arg->event.data.pData = pEventData;
5187	}
5188	else
5189	{
5190	pIOCTL_arg->event.data.pData = pEventData;
5191	}
5192
5193	DSL_IoctlMemCpyTo( bIsInKernel, (DSL_void_t*)nArg, pIOCTL_arg,
5194	sizeof(DSL_EventStatus_t));
5195	}
5196	else
5197	{
5198	DSL_IoctlMemCpyTo( bIsInKernel, (DSL_void_t*)nArg, &nErrCode,
5199	sizeof(DSL_Error_t));
5200	}
5201
5202	if (nErrCode >= DSL_SUCCESS)
5203	{
5204	nErrCode = DSL_SUCCESS;
5205	}
5206	}
5207
5208	break;
5209
5210	case DSL_FIO_INSTANCE_CONTROL_SET:
5211	pIOCTL_arg = DSL_DRV_VMalloc(sizeof(DSL_InstanceControl_t));
5212
5213	if(pIOCTL_arg == DSL_NULL)
5214	{
5215	DSL_IoctlMemCpyTo( bIsInKernel, (DSL_void_t*)nArg, &nErrCode,
5216	sizeof(DSL_Error_t));
5217	break;
5218	}
5219
5220	if (nArg == 0)
5221	{
5222	nErrCode = DSL_ERR_INVALID_PARAMETER;
5223	}
5224	else
5225	{
5226	DSL_IoctlMemCpyFrom(bIsInKernel, pIOCTL_arg, (DSL_void_t*)nArg,
5227	sizeof(DSL_InstanceControl_t));
5228
5229	nErrCode = DSL_SUCCESS;
5230
5231	/* Get bEventActivation flag*/
5232	bEventActivation = (((DSL_InstanceControl_t*)nArg)->data.bEventActivation);
5233	/* Get nResourceActivationMask data*/
5234	nResourceActivationMask = (((DSL_InstanceControl_t*)nArg)->data.nResourceActivationMask);
5235
5236	/* Lock Open Context list*/
5237	if (DSL_DRV_MUTEX_LOCK(pContext->pDevCtx->openContextListMutex))
5238	{
5239	DSL_DEBUG( DSL_DBG_ERR,
5240	(DSL_NULL, "DSL[%02d]: ERROR - Couldn't lock Context List mutex!"DSL_DRV_CRLF,
5241	DSL_DEV_NUM(pContext)));
5242
5243	nErrCode = DSL_ERR_SEMAPHORE_GET;
5244	break;
5245	}
5246
5247	/*
5248	Proceed Event Activation Contriol settings
5249	*/
5250	if(DSL_DRV_MUTEX_LOCK(pOpenCtx->eventMutex))
5251	{
5252	DSL_DEBUG( DSL_DBG_ERR,
5253	(pContext, "DSL[%02d]: Couldn't lock event mutex"DSL_DRV_CRLF,
5254	DSL_DEV_NUM(pContext)));
5255	nErrCode = DSL_ERROR;
5256	}
5257	else
5258	{
5259	if (bEventActivation == DSL_FALSE)
5260	{
5261	DSL_DRV_MUTEX_UNLOCK(pOpenCtx->eventMutex);
5262	/** free event structures */
5263	if (pOpenCtx->eventFifo != DSL_NULL && pOpenCtx->eventFifoBuf != DSL_NULL)
5264	{
5265	while (!DSL_Fifo_isEmpty(pOpenCtx->eventFifo))
5266	{
5267	if (DSL_DRV_EventUnqueue(pOpenCtx, &event) >= DSL_SUCCESS)
5268	{
5269	if (event.pData != DSL_NULL)
5270	{
5271	DSL_DRV_VFree(event.pData);
5272	}
5273	}
5274	}
5275	}
5276
5277	if(DSL_DRV_MUTEX_LOCK(pOpenCtx->eventMutex))
5278	{
5279	DSL_DEBUG( DSL_DBG_ERR,
5280	(pContext, "DSL[%02d]: Couldn't lock event mutex"DSL_DRV_CRLF,
5281	DSL_DEV_NUM(pContext)));
5282	nErrCode = DSL_ERROR;
5283	}
5284	else
5285	{
5286	/* release event structures */
5287	if (pOpenCtx->eventFifo != DSL_NULL)
5288	{
5289	DSL_DRV_VFree(pOpenCtx->eventFifo);
5290	pOpenCtx->eventFifo = DSL_NULL;
5291	}
5292
5293	/* release event structures */
5294	if (pOpenCtx->eventFifoBuf != DSL_NULL)
5295	{
5296	DSL_DRV_VFree(pOpenCtx->eventFifoBuf);
5297	pOpenCtx->eventFifoBuf = DSL_NULL;
5298	}
5299	}
5300	}
5301	else
5302	{
5303	/* initialize event structures */
5304	pOpenCtx->eventFifo = DSL_DRV_VMalloc(sizeof(DSL_FIFO));
5305	if (pOpenCtx->eventFifo == DSL_NULL)
5306	{
5307	DSL_DEBUG(DSL_DBG_ERR,
5308	(DSL_NULL, "DSL[%02d]: Open failed, "
5309	"could not allocate memory for event FIFO..."DSL_DRV_CRLF,
5310	DSL_DEV_NUM(pContext)));
5311	nErrCode = DSL_ERR_MEMORY;
5312	}
5313	else
5314	{
5315	pOpenCtx->eventFifoBuf = DSL_DRV_VMalloc(DSL_EVENT_FIFO_ELEMENT_COUNT
5316	* sizeof(DSL_EventStatusData_t));
5317	if (pOpenCtx->eventFifoBuf == DSL_NULL)
5318	{
5319	DSL_DEBUG(DSL_DBG_ERR,
5320	(DSL_NULL, "DSL[%02d]: Open failed, "
5321	"could not allocate memory for event FIFO..."DSL_DRV_CRLF,
5322	DSL_DEV_NUM(pContext)));
5323	DSL_DRV_VFree(pOpenCtx->eventFifo);
5324	nErrCode = DSL_ERR_MEMORY;
5325	}
5326	else
5327	{
5328	/* init event fifo */
5329	if (DSL_Fifo_Init(pOpenCtx->eventFifo,
5330	pOpenCtx->eventFifoBuf,
5331	pOpenCtx->eventFifoBuf +
5332	(DSL_EVENT_FIFO_ELEMENT_COUNT - 1) *
5333	sizeof(DSL_EventStatusData_t),
5334	sizeof(DSL_EventStatusData_t)) != 0)
5335	{
5336	DSL_DEBUG(DSL_DBG_ERR,
5337	(DSL_NULL, "DSL[%02d]: Internal error in the DSL "
5338	"CPE API. Could not prepare FIFO for the events."DSL_DRV_CRLF,
5339	DSL_DEV_NUM(pContext)));
5340	DSL_DRV_VFree(pOpenCtx->eventFifoBuf);
5341	DSL_DRV_VFree(pOpenCtx->eventFifo);
5342	nErrCode = DSL_ERR_INTERNAL;
5343	}
5344	}
5345	}
5346	}
5347
5348	pOpenCtx->bEventActivation = bEventActivation;
5349	pOpenCtx->nResourceActivationMask = nResourceActivationMask;
5350	DSL_DRV_MUTEX_UNLOCK(pOpenCtx->eventMutex);
5351	}
5352
5353	/*
5354	Proceed Resource activation settings settings
5355	*/
5356	#ifdef INCLUDE_DSL_CEOC
5357	if(DSL_DRV_MUTEX_LOCK(pOpenCtx->rxSnmpFifoMutex))
5358	{
5359	DSL_DEBUG( DSL_DBG_ERR,
5360	(pContext, "DSL[%02d]: Couldn't lock Rx SNMP FIFO mutex"DSL_DRV_CRLF,
5361	DSL_DEV_NUM(pContext)));
5362	nErrCode = DSL_ERR_SEMAPHORE_GET;
5363	}
5364	else
5365	{
5366	if (nResourceActivationMask & DSL_RESOURCE_ACTIVATION_SNMP)
5367	{
5368	/* release event structures */
5369	if (pOpenCtx->rxSnmpFifo != DSL_NULL)
5370	{
5371	DSL_DRV_VFree(pOpenCtx->rxSnmpFifo);
5372	pOpenCtx->rxSnmpFifo = DSL_NULL;
5373	}
5374
5375	/* release event structures */
5376	if (pOpenCtx->rxSnmpFifoBuf != DSL_NULL)
5377	{
5378	DSL_DRV_VFree(pOpenCtx->rxSnmpFifoBuf);
5379	pOpenCtx->rxSnmpFifoBuf = DSL_NULL;
5380	}
5381	}
5382	else
5383	{
5384	/* initialize event structures */
5385	pOpenCtx->rxSnmpFifo = DSL_DRV_VMalloc(sizeof(DSL_FIFO));
5386	if (pOpenCtx->rxSnmpFifo == DSL_NULL)
5387	{
5388	DSL_DEBUG(DSL_DBG_ERR,
5389	(DSL_NULL, "DSL[%02d]: Could not allocate memory for SNMP FIFO!!!"DSL_DRV_CRLF,
5390	DSL_DEV_NUM(pContext)));
5391	nErrCode = DSL_ERR_MEMORY;
5392	}
5393	else
5394	{
5395	pOpenCtx->rxSnmpFifoBuf =
5396	DSL_DRV_VMalloc(DSL_CEOC_RX_FIFO_ELEMENT_COUNT * sizeof(DSL_G997_SnmpData_t));
5397	if (pOpenCtx->rxSnmpFifoBuf == DSL_NULL)
5398	{
5399	DSL_DEBUG(DSL_DBG_ERR,
5400	(DSL_NULL, "DSL[%02d]: Could not allocate memory for SNMP FIFO buffer!!!"DSL_DRV_CRLF,
5401	DSL_DEV_NUM(pContext)));
5402	DSL_DRV_VFree(pOpenCtx->rxSnmpFifo);
5403	nErrCode = DSL_ERR_MEMORY;
5404	}
5405	else
5406	{
5407	/* init event fifo */
5408	if (DSL_Fifo_Init(
5409	pOpenCtx->rxSnmpFifo,
5410	pOpenCtx->rxSnmpFifoBuf,
5411	pOpenCtx->rxSnmpFifoBuf +
5412	sizeof(DSL_CEOC_Message_t)*(DSL_CEOC_RX_FIFO_ELEMENT_COUNT - 1),
5413	sizeof(DSL_CEOC_Message_t)) != 0)
5414	{
5415	DSL_DEBUG(DSL_DBG_ERR,
5416	(DSL_NULL, "DSL[%02d]: Internal error in the DSL "
5417	"CPE API. Could not prepare FIFO for the events."DSL_DRV_CRLF,
5418	DSL_DEV_NUM(pContext)));
5419	DSL_DRV_VFree(pOpenCtx->rxSnmpFifoBuf);
5420	DSL_DRV_VFree(pOpenCtx->rxSnmpFifo);
5421	nErrCode = DSL_ERR_INTERNAL;
5422	}
5423	}
5424	}
5425	}
5426	pOpenCtx->nResourceActivationMask = nResourceActivationMask;
5427	DSL_DRV_MUTEX_UNLOCK(pOpenCtx->rxSnmpFifoMutex);
5428	}
5429	#endif /* #ifdef INCLUDE_DSL_CEOC*/
5430
5431	/* Unlock Open Context list*/
5432	DSL_DRV_MUTEX_UNLOCK(pContext->pDevCtx->openContextListMutex);
5433
5434	DSL_IoctlMemCpyTo( bIsInKernel, (DSL_void_t*)nArg, &nErrCode,
5435	sizeof(DSL_Error_t));
5436	}
5437	break;
5438
5439	default:
5440	/* Search for the available IOCTL*/
5441	while (pIoctlTable->pFunc)
5442	{
5443	if (pIoctlTable->nCommand != nCommand)
5444	{
5445	/* Move to the next Table entry*/
5446	pIoctlTable++;
5447	continue;
5448	}
5449
5450	nErrCode = DSL_DRV_IoctlHandleHelperCall(pOpenCtx, pContext,
5451	bIsInKernel, pIoctlTable->bInstanceCall, pIoctlTable->accessType,
5452	pIoctlTable->pFunc, (DSL_void_t*)nArg, pIoctlTable->nArgSz);
5453
5454	bIoctlFound = DSL_TRUE;
5455	break;
5456	}
5457
5458	if (!bIoctlFound)
5459	{
5460	nErrCode = DSL_ERR_IOCTL_NOT_SUPPORTED;
5461	DSL_IoctlMemCpyTo( bIsInKernel, (DSL_void_t*)nArg, &nErrCode,
5462	sizeof(DSL_Error_t));
5463	}
5464	break;
5465	}
5466
5467	if (pIOCTL_arg != DSL_NULL)
5468	{
5469	DSL_DRV_VFree(pIOCTL_arg);
5470	}
5471
5472	DSL_DEBUG(DSL_DBG_MSG, (pContext, "DSL[%02d]: OUT - DSL_DRV_IoctlHandle,"
5473	" return(from %d - %s) %d"DSL_DRV_CRLF,
5474	DSL_DEV_NUM(pContext), nCommand, DSL_DBG_IoctlName(nCommand),
5475	nErrCode));
5476
5477	return nErrCode;
5478	}
5479
5480	/*
5481	For a detailed description of the function, its arguments and return value
5482	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
5483	*/
5484	DSL_Error_t DSL_DRV_TestModeControlSet(
5485	DSL_IN DSL_Context_t *pContext,
5486	DSL_IN_OUT DSL_TestModeControl_t *pData)
5487	{
5488	DSL_Error_t nErrCode = DSL_SUCCESS;
5489	DSL_TestModeControlSet_t nTestModeControl = DSL_TESTMODE_DISABLE;
5490
5491	DSL_DEBUG(DSL_DBG_MSG,
5492	(pContext, "DSL[%02d]: IN - DSL_TestModeControlSet"DSL_DRV_CRLF,
5493	DSL_DEV_NUM(pContext)));
5494
5495	DSL_CHECK_POINTER(pContext, pData);
5496	DSL_CHECK_ERR_CODE();
5497
5498
5499	if (pData->data.nTestMode >= DSL_TESTMODE_LAST \|\|
5500	pData->data.nTestMode < DSL_TESTMODE_DISABLE)
5501	{
5502	DSL_DEBUG(DSL_DBG_ERR,
5503	(pContext, "DSL[%02d]: ERROR - Wrong test mode (%d) specified!"DSL_DRV_CRLF,
5504	DSL_DEV_NUM(pContext), pData->data.nTestMode));
5505	return DSL_ERR_INVALID_PARAMETER;
5506	}
5507
5508	/* Get current settings for the Test mode*/
5509	DSL_CTX_READ(pContext, nErrCode, nTestModeControl, nTestModeControl);
5510
5511	/* Call device specific stuff*/
5512	nErrCode = DSL_DRV_DEV_TestModeControlSet(pContext,pData);
5513
5514	if ((pData->data.nTestMode == DSL_TESTMODE_DISABLE \|\|
5515	pData->data.nTestMode == DSL_TESTMODE_QUIET \|\|
5516	((pData->data.nTestMode == DSL_TESTMODE_SHOWTIME_LOCK) &&
5517	(nTestModeControl != DSL_TESTMODE_SHOWTIME_LOCK)) \|\|
5518	((pData->data.nTestMode == DSL_TESTMODE_TRAINING_LOCK) &&
5519	(nTestModeControl != DSL_TESTMODE_TRAINING_LOCK))) && nErrCode == DSL_SUCCESS)
5520	{
5521	/* Trigger restart sequence*/
5522	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, bAutobootRestart, DSL_TRUE);
5523	}
5524
5525	DSL_DEBUG(DSL_DBG_MSG,
5526	(pContext, "DSL[%02d]: OUT - DSL_TestModeControlSet"DSL_DRV_CRLF,
5527	DSL_DEV_NUM(pContext)));
5528
5529	return nErrCode;
5530	}
5531
5532	/*
5533	For a detailed description of the function, its arguments and return value
5534	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
5535	*/
5536	DSL_Error_t DSL_DRV_TestModeStatusGet(
5537	DSL_IN DSL_Context_t *pContext,
5538	DSL_IN_OUT DSL_TestModeStatus_t *pData)
5539	{
5540	DSL_Error_t nErrCode = DSL_SUCCESS;
5541
5542	DSL_DEBUG(DSL_DBG_MSG,
5543	(pContext, "DSL[%02d]: IN - DSL_DRV_TestModeStatusGet"DSL_DRV_CRLF,
5544	DSL_DEV_NUM(pContext)));
5545
5546	DSL_CHECK_POINTER(pContext, pData);
5547	DSL_CHECK_ERR_CODE();
5548
5549	DSL_CTX_READ(pContext, nErrCode, nTestModeControl, pData->data.nTestMode);
5550
5551	DSL_DEBUG(DSL_DBG_MSG,
5552	(pContext, "DSL[%02d]: OUT - DSL_DRV_TestModeStatusGet"DSL_DRV_CRLF,
5553	DSL_DEV_NUM(pContext)));
5554
5555	return nErrCode;
5556	}
5557
5558	/*
5559	For a detailed description of the function, its arguments and return value
5560	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
5561	*/
5562	DSL_Error_t DSL_DRV_LineStateUpdate(
5563	DSL_Context_t *pContext)
5564	{
5565	DSL_Error_t nErrCode = DSL_SUCCESS;
5566	DSL_LineStateValue_t nLineState = DSL_LINESTATE_UNKNOWN,
5567	nPrevLineState = DSL_LINESTATE_UNKNOWN;
5568
5569	DSL_DEBUG(DSL_DBG_MSG,
5570	(pContext, "DSL[%02d]: IN - DSL_DRV_LineStateUpdate"DSL_DRV_CRLF,
5571	DSL_DEV_NUM(pContext)));
5572
5573	/* Get Line State from the DSL CPE internal memory*/
5574	DSL_CTX_READ_SCALAR(pContext, nErrCode, nLineState, nPrevLineState);
5575	if(nErrCode != DSL_SUCCESS)
5576	{
5577	return nErrCode;
5578	}
5579
5580	nErrCode = DSL_DRV_DEV_LineStateGet(pContext, &nLineState);
5581	if (nErrCode == DSL_SUCCESS)
5582	{
5583	DSL_DRV_LineStateSet(pContext, nLineState);
5584	}
5585	else
5586	{
5587	DSL_DEBUG(DSL_DBG_ERR,
5588	(pContext, "DSL[%02d]: ERROR - Could not get line state "
5589	"from the device!"DSL_DRV_CRLF, DSL_DEV_NUM(pContext)));
5590	}
5591
5592	DSL_DEBUG(DSL_DBG_MSG,
5593	(pContext, "DSL[%02d]: OUT - DSL_DRV_LineStateUpdate, retCode=%d"DSL_DRV_CRLF,
5594	DSL_DEV_NUM(pContext), nErrCode));
5595
5596	return nErrCode;
5597	}
5598
5599	DSL_DEV_Handle_t DSL_DRV_LowDeviceGet(DSL_devCtx_t *pDevCtx)
5600	{
5601	return pDevCtx->lowHandle;
5602	}
5603
5604	/*
5605	For a detailed description of the function, its arguments and return value
5606	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
5607	*/
5608	DSL_Error_t DSL_DRV_FwDownload(
5609	DSL_Context_t *pContext,
5610	const DSL_char_t *pFw1,
5611	DSL_uint32_t nSize1,
5612	const DSL_char_t *pFw2,
5613	DSL_uint32_t nSize2,
5614	DSL_int32_t *pLoff,
5615	DSL_int32_t *pCurrentOff,
5616	DSL_boolean_t bLastChunk)
5617	{
5618	DSL_Error_t nErrCode = DSL_SUCCESS;
5619
5620	DSL_CHECK_POINTER(pContext, pContext->pDevCtx);
5621	DSL_CHECK_POINTER(pContext, pLoff);
5622	DSL_CHECK_POINTER(pContext, pCurrentOff);
5623	DSL_CHECK_ERR_CODE();
5624
5625	DSL_DRV_LineStateSet(pContext, DSL_LINESTATE_IDLE_REQUEST);
5626
5627	nErrCode = DSL_DRV_DEV_FwDownload(pContext,
5628	pFw1, nSize1, pFw2, nSize2, pLoff, pCurrentOff, bLastChunk);
5629
5630	if (nErrCode != DSL_SUCCESS)
5631	{
5632	DSL_DEBUG( DSL_DBG_ERR,
5633	(pContext, "DSL[%02d]: ERROR - firmware download has failed "
5634	"(on %d byte)"DSL_DRV_CRLF, DSL_DEV_NUM(pContext), *pCurrentOff));
5635	}
5636	else
5637	{
5638	DSL_DEBUG( DSL_DBG_MSG,
5639	(pContext, "DSL[%02d]: Firmware download finished "
5640	"(total %d bytes)"DSL_DRV_CRLF, DSL_DEV_NUM(pContext), *pCurrentOff));
5641	}
5642
5643	return nErrCode;
5644	}
5645
5646	DSL_Error_t DSL_DRV_LineStateSet(
5647	DSL_Context_t *pContext,
5648	DSL_LineStateValue_t nNewLineState)
5649	{
5650	DSL_Error_t nErrCode = DSL_SUCCESS;
5651	DSL_LineStateValue_t nOldLineState = DSL_LINESTATE_UNKNOWN;
5652
5653	DSL_CHECK_CTX_POINTER(pContext);
5654	DSL_CHECK_ERR_CODE();
5655
5656	DSL_CTX_READ_SCALAR(pContext, nErrCode, nLineState, nOldLineState);
5657
5658	if ((nNewLineState != nOldLineState) \|\| (nNewLineState == DSL_LINESTATE_IDLE))
5659	{
5660	DSL_DEBUG(DSL_DBG_MSG, (pContext, "DSL[%02d]: Line state has changed: "
5661	"%08X -> %08X"DSL_DRV_CRLF, DSL_DEV_NUM(pContext),
5662	nOldLineState, nNewLineState));
5663	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, nLineState, nNewLineState);
5664
5665	nErrCode = DSL_DRV_EventGenerate(
5666	pContext, 0, DSL_ACCESSDIR_NA, DSL_XTUDIR_NA,
5667	DSL_EVENT_S_LINE_STATE,
5668	(DSL_EventData_Union_t*)&nNewLineState,
5669	sizeof(DSL_LineStateData_t));
5670
5671	if( nErrCode != DSL_SUCCESS )
5672	{
5673	DSL_DEBUG( DSL_DBG_ERR,
5674	(pContext, "DSL[%02d]: ERROR - Event(%d) generate failed!"DSL_DRV_CRLF,
5675	DSL_DEV_NUM(pContext), DSL_EVENT_S_LINE_STATE));
5676	}
5677	}
5678
5679	return nErrCode;
5680	}
5681
5682	DSL_Error_t DSL_DRV_ShowtimeStatusUpdate(
5683	DSL_Context_t *pContext,
5684	DSL_boolean_t bInit)
5685	{
5686	DSL_Error_t nErrCode = DSL_SUCCESS;
5687	DSL_LineStateValue_t nLineState = DSL_LINESTATE_UNKNOWN;
5688
5689	DSL_DEBUG(DSL_DBG_MSG,
5690	(pContext, "DSL[%02d]: IN - DSL_DRV_ShowtimeStatusUpdate"DSL_DRV_CRLF,
5691	DSL_DEV_NUM(pContext)));
5692
5693	DSL_CHECK_CTX_POINTER(pContext);
5694	DSL_CHECK_ERR_CODE();
5695
5696	DSL_CTX_READ_SCALAR(pContext, nErrCode, nLineState, nLineState);
5697
5698	if(nLineState != DSL_LINESTATE_SHOWTIME_TC_SYNC &&
5699	nLineState != DSL_LINESTATE_SHOWTIME_NO_SYNC &&
5700	nLineState != DSL_LINESTATE_EXCHANGE)
5701	{
5702	DSL_DEBUG(DSL_DBG_ERR, (pContext, "DSL[%02d]: ERROR - This function is applicable "
5703	"while line is in SHOWTIME state only"
5704	DSL_DRV_CRLF, DSL_DEV_NUM(pContext)));
5705	nErrCode = DSL_ERR_ONLY_AVAILABLE_IN_SHOWTIME;
5706	}
5707	else
5708	{
5709	nErrCode = DSL_DRV_DEV_ShowtimeStatusUpdate(pContext, bInit);
5710	}
5711
5712	DSL_DEBUG(DSL_DBG_MSG,
5713	(pContext, "DSL[%02d]: OUT - DSL_DRV_ShowtimeStatusUpdate, retCode=%d"DSL_DRV_CRLF,
5714	DSL_DEV_NUM(pContext), nErrCode));
5715
5716	return nErrCode;
5717	}
5718
5719	/*
5720	For a detailed description of the function, its arguments and return value
5721	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
5722	*/
5723	DSL_Error_t DSL_DRV_CtxDataUpdate(
5724	DSL_Context_t *pContext)
5725	{
5726	DSL_Error_t nErrCode = DSL_SUCCESS;
5727	DSL_uint32_t tmp32 = 0;
5728	DSL_uint8_t i = 0;
5729	DSL_AccessDir_t nDir;
5730
5731	DSL_DEBUG(DSL_DBG_MSG,
5732	(pContext, "DSL[%02d]: IN - DSL_DRV_CtxDataUpdate"DSL_DRV_CRLF,
5733	DSL_DEV_NUM(pContext)));
5734
5735	for (nDir = DSL_UPSTREAM; nDir < DSL_ACCESSDIR_LAST; nDir++)
5736	{
5737	for (i = 0 ; i < DSL_CHANNELS_PER_LINE; i++)
5738	{
5739	/* Update previous data rate values*/
5740	DSL_CTX_READ_SCALAR(pContext, nErrCode, nChannelActualDataRatePrev[nDir][i], tmp32);
5741	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, nChannelPreviousDataRate[nDir][i], tmp32);
5742
5743	/* Reset actual data rate values*/
5744	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, nChannelActualDataRate[nDir][i], 0);
5745
5746	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, ActualInterleaveDelayUs[i], 0);
5747	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, ActualInterleaveDelayDs[i], 0);
5748	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, ActualImpulseNoiseProtectionUs[i], 0);
5749	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, ActualImpulseNoiseProtectionDs[i], 0);
5750	}
5751	}
5752
5753	/* Clean current XTSE status*/
5754	DSL_DRV_MemSet(pContext->xtseCurr, 0, DSL_G997_NUM_XTSE_OCTETS);
5755
5756	#ifdef INCLUDE_DSL_G997_LINE_INVENTORY
5757	#if (INCLUDE_DSL_CPE_API_VDSL_SUPPORT == 1)
5758	/* Clean current AUX line inventory information*/
5759	DSL_DRV_MemSet(&(pContext->auxInventoryFe), 0x0, sizeof(DSL_AuxLineInventoryData_t));
5760	#endif
5761
5762	/* Clean current FE line inventory information*/
5763	DSL_DRV_MemSet(&(pContext->lineInventoryFe), 0x0, sizeof(DSL_G997_LineInventoryData_t));
5764	/* Reset FE line inventory flag*/
5765	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, bFeLineInventoryValid, DSL_FALSE);
5766	/* Reset FE line inventory incomplete flag*/
5767	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, bFeLineInventoryIncomplete, DSL_FALSE);
5768	#endif /* INCLUDE_DSL_G997_LINE_INVENTORY*/
5769
5770	/* Clean line Feature status data, US and DS*/
5771	DSL_DRV_MemSet(&(pContext->lineFeatureDataSts[0]), 0x0, sizeof(DSL_LineFeatureData_t));
5772	DSL_DRV_MemSet(&(pContext->lineFeatureDataSts[1]), 0x0, sizeof(DSL_LineFeatureData_t));
5773
5774	#ifdef INCLUDE_DSL_CPE_API_DANUBE
5775	/* Clean FE line status data*/
5776	DSL_DRV_MemSet(&(pContext->lineStatusFe), 0x0, sizeof(DSL_G997_LineStatusBackupData_t));
5777	/* Clear System Interface status flag*/
5778	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, pDevCtx->data.bSystemIfStatusValid, DSL_FALSE);
5779	/* Clear ADSL1 mode indication*/
5780	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, pDevCtx->data.bAdsl1, DSL_FALSE);
5781	/* Clear ADSL2+ mode indication*/
5782	DSL_CTX_WRITE_SCALAR(pContext, nErrCode, pDevCtx->data.bAdsl2p, DSL_FALSE);
5783	#endif /* INCLUDE_DSL_CPE_API_DANUBE*/
5784
5785	DSL_DEBUG(DSL_DBG_MSG,
5786	(pContext, "DSL[%02d]: OUT - DSL_DRV_CtxDataUpdate, retCode=%d"DSL_DRV_CRLF,
5787	DSL_DEV_NUM(pContext), nErrCode));
5788
5789	return nErrCode;
5790	}
5791
5792	/* Events stuff */
5793
5794	/*
5795	For a detailed description of the function, its arguments and return value
5796	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
5797	*/
5798	DSL_Error_t DSL_DRV_EventQueue(
5799	DSL_Context_t *pContext,
5800	DSL_IN DSL_EventStatusData_t *pEvent,
5801	DSL_IN DSL_uint32_t nDataSize)
5802	{
5803	DSL_Error_t nErrCode = DSL_SUCCESS;
5804	DSL_uint8_t *buf;
5805	DSL_EventStatusData_t *pEvBuf;
5806	DSL_OpenContext_t *pCurr;
5807
5808	DSL_CHECK_POINTER(pContext, pContext->pDevCtx);
5809	DSL_CHECK_ERR_CODE();
5810
5811	DSL_DEBUG(DSL_DBG_MSG,
5812	(DSL_NULL, "DSL[%02d]: IN - DSL_DRV_EventQueue"DSL_DRV_CRLF,
5813	pOpenContextList->pDevCtx->nNum));
5814
5815	if (pEvent == DSL_NULL)
5816	{
5817	return DSL_ERR_INVALID_PARAMETER;
5818	}
5819
5820	/* Lock Open Context list*/
5821	if (DSL_DRV_MUTEX_LOCK(pContext->pDevCtx->openContextListMutex))
5822	{
5823	DSL_DEBUG( DSL_DBG_ERR,
5824	(DSL_NULL, "DSL[%02d]: ERROR - Couldn't lock Context List mutex!"DSL_DRV_CRLF,
5825	DSL_DEV_NUM(pContext)));
5826
5827	return DSL_ERR_SEMAPHORE_GET;
5828	}
5829
5830	for (pCurr = pOpenContextList; pCurr != DSL_NULL; pCurr = pCurr->pNext)
5831	{
5832	/* Queue event only for a specified device*/
5833	if (pContext->pDevCtx->nNum != pCurr->pDevCtx->nNum)
5834	{
5835	continue;
5836	}
5837
5838	if(DSL_DRV_MUTEX_LOCK(pCurr->eventMutex))
5839	{
5840	DSL_DEBUG( DSL_DBG_ERR,
5841	(DSL_NULL, "DSL[%02d]: ERROR - Couldn't lock event mutex!"DSL_DRV_CRLF,
5842	pOpenContextList->pDevCtx->nNum));
5843	}
5844	else
5845	{
5846	if ((pCurr->eventFifo != DSL_NULL) &&
5847	(pCurr->eventFifoBuf != DSL_NULL) &&
5848	(pCurr->bEventActivation == DSL_TRUE) &&
5849	(pCurr->nEventMask & DSL_EVENT2MASK(pEvent->nEventType)) == 0)
5850	{
5851	if ( DSL_Fifo_isFull( pCurr->eventFifo ) == (DSL_int8_t)DSL_TRUE )
5852	{
5853	/* Set FIFO overflow indication flag*/
5854	pCurr->bFifoFull = DSL_TRUE;
5855	DSL_DEBUG( DSL_DBG_WRN,
5856	(DSL_NULL, "DSL[%02d]: WARNING - The fifo is full!"DSL_DRV_CRLF,
5857	pOpenContextList->pDevCtx->nNum));
5858	}
5859	else
5860	{
5861	if ((buf = DSL_Fifo_writeElement(pCurr->eventFifo)) == DSL_NULL)
5862	{
5863	DSL_DEBUG( DSL_DBG_ERR,
5864	(DSL_NULL, "DSL[%02d]: ERROR - Event could not be added!"DSL_DRV_CRLF,
5865	pOpenContextList->pDevCtx->nNum));
5866	}
5867	else
5868	{
5869	/* copy an element */
5870	memcpy(buf, pEvent, sizeof(DSL_EventStatusData_t));
5871
5872	if (pEvent->pData != DSL_NULL)
5873	{
5874	pEvBuf = (DSL_EventStatusData_t *)buf;
5875	pEvBuf->pData = DSL_DRV_VMalloc(nDataSize);
5876	if (pEvBuf->pData != DSL_NULL)
5877	{
5878	/* copy an element data */
5879	memcpy(pEvBuf->pData, pEvent->pData, nDataSize);
5880	}
5881	else
5882	{
5883	DSL_DEBUG( DSL_DBG_WRN,
5884	(DSL_NULL, "DSL[%02d]: WRN - Could not allocate memory for an "
5885	"event data, it will be lost!"DSL_DRV_CRLF,
5886	pOpenContextList->pDevCtx->nNum));
5887	}
5888	}
5889
5890	/* wake up */
5891	DSL_DRV_WAKEUP_WAKELIST(pCurr->eventWaitQueue);
5892	}
5893	}
5894	}
5895
5896	DSL_DRV_MUTEX_UNLOCK(pCurr->eventMutex);
5897	}
5898	}
5899
5900	/* Unlock Open Context List*/
5901	DSL_DRV_MUTEX_UNLOCK(pContext->pDevCtx->openContextListMutex);
5902
5903	/* free event data */
5904	if (pEvent->pData != DSL_NULL)
5905	{
5906	DSL_DRV_VFree(pEvent->pData);
5907	}
5908
5909	DSL_DEBUG(DSL_DBG_MSG,
5910	(DSL_NULL, "DSL[%02d]: OUT - DSL_DRV_EventQueue, retCode=%d"DSL_DRV_CRLF,
5911	pOpenContextList->pDevCtx->nNum, nErrCode));
5912
5913	return nErrCode;
5914	}
5915
5916	/*
5917	For a detailed description of the function, its arguments and return value
5918	please refer to the description in the header file 'drv_dsl_cpe_intern.h'
5919	*/
5920	DSL_Error_t DSL_DRV_EventUnqueue(
5921	DSL_IN DSL_OpenContext_t *pOpenContext,
5922	DSL_IN DSL_EventStatusData_t *pEvent)
5923	{
5924	DSL_Error_t nErrCode = DSL_SUCCESS;
5925	DSL_uint8_t *buf;
5926
5927	if (pOpenContext == DSL_NULL \|\| pEvent == DSL_NULL)
5928	{
5929	return DSL_ERR_INVALID_PARAMETER;
5930	}
5931
5932	if (pOpenContext->eventFifo == DSL_NULL \|\|
5933	pOpenContext->eventFifoBuf == DSL_NULL)
5934	{
5935	DSL_DEBUG( DSL_DBG_WRN,
5936	(DSL_NULL, "DSL[%02d]: WRN - Call to event routine before it "
5937	"is configured!"DSL_DRV_CRLF, pOpenContext->pDevCtx->nNum));
5938	return DSL_ERROR;
5939	}
5940
5941	if(DSL_DRV_MUTEX_LOCK(pOpenContext->eventMutex))
5942	{
5943	DSL_DEBUG( DSL_DBG_ERR,
5944	(DSL_NULL, "DSL[%02d]: ERROR - Couldn't lock event mutex!"DSL_DRV_CRLF,
5945	pOpenContext->pDevCtx->nNum));
5946	return DSL_ERROR;
5947	}
5948
5949	if ( DSL_Fifo_isEmpty( pOpenContext->eventFifo ) == (DSL_int8_t)DSL_TRUE )
5950	{
5951	DSL_DEBUG( DSL_DBG_WRN,
5952	(DSL_NULL, "DSL[%02d]: WARNING - The fifo is empty"DSL_DRV_CRLF,
5953	pOpenContext->pDevCtx->nNum));
5954
5955	pEvent->pData = DSL_NULL;
5956	nErrCode = DSL_WRN_DEVICE_NO_DATA;
5957	}
5958	else
5959	{
5960	if ((buf = DSL_Fifo_readElement(pOpenContext->eventFifo)) == DSL_NULL)
5961	{
5962	DSL_DEBUG( DSL_DBG_ERR,
5963	(DSL_NULL, "DSL[%02d]: ERROR - Event could not be read!"DSL_DRV_CRLF,
5964	pOpenContext->pDevCtx->nNum));
5965	nErrCode = DSL_ERROR;
5966	}
5967	else
5968	{
5969	/* copy an element */
5970	memcpy(pEvent, buf, sizeof(DSL_EventStatusData_t));
5971
5972	/* Get the total FIFO element count*/
5973	pEvent->nEventStatusExt.nEventBufferSize = DSL_EVENT_FIFO_ELEMENT_COUNT;
5974	/* Get currently used FIFO elementy count*/
5975	pEvent->nEventStatusExt.nEventBufferFillStatus =
5976	DSL_Fifo_getCount(pOpenContext->eventFifo);
5977
5978	/* Check for the occured FIFO overflow condition*/
5979	if (pOpenContext->bFifoFull)
5980	{
5981	/* Clear FIFO overflow indication flag*/
5982	pOpenContext->bFifoFull = DSL_FALSE;
5983	/* Signal FIFO overflow condition*/
5984	nErrCode = DSL_WRN_EVENT_FIFO_OVERFLOW;
5985	}
5986	}
5987	}
5988
5989	DSL_DRV_MUTEX_UNLOCK(pOpenContext->eventMutex);
5990
5991	DSL_DEBUG(DSL_DBG_MSG,
5992	(DSL_NULL, "DSL[%02d]: OUT - DSL_DRV_EventUnqueue, retCode=%d"DSL_DRV_CRLF,
5993	pOpenContext->pDevCtx->nNum, nErrCode));
5994
5995	return nErrCode;
5996	}
5997
5998	/* Helpers stuff */
5999
6000	/*
6001	This function converts a given value in unsigned 16-bit value in 2'complement
6002	format to its according signed 16-bit format.
6003	The type of 2'complement can be specified, for example:
6004	nsVal16 = 0x200, nBits = 10 ==> nuVal16 = -512
6005
6006	\param nsVal16
6007	Specifies the unsigned 16-bit value that shall be converted, [I]
6008	\param nBits
6009	Specifies how many bits are used for 2'complement conversion.
6010	The bit that includes the sign is included, [I]
6011	\note It makes only sense to use this function in a range of
6012	2 <= nBits <= 15
6013	In case of nBits = 16 a simple cast will do the right thing.
6014	\param nuVal16
6015	Returns the converted 16-bit int value, [O]
6016
6017	\return
6018	Return values are defined within the DSL_Error_t definition
6019	- DSL_SUCCESS in case of success
6020	- DSL_ERROR if operation failed
6021	*/
6022	DSL_Error_t DSL_DRV_TwosComplement16_HexToInt(
6023	DSL_Context_t *pContext,
6024	DSL_uint16_t nuVal16,
6025	DSL_char_t nBits,
6026	DSL_int16_t *nsVal16)
6027	{
6028	DSL_uint16_t nFullScale = 0, nFullScaleMask = 0;
6029
6030	*nsVal16 = 0;
6031
6032	if ((nBits < 2) \|\| (nBits > 16))
6033	{
6034	DSL_DEBUG(DSL_DBG_ERR, (pContext, "DSL[%02d]: Type of 2'complement (%d)"
6035	" conversion out of valid range (2...16)"DSL_DRV_CRLF,
6036	DSL_DEV_NUM(pContext), nBits));
6037
6038	return DSL_ERROR;
6039	}
6040
6041	nFullScale = (DSL_uint16_t) (1 << (nBits - 1));
6042	nFullScaleMask = nFullScale - 1;
6043
6044	/* If msb is '1' it is a negative value */
6045	if (nuVal16 > (nFullScale - 1))
6046	{
6047	*nsVal16 = (DSL_int16_t) (nFullScaleMask & nuVal16);
6048	*nsVal16 -= ((DSL_int16_t) nFullScale);
6049	}
6050	else
6051	{
6052	*nsVal16 = (DSL_int16_t) nuVal16;
6053	}
6054
6055	return DSL_SUCCESS;
6056	}
6057
6058	#ifndef DRV_DSL_CPE_FORCE_MACROS
6059	DSL_Error_t
6060	_DSL_CHECK_CTX_POINTER(
6061	DSL_Context_t *pContext)
6062	{
6063	if (pContext == DSL_NULL)
6064	{
6065	DSL_DEBUG_SET_ERROR(DSL_ERR_POINTER);
6066	DSL_DEBUG_HDR(DSL_DBG_ERR, (pContext, "Invalid context pointer!"));
6067	return DSL_ERR_POINTER;
6068	}
6069
6070	return DSL_SUCCESS;
6071	}
6072
6073	DSL_Error_t
6074	_DSL_CHECK_POINTER(
6075	DSL_Context_t *pContext,
6076	DSL_void_t *pPtr)
6077	{
6078	DSL_Error_t nErrCode = DSL_SUCCESS;
6079
6080	DSL_CHECK_CTX_POINTER(pContext);
6081	DSL_CHECK_ERR_CODE();
6082
6083	if (pPtr == DSL_NULL)
6084	{
6085	DSL_DEBUG_SET_ERROR(DSL_ERR_POINTER);
6086	DSL_DEBUG_HDR(DSL_DBG_ERR, (pContext, "Invalid data pointer!"));
6087	return DSL_ERR_POINTER;
6088	}
6089
6090	return DSL_SUCCESS;
6091	}
6092
6093	DSL_Error_t
6094	_DSL_CHECK_MODEM_IS_READY(
6095	DSL_Context_t *pContext)
6096	{
6097	DSL_Error_t nErrCode = DSL_SUCCESS;
6098
6099	DSL_CHECK_POINTER(pContext, pContext->pDevCtx);
6100	DSL_CHECK_ERR_CODE();
6101
6102	if (DSL_DRV_DEV_ModemIsReady(pContext) == DSL_FALSE)
6103	{
6104	pContext->nErrNo = DSL_ERR_MODEM_NOT_READY;
6105	DSL_DEBUG(DSL_DBG_ERR, (pContext, "Modem is not ready!")); \
6106	return DSL_ERR_MODEM_NOT_READY;
6107	}
6108
6109	return DSL_SUCCESS;
6110	}
6111
6112	DSL_Error_t
6113	_DSL_CHECK_CHANNEL_RANGE(
6114	DSL_Context_t *pContext,
6115	DSL_uint16_t nChannel)
6116	{
6117	if (nChannel >= DSL_CHANNELS_PER_LINE)
6118	{
6119	DSL_DEBUG_SET_ERROR(DSL_ERR_CHANNEL_RANGE);
6120	DSL_DEBUG(DSL_DBG_ERR,
6121	(pContext, "DSL: invalid bearer channel number %d! (only bearer "
6122	"channels in the range of 0..%d are supported)" DSL_DRV_CRLF,
6123	nChannel, (DSL_CHANNELS_PER_LINE - 1)));
6124	return DSL_ERR_CHANNEL_RANGE;
6125	}
6126
6127	return DSL_SUCCESS;
6128	}
6129
6130	DSL_Error_t
6131	_DSL_CHECK_ATU_DIRECTION(
6132	DSL_Context_t *pContext,
6133	DSL_XTUDir_t nDirection)
6134	{
6135	if ((nDirection != DSL_NEAR_END) && (nDirection != DSL_FAR_END))
6136	{
6137	DSL_DEBUG(DSL_DBG_ERR,
6138	(pContext, "DSL: invalid xTU direction!" DSL_DRV_CRLF));
6139	return DSL_ERR_DIRECTION;
6140	}
6141
6142	return DSL_SUCCESS;
6143	}
6144
6145	DSL_Error_t
6146	_DSL_CHECK_DIRECTION(
6147	DSL_Context_t *pContext,
6148	DSL_AccessDir_t nDirection)
6149	{
6150	if ((nDirection != DSL_DOWNSTREAM) && (nDirection != DSL_UPSTREAM))
6151	{
6152	DSL_DEBUG(DSL_DBG_ERR,
6153	(pContext, "DSL: invalid direction!" DSL_DRV_CRLF));
6154	return DSL_ERR_DIRECTION;
6155	}
6156
6157	return DSL_SUCCESS;
6158	}
6159
6160	DSL_Error_t
6161	_DSL_CTX_ASSIGN_ANY(
6162	DSL_Context_t *pContext,
6163	DSL_void_t *pFrom,
6164	DSL_void_t *pTo,
6165	DSL_uint32_t nSize)
6166	{
6167	DSL_Error_t nErrCode = DSL_SUCCESS;
6168
6169	DSL_CHECK_POINTER(pContext, pFrom);
6170	DSL_CHECK_POINTER(pContext, pTo);
6171	if (nSize == 0)
6172	{
6173	DSL_DEBUG( DSL_DBG_ERR, (pContext, "_DSL_CTX_ASSIGN_ANY: "
6174	"nSize = 0!!!"DSL_DRV_CRLF));
6175	nErrCode \|= DSL_ERR_INVALID_PARAMETER;
6176	}
6177	DSL_CHECK_ERR_CODE();
6178
6179	if(DSL_DRV_MUTEX_LOCK(pContext->dataMutex))
6180	{
6181	DSL_DEBUG( DSL_DBG_ERR, (pContext, "Couldn't lock data mutex "
6182	"(pContext=%p, pFrom=%p, pTo=%p"DSL_DRV_CRLF, pContext, pFrom, pTo));
6183	return DSL_ERR_SEMAPHORE_GET;
6184	}
6185
6186	memcpy(pTo, pFrom, nSize);
6187
6188	DSL_DRV_MUTEX_UNLOCK(pContext->dataMutex);
6189
6190	return DSL_SUCCESS;
6191	}
6192
6193	DSL_Error_t
6194	_DSL_CTX_ASSIGN_8(
6195	DSL_Context_t *pContext,
6196	DSL_uint8_t nFrom,
6197	DSL_void_t *pTo)
6198	{
6199	DSL_Error_t nErrCode = DSL_SUCCESS;
6200
6201	DSL_CHECK_POINTER(pContext, pTo);
6202	DSL_CHECK_ERR_CODE();
6203
6204	if(DSL_DRV_MUTEX_LOCK(pContext->dataMutex))
6205	{
6206	DSL_DEBUG( DSL_DBG_ERR, (pContext, "Couldn't lock data mutex "
6207	"(pContext=%p, nFrom=%02x, pTo=%p"DSL_DRV_CRLF, pContext, nFrom, pTo));
6208	return DSL_ERR_SEMAPHORE_GET;
6209	}
6210
6211	((DSL_uint8_t)pTo) = nFrom;
6212
6213	DSL_DRV_MUTEX_UNLOCK(pContext->dataMutex);
6214
6215	return DSL_SUCCESS;
6216	}
6217
6218	DSL_Error_t
6219	_DSL_CTX_ASSIGN_16(
6220	DSL_Context_t *pContext,
6221	DSL_uint16_t nFrom,
6222	DSL_void_t *pTo)
6223	{
6224	DSL_Error_t nErrCode = DSL_SUCCESS;
6225
6226	DSL_CHECK_POINTER(pContext, pTo);
6227	DSL_CHECK_ERR_CODE();
6228
6229	if(DSL_DRV_MUTEX_LOCK(pContext->dataMutex))
6230	{
6231	DSL_DEBUG( DSL_DBG_ERR, (pContext, "Couldn't lock data mutex "
6232	"(pContext=%p, nFrom=%04x, pTo=%p"DSL_DRV_CRLF, pContext, nFrom, pTo));
6233	return DSL_ERR_SEMAPHORE_GET;
6234	}
6235
6236	((DSL_uint16_t)pTo) = nFrom;
6237
6238	DSL_DRV_MUTEX_UNLOCK(pContext->dataMutex);
6239
6240	return DSL_SUCCESS;
6241	}
6242
6243	DSL_Error_t
6244	_DSL_CTX_ASSIGN_32(
6245	DSL_Context_t *pContext,
6246	DSL_uint32_t nFrom,
6247	DSL_void_t *pTo)
6248	{
6249	DSL_Error_t nErrCode = DSL_SUCCESS;
6250
6251	DSL_CHECK_POINTER(pContext, pTo);
6252	DSL_CHECK_ERR_CODE();
6253
6254	if(DSL_DRV_MUTEX_LOCK(pContext->dataMutex))
6255	{
6256	DSL_DEBUG( DSL_DBG_ERR, (pContext, "Couldn't lock data mutex "
6257	"(pContext=%p, nFrom=%08x, pTo=%p"DSL_DRV_CRLF, pContext, nFrom, pTo));
6258	return DSL_ERR_SEMAPHORE_GET;
6259	}
6260
6261	((DSL_uint32_t)pTo) = nFrom;
6262
6263	DSL_DRV_MUTEX_UNLOCK(pContext->dataMutex);
6264
6265	return DSL_SUCCESS;
6266	}
6267
6268	#endif
6269
6270	#ifdef __cplusplus
6271	}
6272	#endif

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

Context Navigation

source: src/linux/universal/linux-3.2/drivers/net/ethernet/ifxatm/common/drv_dsl_cpe_api.c @ 18231

Download in other formats: