1 #if !defined(MSOS_TYPE_LINUX_KERNEL)
2 #include <stdio.h>
3 #include <string.h>
4 #else
5 #include <linux/string.h>
6 #include <linux/slab.h>
7 #endif
8
9
10 #include "MsTypes.h"
11 #include "MsVersion.h"
12 #include "MsDevice.h"
13 #include "drvMMIO.h"
14 #include "hal_IR_TX.h"
15 #include "drv_IR_TX.h"
16 #include "reg_IR_TX.h"
17 #include "utopia.h"
18 #include "MsOS.h"
19
20
21 #if (IRTX_UTOPIA20)
22
23 #include "drvIR_TX_private.h"
24
25 void* pInstantIRTX = NULL;
26 void* pAttributeIRTX = NULL;
27
28 MS_BOOL bU20IRTXOpened = FALSE;
_MDrv_IR_TX_CheckUtopia20Open(void ** pInstance,MS_U32 u32ModuleVersion,void * pAttribute)29 MS_BOOL _MDrv_IR_TX_CheckUtopia20Open(void** pInstance, MS_U32 u32ModuleVersion, void* pAttribute)
30 {
31 if (FALSE == bU20IRTXOpened)
32 {
33 #if defined(MSOS_TYPE_LINUX_KERNEL)
34 if(UtopiaOpen(MODULE_IR_TX|KERNEL_MODE, pInstance, u32ModuleVersion, pAttribute) != UTOPIA_STATUS_SUCCESS)
35 #else
36 if(UtopiaOpen(MODULE_IR_TX, pInstance, u32ModuleVersion, pAttribute) != UTOPIA_STATUS_SUCCESS)
37 #endif
38 {
39 return FALSE;
40 }
41 bU20IRTXOpened= TRUE;
42 }
43 return TRUE;
44 }
45 #endif
46
47 /****************************************************************/
48
_MDrv_IR_TX_Trigger(void)49 MS_BOOL _MDrv_IR_TX_Trigger(void)
50 {
51 MS_BOOL bRet = TRUE;
52
53 bRet &= HAL_IR_TX_Trigger();
54
55 #if IRTX_UTOPIA20
56 return (!bRet);
57 #else
58 return bRet;
59 #endif
60 }
61
62
MDrv_IR_TX_Trigger(void)63 MS_BOOL MDrv_IR_TX_Trigger(void)
64 {
65 #if (IRTX_UTOPIA20)
66
67 PIRTX_TRIGGER_PARAM pParam = NULL;
68
69 if (FALSE == _MDrv_IR_TX_CheckUtopia20Open(&pInstantIRTX, 0, pAttributeIRTX))
70 return 0;
71
72 pParam = (PIRTX_TRIGGER_PARAM)malloc(sizeof(IRTX_TRIGGER_PARAM));
73
74
75 UtopiaIoctl(pInstantIRTX,MDrv_CMD_IR_TX_Trigger,(MS_U32*)pParam);
76
77 free(pParam);
78 return IRTX_OK;
79 #else
80 return _MDrv_IR_TX_Trigger();
81 #endif
82
83 }
84
85 /****************************************************************/
86
_MDrv_IR_TX_SetStatus(MS_U16 Status)87 MS_BOOL _MDrv_IR_TX_SetStatus(MS_U16 Status)
88 {
89 MS_BOOL bRet = TRUE;
90
91 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_STATUS, (MS_U16)Status);
92
93 #if IRTX_UTOPIA20
94 return (!bRet);
95 #else
96 return bRet;
97 #endif
98 }
99
100
MDrv_IR_TX_SetStatus(MS_U16 Status)101 MS_BOOL MDrv_IR_TX_SetStatus(MS_U16 Status)
102 {
103 #if IRTX_UTOPIA20
104
105 PIRTX_SETSTATUS_PARAM pParam = NULL;
106
107 if (FALSE == _MDrv_IR_TX_CheckUtopia20Open(&pInstantIRTX, 0, pAttributeIRTX))
108 return 0;
109
110
111 pParam = (PIRTX_SETSTATUS_PARAM)malloc(sizeof(IRTX_SETSTATUS_PARAM));
112
113 pParam->Status = Status;
114
115 if(UtopiaIoctl(pInstantIRTX,MDrv_CMD_IR_TX_SetStatus,(MS_U32*)pParam) != UTOPIA_STATUS_SUCCESS)
116 {
117 printf("Ioctl MDrv_CMD_IR_TX_SetStatus fail\n");
118 free(pParam);
119 return IRTX_FAIL;
120 }
121 free(pParam);
122 return IRTX_OK;
123 #else
124 return _MDrv_IR_TX_SetStatus(Status);
125 #endif
126
127 }
128
129 /****************************************************************/
130
_MDrv_IR_TX_SetMemStatus(MS_U16 Status)131 MS_BOOL _MDrv_IR_TX_SetMemStatus(MS_U16 Status)
132 {
133 MS_BOOL bRet = TRUE;
134
135 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_MEM_REG_STATUS, (MS_U16)Status);
136
137 #if IRTX_UTOPIA20
138 return (!bRet);
139 #else
140 return bRet;
141 #endif
142 }
143
MDrv_IR_TX_SetMemStatus(MS_U16 Status)144 MS_BOOL MDrv_IR_TX_SetMemStatus(MS_U16 Status)
145 {
146 #if IRTX_UTOPIA20
147
148 PIRTX_SETMEMSTATUS_PARAM pParam = NULL;
149
150 if (FALSE == _MDrv_IR_TX_CheckUtopia20Open(&pInstantIRTX, 0, pAttributeIRTX))
151 return 0;
152
153 pParam = (PIRTX_SETMEMSTATUS_PARAM)malloc(sizeof(IRTX_SETMEMSTATUS_PARAM));
154 pParam->Status = Status;
155
156 if(UtopiaIoctl(pInstantIRTX,MDrv_CMD_IR_TX_SetMemStatus,(MS_U32*)pParam) != UTOPIA_STATUS_SUCCESS)
157 {
158 printf("Ioctl MDrv_CMD_IR_TX_SetMemStatus fail\n");
159 free(pParam);
160 return IRTX_FAIL;
161 }
162 free(pParam);
163 return IRTX_OK;
164 #else
165 return _MDrv_IR_TX_SetMemStatus(Status);
166 #endif
167
168 }
169
170
171 /****************************************************************/
172
_MDrv_IR_TX_SetClkDiv(MS_U8 Div)173 MS_BOOL _MDrv_IR_TX_SetClkDiv(MS_U8 Div)
174 {
175 MS_BOOL bRet = TRUE;
176 //bRet &= HAL_IR_TX_WriteRegBit((MS_PHY)IR_TX_REG_ClkDiv, (MS_U16)(u16Div << 8));
177 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_ClkDiv, (MS_U16)(Div << 8));
178
179 #if IRTX_UTOPIA20
180 return (!bRet);
181 #else
182 return bRet;
183 #endif
184 }
185
MDrv_IR_TX_SetClkDiv(MS_U8 Div)186 MS_BOOL MDrv_IR_TX_SetClkDiv(MS_U8 Div)
187 {
188 #if IRTX_UTOPIA20
189
190 PIRTX_SETCLKDIV_PARAM pParam;
191
192 if (FALSE == _MDrv_IR_TX_CheckUtopia20Open(&pInstantIRTX, 0, pAttributeIRTX))
193 return 0;
194
195 pParam = (PIRTX_SETCLKDIV_PARAM)malloc(sizeof(IRTX_SETCLKDIV_PARAM));
196 pParam->Div = Div;
197
198 if(UtopiaIoctl(pInstantIRTX,MDrv_CMD_IR_TX_SetClkDiv,(MS_U32*)pParam) != UTOPIA_STATUS_SUCCESS)
199 {
200 free(pParam);
201 return IRTX_FAIL;
202 }
203 free(pParam);
204 return IRTX_OK;
205 #else
206 return _MDrv_IR_TX_SetClkDiv(Div);
207 #endif
208
209 }
210
211
212 /****************************************************************/
213
_MDrv_IR_TX_SetDelayCycleTime(MS_U16 CycleTime_H,MS_U16 CycleTime_L)214 MS_BOOL _MDrv_IR_TX_SetDelayCycleTime(MS_U16 CycleTime_H, MS_U16 CycleTime_L)
215 {
216 MS_BOOL bRet = TRUE;
217 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_CycleTime_H, (MS_U16)CycleTime_H);
218 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_CycleTime_L, (MS_U16)CycleTime_L);
219
220 #if IRTX_UTOPIA20
221 return (!bRet);
222 #else
223 return bRet;
224 #endif
225 }
226
MDrv_IR_TX_SetDelayCycleTime(MS_U16 CycleTime_H,MS_U16 CycleTime_L)227 MS_BOOL MDrv_IR_TX_SetDelayCycleTime(MS_U16 CycleTime_H, MS_U16 CycleTime_L)
228 {
229 #if IRTX_UTOPIA20
230
231 PIRTX_SETDELAYCLKTIME_PARAM pParam;
232
233 if (FALSE == _MDrv_IR_TX_CheckUtopia20Open(&pInstantIRTX, 0, pAttributeIRTX))
234 return 0;
235
236 pParam = (PIRTX_SETDELAYCLKTIME_PARAM)malloc(sizeof(IRTX_SETDELAYCLKTIME_PARAM));
237
238 pParam->CycleTime_H = CycleTime_H;
239 pParam->CycleTime_L = CycleTime_L;
240
241 if(UtopiaIoctl(pInstantIRTX,MDrv_CMD_IR_TX_SetDelayCycleTime,(MS_U32*)pParam) != UTOPIA_STATUS_SUCCESS)
242 {
243 printf("Ioctl MDrv_CMD_IR_TX_SetDelayCycleTime fail\n");
244 free(pParam);
245 return IRTX_FAIL;
246 }
247 free(pParam);
248 return IRTX_OK;
249 #else
250 return _MDrv_IR_TX_SetDelayCycleTime(CycleTime_H, CycleTime_L);
251 #endif
252
253 }
254
255 /****************************************************************/
256
_MDrv_IR_TX_SetMemAddr(MS_U16 MemAddr)257 MS_BOOL _MDrv_IR_TX_SetMemAddr(MS_U16 MemAddr)
258 {
259 MS_BOOL bRet = TRUE;
260
261 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_MEM_REG_ADDR, (MS_U16)MemAddr);
262
263 #if IRTX_UTOPIA20
264 return (!bRet);
265 #else
266 return bRet;
267 #endif
268 }
269
270
MDrv_IR_TX_SetMemAddr(MS_U16 MemAddr)271 MS_BOOL MDrv_IR_TX_SetMemAddr(MS_U16 MemAddr)
272 {
273
274 #if IRTX_UTOPIA20
275
276 PIRTX_SETMEMADDR_PARAM pParam;
277
278 if (FALSE == _MDrv_IR_TX_CheckUtopia20Open(&pInstantIRTX, 0, pAttributeIRTX))
279 return 0;
280
281 pParam = (PIRTX_SETMEMADDR_PARAM)malloc(sizeof(IRTX_SETMEMADDR_PARAM));
282
283 pParam->MemAddr = MemAddr;
284
285 if(UtopiaIoctl(pInstantIRTX,MDrv_CMD_IR_TX_SetMemAddr,(MS_U32*)pParam) != UTOPIA_STATUS_SUCCESS)
286 {
287 printf("Ioctl MDrv_CMD_IR_TX_SetMemAddr fail\n");
288 free(pParam);
289 return IRTX_FAIL;
290 }
291 free(pParam);
292 return IRTX_OK;
293 #else
294 return _MDrv_IR_TX_SetMemAddr(MemAddr);
295 #endif
296
297 }
298
299
300
301 /****************************************************************/
302
_MDrv_IR_TX_SetMemData(MS_U16 MemData)303 MS_BOOL _MDrv_IR_TX_SetMemData(MS_U16 MemData)
304 {
305 MS_BOOL bRet = TRUE;
306
307 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_MEM_REG_DATA, (MS_U16) MemData);
308
309 #if IRTX_UTOPIA20
310 return (!bRet);
311 #else
312 return bRet;
313 #endif
314 }
315
MDrv_IR_TX_SetMemData(MS_U16 MemData)316 MS_BOOL MDrv_IR_TX_SetMemData(MS_U16 MemData)
317 {
318
319 #if IRTX_UTOPIA20
320
321 PIRTX_SETMEMDATA_PARAM pParam;
322
323 if (FALSE == _MDrv_IR_TX_CheckUtopia20Open(&pInstantIRTX, 0, pAttributeIRTX))
324 return 0;
325
326 pParam = (PIRTX_SETMEMDATA_PARAM)malloc(sizeof(IRTX_SETMEMDATA_PARAM));
327
328 pParam->MemData = MemData;
329
330 if(UtopiaIoctl(pInstantIRTX,MDrv_CMD_IR_TX_SetMemData,(MS_U32*)pParam) != UTOPIA_STATUS_SUCCESS)
331 {
332 printf("Ioctl MDrv_CMD_IR_TX_SetMemData fail\n");
333 free(pParam);
334 return IRTX_FAIL;
335 }
336 free(pParam);
337 return IRTX_OK;
338 #else
339 return _MDrv_IR_TX_SetMemData(MemData);
340 #endif
341
342 }
343
344
345 /****************************************************************/
_MDrv_IR_TX_SetUnitValue(MS_U16 Unit_Value,MS_U8 Unit_Number)346 MS_BOOL _MDrv_IR_TX_SetUnitValue(MS_U16 Unit_Value, MS_U8 Unit_Number)
347 {
348 MS_BOOL bRet = TRUE;
349 switch(Unit_Number)
350 {
351 case 0:
352 bRet &= HAL_IR_TX_WriteRegBit((MS_PHY)IR_TX_REG_Unit_Value_H, (MS_U16)Unit_Value);
353 break;
354 case 1:
355 bRet &= HAL_IR_TX_WriteRegBit((MS_PHY)IR_TX_REG_Unit_Value_H, (MS_U16)(Unit_Value << 2));
356 break;
357 case 2:
358 bRet &= HAL_IR_TX_WriteRegBit((MS_PHY)IR_TX_REG_Unit_Value_H, (MS_U16)(Unit_Value << 4));
359 break;
360 case 3:
361 bRet &= HAL_IR_TX_WriteRegBit((MS_PHY)IR_TX_REG_Unit_Value_H, (MS_U16)(Unit_Value << 6));
362 break;
363 case 4:
364 bRet &= HAL_IR_TX_WriteRegBit((MS_PHY)IR_TX_REG_Unit_Value_H, (MS_U16)(Unit_Value << 8));
365 break;
366 case 5:
367 bRet &= HAL_IR_TX_WriteRegBit((MS_PHY)IR_TX_REG_Unit_Value_H, (MS_U16)(Unit_Value << 10));
368 break;
369 case 6:
370 bRet &= HAL_IR_TX_WriteRegBit((MS_PHY)IR_TX_REG_Unit_Value_H, (MS_U16)(Unit_Value << 12));
371 break;
372 case 7:
373 bRet &= HAL_IR_TX_WriteRegBit((MS_PHY)IR_TX_REG_Unit_Value_H, (MS_U16)(Unit_Value << 14));
374 break;
375 case 8:
376 bRet &= HAL_IR_TX_WriteRegBit((MS_PHY)IR_TX_REG_Unit_Value_L, (MS_U16)(Unit_Value));
377 break;
378 case 10:
379 bRet &= HAL_IR_TX_WriteRegBit((MS_PHY)IR_TX_REG_Unit_Value_L, (MS_U16)(Unit_Value << 2));
380 break;
381 case 11:
382 bRet &= HAL_IR_TX_WriteRegBit((MS_PHY)IR_TX_REG_Unit_Value_L, (MS_U16)(Unit_Value << 4));
383 break;
384 case 12:
385 bRet &= HAL_IR_TX_WriteRegBit((MS_PHY)IR_TX_REG_Unit_Value_L, (MS_U16)(Unit_Value << 6));
386 break;
387 case 13:
388 bRet &= HAL_IR_TX_WriteRegBit((MS_PHY)IR_TX_REG_Unit_Value_L, (MS_U16)(Unit_Value << 8));
389 break;
390
391 default:
392 printf("Wrong Unit Number\n");
393 bRet = FALSE;
394 }
395 #if IRTX_UTOPIA20
396 return (!bRet);
397 #else
398 return bRet;
399 #endif
400 }
401
MDrv_IR_TX_SetUnitValue(MS_U16 Unit_Value,MS_U8 Unit_Number)402 MS_BOOL MDrv_IR_TX_SetUnitValue(MS_U16 Unit_Value, MS_U8 Unit_Number)
403 {
404
405 #if IRTX_UTOPIA20
406
407 PIRTX_SETUNITVALUE_PARAM pParam;
408
409 if (FALSE == _MDrv_IR_TX_CheckUtopia20Open(&pInstantIRTX, 0, pAttributeIRTX))
410 return 0;
411
412 pParam = (PIRTX_SETUNITVALUE_PARAM)malloc(sizeof(IRTX_SETUNITVALUE_PARAM));
413
414 pParam->Unit_Value = Unit_Value;
415 pParam->Unit_Number = Unit_Number;
416
417 if(UtopiaIoctl(pInstantIRTX,MDrv_CMD_IR_TX_SetUnitValue,(MS_U32*)pParam) != UTOPIA_STATUS_SUCCESS)
418 {
419 printf("Ioctl MDrv_CMD_IR_TX_SetUnitValue fail\n");
420 free(pParam);
421 return IRTX_FAIL;
422 }
423 free(pParam);
424 return IRTX_OK;
425 #else
426 return _MDrv_IR_TX_SetUnitValue(Unit_Value, Unit_Number);
427 #endif
428
429 }
430
431 /****************************************************************/
_MDrv_IR_TX_SetShotCount(MS_U16 H_ShotCount,MS_U16 L_ShotCount,MS_U8 Unit_Number)432 MS_BOOL _MDrv_IR_TX_SetShotCount(MS_U16 H_ShotCount, MS_U16 L_ShotCount, MS_U8 Unit_Number)
433 {
434 MS_BOOL bRet = TRUE;
435 switch(Unit_Number)
436 {
437 case 0:
438 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit00_ShotCount_H, (MS_U16)H_ShotCount);
439 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit00_ShotCount_L, (MS_U16)L_ShotCount);
440 break;
441 case 1:
442 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit01_ShotCount_H, (MS_U16)H_ShotCount);
443 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit01_ShotCount_L, (MS_U16)L_ShotCount);
444 break;
445 case 2:
446 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit02_ShotCount_H, (MS_U16)H_ShotCount);
447 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit02_ShotCount_L, (MS_U16)L_ShotCount);
448 break;
449 case 3:
450 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit03_ShotCount_H, (MS_U16)H_ShotCount);
451 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit03_ShotCount_L, (MS_U16)L_ShotCount);
452 break;
453 case 4:
454 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit04_ShotCount_H, (MS_U16)H_ShotCount);
455 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit04_ShotCount_L, (MS_U16)L_ShotCount);
456 break;
457 case 5:
458 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit05_ShotCount_H, H_ShotCount);
459 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit05_ShotCount_L, L_ShotCount);
460 break;
461 case 6:
462 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit06_ShotCount_H, H_ShotCount);
463 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit06_ShotCount_L, L_ShotCount);
464 break;
465 case 7:
466 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit07_ShotCount_H, H_ShotCount);
467 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit07_ShotCount_L, L_ShotCount);
468 break;
469 case 8:
470 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit08_ShotCount_H, H_ShotCount);
471 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit08_ShotCount_L, L_ShotCount);
472 break;
473 case 9:
474 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit09_ShotCount_H, H_ShotCount);
475 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit09_ShotCount_L, L_ShotCount);
476 break;
477 case 10:
478 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit10_ShotCount_H, H_ShotCount);
479 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit10_ShotCount_L, L_ShotCount);
480 break;
481 case 11:
482 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit11_ShotCount_H, H_ShotCount);
483 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit11_ShotCount_L, L_ShotCount);
484 break;
485 case 12:
486 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit12_ShotCount_H, H_ShotCount);
487 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit12_ShotCount_L, L_ShotCount);
488 break;
489 case 13:
490 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit13_ShotCount_H, H_ShotCount);
491 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_REG_Unit13_ShotCount_L, L_ShotCount);
492 break;
493 default:
494 printf("Wrong Unit Number\n");
495 bRet = FALSE;
496 }
497 #if IRTX_UTOPIA20
498 return (!bRet);
499 #else
500 return bRet;
501 #endif
502 }
503
MDrv_IR_TX_SetShotCount(MS_U16 H_ShotCount,MS_U16 L_ShotCount,MS_U8 Unit_Number)504 MS_BOOL MDrv_IR_TX_SetShotCount(MS_U16 H_ShotCount, MS_U16 L_ShotCount, MS_U8 Unit_Number)
505 {
506
507 #if IRTX_UTOPIA20
508
509 PIRTX_SETSHOTCOUNT_PARAM pParam;
510
511 if (FALSE == _MDrv_IR_TX_CheckUtopia20Open(&pInstantIRTX, 0, pAttributeIRTX))
512 return 0;
513
514 pParam = (PIRTX_SETSHOTCOUNT_PARAM)malloc(sizeof(IRTX_SETSHOTCOUNT_PARAM));
515
516 pParam->H_ShotCount = H_ShotCount;
517 pParam->L_ShotCount = L_ShotCount;
518 pParam->Unit_Number = Unit_Number;
519
520 if(UtopiaIoctl(pInstantIRTX,MDrv_CMD_IR_TX_SetShotCount,(MS_U32*)pParam) != UTOPIA_STATUS_SUCCESS)
521 {
522 printf("Ioctl MDrv_CMD_IR_TX_SetShotCount fail\n");
523 free(pParam);
524 return IRTX_FAIL;
525 }
526 free(pParam);
527 return IRTX_OK;
528 #else
529 return _MDrv_IR_TX_SetShotCount(H_ShotCount, L_ShotCount, Unit_Number);
530 #endif
531
532 }
533
534
535 /****************************************************************/
536
_MDrv_IR_TX_Init(void)537 MS_BOOL _MDrv_IR_TX_Init(void)
538 {
539 MS_BOOL bRet = TRUE;
540 MS_VIRT virtBaseAddr = 0;
541
542 MS_PHY u32BaseSize = 0;
543
544 MDrv_MMIO_GetBASE(&virtBaseAddr, &u32BaseSize, MS_MODULE_IR_TX);
545
546 HAL_IR_TX_SetIOMapBase(virtBaseAddr);
547
548 bRet &= HAL_IR_TX_Reset();
549 bRet &= HAL_IR_TX_SetIRTXMode();
550
551 #if IRTX_UTOPIA20
552 return (!bRet);
553 #else
554 return bRet;
555 #endif
556 }
557
558
MDrv_IR_TX_Init(void)559 MS_BOOL MDrv_IR_TX_Init(void)
560 {
561
562 #if IRTX_UTOPIA20
563
564 PIRTX_INIT_PARAM pParam;
565
566 if (FALSE == _MDrv_IR_TX_CheckUtopia20Open(&pInstantIRTX, 0, pAttributeIRTX))
567 {
568 printf("Open fail \n");
569 return 0;
570 }
571 else
572 {
573 printf("Open success \n");
574 }
575
576 pParam = (PIRTX_INIT_PARAM)malloc(sizeof(IRTX_INIT_PARAM));
577
578 if(UtopiaIoctl(pInstantIRTX,MDrv_CMD_IR_TX_Init,(void*)pParam) != UTOPIA_STATUS_SUCCESS)
579 {
580 printf("Ioctl MDrv_IR_TX_Init fail\n");
581 free(pParam);
582 return IRTX_FAIL;
583 }
584 free(pParam);
585 return IRTX_OK;
586 #else
587 return _MDrv_IR_TX_Init();
588 #endif
589
590 }
591
592 /****************************************************************/
593
_MDrv_IR_TX_SetCarrierCount(MS_U16 Count)594 MS_BOOL _MDrv_IR_TX_SetCarrierCount(MS_U16 Count)
595 {
596 MS_BOOL bRet = TRUE;
597 bRet &= HAL_IR_TX_Write2Byte((MS_PHY)IR_TX_CARRIER_CNT,(MS_U16)Count);
598 #if IRTX_UTOPIA20
599 return (!bRet);
600 #else
601 return bRet;
602 #endif
603 }
604
MDrv_IR_TX_SetCarrierCount(MS_U16 Count)605 MS_BOOL MDrv_IR_TX_SetCarrierCount(MS_U16 Count)
606 {
607
608 #if IRTX_UTOPIA20
609
610 PIRTX_SETCARRIERCOUNT_PARAM pParam;
611
612 if (FALSE == _MDrv_IR_TX_CheckUtopia20Open(&pInstantIRTX, 0, pAttributeIRTX))
613 return 0;
614
615 pParam = (PIRTX_SETCARRIERCOUNT_PARAM)malloc(sizeof(IRTX_SETCARRIERCOUNT_PARAM));
616
617 pParam->Count = Count;
618
619 if(UtopiaIoctl(pInstantIRTX,MDrv_CMD_IR_TX_SetCarrierCount,(MS_U32*)pParam) != UTOPIA_STATUS_SUCCESS)
620 {
621 printf("Ioctl MDrv_IR_TX_SetCarrierCount fail\n");
622 free(pParam);
623 return IRTX_FAIL;
624 }
625 free(pParam);
626 return IRTX_OK;
627 #else
628 return _MDrv_IR_TX_SetCarrierCount(Count);
629 #endif
630
631 }
632
633