api.c

   1 /**
   2  * Copyright (c) 2016 ITE Technologies, Inc. All rights reserved.
   3  *
   4  * Date:
   5  *    2016/11/17
   6  *
   7  * Module Name:
   8  *    api.c
   9  *
  10  * Abstract:
  11  *    Defines the entry point for the DLL application.
  12  */
  13
  14 #include "api.h"
  15
  16 int g_hDriver[16][2] = {{0}};           // Support number of 16 devices.
  17 int g_hSPIDriverHandle = 0;
  18 int g_hPrimaDriverHandle = 0;
  19
  20 /*********************************************************************************
  21  * The client calls this function to get USB device handle.
  22  * @param void
  23  * Return:  Dword if successful, INVALID_HANDLE_VALUE indicates failure.
  24  *********************************************************************************/
  25 Dword g_ITEAPI_TxDeviceOpen(
  26         IN HandleType handleType,
  27         IN Byte DevNo)
  28 {
  29         int hDriver = 0;
  30         char* devName = "";
  31
  32         switch(handleType){
  33                 case EAGLEI:
  34                         (void)asprintf(&devName, "/dev/usb-it950x%d", DevNo);
  35                         g_hDriver[DevNo][1] = EAGLEI;
  36                         break;
  37
  38                 case EAGLEII:
  39                         (void)asprintf(&devName, "/dev/usb-it951x%d", DevNo);
  40                         g_hDriver[DevNo][1] = EAGLEII;
  41                         break;
  42
  43                 default:
  44                         printf("Handle type error[%d]\n", handleType);
  45                         return ERR_USB_INVALID_HANDLE;
  46         }
  47
  48     hDriver = open(devName, O_RDWR);
  49         if (hDriver <= INVALID_HANDLE_VALUE) {
  50                 printf("\nOpen %s fail\n", devName);
  51                 return ERR_USB_INVALID_HANDLE;
  52         }
  53
  54         return hDriver;
  55 }
  56
  57 /*********************************************************************************
  58  * The client calls this function to close device.
  59  * @param   device handle
  60  * Return:  TRUE indicates success. FALSE indicates failure.
  61  ********************************************************************************/
  62 Dword g_ITEAPI_TxDeviceExit(
  63     IN  Byte DevNo)
  64 {
  65     return (close(g_hDriver[DevNo][0]));
  66 }
  67
  68 Dword g_ITEAPI_TxDeviceInit(
  69         IN HandleType handleType,
  70         IN Byte DevNo)
  71 {
  72     Dword dwError = ERR_NO_ERROR;
  73     DEVICE_INFO DeviceInfo;
  74
  75     g_hDriver[DevNo][0] = g_ITEAPI_TxDeviceOpen(handleType, DevNo);
  76
  77     if (g_hDriver[DevNo][0] == INVALID_HANDLE_VALUE){
  78         dwError = ERR_USB_INVALID_HANDLE;
  79                 return dwError;
  80         }
  81
  82     /* Check driver is loaded correctly */
  83     dwError = g_ITEAPI_TxGetDrvInfo(&DeviceInfo, DevNo);
  84         if(dwError != ERR_NO_ERROR) {
  85                 dwError = ERR_INVALID_CHIP_REV;
  86                 return dwError;
  87         }
  88
  89         return (dwError);
  90 }
  91
  92
  93 Dword g_ITEAPI_TxGetDrvInfo(
  94     OUT PDEVICE_INFO pDeviceInfo,
  95     IN  Byte DevNo)
  96 {
  97     Dword dwError = ERR_NO_ERROR;
  98     TxModDriverInfo request;
  99         Word ChipType = 0;
 100     int result;
 101
 102         /* Get DriverVerion and others information */
 103     if (g_hDriver[DevNo][0] > 0) {
 104         result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_GETDRIVERINFO, (void *)&request);
 105         dwError = (Dword) request.error;
 106         if(result < 0 || dwError != ERR_NO_ERROR) {
 107                         dwError = ERR_INVALID_CHIP_REV;
 108                         return dwError;
 109                 }
 110     }
 111     else {
 112         dwError = ERR_NOT_IMPLEMENTED;
 113     }
 114
 115         /* Get Chip Type */
 116         dwError = g_ITEAPI_TxGetChipType(&ChipType, DevNo);
 117         if(dwError != ERR_NO_ERROR) {
 118         dwError = ERR_INVALID_CHIP_REV;
 119         return dwError;
 120         }
 121
 122         memcpy(pDeviceInfo->DriverVerion, &request.DriverVerion, sizeof(Byte)*16);
 123         memcpy(pDeviceInfo->APIVerion, &request.APIVerion, sizeof(Byte)*32);
 124         memcpy(pDeviceInfo->FWVerionLink, &request.FWVerionLink, sizeof(Byte)*16);
 125         memcpy(pDeviceInfo->FWVerionOFDM, &request.FWVerionOFDM, sizeof(Byte)*16);
 126         memcpy(pDeviceInfo->DateTime, &request.DateTime, sizeof(Byte)*24);
 127         memcpy(pDeviceInfo->Company, &request.Company, sizeof(Byte)*8);
 128         memcpy(pDeviceInfo->SupportHWInfo, &request.SupportHWInfo, sizeof(Byte)*32);
 129         memcpy(&pDeviceInfo->ProductID, &ChipType, sizeof(Word));
 130
 131     return dwError;
 132 }
 133
 134 Dword g_ITEAPI_TxPowerCtl(
 135     IN  Byte byCtrl,
 136     IN  Byte DevNo)
 137 {
 138
 139     Dword dwError = ERR_NO_ERROR;
 140     int result = 0;
 141     TxControlPowerSavingRequest request;
 142
 143     if (g_hDriver[DevNo][0] > 0) {
 144         request.chip = 0;
 145         request.control = byCtrl;
 146         result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_CONTROLPOWERSAVING, (void *)&request);
 147         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 148     }
 149     else {
 150         dwError = ERR_NOT_IMPLEMENTED;
 151     }
 152
 153     return dwError;
 154 }
 155
 156 Dword g_ITEAPI_TxSetChannelModulation(
 157         IN MODULATION_PARAM ChannelModulation_Setting,
 158         IN Byte DevNo)
 159 {
 160         Dword dwError = ERR_NO_ERROR;
 161     int result;
 162     TxSetModuleRequest request;
 163         Byte transmissionMode = ChannelModulation_Setting.transmissionMode;
 164         Byte constellation = ChannelModulation_Setting.constellation;
 165         Byte interval = ChannelModulation_Setting.interval;
 166         Byte highCodeRate = ChannelModulation_Setting.highCodeRate;
 167
 168         if (g_hDriver[DevNo][0] > 0) {
 169         request.chip = 0;
 170                 request.transmissionMode = transmissionMode;
 171         request.constellation = constellation;
 172                 request.interval = interval;
 173                 request.highCodeRate = highCodeRate;
 174         result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_SETMODULE, (void *)&request);
 175         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 176         }
 177         else {
 178         dwError = ERR_NOT_IMPLEMENTED;
 179         }
 180
 181     return (dwError);
 182 }
 183
 184 Dword g_ITEAPI_TxSetChannel(
 185         IN Dword bfrequency,
 186         IN Word bandwidth,
 187         IN Byte DevNo)
 188 {
 189         Dword dwError = ERR_NO_ERROR;
 190     int result;
 191     TxAcquireChannelRequest request;
 192
 193         if (g_hDriver[DevNo][0] > 0) {
 194         request.chip = 0;
 195                 request.frequency = (__u32) bfrequency;
 196         request.bandwidth = bandwidth;
 197         result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_ACQUIRECHANNEL, (void *)&request);
 198         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 199         }
 200         else {
 201         dwError = ERR_NOT_IMPLEMENTED;
 202         }
 203
 204     return (dwError);
 205 }
 206
 207 Dword g_ITEAPI_TxSetChannelDual(
 208         IN Dword bfrequency1,
 209         IN Dword bfrequency2,
 210         IN Word bandwidth,
 211         IN Byte DevNo)
 212 {
 213         Dword dwError = ERR_NO_ERROR;
 214     int result;
 215     TxAcquireChannelDualRequest request;
 216
 217         if (g_hDriver[DevNo][0] > 0) {
 218         request.chip = 0;
 219                 request.frequency1 = (__u32) bfrequency1;
 220                 request.frequency2 = (__u32) bfrequency2;
 221         request.bandwidth = bandwidth;
 222         result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_ACQUIRECHANNELDUAL, (void *)&request);
 223         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 224         }
 225         else {
 226         dwError = ERR_NOT_IMPLEMENTED;
 227         }
 228
 229     return (dwError);
 230 }
 231
 232 Dword g_ITEAPI_TxSetModeEnable(
 233         IN Byte OnOff,
 234         IN Byte DevNo)
 235 {
 236         Dword dwError = ERR_NO_ERROR;
 237     int result;
 238     TxModeRequest request;
 239
 240         if (g_hDriver[DevNo][0] > 0) {
 241         request.OnOff = OnOff;
 242         result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_ENABLETXMODE, (void *)&request);
 243         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 244         }
 245         else {
 246         dwError = ERR_NOT_IMPLEMENTED;
 247         }
 248
 249     return (dwError);
 250 }
 251
 252 Dword g_ITEAPI_TxSetDeviceType(
 253         IN Byte DeviceType,
 254         IN Byte DevNo)
 255 {
 256         Dword dwError = ERR_NO_ERROR;
 257     int result;
 258     TxSetDeviceTypeRequest request;
 259
 260         if (g_hDriver[DevNo][0] > 0) {
 261                 request.DeviceType = DeviceType;
 262         result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_SETDEVICETYPE, (void *)&request);
 263         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 264         }
 265         else {
 266         dwError = ERR_NOT_IMPLEMENTED;
 267         }
 268
 269     return (dwError);
 270 }
 271
 272 Dword g_ITEAPI_TxGetDeviceType(
 273         OUT Byte *DeviceType,
 274         IN Byte DevNo)
 275 {
 276         Dword dwError = ERR_NO_ERROR;
 277     int result;
 278     TxGetDeviceTypeRequest request;
 279
 280         if (g_hDriver[DevNo][0] > 0) {
 281         result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_GETDEVICETYPE, (void *)&request);
 282         *DeviceType = request.DeviceType;
 283         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 284         }
 285         else {
 286         dwError = ERR_NOT_IMPLEMENTED;
 287         }
 288
 289     return (dwError);
 290 }
 291
 292 Dword g_ITEAPI_TxAdjustOutputGain(
 293         IN int Gain_value,
 294         OUT int *Out_Gain_value,
 295         IN Byte DevNo)
 296 {
 297         Dword dwError = ERR_NO_ERROR;
 298     int result;
 299     TxSetGainRequest request;
 300
 301         if (g_hDriver[DevNo][0] > 0) {
 302                 request.GainValue = Gain_value;
 303         result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_ADJUSTOUTPUTGAIN, (void *)&request);
 304         *Out_Gain_value = request.GainValue;
 305         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 306         }
 307         else {
 308         dwError = ERR_NOT_IMPLEMENTED;
 309         }
 310
 311     return (dwError);
 312 }
 313
 314 Dword g_ITEAPI_TxControlPidFilter(
 315         Byte control,
 316         Byte enable,
 317         IN Byte DevNo)
 318 {
 319     Dword dwError = ERR_NO_ERROR;
 320     int result;
 321     TxControlPidFilterRequest request;
 322
 323
 324     if (g_hDriver[DevNo][0] > 0) {
 325         request.control = control;
 326         request.enable = enable;
 327         result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_CONTROLPIDFILTER, (void *)&request);
 328         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 329     }
 330     else {
 331         dwError = ERR_NOT_IMPLEMENTED;
 332     }
 333
 334     return(dwError);
 335 }
 336
 337 Dword g_ITEAPI_TxAddPID(
 338     IN Byte byIndex,            // 0 ~ 31
 339         IN Word wProgId,            // pid number
 340         IN Byte DevNo)
 341 {
 342     Dword dwError = ERR_NO_ERROR;
 343     int result;
 344     AddPidAtRequest request;
 345     Pid pid;
 346         memset(&pid, 0, sizeof(pid));
 347     pid.value = (Word)wProgId;
 348
 349     if (g_hDriver[DevNo][0] > 0) {
 350         request.chip = 0;
 351         request.pid = pid;
 352         request.index = byIndex;
 353
 354
 355         result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_ADDPIDAT, (void *)&request);
 356         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 357     }
 358     else {
 359         dwError = ERR_NOT_IMPLEMENTED;
 360     }
 361
 362     return (dwError);
 363 }
 364
 365 Dword g_ITEAPI_TxResetPidFilter(
 366         IN Byte DevNo)
 367 {
 368     Dword dwError = ERR_NO_ERROR;
 369     int result;
 370     ResetPidRequest request;
 371
 372
 373     if (g_hDriver[DevNo][0] > 0) {
 374         request.chip = 0;
 375         result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_RESETPID, (void *)&request);
 376         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 377     }
 378     else {
 379         dwError = ERR_NOT_IMPLEMENTED;
 380     }
 381
 382     return(dwError);
 383 }
 384
 385 Dword g_ITEAPI_StartTransfer(
 386         IN Byte DevNo)
 387 {
 388
 389         Dword dwError = ERR_NO_ERROR;
 390     int result;
 391
 392     //here tell driver begin to read data
 393     result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_STARTTRANSFER);
 394
 395     dwError = result < 0 ? ERR_NOT_IMPLEMENTED : dwError;
 396     return(dwError);
 397 }
 398
 399 Dword g_ITEAPI_StartTransfer_CMD(
 400         IN Byte DevNo)
 401 {
 402
 403         Dword dwError = ERR_NO_ERROR;
 404     int result;
 405
 406     //here tell driver begin to read data
 407     result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_STARTTRANSFER_CMD);
 408
 409     dwError = result < 0 ? ERR_NOT_IMPLEMENTED : dwError;
 410     return(dwError);
 411 }
 412
 413 Dword g_ITEAPI_StopTransfer(
 414         IN Byte DevNo)
 415 {
 416     Dword dwError = ERR_NO_ERROR;
 417     int result;
 418
 419     result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_STOPTRANSFER);
 420
 421     dwError = result < 0 ? ERR_NOT_IMPLEMENTED : dwError;
 422     return(dwError);
 423 }
 424
 425 Dword g_ITEAPI_StopTransfer_CMD(
 426         IN Byte DevNo)
 427 {
 428     Dword dwError = ERR_NO_ERROR;
 429     int result;
 430
 431     result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_STOPTRANSFER_CMD);
 432
 433     dwError = result < 0 ? ERR_NOT_IMPLEMENTED : dwError;
 434     return(dwError);
 435 }
 436
 437 Dword g_ITEAPI_TxSendTSData(
 438     OUT Byte* pBuffer,
 439     IN  OUT Dword pdwBufferLength,
 440     IN  Byte DevNo)
 441 {
 442         int Len = 0;
 443
 444     if (g_hDriver[DevNo][0] > 0) {
 445                 Len =  write(g_hDriver[DevNo][0], pBuffer, pdwBufferLength);
 446     }
 447     else {
 448         return -ERR_NOT_IMPLEMENTED;
 449     }
 450
 451     return Len;
 452 }
 453
 454 Dword g_ITEAPI_TxAddPIDEx(
 455     IN  DTVPid pid,
 456     IN  Byte DevNo)
 457 {
 458     Dword dwError = ERR_NO_ERROR;
 459     int result;
 460     AddPidAtRequest request;
 461
 462     if (g_hDriver[DevNo][0] > 0) {
 463         request.chip = 0;
 464         memcpy(&request.pid, &pid, sizeof(Pid));
 465         result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_ADDPIDAT, (void *)&request);
 466         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 467     }
 468     else {
 469         dwError = ERR_NOT_IMPLEMENTED;
 470     }
 471
 472     return (dwError);
 473 }
 474
 475 Dword g_ITEAPI_TxReadRegOFDM(
 476     IN  Dword dwRegAddr,
 477     OUT Byte* pbyData,
 478     IN  Byte DevNo)
 479 {
 480     Dword dwError = ERR_NO_ERROR;
 481     int result;
 482     TxReadRegistersRequest request;
 483
 484     if (g_hDriver[DevNo][0] > 0) {
 485         request.chip = 0;
 486         request.processor = Processor_OFDM;
 487         request.registerAddress = (__u32) dwRegAddr;
 488         request.bufferLength = 1;
 489         result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_READREGISTERS, (void *)&request);
 490                 *pbyData = request.buffer[0];
 491         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 492     }
 493     else {
 494         dwError = ERR_NOT_IMPLEMENTED;
 495     }
 496
 497     return dwError;
 498 }
 499
 500 Dword g_ITEAPI_TxWriteRegOFDM(
 501     IN  Dword dwRegAddr,
 502     IN  Byte byData,
 503     IN  Byte DevNo)
 504 {
 505     Dword dwError = ERR_NO_ERROR;
 506     int result;
 507     TxWriteRegistersRequest request;
 508
 509     if (g_hDriver[DevNo][0] > 0) {
 510         request.chip = 0;
 511         request.processor = Processor_OFDM;
 512         request.registerAddress = (__u32) dwRegAddr;
 513         request.bufferLength = 1;
 514         memcpy (request.buffer, &byData, 1);
 515         result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_WRITEREGISTERS, (void *)&request);
 516         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 517     } else {
 518         dwError = ERR_NOT_IMPLEMENTED;
 519     }
 520
 521     return dwError;
 522 }
 523
 524 Dword g_ITEAPI_TxReadRegLINK(
 525     IN  Dword dwRegAddr,
 526     OUT Byte* pbyData,
 527     IN  Byte  DevNo)
 528 {
 529     Dword dwError = ERR_NO_ERROR;
 530
 531     int result;
 532     TxReadRegistersRequest request;
 533
 534     if (g_hDriver[DevNo][0] > 0) {
 535         request.chip = 0;
 536         request.processor = Processor_LINK;
 537         request.registerAddress = (__u32) dwRegAddr;
 538         request.bufferLength = 1;
 539         result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_READREGISTERS, (void *)&request);
 540                 *pbyData = request.buffer[0];
 541         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 542     }
 543     else {
 544         dwError = ERR_NOT_IMPLEMENTED;
 545     }
 546
 547     return dwError;
 548 }
 549
 550 Dword g_ITEAPI_TxWriteRegLINK(
 551     IN  Dword dwRegAddr,
 552     IN  Byte  byData,
 553     IN  Byte  DevNo)
 554 {
 555     Dword dwError = ERR_NO_ERROR;
 556     int result;
 557     TxWriteRegistersRequest request;
 558
 559     if (g_hDriver[DevNo][0] > 0) {
 560         request.chip = 0;
 561         request.processor = Processor_LINK;
 562         request.registerAddress = (__u32) dwRegAddr;
 563         request.bufferLength = 1;
 564         memcpy (request.buffer, &byData, 1);
 565         result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_WRITEREGISTERS, (void *)&request);
 566         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 567     }
 568     else {
 569         dwError = ERR_NOT_IMPLEMENTED;
 570     }
 571
 572     return dwError;
 573 }
 574
 575 Dword g_ITEAPI_TxWriteEEPROM(
 576     IN  Word  wRegAddr,
 577     OUT Byte  byData,
 578     IN  Byte  DevNo)
 579 {
 580     Dword dwError = ERR_NO_ERROR;
 581     int result;
 582     TxWriteEepromValuesRequest request;
 583
 584     if (g_hDriver[DevNo][0] > 0) {
 585         request.chip = 0;
 586         request.registerAddress = wRegAddr;
 587         request.bufferLength = 1;
 588         memcpy (request.buffer, &byData, 1);
 589         result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_WRITEEEPROMVALUES, (void *)&request);
 590         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 591     }
 592     else {
 593         dwError = ERR_NOT_IMPLEMENTED;
 594     }
 595
 596     return dwError;
 597 }
 598
 599 Dword g_ITEAPI_TxReadEEPROM(
 600     IN  Word  wRegAddr,
 601     OUT Byte* pbyData,
 602     IN  Byte  DevNo)
 603 {
 604     Dword dwError = ERR_NO_ERROR;
 605     int result;
 606     TxReadEepromValuesRequest request;
 607
 608     if (g_hDriver[DevNo][0] > 0) {
 609         request.chip = 0;
 610         request.registerAddress = wRegAddr;
 611         request.bufferLength = 1;
 612         result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_READEEPROMVALUES, (void *)&request);
 613                 *pbyData = request.buffer[0];
 614         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 615     }
 616     else {
 617         dwError = ERR_NOT_IMPLEMENTED;
 618     }
 619
 620     return dwError;
 621 }
 622
 623 Dword g_ITEAPI_TxGetGainRange(
 624         IN Dword frequency,
 625         IN Word bandwidth,
 626         OUT int *MaxGain,
 627         OUT int *MinGain,
 628         IN  Byte DevNo)
 629 {
 630         Dword dwError = ERR_NO_ERROR;
 631     int result;
 632     Dword upperBound, lowerBound;
 633     TxGetGainRangeRequest request;
 634
 635         if(g_hDriver[DevNo][1] == EAGLEI) {     //EAGLEI
 636                 lowerBound = 173000;
 637                 upperBound = 9000000;
 638         } else {                                                                // EAGLEII
 639                 lowerBound = 93000;
 640                 upperBound = 8030000;
 641         }
 642
 643         if (g_hDriver[DevNo][0] > 0) {
 644                 if(frequency >= lowerBound && frequency <= upperBound)
 645                         request.frequency = frequency;
 646                 else {
 647                         printf("\nSet Frequency Out of Range!\n");
 648                         dwError = ERR_FREQ_OUT_OF_RANGE;
 649                 }
 650                 if(bandwidth >= 2000 && bandwidth <= 8000)
 651                         request.bandwidth = bandwidth;
 652                 else {
 653                         printf("\nSet Bandwidth Out of Range!\n");
 654                         dwError = ERR_INVALID_BW;
 655                 }
 656                 if(!dwError) {
 657                         result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_GETGAINRANGE, (void *)&request);
 658                         *MaxGain = (int) request.maxGain;
 659                         *MinGain = (int) request.minGain;
 660                         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 661                 }
 662         }
 663         else {
 664         dwError = ERR_NOT_IMPLEMENTED;
 665         }
 666
 667     return (dwError);
 668 }
 669
 670 Dword g_ITEAPI_TxGetTPS(
 671         OUT TPS *tps,
 672         IN Byte DevNo)
 673 {
 674         Dword dwError = ERR_NO_ERROR;
 675     int result;
 676     TxGetTPSRequest request;
 677
 678         if (g_hDriver[DevNo][0] > 0) {
 679                 result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_GETTPS, (void *)&request);
 680                 *tps = (TPS) request.tps;
 681         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 682         }
 683         else {
 684         dwError = ERR_NOT_IMPLEMENTED;
 685         }
 686
 687     return (dwError);
 688 }
 689
 690 Dword g_ITEAPI_TxSetTPS(
 691         IN TPS tps,
 692         IN Byte DevNo)
 693 {
 694         Dword dwError = ERR_NO_ERROR;
 695     int result;
 696     TxSetTPSRequest request;
 697
 698         if (g_hDriver[DevNo][0] > 0) {
 699                 request.tps = tps;
 700                 request.actualInfo = True;
 701                 result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_SETTPS, (void *)&request);
 702         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 703         }
 704         else {
 705         dwError = ERR_NOT_IMPLEMENTED;
 706         }
 707
 708     return (dwError);
 709 }
 710
 711 Dword g_ITEAPI_TxGetOutputGain(
 712         OUT int *gain,
 713         IN  Byte DevNo)
 714 {
 715         Dword dwError = ERR_NO_ERROR;
 716     int result;
 717     TxGetOutputGainRequest request;
 718
 719         if (g_hDriver[DevNo][0] > 0) {
 720                 result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_GETOUTPUTGAIN, (void *)&request);
 721                 *gain = request.gain;
 722         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 723         }
 724         else {
 725         dwError = ERR_NOT_IMPLEMENTED;
 726         }
 727
 728     return (dwError);
 729 }
 730
 731 Dword g_ITEAPI_TxGetNumOfDevice(
 732         OUT Byte *NumOfDev,
 733         IN  Byte DevNo
 734 )
 735 {
 736         Dword dwError = ERR_NO_ERROR;
 737     struct dirent *ptr;
 738     char *handle = "", *existing;
 739     DIR *dir = opendir("/dev");
 740
 741         switch(g_hDriver[DevNo][1]){
 742                 case EAGLEI:
 743                         (void)asprintf(&handle, "usb-it950x");
 744                         break;
 745
 746                 case EAGLEII:
 747                         (void)asprintf(&handle, "usb-it951x");
 748                         break;
 749
 750                 default:
 751                         printf("Handle type error[%d]\n", g_hDriver[DevNo][1]);
 752                         dwError = ERR_USB_INVALID_HANDLE;
 753                         return ERR_USB_INVALID_HANDLE;
 754         }
 755
 756     while((ptr = readdir(dir)) != NULL) {
 757                 existing = strndup(ptr->d_name, 10);
 758                 if(!strcmp(existing, handle))
 759                         (*NumOfDev)++;
 760         }
 761         closedir(dir);
 762     return (dwError);
 763 }
 764
 765 Dword g_ITEAPI_TxSendCustomPacketOnce(
 766         IN int bufferSize,
 767         IN Byte *TableBuffer,
 768         IN Byte DevNo)
 769 {
 770         Dword dwError = ERR_NO_ERROR;
 771     int result;
 772     TxSendHwPSITableRequest request;
 773
 774         if(bufferSize != 188)
 775                 return -1;
 776
 777         if (g_hDriver[DevNo][0] > 0) {
 778                 request.pbufferAddr = (__u32) TableBuffer;
 779                 result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_SENDHWPSITABLE, (void *)&request);
 780         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 781         }
 782         else {
 783         dwError = ERR_NOT_IMPLEMENTED;
 784         }
 785     return (dwError);
 786 }
 787
 788 Dword g_ITEAPI_TxSetPeridicCustomPacket(
 789         IN int bufferSize,
 790         IN Byte *TableBuffer,
 791         IN Byte index,
 792         IN Byte DevNo)
 793 {
 794         Dword dwError = ERR_NO_ERROR;
 795     int result;
 796     TxAccessFwPSITableRequest request;
 797
 798         if(bufferSize != 188)
 799                 return -1;
 800
 801         if (g_hDriver[DevNo][0] > 0) {
 802                 request.psiTableIndex = index;
 803                 request.pbufferAddr = (__u32) TableBuffer;
 804                 result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_ACCESSFWPSITABLE, (void *)&request);
 805         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 806         }
 807         else {
 808         dwError = ERR_NOT_IMPLEMENTED;
 809         }
 810     return (dwError);
 811 }
 812
 813 Dword g_ITEAPI_TxSetPeridicCustomPacketTimer(
 814         IN Byte index,
 815         IN Word timer_interval,
 816         IN Byte DevNo)
 817 {
 818         Dword dwError = ERR_NO_ERROR;
 819     int result;
 820     TxSetFwPSITableTimerRequest request;
 821
 822         if (g_hDriver[DevNo][0] > 0) {
 823                 request.psiTableIndex = index;
 824                 request.timer = timer_interval;
 825                 result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_SETFWPSITABLETIMER, (void *)&request);
 826         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 827         }
 828         else {
 829         dwError = ERR_NOT_IMPLEMENTED;
 830         }
 831     return (dwError);
 832 }
 833
 834 Dword g_ITEAPI_TxSetIQTable(
 835         IN Byte*         ptrIQtable,
 836         IN Word  IQtableSize,
 837         IN Byte DevNo)
 838 {
 839         Dword dwError = ERR_NO_ERROR;
 840     int result;
 841     TxSetIQTableRequest request;
 842
 843         if (g_hDriver[DevNo][0] > 0) {
 844                 request.pIQtableAddr = (__u32) ptrIQtable;
 845                 request.IQtableSize = IQtableSize;
 846                 result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_SETIQTABLE, (void *)&request);
 847         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 848         }
 849         else {
 850         dwError = ERR_NOT_IMPLEMENTED;
 851         }
 852     return (dwError);
 853 }
 854
 855 Dword g_ITEAPI_TxGetChipType(
 856         OUT Word* chipType,
 857         IN Byte DevNo)
 858 {
 859         Dword dwError = ERR_NO_ERROR;
 860     int result;
 861     TxGetChipTypeRequest request;
 862
 863         if (g_hDriver[DevNo][0] > 0) {
 864                 result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_GETCHIPTYPE, (void *)&request);
 865                 *chipType = request.chipType;
 866         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 867         }
 868         else {
 869         dwError = ERR_NOT_IMPLEMENTED;
 870         }
 871     return (dwError);
 872 }
 873
 874 Dword g_ITEAPI_TxSetDCCalibrationValue(
 875         IN int dc_i,
 876         IN int dc_q,
 877         IN Byte DevNo)
 878 {
 879         Dword dwError = ERR_NO_ERROR;
 880     int result;
 881     TxSetDCCalibrationValueRequest request;
 882
 883         if (g_hDriver[DevNo][0] > 0) {
 884                 request.dc_i = dc_i;
 885                 request.dc_q = dc_q;
 886                 result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_SETDCCALIBRATIONVALUE, (void *)&request);
 887         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 888         }
 889         else {
 890         dwError = ERR_NOT_IMPLEMENTED;
 891         }
 892     return (dwError);
 893 }
 894
 895 Dword g_ITEAPI_TxWriteLowBitRateData(
 896         IN Byte* pBuffer,
 897         IN Dword BufferLength,
 898         IN Byte DevNo)
 899 {
 900         Dword dwError = ERR_NO_ERROR;
 901     int result;
 902     TxSetLowBitRateTransferRequest request;
 903
 904         if (g_hDriver[DevNo][0] > 0) {
 905                 request.pBufferAddr = (__u32) pBuffer;
 906                 request.pdwBufferLength = (__u32) &BufferLength;
 907                 result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_WRITE_LOWBITRATEDATA, (void *)&request);
 908         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 909         }
 910         else {
 911         dwError = ERR_NOT_IMPLEMENTED;
 912         }
 913     return (dwError);
 914 }
 915
 916 Dword g_ITEAPI_TxWriteCmd(
 917         IN Word                 len,
 918     IN Byte*                    cmd,
 919         IN Byte DevNo
 920 )
 921 {
 922         Dword dwError = ERR_NO_ERROR;
 923     int result;
 924     TxCmdRequest request;
 925
 926         if (g_hDriver[0] > 0) {
 927                 request.len = len;
 928                 request.cmdAddr = (__u32) cmd;
 929
 930                 result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_WRITE_CMD, (void *)&request);
 931         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 932         }
 933         else {
 934         dwError = ERR_NOT_IMPLEMENTED;
 935         }
 936     return (dwError);
 937 }
 938
 939 /* Only for EAGLEII */
 940 Dword g_ITEAPI_TxSetISDBTChannelModulation(
 941         IN ISDBTModulation isdbtModulation,
 942         IN Byte DevNo)
 943 {
 944         Dword dwError = ERR_NO_ERROR;
 945     int result;
 946     TXSetISDBTChannelModulationRequest request;
 947         ISDBTModulation* isdbtModulationUser = (ISDBTModulation*) malloc(sizeof(ISDBTModulation));
 948
 949         if(g_hDriver[DevNo][1] == EAGLEI) {             /* Only suppurted in EAGLEII*/
 950         dwError = ERR_NOT_IMPLEMENTED;
 951                 return (dwError);
 952         }
 953
 954         memcpy(isdbtModulationUser, &isdbtModulation, sizeof(ISDBTModulation));
 955         if (g_hDriver[DevNo][0] > 0) {
 956                 request.isdbtModulationAddr = (__u32) isdbtModulationUser;
 957                 result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_SETISDBTCHANNELMODULATION, (void *)&request);
 958         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 959         }
 960         else {
 961         dwError = ERR_NOT_IMPLEMENTED;
 962         }
 963         free(isdbtModulationUser);
 964     return (dwError);
 965 }
 966
 967 /* Only for EAGLEII */
 968 Dword g_ITEAPI_TxSetTMCCInfo(
 969     IN  TMCCINFO      TmccInfo,
 970         IN Byte DevNo)
 971 {
 972         Dword dwError = ERR_NO_ERROR;
 973     int result;
 974     TXSetTMCCInfoRequest request;
 975
 976         if(g_hDriver[DevNo][1] == EAGLEI) {             /* Only suppurted in EAGLEII*/
 977         dwError = ERR_NOT_IMPLEMENTED;
 978                 return (dwError);
 979         }
 980
 981         if (g_hDriver[DevNo][0] > 0) {
 982                 request.TmccInfo = TmccInfo;
 983                 request.actualInfo = True;
 984                 result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_SETTMCCINFO, (void *)&request);
 985         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
 986         }
 987         else {
 988         dwError = ERR_NOT_IMPLEMENTED;
 989         }
 990     return (dwError);
 991 }
 992
 993 /* Only for EAGLEII */
 994 Dword g_ITEAPI_TxGetTMCCInfo(
 995     OUT  pTMCCINFO     pTmccInfo,
 996         IN Byte DevNo)
 997 {
 998         Dword dwError = ERR_NO_ERROR;
 999     int result;
1000     TXGetTMCCInfoRequest request;
1001
1002         if(g_hDriver[DevNo][1] == EAGLEI) {             /* Only suppurted in EAGLEII*/
1003         dwError = ERR_NOT_IMPLEMENTED;
1004                 return (dwError);
1005         }
1006
1007         if (g_hDriver[DevNo][0] > 0) {
1008                 result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_GETTMCCINFO, (void *)&request);
1009                 *pTmccInfo = request.TmccInfo;
1010         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
1011         }
1012         else {
1013         dwError = ERR_NOT_IMPLEMENTED;
1014         }
1015     return (dwError);
1016 }
1017
1018 /* Only for EAGLEII */
1019 Dword g_ITEAPI_TxGetTSinputBitRate(
1020     OUT  Word*     BitRate_Kbps,
1021         IN Byte DevNo)
1022 {
1023         Dword dwError = ERR_NO_ERROR;
1024     int result;
1025     TXGetTSinputBitRateRequest request;
1026
1027         if(g_hDriver[DevNo][1] == EAGLEI) {             /* Only suppurted in EAGLEII*/
1028         dwError = ERR_NOT_IMPLEMENTED;
1029                 return (dwError);
1030         }
1031
1032         if (g_hDriver[DevNo][0] > 0) {
1033                 result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_GETTSINPUTBITRATE, (void *)&request);
1034                 *BitRate_Kbps = request.BitRate_Kbps;
1035         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
1036         }
1037         else {
1038         dwError = ERR_NOT_IMPLEMENTED;
1039         }
1040     return (dwError);
1041 }
1042
1043 /* Only for EAGLEII */
1044 Dword g_ITEAPI_TxAddPidToISDBTPidFilter(
1045     IN  Byte            index,
1046     IN  Pid             pid,
1047         IN      TransportLayer  layer,
1048         IN Byte DevNo)
1049 {
1050         Dword dwError = ERR_NO_ERROR;
1051     int result;
1052     TXAddPidToISDBTPidFilterRequest request;
1053
1054         if(g_hDriver[DevNo][1] == EAGLEI) {             /* Only suppurted in EAGLEII*/
1055         dwError = ERR_NOT_IMPLEMENTED;
1056                 return (dwError);
1057         }
1058
1059         if (g_hDriver[DevNo][0] > 0) {
1060                 request.index = index;
1061                 request.pid = pid;
1062                 request.layer = layer;
1063                 result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_ADDPIDTOISDBTPIDFILTER, (void *)&request);
1064         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
1065         }
1066         else {
1067         dwError = ERR_NOT_IMPLEMENTED;
1068         }
1069     return (dwError);
1070 }
1071
1072 /* Only for EAGLEII */
1073 Dword g_ITEAPI_TxSetPCRMode(
1074     IN  PcrMode         mode,
1075         IN  Byte                        DevNo)
1076 {
1077         Dword dwError = ERR_NO_ERROR;
1078     int result;
1079     TxSetPcrModeRequest request;
1080
1081         if(g_hDriver[DevNo][1] == EAGLEI) {             /* Only suppurted in EAGLEII*/
1082         dwError = ERR_NOT_IMPLEMENTED;
1083                 return (dwError);
1084         }
1085
1086         if (g_hDriver[DevNo][0] > 0) {
1087                 request.mode = mode;
1088                 result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_SETPCRMODE, (void *)&request);
1089         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
1090         }
1091         else {
1092         dwError = ERR_NOT_IMPLEMENTED;
1093         }
1094     return (dwError);
1095 }
1096
1097 Dword g_ITEAPI_TxSetDCTable(
1098     IN  DCtable*                pDCtable,
1099     IN  DCtable*                pOFStable,
1100         IN      Word                    tableGroups,
1101         IN  Byte                        DevNo)
1102 {
1103         Dword dwError = ERR_NO_ERROR;
1104     int result;
1105     TxSetDCTableRequest request;
1106
1107         if (g_hDriver[DevNo][0] > 0) {
1108                 request.pDCtableAddr = (__u32) pDCtable;
1109                 request.pOFStableAddr = (__u32) pOFStable;
1110                 request.tableGroups = tableGroups;
1111                 result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_SETDCTABLE, (void *)&request);
1112         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
1113         }
1114         else {
1115         dwError = ERR_NOT_IMPLEMENTED;
1116         }
1117     return (dwError);
1118 }
1119
1120 Dword g_ITEAPI_GetFrequencyIndex(
1121         OUT Byte* frequencyindex,
1122         IN Byte DevNo)
1123 {
1124         Dword dwError = ERR_NO_ERROR;
1125     int result;
1126     TxGetFrequencyIndexRequest request;
1127
1128         if (g_hDriver[DevNo][0] > 0) {
1129                 result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_GETFREQUENCYINDEX, (void *)&request);
1130                 *frequencyindex = request.frequencyindex;
1131         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
1132         }
1133         else {
1134         dwError = ERR_NOT_IMPLEMENTED;
1135         }
1136     return (dwError);
1137 }
1138
1139 Dword g_ITEAPI_TxGetDTVMode(
1140     OUT Byte* DTVMode,
1141     IN  Byte  DevNo)
1142 {
1143     Dword dwError = ERR_NO_ERROR;
1144
1145     int result;
1146     TxGetDTVModeRequest request;
1147
1148     if (g_hDriver[DevNo][0] > 0) {
1149         result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_GETDTVMODE, (void *)&request);
1150                 *DTVMode = request.DTVMode;
1151         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
1152     }
1153     else {
1154         dwError = ERR_NOT_IMPLEMENTED;
1155     }
1156
1157     return dwError;
1158 }
1159
1160 Dword g_ITEAPI_TxEnableTPSEncryption(
1161     IN  Dword key,
1162     IN  Byte  DevNo)
1163 {
1164     Dword dwError = ERR_NO_ERROR;
1165
1166     int result;
1167     TxEnableTpsEncryptionRequest request;
1168
1169     if (g_hDriver[DevNo][0] > 0) {
1170                 request.key = (__u32) key;
1171         result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_ENABLETPSENCRYPTION, (void *)&request);
1172         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
1173     }
1174     else {
1175         dwError = ERR_NOT_IMPLEMENTED;
1176     }
1177
1178     return dwError;
1179 }
1180
1181 Dword g_ITEAPI_TxDisableTPSEncryption(
1182     IN  Byte  DevNo)
1183 {
1184     Dword dwError = ERR_NO_ERROR;
1185
1186     int result;
1187     TxDisableTpsEncryptionRequest request;
1188
1189     if (g_hDriver[DevNo][0] > 0) {
1190         result = ioctl(g_hDriver[DevNo][0], IOCTL_ITE_MOD_DISABLETPSENCRYPTION, (void *)&request);
1191         dwError = result < 0 ? ERR_NOT_IMPLEMENTED : (Dword) request.error;
1192     }
1193     else {
1194         dwError = ERR_NOT_IMPLEMENTED;
1195     }
1196
1197     return dwError;
1198 }
1199